The Ouch Shell

Introduction

Project Management

All files for this assignment are to have version numbers in the range 2.1 through 2.x. Check out each file from Assignment 3 for editing and, without making any changes, check it in again as version 2.1. For example, you would use the following commands for Makefile:

    % co -l Makefile
    % ci -f -r2.1 Makefile
    > No changes.  Starting work on Assignment 4.
    .
    %
  

Future assignments will use version numbers 3.x, 4.x, etc.

Multiple Source Modules

The main() method is to be defined in a file named ouch.cc. For this assignment you will be coding the following methods, each of which is to be in its own .cc file:

Function File Name Purpose getCommandLine() cmd_line.cc Prints a prompt string and reads an entire command line. getSubcommands() subcmds.cc Breaks a command line into sub-commands. tokenize() tokenize.cc Breaks a subcommand into tokens. expandToken() expand.cc Does variable substitutions and pattern matching for a token. executeCommand() exec_single.cc Executes a single command.

Requirements for Version 2.x

getCommandLine()

    int getCommandLine( char *buf, int max );

Use fgets() to read a command line from the user into .buf If a command line ends with a backslash (\), read another command line and append it to whatever you have read so far. When reading continuation lines, use the value of "PS2" as the prompt string if it is set, and use the string "no-prompt>> " if PS2 is not set. Never store more than max bytes into buf, including the end-of-string '\0'.

This function returns 0 if it is successful. It should never fail, but would return -1 if it did.

getSubCommands()

    subcommand_t* getSubcommands( char *buf );

      struct subcommand_t
      {
        char          *cmdString;
        char          termChar;
        token_t       *tokens;
        subcommand_t  *next;
      };
    

The terminating character will be removed from the command string by this function, and returned in the termChar field of the subcommand_t structure. Possible terminating characters are ';', '&', '|', '\0', and possibly other characters to be added in future versions of the shell. (For example, ksh lets you type a subcommand inside parentheses, which makes the command run in a "subshell." The terminating character would be ')' in that case.)

You need to code this function so it does not get fooled by terminating characters that appear inside strings or which are escaped by backslashes. For example, the following is all one subcommand, terminated by '\0':

      echo 'Semicolons (;) & pipes (|)' \& " ||| " are nice.
  

The memory for the linked list will have to be allocated dynamically, but the cmdString pointers may be pointers into the buf parameter. That is, this function may modify buf, much the way strtok() modifies the strings it tokenizes.

tokenize()

  token_t *tokenize( const subcommand_t *cmd );

    struct token_t
    {
      char          *token;
      token_tag_t   tag;
      token_t       *next;
    };

This function does not modify the string passed to it because the character that terminates one token might be the beginning of the next one, so there is no easy way to instert '\0' characters to break up the original string. Rather, the memory for the tokens has to be allocated dynamically.

Note that strings enclose tokens. The echo command listed above contains six tokens:

1. "echo"
2. "Semicolons (;) & pipes (|)"
3. "&"
4. " | | | "
5. "are"
6. "nice."

Although you can't use this code directly, the function [ strtok2() ] might give you some ideas how to work on the design of this function.

expandToken()

    char *expandToken( const char *token )

executeCommand()

    int executeCommand( subcommand_t *cmd );

Development Strategy

• Do a complete implementation of getCommandLine() as described above.
• Code getSubcommands() so that it simply returns the command line passed to it. That is, it doesn't actually break lines into subcommands at all. When testing your program, don't type in subcommands.
• Code tokenize() so that it recognizes only whitespace-separated tokens and does not handle quotes or redirection. The full version of this function will be part of Version 3.x of the assignment. Note: If you have already coded a version of tokenize() that does more than this requirement by the time you read this web page, you may leave your code intact. But it will have to match the definition of tokenize() described above for Version 3.x.
• Code expandToken() so it just returns the pointer passed to it.
• Code executeCommand() so it generates proper values of the traditional variables argc and argv suitable for passing to a main() function. If argv[0] is the name of an executable file (use your previous version of findExecutable()), execute the command. Code wait() so that this function determines the command's exit code, and return that value as the return value for this function. If the command does not name an executable file, print a "command not found" message and return 1.

    int result;
    char inBuf[ 1024 ];
    while ( true )
    {
      //  Read a command line
      result = getCommandLine( inBuf, sizeof( inBuf ) );
      if ( result != 0 )
      {
        fprintf( stderr, "Error reading command line\n" );
        continue;
      }
      fprintf ( stderr, "Result: %d\nStrlen: %d\nCommand: %s\n", 
                        result, strlen( inBuf ), inBuf );
      
      //  Break line into subcommands and tokenize each one
      subcommand_t *cmd_list = getSubcommands( inBuf );
      if ( 0 == cmd_list )
        continue; //  Empty command line
      subcommand_t *cmd = cmd_list;
      while ( cmd )
      {
        token_t *token_list = tokenize( cmd );
        if ( 0 == token_list )
          continue; // Not empty, but no tokens
        cmd->tokens = token_list;
        // execute it
        exitCode = executeCommand( cmd );
        cmd = cmd->next;
      }
    }

The main purpose of Version 2.x of the assignment is to be sure your project is set up with the proper source modules and Makefile. Be sure "make clean" leaves your project directory with nothing but the RCS subdirectory in it, be sure that "make" builds program correctly after you run "make clean,", be sure "make" recompiles only those files you have edited since the last make, and be sure that the sequence "touch ouch.h ; make" recompiles everything before linking.

Be sure to test your program carefully to be sure it works. In particular, be sure nothing happens in interactive mode if the user types an empty command line. Be sure prompt strings are handled correctly; you will probably find that the PS1 and PS2 variables are already set up if you log into a Linux account, and the prompt printed for PS1 will not be "pretty." But on forbin you will have to set up your own values for PS1 and PS2.

Due Date and Grading Criteria

The assignment will be graded on a 5-point scale, with each of the following counting approximately equally:

• Does the tar file contain a subdirectory for the project, is the project directory empty except for an RCS subdirectory, and possibly a file named README (spelled and capitalized exactly like that)?
• Does the following procedure build the ouch application with no warnings or error messages: Checkout a copy of Makefile, locked for editing; type the command "(g)make depend," and check the Makefile back in; type the command "(g)make."
• Does "touch ouch.h; (g)make" recompile everything, and does "(g)make clean" remove everything from the project directory other than the RCS subdirectory and possibly the README file? Do all the files for the project have RCS version numbers in the 2.x range?
• Are the source modules named in the assignment handout all present, and are all required functions defined using the proper function prototypes? Are the source modules coded and documented according to the coding guidelines for the course?
• Does the program manage PS1 and PS2 environment variables correctly, does the program interactively handle a sequence of simple command lines (external commands with any number of arguments; empty command lines; commands with names of nonexistent files) correctly; and does the program process the -c command line option correctly? Do both subcommands entered on the command line and those entered interactively receive the correct environment? In interactive mode, does a backslash at the end of a line allow the user to continue a command line correctly?