CS253 HW6: Recursion!                

Batman #8, 1942

Changes                

Updates to the assignment will be noted here. None yet!                 

Description                

Remember composition of functions? In mathematics, if you want to define z as the square root of the sine of x, you don’t have to do all this:                 

Instead, you simply write z = sqrt sin x . We all understand that this applies the sine function to x, and then applies the square root function to that result.                 

We’re going to do a similar thing with commands. We’re going to feed the output of one or more commands into another command, feed that output into another command, and so on.                 

For this assignment, you will improve your work from HW4. Instead of merely running a single command with arguments, you will run several commands, and feed the output of the inner commands to the output commands, nested to an arbitrary depth.                 

For example, this input:                 

    sort(echo(beta) echo(delta) echo(alpha))

would execute echo(beta), producing beta. Similarly, echo(delta) and echo(alpha) would produce delta and alpha. The output of those echo commands would be placed into temporary files. Then, sort would be executed, with the three temporary files as arguments, and would produce the standard output:                 

    alpha
    beta
    delta

Each argument to a program can be either a word, as defined in HW4, or another program. It it’s a program, run that program with its arguments (which might themselves be programs), put its output into a temporary file, and use the temporary file as an argument to the upper program.                 

Temporary files                

You may create as many temporary files as you wish, but all temporary files must be cleaned up by calling remove(). However, if the program terminates with an error (e.g., from an improperly-formatted input line) then it’s ok (but not admirable) to leave temporary files.                 

Temporary files must be in the current directory, and must be of the form tempnumber.tmp. For example, temp1.tmp, temp0177777.tmp, and temp6750207.tmp are all valid temporary file names.                 

New execute() function                

The file ~cs253/Example/execute2.cc provides a new version of the function execute:                 

    bool execute(vector<string> command, string outfile="");

It is identical to the previous version, except for the optional additional argument. If that argument is provided, it must be the path of an output file, and the standard output of the command will be written to that file. If the file does not exist, it will be created. If it already exists, it will be overwritten.                 

You may copy this function into your code, modify it as you wish, or ignore it completely.                 

Sample Runs                

Here are sample runs, where % is my prompt.                 

% cat data1
cat(/etc/hostname)
echo(===)
sort(date() /etc/hostname)
% ./hw6 data1
beethoven
===
beethoven
Sun Apr  4 23:35:29 MDT 2021
% cat data2
cat(sort(cat(sort(cat(sort(echo(f\oo)))))))
% ./hw6 <data2
foo
% cat data3
sort(echo(Zeta) sed(s/[0-9]/*/g date()))
ps(-H)
% ./hw6 data3
Sun Apr  * **:**:** MDT ****
Zeta
    PID TTY          TIME CMD
 194269 pts/0    00:00:00 bash
 195829 pts/0    00:00:00   hw6
 195834 pts/0    00:00:00     ps

Hints                

For my implementation, I wrote a recursive function called command:                 

    void command(Words w,		// input line broken into words
        	 size_t start,		// where to start looking
        	 size_t end,		// where to stop looking
        	 bool verbose,		// from the -v argument
        	 size_t max_args,	// from the -m argument
        	 string outfile = "");	// optional output file

This function handles an entire input line, already parsed into a Words object. It accumulates arguments and calls execute(). If an argument is of the form word(…), then it’s a sub-process, handled by a recursive call to command().                 

For example, given this input line of 7 words:                 

    sort(/etc/hostname date())

The initial call to command might be:                 

    command(Words, 0, 7, …)

This would generate a recursive call to parse & execute date(), and place the output, “Thu Nov 21 17:50:07 MST 2024” in temp1.tmp:                 

    command(Words, 3, 6, …, temp1.tmp)

This would, effectively, rewrite the input line as:                 

    sort(/etc/hostname temp1.tmp)

Then, it would execute sort with the arguments /etc/hostname and temp1.tmp, producing this output (your computer name will vary):                 

    beethoven
    Thu Nov 21 17:50:07 MST 2024

You may copy this technique, or ignore it completely.                 

    export STACK_FRAME_LINK_OVERRIDE=ffff-ad921d60486366258809553a3db49a4a

Requirements                

All requirements from HW4 still apply, plus:

• The -v option should display the command actually executed, including any temporary filenames as input. A complex input line such as cat(date()) would result in two sets of -v output: one for executing date, and one for executing cat with a temporary file.
• Sub-commands must be executed left-to-right. That is, in alpha(beta() gamma()), the commands must execute in the order beta, gamma, and finally alpha.

Tar file                

• The tar file for this assignment must be called: hw6.tar
• It must contain:
  • source files (*.cc) required to build
  • any header files (*.h) required to build
  • CMakeLists.txt
• This command must produce the program hw6 (note the dot):

    cmake . && make

• At least -Wall must be used every time g++ runs.

How to submit your work:                

In Canvas, check in the file hw6.tar to the assignment “HW6”. It’s due 10:00:00ᴘᴍ MT Saturday, with a 24-hour late period for a 25% penalty.                 

How to receive negative points:                

Turn in someone else’s work.