feat: allow incomplete struct

ccc.h

@@ -213,6 +213,7 @@ Type *short_type();
 Type *int_type();
 Type *long_type();
 Type *enum_type();
+Type *struct_type();
 Type *func_type(Type *return_ty);
 Type *pointer_to(Type *base);
 Type *array_of(Type *base, int size);

parse.c

@@ -5,6 +5,7 @@ typedef struct VarScope VarScope;
 struct VarScope {
   VarScope *next;
   char *name;
+  int depth;
   Var *var;
   Type *type_def;
   Type *enum_ty;
@@ -16,6 +17,7 @@ typedef struct TagScope TagScope;
 struct TagScope {
   TagScope *next;
   char *name;
+  int depth;
   Type *ty;
 };
 
@@ -29,19 +31,22 @@ VarList *globals;
 
 VarScope *var_scope;
 TagScope *tag_scope;
+int scope_depth;
 
 Node *current_switch;
 
 Scope *enter_scope() {
   Scope *sc = calloc(1, sizeof(Scope));
   sc->var_scope = var_scope;
   sc->tag_scope = tag_scope;
+  ++scope_depth;
   return sc;
 }
 
 void leave_scope(Scope *sc) {
   var_scope = sc->var_scope;
   tag_scope = sc->tag_scope;
+  --scope_depth;
 }
 
 // Find a variable or a typedef by name.
@@ -100,6 +105,7 @@ VarScope *push_scope(char *name) {
   VarScope *sc = calloc(1, sizeof(VarScope));
   sc->name = name;
   sc->next = var_scope;
+  sc->depth = scope_depth;
   var_scope = sc;
   return sc;
 }
@@ -375,28 +381,53 @@ void push_tag_scope(Token *tok, Type *ty) {
   TagScope *sc = calloc(1, sizeof(TagScope));
   sc->next = tag_scope;
   sc->name = strndup(tok->str, tok->len);
+  sc->depth = scope_depth;
   sc->ty = ty;
   tag_scope = sc;
 }
 
-// struct-decl = "struct" ident
-//             | "struct" ident? "{" struct-member "}"
+// struct-decl = "struct" iden | "struct" ident? ()"{" struct-member "}")?
 Type *struct_decl() {
   // read struct tag
   expect("struct");
   Token *tag = consume_ident();
   if (tag && !peek("{")) {
     TagScope *sc = find_tag(tag);
     if (!sc) {
-      error_tok(tag, "unknown struct type");
+      Type *ty = struct_type();
+      push_tag_scope(tag, ty);
+      return ty;
     }
     if (sc->ty->kind != TY_STRUCT) {
       error_tok(tag, "not a struct tag");
     }
     return sc->ty;
   }
 
-  expect("{");
+  // "struct *st" is legal C that defines st as a pointer to an unamed
+  // incomplete struct type
+  if (!consume("{")) {
+    return struct_type();
+  }
+
+  TagScope *sc = find_tag(tag);
+  Type *ty;
+
+  if (sc && sc->depth == scope_depth) {
+    // if no existing tag has the same tag in the same block scope, it's a
+    // refinition
+    if (sc->ty->kind != TY_STRUCT) {
+      error_tok(tag, "not a struct tag");
+    }
+    ty = sc->ty;
+  } else {
+    // register a struct type as an incomplete type early, so you can write
+    // recursive structs such as "struct T { struct T *next; }"
+    ty = struct_type();
+    if (tag) {
+      push_tag_scope(tag, ty);
+    }
+  }
 
   // read struct members
   Member head;
@@ -408,8 +439,6 @@ Type *struct_decl() {
     cur = cur->next;
   }
 
-  Type *ty = calloc(1, sizeof(Type));
-  ty->kind = TY_STRUCT;
   ty->members = head.next;
 
   // Assign offsets within the struct to members
@@ -423,10 +452,7 @@ Type *struct_decl() {
     }
   }
 
-  // register the struct type if a name was given
-  if (tag) {
-    push_tag_scope(tag, ty);
-  }
+  ty->is_incomplete = false;
   return ty;
 }
 

tests

@@ -804,6 +804,10 @@ int main() {
   assert(5, ({ int i=0; switch(0) { case 0:i=5;break; default:i=7; } i; }), "int i=0; switch(0) { case 0:i=5;break; default:i=7; } i;");
   assert(7, ({ int i=0; switch(1) { case 0:i=5;break; default:i=7; } i; }), "int i=0; switch(1) { case 0:i=5;break; default:i=7; } i;");
 
+  assert(8, ({ struct *foo; sizeof(foo); }), "struct *foo; sizeof(foo);");
+  assert(4, ({ struct T *foo; struct T {int x;}; sizeof(struct T); }), "struct T *foo; struct T {int x;}; sizeof(struct T);");
+  assert(1, ({ struct T { struct T *next; int x; } a; struct T b; b.x=1; a.next=&b; a.next->x; }), "struct T { struct T *next; int x; } a; struct T b; b.x=1; a.next=&b; a.next->x;");
+
   printf("OK\n");
   return 0;
 }

type.c

@@ -20,6 +20,12 @@ Type* int_type() { return new_type(TY_INT, 4); }
 
 Type* long_type() { return new_type(TY_LONG, 8); }
 
+Type* struct_type() {
+  Type* ty = new_type(TY_STRUCT, 1);
+  ty->is_incomplete = true;
+  return ty;
+}
+
 Type* enum_type() { return new_type(TY_ENUM, 4); }
 
 Type* func_type(Type* return_ty) {