Implement mangling of complex and imaginary types.

[cparser] / mangle.c

diff --git a/mangle.c b/mangle.c
index 42a5745..a79d4e1 100644 (file)
--- a/mangle.c
+++ b/mangle.c
@@ -70,6 +70,26 @@ static void mangle_pointer_type(const pointer_type_t *type)
        mangle_type(type->points_to);
 }
 
+static void mangle_parameters(const function_type_t *type)
+{
+       if (type->unspecified_parameters)
+               panic("can't mangle unspecified parameter types");
+       if (type->kr_style_parameters)
+               panic("can't mangle kr_style_parameters type");
+
+       const function_parameter_t *parameter = type->parameters;
+       if (parameter != NULL) {
+               for ( ; parameter != NULL; parameter = parameter->next) {
+                       mangle_type(parameter->type);
+               }
+               if (type->variadic) {
+                       obstack_1grow(&obst, 'z');
+               }
+       } else {
+               obstack_1grow(&obst, 'v');
+       }
+}
+
 static void mangle_function_type(const function_type_t *type)
 {
        obstack_1grow(&obst, 'F');
@@ -78,30 +98,53 @@ static void mangle_function_type(const function_type_t *type)
        }
 
        mangle_type(type->return_type);
+       mangle_parameters(type);
+
+       obstack_1grow(&obst, 'E');
+}
 
-       function_parameter_t *parameter = type->parameters;
-       for ( ; parameter != NULL; parameter = parameter->next) {
-               mangle_type(parameter->type);
+static void mangle_class_enum_type(const entity_base_t *ent)
+{
+       const symbol_t *sym = ent->symbol;
+       if (sym != NULL) {
+               const char *name = sym->string;
+               obstack_printf(&obst, "%zu%s", strlen(name), name);
+       } else {
+               /* TODO need the first typedef name here */
+               panic("mangling of unnamed class/enum types not implemented yet");
        }
-       if (type->variadic) {
-               obstack_1grow(&obst, 'z');
+}
+
+static void mangle_array_type(const array_type_t *type)
+{
+       if (type->is_vla) {
+               obstack_printf(&obst, "A_");
+       } else if (type->size_constant) {
+               obstack_printf(&obst, "A%zu_", type->size);
+       } else {
+               panic("mangling of non-constant sized arrray types not implemented yet");
        }
-       if (type->unspecified_parameters)
-               panic("can't mangle unspecified parameter types");
-       if (type->kr_style_parameters)
-               panic("can't mangle kr_style_parameters type");
+       mangle_type(type->element_type);
+}
 
-       obstack_1grow(&obst, 'E');
+static void mangle_complex_type(const complex_type_t *type)
+{
+       obstack_printf(&obst, "C%c", get_atomic_type_mangle(type->akind));
+}
+
+static void mangle_imaginary_type(const imaginary_type_t *type)
+{
+       obstack_printf(&obst, "G%c", get_atomic_type_mangle(type->akind));
 }
 
 static void mangle_qualifiers(type_qualifiers_t qualifiers)
 {
-       if (qualifiers & TYPE_QUALIFIER_CONST)
-               obstack_1grow(&obst, 'K');
-       if (qualifiers & TYPE_QUALIFIER_VOLATILE)
-               obstack_1grow(&obst, 'V');
        if (qualifiers & TYPE_QUALIFIER_RESTRICT)
                obstack_1grow(&obst, 'r');
+       if (qualifiers & TYPE_QUALIFIER_VOLATILE)
+               obstack_1grow(&obst, 'V');
+       if (qualifiers & TYPE_QUALIFIER_CONST)
+               obstack_1grow(&obst, 'K');
 
        /* handle MS extended qualifiers? */
 }
@@ -122,6 +165,22 @@ static void mangle_type(type_t *orig_type)
        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);
+               return;
+       case TYPE_ENUM:
+               mangle_class_enum_type(&type->enumt.enume->base);
+               return;
+       case TYPE_ARRAY:
+               mangle_array_type(&type->array);
+               return;
+       case TYPE_COMPLEX:
+               mangle_complex_type(&type->complex);
+               return;
+       case TYPE_IMAGINARY:
+               mangle_imaginary_type(&type->imaginary);
+               return;
        case TYPE_INVALID:
                panic("invalid type encountered while mangling");
        case TYPE_ERROR:
@@ -132,12 +191,6 @@ static void mangle_type(type_t *orig_type)
                panic("typeref not resolved while manging?!?");
 
        case TYPE_BITFIELD:
-       case TYPE_COMPLEX:
-       case TYPE_IMAGINARY:
-       case TYPE_COMPOUND_STRUCT:
-       case TYPE_COMPOUND_UNION:
-       case TYPE_ENUM:
-       case TYPE_ARRAY:
                panic("no mangling for this type implemented yet");
                break;
        }
@@ -151,11 +204,11 @@ static void mangle_entity(entity_t *entity)
 
        /* TODO: mangle scope */
 
-       symbol_t *symbol = entity->base.symbol;
-       obstack_printf(&obst, "%u%s", strlen(symbol->string), symbol->string);
+       const char *name = entity->base.symbol->string;
+       obstack_printf(&obst, "%zu%s", strlen(name), name);
 
        if (entity->kind == ENTITY_FUNCTION) {
-               mangle_type(entity->declaration.type);
+               mangle_parameters(&entity->declaration.type->function);
        }
 }
 
@@ -223,7 +276,7 @@ ident *create_name_win32(entity_t *entity)
                                for (int i = get_method_n_params(irtype) - 1; i >= 0; --i) {
                                        size += get_type_size_bytes(get_method_param_type(irtype, i));
                                }
-                               obstack_printf(o, "@%zu\n", size);
+                               obstack_printf(o, "@%zu", size);
                                break;
                        }