lxs_string* lxs_screate(lua_State* const L,
size_t cap /*= 0u*/,
bool force /*= true*/)
{
lxs_assert(L, L);
lxs_string* s = NULL;
if (cap == 0u)
{
s = static_cast<lxs_string*>(luaM_malloc(L, sizeof(lxs_string)));
}
else
{
if (!force)
cap = lxs_mgrow(L, 0u, cap, true, LXS_GROTH_FACTOR);
lxs_assert(L, cap > 0u);
lxs_scheck_mem_limits(L, 0u, cap, 0u);
s = static_cast<lxs_string*>(
luaM_malloc(L, sizeof(lxs_string) + sizeof(char) * cap)
);
s->data = reinterpret_cast<char*>(s + sizeof(lxs_string));
lxs_assert(L, s->data);
}
lxs_assert(L, s);
s->cap = cap;
return s;
}
void luaL_addlibtolist(luaL_reg *l, int32 n) {
luaL_libList *list = (luaL_libList *)luaM_malloc(sizeof(luaL_libList));
list->list = l;
list->number = n;
list->next = list_of_libs;
list_of_libs = list;
}
Closure *luaF_newclosure(int32 nelems) {
Closure *c = (Closure *)luaM_malloc(sizeof(Closure) + nelems * sizeof(TObject));
luaO_insertlist(&rootcl, (GCnode *)c);
nblocks += gcsizeclosure(c);
c->nelems = nelems;
return c;
}
static int ws2812_buffer_fill(lua_State* L) {
ws2812_buffer * buffer = (ws2812_buffer*)lua_touserdata(L, 1);
luaL_argcheck(L, buffer && buffer->canary == CANARY_VALUE, 1, "ws2812.buffer expected");
// Grab colors
int i, j;
int * colors = luaM_malloc(L, buffer->colorsPerLed * sizeof(int));
for (i = 0; i < buffer->colorsPerLed; i++)
{
colors[i] = luaL_checkinteger(L, 2+i);
}
// Fill buffer
uint8_t * p = &buffer->values[0];
for(i = 0; i < buffer->size; i++)
{
for (j = 0; j < buffer->colorsPerLed; j++)
{
*p++ = colors[j];
}
}
// Free memory
luaM_free(L, colors);
return 0;
}
static lua_State *mallocstate (lua_State *L) {
lu_byte *block = (lu_byte *)luaM_malloc(L, sizeof(lua_State) + EXTRASPACE);
if (block == NULL) return NULL;
else {
block += EXTRASPACE;
return cast(lua_State *, block);
}
}
Closure *luaF_newclosure (lua_State *L, int nelems) {
int size = sizeclosure(nelems);
Closure *c = (Closure *)luaM_malloc(L, size);
c->next = L->rootcl;
L->rootcl = c;
c->mark = c;
c->nupvalues = nelems;
L->nblocks += size;
return c;
}
static void block (LexState *ls) {
/* block -> chunk */
FuncState *fs = ls->fs;
BlockCnt *pbl = (BlockCnt*)luaM_malloc(ls->L,sizeof(BlockCnt));
enterblock(fs, pbl, 0);
chunk(ls);
lua_assert(pbl->breaklist == NO_JUMP);
leaveblock(fs);
luaM_free(ls->L,pbl);
}
static void unpersiststring(UnpersistInfo *upi) {
/* perms reftbl sptbl ref */
int length;
char* string;
verify(luaZ_read(&upi->zio, &length, sizeof(int)) == 0);
string = (char *)luaM_malloc(upi->L, length);
verify(luaZ_read(&upi->zio, string, length) == 0);
lua_pushlstring(upi->L, string, length);
/* perms reftbl sptbl ref str */
luaM_free(upi->L, string, length);
}
lua_State *luaE_newthread (lua_State *L) {
lua_State *L1 = tostate(luaM_malloc(L, state_size(lua_State)));
luaC_link(L, obj2gco(L1), LUA_TTHREAD);
preinit_state(L1, G(L));
stack_init(L1, L); /* init stack */
setobj2n(L, gt(L1), gt(L)); /* share table of globals */
L1->hookmask = L->hookmask;
L1->basehookcount = L->basehookcount;
L1->hook = L->hook;
resethookcount(L1);
lua_assert(iswhite(obj2gco(L1)));
return L1;
}
void *rstack_alloc (lua_State *L, size_t size) {
RStack *rs = rstack(L);
Region *r = check_exp(rs->cregnum > 0, rs->creg);
RObject *top = r->top;
if (top == rs->rbuf.last) {
RObject *ohead = rs->rbuf.head;
buf_resize(L, rs, rs->rbuf.size * 2);
buf_fix(rs, ohead);
top = r->top;
}
top->body = luaM_malloc(L, size);
++r->top;
return top->body;
}
static TaggedString *newone_s (char *str, long l, unsigned long h)
{
TaggedString *ts = (TaggedString *)luaM_malloc(sizeof(TaggedString)+l);
memcpy(ts->str, str, l);
ts->str[l] = 0; /* ending 0 */
ts->u.s.globalval.ttype = LUA_T_NIL; /* initialize global value */
ts->u.s.len = l;
ts->constindex = 0;
L->nblocks += gcsizestring(l);
ts->head.marked = 0;
ts->head.next = (GCnode *)ts; /* signal it is in no list */
ts->hash = h;
return ts;
}
lua_State *luaE_newthread (lua_State *L) {
lua_State *L1 = tostate(luaM_malloc(L, state_size(lua_State)));
luaC_link(L, obj2gco(L1), LUA_TTHREAD);
setthvalue(L, L->top, L1); /* put thread on stack */
incr_top(L);
preinit_state(L1, G(L));
stack_init(L1, L); /* init stack */
setobj2n(L, gt(L1), gt(L)); /* share table of globals */
L1->hookmask = L->hookmask;
L1->basehookcount = L->basehookcount;
L1->hook = L->hook;
resethookcount(L1);
lua_assert(!isdead(G(L), obj2gco(L1)));
L->top--; /* remove thread from stack */
return L1;
}
static void forbody (LexState *ls, int base, int line, int nvars, int isnum) {
/* forbody -> DO block */
BlockCnt *pbl = (BlockCnt*)luaM_malloc(ls->L,sizeof(BlockCnt));
FuncState *fs = ls->fs;
int prep, endfor;
adjustlocalvars(ls, 3); /* control variables */
checknext(ls, TK_DO);
prep = isnum ? luaK_codeAsBx(fs, OP_FORPREP, base, NO_JUMP) : luaK_jump(fs);
enterblock(fs, pbl, 0); /* scope for declared variables */
adjustlocalvars(ls, nvars);
luaK_reserveregs(fs, nvars);
block(ls);
leaveblock(fs); /* end of scope for declared variables */
luaK_patchtohere(fs, prep);
endfor = (isnum) ? luaK_codeAsBx(fs, OP_FORLOOP, base, NO_JUMP) :
luaK_codeABC(fs, OP_TFORLOOP, base, 0, nvars);
luaK_fixline(fs, line); /* pretend that `OP_FOR' starts the loop */
luaK_patchlist(fs, (isnum ? endfor : luaK_jump(fs)), prep + 1);
luaM_free(ls->L,pbl);
}
void lxs_sinit(lua_State* const L, lxs_string* const s, size_t capacity /*= 0*/)
{
lxs_assert(L, L);
lxs_assert(L, s);
if (capacity == 0)
#if LUAXS_STR_READONLY_OPTIONS
capacity = LUAXS_STR_INITIAL_CAPACITY;
#else
capacity = lxs_sdefault_capacity();
#endif // LUAXS_STR_READONLY_OPTIONS
lxs_scheck_mem_limits(L, 0u, capacity, 0u);
char* buffer = static_cast<char*>(luaM_malloc(L, capacity));
if (buffer == NULL)
lxs_error(L, MEMERRMSG);
s->cap = capacity;
s->len = 0;
s->data = buffer;
}
static int websocket_createClient(lua_State *L) {
NODE_DBG("websocket_createClient\n");
// create user data
ws_data *data = (ws_data *) luaM_malloc(L, sizeof(ws_data));
data->onConnection = LUA_NOREF;
data->onReceive = LUA_NOREF;
data->onClose = LUA_NOREF;
data->self_ref = LUA_NOREF; // only set when ws:connect is called
ws_info *ws = (ws_info *) lua_newuserdata(L, sizeof(ws_info));
ws->connectionState = 0;
ws->onConnection = &websocketclient_onConnectionCallback;
ws->onReceive = &websocketclient_onReceiveCallback;
ws->onFailure = &websocketclient_onCloseCallback;
ws->reservedData = data;
// set its metatable
luaL_getmetatable(L, METATABLE_WSCLIENT);
lua_setmetatable(L, -2);
return 1;
}
void rec_bytecode(TProtoFunc* func, int* inst) {
int n_op = num_opcodes(func);
int i, newsize;
Opcode *opcode_list = luaM_newvector(n_op, Opcode);
Byte* p = func->code;
//Load opcodes in a more descriptive structure
i = 0;
do
p += INFO(func, p, &opcode_list[i]);
while (opcode_list[i++].op != ENDCODE);
luaM_free(func->code);
func->code = NULL;
//For jump instructions, calculate the number of
//instructions to skip/rewind, from the number of
//bytes to skip/rewind. The result is improperly
//stored in op.arg2, since it's a unused field.
for (i = 0; opcode_list[i].op != ENDCODE; ++i) {
Opcode &op = opcode_list[i];
int bytesToSkip, instToSkip, bytesToRewind, instToRewind, j;
switch (op.op_class) {
//Forward jump
case ONTJMP:
case ONFJMP:
case JMP:
case IFFJMP:
bytesToSkip = op.arg;
instToSkip = 0;
j = i;
while (bytesToSkip > 0) {
instToSkip++;
bytesToSkip -= opcode_list[++j].size;
}
assert(bytesToSkip == 0);
op.arg2 = instToSkip;
break;
//Backwards jump
case IFTUPJMP:
case IFFUPJMP:
bytesToRewind = op.arg;
instToRewind = 0;
j = i;
while (bytesToRewind > 0) {
bytesToRewind -= opcode_list[j--].size;
instToRewind++;
}
assert(bytesToRewind == 0);
op.arg2 = instToRewind;
break;
}
}
//Change const index
for (i = 0; opcode_list[i].op != ENDCODE; ++i) {
Opcode &op = opcode_list[i];
//Change const index, if needed
if (op.op_class == PUSHCONSTANT ||
op.op_class == GETGLOBAL ||
op.op_class == SETGLOBAL ||
op.op_class == GETDOTTED ||
op.op_class == PUSHSELF)
if (op.arg != inst[op.arg]) {
op.arg = inst[op.arg];
fix_op(&op);
}
}
//Recalculate the number of bytes to jump
bool expJmp;
do {
expJmp = false;
for (i = 0; opcode_list[i].op != ENDCODE; ++i) {
Opcode &op = opcode_list[i];
int bytesToSkip, instToSkip, bytesToRewind, instToRewind, j;
switch (op.op_class) {
//Forward jump
case ONTJMP:
case ONFJMP:
case JMP:
case IFFJMP:
bytesToSkip = 0;
instToSkip = op.arg2;
j = i;
while (instToSkip > 0) {
instToSkip--;
bytesToSkip += opcode_list[++j].size;
}
assert(instToSkip == 0);
op.arg = bytesToSkip;
break;
//Backwards jump
case IFTUPJMP:
case IFFUPJMP:
bytesToRewind = 0;
instToRewind = op.arg2;
j = i;
while (instToRewind > 0) {
bytesToRewind += opcode_list[j--].size;
instToRewind--;
}
assert(instToRewind == 0);
op.arg = bytesToRewind;
break;
default:
continue;
}
//Expand JMPs to JMPWs, if needed.
//It set also the expJmp flag, in order
//to make another cycle, since this
//action changed again the code size
if (op.size == 2 && op.arg > 255) {
op.op++;
op.size++;
expJmp = true;
}
}
} while (expJmp);
//Calculate the size of new bytecode and
//alloc the space for it
i = 0;
newsize = 0;
do
newsize += opcode_list[i].size;
while (opcode_list[i++].op != ENDCODE);
Byte *code = (Byte*)luaM_malloc(newsize);
func->code = code;
//Compile bytecode
Byte out[4];
//Out stacksize and arguments number
code[0] = (byte)opcode_list[0].arg;
if (opcode_list[1].op == VARARGS)
code[1] = (byte)opcode_list[1].arg + ZEROVARARG;
else
code[1] = (byte)opcode_list[1].arg;
code += 2;
for (i = 2; i < n_op; ++i) {
Opcode &op = opcode_list[i];
//Out opcode
out[0] = (byte)op.op;
//Out args
if (op.op == SETLIST || op.op == CLOSURE || op.op == CALLFUNC) {
out[1] = (byte)op.arg;
out[2] = (byte)op.arg2;
}
else if (op.size == 2)
out[1] = (byte)op.arg;
else if (op.size >= 3)
WRITE_LE_UINT16(out + 1, op.arg);
if (op.op == SETLISTW)
out[3] = (byte)op.arg2;
memcpy(code, out, op.size);
code += op.size;
}
luaM_free(opcode_list);
}
/* this function handles only `%d', `%c', %f, %p, and `%s' formats
and now it handles %x and %X as well */
const char *luaO_pushvfstring (lua_State *L, const char *fmt, va_list argp)
{
#if LUAXS_CORE_FORMAT == 2
size_t alloclen = _vscprintf(fmt, argp) + 1;
char* buf = luaM_malloc(L, alloclen);
vsprintf_s(buf, alloclen, fmt, argp);
pushstr(L, buf);
luaM_freemem(L, buf, alloclen);
return svalue(L->top - 1);
#else
int n = 1;
pushstr(L, "");
for (;;) {
const char *e = strchr(fmt, '%');
if (e == NULL) break;
setsvalue2s(L, L->top, luaS_newlstr(L, fmt, e-fmt));
incr_top(L);
switch (*(e+1)) {
case 's': {
const char *s = va_arg(argp, char *);
if (s == NULL) s = "(null)";
pushstr(L, s);
break;
}
case 'c': {
char buff[2];
buff[0] = cast(char, va_arg(argp, int));
buff[1] = '\0';
pushstr(L, buff);
break;
}
case 'd': {
setnvalue(L->top, cast_num(va_arg(argp, int)));
incr_top(L);
break;
}
case 'f': {
setnvalue(L->top, cast_num(va_arg(argp, l_uacNumber)));
incr_top(L);
break;
}
case 'p': {
char buff[4*sizeof(void *) + 8]; /* should be enough space for a `%p' */
sprintf(buff, "%p", va_arg(argp, void *));
pushstr(L, buff);
break;
}
#if LUAXS_CORE_FORMAT == 1
case 'X': {
char buff[sizeof(int)*2+3];
sprintf(buff, "%X", va_arg(argp, int));
pushstr(L, buff);
break;
}
case 'x': {
char buff[sizeof(int)*2+3];
sprintf(buff, "%x", va_arg(argp, int));
pushstr(L, buff);
break;
}
#endif
case '%': {
pushstr(L, "%");
break;
}
default: {
char buff[3];
buff[0] = '%';
buff[1] = *(e+1);
buff[2] = '\0';
pushstr(L, buff);
break;
}
}
n += 2;
fmt = e+2;
}
pushstr(L, fmt);
luaV_concat(L, n+1, cast_int(L->top - L->base) - 1);
L->top -= n;
return svalue(L->top - 1);
#endif
}
void rec_bytecode(TProtoFunc* func, int* inst) {
int n_op = num_opcodes(func);
int i, newsize;
Opcode *opcode_list = luaM_newvector(n_op, Opcode);
Byte* p = func->code;
//Change const index
i = 0;
newsize = 0;
while (1) {
p += INFO(func, p, &opcode_list[i]);
Opcode &op = opcode_list[i];
//Change const index, if needed
if (op.op_class == PUSHCONSTANT ||
op.op_class == GETGLOBAL ||
op.op_class == SETGLOBAL ||
op.op_class == GETDOTTED ||
op.op_class == PUSHSELF)
if (op.arg != inst[op.arg]) {
op.arg = inst[op.arg];
fix_op(&op);
}
newsize += op.size;
++i;
if (op.op == ENDCODE)
break;
}
luaM_free(func->code);
Byte *code = (Byte*)luaM_malloc(newsize);
func->code = code;
//Compile bytecode
Byte out[4];
//Out stacksize and arguments number
code[0] = (byte)opcode_list[0].arg;
if (opcode_list[1].op == VARARGS)
code[1] = (byte)opcode_list[1].arg + ZEROVARARG;
else
code[1] = (byte)opcode_list[1].arg;
code += 2;
for (i = 2; i < n_op; ++i) {
Opcode &op = opcode_list[i];
//Out opcode
out[0] = (byte)op.op;
//Out args
if (op.op == SETLIST || op.op == CLOSURE || op.op == CALLFUNC) {
out[1] = (byte)op.arg;
out[2] = (byte)op.arg2;
}
else if (op.size == 2)
out[1] = (byte)op.arg;
else if (op.size >= 3)
WRITE_LE_UINT16(out + 1, op.arg);
if (op.op == SETLISTW)
out[3] = (byte)op.arg2;
memcpy(code, out, op.size);
code += op.size;
}
luaM_free(opcode_list);
}
