As it happened, Practical 16, task 6 had been cunningly designed in anticipation of this exam question. In that Practical you had been given code like

   PROGRAM DeMorganDemo;
   (* P.D. Terry, Rhodes University, 1999 *)

     BOOL
       X, Y;

     BEGIN
       Write('   X     Y      (X.Y)'' X'' + Y''');
       X := FALSE;
       REPEAT
         Y := FALSE;
         REPEAT
           Write(X, Y, NOT (X AND Y), NOT X OR NOT Y);
           Y := NOT Y;
         UNTIL Y = FALSE (* again *)
         X := NOT X
       UNTIL X = FALSE  (* again *)
     END.

One has the same sort of "prologue" and "epilogue" for setting up a loop to cycle through the values for each variable, and in the innermost body there is simply the important code to evaluate the expression, and then write out its value. One has to be careful to set up the "labels" correctly, and to set up the loops correctly (take a careful look at the attributes used in the Function production; not many got these exactly right).

To be fair, the standard "writestring" system does not produce pretty output across the top of the table. The version of TRUTH.EXE you had been given in the exam kit used an extended version of the PRS opcode to achieve a better effect. Every year some students throw up ideas that are at least as good if not better than my own; I was delighted to see that some students had really imaginative ideas about how to format these names that I had not thought of using.

Overall, though, the solutions received were of rather poor quality, other than about half a dozen who had clearly seen almost exactly how to achieve what was required, and produced superb results, with only the sort of silly mistakes that one must expect under pressure. Given that the grammar itself had appeared in Quiz 25, it was disappointing that many people did not even have this correct, or had got virtually no further.

C++ Solution

   COMPILER Truth $XNC
   /* Truth Table grammar
      This solution uses the Stack machine, table handler and code generator of
      the Clang compiler.  It generates simple repeat loops automagically through
      calls to the internal routines Prolog and Epilog before evaluating the rhs
      of each expression.  Have a look at Prac 16, Task 6 and Quiz 25.  Quiz 25
      actually gave you most of the grammar, while Prac 16 shows how to set up
      the loops.  Ah well, next time you'll study the solutions!
      P.D. Terry, Rhodes University, 1999 */

   #include "table.h"
   #include "report.h"
   #include "cgen.h"

   extern TABLE  *Table;
   extern CGEN   *CGen;
   extern REPORT *Report;  // needed for debugging pragma

   bool WriteAsBoolean;
   CGEN_labels LabelList[100];

   void Prolog1 (int v, CGEN_labels &l)
   {
     CGen->stackaddress(v);
     CGen->stackconstant(0);
     CGen->assign();
     CGen->storelabel(l);
   }

   void Prolog2 (int v)
   {
     CGen->stackaddress(v);
     CGen->dereference();
     CGen->stackconstant(6);  /* default format for PRN or PRB */
     if (WriteAsBoolean) CGen->writeboolean(); else CGen->writevalue();
   }

   void Epilogue (int v, CGEN_labels l)
   { CGEN_labels here;
     CGen->stackaddress(v);
     CGen->stackaddress(v);
     CGen->dereference();
     CGen->negateboolean();
     CGen->assign();
     CGen->stackaddress(v);
     CGen->dereference();
     CGen->negateboolean();
     CGen->jumponfalse(here, l);
   }

   /* ---------------------------------------------------------------------- */

   IGNORE CASE
   IGNORE CHR(9) .. CHR(13)
   COMMENTS FROM "(*" TO "*)" NESTED

   CHARACTERS
     letter     = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" .
     digit      = "0123456789" .

   TOKENS
     identifier = letter { letter | digit | "_" } .

   PRODUCTIONS
     Truth
     = Logic { WEAK ";" Logic }    (. CGen->leaveprogram(); .)
       EOF .

     Logic
     =                             (. int framesize;
                                      char name[100];
                                      CGEN_labels startstring; .)
       [
       ( [ "NUMERIC" ]             (. WriteAsBoolean = FALSE; .)
         | "BOOLEAN"               (. WriteAsBoolean = TRUE; .)
       )
       Ident<name>                 (. framesize = 0; Table->reset(); .)
       Parameters<framesize>       (. CGen->stackstring(name, startstring);
                                      CGen->writestring(startstring);
                                      CGen->newline();
                                      CGen->openstackframe(framesize); .)
       WEAK "="
       Function<framesize>         (. CGen->openstackframe(-framesize);
                                      CGen->newline();  .)
       ] .

     Parameters<int &framesize>
     = "(" OneVar<framesize> { WEAK "," OneVar<framesize> } ")" .

     OneVar<int &framesize>
     =                             (. TABLE_entries entry;
                                      CGEN_labels startstring; .)
       Ident<entry.name>           (. entry.idclass = TABLE_vars;
                                      entry.v.size = 1; entry.v.scalar = true;
                                      entry.v.offset = framesize + 1;
                                      Table->enter(entry);
                                      framesize++;
                                      CGen->stackstring(entry.name, startstring);
                                      CGen->writestring(startstring); .) .

     Designator
     =                             (. TABLE_entries entry;
                                      TABLE_alfa name;
                                      bool found; .)
       Ident<name>                 (. Table->search(name, entry, found);
                                      if (!found) SemError(202);
                                      CGen->stackaddress(entry.v.offset);
                                      CGen->dereference(); .) .

     Function<int VarsUsed>
     =                             (. int i; .)
                                   (. for (i = 1; i<= VarsUsed; i++)
                                        Prolog1(i, LabelList[i]);
                                      for (i = 1; i<= VarsUsed; i++)
                                        Prolog2(i); .)
       Expression                  (. CGen->stackconstant(6); /* default format for PRN or PRB */
                                      if (WriteAsBoolean) CGen->writeboolean();
                                      else CGen->writevalue();
                                      CGen->newline();
                                      for (i = VarsUsed; i >= 1; i--)
                                        Epilogue(i, LabelList[i]); .) .

     Expression
     = Term
       { Or Term                   (. CGen->binarybooleanop(CGEN_orrop); .)
       } .

     Term
     = Factor
       { [ And ] Factor            (. CGen->binarybooleanop(CGEN_andop); .)
       } .

     Factor
     =   Not Factor                (. CGen->negateboolean(); .)
       | Primary
         { "'"                     (. CGen->negateboolean(); .)
         } .

     Primary
     =   Designator
       | True                      (. CGen->stackconstant(1); .)
       | False                     (. CGen->stackconstant(0); .)
       | "(" Expression ")" .

     And   = "AND"   | "&" | "." .
     Or    = "OR"    | "|" | "+" .
     Not   = "NOT"   | "!" | "~" .
     True  = "TRUE"  | "1" .
     False = "FALSE" | "0" .

     Ident<char *name>
     =  identifier                 (. LexName(name, TABLE_alfalength); .) .

   END Truth.

Pascal Solution

   COMPILER Truth $XNC
   (* Truth Table grammar - no extra m/c codes
      This solution uses the Stack machine, table handler and code generator of
      the Clang compiler.  It generates simple repeat loops automagically through
      calls to the internal routines Prolog and Epilog before evaluating the rhs
      of each expression.  Have a look at Prac 16, Task 6 and Quiz 25.  Quix 25
      actually gave you most of the grammar, while Prac 16 shows how to set up
      the loops.  Ah well, next time you'll study the solutions!
      P.D. Terry, Rhodes University, 1999 *)

   USES CGEN, STKMC, TABLE;

   VAR
     WriteAsBoolean : BOOLEAN;
     LabelList : ARRAY [1 .. 100] OF CGEN.Labels;

   PROCEDURE Prolog1 (V : INTEGER; VAR L : CGEN.Labels);
     BEGIN
       CGEN.StackAddress(V);
       CGEN.StackConstant(0);
       CGEN.Assign;
       CGEN.StoreLabel(L);
     END;

   PROCEDURE Prolog2 (V : INTEGER);
     BEGIN
       CGEN.StackAddress(V);
       CGEN.Dereference;
       CGEN.StackConstant(6);     (* default format for PRN or PRB *)
       IF WriteAsBoolean THEN CGEN.WriteBoolean ELSE CGEN.WriteValue;
     END;

   PROCEDURE Epilogue (V : INTEGER; L : CGEN.Labels);
     VAR
       Here : CGEN.Labels;
     BEGIN
       CGEN.StackAddress(V);
       CGEN.StackAddress(V);
       CGEN.Dereference;
       CGEN.NegateBoolean;
       CGEN.Assign;
       CGEN.StackAddress(V);
       CGEN.Dereference;
       CGEN.NegateBoolean;
       CGEN.JumpOnFalse(Here, L);
     END;

   (* ---------------------------------------------------------------------- *)

   IGNORE CASE
   IGNORE CHR(9) .. CHR(13)
   COMMENTS FROM "(*" TO "*)" NESTED

   CHARACTERS
     letter     = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" .
     digit      = "0123456789" .

   TOKENS
     identifier = letter { letter | digit | "_" } .

   PRODUCTIONS
     Truth
     = Logic { WEAK ";" Logic }    (. CGEN.LeaveProgram; .)
       EOF .

     Logic                         (. VAR
                                        FrameSize : INTEGER;
                                        Name : TABLE.ALFA;
                                        StartString : CGEN.Labels; .)
     = [
       ( [ "NUMERIC" ]             (. WriteAsBoolean := FALSE; .)
         | "BOOLEAN"               (. WriteAsBoolean := TRUE; .)
       )
       Ident<Name>                 (. FrameSize := 0; Table.Reset; .)
       Parameters<FrameSize>       (. CGEN.StackString(Name, StartString);
                                      CGEN.WriteString(StartString);
                                      CGEN.NewLine;
                                      CGEN.OpenStackFrame(FrameSize) .)
       WEAK "="
       Function<FrameSize>         (. CGEN.OpenStackFrame(-FrameSize);
                                      CGEN.NewLine;  .)
       ] .

     Parameters<VAR FrameSize : INTEGER>
     = "(" OneVar<FrameSize> { WEAK "," OneVar<FrameSize> } ")" .

     OneVar<VAR FrameSize : INTEGER>
                                   (. VAR
                                        Entry : TABLE.ENTRIES;
                                        StartString : CGEN.Labels; .)
     = Ident<Entry.Name>           (. Entry.IDClass := Vars; Entry.Size := 1;
                                      Entry.Scalar := TRUE;
                                      Entry.Offset := FrameSize + 1;
                                      TABLE.Enter(Entry);
                                      INC(FrameSize);
                                      CGEN.StackString(Entry.Name, StartString);
                                      CGEN.WriteString(StartString) .) .

     Designator                    (. VAR
                                        Name  : TABLE.ALFA;
                                        Entry : TABLE.ENTRIES;
                                        Found : BOOLEAN; .)
     = Ident<Name>                 (. TABLE.Search(Name, Entry, Found);
                                      IF NOT Found THEN SemError(202);
                                      CGEN.StackAddress(Entry.Offset);
                                      CGEN.Dereference; .) .

     Function<VarsUsed : INTEGER>
                                   (. VAR I : INTEGER; .)
     =                             (. FOR I := 1 TO VarsUsed DO
                                        Prolog1(I, LabelList[I]);
                                      FOR I := 1 TO VarsUsed DO
                                        Prolog2(I); .)
       Expression                  (. CGEN.StackConstant(6); (* default format for PRN or PRB *)
                                      IF WriteAsBoolean
                                        THEN CGEN.WriteBoolean
                                        ELSE CGEN.WriteValue;
                                      CGEN.NewLine;
                                      FOR I := VarsUsed DOWNTO 1 DO
                                        Epilogue(I, LabelList[I]); .) .

     Expression
     = Term
       { Or Term                   (. CGEN.BinaryBooleanOp(opOR); .)
       } .

     Term
     = Factor
       { [ And ] Factor            (. CGEN.BinaryBooleanOp(opAND); .)
       } .

     Factor
     =   Not Factor                (. CGEN.NegateBoolean; .)
       | Primary
         { "'"                     (. CGEN.NegateBoolean; .)
         } .

     Primary
     =   Designator
       | True                      (. CGEN.StackConstant(1); .)
       | False                     (. CGEN.StackConstant(0); .)
       | "(" Expression ")" .

     And   = "AND"   | "&" | "." .
     Or    = "OR"    | "|" | "+" .
     Not   = "NOT"   | "!" | "~" .
     True  = "TRUE"  | "1" .
     False = "FALSE" | "0" .

     Ident<VAR Name : TABLE.ALFA>
                                   (. VAR Str : STRING; .)
     =  identifier                 (. LexName(Str); Name := Str; .) .

   END Truth.

A completely different approach was taken by another set of students. At first I was sceptical that this would work, but once it had been explained and debugged I was quite intrigued. Here it is

  COMPILER Bool $XNC
  /* Bool Table grammar
     P.D. Terry, Rhodes University, 1999 */

  /* Corrected version of Josh Vincent's ideas */

  #include "table.h"
  #include "math.h"
  #include "report.h"

  extern TABLE *Table;
  extern REPORT *Report;

  void calculate (int position, bool array[])
  { int count = 0, segment = 1;
    while (segment <= pow(2, 7 - position))
    { int x = 1;
      while (x <= pow(2, position - 1)) { array[count] = 0; count++; x++; }
      while (x <= pow(2, position))     { array[count] = 1; count++; x++; }
      segment++;
    }
  }

  /* ---------------------------------------------------------------------- */

  IGNORE CASE
  IGNORE CHR(9) .. CHR(13)
  COMMENTS FROM "(*" TO "*)" NESTED

  CHARACTERS
    letter     = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" .
    digit      = "0123456789" .

  TOKENS
    identifier = letter { letter | digit | "_" } .

  PRODUCTIONS
    Bool = BoolStatement { WEAK ";" BoolStatement } EOF .

    BoolStatement
    =                             (. bool Result[128], BoolOutput = false;
                                     int params = 0;
                                     Table->reset(); .)
      [
      ( [ "NUMERIC" ]
        | "BOOLEAN"               (. BoolOutput = true; .)
      )
      Function<params> WEAK "="
      Expression<Result>          (. for (int j = 0; j <pow(2, params); j++)
                                     { for (int i = 0; i < params; i++)
                                       { bool pvalue = Table->getval(i+1, j);  // error here
                                         if (BoolOutput) {
                                           if (pvalue) printf("  TRUE"); else printf(" FALSE");
                                         }
                                         else printf("%6d", pvalue);
                                       }
                                       if (BoolOutput) {
                                         if (Result[j]) printf("  TRUE\n"); else printf(" FALSE\n");
                                       }
                                       else printf("%6d\n", Result[j]);
                                     }
                                  .)
      ] .

    Function<int ¶ms>
    =                             (. char fname[16]; .)
      identifier                  (. LexName(fname, sizeof(fname) - 1); .)
      "(" OnePar<params>
          { WEAK "," OnePar<params> } ")"
                                  (. printf("%6s\n", fname); .)
      .

    OnePar<int ¶ms>
    =                             (. TABLE_entries entry; .)
      identifier                  (. LexName(entry.name, TABLE_alfalength);
                                     printf("%6s", entry.name);
                                     params++;
                                     calculate(params, entry.BoolState);
                                     Table->enter(entry);
                                  .) .

    Expression<bool Result[]>
    = AndExp<Result>              (. bool Result2[128]; .)
      { Or AndExp<Result2>        (. for (int i = 0; i < 128; i++)
                                       Result[i] = Result[i] || Result2[i];
                                  .)
      } .

    AndExp<bool Result[]>
    = NotExp<Result>              (. bool Result2[128]; .)
      { [ And ] NotExp<Result2>   (. for (int i = 0; i < 128; i++)
                                       Result[i] = Result[i] && Result2[i];
                                  .)
      } .

    NotExp<bool Result[]>
    =                             (. bool Result2[128]; .)
       PreNot NotExp<Result>      (. for (int i = 0; i < 128; i++)
                                       Result[i] = !Result[i];
                                  .)
      | Factor<Result>
        { "'"                     (. for (int i = 0; i < 128; i++)
                                       Result[i] = !Result[i];
                                  .)
        } .

    Factor<bool Result[]>
    =                             (. char id[16]; int i;
                                     bool found; TABLE_entries entry; .)
        identifier                (. LexName(id, sizeof(id) - 1);
                                     Table->search(id, entry, found);
                                     if (!found) SemError(202);
                                     for (i = 0; i < 128; i++)
                                       Result[i] = entry.BoolState[i];
                                  .)
      | True                      (. for (i = 0; i < 128; i++) Result[i] = true; .)
      | False                     (. for (i = 0; i < 128; i++) Result[i] = false; .)
      | "(" Expression<Result> ")" .

    And      = "AND"   | "&" | "." .
    Or       = "OR"    | "|" | "+" .
    PreNot   = "NOT"   | "!" | "~" .
    True     = "TRUE"  | "1" .
    False    = "FALSE" | "0" .

  END Bool.
</PRE>

With this system the table handler was modified:

<PRE>

  // Handle symbol table for Josh's truth tables

  #ifndef TABLE_H
  #define TABLE_H

  #include "misc.h"
  #include "report.h"

  const int tablemax = 100;        // max number of identifiers

  const int TABLE_alfalength = 15; // maximum length of identifiers
  typedef char TABLE_alfa[TABLE_alfalength + 1];

  struct TABLE_entries {
    TABLE_alfa name;             // identifier
    bool BoolState[128];
  };

  class TABLE {
    public:
      void enter(TABLE_entries &entry);
      // Adds entry to symbol table

      void search(char *name, TABLE_entries &entry, bool &found);
      // Searches table for presence of name.  If found then returns entry

      bool getval(int x, int y);
      // get boolean value of BoolState[x, y]

      TABLE(REPORT *R);
      // Initializes symbol table

      void reset(void);
      // Clear table

    private:
      int top;
      TABLE_entries symtable[tablemax + 1];
      REPORT *Report;
      void find(char *name, int &look);
  };

  #endif /*TABLE_H*/

  // Handle symbol table for Josh's truth tables

  #include "table.h"

  void TABLE::find(char *name, int &look)
  { look = top;
    sprintf(symtable[0].name, "%.*s", TABLE_alfalength, name);
    while (strcmp(symtable[look].name, symtable[0].name)) look--;
  }

  void TABLE::enter(TABLE_entries &entry)
  { int look;
    find(entry.name, look);
    if (look != 0) // check current scope for duplicates
      Report->error(201);
      else
      { if (top == tablemax)  // Symbol Table overflow
          { printf("Symbol table full\n"); exit(1); }
        top++; symtable[top] = entry;
      }
  }

  void TABLE::search(char *name, TABLE_entries &entry, bool &found)
  { int look;
    find(name, look);
    found = (look != 0);
    entry = symtable[look];
  }

  bool TABLE::getval(int x, int y)
  { return symtable[x].BoolState[y]; }

  void TABLE::reset(void)
  { top = 0; symtable[top].name[0] = '\0'; }

  TABLE::TABLE(REPORT *R)
  { Report = R; reset(); }