Write a C program that act as a command interpreter (a shell) for the UNIX kernel. Your shell program should accept and execute commands of the form:
command argument_1 argument_2 ......
where the command to be executed is the first word in the command and the remaining words are arguments expected by that command. The command line should be ended by a NEWLINE (enter or return) character, which is represented in C by 'n'. The command can be any executable file (i.e. any UNIX utility program such as. ls or grep, an any user defined program i.e. any program that you wrote and compiled yourself). While the user command is being executed in the foreground, the shell program should wait (use the fork/exec/wait). Your shell program, once invoked, should continuously accept and process user commands until it encounters the exit command (e.g. quit), at which point it terminates and returns to the original UNIX shell. Your shell should also handle background processes:
command [arguments] [&]
Attacking the Problem
To accomplish its job, a shell program must perform the following tasks:
1.display a prompt
2.read a command line from the terminal
3.Break the command line into tokens
4.Create a process to execute the command with the specified arguments
5.Go back to step 1
The cycle should be broken and the shell terminated when the quit string is encountered at the command line.
Displaying the prompt: there is a default prompt string for every shell (e.g. %, $, #, >). A production shell (such as the C shell), allows the user to modify the prompt by setting the environment variable PROMT. For your shell program, hardcode the prompt with a specific string terminated with a "%>" (e.g. "myshell%>")
Getting the command line: to get the command line, the shell performs a read operation which will cause the process executing the shell to be blocked until the user types a command line in response to the prompt. When the command has been provided by the user (and terminated with a NEWLINE character), the command line string is returned to the shell. Hint: use the gets( ) C function to do this.
"Parsing" the command: The shell does not perform any syntax analysis of the command line. It simply breaks the command line into tokens and builds the argv data structure expected in any C/UNIX main program. To break the command line into tokens, the parser begins at the left side of the command line string and scans until it sees a white space character (space or tab). The tokens are then stored in an array of strings (just like argv) which will later be passed as a parameter to the exec system call. Hint: use the strtok( ) C function to do this.
Note: if you are to write a production shell you would also need to find the path of the executable file by searching in all the directories specified by the PATH environment variable (see Lab exercise on page 76 of text book). A production shell would also provide mechanisms for the user to set the environment variables. However, for our purposes we can skip this phase by using execvp instead of execv and rely on the original UNIX shell to provide the search path (execvp will inherent the environment of its parent, which in this case is the original UNIX shell).
Executing the command: finally, the shell must execute the program with the argument specified in the command line. To do this you need to use the fork/exec/wait combination as discussed in class.
The above discussion provides the bare minimum functionality for a shell. A more sophisticated production shell must do more, e.g. keep track of current directory, handle background processes, handle redirection of stdin and stdout, support the pipe operation ("|"), and so.
Code Skeleton
Based on the above description, the program skeleton should roughly look as follows:
int main( )
{
// Variable declarations and initializations
......
// Main loop
while(TRUE)
{
//Display the prompt string
// Read the command line
// If the command is the quit command then break out of the loop
// break the command line into tokens and build an "argv like" structure.
// Create a process to execute the command
}
// Shell terminates
}
First, implement the basic parts to print the prompt and read the command line. In the first version, just print the command to cout .
Once you are able to read the command line, write code to tokenize it and build the argv structure. Again, just print the command and each of the arguments one per line on cout.
Finally, implement the command execution functionality using the fork/exec/wait code.
Be sure to document your program. Documentation should include: (1) The name of the author of the program (your name) and the date it was written, (2) a concise description of what the program does, (3) a clear description of its limitations if it does not meet all specifications, and (4) comments of critical code and data declarations. The same should also be done for each function written in the program. I will not grade any program that does not include the name of its author or a description of what it does.