From: yu.dongliang <18588496441@163.com> Date: Sat, 19 Sep 2026 09:18:05 +0000 (+0800) Subject: self compile lex module test 'scf_lex_test.c & other files its needs' ok, lex '.... X-Git-Url: http://baseworks.info/?a=commitdiff_plain;h=3c992bd54f0a713321bbe13aacd7ee869aed3c4b;p=scf.git self compile lex module test 'scf_lex_test.c & other files its needs' ok, lex '../examples/hanio.c' ok --- diff --git a/core/scf_lex_word.h b/core/scf_lex_word.h index f505e64..8c1a09f 100644 --- a/core/scf_lex_word.h +++ b/core/scf_lex_word.h @@ -27,11 +27,11 @@ enum scf_lex_words SCF_LEX_WORD_BIT_NOT, // ~ SCF_LEX_WORD_BIT_XOR, // ^ - SCF_LEX_WORD_LOGIC_AND, // && - SCF_LEX_WORD_LOGIC_OR, // || - SCF_LEX_WORD_LOGIC_NOT, // ! + SCF_LEX_WORD_LOGIC_AND, // && + SCF_LEX_WORD_LOGIC_OR, // || + SCF_LEX_WORD_LOGIC_NOT, // ! - SCF_LEX_WORD_ASSIGN, // = assign + SCF_LEX_WORD_ASSIGN, // = assign SCF_LEX_WORD_ADD_ASSIGN, // += SCF_LEX_WORD_SUB_ASSIGN, // -= SCF_LEX_WORD_MUL_ASSIGN, // *= @@ -43,19 +43,19 @@ enum scf_lex_words SCF_LEX_WORD_BIT_OR_ASSIGN, // |= SCF_LEX_WORD_BIT_XOR_ASSIGN, // ^= - SCF_LEX_WORD_LT, // < less than - SCF_LEX_WORD_GT, // > greater than + SCF_LEX_WORD_LT, // < less than + SCF_LEX_WORD_GT, // > greater than - SCF_LEX_WORD_EQ, // == equal - SCF_LEX_WORD_NE, // != not equal - SCF_LEX_WORD_LE, // <= less equal - SCF_LEX_WORD_GE, // >= greater equal + SCF_LEX_WORD_EQ, // == equal + SCF_LEX_WORD_NE, // != not equal + SCF_LEX_WORD_LE, // <= less equal + SCF_LEX_WORD_GE, // >= greater equal - SCF_LEX_WORD_LS, // [ left square brackets - SCF_LEX_WORD_RS, // ] right square brackets + SCF_LEX_WORD_LS, // [ left square brackets + SCF_LEX_WORD_RS, // ] right square brackets - SCF_LEX_WORD_LP, // ( left parentheses - SCF_LEX_WORD_RP, // ) right parentheses + SCF_LEX_WORD_LP, // ( left parentheses + SCF_LEX_WORD_RP, // ) right parentheses SCF_LEX_WORD_LA, // << left angle brackets SCF_LEX_WORD_RA, // >> right angle brackets @@ -95,8 +95,8 @@ enum scf_lex_words SCF_LEX_WORD_EOF, // EOF // key words - SCF_LEX_WORD_KEY_IF, // if - SCF_LEX_WORD_KEY_ELSE, // else + SCF_LEX_WORD_KEY_IF, // if + SCF_LEX_WORD_KEY_ELSE, // else SCF_LEX_WORD_KEY_FOR, // for SCF_LEX_WORD_KEY_DO, // do @@ -106,9 +106,9 @@ enum scf_lex_words SCF_LEX_WORD_KEY_CONTINUE, // continue SCF_LEX_WORD_KEY_GOTO, // goto - SCF_LEX_WORD_KEY_SWITCH, // switch - SCF_LEX_WORD_KEY_CASE, // case - SCF_LEX_WORD_KEY_DEFAULT, // default + SCF_LEX_WORD_KEY_SWITCH, // switch + SCF_LEX_WORD_KEY_CASE, // case + SCF_LEX_WORD_KEY_DEFAULT, // default SCF_LEX_WORD_KEY_RETURN, // return @@ -145,7 +145,7 @@ enum scf_lex_words SCF_LEX_WORD_ASM_ASCIZ, // .asciz // data types - SCF_LEX_WORD_KEY_CHAR, // char + SCF_LEX_WORD_KEY_CHAR, // char SCF_LEX_WORD_KEY_SHORT, // short SCF_LEX_WORD_KEY_INT, // int diff --git a/core/scf_variable.c b/core/scf_variable.c index 785c52f..5769150 100644 --- a/core/scf_variable.c +++ b/core/scf_variable.c @@ -37,8 +37,8 @@ int scf_member_offset(scf_member_t* m) int i; int j; - for (i = 0; i < m->indexes->size; i++) { - idx = m->indexes->data[i]; + for (i = m->indexes->size - 1; i >= 0; i--) { + idx = m->indexes->data[i]; if (idx->member) { offset += idx->member->offset; @@ -395,7 +395,7 @@ int scf_variable_type_like(scf_variable_t* v0, scf_variable_t* v1) return 0; if (v0->type != v1->type) { - scf_loge("v0->type: %d, v1->type: %d\n", v0->type, v1->type); + scf_logd("v0->type: %d, v1->type: %d\n", v0->type, v1->type); return 0; } diff --git a/examples/global_struct_array.c b/examples/global_struct_array.c new file mode 100644 index 0000000..baf9ff7 --- /dev/null +++ b/examples/global_struct_array.c @@ -0,0 +1,340 @@ +int printf(const char* fmt, ...); + +enum scf_lex_words +{ + SCF_LEX_WORD_PLUS = 0, // + + SCF_LEX_WORD_MINUS, // - + SCF_LEX_WORD_STAR, // * + SCF_LEX_WORD_DIV, // / div + SCF_LEX_WORD_MOD, // % + + SCF_LEX_WORD_INC, // ++ + SCF_LEX_WORD_DEC, // -- + + SCF_LEX_WORD_SHL, // << + SCF_LEX_WORD_SHR, // >> + + SCF_LEX_WORD_BIT_AND, // & + SCF_LEX_WORD_BIT_OR, // | + SCF_LEX_WORD_BIT_NOT, // ~ + SCF_LEX_WORD_BIT_XOR, // ^ + + SCF_LEX_WORD_LOGIC_AND, // && + SCF_LEX_WORD_LOGIC_OR, // || + SCF_LEX_WORD_LOGIC_NOT, // ! + + SCF_LEX_WORD_ASSIGN, // = assign + SCF_LEX_WORD_ADD_ASSIGN, // += + SCF_LEX_WORD_SUB_ASSIGN, // -= + SCF_LEX_WORD_MUL_ASSIGN, // *= + SCF_LEX_WORD_DIV_ASSIGN, // /= + SCF_LEX_WORD_MOD_ASSIGN, // %= + SCF_LEX_WORD_SHL_ASSIGN, // <<= + SCF_LEX_WORD_SHR_ASSIGN, // >>= + SCF_LEX_WORD_BIT_AND_ASSIGN, // &= + SCF_LEX_WORD_BIT_OR_ASSIGN, // |= + SCF_LEX_WORD_BIT_XOR_ASSIGN, // ^= + + SCF_LEX_WORD_LT, // < less than + SCF_LEX_WORD_GT, // > greater than + + SCF_LEX_WORD_EQ, // == equal + SCF_LEX_WORD_NE, // != not equal + SCF_LEX_WORD_LE, // <= less equal + SCF_LEX_WORD_GE, // >= greater equal + + SCF_LEX_WORD_LS, // [ left square brackets + SCF_LEX_WORD_RS, // ] right square brackets + + SCF_LEX_WORD_LP, // ( left parentheses + SCF_LEX_WORD_RP, // ) right parentheses + + SCF_LEX_WORD_LA, // << left angle brackets + SCF_LEX_WORD_RA, // >> right angle brackets + + SCF_LEX_WORD_KEY_SIZEOF, // sizeof + SCF_LEX_WORD_KEY_TYPEOF, // typeof + SCF_LEX_WORD_KEY_NEW, // create class object + SCF_LEX_WORD_KEY_CONTAINER, // container_of + SCF_LEX_WORD_KEY_VA_ARG, // va_arg + SCF_LEX_WORD_KEY_VA_COPY, // va_copy + SCF_LEX_WORD_KEY_DEFINED, // #defined + + SCF_LEX_WORD_Q_MASK, // ? + SCF_LEX_WORD_COLON, // : colon + + SCF_LEX_WORD_ARROW, // -> arrow + SCF_LEX_WORD_DOT, // . dot + + SCF_LEX_N_OPS, // number of operators + + SCF_LEX_WORD_RANGE, // .. range + SCF_LEX_WORD_VA_ARGS, // ... variable args + + SCF_LEX_WORD_LB, // { left brace + SCF_LEX_WORD_RB, // } right brace + + SCF_LEX_WORD_LF, // '\n', line feed, LF + SCF_LEX_WORD_HASH, // # hash + SCF_LEX_WORD_HASH2, // ## hash2 + SCF_LEX_WORD_DOLLAR, // $ dollar + + SCF_LEX_WORD_COMMA, // , comma + SCF_LEX_WORD_SEMICOLON, // ; + SCF_LEX_WORD_SPACE, // ' ' space + + // eof + SCF_LEX_WORD_EOF, // EOF + + // key words + SCF_LEX_WORD_KEY_IF, // if + SCF_LEX_WORD_KEY_ELSE, // else + + SCF_LEX_WORD_KEY_FOR, // for + SCF_LEX_WORD_KEY_DO, // do + SCF_LEX_WORD_KEY_WHILE, // while + + SCF_LEX_WORD_KEY_BREAK, // break + SCF_LEX_WORD_KEY_CONTINUE, // continue + SCF_LEX_WORD_KEY_GOTO, // goto + + SCF_LEX_WORD_KEY_SWITCH, // switch + SCF_LEX_WORD_KEY_CASE, // case + SCF_LEX_WORD_KEY_DEFAULT, // default + + SCF_LEX_WORD_KEY_RETURN, // return + + SCF_LEX_WORD_KEY_OPERATOR, // operator + SCF_LEX_WORD_KEY_UNDERLINE, // _ underline + + // macro key word + SCF_LEX_WORD_KEY_INCLUDE, // #include + SCF_LEX_WORD_KEY_DEFINE, // #define + SCF_LEX_WORD_KEY_UNDEF, // #undef + + SCF_LEX_WORD_KEY_ERROR, // #error + SCF_LEX_WORD_KEY_LINE, // #line + SCF_LEX_WORD_KEY_PRAGMA, // #pragma + + SCF_LEX_WORD_KEY_IFDEF, // #ifdef + SCF_LEX_WORD_KEY_IFNDEF, // #ifndef + SCF_LEX_WORD_KEY_ELIF, // #elif + SCF_LEX_WORD_KEY_ENDIF, // #endif + + // asm key word + SCF_LEX_WORD_ASM_TEXT, // .text + SCF_LEX_WORD_ASM_DATA, // .data + SCF_LEX_WORD_ASM_GLOBAL, // .global + SCF_LEX_WORD_ASM_ALIGN, // .align + SCF_LEX_WORD_ASM_ORG, // .org + + SCF_LEX_WORD_ASM_FILL, // .fill + SCF_LEX_WORD_ASM_BYTE, // .byte + SCF_LEX_WORD_ASM_WORD, // .word + SCF_LEX_WORD_ASM_LONG, // .long + SCF_LEX_WORD_ASM_QUAD, // .quad + SCF_LEX_WORD_ASM_ASCII, // .ascii + SCF_LEX_WORD_ASM_ASCIZ, // .asciz + + // data types + SCF_LEX_WORD_KEY_CHAR, // char + + SCF_LEX_WORD_KEY_SHORT, // short + SCF_LEX_WORD_KEY_INT, // int + SCF_LEX_WORD_KEY_LONG, // long + + SCF_LEX_WORD_KEY_SIGNED, // signed + SCF_LEX_WORD_KEY_UNSIGNED, // unsigned + + SCF_LEX_WORD_KEY_FLOAT, // float + SCF_LEX_WORD_KEY_DOUBLE, // double + + SCF_LEX_WORD_KEY_INT1, // int1_t + SCF_LEX_WORD_KEY_INT2, // int2_t + SCF_LEX_WORD_KEY_INT3, // int3_t + SCF_LEX_WORD_KEY_INT4, // int4_t + + SCF_LEX_WORD_KEY_BIT, // bit + SCF_LEX_WORD_KEY_BIT2, // bit2_t + SCF_LEX_WORD_KEY_BIT3, // bit3_t + SCF_LEX_WORD_KEY_BIT4, // bit4_t + + SCF_LEX_WORD_KEY_VOID, // void + + SCF_LEX_WORD_KEY_VA_START, // va_start + SCF_LEX_WORD_KEY_VA_END, // va_end + + SCF_LEX_WORD_KEY_CLASS, // class + SCF_LEX_WORD_KEY_TYPEDEF, // typedef + + SCF_LEX_WORD_KEY_CONST, // const + SCF_LEX_WORD_KEY_STATIC, // static + SCF_LEX_WORD_KEY_EXTERN, // extern + SCF_LEX_WORD_KEY_INLINE, // inline + SCF_LEX_WORD_KEY_VOLATILE, // volatile + + // for co-routine + SCF_LEX_WORD_KEY_ASYNC, // async + SCF_LEX_WORD_KEY_AWAIT, // await + + SCF_LEX_WORD_KEY_ENUM, // enum + SCF_LEX_WORD_KEY_UNION, // union + SCF_LEX_WORD_KEY_STRUCT, // struct + + SCF_LEX_WORD_KEY_VAR, // var + + // const literal value + SCF_LEX_WORD_CONST_CHAR, + SCF_LEX_WORD_CONST_WCHAR, + + SCF_LEX_WORD_CONST_INT, + SCF_LEX_WORD_CONST_U32, + SCF_LEX_WORD_CONST_I64, + SCF_LEX_WORD_CONST_U64, + + SCF_LEX_WORD_CONST_FLOAT, + SCF_LEX_WORD_CONST_DOUBLE, + SCF_LEX_WORD_CONST_COMPLEX, + + SCF_LEX_WORD_CONST_WSTRING, + SCF_LEX_WORD_CONST_STRING, + + SCF_LEX_WORD_ID, // identity, start of _, a-z, A-Z, may include 0-9 +}; + +#define SCF_CSTR(_cstr) (_cstr), (sizeof(_cstr) - 1) + +typedef struct { + char* text; + int len; + int type; +} scf_key_word_t; + +static scf_key_word_t macro_key_words[] = +{ + {SCF_CSTR("include"), SCF_LEX_WORD_KEY_INCLUDE}, + {SCF_CSTR("define"), SCF_LEX_WORD_KEY_DEFINE}, + + {SCF_CSTR("ifndef"), SCF_LEX_WORD_KEY_IFNDEF}, + {SCF_CSTR("ifdef"), SCF_LEX_WORD_KEY_IFDEF}, + + {SCF_CSTR("if"), SCF_LEX_WORD_KEY_IF}, + {SCF_CSTR("else"), SCF_LEX_WORD_KEY_ELSE}, + {SCF_CSTR("elif"), SCF_LEX_WORD_KEY_ELIF}, + {SCF_CSTR("endif"), SCF_LEX_WORD_KEY_ENDIF}, + + {SCF_CSTR("undef"), SCF_LEX_WORD_KEY_UNDEF}, + + {SCF_CSTR("pragma"), SCF_LEX_WORD_KEY_PRAGMA}, + {SCF_CSTR("line"), SCF_LEX_WORD_KEY_LINE}, + {SCF_CSTR("error"), SCF_LEX_WORD_KEY_ERROR}, +}; + +static scf_key_word_t key_words[] = +{ + {SCF_CSTR("if"), SCF_LEX_WORD_KEY_IF}, + {SCF_CSTR("else"), SCF_LEX_WORD_KEY_ELSE}, + + {SCF_CSTR("for"), SCF_LEX_WORD_KEY_FOR}, + {SCF_CSTR("while"), SCF_LEX_WORD_KEY_WHILE}, + {SCF_CSTR("do"), SCF_LEX_WORD_KEY_DO}, + + {SCF_CSTR("break"), SCF_LEX_WORD_KEY_BREAK}, + {SCF_CSTR("continue"), SCF_LEX_WORD_KEY_CONTINUE}, + {SCF_CSTR("goto"), SCF_LEX_WORD_KEY_GOTO}, + + {SCF_CSTR("switch"), SCF_LEX_WORD_KEY_SWITCH}, + {SCF_CSTR("case"), SCF_LEX_WORD_KEY_CASE}, + {SCF_CSTR("default"), SCF_LEX_WORD_KEY_DEFAULT}, + + {SCF_CSTR("return"), SCF_LEX_WORD_KEY_RETURN}, + + {SCF_CSTR("sizeof"), SCF_LEX_WORD_KEY_SIZEOF}, + {SCF_CSTR("typeof"), SCF_LEX_WORD_KEY_TYPEOF}, + + {SCF_CSTR("new"), SCF_LEX_WORD_KEY_NEW}, + {SCF_CSTR("operator"), SCF_LEX_WORD_KEY_OPERATOR}, + + {SCF_CSTR("_"), SCF_LEX_WORD_KEY_UNDERLINE}, + + {SCF_CSTR("char"), SCF_LEX_WORD_KEY_CHAR}, + + {SCF_CSTR("short"), SCF_LEX_WORD_KEY_SHORT}, + {SCF_CSTR("int"), SCF_LEX_WORD_KEY_INT}, + {SCF_CSTR("long"), SCF_LEX_WORD_KEY_LONG}, + + {SCF_CSTR("signed"), SCF_LEX_WORD_KEY_SIGNED}, + {SCF_CSTR("unsigned"), SCF_LEX_WORD_KEY_UNSIGNED}, + + {SCF_CSTR("float"), SCF_LEX_WORD_KEY_FLOAT}, + {SCF_CSTR("double"), SCF_LEX_WORD_KEY_DOUBLE}, + + {SCF_CSTR("bit"), SCF_LEX_WORD_KEY_BIT}, + {SCF_CSTR("bit2_t"), SCF_LEX_WORD_KEY_BIT2}, + {SCF_CSTR("bit3_t"), SCF_LEX_WORD_KEY_BIT3}, + {SCF_CSTR("bit4_t"), SCF_LEX_WORD_KEY_BIT4}, + + {SCF_CSTR("int1_t"), SCF_LEX_WORD_KEY_INT1}, + {SCF_CSTR("int2_t"), SCF_LEX_WORD_KEY_INT2}, + {SCF_CSTR("int3_t"), SCF_LEX_WORD_KEY_INT3}, + {SCF_CSTR("int4_t"), SCF_LEX_WORD_KEY_INT4}, + + {SCF_CSTR("void"), SCF_LEX_WORD_KEY_VOID}, + + {SCF_CSTR("container"), SCF_LEX_WORD_KEY_CONTAINER}, + + {SCF_CSTR("class"), SCF_LEX_WORD_KEY_CLASS}, + {SCF_CSTR("typedef"), SCF_LEX_WORD_KEY_TYPEDEF}, + + {SCF_CSTR("const"), SCF_LEX_WORD_KEY_CONST}, + {SCF_CSTR("static"), SCF_LEX_WORD_KEY_STATIC}, + {SCF_CSTR("extern"), SCF_LEX_WORD_KEY_EXTERN}, + {SCF_CSTR("inline"), SCF_LEX_WORD_KEY_INLINE}, + {SCF_CSTR("volatile"), SCF_LEX_WORD_KEY_VOLATILE}, + + {SCF_CSTR("async"), SCF_LEX_WORD_KEY_ASYNC}, + {SCF_CSTR("await"), SCF_LEX_WORD_KEY_AWAIT}, + + {SCF_CSTR("enum"), SCF_LEX_WORD_KEY_ENUM}, + {SCF_CSTR("union"), SCF_LEX_WORD_KEY_UNION}, + {SCF_CSTR("struct"), SCF_LEX_WORD_KEY_STRUCT}, + + {SCF_CSTR(".text"), SCF_LEX_WORD_ASM_TEXT}, + {SCF_CSTR(".data"), SCF_LEX_WORD_ASM_DATA}, + {SCF_CSTR(".global"), SCF_LEX_WORD_ASM_GLOBAL}, + {SCF_CSTR(".align"), SCF_LEX_WORD_ASM_ALIGN}, + {SCF_CSTR(".org"), SCF_LEX_WORD_ASM_ORG}, + + {SCF_CSTR(".fill"), SCF_LEX_WORD_ASM_FILL}, + {SCF_CSTR(".byte"), SCF_LEX_WORD_ASM_BYTE}, + {SCF_CSTR(".word"), SCF_LEX_WORD_ASM_WORD}, + {SCF_CSTR(".long"), SCF_LEX_WORD_ASM_LONG}, + {SCF_CSTR(".quad"), SCF_LEX_WORD_ASM_QUAD}, + {SCF_CSTR(".ascii"), SCF_LEX_WORD_ASM_ASCII}, + {SCF_CSTR(".asciz"), SCF_LEX_WORD_ASM_ASCIZ}, + + {SCF_CSTR("__builtin_va_start"), SCF_LEX_WORD_KEY_VA_START}, + {SCF_CSTR("__builtin_va_arg"), SCF_LEX_WORD_KEY_VA_ARG}, + {SCF_CSTR("__builtin_va_copy"), SCF_LEX_WORD_KEY_VA_COPY}, + {SCF_CSTR("__builtin_va_end"), SCF_LEX_WORD_KEY_VA_END}, +}; + +int main() +{ + scf_key_word_t* w; + int i; + + for (i = 0; i < sizeof(macro_key_words) / sizeof(macro_key_words[0]); i++) { + w = ¯o_key_words[i]; + + printf("i: %d, text: %s, len: %d, type: %d\n", i, w->text, w->len, w->type); + } + + for (i = 0; i < sizeof(key_words) / sizeof(key_words[0]); i++) { + w = &key_words[i]; + + printf("i: %d, text: %s, len: %d, type: %d\n", i, w->text, w->len, w->type); + } + + return 0; +} diff --git a/native/x64/scf_x64_bb_color.c b/native/x64/scf_x64_bb_color.c index 87043fc..eba4026 100644 --- a/native/x64/scf_x64_bb_color.c +++ b/native/x64/scf_x64_bb_color.c @@ -330,27 +330,31 @@ int x64_load_bb_colors(scf_basic_block_t* bb, scf_bb_group_t* bbg, scf_function_ scf_vector_del(r->dag_nodes, dn); } } -#if 0 + for (i = 0; i < bb->dn_colors_entry->size; i++) { ds = bb->dn_colors_entry->data[i]; dn = ds->dag_node; v = dn->var; - +#if 0 scf_logw("j: %d, bb: %d, color: %ld, loaded: %d, ", j, bb->index, dn->color, dn->loaded); if (v->w) printf("v_%d/%s", v->w->line, v->w->text->data); else printf("v_%#lx", 0xffff & (uintptr_t)v); - +#endif if (dn->color > 0) { - scf_register_t* r = x64_find_register_color(dn->color); + r = x64_find_register_color(dn->color); + + if (dn->loaded) + assert(0 == scf_vector_add_unique(r->dag_nodes, dn)); + else + scf_vector_del(r->dag_nodes, dn); - printf(", %s", r->name); +// printf(", %s", r->name); } - printf("\n"); +// printf("\n"); } -#endif return 0; } @@ -471,6 +475,17 @@ int x64_load_bb_colors2(scf_basic_block_t* bb, scf_bb_group_t* bbg, scf_function if (dn->color != ds2->color) break; + + if (dn->loaded != ds2->loaded) { +#if 0 + scf_loge("j: %d, bb: %d, color: %ld, loaded: %d:%d, prev: %d, ", j, bb->index, dn->color, dn->loaded, ds2->loaded, prev->index); + if (v->w) + printf("v_%d/%s\n", v->w->line, v->w->text->data); + else + printf("v_%#lx\n", 0xffff & (uintptr_t)v); +#endif + break; + } } if (j < bb->prevs->size) { diff --git a/parse/scf_dfa_sizeof.c b/parse/scf_dfa_sizeof.c index 3b523d6..89b3c9d 100644 --- a/parse/scf_dfa_sizeof.c +++ b/parse/scf_dfa_sizeof.c @@ -135,7 +135,7 @@ static int _sizeof_action_rp(scf_dfa_t* dfa, scf_vector_t* words, void* data) scf_loge("\n"); return SCF_DFA_ERROR; } - v->data.i = t->size; + v->data.i64 = t->size; n = scf_node_alloc(NULL, SCF_VAR_INTPTR, v); if (!n) { diff --git a/parse/scf_operator_handler_semantic.c b/parse/scf_operator_handler_semantic.c index 61ddb6c..c7429c1 100644 --- a/parse/scf_operator_handler_semantic.c +++ b/parse/scf_operator_handler_semantic.c @@ -1842,21 +1842,27 @@ static int _scf_op_semantic_sizeof(scf_ast_t* ast, scf_node_t** nodes, int nb_no scf_handler_data_t* d = data; + scf_variable_t* r; scf_variable_t* v0 = _scf_operand_get(nodes[0]); scf_node_t* parent = nodes[0]->parent; + scf_type_t* t; assert(v0); assert(SCF_OP_EXPR == nodes[0]->type); assert(d->pret == &parent->result); - int size = scf_variable_size(v0); + int size; + + if (scf_variable_const_string(v0)) + size = v0->data.s->len + 1; + else + size = scf_variable_size(v0); + if (size < 0) return size; - scf_type_t* t = scf_block_find_type_type(ast->current_block, SCF_VAR_INTPTR); - - scf_lex_word_t* w = parent->w; - scf_variable_t* r = SCF_VAR_ALLOC_BY_TYPE(w, t, 1, 0, NULL); + t = scf_block_find_type_type(ast->current_block, SCF_VAR_INTPTR); + r = SCF_VAR_ALLOC_BY_TYPE(NULL, t, 1, 0, NULL); if (!r) return -ENOMEM; diff --git a/parse/scf_parse.c b/parse/scf_parse.c index e78e4b1..da9eafd 100644 --- a/parse/scf_parse.c +++ b/parse/scf_parse.c @@ -2169,7 +2169,7 @@ int64_t scf_parse_fill_code2(scf_parse_t* parse, scf_vector_t* functions, scf_ve r = f->data_relas->data[j]; if (scf_variable_const_string (r->var) - || (scf_variable_const(r->var) && SCF_FUNCTION_PTR != r->var->type)) + || (scf_variable_const(r->var) && SCF_FUNCTION_PTR != r->var->type && 0 == r->var->nb_dimentions)) ret = scf_vector_add_unique(parse->global_consts, r->var); else @@ -2236,7 +2236,7 @@ int scf_parse_fill_code(scf_parse_t* parse, scf_vector_t* functions, scf_vector_ DEBUG_UPDATE_HIGH_PC(cu, offset); assert(parse->debug->lines->size > 0); - r2 = parse->debug->lines->data[parse->debug->lines->size - 1]; + r2 = parse->debug->lines->data[parse->debug->lines->size - 1]; r = calloc(1, sizeof(scf_dwarf_line_result_t)); if (!r)