parser.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "parser.h"


// Global parser error flag and line tracker
int parseErrorFlag = 0;
int line = 1;

// Checks for two consecutive INT_CONSTANTs, which may indicate a number over 100 digits
int isBiggerThan100Digit(Token* currentT, Token* nextT){
    if (currentT->type == INT_CONSTANT && nextT->type == INT_CONSTANT){
        parseErrorFlag = 1;
        fprintf(stderr,"Line %d Error: Two INT_CONSTANT tokens found consecutively (likely a number > 100 digits)\n",nextT->line);
        return 1;
    }
    return 0;
}

// Checks for two consecutive IDENTIFIERs, which may indicate a name longer than allowed
int isBiggerThan20Char(Token* currentT, Token* nextT){
    if (currentT->type == IDENTIFIER && nextT->type == IDENTIFIER){
        parseErrorFlag = 1;
        fprintf(stderr, "Line %d Error: Two consecutive identifiers not allowed (possible long name)\n",nextT->line);
        return 1;
    }
    return 0;
}

// Allocates and initializes a new Parser
Parser* createParser(Token* tokens,int count){
    Parser* parser = malloc(sizeof(Parser));
    parser ->tokens = tokens;
    parser->count = count;
    parser->pos = 0; 
    return parser;
}

// Frees parser memory
void freeParser(Parser* parser) {
    free(parser);
}

// Returns current token without advancing
static Token* currentT(Parser* parser) {
    if (parser->pos >= parser->count) return NULL;
    return &parser->tokens[parser->pos];
}

// Advances parser and returns next token
static Token* nextT(Parser* parser) {
    parser->pos++;
    if (parser->pos >= parser->count) return NULL;
    return &parser->tokens[parser->pos];
}

// Peeks at next token without advancing
static Token* peekNext(Parser* parser) {
    if (parser->pos + 1 >= parser->count) return NULL;
    return &parser->tokens[parser->pos + 1];
}

// Checks if current token matches expected type and value
static int isEquals(Parser* parser, TokenType expectedType, const char* expectedValue) {
    Token* current = currentT(parser);
    if (!current) return 0;

    if (current->type == expectedType &&
        (!expectedValue || strcmp(current->value, expectedValue) == 0)) {
        return 1;
    }

    return 0;
}

// Parses a variable declaration with optional assignment.
// This parses a variable declaration in the form: number variable := value; or number variable;
AST* parseDeclaration(Parser* parser){

    Token* ident = nextT(parser); 

    // Error if no identifier follows.
    if(!ident || ident->type != IDENTIFIER ){
        parseErrorFlag = 1;
        fprintf(stderr, "Syntax Error on line %d: Identifier expected after 'number'\n", ident ? ident->line : parser->tokens[parser->pos].line);
        return NULL;
    }
    // Check for too long identifier.
    if(isBiggerThan20Char(ident,peekNext(parser))){
        return NULL;
    }

    AST* node = malloc(sizeof(AST));
    if (!node) {
        parseErrorFlag = 1;
        fprintf(stderr, "Memory allocation failed for AST_DECLARATION\n");
        return NULL;
    }

    node->type = AST_DECLARATION;
    node->declaration.name = strdup(ident->value);
    node->line = ident->line;

    // Check if assignment exists.
    Token* peek = peekNext(parser);
    if(strcmp(peek->value, ":=") == 0){
        nextT(parser);
        Token* valueToken = nextT(parser);
        
        if (!valueToken || (valueToken->type != INT_CONSTANT)&& valueToken->type != IDENTIFIER){
            parseErrorFlag = 1;
            fprintf(stderr, "Syntax Error on line %d: Expected numeric value or variable after ':='\n", peek->line);
            return NULL;
        }
        
        if(valueToken->type == INT_CONSTANT && isBiggerThan100Digit(valueToken,peekNext(parser))){
            return NULL;
        }

        node->declaration.value = strdup(valueToken->value);
    } 
    
    else {
        node->declaration.value = strdup("0"); // No value assigned, default to "0"
        
    }
    // Expect ';' to end the statement
    Token* eol = nextT(parser);
    if(!eol || eol->type != ENDOFLINE){
        parseErrorFlag = 1;
        fprintf(stderr, "Syntax Error on line %d: Missing ';' after declaration of '%s'\n", ident->line, ident->value);
        return NULL;
    }
    nextT(parser);

    return node;
}

// Parses assignment, increment, or decrement statements
AST* parserStmtWop(Parser* parser){
    Token* ident = currentT(parser);    // Variable name
    Token* op = nextT(parser);          // Operator (e.g., :=, +=, -=)
    ASTtype opType;

    if (!op || op->type != OPERATOR ) {
        parseErrorFlag = 1;
        fprintf(stderr, "Syntax Error on line %d: Operator expected after identifier '%s'\n", op ? op->line : ident->line, ident->value);
        return NULL;
    }
    else{   // Determine operation type based on the operator
        if(strcmp(op->value,":=") == 0){
            opType = AST_ASSIGNMENT;
        }
        else if(strcmp(op->value,"-=") == 0){
            opType = AST_DECREMENT;
        }
        else if(strcmp(op->value,"+=") == 0){
            opType = AST_INCREMENT;
        }
    }
    // Parse the value to assign/add/subtract
    Token* valueToken = nextT(parser);
    
    if (!valueToken || (valueToken->type != INT_CONSTANT && valueToken->type != IDENTIFIER)) {
        parseErrorFlag = 1;
        fprintf(stderr, "Syntax Error on line %d: Expected value after ':='\n", valueToken ? valueToken->line : op->line);
        return NULL;
    }

    if(valueToken->type == INT_CONSTANT){  
        if(isBiggerThan100Digit(valueToken,peekNext(parser))){
            parseErrorFlag = 1;
            return NULL;
        }
    }

    // Expect ';' at the end
    Token* end = nextT(parser);
    if (!end || end->type != ENDOFLINE) {
        parseErrorFlag = 1;
        fprintf(stderr, "Syntax Error on line %d: Missing ';' after statement\n", end ? end->line : valueToken->line);
        return NULL;
    }
    nextT(parser);

    AST* node = malloc(sizeof(AST));
    node->type = opType;
    node->assignment.name = strdup(ident->value); 
    node->line = ident->line;

    AST* valueNode = malloc(sizeof(AST));
    if (valueToken->type == INT_CONSTANT) {
        valueNode->type = AST_LITERAL;
        valueNode->number_literal.value = strdup(valueToken->value);
    } else {
        valueNode->type = AST_VARIABLE;
        valueNode->variable.name = strdup(valueToken->value);
    }

    node->assignment.value = valueNode;

    return node;
}

// Parses a "write" statement with optional multiple expressions and 'and' keyword
AST* parserOutput(Parser* parser){
    int counter = 0;
    int capacity = 2;
    AST** elementList = malloc(capacity*sizeof(AST)); 
    Token* valueToPrint;
    nextT(parser);

    while (1) {
        if (counter >= capacity) {
            capacity *= 2;
            elementList = realloc(elementList, capacity * sizeof(AST));
        }

        valueToPrint = currentT(parser);
        if (!valueToPrint) {
            parseErrorFlag = 1;
            fprintf(stderr, "Syntax Error: Expected expression after 'write' on line %d\n",
                    parser->tokens[parser->pos].line);
            return NULL;
        }

        AST* element = malloc(sizeof(AST));
        if (!element) return NULL;
            // Determine the type of value to print
        if (valueToPrint->type == STRING_CONSTANT) {
            element->type = AST_LITERAL;
            element->string_literal.value = valueToPrint->value;
        } else if (valueToPrint->type == INT_CONSTANT) {
            element->type = AST_LITERAL;
            element->number_literal.value = valueToPrint->value;
        } else if (valueToPrint->type == IDENTIFIER) {
            element->type = AST_VARIABLE;
            element->variable.name = valueToPrint->value;
        } else if (valueToPrint->type == KEYWORDS && strcmp(valueToPrint->value, "newline") == 0) {
            element->type = AST_NEWLINE;
            element->newLine.value = valueToPrint->value;
        } else {
            parseErrorFlag = 1;
            fprintf(stderr, "Syntax Error on line %d: Unexpected token in write statement\n", valueToPrint->line);
            return NULL;
        }

        elementList[counter++] = element;

        // Handle 'and' keyword or statement end
        Token* next = peekNext(parser);
        if (next) {
            if (next->type == KEYWORDS && strcmp(next->value, "and") == 0) {
                nextT(parser);
                nextT(parser); 
                continue;
            } 
            else if (next->type == ENDOFLINE) {
                nextT(parser); 
                break;
            } 
            else if (next->type == IDENTIFIER || next->type == STRING_CONSTANT || next->type == INT_CONSTANT) {
                parseErrorFlag = 1;
                fprintf(stderr, "Syntax Error on line %d: Missing 'and' between write elements\n", next->line);
                return NULL;
            } 
            else {
                parseErrorFlag = 1;
                fprintf(stderr, "Syntax Error on line %d: ';' expected after write statement\n", next->line);
                return NULL;
            }
        } 
        else {      // Syntax error if something unexpected appears
            parseErrorFlag = 1;
            fprintf(stderr, "Syntax Error: Unexpected end of input after write statement\n");
            return NULL;
        }
    }
    nextT(parser);

    AST* node = malloc(sizeof(AST));
    node->type = AST_WRITE;
    node->write.count = counter;
    node->write.elements = elementList;
    node->line = valueToPrint->line;

    return node;
    
}

// Parses a "repeat <n> times" loop with an optional block of statements inside {}
AST* parserLoop(Parser* parser){

    Token* size = nextT(parser);
    AST* times;
    times = malloc(sizeof(AST));

    // Parse repeat count (integer or variable)
    if(!size){
        parseErrorFlag = 1;
        fprintf(stderr, "Syntax Error: Size expected after 'repeat' on line %d\n", parser->tokens[parser->pos].line);
        free(times);
        return NULL;
    }

    else if(size->type == INT_CONSTANT){
        times->type = AST_LITERAL;
        times->number_literal.value = strdup(size->value);
    }

    else if(size->type == IDENTIFIER){
        times->type = AST_VARIABLE;
        times->variable.name = strdup(size->value);
    }

    else{
        parseErrorFlag = 1;
        fprintf(stderr, "Syntax Error: Invalid size after 'repeat' on line %d\n", size->line);
        free(times);
        return NULL;
    }
    
    // Expect 'times' keyword
    nextT(parser);
    if(!isEquals(parser,KEYWORDS,"times")){
        parseErrorFlag = 1;
        fprintf(stderr, "Syntax Error: 'times' keyword expected after size on line %d\n", size->line);
        free(times);
        return NULL;
    }
    
    Token* nextToken = nextT(parser);

    if(!nextToken){
        parseErrorFlag = 1;
        fprintf(stderr, "Syntax Error: Statement expected after 'times' on line %d\n", parser->tokens[parser->pos].line);
        free(times);
        return NULL;
    }

    AST* valueNode;

    // Parse loop body: either a single statement or a block {...}
    if(nextToken->type == OPEN_BLOCK){
        nextT(parser);
        int capacity = 1;
        AST** statemntList = malloc(capacity * sizeof(AST));
        int counter = 0;
        
        while(currentT(parser) && currentT(parser)->type != CLOSE_BLOCK){   // Repeatedly parse statements inside block until '}' is found

            if(counter >= capacity){
                capacity *= 2;
                statemntList = realloc(statemntList , capacity * sizeof(AST));
            }
            
            statemntList[counter++] = parseStatement(parser);
        }
        if(!currentT(parser)){
            parseErrorFlag = 1;
            fprintf(stderr, "Syntax Error: '}' expected to close block starting at line %d\n", nextToken->line);
            free(times);
            free(statemntList);
            return NULL;
        }

        valueNode = malloc(sizeof(AST));
        valueNode->type = AST_CODEBLOCK;
        valueNode->codeblock.count = counter;
        valueNode->codeblock.statements = statemntList; 
        valueNode->codeblock.position = 0;
    }

    else{
        // single statement
        valueNode = parseStatement(parser);

        if (!valueNode) {
            free(times);
            return NULL;
        }
    }
    nextT(parser);

    AST* node = malloc(sizeof(AST));
    if (!node) {
        parseErrorFlag = 1;
        fprintf(stderr, "Memory allocation failed\n");
        return NULL;
    }
    
    node->type = AST_LOOP;
    node->loop.times = times;
    node->loop.body = valueNode;
    node->line = size->line;
    return node;

}

//  Dispatch separation according to certain conditions.
AST* parseStatement(Parser* parser){

    Token* token = currentT(parser); 

    if(!token){
        return NULL;
    }
    if(token->type == KEYWORDS &&strcmp(token->value, "number") == 0){
        return parseDeclaration(parser);
    }
    if(token->type ==IDENTIFIER){
        return parserStmtWop(parser);
    }
    if(token->type == KEYWORDS && strcmp(token->value,"write") == 0){
        return parserOutput(parser);
    }
    if(token->type == KEYWORDS && strcmp(token->value,"repeat") == 0){
        return parserLoop(parser);
    }
    parseErrorFlag = 1;
    fprintf(stderr, "Error on line %d: Unexpected token '%s'\n", token->line, token->value);
    return NULL;
}

// Parses the entire program as a list of statements
AST* parseProgram(Parser* parser){
    int capacity = 4 ;
    AST** statements = malloc(capacity * sizeof(AST));
    if (!statements) {
        parseErrorFlag = 1;
        fprintf(stderr, "Error: Memory allocation failed for statements array.\n");
        return NULL;
    }

    int count = 0;

    while (parser->pos < parser->count) {
        AST* stmt = parseStatement(parser);
        if (stmt) {
            if (count >= capacity) {
                capacity *= 2;
                statements = realloc(statements, sizeof(AST) * capacity);
                if (!statements) {
                    parseErrorFlag = 1;
                    fprintf(stderr, "Error: Memory reallocation failed for statements array.\n");
                    return NULL;
                }
            }
            statements[count++] = stmt;
        } else {
            if (parser->pos < parser->count) {
                Token* errToken = &parser->tokens[parser->pos];
            } else {
                fprintf(stderr, "Parse error: Unexpected end of input\n");
            }
            parseErrorFlag = 1;
            break;
        }
    }
    AST* node = malloc(sizeof(AST));
    if( !node ){
        parseErrorFlag = 1;
        fprintf(stderr, "Error: Memory allocation failed for program AST.\n");
        return NULL;
    }

    node->type = AST_PROGRAM;
    node->programStatements.position = 0;
    node->programStatements.statements = statements;
    node->programStatements.count = count;
    
    return node;
}