luna - luajit/src/host/minilua.c

   1/* This is a heavily customized and minimized copy of Lua 5.1.5. */
   2/* It's only used to build LuaJIT. It does NOT have all standard functions! */
   3/******************************************************************************
   4* Copyright (C) 1994-2012 Lua.org, PUC-Rio.  All rights reserved.
   5*
   6* Permission is hereby granted, free of charge, to any person obtaining
   7* a copy of this software and associated documentation files (the
   8* "Software"), to deal in the Software without restriction, including
   9* without limitation the rights to use, copy, modify, merge, publish,
  10* distribute, sublicense, and/or sell copies of the Software, and to
  11* permit persons to whom the Software is furnished to do so, subject to
  12* the following conditions:
  13*
  14* The above copyright notice and this permission notice shall be
  15* included in all copies or substantial portions of the Software.
  16*
  17* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  18* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  19* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  20* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
  21* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  22* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  23* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  24******************************************************************************/
  25#ifdef _MSC_VER
  26typedef unsigned __int64 U64;
  27#else
  28typedef unsigned long long U64;
  29#endif
  30int _CRT_glob = 0;
  31#include <stddef.h>
  32#include <stdarg.h>
  33#include <limits.h>
  34#include <math.h>
  35#include <ctype.h>
  36#include <stdio.h>
  37#include <stdlib.h>
  38#include <string.h>
  39#include <setjmp.h>
  40#include <errno.h>
  41#include <time.h>
  42typedef enum{
  43TM_INDEX,
  44TM_NEWINDEX,
  45TM_GC,
  46TM_MODE,
  47TM_EQ,
  48TM_ADD,
  49TM_SUB,
  50TM_MUL,
  51TM_DIV,
  52TM_MOD,
  53TM_POW,
  54TM_UNM,
  55TM_LEN,
  56TM_LT,
  57TM_LE,
  58TM_CONCAT,
  59TM_CALL,
  60TM_N
  61}TMS;
  62enum OpMode{iABC,iABx,iAsBx};
  63typedef enum{
  64OP_MOVE,
  65OP_LOADK,
  66OP_LOADBOOL,
  67OP_LOADNIL,
  68OP_GETUPVAL,
  69OP_GETGLOBAL,
  70OP_GETTABLE,
  71OP_SETGLOBAL,
  72OP_SETUPVAL,
  73OP_SETTABLE,
  74OP_NEWTABLE,
  75OP_SELF,
  76OP_ADD,
  77OP_SUB,
  78OP_MUL,
  79OP_DIV,
  80OP_MOD,
  81OP_POW,
  82OP_UNM,
  83OP_NOT,
  84OP_LEN,
  85OP_CONCAT,
  86OP_JMP,
  87OP_EQ,
  88OP_LT,
  89OP_LE,
  90OP_TEST,
  91OP_TESTSET,
  92OP_CALL,
  93OP_TAILCALL,
  94OP_RETURN,
  95OP_FORLOOP,
  96OP_FORPREP,
  97OP_TFORLOOP,
  98OP_SETLIST,
  99OP_CLOSE,
 100OP_CLOSURE,
 101OP_VARARG
 102}OpCode;
 103enum OpArgMask{
 104OpArgN,
 105OpArgU,
 106OpArgR,
 107OpArgK
 108};
 109typedef enum{
 110VVOID,
 111VNIL,
 112VTRUE,
 113VFALSE,
 114VK,
 115VKNUM,
 116VLOCAL,
 117VUPVAL,
 118VGLOBAL,
 119VINDEXED,
 120VJMP,
 121VRELOCABLE,
 122VNONRELOC,
 123VCALL,
 124VVARARG
 125}expkind;
 126enum RESERVED{
 127TK_AND=257,TK_BREAK,
 128TK_DO,TK_ELSE,TK_ELSEIF,TK_END,TK_FALSE,TK_FOR,TK_FUNCTION,
 129TK_IF,TK_IN,TK_LOCAL,TK_NIL,TK_NOT,TK_OR,TK_REPEAT,
 130TK_RETURN,TK_THEN,TK_TRUE,TK_UNTIL,TK_WHILE,
 131TK_CONCAT,TK_DOTS,TK_EQ,TK_GE,TK_LE,TK_NE,TK_NUMBER,
 132TK_NAME,TK_STRING,TK_EOS
 133};
 134typedef enum BinOpr{
 135OPR_ADD,OPR_SUB,OPR_MUL,OPR_DIV,OPR_MOD,OPR_POW,
 136OPR_CONCAT,
 137OPR_NE,OPR_EQ,
 138OPR_LT,OPR_LE,OPR_GT,OPR_GE,
 139OPR_AND,OPR_OR,
 140OPR_NOBINOPR
 141}BinOpr;
 142typedef enum UnOpr{OPR_MINUS,OPR_NOT,OPR_LEN,OPR_NOUNOPR}UnOpr;
 143#define LUA_QL(x)"'"x"'"
 144#define luai_apicheck(L,o){(void)L;}
 145#define lua_number2str(s,n)sprintf((s),"%.14g",(n))
 146#define lua_str2number(s,p)strtod((s),(p))
 147#define luai_numadd(a,b)((a)+(b))
 148#define luai_numsub(a,b)((a)-(b))
 149#define luai_nummul(a,b)((a)*(b))
 150#define luai_numdiv(a,b)((a)/(b))
 151#define luai_nummod(a,b)((a)-floor((a)/(b))*(b))
 152#define luai_numpow(a,b)(pow(a,b))
 153#define luai_numunm(a)(-(a))
 154#define luai_numeq(a,b)((a)==(b))
 155#define luai_numlt(a,b)((a)<(b))
 156#define luai_numle(a,b)((a)<=(b))
 157#define luai_numisnan(a)(!luai_numeq((a),(a)))
 158#define lua_number2int(i,d)((i)=(int)(d))
 159#define lua_number2integer(i,d)((i)=(lua_Integer)(d))
 160#define LUAI_THROW(L,c)longjmp((c)->b,1)
 161#define LUAI_TRY(L,c,a)if(setjmp((c)->b)==0){a}
 162#define lua_pclose(L,file)((void)((void)L,file),0)
 163#define lua_upvalueindex(i)((-10002)-(i))
 164typedef struct lua_State lua_State;
 165typedef int(*lua_CFunction)(lua_State*L);
 166typedef const char*(*lua_Reader)(lua_State*L,void*ud,size_t*sz);
 167typedef void*(*lua_Alloc)(void*ud,void*ptr,size_t osize,size_t nsize);
 168typedef double lua_Number;
 169typedef ptrdiff_t lua_Integer;
 170static void lua_settop(lua_State*L,int idx);
 171static int lua_type(lua_State*L,int idx);
 172static const char* lua_tolstring(lua_State*L,int idx,size_t*len);
 173static size_t lua_objlen(lua_State*L,int idx);
 174static void lua_pushlstring(lua_State*L,const char*s,size_t l);
 175static void lua_pushcclosure(lua_State*L,lua_CFunction fn,int n);
 176static void lua_createtable(lua_State*L,int narr,int nrec);
 177static void lua_setfield(lua_State*L,int idx,const char*k);
 178#define lua_pop(L,n)lua_settop(L,-(n)-1)
 179#define lua_newtable(L)lua_createtable(L,0,0)
 180#define lua_pushcfunction(L,f)lua_pushcclosure(L,(f),0)
 181#define lua_strlen(L,i)lua_objlen(L,(i))
 182#define lua_isfunction(L,n)(lua_type(L,(n))==6)
 183#define lua_istable(L,n)(lua_type(L,(n))==5)
 184#define lua_isnil(L,n)(lua_type(L,(n))==0)
 185#define lua_isboolean(L,n)(lua_type(L,(n))==1)
 186#define lua_isnone(L,n)(lua_type(L,(n))==(-1))
 187#define lua_isnoneornil(L,n)(lua_type(L,(n))<=0)
 188#define lua_pushliteral(L,s)lua_pushlstring(L,""s,(sizeof(s)/sizeof(char))-1)
 189#define lua_setglobal(L,s)lua_setfield(L,(-10002),(s))
 190#define lua_tostring(L,i)lua_tolstring(L,(i),NULL)
 191typedef struct lua_Debug lua_Debug;
 192typedef void(*lua_Hook)(lua_State*L,lua_Debug*ar);
 193struct lua_Debug{
 194int event;
 195const char*name;
 196const char*namewhat;
 197const char*what;
 198const char*source;
 199int currentline;
 200int nups;
 201int linedefined;
 202int lastlinedefined;
 203char short_src[60];
 204int i_ci;
 205};
 206typedef unsigned int lu_int32;
 207typedef size_t lu_mem;
 208typedef ptrdiff_t l_mem;
 209typedef unsigned char lu_byte;
 210#define IntPoint(p)((unsigned int)(lu_mem)(p))
 211typedef union{double u;void*s;long l;}L_Umaxalign;
 212typedef double l_uacNumber;
 213#define check_exp(c,e)(e)
 214#define UNUSED(x)((void)(x))
 215#define cast(t,exp)((t)(exp))
 216#define cast_byte(i)cast(lu_byte,(i))
 217#define cast_num(i)cast(lua_Number,(i))
 218#define cast_int(i)cast(int,(i))
 219typedef lu_int32 Instruction;
 220#define condhardstacktests(x)((void)0)
 221typedef union GCObject GCObject;
 222typedef struct GCheader{
 223GCObject*next;lu_byte tt;lu_byte marked;
 224}GCheader;
 225typedef union{
 226GCObject*gc;
 227void*p;
 228lua_Number n;
 229int b;
 230}Value;
 231typedef struct lua_TValue{
 232Value value;int tt;
 233}TValue;
 234#define ttisnil(o)(ttype(o)==0)
 235#define ttisnumber(o)(ttype(o)==3)
 236#define ttisstring(o)(ttype(o)==4)
 237#define ttistable(o)(ttype(o)==5)
 238#define ttisfunction(o)(ttype(o)==6)
 239#define ttisboolean(o)(ttype(o)==1)
 240#define ttisuserdata(o)(ttype(o)==7)
 241#define ttisthread(o)(ttype(o)==8)
 242#define ttislightuserdata(o)(ttype(o)==2)
 243#define ttype(o)((o)->tt)
 244#define gcvalue(o)check_exp(iscollectable(o),(o)->value.gc)
 245#define pvalue(o)check_exp(ttislightuserdata(o),(o)->value.p)
 246#define nvalue(o)check_exp(ttisnumber(o),(o)->value.n)
 247#define rawtsvalue(o)check_exp(ttisstring(o),&(o)->value.gc->ts)
 248#define tsvalue(o)(&rawtsvalue(o)->tsv)
 249#define rawuvalue(o)check_exp(ttisuserdata(o),&(o)->value.gc->u)
 250#define uvalue(o)(&rawuvalue(o)->uv)
 251#define clvalue(o)check_exp(ttisfunction(o),&(o)->value.gc->cl)
 252#define hvalue(o)check_exp(ttistable(o),&(o)->value.gc->h)
 253#define bvalue(o)check_exp(ttisboolean(o),(o)->value.b)
 254#define thvalue(o)check_exp(ttisthread(o),&(o)->value.gc->th)
 255#define l_isfalse(o)(ttisnil(o)||(ttisboolean(o)&&bvalue(o)==0))
 256#define checkconsistency(obj)
 257#define checkliveness(g,obj)
 258#define setnilvalue(obj)((obj)->tt=0)
 259#define setnvalue(obj,x){TValue*i_o=(obj);i_o->value.n=(x);i_o->tt=3;}
 260#define setbvalue(obj,x){TValue*i_o=(obj);i_o->value.b=(x);i_o->tt=1;}
 261#define setsvalue(L,obj,x){TValue*i_o=(obj);i_o->value.gc=cast(GCObject*,(x));i_o->tt=4;checkliveness(G(L),i_o);}
 262#define setuvalue(L,obj,x){TValue*i_o=(obj);i_o->value.gc=cast(GCObject*,(x));i_o->tt=7;checkliveness(G(L),i_o);}
 263#define setthvalue(L,obj,x){TValue*i_o=(obj);i_o->value.gc=cast(GCObject*,(x));i_o->tt=8;checkliveness(G(L),i_o);}
 264#define setclvalue(L,obj,x){TValue*i_o=(obj);i_o->value.gc=cast(GCObject*,(x));i_o->tt=6;checkliveness(G(L),i_o);}
 265#define sethvalue(L,obj,x){TValue*i_o=(obj);i_o->value.gc=cast(GCObject*,(x));i_o->tt=5;checkliveness(G(L),i_o);}
 266#define setptvalue(L,obj,x){TValue*i_o=(obj);i_o->value.gc=cast(GCObject*,(x));i_o->tt=(8+1);checkliveness(G(L),i_o);}
 267#define setobj(L,obj1,obj2){const TValue*o2=(obj2);TValue*o1=(obj1);o1->value=o2->value;o1->tt=o2->tt;checkliveness(G(L),o1);}
 268#define setttype(obj,tt)(ttype(obj)=(tt))
 269#define iscollectable(o)(ttype(o)>=4)
 270typedef TValue*StkId;
 271typedef union TString{
 272L_Umaxalign dummy;
 273struct{
 274GCObject*next;lu_byte tt;lu_byte marked;
 275lu_byte reserved;
 276unsigned int hash;
 277size_t len;
 278}tsv;
 279}TString;
 280#define getstr(ts)cast(const char*,(ts)+1)
 281#define svalue(o)getstr(rawtsvalue(o))
 282typedef union Udata{
 283L_Umaxalign dummy;
 284struct{
 285GCObject*next;lu_byte tt;lu_byte marked;
 286struct Table*metatable;
 287struct Table*env;
 288size_t len;
 289}uv;
 290}Udata;
 291typedef struct Proto{
 292GCObject*next;lu_byte tt;lu_byte marked;
 293TValue*k;
 294Instruction*code;
 295struct Proto**p;
 296int*lineinfo;
 297struct LocVar*locvars;
 298TString**upvalues;
 299TString*source;
 300int sizeupvalues;
 301int sizek;
 302int sizecode;
 303int sizelineinfo;
 304int sizep;
 305int sizelocvars;
 306int linedefined;
 307int lastlinedefined;
 308GCObject*gclist;
 309lu_byte nups;
 310lu_byte numparams;
 311lu_byte is_vararg;
 312lu_byte maxstacksize;
 313}Proto;
 314typedef struct LocVar{
 315TString*varname;
 316int startpc;
 317int endpc;
 318}LocVar;
 319typedef struct UpVal{
 320GCObject*next;lu_byte tt;lu_byte marked;
 321TValue*v;
 322union{
 323TValue value;
 324struct{
 325struct UpVal*prev;
 326struct UpVal*next;
 327}l;
 328}u;
 329}UpVal;
 330typedef struct CClosure{
 331GCObject*next;lu_byte tt;lu_byte marked;lu_byte isC;lu_byte nupvalues;GCObject*gclist;struct Table*env;
 332lua_CFunction f;
 333TValue upvalue[1];
 334}CClosure;
 335typedef struct LClosure{
 336GCObject*next;lu_byte tt;lu_byte marked;lu_byte isC;lu_byte nupvalues;GCObject*gclist;struct Table*env;
 337struct Proto*p;
 338UpVal*upvals[1];
 339}LClosure;
 340typedef union Closure{
 341CClosure c;
 342LClosure l;
 343}Closure;
 344#define iscfunction(o)(ttype(o)==6&&clvalue(o)->c.isC)
 345typedef union TKey{
 346struct{
 347Value value;int tt;
 348struct Node*next;
 349}nk;
 350TValue tvk;
 351}TKey;
 352typedef struct Node{
 353TValue i_val;
 354TKey i_key;
 355}Node;
 356typedef struct Table{
 357GCObject*next;lu_byte tt;lu_byte marked;
 358lu_byte flags;
 359lu_byte lsizenode;
 360struct Table*metatable;
 361TValue*array;
 362Node*node;
 363Node*lastfree;
 364GCObject*gclist;
 365int sizearray;
 366}Table;
 367#define lmod(s,size)(check_exp((size&(size-1))==0,(cast(int,(s)&((size)-1)))))
 368#define twoto(x)((size_t)1<<(x))
 369#define sizenode(t)(twoto((t)->lsizenode))
 370static const TValue luaO_nilobject_;
 371#define ceillog2(x)(luaO_log2((x)-1)+1)
 372static int luaO_log2(unsigned int x);
 373#define gfasttm(g,et,e)((et)==NULL?NULL:((et)->flags&(1u<<(e)))?NULL:luaT_gettm(et,e,(g)->tmname[e]))
 374#define fasttm(l,et,e)gfasttm(G(l),et,e)
 375static const TValue*luaT_gettm(Table*events,TMS event,TString*ename);
 376#define luaM_reallocv(L,b,on,n,e)((cast(size_t,(n)+1)<=((size_t)(~(size_t)0)-2)/(e))?luaM_realloc_(L,(b),(on)*(e),(n)*(e)):luaM_toobig(L))
 377#define luaM_freemem(L,b,s)luaM_realloc_(L,(b),(s),0)
 378#define luaM_free(L,b)luaM_realloc_(L,(b),sizeof(*(b)),0)
 379#define luaM_freearray(L,b,n,t)luaM_reallocv(L,(b),n,0,sizeof(t))
 380#define luaM_malloc(L,t)luaM_realloc_(L,NULL,0,(t))
 381#define luaM_new(L,t)cast(t*,luaM_malloc(L,sizeof(t)))
 382#define luaM_newvector(L,n,t)cast(t*,luaM_reallocv(L,NULL,0,n,sizeof(t)))
 383#define luaM_growvector(L,v,nelems,size,t,limit,e)if((nelems)+1>(size))((v)=cast(t*,luaM_growaux_(L,v,&(size),sizeof(t),limit,e)))
 384#define luaM_reallocvector(L,v,oldn,n,t)((v)=cast(t*,luaM_reallocv(L,v,oldn,n,sizeof(t))))
 385static void*luaM_realloc_(lua_State*L,void*block,size_t oldsize,
 386size_t size);
 387static void*luaM_toobig(lua_State*L);
 388static void*luaM_growaux_(lua_State*L,void*block,int*size,
 389size_t size_elem,int limit,
 390const char*errormsg);
 391typedef struct Zio ZIO;
 392#define char2int(c)cast(int,cast(unsigned char,(c)))
 393#define zgetc(z)(((z)->n--)>0?char2int(*(z)->p++):luaZ_fill(z))
 394typedef struct Mbuffer{
 395char*buffer;
 396size_t n;
 397size_t buffsize;
 398}Mbuffer;
 399#define luaZ_initbuffer(L,buff)((buff)->buffer=NULL,(buff)->buffsize=0)
 400#define luaZ_buffer(buff)((buff)->buffer)
 401#define luaZ_sizebuffer(buff)((buff)->buffsize)
 402#define luaZ_bufflen(buff)((buff)->n)
 403#define luaZ_resetbuffer(buff)((buff)->n=0)
 404#define luaZ_resizebuffer(L,buff,size)(luaM_reallocvector(L,(buff)->buffer,(buff)->buffsize,size,char),(buff)->buffsize=size)
 405#define luaZ_freebuffer(L,buff)luaZ_resizebuffer(L,buff,0)
 406struct Zio{
 407size_t n;
 408const char*p;
 409lua_Reader reader;
 410void*data;
 411lua_State*L;
 412};
 413static int luaZ_fill(ZIO*z);
 414struct lua_longjmp;
 415#define gt(L)(&L->l_gt)
 416#define registry(L)(&G(L)->l_registry)
 417typedef struct stringtable{
 418GCObject**hash;
 419lu_int32 nuse;
 420int size;
 421}stringtable;
 422typedef struct CallInfo{
 423StkId base;
 424StkId func;
 425StkId top;
 426const Instruction*savedpc;
 427int nresults;
 428int tailcalls;
 429}CallInfo;
 430#define curr_func(L)(clvalue(L->ci->func))
 431#define ci_func(ci)(clvalue((ci)->func))
 432#define f_isLua(ci)(!ci_func(ci)->c.isC)
 433#define isLua(ci)(ttisfunction((ci)->func)&&f_isLua(ci))
 434typedef struct global_State{
 435stringtable strt;
 436lua_Alloc frealloc;
 437void*ud;
 438lu_byte currentwhite;
 439lu_byte gcstate;
 440int sweepstrgc;
 441GCObject*rootgc;
 442GCObject**sweepgc;
 443GCObject*gray;
 444GCObject*grayagain;
 445GCObject*weak;
 446GCObject*tmudata;
 447Mbuffer buff;
 448lu_mem GCthreshold;
 449lu_mem totalbytes;
 450lu_mem estimate;
 451lu_mem gcdept;
 452int gcpause;
 453int gcstepmul;
 454lua_CFunction panic;
 455TValue l_registry;
 456struct lua_State*mainthread;
 457UpVal uvhead;
 458struct Table*mt[(8+1)];
 459TString*tmname[TM_N];
 460}global_State;
 461struct lua_State{
 462GCObject*next;lu_byte tt;lu_byte marked;
 463lu_byte status;
 464StkId top;
 465StkId base;
 466global_State*l_G;
 467CallInfo*ci;
 468const Instruction*savedpc;
 469StkId stack_last;
 470StkId stack;
 471CallInfo*end_ci;
 472CallInfo*base_ci;
 473int stacksize;
 474int size_ci;
 475unsigned short nCcalls;
 476unsigned short baseCcalls;
 477lu_byte hookmask;
 478lu_byte allowhook;
 479int basehookcount;
 480int hookcount;
 481lua_Hook hook;
 482TValue l_gt;
 483TValue env;
 484GCObject*openupval;
 485GCObject*gclist;
 486struct lua_longjmp*errorJmp;
 487ptrdiff_t errfunc;
 488};
 489#define G(L)(L->l_G)
 490union GCObject{
 491GCheader gch;
 492union TString ts;
 493union Udata u;
 494union Closure cl;
 495struct Table h;
 496struct Proto p;
 497struct UpVal uv;
 498struct lua_State th;
 499};
 500#define rawgco2ts(o)check_exp((o)->gch.tt==4,&((o)->ts))
 501#define gco2ts(o)(&rawgco2ts(o)->tsv)
 502#define rawgco2u(o)check_exp((o)->gch.tt==7,&((o)->u))
 503#define gco2u(o)(&rawgco2u(o)->uv)
 504#define gco2cl(o)check_exp((o)->gch.tt==6,&((o)->cl))
 505#define gco2h(o)check_exp((o)->gch.tt==5,&((o)->h))
 506#define gco2p(o)check_exp((o)->gch.tt==(8+1),&((o)->p))
 507#define gco2uv(o)check_exp((o)->gch.tt==(8+2),&((o)->uv))
 508#define ngcotouv(o)check_exp((o)==NULL||(o)->gch.tt==(8+2),&((o)->uv))
 509#define gco2th(o)check_exp((o)->gch.tt==8,&((o)->th))
 510#define obj2gco(v)(cast(GCObject*,(v)))
 511static void luaE_freethread(lua_State*L,lua_State*L1);
 512#define pcRel(pc,p)(cast(int,(pc)-(p)->code)-1)
 513#define getline_(f,pc)(((f)->lineinfo)?(f)->lineinfo[pc]:0)
 514#define resethookcount(L)(L->hookcount=L->basehookcount)
 515static void luaG_typeerror(lua_State*L,const TValue*o,
 516const char*opname);
 517static void luaG_runerror(lua_State*L,const char*fmt,...);
 518#define luaD_checkstack(L,n)if((char*)L->stack_last-(char*)L->top<=(n)*(int)sizeof(TValue))luaD_growstack(L,n);else condhardstacktests(luaD_reallocstack(L,L->stacksize-5-1));
 519#define incr_top(L){luaD_checkstack(L,1);L->top++;}
 520#define savestack(L,p)((char*)(p)-(char*)L->stack)
 521#define restorestack(L,n)((TValue*)((char*)L->stack+(n)))
 522#define saveci(L,p)((char*)(p)-(char*)L->base_ci)
 523#define restoreci(L,n)((CallInfo*)((char*)L->base_ci+(n)))
 524typedef void(*Pfunc)(lua_State*L,void*ud);
 525static int luaD_poscall(lua_State*L,StkId firstResult);
 526static void luaD_reallocCI(lua_State*L,int newsize);
 527static void luaD_reallocstack(lua_State*L,int newsize);
 528static void luaD_growstack(lua_State*L,int n);
 529static void luaD_throw(lua_State*L,int errcode);
 530static void*luaM_growaux_(lua_State*L,void*block,int*size,size_t size_elems,
 531int limit,const char*errormsg){
 532void*newblock;
 533int newsize;
 534if(*size>=limit/2){
 535if(*size>=limit)
 536luaG_runerror(L,errormsg);
 537newsize=limit;
 538}
 539else{
 540newsize=(*size)*2;
 541if(newsize<4)
 542newsize=4;
 543}
 544newblock=luaM_reallocv(L,block,*size,newsize,size_elems);
 545*size=newsize;
 546return newblock;
 547}
 548static void*luaM_toobig(lua_State*L){
 549luaG_runerror(L,"memory allocation error: block too big");
 550return NULL;
 551}
 552static void*luaM_realloc_(lua_State*L,void*block,size_t osize,size_t nsize){
 553global_State*g=G(L);
 554block=(*g->frealloc)(g->ud,block,osize,nsize);
 555if(block==NULL&&nsize>0)
 556luaD_throw(L,4);
 557g->totalbytes=(g->totalbytes-osize)+nsize;
 558return block;
 559}
 560#define resetbits(x,m)((x)&=cast(lu_byte,~(m)))
 561#define setbits(x,m)((x)|=(m))
 562#define testbits(x,m)((x)&(m))
 563#define bitmask(b)(1<<(b))
 564#define bit2mask(b1,b2)(bitmask(b1)|bitmask(b2))
 565#define l_setbit(x,b)setbits(x,bitmask(b))
 566#define resetbit(x,b)resetbits(x,bitmask(b))
 567#define testbit(x,b)testbits(x,bitmask(b))
 568#define set2bits(x,b1,b2)setbits(x,(bit2mask(b1,b2)))
 569#define reset2bits(x,b1,b2)resetbits(x,(bit2mask(b1,b2)))
 570#define test2bits(x,b1,b2)testbits(x,(bit2mask(b1,b2)))
 571#define iswhite(x)test2bits((x)->gch.marked,0,1)
 572#define isblack(x)testbit((x)->gch.marked,2)
 573#define isgray(x)(!isblack(x)&&!iswhite(x))
 574#define otherwhite(g)(g->currentwhite^bit2mask(0,1))
 575#define isdead(g,v)((v)->gch.marked&otherwhite(g)&bit2mask(0,1))
 576#define changewhite(x)((x)->gch.marked^=bit2mask(0,1))
 577#define gray2black(x)l_setbit((x)->gch.marked,2)
 578#define valiswhite(x)(iscollectable(x)&&iswhite(gcvalue(x)))
 579#define luaC_white(g)cast(lu_byte,(g)->currentwhite&bit2mask(0,1))
 580#define luaC_checkGC(L){condhardstacktests(luaD_reallocstack(L,L->stacksize-5-1));if(G(L)->totalbytes>=G(L)->GCthreshold)luaC_step(L);}
 581#define luaC_barrier(L,p,v){if(valiswhite(v)&&isblack(obj2gco(p)))luaC_barrierf(L,obj2gco(p),gcvalue(v));}
 582#define luaC_barriert(L,t,v){if(valiswhite(v)&&isblack(obj2gco(t)))luaC_barrierback(L,t);}
 583#define luaC_objbarrier(L,p,o){if(iswhite(obj2gco(o))&&isblack(obj2gco(p)))luaC_barrierf(L,obj2gco(p),obj2gco(o));}
 584#define luaC_objbarriert(L,t,o){if(iswhite(obj2gco(o))&&isblack(obj2gco(t)))luaC_barrierback(L,t);}
 585static void luaC_step(lua_State*L);
 586static void luaC_link(lua_State*L,GCObject*o,lu_byte tt);
 587static void luaC_linkupval(lua_State*L,UpVal*uv);
 588static void luaC_barrierf(lua_State*L,GCObject*o,GCObject*v);
 589static void luaC_barrierback(lua_State*L,Table*t);
 590#define sizestring(s)(sizeof(union TString)+((s)->len+1)*sizeof(char))
 591#define sizeudata(u)(sizeof(union Udata)+(u)->len)
 592#define luaS_new(L,s)(luaS_newlstr(L,s,strlen(s)))
 593#define luaS_newliteral(L,s)(luaS_newlstr(L,""s,(sizeof(s)/sizeof(char))-1))
 594#define luaS_fix(s)l_setbit((s)->tsv.marked,5)
 595static TString*luaS_newlstr(lua_State*L,const char*str,size_t l);
 596#define tostring(L,o)((ttype(o)==4)||(luaV_tostring(L,o)))
 597#define tonumber(o,n)(ttype(o)==3||(((o)=luaV_tonumber(o,n))!=NULL))
 598#define equalobj(L,o1,o2)(ttype(o1)==ttype(o2)&&luaV_equalval(L,o1,o2))
 599static int luaV_equalval(lua_State*L,const TValue*t1,const TValue*t2);
 600static const TValue*luaV_tonumber(const TValue*obj,TValue*n);
 601static int luaV_tostring(lua_State*L,StkId obj);
 602static void luaV_execute(lua_State*L,int nexeccalls);
 603static void luaV_concat(lua_State*L,int total,int last);
 604static const TValue luaO_nilobject_={{NULL},0};
 605static int luaO_int2fb(unsigned int x){
 606int e=0;
 607while(x>=16){
 608x=(x+1)>>1;
 609e++;
 610}
 611if(x<8)return x;
 612else return((e+1)<<3)|(cast_int(x)-8);
 613}
 614static int luaO_fb2int(int x){
 615int e=(x>>3)&31;
 616if(e==0)return x;
 617else return((x&7)+8)<<(e-1);
 618}
 619static int luaO_log2(unsigned int x){
 620static const lu_byte log_2[256]={
 6210,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
 6226,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
 6237,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
 6247,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
 6258,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
 6268,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
 6278,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
 6288,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8
 629};
 630int l=-1;
 631while(x>=256){l+=8;x>>=8;}
 632return l+log_2[x];
 633}
 634static int luaO_rawequalObj(const TValue*t1,const TValue*t2){
 635if(ttype(t1)!=ttype(t2))return 0;
 636else switch(ttype(t1)){
 637case 0:
 638return 1;
 639case 3:
 640return luai_numeq(nvalue(t1),nvalue(t2));
 641case 1:
 642return bvalue(t1)==bvalue(t2);
 643case 2:
 644return pvalue(t1)==pvalue(t2);
 645default:
 646return gcvalue(t1)==gcvalue(t2);
 647}
 648}
 649static int luaO_str2d(const char*s,lua_Number*result){
 650char*endptr;
 651*result=lua_str2number(s,&endptr);
 652if(endptr==s)return 0;
 653if(*endptr=='x'||*endptr=='X')
 654*result=cast_num(strtoul(s,&endptr,16));
 655if(*endptr=='\0')return 1;
 656while(isspace(cast(unsigned char,*endptr)))endptr++;
 657if(*endptr!='\0')return 0;
 658return 1;
 659}
 660static void pushstr(lua_State*L,const char*str){
 661setsvalue(L,L->top,luaS_new(L,str));
 662incr_top(L);
 663}
 664static const char*luaO_pushvfstring(lua_State*L,const char*fmt,va_list argp){
 665int n=1;
 666pushstr(L,"");
 667for(;;){
 668const char*e=strchr(fmt,'%');
 669if(e==NULL)break;
 670setsvalue(L,L->top,luaS_newlstr(L,fmt,e-fmt));
 671incr_top(L);
 672switch(*(e+1)){
 673case's':{
 674const char*s=va_arg(argp,char*);
 675if(s==NULL)s="(null)";
 676pushstr(L,s);
 677break;
 678}
 679case'c':{
 680char buff[2];
 681buff[0]=cast(char,va_arg(argp,int));
 682buff[1]='\0';
 683pushstr(L,buff);
 684break;
 685}
 686case'd':{
 687setnvalue(L->top,cast_num(va_arg(argp,int)));
 688incr_top(L);
 689break;
 690}
 691case'f':{
 692setnvalue(L->top,cast_num(va_arg(argp,l_uacNumber)));
 693incr_top(L);
 694break;
 695}
 696case'p':{
 697char buff[4*sizeof(void*)+8];
 698sprintf(buff,"%p",va_arg(argp,void*));
 699pushstr(L,buff);
 700break;
 701}
 702case'%':{
 703pushstr(L,"%");
 704break;
 705}
 706default:{
 707char buff[3];
 708buff[0]='%';
 709buff[1]=*(e+1);
 710buff[2]='\0';
 711pushstr(L,buff);
 712break;
 713}
 714}
 715n+=2;
 716fmt=e+2;
 717}
 718pushstr(L,fmt);
 719luaV_concat(L,n+1,cast_int(L->top-L->base)-1);
 720L->top-=n;
 721return svalue(L->top-1);
 722}
 723static const char*luaO_pushfstring(lua_State*L,const char*fmt,...){
 724const char*msg;
 725va_list argp;
 726va_start(argp,fmt);
 727msg=luaO_pushvfstring(L,fmt,argp);
 728va_end(argp);
 729return msg;
 730}
 731static void luaO_chunkid(char*out,const char*source,size_t bufflen){
 732if(*source=='='){
 733strncpy(out,source+1,bufflen);
 734out[bufflen-1]='\0';
 735}
 736else{
 737if(*source=='@'){
 738size_t l;
 739source++;
 740bufflen-=sizeof(" '...' ");
 741l=strlen(source);
 742strcpy(out,"");
 743if(l>bufflen){
 744source+=(l-bufflen);
 745strcat(out,"...");
 746}
 747strcat(out,source);
 748}
 749else{
 750size_t len=strcspn(source,"\n\r");
 751bufflen-=sizeof(" [string \"...\"] ");
 752if(len>bufflen)len=bufflen;
 753strcpy(out,"[string \"");
 754if(source[len]!='\0'){
 755strncat(out,source,len);
 756strcat(out,"...");
 757}
 758else
 759strcat(out,source);
 760strcat(out,"\"]");
 761}
 762}
 763}
 764#define gnode(t,i)(&(t)->node[i])
 765#define gkey(n)(&(n)->i_key.nk)
 766#define gval(n)(&(n)->i_val)
 767#define gnext(n)((n)->i_key.nk.next)
 768#define key2tval(n)(&(n)->i_key.tvk)
 769static TValue*luaH_setnum(lua_State*L,Table*t,int key);
 770static const TValue*luaH_getstr(Table*t,TString*key);
 771static TValue*luaH_set(lua_State*L,Table*t,const TValue*key);
 772static const char*const luaT_typenames[]={
 773"nil","boolean","userdata","number",
 774"string","table","function","userdata","thread",
 775"proto","upval"
 776};
 777static void luaT_init(lua_State*L){
 778static const char*const luaT_eventname[]={
 779"__index","__newindex",
 780"__gc","__mode","__eq",
 781"__add","__sub","__mul","__div","__mod",
 782"__pow","__unm","__len","__lt","__le",
 783"__concat","__call"
 784};
 785int i;
 786for(i=0;i<TM_N;i++){
 787G(L)->tmname[i]=luaS_new(L,luaT_eventname[i]);
 788luaS_fix(G(L)->tmname[i]);
 789}
 790}
 791static const TValue*luaT_gettm(Table*events,TMS event,TString*ename){
 792const TValue*tm=luaH_getstr(events,ename);
 793if(ttisnil(tm)){
 794events->flags|=cast_byte(1u<<event);
 795return NULL;
 796}
 797else return tm;
 798}
 799static const TValue*luaT_gettmbyobj(lua_State*L,const TValue*o,TMS event){
 800Table*mt;
 801switch(ttype(o)){
 802case 5:
 803mt=hvalue(o)->metatable;
 804break;
 805case 7:
 806mt=uvalue(o)->metatable;
 807break;
 808default:
 809mt=G(L)->mt[ttype(o)];
 810}
 811return(mt?luaH_getstr(mt,G(L)->tmname[event]):(&luaO_nilobject_));
 812}
 813#define sizeCclosure(n)(cast(int,sizeof(CClosure))+cast(int,sizeof(TValue)*((n)-1)))
 814#define sizeLclosure(n)(cast(int,sizeof(LClosure))+cast(int,sizeof(TValue*)*((n)-1)))
 815static Closure*luaF_newCclosure(lua_State*L,int nelems,Table*e){
 816Closure*c=cast(Closure*,luaM_malloc(L,sizeCclosure(nelems)));
 817luaC_link(L,obj2gco(c),6);
 818c->c.isC=1;
 819c->c.env=e;
 820c->c.nupvalues=cast_byte(nelems);
 821return c;
 822}
 823static Closure*luaF_newLclosure(lua_State*L,int nelems,Table*e){
 824Closure*c=cast(Closure*,luaM_malloc(L,sizeLclosure(nelems)));
 825luaC_link(L,obj2gco(c),6);
 826c->l.isC=0;
 827c->l.env=e;
 828c->l.nupvalues=cast_byte(nelems);
 829while(nelems--)c->l.upvals[nelems]=NULL;
 830return c;
 831}
 832static UpVal*luaF_newupval(lua_State*L){
 833UpVal*uv=luaM_new(L,UpVal);
 834luaC_link(L,obj2gco(uv),(8+2));
 835uv->v=&uv->u.value;
 836setnilvalue(uv->v);
 837return uv;
 838}
 839static UpVal*luaF_findupval(lua_State*L,StkId level){
 840global_State*g=G(L);
 841GCObject**pp=&L->openupval;
 842UpVal*p;
 843UpVal*uv;
 844while(*pp!=NULL&&(p=ngcotouv(*pp))->v>=level){
 845if(p->v==level){
 846if(isdead(g,obj2gco(p)))
 847changewhite(obj2gco(p));
 848return p;
 849}
 850pp=&p->next;
 851}
 852uv=luaM_new(L,UpVal);
 853uv->tt=(8+2);
 854uv->marked=luaC_white(g);
 855uv->v=level;
 856uv->next=*pp;
 857*pp=obj2gco(uv);
 858uv->u.l.prev=&g->uvhead;
 859uv->u.l.next=g->uvhead.u.l.next;
 860uv->u.l.next->u.l.prev=uv;
 861g->uvhead.u.l.next=uv;
 862return uv;
 863}
 864static void unlinkupval(UpVal*uv){
 865uv->u.l.next->u.l.prev=uv->u.l.prev;
 866uv->u.l.prev->u.l.next=uv->u.l.next;
 867}
 868static void luaF_freeupval(lua_State*L,UpVal*uv){
 869if(uv->v!=&uv->u.value)
 870unlinkupval(uv);
 871luaM_free(L,uv);
 872}
 873static void luaF_close(lua_State*L,StkId level){
 874UpVal*uv;
 875global_State*g=G(L);
 876while(L->openupval!=NULL&&(uv=ngcotouv(L->openupval))->v>=level){
 877GCObject*o=obj2gco(uv);
 878L->openupval=uv->next;
 879if(isdead(g,o))
 880luaF_freeupval(L,uv);
 881else{
 882unlinkupval(uv);
 883setobj(L,&uv->u.value,uv->v);
 884uv->v=&uv->u.value;
 885luaC_linkupval(L,uv);
 886}
 887}
 888}
 889static Proto*luaF_newproto(lua_State*L){
 890Proto*f=luaM_new(L,Proto);
 891luaC_link(L,obj2gco(f),(8+1));
 892f->k=NULL;
 893f->sizek=0;
 894f->p=NULL;
 895f->sizep=0;
 896f->code=NULL;
 897f->sizecode=0;
 898f->sizelineinfo=0;
 899f->sizeupvalues=0;
 900f->nups=0;
 901f->upvalues=NULL;
 902f->numparams=0;
 903f->is_vararg=0;
 904f->maxstacksize=0;
 905f->lineinfo=NULL;
 906f->sizelocvars=0;
 907f->locvars=NULL;
 908f->linedefined=0;
 909f->lastlinedefined=0;
 910f->source=NULL;
 911return f;
 912}
 913static void luaF_freeproto(lua_State*L,Proto*f){
 914luaM_freearray(L,f->code,f->sizecode,Instruction);
 915luaM_freearray(L,f->p,f->sizep,Proto*);
 916luaM_freearray(L,f->k,f->sizek,TValue);
 917luaM_freearray(L,f->lineinfo,f->sizelineinfo,int);
 918luaM_freearray(L,f->locvars,f->sizelocvars,struct LocVar);
 919luaM_freearray(L,f->upvalues,f->sizeupvalues,TString*);
 920luaM_free(L,f);
 921}
 922static void luaF_freeclosure(lua_State*L,Closure*c){
 923int size=(c->c.isC)?sizeCclosure(c->c.nupvalues):
 924sizeLclosure(c->l.nupvalues);
 925luaM_freemem(L,c,size);
 926}
 927#define MASK1(n,p)((~((~(Instruction)0)<<n))<<p)
 928#define MASK0(n,p)(~MASK1(n,p))
 929#define GET_OPCODE(i)(cast(OpCode,((i)>>0)&MASK1(6,0)))
 930#define SET_OPCODE(i,o)((i)=(((i)&MASK0(6,0))|((cast(Instruction,o)<<0)&MASK1(6,0))))
 931#define GETARG_A(i)(cast(int,((i)>>(0+6))&MASK1(8,0)))
 932#define SETARG_A(i,u)((i)=(((i)&MASK0(8,(0+6)))|((cast(Instruction,u)<<(0+6))&MASK1(8,(0+6)))))
 933#define GETARG_B(i)(cast(int,((i)>>(((0+6)+8)+9))&MASK1(9,0)))
 934#define SETARG_B(i,b)((i)=(((i)&MASK0(9,(((0+6)+8)+9)))|((cast(Instruction,b)<<(((0+6)+8)+9))&MASK1(9,(((0+6)+8)+9)))))
 935#define GETARG_C(i)(cast(int,((i)>>((0+6)+8))&MASK1(9,0)))
 936#define SETARG_C(i,b)((i)=(((i)&MASK0(9,((0+6)+8)))|((cast(Instruction,b)<<((0+6)+8))&MASK1(9,((0+6)+8)))))
 937#define GETARG_Bx(i)(cast(int,((i)>>((0+6)+8))&MASK1((9+9),0)))
 938#define SETARG_Bx(i,b)((i)=(((i)&MASK0((9+9),((0+6)+8)))|((cast(Instruction,b)<<((0+6)+8))&MASK1((9+9),((0+6)+8)))))
 939#define GETARG_sBx(i)(GETARG_Bx(i)-(((1<<(9+9))-1)>>1))
 940#define SETARG_sBx(i,b)SETARG_Bx((i),cast(unsigned int,(b)+(((1<<(9+9))-1)>>1)))
 941#define CREATE_ABC(o,a,b,c)((cast(Instruction,o)<<0)|(cast(Instruction,a)<<(0+6))|(cast(Instruction,b)<<(((0+6)+8)+9))|(cast(Instruction,c)<<((0+6)+8)))
 942#define CREATE_ABx(o,a,bc)((cast(Instruction,o)<<0)|(cast(Instruction,a)<<(0+6))|(cast(Instruction,bc)<<((0+6)+8)))
 943#define ISK(x)((x)&(1<<(9-1)))
 944#define INDEXK(r)((int)(r)&~(1<<(9-1)))
 945#define RKASK(x)((x)|(1<<(9-1)))
 946static const lu_byte luaP_opmodes[(cast(int,OP_VARARG)+1)];
 947#define getBMode(m)(cast(enum OpArgMask,(luaP_opmodes[m]>>4)&3))
 948#define getCMode(m)(cast(enum OpArgMask,(luaP_opmodes[m]>>2)&3))
 949#define testTMode(m)(luaP_opmodes[m]&(1<<7))
 950typedef struct expdesc{
 951expkind k;
 952union{
 953struct{int info,aux;}s;
 954lua_Number nval;
 955}u;
 956int t;
 957int f;
 958}expdesc;
 959typedef struct upvaldesc{
 960lu_byte k;
 961lu_byte info;
 962}upvaldesc;
 963struct BlockCnt;
 964typedef struct FuncState{
 965Proto*f;
 966Table*h;
 967struct FuncState*prev;
 968struct LexState*ls;
 969struct lua_State*L;
 970struct BlockCnt*bl;
 971int pc;
 972int lasttarget;
 973int jpc;
 974int freereg;
 975int nk;
 976int np;
 977short nlocvars;
 978lu_byte nactvar;
 979upvaldesc upvalues[60];
 980unsigned short actvar[200];
 981}FuncState;
 982static Proto*luaY_parser(lua_State*L,ZIO*z,Mbuffer*buff,
 983const char*name);
 984struct lua_longjmp{
 985struct lua_longjmp*previous;
 986jmp_buf b;
 987volatile int status;
 988};
 989static void luaD_seterrorobj(lua_State*L,int errcode,StkId oldtop){
 990switch(errcode){
 991case 4:{
 992setsvalue(L,oldtop,luaS_newliteral(L,"not enough memory"));
 993break;
 994}
 995case 5:{
 996setsvalue(L,oldtop,luaS_newliteral(L,"error in error handling"));
 997break;
 998}
 999case 3:
1000case 2:{
1001setobj(L,oldtop,L->top-1);
1002break;
1003}
1004}
1005L->top=oldtop+1;
1006}
1007static void restore_stack_limit(lua_State*L){
1008if(L->size_ci>20000){
1009int inuse=cast_int(L->ci-L->base_ci);
1010if(inuse+1<20000)
1011luaD_reallocCI(L,20000);
1012}
1013}
1014static void resetstack(lua_State*L,int status){
1015L->ci=L->base_ci;
1016L->base=L->ci->base;
1017luaF_close(L,L->base);
1018luaD_seterrorobj(L,status,L->base);
1019L->nCcalls=L->baseCcalls;
1020L->allowhook=1;
1021restore_stack_limit(L);
1022L->errfunc=0;
1023L->errorJmp=NULL;
1024}
1025static void luaD_throw(lua_State*L,int errcode){
1026if(L->errorJmp){
1027L->errorJmp->status=errcode;
1028LUAI_THROW(L,L->errorJmp);
1029}
1030else{
1031L->status=cast_byte(errcode);
1032if(G(L)->panic){
1033resetstack(L,errcode);
1034G(L)->panic(L);
1035}
1036exit(EXIT_FAILURE);
1037}
1038}
1039static int luaD_rawrunprotected(lua_State*L,Pfunc f,void*ud){
1040struct lua_longjmp lj;
1041lj.status=0;
1042lj.previous=L->errorJmp;
1043L->errorJmp=&lj;
1044LUAI_TRY(L,&lj,
1045(*f)(L,ud);
1046);
1047L->errorJmp=lj.previous;
1048return lj.status;
1049}
1050static void correctstack(lua_State*L,TValue*oldstack){
1051CallInfo*ci;
1052GCObject*up;
1053L->top=(L->top-oldstack)+L->stack;
1054for(up=L->openupval;up!=NULL;up=up->gch.next)
1055gco2uv(up)->v=(gco2uv(up)->v-oldstack)+L->stack;
1056for(ci=L->base_ci;ci<=L->ci;ci++){
1057ci->top=(ci->top-oldstack)+L->stack;
1058ci->base=(ci->base-oldstack)+L->stack;
1059ci->func=(ci->func-oldstack)+L->stack;
1060}
1061L->base=(L->base-oldstack)+L->stack;
1062}
1063static void luaD_reallocstack(lua_State*L,int newsize){
1064TValue*oldstack=L->stack;
1065int realsize=newsize+1+5;
1066luaM_reallocvector(L,L->stack,L->stacksize,realsize,TValue);
1067L->stacksize=realsize;
1068L->stack_last=L->stack+newsize;
1069correctstack(L,oldstack);
1070}
1071static void luaD_reallocCI(lua_State*L,int newsize){
1072CallInfo*oldci=L->base_ci;
1073luaM_reallocvector(L,L->base_ci,L->size_ci,newsize,CallInfo);
1074L->size_ci=newsize;
1075L->ci=(L->ci-oldci)+L->base_ci;
1076L->end_ci=L->base_ci+L->size_ci-1;
1077}
1078static void luaD_growstack(lua_State*L,int n){
1079if(n<=L->stacksize)
1080luaD_reallocstack(L,2*L->stacksize);
1081else
1082luaD_reallocstack(L,L->stacksize+n);
1083}
1084static CallInfo*growCI(lua_State*L){
1085if(L->size_ci>20000)
1086luaD_throw(L,5);
1087else{
1088luaD_reallocCI(L,2*L->size_ci);
1089if(L->size_ci>20000)
1090luaG_runerror(L,"stack overflow");
1091}
1092return++L->ci;
1093}
1094static StkId adjust_varargs(lua_State*L,Proto*p,int actual){
1095int i;
1096int nfixargs=p->numparams;
1097Table*htab=NULL;
1098StkId base,fixed;
1099for(;actual<nfixargs;++actual)
1100setnilvalue(L->top++);
1101fixed=L->top-actual;
1102base=L->top;
1103for(i=0;i<nfixargs;i++){
1104setobj(L,L->top++,fixed+i);
1105setnilvalue(fixed+i);
1106}
1107if(htab){
1108sethvalue(L,L->top++,htab);
1109}
1110return base;
1111}
1112static StkId tryfuncTM(lua_State*L,StkId func){
1113const TValue*tm=luaT_gettmbyobj(L,func,TM_CALL);
1114StkId p;
1115ptrdiff_t funcr=savestack(L,func);
1116if(!ttisfunction(tm))
1117luaG_typeerror(L,func,"call");
1118for(p=L->top;p>func;p--)setobj(L,p,p-1);
1119incr_top(L);
1120func=restorestack(L,funcr);
1121setobj(L,func,tm);
1122return func;
1123}
1124#define inc_ci(L)((L->ci==L->end_ci)?growCI(L):(condhardstacktests(luaD_reallocCI(L,L->size_ci)),++L->ci))
1125static int luaD_precall(lua_State*L,StkId func,int nresults){
1126LClosure*cl;
1127ptrdiff_t funcr;
1128if(!ttisfunction(func))
1129func=tryfuncTM(L,func);
1130funcr=savestack(L,func);
1131cl=&clvalue(func)->l;
1132L->ci->savedpc=L->savedpc;
1133if(!cl->isC){
1134CallInfo*ci;
1135StkId st,base;
1136Proto*p=cl->p;
1137luaD_checkstack(L,p->maxstacksize+p->numparams);
1138func=restorestack(L,funcr);
1139if(!p->is_vararg){
1140base=func+1;
1141if(L->top>base+p->numparams)
1142L->top=base+p->numparams;
1143}
1144else{
1145int nargs=cast_int(L->top-func)-1;
1146base=adjust_varargs(L,p,nargs);
1147func=restorestack(L,funcr);
1148}
1149ci=inc_ci(L);
1150ci->func=func;
1151L->base=ci->base=base;
1152ci->top=L->base+p->maxstacksize;
1153L->savedpc=p->code;
1154ci->tailcalls=0;
1155ci->nresults=nresults;
1156for(st=L->top;st<ci->top;st++)
1157setnilvalue(st);
1158L->top=ci->top;
1159return 0;
1160}
1161else{
1162CallInfo*ci;
1163int n;
1164luaD_checkstack(L,20);
1165ci=inc_ci(L);
1166ci->func=restorestack(L,funcr);
1167L->base=ci->base=ci->func+1;
1168ci->top=L->top+20;
1169ci->nresults=nresults;
1170n=(*curr_func(L)->c.f)(L);
1171if(n<0)
1172return 2;
1173else{
1174luaD_poscall(L,L->top-n);
1175return 1;
1176}
1177}
1178}
1179static int luaD_poscall(lua_State*L,StkId firstResult){
1180StkId res;
1181int wanted,i;
1182CallInfo*ci;
1183ci=L->ci--;
1184res=ci->func;
1185wanted=ci->nresults;
1186L->base=(ci-1)->base;
1187L->savedpc=(ci-1)->savedpc;
1188for(i=wanted;i!=0&&firstResult<L->top;i--)
1189setobj(L,res++,firstResult++);
1190while(i-->0)
1191setnilvalue(res++);
1192L->top=res;
1193return(wanted-(-1));
1194}
1195static void luaD_call(lua_State*L,StkId func,int nResults){
1196if(++L->nCcalls>=200){
1197if(L->nCcalls==200)
1198luaG_runerror(L,"C stack overflow");
1199else if(L->nCcalls>=(200+(200>>3)))
1200luaD_throw(L,5);
1201}
1202if(luaD_precall(L,func,nResults)==0)
1203luaV_execute(L,1);
1204L->nCcalls--;
1205luaC_checkGC(L);
1206}
1207static int luaD_pcall(lua_State*L,Pfunc func,void*u,
1208ptrdiff_t old_top,ptrdiff_t ef){
1209int status;
1210unsigned short oldnCcalls=L->nCcalls;
1211ptrdiff_t old_ci=saveci(L,L->ci);
1212lu_byte old_allowhooks=L->allowhook;
1213ptrdiff_t old_errfunc=L->errfunc;
1214L->errfunc=ef;
1215status=luaD_rawrunprotected(L,func,u);
1216if(status!=0){
1217StkId oldtop=restorestack(L,old_top);
1218luaF_close(L,oldtop);
1219luaD_seterrorobj(L,status,oldtop);
1220L->nCcalls=oldnCcalls;
1221L->ci=restoreci(L,old_ci);
1222L->base=L->ci->base;
1223L->savedpc=L->ci->savedpc;
1224L->allowhook=old_allowhooks;
1225restore_stack_limit(L);
1226}
1227L->errfunc=old_errfunc;
1228return status;
1229}
1230struct SParser{
1231ZIO*z;
1232Mbuffer buff;
1233const char*name;
1234};
1235static void f_parser(lua_State*L,void*ud){
1236int i;
1237Proto*tf;
1238Closure*cl;
1239struct SParser*p=cast(struct SParser*,ud);
1240luaC_checkGC(L);
1241tf=luaY_parser(L,p->z,
1242&p->buff,p->name);
1243cl=luaF_newLclosure(L,tf->nups,hvalue(gt(L)));
1244cl->l.p=tf;
1245for(i=0;i<tf->nups;i++)
1246cl->l.upvals[i]=luaF_newupval(L);
1247setclvalue(L,L->top,cl);
1248incr_top(L);
1249}
1250static int luaD_protectedparser(lua_State*L,ZIO*z,const char*name){
1251struct SParser p;
1252int status;
1253p.z=z;p.name=name;
1254luaZ_initbuffer(L,&p.buff);
1255status=luaD_pcall(L,f_parser,&p,savestack(L,L->top),L->errfunc);
1256luaZ_freebuffer(L,&p.buff);
1257return status;
1258}
1259static void luaS_resize(lua_State*L,int newsize){
1260GCObject**newhash;
1261stringtable*tb;
1262int i;
1263if(G(L)->gcstate==2)
1264return;
1265newhash=luaM_newvector(L,newsize,GCObject*);
1266tb=&G(L)->strt;
1267for(i=0;i<newsize;i++)newhash[i]=NULL;
1268for(i=0;i<tb->size;i++){
1269GCObject*p=tb->hash[i];
1270while(p){
1271GCObject*next=p->gch.next;
1272unsigned int h=gco2ts(p)->hash;
1273int h1=lmod(h,newsize);
1274p->gch.next=newhash[h1];
1275newhash[h1]=p;
1276p=next;
1277}
1278}
1279luaM_freearray(L,tb->hash,tb->size,TString*);
1280tb->size=newsize;
1281tb->hash=newhash;
1282}
1283static TString*newlstr(lua_State*L,const char*str,size_t l,
1284unsigned int h){
1285TString*ts;
1286stringtable*tb;
1287if(l+1>(((size_t)(~(size_t)0)-2)-sizeof(TString))/sizeof(char))
1288luaM_toobig(L);
1289ts=cast(TString*,luaM_malloc(L,(l+1)*sizeof(char)+sizeof(TString)));
1290ts->tsv.len=l;
1291ts->tsv.hash=h;
1292ts->tsv.marked=luaC_white(G(L));
1293ts->tsv.tt=4;
1294ts->tsv.reserved=0;
1295memcpy(ts+1,str,l*sizeof(char));
1296((char*)(ts+1))[l]='\0';
1297tb=&G(L)->strt;
1298h=lmod(h,tb->size);
1299ts->tsv.next=tb->hash[h];
1300tb->hash[h]=obj2gco(ts);
1301tb->nuse++;
1302if(tb->nuse>cast(lu_int32,tb->size)&&tb->size<=(INT_MAX-2)/2)
1303luaS_resize(L,tb->size*2);
1304return ts;
1305}
1306static TString*luaS_newlstr(lua_State*L,const char*str,size_t l){
1307GCObject*o;
1308unsigned int h=cast(unsigned int,l);
1309size_t step=(l>>5)+1;
1310size_t l1;
1311for(l1=l;l1>=step;l1-=step)
1312h=h^((h<<5)+(h>>2)+cast(unsigned char,str[l1-1]));
1313for(o=G(L)->strt.hash[lmod(h,G(L)->strt.size)];
1314o!=NULL;
1315o=o->gch.next){
1316TString*ts=rawgco2ts(o);
1317if(ts->tsv.len==l&&(memcmp(str,getstr(ts),l)==0)){
1318if(isdead(G(L),o))changewhite(o);
1319return ts;
1320}
1321}
1322return newlstr(L,str,l,h);
1323}
1324static Udata*luaS_newudata(lua_State*L,size_t s,Table*e){
1325Udata*u;
1326if(s>((size_t)(~(size_t)0)-2)-sizeof(Udata))
1327luaM_toobig(L);
1328u=cast(Udata*,luaM_malloc(L,s+sizeof(Udata)));
1329u->uv.marked=luaC_white(G(L));
1330u->uv.tt=7;
1331u->uv.len=s;
1332u->uv.metatable=NULL;
1333u->uv.env=e;
1334u->uv.next=G(L)->mainthread->next;
1335G(L)->mainthread->next=obj2gco(u);
1336return u;
1337}
1338#define hashpow2(t,n)(gnode(t,lmod((n),sizenode(t))))
1339#define hashstr(t,str)hashpow2(t,(str)->tsv.hash)
1340#define hashboolean(t,p)hashpow2(t,p)
1341#define hashmod(t,n)(gnode(t,((n)%((sizenode(t)-1)|1))))
1342#define hashpointer(t,p)hashmod(t,IntPoint(p))
1343static const Node dummynode_={
1344{{NULL},0},
1345{{{NULL},0,NULL}}
1346};
1347static Node*hashnum(const Table*t,lua_Number n){
1348unsigned int a[cast_int(sizeof(lua_Number)/sizeof(int))];
1349int i;
1350if(luai_numeq(n,0))
1351return gnode(t,0);
1352memcpy(a,&n,sizeof(a));
1353for(i=1;i<cast_int(sizeof(lua_Number)/sizeof(int));i++)a[0]+=a[i];
1354return hashmod(t,a[0]);
1355}
1356static Node*mainposition(const Table*t,const TValue*key){
1357switch(ttype(key)){
1358case 3:
1359return hashnum(t,nvalue(key));
1360case 4:
1361return hashstr(t,rawtsvalue(key));
1362case 1:
1363return hashboolean(t,bvalue(key));
1364case 2:
1365return hashpointer(t,pvalue(key));
1366default:
1367return hashpointer(t,gcvalue(key));
1368}
1369}
1370static int arrayindex(const TValue*key){
1371if(ttisnumber(key)){
1372lua_Number n=nvalue(key);
1373int k;
1374lua_number2int(k,n);
1375if(luai_numeq(cast_num(k),n))
1376return k;
1377}
1378return-1;
1379}
1380static int findindex(lua_State*L,Table*t,StkId key){
1381int i;
1382if(ttisnil(key))return-1;
1383i=arrayindex(key);
1384if(0<i&&i<=t->sizearray)
1385return i-1;
1386else{
1387Node*n=mainposition(t,key);
1388do{
1389if(luaO_rawequalObj(key2tval(n),key)||
1390(ttype(gkey(n))==(8+3)&&iscollectable(key)&&
1391gcvalue(gkey(n))==gcvalue(key))){
1392i=cast_int(n-gnode(t,0));
1393return i+t->sizearray;
1394}
1395else n=gnext(n);
1396}while(n);
1397luaG_runerror(L,"invalid key to "LUA_QL("next"));
1398return 0;
1399}
1400}
1401static int luaH_next(lua_State*L,Table*t,StkId key){
1402int i=findindex(L,t,key);
1403for(i++;i<t->sizearray;i++){
1404if(!ttisnil(&t->array[i])){
1405setnvalue(key,cast_num(i+1));
1406setobj(L,key+1,&t->array[i]);
1407return 1;
1408}
1409}
1410for(i-=t->sizearray;i<(int)sizenode(t);i++){
1411if(!ttisnil(gval(gnode(t,i)))){
1412setobj(L,key,key2tval(gnode(t,i)));
1413setobj(L,key+1,gval(gnode(t,i)));
1414return 1;
1415}
1416}
1417return 0;
1418}
1419static int computesizes(int nums[],int*narray){
1420int i;
1421int twotoi;
1422int a=0;
1423int na=0;
1424int n=0;
1425for(i=0,twotoi=1;twotoi/2<*narray;i++,twotoi*=2){
1426if(nums[i]>0){
1427a+=nums[i];
1428if(a>twotoi/2){
1429n=twotoi;
1430na=a;
1431}
1432}
1433if(a==*narray)break;
1434}
1435*narray=n;
1436return na;
1437}
1438static int countint(const TValue*key,int*nums){
1439int k=arrayindex(key);
1440if(0<k&&k<=(1<<(32-2))){
1441nums[ceillog2(k)]++;
1442return 1;
1443}
1444else
1445return 0;
1446}
1447static int numusearray(const Table*t,int*nums){
1448int lg;
1449int ttlg;
1450int ause=0;
1451int i=1;
1452for(lg=0,ttlg=1;lg<=(32-2);lg++,ttlg*=2){
1453int lc=0;
1454int lim=ttlg;
1455if(lim>t->sizearray){
1456lim=t->sizearray;
1457if(i>lim)
1458break;
1459}
1460for(;i<=lim;i++){
1461if(!ttisnil(&t->array[i-1]))
1462lc++;
1463}
1464nums[lg]+=lc;
1465ause+=lc;
1466}
1467return ause;
1468}
1469static int numusehash(const Table*t,int*nums,int*pnasize){
1470int totaluse=0;
1471int ause=0;
1472int i=sizenode(t);
1473while(i--){
1474Node*n=&t->node[i];
1475if(!ttisnil(gval(n))){
1476ause+=countint(key2tval(n),nums);
1477totaluse++;
1478}
1479}
1480*pnasize+=ause;
1481return totaluse;
1482}
1483static void setarrayvector(lua_State*L,Table*t,int size){
1484int i;
1485luaM_reallocvector(L,t->array,t->sizearray,size,TValue);
1486for(i=t->sizearray;i<size;i++)
1487setnilvalue(&t->array[i]);
1488t->sizearray=size;
1489}
1490static void setnodevector(lua_State*L,Table*t,int size){
1491int lsize;
1492if(size==0){
1493t->node=cast(Node*,(&dummynode_));
1494lsize=0;
1495}
1496else{
1497int i;
1498lsize=ceillog2(size);
1499if(lsize>(32-2))
1500luaG_runerror(L,"table overflow");
1501size=twoto(lsize);
1502t->node=luaM_newvector(L,size,Node);
1503for(i=0;i<size;i++){
1504Node*n=gnode(t,i);
1505gnext(n)=NULL;
1506setnilvalue(gkey(n));
1507setnilvalue(gval(n));
1508}
1509}
1510t->lsizenode=cast_byte(lsize);
1511t->lastfree=gnode(t,size);
1512}
1513static void resize(lua_State*L,Table*t,int nasize,int nhsize){
1514int i;
1515int oldasize=t->sizearray;
1516int oldhsize=t->lsizenode;
1517Node*nold=t->node;
1518if(nasize>oldasize)
1519setarrayvector(L,t,nasize);
1520setnodevector(L,t,nhsize);
1521if(nasize<oldasize){
1522t->sizearray=nasize;
1523for(i=nasize;i<oldasize;i++){
1524if(!ttisnil(&t->array[i]))
1525setobj(L,luaH_setnum(L,t,i+1),&t->array[i]);
1526}
1527luaM_reallocvector(L,t->array,oldasize,nasize,TValue);
1528}
1529for(i=twoto(oldhsize)-1;i>=0;i--){
1530Node*old=nold+i;
1531if(!ttisnil(gval(old)))
1532setobj(L,luaH_set(L,t,key2tval(old)),gval(old));
1533}
1534if(nold!=(&dummynode_))
1535luaM_freearray(L,nold,twoto(oldhsize),Node);
1536}
1537static void luaH_resizearray(lua_State*L,Table*t,int nasize){
1538int nsize=(t->node==(&dummynode_))?0:sizenode(t);
1539resize(L,t,nasize,nsize);
1540}
1541static void rehash(lua_State*L,Table*t,const TValue*ek){
1542int nasize,na;
1543int nums[(32-2)+1];
1544int i;
1545int totaluse;
1546for(i=0;i<=(32-2);i++)nums[i]=0;
1547nasize=numusearray(t,nums);
1548totaluse=nasize;
1549totaluse+=numusehash(t,nums,&nasize);
1550nasize+=countint(ek,nums);
1551totaluse++;
1552na=computesizes(nums,&nasize);
1553resize(L,t,nasize,totaluse-na);
1554}
1555static Table*luaH_new(lua_State*L,int narray,int nhash){
1556Table*t=luaM_new(L,Table);
1557luaC_link(L,obj2gco(t),5);
1558t->metatable=NULL;
1559t->flags=cast_byte(~0);
1560t->array=NULL;
1561t->sizearray=0;
1562t->lsizenode=0;
1563t->node=cast(Node*,(&dummynode_));
1564setarrayvector(L,t,narray);
1565setnodevector(L,t,nhash);
1566return t;
1567}
1568static void luaH_free(lua_State*L,Table*t){
1569if(t->node!=(&dummynode_))
1570luaM_freearray(L,t->node,sizenode(t),Node);
1571luaM_freearray(L,t->array,t->sizearray,TValue);
1572luaM_free(L,t);
1573}
1574static Node*getfreepos(Table*t){
1575while(t->lastfree-->t->node){
1576if(ttisnil(gkey(t->lastfree)))
1577return t->lastfree;
1578}
1579return NULL;
1580}
1581static TValue*newkey(lua_State*L,Table*t,const TValue*key){
1582Node*mp=mainposition(t,key);
1583if(!ttisnil(gval(mp))||mp==(&dummynode_)){
1584Node*othern;
1585Node*n=getfreepos(t);
1586if(n==NULL){
1587rehash(L,t,key);
1588return luaH_set(L,t,key);
1589}
1590othern=mainposition(t,key2tval(mp));
1591if(othern!=mp){
1592while(gnext(othern)!=mp)othern=gnext(othern);
1593gnext(othern)=n;
1594*n=*mp;
1595gnext(mp)=NULL;
1596setnilvalue(gval(mp));
1597}
1598else{
1599gnext(n)=gnext(mp);
1600gnext(mp)=n;
1601mp=n;
1602}
1603}
1604gkey(mp)->value=key->value;gkey(mp)->tt=key->tt;
1605luaC_barriert(L,t,key);
1606return gval(mp);
1607}
1608static const TValue*luaH_getnum(Table*t,int key){
1609if(cast(unsigned int,key)-1<cast(unsigned int,t->sizearray))
1610return&t->array[key-1];
1611else{
1612lua_Number nk=cast_num(key);
1613Node*n=hashnum(t,nk);
1614do{
1615if(ttisnumber(gkey(n))&&luai_numeq(nvalue(gkey(n)),nk))
1616return gval(n);
1617else n=gnext(n);
1618}while(n);
1619return(&luaO_nilobject_);
1620}
1621}
1622static const TValue*luaH_getstr(Table*t,TString*key){
1623Node*n=hashstr(t,key);
1624do{
1625if(ttisstring(gkey(n))&&rawtsvalue(gkey(n))==key)
1626return gval(n);
1627else n=gnext(n);
1628}while(n);
1629return(&luaO_nilobject_);
1630}
1631static const TValue*luaH_get(Table*t,const TValue*key){
1632switch(ttype(key)){
1633case 0:return(&luaO_nilobject_);
1634case 4:return luaH_getstr(t,rawtsvalue(key));
1635case 3:{
1636int k;
1637lua_Number n=nvalue(key);
1638lua_number2int(k,n);
1639if(luai_numeq(cast_num(k),nvalue(key)))
1640return luaH_getnum(t,k);
1641}
1642/*fallthrough*/
1643default:{
1644Node*n=mainposition(t,key);
1645do{
1646if(luaO_rawequalObj(key2tval(n),key))
1647return gval(n);
1648else n=gnext(n);
1649}while(n);
1650return(&luaO_nilobject_);
1651}
1652}
1653}
1654static TValue*luaH_set(lua_State*L,Table*t,const TValue*key){
1655const TValue*p=luaH_get(t,key);
1656t->flags=0;
1657if(p!=(&luaO_nilobject_))
1658return cast(TValue*,p);
1659else{
1660if(ttisnil(key))luaG_runerror(L,"table index is nil");
1661else if(ttisnumber(key)&&luai_numisnan(nvalue(key)))
1662luaG_runerror(L,"table index is NaN");
1663return newkey(L,t,key);
1664}
1665}
1666static TValue*luaH_setnum(lua_State*L,Table*t,int key){
1667const TValue*p=luaH_getnum(t,key);
1668if(p!=(&luaO_nilobject_))
1669return cast(TValue*,p);
1670else{
1671TValue k;
1672setnvalue(&k,cast_num(key));
1673return newkey(L,t,&k);
1674}
1675}
1676static TValue*luaH_setstr(lua_State*L,Table*t,TString*key){
1677const TValue*p=luaH_getstr(t,key);
1678if(p!=(&luaO_nilobject_))
1679return cast(TValue*,p);
1680else{
1681TValue k;
1682setsvalue(L,&k,key);
1683return newkey(L,t,&k);
1684}
1685}
1686static int unbound_search(Table*t,unsigned int j){
1687unsigned int i=j;
1688j++;
1689while(!ttisnil(luaH_getnum(t,j))){
1690i=j;
1691j*=2;
1692if(j>cast(unsigned int,(INT_MAX-2))){
1693i=1;
1694while(!ttisnil(luaH_getnum(t,i)))i++;
1695return i-1;
1696}
1697}
1698while(j-i>1){
1699unsigned int m=(i+j)/2;
1700if(ttisnil(luaH_getnum(t,m)))j=m;
1701else i=m;
1702}
1703return i;
1704}
1705static int luaH_getn(Table*t){
1706unsigned int j=t->sizearray;
1707if(j>0&&ttisnil(&t->array[j-1])){
1708unsigned int i=0;
1709while(j-i>1){
1710unsigned int m=(i+j)/2;
1711if(ttisnil(&t->array[m-1]))j=m;
1712else i=m;
1713}
1714return i;
1715}
1716else if(t->node==(&dummynode_))
1717return j;
1718else return unbound_search(t,j);
1719}
1720#define makewhite(g,x)((x)->gch.marked=cast_byte(((x)->gch.marked&cast_byte(~(bitmask(2)|bit2mask(0,1))))|luaC_white(g)))
1721#define white2gray(x)reset2bits((x)->gch.marked,0,1)
1722#define black2gray(x)resetbit((x)->gch.marked,2)
1723#define stringmark(s)reset2bits((s)->tsv.marked,0,1)
1724#define isfinalized(u)testbit((u)->marked,3)
1725#define markfinalized(u)l_setbit((u)->marked,3)
1726#define markvalue(g,o){checkconsistency(o);if(iscollectable(o)&&iswhite(gcvalue(o)))reallymarkobject(g,gcvalue(o));}
1727#define markobject(g,t){if(iswhite(obj2gco(t)))reallymarkobject(g,obj2gco(t));}
1728#define setthreshold(g)(g->GCthreshold=(g->estimate/100)*g->gcpause)
1729static void removeentry(Node*n){
1730if(iscollectable(gkey(n)))
1731setttype(gkey(n),(8+3));
1732}
1733static void reallymarkobject(global_State*g,GCObject*o){
1734white2gray(o);
1735switch(o->gch.tt){
1736case 4:{
1737return;
1738}
1739case 7:{
1740Table*mt=gco2u(o)->metatable;
1741gray2black(o);
1742if(mt)markobject(g,mt);
1743markobject(g,gco2u(o)->env);
1744return;
1745}
1746case(8+2):{
1747UpVal*uv=gco2uv(o);
1748markvalue(g,uv->v);
1749if(uv->v==&uv->u.value)
1750gray2black(o);
1751return;
1752}
1753case 6:{
1754gco2cl(o)->c.gclist=g->gray;
1755g->gray=o;
1756break;
1757}
1758case 5:{
1759gco2h(o)->gclist=g->gray;
1760g->gray=o;
1761break;
1762}
1763case 8:{
1764gco2th(o)->gclist=g->gray;
1765g->gray=o;
1766break;
1767}
1768case(8+1):{
1769gco2p(o)->gclist=g->gray;
1770g->gray=o;
1771break;
1772}
1773default:;
1774}
1775}
1776static void marktmu(global_State*g){
1777GCObject*u=g->tmudata;
1778if(u){
1779do{
1780u=u->gch.next;
1781makewhite(g,u);
1782reallymarkobject(g,u);
1783}while(u!=g->tmudata);
1784}
1785}
1786static size_t luaC_separateudata(lua_State*L,int all){
1787global_State*g=G(L);
1788size_t deadmem=0;
1789GCObject**p=&g->mainthread->next;
1790GCObject*curr;
1791while((curr=*p)!=NULL){
1792if(!(iswhite(curr)||all)||isfinalized(gco2u(curr)))
1793p=&curr->gch.next;
1794else if(fasttm(L,gco2u(curr)->metatable,TM_GC)==NULL){
1795markfinalized(gco2u(curr));
1796p=&curr->gch.next;
1797}
1798else{
1799deadmem+=sizeudata(gco2u(curr));
1800markfinalized(gco2u(curr));
1801*p=curr->gch.next;
1802if(g->tmudata==NULL)
1803g->tmudata=curr->gch.next=curr;
1804else{
1805curr->gch.next=g->tmudata->gch.next;
1806g->tmudata->gch.next=curr;
1807g->tmudata=curr;
1808}
1809}
1810}
1811return deadmem;
1812}
1813static int traversetable(global_State*g,Table*h){
1814int i;
1815int weakkey=0;
1816int weakvalue=0;
1817const TValue*mode;
1818if(h->metatable)
1819markobject(g,h->metatable);
1820mode=gfasttm(g,h->metatable,TM_MODE);
1821if(mode&&ttisstring(mode)){
1822weakkey=(strchr(svalue(mode),'k')!=NULL);
1823weakvalue=(strchr(svalue(mode),'v')!=NULL);
1824if(weakkey||weakvalue){
1825h->marked&=~(bitmask(3)|bitmask(4));
1826h->marked|=cast_byte((weakkey<<3)|
1827(weakvalue<<4));
1828h->gclist=g->weak;
1829g->weak=obj2gco(h);
1830}
1831}
1832if(weakkey&&weakvalue)return 1;
1833if(!weakvalue){
1834i=h->sizearray;
1835while(i--)
1836markvalue(g,&h->array[i]);
1837}
1838i=sizenode(h);
1839while(i--){
1840Node*n=gnode(h,i);
1841if(ttisnil(gval(n)))
1842removeentry(n);
1843else{
1844if(!weakkey)markvalue(g,gkey(n));
1845if(!weakvalue)markvalue(g,gval(n));
1846}
1847}
1848return weakkey||weakvalue;
1849}
1850static void traverseproto(global_State*g,Proto*f){
1851int i;
1852if(f->source)stringmark(f->source);
1853for(i=0;i<f->sizek;i++)
1854markvalue(g,&f->k[i]);
1855for(i=0;i<f->sizeupvalues;i++){
1856if(f->upvalues[i])
1857stringmark(f->upvalues[i]);
1858}
1859for(i=0;i<f->sizep;i++){
1860if(f->p[i])
1861markobject(g,f->p[i]);
1862}
1863for(i=0;i<f->sizelocvars;i++){
1864if(f->locvars[i].varname)
1865stringmark(f->locvars[i].varname);
1866}
1867}
1868static void traverseclosure(global_State*g,Closure*cl){
1869markobject(g,cl->c.env);
1870if(cl->c.isC){
1871int i;
1872for(i=0;i<cl->c.nupvalues;i++)
1873markvalue(g,&cl->c.upvalue[i]);
1874}
1875else{
1876int i;
1877markobject(g,cl->l.p);
1878for(i=0;i<cl->l.nupvalues;i++)
1879markobject(g,cl->l.upvals[i]);
1880}
1881}
1882static void checkstacksizes(lua_State*L,StkId max){
1883int ci_used=cast_int(L->ci-L->base_ci);
1884int s_used=cast_int(max-L->stack);
1885if(L->size_ci>20000)
1886return;
1887if(4*ci_used<L->size_ci&&2*8<L->size_ci)
1888luaD_reallocCI(L,L->size_ci/2);
1889condhardstacktests(luaD_reallocCI(L,ci_used+1));
1890if(4*s_used<L->stacksize&&
18912*((2*20)+5)<L->stacksize)
1892luaD_reallocstack(L,L->stacksize/2);
1893condhardstacktests(luaD_reallocstack(L,s_used));
1894}
1895static void traversestack(global_State*g,lua_State*l){
1896StkId o,lim;
1897CallInfo*ci;
1898markvalue(g,gt(l));
1899lim=l->top;
1900for(ci=l->base_ci;ci<=l->ci;ci++){
1901if(lim<ci->top)lim=ci->top;
1902}
1903for(o=l->stack;o<l->top;o++)
1904markvalue(g,o);
1905for(;o<=lim;o++)
1906setnilvalue(o);
1907checkstacksizes(l,lim);
1908}
1909static l_mem propagatemark(global_State*g){
1910GCObject*o=g->gray;
1911gray2black(o);
1912switch(o->gch.tt){
1913case 5:{
1914Table*h=gco2h(o);
1915g->gray=h->gclist;
1916if(traversetable(g,h))
1917black2gray(o);
1918return sizeof(Table)+sizeof(TValue)*h->sizearray+
1919sizeof(Node)*sizenode(h);
1920}
1921case 6:{
1922Closure*cl=gco2cl(o);
1923g->gray=cl->c.gclist;
1924traverseclosure(g,cl);
1925return(cl->c.isC)?sizeCclosure(cl->c.nupvalues):
1926sizeLclosure(cl->l.nupvalues);
1927}
1928case 8:{
1929lua_State*th=gco2th(o);
1930g->gray=th->gclist;
1931th->gclist=g->grayagain;
1932g->grayagain=o;
1933black2gray(o);
1934traversestack(g,th);
1935return sizeof(lua_State)+sizeof(TValue)*th->stacksize+
1936sizeof(CallInfo)*th->size_ci;
1937}
1938case(8+1):{
1939Proto*p=gco2p(o);
1940g->gray=p->gclist;
1941traverseproto(g,p);
1942return sizeof(Proto)+sizeof(Instruction)*p->sizecode+
1943sizeof(Proto*)*p->sizep+
1944sizeof(TValue)*p->sizek+
1945sizeof(int)*p->sizelineinfo+
1946sizeof(LocVar)*p->sizelocvars+
1947sizeof(TString*)*p->sizeupvalues;
1948}
1949default:return 0;
1950}
1951}
1952static size_t propagateall(global_State*g){
1953size_t m=0;
1954while(g->gray)m+=propagatemark(g);
1955return m;
1956}
1957static int iscleared(const TValue*o,int iskey){
1958if(!iscollectable(o))return 0;
1959if(ttisstring(o)){
1960stringmark(rawtsvalue(o));
1961return 0;
1962}
1963return iswhite(gcvalue(o))||
1964(ttisuserdata(o)&&(!iskey&&isfinalized(uvalue(o))));
1965}
1966static void cleartable(GCObject*l){
1967while(l){
1968Table*h=gco2h(l);
1969int i=h->sizearray;
1970if(testbit(h->marked,4)){
1971while(i--){
1972TValue*o=&h->array[i];
1973if(iscleared(o,0))
1974setnilvalue(o);
1975}
1976}
1977i=sizenode(h);
1978while(i--){
1979Node*n=gnode(h,i);
1980if(!ttisnil(gval(n))&&
1981(iscleared(key2tval(n),1)||iscleared(gval(n),0))){
1982setnilvalue(gval(n));
1983removeentry(n);
1984}
1985}
1986l=h->gclist;
1987}
1988}
1989static void freeobj(lua_State*L,GCObject*o){
1990switch(o->gch.tt){
1991case(8+1):luaF_freeproto(L,gco2p(o));break;
1992case 6:luaF_freeclosure(L,gco2cl(o));break;
1993case(8+2):luaF_freeupval(L,gco2uv(o));break;
1994case 5:luaH_free(L,gco2h(o));break;
1995case 8:{
1996luaE_freethread(L,gco2th(o));
1997break;
1998}
1999case 4:{
2000G(L)->strt.nuse--;
2001luaM_freemem(L,o,sizestring(gco2ts(o)));
2002break;
2003}
2004case 7:{
2005luaM_freemem(L,o,sizeudata(gco2u(o)));
2006break;
2007}
2008default:;
2009}
2010}
2011#define sweepwholelist(L,p)sweeplist(L,p,((lu_mem)(~(lu_mem)0)-2))
2012static GCObject**sweeplist(lua_State*L,GCObject**p,lu_mem count){
2013GCObject*curr;
2014global_State*g=G(L);
2015int deadmask=otherwhite(g);
2016while((curr=*p)!=NULL&&count-->0){
2017if(curr->gch.tt==8)
2018sweepwholelist(L,&gco2th(curr)->openupval);
2019if((curr->gch.marked^bit2mask(0,1))&deadmask){
2020makewhite(g,curr);
2021p=&curr->gch.next;
2022}
2023else{
2024*p=curr->gch.next;
2025if(curr==g->rootgc)
2026g->rootgc=curr->gch.next;
2027freeobj(L,curr);
2028}
2029}
2030return p;
2031}
2032static void checkSizes(lua_State*L){
2033global_State*g=G(L);
2034if(g->strt.nuse<cast(lu_int32,g->strt.size/4)&&
2035g->strt.size>32*2)
2036luaS_resize(L,g->strt.size/2);
2037if(luaZ_sizebuffer(&g->buff)>32*2){
2038size_t newsize=luaZ_sizebuffer(&g->buff)/2;
2039luaZ_resizebuffer(L,&g->buff,newsize);
2040}
2041}
2042static void GCTM(lua_State*L){
2043global_State*g=G(L);
2044GCObject*o=g->tmudata->gch.next;
2045Udata*udata=rawgco2u(o);
2046const TValue*tm;
2047if(o==g->tmudata)
2048g->tmudata=NULL;
2049else
2050g->tmudata->gch.next=udata->uv.next;
2051udata->uv.next=g->mainthread->next;
2052g->mainthread->next=o;
2053makewhite(g,o);
2054tm=fasttm(L,udata->uv.metatable,TM_GC);
2055if(tm!=NULL){
2056lu_byte oldah=L->allowhook;
2057lu_mem oldt=g->GCthreshold;
2058L->allowhook=0;
2059g->GCthreshold=2*g->totalbytes;
2060setobj(L,L->top,tm);
2061setuvalue(L,L->top+1,udata);
2062L->top+=2;
2063luaD_call(L,L->top-2,0);
2064L->allowhook=oldah;
2065g->GCthreshold=oldt;
2066}
2067}
2068static void luaC_callGCTM(lua_State*L){
2069while(G(L)->tmudata)
2070GCTM(L);
2071}
2072static void luaC_freeall(lua_State*L){
2073global_State*g=G(L);
2074int i;
2075g->currentwhite=bit2mask(0,1)|bitmask(6);
2076sweepwholelist(L,&g->rootgc);
2077for(i=0;i<g->strt.size;i++)
2078sweepwholelist(L,&g->strt.hash[i]);
2079}
2080static void markmt(global_State*g){
2081int i;
2082for(i=0;i<(8+1);i++)
2083if(g->mt[i])markobject(g,g->mt[i]);
2084}
2085static void markroot(lua_State*L){
2086global_State*g=G(L);
2087g->gray=NULL;
2088g->grayagain=NULL;
2089g->weak=NULL;
2090markobject(g,g->mainthread);
2091markvalue(g,gt(g->mainthread));
2092markvalue(g,registry(L));
2093markmt(g);
2094g->gcstate=1;
2095}
2096static void remarkupvals(global_State*g){
2097UpVal*uv;
2098for(uv=g->uvhead.u.l.next;uv!=&g->uvhead;uv=uv->u.l.next){
2099if(isgray(obj2gco(uv)))
2100markvalue(g,uv->v);
2101}
2102}
2103static void atomic(lua_State*L){
2104global_State*g=G(L);
2105size_t udsize;
2106remarkupvals(g);
2107propagateall(g);
2108g->gray=g->weak;
2109g->weak=NULL;
2110markobject(g,L);
2111markmt(g);
2112propagateall(g);
2113g->gray=g->grayagain;
2114g->grayagain=NULL;
2115propagateall(g);
2116udsize=luaC_separateudata(L,0);
2117marktmu(g);
2118udsize+=propagateall(g);
2119cleartable(g->weak);
2120g->currentwhite=cast_byte(otherwhite(g));
2121g->sweepstrgc=0;
2122g->sweepgc=&g->rootgc;
2123g->gcstate=2;
2124g->estimate=g->totalbytes-udsize;
2125}
2126static l_mem singlestep(lua_State*L){
2127global_State*g=G(L);
2128switch(g->gcstate){
2129case 0:{
2130markroot(L);
2131return 0;
2132}
2133case 1:{
2134if(g->gray)
2135return propagatemark(g);
2136else{
2137atomic(L);
2138return 0;
2139}
2140}
2141case 2:{
2142lu_mem old=g->totalbytes;
2143sweepwholelist(L,&g->strt.hash[g->sweepstrgc++]);
2144if(g->sweepstrgc>=g->strt.size)
2145g->gcstate=3;
2146g->estimate-=old-g->totalbytes;
2147return 10;
2148}
2149case 3:{
2150lu_mem old=g->totalbytes;
2151g->sweepgc=sweeplist(L,g->sweepgc,40);
2152if(*g->sweepgc==NULL){
2153checkSizes(L);
2154g->gcstate=4;
2155}
2156g->estimate-=old-g->totalbytes;
2157return 40*10;
2158}
2159case 4:{
2160if(g->tmudata){
2161GCTM(L);
2162if(g->estimate>100)
2163g->estimate-=100;
2164return 100;
2165}
2166else{
2167g->gcstate=0;
2168g->gcdept=0;
2169return 0;
2170}
2171}
2172default:return 0;
2173}
2174}
2175static void luaC_step(lua_State*L){
2176global_State*g=G(L);
2177l_mem lim=(1024u/100)*g->gcstepmul;
2178if(lim==0)
2179lim=(((lu_mem)(~(lu_mem)0)-2)-1)/2;
2180g->gcdept+=g->totalbytes-g->GCthreshold;
2181do{
2182lim-=singlestep(L);
2183if(g->gcstate==0)
2184break;
2185}while(lim>0);
2186if(g->gcstate!=0){
2187if(g->gcdept<1024u)
2188g->GCthreshold=g->totalbytes+1024u;
2189else{
2190g->gcdept-=1024u;
2191g->GCthreshold=g->totalbytes;
2192}
2193}
2194else{
2195setthreshold(g);
2196}
2197}
2198static void luaC_barrierf(lua_State*L,GCObject*o,GCObject*v){
2199global_State*g=G(L);
2200if(g->gcstate==1)
2201reallymarkobject(g,v);
2202else
2203makewhite(g,o);
2204}
2205static void luaC_barrierback(lua_State*L,Table*t){
2206global_State*g=G(L);
2207GCObject*o=obj2gco(t);
2208black2gray(o);
2209t->gclist=g->grayagain;
2210g->grayagain=o;
2211}
2212static void luaC_link(lua_State*L,GCObject*o,lu_byte tt){
2213global_State*g=G(L);
2214o->gch.next=g->rootgc;
2215g->rootgc=o;
2216o->gch.marked=luaC_white(g);
2217o->gch.tt=tt;
2218}
2219static void luaC_linkupval(lua_State*L,UpVal*uv){
2220global_State*g=G(L);
2221GCObject*o=obj2gco(uv);
2222o->gch.next=g->rootgc;
2223g->rootgc=o;
2224if(isgray(o)){
2225if(g->gcstate==1){
2226gray2black(o);
2227luaC_barrier(L,uv,uv->v);
2228}
2229else{
2230makewhite(g,o);
2231}
2232}
2233}
2234typedef union{
2235lua_Number r;
2236TString*ts;
2237}SemInfo;
2238typedef struct Token{
2239int token;
2240SemInfo seminfo;
2241}Token;
2242typedef struct LexState{
2243int current;
2244int linenumber;
2245int lastline;
2246Token t;
2247Token lookahead;
2248struct FuncState*fs;
2249struct lua_State*L;
2250ZIO*z;
2251Mbuffer*buff;
2252TString*source;
2253char decpoint;
2254}LexState;
2255static void luaX_init(lua_State*L);
2256static void luaX_lexerror(LexState*ls,const char*msg,int token);
2257#define state_size(x)(sizeof(x)+0)
2258#define fromstate(l)(cast(lu_byte*,(l))-0)
2259#define tostate(l)(cast(lua_State*,cast(lu_byte*,l)+0))
2260typedef struct LG{
2261lua_State l;
2262global_State g;
2263}LG;
2264static void stack_init(lua_State*L1,lua_State*L){
2265L1->base_ci=luaM_newvector(L,8,CallInfo);
2266L1->ci=L1->base_ci;
2267L1->size_ci=8;
2268L1->end_ci=L1->base_ci+L1->size_ci-1;
2269L1->stack=luaM_newvector(L,(2*20)+5,TValue);
2270L1->stacksize=(2*20)+5;
2271L1->top=L1->stack;
2272L1->stack_last=L1->stack+(L1->stacksize-5)-1;
2273L1->ci->func=L1->top;
2274setnilvalue(L1->top++);
2275L1->base=L1->ci->base=L1->top;
2276L1->ci->top=L1->top+20;
2277}
2278static void freestack(lua_State*L,lua_State*L1){
2279luaM_freearray(L,L1->base_ci,L1->size_ci,CallInfo);
2280luaM_freearray(L,L1->stack,L1->stacksize,TValue);
2281}
2282static void f_luaopen(lua_State*L,void*ud){
2283global_State*g=G(L);
2284UNUSED(ud);
2285stack_init(L,L);
2286sethvalue(L,gt(L),luaH_new(L,0,2));
2287sethvalue(L,registry(L),luaH_new(L,0,2));
2288luaS_resize(L,32);
2289luaT_init(L);
2290luaX_init(L);
2291luaS_fix(luaS_newliteral(L,"not enough memory"));
2292g->GCthreshold=4*g->totalbytes;
2293}
2294static void preinit_state(lua_State*L,global_State*g){
2295G(L)=g;
2296L->stack=NULL;
2297L->stacksize=0;
2298L->errorJmp=NULL;
2299L->hook=NULL;
2300L->hookmask=0;
2301L->basehookcount=0;
2302L->allowhook=1;
2303resethookcount(L);
2304L->openupval=NULL;
2305L->size_ci=0;
2306L->nCcalls=L->baseCcalls=0;
2307L->status=0;
2308L->base_ci=L->ci=NULL;
2309L->savedpc=NULL;
2310L->errfunc=0;
2311setnilvalue(gt(L));
2312}
2313static void close_state(lua_State*L){
2314global_State*g=G(L);
2315luaF_close(L,L->stack);
2316luaC_freeall(L);
2317luaM_freearray(L,G(L)->strt.hash,G(L)->strt.size,TString*);
2318luaZ_freebuffer(L,&g->buff);
2319freestack(L,L);
2320(*g->frealloc)(g->ud,fromstate(L),state_size(LG),0);
2321}
2322static void luaE_freethread(lua_State*L,lua_State*L1){
2323luaF_close(L1,L1->stack);
2324freestack(L,L1);
2325luaM_freemem(L,fromstate(L1),state_size(lua_State));
2326}
2327static lua_State*lua_newstate(lua_Alloc f,void*ud){
2328int i;
2329lua_State*L;
2330global_State*g;
2331void*l=(*f)(ud,NULL,0,state_size(LG));
2332if(l==NULL)return NULL;
2333L=tostate(l);
2334g=&((LG*)L)->g;
2335L->next=NULL;
2336L->tt=8;
2337g->currentwhite=bit2mask(0,5);
2338L->marked=luaC_white(g);
2339set2bits(L->marked,5,6);
2340preinit_state(L,g);
2341g->frealloc=f;
2342g->ud=ud;
2343g->mainthread=L;
2344g->uvhead.u.l.prev=&g->uvhead;
2345g->uvhead.u.l.next=&g->uvhead;
2346g->GCthreshold=0;
2347g->strt.size=0;
2348g->strt.nuse=0;
2349g->strt.hash=NULL;
2350setnilvalue(registry(L));
2351luaZ_initbuffer(L,&g->buff);
2352g->panic=NULL;
2353g->gcstate=0;
2354g->rootgc=obj2gco(L);
2355g->sweepstrgc=0;
2356g->sweepgc=&g->rootgc;
2357g->gray=NULL;
2358g->grayagain=NULL;
2359g->weak=NULL;
2360g->tmudata=NULL;
2361g->totalbytes=sizeof(LG);
2362g->gcpause=200;
2363g->gcstepmul=200;
2364g->gcdept=0;
2365for(i=0;i<(8+1);i++)g->mt[i]=NULL;
2366if(luaD_rawrunprotected(L,f_luaopen,NULL)!=0){
2367close_state(L);
2368L=NULL;
2369}
2370else
2371{}
2372return L;
2373}
2374static void callallgcTM(lua_State*L,void*ud){
2375UNUSED(ud);
2376luaC_callGCTM(L);
2377}
2378static void lua_close(lua_State*L){
2379L=G(L)->mainthread;
2380luaF_close(L,L->stack);
2381luaC_separateudata(L,1);
2382L->errfunc=0;
2383do{
2384L->ci=L->base_ci;
2385L->base=L->top=L->ci->base;
2386L->nCcalls=L->baseCcalls=0;
2387}while(luaD_rawrunprotected(L,callallgcTM,NULL)!=0);
2388close_state(L);
2389}
2390#define getcode(fs,e)((fs)->f->code[(e)->u.s.info])
2391#define luaK_codeAsBx(fs,o,A,sBx)luaK_codeABx(fs,o,A,(sBx)+(((1<<(9+9))-1)>>1))
2392#define luaK_setmultret(fs,e)luaK_setreturns(fs,e,(-1))
2393static int luaK_codeABx(FuncState*fs,OpCode o,int A,unsigned int Bx);
2394static int luaK_codeABC(FuncState*fs,OpCode o,int A,int B,int C);
2395static void luaK_setreturns(FuncState*fs,expdesc*e,int nresults);
2396static void luaK_patchtohere(FuncState*fs,int list);
2397static void luaK_concat(FuncState*fs,int*l1,int l2);
2398static int currentpc(lua_State*L,CallInfo*ci){
2399if(!isLua(ci))return-1;
2400if(ci==L->ci)
2401ci->savedpc=L->savedpc;
2402return pcRel(ci->savedpc,ci_func(ci)->l.p);
2403}
2404static int currentline(lua_State*L,CallInfo*ci){
2405int pc=currentpc(L,ci);
2406if(pc<0)
2407return-1;
2408else
2409return getline_(ci_func(ci)->l.p,pc);
2410}
2411static int lua_getstack(lua_State*L,int level,lua_Debug*ar){
2412int status;
2413CallInfo*ci;
2414for(ci=L->ci;level>0&&ci>L->base_ci;ci--){
2415level--;
2416if(f_isLua(ci))
2417level-=ci->tailcalls;
2418}
2419if(level==0&&ci>L->base_ci){
2420status=1;
2421ar->i_ci=cast_int(ci-L->base_ci);
2422}
2423else if(level<0){
2424status=1;
2425ar->i_ci=0;
2426}
2427else status=0;
2428return status;
2429}
2430static Proto*getluaproto(CallInfo*ci){
2431return(isLua(ci)?ci_func(ci)->l.p:NULL);
2432}
2433static void funcinfo(lua_Debug*ar,Closure*cl){
2434if(cl->c.isC){
2435ar->source="=[C]";
2436ar->linedefined=-1;
2437ar->lastlinedefined=-1;
2438ar->what="C";
2439}
2440else{
2441ar->source=getstr(cl->l.p->source);
2442ar->linedefined=cl->l.p->linedefined;
2443ar->lastlinedefined=cl->l.p->lastlinedefined;
2444ar->what=(ar->linedefined==0)?"main":"Lua";
2445}
2446luaO_chunkid(ar->short_src,ar->source,60);
2447}
2448static void info_tailcall(lua_Debug*ar){
2449ar->name=ar->namewhat="";
2450ar->what="tail";
2451ar->lastlinedefined=ar->linedefined=ar->currentline=-1;
2452ar->source="=(tail call)";
2453luaO_chunkid(ar->short_src,ar->source,60);
2454ar->nups=0;
2455}
2456static void collectvalidlines(lua_State*L,Closure*f){
2457if(f==NULL||f->c.isC){
2458setnilvalue(L->top);
2459}
2460else{
2461Table*t=luaH_new(L,0,0);
2462int*lineinfo=f->l.p->lineinfo;
2463int i;
2464for(i=0;i<f->l.p->sizelineinfo;i++)
2465setbvalue(luaH_setnum(L,t,lineinfo[i]),1);
2466sethvalue(L,L->top,t);
2467}
2468incr_top(L);
2469}
2470static int auxgetinfo(lua_State*L,const char*what,lua_Debug*ar,
2471Closure*f,CallInfo*ci){
2472int status=1;
2473if(f==NULL){
2474info_tailcall(ar);
2475return status;
2476}
2477for(;*what;what++){
2478switch(*what){
2479case'S':{
2480funcinfo(ar,f);
2481break;
2482}
2483case'l':{
2484ar->currentline=(ci)?currentline(L,ci):-1;
2485break;
2486}
2487case'u':{
2488ar->nups=f->c.nupvalues;
2489break;
2490}
2491case'n':{
2492ar->namewhat=(ci)?NULL:NULL;
2493if(ar->namewhat==NULL){
2494ar->namewhat="";
2495ar->name=NULL;
2496}
2497break;
2498}
2499case'L':
2500case'f':
2501break;
2502default:status=0;
2503}
2504}
2505return status;
2506}
2507static int lua_getinfo(lua_State*L,const char*what,lua_Debug*ar){
2508int status;
2509Closure*f=NULL;
2510CallInfo*ci=NULL;
2511if(*what=='>'){
2512StkId func=L->top-1;
2513luai_apicheck(L,ttisfunction(func));
2514what++;
2515f=clvalue(func);
2516L->top--;
2517}
2518else if(ar->i_ci!=0){
2519ci=L->base_ci+ar->i_ci;
2520f=clvalue(ci->func);
2521}
2522status=auxgetinfo(L,what,ar,f,ci);
2523if(strchr(what,'f')){
2524if(f==NULL)setnilvalue(L->top);
2525else setclvalue(L,L->top,f);
2526incr_top(L);
2527}
2528if(strchr(what,'L'))
2529collectvalidlines(L,f);
2530return status;
2531}
2532static int isinstack(CallInfo*ci,const TValue*o){
2533StkId p;
2534for(p=ci->base;p<ci->top;p++)
2535if(o==p)return 1;
2536return 0;
2537}
2538static void luaG_typeerror(lua_State*L,const TValue*o,const char*op){
2539const char*name=NULL;
2540const char*t=luaT_typenames[ttype(o)];
2541const char*kind=(isinstack(L->ci,o))?
2542NULL:
2543NULL;
2544if(kind)
2545luaG_runerror(L,"attempt to %s %s "LUA_QL("%s")" (a %s value)",
2546op,kind,name,t);
2547else
2548luaG_runerror(L,"attempt to %s a %s value",op,t);
2549}
2550static void luaG_concaterror(lua_State*L,StkId p1,StkId p2){
2551if(ttisstring(p1)||ttisnumber(p1))p1=p2;
2552luaG_typeerror(L,p1,"concatenate");
2553}
2554static void luaG_aritherror(lua_State*L,const TValue*p1,const TValue*p2){
2555TValue temp;
2556if(luaV_tonumber(p1,&temp)==NULL)
2557p2=p1;
2558luaG_typeerror(L,p2,"perform arithmetic on");
2559}
2560static int luaG_ordererror(lua_State*L,const TValue*p1,const TValue*p2){
2561const char*t1=luaT_typenames[ttype(p1)];
2562const char*t2=luaT_typenames[ttype(p2)];
2563if(t1[2]==t2[2])
2564luaG_runerror(L,"attempt to compare two %s values",t1);
2565else
2566luaG_runerror(L,"attempt to compare %s with %s",t1,t2);
2567return 0;
2568}
2569static void addinfo(lua_State*L,const char*msg){
2570CallInfo*ci=L->ci;
2571if(isLua(ci)){
2572char buff[60];
2573int line=currentline(L,ci);
2574luaO_chunkid(buff,getstr(getluaproto(ci)->source),60);
2575luaO_pushfstring(L,"%s:%d: %s",buff,line,msg);
2576}
2577}
2578static void luaG_errormsg(lua_State*L){
2579if(L->errfunc!=0){
2580StkId errfunc=restorestack(L,L->errfunc);
2581if(!ttisfunction(errfunc))luaD_throw(L,5);
2582setobj(L,L->top,L->top-1);
2583setobj(L,L->top-1,errfunc);
2584incr_top(L);
2585luaD_call(L,L->top-2,1);
2586}
2587luaD_throw(L,2);
2588}
2589static void luaG_runerror(lua_State*L,const char*fmt,...){
2590va_list argp;
2591va_start(argp,fmt);
2592addinfo(L,luaO_pushvfstring(L,fmt,argp));
2593va_end(argp);
2594luaG_errormsg(L);
2595}
2596static int luaZ_fill(ZIO*z){
2597size_t size;
2598lua_State*L=z->L;
2599const char*buff;
2600buff=z->reader(L,z->data,&size);
2601if(buff==NULL||size==0)return(-1);
2602z->n=size-1;
2603z->p=buff;
2604return char2int(*(z->p++));
2605}
2606static void luaZ_init(lua_State*L,ZIO*z,lua_Reader reader,void*data){
2607z->L=L;
2608z->reader=reader;
2609z->data=data;
2610z->n=0;
2611z->p=NULL;
2612}
2613static char*luaZ_openspace(lua_State*L,Mbuffer*buff,size_t n){
2614if(n>buff->buffsize){
2615if(n<32)n=32;
2616luaZ_resizebuffer(L,buff,n);
2617}
2618return buff->buffer;
2619}
2620#define opmode(t,a,b,c,m)(((t)<<7)|((a)<<6)|((b)<<4)|((c)<<2)|(m))
2621static const lu_byte luaP_opmodes[(cast(int,OP_VARARG)+1)]={
2622opmode(0,1,OpArgR,OpArgN,iABC)
2623,opmode(0,1,OpArgK,OpArgN,iABx)
2624,opmode(0,1,OpArgU,OpArgU,iABC)
2625,opmode(0,1,OpArgR,OpArgN,iABC)
2626,opmode(0,1,OpArgU,OpArgN,iABC)
2627,opmode(0,1,OpArgK,OpArgN,iABx)
2628,opmode(0,1,OpArgR,OpArgK,iABC)
2629,opmode(0,0,OpArgK,OpArgN,iABx)
2630,opmode(0,0,OpArgU,OpArgN,iABC)
2631,opmode(0,0,OpArgK,OpArgK,iABC)
2632,opmode(0,1,OpArgU,OpArgU,iABC)
2633,opmode(0,1,OpArgR,OpArgK,iABC)
2634,opmode(0,1,OpArgK,OpArgK,iABC)
2635,opmode(0,1,OpArgK,OpArgK,iABC)
2636,opmode(0,1,OpArgK,OpArgK,iABC)
2637,opmode(0,1,OpArgK,OpArgK,iABC)
2638,opmode(0,1,OpArgK,OpArgK,iABC)
2639,opmode(0,1,OpArgK,OpArgK,iABC)
2640,opmode(0,1,OpArgR,OpArgN,iABC)
2641,opmode(0,1,OpArgR,OpArgN,iABC)
2642,opmode(0,1,OpArgR,OpArgN,iABC)
2643,opmode(0,1,OpArgR,OpArgR,iABC)
2644,opmode(0,0,OpArgR,OpArgN,iAsBx)
2645,opmode(1,0,OpArgK,OpArgK,iABC)
2646,opmode(1,0,OpArgK,OpArgK,iABC)
2647,opmode(1,0,OpArgK,OpArgK,iABC)
2648,opmode(1,1,OpArgR,OpArgU,iABC)
2649,opmode(1,1,OpArgR,OpArgU,iABC)
2650,opmode(0,1,OpArgU,OpArgU,iABC)
2651,opmode(0,1,OpArgU,OpArgU,iABC)
2652,opmode(0,0,OpArgU,OpArgN,iABC)
2653,opmode(0,1,OpArgR,OpArgN,iAsBx)
2654,opmode(0,1,OpArgR,OpArgN,iAsBx)
2655,opmode(1,0,OpArgN,OpArgU,iABC)
2656,opmode(0,0,OpArgU,OpArgU,iABC)
2657,opmode(0,0,OpArgN,OpArgN,iABC)
2658,opmode(0,1,OpArgU,OpArgN,iABx)
2659,opmode(0,1,OpArgU,OpArgN,iABC)
2660};
2661#define next(ls)(ls->current=zgetc(ls->z))
2662#define currIsNewline(ls)(ls->current=='\n'||ls->current=='\r')
2663static const char*const luaX_tokens[]={
2664"and","break","do","else","elseif",
2665"end","false","for","function","if",
2666"in","local","nil","not","or","repeat",
2667"return","then","true","until","while",
2668"..","...","==",">=","<=","~=",
2669"<number>","<name>","<string>","<eof>",
2670NULL
2671};
2672#define save_and_next(ls)(save(ls,ls->current),next(ls))
2673static void save(LexState*ls,int c){
2674Mbuffer*b=ls->buff;
2675if(b->n+1>b->buffsize){
2676size_t newsize;
2677if(b->buffsize>=((size_t)(~(size_t)0)-2)/2)
2678luaX_lexerror(ls,"lexical element too long",0);
2679newsize=b->buffsize*2;
2680luaZ_resizebuffer(ls->L,b,newsize);
2681}
2682b->buffer[b->n++]=cast(char,c);
2683}
2684static void luaX_init(lua_State*L){
2685int i;
2686for(i=0;i<(cast(int,TK_WHILE-257+1));i++){
2687TString*ts=luaS_new(L,luaX_tokens[i]);
2688luaS_fix(ts);
2689ts->tsv.reserved=cast_byte(i+1);
2690}
2691}
2692static const char*luaX_token2str(LexState*ls,int token){
2693if(token<257){
2694return(iscntrl(token))?luaO_pushfstring(ls->L,"char(%d)",token):
2695luaO_pushfstring(ls->L,"%c",token);
2696}
2697else
2698return luaX_tokens[token-257];
2699}
2700static const char*txtToken(LexState*ls,int token){
2701switch(token){
2702case TK_NAME:
2703case TK_STRING:
2704case TK_NUMBER:
2705save(ls,'\0');
2706return luaZ_buffer(ls->buff);
2707default:
2708return luaX_token2str(ls,token);
2709}
2710}
2711static void luaX_lexerror(LexState*ls,const char*msg,int token){
2712char buff[80];
2713luaO_chunkid(buff,getstr(ls->source),80);
2714msg=luaO_pushfstring(ls->L,"%s:%d: %s",buff,ls->linenumber,msg);
2715if(token)
2716luaO_pushfstring(ls->L,"%s near "LUA_QL("%s"),msg,txtToken(ls,token));
2717luaD_throw(ls->L,3);
2718}
2719static void luaX_syntaxerror(LexState*ls,const char*msg){
2720luaX_lexerror(ls,msg,ls->t.token);
2721}
2722static TString*luaX_newstring(LexState*ls,const char*str,size_t l){
2723lua_State*L=ls->L;
2724TString*ts=luaS_newlstr(L,str,l);
2725TValue*o=luaH_setstr(L,ls->fs->h,ts);
2726if(ttisnil(o)){
2727setbvalue(o,1);
2728luaC_checkGC(L);
2729}
2730return ts;
2731}
2732static void inclinenumber(LexState*ls){
2733int old=ls->current;
2734next(ls);
2735if(currIsNewline(ls)&&ls->current!=old)
2736next(ls);
2737if(++ls->linenumber>=(INT_MAX-2))
2738luaX_syntaxerror(ls,"chunk has too many lines");
2739}
2740static void luaX_setinput(lua_State*L,LexState*ls,ZIO*z,TString*source){
2741ls->decpoint='.';
2742ls->L=L;
2743ls->lookahead.token=TK_EOS;
2744ls->z=z;
2745ls->fs=NULL;
2746ls->linenumber=1;
2747ls->lastline=1;
2748ls->source=source;
2749luaZ_resizebuffer(ls->L,ls->buff,32);
2750next(ls);
2751}
2752static int check_next(LexState*ls,const char*set){
2753if(!strchr(set,ls->current))
2754return 0;
2755save_and_next(ls);
2756return 1;
2757}
2758static void buffreplace(LexState*ls,char from,char to){
2759size_t n=luaZ_bufflen(ls->buff);
2760char*p=luaZ_buffer(ls->buff);
2761while(n--)
2762if(p[n]==from)p[n]=to;
2763}
2764static void read_numeral(LexState*ls,SemInfo*seminfo){
2765do{
2766save_and_next(ls);
2767}while(isdigit(ls->current)||ls->current=='.');
2768if(check_next(ls,"Ee"))
2769check_next(ls,"+-");
2770while(isalnum(ls->current)||ls->current=='_')
2771save_and_next(ls);
2772save(ls,'\0');
2773buffreplace(ls,'.',ls->decpoint);
2774if(!luaO_str2d(luaZ_buffer(ls->buff),&seminfo->r))
2775luaX_lexerror(ls,"malformed number",TK_NUMBER);
2776}
2777static int skip_sep(LexState*ls){
2778int count=0;
2779int s=ls->current;
2780save_and_next(ls);
2781while(ls->current=='='){
2782save_and_next(ls);
2783count++;
2784}
2785return(ls->current==s)?count:(-count)-1;
2786}
2787static void read_long_string(LexState*ls,SemInfo*seminfo,int sep){
2788int cont=0;
2789(void)(cont);
2790save_and_next(ls);
2791if(currIsNewline(ls))
2792inclinenumber(ls);
2793for(;;){
2794switch(ls->current){
2795case(-1):
2796luaX_lexerror(ls,(seminfo)?"unfinished long string":
2797"unfinished long comment",TK_EOS);
2798break;
2799case']':{
2800if(skip_sep(ls)==sep){
2801save_and_next(ls);
2802goto endloop;
2803}
2804break;
2805}
2806case'\n':
2807case'\r':{
2808save(ls,'\n');
2809inclinenumber(ls);
2810if(!seminfo)luaZ_resetbuffer(ls->buff);
2811break;
2812}
2813default:{
2814if(seminfo)save_and_next(ls);
2815else next(ls);
2816}
2817}
2818}endloop:
2819if(seminfo)
2820seminfo->ts=luaX_newstring(ls,luaZ_buffer(ls->buff)+(2+sep),
2821luaZ_bufflen(ls->buff)-2*(2+sep));
2822}
2823static void read_string(LexState*ls,int del,SemInfo*seminfo){
2824save_and_next(ls);
2825while(ls->current!=del){
2826switch(ls->current){
2827case(-1):
2828luaX_lexerror(ls,"unfinished string",TK_EOS);
2829continue;
2830case'\n':
2831case'\r':
2832luaX_lexerror(ls,"unfinished string",TK_STRING);
2833continue;
2834case'\\':{
2835int c;
2836next(ls);
2837switch(ls->current){
2838case'a':c='\a';break;
2839case'b':c='\b';break;
2840case'f':c='\f';break;
2841case'n':c='\n';break;
2842case'r':c='\r';break;
2843case't':c='\t';break;
2844case'v':c='\v';break;
2845case'\n':
2846case'\r':save(ls,'\n');inclinenumber(ls);continue;
2847case(-1):continue;
2848default:{
2849if(!isdigit(ls->current))
2850save_and_next(ls);
2851else{
2852int i=0;
2853c=0;
2854do{
2855c=10*c+(ls->current-'0');
2856next(ls);
2857}while(++i<3&&isdigit(ls->current));
2858if(c>UCHAR_MAX)
2859luaX_lexerror(ls,"escape sequence too large",TK_STRING);
2860save(ls,c);
2861}
2862continue;
2863}
2864}
2865save(ls,c);
2866next(ls);
2867continue;
2868}
2869default:
2870save_and_next(ls);
2871}
2872}
2873save_and_next(ls);
2874seminfo->ts=luaX_newstring(ls,luaZ_buffer(ls->buff)+1,
2875luaZ_bufflen(ls->buff)-2);
2876}
2877static int llex(LexState*ls,SemInfo*seminfo){
2878luaZ_resetbuffer(ls->buff);
2879for(;;){
2880switch(ls->current){
2881case'\n':
2882case'\r':{
2883inclinenumber(ls);
2884continue;
2885}
2886case'-':{
2887next(ls);
2888if(ls->current!='-')return'-';
2889next(ls);
2890if(ls->current=='['){
2891int sep=skip_sep(ls);
2892luaZ_resetbuffer(ls->buff);
2893if(sep>=0){
2894read_long_string(ls,NULL,sep);
2895luaZ_resetbuffer(ls->buff);
2896continue;
2897}
2898}
2899while(!currIsNewline(ls)&&ls->current!=(-1))
2900next(ls);
2901continue;
2902}
2903case'[':{
2904int sep=skip_sep(ls);
2905if(sep>=0){
2906read_long_string(ls,seminfo,sep);
2907return TK_STRING;
2908}
2909else if (sep!=-1)luaX_lexerror(ls,"invalid long string delimiter",TK_STRING);
2910return'[';
2911}
2912case'=':{
2913next(ls);
2914if(ls->current!='=')return'=';
2915else{next(ls);return TK_EQ;}
2916}
2917case'<':{
2918next(ls);
2919if(ls->current!='=')return'<';
2920else{next(ls);return TK_LE;}
2921}
2922case'>':{
2923next(ls);
2924if(ls->current!='=')return'>';
2925else{next(ls);return TK_GE;}
2926}
2927case'~':{
2928next(ls);
2929if(ls->current!='=')return'~';
2930else{next(ls);return TK_NE;}
2931}
2932case'"':
2933case'\'':{
2934read_string(ls,ls->current,seminfo);
2935return TK_STRING;
2936}
2937case'.':{
2938save_and_next(ls);
2939if(check_next(ls,".")){
2940if(check_next(ls,"."))
2941return TK_DOTS;
2942else return TK_CONCAT;
2943}
2944else if(!isdigit(ls->current))return'.';
2945else{
2946read_numeral(ls,seminfo);
2947return TK_NUMBER;
2948}
2949}
2950case(-1):{
2951return TK_EOS;
2952}
2953default:{
2954if(isspace(ls->current)){
2955next(ls);
2956continue;
2957}
2958else if(isdigit(ls->current)){
2959read_numeral(ls,seminfo);
2960return TK_NUMBER;
2961}
2962else if(isalpha(ls->current)||ls->current=='_'){
2963TString*ts;
2964do{
2965save_and_next(ls);
2966}while(isalnum(ls->current)||ls->current=='_');
2967ts=luaX_newstring(ls,luaZ_buffer(ls->buff),
2968luaZ_bufflen(ls->buff));
2969if(ts->tsv.reserved>0)
2970return ts->tsv.reserved-1+257;
2971else{
2972seminfo->ts=ts;
2973return TK_NAME;
2974}
2975}
2976else{
2977int c=ls->current;
2978next(ls);
2979return c;
2980}
2981}
2982}
2983}
2984}
2985static void luaX_next(LexState*ls){
2986ls->lastline=ls->linenumber;
2987if(ls->lookahead.token!=TK_EOS){
2988ls->t=ls->lookahead;
2989ls->lookahead.token=TK_EOS;
2990}
2991else
2992ls->t.token=llex(ls,&ls->t.seminfo);
2993}
2994static void luaX_lookahead(LexState*ls){
2995ls->lookahead.token=llex(ls,&ls->lookahead.seminfo);
2996}
2997#define hasjumps(e)((e)->t!=(e)->f)
2998static int isnumeral(expdesc*e){
2999return(e->k==VKNUM&&e->t==(-1)&&e->f==(-1));
3000}
3001static void luaK_nil(FuncState*fs,int from,int n){
3002Instruction*previous;
3003if(fs->pc>fs->lasttarget){
3004if(fs->pc==0){
3005if(from>=fs->nactvar)
3006return;
3007}
3008else{
3009previous=&fs->f->code[fs->pc-1];
3010if(GET_OPCODE(*previous)==OP_LOADNIL){
3011int pfrom=GETARG_A(*previous);
3012int pto=GETARG_B(*previous);
3013if(pfrom<=from&&from<=pto+1){
3014if(from+n-1>pto)
3015SETARG_B(*previous,from+n-1);
3016return;
3017}
3018}
3019}
3020}
3021luaK_codeABC(fs,OP_LOADNIL,from,from+n-1,0);
3022}
3023static int luaK_jump(FuncState*fs){
3024int jpc=fs->jpc;
3025int j;
3026fs->jpc=(-1);
3027j=luaK_codeAsBx(fs,OP_JMP,0,(-1));
3028luaK_concat(fs,&j,jpc);
3029return j;
3030}
3031static void luaK_ret(FuncState*fs,int first,int nret){
3032luaK_codeABC(fs,OP_RETURN,first,nret+1,0);
3033}
3034static int condjump(FuncState*fs,OpCode op,int A,int B,int C){
3035luaK_codeABC(fs,op,A,B,C);
3036return luaK_jump(fs);
3037}
3038static void fixjump(FuncState*fs,int pc,int dest){
3039Instruction*jmp=&fs->f->code[pc];
3040int offset=dest-(pc+1);
3041if(abs(offset)>(((1<<(9+9))-1)>>1))
3042luaX_syntaxerror(fs->ls,"control structure too long");
3043SETARG_sBx(*jmp,offset);
3044}
3045static int luaK_getlabel(FuncState*fs){
3046fs->lasttarget=fs->pc;
3047return fs->pc;
3048}
3049static int getjump(FuncState*fs,int pc){
3050int offset=GETARG_sBx(fs->f->code[pc]);
3051if(offset==(-1))
3052return(-1);
3053else
3054return(pc+1)+offset;
3055}
3056static Instruction*getjumpcontrol(FuncState*fs,int pc){
3057Instruction*pi=&fs->f->code[pc];
3058if(pc>=1&&testTMode(GET_OPCODE(*(pi-1))))
3059return pi-1;
3060else
3061return pi;
3062}
3063static int need_value(FuncState*fs,int list){
3064for(;list!=(-1);list=getjump(fs,list)){
3065Instruction i=*getjumpcontrol(fs,list);
3066if(GET_OPCODE(i)!=OP_TESTSET)return 1;
3067}
3068return 0;
3069}
3070static int patchtestreg(FuncState*fs,int node,int reg){
3071Instruction*i=getjumpcontrol(fs,node);
3072if(GET_OPCODE(*i)!=OP_TESTSET)
3073return 0;
3074if(reg!=((1<<8)-1)&&reg!=GETARG_B(*i))
3075SETARG_A(*i,reg);
3076else
3077*i=CREATE_ABC(OP_TEST,GETARG_B(*i),0,GETARG_C(*i));
3078return 1;
3079}
3080static void removevalues(FuncState*fs,int list){
3081for(;list!=(-1);list=getjump(fs,list))
3082patchtestreg(fs,list,((1<<8)-1));
3083}
3084static void patchlistaux(FuncState*fs,int list,int vtarget,int reg,
3085int dtarget){
3086while(list!=(-1)){
3087int next=getjump(fs,list);
3088if(patchtestreg(fs,list,reg))
3089fixjump(fs,list,vtarget);
3090else
3091fixjump(fs,list,dtarget);
3092list=next;
3093}
3094}
3095static void dischargejpc(FuncState*fs){
3096patchlistaux(fs,fs->jpc,fs->pc,((1<<8)-1),fs->pc);
3097fs->jpc=(-1);
3098}
3099static void luaK_patchlist(FuncState*fs,int list,int target){
3100if(target==fs->pc)
3101luaK_patchtohere(fs,list);
3102else{
3103patchlistaux(fs,list,target,((1<<8)-1),target);
3104}
3105}
3106static void luaK_patchtohere(FuncState*fs,int list){
3107luaK_getlabel(fs);
3108luaK_concat(fs,&fs->jpc,list);
3109}
3110static void luaK_concat(FuncState*fs,int*l1,int l2){
3111if(l2==(-1))return;
3112else if(*l1==(-1))
3113*l1=l2;
3114else{
3115int list=*l1;
3116int next;
3117while((next=getjump(fs,list))!=(-1))
3118list=next;
3119fixjump(fs,list,l2);
3120}
3121}
3122static void luaK_checkstack(FuncState*fs,int n){
3123int newstack=fs->freereg+n;
3124if(newstack>fs->f->maxstacksize){
3125if(newstack>=250)
3126luaX_syntaxerror(fs->ls,"function or expression too complex");
3127fs->f->maxstacksize=cast_byte(newstack);
3128}
3129}
3130static void luaK_reserveregs(FuncState*fs,int n){
3131luaK_checkstack(fs,n);
3132fs->freereg+=n;
3133}
3134static void freereg(FuncState*fs,int reg){
3135if(!ISK(reg)&&reg>=fs->nactvar){
3136fs->freereg--;
3137}
3138}
3139static void freeexp(FuncState*fs,expdesc*e){
3140if(e->k==VNONRELOC)
3141freereg(fs,e->u.s.info);
3142}
3143static int addk(FuncState*fs,TValue*k,TValue*v){
3144lua_State*L=fs->L;
3145TValue*idx=luaH_set(L,fs->h,k);
3146Proto*f=fs->f;
3147int oldsize=f->sizek;
3148if(ttisnumber(idx)){
3149return cast_int(nvalue(idx));
3150}
3151else{
3152setnvalue(idx,cast_num(fs->nk));
3153luaM_growvector(L,f->k,fs->nk,f->sizek,TValue,
3154((1<<(9+9))-1),"constant table overflow");
3155while(oldsize<f->sizek)setnilvalue(&f->k[oldsize++]);
3156setobj(L,&f->k[fs->nk],v);
3157luaC_barrier(L,f,v);
3158return fs->nk++;
3159}
3160}
3161static int luaK_stringK(FuncState*fs,TString*s){
3162TValue o;
3163setsvalue(fs->L,&o,s);
3164return addk(fs,&o,&o);
3165}
3166static int luaK_numberK(FuncState*fs,lua_Number r){
3167TValue o;
3168setnvalue(&o,r);
3169return addk(fs,&o,&o);
3170}
3171static int boolK(FuncState*fs,int b){
3172TValue o;
3173setbvalue(&o,b);
3174return addk(fs,&o,&o);
3175}
3176static int nilK(FuncState*fs){
3177TValue k,v;
3178setnilvalue(&v);
3179sethvalue(fs->L,&k,fs->h);
3180return addk(fs,&k,&v);
3181}
3182static void luaK_setreturns(FuncState*fs,expdesc*e,int nresults){
3183if(e->k==VCALL){
3184SETARG_C(getcode(fs,e),nresults+1);
3185}
3186else if(e->k==VVARARG){
3187SETARG_B(getcode(fs,e),nresults+1);
3188SETARG_A(getcode(fs,e),fs->freereg);
3189luaK_reserveregs(fs,1);
3190}
3191}
3192static void luaK_setoneret(FuncState*fs,expdesc*e){
3193if(e->k==VCALL){
3194e->k=VNONRELOC;
3195e->u.s.info=GETARG_A(getcode(fs,e));
3196}
3197else if(e->k==VVARARG){
3198SETARG_B(getcode(fs,e),2);
3199e->k=VRELOCABLE;
3200}
3201}
3202static void luaK_dischargevars(FuncState*fs,expdesc*e){
3203switch(e->k){
3204case VLOCAL:{
3205e->k=VNONRELOC;
3206break;
3207}
3208case VUPVAL:{
3209e->u.s.info=luaK_codeABC(fs,OP_GETUPVAL,0,e->u.s.info,0);
3210e->k=VRELOCABLE;
3211break;
3212}
3213case VGLOBAL:{
3214e->u.s.info=luaK_codeABx(fs,OP_GETGLOBAL,0,e->u.s.info);
3215e->k=VRELOCABLE;
3216break;
3217}
3218case VINDEXED:{
3219freereg(fs,e->u.s.aux);
3220freereg(fs,e->u.s.info);
3221e->u.s.info=luaK_codeABC(fs,OP_GETTABLE,0,e->u.s.info,e->u.s.aux);
3222e->k=VRELOCABLE;
3223break;
3224}
3225case VVARARG:
3226case VCALL:{
3227luaK_setoneret(fs,e);
3228break;
3229}
3230default:break;
3231}
3232}
3233static int code_label(FuncState*fs,int A,int b,int jump){
3234luaK_getlabel(fs);
3235return luaK_codeABC(fs,OP_LOADBOOL,A,b,jump);
3236}
3237static void discharge2reg(FuncState*fs,expdesc*e,int reg){
3238luaK_dischargevars(fs,e);
3239switch(e->k){
3240case VNIL:{
3241luaK_nil(fs,reg,1);
3242break;
3243}
3244case VFALSE:case VTRUE:{
3245luaK_codeABC(fs,OP_LOADBOOL,reg,e->k==VTRUE,0);
3246break;
3247}
3248case VK:{
3249luaK_codeABx(fs,OP_LOADK,reg,e->u.s.info);
3250break;
3251}
3252case VKNUM:{
3253luaK_codeABx(fs,OP_LOADK,reg,luaK_numberK(fs,e->u.nval));
3254break;
3255}
3256case VRELOCABLE:{
3257Instruction*pc=&getcode(fs,e);
3258SETARG_A(*pc,reg);
3259break;
3260}
3261case VNONRELOC:{
3262if(reg!=e->u.s.info)
3263luaK_codeABC(fs,OP_MOVE,reg,e->u.s.info,0);
3264break;
3265}
3266default:{
3267return;
3268}
3269}
3270e->u.s.info=reg;
3271e->k=VNONRELOC;
3272}
3273static void discharge2anyreg(FuncState*fs,expdesc*e){
3274if(e->k!=VNONRELOC){
3275luaK_reserveregs(fs,1);
3276discharge2reg(fs,e,fs->freereg-1);
3277}
3278}
3279static void exp2reg(FuncState*fs,expdesc*e,int reg){
3280discharge2reg(fs,e,reg);
3281if(e->k==VJMP)
3282luaK_concat(fs,&e->t,e->u.s.info);
3283if(hasjumps(e)){
3284int final;
3285int p_f=(-1);
3286int p_t=(-1);
3287if(need_value(fs,e->t)||need_value(fs,e->f)){
3288int fj=(e->k==VJMP)?(-1):luaK_jump(fs);
3289p_f=code_label(fs,reg,0,1);
3290p_t=code_label(fs,reg,1,0);
3291luaK_patchtohere(fs,fj);
3292}
3293final=luaK_getlabel(fs);
3294patchlistaux(fs,e->f,final,reg,p_f);
3295patchlistaux(fs,e->t,final,reg,p_t);
3296}
3297e->f=e->t=(-1);
3298e->u.s.info=reg;
3299e->k=VNONRELOC;
3300}
3301static void luaK_exp2nextreg(FuncState*fs,expdesc*e){
3302luaK_dischargevars(fs,e);
3303freeexp(fs,e);
3304luaK_reserveregs(fs,1);
3305exp2reg(fs,e,fs->freereg-1);
3306}
3307static int luaK_exp2anyreg(FuncState*fs,expdesc*e){
3308luaK_dischargevars(fs,e);
3309if(e->k==VNONRELOC){
3310if(!hasjumps(e))return e->u.s.info;
3311if(e->u.s.info>=fs->nactvar){
3312exp2reg(fs,e,e->u.s.info);
3313return e->u.s.info;
3314}
3315}
3316luaK_exp2nextreg(fs,e);
3317return e->u.s.info;
3318}
3319static void luaK_exp2val(FuncState*fs,expdesc*e){
3320if(hasjumps(e))
3321luaK_exp2anyreg(fs,e);
3322else
3323luaK_dischargevars(fs,e);
3324}
3325static int luaK_exp2RK(FuncState*fs,expdesc*e){
3326luaK_exp2val(fs,e);
3327switch(e->k){
3328case VKNUM:
3329case VTRUE:
3330case VFALSE:
3331case VNIL:{
3332if(fs->nk<=((1<<(9-1))-1)){
3333e->u.s.info=(e->k==VNIL)?nilK(fs):
3334(e->k==VKNUM)?luaK_numberK(fs,e->u.nval):
3335boolK(fs,(e->k==VTRUE));
3336e->k=VK;
3337return RKASK(e->u.s.info);
3338}
3339else break;
3340}
3341case VK:{
3342if(e->u.s.info<=((1<<(9-1))-1))
3343return RKASK(e->u.s.info);
3344else break;
3345}
3346default:break;
3347}
3348return luaK_exp2anyreg(fs,e);
3349}
3350static void luaK_storevar(FuncState*fs,expdesc*var,expdesc*ex){
3351switch(var->k){
3352case VLOCAL:{
3353freeexp(fs,ex);
3354exp2reg(fs,ex,var->u.s.info);
3355return;
3356}
3357case VUPVAL:{
3358int e=luaK_exp2anyreg(fs,ex);
3359luaK_codeABC(fs,OP_SETUPVAL,e,var->u.s.info,0);
3360break;
3361}
3362case VGLOBAL:{
3363int e=luaK_exp2anyreg(fs,ex);
3364luaK_codeABx(fs,OP_SETGLOBAL,e,var->u.s.info);
3365break;
3366}
3367case VINDEXED:{
3368int e=luaK_exp2RK(fs,ex);
3369luaK_codeABC(fs,OP_SETTABLE,var->u.s.info,var->u.s.aux,e);
3370break;
3371}
3372default:{
3373break;
3374}
3375}
3376freeexp(fs,ex);
3377}
3378static void luaK_self(FuncState*fs,expdesc*e,expdesc*key){
3379int func;
3380luaK_exp2anyreg(fs,e);
3381freeexp(fs,e);
3382func=fs->freereg;
3383luaK_reserveregs(fs,2);
3384luaK_codeABC(fs,OP_SELF,func,e->u.s.info,luaK_exp2RK(fs,key));
3385freeexp(fs,key);
3386e->u.s.info=func;
3387e->k=VNONRELOC;
3388}
3389static void invertjump(FuncState*fs,expdesc*e){
3390Instruction*pc=getjumpcontrol(fs,e->u.s.info);
3391SETARG_A(*pc,!(GETARG_A(*pc)));
3392}
3393static int jumponcond(FuncState*fs,expdesc*e,int cond){
3394if(e->k==VRELOCABLE){
3395Instruction ie=getcode(fs,e);
3396if(GET_OPCODE(ie)==OP_NOT){
3397fs->pc--;
3398return condjump(fs,OP_TEST,GETARG_B(ie),0,!cond);
3399}
3400}
3401discharge2anyreg(fs,e);
3402freeexp(fs,e);
3403return condjump(fs,OP_TESTSET,((1<<8)-1),e->u.s.info,cond);
3404}
3405static void luaK_goiftrue(FuncState*fs,expdesc*e){
3406int pc;
3407luaK_dischargevars(fs,e);
3408switch(e->k){
3409case VK:case VKNUM:case VTRUE:{
3410pc=(-1);
3411break;
3412}
3413case VJMP:{
3414invertjump(fs,e);
3415pc=e->u.s.info;
3416break;
3417}
3418default:{
3419pc=jumponcond(fs,e,0);
3420break;
3421}
3422}
3423luaK_concat(fs,&e->f,pc);
3424luaK_patchtohere(fs,e->t);
3425e->t=(-1);
3426}
3427static void luaK_goiffalse(FuncState*fs,expdesc*e){
3428int pc;
3429luaK_dischargevars(fs,e);
3430switch(e->k){
3431case VNIL:case VFALSE:{
3432pc=(-1);
3433break;
3434}
3435case VJMP:{
3436pc=e->u.s.info;
3437break;
3438}
3439default:{
3440pc=jumponcond(fs,e,1);
3441break;
3442}
3443}
3444luaK_concat(fs,&e->t,pc);
3445luaK_patchtohere(fs,e->f);
3446e->f=(-1);
3447}
3448static void codenot(FuncState*fs,expdesc*e){
3449luaK_dischargevars(fs,e);
3450switch(e->k){
3451case VNIL:case VFALSE:{
3452e->k=VTRUE;
3453break;
3454}
3455case VK:case VKNUM:case VTRUE:{
3456e->k=VFALSE;
3457break;
3458}
3459case VJMP:{
3460invertjump(fs,e);
3461break;
3462}
3463case VRELOCABLE:
3464case VNONRELOC:{
3465discharge2anyreg(fs,e);
3466freeexp(fs,e);
3467e->u.s.info=luaK_codeABC(fs,OP_NOT,0,e->u.s.info,0);
3468e->k=VRELOCABLE;
3469break;
3470}
3471default:{
3472break;
3473}
3474}
3475{int temp=e->f;e->f=e->t;e->t=temp;}
3476removevalues(fs,e->f);
3477removevalues(fs,e->t);
3478}
3479static void luaK_indexed(FuncState*fs,expdesc*t,expdesc*k){
3480t->u.s.aux=luaK_exp2RK(fs,k);
3481t->k=VINDEXED;
3482}
3483static int constfolding(OpCode op,expdesc*e1,expdesc*e2){
3484lua_Number v1,v2,r;
3485if(!isnumeral(e1)||!isnumeral(e2))return 0;
3486v1=e1->u.nval;
3487v2=e2->u.nval;
3488switch(op){
3489case OP_ADD:r=luai_numadd(v1,v2);break;
3490case OP_SUB:r=luai_numsub(v1,v2);break;
3491case OP_MUL:r=luai_nummul(v1,v2);break;
3492case OP_DIV:
3493if(v2==0)return 0;
3494r=luai_numdiv(v1,v2);break;
3495case OP_MOD:
3496if(v2==0)return 0;
3497r=luai_nummod(v1,v2);break;
3498case OP_POW:r=luai_numpow(v1,v2);break;
3499case OP_UNM:r=luai_numunm(v1);break;
3500case OP_LEN:return 0;
3501default:r=0;break;
3502}
3503if(luai_numisnan(r))return 0;
3504e1->u.nval=r;
3505return 1;
3506}
3507static void codearith(FuncState*fs,OpCode op,expdesc*e1,expdesc*e2){
3508if(constfolding(op,e1,e2))
3509return;
3510else{
3511int o2=(op!=OP_UNM&&op!=OP_LEN)?luaK_exp2RK(fs,e2):0;
3512int o1=luaK_exp2RK(fs,e1);
3513if(o1>o2){
3514freeexp(fs,e1);
3515freeexp(fs,e2);
3516}
3517else{
3518freeexp(fs,e2);
3519freeexp(fs,e1);
3520}
3521e1->u.s.info=luaK_codeABC(fs,op,0,o1,o2);
3522e1->k=VRELOCABLE;
3523}
3524}
3525static void codecomp(FuncState*fs,OpCode op,int cond,expdesc*e1,
3526expdesc*e2){
3527int o1=luaK_exp2RK(fs,e1);
3528int o2=luaK_exp2RK(fs,e2);
3529freeexp(fs,e2);
3530freeexp(fs,e1);
3531if(cond==0&&op!=OP_EQ){
3532int temp;
3533temp=o1;o1=o2;o2=temp;
3534cond=1;
3535}
3536e1->u.s.info=condjump(fs,op,cond,o1,o2);
3537e1->k=VJMP;
3538}
3539static void luaK_prefix(FuncState*fs,UnOpr op,expdesc*e){
3540expdesc e2;
3541e2.t=e2.f=(-1);e2.k=VKNUM;e2.u.nval=0;
3542switch(op){
3543case OPR_MINUS:{
3544if(!isnumeral(e))
3545luaK_exp2anyreg(fs,e);
3546codearith(fs,OP_UNM,e,&e2);
3547break;
3548}
3549case OPR_NOT:codenot(fs,e);break;
3550case OPR_LEN:{
3551luaK_exp2anyreg(fs,e);
3552codearith(fs,OP_LEN,e,&e2);
3553break;
3554}
3555default:;
3556}
3557}
3558static void luaK_infix(FuncState*fs,BinOpr op,expdesc*v){
3559switch(op){
3560case OPR_AND:{
3561luaK_goiftrue(fs,v);
3562break;
3563}
3564case OPR_OR:{
3565luaK_goiffalse(fs,v);
3566break;
3567}
3568case OPR_CONCAT:{
3569luaK_exp2nextreg(fs,v);
3570break;
3571}
3572case OPR_ADD:case OPR_SUB:case OPR_MUL:case OPR_DIV:
3573case OPR_MOD:case OPR_POW:{
3574if(!isnumeral(v))luaK_exp2RK(fs,v);
3575break;
3576}
3577default:{
3578luaK_exp2RK(fs,v);
3579break;
3580}
3581}
3582}
3583static void luaK_posfix(FuncState*fs,BinOpr op,expdesc*e1,expdesc*e2){
3584switch(op){
3585case OPR_AND:{
3586luaK_dischargevars(fs,e2);
3587luaK_concat(fs,&e2->f,e1->f);
3588*e1=*e2;
3589break;
3590}
3591case OPR_OR:{
3592luaK_dischargevars(fs,e2);
3593luaK_concat(fs,&e2->t,e1->t);
3594*e1=*e2;
3595break;
3596}
3597case OPR_CONCAT:{
3598luaK_exp2val(fs,e2);
3599if(e2->k==VRELOCABLE&&GET_OPCODE(getcode(fs,e2))==OP_CONCAT){
3600freeexp(fs,e1);
3601SETARG_B(getcode(fs,e2),e1->u.s.info);
3602e1->k=VRELOCABLE;e1->u.s.info=e2->u.s.info;
3603}
3604else{
3605luaK_exp2nextreg(fs,e2);
3606codearith(fs,OP_CONCAT,e1,e2);
3607}
3608break;
3609}
3610case OPR_ADD:codearith(fs,OP_ADD,e1,e2);break;
3611case OPR_SUB:codearith(fs,OP_SUB,e1,e2);break;
3612case OPR_MUL:codearith(fs,OP_MUL,e1,e2);break;
3613case OPR_DIV:codearith(fs,OP_DIV,e1,e2);break;
3614case OPR_MOD:codearith(fs,OP_MOD,e1,e2);break;
3615case OPR_POW:codearith(fs,OP_POW,e1,e2);break;
3616case OPR_EQ:codecomp(fs,OP_EQ,1,e1,e2);break;
3617case OPR_NE:codecomp(fs,OP_EQ,0,e1,e2);break;
3618case OPR_LT:codecomp(fs,OP_LT,1,e1,e2);break;
3619case OPR_LE:codecomp(fs,OP_LE,1,e1,e2);break;
3620case OPR_GT:codecomp(fs,OP_LT,0,e1,e2);break;
3621case OPR_GE:codecomp(fs,OP_LE,0,e1,e2);break;
3622default:;
3623}
3624}
3625static void luaK_fixline(FuncState*fs,int line){
3626fs->f->lineinfo[fs->pc-1]=line;
3627}
3628static int luaK_code(FuncState*fs,Instruction i,int line){
3629Proto*f=fs->f;
3630dischargejpc(fs);
3631luaM_growvector(fs->L,f->code,fs->pc,f->sizecode,Instruction,
3632(INT_MAX-2),"code size overflow");
3633f->code[fs->pc]=i;
3634luaM_growvector(fs->L,f->lineinfo,fs->pc,f->sizelineinfo,int,
3635(INT_MAX-2),"code size overflow");
3636f->lineinfo[fs->pc]=line;
3637return fs->pc++;
3638}
3639static int luaK_codeABC(FuncState*fs,OpCode o,int a,int b,int c){
3640return luaK_code(fs,CREATE_ABC(o,a,b,c),fs->ls->lastline);
3641}
3642static int luaK_codeABx(FuncState*fs,OpCode o,int a,unsigned int bc){
3643return luaK_code(fs,CREATE_ABx(o,a,bc),fs->ls->lastline);
3644}
3645static void luaK_setlist(FuncState*fs,int base,int nelems,int tostore){
3646int c=(nelems-1)/50+1;
3647int b=(tostore==(-1))?0:tostore;
3648if(c<=((1<<9)-1))
3649luaK_codeABC(fs,OP_SETLIST,base,b,c);
3650else{
3651luaK_codeABC(fs,OP_SETLIST,base,b,0);
3652luaK_code(fs,cast(Instruction,c),fs->ls->lastline);
3653}
3654fs->freereg=base+1;
3655}
3656#define hasmultret(k)((k)==VCALL||(k)==VVARARG)
3657#define getlocvar(fs,i)((fs)->f->locvars[(fs)->actvar[i]])
3658#define luaY_checklimit(fs,v,l,m)if((v)>(l))errorlimit(fs,l,m)
3659typedef struct BlockCnt{
3660struct BlockCnt*previous;
3661int breaklist;
3662lu_byte nactvar;
3663lu_byte upval;
3664lu_byte isbreakable;
3665}BlockCnt;
3666static void chunk(LexState*ls);
3667static void expr(LexState*ls,expdesc*v);
3668static void anchor_token(LexState*ls){
3669if(ls->t.token==TK_NAME||ls->t.token==TK_STRING){
3670TString*ts=ls->t.seminfo.ts;
3671luaX_newstring(ls,getstr(ts),ts->tsv.len);
3672}
3673}
3674static void error_expected(LexState*ls,int token){
3675luaX_syntaxerror(ls,
3676luaO_pushfstring(ls->L,LUA_QL("%s")" expected",luaX_token2str(ls,token)));
3677}
3678static void errorlimit(FuncState*fs,int limit,const char*what){
3679const char*msg=(fs->f->linedefined==0)?
3680luaO_pushfstring(fs->L,"main function has more than %d %s",limit,what):
3681luaO_pushfstring(fs->L,"function at line %d has more than %d %s",
3682fs->f->linedefined,limit,what);
3683luaX_lexerror(fs->ls,msg,0);
3684}
3685static int testnext(LexState*ls,int c){
3686if(ls->t.token==c){
3687luaX_next(ls);
3688return 1;
3689}
3690else return 0;
3691}
3692static void check(LexState*ls,int c){
3693if(ls->t.token!=c)
3694error_expected(ls,c);
3695}
3696static void checknext(LexState*ls,int c){
3697check(ls,c);
3698luaX_next(ls);
3699}
3700#define check_condition(ls,c,msg){if(!(c))luaX_syntaxerror(ls,msg);}
3701static void check_match(LexState*ls,int what,int who,int where){
3702if(!testnext(ls,what)){
3703if(where==ls->linenumber)
3704error_expected(ls,what);
3705else{
3706luaX_syntaxerror(ls,luaO_pushfstring(ls->L,
3707LUA_QL("%s")" expected (to close "LUA_QL("%s")" at line %d)",
3708luaX_token2str(ls,what),luaX_token2str(ls,who),where));
3709}
3710}
3711}
3712static TString*str_checkname(LexState*ls){
3713TString*ts;
3714check(ls,TK_NAME);
3715ts=ls->t.seminfo.ts;
3716luaX_next(ls);
3717return ts;
3718}
3719static void init_exp(expdesc*e,expkind k,int i){
3720e->f=e->t=(-1);
3721e->k=k;
3722e->u.s.info=i;
3723}
3724static void codestring(LexState*ls,expdesc*e,TString*s){
3725init_exp(e,VK,luaK_stringK(ls->fs,s));
3726}
3727static void checkname(LexState*ls,expdesc*e){
3728codestring(ls,e,str_checkname(ls));
3729}
3730static int registerlocalvar(LexState*ls,TString*varname){
3731FuncState*fs=ls->fs;
3732Proto*f=fs->f;
3733int oldsize=f->sizelocvars;
3734luaM_growvector(ls->L,f->locvars,fs->nlocvars,f->sizelocvars,
3735LocVar,SHRT_MAX,"too many local variables");
3736while(oldsize<f->sizelocvars)f->locvars[oldsize++].varname=NULL;
3737f->locvars[fs->nlocvars].varname=varname;
3738luaC_objbarrier(ls->L,f,varname);
3739return fs->nlocvars++;
3740}
3741#define new_localvarliteral(ls,v,n)new_localvar(ls,luaX_newstring(ls,""v,(sizeof(v)/sizeof(char))-1),n)
3742static void new_localvar(LexState*ls,TString*name,int n){
3743FuncState*fs=ls->fs;
3744luaY_checklimit(fs,fs->nactvar+n+1,200,"local variables");
3745fs->actvar[fs->nactvar+n]=cast(unsigned short,registerlocalvar(ls,name));
3746}
3747static void adjustlocalvars(LexState*ls,int nvars){
3748FuncState*fs=ls->fs;
3749fs->nactvar=cast_byte(fs->nactvar+nvars);
3750for(;nvars;nvars--){
3751getlocvar(fs,fs->nactvar-nvars).startpc=fs->pc;
3752}
3753}
3754static void removevars(LexState*ls,int tolevel){
3755FuncState*fs=ls->fs;
3756while(fs->nactvar>tolevel)
3757getlocvar(fs,--fs->nactvar).endpc=fs->pc;
3758}
3759static int indexupvalue(FuncState*fs,TString*name,expdesc*v){
3760int i;
3761Proto*f=fs->f;
3762int oldsize=f->sizeupvalues;
3763for(i=0;i<f->nups;i++){
3764if(fs->upvalues[i].k==v->k&&fs->upvalues[i].info==v->u.s.info){
3765return i;
3766}
3767}
3768luaY_checklimit(fs,f->nups+1,60,"upvalues");
3769luaM_growvector(fs->L,f->upvalues,f->nups,f->sizeupvalues,
3770TString*,(INT_MAX-2),"");
3771while(oldsize<f->sizeupvalues)f->upvalues[oldsize++]=NULL;
3772f->upvalues[f->nups]=name;
3773luaC_objbarrier(fs->L,f,name);
3774fs->upvalues[f->nups].k=cast_byte(v->k);
3775fs->upvalues[f->nups].info=cast_byte(v->u.s.info);
3776return f->nups++;
3777}
3778static int searchvar(FuncState*fs,TString*n){
3779int i;
3780for(i=fs->nactvar-1;i>=0;i--){
3781if(n==getlocvar(fs,i).varname)
3782return i;
3783}
3784return-1;
3785}
3786static void markupval(FuncState*fs,int level){
3787BlockCnt*bl=fs->bl;
3788while(bl&&bl->nactvar>level)bl=bl->previous;
3789if(bl)bl->upval=1;
3790}
3791static int singlevaraux(FuncState*fs,TString*n,expdesc*var,int base){
3792if(fs==NULL){
3793init_exp(var,VGLOBAL,((1<<8)-1));
3794return VGLOBAL;
3795}
3796else{
3797int v=searchvar(fs,n);
3798if(v>=0){
3799init_exp(var,VLOCAL,v);
3800if(!base)
3801markupval(fs,v);
3802return VLOCAL;
3803}
3804else{
3805if(singlevaraux(fs->prev,n,var,0)==VGLOBAL)
3806return VGLOBAL;
3807var->u.s.info=indexupvalue(fs,n,var);
3808var->k=VUPVAL;
3809return VUPVAL;
3810}
3811}
3812}
3813static void singlevar(LexState*ls,expdesc*var){
3814TString*varname=str_checkname(ls);
3815FuncState*fs=ls->fs;
3816if(singlevaraux(fs,varname,var,1)==VGLOBAL)
3817var->u.s.info=luaK_stringK(fs,varname);
3818}
3819static void adjust_assign(LexState*ls,int nvars,int nexps,expdesc*e){
3820FuncState*fs=ls->fs;
3821int extra=nvars-nexps;
3822if(hasmultret(e->k)){
3823extra++;
3824if(extra<0)extra=0;
3825luaK_setreturns(fs,e,extra);
3826if(extra>1)luaK_reserveregs(fs,extra-1);
3827}
3828else{
3829if(e->k!=VVOID)luaK_exp2nextreg(fs,e);
3830if(extra>0){
3831int reg=fs->freereg;
3832luaK_reserveregs(fs,extra);
3833luaK_nil(fs,reg,extra);
3834}
3835}
3836}
3837static void enterlevel(LexState*ls){
3838if(++ls->L->nCcalls>200)
3839luaX_lexerror(ls,"chunk has too many syntax levels",0);
3840}
3841#define leavelevel(ls)((ls)->L->nCcalls--)
3842static void enterblock(FuncState*fs,BlockCnt*bl,lu_byte isbreakable){
3843bl->breaklist=(-1);
3844bl->isbreakable=isbreakable;
3845bl->nactvar=fs->nactvar;
3846bl->upval=0;
3847bl->previous=fs->bl;
3848fs->bl=bl;
3849}
3850static void leaveblock(FuncState*fs){
3851BlockCnt*bl=fs->bl;
3852fs->bl=bl->previous;
3853removevars(fs->ls,bl->nactvar);
3854if(bl->upval)
3855luaK_codeABC(fs,OP_CLOSE,bl->nactvar,0,0);
3856fs->freereg=fs->nactvar;
3857luaK_patchtohere(fs,bl->breaklist);
3858}
3859static void pushclosure(LexState*ls,FuncState*func,expdesc*v){
3860FuncState*fs=ls->fs;
3861Proto*f=fs->f;
3862int oldsize=f->sizep;
3863int i;
3864luaM_growvector(ls->L,f->p,fs->np,f->sizep,Proto*,
3865((1<<(9+9))-1),"constant table overflow");
3866while(oldsize<f->sizep)f->p[oldsize++]=NULL;
3867f->p[fs->np++]=func->f;
3868luaC_objbarrier(ls->L,f,func->f);
3869init_exp(v,VRELOCABLE,luaK_codeABx(fs,OP_CLOSURE,0,fs->np-1));
3870for(i=0;i<func->f->nups;i++){
3871OpCode o=(func->upvalues[i].k==VLOCAL)?OP_MOVE:OP_GETUPVAL;
3872luaK_codeABC(fs,o,0,func->upvalues[i].info,0);
3873}
3874}
3875static void open_func(LexState*ls,FuncState*fs){
3876lua_State*L=ls->L;
3877Proto*f=luaF_newproto(L);
3878fs->f=f;
3879fs->prev=ls->fs;
3880fs->ls=ls;
3881fs->L=L;
3882ls->fs=fs;
3883fs->pc=0;
3884fs->lasttarget=-1;
3885fs->jpc=(-1);
3886fs->freereg=0;
3887fs->nk=0;
3888fs->np=0;
3889fs->nlocvars=0;
3890fs->nactvar=0;
3891fs->bl=NULL;
3892f->source=ls->source;
3893f->maxstacksize=2;
3894fs->h=luaH_new(L,0,0);
3895sethvalue(L,L->top,fs->h);
3896incr_top(L);
3897setptvalue(L,L->top,f);
3898incr_top(L);
3899}
3900static void close_func(LexState*ls){
3901lua_State*L=ls->L;
3902FuncState*fs=ls->fs;
3903Proto*f=fs->f;
3904removevars(ls,0);
3905luaK_ret(fs,0,0);
3906luaM_reallocvector(L,f->code,f->sizecode,fs->pc,Instruction);
3907f->sizecode=fs->pc;
3908luaM_reallocvector(L,f->lineinfo,f->sizelineinfo,fs->pc,int);
3909f->sizelineinfo=fs->pc;
3910luaM_reallocvector(L,f->k,f->sizek,fs->nk,TValue);
3911f->sizek=fs->nk;
3912luaM_reallocvector(L,f->p,f->sizep,fs->np,Proto*);
3913f->sizep=fs->np;
3914luaM_reallocvector(L,f->locvars,f->sizelocvars,fs->nlocvars,LocVar);
3915f->sizelocvars=fs->nlocvars;
3916luaM_reallocvector(L,f->upvalues,f->sizeupvalues,f->nups,TString*);
3917f->sizeupvalues=f->nups;
3918ls->fs=fs->prev;
3919if(fs)anchor_token(ls);
3920L->top-=2;
3921}
3922static Proto*luaY_parser(lua_State*L,ZIO*z,Mbuffer*buff,const char*name){
3923struct LexState lexstate;
3924struct FuncState funcstate;
3925lexstate.buff=buff;
3926luaX_setinput(L,&lexstate,z,luaS_new(L,name));
3927open_func(&lexstate,&funcstate);
3928funcstate.f->is_vararg=2;
3929luaX_next(&lexstate);
3930chunk(&lexstate);
3931check(&lexstate,TK_EOS);
3932close_func(&lexstate);
3933return funcstate.f;
3934}
3935static void field(LexState*ls,expdesc*v){
3936FuncState*fs=ls->fs;
3937expdesc key;
3938luaK_exp2anyreg(fs,v);
3939luaX_next(ls);
3940checkname(ls,&key);
3941luaK_indexed(fs,v,&key);
3942}
3943static void yindex(LexState*ls,expdesc*v){
3944luaX_next(ls);
3945expr(ls,v);
3946luaK_exp2val(ls->fs,v);
3947checknext(ls,']');
3948}
3949struct ConsControl{
3950expdesc v;
3951expdesc*t;
3952int nh;
3953int na;
3954int tostore;
3955};
3956static void recfield(LexState*ls,struct ConsControl*cc){
3957FuncState*fs=ls->fs;
3958int reg=ls->fs->freereg;
3959expdesc key,val;
3960int rkkey;
3961if(ls->t.token==TK_NAME){
3962luaY_checklimit(fs,cc->nh,(INT_MAX-2),"items in a constructor");
3963checkname(ls,&key);
3964}
3965else
3966yindex(ls,&key);
3967cc->nh++;
3968checknext(ls,'=');
3969rkkey=luaK_exp2RK(fs,&key);
3970expr(ls,&val);
3971luaK_codeABC(fs,OP_SETTABLE,cc->t->u.s.info,rkkey,luaK_exp2RK(fs,&val));
3972fs->freereg=reg;
3973}
3974static void closelistfield(FuncState*fs,struct ConsControl*cc){
3975if(cc->v.k==VVOID)return;
3976luaK_exp2nextreg(fs,&cc->v);
3977cc->v.k=VVOID;
3978if(cc->tostore==50){
3979luaK_setlist(fs,cc->t->u.s.info,cc->na,cc->tostore);
3980cc->tostore=0;
3981}
3982}
3983static void lastlistfield(FuncState*fs,struct ConsControl*cc){
3984if(cc->tostore==0)return;
3985if(hasmultret(cc->v.k)){
3986luaK_setmultret(fs,&cc->v);
3987luaK_setlist(fs,cc->t->u.s.info,cc->na,(-1));
3988cc->na--;
3989}
3990else{
3991if(cc->v.k!=VVOID)
3992luaK_exp2nextreg(fs,&cc->v);
3993luaK_setlist(fs,cc->t->u.s.info,cc->na,cc->tostore);
3994}
3995}
3996static void listfield(LexState*ls,struct ConsControl*cc){
3997expr(ls,&cc->v);
3998luaY_checklimit(ls->fs,cc->na,(INT_MAX-2),"items in a constructor");
3999cc->na++;
4000cc->tostore++;
4001}
4002static void constructor(LexState*ls,expdesc*t){
4003FuncState*fs=ls->fs;
4004int line=ls->linenumber;
4005int pc=luaK_codeABC(fs,OP_NEWTABLE,0,0,0);
4006struct ConsControl cc;
4007cc.na=cc.nh=cc.tostore=0;
4008cc.t=t;
4009init_exp(t,VRELOCABLE,pc);
4010init_exp(&cc.v,VVOID,0);
4011luaK_exp2nextreg(ls->fs,t);
4012checknext(ls,'{');
4013do{
4014if(ls->t.token=='}')break;
4015closelistfield(fs,&cc);
4016switch(ls->t.token){
4017case TK_NAME:{
4018luaX_lookahead(ls);
4019if(ls->lookahead.token!='=')
4020listfield(ls,&cc);
4021else
4022recfield(ls,&cc);
4023break;
4024}
4025case'[':{
4026recfield(ls,&cc);
4027break;
4028}
4029default:{
4030listfield(ls,&cc);
4031break;
4032}
4033}
4034}while(testnext(ls,',')||testnext(ls,';'));
4035check_match(ls,'}','{',line);
4036lastlistfield(fs,&cc);
4037SETARG_B(fs->f->code[pc],luaO_int2fb(cc.na));
4038SETARG_C(fs->f->code[pc],luaO_int2fb(cc.nh));
4039}
4040static void parlist(LexState*ls){
4041FuncState*fs=ls->fs;
4042Proto*f=fs->f;
4043int nparams=0;
4044f->is_vararg=0;
4045if(ls->t.token!=')'){
4046do{
4047switch(ls->t.token){
4048case TK_NAME:{
4049new_localvar(ls,str_checkname(ls),nparams++);
4050break;
4051}
4052case TK_DOTS:{
4053luaX_next(ls);
4054f->is_vararg|=2;
4055break;
4056}
4057default:luaX_syntaxerror(ls,"<name> or "LUA_QL("...")" expected");
4058}
4059}while(!f->is_vararg&&testnext(ls,','));
4060}
4061adjustlocalvars(ls,nparams);
4062f->numparams=cast_byte(fs->nactvar-(f->is_vararg&1));
4063luaK_reserveregs(fs,fs->nactvar);
4064}
4065static void body(LexState*ls,expdesc*e,int needself,int line){
4066FuncState new_fs;
4067open_func(ls,&new_fs);
4068new_fs.f->linedefined=line;
4069checknext(ls,'(');
4070if(needself){
4071new_localvarliteral(ls,"self",0);
4072adjustlocalvars(ls,1);
4073}
4074parlist(ls);
4075checknext(ls,')');
4076chunk(ls);
4077new_fs.f->lastlinedefined=ls->linenumber;
4078check_match(ls,TK_END,TK_FUNCTION,line);
4079close_func(ls);
4080pushclosure(ls,&new_fs,e);
4081}
4082static int explist1(LexState*ls,expdesc*v){
4083int n=1;
4084expr(ls,v);
4085while(testnext(ls,',')){
4086luaK_exp2nextreg(ls->fs,v);
4087expr(ls,v);
4088n++;
4089}
4090return n;
4091}
4092static void funcargs(LexState*ls,expdesc*f){
4093FuncState*fs=ls->fs;
4094expdesc args;
4095int base,nparams;
4096int line=ls->linenumber;
4097switch(ls->t.token){
4098case'(':{
4099if(line!=ls->lastline)
4100luaX_syntaxerror(ls,"ambiguous syntax (function call x new statement)");
4101luaX_next(ls);
4102if(ls->t.token==')')
4103args.k=VVOID;
4104else{
4105explist1(ls,&args);
4106luaK_setmultret(fs,&args);
4107}
4108check_match(ls,')','(',line);
4109break;
4110}
4111case'{':{
4112constructor(ls,&args);
4113break;
4114}
4115case TK_STRING:{
4116codestring(ls,&args,ls->t.seminfo.ts);
4117luaX_next(ls);
4118break;
4119}
4120default:{
4121luaX_syntaxerror(ls,"function arguments expected");
4122return;
4123}
4124}
4125base=f->u.s.info;
4126if(hasmultret(args.k))
4127nparams=(-1);
4128else{
4129if(args.k!=VVOID)
4130luaK_exp2nextreg(fs,&args);
4131nparams=fs->freereg-(base+1);
4132}
4133init_exp(f,VCALL,luaK_codeABC(fs,OP_CALL,base,nparams+1,2));
4134luaK_fixline(fs,line);
4135fs->freereg=base+1;
4136}
4137static void prefixexp(LexState*ls,expdesc*v){
4138switch(ls->t.token){
4139case'(':{
4140int line=ls->linenumber;
4141luaX_next(ls);
4142expr(ls,v);
4143check_match(ls,')','(',line);
4144luaK_dischargevars(ls->fs,v);
4145return;
4146}
4147case TK_NAME:{
4148singlevar(ls,v);
4149return;
4150}
4151default:{
4152luaX_syntaxerror(ls,"unexpected symbol");
4153return;
4154}
4155}
4156}
4157static void primaryexp(LexState*ls,expdesc*v){
4158FuncState*fs=ls->fs;
4159prefixexp(ls,v);
4160for(;;){
4161switch(ls->t.token){
4162case'.':{
4163field(ls,v);
4164break;
4165}
4166case'[':{
4167expdesc key;
4168luaK_exp2anyreg(fs,v);
4169yindex(ls,&key);
4170luaK_indexed(fs,v,&key);
4171break;
4172}
4173case':':{
4174expdesc key;
4175luaX_next(ls);
4176checkname(ls,&key);
4177luaK_self(fs,v,&key);
4178funcargs(ls,v);
4179break;
4180}
4181case'(':case TK_STRING:case'{':{
4182luaK_exp2nextreg(fs,v);
4183funcargs(ls,v);
4184break;
4185}
4186default:return;
4187}
4188}
4189}
4190static void simpleexp(LexState*ls,expdesc*v){
4191switch(ls->t.token){
4192case TK_NUMBER:{
4193init_exp(v,VKNUM,0);
4194v->u.nval=ls->t.seminfo.r;
4195break;
4196}
4197case TK_STRING:{
4198codestring(ls,v,ls->t.seminfo.ts);
4199break;
4200}
4201case TK_NIL:{
4202init_exp(v,VNIL,0);
4203break;
4204}
4205case TK_TRUE:{
4206init_exp(v,VTRUE,0);
4207break;
4208}
4209case TK_FALSE:{
4210init_exp(v,VFALSE,0);
4211break;
4212}
4213case TK_DOTS:{
4214FuncState*fs=ls->fs;
4215check_condition(ls,fs->f->is_vararg,
4216"cannot use "LUA_QL("...")" outside a vararg function");
4217fs->f->is_vararg&=~4;
4218init_exp(v,VVARARG,luaK_codeABC(fs,OP_VARARG,0,1,0));
4219break;
4220}
4221case'{':{
4222constructor(ls,v);
4223return;
4224}
4225case TK_FUNCTION:{
4226luaX_next(ls);
4227body(ls,v,0,ls->linenumber);
4228return;
4229}
4230default:{
4231primaryexp(ls,v);
4232return;
4233}
4234}
4235luaX_next(ls);
4236}
4237static UnOpr getunopr(int op){
4238switch(op){
4239case TK_NOT:return OPR_NOT;
4240case'-':return OPR_MINUS;
4241case'#':return OPR_LEN;
4242default:return OPR_NOUNOPR;
4243}
4244}
4245static BinOpr getbinopr(int op){
4246switch(op){
4247case'+':return OPR_ADD;
4248case'-':return OPR_SUB;
4249case'*':return OPR_MUL;
4250case'/':return OPR_DIV;
4251case'%':return OPR_MOD;
4252case'^':return OPR_POW;
4253case TK_CONCAT:return OPR_CONCAT;
4254case TK_NE:return OPR_NE;
4255case TK_EQ:return OPR_EQ;
4256case'<':return OPR_LT;
4257case TK_LE:return OPR_LE;
4258case'>':return OPR_GT;
4259case TK_GE:return OPR_GE;
4260case TK_AND:return OPR_AND;
4261case TK_OR:return OPR_OR;
4262default:return OPR_NOBINOPR;
4263}
4264}
4265static const struct{
4266lu_byte left;
4267lu_byte right;
4268}priority[]={
4269{6,6},{6,6},{7,7},{7,7},{7,7},
4270{10,9},{5,4},
4271{3,3},{3,3},
4272{3,3},{3,3},{3,3},{3,3},
4273{2,2},{1,1}
4274};
4275static BinOpr subexpr(LexState*ls,expdesc*v,unsigned int limit){
4276BinOpr op;
4277UnOpr uop;
4278enterlevel(ls);
4279uop=getunopr(ls->t.token);
4280if(uop!=OPR_NOUNOPR){
4281luaX_next(ls);
4282subexpr(ls,v,8);
4283luaK_prefix(ls->fs,uop,v);
4284}
4285else simpleexp(ls,v);
4286op=getbinopr(ls->t.token);
4287while(op!=OPR_NOBINOPR&&priority[op].left>limit){
4288expdesc v2;
4289BinOpr nextop;
4290luaX_next(ls);
4291luaK_infix(ls->fs,op,v);
4292nextop=subexpr(ls,&v2,priority[op].right);
4293luaK_posfix(ls->fs,op,v,&v2);
4294op=nextop;
4295}
4296leavelevel(ls);
4297return op;
4298}
4299static void expr(LexState*ls,expdesc*v){
4300subexpr(ls,v,0);
4301}
4302static int block_follow(int token){
4303switch(token){
4304case TK_ELSE:case TK_ELSEIF:case TK_END:
4305case TK_UNTIL:case TK_EOS:
4306return 1;
4307default:return 0;
4308}
4309}
4310static void block(LexState*ls){
4311FuncState*fs=ls->fs;
4312BlockCnt bl;
4313enterblock(fs,&bl,0);
4314chunk(ls);
4315leaveblock(fs);
4316}
4317struct LHS_assign{
4318struct LHS_assign*prev;
4319expdesc v;
4320};
4321static void check_conflict(LexState*ls,struct LHS_assign*lh,expdesc*v){
4322FuncState*fs=ls->fs;
4323int extra=fs->freereg;
4324int conflict=0;
4325for(;lh;lh=lh->prev){
4326if(lh->v.k==VINDEXED){
4327if(lh->v.u.s.info==v->u.s.info){
4328conflict=1;
4329lh->v.u.s.info=extra;
4330}
4331if(lh->v.u.s.aux==v->u.s.info){
4332conflict=1;
4333lh->v.u.s.aux=extra;
4334}
4335}
4336}
4337if(conflict){
4338luaK_codeABC(fs,OP_MOVE,fs->freereg,v->u.s.info,0);
4339luaK_reserveregs(fs,1);
4340}
4341}
4342static void assignment(LexState*ls,struct LHS_assign*lh,int nvars){
4343expdesc e;
4344check_condition(ls,VLOCAL<=lh->v.k&&lh->v.k<=VINDEXED,
4345"syntax error");
4346if(testnext(ls,',')){
4347struct LHS_assign nv;
4348nv.prev=lh;
4349primaryexp(ls,&nv.v);
4350if(nv.v.k==VLOCAL)
4351check_conflict(ls,lh,&nv.v);
4352luaY_checklimit(ls->fs,nvars,200-ls->L->nCcalls,
4353"variables in assignment");
4354assignment(ls,&nv,nvars+1);
4355}
4356else{
4357int nexps;
4358checknext(ls,'=');
4359nexps=explist1(ls,&e);
4360if(nexps!=nvars){
4361adjust_assign(ls,nvars,nexps,&e);
4362if(nexps>nvars)
4363ls->fs->freereg-=nexps-nvars;
4364}
4365else{
4366luaK_setoneret(ls->fs,&e);
4367luaK_storevar(ls->fs,&lh->v,&e);
4368return;
4369}
4370}
4371init_exp(&e,VNONRELOC,ls->fs->freereg-1);
4372luaK_storevar(ls->fs,&lh->v,&e);
4373}
4374static int cond(LexState*ls){
4375expdesc v;
4376expr(ls,&v);
4377if(v.k==VNIL)v.k=VFALSE;
4378luaK_goiftrue(ls->fs,&v);
4379return v.f;
4380}
4381static void breakstat(LexState*ls){
4382FuncState*fs=ls->fs;
4383BlockCnt*bl=fs->bl;
4384int upval=0;
4385while(bl&&!bl->isbreakable){
4386upval|=bl->upval;
4387bl=bl->previous;
4388}
4389if(!bl)
4390luaX_syntaxerror(ls,"no loop to break");
4391if(upval)
4392luaK_codeABC(fs,OP_CLOSE,bl->nactvar,0,0);
4393luaK_concat(fs,&bl->breaklist,luaK_jump(fs));
4394}
4395static void whilestat(LexState*ls,int line){
4396FuncState*fs=ls->fs;
4397int whileinit;
4398int condexit;
4399BlockCnt bl;
4400luaX_next(ls);
4401whileinit=luaK_getlabel(fs);
4402condexit=cond(ls);
4403enterblock(fs,&bl,1);
4404checknext(ls,TK_DO);
4405block(ls);
4406luaK_patchlist(fs,luaK_jump(fs),whileinit);
4407check_match(ls,TK_END,TK_WHILE,line);
4408leaveblock(fs);
4409luaK_patchtohere(fs,condexit);
4410}
4411static void repeatstat(LexState*ls,int line){
4412int condexit;
4413FuncState*fs=ls->fs;
4414int repeat_init=luaK_getlabel(fs);
4415BlockCnt bl1,bl2;
4416enterblock(fs,&bl1,1);
4417enterblock(fs,&bl2,0);
4418luaX_next(ls);
4419chunk(ls);
4420check_match(ls,TK_UNTIL,TK_REPEAT,line);
4421condexit=cond(ls);
4422if(!bl2.upval){
4423leaveblock(fs);
4424luaK_patchlist(ls->fs,condexit,repeat_init);
4425}
4426else{
4427breakstat(ls);
4428luaK_patchtohere(ls->fs,condexit);
4429leaveblock(fs);
4430luaK_patchlist(ls->fs,luaK_jump(fs),repeat_init);
4431}
4432leaveblock(fs);
4433}
4434static int exp1(LexState*ls){
4435expdesc e;
4436int k;
4437expr(ls,&e);
4438k=e.k;
4439luaK_exp2nextreg(ls->fs,&e);
4440return k;
4441}
4442static void forbody(LexState*ls,int base,int line,int nvars,int isnum){
4443BlockCnt bl;
4444FuncState*fs=ls->fs;
4445int prep,endfor;
4446adjustlocalvars(ls,3);
4447checknext(ls,TK_DO);
4448prep=isnum?luaK_codeAsBx(fs,OP_FORPREP,base,(-1)):luaK_jump(fs);
4449enterblock(fs,&bl,0);
4450adjustlocalvars(ls,nvars);
4451luaK_reserveregs(fs,nvars);
4452block(ls);
4453leaveblock(fs);
4454luaK_patchtohere(fs,prep);
4455endfor=(isnum)?luaK_codeAsBx(fs,OP_FORLOOP,base,(-1)):
4456luaK_codeABC(fs,OP_TFORLOOP,base,0,nvars);
4457luaK_fixline(fs,line);
4458luaK_patchlist(fs,(isnum?endfor:luaK_jump(fs)),prep+1);
4459}
4460static void fornum(LexState*ls,TString*varname,int line){
4461FuncState*fs=ls->fs;
4462int base=fs->freereg;
4463new_localvarliteral(ls,"(for index)",0);
4464new_localvarliteral(ls,"(for limit)",1);
4465new_localvarliteral(ls,"(for step)",2);
4466new_localvar(ls,varname,3);
4467checknext(ls,'=');
4468exp1(ls);
4469checknext(ls,',');
4470exp1(ls);
4471if(testnext(ls,','))
4472exp1(ls);
4473else{
4474luaK_codeABx(fs,OP_LOADK,fs->freereg,luaK_numberK(fs,1));
4475luaK_reserveregs(fs,1);
4476}
4477forbody(ls,base,line,1,1);
4478}
4479static void forlist(LexState*ls,TString*indexname){
4480FuncState*fs=ls->fs;
4481expdesc e;
4482int nvars=0;
4483int line;
4484int base=fs->freereg;
4485new_localvarliteral(ls,"(for generator)",nvars++);
4486new_localvarliteral(ls,"(for state)",nvars++);
4487new_localvarliteral(ls,"(for control)",nvars++);
4488new_localvar(ls,indexname,nvars++);
4489while(testnext(ls,','))
4490new_localvar(ls,str_checkname(ls),nvars++);
4491checknext(ls,TK_IN);
4492line=ls->linenumber;
4493adjust_assign(ls,3,explist1(ls,&e),&e);
4494luaK_checkstack(fs,3);
4495forbody(ls,base,line,nvars-3,0);
4496}
4497static void forstat(LexState*ls,int line){
4498FuncState*fs=ls->fs;
4499TString*varname;
4500BlockCnt bl;
4501enterblock(fs,&bl,1);
4502luaX_next(ls);
4503varname=str_checkname(ls);
4504switch(ls->t.token){
4505case'=':fornum(ls,varname,line);break;
4506case',':case TK_IN:forlist(ls,varname);break;
4507default:luaX_syntaxerror(ls,LUA_QL("=")" or "LUA_QL("in")" expected");
4508}
4509check_match(ls,TK_END,TK_FOR,line);
4510leaveblock(fs);
4511}
4512static int test_then_block(LexState*ls){
4513int condexit;
4514luaX_next(ls);
4515condexit=cond(ls);
4516checknext(ls,TK_THEN);
4517block(ls);
4518return condexit;
4519}
4520static void ifstat(LexState*ls,int line){
4521FuncState*fs=ls->fs;
4522int flist;
4523int escapelist=(-1);
4524flist=test_then_block(ls);
4525while(ls->t.token==TK_ELSEIF){
4526luaK_concat(fs,&escapelist,luaK_jump(fs));
4527luaK_patchtohere(fs,flist);
4528flist=test_then_block(ls);
4529}
4530if(ls->t.token==TK_ELSE){
4531luaK_concat(fs,&escapelist,luaK_jump(fs));
4532luaK_patchtohere(fs,flist);
4533luaX_next(ls);
4534block(ls);
4535}
4536else
4537luaK_concat(fs,&escapelist,flist);
4538luaK_patchtohere(fs,escapelist);
4539check_match(ls,TK_END,TK_IF,line);
4540}
4541static void localfunc(LexState*ls){
4542expdesc v,b;
4543FuncState*fs=ls->fs;
4544new_localvar(ls,str_checkname(ls),0);
4545init_exp(&v,VLOCAL,fs->freereg);
4546luaK_reserveregs(fs,1);
4547adjustlocalvars(ls,1);
4548body(ls,&b,0,ls->linenumber);
4549luaK_storevar(fs,&v,&b);
4550getlocvar(fs,fs->nactvar-1).startpc=fs->pc;
4551}
4552static void localstat(LexState*ls){
4553int nvars=0;
4554int nexps;
4555expdesc e;
4556do{
4557new_localvar(ls,str_checkname(ls),nvars++);
4558}while(testnext(ls,','));
4559if(testnext(ls,'='))
4560nexps=explist1(ls,&e);
4561else{
4562e.k=VVOID;
4563nexps=0;
4564}
4565adjust_assign(ls,nvars,nexps,&e);
4566adjustlocalvars(ls,nvars);
4567}
4568static int funcname(LexState*ls,expdesc*v){
4569int needself=0;
4570singlevar(ls,v);
4571while(ls->t.token=='.')
4572field(ls,v);
4573if(ls->t.token==':'){
4574needself=1;
4575field(ls,v);
4576}
4577return needself;
4578}
4579static void funcstat(LexState*ls,int line){
4580int needself;
4581expdesc v,b;
4582luaX_next(ls);
4583needself=funcname(ls,&v);
4584body(ls,&b,needself,line);
4585luaK_storevar(ls->fs,&v,&b);
4586luaK_fixline(ls->fs,line);
4587}
4588static void exprstat(LexState*ls){
4589FuncState*fs=ls->fs;
4590struct LHS_assign v;
4591primaryexp(ls,&v.v);
4592if(v.v.k==VCALL)
4593SETARG_C(getcode(fs,&v.v),1);
4594else{
4595v.prev=NULL;
4596assignment(ls,&v,1);
4597}
4598}
4599static void retstat(LexState*ls){
4600FuncState*fs=ls->fs;
4601expdesc e;
4602int first,nret;
4603luaX_next(ls);
4604if(block_follow(ls->t.token)||ls->t.token==';')
4605first=nret=0;
4606else{
4607nret=explist1(ls,&e);
4608if(hasmultret(e.k)){
4609luaK_setmultret(fs,&e);
4610if(e.k==VCALL&&nret==1){
4611SET_OPCODE(getcode(fs,&e),OP_TAILCALL);
4612}
4613first=fs->nactvar;
4614nret=(-1);
4615}
4616else{
4617if(nret==1)
4618first=luaK_exp2anyreg(fs,&e);
4619else{
4620luaK_exp2nextreg(fs,&e);
4621first=fs->nactvar;
4622}
4623}
4624}
4625luaK_ret(fs,first,nret);
4626}
4627static int statement(LexState*ls){
4628int line=ls->linenumber;
4629switch(ls->t.token){
4630case TK_IF:{
4631ifstat(ls,line);
4632return 0;
4633}
4634case TK_WHILE:{
4635whilestat(ls,line);
4636return 0;
4637}
4638case TK_DO:{
4639luaX_next(ls);
4640block(ls);
4641check_match(ls,TK_END,TK_DO,line);
4642return 0;
4643}
4644case TK_FOR:{
4645forstat(ls,line);
4646return 0;
4647}
4648case TK_REPEAT:{
4649repeatstat(ls,line);
4650return 0;
4651}
4652case TK_FUNCTION:{
4653funcstat(ls,line);
4654return 0;
4655}
4656case TK_LOCAL:{
4657luaX_next(ls);
4658if(testnext(ls,TK_FUNCTION))
4659localfunc(ls);
4660else
4661localstat(ls);
4662return 0;
4663}
4664case TK_RETURN:{
4665retstat(ls);
4666return 1;
4667}
4668case TK_BREAK:{
4669luaX_next(ls);
4670breakstat(ls);
4671return 1;
4672}
4673default:{
4674exprstat(ls);
4675return 0;
4676}
4677}
4678}
4679static void chunk(LexState*ls){
4680int islast=0;
4681enterlevel(ls);
4682while(!islast&&!block_follow(ls->t.token)){
4683islast=statement(ls);
4684testnext(ls,';');
4685ls->fs->freereg=ls->fs->nactvar;
4686}
4687leavelevel(ls);
4688}
4689static const TValue*luaV_tonumber(const TValue*obj,TValue*n){
4690lua_Number num;
4691if(ttisnumber(obj))return obj;
4692if(ttisstring(obj)&&luaO_str2d(svalue(obj),&num)){
4693setnvalue(n,num);
4694return n;
4695}
4696else
4697return NULL;
4698}
4699static int luaV_tostring(lua_State*L,StkId obj){
4700if(!ttisnumber(obj))
4701return 0;
4702else{
4703char s[32];
4704lua_Number n=nvalue(obj);
4705lua_number2str(s,n);
4706setsvalue(L,obj,luaS_new(L,s));
4707return 1;
4708}
4709}
4710static void callTMres(lua_State*L,StkId res,const TValue*f,
4711const TValue*p1,const TValue*p2){
4712ptrdiff_t result=savestack(L,res);
4713setobj(L,L->top,f);
4714setobj(L,L->top+1,p1);
4715setobj(L,L->top+2,p2);
4716luaD_checkstack(L,3);
4717L->top+=3;
4718luaD_call(L,L->top-3,1);
4719res=restorestack(L,result);
4720L->top--;
4721setobj(L,res,L->top);
4722}
4723static void callTM(lua_State*L,const TValue*f,const TValue*p1,
4724const TValue*p2,const TValue*p3){
4725setobj(L,L->top,f);
4726setobj(L,L->top+1,p1);
4727setobj(L,L->top+2,p2);
4728setobj(L,L->top+3,p3);
4729luaD_checkstack(L,4);
4730L->top+=4;
4731luaD_call(L,L->top-4,0);
4732}
4733static void luaV_gettable(lua_State*L,const TValue*t,TValue*key,StkId val){
4734int loop;
4735for(loop=0;loop<100;loop++){
4736const TValue*tm;
4737if(ttistable(t)){
4738Table*h=hvalue(t);
4739const TValue*res=luaH_get(h,key);
4740if(!ttisnil(res)||
4741(tm=fasttm(L,h->metatable,TM_INDEX))==NULL){
4742setobj(L,val,res);
4743return;
4744}
4745}
4746else if(ttisnil(tm=luaT_gettmbyobj(L,t,TM_INDEX)))
4747luaG_typeerror(L,t,"index");
4748if(ttisfunction(tm)){
4749callTMres(L,val,tm,t,key);
4750return;
4751}
4752t=tm;
4753}
4754luaG_runerror(L,"loop in gettable");
4755}
4756static void luaV_settable(lua_State*L,const TValue*t,TValue*key,StkId val){
4757int loop;
4758TValue temp;
4759for(loop=0;loop<100;loop++){
4760const TValue*tm;
4761if(ttistable(t)){
4762Table*h=hvalue(t);
4763TValue*oldval=luaH_set(L,h,key);
4764if(!ttisnil(oldval)||
4765(tm=fasttm(L,h->metatable,TM_NEWINDEX))==NULL){
4766setobj(L,oldval,val);
4767h->flags=0;
4768luaC_barriert(L,h,val);
4769return;
4770}
4771}
4772else if(ttisnil(tm=luaT_gettmbyobj(L,t,TM_NEWINDEX)))
4773luaG_typeerror(L,t,"index");
4774if(ttisfunction(tm)){
4775callTM(L,tm,t,key,val);
4776return;
4777}
4778setobj(L,&temp,tm);
4779t=&temp;
4780}
4781luaG_runerror(L,"loop in settable");
4782}
4783static int call_binTM(lua_State*L,const TValue*p1,const TValue*p2,
4784StkId res,TMS event){
4785const TValue*tm=luaT_gettmbyobj(L,p1,event);
4786if(ttisnil(tm))
4787tm=luaT_gettmbyobj(L,p2,event);
4788if(ttisnil(tm))return 0;
4789callTMres(L,res,tm,p1,p2);
4790return 1;
4791}
4792static const TValue*get_compTM(lua_State*L,Table*mt1,Table*mt2,
4793TMS event){
4794const TValue*tm1=fasttm(L,mt1,event);
4795const TValue*tm2;
4796if(tm1==NULL)return NULL;
4797if(mt1==mt2)return tm1;
4798tm2=fasttm(L,mt2,event);
4799if(tm2==NULL)return NULL;
4800if(luaO_rawequalObj(tm1,tm2))
4801return tm1;
4802return NULL;
4803}
4804static int call_orderTM(lua_State*L,const TValue*p1,const TValue*p2,
4805TMS event){
4806const TValue*tm1=luaT_gettmbyobj(L,p1,event);
4807const TValue*tm2;
4808if(ttisnil(tm1))return-1;
4809tm2=luaT_gettmbyobj(L,p2,event);
4810if(!luaO_rawequalObj(tm1,tm2))
4811return-1;
4812callTMres(L,L->top,tm1,p1,p2);
4813return!l_isfalse(L->top);
4814}
4815static int l_strcmp(const TString*ls,const TString*rs){
4816const char*l=getstr(ls);
4817size_t ll=ls->tsv.len;
4818const char*r=getstr(rs);
4819size_t lr=rs->tsv.len;
4820for(;;){
4821int temp=strcoll(l,r);
4822if(temp!=0)return temp;
4823else{
4824size_t len=strlen(l);
4825if(len==lr)
4826return(len==ll)?0:1;
4827else if(len==ll)
4828return-1;
4829len++;
4830l+=len;ll-=len;r+=len;lr-=len;
4831}
4832}
4833}
4834static int luaV_lessthan(lua_State*L,const TValue*l,const TValue*r){
4835int res;
4836if(ttype(l)!=ttype(r))
4837return luaG_ordererror(L,l,r);
4838else if(ttisnumber(l))
4839return luai_numlt(nvalue(l),nvalue(r));
4840else if(ttisstring(l))
4841return l_strcmp(rawtsvalue(l),rawtsvalue(r))<0;
4842else if((res=call_orderTM(L,l,r,TM_LT))!=-1)
4843return res;
4844return luaG_ordererror(L,l,r);
4845}
4846static int lessequal(lua_State*L,const TValue*l,const TValue*r){
4847int res;
4848if(ttype(l)!=ttype(r))
4849return luaG_ordererror(L,l,r);
4850else if(ttisnumber(l))
4851return luai_numle(nvalue(l),nvalue(r));
4852else if(ttisstring(l))
4853return l_strcmp(rawtsvalue(l),rawtsvalue(r))<=0;
4854else if((res=call_orderTM(L,l,r,TM_LE))!=-1)
4855return res;
4856else if((res=call_orderTM(L,r,l,TM_LT))!=-1)
4857return!res;
4858return luaG_ordererror(L,l,r);
4859}
4860static int luaV_equalval(lua_State*L,const TValue*t1,const TValue*t2){
4861const TValue*tm;
4862switch(ttype(t1)){
4863case 0:return 1;
4864case 3:return luai_numeq(nvalue(t1),nvalue(t2));
4865case 1:return bvalue(t1)==bvalue(t2);
4866case 2:return pvalue(t1)==pvalue(t2);
4867case 7:{
4868if(uvalue(t1)==uvalue(t2))return 1;
4869tm=get_compTM(L,uvalue(t1)->metatable,uvalue(t2)->metatable,
4870TM_EQ);
4871break;
4872}
4873case 5:{
4874if(hvalue(t1)==hvalue(t2))return 1;
4875tm=get_compTM(L,hvalue(t1)->metatable,hvalue(t2)->metatable,TM_EQ);
4876break;
4877}
4878default:return gcvalue(t1)==gcvalue(t2);
4879}
4880if(tm==NULL)return 0;
4881callTMres(L,L->top,tm,t1,t2);
4882return!l_isfalse(L->top);
4883}
4884static void luaV_concat(lua_State*L,int total,int last){
4885do{
4886StkId top=L->base+last+1;
4887int n=2;
4888if(!(ttisstring(top-2)||ttisnumber(top-2))||!tostring(L,top-1)){
4889if(!call_binTM(L,top-2,top-1,top-2,TM_CONCAT))
4890luaG_concaterror(L,top-2,top-1);
4891}else if(tsvalue(top-1)->len==0)
4892(void)tostring(L,top-2);
4893else{
4894size_t tl=tsvalue(top-1)->len;
4895char*buffer;
4896int i;
4897for(n=1;n<total&&tostring(L,top-n-1);n++){
4898size_t l=tsvalue(top-n-1)->len;
4899if(l>=((size_t)(~(size_t)0)-2)-tl)luaG_runerror(L,"string length overflow");
4900tl+=l;
4901}
4902buffer=luaZ_openspace(L,&G(L)->buff,tl);
4903tl=0;
4904for(i=n;i>0;i--){
4905size_t l=tsvalue(top-i)->len;
4906memcpy(buffer+tl,svalue(top-i),l);
4907tl+=l;
4908}
4909setsvalue(L,top-n,luaS_newlstr(L,buffer,tl));
4910}
4911total-=n-1;
4912last-=n-1;
4913}while(total>1);
4914}
4915static void Arith(lua_State*L,StkId ra,const TValue*rb,
4916const TValue*rc,TMS op){
4917TValue tempb,tempc;
4918const TValue*b,*c;
4919if((b=luaV_tonumber(rb,&tempb))!=NULL&&
4920(c=luaV_tonumber(rc,&tempc))!=NULL){
4921lua_Number nb=nvalue(b),nc=nvalue(c);
4922switch(op){
4923case TM_ADD:setnvalue(ra,luai_numadd(nb,nc));break;
4924case TM_SUB:setnvalue(ra,luai_numsub(nb,nc));break;
4925case TM_MUL:setnvalue(ra,luai_nummul(nb,nc));break;
4926case TM_DIV:setnvalue(ra,luai_numdiv(nb,nc));break;
4927case TM_MOD:setnvalue(ra,luai_nummod(nb,nc));break;
4928case TM_POW:setnvalue(ra,luai_numpow(nb,nc));break;
4929case TM_UNM:setnvalue(ra,luai_numunm(nb));break;
4930default:break;
4931}
4932}
4933else if(!call_binTM(L,rb,rc,ra,op))
4934luaG_aritherror(L,rb,rc);
4935}
4936#define runtime_check(L,c){if(!(c))break;}
4937#define RA(i)(base+GETARG_A(i))
4938#define RB(i)check_exp(getBMode(GET_OPCODE(i))==OpArgR,base+GETARG_B(i))
4939#define RKB(i)check_exp(getBMode(GET_OPCODE(i))==OpArgK,ISK(GETARG_B(i))?k+INDEXK(GETARG_B(i)):base+GETARG_B(i))
4940#define RKC(i)check_exp(getCMode(GET_OPCODE(i))==OpArgK,ISK(GETARG_C(i))?k+INDEXK(GETARG_C(i)):base+GETARG_C(i))
4941#define KBx(i)check_exp(getBMode(GET_OPCODE(i))==OpArgK,k+GETARG_Bx(i))
4942#define dojump(L,pc,i){(pc)+=(i);}
4943#define Protect(x){L->savedpc=pc;{x;};base=L->base;}
4944#define arith_op(op,tm){TValue*rb=RKB(i);TValue*rc=RKC(i);if(ttisnumber(rb)&&ttisnumber(rc)){lua_Number nb=nvalue(rb),nc=nvalue(rc);setnvalue(ra,op(nb,nc));}else Protect(Arith(L,ra,rb,rc,tm));}
4945static void luaV_execute(lua_State*L,int nexeccalls){
4946LClosure*cl;
4947StkId base;
4948TValue*k;
4949const Instruction*pc;
4950reentry:
4951pc=L->savedpc;
4952cl=&clvalue(L->ci->func)->l;
4953base=L->base;
4954k=cl->p->k;
4955for(;;){
4956const Instruction i=*pc++;
4957StkId ra;
4958ra=RA(i);
4959switch(GET_OPCODE(i)){
4960case OP_MOVE:{
4961setobj(L,ra,RB(i));
4962continue;
4963}
4964case OP_LOADK:{
4965setobj(L,ra,KBx(i));
4966continue;
4967}
4968case OP_LOADBOOL:{
4969setbvalue(ra,GETARG_B(i));
4970if(GETARG_C(i))pc++;
4971continue;
4972}
4973case OP_LOADNIL:{
4974TValue*rb=RB(i);
4975do{
4976setnilvalue(rb--);
4977}while(rb>=ra);
4978continue;
4979}
4980case OP_GETUPVAL:{
4981int b=GETARG_B(i);
4982setobj(L,ra,cl->upvals[b]->v);
4983continue;
4984}
4985case OP_GETGLOBAL:{
4986TValue g;
4987TValue*rb=KBx(i);
4988sethvalue(L,&g,cl->env);
4989Protect(luaV_gettable(L,&g,rb,ra));
4990continue;
4991}
4992case OP_GETTABLE:{
4993Protect(luaV_gettable(L,RB(i),RKC(i),ra));
4994continue;
4995}
4996case OP_SETGLOBAL:{
4997TValue g;
4998sethvalue(L,&g,cl->env);
4999Protect(luaV_settable(L,&g,KBx(i),ra));
5000continue;
5001}
5002case OP_SETUPVAL:{
5003UpVal*uv=cl->upvals[GETARG_B(i)];
5004setobj(L,uv->v,ra);
5005luaC_barrier(L,uv,ra);
5006continue;
5007}
5008case OP_SETTABLE:{
5009Protect(luaV_settable(L,ra,RKB(i),RKC(i)));
5010continue;
5011}
5012case OP_NEWTABLE:{
5013int b=GETARG_B(i);
5014int c=GETARG_C(i);
5015sethvalue(L,ra,luaH_new(L,luaO_fb2int(b),luaO_fb2int(c)));
5016Protect(luaC_checkGC(L));
5017continue;
5018}
5019case OP_SELF:{
5020StkId rb=RB(i);
5021setobj(L,ra+1,rb);
5022Protect(luaV_gettable(L,rb,RKC(i),ra));
5023continue;
5024}
5025case OP_ADD:{
5026arith_op(luai_numadd,TM_ADD);
5027continue;
5028}
5029case OP_SUB:{
5030arith_op(luai_numsub,TM_SUB);
5031continue;
5032}
5033case OP_MUL:{
5034arith_op(luai_nummul,TM_MUL);
5035continue;
5036}
5037case OP_DIV:{
5038arith_op(luai_numdiv,TM_DIV);
5039continue;
5040}
5041case OP_MOD:{
5042arith_op(luai_nummod,TM_MOD);
5043continue;
5044}
5045case OP_POW:{
5046arith_op(luai_numpow,TM_POW);
5047continue;
5048}
5049case OP_UNM:{
5050TValue*rb=RB(i);
5051if(ttisnumber(rb)){
5052lua_Number nb=nvalue(rb);
5053setnvalue(ra,luai_numunm(nb));
5054}
5055else{
5056Protect(Arith(L,ra,rb,rb,TM_UNM));
5057}
5058continue;
5059}
5060case OP_NOT:{
5061int res=l_isfalse(RB(i));
5062setbvalue(ra,res);
5063continue;
5064}
5065case OP_LEN:{
5066const TValue*rb=RB(i);
5067switch(ttype(rb)){
5068case 5:{
5069setnvalue(ra,cast_num(luaH_getn(hvalue(rb))));
5070break;
5071}
5072case 4:{
5073setnvalue(ra,cast_num(tsvalue(rb)->len));
5074break;
5075}
5076default:{
5077Protect(
5078if(!call_binTM(L,rb,(&luaO_nilobject_),ra,TM_LEN))
5079luaG_typeerror(L,rb,"get length of");
5080)
5081}
5082}
5083continue;
5084}
5085case OP_CONCAT:{
5086int b=GETARG_B(i);
5087int c=GETARG_C(i);
5088Protect(luaV_concat(L,c-b+1,c);luaC_checkGC(L));
5089setobj(L,RA(i),base+b);
5090continue;
5091}
5092case OP_JMP:{
5093dojump(L,pc,GETARG_sBx(i));
5094continue;
5095}
5096case OP_EQ:{
5097TValue*rb=RKB(i);
5098TValue*rc=RKC(i);
5099Protect(
5100if(equalobj(L,rb,rc)==GETARG_A(i))
5101dojump(L,pc,GETARG_sBx(*pc));
5102)
5103pc++;
5104continue;
5105}
5106case OP_LT:{
5107Protect(
5108if(luaV_lessthan(L,RKB(i),RKC(i))==GETARG_A(i))
5109dojump(L,pc,GETARG_sBx(*pc));
5110)
5111pc++;
5112continue;
5113}
5114case OP_LE:{
5115Protect(
5116if(lessequal(L,RKB(i),RKC(i))==GETARG_A(i))
5117dojump(L,pc,GETARG_sBx(*pc));
5118)
5119pc++;
5120continue;
5121}
5122case OP_TEST:{
5123if(l_isfalse(ra)!=GETARG_C(i))
5124dojump(L,pc,GETARG_sBx(*pc));
5125pc++;
5126continue;
5127}
5128case OP_TESTSET:{
5129TValue*rb=RB(i);
5130if(l_isfalse(rb)!=GETARG_C(i)){
5131setobj(L,ra,rb);
5132dojump(L,pc,GETARG_sBx(*pc));
5133}
5134pc++;
5135continue;
5136}
5137case OP_CALL:{
5138int b=GETARG_B(i);
5139int nresults=GETARG_C(i)-1;
5140if(b!=0)L->top=ra+b;
5141L->savedpc=pc;
5142switch(luaD_precall(L,ra,nresults)){
5143case 0:{
5144nexeccalls++;
5145goto reentry;
5146}
5147case 1:{
5148if(nresults>=0)L->top=L->ci->top;
5149base=L->base;
5150continue;
5151}
5152default:{
5153return;
5154}
5155}
5156}
5157case OP_TAILCALL:{
5158int b=GETARG_B(i);
5159if(b!=0)L->top=ra+b;
5160L->savedpc=pc;
5161switch(luaD_precall(L,ra,(-1))){
5162case 0:{
5163CallInfo*ci=L->ci-1;
5164int aux;
5165StkId func=ci->func;
5166StkId pfunc=(ci+1)->func;
5167if(L->openupval)luaF_close(L,ci->base);
5168L->base=ci->base=ci->func+((ci+1)->base-pfunc);
5169for(aux=0;pfunc+aux<L->top;aux++)
5170setobj(L,func+aux,pfunc+aux);
5171ci->top=L->top=func+aux;
5172ci->savedpc=L->savedpc;
5173ci->tailcalls++;
5174L->ci--;
5175goto reentry;
5176}
5177case 1:{
5178base=L->base;
5179continue;
5180}
5181default:{
5182return;
5183}
5184}
5185}
5186case OP_RETURN:{
5187int b=GETARG_B(i);
5188if(b!=0)L->top=ra+b-1;
5189if(L->openupval)luaF_close(L,base);
5190L->savedpc=pc;
5191b=luaD_poscall(L,ra);
5192if(--nexeccalls==0)
5193return;
5194else{
5195if(b)L->top=L->ci->top;
5196goto reentry;
5197}
5198}
5199case OP_FORLOOP:{
5200lua_Number step=nvalue(ra+2);
5201lua_Number idx=luai_numadd(nvalue(ra),step);
5202lua_Number limit=nvalue(ra+1);
5203if(luai_numlt(0,step)?luai_numle(idx,limit)
5204:luai_numle(limit,idx)){
5205dojump(L,pc,GETARG_sBx(i));
5206setnvalue(ra,idx);
5207setnvalue(ra+3,idx);
5208}
5209continue;
5210}
5211case OP_FORPREP:{
5212const TValue*init=ra;
5213const TValue*plimit=ra+1;
5214const TValue*pstep=ra+2;
5215L->savedpc=pc;
5216if(!tonumber(init,ra))
5217luaG_runerror(L,LUA_QL("for")" initial value must be a number");
5218else if(!tonumber(plimit,ra+1))
5219luaG_runerror(L,LUA_QL("for")" limit must be a number");
5220else if(!tonumber(pstep,ra+2))
5221luaG_runerror(L,LUA_QL("for")" step must be a number");
5222setnvalue(ra,luai_numsub(nvalue(ra),nvalue(pstep)));
5223dojump(L,pc,GETARG_sBx(i));
5224continue;
5225}
5226case OP_TFORLOOP:{
5227StkId cb=ra+3;
5228setobj(L,cb+2,ra+2);
5229setobj(L,cb+1,ra+1);
5230setobj(L,cb,ra);
5231L->top=cb+3;
5232Protect(luaD_call(L,cb,GETARG_C(i)));
5233L->top=L->ci->top;
5234cb=RA(i)+3;
5235if(!ttisnil(cb)){
5236setobj(L,cb-1,cb);
5237dojump(L,pc,GETARG_sBx(*pc));
5238}
5239pc++;
5240continue;
5241}
5242case OP_SETLIST:{
5243int n=GETARG_B(i);
5244int c=GETARG_C(i);
5245int last;
5246Table*h;
5247if(n==0){
5248n=cast_int(L->top-ra)-1;
5249L->top=L->ci->top;
5250}
5251if(c==0)c=cast_int(*pc++);
5252runtime_check(L,ttistable(ra));
5253h=hvalue(ra);
5254last=((c-1)*50)+n;
5255if(last>h->sizearray)
5256luaH_resizearray(L,h,last);
5257for(;n>0;n--){
5258TValue*val=ra+n;
5259setobj(L,luaH_setnum(L,h,last--),val);
5260luaC_barriert(L,h,val);
5261}
5262continue;
5263}
5264case OP_CLOSE:{
5265luaF_close(L,ra);
5266continue;
5267}
5268case OP_CLOSURE:{
5269Proto*p;
5270Closure*ncl;
5271int nup,j;
5272p=cl->p->p[GETARG_Bx(i)];
5273nup=p->nups;
5274ncl=luaF_newLclosure(L,nup,cl->env);
5275ncl->l.p=p;
5276for(j=0;j<nup;j++,pc++){
5277if(GET_OPCODE(*pc)==OP_GETUPVAL)
5278ncl->l.upvals[j]=cl->upvals[GETARG_B(*pc)];
5279else{
5280ncl->l.upvals[j]=luaF_findupval(L,base+GETARG_B(*pc));
5281}
5282}
5283setclvalue(L,ra,ncl);
5284Protect(luaC_checkGC(L));
5285continue;
5286}
5287case OP_VARARG:{
5288int b=GETARG_B(i)-1;
5289int j;
5290CallInfo*ci=L->ci;
5291int n=cast_int(ci->base-ci->func)-cl->p->numparams-1;
5292if(b==(-1)){
5293Protect(luaD_checkstack(L,n));
5294ra=RA(i);
5295b=n;
5296L->top=ra+n;
5297}
5298for(j=0;j<b;j++){
5299if(j<n){
5300setobj(L,ra+j,ci->base-n+j);
5301}
5302else{
5303setnilvalue(ra+j);
5304}
5305}
5306continue;
5307}
5308}
5309}
5310}
5311#define api_checknelems(L,n)luai_apicheck(L,(n)<=(L->top-L->base))
5312#define api_checkvalidindex(L,i)luai_apicheck(L,(i)!=(&luaO_nilobject_))
5313#define api_incr_top(L){luai_apicheck(L,L->top<L->ci->top);L->top++;}
5314static TValue*index2adr(lua_State*L,int idx){
5315if(idx>0){
5316TValue*o=L->base+(idx-1);
5317luai_apicheck(L,idx<=L->ci->top-L->base);
5318if(o>=L->top)return cast(TValue*,(&luaO_nilobject_));
5319else return o;
5320}
5321else if(idx>(-10000)){
5322luai_apicheck(L,idx!=0&&-idx<=L->top-L->base);
5323return L->top+idx;
5324}
5325else switch(idx){
5326case(-10000):return registry(L);
5327case(-10001):{
5328Closure*func=curr_func(L);
5329sethvalue(L,&L->env,func->c.env);
5330return&L->env;
5331}
5332case(-10002):return gt(L);
5333default:{
5334Closure*func=curr_func(L);
5335idx=(-10002)-idx;
5336return(idx<=func->c.nupvalues)
5337?&func->c.upvalue[idx-1]
5338:cast(TValue*,(&luaO_nilobject_));
5339}
5340}
5341}
5342static Table*getcurrenv(lua_State*L){
5343if(L->ci==L->base_ci)
5344return hvalue(gt(L));
5345else{
5346Closure*func=curr_func(L);
5347return func->c.env;
5348}
5349}
5350static int lua_checkstack(lua_State*L,int size){
5351int res=1;
5352if(size>8000||(L->top-L->base+size)>8000)
5353res=0;
5354else if(size>0){
5355luaD_checkstack(L,size);
5356if(L->ci->top<L->top+size)
5357L->ci->top=L->top+size;
5358}
5359return res;
5360}
5361static lua_CFunction lua_atpanic(lua_State*L,lua_CFunction panicf){
5362lua_CFunction old;
5363old=G(L)->panic;
5364G(L)->panic=panicf;
5365return old;
5366}
5367static int lua_gettop(lua_State*L){
5368return cast_int(L->top-L->base);
5369}
5370static void lua_settop(lua_State*L,int idx){
5371if(idx>=0){
5372luai_apicheck(L,idx<=L->stack_last-L->base);
5373while(L->top<L->base+idx)
5374setnilvalue(L->top++);
5375L->top=L->base+idx;
5376}
5377else{
5378luai_apicheck(L,-(idx+1)<=(L->top-L->base));
5379L->top+=idx+1;
5380}
5381}
5382static void lua_remove(lua_State*L,int idx){
5383StkId p;
5384p=index2adr(L,idx);
5385api_checkvalidindex(L,p);
5386while(++p<L->top)setobj(L,p-1,p);
5387L->top--;
5388}
5389static void lua_insert(lua_State*L,int idx){
5390StkId p;
5391StkId q;
5392p=index2adr(L,idx);
5393api_checkvalidindex(L,p);
5394for(q=L->top;q>p;q--)setobj(L,q,q-1);
5395setobj(L,p,L->top);
5396}
5397static void lua_replace(lua_State*L,int idx){
5398StkId o;
5399if(idx==(-10001)&&L->ci==L->base_ci)
5400luaG_runerror(L,"no calling environment");
5401api_checknelems(L,1);
5402o=index2adr(L,idx);
5403api_checkvalidindex(L,o);
5404if(idx==(-10001)){
5405Closure*func=curr_func(L);
5406luai_apicheck(L,ttistable(L->top-1));
5407func->c.env=hvalue(L->top-1);
5408luaC_barrier(L,func,L->top-1);
5409}
5410else{
5411setobj(L,o,L->top-1);
5412if(idx<(-10002))
5413luaC_barrier(L,curr_func(L),L->top-1);
5414}
5415L->top--;
5416}
5417static void lua_pushvalue(lua_State*L,int idx){
5418setobj(L,L->top,index2adr(L,idx));
5419api_incr_top(L);
5420}
5421static int lua_type(lua_State*L,int idx){
5422StkId o=index2adr(L,idx);
5423return(o==(&luaO_nilobject_))?(-1):ttype(o);
5424}
5425static const char*lua_typename(lua_State*L,int t){
5426UNUSED(L);
5427return(t==(-1))?"no value":luaT_typenames[t];
5428}
5429static int lua_iscfunction(lua_State*L,int idx){
5430StkId o=index2adr(L,idx);
5431return iscfunction(o);
5432}
5433static int lua_isnumber(lua_State*L,int idx){
5434TValue n;
5435const TValue*o=index2adr(L,idx);
5436return tonumber(o,&n);
5437}
5438static int lua_isstring(lua_State*L,int idx){
5439int t=lua_type(L,idx);
5440return(t==4||t==3);
5441}
5442static int lua_rawequal(lua_State*L,int index1,int index2){
5443StkId o1=index2adr(L,index1);
5444StkId o2=index2adr(L,index2);
5445return(o1==(&luaO_nilobject_)||o2==(&luaO_nilobject_))?0
5446:luaO_rawequalObj(o1,o2);
5447}
5448static int lua_lessthan(lua_State*L,int index1,int index2){
5449StkId o1,o2;
5450int i;
5451o1=index2adr(L,index1);
5452o2=index2adr(L,index2);
5453i=(o1==(&luaO_nilobject_)||o2==(&luaO_nilobject_))?0
5454:luaV_lessthan(L,o1,o2);
5455return i;
5456}
5457static lua_Number lua_tonumber(lua_State*L,int idx){
5458TValue n;
5459const TValue*o=index2adr(L,idx);
5460if(tonumber(o,&n))
5461return nvalue(o);
5462else
5463return 0;
5464}
5465static lua_Integer lua_tointeger(lua_State*L,int idx){
5466TValue n;
5467const TValue*o=index2adr(L,idx);
5468if(tonumber(o,&n)){
5469lua_Integer res;
5470lua_Number num=nvalue(o);
5471lua_number2integer(res,num);
5472return res;
5473}
5474else
5475return 0;
5476}
5477static int lua_toboolean(lua_State*L,int idx){
5478const TValue*o=index2adr(L,idx);
5479return!l_isfalse(o);
5480}
5481static const char*lua_tolstring(lua_State*L,int idx,size_t*len){
5482StkId o=index2adr(L,idx);
5483if(!ttisstring(o)){
5484if(!luaV_tostring(L,o)){
5485if(len!=NULL)*len=0;
5486return NULL;
5487}
5488luaC_checkGC(L);
5489o=index2adr(L,idx);
5490}
5491if(len!=NULL)*len=tsvalue(o)->len;
5492return svalue(o);
5493}
5494static size_t lua_objlen(lua_State*L,int idx){
5495StkId o=index2adr(L,idx);
5496switch(ttype(o)){
5497case 4:return tsvalue(o)->len;
5498case 7:return uvalue(o)->len;
5499case 5:return luaH_getn(hvalue(o));
5500case 3:{
5501size_t l;
5502l=(luaV_tostring(L,o)?tsvalue(o)->len:0);
5503return l;
5504}
5505default:return 0;
5506}
5507}
5508static lua_CFunction lua_tocfunction(lua_State*L,int idx){
5509StkId o=index2adr(L,idx);
5510return(!iscfunction(o))?NULL:clvalue(o)->c.f;
5511}
5512static void*lua_touserdata(lua_State*L,int idx){
5513StkId o=index2adr(L,idx);
5514switch(ttype(o)){
5515case 7:return(rawuvalue(o)+1);
5516case 2:return pvalue(o);
5517default:return NULL;
5518}
5519}
5520static void lua_pushnil(lua_State*L){
5521setnilvalue(L->top);
5522api_incr_top(L);
5523}
5524static void lua_pushnumber(lua_State*L,lua_Number n){
5525setnvalue(L->top,n);
5526api_incr_top(L);
5527}
5528static void lua_pushinteger(lua_State*L,lua_Integer n){
5529setnvalue(L->top,cast_num(n));
5530api_incr_top(L);
5531}
5532static void lua_pushlstring(lua_State*L,const char*s,size_t len){
5533luaC_checkGC(L);
5534setsvalue(L,L->top,luaS_newlstr(L,s,len));
5535api_incr_top(L);
5536}
5537static void lua_pushstring(lua_State*L,const char*s){
5538if(s==NULL)
5539lua_pushnil(L);
5540else
5541lua_pushlstring(L,s,strlen(s));
5542}
5543static const char*lua_pushvfstring(lua_State*L,const char*fmt,
5544va_list argp){
5545const char*ret;
5546luaC_checkGC(L);
5547ret=luaO_pushvfstring(L,fmt,argp);
5548return ret;
5549}
5550static const char*lua_pushfstring(lua_State*L,const char*fmt,...){
5551const char*ret;
5552va_list argp;
5553luaC_checkGC(L);
5554va_start(argp,fmt);
5555ret=luaO_pushvfstring(L,fmt,argp);
5556va_end(argp);
5557return ret;
5558}
5559static void lua_pushcclosure(lua_State*L,lua_CFunction fn,int n){
5560Closure*cl;
5561luaC_checkGC(L);
5562api_checknelems(L,n);
5563cl=luaF_newCclosure(L,n,getcurrenv(L));
5564cl->c.f=fn;
5565L->top-=n;
5566while(n--)
5567setobj(L,&cl->c.upvalue[n],L->top+n);
5568setclvalue(L,L->top,cl);
5569api_incr_top(L);
5570}
5571static void lua_pushboolean(lua_State*L,int b){
5572setbvalue(L->top,(b!=0));
5573api_incr_top(L);
5574}
5575static int lua_pushthread(lua_State*L){
5576setthvalue(L,L->top,L);
5577api_incr_top(L);
5578return(G(L)->mainthread==L);
5579}
5580static void lua_gettable(lua_State*L,int idx){
5581StkId t;
5582t=index2adr(L,idx);
5583api_checkvalidindex(L,t);
5584luaV_gettable(L,t,L->top-1,L->top-1);
5585}
5586static void lua_getfield(lua_State*L,int idx,const char*k){
5587StkId t;
5588TValue key;
5589t=index2adr(L,idx);
5590api_checkvalidindex(L,t);
5591setsvalue(L,&key,luaS_new(L,k));
5592luaV_gettable(L,t,&key,L->top);
5593api_incr_top(L);
5594}
5595static void lua_rawget(lua_State*L,int idx){
5596StkId t;
5597t=index2adr(L,idx);
5598luai_apicheck(L,ttistable(t));
5599setobj(L,L->top-1,luaH_get(hvalue(t),L->top-1));
5600}
5601static void lua_rawgeti(lua_State*L,int idx,int n){
5602StkId o;
5603o=index2adr(L,idx);
5604luai_apicheck(L,ttistable(o));
5605setobj(L,L->top,luaH_getnum(hvalue(o),n));
5606api_incr_top(L);
5607}
5608static void lua_createtable(lua_State*L,int narray,int nrec){
5609luaC_checkGC(L);
5610sethvalue(L,L->top,luaH_new(L,narray,nrec));
5611api_incr_top(L);
5612}
5613static int lua_getmetatable(lua_State*L,int objindex){
5614const TValue*obj;
5615Table*mt=NULL;
5616int res;
5617obj=index2adr(L,objindex);
5618switch(ttype(obj)){
5619case 5:
5620mt=hvalue(obj)->metatable;
5621break;
5622case 7:
5623mt=uvalue(obj)->metatable;
5624break;
5625default:
5626mt=G(L)->mt[ttype(obj)];
5627break;
5628}
5629if(mt==NULL)
5630res=0;
5631else{
5632sethvalue(L,L->top,mt);
5633api_incr_top(L);
5634res=1;
5635}
5636return res;
5637}
5638static void lua_getfenv(lua_State*L,int idx){
5639StkId o;
5640o=index2adr(L,idx);
5641api_checkvalidindex(L,o);
5642switch(ttype(o)){
5643case 6:
5644sethvalue(L,L->top,clvalue(o)->c.env);
5645break;
5646case 7:
5647sethvalue(L,L->top,uvalue(o)->env);
5648break;
5649case 8:
5650setobj(L,L->top,gt(thvalue(o)));
5651break;
5652default:
5653setnilvalue(L->top);
5654break;
5655}
5656api_incr_top(L);
5657}
5658static void lua_settable(lua_State*L,int idx){
5659StkId t;
5660api_checknelems(L,2);
5661t=index2adr(L,idx);
5662api_checkvalidindex(L,t);
5663luaV_settable(L,t,L->top-2,L->top-1);
5664L->top-=2;
5665}
5666static void lua_setfield(lua_State*L,int idx,const char*k){
5667StkId t;
5668TValue key;
5669api_checknelems(L,1);
5670t=index2adr(L,idx);
5671api_checkvalidindex(L,t);
5672setsvalue(L,&key,luaS_new(L,k));
5673luaV_settable(L,t,&key,L->top-1);
5674L->top--;
5675}
5676static void lua_rawset(lua_State*L,int idx){
5677StkId t;
5678api_checknelems(L,2);
5679t=index2adr(L,idx);
5680luai_apicheck(L,ttistable(t));
5681setobj(L,luaH_set(L,hvalue(t),L->top-2),L->top-1);
5682luaC_barriert(L,hvalue(t),L->top-1);
5683L->top-=2;
5684}
5685static void lua_rawseti(lua_State*L,int idx,int n){
5686StkId o;
5687api_checknelems(L,1);
5688o=index2adr(L,idx);
5689luai_apicheck(L,ttistable(o));
5690setobj(L,luaH_setnum(L,hvalue(o),n),L->top-1);
5691luaC_barriert(L,hvalue(o),L->top-1);
5692L->top--;
5693}
5694static int lua_setmetatable(lua_State*L,int objindex){
5695TValue*obj;
5696Table*mt;
5697api_checknelems(L,1);
5698obj=index2adr(L,objindex);
5699api_checkvalidindex(L,obj);
5700if(ttisnil(L->top-1))
5701mt=NULL;
5702else{
5703luai_apicheck(L,ttistable(L->top-1));
5704mt=hvalue(L->top-1);
5705}
5706switch(ttype(obj)){
5707case 5:{
5708hvalue(obj)->metatable=mt;
5709if(mt)
5710luaC_objbarriert(L,hvalue(obj),mt);
5711break;
5712}
5713case 7:{
5714uvalue(obj)->metatable=mt;
5715if(mt)
5716luaC_objbarrier(L,rawuvalue(obj),mt);
5717break;
5718}
5719default:{
5720G(L)->mt[ttype(obj)]=mt;
5721break;
5722}
5723}
5724L->top--;
5725return 1;
5726}
5727static int lua_setfenv(lua_State*L,int idx){
5728StkId o;
5729int res=1;
5730api_checknelems(L,1);
5731o=index2adr(L,idx);
5732api_checkvalidindex(L,o);
5733luai_apicheck(L,ttistable(L->top-1));
5734switch(ttype(o)){
5735case 6:
5736clvalue(o)->c.env=hvalue(L->top-1);
5737break;
5738case 7:
5739uvalue(o)->env=hvalue(L->top-1);
5740break;
5741case 8:
5742sethvalue(L,gt(thvalue(o)),hvalue(L->top-1));
5743break;
5744default:
5745res=0;
5746break;
5747}
5748if(res)luaC_objbarrier(L,gcvalue(o),hvalue(L->top-1));
5749L->top--;
5750return res;
5751}
5752#define adjustresults(L,nres){if(nres==(-1)&&L->top>=L->ci->top)L->ci->top=L->top;}
5753#define checkresults(L,na,nr)luai_apicheck(L,(nr)==(-1)||(L->ci->top-L->top>=(nr)-(na)))
5754static void lua_call(lua_State*L,int nargs,int nresults){
5755StkId func;
5756api_checknelems(L,nargs+1);
5757checkresults(L,nargs,nresults);
5758func=L->top-(nargs+1);
5759luaD_call(L,func,nresults);
5760adjustresults(L,nresults);
5761}
5762struct CallS{
5763StkId func;
5764int nresults;
5765};
5766static void f_call(lua_State*L,void*ud){
5767struct CallS*c=cast(struct CallS*,ud);
5768luaD_call(L,c->func,c->nresults);
5769}
5770static int lua_pcall(lua_State*L,int nargs,int nresults,int errfunc){
5771struct CallS c;
5772int status;
5773ptrdiff_t func;
5774api_checknelems(L,nargs+1);
5775checkresults(L,nargs,nresults);
5776if(errfunc==0)
5777func=0;
5778else{
5779StkId o=index2adr(L,errfunc);
5780api_checkvalidindex(L,o);
5781func=savestack(L,o);
5782}
5783c.func=L->top-(nargs+1);
5784c.nresults=nresults;
5785status=luaD_pcall(L,f_call,&c,savestack(L,c.func),func);
5786adjustresults(L,nresults);
5787return status;
5788}
5789static int lua_load(lua_State*L,lua_Reader reader,void*data,
5790const char*chunkname){
5791ZIO z;
5792int status;
5793if(!chunkname)chunkname="?";
5794luaZ_init(L,&z,reader,data);
5795status=luaD_protectedparser(L,&z,chunkname);
5796return status;
5797}
5798static int lua_error(lua_State*L){
5799api_checknelems(L,1);
5800luaG_errormsg(L);
5801return 0;
5802}
5803static int lua_next(lua_State*L,int idx){
5804StkId t;
5805int more;
5806t=index2adr(L,idx);
5807luai_apicheck(L,ttistable(t));
5808more=luaH_next(L,hvalue(t),L->top-1);
5809if(more){
5810api_incr_top(L);
5811}
5812else
5813L->top-=1;
5814return more;
5815}
5816static void lua_concat(lua_State*L,int n){
5817api_checknelems(L,n);
5818if(n>=2){
5819luaC_checkGC(L);
5820luaV_concat(L,n,cast_int(L->top-L->base)-1);
5821L->top-=(n-1);
5822}
5823else if(n==0){
5824setsvalue(L,L->top,luaS_newlstr(L,"",0));
5825api_incr_top(L);
5826}
5827}
5828static void*lua_newuserdata(lua_State*L,size_t size){
5829Udata*u;
5830luaC_checkGC(L);
5831u=luaS_newudata(L,size,getcurrenv(L));
5832setuvalue(L,L->top,u);
5833api_incr_top(L);
5834return u+1;
5835}
5836#define luaL_getn(L,i)((int)lua_objlen(L,i))
5837#define luaL_setn(L,i,j)((void)0)
5838typedef struct luaL_Reg{
5839const char*name;
5840lua_CFunction func;
5841}luaL_Reg;
5842static void luaI_openlib(lua_State*L,const char*libname,
5843const luaL_Reg*l,int nup);
5844static int luaL_argerror(lua_State*L,int numarg,const char*extramsg);
5845static const char* luaL_checklstring(lua_State*L,int numArg,
5846size_t*l);
5847static const char* luaL_optlstring(lua_State*L,int numArg,
5848const char*def,size_t*l);
5849static lua_Integer luaL_checkinteger(lua_State*L,int numArg);
5850static lua_Integer luaL_optinteger(lua_State*L,int nArg,
5851lua_Integer def);
5852static int luaL_error(lua_State*L,const char*fmt,...);
5853static const char* luaL_findtable(lua_State*L,int idx,
5854const char*fname,int szhint);
5855#define luaL_argcheck(L,cond,numarg,extramsg)((void)((cond)||luaL_argerror(L,(numarg),(extramsg))))
5856#define luaL_checkstring(L,n)(luaL_checklstring(L,(n),NULL))
5857#define luaL_optstring(L,n,d)(luaL_optlstring(L,(n),(d),NULL))
5858#define luaL_checkint(L,n)((int)luaL_checkinteger(L,(n)))
5859#define luaL_optint(L,n,d)((int)luaL_optinteger(L,(n),(d)))
5860#define luaL_typename(L,i)lua_typename(L,lua_type(L,(i)))
5861#define luaL_getmetatable(L,n)(lua_getfield(L,(-10000),(n)))
5862#define luaL_opt(L,f,n,d)(lua_isnoneornil(L,(n))?(d):f(L,(n)))
5863typedef struct luaL_Buffer{
5864char*p;
5865int lvl;
5866lua_State*L;
5867char buffer[BUFSIZ];
5868}luaL_Buffer;
5869#define luaL_addchar(B,c)((void)((B)->p<((B)->buffer+BUFSIZ)||luaL_prepbuffer(B)),(*(B)->p++=(char)(c)))
5870#define luaL_addsize(B,n)((B)->p+=(n))
5871static char* luaL_prepbuffer(luaL_Buffer*B);
5872static int luaL_argerror(lua_State*L,int narg,const char*extramsg){
5873lua_Debug ar;
5874if(!lua_getstack(L,0,&ar))
5875return luaL_error(L,"bad argument #%d (%s)",narg,extramsg);
5876lua_getinfo(L,"n",&ar);
5877if(strcmp(ar.namewhat,"method")==0){
5878narg--;
5879if(narg==0)
5880return luaL_error(L,"calling "LUA_QL("%s")" on bad self (%s)",
5881ar.name,extramsg);
5882}
5883if(ar.name==NULL)
5884ar.name="?";
5885return luaL_error(L,"bad argument #%d to "LUA_QL("%s")" (%s)",
5886narg,ar.name,extramsg);
5887}
5888static int luaL_typerror(lua_State*L,int narg,const char*tname){
5889const char*msg=lua_pushfstring(L,"%s expected, got %s",
5890tname,luaL_typename(L,narg));
5891return luaL_argerror(L,narg,msg);
5892}
5893static void tag_error(lua_State*L,int narg,int tag){
5894luaL_typerror(L,narg,lua_typename(L,tag));
5895}
5896static void luaL_where(lua_State*L,int level){
5897lua_Debug ar;
5898if(lua_getstack(L,level,&ar)){
5899lua_getinfo(L,"Sl",&ar);
5900if(ar.currentline>0){
5901lua_pushfstring(L,"%s:%d: ",ar.short_src,ar.currentline);
5902return;
5903}
5904}
5905lua_pushliteral(L,"");
5906}
5907static int luaL_error(lua_State*L,const char*fmt,...){
5908va_list argp;
5909va_start(argp,fmt);
5910luaL_where(L,1);
5911lua_pushvfstring(L,fmt,argp);
5912va_end(argp);
5913lua_concat(L,2);
5914return lua_error(L);
5915}
5916static int luaL_newmetatable(lua_State*L,const char*tname){
5917lua_getfield(L,(-10000),tname);
5918if(!lua_isnil(L,-1))
5919return 0;
5920lua_pop(L,1);
5921lua_newtable(L);
5922lua_pushvalue(L,-1);
5923lua_setfield(L,(-10000),tname);
5924return 1;
5925}
5926static void*luaL_checkudata(lua_State*L,int ud,const char*tname){
5927void*p=lua_touserdata(L,ud);
5928if(p!=NULL){
5929if(lua_getmetatable(L,ud)){
5930lua_getfield(L,(-10000),tname);
5931if(lua_rawequal(L,-1,-2)){
5932lua_pop(L,2);
5933return p;
5934}
5935}
5936}
5937luaL_typerror(L,ud,tname);
5938return NULL;
5939}
5940static void luaL_checkstack(lua_State*L,int space,const char*mes){
5941if(!lua_checkstack(L,space))
5942luaL_error(L,"stack overflow (%s)",mes);
5943}
5944static void luaL_checktype(lua_State*L,int narg,int t){
5945if(lua_type(L,narg)!=t)
5946tag_error(L,narg,t);
5947}
5948static void luaL_checkany(lua_State*L,int narg){
5949if(lua_type(L,narg)==(-1))
5950luaL_argerror(L,narg,"value expected");
5951}
5952static const char*luaL_checklstring(lua_State*L,int narg,size_t*len){
5953const char*s=lua_tolstring(L,narg,len);
5954if(!s)tag_error(L,narg,4);
5955return s;
5956}
5957static const char*luaL_optlstring(lua_State*L,int narg,
5958const char*def,size_t*len){
5959if(lua_isnoneornil(L,narg)){
5960if(len)
5961*len=(def?strlen(def):0);
5962return def;
5963}
5964else return luaL_checklstring(L,narg,len);
5965}
5966static lua_Number luaL_checknumber(lua_State*L,int narg){
5967lua_Number d=lua_tonumber(L,narg);
5968if(d==0&&!lua_isnumber(L,narg))
5969tag_error(L,narg,3);
5970return d;
5971}
5972static lua_Integer luaL_checkinteger(lua_State*L,int narg){
5973lua_Integer d=lua_tointeger(L,narg);
5974if(d==0&&!lua_isnumber(L,narg))
5975tag_error(L,narg,3);
5976return d;
5977}
5978static lua_Integer luaL_optinteger(lua_State*L,int narg,
5979lua_Integer def){
5980return luaL_opt(L,luaL_checkinteger,narg,def);
5981}
5982static int luaL_getmetafield(lua_State*L,int obj,const char*event){
5983if(!lua_getmetatable(L,obj))
5984return 0;
5985lua_pushstring(L,event);
5986lua_rawget(L,-2);
5987if(lua_isnil(L,-1)){
5988lua_pop(L,2);
5989return 0;
5990}
5991else{
5992lua_remove(L,-2);
5993return 1;
5994}
5995}
5996static void luaL_register(lua_State*L,const char*libname,
5997const luaL_Reg*l){
5998luaI_openlib(L,libname,l,0);
5999}
6000static int libsize(const luaL_Reg*l){
6001int size=0;
6002for(;l->name;l++)size++;
6003return size;
6004}
6005static void luaI_openlib(lua_State*L,const char*libname,
6006const luaL_Reg*l,int nup){
6007if(libname){
6008int size=libsize(l);
6009luaL_findtable(L,(-10000),"_LOADED",1);
6010lua_getfield(L,-1,libname);
6011if(!lua_istable(L,-1)){
6012lua_pop(L,1);
6013if(luaL_findtable(L,(-10002),libname,size)!=NULL)
6014luaL_error(L,"name conflict for module "LUA_QL("%s"),libname);
6015lua_pushvalue(L,-1);
6016lua_setfield(L,-3,libname);
6017}
6018lua_remove(L,-2);
6019lua_insert(L,-(nup+1));
6020}
6021for(;l->name;l++){
6022int i;
6023for(i=0;i<nup;i++)
6024lua_pushvalue(L,-nup);
6025lua_pushcclosure(L,l->func,nup);
6026lua_setfield(L,-(nup+2),l->name);
6027}
6028lua_pop(L,nup);
6029}
6030static const char*luaL_findtable(lua_State*L,int idx,
6031const char*fname,int szhint){
6032const char*e;
6033lua_pushvalue(L,idx);
6034do{
6035e=strchr(fname,'.');
6036if(e==NULL)e=fname+strlen(fname);
6037lua_pushlstring(L,fname,e-fname);
6038lua_rawget(L,-2);
6039if(lua_isnil(L,-1)){
6040lua_pop(L,1);
6041lua_createtable(L,0,(*e=='.'?1:szhint));
6042lua_pushlstring(L,fname,e-fname);
6043lua_pushvalue(L,-2);
6044lua_settable(L,-4);
6045}
6046else if(!lua_istable(L,-1)){
6047lua_pop(L,2);
6048return fname;
6049}
6050lua_remove(L,-2);
6051fname=e+1;
6052}while(*e=='.');
6053return NULL;
6054}
6055#define bufflen(B)((B)->p-(B)->buffer)
6056#define bufffree(B)((size_t)(BUFSIZ-bufflen(B)))
6057static int emptybuffer(luaL_Buffer*B){
6058size_t l=bufflen(B);
6059if(l==0)return 0;
6060else{
6061lua_pushlstring(B->L,B->buffer,l);
6062B->p=B->buffer;
6063B->lvl++;
6064return 1;
6065}
6066}
6067static void adjuststack(luaL_Buffer*B){
6068if(B->lvl>1){
6069lua_State*L=B->L;
6070int toget=1;
6071size_t toplen=lua_strlen(L,-1);
6072do{
6073size_t l=lua_strlen(L,-(toget+1));
6074if(B->lvl-toget+1>=(20/2)||toplen>l){
6075toplen+=l;
6076toget++;
6077}
6078else break;
6079}while(toget<B->lvl);
6080lua_concat(L,toget);
6081B->lvl=B->lvl-toget+1;
6082}
6083}
6084static char*luaL_prepbuffer(luaL_Buffer*B){
6085if(emptybuffer(B))
6086adjuststack(B);
6087return B->buffer;
6088}
6089static void luaL_addlstring(luaL_Buffer*B,const char*s,size_t l){
6090while(l--)
6091luaL_addchar(B,*s++);
6092}
6093static void luaL_pushresult(luaL_Buffer*B){
6094emptybuffer(B);
6095lua_concat(B->L,B->lvl);
6096B->lvl=1;
6097}
6098static void luaL_addvalue(luaL_Buffer*B){
6099lua_State*L=B->L;
6100size_t vl;
6101const char*s=lua_tolstring(L,-1,&vl);
6102if(vl<=bufffree(B)){
6103memcpy(B->p,s,vl);
6104B->p+=vl;
6105lua_pop(L,1);
6106}
6107else{
6108if(emptybuffer(B))
6109lua_insert(L,-2);
6110B->lvl++;
6111adjuststack(B);
6112}
6113}
6114static void luaL_buffinit(lua_State*L,luaL_Buffer*B){
6115B->L=L;
6116B->p=B->buffer;
6117B->lvl=0;
6118}
6119typedef struct LoadF{
6120int extraline;
6121FILE*f;
6122char buff[BUFSIZ];
6123}LoadF;
6124static const char*getF(lua_State*L,void*ud,size_t*size){
6125LoadF*lf=(LoadF*)ud;
6126(void)L;
6127if(lf->extraline){
6128lf->extraline=0;
6129*size=1;
6130return"\n";
6131}
6132if(feof(lf->f))return NULL;
6133*size=fread(lf->buff,1,sizeof(lf->buff),lf->f);
6134return(*size>0)?lf->buff:NULL;
6135}
6136static int errfile(lua_State*L,const char*what,int fnameindex){
6137const char*serr=strerror(errno);
6138const char*filename=lua_tostring(L,fnameindex)+1;
6139lua_pushfstring(L,"cannot %s %s: %s",what,filename,serr);
6140lua_remove(L,fnameindex);
6141return(5+1);
6142}
6143static int luaL_loadfile(lua_State*L,const char*filename){
6144LoadF lf;
6145int status,readstatus;
6146int c;
6147int fnameindex=lua_gettop(L)+1;
6148lf.extraline=0;
6149if(filename==NULL){
6150lua_pushliteral(L,"=stdin");
6151lf.f=stdin;
6152}
6153else{
6154lua_pushfstring(L,"@%s",filename);
6155lf.f=fopen(filename,"r");
6156if(lf.f==NULL)return errfile(L,"open",fnameindex);
6157}
6158c=getc(lf.f);
6159if(c=='#'){
6160lf.extraline=1;
6161while((c=getc(lf.f))!=EOF&&c!='\n');
6162if(c=='\n')c=getc(lf.f);
6163}
6164if(c=="\033Lua"[0]&&filename){
6165lf.f=freopen(filename,"rb",lf.f);
6166if(lf.f==NULL)return errfile(L,"reopen",fnameindex);
6167while((c=getc(lf.f))!=EOF&&c!="\033Lua"[0]);
6168lf.extraline=0;
6169}
6170ungetc(c,lf.f);
6171status=lua_load(L,getF,&lf,lua_tostring(L,-1));
6172readstatus=ferror(lf.f);
6173if(filename)fclose(lf.f);
6174if(readstatus){
6175lua_settop(L,fnameindex);
6176return errfile(L,"read",fnameindex);
6177}
6178lua_remove(L,fnameindex);
6179return status;
6180}
6181typedef struct LoadS{
6182const char*s;
6183size_t size;
6184}LoadS;
6185static const char*getS(lua_State*L,void*ud,size_t*size){
6186LoadS*ls=(LoadS*)ud;
6187(void)L;
6188if(ls->size==0)return NULL;
6189*size=ls->size;
6190ls->size=0;
6191return ls->s;
6192}
6193static int luaL_loadbuffer(lua_State*L,const char*buff,size_t size,
6194const char*name){
6195LoadS ls;
6196ls.s=buff;
6197ls.size=size;
6198return lua_load(L,getS,&ls,name);
6199}
6200static void*l_alloc(void*ud,void*ptr,size_t osize,size_t nsize){
6201(void)ud;
6202(void)osize;
6203if(nsize==0){
6204free(ptr);
6205return NULL;
6206}
6207else
6208return realloc(ptr,nsize);
6209}
6210static int panic(lua_State*L){
6211(void)L;
6212fprintf(stderr,"PANIC: unprotected error in call to Lua API (%s)\n",
6213lua_tostring(L,-1));
6214return 0;
6215}
6216static lua_State*luaL_newstate(void){
6217lua_State*L=lua_newstate(l_alloc,NULL);
6218if(L)lua_atpanic(L,&panic);
6219return L;
6220}
6221static int luaB_tonumber(lua_State*L){
6222int base=luaL_optint(L,2,10);
6223if(base==10){
6224luaL_checkany(L,1);
6225if(lua_isnumber(L,1)){
6226lua_pushnumber(L,lua_tonumber(L,1));
6227return 1;
6228}
6229}
6230else{
6231const char*s1=luaL_checkstring(L,1);
6232char*s2;
6233unsigned long n;
6234luaL_argcheck(L,2<=base&&base<=36,2,"base out of range");
6235n=strtoul(s1,&s2,base);
6236if(s1!=s2){
6237while(isspace((unsigned char)(*s2)))s2++;
6238if(*s2=='\0'){
6239lua_pushnumber(L,(lua_Number)n);
6240return 1;
6241}
6242}
6243}
6244lua_pushnil(L);
6245return 1;
6246}
6247static int luaB_error(lua_State*L){
6248int level=luaL_optint(L,2,1);
6249lua_settop(L,1);
6250if(lua_isstring(L,1)&&level>0){
6251luaL_where(L,level);
6252lua_pushvalue(L,1);
6253lua_concat(L,2);
6254}
6255return lua_error(L);
6256}
6257static int luaB_setmetatable(lua_State*L){
6258int t=lua_type(L,2);
6259luaL_checktype(L,1,5);
6260luaL_argcheck(L,t==0||t==5,2,
6261"nil or table expected");
6262if(luaL_getmetafield(L,1,"__metatable"))
6263luaL_error(L,"cannot change a protected metatable");
6264lua_settop(L,2);
6265lua_setmetatable(L,1);
6266return 1;
6267}
6268static void getfunc(lua_State*L,int opt){
6269if(lua_isfunction(L,1))lua_pushvalue(L,1);
6270else{
6271lua_Debug ar;
6272int level=opt?luaL_optint(L,1,1):luaL_checkint(L,1);
6273luaL_argcheck(L,level>=0,1,"level must be non-negative");
6274if(lua_getstack(L,level,&ar)==0)
6275luaL_argerror(L,1,"invalid level");
6276lua_getinfo(L,"f",&ar);
6277if(lua_isnil(L,-1))
6278luaL_error(L,"no function environment for tail call at level %d",
6279level);
6280}
6281}
6282static int luaB_setfenv(lua_State*L){
6283luaL_checktype(L,2,5);
6284getfunc(L,0);
6285lua_pushvalue(L,2);
6286if(lua_isnumber(L,1)&&lua_tonumber(L,1)==0){
6287lua_pushthread(L);
6288lua_insert(L,-2);
6289lua_setfenv(L,-2);
6290return 0;
6291}
6292else if(lua_iscfunction(L,-2)||lua_setfenv(L,-2)==0)
6293luaL_error(L,
6294LUA_QL("setfenv")" cannot change environment of given object");
6295return 1;
6296}
6297static int luaB_rawget(lua_State*L){
6298luaL_checktype(L,1,5);
6299luaL_checkany(L,2);
6300lua_settop(L,2);
6301lua_rawget(L,1);
6302return 1;
6303}
6304static int luaB_type(lua_State*L){
6305luaL_checkany(L,1);
6306lua_pushstring(L,luaL_typename(L,1));
6307return 1;
6308}
6309static int luaB_next(lua_State*L){
6310luaL_checktype(L,1,5);
6311lua_settop(L,2);
6312if(lua_next(L,1))
6313return 2;
6314else{
6315lua_pushnil(L);
6316return 1;
6317}
6318}
6319static int luaB_pairs(lua_State*L){
6320luaL_checktype(L,1,5);
6321lua_pushvalue(L,lua_upvalueindex(1));
6322lua_pushvalue(L,1);
6323lua_pushnil(L);
6324return 3;
6325}
6326static int ipairsaux(lua_State*L){
6327int i=luaL_checkint(L,2);
6328luaL_checktype(L,1,5);
6329i++;
6330lua_pushinteger(L,i);
6331lua_rawgeti(L,1,i);
6332return(lua_isnil(L,-1))?0:2;
6333}
6334static int luaB_ipairs(lua_State*L){
6335luaL_checktype(L,1,5);
6336lua_pushvalue(L,lua_upvalueindex(1));
6337lua_pushvalue(L,1);
6338lua_pushinteger(L,0);
6339return 3;
6340}
6341static int load_aux(lua_State*L,int status){
6342if(status==0)
6343return 1;
6344else{
6345lua_pushnil(L);
6346lua_insert(L,-2);
6347return 2;
6348}
6349}
6350static int luaB_loadstring(lua_State*L){
6351size_t l;
6352const char*s=luaL_checklstring(L,1,&l);
6353const char*chunkname=luaL_optstring(L,2,s);
6354return load_aux(L,luaL_loadbuffer(L,s,l,chunkname));
6355}
6356static int luaB_loadfile(lua_State*L){
6357const char*fname=luaL_optstring(L,1,NULL);
6358return load_aux(L,luaL_loadfile(L,fname));
6359}
6360static int luaB_assert(lua_State*L){
6361luaL_checkany(L,1);
6362if(!lua_toboolean(L,1))
6363return luaL_error(L,"%s",luaL_optstring(L,2,"assertion failed!"));
6364return lua_gettop(L);
6365}
6366static int luaB_unpack(lua_State*L){
6367int i,e,n;
6368luaL_checktype(L,1,5);
6369i=luaL_optint(L,2,1);
6370e=luaL_opt(L,luaL_checkint,3,luaL_getn(L,1));
6371if(i>e)return 0;
6372n=e-i+1;
6373if(n<=0||!lua_checkstack(L,n))
6374return luaL_error(L,"too many results to unpack");
6375lua_rawgeti(L,1,i);
6376while(i++<e)
6377lua_rawgeti(L,1,i);
6378return n;
6379}
6380static int luaB_pcall(lua_State*L){
6381int status;
6382luaL_checkany(L,1);
6383status=lua_pcall(L,lua_gettop(L)-1,(-1),0);
6384lua_pushboolean(L,(status==0));
6385lua_insert(L,1);
6386return lua_gettop(L);
6387}
6388static int luaB_newproxy(lua_State*L){
6389lua_settop(L,1);
6390lua_newuserdata(L,0);
6391if(lua_toboolean(L,1)==0)
6392return 1;
6393else if(lua_isboolean(L,1)){
6394lua_newtable(L);
6395lua_pushvalue(L,-1);
6396lua_pushboolean(L,1);
6397lua_rawset(L,lua_upvalueindex(1));
6398}
6399else{
6400int validproxy=0;
6401if(lua_getmetatable(L,1)){
6402lua_rawget(L,lua_upvalueindex(1));
6403validproxy=lua_toboolean(L,-1);
6404lua_pop(L,1);
6405}
6406luaL_argcheck(L,validproxy,1,"boolean or proxy expected");
6407lua_getmetatable(L,1);
6408}
6409lua_setmetatable(L,2);
6410return 1;
6411}
6412static const luaL_Reg base_funcs[]={
6413{"assert",luaB_assert},
6414{"error",luaB_error},
6415{"loadfile",luaB_loadfile},
6416{"loadstring",luaB_loadstring},
6417{"next",luaB_next},
6418{"pcall",luaB_pcall},
6419{"rawget",luaB_rawget},
6420{"setfenv",luaB_setfenv},
6421{"setmetatable",luaB_setmetatable},
6422{"tonumber",luaB_tonumber},
6423{"type",luaB_type},
6424{"unpack",luaB_unpack},
6425{NULL,NULL}
6426};
6427static void auxopen(lua_State*L,const char*name,
6428lua_CFunction f,lua_CFunction u){
6429lua_pushcfunction(L,u);
6430lua_pushcclosure(L,f,1);
6431lua_setfield(L,-2,name);
6432}
6433static void base_open(lua_State*L){
6434lua_pushvalue(L,(-10002));
6435lua_setglobal(L,"_G");
6436luaL_register(L,"_G",base_funcs);
6437lua_pushliteral(L,"Lua 5.1");
6438lua_setglobal(L,"_VERSION");
6439auxopen(L,"ipairs",luaB_ipairs,ipairsaux);
6440auxopen(L,"pairs",luaB_pairs,luaB_next);
6441lua_createtable(L,0,1);
6442lua_pushvalue(L,-1);
6443lua_setmetatable(L,-2);
6444lua_pushliteral(L,"kv");
6445lua_setfield(L,-2,"__mode");
6446lua_pushcclosure(L,luaB_newproxy,1);
6447lua_setglobal(L,"newproxy");
6448}
6449static int luaopen_base(lua_State*L){
6450base_open(L);
6451return 1;
6452}
6453#define aux_getn(L,n)(luaL_checktype(L,n,5),luaL_getn(L,n))
6454static int tinsert(lua_State*L){
6455int e=aux_getn(L,1)+1;
6456int pos;
6457switch(lua_gettop(L)){
6458case 2:{
6459pos=e;
6460break;
6461}
6462case 3:{
6463int i;
6464pos=luaL_checkint(L,2);
6465if(pos>e)e=pos;
6466for(i=e;i>pos;i--){
6467lua_rawgeti(L,1,i-1);
6468lua_rawseti(L,1,i);
6469}
6470break;
6471}
6472default:{
6473return luaL_error(L,"wrong number of arguments to "LUA_QL("insert"));
6474}
6475}
6476luaL_setn(L,1,e);
6477lua_rawseti(L,1,pos);
6478return 0;
6479}
6480static int tremove(lua_State*L){
6481int e=aux_getn(L,1);
6482int pos=luaL_optint(L,2,e);
6483if(!(1<=pos&&pos<=e))
6484return 0;
6485luaL_setn(L,1,e-1);
6486lua_rawgeti(L,1,pos);
6487for(;pos<e;pos++){
6488lua_rawgeti(L,1,pos+1);
6489lua_rawseti(L,1,pos);
6490}
6491lua_pushnil(L);
6492lua_rawseti(L,1,e);
6493return 1;
6494}
6495static void addfield(lua_State*L,luaL_Buffer*b,int i){
6496lua_rawgeti(L,1,i);
6497if(!lua_isstring(L,-1))
6498luaL_error(L,"invalid value (%s) at index %d in table for "
6499LUA_QL("concat"),luaL_typename(L,-1),i);
6500luaL_addvalue(b);
6501}
6502static int tconcat(lua_State*L){
6503luaL_Buffer b;
6504size_t lsep;
6505int i,last;
6506const char*sep=luaL_optlstring(L,2,"",&lsep);
6507luaL_checktype(L,1,5);
6508i=luaL_optint(L,3,1);
6509last=luaL_opt(L,luaL_checkint,4,luaL_getn(L,1));
6510luaL_buffinit(L,&b);
6511for(;i<last;i++){
6512addfield(L,&b,i);
6513luaL_addlstring(&b,sep,lsep);
6514}
6515if(i==last)
6516addfield(L,&b,i);
6517luaL_pushresult(&b);
6518return 1;
6519}
6520static void set2(lua_State*L,int i,int j){
6521lua_rawseti(L,1,i);
6522lua_rawseti(L,1,j);
6523}
6524static int sort_comp(lua_State*L,int a,int b){
6525if(!lua_isnil(L,2)){
6526int res;
6527lua_pushvalue(L,2);
6528lua_pushvalue(L,a-1);
6529lua_pushvalue(L,b-2);
6530lua_call(L,2,1);
6531res=lua_toboolean(L,-1);
6532lua_pop(L,1);
6533return res;
6534}
6535else
6536return lua_lessthan(L,a,b);
6537}
6538static void auxsort(lua_State*L,int l,int u){
6539while(l<u){
6540int i,j;
6541lua_rawgeti(L,1,l);
6542lua_rawgeti(L,1,u);
6543if(sort_comp(L,-1,-2))
6544set2(L,l,u);
6545else
6546lua_pop(L,2);
6547if(u-l==1)break;
6548i=(l+u)/2;
6549lua_rawgeti(L,1,i);
6550lua_rawgeti(L,1,l);
6551if(sort_comp(L,-2,-1))
6552set2(L,i,l);
6553else{
6554lua_pop(L,1);
6555lua_rawgeti(L,1,u);
6556if(sort_comp(L,-1,-2))
6557set2(L,i,u);
6558else
6559lua_pop(L,2);
6560}
6561if(u-l==2)break;
6562lua_rawgeti(L,1,i);
6563lua_pushvalue(L,-1);
6564lua_rawgeti(L,1,u-1);
6565set2(L,i,u-1);
6566i=l;j=u-1;
6567for(;;){
6568while(lua_rawgeti(L,1,++i),sort_comp(L,-1,-2)){
6569if(i>u)luaL_error(L,"invalid order function for sorting");
6570lua_pop(L,1);
6571}
6572while(lua_rawgeti(L,1,--j),sort_comp(L,-3,-1)){
6573if(j<l)luaL_error(L,"invalid order function for sorting");
6574lua_pop(L,1);
6575}
6576if(j<i){
6577lua_pop(L,3);
6578break;
6579}
6580set2(L,i,j);
6581}
6582lua_rawgeti(L,1,u-1);
6583lua_rawgeti(L,1,i);
6584set2(L,u-1,i);
6585if(i-l<u-i){
6586j=l;i=i-1;l=i+2;
6587}
6588else{
6589j=i+1;i=u;u=j-2;
6590}
6591auxsort(L,j,i);
6592}
6593}
6594static int sort(lua_State*L){
6595int n=aux_getn(L,1);
6596luaL_checkstack(L,40,"");
6597if(!lua_isnoneornil(L,2))
6598luaL_checktype(L,2,6);
6599lua_settop(L,2);
6600auxsort(L,1,n);
6601return 0;
6602}
6603static const luaL_Reg tab_funcs[]={
6604{"concat",tconcat},
6605{"insert",tinsert},
6606{"remove",tremove},
6607{"sort",sort},
6608{NULL,NULL}
6609};
6610static int luaopen_table(lua_State*L){
6611luaL_register(L,"table",tab_funcs);
6612return 1;
6613}
6614static const char*const fnames[]={"input","output"};
6615static int pushresult(lua_State*L,int i,const char*filename){
6616int en=errno;
6617if(i){
6618lua_pushboolean(L,1);
6619return 1;
6620}
6621else{
6622lua_pushnil(L);
6623if(filename)
6624lua_pushfstring(L,"%s: %s",filename,strerror(en));
6625else
6626lua_pushfstring(L,"%s",strerror(en));
6627lua_pushinteger(L,en);
6628return 3;
6629}
6630}
6631static void fileerror(lua_State*L,int arg,const char*filename){
6632lua_pushfstring(L,"%s: %s",filename,strerror(errno));
6633luaL_argerror(L,arg,lua_tostring(L,-1));
6634}
6635#define tofilep(L)((FILE**)luaL_checkudata(L,1,"FILE*"))
6636static int io_type(lua_State*L){
6637void*ud;
6638luaL_checkany(L,1);
6639ud=lua_touserdata(L,1);
6640lua_getfield(L,(-10000),"FILE*");
6641if(ud==NULL||!lua_getmetatable(L,1)||!lua_rawequal(L,-2,-1))
6642lua_pushnil(L);
6643else if(*((FILE**)ud)==NULL)
6644lua_pushliteral(L,"closed file");
6645else
6646lua_pushliteral(L,"file");
6647return 1;
6648}
6649static FILE*tofile(lua_State*L){
6650FILE**f=tofilep(L);
6651if(*f==NULL)
6652luaL_error(L,"attempt to use a closed file");
6653return*f;
6654}
6655static FILE**newfile(lua_State*L){
6656FILE**pf=(FILE**)lua_newuserdata(L,sizeof(FILE*));
6657*pf=NULL;
6658luaL_getmetatable(L,"FILE*");
6659lua_setmetatable(L,-2);
6660return pf;
6661}
6662static int io_noclose(lua_State*L){
6663lua_pushnil(L);
6664lua_pushliteral(L,"cannot close standard file");
6665return 2;
6666}
6667static int io_pclose(lua_State*L){
6668FILE**p=tofilep(L);
6669int ok=lua_pclose(L,*p);
6670*p=NULL;
6671return pushresult(L,ok,NULL);
6672}
6673static int io_fclose(lua_State*L){
6674FILE**p=tofilep(L);
6675int ok=(fclose(*p)==0);
6676*p=NULL;
6677return pushresult(L,ok,NULL);
6678}
6679static int aux_close(lua_State*L){
6680lua_getfenv(L,1);
6681lua_getfield(L,-1,"__close");
6682return(lua_tocfunction(L,-1))(L);
6683}
6684static int io_close(lua_State*L){
6685if(lua_isnone(L,1))
6686lua_rawgeti(L,(-10001),2);
6687tofile(L);
6688return aux_close(L);
6689}
6690static int io_gc(lua_State*L){
6691FILE*f=*tofilep(L);
6692if(f!=NULL)
6693aux_close(L);
6694return 0;
6695}
6696static int io_open(lua_State*L){
6697const char*filename=luaL_checkstring(L,1);
6698const char*mode=luaL_optstring(L,2,"r");
6699FILE**pf=newfile(L);
6700*pf=fopen(filename,mode);
6701return(*pf==NULL)?pushresult(L,0,filename):1;
6702}
6703static FILE*getiofile(lua_State*L,int findex){
6704FILE*f;
6705lua_rawgeti(L,(-10001),findex);
6706f=*(FILE**)lua_touserdata(L,-1);
6707if(f==NULL)
6708luaL_error(L,"standard %s file is closed",fnames[findex-1]);
6709return f;
6710}
6711static int g_iofile(lua_State*L,int f,const char*mode){
6712if(!lua_isnoneornil(L,1)){
6713const char*filename=lua_tostring(L,1);
6714if(filename){
6715FILE**pf=newfile(L);
6716*pf=fopen(filename,mode);
6717if(*pf==NULL)
6718fileerror(L,1,filename);
6719}
6720else{
6721tofile(L);
6722lua_pushvalue(L,1);
6723}
6724lua_rawseti(L,(-10001),f);
6725}
6726lua_rawgeti(L,(-10001),f);
6727return 1;
6728}
6729static int io_input(lua_State*L){
6730return g_iofile(L,1,"r");
6731}
6732static int io_output(lua_State*L){
6733return g_iofile(L,2,"w");
6734}
6735static int io_readline(lua_State*L);
6736static void aux_lines(lua_State*L,int idx,int toclose){
6737lua_pushvalue(L,idx);
6738lua_pushboolean(L,toclose);
6739lua_pushcclosure(L,io_readline,2);
6740}
6741static int f_lines(lua_State*L){
6742tofile(L);
6743aux_lines(L,1,0);
6744return 1;
6745}
6746static int io_lines(lua_State*L){
6747if(lua_isnoneornil(L,1)){
6748lua_rawgeti(L,(-10001),1);
6749return f_lines(L);
6750}
6751else{
6752const char*filename=luaL_checkstring(L,1);
6753FILE**pf=newfile(L);
6754*pf=fopen(filename,"r");
6755if(*pf==NULL)
6756fileerror(L,1,filename);
6757aux_lines(L,lua_gettop(L),1);
6758return 1;
6759}
6760}
6761static int read_number(lua_State*L,FILE*f){
6762lua_Number d;
6763if(fscanf(f,"%lf",&d)==1){
6764lua_pushnumber(L,d);
6765return 1;
6766}
6767else{
6768lua_pushnil(L);
6769return 0;
6770}
6771}
6772static int test_eof(lua_State*L,FILE*f){
6773int c=getc(f);
6774ungetc(c,f);
6775lua_pushlstring(L,NULL,0);
6776return(c!=EOF);
6777}
6778static int read_line(lua_State*L,FILE*f){
6779luaL_Buffer b;
6780luaL_buffinit(L,&b);
6781for(;;){
6782size_t l;
6783char*p=luaL_prepbuffer(&b);
6784if(fgets(p,BUFSIZ,f)==NULL){
6785luaL_pushresult(&b);
6786return(lua_objlen(L,-1)>0);
6787}
6788l=strlen(p);
6789if(l==0||p[l-1]!='\n')
6790luaL_addsize(&b,l);
6791else{
6792luaL_addsize(&b,l-1);
6793luaL_pushresult(&b);
6794return 1;
6795}
6796}
6797}
6798static int read_chars(lua_State*L,FILE*f,size_t n){
6799size_t rlen;
6800size_t nr;
6801luaL_Buffer b;
6802luaL_buffinit(L,&b);
6803rlen=BUFSIZ;
6804do{
6805char*p=luaL_prepbuffer(&b);
6806if(rlen>n)rlen=n;
6807nr=fread(p,sizeof(char),rlen,f);
6808luaL_addsize(&b,nr);
6809n-=nr;
6810}while(n>0&&nr==rlen);
6811luaL_pushresult(&b);
6812return(n==0||lua_objlen(L,-1)>0);
6813}
6814static int g_read(lua_State*L,FILE*f,int first){
6815int nargs=lua_gettop(L)-1;
6816int success;
6817int n;
6818clearerr(f);
6819if(nargs==0){
6820success=read_line(L,f);
6821n=first+1;
6822}
6823else{
6824luaL_checkstack(L,nargs+20,"too many arguments");
6825success=1;
6826for(n=first;nargs--&&success;n++){
6827if(lua_type(L,n)==3){
6828size_t l=(size_t)lua_tointeger(L,n);
6829success=(l==0)?test_eof(L,f):read_chars(L,f,l);
6830}
6831else{
6832const char*p=lua_tostring(L,n);
6833luaL_argcheck(L,p&&p[0]=='*',n,"invalid option");
6834switch(p[1]){
6835case'n':
6836success=read_number(L,f);
6837break;
6838case'l':
6839success=read_line(L,f);
6840break;
6841case'a':
6842read_chars(L,f,~((size_t)0));
6843success=1;
6844break;
6845default:
6846return luaL_argerror(L,n,"invalid format");
6847}
6848}
6849}
6850}
6851if(ferror(f))
6852return pushresult(L,0,NULL);
6853if(!success){
6854lua_pop(L,1);
6855lua_pushnil(L);
6856}
6857return n-first;
6858}
6859static int io_read(lua_State*L){
6860return g_read(L,getiofile(L,1),1);
6861}
6862static int f_read(lua_State*L){
6863return g_read(L,tofile(L),2);
6864}
6865static int io_readline(lua_State*L){
6866FILE*f=*(FILE**)lua_touserdata(L,lua_upvalueindex(1));
6867int sucess;
6868if(f==NULL)
6869luaL_error(L,"file is already closed");
6870sucess=read_line(L,f);
6871if(ferror(f))
6872return luaL_error(L,"%s",strerror(errno));
6873if(sucess)return 1;
6874else{
6875if(lua_toboolean(L,lua_upvalueindex(2))){
6876lua_settop(L,0);
6877lua_pushvalue(L,lua_upvalueindex(1));
6878aux_close(L);
6879}
6880return 0;
6881}
6882}
6883static int g_write(lua_State*L,FILE*f,int arg){
6884int nargs=lua_gettop(L)-1;
6885int status=1;
6886for(;nargs--;arg++){
6887if(lua_type(L,arg)==3){
6888status=status&&
6889fprintf(f,"%.14g",lua_tonumber(L,arg))>0;
6890}
6891else{
6892size_t l;
6893const char*s=luaL_checklstring(L,arg,&l);
6894status=status&&(fwrite(s,sizeof(char),l,f)==l);
6895}
6896}
6897return pushresult(L,status,NULL);
6898}
6899static int io_write(lua_State*L){
6900return g_write(L,getiofile(L,2),1);
6901}
6902static int f_write(lua_State*L){
6903return g_write(L,tofile(L),2);
6904}
6905static int io_flush(lua_State*L){
6906return pushresult(L,fflush(getiofile(L,2))==0,NULL);
6907}
6908static int f_flush(lua_State*L){
6909return pushresult(L,fflush(tofile(L))==0,NULL);
6910}
6911static const luaL_Reg iolib[]={
6912{"close",io_close},
6913{"flush",io_flush},
6914{"input",io_input},
6915{"lines",io_lines},
6916{"open",io_open},
6917{"output",io_output},
6918{"read",io_read},
6919{"type",io_type},
6920{"write",io_write},
6921{NULL,NULL}
6922};
6923static const luaL_Reg flib[]={
6924{"close",io_close},
6925{"flush",f_flush},
6926{"lines",f_lines},
6927{"read",f_read},
6928{"write",f_write},
6929{"__gc",io_gc},
6930{NULL,NULL}
6931};
6932static void createmeta(lua_State*L){
6933luaL_newmetatable(L,"FILE*");
6934lua_pushvalue(L,-1);
6935lua_setfield(L,-2,"__index");
6936luaL_register(L,NULL,flib);
6937}
6938static void createstdfile(lua_State*L,FILE*f,int k,const char*fname){
6939*newfile(L)=f;
6940if(k>0){
6941lua_pushvalue(L,-1);
6942lua_rawseti(L,(-10001),k);
6943}
6944lua_pushvalue(L,-2);
6945lua_setfenv(L,-2);
6946lua_setfield(L,-3,fname);
6947}
6948static void newfenv(lua_State*L,lua_CFunction cls){
6949lua_createtable(L,0,1);
6950lua_pushcfunction(L,cls);
6951lua_setfield(L,-2,"__close");
6952}
6953static int luaopen_io(lua_State*L){
6954createmeta(L);
6955newfenv(L,io_fclose);
6956lua_replace(L,(-10001));
6957luaL_register(L,"io",iolib);
6958newfenv(L,io_noclose);
6959createstdfile(L,stdin,1,"stdin");
6960createstdfile(L,stdout,2,"stdout");
6961createstdfile(L,stderr,0,"stderr");
6962lua_pop(L,1);
6963lua_getfield(L,-1,"popen");
6964newfenv(L,io_pclose);
6965lua_setfenv(L,-2);
6966lua_pop(L,1);
6967return 1;
6968}
6969static int os_pushresult(lua_State*L,int i,const char*filename){
6970int en=errno;
6971if(i){
6972lua_pushboolean(L,1);
6973return 1;
6974}
6975else{
6976lua_pushnil(L);
6977lua_pushfstring(L,"%s: %s",filename,strerror(en));
6978lua_pushinteger(L,en);
6979return 3;
6980}
6981}
6982static int os_remove(lua_State*L){
6983const char*filename=luaL_checkstring(L,1);
6984return os_pushresult(L,remove(filename)==0,filename);
6985}
6986static int os_exit(lua_State*L){
6987exit(luaL_optint(L,1,EXIT_SUCCESS));
6988}
6989static const luaL_Reg syslib[]={
6990{"exit",os_exit},
6991{"remove",os_remove},
6992{NULL,NULL}
6993};
6994static int luaopen_os(lua_State*L){
6995luaL_register(L,"os",syslib);
6996return 1;
6997}
6998#define uchar(c)((unsigned char)(c))
6999static ptrdiff_t posrelat(ptrdiff_t pos,size_t len){
7000if(pos<0)pos+=(ptrdiff_t)len+1;
7001return(pos>=0)?pos:0;
7002}
7003static int str_sub(lua_State*L){
7004size_t l;
7005const char*s=luaL_checklstring(L,1,&l);
7006ptrdiff_t start=posrelat(luaL_checkinteger(L,2),l);
7007ptrdiff_t end=posrelat(luaL_optinteger(L,3,-1),l);
7008if(start<1)start=1;
7009if(end>(ptrdiff_t)l)end=(ptrdiff_t)l;
7010if(start<=end)
7011lua_pushlstring(L,s+start-1,end-start+1);
7012else lua_pushliteral(L,"");
7013return 1;
7014}
7015static int str_lower(lua_State*L){
7016size_t l;
7017size_t i;
7018luaL_Buffer b;
7019const char*s=luaL_checklstring(L,1,&l);
7020luaL_buffinit(L,&b);
7021for(i=0;i<l;i++)
7022luaL_addchar(&b,tolower(uchar(s[i])));
7023luaL_pushresult(&b);
7024return 1;
7025}
7026static int str_upper(lua_State*L){
7027size_t l;
7028size_t i;
7029luaL_Buffer b;
7030const char*s=luaL_checklstring(L,1,&l);
7031luaL_buffinit(L,&b);
7032for(i=0;i<l;i++)
7033luaL_addchar(&b,toupper(uchar(s[i])));
7034luaL_pushresult(&b);
7035return 1;
7036}
7037static int str_rep(lua_State*L){
7038size_t l;
7039luaL_Buffer b;
7040const char*s=luaL_checklstring(L,1,&l);
7041int n=luaL_checkint(L,2);
7042luaL_buffinit(L,&b);
7043while(n-->0)
7044luaL_addlstring(&b,s,l);
7045luaL_pushresult(&b);
7046return 1;
7047}
7048static int str_byte(lua_State*L){
7049size_t l;
7050const char*s=luaL_checklstring(L,1,&l);
7051ptrdiff_t posi=posrelat(luaL_optinteger(L,2,1),l);
7052ptrdiff_t pose=posrelat(luaL_optinteger(L,3,posi),l);
7053int n,i;
7054if(posi<=0)posi=1;
7055if((size_t)pose>l)pose=l;
7056if(posi>pose)return 0;
7057n=(int)(pose-posi+1);
7058if(posi+n<=pose)
7059luaL_error(L,"string slice too long");
7060luaL_checkstack(L,n,"string slice too long");
7061for(i=0;i<n;i++)
7062lua_pushinteger(L,uchar(s[posi+i-1]));
7063return n;
7064}
7065static int str_char(lua_State*L){
7066int n=lua_gettop(L);
7067int i;
7068luaL_Buffer b;
7069luaL_buffinit(L,&b);
7070for(i=1;i<=n;i++){
7071int c=luaL_checkint(L,i);
7072luaL_argcheck(L,uchar(c)==c,i,"invalid value");
7073luaL_addchar(&b,uchar(c));
7074}
7075luaL_pushresult(&b);
7076return 1;
7077}
7078typedef struct MatchState{
7079const char*src_init;
7080const char*src_end;
7081lua_State*L;
7082int level;
7083struct{
7084const char*init;
7085ptrdiff_t len;
7086}capture[32];
7087}MatchState;
7088static int check_capture(MatchState*ms,int l){
7089l-='1';
7090if(l<0||l>=ms->level||ms->capture[l].len==(-1))
7091return luaL_error(ms->L,"invalid capture index");
7092return l;
7093}
7094static int capture_to_close(MatchState*ms){
7095int level=ms->level;
7096for(level--;level>=0;level--)
7097if(ms->capture[level].len==(-1))return level;
7098return luaL_error(ms->L,"invalid pattern capture");
7099}
7100static const char*classend(MatchState*ms,const char*p){
7101switch(*p++){
7102case'%':{
7103if(*p=='\0')
7104luaL_error(ms->L,"malformed pattern (ends with "LUA_QL("%%")")");
7105return p+1;
7106}
7107case'[':{
7108if(*p=='^')p++;
7109do{
7110if(*p=='\0')
7111luaL_error(ms->L,"malformed pattern (missing "LUA_QL("]")")");
7112if(*(p++)=='%'&&*p!='\0')
7113p++;
7114}while(*p!=']');
7115return p+1;
7116}
7117default:{
7118return p;
7119}
7120}
7121}
7122static int match_class(int c,int cl){
7123int res;
7124switch(tolower(cl)){
7125case'a':res=isalpha(c);break;
7126case'c':res=iscntrl(c);break;
7127case'd':res=isdigit(c);break;
7128case'l':res=islower(c);break;
7129case'p':res=ispunct(c);break;
7130case's':res=isspace(c);break;
7131case'u':res=isupper(c);break;
7132case'w':res=isalnum(c);break;
7133case'x':res=isxdigit(c);break;
7134case'z':res=(c==0);break;
7135default:return(cl==c);
7136}
7137return(islower(cl)?res:!res);
7138}
7139static int matchbracketclass(int c,const char*p,const char*ec){
7140int sig=1;
7141if(*(p+1)=='^'){
7142sig=0;
7143p++;
7144}
7145while(++p<ec){
7146if(*p=='%'){
7147p++;
7148if(match_class(c,uchar(*p)))
7149return sig;
7150}
7151else if((*(p+1)=='-')&&(p+2<ec)){
7152p+=2;
7153if(uchar(*(p-2))<=c&&c<=uchar(*p))
7154return sig;
7155}
7156else if(uchar(*p)==c)return sig;
7157}
7158return!sig;
7159}
7160static int singlematch(int c,const char*p,const char*ep){
7161switch(*p){
7162case'.':return 1;
7163case'%':return match_class(c,uchar(*(p+1)));
7164case'[':return matchbracketclass(c,p,ep-1);
7165default:return(uchar(*p)==c);
7166}
7167}
7168static const char*match(MatchState*ms,const char*s,const char*p);
7169static const char*matchbalance(MatchState*ms,const char*s,
7170const char*p){
7171if(*p==0||*(p+1)==0)
7172luaL_error(ms->L,"unbalanced pattern");
7173if(*s!=*p)return NULL;
7174else{
7175int b=*p;
7176int e=*(p+1);
7177int cont=1;
7178while(++s<ms->src_end){
7179if(*s==e){
7180if(--cont==0)return s+1;
7181}
7182else if(*s==b)cont++;
7183}
7184}
7185return NULL;
7186}
7187static const char*max_expand(MatchState*ms,const char*s,
7188const char*p,const char*ep){
7189ptrdiff_t i=0;
7190while((s+i)<ms->src_end&&singlematch(uchar(*(s+i)),p,ep))
7191i++;
7192while(i>=0){
7193const char*res=match(ms,(s+i),ep+1);
7194if(res)return res;
7195i--;
7196}
7197return NULL;
7198}
7199static const char*min_expand(MatchState*ms,const char*s,
7200const char*p,const char*ep){
7201for(;;){
7202const char*res=match(ms,s,ep+1);
7203if(res!=NULL)
7204return res;
7205else if(s<ms->src_end&&singlematch(uchar(*s),p,ep))
7206s++;
7207else return NULL;
7208}
7209}
7210static const char*start_capture(MatchState*ms,const char*s,
7211const char*p,int what){
7212const char*res;
7213int level=ms->level;
7214if(level>=32)luaL_error(ms->L,"too many captures");
7215ms->capture[level].init=s;
7216ms->capture[level].len=what;
7217ms->level=level+1;
7218if((res=match(ms,s,p))==NULL)
7219ms->level--;
7220return res;
7221}
7222static const char*end_capture(MatchState*ms,const char*s,
7223const char*p){
7224int l=capture_to_close(ms);
7225const char*res;
7226ms->capture[l].len=s-ms->capture[l].init;
7227if((res=match(ms,s,p))==NULL)
7228ms->capture[l].len=(-1);
7229return res;
7230}
7231static const char*match_capture(MatchState*ms,const char*s,int l){
7232size_t len;
7233l=check_capture(ms,l);
7234len=ms->capture[l].len;
7235if((size_t)(ms->src_end-s)>=len&&
7236memcmp(ms->capture[l].init,s,len)==0)
7237return s+len;
7238else return NULL;
7239}
7240static const char*match(MatchState*ms,const char*s,const char*p){
7241init:
7242switch(*p){
7243case'(':{
7244if(*(p+1)==')')
7245return start_capture(ms,s,p+2,(-2));
7246else
7247return start_capture(ms,s,p+1,(-1));
7248}
7249case')':{
7250return end_capture(ms,s,p+1);
7251}
7252case'%':{
7253switch(*(p+1)){
7254case'b':{
7255s=matchbalance(ms,s,p+2);
7256if(s==NULL)return NULL;
7257p+=4;goto init;
7258}
7259case'f':{
7260const char*ep;char previous;
7261p+=2;
7262if(*p!='[')
7263luaL_error(ms->L,"missing "LUA_QL("[")" after "
7264LUA_QL("%%f")" in pattern");
7265ep=classend(ms,p);
7266previous=(s==ms->src_init)?'\0':*(s-1);
7267if(matchbracketclass(uchar(previous),p,ep-1)||
7268!matchbracketclass(uchar(*s),p,ep-1))return NULL;
7269p=ep;goto init;
7270}
7271default:{
7272if(isdigit(uchar(*(p+1)))){
7273s=match_capture(ms,s,uchar(*(p+1)));
7274if(s==NULL)return NULL;
7275p+=2;goto init;
7276}
7277goto dflt;
7278}
7279}
7280}
7281case'\0':{
7282return s;
7283}
7284case'$':{
7285if(*(p+1)=='\0')
7286return(s==ms->src_end)?s:NULL;
7287else goto dflt;
7288}
7289default:dflt:{
7290const char*ep=classend(ms,p);
7291int m=s<ms->src_end&&singlematch(uchar(*s),p,ep);
7292switch(*ep){
7293case'?':{
7294const char*res;
7295if(m&&((res=match(ms,s+1,ep+1))!=NULL))
7296return res;
7297p=ep+1;goto init;
7298}
7299case'*':{
7300return max_expand(ms,s,p,ep);
7301}
7302case'+':{
7303return(m?max_expand(ms,s+1,p,ep):NULL);
7304}
7305case'-':{
7306return min_expand(ms,s,p,ep);
7307}
7308default:{
7309if(!m)return NULL;
7310s++;p=ep;goto init;
7311}
7312}
7313}
7314}
7315}
7316static const char*lmemfind(const char*s1,size_t l1,
7317const char*s2,size_t l2){
7318if(l2==0)return s1;
7319else if(l2>l1)return NULL;
7320else{
7321const char*init;
7322l2--;
7323l1=l1-l2;
7324while(l1>0&&(init=(const char*)memchr(s1,*s2,l1))!=NULL){
7325init++;
7326if(memcmp(init,s2+1,l2)==0)
7327return init-1;
7328else{
7329l1-=init-s1;
7330s1=init;
7331}
7332}
7333return NULL;
7334}
7335}
7336static void push_onecapture(MatchState*ms,int i,const char*s,
7337const char*e){
7338if(i>=ms->level){
7339if(i==0)
7340lua_pushlstring(ms->L,s,e-s);
7341else
7342luaL_error(ms->L,"invalid capture index");
7343}
7344else{
7345ptrdiff_t l=ms->capture[i].len;
7346if(l==(-1))luaL_error(ms->L,"unfinished capture");
7347if(l==(-2))
7348lua_pushinteger(ms->L,ms->capture[i].init-ms->src_init+1);
7349else
7350lua_pushlstring(ms->L,ms->capture[i].init,l);
7351}
7352}
7353static int push_captures(MatchState*ms,const char*s,const char*e){
7354int i;
7355int nlevels=(ms->level==0&&s)?1:ms->level;
7356luaL_checkstack(ms->L,nlevels,"too many captures");
7357for(i=0;i<nlevels;i++)
7358push_onecapture(ms,i,s,e);
7359return nlevels;
7360}
7361static int str_find_aux(lua_State*L,int find){
7362size_t l1,l2;
7363const char*s=luaL_checklstring(L,1,&l1);
7364const char*p=luaL_checklstring(L,2,&l2);
7365ptrdiff_t init=posrelat(luaL_optinteger(L,3,1),l1)-1;
7366if(init<0)init=0;
7367else if((size_t)(init)>l1)init=(ptrdiff_t)l1;
7368if(find&&(lua_toboolean(L,4)||
7369strpbrk(p,"^$*+?.([%-")==NULL)){
7370const char*s2=lmemfind(s+init,l1-init,p,l2);
7371if(s2){
7372lua_pushinteger(L,s2-s+1);
7373lua_pushinteger(L,s2-s+l2);
7374return 2;
7375}
7376}
7377else{
7378MatchState ms;
7379int anchor=(*p=='^')?(p++,1):0;
7380const char*s1=s+init;
7381ms.L=L;
7382ms.src_init=s;
7383ms.src_end=s+l1;
7384do{
7385const char*res;
7386ms.level=0;
7387if((res=match(&ms,s1,p))!=NULL){
7388if(find){
7389lua_pushinteger(L,s1-s+1);
7390lua_pushinteger(L,res-s);
7391return push_captures(&ms,NULL,0)+2;
7392}
7393else
7394return push_captures(&ms,s1,res);
7395}
7396}while(s1++<ms.src_end&&!anchor);
7397}
7398lua_pushnil(L);
7399return 1;
7400}
7401static int str_find(lua_State*L){
7402return str_find_aux(L,1);
7403}
7404static int str_match(lua_State*L){
7405return str_find_aux(L,0);
7406}
7407static int gmatch_aux(lua_State*L){
7408MatchState ms;
7409size_t ls;
7410const char*s=lua_tolstring(L,lua_upvalueindex(1),&ls);
7411const char*p=lua_tostring(L,lua_upvalueindex(2));
7412const char*src;
7413ms.L=L;
7414ms.src_init=s;
7415ms.src_end=s+ls;
7416for(src=s+(size_t)lua_tointeger(L,lua_upvalueindex(3));
7417src<=ms.src_end;
7418src++){
7419const char*e;
7420ms.level=0;
7421if((e=match(&ms,src,p))!=NULL){
7422lua_Integer newstart=e-s;
7423if(e==src)newstart++;
7424lua_pushinteger(L,newstart);
7425lua_replace(L,lua_upvalueindex(3));
7426return push_captures(&ms,src,e);
7427}
7428}
7429return 0;
7430}
7431static int gmatch(lua_State*L){
7432luaL_checkstring(L,1);
7433luaL_checkstring(L,2);
7434lua_settop(L,2);
7435lua_pushinteger(L,0);
7436lua_pushcclosure(L,gmatch_aux,3);
7437return 1;
7438}
7439static void add_s(MatchState*ms,luaL_Buffer*b,const char*s,
7440const char*e){
7441size_t l,i;
7442const char*news=lua_tolstring(ms->L,3,&l);
7443for(i=0;i<l;i++){
7444if(news[i]!='%')
7445luaL_addchar(b,news[i]);
7446else{
7447i++;
7448if(!isdigit(uchar(news[i])))
7449luaL_addchar(b,news[i]);
7450else if(news[i]=='0')
7451luaL_addlstring(b,s,e-s);
7452else{
7453push_onecapture(ms,news[i]-'1',s,e);
7454luaL_addvalue(b);
7455}
7456}
7457}
7458}
7459static void add_value(MatchState*ms,luaL_Buffer*b,const char*s,
7460const char*e){
7461lua_State*L=ms->L;
7462switch(lua_type(L,3)){
7463case 3:
7464case 4:{
7465add_s(ms,b,s,e);
7466return;
7467}
7468case 6:{
7469int n;
7470lua_pushvalue(L,3);
7471n=push_captures(ms,s,e);
7472lua_call(L,n,1);
7473break;
7474}
7475case 5:{
7476push_onecapture(ms,0,s,e);
7477lua_gettable(L,3);
7478break;
7479}
7480}
7481if(!lua_toboolean(L,-1)){
7482lua_pop(L,1);
7483lua_pushlstring(L,s,e-s);
7484}
7485else if(!lua_isstring(L,-1))
7486luaL_error(L,"invalid replacement value (a %s)",luaL_typename(L,-1));
7487luaL_addvalue(b);
7488}
7489static int str_gsub(lua_State*L){
7490size_t srcl;
7491const char*src=luaL_checklstring(L,1,&srcl);
7492const char*p=luaL_checkstring(L,2);
7493int tr=lua_type(L,3);
7494int max_s=luaL_optint(L,4,srcl+1);
7495int anchor=(*p=='^')?(p++,1):0;
7496int n=0;
7497MatchState ms;
7498luaL_Buffer b;
7499luaL_argcheck(L,tr==3||tr==4||
7500tr==6||tr==5,3,
7501"string/function/table expected");
7502luaL_buffinit(L,&b);
7503ms.L=L;
7504ms.src_init=src;
7505ms.src_end=src+srcl;
7506while(n<max_s){
7507const char*e;
7508ms.level=0;
7509e=match(&ms,src,p);
7510if(e){
7511n++;
7512add_value(&ms,&b,src,e);
7513}
7514if(e&&e>src)
7515src=e;
7516else if(src<ms.src_end)
7517luaL_addchar(&b,*src++);
7518else break;
7519if(anchor)break;
7520}
7521luaL_addlstring(&b,src,ms.src_end-src);
7522luaL_pushresult(&b);
7523lua_pushinteger(L,n);
7524return 2;
7525}
7526static void addquoted(lua_State*L,luaL_Buffer*b,int arg){
7527size_t l;
7528const char*s=luaL_checklstring(L,arg,&l);
7529luaL_addchar(b,'"');
7530while(l--){
7531switch(*s){
7532case'"':case'\\':case'\n':{
7533luaL_addchar(b,'\\');
7534luaL_addchar(b,*s);
7535break;
7536}
7537case'\r':{
7538luaL_addlstring(b,"\\r",2);
7539break;
7540}
7541case'\0':{
7542luaL_addlstring(b,"\\000",4);
7543break;
7544}
7545default:{
7546luaL_addchar(b,*s);
7547break;
7548}
7549}
7550s++;
7551}
7552luaL_addchar(b,'"');
7553}
7554static const char*scanformat(lua_State*L,const char*strfrmt,char*form){
7555const char*p=strfrmt;
7556while(*p!='\0'&&strchr("-+ #0",*p)!=NULL)p++;
7557if((size_t)(p-strfrmt)>=sizeof("-+ #0"))
7558luaL_error(L,"invalid format (repeated flags)");
7559if(isdigit(uchar(*p)))p++;
7560if(isdigit(uchar(*p)))p++;
7561if(*p=='.'){
7562p++;
7563if(isdigit(uchar(*p)))p++;
7564if(isdigit(uchar(*p)))p++;
7565}
7566if(isdigit(uchar(*p)))
7567luaL_error(L,"invalid format (width or precision too long)");
7568*(form++)='%';
7569strncpy(form,strfrmt,p-strfrmt+1);
7570form+=p-strfrmt+1;
7571*form='\0';
7572return p;
7573}
7574static void addintlen(char*form){
7575size_t l=strlen(form);
7576char spec=form[l-1];
7577strcpy(form+l-1,"l");
7578form[l+sizeof("l")-2]=spec;
7579form[l+sizeof("l")-1]='\0';
7580}
7581static int str_format(lua_State*L){
7582int top=lua_gettop(L);
7583int arg=1;
7584size_t sfl;
7585const char*strfrmt=luaL_checklstring(L,arg,&sfl);
7586const char*strfrmt_end=strfrmt+sfl;
7587luaL_Buffer b;
7588luaL_buffinit(L,&b);
7589while(strfrmt<strfrmt_end){
7590if(*strfrmt!='%')
7591luaL_addchar(&b,*strfrmt++);
7592else if(*++strfrmt=='%')
7593luaL_addchar(&b,*strfrmt++);
7594else{
7595char form[(sizeof("-+ #0")+sizeof("l")+10)];
7596char buff[512];
7597if(++arg>top)
7598luaL_argerror(L,arg,"no value");
7599strfrmt=scanformat(L,strfrmt,form);
7600switch(*strfrmt++){
7601case'c':{
7602sprintf(buff,form,(int)luaL_checknumber(L,arg));
7603break;
7604}
7605case'd':case'i':{
7606addintlen(form);
7607sprintf(buff,form,(long)luaL_checknumber(L,arg));
7608break;
7609}
7610case'o':case'u':case'x':case'X':{
7611addintlen(form);
7612sprintf(buff,form,(unsigned long)luaL_checknumber(L,arg));
7613break;
7614}
7615case'e':case'E':case'f':
7616case'g':case'G':{
7617sprintf(buff,form,(double)luaL_checknumber(L,arg));
7618break;
7619}
7620case'q':{
7621addquoted(L,&b,arg);
7622continue;
7623}
7624case's':{
7625size_t l;
7626const char*s=luaL_checklstring(L,arg,&l);
7627if(!strchr(form,'.')&&l>=100){
7628lua_pushvalue(L,arg);
7629luaL_addvalue(&b);
7630continue;
7631}
7632else{
7633sprintf(buff,form,s);
7634break;
7635}
7636}
7637default:{
7638return luaL_error(L,"invalid option "LUA_QL("%%%c")" to "
7639LUA_QL("format"),*(strfrmt-1));
7640}
7641}
7642luaL_addlstring(&b,buff,strlen(buff));
7643}
7644}
7645luaL_pushresult(&b);
7646return 1;
7647}
7648static const luaL_Reg strlib[]={
7649{"byte",str_byte},
7650{"char",str_char},
7651{"find",str_find},
7652{"format",str_format},
7653{"gmatch",gmatch},
7654{"gsub",str_gsub},
7655{"lower",str_lower},
7656{"match",str_match},
7657{"rep",str_rep},
7658{"sub",str_sub},
7659{"upper",str_upper},
7660{NULL,NULL}
7661};
7662static void createmetatable(lua_State*L){
7663lua_createtable(L,0,1);
7664lua_pushliteral(L,"");
7665lua_pushvalue(L,-2);
7666lua_setmetatable(L,-2);
7667lua_pop(L,1);
7668lua_pushvalue(L,-2);
7669lua_setfield(L,-2,"__index");
7670lua_pop(L,1);
7671}
7672static int luaopen_string(lua_State*L){
7673luaL_register(L,"string",strlib);
7674createmetatable(L);
7675return 1;
7676}
7677static const luaL_Reg lualibs[]={
7678{"",luaopen_base},
7679{"table",luaopen_table},
7680{"io",luaopen_io},
7681{"os",luaopen_os},
7682{"string",luaopen_string},
7683{NULL,NULL}
7684};
7685static void luaL_openlibs(lua_State*L){
7686const luaL_Reg*lib=lualibs;
7687for(;lib->func;lib++){
7688lua_pushcfunction(L,lib->func);
7689lua_pushstring(L,lib->name);
7690lua_call(L,1,0);
7691}
7692}
7693typedef unsigned int UB;
7694static UB barg(lua_State*L,int idx){
7695union{lua_Number n;U64 b;}bn;
7696bn.n=lua_tonumber(L,idx)+6755399441055744.0;
7697if(bn.n==0.0&&!lua_isnumber(L,idx))luaL_typerror(L,idx,"number");
7698return(UB)bn.b;
7699}
7700#define BRET(b)lua_pushnumber(L,(lua_Number)(int)(b));return 1;
7701static int tobit(lua_State*L){
7702BRET(barg(L,1))}
7703static int bnot(lua_State*L){
7704BRET(~barg(L,1))}
7705static int band(lua_State*L){
7706int i;UB b=barg(L,1);for(i=lua_gettop(L);i>1;i--)b&=barg(L,i);BRET(b)}
7707static int bor(lua_State*L){
7708int i;UB b=barg(L,1);for(i=lua_gettop(L);i>1;i--)b|=barg(L,i);BRET(b)}
7709static int bxor(lua_State*L){
7710int i;UB b=barg(L,1);for(i=lua_gettop(L);i>1;i--)b^=barg(L,i);BRET(b)}
7711static int lshift(lua_State*L){
7712UB b=barg(L,1),n=barg(L,2)&31;BRET(b<<n)}
7713static int rshift(lua_State*L){
7714UB b=barg(L,1),n=barg(L,2)&31;BRET(b>>n)}
7715static int arshift(lua_State*L){
7716UB b=barg(L,1),n=barg(L,2)&31;BRET((int)b>>n)}
7717static int rol(lua_State*L){
7718UB b=barg(L,1),n=barg(L,2)&31;BRET((b<<n)|(b>>(32-n)))}
7719static int ror(lua_State*L){
7720UB b=barg(L,1),n=barg(L,2)&31;BRET((b>>n)|(b<<(32-n)))}
7721static int bswap(lua_State*L){
7722UB b=barg(L,1);b=(b>>24)|((b>>8)&0xff00)|((b&0xff00)<<8)|(b<<24);BRET(b)}
7723static int tohex(lua_State*L){
7724UB b=barg(L,1);
7725UB n=lua_isnone(L,2)?8:barg(L,2);
7726const char*hexdigits="0123456789abcdef";
7727char buf[8];
7728int i;
7729if((int)n<0){n=~n+1;hexdigits="0123456789ABCDEF";}
7730if(n>8)n=8;
7731for(i=(int)n;--i>=0;){buf[i]=hexdigits[b&15];b>>=4;}
7732lua_pushlstring(L,buf,(size_t)n);
7733return 1;
7734}
7735static const struct luaL_Reg bitlib[]={
7736{"tobit",tobit},
7737{"bnot",bnot},
7738{"band",band},
7739{"bor",bor},
7740{"bxor",bxor},
7741{"lshift",lshift},
7742{"rshift",rshift},
7743{"arshift",arshift},
7744{"rol",rol},
7745{"ror",ror},
7746{"bswap",bswap},
7747{"tohex",tohex},
7748{NULL,NULL}
7749};
7750int main(int argc,char**argv){
7751lua_State*L=luaL_newstate();
7752int i;
7753luaL_openlibs(L);
7754luaL_register(L,"bit",bitlib);
7755if(argc<2)return sizeof(void*);
7756lua_createtable(L,0,1);
7757lua_pushstring(L,argv[1]);
7758lua_rawseti(L,-2,0);
7759lua_setglobal(L,"arg");
7760if(luaL_loadfile(L,argv[1]))
7761goto err;
7762for(i=2;i<argc;i++)
7763lua_pushstring(L,argv[i]);
7764if(lua_pcall(L,argc-2,0,0)){
7765err:
7766fprintf(stderr,"Error: %s\n",lua_tostring(L,-1));
7767return 1;
7768}
7769lua_close(L);
7770return 0;
7771}