- allow '-' for s and S format
[cparser] / type.c
diff --git a/type.c b/type.c
index 2a9aba5..56e0af5 100644 (file)
--- a/type.c
+++ b/type.c
@@ -313,7 +313,7 @@ static void print_function_type_pre(const function_type_t *type, bool top)
                break;
        }
 
-       /* don't emit braces if we're the toplevel type... */
+       /* don't emit parenthesis if we're the toplevel type... */
        if (!top)
                fputc('(', out);
 }
@@ -327,7 +327,9 @@ static void print_function_type_pre(const function_type_t *type, bool top)
 static void print_function_type_post(const function_type_t *type,
                                      const scope_t *scope, bool top)
 {
-       intern_print_type_post(type->return_type, false);
+       /* don't emit parenthesis if we're the toplevel type... */
+       if (!top)
+               fputc(')', out);
 
        fputc('(', out);
        bool first = true;
@@ -366,9 +368,7 @@ static void print_function_type_post(const function_type_t *type,
        }
        fputc(')', out);
 
-       /* don't emit braces if we're the toplevel type... */
-       if (!top)
-               fputc(')', out);
+       intern_print_type_post(type->return_type, false);
 }
 
 /**
@@ -435,7 +435,7 @@ static void print_array_type_post(const array_type_t *type)
 static void print_bitfield_type_post(const bitfield_type_t *type)
 {
        fputs(" : ", out);
-       print_expression(type->size);
+       print_expression(type->size_expression);
        intern_print_type_post(type->base_type, false);
 }
 
@@ -747,6 +747,8 @@ type_t *duplicate_type(const type_t *type)
  */
 type_t *get_unqualified_type(type_t *type)
 {
+       assert(!is_typeref(type));
+
        if (type->base.qualifiers == TYPE_QUALIFIER_NONE)
                return type;
 
@@ -761,9 +763,9 @@ type_t *get_unqualified_type(type_t *type)
        return result;
 }
 
-type_t *get_qualified_type(type_t *type, type_qualifiers_t const qual)
+type_t *get_qualified_type(type_t *orig_type, type_qualifiers_t const qual)
 {
-       assert(!is_typeref(type));
+       type_t *type = skip_typeref(orig_type);
 
        type_t *copy;
        if (is_type_array(type)) {
@@ -772,16 +774,18 @@ type_t *get_qualified_type(type_t *type, type_qualifiers_t const qual)
                type_t *qual_element_type = get_qualified_type(element_type, qual);
 
                if (qual_element_type == element_type)
-                       return type;
+                       return orig_type;
 
                copy                     = duplicate_type(type);
                copy->array.element_type = qual_element_type;
-       } else {
+       } else if (is_type_valid(type)) {
                if ((type->base.qualifiers & qual) == qual)
-                       return type;
+                       return orig_type;
 
                copy                   = duplicate_type(type);
                copy->base.qualifiers |= qual;
+       } else {
+               return type;
        }
 
        type = typehash_insert(copy);
@@ -929,9 +933,8 @@ bool is_type_arithmetic(const type_t *type)
  */
 bool is_type_real(const type_t *type)
 {
-       /* 6.2.5.17 */
-       return is_type_integer(type)
-               || (type->kind == TYPE_ATOMIC && is_type_float(type));
+       /* 6.2.5 (17) */
+       return is_type_integer(type) || is_type_float(type);
 }
 
 /**
@@ -1022,6 +1025,9 @@ static bool function_types_compatible(const function_type_t *func1,
        if (!types_compatible(ret1, ret2))
                return false;
 
+       if (func1->calling_convention != func2->calling_convention)
+               return false;
+
        /* can parameters be compared? */
        if (func1->unspecified_parameters || func2->unspecified_parameters)
                return true;
@@ -1029,9 +1035,6 @@ static bool function_types_compatible(const function_type_t *func1,
        if (func1->variadic != func2->variadic)
                return false;
 
-       if (func1->calling_convention != func2->calling_convention)
-               return false;
-
        /* TODO: handling of unspecified parameters not correct yet */
 
        /* all argument types must be compatible */
@@ -1084,12 +1087,15 @@ bool types_compatible(const type_t *type1, const type_t *type2)
        if (type1 == type2)
                return true;
 
+       if (!is_type_valid(type1) || !is_type_valid(type2))
+               return true;
+
        if (type1->base.qualifiers != type2->base.qualifiers)
                return false;
        if (type1->kind != type2->kind)
                return false;
 
-       switch(type1->kind) {
+       switch (type1->kind) {
        case TYPE_FUNCTION:
                return function_types_compatible(&type1->function, &type2->function);
        case TYPE_ATOMIC:
@@ -1141,8 +1147,8 @@ type_t *skip_typeref(type_t *type)
        type_qualifiers_t qualifiers = TYPE_QUALIFIER_NONE;
        type_modifiers_t  modifiers  = TYPE_MODIFIER_NONE;
 
-       while(true) {
-               switch(type->kind) {
+       while (true) {
+               switch (type->kind) {
                case TYPE_ERROR:
                        return type;
                case TYPE_TYPEDEF: {
@@ -1196,6 +1202,44 @@ type_t *skip_typeref(type_t *type)
        return type;
 }
 
+type_qualifiers_t get_type_qualifier(const type_t *type, bool skip_array_type) {
+       type_qualifiers_t qualifiers = TYPE_QUALIFIER_NONE;
+
+       while (true) {
+               switch (type->base.kind) {
+               case TYPE_ERROR:
+                       return TYPE_QUALIFIER_NONE;
+               case TYPE_TYPEDEF:
+                       qualifiers |= type->base.qualifiers;
+                       const typedef_type_t *typedef_type = &type->typedeft;
+                       if (typedef_type->resolved_type != NULL)
+                               type = typedef_type->resolved_type;
+                       else
+                               type = typedef_type->declaration->type;
+                       continue;
+               case TYPE_TYPEOF: {
+                       const typeof_type_t *typeof_type = &type->typeoft;
+                       if (typeof_type->typeof_type != NULL) {
+                               type = typeof_type->typeof_type;
+                       } else {
+                               type = typeof_type->expression->base.type;
+                       }
+                       continue;
+               }
+               case TYPE_ARRAY:
+                       if (skip_array_type) {
+                               type = type->array.element_type;
+                               continue;
+                       }
+                       break;
+               default:
+                       break;
+               }
+               break;
+       }
+       return type->base.qualifiers | qualifiers;
+}
+
 unsigned get_atomic_type_size(atomic_type_kind_t kind)
 {
        assert(kind <= ATOMIC_TYPE_LAST);
@@ -1313,8 +1357,9 @@ type_t *make_atomic_type(atomic_type_kind_t akind, type_qualifiers_t qualifiers)
        memset(type, 0, sizeof(atomic_type_t));
 
        type->kind            = TYPE_ATOMIC;
-       type->base.qualifiers = qualifiers;
+       type->base.size       = get_atomic_type_size(akind);
        type->base.alignment  = get_atomic_type_alignment(akind);
+       type->base.qualifiers = qualifiers;
        type->atomic.akind    = akind;
 
        return identify_new_type(type);