add an is_constant_expression, only try to fold expressions that are really constant...
[cparser] / ast_t.h
diff --git a/ast_t.h b/ast_t.h
index dbcc4f4..77b6860 100644 (file)
--- a/ast_t.h
+++ b/ast_t.h
@@ -20,8 +20,6 @@ typedef enum {
        EXPR_STRING_LITERAL,
        EXPR_WIDE_STRING_LITERAL,
        EXPR_CALL,
-       EXPR_UNARY,
-       EXPR_BINARY,
        EXPR_CONDITIONAL,
        EXPR_SELECT,
        EXPR_ARRAY_ACCESS,
@@ -32,12 +30,121 @@ typedef enum {
        EXPR_PRETTY_FUNCTION,
        EXPR_BUILTIN_SYMBOL,
        EXPR_OFFSETOF,
+       EXPR_VA_START,
        EXPR_VA_ARG,
-       EXPR_STATEMENT
+       EXPR_STATEMENT,
+
+       EXPR_UNARY_FIRST,
+       EXPR_UNARY_NEGATE = EXPR_UNARY_FIRST,
+       EXPR_UNARY_PLUS,
+       EXPR_UNARY_BITWISE_NEGATE,
+       EXPR_UNARY_NOT,
+       EXPR_UNARY_DEREFERENCE,
+       EXPR_UNARY_TAKE_ADDRESS,
+       EXPR_UNARY_POSTFIX_INCREMENT,
+       EXPR_UNARY_POSTFIX_DECREMENT,
+       EXPR_UNARY_PREFIX_INCREMENT,
+       EXPR_UNARY_PREFIX_DECREMENT,
+       EXPR_UNARY_CAST,
+       EXPR_UNARY_CAST_IMPLICIT, /* compiler generated cast */
+       EXPR_UNARY_LAST = EXPR_UNARY_CAST_IMPLICIT,
+
+       EXPR_BINARY_FIRST,
+       EXPR_BINARY_ADD = EXPR_BINARY_FIRST,
+       EXPR_BINARY_SUB,
+       EXPR_BINARY_MUL,
+       EXPR_BINARY_DIV,
+       EXPR_BINARY_MOD,
+       EXPR_BINARY_EQUAL,
+       EXPR_BINARY_NOTEQUAL,
+       EXPR_BINARY_LESS,
+       EXPR_BINARY_LESSEQUAL,
+       EXPR_BINARY_GREATER,
+       EXPR_BINARY_GREATEREQUAL,
+       EXPR_BINARY_BITWISE_AND,
+       EXPR_BINARY_BITWISE_OR,
+       EXPR_BINARY_BITWISE_XOR,
+       EXPR_BINARY_LOGICAL_AND,
+       EXPR_BINARY_LOGICAL_OR,
+       EXPR_BINARY_SHIFTLEFT,
+       EXPR_BINARY_SHIFTRIGHT,
+       EXPR_BINARY_ASSIGN,
+       EXPR_BINARY_MUL_ASSIGN,
+       EXPR_BINARY_DIV_ASSIGN,
+       EXPR_BINARY_MOD_ASSIGN,
+       EXPR_BINARY_ADD_ASSIGN,
+       EXPR_BINARY_SUB_ASSIGN,
+       EXPR_BINARY_SHIFTLEFT_ASSIGN,
+       EXPR_BINARY_SHIFTRIGHT_ASSIGN,
+       EXPR_BINARY_BITWISE_AND_ASSIGN,
+       EXPR_BINARY_BITWISE_XOR_ASSIGN,
+       EXPR_BINARY_BITWISE_OR_ASSIGN,
+       EXPR_BINARY_COMMA,
+
+       EXPR_BINARY_ISGREATER,
+       EXPR_BINARY_ISGREATEREQUAL,
+       EXPR_BINARY_ISLESS,
+       EXPR_BINARY_ISLESSEQUAL,
+       EXPR_BINARY_ISLESSGREATER,
+       EXPR_BINARY_ISUNORDERED,
+       EXPR_BINARY_LAST = EXPR_BINARY_ISUNORDERED,
 } expression_type_t;
 
+/* convenience macros */
+#define EXPR_BINARY_CASES                  \
+       case EXPR_BINARY_ADD:                  \
+       case EXPR_BINARY_SUB:                  \
+       case EXPR_BINARY_MUL:                  \
+       case EXPR_BINARY_DIV:                  \
+       case EXPR_BINARY_MOD:                  \
+       case EXPR_BINARY_EQUAL:                \
+       case EXPR_BINARY_NOTEQUAL:             \
+       case EXPR_BINARY_LESS:                 \
+       case EXPR_BINARY_LESSEQUAL:            \
+       case EXPR_BINARY_GREATER:              \
+       case EXPR_BINARY_GREATEREQUAL:         \
+       case EXPR_BINARY_BITWISE_AND:          \
+       case EXPR_BINARY_BITWISE_OR:           \
+       case EXPR_BINARY_BITWISE_XOR:          \
+       case EXPR_BINARY_LOGICAL_AND:          \
+       case EXPR_BINARY_LOGICAL_OR:           \
+       case EXPR_BINARY_SHIFTLEFT:            \
+       case EXPR_BINARY_SHIFTRIGHT:           \
+       case EXPR_BINARY_ASSIGN:               \
+       case EXPR_BINARY_MUL_ASSIGN:           \
+       case EXPR_BINARY_DIV_ASSIGN:           \
+       case EXPR_BINARY_MOD_ASSIGN:           \
+       case EXPR_BINARY_ADD_ASSIGN:           \
+       case EXPR_BINARY_SUB_ASSIGN:           \
+       case EXPR_BINARY_SHIFTLEFT_ASSIGN:     \
+       case EXPR_BINARY_SHIFTRIGHT_ASSIGN:    \
+       case EXPR_BINARY_BITWISE_AND_ASSIGN:   \
+       case EXPR_BINARY_BITWISE_XOR_ASSIGN:   \
+       case EXPR_BINARY_BITWISE_OR_ASSIGN:    \
+       case EXPR_BINARY_COMMA:                \
+       case EXPR_BINARY_ISGREATER:            \
+       case EXPR_BINARY_ISGREATEREQUAL:       \
+       case EXPR_BINARY_ISLESS:               \
+       case EXPR_BINARY_ISLESSEQUAL:          \
+       case EXPR_BINARY_ISLESSGREATER:        \
+       case EXPR_BINARY_ISUNORDERED:
+
+#define EXPR_UNARY_CASES                   \
+       case EXPR_UNARY_NEGATE:                \
+       case EXPR_UNARY_PLUS:                  \
+       case EXPR_UNARY_BITWISE_NEGATE:        \
+       case EXPR_UNARY_NOT:                   \
+       case EXPR_UNARY_DEREFERENCE:           \
+       case EXPR_UNARY_TAKE_ADDRESS:          \
+       case EXPR_UNARY_POSTFIX_INCREMENT:     \
+       case EXPR_UNARY_POSTFIX_DECREMENT:     \
+       case EXPR_UNARY_PREFIX_INCREMENT:      \
+       case EXPR_UNARY_PREFIX_DECREMENT:      \
+       case EXPR_UNARY_CAST:                  \
+       case EXPR_UNARY_CAST_IMPLICIT:
+
 struct context_t {
-       declaration_t   *declarations;
+       declaration_t *declarations;
 };
 
 struct expression_base_t {
@@ -86,67 +193,15 @@ struct call_expression_t {
        call_argument_t   *arguments;
 };
 
-typedef enum {
-       UNEXPR_INVALID = 0,
-       UNEXPR_NEGATE,
-       UNEXPR_PLUS,
-       UNEXPR_BITWISE_NEGATE,
-       UNEXPR_NOT,
-       UNEXPR_DEREFERENCE,
-       UNEXPR_TAKE_ADDRESS,
-       UNEXPR_POSTFIX_INCREMENT,
-       UNEXPR_POSTFIX_DECREMENT,
-       UNEXPR_PREFIX_INCREMENT,
-       UNEXPR_PREFIX_DECREMENT,
-       UNEXPR_CAST,
-       UNEXPR_CAST_IMPLICIT /* compiler generated cast */
-} unary_expression_type_t;
-
 struct unary_expression_t {
-       expression_base_t        expression;
-       unary_expression_type_t  type;
-       expression_t            *value;
+       expression_base_t  expression;
+       expression_t      *value;
 };
 
-typedef enum {
-       BINEXPR_INVALID = 0,
-       BINEXPR_ADD,
-       BINEXPR_SUB,
-       BINEXPR_MUL,
-       BINEXPR_DIV,
-       BINEXPR_MOD,
-       BINEXPR_EQUAL,
-       BINEXPR_NOTEQUAL,
-       BINEXPR_LESS,
-       BINEXPR_LESSEQUAL,
-       BINEXPR_GREATER,
-       BINEXPR_GREATEREQUAL,
-       BINEXPR_BITWISE_AND,
-       BINEXPR_BITWISE_OR,
-       BINEXPR_BITWISE_XOR,
-       BINEXPR_LOGICAL_AND,
-       BINEXPR_LOGICAL_OR,
-       BINEXPR_SHIFTLEFT,
-       BINEXPR_SHIFTRIGHT,
-       BINEXPR_ASSIGN,
-       BINEXPR_MUL_ASSIGN,
-       BINEXPR_DIV_ASSIGN,
-       BINEXPR_MOD_ASSIGN,
-       BINEXPR_ADD_ASSIGN,
-       BINEXPR_SUB_ASSIGN,
-       BINEXPR_SHIFTLEFT_ASSIGN,
-       BINEXPR_SHIFTRIGHT_ASSIGN,
-       BINEXPR_BITWISE_AND_ASSIGN,
-       BINEXPR_BITWISE_XOR_ASSIGN,
-       BINEXPR_BITWISE_OR_ASSIGN,
-       BINEXPR_COMMA
-} binary_expression_type_t;
-
 struct binary_expression_t {
-       expression_base_t         expression;
-       binary_expression_type_t  type;
-       expression_t             *left;
-       expression_t             *right;
+       expression_base_t  expression;
+       expression_t      *left;
+       expression_t      *right;
 };
 
 struct select_expression_t {
@@ -182,10 +237,15 @@ struct offsetof_expression_t {
        designator_t      *designator;
 };
 
+struct va_start_expression_t {
+       expression_base_t  expression;
+       expression_t      *ap;
+       declaration_t     *parameter;
+};
+
 struct va_arg_expression_t {
        expression_base_t  expression;
-       expression_t      *arg;
-       type_t            *type;
+       expression_t      *ap;
 };
 
 struct conditional_expression_t {
@@ -220,6 +280,7 @@ union expression_t {
        array_access_expression_t        array_access;
        sizeof_expression_t              sizeofe;
        offsetof_expression_t            offsetofe;
+       va_start_expression_t            va_starte;
        va_arg_expression_t              va_arge;
        conditional_expression_t         conditional;
        statement_expression_t           statement;
@@ -251,7 +312,7 @@ typedef enum {
        INITIALIZER_VALUE,
        INITIALIZER_LIST,
        INITIALIZER_STRING,
-       INITIALIZER_COUNT
+       INITIALIZER_WIDE_STRING
 } initializer_type_t;
 
 struct initializer_base_t {
@@ -274,17 +335,37 @@ struct initializer_string_t {
        const char         *string;
 };
 
+struct initializer_wide_string_t {
+       initializer_base_t  initializer;
+       wide_string_t       string;
+};
+
 union initializer_t {
-       initializer_type_t   type;
-       initializer_base_t   base;
-       initializer_value_t  value;
-       initializer_list_t   list;
-       initializer_string_t string;
+       initializer_type_t        type;
+       initializer_base_t        base;
+       initializer_value_t       value;
+       initializer_list_t        list;
+       initializer_string_t      string;
+       initializer_wide_string_t wide_string;
 };
 
+typedef enum {
+       DM_DLLIMPORT   = (1 << 0),
+       DM_DLLEXPORT   = (1 << 1),
+       DM_THREAD      = (1 << 2),
+       DM_NAKED       = (1 << 3),
+       DM_FORCEINLINE = (1 << 4),
+       DM_NOTHROW     = (1 << 5),
+       DM_NORETURN    = (1 << 6),
+       DM_NOINLINE    = (1 << 7)
+} decl_modifier_t;
+
+typedef unsigned short decl_modifiers_t;
+
 struct declaration_t {
        unsigned char       namespc;
        unsigned char       storage_class;
+       decl_modifiers_t    decl_modifiers;
        unsigned int        address_taken : 1;
        unsigned int        is_inline     : 1;
        type_t             *type;