tree.c

#include "tree.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

/* ===== Глобальные для парсера ===== */
static char **token_array = NULL;  // Массив токенов
static int pos = 0;                // Текущая позиция
static int parse_error = 0;        // Флаг ошибки

/* ===== Вспомогательные функции ===== */

/* Текущая лексема */
static char* current(void) {
    return token_array ? token_array[pos] : NULL;
}

/* Продвинуться вперед */
static void advance(void) {
    if (token_array && token_array[pos]) pos++;
}

/* Проверка типа лексемы */
static int is_special(const char *tok) {
    if (!tok) return 0;
    return strchr("|&;<>()", tok[0]) != NULL;
}

static int is_redirection(const char *tok) {
    return tok && (strcmp(tok, "<") == 0 || 
                   strcmp(tok, ">") == 0 || 
                   strcmp(tok, ">>") == 0);
}

/* Функция обработки ошибок */
static void error(const char *format, ...) {
    parse_error = 1;
    fprintf(stderr, "Syntax error: %s\n", format);
}

/* Создать простую команду (статическая, только для tree.c) */
static Command* create_simple_command(char **argv) {
    Command *cmd = malloc(sizeof(Command));
    if (!cmd) return NULL;
    
    cmd->type = CMD_SIMPLE;
    cmd->argv = argv;
    cmd->infile = NULL;
    cmd->outfile = NULL;
    cmd->append = 0;
    cmd->left = cmd->right = cmd->pipe = cmd->next = NULL;
    cmd->background = 0;
    
    return cmd;
}

/* ===== Рекурсивный спуск ===== */

static Command* parse_command_list(void);
static Command* parse_pipeline(void);
static Command* parse_simple_command(void);
static void parse_redirection(Command *cmd);

Command* parse_tokens(TokenList tok) {
    token_array = tok.tokens;
    pos = 0;
    parse_error = 0;
    
    if (!token_array || !token_array[0]) return NULL;
    
    Command *cmd = parse_command_list();
    
    if (!parse_error && current()) {
        error("unexpected token '%s'", current());
        free_command(cmd);
        return NULL;
    }
    
    if (parse_error) {
        free_command(cmd);
        return NULL;
    }
    
    return cmd;
}

static Command* parse_command_list(void) {
    Command *cmd = parse_pipeline();
    if (!cmd || parse_error) return NULL;
    
    while (current()) {
        char *tok = current();
        
        if (strcmp(tok, ";") == 0) {
            advance();
            Command *next = parse_pipeline();
            if (!next) break;
            
            Command *seq = malloc(sizeof(Command));
            seq->type = CMD_SEQ;
            seq->left = cmd;
            seq->right = next;
            seq->next = NULL;
            cmd = seq;
        }
        else if (strcmp(tok, "&") == 0) {
            advance();
            cmd->background = 1;
            break;
        }
        else {
            break;
        }
    }
    
    return cmd;
}

static Command* parse_pipeline(void) {
    Command *first = parse_simple_command();
    if (!first || parse_error) return NULL;
    
    Command *current_cmd = first;
    
    while (current() && strcmp(current(), "|") == 0) {
        advance();
        
        Command *next = parse_simple_command();
        if (!next) {
            parse_error = 1;
            free_command(first);
            return NULL;
        }
        
        Command *pipe_cmd = malloc(sizeof(Command));
        pipe_cmd->type = CMD_PIPE;
        pipe_cmd->left = current_cmd;
        pipe_cmd->right = next;
        
        current_cmd = pipe_cmd;
    }
    
    return first;
}

static Command* parse_simple_command(void) {
    char *args[256];
    int arg_count = 0;
    
    while (current() && !is_special(current())) {
        args[arg_count++] = strdup(current());
        advance();
        
        if (arg_count >= 255) break;
    }
    
    if (arg_count == 0) {
        error("expected command");
        return NULL;
    }
    
    args[arg_count] = NULL;
    
    char **argv = malloc((arg_count + 1) * sizeof(char*));
    for (int i = 0; i <= arg_count; i++) {
        argv[i] = args[i];
    }
    
    Command *cmd = create_simple_command(argv);
    
    while (is_redirection(current())) {
        parse_redirection(cmd);
        if (parse_error) {
            free_command(cmd);
            return NULL;
        }
    }
    
    return cmd;
}

static void parse_redirection(Command *cmd) {
    char *redir = current();
    advance();
    
    char *filename = current();
    if (!filename || is_special(filename)) {
        error("expected filename after '%s'", redir);
        return;
    }
    advance();
    
    if (strcmp(redir, "<") == 0) {
        if (cmd->infile) free(cmd->infile);
        cmd->infile = strdup(filename);
    }
    else if (strcmp(redir, ">") == 0) {
        if (cmd->outfile) free(cmd->outfile);
        cmd->outfile = strdup(filename);
        cmd->append = 0;
    }
    else if (strcmp(redir, ">>") == 0) {
        if (cmd->outfile) free(cmd->outfile);
        cmd->outfile = strdup(filename);
        cmd->append = 1;
    }
}

/* ===== Освобождение памяти ===== */

void free_command(Command *cmd) {
    if (!cmd) return;
    
    switch (cmd->type) {
        case CMD_SIMPLE:
            if (cmd->argv) {
                for (int i = 0; cmd->argv[i]; i++) free(cmd->argv[i]);
                free(cmd->argv);
            }
            if (cmd->infile) free(cmd->infile);
            if (cmd->outfile) free(cmd->outfile);
            break;
            
        case CMD_PIPE:
        case CMD_SEQ:
            free_command(cmd->left);
            free_command(cmd->right);
            break;
            
        case CMD_BACKGROUND:
            free_command(cmd->left);
            break;
    }
    
    free(cmd);
}

/* ===== Отладочная печать ===== */

void print_command_tree(Command *cmd, int depth) {
    if (!cmd) return;
    
    for (int i = 0; i < depth; i++) printf("  ");
    
    switch (cmd->type) {
        case CMD_SIMPLE:
            printf("SIMPLE:");
            for (int i = 0; cmd->argv && cmd->argv[i]; i++) 
                printf(" %s", cmd->argv[i]);
            if (cmd->infile) printf(" < %s", cmd->infile);
            if (cmd->outfile) printf(" %s %s", cmd->append ? ">>" : ">", cmd->outfile);
            if (cmd->background) printf(" &");
            printf("\n");
            break;
            
        case CMD_PIPE:
            printf("PIPE:\n");
            print_command_tree(cmd->left, depth + 1);
            printf("  |\n");
            print_command_tree(cmd->right, depth + 1);
            break;
            
        case CMD_SEQ:
            printf("SEQ:\n");
            print_command_tree(cmd->left, depth + 1);
            printf("  ;\n");
            print_command_tree(cmd->right, depth + 1);
            break;
            
        case CMD_BACKGROUND:
            printf("BACKGROUND:\n");
            print_command_tree(cmd->left, depth + 1);
            printf("  &\n");
            break;
    }
}