5973601545

Committed 25 Aug 2023 08:22AM UTC coverage: 88.113% (+0.2%) from 87.9%

Build # 5973601545

Build Type

push

github

Committed by

igormunkin

Commit Message

Revert to trival pow() optimizations to prevent inaccuracies.

(cherry-picked from commit 96d6d5032)

This patch fixes different misbehaviours between JIT-compiled code and
the interpreter for power operator in the following ways:
* Drop folding optimizations for base ^ n => base * base ..., as far as
  pow(base, n) isn't interchangeable with just multiplicity of numbers
  and depends on the <math.h> implementation.
* Since the internal power function is inaccurate for very big or small
  powers, it is dropped, and `pow()` from the standard library is used
  instead. To save consistency between JIT behaviour and the VM,
  narrowing optimization is dropped, and only trivial folding
  optimizations are used. Also, `math_extern2` version with two
  parameters is dropped, since it's no longer used.

Also, this fixes failures of the [220/502] lib/string/format/num.lua
test [1] from the LuaJIT-test suite.

[1]: https://www.exploringbinary.com/incorrect-floating-point-to-decimal-conversions/

Sergey Kaplun:
* added the description and the test for the problem

Part of tarantool/tarantool#8825

Reviewed-by: Maxim Kokryashkin <m.kokryashkin@tarantool.org>
Reviewed-by: Sergey Bronnikov <sergeyb@tarantool.org>
Signed-off-by: Igor Munkin <imun@tarantool.org>

Run Details

5322 of 5963 branches covered (0.0%)

Branch coverage included in aggregate %.

11 of 11 new or added lines in 5 files covered. (100.0%)

20443 of 23278 relevant lines covered (87.82%)

1292502.03 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.93

/src/lib_io.c

/*
** I/O library.
** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h
**
** Major portions taken verbatim or adapted from the Lua interpreter.
** Copyright (C) 1994-2011 Lua.org, PUC-Rio. See Copyright Notice in lua.h
*/

#include <errno.h>
#include <stdio.h>

#define lib_io_c
#define LUA_LIB

#include "lua.h"
#include "lauxlib.h"
#include "lualib.h"

#include "lj_obj.h"
#include "lj_gc.h"
#include "lj_err.h"
#include "lj_buf.h"
#include "lj_str.h"
#include "lj_state.h"
#include "lj_strfmt.h"
#include "lj_ff.h"
#include "lj_lib.h"

/* Userdata payload for I/O file. */
typedef struct IOFileUD {
  FILE *fp;                /* File handle. */
  uint32_t type;        /* File type. */
} IOFileUD;

#define IOFILE_TYPE_FILE        0        /* Regular file. */
#define IOFILE_TYPE_PIPE        1        /* Pipe. */
#define IOFILE_TYPE_STDF        2        /* Standard file handle. */
#define IOFILE_TYPE_MASK        3

#define IOFILE_FLAG_CLOSE        4        /* Close after io.lines() iterator. */

#define IOSTDF_UD(L, id)        (&gcref(G(L)->gcroot[(id)])->ud)
#define IOSTDF_IOF(L, id)        ((IOFileUD *)uddata(IOSTDF_UD(L, (id))))

/* -- Open/close helpers -------------------------------------------------- */

static IOFileUD *io_tofilep(lua_State *L)
{
  if (!(L->base < L->top && tvisudata(L->base) &&
        udataV(L->base)->udtype == UDTYPE_IO_FILE))
    lj_err_argtype(L, 1, "FILE*");
  return (IOFileUD *)uddata(udataV(L->base));
}

static IOFileUD *io_tofile(lua_State *L)
{
  IOFileUD *iof = io_tofilep(L);
  if (iof->fp == NULL)
    lj_err_caller(L, LJ_ERR_IOCLFL);
  return iof;
}

static IOFileUD *io_stdfile(lua_State *L, ptrdiff_t id)
{
  IOFileUD *iof = IOSTDF_IOF(L, id);
  if (iof->fp == NULL)
    lj_err_caller(L, LJ_ERR_IOSTDCL);
  return iof;
}

static IOFileUD *io_file_new(lua_State *L)
{
  IOFileUD *iof = (IOFileUD *)lua_newuserdata(L, sizeof(IOFileUD));
  GCudata *ud = udataV(L->top-1);
  ud->udtype = UDTYPE_IO_FILE;
  /* NOBARRIER: The GCudata is new (marked white). */
  setgcrefr(ud->metatable, curr_func(L)->c.env);
  iof->fp = NULL;
  iof->type = IOFILE_TYPE_FILE;
  return iof;
}

static IOFileUD *io_file_open(lua_State *L, const char *mode)
{
  const char *fname = strdata(lj_lib_checkstr(L, 1));
  IOFileUD *iof = io_file_new(L);
  iof->fp = fopen(fname, mode);
  if (iof->fp == NULL)
    luaL_argerror(L, 1, lj_strfmt_pushf(L, "%s: %s", fname, strerror(errno)));
  return iof;
}

static int io_file_close(lua_State *L, IOFileUD *iof)
{
  int ok;
  if ((iof->type & IOFILE_TYPE_MASK) == IOFILE_TYPE_FILE) {
    ok = (fclose(iof->fp) == 0);
  } else if ((iof->type & IOFILE_TYPE_MASK) == IOFILE_TYPE_PIPE) {
    int stat = -1;
#if LJ_TARGET_POSIX
    stat = pclose(iof->fp);
#elif LJ_TARGET_WINDOWS && !LJ_TARGET_XBOXONE && !LJ_TARGET_UWP
    stat = _pclose(iof->fp);
#endif
#if LJ_52
    iof->fp = NULL;
    return luaL_execresult(L, stat);
#else
    ok = (stat != -1);
#endif
  } else {
    lj_assertL((iof->type & IOFILE_TYPE_MASK) == IOFILE_TYPE_STDF,
               "close of unknown FILE* type");
    setnilV(L->top++);
    lua_pushliteral(L, "cannot close standard file");
    return 2;
  }
  iof->fp = NULL;
  return luaL_fileresult(L, ok, NULL);
}

/* -- Read/write helpers -------------------------------------------------- */

static int io_file_readnum(lua_State *L, FILE *fp)
{
  lua_Number d;
  if (fscanf(fp, LUA_NUMBER_SCAN, &d) == 1) {
    if (LJ_DUALNUM) {
      int32_t i = lj_num2int(d);
      if (d == (lua_Number)i && !tvismzero((cTValue *)&d)) {
        setintV(L->top++, i);
        return 1;
      }
    }
    setnumV(L->top++, d);
    return 1;
  } else {
    setnilV(L->top++);
    return 0;
  }
}

static int io_file_readline(lua_State *L, FILE *fp, MSize chop)
{
  MSize m = LUAL_BUFFERSIZE, n = 0, ok = 0;
  char *buf;
  for (;;) {
    buf = lj_buf_tmp(L, m);
    if (fgets(buf+n, m-n, fp) == NULL) break;
    n += (MSize)strlen(buf+n);
    ok |= n;
    if (n && buf[n-1] == '\n') { n -= chop; break; }
    if (n >= m - 64) m += m;
  }
  setstrV(L, L->top++, lj_str_new(L, buf, (size_t)n));
  lj_gc_check(L);
  return (int)ok;
}

static void io_file_readall(lua_State *L, FILE *fp)
{
  MSize m, n;
  for (m = LUAL_BUFFERSIZE, n = 0; ; m += m) {
    char *buf = lj_buf_tmp(L, m);
    n += (MSize)fread(buf+n, 1, m-n, fp);
    if (n != m) {
      setstrV(L, L->top++, lj_str_new(L, buf, (size_t)n));
      lj_gc_check(L);
      return;
    }
  }
}

static int io_file_readlen(lua_State *L, FILE *fp, MSize m)
{
  if (m) {
    char *buf = lj_buf_tmp(L, m);
    MSize n = (MSize)fread(buf, 1, m, fp);
    setstrV(L, L->top++, lj_str_new(L, buf, (size_t)n));
    lj_gc_check(L);
    return (n > 0 || m == 0);
  } else {
    int c = getc(fp);
    ungetc(c, fp);
    setstrV(L, L->top++, &G(L)->strempty);
    return (c != EOF);
  }
}

static int io_file_read(lua_State *L, IOFileUD *iof, int start)
{
  FILE *fp = iof->fp;
  int ok, n, nargs = (int)(L->top - L->base) - start;
  clearerr(fp);
  if (nargs == 0) {
    ok = io_file_readline(L, fp, 1);
    n = start+1;  /* Return 1 result. */
  } else {
    /* The results plus the buffers go on top of the args. */
    luaL_checkstack(L, nargs+LUA_MINSTACK, "too many arguments");
    ok = 1;
    for (n = start; nargs-- && ok; n++) {
      if (tvisstr(L->base+n)) {
        const char *p = strVdata(L->base+n);
        if (p[0] == '*') p++;
        if (p[0] == 'n')
          ok = io_file_readnum(L, fp);
        else if ((p[0] & ~0x20) == 'L')
          ok = io_file_readline(L, fp, (p[0] == 'l'));
        else if (p[0] == 'a')
          io_file_readall(L, fp);
        else
          lj_err_arg(L, n+1, LJ_ERR_INVFMT);
      } else if (tvisnumber(L->base+n)) {
        ok = io_file_readlen(L, fp, (MSize)lj_lib_checkint(L, n+1));
      } else {
        lj_err_arg(L, n+1, LJ_ERR_INVOPT);
      }
    }
  }
  if (ferror(fp))
    return luaL_fileresult(L, 0, NULL);
  if (!ok)
    setnilV(L->top-1);  /* Replace last result with nil. */
  return n - start;
}

static int io_file_write(lua_State *L, IOFileUD *iof, int start)
{
  FILE *fp = iof->fp;
  cTValue *tv;
  int status = 1;
  for (tv = L->base+start; tv < L->top; tv++) {
    MSize len;
    const char *p = lj_strfmt_wstrnum(L, tv, &len);
    if (!p)
      lj_err_argt(L, (int)(tv - L->base) + 1, LUA_TSTRING);
    status = status && (fwrite(p, 1, len, fp) == len);
  }
  if (LJ_52 && status) {
    L->top = L->base+1;
    if (start == 0)
      setudataV(L, L->base, IOSTDF_UD(L, GCROOT_IO_OUTPUT));
    return 1;
  }
  return luaL_fileresult(L, status, NULL);
}

static int io_file_iter(lua_State *L)
{
  GCfunc *fn = curr_func(L);
  IOFileUD *iof = uddata(udataV(&fn->c.upvalue[0]));
  int n = fn->c.nupvalues - 1;
  if (iof->fp == NULL)
    lj_err_caller(L, LJ_ERR_IOCLFL);
  L->top = L->base;
  if (n) {  /* Copy upvalues with options to stack. */
    if (n > LUAI_MAXCSTACK)
      lj_err_caller(L, LJ_ERR_STKOV);
    lj_state_checkstack(L, (MSize)n);
    memcpy(L->top, &fn->c.upvalue[1], n*sizeof(TValue));
    L->top += n;
  }
  n = io_file_read(L, iof, 0);
  if (ferror(iof->fp))
    lj_err_callermsg(L, strVdata(L->top-2));
  if (tvisnil(L->base) && (iof->type & IOFILE_FLAG_CLOSE)) {
    io_file_close(L, iof);  /* Return values are ignored. */
    return 0;
  }
  return n;
}

static int io_file_lines(lua_State *L)
{
  int n = (int)(L->top - L->base);
  if (n > LJ_MAX_UPVAL)
    lj_err_caller(L, LJ_ERR_UNPACK);
  lua_pushcclosure(L, io_file_iter, n);
  return 1;
}

/* -- I/O file methods ---------------------------------------------------- */

#define LJLIB_MODULE_io_method

LJLIB_CF(io_method_close)
{
  IOFileUD *iof;
  if (L->base < L->top) {
    iof = io_tofile(L);
  } else {
    iof = IOSTDF_IOF(L, GCROOT_IO_OUTPUT);
    if (iof->fp == NULL)
      lj_err_caller(L, LJ_ERR_IOCLFL);
  }
  return io_file_close(L, iof);
}

LJLIB_CF(io_method_read)
{
  return io_file_read(L, io_tofile(L), 1);
}

LJLIB_CF(io_method_write)                LJLIB_REC(io_write 0)
{
  return io_file_write(L, io_tofile(L), 1);
}

LJLIB_CF(io_method_flush)                LJLIB_REC(io_flush 0)
{
  return luaL_fileresult(L, fflush(io_tofile(L)->fp) == 0, NULL);
}

LJLIB_CF(io_method_seek)
{
  FILE *fp = io_tofile(L)->fp;
  int opt = lj_lib_checkopt(L, 2, 1, "\3set\3cur\3end");
  int64_t ofs = 0;
  cTValue *o;
  int res;
  if (opt == 0) opt = SEEK_SET;
  else if (opt == 1) opt = SEEK_CUR;
  else if (opt == 2) opt = SEEK_END;
  o = L->base+2;
  if (o < L->top) {
    if (tvisint(o))
      ofs = (int64_t)intV(o);
    else if (tvisnum(o))
      ofs = (int64_t)numV(o);
    else if (!tvisnil(o))
      lj_err_argt(L, 3, LUA_TNUMBER);
  }
#if LJ_TARGET_POSIX
  res = fseeko(fp, ofs, opt);
#elif _MSC_VER >= 1400
  res = _fseeki64(fp, ofs, opt);
#elif defined(__MINGW32__)
  res = fseeko64(fp, ofs, opt);
#else
  res = fseek(fp, (long)ofs, opt);
#endif
  if (res)
    return luaL_fileresult(L, 0, NULL);
#if LJ_TARGET_POSIX
  ofs = ftello(fp);
#elif _MSC_VER >= 1400
  ofs = _ftelli64(fp);
#elif defined(__MINGW32__)
  ofs = ftello64(fp);
#else
  ofs = (int64_t)ftell(fp);
#endif
  setint64V(L->top-1, ofs);
  return 1;
}

LJLIB_CF(io_method_setvbuf)
{
  FILE *fp = io_tofile(L)->fp;
  int opt = lj_lib_checkopt(L, 2, -1, "\4full\4line\2no");
  size_t sz = (size_t)lj_lib_optint(L, 3, LUAL_BUFFERSIZE);
  if (opt == 0) opt = _IOFBF;
  else if (opt == 1) opt = _IOLBF;
  else if (opt == 2) opt = _IONBF;
  return luaL_fileresult(L, setvbuf(fp, NULL, opt, sz) == 0, NULL);
}

LJLIB_CF(io_method_lines)
{
  io_tofile(L);
  return io_file_lines(L);
}

LJLIB_CF(io_method___gc)
{
  IOFileUD *iof = io_tofilep(L);
  if (iof->fp != NULL && (iof->type & IOFILE_TYPE_MASK) != IOFILE_TYPE_STDF)
    io_file_close(L, iof);
  return 0;
}

LJLIB_CF(io_method___tostring)
{
  IOFileUD *iof = io_tofilep(L);
  if (iof->fp != NULL)
    lua_pushfstring(L, "file (%p)", iof->fp);
  else
    lua_pushliteral(L, "file (closed)");
  return 1;
}

LJLIB_PUSH(top-1) LJLIB_SET(__index)

#include "lj_libdef.h"

/* -- I/O library functions ----------------------------------------------- */

#define LJLIB_MODULE_io

LJLIB_PUSH(top-2) LJLIB_SET(!)  /* Set environment. */

LJLIB_CF(io_open)
{
  const char *fname = strdata(lj_lib_checkstr(L, 1));
  GCstr *s = lj_lib_optstr(L, 2);
  const char *mode = s ? strdata(s) : "r";
  IOFileUD *iof = io_file_new(L);
  iof->fp = fopen(fname, mode);
  return iof->fp != NULL ? 1 : luaL_fileresult(L, 0, fname);
}

LJLIB_CF(io_popen)
{
#if LJ_TARGET_POSIX || (LJ_TARGET_WINDOWS && !LJ_TARGET_XBOXONE && !LJ_TARGET_UWP)
  const char *fname = strdata(lj_lib_checkstr(L, 1));
  GCstr *s = lj_lib_optstr(L, 2);
  const char *mode = s ? strdata(s) : "r";
  IOFileUD *iof = io_file_new(L);
  iof->type = IOFILE_TYPE_PIPE;
#if LJ_TARGET_POSIX
  fflush(NULL);
  iof->fp = popen(fname, mode);
#else
  iof->fp = _popen(fname, mode);
#endif
  return iof->fp != NULL ? 1 : luaL_fileresult(L, 0, fname);
#else
  return luaL_error(L, LUA_QL("popen") " not supported");
#endif
}

LJLIB_CF(io_tmpfile)
{
  IOFileUD *iof = io_file_new(L);
#if LJ_TARGET_PS3 || LJ_TARGET_PS4 || LJ_TARGET_PSVITA
  iof->fp = NULL; errno = ENOSYS;
#else
  iof->fp = tmpfile();
#endif
  return iof->fp != NULL ? 1 : luaL_fileresult(L, 0, NULL);
}

LJLIB_CF(io_close)
{
  return lj_cf_io_method_close(L);
}

LJLIB_CF(io_read)
{
  return io_file_read(L, io_stdfile(L, GCROOT_IO_INPUT), 0);
}

LJLIB_CF(io_write)                LJLIB_REC(io_write GCROOT_IO_OUTPUT)
{
  return io_file_write(L, io_stdfile(L, GCROOT_IO_OUTPUT), 0);
}

LJLIB_CF(io_flush)                LJLIB_REC(io_flush GCROOT_IO_OUTPUT)
{
  return luaL_fileresult(L, fflush(io_stdfile(L, GCROOT_IO_OUTPUT)->fp) == 0, NULL);
}

static int io_std_getset(lua_State *L, ptrdiff_t id, const char *mode)
{
  if (L->base < L->top && !tvisnil(L->base)) {
    if (tvisudata(L->base)) {
      io_tofile(L);
      L->top = L->base+1;
    } else {
      io_file_open(L, mode);
    }
    /* NOBARRIER: The standard I/O handles are GC roots. */
    setgcref(G(L)->gcroot[id], gcV(L->top-1));
  } else {
    setudataV(L, L->top++, IOSTDF_UD(L, id));
  }
  return 1;
}

LJLIB_CF(io_input)
{
  return io_std_getset(L, GCROOT_IO_INPUT, "r");
}

LJLIB_CF(io_output)
{
  return io_std_getset(L, GCROOT_IO_OUTPUT, "w");
}

LJLIB_CF(io_lines)
{
  if (L->base == L->top) setnilV(L->top++);
  if (!tvisnil(L->base)) {  /* io.lines(fname) */
    IOFileUD *iof = io_file_open(L, "r");
    iof->type = IOFILE_TYPE_FILE|IOFILE_FLAG_CLOSE;
    L->top--;
    setudataV(L, L->base, udataV(L->top));
  } else {  /* io.lines() iterates over stdin. */
    setudataV(L, L->base, IOSTDF_UD(L, GCROOT_IO_INPUT));
  }
  return io_file_lines(L);
}

LJLIB_CF(io_type)
{
  cTValue *o = lj_lib_checkany(L, 1);
  if (!(tvisudata(o) && udataV(o)->udtype == UDTYPE_IO_FILE))
    setnilV(L->top++);
  else if (((IOFileUD *)uddata(udataV(o)))->fp != NULL)
    lua_pushliteral(L, "file");
  else
    lua_pushliteral(L, "closed file");
  return 1;
}

#include "lj_libdef.h"

/* ------------------------------------------------------------------------ */

static GCobj *io_std_new(lua_State *L, FILE *fp, const char *name)
{
  IOFileUD *iof = (IOFileUD *)lua_newuserdata(L, sizeof(IOFileUD));
  GCudata *ud = udataV(L->top-1);
  ud->udtype = UDTYPE_IO_FILE;
  /* NOBARRIER: The GCudata is new (marked white). */
  setgcref(ud->metatable, gcV(L->top-3));
  iof->fp = fp;
  iof->type = IOFILE_TYPE_STDF;
  lua_setfield(L, -2, name);
  return obj2gco(ud);
}

LUALIB_API int luaopen_io(lua_State *L)
{
  LJ_LIB_REG(L, NULL, io_method);
  copyTV(L, L->top, L->top-1); L->top++;
  lua_setfield(L, LUA_REGISTRYINDEX, LUA_FILEHANDLE);
  LJ_LIB_REG(L, LUA_IOLIBNAME, io);
  setgcref(G(L)->gcroot[GCROOT_IO_INPUT], io_std_new(L, stdin, "stdin"));
  setgcref(G(L)->gcroot[GCROOT_IO_OUTPUT], io_std_new(L, stdout, "stdout"));
  io_std_new(L, stderr, "stderr");
  return 1;
}


1	/*
2	** I/O library.
3	** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h
4	**
5	** Major portions taken verbatim or adapted from the Lua interpreter.
6	** Copyright (C) 1994-2011 Lua.org, PUC-Rio. See Copyright Notice in lua.h
7	*/
8
9	#include <errno.h>
10	#include <stdio.h>
11
12	#define lib_io_c
13	#define LUA_LIB
14
15	#include "lua.h"
16	#include "lauxlib.h"
17	#include "lualib.h"
18
19	#include "lj_obj.h"
20	#include "lj_gc.h"
21	#include "lj_err.h"
22	#include "lj_buf.h"
23	#include "lj_str.h"
24	#include "lj_state.h"
25	#include "lj_strfmt.h"
26	#include "lj_ff.h"
27	#include "lj_lib.h"
28
29	/* Userdata payload for I/O file. */
30	typedef struct IOFileUD {
31	FILE fp; / File handle. */
32	uint32_t type; /* File type. */
33	} IOFileUD;
34
35	#define IOFILE_TYPE_FILE 0 /* Regular file. */
36	#define IOFILE_TYPE_PIPE 1 /* Pipe. */
37	#define IOFILE_TYPE_STDF 2 /* Standard file handle. */
38	#define IOFILE_TYPE_MASK 3
39
40	#define IOFILE_FLAG_CLOSE 4 /* Close after io.lines() iterator. */
41
42	#define IOSTDF_UD(L, id) (&gcref(G(L)->gcroot[(id)])->ud)
43	#define IOSTDF_IOF(L, id) ((IOFileUD *)uddata(IOSTDF_UD(L, (id))))
44
45	/* -- Open/close helpers -------------------------------------------------- */
46
47	static IOFileUD io_tofilep(lua_State L)	5,666✔
48	{
49	if (!(L->base < L->top && tvisudata(L->base) &&	5,666✔
50	udataV(L->base)->udtype == UDTYPE_IO_FILE))	5,665✔
51	lj_err_argtype(L, 1, "FILE*");	1✔
52	return (IOFileUD *)uddata(udataV(L->base));	5,665✔
53	}
54
55	static IOFileUD io_tofile(lua_State L)	2,879✔
56	{
57	IOFileUD *iof = io_tofilep(L);	2,879✔
58	if (iof->fp == NULL)	2,879✔
59	lj_err_caller(L, LJ_ERR_IOCLFL);	6✔
60	return iof;	2,873✔
61	}
62
63	static IOFileUD io_stdfile(lua_State L, ptrdiff_t id)	126,860✔
64	{
65	IOFileUD *iof = IOSTDF_IOF(L, id);	126,860✔
66	if (iof->fp == NULL)	126,860✔
67	lj_err_caller(L, LJ_ERR_IOSTDCL);	2✔
68	return iof;	126,858✔
69	}
70
71	static IOFileUD io_file_new(lua_State L)	2,129✔
72	{
73	IOFileUD iof = (IOFileUD )lua_newuserdata(L, sizeof(IOFileUD));	2,129✔
74	GCudata *ud = udataV(L->top-1);	2,129✔
75	ud->udtype = UDTYPE_IO_FILE;	2,129✔
76	/* NOBARRIER: The GCudata is new (marked white). */
77	setgcrefr(ud->metatable, curr_func(L)->c.env);	2,129✔
78	iof->fp = NULL;	2,129✔
79	iof->type = IOFILE_TYPE_FILE;	2,129✔
80	return iof;	2,129✔
81	}
82
83	static IOFileUD io_file_open(lua_State L, const char *mode)	1,282✔
84	{
85	const char *fname = strdata(lj_lib_checkstr(L, 1));	1,282✔
86	IOFileUD *iof = io_file_new(L);	1,282✔
87	iof->fp = fopen(fname, mode);	1,282✔
88	if (iof->fp == NULL)	1,282✔
89	luaL_argerror(L, 1, lj_strfmt_pushf(L, "%s: %s", fname, strerror(errno)));	1✔
90	return iof;	1,281✔
91	}
92
93	static int io_file_close(lua_State L, IOFileUD iof)
94	{
95	int ok;
96	if ((iof->type & IOFILE_TYPE_MASK) == IOFILE_TYPE_FILE) {
97	ok = (fclose(iof->fp) == 0);
98	} else if ((iof->type & IOFILE_TYPE_MASK) == IOFILE_TYPE_PIPE) {
99	int stat = -1;
100	#if LJ_TARGET_POSIX
101	stat = pclose(iof->fp);
102	#elif LJ_TARGET_WINDOWS && !LJ_TARGET_XBOXONE && !LJ_TARGET_UWP
103	stat = _pclose(iof->fp);
104	#endif
105	#if LJ_52
106	iof->fp = NULL;
107	return luaL_execresult(L, stat);
108	#else
109	ok = (stat != -1);
110	#endif
111	} else {
112	lj_assertL((iof->type & IOFILE_TYPE_MASK) == IOFILE_TYPE_STDF,
113	"close of unknown FILE* type");
114	setnilV(L->top++);
115	lua_pushliteral(L, "cannot close standard file");
116	return 2;
117	}
118	iof->fp = NULL;
119	return luaL_fileresult(L, ok, NULL);
120	}
121
122	/* -- Read/write helpers -------------------------------------------------- */
123
124	static int io_file_readnum(lua_State L, FILE fp)
125	{
126	lua_Number d;
127	if (fscanf(fp, LUA_NUMBER_SCAN, &d) == 1) {
128	if (LJ_DUALNUM) {
129	int32_t i = lj_num2int(d);
130	if (d == (lua_Number)i && !tvismzero((cTValue *)&d)) {
131	setintV(L->top++, i);
132	return 1;
133	}
134	}
135	setnumV(L->top++, d);
136	return 1;
137	} else {
138	setnilV(L->top++);
139	return 0;
140	}
141	}
142
143	static int io_file_readline(lua_State L, FILE fp, MSize chop)	509✔
144	{
145	MSize m = LUAL_BUFFERSIZE, n = 0, ok = 0;	509✔
146	char *buf;	515✔
147	for (;;) {	515✔
148	buf = lj_buf_tmp(L, m);	515✔
149	if (fgets(buf+n, m-n, fp) == NULL) break;	515✔
150	n += (MSize)strlen(buf+n);	467✔
151	ok \|= n;	467✔
152	if (n && buf[n-1] == '\n') { n -= chop; break; }	467✔
153	if (n >= m - 64) m += m;	6✔
154	}
155	setstrV(L, L->top++, lj_str_new(L, buf, (size_t)n));	509✔
156	lj_gc_check(L);	509✔
157	return (int)ok;	509✔
158	}
159
160	static void io_file_readall(lua_State L, FILE fp)	140✔
161	{
162	MSize m, n;	140✔
163	for (m = LUAL_BUFFERSIZE, n = 0; ; m += m) {	140✔
164	char *buf = lj_buf_tmp(L, m);	146✔
165	n += (MSize)fread(buf+n, 1, m-n, fp);	146✔
166	if (n != m) {	146✔
167	setstrV(L, L->top++, lj_str_new(L, buf, (size_t)n));	140✔
168	lj_gc_check(L);	140✔
169	return;	140✔
170	}
171	}
172	}
173
174	static int io_file_readlen(lua_State L, FILE fp, MSize m)	32✔
175	{
176	if (m) {	32✔
177	char *buf = lj_buf_tmp(L, m);	22✔
178	MSize n = (MSize)fread(buf, 1, m, fp);	22✔
179	setstrV(L, L->top++, lj_str_new(L, buf, (size_t)n));	22✔
180	lj_gc_check(L);	22✔
181	return (n > 0 \|\| m == 0);	22✔
182	} else {
183	int c = getc(fp);	10✔
184	ungetc(c, fp);	10✔
185	setstrV(L, L->top++, &G(L)->strempty);	10✔
186	return (c != EOF);	10✔
187	}
188	}
189
190	static int io_file_read(lua_State L, IOFileUD iof, int start)
191	{
192	FILE *fp = iof->fp;
193	int ok, n, nargs = (int)(L->top - L->base) - start;
194	clearerr(fp);
195	if (nargs == 0) {
196	ok = io_file_readline(L, fp, 1);
197	n = start+1; /* Return 1 result. */
198	} else {
199	/* The results plus the buffers go on top of the args. */
200	luaL_checkstack(L, nargs+LUA_MINSTACK, "too many arguments");
201	ok = 1;
202	for (n = start; nargs-- && ok; n++) {
203	if (tvisstr(L->base+n)) {
204	const char *p = strVdata(L->base+n);
205	if (p[0] == '*') p++;
206	if (p[0] == 'n')
207	ok = io_file_readnum(L, fp);
208	else if ((p[0] & ~0x20) == 'L')
209	ok = io_file_readline(L, fp, (p[0] == 'l'));
210	else if (p[0] == 'a')
211	io_file_readall(L, fp);
212	else
213	lj_err_arg(L, n+1, LJ_ERR_INVFMT);
214	} else if (tvisnumber(L->base+n)) {
215	ok = io_file_readlen(L, fp, (MSize)lj_lib_checkint(L, n+1));
216	} else {
217	lj_err_arg(L, n+1, LJ_ERR_INVOPT);
218	}
219	}
220	}
221	if (ferror(fp))
222	return luaL_fileresult(L, 0, NULL);
223	if (!ok)
224	setnilV(L->top-1); /* Replace last result with nil. */
225	return n - start;
226	}
227
228	static int io_file_write(lua_State L, IOFileUD iof, int start)
229	{
230	FILE *fp = iof->fp;
231	cTValue *tv;
232	int status = 1;
233	for (tv = L->base+start; tv < L->top; tv++) {
234	MSize len;
235	const char *p = lj_strfmt_wstrnum(L, tv, &len);
236	if (!p)
237	lj_err_argt(L, (int)(tv - L->base) + 1, LUA_TSTRING);
238	status = status && (fwrite(p, 1, len, fp) == len);
239	}
240	if (LJ_52 && status) {
241	L->top = L->base+1;
242	if (start == 0)
243	setudataV(L, L->base, IOSTDF_UD(L, GCROOT_IO_OUTPUT));
244	return 1;
245	}
246	return luaL_fileresult(L, status, NULL);
247	}
248
249	static int io_file_iter(lua_State *L)	411✔
250	{
251	GCfunc *fn = curr_func(L);	411✔
252	IOFileUD *iof = uddata(udataV(&fn->c.upvalue[0]));	411✔
253	int n = fn->c.nupvalues - 1;	411✔
254	if (iof->fp == NULL)	411✔
255	lj_err_caller(L, LJ_ERR_IOCLFL);	2✔
256	L->top = L->base;	409✔
257	if (n) { /* Copy upvalues with options to stack. */	409✔
258	if (n > LUAI_MAXCSTACK)	×
259	lj_err_caller(L, LJ_ERR_STKOV);
260	lj_state_checkstack(L, (MSize)n);	×
261	memcpy(L->top, &fn->c.upvalue[1], n*sizeof(TValue));	×
262	L->top += n;	×
263	}
264	n = io_file_read(L, iof, 0);	409✔
265	if (ferror(iof->fp))	409✔
266	lj_err_callermsg(L, strVdata(L->top-2));	×
267	if (tvisnil(L->base) && (iof->type & IOFILE_FLAG_CLOSE)) {	409✔
268	io_file_close(L, iof); /* Return values are ignored. */	28✔
269	return 0;	28✔
270	}
271	return n;
272	}
273
274	static int io_file_lines(lua_State *L)	637✔
275	{
276	int n = (int)(L->top - L->base);	637✔
277	if (n > LJ_MAX_UPVAL)	637✔
278	lj_err_caller(L, LJ_ERR_UNPACK);	×
279	lua_pushcclosure(L, io_file_iter, n);	637✔
280	return 1;	637✔
281	}
282
283	/* -- I/O file methods ---------------------------------------------------- */
284
285	#define LJLIB_MODULE_io_method
286
287	LJLIB_CF(io_method_close)	271✔
288	{
289	IOFileUD *iof;	271✔
290	if (L->base < L->top) {	271✔
291	iof = io_tofile(L);	244✔
292	} else {
293	iof = IOSTDF_IOF(L, GCROOT_IO_OUTPUT);	27✔
294	if (iof->fp == NULL)	27✔
295	lj_err_caller(L, LJ_ERR_IOCLFL);	1✔
296	}
297	return io_file_close(L, iof);	268✔
298	}
299
300	LJLIB_CF(io_method_read)	216✔
301	{
302	return io_file_read(L, io_tofile(L), 1);	216✔
303	}
304
305	LJLIB_CF(io_method_write) LJLIB_REC(io_write 0)	2,348✔
306	{
307	return io_file_write(L, io_tofile(L), 1);	2,348✔
308	}
309
310	LJLIB_CF(io_method_flush) LJLIB_REC(io_flush 0)	27✔
311	{
312	return luaL_fileresult(L, fflush(io_tofile(L)->fp) == 0, NULL);	27✔
313	}
314
315	LJLIB_CF(io_method_seek)	18✔
316	{
317	FILE *fp = io_tofile(L)->fp;	18✔
318	int opt = lj_lib_checkopt(L, 2, 1, "\3set\3cur\3end");	17✔
319	int64_t ofs = 0;	16✔
320	cTValue *o;	16✔
321	int res;	16✔
322	if (opt == 0) opt = SEEK_SET;	16✔
323	else if (opt == 1) opt = SEEK_CUR;	7✔
324	else if (opt == 2) opt = SEEK_END;	2✔
325	o = L->base+2;	16✔
326	if (o < L->top) {	16✔
327	if (tvisint(o))	9✔
328	ofs = (int64_t)intV(o);
329	else if (tvisnum(o))	9✔
330	ofs = (int64_t)numV(o);	9✔
331	else if (!tvisnil(o))	×
332	lj_err_argt(L, 3, LUA_TNUMBER);	×
333	}
334	#if LJ_TARGET_POSIX
335	res = fseeko(fp, ofs, opt);	16✔
336	#elif _MSC_VER >= 1400
337	res = _fseeki64(fp, ofs, opt);
338	#elif defined(__MINGW32__)
339	res = fseeko64(fp, ofs, opt);
340	#else
341	res = fseek(fp, (long)ofs, opt);
342	#endif
343	if (res)	16✔
344	return luaL_fileresult(L, 0, NULL);	×
345	#if LJ_TARGET_POSIX
346	ofs = ftello(fp);	16✔
347	#elif _MSC_VER >= 1400
348	ofs = _ftelli64(fp);
349	#elif defined(__MINGW32__)
350	ofs = ftello64(fp);
351	#else
352	ofs = (int64_t)ftell(fp);
353	#endif
354	setint64V(L->top-1, ofs);	16✔
355	return 1;	16✔
356	}
357
358	LJLIB_CF(io_method_setvbuf)	6✔
359	{
360	FILE *fp = io_tofile(L)->fp;	6✔
361	int opt = lj_lib_checkopt(L, 2, -1, "\4full\4line\2no");	6✔
362	size_t sz = (size_t)lj_lib_optint(L, 3, LUAL_BUFFERSIZE);	6✔
363	if (opt == 0) opt = _IOFBF;	6✔
364	else if (opt == 1) opt = _IOLBF;	4✔
365	else if (opt == 2) opt = _IONBF;	2✔
366	return luaL_fileresult(L, setvbuf(fp, NULL, opt, sz) == 0, NULL);	6✔
367	}
368
369	LJLIB_CF(io_method_lines)	6✔
370	{
371	io_tofile(L);	6✔
372	return io_file_lines(L);	6✔
373	}
374
375	LJLIB_CF(io_method___gc)	2,778✔
376	{
377	IOFileUD *iof = io_tofilep(L);	2,778✔
378	if (iof->fp != NULL && (iof->type & IOFILE_TYPE_MASK) != IOFILE_TYPE_STDF)	2,777✔
379	io_file_close(L, iof);	1,829✔
380	return 0;	2,777✔
381	}
382
383	LJLIB_CF(io_method___tostring)	9✔
384	{
385	IOFileUD *iof = io_tofilep(L);	9✔
386	if (iof->fp != NULL)	9✔
387	lua_pushfstring(L, "file (%p)", iof->fp);	7✔
388	else
389	lua_pushliteral(L, "file (closed)");	2✔
390	return 1;	9✔
391	}
392
393	LJLIB_PUSH(top-1) LJLIB_SET(__index)
394
395	#include "lj_libdef.h"
396
397	/* -- I/O library functions ----------------------------------------------- */
398
399	#define LJLIB_MODULE_io
400
401	LJLIB_PUSH(top-2) LJLIB_SET(!) /* Set environment. */
402
403	LJLIB_CF(io_open)	778✔
404	{
405	const char *fname = strdata(lj_lib_checkstr(L, 1));	778✔
406	GCstr *s = lj_lib_optstr(L, 2);	778✔
407	const char *mode = s ? strdata(s) : "r";	778✔
408	IOFileUD *iof = io_file_new(L);	778✔
409	iof->fp = fopen(fname, mode);	778✔
410	return iof->fp != NULL ? 1 : luaL_fileresult(L, 0, fname);	778✔
411	}
412
413	LJLIB_CF(io_popen)	66✔
414	{
415	#if LJ_TARGET_POSIX \|\| (LJ_TARGET_WINDOWS && !LJ_TARGET_XBOXONE && !LJ_TARGET_UWP)
416	const char *fname = strdata(lj_lib_checkstr(L, 1));	66✔
417	GCstr *s = lj_lib_optstr(L, 2);	66✔
418	const char *mode = s ? strdata(s) : "r";	66✔
419	IOFileUD *iof = io_file_new(L);	66✔
420	iof->type = IOFILE_TYPE_PIPE;	66✔
421	#if LJ_TARGET_POSIX
422	fflush(NULL);	66✔
423	iof->fp = popen(fname, mode);	66✔
424	#else
425	iof->fp = _popen(fname, mode);
426	#endif
427	return iof->fp != NULL ? 1 : luaL_fileresult(L, 0, fname);	66✔
428	#else
429	return luaL_error(L, LUA_QL("popen") " not supported");
430	#endif
431	}
432
433	LJLIB_CF(io_tmpfile)	3✔
434	{
435	IOFileUD *iof = io_file_new(L);	3✔
436	#if LJ_TARGET_PS3 \|\| LJ_TARGET_PS4 \|\| LJ_TARGET_PSVITA
437	iof->fp = NULL; errno = ENOSYS;
438	#else
439	iof->fp = tmpfile();	3✔
440	#endif
441	return iof->fp != NULL ? 1 : luaL_fileresult(L, 0, NULL);	3✔
442	}
443
444	LJLIB_CF(io_close)	47✔
445	{
446	return lj_cf_io_method_close(L);	47✔
447	}
448
449	LJLIB_CF(io_read)	62✔
450	{
451	return io_file_read(L, io_stdfile(L, GCROOT_IO_INPUT), 0);	62✔
452	}
453
454	LJLIB_CF(io_write) LJLIB_REC(io_write GCROOT_IO_OUTPUT)	126,796✔
455	{
456	return io_file_write(L, io_stdfile(L, GCROOT_IO_OUTPUT), 0);	126,796✔
457	}
458
459	LJLIB_CF(io_flush) LJLIB_REC(io_flush GCROOT_IO_OUTPUT)	2✔
460	{
461	return luaL_fileresult(L, fflush(io_stdfile(L, GCROOT_IO_OUTPUT)->fp) == 0, NULL);	2✔
462	}
463
464	static int io_std_getset(lua_State L, ptrdiff_t id, const char mode)	714✔
465	{
466	if (L->base < L->top && !tvisnil(L->base)) {	714✔
467	if (tvisudata(L->base)) {	667✔
468	io_tofile(L);	14✔
469	L->top = L->base+1;	14✔
470	} else {
471	io_file_open(L, mode);	653✔
472	}
473	/* NOBARRIER: The standard I/O handles are GC roots. */
474	setgcref(G(L)->gcroot[id], gcV(L->top-1));	667✔
475	} else {
476	setudataV(L, L->top++, IOSTDF_UD(L, id));	47✔
477	}
478	return 1;	714✔
479	}
480
481	LJLIB_CF(io_input)	648✔
482	{
483	return io_std_getset(L, GCROOT_IO_INPUT, "r");	648✔
484	}
485
486	LJLIB_CF(io_output)	66✔
487	{
488	return io_std_getset(L, GCROOT_IO_OUTPUT, "w");	66✔
489	}
490
491	LJLIB_CF(io_lines)	632✔
492	{
493	if (L->base == L->top) setnilV(L->top++);	632✔
494	if (!tvisnil(L->base)) { /* io.lines(fname) */	632✔
495	IOFileUD *iof = io_file_open(L, "r");	629✔
496	iof->type = IOFILE_TYPE_FILE\|IOFILE_FLAG_CLOSE;	628✔
497	L->top--;	628✔
498	setudataV(L, L->base, udataV(L->top));	628✔
499	} else { /* io.lines() iterates over stdin. */
500	setudataV(L, L->base, IOSTDF_UD(L, GCROOT_IO_INPUT));	3✔
501	}
502	return io_file_lines(L);	631✔
503	}
504
505	LJLIB_CF(io_type)	14✔
506	{
507	cTValue *o = lj_lib_checkany(L, 1);	14✔
508	if (!(tvisudata(o) && udataV(o)->udtype == UDTYPE_IO_FILE))	14✔
509	setnilV(L->top++);	3✔
510	else if (((IOFileUD *)uddata(udataV(o)))->fp != NULL)	11✔
511	lua_pushliteral(L, "file");	8✔
512	else
513	lua_pushliteral(L, "closed file");	3✔
514	return 1;	14✔
515	}
516
517	#include "lj_libdef.h"
518
519	/* ------------------------------------------------------------------------ */
520
521	static GCobj io_std_new(lua_State L, FILE fp, const char name)	669✔
522	{
523	IOFileUD iof = (IOFileUD )lua_newuserdata(L, sizeof(IOFileUD));	669✔
524	GCudata *ud = udataV(L->top-1);	669✔
525	ud->udtype = UDTYPE_IO_FILE;	669✔
526	/* NOBARRIER: The GCudata is new (marked white). */
527	setgcref(ud->metatable, gcV(L->top-3));	669✔
528	iof->fp = fp;	669✔
529	iof->type = IOFILE_TYPE_STDF;	669✔
530	lua_setfield(L, -2, name);	669✔
531	return obj2gco(ud);	669✔
532	}
533
534	LUALIB_API int luaopen_io(lua_State *L)	223✔
535	{
536	LJ_LIB_REG(L, NULL, io_method);	223✔
537	copyTV(L, L->top, L->top-1); L->top++;	223✔
538	lua_setfield(L, LUA_REGISTRYINDEX, LUA_FILEHANDLE);	223✔
539	LJ_LIB_REG(L, LUA_IOLIBNAME, io);	223✔
540	setgcref(G(L)->gcroot[GCROOT_IO_INPUT], io_std_new(L, stdin, "stdin"));	223✔
541	setgcref(G(L)->gcroot[GCROOT_IO_OUTPUT], io_std_new(L, stdout, "stdout"));	223✔
542	io_std_new(L, stderr, "stderr");	223✔
543	return 1;	223✔
544	}
545

tarantool / luajit / 5973601545

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous