opcode.c 30 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479
  1. /*
  2. ** opcode.c
  3. ** TecCGraf - PUC-Rio
  4. */
  5. char *rcs_opcode="$Id: opcode.c,v 4.15 1997/06/26 21:40:57 roberto Exp roberto $";
  6. #include <setjmp.h>
  7. #include <stdio.h>
  8. #include <string.h>
  9. #include <stdlib.h>
  10. #include "lualoc.h"
  11. #include "luadebug.h"
  12. #include "luamem.h"
  13. #include "opcode.h"
  14. #include "hash.h"
  15. #include "inout.h"
  16. #include "table.h"
  17. #include "lua.h"
  18. #include "fallback.h"
  19. #include "auxlib.h"
  20. #include "lex.h"
  21. #define tonumber(o) ((ttype(o) != LUA_T_NUMBER) && (lua_tonumber(o) != 0))
  22. #define tostring(o) ((ttype(o) != LUA_T_STRING) && (lua_tostring(o) != 0))
  23. #define STACK_SIZE 128
  24. #ifndef STACK_LIMIT
  25. #define STACK_LIMIT 6000
  26. #endif
  27. typedef int StkId; /* index to stack elements */
  28. static TObject initial_stack;
  29. static TObject *stackLimit = &initial_stack+1;
  30. static TObject *stack = &initial_stack;
  31. static TObject *top = &initial_stack;
  32. /* macros to convert from lua_Object to (TObject *) and back */
  33. #define Address(lo) ((lo)+stack-1)
  34. #define Ref(st) ((st)-stack+1)
  35. /* macro to increment stack top. There must be always an empty slot in
  36. * the stack
  37. */
  38. #define incr_top if (++top >= stackLimit) growstack()
  39. struct C_Lua_Stack {
  40. StkId base; /* when Lua calls C or C calls Lua, points to */
  41. /* the first slot after the last parameter. */
  42. StkId lua2C; /* points to first element of "array" lua2C */
  43. int num; /* size of "array" lua2C */
  44. };
  45. static struct C_Lua_Stack CLS_current = {0, 0, 0};
  46. static jmp_buf *errorJmp = NULL; /* current error recover point */
  47. /* Hooks */
  48. lua_LHFunction lua_linehook = NULL;
  49. lua_CHFunction lua_callhook = NULL;
  50. static StkId lua_execute (Byte *pc, StkId base);
  51. static void do_call (StkId base, int nResults);
  52. TObject *luaI_Address (lua_Object o)
  53. {
  54. return Address(o);
  55. }
  56. /*
  57. ** Init stack
  58. */
  59. static void lua_initstack (void)
  60. {
  61. Long maxstack = STACK_SIZE;
  62. stack = newvector(maxstack, TObject);
  63. stackLimit = stack+maxstack;
  64. top = stack;
  65. *(top++) = initial_stack;
  66. }
  67. /*
  68. ** Check stack overflow and, if necessary, realloc vector
  69. */
  70. #define lua_checkstack(nt) if ((nt) >= stackLimit) growstack()
  71. static void growstack (void)
  72. {
  73. if (stack == &initial_stack)
  74. lua_initstack();
  75. else
  76. {
  77. static int limit = STACK_LIMIT;
  78. StkId t = top-stack;
  79. Long stacksize = stackLimit - stack;
  80. stacksize = growvector(&stack, stacksize, TObject, stackEM, limit+100);
  81. stackLimit = stack+stacksize;
  82. top = stack + t;
  83. if (stacksize >= limit)
  84. {
  85. limit = stacksize;
  86. lua_error(stackEM);
  87. }
  88. }
  89. }
  90. /*
  91. ** Concatenate two given strings. Return the new string pointer.
  92. */
  93. static char *lua_strconc (char *l, char *r)
  94. {
  95. size_t nl = strlen(l);
  96. char *buffer = luaI_buffer(nl+strlen(r)+1);
  97. strcpy(buffer, l);
  98. strcpy(buffer+nl, r);
  99. return buffer;
  100. }
  101. /*
  102. ** Convert, if possible, to a number object.
  103. ** Return 0 if success, not 0 if error.
  104. */
  105. static int lua_tonumber (TObject *obj)
  106. {
  107. float t;
  108. char c;
  109. if (ttype(obj) != LUA_T_STRING)
  110. return 1;
  111. else if (sscanf(svalue(obj), "%f %c",&t, &c) == 1)
  112. {
  113. nvalue(obj) = t;
  114. ttype(obj) = LUA_T_NUMBER;
  115. return 0;
  116. }
  117. else
  118. return 2;
  119. }
  120. /*
  121. ** Convert, if possible, to a string ttype
  122. ** Return 0 in success or not 0 on error.
  123. */
  124. static int lua_tostring (TObject *obj)
  125. {
  126. if (ttype(obj) != LUA_T_NUMBER)
  127. return 1;
  128. else {
  129. char s[60];
  130. real f = nvalue(obj);
  131. int i;
  132. if ((real)(-MAX_INT) <= f && f <= (real)MAX_INT && (real)(i=(int)f) == f)
  133. sprintf (s, "%d", i);
  134. else
  135. sprintf (s, "%g", nvalue(obj));
  136. tsvalue(obj) = lua_createstring(s);
  137. ttype(obj) = LUA_T_STRING;
  138. return 0;
  139. }
  140. }
  141. /*
  142. ** Adjust stack. Set top to the given value, pushing NILs if needed.
  143. */
  144. static void adjust_top_aux (StkId newtop)
  145. {
  146. TObject *nt;
  147. lua_checkstack(stack+newtop);
  148. nt = stack+newtop; /* warning: previous call may change stack */
  149. while (top < nt) ttype(top++) = LUA_T_NIL;
  150. }
  151. #define adjust_top(newtop) { if (newtop <= top-stack) \
  152. top = stack+newtop; \
  153. else adjust_top_aux(newtop); }
  154. #define adjustC(nParams) adjust_top(CLS_current.base+nParams)
  155. static void checkCparams (int nParams)
  156. {
  157. if (top-stack < CLS_current.base+nParams)
  158. lua_error("API error - wrong number of arguments in C2lua stack");
  159. }
  160. /*
  161. ** Open a hole below "nelems" from the top.
  162. */
  163. static void open_stack (int nelems)
  164. {
  165. int i;
  166. for (i=0; i<nelems; i++)
  167. *(top-i) = *(top-i-1);
  168. incr_top;
  169. }
  170. static lua_Object put_luaObject (TObject *o)
  171. {
  172. open_stack((top-stack)-CLS_current.base);
  173. stack[CLS_current.base++] = *o;
  174. return CLS_current.base; /* this is +1 real position (see Ref) */
  175. }
  176. static lua_Object put_luaObjectonTop (void)
  177. {
  178. open_stack((top-stack)-CLS_current.base);
  179. stack[CLS_current.base++] = *(--top);
  180. return CLS_current.base; /* this is +1 real position (see Ref) */
  181. }
  182. lua_Object lua_pop (void)
  183. {
  184. checkCparams(1);
  185. return put_luaObjectonTop();
  186. }
  187. /*
  188. ** call Line hook
  189. */
  190. static void lineHook (int line)
  191. {
  192. struct C_Lua_Stack oldCLS = CLS_current;
  193. StkId old_top = CLS_current.lua2C = CLS_current.base = top-stack;
  194. CLS_current.num = 0;
  195. (*lua_linehook)(line);
  196. top = stack+old_top;
  197. CLS_current = oldCLS;
  198. }
  199. /*
  200. ** Call hook
  201. ** The function being called is in [stack+base-1]
  202. */
  203. static void callHook (StkId base, lua_Type type, int isreturn)
  204. {
  205. struct C_Lua_Stack oldCLS = CLS_current;
  206. StkId old_top = CLS_current.lua2C = CLS_current.base = top-stack;
  207. CLS_current.num = 0;
  208. if (isreturn)
  209. (*lua_callhook)(LUA_NOOBJECT, "(return)", 0);
  210. else
  211. {
  212. TObject *f = stack+base-1;
  213. if (type == LUA_T_MARK)
  214. (*lua_callhook)(Ref(f), f->value.tf->fileName, f->value.tf->lineDefined);
  215. else
  216. (*lua_callhook)(Ref(f), "(C)", -1);
  217. }
  218. top = stack+old_top;
  219. CLS_current = oldCLS;
  220. }
  221. /*
  222. ** Call a C function. CLS_current.base will point to the top of the stack,
  223. ** and CLS_current.num is the number of parameters. Returns an index
  224. ** to the first result from C.
  225. */
  226. static StkId callC (lua_CFunction func, StkId base)
  227. {
  228. struct C_Lua_Stack oldCLS = CLS_current;
  229. StkId firstResult;
  230. CLS_current.num = (top-stack) - base;
  231. /* incorporate parameters on the stack */
  232. CLS_current.lua2C = base;
  233. CLS_current.base = base+CLS_current.num; /* == top-stack */
  234. if (lua_callhook)
  235. callHook(base, LUA_T_CMARK, 0);
  236. (*func)();
  237. if (lua_callhook) /* func may have changed lua_callhook */
  238. callHook(base, LUA_T_CMARK, 1);
  239. firstResult = CLS_current.base;
  240. CLS_current = oldCLS;
  241. return firstResult;
  242. }
  243. static void callIM (TObject *f, int nParams, int nResults)
  244. {
  245. open_stack(nParams);
  246. *(top-nParams-1) = *f;
  247. do_call((top-stack)-nParams, nResults);
  248. }
  249. /*
  250. ** Call a function (C or Lua). The parameters must be on the stack,
  251. ** between [stack+base,top). The function to be called is at stack+base-1.
  252. ** When returns, the results are on the stack, between [stack+base-1,top).
  253. ** The number of results is nResults, unless nResults=MULT_RET.
  254. */
  255. static void do_call (StkId base, int nResults)
  256. {
  257. StkId firstResult;
  258. TObject *func = stack+base-1;
  259. int i;
  260. if (ttype(func) == LUA_T_CFUNCTION) {
  261. ttype(func) = LUA_T_CMARK;
  262. firstResult = callC(fvalue(func), base);
  263. }
  264. else if (ttype(func) == LUA_T_FUNCTION) {
  265. ttype(func) = LUA_T_MARK;
  266. firstResult = lua_execute(func->value.tf->code, base);
  267. }
  268. else { /* func is not a function */
  269. /* Check the tag method for invalid functions */
  270. TObject *im = luaI_getimbyObj(func, IM_FUNCTION);
  271. if (ttype(im) == LUA_T_NIL)
  272. lua_error("call expression not a function");
  273. open_stack((top-stack)-(base-1));
  274. stack[base-1] = *im;
  275. do_call(base, nResults);
  276. return;
  277. }
  278. /* adjust the number of results */
  279. if (nResults != MULT_RET)
  280. adjust_top(firstResult+nResults);
  281. /* move results to base-1 (to erase parameters and function) */
  282. base--;
  283. nResults = top - (stack+firstResult); /* actual number of results */
  284. for (i=0; i<nResults; i++)
  285. *(stack+base+i) = *(stack+firstResult+i);
  286. top -= firstResult-base;
  287. }
  288. /*
  289. ** Function to index a table. Receives the table at top-2 and the index
  290. ** at top-1.
  291. */
  292. static void pushsubscript (void)
  293. {
  294. TObject *im;
  295. if (ttype(top-2) != LUA_T_ARRAY) /* not a table, get "gettable" method */
  296. im = luaI_getimbyObj(top-2, IM_GETTABLE);
  297. else { /* object is a table... */
  298. int tg = (top-2)->value.a->htag;
  299. im = luaI_getim(tg, IM_GETTABLE);
  300. if (ttype(im) == LUA_T_NIL) { /* and does not have a "gettable" method */
  301. TObject *h = lua_hashget(avalue(top-2), top-1);
  302. if (h != NULL && ttype(h) != LUA_T_NIL) {
  303. --top;
  304. *(top-1) = *h;
  305. }
  306. else if (ttype(im=luaI_getim(tg, IM_INDEX)) != LUA_T_NIL)
  307. callIM(im, 2, 1);
  308. else {
  309. --top;
  310. ttype(top-1) = LUA_T_NIL;
  311. }
  312. return;
  313. }
  314. /* else it has a "gettable" method, go through to next command */
  315. }
  316. /* object is not a table, or it has a "gettable" method */
  317. if (ttype(im) != LUA_T_NIL)
  318. callIM(im, 2, 1);
  319. else
  320. lua_error("indexed expression not a table");
  321. }
  322. lua_Object lua_rawgettable (void)
  323. {
  324. checkCparams(2);
  325. if (ttype(top-2) != LUA_T_ARRAY)
  326. lua_error("indexed expression not a table in raw gettable");
  327. else {
  328. TObject *h = lua_hashget(avalue(top-2), top-1);
  329. --top;
  330. if (h != NULL)
  331. *(top-1) = *h;
  332. else
  333. ttype(top-1) = LUA_T_NIL;
  334. }
  335. return put_luaObjectonTop();
  336. }
  337. /*
  338. ** Function to store indexed based on values at the top
  339. ** mode = 0: raw store (without internal methods)
  340. ** mode = 1: normal store (with internal methods)
  341. ** mode = 2: "deep stack" store (with internal methods)
  342. */
  343. static void storesubscript (TObject *t, int mode)
  344. {
  345. TObject *im = (mode == 0) ? NULL : luaI_getimbyObj(t, IM_SETTABLE);
  346. if (ttype(t) == LUA_T_ARRAY && (im == NULL || ttype(im) == LUA_T_NIL)) {
  347. TObject *h = lua_hashdefine(avalue(t), t+1);
  348. *h = *(top-1);
  349. top -= (mode == 2) ? 1 : 3;
  350. }
  351. else { /* object is not a table, and/or has a specific "settable" method */
  352. if (im && ttype(im) != LUA_T_NIL) {
  353. if (mode == 2) {
  354. lua_checkstack(top+2);
  355. *(top+1) = *(top-1);
  356. *(top) = *(t+1);
  357. *(top-1) = *t;
  358. top += 2;
  359. }
  360. callIM(im, 3, 0);
  361. }
  362. else
  363. lua_error("indexed expression not a table");
  364. }
  365. }
  366. static void getglobal (Word n)
  367. {
  368. TObject *value = &lua_table[n].object;
  369. TObject *im = luaI_getimbyObj(value, IM_GETGLOBAL);
  370. if (ttype(im) == LUA_T_NIL) { /* default behavior */
  371. *top = *value;
  372. incr_top;
  373. }
  374. else {
  375. ttype(top) = LUA_T_STRING;
  376. tsvalue(top) = lua_table[n].varname;
  377. incr_top;
  378. *top = *value;
  379. incr_top;
  380. callIM(im, 2, 1);
  381. }
  382. }
  383. /*
  384. ** Traverse all objects on stack
  385. */
  386. void lua_travstack (int (*fn)(TObject *))
  387. {
  388. StkId i;
  389. for (i = (top-1)-stack; i>=0; i--)
  390. fn (stack+i);
  391. }
  392. /*
  393. ** Error messages and debug functions
  394. */
  395. static void lua_message (char *s)
  396. {
  397. TObject *im = luaI_geterrorim();
  398. if (ttype(im) != LUA_T_NIL) {
  399. lua_pushstring(s);
  400. callIM(im, 1, 0);
  401. }
  402. }
  403. /*
  404. ** Reports an error, and jumps up to the available recover label
  405. */
  406. void lua_error (char *s)
  407. {
  408. if (s) lua_message(s);
  409. if (errorJmp)
  410. longjmp(*errorJmp, 1);
  411. else
  412. {
  413. fprintf (stderr, "lua: exit(1). Unable to recover\n");
  414. exit(1);
  415. }
  416. }
  417. lua_Function lua_stackedfunction (int level)
  418. {
  419. StkId i;
  420. for (i = (top-1)-stack; i>=0; i--)
  421. if (stack[i].ttype == LUA_T_MARK || stack[i].ttype == LUA_T_CMARK)
  422. if (level-- == 0)
  423. return Ref(stack+i);
  424. return LUA_NOOBJECT;
  425. }
  426. int lua_currentline (lua_Function func)
  427. {
  428. TObject *f = Address(func);
  429. return (f+1 < top && (f+1)->ttype == LUA_T_LINE) ? (f+1)->value.i : -1;
  430. }
  431. lua_Object lua_getlocal (lua_Function func, int local_number, char **name)
  432. {
  433. TObject *f = luaI_Address(func);
  434. *name = luaI_getlocalname(f->value.tf, local_number, lua_currentline(func));
  435. if (*name)
  436. {
  437. /* if "*name", there must be a LUA_T_LINE */
  438. /* therefore, f+2 points to function base */
  439. return Ref((f+2)+(local_number-1));
  440. }
  441. else
  442. return LUA_NOOBJECT;
  443. }
  444. int lua_setlocal (lua_Function func, int local_number)
  445. {
  446. TObject *f = Address(func);
  447. char *name = luaI_getlocalname(f->value.tf, local_number, lua_currentline(func));
  448. checkCparams(1);
  449. --top;
  450. if (name)
  451. {
  452. /* if "name", there must be a LUA_T_LINE */
  453. /* therefore, f+2 points to function base */
  454. *((f+2)+(local_number-1)) = *top;
  455. return 1;
  456. }
  457. else
  458. return 0;
  459. }
  460. /*
  461. ** Call the function at CLS_current.base, and incorporate results on
  462. ** the Lua2C structure.
  463. */
  464. static void do_callinc (int nResults)
  465. {
  466. StkId base = CLS_current.base;
  467. do_call(base+1, nResults);
  468. CLS_current.lua2C = base; /* position of the new results */
  469. CLS_current.num = (top-stack) - base; /* number of results */
  470. CLS_current.base = base + CLS_current.num; /* incorporate results on stack */
  471. }
  472. static void do_unprotectedrun (lua_CFunction f, int nParams, int nResults)
  473. {
  474. StkId base = (top-stack)-nParams;
  475. open_stack(nParams);
  476. stack[base].ttype = LUA_T_CFUNCTION;
  477. stack[base].value.f = f;
  478. do_call(base+1, nResults);
  479. }
  480. /*
  481. ** Execute a protected call. Assumes that function is at CLS_current.base and
  482. ** parameters are on top of it. Leave nResults on the stack.
  483. */
  484. static int do_protectedrun (int nResults)
  485. {
  486. jmp_buf myErrorJmp;
  487. int status;
  488. struct C_Lua_Stack oldCLS = CLS_current;
  489. jmp_buf *oldErr = errorJmp;
  490. errorJmp = &myErrorJmp;
  491. if (setjmp(myErrorJmp) == 0) {
  492. do_callinc(nResults);
  493. status = 0;
  494. }
  495. else { /* an error occurred: restore CLS_current and top */
  496. CLS_current = oldCLS;
  497. top = stack+CLS_current.base;
  498. status = 1;
  499. }
  500. errorJmp = oldErr;
  501. return status;
  502. }
  503. int luaI_dorun (TFunc *tf)
  504. {
  505. int status;
  506. adjustC(1); /* one slot for the pseudo-function */
  507. stack[CLS_current.base].ttype = LUA_T_FUNCTION;
  508. stack[CLS_current.base].value.tf = tf;
  509. status = do_protectedrun(MULT_RET);
  510. return status;
  511. }
  512. int lua_domain (void)
  513. {
  514. TFunc tf;
  515. int status;
  516. jmp_buf myErrorJmp;
  517. jmp_buf *oldErr = errorJmp;
  518. errorJmp = &myErrorJmp;
  519. luaI_initTFunc(&tf);
  520. if (setjmp(myErrorJmp) == 0) {
  521. lua_parse(&tf);
  522. status = 0;
  523. }
  524. else {
  525. adjustC(0); /* erase extra slot */
  526. status = 1;
  527. }
  528. if (status == 0)
  529. status = luaI_dorun(&tf);
  530. errorJmp = oldErr;
  531. luaI_free(tf.code);
  532. return status;
  533. }
  534. /*
  535. ** Execute the given lua function. Return 0 on success or 1 on error.
  536. */
  537. int lua_callfunction (lua_Object function)
  538. {
  539. if (function == LUA_NOOBJECT)
  540. return 1;
  541. else
  542. {
  543. open_stack((top-stack)-CLS_current.base);
  544. stack[CLS_current.base] = *Address(function);
  545. return do_protectedrun (MULT_RET);
  546. }
  547. }
  548. lua_Object lua_gettagmethod (int tag, char *event)
  549. {
  550. lua_pushnumber(tag);
  551. lua_pushstring(event);
  552. do_unprotectedrun(luaI_gettagmethod, 2, 1);
  553. return put_luaObjectonTop();
  554. }
  555. lua_Object lua_settagmethod (int tag, char *event)
  556. {
  557. TObject newmethod;
  558. checkCparams(1);
  559. newmethod = *(--top);
  560. lua_pushnumber(tag);
  561. lua_pushstring(event);
  562. *top = newmethod; incr_top;
  563. do_unprotectedrun(luaI_settagmethod, 3, 1);
  564. return put_luaObjectonTop();
  565. }
  566. lua_Object lua_seterrormethod (void)
  567. {
  568. checkCparams(1);
  569. do_unprotectedrun(luaI_seterrormethod, 1, 1);
  570. return put_luaObjectonTop();
  571. }
  572. /*
  573. ** API: receives on the stack the table and the index.
  574. ** returns the value.
  575. */
  576. lua_Object lua_gettable (void)
  577. {
  578. checkCparams(2);
  579. pushsubscript();
  580. return put_luaObjectonTop();
  581. }
  582. #define MAX_C_BLOCKS 10
  583. static int numCblocks = 0;
  584. static struct C_Lua_Stack Cblocks[MAX_C_BLOCKS];
  585. /*
  586. ** API: starts a new block
  587. */
  588. void lua_beginblock (void)
  589. {
  590. if (numCblocks >= MAX_C_BLOCKS)
  591. lua_error("`lua_beginblock': too many nested blocks");
  592. Cblocks[numCblocks] = CLS_current;
  593. numCblocks++;
  594. }
  595. /*
  596. ** API: ends a block
  597. */
  598. void lua_endblock (void)
  599. {
  600. --numCblocks;
  601. CLS_current = Cblocks[numCblocks];
  602. adjustC(0);
  603. }
  604. void lua_settag (int tag)
  605. {
  606. checkCparams(1);
  607. luaI_settag(tag, --top);
  608. }
  609. /*
  610. ** API: receives on the stack the table, the index, and the new value.
  611. */
  612. void lua_settable (void)
  613. {
  614. checkCparams(3);
  615. storesubscript(top-3, 1);
  616. }
  617. void lua_rawsettable (void)
  618. {
  619. checkCparams(3);
  620. storesubscript(top-3, 0);
  621. }
  622. /*
  623. ** API: creates a new table
  624. */
  625. lua_Object lua_createtable (void)
  626. {
  627. TObject o;
  628. avalue(&o) = lua_createarray(0);
  629. ttype(&o) = LUA_T_ARRAY;
  630. return put_luaObject(&o);
  631. }
  632. /*
  633. ** Get a parameter, returning the object handle or LUA_NOOBJECT on error.
  634. ** 'number' must be 1 to get the first parameter.
  635. */
  636. lua_Object lua_lua2C (int number)
  637. {
  638. if (number <= 0 || number > CLS_current.num) return LUA_NOOBJECT;
  639. /* Ref(stack+(CLS_current.lua2C+number-1)) ==
  640. stack+(CLS_current.lua2C+number-1)-stack+1 == */
  641. return CLS_current.lua2C+number;
  642. }
  643. int lua_isnil (lua_Object o)
  644. {
  645. return (o!= LUA_NOOBJECT) && (ttype(Address(o)) == LUA_T_NIL);
  646. }
  647. int lua_istable (lua_Object o)
  648. {
  649. return (o!= LUA_NOOBJECT) && (ttype(Address(o)) == LUA_T_ARRAY);
  650. }
  651. int lua_isuserdata (lua_Object o)
  652. {
  653. return (o!= LUA_NOOBJECT) && (ttype(Address(o)) == LUA_T_USERDATA);
  654. }
  655. int lua_iscfunction (lua_Object o)
  656. {
  657. int t = lua_tag(o);
  658. return (t == LUA_T_CMARK) || (t == LUA_T_CFUNCTION);
  659. }
  660. int lua_isnumber (lua_Object o)
  661. {
  662. return (o!= LUA_NOOBJECT) && (tonumber(Address(o)) == 0);
  663. }
  664. int lua_isstring (lua_Object o)
  665. {
  666. int t = lua_tag(o);
  667. return (t == LUA_T_STRING) || (t == LUA_T_NUMBER);
  668. }
  669. int lua_isfunction (lua_Object o)
  670. {
  671. int t = lua_tag(o);
  672. return (t == LUA_T_FUNCTION) || (t == LUA_T_CFUNCTION) ||
  673. (t == LUA_T_MARK) || (t == LUA_T_CMARK);
  674. }
  675. /*
  676. ** Given an object handle, return its number value. On error, return 0.0.
  677. */
  678. real lua_getnumber (lua_Object object)
  679. {
  680. if (object == LUA_NOOBJECT) return 0.0;
  681. if (tonumber (Address(object))) return 0.0;
  682. else return (nvalue(Address(object)));
  683. }
  684. /*
  685. ** Given an object handle, return its string pointer. On error, return NULL.
  686. */
  687. char *lua_getstring (lua_Object object)
  688. {
  689. if (object == LUA_NOOBJECT || tostring (Address(object)))
  690. return NULL;
  691. else return (svalue(Address(object)));
  692. }
  693. void *lua_getuserdata (lua_Object object)
  694. {
  695. if (object == LUA_NOOBJECT || ttype(Address(object)) != LUA_T_USERDATA)
  696. return NULL;
  697. else return tsvalue(Address(object))->u.v;
  698. }
  699. /*
  700. ** Given an object handle, return its cfuntion pointer. On error, return NULL.
  701. */
  702. lua_CFunction lua_getcfunction (lua_Object object)
  703. {
  704. if (object == LUA_NOOBJECT || ((ttype(Address(object)) != LUA_T_CFUNCTION) &&
  705. (ttype(Address(object)) != LUA_T_CMARK)))
  706. return NULL;
  707. else return (fvalue(Address(object)));
  708. }
  709. lua_Object lua_getref (int ref)
  710. {
  711. TObject *o = luaI_getref(ref);
  712. if (o == NULL)
  713. return LUA_NOOBJECT;
  714. return put_luaObject(o);
  715. }
  716. int lua_ref (int lock)
  717. {
  718. checkCparams(1);
  719. return luaI_ref(--top, lock);
  720. }
  721. /*
  722. ** Get a global object.
  723. */
  724. lua_Object lua_getglobal (char *name)
  725. {
  726. getglobal(luaI_findsymbolbyname(name));
  727. return put_luaObjectonTop();
  728. }
  729. lua_Object lua_rawgetglobal (char *name)
  730. {
  731. return put_luaObject(&lua_table[luaI_findsymbolbyname(name)].object);
  732. }
  733. /*
  734. ** Store top of the stack at a global variable array field.
  735. */
  736. static void setglobal (Word n)
  737. {
  738. TObject *oldvalue = &lua_table[n].object;
  739. TObject *im = luaI_getimbyObj(oldvalue, IM_SETGLOBAL);
  740. if (ttype(im) == LUA_T_NIL) /* default behavior */
  741. s_object(n) = *(--top);
  742. else {
  743. TObject newvalue = *(top-1);
  744. ttype(top-1) = LUA_T_STRING;
  745. tsvalue(top-1) = lua_table[n].varname;
  746. *top = *oldvalue;
  747. incr_top;
  748. *top = newvalue;
  749. incr_top;
  750. callIM(im, 3, 0);
  751. }
  752. }
  753. void lua_setglobal (char *name)
  754. {
  755. checkCparams(1);
  756. setglobal(luaI_findsymbolbyname(name));
  757. }
  758. void lua_rawsetglobal (char *name)
  759. {
  760. Word n = luaI_findsymbolbyname(name);
  761. checkCparams(1);
  762. s_object(n) = *(--top);
  763. }
  764. /*
  765. ** Push a nil object
  766. */
  767. void lua_pushnil (void)
  768. {
  769. ttype(top) = LUA_T_NIL;
  770. incr_top;
  771. }
  772. /*
  773. ** Push an object (ttype=number) to stack.
  774. */
  775. void lua_pushnumber (real n)
  776. {
  777. ttype(top) = LUA_T_NUMBER; nvalue(top) = n;
  778. incr_top;
  779. }
  780. /*
  781. ** Push an object (ttype=string) to stack.
  782. */
  783. void lua_pushstring (char *s)
  784. {
  785. if (s == NULL)
  786. ttype(top) = LUA_T_NIL;
  787. else
  788. {
  789. tsvalue(top) = lua_createstring(s);
  790. ttype(top) = LUA_T_STRING;
  791. }
  792. incr_top;
  793. }
  794. /*
  795. ** Push an object (ttype=cfunction) to stack.
  796. */
  797. void lua_pushcfunction (lua_CFunction fn)
  798. {
  799. ttype(top) = LUA_T_CFUNCTION; fvalue(top) = fn;
  800. incr_top;
  801. }
  802. void lua_pushusertag (void *u, int tag)
  803. {
  804. if (tag < 0 && tag != LUA_ANYTAG)
  805. luaI_realtag(tag); /* error if tag is not valid */
  806. tsvalue(top) = luaI_createudata(u, tag);
  807. ttype(top) = LUA_T_USERDATA;
  808. incr_top;
  809. }
  810. /*
  811. ** Push an object on the stack.
  812. */
  813. void luaI_pushobject (TObject *o)
  814. {
  815. *top = *o;
  816. incr_top;
  817. }
  818. /*
  819. ** Push a lua_Object on stack.
  820. */
  821. void lua_pushobject (lua_Object o)
  822. {
  823. if (o == LUA_NOOBJECT)
  824. lua_error("API error - attempt to push a NOOBJECT");
  825. *top = *Address(o);
  826. if (ttype(top) == LUA_T_MARK) ttype(top) = LUA_T_FUNCTION;
  827. else if (ttype(top) == LUA_T_CMARK) ttype(top) = LUA_T_CFUNCTION;
  828. incr_top;
  829. }
  830. int lua_tag (lua_Object lo)
  831. {
  832. if (lo == LUA_NOOBJECT) return LUA_T_NIL;
  833. else {
  834. TObject *o = Address(lo);
  835. lua_Type t = ttype(o);
  836. if (t == LUA_T_USERDATA)
  837. return o->value.ts->tag;
  838. else if (t == LUA_T_ARRAY)
  839. return o->value.a->htag;
  840. else return t;
  841. }
  842. }
  843. void luaI_gcIM (TObject *o)
  844. {
  845. TObject *im = luaI_getimbyObj(o, IM_GC);
  846. if (ttype(im) != LUA_T_NIL) {
  847. *top = *o;
  848. incr_top;
  849. callIM(im, 1, 0);
  850. }
  851. }
  852. static void call_binTM (IMS event, char *msg)
  853. {
  854. TObject *im = luaI_getimbyObj(top-2, event); /* try first operand */
  855. if (ttype(im) == LUA_T_NIL) {
  856. im = luaI_getimbyObj(top-1, event); /* try second operand */
  857. if (ttype(im) == LUA_T_NIL) {
  858. im = luaI_getim(0, event); /* try a 'global' i.m. */
  859. if (ttype(im) == LUA_T_NIL)
  860. lua_error(msg);
  861. }
  862. }
  863. lua_pushstring(luaI_eventname[event]);
  864. callIM(im, 3, 1);
  865. }
  866. static void call_arith (IMS event)
  867. {
  868. call_binTM(event, "unexpected type at arithmetic operation");
  869. }
  870. static void comparison (lua_Type ttype_less, lua_Type ttype_equal,
  871. lua_Type ttype_great, IMS op)
  872. {
  873. TObject *l = top-2;
  874. TObject *r = top-1;
  875. int result;
  876. if (ttype(l) == LUA_T_NUMBER && ttype(r) == LUA_T_NUMBER)
  877. result = (nvalue(l) < nvalue(r)) ? -1 : (nvalue(l) == nvalue(r)) ? 0 : 1;
  878. else if (ttype(l) == LUA_T_STRING && ttype(r) == LUA_T_STRING)
  879. result = strcoll(svalue(l), svalue(r));
  880. else {
  881. call_binTM(op, "unexpected type at comparison");
  882. return;
  883. }
  884. top--;
  885. nvalue(top-1) = 1;
  886. ttype(top-1) = (result < 0) ? ttype_less :
  887. (result == 0) ? ttype_equal : ttype_great;
  888. }
  889. static void adjust_varargs (StkId first_extra_arg)
  890. {
  891. TObject arg;
  892. TObject *firstelem = stack+first_extra_arg;
  893. int nvararg = top-firstelem;
  894. int i;
  895. if (nvararg < 0) nvararg = 0;
  896. avalue(&arg) = lua_createarray(nvararg+1); /* +1 for field 'n' */
  897. ttype(&arg) = LUA_T_ARRAY;
  898. for (i=0; i<nvararg; i++) {
  899. TObject index;
  900. ttype(&index) = LUA_T_NUMBER;
  901. nvalue(&index) = i+1;
  902. *(lua_hashdefine(avalue(&arg), &index)) = *(firstelem+i);
  903. }
  904. /* store counter in field "n" */ {
  905. TObject index, extra;
  906. ttype(&index) = LUA_T_STRING;
  907. tsvalue(&index) = lua_createstring("n");
  908. ttype(&extra) = LUA_T_NUMBER;
  909. nvalue(&extra) = nvararg;
  910. *(lua_hashdefine(avalue(&arg), &index)) = extra;
  911. }
  912. adjust_top(first_extra_arg);
  913. *top = arg; incr_top;
  914. }
  915. /*
  916. ** Execute the given opcode, until a RET. Parameters are between
  917. ** [stack+base,top). Returns n such that the the results are between
  918. ** [stack+n,top).
  919. */
  920. static StkId lua_execute (Byte *pc, StkId base)
  921. {
  922. if (lua_callhook)
  923. callHook (base, LUA_T_MARK, 0);
  924. while (1)
  925. {
  926. OpCode opcode;
  927. switch (opcode = (OpCode)*pc++)
  928. {
  929. case PUSHNIL: ttype(top) = LUA_T_NIL; incr_top; break;
  930. case PUSH0: case PUSH1: case PUSH2:
  931. ttype(top) = LUA_T_NUMBER;
  932. nvalue(top) = opcode-PUSH0;
  933. incr_top;
  934. break;
  935. case PUSHBYTE:
  936. ttype(top) = LUA_T_NUMBER; nvalue(top) = *pc++; incr_top; break;
  937. case PUSHWORD:
  938. {
  939. Word w;
  940. get_word(w,pc);
  941. ttype(top) = LUA_T_NUMBER; nvalue(top) = w;
  942. incr_top;
  943. }
  944. break;
  945. case PUSHFLOAT:
  946. {
  947. real num;
  948. get_float(num,pc);
  949. ttype(top) = LUA_T_NUMBER; nvalue(top) = num;
  950. incr_top;
  951. }
  952. break;
  953. case PUSHSTRING:
  954. {
  955. Word w;
  956. get_word(w,pc);
  957. ttype(top) = LUA_T_STRING; tsvalue(top) = lua_constant[w];
  958. incr_top;
  959. }
  960. break;
  961. case PUSHFUNCTION:
  962. {
  963. TFunc *f;
  964. get_code(f,pc);
  965. luaI_insertfunction(f); /* may take part in GC */
  966. top->ttype = LUA_T_FUNCTION;
  967. top->value.tf = f;
  968. incr_top;
  969. }
  970. break;
  971. case PUSHLOCAL0: case PUSHLOCAL1: case PUSHLOCAL2:
  972. case PUSHLOCAL3: case PUSHLOCAL4: case PUSHLOCAL5:
  973. case PUSHLOCAL6: case PUSHLOCAL7: case PUSHLOCAL8:
  974. case PUSHLOCAL9:
  975. *top = *((stack+base) + (int)(opcode-PUSHLOCAL0)); incr_top; break;
  976. case PUSHLOCAL: *top = *((stack+base) + (*pc++)); incr_top; break;
  977. case PUSHGLOBAL:
  978. {
  979. Word w;
  980. get_word(w,pc);
  981. getglobal(w);
  982. }
  983. break;
  984. case PUSHINDEXED:
  985. pushsubscript();
  986. break;
  987. case PUSHSELF:
  988. {
  989. TObject receiver = *(top-1);
  990. Word w;
  991. get_word(w,pc);
  992. ttype(top) = LUA_T_STRING; tsvalue(top) = lua_constant[w];
  993. incr_top;
  994. pushsubscript();
  995. *top = receiver;
  996. incr_top;
  997. break;
  998. }
  999. case STORELOCAL0: case STORELOCAL1: case STORELOCAL2:
  1000. case STORELOCAL3: case STORELOCAL4: case STORELOCAL5:
  1001. case STORELOCAL6: case STORELOCAL7: case STORELOCAL8:
  1002. case STORELOCAL9:
  1003. *((stack+base) + (int)(opcode-STORELOCAL0)) = *(--top);
  1004. break;
  1005. case STORELOCAL: *((stack+base) + (*pc++)) = *(--top); break;
  1006. case STOREGLOBAL:
  1007. {
  1008. Word w;
  1009. get_word(w,pc);
  1010. setglobal(w);
  1011. }
  1012. break;
  1013. case STOREINDEXED0:
  1014. storesubscript(top-3, 1);
  1015. break;
  1016. case STOREINDEXED: {
  1017. int n = *pc++;
  1018. storesubscript(top-3-n, 2);
  1019. break;
  1020. }
  1021. case STORELIST0:
  1022. case STORELIST:
  1023. {
  1024. int m, n;
  1025. TObject *arr;
  1026. if (opcode == STORELIST0) m = 0;
  1027. else m = *(pc++) * FIELDS_PER_FLUSH;
  1028. n = *(pc++);
  1029. arr = top-n-1;
  1030. while (n)
  1031. {
  1032. ttype(top) = LUA_T_NUMBER; nvalue(top) = n+m;
  1033. *(lua_hashdefine (avalue(arr), top)) = *(top-1);
  1034. top--;
  1035. n--;
  1036. }
  1037. }
  1038. break;
  1039. case STORERECORD: /* opcode obsolete: supersed by STOREMAP */
  1040. {
  1041. int n = *(pc++);
  1042. TObject *arr = top-n-1;
  1043. while (n)
  1044. {
  1045. Word w;
  1046. get_word(w,pc);
  1047. ttype(top) = LUA_T_STRING; tsvalue(top) = lua_constant[w];
  1048. *(lua_hashdefine (avalue(arr), top)) = *(top-1);
  1049. top--;
  1050. n--;
  1051. }
  1052. }
  1053. break;
  1054. case STOREMAP: {
  1055. int n = *(pc++);
  1056. TObject *arr = top-(2*n)-1;
  1057. while (n--) {
  1058. *(lua_hashdefine (avalue(arr), top-2)) = *(top-1);
  1059. top-=2;
  1060. }
  1061. }
  1062. break;
  1063. case ADJUST0:
  1064. adjust_top(base);
  1065. break;
  1066. case ADJUST: {
  1067. StkId newtop = base + *(pc++);
  1068. adjust_top(newtop);
  1069. break;
  1070. }
  1071. case VARARGS:
  1072. adjust_varargs(base + *(pc++));
  1073. break;
  1074. case CREATEARRAY:
  1075. {
  1076. Word size;
  1077. get_word(size,pc);
  1078. avalue(top) = lua_createarray(size);
  1079. ttype(top) = LUA_T_ARRAY;
  1080. incr_top;
  1081. }
  1082. break;
  1083. case EQOP:
  1084. {
  1085. int res = lua_equalObj(top-2, top-1);
  1086. --top;
  1087. ttype(top-1) = res ? LUA_T_NUMBER : LUA_T_NIL;
  1088. nvalue(top-1) = 1;
  1089. }
  1090. break;
  1091. case LTOP:
  1092. comparison(LUA_T_NUMBER, LUA_T_NIL, LUA_T_NIL, IM_LT);
  1093. break;
  1094. case LEOP:
  1095. comparison(LUA_T_NUMBER, LUA_T_NUMBER, LUA_T_NIL, IM_LE);
  1096. break;
  1097. case GTOP:
  1098. comparison(LUA_T_NIL, LUA_T_NIL, LUA_T_NUMBER, IM_GT);
  1099. break;
  1100. case GEOP:
  1101. comparison(LUA_T_NIL, LUA_T_NUMBER, LUA_T_NUMBER, IM_GE);
  1102. break;
  1103. case ADDOP:
  1104. {
  1105. TObject *l = top-2;
  1106. TObject *r = top-1;
  1107. if (tonumber(r) || tonumber(l))
  1108. call_arith(IM_ADD);
  1109. else
  1110. {
  1111. nvalue(l) += nvalue(r);
  1112. --top;
  1113. }
  1114. }
  1115. break;
  1116. case SUBOP:
  1117. {
  1118. TObject *l = top-2;
  1119. TObject *r = top-1;
  1120. if (tonumber(r) || tonumber(l))
  1121. call_arith(IM_SUB);
  1122. else
  1123. {
  1124. nvalue(l) -= nvalue(r);
  1125. --top;
  1126. }
  1127. }
  1128. break;
  1129. case MULTOP:
  1130. {
  1131. TObject *l = top-2;
  1132. TObject *r = top-1;
  1133. if (tonumber(r) || tonumber(l))
  1134. call_arith(IM_MUL);
  1135. else
  1136. {
  1137. nvalue(l) *= nvalue(r);
  1138. --top;
  1139. }
  1140. }
  1141. break;
  1142. case DIVOP:
  1143. {
  1144. TObject *l = top-2;
  1145. TObject *r = top-1;
  1146. if (tonumber(r) || tonumber(l))
  1147. call_arith(IM_DIV);
  1148. else
  1149. {
  1150. nvalue(l) /= nvalue(r);
  1151. --top;
  1152. }
  1153. }
  1154. break;
  1155. case POWOP:
  1156. call_arith(IM_POW);
  1157. break;
  1158. case CONCOP: {
  1159. TObject *l = top-2;
  1160. TObject *r = top-1;
  1161. if (tostring(l) || tostring(r))
  1162. call_binTM(IM_CONCAT, "unexpected type for concatenation");
  1163. else {
  1164. tsvalue(l) = lua_createstring(lua_strconc(svalue(l),svalue(r)));
  1165. --top;
  1166. }
  1167. }
  1168. break;
  1169. case MINUSOP:
  1170. if (tonumber(top-1))
  1171. {
  1172. ttype(top) = LUA_T_NIL;
  1173. incr_top;
  1174. call_arith(IM_UNM);
  1175. }
  1176. else
  1177. nvalue(top-1) = - nvalue(top-1);
  1178. break;
  1179. case NOTOP:
  1180. ttype(top-1) = (ttype(top-1) == LUA_T_NIL) ? LUA_T_NUMBER : LUA_T_NIL;
  1181. nvalue(top-1) = 1;
  1182. break;
  1183. case ONTJMP:
  1184. {
  1185. Word w;
  1186. get_word(w,pc);
  1187. if (ttype(top-1) != LUA_T_NIL) pc += w;
  1188. }
  1189. break;
  1190. case ONFJMP:
  1191. {
  1192. Word w;
  1193. get_word(w,pc);
  1194. if (ttype(top-1) == LUA_T_NIL) pc += w;
  1195. }
  1196. break;
  1197. case JMP:
  1198. {
  1199. Word w;
  1200. get_word(w,pc);
  1201. pc += w;
  1202. }
  1203. break;
  1204. case UPJMP:
  1205. {
  1206. Word w;
  1207. get_word(w,pc);
  1208. pc -= w;
  1209. }
  1210. break;
  1211. case IFFJMP:
  1212. {
  1213. Word w;
  1214. get_word(w,pc);
  1215. top--;
  1216. if (ttype(top) == LUA_T_NIL) pc += w;
  1217. }
  1218. break;
  1219. case IFFUPJMP:
  1220. {
  1221. Word w;
  1222. get_word(w,pc);
  1223. top--;
  1224. if (ttype(top) == LUA_T_NIL) pc -= w;
  1225. }
  1226. break;
  1227. case POP: --top; break;
  1228. case CALLFUNC:
  1229. {
  1230. int nParams = *(pc++);
  1231. int nResults = *(pc++);
  1232. StkId newBase = (top-stack)-nParams;
  1233. do_call(newBase, nResults);
  1234. }
  1235. break;
  1236. case RETCODE0:
  1237. case RETCODE:
  1238. if (lua_callhook)
  1239. callHook (base, LUA_T_MARK, 1);
  1240. return (base + ((opcode==RETCODE0) ? 0 : *pc));
  1241. case SETLINE:
  1242. {
  1243. Word line;
  1244. get_word(line,pc);
  1245. if ((stack+base-1)->ttype != LUA_T_LINE)
  1246. {
  1247. /* open space for LINE value */
  1248. open_stack((top-stack)-base);
  1249. base++;
  1250. (stack+base-1)->ttype = LUA_T_LINE;
  1251. }
  1252. (stack+base-1)->value.i = line;
  1253. if (lua_linehook)
  1254. lineHook (line);
  1255. break;
  1256. }
  1257. default:
  1258. lua_error ("internal error - opcode doesn't match");
  1259. }
  1260. }
  1261. }
  1262. #if COMPAT2_5
  1263. /*
  1264. ** API: set a function as a fallback
  1265. */
  1266. lua_Object lua_setfallback (char *name, lua_CFunction fallback)
  1267. {
  1268. lua_pushstring(name);
  1269. lua_pushcfunction(fallback);
  1270. do_unprotectedrun(luaI_setfallback, 2, 1);
  1271. return put_luaObjectonTop();
  1272. }
  1273. #endif