Line data    Source code

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