/*** $Id: lvm.c,v 2.62 2006/01/23 19:51:43 roberto Exp $** Lua virtual machine** See Copyright Notice in lua.h*/#include <stdio.h>#include <stdlib.h>#include <string.h>#define lvm_c#define LUA_CORE#include "lua.h"#include "ldebug.h"#include "ldo.h"#include "lfunc.h"#include "lgc.h"#include "lobject.h"#include "lopcodes.h"#include "lstate.h"#include "lstring.h"#include "ltable.h"#include "ltm.h"#include "lvm.h"/* limit for table tag-method chains (to avoid loops) */#define MAXTAGLOOP	100const TValue *luaV_tonumber (const TValue *obj, TValue *n) {  lua_Number num;  if (ttisnumber(obj)) return obj;  if (ttisstring(obj) && luaO_str2d(svalue(obj), &num)) {    setnvalue(n, num);    return n;  }  else    return NULL;}int luaV_tostring (lua_State *L, StkId obj) {  if (!ttisnumber(obj))    return 0;  else {    char s[LUAI_MAXNUMBER2STR];    lua_Number n = nvalue(obj);    lua_number2str(s, n);    setsvalue2s(L, obj, luaS_new(L, s));    return 1;  }}static void traceexec (lua_State *L, const Instruction *pc) {  lu_byte mask = L->hookmask;  const Instruction *oldpc = L->savedpc;  L->savedpc = pc;  if (mask > LUA_MASKLINE) {  /* instruction-hook set? */    if (L->hookcount == 0) {      resethookcount(L);      luaD_callhook(L, LUA_HOOKCOUNT, -1);    }  }  if (mask & LUA_MASKLINE) {    Proto *p = ci_func(L->ci)->l.p;    int npc = pcRel(pc, p);    int newline = getline(p, npc);    /* call linehook when enter a new function, when jump back (loop),       or when enter a new line */    if (npc == 0 || pc <= oldpc || newline != getline(p, pcRel(oldpc, p)))      luaD_callhook(L, LUA_HOOKLINE, newline);  }}static void callTMres (lua_State *L, StkId res, const TValue *f,                        const TValue *p1, const TValue *p2) {  ptrdiff_t result = savestack(L, res);  setobj2s(L, L->top, f);  /* push function */  setobj2s(L, L->top+1, p1);  /* 1st argument */  setobj2s(L, L->top+2, p2);  /* 2nd argument */  luaD_checkstack(L, 3);  L->top += 3;  luaD_call(L, L->top - 3, 1);  res = restorestack(L, result);  L->top--;  setobjs2s(L, res, L->top);}static void callTM (lua_State *L, const TValue *f, const TValue *p1,                    const TValue *p2, const TValue *p3) {  setobj2s(L, L->top, f);  /* push function */  setobj2s(L, L->top+1, p1);  /* 1st argument */  setobj2s(L, L->top+2, p2);  /* 2nd argument */  setobj2s(L, L->top+3, p3);  /* 3th argument */  luaD_checkstack(L, 4);  L->top += 4;  luaD_call(L, L->top - 4, 0);}void luaV_gettable (lua_State *L, const TValue *t, TValue *key, StkId val) {  int loop;  for (loop = 0; loop < MAXTAGLOOP; loop++) {    const TValue *tm;    if (ttistable(t)) {  /* `t' is a table? */      Table *h = hvalue(t);      const TValue *res = luaH_get(h, key); /* do a primitive get */      if (!ttisnil(res) ||  /* result is no nil? */          (tm = fasttm(L, h->metatable, TM_INDEX)) == NULL) { /* or no TM? */        setobj2s(L, val, res);        return;      }      /* else will try the tag method */    }    else if (ttisnil(tm = luaT_gettmbyobj(L, t, TM_INDEX)))      luaG_typeerror(L, t, "index");    if (ttisfunction(tm)) {      callTMres(L, val, tm, t, key);      return;    }    t = tm;  /* else repeat with `tm' */   }  luaG_runerror(L, "loop in gettable");}void luaV_settable (lua_State *L, const TValue *t, TValue *key, StkId val) {  int loop;  for (loop = 0; loop < MAXTAGLOOP; loop++) {    const TValue *tm;    if (ttistable(t)) {  /* `t' is a table? */      Table *h = hvalue(t);      TValue *oldval = luaH_set(L, h, key); /* do a primitive set */      if (!ttisnil(oldval) ||  /* result is no nil? */          (tm = fasttm(L, h->metatable, TM_NEWINDEX)) == NULL) { /* or no TM? */        setobj2t(L, oldval, val);        luaC_barriert(L, h, val);        return;      }      /* else will try the tag method */    }    else if (ttisnil(tm = luaT_gettmbyobj(L, t, TM_NEWINDEX)))      luaG_typeerror(L, t, "index");    if (ttisfunction(tm)) {      callTM(L, tm, t, key, val);      return;    }    t = tm;  /* else repeat with `tm' */   }  luaG_runerror(L, "loop in settable");}static int call_binTM (lua_State *L, const TValue *p1, const TValue *p2,                       StkId res, TMS event) {  const TValue *tm = luaT_gettmbyobj(L, p1, event);  /* try first operand */  if (ttisnil(tm))    tm = luaT_gettmbyobj(L, p2, event);  /* try second operand */  if (!ttisfunction(tm)) return 0;  callTMres(L, res, tm, p1, p2);  return 1;}static const TValue *get_compTM (lua_State *L, Table *mt1, Table *mt2,                                  TMS event) {  const TValue *tm1 = fasttm(L, mt1, event);  const TValue *tm2;  if (tm1 == NULL) return NULL;  /* no metamethod */  if (mt1 == mt2) return tm1;  /* same metatables => same metamethods */  tm2 = fasttm(L, mt2, event);  if (tm2 == NULL) return NULL;  /* no metamethod */  if (luaO_rawequalObj(tm1, tm2))  /* same metamethods? */    return tm1;  return NULL;}static int call_orderTM (lua_State *L, const TValue *p1, const TValue *p2,                         TMS event) {  const TValue *tm1 = luaT_gettmbyobj(L, p1, event);  const TValue *tm2;  if (ttisnil(tm1)) return -1;  /* no metamethod? */  tm2 = luaT_gettmbyobj(L, p2, event);  if (!luaO_rawequalObj(tm1, tm2))  /* different metamethods? */    return -1;  callTMres(L, L->top, tm1, p1, p2);  return !l_isfalse(L->top);}static int l_strcmp (const TString *ls, const TString *rs) {  const char *l = getstr(ls);  size_t ll = ls->tsv.len;  const char *r = getstr(rs);  size_t lr = rs->tsv.len;  for (;;) {    int temp = strcoll(l, r);    if (temp != 0) return temp;    else {  /* strings are equal up to a `\0' */      size_t len = strlen(l);  /* index of first `\0' in both strings */      if (len == lr)  /* r is finished? */        return (len == ll) ? 0 : 1;      else if (len == ll)  /* l is finished? */        return -1;  /* l is smaller than r (because r is not finished) */      /* both strings longer than `len'; go on comparing (after the `\0') */      len++;      l += len; ll -= len; r += len; lr -= len;    }  }}int luaV_lessthan (lua_State *L, const TValue *l, const TValue *r) {  int res;  if (ttype(l) != ttype(r))    return luaG_ordererror(L, l, r);  else if (ttisnumber(l))    return luai_numlt(nvalue(l), nvalue(r));  else if (ttisstring(l))    return l_strcmp(rawtsvalue(l), rawtsvalue(r)) < 0;  else if ((res = call_orderTM(L, l, r, TM_LT)) != -1)    return res;  return luaG_ordererror(L, l, r);}static int lessequal (lua_State *L, const TValue *l, const TValue *r) {  int res;  if (ttype(l) != ttype(r))    return luaG_ordererror(L, l, r);  else if (ttisnumber(l))    return luai_numle(nvalue(l), nvalue(r));  else if (ttisstring(l))    return l_strcmp(rawtsvalue(l), rawtsvalue(r)) <= 0;  else if ((res = call_orderTM(L, l, r, TM_LE)) != -1)  /* first try `le' */    return res;  else if ((res = call_orderTM(L, r, l, TM_LT)) != -1)  /* else try `lt' */    return !res;  return luaG_ordererror(L, l, r);}int luaV_equalval (lua_State *L, const TValue *t1, const TValue *t2) {  const TValue *tm;  lua_assert(ttype(t1) == ttype(t2));  switch (ttype(t1)) {    case LUA_TNIL: return 1;    case LUA_TNUMBER: return luai_numeq(nvalue(t1), nvalue(t2));    case LUA_TBOOLEAN: return bvalue(t1) == bvalue(t2);  /* true must be 1 !! */    case LUA_TLIGHTUSERDATA: return pvalue(t1) == pvalue(t2);    case LUA_TUSERDATA: {      if (uvalue(t1) == uvalue(t2)) return 1;      tm = get_compTM(L, uvalue(t1)->metatable, uvalue(t2)->metatable,                         TM_EQ);      break;  /* will try TM */    }    case LUA_TTABLE: {      if (hvalue(t1) == hvalue(t2)) return 1;      tm = get_compTM(L, hvalue(t1)->metatable, hvalue(t2)->metatable, TM_EQ);      break;  /* will try TM */    }    default: return gcvalue(t1) == gcvalue(t2);  }  if (tm == NULL) return 0;  /* no TM? */  callTMres(L, L->top, tm, t1, t2);  /* call TM */  return !l_isfalse(L->top);}void luaV_concat (lua_State *L, int total, int last) {  do {    StkId top = L->base + last + 1;    int n = 2;  /* number of elements handled in this pass (at least 2) */    if (!tostring(L, top-2) || !tostring(L, top-1)) {      if (!call_binTM(L, top-2, top-1, top-2, TM_CONCAT))        luaG_concaterror(L, top-2, top-1);    } else if (tsvalue(top-1)->len > 0) {  /* if len=0, do nothing */      /* at least two string values; get as many as possible */      size_t tl = tsvalue(top-1)->len;      char *buffer;      int i;      /* collect total length */      for (n = 1; n < total && tostring(L, top-n-1); n++) {        size_t l = tsvalue(top-n-1)->len;        if (l >= MAX_SIZET - tl) luaG_runerror(L, "string length overflow");        tl += l;      }      buffer = luaZ_openspace(L, &G(L)->buff, tl);      tl = 0;      for (i=n; i>0; i--) {  /* concat all strings */        size_t l = tsvalue(top-i)->len;        memcpy(buffer+tl, svalue(top-i), l);        tl += l;      }      setsvalue2s(L, top-n, luaS_newlstr(L, buffer, tl));    }    total -= n-1;  /* got `n' strings to create 1 new */    last -= n-1;  } while (total > 1);  /* repeat until only 1 result left */}static void Arith (lua_State *L, StkId ra, const TValue *rb,                   const TValue *rc, TMS op) {  TValue tempb, tempc;  const TValue *b, *c;  if ((b = luaV_tonumber(rb, &tempb)) != NULL &&      (c = luaV_tonumber(rc, &tempc)) != NULL) {    lua_Number nb = nvalue(b), nc = nvalue(c);    switch (op) {      case TM_ADD: setnvalue(ra, luai_numadd(nb, nc)); break;      case TM_SUB: setnvalue(ra, luai_numsub(nb, nc)); break;      case TM_MUL: setnvalue(ra, luai_nummul(nb, nc)); break;      case TM_DIV: setnvalue(ra, luai_numdiv(nb, nc)); break;      case TM_MOD: setnvalue(ra, luai_nummod(nb, nc)); break;      case TM_POW: setnvalue(ra, luai_numpow(nb, nc)); break;      case TM_UNM: setnvalue(ra, luai_numunm(nb)); break;      default: lua_assert(0); break;    }  }  else if (!call_binTM(L, rb, rc, ra, op))    luaG_aritherror(L, rb, rc);}/*** some macros for common tasks in `luaV_execute'*/#define runtime_check(L, c)	{ if (!(c)) break; }#define RA(i)	(base+GETARG_A(i))/* to be used after possible stack reallocation */#define RB(i)	check_exp(getBMode(GET_OPCODE(i)) == OpArgR, base+GETARG_B(i))#define RC(i)	check_exp(getCMode(GET_OPCODE(i)) == OpArgR, base+GETARG_C(i))#define RKB(i)	check_exp(getBMode(GET_OPCODE(i)) == OpArgK, \	ISK(GETARG_B(i)) ? k+INDEXK(GETARG_B(i)) : base+GETARG_B(i))#define RKC(i)	check_exp(getCMode(GET_OPCODE(i)) == OpArgK, \	ISK(GETARG_C(i)) ? k+INDEXK(GETARG_C(i)) : base+GETARG_C(i))#define KBx(i)	check_exp(getBMode(GET_OPCODE(i)) == OpArgK, k+GETARG_Bx(i))#define dojump(L,pc,i)	{(pc) += (i); luai_threadyield(L);}#define Protect(x)	{ L->savedpc = pc; {x;}; base = L->base; }#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)); \      }void luaV_execute (lua_State *L, int nexeccalls) {  LClosure *cl;  StkId base;  TValue *k;  const Instruction *pc; reentry:  /* entry point */  pc = L->savedpc;  cl = &clvalue(L->ci->func)->l;  base = L->base;  k = cl->p->k;