rewrite of attribute handling

[cparser] / ast.c

diff --git a/ast.c b/ast.c
index 613da53..108e157 100644 (file)
--- a/ast.c
+++ b/ast.c
@@ -114,12 +114,12 @@ static unsigned get_expression_precedence(expression_kind_t kind)
                [EXPR_ALIGNOF]                    = PREC_UNARY,
 
                [EXPR_FUNCNAME]                   = PREC_PRIMARY,
-               [EXPR_BUILTIN_SYMBOL]             = PREC_PRIMARY,
                [EXPR_BUILTIN_CONSTANT_P]         = PREC_PRIMARY,
                [EXPR_BUILTIN_TYPES_COMPATIBLE_P] = PREC_PRIMARY,
                [EXPR_OFFSETOF]                   = PREC_PRIMARY,
                [EXPR_VA_START]                   = PREC_PRIMARY,
                [EXPR_VA_ARG]                     = PREC_PRIMARY,
+               [EXPR_VA_COPY]                    = PREC_PRIMARY,
                [EXPR_STATEMENT]                  = PREC_PRIMARY,
                [EXPR_LABEL_ADDRESS]              = PREC_PRIMARY,
 
@@ -398,8 +398,7 @@ static void print_assignment_expression(const expression_t *const expr)
  */
 static void print_call_expression(const call_expression_t *call)
 {
-       unsigned prec = get_expression_precedence(call->base.kind);
-       print_expression_prec(call->function, prec);
+       print_expression_prec(call->function, PREC_POSTFIX);
        fputc('(', out);
        call_argument_t *argument = call->arguments;
        int              first    = 1;
@@ -547,14 +546,13 @@ static void print_label_address_expression(const label_address_expression_t *le)
  */
 static void print_array_expression(const array_access_expression_t *expression)
 {
-       unsigned prec = get_expression_precedence(expression->base.kind);
        if (!expression->flipped) {
-               print_expression_prec(expression->array_ref, prec);
+               print_expression_prec(expression->array_ref, PREC_POSTFIX);
                fputc('[', out);
                print_expression(expression->index);
                fputc(']', out);
        } else {
-               print_expression_prec(expression->index, prec);
+               print_expression_prec(expression->index, PREC_POSTFIX);
                fputc('[', out);
                print_expression(expression->array_ref);
                fputc(']', out);
@@ -584,16 +582,6 @@ static void print_typeprop_expression(const typeprop_expression_t *expression)
        }
 }
 
-/**
- * Prints an builtin symbol.
- *
- * @param expression   the builtin symbol expression
- */
-static void print_builtin_symbol(const builtin_symbol_expression_t *expression)
-{
-       fputs(expression->symbol->string, out);
-}
-
 /**
  * Prints a builtin constant expression.
  *
@@ -668,6 +656,20 @@ static void print_va_arg(const va_arg_expression_t *expression)
        fputc(')', out);
 }
 
+/**
+ * Prints a va_copy expression.
+ *
+ * @param expression   the va_copy expression
+ */
+static void print_va_copy(const va_copy_expression_t *expression)
+{
+       fputs("__builtin_va_copy(", out);
+       print_assignment_expression(expression->dst);
+       fputs(", ", out);
+       print_assignment_expression(expression->src);
+       fputc(')', out);
+}
+
 /**
  * Prints a select expression (. or ->).
  *
@@ -675,8 +677,7 @@ static void print_va_arg(const va_arg_expression_t *expression)
  */
 static void print_select(const select_expression_t *expression)
 {
-       unsigned prec = get_expression_precedence(expression->base.kind);
-       print_expression_prec(expression->compound, prec);
+       print_expression_prec(expression->compound, PREC_POSTFIX);
        if (is_type_pointer(skip_typeref(expression->compound->base.type))) {
                fputs("->", out);
        } else {
@@ -724,8 +725,7 @@ static void print_designator(const designator_t *designator)
  */
 static void print_offsetof_expression(const offsetof_expression_t *expression)
 {
-       fputs("__builtin_offsetof", out);
-       fputc('(', out);
+       fputs("__builtin_offsetof(", out);
        print_type(expression->type);
        fputc(',', out);
        print_designator(expression->designator);
@@ -812,9 +812,6 @@ static void print_expression_prec(const expression_t *expression, unsigned top_p
        case EXPR_ALIGNOF:
                print_typeprop_expression(&expression->typeprop);
                break;
-       case EXPR_BUILTIN_SYMBOL:
-               print_builtin_symbol(&expression->builtin_symbol);
-               break;
        case EXPR_BUILTIN_CONSTANT_P:
                print_builtin_constant(&expression->builtin_constant);
                break;
@@ -830,6 +827,9 @@ static void print_expression_prec(const expression_t *expression, unsigned top_p
        case EXPR_VA_ARG:
                print_va_arg(&expression->va_arge);
                break;
+       case EXPR_VA_COPY:
+               print_va_copy(&expression->va_copye);
+               break;
        case EXPR_SELECT:
                print_select(&expression->select);
                break;
@@ -1349,6 +1349,7 @@ void print_initializer(const initializer_t *initializer)
        panic("invalid initializer kind found");
 }
 
+#if 0
 /**
  * Print microsoft extended declaration modifiers.
  */
@@ -1440,6 +1441,7 @@ static void print_ms_modifiers(const declaration_t *declaration)
        if (ds_shown)
                fputs(") ", out);
 }
+#endif
 
 static void print_scope(const scope_t *scope)
 {
@@ -1490,7 +1492,7 @@ void print_declaration(const entity_t *entity)
                        }
                }
        }
-       print_ms_modifiers(declaration);
+       //print_ms_modifiers(declaration);
        switch (entity->kind) {
                case ENTITY_FUNCTION:
                        print_type_ext(entity->declaration.type, entity->base.symbol,
@@ -1686,6 +1688,12 @@ static bool is_object_with_linker_constant_address(const expression_t *expressio
 bool is_address_constant(const expression_t *expression)
 {
        switch (expression->kind) {
+       case EXPR_STRING_LITERAL:
+       case EXPR_WIDE_STRING_LITERAL:
+       case EXPR_FUNCNAME:
+       case EXPR_LABEL_ADDRESS:
+               return true;
+
        case EXPR_UNARY_TAKE_ADDRESS:
                return is_object_with_linker_constant_address(expression->unary.value);
 
@@ -1757,27 +1765,32 @@ bool is_address_constant(const expression_t *expression)
        }
 }
 
+/**
+ * Check if the given expression is a call to a builtin function
+ * returning a constant result.
+ */
 static bool is_builtin_const_call(const expression_t *expression)
 {
        expression_t *function = expression->call.function;
-       if (function->kind != EXPR_BUILTIN_SYMBOL) {
+       if (function->kind != EXPR_REFERENCE)
+               return false;
+       reference_expression_t *ref = &function->reference;
+       if (ref->entity->kind != ENTITY_FUNCTION)
                return false;
-       }
-
-       symbol_t *symbol = function->builtin_symbol.symbol;
 
-       switch (symbol->ID) {
-       case T___builtin_huge_val:
-       case T___builtin_inf:
-       case T___builtin_inff:
-       case T___builtin_infl:
-       case T___builtin_nan:
-       case T___builtin_nanf:
-       case T___builtin_nanl:
+       switch (ref->entity->function.btk) {
+       case bk_gnu_builtin_huge_val:
+       case bk_gnu_builtin_inf:
+       case bk_gnu_builtin_inff:
+       case bk_gnu_builtin_infl:
+       case bk_gnu_builtin_nan:
+       case bk_gnu_builtin_nanf:
+       case bk_gnu_builtin_nanl:
                return true;
+       default:
+               return false;
        }
 
-       return false;
 }
 
 static bool is_constant_pointer(const expression_t *expression)
@@ -1831,15 +1844,11 @@ bool is_constant_expression(const expression_t *expression)
        case EXPR_CONST:
        case EXPR_CHARACTER_CONSTANT:
        case EXPR_WIDE_CHARACTER_CONSTANT:
-       case EXPR_STRING_LITERAL:
-       case EXPR_WIDE_STRING_LITERAL:
        case EXPR_CLASSIFY_TYPE:
-       case EXPR_FUNCNAME:
        case EXPR_OFFSETOF:
        case EXPR_ALIGNOF:
        case EXPR_BUILTIN_CONSTANT_P:
        case EXPR_BUILTIN_TYPES_COMPATIBLE_P:
-       case EXPR_LABEL_ADDRESS:
        case EXPR_REFERENCE_ENUM_VALUE:
                return true;
 
@@ -1854,10 +1863,14 @@ bool is_constant_expression(const expression_t *expression)
                return true;
        }
 
-       case EXPR_BUILTIN_SYMBOL:
+       case EXPR_STRING_LITERAL:
+       case EXPR_WIDE_STRING_LITERAL:
+       case EXPR_FUNCNAME:
+       case EXPR_LABEL_ADDRESS:
        case EXPR_SELECT:
        case EXPR_VA_START:
        case EXPR_VA_ARG:
+       case EXPR_VA_COPY:
        case EXPR_STATEMENT:
        case EXPR_REFERENCE:
        case EXPR_UNARY_POSTFIX_INCREMENT: