type: Add missing space for printing complex types.

[cparser] / type_t.h

diff --git a/type_t.h b/type_t.h
index 05af673..b0c21ac 100644 (file)
--- a/type_t.h
+++ b/type_t.h
@@ -55,21 +55,14 @@ struct type_base_t {
        ir_type          *firm_type;
 };
 
+/**
+ * used for atomic types, complex and imaginary
+ */
 struct atomic_type_t {
        type_base_t         base;
        atomic_type_kind_t  akind;
 };
 
-struct complex_type_t {
-       type_base_t         base;
-       atomic_type_kind_t  akind;
-};
-
-struct imaginary_type_t {
-       type_base_t         base;
-       atomic_type_kind_t  akind;
-};
-
 struct pointer_type_t {
        type_base_t  base;
        type_t      *points_to;
@@ -106,8 +99,7 @@ struct function_parameter_t {
 
 /** Linkage specifications. */
 typedef enum linkage_kind_t {
-       LINKAGE_INVALID,
-       LINKAGE_C,       /**< C linkage. */
+       LINKAGE_C = 1,   /**< C linkage. */
        LINKAGE_CXX      /**< C++ linkage. */
 } linkage_kind_t;
 
@@ -144,8 +136,7 @@ struct compound_type_t {
 };
 
 struct enum_type_t {
-       type_base_t         base;
-       atomic_type_kind_t  akind; /**< underlying atomic type */
+       atomic_type_t       base;
        /** the enum entity. You can find the enum entries by walking the
         *  enum->base.next list until you don't find ENTITY_ENUM_VALUE entities
         *  anymore */
@@ -169,8 +160,6 @@ union type_t {
        type_kind_t      kind;
        type_base_t      base;
        atomic_type_t    atomic;
-       complex_type_t   complex;
-       imaginary_type_t imaginary;
        pointer_type_t   pointer;
        reference_type_t reference;
        array_type_t     array;
@@ -192,6 +181,7 @@ struct atomic_type_properties_t {
         */
        unsigned   struct_alignment;
        unsigned   flags;             /**< type flags from atomic_type_flag_t */
+       unsigned   rank;              /**< integer conversion rank */
 };
 
 extern atomic_type_properties_t atomic_type_properties[ATOMIC_TYPE_LAST+1];
@@ -211,7 +201,16 @@ type_t *make_array_type(type_t *element_type, size_t size,
                         type_qualifiers_t qualifiers);
 function_parameter_t *allocate_parameter(type_t*);
 
+/**
+ * Duplicates a type.
+ *
+ * @param type  The type to copy.
+ * @return A copy of the type.
+ *
+ * @note This does not produce a deep copy!
+ */
 type_t *duplicate_type(const type_t *type);
+
 type_t *identify_new_type(type_t *type);
 
 static inline bool is_typeref(const type_t *type)
@@ -230,6 +229,11 @@ static inline bool is_type_atomic(const type_t *type, atomic_type_kind_t atype)
        return atomic_type->akind == atype;
 }
 
+static inline bool is_type_void(type_t const *const type)
+{
+       return is_type_atomic(type, ATOMIC_TYPE_VOID);
+}
+
 static inline bool is_type_pointer(const type_t *type)
 {
        assert(!is_typeref(type));
@@ -279,6 +283,14 @@ static inline bool is_type_valid(const type_t *type)
        return type->kind != TYPE_ERROR;
 }
 
+/**
+ * return integer conversion rank of an atomic type kind
+ */
+static inline unsigned get_akind_rank(atomic_type_kind_t akind)
+{
+       return atomic_type_properties[akind].rank;
+}
+
 /**
  * Allocate a type node of given kind and initialize all
  * fields with zero.
@@ -293,7 +305,8 @@ type_t *allocate_type_zero(type_kind_t kind);
  *
  * @param return_type    the return type
  */
-type_t *make_function_0_type(type_t *return_type);
+type_t *make_function_0_type(type_t *return_type,
+                             decl_modifiers_t modifiers);
 
 /**
  * Creates a return_type (func)(argument_type) function type if not
@@ -302,7 +315,8 @@ type_t *make_function_0_type(type_t *return_type);
  * @param return_type    the return type
  * @param argument_type  the argument type
  */
-type_t *make_function_1_type(type_t *return_type, type_t *argument_type1);
+type_t *make_function_1_type(type_t *return_type, type_t *argument_type1,
+                             decl_modifiers_t modifiers);
 
 
 /**
@@ -310,7 +324,8 @@ type_t *make_function_1_type(type_t *return_type, type_t *argument_type1);
  * if not already exists.
  */
 type_t *make_function_2_type(type_t *return_type, type_t *argument_type1,
-                             type_t *argument_type2);
+                             type_t *argument_type2,
+                             decl_modifiers_t modifiers);
 
 /**
  * Creates a return_type (func)(argument_type, ...) function type if not
@@ -319,7 +334,9 @@ type_t *make_function_2_type(type_t *return_type, type_t *argument_type1,
  * @param return_type    the return type
  * @param argument_type  the argument type
  */
-type_t *make_function_1_type_variadic(type_t *return_type, type_t *argument_type);
+type_t *make_function_1_type_variadic(type_t *return_type,
+                                      type_t *argument_type,
+                                      decl_modifiers_t modifiers);
 
 /**
  * Create a function type with n parameters