fix one more problematic omitted conditional case

[cparser] / mangle.c

diff --git a/mangle.c b/mangle.c
index e4f1092..f9ebe76 100644 (file)
--- a/mangle.c
+++ b/mangle.c
@@ -70,6 +70,12 @@ static void mangle_pointer_type(const pointer_type_t *type)
        mangle_type(type->points_to);
 }
 
+static void mangle_reference_type(const reference_type_t *type)
+{
+       obstack_1grow(&obst, 'R');
+       mangle_type(type->refers_to);
+}
+
 static void mangle_parameters(const function_type_t *type)
 {
        if (type->unspecified_parameters)
@@ -103,16 +109,31 @@ static void mangle_function_type(const function_type_t *type)
        obstack_1grow(&obst, 'E');
 }
 
-static void mangle_class_enum_type(const entity_base_t *ent)
+static void print_name(const char* name)
 {
-       const symbol_t *sym = ent->symbol;
-       if (sym != NULL) {
-               const char *name = sym->string;
-               obstack_printf(&obst, "%u%s", (unsigned) strlen(name), name);
-       } else {
-               /* TODO need the first typedef name here */
-               panic("mangling of unnamed class/enum types not implemented yet");
+       obstack_printf(&obst, "%u%s", (unsigned)strlen(name), name);
+}
+
+static void mangle_class_type(const compound_type_t *type)
+{
+       const symbol_t *sym = type->compound->base.symbol;
+       if (sym == NULL) {
+               if (type->compound->alias == NULL)
+                       panic("mangling anonymous type");
+               sym = type->compound->alias->base.symbol;
+       }
+       print_name(sym->string);
+}
+
+static void mangle_enum_type(const enum_type_t *type)
+{
+       const symbol_t *sym = type->enume->base.symbol;
+       if (sym == NULL) {
+               if (type->enume->alias == NULL)
+                       panic("mangling anonymous type");
+               sym = type->enume->alias->base.symbol;
        }
+       print_name(sym->string);
 }
 
 static void mangle_array_type(const array_type_t *type)
@@ -142,8 +163,10 @@ static void mangle_imaginary_type(const imaginary_type_t *type)
 
 static void mangle_qualifiers(type_qualifiers_t qualifiers)
 {
+#if 0 /* Do not mangle restrict qualifiers.  GCC doesn't either */
        if (qualifiers & TYPE_QUALIFIER_RESTRICT)
                obstack_1grow(&obst, 'r');
+#endif
        if (qualifiers & TYPE_QUALIFIER_VOLATILE)
                obstack_1grow(&obst, 'V');
        if (qualifiers & TYPE_QUALIFIER_CONST)
@@ -165,15 +188,18 @@ static void mangle_type(type_t *orig_type)
        case TYPE_POINTER:
                mangle_pointer_type(&type->pointer);
                return;
+       case TYPE_REFERENCE:
+               mangle_reference_type(&type->reference);
+               return;
        case TYPE_FUNCTION:
                mangle_function_type(&type->function);
                return;
        case TYPE_COMPOUND_STRUCT:
        case TYPE_COMPOUND_UNION:
-               mangle_class_enum_type(&type->compound.compound->base);
+               mangle_class_type(&type->compound);
                return;
        case TYPE_ENUM:
-               mangle_class_enum_type(&type->enumt.enume->base);
+               mangle_enum_type(&type->enumt);
                return;
        case TYPE_ARRAY:
                mangle_array_type(&type->array);
@@ -207,8 +233,7 @@ static void mangle_entity(entity_t *entity)
 
        /* TODO: mangle scope */
 
-       const char *name = entity->base.symbol->string;
-       obstack_printf(&obst, "%u%s", (unsigned) strlen(name), name);
+       print_name(entity->base.symbol->string);
 
        if (entity->kind == ENTITY_FUNCTION) {
                mangle_parameters(&entity->declaration.type->function);