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.
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:
14 * The above copyright notice and this permission notice shall be
15 * included in all copies or substantial portions of the Software.
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 ******************************************************************************/
26 typedef unsigned __int64 U64
;
28 typedef unsigned long long U64
;
62 enum OpMode
{iABC
,iABx
,iAsBx
};
128 TK_DO
,TK_ELSE
,TK_ELSEIF
,TK_END
,TK_FALSE
,TK_FOR
,TK_FUNCTION
,
129 TK_IF
,TK_IN
,TK_LOCAL
,TK_NIL
,TK_NOT
,TK_OR
,TK_REPEAT
,
130 TK_RETURN
,TK_THEN
,TK_TRUE
,TK_UNTIL
,TK_WHILE
,
131 TK_CONCAT
,TK_DOTS
,TK_EQ
,TK_GE
,TK_LE
,TK_NE
,TK_NUMBER
,
132 TK_NAME
,TK_STRING
,TK_EOS
135 OPR_ADD
,OPR_SUB
,OPR_MUL
,OPR_DIV
,OPR_MOD
,OPR_POW
,
138 OPR_LT
,OPR_LE
,OPR_GT
,OPR_GE
,
142 typedef enum UnOpr
{OPR_MINUS
,OPR_NOT
,OPR_LEN
,OPR_NOUNOPR
}UnOpr
;
143 #define LUA_QL(x)"'"x"'"
144 #define luai_apicheck(L,o){(void)L;}
145 #define lua_number2str(s,n)sprintf((s),"%.14g",(n))
146 #define lua_str2number(s,p)strtod((s),(p))
147 #define luai_numadd(a,b)((a)+(b))
148 #define luai_numsub(a,b)((a)-(b))
149 #define luai_nummul(a,b)((a)*(b))
150 #define luai_numdiv(a,b)((a)/(b))
151 #define luai_nummod(a,b)((a)-floor((a)/(b))*(b))
152 #define luai_numpow(a,b)(pow(a,b))
153 #define luai_numunm(a)(-(a))
154 #define luai_numeq(a,b)((a)==(b))
155 #define luai_numlt(a,b)((a)<(b))
156 #define luai_numle(a,b)((a)<=(b))
157 #define luai_numisnan(a)(!luai_numeq((a),(a)))
158 #define lua_number2int(i,d)((i)=(int)(d))
159 #define lua_number2integer(i,d)((i)=(lua_Integer)(d))
160 #define LUAI_THROW(L,c)longjmp((c)->b,1)
161 #define LUAI_TRY(L,c,a)if(setjmp((c)->b)==0){a}
162 #define lua_pclose(L,file)((void)((void)L,file),0)
163 #define lua_upvalueindex(i)((-10002)-(i))
164 typedef struct lua_State lua_State
;
165 typedef int(*lua_CFunction
)(lua_State
*L
);
166 typedef const char*(*lua_Reader
)(lua_State
*L
,void*ud
,size_t*sz
);
167 typedef void*(*lua_Alloc
)(void*ud
,void*ptr
,size_t osize
,size_t nsize
);
168 typedef double lua_Number
;
169 typedef ptrdiff_t lua_Integer
;
170 static void lua_settop(lua_State
*L
,int idx
);
171 static int lua_type(lua_State
*L
,int idx
);
172 static const char* lua_tolstring(lua_State
*L
,int idx
,size_t*len
);
173 static size_t lua_objlen(lua_State
*L
,int idx
);
174 static void lua_pushlstring(lua_State
*L
,const char*s
,size_t l
);
175 static void lua_pushcclosure(lua_State
*L
,lua_CFunction fn
,int n
);
176 static void lua_createtable(lua_State
*L
,int narr
,int nrec
);
177 static void lua_setfield(lua_State
*L
,int idx
,const char*k
);
178 #define lua_pop(L,n)lua_settop(L,-(n)-1)
179 #define lua_newtable(L)lua_createtable(L,0,0)
180 #define lua_pushcfunction(L,f)lua_pushcclosure(L,(f),0)
181 #define lua_strlen(L,i)lua_objlen(L,(i))
182 #define lua_isfunction(L,n)(lua_type(L,(n))==6)
183 #define lua_istable(L,n)(lua_type(L,(n))==5)
184 #define lua_isnil(L,n)(lua_type(L,(n))==0)
185 #define lua_isboolean(L,n)(lua_type(L,(n))==1)
186 #define lua_isnone(L,n)(lua_type(L,(n))==(-1))
187 #define lua_isnoneornil(L,n)(lua_type(L,(n))<=0)
188 #define lua_pushliteral(L,s)lua_pushlstring(L,""s,(sizeof(s)/sizeof(char))-1)
189 #define lua_setglobal(L,s)lua_setfield(L,(-10002),(s))
190 #define lua_tostring(L,i)lua_tolstring(L,(i),NULL)
191 typedef struct lua_Debug lua_Debug
;
192 typedef void(*lua_Hook
)(lua_State
*L
,lua_Debug
*ar
);
206 typedef unsigned int lu_int32
;
207 typedef size_t lu_mem
;
208 typedef ptrdiff_t l_mem
;
209 typedef unsigned char lu_byte
;
210 #define IntPoint(p)((unsigned int)(lu_mem)(p))
211 typedef union{double u
;void*s
;long l
;}L_Umaxalign
;
212 typedef double l_uacNumber
;
213 #define check_exp(c,e)(e)
214 #define UNUSED(x)((void)(x))
215 #define cast(t,exp)((t)(exp))
216 #define cast_byte(i)cast(lu_byte,(i))
217 #define cast_num(i)cast(lua_Number,(i))
218 #define cast_int(i)cast(int,(i))
219 typedef lu_int32 Instruction
;
220 #define condhardstacktests(x)((void)0)
221 typedef union GCObject GCObject
;
222 typedef struct GCheader
{
223 GCObject
*next
;lu_byte tt
;lu_byte marked
;
231 typedef struct lua_TValue
{
234 #define ttisnil(o)(ttype(o)==0)
235 #define ttisnumber(o)(ttype(o)==3)
236 #define ttisstring(o)(ttype(o)==4)
237 #define ttistable(o)(ttype(o)==5)
238 #define ttisfunction(o)(ttype(o)==6)
239 #define ttisboolean(o)(ttype(o)==1)
240 #define ttisuserdata(o)(ttype(o)==7)
241 #define ttisthread(o)(ttype(o)==8)
242 #define ttislightuserdata(o)(ttype(o)==2)
243 #define ttype(o)((o)->tt)
244 #define gcvalue(o)check_exp(iscollectable(o),(o)->value.gc)
245 #define pvalue(o)check_exp(ttislightuserdata(o),(o)->value.p)
246 #define nvalue(o)check_exp(ttisnumber(o),(o)->value.n)
247 #define rawtsvalue(o)check_exp(ttisstring(o),&(o)->value.gc->ts)
248 #define tsvalue(o)(&rawtsvalue(o)->tsv)
249 #define rawuvalue(o)check_exp(ttisuserdata(o),&(o)->value.gc->u)
250 #define uvalue(o)(&rawuvalue(o)->uv)
251 #define clvalue(o)check_exp(ttisfunction(o),&(o)->value.gc->cl)
252 #define hvalue(o)check_exp(ttistable(o),&(o)->value.gc->h)
253 #define bvalue(o)check_exp(ttisboolean(o),(o)->value.b)
254 #define thvalue(o)check_exp(ttisthread(o),&(o)->value.gc->th)
255 #define l_isfalse(o)(ttisnil(o)||(ttisboolean(o)&&bvalue(o)==0))
256 #define checkconsistency(obj)
257 #define checkliveness(g,obj)
258 #define setnilvalue(obj)((obj)->tt=0)
259 #define setnvalue(obj,x){TValue*i_o=(obj);i_o->value.n=(x);i_o->tt=3;}
260 #define setbvalue(obj,x){TValue*i_o=(obj);i_o->value.b=(x);i_o->tt=1;}
261 #define setsvalue(L,obj,x){TValue*i_o=(obj);i_o->value.gc=cast(GCObject*,(x));i_o->tt=4;checkliveness(G(L),i_o);}
262 #define setuvalue(L,obj,x){TValue*i_o=(obj);i_o->value.gc=cast(GCObject*,(x));i_o->tt=7;checkliveness(G(L),i_o);}
263 #define setthvalue(L,obj,x){TValue*i_o=(obj);i_o->value.gc=cast(GCObject*,(x));i_o->tt=8;checkliveness(G(L),i_o);}
264 #define setclvalue(L,obj,x){TValue*i_o=(obj);i_o->value.gc=cast(GCObject*,(x));i_o->tt=6;checkliveness(G(L),i_o);}
265 #define sethvalue(L,obj,x){TValue*i_o=(obj);i_o->value.gc=cast(GCObject*,(x));i_o->tt=5;checkliveness(G(L),i_o);}
266 #define setptvalue(L,obj,x){TValue*i_o=(obj);i_o->value.gc=cast(GCObject*,(x));i_o->tt=(8+1);checkliveness(G(L),i_o);}
267 #define setobj(L,obj1,obj2){const TValue*o2=(obj2);TValue*o1=(obj1);o1->value=o2->value;o1->tt=o2->tt;checkliveness(G(L),o1);}
268 #define setttype(obj,tt)(ttype(obj)=(tt))
269 #define iscollectable(o)(ttype(o)>=4)
270 typedef TValue
*StkId
;
271 typedef union TString
{
274 GCObject
*next
;lu_byte tt
;lu_byte marked
;
280 #define getstr(ts)cast(const char*,(ts)+1)
281 #define svalue(o)getstr(rawtsvalue(o))
285 GCObject
*next
;lu_byte tt
;lu_byte marked
;
286 struct Table
*metatable
;
291 typedef struct Proto
{
292 GCObject
*next
;lu_byte tt
;lu_byte marked
;
297 struct LocVar
*locvars
;
312 lu_byte maxstacksize
;
314 typedef struct LocVar
{
319 typedef struct UpVal
{
320 GCObject
*next
;lu_byte tt
;lu_byte marked
;
330 typedef struct CClosure
{
331 GCObject
*next
;lu_byte tt
;lu_byte marked
;lu_byte isC
;lu_byte nupvalues
;GCObject
*gclist
;struct Table
*env
;
335 typedef struct LClosure
{
336 GCObject
*next
;lu_byte tt
;lu_byte marked
;lu_byte isC
;lu_byte nupvalues
;GCObject
*gclist
;struct Table
*env
;
340 typedef union Closure
{
344 #define iscfunction(o)(ttype(o)==6&&clvalue(o)->c.isC)
356 typedef struct Table
{
357 GCObject
*next
;lu_byte tt
;lu_byte marked
;
360 struct Table
*metatable
;
367 #define lmod(s,size)(check_exp((size&(size-1))==0,(cast(int,(s)&((size)-1)))))
368 #define twoto(x)((size_t)1<<(x))
369 #define sizenode(t)(twoto((t)->lsizenode))
370 static const TValue luaO_nilobject_
;
371 #define ceillog2(x)(luaO_log2((x)-1)+1)
372 static int luaO_log2(unsigned int x
);
373 #define gfasttm(g,et,e)((et)==NULL?NULL:((et)->flags&(1u<<(e)))?NULL:luaT_gettm(et,e,(g)->tmname[e]))
374 #define fasttm(l,et,e)gfasttm(G(l),et,e)
375 static const TValue
*luaT_gettm(Table
*events
,TMS event
,TString
*ename
);
376 #define luaM_reallocv(L,b,on,n,e)((cast(size_t,(n)+1)<=((size_t)(~(size_t)0)-2)/(e))?luaM_realloc_(L,(b),(on)*(e),(n)*(e)):luaM_toobig(L))
377 #define luaM_freemem(L,b,s)luaM_realloc_(L,(b),(s),0)
378 #define luaM_free(L,b)luaM_realloc_(L,(b),sizeof(*(b)),0)
379 #define luaM_freearray(L,b,n,t)luaM_reallocv(L,(b),n,0,sizeof(t))
380 #define luaM_malloc(L,t)luaM_realloc_(L,NULL,0,(t))
381 #define luaM_new(L,t)cast(t*,luaM_malloc(L,sizeof(t)))
382 #define luaM_newvector(L,n,t)cast(t*,luaM_reallocv(L,NULL,0,n,sizeof(t)))
383 #define luaM_growvector(L,v,nelems,size,t,limit,e)if((nelems)+1>(size))((v)=cast(t*,luaM_growaux_(L,v,&(size),sizeof(t),limit,e)))
384 #define luaM_reallocvector(L,v,oldn,n,t)((v)=cast(t*,luaM_reallocv(L,v,oldn,n,sizeof(t))))
385 static void*luaM_realloc_(lua_State
*L
,void*block
,size_t oldsize
,
387 static void*luaM_toobig(lua_State
*L
);
388 static void*luaM_growaux_(lua_State
*L
,void*block
,int*size
,
389 size_t size_elem
,int limit
,
390 const char*errormsg
);
391 typedef struct Zio ZIO
;
392 #define char2int(c)cast(int,cast(unsigned char,(c)))
393 #define zgetc(z)(((z)->n--)>0?char2int(*(z)->p++):luaZ_fill(z))
394 typedef struct Mbuffer
{
399 #define luaZ_initbuffer(L,buff)((buff)->buffer=NULL,(buff)->buffsize=0)
400 #define luaZ_buffer(buff)((buff)->buffer)
401 #define luaZ_sizebuffer(buff)((buff)->buffsize)
402 #define luaZ_bufflen(buff)((buff)->n)
403 #define luaZ_resetbuffer(buff)((buff)->n=0)
404 #define luaZ_resizebuffer(L,buff,size)(luaM_reallocvector(L,(buff)->buffer,(buff)->buffsize,size,char),(buff)->buffsize=size)
405 #define luaZ_freebuffer(L,buff)luaZ_resizebuffer(L,buff,0)
413 static int luaZ_fill(ZIO
*z
);
415 #define gt(L)(&L->l_gt)
416 #define registry(L)(&G(L)->l_registry)
417 typedef struct stringtable
{
422 typedef struct CallInfo
{
426 const Instruction
*savedpc
;
430 #define curr_func(L)(clvalue(L->ci->func))
431 #define ci_func(ci)(clvalue((ci)->func))
432 #define f_isLua(ci)(!ci_func(ci)->c.isC)
433 #define isLua(ci)(ttisfunction((ci)->func)&&f_isLua(ci))
434 typedef struct global_State
{
438 lu_byte currentwhite
;
456 struct lua_State
*mainthread
;
458 struct Table
*mt
[(8+1)];
459 TString
*tmname
[TM_N
];
462 GCObject
*next
;lu_byte tt
;lu_byte marked
;
468 const Instruction
*savedpc
;
475 unsigned short nCcalls
;
476 unsigned short baseCcalls
;
486 struct lua_longjmp
*errorJmp
;
500 #define rawgco2ts(o)check_exp((o)->gch.tt==4,&((o)->ts))
501 #define gco2ts(o)(&rawgco2ts(o)->tsv)
502 #define rawgco2u(o)check_exp((o)->gch.tt==7,&((o)->u))
503 #define gco2u(o)(&rawgco2u(o)->uv)
504 #define gco2cl(o)check_exp((o)->gch.tt==6,&((o)->cl))
505 #define gco2h(o)check_exp((o)->gch.tt==5,&((o)->h))
506 #define gco2p(o)check_exp((o)->gch.tt==(8+1),&((o)->p))
507 #define gco2uv(o)check_exp((o)->gch.tt==(8+2),&((o)->uv))
508 #define ngcotouv(o)check_exp((o)==NULL||(o)->gch.tt==(8+2),&((o)->uv))
509 #define gco2th(o)check_exp((o)->gch.tt==8,&((o)->th))
510 #define obj2gco(v)(cast(GCObject*,(v)))
511 static void luaE_freethread(lua_State
*L
,lua_State
*L1
);
512 #define pcRel(pc,p)(cast(int,(pc)-(p)->code)-1)
513 #define getline_(f,pc)(((f)->lineinfo)?(f)->lineinfo[pc]:0)
514 #define resethookcount(L)(L->hookcount=L->basehookcount)
515 static void luaG_typeerror(lua_State
*L
,const TValue
*o
,
517 static void luaG_runerror(lua_State
*L
,const char*fmt
,...);
518 #define luaD_checkstack(L,n)if((char*)L->stack_last-(char*)L->top<=(n)*(int)sizeof(TValue))luaD_growstack(L,n);else condhardstacktests(luaD_reallocstack(L,L->stacksize-5-1));
519 #define incr_top(L){luaD_checkstack(L,1);L->top++;}
520 #define savestack(L,p)((char*)(p)-(char*)L->stack)
521 #define restorestack(L,n)((TValue*)((char*)L->stack+(n)))
522 #define saveci(L,p)((char*)(p)-(char*)L->base_ci)
523 #define restoreci(L,n)((CallInfo*)((char*)L->base_ci+(n)))
524 typedef void(*Pfunc
)(lua_State
*L
,void*ud
);
525 static int luaD_poscall(lua_State
*L
,StkId firstResult
);
526 static void luaD_reallocCI(lua_State
*L
,int newsize
);
527 static void luaD_reallocstack(lua_State
*L
,int newsize
);
528 static void luaD_growstack(lua_State
*L
,int n
);
529 static void luaD_throw(lua_State
*L
,int errcode
);
530 static void*luaM_growaux_(lua_State
*L
,void*block
,int*size
,size_t size_elems
,
531 int limit
,const char*errormsg
){
536 luaG_runerror(L
,errormsg
);
544 newblock
=luaM_reallocv(L
,block
,*size
,newsize
,size_elems
);
548 static void*luaM_toobig(lua_State
*L
){
549 luaG_runerror(L
,"memory allocation error: block too big");
552 static void*luaM_realloc_(lua_State
*L
,void*block
,size_t osize
,size_t nsize
){
554 block
=(*g
->frealloc
)(g
->ud
,block
,osize
,nsize
);
555 if(block
==NULL
&&nsize
>0)
557 g
->totalbytes
=(g
->totalbytes
-osize
)+nsize
;
560 #define resetbits(x,m)((x)&=cast(lu_byte,~(m)))
561 #define setbits(x,m)((x)|=(m))
562 #define testbits(x,m)((x)&(m))
563 #define bitmask(b)(1<<(b))
564 #define bit2mask(b1,b2)(bitmask(b1)|bitmask(b2))
565 #define l_setbit(x,b)setbits(x,bitmask(b))
566 #define resetbit(x,b)resetbits(x,bitmask(b))
567 #define testbit(x,b)testbits(x,bitmask(b))
568 #define set2bits(x,b1,b2)setbits(x,(bit2mask(b1,b2)))
569 #define reset2bits(x,b1,b2)resetbits(x,(bit2mask(b1,b2)))
570 #define test2bits(x,b1,b2)testbits(x,(bit2mask(b1,b2)))
571 #define iswhite(x)test2bits((x)->gch.marked,0,1)
572 #define isblack(x)testbit((x)->gch.marked,2)
573 #define isgray(x)(!isblack(x)&&!iswhite(x))
574 #define otherwhite(g)(g->currentwhite^bit2mask(0,1))
575 #define isdead(g,v)((v)->gch.marked&otherwhite(g)&bit2mask(0,1))
576 #define changewhite(x)((x)->gch.marked^=bit2mask(0,1))
577 #define gray2black(x)l_setbit((x)->gch.marked,2)
578 #define valiswhite(x)(iscollectable(x)&&iswhite(gcvalue(x)))
579 #define luaC_white(g)cast(lu_byte,(g)->currentwhite&bit2mask(0,1))
580 #define luaC_checkGC(L){condhardstacktests(luaD_reallocstack(L,L->stacksize-5-1));if(G(L)->totalbytes>=G(L)->GCthreshold)luaC_step(L);}
581 #define luaC_barrier(L,p,v){if(valiswhite(v)&&isblack(obj2gco(p)))luaC_barrierf(L,obj2gco(p),gcvalue(v));}
582 #define luaC_barriert(L,t,v){if(valiswhite(v)&&isblack(obj2gco(t)))luaC_barrierback(L,t);}
583 #define luaC_objbarrier(L,p,o){if(iswhite(obj2gco(o))&&isblack(obj2gco(p)))luaC_barrierf(L,obj2gco(p),obj2gco(o));}
584 #define luaC_objbarriert(L,t,o){if(iswhite(obj2gco(o))&&isblack(obj2gco(t)))luaC_barrierback(L,t);}
585 static void luaC_step(lua_State
*L
);
586 static void luaC_link(lua_State
*L
,GCObject
*o
,lu_byte tt
);
587 static void luaC_linkupval(lua_State
*L
,UpVal
*uv
);
588 static void luaC_barrierf(lua_State
*L
,GCObject
*o
,GCObject
*v
);
589 static void luaC_barrierback(lua_State
*L
,Table
*t
);
590 #define sizestring(s)(sizeof(union TString)+((s)->len+1)*sizeof(char))
591 #define sizeudata(u)(sizeof(union Udata)+(u)->len)
592 #define luaS_new(L,s)(luaS_newlstr(L,s,strlen(s)))
593 #define luaS_newliteral(L,s)(luaS_newlstr(L,""s,(sizeof(s)/sizeof(char))-1))
594 #define luaS_fix(s)l_setbit((s)->tsv.marked,5)
595 static TString
*luaS_newlstr(lua_State
*L
,const char*str
,size_t l
);
596 #define tostring(L,o)((ttype(o)==4)||(luaV_tostring(L,o)))
597 #define tonumber(o,n)(ttype(o)==3||(((o)=luaV_tonumber(o,n))!=NULL))
598 #define equalobj(L,o1,o2)(ttype(o1)==ttype(o2)&&luaV_equalval(L,o1,o2))
599 static int luaV_equalval(lua_State
*L
,const TValue
*t1
,const TValue
*t2
);
600 static const TValue
*luaV_tonumber(const TValue
*obj
,TValue
*n
);
601 static int luaV_tostring(lua_State
*L
,StkId obj
);
602 static void luaV_execute(lua_State
*L
,int nexeccalls
);
603 static void luaV_concat(lua_State
*L
,int total
,int last
);
604 static const TValue luaO_nilobject_
={{NULL
},0};
605 static int luaO_int2fb(unsigned int x
){
612 else return((e
+1)<<3)|(cast_int(x
)-8);
614 static int luaO_fb2int(int x
){
617 else return((x
&7)+8)<<(e
-1);
619 static int luaO_log2(unsigned int x
){
620 static const lu_byte log_2
[256]={
621 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,
622 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,
623 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,
624 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,
625 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,
626 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,
627 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,
628 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
631 while(x
>=256){l
+=8;x
>>=8;}
634 static int luaO_rawequalObj(const TValue
*t1
,const TValue
*t2
){
635 if(ttype(t1
)!=ttype(t2
))return 0;
636 else switch(ttype(t1
)){
640 return luai_numeq(nvalue(t1
),nvalue(t2
));
642 return bvalue(t1
)==bvalue(t2
);
644 return pvalue(t1
)==pvalue(t2
);
646 return gcvalue(t1
)==gcvalue(t2
);
649 static int luaO_str2d(const char*s
,lua_Number
*result
){
651 *result
=lua_str2number(s
,&endptr
);
652 if(endptr
==s
)return 0;
653 if(*endptr
=='x'||*endptr
=='X')
654 *result
=cast_num(strtoul(s
,&endptr
,16));
655 if(*endptr
=='\0')return 1;
656 while(isspace(cast(unsigned char,*endptr
)))endptr
++;
657 if(*endptr
!='\0')return 0;
660 static void pushstr(lua_State
*L
,const char*str
){
661 setsvalue(L
,L
->top
,luaS_new(L
,str
));
664 static const char*luaO_pushvfstring(lua_State
*L
,const char*fmt
,va_list argp
){
668 const char*e
=strchr(fmt
,'%');
670 setsvalue(L
,L
->top
,luaS_newlstr(L
,fmt
,e
-fmt
));
674 const char*s
=va_arg(argp
,char*);
675 if(s
==NULL
)s
="(null)";
681 buff
[0]=cast(char,va_arg(argp
,int));
687 setnvalue(L
->top
,cast_num(va_arg(argp
,int)));
692 setnvalue(L
->top
,cast_num(va_arg(argp
,l_uacNumber
)));
697 char buff
[4*sizeof(void*)+8];
698 sprintf(buff
,"%p",va_arg(argp
,void*));
719 luaV_concat(L
,n
+1,cast_int(L
->top
-L
->base
)-1);
721 return svalue(L
->top
-1);
723 static const char*luaO_pushfstring(lua_State
*L
,const char*fmt
,...){
727 msg
=luaO_pushvfstring(L
,fmt
,argp
);
731 static void luaO_chunkid(char*out
,const char*source
,size_t bufflen
){
733 strncpy(out
,source
+1,bufflen
);
740 bufflen
-=sizeof(" '...' ");
750 size_t len
=strcspn(source
,"\n\r");
751 bufflen
-=sizeof(" [string \"...\"] ");
752 if(len
>bufflen
)len
=bufflen
;
753 strcpy(out
,"[string \"");
754 if(source
[len
]!='\0'){
755 strncat(out
,source
,len
);
764 #define gnode(t,i)(&(t)->node[i])
765 #define gkey(n)(&(n)->i_key.nk)
766 #define gval(n)(&(n)->i_val)
767 #define gnext(n)((n)->i_key.nk.next)
768 #define key2tval(n)(&(n)->i_key.tvk)
769 static TValue
*luaH_setnum(lua_State
*L
,Table
*t
,int key
);
770 static const TValue
*luaH_getstr(Table
*t
,TString
*key
);
771 static TValue
*luaH_set(lua_State
*L
,Table
*t
,const TValue
*key
);
772 static const char*const luaT_typenames
[]={
773 "nil","boolean","userdata","number",
774 "string","table","function","userdata","thread",
777 static void luaT_init(lua_State
*L
){
778 static const char*const luaT_eventname
[]={
779 "__index","__newindex",
780 "__gc","__mode","__eq",
781 "__add","__sub","__mul","__div","__mod",
782 "__pow","__unm","__len","__lt","__le",
787 G(L
)->tmname
[i
]=luaS_new(L
,luaT_eventname
[i
]);
788 luaS_fix(G(L
)->tmname
[i
]);
791 static const TValue
*luaT_gettm(Table
*events
,TMS event
,TString
*ename
){
792 const TValue
*tm
=luaH_getstr(events
,ename
);
794 events
->flags
|=cast_byte(1u<<event
);
799 static const TValue
*luaT_gettmbyobj(lua_State
*L
,const TValue
*o
,TMS event
){
803 mt
=hvalue(o
)->metatable
;
806 mt
=uvalue(o
)->metatable
;
809 mt
=G(L
)->mt
[ttype(o
)];
811 return(mt
?luaH_getstr(mt
,G(L
)->tmname
[event
]):(&luaO_nilobject_
));
813 #define sizeCclosure(n)(cast(int,sizeof(CClosure))+cast(int,sizeof(TValue)*((n)-1)))
814 #define sizeLclosure(n)(cast(int,sizeof(LClosure))+cast(int,sizeof(TValue*)*((n)-1)))
815 static Closure
*luaF_newCclosure(lua_State
*L
,int nelems
,Table
*e
){
816 Closure
*c
=cast(Closure
*,luaM_malloc(L
,sizeCclosure(nelems
)));
817 luaC_link(L
,obj2gco(c
),6);
820 c
->c
.nupvalues
=cast_byte(nelems
);
823 static Closure
*luaF_newLclosure(lua_State
*L
,int nelems
,Table
*e
){
824 Closure
*c
=cast(Closure
*,luaM_malloc(L
,sizeLclosure(nelems
)));
825 luaC_link(L
,obj2gco(c
),6);
828 c
->l
.nupvalues
=cast_byte(nelems
);
829 while(nelems
--)c
->l
.upvals
[nelems
]=NULL
;
832 static UpVal
*luaF_newupval(lua_State
*L
){
833 UpVal
*uv
=luaM_new(L
,UpVal
);
834 luaC_link(L
,obj2gco(uv
),(8+2));
839 static UpVal
*luaF_findupval(lua_State
*L
,StkId level
){
841 GCObject
**pp
=&L
->openupval
;
844 while(*pp
!=NULL
&&(p
=ngcotouv(*pp
))->v
>=level
){
846 if(isdead(g
,obj2gco(p
)))
847 changewhite(obj2gco(p
));
852 uv
=luaM_new(L
,UpVal
);
854 uv
->marked
=luaC_white(g
);
858 uv
->u
.l
.prev
=&g
->uvhead
;
859 uv
->u
.l
.next
=g
->uvhead
.u
.l
.next
;
860 uv
->u
.l
.next
->u
.l
.prev
=uv
;
861 g
->uvhead
.u
.l
.next
=uv
;
864 static void unlinkupval(UpVal
*uv
){
865 uv
->u
.l
.next
->u
.l
.prev
=uv
->u
.l
.prev
;
866 uv
->u
.l
.prev
->u
.l
.next
=uv
->u
.l
.next
;
868 static void luaF_freeupval(lua_State
*L
,UpVal
*uv
){
869 if(uv
->v
!=&uv
->u
.value
)
873 static void luaF_close(lua_State
*L
,StkId level
){
876 while(L
->openupval
!=NULL
&&(uv
=ngcotouv(L
->openupval
))->v
>=level
){
877 GCObject
*o
=obj2gco(uv
);
878 L
->openupval
=uv
->next
;
880 luaF_freeupval(L
,uv
);
883 setobj(L
,&uv
->u
.value
,uv
->v
);
885 luaC_linkupval(L
,uv
);
889 static Proto
*luaF_newproto(lua_State
*L
){
890 Proto
*f
=luaM_new(L
,Proto
);
891 luaC_link(L
,obj2gco(f
),(8+1));
909 f
->lastlinedefined
=0;
913 static void luaF_freeproto(lua_State
*L
,Proto
*f
){
914 luaM_freearray(L
,f
->code
,f
->sizecode
,Instruction
);
915 luaM_freearray(L
,f
->p
,f
->sizep
,Proto
*);
916 luaM_freearray(L
,f
->k
,f
->sizek
,TValue
);
917 luaM_freearray(L
,f
->lineinfo
,f
->sizelineinfo
,int);
918 luaM_freearray(L
,f
->locvars
,f
->sizelocvars
,struct LocVar
);
919 luaM_freearray(L
,f
->upvalues
,f
->sizeupvalues
,TString
*);
922 static void luaF_freeclosure(lua_State
*L
,Closure
*c
){
923 int size
=(c
->c
.isC
)?sizeCclosure(c
->c
.nupvalues
):
924 sizeLclosure(c
->l
.nupvalues
);
925 luaM_freemem(L
,c
,size
);
927 #define MASK1(n,p)((~((~(Instruction)0)<<n))<<p)
928 #define MASK0(n,p)(~MASK1(n,p))
929 #define GET_OPCODE(i)(cast(OpCode,((i)>>0)&MASK1(6,0)))
930 #define SET_OPCODE(i,o)((i)=(((i)&MASK0(6,0))|((cast(Instruction,o)<<0)&MASK1(6,0))))
931 #define GETARG_A(i)(cast(int,((i)>>(0+6))&MASK1(8,0)))
932 #define SETARG_A(i,u)((i)=(((i)&MASK0(8,(0+6)))|((cast(Instruction,u)<<(0+6))&MASK1(8,(0+6)))))
933 #define GETARG_B(i)(cast(int,((i)>>(((0+6)+8)+9))&MASK1(9,0)))
934 #define SETARG_B(i,b)((i)=(((i)&MASK0(9,(((0+6)+8)+9)))|((cast(Instruction,b)<<(((0+6)+8)+9))&MASK1(9,(((0+6)+8)+9)))))
935 #define GETARG_C(i)(cast(int,((i)>>((0+6)+8))&MASK1(9,0)))
936 #define SETARG_C(i,b)((i)=(((i)&MASK0(9,((0+6)+8)))|((cast(Instruction,b)<<((0+6)+8))&MASK1(9,((0+6)+8)))))
937 #define GETARG_Bx(i)(cast(int,((i)>>((0+6)+8))&MASK1((9+9),0)))
938 #define SETARG_Bx(i,b)((i)=(((i)&MASK0((9+9),((0+6)+8)))|((cast(Instruction,b)<<((0+6)+8))&MASK1((9+9),((0+6)+8)))))
939 #define GETARG_sBx(i)(GETARG_Bx(i)-(((1<<(9+9))-1)>>1))
940 #define SETARG_sBx(i,b)SETARG_Bx((i),cast(unsigned int,(b)+(((1<<(9+9))-1)>>1)))
941 #define CREATE_ABC(o,a,b,c)((cast(Instruction,o)<<0)|(cast(Instruction,a)<<(0+6))|(cast(Instruction,b)<<(((0+6)+8)+9))|(cast(Instruction,c)<<((0+6)+8)))
942 #define CREATE_ABx(o,a,bc)((cast(Instruction,o)<<0)|(cast(Instruction,a)<<(0+6))|(cast(Instruction,bc)<<((0+6)+8)))
943 #define ISK(x)((x)&(1<<(9-1)))
944 #define INDEXK(r)((int)(r)&~(1<<(9-1)))
945 #define RKASK(x)((x)|(1<<(9-1)))
946 static const lu_byte luaP_opmodes
[(cast(int,OP_VARARG
)+1)];
947 #define getBMode(m)(cast(enum OpArgMask,(luaP_opmodes[m]>>4)&3))
948 #define getCMode(m)(cast(enum OpArgMask,(luaP_opmodes[m]>>2)&3))
949 #define testTMode(m)(luaP_opmodes[m]&(1<<7))
950 typedef struct expdesc
{
953 struct{int info
,aux
;}s
;
959 typedef struct upvaldesc
{
964 typedef struct FuncState
{
967 struct FuncState
*prev
;
979 upvaldesc upvalues
[60];
980 unsigned short actvar
[200];
982 static Proto
*luaY_parser(lua_State
*L
,ZIO
*z
,Mbuffer
*buff
,
985 struct lua_longjmp
*previous
;
989 static void luaD_seterrorobj(lua_State
*L
,int errcode
,StkId oldtop
){
992 setsvalue(L
,oldtop
,luaS_newliteral(L
,"not enough memory"));
996 setsvalue(L
,oldtop
,luaS_newliteral(L
,"error in error handling"));
1001 setobj(L
,oldtop
,L
->top
-1);
1007 static void restore_stack_limit(lua_State
*L
){
1008 if(L
->size_ci
>20000){
1009 int inuse
=cast_int(L
->ci
-L
->base_ci
);
1011 luaD_reallocCI(L
,20000);
1014 static void resetstack(lua_State
*L
,int status
){
1016 L
->base
=L
->ci
->base
;
1017 luaF_close(L
,L
->base
);
1018 luaD_seterrorobj(L
,status
,L
->base
);
1019 L
->nCcalls
=L
->baseCcalls
;
1021 restore_stack_limit(L
);
1025 static void luaD_throw(lua_State
*L
,int errcode
){
1027 L
->errorJmp
->status
=errcode
;
1028 LUAI_THROW(L
,L
->errorJmp
);
1031 L
->status
=cast_byte(errcode
);
1033 resetstack(L
,errcode
);
1039 static int luaD_rawrunprotected(lua_State
*L
,Pfunc f
,void*ud
){
1040 struct lua_longjmp lj
;
1042 lj
.previous
=L
->errorJmp
;
1047 L
->errorJmp
=lj
.previous
;
1050 static void correctstack(lua_State
*L
,TValue
*oldstack
){
1053 L
->top
=(L
->top
-oldstack
)+L
->stack
;
1054 for(up
=L
->openupval
;up
!=NULL
;up
=up
->gch
.next
)
1055 gco2uv(up
)->v
=(gco2uv(up
)->v
-oldstack
)+L
->stack
;
1056 for(ci
=L
->base_ci
;ci
<=L
->ci
;ci
++){
1057 ci
->top
=(ci
->top
-oldstack
)+L
->stack
;
1058 ci
->base
=(ci
->base
-oldstack
)+L
->stack
;
1059 ci
->func
=(ci
->func
-oldstack
)+L
->stack
;
1061 L
->base
=(L
->base
-oldstack
)+L
->stack
;
1063 static void luaD_reallocstack(lua_State
*L
,int newsize
){
1064 TValue
*oldstack
=L
->stack
;
1065 int realsize
=newsize
+1+5;
1066 luaM_reallocvector(L
,L
->stack
,L
->stacksize
,realsize
,TValue
);
1067 L
->stacksize
=realsize
;
1068 L
->stack_last
=L
->stack
+newsize
;
1069 correctstack(L
,oldstack
);
1071 static void luaD_reallocCI(lua_State
*L
,int newsize
){
1072 CallInfo
*oldci
=L
->base_ci
;
1073 luaM_reallocvector(L
,L
->base_ci
,L
->size_ci
,newsize
,CallInfo
);
1075 L
->ci
=(L
->ci
-oldci
)+L
->base_ci
;
1076 L
->end_ci
=L
->base_ci
+L
->size_ci
-1;
1078 static void luaD_growstack(lua_State
*L
,int n
){
1080 luaD_reallocstack(L
,2*L
->stacksize
);
1082 luaD_reallocstack(L
,L
->stacksize
+n
);
1084 static CallInfo
*growCI(lua_State
*L
){
1085 if(L
->size_ci
>20000)
1088 luaD_reallocCI(L
,2*L
->size_ci
);
1089 if(L
->size_ci
>20000)
1090 luaG_runerror(L
,"stack overflow");
1094 static StkId
adjust_varargs(lua_State
*L
,Proto
*p
,int actual
){
1096 int nfixargs
=p
->numparams
;
1099 for(;actual
<nfixargs
;++actual
)
1100 setnilvalue(L
->top
++);
1101 fixed
=L
->top
-actual
;
1103 for(i
=0;i
<nfixargs
;i
++){
1104 setobj(L
,L
->top
++,fixed
+i
);
1105 setnilvalue(fixed
+i
);
1108 sethvalue(L
,L
->top
++,htab
);
1112 static StkId
tryfuncTM(lua_State
*L
,StkId func
){
1113 const TValue
*tm
=luaT_gettmbyobj(L
,func
,TM_CALL
);
1115 ptrdiff_t funcr
=savestack(L
,func
);
1116 if(!ttisfunction(tm
))
1117 luaG_typeerror(L
,func
,"call");
1118 for(p
=L
->top
;p
>func
;p
--)setobj(L
,p
,p
-1);
1120 func
=restorestack(L
,funcr
);
1124 #define inc_ci(L)((L->ci==L->end_ci)?growCI(L):(condhardstacktests(luaD_reallocCI(L,L->size_ci)),++L->ci))
1125 static int luaD_precall(lua_State
*L
,StkId func
,int nresults
){
1128 if(!ttisfunction(func
))
1129 func
=tryfuncTM(L
,func
);
1130 funcr
=savestack(L
,func
);
1131 cl
=&clvalue(func
)->l
;
1132 L
->ci
->savedpc
=L
->savedpc
;
1137 luaD_checkstack(L
,p
->maxstacksize
);
1138 func
=restorestack(L
,funcr
);
1141 if(L
->top
>base
+p
->numparams
)
1142 L
->top
=base
+p
->numparams
;
1145 int nargs
=cast_int(L
->top
-func
)-1;
1146 base
=adjust_varargs(L
,p
,nargs
);
1147 func
=restorestack(L
,funcr
);
1151 L
->base
=ci
->base
=base
;
1152 ci
->top
=L
->base
+p
->maxstacksize
;
1155 ci
->nresults
=nresults
;
1156 for(st
=L
->top
;st
<ci
->top
;st
++)
1164 luaD_checkstack(L
,20);
1166 ci
->func
=restorestack(L
,funcr
);
1167 L
->base
=ci
->base
=ci
->func
+1;
1169 ci
->nresults
=nresults
;
1170 n
=(*curr_func(L
)->c
.f
)(L
);
1174 luaD_poscall(L
,L
->top
-n
);
1179 static int luaD_poscall(lua_State
*L
,StkId firstResult
){
1185 wanted
=ci
->nresults
;
1186 L
->base
=(ci
-1)->base
;
1187 L
->savedpc
=(ci
-1)->savedpc
;
1188 for(i
=wanted
;i
!=0&&firstResult
<L
->top
;i
--)
1189 setobj(L
,res
++,firstResult
++);
1193 return(wanted
-(-1));
1195 static void luaD_call(lua_State
*L
,StkId func
,int nResults
){
1196 if(++L
->nCcalls
>=200){
1198 luaG_runerror(L
,"C stack overflow");
1199 else if(L
->nCcalls
>=(200+(200>>3)))
1202 if(luaD_precall(L
,func
,nResults
)==0)
1207 static int luaD_pcall(lua_State
*L
,Pfunc func
,void*u
,
1208 ptrdiff_t old_top
,ptrdiff_t ef
){
1210 unsigned short oldnCcalls
=L
->nCcalls
;
1211 ptrdiff_t old_ci
=saveci(L
,L
->ci
);
1212 lu_byte old_allowhooks
=L
->allowhook
;
1213 ptrdiff_t old_errfunc
=L
->errfunc
;
1215 status
=luaD_rawrunprotected(L
,func
,u
);
1217 StkId oldtop
=restorestack(L
,old_top
);
1218 luaF_close(L
,oldtop
);
1219 luaD_seterrorobj(L
,status
,oldtop
);
1220 L
->nCcalls
=oldnCcalls
;
1221 L
->ci
=restoreci(L
,old_ci
);
1222 L
->base
=L
->ci
->base
;
1223 L
->savedpc
=L
->ci
->savedpc
;
1224 L
->allowhook
=old_allowhooks
;
1225 restore_stack_limit(L
);
1227 L
->errfunc
=old_errfunc
;
1235 static void f_parser(lua_State
*L
,void*ud
){
1239 struct SParser
*p
=cast(struct SParser
*,ud
);
1241 tf
=luaY_parser(L
,p
->z
,
1243 cl
=luaF_newLclosure(L
,tf
->nups
,hvalue(gt(L
)));
1245 for(i
=0;i
<tf
->nups
;i
++)
1246 cl
->l
.upvals
[i
]=luaF_newupval(L
);
1247 setclvalue(L
,L
->top
,cl
);
1250 static int luaD_protectedparser(lua_State
*L
,ZIO
*z
,const char*name
){
1254 luaZ_initbuffer(L
,&p
.buff
);
1255 status
=luaD_pcall(L
,f_parser
,&p
,savestack(L
,L
->top
),L
->errfunc
);
1256 luaZ_freebuffer(L
,&p
.buff
);
1259 static void luaS_resize(lua_State
*L
,int newsize
){
1263 if(G(L
)->gcstate
==2)
1265 newhash
=luaM_newvector(L
,newsize
,GCObject
*);
1267 for(i
=0;i
<newsize
;i
++)newhash
[i
]=NULL
;
1268 for(i
=0;i
<tb
->size
;i
++){
1269 GCObject
*p
=tb
->hash
[i
];
1271 GCObject
*next
=p
->gch
.next
;
1272 unsigned int h
=gco2ts(p
)->hash
;
1273 int h1
=lmod(h
,newsize
);
1274 p
->gch
.next
=newhash
[h1
];
1279 luaM_freearray(L
,tb
->hash
,tb
->size
,TString
*);
1283 static TString
*newlstr(lua_State
*L
,const char*str
,size_t l
,
1287 if(l
+1>(((size_t)(~(size_t)0)-2)-sizeof(TString
))/sizeof(char))
1289 ts
=cast(TString
*,luaM_malloc(L
,(l
+1)*sizeof(char)+sizeof(TString
)));
1292 ts
->tsv
.marked
=luaC_white(G(L
));
1295 memcpy(ts
+1,str
,l
*sizeof(char));
1296 ((char*)(ts
+1))[l
]='\0';
1299 ts
->tsv
.next
=tb
->hash
[h
];
1300 tb
->hash
[h
]=obj2gco(ts
);
1302 if(tb
->nuse
>cast(lu_int32
,tb
->size
)&&tb
->size
<=(INT_MAX
-2)/2)
1303 luaS_resize(L
,tb
->size
*2);
1306 static TString
*luaS_newlstr(lua_State
*L
,const char*str
,size_t l
){
1308 unsigned int h
=cast(unsigned int,l
);
1309 size_t step
=(l
>>5)+1;
1311 for(l1
=l
;l1
>=step
;l1
-=step
)
1312 h
=h
^((h
<<5)+(h
>>2)+cast(unsigned char,str
[l1
-1]));
1313 for(o
=G(L
)->strt
.hash
[lmod(h
,G(L
)->strt
.size
)];
1316 TString
*ts
=rawgco2ts(o
);
1317 if(ts
->tsv
.len
==l
&&(memcmp(str
,getstr(ts
),l
)==0)){
1318 if(isdead(G(L
),o
))changewhite(o
);
1322 return newlstr(L
,str
,l
,h
);
1324 static Udata
*luaS_newudata(lua_State
*L
,size_t s
,Table
*e
){
1326 if(s
>((size_t)(~(size_t)0)-2)-sizeof(Udata
))
1328 u
=cast(Udata
*,luaM_malloc(L
,s
+sizeof(Udata
)));
1329 u
->uv
.marked
=luaC_white(G(L
));
1332 u
->uv
.metatable
=NULL
;
1334 u
->uv
.next
=G(L
)->mainthread
->next
;
1335 G(L
)->mainthread
->next
=obj2gco(u
);
1338 #define hashpow2(t,n)(gnode(t,lmod((n),sizenode(t))))
1339 #define hashstr(t,str)hashpow2(t,(str)->tsv.hash)
1340 #define hashboolean(t,p)hashpow2(t,p)
1341 #define hashmod(t,n)(gnode(t,((n)%((sizenode(t)-1)|1))))
1342 #define hashpointer(t,p)hashmod(t,IntPoint(p))
1343 static const Node dummynode_
={
1347 static Node
*hashnum(const Table
*t
,lua_Number n
){
1348 unsigned int a
[cast_int(sizeof(lua_Number
)/sizeof(int))];
1352 memcpy(a
,&n
,sizeof(a
));
1353 for(i
=1;i
<cast_int(sizeof(lua_Number
)/sizeof(int));i
++)a
[0]+=a
[i
];
1354 return hashmod(t
,a
[0]);
1356 static Node
*mainposition(const Table
*t
,const TValue
*key
){
1359 return hashnum(t
,nvalue(key
));
1361 return hashstr(t
,rawtsvalue(key
));
1363 return hashboolean(t
,bvalue(key
));
1365 return hashpointer(t
,pvalue(key
));
1367 return hashpointer(t
,gcvalue(key
));
1370 static int arrayindex(const TValue
*key
){
1371 if(ttisnumber(key
)){
1372 lua_Number n
=nvalue(key
);
1374 lua_number2int(k
,n
);
1375 if(luai_numeq(cast_num(k
),n
))
1380 static int findindex(lua_State
*L
,Table
*t
,StkId key
){
1382 if(ttisnil(key
))return-1;
1384 if(0<i
&&i
<=t
->sizearray
)
1387 Node
*n
=mainposition(t
,key
);
1389 if(luaO_rawequalObj(key2tval(n
),key
)||
1390 (ttype(gkey(n
))==(8+3)&&iscollectable(key
)&&
1391 gcvalue(gkey(n
))==gcvalue(key
))){
1392 i
=cast_int(n
-gnode(t
,0));
1393 return i
+t
->sizearray
;
1397 luaG_runerror(L
,"invalid key to "LUA_QL("next"));
1401 static int luaH_next(lua_State
*L
,Table
*t
,StkId key
){
1402 int i
=findindex(L
,t
,key
);
1403 for(i
++;i
<t
->sizearray
;i
++){
1404 if(!ttisnil(&t
->array
[i
])){
1405 setnvalue(key
,cast_num(i
+1));
1406 setobj(L
,key
+1,&t
->array
[i
]);
1410 for(i
-=t
->sizearray
;i
<(int)sizenode(t
);i
++){
1411 if(!ttisnil(gval(gnode(t
,i
)))){
1412 setobj(L
,key
,key2tval(gnode(t
,i
)));
1413 setobj(L
,key
+1,gval(gnode(t
,i
)));
1419 static int computesizes(int nums
[],int*narray
){
1425 for(i
=0,twotoi
=1;twotoi
/2<*narray
;i
++,twotoi
*=2){
1433 if(a
==*narray
)break;
1438 static int countint(const TValue
*key
,int*nums
){
1439 int k
=arrayindex(key
);
1440 if(0<k
&&k
<=(1<<(32-2))){
1441 nums
[ceillog2(k
)]++;
1447 static int numusearray(const Table
*t
,int*nums
){
1452 for(lg
=0,ttlg
=1;lg
<=(32-2);lg
++,ttlg
*=2){
1455 if(lim
>t
->sizearray
){
1461 if(!ttisnil(&t
->array
[i
-1]))
1469 static int numusehash(const Table
*t
,int*nums
,int*pnasize
){
1475 if(!ttisnil(gval(n
))){
1476 ause
+=countint(key2tval(n
),nums
);
1483 static void setarrayvector(lua_State
*L
,Table
*t
,int size
){
1485 luaM_reallocvector(L
,t
->array
,t
->sizearray
,size
,TValue
);
1486 for(i
=t
->sizearray
;i
<size
;i
++)
1487 setnilvalue(&t
->array
[i
]);
1490 static void setnodevector(lua_State
*L
,Table
*t
,int size
){
1493 t
->node
=cast(Node
*,(&dummynode_
));
1498 lsize
=ceillog2(size
);
1500 luaG_runerror(L
,"table overflow");
1502 t
->node
=luaM_newvector(L
,size
,Node
);
1503 for(i
=0;i
<size
;i
++){
1506 setnilvalue(gkey(n
));
1507 setnilvalue(gval(n
));
1510 t
->lsizenode
=cast_byte(lsize
);
1511 t
->lastfree
=gnode(t
,size
);
1513 static void resize(lua_State
*L
,Table
*t
,int nasize
,int nhsize
){
1515 int oldasize
=t
->sizearray
;
1516 int oldhsize
=t
->lsizenode
;
1519 setarrayvector(L
,t
,nasize
);
1520 setnodevector(L
,t
,nhsize
);
1521 if(nasize
<oldasize
){
1522 t
->sizearray
=nasize
;
1523 for(i
=nasize
;i
<oldasize
;i
++){
1524 if(!ttisnil(&t
->array
[i
]))
1525 setobj(L
,luaH_setnum(L
,t
,i
+1),&t
->array
[i
]);
1527 luaM_reallocvector(L
,t
->array
,oldasize
,nasize
,TValue
);
1529 for(i
=twoto(oldhsize
)-1;i
>=0;i
--){
1531 if(!ttisnil(gval(old
)))
1532 setobj(L
,luaH_set(L
,t
,key2tval(old
)),gval(old
));
1534 if(nold
!=(&dummynode_
))
1535 luaM_freearray(L
,nold
,twoto(oldhsize
),Node
);
1537 static void luaH_resizearray(lua_State
*L
,Table
*t
,int nasize
){
1538 int nsize
=(t
->node
==(&dummynode_
))?0:sizenode(t
);
1539 resize(L
,t
,nasize
,nsize
);
1541 static void rehash(lua_State
*L
,Table
*t
,const TValue
*ek
){
1546 for(i
=0;i
<=(32-2);i
++)nums
[i
]=0;
1547 nasize
=numusearray(t
,nums
);
1549 totaluse
+=numusehash(t
,nums
,&nasize
);
1550 nasize
+=countint(ek
,nums
);
1552 na
=computesizes(nums
,&nasize
);
1553 resize(L
,t
,nasize
,totaluse
-na
);
1555 static Table
*luaH_new(lua_State
*L
,int narray
,int nhash
){
1556 Table
*t
=luaM_new(L
,Table
);
1557 luaC_link(L
,obj2gco(t
),5);
1559 t
->flags
=cast_byte(~0);
1563 t
->node
=cast(Node
*,(&dummynode_
));
1564 setarrayvector(L
,t
,narray
);
1565 setnodevector(L
,t
,nhash
);
1568 static void luaH_free(lua_State
*L
,Table
*t
){
1569 if(t
->node
!=(&dummynode_
))
1570 luaM_freearray(L
,t
->node
,sizenode(t
),Node
);
1571 luaM_freearray(L
,t
->array
,t
->sizearray
,TValue
);
1574 static Node
*getfreepos(Table
*t
){
1575 while(t
->lastfree
-->t
->node
){
1576 if(ttisnil(gkey(t
->lastfree
)))
1581 static TValue
*newkey(lua_State
*L
,Table
*t
,const TValue
*key
){
1582 Node
*mp
=mainposition(t
,key
);
1583 if(!ttisnil(gval(mp
))||mp
==(&dummynode_
)){
1585 Node
*n
=getfreepos(t
);
1588 return luaH_set(L
,t
,key
);
1590 othern
=mainposition(t
,key2tval(mp
));
1592 while(gnext(othern
)!=mp
)othern
=gnext(othern
);
1596 setnilvalue(gval(mp
));
1604 gkey(mp
)->value
=key
->value
;gkey(mp
)->tt
=key
->tt
;
1605 luaC_barriert(L
,t
,key
);
1608 static const TValue
*luaH_getnum(Table
*t
,int key
){
1609 if(cast(unsigned int,key
-1)<cast(unsigned int,t
->sizearray
))
1610 return&t
->array
[key
-1];
1612 lua_Number nk
=cast_num(key
);
1613 Node
*n
=hashnum(t
,nk
);
1615 if(ttisnumber(gkey(n
))&&luai_numeq(nvalue(gkey(n
)),nk
))
1619 return(&luaO_nilobject_
);
1622 static const TValue
*luaH_getstr(Table
*t
,TString
*key
){
1623 Node
*n
=hashstr(t
,key
);
1625 if(ttisstring(gkey(n
))&&rawtsvalue(gkey(n
))==key
)
1629 return(&luaO_nilobject_
);
1631 static const TValue
*luaH_get(Table
*t
,const TValue
*key
){
1633 case 0:return(&luaO_nilobject_
);
1634 case 4:return luaH_getstr(t
,rawtsvalue(key
));
1637 lua_Number n
=nvalue(key
);
1638 lua_number2int(k
,n
);
1639 if(luai_numeq(cast_num(k
),nvalue(key
)))
1640 return luaH_getnum(t
,k
);
1643 Node
*n
=mainposition(t
,key
);
1645 if(luaO_rawequalObj(key2tval(n
),key
))
1649 return(&luaO_nilobject_
);
1653 static TValue
*luaH_set(lua_State
*L
,Table
*t
,const TValue
*key
){
1654 const TValue
*p
=luaH_get(t
,key
);
1656 if(p
!=(&luaO_nilobject_
))
1657 return cast(TValue
*,p
);
1659 if(ttisnil(key
))luaG_runerror(L
,"table index is nil");
1660 else if(ttisnumber(key
)&&luai_numisnan(nvalue(key
)))
1661 luaG_runerror(L
,"table index is NaN");
1662 return newkey(L
,t
,key
);
1665 static TValue
*luaH_setnum(lua_State
*L
,Table
*t
,int key
){
1666 const TValue
*p
=luaH_getnum(t
,key
);
1667 if(p
!=(&luaO_nilobject_
))
1668 return cast(TValue
*,p
);
1671 setnvalue(&k
,cast_num(key
));
1672 return newkey(L
,t
,&k
);
1675 static TValue
*luaH_setstr(lua_State
*L
,Table
*t
,TString
*key
){
1676 const TValue
*p
=luaH_getstr(t
,key
);
1677 if(p
!=(&luaO_nilobject_
))
1678 return cast(TValue
*,p
);
1681 setsvalue(L
,&k
,key
);
1682 return newkey(L
,t
,&k
);
1685 static int unbound_search(Table
*t
,unsigned int j
){
1688 while(!ttisnil(luaH_getnum(t
,j
))){
1691 if(j
>cast(unsigned int,(INT_MAX
-2))){
1693 while(!ttisnil(luaH_getnum(t
,i
)))i
++;
1698 unsigned int m
=(i
+j
)/2;
1699 if(ttisnil(luaH_getnum(t
,m
)))j
=m
;
1704 static int luaH_getn(Table
*t
){
1705 unsigned int j
=t
->sizearray
;
1706 if(j
>0&&ttisnil(&t
->array
[j
-1])){
1709 unsigned int m
=(i
+j
)/2;
1710 if(ttisnil(&t
->array
[m
-1]))j
=m
;
1715 else if(t
->node
==(&dummynode_
))
1717 else return unbound_search(t
,j
);
1719 #define makewhite(g,x)((x)->gch.marked=cast_byte(((x)->gch.marked&cast_byte(~(bitmask(2)|bit2mask(0,1))))|luaC_white(g)))
1720 #define white2gray(x)reset2bits((x)->gch.marked,0,1)
1721 #define black2gray(x)resetbit((x)->gch.marked,2)
1722 #define stringmark(s)reset2bits((s)->tsv.marked,0,1)
1723 #define isfinalized(u)testbit((u)->marked,3)
1724 #define markfinalized(u)l_setbit((u)->marked,3)
1725 #define markvalue(g,o){checkconsistency(o);if(iscollectable(o)&&iswhite(gcvalue(o)))reallymarkobject(g,gcvalue(o));}
1726 #define markobject(g,t){if(iswhite(obj2gco(t)))reallymarkobject(g,obj2gco(t));}
1727 #define setthreshold(g)(g->GCthreshold=(g->estimate/100)*g->gcpause)
1728 static void removeentry(Node
*n
){
1729 if(iscollectable(gkey(n
)))
1730 setttype(gkey(n
),(8+3));
1732 static void reallymarkobject(global_State
*g
,GCObject
*o
){
1739 Table
*mt
=gco2u(o
)->metatable
;
1741 if(mt
)markobject(g
,mt
);
1742 markobject(g
,gco2u(o
)->env
);
1748 if(uv
->v
==&uv
->u
.value
)
1753 gco2cl(o
)->c
.gclist
=g
->gray
;
1758 gco2h(o
)->gclist
=g
->gray
;
1763 gco2th(o
)->gclist
=g
->gray
;
1768 gco2p(o
)->gclist
=g
->gray
;
1775 static void marktmu(global_State
*g
){
1776 GCObject
*u
=g
->tmudata
;
1781 reallymarkobject(g
,u
);
1782 }while(u
!=g
->tmudata
);
1785 static size_t luaC_separateudata(lua_State
*L
,int all
){
1786 global_State
*g
=G(L
);
1788 GCObject
**p
=&g
->mainthread
->next
;
1790 while((curr
=*p
)!=NULL
){
1791 if(!(iswhite(curr
)||all
)||isfinalized(gco2u(curr
)))
1793 else if(fasttm(L
,gco2u(curr
)->metatable
,TM_GC
)==NULL
){
1794 markfinalized(gco2u(curr
));
1798 deadmem
+=sizeudata(gco2u(curr
));
1799 markfinalized(gco2u(curr
));
1801 if(g
->tmudata
==NULL
)
1802 g
->tmudata
=curr
->gch
.next
=curr
;
1804 curr
->gch
.next
=g
->tmudata
->gch
.next
;
1805 g
->tmudata
->gch
.next
=curr
;
1812 static int traversetable(global_State
*g
,Table
*h
){
1818 markobject(g
,h
->metatable
);
1819 mode
=gfasttm(g
,h
->metatable
,TM_MODE
);
1820 if(mode
&&ttisstring(mode
)){
1821 weakkey
=(strchr(svalue(mode
),'k')!=NULL
);
1822 weakvalue
=(strchr(svalue(mode
),'v')!=NULL
);
1823 if(weakkey
||weakvalue
){
1824 h
->marked
&=~(bitmask(3)|bitmask(4));
1825 h
->marked
|=cast_byte((weakkey
<<3)|
1831 if(weakkey
&&weakvalue
)return 1;
1835 markvalue(g
,&h
->array
[i
]);
1840 if(ttisnil(gval(n
)))
1843 if(!weakkey
)markvalue(g
,gkey(n
));
1844 if(!weakvalue
)markvalue(g
,gval(n
));
1847 return weakkey
||weakvalue
;
1849 static void traverseproto(global_State
*g
,Proto
*f
){
1851 if(f
->source
)stringmark(f
->source
);
1852 for(i
=0;i
<f
->sizek
;i
++)
1853 markvalue(g
,&f
->k
[i
]);
1854 for(i
=0;i
<f
->sizeupvalues
;i
++){
1856 stringmark(f
->upvalues
[i
]);
1858 for(i
=0;i
<f
->sizep
;i
++){
1860 markobject(g
,f
->p
[i
]);
1862 for(i
=0;i
<f
->sizelocvars
;i
++){
1863 if(f
->locvars
[i
].varname
)
1864 stringmark(f
->locvars
[i
].varname
);
1867 static void traverseclosure(global_State
*g
,Closure
*cl
){
1868 markobject(g
,cl
->c
.env
);
1871 for(i
=0;i
<cl
->c
.nupvalues
;i
++)
1872 markvalue(g
,&cl
->c
.upvalue
[i
]);
1876 markobject(g
,cl
->l
.p
);
1877 for(i
=0;i
<cl
->l
.nupvalues
;i
++)
1878 markobject(g
,cl
->l
.upvals
[i
]);
1881 static void checkstacksizes(lua_State
*L
,StkId max
){
1882 int ci_used
=cast_int(L
->ci
-L
->base_ci
);
1883 int s_used
=cast_int(max
-L
->stack
);
1884 if(L
->size_ci
>20000)
1886 if(4*ci_used
<L
->size_ci
&&2*8<L
->size_ci
)
1887 luaD_reallocCI(L
,L
->size_ci
/2);
1888 condhardstacktests(luaD_reallocCI(L
,ci_used
+1));
1889 if(4*s_used
<L
->stacksize
&&
1890 2*((2*20)+5)<L
->stacksize
)
1891 luaD_reallocstack(L
,L
->stacksize
/2);
1892 condhardstacktests(luaD_reallocstack(L
,s_used
));
1894 static void traversestack(global_State
*g
,lua_State
*l
){
1899 for(ci
=l
->base_ci
;ci
<=l
->ci
;ci
++){
1900 if(lim
<ci
->top
)lim
=ci
->top
;
1902 for(o
=l
->stack
;o
<l
->top
;o
++)
1906 checkstacksizes(l
,lim
);
1908 static l_mem
propagatemark(global_State
*g
){
1915 if(traversetable(g
,h
))
1917 return sizeof(Table
)+sizeof(TValue
)*h
->sizearray
+
1918 sizeof(Node
)*sizenode(h
);
1921 Closure
*cl
=gco2cl(o
);
1922 g
->gray
=cl
->c
.gclist
;
1923 traverseclosure(g
,cl
);
1924 return(cl
->c
.isC
)?sizeCclosure(cl
->c
.nupvalues
):
1925 sizeLclosure(cl
->l
.nupvalues
);
1928 lua_State
*th
=gco2th(o
);
1930 th
->gclist
=g
->grayagain
;
1933 traversestack(g
,th
);
1934 return sizeof(lua_State
)+sizeof(TValue
)*th
->stacksize
+
1935 sizeof(CallInfo
)*th
->size_ci
;
1941 return sizeof(Proto
)+sizeof(Instruction
)*p
->sizecode
+
1942 sizeof(Proto
*)*p
->sizep
+
1943 sizeof(TValue
)*p
->sizek
+
1944 sizeof(int)*p
->sizelineinfo
+
1945 sizeof(LocVar
)*p
->sizelocvars
+
1946 sizeof(TString
*)*p
->sizeupvalues
;
1951 static size_t propagateall(global_State
*g
){
1953 while(g
->gray
)m
+=propagatemark(g
);
1956 static int iscleared(const TValue
*o
,int iskey
){
1957 if(!iscollectable(o
))return 0;
1959 stringmark(rawtsvalue(o
));
1962 return iswhite(gcvalue(o
))||
1963 (ttisuserdata(o
)&&(!iskey
&&isfinalized(uvalue(o
))));
1965 static void cleartable(GCObject
*l
){
1969 if(testbit(h
->marked
,4)){
1971 TValue
*o
=&h
->array
[i
];
1979 if(!ttisnil(gval(n
))&&
1980 (iscleared(key2tval(n
),1)||iscleared(gval(n
),0))){
1981 setnilvalue(gval(n
));
1988 static void freeobj(lua_State
*L
,GCObject
*o
){
1990 case(8+1):luaF_freeproto(L
,gco2p(o
));break;
1991 case 6:luaF_freeclosure(L
,gco2cl(o
));break;
1992 case(8+2):luaF_freeupval(L
,gco2uv(o
));break;
1993 case 5:luaH_free(L
,gco2h(o
));break;
1995 luaE_freethread(L
,gco2th(o
));
2000 luaM_freemem(L
,o
,sizestring(gco2ts(o
)));
2004 luaM_freemem(L
,o
,sizeudata(gco2u(o
)));
2010 #define sweepwholelist(L,p)sweeplist(L,p,((lu_mem)(~(lu_mem)0)-2))
2011 static GCObject
**sweeplist(lua_State
*L
,GCObject
**p
,lu_mem count
){
2013 global_State
*g
=G(L
);
2014 int deadmask
=otherwhite(g
);
2015 while((curr
=*p
)!=NULL
&&count
-->0){
2017 sweepwholelist(L
,&gco2th(curr
)->openupval
);
2018 if((curr
->gch
.marked
^bit2mask(0,1))&deadmask
){
2025 g
->rootgc
=curr
->gch
.next
;
2031 static void checkSizes(lua_State
*L
){
2032 global_State
*g
=G(L
);
2033 if(g
->strt
.nuse
<cast(lu_int32
,g
->strt
.size
/4)&&
2035 luaS_resize(L
,g
->strt
.size
/2);
2036 if(luaZ_sizebuffer(&g
->buff
)>32*2){
2037 size_t newsize
=luaZ_sizebuffer(&g
->buff
)/2;
2038 luaZ_resizebuffer(L
,&g
->buff
,newsize
);
2041 static void GCTM(lua_State
*L
){
2042 global_State
*g
=G(L
);
2043 GCObject
*o
=g
->tmudata
->gch
.next
;
2044 Udata
*udata
=rawgco2u(o
);
2049 g
->tmudata
->gch
.next
=udata
->uv
.next
;
2050 udata
->uv
.next
=g
->mainthread
->next
;
2051 g
->mainthread
->next
=o
;
2053 tm
=fasttm(L
,udata
->uv
.metatable
,TM_GC
);
2055 lu_byte oldah
=L
->allowhook
;
2056 lu_mem oldt
=g
->GCthreshold
;
2058 g
->GCthreshold
=2*g
->totalbytes
;
2059 setobj(L
,L
->top
,tm
);
2060 setuvalue(L
,L
->top
+1,udata
);
2062 luaD_call(L
,L
->top
-2,0);
2064 g
->GCthreshold
=oldt
;
2067 static void luaC_callGCTM(lua_State
*L
){
2068 while(G(L
)->tmudata
)
2071 static void luaC_freeall(lua_State
*L
){
2072 global_State
*g
=G(L
);
2074 g
->currentwhite
=bit2mask(0,1)|bitmask(6);
2075 sweepwholelist(L
,&g
->rootgc
);
2076 for(i
=0;i
<g
->strt
.size
;i
++)
2077 sweepwholelist(L
,&g
->strt
.hash
[i
]);
2079 static void markmt(global_State
*g
){
2081 for(i
=0;i
<(8+1);i
++)
2082 if(g
->mt
[i
])markobject(g
,g
->mt
[i
]);
2084 static void markroot(lua_State
*L
){
2085 global_State
*g
=G(L
);
2089 markobject(g
,g
->mainthread
);
2090 markvalue(g
,gt(g
->mainthread
));
2091 markvalue(g
,registry(L
));
2095 static void remarkupvals(global_State
*g
){
2097 for(uv
=g
->uvhead
.u
.l
.next
;uv
!=&g
->uvhead
;uv
=uv
->u
.l
.next
){
2098 if(isgray(obj2gco(uv
)))
2102 static void atomic(lua_State
*L
){
2103 global_State
*g
=G(L
);
2112 g
->gray
=g
->grayagain
;
2115 udsize
=luaC_separateudata(L
,0);
2117 udsize
+=propagateall(g
);
2118 cleartable(g
->weak
);
2119 g
->currentwhite
=cast_byte(otherwhite(g
));
2121 g
->sweepgc
=&g
->rootgc
;
2123 g
->estimate
=g
->totalbytes
-udsize
;
2125 static l_mem
singlestep(lua_State
*L
){
2126 global_State
*g
=G(L
);
2134 return propagatemark(g
);
2141 lu_mem old
=g
->totalbytes
;
2142 sweepwholelist(L
,&g
->strt
.hash
[g
->sweepstrgc
++]);
2143 if(g
->sweepstrgc
>=g
->strt
.size
)
2145 g
->estimate
-=old
-g
->totalbytes
;
2149 lu_mem old
=g
->totalbytes
;
2150 g
->sweepgc
=sweeplist(L
,g
->sweepgc
,40);
2151 if(*g
->sweepgc
==NULL
){
2155 g
->estimate
-=old
-g
->totalbytes
;
2174 static void luaC_step(lua_State
*L
){
2175 global_State
*g
=G(L
);
2176 l_mem lim
=(1024u/100)*g
->gcstepmul
;
2178 lim
=(((lu_mem
)(~(lu_mem
)0)-2)-1)/2;
2179 g
->gcdept
+=g
->totalbytes
-g
->GCthreshold
;
2187 g
->GCthreshold
=g
->totalbytes
+1024u;
2190 g
->GCthreshold
=g
->totalbytes
;
2197 static void luaC_barrierf(lua_State
*L
,GCObject
*o
,GCObject
*v
){
2198 global_State
*g
=G(L
);
2200 reallymarkobject(g
,v
);
2204 static void luaC_barrierback(lua_State
*L
,Table
*t
){
2205 global_State
*g
=G(L
);
2206 GCObject
*o
=obj2gco(t
);
2208 t
->gclist
=g
->grayagain
;
2211 static void luaC_link(lua_State
*L
,GCObject
*o
,lu_byte tt
){
2212 global_State
*g
=G(L
);
2213 o
->gch
.next
=g
->rootgc
;
2215 o
->gch
.marked
=luaC_white(g
);
2218 static void luaC_linkupval(lua_State
*L
,UpVal
*uv
){
2219 global_State
*g
=G(L
);
2220 GCObject
*o
=obj2gco(uv
);
2221 o
->gch
.next
=g
->rootgc
;
2226 luaC_barrier(L
,uv
,uv
->v
);
2237 typedef struct Token
{
2241 typedef struct LexState
{
2247 struct FuncState
*fs
;
2254 static void luaX_init(lua_State
*L
);
2255 static void luaX_lexerror(LexState
*ls
,const char*msg
,int token
);
2256 #define state_size(x)(sizeof(x)+0)
2257 #define fromstate(l)(cast(lu_byte*,(l))-0)
2258 #define tostate(l)(cast(lua_State*,cast(lu_byte*,l)+0))
2263 static void stack_init(lua_State
*L1
,lua_State
*L
){
2264 L1
->base_ci
=luaM_newvector(L
,8,CallInfo
);
2267 L1
->end_ci
=L1
->base_ci
+L1
->size_ci
-1;
2268 L1
->stack
=luaM_newvector(L
,(2*20)+5,TValue
);
2269 L1
->stacksize
=(2*20)+5;
2271 L1
->stack_last
=L1
->stack
+(L1
->stacksize
-5)-1;
2272 L1
->ci
->func
=L1
->top
;
2273 setnilvalue(L1
->top
++);
2274 L1
->base
=L1
->ci
->base
=L1
->top
;
2275 L1
->ci
->top
=L1
->top
+20;
2277 static void freestack(lua_State
*L
,lua_State
*L1
){
2278 luaM_freearray(L
,L1
->base_ci
,L1
->size_ci
,CallInfo
);
2279 luaM_freearray(L
,L1
->stack
,L1
->stacksize
,TValue
);
2281 static void f_luaopen(lua_State
*L
,void*ud
){
2282 global_State
*g
=G(L
);
2285 sethvalue(L
,gt(L
),luaH_new(L
,0,2));
2286 sethvalue(L
,registry(L
),luaH_new(L
,0,2));
2290 luaS_fix(luaS_newliteral(L
,"not enough memory"));
2291 g
->GCthreshold
=4*g
->totalbytes
;
2293 static void preinit_state(lua_State
*L
,global_State
*g
){
2305 L
->nCcalls
=L
->baseCcalls
=0;
2307 L
->base_ci
=L
->ci
=NULL
;
2312 static void close_state(lua_State
*L
){
2313 global_State
*g
=G(L
);
2314 luaF_close(L
,L
->stack
);
2316 luaM_freearray(L
,G(L
)->strt
.hash
,G(L
)->strt
.size
,TString
*);
2317 luaZ_freebuffer(L
,&g
->buff
);
2319 (*g
->frealloc
)(g
->ud
,fromstate(L
),state_size(LG
),0);
2321 static void luaE_freethread(lua_State
*L
,lua_State
*L1
){
2322 luaF_close(L1
,L1
->stack
);
2324 luaM_freemem(L
,fromstate(L1
),state_size(lua_State
));
2326 static lua_State
*lua_newstate(lua_Alloc f
,void*ud
){
2330 void*l
=(*f
)(ud
,NULL
,0,state_size(LG
));
2331 if(l
==NULL
)return NULL
;
2336 g
->currentwhite
=bit2mask(0,5);
2337 L
->marked
=luaC_white(g
);
2338 set2bits(L
->marked
,5,6);
2343 g
->uvhead
.u
.l
.prev
=&g
->uvhead
;
2344 g
->uvhead
.u
.l
.next
=&g
->uvhead
;
2349 setnilvalue(registry(L
));
2350 luaZ_initbuffer(L
,&g
->buff
);
2353 g
->rootgc
=obj2gco(L
);
2355 g
->sweepgc
=&g
->rootgc
;
2360 g
->totalbytes
=sizeof(LG
);
2364 for(i
=0;i
<(8+1);i
++)g
->mt
[i
]=NULL
;
2365 if(luaD_rawrunprotected(L
,f_luaopen
,NULL
)!=0){
2373 static void callallgcTM(lua_State
*L
,void*ud
){
2377 static void lua_close(lua_State
*L
){
2379 luaF_close(L
,L
->stack
);
2380 luaC_separateudata(L
,1);
2384 L
->base
=L
->top
=L
->ci
->base
;
2385 L
->nCcalls
=L
->baseCcalls
=0;
2386 }while(luaD_rawrunprotected(L
,callallgcTM
,NULL
)!=0);
2389 #define getcode(fs,e)((fs)->f->code[(e)->u.s.info])
2390 #define luaK_codeAsBx(fs,o,A,sBx)luaK_codeABx(fs,o,A,(sBx)+(((1<<(9+9))-1)>>1))
2391 #define luaK_setmultret(fs,e)luaK_setreturns(fs,e,(-1))
2392 static int luaK_codeABx(FuncState
*fs
,OpCode o
,int A
,unsigned int Bx
);
2393 static int luaK_codeABC(FuncState
*fs
,OpCode o
,int A
,int B
,int C
);
2394 static void luaK_setreturns(FuncState
*fs
,expdesc
*e
,int nresults
);
2395 static void luaK_patchtohere(FuncState
*fs
,int list
);
2396 static void luaK_concat(FuncState
*fs
,int*l1
,int l2
);
2397 static int currentpc(lua_State
*L
,CallInfo
*ci
){
2398 if(!isLua(ci
))return-1;
2400 ci
->savedpc
=L
->savedpc
;
2401 return pcRel(ci
->savedpc
,ci_func(ci
)->l
.p
);
2403 static int currentline(lua_State
*L
,CallInfo
*ci
){
2404 int pc
=currentpc(L
,ci
);
2408 return getline_(ci_func(ci
)->l
.p
,pc
);
2410 static int lua_getstack(lua_State
*L
,int level
,lua_Debug
*ar
){
2413 for(ci
=L
->ci
;level
>0&&ci
>L
->base_ci
;ci
--){
2416 level
-=ci
->tailcalls
;
2418 if(level
==0&&ci
>L
->base_ci
){
2420 ar
->i_ci
=cast_int(ci
-L
->base_ci
);
2429 static Proto
*getluaproto(CallInfo
*ci
){
2430 return(isLua(ci
)?ci_func(ci
)->l
.p
:NULL
);
2432 static void funcinfo(lua_Debug
*ar
,Closure
*cl
){
2436 ar
->lastlinedefined
=-1;
2440 ar
->source
=getstr(cl
->l
.p
->source
);
2441 ar
->linedefined
=cl
->l
.p
->linedefined
;
2442 ar
->lastlinedefined
=cl
->l
.p
->lastlinedefined
;
2443 ar
->what
=(ar
->linedefined
==0)?"main":"Lua";
2445 luaO_chunkid(ar
->short_src
,ar
->source
,60);
2447 static void info_tailcall(lua_Debug
*ar
){
2448 ar
->name
=ar
->namewhat
="";
2450 ar
->lastlinedefined
=ar
->linedefined
=ar
->currentline
=-1;
2451 ar
->source
="=(tail call)";
2452 luaO_chunkid(ar
->short_src
,ar
->source
,60);
2455 static void collectvalidlines(lua_State
*L
,Closure
*f
){
2456 if(f
==NULL
||f
->c
.isC
){
2457 setnilvalue(L
->top
);
2460 Table
*t
=luaH_new(L
,0,0);
2461 int*lineinfo
=f
->l
.p
->lineinfo
;
2463 for(i
=0;i
<f
->l
.p
->sizelineinfo
;i
++)
2464 setbvalue(luaH_setnum(L
,t
,lineinfo
[i
]),1);
2465 sethvalue(L
,L
->top
,t
);
2469 static int auxgetinfo(lua_State
*L
,const char*what
,lua_Debug
*ar
,
2470 Closure
*f
,CallInfo
*ci
){
2483 ar
->currentline
=(ci
)?currentline(L
,ci
):-1;
2487 ar
->nups
=f
->c
.nupvalues
;
2491 ar
->namewhat
=(ci
)?NULL
:NULL
;
2492 if(ar
->namewhat
==NULL
){
2506 static int lua_getinfo(lua_State
*L
,const char*what
,lua_Debug
*ar
){
2511 StkId func
=L
->top
-1;
2512 luai_apicheck(L
,ttisfunction(func
));
2517 else if(ar
->i_ci
!=0){
2518 ci
=L
->base_ci
+ar
->i_ci
;
2519 f
=clvalue(ci
->func
);
2521 status
=auxgetinfo(L
,what
,ar
,f
,ci
);
2522 if(strchr(what
,'f')){
2523 if(f
==NULL
)setnilvalue(L
->top
);
2524 else setclvalue(L
,L
->top
,f
);
2527 if(strchr(what
,'L'))
2528 collectvalidlines(L
,f
);
2531 static int isinstack(CallInfo
*ci
,const TValue
*o
){
2533 for(p
=ci
->base
;p
<ci
->top
;p
++)
2537 static void luaG_typeerror(lua_State
*L
,const TValue
*o
,const char*op
){
2538 const char*name
=NULL
;
2539 const char*t
=luaT_typenames
[ttype(o
)];
2540 const char*kind
=(isinstack(L
->ci
,o
))?
2544 luaG_runerror(L
,"attempt to %s %s "LUA_QL("%s")" (a %s value)",
2547 luaG_runerror(L
,"attempt to %s a %s value",op
,t
);
2549 static void luaG_concaterror(lua_State
*L
,StkId p1
,StkId p2
){
2550 if(ttisstring(p1
)||ttisnumber(p1
))p1
=p2
;
2551 luaG_typeerror(L
,p1
,"concatenate");
2553 static void luaG_aritherror(lua_State
*L
,const TValue
*p1
,const TValue
*p2
){
2555 if(luaV_tonumber(p1
,&temp
)==NULL
)
2557 luaG_typeerror(L
,p2
,"perform arithmetic on");
2559 static int luaG_ordererror(lua_State
*L
,const TValue
*p1
,const TValue
*p2
){
2560 const char*t1
=luaT_typenames
[ttype(p1
)];
2561 const char*t2
=luaT_typenames
[ttype(p2
)];
2563 luaG_runerror(L
,"attempt to compare two %s values",t1
);
2565 luaG_runerror(L
,"attempt to compare %s with %s",t1
,t2
);
2568 static void addinfo(lua_State
*L
,const char*msg
){
2572 int line
=currentline(L
,ci
);
2573 luaO_chunkid(buff
,getstr(getluaproto(ci
)->source
),60);
2574 luaO_pushfstring(L
,"%s:%d: %s",buff
,line
,msg
);
2577 static void luaG_errormsg(lua_State
*L
){
2579 StkId errfunc
=restorestack(L
,L
->errfunc
);
2580 if(!ttisfunction(errfunc
))luaD_throw(L
,5);
2581 setobj(L
,L
->top
,L
->top
-1);
2582 setobj(L
,L
->top
-1,errfunc
);
2584 luaD_call(L
,L
->top
-2,1);
2588 static void luaG_runerror(lua_State
*L
,const char*fmt
,...){
2591 addinfo(L
,luaO_pushvfstring(L
,fmt
,argp
));
2595 static int luaZ_fill(ZIO
*z
){
2599 buff
=z
->reader(L
,z
->data
,&size
);
2600 if(buff
==NULL
||size
==0)return(-1);
2603 return char2int(*(z
->p
++));
2605 static void luaZ_init(lua_State
*L
,ZIO
*z
,lua_Reader reader
,void*data
){
2612 static char*luaZ_openspace(lua_State
*L
,Mbuffer
*buff
,size_t n
){
2613 if(n
>buff
->buffsize
){
2615 luaZ_resizebuffer(L
,buff
,n
);
2617 return buff
->buffer
;
2619 #define opmode(t,a,b,c,m)(((t)<<7)|((a)<<6)|((b)<<4)|((c)<<2)|(m))
2620 static const lu_byte luaP_opmodes
[(cast(int,OP_VARARG
)+1)]={
2621 opmode(0,1,OpArgR
,OpArgN
,iABC
)
2622 ,opmode(0,1,OpArgK
,OpArgN
,iABx
)
2623 ,opmode(0,1,OpArgU
,OpArgU
,iABC
)
2624 ,opmode(0,1,OpArgR
,OpArgN
,iABC
)
2625 ,opmode(0,1,OpArgU
,OpArgN
,iABC
)
2626 ,opmode(0,1,OpArgK
,OpArgN
,iABx
)
2627 ,opmode(0,1,OpArgR
,OpArgK
,iABC
)
2628 ,opmode(0,0,OpArgK
,OpArgN
,iABx
)
2629 ,opmode(0,0,OpArgU
,OpArgN
,iABC
)
2630 ,opmode(0,0,OpArgK
,OpArgK
,iABC
)
2631 ,opmode(0,1,OpArgU
,OpArgU
,iABC
)
2632 ,opmode(0,1,OpArgR
,OpArgK
,iABC
)
2633 ,opmode(0,1,OpArgK
,OpArgK
,iABC
)
2634 ,opmode(0,1,OpArgK
,OpArgK
,iABC
)
2635 ,opmode(0,1,OpArgK
,OpArgK
,iABC
)
2636 ,opmode(0,1,OpArgK
,OpArgK
,iABC
)
2637 ,opmode(0,1,OpArgK
,OpArgK
,iABC
)
2638 ,opmode(0,1,OpArgK
,OpArgK
,iABC
)
2639 ,opmode(0,1,OpArgR
,OpArgN
,iABC
)
2640 ,opmode(0,1,OpArgR
,OpArgN
,iABC
)
2641 ,opmode(0,1,OpArgR
,OpArgN
,iABC
)
2642 ,opmode(0,1,OpArgR
,OpArgR
,iABC
)
2643 ,opmode(0,0,OpArgR
,OpArgN
,iAsBx
)
2644 ,opmode(1,0,OpArgK
,OpArgK
,iABC
)
2645 ,opmode(1,0,OpArgK
,OpArgK
,iABC
)
2646 ,opmode(1,0,OpArgK
,OpArgK
,iABC
)
2647 ,opmode(1,1,OpArgR
,OpArgU
,iABC
)
2648 ,opmode(1,1,OpArgR
,OpArgU
,iABC
)
2649 ,opmode(0,1,OpArgU
,OpArgU
,iABC
)
2650 ,opmode(0,1,OpArgU
,OpArgU
,iABC
)
2651 ,opmode(0,0,OpArgU
,OpArgN
,iABC
)
2652 ,opmode(0,1,OpArgR
,OpArgN
,iAsBx
)
2653 ,opmode(0,1,OpArgR
,OpArgN
,iAsBx
)
2654 ,opmode(1,0,OpArgN
,OpArgU
,iABC
)
2655 ,opmode(0,0,OpArgU
,OpArgU
,iABC
)
2656 ,opmode(0,0,OpArgN
,OpArgN
,iABC
)
2657 ,opmode(0,1,OpArgU
,OpArgN
,iABx
)
2658 ,opmode(0,1,OpArgU
,OpArgN
,iABC
)
2660 #define next(ls)(ls->current=zgetc(ls->z))
2661 #define currIsNewline(ls)(ls->current=='\n'||ls->current=='\r')
2662 static const char*const luaX_tokens
[]={
2663 "and","break","do","else","elseif",
2664 "end","false","for","function","if",
2665 "in","local","nil","not","or","repeat",
2666 "return","then","true","until","while",
2667 "..","...","==",">=","<=","~=",
2668 "<number>","<name>","<string>","<eof>",
2671 #define save_and_next(ls)(save(ls,ls->current),next(ls))
2672 static void save(LexState
*ls
,int c
){
2674 if(b
->n
+1>b
->buffsize
){
2676 if(b
->buffsize
>=((size_t)(~(size_t)0)-2)/2)
2677 luaX_lexerror(ls
,"lexical element too long",0);
2678 newsize
=b
->buffsize
*2;
2679 luaZ_resizebuffer(ls
->L
,b
,newsize
);
2681 b
->buffer
[b
->n
++]=cast(char,c
);
2683 static void luaX_init(lua_State
*L
){
2685 for(i
=0;i
<(cast(int,TK_WHILE
-257+1));i
++){
2686 TString
*ts
=luaS_new(L
,luaX_tokens
[i
]);
2688 ts
->tsv
.reserved
=cast_byte(i
+1);
2691 static const char*luaX_token2str(LexState
*ls
,int token
){
2693 return(iscntrl(token
))?luaO_pushfstring(ls
->L
,"char(%d)",token
):
2694 luaO_pushfstring(ls
->L
,"%c",token
);
2697 return luaX_tokens
[token
-257];
2699 static const char*txtToken(LexState
*ls
,int token
){
2705 return luaZ_buffer(ls
->buff
);
2707 return luaX_token2str(ls
,token
);
2710 static void luaX_lexerror(LexState
*ls
,const char*msg
,int token
){
2712 luaO_chunkid(buff
,getstr(ls
->source
),80);
2713 msg
=luaO_pushfstring(ls
->L
,"%s:%d: %s",buff
,ls
->linenumber
,msg
);
2715 luaO_pushfstring(ls
->L
,"%s near "LUA_QL("%s"),msg
,txtToken(ls
,token
));
2716 luaD_throw(ls
->L
,3);
2718 static void luaX_syntaxerror(LexState
*ls
,const char*msg
){
2719 luaX_lexerror(ls
,msg
,ls
->t
.token
);
2721 static TString
*luaX_newstring(LexState
*ls
,const char*str
,size_t l
){
2723 TString
*ts
=luaS_newlstr(L
,str
,l
);
2724 TValue
*o
=luaH_setstr(L
,ls
->fs
->h
,ts
);
2731 static void inclinenumber(LexState
*ls
){
2732 int old
=ls
->current
;
2734 if(currIsNewline(ls
)&&ls
->current
!=old
)
2736 if(++ls
->linenumber
>=(INT_MAX
-2))
2737 luaX_syntaxerror(ls
,"chunk has too many lines");
2739 static void luaX_setinput(lua_State
*L
,LexState
*ls
,ZIO
*z
,TString
*source
){
2742 ls
->lookahead
.token
=TK_EOS
;
2748 luaZ_resizebuffer(ls
->L
,ls
->buff
,32);
2751 static int check_next(LexState
*ls
,const char*set
){
2752 if(!strchr(set
,ls
->current
))
2757 static void buffreplace(LexState
*ls
,char from
,char to
){
2758 size_t n
=luaZ_bufflen(ls
->buff
);
2759 char*p
=luaZ_buffer(ls
->buff
);
2761 if(p
[n
]==from
)p
[n
]=to
;
2763 static void read_numeral(LexState
*ls
,SemInfo
*seminfo
){
2766 }while(isdigit(ls
->current
)||ls
->current
=='.');
2767 if(check_next(ls
,"Ee"))
2768 check_next(ls
,"+-");
2769 while(isalnum(ls
->current
)||ls
->current
=='_')
2772 buffreplace(ls
,'.',ls
->decpoint
);
2773 if(!luaO_str2d(luaZ_buffer(ls
->buff
),&seminfo
->r
))
2774 luaX_lexerror(ls
,"malformed number",TK_NUMBER
);
2776 static int skip_sep(LexState
*ls
){
2780 while(ls
->current
=='='){
2784 return(ls
->current
==s
)?count
:(-count
)-1;
2786 static void read_long_string(LexState
*ls
,SemInfo
*seminfo
,int sep
){
2790 if(currIsNewline(ls
))
2793 switch(ls
->current
){
2795 luaX_lexerror(ls
,(seminfo
)?"unfinished long string":
2796 "unfinished long comment",TK_EOS
);
2799 if(skip_sep(ls
)==sep
){
2809 if(!seminfo
)luaZ_resetbuffer(ls
->buff
);
2813 if(seminfo
)save_and_next(ls
);
2819 seminfo
->ts
=luaX_newstring(ls
,luaZ_buffer(ls
->buff
)+(2+sep
),
2820 luaZ_bufflen(ls
->buff
)-2*(2+sep
));
2822 static void read_string(LexState
*ls
,int del
,SemInfo
*seminfo
){
2824 while(ls
->current
!=del
){
2825 switch(ls
->current
){
2827 luaX_lexerror(ls
,"unfinished string",TK_EOS
);
2831 luaX_lexerror(ls
,"unfinished string",TK_STRING
);
2836 switch(ls
->current
){
2837 case'a':c
='\a';break;
2838 case'b':c
='\b';break;
2839 case'f':c
='\f';break;
2840 case'n':c
='\n';break;
2841 case'r':c
='\r';break;
2842 case't':c
='\t';break;
2843 case'v':c
='\v';break;
2845 case'\r':save(ls
,'\n');inclinenumber(ls
);continue;
2848 if(!isdigit(ls
->current
))
2854 c
=10*c
+(ls
->current
-'0');
2856 }while(++i
<3&&isdigit(ls
->current
));
2858 luaX_lexerror(ls
,"escape sequence too large",TK_STRING
);
2873 seminfo
->ts
=luaX_newstring(ls
,luaZ_buffer(ls
->buff
)+1,
2874 luaZ_bufflen(ls
->buff
)-2);
2876 static int llex(LexState
*ls
,SemInfo
*seminfo
){
2877 luaZ_resetbuffer(ls
->buff
);
2879 switch(ls
->current
){
2887 if(ls
->current
!='-')return'-';
2889 if(ls
->current
=='['){
2890 int sep
=skip_sep(ls
);
2891 luaZ_resetbuffer(ls
->buff
);
2893 read_long_string(ls
,NULL
,sep
);
2894 luaZ_resetbuffer(ls
->buff
);
2898 while(!currIsNewline(ls
)&&ls
->current
!=(-1))
2903 int sep
=skip_sep(ls
);
2905 read_long_string(ls
,seminfo
,sep
);
2908 else if(sep
==-1)return'[';
2909 else luaX_lexerror(ls
,"invalid long string delimiter",TK_STRING
);
2913 if(ls
->current
!='=')return'=';
2914 else{next(ls
);return TK_EQ
;}
2918 if(ls
->current
!='=')return'<';
2919 else{next(ls
);return TK_LE
;}
2923 if(ls
->current
!='=')return'>';
2924 else{next(ls
);return TK_GE
;}
2928 if(ls
->current
!='=')return'~';
2929 else{next(ls
);return TK_NE
;}
2933 read_string(ls
,ls
->current
,seminfo
);
2938 if(check_next(ls
,".")){
2939 if(check_next(ls
,"."))
2941 else return TK_CONCAT
;
2943 else if(!isdigit(ls
->current
))return'.';
2945 read_numeral(ls
,seminfo
);
2953 if(isspace(ls
->current
)){
2957 else if(isdigit(ls
->current
)){
2958 read_numeral(ls
,seminfo
);
2961 else if(isalpha(ls
->current
)||ls
->current
=='_'){
2965 }while(isalnum(ls
->current
)||ls
->current
=='_');
2966 ts
=luaX_newstring(ls
,luaZ_buffer(ls
->buff
),
2967 luaZ_bufflen(ls
->buff
));
2968 if(ts
->tsv
.reserved
>0)
2969 return ts
->tsv
.reserved
-1+257;
2984 static void luaX_next(LexState
*ls
){
2985 ls
->lastline
=ls
->linenumber
;
2986 if(ls
->lookahead
.token
!=TK_EOS
){
2987 ls
->t
=ls
->lookahead
;
2988 ls
->lookahead
.token
=TK_EOS
;
2991 ls
->t
.token
=llex(ls
,&ls
->t
.seminfo
);
2993 static void luaX_lookahead(LexState
*ls
){
2994 ls
->lookahead
.token
=llex(ls
,&ls
->lookahead
.seminfo
);
2996 #define hasjumps(e)((e)->t!=(e)->f)
2997 static int isnumeral(expdesc
*e
){
2998 return(e
->k
==VKNUM
&&e
->t
==(-1)&&e
->f
==(-1));
3000 static void luaK_nil(FuncState
*fs
,int from
,int n
){
3001 Instruction
*previous
;
3002 if(fs
->pc
>fs
->lasttarget
){
3004 if(from
>=fs
->nactvar
)
3008 previous
=&fs
->f
->code
[fs
->pc
-1];
3009 if(GET_OPCODE(*previous
)==OP_LOADNIL
){
3010 int pfrom
=GETARG_A(*previous
);
3011 int pto
=GETARG_B(*previous
);
3012 if(pfrom
<=from
&&from
<=pto
+1){
3014 SETARG_B(*previous
,from
+n
-1);
3020 luaK_codeABC(fs
,OP_LOADNIL
,from
,from
+n
-1,0);
3022 static int luaK_jump(FuncState
*fs
){
3026 j
=luaK_codeAsBx(fs
,OP_JMP
,0,(-1));
3027 luaK_concat(fs
,&j
,jpc
);
3030 static void luaK_ret(FuncState
*fs
,int first
,int nret
){
3031 luaK_codeABC(fs
,OP_RETURN
,first
,nret
+1,0);
3033 static int condjump(FuncState
*fs
,OpCode op
,int A
,int B
,int C
){
3034 luaK_codeABC(fs
,op
,A
,B
,C
);
3035 return luaK_jump(fs
);
3037 static void fixjump(FuncState
*fs
,int pc
,int dest
){
3038 Instruction
*jmp
=&fs
->f
->code
[pc
];
3039 int offset
=dest
-(pc
+1);
3040 if(abs(offset
)>(((1<<(9+9))-1)>>1))
3041 luaX_syntaxerror(fs
->ls
,"control structure too long");
3042 SETARG_sBx(*jmp
,offset
);
3044 static int luaK_getlabel(FuncState
*fs
){
3045 fs
->lasttarget
=fs
->pc
;
3048 static int getjump(FuncState
*fs
,int pc
){
3049 int offset
=GETARG_sBx(fs
->f
->code
[pc
]);
3053 return(pc
+1)+offset
;
3055 static Instruction
*getjumpcontrol(FuncState
*fs
,int pc
){
3056 Instruction
*pi
=&fs
->f
->code
[pc
];
3057 if(pc
>=1&&testTMode(GET_OPCODE(*(pi
-1))))
3062 static int need_value(FuncState
*fs
,int list
){
3063 for(;list
!=(-1);list
=getjump(fs
,list
)){
3064 Instruction i
=*getjumpcontrol(fs
,list
);
3065 if(GET_OPCODE(i
)!=OP_TESTSET
)return 1;
3069 static int patchtestreg(FuncState
*fs
,int node
,int reg
){
3070 Instruction
*i
=getjumpcontrol(fs
,node
);
3071 if(GET_OPCODE(*i
)!=OP_TESTSET
)
3073 if(reg
!=((1<<8)-1)&®
!=GETARG_B(*i
))
3076 *i
=CREATE_ABC(OP_TEST
,GETARG_B(*i
),0,GETARG_C(*i
));
3079 static void removevalues(FuncState
*fs
,int list
){
3080 for(;list
!=(-1);list
=getjump(fs
,list
))
3081 patchtestreg(fs
,list
,((1<<8)-1));
3083 static void patchlistaux(FuncState
*fs
,int list
,int vtarget
,int reg
,
3086 int next
=getjump(fs
,list
);
3087 if(patchtestreg(fs
,list
,reg
))
3088 fixjump(fs
,list
,vtarget
);
3090 fixjump(fs
,list
,dtarget
);
3094 static void dischargejpc(FuncState
*fs
){
3095 patchlistaux(fs
,fs
->jpc
,fs
->pc
,((1<<8)-1),fs
->pc
);
3098 static void luaK_patchlist(FuncState
*fs
,int list
,int target
){
3100 luaK_patchtohere(fs
,list
);
3102 patchlistaux(fs
,list
,target
,((1<<8)-1),target
);
3105 static void luaK_patchtohere(FuncState
*fs
,int list
){
3107 luaK_concat(fs
,&fs
->jpc
,list
);
3109 static void luaK_concat(FuncState
*fs
,int*l1
,int l2
){
3116 while((next
=getjump(fs
,list
))!=(-1))
3118 fixjump(fs
,list
,l2
);
3121 static void luaK_checkstack(FuncState
*fs
,int n
){
3122 int newstack
=fs
->freereg
+n
;
3123 if(newstack
>fs
->f
->maxstacksize
){
3125 luaX_syntaxerror(fs
->ls
,"function or expression too complex");
3126 fs
->f
->maxstacksize
=cast_byte(newstack
);
3129 static void luaK_reserveregs(FuncState
*fs
,int n
){
3130 luaK_checkstack(fs
,n
);
3133 static void freereg(FuncState
*fs
,int reg
){
3134 if(!ISK(reg
)&®
>=fs
->nactvar
){
3138 static void freeexp(FuncState
*fs
,expdesc
*e
){
3140 freereg(fs
,e
->u
.s
.info
);
3142 static int addk(FuncState
*fs
,TValue
*k
,TValue
*v
){
3144 TValue
*idx
=luaH_set(L
,fs
->h
,k
);
3146 int oldsize
=f
->sizek
;
3147 if(ttisnumber(idx
)){
3148 return cast_int(nvalue(idx
));
3151 setnvalue(idx
,cast_num(fs
->nk
));
3152 luaM_growvector(L
,f
->k
,fs
->nk
,f
->sizek
,TValue
,
3153 ((1<<(9+9))-1),"constant table overflow");
3154 while(oldsize
<f
->sizek
)setnilvalue(&f
->k
[oldsize
++]);
3155 setobj(L
,&f
->k
[fs
->nk
],v
);
3156 luaC_barrier(L
,f
,v
);
3160 static int luaK_stringK(FuncState
*fs
,TString
*s
){
3162 setsvalue(fs
->L
,&o
,s
);
3163 return addk(fs
,&o
,&o
);
3165 static int luaK_numberK(FuncState
*fs
,lua_Number r
){
3168 return addk(fs
,&o
,&o
);
3170 static int boolK(FuncState
*fs
,int b
){
3173 return addk(fs
,&o
,&o
);
3175 static int nilK(FuncState
*fs
){
3178 sethvalue(fs
->L
,&k
,fs
->h
);
3179 return addk(fs
,&k
,&v
);
3181 static void luaK_setreturns(FuncState
*fs
,expdesc
*e
,int nresults
){
3183 SETARG_C(getcode(fs
,e
),nresults
+1);
3185 else if(e
->k
==VVARARG
){
3186 SETARG_B(getcode(fs
,e
),nresults
+1);
3187 SETARG_A(getcode(fs
,e
),fs
->freereg
);
3188 luaK_reserveregs(fs
,1);
3191 static void luaK_setoneret(FuncState
*fs
,expdesc
*e
){
3194 e
->u
.s
.info
=GETARG_A(getcode(fs
,e
));
3196 else if(e
->k
==VVARARG
){
3197 SETARG_B(getcode(fs
,e
),2);
3201 static void luaK_dischargevars(FuncState
*fs
,expdesc
*e
){
3208 e
->u
.s
.info
=luaK_codeABC(fs
,OP_GETUPVAL
,0,e
->u
.s
.info
,0);
3213 e
->u
.s
.info
=luaK_codeABx(fs
,OP_GETGLOBAL
,0,e
->u
.s
.info
);
3218 freereg(fs
,e
->u
.s
.aux
);
3219 freereg(fs
,e
->u
.s
.info
);
3220 e
->u
.s
.info
=luaK_codeABC(fs
,OP_GETTABLE
,0,e
->u
.s
.info
,e
->u
.s
.aux
);
3226 luaK_setoneret(fs
,e
);
3232 static int code_label(FuncState
*fs
,int A
,int b
,int jump
){
3234 return luaK_codeABC(fs
,OP_LOADBOOL
,A
,b
,jump
);
3236 static void discharge2reg(FuncState
*fs
,expdesc
*e
,int reg
){
3237 luaK_dischargevars(fs
,e
);
3243 case VFALSE
:case VTRUE
:{
3244 luaK_codeABC(fs
,OP_LOADBOOL
,reg
,e
->k
==VTRUE
,0);
3248 luaK_codeABx(fs
,OP_LOADK
,reg
,e
->u
.s
.info
);
3252 luaK_codeABx(fs
,OP_LOADK
,reg
,luaK_numberK(fs
,e
->u
.nval
));
3256 Instruction
*pc
=&getcode(fs
,e
);
3261 if(reg
!=e
->u
.s
.info
)
3262 luaK_codeABC(fs
,OP_MOVE
,reg
,e
->u
.s
.info
,0);
3272 static void discharge2anyreg(FuncState
*fs
,expdesc
*e
){
3273 if(e
->k
!=VNONRELOC
){
3274 luaK_reserveregs(fs
,1);
3275 discharge2reg(fs
,e
,fs
->freereg
-1);
3278 static void exp2reg(FuncState
*fs
,expdesc
*e
,int reg
){
3279 discharge2reg(fs
,e
,reg
);
3281 luaK_concat(fs
,&e
->t
,e
->u
.s
.info
);
3286 if(need_value(fs
,e
->t
)||need_value(fs
,e
->f
)){
3287 int fj
=(e
->k
==VJMP
)?(-1):luaK_jump(fs
);
3288 p_f
=code_label(fs
,reg
,0,1);
3289 p_t
=code_label(fs
,reg
,1,0);
3290 luaK_patchtohere(fs
,fj
);
3292 final
=luaK_getlabel(fs
);
3293 patchlistaux(fs
,e
->f
,final
,reg
,p_f
);
3294 patchlistaux(fs
,e
->t
,final
,reg
,p_t
);
3300 static void luaK_exp2nextreg(FuncState
*fs
,expdesc
*e
){
3301 luaK_dischargevars(fs
,e
);
3303 luaK_reserveregs(fs
,1);
3304 exp2reg(fs
,e
,fs
->freereg
-1);
3306 static int luaK_exp2anyreg(FuncState
*fs
,expdesc
*e
){
3307 luaK_dischargevars(fs
,e
);
3308 if(e
->k
==VNONRELOC
){
3309 if(!hasjumps(e
))return e
->u
.s
.info
;
3310 if(e
->u
.s
.info
>=fs
->nactvar
){
3311 exp2reg(fs
,e
,e
->u
.s
.info
);
3315 luaK_exp2nextreg(fs
,e
);
3318 static void luaK_exp2val(FuncState
*fs
,expdesc
*e
){
3320 luaK_exp2anyreg(fs
,e
);
3322 luaK_dischargevars(fs
,e
);
3324 static int luaK_exp2RK(FuncState
*fs
,expdesc
*e
){
3331 if(fs
->nk
<=((1<<(9-1))-1)){
3332 e
->u
.s
.info
=(e
->k
==VNIL
)?nilK(fs
):
3333 (e
->k
==VKNUM
)?luaK_numberK(fs
,e
->u
.nval
):
3334 boolK(fs
,(e
->k
==VTRUE
));
3336 return RKASK(e
->u
.s
.info
);
3341 if(e
->u
.s
.info
<=((1<<(9-1))-1))
3342 return RKASK(e
->u
.s
.info
);
3347 return luaK_exp2anyreg(fs
,e
);
3349 static void luaK_storevar(FuncState
*fs
,expdesc
*var
,expdesc
*ex
){
3353 exp2reg(fs
,ex
,var
->u
.s
.info
);
3357 int e
=luaK_exp2anyreg(fs
,ex
);
3358 luaK_codeABC(fs
,OP_SETUPVAL
,e
,var
->u
.s
.info
,0);
3362 int e
=luaK_exp2anyreg(fs
,ex
);
3363 luaK_codeABx(fs
,OP_SETGLOBAL
,e
,var
->u
.s
.info
);
3367 int e
=luaK_exp2RK(fs
,ex
);
3368 luaK_codeABC(fs
,OP_SETTABLE
,var
->u
.s
.info
,var
->u
.s
.aux
,e
);
3377 static void luaK_self(FuncState
*fs
,expdesc
*e
,expdesc
*key
){
3379 luaK_exp2anyreg(fs
,e
);
3382 luaK_reserveregs(fs
,2);
3383 luaK_codeABC(fs
,OP_SELF
,func
,e
->u
.s
.info
,luaK_exp2RK(fs
,key
));
3388 static void invertjump(FuncState
*fs
,expdesc
*e
){
3389 Instruction
*pc
=getjumpcontrol(fs
,e
->u
.s
.info
);
3390 SETARG_A(*pc
,!(GETARG_A(*pc
)));
3392 static int jumponcond(FuncState
*fs
,expdesc
*e
,int cond
){
3393 if(e
->k
==VRELOCABLE
){
3394 Instruction ie
=getcode(fs
,e
);
3395 if(GET_OPCODE(ie
)==OP_NOT
){
3397 return condjump(fs
,OP_TEST
,GETARG_B(ie
),0,!cond
);
3400 discharge2anyreg(fs
,e
);
3402 return condjump(fs
,OP_TESTSET
,((1<<8)-1),e
->u
.s
.info
,cond
);
3404 static void luaK_goiftrue(FuncState
*fs
,expdesc
*e
){
3406 luaK_dischargevars(fs
,e
);
3408 case VK
:case VKNUM
:case VTRUE
:{
3418 pc
=jumponcond(fs
,e
,0);
3422 luaK_concat(fs
,&e
->f
,pc
);
3423 luaK_patchtohere(fs
,e
->t
);
3426 static void luaK_goiffalse(FuncState
*fs
,expdesc
*e
){
3428 luaK_dischargevars(fs
,e
);
3430 case VNIL
:case VFALSE
:{
3439 pc
=jumponcond(fs
,e
,1);
3443 luaK_concat(fs
,&e
->t
,pc
);
3444 luaK_patchtohere(fs
,e
->f
);
3447 static void codenot(FuncState
*fs
,expdesc
*e
){
3448 luaK_dischargevars(fs
,e
);
3450 case VNIL
:case VFALSE
:{
3454 case VK
:case VKNUM
:case VTRUE
:{
3464 discharge2anyreg(fs
,e
);
3466 e
->u
.s
.info
=luaK_codeABC(fs
,OP_NOT
,0,e
->u
.s
.info
,0);
3474 {int temp
=e
->f
;e
->f
=e
->t
;e
->t
=temp
;}
3475 removevalues(fs
,e
->f
);
3476 removevalues(fs
,e
->t
);
3478 static void luaK_indexed(FuncState
*fs
,expdesc
*t
,expdesc
*k
){
3479 t
->u
.s
.aux
=luaK_exp2RK(fs
,k
);
3482 static int constfolding(OpCode op
,expdesc
*e1
,expdesc
*e2
){
3484 if(!isnumeral(e1
)||!isnumeral(e2
))return 0;
3488 case OP_ADD
:r
=luai_numadd(v1
,v2
);break;
3489 case OP_SUB
:r
=luai_numsub(v1
,v2
);break;
3490 case OP_MUL
:r
=luai_nummul(v1
,v2
);break;
3493 r
=luai_numdiv(v1
,v2
);break;
3496 r
=luai_nummod(v1
,v2
);break;
3497 case OP_POW
:r
=luai_numpow(v1
,v2
);break;
3498 case OP_UNM
:r
=luai_numunm(v1
);break;
3499 case OP_LEN
:return 0;
3502 if(luai_numisnan(r
))return 0;
3506 static void codearith(FuncState
*fs
,OpCode op
,expdesc
*e1
,expdesc
*e2
){
3507 if(constfolding(op
,e1
,e2
))
3510 int o2
=(op
!=OP_UNM
&&op
!=OP_LEN
)?luaK_exp2RK(fs
,e2
):0;
3511 int o1
=luaK_exp2RK(fs
,e1
);
3520 e1
->u
.s
.info
=luaK_codeABC(fs
,op
,0,o1
,o2
);
3524 static void codecomp(FuncState
*fs
,OpCode op
,int cond
,expdesc
*e1
,
3526 int o1
=luaK_exp2RK(fs
,e1
);
3527 int o2
=luaK_exp2RK(fs
,e2
);
3530 if(cond
==0&&op
!=OP_EQ
){
3532 temp
=o1
;o1
=o2
;o2
=temp
;
3535 e1
->u
.s
.info
=condjump(fs
,op
,cond
,o1
,o2
);
3538 static void luaK_prefix(FuncState
*fs
,UnOpr op
,expdesc
*e
){
3540 e2
.t
=e2
.f
=(-1);e2
.k
=VKNUM
;e2
.u
.nval
=0;
3544 luaK_exp2anyreg(fs
,e
);
3545 codearith(fs
,OP_UNM
,e
,&e2
);
3548 case OPR_NOT
:codenot(fs
,e
);break;
3550 luaK_exp2anyreg(fs
,e
);
3551 codearith(fs
,OP_LEN
,e
,&e2
);
3557 static void luaK_infix(FuncState
*fs
,BinOpr op
,expdesc
*v
){
3560 luaK_goiftrue(fs
,v
);
3564 luaK_goiffalse(fs
,v
);
3568 luaK_exp2nextreg(fs
,v
);
3571 case OPR_ADD
:case OPR_SUB
:case OPR_MUL
:case OPR_DIV
:
3572 case OPR_MOD
:case OPR_POW
:{
3573 if(!isnumeral(v
))luaK_exp2RK(fs
,v
);
3582 static void luaK_posfix(FuncState
*fs
,BinOpr op
,expdesc
*e1
,expdesc
*e2
){
3585 luaK_dischargevars(fs
,e2
);
3586 luaK_concat(fs
,&e2
->f
,e1
->f
);
3591 luaK_dischargevars(fs
,e2
);
3592 luaK_concat(fs
,&e2
->t
,e1
->t
);
3597 luaK_exp2val(fs
,e2
);
3598 if(e2
->k
==VRELOCABLE
&&GET_OPCODE(getcode(fs
,e2
))==OP_CONCAT
){
3600 SETARG_B(getcode(fs
,e2
),e1
->u
.s
.info
);
3601 e1
->k
=VRELOCABLE
;e1
->u
.s
.info
=e2
->u
.s
.info
;
3604 luaK_exp2nextreg(fs
,e2
);
3605 codearith(fs
,OP_CONCAT
,e1
,e2
);
3609 case OPR_ADD
:codearith(fs
,OP_ADD
,e1
,e2
);break;
3610 case OPR_SUB
:codearith(fs
,OP_SUB
,e1
,e2
);break;
3611 case OPR_MUL
:codearith(fs
,OP_MUL
,e1
,e2
);break;
3612 case OPR_DIV
:codearith(fs
,OP_DIV
,e1
,e2
);break;
3613 case OPR_MOD
:codearith(fs
,OP_MOD
,e1
,e2
);break;
3614 case OPR_POW
:codearith(fs
,OP_POW
,e1
,e2
);break;
3615 case OPR_EQ
:codecomp(fs
,OP_EQ
,1,e1
,e2
);break;
3616 case OPR_NE
:codecomp(fs
,OP_EQ
,0,e1
,e2
);break;
3617 case OPR_LT
:codecomp(fs
,OP_LT
,1,e1
,e2
);break;
3618 case OPR_LE
:codecomp(fs
,OP_LE
,1,e1
,e2
);break;
3619 case OPR_GT
:codecomp(fs
,OP_LT
,0,e1
,e2
);break;
3620 case OPR_GE
:codecomp(fs
,OP_LE
,0,e1
,e2
);break;
3624 static void luaK_fixline(FuncState
*fs
,int line
){
3625 fs
->f
->lineinfo
[fs
->pc
-1]=line
;
3627 static int luaK_code(FuncState
*fs
,Instruction i
,int line
){
3630 luaM_growvector(fs
->L
,f
->code
,fs
->pc
,f
->sizecode
,Instruction
,
3631 (INT_MAX
-2),"code size overflow");
3633 luaM_growvector(fs
->L
,f
->lineinfo
,fs
->pc
,f
->sizelineinfo
,int,
3634 (INT_MAX
-2),"code size overflow");
3635 f
->lineinfo
[fs
->pc
]=line
;
3638 static int luaK_codeABC(FuncState
*fs
,OpCode o
,int a
,int b
,int c
){
3639 return luaK_code(fs
,CREATE_ABC(o
,a
,b
,c
),fs
->ls
->lastline
);
3641 static int luaK_codeABx(FuncState
*fs
,OpCode o
,int a
,unsigned int bc
){
3642 return luaK_code(fs
,CREATE_ABx(o
,a
,bc
),fs
->ls
->lastline
);
3644 static void luaK_setlist(FuncState
*fs
,int base
,int nelems
,int tostore
){
3645 int c
=(nelems
-1)/50+1;
3646 int b
=(tostore
==(-1))?0:tostore
;
3648 luaK_codeABC(fs
,OP_SETLIST
,base
,b
,c
);
3650 luaK_codeABC(fs
,OP_SETLIST
,base
,b
,0);
3651 luaK_code(fs
,cast(Instruction
,c
),fs
->ls
->lastline
);
3655 #define hasmultret(k)((k)==VCALL||(k)==VVARARG)
3656 #define getlocvar(fs,i)((fs)->f->locvars[(fs)->actvar[i]])
3657 #define luaY_checklimit(fs,v,l,m)if((v)>(l))errorlimit(fs,l,m)
3658 typedef struct BlockCnt
{
3659 struct BlockCnt
*previous
;
3663 lu_byte isbreakable
;
3665 static void chunk(LexState
*ls
);
3666 static void expr(LexState
*ls
,expdesc
*v
);
3667 static void anchor_token(LexState
*ls
){
3668 if(ls
->t
.token
==TK_NAME
||ls
->t
.token
==TK_STRING
){
3669 TString
*ts
=ls
->t
.seminfo
.ts
;
3670 luaX_newstring(ls
,getstr(ts
),ts
->tsv
.len
);
3673 static void error_expected(LexState
*ls
,int token
){
3674 luaX_syntaxerror(ls
,
3675 luaO_pushfstring(ls
->L
,LUA_QL("%s")" expected",luaX_token2str(ls
,token
)));
3677 static void errorlimit(FuncState
*fs
,int limit
,const char*what
){
3678 const char*msg
=(fs
->f
->linedefined
==0)?
3679 luaO_pushfstring(fs
->L
,"main function has more than %d %s",limit
,what
):
3680 luaO_pushfstring(fs
->L
,"function at line %d has more than %d %s",
3681 fs
->f
->linedefined
,limit
,what
);
3682 luaX_lexerror(fs
->ls
,msg
,0);
3684 static int testnext(LexState
*ls
,int c
){
3691 static void check(LexState
*ls
,int c
){
3693 error_expected(ls
,c
);
3695 static void checknext(LexState
*ls
,int c
){
3699 #define check_condition(ls,c,msg){if(!(c))luaX_syntaxerror(ls,msg);}
3700 static void check_match(LexState
*ls
,int what
,int who
,int where
){
3701 if(!testnext(ls
,what
)){
3702 if(where
==ls
->linenumber
)
3703 error_expected(ls
,what
);
3705 luaX_syntaxerror(ls
,luaO_pushfstring(ls
->L
,
3706 LUA_QL("%s")" expected (to close "LUA_QL("%s")" at line %d)",
3707 luaX_token2str(ls
,what
),luaX_token2str(ls
,who
),where
));
3711 static TString
*str_checkname(LexState
*ls
){
3714 ts
=ls
->t
.seminfo
.ts
;
3718 static void init_exp(expdesc
*e
,expkind k
,int i
){
3723 static void codestring(LexState
*ls
,expdesc
*e
,TString
*s
){
3724 init_exp(e
,VK
,luaK_stringK(ls
->fs
,s
));
3726 static void checkname(LexState
*ls
,expdesc
*e
){
3727 codestring(ls
,e
,str_checkname(ls
));
3729 static int registerlocalvar(LexState
*ls
,TString
*varname
){
3730 FuncState
*fs
=ls
->fs
;
3732 int oldsize
=f
->sizelocvars
;
3733 luaM_growvector(ls
->L
,f
->locvars
,fs
->nlocvars
,f
->sizelocvars
,
3734 LocVar
,SHRT_MAX
,"too many local variables");
3735 while(oldsize
<f
->sizelocvars
)f
->locvars
[oldsize
++].varname
=NULL
;
3736 f
->locvars
[fs
->nlocvars
].varname
=varname
;
3737 luaC_objbarrier(ls
->L
,f
,varname
);
3738 return fs
->nlocvars
++;
3740 #define new_localvarliteral(ls,v,n)new_localvar(ls,luaX_newstring(ls,""v,(sizeof(v)/sizeof(char))-1),n)
3741 static void new_localvar(LexState
*ls
,TString
*name
,int n
){
3742 FuncState
*fs
=ls
->fs
;
3743 luaY_checklimit(fs
,fs
->nactvar
+n
+1,200,"local variables");
3744 fs
->actvar
[fs
->nactvar
+n
]=cast(unsigned short,registerlocalvar(ls
,name
));
3746 static void adjustlocalvars(LexState
*ls
,int nvars
){
3747 FuncState
*fs
=ls
->fs
;
3748 fs
->nactvar
=cast_byte(fs
->nactvar
+nvars
);
3749 for(;nvars
;nvars
--){
3750 getlocvar(fs
,fs
->nactvar
-nvars
).startpc
=fs
->pc
;
3753 static void removevars(LexState
*ls
,int tolevel
){
3754 FuncState
*fs
=ls
->fs
;
3755 while(fs
->nactvar
>tolevel
)
3756 getlocvar(fs
,--fs
->nactvar
).endpc
=fs
->pc
;
3758 static int indexupvalue(FuncState
*fs
,TString
*name
,expdesc
*v
){
3761 int oldsize
=f
->sizeupvalues
;
3762 for(i
=0;i
<f
->nups
;i
++){
3763 if(fs
->upvalues
[i
].k
==v
->k
&&fs
->upvalues
[i
].info
==v
->u
.s
.info
){
3767 luaY_checklimit(fs
,f
->nups
+1,60,"upvalues");
3768 luaM_growvector(fs
->L
,f
->upvalues
,f
->nups
,f
->sizeupvalues
,
3769 TString
*,(INT_MAX
-2),"");
3770 while(oldsize
<f
->sizeupvalues
)f
->upvalues
[oldsize
++]=NULL
;
3771 f
->upvalues
[f
->nups
]=name
;
3772 luaC_objbarrier(fs
->L
,f
,name
);
3773 fs
->upvalues
[f
->nups
].k
=cast_byte(v
->k
);
3774 fs
->upvalues
[f
->nups
].info
=cast_byte(v
->u
.s
.info
);
3777 static int searchvar(FuncState
*fs
,TString
*n
){
3779 for(i
=fs
->nactvar
-1;i
>=0;i
--){
3780 if(n
==getlocvar(fs
,i
).varname
)
3785 static void markupval(FuncState
*fs
,int level
){
3787 while(bl
&&bl
->nactvar
>level
)bl
=bl
->previous
;
3790 static int singlevaraux(FuncState
*fs
,TString
*n
,expdesc
*var
,int base
){
3792 init_exp(var
,VGLOBAL
,((1<<8)-1));
3796 int v
=searchvar(fs
,n
);
3798 init_exp(var
,VLOCAL
,v
);
3804 if(singlevaraux(fs
->prev
,n
,var
,0)==VGLOBAL
)
3806 var
->u
.s
.info
=indexupvalue(fs
,n
,var
);
3812 static void singlevar(LexState
*ls
,expdesc
*var
){
3813 TString
*varname
=str_checkname(ls
);
3814 FuncState
*fs
=ls
->fs
;
3815 if(singlevaraux(fs
,varname
,var
,1)==VGLOBAL
)
3816 var
->u
.s
.info
=luaK_stringK(fs
,varname
);
3818 static void adjust_assign(LexState
*ls
,int nvars
,int nexps
,expdesc
*e
){
3819 FuncState
*fs
=ls
->fs
;
3820 int extra
=nvars
-nexps
;
3821 if(hasmultret(e
->k
)){
3824 luaK_setreturns(fs
,e
,extra
);
3825 if(extra
>1)luaK_reserveregs(fs
,extra
-1);
3828 if(e
->k
!=VVOID
)luaK_exp2nextreg(fs
,e
);
3830 int reg
=fs
->freereg
;
3831 luaK_reserveregs(fs
,extra
);
3832 luaK_nil(fs
,reg
,extra
);
3836 static void enterlevel(LexState
*ls
){
3837 if(++ls
->L
->nCcalls
>200)
3838 luaX_lexerror(ls
,"chunk has too many syntax levels",0);
3840 #define leavelevel(ls)((ls)->L->nCcalls--)
3841 static void enterblock(FuncState
*fs
,BlockCnt
*bl
,lu_byte isbreakable
){
3843 bl
->isbreakable
=isbreakable
;
3844 bl
->nactvar
=fs
->nactvar
;
3846 bl
->previous
=fs
->bl
;
3849 static void leaveblock(FuncState
*fs
){
3851 fs
->bl
=bl
->previous
;
3852 removevars(fs
->ls
,bl
->nactvar
);
3854 luaK_codeABC(fs
,OP_CLOSE
,bl
->nactvar
,0,0);
3855 fs
->freereg
=fs
->nactvar
;
3856 luaK_patchtohere(fs
,bl
->breaklist
);
3858 static void pushclosure(LexState
*ls
,FuncState
*func
,expdesc
*v
){
3859 FuncState
*fs
=ls
->fs
;
3861 int oldsize
=f
->sizep
;
3863 luaM_growvector(ls
->L
,f
->p
,fs
->np
,f
->sizep
,Proto
*,
3864 ((1<<(9+9))-1),"constant table overflow");
3865 while(oldsize
<f
->sizep
)f
->p
[oldsize
++]=NULL
;
3866 f
->p
[fs
->np
++]=func
->f
;
3867 luaC_objbarrier(ls
->L
,f
,func
->f
);
3868 init_exp(v
,VRELOCABLE
,luaK_codeABx(fs
,OP_CLOSURE
,0,fs
->np
-1));
3869 for(i
=0;i
<func
->f
->nups
;i
++){
3870 OpCode o
=(func
->upvalues
[i
].k
==VLOCAL
)?OP_MOVE
:OP_GETUPVAL
;
3871 luaK_codeABC(fs
,o
,0,func
->upvalues
[i
].info
,0);
3874 static void open_func(LexState
*ls
,FuncState
*fs
){
3876 Proto
*f
=luaF_newproto(L
);
3891 f
->source
=ls
->source
;
3893 fs
->h
=luaH_new(L
,0,0);
3894 sethvalue(L
,L
->top
,fs
->h
);
3896 setptvalue(L
,L
->top
,f
);
3899 static void close_func(LexState
*ls
){
3901 FuncState
*fs
=ls
->fs
;
3905 luaM_reallocvector(L
,f
->code
,f
->sizecode
,fs
->pc
,Instruction
);
3907 luaM_reallocvector(L
,f
->lineinfo
,f
->sizelineinfo
,fs
->pc
,int);
3908 f
->sizelineinfo
=fs
->pc
;
3909 luaM_reallocvector(L
,f
->k
,f
->sizek
,fs
->nk
,TValue
);
3911 luaM_reallocvector(L
,f
->p
,f
->sizep
,fs
->np
,Proto
*);
3913 luaM_reallocvector(L
,f
->locvars
,f
->sizelocvars
,fs
->nlocvars
,LocVar
);
3914 f
->sizelocvars
=fs
->nlocvars
;
3915 luaM_reallocvector(L
,f
->upvalues
,f
->sizeupvalues
,f
->nups
,TString
*);
3916 f
->sizeupvalues
=f
->nups
;
3918 if(fs
)anchor_token(ls
);
3921 static Proto
*luaY_parser(lua_State
*L
,ZIO
*z
,Mbuffer
*buff
,const char*name
){
3922 struct LexState lexstate
;
3923 struct FuncState funcstate
;
3925 luaX_setinput(L
,&lexstate
,z
,luaS_new(L
,name
));
3926 open_func(&lexstate
,&funcstate
);
3927 funcstate
.f
->is_vararg
=2;
3928 luaX_next(&lexstate
);
3930 check(&lexstate
,TK_EOS
);
3931 close_func(&lexstate
);
3934 static void field(LexState
*ls
,expdesc
*v
){
3935 FuncState
*fs
=ls
->fs
;
3937 luaK_exp2anyreg(fs
,v
);
3940 luaK_indexed(fs
,v
,&key
);
3942 static void yindex(LexState
*ls
,expdesc
*v
){
3945 luaK_exp2val(ls
->fs
,v
);
3955 static void recfield(LexState
*ls
,struct ConsControl
*cc
){
3956 FuncState
*fs
=ls
->fs
;
3957 int reg
=ls
->fs
->freereg
;
3960 if(ls
->t
.token
==TK_NAME
){
3961 luaY_checklimit(fs
,cc
->nh
,(INT_MAX
-2),"items in a constructor");
3968 rkkey
=luaK_exp2RK(fs
,&key
);
3970 luaK_codeABC(fs
,OP_SETTABLE
,cc
->t
->u
.s
.info
,rkkey
,luaK_exp2RK(fs
,&val
));
3973 static void closelistfield(FuncState
*fs
,struct ConsControl
*cc
){
3974 if(cc
->v
.k
==VVOID
)return;
3975 luaK_exp2nextreg(fs
,&cc
->v
);
3977 if(cc
->tostore
==50){
3978 luaK_setlist(fs
,cc
->t
->u
.s
.info
,cc
->na
,cc
->tostore
);
3982 static void lastlistfield(FuncState
*fs
,struct ConsControl
*cc
){
3983 if(cc
->tostore
==0)return;
3984 if(hasmultret(cc
->v
.k
)){
3985 luaK_setmultret(fs
,&cc
->v
);
3986 luaK_setlist(fs
,cc
->t
->u
.s
.info
,cc
->na
,(-1));
3991 luaK_exp2nextreg(fs
,&cc
->v
);
3992 luaK_setlist(fs
,cc
->t
->u
.s
.info
,cc
->na
,cc
->tostore
);
3995 static void listfield(LexState
*ls
,struct ConsControl
*cc
){
3997 luaY_checklimit(ls
->fs
,cc
->na
,(INT_MAX
-2),"items in a constructor");
4001 static void constructor(LexState
*ls
,expdesc
*t
){
4002 FuncState
*fs
=ls
->fs
;
4003 int line
=ls
->linenumber
;
4004 int pc
=luaK_codeABC(fs
,OP_NEWTABLE
,0,0,0);
4005 struct ConsControl cc
;
4006 cc
.na
=cc
.nh
=cc
.tostore
=0;
4008 init_exp(t
,VRELOCABLE
,pc
);
4009 init_exp(&cc
.v
,VVOID
,0);
4010 luaK_exp2nextreg(ls
->fs
,t
);
4013 if(ls
->t
.token
=='}')break;
4014 closelistfield(fs
,&cc
);
4015 switch(ls
->t
.token
){
4018 if(ls
->lookahead
.token
!='=')
4033 }while(testnext(ls
,',')||testnext(ls
,';'));
4034 check_match(ls
,'}','{',line
);
4035 lastlistfield(fs
,&cc
);
4036 SETARG_B(fs
->f
->code
[pc
],luaO_int2fb(cc
.na
));
4037 SETARG_C(fs
->f
->code
[pc
],luaO_int2fb(cc
.nh
));
4039 static void parlist(LexState
*ls
){
4040 FuncState
*fs
=ls
->fs
;
4044 if(ls
->t
.token
!=')'){
4046 switch(ls
->t
.token
){
4048 new_localvar(ls
,str_checkname(ls
),nparams
++);
4056 default:luaX_syntaxerror(ls
,"<name> or "LUA_QL("...")" expected");
4058 }while(!f
->is_vararg
&&testnext(ls
,','));
4060 adjustlocalvars(ls
,nparams
);
4061 f
->numparams
=cast_byte(fs
->nactvar
-(f
->is_vararg
&1));
4062 luaK_reserveregs(fs
,fs
->nactvar
);
4064 static void body(LexState
*ls
,expdesc
*e
,int needself
,int line
){
4066 open_func(ls
,&new_fs
);
4067 new_fs
.f
->linedefined
=line
;
4070 new_localvarliteral(ls
,"self",0);
4071 adjustlocalvars(ls
,1);
4076 new_fs
.f
->lastlinedefined
=ls
->linenumber
;
4077 check_match(ls
,TK_END
,TK_FUNCTION
,line
);
4079 pushclosure(ls
,&new_fs
,e
);
4081 static int explist1(LexState
*ls
,expdesc
*v
){
4084 while(testnext(ls
,',')){
4085 luaK_exp2nextreg(ls
->fs
,v
);
4091 static void funcargs(LexState
*ls
,expdesc
*f
){
4092 FuncState
*fs
=ls
->fs
;
4095 int line
=ls
->linenumber
;
4096 switch(ls
->t
.token
){
4098 if(line
!=ls
->lastline
)
4099 luaX_syntaxerror(ls
,"ambiguous syntax (function call x new statement)");
4101 if(ls
->t
.token
==')')
4105 luaK_setmultret(fs
,&args
);
4107 check_match(ls
,')','(',line
);
4111 constructor(ls
,&args
);
4115 codestring(ls
,&args
,ls
->t
.seminfo
.ts
);
4120 luaX_syntaxerror(ls
,"function arguments expected");
4125 if(hasmultret(args
.k
))
4129 luaK_exp2nextreg(fs
,&args
);
4130 nparams
=fs
->freereg
-(base
+1);
4132 init_exp(f
,VCALL
,luaK_codeABC(fs
,OP_CALL
,base
,nparams
+1,2));
4133 luaK_fixline(fs
,line
);
4136 static void prefixexp(LexState
*ls
,expdesc
*v
){
4137 switch(ls
->t
.token
){
4139 int line
=ls
->linenumber
;
4142 check_match(ls
,')','(',line
);
4143 luaK_dischargevars(ls
->fs
,v
);
4151 luaX_syntaxerror(ls
,"unexpected symbol");
4156 static void primaryexp(LexState
*ls
,expdesc
*v
){
4157 FuncState
*fs
=ls
->fs
;
4160 switch(ls
->t
.token
){
4167 luaK_exp2anyreg(fs
,v
);
4169 luaK_indexed(fs
,v
,&key
);
4176 luaK_self(fs
,v
,&key
);
4180 case'(':case TK_STRING
:case'{':{
4181 luaK_exp2nextreg(fs
,v
);
4189 static void simpleexp(LexState
*ls
,expdesc
*v
){
4190 switch(ls
->t
.token
){
4192 init_exp(v
,VKNUM
,0);
4193 v
->u
.nval
=ls
->t
.seminfo
.r
;
4197 codestring(ls
,v
,ls
->t
.seminfo
.ts
);
4205 init_exp(v
,VTRUE
,0);
4209 init_exp(v
,VFALSE
,0);
4213 FuncState
*fs
=ls
->fs
;
4214 check_condition(ls
,fs
->f
->is_vararg
,
4215 "cannot use "LUA_QL("...")" outside a vararg function");
4216 fs
->f
->is_vararg
&=~4;
4217 init_exp(v
,VVARARG
,luaK_codeABC(fs
,OP_VARARG
,0,1,0));
4226 body(ls
,v
,0,ls
->linenumber
);
4236 static UnOpr
getunopr(int op
){
4238 case TK_NOT
:return OPR_NOT
;
4239 case'-':return OPR_MINUS
;
4240 case'#':return OPR_LEN
;
4241 default:return OPR_NOUNOPR
;
4244 static BinOpr
getbinopr(int op
){
4246 case'+':return OPR_ADD
;
4247 case'-':return OPR_SUB
;
4248 case'*':return OPR_MUL
;
4249 case'/':return OPR_DIV
;
4250 case'%':return OPR_MOD
;
4251 case'^':return OPR_POW
;
4252 case TK_CONCAT
:return OPR_CONCAT
;
4253 case TK_NE
:return OPR_NE
;
4254 case TK_EQ
:return OPR_EQ
;
4255 case'<':return OPR_LT
;
4256 case TK_LE
:return OPR_LE
;
4257 case'>':return OPR_GT
;
4258 case TK_GE
:return OPR_GE
;
4259 case TK_AND
:return OPR_AND
;
4260 case TK_OR
:return OPR_OR
;
4261 default:return OPR_NOBINOPR
;
4264 static const struct{
4268 {6,6},{6,6},{7,7},{7,7},{7,7},
4271 {3,3},{3,3},{3,3},{3,3},
4274 static BinOpr
subexpr(LexState
*ls
,expdesc
*v
,unsigned int limit
){
4278 uop
=getunopr(ls
->t
.token
);
4279 if(uop
!=OPR_NOUNOPR
){
4282 luaK_prefix(ls
->fs
,uop
,v
);
4284 else simpleexp(ls
,v
);
4285 op
=getbinopr(ls
->t
.token
);
4286 while(op
!=OPR_NOBINOPR
&&priority
[op
].left
>limit
){
4290 luaK_infix(ls
->fs
,op
,v
);
4291 nextop
=subexpr(ls
,&v2
,priority
[op
].right
);
4292 luaK_posfix(ls
->fs
,op
,v
,&v2
);
4298 static void expr(LexState
*ls
,expdesc
*v
){
4301 static int block_follow(int token
){
4303 case TK_ELSE
:case TK_ELSEIF
:case TK_END
:
4304 case TK_UNTIL
:case TK_EOS
:
4309 static void block(LexState
*ls
){
4310 FuncState
*fs
=ls
->fs
;
4312 enterblock(fs
,&bl
,0);
4317 struct LHS_assign
*prev
;
4320 static void check_conflict(LexState
*ls
,struct LHS_assign
*lh
,expdesc
*v
){
4321 FuncState
*fs
=ls
->fs
;
4322 int extra
=fs
->freereg
;
4324 for(;lh
;lh
=lh
->prev
){
4325 if(lh
->v
.k
==VINDEXED
){
4326 if(lh
->v
.u
.s
.info
==v
->u
.s
.info
){
4328 lh
->v
.u
.s
.info
=extra
;
4330 if(lh
->v
.u
.s
.aux
==v
->u
.s
.info
){
4332 lh
->v
.u
.s
.aux
=extra
;
4337 luaK_codeABC(fs
,OP_MOVE
,fs
->freereg
,v
->u
.s
.info
,0);
4338 luaK_reserveregs(fs
,1);
4341 static void assignment(LexState
*ls
,struct LHS_assign
*lh
,int nvars
){
4343 check_condition(ls
,VLOCAL
<=lh
->v
.k
&&lh
->v
.k
<=VINDEXED
,
4345 if(testnext(ls
,',')){
4346 struct LHS_assign nv
;
4348 primaryexp(ls
,&nv
.v
);
4350 check_conflict(ls
,lh
,&nv
.v
);
4351 luaY_checklimit(ls
->fs
,nvars
,200-ls
->L
->nCcalls
,
4352 "variables in assignment");
4353 assignment(ls
,&nv
,nvars
+1);
4358 nexps
=explist1(ls
,&e
);
4360 adjust_assign(ls
,nvars
,nexps
,&e
);
4362 ls
->fs
->freereg
-=nexps
-nvars
;
4365 luaK_setoneret(ls
->fs
,&e
);
4366 luaK_storevar(ls
->fs
,&lh
->v
,&e
);
4370 init_exp(&e
,VNONRELOC
,ls
->fs
->freereg
-1);
4371 luaK_storevar(ls
->fs
,&lh
->v
,&e
);
4373 static int cond(LexState
*ls
){
4376 if(v
.k
==VNIL
)v
.k
=VFALSE
;
4377 luaK_goiftrue(ls
->fs
,&v
);
4380 static void breakstat(LexState
*ls
){
4381 FuncState
*fs
=ls
->fs
;
4384 while(bl
&&!bl
->isbreakable
){
4389 luaX_syntaxerror(ls
,"no loop to break");
4391 luaK_codeABC(fs
,OP_CLOSE
,bl
->nactvar
,0,0);
4392 luaK_concat(fs
,&bl
->breaklist
,luaK_jump(fs
));
4394 static void whilestat(LexState
*ls
,int line
){
4395 FuncState
*fs
=ls
->fs
;
4400 whileinit
=luaK_getlabel(fs
);
4402 enterblock(fs
,&bl
,1);
4403 checknext(ls
,TK_DO
);
4405 luaK_patchlist(fs
,luaK_jump(fs
),whileinit
);
4406 check_match(ls
,TK_END
,TK_WHILE
,line
);
4408 luaK_patchtohere(fs
,condexit
);
4410 static void repeatstat(LexState
*ls
,int line
){
4412 FuncState
*fs
=ls
->fs
;
4413 int repeat_init
=luaK_getlabel(fs
);
4415 enterblock(fs
,&bl1
,1);
4416 enterblock(fs
,&bl2
,0);
4419 check_match(ls
,TK_UNTIL
,TK_REPEAT
,line
);
4423 luaK_patchlist(ls
->fs
,condexit
,repeat_init
);
4427 luaK_patchtohere(ls
->fs
,condexit
);
4429 luaK_patchlist(ls
->fs
,luaK_jump(fs
),repeat_init
);
4433 static int exp1(LexState
*ls
){
4438 luaK_exp2nextreg(ls
->fs
,&e
);
4441 static void forbody(LexState
*ls
,int base
,int line
,int nvars
,int isnum
){
4443 FuncState
*fs
=ls
->fs
;
4445 adjustlocalvars(ls
,3);
4446 checknext(ls
,TK_DO
);
4447 prep
=isnum
?luaK_codeAsBx(fs
,OP_FORPREP
,base
,(-1)):luaK_jump(fs
);
4448 enterblock(fs
,&bl
,0);
4449 adjustlocalvars(ls
,nvars
);
4450 luaK_reserveregs(fs
,nvars
);
4453 luaK_patchtohere(fs
,prep
);
4454 endfor
=(isnum
)?luaK_codeAsBx(fs
,OP_FORLOOP
,base
,(-1)):
4455 luaK_codeABC(fs
,OP_TFORLOOP
,base
,0,nvars
);
4456 luaK_fixline(fs
,line
);
4457 luaK_patchlist(fs
,(isnum
?endfor
:luaK_jump(fs
)),prep
+1);
4459 static void fornum(LexState
*ls
,TString
*varname
,int line
){
4460 FuncState
*fs
=ls
->fs
;
4461 int base
=fs
->freereg
;
4462 new_localvarliteral(ls
,"(for index)",0);
4463 new_localvarliteral(ls
,"(for limit)",1);
4464 new_localvarliteral(ls
,"(for step)",2);
4465 new_localvar(ls
,varname
,3);
4470 if(testnext(ls
,','))
4473 luaK_codeABx(fs
,OP_LOADK
,fs
->freereg
,luaK_numberK(fs
,1));
4474 luaK_reserveregs(fs
,1);
4476 forbody(ls
,base
,line
,1,1);
4478 static void forlist(LexState
*ls
,TString
*indexname
){
4479 FuncState
*fs
=ls
->fs
;
4483 int base
=fs
->freereg
;
4484 new_localvarliteral(ls
,"(for generator)",nvars
++);
4485 new_localvarliteral(ls
,"(for state)",nvars
++);
4486 new_localvarliteral(ls
,"(for control)",nvars
++);
4487 new_localvar(ls
,indexname
,nvars
++);
4488 while(testnext(ls
,','))
4489 new_localvar(ls
,str_checkname(ls
),nvars
++);
4490 checknext(ls
,TK_IN
);
4491 line
=ls
->linenumber
;
4492 adjust_assign(ls
,3,explist1(ls
,&e
),&e
);
4493 luaK_checkstack(fs
,3);
4494 forbody(ls
,base
,line
,nvars
-3,0);
4496 static void forstat(LexState
*ls
,int line
){
4497 FuncState
*fs
=ls
->fs
;
4500 enterblock(fs
,&bl
,1);
4502 varname
=str_checkname(ls
);
4503 switch(ls
->t
.token
){
4504 case'=':fornum(ls
,varname
,line
);break;
4505 case',':case TK_IN
:forlist(ls
,varname
);break;
4506 default:luaX_syntaxerror(ls
,LUA_QL("=")" or "LUA_QL("in")" expected");
4508 check_match(ls
,TK_END
,TK_FOR
,line
);
4511 static int test_then_block(LexState
*ls
){
4515 checknext(ls
,TK_THEN
);
4519 static void ifstat(LexState
*ls
,int line
){
4520 FuncState
*fs
=ls
->fs
;
4522 int escapelist
=(-1);
4523 flist
=test_then_block(ls
);
4524 while(ls
->t
.token
==TK_ELSEIF
){
4525 luaK_concat(fs
,&escapelist
,luaK_jump(fs
));
4526 luaK_patchtohere(fs
,flist
);
4527 flist
=test_then_block(ls
);
4529 if(ls
->t
.token
==TK_ELSE
){
4530 luaK_concat(fs
,&escapelist
,luaK_jump(fs
));
4531 luaK_patchtohere(fs
,flist
);
4536 luaK_concat(fs
,&escapelist
,flist
);
4537 luaK_patchtohere(fs
,escapelist
);
4538 check_match(ls
,TK_END
,TK_IF
,line
);
4540 static void localfunc(LexState
*ls
){
4542 FuncState
*fs
=ls
->fs
;
4543 new_localvar(ls
,str_checkname(ls
),0);
4544 init_exp(&v
,VLOCAL
,fs
->freereg
);
4545 luaK_reserveregs(fs
,1);
4546 adjustlocalvars(ls
,1);
4547 body(ls
,&b
,0,ls
->linenumber
);
4548 luaK_storevar(fs
,&v
,&b
);
4549 getlocvar(fs
,fs
->nactvar
-1).startpc
=fs
->pc
;
4551 static void localstat(LexState
*ls
){
4556 new_localvar(ls
,str_checkname(ls
),nvars
++);
4557 }while(testnext(ls
,','));
4558 if(testnext(ls
,'='))
4559 nexps
=explist1(ls
,&e
);
4564 adjust_assign(ls
,nvars
,nexps
,&e
);
4565 adjustlocalvars(ls
,nvars
);
4567 static int funcname(LexState
*ls
,expdesc
*v
){
4570 while(ls
->t
.token
=='.')
4572 if(ls
->t
.token
==':'){
4578 static void funcstat(LexState
*ls
,int line
){
4582 needself
=funcname(ls
,&v
);
4583 body(ls
,&b
,needself
,line
);
4584 luaK_storevar(ls
->fs
,&v
,&b
);
4585 luaK_fixline(ls
->fs
,line
);
4587 static void exprstat(LexState
*ls
){
4588 FuncState
*fs
=ls
->fs
;
4589 struct LHS_assign v
;
4590 primaryexp(ls
,&v
.v
);
4592 SETARG_C(getcode(fs
,&v
.v
),1);
4595 assignment(ls
,&v
,1);
4598 static void retstat(LexState
*ls
){
4599 FuncState
*fs
=ls
->fs
;
4603 if(block_follow(ls
->t
.token
)||ls
->t
.token
==';')
4606 nret
=explist1(ls
,&e
);
4607 if(hasmultret(e
.k
)){
4608 luaK_setmultret(fs
,&e
);
4609 if(e
.k
==VCALL
&&nret
==1){
4610 SET_OPCODE(getcode(fs
,&e
),OP_TAILCALL
);
4617 first
=luaK_exp2anyreg(fs
,&e
);
4619 luaK_exp2nextreg(fs
,&e
);
4624 luaK_ret(fs
,first
,nret
);
4626 static int statement(LexState
*ls
){
4627 int line
=ls
->linenumber
;
4628 switch(ls
->t
.token
){
4640 check_match(ls
,TK_END
,TK_DO
,line
);
4648 repeatstat(ls
,line
);
4657 if(testnext(ls
,TK_FUNCTION
))
4678 static void chunk(LexState
*ls
){
4681 while(!islast
&&!block_follow(ls
->t
.token
)){
4682 islast
=statement(ls
);
4684 ls
->fs
->freereg
=ls
->fs
->nactvar
;
4688 static const TValue
*luaV_tonumber(const TValue
*obj
,TValue
*n
){
4690 if(ttisnumber(obj
))return obj
;
4691 if(ttisstring(obj
)&&luaO_str2d(svalue(obj
),&num
)){
4698 static int luaV_tostring(lua_State
*L
,StkId obj
){
4699 if(!ttisnumber(obj
))
4703 lua_Number n
=nvalue(obj
);
4704 lua_number2str(s
,n
);
4705 setsvalue(L
,obj
,luaS_new(L
,s
));
4709 static void callTMres(lua_State
*L
,StkId res
,const TValue
*f
,
4710 const TValue
*p1
,const TValue
*p2
){
4711 ptrdiff_t result
=savestack(L
,res
);
4713 setobj(L
,L
->top
+1,p1
);
4714 setobj(L
,L
->top
+2,p2
);
4715 luaD_checkstack(L
,3);
4717 luaD_call(L
,L
->top
-3,1);
4718 res
=restorestack(L
,result
);
4720 setobj(L
,res
,L
->top
);
4722 static void callTM(lua_State
*L
,const TValue
*f
,const TValue
*p1
,
4723 const TValue
*p2
,const TValue
*p3
){
4725 setobj(L
,L
->top
+1,p1
);
4726 setobj(L
,L
->top
+2,p2
);
4727 setobj(L
,L
->top
+3,p3
);
4728 luaD_checkstack(L
,4);
4730 luaD_call(L
,L
->top
-4,0);
4732 static void luaV_gettable(lua_State
*L
,const TValue
*t
,TValue
*key
,StkId val
){
4734 for(loop
=0;loop
<100;loop
++){
4738 const TValue
*res
=luaH_get(h
,key
);
4740 (tm
=fasttm(L
,h
->metatable
,TM_INDEX
))==NULL
){
4745 else if(ttisnil(tm
=luaT_gettmbyobj(L
,t
,TM_INDEX
)))
4746 luaG_typeerror(L
,t
,"index");
4747 if(ttisfunction(tm
)){
4748 callTMres(L
,val
,tm
,t
,key
);
4753 luaG_runerror(L
,"loop in gettable");
4755 static void luaV_settable(lua_State
*L
,const TValue
*t
,TValue
*key
,StkId val
){
4758 for(loop
=0;loop
<100;loop
++){
4762 TValue
*oldval
=luaH_set(L
,h
,key
);
4763 if(!ttisnil(oldval
)||
4764 (tm
=fasttm(L
,h
->metatable
,TM_NEWINDEX
))==NULL
){
4765 setobj(L
,oldval
,val
);
4767 luaC_barriert(L
,h
,val
);
4771 else if(ttisnil(tm
=luaT_gettmbyobj(L
,t
,TM_NEWINDEX
)))
4772 luaG_typeerror(L
,t
,"index");
4773 if(ttisfunction(tm
)){
4774 callTM(L
,tm
,t
,key
,val
);
4780 luaG_runerror(L
,"loop in settable");
4782 static int call_binTM(lua_State
*L
,const TValue
*p1
,const TValue
*p2
,
4783 StkId res
,TMS event
){
4784 const TValue
*tm
=luaT_gettmbyobj(L
,p1
,event
);
4786 tm
=luaT_gettmbyobj(L
,p2
,event
);
4787 if(ttisnil(tm
))return 0;
4788 callTMres(L
,res
,tm
,p1
,p2
);
4791 static const TValue
*get_compTM(lua_State
*L
,Table
*mt1
,Table
*mt2
,
4793 const TValue
*tm1
=fasttm(L
,mt1
,event
);
4795 if(tm1
==NULL
)return NULL
;
4796 if(mt1
==mt2
)return tm1
;
4797 tm2
=fasttm(L
,mt2
,event
);
4798 if(tm2
==NULL
)return NULL
;
4799 if(luaO_rawequalObj(tm1
,tm2
))
4803 static int call_orderTM(lua_State
*L
,const TValue
*p1
,const TValue
*p2
,
4805 const TValue
*tm1
=luaT_gettmbyobj(L
,p1
,event
);
4807 if(ttisnil(tm1
))return-1;
4808 tm2
=luaT_gettmbyobj(L
,p2
,event
);
4809 if(!luaO_rawequalObj(tm1
,tm2
))
4811 callTMres(L
,L
->top
,tm1
,p1
,p2
);
4812 return!l_isfalse(L
->top
);
4814 static int l_strcmp(const TString
*ls
,const TString
*rs
){
4815 const char*l
=getstr(ls
);
4816 size_t ll
=ls
->tsv
.len
;
4817 const char*r
=getstr(rs
);
4818 size_t lr
=rs
->tsv
.len
;
4820 int temp
=strcoll(l
,r
);
4821 if(temp
!=0)return temp
;
4823 size_t len
=strlen(l
);
4825 return(len
==ll
)?0:1;
4829 l
+=len
;ll
-=len
;r
+=len
;lr
-=len
;
4833 static int luaV_lessthan(lua_State
*L
,const TValue
*l
,const TValue
*r
){
4835 if(ttype(l
)!=ttype(r
))
4836 return luaG_ordererror(L
,l
,r
);
4837 else if(ttisnumber(l
))
4838 return luai_numlt(nvalue(l
),nvalue(r
));
4839 else if(ttisstring(l
))
4840 return l_strcmp(rawtsvalue(l
),rawtsvalue(r
))<0;
4841 else if((res
=call_orderTM(L
,l
,r
,TM_LT
))!=-1)
4843 return luaG_ordererror(L
,l
,r
);
4845 static int lessequal(lua_State
*L
,const TValue
*l
,const TValue
*r
){
4847 if(ttype(l
)!=ttype(r
))
4848 return luaG_ordererror(L
,l
,r
);
4849 else if(ttisnumber(l
))
4850 return luai_numle(nvalue(l
),nvalue(r
));
4851 else if(ttisstring(l
))
4852 return l_strcmp(rawtsvalue(l
),rawtsvalue(r
))<=0;
4853 else if((res
=call_orderTM(L
,l
,r
,TM_LE
))!=-1)
4855 else if((res
=call_orderTM(L
,r
,l
,TM_LT
))!=-1)
4857 return luaG_ordererror(L
,l
,r
);
4859 static int luaV_equalval(lua_State
*L
,const TValue
*t1
,const TValue
*t2
){
4863 case 3:return luai_numeq(nvalue(t1
),nvalue(t2
));
4864 case 1:return bvalue(t1
)==bvalue(t2
);
4865 case 2:return pvalue(t1
)==pvalue(t2
);
4867 if(uvalue(t1
)==uvalue(t2
))return 1;
4868 tm
=get_compTM(L
,uvalue(t1
)->metatable
,uvalue(t2
)->metatable
,
4873 if(hvalue(t1
)==hvalue(t2
))return 1;
4874 tm
=get_compTM(L
,hvalue(t1
)->metatable
,hvalue(t2
)->metatable
,TM_EQ
);
4877 default:return gcvalue(t1
)==gcvalue(t2
);
4879 if(tm
==NULL
)return 0;
4880 callTMres(L
,L
->top
,tm
,t1
,t2
);
4881 return!l_isfalse(L
->top
);
4883 static void luaV_concat(lua_State
*L
,int total
,int last
){
4885 StkId top
=L
->base
+last
+1;
4887 if(!(ttisstring(top
-2)||ttisnumber(top
-2))||!tostring(L
,top
-1)){
4888 if(!call_binTM(L
,top
-2,top
-1,top
-2,TM_CONCAT
))
4889 luaG_concaterror(L
,top
-2,top
-1);
4890 }else if(tsvalue(top
-1)->len
==0)
4891 (void)tostring(L
,top
-2);
4893 size_t tl
=tsvalue(top
-1)->len
;
4896 for(n
=1;n
<total
&&tostring(L
,top
-n
-1);n
++){
4897 size_t l
=tsvalue(top
-n
-1)->len
;
4898 if(l
>=((size_t)(~(size_t)0)-2)-tl
)luaG_runerror(L
,"string length overflow");
4901 buffer
=luaZ_openspace(L
,&G(L
)->buff
,tl
);
4904 size_t l
=tsvalue(top
-i
)->len
;
4905 memcpy(buffer
+tl
,svalue(top
-i
),l
);
4908 setsvalue(L
,top
-n
,luaS_newlstr(L
,buffer
,tl
));
4914 static void Arith(lua_State
*L
,StkId ra
,const TValue
*rb
,
4915 const TValue
*rc
,TMS op
){
4918 if((b
=luaV_tonumber(rb
,&tempb
))!=NULL
&&
4919 (c
=luaV_tonumber(rc
,&tempc
))!=NULL
){
4920 lua_Number nb
=nvalue(b
),nc
=nvalue(c
);
4922 case TM_ADD
:setnvalue(ra
,luai_numadd(nb
,nc
));break;
4923 case TM_SUB
:setnvalue(ra
,luai_numsub(nb
,nc
));break;
4924 case TM_MUL
:setnvalue(ra
,luai_nummul(nb
,nc
));break;
4925 case TM_DIV
:setnvalue(ra
,luai_numdiv(nb
,nc
));break;
4926 case TM_MOD
:setnvalue(ra
,luai_nummod(nb
,nc
));break;
4927 case TM_POW
:setnvalue(ra
,luai_numpow(nb
,nc
));break;
4928 case TM_UNM
:setnvalue(ra
,luai_numunm(nb
));break;
4932 else if(!call_binTM(L
,rb
,rc
,ra
,op
))
4933 luaG_aritherror(L
,rb
,rc
);
4935 #define runtime_check(L,c){if(!(c))break;}
4936 #define RA(i)(base+GETARG_A(i))
4937 #define RB(i)check_exp(getBMode(GET_OPCODE(i))==OpArgR,base+GETARG_B(i))
4938 #define RKB(i)check_exp(getBMode(GET_OPCODE(i))==OpArgK,ISK(GETARG_B(i))?k+INDEXK(GETARG_B(i)):base+GETARG_B(i))
4939 #define RKC(i)check_exp(getCMode(GET_OPCODE(i))==OpArgK,ISK(GETARG_C(i))?k+INDEXK(GETARG_C(i)):base+GETARG_C(i))
4940 #define KBx(i)check_exp(getBMode(GET_OPCODE(i))==OpArgK,k+GETARG_Bx(i))
4941 #define dojump(L,pc,i){(pc)+=(i);}
4942 #define Protect(x){L->savedpc=pc;{x;};base=L->base;}
4943 #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));}
4944 static void luaV_execute(lua_State
*L
,int nexeccalls
){
4948 const Instruction
*pc
;
4951 cl
=&clvalue(L
->ci
->func
)->l
;
4955 const Instruction i
=*pc
++;
4958 switch(GET_OPCODE(i
)){
4964 setobj(L
,ra
,KBx(i
));
4968 setbvalue(ra
,GETARG_B(i
));
4969 if(GETARG_C(i
))pc
++;
4981 setobj(L
,ra
,cl
->upvals
[b
]->v
);
4987 sethvalue(L
,&g
,cl
->env
);
4988 Protect(luaV_gettable(L
,&g
,rb
,ra
));
4992 Protect(luaV_gettable(L
,RB(i
),RKC(i
),ra
));
4997 sethvalue(L
,&g
,cl
->env
);
4998 Protect(luaV_settable(L
,&g
,KBx(i
),ra
));
5002 UpVal
*uv
=cl
->upvals
[GETARG_B(i
)];
5004 luaC_barrier(L
,uv
,ra
);
5008 Protect(luaV_settable(L
,ra
,RKB(i
),RKC(i
)));
5014 sethvalue(L
,ra
,luaH_new(L
,luaO_fb2int(b
),luaO_fb2int(c
)));
5015 Protect(luaC_checkGC(L
));
5021 Protect(luaV_gettable(L
,rb
,RKC(i
),ra
));
5025 arith_op(luai_numadd
,TM_ADD
);
5029 arith_op(luai_numsub
,TM_SUB
);
5033 arith_op(luai_nummul
,TM_MUL
);
5037 arith_op(luai_numdiv
,TM_DIV
);
5041 arith_op(luai_nummod
,TM_MOD
);
5045 arith_op(luai_numpow
,TM_POW
);
5051 lua_Number nb
=nvalue(rb
);
5052 setnvalue(ra
,luai_numunm(nb
));
5055 Protect(Arith(L
,ra
,rb
,rb
,TM_UNM
));
5060 int res
=l_isfalse(RB(i
));
5065 const TValue
*rb
=RB(i
);
5068 setnvalue(ra
,cast_num(luaH_getn(hvalue(rb
))));
5072 setnvalue(ra
,cast_num(tsvalue(rb
)->len
));
5077 if(!call_binTM(L
,rb
,(&luaO_nilobject_
),ra
,TM_LEN
))
5078 luaG_typeerror(L
,rb
,"get length of");
5087 Protect(luaV_concat(L
,c
-b
+1,c
);luaC_checkGC(L
));
5088 setobj(L
,RA(i
),base
+b
);
5092 dojump(L
,pc
,GETARG_sBx(i
));
5099 if(equalobj(L
,rb
,rc
)==GETARG_A(i
))
5100 dojump(L
,pc
,GETARG_sBx(*pc
));
5107 if(luaV_lessthan(L
,RKB(i
),RKC(i
))==GETARG_A(i
))
5108 dojump(L
,pc
,GETARG_sBx(*pc
));
5115 if(lessequal(L
,RKB(i
),RKC(i
))==GETARG_A(i
))
5116 dojump(L
,pc
,GETARG_sBx(*pc
));
5122 if(l_isfalse(ra
)!=GETARG_C(i
))
5123 dojump(L
,pc
,GETARG_sBx(*pc
));
5129 if(l_isfalse(rb
)!=GETARG_C(i
)){
5131 dojump(L
,pc
,GETARG_sBx(*pc
));
5138 int nresults
=GETARG_C(i
)-1;
5139 if(b
!=0)L
->top
=ra
+b
;
5141 switch(luaD_precall(L
,ra
,nresults
)){
5147 if(nresults
>=0)L
->top
=L
->ci
->top
;
5158 if(b
!=0)L
->top
=ra
+b
;
5160 switch(luaD_precall(L
,ra
,(-1))){
5162 CallInfo
*ci
=L
->ci
-1;
5164 StkId func
=ci
->func
;
5165 StkId pfunc
=(ci
+1)->func
;
5166 if(L
->openupval
)luaF_close(L
,ci
->base
);
5167 L
->base
=ci
->base
=ci
->func
+((ci
+1)->base
-pfunc
);
5168 for(aux
=0;pfunc
+aux
<L
->top
;aux
++)
5169 setobj(L
,func
+aux
,pfunc
+aux
);
5170 ci
->top
=L
->top
=func
+aux
;
5171 ci
->savedpc
=L
->savedpc
;
5187 if(b
!=0)L
->top
=ra
+b
-1;
5188 if(L
->openupval
)luaF_close(L
,base
);
5190 b
=luaD_poscall(L
,ra
);
5194 if(b
)L
->top
=L
->ci
->top
;
5199 lua_Number step
=nvalue(ra
+2);
5200 lua_Number idx
=luai_numadd(nvalue(ra
),step
);
5201 lua_Number limit
=nvalue(ra
+1);
5202 if(luai_numlt(0,step
)?luai_numle(idx
,limit
)
5203 :luai_numle(limit
,idx
)){
5204 dojump(L
,pc
,GETARG_sBx(i
));
5206 setnvalue(ra
+3,idx
);
5211 const TValue
*init
=ra
;
5212 const TValue
*plimit
=ra
+1;
5213 const TValue
*pstep
=ra
+2;
5215 if(!tonumber(init
,ra
))
5216 luaG_runerror(L
,LUA_QL("for")" initial value must be a number");
5217 else if(!tonumber(plimit
,ra
+1))
5218 luaG_runerror(L
,LUA_QL("for")" limit must be a number");
5219 else if(!tonumber(pstep
,ra
+2))
5220 luaG_runerror(L
,LUA_QL("for")" step must be a number");
5221 setnvalue(ra
,luai_numsub(nvalue(ra
),nvalue(pstep
)));
5222 dojump(L
,pc
,GETARG_sBx(i
));
5227 setobj(L
,cb
+2,ra
+2);
5228 setobj(L
,cb
+1,ra
+1);
5231 Protect(luaD_call(L
,cb
,GETARG_C(i
)));
5236 dojump(L
,pc
,GETARG_sBx(*pc
));
5247 n
=cast_int(L
->top
-ra
)-1;
5250 if(c
==0)c
=cast_int(*pc
++);
5251 runtime_check(L
,ttistable(ra
));
5254 if(last
>h
->sizearray
)
5255 luaH_resizearray(L
,h
,last
);
5258 setobj(L
,luaH_setnum(L
,h
,last
--),val
);
5259 luaC_barriert(L
,h
,val
);
5271 p
=cl
->p
->p
[GETARG_Bx(i
)];
5273 ncl
=luaF_newLclosure(L
,nup
,cl
->env
);
5275 for(j
=0;j
<nup
;j
++,pc
++){
5276 if(GET_OPCODE(*pc
)==OP_GETUPVAL
)
5277 ncl
->l
.upvals
[j
]=cl
->upvals
[GETARG_B(*pc
)];
5279 ncl
->l
.upvals
[j
]=luaF_findupval(L
,base
+GETARG_B(*pc
));
5282 setclvalue(L
,ra
,ncl
);
5283 Protect(luaC_checkGC(L
));
5287 int b
=GETARG_B(i
)-1;
5290 int n
=cast_int(ci
->base
-ci
->func
)-cl
->p
->numparams
-1;
5292 Protect(luaD_checkstack(L
,n
));
5299 setobj(L
,ra
+j
,ci
->base
-n
+j
);
5310 #define api_checknelems(L,n)luai_apicheck(L,(n)<=(L->top-L->base))
5311 #define api_checkvalidindex(L,i)luai_apicheck(L,(i)!=(&luaO_nilobject_))
5312 #define api_incr_top(L){luai_apicheck(L,L->top<L->ci->top);L->top++;}
5313 static TValue
*index2adr(lua_State
*L
,int idx
){
5315 TValue
*o
=L
->base
+(idx
-1);
5316 luai_apicheck(L
,idx
<=L
->ci
->top
-L
->base
);
5317 if(o
>=L
->top
)return cast(TValue
*,(&luaO_nilobject_
));
5320 else if(idx
>(-10000)){
5321 luai_apicheck(L
,idx
!=0&&-idx
<=L
->top
-L
->base
);
5325 case(-10000):return registry(L
);
5327 Closure
*func
=curr_func(L
);
5328 sethvalue(L
,&L
->env
,func
->c
.env
);
5331 case(-10002):return gt(L
);
5333 Closure
*func
=curr_func(L
);
5335 return(idx
<=func
->c
.nupvalues
)
5336 ?&func
->c
.upvalue
[idx
-1]
5337 :cast(TValue
*,(&luaO_nilobject_
));
5341 static Table
*getcurrenv(lua_State
*L
){
5342 if(L
->ci
==L
->base_ci
)
5343 return hvalue(gt(L
));
5345 Closure
*func
=curr_func(L
);
5349 static int lua_checkstack(lua_State
*L
,int size
){
5351 if(size
>8000||(L
->top
-L
->base
+size
)>8000)
5354 luaD_checkstack(L
,size
);
5355 if(L
->ci
->top
<L
->top
+size
)
5356 L
->ci
->top
=L
->top
+size
;
5360 static lua_CFunction
lua_atpanic(lua_State
*L
,lua_CFunction panicf
){
5366 static int lua_gettop(lua_State
*L
){
5367 return cast_int(L
->top
-L
->base
);
5369 static void lua_settop(lua_State
*L
,int idx
){
5371 luai_apicheck(L
,idx
<=L
->stack_last
-L
->base
);
5372 while(L
->top
<L
->base
+idx
)
5373 setnilvalue(L
->top
++);
5377 luai_apicheck(L
,-(idx
+1)<=(L
->top
-L
->base
));
5381 static void lua_remove(lua_State
*L
,int idx
){
5384 api_checkvalidindex(L
,p
);
5385 while(++p
<L
->top
)setobj(L
,p
-1,p
);
5388 static void lua_insert(lua_State
*L
,int idx
){
5392 api_checkvalidindex(L
,p
);
5393 for(q
=L
->top
;q
>p
;q
--)setobj(L
,q
,q
-1);
5396 static void lua_replace(lua_State
*L
,int idx
){
5398 if(idx
==(-10001)&&L
->ci
==L
->base_ci
)
5399 luaG_runerror(L
,"no calling environment");
5400 api_checknelems(L
,1);
5402 api_checkvalidindex(L
,o
);
5404 Closure
*func
=curr_func(L
);
5405 luai_apicheck(L
,ttistable(L
->top
-1));
5406 func
->c
.env
=hvalue(L
->top
-1);
5407 luaC_barrier(L
,func
,L
->top
-1);
5410 setobj(L
,o
,L
->top
-1);
5412 luaC_barrier(L
,curr_func(L
),L
->top
-1);
5416 static void lua_pushvalue(lua_State
*L
,int idx
){
5417 setobj(L
,L
->top
,index2adr(L
,idx
));
5420 static int lua_type(lua_State
*L
,int idx
){
5421 StkId o
=index2adr(L
,idx
);
5422 return(o
==(&luaO_nilobject_
))?(-1):ttype(o
);
5424 static const char*lua_typename(lua_State
*L
,int t
){
5426 return(t
==(-1))?"no value":luaT_typenames
[t
];
5428 static int lua_iscfunction(lua_State
*L
,int idx
){
5429 StkId o
=index2adr(L
,idx
);
5430 return iscfunction(o
);
5432 static int lua_isnumber(lua_State
*L
,int idx
){
5434 const TValue
*o
=index2adr(L
,idx
);
5435 return tonumber(o
,&n
);
5437 static int lua_isstring(lua_State
*L
,int idx
){
5438 int t
=lua_type(L
,idx
);
5441 static int lua_rawequal(lua_State
*L
,int index1
,int index2
){
5442 StkId o1
=index2adr(L
,index1
);
5443 StkId o2
=index2adr(L
,index2
);
5444 return(o1
==(&luaO_nilobject_
)||o2
==(&luaO_nilobject_
))?0
5445 :luaO_rawequalObj(o1
,o2
);
5447 static int lua_lessthan(lua_State
*L
,int index1
,int index2
){
5450 o1
=index2adr(L
,index1
);
5451 o2
=index2adr(L
,index2
);
5452 i
=(o1
==(&luaO_nilobject_
)||o2
==(&luaO_nilobject_
))?0
5453 :luaV_lessthan(L
,o1
,o2
);
5456 static lua_Number
lua_tonumber(lua_State
*L
,int idx
){
5458 const TValue
*o
=index2adr(L
,idx
);
5464 static lua_Integer
lua_tointeger(lua_State
*L
,int idx
){
5466 const TValue
*o
=index2adr(L
,idx
);
5469 lua_Number num
=nvalue(o
);
5470 lua_number2integer(res
,num
);
5476 static int lua_toboolean(lua_State
*L
,int idx
){
5477 const TValue
*o
=index2adr(L
,idx
);
5478 return!l_isfalse(o
);
5480 static const char*lua_tolstring(lua_State
*L
,int idx
,size_t*len
){
5481 StkId o
=index2adr(L
,idx
);
5483 if(!luaV_tostring(L
,o
)){
5484 if(len
!=NULL
)*len
=0;
5490 if(len
!=NULL
)*len
=tsvalue(o
)->len
;
5493 static size_t lua_objlen(lua_State
*L
,int idx
){
5494 StkId o
=index2adr(L
,idx
);
5496 case 4:return tsvalue(o
)->len
;
5497 case 7:return uvalue(o
)->len
;
5498 case 5:return luaH_getn(hvalue(o
));
5501 l
=(luaV_tostring(L
,o
)?tsvalue(o
)->len
:0);
5507 static lua_CFunction
lua_tocfunction(lua_State
*L
,int idx
){
5508 StkId o
=index2adr(L
,idx
);
5509 return(!iscfunction(o
))?NULL
:clvalue(o
)->c
.f
;
5511 static void*lua_touserdata(lua_State
*L
,int idx
){
5512 StkId o
=index2adr(L
,idx
);
5514 case 7:return(rawuvalue(o
)+1);
5515 case 2:return pvalue(o
);
5516 default:return NULL
;
5519 static void lua_pushnil(lua_State
*L
){
5520 setnilvalue(L
->top
);
5523 static void lua_pushnumber(lua_State
*L
,lua_Number n
){
5524 setnvalue(L
->top
,n
);
5527 static void lua_pushinteger(lua_State
*L
,lua_Integer n
){
5528 setnvalue(L
->top
,cast_num(n
));
5531 static void lua_pushlstring(lua_State
*L
,const char*s
,size_t len
){
5533 setsvalue(L
,L
->top
,luaS_newlstr(L
,s
,len
));
5536 static void lua_pushstring(lua_State
*L
,const char*s
){
5540 lua_pushlstring(L
,s
,strlen(s
));
5542 static const char*lua_pushvfstring(lua_State
*L
,const char*fmt
,
5546 ret
=luaO_pushvfstring(L
,fmt
,argp
);
5549 static const char*lua_pushfstring(lua_State
*L
,const char*fmt
,...){
5554 ret
=luaO_pushvfstring(L
,fmt
,argp
);
5558 static void lua_pushcclosure(lua_State
*L
,lua_CFunction fn
,int n
){
5561 api_checknelems(L
,n
);
5562 cl
=luaF_newCclosure(L
,n
,getcurrenv(L
));
5566 setobj(L
,&cl
->c
.upvalue
[n
],L
->top
+n
);
5567 setclvalue(L
,L
->top
,cl
);
5570 static void lua_pushboolean(lua_State
*L
,int b
){
5571 setbvalue(L
->top
,(b
!=0));
5574 static int lua_pushthread(lua_State
*L
){
5575 setthvalue(L
,L
->top
,L
);
5577 return(G(L
)->mainthread
==L
);
5579 static void lua_gettable(lua_State
*L
,int idx
){
5582 api_checkvalidindex(L
,t
);
5583 luaV_gettable(L
,t
,L
->top
-1,L
->top
-1);
5585 static void lua_getfield(lua_State
*L
,int idx
,const char*k
){
5589 api_checkvalidindex(L
,t
);
5590 setsvalue(L
,&key
,luaS_new(L
,k
));
5591 luaV_gettable(L
,t
,&key
,L
->top
);
5594 static void lua_rawget(lua_State
*L
,int idx
){
5597 luai_apicheck(L
,ttistable(t
));
5598 setobj(L
,L
->top
-1,luaH_get(hvalue(t
),L
->top
-1));
5600 static void lua_rawgeti(lua_State
*L
,int idx
,int n
){
5603 luai_apicheck(L
,ttistable(o
));
5604 setobj(L
,L
->top
,luaH_getnum(hvalue(o
),n
));
5607 static void lua_createtable(lua_State
*L
,int narray
,int nrec
){
5609 sethvalue(L
,L
->top
,luaH_new(L
,narray
,nrec
));
5612 static int lua_getmetatable(lua_State
*L
,int objindex
){
5616 obj
=index2adr(L
,objindex
);
5619 mt
=hvalue(obj
)->metatable
;
5622 mt
=uvalue(obj
)->metatable
;
5625 mt
=G(L
)->mt
[ttype(obj
)];
5631 sethvalue(L
,L
->top
,mt
);
5637 static void lua_getfenv(lua_State
*L
,int idx
){
5640 api_checkvalidindex(L
,o
);
5643 sethvalue(L
,L
->top
,clvalue(o
)->c
.env
);
5646 sethvalue(L
,L
->top
,uvalue(o
)->env
);
5649 setobj(L
,L
->top
,gt(thvalue(o
)));
5652 setnilvalue(L
->top
);
5657 static void lua_settable(lua_State
*L
,int idx
){
5659 api_checknelems(L
,2);
5661 api_checkvalidindex(L
,t
);
5662 luaV_settable(L
,t
,L
->top
-2,L
->top
-1);
5665 static void lua_setfield(lua_State
*L
,int idx
,const char*k
){
5668 api_checknelems(L
,1);
5670 api_checkvalidindex(L
,t
);
5671 setsvalue(L
,&key
,luaS_new(L
,k
));
5672 luaV_settable(L
,t
,&key
,L
->top
-1);
5675 static void lua_rawset(lua_State
*L
,int idx
){
5677 api_checknelems(L
,2);
5679 luai_apicheck(L
,ttistable(t
));
5680 setobj(L
,luaH_set(L
,hvalue(t
),L
->top
-2),L
->top
-1);
5681 luaC_barriert(L
,hvalue(t
),L
->top
-1);
5684 static void lua_rawseti(lua_State
*L
,int idx
,int n
){
5686 api_checknelems(L
,1);
5688 luai_apicheck(L
,ttistable(o
));
5689 setobj(L
,luaH_setnum(L
,hvalue(o
),n
),L
->top
-1);
5690 luaC_barriert(L
,hvalue(o
),L
->top
-1);
5693 static int lua_setmetatable(lua_State
*L
,int objindex
){
5696 api_checknelems(L
,1);
5697 obj
=index2adr(L
,objindex
);
5698 api_checkvalidindex(L
,obj
);
5699 if(ttisnil(L
->top
-1))
5702 luai_apicheck(L
,ttistable(L
->top
-1));
5703 mt
=hvalue(L
->top
-1);
5707 hvalue(obj
)->metatable
=mt
;
5709 luaC_objbarriert(L
,hvalue(obj
),mt
);
5713 uvalue(obj
)->metatable
=mt
;
5715 luaC_objbarrier(L
,rawuvalue(obj
),mt
);
5719 G(L
)->mt
[ttype(obj
)]=mt
;
5726 static int lua_setfenv(lua_State
*L
,int idx
){
5729 api_checknelems(L
,1);
5731 api_checkvalidindex(L
,o
);
5732 luai_apicheck(L
,ttistable(L
->top
-1));
5735 clvalue(o
)->c
.env
=hvalue(L
->top
-1);
5738 uvalue(o
)->env
=hvalue(L
->top
-1);
5741 sethvalue(L
,gt(thvalue(o
)),hvalue(L
->top
-1));
5747 if(res
)luaC_objbarrier(L
,gcvalue(o
),hvalue(L
->top
-1));
5751 #define adjustresults(L,nres){if(nres==(-1)&&L->top>=L->ci->top)L->ci->top=L->top;}
5752 #define checkresults(L,na,nr)luai_apicheck(L,(nr)==(-1)||(L->ci->top-L->top>=(nr)-(na)))
5753 static void lua_call(lua_State
*L
,int nargs
,int nresults
){
5755 api_checknelems(L
,nargs
+1);
5756 checkresults(L
,nargs
,nresults
);
5757 func
=L
->top
-(nargs
+1);
5758 luaD_call(L
,func
,nresults
);
5759 adjustresults(L
,nresults
);
5765 static void f_call(lua_State
*L
,void*ud
){
5766 struct CallS
*c
=cast(struct CallS
*,ud
);
5767 luaD_call(L
,c
->func
,c
->nresults
);
5769 static int lua_pcall(lua_State
*L
,int nargs
,int nresults
,int errfunc
){
5773 api_checknelems(L
,nargs
+1);
5774 checkresults(L
,nargs
,nresults
);
5778 StkId o
=index2adr(L
,errfunc
);
5779 api_checkvalidindex(L
,o
);
5780 func
=savestack(L
,o
);
5782 c
.func
=L
->top
-(nargs
+1);
5783 c
.nresults
=nresults
;
5784 status
=luaD_pcall(L
,f_call
,&c
,savestack(L
,c
.func
),func
);
5785 adjustresults(L
,nresults
);
5788 static int lua_load(lua_State
*L
,lua_Reader reader
,void*data
,
5789 const char*chunkname
){
5792 if(!chunkname
)chunkname
="?";
5793 luaZ_init(L
,&z
,reader
,data
);
5794 status
=luaD_protectedparser(L
,&z
,chunkname
);
5797 static int lua_error(lua_State
*L
){
5798 api_checknelems(L
,1);
5802 static int lua_next(lua_State
*L
,int idx
){
5806 luai_apicheck(L
,ttistable(t
));
5807 more
=luaH_next(L
,hvalue(t
),L
->top
-1);
5815 static void lua_concat(lua_State
*L
,int n
){
5816 api_checknelems(L
,n
);
5819 luaV_concat(L
,n
,cast_int(L
->top
-L
->base
)-1);
5823 setsvalue(L
,L
->top
,luaS_newlstr(L
,"",0));
5827 static void*lua_newuserdata(lua_State
*L
,size_t size
){
5830 u
=luaS_newudata(L
,size
,getcurrenv(L
));
5831 setuvalue(L
,L
->top
,u
);
5835 #define luaL_getn(L,i)((int)lua_objlen(L,i))
5836 #define luaL_setn(L,i,j)((void)0)
5837 typedef struct luaL_Reg
{
5841 static void luaI_openlib(lua_State
*L
,const char*libname
,
5842 const luaL_Reg
*l
,int nup
);
5843 static int luaL_argerror(lua_State
*L
,int numarg
,const char*extramsg
);
5844 static const char* luaL_checklstring(lua_State
*L
,int numArg
,
5846 static const char* luaL_optlstring(lua_State
*L
,int numArg
,
5847 const char*def
,size_t*l
);
5848 static lua_Integer
luaL_checkinteger(lua_State
*L
,int numArg
);
5849 static lua_Integer
luaL_optinteger(lua_State
*L
,int nArg
,
5851 static int luaL_error(lua_State
*L
,const char*fmt
,...);
5852 static const char* luaL_findtable(lua_State
*L
,int idx
,
5853 const char*fname
,int szhint
);
5854 #define luaL_argcheck(L,cond,numarg,extramsg)((void)((cond)||luaL_argerror(L,(numarg),(extramsg))))
5855 #define luaL_checkstring(L,n)(luaL_checklstring(L,(n),NULL))
5856 #define luaL_optstring(L,n,d)(luaL_optlstring(L,(n),(d),NULL))
5857 #define luaL_checkint(L,n)((int)luaL_checkinteger(L,(n)))
5858 #define luaL_optint(L,n,d)((int)luaL_optinteger(L,(n),(d)))
5859 #define luaL_typename(L,i)lua_typename(L,lua_type(L,(i)))
5860 #define luaL_getmetatable(L,n)(lua_getfield(L,(-10000),(n)))
5861 #define luaL_opt(L,f,n,d)(lua_isnoneornil(L,(n))?(d):f(L,(n)))
5862 typedef struct luaL_Buffer
{
5866 char buffer
[BUFSIZ
];
5868 #define luaL_addchar(B,c)((void)((B)->p<((B)->buffer+BUFSIZ)||luaL_prepbuffer(B)),(*(B)->p++=(char)(c)))
5869 #define luaL_addsize(B,n)((B)->p+=(n))
5870 static char* luaL_prepbuffer(luaL_Buffer
*B
);
5871 static int luaL_argerror(lua_State
*L
,int narg
,const char*extramsg
){
5873 if(!lua_getstack(L
,0,&ar
))
5874 return luaL_error(L
,"bad argument #%d (%s)",narg
,extramsg
);
5875 lua_getinfo(L
,"n",&ar
);
5876 if(strcmp(ar
.namewhat
,"method")==0){
5879 return luaL_error(L
,"calling "LUA_QL("%s")" on bad self (%s)",
5884 return luaL_error(L
,"bad argument #%d to "LUA_QL("%s")" (%s)",
5885 narg
,ar
.name
,extramsg
);
5887 static int luaL_typerror(lua_State
*L
,int narg
,const char*tname
){
5888 const char*msg
=lua_pushfstring(L
,"%s expected, got %s",
5889 tname
,luaL_typename(L
,narg
));
5890 return luaL_argerror(L
,narg
,msg
);
5892 static void tag_error(lua_State
*L
,int narg
,int tag
){
5893 luaL_typerror(L
,narg
,lua_typename(L
,tag
));
5895 static void luaL_where(lua_State
*L
,int level
){
5897 if(lua_getstack(L
,level
,&ar
)){
5898 lua_getinfo(L
,"Sl",&ar
);
5899 if(ar
.currentline
>0){
5900 lua_pushfstring(L
,"%s:%d: ",ar
.short_src
,ar
.currentline
);
5904 lua_pushliteral(L
,"");
5906 static int luaL_error(lua_State
*L
,const char*fmt
,...){
5910 lua_pushvfstring(L
,fmt
,argp
);
5913 return lua_error(L
);
5915 static int luaL_newmetatable(lua_State
*L
,const char*tname
){
5916 lua_getfield(L
,(-10000),tname
);
5917 if(!lua_isnil(L
,-1))
5921 lua_pushvalue(L
,-1);
5922 lua_setfield(L
,(-10000),tname
);
5925 static void*luaL_checkudata(lua_State
*L
,int ud
,const char*tname
){
5926 void*p
=lua_touserdata(L
,ud
);
5928 if(lua_getmetatable(L
,ud
)){
5929 lua_getfield(L
,(-10000),tname
);
5930 if(lua_rawequal(L
,-1,-2)){
5936 luaL_typerror(L
,ud
,tname
);
5939 static void luaL_checkstack(lua_State
*L
,int space
,const char*mes
){
5940 if(!lua_checkstack(L
,space
))
5941 luaL_error(L
,"stack overflow (%s)",mes
);
5943 static void luaL_checktype(lua_State
*L
,int narg
,int t
){
5944 if(lua_type(L
,narg
)!=t
)
5945 tag_error(L
,narg
,t
);
5947 static void luaL_checkany(lua_State
*L
,int narg
){
5948 if(lua_type(L
,narg
)==(-1))
5949 luaL_argerror(L
,narg
,"value expected");
5951 static const char*luaL_checklstring(lua_State
*L
,int narg
,size_t*len
){
5952 const char*s
=lua_tolstring(L
,narg
,len
);
5953 if(!s
)tag_error(L
,narg
,4);
5956 static const char*luaL_optlstring(lua_State
*L
,int narg
,
5957 const char*def
,size_t*len
){
5958 if(lua_isnoneornil(L
,narg
)){
5960 *len
=(def
?strlen(def
):0);
5963 else return luaL_checklstring(L
,narg
,len
);
5965 static lua_Number
luaL_checknumber(lua_State
*L
,int narg
){
5966 lua_Number d
=lua_tonumber(L
,narg
);
5967 if(d
==0&&!lua_isnumber(L
,narg
))
5968 tag_error(L
,narg
,3);
5971 static lua_Integer
luaL_checkinteger(lua_State
*L
,int narg
){
5972 lua_Integer d
=lua_tointeger(L
,narg
);
5973 if(d
==0&&!lua_isnumber(L
,narg
))
5974 tag_error(L
,narg
,3);
5977 static lua_Integer
luaL_optinteger(lua_State
*L
,int narg
,
5979 return luaL_opt(L
,luaL_checkinteger
,narg
,def
);
5981 static int luaL_getmetafield(lua_State
*L
,int obj
,const char*event
){
5982 if(!lua_getmetatable(L
,obj
))
5984 lua_pushstring(L
,event
);
5986 if(lua_isnil(L
,-1)){
5995 static void luaL_register(lua_State
*L
,const char*libname
,
5997 luaI_openlib(L
,libname
,l
,0);
5999 static int libsize(const luaL_Reg
*l
){
6001 for(;l
->name
;l
++)size
++;
6004 static void luaI_openlib(lua_State
*L
,const char*libname
,
6005 const luaL_Reg
*l
,int nup
){
6007 int size
=libsize(l
);
6008 luaL_findtable(L
,(-10000),"_LOADED",1);
6009 lua_getfield(L
,-1,libname
);
6010 if(!lua_istable(L
,-1)){
6012 if(luaL_findtable(L
,(-10002),libname
,size
)!=NULL
)
6013 luaL_error(L
,"name conflict for module "LUA_QL("%s"),libname
);
6014 lua_pushvalue(L
,-1);
6015 lua_setfield(L
,-3,libname
);
6018 lua_insert(L
,-(nup
+1));
6023 lua_pushvalue(L
,-nup
);
6024 lua_pushcclosure(L
,l
->func
,nup
);
6025 lua_setfield(L
,-(nup
+2),l
->name
);
6029 static const char*luaL_findtable(lua_State
*L
,int idx
,
6030 const char*fname
,int szhint
){
6032 lua_pushvalue(L
,idx
);
6034 e
=strchr(fname
,'.');
6035 if(e
==NULL
)e
=fname
+strlen(fname
);
6036 lua_pushlstring(L
,fname
,e
-fname
);
6038 if(lua_isnil(L
,-1)){
6040 lua_createtable(L
,0,(*e
=='.'?1:szhint
));
6041 lua_pushlstring(L
,fname
,e
-fname
);
6042 lua_pushvalue(L
,-2);
6045 else if(!lua_istable(L
,-1)){
6054 #define bufflen(B)((B)->p-(B)->buffer)
6055 #define bufffree(B)((size_t)(BUFSIZ-bufflen(B)))
6056 static int emptybuffer(luaL_Buffer
*B
){
6057 size_t l
=bufflen(B
);
6060 lua_pushlstring(B
->L
,B
->buffer
,l
);
6066 static void adjuststack(luaL_Buffer
*B
){
6070 size_t toplen
=lua_strlen(L
,-1);
6072 size_t l
=lua_strlen(L
,-(toget
+1));
6073 if(B
->lvl
-toget
+1>=(20/2)||toplen
>l
){
6078 }while(toget
<B
->lvl
);
6079 lua_concat(L
,toget
);
6080 B
->lvl
=B
->lvl
-toget
+1;
6083 static char*luaL_prepbuffer(luaL_Buffer
*B
){
6088 static void luaL_addlstring(luaL_Buffer
*B
,const char*s
,size_t l
){
6090 luaL_addchar(B
,*s
++);
6092 static void luaL_pushresult(luaL_Buffer
*B
){
6094 lua_concat(B
->L
,B
->lvl
);
6097 static void luaL_addvalue(luaL_Buffer
*B
){
6100 const char*s
=lua_tolstring(L
,-1,&vl
);
6101 if(vl
<=bufffree(B
)){
6113 static void luaL_buffinit(lua_State
*L
,luaL_Buffer
*B
){
6118 typedef struct LoadF
{
6123 static const char*getF(lua_State
*L
,void*ud
,size_t*size
){
6124 LoadF
*lf
=(LoadF
*)ud
;
6131 if(feof(lf
->f
))return NULL
;
6132 *size
=fread(lf
->buff
,1,sizeof(lf
->buff
),lf
->f
);
6133 return(*size
>0)?lf
->buff
:NULL
;
6135 static int errfile(lua_State
*L
,const char*what
,int fnameindex
){
6136 const char*serr
=strerror(errno
);
6137 const char*filename
=lua_tostring(L
,fnameindex
)+1;
6138 lua_pushfstring(L
,"cannot %s %s: %s",what
,filename
,serr
);
6139 lua_remove(L
,fnameindex
);
6142 static int luaL_loadfile(lua_State
*L
,const char*filename
){
6144 int status
,readstatus
;
6146 int fnameindex
=lua_gettop(L
)+1;
6149 lua_pushliteral(L
,"=stdin");
6153 lua_pushfstring(L
,"@%s",filename
);
6154 lf
.f
=fopen(filename
,"r");
6155 if(lf
.f
==NULL
)return errfile(L
,"open",fnameindex
);
6160 while((c
=getc(lf
.f
))!=EOF
&&c
!='\n');
6161 if(c
=='\n')c
=getc(lf
.f
);
6163 if(c
=="\033Lua"[0]&&filename
){
6164 lf
.f
=freopen(filename
,"rb",lf
.f
);
6165 if(lf
.f
==NULL
)return errfile(L
,"reopen",fnameindex
);
6166 while((c
=getc(lf
.f
))!=EOF
&&c
!="\033Lua"[0]);
6170 status
=lua_load(L
,getF
,&lf
,lua_tostring(L
,-1));
6171 readstatus
=ferror(lf
.f
);
6172 if(filename
)fclose(lf
.f
);
6174 lua_settop(L
,fnameindex
);
6175 return errfile(L
,"read",fnameindex
);
6177 lua_remove(L
,fnameindex
);
6180 typedef struct LoadS
{
6184 static const char*getS(lua_State
*L
,void*ud
,size_t*size
){
6185 LoadS
*ls
=(LoadS
*)ud
;
6187 if(ls
->size
==0)return NULL
;
6192 static int luaL_loadbuffer(lua_State
*L
,const char*buff
,size_t size
,
6197 return lua_load(L
,getS
,&ls
,name
);
6199 static void*l_alloc(void*ud
,void*ptr
,size_t osize
,size_t nsize
){
6207 return realloc(ptr
,nsize
);
6209 static int panic(lua_State
*L
){
6211 fprintf(stderr
,"PANIC: unprotected error in call to Lua API (%s)\n",
6212 lua_tostring(L
,-1));
6215 static lua_State
*luaL_newstate(void){
6216 lua_State
*L
=lua_newstate(l_alloc
,NULL
);
6217 if(L
)lua_atpanic(L
,&panic
);
6220 static int luaB_tonumber(lua_State
*L
){
6221 int base
=luaL_optint(L
,2,10);
6224 if(lua_isnumber(L
,1)){
6225 lua_pushnumber(L
,lua_tonumber(L
,1));
6230 const char*s1
=luaL_checkstring(L
,1);
6233 luaL_argcheck(L
,2<=base
&&base
<=36,2,"base out of range");
6234 n
=strtoul(s1
,&s2
,base
);
6236 while(isspace((unsigned char)(*s2
)))s2
++;
6238 lua_pushnumber(L
,(lua_Number
)n
);
6246 static int luaB_error(lua_State
*L
){
6247 int level
=luaL_optint(L
,2,1);
6249 if(lua_isstring(L
,1)&&level
>0){
6250 luaL_where(L
,level
);
6254 return lua_error(L
);
6256 static int luaB_setmetatable(lua_State
*L
){
6257 int t
=lua_type(L
,2);
6258 luaL_checktype(L
,1,5);
6259 luaL_argcheck(L
,t
==0||t
==5,2,
6260 "nil or table expected");
6261 if(luaL_getmetafield(L
,1,"__metatable"))
6262 luaL_error(L
,"cannot change a protected metatable");
6264 lua_setmetatable(L
,1);
6267 static void getfunc(lua_State
*L
,int opt
){
6268 if(lua_isfunction(L
,1))lua_pushvalue(L
,1);
6271 int level
=opt
?luaL_optint(L
,1,1):luaL_checkint(L
,1);
6272 luaL_argcheck(L
,level
>=0,1,"level must be non-negative");
6273 if(lua_getstack(L
,level
,&ar
)==0)
6274 luaL_argerror(L
,1,"invalid level");
6275 lua_getinfo(L
,"f",&ar
);
6277 luaL_error(L
,"no function environment for tail call at level %d",
6281 static int luaB_setfenv(lua_State
*L
){
6282 luaL_checktype(L
,2,5);
6285 if(lua_isnumber(L
,1)&&lua_tonumber(L
,1)==0){
6291 else if(lua_iscfunction(L
,-2)||lua_setfenv(L
,-2)==0)
6293 LUA_QL("setfenv")" cannot change environment of given object");
6296 static int luaB_rawget(lua_State
*L
){
6297 luaL_checktype(L
,1,5);
6303 static int luaB_type(lua_State
*L
){
6305 lua_pushstring(L
,luaL_typename(L
,1));
6308 static int luaB_next(lua_State
*L
){
6309 luaL_checktype(L
,1,5);
6318 static int luaB_pairs(lua_State
*L
){
6319 luaL_checktype(L
,1,5);
6320 lua_pushvalue(L
,lua_upvalueindex(1));
6325 static int ipairsaux(lua_State
*L
){
6326 int i
=luaL_checkint(L
,2);
6327 luaL_checktype(L
,1,5);
6329 lua_pushinteger(L
,i
);
6331 return(lua_isnil(L
,-1))?0:2;
6333 static int luaB_ipairs(lua_State
*L
){
6334 luaL_checktype(L
,1,5);
6335 lua_pushvalue(L
,lua_upvalueindex(1));
6337 lua_pushinteger(L
,0);
6340 static int load_aux(lua_State
*L
,int status
){
6349 static int luaB_loadstring(lua_State
*L
){
6351 const char*s
=luaL_checklstring(L
,1,&l
);
6352 const char*chunkname
=luaL_optstring(L
,2,s
);
6353 return load_aux(L
,luaL_loadbuffer(L
,s
,l
,chunkname
));
6355 static int luaB_loadfile(lua_State
*L
){
6356 const char*fname
=luaL_optstring(L
,1,NULL
);
6357 return load_aux(L
,luaL_loadfile(L
,fname
));
6359 static int luaB_assert(lua_State
*L
){
6361 if(!lua_toboolean(L
,1))
6362 return luaL_error(L
,"%s",luaL_optstring(L
,2,"assertion failed!"));
6363 return lua_gettop(L
);
6365 static int luaB_unpack(lua_State
*L
){
6367 luaL_checktype(L
,1,5);
6368 i
=luaL_optint(L
,2,1);
6369 e
=luaL_opt(L
,luaL_checkint
,3,luaL_getn(L
,1));
6372 if(n
<=0||!lua_checkstack(L
,n
))
6373 return luaL_error(L
,"too many results to unpack");
6379 static int luaB_pcall(lua_State
*L
){
6382 status
=lua_pcall(L
,lua_gettop(L
)-1,(-1),0);
6383 lua_pushboolean(L
,(status
==0));
6385 return lua_gettop(L
);
6387 static int luaB_newproxy(lua_State
*L
){
6389 lua_newuserdata(L
,0);
6390 if(lua_toboolean(L
,1)==0)
6392 else if(lua_isboolean(L
,1)){
6394 lua_pushvalue(L
,-1);
6395 lua_pushboolean(L
,1);
6396 lua_rawset(L
,lua_upvalueindex(1));
6400 if(lua_getmetatable(L
,1)){
6401 lua_rawget(L
,lua_upvalueindex(1));
6402 validproxy
=lua_toboolean(L
,-1);
6405 luaL_argcheck(L
,validproxy
,1,"boolean or proxy expected");
6406 lua_getmetatable(L
,1);
6408 lua_setmetatable(L
,2);
6411 static const luaL_Reg base_funcs
[]={
6412 {"assert",luaB_assert
},
6413 {"error",luaB_error
},
6414 {"loadfile",luaB_loadfile
},
6415 {"loadstring",luaB_loadstring
},
6417 {"pcall",luaB_pcall
},
6418 {"rawget",luaB_rawget
},
6419 {"setfenv",luaB_setfenv
},
6420 {"setmetatable",luaB_setmetatable
},
6421 {"tonumber",luaB_tonumber
},
6423 {"unpack",luaB_unpack
},
6426 static void auxopen(lua_State
*L
,const char*name
,
6427 lua_CFunction f
,lua_CFunction u
){
6428 lua_pushcfunction(L
,u
);
6429 lua_pushcclosure(L
,f
,1);
6430 lua_setfield(L
,-2,name
);
6432 static void base_open(lua_State
*L
){
6433 lua_pushvalue(L
,(-10002));
6434 lua_setglobal(L
,"_G");
6435 luaL_register(L
,"_G",base_funcs
);
6436 lua_pushliteral(L
,"Lua 5.1");
6437 lua_setglobal(L
,"_VERSION");
6438 auxopen(L
,"ipairs",luaB_ipairs
,ipairsaux
);
6439 auxopen(L
,"pairs",luaB_pairs
,luaB_next
);
6440 lua_createtable(L
,0,1);
6441 lua_pushvalue(L
,-1);
6442 lua_setmetatable(L
,-2);
6443 lua_pushliteral(L
,"kv");
6444 lua_setfield(L
,-2,"__mode");
6445 lua_pushcclosure(L
,luaB_newproxy
,1);
6446 lua_setglobal(L
,"newproxy");
6448 static int luaopen_base(lua_State
*L
){
6452 #define aux_getn(L,n)(luaL_checktype(L,n,5),luaL_getn(L,n))
6453 static int tinsert(lua_State
*L
){
6454 int e
=aux_getn(L
,1)+1;
6456 switch(lua_gettop(L
)){
6463 pos
=luaL_checkint(L
,2);
6466 lua_rawgeti(L
,1,i
-1);
6472 return luaL_error(L
,"wrong number of arguments to "LUA_QL("insert"));
6476 lua_rawseti(L
,1,pos
);
6479 static int tremove(lua_State
*L
){
6480 int e
=aux_getn(L
,1);
6481 int pos
=luaL_optint(L
,2,e
);
6482 if(!(1<=pos
&&pos
<=e
))
6485 lua_rawgeti(L
,1,pos
);
6487 lua_rawgeti(L
,1,pos
+1);
6488 lua_rawseti(L
,1,pos
);
6494 static void addfield(lua_State
*L
,luaL_Buffer
*b
,int i
){
6496 if(!lua_isstring(L
,-1))
6497 luaL_error(L
,"invalid value (%s) at index %d in table for "
6498 LUA_QL("concat"),luaL_typename(L
,-1),i
);
6501 static int tconcat(lua_State
*L
){
6505 const char*sep
=luaL_optlstring(L
,2,"",&lsep
);
6506 luaL_checktype(L
,1,5);
6507 i
=luaL_optint(L
,3,1);
6508 last
=luaL_opt(L
,luaL_checkint
,4,luaL_getn(L
,1));
6509 luaL_buffinit(L
,&b
);
6512 luaL_addlstring(&b
,sep
,lsep
);
6516 luaL_pushresult(&b
);
6519 static void set2(lua_State
*L
,int i
,int j
){
6523 static int sort_comp(lua_State
*L
,int a
,int b
){
6524 if(!lua_isnil(L
,2)){
6527 lua_pushvalue(L
,a
-1);
6528 lua_pushvalue(L
,b
-2);
6530 res
=lua_toboolean(L
,-1);
6535 return lua_lessthan(L
,a
,b
);
6537 static void auxsort(lua_State
*L
,int l
,int u
){
6542 if(sort_comp(L
,-1,-2))
6550 if(sort_comp(L
,-2,-1))
6555 if(sort_comp(L
,-1,-2))
6562 lua_pushvalue(L
,-1);
6563 lua_rawgeti(L
,1,u
-1);
6567 while(lua_rawgeti(L
,1,++i
),sort_comp(L
,-1,-2)){
6568 if(i
>u
)luaL_error(L
,"invalid order function for sorting");
6571 while(lua_rawgeti(L
,1,--j
),sort_comp(L
,-3,-1)){
6572 if(j
<l
)luaL_error(L
,"invalid order function for sorting");
6581 lua_rawgeti(L
,1,u
-1);
6593 static int sort(lua_State
*L
){
6594 int n
=aux_getn(L
,1);
6595 luaL_checkstack(L
,40,"");
6596 if(!lua_isnoneornil(L
,2))
6597 luaL_checktype(L
,2,6);
6602 static const luaL_Reg tab_funcs
[]={
6609 static int luaopen_table(lua_State
*L
){
6610 luaL_register(L
,"table",tab_funcs
);
6613 static const char*const fnames
[]={"input","output"};
6614 static int pushresult(lua_State
*L
,int i
,const char*filename
){
6617 lua_pushboolean(L
,1);
6623 lua_pushfstring(L
,"%s: %s",filename
,strerror(en
));
6625 lua_pushfstring(L
,"%s",strerror(en
));
6626 lua_pushinteger(L
,en
);
6630 static void fileerror(lua_State
*L
,int arg
,const char*filename
){
6631 lua_pushfstring(L
,"%s: %s",filename
,strerror(errno
));
6632 luaL_argerror(L
,arg
,lua_tostring(L
,-1));
6634 #define tofilep(L)((FILE**)luaL_checkudata(L,1,"FILE*"))
6635 static int io_type(lua_State
*L
){
6638 ud
=lua_touserdata(L
,1);
6639 lua_getfield(L
,(-10000),"FILE*");
6640 if(ud
==NULL
||!lua_getmetatable(L
,1)||!lua_rawequal(L
,-2,-1))
6642 else if(*((FILE**)ud
)==NULL
)
6643 lua_pushliteral(L
,"closed file");
6645 lua_pushliteral(L
,"file");
6648 static FILE*tofile(lua_State
*L
){
6651 luaL_error(L
,"attempt to use a closed file");
6654 static FILE**newfile(lua_State
*L
){
6655 FILE**pf
=(FILE**)lua_newuserdata(L
,sizeof(FILE*));
6657 luaL_getmetatable(L
,"FILE*");
6658 lua_setmetatable(L
,-2);
6661 static int io_noclose(lua_State
*L
){
6663 lua_pushliteral(L
,"cannot close standard file");
6666 static int io_pclose(lua_State
*L
){
6668 int ok
=lua_pclose(L
,*p
);
6670 return pushresult(L
,ok
,NULL
);
6672 static int io_fclose(lua_State
*L
){
6674 int ok
=(fclose(*p
)==0);
6676 return pushresult(L
,ok
,NULL
);
6678 static int aux_close(lua_State
*L
){
6680 lua_getfield(L
,-1,"__close");
6681 return(lua_tocfunction(L
,-1))(L
);
6683 static int io_close(lua_State
*L
){
6685 lua_rawgeti(L
,(-10001),2);
6687 return aux_close(L
);
6689 static int io_gc(lua_State
*L
){
6695 static int io_open(lua_State
*L
){
6696 const char*filename
=luaL_checkstring(L
,1);
6697 const char*mode
=luaL_optstring(L
,2,"r");
6698 FILE**pf
=newfile(L
);
6699 *pf
=fopen(filename
,mode
);
6700 return(*pf
==NULL
)?pushresult(L
,0,filename
):1;
6702 static FILE*getiofile(lua_State
*L
,int findex
){
6704 lua_rawgeti(L
,(-10001),findex
);
6705 f
=*(FILE**)lua_touserdata(L
,-1);
6707 luaL_error(L
,"standard %s file is closed",fnames
[findex
-1]);
6710 static int g_iofile(lua_State
*L
,int f
,const char*mode
){
6711 if(!lua_isnoneornil(L
,1)){
6712 const char*filename
=lua_tostring(L
,1);
6714 FILE**pf
=newfile(L
);
6715 *pf
=fopen(filename
,mode
);
6717 fileerror(L
,1,filename
);
6723 lua_rawseti(L
,(-10001),f
);
6725 lua_rawgeti(L
,(-10001),f
);
6728 static int io_input(lua_State
*L
){
6729 return g_iofile(L
,1,"r");
6731 static int io_output(lua_State
*L
){
6732 return g_iofile(L
,2,"w");
6734 static int io_readline(lua_State
*L
);
6735 static void aux_lines(lua_State
*L
,int idx
,int toclose
){
6736 lua_pushvalue(L
,idx
);
6737 lua_pushboolean(L
,toclose
);
6738 lua_pushcclosure(L
,io_readline
,2);
6740 static int f_lines(lua_State
*L
){
6745 static int io_lines(lua_State
*L
){
6746 if(lua_isnoneornil(L
,1)){
6747 lua_rawgeti(L
,(-10001),1);
6751 const char*filename
=luaL_checkstring(L
,1);
6752 FILE**pf
=newfile(L
);
6753 *pf
=fopen(filename
,"r");
6755 fileerror(L
,1,filename
);
6756 aux_lines(L
,lua_gettop(L
),1);
6760 static int read_number(lua_State
*L
,FILE*f
){
6762 if(fscanf(f
,"%lf",&d
)==1){
6763 lua_pushnumber(L
,d
);
6771 static int test_eof(lua_State
*L
,FILE*f
){
6774 lua_pushlstring(L
,NULL
,0);
6777 static int read_line(lua_State
*L
,FILE*f
){
6779 luaL_buffinit(L
,&b
);
6782 char*p
=luaL_prepbuffer(&b
);
6783 if(fgets(p
,BUFSIZ
,f
)==NULL
){
6784 luaL_pushresult(&b
);
6785 return(lua_objlen(L
,-1)>0);
6788 if(l
==0||p
[l
-1]!='\n')
6791 luaL_addsize(&b
,l
-1);
6792 luaL_pushresult(&b
);
6797 static int read_chars(lua_State
*L
,FILE*f
,size_t n
){
6801 luaL_buffinit(L
,&b
);
6804 char*p
=luaL_prepbuffer(&b
);
6806 nr
=fread(p
,sizeof(char),rlen
,f
);
6807 luaL_addsize(&b
,nr
);
6809 }while(n
>0&&nr
==rlen
);
6810 luaL_pushresult(&b
);
6811 return(n
==0||lua_objlen(L
,-1)>0);
6813 static int g_read(lua_State
*L
,FILE*f
,int first
){
6814 int nargs
=lua_gettop(L
)-1;
6819 success
=read_line(L
,f
);
6823 luaL_checkstack(L
,nargs
+20,"too many arguments");
6825 for(n
=first
;nargs
--&&success
;n
++){
6826 if(lua_type(L
,n
)==3){
6827 size_t l
=(size_t)lua_tointeger(L
,n
);
6828 success
=(l
==0)?test_eof(L
,f
):read_chars(L
,f
,l
);
6831 const char*p
=lua_tostring(L
,n
);
6832 luaL_argcheck(L
,p
&&p
[0]=='*',n
,"invalid option");
6835 success
=read_number(L
,f
);
6838 success
=read_line(L
,f
);
6841 read_chars(L
,f
,~((size_t)0));
6845 return luaL_argerror(L
,n
,"invalid format");
6851 return pushresult(L
,0,NULL
);
6858 static int io_read(lua_State
*L
){
6859 return g_read(L
,getiofile(L
,1),1);
6861 static int f_read(lua_State
*L
){
6862 return g_read(L
,tofile(L
),2);
6864 static int io_readline(lua_State
*L
){
6865 FILE*f
=*(FILE**)lua_touserdata(L
,lua_upvalueindex(1));
6868 luaL_error(L
,"file is already closed");
6869 sucess
=read_line(L
,f
);
6871 return luaL_error(L
,"%s",strerror(errno
));
6874 if(lua_toboolean(L
,lua_upvalueindex(2))){
6876 lua_pushvalue(L
,lua_upvalueindex(1));
6882 static int g_write(lua_State
*L
,FILE*f
,int arg
){
6883 int nargs
=lua_gettop(L
)-1;
6885 for(;nargs
--;arg
++){
6886 if(lua_type(L
,arg
)==3){
6888 fprintf(f
,"%.14g",lua_tonumber(L
,arg
))>0;
6892 const char*s
=luaL_checklstring(L
,arg
,&l
);
6893 status
=status
&&(fwrite(s
,sizeof(char),l
,f
)==l
);
6896 return pushresult(L
,status
,NULL
);
6898 static int io_write(lua_State
*L
){
6899 return g_write(L
,getiofile(L
,2),1);
6901 static int f_write(lua_State
*L
){
6902 return g_write(L
,tofile(L
),2);
6904 static int io_flush(lua_State
*L
){
6905 return pushresult(L
,fflush(getiofile(L
,2))==0,NULL
);
6907 static int f_flush(lua_State
*L
){
6908 return pushresult(L
,fflush(tofile(L
))==0,NULL
);
6910 static const luaL_Reg iolib
[]={
6916 {"output",io_output
},
6922 static const luaL_Reg flib
[]={
6931 static void createmeta(lua_State
*L
){
6932 luaL_newmetatable(L
,"FILE*");
6933 lua_pushvalue(L
,-1);
6934 lua_setfield(L
,-2,"__index");
6935 luaL_register(L
,NULL
,flib
);
6937 static void createstdfile(lua_State
*L
,FILE*f
,int k
,const char*fname
){
6940 lua_pushvalue(L
,-1);
6941 lua_rawseti(L
,(-10001),k
);
6943 lua_pushvalue(L
,-2);
6945 lua_setfield(L
,-3,fname
);
6947 static void newfenv(lua_State
*L
,lua_CFunction cls
){
6948 lua_createtable(L
,0,1);
6949 lua_pushcfunction(L
,cls
);
6950 lua_setfield(L
,-2,"__close");
6952 static int luaopen_io(lua_State
*L
){
6954 newfenv(L
,io_fclose
);
6955 lua_replace(L
,(-10001));
6956 luaL_register(L
,"io",iolib
);
6957 newfenv(L
,io_noclose
);
6958 createstdfile(L
,stdin
,1,"stdin");
6959 createstdfile(L
,stdout
,2,"stdout");
6960 createstdfile(L
,stderr
,0,"stderr");
6962 lua_getfield(L
,-1,"popen");
6963 newfenv(L
,io_pclose
);
6968 static int os_pushresult(lua_State
*L
,int i
,const char*filename
){
6971 lua_pushboolean(L
,1);
6976 lua_pushfstring(L
,"%s: %s",filename
,strerror(en
));
6977 lua_pushinteger(L
,en
);
6981 static int os_remove(lua_State
*L
){
6982 const char*filename
=luaL_checkstring(L
,1);
6983 return os_pushresult(L
,remove(filename
)==0,filename
);
6985 static int os_exit(lua_State
*L
){
6986 exit(luaL_optint(L
,1,EXIT_SUCCESS
));
6988 static const luaL_Reg syslib
[]={
6990 {"remove",os_remove
},
6993 static int luaopen_os(lua_State
*L
){
6994 luaL_register(L
,"os",syslib
);
6997 #define uchar(c)((unsigned char)(c))
6998 static ptrdiff_t posrelat(ptrdiff_t pos
,size_t len
){
6999 if(pos
<0)pos
+=(ptrdiff_t)len
+1;
7000 return(pos
>=0)?pos
:0;
7002 static int str_sub(lua_State
*L
){
7004 const char*s
=luaL_checklstring(L
,1,&l
);
7005 ptrdiff_t start
=posrelat(luaL_checkinteger(L
,2),l
);
7006 ptrdiff_t end
=posrelat(luaL_optinteger(L
,3,-1),l
);
7008 if(end
>(ptrdiff_t)l
)end
=(ptrdiff_t)l
;
7010 lua_pushlstring(L
,s
+start
-1,end
-start
+1);
7011 else lua_pushliteral(L
,"");
7014 static int str_lower(lua_State
*L
){
7018 const char*s
=luaL_checklstring(L
,1,&l
);
7019 luaL_buffinit(L
,&b
);
7021 luaL_addchar(&b
,tolower(uchar(s
[i
])));
7022 luaL_pushresult(&b
);
7025 static int str_upper(lua_State
*L
){
7029 const char*s
=luaL_checklstring(L
,1,&l
);
7030 luaL_buffinit(L
,&b
);
7032 luaL_addchar(&b
,toupper(uchar(s
[i
])));
7033 luaL_pushresult(&b
);
7036 static int str_rep(lua_State
*L
){
7039 const char*s
=luaL_checklstring(L
,1,&l
);
7040 int n
=luaL_checkint(L
,2);
7041 luaL_buffinit(L
,&b
);
7043 luaL_addlstring(&b
,s
,l
);
7044 luaL_pushresult(&b
);
7047 static int str_byte(lua_State
*L
){
7049 const char*s
=luaL_checklstring(L
,1,&l
);
7050 ptrdiff_t posi
=posrelat(luaL_optinteger(L
,2,1),l
);
7051 ptrdiff_t pose
=posrelat(luaL_optinteger(L
,3,posi
),l
);
7054 if((size_t)pose
>l
)pose
=l
;
7055 if(posi
>pose
)return 0;
7056 n
=(int)(pose
-posi
+1);
7058 luaL_error(L
,"string slice too long");
7059 luaL_checkstack(L
,n
,"string slice too long");
7061 lua_pushinteger(L
,uchar(s
[posi
+i
-1]));
7064 static int str_char(lua_State
*L
){
7065 int n
=lua_gettop(L
);
7068 luaL_buffinit(L
,&b
);
7070 int c
=luaL_checkint(L
,i
);
7071 luaL_argcheck(L
,uchar(c
)==c
,i
,"invalid value");
7072 luaL_addchar(&b
,uchar(c
));
7074 luaL_pushresult(&b
);
7077 typedef struct MatchState
{
7078 const char*src_init
;
7087 static int check_capture(MatchState
*ms
,int l
){
7089 if(l
<0||l
>=ms
->level
||ms
->capture
[l
].len
==(-1))
7090 return luaL_error(ms
->L
,"invalid capture index");
7093 static int capture_to_close(MatchState
*ms
){
7094 int level
=ms
->level
;
7095 for(level
--;level
>=0;level
--)
7096 if(ms
->capture
[level
].len
==(-1))return level
;
7097 return luaL_error(ms
->L
,"invalid pattern capture");
7099 static const char*classend(MatchState
*ms
,const char*p
){
7103 luaL_error(ms
->L
,"malformed pattern (ends with "LUA_QL("%%")")");
7110 luaL_error(ms
->L
,"malformed pattern (missing "LUA_QL("]")")");
7111 if(*(p
++)=='%'&&*p
!='\0')
7121 static int match_class(int c
,int cl
){
7123 switch(tolower(cl
)){
7124 case'a':res
=isalpha(c
);break;
7125 case'c':res
=iscntrl(c
);break;
7126 case'd':res
=isdigit(c
);break;
7127 case'l':res
=islower(c
);break;
7128 case'p':res
=ispunct(c
);break;
7129 case's':res
=isspace(c
);break;
7130 case'u':res
=isupper(c
);break;
7131 case'w':res
=isalnum(c
);break;
7132 case'x':res
=isxdigit(c
);break;
7133 case'z':res
=(c
==0);break;
7134 default:return(cl
==c
);
7136 return(islower(cl
)?res
:!res
);
7138 static int matchbracketclass(int c
,const char*p
,const char*ec
){
7147 if(match_class(c
,uchar(*p
)))
7150 else if((*(p
+1)=='-')&&(p
+2<ec
)){
7152 if(uchar(*(p
-2))<=c
&&c
<=uchar(*p
))
7155 else if(uchar(*p
)==c
)return sig
;
7159 static int singlematch(int c
,const char*p
,const char*ep
){
7162 case'%':return match_class(c
,uchar(*(p
+1)));
7163 case'[':return matchbracketclass(c
,p
,ep
-1);
7164 default:return(uchar(*p
)==c
);
7167 static const char*match(MatchState
*ms
,const char*s
,const char*p
);
7168 static const char*matchbalance(MatchState
*ms
,const char*s
,
7170 if(*p
==0||*(p
+1)==0)
7171 luaL_error(ms
->L
,"unbalanced pattern");
7172 if(*s
!=*p
)return NULL
;
7177 while(++s
<ms
->src_end
){
7179 if(--cont
==0)return s
+1;
7181 else if(*s
==b
)cont
++;
7186 static const char*max_expand(MatchState
*ms
,const char*s
,
7187 const char*p
,const char*ep
){
7189 while((s
+i
)<ms
->src_end
&&singlematch(uchar(*(s
+i
)),p
,ep
))
7192 const char*res
=match(ms
,(s
+i
),ep
+1);
7198 static const char*min_expand(MatchState
*ms
,const char*s
,
7199 const char*p
,const char*ep
){
7201 const char*res
=match(ms
,s
,ep
+1);
7204 else if(s
<ms
->src_end
&&singlematch(uchar(*s
),p
,ep
))
7209 static const char*start_capture(MatchState
*ms
,const char*s
,
7210 const char*p
,int what
){
7212 int level
=ms
->level
;
7213 if(level
>=32)luaL_error(ms
->L
,"too many captures");
7214 ms
->capture
[level
].init
=s
;
7215 ms
->capture
[level
].len
=what
;
7217 if((res
=match(ms
,s
,p
))==NULL
)
7221 static const char*end_capture(MatchState
*ms
,const char*s
,
7223 int l
=capture_to_close(ms
);
7225 ms
->capture
[l
].len
=s
-ms
->capture
[l
].init
;
7226 if((res
=match(ms
,s
,p
))==NULL
)
7227 ms
->capture
[l
].len
=(-1);
7230 static const char*match_capture(MatchState
*ms
,const char*s
,int l
){
7232 l
=check_capture(ms
,l
);
7233 len
=ms
->capture
[l
].len
;
7234 if((size_t)(ms
->src_end
-s
)>=len
&&
7235 memcmp(ms
->capture
[l
].init
,s
,len
)==0)
7239 static const char*match(MatchState
*ms
,const char*s
,const char*p
){
7244 return start_capture(ms
,s
,p
+2,(-2));
7246 return start_capture(ms
,s
,p
+1,(-1));
7249 return end_capture(ms
,s
,p
+1);
7254 s
=matchbalance(ms
,s
,p
+2);
7255 if(s
==NULL
)return NULL
;
7259 const char*ep
;char previous
;
7262 luaL_error(ms
->L
,"missing "LUA_QL("[")" after "
7263 LUA_QL("%%f")" in pattern");
7265 previous
=(s
==ms
->src_init
)?'\0':*(s
-1);
7266 if(matchbracketclass(uchar(previous
),p
,ep
-1)||
7267 !matchbracketclass(uchar(*s
),p
,ep
-1))return NULL
;
7271 if(isdigit(uchar(*(p
+1)))){
7272 s
=match_capture(ms
,s
,uchar(*(p
+1)));
7273 if(s
==NULL
)return NULL
;
7285 return(s
==ms
->src_end
)?s
:NULL
;
7289 const char*ep
=classend(ms
,p
);
7290 int m
=s
<ms
->src_end
&&singlematch(uchar(*s
),p
,ep
);
7294 if(m
&&((res
=match(ms
,s
+1,ep
+1))!=NULL
))
7299 return max_expand(ms
,s
,p
,ep
);
7302 return(m
?max_expand(ms
,s
+1,p
,ep
):NULL
);
7305 return min_expand(ms
,s
,p
,ep
);
7315 static const char*lmemfind(const char*s1
,size_t l1
,
7316 const char*s2
,size_t l2
){
7318 else if(l2
>l1
)return NULL
;
7323 while(l1
>0&&(init
=(const char*)memchr(s1
,*s2
,l1
))!=NULL
){
7325 if(memcmp(init
,s2
+1,l2
)==0)
7335 static void push_onecapture(MatchState
*ms
,int i
,const char*s
,
7339 lua_pushlstring(ms
->L
,s
,e
-s
);
7341 luaL_error(ms
->L
,"invalid capture index");
7344 ptrdiff_t l
=ms
->capture
[i
].len
;
7345 if(l
==(-1))luaL_error(ms
->L
,"unfinished capture");
7347 lua_pushinteger(ms
->L
,ms
->capture
[i
].init
-ms
->src_init
+1);
7349 lua_pushlstring(ms
->L
,ms
->capture
[i
].init
,l
);
7352 static int push_captures(MatchState
*ms
,const char*s
,const char*e
){
7354 int nlevels
=(ms
->level
==0&&s
)?1:ms
->level
;
7355 luaL_checkstack(ms
->L
,nlevels
,"too many captures");
7356 for(i
=0;i
<nlevels
;i
++)
7357 push_onecapture(ms
,i
,s
,e
);
7360 static int str_find_aux(lua_State
*L
,int find
){
7362 const char*s
=luaL_checklstring(L
,1,&l1
);
7363 const char*p
=luaL_checklstring(L
,2,&l2
);
7364 ptrdiff_t init
=posrelat(luaL_optinteger(L
,3,1),l1
)-1;
7366 else if((size_t)(init
)>l1
)init
=(ptrdiff_t)l1
;
7367 if(find
&&(lua_toboolean(L
,4)||
7368 strpbrk(p
,"^$*+?.([%-")==NULL
)){
7369 const char*s2
=lmemfind(s
+init
,l1
-init
,p
,l2
);
7371 lua_pushinteger(L
,s2
-s
+1);
7372 lua_pushinteger(L
,s2
-s
+l2
);
7378 int anchor
=(*p
=='^')?(p
++,1):0;
7379 const char*s1
=s
+init
;
7386 if((res
=match(&ms
,s1
,p
))!=NULL
){
7388 lua_pushinteger(L
,s1
-s
+1);
7389 lua_pushinteger(L
,res
-s
);
7390 return push_captures(&ms
,NULL
,0)+2;
7393 return push_captures(&ms
,s1
,res
);
7395 }while(s1
++<ms
.src_end
&&!anchor
);
7400 static int str_find(lua_State
*L
){
7401 return str_find_aux(L
,1);
7403 static int str_match(lua_State
*L
){
7404 return str_find_aux(L
,0);
7406 static int gmatch_aux(lua_State
*L
){
7409 const char*s
=lua_tolstring(L
,lua_upvalueindex(1),&ls
);
7410 const char*p
=lua_tostring(L
,lua_upvalueindex(2));
7415 for(src
=s
+(size_t)lua_tointeger(L
,lua_upvalueindex(3));
7420 if((e
=match(&ms
,src
,p
))!=NULL
){
7421 lua_Integer newstart
=e
-s
;
7422 if(e
==src
)newstart
++;
7423 lua_pushinteger(L
,newstart
);
7424 lua_replace(L
,lua_upvalueindex(3));
7425 return push_captures(&ms
,src
,e
);
7430 static int gmatch(lua_State
*L
){
7431 luaL_checkstring(L
,1);
7432 luaL_checkstring(L
,2);
7434 lua_pushinteger(L
,0);
7435 lua_pushcclosure(L
,gmatch_aux
,3);
7438 static void add_s(MatchState
*ms
,luaL_Buffer
*b
,const char*s
,
7441 const char*news
=lua_tolstring(ms
->L
,3,&l
);
7444 luaL_addchar(b
,news
[i
]);
7447 if(!isdigit(uchar(news
[i
])))
7448 luaL_addchar(b
,news
[i
]);
7449 else if(news
[i
]=='0')
7450 luaL_addlstring(b
,s
,e
-s
);
7452 push_onecapture(ms
,news
[i
]-'1',s
,e
);
7458 static void add_value(MatchState
*ms
,luaL_Buffer
*b
,const char*s
,
7461 switch(lua_type(L
,3)){
7470 n
=push_captures(ms
,s
,e
);
7475 push_onecapture(ms
,0,s
,e
);
7480 if(!lua_toboolean(L
,-1)){
7482 lua_pushlstring(L
,s
,e
-s
);
7484 else if(!lua_isstring(L
,-1))
7485 luaL_error(L
,"invalid replacement value (a %s)",luaL_typename(L
,-1));
7488 static int str_gsub(lua_State
*L
){
7490 const char*src
=luaL_checklstring(L
,1,&srcl
);
7491 const char*p
=luaL_checkstring(L
,2);
7492 int tr
=lua_type(L
,3);
7493 int max_s
=luaL_optint(L
,4,srcl
+1);
7494 int anchor
=(*p
=='^')?(p
++,1):0;
7498 luaL_argcheck(L
,tr
==3||tr
==4||
7500 "string/function/table expected");
7501 luaL_buffinit(L
,&b
);
7504 ms
.src_end
=src
+srcl
;
7511 add_value(&ms
,&b
,src
,e
);
7515 else if(src
<ms
.src_end
)
7516 luaL_addchar(&b
,*src
++);
7520 luaL_addlstring(&b
,src
,ms
.src_end
-src
);
7521 luaL_pushresult(&b
);
7522 lua_pushinteger(L
,n
);
7525 static void addquoted(lua_State
*L
,luaL_Buffer
*b
,int arg
){
7527 const char*s
=luaL_checklstring(L
,arg
,&l
);
7528 luaL_addchar(b
,'"');
7531 case'"':case'\\':case'\n':{
7532 luaL_addchar(b
,'\\');
7537 luaL_addlstring(b
,"\\r",2);
7541 luaL_addlstring(b
,"\\000",4);
7551 luaL_addchar(b
,'"');
7553 static const char*scanformat(lua_State
*L
,const char*strfrmt
,char*form
){
7554 const char*p
=strfrmt
;
7555 while(*p
!='\0'&&strchr("-+ #0",*p
)!=NULL
)p
++;
7556 if((size_t)(p
-strfrmt
)>=sizeof("-+ #0"))
7557 luaL_error(L
,"invalid format (repeated flags)");
7558 if(isdigit(uchar(*p
)))p
++;
7559 if(isdigit(uchar(*p
)))p
++;
7562 if(isdigit(uchar(*p
)))p
++;
7563 if(isdigit(uchar(*p
)))p
++;
7565 if(isdigit(uchar(*p
)))
7566 luaL_error(L
,"invalid format (width or precision too long)");
7568 strncpy(form
,strfrmt
,p
-strfrmt
+1);
7573 static void addintlen(char*form
){
7574 size_t l
=strlen(form
);
7575 char spec
=form
[l
-1];
7576 strcpy(form
+l
-1,"l");
7577 form
[l
+sizeof("l")-2]=spec
;
7578 form
[l
+sizeof("l")-1]='\0';
7580 static int str_format(lua_State
*L
){
7581 int top
=lua_gettop(L
);
7584 const char*strfrmt
=luaL_checklstring(L
,arg
,&sfl
);
7585 const char*strfrmt_end
=strfrmt
+sfl
;
7587 luaL_buffinit(L
,&b
);
7588 while(strfrmt
<strfrmt_end
){
7590 luaL_addchar(&b
,*strfrmt
++);
7591 else if(*++strfrmt
=='%')
7592 luaL_addchar(&b
,*strfrmt
++);
7594 char form
[(sizeof("-+ #0")+sizeof("l")+10)];
7597 luaL_argerror(L
,arg
,"no value");
7598 strfrmt
=scanformat(L
,strfrmt
,form
);
7601 sprintf(buff
,form
,(int)luaL_checknumber(L
,arg
));
7606 sprintf(buff
,form
,(long)luaL_checknumber(L
,arg
));
7609 case'o':case'u':case'x':case'X':{
7611 sprintf(buff
,form
,(unsigned long)luaL_checknumber(L
,arg
));
7614 case'e':case'E':case'f':
7616 sprintf(buff
,form
,(double)luaL_checknumber(L
,arg
));
7620 addquoted(L
,&b
,arg
);
7625 const char*s
=luaL_checklstring(L
,arg
,&l
);
7626 if(!strchr(form
,'.')&&l
>=100){
7627 lua_pushvalue(L
,arg
);
7632 sprintf(buff
,form
,s
);
7637 return luaL_error(L
,"invalid option "LUA_QL("%%%c")" to "
7638 LUA_QL("format"),*(strfrmt
-1));
7641 luaL_addlstring(&b
,buff
,strlen(buff
));
7644 luaL_pushresult(&b
);
7647 static const luaL_Reg strlib
[]={
7651 {"format",str_format
},
7654 {"lower",str_lower
},
7655 {"match",str_match
},
7658 {"upper",str_upper
},
7661 static void createmetatable(lua_State
*L
){
7662 lua_createtable(L
,0,1);
7663 lua_pushliteral(L
,"");
7664 lua_pushvalue(L
,-2);
7665 lua_setmetatable(L
,-2);
7667 lua_pushvalue(L
,-2);
7668 lua_setfield(L
,-2,"__index");
7671 static int luaopen_string(lua_State
*L
){
7672 luaL_register(L
,"string",strlib
);
7676 static const luaL_Reg lualibs
[]={
7678 {"table",luaopen_table
},
7681 {"string",luaopen_string
},
7684 static void luaL_openlibs(lua_State
*L
){
7685 const luaL_Reg
*lib
=lualibs
;
7686 for(;lib
->func
;lib
++){
7687 lua_pushcfunction(L
,lib
->func
);
7688 lua_pushstring(L
,lib
->name
);
7692 typedef unsigned int UB
;
7693 static UB
barg(lua_State
*L
,int idx
){
7694 union{lua_Number n
;U64 b
;}bn
;
7695 bn
.n
=lua_tonumber(L
,idx
)+6755399441055744.0;
7696 if(bn
.n
==0.0&&!lua_isnumber(L
,idx
))luaL_typerror(L
,idx
,"number");
7699 #define BRET(b)lua_pushnumber(L,(lua_Number)(int)(b));return 1;
7700 static int tobit(lua_State
*L
){
7702 static int bnot(lua_State
*L
){
7704 static int band(lua_State
*L
){
7705 int i
;UB b
=barg(L
,1);for(i
=lua_gettop(L
);i
>1;i
--)b
&=barg(L
,i
);BRET(b
)}
7706 static int bor(lua_State
*L
){
7707 int i
;UB b
=barg(L
,1);for(i
=lua_gettop(L
);i
>1;i
--)b
|=barg(L
,i
);BRET(b
)}
7708 static int bxor(lua_State
*L
){
7709 int i
;UB b
=barg(L
,1);for(i
=lua_gettop(L
);i
>1;i
--)b
^=barg(L
,i
);BRET(b
)}
7710 static int lshift(lua_State
*L
){
7711 UB b
=barg(L
,1),n
=barg(L
,2)&31;BRET(b
<<n
)}
7712 static int rshift(lua_State
*L
){
7713 UB b
=barg(L
,1),n
=barg(L
,2)&31;BRET(b
>>n
)}
7714 static int arshift(lua_State
*L
){
7715 UB b
=barg(L
,1),n
=barg(L
,2)&31;BRET((int)b
>>n
)}
7716 static int rol(lua_State
*L
){
7717 UB b
=barg(L
,1),n
=barg(L
,2)&31;BRET((b
<<n
)|(b
>>(32-n
)))}
7718 static int ror(lua_State
*L
){
7719 UB b
=barg(L
,1),n
=barg(L
,2)&31;BRET((b
>>n
)|(b
<<(32-n
)))}
7720 static int bswap(lua_State
*L
){
7721 UB b
=barg(L
,1);b
=(b
>>24)|((b
>>8)&0xff00)|((b
&0xff00)<<8)|(b
<<24);BRET(b
)}
7722 static int tohex(lua_State
*L
){
7724 int n
=lua_isnone(L
,2)?8:(int)barg(L
,2);
7725 const char*hexdigits
="0123456789abcdef";
7728 if(n
<0){n
=-n
;hexdigits
="0123456789ABCDEF";}
7730 for(i
=(int)n
;--i
>=0;){buf
[i
]=hexdigits
[b
&15];b
>>=4;}
7731 lua_pushlstring(L
,buf
,(size_t)n
);
7734 static const struct luaL_Reg bitlib
[]={
7742 {"arshift",arshift
},
7749 int main(int argc
,char**argv
){
7750 lua_State
*L
=luaL_newstate();
7753 luaL_register(L
,"bit",bitlib
);
7754 if(argc
<2)return sizeof(void*);
7755 lua_createtable(L
,0,1);
7756 lua_pushstring(L
,argv
[1]);
7757 lua_rawseti(L
,-2,0);
7758 lua_setglobal(L
,"arg");
7759 if(luaL_loadfile(L
,argv
[1]))
7762 lua_pushstring(L
,argv
[i
]);
7763 if(lua_pcall(L
,argc
-2,0,0)){
7765 fprintf(stderr
,"Error: %s\n",lua_tostring(L
,-1));