X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;ds=sidebyside;f=type_t.h;h=262fb631d2d1f84c908f8ee5040fa3857063ce7f;hb=7473d9545525216a1276296dbc1759e07972cf96;hp=1d3ab4c047eb0936f1615015d3101fd7466811b7;hpb=58558497dcf35ed589188c87600576b58d7c237d;p=cparser diff --git a/type_t.h b/type_t.h index 1d3ab4c..262fb63 100644 --- a/type_t.h +++ b/type_t.h @@ -1,21 +1,6 @@ /* * This file is part of cparser. - * 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 - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA - * 02111-1307, USA. + * Copyright (C) 2012 Matthias Braun */ #ifndef TYPE_T_H #define TYPE_T_H @@ -25,15 +10,11 @@ #include +#include "ast.h" #include "type.h" -#include "symbol.h" -#include "token_t.h" -#include "ast_t.h" -#include "adt/obst.h" typedef enum type_kind_t { - TYPE_INVALID, - TYPE_ERROR, + TYPE_ERROR = 1, TYPE_ATOMIC, TYPE_COMPLEX, TYPE_IMAGINARY, @@ -56,21 +37,14 @@ struct type_base_t { ir_type *firm_type; }; +/** + * used for atomic types, complex and imaginary and as base for enum + */ 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; @@ -107,8 +81,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; @@ -145,8 +118,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 */ @@ -170,8 +142,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; @@ -193,6 +163,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]; @@ -212,7 +183,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) @@ -224,13 +204,18 @@ static inline bool is_type_atomic(const type_t *type, atomic_type_kind_t atype) { assert(!is_typeref(type)); - if(type->kind != TYPE_ATOMIC) + if (type->kind != TYPE_ATOMIC) return false; const atomic_type_t *atomic_type = &type->atomic; 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)); @@ -280,6 +265,27 @@ 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; +} + +static inline bool is_akind_signed(atomic_type_kind_t akind) +{ + return atomic_type_properties[akind].flags & ATOMIC_TYPE_FLAG_SIGNED; +} + +static inline atomic_type_kind_t get_arithmetic_akind(const type_t *type) +{ + assert(type->kind == TYPE_ATOMIC || type->kind == TYPE_COMPLEX + || type->kind == TYPE_IMAGINARY || type->kind == TYPE_ENUM); + /* note that atomic, complex and enum share atomic_type_t base */ + return type->atomic.akind; +} + /** * Allocate a type node of given kind and initialize all * fields with zero. @@ -294,7 +300,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 @@ -303,7 +310,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); /** @@ -311,7 +319,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 @@ -320,7 +329,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