LCOV - code coverage report
Current view: top level - src - liolib.c Hit Total Coverage
Test: Lua 5.1.5 Lines: 265 279 95.0 %
Date: 2012-02-18
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.9