X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=type_t.h;h=2824b96dc66879c3616a2884e72af7b24a2a56e0;hb=7ea2ad59b0f4b39c3a18b680b13fb4011ba02a41;hp=b9365c27c0935b65ea573230a85fe593a350bcb9;hpb=8e32d3ef5acf95570f32c8f7a6c64e897170bdf6;p=cparser diff --git a/type_t.h b/type_t.h index b9365c2..2824b96 100644 --- a/type_t.h +++ b/type_t.h @@ -1,3 +1,22 @@ +/* + * This file is part of cparser. + * Copyright (C) 2007-2008 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. + */ #ifndef TYPE_T_H #define TYPE_T_H @@ -12,10 +31,11 @@ #include "ast_t.h" #include "adt/obst.h" -struct obstack *type_obst; +extern struct obstack *type_obst; typedef enum { TYPE_INVALID, + TYPE_ERROR, TYPE_ATOMIC, TYPE_COMPOUND_STRUCT, TYPE_COMPOUND_UNION, @@ -23,61 +43,39 @@ typedef enum { TYPE_FUNCTION, TYPE_POINTER, TYPE_ARRAY, + TYPE_BITFIELD, TYPE_BUILTIN, TYPE_TYPEDEF, TYPE_TYPEOF, - TYPE_COUNT -} type_type_t; - -/* note that the constant values represent the rank of the types as defined - * in § 6.3.1 */ -typedef enum { - ATOMIC_TYPE_INVALID = 0, - ATOMIC_TYPE_VOID, - ATOMIC_TYPE_CHAR, - ATOMIC_TYPE_SCHAR, - ATOMIC_TYPE_UCHAR, - ATOMIC_TYPE_SHORT, - ATOMIC_TYPE_USHORT, - ATOMIC_TYPE_INT, - ATOMIC_TYPE_UINT, - ATOMIC_TYPE_LONG, - ATOMIC_TYPE_ULONG, - ATOMIC_TYPE_LONGLONG, - ATOMIC_TYPE_ULONGLONG, - ATOMIC_TYPE_FLOAT, - ATOMIC_TYPE_DOUBLE, - ATOMIC_TYPE_LONG_DOUBLE, - ATOMIC_TYPE_BOOL, -#ifdef PROVIDE_COMPLEX - ATOMIC_TYPE_FLOAT_COMPLEX, - ATOMIC_TYPE_DOUBLE_COMPLEX, - ATOMIC_TYPE_LONG_DOUBLE_COMPLEX, - ATOMIC_TYPE_FLOAT_IMAGINARY, - ATOMIC_TYPE_DOUBLE_IMAGINARY, - ATOMIC_TYPE_LONG_DOUBLE_IMAGINARY, -#endif -} atomic_type_type_t; +} type_kind_t; typedef enum { TYPE_QUALIFIER_NONE = 0, TYPE_QUALIFIER_CONST = 1 << 0, TYPE_QUALIFIER_RESTRICT = 1 << 1, TYPE_QUALIFIER_VOLATILE = 1 << 2, + /* microsoft extended qualifiers */ + TYPE_QUALIFIER_W64 = 1 << 3, + TYPE_QUALIFIER_PTR32 = 1 << 4, + TYPE_QUALIFIER_PTR64 = 1 << 5, + TYPE_QUALIFIER_SPTR = 1 << 6, + TYPE_QUALIFIER_UPTR = 1 << 7, } type_qualifier_t; typedef unsigned int type_qualifiers_t; struct type_base_t { - type_type_t type; + type_kind_t kind; type_qualifiers_t qualifiers; + unsigned char alignment; /**< The extra alignment of the type, 0 for default. */ + source_position_t source_position; ir_type *firm_type; }; struct atomic_type_t { type_base_t type; - atomic_type_type_t atype; + atomic_type_kind_t akind; }; struct builtin_type_t { @@ -94,9 +92,16 @@ struct pointer_type_t { struct array_type_t { type_base_t type; type_t *element_type; - expression_t *size; - bool is_static; - bool is_variable; + expression_t *size_expression; + size_t size; + + ir_node *size_node; /**< used by ast2firm phase */ + + unsigned is_static : 1; /**< a [static] type */ + unsigned is_variable : 1; /**< a [*] type */ + unsigned has_implicit_size : 1; + unsigned size_constant : 1; /**< size expression is constant */ + unsigned is_vla : 1; /**< it's a variable length array */ }; struct function_parameter_t { @@ -106,15 +111,16 @@ struct function_parameter_t { struct function_type_t { type_base_t type; - type_t *result_type; + type_t *return_type; function_parameter_t *parameters; - bool variadic; - bool unspecified_parameters; + unsigned variadic : 1; + unsigned unspecified_parameters : 1; + unsigned kr_style_parameters : 1; }; struct compound_type_t { type_base_t type; - /** the declaration of the compound type, its context field + /** the declaration of the compound type, the scope of the declaration * contains the compound entries. */ declaration_t *declaration; }; @@ -140,8 +146,14 @@ struct typeof_type_t { type_t *resolved_type; }; +struct bitfield_type_t { + type_base_t type; + type_t *base; + expression_t *size; +}; + union type_t { - type_type_t type; + type_kind_t kind; type_base_t base; atomic_type_t atomic; builtin_type_t builtin; @@ -151,39 +163,79 @@ union type_t { compound_type_t compound; enum_type_t enumt; typedef_type_t typedeft; + bitfield_type_t bitfield; typeof_type_t typeoft; }; -type_t *make_atomic_type(atomic_type_type_t type, type_qualifiers_t qualifiers); +type_t *make_atomic_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_array_type(type_t *element_type, size_t size, + type_qualifiers_t qualifiers); + +type_t *duplicate_type(const type_t *type); static inline bool is_typeref(const type_t *type) { - return type->type == TYPE_TYPEDEF || type->type == TYPE_TYPEOF; + return type->kind == TYPE_TYPEDEF || type->kind == TYPE_TYPEOF; } -static inline bool is_type_atomic(const type_t *type, atomic_type_type_t atype) +static inline bool is_type_atomic(const type_t *type, atomic_type_kind_t atype) { assert(!is_typeref(type)); - if(type->type != TYPE_ATOMIC) + if(type->kind != TYPE_ATOMIC) return false; const atomic_type_t *atomic_type = &type->atomic; - return atomic_type->atype == atype; + return atomic_type->akind == atype; } static inline bool is_type_pointer(const type_t *type) { assert(!is_typeref(type)); - return type->type == TYPE_POINTER; + return type->kind == TYPE_POINTER; +} + +static inline bool is_type_array(const type_t *type) +{ + assert(!is_typeref(type)); + return type->kind == TYPE_ARRAY; +} + +static inline bool is_type_function(const type_t *type) +{ + assert(!is_typeref(type)); + return type->kind == TYPE_FUNCTION; +} + +static inline bool is_type_union(const type_t *type) +{ + assert(!is_typeref(type)); + return type->kind == TYPE_COMPOUND_UNION; +} + +static inline bool is_type_struct(const type_t *type) +{ + assert(!is_typeref(type)); + return type->kind == TYPE_COMPOUND_STRUCT; +} + +static inline bool is_type_builtin(const type_t *type) +{ + assert(!is_typeref(type)); + return type->kind == TYPE_BUILTIN; } static inline bool is_type_compound(const type_t *type) { assert(!is_typeref(type)); - return type->type == TYPE_COMPOUND_STRUCT - || type->type == TYPE_COMPOUND_UNION; + return type->kind == TYPE_COMPOUND_STRUCT + || type->kind == TYPE_COMPOUND_UNION; +} + +static inline bool is_type_valid(const type_t *type) +{ + return type->kind != TYPE_ERROR; } #endif