...

2 files changed, 58 insertions, 25 deletions

diff --git a/semantics.c b/semantics.c
index 3f481a9..a86462c 100644
--- a/semantics.c
+++ b/semantics.c
@@ -292,25 +292,32 @@ void ctype_print(CType_t ct) {
     }
 }
 
-static CType_t type_merge(CType_t new, CScope_t scope) {
-    CType_t old;
-    if (cscope_push_type(scope, new))
+static CType_t struct_type_merge(CType_t new, CScope_t scope) {
+    /* Note: we shall try to lookup first instead of pushing !! */
+    CType_t old = cscope_lookup_type(scope, new->name);
+    if (!old) /* create it if it does not exist */
+    {
+        cscope_push_type(scope, new);
         return new;
-    else 
-        old = cscope_lookup_type(scope, new->name);
-    if (old->type != new->type) 
+    } /* otherwise we have it */
+    if (old->type != new->type) /* not a struct or union */
     {
         sprintf(err_buff, "conflicting types of '%s'", new->name);
         ERROR(new->ast->loc.row, new->ast->loc.col);
     }
-    if (!new->rec.fields)
+    /* otherwise it is a struct or union */
+    if (!new->rec.fields) /* use the old definition */
         return old;
-    if (old->rec.fields)
+    /* otherwise there's a completion definition */
+    if (cscope_push_type(scope, new)) /* try to push the defintion */
+        return new;
+    /* conflict appear */
+    if (old->rec.fields) /* if the old one is complete */
     {
         sprintf(err_buff, "redefinition of '%s'", new->name);
         ERROR(new->ast->loc.row, new->ast->loc.col);
     }
-    /* complete the type */
+    /* otherwise incomplete, thus complete the type */
     old->next = new->next;
     old->rec.fields = new->rec.fields;
     old->ast = new->ast;
@@ -343,7 +350,8 @@ int is_same_type(CType_t typea, CType_t typeb) {
                         return 0;
                 if (pa || pb) 
                     return 0; /* different number of parameters */
-                break;
+                return is_same_type(typea->rec.func.ret,
+                                    typeb->rec.func.ret);
             }
         case CINT: case CCHAR: case CVOID:
             ;
@@ -389,7 +397,7 @@ CType_t semantics_type_spec(CNode *p, CScope_t scope) {
                     type->rec.fields = semantics_fields(fields, scope);
 
                 if (id->type != NOP)
-                    type = type_merge(type, scope);
+                    type = struct_type_merge(type, scope);
             }
             break;
         default: assert(0);
@@ -474,6 +482,7 @@ CVar_t semantics_declr(CNode *p, CType_t type_spec, CScope_t scope) {
                 /* incomplete type */
                 type->rec.func.local = NULL;
                 type->rec.func.ret = p_declr->type;
+                type->rec.func.body = NULL;         /* not a definition */
                 name = p_declr->name;
                 ast = p_declr->ast;
                 free(p_declr);
@@ -537,15 +546,12 @@ CVar_t semantics_decl(CNode *p, CScope_t scope) {
     CNode *init = p->chd->next;
     CType_t type = semantics_type_spec(p->chd, scope);
     CVar_t res = NULL;
-    switch (type->type)
+    int useful = 0;
+    if ((type->type == CSTRUCT || type->type == CUNION) && 
+        (*type->name) != '\0')
     {
-        case CSTRUCT: 
-        case CUNION:
-            cscope_push_type(scope, type); break;
-        case CINT:
-        case CCHAR:
-        case CVOID: break;
-        default: assert(0);
+        cscope_push_type(scope, type);
+        useful = 1;
     }
     if (init->chd->type != NOP)
     {
@@ -558,8 +564,9 @@ CVar_t semantics_decl(CNode *p, CScope_t scope) {
             var->next = res;
             res = var;
         }
+        useful = 1;
     }
-    else
+    if (!useful)
     {
         /* TODO: useless typename warning */
         sprintf(err_buff, "useless declaration");
@@ -647,19 +654,44 @@ CVar_t semantics_comp(CNode *p, CScope_t scope) {
 CVar_t semantics_func(CNode *p, CScope_t scope) {
     CHECK_TYPE(p, FUNC_DEF);
     CNode *chd = p->chd->next;
-    CType_t func = ctype_create(chd->rec.strval, CFUNC, p);
-    CVar_t res;
+    CType_t func = ctype_create(chd->rec.strval, CFUNC, p), funco;
+    CVar_t res, old;
 
     chd = chd->next;
     func->rec.func.ret = semantics_type_spec(p->chd, scope);   /* check return type */
     cscope_enter(scope);                                       /* enter into function local scope */
     func->rec.func.params = semantics_params(chd, scope);      /* check params */
     func->rec.func.local = semantics_comp(chd->next, scope);   /* check comp */
+    func->rec.func.body = chd->next;
     cscope_exit(scope);                                        /* exit from local scope */
     res = cvar_create(func->name, func, p);
-    if (!cscope_push_var(scope, res))
-        puts("fuck func name");
-    return res;
+
+    if (cscope_push_var(scope, res))
+        return res;
+    else
+    {
+        old = cscope_lookup_var(scope, res->name);
+        funco = old->type;
+    }
+    if (funco->type != CFUNC)
+    {
+        sprintf(err_buff, "conflicting types of '%s'", res->name);
+        ERROR(res->ast->loc.row, res->ast->loc.col);
+    }
+    else if (funco->rec.func.body)
+    {
+        sprintf(err_buff, "redefintion of function '%s'", res->name);
+        ERROR(res->ast->loc.row, res->ast->loc.col);
+    }
+    else if (!is_same_type(funco, res->type))
+    {
+        sprintf(err_buff, "function defintion does not match the prototype");
+        ERROR(res->ast->loc.row, res->ast->loc.col);
+    }
+    funco->rec.func.local = res->type->rec.func.local;
+    funco->rec.func.body = res->type->rec.func.body;
+    free(res);
+    return old;
 }
 
 void semantics_check_(CNode *p, CScope_t scope) {
diff --git a/semantics.h b/semantics.h
index dfbf7b7..b770156 100644
--- a/semantics.h
+++ b/semantics.h
@@ -43,6 +43,7 @@ typedef struct CType {
             CVar *params;
             CVar *local;
             struct CType *ret;
+            CNode *body;
         } func;               /* for a function */
     } rec;
     int size;   /* memory footprint */