From 73aa465a8ed8dee6c6a27a6f8b2f51227b70789d Mon Sep 17 00:00:00 2001 From: Roberto Ierusalimschy Date: Fri, 10 Mar 2000 15:37:44 -0300 Subject: some name changes --- lparser.c | 158 +++++++++++++++++++++++++++++++------------------------------- 1 file changed, 79 insertions(+), 79 deletions(-) (limited to 'lparser.c') diff --git a/lparser.c b/lparser.c index a8198190..c875f784 100644 --- a/lparser.c +++ b/lparser.c @@ -1,5 +1,5 @@ /* -** $Id: lparser.c,v 1.64 2000/03/03 20:29:25 roberto Exp roberto $ +** $Id: lparser.c,v 1.67 2000/03/09 13:57:37 roberto Exp roberto $ ** LL(1) Parser and code generator for Lua ** See Copyright Notice in lua.h */ @@ -116,7 +116,7 @@ static void checklimit (LexState *ls, int val, int limit, const char *msg) { static void check_debugline (LexState *ls) { if (ls->L->debug && ls->linenumber != ls->fs->lastsetline) { - luaK_U(ls, SETLINE, ls->linenumber, 0); + luaK_U(ls, OP_SETLINE, ls->linenumber, 0); ls->fs->lastsetline = ls->linenumber; } } @@ -130,11 +130,11 @@ static void check_match (LexState *ls, int what, int who, int where) { } -static int string_constant (LexState *ls, FuncState *fs, TaggedString *s) { - TProtoFunc *f = fs->f; +static int string_constant (LexState *ls, FuncState *fs, TString *s) { + Proto *f = fs->f; int c = s->constindex; if (c >= f->nkstr || f->kstr[c] != s) { - luaM_growvector(ls->L, f->kstr, f->nkstr, 1, TaggedString *, + luaM_growvector(ls->L, f->kstr, f->nkstr, 1, TString *, constantEM, MAXARG_U); c = f->nkstr++; f->kstr[c] = s; @@ -144,14 +144,14 @@ static int string_constant (LexState *ls, FuncState *fs, TaggedString *s) { } -static void code_string (LexState *ls, TaggedString *s) { +static void code_string (LexState *ls, TString *s) { luaK_kstr(ls, string_constant(ls, ls->fs, s)); } static int checkname (LexState *ls) { int sc; - if (ls->token != NAME) + if (ls->token != TK_NAME) luaK_error(ls, " expected"); sc = string_constant(ls, ls->fs, ls->seminfo.ts); next(ls); @@ -159,17 +159,17 @@ static int checkname (LexState *ls) { } -static TaggedString *str_checkname (LexState *ls) { +static TString *str_checkname (LexState *ls) { int i = checkname(ls); /* this call may realloc `f->consts' */ return ls->fs->f->kstr[i]; } -static void luaI_registerlocalvar (LexState *ls, TaggedString *varname, +static void luaI_registerlocalvar (LexState *ls, TString *varname, int line) { FuncState *fs = ls->fs; if (fs->nvars != -1) { /* debug information? */ - TProtoFunc *f = fs->f; + Proto *f = fs->f; luaM_growvector(ls->L, f->locvars, fs->nvars, 1, LocVar, "", MAX_INT); f->locvars[fs->nvars].varname = varname; f->locvars[fs->nvars].line = line; @@ -183,7 +183,7 @@ static void luaI_unregisterlocalvar (LexState *ls, int line) { } -static void store_localvar (LexState *ls, TaggedString *name, int n) { +static void store_localvar (LexState *ls, TString *name, int n) { FuncState *fs = ls->fs; checklimit(ls, fs->nlocalvar+n+1, MAXLOCALS, "local variables"); fs->localvar[fs->nlocalvar+n] = name; @@ -199,13 +199,13 @@ static void adjustlocalvars (LexState *ls, int nvars, int line) { } -static void add_localvar (LexState *ls, TaggedString *name) { +static void add_localvar (LexState *ls, TString *name) { store_localvar(ls, name, 0); adjustlocalvars(ls, 1, 0); } -static int aux_localname (FuncState *fs, TaggedString *n) { +static int aux_localname (FuncState *fs, TString *n) { int i; for (i=fs->nlocalvar-1; i >= 0; i--) if (n == fs->localvar[i]) return i; /* local var index */ @@ -213,7 +213,7 @@ static int aux_localname (FuncState *fs, TaggedString *n) { } -static void singlevar (LexState *ls, TaggedString *n, expdesc *var, int prev) { +static void singlevar (LexState *ls, TString *n, expdesc *var, int prev) { FuncState *fs = prev ? ls->fs->prev : ls->fs; int i = aux_localname(fs, n); if (i >= 0) { /* local value? */ @@ -231,7 +231,7 @@ static void singlevar (LexState *ls, TaggedString *n, expdesc *var, int prev) { } -static int indexupvalue (LexState *ls, TaggedString *n) { +static int indexupvalue (LexState *ls, TString *n) { FuncState *fs = ls->fs; expdesc v; int i; @@ -248,12 +248,12 @@ static int indexupvalue (LexState *ls, TaggedString *n) { } -static void pushupvalue (LexState *ls, TaggedString *n) { +static void pushupvalue (LexState *ls, TString *n) { if (ls->fs->prev == NULL) luaX_syntaxerror(ls, "cannot access upvalue in main", n->str); if (aux_localname(ls->fs, n) >= 0) luaX_syntaxerror(ls, "cannot access an upvalue in current scope", n->str); - luaK_U(ls, PUSHUPVALUE, indexupvalue(ls, n), 1); + luaK_U(ls, OP_PUSHUPVALUE, indexupvalue(ls, n), 1); } @@ -308,21 +308,21 @@ static int getvarname (LexState *ls, expdesc *var) { static void func_onstack (LexState *ls, FuncState *func) { - TProtoFunc *f = ls->fs->f; + Proto *f = ls->fs->f; int i; for (i=0; inupvalues; i++) luaK_tostack(ls, &func->upvalues[i], 1); - luaM_growvector(ls->L, f->kproto, f->nkproto, 1, TProtoFunc *, + luaM_growvector(ls->L, f->kproto, f->nkproto, 1, Proto *, constantEM, MAXARG_A); f->kproto[f->nkproto++] = func->f; luaK_deltastack(ls, 1); /* CLOSURE puts one extra element before popping */ - luaK_AB(ls, CLOSURE, f->nkproto-1, func->nupvalues, -func->nupvalues); + luaK_AB(ls, OP_CLOSURE, f->nkproto-1, func->nupvalues, -func->nupvalues); } -static void init_state (LexState *ls, FuncState *fs, TaggedString *source) { +static void init_state (LexState *ls, FuncState *fs, TString *source) { lua_State *L = ls->L; - TProtoFunc *f = luaF_newproto(ls->L); + Proto *f = luaF_newproto(ls->L); fs->prev = ls->fs; /* linked list of funcstates */ ls->fs = fs; fs->stacksize = 0; @@ -340,19 +340,19 @@ static void init_state (LexState *ls, FuncState *fs, TaggedString *source) { fs->nvars = (L->debug) ? 0 : -1; /* flag no debug information? */ /* push function (to avoid GC) */ tfvalue(L->top) = f; - ttype(L->top) = LUA_T_LPROTO; + ttype(L->top) = TAG_LPROTO; incr_top; } static void close_func (LexState *ls) { FuncState *fs = ls->fs; - TProtoFunc *f = fs->f; - luaK_0(ls, ENDCODE, 0); + Proto *f = fs->f; + luaK_0(ls, OP_END, 0); luaM_reallocvector(ls->L, f->code, fs->pc, Instruction); - luaM_reallocvector(ls->L, f->kstr, f->nkstr, TaggedString *); - luaM_reallocvector(ls->L, f->knum, f->nknum, real); - luaM_reallocvector(ls->L, f->kproto, f->nkproto, TProtoFunc *); + luaM_reallocvector(ls->L, f->kstr, f->nkstr, TString *); + luaM_reallocvector(ls->L, f->knum, f->nknum, Number); + luaM_reallocvector(ls->L, f->kproto, f->nkproto, Proto *); if (fs->nvars != -1) { /* debug information? */ luaI_registerlocalvar(ls, NULL, -1); /* flag end of vector */ luaM_reallocvector(ls->L, f->locvars, fs->nvars, LocVar); @@ -362,14 +362,14 @@ static void close_func (LexState *ls) { } -TProtoFunc *luaY_parser (lua_State *L, ZIO *z) { +Proto *luaY_parser (lua_State *L, ZIO *z) { struct LexState lexstate; struct FuncState funcstate; luaX_setinput(L, &lexstate, z); init_state(&lexstate, &funcstate, luaS_new(L, zname(z))); next(&lexstate); /* read first token */ chunk(&lexstate); - if (lexstate.token != EOS) + if (lexstate.token != TK_EOS) luaK_error(&lexstate, " expected"); close_func(&lexstate); return funcstate.f; @@ -401,8 +401,8 @@ static int explist1 (LexState *ls) { static int explist (LexState *ls) { /* explist -> [ explist1 ] */ switch (ls->token) { - case ELSE: case ELSEIF: case END: case UNTIL: - case EOS: case ';': case ')': + case TK_ELSE: case TK_ELSEIF: case TK_END: case TK_UNTIL: + case TK_EOS: case ';': case ')': return 0; /* empty list */ default: @@ -432,7 +432,7 @@ static void funcargs (LexState *ls, int slf) { constructor(ls); break; - case STRING: /* funcargs -> STRING */ + case TK_STRING: /* funcargs -> STRING */ code_string(ls, ls->seminfo.ts); /* must use `seminfo' before `next' */ next(ls); break; @@ -442,7 +442,7 @@ static void funcargs (LexState *ls, int slf) { break; } fs->stacksize = slevel; /* call will remove function and arguments */ - luaK_AB(ls, CALL, slevel, MULT_RET, 0); + luaK_AB(ls, OP_CALL, slevel, MULT_RET, 0); } @@ -469,14 +469,14 @@ static void var_or_func_tail (LexState *ls, expdesc *v) { next(ls); name = checkname(ls); luaK_tostack(ls, v, 1); /* `v' must be on stack */ - luaK_U(ls, PUSHSELF, name, 1); + luaK_U(ls, OP_PUSHSELF, name, 1); funcargs(ls, 1); v->k = VEXP; v->u.l.t = v->u.l.f = 0; break; } - case '(': case STRING: case '{': /* var_or_func_tail -> funcargs */ + case '(': case TK_STRING: case '{': /* var_or_func_tail -> funcargs */ luaK_tostack(ls, v, 1); /* `v' must be on stack */ funcargs(ls, 0); v->k = VEXP; @@ -513,7 +513,7 @@ static void var_or_func (LexState *ls, expdesc *v) { static void recfield (LexState *ls) { /* recfield -> (NAME | '['exp1']') = exp1 */ switch (ls->token) { - case NAME: + case TK_NAME: luaK_kstr(ls, checkname(ls)); break; @@ -541,12 +541,12 @@ static int recfields (LexState *ls) { recfield(ls); n++; if (++mod_n == RFIELDS_PER_FLUSH) { - luaK_U(ls, SETMAP, RFIELDS_PER_FLUSH-1, -2*RFIELDS_PER_FLUSH); + luaK_U(ls, OP_SETMAP, RFIELDS_PER_FLUSH-1, -2*RFIELDS_PER_FLUSH); mod_n = 0; } } if (mod_n) - luaK_U(ls, SETMAP, mod_n-1, -2*mod_n); + luaK_U(ls, OP_SETMAP, mod_n-1, -2*mod_n); return n; } @@ -564,13 +564,13 @@ static int listfields (LexState *ls) { checklimit(ls, n, MAXARG_A*LFIELDS_PER_FLUSH, "items in a list initializer"); if (++mod_n == LFIELDS_PER_FLUSH) { - luaK_AB(ls, SETLIST, n/LFIELDS_PER_FLUSH - 1, LFIELDS_PER_FLUSH-1, + luaK_AB(ls, OP_SETLIST, n/LFIELDS_PER_FLUSH - 1, LFIELDS_PER_FLUSH-1, -LFIELDS_PER_FLUSH); mod_n = 0; } } if (mod_n > 0) - luaK_AB(ls, SETLIST, n/LFIELDS_PER_FLUSH, mod_n-1, -mod_n); + luaK_AB(ls, OP_SETLIST, n/LFIELDS_PER_FLUSH, mod_n-1, -mod_n); return n; } @@ -583,7 +583,7 @@ static void constructor_part (LexState *ls, constdesc *cd) { cd->k = ls->token; return; - case NAME: { + case TK_NAME: { expdesc v; expr(ls, &v); if (ls->token == '=') { @@ -619,7 +619,7 @@ static void constructor_part (LexState *ls, constdesc *cd) { static void constructor (LexState *ls) { /* constructor -> '{' constructor_part [';' constructor_part] '}' */ int line = ls->linenumber; - int pc = luaK_U(ls, CREATETABLE, 0, 1); + int pc = luaK_U(ls, OP_CREATETABLE, 0, 1); int nelems; constdesc cd; check(ls, '{'); @@ -653,19 +653,19 @@ static void constructor (LexState *ls) { static void simpleexp (LexState *ls, expdesc *v) { check_debugline(ls); switch (ls->token) { - case NUMBER: { /* simpleexp -> NUMBER */ - real r = ls->seminfo.r; + case TK_NUMBER: { /* simpleexp -> NUMBER */ + Number r = ls->seminfo.r; next(ls); luaK_number(ls, r); break; } - case STRING: /* simpleexp -> STRING */ + case TK_STRING: /* simpleexp -> STRING */ code_string(ls, ls->seminfo.ts); /* must use `seminfo' before `next' */ next(ls); break; - case NIL: /* simpleexp -> NIL */ + case TK_NIL: /* simpleexp -> NIL */ luaK_adjuststack(ls, -1); next(ls); break; @@ -674,7 +674,7 @@ static void simpleexp (LexState *ls, expdesc *v) { constructor(ls); break; - case FUNCTION: /* simpleexp -> FUNCTION body */ + case TK_FUNCTION: /* simpleexp -> FUNCTION body */ next(ls); body(ls, 0, ls->linenumber); break; @@ -685,7 +685,7 @@ static void simpleexp (LexState *ls, expdesc *v) { check(ls, ')'); return; - case NAME: case '%': + case TK_NAME: case '%': var_or_func(ls, v); return; @@ -720,12 +720,12 @@ static int get_priority (int op, int *rp) { case '+': case '-': *rp = 5; return 5; - case CONC: *rp = 3; return 4; /* right associative (?) */ + case TK_CONC: *rp = 3; return 4; /* right associative (?) */ - case EQ: case NE: case '>': case '<': case LE: case GE: + case TK_EQ: case TK_NE: case '>': case '<': case TK_LE: case TK_GE: *rp = 2; return 2; - case AND: case OR: *rp = 1; return 1; + case TK_AND: case TK_OR: *rp = 1; return 1; default: *rp = -1; return -1; } @@ -738,7 +738,7 @@ static int get_priority (int op, int *rp) { */ static void subexpr (LexState *ls, expdesc *v, int limit) { int rp; - if (ls->token == '-' || ls->token == NOT) { + if (ls->token == '-' || ls->token == TK_NOT) { int op = ls->token; /* operator */ next(ls); subexpr(ls, v, UNARY_PRIORITY); @@ -806,7 +806,7 @@ static int assignment (LexState *ls, expdesc *v, int nvars) { luaK_storevar(ls, v); } else { /* indexed var with values in between*/ - luaK_U(ls, SETTABLE, left+(nvars-1), -1); + luaK_U(ls, OP_SETTABLE, left+(nvars-1), -1); left += 2; /* table&index are not popped, because they aren't on top */ } return left; @@ -838,11 +838,11 @@ static void whilestat (LexState *ls, int line) { for (i=0; if->code[while_init+i]; /* go back to state prior condition */ fs->pc = while_init; - luaK_S(ls, JMP, 0, 0); /* initial jump to condition */ - check(ls, DO); + luaK_S(ls, OP_JMP, 0, 0); /* initial jump to condition */ + check(ls, TK_DO); loopentry = luaK_getlabel(ls); block(ls); - check_match(ls, END, WHILE, line); + check_match(ls, TK_END, TK_WHILE, line); cond_init = luaK_getlabel(ls); luaK_fixjump(ls, while_init, cond_init); /* correct `v' and copy condition to new position */ @@ -859,7 +859,7 @@ static void repeatstat (LexState *ls, int line) { expdesc v; next(ls); block(ls); - check_match(ls, UNTIL, REPEAT, line); + check_match(ls, TK_UNTIL, TK_REPEAT, line); expr(ls, &v); luaK_goiftrue(ls, &v, 0); luaK_patchlist(ls, v.u.l.f, repeat_init); @@ -958,16 +958,16 @@ static void ifpart (LexState *ls, int line) { next(ls); /* skip IF or ELSEIF */ expr(ls, &v); /* cond */ luaK_goiftrue(ls, &v, 0); - check(ls, THEN); + check(ls, TK_THEN); block(ls); /* `then' part */ - luaK_S(ls, JMP, 0, 0); /* 2nd jump: over `else' part */ + luaK_S(ls, OP_JMP, 0, 0); /* 2nd jump: over `else' part */ elseinit = luaK_getlabel(ls); /* address of 2nd jump == elseinit-1 */ - if (ls->token == ELSEIF) + if (ls->token == TK_ELSEIF) ifpart(ls, line); else { - if (optional(ls, ELSE)) + if (optional(ls, TK_ELSE)) block(ls); /* `else' part */ - check_match(ls, END, IF, line); + check_match(ls, TK_END, TK_IF, line); } if (fs->pc > elseinit) { /* is there an `else' part? */ luaK_fixjump(ls, elseinit-1, luaK_getlabel(ls)); /* fix 2nd jump */ @@ -983,38 +983,38 @@ static void ifpart (LexState *ls, int line) { static int stat (LexState *ls) { int line = ls->linenumber; /* may be needed for error messages */ switch (ls->token) { - case IF: /* stat -> IF ifpart END */ + case TK_IF: /* stat -> IF ifpart END */ ifpart(ls, line); return 1; - case WHILE: /* stat -> whilestat */ + case TK_WHILE: /* stat -> whilestat */ whilestat(ls, line); return 1; - case DO: { /* stat -> DO block END */ + case TK_DO: { /* stat -> DO block END */ next(ls); block(ls); - check_match(ls, END, DO, line); + check_match(ls, TK_END, TK_DO, line); return 1; } - case REPEAT: /* stat -> repeatstat */ + case TK_REPEAT: /* stat -> repeatstat */ repeatstat(ls, line); return 1; - case FUNCTION: /* stat -> funcstat */ + case TK_FUNCTION: /* stat -> funcstat */ return funcstat(ls, line); - case LOCAL: /* stat -> localstat */ + case TK_LOCAL: /* stat -> localstat */ localstat(ls); return 1; - case NAME: case '%': /* stat -> namestat */ + case TK_NAME: case '%': /* stat -> namestat */ namestat(ls); return 1; - case RETURN: case ';': case ELSE: case ELSEIF: - case END: case UNTIL: case EOS: /* `stat' follow */ + case TK_RETURN: case ';': case TK_ELSE: case TK_ELSEIF: + case TK_END: case TK_UNTIL: case TK_EOS: /* `stat' follow */ return 0; default: @@ -1028,23 +1028,23 @@ static void parlist (LexState *ls) { int nparams = 0; int dots = 0; switch (ls->token) { - case DOTS: /* parlist -> DOTS */ + case TK_DOTS: /* parlist -> DOTS */ next(ls); dots = 1; break; - case NAME: /* parlist, tailparlist -> NAME [',' tailparlist] */ + case TK_NAME: /* parlist, tailparlist -> NAME [',' tailparlist] */ init: store_localvar(ls, str_checkname(ls), nparams++); if (ls->token == ',') { next(ls); switch (ls->token) { - case DOTS: /* tailparlist -> DOTS */ + case TK_DOTS: /* tailparlist -> DOTS */ next(ls); dots = 1; break; - case NAME: /* tailparlist -> NAME [',' tailparlist] */ + case TK_NAME: /* tailparlist -> NAME [',' tailparlist] */ goto init; default: luaK_error(ls, " or `...' expected"); @@ -1071,7 +1071,7 @@ static void body (LexState *ls, int needself, int line) { parlist(ls); check(ls, ')'); chunk(ls); - check_match(ls, END, FUNCTION, line); + check_match(ls, TK_END, TK_FUNCTION, line); close_func(ls); func_onstack(ls, &new_fs); } @@ -1079,7 +1079,7 @@ static void body (LexState *ls, int needself, int line) { static void ret (LexState *ls) { /* ret -> [RETURN explist sc] */ - if (ls->token == RETURN) { + if (ls->token == TK_RETURN) { int nexps; /* number of expressions returned */ check_debugline(ls); next(ls); -- cgit v1.2.3-55-g6feb