X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;ds=sidebyside;f=ast.c;h=87d490ed16bed8cf6307ddebee2794c5c6c8e422;hb=23a7fb81b19babf67991342c583bf74a556f3019;hp=41960186a3d57b25e1a9c3835252e1a2ac81a50d;hpb=e141741dd5e795dbb85a97a0a54505bc7ef932da;p=cparser diff --git a/ast.c b/ast.c index 4196018..87d490e 100644 --- a/ast.c +++ b/ast.c @@ -29,22 +29,22 @@ void print_indent(void) fprintf(out, "\t"); } -static void print_const(const const_t *cnst) +static void print_const(const const_expression_t *cnst) { if(cnst->expression.datatype == NULL) return; if(is_type_integer(cnst->expression.datatype)) { - fprintf(out, "%d", cnst->v.int_value); + fprintf(out, "%lld", cnst->v.int_value); } else if(is_type_floating(cnst->expression.datatype)) { fprintf(out, "%Lf", cnst->v.float_value); } } -static void print_string_literal(const string_literal_t *string_literal) +static void print_quoted_string(const char *string) { fputc('"', out); - for(const char *c = string_literal->value; *c != '\0'; ++c) { + for(const char *c = string; *c != '\0'; ++c) { switch(*c) { case '\"': fputs("\\\"", out); break; case '\\': fputs("\\\\", out); break; @@ -68,6 +68,57 @@ static void print_string_literal(const string_literal_t *string_literal) fputc('"', out); } +static void print_string_literal( + const string_literal_expression_t *string_literal) +{ + 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) { print_expression(call->function); @@ -160,8 +211,11 @@ static void print_unary_expression(const unary_expression_t *unexpr) print_type(unexpr->expression.datatype); fputs(")", out); break; + case UNEXPR_CAST_IMPLICIT: + print_expression(unexpr->value); + return; case UNEXPR_INVALID: - fprintf(out, "unop%d", unexpr->type); + fprintf(out, "unop%d", (int) unexpr->type); break; } fputs("(", out); @@ -176,11 +230,19 @@ static void print_reference_expression(const reference_expression_t *ref) static void print_array_expression(const array_access_expression_t *expression) { - fputs("(", out); - print_expression(expression->array_ref); - fputs(")[", out); - print_expression(expression->index); - fputs("]", out); + if(!expression->flipped) { + fputs("(", out); + print_expression(expression->array_ref); + fputs(")[", out); + print_expression(expression->index); + fputs("]", out); + } else { + fputs("(", out); + print_expression(expression->index); + fputs(")[", out); + print_expression(expression->array_ref); + fputs("]", out); + } } static void print_sizeof_expression(const sizeof_expression_t *expression) @@ -225,8 +287,8 @@ static void print_va_arg(const va_arg_expression_t *expression) static void print_select(const select_expression_t *expression) { print_expression(expression->compound); - if(expression->compound->datatype == NULL || - expression->compound->datatype->type == TYPE_POINTER) { + if(expression->compound->base.datatype == NULL || + expression->compound->base.datatype->type == TYPE_POINTER) { fputs("->", out); } else { fputc('.', out); @@ -234,6 +296,14 @@ static void print_select(const select_expression_t *expression) fputs(expression->symbol->string, out); } +static void print_classify_type_expression( + const classify_type_expression_t *const expr) +{ + fputs("__builtin_classify_type(", out); + print_expression(expr->type_expression); + fputc(')', out); +} + void print_expression(const expression_t *expression) { switch(expression->type) { @@ -242,48 +312,54 @@ void print_expression(const expression_t *expression) fprintf(out, "*invalid expression*"); break; case EXPR_CONST: - print_const((const const_t*) expression); + print_const(&expression->conste); break; case EXPR_FUNCTION: case EXPR_PRETTY_FUNCTION: case EXPR_STRING_LITERAL: - print_string_literal((const string_literal_t*) expression); + 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((const call_expression_t*) expression); + print_call_expression(&expression->call); break; case EXPR_BINARY: - print_binary_expression((const binary_expression_t*) expression); + print_binary_expression(&expression->binary); break; case EXPR_REFERENCE: - print_reference_expression((const reference_expression_t*) expression); + print_reference_expression(&expression->reference); break; case EXPR_ARRAY_ACCESS: - print_array_expression((const array_access_expression_t*) expression); + print_array_expression(&expression->array_access); break; case EXPR_UNARY: - print_unary_expression((const unary_expression_t*) expression); + print_unary_expression(&expression->unary); break; case EXPR_SIZEOF: - print_sizeof_expression((const sizeof_expression_t*) expression); + print_sizeof_expression(&expression->sizeofe); break; case EXPR_BUILTIN_SYMBOL: - print_builtin_symbol((const builtin_symbol_expression_t*) expression); + print_builtin_symbol(&expression->builtin_symbol); break; case EXPR_CONDITIONAL: - print_conditional((const conditional_expression_t*) expression); + print_conditional(&expression->conditional); break; case EXPR_VA_ARG: - print_va_arg((const va_arg_expression_t*) expression); + print_va_arg(&expression->va_arge); break; case EXPR_SELECT: - print_select((const select_expression_t*) expression); + print_select(&expression->select); + break; + case EXPR_CLASSIFY_TYPE: + print_classify_type_expression(&expression->classify_type); break; case EXPR_OFFSETOF: case EXPR_STATEMENT: /* TODO */ - fprintf(out, "some expression of type %d", expression->type); + fprintf(out, "some expression of type %d", (int) expression->type); break; } } @@ -298,7 +374,7 @@ static void print_compound_statement(const compound_statement_t *block) print_indent(); print_statement(statement); - statement = statement->next; + statement = statement->base.next; } indent--; print_indent(); @@ -369,6 +445,7 @@ static void print_case_label(const case_label_statement_t *statement) print_expression(statement->expression); fputs(":\n", out); } + print_statement(statement->label_statement); } static void print_declaration_statement( @@ -433,23 +510,80 @@ static void print_for_statement(const for_statement_t *statement) print_statement(statement->body); } +static void print_asm_constraints(asm_constraint_t *constraints) +{ + asm_constraint_t *constraint = constraints; + for( ; constraint != NULL; constraint = constraint->next) { + if(constraint != constraints) + fputs(", ", out); + + if(constraint->symbol) { + fprintf(out, "[%s] ", constraint->symbol->string); + } + print_quoted_string(constraint->constraints); + fputs(" (", out); + print_expression(constraint->expression); + fputs(")", out); + } +} + +static void print_asm_clobbers(asm_clobber_t *clobbers) +{ + asm_clobber_t *clobber = clobbers; + for( ; clobber != NULL; clobber = clobber->next) { + if(clobber != clobbers) + fputs(", ", out); + + print_quoted_string(clobber->clobber); + } +} + +static void print_asm_statement(const asm_statement_t *statement) +{ + fputs("asm ", out); + if(statement->is_volatile) { + fputs("volatile ", out); + } + fputs("(", out); + print_quoted_string(statement->asm_text); + if(statement->inputs == NULL && statement->outputs == NULL + && statement->clobbers == NULL) + goto end_of_print_asm_statement; + + fputs(" : ", out); + print_asm_constraints(statement->inputs); + if(statement->outputs == NULL && statement->clobbers == NULL) + goto end_of_print_asm_statement; + + fputs(" : ", out); + print_asm_constraints(statement->outputs); + if(statement->clobbers == NULL) + goto end_of_print_asm_statement; + + fputs(" : ", out); + print_asm_clobbers(statement->clobbers); + +end_of_print_asm_statement: + fputs(");\n", out); +} + void print_statement(const statement_t *statement) { switch(statement->type) { case STATEMENT_COMPOUND: - print_compound_statement((const compound_statement_t*) statement); + print_compound_statement(&statement->compound); break; case STATEMENT_RETURN: - print_return_statement((const return_statement_t*) statement); + print_return_statement(&statement->returns); break; case STATEMENT_EXPRESSION: - print_expression_statement((const expression_statement_t*) statement); + print_expression_statement(&statement->expression); break; case STATEMENT_LABEL: - print_label_statement((const label_statement_t*) statement); + print_label_statement(&statement->label); break; case STATEMENT_GOTO: - print_goto_statement((const goto_statement_t*) statement); + print_goto_statement(&statement->gotos); break; case STATEMENT_CONTINUE: fputs("continue;\n", out); @@ -458,25 +592,28 @@ void print_statement(const statement_t *statement) fputs("break;\n", out); break; case STATEMENT_IF: - print_if_statement((const if_statement_t*) statement); + print_if_statement(&statement->ifs); break; case STATEMENT_SWITCH: - print_switch_statement((const switch_statement_t*) statement); + print_switch_statement(&statement->switchs); break; case STATEMENT_CASE_LABEL: - print_case_label((const case_label_statement_t*) statement); + print_case_label(&statement->case_label); break; case STATEMENT_DECLARATION: - print_declaration_statement((const declaration_statement_t*) statement); + print_declaration_statement(&statement->declaration); break; case STATEMENT_WHILE: - print_while_statement((const while_statement_t*) statement); + print_while_statement(&statement->whiles); break; case STATEMENT_DO_WHILE: - print_do_while_statement((const do_while_statement_t*) statement); + print_do_while_statement(&statement->do_while); break; case STATEMENT_FOR: - print_for_statement((const for_statement_t*) statement); + print_for_statement(&statement->fors); + break; + case STATEMENT_ASM: + print_asm_statement(&statement->asms); break; case STATEMENT_INVALID: fprintf(out, "*invalid statement*"); @@ -484,35 +621,40 @@ void print_statement(const statement_t *statement) } } -static void print_storage_class(storage_class_t storage_class) +static void print_storage_class(unsigned storage_class) { - switch(storage_class) { + switch((storage_class_tag_t) storage_class) { case STORAGE_CLASS_ENUM_ENTRY: case STORAGE_CLASS_NONE: break; - case STORAGE_CLASS_TYPEDEF: fputs("typedef ", out); break; - case STORAGE_CLASS_EXTERN: fputs("extern ", out); break; - case STORAGE_CLASS_STATIC: fputs("static ", out); break; - case STORAGE_CLASS_AUTO: fputs("auto ", out); break; - case STORAGE_CLASS_REGISTER: fputs("register ", out); break; + case STORAGE_CLASS_TYPEDEF: fputs("typedef ", out); break; + case STORAGE_CLASS_EXTERN: fputs("extern ", out); break; + case STORAGE_CLASS_STATIC: fputs("static ", out); break; + case STORAGE_CLASS_AUTO: fputs("auto ", out); break; + case STORAGE_CLASS_REGISTER: fputs("register ", out); break; + case STORAGE_CLASS_THREAD: fputs("__thread", out); break; + case STORAGE_CLASS_THREAD_EXTERN: fputs("extern __thread", out); break; + case STORAGE_CLASS_THREAD_STATIC: fputs("static __thread", out); break; } } void print_initializer(const initializer_t *initializer) { if(initializer->type == INITIALIZER_VALUE) { - print_expression(initializer->v.value); + const initializer_value_t *value = &initializer->value; + print_expression(value->value); return; } assert(initializer->type == INITIALIZER_LIST); fputs("{ ", out); - initializer_t *iter = initializer->v.list; - for( ; iter != NULL; iter = iter->next) { - print_initializer(iter); - if(iter->next != NULL) { + const initializer_list_t *list = &initializer->list; + + for(size_t i = 0 ; i < list->len; ++i) { + if(i > 0) { fputs(", ", out); } + print_initializer(list->initializers[i]); } fputs("}", out); } @@ -520,11 +662,11 @@ void print_initializer(const initializer_t *initializer) static void print_normal_declaration(const declaration_t *declaration) { print_storage_class(declaration->storage_class); - print_type_ext(declaration->type, declaration->symbol, - &declaration->context); if(declaration->is_inline) { fputs("inline ", out); } + print_type_ext(declaration->type, declaration->symbol, + &declaration->context); if(declaration->type->type == TYPE_FUNCTION) { if(declaration->init.statement != NULL) { @@ -541,11 +683,11 @@ static void print_normal_declaration(const declaration_t *declaration) void print_declaration(const declaration_t *declaration) { - if(declaration->namespace != NAMESPACE_NORMAL && + if(declaration->namespc != NAMESPACE_NORMAL && declaration->symbol == NULL) return; - switch(declaration->namespace) { + switch(declaration->namespc) { case NAMESPACE_NORMAL: print_normal_declaration(declaration); break; @@ -576,13 +718,12 @@ void print_declaration(const declaration_t *declaration) void print_ast(const translation_unit_t *unit) { inc_type_visited(); - set_print_compound_entries(true); declaration_t *declaration = unit->context.declarations; for( ; declaration != NULL; declaration = declaration->next) { if(declaration->storage_class == STORAGE_CLASS_ENUM_ENTRY) continue; - if(declaration->namespace != NAMESPACE_NORMAL && + if(declaration->namespc != NAMESPACE_NORMAL && declaration->symbol == NULL) continue;