From: Matthias Kruk <m@m10k.eu>
Date: Sat, 11 Jul 2020 07:16:41 +0000 (+0900)
Subject: parser: Add several constructors and destructors for grammatical structures
X-Git-Url: https://git.corax.cc/?a=commitdiff_plain;h=761dc0a2ecce9ee0757c967fcf5e5e162aa3512b;p=ccc

parser: Add several constructors and destructors for grammatical structures
---

diff --git a/src/grammar.c b/src/grammar.c
index e736a0f..f281d79 100644
--- a/src/grammar.c
+++ b/src/grammar.c
@@ -327,6 +327,11 @@ struct identifier *identifier_new(void)
 	return(id);
 }
 
+void identifier_free(struct identifier *id)
+{
+	free(id);
+}
+
 struct string *string_new(void)
 {
 	struct string *s;
@@ -353,6 +358,22 @@ struct argument_expression_list* argument_expression_list_new(void)
 	return(aelist);
 }
 
+void argument_expression_list_free(struct argument_expression_list *list)
+{
+	if(list->aexpr) {
+		assignment_expression_free(list->aexpr);
+	}
+
+	if(list->next) {
+		argument_expression_list_free(list->next);
+	}
+
+	memset(list, 0, sizeof(*list));
+	free(list);
+
+	return;
+}
+
 void constant_debug(struct constant *cnst)
 {
 	static const char *_const_type_str[] = {
@@ -404,6 +425,34 @@ void string_debug(struct string *s)
 	return;
 }
 
+struct expression *expression_new(void)
+{
+	struct expression *expr;
+
+	expr = malloc(sizeof(*expr));
+
+	if(expr) {
+		memset(expr, 0, sizeof(*expr));
+	}
+
+	return(expr);
+}
+
+void expression_free(struct expression *expr)
+{
+	if(expr->expr) {
+		expression_free(expr->expr);
+	}
+
+	if(expr->aexpr) {
+		assignment_expression_free(expr->aexpr);
+	}
+
+	free(expr);
+
+	return;
+}
+
 struct assignment_expression *assignment_expression_new(void)
 {
 	struct assignment_expression *ae;
@@ -417,6 +466,36 @@ struct assignment_expression *assignment_expression_new(void)
 	return(ae);
 }
 
+void assignment_expression_free(struct assignment_expression *expr)
+{
+	switch(expr->type) {
+	case ASSIGNMENT_EXPR_CONDITIONAL:
+		if(expr->data.cexpr) {
+			conditional_expression_free(expr->data.cexpr);
+		}
+
+		break;
+
+	case ASSIGNMENT_EXPR_ASSIGNMENT:
+		if(expr->data.aexpr.uexpr) {
+			unary_expression_free(expr->data.aexpr.uexpr);
+		}
+
+		if(expr->data.aexpr.aexpr) {
+			assignment_expression_free(expr->data.aexpr.aexpr);
+		}
+
+		break;
+
+	default:
+		break;
+	}
+
+	memset(expr, 0, sizeof(*expr));
+
+	return;
+}
+
 struct conditional_expression *conditional_expression_new(void)
 {
 	struct conditional_expression *ce;
@@ -786,6 +865,54 @@ struct unary_expression *unary_expression_new(void)
 	return(ue);
 }
 
+void unary_expression_free(struct unary_expression *expr)
+{
+	switch(expr->type) {
+	case UNARY_EXPR_POSTFIX:
+		if(expr->data.postfix) {
+			postfix_expression_free(expr->data.postfix);
+		}
+
+		break;
+
+	case UNARY_EXPR_PREFIX:
+		if(expr->data.prefix.uexpr) {
+			unary_expression_free(expr->data.prefix.uexpr);
+		}
+
+		break;
+
+	case UNARY_EXPR_CAST:
+		if(expr->data.cast.castexpr) {
+			cast_expression_free(expr->data.cast.castexpr);
+		}
+
+		break;
+
+	case UNARY_EXPR_SIZEOF_UNARY:
+		if(expr->data.sizeof_unary.uexpr) {
+			unary_expression_free(expr->data.sizeof_unary.uexpr);
+		}
+
+		break;
+
+	case UNARY_EXPR_SIZEOF_TYPE:
+		if(expr->data.sizeof_type.typename) {
+			type_name_free(expr->data.sizeof_type.typename);
+		}
+
+		break;
+
+	default:
+		break;
+	}
+
+	memset(expr, 0, sizeof(*expr));
+	free(expr);
+
+	return;
+}
+
 struct type_name *type_name_new(void)
 {
 	struct type_name *tn;
@@ -798,3 +925,524 @@ struct type_name *type_name_new(void)
 
 	return(tn);
 }
+
+void type_name_free(struct type_name *name)
+{
+	if(name->sqlist) {
+		specifier_qualifier_list_free(name->sqlist);
+	}
+
+	if(name->absdecl) {
+		abstract_declarator_free(name->absdecl);
+	}
+
+	memset(name, 0, sizeof(*name));
+	free(name);
+
+	return;
+}
+
+struct postfix_expression* postfix_expression_new(void)
+{
+	struct postfix_expression *expr;
+
+	expr = malloc(sizeof(*expr));
+
+	if(expr) {
+		memset(expr, 0, sizeof(*expr));
+	}
+
+	return(expr);
+}
+
+void postfix_expression_free(struct postfix_expression *expr)
+{
+	switch(expr->type) {
+	case POSTFIX_EXPR_PRIMARY:
+		if(expr->data.primary) {
+			primary_expression_free(expr->data.primary);
+			expr->data.primary = NULL;
+		}
+
+		break;
+
+	case POSTFIX_EXPR_INDEX:
+		if(expr->data.index.pfexpr) {
+			postfix_expression_free(expr->data.index.pfexpr);
+			expr->data.index.pfexpr = NULL;
+		}
+
+		if(expr->data.index.expr) {
+			expression_free(expr->data.index.expr);
+			expr->data.index.expr = NULL;
+		}
+
+		expr->data.index.lbracket = NULL;
+		expr->data.index.rbracket = NULL;
+
+		break;
+
+	case POSTFIX_EXPR_CALL:
+		if(expr->data.call.pfexpr) {
+			postfix_expression_free(expr->data.call.pfexpr);
+			expr->data.call.pfexpr = NULL;
+		}
+
+		if(expr->data.call.args) {
+			argument_expression_list_free(expr->data.call.args);
+			expr->data.call.args = NULL;
+		}
+
+		expr->data.call.lparen = NULL;
+		expr->data.call.rparen = NULL;
+
+		break;
+
+	case POSTFIX_EXPR_MEMBER:
+		if(expr->data.member.pfexpr) {
+			postfix_expression_free(expr->data.member.pfexpr);
+			expr->data.member.pfexpr = NULL;
+		}
+
+		if(expr->data.member.ident) {
+			identifier_free(expr->data.member.ident);
+			expr->data.member.ident = NULL;
+		}
+
+		expr->data.member.op = NULL;
+
+		break;
+
+	case POSTFIX_EXPR_INCDEC:
+		if(expr->data.incdec.pfexpr) {
+			postfix_expression_free(expr->data.incdec.pfexpr);
+			expr->data.incdec.pfexpr = NULL;
+		}
+
+		expr->data.incdec.op = NULL;
+
+		break;
+
+	default:
+		break;
+	}
+
+	free(expr);
+
+	return;
+}
+
+struct specifier_qualifier_list *specifier_qualifier_list_new(void)
+{
+	struct specifier_qualifier_list *sql;
+
+	sql = malloc(sizeof(*sql));
+
+	if(sql) {
+		memset(sql, 0, sizeof(*sql));
+	}
+
+	return(sql);
+}
+
+void specifier_qualifier_list_free(struct specifier_qualifier_list *sql)
+{
+	switch(sql->type) {
+	case SQ_LIST_TYPE_SPECIFIER_LIST:
+		if(sql->data.tspec) {
+			type_specifier_free(sql->data.tspec);
+		}
+
+		break;
+
+	case SQ_LIST_TYPE_QUALIFIER_LIST:
+		if(sql->data.tqual) {
+			type_qualifier_free(sql->data.tqual);
+		}
+
+		break;
+
+	default:
+		break;
+	}
+
+	if(sql->next) {
+		specifier_qualifier_list_free(sql->next);
+	}
+
+	memset(sql, 0, sizeof(*sql));
+	free(sql);
+
+	return;
+}
+
+void type_specifier_free(struct type_specifier *tspec)
+{
+	switch(tspec->type) {
+	case TYPE_SPECIFIER_STRUCT:
+	case TYPE_SPECIFIER_UNION:
+		if(tspec->data.su) {
+			struct_union_specifier_free(tspec->data.su);
+		}
+
+		break;
+
+	case TYPE_SPECIFIER_ENUM:
+		if(tspec->data.es) {
+			enum_specifier_free(tspec->data.es);
+		}
+
+		break;
+
+	case TYPE_SPECIFIER_TYPEDEF:
+		if(tspec->data.tn) {
+			typedef_name_free(tspec->data.tn);
+		}
+
+		break;
+
+	default:
+		break;
+	}
+
+	memset(tspec, 0, sizeof(*tspec));
+	free(tspec);
+
+	return;
+}
+
+void type_qualifier_free(struct type_qualifier *tqual)
+{
+	memset(tqual, 0, sizeof(*tqual));
+	free(tqual);
+
+	return;
+}
+
+struct struct_union_specifier *struct_union_specifier_new(void)
+{
+	struct struct_union_specifier *sus;
+
+	sus = malloc(sizeof(*sus));
+
+	if(sus) {
+		memset(sus, 0, sizeof(*sus));
+	}
+
+	return(sus);
+}
+
+void struct_union_specifier_free(struct struct_union_specifier *sus)
+{
+	if(sus->identifier) {
+		identifier_free(sus->identifier);
+	}
+
+	if(sus->sdecl) {
+		struct_declaration_list_free(sus->sdecl);
+	}
+
+	memset(sus, 0, sizeof(*sus));
+	free(sus);
+
+	return;
+}
+
+struct struct_declaration_list *struct_declaration_list_new(void)
+{
+	struct struct_declaration_list *sdl;
+
+	sdl = malloc(sizeof(*sdl));
+
+	if(sdl) {
+		memset(sdl, 0, sizeof(*sdl));
+	}
+
+	return(sdl);
+}
+
+void struct_declaration_list_free(struct struct_declaration_list *sdecl)
+{
+	if(sdecl->decl) {
+		struct_declaration_free(sdecl->decl);
+	}
+
+	if(sdecl->next) {
+		struct_declaration_list_free(sdecl->next);
+	}
+
+	memset(sdecl, 0, sizeof(*sdecl));
+	free(sdecl);
+
+	return;
+}
+
+void struct_declaration_free(struct struct_declaration *sdecl)
+{
+	if(sdecl->sqlist) {
+		specifier_qualifier_list_free(sdecl->sqlist);
+	}
+
+	if(sdecl->sdecl) {
+		struct_declarator_list_free(sdecl->sdecl);
+	}
+
+	memset(sdecl, 0, sizeof(*sdecl));
+	free(sdecl);
+
+	return;
+}
+
+struct struct_declarator_list *struct_declarator_list_new(void)
+{
+	struct struct_declarator_list *sdl;
+
+	sdl = malloc(sizeof(*sdl));
+
+	if(sdl) {
+		memset(sdl, 0, sizeof(*sdl));
+	}
+
+	return(sdl);
+}
+
+void struct_declarator_list_free(struct struct_declarator_list *sdecl)
+{
+	if(sdecl->sdecl) {
+		struct_declarator_free(sdecl->sdecl);
+	}
+
+	if(sdecl->next) {
+		struct_declarator_list_free(sdecl->next);
+	}
+
+	memset(sdecl, 0, sizeof(*sdecl));
+	free(sdecl);
+
+	return;
+}
+
+struct struct_declarator *struct_declarator_new(void)
+{
+	struct struct_declarator *sd;
+
+	sd = malloc(sizeof(*sd));
+
+	if(sd) {
+		memset(sd, 0, sizeof(*sd));
+	}
+
+	return(sd);
+}
+
+void struct_declarator_free(struct struct_declarator *decl)
+{
+	if(decl->decl) {
+		declarator_free(decl->decl);
+	}
+
+	if(decl->cexpr) {
+		constant_expression_free(decl->cexpr);
+	}
+
+	memset(decl, 0, sizeof(*decl));
+	free(decl);
+
+	return;
+}
+
+struct direct_abstract_declarator *direct_abstract_declarator_new(void)
+{
+	struct direct_abstract_declarator *decl;
+
+	decl = malloc(sizeof(*decl));
+
+	if(decl) {
+		memset(decl, 0, sizeof(*decl));
+	}
+
+	return(decl);
+}
+
+void direct_abstract_declarator_free(struct direct_abstract_declarator *decl)
+{
+	fprintf(stderr, "FIXME: %s() not implemented\n", __func__);
+	return;
+}
+
+struct abstract_declarator *abstract_declarator_new(void)
+{
+	struct abstract_declarator *decl;
+
+	decl = malloc(sizeof(*decl));
+
+	if(decl) {
+		memset(decl, 0, sizeof(*decl));
+	}
+
+	return(decl);
+}
+
+void abstract_declarator_free(struct abstract_declarator *decl)
+{
+	if(decl->pointer) {
+		pointer_free(decl->pointer);
+	}
+
+	if(decl->dadecl) {
+		direct_abstract_declarator_free(decl->dadecl);
+	}
+
+	memset(decl, 0, sizeof(*decl));
+	free(decl);
+
+	return;
+}
+
+struct pointer *pointer_new(void)
+{
+	struct pointer *ptr;
+
+	ptr = malloc(sizeof(*ptr));
+
+	if(ptr) {
+		memset(ptr, 0, sizeof(*ptr));
+	}
+
+	return(ptr);
+}
+
+void pointer_free(struct pointer *ptr)
+{
+	memset(ptr, 0, sizeof(*ptr));
+	free(ptr);
+}
+
+struct enum_specifier *enum_specifier_new(void)
+{
+	struct enum_specifier *espec;
+
+	espec = malloc(sizeof(*espec));
+
+	if(espec) {
+		memset(espec, 0, sizeof(*espec));
+	}
+
+	return(espec);
+}
+
+void enum_specifier_free(struct enum_specifier *espec)
+{
+	if(espec->identifier) {
+		identifier_free(espec->identifier);
+	}
+
+	if(espec->enum_list) {
+		enumerator_list_free(espec->enum_list);
+	}
+
+	memset(espec, 0, sizeof(*espec));
+	free(espec);
+
+	return;
+}
+
+struct typedef_name *typedef_name_new(void)
+{
+	struct typedef_name *name;
+
+	name = malloc(sizeof(*name));
+
+	if(name) {
+		memset(name, 0, sizeof(*name));
+	}
+
+	return(name);
+}
+
+void typedef_name_free(struct typedef_name *name)
+{
+	memset(name, 0, sizeof(*name));
+	free(name);
+
+	return;
+}
+
+struct declarator *declarator_new(void)
+{
+	struct declarator *decl;
+
+	decl = malloc(sizeof(*decl));
+
+	if(decl) {
+		memset(decl, 0, sizeof(*decl));
+	}
+
+	return(decl);
+}
+
+void declarator_free(struct declarator *decl)
+{
+	memset(decl, 0, sizeof(*decl));
+	free(decl);
+
+	return;
+}
+
+struct enumerator_list *enumerator_list_new(void)
+{
+	struct enumerator_list *elist;
+
+	elist = malloc(sizeof(*elist));
+
+	if(elist) {
+		memset(elist, 0, sizeof(*elist));
+	}
+
+	return(elist);
+}
+
+void enumerator_list_free(struct enumerator_list *elist)
+{
+	if(elist->en) {
+		enumerator_free(elist->en);
+	}
+
+	if(elist->next) {
+		enumerator_list_free(elist->next);
+	}
+
+	memset(elist, 0, sizeof(*elist));
+	free(elist);
+
+	return;
+}
+
+struct enumerator *enumerator_new(void)
+{
+	struct enumerator *en;
+
+	en = malloc(sizeof(*en));
+
+	if(en) {
+		memset(en, 0, sizeof(*en));
+	}
+
+	return(en);
+}
+
+void enumerator_free(struct enumerator *en)
+{
+	if(en->identifier) {
+		identifier_free(en->identifier);
+	}
+
+	if(en->cexpr) {
+		constant_expression_free(en->cexpr);
+	}
+
+	memset(en, 0, sizeof(*en));
+	free(en);
+
+	return;
+}
diff --git a/src/grammar.h b/src/grammar.h
index 9224b16..59dc61a 100644
--- a/src/grammar.h
+++ b/src/grammar.h
@@ -32,6 +32,53 @@ struct string {
 	struct token *token;
 };
 
+struct expression {
+	struct expression *expr;
+	struct token *comma;
+	struct assignment_expression *aexpr;
+};
+
+enum postfix_expression_type {
+	POSTFIX_EXPR_INVALID,
+	POSTFIX_EXPR_PRIMARY,
+	POSTFIX_EXPR_INDEX,
+	POSTFIX_EXPR_CALL,
+	POSTFIX_EXPR_MEMBER,
+	POSTFIX_EXPR_INCDEC
+};
+
+struct postfix_expression {
+	enum postfix_expression_type type;
+
+	union {
+		struct primary_expression *primary;
+		struct {
+			struct postfix_expression *pfexpr;
+			struct token *lbracket;
+			struct expression *expr;
+			struct token *rbracket;
+		} index;
+
+		struct {
+			struct postfix_expression *pfexpr;
+			struct token *lparen;
+			struct argument_expression_list *args;
+			struct token *rparen;
+		} call;
+
+		struct {
+			struct postfix_expression *pfexpr;
+			struct token *op;
+			struct identifier *ident;
+		} member;
+
+		struct {
+			struct postfix_expression *pfexpr;
+			struct token *op;
+		} incdec;
+	} data;
+};
+
 enum unary_expression_type {
 	UNARY_EXPR_INVALID,
 	UNARY_EXPR_POSTFIX,
@@ -41,6 +88,19 @@ enum unary_expression_type {
 	UNARY_EXPR_SIZEOF_TYPE
 };
 
+struct pointer {
+
+};
+
+struct direct_abstract_declarator {
+
+};
+
+struct abstract_declarator {
+	struct pointer *pointer;
+	struct direct_abstract_declarator *dadecl;
+};
+
 struct type_name {
 	struct specifier_qualifier_list *sqlist;
 	struct abstract_declarator *absdecl;
@@ -189,7 +249,7 @@ struct assignment_expression {
 };
 
 struct argument_expression_list {
-	struct assigment_expression *aexpr;
+	struct assignment_expression *aexpr;
 	struct argument_expression_list *next;
 };
 
@@ -273,6 +333,12 @@ struct specifier_qualifier_list {
 	struct specifier_qualifier_list *next;
 };
 
+struct struct_declarator {
+	struct declarator *decl;
+	struct token *colon;
+	struct constant_expression *cexpr;
+};
+
 struct struct_declarator_list {
 	struct struct_declarator *sdecl;
 	struct struct_declarator_list *next;
@@ -321,8 +387,7 @@ struct type_specifier {
 
 	union {
 		struct token *token;
-		struct struct_specifier *ss;
-		struct union_specifier *us;
+		struct struct_union_specifier *su;
 		struct enum_specifier *es;
 		struct typedef_name *tn;
 	} data;
@@ -381,23 +446,24 @@ struct translation_unit {
 };
 
 struct primary_expression *primary_expression_new(void);
+void primary_expression_free(struct primary_expression*);
 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);
 struct enumeration_constant *enumeration_constant_new(void);
+
 struct argument_expression_list *argument_expression_list_new(void);
+void argument_expression_list_free(struct argument_expression_list*);
 
 struct function_definition *function_definition_new(void);
 
 struct type_qualifier *type_qualifier_new(struct token*);
+void type_qualifier_free(struct type_qualifier*);
 int type_qualifier_to_string(struct type_qualifier*, char*, size_t);
 
 struct storage_class_specifier *storage_class_specifier_new(struct token*);
-struct type_specifier *type_specifier_new(void);
 struct translation_unit *translation_unit_new(struct external_declaration*);
 struct external_declaration *external_declaration_new(void);
 
@@ -405,6 +471,7 @@ struct declaration_specifiers* declaration_specifiers_new(void);
 void declaration_specifiers_debug(struct declaration_specifiers*);
 
 struct constant *constant_new(void);
+
 struct integer_constant *integer_constant_new(void);
 struct character_constant *character_constant_new(void);
 struct floating_constant *floating_constant_new(void);
@@ -412,37 +479,105 @@ struct enumeration_constant *enueration_constant_new(void);
 struct string *string_new(void);
 
 struct identifier* identifier_new(void);
+void identifier_free(struct identifier*);
 
 void constant_debug(struct constant*);
 void string_debug(struct string*);
 
 struct assignment_expression *assignment_expression_new(void);
+void assignment_expression_free(struct assignment_expression*);
+
 struct conditional_expression *conditional_expression_new(void);
+void conditional_expression_free(struct conditional_expression*);
+
 struct constant_expression *constant_expression_new(void);
+void constant_expression_free(struct constant_expression*);
+
 struct logical_or_expression *logical_or_expression_new(void);
+void logical_or_expression_free(struct logical_or_expression*);
+
 struct logical_and_expression *logical_and_expression_new(void);
+void logical_and_expression_free(struct logical_and_expression*);
+
 struct inclusive_or_expression *inclusive_or_expression_new(void);
+void inclusive_or_expression_free(struct inclusive_or_expression*);
+
 struct exclusive_or_expression *exclusive_or_expression_new(void);
+void exclusive_or_expression_free(struct exclusive_or_expression*);
+
 struct and_expression *and_expression_new(void);
+void and_expression_free(struct and_expression*);
+
 struct equality_expression *equality_expression_new(void);
+void equality_expression_free(struct equality_expression*);
+
 struct relational_expression *relational_expression_new(void);
+void relational_expression_free(struct relational_expression*);
+
 struct shift_expression *shift_expression_new(void);
+void shift_expression_free(struct shift_expression*);
+
 struct additive_expression *additive_expression_new(void);
+void additive_expression_free(struct additive_expression*);
+
 struct multiplicative_expression *multiplicative_expression_new(void);
+void multiplicative_expression_free(struct multiplicative_expression*);
+
 struct cast_expression *cast_expression_new(void);
+void cast_expression_free(struct cast_expression*);
+
 struct unary_expression *unary_expression_new(void);
+void unary_expression_free(struct unary_expression*);
+
 struct type_name *type_name_new(void);
+void type_name_free(struct type_name*);
 
-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*);
+struct postfix_expression *postfix_expression_new(void);
+void postfix_expression_free(struct postfix_expression*);
+
+struct specifier_qualifier_list *specifier_qualifier_list_new(void);
+void specifier_qualifier_list_free(struct specifier_qualifier_list*);
+
+struct direct_abstract_declarator *direct_abstract_declarator_new(void);
+void direct_abstract_declarator_free(struct direct_abstract_declarator*);
+
+struct abstract_declarator *abstract_declarator_new(void);
+void abstract_declarator_free(struct abstract_declarator*);
+
+struct pointer *pointer_new(void);
+void pointer_free(struct pointer*);
+
+struct type_specifier *type_specifier_new(void);
+void type_specifier_free(struct type_specifier*);
+
+struct struct_union_specifier *struct_union_specifier_new(void);
+void struct_union_specifier_free(struct struct_union_specifier*);
+
+struct enum_specifier *enum_specifier_new(void);
+void enum_specifier_free(struct enum_specifier*);
+
+struct typedef_name *typedef_name_new(void);
+void typedef_name_free(struct typedef_name*);
+
+struct struct_declarator *struct_declarator_new(void);
+void struct_declarator_free(struct struct_declarator*);
+
+struct struct_declarator_list *struct_declarator_list_new(void);
+void struct_declarator_list_free(struct struct_declarator_list*);
+
+struct struct_declaration *struct_declaration_new(void);
+void struct_declaration_free(struct struct_declaration*);
+
+struct struct_declaration_list *struct_declaration_list_new(void);
+void struct_declaration_list_free(struct struct_declaration_list*);
+
+struct declarator *declarator_new(void);
+void declarator_free(struct declarator*);
+
+struct enumerator *enumerator_new(void);
+void enumerator_free(struct enumerator*);
+
+struct enumerator_list *enumerator_list_new(void);
+void enumerator_list_free(struct enumerator_list*);
 
 #endif /* GRAMMAR_H */