For your assignment you must build on two existing C programs as described below.

Super Text Printer

In your prior assignment, you developed a program to print text and allow control over line sequencing and timing. In this assignment, you start with a template program (below) with that functionality, and enhance it. It should be improved to allow variables to be defined and used, to support files and data streams of unlimited size, and to allow for file inclusion. Note you should note start with your own particular solution from the last assignment as the starting template.

Build on the solution provided below to create a program superprinter that reads the characters in a file (specified as an argument to the program) and prints the text to stdout. When it encounters a line whose first character is a period, it reads to following characters as a special command.

If the command is:

.quit                            -- the program exits,
.sleep N (where N is an integer) -- the program pauses for N seconds,
.rewind                          -- the program starts reading from the
                                    beginning of the file again
.rewind N                        -- rewind N lines forward from the 
                                    beginning,
.skip N                          -- skip the next N lines in the file
.set A = expr                    -- set a variable A to an expression
.include path                    -- include another file in the output
                                   (do not read commands in this file though)
.system A = s                    -- A takes the result of the UNIX command s
                                   (e.g. .system A date)

Expressions take the form value1 operator value2 where the operator can be one of:

 +          -- addition
 -          -- subtraction
 *
 /
 |          -- string concatenation (e.g.  hell | o  -> hello)
 R          -- repetition (e.g. hi R 3  -> hihihi )

If the string $$name occurs anywhere in the text, the 
value of the variable called name should be interpolated.  If no
such variable exists, then the string should be unchanged.

Variables can take on string values, but if used in an arithmetic expression
then they numeric equivalent should be used  (i.e. the value 32
for the variable "32"). If a variable has a non-numeric interpretation, then
the numeric value is zero (i.e.  hello + 3 has the result 3).


Click here for a solution to the iprinter program from
the last assignment that must be used as your starting point for this problem.
NOTE: There was a bug in the program which made it stop 
reading when it encountered empty lines in the input file. That problem has been fixed.

Part 2, superlife

The "game of life" is a standard example of a cellular automation.  
This was briefly discussed in class and in the 
.
In this assignment you will start with a fully operational life 
program.  You need to modify and improve it in serval ways.
These are as follows:

 The field (board) has a fixed size. Make the program flexible so this
  is a command-line parameter.  Use dynamic memory allocation to do this, no
  static arrays (except for help text). (Note handling for the require command-line arguments
  has already been implemented for you.)
 Implement the ability to save and restore the playing field. (Basic reading/restoring
  is already implemented for you. Implement saving in a compatible fashion.)
 In the saved files, allow comment lines starting with a '%' character (in column 1).
     Lines of this form should be ignore when the file is read in.
 Add a command-line flag -q (for quiet) to inhibit the graphic display.
 Implement feedback to the user when invalid command line arguments are
  provided (some text is already provided).
 Allow for flexible life rules.  The rules for life
  can be encoded as outcomes as a function of the number of neighbors that a
  cell has.  The default rule for  survival, for example, it that if you have
  3 or 4 neighbors you survive, otherwise you die.  For birth, if an empty cell 
  has exactly 3 neighbors an element is born there.  These two rules can be 
  encoded as:

    34/3
    

  Provide the ability to take a new set of rules as a command-line argument of
  the form:  as3lstart -r 34/3
 Allow for cells to have a family ID (an integer).  Allow for an alternative
  set of rules based on the number of neighbors from your own family, versus the
  number of non-family neighhbors.  This set of rules will be an 8x8 table of bits
  for each of the survival and birth conditions. Read the rules from the 
  command line in the form:

  as3lstart -R N r1 r2 r3 r4 r5 r6 r7 r8

  where N is the number of families and r1 through r8 are rows rules of the form 34/3.
  

  You probably want to implement this last, as it is the most obscure feature.


Output of the multi-family variation should look like this file (which is
the save file that resulted after 100 generations).

Start with the coding of the ability to use a
world of arbitrary size (do this using dynamically allocated memory). The sample code
for you to start with is
as3lstart.c
You can compile it using the command
   gcc -o as3lstart as3lstart.c -O2 -Wall -s -lcurses


Submit: 1) your source code (see course page), 2) testing, 3) timing data on how long
it takes to run 10,000 generations on a 80x80 world with one family, with and without screen
output (quiet mode), Give the time per generation. Evaluation criteria: performance, 
elegance, completeness, robustness, efficiency.


See the course home page hot links section for information related to this
code assignment and/or sample.  
Be sure to read the policy of collaboration, independence and
plagarism on the class home page.