master

Author: OneM1

arg_handle.c

@@ -0,0 +1,28 @@
+#include "shell.h"
+
+
+/**
+ * main - Entry point for a shell that handles command arguments.
+ *
+ * Return: Exit status.
+ */
+
+int argument_handling() {
+    char *buffer = NULL;
+    size_t bufsize = 0;
+    char **args;
+
+    while (1) {
+        printf("$ ");
+        getline(&buffer, &bufsize, stdin);
+
+        args = parse_input(buffer);
+        execute_command(args);
+
+        free(args);
+    }
+
+    free(buffer);
+    return 0;
+}
+

bas_com.c

@@ -0,0 +1,31 @@
+#include "shell.h"
+
+
+/**
+ * main - Entry point for a basic shell that executes single commands.
+ *
+ * Return: Exit status.
+ */
+
+
+int basic_command_execution(){
+    char *buffer = NULL;
+    size_t bufsize = 0;
+    char *args[2]; 
+
+    while (1) {
+        printf("$ ");
+        getline(&buffer, &bufsize, stdin);
+
+        buffer[strcspn(buffer, "\n")] = 0;
+        if (strlen(buffer) == 0) continue;
+
+        args[0] = buffer; 
+        args[1] = NULL;
+
+        execute_command(args);
+    }
+
+    free(buffer);
+    return 0;
+}

env.c

@@ -0,0 +1,42 @@
+#include "shell.h"
+
+
+/**
+ * main - Entry point for a shell that can display environment variables.
+ *
+ * Return: Exit status.
+ */
+
+
+extern char **environ; 
+
+int environment_builtin_command() {
+    char *buffer = NULL;
+    size_t bufsize = 0;
+    char **args;
+    char **env; 
+
+    while (1) {
+        printf("$ ");
+        getline(&buffer, &bufsize, stdin);
+
+        args = parse_input(buffer);
+
+        if (strcmp(args[0], "exit") == 0) {
+            free(args);
+            break;
+        } else if (strcmp(args[0], "env") == 0) {
+            for (env = environ; *env != NULL; env++) {
+                printf("%s\n", *env);
+            }
+        } else {
+            execute_command(args);
+        }
+
+        free(args);
+    }
+
+    free(buffer);
+    return 0;
+}
+

exit.c

@@ -0,0 +1,34 @@
+#include "shell.h"
+
+
+/**
+ * main - Entry point for a shell that implements the 'exit' command.
+ *
+ * Return: Exit status.
+ */
+
+
+int exit_builtin_command() {
+    char *buffer = NULL;
+    size_t bufsize = 0;
+    char **args;
+
+    while (1) {
+        printf("$ ");
+        getline(&buffer, &bufsize, stdin);
+
+        args = parse_input(buffer);
+
+        if (strcmp(args[0], "exit") == 0) {
+            free(args);
+            break;
+        }
+
+        execute_command(args);
+        free(args);
+    }
+
+    free(buffer);
+    return 0;
+}
+

hsh

@@ -0,0 +1,64 @@
+#include "shell.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+extern char** environ; 
+
+int main(int argc, char *argv[]) {
+    char *input;
+    size_t input_size = 0;
+    size_t input_length;
+
+    if (argc > 1) {
+        
+        FILE *input_file = fopen(argv[1], "r");
+        if (input_file == NULL) {
+            perror("Error opening input file");
+            return EXIT_FAILURE;
+        }
+
+        input = NULL;
+
+        while (getline(&input, &input_size, input_file) != -1) {
+            
+            input_length = strlen(input);
+            if (input_length > 0 && input[input_length - 1] == '\n') {
+                input[input_length - 1] = '\0';
+            }
+
+            
+            printf("You entered: %s\n", input);
+        }
+
+        free(input);
+        fclose(input_file);
+    } else {
+        
+        input = NULL;
+
+        while (1) {
+            printf("($) ");
+            getline(&input, &input_size, stdin);
+
+            
+            input_length = strlen(input);
+            if (input_length > 0 && input[input_length - 1] == '\n') {
+                input[input_length - 1] = '\0';
+            }
+
+            if (strcmp(input, "exit") == 0) {
+                free(input);
+                exit(0);
+            }
+
+           
+            printf("You entered: %s\n", input);
+        }
+
+        free(input);
+    }
+
+    return 0;
+}
+

main.c

@@ -0,0 +1,28 @@
+#include "shell.h"
+
+
+/**
+ * main - Entry point for a shell that handles command arguments.
+ *
+ * Return: Exit status.
+ */
+
+int environment_variable_handling() {
+    char *buffer = NULL;
+    size_t bufsize = 0;
+    char **args;
+
+    while (1) {
+        printf("$ ");
+        getline(&buffer, &bufsize, stdin);
+
+        args = parse_input(buffer);
+        execute_command(args);
+
+        free(args);
+    }
+
+    free(buffer);
+    return 0;
+}
+

path_handle.c

@@ -0,0 +1,77 @@
+#include "shell.h"
+
+char **parse_input(char *input) {
+    int position = 0;
+    char **tokens;
+    char *token;
+
+    tokens = malloc(MAX_ARGS * sizeof(char*));
+    if (!tokens) {
+        fprintf(stderr, "allocation error\n");
+        exit(EXIT_FAILURE);
+    }
+
+    token = strtok(input, " \t\r\n\a");
+    while (token != NULL) {
+        tokens[position++] = token;
+        if (position >= MAX_ARGS) {
+            position = MAX_ARGS - 1;
+            break;
+        }
+        token = strtok(NULL, " \t\r\n\a");
+    }
+    tokens[position] = NULL;
+    return tokens;
+}
+
+char *find_command_in_path(char *cmd) {
+    char *path, *path_copy, *token, *full_path;
+    struct stat st;
+
+    path = getenv("PATH");
+    path_copy = strdup(path);
+    full_path = malloc(BUFFER_SIZE * sizeof(char));
+
+    token = strtok(path_copy, ":");
+    while (token != NULL) {
+        snprintf(full_path, BUFFER_SIZE, "%s/%s", token, cmd);
+        if (stat(full_path, &st) == 0) {
+            free(path_copy);
+            return full_path;
+        }
+        token = strtok(NULL, ":");
+    }
+
+    free(path_copy);
+    free(full_path);
+    return NULL;
+}
+
+void execute_command(char **args) {
+    pid_t pid;
+    int status;
+    char *command_path;
+
+    command_path = find_command_in_path(args[0]);
+    if (command_path == NULL) {
+        printf("%s: command not found\n", args[0]);
+        return;
+    }
+
+    pid = fork();
+    if (pid == 0) {
+        if (execv(command_path, args) == -1) {
+            perror("Error");
+        }
+        exit(EXIT_FAILURE);
+    } else if (pid < 0) {
+        perror("Error");
+    } else {
+        do {
+            waitpid(pid, &status, WUNTRACED);
+        } while (!WIFEXITED(status) && !WIFSIGNALED(status));
+    }
+
+    free(command_path);
+}
+

shell.c

@@ -0,0 +1,25 @@
+#ifndef SHELL_H
+#define SHELL_H
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/wait.h>
+#include <sys/stat.h>
+
+#define BUFFER_SIZE 1024
+#define MAX_ARGS 64
+
+
+char **parse_input(char *input);
+char *find_command_in_path(char *cmd);
+void execute_command(char **args);
+int basic_command_execution(void);
+int argument_handling(void);
+int environment_variable_handling(void);
+int exit_builtin_command(void);
+int environment_builtin_command(void);
+
+#endif 
+