root/host/minilua.c

/* [<][>][^][v][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. luaM_growaux_
  2. luaM_toobig
  3. luaM_realloc_
  4. luaO_int2fb
  5. luaO_fb2int
  6. luaO_log2
  7. luaO_rawequalObj
  8. luaO_str2d
  9. pushstr
  10. luaO_pushvfstring
  11. luaO_pushfstring
  12. luaO_chunkid
  13. luaT_init
  14. luaT_gettm
  15. luaT_gettmbyobj
  16. luaF_newCclosure
  17. luaF_newLclosure
  18. luaF_newupval
  19. luaF_findupval
  20. unlinkupval
  21. luaF_freeupval
  22. luaF_close
  23. luaF_newproto
  24. luaF_freeproto
  25. luaF_freeclosure
  26. luaD_seterrorobj
  27. restore_stack_limit
  28. resetstack
  29. luaD_throw
  30. luaD_rawrunprotected
  31. correctstack
  32. luaD_reallocstack
  33. luaD_reallocCI
  34. luaD_growstack
  35. growCI
  36. adjust_varargs
  37. tryfuncTM
  38. luaD_precall
  39. luaD_poscall
  40. luaD_call
  41. luaD_pcall
  42. f_parser
  43. luaD_protectedparser
  44. luaS_resize
  45. newlstr
  46. luaS_newlstr
  47. luaS_newudata
  48. hashnum
  49. mainposition
  50. arrayindex
  51. findindex
  52. luaH_next
  53. computesizes
  54. countint
  55. numusearray
  56. numusehash
  57. setarrayvector
  58. setnodevector
  59. resize
  60. luaH_resizearray
  61. rehash
  62. luaH_new
  63. luaH_free
  64. getfreepos
  65. newkey
  66. luaH_getnum
  67. luaH_getstr
  68. luaH_get
  69. luaH_set
  70. luaH_setnum
  71. luaH_setstr
  72. unbound_search
  73. luaH_getn
  74. removeentry
  75. reallymarkobject
  76. marktmu
  77. luaC_separateudata
  78. traversetable
  79. traverseproto
  80. traverseclosure
  81. checkstacksizes
  82. traversestack
  83. propagatemark
  84. propagateall
  85. iscleared
  86. cleartable
  87. freeobj
  88. sweeplist
  89. checkSizes
  90. GCTM
  91. luaC_callGCTM
  92. luaC_freeall
  93. markmt
  94. markroot
  95. remarkupvals
  96. atomic
  97. singlestep
  98. luaC_step
  99. luaC_barrierf
  100. luaC_barrierback
  101. luaC_link
  102. luaC_linkupval
  103. stack_init
  104. freestack
  105. f_luaopen
  106. preinit_state
  107. close_state
  108. luaE_freethread
  109. lua_newstate
  110. callallgcTM
  111. lua_close
  112. currentpc
  113. currentline
  114. lua_getstack
  115. getluaproto
  116. funcinfo
  117. info_tailcall
  118. collectvalidlines
  119. auxgetinfo
  120. lua_getinfo
  121. isinstack
  122. luaG_typeerror
  123. luaG_concaterror
  124. luaG_aritherror
  125. luaG_ordererror
  126. addinfo
  127. luaG_errormsg
  128. luaG_runerror
  129. luaZ_fill
  130. luaZ_init
  131. luaZ_openspace
  132. save
  133. luaX_init
  134. luaX_token2str
  135. txtToken
  136. luaX_lexerror
  137. luaX_syntaxerror
  138. luaX_newstring
  139. inclinenumber
  140. luaX_setinput
  141. check_next
  142. buffreplace
  143. read_numeral
  144. skip_sep
  145. read_long_string
  146. read_string
  147. llex
  148. luaX_next
  149. luaX_lookahead
  150. isnumeral
  151. luaK_nil
  152. luaK_jump
  153. luaK_ret
  154. condjump
  155. fixjump
  156. luaK_getlabel
  157. getjump
  158. getjumpcontrol
  159. need_value
  160. patchtestreg
  161. removevalues
  162. patchlistaux
  163. dischargejpc
  164. luaK_patchlist
  165. luaK_patchtohere
  166. luaK_concat
  167. luaK_checkstack
  168. luaK_reserveregs
  169. freereg
  170. freeexp
  171. addk
  172. luaK_stringK
  173. luaK_numberK
  174. boolK
  175. nilK
  176. luaK_setreturns
  177. luaK_setoneret
  178. luaK_dischargevars
  179. code_label
  180. discharge2reg
  181. discharge2anyreg
  182. exp2reg
  183. luaK_exp2nextreg
  184. luaK_exp2anyreg
  185. luaK_exp2val
  186. luaK_exp2RK
  187. luaK_storevar
  188. luaK_self
  189. invertjump
  190. jumponcond
  191. luaK_goiftrue
  192. luaK_goiffalse
  193. codenot
  194. luaK_indexed
  195. constfolding
  196. codearith
  197. codecomp
  198. luaK_prefix
  199. luaK_infix
  200. luaK_posfix
  201. luaK_fixline
  202. luaK_code
  203. luaK_codeABC
  204. luaK_codeABx
  205. luaK_setlist
  206. anchor_token
  207. error_expected
  208. errorlimit
  209. testnext
  210. check
  211. checknext
  212. check_match
  213. str_checkname
  214. init_exp
  215. codestring
  216. checkname
  217. registerlocalvar
  218. new_localvar
  219. adjustlocalvars
  220. removevars
  221. indexupvalue
  222. searchvar
  223. markupval
  224. singlevaraux
  225. singlevar
  226. adjust_assign
  227. enterlevel
  228. enterblock
  229. leaveblock
  230. pushclosure
  231. open_func
  232. close_func
  233. luaY_parser
  234. field
  235. yindex
  236. recfield
  237. closelistfield
  238. lastlistfield
  239. listfield
  240. constructor
  241. parlist
  242. body
  243. explist1
  244. funcargs
  245. prefixexp
  246. primaryexp
  247. simpleexp
  248. getunopr
  249. getbinopr
  250. subexpr
  251. expr
  252. block_follow
  253. block
  254. check_conflict
  255. assignment
  256. cond
  257. breakstat
  258. whilestat
  259. repeatstat
  260. exp1
  261. forbody
  262. fornum
  263. forlist
  264. forstat
  265. test_then_block
  266. ifstat
  267. localfunc
  268. localstat
  269. funcname
  270. funcstat
  271. exprstat
  272. retstat
  273. statement
  274. chunk
  275. luaV_tonumber
  276. luaV_tostring
  277. callTMres
  278. callTM
  279. luaV_gettable
  280. luaV_settable
  281. call_binTM
  282. get_compTM
  283. call_orderTM
  284. l_strcmp
  285. luaV_lessthan
  286. lessequal
  287. luaV_equalval
  288. luaV_concat
  289. Arith
  290. luaV_execute
  291. index2adr
  292. getcurrenv
  293. lua_checkstack
  294. lua_atpanic
  295. lua_gettop
  296. lua_settop
  297. lua_remove
  298. lua_insert
  299. lua_replace
  300. lua_pushvalue
  301. lua_type
  302. lua_typename
  303. lua_iscfunction
  304. lua_isnumber
  305. lua_isstring
  306. lua_rawequal
  307. lua_lessthan
  308. lua_tonumber
  309. lua_tointeger
  310. lua_toboolean
  311. lua_tolstring
  312. lua_objlen
  313. lua_tocfunction
  314. lua_touserdata
  315. lua_pushnil
  316. lua_pushnumber
  317. lua_pushinteger
  318. lua_pushlstring
  319. lua_pushstring
  320. lua_pushvfstring
  321. lua_pushfstring
  322. lua_pushcclosure
  323. lua_pushboolean
  324. lua_pushthread
  325. lua_gettable
  326. lua_getfield
  327. lua_rawget
  328. lua_rawgeti
  329. lua_createtable
  330. lua_getmetatable
  331. lua_getfenv
  332. lua_settable
  333. lua_setfield
  334. lua_rawset
  335. lua_rawseti
  336. lua_setmetatable
  337. lua_setfenv
  338. lua_call
  339. f_call
  340. lua_pcall
  341. lua_load
  342. lua_error
  343. lua_next
  344. lua_concat
  345. lua_newuserdata
  346. luaL_argerror
  347. luaL_typerror
  348. tag_error
  349. luaL_where
  350. luaL_error
  351. luaL_newmetatable
  352. luaL_checkudata
  353. luaL_checkstack
  354. luaL_checktype
  355. luaL_checkany
  356. luaL_checklstring
  357. luaL_optlstring
  358. luaL_checknumber
  359. luaL_checkinteger
  360. luaL_optinteger
  361. luaL_getmetafield
  362. luaL_register
  363. libsize
  364. luaI_openlib
  365. luaL_findtable
  366. emptybuffer
  367. adjuststack
  368. luaL_prepbuffer
  369. luaL_addlstring
  370. luaL_pushresult
  371. luaL_addvalue
  372. luaL_buffinit
  373. getF
  374. errfile
  375. luaL_loadfile
  376. getS
  377. luaL_loadbuffer
  378. l_alloc
  379. panic
  380. luaL_newstate
  381. luaB_tonumber
  382. luaB_error
  383. luaB_setmetatable
  384. getfunc
  385. luaB_setfenv
  386. luaB_rawget
  387. luaB_type
  388. luaB_next
  389. luaB_pairs
  390. ipairsaux
  391. luaB_ipairs
  392. load_aux
  393. luaB_loadstring
  394. luaB_loadfile
  395. luaB_assert
  396. luaB_unpack
  397. luaB_pcall
  398. luaB_newproxy
  399. auxopen
  400. base_open
  401. luaopen_base
  402. tinsert
  403. tremove
  404. addfield
  405. tconcat
  406. set2
  407. sort_comp
  408. auxsort
  409. sort
  410. luaopen_table
  411. pushresult
  412. fileerror
  413. io_type
  414. tofile
  415. newfile
  416. io_noclose
  417. io_pclose
  418. io_fclose
  419. aux_close
  420. io_close
  421. io_gc
  422. io_open
  423. getiofile
  424. g_iofile
  425. io_input
  426. io_output
  427. aux_lines
  428. f_lines
  429. io_lines
  430. read_number
  431. test_eof
  432. read_line
  433. read_chars
  434. g_read
  435. io_read
  436. f_read
  437. io_readline
  438. g_write
  439. io_write
  440. f_write
  441. io_flush
  442. f_flush
  443. createmeta
  444. createstdfile
  445. newfenv
  446. luaopen_io
  447. os_pushresult
  448. os_remove
  449. os_exit
  450. luaopen_os
  451. posrelat
  452. str_sub
  453. str_lower
  454. str_upper
  455. str_rep
  456. str_byte
  457. str_char
  458. check_capture
  459. capture_to_close
  460. classend
  461. match_class
  462. matchbracketclass
  463. singlematch
  464. matchbalance
  465. max_expand
  466. min_expand
  467. start_capture
  468. end_capture
  469. match_capture
  470. match
  471. lmemfind
  472. push_onecapture
  473. push_captures
  474. str_find_aux
  475. str_find
  476. str_match
  477. gmatch_aux
  478. gmatch
  479. add_s
  480. add_value
  481. str_gsub
  482. addquoted
  483. scanformat
  484. addintlen
  485. str_format
  486. createmetatable
  487. luaopen_string
  488. luaL_openlibs
  489. barg
  490. tobit
  491. bnot
  492. band
  493. bor
  494. bxor
  495. lshift
  496. rshift
  497. arshift
  498. rol
  499. ror
  500. bswap
  501. tohex
  502. main

   1 /* This is a heavily customized and minimized copy of Lua 5.1.5. */
   2 /* It's only used to build LuaJIT. It does NOT have all standard functions! */
   3 /******************************************************************************
   4 * Copyright (C) 1994-2012 Lua.org, PUC-Rio.  All rights reserved.
   5 *
   6 * Permission is hereby granted, free of charge, to any person obtaining
   7 * a copy of this software and associated documentation files (the
   8 * "Software"), to deal in the Software without restriction, including
   9 * without limitation the rights to use, copy, modify, merge, publish,
  10 * distribute, sublicense, and/or sell copies of the Software, and to
  11 * permit persons to whom the Software is furnished to do so, subject to
  12 * the following conditions:
  13 *
  14 * The above copyright notice and this permission notice shall be
  15 * included in all copies or substantial portions of the Software.
  16 *
  17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  18 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  19 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  20 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
  21 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  22 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  23 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  24 ******************************************************************************/
  25 #ifdef _MSC_VER
  26 typedef unsigned __int64 U64;
  27 #else
  28 typedef unsigned long long U64;
  29 #endif
  30 int _CRT_glob = 0;
  31 #include <stddef.h>
  32 #include <stdarg.h>
  33 #include <limits.h>
  34 #include <math.h>
  35 #include <ctype.h>
  36 #include <stdio.h>
  37 #include <stdlib.h>
  38 #include <string.h>
  39 #include <setjmp.h>
  40 #include <errno.h>
  41 #include <time.h>
  42 typedef enum{
  43 TM_INDEX,
  44 TM_NEWINDEX,
  45 TM_GC,
  46 TM_MODE,
  47 TM_EQ,
  48 TM_ADD,
  49 TM_SUB,
  50 TM_MUL,
  51 TM_DIV,
  52 TM_MOD,
  53 TM_POW,
  54 TM_UNM,
  55 TM_LEN,
  56 TM_LT,
  57 TM_LE,
  58 TM_CONCAT,
  59 TM_CALL,
  60 TM_N
  61 }TMS;
  62 enum OpMode{iABC,iABx,iAsBx};
  63 typedef enum{
  64 OP_MOVE,
  65 OP_LOADK,
  66 OP_LOADBOOL,
  67 OP_LOADNIL,
  68 OP_GETUPVAL,
  69 OP_GETGLOBAL,
  70 OP_GETTABLE,
  71 OP_SETGLOBAL,
  72 OP_SETUPVAL,
  73 OP_SETTABLE,
  74 OP_NEWTABLE,
  75 OP_SELF,
  76 OP_ADD,
  77 OP_SUB,
  78 OP_MUL,
  79 OP_DIV,
  80 OP_MOD,
  81 OP_POW,
  82 OP_UNM,
  83 OP_NOT,
  84 OP_LEN,
  85 OP_CONCAT,
  86 OP_JMP,
  87 OP_EQ,
  88 OP_LT,
  89 OP_LE,
  90 OP_TEST,
  91 OP_TESTSET,
  92 OP_CALL,
  93 OP_TAILCALL,
  94 OP_RETURN,
  95 OP_FORLOOP,
  96 OP_FORPREP,
  97 OP_TFORLOOP,
  98 OP_SETLIST,
  99 OP_CLOSE,
 100 OP_CLOSURE,
 101 OP_VARARG
 102 }OpCode;
 103 enum OpArgMask{
 104 OpArgN,
 105 OpArgU,
 106 OpArgR,
 107 OpArgK
 108 };
 109 typedef enum{
 110 VVOID,
 111 VNIL,
 112 VTRUE,
 113 VFALSE,
 114 VK,
 115 VKNUM,
 116 VLOCAL,
 117 VUPVAL,
 118 VGLOBAL,
 119 VINDEXED,
 120 VJMP,
 121 VRELOCABLE,
 122 VNONRELOC,
 123 VCALL,
 124 VVARARG
 125 }expkind;
 126 enum RESERVED{
 127 TK_AND=257,TK_BREAK,
 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
 133 };
 134 typedef enum BinOpr{
 135 OPR_ADD,OPR_SUB,OPR_MUL,OPR_DIV,OPR_MOD,OPR_POW,
 136 OPR_CONCAT,
 137 OPR_NE,OPR_EQ,
 138 OPR_LT,OPR_LE,OPR_GT,OPR_GE,
 139 OPR_AND,OPR_OR,
 140 OPR_NOBINOPR
 141 }BinOpr;
 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);
 193 struct lua_Debug{
 194 int event;
 195 const char*name;
 196 const char*namewhat;
 197 const char*what;
 198 const char*source;
 199 int currentline;
 200 int nups;
 201 int linedefined;
 202 int lastlinedefined;
 203 char short_src[60];
 204 int i_ci;
 205 };
 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;
 224 }GCheader;
 225 typedef union{
 226 GCObject*gc;
 227 void*p;
 228 lua_Number n;
 229 int b;
 230 }Value;
 231 typedef struct lua_TValue{
 232 Value value;int tt;
 233 }TValue;
 234 #define ttisnil(o)(ttype(o)==0)
 235 #define ttisnumber(o)(ttype(o)==3)
 236 #define ttisstring(o)(ttype(o)==4)
 237 #define ttistable(o)(ttype(o)==5)
 238 #define ttisfunction(o)(ttype(o)==6)
 239 #define ttisboolean(o)(ttype(o)==1)
 240 #define ttisuserdata(o)(ttype(o)==7)
 241 #define ttisthread(o)(ttype(o)==8)
 242 #define ttislightuserdata(o)(ttype(o)==2)
 243 #define ttype(o)((o)->tt)
 244 #define gcvalue(o)check_exp(iscollectable(o),(o)->value.gc)
 245 #define pvalue(o)check_exp(ttislightuserdata(o),(o)->value.p)
 246 #define nvalue(o)check_exp(ttisnumber(o),(o)->value.n)
 247 #define rawtsvalue(o)check_exp(ttisstring(o),&(o)->value.gc->ts)
 248 #define tsvalue(o)(&rawtsvalue(o)->tsv)
 249 #define rawuvalue(o)check_exp(ttisuserdata(o),&(o)->value.gc->u)
 250 #define uvalue(o)(&rawuvalue(o)->uv)
 251 #define clvalue(o)check_exp(ttisfunction(o),&(o)->value.gc->cl)
 252 #define hvalue(o)check_exp(ttistable(o),&(o)->value.gc->h)
 253 #define bvalue(o)check_exp(ttisboolean(o),(o)->value.b)
 254 #define thvalue(o)check_exp(ttisthread(o),&(o)->value.gc->th)
 255 #define l_isfalse(o)(ttisnil(o)||(ttisboolean(o)&&bvalue(o)==0))
 256 #define checkconsistency(obj)
 257 #define checkliveness(g,obj)
 258 #define setnilvalue(obj)((obj)->tt=0)
 259 #define setnvalue(obj,x){TValue*i_o=(obj);i_o->value.n=(x);i_o->tt=3;}
 260 #define setbvalue(obj,x){TValue*i_o=(obj);i_o->value.b=(x);i_o->tt=1;}
 261 #define setsvalue(L,obj,x){TValue*i_o=(obj);i_o->value.gc=cast(GCObject*,(x));i_o->tt=4;checkliveness(G(L),i_o);}
 262 #define setuvalue(L,obj,x){TValue*i_o=(obj);i_o->value.gc=cast(GCObject*,(x));i_o->tt=7;checkliveness(G(L),i_o);}
 263 #define setthvalue(L,obj,x){TValue*i_o=(obj);i_o->value.gc=cast(GCObject*,(x));i_o->tt=8;checkliveness(G(L),i_o);}
 264 #define setclvalue(L,obj,x){TValue*i_o=(obj);i_o->value.gc=cast(GCObject*,(x));i_o->tt=6;checkliveness(G(L),i_o);}
 265 #define sethvalue(L,obj,x){TValue*i_o=(obj);i_o->value.gc=cast(GCObject*,(x));i_o->tt=5;checkliveness(G(L),i_o);}
 266 #define setptvalue(L,obj,x){TValue*i_o=(obj);i_o->value.gc=cast(GCObject*,(x));i_o->tt=(8+1);checkliveness(G(L),i_o);}
 267 #define setobj(L,obj1,obj2){const TValue*o2=(obj2);TValue*o1=(obj1);o1->value=o2->value;o1->tt=o2->tt;checkliveness(G(L),o1);}
 268 #define setttype(obj,tt)(ttype(obj)=(tt))
 269 #define iscollectable(o)(ttype(o)>=4)
 270 typedef TValue*StkId;
 271 typedef union TString{
 272 L_Umaxalign dummy;
 273 struct{
 274 GCObject*next;lu_byte tt;lu_byte marked;
 275 lu_byte reserved;
 276 unsigned int hash;
 277 size_t len;
 278 }tsv;
 279 }TString;
 280 #define getstr(ts)cast(const char*,(ts)+1)
 281 #define svalue(o)getstr(rawtsvalue(o))
 282 typedef union Udata{
 283 L_Umaxalign dummy;
 284 struct{
 285 GCObject*next;lu_byte tt;lu_byte marked;
 286 struct Table*metatable;
 287 struct Table*env;
 288 size_t len;
 289 }uv;
 290 }Udata;
 291 typedef struct Proto{
 292 GCObject*next;lu_byte tt;lu_byte marked;
 293 TValue*k;
 294 Instruction*code;
 295 struct Proto**p;
 296 int*lineinfo;
 297 struct LocVar*locvars;
 298 TString**upvalues;
 299 TString*source;
 300 int sizeupvalues;
 301 int sizek;
 302 int sizecode;
 303 int sizelineinfo;
 304 int sizep;
 305 int sizelocvars;
 306 int linedefined;
 307 int lastlinedefined;
 308 GCObject*gclist;
 309 lu_byte nups;
 310 lu_byte numparams;
 311 lu_byte is_vararg;
 312 lu_byte maxstacksize;
 313 }Proto;
 314 typedef struct LocVar{
 315 TString*varname;
 316 int startpc;
 317 int endpc;
 318 }LocVar;
 319 typedef struct UpVal{
 320 GCObject*next;lu_byte tt;lu_byte marked;
 321 TValue*v;
 322 union{
 323 TValue value;
 324 struct{
 325 struct UpVal*prev;
 326 struct UpVal*next;
 327 }l;
 328 }u;
 329 }UpVal;
 330 typedef struct CClosure{
 331 GCObject*next;lu_byte tt;lu_byte marked;lu_byte isC;lu_byte nupvalues;GCObject*gclist;struct Table*env;
 332 lua_CFunction f;
 333 TValue upvalue[1];
 334 }CClosure;
 335 typedef struct LClosure{
 336 GCObject*next;lu_byte tt;lu_byte marked;lu_byte isC;lu_byte nupvalues;GCObject*gclist;struct Table*env;
 337 struct Proto*p;
 338 UpVal*upvals[1];
 339 }LClosure;
 340 typedef union Closure{
 341 CClosure c;
 342 LClosure l;
 343 }Closure;
 344 #define iscfunction(o)(ttype(o)==6&&clvalue(o)->c.isC)
 345 typedef union TKey{
 346 struct{
 347 Value value;int tt;
 348 struct Node*next;
 349 }nk;
 350 TValue tvk;
 351 }TKey;
 352 typedef struct Node{
 353 TValue i_val;
 354 TKey i_key;
 355 }Node;
 356 typedef struct Table{
 357 GCObject*next;lu_byte tt;lu_byte marked;
 358 lu_byte flags;
 359 lu_byte lsizenode;
 360 struct Table*metatable;
 361 TValue*array;
 362 Node*node;
 363 Node*lastfree;
 364 GCObject*gclist;
 365 int sizearray;
 366 }Table;
 367 #define lmod(s,size)(check_exp((size&(size-1))==0,(cast(int,(s)&((size)-1)))))
 368 #define twoto(x)((size_t)1<<(x))
 369 #define sizenode(t)(twoto((t)->lsizenode))
 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,
 386 size_t size);
 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{
 395 char*buffer;
 396 size_t n;
 397 size_t buffsize;
 398 }Mbuffer;
 399 #define luaZ_initbuffer(L,buff)((buff)->buffer=NULL,(buff)->buffsize=0)
 400 #define luaZ_buffer(buff)((buff)->buffer)
 401 #define luaZ_sizebuffer(buff)((buff)->buffsize)
 402 #define luaZ_bufflen(buff)((buff)->n)
 403 #define luaZ_resetbuffer(buff)((buff)->n=0)
 404 #define luaZ_resizebuffer(L,buff,size)(luaM_reallocvector(L,(buff)->buffer,(buff)->buffsize,size,char),(buff)->buffsize=size)
 405 #define luaZ_freebuffer(L,buff)luaZ_resizebuffer(L,buff,0)
 406 struct Zio{
 407 size_t n;
 408 const char*p;
 409 lua_Reader reader;
 410 void*data;
 411 lua_State*L;
 412 };
 413 static int luaZ_fill(ZIO*z);
 414 struct lua_longjmp;
 415 #define gt(L)(&L->l_gt)
 416 #define registry(L)(&G(L)->l_registry)
 417 typedef struct stringtable{
 418 GCObject**hash;
 419 lu_int32 nuse;
 420 int size;
 421 }stringtable;
 422 typedef struct CallInfo{
 423 StkId base;
 424 StkId func;
 425 StkId top;
 426 const Instruction*savedpc;
 427 int nresults;
 428 int tailcalls;
 429 }CallInfo;
 430 #define curr_func(L)(clvalue(L->ci->func))
 431 #define ci_func(ci)(clvalue((ci)->func))
 432 #define f_isLua(ci)(!ci_func(ci)->c.isC)
 433 #define isLua(ci)(ttisfunction((ci)->func)&&f_isLua(ci))
 434 typedef struct global_State{
 435 stringtable strt;
 436 lua_Alloc frealloc;
 437 void*ud;
 438 lu_byte currentwhite;
 439 lu_byte gcstate;
 440 int sweepstrgc;
 441 GCObject*rootgc;
 442 GCObject**sweepgc;
 443 GCObject*gray;
 444 GCObject*grayagain;
 445 GCObject*weak;
 446 GCObject*tmudata;
 447 Mbuffer buff;
 448 lu_mem GCthreshold;
 449 lu_mem totalbytes;
 450 lu_mem estimate;
 451 lu_mem gcdept;
 452 int gcpause;
 453 int gcstepmul;
 454 lua_CFunction panic;
 455 TValue l_registry;
 456 struct lua_State*mainthread;
 457 UpVal uvhead;
 458 struct Table*mt[(8+1)];
 459 TString*tmname[TM_N];
 460 }global_State;
 461 struct lua_State{
 462 GCObject*next;lu_byte tt;lu_byte marked;
 463 lu_byte status;
 464 StkId top;
 465 StkId base;
 466 global_State*l_G;
 467 CallInfo*ci;
 468 const Instruction*savedpc;
 469 StkId stack_last;
 470 StkId stack;
 471 CallInfo*end_ci;
 472 CallInfo*base_ci;
 473 int stacksize;
 474 int size_ci;
 475 unsigned short nCcalls;
 476 unsigned short baseCcalls;
 477 lu_byte hookmask;
 478 lu_byte allowhook;
 479 int basehookcount;
 480 int hookcount;
 481 lua_Hook hook;
 482 TValue l_gt;
 483 TValue env;
 484 GCObject*openupval;
 485 GCObject*gclist;
 486 struct lua_longjmp*errorJmp;
 487 ptrdiff_t errfunc;
 488 };
 489 #define G(L)(L->l_G)
 490 union GCObject{
 491 GCheader gch;
 492 union TString ts;
 493 union Udata u;
 494 union Closure cl;
 495 struct Table h;
 496 struct Proto p;
 497 struct UpVal uv;
 498 struct lua_State th;
 499 };
 500 #define rawgco2ts(o)check_exp((o)->gch.tt==4,&((o)->ts))
 501 #define gco2ts(o)(&rawgco2ts(o)->tsv)
 502 #define rawgco2u(o)check_exp((o)->gch.tt==7,&((o)->u))
 503 #define gco2u(o)(&rawgco2u(o)->uv)
 504 #define gco2cl(o)check_exp((o)->gch.tt==6,&((o)->cl))
 505 #define gco2h(o)check_exp((o)->gch.tt==5,&((o)->h))
 506 #define gco2p(o)check_exp((o)->gch.tt==(8+1),&((o)->p))
 507 #define gco2uv(o)check_exp((o)->gch.tt==(8+2),&((o)->uv))
 508 #define ngcotouv(o)check_exp((o)==NULL||(o)->gch.tt==(8+2),&((o)->uv))
 509 #define gco2th(o)check_exp((o)->gch.tt==8,&((o)->th))
 510 #define obj2gco(v)(cast(GCObject*,(v)))
 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,
 516 const char*opname);
 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){
 532 void*newblock;
 533 int newsize;
 534 if(*size>=limit/2){
 535 if(*size>=limit)
 536 luaG_runerror(L,errormsg);
 537 newsize=limit;
 538 }
 539 else{
 540 newsize=(*size)*2;
 541 if(newsize<4)
 542 newsize=4;
 543 }
 544 newblock=luaM_reallocv(L,block,*size,newsize,size_elems);
 545 *size=newsize;
 546 return newblock;
 547 }
 548 static void*luaM_toobig(lua_State*L){
 549 luaG_runerror(L,"memory allocation error: block too big");
 550 return NULL;
 551 }
 552 static void*luaM_realloc_(lua_State*L,void*block,size_t osize,size_t nsize){
 553 global_State*g=G(L);
 554 block=(*g->frealloc)(g->ud,block,osize,nsize);
 555 if(block==NULL&&nsize>0)
 556 luaD_throw(L,4);
 557 g->totalbytes=(g->totalbytes-osize)+nsize;
 558 return block;
 559 }
 560 #define resetbits(x,m)((x)&=cast(lu_byte,~(m)))
 561 #define setbits(x,m)((x)|=(m))
 562 #define testbits(x,m)((x)&(m))
 563 #define bitmask(b)(1<<(b))
 564 #define bit2mask(b1,b2)(bitmask(b1)|bitmask(b2))
 565 #define l_setbit(x,b)setbits(x,bitmask(b))
 566 #define resetbit(x,b)resetbits(x,bitmask(b))
 567 #define testbit(x,b)testbits(x,bitmask(b))
 568 #define set2bits(x,b1,b2)setbits(x,(bit2mask(b1,b2)))
 569 #define reset2bits(x,b1,b2)resetbits(x,(bit2mask(b1,b2)))
 570 #define test2bits(x,b1,b2)testbits(x,(bit2mask(b1,b2)))
 571 #define iswhite(x)test2bits((x)->gch.marked,0,1)
 572 #define isblack(x)testbit((x)->gch.marked,2)
 573 #define isgray(x)(!isblack(x)&&!iswhite(x))
 574 #define otherwhite(g)(g->currentwhite^bit2mask(0,1))
 575 #define isdead(g,v)((v)->gch.marked&otherwhite(g)&bit2mask(0,1))
 576 #define changewhite(x)((x)->gch.marked^=bit2mask(0,1))
 577 #define gray2black(x)l_setbit((x)->gch.marked,2)
 578 #define valiswhite(x)(iscollectable(x)&&iswhite(gcvalue(x)))
 579 #define luaC_white(g)cast(lu_byte,(g)->currentwhite&bit2mask(0,1))
 580 #define luaC_checkGC(L){condhardstacktests(luaD_reallocstack(L,L->stacksize-5-1));if(G(L)->totalbytes>=G(L)->GCthreshold)luaC_step(L);}
 581 #define luaC_barrier(L,p,v){if(valiswhite(v)&&isblack(obj2gco(p)))luaC_barrierf(L,obj2gco(p),gcvalue(v));}
 582 #define luaC_barriert(L,t,v){if(valiswhite(v)&&isblack(obj2gco(t)))luaC_barrierback(L,t);}
 583 #define luaC_objbarrier(L,p,o){if(iswhite(obj2gco(o))&&isblack(obj2gco(p)))luaC_barrierf(L,obj2gco(p),obj2gco(o));}
 584 #define luaC_objbarriert(L,t,o){if(iswhite(obj2gco(o))&&isblack(obj2gco(t)))luaC_barrierback(L,t);}
 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){
 606 int e=0;
 607 while(x>=16){
 608 x=(x+1)>>1;
 609 e++;
 610 }
 611 if(x<8)return x;
 612 else return((e+1)<<3)|(cast_int(x)-8);
 613 }
 614 static int luaO_fb2int(int x){
 615 int e=(x>>3)&31;
 616 if(e==0)return x;
 617 else return((x&7)+8)<<(e-1);
 618 }
 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
 629 };
 630 int l=-1;
 631 while(x>=256){l+=8;x>>=8;}
 632 return l+log_2[x];
 633 }
 634 static int luaO_rawequalObj(const TValue*t1,const TValue*t2){
 635 if(ttype(t1)!=ttype(t2))return 0;
 636 else switch(ttype(t1)){
 637 case 0:
 638 return 1;
 639 case 3:
 640 return luai_numeq(nvalue(t1),nvalue(t2));
 641 case 1:
 642 return bvalue(t1)==bvalue(t2);
 643 case 2:
 644 return pvalue(t1)==pvalue(t2);
 645 default:
 646 return gcvalue(t1)==gcvalue(t2);
 647 }
 648 }
 649 static int luaO_str2d(const char*s,lua_Number*result){
 650 char*endptr;
 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;
 658 return 1;
 659 }
 660 static void pushstr(lua_State*L,const char*str){
 661 setsvalue(L,L->top,luaS_new(L,str));
 662 incr_top(L);
 663 }
 664 static const char*luaO_pushvfstring(lua_State*L,const char*fmt,va_list argp){
 665 int n=1;
 666 pushstr(L,"");
 667 for(;;){
 668 const char*e=strchr(fmt,'%');
 669 if(e==NULL)break;
 670 setsvalue(L,L->top,luaS_newlstr(L,fmt,e-fmt));
 671 incr_top(L);
 672 switch(*(e+1)){
 673 case's':{
 674 const char*s=va_arg(argp,char*);
 675 if(s==NULL)s="(null)";
 676 pushstr(L,s);
 677 break;
 678 }
 679 case'c':{
 680 char buff[2];
 681 buff[0]=cast(char,va_arg(argp,int));
 682 buff[1]='\0';
 683 pushstr(L,buff);
 684 break;
 685 }
 686 case'd':{
 687 setnvalue(L->top,cast_num(va_arg(argp,int)));
 688 incr_top(L);
 689 break;
 690 }
 691 case'f':{
 692 setnvalue(L->top,cast_num(va_arg(argp,l_uacNumber)));
 693 incr_top(L);
 694 break;
 695 }
 696 case'p':{
 697 char buff[4*sizeof(void*)+8];
 698 sprintf(buff,"%p",va_arg(argp,void*));
 699 pushstr(L,buff);
 700 break;
 701 }
 702 case'%':{
 703 pushstr(L,"%");
 704 break;
 705 }
 706 default:{
 707 char buff[3];
 708 buff[0]='%';
 709 buff[1]=*(e+1);
 710 buff[2]='\0';
 711 pushstr(L,buff);
 712 break;
 713 }
 714 }
 715 n+=2;
 716 fmt=e+2;
 717 }
 718 pushstr(L,fmt);
 719 luaV_concat(L,n+1,cast_int(L->top-L->base)-1);
 720 L->top-=n;
 721 return svalue(L->top-1);
 722 }
 723 static const char*luaO_pushfstring(lua_State*L,const char*fmt,...){
 724 const char*msg;
 725 va_list argp;
 726 va_start(argp,fmt);
 727 msg=luaO_pushvfstring(L,fmt,argp);
 728 va_end(argp);
 729 return msg;
 730 }
 731 static void luaO_chunkid(char*out,const char*source,size_t bufflen){
 732 if(*source=='='){
 733 strncpy(out,source+1,bufflen);
 734 out[bufflen-1]='\0';
 735 }
 736 else{
 737 if(*source=='@'){
 738 size_t l;
 739 source++;
 740 bufflen-=sizeof(" '...' ");
 741 l=strlen(source);
 742 strcpy(out,"");
 743 if(l>bufflen){
 744 source+=(l-bufflen);
 745 strcat(out,"...");
 746 }
 747 strcat(out,source);
 748 }
 749 else{
 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);
 756 strcat(out,"...");
 757 }
 758 else
 759 strcat(out,source);
 760 strcat(out,"\"]");
 761 }
 762 }
 763 }
 764 #define gnode(t,i)(&(t)->node[i])
 765 #define gkey(n)(&(n)->i_key.nk)
 766 #define gval(n)(&(n)->i_val)
 767 #define gnext(n)((n)->i_key.nk.next)
 768 #define key2tval(n)(&(n)->i_key.tvk)
 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",
 775 "proto","upval"
 776 };
 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",
 783 "__concat","__call"
 784 };
 785 int i;
 786 for(i=0;i<TM_N;i++){
 787 G(L)->tmname[i]=luaS_new(L,luaT_eventname[i]);
 788 luaS_fix(G(L)->tmname[i]);
 789 }
 790 }
 791 static const TValue*luaT_gettm(Table*events,TMS event,TString*ename){
 792 const TValue*tm=luaH_getstr(events,ename);
 793 if(ttisnil(tm)){
 794 events->flags|=cast_byte(1u<<event);
 795 return NULL;
 796 }
 797 else return tm;
 798 }
 799 static const TValue*luaT_gettmbyobj(lua_State*L,const TValue*o,TMS event){
 800 Table*mt;
 801 switch(ttype(o)){
 802 case 5:
 803 mt=hvalue(o)->metatable;
 804 break;
 805 case 7:
 806 mt=uvalue(o)->metatable;
 807 break;
 808 default:
 809 mt=G(L)->mt[ttype(o)];
 810 }
 811 return(mt?luaH_getstr(mt,G(L)->tmname[event]):(&luaO_nilobject_));
 812 }
 813 #define sizeCclosure(n)(cast(int,sizeof(CClosure))+cast(int,sizeof(TValue)*((n)-1)))
 814 #define sizeLclosure(n)(cast(int,sizeof(LClosure))+cast(int,sizeof(TValue*)*((n)-1)))
 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);
 818 c->c.isC=1;
 819 c->c.env=e;
 820 c->c.nupvalues=cast_byte(nelems);
 821 return c;
 822 }
 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);
 826 c->l.isC=0;
 827 c->l.env=e;
 828 c->l.nupvalues=cast_byte(nelems);
 829 while(nelems--)c->l.upvals[nelems]=NULL;
 830 return c;
 831 }
 832 static UpVal*luaF_newupval(lua_State*L){
 833 UpVal*uv=luaM_new(L,UpVal);
 834 luaC_link(L,obj2gco(uv),(8+2));
 835 uv->v=&uv->u.value;
 836 setnilvalue(uv->v);
 837 return uv;
 838 }
 839 static UpVal*luaF_findupval(lua_State*L,StkId level){
 840 global_State*g=G(L);
 841 GCObject**pp=&L->openupval;
 842 UpVal*p;
 843 UpVal*uv;
 844 while(*pp!=NULL&&(p=ngcotouv(*pp))->v>=level){
 845 if(p->v==level){
 846 if(isdead(g,obj2gco(p)))
 847 changewhite(obj2gco(p));
 848 return p;
 849 }
 850 pp=&p->next;
 851 }
 852 uv=luaM_new(L,UpVal);
 853 uv->tt=(8+2);
 854 uv->marked=luaC_white(g);
 855 uv->v=level;
 856 uv->next=*pp;
 857 *pp=obj2gco(uv);
 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;
 862 return uv;
 863 }
 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;
 867 }
 868 static void luaF_freeupval(lua_State*L,UpVal*uv){
 869 if(uv->v!=&uv->u.value)
 870 unlinkupval(uv);
 871 luaM_free(L,uv);
 872 }
 873 static void luaF_close(lua_State*L,StkId level){
 874 UpVal*uv;
 875 global_State*g=G(L);
 876 while(L->openupval!=NULL&&(uv=ngcotouv(L->openupval))->v>=level){
 877 GCObject*o=obj2gco(uv);
 878 L->openupval=uv->next;
 879 if(isdead(g,o))
 880 luaF_freeupval(L,uv);
 881 else{
 882 unlinkupval(uv);
 883 setobj(L,&uv->u.value,uv->v);
 884 uv->v=&uv->u.value;
 885 luaC_linkupval(L,uv);
 886 }
 887 }
 888 }
 889 static Proto*luaF_newproto(lua_State*L){
 890 Proto*f=luaM_new(L,Proto);
 891 luaC_link(L,obj2gco(f),(8+1));
 892 f->k=NULL;
 893 f->sizek=0;
 894 f->p=NULL;
 895 f->sizep=0;
 896 f->code=NULL;
 897 f->sizecode=0;
 898 f->sizelineinfo=0;
 899 f->sizeupvalues=0;
 900 f->nups=0;
 901 f->upvalues=NULL;
 902 f->numparams=0;
 903 f->is_vararg=0;
 904 f->maxstacksize=0;
 905 f->lineinfo=NULL;
 906 f->sizelocvars=0;
 907 f->locvars=NULL;
 908 f->linedefined=0;
 909 f->lastlinedefined=0;
 910 f->source=NULL;
 911 return f;
 912 }
 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*);
 920 luaM_free(L,f);
 921 }
 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);
 926 }
 927 #define MASK1(n,p)((~((~(Instruction)0)<<n))<<p)
 928 #define MASK0(n,p)(~MASK1(n,p))
 929 #define GET_OPCODE(i)(cast(OpCode,((i)>>0)&MASK1(6,0)))
 930 #define SET_OPCODE(i,o)((i)=(((i)&MASK0(6,0))|((cast(Instruction,o)<<0)&MASK1(6,0))))
 931 #define GETARG_A(i)(cast(int,((i)>>(0+6))&MASK1(8,0)))
 932 #define SETARG_A(i,u)((i)=(((i)&MASK0(8,(0+6)))|((cast(Instruction,u)<<(0+6))&MASK1(8,(0+6)))))
 933 #define GETARG_B(i)(cast(int,((i)>>(((0+6)+8)+9))&MASK1(9,0)))
 934 #define SETARG_B(i,b)((i)=(((i)&MASK0(9,(((0+6)+8)+9)))|((cast(Instruction,b)<<(((0+6)+8)+9))&MASK1(9,(((0+6)+8)+9)))))
 935 #define GETARG_C(i)(cast(int,((i)>>((0+6)+8))&MASK1(9,0)))
 936 #define SETARG_C(i,b)((i)=(((i)&MASK0(9,((0+6)+8)))|((cast(Instruction,b)<<((0+6)+8))&MASK1(9,((0+6)+8)))))
 937 #define GETARG_Bx(i)(cast(int,((i)>>((0+6)+8))&MASK1((9+9),0)))
 938 #define SETARG_Bx(i,b)((i)=(((i)&MASK0((9+9),((0+6)+8)))|((cast(Instruction,b)<<((0+6)+8))&MASK1((9+9),((0+6)+8)))))
 939 #define GETARG_sBx(i)(GETARG_Bx(i)-(((1<<(9+9))-1)>>1))
 940 #define SETARG_sBx(i,b)SETARG_Bx((i),cast(unsigned int,(b)+(((1<<(9+9))-1)>>1)))
 941 #define CREATE_ABC(o,a,b,c)((cast(Instruction,o)<<0)|(cast(Instruction,a)<<(0+6))|(cast(Instruction,b)<<(((0+6)+8)+9))|(cast(Instruction,c)<<((0+6)+8)))
 942 #define CREATE_ABx(o,a,bc)((cast(Instruction,o)<<0)|(cast(Instruction,a)<<(0+6))|(cast(Instruction,bc)<<((0+6)+8)))
 943 #define ISK(x)((x)&(1<<(9-1)))
 944 #define INDEXK(r)((int)(r)&~(1<<(9-1)))
 945 #define RKASK(x)((x)|(1<<(9-1)))
 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{
 951 expkind k;
 952 union{
 953 struct{int info,aux;}s;
 954 lua_Number nval;
 955 }u;
 956 int t;
 957 int f;
 958 }expdesc;
 959 typedef struct upvaldesc{
 960 lu_byte k;
 961 lu_byte info;
 962 }upvaldesc;
 963 struct BlockCnt;
 964 typedef struct FuncState{
 965 Proto*f;
 966 Table*h;
 967 struct FuncState*prev;
 968 struct LexState*ls;
 969 struct lua_State*L;
 970 struct BlockCnt*bl;
 971 int pc;
 972 int lasttarget;
 973 int jpc;
 974 int freereg;
 975 int nk;
 976 int np;
 977 short nlocvars;
 978 lu_byte nactvar;
 979 upvaldesc upvalues[60];
 980 unsigned short actvar[200];
 981 }FuncState;
 982 static Proto*luaY_parser(lua_State*L,ZIO*z,Mbuffer*buff,
 983 const char*name);
 984 struct lua_longjmp{
 985 struct lua_longjmp*previous;
 986 jmp_buf b;
 987 volatile int status;
 988 };
 989 static void luaD_seterrorobj(lua_State*L,int errcode,StkId oldtop){
 990 switch(errcode){
 991 case 4:{
 992 setsvalue(L,oldtop,luaS_newliteral(L,"not enough memory"));
 993 break;
 994 }
 995 case 5:{
 996 setsvalue(L,oldtop,luaS_newliteral(L,"error in error handling"));
 997 break;
 998 }
 999 case 3:
1000 case 2:{
1001 setobj(L,oldtop,L->top-1);
1002 break;
1003 }
1004 }
1005 L->top=oldtop+1;
1006 }
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);
1010 if(inuse+1<20000)
1011 luaD_reallocCI(L,20000);
1012 }
1013 }
1014 static void resetstack(lua_State*L,int status){
1015 L->ci=L->base_ci;
1016 L->base=L->ci->base;
1017 luaF_close(L,L->base);
1018 luaD_seterrorobj(L,status,L->base);
1019 L->nCcalls=L->baseCcalls;
1020 L->allowhook=1;
1021 restore_stack_limit(L);
1022 L->errfunc=0;
1023 L->errorJmp=NULL;
1024 }
1025 static void luaD_throw(lua_State*L,int errcode){
1026 if(L->errorJmp){
1027 L->errorJmp->status=errcode;
1028 LUAI_THROW(L,L->errorJmp);
1029 }
1030 else{
1031 L->status=cast_byte(errcode);
1032 if(G(L)->panic){
1033 resetstack(L,errcode);
1034 G(L)->panic(L);
1035 }
1036 exit(EXIT_FAILURE);
1037 }
1038 }
1039 static int luaD_rawrunprotected(lua_State*L,Pfunc f,void*ud){
1040 struct lua_longjmp lj;
1041 lj.status=0;
1042 lj.previous=L->errorJmp;
1043 L->errorJmp=&lj;
1044 LUAI_TRY(L,&lj,
1045 (*f)(L,ud);
1046 );
1047 L->errorJmp=lj.previous;
1048 return lj.status;
1049 }
1050 static void correctstack(lua_State*L,TValue*oldstack){
1051 CallInfo*ci;
1052 GCObject*up;
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;
1060 }
1061 L->base=(L->base-oldstack)+L->stack;
1062 }
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);
1070 }
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);
1074 L->size_ci=newsize;
1075 L->ci=(L->ci-oldci)+L->base_ci;
1076 L->end_ci=L->base_ci+L->size_ci-1;
1077 }
1078 static void luaD_growstack(lua_State*L,int n){
1079 if(n<=L->stacksize)
1080 luaD_reallocstack(L,2*L->stacksize);
1081 else
1082 luaD_reallocstack(L,L->stacksize+n);
1083 }
1084 static CallInfo*growCI(lua_State*L){
1085 if(L->size_ci>20000)
1086 luaD_throw(L,5);
1087 else{
1088 luaD_reallocCI(L,2*L->size_ci);
1089 if(L->size_ci>20000)
1090 luaG_runerror(L,"stack overflow");
1091 }
1092 return++L->ci;
1093 }
1094 static StkId adjust_varargs(lua_State*L,Proto*p,int actual){
1095 int i;
1096 int nfixargs=p->numparams;
1097 Table*htab=NULL;
1098 StkId base,fixed;
1099 for(;actual<nfixargs;++actual)
1100 setnilvalue(L->top++);
1101 fixed=L->top-actual;
1102 base=L->top;
1103 for(i=0;i<nfixargs;i++){
1104 setobj(L,L->top++,fixed+i);
1105 setnilvalue(fixed+i);
1106 }
1107 if(htab){
1108 sethvalue(L,L->top++,htab);
1109 }
1110 return base;
1111 }
1112 static StkId tryfuncTM(lua_State*L,StkId func){
1113 const TValue*tm=luaT_gettmbyobj(L,func,TM_CALL);
1114 StkId p;
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);
1119 incr_top(L);
1120 func=restorestack(L,funcr);
1121 setobj(L,func,tm);
1122 return func;
1123 }
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){
1126 LClosure*cl;
1127 ptrdiff_t funcr;
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;
1133 if(!cl->isC){
1134 CallInfo*ci;
1135 StkId st,base;
1136 Proto*p=cl->p;
1137 luaD_checkstack(L,p->maxstacksize);
1138 func=restorestack(L,funcr);
1139 if(!p->is_vararg){
1140 base=func+1;
1141 if(L->top>base+p->numparams)
1142 L->top=base+p->numparams;
1143 }
1144 else{
1145 int nargs=cast_int(L->top-func)-1;
1146 base=adjust_varargs(L,p,nargs);
1147 func=restorestack(L,funcr);
1148 }
1149 ci=inc_ci(L);
1150 ci->func=func;
1151 L->base=ci->base=base;
1152 ci->top=L->base+p->maxstacksize;
1153 L->savedpc=p->code;
1154 ci->tailcalls=0;
1155 ci->nresults=nresults;
1156 for(st=L->top;st<ci->top;st++)
1157 setnilvalue(st);
1158 L->top=ci->top;
1159 return 0;
1160 }
1161 else{
1162 CallInfo*ci;
1163 int n;
1164 luaD_checkstack(L,20);
1165 ci=inc_ci(L);
1166 ci->func=restorestack(L,funcr);
1167 L->base=ci->base=ci->func+1;
1168 ci->top=L->top+20;
1169 ci->nresults=nresults;
1170 n=(*curr_func(L)->c.f)(L);
1171 if(n<0)
1172 return 2;
1173 else{
1174 luaD_poscall(L,L->top-n);
1175 return 1;
1176 }
1177 }
1178 }
1179 static int luaD_poscall(lua_State*L,StkId firstResult){
1180 StkId res;
1181 int wanted,i;
1182 CallInfo*ci;
1183 ci=L->ci--;
1184 res=ci->func;
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++);
1190 while(i-->0)
1191 setnilvalue(res++);
1192 L->top=res;
1193 return(wanted-(-1));
1194 }
1195 static void luaD_call(lua_State*L,StkId func,int nResults){
1196 if(++L->nCcalls>=200){
1197 if(L->nCcalls==200)
1198 luaG_runerror(L,"C stack overflow");
1199 else if(L->nCcalls>=(200+(200>>3)))
1200 luaD_throw(L,5);
1201 }
1202 if(luaD_precall(L,func,nResults)==0)
1203 luaV_execute(L,1);
1204 L->nCcalls--;
1205 luaC_checkGC(L);
1206 }
1207 static int luaD_pcall(lua_State*L,Pfunc func,void*u,
1208 ptrdiff_t old_top,ptrdiff_t ef){
1209 int status;
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;
1214 L->errfunc=ef;
1215 status=luaD_rawrunprotected(L,func,u);
1216 if(status!=0){
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);
1226 }
1227 L->errfunc=old_errfunc;
1228 return status;
1229 }
1230 struct SParser{
1231 ZIO*z;
1232 Mbuffer buff;
1233 const char*name;
1234 };
1235 static void f_parser(lua_State*L,void*ud){
1236 int i;
1237 Proto*tf;
1238 Closure*cl;
1239 struct SParser*p=cast(struct SParser*,ud);
1240 luaC_checkGC(L);
1241 tf=luaY_parser(L,p->z,
1242 &p->buff,p->name);
1243 cl=luaF_newLclosure(L,tf->nups,hvalue(gt(L)));
1244 cl->l.p=tf;
1245 for(i=0;i<tf->nups;i++)
1246 cl->l.upvals[i]=luaF_newupval(L);
1247 setclvalue(L,L->top,cl);
1248 incr_top(L);
1249 }
1250 static int luaD_protectedparser(lua_State*L,ZIO*z,const char*name){
1251 struct SParser p;
1252 int status;
1253 p.z=z;p.name=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);
1257 return status;
1258 }
1259 static void luaS_resize(lua_State*L,int newsize){
1260 GCObject**newhash;
1261 stringtable*tb;
1262 int i;
1263 if(G(L)->gcstate==2)
1264 return;
1265 newhash=luaM_newvector(L,newsize,GCObject*);
1266 tb=&G(L)->strt;
1267 for(i=0;i<newsize;i++)newhash[i]=NULL;
1268 for(i=0;i<tb->size;i++){
1269 GCObject*p=tb->hash[i];
1270 while(p){
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];
1275 newhash[h1]=p;
1276 p=next;
1277 }
1278 }
1279 luaM_freearray(L,tb->hash,tb->size,TString*);
1280 tb->size=newsize;
1281 tb->hash=newhash;
1282 }
1283 static TString*newlstr(lua_State*L,const char*str,size_t l,
1284 unsigned int h){
1285 TString*ts;
1286 stringtable*tb;
1287 if(l+1>(((size_t)(~(size_t)0)-2)-sizeof(TString))/sizeof(char))
1288 luaM_toobig(L);
1289 ts=cast(TString*,luaM_malloc(L,(l+1)*sizeof(char)+sizeof(TString)));
1290 ts->tsv.len=l;
1291 ts->tsv.hash=h;
1292 ts->tsv.marked=luaC_white(G(L));
1293 ts->tsv.tt=4;
1294 ts->tsv.reserved=0;
1295 memcpy(ts+1,str,l*sizeof(char));
1296 ((char*)(ts+1))[l]='\0';
1297 tb=&G(L)->strt;
1298 h=lmod(h,tb->size);
1299 ts->tsv.next=tb->hash[h];
1300 tb->hash[h]=obj2gco(ts);
1301 tb->nuse++;
1302 if(tb->nuse>cast(lu_int32,tb->size)&&tb->size<=(INT_MAX-2)/2)
1303 luaS_resize(L,tb->size*2);
1304 return ts;
1305 }
1306 static TString*luaS_newlstr(lua_State*L,const char*str,size_t l){
1307 GCObject*o;
1308 unsigned int h=cast(unsigned int,l);
1309 size_t step=(l>>5)+1;
1310 size_t l1;
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)];
1314 o!=NULL;
1315 o=o->gch.next){
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);
1319 return ts;
1320 }
1321 }
1322 return newlstr(L,str,l,h);
1323 }
1324 static Udata*luaS_newudata(lua_State*L,size_t s,Table*e){
1325 Udata*u;
1326 if(s>((size_t)(~(size_t)0)-2)-sizeof(Udata))
1327 luaM_toobig(L);
1328 u=cast(Udata*,luaM_malloc(L,s+sizeof(Udata)));
1329 u->uv.marked=luaC_white(G(L));
1330 u->uv.tt=7;
1331 u->uv.len=s;
1332 u->uv.metatable=NULL;
1333 u->uv.env=e;
1334 u->uv.next=G(L)->mainthread->next;
1335 G(L)->mainthread->next=obj2gco(u);
1336 return u;
1337 }
1338 #define hashpow2(t,n)(gnode(t,lmod((n),sizenode(t))))
1339 #define hashstr(t,str)hashpow2(t,(str)->tsv.hash)
1340 #define hashboolean(t,p)hashpow2(t,p)
1341 #define hashmod(t,n)(gnode(t,((n)%((sizenode(t)-1)|1))))
1342 #define hashpointer(t,p)hashmod(t,IntPoint(p))
1343 static const Node dummynode_={
1344 {{NULL},0},
1345 {{{NULL},0,NULL}}
1346 };
1347 static Node*hashnum(const Table*t,lua_Number n){
1348 unsigned int a[cast_int(sizeof(lua_Number)/sizeof(int))];
1349 int i;
1350 if(luai_numeq(n,0))
1351 return gnode(t,0);
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]);
1355 }
1356 static Node*mainposition(const Table*t,const TValue*key){
1357 switch(ttype(key)){
1358 case 3:
1359 return hashnum(t,nvalue(key));
1360 case 4:
1361 return hashstr(t,rawtsvalue(key));
1362 case 1:
1363 return hashboolean(t,bvalue(key));
1364 case 2:
1365 return hashpointer(t,pvalue(key));
1366 default:
1367 return hashpointer(t,gcvalue(key));
1368 }
1369 }
1370 static int arrayindex(const TValue*key){
1371 if(ttisnumber(key)){
1372 lua_Number n=nvalue(key);
1373 int k;
1374 lua_number2int(k,n);
1375 if(luai_numeq(cast_num(k),n))
1376 return k;
1377 }
1378 return-1;
1379 }
1380 static int findindex(lua_State*L,Table*t,StkId key){
1381 int i;
1382 if(ttisnil(key))return-1;
1383 i=arrayindex(key);
1384 if(0<i&&i<=t->sizearray)
1385 return i-1;
1386 else{
1387 Node*n=mainposition(t,key);
1388 do{
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;
1394 }
1395 else n=gnext(n);
1396 }while(n);
1397 luaG_runerror(L,"invalid key to "LUA_QL("next"));
1398 return 0;
1399 }
1400 }
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]);
1407 return 1;
1408 }
1409 }
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)));
1414 return 1;
1415 }
1416 }
1417 return 0;
1418 }
1419 static int computesizes(int nums[],int*narray){
1420 int i;
1421 int twotoi;
1422 int a=0;
1423 int na=0;
1424 int n=0;
1425 for(i=0,twotoi=1;twotoi/2<*narray;i++,twotoi*=2){
1426 if(nums[i]>0){
1427 a+=nums[i];
1428 if(a>twotoi/2){
1429 n=twotoi;
1430 na=a;
1431 }
1432 }
1433 if(a==*narray)break;
1434 }
1435 *narray=n;
1436 return na;
1437 }
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)]++;
1442 return 1;
1443 }
1444 else
1445 return 0;
1446 }
1447 static int numusearray(const Table*t,int*nums){
1448 int lg;
1449 int ttlg;
1450 int ause=0;
1451 int i=1;
1452 for(lg=0,ttlg=1;lg<=(32-2);lg++,ttlg*=2){
1453 int lc=0;
1454 int lim=ttlg;
1455 if(lim>t->sizearray){
1456 lim=t->sizearray;
1457 if(i>lim)
1458 break;
1459 }
1460 for(;i<=lim;i++){
1461 if(!ttisnil(&t->array[i-1]))
1462 lc++;
1463 }
1464 nums[lg]+=lc;
1465 ause+=lc;
1466 }
1467 return ause;
1468 }
1469 static int numusehash(const Table*t,int*nums,int*pnasize){
1470 int totaluse=0;
1471 int ause=0;
1472 int i=sizenode(t);
1473 while(i--){
1474 Node*n=&t->node[i];
1475 if(!ttisnil(gval(n))){
1476 ause+=countint(key2tval(n),nums);
1477 totaluse++;
1478 }
1479 }
1480 *pnasize+=ause;
1481 return totaluse;
1482 }
1483 static void setarrayvector(lua_State*L,Table*t,int size){
1484 int i;
1485 luaM_reallocvector(L,t->array,t->sizearray,size,TValue);
1486 for(i=t->sizearray;i<size;i++)
1487 setnilvalue(&t->array[i]);
1488 t->sizearray=size;
1489 }
1490 static void setnodevector(lua_State*L,Table*t,int size){
1491 int lsize;
1492 if(size==0){
1493 t->node=cast(Node*,(&dummynode_));
1494 lsize=0;
1495 }
1496 else{
1497 int i;
1498 lsize=ceillog2(size);
1499 if(lsize>(32-2))
1500 luaG_runerror(L,"table overflow");
1501 size=twoto(lsize);
1502 t->node=luaM_newvector(L,size,Node);
1503 for(i=0;i<size;i++){
1504 Node*n=gnode(t,i);
1505 gnext(n)=NULL;
1506 setnilvalue(gkey(n));
1507 setnilvalue(gval(n));
1508 }
1509 }
1510 t->lsizenode=cast_byte(lsize);
1511 t->lastfree=gnode(t,size);
1512 }
1513 static void resize(lua_State*L,Table*t,int nasize,int nhsize){
1514 int i;
1515 int oldasize=t->sizearray;
1516 int oldhsize=t->lsizenode;
1517 Node*nold=t->node;
1518 if(nasize>oldasize)
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]);
1526 }
1527 luaM_reallocvector(L,t->array,oldasize,nasize,TValue);
1528 }
1529 for(i=twoto(oldhsize)-1;i>=0;i--){
1530 Node*old=nold+i;
1531 if(!ttisnil(gval(old)))
1532 setobj(L,luaH_set(L,t,key2tval(old)),gval(old));
1533 }
1534 if(nold!=(&dummynode_))
1535 luaM_freearray(L,nold,twoto(oldhsize),Node);
1536 }
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);
1540 }
1541 static void rehash(lua_State*L,Table*t,const TValue*ek){
1542 int nasize,na;
1543 int nums[(32-2)+1];
1544 int i;
1545 int totaluse;
1546 for(i=0;i<=(32-2);i++)nums[i]=0;
1547 nasize=numusearray(t,nums);
1548 totaluse=nasize;
1549 totaluse+=numusehash(t,nums,&nasize);
1550 nasize+=countint(ek,nums);
1551 totaluse++;
1552 na=computesizes(nums,&nasize);
1553 resize(L,t,nasize,totaluse-na);
1554 }
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);
1558 t->metatable=NULL;
1559 t->flags=cast_byte(~0);
1560 t->array=NULL;
1561 t->sizearray=0;
1562 t->lsizenode=0;
1563 t->node=cast(Node*,(&dummynode_));
1564 setarrayvector(L,t,narray);
1565 setnodevector(L,t,nhash);
1566 return t;
1567 }
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);
1572 luaM_free(L,t);
1573 }
1574 static Node*getfreepos(Table*t){
1575 while(t->lastfree-->t->node){
1576 if(ttisnil(gkey(t->lastfree)))
1577 return t->lastfree;
1578 }
1579 return NULL;
1580 }
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_)){
1584 Node*othern;
1585 Node*n=getfreepos(t);
1586 if(n==NULL){
1587 rehash(L,t,key);
1588 return luaH_set(L,t,key);
1589 }
1590 othern=mainposition(t,key2tval(mp));
1591 if(othern!=mp){
1592 while(gnext(othern)!=mp)othern=gnext(othern);
1593 gnext(othern)=n;
1594 *n=*mp;
1595 gnext(mp)=NULL;
1596 setnilvalue(gval(mp));
1597 }
1598 else{
1599 gnext(n)=gnext(mp);
1600 gnext(mp)=n;
1601 mp=n;
1602 }
1603 }
1604 gkey(mp)->value=key->value;gkey(mp)->tt=key->tt;
1605 luaC_barriert(L,t,key);
1606 return gval(mp);
1607 }
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];
1611 else{
1612 lua_Number nk=cast_num(key);
1613 Node*n=hashnum(t,nk);
1614 do{
1615 if(ttisnumber(gkey(n))&&luai_numeq(nvalue(gkey(n)),nk))
1616 return gval(n);
1617 else n=gnext(n);
1618 }while(n);
1619 return(&luaO_nilobject_);
1620 }
1621 }
1622 static const TValue*luaH_getstr(Table*t,TString*key){
1623 Node*n=hashstr(t,key);
1624 do{
1625 if(ttisstring(gkey(n))&&rawtsvalue(gkey(n))==key)
1626 return gval(n);
1627 else n=gnext(n);
1628 }while(n);
1629 return(&luaO_nilobject_);
1630 }
1631 static const TValue*luaH_get(Table*t,const TValue*key){
1632 switch(ttype(key)){
1633 case 0:return(&luaO_nilobject_);
1634 case 4:return luaH_getstr(t,rawtsvalue(key));
1635 case 3:{
1636 int k;
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);
1641 }
1642 default:{
1643 Node*n=mainposition(t,key);
1644 do{
1645 if(luaO_rawequalObj(key2tval(n),key))
1646 return gval(n);
1647 else n=gnext(n);
1648 }while(n);
1649 return(&luaO_nilobject_);
1650 }
1651 }
1652 }
1653 static TValue*luaH_set(lua_State*L,Table*t,const TValue*key){
1654 const TValue*p=luaH_get(t,key);
1655 t->flags=0;
1656 if(p!=(&luaO_nilobject_))
1657 return cast(TValue*,p);
1658 else{
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);
1663 }
1664 }
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);
1669 else{
1670 TValue k;
1671 setnvalue(&k,cast_num(key));
1672 return newkey(L,t,&k);
1673 }
1674 }
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);
1679 else{
1680 TValue k;
1681 setsvalue(L,&k,key);
1682 return newkey(L,t,&k);
1683 }
1684 }
1685 static int unbound_search(Table*t,unsigned int j){
1686 unsigned int i=j;
1687 j++;
1688 while(!ttisnil(luaH_getnum(t,j))){
1689 i=j;
1690 j*=2;
1691 if(j>cast(unsigned int,(INT_MAX-2))){
1692 i=1;
1693 while(!ttisnil(luaH_getnum(t,i)))i++;
1694 return i-1;
1695 }
1696 }
1697 while(j-i>1){
1698 unsigned int m=(i+j)/2;
1699 if(ttisnil(luaH_getnum(t,m)))j=m;
1700 else i=m;
1701 }
1702 return i;
1703 }
1704 static int luaH_getn(Table*t){
1705 unsigned int j=t->sizearray;
1706 if(j>0&&ttisnil(&t->array[j-1])){
1707 unsigned int i=0;
1708 while(j-i>1){
1709 unsigned int m=(i+j)/2;
1710 if(ttisnil(&t->array[m-1]))j=m;
1711 else i=m;
1712 }
1713 return i;
1714 }
1715 else if(t->node==(&dummynode_))
1716 return j;
1717 else return unbound_search(t,j);
1718 }
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));
1731 }
1732 static void reallymarkobject(global_State*g,GCObject*o){
1733 white2gray(o);
1734 switch(o->gch.tt){
1735 case 4:{
1736 return;
1737 }
1738 case 7:{
1739 Table*mt=gco2u(o)->metatable;
1740 gray2black(o);
1741 if(mt)markobject(g,mt);
1742 markobject(g,gco2u(o)->env);
1743 return;
1744 }
1745 case(8+2):{
1746 UpVal*uv=gco2uv(o);
1747 markvalue(g,uv->v);
1748 if(uv->v==&uv->u.value)
1749 gray2black(o);
1750 return;
1751 }
1752 case 6:{
1753 gco2cl(o)->c.gclist=g->gray;
1754 g->gray=o;
1755 break;
1756 }
1757 case 5:{
1758 gco2h(o)->gclist=g->gray;
1759 g->gray=o;
1760 break;
1761 }
1762 case 8:{
1763 gco2th(o)->gclist=g->gray;
1764 g->gray=o;
1765 break;
1766 }
1767 case(8+1):{
1768 gco2p(o)->gclist=g->gray;
1769 g->gray=o;
1770 break;
1771 }
1772 default:;
1773 }
1774 }
1775 static void marktmu(global_State*g){
1776 GCObject*u=g->tmudata;
1777 if(u){
1778 do{
1779 u=u->gch.next;
1780 makewhite(g,u);
1781 reallymarkobject(g,u);
1782 }while(u!=g->tmudata);
1783 }
1784 }
1785 static size_t luaC_separateudata(lua_State*L,int all){
1786 global_State*g=G(L);
1787 size_t deadmem=0;
1788 GCObject**p=&g->mainthread->next;
1789 GCObject*curr;
1790 while((curr=*p)!=NULL){
1791 if(!(iswhite(curr)||all)||isfinalized(gco2u(curr)))
1792 p=&curr->gch.next;
1793 else if(fasttm(L,gco2u(curr)->metatable,TM_GC)==NULL){
1794 markfinalized(gco2u(curr));
1795 p=&curr->gch.next;
1796 }
1797 else{
1798 deadmem+=sizeudata(gco2u(curr));
1799 markfinalized(gco2u(curr));
1800 *p=curr->gch.next;
1801 if(g->tmudata==NULL)
1802 g->tmudata=curr->gch.next=curr;
1803 else{
1804 curr->gch.next=g->tmudata->gch.next;
1805 g->tmudata->gch.next=curr;
1806 g->tmudata=curr;
1807 }
1808 }
1809 }
1810 return deadmem;
1811 }
1812 static int traversetable(global_State*g,Table*h){
1813 int i;
1814 int weakkey=0;
1815 int weakvalue=0;
1816 const TValue*mode;
1817 if(h->metatable)
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)|
1826 (weakvalue<<4));
1827 h->gclist=g->weak;
1828 g->weak=obj2gco(h);
1829 }
1830 }
1831 if(weakkey&&weakvalue)return 1;
1832 if(!weakvalue){
1833 i=h->sizearray;
1834 while(i--)
1835 markvalue(g,&h->array[i]);
1836 }
1837 i=sizenode(h);
1838 while(i--){
1839 Node*n=gnode(h,i);
1840 if(ttisnil(gval(n)))
1841 removeentry(n);
1842 else{
1843 if(!weakkey)markvalue(g,gkey(n));
1844 if(!weakvalue)markvalue(g,gval(n));
1845 }
1846 }
1847 return weakkey||weakvalue;
1848 }
1849 static void traverseproto(global_State*g,Proto*f){
1850 int i;
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++){
1855 if(f->upvalues[i])
1856 stringmark(f->upvalues[i]);
1857 }
1858 for(i=0;i<f->sizep;i++){
1859 if(f->p[i])
1860 markobject(g,f->p[i]);
1861 }
1862 for(i=0;i<f->sizelocvars;i++){
1863 if(f->locvars[i].varname)
1864 stringmark(f->locvars[i].varname);
1865 }
1866 }
1867 static void traverseclosure(global_State*g,Closure*cl){
1868 markobject(g,cl->c.env);
1869 if(cl->c.isC){
1870 int i;
1871 for(i=0;i<cl->c.nupvalues;i++)
1872 markvalue(g,&cl->c.upvalue[i]);
1873 }
1874 else{
1875 int i;
1876 markobject(g,cl->l.p);
1877 for(i=0;i<cl->l.nupvalues;i++)
1878 markobject(g,cl->l.upvals[i]);
1879 }
1880 }
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)
1885 return;
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));
1893 }
1894 static void traversestack(global_State*g,lua_State*l){
1895 StkId o,lim;
1896 CallInfo*ci;
1897 markvalue(g,gt(l));
1898 lim=l->top;
1899 for(ci=l->base_ci;ci<=l->ci;ci++){
1900 if(lim<ci->top)lim=ci->top;
1901 }
1902 for(o=l->stack;o<l->top;o++)
1903 markvalue(g,o);
1904 for(;o<=lim;o++)
1905 setnilvalue(o);
1906 checkstacksizes(l,lim);
1907 }
1908 static l_mem propagatemark(global_State*g){
1909 GCObject*o=g->gray;
1910 gray2black(o);
1911 switch(o->gch.tt){
1912 case 5:{
1913 Table*h=gco2h(o);
1914 g->gray=h->gclist;
1915 if(traversetable(g,h))
1916 black2gray(o);
1917 return sizeof(Table)+sizeof(TValue)*h->sizearray+
1918 sizeof(Node)*sizenode(h);
1919 }
1920 case 6:{
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);
1926 }
1927 case 8:{
1928 lua_State*th=gco2th(o);
1929 g->gray=th->gclist;
1930 th->gclist=g->grayagain;
1931 g->grayagain=o;
1932 black2gray(o);
1933 traversestack(g,th);
1934 return sizeof(lua_State)+sizeof(TValue)*th->stacksize+
1935 sizeof(CallInfo)*th->size_ci;
1936 }
1937 case(8+1):{
1938 Proto*p=gco2p(o);
1939 g->gray=p->gclist;
1940 traverseproto(g,p);
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;
1947 }
1948 default:return 0;
1949 }
1950 }
1951 static size_t propagateall(global_State*g){
1952 size_t m=0;
1953 while(g->gray)m+=propagatemark(g);
1954 return m;
1955 }
1956 static int iscleared(const TValue*o,int iskey){
1957 if(!iscollectable(o))return 0;
1958 if(ttisstring(o)){
1959 stringmark(rawtsvalue(o));
1960 return 0;
1961 }
1962 return iswhite(gcvalue(o))||
1963 (ttisuserdata(o)&&(!iskey&&isfinalized(uvalue(o))));
1964 }
1965 static void cleartable(GCObject*l){
1966 while(l){
1967 Table*h=gco2h(l);
1968 int i=h->sizearray;
1969 if(testbit(h->marked,4)){
1970 while(i--){
1971 TValue*o=&h->array[i];
1972 if(iscleared(o,0))
1973 setnilvalue(o);
1974 }
1975 }
1976 i=sizenode(h);
1977 while(i--){
1978 Node*n=gnode(h,i);
1979 if(!ttisnil(gval(n))&&
1980 (iscleared(key2tval(n),1)||iscleared(gval(n),0))){
1981 setnilvalue(gval(n));
1982 removeentry(n);
1983 }
1984 }
1985 l=h->gclist;
1986 }
1987 }
1988 static void freeobj(lua_State*L,GCObject*o){
1989 switch(o->gch.tt){
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;
1994 case 8:{
1995 luaE_freethread(L,gco2th(o));
1996 break;
1997 }
1998 case 4:{
1999 G(L)->strt.nuse--;
2000 luaM_freemem(L,o,sizestring(gco2ts(o)));
2001 break;
2002 }
2003 case 7:{
2004 luaM_freemem(L,o,sizeudata(gco2u(o)));
2005 break;
2006 }
2007 default:;
2008 }
2009 }
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){
2012 GCObject*curr;
2013 global_State*g=G(L);
2014 int deadmask=otherwhite(g);
2015 while((curr=*p)!=NULL&&count-->0){
2016 if(curr->gch.tt==8)
2017 sweepwholelist(L,&gco2th(curr)->openupval);
2018 if((curr->gch.marked^bit2mask(0,1))&deadmask){
2019 makewhite(g,curr);
2020 p=&curr->gch.next;
2021 }
2022 else{
2023 *p=curr->gch.next;
2024 if(curr==g->rootgc)
2025 g->rootgc=curr->gch.next;
2026 freeobj(L,curr);
2027 }
2028 }
2029 return p;
2030 }
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)&&
2034 g->strt.size>32*2)
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);
2039 }
2040 }
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);
2045 const TValue*tm;
2046 if(o==g->tmudata)
2047 g->tmudata=NULL;
2048 else
2049 g->tmudata->gch.next=udata->uv.next;
2050 udata->uv.next=g->mainthread->next;
2051 g->mainthread->next=o;
2052 makewhite(g,o);
2053 tm=fasttm(L,udata->uv.metatable,TM_GC);
2054 if(tm!=NULL){
2055 lu_byte oldah=L->allowhook;
2056 lu_mem oldt=g->GCthreshold;
2057 L->allowhook=0;
2058 g->GCthreshold=2*g->totalbytes;
2059 setobj(L,L->top,tm);
2060 setuvalue(L,L->top+1,udata);
2061 L->top+=2;
2062 luaD_call(L,L->top-2,0);
2063 L->allowhook=oldah;
2064 g->GCthreshold=oldt;
2065 }
2066 }
2067 static void luaC_callGCTM(lua_State*L){
2068 while(G(L)->tmudata)
2069 GCTM(L);
2070 }
2071 static void luaC_freeall(lua_State*L){
2072 global_State*g=G(L);
2073 int i;
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]);
2078 }
2079 static void markmt(global_State*g){
2080 int i;
2081 for(i=0;i<(8+1);i++)
2082 if(g->mt[i])markobject(g,g->mt[i]);
2083 }
2084 static void markroot(lua_State*L){
2085 global_State*g=G(L);
2086 g->gray=NULL;
2087 g->grayagain=NULL;
2088 g->weak=NULL;
2089 markobject(g,g->mainthread);
2090 markvalue(g,gt(g->mainthread));
2091 markvalue(g,registry(L));
2092 markmt(g);
2093 g->gcstate=1;
2094 }
2095 static void remarkupvals(global_State*g){
2096 UpVal*uv;
2097 for(uv=g->uvhead.u.l.next;uv!=&g->uvhead;uv=uv->u.l.next){
2098 if(isgray(obj2gco(uv)))
2099 markvalue(g,uv->v);
2100 }
2101 }
2102 static void atomic(lua_State*L){
2103 global_State*g=G(L);
2104 size_t udsize;
2105 remarkupvals(g);
2106 propagateall(g);
2107 g->gray=g->weak;
2108 g->weak=NULL;
2109 markobject(g,L);
2110 markmt(g);
2111 propagateall(g);
2112 g->gray=g->grayagain;
2113 g->grayagain=NULL;
2114 propagateall(g);
2115 udsize=luaC_separateudata(L,0);
2116 marktmu(g);
2117 udsize+=propagateall(g);
2118 cleartable(g->weak);
2119 g->currentwhite=cast_byte(otherwhite(g));
2120 g->sweepstrgc=0;
2121 g->sweepgc=&g->rootgc;
2122 g->gcstate=2;
2123 g->estimate=g->totalbytes-udsize;
2124 }
2125 static l_mem singlestep(lua_State*L){
2126 global_State*g=G(L);
2127 switch(g->gcstate){
2128 case 0:{
2129 markroot(L);
2130 return 0;
2131 }
2132 case 1:{
2133 if(g->gray)
2134 return propagatemark(g);
2135 else{
2136 atomic(L);
2137 return 0;
2138 }
2139 }
2140 case 2:{
2141 lu_mem old=g->totalbytes;
2142 sweepwholelist(L,&g->strt.hash[g->sweepstrgc++]);
2143 if(g->sweepstrgc>=g->strt.size)
2144 g->gcstate=3;
2145 g->estimate-=old-g->totalbytes;
2146 return 10;
2147 }
2148 case 3:{
2149 lu_mem old=g->totalbytes;
2150 g->sweepgc=sweeplist(L,g->sweepgc,40);
2151 if(*g->sweepgc==NULL){
2152 checkSizes(L);
2153 g->gcstate=4;
2154 }
2155 g->estimate-=old-g->totalbytes;
2156 return 40*10;
2157 }
2158 case 4:{
2159 if(g->tmudata){
2160 GCTM(L);
2161 if(g->estimate>100)
2162 g->estimate-=100;
2163 return 100;
2164 }
2165 else{
2166 g->gcstate=0;
2167 g->gcdept=0;
2168 return 0;
2169 }
2170 }
2171 default:return 0;
2172 }
2173 }
2174 static void luaC_step(lua_State*L){
2175 global_State*g=G(L);
2176 l_mem lim=(1024u/100)*g->gcstepmul;
2177 if(lim==0)
2178 lim=(((lu_mem)(~(lu_mem)0)-2)-1)/2;
2179 g->gcdept+=g->totalbytes-g->GCthreshold;
2180 do{
2181 lim-=singlestep(L);
2182 if(g->gcstate==0)
2183 break;
2184 }while(lim>0);
2185 if(g->gcstate!=0){
2186 if(g->gcdept<1024u)
2187 g->GCthreshold=g->totalbytes+1024u;
2188 else{
2189 g->gcdept-=1024u;
2190 g->GCthreshold=g->totalbytes;
2191 }
2192 }
2193 else{
2194 setthreshold(g);
2195 }
2196 }
2197 static void luaC_barrierf(lua_State*L,GCObject*o,GCObject*v){
2198 global_State*g=G(L);
2199 if(g->gcstate==1)
2200 reallymarkobject(g,v);
2201 else
2202 makewhite(g,o);
2203 }
2204 static void luaC_barrierback(lua_State*L,Table*t){
2205 global_State*g=G(L);
2206 GCObject*o=obj2gco(t);
2207 black2gray(o);
2208 t->gclist=g->grayagain;
2209 g->grayagain=o;
2210 }
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;
2214 g->rootgc=o;
2215 o->gch.marked=luaC_white(g);
2216 o->gch.tt=tt;
2217 }
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;
2222 g->rootgc=o;
2223 if(isgray(o)){
2224 if(g->gcstate==1){
2225 gray2black(o);
2226 luaC_barrier(L,uv,uv->v);
2227 }
2228 else{
2229 makewhite(g,o);
2230 }
2231 }
2232 }
2233 typedef union{
2234 lua_Number r;
2235 TString*ts;
2236 }SemInfo;
2237 typedef struct Token{
2238 int token;
2239 SemInfo seminfo;
2240 }Token;
2241 typedef struct LexState{
2242 int current;
2243 int linenumber;
2244 int lastline;
2245 Token t;
2246 Token lookahead;
2247 struct FuncState*fs;
2248 struct lua_State*L;
2249 ZIO*z;
2250 Mbuffer*buff;
2251 TString*source;
2252 char decpoint;
2253 }LexState;
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))
2259 typedef struct LG{
2260 lua_State l;
2261 global_State g;
2262 }LG;
2263 static void stack_init(lua_State*L1,lua_State*L){
2264 L1->base_ci=luaM_newvector(L,8,CallInfo);
2265 L1->ci=L1->base_ci;
2266 L1->size_ci=8;
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;
2270 L1->top=L1->stack;
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;
2276 }
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);
2280 }
2281 static void f_luaopen(lua_State*L,void*ud){
2282 global_State*g=G(L);
2283 UNUSED(ud);
2284 stack_init(L,L);
2285 sethvalue(L,gt(L),luaH_new(L,0,2));
2286 sethvalue(L,registry(L),luaH_new(L,0,2));
2287 luaS_resize(L,32);
2288 luaT_init(L);
2289 luaX_init(L);
2290 luaS_fix(luaS_newliteral(L,"not enough memory"));
2291 g->GCthreshold=4*g->totalbytes;
2292 }
2293 static void preinit_state(lua_State*L,global_State*g){
2294 G(L)=g;
2295 L->stack=NULL;
2296 L->stacksize=0;
2297 L->errorJmp=NULL;
2298 L->hook=NULL;
2299 L->hookmask=0;
2300 L->basehookcount=0;
2301 L->allowhook=1;
2302 resethookcount(L);
2303 L->openupval=NULL;
2304 L->size_ci=0;
2305 L->nCcalls=L->baseCcalls=0;
2306 L->status=0;
2307 L->base_ci=L->ci=NULL;
2308 L->savedpc=NULL;
2309 L->errfunc=0;
2310 setnilvalue(gt(L));
2311 }
2312 static void close_state(lua_State*L){
2313 global_State*g=G(L);
2314 luaF_close(L,L->stack);
2315 luaC_freeall(L);
2316 luaM_freearray(L,G(L)->strt.hash,G(L)->strt.size,TString*);
2317 luaZ_freebuffer(L,&g->buff);
2318 freestack(L,L);
2319 (*g->frealloc)(g->ud,fromstate(L),state_size(LG),0);
2320 }
2321 static void luaE_freethread(lua_State*L,lua_State*L1){
2322 luaF_close(L1,L1->stack);
2323 freestack(L,L1);
2324 luaM_freemem(L,fromstate(L1),state_size(lua_State));
2325 }
2326 static lua_State*lua_newstate(lua_Alloc f,void*ud){
2327 int i;
2328 lua_State*L;
2329 global_State*g;
2330 void*l=(*f)(ud,NULL,0,state_size(LG));
2331 if(l==NULL)return NULL;
2332 L=tostate(l);
2333 g=&((LG*)L)->g;
2334 L->next=NULL;
2335 L->tt=8;
2336 g->currentwhite=bit2mask(0,5);
2337 L->marked=luaC_white(g);
2338 set2bits(L->marked,5,6);
2339 preinit_state(L,g);
2340 g->frealloc=f;
2341 g->ud=ud;
2342 g->mainthread=L;
2343 g->uvhead.u.l.prev=&g->uvhead;
2344 g->uvhead.u.l.next=&g->uvhead;
2345 g->GCthreshold=0;
2346 g->strt.size=0;
2347 g->strt.nuse=0;
2348 g->strt.hash=NULL;
2349 setnilvalue(registry(L));
2350 luaZ_initbuffer(L,&g->buff);
2351 g->panic=NULL;
2352 g->gcstate=0;
2353 g->rootgc=obj2gco(L);
2354 g->sweepstrgc=0;
2355 g->sweepgc=&g->rootgc;
2356 g->gray=NULL;
2357 g->grayagain=NULL;
2358 g->weak=NULL;
2359 g->tmudata=NULL;
2360 g->totalbytes=sizeof(LG);
2361 g->gcpause=200;
2362 g->gcstepmul=200;
2363 g->gcdept=0;
2364 for(i=0;i<(8+1);i++)g->mt[i]=NULL;
2365 if(luaD_rawrunprotected(L,f_luaopen,NULL)!=0){
2366 close_state(L);
2367 L=NULL;
2368 }
2369 else
2370 {}
2371 return L;
2372 }
2373 static void callallgcTM(lua_State*L,void*ud){
2374 UNUSED(ud);
2375 luaC_callGCTM(L);
2376 }
2377 static void lua_close(lua_State*L){
2378 L=G(L)->mainthread;
2379 luaF_close(L,L->stack);
2380 luaC_separateudata(L,1);
2381 L->errfunc=0;
2382 do{
2383 L->ci=L->base_ci;
2384 L->base=L->top=L->ci->base;
2385 L->nCcalls=L->baseCcalls=0;
2386 }while(luaD_rawrunprotected(L,callallgcTM,NULL)!=0);
2387 close_state(L);
2388 }
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;
2399 if(ci==L->ci)
2400 ci->savedpc=L->savedpc;
2401 return pcRel(ci->savedpc,ci_func(ci)->l.p);
2402 }
2403 static int currentline(lua_State*L,CallInfo*ci){
2404 int pc=currentpc(L,ci);
2405 if(pc<0)
2406 return-1;
2407 else
2408 return getline_(ci_func(ci)->l.p,pc);
2409 }
2410 static int lua_getstack(lua_State*L,int level,lua_Debug*ar){
2411 int status;
2412 CallInfo*ci;
2413 for(ci=L->ci;level>0&&ci>L->base_ci;ci--){
2414 level--;
2415 if(f_isLua(ci))
2416 level-=ci->tailcalls;
2417 }
2418 if(level==0&&ci>L->base_ci){
2419 status=1;
2420 ar->i_ci=cast_int(ci-L->base_ci);
2421 }
2422 else if(level<0){
2423 status=1;
2424 ar->i_ci=0;
2425 }
2426 else status=0;
2427 return status;
2428 }
2429 static Proto*getluaproto(CallInfo*ci){
2430 return(isLua(ci)?ci_func(ci)->l.p:NULL);
2431 }
2432 static void funcinfo(lua_Debug*ar,Closure*cl){
2433 if(cl->c.isC){
2434 ar->source="=[C]";
2435 ar->linedefined=-1;
2436 ar->lastlinedefined=-1;
2437 ar->what="C";
2438 }
2439 else{
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";
2444 }
2445 luaO_chunkid(ar->short_src,ar->source,60);
2446 }
2447 static void info_tailcall(lua_Debug*ar){
2448 ar->name=ar->namewhat="";
2449 ar->what="tail";
2450 ar->lastlinedefined=ar->linedefined=ar->currentline=-1;
2451 ar->source="=(tail call)";
2452 luaO_chunkid(ar->short_src,ar->source,60);
2453 ar->nups=0;
2454 }
2455 static void collectvalidlines(lua_State*L,Closure*f){
2456 if(f==NULL||f->c.isC){
2457 setnilvalue(L->top);
2458 }
2459 else{
2460 Table*t=luaH_new(L,0,0);
2461 int*lineinfo=f->l.p->lineinfo;
2462 int i;
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);
2466 }
2467 incr_top(L);
2468 }
2469 static int auxgetinfo(lua_State*L,const char*what,lua_Debug*ar,
2470 Closure*f,CallInfo*ci){
2471 int status=1;
2472 if(f==NULL){
2473 info_tailcall(ar);
2474 return status;
2475 }
2476 for(;*what;what++){
2477 switch(*what){
2478 case'S':{
2479 funcinfo(ar,f);
2480 break;
2481 }
2482 case'l':{
2483 ar->currentline=(ci)?currentline(L,ci):-1;
2484 break;
2485 }
2486 case'u':{
2487 ar->nups=f->c.nupvalues;
2488 break;
2489 }
2490 case'n':{
2491 ar->namewhat=(ci)?NULL:NULL;
2492 if(ar->namewhat==NULL){
2493 ar->namewhat="";
2494 ar->name=NULL;
2495 }
2496 break;
2497 }
2498 case'L':
2499 case'f':
2500 break;
2501 default:status=0;
2502 }
2503 }
2504 return status;
2505 }
2506 static int lua_getinfo(lua_State*L,const char*what,lua_Debug*ar){
2507 int status;
2508 Closure*f=NULL;
2509 CallInfo*ci=NULL;
2510 if(*what=='>'){
2511 StkId func=L->top-1;
2512 luai_apicheck(L,ttisfunction(func));
2513 what++;
2514 f=clvalue(func);
2515 L->top--;
2516 }
2517 else if(ar->i_ci!=0){
2518 ci=L->base_ci+ar->i_ci;
2519 f=clvalue(ci->func);
2520 }
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);
2525 incr_top(L);
2526 }
2527 if(strchr(what,'L'))
2528 collectvalidlines(L,f);
2529 return status;
2530 }
2531 static int isinstack(CallInfo*ci,const TValue*o){
2532 StkId p;
2533 for(p=ci->base;p<ci->top;p++)
2534 if(o==p)return 1;
2535 return 0;
2536 }
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))?
2541 NULL:
2542 NULL;
2543 if(kind)
2544 luaG_runerror(L,"attempt to %s %s "LUA_QL("%s")" (a %s value)",
2545 op,kind,name,t);
2546 else
2547 luaG_runerror(L,"attempt to %s a %s value",op,t);
2548 }
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");
2552 }
2553 static void luaG_aritherror(lua_State*L,const TValue*p1,const TValue*p2){
2554 TValue temp;
2555 if(luaV_tonumber(p1,&temp)==NULL)
2556 p2=p1;
2557 luaG_typeerror(L,p2,"perform arithmetic on");
2558 }
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)];
2562 if(t1[2]==t2[2])
2563 luaG_runerror(L,"attempt to compare two %s values",t1);
2564 else
2565 luaG_runerror(L,"attempt to compare %s with %s",t1,t2);
2566 return 0;
2567 }
2568 static void addinfo(lua_State*L,const char*msg){
2569 CallInfo*ci=L->ci;
2570 if(isLua(ci)){
2571 char buff[60];
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);
2575 }
2576 }
2577 static void luaG_errormsg(lua_State*L){
2578 if(L->errfunc!=0){
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);
2583 incr_top(L);
2584 luaD_call(L,L->top-2,1);
2585 }
2586 luaD_throw(L,2);
2587 }
2588 static void luaG_runerror(lua_State*L,const char*fmt,...){
2589 va_list argp;
2590 va_start(argp,fmt);
2591 addinfo(L,luaO_pushvfstring(L,fmt,argp));
2592 va_end(argp);
2593 luaG_errormsg(L);
2594 }
2595 static int luaZ_fill(ZIO*z){
2596 size_t size;
2597 lua_State*L=z->L;
2598 const char*buff;
2599 buff=z->reader(L,z->data,&size);
2600 if(buff==NULL||size==0)return(-1);
2601 z->n=size-1;
2602 z->p=buff;
2603 return char2int(*(z->p++));
2604 }
2605 static void luaZ_init(lua_State*L,ZIO*z,lua_Reader reader,void*data){
2606 z->L=L;
2607 z->reader=reader;
2608 z->data=data;
2609 z->n=0;
2610 z->p=NULL;
2611 }
2612 static char*luaZ_openspace(lua_State*L,Mbuffer*buff,size_t n){
2613 if(n>buff->buffsize){
2614 if(n<32)n=32;
2615 luaZ_resizebuffer(L,buff,n);
2616 }
2617 return buff->buffer;
2618 }
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)
2659 };
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>",
2669 NULL
2670 };
2671 #define save_and_next(ls)(save(ls,ls->current),next(ls))
2672 static void save(LexState*ls,int c){
2673 Mbuffer*b=ls->buff;
2674 if(b->n+1>b->buffsize){
2675 size_t newsize;
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);
2680 }
2681 b->buffer[b->n++]=cast(char,c);
2682 }
2683 static void luaX_init(lua_State*L){
2684 int i;
2685 for(i=0;i<(cast(int,TK_WHILE-257+1));i++){
2686 TString*ts=luaS_new(L,luaX_tokens[i]);
2687 luaS_fix(ts);
2688 ts->tsv.reserved=cast_byte(i+1);
2689 }
2690 }
2691 static const char*luaX_token2str(LexState*ls,int token){
2692 if(token<257){
2693 return(iscntrl(token))?luaO_pushfstring(ls->L,"char(%d)",token):
2694 luaO_pushfstring(ls->L,"%c",token);
2695 }
2696 else
2697 return luaX_tokens[token-257];
2698 }
2699 static const char*txtToken(LexState*ls,int token){
2700 switch(token){
2701 case TK_NAME:
2702 case TK_STRING:
2703 case TK_NUMBER:
2704 save(ls,'\0');
2705 return luaZ_buffer(ls->buff);
2706 default:
2707 return luaX_token2str(ls,token);
2708 }
2709 }
2710 static void luaX_lexerror(LexState*ls,const char*msg,int token){
2711 char buff[80];
2712 luaO_chunkid(buff,getstr(ls->source),80);
2713 msg=luaO_pushfstring(ls->L,"%s:%d: %s",buff,ls->linenumber,msg);
2714 if(token)
2715 luaO_pushfstring(ls->L,"%s near "LUA_QL("%s"),msg,txtToken(ls,token));
2716 luaD_throw(ls->L,3);
2717 }
2718 static void luaX_syntaxerror(LexState*ls,const char*msg){
2719 luaX_lexerror(ls,msg,ls->t.token);
2720 }
2721 static TString*luaX_newstring(LexState*ls,const char*str,size_t l){
2722 lua_State*L=ls->L;
2723 TString*ts=luaS_newlstr(L,str,l);
2724 TValue*o=luaH_setstr(L,ls->fs->h,ts);
2725 if(ttisnil(o)){
2726 setbvalue(o,1);
2727 luaC_checkGC(L);
2728 }
2729 return ts;
2730 }
2731 static void inclinenumber(LexState*ls){
2732 int old=ls->current;
2733 next(ls);
2734 if(currIsNewline(ls)&&ls->current!=old)
2735 next(ls);
2736 if(++ls->linenumber>=(INT_MAX-2))
2737 luaX_syntaxerror(ls,"chunk has too many lines");
2738 }
2739 static void luaX_setinput(lua_State*L,LexState*ls,ZIO*z,TString*source){
2740 ls->decpoint='.';
2741 ls->L=L;
2742 ls->lookahead.token=TK_EOS;
2743 ls->z=z;
2744 ls->fs=NULL;
2745 ls->linenumber=1;
2746 ls->lastline=1;
2747 ls->source=source;
2748 luaZ_resizebuffer(ls->L,ls->buff,32);
2749 next(ls);
2750 }
2751 static int check_next(LexState*ls,const char*set){
2752 if(!strchr(set,ls->current))
2753 return 0;
2754 save_and_next(ls);
2755 return 1;
2756 }
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);
2760 while(n--)
2761 if(p[n]==from)p[n]=to;
2762 }
2763 static void read_numeral(LexState*ls,SemInfo*seminfo){
2764 do{
2765 save_and_next(ls);
2766 }while(isdigit(ls->current)||ls->current=='.');
2767 if(check_next(ls,"Ee"))
2768 check_next(ls,"+-");
2769 while(isalnum(ls->current)||ls->current=='_')
2770 save_and_next(ls);
2771 save(ls,'\0');
2772 buffreplace(ls,'.',ls->decpoint);
2773 if(!luaO_str2d(luaZ_buffer(ls->buff),&seminfo->r))
2774 luaX_lexerror(ls,"malformed number",TK_NUMBER);
2775 }
2776 static int skip_sep(LexState*ls){
2777 int count=0;
2778 int s=ls->current;
2779 save_and_next(ls);
2780 while(ls->current=='='){
2781 save_and_next(ls);
2782 count++;
2783 }
2784 return(ls->current==s)?count:(-count)-1;
2785 }
2786 static void read_long_string(LexState*ls,SemInfo*seminfo,int sep){
2787 int cont=0;
2788 (void)(cont);
2789 save_and_next(ls);
2790 if(currIsNewline(ls))
2791 inclinenumber(ls);
2792 for(;;){
2793 switch(ls->current){
2794 case(-1):
2795 luaX_lexerror(ls,(seminfo)?"unfinished long string":
2796 "unfinished long comment",TK_EOS);
2797 break;
2798 case']':{
2799 if(skip_sep(ls)==sep){
2800 save_and_next(ls);
2801 goto endloop;
2802 }
2803 break;
2804 }
2805 case'\n':
2806 case'\r':{
2807 save(ls,'\n');
2808 inclinenumber(ls);
2809 if(!seminfo)luaZ_resetbuffer(ls->buff);
2810 break;
2811 }
2812 default:{
2813 if(seminfo)save_and_next(ls);
2814 else next(ls);
2815 }
2816 }
2817 }endloop:
2818 if(seminfo)
2819 seminfo->ts=luaX_newstring(ls,luaZ_buffer(ls->buff)+(2+sep),
2820 luaZ_bufflen(ls->buff)-2*(2+sep));
2821 }
2822 static void read_string(LexState*ls,int del,SemInfo*seminfo){
2823 save_and_next(ls);
2824 while(ls->current!=del){
2825 switch(ls->current){
2826 case(-1):
2827 luaX_lexerror(ls,"unfinished string",TK_EOS);
2828 continue;
2829 case'\n':
2830 case'\r':
2831 luaX_lexerror(ls,"unfinished string",TK_STRING);
2832 continue;
2833 case'\\':{
2834 int c;
2835 next(ls);
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;
2844 case'\n':
2845 case'\r':save(ls,'\n');inclinenumber(ls);continue;
2846 case(-1):continue;
2847 default:{
2848 if(!isdigit(ls->current))
2849 save_and_next(ls);
2850 else{
2851 int i=0;
2852 c=0;
2853 do{
2854 c=10*c+(ls->current-'0');
2855 next(ls);
2856 }while(++i<3&&isdigit(ls->current));
2857 if(c>UCHAR_MAX)
2858 luaX_lexerror(ls,"escape sequence too large",TK_STRING);
2859 save(ls,c);
2860 }
2861 continue;
2862 }
2863 }
2864 save(ls,c);
2865 next(ls);
2866 continue;
2867 }
2868 default:
2869 save_and_next(ls);
2870 }
2871 }
2872 save_and_next(ls);
2873 seminfo->ts=luaX_newstring(ls,luaZ_buffer(ls->buff)+1,
2874 luaZ_bufflen(ls->buff)-2);
2875 }
2876 static int llex(LexState*ls,SemInfo*seminfo){
2877 luaZ_resetbuffer(ls->buff);
2878 for(;;){
2879 switch(ls->current){
2880 case'\n':
2881 case'\r':{
2882 inclinenumber(ls);
2883 continue;
2884 }
2885 case'-':{
2886 next(ls);
2887 if(ls->current!='-')return'-';
2888 next(ls);
2889 if(ls->current=='['){
2890 int sep=skip_sep(ls);
2891 luaZ_resetbuffer(ls->buff);
2892 if(sep>=0){
2893 read_long_string(ls,NULL,sep);
2894 luaZ_resetbuffer(ls->buff);
2895 continue;
2896 }
2897 }
2898 while(!currIsNewline(ls)&&ls->current!=(-1))
2899 next(ls);
2900 continue;
2901 }
2902 case'[':{
2903 int sep=skip_sep(ls);
2904 if(sep>=0){
2905 read_long_string(ls,seminfo,sep);
2906 return TK_STRING;
2907 }
2908 else if(sep==-1)return'[';
2909 else luaX_lexerror(ls,"invalid long string delimiter",TK_STRING);
2910 }
2911 case'=':{
2912 next(ls);
2913 if(ls->current!='=')return'=';
2914 else{next(ls);return TK_EQ;}
2915 }
2916 case'<':{
2917 next(ls);
2918 if(ls->current!='=')return'<';
2919 else{next(ls);return TK_LE;}
2920 }
2921 case'>':{
2922 next(ls);
2923 if(ls->current!='=')return'>';
2924 else{next(ls);return TK_GE;}
2925 }
2926 case'~':{
2927 next(ls);
2928 if(ls->current!='=')return'~';
2929 else{next(ls);return TK_NE;}
2930 }
2931 case'"':
2932 case'\'':{
2933 read_string(ls,ls->current,seminfo);
2934 return TK_STRING;
2935 }
2936 case'.':{
2937 save_and_next(ls);
2938 if(check_next(ls,".")){
2939 if(check_next(ls,"."))
2940 return TK_DOTS;
2941 else return TK_CONCAT;
2942 }
2943 else if(!isdigit(ls->current))return'.';
2944 else{
2945 read_numeral(ls,seminfo);
2946 return TK_NUMBER;
2947 }
2948 }
2949 case(-1):{
2950 return TK_EOS;
2951 }
2952 default:{
2953 if(isspace(ls->current)){
2954 next(ls);
2955 continue;
2956 }
2957 else if(isdigit(ls->current)){
2958 read_numeral(ls,seminfo);
2959 return TK_NUMBER;
2960 }
2961 else if(isalpha(ls->current)||ls->current=='_'){
2962 TString*ts;
2963 do{
2964 save_and_next(ls);
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;
2970 else{
2971 seminfo->ts=ts;
2972 return TK_NAME;
2973 }
2974 }
2975 else{
2976 int c=ls->current;
2977 next(ls);
2978 return c;
2979 }
2980 }
2981 }
2982 }
2983 }
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;
2989 }
2990 else
2991 ls->t.token=llex(ls,&ls->t.seminfo);
2992 }
2993 static void luaX_lookahead(LexState*ls){
2994 ls->lookahead.token=llex(ls,&ls->lookahead.seminfo);
2995 }
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));
2999 }
3000 static void luaK_nil(FuncState*fs,int from,int n){
3001 Instruction*previous;
3002 if(fs->pc>fs->lasttarget){
3003 if(fs->pc==0){
3004 if(from>=fs->nactvar)
3005 return;
3006 }
3007 else{
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){
3013 if(from+n-1>pto)
3014 SETARG_B(*previous,from+n-1);
3015 return;
3016 }
3017 }
3018 }
3019 }
3020 luaK_codeABC(fs,OP_LOADNIL,from,from+n-1,0);
3021 }
3022 static int luaK_jump(FuncState*fs){
3023 int jpc=fs->jpc;
3024 int j;
3025 fs->jpc=(-1);
3026 j=luaK_codeAsBx(fs,OP_JMP,0,(-1));
3027 luaK_concat(fs,&j,jpc);
3028 return j;
3029 }
3030 static void luaK_ret(FuncState*fs,int first,int nret){
3031 luaK_codeABC(fs,OP_RETURN,first,nret+1,0);
3032 }
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);
3036 }
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);
3043 }
3044 static int luaK_getlabel(FuncState*fs){
3045 fs->lasttarget=fs->pc;
3046 return fs->pc;
3047 }
3048 static int getjump(FuncState*fs,int pc){
3049 int offset=GETARG_sBx(fs->f->code[pc]);
3050 if(offset==(-1))
3051 return(-1);
3052 else
3053 return(pc+1)+offset;
3054 }
3055 static Instruction*getjumpcontrol(FuncState*fs,int pc){
3056 Instruction*pi=&fs->f->code[pc];
3057 if(pc>=1&&testTMode(GET_OPCODE(*(pi-1))))
3058 return pi-1;
3059 else
3060 return pi;
3061 }
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;
3066 }
3067 return 0;
3068 }
3069 static int patchtestreg(FuncState*fs,int node,int reg){
3070 Instruction*i=getjumpcontrol(fs,node);
3071 if(GET_OPCODE(*i)!=OP_TESTSET)
3072 return 0;
3073 if(reg!=((1<<8)-1)&&reg!=GETARG_B(*i))
3074 SETARG_A(*i,reg);
3075 else
3076 *i=CREATE_ABC(OP_TEST,GETARG_B(*i),0,GETARG_C(*i));
3077 return 1;
3078 }
3079 static void removevalues(FuncState*fs,int list){
3080 for(;list!=(-1);list=getjump(fs,list))
3081 patchtestreg(fs,list,((1<<8)-1));
3082 }
3083 static void patchlistaux(FuncState*fs,int list,int vtarget,int reg,
3084 int dtarget){
3085 while(list!=(-1)){
3086 int next=getjump(fs,list);
3087 if(patchtestreg(fs,list,reg))
3088 fixjump(fs,list,vtarget);
3089 else
3090 fixjump(fs,list,dtarget);
3091 list=next;
3092 }
3093 }
3094 static void dischargejpc(FuncState*fs){
3095 patchlistaux(fs,fs->jpc,fs->pc,((1<<8)-1),fs->pc);
3096 fs->jpc=(-1);
3097 }
3098 static void luaK_patchlist(FuncState*fs,int list,int target){
3099 if(target==fs->pc)
3100 luaK_patchtohere(fs,list);
3101 else{
3102 patchlistaux(fs,list,target,((1<<8)-1),target);
3103 }
3104 }
3105 static void luaK_patchtohere(FuncState*fs,int list){
3106 luaK_getlabel(fs);
3107 luaK_concat(fs,&fs->jpc,list);
3108 }
3109 static void luaK_concat(FuncState*fs,int*l1,int l2){
3110 if(l2==(-1))return;
3111 else if(*l1==(-1))
3112 *l1=l2;
3113 else{
3114 int list=*l1;
3115 int next;
3116 while((next=getjump(fs,list))!=(-1))
3117 list=next;
3118 fixjump(fs,list,l2);
3119 }
3120 }
3121 static void luaK_checkstack(FuncState*fs,int n){
3122 int newstack=fs->freereg+n;
3123 if(newstack>fs->f->maxstacksize){
3124 if(newstack>=250)
3125 luaX_syntaxerror(fs->ls,"function or expression too complex");
3126 fs->f->maxstacksize=cast_byte(newstack);
3127 }
3128 }
3129 static void luaK_reserveregs(FuncState*fs,int n){
3130 luaK_checkstack(fs,n);
3131 fs->freereg+=n;
3132 }
3133 static void freereg(FuncState*fs,int reg){
3134 if(!ISK(reg)&&reg>=fs->nactvar){
3135 fs->freereg--;
3136 }
3137 }
3138 static void freeexp(FuncState*fs,expdesc*e){
3139 if(e->k==VNONRELOC)
3140 freereg(fs,e->u.s.info);
3141 }
3142 static int addk(FuncState*fs,TValue*k,TValue*v){
3143 lua_State*L=fs->L;
3144 TValue*idx=luaH_set(L,fs->h,k);
3145 Proto*f=fs->f;
3146 int oldsize=f->sizek;
3147 if(ttisnumber(idx)){
3148 return cast_int(nvalue(idx));
3149 }
3150 else{
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);
3157 return fs->nk++;
3158 }
3159 }
3160 static int luaK_stringK(FuncState*fs,TString*s){
3161 TValue o;
3162 setsvalue(fs->L,&o,s);
3163 return addk(fs,&o,&o);
3164 }
3165 static int luaK_numberK(FuncState*fs,lua_Number r){
3166 TValue o;
3167 setnvalue(&o,r);
3168 return addk(fs,&o,&o);
3169 }
3170 static int boolK(FuncState*fs,int b){
3171 TValue o;
3172 setbvalue(&o,b);
3173 return addk(fs,&o,&o);
3174 }
3175 static int nilK(FuncState*fs){
3176 TValue k,v;
3177 setnilvalue(&v);
3178 sethvalue(fs->L,&k,fs->h);
3179 return addk(fs,&k,&v);
3180 }
3181 static void luaK_setreturns(FuncState*fs,expdesc*e,int nresults){
3182 if(e->k==VCALL){
3183 SETARG_C(getcode(fs,e),nresults+1);
3184 }
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);
3189 }
3190 }
3191 static void luaK_setoneret(FuncState*fs,expdesc*e){
3192 if(e->k==VCALL){
3193 e->k=VNONRELOC;
3194 e->u.s.info=GETARG_A(getcode(fs,e));
3195 }
3196 else if(e->k==VVARARG){
3197 SETARG_B(getcode(fs,e),2);
3198 e->k=VRELOCABLE;
3199 }
3200 }
3201 static void luaK_dischargevars(FuncState*fs,expdesc*e){
3202 switch(e->k){
3203 case VLOCAL:{
3204 e->k=VNONRELOC;
3205 break;
3206 }
3207 case VUPVAL:{
3208 e->u.s.info=luaK_codeABC(fs,OP_GETUPVAL,0,e->u.s.info,0);
3209 e->k=VRELOCABLE;
3210 break;
3211 }
3212 case VGLOBAL:{
3213 e->u.s.info=luaK_codeABx(fs,OP_GETGLOBAL,0,e->u.s.info);
3214 e->k=VRELOCABLE;
3215 break;
3216 }
3217 case VINDEXED:{
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);
3221 e->k=VRELOCABLE;
3222 break;
3223 }
3224 case VVARARG:
3225 case VCALL:{
3226 luaK_setoneret(fs,e);
3227 break;
3228 }
3229 default:break;
3230 }
3231 }
3232 static int code_label(FuncState*fs,int A,int b,int jump){
3233 luaK_getlabel(fs);
3234 return luaK_codeABC(fs,OP_LOADBOOL,A,b,jump);
3235 }
3236 static void discharge2reg(FuncState*fs,expdesc*e,int reg){
3237 luaK_dischargevars(fs,e);
3238 switch(e->k){
3239 case VNIL:{
3240 luaK_nil(fs,reg,1);
3241 break;
3242 }
3243 case VFALSE:case VTRUE:{
3244 luaK_codeABC(fs,OP_LOADBOOL,reg,e->k==VTRUE,0);
3245 break;
3246 }
3247 case VK:{
3248 luaK_codeABx(fs,OP_LOADK,reg,e->u.s.info);
3249 break;
3250 }
3251 case VKNUM:{
3252 luaK_codeABx(fs,OP_LOADK,reg,luaK_numberK(fs,e->u.nval));
3253 break;
3254 }
3255 case VRELOCABLE:{
3256 Instruction*pc=&getcode(fs,e);
3257 SETARG_A(*pc,reg);
3258 break;
3259 }
3260 case VNONRELOC:{
3261 if(reg!=e->u.s.info)
3262 luaK_codeABC(fs,OP_MOVE,reg,e->u.s.info,0);
3263 break;
3264 }
3265 default:{
3266 return;
3267 }
3268 }
3269 e->u.s.info=reg;
3270 e->k=VNONRELOC;
3271 }
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);
3276 }
3277 }
3278 static void exp2reg(FuncState*fs,expdesc*e,int reg){
3279 discharge2reg(fs,e,reg);
3280 if(e->k==VJMP)
3281 luaK_concat(fs,&e->t,e->u.s.info);
3282 if(hasjumps(e)){
3283 int final;
3284 int p_f=(-1);
3285 int p_t=(-1);
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);
3291 }
3292 final=luaK_getlabel(fs);
3293 patchlistaux(fs,e->f,final,reg,p_f);
3294 patchlistaux(fs,e->t,final,reg,p_t);
3295 }
3296 e->f=e->t=(-1);
3297 e->u.s.info=reg;
3298 e->k=VNONRELOC;
3299 }
3300 static void luaK_exp2nextreg(FuncState*fs,expdesc*e){
3301 luaK_dischargevars(fs,e);
3302 freeexp(fs,e);
3303 luaK_reserveregs(fs,1);
3304 exp2reg(fs,e,fs->freereg-1);
3305 }
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);
3312 return e->u.s.info;
3313 }
3314 }
3315 luaK_exp2nextreg(fs,e);
3316 return e->u.s.info;
3317 }
3318 static void luaK_exp2val(FuncState*fs,expdesc*e){
3319 if(hasjumps(e))
3320 luaK_exp2anyreg(fs,e);
3321 else
3322 luaK_dischargevars(fs,e);
3323 }
3324 static int luaK_exp2RK(FuncState*fs,expdesc*e){
3325 luaK_exp2val(fs,e);
3326 switch(e->k){
3327 case VKNUM:
3328 case VTRUE:
3329 case VFALSE:
3330 case VNIL:{
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));
3335 e->k=VK;
3336 return RKASK(e->u.s.info);
3337 }
3338 else break;
3339 }
3340 case VK:{
3341 if(e->u.s.info<=((1<<(9-1))-1))
3342 return RKASK(e->u.s.info);
3343 else break;
3344 }
3345 default:break;
3346 }
3347 return luaK_exp2anyreg(fs,e);
3348 }
3349 static void luaK_storevar(FuncState*fs,expdesc*var,expdesc*ex){
3350 switch(var->k){
3351 case VLOCAL:{
3352 freeexp(fs,ex);
3353 exp2reg(fs,ex,var->u.s.info);
3354 return;
3355 }
3356 case VUPVAL:{
3357 int e=luaK_exp2anyreg(fs,ex);
3358 luaK_codeABC(fs,OP_SETUPVAL,e,var->u.s.info,0);
3359 break;
3360 }
3361 case VGLOBAL:{
3362 int e=luaK_exp2anyreg(fs,ex);
3363 luaK_codeABx(fs,OP_SETGLOBAL,e,var->u.s.info);
3364 break;
3365 }
3366 case VINDEXED:{
3367 int e=luaK_exp2RK(fs,ex);
3368 luaK_codeABC(fs,OP_SETTABLE,var->u.s.info,var->u.s.aux,e);
3369 break;
3370 }
3371 default:{
3372 break;
3373 }
3374 }
3375 freeexp(fs,ex);
3376 }
3377 static void luaK_self(FuncState*fs,expdesc*e,expdesc*key){
3378 int func;
3379 luaK_exp2anyreg(fs,e);
3380 freeexp(fs,e);
3381 func=fs->freereg;
3382 luaK_reserveregs(fs,2);
3383 luaK_codeABC(fs,OP_SELF,func,e->u.s.info,luaK_exp2RK(fs,key));
3384 freeexp(fs,key);
3385 e->u.s.info=func;
3386 e->k=VNONRELOC;
3387 }
3388 static void invertjump(FuncState*fs,expdesc*e){
3389 Instruction*pc=getjumpcontrol(fs,e->u.s.info);
3390 SETARG_A(*pc,!(GETARG_A(*pc)));
3391 }
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){
3396 fs->pc--;
3397 return condjump(fs,OP_TEST,GETARG_B(ie),0,!cond);
3398 }
3399 }
3400 discharge2anyreg(fs,e);
3401 freeexp(fs,e);
3402 return condjump(fs,OP_TESTSET,((1<<8)-1),e->u.s.info,cond);
3403 }
3404 static void luaK_goiftrue(FuncState*fs,expdesc*e){
3405 int pc;
3406 luaK_dischargevars(fs,e);
3407 switch(e->k){
3408 case VK:case VKNUM:case VTRUE:{
3409 pc=(-1);
3410 break;
3411 }
3412 case VJMP:{
3413 invertjump(fs,e);
3414 pc=e->u.s.info;
3415 break;
3416 }
3417 default:{
3418 pc=jumponcond(fs,e,0);
3419 break;
3420 }
3421 }
3422 luaK_concat(fs,&e->f,pc);
3423 luaK_patchtohere(fs,e->t);
3424 e->t=(-1);
3425 }
3426 static void luaK_goiffalse(FuncState*fs,expdesc*e){
3427 int pc;
3428 luaK_dischargevars(fs,e);
3429 switch(e->k){
3430 case VNIL:case VFALSE:{
3431 pc=(-1);
3432 break;
3433 }
3434 case VJMP:{
3435 pc=e->u.s.info;
3436 break;
3437 }
3438 default:{
3439 pc=jumponcond(fs,e,1);
3440 break;
3441 }
3442 }
3443 luaK_concat(fs,&e->t,pc);
3444 luaK_patchtohere(fs,e->f);
3445 e->f=(-1);
3446 }
3447 static void codenot(FuncState*fs,expdesc*e){
3448 luaK_dischargevars(fs,e);
3449 switch(e->k){
3450 case VNIL:case VFALSE:{
3451 e->k=VTRUE;
3452 break;
3453 }
3454 case VK:case VKNUM:case VTRUE:{
3455 e->k=VFALSE;
3456 break;
3457 }
3458 case VJMP:{
3459 invertjump(fs,e);
3460 break;
3461 }
3462 case VRELOCABLE:
3463 case VNONRELOC:{
3464 discharge2anyreg(fs,e);
3465 freeexp(fs,e);
3466 e->u.s.info=luaK_codeABC(fs,OP_NOT,0,e->u.s.info,0);
3467 e->k=VRELOCABLE;
3468 break;
3469 }
3470 default:{
3471 break;
3472 }
3473 }
3474 {int temp=e->f;e->f=e->t;e->t=temp;}
3475 removevalues(fs,e->f);
3476 removevalues(fs,e->t);
3477 }
3478 static void luaK_indexed(FuncState*fs,expdesc*t,expdesc*k){
3479 t->u.s.aux=luaK_exp2RK(fs,k);
3480 t->k=VINDEXED;
3481 }
3482 static int constfolding(OpCode op,expdesc*e1,expdesc*e2){
3483 lua_Number v1,v2,r;
3484 if(!isnumeral(e1)||!isnumeral(e2))return 0;
3485 v1=e1->u.nval;
3486 v2=e2->u.nval;
3487 switch(op){
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;
3491 case OP_DIV:
3492 if(v2==0)return 0;
3493 r=luai_numdiv(v1,v2);break;
3494 case OP_MOD:
3495 if(v2==0)return 0;
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;
3500 default:r=0;break;
3501 }
3502 if(luai_numisnan(r))return 0;
3503 e1->u.nval=r;
3504 return 1;
3505 }
3506 static void codearith(FuncState*fs,OpCode op,expdesc*e1,expdesc*e2){
3507 if(constfolding(op,e1,e2))
3508 return;
3509 else{
3510 int o2=(op!=OP_UNM&&op!=OP_LEN)?luaK_exp2RK(fs,e2):0;
3511 int o1=luaK_exp2RK(fs,e1);
3512 if(o1>o2){
3513 freeexp(fs,e1);
3514 freeexp(fs,e2);
3515 }
3516 else{
3517 freeexp(fs,e2);
3518 freeexp(fs,e1);
3519 }
3520 e1->u.s.info=luaK_codeABC(fs,op,0,o1,o2);
3521 e1->k=VRELOCABLE;
3522 }
3523 }
3524 static void codecomp(FuncState*fs,OpCode op,int cond,expdesc*e1,
3525 expdesc*e2){
3526 int o1=luaK_exp2RK(fs,e1);
3527 int o2=luaK_exp2RK(fs,e2);
3528 freeexp(fs,e2);
3529 freeexp(fs,e1);
3530 if(cond==0&&op!=OP_EQ){
3531 int temp;
3532 temp=o1;o1=o2;o2=temp;
3533 cond=1;
3534 }
3535 e1->u.s.info=condjump(fs,op,cond,o1,o2);
3536 e1->k=VJMP;
3537 }
3538 static void luaK_prefix(FuncState*fs,UnOpr op,expdesc*e){
3539 expdesc e2;
3540 e2.t=e2.f=(-1);e2.k=VKNUM;e2.u.nval=0;
3541 switch(op){
3542 case OPR_MINUS:{
3543 if(!isnumeral(e))
3544 luaK_exp2anyreg(fs,e);
3545 codearith(fs,OP_UNM,e,&e2);
3546 break;
3547 }
3548 case OPR_NOT:codenot(fs,e);break;
3549 case OPR_LEN:{
3550 luaK_exp2anyreg(fs,e);
3551 codearith(fs,OP_LEN,e,&e2);
3552 break;
3553 }
3554 default:;
3555 }
3556 }
3557 static void luaK_infix(FuncState*fs,BinOpr op,expdesc*v){
3558 switch(op){
3559 case OPR_AND:{
3560 luaK_goiftrue(fs,v);
3561 break;
3562 }
3563 case OPR_OR:{
3564 luaK_goiffalse(fs,v);
3565 break;
3566 }
3567 case OPR_CONCAT:{
3568 luaK_exp2nextreg(fs,v);
3569 break;
3570 }
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);
3574 break;
3575 }
3576 default:{
3577 luaK_exp2RK(fs,v);
3578 break;
3579 }
3580 }
3581 }
3582 static void luaK_posfix(FuncState*fs,BinOpr op,expdesc*e1,expdesc*e2){
3583 switch(op){
3584 case OPR_AND:{
3585 luaK_dischargevars(fs,e2);
3586 luaK_concat(fs,&e2->f,e1->f);
3587 *e1=*e2;
3588 break;
3589 }
3590 case OPR_OR:{
3591 luaK_dischargevars(fs,e2);
3592 luaK_concat(fs,&e2->t,e1->t);
3593 *e1=*e2;
3594 break;
3595 }
3596 case OPR_CONCAT:{
3597 luaK_exp2val(fs,e2);
3598 if(e2->k==VRELOCABLE&&GET_OPCODE(getcode(fs,e2))==OP_CONCAT){
3599 freeexp(fs,e1);
3600 SETARG_B(getcode(fs,e2),e1->u.s.info);
3601 e1->k=VRELOCABLE;e1->u.s.info=e2->u.s.info;
3602 }
3603 else{
3604 luaK_exp2nextreg(fs,e2);
3605 codearith(fs,OP_CONCAT,e1,e2);
3606 }
3607 break;
3608 }
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;
3621 default:;
3622 }
3623 }
3624 static void luaK_fixline(FuncState*fs,int line){
3625 fs->f->lineinfo[fs->pc-1]=line;
3626 }
3627 static int luaK_code(FuncState*fs,Instruction i,int line){
3628 Proto*f=fs->f;
3629 dischargejpc(fs);
3630 luaM_growvector(fs->L,f->code,fs->pc,f->sizecode,Instruction,
3631 (INT_MAX-2),"code size overflow");
3632 f->code[fs->pc]=i;
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;
3636 return fs->pc++;
3637 }
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);
3640 }
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);
3643 }
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;
3647 if(c<=((1<<9)-1))
3648 luaK_codeABC(fs,OP_SETLIST,base,b,c);
3649 else{
3650 luaK_codeABC(fs,OP_SETLIST,base,b,0);
3651 luaK_code(fs,cast(Instruction,c),fs->ls->lastline);
3652 }
3653 fs->freereg=base+1;
3654 }
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;
3660 int breaklist;
3661 lu_byte nactvar;
3662 lu_byte upval;
3663 lu_byte isbreakable;
3664 }BlockCnt;
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);
3671 }
3672 }
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)));
3676 }
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);
3683 }
3684 static int testnext(LexState*ls,int c){
3685 if(ls->t.token==c){
3686 luaX_next(ls);
3687 return 1;
3688 }
3689 else return 0;
3690 }
3691 static void check(LexState*ls,int c){
3692 if(ls->t.token!=c)
3693 error_expected(ls,c);
3694 }
3695 static void checknext(LexState*ls,int c){
3696 check(ls,c);
3697 luaX_next(ls);
3698 }
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);
3704 else{
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));
3708 }
3709 }
3710 }
3711 static TString*str_checkname(LexState*ls){
3712 TString*ts;
3713 check(ls,TK_NAME);
3714 ts=ls->t.seminfo.ts;
3715 luaX_next(ls);
3716 return ts;
3717 }
3718 static void init_exp(expdesc*e,expkind k,int i){
3719 e->f=e->t=(-1);
3720 e->k=k;
3721 e->u.s.info=i;
3722 }
3723 static void codestring(LexState*ls,expdesc*e,TString*s){
3724 init_exp(e,VK,luaK_stringK(ls->fs,s));
3725 }
3726 static void checkname(LexState*ls,expdesc*e){
3727 codestring(ls,e,str_checkname(ls));
3728 }
3729 static int registerlocalvar(LexState*ls,TString*varname){
3730 FuncState*fs=ls->fs;
3731 Proto*f=fs->f;
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++;
3739 }
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));
3745 }
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;
3751 }
3752 }
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;
3757 }
3758 static int indexupvalue(FuncState*fs,TString*name,expdesc*v){
3759 int i;
3760 Proto*f=fs->f;
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){
3764 return i;
3765 }
3766 }
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);
3775 return f->nups++;
3776 }
3777 static int searchvar(FuncState*fs,TString*n){
3778 int i;
3779 for(i=fs->nactvar-1;i>=0;i--){
3780 if(n==getlocvar(fs,i).varname)
3781 return i;
3782 }
3783 return-1;
3784 }
3785 static void markupval(FuncState*fs,int level){
3786 BlockCnt*bl=fs->bl;
3787 while(bl&&bl->nactvar>level)bl=bl->previous;
3788 if(bl)bl->upval=1;
3789 }
3790 static int singlevaraux(FuncState*fs,TString*n,expdesc*var,int base){
3791 if(fs==NULL){
3792 init_exp(var,VGLOBAL,((1<<8)-1));
3793 return VGLOBAL;
3794 }
3795 else{
3796 int v=searchvar(fs,n);
3797 if(v>=0){
3798 init_exp(var,VLOCAL,v);
3799 if(!base)
3800 markupval(fs,v);
3801 return VLOCAL;
3802 }
3803 else{
3804 if(singlevaraux(fs->prev,n,var,0)==VGLOBAL)
3805 return VGLOBAL;
3806 var->u.s.info=indexupvalue(fs,n,var);
3807 var->k=VUPVAL;
3808 return VUPVAL;
3809 }
3810 }
3811 }
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);
3817 }
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)){
3822 extra++;
3823 if(extra<0)extra=0;
3824 luaK_setreturns(fs,e,extra);
3825 if(extra>1)luaK_reserveregs(fs,extra-1);
3826 }
3827 else{
3828 if(e->k!=VVOID)luaK_exp2nextreg(fs,e);
3829 if(extra>0){
3830 int reg=fs->freereg;
3831 luaK_reserveregs(fs,extra);
3832 luaK_nil(fs,reg,extra);
3833 }
3834 }
3835 }
3836 static void enterlevel(LexState*ls){
3837 if(++ls->L->nCcalls>200)
3838 luaX_lexerror(ls,"chunk has too many syntax levels",0);
3839 }
3840 #define leavelevel(ls)((ls)->L->nCcalls--)
3841 static void enterblock(FuncState*fs,BlockCnt*bl,lu_byte isbreakable){
3842 bl->breaklist=(-1);
3843 bl->isbreakable=isbreakable;
3844 bl->nactvar=fs->nactvar;
3845 bl->upval=0;
3846 bl->previous=fs->bl;
3847 fs->bl=bl;
3848 }
3849 static void leaveblock(FuncState*fs){
3850 BlockCnt*bl=fs->bl;
3851 fs->bl=bl->previous;
3852 removevars(fs->ls,bl->nactvar);
3853 if(bl->upval)
3854 luaK_codeABC(fs,OP_CLOSE,bl->nactvar,0,0);
3855 fs->freereg=fs->nactvar;
3856 luaK_patchtohere(fs,bl->breaklist);
3857 }
3858 static void pushclosure(LexState*ls,FuncState*func,expdesc*v){
3859 FuncState*fs=ls->fs;
3860 Proto*f=fs->f;
3861 int oldsize=f->sizep;
3862 int i;
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);
3872 }
3873 }
3874 static void open_func(LexState*ls,FuncState*fs){
3875 lua_State*L=ls->L;
3876 Proto*f=luaF_newproto(L);
3877 fs->f=f;
3878 fs->prev=ls->fs;
3879 fs->ls=ls;
3880 fs->L=L;
3881 ls->fs=fs;
3882 fs->pc=0;
3883 fs->lasttarget=-1;
3884 fs->jpc=(-1);
3885 fs->freereg=0;
3886 fs->nk=0;
3887 fs->np=0;
3888 fs->nlocvars=0;
3889 fs->nactvar=0;
3890 fs->bl=NULL;
3891 f->source=ls->source;
3892 f->maxstacksize=2;
3893 fs->h=luaH_new(L,0,0);
3894 sethvalue(L,L->top,fs->h);
3895 incr_top(L);
3896 setptvalue(L,L->top,f);
3897 incr_top(L);
3898 }
3899 static void close_func(LexState*ls){
3900 lua_State*L=ls->L;
3901 FuncState*fs=ls->fs;
3902 Proto*f=fs->f;
3903 removevars(ls,0);
3904 luaK_ret(fs,0,0);
3905 luaM_reallocvector(L,f->code,f->sizecode,fs->pc,Instruction);
3906 f->sizecode=fs->pc;
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);
3910 f->sizek=fs->nk;
3911 luaM_reallocvector(L,f->p,f->sizep,fs->np,Proto*);
3912 f->sizep=fs->np;
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;
3917 ls->fs=fs->prev;
3918 if(fs)anchor_token(ls);
3919 L->top-=2;
3920 }
3921 static Proto*luaY_parser(lua_State*L,ZIO*z,Mbuffer*buff,const char*name){
3922 struct LexState lexstate;
3923 struct FuncState funcstate;
3924 lexstate.buff=buff;
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);
3929 chunk(&lexstate);
3930 check(&lexstate,TK_EOS);
3931 close_func(&lexstate);
3932 return funcstate.f;
3933 }
3934 static void field(LexState*ls,expdesc*v){
3935 FuncState*fs=ls->fs;
3936 expdesc key;
3937 luaK_exp2anyreg(fs,v);
3938 luaX_next(ls);
3939 checkname(ls,&key);
3940 luaK_indexed(fs,v,&key);
3941 }
3942 static void yindex(LexState*ls,expdesc*v){
3943 luaX_next(ls);
3944 expr(ls,v);
3945 luaK_exp2val(ls->fs,v);
3946 checknext(ls,']');
3947 }
3948 struct ConsControl{
3949 expdesc v;
3950 expdesc*t;
3951 int nh;
3952 int na;
3953 int tostore;
3954 };
3955 static void recfield(LexState*ls,struct ConsControl*cc){
3956 FuncState*fs=ls->fs;
3957 int reg=ls->fs->freereg;
3958 expdesc key,val;
3959 int rkkey;
3960 if(ls->t.token==TK_NAME){
3961 luaY_checklimit(fs,cc->nh,(INT_MAX-2),"items in a constructor");
3962 checkname(ls,&key);
3963 }
3964 else
3965 yindex(ls,&key);
3966 cc->nh++;
3967 checknext(ls,'=');
3968 rkkey=luaK_exp2RK(fs,&key);
3969 expr(ls,&val);
3970 luaK_codeABC(fs,OP_SETTABLE,cc->t->u.s.info,rkkey,luaK_exp2RK(fs,&val));
3971 fs->freereg=reg;
3972 }
3973 static void closelistfield(FuncState*fs,struct ConsControl*cc){
3974 if(cc->v.k==VVOID)return;
3975 luaK_exp2nextreg(fs,&cc->v);
3976 cc->v.k=VVOID;
3977 if(cc->tostore==50){
3978 luaK_setlist(fs,cc->t->u.s.info,cc->na,cc->tostore);
3979 cc->tostore=0;
3980 }
3981 }
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));
3987 cc->na--;
3988 }
3989 else{
3990 if(cc->v.k!=VVOID)
3991 luaK_exp2nextreg(fs,&cc->v);
3992 luaK_setlist(fs,cc->t->u.s.info,cc->na,cc->tostore);
3993 }
3994 }
3995 static void listfield(LexState*ls,struct ConsControl*cc){
3996 expr(ls,&cc->v);
3997 luaY_checklimit(ls->fs,cc->na,(INT_MAX-2),"items in a constructor");
3998 cc->na++;
3999 cc->tostore++;
4000 }
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;
4007 cc.t=t;
4008 init_exp(t,VRELOCABLE,pc);
4009 init_exp(&cc.v,VVOID,0);
4010 luaK_exp2nextreg(ls->fs,t);
4011 checknext(ls,'{');
4012 do{
4013 if(ls->t.token=='}')break;
4014 closelistfield(fs,&cc);
4015 switch(ls->t.token){
4016 case TK_NAME:{
4017 luaX_lookahead(ls);
4018 if(ls->lookahead.token!='=')
4019 listfield(ls,&cc);
4020 else
4021 recfield(ls,&cc);
4022 break;
4023 }
4024 case'[':{
4025 recfield(ls,&cc);
4026 break;
4027 }
4028 default:{
4029 listfield(ls,&cc);
4030 break;
4031 }
4032 }
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));
4038 }
4039 static void parlist(LexState*ls){
4040 FuncState*fs=ls->fs;
4041 Proto*f=fs->f;
4042 int nparams=0;
4043 f->is_vararg=0;
4044 if(ls->t.token!=')'){
4045 do{
4046 switch(ls->t.token){
4047 case TK_NAME:{
4048 new_localvar(ls,str_checkname(ls),nparams++);
4049 break;
4050 }
4051 case TK_DOTS:{
4052 luaX_next(ls);
4053 f->is_vararg|=2;
4054 break;
4055 }
4056 default:luaX_syntaxerror(ls,"<name> or "LUA_QL("...")" expected");
4057 }
4058 }while(!f->is_vararg&&testnext(ls,','));
4059 }
4060 adjustlocalvars(ls,nparams);
4061 f->numparams=cast_byte(fs->nactvar-(f->is_vararg&1));
4062 luaK_reserveregs(fs,fs->nactvar);
4063 }
4064 static void body(LexState*ls,expdesc*e,int needself,int line){
4065 FuncState new_fs;
4066 open_func(ls,&new_fs);
4067 new_fs.f->linedefined=line;
4068 checknext(ls,'(');
4069 if(needself){
4070 new_localvarliteral(ls,"self",0);
4071 adjustlocalvars(ls,1);
4072 }
4073 parlist(ls);
4074 checknext(ls,')');
4075 chunk(ls);
4076 new_fs.f->lastlinedefined=ls->linenumber;
4077 check_match(ls,TK_END,TK_FUNCTION,line);
4078 close_func(ls);
4079 pushclosure(ls,&new_fs,e);
4080 }
4081 static int explist1(LexState*ls,expdesc*v){
4082 int n=1;
4083 expr(ls,v);
4084 while(testnext(ls,',')){
4085 luaK_exp2nextreg(ls->fs,v);
4086 expr(ls,v);
4087 n++;
4088 }
4089 return n;
4090 }
4091 static void funcargs(LexState*ls,expdesc*f){
4092 FuncState*fs=ls->fs;
4093 expdesc args;
4094 int base,nparams;
4095 int line=ls->linenumber;
4096 switch(ls->t.token){
4097 case'(':{
4098 if(line!=ls->lastline)
4099 luaX_syntaxerror(ls,"ambiguous syntax (function call x new statement)");
4100 luaX_next(ls);
4101 if(ls->t.token==')')
4102 args.k=VVOID;
4103 else{
4104 explist1(ls,&args);
4105 luaK_setmultret(fs,&args);
4106 }
4107 check_match(ls,')','(',line);
4108 break;
4109 }
4110 case'{':{
4111 constructor(ls,&args);
4112 break;
4113 }
4114 case TK_STRING:{
4115 codestring(ls,&args,ls->t.seminfo.ts);
4116 luaX_next(ls);
4117 break;
4118 }
4119 default:{
4120 luaX_syntaxerror(ls,"function arguments expected");
4121 return;
4122 }
4123 }
4124 base=f->u.s.info;
4125 if(hasmultret(args.k))
4126 nparams=(-1);
4127 else{
4128 if(args.k!=VVOID)
4129 luaK_exp2nextreg(fs,&args);
4130 nparams=fs->freereg-(base+1);
4131 }
4132 init_exp(f,VCALL,luaK_codeABC(fs,OP_CALL,base,nparams+1,2));
4133 luaK_fixline(fs,line);
4134 fs->freereg=base+1;
4135 }
4136 static void prefixexp(LexState*ls,expdesc*v){
4137 switch(ls->t.token){
4138 case'(':{
4139 int line=ls->linenumber;
4140 luaX_next(ls);
4141 expr(ls,v);
4142 check_match(ls,')','(',line);
4143 luaK_dischargevars(ls->fs,v);
4144 return;
4145 }
4146 case TK_NAME:{
4147 singlevar(ls,v);
4148 return;
4149 }
4150 default:{
4151 luaX_syntaxerror(ls,"unexpected symbol");
4152 return;
4153 }
4154 }
4155 }
4156 static void primaryexp(LexState*ls,expdesc*v){
4157 FuncState*fs=ls->fs;
4158 prefixexp(ls,v);
4159 for(;;){
4160 switch(ls->t.token){
4161 case'.':{
4162 field(ls,v);
4163 break;
4164 }
4165 case'[':{
4166 expdesc key;
4167 luaK_exp2anyreg(fs,v);
4168 yindex(ls,&key);
4169 luaK_indexed(fs,v,&key);
4170 break;
4171 }
4172 case':':{
4173 expdesc key;
4174 luaX_next(ls);
4175 checkname(ls,&key);
4176 luaK_self(fs,v,&key);
4177 funcargs(ls,v);
4178 break;
4179 }
4180 case'(':case TK_STRING:case'{':{
4181 luaK_exp2nextreg(fs,v);
4182 funcargs(ls,v);
4183 break;
4184 }
4185 default:return;
4186 }
4187 }
4188 }
4189 static void simpleexp(LexState*ls,expdesc*v){
4190 switch(ls->t.token){
4191 case TK_NUMBER:{
4192 init_exp(v,VKNUM,0);
4193 v->u.nval=ls->t.seminfo.r;
4194 break;
4195 }
4196 case TK_STRING:{
4197 codestring(ls,v,ls->t.seminfo.ts);
4198 break;
4199 }
4200 case TK_NIL:{
4201 init_exp(v,VNIL,0);
4202 break;
4203 }
4204 case TK_TRUE:{
4205 init_exp(v,VTRUE,0);
4206 break;
4207 }
4208 case TK_FALSE:{
4209 init_exp(v,VFALSE,0);
4210 break;
4211 }
4212 case TK_DOTS:{
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));
4218 break;
4219 }
4220 case'{':{
4221 constructor(ls,v);
4222 return;
4223 }
4224 case TK_FUNCTION:{
4225 luaX_next(ls);
4226 body(ls,v,0,ls->linenumber);
4227 return;
4228 }
4229 default:{
4230 primaryexp(ls,v);
4231 return;
4232 }
4233 }
4234 luaX_next(ls);
4235 }
4236 static UnOpr getunopr(int op){
4237 switch(op){
4238 case TK_NOT:return OPR_NOT;
4239 case'-':return OPR_MINUS;
4240 case'#':return OPR_LEN;
4241 default:return OPR_NOUNOPR;
4242 }
4243 }
4244 static BinOpr getbinopr(int op){
4245 switch(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;
4262 }
4263 }
4264 static const struct{
4265 lu_byte left;
4266 lu_byte right;
4267 }priority[]={
4268 {6,6},{6,6},{7,7},{7,7},{7,7},
4269 {10,9},{5,4},
4270 {3,3},{3,3},
4271 {3,3},{3,3},{3,3},{3,3},
4272 {2,2},{1,1}
4273 };
4274 static BinOpr subexpr(LexState*ls,expdesc*v,unsigned int limit){
4275 BinOpr op;
4276 UnOpr uop;
4277 enterlevel(ls);
4278 uop=getunopr(ls->t.token);
4279 if(uop!=OPR_NOUNOPR){
4280 luaX_next(ls);
4281 subexpr(ls,v,8);
4282 luaK_prefix(ls->fs,uop,v);
4283 }
4284 else simpleexp(ls,v);
4285 op=getbinopr(ls->t.token);
4286 while(op!=OPR_NOBINOPR&&priority[op].left>limit){
4287 expdesc v2;
4288 BinOpr nextop;
4289 luaX_next(ls);
4290 luaK_infix(ls->fs,op,v);
4291 nextop=subexpr(ls,&v2,priority[op].right);
4292 luaK_posfix(ls->fs,op,v,&v2);
4293 op=nextop;
4294 }
4295 leavelevel(ls);
4296 return op;
4297 }
4298 static void expr(LexState*ls,expdesc*v){
4299 subexpr(ls,v,0);
4300 }
4301 static int block_follow(int token){
4302 switch(token){
4303 case TK_ELSE:case TK_ELSEIF:case TK_END:
4304 case TK_UNTIL:case TK_EOS:
4305 return 1;
4306 default:return 0;
4307 }
4308 }
4309 static void block(LexState*ls){
4310 FuncState*fs=ls->fs;
4311 BlockCnt bl;
4312 enterblock(fs,&bl,0);
4313 chunk(ls);
4314 leaveblock(fs);
4315 }
4316 struct LHS_assign{
4317 struct LHS_assign*prev;
4318 expdesc v;
4319 };
4320 static void check_conflict(LexState*ls,struct LHS_assign*lh,expdesc*v){
4321 FuncState*fs=ls->fs;
4322 int extra=fs->freereg;
4323 int conflict=0;
4324 for(;lh;lh=lh->prev){
4325 if(lh->v.k==VINDEXED){
4326 if(lh->v.u.s.info==v->u.s.info){
4327 conflict=1;
4328 lh->v.u.s.info=extra;
4329 }
4330 if(lh->v.u.s.aux==v->u.s.info){
4331 conflict=1;
4332 lh->v.u.s.aux=extra;
4333 }
4334 }
4335 }
4336 if(conflict){
4337 luaK_codeABC(fs,OP_MOVE,fs->freereg,v->u.s.info,0);
4338 luaK_reserveregs(fs,1);
4339 }
4340 }
4341 static void assignment(LexState*ls,struct LHS_assign*lh,int nvars){
4342 expdesc e;
4343 check_condition(ls,VLOCAL<=lh->v.k&&lh->v.k<=VINDEXED,
4344 "syntax error");
4345 if(testnext(ls,',')){
4346 struct LHS_assign nv;
4347 nv.prev=lh;
4348 primaryexp(ls,&nv.v);
4349 if(nv.v.k==VLOCAL)
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);
4354 }
4355 else{
4356 int nexps;
4357 checknext(ls,'=');
4358 nexps=explist1(ls,&e);
4359 if(nexps!=nvars){
4360 adjust_assign(ls,nvars,nexps,&e);
4361 if(nexps>nvars)
4362 ls->fs->freereg-=nexps-nvars;
4363 }
4364 else{
4365 luaK_setoneret(ls->fs,&e);
4366 luaK_storevar(ls->fs,&lh->v,&e);
4367 return;
4368 }
4369 }
4370 init_exp(&e,VNONRELOC,ls->fs->freereg-1);
4371 luaK_storevar(ls->fs,&lh->v,&e);
4372 }
4373 static int cond(LexState*ls){
4374 expdesc v;
4375 expr(ls,&v);
4376 if(v.k==VNIL)v.k=VFALSE;
4377 luaK_goiftrue(ls->fs,&v);
4378 return v.f;
4379 }
4380 static void breakstat(LexState*ls){
4381 FuncState*fs=ls->fs;
4382 BlockCnt*bl=fs->bl;
4383 int upval=0;
4384 while(bl&&!bl->isbreakable){
4385 upval|=bl->upval;
4386 bl=bl->previous;
4387 }
4388 if(!bl)
4389 luaX_syntaxerror(ls,"no loop to break");
4390 if(upval)
4391 luaK_codeABC(fs,OP_CLOSE,bl->nactvar,0,0);
4392 luaK_concat(fs,&bl->breaklist,luaK_jump(fs));
4393 }
4394 static void whilestat(LexState*ls,int line){
4395 FuncState*fs=ls->fs;
4396 int whileinit;
4397 int condexit;
4398 BlockCnt bl;
4399 luaX_next(ls);
4400 whileinit=luaK_getlabel(fs);
4401 condexit=cond(ls);
4402 enterblock(fs,&bl,1);
4403 checknext(ls,TK_DO);
4404 block(ls);
4405 luaK_patchlist(fs,luaK_jump(fs),whileinit);
4406 check_match(ls,TK_END,TK_WHILE,line);
4407 leaveblock(fs);
4408 luaK_patchtohere(fs,condexit);
4409 }
4410 static void repeatstat(LexState*ls,int line){
4411 int condexit;
4412 FuncState*fs=ls->fs;
4413 int repeat_init=luaK_getlabel(fs);
4414 BlockCnt bl1,bl2;
4415 enterblock(fs,&bl1,1);
4416 enterblock(fs,&bl2,0);
4417 luaX_next(ls);
4418 chunk(ls);
4419 check_match(ls,TK_UNTIL,TK_REPEAT,line);
4420 condexit=cond(ls);
4421 if(!bl2.upval){
4422 leaveblock(fs);
4423 luaK_patchlist(ls->fs,condexit,repeat_init);
4424 }
4425 else{
4426 breakstat(ls);
4427 luaK_patchtohere(ls->fs,condexit);
4428 leaveblock(fs);
4429 luaK_patchlist(ls->fs,luaK_jump(fs),repeat_init);
4430 }
4431 leaveblock(fs);
4432 }
4433 static int exp1(LexState*ls){
4434 expdesc e;
4435 int k;
4436 expr(ls,&e);
4437 k=e.k;
4438 luaK_exp2nextreg(ls->fs,&e);
4439 return k;
4440 }
4441 static void forbody(LexState*ls,int base,int line,int nvars,int isnum){
4442 BlockCnt bl;
4443 FuncState*fs=ls->fs;
4444 int prep,endfor;
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);
4451 block(ls);
4452 leaveblock(fs);
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);
4458 }
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);
4466 checknext(ls,'=');
4467 exp1(ls);
4468 checknext(ls,',');
4469 exp1(ls);
4470 if(testnext(ls,','))
4471 exp1(ls);
4472 else{
4473 luaK_codeABx(fs,OP_LOADK,fs->freereg,luaK_numberK(fs,1));
4474 luaK_reserveregs(fs,1);
4475 }
4476 forbody(ls,base,line,1,1);
4477 }
4478 static void forlist(LexState*ls,TString*indexname){
4479 FuncState*fs=ls->fs;
4480 expdesc e;
4481 int nvars=0;
4482 int line;
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);
4495 }
4496 static void forstat(LexState*ls,int line){
4497 FuncState*fs=ls->fs;
4498 TString*varname;
4499 BlockCnt bl;
4500 enterblock(fs,&bl,1);
4501 luaX_next(ls);
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");
4507 }
4508 check_match(ls,TK_END,TK_FOR,line);
4509 leaveblock(fs);
4510 }
4511 static int test_then_block(LexState*ls){
4512 int condexit;
4513 luaX_next(ls);
4514 condexit=cond(ls);
4515 checknext(ls,TK_THEN);
4516 block(ls);
4517 return condexit;
4518 }
4519 static void ifstat(LexState*ls,int line){
4520 FuncState*fs=ls->fs;
4521 int flist;
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);
4528 }
4529 if(ls->t.token==TK_ELSE){
4530 luaK_concat(fs,&escapelist,luaK_jump(fs));
4531 luaK_patchtohere(fs,flist);
4532 luaX_next(ls);
4533 block(ls);
4534 }
4535 else
4536 luaK_concat(fs,&escapelist,flist);
4537 luaK_patchtohere(fs,escapelist);
4538 check_match(ls,TK_END,TK_IF,line);
4539 }
4540 static void localfunc(LexState*ls){
4541 expdesc v,b;
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;
4550 }
4551 static void localstat(LexState*ls){
4552 int nvars=0;
4553 int nexps;
4554 expdesc e;
4555 do{
4556 new_localvar(ls,str_checkname(ls),nvars++);
4557 }while(testnext(ls,','));
4558 if(testnext(ls,'='))
4559 nexps=explist1(ls,&e);
4560 else{
4561 e.k=VVOID;
4562 nexps=0;
4563 }
4564 adjust_assign(ls,nvars,nexps,&e);
4565 adjustlocalvars(ls,nvars);
4566 }
4567 static int funcname(LexState*ls,expdesc*v){
4568 int needself=0;
4569 singlevar(ls,v);
4570 while(ls->t.token=='.')
4571 field(ls,v);
4572 if(ls->t.token==':'){
4573 needself=1;
4574 field(ls,v);
4575 }
4576 return needself;
4577 }
4578 static void funcstat(LexState*ls,int line){
4579 int needself;
4580 expdesc v,b;
4581 luaX_next(ls);
4582 needself=funcname(ls,&v);
4583 body(ls,&b,needself,line);
4584 luaK_storevar(ls->fs,&v,&b);
4585 luaK_fixline(ls->fs,line);
4586 }
4587 static void exprstat(LexState*ls){
4588 FuncState*fs=ls->fs;
4589 struct LHS_assign v;
4590 primaryexp(ls,&v.v);
4591 if(v.v.k==VCALL)
4592 SETARG_C(getcode(fs,&v.v),1);
4593 else{
4594 v.prev=NULL;
4595 assignment(ls,&v,1);
4596 }
4597 }
4598 static void retstat(LexState*ls){
4599 FuncState*fs=ls->fs;
4600 expdesc e;
4601 int first,nret;
4602 luaX_next(ls);
4603 if(block_follow(ls->t.token)||ls->t.token==';')
4604 first=nret=0;
4605 else{
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);
4611 }
4612 first=fs->nactvar;
4613 nret=(-1);
4614 }
4615 else{
4616 if(nret==1)
4617 first=luaK_exp2anyreg(fs,&e);
4618 else{
4619 luaK_exp2nextreg(fs,&e);
4620 first=fs->nactvar;
4621 }
4622 }
4623 }
4624 luaK_ret(fs,first,nret);
4625 }
4626 static int statement(LexState*ls){
4627 int line=ls->linenumber;
4628 switch(ls->t.token){
4629 case TK_IF:{
4630 ifstat(ls,line);
4631 return 0;
4632 }
4633 case TK_WHILE:{
4634 whilestat(ls,line);
4635 return 0;
4636 }
4637 case TK_DO:{
4638 luaX_next(ls);
4639 block(ls);
4640 check_match(ls,TK_END,TK_DO,line);
4641 return 0;
4642 }
4643 case TK_FOR:{
4644 forstat(ls,line);
4645 return 0;
4646 }
4647 case TK_REPEAT:{
4648 repeatstat(ls,line);
4649 return 0;
4650 }
4651 case TK_FUNCTION:{
4652 funcstat(ls,line);
4653 return 0;
4654 }
4655 case TK_LOCAL:{
4656 luaX_next(ls);
4657 if(testnext(ls,TK_FUNCTION))
4658 localfunc(ls);
4659 else
4660 localstat(ls);
4661 return 0;
4662 }
4663 case TK_RETURN:{
4664 retstat(ls);
4665 return 1;
4666 }
4667 case TK_BREAK:{
4668 luaX_next(ls);
4669 breakstat(ls);
4670 return 1;
4671 }
4672 default:{
4673 exprstat(ls);
4674 return 0;
4675 }
4676 }
4677 }
4678 static void chunk(LexState*ls){
4679 int islast=0;
4680 enterlevel(ls);
4681 while(!islast&&!block_follow(ls->t.token)){
4682 islast=statement(ls);
4683 testnext(ls,';');
4684 ls->fs->freereg=ls->fs->nactvar;
4685 }
4686 leavelevel(ls);
4687 }
4688 static const TValue*luaV_tonumber(const TValue*obj,TValue*n){
4689 lua_Number num;
4690 if(ttisnumber(obj))return obj;
4691 if(ttisstring(obj)&&luaO_str2d(svalue(obj),&num)){
4692 setnvalue(n,num);
4693 return n;
4694 }
4695 else
4696 return NULL;
4697 }
4698 static int luaV_tostring(lua_State*L,StkId obj){
4699 if(!ttisnumber(obj))
4700 return 0;
4701 else{
4702 char s[32];
4703 lua_Number n=nvalue(obj);
4704 lua_number2str(s,n);
4705 setsvalue(L,obj,luaS_new(L,s));
4706 return 1;
4707 }
4708 }
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);
4712 setobj(L,L->top,f);
4713 setobj(L,L->top+1,p1);
4714 setobj(L,L->top+2,p2);
4715 luaD_checkstack(L,3);
4716 L->top+=3;
4717 luaD_call(L,L->top-3,1);
4718 res=restorestack(L,result);
4719 L->top--;
4720 setobj(L,res,L->top);
4721 }
4722 static void callTM(lua_State*L,const TValue*f,const TValue*p1,
4723 const TValue*p2,const TValue*p3){
4724 setobj(L,L->top,f);
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);
4729 L->top+=4;
4730 luaD_call(L,L->top-4,0);
4731 }
4732 static void luaV_gettable(lua_State*L,const TValue*t,TValue*key,StkId val){
4733 int loop;
4734 for(loop=0;loop<100;loop++){
4735 const TValue*tm;
4736 if(ttistable(t)){
4737 Table*h=hvalue(t);
4738 const TValue*res=luaH_get(h,key);
4739 if(!ttisnil(res)||
4740 (tm=fasttm(L,h->metatable,TM_INDEX))==NULL){
4741 setobj(L,val,res);
4742 return;
4743 }
4744 }
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);
4749 return;
4750 }
4751 t=tm;
4752 }
4753 luaG_runerror(L,"loop in gettable");
4754 }
4755 static void luaV_settable(lua_State*L,const TValue*t,TValue*key,StkId val){
4756 int loop;
4757 TValue temp;
4758 for(loop=0;loop<100;loop++){
4759 const TValue*tm;
4760 if(ttistable(t)){
4761 Table*h=hvalue(t);
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);
4766 h->flags=0;
4767 luaC_barriert(L,h,val);
4768 return;
4769 }
4770 }
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);
4775 return;
4776 }
4777 setobj(L,&temp,tm);
4778 t=&temp;
4779 }
4780 luaG_runerror(L,"loop in settable");
4781 }
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);
4785 if(ttisnil(tm))
4786 tm=luaT_gettmbyobj(L,p2,event);
4787 if(ttisnil(tm))return 0;
4788 callTMres(L,res,tm,p1,p2);
4789 return 1;
4790 }
4791 static const TValue*get_compTM(lua_State*L,Table*mt1,Table*mt2,
4792 TMS event){
4793 const TValue*tm1=fasttm(L,mt1,event);
4794 const TValue*tm2;
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))
4800 return tm1;
4801 return NULL;
4802 }
4803 static int call_orderTM(lua_State*L,const TValue*p1,const TValue*p2,
4804 TMS event){
4805 const TValue*tm1=luaT_gettmbyobj(L,p1,event);
4806 const TValue*tm2;
4807 if(ttisnil(tm1))return-1;
4808 tm2=luaT_gettmbyobj(L,p2,event);
4809 if(!luaO_rawequalObj(tm1,tm2))
4810 return-1;
4811 callTMres(L,L->top,tm1,p1,p2);
4812 return!l_isfalse(L->top);
4813 }
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;
4819 for(;;){
4820 int temp=strcoll(l,r);
4821 if(temp!=0)return temp;
4822 else{
4823 size_t len=strlen(l);
4824 if(len==lr)
4825 return(len==ll)?0:1;
4826 else if(len==ll)
4827 return-1;
4828 len++;
4829 l+=len;ll-=len;r+=len;lr-=len;
4830 }
4831 }
4832 }
4833 static int luaV_lessthan(lua_State*L,const TValue*l,const TValue*r){
4834 int res;
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)
4842 return res;
4843 return luaG_ordererror(L,l,r);
4844 }
4845 static int lessequal(lua_State*L,const TValue*l,const TValue*r){
4846 int res;
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)
4854 return res;
4855 else if((res=call_orderTM(L,r,l,TM_LT))!=-1)
4856 return!res;
4857 return luaG_ordererror(L,l,r);
4858 }
4859 static int luaV_equalval(lua_State*L,const TValue*t1,const TValue*t2){
4860 const TValue*tm;
4861 switch(ttype(t1)){
4862 case 0:return 1;
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);
4866 case 7:{
4867 if(uvalue(t1)==uvalue(t2))return 1;
4868 tm=get_compTM(L,uvalue(t1)->metatable,uvalue(t2)->metatable,
4869 TM_EQ);
4870 break;
4871 }
4872 case 5:{
4873 if(hvalue(t1)==hvalue(t2))return 1;
4874 tm=get_compTM(L,hvalue(t1)->metatable,hvalue(t2)->metatable,TM_EQ);
4875 break;
4876 }
4877 default:return gcvalue(t1)==gcvalue(t2);
4878 }
4879 if(tm==NULL)return 0;
4880 callTMres(L,L->top,tm,t1,t2);
4881 return!l_isfalse(L->top);
4882 }
4883 static void luaV_concat(lua_State*L,int total,int last){
4884 do{
4885 StkId top=L->base+last+1;
4886 int n=2;
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);
4892 else{
4893 size_t tl=tsvalue(top-1)->len;
4894 char*buffer;
4895 int i;
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");
4899 tl+=l;
4900 }
4901 buffer=luaZ_openspace(L,&G(L)->buff,tl);
4902 tl=0;
4903 for(i=n;i>0;i--){
4904 size_t l=tsvalue(top-i)->len;
4905 memcpy(buffer+tl,svalue(top-i),l);
4906 tl+=l;
4907 }
4908 setsvalue(L,top-n,luaS_newlstr(L,buffer,tl));
4909 }
4910 total-=n-1;
4911 last-=n-1;
4912 }while(total>1);
4913 }
4914 static void Arith(lua_State*L,StkId ra,const TValue*rb,
4915 const TValue*rc,TMS op){
4916 TValue tempb,tempc;
4917 const TValue*b,*c;
4918 if((b=luaV_tonumber(rb,&tempb))!=NULL&&
4919 (c=luaV_tonumber(rc,&tempc))!=NULL){
4920 lua_Number nb=nvalue(b),nc=nvalue(c);
4921 switch(op){
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;
4929 default:break;
4930 }
4931 }
4932 else if(!call_binTM(L,rb,rc,ra,op))
4933 luaG_aritherror(L,rb,rc);
4934 }
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){
4945 LClosure*cl;
4946 StkId base;
4947 TValue*k;
4948 const Instruction*pc;
4949 reentry:
4950 pc=L->savedpc;
4951 cl=&clvalue(L->ci->func)->l;
4952 base=L->base;
4953 k=cl->p->k;
4954 for(;;){
4955 const Instruction i=*pc++;
4956 StkId ra;
4957 ra=RA(i);
4958 switch(GET_OPCODE(i)){
4959 case OP_MOVE:{
4960 setobj(L,ra,RB(i));
4961 continue;
4962 }
4963 case OP_LOADK:{
4964 setobj(L,ra,KBx(i));
4965 continue;
4966 }
4967 case OP_LOADBOOL:{
4968 setbvalue(ra,GETARG_B(i));
4969 if(GETARG_C(i))pc++;
4970 continue;
4971 }
4972 case OP_LOADNIL:{
4973 TValue*rb=RB(i);
4974 do{
4975 setnilvalue(rb--);
4976 }while(rb>=ra);
4977 continue;
4978 }
4979 case OP_GETUPVAL:{
4980 int b=GETARG_B(i);
4981 setobj(L,ra,cl->upvals[b]->v);
4982 continue;
4983 }
4984 case OP_GETGLOBAL:{
4985 TValue g;
4986 TValue*rb=KBx(i);
4987 sethvalue(L,&g,cl->env);
4988 Protect(luaV_gettable(L,&g,rb,ra));
4989 continue;
4990 }
4991 case OP_GETTABLE:{
4992 Protect(luaV_gettable(L,RB(i),RKC(i),ra));
4993 continue;
4994 }
4995 case OP_SETGLOBAL:{
4996 TValue g;
4997 sethvalue(L,&g,cl->env);
4998 Protect(luaV_settable(L,&g,KBx(i),ra));
4999 continue;
5000 }
5001 case OP_SETUPVAL:{
5002 UpVal*uv=cl->upvals[GETARG_B(i)];
5003 setobj(L,uv->v,ra);
5004 luaC_barrier(L,uv,ra);
5005 continue;
5006 }
5007 case OP_SETTABLE:{
5008 Protect(luaV_settable(L,ra,RKB(i),RKC(i)));
5009 continue;
5010 }
5011 case OP_NEWTABLE:{
5012 int b=GETARG_B(i);
5013 int c=GETARG_C(i);
5014 sethvalue(L,ra,luaH_new(L,luaO_fb2int(b),luaO_fb2int(c)));
5015 Protect(luaC_checkGC(L));
5016 continue;
5017 }
5018 case OP_SELF:{
5019 StkId rb=RB(i);
5020 setobj(L,ra+1,rb);
5021 Protect(luaV_gettable(L,rb,RKC(i),ra));
5022 continue;
5023 }
5024 case OP_ADD:{
5025 arith_op(luai_numadd,TM_ADD);
5026 continue;
5027 }
5028 case OP_SUB:{
5029 arith_op(luai_numsub,TM_SUB);
5030 continue;
5031 }
5032 case OP_MUL:{
5033 arith_op(luai_nummul,TM_MUL);
5034 continue;
5035 }
5036 case OP_DIV:{
5037 arith_op(luai_numdiv,TM_DIV);
5038 continue;
5039 }
5040 case OP_MOD:{
5041 arith_op(luai_nummod,TM_MOD);
5042 continue;
5043 }
5044 case OP_POW:{
5045 arith_op(luai_numpow,TM_POW);
5046 continue;
5047 }
5048 case OP_UNM:{
5049 TValue*rb=RB(i);
5050 if(ttisnumber(rb)){
5051 lua_Number nb=nvalue(rb);
5052 setnvalue(ra,luai_numunm(nb));
5053 }
5054 else{
5055 Protect(Arith(L,ra,rb,rb,TM_UNM));
5056 }
5057 continue;
5058 }
5059 case OP_NOT:{
5060 int res=l_isfalse(RB(i));
5061 setbvalue(ra,res);
5062 continue;
5063 }
5064 case OP_LEN:{
5065 const TValue*rb=RB(i);
5066 switch(ttype(rb)){
5067 case 5:{
5068 setnvalue(ra,cast_num(luaH_getn(hvalue(rb))));
5069 break;
5070 }
5071 case 4:{
5072 setnvalue(ra,cast_num(tsvalue(rb)->len));
5073 break;
5074 }
5075 default:{
5076 Protect(
5077 if(!call_binTM(L,rb,(&luaO_nilobject_),ra,TM_LEN))
5078 luaG_typeerror(L,rb,"get length of");
5079 )
5080 }
5081 }
5082 continue;
5083 }
5084 case OP_CONCAT:{
5085 int b=GETARG_B(i);
5086 int c=GETARG_C(i);
5087 Protect(luaV_concat(L,c-b+1,c);luaC_checkGC(L));
5088 setobj(L,RA(i),base+b);
5089 continue;
5090 }
5091 case OP_JMP:{
5092 dojump(L,pc,GETARG_sBx(i));
5093 continue;
5094 }
5095 case OP_EQ:{
5096 TValue*rb=RKB(i);
5097 TValue*rc=RKC(i);
5098 Protect(
5099 if(equalobj(L,rb,rc)==GETARG_A(i))
5100 dojump(L,pc,GETARG_sBx(*pc));
5101 )
5102 pc++;
5103 continue;
5104 }
5105 case OP_LT:{
5106 Protect(
5107 if(luaV_lessthan(L,RKB(i),RKC(i))==GETARG_A(i))
5108 dojump(L,pc,GETARG_sBx(*pc));
5109 )
5110 pc++;
5111 continue;
5112 }
5113 case OP_LE:{
5114 Protect(
5115 if(lessequal(L,RKB(i),RKC(i))==GETARG_A(i))
5116 dojump(L,pc,GETARG_sBx(*pc));
5117 )
5118 pc++;
5119 continue;
5120 }
5121 case OP_TEST:{
5122 if(l_isfalse(ra)!=GETARG_C(i))
5123 dojump(L,pc,GETARG_sBx(*pc));
5124 pc++;
5125 continue;
5126 }
5127 case OP_TESTSET:{
5128 TValue*rb=RB(i);
5129 if(l_isfalse(rb)!=GETARG_C(i)){
5130 setobj(L,ra,rb);
5131 dojump(L,pc,GETARG_sBx(*pc));
5132 }
5133 pc++;
5134 continue;
5135 }
5136 case OP_CALL:{
5137 int b=GETARG_B(i);
5138 int nresults=GETARG_C(i)-1;
5139 if(b!=0)L->top=ra+b;
5140 L->savedpc=pc;
5141 switch(luaD_precall(L,ra,nresults)){
5142 case 0:{
5143 nexeccalls++;
5144 goto reentry;
5145 }
5146 case 1:{
5147 if(nresults>=0)L->top=L->ci->top;
5148 base=L->base;
5149 continue;
5150 }
5151 default:{
5152 return;
5153 }
5154 }
5155 }
5156 case OP_TAILCALL:{
5157 int b=GETARG_B(i);
5158 if(b!=0)L->top=ra+b;
5159 L->savedpc=pc;
5160 switch(luaD_precall(L,ra,(-1))){
5161 case 0:{
5162 CallInfo*ci=L->ci-1;
5163 int aux;
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;
5172 ci->tailcalls++;
5173 L->ci--;
5174 goto reentry;
5175 }
5176 case 1:{
5177 base=L->base;
5178 continue;
5179 }
5180 default:{
5181 return;
5182 }
5183 }
5184 }
5185 case OP_RETURN:{
5186 int b=GETARG_B(i);
5187 if(b!=0)L->top=ra+b-1;
5188 if(L->openupval)luaF_close(L,base);
5189 L->savedpc=pc;
5190 b=luaD_poscall(L,ra);
5191 if(--nexeccalls==0)
5192 return;
5193 else{
5194 if(b)L->top=L->ci->top;
5195 goto reentry;
5196 }
5197 }
5198 case OP_FORLOOP:{
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));
5205 setnvalue(ra,idx);
5206 setnvalue(ra+3,idx);
5207 }
5208 continue;
5209 }
5210 case OP_FORPREP:{
5211 const TValue*init=ra;
5212 const TValue*plimit=ra+1;
5213 const TValue*pstep=ra+2;
5214 L->savedpc=pc;
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));
5223 continue;
5224 }
5225 case OP_TFORLOOP:{
5226 StkId cb=ra+3;
5227 setobj(L,cb+2,ra+2);
5228 setobj(L,cb+1,ra+1);
5229 setobj(L,cb,ra);
5230 L->top=cb+3;
5231 Protect(luaD_call(L,cb,GETARG_C(i)));
5232 L->top=L->ci->top;
5233 cb=RA(i)+3;
5234 if(!ttisnil(cb)){
5235 setobj(L,cb-1,cb);
5236 dojump(L,pc,GETARG_sBx(*pc));
5237 }
5238 pc++;
5239 continue;
5240 }
5241 case OP_SETLIST:{
5242 int n=GETARG_B(i);
5243 int c=GETARG_C(i);
5244 int last;
5245 Table*h;
5246 if(n==0){
5247 n=cast_int(L->top-ra)-1;
5248 L->top=L->ci->top;
5249 }
5250 if(c==0)c=cast_int(*pc++);
5251 runtime_check(L,ttistable(ra));
5252 h=hvalue(ra);
5253 last=((c-1)*50)+n;
5254 if(last>h->sizearray)
5255 luaH_resizearray(L,h,last);
5256 for(;n>0;n--){
5257 TValue*val=ra+n;
5258 setobj(L,luaH_setnum(L,h,last--),val);
5259 luaC_barriert(L,h,val);
5260 }
5261 continue;
5262 }
5263 case OP_CLOSE:{
5264 luaF_close(L,ra);
5265 continue;
5266 }
5267 case OP_CLOSURE:{
5268 Proto*p;
5269 Closure*ncl;
5270 int nup,j;
5271 p=cl->p->p[GETARG_Bx(i)];
5272 nup=p->nups;
5273 ncl=luaF_newLclosure(L,nup,cl->env);
5274 ncl->l.p=p;
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)];
5278 else{
5279 ncl->l.upvals[j]=luaF_findupval(L,base+GETARG_B(*pc));
5280 }
5281 }
5282 setclvalue(L,ra,ncl);
5283 Protect(luaC_checkGC(L));
5284 continue;
5285 }
5286 case OP_VARARG:{
5287 int b=GETARG_B(i)-1;
5288 int j;
5289 CallInfo*ci=L->ci;
5290 int n=cast_int(ci->base-ci->func)-cl->p->numparams-1;
5291 if(b==(-1)){
5292 Protect(luaD_checkstack(L,n));
5293 ra=RA(i);
5294 b=n;
5295 L->top=ra+n;
5296 }
5297 for(j=0;j<b;j++){
5298 if(j<n){
5299 setobj(L,ra+j,ci->base-n+j);
5300 }
5301 else{
5302 setnilvalue(ra+j);
5303 }
5304 }
5305 continue;
5306 }
5307 }
5308 }
5309 }
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){
5314 if(idx>0){
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_));
5318 else return o;
5319 }
5320 else if(idx>(-10000)){
5321 luai_apicheck(L,idx!=0&&-idx<=L->top-L->base);
5322 return L->top+idx;
5323 }
5324 else switch(idx){
5325 case(-10000):return registry(L);
5326 case(-10001):{
5327 Closure*func=curr_func(L);
5328 sethvalue(L,&L->env,func->c.env);
5329 return&L->env;
5330 }
5331 case(-10002):return gt(L);
5332 default:{
5333 Closure*func=curr_func(L);
5334 idx=(-10002)-idx;
5335 return(idx<=func->c.nupvalues)
5336 ?&func->c.upvalue[idx-1]
5337 :cast(TValue*,(&luaO_nilobject_));
5338 }
5339 }
5340 }
5341 static Table*getcurrenv(lua_State*L){
5342 if(L->ci==L->base_ci)
5343 return hvalue(gt(L));
5344 else{
5345 Closure*func=curr_func(L);
5346 return func->c.env;
5347 }
5348 }
5349 static int lua_checkstack(lua_State*L,int size){
5350 int res=1;
5351 if(size>8000||(L->top-L->base+size)>8000)
5352 res=0;
5353 else if(size>0){
5354 luaD_checkstack(L,size);
5355 if(L->ci->top<L->top+size)
5356 L->ci->top=L->top+size;
5357 }
5358 return res;
5359 }
5360 static lua_CFunction lua_atpanic(lua_State*L,lua_CFunction panicf){
5361 lua_CFunction old;
5362 old=G(L)->panic;
5363 G(L)->panic=panicf;
5364 return old;
5365 }
5366 static int lua_gettop(lua_State*L){
5367 return cast_int(L->top-L->base);
5368 }
5369 static void lua_settop(lua_State*L,int idx){
5370 if(idx>=0){
5371 luai_apicheck(L,idx<=L->stack_last-L->base);
5372 while(L->top<L->base+idx)
5373 setnilvalue(L->top++);
5374 L->top=L->base+idx;
5375 }
5376 else{
5377 luai_apicheck(L,-(idx+1)<=(L->top-L->base));
5378 L->top+=idx+1;
5379 }
5380 }
5381 static void lua_remove(lua_State*L,int idx){
5382 StkId p;
5383 p=index2adr(L,idx);
5384 api_checkvalidindex(L,p);
5385 while(++p<L->top)setobj(L,p-1,p);
5386 L->top--;
5387 }
5388 static void lua_insert(lua_State*L,int idx){
5389 StkId p;
5390 StkId q;
5391 p=index2adr(L,idx);
5392 api_checkvalidindex(L,p);
5393 for(q=L->top;q>p;q--)setobj(L,q,q-1);
5394 setobj(L,p,L->top);
5395 }
5396 static void lua_replace(lua_State*L,int idx){
5397 StkId o;
5398 if(idx==(-10001)&&L->ci==L->base_ci)
5399 luaG_runerror(L,"no calling environment");
5400 api_checknelems(L,1);
5401 o=index2adr(L,idx);
5402 api_checkvalidindex(L,o);
5403 if(idx==(-10001)){
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);
5408 }
5409 else{
5410 setobj(L,o,L->top-1);
5411 if(idx<(-10002))
5412 luaC_barrier(L,curr_func(L),L->top-1);
5413 }
5414 L->top--;
5415 }
5416 static void lua_pushvalue(lua_State*L,int idx){
5417 setobj(L,L->top,index2adr(L,idx));
5418 api_incr_top(L);
5419 }
5420 static int lua_type(lua_State*L,int idx){
5421 StkId o=index2adr(L,idx);
5422 return(o==(&luaO_nilobject_))?(-1):ttype(o);
5423 }
5424 static const char*lua_typename(lua_State*L,int t){
5425 UNUSED(L);
5426 return(t==(-1))?"no value":luaT_typenames[t];
5427 }
5428 static int lua_iscfunction(lua_State*L,int idx){
5429 StkId o=index2adr(L,idx);
5430 return iscfunction(o);
5431 }
5432 static int lua_isnumber(lua_State*L,int idx){
5433 TValue n;
5434 const TValue*o=index2adr(L,idx);
5435 return tonumber(o,&n);
5436 }
5437 static int lua_isstring(lua_State*L,int idx){
5438 int t=lua_type(L,idx);
5439 return(t==4||t==3);
5440 }
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);
5446 }
5447 static int lua_lessthan(lua_State*L,int index1,int index2){
5448 StkId o1,o2;
5449 int i;
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);
5454 return i;
5455 }
5456 static lua_Number lua_tonumber(lua_State*L,int idx){
5457 TValue n;
5458 const TValue*o=index2adr(L,idx);
5459 if(tonumber(o,&n))
5460 return nvalue(o);
5461 else
5462 return 0;
5463 }
5464 static lua_Integer lua_tointeger(lua_State*L,int idx){
5465 TValue n;
5466 const TValue*o=index2adr(L,idx);
5467 if(tonumber(o,&n)){
5468 lua_Integer res;
5469 lua_Number num=nvalue(o);
5470 lua_number2integer(res,num);
5471 return res;
5472 }
5473 else
5474 return 0;
5475 }
5476 static int lua_toboolean(lua_State*L,int idx){
5477 const TValue*o=index2adr(L,idx);
5478 return!l_isfalse(o);
5479 }
5480 static const char*lua_tolstring(lua_State*L,int idx,size_t*len){
5481 StkId o=index2adr(L,idx);
5482 if(!ttisstring(o)){
5483 if(!luaV_tostring(L,o)){
5484 if(len!=NULL)*len=0;
5485 return NULL;
5486 }
5487 luaC_checkGC(L);
5488 o=index2adr(L,idx);
5489 }
5490 if(len!=NULL)*len=tsvalue(o)->len;
5491 return svalue(o);
5492 }
5493 static size_t lua_objlen(lua_State*L,int idx){
5494 StkId o=index2adr(L,idx);
5495 switch(ttype(o)){
5496 case 4:return tsvalue(o)->len;
5497 case 7:return uvalue(o)->len;
5498 case 5:return luaH_getn(hvalue(o));
5499 case 3:{
5500 size_t l;
5501 l=(luaV_tostring(L,o)?tsvalue(o)->len:0);
5502 return l;
5503 }
5504 default:return 0;
5505 }
5506 }
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;
5510 }
5511 static void*lua_touserdata(lua_State*L,int idx){
5512 StkId o=index2adr(L,idx);
5513 switch(ttype(o)){
5514 case 7:return(rawuvalue(o)+1);
5515 case 2:return pvalue(o);
5516 default:return NULL;
5517 }
5518 }
5519 static void lua_pushnil(lua_State*L){
5520 setnilvalue(L->top);
5521 api_incr_top(L);
5522 }
5523 static void lua_pushnumber(lua_State*L,lua_Number n){
5524 setnvalue(L->top,n);
5525 api_incr_top(L);
5526 }
5527 static void lua_pushinteger(lua_State*L,lua_Integer n){
5528 setnvalue(L->top,cast_num(n));
5529 api_incr_top(L);
5530 }
5531 static void lua_pushlstring(lua_State*L,const char*s,size_t len){
5532 luaC_checkGC(L);
5533 setsvalue(L,L->top,luaS_newlstr(L,s,len));
5534 api_incr_top(L);
5535 }
5536 static void lua_pushstring(lua_State*L,const char*s){
5537 if(s==NULL)
5538 lua_pushnil(L);
5539 else
5540 lua_pushlstring(L,s,strlen(s));
5541 }
5542 static const char*lua_pushvfstring(lua_State*L,const char*fmt,
5543 va_list argp){
5544 const char*ret;
5545 luaC_checkGC(L);
5546 ret=luaO_pushvfstring(L,fmt,argp);
5547 return ret;
5548 }
5549 static const char*lua_pushfstring(lua_State*L,const char*fmt,...){
5550 const char*ret;
5551 va_list argp;
5552 luaC_checkGC(L);
5553 va_start(argp,fmt);
5554 ret=luaO_pushvfstring(L,fmt,argp);
5555 va_end(argp);
5556 return ret;
5557 }
5558 static void lua_pushcclosure(lua_State*L,lua_CFunction fn,int n){
5559 Closure*cl;
5560 luaC_checkGC(L);
5561 api_checknelems(L,n);
5562 cl=luaF_newCclosure(L,n,getcurrenv(L));
5563 cl->c.f=fn;
5564 L->top-=n;
5565 while(n--)
5566 setobj(L,&cl->c.upvalue[n],L->top+n);
5567 setclvalue(L,L->top,cl);
5568 api_incr_top(L);
5569 }
5570 static void lua_pushboolean(lua_State*L,int b){
5571 setbvalue(L->top,(b!=0));
5572 api_incr_top(L);
5573 }
5574 static int lua_pushthread(lua_State*L){
5575 setthvalue(L,L->top,L);
5576 api_incr_top(L);
5577 return(G(L)->mainthread==L);
5578 }
5579 static void lua_gettable(lua_State*L,int idx){
5580 StkId t;
5581 t=index2adr(L,idx);
5582 api_checkvalidindex(L,t);
5583 luaV_gettable(L,t,L->top-1,L->top-1);
5584 }
5585 static void lua_getfield(lua_State*L,int idx,const char*k){
5586 StkId t;
5587 TValue key;
5588 t=index2adr(L,idx);
5589 api_checkvalidindex(L,t);
5590 setsvalue(L,&key,luaS_new(L,k));
5591 luaV_gettable(L,t,&key,L->top);
5592 api_incr_top(L);
5593 }
5594 static void lua_rawget(lua_State*L,int idx){
5595 StkId t;
5596 t=index2adr(L,idx);
5597 luai_apicheck(L,ttistable(t));
5598 setobj(L,L->top-1,luaH_get(hvalue(t),L->top-1));
5599 }
5600 static void lua_rawgeti(lua_State*L,int idx,int n){
5601 StkId o;
5602 o=index2adr(L,idx);
5603 luai_apicheck(L,ttistable(o));
5604 setobj(L,L->top,luaH_getnum(hvalue(o),n));
5605 api_incr_top(L);
5606 }
5607 static void lua_createtable(lua_State*L,int narray,int nrec){
5608 luaC_checkGC(L);
5609 sethvalue(L,L->top,luaH_new(L,narray,nrec));
5610 api_incr_top(L);
5611 }
5612 static int lua_getmetatable(lua_State*L,int objindex){
5613 const TValue*obj;
5614 Table*mt=NULL;
5615 int res;
5616 obj=index2adr(L,objindex);
5617 switch(ttype(obj)){
5618 case 5:
5619 mt=hvalue(obj)->metatable;
5620 break;
5621 case 7:
5622 mt=uvalue(obj)->metatable;
5623 break;
5624 default:
5625 mt=G(L)->mt[ttype(obj)];
5626 break;
5627 }
5628 if(mt==NULL)
5629 res=0;
5630 else{
5631 sethvalue(L,L->top,mt);
5632 api_incr_top(L);
5633 res=1;
5634 }
5635 return res;
5636 }
5637 static void lua_getfenv(lua_State*L,int idx){
5638 StkId o;
5639 o=index2adr(L,idx);
5640 api_checkvalidindex(L,o);
5641 switch(ttype(o)){
5642 case 6:
5643 sethvalue(L,L->top,clvalue(o)->c.env);
5644 break;
5645 case 7:
5646 sethvalue(L,L->top,uvalue(o)->env);
5647 break;
5648 case 8:
5649 setobj(L,L->top,gt(thvalue(o)));
5650 break;
5651 default:
5652 setnilvalue(L->top);
5653 break;
5654 }
5655 api_incr_top(L);
5656 }
5657 static void lua_settable(lua_State*L,int idx){
5658 StkId t;
5659 api_checknelems(L,2);
5660 t=index2adr(L,idx);
5661 api_checkvalidindex(L,t);
5662 luaV_settable(L,t,L->top-2,L->top-1);
5663 L->top-=2;
5664 }
5665 static void lua_setfield(lua_State*L,int idx,const char*k){
5666 StkId t;
5667 TValue key;
5668 api_checknelems(L,1);
5669 t=index2adr(L,idx);
5670 api_checkvalidindex(L,t);
5671 setsvalue(L,&key,luaS_new(L,k));
5672 luaV_settable(L,t,&key,L->top-1);
5673 L->top--;
5674 }
5675 static void lua_rawset(lua_State*L,int idx){
5676 StkId t;
5677 api_checknelems(L,2);
5678 t=index2adr(L,idx);
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);
5682 L->top-=2;
5683 }
5684 static void lua_rawseti(lua_State*L,int idx,int n){
5685 StkId o;
5686 api_checknelems(L,1);
5687 o=index2adr(L,idx);
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);
5691 L->top--;
5692 }
5693 static int lua_setmetatable(lua_State*L,int objindex){
5694 TValue*obj;
5695 Table*mt;
5696 api_checknelems(L,1);
5697 obj=index2adr(L,objindex);
5698 api_checkvalidindex(L,obj);
5699 if(ttisnil(L->top-1))
5700 mt=NULL;
5701 else{
5702 luai_apicheck(L,ttistable(L->top-1));
5703 mt=hvalue(L->top-1);
5704 }
5705 switch(ttype(obj)){
5706 case 5:{
5707 hvalue(obj)->metatable=mt;
5708 if(mt)
5709 luaC_objbarriert(L,hvalue(obj),mt);
5710 break;
5711 }
5712 case 7:{
5713 uvalue(obj)->metatable=mt;
5714 if(mt)
5715 luaC_objbarrier(L,rawuvalue(obj),mt);
5716 break;
5717 }
5718 default:{
5719 G(L)->mt[ttype(obj)]=mt;
5720 break;
5721 }
5722 }
5723 L->top--;
5724 return 1;
5725 }
5726 static int lua_setfenv(lua_State*L,int idx){
5727 StkId o;
5728 int res=1;
5729 api_checknelems(L,1);
5730 o=index2adr(L,idx);
5731 api_checkvalidindex(L,o);
5732 luai_apicheck(L,ttistable(L->top-1));
5733 switch(ttype(o)){
5734 case 6:
5735 clvalue(o)->c.env=hvalue(L->top-1);
5736 break;
5737 case 7:
5738 uvalue(o)->env=hvalue(L->top-1);
5739 break;
5740 case 8:
5741 sethvalue(L,gt(thvalue(o)),hvalue(L->top-1));
5742 break;
5743 default:
5744 res=0;
5745 break;
5746 }
5747 if(res)luaC_objbarrier(L,gcvalue(o),hvalue(L->top-1));
5748 L->top--;
5749 return res;
5750 }
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){
5754 StkId func;
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);
5760 }
5761 struct CallS{
5762 StkId func;
5763 int nresults;
5764 };
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);
5768 }
5769 static int lua_pcall(lua_State*L,int nargs,int nresults,int errfunc){
5770 struct CallS c;
5771 int status;
5772 ptrdiff_t func;
5773 api_checknelems(L,nargs+1);
5774 checkresults(L,nargs,nresults);
5775 if(errfunc==0)
5776 func=0;
5777 else{
5778 StkId o=index2adr(L,errfunc);
5779 api_checkvalidindex(L,o);
5780 func=savestack(L,o);
5781 }
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);
5786 return status;
5787 }
5788 static int lua_load(lua_State*L,lua_Reader reader,void*data,
5789 const char*chunkname){
5790 ZIO z;
5791 int status;
5792 if(!chunkname)chunkname="?";
5793 luaZ_init(L,&z,reader,data);
5794 status=luaD_protectedparser(L,&z,chunkname);
5795 return status;
5796 }
5797 static int lua_error(lua_State*L){
5798 api_checknelems(L,1);
5799 luaG_errormsg(L);
5800 return 0;
5801 }
5802 static int lua_next(lua_State*L,int idx){
5803 StkId t;
5804 int more;
5805 t=index2adr(L,idx);
5806 luai_apicheck(L,ttistable(t));
5807 more=luaH_next(L,hvalue(t),L->top-1);
5808 if(more){
5809 api_incr_top(L);
5810 }
5811 else
5812 L->top-=1;
5813 return more;
5814 }
5815 static void lua_concat(lua_State*L,int n){
5816 api_checknelems(L,n);
5817 if(n>=2){
5818 luaC_checkGC(L);
5819 luaV_concat(L,n,cast_int(L->top-L->base)-1);
5820 L->top-=(n-1);
5821 }
5822 else if(n==0){
5823 setsvalue(L,L->top,luaS_newlstr(L,"",0));
5824 api_incr_top(L);
5825 }
5826 }
5827 static void*lua_newuserdata(lua_State*L,size_t size){
5828 Udata*u;
5829 luaC_checkGC(L);
5830 u=luaS_newudata(L,size,getcurrenv(L));
5831 setuvalue(L,L->top,u);
5832 api_incr_top(L);
5833 return u+1;
5834 }
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{
5838 const char*name;
5839 lua_CFunction func;
5840 }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,
5845 size_t*l);
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,
5850 lua_Integer def);
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{
5863 char*p;
5864 int lvl;
5865 lua_State*L;
5866 char buffer[BUFSIZ];
5867 }luaL_Buffer;
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){
5872 lua_Debug ar;
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){
5877 narg--;
5878 if(narg==0)
5879 return luaL_error(L,"calling "LUA_QL("%s")" on bad self (%s)",
5880 ar.name,extramsg);
5881 }
5882 if(ar.name==NULL)
5883 ar.name="?";
5884 return luaL_error(L,"bad argument #%d to "LUA_QL("%s")" (%s)",
5885 narg,ar.name,extramsg);
5886 }
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);
5891 }
5892 static void tag_error(lua_State*L,int narg,int tag){
5893 luaL_typerror(L,narg,lua_typename(L,tag));
5894 }
5895 static void luaL_where(lua_State*L,int level){
5896 lua_Debug ar;
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);
5901 return;
5902 }
5903 }
5904 lua_pushliteral(L,"");
5905 }
5906 static int luaL_error(lua_State*L,const char*fmt,...){
5907 va_list argp;
5908 va_start(argp,fmt);
5909 luaL_where(L,1);
5910 lua_pushvfstring(L,fmt,argp);
5911 va_end(argp);
5912 lua_concat(L,2);
5913 return lua_error(L);
5914 }
5915 static int luaL_newmetatable(lua_State*L,const char*tname){
5916 lua_getfield(L,(-10000),tname);
5917 if(!lua_isnil(L,-1))
5918 return 0;
5919 lua_pop(L,1);
5920 lua_newtable(L);
5921 lua_pushvalue(L,-1);
5922 lua_setfield(L,(-10000),tname);
5923 return 1;
5924 }
5925 static void*luaL_checkudata(lua_State*L,int ud,const char*tname){
5926 void*p=lua_touserdata(L,ud);
5927 if(p!=NULL){
5928 if(lua_getmetatable(L,ud)){
5929 lua_getfield(L,(-10000),tname);
5930 if(lua_rawequal(L,-1,-2)){
5931 lua_pop(L,2);
5932 return p;
5933 }
5934 }
5935 }
5936 luaL_typerror(L,ud,tname);
5937 return NULL;
5938 }
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);
5942 }
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);
5946 }
5947 static void luaL_checkany(lua_State*L,int narg){
5948 if(lua_type(L,narg)==(-1))
5949 luaL_argerror(L,narg,"value expected");
5950 }
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);
5954 return s;
5955 }
5956 static const char*luaL_optlstring(lua_State*L,int narg,
5957 const char*def,size_t*len){
5958 if(lua_isnoneornil(L,narg)){
5959 if(len)
5960 *len=(def?strlen(def):0);
5961 return def;
5962 }
5963 else return luaL_checklstring(L,narg,len);
5964 }
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);
5969 return d;
5970 }
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);
5975 return d;
5976 }
5977 static lua_Integer luaL_optinteger(lua_State*L,int narg,
5978 lua_Integer def){
5979 return luaL_opt(L,luaL_checkinteger,narg,def);
5980 }
5981 static int luaL_getmetafield(lua_State*L,int obj,const char*event){
5982 if(!lua_getmetatable(L,obj))
5983 return 0;
5984 lua_pushstring(L,event);
5985 lua_rawget(L,-2);
5986 if(lua_isnil(L,-1)){
5987 lua_pop(L,2);
5988 return 0;
5989 }
5990 else{
5991 lua_remove(L,-2);
5992 return 1;
5993 }
5994 }
5995 static void luaL_register(lua_State*L,const char*libname,
5996 const luaL_Reg*l){
5997 luaI_openlib(L,libname,l,0);
5998 }
5999 static int libsize(const luaL_Reg*l){
6000 int size=0;
6001 for(;l->name;l++)size++;
6002 return size;
6003 }
6004 static void luaI_openlib(lua_State*L,const char*libname,
6005 const luaL_Reg*l,int nup){
6006 if(libname){
6007 int size=libsize(l);
6008 luaL_findtable(L,(-10000),"_LOADED",1);
6009 lua_getfield(L,-1,libname);
6010 if(!lua_istable(L,-1)){
6011 lua_pop(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);
6016 }
6017 lua_remove(L,-2);
6018 lua_insert(L,-(nup+1));
6019 }
6020 for(;l->name;l++){
6021 int i;
6022 for(i=0;i<nup;i++)
6023 lua_pushvalue(L,-nup);
6024 lua_pushcclosure(L,l->func,nup);
6025 lua_setfield(L,-(nup+2),l->name);
6026 }
6027 lua_pop(L,nup);
6028 }
6029 static const char*luaL_findtable(lua_State*L,int idx,
6030 const char*fname,int szhint){
6031 const char*e;
6032 lua_pushvalue(L,idx);
6033 do{
6034 e=strchr(fname,'.');
6035 if(e==NULL)e=fname+strlen(fname);
6036 lua_pushlstring(L,fname,e-fname);
6037 lua_rawget(L,-2);
6038 if(lua_isnil(L,-1)){
6039 lua_pop(L,1);
6040 lua_createtable(L,0,(*e=='.'?1:szhint));
6041 lua_pushlstring(L,fname,e-fname);
6042 lua_pushvalue(L,-2);
6043 lua_settable(L,-4);
6044 }
6045 else if(!lua_istable(L,-1)){
6046 lua_pop(L,2);
6047 return fname;
6048 }
6049 lua_remove(L,-2);
6050 fname=e+1;
6051 }while(*e=='.');
6052 return NULL;
6053 }
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);
6058 if(l==0)return 0;
6059 else{
6060 lua_pushlstring(B->L,B->buffer,l);
6061 B->p=B->buffer;
6062 B->lvl++;
6063 return 1;
6064 }
6065 }
6066 static void adjuststack(luaL_Buffer*B){
6067 if(B->lvl>1){
6068 lua_State*L=B->L;
6069 int toget=1;
6070 size_t toplen=lua_strlen(L,-1);
6071 do{
6072 size_t l=lua_strlen(L,-(toget+1));
6073 if(B->lvl-toget+1>=(20/2)||toplen>l){
6074 toplen+=l;
6075 toget++;
6076 }
6077 else break;
6078 }while(toget<B->lvl);
6079 lua_concat(L,toget);
6080 B->lvl=B->lvl-toget+1;
6081 }
6082 }
6083 static char*luaL_prepbuffer(luaL_Buffer*B){
6084 if(emptybuffer(B))
6085 adjuststack(B);
6086 return B->buffer;
6087 }
6088 static void luaL_addlstring(luaL_Buffer*B,const char*s,size_t l){
6089 while(l--)
6090 luaL_addchar(B,*s++);
6091 }
6092 static void luaL_pushresult(luaL_Buffer*B){
6093 emptybuffer(B);
6094 lua_concat(B->L,B->lvl);
6095 B->lvl=1;
6096 }
6097 static void luaL_addvalue(luaL_Buffer*B){
6098 lua_State*L=B->L;
6099 size_t vl;
6100 const char*s=lua_tolstring(L,-1,&vl);
6101 if(vl<=bufffree(B)){
6102 memcpy(B->p,s,vl);
6103 B->p+=vl;
6104 lua_pop(L,1);
6105 }
6106 else{
6107 if(emptybuffer(B))
6108 lua_insert(L,-2);
6109 B->lvl++;
6110 adjuststack(B);
6111 }
6112 }
6113 static void luaL_buffinit(lua_State*L,luaL_Buffer*B){
6114 B->L=L;
6115 B->p=B->buffer;
6116 B->lvl=0;
6117 }
6118 typedef struct LoadF{
6119 int extraline;
6120 FILE*f;
6121 char buff[BUFSIZ];
6122 }LoadF;
6123 static const char*getF(lua_State*L,void*ud,size_t*size){
6124 LoadF*lf=(LoadF*)ud;
6125 (void)L;
6126 if(lf->extraline){
6127 lf->extraline=0;
6128 *size=1;
6129 return"\n";
6130 }
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;
6134 }
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);
6140 return(5+1);
6141 }
6142 static int luaL_loadfile(lua_State*L,const char*filename){
6143 LoadF lf;
6144 int status,readstatus;
6145 int c;
6146 int fnameindex=lua_gettop(L)+1;
6147 lf.extraline=0;
6148 if(filename==NULL){
6149 lua_pushliteral(L,"=stdin");
6150 lf.f=stdin;
6151 }
6152 else{
6153 lua_pushfstring(L,"@%s",filename);
6154 lf.f=fopen(filename,"r");
6155 if(lf.f==NULL)return errfile(L,"open",fnameindex);
6156 }
6157 c=getc(lf.f);
6158 if(c=='#'){
6159 lf.extraline=1;
6160 while((c=getc(lf.f))!=EOF&&c!='\n');
6161 if(c=='\n')c=getc(lf.f);
6162 }
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]);
6167 lf.extraline=0;
6168 }
6169 ungetc(c,lf.f);
6170 status=lua_load(L,getF,&lf,lua_tostring(L,-1));
6171 readstatus=ferror(lf.f);
6172 if(filename)fclose(lf.f);
6173 if(readstatus){
6174 lua_settop(L,fnameindex);
6175 return errfile(L,"read",fnameindex);
6176 }
6177 lua_remove(L,fnameindex);
6178 return status;
6179 }
6180 typedef struct LoadS{
6181 const char*s;
6182 size_t size;
6183 }LoadS;
6184 static const char*getS(lua_State*L,void*ud,size_t*size){
6185 LoadS*ls=(LoadS*)ud;
6186 (void)L;
6187 if(ls->size==0)return NULL;
6188 *size=ls->size;
6189 ls->size=0;
6190 return ls->s;
6191 }
6192 static int luaL_loadbuffer(lua_State*L,const char*buff,size_t size,
6193 const char*name){
6194 LoadS ls;
6195 ls.s=buff;
6196 ls.size=size;
6197 return lua_load(L,getS,&ls,name);
6198 }
6199 static void*l_alloc(void*ud,void*ptr,size_t osize,size_t nsize){
6200 (void)ud;
6201 (void)osize;
6202 if(nsize==0){
6203 free(ptr);
6204 return NULL;
6205 }
6206 else
6207 return realloc(ptr,nsize);
6208 }
6209 static int panic(lua_State*L){
6210 (void)L;
6211 fprintf(stderr,"PANIC: unprotected error in call to Lua API (%s)\n",
6212 lua_tostring(L,-1));
6213 return 0;
6214 }
6215 static lua_State*luaL_newstate(void){
6216 lua_State*L=lua_newstate(l_alloc,NULL);
6217 if(L)lua_atpanic(L,&panic);
6218 return L;
6219 }
6220 static int luaB_tonumber(lua_State*L){
6221 int base=luaL_optint(L,2,10);
6222 if(base==10){
6223 luaL_checkany(L,1);
6224 if(lua_isnumber(L,1)){
6225 lua_pushnumber(L,lua_tonumber(L,1));
6226 return 1;
6227 }
6228 }
6229 else{
6230 const char*s1=luaL_checkstring(L,1);
6231 char*s2;
6232 unsigned long n;
6233 luaL_argcheck(L,2<=base&&base<=36,2,"base out of range");
6234 n=strtoul(s1,&s2,base);
6235 if(s1!=s2){
6236 while(isspace((unsigned char)(*s2)))s2++;
6237 if(*s2=='\0'){
6238 lua_pushnumber(L,(lua_Number)n);
6239 return 1;
6240 }
6241 }
6242 }
6243 lua_pushnil(L);
6244 return 1;
6245 }
6246 static int luaB_error(lua_State*L){
6247 int level=luaL_optint(L,2,1);
6248 lua_settop(L,1);
6249 if(lua_isstring(L,1)&&level>0){
6250 luaL_where(L,level);
6251 lua_pushvalue(L,1);
6252 lua_concat(L,2);
6253 }
6254 return lua_error(L);
6255 }
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");
6263 lua_settop(L,2);
6264 lua_setmetatable(L,1);
6265 return 1;
6266 }
6267 static void getfunc(lua_State*L,int opt){
6268 if(lua_isfunction(L,1))lua_pushvalue(L,1);
6269 else{
6270 lua_Debug ar;
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);
6276 if(lua_isnil(L,-1))
6277 luaL_error(L,"no function environment for tail call at level %d",
6278 level);
6279 }
6280 }
6281 static int luaB_setfenv(lua_State*L){
6282 luaL_checktype(L,2,5);
6283 getfunc(L,0);
6284 lua_pushvalue(L,2);
6285 if(lua_isnumber(L,1)&&lua_tonumber(L,1)==0){
6286 lua_pushthread(L);
6287 lua_insert(L,-2);
6288 lua_setfenv(L,-2);
6289 return 0;
6290 }
6291 else if(lua_iscfunction(L,-2)||lua_setfenv(L,-2)==0)
6292 luaL_error(L,
6293 LUA_QL("setfenv")" cannot change environment of given object");
6294 return 1;
6295 }
6296 static int luaB_rawget(lua_State*L){
6297 luaL_checktype(L,1,5);
6298 luaL_checkany(L,2);
6299 lua_settop(L,2);
6300 lua_rawget(L,1);
6301 return 1;
6302 }
6303 static int luaB_type(lua_State*L){
6304 luaL_checkany(L,1);
6305 lua_pushstring(L,luaL_typename(L,1));
6306 return 1;
6307 }
6308 static int luaB_next(lua_State*L){
6309 luaL_checktype(L,1,5);
6310 lua_settop(L,2);
6311 if(lua_next(L,1))
6312 return 2;
6313 else{
6314 lua_pushnil(L);
6315 return 1;
6316 }
6317 }
6318 static int luaB_pairs(lua_State*L){
6319 luaL_checktype(L,1,5);
6320 lua_pushvalue(L,lua_upvalueindex(1));
6321 lua_pushvalue(L,1);
6322 lua_pushnil(L);
6323 return 3;
6324 }
6325 static int ipairsaux(lua_State*L){
6326 int i=luaL_checkint(L,2);
6327 luaL_checktype(L,1,5);
6328 i++;
6329 lua_pushinteger(L,i);
6330 lua_rawgeti(L,1,i);
6331 return(lua_isnil(L,-1))?0:2;
6332 }
6333 static int luaB_ipairs(lua_State*L){
6334 luaL_checktype(L,1,5);
6335 lua_pushvalue(L,lua_upvalueindex(1));
6336 lua_pushvalue(L,1);
6337 lua_pushinteger(L,0);
6338 return 3;
6339 }
6340 static int load_aux(lua_State*L,int status){
6341 if(status==0)
6342 return 1;
6343 else{
6344 lua_pushnil(L);
6345 lua_insert(L,-2);
6346 return 2;
6347 }
6348 }
6349 static int luaB_loadstring(lua_State*L){
6350 size_t 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));
6354 }
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));
6358 }
6359 static int luaB_assert(lua_State*L){
6360 luaL_checkany(L,1);
6361 if(!lua_toboolean(L,1))
6362 return luaL_error(L,"%s",luaL_optstring(L,2,"assertion failed!"));
6363 return lua_gettop(L);
6364 }
6365 static int luaB_unpack(lua_State*L){
6366 int i,e,n;
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));
6370 if(i>e)return 0;
6371 n=e-i+1;
6372 if(n<=0||!lua_checkstack(L,n))
6373 return luaL_error(L,"too many results to unpack");
6374 lua_rawgeti(L,1,i);
6375 while(i++<e)
6376 lua_rawgeti(L,1,i);
6377 return n;
6378 }
6379 static int luaB_pcall(lua_State*L){
6380 int status;
6381 luaL_checkany(L,1);
6382 status=lua_pcall(L,lua_gettop(L)-1,(-1),0);
6383 lua_pushboolean(L,(status==0));
6384 lua_insert(L,1);
6385 return lua_gettop(L);
6386 }
6387 static int luaB_newproxy(lua_State*L){
6388 lua_settop(L,1);
6389 lua_newuserdata(L,0);
6390 if(lua_toboolean(L,1)==0)
6391 return 1;
6392 else if(lua_isboolean(L,1)){
6393 lua_newtable(L);
6394 lua_pushvalue(L,-1);
6395 lua_pushboolean(L,1);
6396 lua_rawset(L,lua_upvalueindex(1));
6397 }
6398 else{
6399 int validproxy=0;
6400 if(lua_getmetatable(L,1)){
6401 lua_rawget(L,lua_upvalueindex(1));
6402 validproxy=lua_toboolean(L,-1);
6403 lua_pop(L,1);
6404 }
6405 luaL_argcheck(L,validproxy,1,"boolean or proxy expected");
6406 lua_getmetatable(L,1);
6407 }
6408 lua_setmetatable(L,2);
6409 return 1;
6410 }
6411 static const luaL_Reg base_funcs[]={
6412 {"assert",luaB_assert},
6413 {"error",luaB_error},
6414 {"loadfile",luaB_loadfile},
6415 {"loadstring",luaB_loadstring},
6416 {"next",luaB_next},
6417 {"pcall",luaB_pcall},
6418 {"rawget",luaB_rawget},
6419 {"setfenv",luaB_setfenv},
6420 {"setmetatable",luaB_setmetatable},
6421 {"tonumber",luaB_tonumber},
6422 {"type",luaB_type},
6423 {"unpack",luaB_unpack},
6424 {NULL,NULL}
6425 };
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);
6431 }
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");
6447 }
6448 static int luaopen_base(lua_State*L){
6449 base_open(L);
6450 return 1;
6451 }
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;
6455 int pos;
6456 switch(lua_gettop(L)){
6457 case 2:{
6458 pos=e;
6459 break;
6460 }
6461 case 3:{
6462 int i;
6463 pos=luaL_checkint(L,2);
6464 if(pos>e)e=pos;
6465 for(i=e;i>pos;i--){
6466 lua_rawgeti(L,1,i-1);
6467 lua_rawseti(L,1,i);
6468 }
6469 break;
6470 }
6471 default:{
6472 return luaL_error(L,"wrong number of arguments to "LUA_QL("insert"));
6473 }
6474 }
6475 luaL_setn(L,1,e);
6476 lua_rawseti(L,1,pos);
6477 return 0;
6478 }
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))
6483 return 0;
6484 luaL_setn(L,1,e-1);
6485 lua_rawgeti(L,1,pos);
6486 for(;pos<e;pos++){
6487 lua_rawgeti(L,1,pos+1);
6488 lua_rawseti(L,1,pos);
6489 }
6490 lua_pushnil(L);
6491 lua_rawseti(L,1,e);
6492 return 1;
6493 }
6494 static void addfield(lua_State*L,luaL_Buffer*b,int i){
6495 lua_rawgeti(L,1,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);
6499 luaL_addvalue(b);
6500 }
6501 static int tconcat(lua_State*L){
6502 luaL_Buffer b;
6503 size_t lsep;
6504 int i,last;
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);
6510 for(;i<last;i++){
6511 addfield(L,&b,i);
6512 luaL_addlstring(&b,sep,lsep);
6513 }
6514 if(i==last)
6515 addfield(L,&b,i);
6516 luaL_pushresult(&b);
6517 return 1;
6518 }
6519 static void set2(lua_State*L,int i,int j){
6520 lua_rawseti(L,1,i);
6521 lua_rawseti(L,1,j);
6522 }
6523 static int sort_comp(lua_State*L,int a,int b){
6524 if(!lua_isnil(L,2)){
6525 int res;
6526 lua_pushvalue(L,2);
6527 lua_pushvalue(L,a-1);
6528 lua_pushvalue(L,b-2);
6529 lua_call(L,2,1);
6530 res=lua_toboolean(L,-1);
6531 lua_pop(L,1);
6532 return res;
6533 }
6534 else
6535 return lua_lessthan(L,a,b);
6536 }
6537 static void auxsort(lua_State*L,int l,int u){
6538 while(l<u){
6539 int i,j;
6540 lua_rawgeti(L,1,l);
6541 lua_rawgeti(L,1,u);
6542 if(sort_comp(L,-1,-2))
6543 set2(L,l,u);
6544 else
6545 lua_pop(L,2);
6546 if(u-l==1)break;
6547 i=(l+u)/2;
6548 lua_rawgeti(L,1,i);
6549 lua_rawgeti(L,1,l);
6550 if(sort_comp(L,-2,-1))
6551 set2(L,i,l);
6552 else{
6553 lua_pop(L,1);
6554 lua_rawgeti(L,1,u);
6555 if(sort_comp(L,-1,-2))
6556 set2(L,i,u);
6557 else
6558 lua_pop(L,2);
6559 }
6560 if(u-l==2)break;
6561 lua_rawgeti(L,1,i);
6562 lua_pushvalue(L,-1);
6563 lua_rawgeti(L,1,u-1);
6564 set2(L,i,u-1);
6565 i=l;j=u-1;
6566 for(;;){
6567 while(lua_rawgeti(L,1,++i),sort_comp(L,-1,-2)){
6568 if(i>u)luaL_error(L,"invalid order function for sorting");
6569 lua_pop(L,1);
6570 }
6571 while(lua_rawgeti(L,1,--j),sort_comp(L,-3,-1)){
6572 if(j<l)luaL_error(L,"invalid order function for sorting");
6573 lua_pop(L,1);
6574 }
6575 if(j<i){
6576 lua_pop(L,3);
6577 break;
6578 }
6579 set2(L,i,j);
6580 }
6581 lua_rawgeti(L,1,u-1);
6582 lua_rawgeti(L,1,i);
6583 set2(L,u-1,i);
6584 if(i-l<u-i){
6585 j=l;i=i-1;l=i+2;
6586 }
6587 else{
6588 j=i+1;i=u;u=j-2;
6589 }
6590 auxsort(L,j,i);
6591 }
6592 }
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);
6598 lua_settop(L,2);
6599 auxsort(L,1,n);
6600 return 0;
6601 }
6602 static const luaL_Reg tab_funcs[]={
6603 {"concat",tconcat},
6604 {"insert",tinsert},
6605 {"remove",tremove},
6606 {"sort",sort},
6607 {NULL,NULL}
6608 };
6609 static int luaopen_table(lua_State*L){
6610 luaL_register(L,"table",tab_funcs);
6611 return 1;
6612 }
6613 static const char*const fnames[]={"input","output"};
6614 static int pushresult(lua_State*L,int i,const char*filename){
6615 int en=errno;
6616 if(i){
6617 lua_pushboolean(L,1);
6618 return 1;
6619 }
6620 else{
6621 lua_pushnil(L);
6622 if(filename)
6623 lua_pushfstring(L,"%s: %s",filename,strerror(en));
6624 else
6625 lua_pushfstring(L,"%s",strerror(en));
6626 lua_pushinteger(L,en);
6627 return 3;
6628 }
6629 }
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));
6633 }
6634 #define tofilep(L)((FILE**)luaL_checkudata(L,1,"FILE*"))
6635 static int io_type(lua_State*L){
6636 void*ud;
6637 luaL_checkany(L,1);
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))
6641 lua_pushnil(L);
6642 else if(*((FILE**)ud)==NULL)
6643 lua_pushliteral(L,"closed file");
6644 else
6645 lua_pushliteral(L,"file");
6646 return 1;
6647 }
6648 static FILE*tofile(lua_State*L){
6649 FILE**f=tofilep(L);
6650 if(*f==NULL)
6651 luaL_error(L,"attempt to use a closed file");
6652 return*f;
6653 }
6654 static FILE**newfile(lua_State*L){
6655 FILE**pf=(FILE**)lua_newuserdata(L,sizeof(FILE*));
6656 *pf=NULL;
6657 luaL_getmetatable(L,"FILE*");
6658 lua_setmetatable(L,-2);
6659 return pf;
6660 }
6661 static int io_noclose(lua_State*L){
6662 lua_pushnil(L);
6663 lua_pushliteral(L,"cannot close standard file");
6664 return 2;
6665 }
6666 static int io_pclose(lua_State*L){
6667 FILE**p=tofilep(L);
6668 int ok=lua_pclose(L,*p);
6669 *p=NULL;
6670 return pushresult(L,ok,NULL);
6671 }
6672 static int io_fclose(lua_State*L){
6673 FILE**p=tofilep(L);
6674 int ok=(fclose(*p)==0);
6675 *p=NULL;
6676 return pushresult(L,ok,NULL);
6677 }
6678 static int aux_close(lua_State*L){
6679 lua_getfenv(L,1);
6680 lua_getfield(L,-1,"__close");
6681 return(lua_tocfunction(L,-1))(L);
6682 }
6683 static int io_close(lua_State*L){
6684 if(lua_isnone(L,1))
6685 lua_rawgeti(L,(-10001),2);
6686 tofile(L);
6687 return aux_close(L);
6688 }
6689 static int io_gc(lua_State*L){
6690 FILE*f=*tofilep(L);
6691 if(f!=NULL)
6692 aux_close(L);
6693 return 0;
6694 }
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;
6701 }
6702 static FILE*getiofile(lua_State*L,int findex){
6703 FILE*f;
6704 lua_rawgeti(L,(-10001),findex);
6705 f=*(FILE**)lua_touserdata(L,-1);
6706 if(f==NULL)
6707 luaL_error(L,"standard %s file is closed",fnames[findex-1]);
6708 return f;
6709 }
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);
6713 if(filename){
6714 FILE**pf=newfile(L);
6715 *pf=fopen(filename,mode);
6716 if(*pf==NULL)
6717 fileerror(L,1,filename);
6718 }
6719 else{
6720 tofile(L);
6721 lua_pushvalue(L,1);
6722 }
6723 lua_rawseti(L,(-10001),f);
6724 }
6725 lua_rawgeti(L,(-10001),f);
6726 return 1;
6727 }
6728 static int io_input(lua_State*L){
6729 return g_iofile(L,1,"r");
6730 }
6731 static int io_output(lua_State*L){
6732 return g_iofile(L,2,"w");
6733 }
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);
6739 }
6740 static int f_lines(lua_State*L){
6741 tofile(L);
6742 aux_lines(L,1,0);
6743 return 1;
6744 }
6745 static int io_lines(lua_State*L){
6746 if(lua_isnoneornil(L,1)){
6747 lua_rawgeti(L,(-10001),1);
6748 return f_lines(L);
6749 }
6750 else{
6751 const char*filename=luaL_checkstring(L,1);
6752 FILE**pf=newfile(L);
6753 *pf=fopen(filename,"r");
6754 if(*pf==NULL)
6755 fileerror(L,1,filename);
6756 aux_lines(L,lua_gettop(L),1);
6757 return 1;
6758 }
6759 }
6760 static int read_number(lua_State*L,FILE*f){
6761 lua_Number d;
6762 if(fscanf(f,"%lf",&d)==1){
6763 lua_pushnumber(L,d);
6764 return 1;
6765 }
6766 else{
6767 lua_pushnil(L);
6768 return 0;
6769 }
6770 }
6771 static int test_eof(lua_State*L,FILE*f){
6772 int c=getc(f);
6773 ungetc(c,f);
6774 lua_pushlstring(L,NULL,0);
6775 return(c!=EOF);
6776 }
6777 static int read_line(lua_State*L,FILE*f){
6778 luaL_Buffer b;
6779 luaL_buffinit(L,&b);
6780 for(;;){
6781 size_t l;
6782 char*p=luaL_prepbuffer(&b);
6783 if(fgets(p,BUFSIZ,f)==NULL){
6784 luaL_pushresult(&b);
6785 return(lua_objlen(L,-1)>0);
6786 }
6787 l=strlen(p);
6788 if(l==0||p[l-1]!='\n')
6789 luaL_addsize(&b,l);
6790 else{
6791 luaL_addsize(&b,l-1);
6792 luaL_pushresult(&b);
6793 return 1;
6794 }
6795 }
6796 }
6797 static int read_chars(lua_State*L,FILE*f,size_t n){
6798 size_t rlen;
6799 size_t nr;
6800 luaL_Buffer b;
6801 luaL_buffinit(L,&b);
6802 rlen=BUFSIZ;
6803 do{
6804 char*p=luaL_prepbuffer(&b);
6805 if(rlen>n)rlen=n;
6806 nr=fread(p,sizeof(char),rlen,f);
6807 luaL_addsize(&b,nr);
6808 n-=nr;
6809 }while(n>0&&nr==rlen);
6810 luaL_pushresult(&b);
6811 return(n==0||lua_objlen(L,-1)>0);
6812 }
6813 static int g_read(lua_State*L,FILE*f,int first){
6814 int nargs=lua_gettop(L)-1;
6815 int success;
6816 int n;
6817 clearerr(f);
6818 if(nargs==0){
6819 success=read_line(L,f);
6820 n=first+1;
6821 }
6822 else{
6823 luaL_checkstack(L,nargs+20,"too many arguments");
6824 success=1;
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);
6829 }
6830 else{
6831 const char*p=lua_tostring(L,n);
6832 luaL_argcheck(L,p&&p[0]=='*',n,"invalid option");
6833 switch(p[1]){
6834 case'n':
6835 success=read_number(L,f);
6836 break;
6837 case'l':
6838 success=read_line(L,f);
6839 break;
6840 case'a':
6841 read_chars(L,f,~((size_t)0));
6842 success=1;
6843 break;
6844 default:
6845 return luaL_argerror(L,n,"invalid format");
6846 }
6847 }
6848 }
6849 }
6850 if(ferror(f))
6851 return pushresult(L,0,NULL);
6852 if(!success){
6853 lua_pop(L,1);
6854 lua_pushnil(L);
6855 }
6856 return n-first;
6857 }
6858 static int io_read(lua_State*L){
6859 return g_read(L,getiofile(L,1),1);
6860 }
6861 static int f_read(lua_State*L){
6862 return g_read(L,tofile(L),2);
6863 }
6864 static int io_readline(lua_State*L){
6865 FILE*f=*(FILE**)lua_touserdata(L,lua_upvalueindex(1));
6866 int sucess;
6867 if(f==NULL)
6868 luaL_error(L,"file is already closed");
6869 sucess=read_line(L,f);
6870 if(ferror(f))
6871 return luaL_error(L,"%s",strerror(errno));
6872 if(sucess)return 1;
6873 else{
6874 if(lua_toboolean(L,lua_upvalueindex(2))){
6875 lua_settop(L,0);
6876 lua_pushvalue(L,lua_upvalueindex(1));
6877 aux_close(L);
6878 }
6879 return 0;
6880 }
6881 }
6882 static int g_write(lua_State*L,FILE*f,int arg){
6883 int nargs=lua_gettop(L)-1;
6884 int status=1;
6885 for(;nargs--;arg++){
6886 if(