parser.c

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

#include "parser.h"

Token *peek(Parser *parser)
{
    return &parser->stream->tokens[parser->current];
}

bool isAtEnd(Parser *parser)
{
    return peek(parser)->type == TOKEN_EOF;
}

void advance(Parser *parser)
{
    if (!isAtEnd(parser))
        parser->current++;
}

ASTNode *parseCommand(Parser *parser)
{
    ASTNode *node;
    Token *token;

    if (peek(parser)->type != TOKEN_WORD)
    {
        fprintf(stderr, "Syntax error: expected command.\n");
        return NULL;
    }

    node = malloc(sizeof(*node));

    if (node == NULL)
    {
        fprintf(stderr, "Parser error: memory allocation failed.\n");
        return NULL;
    }

    node->type = NODE_COMMAND;

    node->command.argc = 0;

    node->left = NULL;
    node->right = NULL;
    node->child = NULL;

    while (!isAtEnd(parser) && peek(parser)->type == TOKEN_WORD)
    {
        if (node->command.argc >= MAX_ARGS - 1)
        {
            fprintf( stderr, "Parser error: too many command arguments.\n");

            free(node);
            return NULL;
        }

        token = peek(parser);

        node->command.argv[node->command.argc] =
            &parser->stream->pool[token->start];

        node->command.argc++;

        advance(parser);
    }
    node->command.argv[node->command.argc] = NULL;

    return node;
}

ASTNode *parseExpression(Parser *parser)
{
    return parseCommand(parser);
}

ASTNode *parse(TokenStream *stream)
{
    Parser parser;
    ASTNode *root;

    if (stream == NULL)
        return NULL;

    parser.stream = stream;
    parser.current = 0;

    root = parseExpression(&parser);

    if (root == NULL)
        return NULL;
    if (!isAtEnd(&parser))
    {
        fprintf(
            stderr,
            "Syntax error: unsupported token after command.\n"
        );

        free(root);
        return NULL;
    }

    return root;
}