Use strstart() instead of strncmp().

[cparser] / ast.c

diff --git a/ast.c b/ast.c
index b8f2b87..3944ade 100644 (file)
--- a/ast.c
+++ b/ast.c
@@ -66,11 +66,6 @@ void print_indent(void)
                print_string("\t");
 }
 
-static void print_symbol(const symbol_t *symbol)
-{
-       print_string(symbol->string);
-}
-
 static void print_stringrep(const string_t *string)
 {
        for (size_t i = 0; i < string->size; ++i) {
@@ -105,8 +100,6 @@ static int right_to_left(unsigned precedence)
 static unsigned get_expression_precedence(expression_kind_t kind)
 {
        static const unsigned prec[] = {
-               [EXPR_UNKNOWN]                           = PREC_PRIMARY,
-               [EXPR_INVALID]                           = PREC_PRIMARY,
                [EXPR_REFERENCE]                         = PREC_PRIMARY,
                [EXPR_REFERENCE_ENUM_VALUE]              = PREC_PRIMARY,
                [EXPR_LITERAL_INTEGER]                   = PREC_PRIMARY,
@@ -149,7 +142,6 @@ static unsigned get_expression_precedence(expression_kind_t kind)
                [EXPR_UNARY_PREFIX_INCREMENT]            = PREC_UNARY,
                [EXPR_UNARY_PREFIX_DECREMENT]            = PREC_UNARY,
                [EXPR_UNARY_CAST]                        = PREC_UNARY,
-               [EXPR_UNARY_CAST_IMPLICIT]               = PREC_UNARY,
                [EXPR_UNARY_ASSUME]                      = PREC_PRIMARY,
                [EXPR_UNARY_DELETE]                      = PREC_UNARY,
                [EXPR_UNARY_DELETE_ARRAY]                = PREC_UNARY,
@@ -267,8 +259,8 @@ static void print_literal(const literal_expression_t *literal)
        case EXPR_LITERAL_INTEGER_OCTAL:
        case EXPR_LITERAL_FLOATINGPOINT:
                print_stringrep(&literal->value);
-               if (literal->suffix != NULL)
-                       print_symbol(literal->suffix);
+               if (literal->suffix.size > 0)
+                       print_stringrep(&literal->suffix);
                return;
        case EXPR_LITERAL_WIDE_CHARACTER:
                print_char('L');
@@ -413,7 +405,6 @@ static void print_unary_expression(const unary_expression_t *unexpr)
                print_expression_prec(unexpr->value, prec);
                print_string("--");
                return;
-       case EXPR_UNARY_CAST_IMPLICIT:
        case EXPR_UNARY_CAST:
                print_string("(");
                print_type(unexpr->base.type);
@@ -598,6 +589,12 @@ static void print_va_copy(const va_copy_expression_t *expression)
 static void print_select(const select_expression_t *expression)
 {
        print_expression_prec(expression->compound, PREC_POSTFIX);
+       /* do not print anything for anonymous struct/union selects
+        * FIXME: if the anonymous select was a '->' this will print '.'
+        */
+       if (expression->compound_entry->base.symbol == NULL)
+               return;
+
        if (is_type_pointer(skip_typeref(expression->compound->base.type))) {
                print_string("->");
        } else {
@@ -672,7 +669,8 @@ static void print_statement_expression(const statement_expression_t *expression)
  */
 static void print_expression_prec(const expression_t *expression, unsigned top_prec)
 {
-       if (expression->kind == EXPR_UNARY_CAST_IMPLICIT && !print_implicit_casts) {
+       if (expression->kind == EXPR_UNARY_CAST
+           && expression->base.implicit && !print_implicit_casts) {
                expression = expression->unary.value;
        }
 
@@ -684,9 +682,8 @@ static void print_expression_prec(const expression_t *expression, unsigned top_p
        if (parenthesized)
                print_string("(");
        switch (expression->kind) {
-       case EXPR_UNKNOWN:
-       case EXPR_INVALID:
-               print_string("$invalid expression$");
+       case EXPR_ERROR:
+               print_string("$error$");
                break;
        case EXPR_WIDE_STRING_LITERAL:
        case EXPR_STRING_LITERAL:
@@ -754,13 +751,6 @@ static void print_expression_prec(const expression_t *expression, unsigned top_p
        case EXPR_STATEMENT:
                print_statement_expression(&expression->statement);
                break;
-
-#if 0
-       default:
-               /* TODO */
-               print_format("some expression of type %d", (int)expression->kind);
-               break;
-#endif
        }
        if (parenthesized)
                print_string(")");
@@ -1190,8 +1180,8 @@ void print_statement(const statement_t *statement)
        case STATEMENT_LEAVE:
                print_leave_statement(&statement->leave);
                break;
-       case STATEMENT_INVALID:
-               print_string("$invalid statement$\n");
+       case STATEMENT_ERROR:
+               print_string("$error statement$\n");
                break;
        }
 }
@@ -1430,6 +1420,13 @@ void print_declaration(const entity_t *entity)
                        }
                        break;
 
+               case ENTITY_COMPOUND_MEMBER:
+                       print_type_ext(declaration->type, declaration->base.symbol, NULL);
+                       if (entity->compound_member.bitfield) {
+                               print_format(" : %u", entity->compound_member.bit_size);
+                       }
+                       break;
+
                default:
                        print_type_ext(declaration->type, declaration->base.symbol, NULL);
                        break;
@@ -1504,8 +1501,6 @@ print_compound:
        case ENTITY_LABEL:
        case ENTITY_ENUM_VALUE:
                panic("print_entity used on unexpected entity type");
-       case ENTITY_INVALID:
-               break;
        }
        panic("Invalid entity type encountered");
 }
@@ -1611,7 +1606,7 @@ static expression_classification_t is_object_with_linker_constant_address(
                return EXPR_CLASS_VARIABLE;
        }
 
-       case EXPR_INVALID:
+       case EXPR_ERROR:
                return EXPR_CLASS_ERROR;
 
        default:
@@ -1646,7 +1641,7 @@ expression_classification_t is_linker_constant(const expression_t *expression)
                if (!is_type_pointer(dest) && (
                                dest->kind != TYPE_ATOMIC                                               ||
                                !(get_atomic_type_flags(dest->atomic.akind) & ATOMIC_TYPE_FLAG_INTEGER) ||
-                               get_atomic_type_size(dest->atomic.akind) < get_atomic_type_size(get_intptr_kind())
+                               get_atomic_type_size(dest->atomic.akind) < get_type_size(type_void_ptr)
                    ))
                        return EXPR_CLASS_VARIABLE;
 
@@ -1737,7 +1732,7 @@ expression_classification_t is_linker_constant(const expression_t *expression)
                return EXPR_CLASS_VARIABLE;
        }
 
-       case EXPR_INVALID:
+       case EXPR_ERROR:
                return EXPR_CLASS_ERROR;
 
        default:
@@ -1759,15 +1754,8 @@ static expression_classification_t is_builtin_const_call(const expression_t *exp
                return EXPR_CLASS_VARIABLE;
 
        switch (ref->entity->function.btk) {
-       case bk_gnu_builtin_huge_val:
-       case bk_gnu_builtin_huge_valf:
-       case bk_gnu_builtin_huge_vall:
-       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:
+       case BUILTIN_INF:
+       case BUILTIN_NAN:
                return EXPR_CLASS_CONSTANT;
        default:
                return EXPR_CLASS_VARIABLE;
@@ -1817,7 +1805,7 @@ static expression_classification_t is_object_with_constant_address(const express
        case EXPR_UNARY_DEREFERENCE:
                return is_constant_pointer(expression->unary.value);
 
-       case EXPR_INVALID:
+       case EXPR_ERROR:
                return EXPR_CLASS_ERROR;
 
        default:
@@ -1894,8 +1882,7 @@ expression_classification_t is_constant_expression(const expression_t *expressio
        case EXPR_UNARY_NOT:
                return is_constant_expression(expression->unary.value);
 
-       case EXPR_UNARY_CAST:
-       case EXPR_UNARY_CAST_IMPLICIT: {
+       case EXPR_UNARY_CAST: {
                type_t *const type = skip_typeref(expression->base.type);
                if (is_type_scalar(type))
                        return is_constant_expression(expression->unary.value);
@@ -1968,11 +1955,8 @@ expression_classification_t is_constant_expression(const expression_t *expressio
                }
        }
 
-       case EXPR_INVALID:
+       case EXPR_ERROR:
                return EXPR_CLASS_ERROR;
-
-       case EXPR_UNKNOWN:
-               break;
        }
        panic("invalid expression found (is constant expression)");
 }