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