rewrite of attribute handling
[cparser] / ast_t.h
diff --git a/ast_t.h b/ast_t.h
index 2c32f85..7a08c2a 100644 (file)
--- a/ast_t.h
+++ b/ast_t.h
@@ -81,12 +81,12 @@ typedef enum expression_kind_t {
        EXPR_ALIGNOF,
 
        EXPR_FUNCNAME,
-       EXPR_BUILTIN_SYMBOL,
        EXPR_BUILTIN_CONSTANT_P,
-       EXPR_BUILTIN_PREFETCH,
+       EXPR_BUILTIN_TYPES_COMPATIBLE_P,
        EXPR_OFFSETOF,
        EXPR_VA_START,
        EXPR_VA_ARG,
+       EXPR_VA_COPY,
        EXPR_STATEMENT,
        EXPR_LABEL_ADDRESS, /**< GCC extension &&label operator */
 
@@ -226,16 +226,22 @@ typedef enum funcname_kind_t {
        EXPR_UNARY_CASES_MANDATORY \
        EXPR_UNARY_CASES_OPTIONAL
 
+/**
+ * The base class of every expression.
+ */
 struct expression_base_t {
-       expression_kind_t   kind;
-       type_t             *type;
-       source_position_t   source_position;
+       expression_kind_t   kind;            /**< The expression kind. */
+       type_t             *type;            /**< The type of the expression. */
+       source_position_t   source_position; /**< The source position of this expression. */
        bool                parenthesized;
 #ifndef NDEBUG
-       bool                transformed;
+       bool                transformed;     /**< Set if this expression was transformed. */
 #endif
 };
 
+/**
+ * A constant.
+ */
 struct const_expression_t {
        expression_base_t  base;
        union {
@@ -270,21 +276,15 @@ struct compound_literal_expression_t {
        initializer_t     *initializer;
 };
 
-struct builtin_symbol_expression_t {
-       expression_base_t  base;
-       symbol_t          *symbol;
-};
-
 struct builtin_constant_expression_t {
        expression_base_t  base;
        expression_t      *value;
 };
 
-struct builtin_prefetch_expression_t {
+struct builtin_types_compatible_expression_t {
        expression_base_t  base;
-       expression_t      *adr;
-       expression_t      *rw;
-       expression_t      *locality;
+       type_t            *left;
+       type_t            *right;
 };
 
 struct reference_expression_t {
@@ -292,20 +292,25 @@ struct reference_expression_t {
        entity_t          *entity;
 };
 
+/**
+ * An argument of a call.
+ */
 struct call_argument_t {
-       expression_t    *expression;
-       call_argument_t *next;
+       expression_t    *expression;  /**< The expression which value is transmitted. */
+       call_argument_t *next;        /**< Links to the next argument of this call. */
 };
 
+
 struct call_expression_t {
        expression_base_t  base;
-       expression_t      *function;
-       call_argument_t   *arguments;
+       expression_t      *function;  /**< The address of the function to call. */
+       call_argument_t   *arguments; /**< List of arguments of this call. */
 };
 
+
 struct unary_expression_t {
        expression_base_t  base;
-       expression_t      *value;
+       expression_t      *value;     /**< The unary operand. */
 };
 
 struct binary_expression_t {
@@ -322,9 +327,9 @@ struct select_expression_t {
 
 struct array_access_expression_t {
        expression_base_t  base;
-       expression_t      *array_ref;
-       expression_t      *index;
-       bool               flipped; /**< index/ref was written in a 5[a] way */
+       expression_t      *array_ref; /**< the referenced array */
+       expression_t      *index;     /**< the index used */
+       bool               flipped;   /**< True if index/ref was written in a 5[a] way */
 };
 
 struct typeprop_expression_t {
@@ -335,8 +340,8 @@ struct typeprop_expression_t {
 
 struct designator_t {
        source_position_t  source_position;
-       symbol_t          *symbol;
-       expression_t      *array_index;
+       symbol_t          *symbol;      /**< the symbol if any */
+       expression_t      *array_index; /**< the array index if any */
        designator_t      *next;
 };
 
@@ -357,6 +362,12 @@ struct va_arg_expression_t {
        expression_t      *ap;
 };
 
+struct va_copy_expression_t {
+       expression_base_t  base;
+       expression_t      *dst;    /**< destination argument */
+       expression_t      *src;    /**< source argument */
+};
+
 struct conditional_expression_t {
        expression_base_t  base;
        expression_t      *condition;
@@ -380,30 +391,30 @@ struct label_address_expression_t {
 };
 
 union expression_t {
-       expression_kind_t                kind;
-       expression_base_t                base;
-       const_expression_t               conste;
-       funcname_expression_t            funcname;
-       string_literal_expression_t      string;
-       wide_string_literal_expression_t wide_string;
-       compound_literal_expression_t    compound_literal;
-       builtin_symbol_expression_t      builtin_symbol;
-       builtin_constant_expression_t    builtin_constant;
-       builtin_prefetch_expression_t    builtin_prefetch;
-       reference_expression_t           reference;
-       call_expression_t                call;
-       unary_expression_t               unary;
-       binary_expression_t              binary;
-       select_expression_t              select;
-       array_access_expression_t        array_access;
-       typeprop_expression_t            typeprop;
-       offsetof_expression_t            offsetofe;
-       va_start_expression_t            va_starte;
-       va_arg_expression_t              va_arge;
-       conditional_expression_t         conditional;
-       statement_expression_t           statement;
-       classify_type_expression_t       classify_type;
-       label_address_expression_t       label_address;
+       expression_kind_t                     kind;
+       expression_base_t                     base;
+       const_expression_t                    conste;
+       funcname_expression_t                 funcname;
+       string_literal_expression_t           string;
+       wide_string_literal_expression_t      wide_string;
+       compound_literal_expression_t         compound_literal;
+       builtin_constant_expression_t         builtin_constant;
+       builtin_types_compatible_expression_t builtin_types_compatible;
+       reference_expression_t                reference;
+       call_expression_t                     call;
+       unary_expression_t                    unary;
+       binary_expression_t                   binary;
+       select_expression_t                   select;
+       array_access_expression_t             array_access;
+       typeprop_expression_t                 typeprop;
+       offsetof_expression_t                 offsetofe;
+       va_start_expression_t                 va_starte;
+       va_arg_expression_t                   va_arge;
+       va_copy_expression_t                  va_copye;
+       conditional_expression_t              conditional;
+       statement_expression_t                statement;
+       classify_type_expression_t            classify_type;
+       label_address_expression_t            label_address;
 };
 
 typedef enum initializer_kind_t {
@@ -455,78 +466,8 @@ union initializer_t {
 };
 
 /**
- * GNU attributes.
+ * The statement kinds.
  */
-typedef enum gnu_attribute_kind_t {
-       GNU_AK_CONST,
-       GNU_AK_VOLATILE,
-       GNU_AK_CDECL,
-       GNU_AK_STDCALL,
-       GNU_AK_FASTCALL,
-       GNU_AK_DEPRECATED,
-       GNU_AK_NOINLINE,
-       GNU_AK_RETURNS_TWICE,
-       GNU_AK_NORETURN,
-       GNU_AK_NAKED,
-       GNU_AK_PURE,
-       GNU_AK_ALWAYS_INLINE,
-       GNU_AK_MALLOC,
-       GNU_AK_WEAK,
-       GNU_AK_CONSTRUCTOR,
-       GNU_AK_DESTRUCTOR,
-       GNU_AK_NOTHROW,
-       GNU_AK_TRANSPARENT_UNION,
-       GNU_AK_COMMON,
-       GNU_AK_NOCOMMON,
-       GNU_AK_PACKED,
-       GNU_AK_SHARED,
-       GNU_AK_NOTSHARED,
-       GNU_AK_USED,
-       GNU_AK_UNUSED,
-       GNU_AK_NO_INSTRUMENT_FUNCTION,
-       GNU_AK_WARN_UNUSED_RESULT,
-       GNU_AK_LONGCALL,
-       GNU_AK_SHORTCALL,
-       GNU_AK_LONG_CALL,
-       GNU_AK_SHORT_CALL,
-       GNU_AK_FUNCTION_VECTOR,
-       GNU_AK_INTERRUPT,
-       GNU_AK_INTERRUPT_HANDLER,
-       GNU_AK_NMI_HANDLER,
-       GNU_AK_NESTING,
-       GNU_AK_NEAR,
-       GNU_AK_FAR,
-       GNU_AK_SIGNAL,
-       GNU_AK_EIGTHBIT_DATA,
-       GNU_AK_TINY_DATA,
-       GNU_AK_SAVEALL,
-       GNU_AK_FLATTEN,
-       GNU_AK_SSEREGPARM,
-       GNU_AK_EXTERNALLY_VISIBLE,
-       GNU_AK_RETURN_TWICE,
-       GNU_AK_MAY_ALIAS,
-       GNU_AK_MS_STRUCT,
-       GNU_AK_GCC_STRUCT,
-       GNU_AK_DLLIMPORT,
-       GNU_AK_DLLEXPORT,
-       GNU_AK_ALIGNED,
-       GNU_AK_ALIAS,
-       GNU_AK_SECTION,
-       GNU_AK_FORMAT,
-       GNU_AK_FORMAT_ARG,
-       GNU_AK_WEAKREF,
-       GNU_AK_NONNULL,
-       GNU_AK_TLS_MODEL,
-       GNU_AK_VISIBILITY,
-       GNU_AK_REGPARM,
-       GNU_AK_MODEL,
-       GNU_AK_MODE,
-       GNU_AK_TRAP_EXIT,
-       GNU_AK_SP_SWITCH,
-       GNU_AK_SENTINEL,
-       GNU_AK_LAST
-} gnu_attribute_kind_t;
-
 typedef enum statement_kind_t {
        STATEMENT_INVALID,
        STATEMENT_EMPTY,
@@ -549,12 +490,15 @@ typedef enum statement_kind_t {
        STATEMENT_LEAVE            /**< MS __leave */
 } statement_kind_t;
 
+/**
+ * The base class of every statement.
+ */
 struct statement_base_t {
        statement_kind_t   kind;
-       statement_t       *next;
+       statement_t       *next;         /**< Point to the next statement in a compound statement. */
        source_position_t  source_position;
-       statement_t       *parent;
-       bool               reachable;
+       statement_t       *parent;       /**< The Parent statement that controls the execution. */
+       bool               reachable;    /**< True, if this statement is reachable. */
 #ifndef NDEBUG
        bool               transformed;
 #endif
@@ -570,14 +514,14 @@ struct empty_statement_t {
 
 struct return_statement_t {
        statement_base_t  base;
-       expression_t     *value;
+       expression_t     *value;    /**< The return value if any. */
 };
 
 struct compound_statement_t {
        statement_base_t  base;
        statement_t      *statements;
        scope_t           scope;
-       bool              stmt_expr; /* The compound statement is a statement expression */
+       bool              stmt_expr; /**< True if this compound statement is a statement expression. */
 };
 
 struct declaration_statement_t {
@@ -731,7 +675,6 @@ bool is_invalid_statement(statement_t *statement)
        return statement->base.kind == STATEMENT_INVALID;
 }
 
-
 #define allocate_ast(size)                 _allocate_ast(size)
 
 #endif