From: Matthias Kruk Date: Tue, 7 Jul 2020 11:41:07 +0000 (+0900) Subject: parser: Add destructors for logical-or-expression, logical-and-expression, inclusive... X-Git-Url: https://git.corax.cc/?a=commitdiff_plain;h=8347ec96d025e96d0696494fb401cf7ffb166bb3;p=ccc parser: Add destructors for logical-or-expression, logical-and-expression, inclusive-or-expression, exclusive-or-expression, and-expression, equality-expression, relational-expression, shift-expression, additive-expression, multiplicative-expression, and cast-expression grammatical structures --- diff --git a/src/grammar.c b/src/grammar.c index 765fde4..e736a0f 100644 --- a/src/grammar.c +++ b/src/grammar.c @@ -456,6 +456,22 @@ struct logical_or_expression *logical_or_expression_new(void) return(loe); } +void logical_or_expression_free(struct logical_or_expression *expr) +{ + if(expr->lorexpr) { + free(expr->lorexpr); + expr->lorexpr = NULL; + } + + if(expr->landexpr) { + free(expr->landexpr); + expr->landexpr = NULL; + } + + free(expr); + return; +} + struct logical_and_expression *logical_and_expression_new(void) { struct logical_and_expression *lae; @@ -469,6 +485,22 @@ struct logical_and_expression *logical_and_expression_new(void) return(lae); } +void logical_and_expression_free(struct logical_and_expression *expr) +{ + if(expr->landexpr) { + free(expr->landexpr); + expr->landexpr = NULL; + } + + if(expr->iorexpr) { + free(expr->iorexpr); + expr->iorexpr = NULL; + } + + free(expr); + return; +} + struct inclusive_or_expression *inclusive_or_expression_new(void) { struct inclusive_or_expression *ioe; @@ -482,6 +514,22 @@ struct inclusive_or_expression *inclusive_or_expression_new(void) return(ioe); } +void inclusive_or_expression_free(struct inclusive_or_expression *expr) +{ + if(expr->iorexpr) { + free(expr->iorexpr); + expr->iorexpr = NULL; + } + + if(expr->xorexpr) { + free(expr->xorexpr); + expr->xorexpr = NULL; + } + + free(expr); + return; +} + struct exclusive_or_expression *exclusive_or_expression_new(void) { struct exclusive_or_expression *eoe; @@ -495,6 +543,22 @@ struct exclusive_or_expression *exclusive_or_expression_new(void) return(eoe); } +void exclusive_or_expression_free(struct exclusive_or_expression *expr) +{ + if(expr->xorexpr) { + free(expr->xorexpr); + expr->xorexpr = NULL; + } + + if(expr->andexpr) { + free(expr->andexpr); + expr->andexpr = NULL; + } + + free(expr); + return; +} + struct and_expression *and_expression_new(void) { struct and_expression *ae; @@ -508,6 +572,22 @@ struct and_expression *and_expression_new(void) return(ae); } +void and_expression_free(struct and_expression *expr) +{ + if(expr->andexpr) { + free(expr->andexpr); + expr->andexpr = NULL; + } + + if(expr->eqexpr){ + free(expr->eqexpr); + expr->eqexpr = NULL; + } + + free(expr); + return; +} + struct equality_expression *equality_expression_new(void) { struct equality_expression *ee; @@ -521,6 +601,22 @@ struct equality_expression *equality_expression_new(void) return(ee); } +void equality_expression_free(struct equality_expression *expr) +{ + if(expr->eqexpr) { + free(expr->eqexpr); + expr->eqexpr = NULL; + } + + if(expr->relexpr) { + free(expr->relexpr); + expr->relexpr = NULL; + } + + free(expr); + return; +} + struct relational_expression *relational_expression_new(void) { struct relational_expression *re; @@ -534,6 +630,22 @@ struct relational_expression *relational_expression_new(void) return(re); } +void relational_expression_free(struct relational_expression *expr) +{ + if(expr->relexpr) { + free(expr->relexpr); + expr->relexpr = NULL; + } + + if(expr->sexpr) { + free(expr->sexpr); + expr->sexpr = NULL; + } + + free(expr); + return; +} + struct shift_expression *shift_expression_new(void) { struct shift_expression *se; @@ -547,6 +659,22 @@ struct shift_expression *shift_expression_new(void) return(se); } +void shift_expression_free(struct shift_expression *expr) +{ + if(expr->sexpr) { + free(expr->sexpr); + expr->sexpr = NULL; + } + + if(expr->addexpr) { + free(expr->addexpr); + expr->addexpr = NULL; + } + + free(expr); + return; +} + struct additive_expression *additive_expression_new(void) { struct additive_expression *ae; @@ -560,6 +688,22 @@ struct additive_expression *additive_expression_new(void) return(ae); } +void additive_expression_free(struct additive_expression *expr) +{ + if(expr->addexpr) { + free(expr->addexpr); + expr->addexpr = NULL; + } + + if(expr->mulexpr) { + free(expr->mulexpr); + expr->mulexpr = NULL; + } + + free(expr); + return; +} + struct multiplicative_expression *multiplicative_expression_new(void) { struct multiplicative_expression *me; @@ -573,6 +717,22 @@ struct multiplicative_expression *multiplicative_expression_new(void) return(me); } +void multiplicative_expression_free(struct multiplicative_expression *expr) +{ + if(expr->mulexpr) { + free(expr->mulexpr); + expr->mulexpr = NULL; + } + + if(expr->castexpr) { + free(expr->castexpr); + expr->castexpr = NULL; + } + + free(expr); + return; +} + struct cast_expression *cast_expression_new(void) { struct cast_expression *ce; @@ -586,6 +746,33 @@ struct cast_expression *cast_expression_new(void) return(ce); } +void cast_expression_free(struct cast_expression *expr) +{ + switch(expr->type) { + case CAST_EXPR_UNARY: + if(expr->data.uexpr) { + free(expr->data.uexpr); + } + break; + + case CAST_EXPR_CAST: + if(expr->data.cast.typename) { + free(expr->data.cast.typename); + } + + if(expr->data.cast.castexpr) { + free(expr->data.cast.castexpr); + } + break; + + default: + break; + } + + free(expr); + return; +} + struct unary_expression *unary_expression_new(void) { struct unary_expression *ue; diff --git a/src/grammar.h b/src/grammar.h index b55e536..9224b16 100644 --- a/src/grammar.h +++ b/src/grammar.h @@ -433,4 +433,16 @@ struct cast_expression *cast_expression_new(void); struct unary_expression *unary_expression_new(void); struct type_name *type_name_new(void); +void logical_or_expression_free(struct logical_or_expression*); +void logical_and_expression_free(struct logical_and_expression*); +void inclusive_or_expression_free(struct inclusive_or_expression*); +void exclusive_or_expression_free(struct exclusive_or_expression*); +void and_expression_free(struct and_expression*); +void equality_expression_free(struct equality_expression*); +void relational_expression_free(struct relational_expression*); +void shift_expression_free(struct shift_expression*); +void additive_expression_free(struct additive_expression*); +void multiplicative_expression_free(struct multiplicative_expression*); +void cast_expression_free(struct cast_expression*); + #endif /* GRAMMAR_H */