list.c

#include "list.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <unistd.h>
#include <pwd.h>

/* ===== Глобальные для обратной совместимости ===== */
static char **global_lst = NULL;
static int global_sizelist = 0;
static int global_curlist = 0;

/* ===== Реализация структуры TokenList ===== */

TokenList* token_list_create(void) {
    TokenList *list = malloc(sizeof(TokenList));
    if (!list) return NULL;
    
    list->capacity = 16;
    list->count = 0;
    list->tokens = malloc(list->capacity * sizeof(char*));
    
    if (!list->tokens) {
        free(list);
        return NULL;
    }
    
    return list;
}

void token_list_free(TokenList *list) {
    if (!list) return;
    
    for (int i = 0; i < list->count; i++) {
        free(list->tokens[i]);
    }
    
    free(list->tokens);
    free(list);
}

void token_list_clear(TokenList *list) {
    if (!list) return;
    
    for (int i = 0; i < list->count; i++) {
        free(list->tokens[i]);
        list->tokens[i] = NULL;
    }
    
    list->count = 0;
}

int token_list_append(TokenList *list, const char *token) {
    if (!list || !token) return -1;
    
    /* Увеличиваем capacity если нужно */
    if (list->count >= list->capacity - 1) {
        int new_capacity = list->capacity * 2;
        char **new_tokens = realloc(list->tokens, new_capacity * sizeof(char*));
        
        if (!new_tokens) return -1;
        
        list->tokens = new_tokens;
        list->capacity = new_capacity;
    }
    
    /* Копируем строку */
    list->tokens[list->count] = strdup(token);
    if (!list->tokens[list->count]) return -1;
    
    list->count++;
    list->tokens[list->count] = NULL; /* NULL-терминатор */
    
    return 0;
}

int token_list_count(const TokenList *list) {
    return list ? list->count : 0;
}

char** token_list_array(const TokenList *list) {
    return list ? list->tokens : NULL;
}

/* ===== Подстановка переменных окружения ===== */

static char* get_var_value(const char *name) {
    if (strcmp(name, "HOME") == 0) {
        char *home = getenv("HOME");
        return home ? home : "";
    }
    else if (strcmp(name, "SHELL") == 0) {
        char *shell = getenv("SHELL");
        return shell ? shell : "";
    }
    else if (strcmp(name, "USER") == 0) {
        char *user = getenv("USER");
        return user ? user : "";
    }
    else if (strcmp(name, "EUID") == 0) {
        static char euid_str[20];
        snprintf(euid_str, sizeof(euid_str), "%d", geteuid());
        return euid_str;
    }
    return getenv(name);
}

static void replace_var_in_token(char **token_ptr) {
    char *token = *token_ptr;
    if (!token || token[0] != '$') return;
    
    char *var_name = token + 1;
    if (var_name[0] == '\0') return;
    
    char *value = get_var_value(var_name);
    if (value) {
        free(*token_ptr);
        *token_ptr = strdup(value);
    }
}

void substitute_env_vars_in_list(TokenList *list) {
    if (!list) return;
    
    for (int i = 0; i < list->count; i++) {
        replace_var_in_token(&list->tokens[i]);
    }
}

/* ===== Построение списка из строки ===== */

TokenList* tokenize_to_list(const char *line) {
    TokenList *list = token_list_create();
    if (!list) return NULL;
    
    if (!line || !*line) return list;
    
    int i = 0;
    int len = strlen(line);
    
    while (i < len) {
        /* Пропуск пробелов */
        while (i < len && isspace(line[i])) i++;
        if (i >= len) break;
        
        /* Комментарии */
        if (line[i] == '#') break;
        
        /* Спецсимволы */
        if (strchr("|&;<>()", line[i])) {
            char token[3] = {0};
            token[0] = line[i];
            
            /* Проверка на двойные символы */
            if (i + 1 < len && ((line[i] == '|' && line[i+1] == '|') ||
                                (line[i] == '&' && line[i+1] == '&') ||
                                (line[i] == '>' && line[i+1] == '>'))) {
                token[1] = line[i+1];
                i += 2;
            } else {
                i++;
            }
            
            token_list_append(list, token);
            continue;
        }
        
        /* Слово (с обработкой кавычек) */
        int start = i;
        int in_quotes = 0;
        char quote_char = 0;
        int escaped = 0;
        
        while (i < len) {
            char c = line[i];
            
            if (escaped) {
                escaped = 0;
                i++;
                continue;
            }
            
            if (c == '\\') {
                escaped = 1;
                i++;
                continue;
            }
            
            if (!in_quotes && (c == '\'' || c == '"')) {
                in_quotes = 1;
                quote_char = c;
                i++;
                continue;
            }
            
            if (in_quotes && c == quote_char) {
                in_quotes = 0;
                i++;
                continue;
            }
            
            if (!in_quotes && (isspace(c) || strchr("|&;<>()#", c))) {
                break;
            }
            
            i++;
        }
        
        if (i > start) {
            /* Извлекаем слово */
            char *word = strndup(line + start, i - start);
            if (!word) {
                token_list_free(list);
                return NULL;
            }
            
            /* Убираем кавычки */
            char *dst = word;
            char *src = word;
            escaped = 0;
            int in_quotes_clean = 0;
            char current_quote = 0;
            
            while (*src) {
                if (!escaped && !in_quotes_clean && (*src == '\'' || *src == '"')) {
                    in_quotes_clean = 1;
                    current_quote = *src;
                    src++;
                    continue;
                }
                
                if (!escaped && in_quotes_clean && *src == current_quote) {
                    in_quotes_clean = 0;
                    src++;
                    continue;
                }
                
                if (!escaped && *src == '\\') {
                    escaped = 1;
                    src++;
                    continue;
                }
                
                escaped = 0;
                *dst++ = *src++;
            }
            *dst = '\0';
            
            token_list_append(list, word);
            free(word);
        }
    }
    
    return list;
}

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

void token_list_print(const TokenList *list) {
    if (!list) {
        printf("TokenList: (null)\n");
        return;
    }
    
    printf("TokenList [%d/%d]:\n", list->count, list->capacity);
    for (int i = 0; i < list->count; i++) {
        printf("  [%d]: \"%s\"\n", i, list->tokens[i]);
    }
    if (list->tokens[list->count] == NULL) {
        printf("  [%d]: (NULL terminator)\n", list->count);
    }
}

/* ===== Функции для обратной совместимости ===== */

void list_init(void) {
    global_lst = NULL;
    global_sizelist = 0;
    global_curlist = 0;
}

void list_clear(void) {
    for (int i = 0; i < global_curlist; i++) {
        free(global_lst[i]);
    }
    free(global_lst);
    global_lst = NULL;
    global_sizelist = 0;
    global_curlist = 0;
}

/* Старая функция tokenize - для обратной совместимости */
TokenList tokenize(const char *line) {
    TokenList *list = tokenize_to_list(line);
    if (!list) {
        TokenList empty = {NULL, 0, 0};
        return empty;
    }
    
    TokenList result = *list;
    free(list); /* Освобождаем структуру, но не данные */
    return result;
}

void substitute_env_vars(TokenList tokens) {
    /* Конвертируем старый формат в новый */
    TokenList temp_list = {tokens.tokens, tokens.count, tokens.capacity};
    substitute_env_vars_in_list(&temp_list);
}

void free_tokens(TokenList tokens) {
    for (int i = 0; i < tokens.count; i++) {
        free(tokens.tokens[i]);
    }
    free(tokens.tokens);
}