X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ast.c;h=c29b730bf19560b2633d4ef9c3e11ce8633e3db2;hb=afb476e0d11276b63ca7dfd429f8b2fdd53797b1;hp=0ba0492d4e6b9dfb657938b39c59dcdb95e6514d;hpb=6dc5b6251ac0d183a62021b991d17d2debd603eb;p=cparser diff --git a/ast.c b/ast.c index 0ba0492..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,52 @@ 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( + const wide_string_literal_expression_t *const wstr) +{ + fputs("L\"", out); + for (const wchar_rep_t *c = wstr->value.begin, + *end = c + wstr->value.size; + c != end; ++c) { + switch (*c) { + case L'\"': fputs("\\\"", out); break; + case L'\\': fputs("\\\\", out); break; + case L'\a': fputs("\\a", out); break; + case L'\b': fputs("\\b", out); break; + case L'\f': fputs("\\f", out); break; + case L'\n': fputs("\\n", out); break; + case L'\r': fputs("\\r", out); break; + case L'\t': fputs("\\t", out); break; + case L'\v': fputs("\\v", out); break; + case L'\?': fputs("\\?", out); break; + default: { + const unsigned tc = *c; + if (tc < 0x80U) { + if (!isprint(*c)) { + fprintf(out, "\\%03o", (char)*c); + } else { + fputc(*c, out); + } + } else if (tc < 0x800) { + fputc(0xC0 | (tc >> 6), out); + fputc(0x80 | (tc & 0x3F), out); + } else if (tc < 0x10000) { + fputc(0xE0 | ( tc >> 12), out); + fputc(0x80 | ((tc >> 6) & 0x3F), out); + fputc(0x80 | ( tc & 0x3F), out); + } else { + fputc(0xF0 | ( tc >> 18), out); + fputc(0x80 | ((tc >> 12) & 0x3F), out); + fputc(0x80 | ((tc >> 6) & 0x3F), out); + fputc(0x80 | ( tc & 0x3F), out); + } + } + } + } + fputc('"', out); } static void print_call_expression(const call_expression_t *call) @@ -95,42 +141,51 @@ static void print_call_expression(const call_expression_t *call) static void print_binary_expression(const binary_expression_t *binexpr) { + if(binexpr->expression.kind == EXPR_BINARY_BUILTIN_EXPECT) { + fputs("__builtin_expect(", out); + print_expression(binexpr->left); + fputs(", ", out); + print_expression(binexpr->right); + fputs(")", out); + return; + } + fprintf(out, "("); print_expression(binexpr->left); fprintf(out, " "); - switch(binexpr->type) { - case BINEXPR_INVALID: fputs("INVOP", out); break; - case BINEXPR_COMMA: fputs(",", out); break; - case BINEXPR_ASSIGN: fputs("=", out); break; - case BINEXPR_ADD: fputs("+", out); break; - case BINEXPR_SUB: fputs("-", out); break; - case BINEXPR_MUL: fputs("*", out); break; - case BINEXPR_MOD: fputs("%", out); break; - case BINEXPR_DIV: fputs("/", out); break; - case BINEXPR_BITWISE_OR: fputs("|", out); break; - case BINEXPR_BITWISE_AND: fputs("&", out); break; - case BINEXPR_BITWISE_XOR: fputs("^", out); break; - case BINEXPR_LOGICAL_OR: fputs("||", out); break; - case BINEXPR_LOGICAL_AND: fputs("&&", out); break; - case BINEXPR_NOTEQUAL: fputs("!=", out); break; - case BINEXPR_EQUAL: fputs("==", out); break; - case BINEXPR_LESS: fputs("<", out); break; - case BINEXPR_LESSEQUAL: fputs("<=", out); break; - case BINEXPR_GREATER: fputs(">", out); break; - case BINEXPR_GREATEREQUAL: fputs(">=", out); break; - case BINEXPR_SHIFTLEFT: fputs("<<", out); break; - case BINEXPR_SHIFTRIGHT: fputs(">>", out); break; - - case BINEXPR_ADD_ASSIGN: fputs("+=", out); break; - case BINEXPR_SUB_ASSIGN: fputs("-=", out); break; - case BINEXPR_MUL_ASSIGN: fputs("*=", out); break; - case BINEXPR_MOD_ASSIGN: fputs("%=", out); break; - case BINEXPR_DIV_ASSIGN: fputs("/=", out); break; - case BINEXPR_BITWISE_OR_ASSIGN: fputs("|=", out); break; - case BINEXPR_BITWISE_AND_ASSIGN: fputs("&=", out); break; - case BINEXPR_BITWISE_XOR_ASSIGN: fputs("^=", out); break; - case BINEXPR_SHIFTLEFT_ASSIGN: fputs("<<=", out); break; - case BINEXPR_SHIFTRIGHT_ASSIGN: fputs(">>=", out); break; + 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; + case EXPR_BINARY_SUB: fputs("-", out); break; + case EXPR_BINARY_MUL: fputs("*", out); break; + case EXPR_BINARY_MOD: fputs("%", out); break; + case EXPR_BINARY_DIV: fputs("/", out); break; + case EXPR_BINARY_BITWISE_OR: fputs("|", out); break; + case EXPR_BINARY_BITWISE_AND: fputs("&", out); break; + case EXPR_BINARY_BITWISE_XOR: fputs("^", out); break; + case EXPR_BINARY_LOGICAL_OR: fputs("||", out); break; + case EXPR_BINARY_LOGICAL_AND: fputs("&&", out); break; + case EXPR_BINARY_NOTEQUAL: fputs("!=", out); break; + case EXPR_BINARY_EQUAL: fputs("==", out); break; + case EXPR_BINARY_LESS: fputs("<", out); break; + case EXPR_BINARY_LESSEQUAL: fputs("<=", out); break; + case EXPR_BINARY_GREATER: fputs(">", out); break; + case EXPR_BINARY_GREATEREQUAL: fputs(">=", out); break; + case EXPR_BINARY_SHIFTLEFT: fputs("<<", out); break; + case EXPR_BINARY_SHIFTRIGHT: fputs(">>", out); break; + + case EXPR_BINARY_ADD_ASSIGN: fputs("+=", out); break; + case EXPR_BINARY_SUB_ASSIGN: fputs("-=", out); break; + case EXPR_BINARY_MUL_ASSIGN: fputs("*=", out); break; + case EXPR_BINARY_MOD_ASSIGN: fputs("%=", out); break; + case EXPR_BINARY_DIV_ASSIGN: fputs("/=", out); break; + case EXPR_BINARY_BITWISE_OR_ASSIGN: fputs("|=", out); break; + case EXPR_BINARY_BITWISE_AND_ASSIGN: fputs("&=", out); break; + case EXPR_BINARY_BITWISE_XOR_ASSIGN: fputs("^=", out); break; + case EXPR_BINARY_SHIFTLEFT_ASSIGN: fputs("<<=", out); break; + case EXPR_BINARY_SHIFTRIGHT_ASSIGN: fputs(">>=", out); break; + default: panic("invalid binexpression found"); } fprintf(out, " "); print_expression(binexpr->right); @@ -139,39 +194,48 @@ static void print_binary_expression(const binary_expression_t *binexpr) static void print_unary_expression(const unary_expression_t *unexpr) { - switch(unexpr->type) { - case UNEXPR_NEGATE: fputs("-", out); break; - case UNEXPR_PLUS: fputs("+", out); break; - case UNEXPR_NOT: fputs("!", out); break; - case UNEXPR_BITWISE_NEGATE: fputs("~", out); break; - case UNEXPR_PREFIX_INCREMENT: fputs("++", out); break; - case UNEXPR_PREFIX_DECREMENT: fputs("--", out); break; - case UNEXPR_DEREFERENCE: fputs("*", out); break; - case UNEXPR_TAKE_ADDRESS: fputs("&", out); break; - - case UNEXPR_POSTFIX_INCREMENT: + 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; + case EXPR_UNARY_BITWISE_NEGATE: fputs("~", out); break; + case EXPR_UNARY_PREFIX_INCREMENT: fputs("++", out); break; + case EXPR_UNARY_PREFIX_DECREMENT: fputs("--", out); break; + 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); fputs(")", out); fputs("++", out); return; - case UNEXPR_POSTFIX_DECREMENT: + case EXPR_UNARY_POSTFIX_DECREMENT: fputs("(", out); print_expression(unexpr->value); fputs(")", out); fputs("--", out); return; - case UNEXPR_CAST: + 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 UNEXPR_CAST_IMPLICIT: - print_expression(unexpr->value); - return; - case UNEXPR_INVALID: - fprintf(out, "unop%d", (int) unexpr->type); + case EXPR_UNARY_ASSUME: + fputs("__assume", out); break; + default: + panic("invalid unary expression found"); } fputs("(", out); print_expression(unexpr->value); @@ -214,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); @@ -230,10 +323,19 @@ static void print_conditional(const conditional_expression_t *expression) fputs(")", out); } +static void print_va_start(const va_start_expression_t *const expression) +{ + fputs("__builtin_va_start(", out); + print_expression(expression->ap); + fputs(", ", out); + fputs(expression->parameter->symbol->string, out); + fputs(")", out); +} + static void print_va_arg(const va_arg_expression_t *expression) { fputs("__builtin_va_arg(", out); - print_expression(expression->arg); + print_expression(expression->ap); fputs(", ", out); print_type(expression->expression.datatype); fputs(")", out); @@ -243,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); @@ -259,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*"); @@ -274,10 +408,13 @@ void print_expression(const expression_t *expression) case EXPR_STRING_LITERAL: print_string_literal(&expression->string); break; + case EXPR_WIDE_STRING_LITERAL: + print_wide_string_literal(&expression->wide_string); + break; case EXPR_CALL: print_call_expression(&expression->call); break; - case EXPR_BINARY: + EXPR_BINARY_CASES print_binary_expression(&expression->binary); break; case EXPR_REFERENCE: @@ -286,18 +423,30 @@ void print_expression(const expression_t *expression) case EXPR_ARRAY_ACCESS: print_array_expression(&expression->array_access); break; - case EXPR_UNARY: + EXPR_UNARY_CASES print_unary_expression(&expression->unary); break; 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; @@ -307,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; } } @@ -472,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); @@ -486,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); } } @@ -497,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; @@ -521,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; @@ -592,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; @@ -615,12 +769,15 @@ static void print_normal_declaration(const declaration_t *declaration) { print_storage_class(declaration->storage_class); if(declaration->is_inline) { - fputs("inline ", out); + if (declaration->modifiers & DM_FORCEINLINE) + fputs("__forceinline ", out); + else + fputs("inline ", out); } 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); @@ -685,6 +842,115 @@ void print_ast(const translation_unit_t *unit) } } +bool is_constant_expression(const expression_t *expression) +{ + switch(expression->kind) { + + case EXPR_CONST: + case EXPR_STRING_LITERAL: + case EXPR_WIDE_STRING_LITERAL: + case EXPR_SIZEOF: + case EXPR_CLASSIFY_TYPE: + 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: + case EXPR_VA_ARG: + case EXPR_STATEMENT: + case EXPR_UNARY_POSTFIX_INCREMENT: + 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: + case EXPR_BINARY_DIV_ASSIGN: + case EXPR_BINARY_MOD_ASSIGN: + case EXPR_BINARY_ADD_ASSIGN: + case EXPR_BINARY_SUB_ASSIGN: + case EXPR_BINARY_SHIFTLEFT_ASSIGN: + case EXPR_BINARY_SHIFTRIGHT_ASSIGN: + case EXPR_BINARY_BITWISE_AND_ASSIGN: + case EXPR_BINARY_BITWISE_XOR_ASSIGN: + case EXPR_BINARY_BITWISE_OR_ASSIGN: + case EXPR_BINARY_COMMA: + return false; + + case EXPR_UNARY_NEGATE: + case EXPR_UNARY_PLUS: + case EXPR_UNARY_BITWISE_NEGATE: + case EXPR_UNARY_NOT: + case EXPR_UNARY_DEREFERENCE: + case EXPR_UNARY_TAKE_ADDRESS: + case EXPR_UNARY_CAST: + case EXPR_UNARY_CAST_IMPLICIT: + return is_constant_expression(expression->unary.value); + + case EXPR_BINARY_ADD: + case EXPR_BINARY_SUB: + case EXPR_BINARY_MUL: + case EXPR_BINARY_DIV: + case EXPR_BINARY_MOD: + case EXPR_BINARY_EQUAL: + case EXPR_BINARY_NOTEQUAL: + case EXPR_BINARY_LESS: + case EXPR_BINARY_LESSEQUAL: + case EXPR_BINARY_GREATER: + case EXPR_BINARY_GREATEREQUAL: + case EXPR_BINARY_BITWISE_AND: + case EXPR_BINARY_BITWISE_OR: + case EXPR_BINARY_BITWISE_XOR: + case EXPR_BINARY_LOGICAL_AND: + case EXPR_BINARY_LOGICAL_OR: + case EXPR_BINARY_SHIFTLEFT: + case EXPR_BINARY_SHIFTRIGHT: + case EXPR_BINARY_BUILTIN_EXPECT: + case EXPR_BINARY_ISGREATER: + case EXPR_BINARY_ISGREATEREQUAL: + case EXPR_BINARY_ISLESS: + case EXPR_BINARY_ISLESSEQUAL: + case EXPR_BINARY_ISLESSGREATER: + case EXPR_BINARY_ISUNORDERED: + return is_constant_expression(expression->binary.left) + && is_constant_expression(expression->binary.right); + + case EXPR_CONDITIONAL: + /* TODO: not correct, we only have to test expressions which are + * evaluated, which means either the true or false part might be not + * constant */ + return is_constant_expression(expression->conditional.condition) + && is_constant_expression(expression->conditional.true_expression) + && is_constant_expression(expression->conditional.false_expression); + + case EXPR_ARRAY_ACCESS: + return is_constant_expression(expression->array_access.array_ref) + && is_constant_expression(expression->array_access.index); + + case EXPR_REFERENCE: { + declaration_t *declaration = expression->reference.declaration; + if(declaration->storage_class == STORAGE_CLASS_ENUM_ENTRY) + return true; + + return false; + } + + case EXPR_UNKNOWN: + case EXPR_INVALID: + break; + } + panic("invalid expression found (is constant expression)"); +} + + void init_ast(void) { obstack_init(&ast_obstack);