Multiple Changes to CIVL Code

Model Changes

• introduce LHSExpression, a subtype of Expression: DONE
• rename ArrayIndexExpression to SubscriptExpression: DONE
• modify ModelBuilder to get rid of arrow expressions, replacing them with dot of star: DONE
• modify ModelBuilder to get rid of C's pointer-array pun:
  • in any subscript expression a[i], make sure a has array type. If it doesn't, translate to *(a+i) : DONE
  • in any place where a pointer is called for, but instead an array a is used, replace a with &a[0]. Examples include pointer arithmetic (a+i, a-b), argument to dereference operator *, actual arguments in function calls where the corresponding parameter has pointer type. : DONE
  • make sure the parameter type of a function call is never an array type. ABC should already be doing this.
• use an enumerated type like ExpressionKind for the different kinds of expressions, so switch statements can be used: DONE
• add a method to expressions like SymbolicExpression getConstantValue() and a corresponding setter, to cache the value of any expression that has a constant value, such as a literal expression

Semantics Changes

• use interfaces for !Executor, !Evaluator, etc.
• finish javadocs for all methods
• don't use !Vector. Use LinkedList if you only need to iterate; use ArrayList if you need constant time access
• !processType, etc: for these and other fields, make them canonic using !universe.canonic(…)!. This can improve efficiency. DONE
• never return !null if a case is not handled. Instead throw an appropriate exception: DONE
• use !switch instead of big if...else if… sequence "mostly DONE"
• evaluation of dot expression should be simply return universe.tupleRead(evaluate(expr.struct()…), expr.index()) or something like that: DONE
• evaluation of SubscriptExpression should be simply return universe.arrayRead(evaluate(expr.array()…), evaluate(expr.index()…)) or something like that: DONE
• evaluate of NOT_EQUAL: use universe.neq(): DONE
• implement pointer addition and subtraction. [addition DONE, subtraction coming]
• implement string literals using universe.stringExpression() (it returns an array of char). DONE?
• references: re-do to use new (upcoming) methods in symbolic universe to create a reference to a point within a symbolic expression. this will eliminate the need to deal with navigation sequences. You still need to figure out the variable, scope and model IDs. DONE
• use a tuple with one integer field for scope IDs instead of symbolic constants. DONE
• don't do any string manipulation or parsing dynamically, if possible: DONE
• evaluate(…VariableExpression): the error reporting code for incorporating the state into the log entry seems general enough that you could factor it out into a separate method somewhere to re-use every time there is an error to report (maybe in Log?) : DONE (state exceptions)
• construct and set the heap type in the constructor for !Evaluator, just like the other special types