开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 模拟服务器 > 查看源码
lcode.c
资源名称：SwordOnline.rar　[点击查看]
上传用户：dzyhzl
上传日期：2019-04-29
资源大小：56270k
文件大小：20k
源码类别：

模拟服务器

开发平台：

C/C++

lcode.c：源码内容
  1. /*
  2. ** $Id: lcode.c,v 1.51 2000/09/29 12:42:13 roberto Exp $
  3. ** Code generator for Lua
  4. ** See Copyright Notice in lua.h
  5. */
  8. #include "stdlib.h"
  10. #include "lua.h"
  12. #include "lcode.h"
  13. #include "ldo.h"
  14. #include "llex.h"
  15. #include "lmem.h"
  16. #include "lobject.h"
  17. #include "lopcodes.h"
  18. #include "lparser.h"
  21. void luaK_error (LexState *ls, const char *msg) {
  22.   luaX_error(ls, msg, ls->t.token);
  23. }
  26. /*
  27. ** Returns the the previous instruction, for optimizations.
  28. ** If there is a jump target between this and the current instruction,
  29. ** returns a dummy instruction to avoid wrong optimizations.
  30. */
  31. static Instruction previous_instruction (FuncState *fs) {
  32.   if (fs->pc > fs->lasttarget)  /* no jumps to current position? */
  33.     return fs->f->code[fs->pc-1];  /* returns previous instruction */
  34.   else
  35.     return CREATE_0(OP_END);  /* no optimizations after an `END' */
  36. }
  39. int luaK_jump (FuncState *fs) {
  40.   int j = luaK_code1(fs, OP_JMP, NO_JUMP);
  41.   if (j == fs->lasttarget) {  /* possible jumps to this jump? */
  42.     luaK_concat(fs, &j, fs->jlt);  /* keep them on hold */
  43.     fs->jlt = NO_JUMP;
  44.   }
  45.   return j;
  46. }
  49. static void luaK_fixjump (FuncState *fs, int pc, int dest) {
  50.   Instruction *jmp = &fs->f->code[pc];
  51.   if (dest == NO_JUMP)
  52.     SETARG_S(*jmp, NO_JUMP);  /* point to itself to represent end of list */
  53.   else {  /* jump is relative to position following jump instruction */
  54.     int offset = dest-(pc+1);
  55.     if (abs(offset) > MAXARG_S)
  56.       luaK_error(fs->ls, "control structure too long");
  57.     SETARG_S(*jmp, offset);
  58.   }
  59. }
  62. static int luaK_getjump (FuncState *fs, int pc) {
  63.   int offset = GETARG_S(fs->f->code[pc]);
  64.   if (offset == NO_JUMP)  /* point to itself represents end of list */
  65.     return NO_JUMP;  /* end of list */
  66.   else
  67.     return (pc+1)+offset;  /* turn offset into absolute position */
  68. }
  71. /*
  72. ** returns current `pc' and marks it as a jump target (to avoid wrong
  73. ** optimizations with consecutive instructions not in the same basic block).
  74. ** discharge list of jumps to last target.
  75. */
  76. int luaK_getlabel (FuncState *fs) {
  77.   if (fs->pc != fs->lasttarget) {
  78.     int lasttarget = fs->lasttarget;
  79.     fs->lasttarget = fs->pc;
  80.     luaK_patchlist(fs, fs->jlt, lasttarget);  /* discharge old list `jlt' */
  81.     fs->jlt = NO_JUMP;  /* nobody jumps to this new label (yet) */
  82.   }
  83.   return fs->pc;
  84. }
  87. void luaK_deltastack (FuncState *fs, int delta) {
  88.   fs->stacklevel += delta;
  89.   if (fs->stacklevel > fs->f->maxstacksize) {
  90.     if (fs->stacklevel > MAXSTACK)
  91.       luaK_error(fs->ls, "function or expression too complex");
  92.     fs->f->maxstacksize = fs->stacklevel;
  93.   }
  94. }
  97. void luaK_kstr (LexState *ls, int c) {
  98.   luaK_code1(ls->fs, OP_PUSHSTRING, c);
  99. }
  102. static int number_constant (FuncState *fs, Number r) {
  103.   /* check whether `r' has appeared within the last LOOKBACKNUMS entries */
  104.   Proto *f = fs->f;
  105.   int c = f->nknum;
  106.   int lim = c < LOOKBACKNUMS ? 0 : c-LOOKBACKNUMS;
  107.   while (--c >= lim)
  108.     if (f->knum[c] == r) return c;
  109.   /* not found; create a new entry */
  110.   luaM_growvector(fs->L, f->knum, f->nknum, 1, Number,
  111.                   "constant table overflow", MAXARG_U);
  112.   c = f->nknum++;
  113.   f->knum[c] = r;
  114.   return c;
  115. }
  118. void luaK_number (FuncState *fs, Number f) {
  119.   if (f <= (Number)MAXARG_S && (Number)(int)f == f)
  120.     luaK_code1(fs, OP_PUSHINT, (int)f);  /* f has a short integer value */
  121.   else
  122.     luaK_code1(fs, OP_PUSHNUM, number_constant(fs, f));
  123. }
  126. void luaK_adjuststack (FuncState *fs, int n) {
  127.   if (n > 0)
  128.     luaK_code1(fs, OP_POP, n);
  129.   else
  130.     luaK_code1(fs, OP_PUSHNIL, -n);
  131. }
  134. int luaK_lastisopen (FuncState *fs) {
  135.   /* check whether last instruction is an open function call */
  136.   Instruction i = previous_instruction(fs);
  137.   if (GET_OPCODE(i) == OP_CALL && GETARG_B(i) == MULT_RET)
  138.     return 1;
  139.   else return 0;
  140. }
  143. void luaK_setcallreturns (FuncState *fs, int nresults) {
  144.   if (luaK_lastisopen(fs)) {  /* expression is an open function call? */
  145.     SETARG_B(fs->f->code[fs->pc-1], nresults);  /* set number of results */
  146.     luaK_deltastack(fs, nresults);  /* push results */
  147.   }
  148. }
  151. static int discharge (FuncState *fs, expdesc *var) {
  152.   switch (var->k) {
  153.     case VLOCAL:
  154.       luaK_code1(fs, OP_GETLOCAL, var->u.index);
  155.       break;
  156.     case VGLOBAL:
  157.       luaK_code1(fs, OP_GETGLOBAL, var->u.index);
  158.       break;
  159.     case VINDEXED:
  160.       luaK_code0(fs, OP_GETTABLE);
  161.       break;
  162.     case VEXP:
  163.       return 0;  /* nothing to do */
  164.   }
  165.   var->k = VEXP;
  166.   var->u.l.t = var->u.l.f = NO_JUMP;
  167.   return 1;
  168. }
  171. static void discharge1 (FuncState *fs, expdesc *var) {
  173. discharge(fs, var);
  174.  /* if it has jumps then it is already discharged */
  175.   if (var->u.l.t == NO_JUMP && var->u.l.f  == NO_JUMP)
  176.     luaK_setcallreturns(fs, 1);  /* call must return 1 value */
  177. }
  180. void luaK_storevar (LexState *ls, const expdesc *var) {
  181.   FuncState *fs = ls->fs;
  182.   switch (var->k) {
  183.     case VLOCAL:
  184.       luaK_code1(fs, OP_SETLOCAL, var->u.index);
  185.       break;
  186.     case VGLOBAL:
  187.       luaK_code1(fs, OP_SETGLOBAL, var->u.index);
  188.       break;
  189.     case VINDEXED:  /* table is at top-3; pop 3 elements after operation */
  190.       luaK_code2(fs, OP_SETTABLE, 3, 3);
  191.       break;
  192.     default:
  193.       LUA_INTERNALERROR("invalid var kind to store");
  194.   }
  195. }
  198. static OpCode invertjump (OpCode op) {
  199.   switch (op) {
  200.     case OP_JMPNE: return OP_JMPEQ;
  201.     case OP_JMPEQ: return OP_JMPNE;
  202.     case OP_JMPLT: return OP_JMPGE;
  203.     case OP_JMPLE: return OP_JMPGT;
  204.     case OP_JMPGT: return OP_JMPLE;
  205.     case OP_JMPGE: return OP_JMPLT;
  206.     case OP_JMPT: case OP_JMPONT:  return OP_JMPF;
  207.     case OP_JMPF: case OP_JMPONF:  return OP_JMPT;
  208.     default:
  209.       LUA_INTERNALERROR("invalid jump instruction");
  210.       return OP_END;  /* to avoid warnings */
  211.   }
  212. }
  215. static void luaK_patchlistaux (FuncState *fs, int list, int target,
  216.                                OpCode special, int special_target) {
  217.   Instruction *code = fs->f->code;
  218.   while (list != NO_JUMP) {
  219.     int next = luaK_getjump(fs, list);
  220.     Instruction *i = &code[list];
  221.     OpCode op = GET_OPCODE(*i);
  222.     if (op == special)  /* this `op' already has a value */
  223.       luaK_fixjump(fs, list, special_target);
  224.     else {
  225.       luaK_fixjump(fs, list, target);  /* do the patch */
  226.       if (op == OP_JMPONT)  /* remove eventual values */
  227.         SET_OPCODE(*i, OP_JMPT);
  228.       else if (op == OP_JMPONF)
  229.         SET_OPCODE(*i, OP_JMPF);
  230.     }
  231.     list = next;
  232.   }
  233. }
  236. void luaK_patchlist (FuncState *fs, int list, int target) {
  237.   if (target == fs->lasttarget)  /* same target that list `jlt'? */
  238.     luaK_concat(fs, &fs->jlt, list);  /* delay fixing */
  239.   else
  240.     luaK_patchlistaux(fs, list, target, OP_END, 0);
  241. }
  244. static int need_value (FuncState *fs, int list, OpCode hasvalue) {
  245.   /* check whether list has a jump without a value */
  246.   for (; list != NO_JUMP; list = luaK_getjump(fs, list))
  247.     if (GET_OPCODE(fs->f->code[list]) != hasvalue) return 1;
  248.   return 0;  /* not found */
  249. }
  252. void luaK_concat (FuncState *fs, int *l1, int l2) {
  253.   if (*l1 == NO_JUMP)
  254.     *l1 = l2;
  255.   else {
  256.     int list = *l1;
  257.     for (;;) {  /* traverse `l1' */
  258.       int next = luaK_getjump(fs, list);
  259.       if (next == NO_JUMP) {  /* end of list? */
  260.         luaK_fixjump(fs, list, l2);
  261.         return;
  262.       }
  263.       list = next;
  264.     }
  265.   }
  266. }
  269. static void luaK_testgo (FuncState *fs, expdesc *v, int invert, OpCode jump) {
  270.   int prevpos;  /* position of last instruction */
  271.   Instruction *previous;
  272.   int *golist, *exitlist;
  273.   if (!invert) {
  274.     golist = &v->u.l.f;    /* go if false */
  275.     exitlist = &v->u.l.t;  /* exit if true */
  276.   }
  277.   else {
  278.     golist = &v->u.l.t;    /* go if true */
  279.     exitlist = &v->u.l.f;  /* exit if false */
  280.   }
  281.   discharge1(fs, v);
  282.   prevpos = fs->pc-1;
  283.   previous = &fs->f->code[prevpos];
  284.   LUA_ASSERT(*previous==previous_instruction(fs), "no jump allowed here");
  285.   if (!ISJUMP(GET_OPCODE(*previous)))
  286.     prevpos = luaK_code1(fs, jump, NO_JUMP);
  287.   else {  /* last instruction is already a jump */
  288.     if (invert)
  289.       SET_OPCODE(*previous, invertjump(GET_OPCODE(*previous)));
  290.   }
  291.   luaK_concat(fs, exitlist, prevpos);  /* insert last jump in `exitlist' */
  292.   luaK_patchlist(fs, *golist, luaK_getlabel(fs));
  293.   *golist = NO_JUMP;
  294. }
  297. void luaK_goiftrue (FuncState *fs, expdesc *v, int keepvalue) {
  298.   luaK_testgo(fs, v, 1, keepvalue ? OP_JMPONF : OP_JMPF);
  299. }
  302. static void luaK_goiffalse (FuncState *fs, expdesc *v, int keepvalue) {
  303.   luaK_testgo(fs, v, 0, keepvalue ? OP_JMPONT : OP_JMPT);
  304. }
  307. static int code_label (FuncState *fs, OpCode op, int arg) {
  308.   luaK_getlabel(fs);  /* those instructions may be jump targets */
  309.   return luaK_code1(fs, op, arg);
  310. }
  313. void luaK_tostack (LexState *ls, expdesc *v, int onlyone) {
  314.   FuncState *fs = ls->fs;
  315.   if (!discharge(fs, v)) {  /* `v' is an expression? */
  316.     OpCode previous = GET_OPCODE(fs->f->code[fs->pc-1]);
  317.     if (!ISJUMP(previous) && v->u.l.f == NO_JUMP && v->u.l.t == NO_JUMP) {
  318.       /* expression has no jumps */
  319.       if (onlyone)
  320.         luaK_setcallreturns(fs, 1);  /* call must return 1 value */
  321.     }
  322.     else {  /* expression has jumps */
  323.       int final;  /* position after whole expression */
  324.       int j = NO_JUMP;  /*  eventual  jump over values */
  325.       int p_nil = NO_JUMP;  /* position of an eventual PUSHNIL */
  326.       int p_1 = NO_JUMP;  /* position of an eventual PUSHINT */
  327.       if (ISJUMP(previous) || need_value(fs, v->u.l.f, OP_JMPONF)
  328.                            || need_value(fs, v->u.l.t, OP_JMPONT)) {
  329.         /* expression needs values */
  330.         if (ISJUMP(previous))
  331.           luaK_concat(fs, &v->u.l.t, fs->pc-1);  /* put `previous' in t. list */
  332.         else {
  333.           j = code_label(fs, OP_JMP, NO_JUMP);  /* to jump over both pushes */
  334.           /* correct stack for compiler and symbolic execution */
  335.           luaK_adjuststack(fs, 1);
  336.         }
  337.         p_nil = code_label(fs, OP_PUSHNILJMP, 0);
  338.         p_1 = code_label(fs, OP_PUSHINT, 1);
  339.         luaK_patchlist(fs, j, luaK_getlabel(fs));
  340.       }
  341.       final = luaK_getlabel(fs);
  342.       luaK_patchlistaux(fs, v->u.l.f, p_nil, OP_JMPONF, final);
  343.       luaK_patchlistaux(fs, v->u.l.t, p_1, OP_JMPONT, final);
  344.       v->u.l.f = v->u.l.t = NO_JUMP;
  345.     }
  346.   }
  347. }
  350. void luaK_prefix (LexState *ls, UnOpr op, expdesc *v) {
  351.   FuncState *fs = ls->fs;
  352.   if (op == OPR_MINUS) {
  353.     luaK_tostack(ls, v, 1);
  354.     luaK_code0(fs, OP_MINUS);
  355.   }
  356.   else {  /* op == NOT */
  357.     Instruction *previous;
  358.     discharge1(fs, v);
  359.     previous = &fs->f->code[fs->pc-1];
  360.     if (ISJUMP(GET_OPCODE(*previous)))
  361.       SET_OPCODE(*previous, invertjump(GET_OPCODE(*previous)));
  362.     else
  363.       luaK_code0(fs, OP_NOT);
  364.     /* interchange true and false lists */
  365.     { int temp = v->u.l.f; v->u.l.f = v->u.l.t; v->u.l.t = temp; }
  366.   }
  367. }
  370. void luaK_infix (LexState *ls, BinOpr op, expdesc *v) {
  371.   FuncState *fs = ls->fs;
  372.   switch (op) {
  373.     case OPR_AND:
  374.       luaK_goiftrue(fs, v, 1);
  375.       break;
  376.     case OPR_OR:
  377.       luaK_goiffalse(fs, v, 1);
  378.       break;
  379.     default:
  380.       luaK_tostack(ls, v, 1);  /* all other binary operators need a value */
  381.   }
  382. }
  386. static const struct {
  387.   OpCode opcode;  /* opcode for each binary operator */
  388.   int arg;        /* default argument for the opcode */
  389. } codes[] = {  /* ORDER OPR */
  390.       {OP_ADD, 0}, {OP_SUB, 0}, {OP_MULT, 0}, {OP_DIV, 0},
  391.       {OP_POW, 0}, {OP_CONCAT, 2},
  392.       {OP_JMPNE, NO_JUMP}, {OP_JMPEQ, NO_JUMP},
  393.       {OP_JMPLT, NO_JUMP}, {OP_JMPLE, NO_JUMP},
  394.       {OP_JMPGT, NO_JUMP}, {OP_JMPGE, NO_JUMP}
  395. };
  398. void luaK_posfix (LexState *ls, BinOpr op, expdesc *v1, expdesc *v2) {
  399.   FuncState *fs = ls->fs;
  400.   switch (op) {
  401.     case OPR_AND: {
  402.       LUA_ASSERT(v1->u.l.t == NO_JUMP, "list must be closed");
  403.       discharge1(fs, v2);
  404.       v1->u.l.t = v2->u.l.t;
  405.       luaK_concat(fs, &v1->u.l.f, v2->u.l.f);
  406.       break;
  407.     }
  408.     case OPR_OR: {
  409.       LUA_ASSERT(v1->u.l.f == NO_JUMP, "list must be closed");
  410.       discharge1(fs, v2);
  411.       v1->u.l.f = v2->u.l.f;
  412.       luaK_concat(fs, &v1->u.l.t, v2->u.l.t);
  413.       break;
  414.     }
  415.     default: {
  416.       luaK_tostack(ls, v2, 1);  /* `v2' must be a value */
  417.       luaK_code1(fs, codes[op].opcode, codes[op].arg);
  418.     }
  419.   }
  420. }
  423. static void codelineinfo (FuncState *fs) {
  424.   Proto *f = fs->f;
  425.   LexState *ls = fs->ls;
  426.   if (ls->lastline > fs->lastline) {
  427.     luaM_growvector(fs->L, f->lineinfo, f->nlineinfo, 2, int,
  428.                     "line info overflow", MAX_INT);
  429.     if (ls->lastline > fs->lastline+1)
  430.       f->lineinfo[f->nlineinfo++] = -(ls->lastline - (fs->lastline+1));
  431.     f->lineinfo[f->nlineinfo++] = fs->pc;
  432.     fs->lastline = ls->lastline;
  433.   }
  434. }
  437. int luaK_code0 (FuncState *fs, OpCode o) {
  438.   return luaK_code2(fs, o, 0, 0);
  439. }
  442. int luaK_code1 (FuncState *fs, OpCode o, int arg1) {
  443.   return luaK_code2(fs, o, arg1, 0);
  444. }
  447. int luaK_code2 (FuncState *fs, OpCode o, int arg1, int arg2) {
  448.   Instruction i = previous_instruction(fs);
  449.   int delta = luaK_opproperties[o].push - luaK_opproperties[o].pop;
  450.   int optm = 0;  /* 1 when there is an optimization */
  451.   switch (o) {
  452.     case OP_CLOSURE: {
  453.       delta = -arg2+1;
  454.       break;
  455.     }
  456.     case OP_SETTABLE: {
  457.       delta = -arg2;
  458.       break;
  459.     }
  460.     case OP_SETLIST: {
  461.       if (arg2 == 0) return NO_JUMP;  /* nothing to do */
  462.       delta = -arg2;
  463.       break;
  464.     }
  465.     case OP_SETMAP: {
  466.       if (arg1 == 0) return NO_JUMP;  /* nothing to do */
  467.       delta = -2*arg1;
  468.       break;
  469.     }
  470.     case OP_RETURN: {
  471.       if (GET_OPCODE(i) == OP_CALL && GETARG_B(i) == MULT_RET) {
  472.         SET_OPCODE(i, OP_TAILCALL);
  473.         SETARG_B(i, arg1);
  474.         optm = 1;
  475.       }
  476.       break;
  477.     }
  478.     case OP_PUSHNIL: {
  479.       if (arg1 == 0) return NO_JUMP;  /* nothing to do */
  480.       delta = arg1;
  481.       switch(GET_OPCODE(i)) {
  482.         case OP_PUSHNIL: SETARG_U(i, GETARG_U(i)+arg1); optm = 1; break;
  483.         default: break;
  484.       }
  485.       break;
  486.     }
  487.     case OP_POP: {
  488.       if (arg1 == 0) return NO_JUMP;  /* nothing to do */
  489.       delta = -arg1;
  490.       switch(GET_OPCODE(i)) {
  491.         case OP_SETTABLE: SETARG_B(i, GETARG_B(i)+arg1); optm = 1; break;
  492.         default: break;
  493.       }
  494.       break;
  495.     }
  496.     case OP_GETTABLE: {
  497.       switch(GET_OPCODE(i)) {
  498.         case OP_PUSHSTRING:  /* `t.x' */
  499.           SET_OPCODE(i, OP_GETDOTTED);
  500.           optm = 1;
  501.           break;
  502.         case OP_GETLOCAL:  /* `t[i]' */
  503.           SET_OPCODE(i, OP_GETINDEXED);
  504.           optm = 1;
  505.           break;
  506.         default: break;
  507.       }
  508.       break;
  509.     }
  510.     case OP_ADD: {
  511.       switch(GET_OPCODE(i)) {
  512.         case OP_PUSHINT: SET_OPCODE(i, OP_ADDI); optm = 1; break;  /* `a+k' */
  513.         default: break;
  514.       }
  515.       break;
  516.     }
  517.     case OP_SUB: {
  518.       switch(GET_OPCODE(i)) {
  519.         case OP_PUSHINT:  /* `a-k' */
  520.           i = CREATE_S(OP_ADDI, -GETARG_S(i));
  521.           optm = 1;
  522.           break;
  523.         default: break;
  524.       }
  525.       break;
  526.     }
  527.     case OP_CONCAT: {
  528.       delta = -arg1+1;
  529.       switch(GET_OPCODE(i)) {
  530.         case OP_CONCAT:  /* `a..b..c' */
  531.           SETARG_U(i, GETARG_U(i)+1);
  532.           optm = 1;
  533.           break;
  534.         default: break;
  535.       }
  536.       break;
  537.     }
  538.     case OP_MINUS: {
  539.       switch(GET_OPCODE(i)) {
  540.         case OP_PUSHINT:  /* `-k' */
  541.           SETARG_S(i, -GETARG_S(i));
  542.           optm = 1;
  543.           break;
  544.         case OP_PUSHNUM:  /* `-k' */
  545.           SET_OPCODE(i, OP_PUSHNEGNUM);
  546.           optm = 1;
  547.           break;
  548.         default: break;
  549.       }
  550.       break;
  551.     }
  552.     case OP_JMPNE: {
  553.       if (i == CREATE_U(OP_PUSHNIL, 1)) {  /* `a~=nil' */
  554.         i = CREATE_S(OP_JMPT, NO_JUMP);
  555.         optm = 1;
  556.       }
  557.       break;
  558.     }
  559.     case OP_JMPEQ: {
  560.       if (i == CREATE_U(OP_PUSHNIL, 1)) {  /* `a==nil' */
  561.         i = CREATE_0(OP_NOT);
  562.         delta = -1;  /* just undo effect of previous PUSHNIL */
  563.         optm = 1;
  564.       }
  565.       break;
  566.     }
  567.     case OP_JMPT:
  568.     case OP_JMPONT: {
  569.       switch (GET_OPCODE(i)) {
  570.         case OP_NOT: {
  571.           i = CREATE_S(OP_JMPF, NO_JUMP);
  572.           optm = 1;
  573.           break;
  574.         }
  575.         case OP_PUSHINT: {
  576.           if (o == OP_JMPT) {  /* JMPONT must keep original integer value */
  577.             i = CREATE_S(OP_JMP, NO_JUMP);
  578.             optm = 1;
  579.           }
  580.           break;
  581.         }
  582.         case OP_PUSHNIL: {
  583.           if (GETARG_U(i) == 1) {
  584.             fs->pc--;  /* erase previous instruction */
  585.             luaK_deltastack(fs, -1);  /* correct stack */
  586.             return NO_JUMP; 
  587.           }
  588.           break;
  589.         }
  590.         default: break;
  591.       }
  592.       break;
  593.     }
  594.     case OP_JMPF:
  595.     case OP_JMPONF: {
  596.       switch (GET_OPCODE(i)) {
  597.         case OP_NOT: {
  598.           i = CREATE_S(OP_JMPT, NO_JUMP);
  599.           optm = 1;
  600.           break;
  601.         }
  602.         case OP_PUSHINT: {  /* `while 1 do ...' */
  603.           fs->pc--;  /* erase previous instruction */
  604.           luaK_deltastack(fs, -1);  /* correct stack */
  605.           return NO_JUMP; 
  606.         }
  607.         case OP_PUSHNIL: {  /* `repeat ... until nil' */
  608.           if (GETARG_U(i) == 1) {
  609.             i = CREATE_S(OP_JMP, NO_JUMP);
  610.             optm = 1;
  611.           }
  612.           break;
  613.         }
  614.         default: break;
  615.       }
  616.       break;
  617.     }
  618.     case OP_GETDOTTED:
  619.     case OP_GETINDEXED:
  620.     case OP_TAILCALL:
  621.     case OP_ADDI: {
  622.       LUA_INTERNALERROR("instruction used only for optimizations");
  623.       break;
  624.     }
  625.     default: {
  626.       LUA_ASSERT(delta != VD, "invalid delta");
  627.       break;
  628.     }
  629.   }
  630.   luaK_deltastack(fs, delta);
  631.   if (optm) {  /* optimize: put instruction in place of last one */
  632.       fs->f->code[fs->pc-1] = i;  /* change previous instruction */
  633.       return fs->pc-1;  /* do not generate new instruction */
  634.   }
  635.   /* else build new instruction */
  636.   switch ((enum Mode)luaK_opproperties[o].mode) {
  637.     case iO: i = CREATE_0(o); break;
  638.     case iU: i = CREATE_U(o, arg1); break;
  639.     case iS: i = CREATE_S(o, arg1); break;
  640.     case iAB: i = CREATE_AB(o, arg1, arg2); break;
  641.   }
  642.   codelineinfo(fs);
  643.   /* put new instruction in code array */
  644.   luaM_growvector(fs->L, fs->f->code, fs->pc, 1, Instruction,
  645.                   "code size overflow", MAX_INT);
  646.   fs->f->code[fs->pc] = i;
  647.   return fs->pc++;
  648. }
  651. const struct OpProperties luaK_opproperties[NUM_OPCODES] = {
  652.   {iO, 0, 0}, /* OP_END */
  653.   {iU, 0, 0}, /* OP_RETURN */
  654.   {iAB, 0, 0}, /* OP_CALL */
  655.   {iAB, 0, 0}, /* OP_TAILCALL */
  656.   {iU, VD, 0}, /* OP_PUSHNIL */
  657.   {iU, VD, 0}, /* OP_POP */
  658.   {iS, 1, 0}, /* OP_PUSHINT */
  659.   {iU, 1, 0}, /* OP_PUSHSTRING */
  660.   {iU, 1, 0}, /* OP_PUSHNUM */
  661.   {iU, 1, 0}, /* OP_PUSHNEGNUM */
  662.   {iU, 1, 0}, /* OP_PUSHUPVALUE */
  663.   {iU, 1, 0}, /* OP_GETLOCAL */
  664.   {iU, 1, 0}, /* OP_GETGLOBAL */
  665.   {iO, 1, 2}, /* OP_GETTABLE */
  666.   {iU, 1, 1}, /* OP_GETDOTTED */
  667.   {iU, 1, 1}, /* OP_GETINDEXED */
  668.   {iU, 2, 1}, /* OP_PUSHSELF */
  669.   {iU, 1, 0}, /* OP_CREATETABLE */
  670.   {iU, 0, 1}, /* OP_SETLOCAL */
  671.   {iU, 0, 1}, /* OP_SETGLOBAL */
  672.   {iAB, VD, 0}, /* OP_SETTABLE */
  673.   {iAB, VD, 0}, /* OP_SETLIST */
  674.   {iU, VD, 0}, /* OP_SETMAP */
  675.   {iO, 1, 2}, /* OP_ADD */
  676.   {iS, 1, 1}, /* OP_ADDI */
  677.   {iO, 1, 2}, /* OP_SUB */
  678.   {iO, 1, 2}, /* OP_MULT */
  679.   {iO, 1, 2}, /* OP_DIV */
  680.   {iO, 1, 2}, /* OP_POW */
  681.   {iU, VD, 0}, /* OP_CONCAT */
  682.   {iO, 1, 1}, /* OP_MINUS */
  683.   {iO, 1, 1}, /* OP_NOT */
  684.   {iS, 0, 2}, /* OP_JMPNE */
  685.   {iS, 0, 2}, /* OP_JMPEQ */
  686.   {iS, 0, 2}, /* OP_JMPLT */
  687.   {iS, 0, 2}, /* OP_JMPLE */
  688.   {iS, 0, 2}, /* OP_JMPGT */
  689.   {iS, 0, 2}, /* OP_JMPGE */
  690.   {iS, 0, 1}, /* OP_JMPT */
  691.   {iS, 0, 1}, /* OP_JMPF */
  692.   {iS, 0, 1}, /* OP_JMPONT */
  693.   {iS, 0, 1}, /* OP_JMPONF */
  694.   {iS, 0, 0}, /* OP_JMP */
  695.   {iO, 0, 0}, /* OP_PUSHNILJMP */
  696.   {iS, 0, 0}, /* OP_FORPREP */
  697.   {iS, 0, 3}, /* OP_FORLOOP */
  698.   {iS, 2, 0}, /* OP_LFORPREP */
  699.   {iS, 0, 3}, /* OP_LFORLOOP */
  700.   {iAB, VD, 0} /* OP_CLOSURE */
  701. };