X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=write_fluffy.c;h=5379aee2de6901fc7793ba401a2154669b6cbb31;hb=de8b5458c2ecf2bdc87ed001dbfcb1211d1de240;hp=e2d9aac8136c40b869b73851fe85d23445729884;hpb=3ed4fdd019f473d959409bd39d128435189108d4;p=cparser diff --git a/write_fluffy.c b/write_fluffy.c index e2d9aac..5379aee 100644 --- a/write_fluffy.c +++ b/write_fluffy.c @@ -1,45 +1,65 @@ +/* + * This file is part of cparser. + * Copyright (C) 2007-2008 Matthias Braun + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA + * 02111-1307, USA. + */ #include #include #include #include "write_fluffy.h" +#include "symbol_t.h" #include "ast_t.h" #include "type_t.h" #include "type.h" #include "adt/error.h" -static const context_t *global_context; -static FILE *out; +static const scope_t *global_scope; +static FILE *out; static void write_type(const type_t *type); -static const char *get_atomic_type_string(const atomic_type_type_t type) +static const char *get_atomic_type_string(const atomic_type_kind_t type) { switch(type) { - case ATOMIC_TYPE_VOID: return "void"; - case ATOMIC_TYPE_CHAR: return "byte"; - case ATOMIC_TYPE_SCHAR: return "byte"; - case ATOMIC_TYPE_UCHAR: return "unsigned byte"; - case ATOMIC_TYPE_SHORT: return "short"; - case ATOMIC_TYPE_USHORT: return "unsigned short"; - case ATOMIC_TYPE_INT: return "int"; - case ATOMIC_TYPE_UINT: return "unsigned int"; - case ATOMIC_TYPE_LONG: return "int"; - case ATOMIC_TYPE_ULONG: return "unsigned int"; - case ATOMIC_TYPE_LONGLONG: return "long"; - case ATOMIC_TYPE_ULONGLONG: return "unsigned long"; - case ATOMIC_TYPE_FLOAT: return "float"; - case ATOMIC_TYPE_DOUBLE: return "double"; + case ATOMIC_TYPE_VOID: return "void"; + case ATOMIC_TYPE_CHAR: return "byte"; + case ATOMIC_TYPE_SCHAR: return "byte"; + case ATOMIC_TYPE_UCHAR: return "unsigned byte"; + case ATOMIC_TYPE_SHORT: return "short"; + case ATOMIC_TYPE_USHORT: return "unsigned short"; + case ATOMIC_TYPE_INT: return "int"; + case ATOMIC_TYPE_UINT: return "unsigned int"; + case ATOMIC_TYPE_LONG: return "int"; + case ATOMIC_TYPE_ULONG: return "unsigned int"; + case ATOMIC_TYPE_LONGLONG: return "long"; + case ATOMIC_TYPE_ULONGLONG: return "unsigned long"; + case ATOMIC_TYPE_FLOAT: return "float"; + case ATOMIC_TYPE_DOUBLE: return "double"; case ATOMIC_TYPE_LONG_DOUBLE: return "double"; - case ATOMIC_TYPE_BOOL: return "bool"; - default: panic("unsupported atomic type"); + case ATOMIC_TYPE_BOOL: return "bool"; + default: panic("unsupported atomic type"); } } static void write_atomic_type(const atomic_type_t *type) { - fprintf(out, "%s", get_atomic_type_string(type->atype)); + fprintf(out, "%s", get_atomic_type_string(type->akind)); } static void write_pointer_type(const pointer_type_t *type) @@ -51,7 +71,7 @@ static void write_pointer_type(const pointer_type_t *type) static declaration_t *find_typedef(const type_t *type) { /* first: search for a matching typedef in the global type... */ - declaration_t *declaration = global_context->declarations; + declaration_t *declaration = global_scope->declarations; while(declaration != NULL) { if(! (declaration->storage_class == STORAGE_CLASS_TYPEDEF)) { declaration = declaration->next; @@ -131,32 +151,34 @@ static void write_function_type(const function_type_t *type) } fprintf(out, ") : "); - write_type(type->result_type); + write_type(type->return_type); fprintf(out, ")"); } static void write_type(const type_t *type) { - switch(type->type) { + switch(type->kind) { case TYPE_ATOMIC: - write_atomic_type((const atomic_type_t*) type); + write_atomic_type(&type->atomic); return; case TYPE_POINTER: - write_pointer_type((const pointer_type_t*) type); + write_pointer_type(&type->pointer); return; case TYPE_COMPOUND_UNION: case TYPE_COMPOUND_STRUCT: - write_compound_type((const compound_type_t*) type); + write_compound_type(&type->compound); return; case TYPE_ENUM: - write_enum_type((const enum_type_t*) type); + write_enum_type(&type->enumt); return; case TYPE_FUNCTION: - write_function_type((const function_type_t*) type); + write_function_type(&type->function); return; case TYPE_INVALID: panic("invalid type found"); break; + case TYPE_COMPLEX: + case TYPE_IMAGINARY: default: fprintf(out, "/* TODO type */"); break; @@ -174,7 +196,7 @@ static void write_struct(const symbol_t *symbol, const compound_type_t *type) { fprintf(out, "struct %s:\n", symbol->string); - const declaration_t *declaration = type->declaration->context.declarations; + const declaration_t *declaration = type->declaration->scope.declarations; while(declaration != NULL) { write_struct_entry(declaration); declaration = declaration->next; @@ -187,7 +209,7 @@ static void write_union(const symbol_t *symbol, const compound_type_t *type) { fprintf(out, "union %s:\n", symbol->string); - const declaration_t *declaration = type->declaration->context.declarations; + const declaration_t *declaration = type->declaration->scope.declarations; while(declaration != NULL) { write_struct_entry(declaration); declaration = declaration->next; @@ -200,11 +222,11 @@ static void write_expression(const expression_t *expression); static void write_unary_expression(const unary_expression_t *expression) { - switch(expression->type) { - case UNEXPR_NEGATE: + switch(expression->base.kind) { + case EXPR_UNARY_NEGATE: fputc('-', out); break; - case UNEXPR_NOT: + case EXPR_UNARY_NOT: fputc('!', out); break; default: @@ -215,18 +237,18 @@ static void write_unary_expression(const unary_expression_t *expression) static void write_expression(const expression_t *expression) { - const const_t *constant; + const const_expression_t *constant; /* TODO */ - switch(expression->type) { + switch(expression->kind) { case EXPR_CONST: - constant = (const const_t*) expression; - if(is_type_integer(expression->datatype)) { - fprintf(out, "%d", constant->v.int_value); + constant = &expression->conste; + if(is_type_integer(expression->base.type)) { + fprintf(out, "%lld", constant->v.int_value); } else { fprintf(out, "%Lf", constant->v.float_value); } break; - case EXPR_UNARY: + EXPR_UNARY_CASES write_unary_expression((const unary_expression_t*) expression); break; default: @@ -234,15 +256,6 @@ static void write_expression(const expression_t *expression) } } -static void write_initializer(const initializer_t *initializer) -{ - if(initializer->type != INITIALIZER_VALUE) { - panic("list initializers not supported yet"); - } - - //write_expression(initializer->v.value); -} - static void write_enum(const symbol_t *symbol, const enum_type_t *type) { fprintf(out, "enum %s:\n", symbol->string); @@ -253,7 +266,7 @@ static void write_enum(const symbol_t *symbol, const enum_type_t *type) fprintf(out, "\t%s", entry->symbol->string); if(entry->init.initializer != NULL) { fprintf(out, " <- "); - write_initializer(entry->init.initializer); + write_expression(entry->init.enum_value); } fputc('\n', out); } @@ -282,7 +295,7 @@ static void write_function(const declaration_t *declaration) const function_type_t *function_type = (const function_type_t*) declaration->type; - declaration_t *parameter = declaration->context.declarations; + declaration_t *parameter = declaration->scope.declarations; int first = 1; for( ; parameter != NULL; parameter = parameter->next) { if(!first) { @@ -307,73 +320,69 @@ static void write_function(const declaration_t *declaration) } fprintf(out, ")"); - const type_t *result_type = function_type->result_type; - if(result_type->type != TYPE_ATOMIC || - ((const atomic_type_t*) result_type)->atype != ATOMIC_TYPE_VOID) { + const type_t *return_type = function_type->return_type; + if(!is_type_atomic(return_type, ATOMIC_TYPE_VOID)) { fprintf(out, " : "); - write_type(result_type); + write_type(return_type); } fputc('\n', out); } -void write_fluffy_decls(const translation_unit_t *unit) +void write_fluffy_decls(FILE *output, const translation_unit_t *unit) { -#if 0 - out = fopen("out.fluffy", "w"); - if(out == NULL) { - fprintf(stderr, "Couldn't open out.fluffy: %s\n", strerror(errno)); - exit(1); - } -#endif - out = stdout; - global_context = &unit->context; + out = output; + global_scope = &unit->scope; + ast_set_output(out); + type_set_output(out); fprintf(out, "/* WARNING: Automatically generated file */\n"); /* write structs,unions + enums */ - declaration_t *declaration = unit->context.declarations; + declaration_t *declaration = unit->scope.declarations; for( ; declaration != NULL; declaration = declaration->next) { //fprintf(out, "// Decl: %s\n", declaration->symbol->string); if(! (declaration->storage_class == STORAGE_CLASS_TYPEDEF)) { continue; } type_t *type = declaration->type; - if(type->type == TYPE_COMPOUND_STRUCT) { - write_struct(declaration->symbol, (compound_type_t*) type); - } else if(type->type == TYPE_COMPOUND_UNION) { - write_union(declaration->symbol, (compound_type_t*) type); - } else if(type->type == TYPE_ENUM) { - write_enum(declaration->symbol, (enum_type_t*) type); + if(type->kind == TYPE_COMPOUND_STRUCT) { + write_struct(declaration->symbol, &type->compound); + } else if(type->kind == TYPE_COMPOUND_UNION) { + write_union(declaration->symbol, &type->compound); + } else if(type->kind == TYPE_ENUM) { + write_enum(declaration->symbol, &type->enumt); } } /* write global variables */ - declaration = unit->context.declarations; + declaration = unit->scope.declarations; for( ; declaration != NULL; declaration = declaration->next) { + if(declaration->namespc != NAMESPACE_NORMAL) + continue; if(declaration->storage_class == STORAGE_CLASS_TYPEDEF || declaration->storage_class == STORAGE_CLASS_ENUM_ENTRY) continue; type_t *type = declaration->type; - if(type->type == TYPE_FUNCTION) + if(type->kind == TYPE_FUNCTION) continue; write_variable(declaration); } /* write functions */ - declaration = unit->context.declarations; + declaration = unit->scope.declarations; for( ; declaration != NULL; declaration = declaration->next) { + if(declaration->namespc != NAMESPACE_NORMAL) + continue; if(declaration->storage_class == STORAGE_CLASS_TYPEDEF || declaration->storage_class == STORAGE_CLASS_ENUM_ENTRY) continue; type_t *type = declaration->type; - if(type->type != TYPE_FUNCTION) + if(type->kind != TYPE_FUNCTION) continue; write_function(declaration); } - - //fclose(out); }