X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=type_t.h;h=a793f7aaf27ba388c8ff553cd030842e0ed55b83;hb=0ebbd3e65a57231db1c7346190cb4f04ea52b628;hp=0773f70feb894902fef8bb26c00b7fbc88bf322a;hpb=02f47f268839c472e23095ac0025e5ccbb5ed70a;p=cparser diff --git a/type_t.h b/type_t.h index 0773f70..a793f7a 100644 --- a/type_t.h +++ b/type_t.h @@ -1,6 +1,6 @@ /* * This file is part of cparser. - * Copyright (C) 2007-2008 Matthias Braun + * Copyright (C) 2007-2009 Matthias Braun * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License @@ -44,6 +44,7 @@ typedef enum type_kind_t { TYPE_ENUM, TYPE_FUNCTION, TYPE_POINTER, + TYPE_REFERENCE, TYPE_ARRAY, TYPE_BITFIELD, TYPE_BUILTIN, @@ -51,19 +52,11 @@ typedef enum type_kind_t { TYPE_TYPEOF, } type_kind_t; -typedef enum type_modifier_t { - TYPE_MODIFIER_NONE = 0, - TYPE_MODIFIER_TRANSPARENT_UNION = 1 << 0, -} type_modifier_t; -typedef unsigned short type_modifiers_t; - struct type_base_t { type_kind_t kind; - il_size_t size; /**< The size of this type. */ type_qualifiers_t qualifiers; - type_modifiers_t modifiers; - il_alignment_t alignment; /**< The extra alignment of the type, 0 for default. */ + /* cached ast2firm infos */ ir_type *firm_type; }; @@ -91,6 +84,12 @@ struct builtin_type_t { struct pointer_type_t { type_base_t base; type_t *points_to; + variable_t *base_variable; /**< Microsoft __based() extension: base variable or NULL. */ +}; + +struct reference_type_t { + type_base_t base; + type_t *refers_to; }; struct array_type_t { @@ -113,9 +112,16 @@ struct array_type_t { */ struct function_parameter_t { type_t *type; /**< The parameter type. */ - function_parameter_t *next; /**< Points to the next type inthe parameter list.*/ + function_parameter_t *next; /**< Points to the next type in the parameter list.*/ }; +/** Linkage specifications. */ +typedef enum linkage_kind_t { + LINKAGE_INVALID, + LINKAGE_C, /**< C linkage. */ + LINKAGE_CXX /**< C++ linkage. */ +} linkage_kind_t; + /** Calling conventions. */ typedef enum cc_kind_t { CC_DEFAULT, /**< default calling convention. */ @@ -132,26 +138,29 @@ struct function_type_t { type_base_t base; type_t *return_type; /**< The return type. */ function_parameter_t *parameters; /**< A list of the parameter types. */ - symbol_t *linkage; + linkage_kind_t linkage; + cc_kind_t calling_convention; /**< The specified calling convention. */ + decl_modifiers_t modifiers; bool variadic : 1; bool unspecified_parameters : 1; bool kr_style_parameters : 1; }; struct compound_type_t { - type_base_t base; - bool packed : 1; /**< Set if packed was specified. */ + type_base_t base; + bool packed : 1; /**< Set if packed was specified. */ /** the declaration of the compound type, the scope of the declaration * contains the compound entries. */ - compound_t *compound; + compound_t *compound; }; struct enum_type_t { - type_base_t base; + type_base_t base; + atomic_type_kind_t akind; /**< underlying atomic type */ /** 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 */ - enum_t *enume; + enum_t *enume; }; struct typedef_type_t { @@ -182,6 +191,7 @@ union type_t { imaginary_type_t imaginary; builtin_type_t builtin; pointer_type_t pointer; + reference_type_t reference; array_type_t array; function_type_t function; compound_type_t compound; @@ -191,14 +201,21 @@ union type_t { typeof_type_t typeoft; }; +/** The default calling convention for functions. */ +extern cc_kind_t default_calling_convention; + type_t *make_atomic_type(atomic_type_kind_t type, type_qualifiers_t qualifiers); type_t *make_complex_type(atomic_type_kind_t type, type_qualifiers_t qualifiers); type_t *make_imaginary_type(atomic_type_kind_t type, type_qualifiers_t qualifiers); type_t *make_pointer_type(type_t *points_to, type_qualifiers_t qualifiers); +type_t *make_reference_type(type_t *refers_to); +type_t *make_based_pointer_type(type_t *points_to, + type_qualifiers_t qualifiers, variable_t *variable); type_t *make_array_type(type_t *element_type, size_t size, type_qualifiers_t qualifiers); 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) { @@ -222,6 +239,12 @@ static inline bool is_type_pointer(const type_t *type) return type->kind == TYPE_POINTER; } +static inline bool is_type_reference(const type_t *type) +{ + assert(!is_typeref(type)); + return type->kind == TYPE_REFERENCE; +} + static inline bool is_type_array(const type_t *type) { assert(!is_typeref(type)); @@ -265,4 +288,53 @@ static inline bool is_type_valid(const type_t *type) return type->kind != TYPE_ERROR; } +/** + * Allocate a type node of given kind and initialize all + * fields with zero. + * + * @param kind type kind to allocate + */ +type_t *allocate_type_zero(type_kind_t kind); + +/** + * Creates a return_type (func)(void) function type if not + * already exists. + * + * @param return_type the return type + */ +type_t *make_function_0_type(type_t *return_type); + +/** + * Creates a return_type (func)(argument_type) function type if not + * already exists. + * + * @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); + + +/** + * Creates a return_type (func)(argument_type1,argument_type2) function type + * if not already exists. + */ +type_t *make_function_2_type(type_t *return_type, type_t *argument_type1, + type_t *argument_type2); + +/** + * Creates a return_type (func)(argument_type, ...) function type if not + * already exists. + * + * @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); + +/** + * Create a function type with n parameters + */ +type_t *make_function_type(type_t *return_type, int n_types, + type_t *const *argument_types, + decl_modifiers_t modifiers); + #endif