return(id);
}
+void identifier_free(struct identifier *id)
+{
+ free(id);
+}
+
struct string *string_new(void)
{
struct string *s;
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[] = {
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;
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;
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;
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;
+}
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,
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;
};
struct argument_expression_list {
- struct assigment_expression *aexpr;
+ struct assignment_expression *aexpr;
struct argument_expression_list *next;
};
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;
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;
};
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);
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);
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 */
projects / ccc / commitdiff