7280369395

Committed 20 Dec 2023 08:09PM UTC coverage: 88.911% (+0.3%) from 88.567%

Build # 7280369395

Build Type

push

github

Committed by

igormunkin

Commit Message

FFI: Fix dangling reference to CType in carith_checkarg().

Reported by Sergey Kaplun.

(cherry-picked from commit db944b2b5)

During of an arithmetic operation with a cdata function object and some
cdata value in `carith_checkarg()`, reallocation of `cts->tab` in
`lj_ctype_intern()` may occur. In that case, the reference to the first
`CType` object (`ca->ct[0]`) becomes invalid. This patch saves the
`CTypeID` of this object and gets its `CType` again after possible
reallocation.

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

Part of tarantool/tarantool#9145

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

5404 of 5995 branches covered (0.0%)

Branch coverage included in aggregate %.

3 of 3 new or added lines in 1 file covered. (100.0%)

129 existing lines in 9 files now uncovered.

20694 of 23358 relevant lines covered (88.59%)

2751330.22 hits per line

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

98.65

/src/lj_lex.c

/*
** Lexical analyzer.
** 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-2008 Lua.org, PUC-Rio. See Copyright Notice in lua.h
*/

#define lj_lex_c
#define LUA_CORE

#include "lj_obj.h"
#include "lj_gc.h"
#include "lj_err.h"
#include "lj_buf.h"
#include "lj_str.h"
#if LJ_HASFFI
#include "lj_tab.h"
#include "lj_ctype.h"
#include "lj_cdata.h"
#include "lualib.h"
#endif
#include "lj_state.h"
#include "lj_lex.h"
#include "lj_parse.h"
#include "lj_char.h"
#include "lj_strscan.h"
#include "lj_strfmt.h"

/* Lua lexer token names. */
static const char *const tokennames[] = {
#define TKSTR1(name)                #name,
#define TKSTR2(name, sym)        #sym,
TKDEF(TKSTR1, TKSTR2)
#undef TKSTR1
#undef TKSTR2
  NULL
};

/* -- Buffer handling ----------------------------------------------------- */

#define LEX_EOF                        (-1)
#define lex_iseol(ls)                (ls->c == '\n' || ls->c == '\r')

/* Get more input from reader. */
static LJ_NOINLINE LexChar lex_more(LexState *ls)
{
  size_t sz;
  const char *p = ls->rfunc(ls->L, ls->rdata, &sz);
  if (p == NULL || sz == 0) return LEX_EOF;
  ls->pe = p + sz;
  ls->p = p + 1;
  return (LexChar)(uint8_t)p[0];
}

/* Get next character. */
static LJ_AINLINE LexChar lex_next(LexState *ls)
{
  return (ls->c = ls->p < ls->pe ? (LexChar)(uint8_t)*ls->p++ : lex_more(ls));
}

/* Save character. */
static LJ_AINLINE void lex_save(LexState *ls, LexChar c)
{
  lj_buf_putb(&ls->sb, c);
}

/* Save previous character and get next character. */
static LJ_AINLINE LexChar lex_savenext(LexState *ls)
{
  lex_save(ls, ls->c);
  return lex_next(ls);
}

/* Skip line break. Handles "\n", "\r", "\r\n" or "\n\r". */
static void lex_newline(LexState *ls)
{
  LexChar old = ls->c;
  lj_assertLS(lex_iseol(ls), "bad usage");
  lex_next(ls);  /* Skip "\n" or "\r". */
  if (lex_iseol(ls) && ls->c != old) lex_next(ls);  /* Skip "\n\r" or "\r\n". */
  if (++ls->linenumber >= LJ_MAX_LINE)
    lj_lex_error(ls, ls->tok, LJ_ERR_XLINES);
}

/* -- Scanner for terminals ----------------------------------------------- */

/* Parse a number literal. */
static void lex_number(LexState *ls, TValue *tv)
{
  StrScanFmt fmt;
  LexChar c, xp = 'e';
  lj_assertLS(lj_char_isdigit(ls->c), "bad usage");
  if ((c = ls->c) == '0' && (lex_savenext(ls) | 0x20) == 'x')
    xp = 'p';
  while (lj_char_isident(ls->c) || ls->c == '.' ||
         ((ls->c == '-' || ls->c == '+') && (c | 0x20) == xp)) {
    c = ls->c;
    lex_savenext(ls);
  }
  lex_save(ls, '\0');
  fmt = lj_strscan_scan((const uint8_t *)sbufB(&ls->sb), sbuflen(&ls->sb)-1, tv,
          (LJ_DUALNUM ? STRSCAN_OPT_TOINT : STRSCAN_OPT_TONUM) |
          (LJ_HASFFI ? (STRSCAN_OPT_LL|STRSCAN_OPT_IMAG) : 0));
  if (LJ_DUALNUM && fmt == STRSCAN_INT) {
    setitype(tv, LJ_TISNUM);
  } else if (fmt == STRSCAN_NUM) {
    /* Already in correct format. */
#if LJ_HASFFI
  } else if (fmt != STRSCAN_ERROR) {
    lua_State *L = ls->L;
    GCcdata *cd;
    lj_assertLS(fmt == STRSCAN_I64 || fmt == STRSCAN_U64 || fmt == STRSCAN_IMAG,
                "unexpected number format %d", fmt);
    ctype_loadffi(L);
    if (fmt == STRSCAN_IMAG) {
      cd = lj_cdata_new_(L, CTID_COMPLEX_DOUBLE, 2*sizeof(double));
      ((double *)cdataptr(cd))[0] = 0;
      ((double *)cdataptr(cd))[1] = numV(tv);
    } else {
      cd = lj_cdata_new_(L, fmt==STRSCAN_I64 ? CTID_INT64 : CTID_UINT64, 8);
      *(uint64_t *)cdataptr(cd) = tv->u64;
    }
    lj_parse_keepcdata(ls, tv, cd);
#endif
  } else {
    lj_assertLS(fmt == STRSCAN_ERROR,
                "unexpected number format %d", fmt);
    lj_lex_error(ls, TK_number, LJ_ERR_XNUMBER);
  }
}

/* Skip equal signs for "[=...=[" and "]=...=]" and return their count. */
static int lex_skipeq(LexState *ls)
{
  int count = 0;
  LexChar s = ls->c;
  lj_assertLS(s == '[' || s == ']', "bad usage");
  while (lex_savenext(ls) == '=' && count < 0x20000000)
    count++;
  return (ls->c == s) ? count : (-count) - 1;
}

/* Parse a long string or long comment (tv set to NULL). */
static void lex_longstring(LexState *ls, TValue *tv, int sep)
{
  lex_savenext(ls);  /* Skip second '['. */
  if (lex_iseol(ls))  /* Skip initial newline. */
    lex_newline(ls);
  for (;;) {
    switch (ls->c) {
    case LEX_EOF:
      lj_lex_error(ls, TK_eof, tv ? LJ_ERR_XLSTR : LJ_ERR_XLCOM);
      break;
    case ']':
      if (lex_skipeq(ls) == sep) {
        lex_savenext(ls);  /* Skip second ']'. */
        goto endloop;
      }
      break;
    case '\n':
    case '\r':
      lex_save(ls, '\n');
      lex_newline(ls);
      if (!tv) lj_buf_reset(&ls->sb);  /* Don't waste space for comments. */
      break;
    default:
      lex_savenext(ls);
      break;
    }
  } endloop:
  if (tv) {
    GCstr *str = lj_parse_keepstr(ls, sbufB(&ls->sb) + (2 + (MSize)sep),
                                      sbuflen(&ls->sb) - 2*(2 + (MSize)sep));
    setstrV(ls->L, tv, str);
  }
}

/* Parse a string. */
static void lex_string(LexState *ls, TValue *tv)
{
  LexChar delim = ls->c;  /* Delimiter is '\'' or '"'. */
  lex_savenext(ls);
  while (ls->c != delim) {
    switch (ls->c) {
    case LEX_EOF:
      lj_lex_error(ls, TK_eof, LJ_ERR_XSTR);
      continue;
    case '\n':
    case '\r':
      lj_lex_error(ls, TK_string, LJ_ERR_XSTR);
      continue;
    case '\\': {
      LexChar c = lex_next(ls);  /* Skip the '\\'. */
      switch (c) {
      case 'a': c = '\a'; break;
      case 'b': c = '\b'; break;
      case 'f': c = '\f'; break;
      case 'n': c = '\n'; break;
      case 'r': c = '\r'; break;
      case 't': c = '\t'; break;
      case 'v': c = '\v'; break;
      case 'x':  /* Hexadecimal escape '\xXX'. */
        c = (lex_next(ls) & 15u) << 4;
        if (!lj_char_isdigit(ls->c)) {
          if (!lj_char_isxdigit(ls->c)) goto err_xesc;
          c += 9 << 4;
        }
        c += (lex_next(ls) & 15u);
        if (!lj_char_isdigit(ls->c)) {
          if (!lj_char_isxdigit(ls->c)) goto err_xesc;
          c += 9;
        }
        break;
      case 'u':  /* Unicode escape '\u{XX...}'. */
        if (lex_next(ls) != '{') goto err_xesc;
        lex_next(ls);
        c = 0;
        do {
          c = (c << 4) | (ls->c & 15u);
          if (!lj_char_isdigit(ls->c)) {
            if (!lj_char_isxdigit(ls->c)) goto err_xesc;
            c += 9;
          }
          if (c >= 0x110000) goto err_xesc;  /* Out of Unicode range. */
        } while (lex_next(ls) != '}');
        if (c < 0x800) {
          if (c < 0x80) break;
          lex_save(ls, 0xc0 | (c >> 6));
        } else {
          if (c >= 0x10000) {
            lex_save(ls, 0xf0 | (c >> 18));
            lex_save(ls, 0x80 | ((c >> 12) & 0x3f));
          } else {
            if (c >= 0xd800 && c < 0xe000) goto err_xesc;  /* No surrogates. */
            lex_save(ls, 0xe0 | (c >> 12));
          }
          lex_save(ls, 0x80 | ((c >> 6) & 0x3f));
        }
        c = 0x80 | (c & 0x3f);
        break;
      case 'z':  /* Skip whitespace. */
        lex_next(ls);
        while (lj_char_isspace(ls->c))
          if (lex_iseol(ls)) lex_newline(ls); else lex_next(ls);
        continue;
      case '\n': case '\r': lex_save(ls, '\n'); lex_newline(ls); continue;
      case '\\': case '\"': case '\'': break;
      case LEX_EOF: continue;
      default:
        if (!lj_char_isdigit(c))
          goto err_xesc;
        c -= '0';  /* Decimal escape '\ddd'. */
        if (lj_char_isdigit(lex_next(ls))) {
          c = c*10 + (ls->c - '0');
          if (lj_char_isdigit(lex_next(ls))) {
            c = c*10 + (ls->c - '0');
            if (c > 255) {
            err_xesc:
              lj_lex_error(ls, TK_string, LJ_ERR_XESC);
            }
            lex_next(ls);
          }
        }
        lex_save(ls, c);
        continue;
      }
      lex_save(ls, c);
      lex_next(ls);
      continue;
      }
    default:
      lex_savenext(ls);
      break;
    }
  }
  lex_savenext(ls);  /* Skip trailing delimiter. */
  setstrV(ls->L, tv,
          lj_parse_keepstr(ls, sbufB(&ls->sb)+1, sbuflen(&ls->sb)-2));
}

/* -- Main lexical scanner ------------------------------------------------ */

/* Get next lexical token. */
static LexToken lex_scan(LexState *ls, TValue *tv)
{
  lj_buf_reset(&ls->sb);
  for (;;) {
    if (lj_char_isident(ls->c)) {
      GCstr *s;
      if (lj_char_isdigit(ls->c)) {  /* Numeric literal. */
        lex_number(ls, tv);
        return TK_number;
      }
      /* Identifier or reserved word. */
      do {
        lex_savenext(ls);
      } while (lj_char_isident(ls->c));
      s = lj_parse_keepstr(ls, sbufB(&ls->sb), sbuflen(&ls->sb));
      setstrV(ls->L, tv, s);
      if (s->reserved > 0)  /* Reserved word? */
        return TK_OFS + s->reserved;
      return TK_name;
    }
    switch (ls->c) {
    case '\n':
    case '\r':
      lex_newline(ls);
      continue;
    case ' ':
    case '\t':
    case '\v':
    case '\f':
      lex_next(ls);
      continue;
    case '-':
      lex_next(ls);
      if (ls->c != '-') return '-';
      lex_next(ls);
      if (ls->c == '[') {  /* Long comment "--[=*[...]=*]". */
        int sep = lex_skipeq(ls);
        lj_buf_reset(&ls->sb);  /* `lex_skipeq' may dirty the buffer */
        if (sep >= 0) {
          lex_longstring(ls, NULL, sep);
          lj_buf_reset(&ls->sb);
          continue;
        }
      }
      /* Short comment "--.*\n". */
      while (!lex_iseol(ls) && ls->c != LEX_EOF)
        lex_next(ls);
      continue;
    case '[': {
      int sep = lex_skipeq(ls);
      if (sep >= 0) {
        lex_longstring(ls, tv, sep);
        return TK_string;
      } else if (sep == -1) {
        return '[';
      } else {
        lj_lex_error(ls, TK_string, LJ_ERR_XLDELIM);
        continue;
      }
      }
    case '=':
      lex_next(ls);
      if (ls->c != '=') return '='; else { lex_next(ls); return TK_eq; }
    case '<':
      lex_next(ls);
      if (ls->c != '=') return '<'; else { lex_next(ls); return TK_le; }
    case '>':
      lex_next(ls);
      if (ls->c != '=') return '>'; else { lex_next(ls); return TK_ge; }
    case '~':
      lex_next(ls);
      if (ls->c != '=') return '~'; else { lex_next(ls); return TK_ne; }
    case ':':
      lex_next(ls);
      if (ls->c != ':') return ':'; else { lex_next(ls); return TK_label; }
    case '"':
    case '\'':
      lex_string(ls, tv);
      return TK_string;
    case '.':
      if (lex_savenext(ls) == '.') {
        lex_next(ls);
        if (ls->c == '.') {
          lex_next(ls);
          return TK_dots;   /* ... */
        }
        return TK_concat;   /* .. */
      } else if (!lj_char_isdigit(ls->c)) {
        return '.';
      } else {
        lex_number(ls, tv);
        return TK_number;
      }
    case LEX_EOF:
      return TK_eof;
    default: {
      LexChar c = ls->c;
      lex_next(ls);
      return c;  /* Single-char tokens (+ - / ...). */
    }
    }
  }
}

/* -- Lexer API ----------------------------------------------------------- */

/* Setup lexer state. */
int lj_lex_setup(lua_State *L, LexState *ls)
{
  int header = 0;
  ls->L = L;
  ls->fs = NULL;
  ls->pe = ls->p = NULL;
  ls->vstack = NULL;
  ls->sizevstack = 0;
  ls->vtop = 0;
  ls->bcstack = NULL;
  ls->sizebcstack = 0;
  ls->tok = 0;
  ls->lookahead = TK_eof;  /* No look-ahead token. */
  ls->linenumber = 1;
  ls->lastline = 1;
  lex_next(ls);  /* Read-ahead first char. */
  if (ls->c == 0xef && ls->p + 2 <= ls->pe && (uint8_t)ls->p[0] == 0xbb &&
      (uint8_t)ls->p[1] == 0xbf) {  /* Skip UTF-8 BOM (if buffered). */
    ls->p += 2;
    lex_next(ls);
    header = 1;
  }
  if (ls->c == '#') {  /* Skip POSIX #! header line. */
    do {
      lex_next(ls);
      if (ls->c == LEX_EOF) return 0;
    } while (!lex_iseol(ls));
    lex_newline(ls);
    header = 1;
  }
  if (ls->c == LUA_SIGNATURE[0]) {  /* Bytecode dump. */
    if (header) {
      /*
      ** Loading bytecode with an extra header is disabled for security
      ** reasons. This may circumvent the usual check for bytecode vs.
      ** Lua code by looking at the first char. Since this is a potential
      ** security violation no attempt is made to echo the chunkname either.
      */
      setstrV(L, L->top++, lj_err_str(L, LJ_ERR_BCBAD));
      lj_err_throw(L, LUA_ERRSYNTAX);
    }
    return 1;
  }
  return 0;
}

/* Cleanup lexer state. */
void lj_lex_cleanup(lua_State *L, LexState *ls)
{
  global_State *g = G(L);
  lj_mem_freevec(g, ls->bcstack, ls->sizebcstack, BCInsLine);
  lj_mem_freevec(g, ls->vstack, ls->sizevstack, VarInfo);
  lj_buf_free(g, &ls->sb);
}

/* Return next lexical token. */
void lj_lex_next(LexState *ls)
{
  ls->lastline = ls->linenumber;
  if (LJ_LIKELY(ls->lookahead == TK_eof)) {  /* No lookahead token? */
    ls->tok = lex_scan(ls, &ls->tokval);  /* Get next token. */
  } else {  /* Otherwise return lookahead token. */
    ls->tok = ls->lookahead;
    ls->lookahead = TK_eof;
    ls->tokval = ls->lookaheadval;
  }
}

/* Look ahead for the next token. */
LexToken lj_lex_lookahead(LexState *ls)
{
  lj_assertLS(ls->lookahead == TK_eof, "double lookahead");
  ls->lookahead = lex_scan(ls, &ls->lookaheadval);
  return ls->lookahead;
}

/* Convert token to string. */
const char *lj_lex_token2str(LexState *ls, LexToken tok)
{
  if (tok > TK_OFS)
    return tokennames[tok-TK_OFS-1];
  else if (!lj_char_iscntrl(tok))
    return lj_strfmt_pushf(ls->L, "%c", tok);
  else
    return lj_strfmt_pushf(ls->L, "char(%d)", tok);
}

/* Lexer error. */
void lj_lex_error(LexState *ls, LexToken tok, ErrMsg em, ...)
{
  const char *tokstr;
  va_list argp;
  if (tok == 0) {
    tokstr = NULL;
  } else if (tok == TK_name || tok == TK_string || tok == TK_number) {
    lex_save(ls, '\0');
    tokstr = sbufB(&ls->sb);
  } else {
    tokstr = lj_lex_token2str(ls, tok);
  }
  va_start(argp, em);
  lj_err_lex(ls->L, ls->chunkname, tokstr, ls->linenumber, em, argp);
  va_end(argp);
}

/* Initialize strings for reserved words. */
void lj_lex_init(lua_State *L)
{
  uint32_t i;
  for (i = 0; i < TK_RESERVED; i++) {
    GCstr *s = lj_str_newz(L, tokennames[i]);
    fixstring(s);  /* Reserved words are never collected. */
    s->reserved = (uint8_t)(i+1);
  }
}


1	/*
2	** Lexical analyzer.
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-2008 Lua.org, PUC-Rio. See Copyright Notice in lua.h
7	*/
8
9	#define lj_lex_c
10	#define LUA_CORE
11
12	#include "lj_obj.h"
13	#include "lj_gc.h"
14	#include "lj_err.h"
15	#include "lj_buf.h"
16	#include "lj_str.h"
17	#if LJ_HASFFI
18	#include "lj_tab.h"
19	#include "lj_ctype.h"
20	#include "lj_cdata.h"
21	#include "lualib.h"
22	#endif
23	#include "lj_state.h"
24	#include "lj_lex.h"
25	#include "lj_parse.h"
26	#include "lj_char.h"
27	#include "lj_strscan.h"
28	#include "lj_strfmt.h"
29
30	/* Lua lexer token names. */
31	static const char *const tokennames[] = {
32	#define TKSTR1(name) #name,
33	#define TKSTR2(name, sym) #sym,
34	TKDEF(TKSTR1, TKSTR2)
35	#undef TKSTR1
36	#undef TKSTR2
37	NULL
38	};
39
40	/* -- Buffer handling ----------------------------------------------------- */
41
42	#define LEX_EOF (-1)
43	#define lex_iseol(ls) (ls->c == '\n' \|\| ls->c == '\r')
44
45	/* Get more input from reader. */
46	static LJ_NOINLINE LexChar lex_more(LexState *ls)	97,181✔
47	{
48	size_t sz;	97,181✔
49	const char *p = ls->rfunc(ls->L, ls->rdata, &sz);	97,181✔
50	if (p == NULL \|\| sz == 0) return LEX_EOF;	97,179✔
51	ls->pe = p + sz;	53,567✔
52	ls->p = p + 1;	53,567✔
53	return (LexChar)(uint8_t)p[0];	53,567✔
54	}
55
56	/* Get next character. */
57	static LJ_AINLINE LexChar lex_next(LexState *ls)	558,072,071✔
58	{
59	return (ls->c = ls->p < ls->pe ? (LexChar)(uint8_t)*ls->p++ : lex_more(ls));	558,019,210✔
60	}
61
62	/* Save character. */
63	static LJ_AINLINE void lex_save(LexState *ls, LexChar c)	547,363,965✔
64	{
65	lj_buf_putb(&ls->sb, c);	1,094,727,930✔
66	}
67
68	/* Save previous character and get next character. */
69	static LJ_AINLINE LexChar lex_savenext(LexState *ls)	546,656,696✔
70	{
71	lex_save(ls, ls->c);	12,738✔
72	return lex_next(ls);	548,898,826✔
73	}
74
75	/* Skip line break. Handles "\n", "\r", "\r\n" or "\n\r". */
76	static void lex_newline(LexState *ls)	716,864✔
77	{
78	LexChar old = ls->c;	716,864✔
79	lj_assertLS(lex_iseol(ls), "bad usage");	716,864✔
80	lex_next(ls); /* Skip "\n" or "\r". */	716,864✔
81	if (lex_iseol(ls) && ls->c != old) lex_next(ls); /* Skip "\n\r" or "\r\n". */	716,864✔
82	if (++ls->linenumber >= LJ_MAX_LINE)	716,864✔
83	lj_lex_error(ls, ls->tok, LJ_ERR_XLINES);	×
84	}	716,864✔
85
86	/* -- Scanner for terminals ----------------------------------------------- */
87
88	/* Parse a number literal. */
89	static void lex_number(LexState ls, TValue tv)	698,690✔
90	{
91	StrScanFmt fmt;	698,690✔
92	LexChar c, xp = 'e';	698,690✔
93	lj_assertLS(lj_char_isdigit(ls->c), "bad usage");	698,690✔
94	if ((c = ls->c) == '0' && (lex_savenext(ls) \| 0x20) == 'x')	711,428✔
95	xp = 'p';	572✔
96	while (lj_char_isident(ls->c) \|\| ls->c == '.' \|\|	902,613✔
97	((ls->c == '-' \|\| ls->c == '+') && (c \| 0x20) == xp)) {	701,338✔
98	c = ls->c;	2,112,323✔
99	lex_savenext(ls);	3,014,936✔
100	}
101	lex_save(ls, '\0');	698,690✔
102	fmt = lj_strscan_scan((const uint8_t *)sbufB(&ls->sb), sbuflen(&ls->sb)-1, tv,	698,690✔
103	(LJ_DUALNUM ? STRSCAN_OPT_TOINT : STRSCAN_OPT_TONUM) \|
104	(LJ_HASFFI ? (STRSCAN_OPT_LL\|STRSCAN_OPT_IMAG) : 0));
105	if (LJ_DUALNUM && fmt == STRSCAN_INT) {	698,690✔
106	setitype(tv, LJ_TISNUM);
107	} else if (fmt == STRSCAN_NUM) {	698,690✔
108	/* Already in correct format. */
109	#if LJ_HASFFI
110	} else if (fmt != STRSCAN_ERROR) {	197✔
111	lua_State *L = ls->L;	142✔
112	GCcdata *cd;	142✔
113	lj_assertLS(fmt == STRSCAN_I64 \|\| fmt == STRSCAN_U64 \|\| fmt == STRSCAN_IMAG,	142✔
114	"unexpected number format %d", fmt);
115	ctype_loadffi(L);	142✔
116	if (fmt == STRSCAN_IMAG) {	142✔
117	cd = lj_cdata_new_(L, CTID_COMPLEX_DOUBLE, 2*sizeof(double));	9✔
118	((double *)cdataptr(cd))[0] = 0;	9✔
119	((double *)cdataptr(cd))[1] = numV(tv);	9✔
120	} else {
121	cd = lj_cdata_new_(L, fmt==STRSCAN_I64 ? CTID_INT64 : CTID_UINT64, 8);	133✔
122	(uint64_t )cdataptr(cd) = tv->u64;	133✔
123	}
124	lj_parse_keepcdata(ls, tv, cd);	142✔
125	#endif
126	} else {
127	lj_assertLS(fmt == STRSCAN_ERROR,	55✔
128	"unexpected number format %d", fmt);
129	lj_lex_error(ls, TK_number, LJ_ERR_XNUMBER);	55✔
130	}
131	}	698,635✔
132
133	/* Skip equal signs for "[=...=[" and "]=...=]" and return their count. */
134	static int lex_skipeq(LexState *ls)	12,335✔
135	{
136	int count = 0;	12,335✔
137	LexChar s = ls->c;	12,335✔
138	lj_assertLS(s == '[' \|\| s == ']', "bad usage");	12,335✔
139	while (lex_savenext(ls) == '=' && count < 0x20000000)	1,073,770,894✔
140	count++;	536,873,112✔
141	return (ls->c == s) ? count : (-count) - 1;	12,335✔
142	}
143
144	/* Parse a long string or long comment (tv set to NULL). */
145	static void lex_longstring(LexState ls, TValue tv, int sep)	1,269✔
146	{
147	lex_savenext(ls); /* Skip second '['. */	1,269✔
148	if (lex_iseol(ls)) /* Skip initial newline. */	1,269✔
149	lex_newline(ls);	769✔
150	for (;;) {	137,137✔
151	switch (ls->c) {	137,137✔
152	case LEX_EOF:	15✔
153	lj_lex_error(ls, TK_eof, tv ? LJ_ERR_XLSTR : LJ_ERR_XLCOM);	24✔
154	break;	1,948✔
155	case ']':	1,948✔
156	if (lex_skipeq(ls) == sep) {	1,948✔
157	lex_savenext(ls); /* Skip second ']'. */	1,254✔
158	goto endloop;	1,254✔
159	}
160	break;
161	case '\n':
162	case '\r':
163	lex_save(ls, '\n');	5,367✔
164	lex_newline(ls);	5,367✔
165	if (!tv) lj_buf_reset(&ls->sb); /* Don't waste space for comments. */	5,367✔
166	break;
167	default:
168	lex_savenext(ls);	137,137✔
169	break;
170	}
171	} endloop:	1,254✔
172	if (tv) {	1,254✔
173	GCstr *str = lj_parse_keepstr(ls, sbufB(&ls->sb) + (2 + (MSize)sep),	1,748✔
174	sbuflen(&ls->sb) - 2*(2 + (MSize)sep));	874✔
175	setstrV(ls->L, tv, str);	874✔
176	}
177	}	1,254✔
178
179	/* Parse a string. */
180	static void lex_string(LexState ls, TValue tv)
181	{
182	LexChar delim = ls->c; /* Delimiter is '\'' or '"'. */
183	lex_savenext(ls);
184	while (ls->c != delim) {
185	switch (ls->c) {
186	case LEX_EOF:
187	lj_lex_error(ls, TK_eof, LJ_ERR_XSTR);
188	continue;
189	case '\n':
190	case '\r':
191	lj_lex_error(ls, TK_string, LJ_ERR_XSTR);
192	continue;
193	case '\\': {
194	LexChar c = lex_next(ls); /* Skip the '\\'. */
195	switch (c) {
196	case 'a': c = '\a'; break;
197	case 'b': c = '\b'; break;
198	case 'f': c = '\f'; break;
199	case 'n': c = '\n'; break;
200	case 'r': c = '\r'; break;
201	case 't': c = '\t'; break;
202	case 'v': c = '\v'; break;
203	case 'x': /* Hexadecimal escape '\xXX'. */
204	c = (lex_next(ls) & 15u) << 4;
205	if (!lj_char_isdigit(ls->c)) {
206	if (!lj_char_isxdigit(ls->c)) goto err_xesc;
207	c += 9 << 4;
208	}
209	c += (lex_next(ls) & 15u);
210	if (!lj_char_isdigit(ls->c)) {
211	if (!lj_char_isxdigit(ls->c)) goto err_xesc;
212	c += 9;
213	}
214	break;
215	case 'u': /* Unicode escape '\u{XX...}'. */
216	if (lex_next(ls) != '{') goto err_xesc;
217	lex_next(ls);
218	c = 0;
219	do {
220	c = (c << 4) \| (ls->c & 15u);
221	if (!lj_char_isdigit(ls->c)) {
222	if (!lj_char_isxdigit(ls->c)) goto err_xesc;
223	c += 9;
224	}
225	if (c >= 0x110000) goto err_xesc; /* Out of Unicode range. */
226	} while (lex_next(ls) != '}');
227	if (c < 0x800) {
228	if (c < 0x80) break;
229	lex_save(ls, 0xc0 \| (c >> 6));
230	} else {
231	if (c >= 0x10000) {
232	lex_save(ls, 0xf0 \| (c >> 18));
233	lex_save(ls, 0x80 \| ((c >> 12) & 0x3f));
234	} else {
235	if (c >= 0xd800 && c < 0xe000) goto err_xesc; /* No surrogates. */
236	lex_save(ls, 0xe0 \| (c >> 12));
237	}
238	lex_save(ls, 0x80 \| ((c >> 6) & 0x3f));
239	}
240	c = 0x80 \| (c & 0x3f);
241	break;
242	case 'z': /* Skip whitespace. */
243	lex_next(ls);
244	while (lj_char_isspace(ls->c))
245	if (lex_iseol(ls)) lex_newline(ls); else lex_next(ls);
246	continue;
247	case '\n': case '\r': lex_save(ls, '\n'); lex_newline(ls); continue;
248	case '\\': case '\"': case '\'': break;
249	case LEX_EOF: continue;
250	default:
251	if (!lj_char_isdigit(c))
252	goto err_xesc;
253	c -= '0'; /* Decimal escape '\ddd'. */
254	if (lj_char_isdigit(lex_next(ls))) {
255	c = c*10 + (ls->c - '0');
256	if (lj_char_isdigit(lex_next(ls))) {
257	c = c*10 + (ls->c - '0');
258	if (c > 255) {
259	err_xesc:
260	lj_lex_error(ls, TK_string, LJ_ERR_XESC);
261	}
262	lex_next(ls);
263	}
264	}
265	lex_save(ls, c);
266	continue;
267	}
268	lex_save(ls, c);
269	lex_next(ls);
270	continue;
271	}
272	default:
273	lex_savenext(ls);
274	break;
275	}
276	}
277	lex_savenext(ls); /* Skip trailing delimiter. */
278	setstrV(ls->L, tv,
279	lj_parse_keepstr(ls, sbufB(&ls->sb)+1, sbuflen(&ls->sb)-2));
280	}
281
282	/* -- Main lexical scanner ------------------------------------------------ */
283
284	/* Get next lexical token. */
285	static LexToken lex_scan(LexState ls, TValue tv)	6,624,131✔
286	{
287	lj_buf_reset(&ls->sb);	6,624,131✔
288	for (;;) {	14,178,536✔
289	if (lj_char_isident(ls->c)) {	14,178,536✔
290	GCstr *s;	3,366,009✔
291	if (lj_char_isdigit(ls->c)) { /* Numeric literal. */	3,366,009✔
292	lex_number(ls, tv);	698,481✔
293	return TK_number;	698,481✔
294	}
295	/* Identifier or reserved word. */
296	do {	7,330,748✔
297	lex_savenext(ls);	7,330,748✔
298	} while (lj_char_isident(ls->c));	7,330,748✔
299	s = lj_parse_keepstr(ls, sbufB(&ls->sb), sbuflen(&ls->sb));	2,667,528✔
300	setstrV(ls->L, tv, s);	2,667,528✔
301	if (s->reserved > 0) /* Reserved word? */	2,667,528✔
302	return TK_OFS + s->reserved;	1,152,158✔
303	return TK_name;
304	}
305	switch (ls->c) {	10,812,527✔
306	case '\n':	710,605✔
307	case '\r':
308	lex_newline(ls);	710,605✔
309	continue;	710,605✔
310	case ' ':
311	case '\t':
312	case '\v':
313	case '\f':
314	lex_next(ls);	6,825,680✔
315	continue;	6,825,680✔
316	case '-':
317	lex_next(ls);	24,559✔
318	if (ls->c != '-') return '-';	24,559✔
319	lex_next(ls);	18,129✔
320	if (ls->c == '[') { /* Long comment "--[=[...]=]". */	18,129✔
321	int sep = lex_skipeq(ls);	390✔
322	lj_buf_reset(&ls->sb); /* `lex_skipeq' may dirty the buffer */	390✔
323	if (sep >= 0) {	390✔
324	lex_longstring(ls, NULL, sep);	389✔
325	lj_buf_reset(&ls->sb);	380✔
326	continue;	380✔
327	}
328	}
329	/* Short comment "--.\n". /
330	while (!lex_iseol(ls) && ls->c != LEX_EOF)	729,196✔
331	lex_next(ls);	1,476,120✔
332	continue;	17,740✔
333	case '[': {	9,997✔
334	int sep = lex_skipeq(ls);	9,997✔
335	if (sep >= 0) {	9,997✔
336	lex_longstring(ls, tv, sep);	880✔
337	return TK_string;	880✔
338	} else if (sep == -1) {	9,117✔
339	return '[';
340	} else {
341	lj_lex_error(ls, TK_string, LJ_ERR_XLDELIM);	2✔
342	continue;	677,369✔
343	}
344	}
345	case '=':
346	lex_next(ls);	677,369✔
347	if (ls->c != '=') return '='; else { lex_next(ls); return TK_eq; }	750,711✔
348	case '<':
349	lex_next(ls);	98,953✔
350	if (ls->c != '=') return '<'; else { lex_next(ls); return TK_le; }	99,240✔
351	case '>':
352	lex_next(ls);	99,127✔
353	if (ls->c != '=') return '>'; else { lex_next(ls); return TK_ge; }	197,782✔
354	case '~':
355	lex_next(ls);	68,593✔
356	if (ls->c != '=') return '~'; else { lex_next(ls); return TK_ne; }	137,186✔
357	case ':':
358	lex_next(ls);	6,184✔
359	if (ls->c != ':') return ':'; else { lex_next(ls); return TK_label; }	6,252✔
360	case '"':	215,823✔
361	case '\'':
362	lex_string(ls, tv);	215,823✔
363	return TK_string;	215,823✔
364	case '.':
365	if (lex_savenext(ls) == '.') {	366,220✔
366	lex_next(ls);	5,675✔
367	if (ls->c == '.') {	5,675✔
368	lex_next(ls);	1,118✔
369	return TK_dots; /* ... */	1,118✔
370	}
371	return TK_concat; /* .. */
372	} else if (!lj_char_isdigit(ls->c)) {	177,435✔
373	return '.';
374	} else {
375	lex_number(ls, tv);	209✔
376	return TK_number;	209✔
377	}
378	case LEX_EOF:
379	return TK_eof;
380	default: {	1,849,266✔
381	LexChar c = ls->c;	1,849,266✔
382	lex_next(ls);	1,849,266✔
383	return c; /* Single-char tokens (+ - / ...). */	1,849,266✔
384	}
385	}
386	}
387	}
388
389	/* -- Lexer API ----------------------------------------------------------- */
390
391	/* Setup lexer state. */
392	int lj_lex_setup(lua_State L, LexState ls)	52,861✔
393	{
394	int header = 0;	52,861✔
395	ls->L = L;	52,861✔
396	ls->fs = NULL;	52,861✔
397	ls->pe = ls->p = NULL;	52,861✔
398	ls->vstack = NULL;	52,861✔
399	ls->sizevstack = 0;	52,861✔
400	ls->vtop = 0;	52,861✔
401	ls->bcstack = NULL;	52,861✔
402	ls->sizebcstack = 0;	52,861✔
403	ls->tok = 0;	52,861✔
404	ls->lookahead = TK_eof; /* No look-ahead token. */	52,861✔
405	ls->linenumber = 1;	52,861✔
406	ls->lastline = 1;	52,861✔
407	lex_next(ls); /* Read-ahead first char. */	52,861✔
408	if (ls->c == 0xef && ls->p + 2 <= ls->pe && (uint8_t)ls->p[0] == 0xbb &&	52,859✔
409	(uint8_t)ls->p[1] == 0xbf) { /* Skip UTF-8 BOM (if buffered). */	1✔
410	ls->p += 2;	1✔
411	lex_next(ls);	1✔
412	header = 1;	1✔
413	}
414	if (ls->c == '#') { /* Skip POSIX #! header line. */	52,859✔
415	do {	839✔
416	lex_next(ls);	839✔
417	if (ls->c == LEX_EOF) return 0;	839✔
418	} while (!lex_iseol(ls));	838✔
419	lex_newline(ls);	52✔
420	header = 1;	52✔
421	}
422	if (ls->c == LUA_SIGNATURE[0]) { /* Bytecode dump. */	52,858✔
423	if (header) {	39✔
424	/*
425	** Loading bytecode with an extra header is disabled for security
426	** reasons. This may circumvent the usual check for bytecode vs.
427	** Lua code by looking at the first char. Since this is a potential
428	** security violation no attempt is made to echo the chunkname either.
429	*/
UNCOV 430	setstrV(L, L->top++, lj_err_str(L, LJ_ERR_BCBAD));	×
UNCOV 431	lj_err_throw(L, LUA_ERRSYNTAX);	×
432	}
433	return 1;
434	}
435	return 0;
436	}
437
438	/* Cleanup lexer state. */
439	void lj_lex_cleanup(lua_State L, LexState ls)	52,861✔
440	{
441	global_State *g = G(L);	52,861✔
442	lj_mem_freevec(g, ls->bcstack, ls->sizebcstack, BCInsLine);	52,861✔
443	lj_mem_freevec(g, ls->vstack, ls->sizevstack, VarInfo);	52,861✔
444	lj_buf_free(g, &ls->sb);	52,861✔
445	}	52,861✔
446
447	/* Return next lexical token. */
448	void lj_lex_next(LexState *ls)	6,624,131✔
449	{
450	ls->lastline = ls->linenumber;	6,624,131✔
451	if (LJ_LIKELY(ls->lookahead == TK_eof)) { /* No lookahead token? */	6,624,131✔
452	ls->tok = lex_scan(ls, &ls->tokval); /* Get next token. */	6,545,137✔
453	} else { /* Otherwise return lookahead token. */
454	ls->tok = ls->lookahead;	78,994✔
455	ls->lookahead = TK_eof;	78,994✔
456	ls->tokval = ls->lookaheadval;	78,994✔
457	}
458	}	6,624,047✔
459
460	/* Look ahead for the next token. */
461	LexToken lj_lex_lookahead(LexState *ls)	78,994✔
462	{
463	lj_assertLS(ls->lookahead == TK_eof, "double lookahead");	78,994✔
464	ls->lookahead = lex_scan(ls, &ls->lookaheadval);	78,994✔
465	return ls->lookahead;	78,994✔
466	}
467
468	/* Convert token to string. */
469	const char lj_lex_token2str(LexState ls, LexToken tok)	14,967✔
470	{
471	if (tok > TK_OFS)	14,967✔
472	return tokennames[tok-TK_OFS-1];	5,685✔
473	else if (!lj_char_iscntrl(tok))	9,282✔
474	return lj_strfmt_pushf(ls->L, "%c", tok);	9,282✔
475	else
UNCOV 476	return lj_strfmt_pushf(ls->L, "char(%d)", tok);	×
477	}
478
479	/* Lexer error. */
480	void lj_lex_error(LexState *ls, LexToken tok, ErrMsg em, ...)	12,702✔
481	{
482	const char *tokstr;	12,702✔
483	va_list argp;	12,702✔
484	if (tok == 0) {	12,702✔
485	tokstr = NULL;
486	} else if (tok == TK_name \|\| tok == TK_string \|\| tok == TK_number) {	12,675✔
487	lex_save(ls, '\0');	3,212✔
488	tokstr = sbufB(&ls->sb);	3,212✔
489	} else {
490	tokstr = lj_lex_token2str(ls, tok);	9,463✔
491	}
492	va_start(argp, em);	12,702✔
493	lj_err_lex(ls->L, ls->chunkname, tokstr, ls->linenumber, em, argp);	12,702✔
494	va_end(argp);
495	}
496
497	/* Initialize strings for reserved words. */
498	void lj_lex_init(lua_State *L)	278✔
499	{
500	uint32_t i;	278✔
501	for (i = 0; i < TK_RESERVED; i++) {	6,394✔
502	GCstr *s = lj_str_newz(L, tokennames[i]);	6,116✔
503	fixstring(s); /* Reserved words are never collected. */	6,116✔
504	s->reserved = (uint8_t)(i+1);	6,116✔
505	}
506	}	278✔
507

tarantool / luajit / 7280369395

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