X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ast.c;h=c29b730bf19560b2633d4ef9c3e11ce8633e3db2;hb=afb476e0d11276b63ca7dfd429f8b2fdd53797b1;hp=86ee507ea1c18c03575a3e56198cc61344ca9e88;hpb=be2e3b8126faf869a608db4d91c57f25a532f55b;p=cparser diff --git a/ast.c b/ast.c index 86ee507..c29b730 100644 --- a/ast.c +++ b/ast.c @@ -14,6 +14,7 @@ struct obstack ast_obstack; static FILE *out; static int indent; +static int print_implicit_casts = 1; static void print_statement(const statement_t *statement); @@ -41,10 +42,10 @@ static void print_const(const const_expression_t *cnst) } } -static void print_quoted_string(const char *string) +static void print_quoted_string(const string_t *const string) { fputc('"', out); - for(const char *c = string; *c != '\0'; ++c) { + for (const char *c = string->begin, *const end = c + string->size; c != end; ++c) { switch(*c) { case '\"': fputs("\\\"", out); break; case '\\': fputs("\\\\", out); break; @@ -58,7 +59,7 @@ static void print_quoted_string(const char *string) case '\?': fputs("\\?", out); break; default: if(!isprint(*c)) { - fprintf(out, "\\x%x", *c); + fprintf(out, "\\%03o", *c); break; } fputc(*c, out); @@ -71,7 +72,7 @@ static void print_quoted_string(const char *string) static void print_string_literal( const string_literal_expression_t *string_literal) { - print_quoted_string(string_literal->value); + print_quoted_string(&string_literal->value); } static void print_wide_string_literal( @@ -140,7 +141,7 @@ static void print_call_expression(const call_expression_t *call) static void print_binary_expression(const binary_expression_t *binexpr) { - if(binexpr->expression.type == EXPR_BINARY_BUILTIN_EXPECT) { + if(binexpr->expression.kind == EXPR_BINARY_BUILTIN_EXPECT) { fputs("__builtin_expect(", out); print_expression(binexpr->left); fputs(", ", out); @@ -152,7 +153,7 @@ static void print_binary_expression(const binary_expression_t *binexpr) fprintf(out, "("); print_expression(binexpr->left); fprintf(out, " "); - switch(binexpr->expression.type) { + switch(binexpr->expression.kind) { case EXPR_BINARY_COMMA: fputs(",", out); break; case EXPR_BINARY_ASSIGN: fputs("=", out); break; case EXPR_BINARY_ADD: fputs("+", out); break; @@ -193,7 +194,7 @@ static void print_binary_expression(const binary_expression_t *binexpr) static void print_unary_expression(const unary_expression_t *unexpr) { - switch(unexpr->expression.type) { + switch(unexpr->expression.kind) { case EXPR_UNARY_NEGATE: fputs("-", out); break; case EXPR_UNARY_PLUS: fputs("+", out); break; case EXPR_UNARY_NOT: fputs("!", out); break; @@ -203,6 +204,10 @@ static void print_unary_expression(const unary_expression_t *unexpr) case EXPR_UNARY_DEREFERENCE: fputs("*", out); break; case EXPR_UNARY_TAKE_ADDRESS: fputs("&", out); break; + case EXPR_UNARY_BITFIELD_EXTRACT: + print_expression(unexpr->value); + return; + case EXPR_UNARY_POSTFIX_INCREMENT: fputs("(", out); print_expression(unexpr->value); @@ -215,14 +220,17 @@ static void print_unary_expression(const unary_expression_t *unexpr) fputs(")", out); fputs("--", out); return; + case EXPR_UNARY_CAST_IMPLICIT: + if(!print_implicit_casts) { + print_expression(unexpr->value); + return; + } + /* fallthrough */ case EXPR_UNARY_CAST: fputs("(", out); print_type(unexpr->expression.datatype); fputs(")", out); break; - case EXPR_UNARY_CAST_IMPLICIT: - print_expression(unexpr->value); - return; case EXPR_UNARY_ASSUME: fputs("__assume", out); break; @@ -270,11 +278,40 @@ static void print_sizeof_expression(const sizeof_expression_t *expression) } } +static void print_alignof_expression(const alignof_expression_t *expression) +{ + fputs("__alignof__(", out); + print_type(expression->type); + fputc(')', out); +} + static void print_builtin_symbol(const builtin_symbol_expression_t *expression) { fputs(expression->symbol->string, out); } +static void print_builtin_constant(const builtin_constant_expression_t *expression) +{ + fputs("__builtin_constant_p(", out); + print_expression(expression->value); + fputc(')', out); +} + +static void print_builtin_prefetch(const builtin_prefetch_expression_t *expression) +{ + fputs("__builtin_prefetch(", out); + print_expression(expression->adr); + if (expression->rw) { + fputc(',', out); + print_expression(expression->rw); + } + if (expression->locality) { + fputc(',', out); + print_expression(expression->locality); + } + fputc(')', out); +} + static void print_conditional(const conditional_expression_t *expression) { fputs("(", out); @@ -308,7 +345,7 @@ static void print_select(const select_expression_t *expression) { print_expression(expression->compound); if(expression->compound->base.datatype == NULL || - expression->compound->base.datatype->type == TYPE_POINTER) { + expression->compound->base.datatype->kind == TYPE_POINTER) { fputs("->", out); } else { fputc('.', out); @@ -324,9 +361,41 @@ static void print_classify_type_expression( fputc(')', out); } +static void print_designator(const designator_t *designator) +{ + fputs(designator->symbol->string, out); + for (designator = designator->next; designator != NULL; designator = designator->next) { + if (designator->array_access) { + fputc('[', out); + print_expression(designator->array_access); + fputc(']', out); + } else { + fputc('.', out); + fputs(designator->symbol->string, out); + } + } +} + +static void print_offsetof_expression(const offsetof_expression_t *expression) +{ + fputs("__builtin_offsetof", out); + fputc('(', out); + print_type(expression->type); + fputc(',', out); + print_designator(expression->designator); + fputc(')', out); +} + +static void print_statement_expression(const statement_expression_t *expression) +{ + fputc('(', out); + print_statement(expression->statement); + fputc(')', out); +} + void print_expression(const expression_t *expression) { - switch(expression->type) { + switch(expression->kind) { case EXPR_UNKNOWN: case EXPR_INVALID: fprintf(out, "*invalid expression*"); @@ -360,14 +429,24 @@ void print_expression(const expression_t *expression) case EXPR_SIZEOF: print_sizeof_expression(&expression->sizeofe); break; + case EXPR_ALIGNOF: + print_alignof_expression(&expression->alignofe); + break; case EXPR_BUILTIN_SYMBOL: print_builtin_symbol(&expression->builtin_symbol); break; + case EXPR_BUILTIN_CONSTANT_P: + print_builtin_constant(&expression->builtin_constant); + break; + case EXPR_BUILTIN_PREFETCH: + print_builtin_prefetch(&expression->builtin_prefetch); + break; case EXPR_CONDITIONAL: print_conditional(&expression->conditional); break; case EXPR_VA_START: print_va_start(&expression->va_starte); + break; case EXPR_VA_ARG: print_va_arg(&expression->va_arge); break; @@ -377,11 +456,16 @@ void print_expression(const expression_t *expression) case EXPR_CLASSIFY_TYPE: print_classify_type_expression(&expression->classify_type); break; - case EXPR_OFFSETOF: + print_offsetof_expression(&expression->offsetofe); + break; case EXPR_STATEMENT: + print_statement_expression(&expression->statement); + break; + + default: /* TODO */ - fprintf(out, "some expression of type %d", (int) expression->type); + fprintf(out, "some expression of type %d", (int) expression->kind); break; } } @@ -542,7 +626,7 @@ static void print_asm_constraints(asm_constraint_t *constraints) if(constraint->symbol) { fprintf(out, "[%s] ", constraint->symbol->string); } - print_quoted_string(constraint->constraints); + print_quoted_string(&constraint->constraints); fputs(" (", out); print_expression(constraint->expression); fputs(")", out); @@ -556,7 +640,7 @@ static void print_asm_clobbers(asm_clobber_t *clobbers) if(clobber != clobbers) fputs(", ", out); - print_quoted_string(clobber->clobber); + print_quoted_string(&clobber->clobber); } } @@ -567,7 +651,7 @@ static void print_asm_statement(const asm_statement_t *statement) fputs("volatile ", out); } fputs("(", out); - print_quoted_string(statement->asm_text); + print_quoted_string(&statement->asm_text); if(statement->inputs == NULL && statement->outputs == NULL && statement->clobbers == NULL) goto end_of_print_asm_statement; @@ -591,7 +675,7 @@ end_of_print_asm_statement: void print_statement(const statement_t *statement) { - switch(statement->type) { + switch(statement->kind) { case STATEMENT_COMPOUND: print_compound_statement(&statement->compound); break; @@ -662,13 +746,13 @@ static void print_storage_class(unsigned storage_class) void print_initializer(const initializer_t *initializer) { - if(initializer->type == INITIALIZER_VALUE) { + if(initializer->kind == INITIALIZER_VALUE) { const initializer_value_t *value = &initializer->value; print_expression(value->value); return; } - assert(initializer->type == INITIALIZER_LIST); + assert(initializer->kind == INITIALIZER_LIST); fputs("{ ", out); const initializer_list_t *list = &initializer->list; @@ -685,7 +769,7 @@ static void print_normal_declaration(const declaration_t *declaration) { print_storage_class(declaration->storage_class); if(declaration->is_inline) { - if (declaration->decl_modifiers & DM_FORCEINLINE) + if (declaration->modifiers & DM_FORCEINLINE) fputs("__forceinline ", out); else fputs("inline ", out); @@ -693,7 +777,7 @@ static void print_normal_declaration(const declaration_t *declaration) print_type_ext(declaration->type, declaration->symbol, &declaration->context); - if(declaration->type->type == TYPE_FUNCTION) { + if(declaration->type->kind == TYPE_FUNCTION) { if(declaration->init.statement != NULL) { fputs("\n", out); print_statement(declaration->init.statement); @@ -760,7 +844,7 @@ void print_ast(const translation_unit_t *unit) bool is_constant_expression(const expression_t *expression) { - switch(expression->type) { + switch(expression->kind) { case EXPR_CONST: case EXPR_STRING_LITERAL: @@ -770,9 +854,12 @@ bool is_constant_expression(const expression_t *expression) case EXPR_FUNCTION: case EXPR_PRETTY_FUNCTION: case EXPR_OFFSETOF: + case EXPR_ALIGNOF: + case EXPR_BUILTIN_CONSTANT_P: return true; case EXPR_BUILTIN_SYMBOL: + case EXPR_BUILTIN_PREFETCH: case EXPR_CALL: case EXPR_SELECT: case EXPR_VA_START: @@ -782,6 +869,7 @@ bool is_constant_expression(const expression_t *expression) case EXPR_UNARY_POSTFIX_DECREMENT: case EXPR_UNARY_PREFIX_INCREMENT: case EXPR_UNARY_PREFIX_DECREMENT: + case EXPR_UNARY_BITFIELD_EXTRACT: case EXPR_UNARY_ASSUME: /* has VOID type */ case EXPR_BINARY_ASSIGN: case EXPR_BINARY_MUL_ASSIGN: