LCOV - code coverage report
Current view: directory - src - liolib.c Found Hit Coverage
Test: Lua 5.1.4 Lines: 276 256 92.8 %
Date: 2009-09-13
Colors: not hit hit

       1                 : /*
       2                 : ** $Id: liolib.c,v 2.73.1.3 2008/01/18 17:47:43 roberto Exp $
       3                 : ** Standard I/O (and system) library
       4                 : ** See Copyright Notice in lua.h
       5                 : */
       6                 : 
       7                 : 
       8                 : #include <errno.h>
       9                 : #include <stdio.h>
      10                 : #include <stdlib.h>
      11                 : #include <string.h>
      12                 : 
      13                 : #define liolib_c
      14                 : #define LUA_LIB
      15                 : 
      16                 : #include "lua.h"
      17                 : 
      18                 : #include "lauxlib.h"
      19                 : #include "lualib.h"
      20                 : 
      21                 : 
      22                 : 
      23                 : #define IO_INPUT        1
      24                 : #define IO_OUTPUT       2
      25                 : 
      26                 : 
      27                 : static const char *const fnames[] = {"input", "output"};
      28                 : 
      29                 : 
      30              58 : static int pushresult (lua_State *L, int i, const char *filename) {
      31              58 :   int en = errno;  /* calls to Lua API may change this value */
      32              58 :   if (i) {
      33              57 :     lua_pushboolean(L, 1);
      34              57 :     return 1;
      35                 :   }
      36                 :   else {
      37               1 :     lua_pushnil(L);
      38               1 :     if (filename)
      39               1 :       lua_pushfstring(L, "%s: %s", filename, strerror(en));
      40                 :     else
      41               0 :       lua_pushfstring(L, "%s", strerror(en));
      42               1 :     lua_pushinteger(L, en);
      43               1 :     return 3;
      44                 :   }
      45                 : }
      46                 : 
      47                 : 
      48               0 : static void fileerror (lua_State *L, int arg, const char *filename) {
      49               0 :   lua_pushfstring(L, "%s: %s", filename, strerror(errno));
      50               0 :   luaL_argerror(L, arg, lua_tostring(L, -1));
      51               0 : }
      52                 : 
      53                 : 
      54                 : #define tofilep(L)      ((FILE **)luaL_checkudata(L, 1, LUA_FILEHANDLE))
      55                 : 
      56                 : 
      57               8 : static int io_type (lua_State *L) {
      58                 :   void *ud;
      59               8 :   luaL_checkany(L, 1);
      60               8 :   ud = lua_touserdata(L, 1);
      61               8 :   lua_getfield(L, LUA_REGISTRYINDEX, LUA_FILEHANDLE);
      62               9 :   if (ud == NULL || !lua_getmetatable(L, 1) || !lua_rawequal(L, -2, -1))
      63               1 :     lua_pushnil(L);  /* not a file */
      64               7 :   else if (*((FILE **)ud) == NULL)
      65               2 :     lua_pushliteral(L, "closed file");
      66                 :   else
      67               5 :     lua_pushliteral(L, "file");
      68               8 :   return 1;
      69                 : }
      70                 : 
      71                 : 
      72              73 : static FILE *tofile (lua_State *L) {
      73              73 :   FILE **f = tofilep(L);
      74              73 :   if (*f == NULL)
      75               5 :     luaL_error(L, "attempt to use a closed file");
      76              68 :   return *f;
      77                 : }
      78                 : 
      79                 : 
      80                 : 
      81                 : /*
      82                 : ** When creating file handles, always creates a `closed' file handle
      83                 : ** before opening the actual file; so, if there is a memory error, the
      84                 : ** file is not left opened.
      85                 : */
      86             141 : static FILE **newfile (lua_State *L) {
      87             141 :   FILE **pf = (FILE **)lua_newuserdata(L, sizeof(FILE *));
      88             141 :   *pf = NULL;  /* file handle is currently `closed' */
      89             141 :   luaL_getmetatable(L, LUA_FILEHANDLE);
      90             141 :   lua_setmetatable(L, -2);
      91             141 :   return pf;
      92                 : }
      93                 : 
      94                 : 
      95                 : /*
      96                 : ** function to (not) close the standard files stdin, stdout, and stderr
      97                 : */
      98             107 : static int io_noclose (lua_State *L) {
      99             107 :   lua_pushnil(L);
     100             107 :   lua_pushliteral(L, "cannot close standard file");
     101             107 :   return 2;
     102                 : }
     103                 : 
     104                 : 
     105                 : /*
     106                 : ** function to close 'popen' files
     107                 : */
     108               2 : static int io_pclose (lua_State *L) {
     109               2 :   FILE **p = tofilep(L);
     110               2 :   int ok = lua_pclose(L, *p);
     111               2 :   *p = NULL;
     112               2 :   return pushresult(L, ok, NULL);
     113                 : }
     114                 : 
     115                 : 
     116                 : /*
     117                 : ** function to close regular files
     118                 : */
     119              33 : static int io_fclose (lua_State *L) {
     120              33 :   FILE **p = tofilep(L);
     121              33 :   int ok = (fclose(*p) == 0);
     122              33 :   *p = NULL;
     123              33 :   return pushresult(L, ok, NULL);
     124                 : }
     125                 : 
     126                 : 
     127             142 : static int aux_close (lua_State *L) {
     128             142 :   lua_getfenv(L, 1);
     129             142 :   lua_getfield(L, -1, "__close");
     130             142 :   return (lua_tocfunction(L, -1))(L);
     131                 : }
     132                 : 
     133                 : 
     134              34 : static int io_close (lua_State *L) {
     135              34 :   if (lua_isnone(L, 1))
     136               0 :     lua_rawgeti(L, LUA_ENVIRONINDEX, IO_OUTPUT);
     137              34 :   tofile(L);  /* make sure argument is a file */
     138              33 :   return aux_close(L);
     139                 : }
     140                 : 
     141                 : 
     142             141 : static int io_gc (lua_State *L) {
     143             141 :   FILE *f = *tofilep(L);
     144                 :   /* ignore closed files */
     145             141 :   if (f != NULL)
     146             108 :     aux_close(L);
     147             141 :   return 0;
     148                 : }
     149                 : 
     150                 : 
     151               6 : static int io_tostring (lua_State *L) {
     152               6 :   FILE *f = *tofilep(L);
     153               6 :   if (f == NULL)
     154               0 :     lua_pushliteral(L, "file (closed)");
     155                 :   else
     156               6 :     lua_pushfstring(L, "file (%p)", f);
     157               6 :   return 1;
     158                 : }
     159                 : 
     160                 : 
     161              30 : static int io_open (lua_State *L) {
     162              30 :   const char *filename = luaL_checkstring(L, 1);
     163              30 :   const char *mode = luaL_optstring(L, 2, "r");
     164              30 :   FILE **pf = newfile(L);
     165              30 :   *pf = fopen(filename, mode);
     166              30 :   return (*pf == NULL) ? pushresult(L, 0, filename) : 1;
     167                 : }
     168                 : 
     169                 : 
     170                 : /*
     171                 : ** this function has a separated environment, which defines the
     172                 : ** correct __close for 'popen' files
     173                 : */
     174               2 : static int io_popen (lua_State *L) {
     175               2 :   const char *filename = luaL_checkstring(L, 1);
     176               2 :   const char *mode = luaL_optstring(L, 2, "r");
     177               2 :   FILE **pf = newfile(L);
     178               2 :   *pf = lua_popen(L, filename, mode);
     179               2 :   return (*pf == NULL) ? pushresult(L, 0, filename) : 1;
     180                 : }
     181                 : 
     182                 : 
     183               1 : static int io_tmpfile (lua_State *L) {
     184               1 :   FILE **pf = newfile(L);
     185               1 :   *pf = tmpfile();
     186               1 :   return (*pf == NULL) ? pushresult(L, 0, NULL) : 1;
     187                 : }
     188                 : 
     189                 : 
     190               4 : static FILE *getiofile (lua_State *L, int findex) {
     191                 :   FILE *f;
     192               4 :   lua_rawgeti(L, LUA_ENVIRONINDEX, findex);
     193               4 :   f = *(FILE **)lua_touserdata(L, -1);
     194               4 :   if (f == NULL)
     195               0 :     luaL_error(L, "standard %s file is closed", fnames[findex - 1]);
     196               4 :   return f;
     197                 : }
     198                 : 
     199                 : 
     200               8 : static int g_iofile (lua_State *L, int f, const char *mode) {
     201               8 :   if (!lua_isnoneornil(L, 1)) {
     202               4 :     const char *filename = lua_tostring(L, 1);
     203               4 :     if (filename) {
     204               2 :       FILE **pf = newfile(L);
     205               2 :       *pf = fopen(filename, mode);
     206               2 :       if (*pf == NULL)
     207               0 :         fileerror(L, 1, filename);
     208                 :     }
     209                 :     else {
     210               2 :       tofile(L);  /* check that it's a valid file handle */
     211               2 :       lua_pushvalue(L, 1);
     212                 :     }
     213               4 :     lua_rawseti(L, LUA_ENVIRONINDEX, f);
     214                 :   }
     215                 :   /* return current value */
     216               8 :   lua_rawgeti(L, LUA_ENVIRONINDEX, f);
     217               8 :   return 1;
     218                 : }
     219                 : 
     220                 : 
     221               4 : static int io_input (lua_State *L) {
     222               4 :   return g_iofile(L, IO_INPUT, "r");
     223                 : }
     224                 : 
     225                 : 
     226               4 : static int io_output (lua_State *L) {
     227               4 :   return g_iofile(L, IO_OUTPUT, "w");
     228                 : }
     229                 : 
     230                 : 
     231                 : static int io_readline (lua_State *L);
     232                 : 
     233                 : 
     234               5 : static void aux_lines (lua_State *L, int idx, int toclose) {
     235               5 :   lua_pushvalue(L, idx);
     236               5 :   lua_pushboolean(L, toclose);  /* close/not close file when finished */
     237               5 :   lua_pushcclosure(L, io_readline, 2);
     238               5 : }
     239                 : 
     240                 : 
     241               4 : static int f_lines (lua_State *L) {
     242               4 :   tofile(L);  /* check that it's a valid file handle */
     243               4 :   aux_lines(L, 1, 0);
     244               4 :   return 1;
     245                 : }
     246                 : 
     247                 : 
     248               1 : static int io_lines (lua_State *L) {
     249               1 :   if (lua_isnoneornil(L, 1)) {  /* no arguments? */
     250                 :     /* will iterate over default input */
     251               0 :     lua_rawgeti(L, LUA_ENVIRONINDEX, IO_INPUT);
     252               0 :     return f_lines(L);
     253                 :   }
     254                 :   else {
     255               1 :     const char *filename = luaL_checkstring(L, 1);
     256               1 :     FILE **pf = newfile(L);
     257               1 :     *pf = fopen(filename, "r");
     258               1 :     if (*pf == NULL)
     259               0 :       fileerror(L, 1, filename);
     260               1 :     aux_lines(L, lua_gettop(L), 1);
     261               1 :     return 1;
     262                 :   }
     263                 : }
     264                 : 
     265                 : 
     266                 : /*
     267                 : ** {======================================================
     268                 : ** READ
     269                 : ** =======================================================
     270                 : */
     271                 : 
     272                 : 
     273               1 : static int read_number (lua_State *L, FILE *f) {
     274                 :   lua_Number d;
     275               1 :   if (fscanf(f, LUA_NUMBER_SCAN, &d) == 1) {
     276               0 :     lua_pushnumber(L, d);
     277               0 :     return 1;
     278                 :   }
     279               1 :   else return 0;  /* read fails */
     280                 : }
     281                 : 
     282                 : 
     283               1 : static int test_eof (lua_State *L, FILE *f) {
     284               1 :   int c = getc(f);
     285               1 :   ungetc(c, f);
     286               1 :   lua_pushlstring(L, NULL, 0);
     287               1 :   return (c != EOF);
     288                 : }
     289                 : 
     290                 : 
     291             162 : static int read_line (lua_State *L, FILE *f) {
     292                 :   luaL_Buffer b;
     293             162 :   luaL_buffinit(L, &b);
     294                 :   for (;;) {
     295                 :     size_t l;
     296             163 :     char *p = luaL_prepbuffer(&b);
     297             163 :     if (fgets(p, LUAL_BUFFERSIZE, f) == NULL) {  /* eof? */
     298               5 :       luaL_pushresult(&b);  /* close buffer */
     299               5 :       return (lua_objlen(L, -1) > 0);  /* check whether read something */
     300                 :     }
     301             158 :     l = strlen(p);
     302             158 :     if (l == 0 || p[l-1] != '\n')
     303               1 :       luaL_addsize(&b, l);
     304                 :     else {
     305             157 :       luaL_addsize(&b, l - 1);  /* do not include `eol' */
     306             157 :       luaL_pushresult(&b);  /* close buffer */
     307             157 :       return 1;  /* read at least an `eol' */
     308                 :     }
     309               1 :   }
     310                 : }
     311                 : 
     312                 : 
     313               4 : static int read_chars (lua_State *L, FILE *f, size_t n) {
     314                 :   size_t rlen;  /* how much to read */
     315                 :   size_t nr;  /* number of chars actually read */
     316                 :   luaL_Buffer b;
     317               4 :   luaL_buffinit(L, &b);
     318               4 :   rlen = LUAL_BUFFERSIZE;  /* try to read that much each time */
     319                 :   do {
     320               4 :     char *p = luaL_prepbuffer(&b);
     321               4 :     if (rlen > n) rlen = n;  /* cannot read more than asked */
     322               4 :     nr = fread(p, sizeof(char), rlen, f);
     323               4 :     luaL_addsize(&b, nr);
     324               4 :     n -= nr;  /* still have to read `n' chars */
     325               4 :   } while (n > 0 && nr == rlen);  /* until end of count or eof */
     326               4 :   luaL_pushresult(&b);  /* close buffer */
     327               4 :   return (n == 0 || lua_objlen(L, -1) > 0);
     328                 : }
     329                 : 
     330                 : 
     331               9 : static int g_read (lua_State *L, FILE *f, int first) {
     332               9 :   int nargs = lua_gettop(L) - 1;
     333                 :   int success;
     334                 :   int n;
     335               9 :   clearerr(f);
     336               9 :   if (nargs == 0) {  /* no arguments? */
     337               3 :     success = read_line(L, f);
     338               3 :     n = first+1;  /* to return 1 result */
     339                 :   }
     340                 :   else {  /* ensure stack space for all results and for auxlib's buffer */
     341               6 :     luaL_checkstack(L, nargs+LUA_MINSTACK, "too many arguments");
     342               6 :     success = 1;
     343              14 :     for (n = first; nargs-- && success; n++) {
     344               9 :       if (lua_type(L, n) == LUA_TNUMBER) {
     345               4 :         size_t l = (size_t)lua_tointeger(L, n);
     346               4 :         success = (l == 0) ? test_eof(L, f) : read_chars(L, f, l);
     347                 :       }
     348                 :       else {
     349               5 :         const char *p = lua_tostring(L, n);
     350               5 :         luaL_argcheck(L, p && p[0] == '*', n, "invalid option");
     351               5 :         switch (p[1]) {
     352                 :           case 'n':  /* number */
     353               1 :             success = read_number(L, f);
     354               1 :             break;
     355                 :           case 'l':  /* line */
     356               2 :             success = read_line(L, f);
     357               2 :             break;
     358                 :           case 'a':  /* file */
     359               1 :             read_chars(L, f, ~((size_t)0));  /* read MAX_SIZE_T chars */
     360               1 :             success = 1; /* always success */
     361               1 :             break;
     362                 :           default:
     363               1 :             return luaL_argerror(L, n, "invalid format");
     364                 :         }
     365                 :       }
     366                 :     }
     367                 :   }
     368               8 :   if (ferror(f))
     369               0 :     return pushresult(L, 0, NULL);
     370               8 :   if (!success) {
     371               3 :     lua_pop(L, 1);  /* remove last result */
     372               3 :     lua_pushnil(L);  /* push nil instead */
     373                 :   }
     374               8 :   return n - first;
     375                 : }
     376                 : 
     377                 : 
     378               0 : static int io_read (lua_State *L) {
     379               0 :   return g_read(L, getiofile(L, IO_INPUT), 1);
     380                 : }
     381                 : 
     382                 : 
     383              10 : static int f_read (lua_State *L) {
     384              10 :   return g_read(L, tofile(L), 2);
     385                 : }
     386                 : 
     387                 : 
     388             157 : static int io_readline (lua_State *L) {
     389             157 :   FILE *f = *(FILE **)lua_touserdata(L, lua_upvalueindex(1));
     390                 :   int sucess;
     391             157 :   if (f == NULL)  /* file is already closed? */
     392               0 :     luaL_error(L, "file is already closed");
     393             157 :   sucess = read_line(L, f);
     394             157 :   if (ferror(f))
     395               0 :     return luaL_error(L, "%s", strerror(errno));
     396             157 :   if (sucess) return 1;
     397                 :   else {  /* EOF */
     398               2 :     if (lua_toboolean(L, lua_upvalueindex(2))) {  /* generator created file? */
     399               1 :       lua_settop(L, 0);
     400               1 :       lua_pushvalue(L, lua_upvalueindex(1));
     401               1 :       aux_close(L);  /* close it */
     402                 :     }
     403               2 :     return 0;
     404                 :   }
     405                 : }
     406                 : 
     407                 : /* }====================================================== */
     408                 : 
     409                 : 
     410              16 : static int g_write (lua_State *L, FILE *f, int arg) {
     411              16 :   int nargs = lua_gettop(L) - 1;
     412              16 :   int status = 1;
     413              33 :   for (; nargs--; arg++) {
     414              17 :     if (lua_type(L, arg) == LUA_TNUMBER) {
     415                 :       /* optimization: could be done exactly as for strings */
     416               1 :       status = status &&
     417                 :           fprintf(f, LUA_NUMBER_FMT, lua_tonumber(L, arg)) > 0;
     418                 :     }
     419                 :     else {
     420                 :       size_t l;
     421              16 :       const char *s = luaL_checklstring(L, arg, &l);
     422              16 :       status = status && (fwrite(s, sizeof(char), l, f) == l);
     423                 :     }
     424                 :   }
     425              16 :   return pushresult(L, status, NULL);
     426                 : }
     427                 : 
     428                 : 
     429               2 : static int io_write (lua_State *L) {
     430               2 :   return g_write(L, getiofile(L, IO_OUTPUT), 1);
     431                 : }
     432                 : 
     433                 : 
     434              15 : static int f_write (lua_State *L) {
     435              15 :   return g_write(L, tofile(L), 2);
     436                 : }
     437                 : 
     438                 : 
     439               3 : static int f_seek (lua_State *L) {
     440                 :   static const int mode[] = {SEEK_SET, SEEK_CUR, SEEK_END};
     441                 :   static const char *const modenames[] = {"set", "cur", "end", NULL};
     442               3 :   FILE *f = tofile(L);
     443               2 :   int op = luaL_checkoption(L, 2, "cur", modenames);
     444               1 :   long offset = luaL_optlong(L, 3, 0);
     445               1 :   op = fseek(f, offset, mode[op]);
     446               1 :   if (op)
     447               0 :     return pushresult(L, 0, NULL);  /* error */
     448                 :   else {
     449               1 :     lua_pushinteger(L, ftell(f));
     450               1 :     return 1;
     451                 :   }
     452                 : }
     453                 : 
     454                 : 
     455               3 : static int f_setvbuf (lua_State *L) {
     456                 :   static const int mode[] = {_IONBF, _IOFBF, _IOLBF};
     457                 :   static const char *const modenames[] = {"no", "full", "line", NULL};
     458               3 :   FILE *f = tofile(L);
     459               3 :   int op = luaL_checkoption(L, 2, NULL, modenames);
     460               3 :   lua_Integer sz = luaL_optinteger(L, 3, LUAL_BUFFERSIZE);
     461               3 :   int res = setvbuf(f, NULL, mode[op], sz);
     462               3 :   return pushresult(L, res == 0, NULL);
     463                 : }
     464                 : 
     465                 : 
     466                 : 
     467               2 : static int io_flush (lua_State *L) {
     468               2 :   return pushresult(L, fflush(getiofile(L, IO_OUTPUT)) == 0, NULL);
     469                 : }
     470                 : 
     471                 : 
     472               2 : static int f_flush (lua_State *L) {
     473               2 :   return pushresult(L, fflush(tofile(L)) == 0, NULL);
     474                 : }
     475                 : 
     476                 : 
     477                 : static const luaL_Reg iolib[] = {
     478                 :   {"close", io_close},
     479                 :   {"flush", io_flush},
     480                 :   {"input", io_input},
     481                 :   {"lines", io_lines},
     482                 :   {"open", io_open},
     483                 :   {"output", io_output},
     484                 :   {"popen", io_popen},
     485                 :   {"read", io_read},
     486                 :   {"tmpfile", io_tmpfile},
     487                 :   {"type", io_type},
     488                 :   {"write", io_write},
     489                 :   {NULL, NULL}
     490                 : };
     491                 : 
     492                 : 
     493                 : static const luaL_Reg flib[] = {
     494                 :   {"close", io_close},
     495                 :   {"flush", f_flush},
     496                 :   {"lines", f_lines},
     497                 :   {"read", f_read},
     498                 :   {"seek", f_seek},
     499                 :   {"setvbuf", f_setvbuf},
     500                 :   {"write", f_write},
     501                 :   {"__gc", io_gc},
     502                 :   {"__tostring", io_tostring},
     503                 :   {NULL, NULL}
     504                 : };
     505                 : 
     506                 : 
     507              35 : static void createmeta (lua_State *L) {
     508              35 :   luaL_newmetatable(L, LUA_FILEHANDLE);  /* create metatable for file handles */
     509              35 :   lua_pushvalue(L, -1);  /* push metatable */
     510              35 :   lua_setfield(L, -2, "__index");  /* metatable.__index = metatable */
     511              35 :   luaL_register(L, NULL, flib);  /* file methods */
     512              35 : }
     513                 : 
     514                 : 
     515             105 : static void createstdfile (lua_State *L, FILE *f, int k, const char *fname) {
     516             105 :   *newfile(L) = f;
     517             105 :   if (k > 0) {
     518              70 :     lua_pushvalue(L, -1);
     519              70 :     lua_rawseti(L, LUA_ENVIRONINDEX, k);
     520                 :   }
     521             105 :   lua_pushvalue(L, -2);  /* copy environment */
     522             105 :   lua_setfenv(L, -2);  /* set it */
     523             105 :   lua_setfield(L, -3, fname);
     524             105 : }
     525                 : 
     526                 : 
     527             105 : static void newfenv (lua_State *L, lua_CFunction cls) {
     528             105 :   lua_createtable(L, 0, 1);
     529             105 :   lua_pushcfunction(L, cls);
     530             105 :   lua_setfield(L, -2, "__close");
     531             105 : }
     532                 : 
     533                 : 
     534              35 : LUALIB_API int luaopen_io (lua_State *L) {
     535              35 :   createmeta(L);
     536                 :   /* create (private) environment (with fields IO_INPUT, IO_OUTPUT, __close) */
     537              35 :   newfenv(L, io_fclose);
     538              35 :   lua_replace(L, LUA_ENVIRONINDEX);
     539                 :   /* open library */
     540              35 :   luaL_register(L, LUA_IOLIBNAME, iolib);
     541                 :   /* create (and set) default files */
     542              35 :   newfenv(L, io_noclose);  /* close function for default files */
     543              35 :   createstdfile(L, stdin, IO_INPUT, "stdin");
     544              35 :   createstdfile(L, stdout, IO_OUTPUT, "stdout");
     545              35 :   createstdfile(L, stderr, 0, "stderr");
     546              35 :   lua_pop(L, 1);  /* pop environment for default files */
     547              35 :   lua_getfield(L, -1, "popen");
     548              35 :   newfenv(L, io_pclose);  /* create environment for 'popen' */
     549              35 :   lua_setfenv(L, -2);  /* set fenv for 'popen' */
     550              35 :   lua_pop(L, 1);  /* pop 'popen' */
     551              35 :   return 1;
     552                 : }
     553                 : 

Generated by: LCOV version 1.7