# Building a Simple Shell in C

Ever thought about creating your own shell? It might seem tough, but with C programming, it's pretty simple. Let's break down a basic shell implementation step-by-step.

### What This Code Does

This code is a basic shell program that lets users execute commands in a terminal. It reads user input, parses the command, and executes it. Here’s how it works:

### Header Files and other ish

```c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/wait.h>
#include <fcntl.h>

#define MAX_COMMAND_LENGTH 1024
#define MAX_ARGS 64
#define MAX_ARG_LENGTH 256
#define DELIMETERS " \t\r\n\a"
```

### Key Components

1. **Prompt Display**:
    
    ```c
    void print_prompt() {
        printf("sell-shell> ");
    }
    ```
    
    * This function displays a simple prompt ("sell-shell&gt; ") to indicate that the shell is ready to accept commands.
        
2. **Reading Commands**:
    
    ```c
    void read_command(char *cmd) {
        fgets(cmd, MAX_COMMAND_LENGTH, stdin);
    }
    ```
    
    * This function reads the user input from the terminal and stores it in the `cmd` array.
        
3. **Parsing Commands**:
    
    ```c
    void parse_command(char *cmd, char **args) {
        int index = 0;
        char *token = strtok(cmd, DELIMETERS);
        while (token != NULL) {
            args[index++] = token;
            token = strtok(NULL, DELIMETERS);
        }
        args[index] = NULL;
    }
    ```
    
    * Here, the input command is split into separate arguments using `strtok`. For example, if the user types `ls -l`, `parse_command` will split it into `["ls", "-l", NULL]`.
        
4. **Background Execution**:
    
    ```c
    int is_background(char **args) {
        int i = 0;
        while (args[i] != NULL) {
            if (strcmp(args[i], "&") == 0) {
                args[i] = NULL;
                return 1;
            }
            i++;
        }
        return 0;
    }
    ```
    
    * This function checks if the user wants to run the command in the background by looking for an `&` at the end of the command. If found, it removes the `&` and returns `1`, otherwise `0`.
        
5. **Executing Commands**:
    
    ```c
    void execute_command(char **args, int background) {
        pid_t pid = fork();
        if (pid == 0) {  
            if (execvp(args[0], args) == -1) {
                perror("simple-shell");
            }
            exit(EXIT_FAILURE);
        } else if (pid < 0) {
            perror("simple-shell");
        } else {  
            if (!background) {
                int status;
                waitpid(pid, &status, 0);
            }
        }
    }
    ```
    
    * This function forks a new process to execute the command. If the command is not meant to run in the background, it waits for the command to complete.
        
6. **Main Loop**:
    
    ```c
    int main() {
        char cmd[MAX_COMMAND_LENGTH];
        char *args[MAX_ARGS];
        int background;
    
        while (1) {
            print_prompt();
            read_command(cmd);
            if (strlen(cmd) == 1 && cmd[0] == '\n') {
                continue;
            }
            parse_command(cmd, args);
            background = is_background(args);
            execute_command(args, background);
        }
        
        return 0;
    }
    ```
    
    1. The main loop keeps running (like a pig), displaying the prompt, reading user input, parsing it, checking for background execution, and finally executing the command.
        
    
    ### Summary
    
    This basic shell in C shows essential shell functions: showing a prompt, reading commands, parsing arguments, and executing them. It also lets you run commands in the background. If you're new to systems programming, this is a great way to learn how shells operate!