[proxmark3-svn] / liblua / lstate.c

/*
** $Id: lstate.c,v 2.99 2012/10/02 17:40:53 roberto Exp $
** Global State
** See Copyright Notice in lua.h
*/


#include <stddef.h>
#include <string.h>

#define lstate_c
#define LUA_CORE

#include "lua.h"

#include "lapi.h"
#include "ldebug.h"
#include "ldo.h"
#include "lfunc.h"
#include "lgc.h"
#include "llex.h"
#include "lmem.h"
#include "lstate.h"
#include "lstring.h"
#include "ltable.h"
#include "ltm.h"


#if !defined(LUAI_GCPAUSE)
#define LUAI_GCPAUSE	200  /* 200% */
#endif

#if !defined(LUAI_GCMAJOR)
#define LUAI_GCMAJOR	200  /* 200% */
#endif

#if !defined(LUAI_GCMUL)
#define LUAI_GCMUL	200 /* GC runs 'twice the speed' of memory allocation */
#endif


#define MEMERRMSG	"not enough memory"


/*
** a macro to help the creation of a unique random seed when a state is
** created; the seed is used to randomize hashes.
*/
#if !defined(luai_makeseed)
#include <time.h>
#define luai_makeseed()		cast(unsigned int, time(NULL))
#endif


/*
** thread state + extra space
*/
typedef struct LX {
#if defined(LUAI_EXTRASPACE)
  char buff[LUAI_EXTRASPACE];
#endif
  lua_State l;
} LX;


/*
** Main thread combines a thread state and the global state
*/
typedef struct LG {
  LX l;
  global_State g;
} LG;


#define fromstate(L)	(cast(LX *, cast(lu_byte *, (L)) - offsetof(LX, l)))


/*
** Compute an initial seed as random as possible. In ANSI, rely on
** Address Space Layout Randomization (if present) to increase
** randomness..
*/
#define addbuff(b,p,e) \
  { size_t t = cast(size_t, e); \
    memcpy(buff + p, &t, sizeof(t)); p += sizeof(t); }

static unsigned int makeseed (lua_State *L) {
  char buff[4 * sizeof(size_t)];
  unsigned int h = luai_makeseed();
  int p = 0;
  addbuff(buff, p, L);  /* heap variable */
  addbuff(buff, p, &h);  /* local variable */
  addbuff(buff, p, luaO_nilobject);  /* global variable */
  addbuff(buff, p, &lua_newstate);  /* public function */
  lua_assert(p == sizeof(buff));
  return luaS_hash(buff, p, h);
}


/*
** set GCdebt to a new value keeping the value (totalbytes + GCdebt)
** invariant
*/
void luaE_setdebt (global_State *g, l_mem debt) {
  g->totalbytes -= (debt - g->GCdebt);
  g->GCdebt = debt;
}


CallInfo *luaE_extendCI (lua_State *L) {
  CallInfo *ci = luaM_new(L, CallInfo);
  lua_assert(L->ci->next == NULL);
  L->ci->next = ci;
  ci->previous = L->ci;
  ci->next = NULL;
  return ci;
}


void luaE_freeCI (lua_State *L) {
  CallInfo *ci = L->ci;
  CallInfo *next = ci->next;
  ci->next = NULL;
  while ((ci = next) != NULL) {
    next = ci->next;
    luaM_free(L, ci);
  }
}


static void stack_init (lua_State *L1, lua_State *L) {
  int i; CallInfo *ci;
  /* initialize stack array */
  L1->stack = luaM_newvector(L, BASIC_STACK_SIZE, TValue);
  L1->stacksize = BASIC_STACK_SIZE;
  for (i = 0; i < BASIC_STACK_SIZE; i++)
    setnilvalue(L1->stack + i);  /* erase new stack */
  L1->top = L1->stack;
  L1->stack_last = L1->stack + L1->stacksize - EXTRA_STACK;
  /* initialize first ci */
  ci = &L1->base_ci;
  ci->next = ci->previous = NULL;
  ci->callstatus = 0;
  ci->func = L1->top;
  setnilvalue(L1->top++);  /* 'function' entry for this 'ci' */
  ci->top = L1->top + LUA_MINSTACK;
  L1->ci = ci;
}


static void freestack (lua_State *L) {
  if (L->stack == NULL)
    return;  /* stack not completely built yet */
  L->ci = &L->base_ci;  /* free the entire 'ci' list */
  luaE_freeCI(L);
  luaM_freearray(L, L->stack, L->stacksize);  /* free stack array */
}


/*
** Create registry table and its predefined values
*/
static void init_registry (lua_State *L, global_State *g) {
  TValue mt;
  /* create registry */
  Table *registry = luaH_new(L);
  sethvalue(L, &g->l_registry, registry);
  luaH_resize(L, registry, LUA_RIDX_LAST, 0);
  /* registry[LUA_RIDX_MAINTHREAD] = L */
  setthvalue(L, &mt, L);
  luaH_setint(L, registry, LUA_RIDX_MAINTHREAD, &mt);
  /* registry[LUA_RIDX_GLOBALS] = table of globals */
  sethvalue(L, &mt, luaH_new(L));
  luaH_setint(L, registry, LUA_RIDX_GLOBALS, &mt);
}


/*
** open parts of the state that may cause memory-allocation errors
*/
static void f_luaopen (lua_State *L, void *ud) {
  global_State *g = G(L);
  UNUSED(ud);
  stack_init(L, L);  /* init stack */
  init_registry(L, g);
  luaS_resize(L, MINSTRTABSIZE);  /* initial size of string table */
  luaT_init(L);
  luaX_init(L);
  /* pre-create memory-error message */
  g->memerrmsg = luaS_newliteral(L, MEMERRMSG);
  luaS_fix(g->memerrmsg);  /* it should never be collected */
  g->gcrunning = 1;  /* allow gc */
}


/*
** preinitialize a state with consistent values without allocating
** any memory (to avoid errors)
*/
static void preinit_state (lua_State *L, global_State *g) {
  G(L) = g;
  L->stack = NULL;
  L->ci = NULL;
  L->stacksize = 0;
  L->errorJmp = NULL;
  L->nCcalls = 0;
  L->hook = NULL;
  L->hookmask = 0;
  L->basehookcount = 0;
  L->allowhook = 1;
  resethookcount(L);
  L->openupval = NULL;
  L->nny = 1;
  L->status = LUA_OK;
  L->errfunc = 0;
}


static void close_state (lua_State *L) {
  global_State *g = G(L);
  luaF_close(L, L->stack);  /* close all upvalues for this thread */
  luaC_freeallobjects(L);  /* collect all objects */
  luaM_freearray(L, G(L)->strt.hash, G(L)->strt.size);
  luaZ_freebuffer(L, &g->buff);
  freestack(L);
  lua_assert(gettotalbytes(g) == sizeof(LG));
  (*g->frealloc)(g->ud, fromstate(L), sizeof(LG), 0);  /* free main block */
}


LUA_API lua_State *lua_newthread (lua_State *L) {
  lua_State *L1;
  lua_lock(L);
  luaC_checkGC(L);
  L1 = &luaC_newobj(L, LUA_TTHREAD, sizeof(LX), NULL, offsetof(LX, l))->th;
  setthvalue(L, L->top, L1);
  api_incr_top(L);
  preinit_state(L1, G(L));
  L1->hookmask = L->hookmask;
  L1->basehookcount = L->basehookcount;
  L1->hook = L->hook;
  resethookcount(L1);
  luai_userstatethread(L, L1);
  stack_init(L1, L);  /* init stack */
  lua_unlock(L);
  return L1;
}


void luaE_freethread (lua_State *L, lua_State *L1) {
  LX *l = fromstate(L1);
  luaF_close(L1, L1->stack);  /* close all upvalues for this thread */
  lua_assert(L1->openupval == NULL);
  luai_userstatefree(L, L1);
  freestack(L1);
  luaM_free(L, l);
}


LUA_API lua_State *lua_newstate (lua_Alloc f, void *ud) {
  int i;
  lua_State *L;
  global_State *g;
  LG *l = cast(LG *, (*f)(ud, NULL, LUA_TTHREAD, sizeof(LG)));
  if (l == NULL) return NULL;
  L = &l->l.l;
  g = &l->g;
  L->next = NULL;
  L->tt = LUA_TTHREAD;
  g->currentwhite = bit2mask(WHITE0BIT, FIXEDBIT);
  L->marked = luaC_white(g);
  g->gckind = KGC_NORMAL;
  preinit_state(L, g);
  g->frealloc = f;
  g->ud = ud;
  g->mainthread = L;
  g->seed = makeseed(L);
  g->uvhead.u.l.prev = &g->uvhead;
  g->uvhead.u.l.next = &g->uvhead;
  g->gcrunning = 0;  /* no GC while building state */
  g->GCestimate = 0;
  g->strt.size = 0;
  g->strt.nuse = 0;
  g->strt.hash = NULL;
  setnilvalue(&g->l_registry);
  luaZ_initbuffer(L, &g->buff);
  g->panic = NULL;
  g->version = lua_version(NULL);
  g->gcstate = GCSpause;
  g->allgc = NULL;
  g->finobj = NULL;
  g->tobefnz = NULL;
  g->sweepgc = g->sweepfin = NULL;
  g->gray = g->grayagain = NULL;
  g->weak = g->ephemeron = g->allweak = NULL;
  g->totalbytes = sizeof(LG);
  g->GCdebt = 0;
  g->gcpause = LUAI_GCPAUSE;
  g->gcmajorinc = LUAI_GCMAJOR;
  g->gcstepmul = LUAI_GCMUL;
  for (i=0; i < LUA_NUMTAGS; i++) g->mt[i] = NULL;
  if (luaD_rawrunprotected(L, f_luaopen, NULL) != LUA_OK) {
    /* memory allocation error: free partial state */
    close_state(L);
    L = NULL;
  }
  else
    luai_userstateopen(L);
  return L;
}


LUA_API void lua_close (lua_State *L) {
  L = G(L)->mainthread;  /* only the main thread can be closed */
  lua_lock(L);
  luai_userstateclose(L);
  close_state(L);
}
Commit	Line	Data
ba8b5c17	1	/*
	2	** $Id: lstate.c,v 2.99 2012/10/02 17:40:53 roberto Exp $
	3	** Global State
	4	** See Copyright Notice in lua.h
	5	*/
	6
	7
	8	#include <stddef.h>
	9	#include <string.h>
	10
	11	#define lstate_c
	12	#define LUA_CORE
	13
	14	#include "lua.h"
	15
	16	#include "lapi.h"
	17	#include "ldebug.h"
	18	#include "ldo.h"
	19	#include "lfunc.h"
	20	#include "lgc.h"
	21	#include "llex.h"
	22	#include "lmem.h"
	23	#include "lstate.h"
	24	#include "lstring.h"
	25	#include "ltable.h"
	26	#include "ltm.h"
	27
	28
	29	#if !defined(LUAI_GCPAUSE)
	30	#define LUAI_GCPAUSE 200 /* 200% */
	31	#endif
	32
	33	#if !defined(LUAI_GCMAJOR)
	34	#define LUAI_GCMAJOR 200 /* 200% */
	35	#endif
	36
	37	#if !defined(LUAI_GCMUL)
	38	#define LUAI_GCMUL 200 /* GC runs 'twice the speed' of memory allocation */
	39	#endif
	40
	41
	42	#define MEMERRMSG "not enough memory"
	43
	44
	45	/*
	46	** a macro to help the creation of a unique random seed when a state is
	47	** created; the seed is used to randomize hashes.
	48	*/
	49	#if !defined(luai_makeseed)
	50	#include <time.h>
	51	#define luai_makeseed() cast(unsigned int, time(NULL))
	52	#endif
	53
	54
	55
	56	/*
	57	** thread state + extra space
	58	*/
	59	typedef struct LX {
	60	#if defined(LUAI_EXTRASPACE)
	61	char buff[LUAI_EXTRASPACE];
	62	#endif
	63	lua_State l;
	64	} LX;
65
66
67	/*
68	** Main thread combines a thread state and the global state
69	*/
70	typedef struct LG {
71	LX l;
72	global_State g;
73	} LG;
74
75
76
77	#define fromstate(L) (cast(LX , cast(lu_byte , (L)) - offsetof(LX, l)))
78
79
80	/*
81	** Compute an initial seed as random as possible. In ANSI, rely on
82	** Address Space Layout Randomization (if present) to increase
83	** randomness..
84	*/
85	#define addbuff(b,p,e) \
86	{ size_t t = cast(size_t, e); \
87	memcpy(buff + p, &t, sizeof(t)); p += sizeof(t); }
88
89	static unsigned int makeseed (lua_State *L) {
90	char buff[4 * sizeof(size_t)];
91	unsigned int h = luai_makeseed();
92	int p = 0;
93	addbuff(buff, p, L); /* heap variable */
94	addbuff(buff, p, &h); /* local variable */
95	addbuff(buff, p, luaO_nilobject); /* global variable */
96	addbuff(buff, p, &lua_newstate); /* public function */
97	lua_assert(p == sizeof(buff));
98	return luaS_hash(buff, p, h);
99	}
100
101
102	/*
103	** set GCdebt to a new value keeping the value (totalbytes + GCdebt)
104	** invariant
105	*/
106	void luaE_setdebt (global_State *g, l_mem debt) {
107	g->totalbytes -= (debt - g->GCdebt);
108	g->GCdebt = debt;
109	}
110
111
112	CallInfo luaE_extendCI (lua_State L) {
113	CallInfo *ci = luaM_new(L, CallInfo);
114	lua_assert(L->ci->next == NULL);
115	L->ci->next = ci;
116	ci->previous = L->ci;
117	ci->next = NULL;
118	return ci;
119	}
120
121
122	void luaE_freeCI (lua_State *L) {
123	CallInfo *ci = L->ci;
124	CallInfo *next = ci->next;
125	ci->next = NULL;
126	while ((ci = next) != NULL) {
127	next = ci->next;
128	luaM_free(L, ci);
129	}
130	}
131
132
133	static void stack_init (lua_State L1, lua_State L) {
134	int i; CallInfo *ci;
135	/* initialize stack array */
136	L1->stack = luaM_newvector(L, BASIC_STACK_SIZE, TValue);
137	L1->stacksize = BASIC_STACK_SIZE;
138	for (i = 0; i < BASIC_STACK_SIZE; i++)
139	setnilvalue(L1->stack + i); /* erase new stack */
140	L1->top = L1->stack;
141	L1->stack_last = L1->stack + L1->stacksize - EXTRA_STACK;
142	/* initialize first ci */
143	ci = &L1->base_ci;
144	ci->next = ci->previous = NULL;
145	ci->callstatus = 0;
146	ci->func = L1->top;
147	setnilvalue(L1->top++); /* 'function' entry for this 'ci' */
148	ci->top = L1->top + LUA_MINSTACK;
149	L1->ci = ci;
150	}
151
152
153	static void freestack (lua_State *L) {
154	if (L->stack == NULL)
155	return; /* stack not completely built yet */
156	L->ci = &L->base_ci; /* free the entire 'ci' list */
157	luaE_freeCI(L);
158	luaM_freearray(L, L->stack, L->stacksize); /* free stack array */
159	}
160
161
162	/*
163	** Create registry table and its predefined values
164	*/
165	static void init_registry (lua_State L, global_State g) {
166	TValue mt;
167	/* create registry */
168	Table *registry = luaH_new(L);
169	sethvalue(L, &g->l_registry, registry);
170	luaH_resize(L, registry, LUA_RIDX_LAST, 0);
171	/* registry[LUA_RIDX_MAINTHREAD] = L */
172	setthvalue(L, &mt, L);
173	luaH_setint(L, registry, LUA_RIDX_MAINTHREAD, &mt);
174	/* registry[LUA_RIDX_GLOBALS] = table of globals */
175	sethvalue(L, &mt, luaH_new(L));
176	luaH_setint(L, registry, LUA_RIDX_GLOBALS, &mt);
177	}
178
179
180	/*
181	** open parts of the state that may cause memory-allocation errors
182	*/
183	static void f_luaopen (lua_State L, void ud) {
184	global_State *g = G(L);
185	UNUSED(ud);
186	stack_init(L, L); /* init stack */
187	init_registry(L, g);
188	luaS_resize(L, MINSTRTABSIZE); /* initial size of string table */
189	luaT_init(L);
190	luaX_init(L);
191	/* pre-create memory-error message */
192	g->memerrmsg = luaS_newliteral(L, MEMERRMSG);
193	luaS_fix(g->memerrmsg); /* it should never be collected */
194	g->gcrunning = 1; /* allow gc */
195	}
196
197
198	/*
199	** preinitialize a state with consistent values without allocating
200	** any memory (to avoid errors)
201	*/
202	static void preinit_state (lua_State L, global_State g) {
203	G(L) = g;
204	L->stack = NULL;
205	L->ci = NULL;
206	L->stacksize = 0;
207	L->errorJmp = NULL;
208	L->nCcalls = 0;
209	L->hook = NULL;
210	L->hookmask = 0;
211	L->basehookcount = 0;
212	L->allowhook = 1;
213	resethookcount(L);
214	L->openupval = NULL;
215	L->nny = 1;
216	L->status = LUA_OK;
217	L->errfunc = 0;
218	}
219
220
221	static void close_state (lua_State *L) {
222	global_State *g = G(L);
223	luaF_close(L, L->stack); /* close all upvalues for this thread */
224	luaC_freeallobjects(L); /* collect all objects */
225	luaM_freearray(L, G(L)->strt.hash, G(L)->strt.size);
226	luaZ_freebuffer(L, &g->buff);
227	freestack(L);
228	lua_assert(gettotalbytes(g) == sizeof(LG));
229	(g->frealloc)(g->ud, fromstate(L), sizeof(LG), 0); / free main block */
230	}
231
232
233	LUA_API lua_State lua_newthread (lua_State L) {
234	lua_State *L1;
235	lua_lock(L);
236	luaC_checkGC(L);
237	L1 = &luaC_newobj(L, LUA_TTHREAD, sizeof(LX), NULL, offsetof(LX, l))->th;
238	setthvalue(L, L->top, L1);
239	api_incr_top(L);
240	preinit_state(L1, G(L));
241	L1->hookmask = L->hookmask;
242	L1->basehookcount = L->basehookcount;
243	L1->hook = L->hook;
244	resethookcount(L1);
245	luai_userstatethread(L, L1);
246	stack_init(L1, L); /* init stack */
247	lua_unlock(L);
248	return L1;
249	}
250
251
252	void luaE_freethread (lua_State L, lua_State L1) {
253	LX *l = fromstate(L1);
254	luaF_close(L1, L1->stack); /* close all upvalues for this thread */
255	lua_assert(L1->openupval == NULL);
256	luai_userstatefree(L, L1);
257	freestack(L1);
258	luaM_free(L, l);
259	}
260
261
262	LUA_API lua_State lua_newstate (lua_Alloc f, void ud) {
263	int i;
264	lua_State *L;
265	global_State *g;
266	LG l = cast(LG , (*f)(ud, NULL, LUA_TTHREAD, sizeof(LG)));
267	if (l == NULL) return NULL;
268	L = &l->l.l;
269	g = &l->g;
270	L->next = NULL;
271	L->tt = LUA_TTHREAD;
272	g->currentwhite = bit2mask(WHITE0BIT, FIXEDBIT);
273	L->marked = luaC_white(g);
274	g->gckind = KGC_NORMAL;
275	preinit_state(L, g);
276	g->frealloc = f;
277	g->ud = ud;
278	g->mainthread = L;
279	g->seed = makeseed(L);
280	g->uvhead.u.l.prev = &g->uvhead;
281	g->uvhead.u.l.next = &g->uvhead;
282	g->gcrunning = 0; /* no GC while building state */
283	g->GCestimate = 0;
284	g->strt.size = 0;
285	g->strt.nuse = 0;
286	g->strt.hash = NULL;
287	setnilvalue(&g->l_registry);
288	luaZ_initbuffer(L, &g->buff);
289	g->panic = NULL;
290	g->version = lua_version(NULL);
291	g->gcstate = GCSpause;
292	g->allgc = NULL;
293	g->finobj = NULL;
294	g->tobefnz = NULL;
295	g->sweepgc = g->sweepfin = NULL;
296	g->gray = g->grayagain = NULL;
297	g->weak = g->ephemeron = g->allweak = NULL;
298	g->totalbytes = sizeof(LG);
299	g->GCdebt = 0;
300	g->gcpause = LUAI_GCPAUSE;
301	g->gcmajorinc = LUAI_GCMAJOR;
302	g->gcstepmul = LUAI_GCMUL;
303	for (i=0; i < LUA_NUMTAGS; i++) g->mt[i] = NULL;
304	if (luaD_rawrunprotected(L, f_luaopen, NULL) != LUA_OK) {
305	/* memory allocation error: free partial state */
306	close_state(L);
307	L = NULL;
308	}
309	else
310	luai_userstateopen(L);
311	return L;
312	}
313
314
315	LUA_API void lua_close (lua_State *L) {
316	L = G(L)->mainthread; /* only the main thread can be closed */
317	lua_lock(L);
318	luai_userstateclose(L);
319	close_state(L);
320	}
321
322