more work on local variable support

[cparser] / write_fluffy.c

diff --git a/write_fluffy.c b/write_fluffy.c
index c33b546..e8ccbd7 100644 (file)
--- a/write_fluffy.c
+++ b/write_fluffy.c
@@ -3,6 +3,7 @@
 #include <errno.h>
 #include <string.h>
 
+#include "write_fluffy.h"
 #include "ast_t.h"
 #include "type_t.h"
 #include "type.h"
@@ -73,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... */
@@ -91,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, ", ");
@@ -148,8 +151,8 @@ static void write_type(const type_t *type)
        case TYPE_ENUM:
                write_enum_type((const enum_type_t*) type);
                return;
-       case TYPE_METHOD:
-               write_method_type((const method_type_t*) type);
+       case TYPE_FUNCTION:
+               write_function_type((const function_type_t*) type);
                return;
        case TYPE_INVALID:
                panic("invalid type found");
@@ -171,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;
@@ -184,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;
@@ -244,12 +247,13 @@ static void write_enum(const symbol_t *symbol, const enum_type_t *type)
 {
        fprintf(out, "enum %s:\n", symbol->string);
 
-       declaration_t *entry = type->entries_begin;
-       for ( ; entry != type->entries_end->next; 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->initializer != NULL) {
+               if(entry->init.initializer != NULL) {
                        fprintf(out, " <- ");
-                       write_initializer(entry->initializer);
+                       write_initializer(entry->init.initializer);
                }
                fputc('\n', out);
        }
@@ -267,7 +271,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);
        }
@@ -275,7 +279,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;
@@ -292,7 +297,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 {
@@ -302,7 +307,7 @@ static void write_function(const declaration_t *declaration)
        }
        fprintf(out, ")");
 
-       const type_t        *result_type = method_type->result_type;
+       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) {
                fprintf(out, " : ");
@@ -350,7 +355,7 @@ void write_fluffy_decls(const translation_unit_t *unit)
                        continue;
 
                type_t *type = declaration->type;
-               if(type->type == TYPE_METHOD)
+               if(type->type == TYPE_FUNCTION)
                        continue;
 
                write_variable(declaration);
@@ -364,7 +369,7 @@ void write_fluffy_decls(const translation_unit_t *unit)
                        continue;
 
                type_t *type = declaration->type;
-               if(type->type != TYPE_METHOD)
+               if(type->type != TYPE_FUNCTION)
                        continue;
 
                write_function(declaration);