updated outputTree with macros

ccmeta.leg

@@ -40,7 +40,7 @@
     _DO(C_aggregate) _DO(C_attribute) _DO(C_postfix) _DO(C_compound) _DO(C_functionDef)         \
     _DO(C_exprStatement) _DO(C_switch) _DO(C_goto) _DO(C_continue) _DO(C_break) _DO(C_return)   \
     _DO(C_case) _DO(C_default) _DO(C_label) _DO(C_labelDeclaration) _DO(C_structSpec)           \
-    _DO(C_structDeclarator) _DO(C_enumSpec) _DO(C_enum) _DO(NullObject)
+    _DO(C_structDeclarator) _DO(C_enumSpec) _DO(C_enum)
 
 typedef enum {
 t_UNDEFINED=0,
@@ -49,7 +49,8 @@ DO_PROTOS()
 #undef _DO
 } proto_t;
 
-#define SYMBOL_PAYLOAD proto_t prototype;
+#define SYMBOL_PAYLOAD proto_t prototype; int typeName;
+#define DELTA 3
 
 #include "object.c"
 
@@ -91,8 +92,9 @@ oop globals= 0;
     _DO(try) _DO(catch) _DO(finally) _DO(exception)                                                     \
     _DO(__line__) _DO(__file__)                                                                         \
     _DO(comment)	                                                                                    \
-    _DO(text) _DO(if) _DO(lparen) _DO(rparen) _DO(else) _DO(identifier) _DO(semicolon) _DO(while)       \
-    _DO(do) _DO(for) _DO(initExpr) _DO(condExpr) _DO(incrExpr) _DO(firstSemi) _DO(secondSemi)           \
+    _DO(text) _DO(ifTok) _DO(lparen) _DO(rparen) _DO(elseTok) _DO(identifier) _DO(semicolon)            \
+    _DO(whileTok)                                                                                       \
+    _DO(doTok) _DO(forTok) _DO(initExpr) _DO(condExpr) _DO(incrExpr) _DO(firstSemi) _DO(secondSemi)     \
     _DO(binary) _DO(specifiers) _DO(declarators)                                                        \
     _DO(rightCurly) _DO(leftCurly) _DO(initList) _DO(comma) _DO(constExpr1) _DO(constExpr2)             \
     _DO(ellipsis) _DO(logicalOr) _DO(question) _DO(colon) _DO(leftBracket) _DO(rightBracket)            \
@@ -255,19 +257,18 @@ oop newMap(oop value)
 }
 
 oop newNullObject() {
-    oop object = newObject(NullObject_proto);
-    return object;
+    return null;
 }
 
 oop new_C_if(oop ifTok, oop lParen, oop condition, oop rParen, oop consequent, oop elseTok, oop alternate)
 {
     oop obj = newObject(C_if_proto);
-    map_set(obj, if_symbol,         ifTok);
+    map_set(obj, ifTok_symbol,      ifTok);
     map_set(obj, lparen_symbol,     lParen);
     map_set(obj, condition_symbol,  condition);
     map_set(obj, rparen_symbol,     rParen);
     map_set(obj, consequent_symbol, consequent);
-    map_set(obj, else_symbol,       elseTok);
+    map_set(obj, elseTok_symbol,    elseTok);
     map_set(obj, alternate_symbol,  alternate);
     return obj;
 }
@@ -275,7 +276,7 @@ oop new_C_if(oop ifTok, oop lParen, oop condition, oop rParen, oop consequent, o
 oop new_C_while(oop whileTok, oop lParen, oop expression, oop rParen, oop statement)
 {
     oop object = newObject(C_while_proto);
-    map_set(object, while_symbol,       whileTok);
+    map_set(object, whileTok_symbol,    whileTok);
     map_set(object, lparen_symbol,      lParen);
     map_set(object, expression_symbol,  expression);
     map_set(object, rparen_symbol,      rParen);
@@ -286,9 +287,9 @@ oop new_C_while(oop whileTok, oop lParen, oop expression, oop rParen, oop statem
 oop new_C_do(oop doTok, oop statement, oop whileTok, oop lParen, oop expression, oop rParen, oop semicolon)
 {
     oop object = newObject(C_do_proto);
-    map_set(object, do_symbol,          doTok);
+    map_set(object, doTok_symbol,       doTok);
     map_set(object, statements_symbol,  statement);
-    map_set(object, while_symbol,       whileTok);
+    map_set(object, whileTok_symbol,    whileTok);
     map_set(object, lparen_symbol,      lParen);
     map_set(object, expression_symbol,  expression);
     map_set(object, rparen_symbol,      rParen);
@@ -299,7 +300,7 @@ oop new_C_do(oop doTok, oop statement, oop whileTok, oop lParen, oop expression,
 oop new_C_for(oop forTok, oop lParen, oop initExpr, oop semicolon1, oop condExpr, oop semicolon2, oop incrExpr, oop rParen, oop statement)
 {
     oop object = newObject(C_for_proto);
-    map_set(object, for_symbol,         forTok);
+    map_set(object, forTok_symbol,         forTok);
     map_set(object, lparen_symbol,      lParen);
     map_set(object, initExpr_symbol,    initExpr);
     map_set(object, firstSemi_symbol,   semicolon1);
@@ -812,17 +813,43 @@ oop new_C_parameter(oop paramSpecifiers, oop declarator) {
     return object;
 }
 
+int typdeffing = 0;
+
+void declarationTypedef() {
+    typdeffing++;
+}
+
         /* TODO */
-void C_declarationBegin(void) {}
-int  C_declarationAbort(void) { return 0; }
-void C_declarationEnd(void) {}
+void C_declarationBegin(void) {
+    typdeffing = 0;
+}
+
+int  C_declarationAbort(void) { 
+    typdeffing = 0; 
+    return 0;
+}
+
+void C_declarationEnd(void) {
+    typdeffing = 0;
+}
 
 void C_scopeBegin(){}
 int C_scopeAbort(){ return 0; }
 void C_scopeEnd(){}
 
-int declarationId(char *s) { return 1; }
-int isTypedefName(char *s) { return 1; }
+int declarationId(char *s) { 
+    oop object = intern(s);
+    int typeName = get(object, Symbol, typeName);
+    if (typeName) return 1; 
+    if (!typdeffing) return 0;
+    set(object, Symbol, typeName, 1);
+    return 1;
+}
+
+int isTypedefName(char *s) { 
+    oop object = intern(s);
+    return get(object, Symbol, typeName);
+}
 
 oop new_C_conditional(oop logicalOrExpression, oop question, oop expression, oop colon, oop conditionalExpression) {
     oop object = newObject(C_conditional_proto);
@@ -1060,10 +1087,7 @@ oop  listEmpty(void)
     return makeMap();
 }
 
-void declarationTypedef(void)
-{
-    //printf("DECLARATION TYPEDEF\n");
-}
+
 
 %}
 
@@ -3022,35 +3046,33 @@ void outputNode(oop node)
       case t_C_id:
           outputNode(map_get(node, identifier_symbol));
           break;
-      case t_NullObject:
-          break;
       case t_C_if:
-          outputNode(map_get(node, if_symbol));
+          outputNode(map_get(node, ifTok_symbol));
           outputNode(map_get(node, lparen_symbol));
           outputNode(map_get(node, condition_symbol));
           outputNode(map_get(node, rparen_symbol));
           outputNode(map_get(node, consequent_symbol));
-          outputNode(map_get(node, else_symbol));       // null if no else clause
+          outputNode(map_get(node, elseTok_symbol));       // null if no else clause
           outputNode(map_get(node, alternate_symbol));  // null if no else clause
           break;
       case t_C_while:
-          outputNode(map_get(node, while_symbol));
+          outputNode(map_get(node, whileTok_symbol));
           outputNode(map_get(node, lparen_symbol));
           outputNode(map_get(node, expression_symbol));
           outputNode(map_get(node, rparen_symbol));
           outputNode(map_get(node, statements_symbol));
           break;
       case t_C_do:
-          outputNode(map_get(node, do_symbol));
+          outputNode(map_get(node, doTok_symbol));
           outputNode(map_get(node, statements_symbol));
-          outputNode(map_get(node, while_symbol));
+          outputNode(map_get(node, whileTok_symbol));
           outputNode(map_get(node, lparen_symbol));
           outputNode(map_get(node, expression_symbol));
           outputNode(map_get(node, rparen_symbol));
           outputNode(map_get(node, semicolon_symbol));
           break;
       case t_C_for:
-          outputNode(map_get(node, for_symbol));
+          outputNode(map_get(node, forTok_symbol));
           outputNode(map_get(node, lparen_symbol));
           outputNode(map_get(node, initExpr_symbol));
           outputNode(map_get(node, firstSemi_symbol));
@@ -3324,12 +3346,12 @@ void outputValue(oop node) {
         case Undefined:
             return;
         case String:
-            printf("%s\n", (get(node, String, value)));
+            printf("<%s>\n", (get(node, String, value)));
             return;
         case Map:
             break;
         case Symbol:
-            printf("%s\n", get(node, Symbol, name));
+            printf("<%s>\n", get(node, Symbol, name));
             return;
         default:
             fprintf(stderr, "\noutputNode: unknown node type %i\n", getType(node));
@@ -3345,6 +3367,11 @@ void printSpace(int depth) {
 
 void outputTree(oop node, int depth)
 {
+    if(node == null) {
+        printSpace(depth);
+        printf("<null>\n");
+        return;
+    }
     assert(is(Map, node));
     oop proto= map_get(node, __proto___symbol);
     if (null == proto) { // assume this is just a list of nodes
@@ -3359,349 +3386,324 @@ void outputTree(oop node, int depth)
     proto_t proto_number= get(map_get(proto, __name___symbol), Symbol, prototype);
     printSpace(depth);
     switch (proto_number) {
-      case t_Comment:
-          printf("COMMENT : ");
-          outputValue(map_get(node, text_symbol));
-          break;
-      case t_Token:
-          printf("TOKEN : ");
-          outputValue(map_get(node, text_symbol));
-          break;
-      case t_C_int:
-          printf("INT : ");
-          outputValue(map_get(node, text_symbol));
-          break;
-      case t_C_float:
-          printf("FLOAT : ");
-          outputValue(map_get(node, text_symbol));
-          break;
-      case t_C_char:
-          printf("CHAR : ");
-          outputValue(map_get(node, value_symbol));
-          break;
-      case t_C_id:
-          printf("ID : ");
-          outputValue(map_get(node, identifier_symbol));
-          break;
-      case t_NullObject:
-          printf("\r");
-          break;
-      case t_C_if:
-          outputTree(map_get(node, if_symbol), depth);
-          outputTree(map_get(node, lparen_symbol), depth+3);
-          outputTree(map_get(node, condition_symbol), depth+3);
-          outputTree(map_get(node, rparen_symbol), depth+3);
-          outputTree(map_get(node, consequent_symbol), depth+3);
-          outputTree(map_get(node, else_symbol), depth);            // null if no else clause
-          outputTree(map_get(node, alternate_symbol), depth+3);     // null if no else clause
+#define CASE(NAME) case t_##NAME:printf("%s:\n", #NAME);
+#define OUT(NAME) printSpace(depth+DELTA); outputValue(map_get(node, text_symbol));
+      CASE(Comment)
+          OUT(Comment);
+          break;
+      CASE(Token)
+          OUT(Token);
+          break;
+#undef  CASE
+#undef  OUT
+
+#define CASE(NAME) case t_C_##NAME:printf("%s:\n", #NAME);
+#define OUT(NAME) printSpace(depth+DELTA) ; outputValue(map_get(node, NAME##_symbol));
+      CASE(int)
+          OUT(text);
+          break;
+      CASE(float)
+          OUT(text);
+          break;
+      CASE(char)
+          OUT(value);
+          break;
+      CASE(id)
+          OUT(identifier);
+          break;
+#undef  CASE
+#undef  OUT
+
+#define CASE(NAME) case t_C_##NAME:printf("%s:\n", #NAME);
+#define OUT(NAME) printSpace(depth+DELTA); printf("(%s)\n", #NAME); outputTree(map_get(node, NAME##_symbol), depth+2*DELTA);
+      CASE(if)
+          OUT(ifTok);
+          OUT(lparen);
+          OUT(condition);
+          OUT(rparen);
+          OUT(consequent);
+          OUT(elseTok);
+          OUT(alternate);
           break;      
-      case t_C_while:
-          outputTree(map_get(node, while_symbol), depth);
-          outputTree(map_get(node, lparen_symbol), depth+3);
-          outputTree(map_get(node, expression_symbol), depth+3);
-          outputTree(map_get(node, rparen_symbol), depth+3);
-          outputTree(map_get(node, statements_symbol), depth+3);
-          break;
-      case t_C_do:
-          outputTree(map_get(node, do_symbol), depth);
-          outputTree(map_get(node, statements_symbol), depth+3);
-          outputTree(map_get(node, while_symbol), depth);
-          outputTree(map_get(node, lparen_symbol), depth+3);
-          outputTree(map_get(node, expression_symbol), depth+3);
-          outputTree(map_get(node, rparen_symbol), depth+3);
-          outputTree(map_get(node, semicolon_symbol), depth+3);
-          break;
-      case t_C_for:
-          outputTree(map_get(node, for_symbol), depth);
-          outputTree(map_get(node, lparen_symbol), depth+3);
-          outputTree(map_get(node, initExpr_symbol), depth+3);
-          outputTree(map_get(node, firstSemi_symbol), depth+3);
-          outputTree(map_get(node, condExpr_symbol), depth+3);
-          outputTree(map_get(node, secondSemi_symbol), depth+3);
-          outputTree(map_get(node, incrExpr_symbol), depth+3);
-          outputTree(map_get(node, rparen_symbol), depth+3);
-          outputTree(map_get(node, statements_symbol), depth+3);
-          break;
-      case t_C_goto:
-          outputTree(map_get(node, gotoTok_symbol), depth);
-          outputTree(map_get(node, star_symbol), depth+3);
-          outputTree(map_get(node, name_symbol), depth+3);
-          outputTree(map_get(node, semicolon_symbol), depth+3);
-          break;
-      case t_C_initializer:
-          printf("INITIALIZER :\n");
-          outputTree(map_get(node, leftCurly_symbol), depth+3);
-          outputTree(map_get(node, initList_symbol), depth+3);
-          outputTree(map_get(node, comma_symbol), depth+3);
-          outputTree(map_get(node, rightCurly_symbol), depth+3);
-          break;
-      case t_C_range:
-          printf("RANGE :\n");
-          outputTree(map_get(node, constExpr1_symbol), depth+3);
-          outputTree(map_get(node, ellipsis_symbol), depth+3);
-          outputTree(map_get(node, constExpr2_symbol), depth+3);
-          break;
-      case t_C_switch:
-          outputTree(map_get(node, switchTok_symbol), depth);
-          outputTree(map_get(node, lparen_symbol), depth+3);
-          outputTree(map_get(node, expression_symbol), depth+3);
-          outputTree(map_get(node, rparen_symbol), depth+3);
-          outputTree(map_get(node, statements_symbol), depth+3);
-          break;
-      case t_C_case:
-          outputTree(map_get(node, caseTok_symbol), depth);
-          outputTree(map_get(node, expression_symbol), depth+3);
-          outputTree(map_get(node, colon_symbol), depth+3);
-          outputTree(map_get(node, statements_symbol), depth+3);
-          break;
-      case t_C_default:
-          outputTree(map_get(node, defaultTok_symbol), depth);
-          outputTree(map_get(node, colon_symbol), depth+3);
-          outputTree(map_get(node, statements_symbol), depth+3);
-          break;
-      case t_C_attribution:
-          printf("ATTRIBUTION :\n");
-          outputTree(map_get(node, specifiers_symbol), depth+3);
-          outputTree(map_get(node, declarators_symbol), depth+3);
-          break;
-      case t_C_deref:
-          printf("DEREF :\n");
-          outputTree(map_get(node, star_symbol), depth+3);
-          outputTree(map_get(node, typeQualList_symbol), depth+3);
-          outputTree(map_get(node, declarators_symbol), depth+3);
-          break;
-      case t_C_functionDef:
-          printf("FUNCTION DEF :\n");
-          outputTree(map_get(node, specifiers_symbol), depth+3);
-          outputTree(map_get(node, declarators_symbol), depth+3);
-          outputTree(map_get(node, declarationL_symbol), depth+3);
-          outputTree(map_get(node, compoundS_symbol), depth+3);
-          break;
-      case t_C_sizeOf:
-          outputTree(map_get(node, sizeOfTok_symbol), depth);
-          outputTree(map_get(node, lparen_symbol), depth+3);
-          outputTree(map_get(node, typeName_symbol), depth+3);
-          outputTree(map_get(node, rparen_symbol), depth+3);
-          break;
-      case t_C_alignOf:
-          outputTree(map_get(node, alignOfTok_symbol), depth);
-          outputTree(map_get(node, lparen_symbol), depth+3);
-          outputTree(map_get(node, typeName_symbol), depth+3);
-          outputTree(map_get(node, rparen_symbol), depth+3);
-          break;
-      case t_C_prefix:
-          printf("PREFIX :\n");
-          outputTree(map_get(node, operator_symbol), depth+3);
-          outputTree(map_get(node, expression_symbol), depth+3);
+      CASE(while)
+          OUT(whileTok);
+          OUT(lparen);
+          OUT(expression);
+          OUT(rparen);
+          OUT(statements)
+          break;
+      CASE(do)
+          OUT(doTok);
+          OUT(statements);
+          OUT(whileTok);
+          OUT(lparen);
+          OUT(expression);
+          OUT(rparen);
+          OUT(semicolon);
+          break;
+      CASE(for)
+          OUT(forTok);
+          OUT(lparen);
+          OUT(initExpr);
+          OUT(firstSemi);
+          OUT(condExpr);
+          OUT(secondSemi);
+          OUT(incrExpr);
+          OUT(rparen);
+          OUT(statements);
+          break;
+      CASE(goto)
+          OUT(gotoTok);
+          OUT(star);
+          OUT(name);
+          OUT(semicolon);
+          break;
+      CASE(initializer)
+          OUT(leftCurly);
+          OUT(initList);
+          OUT(comma);
+          OUT(rightCurly);
+          break;
+      CASE(range)
+          OUT(constExpr1);
+          OUT(ellipsis);
+          OUT(constExpr2);
+          break;
+      CASE(switch)
+          OUT(switchTok);
+          OUT(lparen);
+          OUT(expression);
+          OUT(rparen);
+          OUT(statements);
+          break;
+      CASE(case)
+          OUT(caseTok);
+          OUT(expression);
+          OUT(colon);
+          OUT(statements);
+          break;
+      CASE(default)
+          OUT(defaultTok);
+          OUT(colon);
+          OUT(statements);
+          break;
+      CASE(attribution)
+          OUT(specifiers);
+          OUT(declarators);
+          break;
+      CASE(deref)
+          OUT(star);
+          OUT(typeQualList);
+          OUT(declarators);
+          break;
+      CASE(functionDef)
+          OUT(specifiers);
+          OUT(declarators);
+          OUT(declarationL);
+          OUT(compoundS);
+          break;
+      CASE(sizeOf)
+          OUT(sizeOfTok);
+          OUT(lparen);
+          OUT(typeName);
+          OUT(rparen);
+          break;
+      CASE(alignOf)
+          OUT(alignOfTok);
+          OUT(lparen);
+          OUT(typeName);
+          OUT(rparen);
+          break;
+      CASE(prefix)
+          OUT(operator);
+          OUT(expression);
           break; 
-      case t_C_postfix:
-          printf("POSTFIX :\n");
-          outputTree(map_get(node, expression_symbol), depth+3);
-          outputTree(map_get(node, operator_symbol), depth+3);
+      CASE(postfix)
+          OUT(expression);
+          OUT(operator);
           break; 
-      case t_C_unary:
-          printf("UNARY :\n");
-          outputTree(map_get(node, operator_symbol), depth+3);
-          outputTree(map_get(node, expression_symbol), depth+3);
+      CASE(unary)
+          OUT(operator);
+          OUT(expression);
           break;    
-      case t_C_binary:
-          printf("BINARY \n");
-          outputTree(map_get(node, lhs_symbol), depth+3);
-          outputTree(map_get(node, binary_symbol), depth+3);
-          outputTree(map_get(node, rhs_symbol), depth+3);
-          break;
-      case t_C_compound:
-          printf("COMPOUND :\n");
-          outputTree(map_get(node, leftCurly_symbol), depth+3);
-          outputTree(map_get(node, expression_symbol), depth+3);
-          outputTree(map_get(node, rightCurly_symbol), depth+3);
-          break;
-      case t_C_subexpr:
-          printf("SUBEXPR :\n");
-          outputTree(map_get(node, lparen_symbol), depth+3);
-          outputTree(map_get(node, declarators_symbol), depth+3);
-          outputTree(map_get(node, rparen_symbol), depth+3);
-          break;
-      case t_C_call:
-          printf("CALL :\n");
-          outputTree(map_get(node, declarators_symbol), depth+3);
-          outputTree(map_get(node, lparen_symbol), depth+3);
-          outputTree(map_get(node, paramTypeL_symbol), depth+3);
-          outputTree(map_get(node, rparen_symbol), depth+3);
-          break;
-      case t_C_array:
-          printf("ARRAY :\n");
-          outputTree(map_get(node, declarators_symbol), depth+3);
-          outputTree(map_get(node, leftBracket_symbol), depth+3);
-          outputTree(map_get(node, static_symbol), depth+3);
-          outputTree(map_get(node, typeQualList_symbol), depth+3);
-          outputTree(map_get(node, dynamic_symbol), depth+3);
-          outputTree(map_get(node, assignExpr_symbol), depth+3);
-          outputTree(map_get(node, rightBracket_symbol), depth+3);
-          break;
-      case t_C_block:
-          printf("BLOCK :\n");
-          outputTree(map_get(node, bxor_symbol), depth+3);
-          outputTree(map_get(node, typeQualList_symbol), depth+3);
-          outputTree(map_get(node, declarators_symbol), depth+3);
-          break;
-      case t_C_continue:
-          outputTree(map_get(node, continueTok_symbol), depth);
-          outputTree(map_get(node, semicolon_symbol), depth+3);
-          break;
-      case t_C_break:
-          outputTree(map_get(node, breakTok_symbol), depth);
-          outputTree(map_get(node, semicolon_symbol), depth+3);
-          break;
-      case t_C_return:
-          printf("Salut");
-          outputTree(map_get(node, returnTok_symbol), depth);
-          outputTree(map_get(node, expression_symbol), depth+3);
-          outputTree(map_get(node, semicolon_symbol), depth+3);
-          break;
-      case t_C_exprStatement:
-          printf("EXPRESSION :\n");
-          outputTree(map_get(node, expression_symbol), depth+3);
-          outputTree(map_get(node, semicolon_symbol), depth+3);
-          break;
-      case t_C_asm:
-          outputTree(map_get(node, asmTok_symbol), depth);
-          outputTree(map_get(node, lparen_symbol), depth+3);
-          outputTree(map_get(node, text_symbol), depth+3);
-          outputTree(map_get(node, rparen_symbol), depth+3);
-          break;
-      case t_C_asmExpr:
-          printf("ASM EXPR :\n");
-          outputTree(map_get(node, asmTok_symbol), depth+3);
-          outputTree(map_get(node, volatileTok_symbol), depth+3);
-          outputTree(map_get(node, gotoTok_symbol), depth+3);
-          outputTree(map_get(node, lparen_symbol), depth+3);
-          outputTree(map_get(node, text_symbol), depth+3);
-          outputTree(map_get(node, element_symbol), depth+3);
-          outputTree(map_get(node, lparen_symbol), depth+3);
-          break;
-      case t_C_asmExprArg:
-          printf("ASM EXPR ARG :\n");
-          outputTree(map_get(node, text_symbol), depth+3);
-          outputTree(map_get(node, lparen_symbol), depth+3);
-          outputTree(map_get(node, expression_symbol), depth+3);
-          outputTree(map_get(node, lparen_symbol), depth+3);
-          break;
-      case t_C_declaration:
-          printf("DECLARATION :\n");
-          outputTree(map_get(node, specifiers_symbol), depth+3);
-          outputTree(map_get(node, declarators_symbol), depth+3);
-          outputTree(map_get(node, semicolon_symbol), depth+3);
-          break;
-      case t_C_parameter:
-          printf("PARAMETER :\n");
-          outputTree(map_get(node, specifiers_symbol), depth+3);
-          outputTree(map_get(node, declarators_symbol), depth+3);
-          break;
-      case t_C_conditional:
-          printf("CONDITIONAL :\n");
-          outputTree(map_get(node, logicalOr_symbol), depth+3);
-          outputTree(map_get(node, question_symbol), depth+3);
-          outputTree(map_get(node, expression_symbol), depth+3);
-          outputTree(map_get(node, colon_symbol), depth+3);
-          outputTree(map_get(node, condExpr_symbol), depth+3);
-          break;
-      case t_C_designation:
-          printf("DESIGNATION :\n");
-          outputTree(map_get(node, identifier_symbol), depth+3);
-          outputTree(map_get(node, colon_symbol), depth+3);
-          break;
-      case t_C_index:
-          printf("INDEX :\n");
-          outputTree(map_get(node, primaryExpr_symbol), depth+3);
-          outputTree(map_get(node, leftBracket_symbol), depth+3);
-          outputTree(map_get(node, expression_symbol), depth+3);
-          outputTree(map_get(node, rightBracket_symbol), depth+3);
-          break;
-      case t_C_typeOf:
-          outputTree(map_get(node, typeOfTok_symbol), depth);
-          outputTree(map_get(node, lparen_symbol), depth+3);
-          outputTree(map_get(node, typeName_symbol), depth+3);
-          outputTree(map_get(node, expression_symbol), depth+3);
-          outputTree(map_get(node, rparen_symbol), depth+3);
-          break;
-      case t_C_cast:
-          printf("CAST :\n");
-          outputTree(map_get(node, lparen_symbol), depth+3);
-          outputTree(map_get(node, typeName_symbol), depth+3);
-          outputTree(map_get(node, rparen_symbol), depth+3);
-          outputTree(map_get(node, expression_symbol), depth+3);
-          break;
-      case t_C_attributeSpec:
-          printf("ATTRIBUTE SPEC :\n");
-          outputTree(map_get(node, attributeTok_symbol), depth+3);
-          outputTree(map_get(node, llparen_symbol), depth+3);
-          outputTree(map_get(node, lrparen_symbol), depth+3);
-          outputTree(map_get(node, attributeL_symbol), depth+3);
-          outputTree(map_get(node, rlparen_symbol), depth+3);
-          outputTree(map_get(node, rrparen_symbol), depth+3);
-          break;
-      case t_C_aggregate:
-          printf("AGGREGATE :\n");
-          outputTree(map_get(node, lparen_symbol), depth+3);
-          outputTree(map_get(node, typeName_symbol), depth+3);
-          outputTree(map_get(node, rparen_symbol), depth+3);
-          outputTree(map_get(node, leftCurly_symbol), depth+3);
-          outputTree(map_get(node, initList_symbol), depth+3);
-          outputTree(map_get(node, comma_symbol), depth+3);
-          outputTree(map_get(node, rightCurly_symbol), depth+3);
-          break;
-      case t_C_attribute:
-          printf("ATTRIBUTE :\n");
-          outputTree(map_get(node, text_symbol), depth+3);
-          outputTree(map_get(node, lparen_symbol), depth+3);
-          outputTree(map_get(node, expression_symbol), depth+3);
-          outputTree(map_get(node, rparen_symbol), depth+3);
-          break;
-      case t_C_label:
-          printf("LABEL :\n");
-          outputTree(map_get(node, name_symbol), depth+3);
-          outputTree(map_get(node, colon_symbol), depth+3);
-          outputTree(map_get(node, attributeL_symbol), depth+3);
-          outputTree(map_get(node, statements_symbol), depth+3);
-          break;
-      case t_C_labelDeclaration:
-          outputTree(map_get(node, labels_symbol), depth);
-          outputTree(map_get(node, element_symbol), depth+3);
-          outputTree(map_get(node, semicolon_symbol), depth+3);
-          break;
-      case t_C_structSpec:
-          outputTree(map_get(node, structTok_symbol), depth);
-          outputTree(map_get(node, attribute1_symbol), depth+3);
-          outputTree(map_get(node, name_symbol), depth+3);
-          outputTree(map_get(node, leftCurly_symbol), depth+3);
-          outputTree(map_get(node, declarationL_symbol), depth+3);
-          outputTree(map_get(node, rightCurly_symbol), depth+3);
-          outputTree(map_get(node, attribute2_symbol), depth+3);
-          break;
-      case t_C_structDeclarator:
-          printf("STRUCT DECLARATOR :\n");
-          outputTree(map_get(node, declarators_symbol), depth+3);
-          outputTree(map_get(node, colon_symbol), depth+3);
-          outputTree(map_get(node, expression_symbol), depth+3);
-          break;
-      case t_C_enumSpec:
-          outputTree(map_get(node, enumTok_symbol), depth);
-          outputTree(map_get(node, name_symbol), depth+3);
-          outputTree(map_get(node, leftCurly_symbol), depth+3);
-          outputTree(map_get(node, enumList_symbol), depth+3);
-          outputTree(map_get(node, rightCurly_symbol), depth+3);
-          break;
-      case t_C_enum:
-          printf("ENUM :");
-          outputTree(map_get(node, name_symbol), depth+3);
-          outputTree(map_get(node, attributeL_symbol), depth+3);
-          outputTree(map_get(node, expression_symbol), depth+3);
+      CASE(binary)
+          OUT(lhs);
+          OUT(binary);
+          OUT(rhs);
+          break;
+      CASE(compound)
+          OUT(leftCurly);
+          OUT(expression);
+          OUT(rightCurly);
+          break;
+      CASE(subexpr)
+          OUT(lparen);
+          OUT(declarators);
+          OUT(rparen);
+          break;
+      CASE(call)
+          OUT(declarators);
+          OUT(lparen);
+          OUT(paramTypeL);
+          OUT(rparen);
+          break;
+      CASE(array)
+          OUT(declarators);
+          OUT(leftBracket);
+          OUT(static);
+          OUT(typeQualList);
+          OUT(dynamic);
+          OUT(assignExpr);
+          OUT(rightBracket);
+          break;
+      CASE(block)
+          OUT(bxor);
+          OUT(typeQualList);
+          OUT(declarators);
+          break;
+      CASE(continue)
+          OUT(continueTok);
+          OUT(semicolon);
+          break;
+      CASE(break)
+          OUT(breakTok);
+          OUT(semicolon);
+          break;
+      CASE(return)
+          OUT(returnTok);
+          OUT(expression);
+          OUT(semicolon);
+          break;
+      CASE(exprStatement)
+          OUT(expression);
+          OUT(semicolon);
+          break;
+      CASE(asm)
+          OUT(asmTok);
+          OUT(lparen);
+          OUT(text);
+          OUT(rparen);
+          break;
+      CASE(asmExpr)
+          OUT(asmTok);
+          OUT(volatileTok);
+          OUT(gotoTok);
+          OUT(lparen);
+          OUT(text);
+          OUT(element);
+          OUT(rparen);
+          break;
+      CASE(asmExprArg)
+          OUT(text);
+          OUT(lparen);
+          OUT(expression);
+          OUT(rparen);
+          break;
+      CASE(declaration)
+          OUT(specifiers);
+          OUT(declarators);
+          OUT(semicolon);
+          break;
+      CASE(parameter)
+          OUT(specifiers);
+          OUT(declarators);
+          break;
+      CASE(conditional)
+          OUT(logicalOr);
+          OUT(question);
+          OUT(expression);
+          OUT(colon);
+          OUT(condExpr);
+          break;
+      CASE(designation)
+          OUT(identifier);
+          OUT(colon);
+          break;
+      CASE(index)
+          OUT(primaryExpr);
+          OUT(leftBracket);
+          OUT(expression);
+          OUT(rightBracket);
+          break;
+      CASE(typeOf)
+          OUT(typeOfTok);
+          OUT(lparen);
+          OUT(typeName);
+          OUT(expression);
+          OUT(rparen);
+          break;
+      CASE(cast)
+          OUT(lparen);
+          OUT(typeName);
+          OUT(rparen);
+          OUT(expression);
+          break;
+      CASE(attributeSpec)
+          OUT(attributeTok);
+          OUT(llparen);
+          OUT(lrparen);
+          OUT(attributeL);
+          OUT(rlparen);
+          OUT(rrparen);
+          break;
+      CASE(aggregate)
+          OUT(lparen);
+          OUT(typeName);
+          OUT(rparen);
+          OUT(leftCurly);
+          OUT(initList);
+          OUT(comma);
+          OUT(rightCurly);
+          break;
+      CASE(attribute)
+          OUT(text);
+          OUT(lparen);
+          OUT(expression);
+          OUT(rparen);
+          break;
+      CASE(label)
+          OUT(name);
+          OUT(colon);
+          OUT(attributeL);
+          OUT(statements);
+          break;
+      CASE(labelDeclaration)
+          OUT(labels);
+          OUT(element);
+          OUT(semicolon);
+          break;
+      CASE(structSpec)
+          OUT(structTok);
+          OUT(attribute1);
+          OUT(name);
+          OUT(leftCurly);
+          OUT(declarationL);
+          OUT(rightCurly);
+          OUT(attribute2);
+          break;
+      CASE(structDeclarator)
+          OUT(declarators);
+          OUT(colon);
+          OUT(expression);
+          break;
+      CASE(enumSpec)
+          OUT(enumTok);
+          OUT(name);
+          OUT(leftCurly);
+          OUT(enumList);
+          OUT(rightCurly);
+          break;
+      CASE(enum)
+          OUT(name);
+          OUT(attributeL);
+          OUT(expression);
           break;
       default:
           printf("I cannot print a node with proto_number %i\n", proto_number);
           exit(0);
     }
+#undef CASE
+#undef OUT
 }
 
 int main(int argc, char **argv)