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

some preparatory work before supporting method body in an interface.

Browse Source
This commit is contained in:
hyunghwan.chung 2019-10-03 16:38:15 +00:00
parent e1d71f340e
commit 8390804a6c
3 changed files with 97 additions and 73 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

162
moo/lib/comp.c
View File

@ -945,6 +945,20 @@ static int add_to_oow_pool (moo_t* moo, moo_oow_pool_t* pool, moo_oow_t v, const
return 0; return 0;
} }
static MOO_INLINE moo_method_data_t* get_cunit_method_data (moo_t* moo)
{
static moo_oow_t offset[] = /* [NOTE] this is dependent on moo_cunit_type_t */
{
0, /* blank */
0, /* pooldic */
MOO_OFFSETOF(moo_cunit_class_t, mth),
MOO_OFFSETOF(moo_cunit_interface_t, mth)
};
MOO_ASSERT (moo, moo->c->cunit && (moo->c->cunit->cunit_type == MOO_CUNIT_CLASS || moo->c->cunit->cunit_type == MOO_CUNIT_INTERFACE));
return (moo_method_data_t*)((moo_uint8_t*)moo->c->cunit + offset[moo->c->cunit->cunit_type]);
}
/* --------------------------------------------------------------------- /* ---------------------------------------------------------------------
* Tokenizer * Tokenizer
* --------------------------------------------------------------------- */ * --------------------------------------------------------------------- */
@ -2438,25 +2452,25 @@ static int end_include (moo_t* moo)
static MOO_INLINE int add_literal (moo_t* moo, moo_oop_t lit, moo_oow_t* index) static MOO_INLINE int add_literal (moo_t* moo, moo_oop_t lit, moo_oow_t* index)
{ {
#if 0 #if 0
moo_cunit_class_t* cc = (moo_cunit_class_t*)moo->c->cunit; moo_method_data_t* md = get_cunit_method_data(moo);
moo_oow_t i; moo_oow_t i;
for (i = 0; i < cc->mth.literals.count; i++) for (i = 0; i < md->literals.count; i++)
{ {
/* /*
* this removes redundancy of symbols, characters, and small integers. * this removes redundancy of symbols, characters, and small integers.
* more complex redundacy check may be done somewhere else like * more complex redundacy check may be done somewhere else like
* in add_string_literal(). * in add_string_literal().
*/ */
if (cc->mth.literals.ptr[i] == lit) if (md->literals.ptr[i] == lit)
{ {
*index = i; *index = i;
return 0; return 0;
} }
} }
if (add_oop_to_oopbuf(moo, &cc->mth.literals, lit) <= -1) return -1; if (add_oop_to_oopbuf(moo, &md->literals, lit) <= -1) return -1;
*index = cc->mth.literals.count - 1; *index = md->literals.count - 1;
return 0; return 0;
#else #else
/* /*
@ -2464,19 +2478,20 @@ static MOO_INLINE int add_literal (moo_t* moo, moo_oop_t lit, moo_oow_t* index)
* more complex redundacy check may be done somewhere else like * more complex redundacy check may be done somewhere else like
* in add_string_literal(). * in add_string_literal().
*/ */
return add_oop_to_oopbuf_nodup(moo, &((moo_cunit_class_t*)moo->c->cunit)->mth.literals, lit, index); moo_method_data_t* md = get_cunit_method_data(moo);
return add_oop_to_oopbuf_nodup(moo, &md->literals, lit, index);
#endif #endif
} }
static int add_string_literal (moo_t* moo, const moo_oocs_t* str, moo_oow_t* index) static int add_string_literal (moo_t* moo, const moo_oocs_t* str, moo_oow_t* index)
{ {
moo_cunit_class_t* cc = (moo_cunit_class_t*)moo->c->cunit; moo_method_data_t* md = get_cunit_method_data(moo);
moo_oop_t lit; moo_oop_t lit;
moo_oow_t i; moo_oow_t i;
for (i = 0; i < cc->mth.literals.count; i++) for (i = 0; i < md->literals.count; i++)
{ {
lit = cc->mth.literals.ptr[i]; lit = md->literals.ptr[i];
if (MOO_CLASSOF(moo, lit) == moo->_string && if (MOO_CLASSOF(moo, lit) == moo->_string &&
MOO_OBJ_GET_SIZE(lit) == str->len && MOO_OBJ_GET_SIZE(lit) == str->len &&
@ -2525,58 +2540,58 @@ static int add_byte_array_literal (moo_t* moo, const moo_oocs_t* str, moo_oow_t*
static MOO_INLINE int emit_byte_instruction (moo_t* moo, moo_oob_t code, const moo_ioloc_t* srcloc) static MOO_INLINE int emit_byte_instruction (moo_t* moo, moo_oob_t code, const moo_ioloc_t* srcloc)
{ {
moo_cunit_class_t* cc = (moo_cunit_class_t*)moo->c->cunit; moo_method_data_t* md = get_cunit_method_data(moo);
/* the context object has the ip field. it should be representable /* the context object has the ip field. it should be representable
* in a small integer. for simplicity, limit the total byte code length * in a small integer. for simplicity, limit the total byte code length
* to fit in a small integer. because 'ip' points to the next instruction * to fit in a small integer. because 'ip' points to the next instruction
* to execute, he upper bound should be (max - 1) so that i stays * to execute, he upper bound should be (max - 1) so that i stays
* at the max when incremented */ * at the max when incremented */
if (cc->mth.code.len == MOO_SMOOI_MAX - 1) if (md->code.len == MOO_SMOOI_MAX - 1)
{ {
moo_seterrnum (moo, MOO_EBCFULL); /* byte code too big */ moo_seterrnum (moo, MOO_EBCFULL); /* byte code too big */
return -1; return -1;
} }
if (cc->mth.code.len >= cc->mth.code.capa) if (md->code.len >= md->code.capa)
{ {
moo_oob_t* tmp; moo_oob_t* tmp;
moo_oow_t* tmp2; moo_oow_t* tmp2;
moo_oow_t newcapa; moo_oow_t newcapa;
newcapa = MOO_ALIGN (cc->mth.code.len + 1, CODE_BUFFER_ALIGN); newcapa = MOO_ALIGN (md->code.len + 1, CODE_BUFFER_ALIGN);
tmp = (moo_oob_t*)moo_reallocmem(moo, cc->mth.code.ptr, newcapa * MOO_SIZEOF(*tmp)); tmp = (moo_oob_t*)moo_reallocmem(moo, md->code.ptr, newcapa * MOO_SIZEOF(*tmp));
if (!tmp) return -1; if (!tmp) return -1;
tmp2 = (moo_oow_t*)moo_reallocmem(moo, cc->mth.code.locptr, newcapa * MOO_SIZEOF(*tmp2)); tmp2 = (moo_oow_t*)moo_reallocmem(moo, md->code.locptr, newcapa * MOO_SIZEOF(*tmp2));
if (!tmp) if (!tmp)
{ {
moo_freemem (moo, tmp); moo_freemem (moo, tmp);
return -1; return -1;
} }
cc->mth.code.capa = newcapa; md->code.capa = newcapa;
cc->mth.code.ptr = tmp; md->code.ptr = tmp;
cc->mth.code.locptr = tmp2; md->code.locptr = tmp2;
} }
cc->mth.code.ptr[cc->mth.code.len] = code; md->code.ptr[md->code.len] = code;
if (srcloc) if (srcloc)
{ {
if (srcloc->file == cc->mth.start_loc.file && srcloc->line >= cc->mth.start_loc.line) if (srcloc->file == md->start_loc.file && srcloc->line >= md->start_loc.line)
{ {
/*cc->mth.code.locptr[cc->mth.code.len] = srcloc->line - cc->mth.start_loc.line; // relative within the method? */ /*md->code.locptr[md->code.len] = srcloc->line - md->start_loc.line; // relative within the method? */
cc->mth.code.locptr[cc->mth.code.len] = srcloc->line; md->code.locptr[md->code.len] = srcloc->line;
} }
else else
{ {
/* i can't record the distance as the method body is not in the same file */ /* i can't record the distance as the method body is not in the same file */
/* TODO: warning, error handling? */ /* TODO: warning, error handling? */
cc->mth.code.locptr[cc->mth.code.len] = 0; md->code.locptr[md->code.len] = 0;
} }
} }
cc->mth.code.len++; md->code.len++;
return 0; return 0;
} }
@ -2807,15 +2822,15 @@ static MOO_INLINE int emit_backward_jump_instruction (moo_t* moo, int cmd, moo_o
static int patch_forward_jump_instruction (moo_t* moo, moo_oow_t jip, moo_oow_t jt) static int patch_forward_jump_instruction (moo_t* moo, moo_oow_t jip, moo_oow_t jt)
{ {
moo_cunit_class_t* cc = (moo_cunit_class_t*)moo->c->cunit; moo_method_data_t* md = get_cunit_method_data(moo);
moo_oow_t code_size; moo_oow_t code_size;
moo_oow_t jump_offset; moo_oow_t jump_offset;
MOO_ASSERT (moo, cc->mth.code.ptr[jip] == BCODE_JUMP_FORWARD || MOO_ASSERT (moo, md->code.ptr[jip] == BCODE_JUMP_FORWARD ||
cc->mth.code.ptr[jip] == BCODE_JUMP_FORWARD_IF_FALSE || md->code.ptr[jip] == BCODE_JUMP_FORWARD_IF_FALSE ||
cc->mth.code.ptr[jip] == BCODE_JUMP_FORWARD_IF_TRUE || md->code.ptr[jip] == BCODE_JUMP_FORWARD_IF_TRUE ||
cc->mth.code.ptr[jip] == BCODE_JMPOP_FORWARD_IF_FALSE || md->code.ptr[jip] == BCODE_JMPOP_FORWARD_IF_FALSE ||
cc->mth.code.ptr[jip] == BCODE_JMPOP_FORWARD_IF_TRUE); md->code.ptr[jip] == BCODE_JMPOP_FORWARD_IF_TRUE);
if (jt <= jip) if (jt <= jip)
{ {
@ -2828,7 +2843,7 @@ static int patch_forward_jump_instruction (moo_t* moo, moo_oow_t jip, moo_oow_t
MOO_STATIC_ASSERT (BCODE_JUMP_FORWARD_IF_FALSE + 10 == BCODE_JUMP_BACKWARD_IF_FALSE); MOO_STATIC_ASSERT (BCODE_JUMP_FORWARD_IF_FALSE + 10 == BCODE_JUMP_BACKWARD_IF_FALSE);
MOO_STATIC_ASSERT (BCODE_JMPOP_FORWARD_IF_TRUE + 10 == BCODE_JMPOP_BACKWARD_IF_TRUE); MOO_STATIC_ASSERT (BCODE_JMPOP_FORWARD_IF_TRUE + 10 == BCODE_JMPOP_BACKWARD_IF_TRUE);
MOO_STATIC_ASSERT (BCODE_JMPOP_FORWARD_IF_FALSE + 10 == BCODE_JMPOP_BACKWARD_IF_FALSE); MOO_STATIC_ASSERT (BCODE_JMPOP_FORWARD_IF_FALSE + 10 == BCODE_JMPOP_BACKWARD_IF_FALSE);
cc->mth.code.ptr[jip] += 10; /* switch to the backward jump instruction */ md->code.ptr[jip] += 10; /* switch to the backward jump instruction */
code_size = jip - jt + (MOO_BCODE_LONG_PARAM_SIZE + 1); code_size = jip - jt + (MOO_BCODE_LONG_PARAM_SIZE + 1);
} }
else else
@ -2852,7 +2867,7 @@ static int patch_forward_jump_instruction (moo_t* moo, moo_oow_t jip, moo_oow_t
{ {
/* switch to JUMP2 instruction to allow a bigger jump offset. /* switch to JUMP2 instruction to allow a bigger jump offset.
* up to twice MAX_CODE_JUMP only */ * up to twice MAX_CODE_JUMP only */
cc->mth.code.ptr[jip]++; /* switch to the JUMP2 instruction */ md->code.ptr[jip]++; /* switch to the JUMP2 instruction */
jump_offset = code_size - MAX_CODE_JUMP; jump_offset = code_size - MAX_CODE_JUMP;
} }
else else
@ -2861,10 +2876,10 @@ static int patch_forward_jump_instruction (moo_t* moo, moo_oow_t jip, moo_oow_t
} }
#if (MOO_BCODE_LONG_PARAM_SIZE == 2) #if (MOO_BCODE_LONG_PARAM_SIZE == 2)
cc->mth.code.ptr[jip + 1] = jump_offset >> 8; md->code.ptr[jip + 1] = jump_offset >> 8;
cc->mth.code.ptr[jip + 2] = jump_offset & 0xFF; md->code.ptr[jip + 2] = jump_offset & 0xFF;
#else #else
cc->mth.code.ptr[jip + 1] = jump_offset; md->code.ptr[jip + 1] = jump_offset;
#endif #endif
return 0; return 0;
@ -2953,10 +2968,10 @@ static MOO_INLINE int update_loop_continues (moo_t* moo, moo_oow_t jt)
static MOO_INLINE void adjust_all_loop_jumps_for_elimination (moo_t* moo, moo_oow_t start, moo_oow_t end) static MOO_INLINE void adjust_all_loop_jumps_for_elimination (moo_t* moo, moo_oow_t start, moo_oow_t end)
{ {
moo_cunit_class_t* cc = (moo_cunit_class_t*)moo->c->cunit; moo_method_data_t* md = get_cunit_method_data(moo);
moo_loop_t* loop; moo_loop_t* loop;
loop = cc->mth.loop; loop = md->loop;
while (loop) while (loop)
{ {
adjust_loop_jumps_for_elimination (moo, &loop->break_ip_pool, start, end); adjust_loop_jumps_for_elimination (moo, &loop->break_ip_pool, start, end);
@ -2967,10 +2982,10 @@ static MOO_INLINE void adjust_all_loop_jumps_for_elimination (moo_t* moo, moo_oo
static MOO_INLINE void adjust_all_gotos_for_elimination (moo_t* moo, moo_oow_t start, moo_oow_t end) static MOO_INLINE void adjust_all_gotos_for_elimination (moo_t* moo, moo_oow_t start, moo_oow_t end)
{ {
moo_cunit_class_t* cc = (moo_cunit_class_t*)moo->c->cunit; moo_method_data_t* md = get_cunit_method_data(moo);
moo_goto_t* _goto; moo_goto_t* _goto;
_goto = cc->mth._goto; _goto = md->_goto;
while (_goto) while (_goto)
{ {
if (_goto->ip != INVALID_IP) if (_goto->ip != INVALID_IP)
@ -2993,15 +3008,16 @@ static MOO_INLINE void adjust_all_gotos_for_elimination (moo_t* moo, moo_oow_t s
static MOO_INLINE void adjust_all_labels_for_elimination (moo_t* moo, moo_oow_t start, moo_oow_t end) static MOO_INLINE void adjust_all_labels_for_elimination (moo_t* moo, moo_oow_t start, moo_oow_t end)
{ {
moo_cunit_class_t* cc = (moo_cunit_class_t*)moo->c->cunit; moo_method_data_t* md = get_cunit_method_data(moo);
moo_label_t* _label; moo_label_t* _label;
_label = cc->mth._label; _label = md->_label;
while (_label) while (_label)
{ {
if (_label->ip >= start && _label->ip <= end) if (_label->ip >= start && _label->ip <= end)
{ {
/* TODO: ERROR - cannot eliminate this part. caller must ensure this doesn't happen */ /* TODO: ERROR - cannot eliminate this part. caller must ensure this doesn't happen */
MOO_ASSERT (moo, _label->ip < start || _label->ip > end);
} }
else if (_label->ip > end) else if (_label->ip > end)
{ {
@ -3013,12 +3029,12 @@ static MOO_INLINE void adjust_all_labels_for_elimination (moo_t* moo, moo_oow_t
static MOO_INLINE moo_loop_t* unlink_loop (moo_t* moo) static MOO_INLINE moo_loop_t* unlink_loop (moo_t* moo)
{ {
moo_cunit_class_t* cc = (moo_cunit_class_t*)moo->c->cunit; moo_method_data_t* md = get_cunit_method_data(moo);
moo_loop_t* loop; moo_loop_t* loop;
MOO_ASSERT (moo, cc->mth.loop != MOO_NULL); MOO_ASSERT (moo, md->loop != MOO_NULL);
loop = cc->mth.loop; loop = md->loop;
cc->mth.loop = loop->next; md->loop = loop->next;
return loop; return loop;
} }
@ -3037,18 +3053,18 @@ static MOO_INLINE void pop_loop (moo_t* moo)
static MOO_INLINE int inject_break_to_loop (moo_t* moo, const moo_ioloc_t* srcloc) static MOO_INLINE int inject_break_to_loop (moo_t* moo, const moo_ioloc_t* srcloc)
{ {
moo_cunit_class_t* cc = (moo_cunit_class_t*)moo->c->cunit; moo_method_data_t* md = get_cunit_method_data(moo);
if (add_to_oow_pool(moo, &cc->mth.loop->break_ip_pool, cc->mth.code.len, srcloc) <= -1 || if (add_to_oow_pool(moo, &md->loop->break_ip_pool, md->code.len, srcloc) <= -1 ||
emit_single_param_instruction(moo, BCODE_JUMP_FORWARD, MAX_CODE_JUMP, srcloc) <= -1) return -1; emit_single_param_instruction(moo, BCODE_JUMP_FORWARD, MAX_CODE_JUMP, srcloc) <= -1) return -1;
return 0; return 0;
} }
static MOO_INLINE int inject_continue_to_loop (moo_t* moo, const moo_ioloc_t* srcloc) static MOO_INLINE int inject_continue_to_loop (moo_t* moo, const moo_ioloc_t* srcloc)
{ {
moo_cunit_class_t* cc = (moo_cunit_class_t*)moo->c->cunit; moo_method_data_t* md = get_cunit_method_data(moo);
/* used for a do-while loop. jump forward because the conditional /* used for a do-while loop. jump forward because the conditional
* is at the end of the do-while loop */ * is at the end of the do-while loop */
if (add_to_oow_pool(moo, &cc->mth.loop->continue_ip_pool, cc->mth.code.len, srcloc) <= -1 || if (add_to_oow_pool(moo, &md->loop->continue_ip_pool, md->code.len, srcloc) <= -1 ||
emit_single_param_instruction(moo, BCODE_JUMP_FORWARD, MAX_CODE_JUMP, srcloc) <= -1) return -1; emit_single_param_instruction(moo, BCODE_JUMP_FORWARD, MAX_CODE_JUMP, srcloc) <= -1) return -1;
return 0; return 0;
} }
@ -3056,11 +3072,11 @@ static MOO_INLINE int inject_continue_to_loop (moo_t* moo, const moo_ioloc_t* sr
static void eliminate_instructions (moo_t* moo, moo_oow_t start, moo_oow_t end) static void eliminate_instructions (moo_t* moo, moo_oow_t start, moo_oow_t end)
{ {
moo_oow_t last; moo_oow_t last;
moo_cunit_class_t* cc = (moo_cunit_class_t*)moo->c->cunit; moo_method_data_t* md = get_cunit_method_data(moo);
MOO_ASSERT (moo, cc->mth.code.len >= 1); MOO_ASSERT (moo, md->code.len >= 1);
last = cc->mth.code.len - 1; last = md->code.len - 1;
if (end >= last) if (end >= last)
{ {
@ -3069,7 +3085,7 @@ static void eliminate_instructions (moo_t* moo, moo_oow_t start, moo_oow_t end)
adjust_all_loop_jumps_for_elimination (moo, start, last); adjust_all_loop_jumps_for_elimination (moo, start, last);
adjust_all_gotos_for_elimination (moo, start, last); adjust_all_gotos_for_elimination (moo, start, last);
adjust_all_labels_for_elimination (moo, start, last); adjust_all_labels_for_elimination (moo, start, last);
cc->mth.code.len = start; md->code.len = start;
} }
else else
{ {
@ -3081,11 +3097,11 @@ static void eliminate_instructions (moo_t* moo, moo_oow_t start, moo_oow_t end)
adjust_all_gotos_for_elimination (moo, start, end); adjust_all_gotos_for_elimination (moo, start, end);
adjust_all_labels_for_elimination (moo, start, end); adjust_all_labels_for_elimination (moo, start, end);
tail_len = cc->mth.code.len - end - 1; tail_len = md->code.len - end - 1;
MOO_MEMMOVE (&cc->mth.code.ptr[start], &cc->mth.code.ptr[end + 1], tail_len * MOO_SIZEOF(cc->mth.code.ptr[0])); MOO_MEMMOVE (&md->code.ptr[start], &md->code.ptr[end + 1], tail_len * MOO_SIZEOF(md->code.ptr[0]));
MOO_MEMMOVE (&cc->mth.code.locptr[start], &cc->mth.code.locptr[end + 1], tail_len * MOO_SIZEOF(cc->mth.code.locptr[0])); MOO_MEMMOVE (&md->code.locptr[start], &md->code.locptr[end + 1], tail_len * MOO_SIZEOF(md->code.locptr[0]));
cc->mth.code.len -= end - start + 1; md->code.len -= end - start + 1;
} }
} }
@ -3371,48 +3387,48 @@ done:
static int clone_assignee (moo_t* moo, const moo_oocs_t* name, moo_oow_t* offset) static int clone_assignee (moo_t* moo, const moo_oocs_t* name, moo_oow_t* offset)
{ {
moo_cunit_class_t* cc = (moo_cunit_class_t*)moo->c->cunit; moo_method_data_t* md = get_cunit_method_data(moo);
int n; int n;
moo_oow_t old_len; moo_oow_t old_len;
old_len = cc->mth.assignees.len; old_len = md->assignees.len;
n = copy_string_to(moo, name, &cc->mth.assignees, &cc->mth.assignees_capa, 1, '\0'); n = copy_string_to(moo, name, &md->assignees, &md->assignees_capa, 1, '\0');
if (n <= -1) return -1; if (n <= -1) return -1;
/* update the pointer to of the name. its length is the same. */ /* update the pointer to of the name. its length is the same. */
/*name->ptr = cc->mth.assignees.ptr + old_len;*/ /*name->ptr = md->assignees.ptr + old_len;*/
*offset = old_len; *offset = old_len;
return 0; return 0;
} }
static int clone_binary_selector (moo_t* moo, const moo_oocs_t* name, moo_oow_t* offset) static int clone_binary_selector (moo_t* moo, const moo_oocs_t* name, moo_oow_t* offset)
{ {
moo_cunit_class_t* cc = (moo_cunit_class_t*)moo->c->cunit; moo_method_data_t* md = get_cunit_method_data(moo);
int n; int n;
moo_oow_t old_len; moo_oow_t old_len;
old_len = cc->mth.binsels.len; old_len = md->binsels.len;
n = copy_string_to (moo, name, &cc->mth.binsels, &cc->mth.binsels_capa, 1, '\0'); n = copy_string_to (moo, name, &md->binsels, &md->binsels_capa, 1, '\0');
if (n <= -1) return -1; if (n <= -1) return -1;
/* update the pointer to of the name. its length is the same. */ /* update the pointer to of the name. its length is the same. */
/*name->ptr = cc->mth.binsels.ptr + old_len;*/ /*name->ptr = md->binsels.ptr + old_len;*/
*offset = old_len; *offset = old_len;
return 0; return 0;
} }
static int clone_keyword (moo_t* moo, const moo_oocs_t* name, moo_oow_t* offset) static int clone_keyword (moo_t* moo, const moo_oocs_t* name, moo_oow_t* offset)
{ {
moo_cunit_class_t* cc = (moo_cunit_class_t*)moo->c->cunit; moo_method_data_t* md = get_cunit_method_data(moo);
int n; int n;
moo_oow_t old_len; moo_oow_t old_len;
old_len = cc->mth.kwsels.len; old_len = md->kwsels.len;
n = copy_string_to (moo, name, &cc->mth.kwsels, &cc->mth.kwsels_capa, 1, '\0'); n = copy_string_to (moo, name, &md->kwsels, &md->kwsels_capa, 1, '\0');
if (n <= -1) return -1; if (n <= -1) return -1;
/* update the pointer to of the name. its length is the same. */ /* update the pointer to of the name. its length is the same. */
/*name->ptr = cc->mth.kwsels.ptr + old_len;*/ /*name->ptr = md->kwsels.ptr + old_len;*/
*offset = old_len; *offset = old_len;
return 0; return 0;
} }
@ -8471,18 +8487,18 @@ static int make_defined_class (moo_t* moo)
/* TODO: update the subclasses field of the superclass if it's not nil */ /* TODO: update the subclasses field of the superclass if it's not nil */
if (make_getters_and_setters(moo) <= -1) return -1;
if (just_made) if (just_made)
{ {
/* register the class to the system dictionary. kernel classes have /* register the class to the system dictionary. kernel classes have
* been registered at the ignition phase. */ * been registered at the ignition phase. */
if (!moo_putatdic(moo, (moo_oop_dic_t)cc->ns_oop, (moo_oop_t)cc->self_oop->name, (moo_oop_t)cc->self_oop)) return -1; if (!moo_putatdic(moo, (moo_oop_dic_t)cc->ns_oop, (moo_oop_t)cc->self_oop->name, (moo_oop_t)cc->self_oop)) return -1;
MOO_STORE_OOP (moo, (moo_oop_t*)&cc->self_oop->nsup, (moo_oop_t)cc->ns_oop); MOO_STORE_OOP (moo, (moo_oop_t*)&cc->self_oop->nsup, (moo_oop_t)cc->ns_oop);
/* the nsup field of the class must be set before a call to make_getters_and_setters().
* the function may print the full qualified name of the class if method dump
* is performed. */
} }
return 0; return make_getters_and_setters(moo);
} }
static MOO_INLINE int _set_class_indexed_type (moo_t* moo, moo_obj_type_t type) static MOO_INLINE int _set_class_indexed_type (moo_t* moo, moo_obj_type_t type)

6
moo/lib/fmt.c
View File

@ -1583,6 +1583,8 @@ int moo_fmt_object_ (moo_fmtout_t* fmtout, moo_oop_t oop)
} }
else else
{ {
MOO_ASSERT (moo, MOO_CLASSOF(moo, ns) == moo->_namespace);
/* TODO: better memory allocation management? */ /* TODO: better memory allocation management? */
tmp = moo_callocmem(moo, MOO_SIZEOF(*tmp)); tmp = moo_callocmem(moo, MOO_SIZEOF(*tmp));
if (!tmp) goto done_namespace; if (!tmp) goto done_namespace;
@ -1633,6 +1635,8 @@ int moo_fmt_object_ (moo_fmtout_t* fmtout, moo_oop_t oop)
} }
else else
{ {
MOO_ASSERT (moo, MOO_CLASSOF(moo, ns) == moo->_namespace);
/* TODO: better memory allocation management? */ /* TODO: better memory allocation management? */
tmp = moo_callocmem(moo, MOO_SIZEOF(*tmp)); tmp = moo_callocmem(moo, MOO_SIZEOF(*tmp));
if (!tmp) goto done_class; if (!tmp) goto done_class;
@ -1680,6 +1684,8 @@ int moo_fmt_object_ (moo_fmtout_t* fmtout, moo_oop_t oop)
} }
else else
{ {
MOO_ASSERT (moo, MOO_CLASSOF(moo, ns) == moo->_namespace);
/* TODO: better memory allocation management? */ /* TODO: better memory allocation management? */
tmp = moo_callocmem(moo, MOO_SIZEOF(*tmp)); tmp = moo_callocmem(moo, MOO_SIZEOF(*tmp));
if (!tmp) goto done_interface; if (!tmp) goto done_interface;

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

@ -459,6 +459,8 @@ enum moo_pragma_flag_t
enum moo_cunit_type_t enum moo_cunit_type_t
{ {
/* [NOTE] get_cunit_method_data() in comp.c depends on the order of the
* following enumerators */
MOO_CUNIT_BLANK = 0, MOO_CUNIT_BLANK = 0,
MOO_CUNIT_POOLDIC, MOO_CUNIT_POOLDIC,
MOO_CUNIT_CLASS, MOO_CUNIT_CLASS,