src/lua/src/liolib.c

   1 /*
   2 ** $Id: liolib.c,v 2.112.1.1 2013/04/12 18:48:47 roberto Exp $
   3 ** Standard I/O (and system) library
   4 ** See Copyright Notice in lua.h
   5 */
   6
   7
   8 /*
   9 ** This definition must come before the inclusion of 'stdio.h'; it
  10 ** should not affect non-POSIX systems
  11 */
  12 #if !defined(_FILE_OFFSET_BITS)
  13 #define _LARGEFILE_SOURCE       1
  14 #define _FILE_OFFSET_BITS       64
  15 #endif
  16
  17
  18 #include <errno.h>
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <string.h>
  22
  23 #define liolib_c
  24 #define LUA_LIB
  25
  26 #include "lua.h"
  27
  28 #include "lauxlib.h"
  29 #include "lualib.h"
  30
  31
  32 #if !defined(lua_checkmode)
  33
  34 /*
  35 ** Check whether 'mode' matches '[rwa]%+?b?'.
  36 ** Change this macro to accept other modes for 'fopen' besides
  37 ** the standard ones.
  38 */
  39 #define lua_checkmode(mode) \
  40         (*mode != '\0' && strchr("rwa", *(mode++)) != NULL &&   \
  41         (*mode != '+' || ++mode) &&  /* skip if char is '+' */  \
  42         (*mode != 'b' || ++mode) &&  /* skip if char is 'b' */  \
  43         (*mode == '\0'))
  44
  45 #endif
  46
  47 /*
  48 ** {======================================================
  49 ** lua_popen spawns a new process connected to the current
  50 ** one through the file streams.
  51 ** =======================================================
  52 */
  53
  54 #if !defined(lua_popen) /* { */
  55
  56 #if defined(LUA_USE_POPEN)      /* { */
  57
  58 #define lua_popen(L,c,m)        ((void)L, fflush(NULL), popen(c,m))
  59 #define lua_pclose(L,file)      ((void)L, pclose(file))
  60
  61 #elif defined(LUA_WIN)          /* }{ */
  62
  63 #define lua_popen(L,c,m)                ((void)L, _popen(c,m))
  64 #define lua_pclose(L,file)              ((void)L, _pclose(file))
  65
  66
  67 #else                           /* }{ */
  68
  69 #define lua_popen(L,c,m)                ((void)((void)c, m),  \
  70                 luaL_error(L, LUA_QL("popen") " not supported"), (FILE*)0)
  71 #define lua_pclose(L,file)              ((void)((void)L, file), -1)
  72
  73
  74 #endif                          /* } */
  75
  76 #endif                  /* } */
  77
  78 /* }====================================================== */
  79
  80
  81 /*
  82 ** {======================================================
  83 ** lua_fseek: configuration for longer offsets
  84 ** =======================================================
  85 */
  86
  87 #if !defined(lua_fseek) && !defined(LUA_ANSI)   /* { */
  88
  89 #if defined(LUA_USE_POSIX)      /* { */
  90
  91 #define l_fseek(f,o,w)          fseeko(f,o,w)
  92 #define l_ftell(f)              ftello(f)
  93 #define l_seeknum               off_t
  94
  95 #elif defined(LUA_WIN) && !defined(_CRTIMP_TYPEINFO) \
  96    && defined(_MSC_VER) && (_MSC_VER >= 1400)   /* }{ */
  97 /* Windows (but not DDK) and Visual C++ 2005 or higher */
  98
  99 #define l_fseek(f,o,w)          _fseeki64(f,o,w)
 100 #define l_ftell(f)              _ftelli64(f)
 101 #define l_seeknum               __int64
 102
 103 #endif  /* } */
 104
 105 #endif                  /* } */
 106
 107
 108 #if !defined(l_fseek)           /* default definitions */
 109 #define l_fseek(f,o,w)          fseek(f,o,w)
 110 #define l_ftell(f)              ftell(f)
 111 #define l_seeknum               long
 112 #endif
 113
 114 /* }====================================================== */
 115
 116
 117 #define IO_PREFIX       "_IO_"
 118 #define IO_INPUT        (IO_PREFIX "input")
 119 #define IO_OUTPUT       (IO_PREFIX "output")
 120
 121
 122 typedef luaL_Stream LStream;
 123
 124
 125 #define tolstream(L)    ((LStream *)luaL_checkudata(L, 1, LUA_FILEHANDLE))
 126
 127 #define isclosed(p)     ((p)->closef == NULL)
 128
 129
 130 static int io_type (lua_State *L) {
 131   LStream *p;
 132   luaL_checkany(L, 1);
 133   p = (LStream *)luaL_testudata(L, 1, LUA_FILEHANDLE);
 134   if (p == NULL)
 135     lua_pushnil(L);  /* not a file */
 136   else if (isclosed(p))
 137     lua_pushliteral(L, "closed file");
 138   else
 139     lua_pushliteral(L, "file");
 140   return 1;
 141 }
 142
 143
 144 static int f_tostring (lua_State *L) {
 145   LStream *p = tolstream(L);
 146   if (isclosed(p))
 147     lua_pushliteral(L, "file (closed)");
 148   else
 149     lua_pushfstring(L, "file (%p)", p->f);
 150   return 1;
 151 }
 152
 153
 154 static FILE *tofile (lua_State *L) {
 155   LStream *p = tolstream(L);
 156   if (isclosed(p))
 157     luaL_error(L, "attempt to use a closed file");
 158   lua_assert(p->f);
 159   return p->f;
 160 }
 161
 162
 163 /*
 164 ** When creating file handles, always creates a `closed' file handle
 165 ** before opening the actual file; so, if there is a memory error, the
 166 ** file is not left opened.
 167 */
 168 static LStream *newprefile (lua_State *L) {
 169   LStream *p = (LStream *)lua_newuserdata(L, sizeof(LStream));
 170   p->closef = NULL;  /* mark file handle as 'closed' */
 171   luaL_setmetatable(L, LUA_FILEHANDLE);
 172   return p;
 173 }
 174
 175
 176 static int aux_close (lua_State *L) {
 177   LStream *p = tolstream(L);
 178   lua_CFunction cf = p->closef;
 179   p->closef = NULL;  /* mark stream as closed */
 180   return (*cf)(L);  /* close it */
 181 }
 182
 183
 184 static int io_close (lua_State *L) {
 185   if (lua_isnone(L, 1))  /* no argument? */
 186     lua_getfield(L, LUA_REGISTRYINDEX, IO_OUTPUT);  /* use standard output */
 187   tofile(L);  /* make sure argument is an open stream */
 188   return aux_close(L);
 189 }
 190
 191
 192 static int f_gc (lua_State *L) {
 193   LStream *p = tolstream(L);
 194   if (!isclosed(p) && p->f != NULL)
 195     aux_close(L);  /* ignore closed and incompletely open files */
 196   return 0;
 197 }
 198
 199
 200 /*
 201 ** function to close regular files
 202 */
 203 static int io_fclose (lua_State *L) {
 204   LStream *p = tolstream(L);
 205   int res = fclose(p->f);
 206   return luaL_fileresult(L, (res == 0), NULL);
 207 }
 208
 209
 210 static LStream *newfile (lua_State *L) {
 211   LStream *p = newprefile(L);
 212   p->f = NULL;
 213   p->closef = &io_fclose;
 214   return p;
 215 }
 216
 217
 218 static void opencheck (lua_State *L, const char *fname, const char *mode) {
 219   LStream *p = newfile(L);
 220   p->f = fopen(fname, mode);
 221   if (p->f == NULL)
 222     luaL_error(L, "cannot open file " LUA_QS " (%s)", fname, strerror(errno));
 223 }
 224
 225
 226 static int io_open (lua_State *L) {
 227   const char *filename = luaL_checkstring(L, 1);
 228   const char *mode = luaL_optstring(L, 2, "r");
 229   LStream *p = newfile(L);
 230   const char *md = mode;  /* to traverse/check mode */
 231   luaL_argcheck(L, lua_checkmode(md), 2, "invalid mode");
 232   p->f = fopen(filename, mode);
 233   return (p->f == NULL) ? luaL_fileresult(L, 0, filename) : 1;
 234 }
 235
 236
 237 /*
 238 ** function to close 'popen' files
 239 */
 240 static int io_pclose (lua_State *L) {
 241   LStream *p = tolstream(L);
 242   return luaL_execresult(L, lua_pclose(L, p->f));
 243 }
 244
 245
 246 static int io_popen (lua_State *L) {
 247   const char *filename = luaL_checkstring(L, 1);
 248   const char *mode = luaL_optstring(L, 2, "r");
 249   LStream *p = newprefile(L);
 250   p->f = lua_popen(L, filename, mode);
 251   p->closef = &io_pclose;
 252   return (p->f == NULL) ? luaL_fileresult(L, 0, filename) : 1;
 253 }
 254
 255
 256 static int io_tmpfile (lua_State *L) {
 257   LStream *p = newfile(L);
 258   p->f = tmpfile();
 259   return (p->f == NULL) ? luaL_fileresult(L, 0, NULL) : 1;
 260 }
 261
 262
 263 static FILE *getiofile (lua_State *L, const char *findex) {
 264   LStream *p;
 265   lua_getfield(L, LUA_REGISTRYINDEX, findex);
 266   p = (LStream *)lua_touserdata(L, -1);
 267   if (isclosed(p))
 268     luaL_error(L, "standard %s file is closed", findex + strlen(IO_PREFIX));
 269   return p->f;
 270 }
 271
 272
 273 static int g_iofile (lua_State *L, const char *f, const char *mode) {
 274   if (!lua_isnoneornil(L, 1)) {
 275     const char *filename = lua_tostring(L, 1);
 276     if (filename)
 277       opencheck(L, filename, mode);
 278     else {
 279       tofile(L);  /* check that it's a valid file handle */
 280       lua_pushvalue(L, 1);
 281     }
 282     lua_setfield(L, LUA_REGISTRYINDEX, f);
 283   }
 284   /* return current value */
 285   lua_getfield(L, LUA_REGISTRYINDEX, f);
 286   return 1;
 287 }
 288
 289
 290 static int io_input (lua_State *L) {
 291   return g_iofile(L, IO_INPUT, "r");
 292 }
 293
 294
 295 static int io_output (lua_State *L) {
 296   return g_iofile(L, IO_OUTPUT, "w");
 297 }
 298
 299
 300 static int io_readline (lua_State *L);
 301
 302
 303 static void aux_lines (lua_State *L, int toclose) {
 304   int i;
 305   int n = lua_gettop(L) - 1;  /* number of arguments to read */
 306   /* ensure that arguments will fit here and into 'io_readline' stack */
 307   luaL_argcheck(L, n <= LUA_MINSTACK - 3, LUA_MINSTACK - 3, "too many options");
 308   lua_pushvalue(L, 1);  /* file handle */
 309   lua_pushinteger(L, n);  /* number of arguments to read */
 310   lua_pushboolean(L, toclose);  /* close/not close file when finished */
 311   for (i = 1; i <= n; i++) lua_pushvalue(L, i + 1);  /* copy arguments */
 312   lua_pushcclosure(L, io_readline, 3 + n);
 313 }
 314
 315
 316 static int f_lines (lua_State *L) {
 317   tofile(L);  /* check that it's a valid file handle */
 318   aux_lines(L, 0);
 319   return 1;
 320 }
 321
 322
 323 static int io_lines (lua_State *L) {
 324   int toclose;
 325   if (lua_isnone(L, 1)) lua_pushnil(L);  /* at least one argument */
 326   if (lua_isnil(L, 1)) {  /* no file name? */
 327     lua_getfield(L, LUA_REGISTRYINDEX, IO_INPUT);  /* get default input */
 328     lua_replace(L, 1);  /* put it at index 1 */
 329     tofile(L);  /* check that it's a valid file handle */
 330     toclose = 0;  /* do not close it after iteration */
 331   }
 332   else {  /* open a new file */
 333     const char *filename = luaL_checkstring(L, 1);
 334     opencheck(L, filename, "r");
 335     lua_replace(L, 1);  /* put file at index 1 */
 336     toclose = 1;  /* close it after iteration */
 337   }
 338   aux_lines(L, toclose);
 339   return 1;
 340 }
 341
 342
 343 /*
 344 ** {======================================================
 345 ** READ
 346 ** =======================================================
 347 */
 348
 349
 350 static int read_number (lua_State *L, FILE *f) {
 351   lua_Number d;
 352   if (fscanf(f, LUA_NUMBER_SCAN, &d) == 1) {
 353     lua_pushnumber(L, d);
 354     return 1;
 355   }
 356   else {
 357    lua_pushnil(L);  /* "result" to be removed */
 358    return 0;  /* read fails */
 359   }
 360 }
 361
 362
 363 static int test_eof (lua_State *L, FILE *f) {
 364   int c = getc(f);
 365   ungetc(c, f);
 366   lua_pushlstring(L, NULL, 0);
 367   return (c != EOF);
 368 }
 369
 370
 371 static int read_line (lua_State *L, FILE *f, int chop) {
 372   luaL_Buffer b;
 373   luaL_buffinit(L, &b);
 374   for (;;) {
 375     size_t l;
 376     char *p = luaL_prepbuffer(&b);
 377     if (fgets(p, LUAL_BUFFERSIZE, f) == NULL) {  /* eof? */
 378       luaL_pushresult(&b);  /* close buffer */
 379       return (lua_rawlen(L, -1) > 0);  /* check whether read something */
 380     }
 381     l = strlen(p);
 382     if (l == 0 || p[l-1] != '\n')
 383       luaL_addsize(&b, l);
 384     else {
 385       luaL_addsize(&b, l - chop);  /* chop 'eol' if needed */
 386       luaL_pushresult(&b);  /* close buffer */
 387       return 1;  /* read at least an `eol' */
 388     }
 389   }
 390 }
 391
 392
 393 #define MAX_SIZE_T      (~(size_t)0)
 394
 395 static void read_all (lua_State *L, FILE *f) {
 396   size_t rlen = LUAL_BUFFERSIZE;  /* how much to read in each cycle */
 397   luaL_Buffer b;
 398   luaL_buffinit(L, &b);
 399   for (;;) {
 400     char *p = luaL_prepbuffsize(&b, rlen);
 401     size_t nr = fread(p, sizeof(char), rlen, f);
 402     luaL_addsize(&b, nr);
 403     if (nr < rlen) break;  /* eof? */
 404     else if (rlen <= (MAX_SIZE_T / 4))  /* avoid buffers too large */
 405       rlen *= 2;  /* double buffer size at each iteration */
 406   }
 407   luaL_pushresult(&b);  /* close buffer */
 408 }
 409
 410
 411 static int read_chars (lua_State *L, FILE *f, size_t n) {
 412   size_t nr;  /* number of chars actually read */
 413   char *p;
 414   luaL_Buffer b;
 415   luaL_buffinit(L, &b);
 416   p = luaL_prepbuffsize(&b, n);  /* prepare buffer to read whole block */
 417   nr = fread(p, sizeof(char), n, f);  /* try to read 'n' chars */
 418   luaL_addsize(&b, nr);
 419   luaL_pushresult(&b);  /* close buffer */
 420   return (nr > 0);  /* true iff read something */
 421 }
 422
 423
 424 static int g_read (lua_State *L, FILE *f, int first) {
 425   int nargs = lua_gettop(L) - 1;
 426   int success;
 427   int n;
 428   clearerr(f);
 429   if (nargs == 0) {  /* no arguments? */
 430     success = read_line(L, f, 1);
 431     n = first+1;  /* to return 1 result */
 432   }
 433   else {  /* ensure stack space for all results and for auxlib's buffer */
 434     luaL_checkstack(L, nargs+LUA_MINSTACK, "too many arguments");
 435     success = 1;
 436     for (n = first; nargs-- && success; n++) {
 437       if (lua_type(L, n) == LUA_TNUMBER) {
 438         size_t l = (size_t)lua_tointeger(L, n);
 439         success = (l == 0) ? test_eof(L, f) : read_chars(L, f, l);
 440       }
 441       else {
 442         const char *p = lua_tostring(L, n);
 443         luaL_argcheck(L, p && p[0] == '*', n, "invalid option");
 444         switch (p[1]) {
 445           case 'n':  /* number */
 446             success = read_number(L, f);
 447             break;
 448           case 'l':  /* line */
 449             success = read_line(L, f, 1);
 450             break;
 451           case 'L':  /* line with end-of-line */
 452             success = read_line(L, f, 0);
 453             break;
 454           case 'a':  /* file */
 455             read_all(L, f);  /* read entire file */
 456             success = 1; /* always success */
 457             break;
 458           default:
 459             return luaL_argerror(L, n, "invalid format");
 460         }
 461       }
 462     }
 463   }
 464   if (ferror(f))
 465     return luaL_fileresult(L, 0, NULL);
 466   if (!success) {
 467     lua_pop(L, 1);  /* remove last result */
 468     lua_pushnil(L);  /* push nil instead */
 469   }
 470   return n - first;
 471 }
 472
 473
 474 static int io_read (lua_State *L) {
 475   return g_read(L, getiofile(L, IO_INPUT), 1);
 476 }
 477
 478
 479 static int f_read (lua_State *L) {
 480   return g_read(L, tofile(L), 2);
 481 }
 482
 483
 484 static int io_readline (lua_State *L) {
 485   LStream *p = (LStream *)lua_touserdata(L, lua_upvalueindex(1));
 486   int i;
 487   int n = (int)lua_tointeger(L, lua_upvalueindex(2));
 488   if (isclosed(p))  /* file is already closed? */
 489     return luaL_error(L, "file is already closed");
 490   lua_settop(L , 1);
 491   for (i = 1; i <= n; i++)  /* push arguments to 'g_read' */
 492     lua_pushvalue(L, lua_upvalueindex(3 + i));
 493   n = g_read(L, p->f, 2);  /* 'n' is number of results */
 494   lua_assert(n > 0);  /* should return at least a nil */
 495   if (!lua_isnil(L, -n))  /* read at least one value? */
 496     return n;  /* return them */
 497   else {  /* first result is nil: EOF or error */
 498     if (n > 1) {  /* is there error information? */
 499       /* 2nd result is error message */
 500       return luaL_error(L, "%s", lua_tostring(L, -n + 1));
 501     }
 502     if (lua_toboolean(L, lua_upvalueindex(3))) {  /* generator created file? */
 503       lua_settop(L, 0);
 504       lua_pushvalue(L, lua_upvalueindex(1));
 505       aux_close(L);  /* close it */
 506     }
 507     return 0;
 508   }
 509 }
 510
 511 /* }====================================================== */
 512
 513
 514 static int g_write (lua_State *L, FILE *f, int arg) {
 515   int nargs = lua_gettop(L) - arg;
 516   int status = 1;
 517   for (; nargs--; arg++) {
 518     if (lua_type(L, arg) == LUA_TNUMBER) {
 519       /* optimization: could be done exactly as for strings */
 520       status = status &&
 521           fprintf(f, LUA_NUMBER_FMT, lua_tonumber(L, arg)) > 0;
 522     }
 523     else {
 524       size_t l;
 525       const char *s = luaL_checklstring(L, arg, &l);
 526       status = status && (fwrite(s, sizeof(char), l, f) == l);
 527     }
 528   }
 529   if (status) return 1;  /* file handle already on stack top */
 530   else return luaL_fileresult(L, status, NULL);
 531 }
 532
 533
 534 static int io_write (lua_State *L) {
 535   return g_write(L, getiofile(L, IO_OUTPUT), 1);
 536 }
 537
 538
 539 static int f_write (lua_State *L) {
 540   FILE *f = tofile(L);
 541   lua_pushvalue(L, 1);  /* push file at the stack top (to be returned) */
 542   return g_write(L, f, 2);
 543 }
 544
 545
 546 static int f_seek (lua_State *L) {
 547   static const int mode[] = {SEEK_SET, SEEK_CUR, SEEK_END};
 548   static const char *const modenames[] = {"set", "cur", "end", NULL};
 549   FILE *f = tofile(L);
 550   int op = luaL_checkoption(L, 2, "cur", modenames);
 551   lua_Number p3 = luaL_optnumber(L, 3, 0);
 552   l_seeknum offset = (l_seeknum)p3;
 553   luaL_argcheck(L, (lua_Number)offset == p3, 3,
 554                   "not an integer in proper range");
 555   op = l_fseek(f, offset, mode[op]);
 556   if (op)
 557     return luaL_fileresult(L, 0, NULL);  /* error */
 558   else {
 559     lua_pushnumber(L, (lua_Number)l_ftell(f));
 560     return 1;
 561   }
 562 }
 563
 564
 565 static int f_setvbuf (lua_State *L) {
 566   static const int mode[] = {_IONBF, _IOFBF, _IOLBF};
 567   static const char *const modenames[] = {"no", "full", "line", NULL};
 568   FILE *f = tofile(L);
 569   int op = luaL_checkoption(L, 2, NULL, modenames);
 570   lua_Integer sz = luaL_optinteger(L, 3, LUAL_BUFFERSIZE);
 571   int res = setvbuf(f, NULL, mode[op], sz);
 572   return luaL_fileresult(L, res == 0, NULL);
 573 }
 574
 575
 576
 577 static int io_flush (lua_State *L) {
 578   return luaL_fileresult(L, fflush(getiofile(L, IO_OUTPUT)) == 0, NULL);
 579 }
 580
 581
 582 static int f_flush (lua_State *L) {
 583   return luaL_fileresult(L, fflush(tofile(L)) == 0, NULL);
 584 }
 585
 586
 587 /*
 588 ** functions for 'io' library
 589 */
 590 static const luaL_Reg iolib[] = {
 591   {"close", io_close},
 592   {"flush", io_flush},
 593   {"input", io_input},
 594   {"lines", io_lines},
 595   {"open", io_open},
 596   {"output", io_output},
 597   {"popen", io_popen},
 598   {"read", io_read},
 599   {"tmpfile", io_tmpfile},
 600   {"type", io_type},
 601   {"write", io_write},
 602   {NULL, NULL}
 603 };
 604
 605
 606 /*
 607 ** methods for file handles
 608 */
 609 static const luaL_Reg flib[] = {
 610   {"close", io_close},
 611   {"flush", f_flush},
 612   {"lines", f_lines},
 613   {"read", f_read},
 614   {"seek", f_seek},
 615   {"setvbuf", f_setvbuf},
 616   {"write", f_write},
 617   {"__gc", f_gc},
 618   {"__tostring", f_tostring},
 619   {NULL, NULL}
 620 };
 621
 622
 623 static void createmeta (lua_State *L) {
 624   luaL_newmetatable(L, LUA_FILEHANDLE);  /* create metatable for file handles */
 625   lua_pushvalue(L, -1);  /* push metatable */
 626   lua_setfield(L, -2, "__index");  /* metatable.__index = metatable */
 627   luaL_setfuncs(L, flib, 0);  /* add file methods to new metatable */
 628   lua_pop(L, 1);  /* pop new metatable */
 629 }
 630
 631
 632 /*
 633 ** function to (not) close the standard files stdin, stdout, and stderr
 634 */
 635 static int io_noclose (lua_State *L) {
 636   LStream *p = tolstream(L);
 637   p->closef = &io_noclose;  /* keep file opened */
 638   lua_pushnil(L);
 639   lua_pushliteral(L, "cannot close standard file");
 640   return 2;
 641 }
 642
 643
 644 static void createstdfile (lua_State *L, FILE *f, const char *k,
 645                            const char *fname) {
 646   LStream *p = newprefile(L);
 647   p->f = f;
 648   p->closef = &io_noclose;
 649   if (k != NULL) {
 650     lua_pushvalue(L, -1);
 651     lua_setfield(L, LUA_REGISTRYINDEX, k);  /* add file to registry */
 652   }
 653   lua_setfield(L, -2, fname);  /* add file to module */
 654 }
 655
 656
 657 LUAMOD_API int luaopen_io (lua_State *L) {
 658   luaL_newlib(L, iolib);  /* new module */
 659   createmeta(L);
 660   /* create (and set) default files */
 661   createstdfile(L, stdin, IO_INPUT, "stdin");
 662   createstdfile(L, stdout, IO_OUTPUT, "stdout");
 663   createstdfile(L, stderr, NULL, "stderr");
 664   return 1;
 665 }
 666