parser: Add various grammatical types and allocator functions

diff --git a/src/grammar.c b/src/grammar.c
index b83e557a307e9d9d8db44e73ce6310394afd4c58..aee957f196cb639ec3642cd4e079fb03b3449658 100644 (file)
--- a/src/grammar.c
+++ b/src/grammar.c
@@ -403,3 +403,198 @@ void string_debug(struct string *s)
 
        return;
 }
+
+struct assignment_expression *assignment_expression_new(void)
+{
+       struct assignment_expression *ae;
+
+       ae = malloc(sizeof(*ae));
+
+       if(ae) {
+               memset(ae, 0, sizeof(*ae));
+       }
+
+       return(ae);
+}
+
+struct conditional_expression *conditional_expression_new(void)
+{
+       struct conditional_expression *ce;
+
+       ce = malloc(sizeof(*ce));
+
+       if(ce) {
+               memset(ce, 0, sizeof(*ce));
+       }
+
+       return(ce);
+}
+
+struct constant_expression *constant_expression_new(void)
+{
+       struct constant_expression *ce;
+
+       ce = malloc(sizeof(*ce));
+
+       if(ce) {
+               memset(ce, 0, sizeof(*ce));
+       }
+
+       return(ce);
+}
+
+struct logical_or_expression *logical_or_expression_new(void)
+{
+       struct logical_or_expression *loe;
+
+       loe = malloc(sizeof(*loe));
+
+       if(loe) {
+               memset(loe, 0, sizeof(*loe));
+       }
+
+       return(loe);
+}
+
+struct logical_and_expression *logical_and_expression_new(void)
+{
+       struct logical_and_expression *lae;
+
+       lae = malloc(sizeof(*lae));
+
+       if(lae) {
+               memset(lae, 0, sizeof(*lae));
+       }
+
+       return(lae);
+}
+
+struct inclusive_or_expression *inclusive_or_expression_new(void)
+{
+       struct inclusive_or_expression *ioe;
+
+       ioe = malloc(sizeof(*ioe));
+
+       if(ioe) {
+               memset(ioe, 0, sizeof(*ioe));
+       }
+
+       return(ioe);
+}
+
+struct exclusive_or_expression *exclusive_or_expression_new(void)
+{
+       struct exclusive_or_expression *eoe;
+
+       eoe = malloc(sizeof(*eoe));
+
+       if(eoe) {
+               memset(eoe, 0, sizeof(*eoe));
+       }
+
+       return(eoe);
+}
+
+struct and_expression *and_expression_new(void)
+{
+       struct and_expression *ae;
+
+       ae = malloc(sizeof(*ae));
+
+       if(ae) {
+               memset(ae, 0, sizeof(*ae));
+       }
+
+       return(ae);
+}
+
+struct equality_expression *equality_expression_new(void)
+{
+       struct equality_expression *ee;
+
+       ee = malloc(sizeof(*ee));
+
+       if(ee) {
+               memset(ee, 0, sizeof(*ee));
+       }
+
+       return(ee);
+}
+
+struct relational_expression *relational_expression_new(void)
+{
+       struct relational_expression *re;
+
+       re = malloc(sizeof(*re));
+
+       if(re) {
+               memset(re, 0, sizeof(*re));
+       }
+
+       return(re);
+}
+
+struct shift_expression *shift_expression_new(void)
+{
+       struct shift_expression *se;
+
+       se = malloc(sizeof(*se));
+
+       if(se) {
+               memset(se, 0, sizeof(*se));
+       }
+
+       return(se);
+}
+
+struct additive_expression *additive_expression_new(void)
+{
+       struct additive_expression *ae;
+
+       ae = malloc(sizeof(*ae));
+
+       if(ae) {
+               memset(ae, 0, sizeof(*ae));
+       }
+
+       return(ae);
+}
+
+struct multiplicative_expression *multiplicative_expression_new(void)
+{
+       struct multiplicative_expression *me;
+
+       me = malloc(sizeof(*me));
+
+       if(me) {
+               memset(me, 0, sizeof(*me));
+       }
+
+       return(me);
+}
+
+struct cast_expression *cast_expression_new(void)
+{
+       struct cast_expression *ce;
+
+       ce = malloc(sizeof(*ce));
+
+       if(ce) {
+               memset(ce, 0, sizeof(*ce));
+       }
+
+       return(ce);
+}
+
+struct unary_expression *unary_expression_new(void)
+{
+       struct unary_expression *ue;
+
+       ue = malloc(sizeof(*ue));
+
+       if(ue) {
+               memset(ue, 0, sizeof(*ue));
+       }
+
+       return(ue);
+}

diff --git a/src/grammar.h b/src/grammar.h
index fbaca9cea9782dd414c2c875cb4ee2b2c7bab030..3979f120c1edb4da36ee9d454c36d20a7a29d282 100644 (file)
--- a/src/grammar.h
+++ b/src/grammar.h
@@ -32,6 +32,157 @@ struct string {
        struct token *token;
 };
 
+enum unary_expression_type {
+       UNARY_EXPR_INVALID,
+       UNARY_EXPR_POSTFIX,
+       UNARY_EXPR_PREFIX,
+       UNARY_EXPR_CAST,
+       UNARY_EXPR_SIZEOF_UNARY,
+       UNARY_EXPR_SIZEOF_TYPE
+};
+
+struct unary_expression {
+       enum unary_expression_type type;
+
+       union {
+               struct postfix_expression *postfix;
+
+               struct {
+                       struct token *prefix;
+                       struct unary_expression *uexpr;
+               } prefix;
+
+               struct {
+                       struct token *op;
+                       struct cast_expression *castexpr;
+               } cast;
+
+               struct {
+                       struct token *op;
+                       struct unary_expression *uexpr;
+               } sizeof_unary;
+
+               struct {
+                       struct token *op;
+                       struct token *lparen;
+                       struct type_name *typename;
+                       struct token *rparen;
+               } sizeof_type;
+       } data;
+};
+
+enum cast_expression_type {
+       CAST_EXPR_INVALID = 0,
+       CAST_EXPR_UNARY,
+       CAST_EXPR_CAST
+};
+
+struct cast_expression {
+       enum cast_expression_type type;
+
+       union {
+               struct unary_expression *uexpr;
+
+               struct {
+                       struct token *lparen;
+                       struct type_name *typename;
+                       struct token *rparen;
+                       struct cast_expression *castexpr;
+               } cast;
+       } data;
+};
+
+struct multiplicative_expression {
+       struct multiplicative_expression *mulexpr;
+       struct token *op;
+       struct cast_expression *castexpr;
+};
+
+struct additive_expression {
+       struct additive_expression *addexpr;
+       struct token *op;
+       struct multiplicative_expression *mulexpr;
+};
+
+struct shift_expression {
+       struct shift_expression *sexpr;
+       struct token *op;
+       struct additive_expression *addexpr;
+};
+
+struct relational_expression {
+       struct relational_expression *relexpr;
+       struct token *op;
+       struct shift_expression *sexpr;
+};
+
+struct equality_expression {
+       struct equality_expression *eqexpr;
+       struct token *op;
+       struct relational_expression *relexpr;
+};
+
+struct and_expression {
+       struct and_expression *andexpr;
+       struct token *op;
+       struct equality_expression *eqexpr;
+};
+
+struct exclusive_or_expression {
+       struct exclusive_or_expression *xorexpr;
+       struct token *op;
+       struct and_expression *andexpr;
+};
+
+struct inclusive_or_expression {
+       struct inclusive_or_expression *iorepr;
+       struct token *op;
+       struct exclusive_or_expression *xorexpr;
+};
+
+struct logical_and_expression {
+       struct logical_and_expression *landexpr;
+       struct token *op;
+       struct inclusive_or_expression *iorexpr;
+};
+
+struct logical_or_expression {
+       struct logical_or_expression *lorexpr;
+       struct token *op;
+       struct logical_and_expression *landexpr;
+};
+
+struct conditional_expression {
+       struct logical_or_expression *lorexpr;
+       struct token *qmark;
+       struct expression *expr;
+       struct token *colon;
+       struct conditional_expression *cexpr;
+};
+
+struct constant_expression {
+       struct conditional_expression *cexpr;
+};
+
+enum assignment_expression_type {
+       ASSIGNMENT_EXPR_INVALID = 0,
+       ASSIGNMENT_EXPR_CONDITIONAL,
+       ASSIGNMENT_EXPR_ASSIGNMENT
+};
+
+struct assignment_expression {
+       enum assignment_expression_type type;
+
+       union {
+               struct conditional_expression *cexpr;
+               struct {
+                       struct unary_expression *uexpr;
+                       struct token *op;
+                       struct assignment_expression *aexpr;
+               } aexpr;
+       } data;
+};
+
 struct argument_expression_list {
        struct assigment_expression *aexpr;
        struct argument_expression_list *next;
@@ -227,6 +378,8 @@ struct translation_unit {
 struct primary_expression *primary_expression_new(void);
 void primary_expression_debug(struct primary_expression*);
 
+struct assignment_expression *assignment_expression_new(void);
+
 struct integer_constant *integer_constant_new(void);
 struct character_constant *character_constant_new(void);
 struct floating_constant *floating_constant_new(void);
@@ -258,4 +411,20 @@ struct identifier* identifier_new(void);
 void constant_debug(struct constant*);
 void string_debug(struct string*);
 
+struct assignment_expression *assignment_expression_new(void);
+struct conditional_expression *conditional_expression_new(void);
+struct constant_expression *constant_expression_new(void);
+struct logical_or_expression *logical_or_expression_new(void);
+struct logical_and_expression *logical_and_expression_new(void);
+struct inclusive_or_expression *inclusive_or_expression_new(void);
+struct exclusive_or_expression *exclusive_or_expression_new(void);
+struct and_expression *and_expression_new(void);
+struct equality_expression *equality_expression_new(void);
+struct relational_expression *relational_expression_new(void);
+struct shift_expression *shift_expression_new(void);
+struct additive_expression *additive_expression_new(void);
+struct multiplicative_expression *multiplicative_expression_new(void);
+struct cast_expression *cast_expression_new(void);
+struct unary_expression *unary_expression_new(void);
+
 #endif /* GRAMMAR_H */