8062004225

Committed 27 Feb 2024 08:41AM UTC coverage: 92.591% (-0.007%) from 92.598%

Build # 8062004225

Build Type

push

github

Committed by

Buristan

Commit Message

test: enable CLI-related lua-Harness tests back

Tarantool supports -b and -j options to use LuaJIT modules since the
commit bf8b76a4d ("lua: proxy -j and -b
flags"), so 241-standalone.t and 411-luajit.t tests in the lua-Harness
suite, disabled in the commit 39a4db500
("test: support Tarantool in lua-Harness"), can be enabled back.

However, the -O option is still not implemented in Tarantool, so the
related part in the 411-luajit.t test chunk is still disabled.

Follows up tarantool/tarantool#5541

Reviewed-by: Maxim Kokryashkin <m.kokryashkin@tarantool.org>
Reviewed-by: Sergey Kaplun <skaplun@tarantool.org>
Signed-off-by: Sergey Kaplun <skaplun@tarantool.org>
(cherry picked from commit e316cbf0d)

Run Details

5657 of 6016 branches covered (94.03%)

Branch coverage included in aggregate %.

21588 of 23409 relevant lines covered (92.22%)

2817149.02 hits per line

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

84.21

/src/lj_load.c

/*
** Load and dump code.
** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h
*/

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

#define lj_load_c
#define LUA_CORE

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

#include "lj_obj.h"
#include "lj_gc.h"
#include "lj_err.h"
#include "lj_buf.h"
#include "lj_func.h"
#include "lj_frame.h"
#include "lj_vm.h"
#include "lj_lex.h"
#include "lj_bcdump.h"
#include "lj_parse.h"

/* -- Load Lua source code and bytecode ----------------------------------- */

static TValue *cpparser(lua_State *L, lua_CFunction dummy, void *ud)
{
  LexState *ls = (LexState *)ud;
  GCproto *pt;
  GCfunc *fn;
  int bc;
  UNUSED(dummy);
  cframe_errfunc(L->cframe) = -1;  /* Inherit error function. */
  bc = lj_lex_setup(L, ls);
  if (ls->mode && !strchr(ls->mode, bc ? 'b' : 't')) {
    setstrV(L, L->top++, lj_err_str(L, LJ_ERR_XMODE));
    lj_err_throw(L, LUA_ERRSYNTAX);
  }
  pt = bc ? lj_bcread(ls) : lj_parse(ls);
  fn = lj_func_newL_empty(L, pt, tabref(L->env));
  /* Don't combine above/below into one statement. */
  setfuncV(L, L->top++, fn);
  return NULL;
}

LUA_API int lua_loadx(lua_State *L, lua_Reader reader, void *data,
                      const char *chunkname, const char *mode)
{
  LexState ls;
  int status;
  ls.rfunc = reader;
  ls.rdata = data;
  ls.chunkarg = chunkname ? chunkname : "?";
  ls.mode = mode;
  lj_buf_init(L, &ls.sb);
  status = lj_vm_cpcall(L, NULL, &ls, cpparser);
  lj_lex_cleanup(L, &ls);
  lj_gc_check(L);
  return status;
}

LUA_API int lua_load(lua_State *L, lua_Reader reader, void *data,
                     const char *chunkname)
{
  return lua_loadx(L, reader, data, chunkname, NULL);
}

typedef struct FileReaderCtx {
  FILE *fp;
  char buf[LUAL_BUFFERSIZE];
} FileReaderCtx;

static const char *reader_file(lua_State *L, void *ud, size_t *size)
{
  FileReaderCtx *ctx = (FileReaderCtx *)ud;
  UNUSED(L);
  if (feof(ctx->fp)) return NULL;
  *size = fread(ctx->buf, 1, sizeof(ctx->buf), ctx->fp);
  return *size > 0 ? ctx->buf : NULL;
}

LUALIB_API int luaL_loadfilex(lua_State *L, const char *filename,
                              const char *mode)
{
  FileReaderCtx ctx;
  int status;
  const char *chunkname;
  if (filename) {
    ctx.fp = fopen(filename, "rb");
    if (ctx.fp == NULL) {
      lua_pushfstring(L, "cannot open %s: %s", filename, strerror(errno));
      return LUA_ERRFILE;
    }
    chunkname = lua_pushfstring(L, "@%s", filename);
  } else {
    ctx.fp = stdin;
    chunkname = "=stdin";
  }
  status = lua_loadx(L, reader_file, &ctx, chunkname, mode);
  if (ferror(ctx.fp)) {
    L->top -= filename ? 2 : 1;
    lua_pushfstring(L, "cannot read %s: %s", chunkname+1, strerror(errno));
    if (filename)
      fclose(ctx.fp);
    return LUA_ERRFILE;
  }
  if (filename) {
    L->top--;
    copyTV(L, L->top-1, L->top);
    fclose(ctx.fp);
  }
  return status;
}

LUALIB_API int luaL_loadfile(lua_State *L, const char *filename)
{
  return luaL_loadfilex(L, filename, NULL);
}

typedef struct StringReaderCtx {
  const char *str;
  size_t size;
} StringReaderCtx;

static const char *reader_string(lua_State *L, void *ud, size_t *size)
{
  StringReaderCtx *ctx = (StringReaderCtx *)ud;
  UNUSED(L);
  if (ctx->size == 0) return NULL;
  *size = ctx->size;
  ctx->size = 0;
  return ctx->str;
}

LUALIB_API int luaL_loadbufferx(lua_State *L, const char *buf, size_t size,
                                const char *name, const char *mode)
{
  StringReaderCtx ctx;
  ctx.str = buf;
  ctx.size = size;
  return lua_loadx(L, reader_string, &ctx, name, mode);
}

LUALIB_API int luaL_loadbuffer(lua_State *L, const char *buf, size_t size,
                               const char *name)
{
  return luaL_loadbufferx(L, buf, size, name, NULL);
}

LUALIB_API int luaL_loadstring(lua_State *L, const char *s)
{
  return luaL_loadbuffer(L, s, strlen(s), s);
}

/* -- Dump bytecode ------------------------------------------------------- */

LUA_API int lua_dump(lua_State *L, lua_Writer writer, void *data)
{
  cTValue *o = L->top-1;
  lj_checkapi(L->top > L->base, "top slot empty");
  if (tvisfunc(o) && isluafunc(funcV(o)))
    return lj_bcwrite(L, funcproto(funcV(o)), writer, data, 0);
  else
    return 1;
}


1	/*
2	** Load and dump code.
3	** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h
4	*/
5
6	#include <errno.h>
7	#include <stdio.h>
8
9	#define lj_load_c
10	#define LUA_CORE
11
12	#include "lua.h"
13	#include "lauxlib.h"
14
15	#include "lj_obj.h"
16	#include "lj_gc.h"
17	#include "lj_err.h"
18	#include "lj_buf.h"
19	#include "lj_func.h"
20	#include "lj_frame.h"
21	#include "lj_vm.h"
22	#include "lj_lex.h"
23	#include "lj_bcdump.h"
24	#include "lj_parse.h"
25
26	/* -- Load Lua source code and bytecode ----------------------------------- */
27
28	static TValue cpparser(lua_State L, lua_CFunction dummy, void *ud)	53,454✔
29	{
30	LexState ls = (LexState )ud;	53,454✔
31	GCproto *pt;	53,454✔
32	GCfunc *fn;	53,454✔
33	int bc;	53,454✔
34	UNUSED(dummy);	53,454✔
35	cframe_errfunc(L->cframe) = -1; /* Inherit error function. */	53,454✔
36	bc = lj_lex_setup(L, ls);	53,454✔
37	if (ls->mode && !strchr(ls->mode, bc ? 'b' : 't')) {	53,452✔
38	setstrV(L, L->top++, lj_err_str(L, LJ_ERR_XMODE));	×
39	lj_err_throw(L, LUA_ERRSYNTAX);	×
40	}
41	pt = bc ? lj_bcread(ls) : lj_parse(ls);	53,452✔
42	fn = lj_func_newL_empty(L, pt, tabref(L->env));	40,740✔
43	/* Don't combine above/below into one statement. */
44	setfuncV(L, L->top++, fn);	40,740✔
45	return NULL;	40,740✔
46	}
47
48	LUA_API int lua_loadx(lua_State L, lua_Reader reader, void data,	53,454✔
49	const char chunkname, const char mode)
50	{
51	LexState ls;	53,454✔
52	int status;	53,454✔
53	ls.rfunc = reader;	53,454✔
54	ls.rdata = data;	53,454✔
55	ls.chunkarg = chunkname ? chunkname : "?";	53,454✔
56	ls.mode = mode;	53,454✔
57	lj_buf_init(L, &ls.sb);	53,454✔
58	status = lj_vm_cpcall(L, NULL, &ls, cpparser);	53,454✔
59	lj_lex_cleanup(L, &ls);	53,454✔
60	lj_gc_check(L);	53,454✔
61	return status;	53,454✔
62	}
63
64	LUA_API int lua_load(lua_State L, lua_Reader reader, void data,	2✔
65	const char *chunkname)
66	{
67	return lua_loadx(L, reader, data, chunkname, NULL);	2✔
68	}
69
70	typedef struct FileReaderCtx {
71	FILE *fp;
72	char buf[LUAL_BUFFERSIZE];
73	} FileReaderCtx;
74
75	static const char reader_file(lua_State L, void ud, size_t size)	2,245✔
76	{
77	FileReaderCtx ctx = (FileReaderCtx )ud;	2,245✔
78	UNUSED(L);	2,245✔
79	if (feof(ctx->fp)) return NULL;	2,245✔
80	*size = fread(ctx->buf, 1, sizeof(ctx->buf), ctx->fp);	1,348✔
81	return *size > 0 ? ctx->buf : NULL;	1,348✔
82	}
83
84	LUALIB_API int luaL_loadfilex(lua_State L, const char filename,	910✔
85	const char *mode)
86	{
87	FileReaderCtx ctx;	910✔
88	int status;	910✔
89	const char *chunkname;	910✔
90	if (filename) {	910✔
91	ctx.fp = fopen(filename, "rb");	903✔
92	if (ctx.fp == NULL) {	903✔
93	lua_pushfstring(L, "cannot open %s: %s", filename, strerror(errno));	4✔
94	return LUA_ERRFILE;	4✔
95	}
96	chunkname = lua_pushfstring(L, "@%s", filename);	899✔
97	} else {
98	ctx.fp = stdin;	7✔
99	chunkname = "=stdin";	7✔
100	}
101	status = lua_loadx(L, reader_file, &ctx, chunkname, mode);	906✔
102	if (ferror(ctx.fp)) {	906✔
103	L->top -= filename ? 2 : 1;	×
104	lua_pushfstring(L, "cannot read %s: %s", chunkname+1, strerror(errno));	×
105	if (filename)	×
106	fclose(ctx.fp);	×
107	return LUA_ERRFILE;	×
108	}
109	if (filename) {	906✔
110	L->top--;	899✔
111	copyTV(L, L->top-1, L->top);	899✔
112	fclose(ctx.fp);	899✔
113	}
114	return status;
115	}
116
117	LUALIB_API int luaL_loadfile(lua_State L, const char filename)	873✔
118	{
119	return luaL_loadfilex(L, filename, NULL);	873✔
120	}
121
122	typedef struct StringReaderCtx {
123	const char *str;
124	size_t size;
125	} StringReaderCtx;
126
127	static const char reader_string(lua_State L, void ud, size_t size)	95,584✔
128	{
129	StringReaderCtx ctx = (StringReaderCtx )ud;	95,584✔
130	UNUSED(L);	95,584✔
131	if (ctx->size == 0) return NULL;	95,584✔
132	*size = ctx->size;	52,406✔
133	ctx->size = 0;	52,406✔
134	return ctx->str;	52,406✔
135	}
136
137	LUALIB_API int luaL_loadbufferx(lua_State L, const char buf, size_t size,	52,415✔
138	const char name, const char mode)
139	{
140	StringReaderCtx ctx;	52,415✔
141	ctx.str = buf;	52,415✔
142	ctx.size = size;	52,415✔
143	return lua_loadx(L, reader_string, &ctx, name, mode);	52,029✔
144	}
145
146	LUALIB_API int luaL_loadbuffer(lua_State L, const char buf, size_t size,	386✔
147	const char *name)
148	{
149	return luaL_loadbufferx(L, buf, size, name, NULL);	381✔
150	}
151
152	LUALIB_API int luaL_loadstring(lua_State L, const char s)	5✔
153	{
154	return luaL_loadbuffer(L, s, strlen(s), s);	5✔
155	}
156
157	/* -- Dump bytecode ------------------------------------------------------- */
158
159	LUA_API int lua_dump(lua_State L, lua_Writer writer, void data)	×
160	{
161	cTValue *o = L->top-1;	×
162	lj_checkapi(L->top > L->base, "top slot empty");	×
163	if (tvisfunc(o) && isluafunc(funcV(o)))	×
164	return lj_bcwrite(L, funcproto(funcV(o)), writer, data, 0);	×
165	else
166	return 1;
167	}
168

tarantool / luajit / 8062004225

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