parser: Add destructors for logical-or-expression, logical-and-expression, inclusive...

diff --git a/src/grammar.c b/src/grammar.c
index 765fde4a0dbacde187345c72e5d1ce36cc0c7a85..e736a0fe5f3e27887f8fe8fe4e23b37afcbf5f90 100644 (file)
--- 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 b55e53676f67deea598d383dc13a6238142c1907..9224b16ff89dfa1a39aa931ce8f4819fb71ac619 100644 (file)
--- 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 */