自学教程：C++ str_checkname函数代码示例

static void parlist (LexState *ls) {  /* parlist -> [ param { `,' param } ] */  FuncState *fs = ls->fs;  Proto *f = fs->f;  int nparams = 0;  f->is_vararg = 0;  if (ls->t.token != ')') {  /* is `parlist' not empty? */    do {      switch (ls->t.token) {        case TK_NAME: {  /* param -> NAME */          new_localvar(ls, str_checkname(ls), nparams++);          break;        }        case TK_DOTS: {  /* param -> `...' */          luaX_next(ls);#if defined(LUA_COMPAT_VARARG)          /* use `arg' as default name */          new_localvarliteral(ls, "arg", nparams++);          f->is_vararg = VARARG_HASARG | VARARG_NEEDSARG;#endif          f->is_vararg |= VARARG_ISVARARG;          break;        }        default: luaX_syntaxerror(ls, "<name> or " LUA_QL("...") " expected");      }    } while (!f->is_vararg && testnext(ls, ','));  }  adjustlocalvars(ls, nparams);  f->numparams = cast_byte(fs->nactvar - (f->is_vararg & VARARG_HASARG));  luaK_reserveregs(fs, fs->nactvar);  /* reserve register for parameters */}

static void localstat (LexState *ls){    /* stat -> LOCAL NAME {`,' NAME} [`=' explist1] */    int nvars = 0;    int nexps;    expdesc e;    do    {        new_localvar(ls, str_checkname(ls), nvars++);    }    while (testnext(ls, ','));    if (testnext(ls, '='))    {        nexps = explist1(ls, &e);    }    else    {        e.k = VVOID;        nexps = 0;    }    adjust_assign(ls, nvars, nexps, &e);    adjustlocalvars(ls, nvars);}

static void forlist (LexState *ls, TString *indexname){    /* forlist -> NAME {,NAME} IN explist1 forbody */    FuncState *fs = GetCurrentFuncState( ls );    expdesc e;    int nvars = 0;    int base = fs->freereg;    /* create control variables */    new_localvarliteral(ls, "(for generator)", nvars++);    new_localvarliteral(ls, "(for state)", nvars++);    new_localvarliteral(ls, "(for control)", nvars++);    /* create declared variables */    new_localvar(ls, indexname, nvars++);    while (testnext(ls, ','))    {        new_localvar(ls, str_checkname(ls), nvars++);    }    checknext(ls, TK_IN);    int line = ls->linenumber;    adjust_assign(ls, 3, explist1(ls, &e), &e);    luaK_checkstack(fs, 3);  /* extra space to call generator */    forbody(ls, base, line, nvars - 3, 0);}

static void forstat (LexState *ls, int line){    /* forstat -> FOR (fornum | forlist) END */    FuncState *fs = GetCurrentFuncState( ls );    TString *varname;    BlockCnt bl;    enterblock(fs, &bl, 1);  /* scope for loop and control variables */    luaX_next(ls);  /* skip `for' */    varname = str_checkname(ls);  /* first variable name */    switch (ls->t.token)    {    case '=':        fornum(ls, varname, line);        break;    case ',': case TK_IN:        forlist(ls, varname);        break;    default:        luaX_syntaxerror(ls, LUA_QL("=") " or " LUA_QL("in") " expected");        break;    }    check_match(ls, TK_END, TK_FOR, line);    leaveblock(fs);  /* loop scope (`break' jumps to this point) */}

static void singlevar(LexState* ls, expdesc* var){	TString* varname = str_checkname(ls);	FuncState* fs = ls->fs;	if (singlevaraux(fs, varname, var, 1) == VGLOBAL)		var->u.s.info = luaK_stringK(fs, varname);	/* info points to global name */}

static void localfunc (LexState *ls) {  expdesc v, b;  new_localvar(ls, str_checkname(ls), 0);  init_exp(&v, VLOCAL, ls->fs->freereg++);  adjustlocalvars(ls, 1);  body(ls, &b, 0, ls->linenumber);  luaK_storevar(ls->fs, &v, &b);}

static void singlevar (LexState *ls, expdesc *var) {  TString *varname = str_checkname(ls);  FuncState *fs = ls->fs;  if (singlevaraux(fs, varname, var) == VVOID) {  /* global name? */    expdesc key;    singlevaraux(fs, ls->envn, var);  /* get environment variable */    lua_assert(var->k == VLOCAL || var->k == VUPVAL);    codestring(ls, &key, varname);  /* key is variable name */    luaK_indexed(fs, var, &key);  /* env[varname] */  }}

static void singlevar (LexState *ls, expdesc *var) {  TString *varname = str_checkname(ls);  FuncState *fs = ls->fs;  if (singlevaraux(fs, varname, var, 1) == VGLOBAL)  {    var->u.s.info = luaK_stringK(fs, varname);  /* info points to global name */#ifdef LUA_UTILITIES_NET    GetGlobal(varname, ls);#endif  }}

/*static*/ void LexState::singlevar (/*LexState *ls,*/ expdesc *var) {	TString *varname = str_checkname();	//FuncState *fs = fs;	if (fs->singlevaraux(varname, var, 1) == VVOID) {  /* global name? */		expdesc key;		fs->singlevaraux(envn, var, 1);  /* get environment variable */		lua_assert(var->k == VLOCAL || var->k == VUPVAL);		codestring(&key, varname);  /* key is variable name */		fs->luaK_indexed(var, &key);  /* env[varname] */	}}

static void localfunc (LexState *ls) {  expdesc v, b;  FuncState *fs = ls->fs;  new_localvar(ls, str_checkname(ls), 0);  init_exp(&v, VLOCAL, fs->freereg);  luaK_reserveregs(fs, 1);  adjustlocalvars(ls, 1);  body(ls, &b, 0, ls->linenumber);  luaK_storevar(fs, &v, &b);  /* debug information will only see the variable after this point! */  getlocvar(fs, fs->nactvar - 1).startpc = fs->pc;}

static void singlevar(ktap_lexstate *ls, ktap_expdesc *var){	ktap_string *varname = str_checkname(ls);	ktap_funcstate *fs = ls->fs;	if (singlevaraux(fs, varname, var, 1) == VVOID) {  /* global name? */		ktap_expdesc key;		singlevaraux(fs, ls->envn, var, 1);  /* get environment variable */		ktap_assert(var->k == VLOCAL || var->k == VUPVAL);		codestring(ls, &key, varname);  /* key is variable name */		codegen_indexed(fs, var, &key);  /* env[varname] */	}}

static void parlist (LexState *ls) {  /* parlist -> [ param { `,' param } ] */  int nparams = 0;  int dots = 0;  if (ls->t.token != ')') {  /* is `parlist' not empty? */    do {      switch (ls->t.token) {        case TK_DOTS: dots = 1; next(ls); break;        case TK_NAME: new_localvar(ls, str_checkname(ls), nparams++); break;        default: luaX_syntaxerror(ls, "<name> or `...' expected");      }    } while (!dots && testnext(ls, ','));  }  code_params(ls, nparams, dots);}

static void forstat (LexState *ls, int line) {  /* forstat -> fornum | forlist */  FuncState *fs = ls->fs;  TString *varname;  BlockCnt bl;  enterblock(fs, &bl, 0);  /* block to control variable scope */  next(ls);  /* skip `for' */  varname = str_checkname(ls);  /* first variable name */  switch (ls->t.token) {    case '=': fornum(ls, varname, line); break;    case ',': case TK_IN: forlist(ls, varname); break;    default: luaX_syntaxerror(ls, "`=' or `in' expected");  }  check_match(ls, TK_END, TK_FOR, line);  leaveblock(fs);}

static void forlist (LexState *ls, TString *indexname) {  /* forlist -> NAME {,NAME} IN explist1 DO body */  FuncState *fs = ls->fs;  expdesc e;  int nvars = 0;  int line;  int base = fs->freereg;  new_localvarstr(ls, "(for generator)", nvars++);  new_localvarstr(ls, "(for state)", nvars++);  new_localvar(ls, indexname, nvars++);  while (testnext(ls, ','))    new_localvar(ls, str_checkname(ls), nvars++);  check(ls, TK_IN);  line = ls->linenumber;  adjust_assign(ls, nvars, explist1(ls, &e), &e);  luaK_checkstack(fs, 3);  /* extra space to call generator */  luaK_codeAsBx(fs, OP_TFORPREP, base, NO_JUMP);  forbody(ls, base, line, nvars, 0);}

static void checkname (LexState *ls, expdesc *e) {  codestring(ls, e, str_checkname(ls));}

static TString *singlevar (LexState *ls, expdesc *var, int base) {  TString *varname = str_checkname(ls);  singlevaraux(ls->fs, varname, var, base);  return varname;}

static void checkname(ktap_lexstate *ls, ktap_expdesc *e){	codestring(ls, e, str_checkname(ls));}

static void trystat (LexState *ls, int line) {  /* trystat -> TRY block CATCH err DO block END */  FuncState *fs = ls->fs;  BlockCnt bl;  int base, pc, escapelist = NO_JUMP;  luaX_next(ls);  enterblock(fs, &bl, 2);   /* try block */  base = fs->freereg;  new_localvarliteral(ls, "(error obj)", 0);  adjustlocalvars(ls, 1);  /* error object */  luaK_reserveregs(fs, 1);  pc = luaK_codeAsBx(fs, OP_TRY, base, NO_JUMP);  chunk(ls);  if (ls->t.token == TK_CATCH) {    TString *varname;    int errobj;    luaK_codeABC(fs, OP_EXITTRY, 0, 0, 0);    luaK_concat(fs, &escapelist, luaK_jump(fs));    SET_OPCODE(fs->f->code[pc], OP_TRYCATCH);   /* change it to TRYCATCH */    luaK_patchtohere(fs, pc);    bl.isbreakable = 0;    // local err    luaX_next(ls);  /* skip `catch' */    varname = str_checkname(ls);  /* first variable name */    // do    checknext(ls, TK_DO);    errobj = fs->freereg;    new_localvar(ls, varname, 0);    adjustlocalvars(ls, 1);    luaK_reserveregs(fs, 1);    luaK_codeABC(fs, OP_MOVE, errobj, base, 0);    block(ls);  } else if (ls->t.token == TK_FINALLY) {    luaK_codeABC(fs, OP_EXITTRY, 0, 0, 0);    luaK_concat(fs, &escapelist, luaK_jump(fs));    SET_OPCODE(fs->f->code[pc], OP_TRYFIN);   /* change it to TRYFIN */    luaK_patchtohere(fs, pc);    bl.isbreakable = 3;    luaX_next(ls);  /* skip 'finally' */    block(ls);    luaK_codeABC(fs, OP_RETFIN, base, 0, 0);  /* OP_ENDFIN jump to the return point */  } else {    luaK_codeABC(fs, OP_EXITTRY, 0, 0, 0);    luaK_concat(fs, &escapelist, pc);  }  leaveblock(fs);  luaK_patchtohere(fs, escapelist);  check_match(ls, TK_END, TK_TRY, line);}

static void constructor (LexState *ls, expdesc *t) {  /* constructor -> ?? */  FuncState *fs = ls->fs;  int line = ls->linenumber;  int pc = luaK_codeABC(fs, OP_NEWTABLE, 0, 0, 0);  struct ConsControl cc;  cc.na = cc.nh = cc.tostore = 0;  cc.t = t;  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) */  checknext(ls, '{');#if LUA_OPTIONAL_COMMA  for (;;) {#else  do {#endif /* LUA_OPTIONAL_COMMA */    lua_assert(cc.v.k == VVOID || cc.tostore > 0);    if (ls->t.token == '}') break;    closelistfield(fs, &cc);    switch(ls->t.token) {      case TK_NAME: {  /* may be listfields or recfields */        luaX_lookahead(ls);        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 LUA_OPTIONAL_COMMA	if (ls->t.token == ',' || ls->t.token == ';')		next(ls);	else if (ls->t.token == '}')		break;  }#else  } while (testnext(ls, ',') || testnext(ls, ';'));#endif /* LUA_OPTIONAL_COMMA */  check_match(ls, '}', '{', line);  lastlistfield(fs, &cc);  SETARG_B(fs->f->code[pc], luaO_int2fb(cc.na)); /* set initial array size */  SETARG_C(fs->f->code[pc], luaO_int2fb(cc.nh));  /* set initial table size */}/* }====================================================================== */static void parlist (LexState *ls) {  /* parlist -> [ param { `,' param } ] */  FuncState *fs = ls->fs;  Proto *f = fs->f;  int nparams = 0;  f->is_vararg = 0;  if (ls->t.token != ')') {  /* is `parlist' not empty? */    do {      switch (ls->t.token) {        case TK_NAME: {  /* param -> NAME */          new_localvar(ls, str_checkname(ls), nparams++);          break;        }        case TK_DOTS: {  /* param -> `...' */          luaX_next(ls);#if defined(LUA_COMPAT_VARARG)          /* use `arg' as default name */          new_localvarliteral(ls, "arg", nparams++);          f->is_vararg = VARARG_HASARG | VARARG_NEEDSARG;#endif          f->is_vararg |= VARARG_ISVARARG;          break;        }        default: luaX_syntaxerror(ls, "<name> or " LUA_QL("...") " expected");      }    } while (!f->is_vararg && testnext(ls, ','));  }  adjustlocalvars(ls, nparams);  f->numparams = cast_byte(fs->nactvar - (f->is_vararg & VARARG_HASARG));  luaK_reserveregs(fs, fs->nactvar);  /* reserve register for parameters */}

static void ICACHE_FLASH_ATTR checkname(LexState *ls, expdesc *e) {  codestring(ls, e, str_checkname(ls));}

/*static*/ void LexState::checkname (/*LexState *ls,*/ expdesc *e) {	codestring(e, str_checkname());}