自学教程：C++ ttype函数代码示例

LUA_API const void *lua_topointer (lua_State *L, int idx) {    StkId o = index2addr(L, idx);    switch (ttype(o)) {    case LUA_TTABLE:        return hvalue(o);    case LUA_TLCL:        return clLvalue(o);    case LUA_TCCL:        return clCvalue(o);    case LUA_TLCF:        return cast(void *, cast(size_t, fvalue(o)));    case LUA_TTHREAD:        return thvalue(o);    case LUA_TUSERDATA:    case LUA_TLIGHTUSERDATA:        return lua_touserdata(L, idx);    default:        return NULL;    }}

static void rehash (lua_State *L, Hash *t) {  int oldsize = t->size;  Node *nold = t->node;  int nelems = numuse(t);  int i;  LUA_ASSERT(nelems<=oldsize, "wrong count");  if (nelems >= oldsize-oldsize/4)  /* using more than 3/4? */    setnodevector(L, t, (lint32)oldsize*2);  else if (nelems <= oldsize/4 &&  /* less than 1/4? */           oldsize > MINPOWER2)    setnodevector(L, t, oldsize/2);  else    setnodevector(L, t, oldsize);  for (i=0; i<oldsize; i++) {    Node *old = nold+i;    if (ttype(&old->val) != LUA_TNIL)      *luaH_set(L, t, &old->key) = old->val;  }  luaM_free(L, nold);  /* free old array */}

int luaT_efectivetag (TObject *o){  int t;  switch (t = ttype(o)) {    case LUA_T_ARRAY:      return o->value.a->htag;    case LUA_T_USERDATA: {      int tag = o->value.ts->u.d.tag;      return (tag >= 0) ? LUA_T_USERDATA : tag;    }    case LUA_T_CLOSURE:      return o->value.cl->consts[0].ttype;#ifdef DEBUG    case LUA_T_PMARK: case LUA_T_CMARK:    case LUA_T_CLMARK: case LUA_T_LINE:      LUA_INTERNALERROR("invalid type");#endif    default:      return t;  }}

static long int hashindex (TObject *ref){  long int h;  switch (ttype(ref)) {    case LUA_T_NUMBER:      h = (long int)nvalue(ref); break;    case LUA_T_STRING: case LUA_T_USERDATA:      h = tsvalue(ref)->hash; break;    case LUA_T_FUNCTION:      h = (IntPoint)ref->value.tf; break;    case LUA_T_CFUNCTION:      h = (IntPoint)fvalue(ref); break;    case LUA_T_ARRAY:      h = (IntPoint)avalue(ref); break;    default:      lua_error ("unexpected type to index table");      h = 0;  /* UNREACHEABLE */  }  if (h < 0) h = -h;  return h;}

static int32 markobject(TObject *o) {	switch (ttype(o)) {	case LUA_T_STRING:		strmark(tsvalue(o));		break;	case LUA_T_ARRAY:		hashmark(avalue(o));		break;	case LUA_T_CLOSURE:	case LUA_T_CLMARK:		closuremark(o->value.cl);		break;	case LUA_T_PROTO:	case LUA_T_PMARK:		protomark(o->value.tf);		break;	default:		break;  // numbers, cprotos, etc	}	return 0;}

static void markobject (GCState *st, TObject *o) {  switch (ttype(o)) {    case LUA_TUSERDATA:  case LUA_TSTRING:      strmark(tsvalue(o));      break;    case LUA_TMARK:      markclosure(st, infovalue(o)->func);      break;    case LUA_TFUNCTION:      markclosure(st, clvalue(o));      break;    case LUA_TTABLE: {      if (!ismarked(hvalue(o))) {        hvalue(o)->mark = st->tmark;  /* chain it in list of marked */        st->tmark = hvalue(o);      }      break;    }    default: break;  /* numbers, etc */  }}

LUA_API int lua_ref (lua_State *L,  int lock) {  int ref;  if (ttype(L->top-1) == LUA_TNIL)    ref = LUA_REFNIL;  else {    if (L->refFree != NONEXT) {  /* is there a free place? */      ref = L->refFree;      L->refFree = L->refArray[ref].st;    }    else {  /* no more free places */      luaM_growvector(L, L->refArray, L->refSize, 1, struct Ref,                      "reference table overflow", MAX_INT);      L->nblocks += sizeof(struct Ref);      ref = L->refSize++;    }    L->refArray[ref].o = *(L->top-1);    L->refArray[ref].st = lock ? LOCK : HOLD;  }  L->top--;  return ref;}

static void PrintConstant(const Proto* f, int i){	const TValue* o=&f->k[i];	switch (ttypenv(o))	{	case LUA_TNIL:	printf("nil");	break;	case LUA_TBOOLEAN:	printf(bvalue(o) ? "true" : "false");	break;	case LUA_TNUMBER:	printf(LUA_NUMBER_FMT,nvalue(o));	break;	case LUA_TSTRING:	PrintString(rawtsvalue(o));	break;	default:                /* cannot happen */	printf("? type=%d",ttype(o));	break;	}}

void stop_script() {	lua_Object paramObj = lua_getparam(1);	lua_Type type = ttype(Address(paramObj));	LState *state;	if (paramObj == LUA_NOOBJECT || (type != LUA_T_CPROTO && type != LUA_T_PROTO && type != LUA_T_TASK))		lua_error("Bad argument to stop_script");	if (type == LUA_T_TASK) {		uint32 task = (uint32)nvalue(Address(paramObj));		for (state = lua_rootState->next; state != NULL; state = state->next) {			if (state->id == task)				break;		}		if (state) {			if (state != lua_state) {				lua_statedeinit(state);				luaM_free(state);			}		}	} else if (type == LUA_T_PROTO || type == LUA_T_CPROTO) {		for (state = lua_rootState->next; state != NULL;) {			bool match;			if (type == LUA_T_PROTO) {				match = (state->taskFunc.ttype == type && tfvalue(&state->taskFunc) == tfvalue(Address(paramObj)));			} else {				match = (state->taskFunc.ttype == type && fvalue(&state->taskFunc) == fvalue(Address(paramObj)));			}			if (match && state != lua_state) {				LState *tmp = state->next;				lua_statedeinit(state);				luaM_free(state);				state = tmp;			} else {				state = state->next;			}		}	}}

int32 luaC_ref (TObject *o, int32 lock){  int32 ref;  if (ttype(o) == LUA_T_NIL)    ref = -1;   /* special ref for nil */  else {    for (ref=0; ref<L->refSize; ref++)      if (L->refArray[ref].status == FREE)        goto found;    /* no more empty spaces */ {      int32 oldSize = L->refSize;      L->refSize = luaM_growvector(&L->refArray, L->refSize, struct ref,                                   refEM, MAX_INT);      for (ref=oldSize; ref<L->refSize; ref++)        L->refArray[ref].status = FREE;      ref = oldSize;    } found:    L->refArray[ref].o = *o;    L->refArray[ref].status = lock ? LOCK : HOLD;  }  return ref;}

static int traversetable (global_State *g, Table *h) {  int i;  int weakkey = 0;  int weakvalue = 0;  const TValue *mode;  if (h->metatable)    markobject(g, h->metatable);  mode = gfasttm(g, h->metatable, TM_MODE);  if (mode && ttisstring(mode)) {  /* is there a weak mode? */    weakkey = (strchr(svalue(mode), 'k') != NULL);    weakvalue = (strchr(svalue(mode), 'v') != NULL);    if (weakkey || weakvalue) {  /* is really weak? */      h->marked &= ~(KEYWEAK | VALUEWEAK);  /* clear bits */      h->marked |= cast_byte((weakkey << KEYWEAKBIT) |                             (weakvalue << VALUEWEAKBIT));      h->gclist = g->weak;  /* must be cleared after GC, ... */      g->weak = obj2gco(h);  /* ... so put in the appropriate list */    }  }  if (weakkey && weakvalue) return 1;  if (!weakvalue) {    i = h->sizearray;    while (i--)      markvalue(g, &h->array[i]);  }  i = sizenode(h);  while (i--) {    Node *n = gnode(h, i);    lua_assert(ttype(gkey(n)) != LUA_TDEADKEY || ttisnil(gval(n)));    if (ttisnil(gval(n)))      removeentry(n);  /* remove empty entries */    else {      lua_assert(!ttisnil(gkey(n)));      if (!weakkey) markvalue(g, gkey(n));      if (!weakvalue) markvalue(g, gval(n));    }  }  return weakkey || weakvalue;}

static void luaB_foreachvar (void) {  GCnode *g;  TObject f;  /* see comment in 'foreachi' */  f = *luaA_Address(luaL_functionarg(1));  luaD_checkstack(4);  /* for extra var name, f, var name, and globalval */  for (g = L->rootglobal.next; g; g = g->next) {    TaggedString *s = (TaggedString *)g;    if (s->u.s.globalval.ttype != LUA_T_NIL) {      pushtagstring(s);  /* keep (extra) s on stack to avoid GC */      *(L->stack.top++) = f;      pushtagstring(s);      *(L->stack.top++) = s->u.s.globalval;      luaD_calln(2, 1);      if (ttype(L->stack.top-1) != LUA_T_NIL) {        L->stack.top--;        *(L->stack.top-1) = *L->stack.top;  /* remove extra s */        return;      }      L->stack.top-=2;  /* remove result and extra s */    }  }}

LUA_API int lua_setmetatable (lua_State *L, int objindex) {  TObject *obj, *mt;  int res = 1;  lua_lock(L);  api_checknelems(L, 1);  obj = luaA_index(L, objindex);  mt = (!ttisnil(L->top - 1)) ? L->top - 1 : defaultmeta(L);  api_check(L, ttistable(mt));  switch (ttype(obj)) {    case LUA_TTABLE: {#if LUA_REFCOUNT      __AddRefDirect(hvalue(mt));      __ReleaseDirect(L, hvalue(obj)->metatable);#endif LUA_REFCOUNT	  hvalue(obj)->metatable = hvalue(mt);  /* write barrier */      break;    }    case LUA_TUSERDATA: {#if LUA_REFCOUNT      __AddRefDirect(hvalue(mt));	  __ReleaseDirect(L, &uvalue(obj)->uv.metatable);#endif LUA_REFCOUNT      uvalue(obj)->uv.metatable = hvalue(mt);  /* write barrier */      break;    }    default: {      res = 0;  /* cannot set */      break;    }  }#if LUA_REFCOUNT  setnilvalue(--L->top);#else !LUA_REFCOUNT  L->top--;#endif LUA_REFCOUNT  lua_unlock(L);  return res;}

int32 luaT_efectivetag(TObject *o) {	int32 t;	switch (t = ttype(o)) {	case LUA_T_ARRAY:		return o->value.a->htag;	case LUA_T_USERDATA:		{			int32 tag = o->value.ud.tag;			return (tag >= 0) ? LUA_T_USERDATA : tag;		}	case LUA_T_CLOSURE:		return o->value.cl->consts[0].ttype;#ifdef LUA_DEBUG	case LUA_T_PMARK:	case LUA_T_CMARK:	case LUA_T_CLMARK:	case LUA_T_LINE:		lua_error("internal error");#endif	default:		return t;	}}

static void funcinfo (lua_State *L, lua_Debug *ar, StkId func) {  Closure *cl = NULL;  switch (ttype(func)) {    case LUA_TFUNCTION:      cl = clvalue(func);      break;    case LUA_TMARK:      cl = infovalue(func)->func;      break;    default:      lua_error(L, "value for `lua_getinfo' is not a function");  }  if (cl->isC) {    ar->source = "=C";    ar->linedefined = -1;    ar->what = "C";  }  else    infoLproto(ar, cl->f.l);  luaO_chunkid(ar->short_src, ar->source, sizeof(ar->short_src));  if (ar->linedefined == 0)    ar->what = "main";}

void luaV_objlen (lua_State *L, StkId ra, const TValue *rb) {  const TValue *tm;  switch (ttype(rb)) {    case LUA_TTABLE: {      Table *h = hvalue(rb);      tm = fasttm(L, h->metatable, TM_LEN);      if (tm) break;  /* metamethod? break switch to call it */      setnvalue(ra, cast_num(luaH_getn(h)));  /* else primitive len */      return;    }    case LUA_TSTRING: {      setnvalue(ra, cast_num(tsvalue(rb)->len));      return;    }    default: {  /* try metamethod */      tm = luaT_gettmbyobj(L, rb, TM_LEN);      if (ttisnil(tm))  /* no metamethod? */        luaG_typeerror(L, rb, "get length of");      break;    }  }  callTMres(L, ra, tm, rb, luaO_nilobject);}

/*** returns the index of a `key' for table traversals. First goes all** elements in the array part, then elements in the hash part. The** beginning of a traversal is signalled by -1.*/static int findindex (lv_State *L, Table *t, StkId key) {    int i;    if (ttisnil(key)) return -1;  /* first iteration */    i = arrayindex(key);    if (0 < i && i <= t->sizearray)  /* is `key' inside array part? */        return i-1;  /* yes; that's the index (corrected to C) */    else {        Node *n = mainposition(t, key);        do {  /* check whether `key' is somewhere in the chain */            /* key may be dead already, but it is ok to use it in `next' */            if (lvO_rawequalObj(key2tval(n), key) ||                    (ttype(gkey(n)) == LV_TDEADKEY && iscollectable(key) &&                     gcvalue(gkey(n)) == gcvalue(key))) {                i = cast_int(n - gnode(t, 0));  /* key index in hash table */                /* hash elements are numbered after array ones */                return i + t->sizearray;            }            else n = gnext(n);        } while (n);        lvG_runerror(L, "invalid key to " LV_QL("next"));  /* key not found */        return 0;  /* to avoid warnings */    }}

/* * equality of ktap values. ks == NULL means raw equality */int kp_equalobjv(ktap_state *ks, const ktap_value *t1, const ktap_value *t2){	switch (ttype(t1)) {	case KTAP_TNIL:		return 1;	case KTAP_TNUMBER:		return nvalue(t1) == nvalue(t2);	case KTAP_TBOOLEAN:		return bvalue(t1) == bvalue(t2);  /* true must be 1 !! */	case KTAP_TLIGHTUSERDATA:		return pvalue(t1) == pvalue(t2);	case KTAP_TLCF:		return fvalue(t1) == fvalue(t2);	case KTAP_TSHRSTR:		return eqshrstr(rawtsvalue(t1), rawtsvalue(t2));	case KTAP_TLNGSTR:		return kp_tstring_eqlngstr(rawtsvalue(t1), rawtsvalue(t2));	case KTAP_TUSERDATA:		if (uvalue(t1) == uvalue(t2))			return 1;		else if (ks == NULL)			return 0;	case KTAP_TTABLE:		if (hvalue(t1) == hvalue(t2))			return 1;		else if (ks == NULL)			return 0;#ifdef __KERNEL__	case KTAP_TBTRACE:		return kp_btrace_equal(btvalue(t1), btvalue(t2));#endif	default:		return gcvalue(t1) == gcvalue(t2);	}	return 0;}

/*** Call a function (C or Lua). The parameters must be on the stack,** between [top-nArgs,top). The function to be called is right below the** arguments.** When returns, the results are on the stack, between [top-nArgs-1,top).** The number of results is nResults, unless nResults=MULT_RET.*/void luaD_calln (int nArgs, int nResults) {  struct Stack *S = &L->stack;  /* to optimize */  StkId base = (S->top-S->stack)-nArgs;  TObject *func = S->stack+base-1;  StkId firstResult;  int i;  switch (ttype(func)) {    case LUA_T_CPROTO:      ttype(func) = LUA_T_CMARK;      firstResult = callC(fvalue(func), base);      break;    case LUA_T_PROTO:      ttype(func) = LUA_T_PMARK;      firstResult = luaV_execute(NULL, tfvalue(func), base);      break;    case LUA_T_CLOSURE: {      Closure *c = clvalue(func);      TObject *proto = &(c->consts[0]);      ttype(func) = LUA_T_CLMARK;      firstResult = (ttype(proto) == LUA_T_CPROTO) ?                       callCclosure(c, fvalue(proto), base) :                       luaV_execute(c, tfvalue(proto), base);      break;    }    default: { /* func is not a function */      /* Check the tag method for invalid functions */      TObject *im = luaT_getimbyObj(func, IM_FUNCTION);      if (ttype(im) == LUA_T_NIL)        lua_error("call expression not a function");      luaD_callTM(im, (S->top-S->stack)-(base-1), nResults);      return;    }  }  /* adjust the number of results */  if (nResults == MULT_RET)    nResults = (S->top-S->stack)-firstResult;  else    luaD_adjusttop(firstResult+nResults);  /* move results to base-1 (to erase parameters and function) */  base--;  for (i=0; i<nResults; i++)    *(S->stack+base+i) = *(S->stack+firstResult+i);  S->top -= firstResult-base;}

//.........这里部分代码省略.........        Protect(luaV_gettable(L, rb, RKC(i), ra));        continue;      }      case OP_ADD: {        arith_op(luai_numadd, TM_ADD);        continue;      }      case OP_SUB: {        arith_op(luai_numsub, TM_SUB);        continue;      }      case OP_MUL: {        arith_op(luai_nummul, TM_MUL);        continue;      }      case OP_DIV: {        arith_op(luai_numdiv, TM_DIV);        continue;      }      case OP_MOD: {        arith_op(luai_nummod, TM_MOD);        continue;      }      case OP_POW: {        arith_op(luai_numpow, TM_POW);        continue;      }      case OP_UNM: {        TValue *rb = RB(i);        if (ttisnumber(rb)) {          lua_Number nb = nvalue(rb);          setnvalue(ra, luai_numunm(nb));        }        else {          Protect(luaV_arith(L, ra, rb, rb, TM_UNM));        }        continue;      }      case OP_NOT: {        int res = l_isfalse(RB(i));  /* next assignment may change this value */        setbvalue(ra, res);        continue;      }      case OP_LEN: {        const TValue *rb = RB(i);        switch (ttype(rb)) {          case LUA_TTABLE: {            setnvalue(ra, cast_num(luaH_getn(hvalue(rb))));            break;          }          case LUA_TSTRING: {            setnvalue(ra, cast_num(tsvalue(rb)->len));            break;          }          default: {  /* try metamethod */            Protect(              if (!call_binTM(L, rb, luaO_nilobject, ra, TM_LEN))                luaG_typeerror(L, rb, "get length of");            )          }        }        continue;      }      case OP_CONCAT: {        int b = GETARG_B(i);        int c = GETARG_C(i);        Protect(luaV_concat(L, c-b+1, c); luaC_checkGC(L));        setobjs2s(L, RA(i), base+b);        continue;      }      case OP_JMP: {        dojump(L, pc, GETARG_sBx(i));        continue;      }      case OP_EQ: {        TValue *rb = RKB(i);        TValue *rc = RKC(i);        Protect(          if (equalobj(L, rb, rc) == GETARG_A(i))            dojump(L, pc, GETARG_sBx(*pc));        )        pc++;        continue;      }      case OP_LT: {        Protect(          if (luaV_lessthan(L, RKB(i), RKC(i)) == GETARG_A(i))            dojump(L, pc, GETARG_sBx(*pc));        )        pc++;        continue;      }      case OP_LE: {        Protect(          if (luaV_lessequal(L, RKB(i), RKC(i)) == GETARG_A(i))            dojump(L, pc, GETARG_sBx(*pc));        )        pc++;        continue;      }

/*** Executes the given Lua function. Parameters are between [base,top).** Returns n such that the the results are between [n,top).*/StkId luaV_execute (lua_State *L, const Closure *cl, StkId base) {  const Proto *const tf = cl->f.l;  StkId top;  /* keep top local, for performance */  const Instruction *pc = tf->code;  TString **const kstr = tf->kstr;  const lua_Hook linehook = L->linehook;  infovalue(base-1)->pc = &pc;  luaD_checkstack(L, tf->maxstacksize+EXTRA_STACK);  if (tf->is_vararg)  /* varargs? */    adjust_varargs(L, base, tf->numparams);  else    luaD_adjusttop(L, base, tf->numparams);  top = L->top;  /* main loop of interpreter */  for (;;) {    const Instruction i = *pc++;    if (linehook)      traceexec(L, base, top, linehook);    switch (GET_OPCODE(i)) {      case OP_END: {        L->top = top;        return top;      }      case OP_RETURN: {        L->top = top;        return base+GETARG_U(i);      }      case OP_CALL: {        int nres = GETARG_B(i);        if (nres == MULT_RET) nres = LUA_MULTRET;        L->top = top;        luaD_call(L, base+GETARG_A(i), nres);        top = L->top;        break;      }      case OP_TAILCALL: {        L->top = top;        luaD_call(L, base+GETARG_A(i), LUA_MULTRET);        return base+GETARG_B(i);      }      case OP_PUSHNIL: {        int n = GETARG_U(i);        LUA_ASSERT(n>0, "invalid argument");        do {          ttype(top++) = LUA_TNIL;        } while (--n > 0);        break;      }      case OP_POP: {        top -= GETARG_U(i);        break;      }      case OP_PUSHINT: {        ttype(top) = LUA_TNUMBER;        nvalue(top) = (Number)GETARG_S(i);        top++;        break;      }      case OP_PUSHSTRING: {        ttype(top) = LUA_TSTRING;        tsvalue(top) = kstr[GETARG_U(i)];        top++;        break;      }      case OP_PUSHNUM: {        ttype(top) = LUA_TNUMBER;        nvalue(top) = tf->knum[GETARG_U(i)];        top++;        break;      }      case OP_PUSHNEGNUM: {        ttype(top) = LUA_TNUMBER;        nvalue(top) = -tf->knum[GETARG_U(i)];        top++;        break;      }      case OP_PUSHUPVALUE: {        *top++ = cl->upvalue[GETARG_U(i)];        break;      }      case OP_GETLOCAL: {        *top++ = *(base+GETARG_U(i));        break;      }      case OP_GETGLOBAL: {        L->top = top;        *top = *luaV_getglobal(L, kstr[GETARG_U(i)]);        top++;        break;      }      case OP_GETTABLE: {        L->top = top;        top--;        *(top-1) = *luaV_gettable(L, top-1);        break;      }//.........这里部分代码省略.........

LUA_API void lua_setglobals (lua_State *L) {  StkId newtable = --L->top;  LUA_ASSERT(ttype(newtable) == LUA_TTABLE, "table expected");  L->gt = hvalue(newtable);}

//.........这里部分代码省略.........    case PUSHNUMBER0:    case PUSHNUMBER1:    case PUSHNUMBER2:      aux = opc - PUSHNUMBER0;      goto pushnumber;    case PUSHNUMBERW:      aux = start[0] | (start[1] << 8);      start += 2;    pushnumber:      stk->push(new NumberExpr(start, aux));      break;    case PUSHCONSTANT:      aux = *start++;      goto pushconst;    case PUSHCONSTANT0:    case PUSHCONSTANT1:    case PUSHCONSTANT2:    case PUSHCONSTANT3:    case PUSHCONSTANT4:    case PUSHCONSTANT5:    case PUSHCONSTANT6:    case PUSHCONSTANT7:      aux = opc - PUSHCONSTANT0;      goto pushconst;    case PUSHCONSTANTW:      aux = start[0] | (start[1] << 8);      start += 2;    pushconst:      switch (ttype(tf->consts + aux)) {      case LUA_T_STRING:	stk->push(new StringExpr(start, tsvalue(tf->consts + aux)));	break;      case LUA_T_NUMBER:	stk->push(new NumberExpr(start, nvalue(tf->consts + aux)));	break;      case LUA_T_PROTO:	stk->push(new FuncExpr(start, tfvalue(tf->consts + aux), indent_str));	break;      default:	*os << indent_str << "error: invalid constant type "	    << int(ttype(tf->consts + aux)) << std::endl;      }      break;    case PUSHUPVALUE:      aux = *start++;      goto pushupvalue;    case PUSHUPVALUE0:    case PUSHUPVALUE1:      aux = opc - PUSHUPVALUE0;    pushupvalue:      {	if (aux >= num_upvals) {	  *os << indent_str << "error: invalid upvalue #"	      << aux << std::endl;	}	std::ostringstream s;	s << "%" << *upvals[aux];	stk->push(new VarExpr(start, s.str()));

static void luaI_type() {	lua_Object o = luaL_nonnullarg(1);	lua_pushstring(luaO_typenames[-ttype(luaA_Address(o))]);	lua_pushnumber(lua_tag(o));}

TObject *luaH_setint (lua_State *L, Hash *t, int key) {  TObject index;  ttype(&index) = LUA_TNUMBER;  nvalue(&index) = key;  return luaH_set(L, t, &index);}

	loop2(TypBin, ptBin, nCorrTyp, nPtBins)	{		float pt1 = PtRes::PtBinLow(  ptBin);		float pt2 = PtRes::PtBinHigh( ptBin);		gStyle->SetOptStat(0);		double nEntries = RelDiffPt[TypBin][ptBin]->Integral();		RelDiffPt[TypBin][ptBin]->Scale(1./nEntries);		RelDiffPt_Func[TypBin][ptBin]->SetParameter(1, 0.0);		RelDiffPt_Func[TypBin][ptBin]->SetParameter(2, 0.1);		RelDiffPt[TypBin][ptBin]->Fit( RelDiffPt_Func[TypBin][ptBin] );		TCanvas canv ("canv",";lel;",1024,768);		canv.SetLeftMargin  ( RelDiffPt_leftmargin   );		canv.SetRightMargin ( RelDiffPt_rightmargin  );		canv.SetTopMargin   ( RelDiffPt_topmargin    );		canv.SetBottomMargin( RelDiffPt_bottommargin );		RelDiffPt[TypBin][ptBin]->SetTitle("");		//RelDiffPt[TypBin][ptBin]->GetXaxis()->CenterTitle(1);		RelDiffPt[TypBin][ptBin]->GetXaxis()->SetTitleSize( RelDiffPt_xlabelsize );		RelDiffPt[TypBin][ptBin]->GetXaxis()->SetTitle( "x = #frac{p_{T}^{reco}-p_{T}^{gen}}{p_{T}^{gen}}" );		RelDiffPt[TypBin][ptBin]->GetYaxis()->SetTitleSize( RelDiffPt_ylabelsize );		RelDiffPt[TypBin][ptBin]->GetYaxis()->SetTitle( "occurance" );		RelDiffPt[TypBin][ptBin]->SetTitleOffset( RelDiffPt_xlabeloffset ,"X");		RelDiffPt[TypBin][ptBin]->SetTitleOffset( RelDiffPt_ylabeloffset ,"Y");		RelDiffPt[TypBin][ptBin]->GetYaxis()->CenterTitle(1);		double amp   = abs(RelDiffPt_Func[TypBin][ptBin]->GetParameter(0));		double x0    = abs(RelDiffPt_Func[TypBin][ptBin]->GetParameter(1));		double sigma = abs(RelDiffPt_Func[TypBin][ptBin]->GetParameter(2));		double amp_Err   = abs(RelDiffPt_Func[TypBin][ptBin]->GetParError(0));		double x0_Err    = abs(RelDiffPt_Func[TypBin][ptBin]->GetParError(1));		double sigma_Err = abs(RelDiffPt_Func[TypBin][ptBin]->GetParError(2));		RelDiffPtSigma[TypBin][ptBin] = sigma; 		RelDiffPtMean [TypBin][ptBin] = x0;		(*PtResolutionParams[TypBin][ptBin])[0] = sigma;		(*PtResolutionParams[TypBin][ptBin])[1] = x0;		TLatex tres( RelDiffPt_tres_upperleftposx, RelDiffPt_tres_upperleftposy , Form("#splitline{#splitline{amp = %.3f #pm %.3f}{x_{0} = %.3f #pm %.3f}}{#sigma = %.3f #pm %.3f}", amp, amp_Err, x0, x0_Err, sigma, sigma_Err) ); 		tres.SetTextSize( RelDiffPt_figuretextsize );		tres.SetNDC(kTRUE);		TLatex ttype( RelDiffPt_ttype_upperleftposx, RelDiffPt_ttype_upperleftposy , Form("#splitline{%s}{p_{T} = [%.2f - %.2f] GeV/c}", particletype(TypBin).c_str(), pt1, pt2 ) ); 		ttype.SetTextSize( RelDiffPt_figuretextsize );		ttype.SetNDC(kTRUE);		RelDiffPt[TypBin][ptBin]->Draw("");		tres.Draw();		ttype.Draw();		std::string dir   = Form("./figures/");		std::string filePDF = Form("PtRelDiff_%d_pt_%.2f-%.2f.pdf", TypBin, pt1, pt2);		std::string filePNG = Form("PtRelDiff_%d_pt_%.2f-%.2f.png", TypBin, pt1, pt2);		std::string figurePNG = dir+filePNG;		std::string figurePDF = dir+filePDF;		canv.SaveAs( figurePNG.c_str() );		canv.SaveAs( figurePDF.c_str() );		canv.Clear();	}

static UpVal *toupval(lua_State *L, int stackpos){	lua_assert(ttype(getobject(L, stackpos)) == LUA_TUPVAL);	return gco2uv(getobject(L, stackpos)->value.gc);}

LUA_API int lua_type (lua_State *L, int idx) {  StkId o = luaA_indexAcceptable(L, idx);  return (o == NULL) ? LUA_TNONE : ttype(o);}

void current_script() {	ttype(lua_state->stack.top) = LUA_T_TASK;	nvalue(lua_state->stack.top) = (float)lua_state->id;	incr_top;}

static void init_entry (int tag){  int i;  for (i=0; i<IM_N; i++)    ttype(luaT_getim(tag, i)) = LUA_T_NIL;}