GitHub/lua
1
0
Fork 0
mirror of https://github.com/lua/lua.git synced 2025-01-28 06:03:00 +08:00
Code Issues Projects Releases Wiki Activity

new constructor syntax + new generic `for'

Browse Source
This commit is contained in:
Roberto Ierusalimschy 2002-02-14 19:46:58 -02:00
parent 1e602a61b3
commit ac178ee478
1 changed files with 102 additions and 135 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

237
lparser.c
View File

@ -22,18 +22,6 @@
#include "lstring.h" #include "lstring.h"
/*
** Constructors descriptor:
** `n' indicates number of elements, and `k' signals whether
** it is a list constructor (k = 0) or a record constructor (k = 1)
** or empty (k = `;' or `}')
*/
typedef struct Constdesc {
int narray;
int nhash;
int k;
} Constdesc;
/* /*
** nodes for break list (list of active breakable loops) ** nodes for break list (list of active breakable loops)
@ -251,7 +239,7 @@ static void adjust_assign (LexState *ls, int nvars, int nexps, expdesc *e) {
else { else {
if (e->k != VVOID) luaK_exp2nextreg(fs, e); /* close last expression */ if (e->k != VVOID) luaK_exp2nextreg(fs, e); /* close last expression */
if (extra > 0) { if (extra > 0) {
int reg = fs->freereg; int reg = fs->freereg;
luaK_reserveregs(fs, extra); luaK_reserveregs(fs, extra);
luaK_nil(fs, reg, extra); luaK_nil(fs, reg, extra);
} }
@ -469,139 +457,118 @@ static void funcargs (LexState *ls, expdesc *f) {
*/ */
static void recfield (LexState *ls, expdesc *t) { struct ConsControl {
expdesc v; /* last list item read */
expdesc *t; /* table descriptor */
int nh; /* total number of `record' elements */
int na; /* total number of array elements */
int tostore; /* number of array elements pending to be stored */
};
static void recfield (LexState *ls, struct ConsControl *cc) {
/* recfield -> (NAME | `['exp1`]') = exp1 */ /* recfield -> (NAME | `['exp1`]') = exp1 */
FuncState *fs = ls->fs; FuncState *fs = ls->fs;
int reg = ls->fs->freereg; int reg = ls->fs->freereg;
expdesc key, val; expdesc key, val;
switch (ls->t.token) { if (ls->t.token == TK_NAME)
case TK_NAME: { checkname(ls, &key);
checkname(ls, &key); else /* ls->t.token == '[' */
break; luaY_index(ls, &key);
}
case '[': {
luaY_index(ls, &key);
break;
}
default: luaK_error(ls, "<name> or `[' expected");
}
check(ls, '='); check(ls, '=');
luaK_exp2RK(fs, &key); luaK_exp2RK(fs, &key);
expr(ls, &val); expr(ls, &val);
luaK_exp2anyreg(fs, &val); luaK_exp2anyreg(fs, &val);
luaK_codeABC(fs, OP_SETTABLE, val.info, t->info, luaK_codeABC(fs, OP_SETTABLE, val.info, cc->t->info, luaK_exp2RK(fs, &key));
luaK_exp2RK(fs, &key));
fs->freereg = reg; /* free registers */ fs->freereg = reg; /* free registers */
luaX_checklimit(ls, cc->nh, MAX_INT, "items in a constructor");
cc->nh++;
} }
static int anotherfield (LexState *ls) { static void closelistfield (FuncState *fs, struct ConsControl *cc) {
if (ls->t.token != ',') return 0; if (cc->v.k == VVOID) return; /* there is no list item */
next(ls); /* skip the comma */ luaK_exp2nextreg(fs, &cc->v);
return (ls->t.token != ';' && ls->t.token != '}'); cc->v.k = VVOID;
} if (cc->tostore == LFIELDS_PER_FLUSH) {
luaK_codeABc(fs, OP_SETLIST, cc->t->info, cc->na-1); /* flush */
cc->tostore = 0; /* no more items pending */
static int recfields (LexState *ls, expdesc *t) { fs->freereg = cc->t->info + 1; /* free registers */
/* recfields -> recfield { `,' recfield } [`,'] */
int n = 0;
do { /* at least one element */
recfield(ls, t);
luaX_checklimit(ls, n, MAX_INT, "items in a constructor");
n++;
} while (anotherfield(ls));
return n;
}
static int listfields (LexState *ls, expdesc *t) {
/* listfields -> exp1 { `,' exp1 } [`,'] */
expdesc v;
FuncState *fs = ls->fs;
int n = 1; /* at least one element */
int reg;
reg = fs->freereg;
expr(ls, &v);
while (anotherfield(ls)) {
luaK_exp2nextreg(fs, &v);
luaX_checklimit(ls, n, MAXARG_Bc, "items in a constructor");
if (n%LFIELDS_PER_FLUSH == 0) {
luaK_codeABc(fs, OP_SETLIST, t->info, n-1); /* flush */
fs->freereg = reg; /* free registers */
}
expr(ls, &v);
n++;
} }
if (v.k == VCALL) { }
luaK_setcallreturns(fs, &v, LUA_MULTRET);
luaK_codeABc(fs, OP_SETLISTO, t->info, n-1);
static void lastlistfield (FuncState *fs, struct ConsControl *cc) {
if (cc->tostore == 0) return;
if (cc->v.k == VCALL) {
luaK_setcallreturns(fs, &cc->v, LUA_MULTRET);
luaK_codeABc(fs, OP_SETLISTO, cc->t->info, cc->na-1);
} }
else { else {
luaK_exp2nextreg(fs, &v); if (cc->v.k != VVOID)
luaK_codeABc(fs, OP_SETLIST, t->info, n-1); luaK_exp2nextreg(fs, &cc->v);
luaK_codeABc(fs, OP_SETLIST, cc->t->info, cc->na-1);
} }
fs->freereg = reg; /* free registers */ fs->freereg = cc->t->info + 1; /* free registers */
return n;
} }
static void constructor_part (LexState *ls, expdesc *t, Constdesc *cd) { static void listfield (LexState *ls, struct ConsControl *cc) {
switch (ls->t.token) { expr(ls, &cc->v);
case ';': case '}': { /* constructor_part -> empty */ luaX_checklimit(ls, cc->na, MAXARG_Bc, "items in a constructor");
cd->narray = cd->nhash = 0; cc->na++;
cd->k = ls->t.token; cc->tostore++;
break;
}
case TK_NAME: { /* may be listfields or recfields */
lookahead(ls);
if (ls->lookahead.token != '=') /* expression? */
goto case_default;
/* else go through to recfields */
}
case '[': { /* constructor_part -> recfields */
cd->nhash = recfields(ls, t);
cd->narray = 0;
cd->k = 1; /* record */
break;
}
default: { /* constructor_part -> listfields */
case_default:
cd->narray = listfields(ls, t);
cd->nhash = 0;
cd->k = 0; /* list */
break;
}
}
} }
static void constructor (LexState *ls, expdesc *t) { static void constructor (LexState *ls, expdesc *t) {
/* constructor -> `{' constructor_part [`;' constructor_part] `}' */ /* constructor -> ?? */
FuncState *fs = ls->fs; FuncState *fs = ls->fs;
int line = ls->linenumber; int line = ls->linenumber;
int na, nh; int pc = luaK_codeABC(fs, OP_NEWTABLE, 0, 0, 0);
int pc; struct ConsControl cc;
Constdesc cd; cc.na = cc.nh = cc.tostore = 0;
pc = luaK_codeABC(fs, OP_NEWTABLE, 0, 0, 0); cc.t = t;
init_exp(t, VRELOCABLE, pc); init_exp(t, VRELOCABLE, pc);
init_exp(&cc.v, VVOID, 0); /* no value (yet) */
luaK_exp2nextreg(ls->fs, t); /* fix it at stack top (for gc) */ luaK_exp2nextreg(ls->fs, t); /* fix it at stack top (for gc) */
check(ls, '{'); check(ls, '{');
constructor_part(ls, t, &cd); for (;;) {
na = cd.narray; lua_assert(cc.v.k == VVOID || cc.tostore > 0);
nh = cd.nhash; optional(ls, ';'); /* compatibility only */
if (optional(ls, ';')) { if (ls->t.token == '}') break;
Constdesc other_cd; closelistfield(fs, &cc);
constructor_part(ls, t, &other_cd); switch(ls->t.token) {
check_condition(ls,(cd.k != other_cd.k), "invalid constructor syntax"); case TK_NAME: { /* may be listfields or recfields */
na += other_cd.narray; lookahead(ls);
nh += other_cd.nhash; if (ls->lookahead.token != '=') /* expression? */
listfield(ls, &cc);
else
recfield(ls, &cc);
break;
}
case '[': { /* constructor_item -> recfield */
recfield(ls, &cc);
break;
}
default: { /* constructor_part -> listfield */
listfield(ls, &cc);
break;
}
}
if (ls->t.token == ',' || ls->t.token == ';')
next(ls);
else
break;
} }
check_match(ls, '}', '{', line); check_match(ls, '}', '{', line);
if (na > 0) lastlistfield(fs, &cc);
SETARG_B(fs->f->code[pc], luaO_log2(na-1)+2); /* set initial table size */ if (cc.na > 0)
SETARG_C(fs->f->code[pc], luaO_log2(nh)+1); /* set initial table size */ SETARG_B(fs->f->code[pc], luaO_log2(cc.na-1)+2); /* set initial table size */
SETARG_C(fs->f->code[pc], luaO_log2(cc.nh)+1); /* set initial table size */
} }
/* }====================================================================== */ /* }====================================================================== */
@ -955,24 +922,27 @@ static void exp1 (LexState *ls) {
} }
static void forbody (LexState *ls, int nvar, OpCode loopfor) { static void forbody (LexState *ls, OpCode loopfor) {
/* forbody -> DO block END */ /* forbody -> DO block END */
FuncState *fs = ls->fs; FuncState *fs = ls->fs;
int basereg = fs->freereg - nvar; int basereg = fs->freereg - 3;
int prep = luaK_jump(fs); int prep = luaK_jump(fs);
int blockinit = luaK_getlabel(fs); int blockinit = luaK_getlabel(fs);
check(ls, TK_DO); check(ls, TK_DO);
adjustlocalvars(ls, nvar); /* scope for control variables */ adjustlocalvars(ls, 3); /* scope for control variables */
block(ls); block(ls);
luaK_patchlist(fs, prep, luaK_getlabel(fs)); luaK_patchlist(fs, prep, luaK_getlabel(fs));
luaK_patchlist(fs, luaK_codeAsBc(fs, loopfor, basereg, NO_JUMP), blockinit); luaK_patchlist(fs, luaK_codeAsBc(fs, loopfor, basereg, NO_JUMP), blockinit);
removelocalvars(ls, nvar, 1); removelocalvars(ls, 3, 1);
} }
static void fornum (LexState *ls, TString *varname) { static void fornum (LexState *ls, TString *varname) {
/* fornum -> NAME = exp1,exp1[,exp1] forbody */ /* fornum -> NAME = exp1,exp1[,exp1] forbody */
FuncState *fs = ls->fs; FuncState *fs = ls->fs;
new_localvar(ls, varname, 0);
new_localvarstr(ls, "(limit)", 1);
new_localvarstr(ls, "(step)", 2);
check(ls, '='); check(ls, '=');
exp1(ls); /* initial value */ exp1(ls); /* initial value */
check(ls, ','); check(ls, ',');
@ -983,30 +953,27 @@ static void fornum (LexState *ls, TString *varname) {
luaK_codeABc(fs, OP_LOADK, fs->freereg, luaK_numberK(fs, 1)); luaK_codeABc(fs, OP_LOADK, fs->freereg, luaK_numberK(fs, 1));
luaK_reserveregs(fs, 1); luaK_reserveregs(fs, 1);
} }
new_localvar(ls, varname, 0);
new_localvarstr(ls, "(limit)", 1);
new_localvarstr(ls, "(step)", 2);
luaK_codeABC(fs, OP_SUB, fs->freereg - 3, fs->freereg - 3, fs->freereg - 1); luaK_codeABC(fs, OP_SUB, fs->freereg - 3, fs->freereg - 3, fs->freereg - 1);
forbody(ls, 3, OP_FORLOOP); forbody(ls, OP_FORLOOP);
} }
static void forlist (LexState *ls, TString *indexname) { static void forlist (LexState *ls, TString *indexname) {
/* forlist -> NAME,NAME IN exp1 forbody */ /* forlist -> NAME,NAME IN exp1 forbody */
TString *valname;
FuncState *fs = ls->fs; FuncState *fs = ls->fs;
check(ls, ','); new_localvarstr(ls, "(table)", 0);
valname = str_checkname(ls); new_localvar(ls, indexname, 1);
next(ls); /* skip var name */ if (optional(ls, ',')) {
new_localvar(ls, str_checkname(ls), 2);
next(ls); /* skip var name */
}
else
new_localvarstr(ls, "(val)", 2);
check(ls, TK_IN); check(ls, TK_IN);
exp1(ls); /* table */ exp1(ls); /* table */
new_localvarstr(ls, "(table)", 0); luaK_reserveregs(fs, 2); /* registers for index and val */
new_localvarstr(ls, "(index)", 1); luaK_codeABC(fs, OP_LOADNIL, fs->freereg - 2, fs->freereg - 1, 0);
new_localvar(ls, indexname, 2); forbody(ls, OP_TFORLOOP);
new_localvar(ls, valname, 3);
luaK_reserveregs(fs, 3); /* registers for control, index and val */
luaK_codeABc(fs, OP_LOADK, fs->freereg - 3, luaK_numberK(fs, -1));
forbody(ls, 4, OP_TFORLOOP);
} }
@ -1021,8 +988,8 @@ static void forstat (LexState *ls, int line) {
next(ls); /* skip var name */ next(ls); /* skip var name */
switch (ls->t.token) { switch (ls->t.token) {
case '=': fornum(ls, varname); break; case '=': fornum(ls, varname); break;
case ',': forlist(ls, varname); break; case ',': case TK_IN: forlist(ls, varname); break;
default: luaK_error(ls, "`=' or `,' expected"); default: luaK_error(ls, "`=' or `in' expected");
} }
check_match(ls, TK_END, TK_FOR, line); check_match(ls, TK_END, TK_FOR, line);
leavebreak(fs, &bl); leavebreak(fs, &bl);