Various fixes and starting on handling eject expressions

Author: UplinkCoder

compiler_intrinsics/metac_compiler_interface.h

@@ -12,11 +12,18 @@ typedef void* type;
 typedef enum type_kind_t
 {
     TypeKind_Invalid,
+    TypeKind_Enum,
     TypeKind_Struct = 5,
     TypeKind_Class = TypeKind_Struct + 2,
     TypeKind_Max
 } type_kind_t;
 
+typedef struct  metac_enum_members_t {
+    const char** Names;
+    uint32_t* Values;
+    uint32_t Count;
+} metac_enum_members_t;
+
 typedef struct metac_compiler_t
 {
     void* semanticState;
@@ -50,6 +57,11 @@ typedef struct metac_compiler_t
                                         void (*IdentfierCb)(const char* idChars, uint32_t idKey, void* context),
                                         void* context);
     void (*PrintInt) (int32_t* value);
+
+    metac_enum_members_t* (*GetEnumMembers) (struct metac_compiler_t* compilerP, type* T);
+
+    metac_node_t (*ResolveNode)(struct metac_compiler_t* compilerP, const char* name);
+
 } metac_compiler_t;
 
 /* Proposed Interface:

os/os.c

@@ -5,6 +5,7 @@
 #include <stdio.h>
 
 #define DEFAULT_PAGESIZE 4096
+
 os_error_t PageAlloc(uint32_t minSize, uint32_t* allocatedSize, void** outMemory);
 os_error_t GetTimeStamp(uint32_t* tsp);
 os_error_t SetStartTime(void);
@@ -41,6 +42,7 @@ os_error_t PageAlloc(uint32_t minSize, uint32_t* allocatedSize, void** outMemory
 #else
 #  error "OS not supported"
 #endif
+
     if (result)
     {
         (*allocatedSize) = allocated;

parser/metac_expr_parser.c

@@ -1182,6 +1182,12 @@ metac_expr_t* MetaCParser_ParseUnaryExpr(metac_parser_t* self)
         MetaCParser_Match(self, tok_kw_eject);
         result = AllocNewExpr(expr_eject);
         //PushOperator(expr_eject);
+
+        if (NextIsStmt(self, 1))
+        {
+            result->EjectedStmt = MetaCParser_ParseStmt(self, 0, 0);
+        }
+
         result->E1 = MetaCParser_ParseExpr(self, expr_flags_none, 0);
         result->Hash = CRC32C_VALUE(eject_key, result->E1->Hash);
         //PushOperand(result);

parser/metac_node.h

@@ -39,8 +39,6 @@
     \
     M(decl_function) \
     \
-    M(decl_preproc) \
-    \
     M(decl_label) \
     M(decl_comment)
 

parser/metac_parser.c

@@ -1737,6 +1737,29 @@ static metac_storageclasses_t ParseStorageClasses(metac_parser_t* self)
     return result;
 }
 
+bool NextIsStmt(metac_parser_t* self, int32_t offset)
+{
+    metac_token_t* peek = MetaCParser_PeekToken(self, offset);
+    metac_token_t* peek2 = MetaCParser_PeekToken(self, offset + 1);
+    metac_token_enum_t tok = peek->TokenType;
+
+    return (tok == tok_kw_if ||
+            tok == tok_kw_while ||
+            tok == tok_kw_do ||
+            (tok == tok_at && peek2->IdentifierKey == run_key) ||
+            tok == tok_kw_for ||
+            tok == tok_kw_switch ||
+            (tok == tok_identifier && peek2->TokenType == tok_colon) ||
+            tok == tok_kw_goto ||
+            tok == tok_kw_break ||
+            tok == tok_kw_continue ||
+            tok == tok_kw_case ||
+            tok == tok_kw_default ||
+            tok == tok_kw_return ||
+            tok == tok_kw__yield);
+}
+
+
 metac_decl_t* MetaCParser_ParseDecl(metac_parser_t* self, metac_decl_t* parent)
 {
     metac_storageclasses_t stc = storageclass_none;
@@ -1750,7 +1773,7 @@ metac_decl_t* MetaCParser_ParseDecl(metac_parser_t* self, metac_decl_t* parent)
 
     decl_type_t* type = 0;
 
-#ifndef NO_PREPROCESSOR
+#if !defined(NO_PREPROCESSOR) && 0
     decl_preproc_t* preProcDecl = AllocNewDecl(decl_preproc, &result);
     preProcDecl->DirectiveKind = pp_invalid;
 
@@ -1884,11 +1907,11 @@ metac_decl_t* MetaCParser_ParseDecl(metac_parser_t* self, metac_decl_t* parent)
         // typedefs are exactly like variables
         decl_variable_t* var;
         MetaCParser_Match(self, tok_kw_typedef);
-        var = (decl_variable_t*)MetaCParser_ParseDecl(self, (metac_decl_t*) typdef);
+        var = cast(decl_variable_t*) MetaCParser_ParseDecl(self, (metac_decl_t*) typdef);
 
         MetaCParser_Match(self, tok_semicolon);
 
-        typdef->Type = var->VarType;
+        typdef->Type       = var->VarType;
         typdef->Identifier = var->VarIdentifier;
         assert(typdef->Type->Hash != 0);
         hash = CRC32C_VALUE(hash, typdef->Type->Hash);

parser/metac_parser.h

@@ -113,6 +113,7 @@ bool IsExprNode(metac_node_kind_t Kind);
 bool IsBinaryAssignExp(metac_expr_kind_t expr_kind);
 bool IsBinaryExp(metac_expr_kind_t expr_kind);
 static bool IsUnaryExp(metac_expr_kind_t expr_kind);
+bool NextIsStmt(metac_parser_t* self, int32_t offset);
 
 void MetaCParser_Init(metac_parser_t* self, metac_alloc_t* allocator);
 void MetaCParser_InitFromLexer(metac_parser_t* self, metac_lexer_t* lexer, metac_alloc_t* allocator);

parser/metac_parsetree.c

@@ -38,11 +38,6 @@ int MetaCNode_TreeWalk_Real(metac_node_t node, walker_function_t walker_fn, void
         // decl_type_tuple doesn't really exist
             assert(0);
 
-        case node_decl_preproc:
-        {
-            //TODO do something here.
-        } break;
-
         case node_decl_variable:
         {
             decl_variable_t* decl_variable = cast(decl_variable_t*) node;

parser/metac_parsetree.h

@@ -86,6 +86,10 @@ typedef struct metac_expr_t
         struct {
             struct metac_expr_t* E1;
         };
+        // case expr_eject:
+        struct {
+            struct metac_stmt_t* EjectedStmt;
+        };
         // case expr_sizeof:
         struct {
             struct metac_expr_t* SizeofExp;

repl/repl.c

@@ -233,11 +233,13 @@ static inline int Presemantic(metac_node_t node, void* ctx)
 
         return 1;
     }
+/*
     else if (node->Kind == node_decl_preproc)
     {
         // ignore preproc decls in presemantic
         return 1;
     }
+*/
     else if (MetaCNode_IsDecl(node))
     {
         MetaCSemantic_doDeclSemantic(context->Sema, node);

semantic/metac_semantic.c

@@ -876,15 +876,18 @@ sema_decl_function_t* MetaCSemantic_doFunctionSemantic(metac_sema_state_t* self,
         // as we have an easier time if we know at which
         // param we are and how many follow
         decl_variable_t* paramVar = currentParam->Parameter;
-        /*TODO use identifier in sema table
-        metac_identifier_ptr_t semaId =
-            MetaCIdentifierTable_CopyIdentifier(self->ParserIdentifierTable,
-                                                &self->SemanticIdentifierTable,
-                                                paramVar->VarIdentifier);
-        f->Parameters[i].VarIdentifier = semaId;
-        */
+#if 0
+        // TODO use identifier in sema table
+        {
+            metac_identifier_ptr_t semaId =
+                MetaCIdentifierTable_CopyIdentifier(self->ParserIdentifierTable,
+                                                    &self->SemanticIdentifierTable,
+                                                    paramVar->VarIdentifier);
+            f->Parameters[i].VarIdentifier = semaId;
+        }
+#else
         f->Parameters[i].VarIdentifier = paramVar->VarIdentifier;
-
+#endif
         f->Parameters[i].VarFlags |= variable_is_parameter;
         if (METAC_NODE(paramVar->VarInitExpr) != emptyNode)
         {
@@ -915,6 +918,13 @@ sema_decl_function_t* MetaCSemantic_doFunctionSemantic(metac_sema_state_t* self,
 #endif
             }
         }
+        metac_type_index_t paramTypeIdx = f->Parameters[i].TypeIndex;
+        if (paramTypeIdx.Kind == type_index_basic
+         && paramTypeIdx.Index == type_auto)
+        {
+            fprintf(stderr,
+                "Detected auto type in func params which implies template\n");
+        }
         uint32_t hash = f->Parameters[i].TypeIndex.v;
         hash = CRC32C_VALUE(hash, i);
         f->Parameters[i].Hash = hash;