]> 4ch.mooo.com Git - 16.git/blob - src/lua/src/liolib.c
renamed: ptmp0.pcx -> data/ptmp0.pcx
[16.git] / 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