1 /* $NetBSD: lfunc.c,v 1.2 2014/07/19 18:38:34 lneto Exp $ */ 2 3 /* 4 ** $Id: lfunc.c,v 1.2 2014/07/19 18:38:34 lneto Exp $ 5 ** Auxiliary functions to manipulate prototypes and closures 6 ** See Copyright Notice in lua.h 7 */ 8 9 10 #ifndef _KERNEL 11 #include <stddef.h> 12 #endif 13 14 #define lfunc_c 15 #define LUA_CORE 16 17 #include "lua.h" 18 19 #include "lfunc.h" 20 #include "lgc.h" 21 #include "lmem.h" 22 #include "lobject.h" 23 #include "lstate.h" 24 25 26 27 CClosure *luaF_newCclosure (lua_State *L, int n) { 28 GCObject *o = luaC_newobj(L, LUA_TCCL, sizeCclosure(n)); 29 CClosure *c = gco2ccl(o); 30 c->nupvalues = cast_byte(n); 31 return c; 32 } 33 34 35 LClosure *luaF_newLclosure (lua_State *L, int n) { 36 GCObject *o = luaC_newobj(L, LUA_TLCL, sizeLclosure(n)); 37 LClosure *c = gco2lcl(o); 38 c->p = NULL; 39 c->nupvalues = cast_byte(n); 40 while (n--) c->upvals[n] = NULL; 41 return c; 42 } 43 44 /* 45 ** fill a closure with new closed upvalues 46 */ 47 void luaF_initupvals (lua_State *L, LClosure *cl) { 48 int i; 49 for (i = 0; i < cl->nupvalues; i++) { 50 UpVal *uv = luaM_new(L, UpVal); 51 uv->refcount = 1; 52 uv->v = &uv->u.value; /* make it closed */ 53 setnilvalue(uv->v); 54 cl->upvals[i] = uv; 55 } 56 } 57 58 59 UpVal *luaF_findupval (lua_State *L, StkId level) { 60 UpVal **pp = &L->openupval; 61 UpVal *p; 62 UpVal *uv; 63 lua_assert(isintwups(L) || L->openupval == NULL); 64 while (*pp != NULL && (p = *pp)->v >= level) { 65 lua_assert(upisopen(p)); 66 if (p->v == level) /* found a corresponding upvalue? */ 67 return p; /* return it */ 68 pp = &p->u.open.next; 69 } 70 /* not found: create a new upvalue */ 71 uv = luaM_new(L, UpVal); 72 uv->refcount = 0; 73 uv->u.open.next = *pp; /* link it to list of open upvalues */ 74 uv->u.open.touched = 1; 75 *pp = uv; 76 uv->v = level; /* current value lives in the stack */ 77 if (!isintwups(L)) { /* thread not in list of threads with upvalues? */ 78 L->twups = G(L)->twups; /* link it to the list */ 79 G(L)->twups = L; 80 } 81 return uv; 82 } 83 84 85 void luaF_close (lua_State *L, StkId level) { 86 UpVal *uv; 87 while (L->openupval != NULL && (uv = L->openupval)->v >= level) { 88 lua_assert(upisopen(uv)); 89 L->openupval = uv->u.open.next; /* remove from `open' list */ 90 if (uv->refcount == 0) /* no references? */ 91 luaM_free(L, uv); /* free upvalue */ 92 else { 93 setobj(L, &uv->u.value, uv->v); /* move value to upvalue slot */ 94 uv->v = &uv->u.value; /* now current value lives here */ 95 luaC_upvalbarrier(L, uv); 96 } 97 } 98 } 99 100 101 Proto *luaF_newproto (lua_State *L) { 102 GCObject *o = luaC_newobj(L, LUA_TPROTO, sizeof(Proto)); 103 Proto *f = gco2p(o); 104 f->k = NULL; 105 f->sizek = 0; 106 f->p = NULL; 107 f->sizep = 0; 108 f->code = NULL; 109 f->cache = NULL; 110 f->sizecode = 0; 111 f->lineinfo = NULL; 112 f->sizelineinfo = 0; 113 f->upvalues = NULL; 114 f->sizeupvalues = 0; 115 f->numparams = 0; 116 f->is_vararg = 0; 117 f->maxstacksize = 0; 118 f->locvars = NULL; 119 f->sizelocvars = 0; 120 f->linedefined = 0; 121 f->lastlinedefined = 0; 122 f->source = NULL; 123 return f; 124 } 125 126 127 void luaF_freeproto (lua_State *L, Proto *f) { 128 luaM_freearray(L, f->code, f->sizecode); 129 luaM_freearray(L, f->p, f->sizep); 130 luaM_freearray(L, f->k, f->sizek); 131 luaM_freearray(L, f->lineinfo, f->sizelineinfo); 132 luaM_freearray(L, f->locvars, f->sizelocvars); 133 luaM_freearray(L, f->upvalues, f->sizeupvalues); 134 luaM_free(L, f); 135 } 136 137 138 /* 139 ** Look for n-th local variable at line `line' in function `func'. 140 ** Returns NULL if not found. 141 */ 142 const char *luaF_getlocalname (const Proto *f, int local_number, int pc) { 143 int i; 144 for (i = 0; i<f->sizelocvars && f->locvars[i].startpc <= pc; i++) { 145 if (pc < f->locvars[i].endpc) { /* is variable active? */ 146 local_number--; 147 if (local_number == 0) 148 return getstr(f->locvars[i].varname); 149 } 150 } 151 return NULL; /* not found */ 152 } 153 154