parser.c

#include <stdio.h>
#include "kcc.h"
#include "parser.h"
 
Parser *parser_create(Lexer *lexer) {
    Parser *parser = malloc(sizeof(Parser));
    if (!parser) {
        error_fatal("Memory allocation failed for parser");
        return NULL;
    }
 
    parser->lexer = lexer;
    parser->current_token = lexer_next_token(lexer);
    parser->peek_token = lexer_next_token(lexer);
 
    return parser;
}
 
void parser_destroy(Parser *parser) {
    if (parser) {
        free(parser);
    }
}
 
void parser_advance(Parser *parser) {
    parser->current_token = parser->peek_token;
    parser->peek_token = lexer_next_token(parser->lexer);
}
 
bool parser_match(Parser *parser, TokenType type) {
    return parser->current_token.type == type;
}
 
bool parser_expect(Parser *parser, TokenType type) {
    if (parser_match(parser, type)) {
        parser_advance(parser);
        return true;
    } else {
        error_syntax(parser->current_token.line, parser->current_token.column,
                    "Expected %s, got %s",
                    token_type_to_string(type),
                    token_type_to_string(parser->current_token.type));
        return false;
    }
}
 
bool parser_is_type_specifier(TokenType type) {
    return type == TOKEN_INT || type == TOKEN_CHAR_KW || type == TOKEN_VOID;
}
 
DataType parser_parse_type_specifier(Parser *parser) {
    DataType type = token_to_data_type(parser->current_token.type);
    if (type != TYPE_UNKNOWN) {
        parser_advance(parser);
        return type;
    }
 
    error_syntax(parser->current_token.line, parser->current_token.column,
                "Expected type specifier");
    return TYPE_UNKNOWN;
}
 
// Helper function to convert TokenType to DataType
DataType token_type_to_data_type(TokenType type) {
    switch (type) {
    case TOKEN_INT:      return TYPE_INT;
    case TOKEN_CHAR_KW:  return TYPE_CHAR;
    case TOKEN_VOID:     return TYPE_VOID;
    default:             return TYPE_UNKNOWN;
    }
}
 
ASTNode *parser_parse_program(Parser *parser) {
    ASTNode *program = ast_create_program();
 
    while (!parser_match(parser, TOKEN_EOF)) {
        // Skip any UNKNOWN tokens
        if (parser->current_token.type == TOKEN_UNKNOWN) {
            parser_advance(parser);
            continue;
        }
 
        ASTNode *declaration = parser_parse_declaration(parser);
 
        if (declaration) {
            ast_add_declaration(program, declaration);
        } else {
            // Skip to next potential declaration
            while (!parser_match(parser, TOKEN_EOF) &&
                   !parser_is_type_specifier(parser->current_token.type)) {
                parser_advance(parser);
            }
        }
    }
 
    return program;
}
 
ASTNode *parser_parse_declaration(Parser *parser) {
    // Parse type specifier (int, char, etc.)
    if (!parser_is_type_specifier(parser->current_token.type)) {
        // Don't call parser_error if it doesn't exist - handle gracefully
        return NULL;
    }
 
    TokenType type_token = parser->current_token.type;
    DataType data_type = token_type_to_data_type(type_token);
    parser_advance(parser);
 
    // Parse identifier
    if (parser->current_token.type != TOKEN_IDENTIFIER) {
        return NULL;
    }
 
    char *name = strdup(parser->current_token.value);
    parser_advance(parser);
 
    // Check what comes after the identifier
    if (parser->current_token.type == TOKEN_LPAREN) {
        // This is a function (declaration or definition)
        ASTNode *result = parser_parse_function(parser, data_type, name);
        free(name);
        return result;
    } else if (parser->current_token.type == TOKEN_SEMICOLON) {
        // This is a variable declaration
        parser_advance(parser); // consume semicolon
        ASTNode *result = parser_create_variable_declaration(data_type, name);
        free(name);
        return result;
    } else {
        // Handle error gracefully
        free(name);
        return NULL;
    }
}
 
ASTNode *parser_parse_function(Parser *parser, DataType return_type, char *name) {
    // Expect '('
    if (parser->current_token.type != TOKEN_LPAREN) {
        return NULL;
    }
    parser_advance(parser);
 
    // Parse parameters (for now, just handle empty parameter list)
    if (parser->current_token.type != TOKEN_RPAREN) {
        // Skip parameters for now - advance until we find ')'
        while (parser->current_token.type != TOKEN_RPAREN &&
               parser->current_token.type != TOKEN_EOF) {
            parser_advance(parser);
        }
    }
 
    if (parser->current_token.type == TOKEN_RPAREN) {
        parser_advance(parser); // consume ')'
    }
 
    // Check if this is a declaration or definition
    if (parser->current_token.type == TOKEN_SEMICOLON) {
        // Function declaration: int func();
        parser_advance(parser);
        return parser_create_function_declaration(return_type, name);
    } else if (parser->current_token.type == TOKEN_LBRACE) {
        // Function definition: int func() { ... }
        return parser_parse_function_definition(parser, return_type, name);
    } else {
        return NULL;
    }
}
 
ASTNode *parser_parse_function_definition(Parser *parser, DataType return_type, char *name) {
    // Parse the function body
    ASTNode *body = parser_parse_compound_statement(parser);
    if (!body) {
        return NULL;
    }
 
    // Create a function declaration node with body
    ASTNode *func = parser_create_function_declaration(return_type, name);
    if (func) {
        // If your AST supports function definitions, set the body here
        // This depends on your AST structure
        // func->data.function.body = body; // Adjust according to your AST
    }
 
    return func;
}
 
// Helper function to create function declaration
ASTNode *parser_create_function_declaration(DataType return_type, const char *name) {
    // This should match your AST creation functions
    // Adjust according to your actual AST API
    return ast_create_function_decl(return_type, name, NULL, NULL);
}
 
// Helper function to create variable declaration
ASTNode *parser_create_variable_declaration(DataType type, const char *name) {
    // This should match your AST creation functions
    // Adjust according to your actual AST API
    return ast_create_var_decl(type, name, NULL);
}
 
ASTNode *parser_parse_variable_declaration(Parser *parser, DataType var_type) {
    ASTNode *initializer = NULL;
 
    if (parser_match(parser, TOKEN_ASSIGN)) {
        parser_advance(parser);
        initializer = parser_parse_expression(parser);
    }
 
    parser_expect(parser, TOKEN_SEMICOLON);
 
    return ast_create_var_decl(var_type, "", initializer);
}
 
ASTNode *parser_parse_statement(Parser *parser) {
    switch (parser->current_token.type) {
        case TOKEN_LBRACE:
            return parser_parse_compound_statement(parser);
        case TOKEN_RETURN:
            return parser_parse_return_statement(parser);
        case TOKEN_IF:
            return parser_parse_if_statement(parser);
        case TOKEN_WHILE:
            return parser_parse_while_statement(parser);
        case TOKEN_FOR:
            return parser_parse_for_statement(parser);
        case TOKEN_BREAK:
            parser_advance(parser);
            parser_expect(parser, TOKEN_SEMICOLON);
            return ast_create_break_stmt();
        case TOKEN_CONTINUE:
            parser_advance(parser);
            parser_expect(parser, TOKEN_SEMICOLON);
            return ast_create_continue_stmt();
        default:
            return parser_parse_expression_statement(parser);
    }
}
 
ASTNode *parser_parse_compound_statement(Parser *parser) {
    ASTNode *compound = ast_create_compound_stmt();
 
    parser_expect(parser, TOKEN_LBRACE);
 
    while (!parser_match(parser, TOKEN_RBRACE) && !parser_match(parser, TOKEN_EOF)) {
        ASTNode *stmt = NULL;
 
        if (parser_is_type_specifier(parser->current_token.type)) {
            // Variable declaration
            DataType var_type = parser_parse_type_specifier(parser);
 
            if (parser_match(parser, TOKEN_IDENTIFIER)) {
                char *var_name = strdup(parser->current_token.value);
                parser_advance(parser);
 
                ASTNode *var_decl = parser_parse_variable_declaration(parser, var_type);
                if (var_decl) {
                    free(var_decl->data.var_decl.name);
                    var_decl->data.var_decl.name = var_name;
                    stmt = var_decl;
                } else {
                    free(var_name);
                }
            }
        } else {
            stmt = parser_parse_statement(parser);
        }
 
        if (stmt) {
            ast_add_statement(compound, stmt);
        }
    }
 
    parser_expect(parser, TOKEN_RBRACE);
 
    return compound;
}
 
ASTNode *parser_parse_expression_statement(Parser *parser) {
    ASTNode *expr = parser_parse_expression(parser);
    parser_expect(parser, TOKEN_SEMICOLON);
    return ast_create_expression_stmt(expr);
}
 
ASTNode *parser_parse_return_statement(Parser *parser) {
    parser_advance(parser); // consume 'return'
 
    ASTNode *expr = NULL;
    if (!parser_match(parser, TOKEN_SEMICOLON)) {
        expr = parser_parse_expression(parser);
    }
 
    parser_expect(parser, TOKEN_SEMICOLON);
 
    return ast_create_return_stmt(expr);
}
 
ASTNode *parser_parse_if_statement(Parser *parser) {
    parser_advance(parser); // consume 'if'
 
    parser_expect(parser, TOKEN_LPAREN);
    ASTNode *condition = parser_parse_expression(parser);
    parser_expect(parser, TOKEN_RPAREN);
 
    ASTNode *then_stmt = parser_parse_statement(parser);
 
    ASTNode *else_stmt = NULL;
    if (parser_match(parser, TOKEN_ELSE)) {
        parser_advance(parser);
        else_stmt = parser_parse_statement(parser);
    }
 
    return ast_create_if_stmt(condition, then_stmt, else_stmt);
}
 
ASTNode *parser_parse_while_statement(Parser *parser) {
    parser_advance(parser); // consume 'while'
 
    parser_expect(parser, TOKEN_LPAREN);
    ASTNode *condition = parser_parse_expression(parser);
    parser_expect(parser, TOKEN_RPAREN);
 
    ASTNode *body = parser_parse_statement(parser);
 
    return ast_create_while_stmt(condition, body);
}
 
ASTNode *parser_parse_for_statement(Parser *parser) {
    parser_advance(parser); // consume 'for'
 
    parser_expect(parser, TOKEN_LPAREN);
 
    ASTNode *init = NULL;
    if (!parser_match(parser, TOKEN_SEMICOLON)) {
        init = parser_parse_expression(parser);
    }
    parser_expect(parser, TOKEN_SEMICOLON);
 
    ASTNode *condition = NULL;
    if (!parser_match(parser, TOKEN_SEMICOLON)) {
        condition = parser_parse_expression(parser);
    }
    parser_expect(parser, TOKEN_SEMICOLON);
 
    ASTNode *update = NULL;
    if (!parser_match(parser, TOKEN_RPAREN)) {
        update = parser_parse_expression(parser);
    }
    parser_expect(parser, TOKEN_RPAREN);
 
    ASTNode *body = parser_parse_statement(parser);
 
    return ast_create_for_stmt(init, condition, update, body);
}
 
ASTNode *parser_parse_expression(Parser *parser) {
    return parser_parse_assignment_expression(parser);
}
 
ASTNode *parser_parse_assignment_expression(Parser *parser) {
    ASTNode *left = parser_parse_logical_or_expression(parser);
 
    if (parser_match(parser, TOKEN_ASSIGN)) {
        parser_advance(parser);
        ASTNode *right = parser_parse_assignment_expression(parser);
 
        if (left->type == AST_IDENTIFIER) {
            return ast_create_assignment(left->data.identifier.name, right);
        } else {
            error_syntax(parser->current_token.line, parser->current_token.column,
                        "Invalid left-hand side in assignment");
        }
    }
 
    return left;
}
 
ASTNode *parser_parse_logical_or_expression(Parser *parser) {
    ASTNode *left = parser_parse_logical_and_expression(parser);
 
    while (parser_match(parser, TOKEN_OR)) {
        TokenType op = parser->current_token.type;
        parser_advance(parser);
        ASTNode *right = parser_parse_logical_and_expression(parser);
        left = ast_create_binary_expr(op, left, right);
    }
 
    return left;
}
 
ASTNode *parser_parse_logical_and_expression(Parser *parser) {
    ASTNode *left = parser_parse_equality_expression(parser);
 
    while (parser_match(parser, TOKEN_AND)) {
        TokenType op = parser->current_token.type;
        parser_advance(parser);
        ASTNode *right = parser_parse_equality_expression(parser);
        left = ast_create_binary_expr(op, left, right);
    }
 
    return left;
}
 
ASTNode *parser_parse_equality_expression(Parser *parser) {
    ASTNode *left = parser_parse_relational_expression(parser);
 
    while (parser_match(parser, TOKEN_EQUAL) || parser_match(parser, TOKEN_NOT_EQUAL)) {
        TokenType op = parser->current_token.type;
        parser_advance(parser);
        ASTNode *right = parser_parse_relational_expression(parser);
        left = ast_create_binary_expr(op, left, right);
    }
 
    return left;
}
 
ASTNode *parser_parse_relational_expression(Parser *parser) {
    ASTNode *left = parser_parse_additive_expression(parser);
 
    while (parser_match(parser, TOKEN_LESS) || parser_match(parser, TOKEN_LESS_EQUAL) ||
           parser_match(parser, TOKEN_GREATER) || parser_match(parser, TOKEN_GREATER_EQUAL)) {
        TokenType op = parser->current_token.type;
        parser_advance(parser);
        ASTNode *right = parser_parse_additive_expression(parser);
        left = ast_create_binary_expr(op, left, right);
    }
 
    return left;
}
 
ASTNode *parser_parse_additive_expression(Parser *parser) {
    ASTNode *left = parser_parse_multiplicative_expression(parser);
 
    while (parser_match(parser, TOKEN_PLUS) || parser_match(parser, TOKEN_MINUS)) {
        TokenType op = parser->current_token.type;
        parser_advance(parser);
        ASTNode *right = parser_parse_multiplicative_expression(parser);
        left = ast_create_binary_expr(op, left, right);
    }
 
    return left;
}
 
ASTNode *parser_parse_multiplicative_expression(Parser *parser) {
    ASTNode *left = parser_parse_unary_expression(parser);
 
    while (parser_match(parser, TOKEN_MULTIPLY) || parser_match(parser, TOKEN_DIVIDE) ||
           parser_match(parser, TOKEN_MODULO)) {
        TokenType op = parser->current_token.type;
        parser_advance(parser);
        ASTNode *right = parser_parse_unary_expression(parser);
        left = ast_create_binary_expr(op, left, right);
    }
 
    return left;
}
 
ASTNode *parser_parse_unary_expression(Parser *parser) {
    if (parser_match(parser, TOKEN_MINUS) || parser_match(parser, TOKEN_NOT)) {
        TokenType op = parser->current_token.type;
        parser_advance(parser);
        ASTNode *operand = parser_parse_unary_expression(parser);
        return ast_create_unary_expr(op, operand);
    }
 
    return parser_parse_primary_expression(parser);
}
 
ASTNode *parser_parse_primary_expression(Parser *parser) {
    ASTNode *primary = NULL;
 
    switch (parser->current_token.type) {
        case TOKEN_NUMBER: {
            int value = atoi(parser->current_token.value);
            primary = ast_create_number(value);
            parser_advance(parser);
            break;
        }
        case TOKEN_STRING: {
            primary = ast_create_string(parser->current_token.value);
            parser_advance(parser);
            break;
        }
        case TOKEN_IDENTIFIER: {
            primary = ast_create_identifier(parser->current_token.value);
            parser_advance(parser);
            break;
        }
        case TOKEN_LPAREN: {
            parser_advance(parser);
            primary = parser_parse_expression(parser);
            parser_expect(parser, TOKEN_RPAREN);
            break;
        }
        default:
            error_syntax(parser->current_token.line, parser->current_token.column,
                        "Expected primary expression");
            return NULL;
    }
 
    // Handle function calls
    if (primary && primary->type == AST_IDENTIFIER && parser_match(parser, TOKEN_LPAREN)) {
        primary = parser_parse_call_expression(parser, primary);
    }
 
    return primary;
}
 
ASTNode *parser_parse_call_expression(Parser *parser, ASTNode *primary) {
    if (primary->type != AST_IDENTIFIER) {
        return primary;
    }
 
    ASTNode *call = ast_create_call_expr(primary->data.identifier.name);
 
    parser_advance(parser); // consume '('
 
    if (!parser_match(parser, TOKEN_RPAREN)) {
        do {
            ASTNode *arg = parser_parse_expression(parser);
            if (arg) {
                ast_add_argument(call, arg);
            }
 
            if (parser_match(parser, TOKEN_COMMA)) {
                parser_advance(parser);
            } else {
                break;
            }
        } while (true);
    }
 
    parser_expect(parser, TOKEN_RPAREN);
 
    // Clean up the original identifier node
    ast_destroy(primary);
 
    return call;
}