hyung-hwan/moo
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

reorganized moo_duputobcstr(), moo_dupbtoucstr(), moo_dupbtouchars(), moo_duputobchars().

Browse Source 
renamed add_io_name() to moo_addcioname().
changed input_handler in std.c to set arg->name when opening a file with moo_addcioname().
shortened dbginfo to dbgi.
enhanced the compiler to record the class location in dbgi
This commit is contained in:
hyunghwan.chung 2019-07-10 09:19:38 +00:00
parent b4c6e6a9de
commit b3eb804f87
12 changed files with 251 additions and 223 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
moo/bin/main.c
View File

@ -241,8 +241,8 @@ int main (int argc, char* argv[])
} }
/* TODO: don't initialize debug information if debug info is not requested. /* TODO: don't initialize debug information if debug info is not requested.
* call moo_loaddbginfo() if loading a compiled image... */ * call moo_loaddbgi() if loading a compiled image... */
if (moo_initdbginfo(moo, 102400) <= -1) /* TODO: set initial debug information size from a configurable value */ if (moo_initdbgi(moo, 102400) <= -1) /* TODO: set initial debug information size from a configurable value */
{ {
moo_logbfmt (moo, MOO_LOG_STDERR, "ERROR: cannot initialize debug information - [%d] %js\n", moo_geterrnum(moo), moo_geterrstr(moo)); moo_logbfmt (moo, MOO_LOG_STDERR, "ERROR: cannot initialize debug information - [%d] %js\n", moo_geterrnum(moo), moo_geterrstr(moo));
moo_close (moo); moo_close (moo);

10
moo/kernel/Except.moo
View File

@ -69,12 +69,18 @@ TODO: can i convert 'thisProcess primError' to a relevant exception?
//thisContext unwindTo: nil return: nil. //thisContext unwindTo: nil return: nil.
//thisContext unwindTo: (Processor activeProcess initialContext) return: nil. //thisContext unwindTo: (Processor activeProcess initialContext) return: nil.
// TOOD: IMPROVE THIS EXPERIMENTAL BACKTRACE... // TOOD: IMPROVE THIS EXPERIMENTAL BACKTRACE... MOVE THIS TO System>>backtrace and skip the first method context for backtrace itself.
System logNl: "== BACKTRACE ==". System logNl: "== BACKTRACE ==".
ctx := thisContext. ctx := thisContext.
while (ctx notNil) while (ctx notNil)
{ {
if (ctx class == MethodContext) { System logNl: (" " & ctx method owner name & ">>" & ctx method name & " (" & ctx method sourceFile & " " & ctx method sourceLine asString & ")"). }. if (ctx class == MethodContext)
{
System logNl: (" " & ctx method owner name & ">>" & ctx method name &
" (" & ctx method sourceFile & " " & ctx method sourceLine asString & ")").
// TODO: get location of the current pc and include it... (ctx method sourceLine: ctx pc) asString dump.
}.
// TODO: include blockcontext??? // TODO: include blockcontext???
ctx := ctx sender. ctx := ctx sender.
}. }.

1
moo/kernel/test-003.moo
View File

@ -92,6 +92,7 @@ class MyObject(Object)
tb := tc at: idx. tb := tc at: idx.
System log(System.Log.INFO, idx asString, (if (tb value) { " PASS" } else { " FAIL" }), "\n"). System log(System.Log.INFO, idx asString, (if (tb value) { " PASS" } else { " FAIL" }), "\n").
]. ].
Exception signal: 'xxx'.
// TODO: // TODO:
String format("%s", " 나 는\\\"") dump. String format("%s", " 나 는\\\"") dump.

73
moo/lib/comp.c
View File

@ -246,6 +246,8 @@ enum voca_id_t
}; };
typedef enum voca_id_t voca_id_t; typedef enum voca_id_t voca_id_t;
static moo_ooch_t _nul = '\0';
static int compile_pooldic_definition (moo_t* moo); static int compile_pooldic_definition (moo_t* moo);
static int compile_interface_definition (moo_t* moo); static int compile_interface_definition (moo_t* moo);
static int compile_class_definition (moo_t* moo, int class_type); static int compile_class_definition (moo_t* moo, int class_type);
@ -452,22 +454,23 @@ static int copy_string_to (moo_t* moo, const moo_oocs_t* src, moo_oocs_t* dst, m
len = src->len; len = src->len;
} }
if (len > *dst_capa) if (len >= *dst_capa)
{ {
moo_ooch_t* tmp; moo_ooch_t* tmp;
moo_oow_t capa; moo_oow_t capa;
capa = MOO_ALIGN(len, CLASS_BUFFER_ALIGN); capa = MOO_ALIGN(len + 1, CLASS_BUFFER_ALIGN);
tmp = (moo_ooch_t*)moo_reallocmem(moo, dst->ptr, MOO_SIZEOF(*tmp) * capa); tmp = (moo_ooch_t*)moo_reallocmem(moo, dst->ptr, MOO_SIZEOF(*tmp) * capa);
if (!tmp) return -1; if (!tmp) return -1;
dst->ptr = tmp; dst->ptr = tmp;
*dst_capa = capa; *dst_capa = capa - 1;
} }
if (append && delim_char != '\0') dst->ptr[pos++] = delim_char; if (append && delim_char != '\0') dst->ptr[pos++] = delim_char;
moo_copy_oochars (&dst->ptr[pos], src->ptr, src->len); moo_copy_oochars (&dst->ptr[pos], src->ptr, src->len);
dst->ptr[len] = '\0';
dst->len = len; dst->len = len;
return 0; return 0;
} }
@ -2363,7 +2366,7 @@ static void clear_io_names (moo_t* moo)
} }
} }
static const moo_ooch_t* add_io_name (moo_t* moo, const moo_oocs_t* name) const moo_ooch_t* moo_addcioname (moo_t* moo, const moo_oocs_t* name)
{ {
moo_iolink_t* link; moo_iolink_t* link;
moo_ooch_t* ptr; moo_ooch_t* ptr;
@ -2387,7 +2390,7 @@ static int begin_include (moo_t* moo)
moo_ioarg_t* arg; moo_ioarg_t* arg;
const moo_ooch_t* io_name; const moo_ooch_t* io_name;
io_name = add_io_name (moo, TOKEN_NAME(moo)); io_name = moo_addcioname(moo, TOKEN_NAME(moo));
if (!io_name) return -1; if (!io_name) return -1;
arg = (moo_ioarg_t*)moo_callocmem(moo, MOO_SIZEOF(*arg)); arg = (moo_ioarg_t*)moo_callocmem(moo, MOO_SIZEOF(*arg));
@ -4158,7 +4161,6 @@ static int compile_method_name (moo_t* moo, moo_method_data_t* mth)
* unary-selector := identifier * unary-selector := identifier
*/ */
int n; int n;
static moo_ooch_t _nul = '\0';
moo_oocs_t dummy; moo_oocs_t dummy;
MOO_ASSERT (moo, mth->tmpr_count == 0); MOO_ASSERT (moo, mth->tmpr_count == 0);
@ -4187,12 +4189,6 @@ static int compile_method_name (moo_t* moo, moo_method_data_t* mth)
if (n <= -1) return -1; if (n <= -1) return -1;
/* null terminate it for convenience */
dummy.ptr = &_nul;
dummy.len = 1;
if (add_method_name_fragment(moo, mth, &dummy) <= -1) return -1;
mth->name.len--; /* restore the method name length back */
if (method_exists(moo, &mth->name)) if (method_exists(moo, &mth->name))
{ {
moo_setsynerr (moo, MOO_SYNERR_MTHNAMEDUPL, &mth->name_loc, &mth->name); moo_setsynerr (moo, MOO_SYNERR_MTHNAMEDUPL, &mth->name_loc, &mth->name);
@ -7006,36 +7002,28 @@ static int add_compiled_method (moo_t* moo)
mth->source_line = MOO_SMOOI_TO_OOP(0); mth->source_line = MOO_SMOOI_TO_OOP(0);
} }
if (moo->dbginfo) if (moo->dbgi)
{ {
moo_oow_t file_offset; moo_oow_t file_offset;
moo_oow_t class_offset;
moo_oow_t method_offset; moo_oow_t method_offset;
const moo_ooch_t* file_name;
if (cc->mth.code_start_loc.file) file_name = cc->mth.code_start_loc.file;
{ if (!file_name) file_name = &_nul;
if (moo_addfiletodbginfo(moo, cc->mth.code_start_loc.file, &file_offset) <= -1)
if (moo_addfiletodbgi(moo, file_name, &file_offset) <= -1)
{ {
/* TODO: warning */ /* TODO: warning */
file_offset = 0; file_offset = 0;
} }
else if (file_offset > MOO_SMOOI_MAX) else if (file_offset > MOO_SMOOI_MAX)
{ {
/* TODO: warnign */ /* TODO: warning */
file_offset = 0;
}
}
else
{
/* main stream */
file_offset = 0; file_offset = 0;
} }
mth->source_file = MOO_SMOOI_TO_OOP(file_offset); mth->source_file = MOO_SMOOI_TO_OOP(file_offset);
/* TODO: call moo_addclasstodbginfo() */ if (moo_addmethodtodbgi(moo, file_offset, cc->dbgi_class_offset, cc->mth.name.ptr, cc->mth.code.locptr, cc->mth.code.len, &method_offset) <= -1)
class_offset = 0;
if (moo_addmethodtodbginfo(moo, file_offset, class_offset, cc->mth.name.ptr, cc->mth.code.locptr, cc->mth.code.len, &method_offset) <= -1)
{ {
/* TODO: warning. no debug information about this method will be available */ /* TODO: warning. no debug information about this method will be available */
} }
@ -8517,6 +8505,33 @@ static int __compile_class_definition (moo_t* moo, int class_type)
GET_TOKEN (moo); GET_TOKEN (moo);
if (moo->dbgi)
{
moo_oow_t file_offset;
moo_oow_t class_offset;
const moo_ooch_t* file_name;
file_name = cc->fqn_loc.file;
if (!file_name) file_name = &_nul;
if (moo_addfiletodbgi(moo, file_name, &file_offset) <= -1)
{
/* TODO: warning */
file_offset = 0;
}
else if (file_offset > MOO_SMOOI_MAX)
{
/* TODO: warning */
file_offset = 0;
}
if (moo_addclasstodbgi(moo, cc->fqn.ptr, file_offset, cc->fqn_loc.line, &cc->dbgi_class_offset) <= -1)
{
/* TODO: warning. no debug information about this method will be available */
}
/* TODO: store source file offset and class offset in the class object only for NORMAL. make_defined_class is a good candidate to do this in. */
}
if (class_type == CLASS_TYPE_EXTEND) if (class_type == CLASS_TYPE_EXTEND)
{ {
moo_oop_char_t pds; moo_oop_char_t pds;
@ -9674,6 +9689,8 @@ static void fini_compiler (moo_t* moo)
while (moo->c->cunit) pop_cunit (moo); while (moo->c->cunit) pop_cunit (moo);
if (moo->c->iid) moo_freemem (moo, moo->c->iid);
moo_freemem (moo, moo->c); moo_freemem (moo, moo->c);
moo->c = MOO_NULL; moo->c = MOO_NULL;
} }

114
moo/lib/debug.c
View File

@ -68,18 +68,18 @@ void moo_dumpdic (moo_t* moo, moo_oop_dic_t dic, const moo_bch_t* title)
} }
/* TODO: moo_loaddbginfofromimage() -> load debug information from compiled image? /* TODO: moo_loaddbgifromimage() -> load debug information from compiled image?
moo_storedbginfotoimage()? -> store debug information to compiled image? moo_storedbgitoimage()? -> store debug information to compiled image?
moo_compactdbginfo()? -> compact debug information by scaning dbginfo data. find class and method. if not found, drop the portion. moo_compactdbgi()? -> compact debug information by scaning dbgi data. find class and method. if not found, drop the portion.
*/ */
int moo_initdbginfo (moo_t* moo, moo_oow_t capa) int moo_initdbgi (moo_t* moo, moo_oow_t capa)
{ {
moo_dbginfo_t* tmp; moo_dbgi_t* tmp;
if (capa < MOO_SIZEOF(*tmp)) capa = MOO_SIZEOF(*tmp); if (capa < MOO_SIZEOF(*tmp)) capa = MOO_SIZEOF(*tmp);
tmp = (moo_dbginfo_t*)moo_callocmem(moo, capa); tmp = (moo_dbgi_t*)moo_callocmem(moo, capa);
if (!tmp) return -1; if (!tmp) return -1;
tmp->_capa = capa; tmp->_capa = capa;
@ -87,57 +87,57 @@ int moo_initdbginfo (moo_t* moo, moo_oow_t capa)
tmp->_last_class = 0; tmp->_last_class = 0;
tmp->_last_file = 0; tmp->_last_file = 0;
moo->dbginfo = tmp; moo->dbgi = tmp;
return 0; return 0;
} }
void moo_finidbginfo (moo_t* moo) void moo_finidbgi (moo_t* moo)
{ {
if (moo->dbginfo) if (moo->dbgi)
{ {
moo_freemem (moo, moo->dbginfo); moo_freemem (moo, moo->dbgi);
moo->dbginfo = MOO_NULL; moo->dbgi = MOO_NULL;
} }
} }
static MOO_INLINE moo_uint8_t* secure_dbginfo_space (moo_t* moo, moo_oow_t req_bytes) static MOO_INLINE moo_uint8_t* secure_dbgi_space (moo_t* moo, moo_oow_t req_bytes)
{ {
if (moo->dbginfo->_capa - moo->dbginfo->_len < req_bytes) if (moo->dbgi->_capa - moo->dbgi->_len < req_bytes)
{ {
moo_dbginfo_t* tmp; moo_dbgi_t* tmp;
moo_oow_t newcapa; moo_oow_t newcapa;
newcapa = moo->dbginfo->_len + req_bytes; newcapa = moo->dbgi->_len + req_bytes;
newcapa = MOO_ALIGN_POW2(newcapa, 65536); /* TODO: make the align value configurable */ newcapa = MOO_ALIGN_POW2(newcapa, 65536); /* TODO: make the align value configurable */
tmp = moo_reallocmem(moo, moo->dbginfo, newcapa); tmp = moo_reallocmem(moo, moo->dbgi, newcapa);
if (!tmp) return MOO_NULL; if (!tmp) return MOO_NULL;
moo->dbginfo = tmp; moo->dbgi = tmp;
moo->dbginfo->_capa = newcapa; moo->dbgi->_capa = newcapa;
} }
return &((moo_uint8_t*)moo->dbginfo)[moo->dbginfo->_len]; return &((moo_uint8_t*)moo->dbgi)[moo->dbgi->_len];
} }
int moo_addfiletodbginfo (moo_t* moo, const moo_ooch_t* file_name, moo_oow_t* start_offset) int moo_addfiletodbgi (moo_t* moo, const moo_ooch_t* file_name, moo_oow_t* start_offset)
{ {
moo_oow_t name_len, name_bytes, name_bytes_aligned, req_bytes; moo_oow_t name_len, name_bytes, name_bytes_aligned, req_bytes;
moo_dbginfo_file_t* di; moo_dbgi_file_t* di;
if (!moo->dbginfo) if (!moo->dbgi)
{ {
if (start_offset) *start_offset = MOO_NULL; if (start_offset) *start_offset = MOO_NULL;
return 0; /* debug information is disabled*/ return 0; /* debug information is disabled*/
} }
if (moo->dbginfo->_last_file > 0) if (moo->dbgi->_last_file > 0)
{ {
/* TODO: avoid linear search. need indexing for speed up */ /* TODO: avoid linear search. need indexing for speed up */
moo_oow_t offset = moo->dbginfo->_last_file; moo_oow_t offset = moo->dbgi->_last_file;
do do
{ {
di = &((moo_uint8_t*)moo->dbginfo)[offset]; di = (moo_dbgi_file_t*)&((moo_uint8_t*)moo->dbgi)[offset];
if (moo_comp_oocstr(di + 1, file_name) == 0) if (moo_comp_oocstr((moo_ooch_t*)(di + 1), file_name) == 0)
{ {
if (start_offset) *start_offset = offset; if (start_offset) *start_offset = offset;
return 0; return 0;
@ -150,38 +150,38 @@ int moo_addfiletodbginfo (moo_t* moo, const moo_ooch_t* file_name, moo_oow_t* st
name_len = moo_count_oocstr(file_name); name_len = moo_count_oocstr(file_name);
name_bytes = (name_len + 1) * MOO_SIZEOF(*file_name); name_bytes = (name_len + 1) * MOO_SIZEOF(*file_name);
name_bytes_aligned = MOO_ALIGN_POW2(name_bytes, MOO_SIZEOF_OOW_T); name_bytes_aligned = MOO_ALIGN_POW2(name_bytes, MOO_SIZEOF_OOW_T);
req_bytes = MOO_SIZEOF(moo_dbginfo_file_t) + name_bytes_aligned; req_bytes = MOO_SIZEOF(moo_dbgi_file_t) + name_bytes_aligned;
di = (moo_dbginfo_file_t*)secure_dbginfo_space(moo, req_bytes); di = (moo_dbgi_file_t*)secure_dbgi_space(moo, req_bytes);
if (!di) return -1; if (!di) return -1;
di->_type = MOO_DBGINFO_MAKE_TYPE(MOO_DBGINFO_TYPE_CODE_FILE, 0); di->_type = MOO_DBGINFO_MAKE_TYPE(MOO_DBGINFO_TYPE_CODE_FILE, 0);
di->_len = req_bytes; di->_len = req_bytes;
di->_next = moo->dbginfo->_last_file; di->_next = moo->dbgi->_last_file;
moo_copy_oocstr (di + 1, name_len + 1, file_name); moo_copy_oocstr ((moo_ooch_t*)(di + 1), name_len + 1, file_name);
moo->dbginfo->_last_file = moo->dbginfo->_len; moo->dbgi->_last_file = moo->dbgi->_len;
moo->dbginfo->_len += req_bytes; moo->dbgi->_len += req_bytes;
if (start_offset) *start_offset = moo->dbginfo->_last_file; if (start_offset) *start_offset = moo->dbgi->_last_file;
return 0; return 0;
} }
int moo_addclasstodbginfo (moo_t* moo, const moo_ooch_t* class_name, moo_oow_t file_offset, moo_oow_t file_line, moo_oow_t* start_offset) int moo_addclasstodbgi (moo_t* moo, const moo_ooch_t* class_name, moo_oow_t file_offset, moo_oow_t file_line, moo_oow_t* start_offset)
{ {
moo_oow_t name_len, name_bytes, name_bytes_aligned, req_bytes; moo_oow_t name_len, name_bytes, name_bytes_aligned, req_bytes;
moo_dbginfo_class_t* di; moo_dbgi_class_t* di;
if (!moo->dbginfo) return 0; /* debug information is disabled*/ if (!moo->dbgi) return 0; /* debug information is disabled*/
if (moo->dbginfo->_last_class > 0) if (moo->dbgi->_last_class > 0)
{ {
/* TODO: avoid linear search. need indexing for speed up */ /* TODO: avoid linear search. need indexing for speed up */
moo_oow_t offset = moo->dbginfo->_last_class; moo_oow_t offset = moo->dbgi->_last_class;
do do
{ {
di = &((moo_uint8_t*)moo->dbginfo)[offset]; di = (moo_dbgi_class_t*)&((moo_uint8_t*)moo->dbgi)[offset];
if (moo_comp_oocstr(di + 1, class_name) == 0 && di->_file == file_offset && di->_line == file_line) if (moo_comp_oocstr((moo_ooch_t*)(di + 1), class_name) == 0 && di->_file == file_offset && di->_line == file_line)
{ {
if (start_offset) *start_offset = offset; if (start_offset) *start_offset = offset;
return 0; return 0;
@ -194,55 +194,55 @@ int moo_addclasstodbginfo (moo_t* moo, const moo_ooch_t* class_name, moo_oow_t f
name_len = moo_count_oocstr(class_name); name_len = moo_count_oocstr(class_name);
name_bytes = (name_len + 1) * MOO_SIZEOF(*class_name); name_bytes = (name_len + 1) * MOO_SIZEOF(*class_name);
name_bytes_aligned = MOO_ALIGN_POW2(name_bytes, MOO_SIZEOF_OOW_T); name_bytes_aligned = MOO_ALIGN_POW2(name_bytes, MOO_SIZEOF_OOW_T);
req_bytes = MOO_SIZEOF(moo_dbginfo_class_t) + name_bytes_aligned; req_bytes = MOO_SIZEOF(moo_dbgi_class_t) + name_bytes_aligned;
di = (moo_dbginfo_class_t*)secure_dbginfo_space(moo, req_bytes); di = (moo_dbgi_class_t*)secure_dbgi_space(moo, req_bytes);
if (!di) return -1; if (!di) return -1;
di->_type = MOO_DBGINFO_MAKE_TYPE(MOO_DBGINFO_TYPE_CODE_CLASS, 0); di->_type = MOO_DBGINFO_MAKE_TYPE(MOO_DBGINFO_TYPE_CODE_CLASS, 0);
di->_len = req_bytes; di->_len = req_bytes;
di->_next = moo->dbginfo->_last_class; di->_next = moo->dbgi->_last_class;
di->_file = file_offset; di->_file = file_offset;
di->_line = file_line; di->_line = file_line;
moo_copy_oocstr (di + 1, name_len + 1, class_name); moo_copy_oocstr ((moo_ooch_t*)(di + 1), name_len + 1, class_name);
moo->dbginfo->_last_class = moo->dbginfo->_len; moo->dbgi->_last_class = moo->dbgi->_len;
moo->dbginfo->_len += req_bytes; moo->dbgi->_len += req_bytes;
if (start_offset) *start_offset = moo->dbginfo->_last_class; if (start_offset) *start_offset = moo->dbgi->_last_class;
return 0; return 0;
} }
int moo_addmethodtodbginfo (moo_t* moo, moo_oow_t file_offset, moo_oow_t class_offset, const moo_ooch_t* method_name, const moo_oow_t* code_loc_ptr, moo_oow_t code_loc_len, moo_oow_t* start_offset) int moo_addmethodtodbgi (moo_t* moo, moo_oow_t file_offset, moo_oow_t class_offset, const moo_ooch_t* method_name, const moo_oow_t* code_loc_ptr, moo_oow_t code_loc_len, moo_oow_t* start_offset)
{ {
moo_oow_t name_len, name_bytes, name_bytes_aligned, code_loc_bytes, code_loc_bytes_aligned, req_bytes; moo_oow_t name_len, name_bytes, name_bytes_aligned, code_loc_bytes, code_loc_bytes_aligned, req_bytes;
moo_dbginfo_method_t* di; moo_dbgi_method_t* di;
if (!moo->dbginfo) return 0; /* debug information is disabled*/ if (!moo->dbgi) return 0; /* debug information is disabled*/
name_len = moo_count_oocstr(method_name); name_len = moo_count_oocstr(method_name);
name_bytes = (name_len + 1) * MOO_SIZEOF(*method_name); name_bytes = (name_len + 1) * MOO_SIZEOF(*method_name);
name_bytes_aligned = MOO_ALIGN_POW2(name_bytes, MOO_SIZEOF_OOW_T); name_bytes_aligned = MOO_ALIGN_POW2(name_bytes, MOO_SIZEOF_OOW_T);
code_loc_bytes = code_loc_len * MOO_SIZEOF(*code_loc_ptr); code_loc_bytes = code_loc_len * MOO_SIZEOF(*code_loc_ptr);
code_loc_bytes_aligned = MOO_ALIGN_POW2(code_loc_bytes, MOO_SIZEOF_OOW_T); code_loc_bytes_aligned = MOO_ALIGN_POW2(code_loc_bytes, MOO_SIZEOF_OOW_T);
req_bytes = MOO_SIZEOF(moo_dbginfo_method_t) + name_bytes_aligned + code_loc_bytes_aligned; req_bytes = MOO_SIZEOF(moo_dbgi_method_t) + name_bytes_aligned + code_loc_bytes_aligned;
di = (moo_dbginfo_method_t*)secure_dbginfo_space(moo, req_bytes); di = (moo_dbgi_method_t*)secure_dbgi_space(moo, req_bytes);
if (!di) return -1; if (!di) return -1;
di->_type = MOO_DBGINFO_MAKE_TYPE(MOO_DBGINFO_TYPE_CODE_METHOD, 0); di->_type = MOO_DBGINFO_MAKE_TYPE(MOO_DBGINFO_TYPE_CODE_METHOD, 0);
di->_len = req_bytes; di->_len = req_bytes;
di->_next = moo->dbginfo->_last_method; di->_next = moo->dbgi->_last_method;
di->_file = file_offset; di->_file = file_offset;
di->_class = class_offset; di->_class = class_offset;
di->code_loc_len = code_loc_len; di->code_loc_len = code_loc_len;
moo_copy_oocstr (di + 1, name_len + 1, method_name); moo_copy_oocstr ((moo_ooch_t*)(di + 1), name_len + 1, method_name);
MOO_MEMCPY ((moo_uint8_t*)(di + 1) + name_bytes_aligned, code_loc_ptr, code_loc_bytes); MOO_MEMCPY ((moo_uint8_t*)(di + 1) + name_bytes_aligned, code_loc_ptr, code_loc_bytes);
moo->dbginfo->_last_method = moo->dbginfo->_len; moo->dbgi->_last_method = moo->dbgi->_len;
moo->dbginfo->_len += req_bytes; moo->dbgi->_len += req_bytes;
if (start_offset) *start_offset = moo->dbginfo->_last_method; if (start_offset) *start_offset = moo->dbgi->_last_method;
return 0; return 0;
} }

40
moo/lib/exec.c
View File

@ -2179,7 +2179,7 @@ static moo_pfrc_t pf_context_find_exception_handler (moo_t* moo, moo_mod_t* mod,
rcv = (moo_oop_context_t)MOO_STACK_GETRCV(moo, nargs); rcv = (moo_oop_context_t)MOO_STACK_GETRCV(moo, nargs);
MOO_PF_CHECK_RCV (moo, MOO_CLASSOF(moo,rcv) == moo->_method_context); MOO_PF_CHECK_RCV (moo, MOO_CLASSOF(moo,rcv) == moo->_method_context);
except_class = MOO_STACK_GETARG(moo, nargs, 0); except_class = (moo_oop_class_t)MOO_STACK_GETARG(moo, nargs, 0);
MOO_PF_CHECK_ARGS (moo, nargs, MOO_CLASSOF(moo,rcv) == moo->_class); MOO_PF_CHECK_ARGS (moo, nargs, MOO_CLASSOF(moo,rcv) == moo->_class);
preamble = MOO_OOP_TO_SMOOI(((moo_oop_method_t)rcv->method_or_nargs)->preamble); preamble = MOO_OOP_TO_SMOOI(((moo_oop_method_t)rcv->method_or_nargs)->preamble);
@ -2217,34 +2217,32 @@ static moo_pfrc_t pf_context_find_exception_handler (moo_t* moo, moo_mod_t* mod,
/* ------------------------------------------------------------------ */ /* ------------------------------------------------------------------ */
static moo_pfrc_t pf_method_get_source_file (moo_t* moo, moo_mod_t* mod, moo_ooi_t nargs) static moo_pfrc_t pf_method_get_source_file (moo_t* moo, moo_mod_t* mod, moo_ooi_t nargs)
{
moo_oop_t retv = moo->_nil;
if (moo->dbgi)
{ {
moo_oop_method_t rcv; moo_oop_method_t rcv;
moo_oop_t tmp;
if (moo->dbginfo) /* TODO: return something else lighter-weight than a string? */
rcv = (moo_oop_method_t)MOO_STACK_GETRCV(moo, nargs);
if (MOO_OOP_IS_SMOOI(rcv->source_file) && MOO_OOP_TO_SMOOI(rcv->source_file) > 0)
{ {
/* TODO: return sothing else lighter-weight than a string? */ moo_dbgi_file_t* di;
rcv = (moo_oop_method_t*)MOO_STACK_GETRCV(moo, nargs); const moo_ooch_t* file_name;
if (rcv->source_file == MOO_SMOOI_TO_OOP(0))
{
/* TOOD: use the actual name as given by the caller ? */
tmp = moo_makestringwithbchars(moo, "<MAIN>", 6);
}
else
{
moo_dbginfo_file_t* di;
di = (moo_dbginfo_file_t*)&((moo_uint8_t*)moo->dbginfo)[MOO_OOP_TO_SMOOI(rcv->source_file)];
tmp = moo_makestring(moo, di + 1, moo_count_oocstr(di + 1));
}
if (!tmp) return MOO_PF_FAILURE;
MOO_STACK_SETRET (moo, nargs, tmp); di = (moo_dbgi_file_t*)&((moo_uint8_t*)moo->dbgi)[MOO_OOP_TO_SMOOI(rcv->source_file)];
/* TODO: check if di is the file type... otherwise, it's internal corruption */
file_name = (const moo_ooch_t*)(di + 1);
moo_pushvolat (moo, &retv);
retv = moo_makestring(moo, file_name, moo_count_oocstr(file_name));
moo_popvolat (moo);
if (!retv) return MOO_PF_FAILURE;
} }
else
{
MOO_STACK_SETRET (moo, nargs, moo->_nil);
} }
MOO_STACK_SETRET (moo, nargs, retv);
return MOO_PF_SUCCESS; return MOO_PF_SUCCESS;
} }

19
moo/lib/moo-prv.h
View File

@ -595,6 +595,8 @@ struct moo_cunit_class_t
moo_oow_t initv_count; moo_oow_t initv_count;
} var[3]; } var[3];
moo_oow_t dbgi_class_offset;
moo_pooldic_import_data_t pdimp; moo_pooldic_import_data_t pdimp;
moo_method_data_t mth; moo_method_data_t mth;
}; };
@ -620,6 +622,7 @@ struct moo_compiler_t
/* input handler */ /* input handler */
moo_ioimpl_t impl; moo_ioimpl_t impl;
moo_ooch_t* iid; /* input id that represents the current main input file */
/* information about the last meaningful character read. /* information about the last meaningful character read.
* this is a copy of curinp->lxc if no ungetting is performed. * this is a copy of curinp->lxc if no ungetting is performed.
@ -1658,18 +1661,26 @@ moo_pfrc_t moo_pf_utf8_seqlen (moo_t* moo, moo_mod_t* mod, moo_ooi_t nargs);
moo_pfrc_t moo_pf_utf8_to_uc (moo_t* moo, moo_mod_t* mod, moo_ooi_t nargs); moo_pfrc_t moo_pf_utf8_to_uc (moo_t* moo, moo_mod_t* mod, moo_ooi_t nargs);
moo_pfrc_t moo_pf_uc_to_utf8 (moo_t* moo, moo_mod_t* mod, moo_ooi_t nargs); moo_pfrc_t moo_pf_uc_to_utf8 (moo_t* moo, moo_mod_t* mod, moo_ooi_t nargs);
/* TODO: remove the following debugging functions */
/* ========================================================================= */ /* ========================================================================= */
/* debug.c */ /* debug.c */
/* ========================================================================= */ /* ========================================================================= */
/* TODO: remove the following dump functions */
void moo_dumpsymtab (moo_t* moo); void moo_dumpsymtab (moo_t* moo);
void moo_dumpdic (moo_t* moo, moo_oop_dic_t dic, const moo_bch_t* title); void moo_dumpdic (moo_t* moo, moo_oop_dic_t dic, const moo_bch_t* title);
int moo_addfiletodbginfo (moo_t* moo, const moo_ooch_t* file_name, moo_oow_t* start_offset); int moo_addfiletodbgi (moo_t* moo, const moo_ooch_t* file_name, moo_oow_t* start_offset);
int moo_addclasstodbginfo (moo_t* moo, const moo_ooch_t* class_name, moo_oow_t file_offset, moo_oow_t file_line, moo_oow_t* start_offset); int moo_addclasstodbgi (moo_t* moo, const moo_ooch_t* class_name, moo_oow_t file_offset, moo_oow_t file_line, moo_oow_t* start_offset);
int moo_addmethodtodbginfo (moo_t* moo, moo_oow_t file_offset, moo_oow_t class_offset, const moo_ooch_t* method_name, const moo_oow_t* code_loc_ptr, moo_oow_t code_loc_len, moo_oow_t* start_offset); int moo_addmethodtodbgi (moo_t* moo, moo_oow_t file_offset, moo_oow_t class_offset, const moo_ooch_t* method_name, const moo_oow_t* code_loc_ptr, moo_oow_t code_loc_len, moo_oow_t* start_offset);
/* ========================================================================= */
/* comp.c */
/* ========================================================================= */
#if defined(MOO_INCLUDE_COMPILER)
const moo_ooch_t* moo_addcioname (moo_t* moo, const moo_oocs_t* name);
#endif
#if defined(__cplusplus) #if defined(__cplusplus)
} }
#endif #endif

2
moo/lib/moo-std.h
View File

@ -108,11 +108,13 @@ MOO_EXPORT void moo_abortstd (
moo_t* moo moo_t* moo
); );
#if defined(MOO_INCLUDE_COMPILER)
MOO_EXPORT int moo_compilestd( MOO_EXPORT int moo_compilestd(
moo_t* moo, moo_t* moo,
const moo_iostd_t* in, const moo_iostd_t* in,
moo_oow_t count moo_oow_t count
); );
#endif
MOO_EXPORT void moo_rcvtickstd ( MOO_EXPORT void moo_rcvtickstd (
moo_t* moo, moo_t* moo,

2
moo/lib/moo.c
View File

@ -249,7 +249,7 @@ void moo_fini (moo_t* moo)
* the heap may not exist */ * the heap may not exist */
if (moo->heap) moo_killheap (moo, moo->heap); if (moo->heap) moo_killheap (moo, moo->heap);
moo_finidbginfo (moo); moo_finidbgi (moo);
for (i = 0; i < MOO_COUNTOF(moo->sbuf); i++) for (i = 0; i < MOO_COUNTOF(moo->sbuf); i++)
{ {

128
moo/lib/moo.h
View File

@ -586,7 +586,7 @@ struct moo_method_t
#endif #endif
moo_oop_t source_text; /* source text. String if available. nil if not */ moo_oop_t source_text; /* source text. String if available. nil if not */
moo_oop_t source_file; /* SmallInteger. source file path that contains the definition of this method. offset from moo->dbginfo. 0 for the main stream. */ moo_oop_t source_file; /* SmallInteger. source file path that contains the definition of this method. offset from moo->dbgi. 0 for the main stream. */
moo_oop_t source_line; /* SmallInteger. line of the source file where the method definition begins. valid only if source_file is not nil */ moo_oop_t source_line; /* SmallInteger. line of the source file where the method definition begins. valid only if source_file is not nil */
/* == variable indexed part == */ /* == variable indexed part == */
@ -944,8 +944,8 @@ struct moo_heap_t
moo_space_t newspace; moo_space_t newspace;
}; };
typedef struct moo_dbginfo_t moo_dbginfo_t; typedef struct moo_dbgi_t moo_dbgi_t;
struct moo_dbginfo_t struct moo_dbgi_t
{ {
moo_oow_t _capa; moo_oow_t _capa;
moo_oow_t _len; moo_oow_t _len;
@ -955,7 +955,7 @@ struct moo_dbginfo_t
/* actual information is recorded here */ /* actual information is recorded here */
}; };
enum moo_dbginfo_type_t enum moo_dbgi_type_t
{ {
/* bit 8 to bit 15 */ /* bit 8 to bit 15 */
MOO_DBGINFO_TYPE_CODE_FILE = 0, MOO_DBGINFO_TYPE_CODE_FILE = 0,
@ -966,12 +966,12 @@ enum moo_dbginfo_type_t
/* low 8 bits */ /* low 8 bits */
MOO_DBGINFO_TYPE_FLAG_INVALID = (1 << 0) MOO_DBGINFO_TYPE_FLAG_INVALID = (1 << 0)
}; };
typedef enum moo_dbginfo_type_t moo_dbginfo_type_t; typedef enum moo_dbgi_type_t moo_dbgi_type_t;
#define MOO_DBGINFO_MAKE_TYPE(code,flags) (((code) << 8) | (flags)) #define MOO_DBGINFO_MAKE_TYPE(code,flags) (((code) << 8) | (flags))
typedef struct moo_dbginfo_file_t moo_dbginfo_file_t; typedef struct moo_dbgi_file_t moo_dbgi_file_t;
struct moo_dbginfo_file_t struct moo_dbgi_file_t
{ {
moo_oow_t _type; moo_oow_t _type;
moo_oow_t _len; moo_oow_t _len;
@ -979,8 +979,8 @@ struct moo_dbginfo_file_t
/* ... file path here ... */ /* ... file path here ... */
}; };
typedef struct moo_dbginfo_class_t moo_dbginfo_class_t; typedef struct moo_dbgi_class_t moo_dbgi_class_t;
struct moo_dbginfo_class_t struct moo_dbgi_class_t
{ {
moo_oow_t _type; moo_oow_t _type;
moo_oow_t _len; moo_oow_t _len;
@ -990,8 +990,8 @@ struct moo_dbginfo_class_t
/* ... class name here ... */ /* ... class name here ... */
}; };
typedef struct moo_dbginfo_method_t moo_dbginfo_method_t; typedef struct moo_dbgi_method_t moo_dbgi_method_t;
struct moo_dbginfo_method_t struct moo_dbgi_method_t
{ {
moo_oow_t _type; moo_oow_t _type;
moo_oow_t _len; moo_oow_t _len;
@ -1482,7 +1482,7 @@ struct moo_t
/* ========================= */ /* ========================= */
moo_heap_t* heap; moo_heap_t* heap;
moo_dbginfo_t* dbginfo; moo_dbgi_t* dbgi;
/* ============================================================= /* =============================================================
* nil, true, false * nil, true, false
@ -2133,17 +2133,17 @@ MOO_EXPORT void moo_abort (
* DEBUG SUPPORT * DEBUG SUPPORT
* ========================================================================= */ * ========================================================================= */
MOO_EXPORT int moo_initdbginfo ( MOO_EXPORT int moo_initdbgi (
moo_t* moo, moo_t* moo,
moo_oow_t init_capa moo_oow_t init_capa
); );
/** /**
* The moo_finidbginfo() function deletes the debug information. * The moo_finidbgi() function deletes the debug information.
* It is called by moo_close(). Unless you want the debug information to * It is called by moo_close(). Unless you want the debug information to
* be deleted earlier, you need not call this function explicitly. * be deleted earlier, you need not call this function explicitly.
*/ */
MOO_EXPORT void moo_finidbginfo ( MOO_EXPORT void moo_finidbgi (
moo_t* moo moo_t* moo
); );
/* ========================================================================= /* =========================================================================
@ -2365,29 +2365,6 @@ MOO_EXPORT int moo_convutobcstr (
* STRING DUPLICATION * STRING DUPLICATION
* ========================================================================= */ * ========================================================================= */
#if defined(MOO_OOCH_IS_UCH)
# define moo_dupootobcharswithheadroom(moo,hrb,oocs,oocslen,bcslen) moo_duputobcharswithheadroom(moo,hrb,oocs,oocslen,bcslen)
# define moo_dupbtooocharswithheadroom(moo,hrb,bcs,bcslen,oocslen) moo_dupbtoucharswithheadroom(moo,hrb,bcs,bcslen,oocslen)
# define moo_dupootobchars(moo,oocs,oocslen,bcslen) moo_duputobchars(moo,oocs,oocslen,bcslen)
# define moo_dupbtooochars(moo,bcs,bcslen,oocslen) moo_dupbtouchars(moo,bcs,bcslen,oocslen)
# define moo_dupootobcstrwithheadroom(moo,hrb,oocs,bcslen) moo_duputobcstrwithheadroom(moo,hrb,oocs,bcslen)
# define moo_dupbtooocstrwithheadroom(moo,hrb,bcs,oocslen) moo_dupbtoucstrwithheadroom(moo,hrb,bcs,oocslen)
# define moo_dupootobcstr(moo,oocs,bcslen) moo_duputobcstr(moo,oocs,bcslen)
# define moo_dupbtooocstr(moo,bcs,oocslen) moo_dupbtoucstr(moo,bcs,oocslen)
#else
# define moo_dupootoucharswithheadroom(moo,hrb,oocs,oocslen,ucslen) moo_dupbtoucharswithheadroom(moo,hrb,oocs,oocslen,ucslen)
# define moo_duputooocharswithheadroom(moo,hrb,ucs,ucslen,oocslen) moo_duputobcharswithheadroom(moo,hrb,ucs,ucslen,oocslen)
# define moo_dupootouchars(moo,oocs,oocslen,ucslen) moo_dupbtouchars(moo,oocs,oocslen,ucslen)
# define moo_duputooochars(moo,ucs,ucslen,oocslen) moo_duputobchars(moo,ucs,ucslen,oocslen)
# define moo_dupootoucstrwithheadroom(moo,hrb,oocs,ucslen) moo_dupbtoucstrwithheadroom(moo,hrb,oocs,ucslen)
# define moo_duputooocstrwithheadroom(moo,hrb,ucs,oocslen) moo_duputobcstrwithheadroom(moo,hrb,ucs,oocslen)
# define moo_dupootoucstr(moo,oocs,ucslen) moo_dupbtoucstr(moo,oocs,ucslen)
# define moo_duputooocstr(moo,ucs,oocslen) moo_duputobcstr(moo,ucs,oocslen)
#endif
MOO_EXPORT moo_uch_t* moo_dupbtoucharswithheadroom ( MOO_EXPORT moo_uch_t* moo_dupbtoucharswithheadroom (
moo_t* moo, moo_t* moo,
moo_oow_t headroom_bytes, moo_oow_t headroom_bytes,
@ -2404,21 +2381,6 @@ MOO_EXPORT moo_bch_t* moo_duputobcharswithheadroom (
moo_oow_t* bcslen moo_oow_t* bcslen
); );
MOO_EXPORT moo_uch_t* moo_dupbtouchars (
moo_t* moo,
const moo_bch_t* bcs,
moo_oow_t bcslen,
moo_oow_t* ucslen
);
MOO_EXPORT moo_bch_t* moo_duputobchars (
moo_t* moo,
const moo_uch_t* ucs,
moo_oow_t ucslen,
moo_oow_t* bcslen
);
MOO_EXPORT moo_uch_t* moo_dupbtoucstrwithheadroom ( MOO_EXPORT moo_uch_t* moo_dupbtoucstrwithheadroom (
moo_t* moo, moo_t* moo,
moo_oow_t headroom_bytes, moo_oow_t headroom_bytes,
@ -2433,25 +2395,34 @@ MOO_EXPORT moo_bch_t* moo_duputobcstrwithheadroom (
moo_oow_t* bcslen moo_oow_t* bcslen
); );
MOO_EXPORT moo_uch_t* moo_dupbtoucstr ( #if defined(MOO_HAVE_INLINE)
moo_t* moo, static MOO_INLINE moo_bch_t* moo_duputobchars (moo_t* moo, const moo_uch_t* ucs, moo_oow_t ucslen, moo_oow_t* bcslen)
const moo_bch_t* bcs, {
moo_oow_t* ucslen /* optional: length of returned string */ return moo_duputobcharswithheadroom (moo, 0, ucs, ucslen, bcslen);
); }
MOO_EXPORT moo_bch_t* moo_duputobcstr ( static MOO_INLINE moo_uch_t* moo_dupbtouchars (moo_t* moo, const moo_bch_t* bcs, moo_oow_t bcslen, moo_oow_t* ucslen)
moo_t* moo, {
const moo_uch_t* ucs, return moo_dupbtoucharswithheadroom (moo, 0, bcs, bcslen, ucslen);
moo_oow_t* bcslen /* optional: length of returned string */ }
);
static MOO_INLINE moo_bch_t* moo_duputobcstr (moo_t* moo, const moo_uch_t* ucs, moo_oow_t* bcslen)
{
return moo_duputobcstrwithheadroom (moo, 0, ucs, bcslen);
}
#if defined(MOO_OOCH_IS_UCH) static MOO_INLINE moo_uch_t* moo_dupbtoucstr (moo_t* moo, const moo_bch_t* bcs, moo_oow_t* ucslen)
# define moo_dupoochars(moo,oocs,oocslen) moo_dupuchars(moo,oocs,oocslen) {
return moo_dupbtoucstrwithheadroom(moo, 0, bcs, ucslen);
}
#else #else
# define moo_dupoochars(moo,oocs,oocslen) moo_dupbchars(moo,oocs,oocslen) # define moo_duputobchars(moo, ucs, ucslen, bcslen) moo_duputobcharswithheadroom(moo, 0, ucs, ucslen, bcslen)
# define moo_dupbtouchars(moo, bcs, bcslen, ucslen) moo_dupbtoucharswithheadroom(moo, 0, bcs, bcslen, ucslen)
# define moo_duputobcstr(moo, ucs, bcslen) moo_duputobcstrwithheadroom(moo, 0, ucs, bcslen)
# define moo_dupbtoucstr(moo, bcs, ucslen) moo_dupbtoucstrwithheadroom(moo, 0, bcs, ucslen)
#endif #endif
MOO_EXPORT moo_uch_t* moo_dupuchars ( MOO_EXPORT moo_uch_t* moo_dupuchars (
moo_t* moo, moo_t* moo,
const moo_uch_t* ucs, const moo_uch_t* ucs,
@ -2464,6 +2435,31 @@ MOO_EXPORT moo_bch_t* moo_dupbchars (
moo_oow_t bcslen moo_oow_t bcslen
); );
#if defined(MOO_OOCH_IS_UCH)
# define moo_dupootobcharswithheadroom(moo,hrb,oocs,oocslen,bcslen) moo_duputobcharswithheadroom(moo,hrb,oocs,oocslen,bcslen)
# define moo_dupbtooocharswithheadroom(moo,hrb,bcs,bcslen,oocslen) moo_dupbtoucharswithheadroom(moo,hrb,bcs,bcslen,oocslen)
# define moo_dupootobchars(moo,oocs,oocslen,bcslen) moo_duputobchars(moo,oocs,oocslen,bcslen)
# define moo_dupbtooochars(moo,bcs,bcslen,oocslen) moo_dupbtouchars(moo,bcs,bcslen,oocslen)
# define moo_dupootobcstrwithheadroom(moo,hrb,oocs,bcslen) moo_duputobcstrwithheadroom(moo,hrb,oocs,bcslen)
# define moo_dupbtooocstrwithheadroom(moo,hrb,bcs,oocslen) moo_dupbtoucstrwithheadroom(moo,hrb,bcs,oocslen)
# define moo_dupootobcstr(moo,oocs,bcslen) moo_duputobcstr(moo,oocs,bcslen)
# define moo_dupbtooocstr(moo,bcs,oocslen) moo_dupbtoucstr(moo,bcs,oocslen)
# define moo_dupoochars(moo,oocs,oocslen) moo_dupuchars(moo,oocs,oocslen)
#else
# define moo_dupootoucharswithheadroom(moo,hrb,oocs,oocslen,ucslen) moo_dupbtoucharswithheadroom(moo,hrb,oocs,oocslen,ucslen)
# define moo_duputooocharswithheadroom(moo,hrb,ucs,ucslen,oocslen) moo_duputobcharswithheadroom(moo,hrb,ucs,ucslen,oocslen)
# define moo_dupootouchars(moo,oocs,oocslen,ucslen) moo_dupbtouchars(moo,oocs,oocslen,ucslen)
# define moo_duputooochars(moo,ucs,ucslen,oocslen) moo_duputobchars(moo,ucs,ucslen,oocslen)
# define moo_dupootoucstrwithheadroom(moo,hrb,oocs,ucslen) moo_dupbtoucstrwithheadroom(moo,hrb,oocs,ucslen)
# define moo_duputooocstrwithheadroom(moo,hrb,ucs,oocslen) moo_duputobcstrwithheadroom(moo,hrb,ucs,oocslen)
# define moo_dupootoucstr(moo,oocs,ucslen) moo_dupbtoucstr(moo,oocs,ucslen)
# define moo_duputooocstr(moo,ucs,oocslen) moo_duputobcstr(moo,ucs,oocslen)
# define moo_dupoochars(moo,oocs,oocslen) moo_dupbchars(moo,oocs,oocslen)
#endif
/* ========================================================================= /* =========================================================================
* SBUF MANIPULATION * SBUF MANIPULATION
* ========================================================================= */ * ========================================================================= */

17
moo/lib/std.c
View File

@ -545,6 +545,21 @@ static MOO_INLINE moo_ooi_t open_input (moo_t* moo, moo_ioarg_t* arg)
} }
arg->handle = bb; arg->handle = bb;
if (!arg->name)
{
/* for the top-level stream, i simply change the arg->name field
* so that the compiler knows the file to be read */
moo_oocs_t io_name;
io_name.ptr = moo_dupbtooocstr(moo, get_base_name(bb->fn), &io_name.len);
if (!io_name.ptr) goto oops;
arg->name = moo_addcioname(moo, &io_name);
moo_freemem (moo, io_name.ptr);
if (!arg->name) goto oops;
}
return 0; return 0;
oops: oops:
@ -3703,6 +3718,7 @@ void moo_abortstd (moo_t* moo)
moo_abort (moo); moo_abort (moo);
} }
#if defined(MOO_INCLUDE_COMPILER)
int moo_compilestd (moo_t* moo, const moo_iostd_t* in, moo_oow_t count) int moo_compilestd (moo_t* moo, const moo_iostd_t* in, moo_oow_t count)
{ {
xtn_t* xtn = GET_XTN(moo); xtn_t* xtn = GET_XTN(moo);
@ -3716,6 +3732,7 @@ int moo_compilestd (moo_t* moo, const moo_iostd_t* in, moo_oow_t count)
return 0; return 0;
} }
#endif
void moo_rcvtickstd (moo_t* moo, int v) void moo_rcvtickstd (moo_t* moo, int v)
{ {

28
moo/lib/utl.c
View File

@ -914,7 +914,7 @@ int moo_convutobcstr (moo_t* moo, const moo_uch_t* ucs, moo_oow_t* ucslen, moo_b
/* ----------------------------------------------------------------------- */ /* ----------------------------------------------------------------------- */
MOO_INLINE moo_uch_t* moo_dupbtoucharswithheadroom (moo_t* moo, moo_oow_t headroom_bytes, const moo_bch_t* bcs, moo_oow_t bcslen, moo_oow_t* ucslen) moo_uch_t* moo_dupbtoucharswithheadroom (moo_t* moo, moo_oow_t headroom_bytes, const moo_bch_t* bcs, moo_oow_t bcslen, moo_oow_t* ucslen)
{ {
moo_oow_t inlen, outlen; moo_oow_t inlen, outlen;
moo_uch_t* ptr; moo_uch_t* ptr;
@ -942,12 +942,7 @@ MOO_INLINE moo_uch_t* moo_dupbtoucharswithheadroom (moo_t* moo, moo_oow_t headro
return ptr; return ptr;
} }
moo_uch_t* moo_dupbtouchars (moo_t* moo, const moo_bch_t* bcs, moo_oow_t bcslen, moo_oow_t* ucslen) moo_bch_t* moo_duputobcharswithheadroom (moo_t* moo, moo_oow_t headroom_bytes, const moo_uch_t* ucs, moo_oow_t ucslen, moo_oow_t* bcslen)
{
return moo_dupbtoucharswithheadroom (moo, 0, bcs, bcslen, ucslen);
}
MOO_INLINE moo_bch_t* moo_duputobcharswithheadroom (moo_t* moo, moo_oow_t headroom_bytes, const moo_uch_t* ucs, moo_oow_t ucslen, moo_oow_t* bcslen)
{ {
moo_oow_t inlen, outlen; moo_oow_t inlen, outlen;
moo_bch_t* ptr; moo_bch_t* ptr;
@ -971,15 +966,9 @@ MOO_INLINE moo_bch_t* moo_duputobcharswithheadroom (moo_t* moo, moo_oow_t headro
return ptr; return ptr;
} }
moo_bch_t* moo_duputobchars (moo_t* moo, const moo_uch_t* ucs, moo_oow_t ucslen, moo_oow_t* bcslen)
{
return moo_duputobcharswithheadroom (moo, 0, ucs, ucslen, bcslen);
}
/* ----------------------------------------------------------------------- */ /* ----------------------------------------------------------------------- */
MOO_INLINE moo_uch_t* moo_dupbtoucstrwithheadroom (moo_t* moo, moo_oow_t headroom_bytes, const moo_bch_t* bcs, moo_oow_t* ucslen) moo_uch_t* moo_dupbtoucstrwithheadroom (moo_t* moo, moo_oow_t headroom_bytes, const moo_bch_t* bcs, moo_oow_t* ucslen)
{ {
moo_oow_t inlen, outlen; moo_oow_t inlen, outlen;
moo_uch_t* ptr; moo_uch_t* ptr;
@ -999,12 +988,7 @@ MOO_INLINE moo_uch_t* moo_dupbtoucstrwithheadroom (moo_t* moo, moo_oow_t headroo
return ptr; return ptr;
} }
moo_uch_t* moo_dupbtoucstr (moo_t* moo, const moo_bch_t* bcs, moo_oow_t* ucslen) moo_bch_t* moo_duputobcstrwithheadroom (moo_t* moo, moo_oow_t headroom_bytes, const moo_uch_t* ucs, moo_oow_t* bcslen)
{
return moo_dupbtoucstrwithheadroom (moo, 0, bcs, ucslen);
}
MOO_INLINE moo_bch_t* moo_duputobcstrwithheadroom (moo_t* moo, moo_oow_t headroom_bytes, const moo_uch_t* ucs, moo_oow_t* bcslen)
{ {
moo_oow_t inlen, outlen; moo_oow_t inlen, outlen;
moo_bch_t* ptr; moo_bch_t* ptr;
@ -1026,10 +1010,6 @@ MOO_INLINE moo_bch_t* moo_duputobcstrwithheadroom (moo_t* moo, moo_oow_t headroo
return ptr; return ptr;
} }
moo_bch_t* moo_duputobcstr (moo_t* moo, const moo_uch_t* ucs, moo_oow_t* bcslen)
{
return moo_duputobcstrwithheadroom (moo, 0, ucs, bcslen);
}
/* ----------------------------------------------------------------------- */ /* ----------------------------------------------------------------------- */
moo_uch_t* moo_dupuchars (moo_t* moo, const moo_uch_t* ucs, moo_oow_t ucslen) moo_uch_t* moo_dupuchars (moo_t* moo, const moo_uch_t* ucs, moo_oow_t ucslen)