/* A truth table builder using modern compiler technology */

public class truthtable
{

/* Abstract Syntax Tree Classes: */
/* Each propositional sentence is represented using the following structures */

public static abstract class proposition   
{
  String syntax;    // original text
  proposition p1, p2;  // sub propositions (descendent nodes in tree)
  abstract boolean eval(assignment a);  // SEMANTIC "evaluation" action
} // end of abstract class proposition

/* You define the rest of the classes here .....*/




/* --------------------------------------------------------------- */
/* semantic structures: */

/* an assignment associates a list of letters with a list of booleans */
public static class assignment
{ private strlst letters;   // propositional letters
  private vallst values;    // corresponding values

/* the constructor takes a string such as "1011", adds leading "0"'s
   so the length of the string is same as number of letters, then
   builds a list of corresponding booleans: */
  assignment(strlst l, String binseq)
   { letters = l;
     int llength = letters.length();
     /* fill string with leading 0's: */
     while (binseq.length() < llength) binseq = "0" + binseq;
     strlst tracker1 = letters;
     vallst tracker2 = new vallst(false,null);  // dummy header
     values = tracker2;   		// rememeber where it starts!
     int len = binseq.length();
     for(int i=0; i<len; i++)
       { 
         if (binseq.charAt(i) == '0')		// assign truth values
              tracker2.tail = new vallst(false,null);
           else tracker2.tail = new vallst(true,null);
         tracker2 = tracker2.tail;
         tracker1 = tracker1.tail;
       }
     values = values.tail;  // discard dummy list header
   }
 
  public boolean lookup(String l)  // return value of a letter
    { strlst tracker1 = letters;
      vallst tracker2 = values;
      while ( (tracker1 != null) && (!(tracker1.head.equals(l))))
        { tracker1 = tracker1.tail;
          tracker2 = tracker2.tail;
        }
      if (tracker1 == null) return false;  // default is false
        else return tracker2.head;
    } // end of lookup

  public void print()     // prints assignment (as 1's and 0's)
    { vallst tracker2 = values;
      while (tracker2 != null)
        { if (tracker2.head) System.out.print("1 "); 
	     else System.out.print("0 ");
          tracker2 = tracker2.tail;
        }
    }  // end of print
} // end of class assignment


public static class strlst  // list of strings with basic ops
{  String head;
   strlst tail;
   strlst(String h, strlst t)  { head = h;  tail = t; }
   int length()
    { int ax = 0;  // accumulator
      strlst current = this;
      while (current != null) 
        { ax++; current = current.tail; }
      return ax;
    }
   void print()   // prints list;
    { strlst current = this;
      while (current != null)
       { System.out.print(current.head + " ");
         current = current.tail;
       }
    }
} // strlst

public static class vallst   // list of boolean values
{  boolean head;
   vallst tail;
   vallst(boolean h, vallst t)  { head = h;  tail = t; }
} // vallst


/* global list manipulation functions:   */

static strlst append(strlst l, strlst m)  // appends two lists
  { if (l == null) return m;
      else return new strlst(l.head, append(l.tail,m));
  }

static strlst delete(String x, strlst l)  // delete x's from l
    { if (l == null) return null;
       else if (l.head.equals(x)) return delete(x,l.tail);
              else return new strlst(l.head, delete(x,l.tail));
    }

static strlst remdups(strlst l)   		// remove duplicates
    { if (l == null) return null;
        else return new strlst(l.head, remdups(delete(l.head,l.tail)));
    }



    
/* findletters finds all letters in a proposition, discarding duplicates */
/* you'll have to define it here */



public static void main(String[] arg)  // the actual program
{ strlst letters; // letters in a sentence
  int len, limit, valnum, temp;
  assignment a;   // holds various assignments
try { 
  /* parser will get input: */
  parser theparser = new parser();	 // create parser object
  proposition theprop;  // the proposition as a tree
  theprop = (proposition) theparser.parse().value;  // parser returns tree!

  /* the rest you define here.... */


 } catch (Exception e) {}

} // end of main


} // end of class truthtable