From: Matthias Kruk Date: Sun, 5 Jul 2020 07:28:25 +0000 (+0900) Subject: parser: Add various grammatical types and allocator functions X-Git-Url: https://git.corax.cc/?a=commitdiff_plain;h=739efdeff20e12d37746da26918ab7a5d7c44a27;p=ccc parser: Add various grammatical types and allocator functions --- diff --git a/src/grammar.c b/src/grammar.c index b83e557..aee957f 100644 --- 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 fbaca9c..3979f12 100644 --- 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 */