self compile lex module test 'scf_lex_test.c & other files its needs' ok, lex '....

diff --git a/core/scf_lex_word.h b/core/scf_lex_word.h
index f505e64ee232d3b035e6c35e47ab690ca4dab54c..8c1a09f9f200b5234de96de9a514d80cddcf82ad 100644 (file)
--- 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 785c52f627b00efaa8bb8c06286796660481f2fd..576915065876a59fe417d5d83542ff720e83621c 100644 (file)
--- 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 (file)
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  = &macro_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 87043fc541d70f3063b88f23f08747bc680b58ed..eba4026e1e4d309969f48052fb14d21c718df65a 100644 (file)
--- 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 3b523d63fff02bc32ef675c59d7e108cdbd46cf9..89b3c9d59eb4560f3b82bf6be8cf469c264b48c0 100644 (file)
--- 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 61ddb6c0d065aa9979d629feea98287cb63c4bec..c7429c13bfd199cb4b5c1ccb2596e70b2ca5de22 100644 (file)
--- 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 e78e4b1d0819f61c58333fd62cdde7ce97018a89..da9eafd1847003b3f648ae46c72f7f6f27090d22 100644 (file)
--- 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)