X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=mangle.c;h=1eb6a16b30410a426d861e453ee8bcd7cdcad53e;hb=56f27575224c2d16125892f55be2b2d49c12b37a;hp=a79d4e1d3c6853ce92fa70c672a5807e70af941a;hpb=8bd23e0c2c6bff177fa4a597a746eaf587f729e2;p=cparser

diff --git a/mangle.c b/mangle.c
index a79d4e1..1eb6a16 100644
--- a/mangle.c
+++ b/mangle.c
@@ -40,6 +40,7 @@ static char get_atomic_type_mangle(atomic_type_kind_t kind)
 	switch (kind) {
 	case ATOMIC_TYPE_INVALID: break;
 	case ATOMIC_TYPE_VOID:        return 'v';
+	case ATOMIC_TYPE_WCHAR_T:     return 'w';
 	case ATOMIC_TYPE_BOOL:        return 'b';
 	case ATOMIC_TYPE_CHAR:        return 'c';
 	case ATOMIC_TYPE_SCHAR:       return 'a';
@@ -70,6 +71,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,44 +110,64 @@ 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, "%zu%s", 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)
 {
 	if (type->is_vla) {
-		obstack_printf(&obst, "A_");
+		obstack_1grow(&obst, 'A');
+		obstack_1grow(&obst, '_');
 	} else if (type->size_constant) {
-		obstack_printf(&obst, "A%zu_", type->size);
+		obstack_printf(&obst, "A%u_", (unsigned) type->size);
 	} else {
-		panic("mangling of non-constant sized arrray types not implemented yet");
+		panic("mangling of non-constant sized array types not implemented yet");
 	}
 	mangle_type(type->element_type);
 }
 
 static void mangle_complex_type(const complex_type_t *type)
 {
-	obstack_printf(&obst, "C%c", get_atomic_type_mangle(type->akind));
+	obstack_1grow(&obst, 'C');
+	obstack_1grow(&obst, 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));
+	obstack_1grow(&obst, 'G');
+	obstack_1grow(&obst, get_atomic_type_mangle(type->akind));
 }
 
 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)
@@ -162,15 +189,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);
@@ -204,8 +234,7 @@ static void mangle_entity(entity_t *entity)
 
 	/* TODO: mangle scope */
 
-	const char *name = entity->base.symbol->string;
-	obstack_printf(&obst, "%zu%s", strlen(name), name);
+	print_name(entity->base.symbol->string);
 
 	if (entity->kind == ENTITY_FUNCTION) {
 		mangle_parameters(&entity->declaration.type->function);
@@ -252,7 +281,7 @@ ident *create_name_win32(entity_t *entity)
 
 		switch (entity->declaration.type->function.linkage) {
 			case LINKAGE_INVALID:
-				break;
+				panic("linkage type of function is invalid");
 
 			case LINKAGE_C:
 				obstack_printf(o, "%s", entity->base.symbol->string);
@@ -271,12 +300,12 @@ ident *create_name_win32(entity_t *entity)
 
 			case CC_STDCALL:
 			case CC_FASTCALL: {
-				ir_type *irtype = get_ir_type(entity->declaration.type);
-				size_t   size   = 0;
+				ir_type  *irtype = get_ir_type(entity->declaration.type);
+				unsigned size    = 0;
 				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", size);
+				obstack_printf(o, "@%u", size);
 				break;
 			}
 
@@ -302,7 +331,9 @@ ident *create_name_linux_elf(entity_t *entity)
 
 	if (entity->kind == ENTITY_FUNCTION) {
 		switch (entity->declaration.type->function.linkage) {
-			case LINKAGE_INVALID: break;
+			case LINKAGE_INVALID:
+				panic("linkage type of function is invalid");
+
 			case LINKAGE_C:       break;
 			case LINKAGE_CXX:     needs_mangling = true; break;
 		}
@@ -324,6 +355,9 @@ ident *create_name_linux_elf(entity_t *entity)
  */
 ident *create_name_macho(entity_t *entity)
 {
+	if (entity->kind == ENTITY_FUNCTION && entity->declaration.type->function.linkage == LINKAGE_INVALID)
+		panic("linkage type of function is invalid");
+
 	obstack_printf(&obst, "_%s", entity->base.symbol->string);
 	return make_id_from_obst();
 }