Implemented some ast handlings...

ast lists, and_or, redirection and builtins

src/execution/execution.c

@@ -5,9 +5,14 @@
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <unistd.h>
+#include <string.h>
+#include <fcntl.h>
+#include <errno.h>
 
 #include "../utils/ast/ast.h"
 
+// --- Helpers ---
+
 /**
  * @brief converts a linked list of command arguments to an argv array. Don't
  * forget to free the result
@@ -44,6 +49,94 @@ static char **list_to_argv(struct list *command_list)
     return argv;
 }
 
+// --- Builtins ---
+
+static int builtin_echo(char **argv)
+{
+    bool newline = true;
+    int i = 1;
+
+    if (argv[1] && strcmp(argv[1], "-n") == 0)
+    {
+        newline = false;
+        i++;
+    }
+
+    for (; argv[i]; i++)
+    {
+        printf("%s", argv[i]);
+        if (argv[i + 1])
+            printf(" ");
+    }
+    if (newline)
+        printf("\n");
+    
+    fflush(stdout);
+    return 0;
+}
+
+static int builtin_true(char **argv)
+{
+    (void)argv;
+    return 0;
+}
+
+static int builtin_false(char **argv)
+{
+    (void)argv;
+    return 1;
+}
+
+static int builtin_exit(char **argv)
+{
+    int exit_val = 0;
+    if (argv[1])
+        exit_val = atoi(argv[1]);
+    exit(exit_val);
+    return exit_val;
+}
+
+static int builtin_cd(char **argv)
+{
+    const char *path = argv[1];
+    if (!path)
+    {
+        path = getenv("HOME");
+        if (!path)
+        {
+            fprintf(stderr, "cd: HOME not set\n");
+            return 1;
+        }
+    }
+    if (chdir(path) != 0)
+    {
+        perror("cd");
+        return 1;
+    }
+    return 0;
+}
+
+static int try_builtin(char **argv)
+{
+    if (!argv || !argv[0])
+        return 0;
+    
+    if (strcmp(argv[0], "echo") == 0)
+        return builtin_echo(argv);
+    if (strcmp(argv[0], "true") == 0)
+        return builtin_true(argv);
+    if (strcmp(argv[0], "false") == 0)
+        return builtin_false(argv);
+    if (strcmp(argv[0], "exit") == 0)
+        return builtin_exit(argv);
+    if (strcmp(argv[0], "cd") == 0)
+        return builtin_cd(argv);
+
+    return -1;
+}
+
+// --- Execution Core ---
+
 /**
  * @brief Executes a command represented by an ast_command structure
  *
@@ -54,7 +147,7 @@ static int exec_command(struct ast_command *command)
 {
     if (!command || !(command->command))
     {
-        return -1;
+        return 1;
     }
 
     char **argv = list_to_argv(command->command);
@@ -62,23 +155,30 @@ static int exec_command(struct ast_command *command)
     if (!argv || !(argv[0]))
     {
         free(argv);
-        return -1;
+        return 0;
+    }
+
+    int builtin_ret = try_builtin(argv);
+    if (builtin_ret != -1)
+    {
+        free(argv);
+        return builtin_ret;
     }
 
     pid_t pid = fork();
 
-    if (pid < 0) // Fork failed
+    if (pid < 0)
     {
         perror("fork");
         free(argv);
-        return -1;
+        return 1;
     }
 
-    if (pid == 0) // If child process
+    if (pid == 0)
     {
         execvp(argv[0], argv);
-        perror("execvp"); // If execvp returns, there was an error
-        exit(EXIT_FAILURE); // Exit child process
+        perror("execvp");
+        _exit(127);
     }
 
     int status = 0;
@@ -90,7 +190,7 @@ static int exec_command(struct ast_command *command)
         return WEXITSTATUS(status);
     }
 
-    return -1; // Should not happen
+    return 1;
 }
 
 /**
@@ -113,7 +213,7 @@ int execution(struct ast *ast)
     }
     case AST_CMD: {
         struct ast_command *command = ast_get_command(ast);
-        return exec_command(command); // It's recursive
+        return exec_command(command);
     }
     case AST_IF: {
         struct ast_if *if_node = ast_get_if(ast);
@@ -127,8 +227,117 @@ int execution(struct ast *ast)
             return execution(if_node->else_clause);
         }
     }
+    case AST_LIST: {
+        struct ast_list *list_node = ast_get_list(ast);
+        struct list *cur = list_node->children;
+        int ret = 0;
+        while (cur)
+        {
+            struct ast *child = (struct ast *)cur->data;
+            ret = execution(child);
+            cur = cur->next;
+        }
+        return ret;
+    }
+    case AST_AND_OR: {
+        struct ast_and_or *ao_node = ast_get_and_or(ast);
+        int left_ret = execution(ao_node->left);
+        
+        if (ao_node->type == AST_AND_OR_TYPE_AND)
+        {
+            if (left_ret == 0)
+                return execution(ao_node->right);
+            return left_ret;
+        }
+        else // OR
+        {
+            if (left_ret != 0)
+                return execution(ao_node->right);
+            return left_ret;
+        }
+    }
+    case AST_REDIR: {
+        struct ast_redir *redir = ast_get_redir(ast);
+        
+        int fd_target = redir->io_number;
+        if (fd_target == -1)
+        {
+            if (redir->type == AST_REDIR_TYPE_LESS || redir->type == AST_REDIR_TYPE_DLESS || redir->type == AST_REDIR_TYPE_LESSAND)
+                fd_target = 0;
+            else
+                fd_target = 1;
+        }
+        
+        int saved_fd = dup(fd_target);
+        
+        int new_fd = -1;
+        int flags = 0;
+        int mode = 0644;
+        
+        if (redir->type == AST_REDIR_TYPE_GREAT || redir->type == AST_REDIR_TYPE_CLOBBER)
+        {
+            flags = O_WRONLY | O_CREAT | O_TRUNC;
+            new_fd = open(redir->filename, flags, mode);
+        }
+        else if (redir->type == AST_REDIR_TYPE_DGREAT)
+        {
+             flags = O_WRONLY | O_CREAT | O_APPEND;
+             new_fd = open(redir->filename, flags, mode);
+        }
+        else if (redir->type == AST_REDIR_TYPE_LESS)
+        {
+             flags = O_RDONLY;
+             new_fd = open(redir->filename, flags);
+        }
+        else if (redir->type == AST_REDIR_TYPE_GREATAND || redir->type == AST_REDIR_TYPE_LESSAND)
+        {
+            // Simple fd duplication
+            new_fd = atoi(redir->filename);
+            // Verify new_fd is valid? dup2 will check.
+            if (dup2(new_fd, fd_target) == -1)
+            {
+                perror("dup2");
+                if (saved_fd != -1) close(saved_fd);
+                return 1;
+            }
+            new_fd = -2; // Mark as "already duped"
+        }
+        
+        if (new_fd == -1)
+        {
+            perror("open");
+            if (saved_fd != -1) close(saved_fd);
+            return 1;
+        }
+
+        if (new_fd != -2)
+        {
+            if (dup2(new_fd, fd_target) == -1)
+            {
+                perror("dup2");
+                close(new_fd);
+                if (saved_fd != -1) close(saved_fd);
+                return 1;
+            }
+            close(new_fd);
+        }
+
+        int ret = execution(redir->child);
+
+        if (saved_fd != -1)
+        {
+            dup2(saved_fd, fd_target);
+            close(saved_fd);
+        }
+        else
+        {
+            close(fd_target);
+        }
+
+        return ret;
+    }
     default: {
-        return -1; // Should not happen
+        return 127;
     }
     }
-}
+}