void codegen::output(const char * filename, const char * packagename, const char * name, func_binary * bin)
{
assert(m_byte_code_list.size() == m_byte_lineno_list.size());
bin->m_filename = stringdump(m_fk, filename, strlen(filename));
bin->m_packagename = stringdump(m_fk, packagename, strlen(packagename));
bin->m_name = stringdump(m_fk, name, strlen(name));
bin->m_maxstack = m_maxstackpos;
bin->m_size = m_byte_code_list.size();
if (bin->m_size > 0)
{
bin->m_buff = (command *)safe_fkmalloc(m_fk, (bin->m_size * sizeof(command)), emt_func_binary);
memcpy(bin->m_buff, &m_byte_code_list[0], bin->m_size * sizeof(command));
}
bin->m_lineno_size = m_byte_lineno_list.size();
if (bin->m_lineno_size > 0)
{
bin->m_lineno_buff = (int *)safe_fkmalloc(m_fk, (bin->m_lineno_size * sizeof(int)), emt_func_binary);
memcpy(bin->m_lineno_buff, &m_byte_lineno_list[0], bin->m_lineno_size * sizeof(int));
}
bin->m_const_list_num = m_const_list.size();
if (bin->m_const_list_num > 0)
{
bin->m_const_list = (variant *)safe_fkmalloc(m_fk, (bin->m_const_list_num * sizeof(variant)), emt_func_binary);
memcpy(bin->m_const_list, &m_const_list[0], bin->m_const_list_num * sizeof(variant));
}
bin->m_container_addr_list_num = m_containeraddr_list.size();
if (bin->m_container_addr_list_num > 0)
{
bin->m_container_addr_list = (container_addr *)safe_fkmalloc(m_fk, (bin->m_container_addr_list_num * sizeof(container_addr)), emt_func_binary);
memcpy(bin->m_container_addr_list, &m_containeraddr_list[0], bin->m_container_addr_list_num * sizeof(container_addr));
}
bin->m_debug_stack_variant_info_num = m_debug_block_identifiers_list.size();
if (bin->m_debug_stack_variant_info_num > 0)
{
bin->m_debug_stack_variant_info = (stack_variant_info *)safe_fkmalloc(m_fk, (bin->m_debug_stack_variant_info_num * sizeof(stack_variant_info)), emt_func_binary);
memcpy(bin->m_debug_stack_variant_info, &m_debug_block_identifiers_list[0], bin->m_debug_stack_variant_info_num * sizeof(stack_variant_info));
}
bin->m_fresh++;
FKLOG("codegen out %s %d", name, m_maxstackpos);
}
void * myflexer::malloc(size_t size, const char * name)
{
void * p = safe_fkmalloc(m_fk, size);
FKLOG("flexer malloc %p %d %s", p, (int)size, name);
m_nodelist.push_back((syntree_node*)p);
return p;
}
// trim
void buildin_string_trim(fake * fk, interpreter * inter)
{
BIF_CHECK_ARG_NUM(2);
const char * trimstr = fkpspopcstrptr(fk);
const char * str = fkpspopcstrptr(fk);
if (trimstr && str)
{
// left
int trimlen = strlen(trimstr);
while (1)
{
const char * s = strstr(str, trimstr);
if (s == str)
{
str += trimlen;
}
else
{
break;
}
}
// right
const char * srcstr = str;
int endpos = strlen(str);
int trimnum = 0;
while (str < srcstr + endpos)
{
const char * s = strstr(str, trimstr);
if (s == str)
{
str += trimlen;
trimnum++;
}
else if (s)
{
trimnum = 0;
str = s;
}
else
{
trimnum = 0;
break;
}
}
int afterlen = endpos - trimlen * trimnum;
assert(afterlen >= 0);
char * buf = (char *)safe_fkmalloc(fk, afterlen + 1, emt_tmp);
buf[afterlen] = 0;
memcpy(buf, srcstr, afterlen);
fkpspush<const char *>(fk, buf);
safe_fkfree(fk, buf);
}
else
{
fkpspush<const char *>(fk, str);
}
}
void buildin_buffer_popstring(fake * fk, interpreter * inter)
{
int len = fkpspop<int>(fk);
char * data = (char *)safe_fkmalloc(fk, len + 1);
memset(data, 0, len + 1);
buffer * b = fkpspop<buffer *>(fk);
if (b)
{
b->read(data, len);
}
fkpspush<const char *>(fk, data);
safe_fkfree(fk, data);
}
// substr
void buildin_string_substr(fake * fk, interpreter * inter)
{
BIF_CHECK_ARG_NUM(3);
int count = fkpspop<int>(fk);
int pos = fkpspop<int>(fk);
const char * srcstr = 0;
variant * v = 0;
bool err = false;
PS_POP_AND_GET(fk->ps, v);
V_GET_STRING(v, srcstr);
CHECK_ERR(err);
int len = srcstr ? v->data.str->sz : 0;
if (count == -1)
{
count = 0x7FFFFFFF;
}
if (count < 0)
{
fkpspush<const char *>(fk, "");
return;
}
if ((uint32_t)((uint32_t)pos + (uint32_t)count) > (uint32_t)len)
{
count = len - pos;
}
if (pos >= 0 && pos < len && srcstr && count > 0)
{
char * buf = (char *)safe_fkmalloc(fk, count + 1, emt_tmp);
buf[count] = 0;
memcpy(buf, srcstr + pos, count);
fkpspush<const char *>(fk, buf);
safe_fkfree(fk, buf);
}
else
{
fkpspush<const char *>(fk, "");
}
}
// freadall
void buildin_freadall(fake * fk, interpreter * inter)
{
FILE * f = fkpspop<FILE *>(fk);
if (f)
{
fseek(f, 0, SEEK_END);
size_t filesize = ftell(f);
fseek(f, 0, SEEK_SET);
char * buffer = (char *)safe_fkmalloc(fk, filesize + 1, emt_tmp);
buffer[filesize] = 0;
if (fread(buffer, filesize, 1, f) == 1)
{
fkpspush<char *>(fk, buffer);
safe_fkfree(fk, buffer);
return;
}
safe_fkfree(fk, buffer);
}
const char * ret = "";
fkpspush<const char *>(fk, ret);
}
void * myflexer::malloc(size_t size, const char * name)
{
void * p = safe_fkmalloc(m_fk, size);
FKLOG("flexer malloc %p %d %s", p, (int)size, name);
return p;
}
// replace
void buildin_string_replace(fake * fk, interpreter * inter)
{
BIF_CHECK_ARG_NUM(3);
const char * tostr = fkpspopcstrptr(fk);
const char * fromstr = fkpspopcstrptr(fk);
const char * str = fkpspopcstrptr(fk);
if (!tostr || !fromstr || !str)
{
fkpspush<const char *>(fk, "");
return;
}
int str_size = strlen(str);
int from_size = strlen(fromstr);
int to_size = strlen(tostr);
if (from_size == 0)
{
fkpspush<const char *>(fk, str);
return;
}
char * tmpbuff = 0;
int delta = to_size - from_size;
if (delta == 0)
{
tmpbuff = (char *)safe_fkmalloc(fk, str_size + 1, emt_tmp);
memcpy(tmpbuff, str, str_size);
tmpbuff[str_size] = 0;
int pos = 0;
const char * find = strstr(tmpbuff + pos, fromstr);
while (find)
{
memcpy((void*)find, tostr, to_size);
pos = find - tmpbuff + to_size;
find = strstr(tmpbuff + pos, fromstr);
}
}
else
{
int num = 0;
int pos = 0;
const char * find = strstr(str + pos, fromstr);
while (find)
{
num++;
pos = find - str + from_size;
find = strstr(str + pos, fromstr);
}
if (num >= 0)
{
int new_str_size = str_size + num * delta + 1;
tmpbuff = (char *)safe_fkmalloc(fk, new_str_size, emt_tmp);
tmpbuff[str_size + num * delta] = 0;
char * pbuff = tmpbuff;
int pos = 0;
const char * find = strstr(str + pos, fromstr);
while (find)
{
int skip_size = find - str - pos;
if (skip_size > 0)
{
memcpy(pbuff, str + pos, skip_size);
pbuff += skip_size;
}
memcpy(pbuff, tostr, to_size);
pbuff += to_size;
pos = find - str + from_size;
find = strstr(str + pos, fromstr);
}
if (pos < str_size)
{
memcpy(pbuff, str + pos, str_size - pos);
}
}
else
{
fkpspush<const char *>(fk, str);
return;
}
}
fkpspush<const char *>(fk, tmpbuff);
safe_fkfree(fk, tmpbuff);
}
