parser: Implement parsing of postfix expressions

diff --git a/src/parser.c b/src/parser.c
index 1743595525413e94440ac197e5fcbc2302900fb5..f89ee12b07dcbbc97dda1d371c891fb1a344c5c0 100644 (file)
--- a/src/parser.c
+++ b/src/parser.c
@@ -64,16 +64,19 @@ struct storage_class_specifier *parse_storage_class_specifier(void)
 
 struct struct_union_specifier *parse_struct_union_specifier(void)
 {
+       fprintf(stderr, "FIXME: %s() is not implemented\n", __func__);
        return(NULL);
 }
 
 struct enum_specifier *parse_enum_specifier(void)
 {
+       fprintf(stderr, "FIXME: %s() is not implemented\n", __func__);
        return(NULL);
 }
 
 struct typedef_name *parse_typedef_name(void)
 {
+       fprintf(stderr, "FIXME: %s() is not implemented\n", __func__);
        return(NULL);
 }
 
@@ -282,21 +285,25 @@ gtfo:
 
 struct declaration_list *parse_declaration_list(void)
 {
+       fprintf(stderr, "FIXME: %s() is not implemented\n", __func__);
        return(NULL);
 }
 
 struct compound_statement *parse_compound_statement(void)
 {
+       fprintf(stderr, "FIXME: %s() is not implemented\n", __func__);
        return(NULL);
 }
 
 struct declarator *parse_declarator(void)
 {
+       fprintf(stderr, "FIXME: %s() is not implemented\n", __func__);
        return(NULL);
 }
 
 struct declaration *parse_declaration(void)
 {
+       fprintf(stderr, "FIXME: %s() is not implemented\n", __func__);
        return(NULL);
 }
 
@@ -490,6 +497,7 @@ struct floating_constant *parse_floating_constant(void)
 
 struct enumeration_constant *parse_enumeration_constant(void)
 {
+       fprintf(stderr, "FIXME: %s() is not implemented\n", __func__);
        /* TODO: Implement parsing of enumeration constants */
        return(NULL);
 }
@@ -543,7 +551,7 @@ struct string *parse_string(void)
 struct expression *parse_expression(void)
 {
        /* TODO: Implement parsing of expressions */
-
+       fprintf(stderr, "FIXME: %s() is not implemented\n", __func__);
        return(NULL);
 }
 
@@ -830,6 +838,7 @@ struct cast_expression *parse_cast_expression(void)
 
 struct type_name *parse_type_name(void)
 {
+       fprintf(stderr, "FIXME: %s() is not implemented\n", __func__);
        return(NULL);
 }
 
@@ -1153,5 +1162,122 @@ struct multiplicative_expression *parse_multiplicative_expression(void)
 
 struct postfix_expression *parse_postfix_expression(void)
 {
+       struct postfix_expression *expr;
+       int pos;
+
+       expr = postfix_expression_new();
+
+       if(!expr) {
+               return(NULL);
+       }
+
+       if((expr->data.primary = parse_primary_expression())) {
+               expr->type = POSTFIX_EXPR_PRIMARY;
+               return(expr);
+       }
+
+       pos = lex_getpos();
+
+       expr->data.index.pfexpr = parse_postfix_expression();
+       expr->data.index.lbracket = lex_gettoken();
+       expr->data.index.expr = parse_expression();
+       expr->data.index.rbracket = lex_gettoken();
+
+       if(expr->data.index.pfexpr && expr->data.index.lbracket && expr->data.index.expr &&
+          expr->data.index.rbracket && expr->data.index.lbracket->type == TOKEN_LBRACKET &&
+          expr->data.index.rbracket->type == TOKEN_RBRACKET) {
+               expr->type = POSTFIX_EXPR_INDEX;
+               return(expr);
+       }
+
+       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;
+
+       lex_setpos(pos);
+
+       expr->data.call.pfexpr = parse_postfix_expression();
+       expr->data.call.lparen = lex_gettoken();
+       expr->data.call.args = parse_argument_expression_list();
+       expr->data.call.rparen = lex_gettoken();
+
+       if(expr->data.call.pfexpr && expr->data.call.lparen && expr->data.call.args && expr->data.call.rparen &&
+          expr->data.call.lparen->type == TOKEN_LPAREN && expr->data.call.rparen->type == TOKEN_RPAREN) {
+               expr->type = POSTFIX_EXPR_CALL;
+               return(expr);
+       }
+
+       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;
+
+       lex_setpos(pos);
+
+       expr->data.member.pfexpr = parse_postfix_expression();
+       expr->data.member.op = lex_gettoken();
+       expr->data.member.identifier = parse_identifier();
+
+       if(expr->data.member.pfexpr && expr->data.member.op &&
+          expr->data.member.identifier && (expr->data.member.op->type == TOKEN_DMEMBER ||
+                                           expr->data.member.op->type == TOKEN_MEMBER)) {
+               expr->type = POSTFIX_EXPR_MEMBER;
+               return(expr);
+       }
+
+       if(expr->data.member.pfexpr) {
+               postfix_expression_free(expr->data.member.pfexpr);
+               expr->data.member.pfexpr = NULL;
+       }
+
+       if(expr->data.member.identifier) {
+               identifier_free(expr->data.member.identifier);
+               expr->data.member.identifier = NULL;
+       }
+
+       expr->data.member.op = NULL;
+
+       lex_setpos(pos);
+
+       expr->data.incdec.pfexpr = parse_postfix_expression();
+       expr->data.incdec.op = lex_gettoken();
+
+       if(expr->data.incdec.pfexpr && expr->data.incdec.op && (expr->data.incdec.op->type == TOKEN_INC ||
+                                                               expr->data.incdec.op->type == TOKEN_DEC)) {
+               expr->type = POSTFIX_EXPR_INCDEC;
+               return(expr);
+       }
+
+       if(expr->data.incdec.pfexpr) {
+               postfix_expression_free(expr->data.incdec.pfexpr);
+               expr->data.incdec.pfexpr = NULL;
+       }
+
+       lex_setpos(pos);
+       free(expr);
+
+       return(NULL);
+}
+
+struct argument_expression_list *parse_argument_expression_list(void)
+{
+       fprintf(stderr, "FIXME: %s() is not implemented\n", __func__);
        return(NULL);
 }

diff --git a/src/parser.h b/src/parser.h
index f1d51ef4827bac37c9346a89fefb2279769e4ebc..d389b8d518b76056ce606642165fc937dcfa7ae6 100644 (file)
--- a/src/parser.h
+++ b/src/parser.h
@@ -23,6 +23,7 @@ struct additive_expression *parse_additive_expression(void);
 struct multiplicative_expression *parse_multiplicative_expression(void);
 struct cast_expression *parse_cast_expression(void);
 struct postfix_expression *parse_postfix_expression(void);
+struct argument_expression_list *parse_argument_expression_list(void);
 
 struct unary_expression *parse_unary_expression(void);
 struct conditional_expression *parse_conditional_expression(void);