From 72659a06050632da1a9b4c492302be46ac283f6b Mon Sep 17 00:00:00 2001 From: Roberto Ierusalimschy Date: Wed, 28 Nov 2001 18:13:13 -0200 Subject: no more explicit support for wide-chars; too much troble... --- lparser.c | 167 +++++++++++++++++++++++++++++++------------------------------- 1 file changed, 83 insertions(+), 84 deletions(-) (limited to 'lparser.c') diff --git a/lparser.c b/lparser.c index 744c9ce6..f5d722c4 100644 --- a/lparser.c +++ b/lparser.c @@ -1,5 +1,5 @@ /* -** $Id: lparser.c,v 1.159 2001/10/02 16:41:36 roberto Exp $ +** $Id: lparser.c,v 1.160 2001/10/25 19:14:14 roberto Exp $ ** Lua Parser ** See Copyright Notice in lua.h */ @@ -8,7 +8,6 @@ #include #include -#define LUA_PRIVATE #include "lua.h" #include "lcode.h" @@ -76,9 +75,9 @@ static void lookahead (LexState *ls) { static void error_expected (LexState *ls, int token) { - l_char buff[30], t[TOKEN_LEN]; + char buff[30], t[TOKEN_LEN]; luaX_token2str(token, t); - sprintf(buff, l_s("`%.10s' expected"), t); + sprintf(buff, "`%.10s' expected", t); luaK_error(ls, buff); } @@ -90,7 +89,7 @@ static void check (LexState *ls, int c) { } -static void check_condition (LexState *ls, int c, const l_char *msg) { +static void check_condition (LexState *ls, int c, const char *msg) { if (!c) luaK_error(ls, msg); } @@ -109,11 +108,11 @@ static void check_match (LexState *ls, int what, int who, int where) { if (where == ls->linenumber) error_expected(ls, what); else { - l_char buff[70]; - l_char t_what[TOKEN_LEN], t_who[TOKEN_LEN]; + char buff[70]; + char t_what[TOKEN_LEN], t_who[TOKEN_LEN]; luaX_token2str(what, t_what); luaX_token2str(who, t_who); - sprintf(buff, l_s("`%.10s' expected (to close `%.10s' at line %d)"), + sprintf(buff, "`%.10s' expected (to close `%.10s' at line %d)", t_what, t_who, where); luaK_error(ls, buff); } @@ -123,7 +122,7 @@ static void check_match (LexState *ls, int what, int who, int where) { static TString *str_checkname (LexState *ls) { - check_condition(ls, (ls->t.token == TK_NAME), l_s(" expected")); + check_condition(ls, (ls->t.token == TK_NAME), " expected"); return ls->t.seminfo.ts; } @@ -150,7 +149,7 @@ static int luaI_registerlocalvar (LexState *ls, TString *varname) { FuncState *fs = ls->fs; Proto *f = fs->f; luaM_growvector(ls->L, f->locvars, fs->nlocvars, f->sizelocvars, - LocVar, MAX_INT, l_s("")); + LocVar, MAX_INT, ""); f->locvars[fs->nlocvars].varname = varname; return fs->nlocvars++; } @@ -158,7 +157,7 @@ static int luaI_registerlocalvar (LexState *ls, TString *varname) { static void new_localvar (LexState *ls, TString *name, int n) { FuncState *fs = ls->fs; - luaX_checklimit(ls, fs->nactloc+n+1, MAXLOCALS, l_s("local variables")); + luaX_checklimit(ls, fs->nactloc+n+1, MAXLOCALS, "local variables"); fs->actloc[fs->nactloc+n] = luaI_registerlocalvar(ls, name); } @@ -194,7 +193,7 @@ static void removelocalvars (LexState *ls, int nvars, int toclose) { } -static void new_localvarstr (LexState *ls, const l_char *name, int n) { +static void new_localvarstr (LexState *ls, const char *name, int n) { new_localvar(ls, luaS_new(ls->L, name), n); } @@ -206,7 +205,7 @@ static int indexupvalue (FuncState *fs, expdesc *v) { return i; } /* new one */ - luaX_checklimit(fs->ls, fs->f->nupvalues+1, MAXUPVALUES, l_s("upvalues")); + luaX_checklimit(fs->ls, fs->f->nupvalues+1, MAXUPVALUES, "upvalues"); fs->upvalues[fs->f->nupvalues] = *v; return fs->f->nupvalues++; } @@ -263,11 +262,11 @@ static void adjust_assign (LexState *ls, int nvars, int nexps, expdesc *e) { static void code_params (LexState *ls, int nparams, short dots) { FuncState *fs = ls->fs; adjustlocalvars(ls, nparams); - luaX_checklimit(ls, fs->nactloc, MAXPARAMS, l_s("parameters")); + luaX_checklimit(ls, fs->nactloc, MAXPARAMS, "parameters"); fs->f->numparams = cast(short, fs->nactloc); /* `self' could be there already */ fs->f->is_vararg = dots; if (dots) { - new_localvarstr(ls, l_s("arg"), 0); + new_localvarstr(ls, "arg", 0); adjustlocalvars(ls, 1); } luaK_reserveregs(fs, fs->nactloc); /* reserve register for parameters */ @@ -294,7 +293,7 @@ static void pushclosure (LexState *ls, FuncState *func, expdesc *v) { Proto *f = fs->f; int i; luaM_growvector(ls->L, f->p, fs->np, f->sizep, Proto *, - MAXARG_Bc, l_s("constant table overflow")); + MAXARG_Bc, "constant table overflow"); f->p[fs->np++] = func->f; init_exp(v, VRELOCABLE, luaK_codeABc(fs, OP_CLOSURE, 0, fs->np-1)); for (i=0; if->nupvalues; i++) { @@ -366,7 +365,7 @@ Proto *luaY_parser (lua_State *L, ZIO *z) { next(&lexstate); /* read first token */ chunk(&lexstate); check_condition(&lexstate, (lexstate.t.token == TK_EOS), - l_s(" expected")); + " expected"); close_func(&lexstate); lua_assert(funcstate.prev == NULL); lua_assert(funcstate.f->nupvalues == 0); @@ -396,7 +395,7 @@ static void luaY_index (LexState *ls, expdesc *v) { next(ls); /* skip the '[' */ expr(ls, v); luaK_exp2val(ls->fs, v); - check(ls, l_c(']')); + check(ls, ']'); } @@ -404,7 +403,7 @@ static int explist1 (LexState *ls, expdesc *v) { /* explist1 -> expr { `,' expr } */ int n = 1; /* at least one expression */ expr(ls, v); - while (ls->t.token == l_c(',')) { + while (ls->t.token == ',') { next(ls); /* skip comma */ luaK_exp2nextreg(ls->fs, v); expr(ls, v); @@ -419,21 +418,21 @@ static void funcargs (LexState *ls, expdesc *f) { expdesc args; int base, nparams; switch (ls->t.token) { - case l_c('('): { /* funcargs -> `(' [ explist1 ] `)' */ + case '(': { /* funcargs -> `(' [ explist1 ] `)' */ int line = ls->linenumber; if (line != ls->lastline) - luaK_error(ls, l_s("ambiguous syntax (function call x new statement)")); + luaK_error(ls, "ambiguous syntax (function call x new statement)"); next(ls); - if (ls->t.token == l_c(')')) /* arg list is empty? */ + if (ls->t.token == ')') /* arg list is empty? */ args.k = VVOID; else { explist1(ls, &args); luaK_setcallreturns(fs, &args, LUA_MULTRET); } - check_match(ls, l_c(')'), l_c('('), line); + check_match(ls, ')', '(', line); break; } - case l_c('{'): { /* funcargs -> constructor */ + case '{': { /* funcargs -> constructor */ constructor(ls, &args); break; } @@ -443,7 +442,7 @@ static void funcargs (LexState *ls, expdesc *f) { break; } default: { - luaK_error(ls, l_s("function arguments expected")); + luaK_error(ls, "function arguments expected"); break; } } @@ -480,13 +479,13 @@ static void recfield (LexState *ls, expdesc *t) { checkname(ls, &key); break; } - case l_c('['): { + case '[': { luaY_index(ls, &key); break; } - default: luaK_error(ls, l_s(" or `[' expected")); + default: luaK_error(ls, " or `[' expected"); } - check(ls, l_c('=')); + check(ls, '='); luaK_exp2RK(fs, &key); expr(ls, &val); luaK_exp2anyreg(fs, &val); @@ -497,9 +496,9 @@ static void recfield (LexState *ls, expdesc *t) { static int anotherfield (LexState *ls) { - if (ls->t.token != l_c(',')) return 0; + if (ls->t.token != ',') return 0; next(ls); /* skip the comma */ - return (ls->t.token != l_c(';') && ls->t.token != l_c('}')); + return (ls->t.token != ';' && ls->t.token != '}'); } @@ -508,7 +507,7 @@ static int recfields (LexState *ls, expdesc *t) { int n = 0; do { /* at least one element */ recfield(ls, t); - luaX_checklimit(ls, n, MAX_INT, l_s("items in a constructor")); + luaX_checklimit(ls, n, MAX_INT, "items in a constructor"); n++; } while (anotherfield(ls)); return n; @@ -525,7 +524,7 @@ static int listfields (LexState *ls, expdesc *t) { expr(ls, &v); while (anotherfield(ls)) { luaK_exp2nextreg(fs, &v); - luaX_checklimit(ls, n, MAXARG_Bc, l_s("items in a constructor")); + luaX_checklimit(ls, n, MAXARG_Bc, "items in a constructor"); if (n%LFIELDS_PER_FLUSH == 0) { luaK_codeABc(fs, OP_SETLIST, t->u.i.info, n-1); /* flush */ fs->freereg = reg; /* free registers */ @@ -548,18 +547,18 @@ static int listfields (LexState *ls, expdesc *t) { static void constructor_part (LexState *ls, expdesc *t, Constdesc *cd) { switch (ls->t.token) { - case l_c(';'): case l_c('}'): { /* constructor_part -> empty */ + case ';': case '}': { /* constructor_part -> empty */ cd->narray = cd->nhash = 0; cd->k = ls->t.token; break; } case TK_NAME: { /* may be listfields or recfields */ lookahead(ls); - if (ls->lookahead.token != l_c('=')) /* expression? */ + if (ls->lookahead.token != '=') /* expression? */ goto case_default; /* else go through to recfields */ } - case l_c('['): { /* constructor_part -> recfields */ + case '[': { /* constructor_part -> recfields */ cd->nhash = recfields(ls, t); cd->narray = 0; cd->k = 1; /* record */ @@ -586,18 +585,18 @@ static void constructor (LexState *ls, expdesc *t) { pc = luaK_codeABC(fs, OP_NEWTABLE, 0, 0, 0); init_exp(t, VRELOCABLE, pc); luaK_exp2nextreg(ls->fs, t); /* fix it at stack top (for gc) */ - check(ls, l_c('{')); + check(ls, '{'); constructor_part(ls, t, &cd); na = cd.narray; nh = cd.nhash; - if (optional(ls, l_c(';'))) { + if (optional(ls, ';')) { Constdesc other_cd; constructor_part(ls, t, &other_cd); - check_condition(ls,(cd.k != other_cd.k), l_s("invalid constructor syntax")); + check_condition(ls,(cd.k != other_cd.k), "invalid constructor syntax"); na += other_cd.narray; nh += other_cd.nhash; } - check_match(ls, l_c('}'), l_c('{'), line); + check_match(ls, '}', '{', line); if (na > 0) SETARG_B(fs->f->code[pc], luaO_log2(na-1)+2); /* set initial table size */ SETARG_C(fs->f->code[pc], luaO_log2(nh)+1); /* set initial table size */ @@ -618,10 +617,10 @@ static void constructor (LexState *ls, expdesc *t) { static void prefixexp (LexState *ls, expdesc *v) { /* prefixexp -> NAME | '(' expr ')' */ switch (ls->t.token) { - case l_c('('): { + case '(': { next(ls); expr(ls, v); - check(ls, l_c(')')); + check(ls, ')'); luaK_dischargevars(ls->fs, v); return; } @@ -630,15 +629,15 @@ static void prefixexp (LexState *ls, expdesc *v) { next(ls); return; } - case l_c('%'): { /* for compatibility only */ + case '%': { /* for compatibility only */ next(ls); /* skip `%' */ singlevar(ls->fs, str_checkname(ls), v, 1); - check_condition(ls, v->k == VUPVAL, l_s("global upvalues are obsolete")); + check_condition(ls, v->k == VUPVAL, "global upvalues are obsolete"); next(ls); return; } default: { - luaK_error(ls, l_s("unexpected symbol")); + luaK_error(ls, "unexpected symbol"); return; } } @@ -652,18 +651,18 @@ static void primaryexp (LexState *ls, expdesc *v) { prefixexp(ls, v); for (;;) { switch (ls->t.token) { - case l_c('.'): { /* field */ + case '.': { /* field */ luaY_field(ls, v); break; } - case l_c('['): { /* `[' exp1 `]' */ + case '[': { /* `[' exp1 `]' */ expdesc key; luaK_exp2anyreg(fs, v); luaY_index(ls, &key); luaK_indexed(fs, v, &key); break; } - case l_c(':'): { /* `:' NAME funcargs */ + case ':': { /* `:' NAME funcargs */ expdesc key; next(ls); checkname(ls, &key); @@ -671,7 +670,7 @@ static void primaryexp (LexState *ls, expdesc *v) { funcargs(ls, v); break; } - case l_c('('): case TK_STRING: case l_c('{'): { /* funcargs */ + case '(': case TK_STRING: case '{': { /* funcargs */ luaK_exp2nextreg(fs, v); funcargs(ls, v); break; @@ -702,7 +701,7 @@ static void simpleexp (LexState *ls, expdesc *v) { next(ls); break; } - case l_c('{'): { /* constructor */ + case '{': { /* constructor */ constructor(ls, v); break; } @@ -724,7 +723,7 @@ static void simpleexp (LexState *ls, expdesc *v) { static UnOpr getunopr (int op) { switch (op) { case TK_NOT: return OPR_NOT; - case l_c('-'): return OPR_MINUS; + case '-': return OPR_MINUS; default: return OPR_NOUNOPR; } } @@ -732,17 +731,17 @@ static UnOpr getunopr (int op) { static BinOpr getbinopr (int op) { switch (op) { - case l_c('+'): return OPR_ADD; - case l_c('-'): return OPR_SUB; - case l_c('*'): return OPR_MULT; - case l_c('/'): return OPR_DIV; - case l_c('^'): return OPR_POW; + case '+': return OPR_ADD; + case '-': return OPR_SUB; + case '*': return OPR_MULT; + case '/': return OPR_DIV; + case '^': return OPR_POW; case TK_CONCAT: return OPR_CONCAT; case TK_NE: return OPR_NE; case TK_EQ: return OPR_EQ; - case l_c('<'): return OPR_LT; + case '<': return OPR_LT; case TK_LE: return OPR_LE; - case l_c('>'): return OPR_GT; + case '>': return OPR_GT; case TK_GE: return OPR_GE; case TK_AND: return OPR_AND; case TK_OR: return OPR_OR; @@ -870,8 +869,8 @@ static void check_conflict (LexState *ls, struct LHS_assign *lh, expdesc *v) { static void assignment (LexState *ls, struct LHS_assign *lh, int nvars) { expdesc e; check_condition(ls, VLOCAL <= lh->v.k && lh->v.k <= VINDEXED, - l_s("syntax error!")); - if (ls->t.token == l_c(',')) { /* assignment -> `,' primaryexp assignment */ + "syntax error!"); + if (ls->t.token == ',') { /* assignment -> `,' primaryexp assignment */ struct LHS_assign nv; nv.prev = lh; next(ls); @@ -882,7 +881,7 @@ static void assignment (LexState *ls, struct LHS_assign *lh, int nvars) { } else { /* assignment -> `=' explist1 */ int nexps; - check(ls, l_c('=')); + check(ls, '='); nexps = explist1(ls, &e); if (nexps != nvars) { adjust_assign(ls, nvars, nexps, &e); @@ -965,19 +964,19 @@ static void forbody (LexState *ls, int nvar, OpCode prepfor, OpCode loopfor) { static void fornum (LexState *ls, TString *varname) { /* fornum -> NAME = exp1,exp1[,exp1] forbody */ FuncState *fs = ls->fs; - check(ls, l_c('=')); + check(ls, '='); exp1(ls); /* initial value */ - check(ls, l_c(',')); + check(ls, ','); exp1(ls); /* limit */ - if (optional(ls, l_c(','))) + if (optional(ls, ',')) exp1(ls); /* optional step */ else { luaK_codeAsBc(fs, OP_LOADINT, fs->freereg, 1); /* default step */ luaK_reserveregs(fs, 1); } new_localvar(ls, varname, 0); - new_localvarstr(ls, l_s("(limit)"), 1); - new_localvarstr(ls, l_s("(step)"), 2); + new_localvarstr(ls, "(limit)", 1); + new_localvarstr(ls, "(step)", 2); forbody(ls, 3, OP_FORPREP, OP_FORLOOP); } @@ -985,13 +984,13 @@ static void fornum (LexState *ls, TString *varname) { static void forlist (LexState *ls, TString *indexname) { /* forlist -> NAME,NAME IN exp1 forbody */ TString *valname; - check(ls, l_c(',')); + check(ls, ','); valname = str_checkname(ls); next(ls); /* skip var name */ check(ls, TK_IN); exp1(ls); /* table */ - new_localvarstr(ls, l_s("(table)"), 0); - new_localvarstr(ls, l_s("(index)"), 1); + new_localvarstr(ls, "(table)", 0); + new_localvarstr(ls, "(index)", 1); new_localvar(ls, indexname, 2); new_localvar(ls, valname, 3); luaK_reserveregs(ls->fs, 3); /* registers for control, index and val */ @@ -1009,9 +1008,9 @@ static void forstat (LexState *ls, int line) { varname = str_checkname(ls); /* first variable name */ next(ls); /* skip var name */ switch (ls->t.token) { - case l_c('='): fornum(ls, varname); break; - case l_c(','): forlist(ls, varname); break; - default: luaK_error(ls, l_s("`=' or `,' expected")); + case '=': fornum(ls, varname); break; + case ',': forlist(ls, varname); break; + default: luaK_error(ls, "`=' or `,' expected"); } check_match(ls, TK_END, TK_FOR, line); leavebreak(fs, &bl); @@ -1060,8 +1059,8 @@ static void localstat (LexState *ls) { next(ls); /* skip LOCAL or `,' */ new_localvar(ls, str_checkname(ls), nvars++); next(ls); /* skip var name */ - } while (ls->t.token == l_c(',')); - if (optional(ls, l_c('='))) + } while (ls->t.token == ','); + if (optional(ls, '=')) nexps = explist1(ls, &e); else { e.k = VVOID; @@ -1077,10 +1076,10 @@ static int funcname (LexState *ls, expdesc *v) { int needself = 0; singlevar(ls->fs, str_checkname(ls), v, 1); next(ls); /* skip var name */ - while (ls->t.token == l_c('.')) { + while (ls->t.token == '.') { luaY_field(ls, v); } - if (ls->t.token == l_c(':')) { + if (ls->t.token == ':') { needself = 1; luaY_field(ls, v); } @@ -1120,7 +1119,7 @@ static void retstat (LexState *ls) { expdesc e; int first, nret; /* registers with returned values */ next(ls); /* skip RETURN */ - if (block_follow(ls->t.token) || ls->t.token == l_c(';')) + if (block_follow(ls->t.token) || ls->t.token == ';') first = nret = 0; /* return no values */ else { explist1(ls, &e); /* optional return values */ @@ -1145,7 +1144,7 @@ static void breakstat (LexState *ls) { FuncState *fs = ls->fs; Breaklabel *bl = fs->bl; if (!bl) - luaK_error(ls, l_s("no loop to break")); + luaK_error(ls, "no loop to break"); next(ls); /* skip BREAK */ closelevel(ls, bl->nactloc); luaK_concat(fs, &bl->breaklist, luaK_jump(fs)); @@ -1205,15 +1204,15 @@ static void parlist (LexState *ls) { /* parlist -> [ param { `,' param } ] */ int nparams = 0; short dots = 0; - if (ls->t.token != l_c(')')) { /* is `parlist' not empty? */ + if (ls->t.token != ')') { /* is `parlist' not empty? */ do { switch (ls->t.token) { case TK_DOTS: dots = 1; break; case TK_NAME: new_localvar(ls, str_checkname(ls), nparams++); break; - default: luaK_error(ls, l_s(" or `...' expected")); + default: luaK_error(ls, " or `...' expected"); } next(ls); - } while (!dots && optional(ls, l_c(','))); + } while (!dots && optional(ls, ',')); } code_params(ls, nparams, dots); } @@ -1224,13 +1223,13 @@ static void body (LexState *ls, expdesc *e, int needself, int line) { FuncState new_fs; open_func(ls, &new_fs); new_fs.f->lineDefined = line; - check(ls, l_c('(')); + check(ls, '('); if (needself) { - new_localvarstr(ls, l_s("self"), 0); + new_localvarstr(ls, "self", 0); adjustlocalvars(ls, 1); } parlist(ls); - check(ls, l_c(')')); + check(ls, ')'); chunk(ls); check_match(ls, TK_END, TK_FUNCTION, line); close_func(ls); @@ -1246,7 +1245,7 @@ static void chunk (LexState *ls) { int islast = 0; while (!islast && !block_follow(ls->t.token)) { islast = statement(ls); - optional(ls, l_c(';')); + optional(ls, ';'); lua_assert(ls->fs->freereg >= ls->fs->nactloc); ls->fs->freereg = ls->fs->nactloc; /* free registers */ } -- cgit v1.2.3-55-g6feb