liolib.c 20 KB

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