shell.c

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include <dirent.h>
#include <limits.h>
#include <errno.h>
#include <ctype.h>
#include <strings.h>
#include <stddef.h>

#ifndef PATH_MAX
#define PATH_MAX 4096
#endif

#define MAX_CMD_LENGTH 1024
#define MAX_ARGS 64

// Global variable to track if we're in batch mode
int batch_mode = 0;
int last_exit_code = 0;

// Function declarations
void print_prompt();
char* read_command();
char** parse_command(char* cmd, int* arg_count);
int execute_command(char** args, int arg_count);
void free_args(char** args);
int handle_redirection(char** args, int arg_count);
int is_batch_file(const char* filename);
int execute_batch_file(const char* filename);
char* expand_path(char* path);
char* convert_win_to_unix_path(const char* win_path);
int starts_with(const char* str, const char* prefix);
char* expand_environment_variables(char* str);
void print_help();

int main(int argc, char* argv[]) {
    if (argc > 1) {
        if (strcmp(argv[1], "-h") == 0 || strcmp(argv[1], "--help") == 0) {
            printf("Batch Script Shell (BSS) - A shell for executing batch scripts\n");
            printf("Usage: %s [batch_file.bat]\n", argv[0]);
            printf("       %s -h | --help (show this help)\n", argv[0]);
            return 0;
        } else {
            // Execute batch file
            int result = execute_batch_file(argv[1]);
            // Reset batch mode after executing batch file from command line
            batch_mode = 0;
            return result;
        }
    }

    // Interactive mode
    char* cmd;
    char** args;
    int arg_count;
    int status = 1;

    printf("Batch Script Shell (BSS) - Type 'help' for available commands\n");

    do {
        print_prompt();
        cmd = read_command();

        if (cmd == NULL) {
            // EOF or error reading command
            break;
        }

        if (strlen(cmd) == 0) {
            // Empty command, continue to next prompt
            free(cmd);
            continue;
        }

        args = parse_command(cmd, &arg_count);

        if (args == NULL) {
            free(cmd);
            continue;
        }

        status = execute_command(args, arg_count);

        free_args(args);
        free(cmd);
    } while (status);

    return 0;
}

void print_prompt() {
    char cwd[PATH_MAX];
    if (getcwd(cwd, sizeof(cwd)) != NULL) {
        // Convert to Windows-style path for display
        char win_path[PATH_MAX];
        char* ptr = cwd;
        int i = 0;
        
        // If path starts with '/', replace with 'C:\'
        if (*ptr == '/') {
            strcpy(win_path, "C:\\");
            i = 3;
            ptr++;
        }
        
        while (*ptr != '\0' && i < PATH_MAX-1) {
            if (*ptr == '/') {
                win_path[i] = '\\';
            } else {
                win_path[i] = *ptr;
            }
            i++;
            ptr++;
        }
        win_path[i] = '\0';
        
        printf("%s> ", win_path);
    } else {
        printf("C:\\> ");
    }
    fflush(stdout);
}

char* read_command() {
    char* line = NULL;
    size_t len = 0;
    ssize_t read;

    read = getline(&line, &len, stdin);

    if (read == -1) {
        if (feof(stdin)) {
            free(line);
            return NULL;
        } else {
            perror("getline");
            exit(EXIT_FAILURE);
        }
    }

    // Remove trailing newline
    if (line[read - 1] == '\n') {
        line[read - 1] = '\0';
    }

    return line;
}

char** parse_command(char* cmd, int* arg_count) {
    char** args = malloc(MAX_ARGS * sizeof(char*));
    if (args == NULL) {
        perror("malloc");
        return NULL;
    }

    int count = 0;
    char* ptr = cmd;

    // Handle @echo off and similar commands at start
    if (cmd[0] == '@') {
        memmove(cmd, cmd + 1, strlen(cmd)); // Remove the '@'
        ptr = cmd;
    }

    // Skip leading whitespace
    while (isspace((unsigned char)*ptr)) {
        ptr++;
    }

    while (*ptr != '\0' && count < MAX_ARGS - 1) {
        // Skip whitespace
        while (isspace((unsigned char)*ptr)) {
            ptr++;
        }

        if (*ptr == '\0') {
            break;
        }

        // Check for redirection operators
        if (*ptr == '>' || (*ptr == '>' && *(ptr + 1) == '>') || *ptr == '<') {
            // Handle redirection operators as separate tokens
            if (*ptr == '>' && *(ptr + 1) == '>') {
                // Handle >>
                args[count] = strdup(">>");
                ptr += 2;
            } else if (*ptr == '>') {
                // Handle >
                args[count] = strdup(">");
                ptr += 1;
            } else if (*ptr == '<') {
                // Handle <
                args[count] = strdup("<");
                ptr += 1;
            }
        } else {
            // Handle regular arguments (including quoted strings)
            char* start = ptr;

            if (*ptr == '"') {
                // Handle quoted string
                start = ptr + 1; // Skip opening quote
                ptr++;
                while (*ptr != '\0' && *ptr != '"') {
                    ptr++;
                }
                if (*ptr == '"') {
                    *ptr = '\0'; // Terminate the quoted string
                    ptr++;
                }
                // Expand environment variables in the quoted argument
                char* expanded = expand_environment_variables(start);
                args[count] = expanded ? expanded : strdup(start);
            } else {
                // Handle unquoted string
                while (*ptr != '\0' && !isspace((unsigned char)*ptr) && 
                       *ptr != '>' && *ptr != '<') {
                    ptr++;
                }
                
                // Check if we're at a redirection operator
                if (*ptr == '>' || *ptr == '<') {
                    // Break here to allow the redirection operator to be parsed separately
                    char temp = *ptr;
                    *ptr = '\0';
                    // Expand environment variables in the argument
                    char* expanded = expand_environment_variables(start);
                    args[count] = expanded ? expanded : strdup(start);
                    *ptr = temp; // Restore the character
                    if (args[count] == NULL) {
                        perror("strdup");
                        for (int i = 0; i < count; i++) {
                            free(args[i]);
                        }
                        free(args);
                        return NULL;
                    }
                    count++;
                    continue; // Continue to parse the redirection operator
                } else {
                    char temp = *ptr;
                    *ptr = '\0';
                    // Expand environment variables in the argument
                    char* expanded = expand_environment_variables(start);
                    args[count] = expanded ? expanded : strdup(start);
                    *ptr = temp; // Restore the character
                }
            }
        }

        if (args[count] == NULL) {
            perror("strdup");
            for (int i = 0; i < count; i++) {
                free(args[i]);
            }
            free(args);
            return NULL;
        }
        count++;
    }

    args[count] = NULL;
    *arg_count = count;

    return args;
}

int execute_command(char** args, int arg_count) {
    last_exit_code = 0;

    if (args[0] == NULL) {
        return 1; // No command entered, continue shell
    }

    // Check for redirections first, before handling built-in commands
    // This ensures commands with redirections like 'echo Hello > file.txt' work properly
    if (handle_redirection(args, arg_count) == 0) {
        // Redirection was handled successfully
        return 1;
    }

    // Built-in commands
    if (strcmp(args[0], "echo") == 0) {
        if (arg_count == 1) {
            printf("\n");
        } else if (arg_count == 2) {
            if (strcmp(args[1], "on") == 0) {
                printf("ECHO is on.\n");
            } else if (strcmp(args[1], "off") == 0) {
                printf("ECHO is off.\n");
            } else {
                printf("%s\n", args[1]);
            }
        } else {
            for (int i = 1; i < arg_count; i++) {
                printf("%s ", args[i]);
            }
            printf("\n");
        }
        return 1;
    } else if (strcmp(args[0], "set") == 0) {
        // Handle SET command to display or set environment variables
        if (arg_count == 1) {
            // Display all environment variables
            extern char **environ;
            for (char **env = environ; *env != 0; env++) {
                printf("%s\n", *env);
            }
        } else if (arg_count >= 2) {
            // Simple variable setting (not persistent in this implementation)
            char* var = args[1];
            char* equals = strchr(var, '=');
            if (equals != NULL) {
                *equals = '\0';
                setenv(var, equals + 1, 1);
            } else {
                // Display specific variable
                char* value = getenv(var);
                if (value != NULL) {
                    printf("%s=%s\n", var, value);
                } else {
                    printf("%s\n", var);
                }
            }
        }
        return 1;
    } else if (strcmp(args[0], "cd") == 0 || strcmp(args[0], "chdir") == 0) {
        if (arg_count == 1) {
            // No arguments - just print current directory
            char cwd[PATH_MAX];
            if (getcwd(cwd, sizeof(cwd)) != NULL) {
                printf("%s\n", cwd);
            }
        } else if (arg_count == 2) {
            char* path = convert_win_to_unix_path(args[1]);
            if (chdir(path) != 0) {
                printf("cd: %s: %s\n", path, strerror(errno));
                last_exit_code = 1;
            }
            free(path);
        } else {
            printf("cd: Too many arguments\n");
            last_exit_code = 1;
        }
        return 1;
    } else if (strcmp(args[0], "pwd") == 0) {
        char cwd[PATH_MAX];
        if (getcwd(cwd, sizeof(cwd)) != NULL) {
            printf("%s\n", cwd);
        } else {
            perror("getcwd() error");
            last_exit_code = 1;
            return 1;
        }
        return 1;
    } else if (strcmp(args[0], "cls") == 0 || strcmp(args[0], "clear") == 0) {
        system("clear");
        return 1;
    } else if (strcmp(args[0], "pause") == 0) {
        if (batch_mode) {
            // In batch mode, don't actually pause, just continue
            return 1;
        } else {
            // In interactive mode, behave normally
            printf("Press any key to continue . . . ");
            getchar();
            return 1;
        }
    } else if (strcmp(args[0], "help") == 0) {
        print_help();
        return 1;
    } else if (strcasecmp(args[0], "exit") == 0) {
        int exit_code = 0;
        
        if (arg_count >= 2) {
            // Handle special batch parameters like /b
            if (strcasecmp(args[1], "/b") == 0) {
                // exit /b is used in batch files to exit the batch without terminating shell
                // In our context, this should just return from execute_batch_file 
                // but since we're inside execute_command, we just return normally
                if (arg_count >= 3) {
                    exit_code = atoi(args[2]);  // Use the 3rd argument as exit code if provided
                    last_exit_code = exit_code;
                } else {
                    // With exit /b and no explicit code, preserve the current error level
                    // This is the Windows batch default behavior
                    exit_code = last_exit_code;
                }
            } else {
                // Regular exit with numeric code
                exit_code = atoi(args[1]);
                last_exit_code = exit_code;
            }
        } else {
            // Just 'exit' without arguments - exit with code 0
            last_exit_code = exit_code;
        }
        return 0; // Exit the shell/return from command
    } else if (strcasecmp(args[0], "echo.") == 0) {
        printf("\n");
        return 1;
    } else if (strcmp(args[0], "for") == 0) {
        // For loops are not supported in this basic shell
        // In batch mode, just continue without executing
        if (batch_mode) {
            return 1;
        } else {
            printf("Command 'for' not supported in interactive mode\n");
            return 1;
        }
    } else if (strcasecmp(args[0], "choice") == 0) {
        // CHOICE command implementation - skip in batch mode to avoid user input
        if (batch_mode) {
            // In batch mode, just continue without executing (to avoid hanging)
            return 1;
        } else {
            // In interactive mode, we could implement the full choice functionality
            // For now, just show what would happen
            printf("CHOICE command (not fully implemented in this version):\n");
            for (int i = 1; i < arg_count; i++) {  // Start from 1 to skip "CHOICE"
                printf("  %s", args[i]);
                if (i < arg_count - 1) printf(" ");  // Add space between arguments except for the last
            }
            printf("\nThis command would pause for user input in interactive mode\n");
            return 1;
        }
    } else if (strcasecmp(args[0], "find") == 0) {
        // FIND command implementation - basic functionality with flag support
        if (arg_count < 2) {
            printf("FIND: Insufficient arguments\n");
            printf("Usage: FIND [/V] [/C] [/I] \"string\" [filename]\n");
            last_exit_code = 1;
            return 1;
        }
        
        // Parse flags
        int invert_match = 0;  // /V flag - select non-matching lines
        int count_only = 0;    // /C flag - count matching lines
        int ignore_case = 0;   // /I flag - ignore case
        
        int start_arg = 1;
        // Process any flags at the beginning of the arguments
        for (int i = 1; i < arg_count; i++) {
            if (strlen(args[i]) >= 2 && args[i][0] == '/') {
                if (strcasecmp(args[i] + 1, "V") == 0) {
                    invert_match = 1;
                    start_arg++;
                } else if (strcasecmp(args[i] + 1, "C") == 0) {
                    count_only = 1;
                    start_arg++;
                } else if (strcasecmp(args[i] + 1, "I") == 0) {
                    ignore_case = 1;
                    start_arg++;
                } else {
                    // Not a recognized flag, so stop flag processing
                    break;
                }
            } else {
                // This is not a flag, so stop processing flags
                break;
            }
        }
        
        if (start_arg >= arg_count) {
            printf("FIND: No search string provided\n");
            last_exit_code = 1;
            return 1;
        }
        
        // Handle the case where quoted strings were split by strtok
        // e.g. "find \"search term\" file.txt" becomes ["find", "\"search", "term\"", "file.txt"]
        char search_string[MAX_CMD_LENGTH];
        int end_arg = arg_count - 1;  // assume last arg is filename unless it doesn't look like one
        
        // Check if last argument might be a Windows-style error redirection (e.g. "2>nul") and exclude it
        if (arg_count >= 2 && strlen(args[arg_count-1]) > 2 && args[arg_count-1][0] == '2' && args[arg_count-1][1] == '>') {
            // This is a redirection pattern like "2>nul", so ignore it and treat the previous arg as filename if appropriate
            arg_count--;  // Effectively remove the last argument
        }
        
        // Check if last argument might be a filename by looking for file extensions or path indicators
        int has_filename = (start_arg < arg_count - 1) &&  // Make sure we still have potential filename arg
                          (strchr(args[arg_count-1], '.') || 
                           strchr(args[arg_count-1], '/') || 
                           strchr(args[arg_count-1], '\\') ||
                           // Additional patterns that suggest it's a filename
                           args[arg_count-1][0] == '/' || args[arg_count-1][0] == '\\');
        
        char* filename = has_filename ? args[arg_count - 1] : NULL;
        if (has_filename) {
            end_arg = arg_count - 2;  // Exclude the filename
        }
        
        // Reconstruct the search string from multiple arguments, handling quoted fragments
        strcpy(search_string, "");
        for (int i = start_arg; i <= end_arg; i++) {
            if (i > start_arg) strcat(search_string, " ");
            
            const char* arg = args[i];
            
            // Remove leading quote if present
            if (arg[0] == '"') {
                arg++;
            }
            
            // Remove trailing quote if present
            size_t arg_len = strlen(arg);
            char* temp_arg = strdup(arg);
            if (temp_arg && arg_len > 0 && temp_arg[arg_len-1] == '"') {
                temp_arg[arg_len-1] = '\0';
            }
            
            strcat(search_string, temp_arg ? temp_arg : arg);
            free(temp_arg);
        }
        
        // If no filename provided, read from stdin in interactive mode
        if (filename == NULL && !batch_mode) {
            printf("FIND: Reading from stdin (Ctrl+D to end)\n");
            char line[MAX_CMD_LENGTH];
            int line_num = 1;
            int found_count = 0;
            
            while (fgets(line, sizeof(line), stdin) != NULL) {
                int match;
                if (ignore_case) {
                    // Manual case-insensitive search
                    char* lower_line = strdup(line);
                    char* lower_search = strdup(search_string);
                    if (lower_line && lower_search) {
                        for (int j = 0; lower_line[j]; j++) {
                            lower_line[j] = tolower(lower_line[j]);
                        }
                        for (int j = 0; lower_search[j]; j++) {
                            lower_search[j] = tolower(lower_search[j]);
                        }
                        match = (strstr(lower_line, lower_search) != NULL);
                        free(lower_line);
                        free(lower_search);
                    } else {
                        match = (strstr(line, search_string) != NULL); // fallback to case-sensitive
                    }
                } else {
                    match = (strstr(line, search_string) != NULL);
                }
                
                if (invert_match) {
                    match = !match;  // Invert the match for /V flag
                }
                
                if (match) {
                    found_count++;
                    if (!count_only) {
                        printf("%s", line);
                    }
                }
                line_num++;
            }
            
            if (count_only) {
                printf("%d\n", found_count);
            }
            
            if (found_count == 0) {
                last_exit_code = 1; // Not found
            }
            return 1;
        } else if (filename != NULL) {
            // Search in the specified file
            FILE* file = fopen(filename, "r");
            if (file == NULL) {
                printf("FIND: %s: No such file or directory\n", filename);
                last_exit_code = 1;
                return 1;
            }
            
            char line[MAX_CMD_LENGTH];
            int line_num = 1;
            int found_count = 0;
            
            while (fgets(line, sizeof(line), file) != NULL) {
                int match;
                if (ignore_case) {
                    // Manual case-insensitive search
                    char* lower_line = strdup(line);
                    char* lower_search = strdup(search_string);
                    if (lower_line && lower_search) {
                        for (int j = 0; lower_line[j]; j++) {
                            lower_line[j] = tolower(lower_line[j]);
                        }
                        for (int j = 0; lower_search[j]; j++) {
                            lower_search[j] = tolower(lower_search[j]);
                        }
                        match = (strstr(lower_line, lower_search) != NULL);
                        free(lower_line);
                        free(lower_search);
                    } else {
                        match = (strstr(line, search_string) != NULL); // fallback to case-sensitive
                    }
                } else {
                    match = (strstr(line, search_string) != NULL);
                }
                
                if (invert_match) {
                    match = !match;  // Invert the match for /V flag
                }
                
                if (match) {
                    found_count++;
                    if (!count_only) {
                        printf("%s", line);
                    }
                }
                line_num++;
            }
            
            fclose(file);
            
            if (count_only) {
                printf("%d\n", found_count);
            }
            
            if (found_count == 0) {
                last_exit_code = 1; // Not found
            }
            return 1;
        } else {
            // Search without a file - this would be in stdin in interactive mode
            if (batch_mode) {
                printf("FIND: No filename provided in batch mode\n");
                last_exit_code = 1;
                return 1;
            } else {
                printf("FIND: Reading from stdin (Ctrl+D to end)\n");
                char line[MAX_CMD_LENGTH];
                int line_num = 1;
                int found_count = 0;
                
                while (fgets(line, sizeof(line), stdin) != NULL) {
                    int match;
                    if (ignore_case) {
                        // Manual case-insensitive search
                        char* lower_line = strdup(line);
                        char* lower_search = strdup(search_string);
                        if (lower_line && lower_search) {
                            for (int j = 0; lower_line[j]; j++) {
                                lower_line[j] = tolower(lower_line[j]);
                            }
                            for (int j = 0; lower_search[j]; j++) {
                                lower_search[j] = tolower(lower_search[j]);
                            }
                            match = (strstr(lower_line, lower_search) != NULL);
                            free(lower_line);
                            free(lower_search);
                        } else {
                            match = (strstr(line, search_string) != NULL); // fallback to case-sensitive
                        }
                    } else {
                        match = (strstr(line, search_string) != NULL);
                    }
                    
                    if (invert_match) {
                        match = !match;  // Invert the match for /V flag
                    }
                    
                    if (match) {
                        found_count++;
                        if (!count_only) {
                            printf("%s", line);
                        }
                    }
                    line_num++;
                }
                
                if (count_only) {
                    printf("%d\n", found_count);
                }
                
                if (found_count == 0) {
                    last_exit_code = 1; // Not found
                }
                return 1;
            }
        }
    } else if (strcasecmp(args[0], "del") == 0 || strcasecmp(args[0], "erase") == 0) {
        // DEL/ERASE command implementation
        if (arg_count < 2) {
            printf("DEL: Insufficient arguments\n");
            printf("Usage: DEL filename\n");
            last_exit_code = 1;
            return 1;
        }
        
        if (batch_mode) {
            // In batch mode, just try to delete the file
            if (remove(args[1]) != 0) {
                printf("DEL: Cannot delete %s: %s\n", args[1], strerror(errno));
                last_exit_code = 1;
            }
        } else {
            // In interactive mode, maybe ask for confirmation
            char response[10];
            printf("Delete %s? (Y/N): ", args[1]);
            fflush(stdout);
            if (fgets(response, sizeof(response), stdin) && 
                (response[0] == 'Y' || response[0] == 'y')) {
                if (remove(args[1]) != 0) {
                    printf("DEL: Cannot delete %s: %s\n", args[1], strerror(errno));
                    last_exit_code = 1;
                }
            }
        }
        return 1;
    } else if (strcasecmp(args[0], "type") == 0) {
        // TYPE command implementation (similar to cat in Linux)
        if (arg_count < 2) {
            printf("TYPE: Insufficient arguments\n");
            printf("Usage: TYPE filename\n");
            last_exit_code = 1;
            return 1;
        }
        
        FILE* file = fopen(args[1], "r");
        if (file == NULL) {
            printf("TYPE: %s: No such file or directory\n", args[1]);
            last_exit_code = 1;
            return 1;
        }
        
        char line[MAX_CMD_LENGTH];
        while (fgets(line, sizeof(line), file) != NULL) {
            printf("%s", line);
        }
        
        fclose(file);
        return 1;
    }

    // For other commands, try to execute them as external programs
    pid_t pid = fork();
    if (pid == -1) {
        perror("fork");
        return 1;
    } else if (pid == 0) {
        // Child process
        if (execvp(args[0], args) == -1) {
            perror("Command not found");
            exit(EXIT_FAILURE);
        }
    } else {
        // Parent process
        int status;
        waitpid(pid, &status, 0);
        if (WIFEXITED(status)) {
            last_exit_code = WEXITSTATUS(status);
        } else if (WIFSIGNALED(status)) {
            last_exit_code = 128 + WTERMSIG(status);
        } else {
            last_exit_code = 1;
        }
    }

    return 1;
}

void free_args(char** args) {
    for (int i = 0; args[i] != NULL; i++) {
        free(args[i]);
    }
    free(args);
}

int handle_redirection(char** args, int arg_count) {
    for (int i = 0; i < arg_count; i++) {
        // Check for standard redirection operators
        int is_standard_redir = (strcmp(args[i], ">") == 0 || strcmp(args[i], ">>") == 0 || strcmp(args[i], "<") == 0);
        
        // Check for Windows-style error redirection (e.g., "2>nul", "2>error.txt")
        int is_error_redir = 0;
        char* error_redir_file = NULL;
        if (strlen(args[i]) > 2 && args[i][0] == '2' && args[i][1] == '>') {
            is_error_redir = 1;
            error_redir_file = args[i] + 2;  // Point to the filename part
        }
        
        if (is_standard_redir || is_error_redir) {
            // Found a redirection operator
            if (is_standard_redir && i + 1 >= arg_count && strcmp(args[i], "<") != 0) {
                // For > and >>, we need a file; for <, the next argument could be optional in some contexts
                if (strcmp(args[i], "<") != 0) {
                    printf("Syntax error: No file specified after redirection operator\n");
                    last_exit_code = 1;
                    return -1; // Indicate error
                }
            }
            
            char* cmd = args[0]; // Command is first argument
            char* file = is_standard_redir ? args[i + 1] : error_redir_file;  // Get file based on redirection type
            
            // Create new argument list without redirection part
            char** new_args = malloc((arg_count) * sizeof(char*));  // Allocate for all possible args
            if (new_args == NULL) {
                perror("malloc");
                return -1;
            }
            
            // Copy arguments, skipping the redirection part
            int new_idx = 0;
            for (int j = 0; j < arg_count; j++) {
                if (j == i) {
                    // Skip this redirection argument
                    if (is_standard_redir) {
                        // For standard redirection like ">", skip the next argument (filename) too
                        j++;  // Skip the file argument after the operator
                    }
                    continue;  // Skip the redirection operator itself
                }
                new_args[new_idx] = strdup(args[j]);
                if (new_args[new_idx] == NULL) {
                    perror("strdup");
                    for (int k = 0; k < new_idx; k++) {
                        free(new_args[k]);
                    }
                    free(new_args);
                    return -1;
                }
                new_idx++;
            }
            new_args[new_idx] = NULL; // Set the last element to NULL
            
            // Special handling for echo command with redirection
            if (strcmp(cmd, "echo") == 0 && (is_standard_redir || is_error_redir)) {
                if (is_standard_redir) {
                    FILE* f = fopen(file, strcmp(args[i], ">>") == 0 ? "a" : "w");
                    if (f == NULL) {
                        perror("fopen");
                        free_args(new_args);
                        last_exit_code = 1;
                        return -1;
                    }
                    
                    // Write the echo content to the file
                    for (int j = 1; j < new_idx; j++) { // Start from 1 to skip "echo", go to new_idx
                        fputs(new_args[j], f);
                        if (j < new_idx - 1) { // Add space between arguments
                            fputc(' ', f);
                        }
                    }
                    fputc('\n', f); // Add newline at the end
                    fclose(f);
                    
                    free_args(new_args);
                    return 0; // Success
                } else if (is_error_redir) {
                    // For error redirection, just continue after removing the redirection arg from args
                    // This is a simplified approach - a full implementation would redirect stderr
                    free_args(new_args);
                    return -1; // Not fully handled, let the normal execution continue
                }
            } else {
                // For other commands, just return -1 to continue with normal execution after filtering args
                // But we need to update the original args list, which is not possible here
                // A better approach would be to return the modified arguments and have them used
                // However, since we can't change the execute_command signature easily,
                // we'll execute the command directly here for supported redirections
                free_args(new_args);
                return -1; // For other commands, return -1 to continue with original args handling
            }
        }
    }
    
    // No redirection operators found
    return -1; // Indicate no redirection to handle
}

int is_batch_file(const char* filename) {
    const char* ext = strrchr(filename, '.');
    return (ext != NULL && (strcmp(ext, ".bat") == 0 || strcmp(ext, ".cmd") == 0));
}

int execute_batch_file(const char* filename) {
    // Set batch mode to true when executing a batch file
    batch_mode = 1;
    last_exit_code = 0;
    
    FILE* file = fopen(filename, "r");
    if (file == NULL) {
        printf("Error: Cannot open file '%s'\n", filename);
        // Reset batch mode before returning
        batch_mode = 0;
        return 1;
    }

    char* line = NULL;
    size_t len = 0;
    ssize_t read;
    int echo_on = 1; // Echo is on by default
    int script_exit_code = 0;

    while ((read = getline(&line, &len, file)) != -1) {
        // Remove trailing newline
        if (line[read - 1] == '\n') {
            line[read - 1] = '\0';
            read--;
        }

        // Skip empty lines
        char* trimmed = line;
        while (*trimmed && isspace((unsigned char)*trimmed)) {
            trimmed++;
        }
        if (*trimmed == '\0') {
            continue;
        }

        // Check for @echo on/off at the beginning of the line
        if (starts_with(trimmed, "@echo off")) {
            echo_on = 0;
            // Remove the @echo off command and continue to next line
            continue;
        } else if (starts_with(trimmed, "@echo on")) {
            echo_on = 1;
            // Remove the @echo on command and continue to next line
            continue;
        } else if (starts_with(trimmed, "echo off")) {
            echo_on = 0;
            continue;
        } else if (starts_with(trimmed, "echo on")) {
            echo_on = 1;
            continue;
        }

        // Skip REM or :: comments
        if (strncasecmp(trimmed, "rem", 3) == 0 && (trimmed[3] == '\0' || isspace((unsigned char)trimmed[3]))) {
            continue;
        }
        if (trimmed[0] == ':' && trimmed[1] == ':') {
            continue;
        }

        // Print command if echo is on and it doesn't start with @
        if (echo_on && trimmed[0] != '@') {
            printf("%s\n", line);
        }

        // Execute the command
        char** args;
        int arg_count;
        char* cmd_copy = strdup(trimmed);
        
        // Handle @ at the beginning of line (suppress echo)
        if (cmd_copy[0] == '@') {
            memmove(cmd_copy, cmd_copy + 1, strlen(cmd_copy)); // Remove the '@'
        }
        
        args = parse_command(cmd_copy, &arg_count);
        if (args != NULL) {
            int should_continue = execute_command(args, arg_count);
            if (last_exit_code != 0) {
                script_exit_code = last_exit_code;
            }
            free_args(args);
            if (should_continue == 0) {
                free(cmd_copy);
                break;
            }
        }
        free(cmd_copy);
    }

    free(line);
    fclose(file);
    
    // Reset batch mode after completing the batch file
    batch_mode = 0;
    return script_exit_code;
}

char* convert_win_to_unix_path(const char* win_path) {
    char* unix_path = malloc(strlen(win_path) + 1);
    if (unix_path == NULL) {
        return NULL;
    }

    strcpy(unix_path, win_path);

    // Convert Windows-style paths to Unix-style
    for (int i = 0; unix_path[i] != '\0'; i++) {
        if (unix_path[i] == '\\') {
            unix_path[i] = '/';
        }
    }

    // Handle drive letter mapping (e.g., C:\ to /)
    if (strlen(unix_path) >= 3 && 
        ((unix_path[0] >= 'A' && unix_path[0] <= 'Z') || (unix_path[0] >= 'a' && unix_path[0] <= 'z')) && 
        unix_path[1] == ':' && unix_path[2] == '/') {
        // Move the path after the drive letter to the beginning
        memmove(unix_path, unix_path + 2, strlen(unix_path) - 1);
    }

    return unix_path;
}

int starts_with(const char* str, const char* prefix) {
    return strncmp(str, prefix, strlen(prefix)) == 0;
}

// Function to map Windows environment variables to Linux equivalents
char* map_windows_env_var(const char* var_name) {
    if (strcmp(var_name, "USERPROFILE") == 0) {
        // USERPROFILE maps to HOME
        return getenv("HOME");
    } else if (strcmp(var_name, "HOMEDRIVE") == 0) {
        // HOMEDRIVE is typically 'C:' on Windows, but we'll return empty since Linux doesn't use drive letters
        return "C:";
    } else if (strcmp(var_name, "HOMEPATH") == 0) {
        // HOMEPATH is the path portion after the drive, we'll use the home directory
        char* home = getenv("HOME");
        if (home) {
            // Remove the leading part, just get the relative path from home root
            return home;
        }
        return NULL;
    } else if (strcmp(var_name, "APPDATA") == 0) {
        // APPDATA maps to XDG_CONFIG_HOME or ~/.config
        char* xdg_config = getenv("XDG_CONFIG_HOME");
        if (xdg_config) {
            return xdg_config;
        } else {
            static char config_path[PATH_MAX];
            char* home = getenv("HOME");
            if (home) {
                snprintf(config_path, sizeof(config_path), "%s/.config", home);
                return config_path;
            }
        }
        return NULL;
    } else if (strcmp(var_name, "LOCALAPPDATA") == 0) {
        // LOCALAPPDATA maps to XDG_CACHE_HOME or ~/.cache
        char* xdg_cache = getenv("XDG_CACHE_HOME");
        if (xdg_cache) {
            return xdg_cache;
        } else {
            static char cache_path[PATH_MAX];
            char* home = getenv("HOME");
            if (home) {
                snprintf(cache_path, sizeof(cache_path), "%s/.cache", home);
                return cache_path;
            }
        }
        return NULL;
    } else if (strcmp(var_name, "TEMP") == 0 || strcmp(var_name, "TMP") == 0) {
        // TEMP and TMP map to TMPDIR or /tmp
        char* tmpdir = getenv("TMPDIR");
        if (tmpdir) {
            return tmpdir;
        } else {
            return "/tmp";  // Default temp directory on Linux
        }
    } else if (strcmp(var_name, "ALLUSERSPROFILE") == 0 || strcmp(var_name, "ProgramData") == 0) {
        // Both ALLUSERSPROFILE and ProgramData map to system-wide data locations
        return "/etc";  // Closest Linux equivalent for system-wide config/data
    } else if (strcmp(var_name, "ProgramFiles") == 0) {
        // ProgramFiles maps to where programs are installed on Linux
        return "/usr";  // Closest equivalent for system-wide programs
    } else if (strcmp(var_name, "ProgramFiles(x86)") == 0) {
        // ProgramFiles(x86) for 32-bit programs on 64-bit systems
        return "/usr/lib32";  // On multilib systems, 32-bit libraries go here
    } else if (strcmp(var_name, "CommonProgramFiles") == 0) {
        // CommonProgramFiles typically maps to lib directories
        return "/usr/lib";  // Architecture-independent files
    } else if (strcmp(var_name, "SystemDrive") == 0) {
        // SystemDrive is the main system drive (e.g. C:)
        return "/";  // Root directory in Linux
    } else if (strcmp(var_name, "SystemRoot") == 0 || strcmp(var_name, "windir") == 0) {
        // SystemRoot and windir map to the Windows system directory
        // In Linux, this is spread across multiple locations; using /usr as the closest equivalent
        return "/usr";
    } else if (strcmp(var_name, "PUBLIC") == 0) {
        // PUBLIC folder is a shared space
        return "/home";  // Commonly shared across users
    }
    
    // If no mapping found, return NULL and fallback to regular getenv
    return NULL;
}

// Expand environment variables in the format %VARNAME%
char* expand_environment_variables(char* str) {
    if (str == NULL) {
        return NULL;
    }
    
    size_t original_len = strlen(str);
    // Allocate initial memory for the expanded string
    size_t buf_size = original_len + 1; // Start with original size + null terminator
    char* expanded = malloc(buf_size);
    if (expanded == NULL) {
        return NULL;
    }
    
    char* src = str;
    char* dst = expanded;
    char var_name[256];
    size_t current_size = buf_size;
    
    while (*src != '\0') {
        // Check if we need more space
        if ((size_t)(dst - expanded) >= current_size - 1) { // Leave space for at least one character
            size_t offset = dst - expanded;  // Store offset before realloc
            current_size *= 2; // Double the buffer size
            char* new_expanded = realloc(expanded, current_size);
            if (new_expanded == NULL) {
                free(expanded);
                return NULL;
            }
            expanded = new_expanded;
            dst = expanded + offset;  // Restore dst with new base address
        }
        
        if (*src == '%' && *(src + 1) != '\0' && *(src + 1) != '%') {
            // Found a potential environment variable
            src++; // Skip the first %
            char* var_start = src;
            
            // Find the closing %
            while (*src != '\0' && *src != '%') {
                src++;
            }
            
            if (*src == '%') {
                // Found closing %, extract variable name
                size_t var_len = src - var_start;
                if (var_len < sizeof(var_name) - 1) {
                    strncpy(var_name, var_start, var_len);
                    var_name[var_len] = '\0';
                    
                    // First check for Windows-specific environment variable mappings
                    char* var_value = map_windows_env_var(var_name);
                    if (var_value != NULL) {
                        // Use Windows to Linux mapping
                        size_t value_len = strlen(var_value);
                        // Ensure we have enough space for the value
                        while ((size_t)((dst - expanded) + value_len) >= current_size - 1) {
                            size_t offset = dst - expanded;  // Store offset before realloc
                            current_size *= 2;
                            char* new_expanded = realloc(expanded, current_size);
                            if (new_expanded == NULL) {
                                free(expanded);
                                return NULL;
                            }
                            expanded = new_expanded;
                            dst = expanded + offset;  // Restore dst with new base address
                        }
                        // Copy the mapped value to the destination
                        strcpy(dst, var_value);
                        dst += value_len;
                    } else {
                        // Not a Windows-specific variable, try regular environment variable
                        var_value = getenv(var_name);
                        if (var_value != NULL) {
                            size_t value_len = strlen(var_value);
                            // Ensure we have enough space for the value
                            while ((size_t)((dst - expanded) + value_len) >= current_size - 1) {
                                size_t offset = dst - expanded;  // Store offset before realloc
                                current_size *= 2;
                                char* new_expanded = realloc(expanded, current_size);
                                if (new_expanded == NULL) {
                                    free(expanded);
                                    return NULL;
                                }
                                expanded = new_expanded;
                                dst = expanded + offset;  // Restore dst with new base address
                            }
                            // Copy the value to the destination
                            strcpy(dst, var_value);
                            dst += value_len;
                        } else {
                            // Variable not found, copy the original %VARNAME% text
                            size_t needed_len = 2 + var_len; // 2 for the % signs + var name
                            while ((size_t)((dst - expanded) + needed_len) >= current_size - 1) {
                                size_t offset = dst - expanded;  // Store offset before realloc
                                current_size *= 2;
                                char* new_expanded = realloc(expanded, current_size);
                                if (new_expanded == NULL) {
                                    free(expanded);
                                    return NULL;
                                }
                                expanded = new_expanded;
                                dst = expanded + offset;  // Restore dst with new base address
                            }
                            
                            *dst++ = '%';
                            strcpy(dst, var_name);
                            dst += var_len;
                            *dst++ = '%';
                        }
                    }
                    src++; // Skip the closing %
                } else {
                    // Variable name too long, copy as-is
                    *dst++ = '%';
                    while (var_start < src) {
                        // Check for space before copying
                        if ((size_t)(dst - expanded) >= current_size - 1) {
                            size_t offset = dst - expanded;  // Store offset before realloc
                            current_size *= 2;
                            char* new_expanded = realloc(expanded, current_size);
                            if (new_expanded == NULL) {
                                free(expanded);
                                return NULL;
                            }
                            expanded = new_expanded;
                            dst = expanded + offset;  // Restore dst with new base address
                        }
                        *dst++ = *var_start++;
                    }
                    *dst++ = '%';
                    src++; // Skip the closing %
                }
            } else {
                // No closing %, copy the opening % and continue
                *dst++ = '%';
            }
        } else if (*src == '%' && *(src + 1) == '%') {
            // Handle escaped %% as a literal %
            *dst++ = '%';
            src += 2;
        } else {
            // Regular character, copy as-is
            *dst++ = *src++;
        }
    }
    
    *dst = '\0'; // Null terminate the expanded string
    
    // Reallocate to fit the actual size plus a small buffer to avoid issues with realloc
    size_t final_size = strlen(expanded) + 1;
    char* result = realloc(expanded, final_size);
    return result ? result : expanded;
}

void print_help() {
    printf("Batch Script Shell (BSS) Help\n");
    printf("Commands available:\n");
    printf("  echo [text]     - Display message or set echo on/off\n");
    printf("  set [variable[=value]] - Display or set environment variables\n");
    printf("  cd [directory]  - Change current directory\n");
    printf("  chdir [directory] - Change current directory\n");
    printf("  pwd             - Print working directory\n");
    printf("  cls/clear       - Clear screen\n");
    printf("  pause           - Pause and wait for keypress\n");
    printf("  help            - Show this help message\n");
    printf("  exit            - Exit the shell\n");
    printf("  type [filename] - Display the contents of a file\n");
    printf("\n");
    printf("Additional features:\n");
    printf("  - Execute batch files (.bat, .cmd)\n");
    printf("  - Path conversion between Windows and Unix formats\n");
    printf("  - Environment variable expansion\n");
}