From 9511ac744290276d7f213b2731fcf2d47d87bcc7 Mon Sep 17 00:00:00 2001 From: Nathan R Date: Mon, 26 Jul 2021 15:40:19 +0200 Subject: [PATCH] updated outputTree with macros --- ccmeta.leg | 732 +++++++++++++++++++++++++++-------------------------- 1 file changed, 367 insertions(+), 365 deletions(-) diff --git a/ccmeta.leg b/ccmeta.leg index 4c6a80f..e23d0ed 100644 --- a/ccmeta.leg +++ b/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("\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)