X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=write_fluffy.c;h=bd979c37deb385b639f0e585ad5fe875a1865e3c;hb=28767377c53b605623c2cd2339114c3c8a99597d;hp=1d6aefff22b1ec46308add27ab6ca2b4b511487f;hpb=5c350f5bc775f92a6fb5131e54b2e818574843aa;p=cparser diff --git a/write_fluffy.c b/write_fluffy.c index 1d6aeff..bd979c3 100644 --- a/write_fluffy.c +++ b/write_fluffy.c @@ -3,8 +3,10 @@ #include #include +#include "write_fluffy.h" #include "ast_t.h" #include "type_t.h" +#include "type.h" #include "adt/error.h" static const context_t *global_context; @@ -12,7 +14,7 @@ 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"; @@ -37,7 +39,7 @@ static const char *get_atomic_type_string(const atomic_type_type_t 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 +53,7 @@ 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; while(declaration != NULL) { - if(! (declaration->storage_class & STORAGE_CLASS_TYPEDEF)) { + if(! (declaration->storage_class == STORAGE_CLASS_TYPEDEF)) { declaration = declaration->next; continue; } @@ -72,9 +74,10 @@ static void write_compound_type(const compound_type_t *type) } /* does the struct have a name? */ - if(type->symbol != NULL) { + symbol_t *symbol = type->declaration->symbol; + if(symbol != NULL) { /* TODO: make sure we create a struct for it... */ - fprintf(out, "%s", type->symbol->string); + fprintf(out, "%s", symbol->string); return; } /* TODO: create a struct and use its name here... */ @@ -90,21 +93,22 @@ static void write_enum_type(const enum_type_t *type) } /* does the enum have a name? */ - if(type->symbol != NULL) { + symbol_t *symbol = type->declaration->symbol; + if(symbol != NULL) { /* TODO: make sure we create an enum for it... */ - fprintf(out, "%s", type->symbol->string); + fprintf(out, "%s", symbol->string); return; } /* TODO: create a struct and use its name here... */ fprintf(out, "/* TODO anonymous enum */byte"); } -static void write_method_type(const method_type_t *type) +static void write_function_type(const function_type_t *type) { fprintf(out, "(func("); - method_parameter_t *parameter = type->parameters; - int first = 1; + function_parameter_t *parameter = type->parameters; + int first = 1; while(parameter != NULL) { if(!first) { fprintf(out, ", "); @@ -127,28 +131,28 @@ static void write_method_type(const method_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_METHOD: - write_method_type((const method_type_t*) type); + case TYPE_FUNCTION: + write_function_type(&type->function); return; case TYPE_INVALID: panic("invalid type found"); @@ -170,7 +174,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->context.declarations; + const declaration_t *declaration = type->declaration->context.declarations; while(declaration != NULL) { write_struct_entry(declaration); declaration = declaration->next; @@ -183,7 +187,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->context.declarations; + const declaration_t *declaration = type->declaration->context.declarations; while(declaration != NULL) { write_struct_entry(declaration); declaration = declaration->next; @@ -196,11 +200,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->expression.kind) { + case EXPR_UNARY_NEGATE: fputc('-', out); break; - case UNEXPR_NOT: + case EXPR_UNARY_NOT: fputc('!', out); break; default: @@ -211,14 +215,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; - fprintf(out, "%d", constant->value); + constant = &expression->conste; + if(is_type_integer(expression->base.datatype)) { + 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: @@ -230,12 +238,13 @@ static void write_enum(const symbol_t *symbol, const enum_type_t *type) { fprintf(out, "enum %s:\n", symbol->string); - const enum_entry_t *entry = type->entries; - for ( ; entry != NULL; entry = entry->next) { + declaration_t *entry = type->declaration->next; + for ( ; entry != NULL && entry->storage_class == STORAGE_CLASS_ENUM_ENTRY; + entry = entry->next) { fprintf(out, "\t%s", entry->symbol->string); - if(entry->value != NULL) { + if(entry->init.initializer != NULL) { fprintf(out, " <- "); - write_expression(entry->value); + write_expression(entry->init.enum_value); } fputc('\n', out); } @@ -253,7 +262,7 @@ static void write_variable(const declaration_t *declaration) static void write_function(const declaration_t *declaration) { - if(declaration->statement != NULL) { + if(declaration->init.statement != NULL) { fprintf(stderr, "Warning: can't convert function bodies (at %s)\n", declaration->symbol->string); } @@ -261,7 +270,8 @@ static void write_function(const declaration_t *declaration) fprintf(out, "func extern %s(", declaration->symbol->string); - const method_type_t *method_type = (const method_type_t*) declaration->type; + const function_type_t *function_type + = (const function_type_t*) declaration->type; declaration_t *parameter = declaration->context.declarations; int first = 1; @@ -278,7 +288,7 @@ static void write_function(const declaration_t *declaration) } write_type(parameter->type); } - if(method_type->variadic) { + if(function_type->variadic) { if(!first) { fprintf(out, ", "); } else { @@ -288,57 +298,50 @@ static void write_function(const declaration_t *declaration) } fprintf(out, ")"); - const type_t *result_type = method_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; + out = output; global_context = &unit->context; + ast_set_output(out); fprintf(out, "/* WARNING: Automatically generated file */\n"); /* write structs,unions + enums */ declaration_t *declaration = unit->context.declarations; - while(declaration != NULL) { + for( ; declaration != NULL; declaration = declaration->next) { //fprintf(out, "// Decl: %s\n", declaration->symbol->string); - if(! (declaration->storage_class & STORAGE_CLASS_TYPEDEF)) { - declaration = declaration->next; + 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); } - - declaration = declaration->next; } /* write global variables */ declaration = unit->context.declarations; for( ; declaration != NULL; declaration = declaration->next) { - if(declaration->storage_class & STORAGE_CLASS_TYPEDEF) + 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_METHOD) + if(type->kind == TYPE_FUNCTION) continue; write_variable(declaration); @@ -347,15 +350,16 @@ void write_fluffy_decls(const translation_unit_t *unit) /* write functions */ declaration = unit->context.declarations; for( ; declaration != NULL; declaration = declaration->next) { - if(declaration->storage_class & STORAGE_CLASS_TYPEDEF) + 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_METHOD) + if(type->kind != TYPE_FUNCTION) continue; write_function(declaration); } - - //fclose(out); }