Uses of Interface
fmrisc.AST.Expression

Packages that use Expression
fmrisc.AST   
fmrisc.ProofNavigator   
fmrisc.Proving   
fmrisc.Proving.CVCL   
fmrisc.Semantics   
 

Uses of Expression in fmrisc.AST
 

Classes in fmrisc.AST that implement Expression
 class AndFormula
          Handling of conjunctions.
 class ApplicationExpression
          Handling of function and predicate applications.
 class ArrayTerm
          Handling of array terms.
 class BinaryExpression
          Abstract base class of binary expressions
 class DividesTerm
          Handling of quotients.
 class EqualsFormula
          Handling of conjunctions
 class ExistsFormula
          Handling of universally quantified formulas.
 class ExpressionBase
          Base class of all expressions (terms and formulas)
 class ForallFormula
          Handling of universally quantified formulas.
 class GreaterEqualFormula
          Handling of greater-than-or-equal formulas.
 class GreaterFormula
          Handling of greater-than formulas.
 class IfThenElseExpression
          Handling of if-then-else expressions.
 class ImpliesFormula
          Handling of implications
 class LambdaTerm
          Handling of lambda terms.
 class LessEqualFormula
          Handling of less-than-or-equal formulas.
 class LessFormula
          Handling of less-than formulas.
 class LetExpression
          Handling of terms with local bindings.
 class Logical
          Logical constants.
 class MinusTerm
          Handling of differences.
 class NegationTerm
          Handling of negated (minus) terms
 class NotEqualsFormula
          Handling of conjunctions
 class NotFormula
          Handling of negations
 class Number
          Handling of numbers.
 class OrFormula
          Handling of disjunctions.
 class PlusTerm
          Handling of binary sums.
 class QuantifiedExpression
          Abstract base class of quantified expressions.
 class RecordTerm
          Handling of record terms.
 class Reference
          Handling of identifiers used in declarations
 class SelectionTerm
          Handling of component access by index selections.
 class TimesTerm
          Handling of conjunctions
 class TupleTerm
          Handling of tuple terms.
 class UnaryExpression
          Abstract base class of unary expressions
 class UpdateTerm
          Handling of component updates by index selection.
 

Methods in fmrisc.AST that return Expression
 Expression Reference.instantiate()
          return copy of AST with value references instantiated by the substitutions set in the corresponding declaration identifiers
 Expression EqualsFormula.instantiate()
          return copy of AST with value references instantiated by the substitutions set in the corresponding declaration identifiers
 Expression FormulaDeclaration.getFormula()
          returns declaration formula
 Expression SubrangeType.getFrom()
          returns lower bound
 Expression SubrangeType.getTo()
          returns to bound
 Expression ArrayTerm.instantiate()
          return copy of AST with value references instantiated by the substitutions set in the corresponding declaration identifiers
 Expression ValuedIdentifier.getValue()
          returns identifier value
 Expression RecordTerm.instantiate()
          return copy of AST with value references instantiated by the substitutions set in the corresponding declaration identifiers
 Expression Expression.instantiate()
          return copy of AST with value references instantiated by the substitutions set in the corresponding declaration identifiers
static Expression[] ASTUtil.toExpressionArray(java.util.Vector v)
          converts vector v of Expression objects to Expression array
 Expression UpdateTerm.getBase()
          get the base expression
 Expression UpdateTerm.getUpdate()
          get the update value
 Expression UpdateTerm.instantiate()
          return copy of AST with value references instantiated by the substitutions set in the corresponding declaration identifiers
 Expression Logical.instantiate()
          return copy of AST with value references instantiated by the substitutions set in the corresponding declaration identifiers
 Expression NotEqualsFormula.instantiate()
          return copy of AST with value references instantiated by the substitutions set in the corresponding declaration identifiers
 Expression SelectionTerm.getBase()
          get base expression
 Expression SelectionTerm.instantiate()
          return copy of AST with value references instantiated by the substitutions set in the corresponding declaration identifiers
 Expression SelectorIndex.getIndex()
          get index expression
 Expression ApplicationExpression.getFunction()
          get function/predicate
 Expression[] ApplicationExpression.getArguments()
          get arguments
 Expression ApplicationExpression.instantiate()
          return copy of AST with value references instantiated by the substitutions set in the corresponding declaration identifiers
 Expression GreaterEqualFormula.instantiate()
          return copy of AST with value references instantiated by the substitutions set in the corresponding declaration identifiers
 Expression GreaterFormula.instantiate()
          return copy of AST with value references instantiated by the substitutions set in the corresponding declaration identifiers
 Expression LessEqualFormula.instantiate()
          return copy of AST with value references instantiated by the substitutions set in the corresponding declaration identifiers
 Expression LessFormula.instantiate()
          return copy of AST with value references instantiated by the substitutions set in the corresponding declaration identifiers
 Expression DividesTerm.instantiate()
          return copy of AST with value references instantiated by the substitutions set in the corresponding declaration identifiers
 Expression TimesTerm.instantiate()
          return copy of AST with value references instantiated by the substitutions set in the corresponding declaration identifiers
 Expression MinusTerm.instantiate()
          return copy of AST with value references instantiated by the substitutions set in the corresponding declaration identifiers
 Expression PlusTerm.instantiate()
          return copy of AST with value references instantiated by the substitutions set in the corresponding declaration identifiers
 Expression ImpliesFormula.instantiate()
          return copy of AST with value references instantiated by the substitutions set in the corresponding declaration identifiers
 Expression OrFormula.instantiate()
          return copy of AST with value references instantiated by the substitutions set in the corresponding declaration identifiers
 Expression AndFormula.instantiate()
          return copy of AST with value references instantiated by the substitutions set in the corresponding declaration identifiers
 Expression BinaryExpression.getFirst()
          Returns first subexpression
 Expression BinaryExpression.getSecond()
          Returns second subexpression
 Expression LetExpression.getBase()
          get base expression
 Expression LetExpression.instantiate()
          return copy of AST with value references instantiated by the substitutions set in the corresponding declaration identifiers
 Expression IfThenElseExpression.getCondition()
          get condition of expression
 Expression IfThenElseExpression.getThenBranch()
          get then branch of expression
 Expression IfThenElseExpression.getElseBranch()
          get else branch of expression
 Expression IfThenElseExpression.instantiate()
          return copy of AST with value references instantiated by the substitutions set in the corresponding declaration identifiers
 Expression[] TupleTerm.getBase()
          get base expressions
 Expression TupleTerm.instantiate()
          return copy of AST with value references instantiated by the substitutions set in the corresponding declaration identifiers
 Expression LambdaTerm.instantiate()
          return copy of AST with value references instantiated by the substitutions set in the corresponding declaration identifiers
 Expression ExistsFormula.instantiate()
          return copy of AST with value references instantiated by the substitutions set in the corresponding declaration identifiers
 Expression ForallFormula.instantiate()
          return copy of AST with value references instantiated by the substitutions set in the corresponding declaration identifiers
 Expression QuantifiedExpression.getBase()
          get base expression
 Expression NegationTerm.instantiate()
          return copy of AST with value references instantiated by the substitutions set in the corresponding declaration identifiers
 Expression NotFormula.instantiate()
          return copy of AST with value references instantiated by the substitutions set in the corresponding declaration identifiers
 Expression UnaryExpression.getBase()
          Returns base expression
 Expression Number.instantiate()
          return copy of AST with value references instantiated by the substitutions set in the corresponding declaration identifiers
 Expression SubType.getPredicate()
          returns predicate
 Expression ValueDeclaration.getValue()
          returns declaration value
 

Methods in fmrisc.AST with parameters of type Expression
static ValuedIdentifier Construct.valuedIdentifier(Reference identifier, Expression value)
          construct identifier with value from identifier and value.
static FormulaDeclaration Construct.formulaDeclaration(FormulaDeclIdentifier name, Expression formula)
          construct formula declaration with denoted name and formula.
static ValueDeclaration Construct.valueDeclaration(ValueDeclIdentifier name, Type type, Expression value)
          construct value declaration with denoted name, type and value.
static SubType Construct.subType(Expression predicate)
          construct subtype with denoted predicate.
static SubrangeType Construct.subrangeType(Expression from, Expression to)
          construct subrangetype with denoted bounds.
static LetExpression Construct.letExpression(ValueDeclaration[] declarations, Expression base)
          construct let expressions of declarations and base expressions
static IfThenElseExpression Construct.ifThenElseExpression(Expression condition, Expression thenbranch, Expression elsebranch)
          construct if-then-else expressions from condition, thenbranch, elsebranch.
static NotFormula Construct.notFormula(Expression base)
          construct negation (not formula) of base formula
static NegationTerm Construct.negationTerm(Expression base)
          construct negation (minus term) of base term
static TupleTerm Construct.tupleTerm(Expression[] base)
          construct tuple term of base terms
static LambdaTerm Construct.lambdaTerm(TypedIdentifier[] variables, Expression base)
          construct lambda term of variables and base term
static ArrayTerm Construct.arrayTerm(TypedIdentifier[] variables, Expression base)
          construct array term of variables and base term
static ForallFormula Construct.forallFormula(TypedIdentifier[] variables, Expression base)
          construct universally quantifed formula of variables and base formula
static ExistsFormula Construct.existsFormula(TypedIdentifier[] variables, Expression base)
          construct existentially quantifed formula of variables and base formula
static AndFormula Construct.andFormula(Expression base1, Expression base2)
          construct conjunction with components base1 and base2
static OrFormula Construct.orFormula(Expression base1, Expression base2)
          construct disjunction with components base1 and base2
static ImpliesFormula Construct.impliesFormula(Expression base1, Expression base2)
          construct implication with components base1 and base2
static EqualsFormula Construct.equalsFormula(Expression base1, Expression base2)
          construct equality/equivalence with components base1 and base2
static NotEqualsFormula Construct.notEqualsFormula(Expression base1, Expression base2)
          construct inequality/exclusive disjunction with components base1 and base2
static PlusTerm Construct.plusTerm(Expression base1, Expression base2)
          construct binary sum with components base1 and base2
static MinusTerm Construct.minusTerm(Expression base1, Expression base2)
          construct difference with components base1 and base2
static TimesTerm Construct.timesTerm(Expression base1, Expression base2)
          construct binary product with components base1 and base2
static DividesTerm Construct.dividesTerm(Expression base1, Expression base2)
          construct quotient with components base1 and base2
static LessFormula Construct.lessFormula(Expression base1, Expression base2)
          construct less-than formula with components base1 and base2
static LessEqualFormula Construct.lessEqualFormula(Expression base1, Expression base2)
          construct less-than-or-equal formula with components base1 and base2
static GreaterFormula Construct.greaterFormula(Expression base1, Expression base2)
          construct greater-than formula with components base1 and base2
static GreaterEqualFormula Construct.greaterEqualFormula(Expression base1, Expression base2)
          construct greater-than-or-equal formula with components base1 and base2
static SelectorIndex Construct.selectorIndex(Expression base)
          make selector from index expression base
static SelectionTerm Construct.selectionTerm(Expression base1, Selector base2)
          construct component selection from base1 and base2
static UpdateTerm Construct.updateTerm(Expression base1, Selector[] base2, Expression value)
          construct component update by index selection from base, base2, and base3
static ApplicationExpression Construct.applicationExpression(Expression base1, Expression[] base2)
          construct application of base1 to base2
 

Constructors in fmrisc.AST with parameters of type Expression
EqualsFormula(Expression base1, Expression base2)
          construct equality with components base1 and base2
FormulaDeclaration(FormulaDeclIdentifier name, Expression formula)
          construct formula declaration with denoted name and formula
SubrangeType(Expression from, Expression to)
          construct subrangetype with denoted bounds
ArrayTerm(TypedIdentifier[] variables, Expression base)
          construct array term of variables and base term
ValuedIdentifier(Reference identifier, Expression value)
          construct identifier with value from identifier and value.
UpdateTerm(Expression base1, Selector[] base2, Expression value)
          construct component update by index selection from base, base2, and base3
NotEqualsFormula(Expression base1, Expression base2)
          construct inequality with components base1 and base2
SelectionTerm(Expression base1, Selector base2)
          construct component selection from base1 and base2
SelectorIndex(Expression base)
          make selector from general index expression
ApplicationExpression(Expression fun, Expression[] args)
          construct application of fun to args
GreaterEqualFormula(Expression base1, Expression base2)
          construct greater-than-or-equal formula with components base1 and base2
GreaterFormula(Expression base1, Expression base2)
          construct greater-than formula with components base1 and base2
LessEqualFormula(Expression base1, Expression base2)
          construct less-than-or-equal formula with components base1 and base2
LessFormula(Expression base1, Expression base2)
          construct less-than formula with components base1 and base2
DividesTerm(Expression base1, Expression base2)
          construct quotient with components base1 and base2
TimesTerm(Expression base1, Expression base2)
          construct binary product with components base1 and base2
MinusTerm(Expression base1, Expression base2)
          construct difference with components base1 and base2
PlusTerm(Expression base1, Expression base2)
          construct binary sum with components base1 and base2
ImpliesFormula(Expression base1, Expression base2)
          construct conjunction with components base1 and base2
OrFormula(Expression base1, Expression base2)
          construct disjunction with components base1 and base2
AndFormula(Expression base1, Expression base2)
          construct conjunction with components base1 and base2
BinaryExpression(java.lang.String op, Expression first, Expression second)
          constructs binary expression from op, first, and second
LetExpression(ValueDeclaration[] declarations, Expression base)
          construct let expressions of declarations and base expressions
IfThenElseExpression(Expression condition, Expression thenbranch, Expression elsebranch)
          construct if-then-else expressions from condition, thenbranch, elsebranch.
TupleTerm(Expression[] base)
          construct tuple term of base terms
LambdaTerm(TypedIdentifier[] variables, Expression base)
          construct lambda term of variables and base term
ExistsFormula(TypedIdentifier[] variables, Expression base)
          construct exists formula of variables and base formula
ForallFormula(TypedIdentifier[] variables, Expression base)
          construct forall formula of variables and base formula
QuantifiedExpression(java.lang.String quantifier, TypedIdentifier[] variables, Expression base)
          constructs quantified expression from quantifier, variables, and base
NegationTerm(Expression base)
          construct negation (minus term) of base term
NotFormula(Expression base)
          construct negation (not formula) of base formula
UnaryExpression(java.lang.String op, Expression base)
          constructs binary expression from op and base
SubType(Expression predicate)
          construct subtype with denoted predicate.
ValueDeclaration(ValueDeclIdentifier name, Type type, Expression value)
          construct value declaration with denoted name, type and value.
 

Uses of Expression in fmrisc.ProofNavigator
 

Methods in fmrisc.ProofNavigator that return Expression
static Expression State.getLastTCC()
          get last type checking condition
 Expression PNParser.valueExp()
           
 Expression PNParser.valueExp90()
           
 Expression PNParser.valueExp70()
           
 Expression PNParser.valueExp60()
           
 Expression PNParser.valueExp50()
           
 Expression PNParser.valueExp45()
           
 Expression PNParser.valueExp43()
           
 Expression PNParser.valueExp40()
           
 Expression PNParser.valueExp30()
           
 Expression PNParser.valueExp20()
           
 Expression PNParser.valueExp10()
           
 Expression PNParser.valueExp5()
           
 Expression PNParser.valueExp3()
           
 Expression PNParser.valueExp0()
           
 

Methods in fmrisc.ProofNavigator with parameters of type Expression
static void State.setLastTCC(Expression tcc)
          set last type checking condition
static void Main.checkTCC(Expression tcc)
          check type checking condition
 

Uses of Expression in fmrisc.Proving
 

Methods in fmrisc.Proving that return Expression
static Expression LogicUtil.negate(Expression formula)
          return negated version of formula where negation is drawn innermost (to atomic formulas)
 Expression Formula.getExpression()
          get formula expression
 Expression Prover.simplifyExpression(Expression exp)
          simplify expression
 

Methods in fmrisc.Proving with parameters of type Expression
static Expression LogicUtil.negate(Expression formula)
          return negated version of formula where negation is drawn innermost (to atomic formulas)
 void Prover.assertFormula(Expression formula)
          assert truth of formula.
 Answer Prover.queryFormula(Expression formula)
          query truth of formula.
 Expression Prover.simplifyExpression(Expression exp)
          simplify expression
 

Constructors in fmrisc.Proving with parameters of type Expression
Formula(ProofState state, Expression formula, boolean isGoal)
          construct a formula from an expression
ProofState(Proof proof, Environment env, Expression goal)
          construct a root state from a single goal and without assumptions
 

Uses of Expression in fmrisc.Proving.CVCL
 

Methods in fmrisc.Proving.CVCL that return Expression
 Expression CVCLParser.valueExp()
           
 Expression CVCLParser.valueExp90()
           
 Expression CVCLParser.valueExp70()
           
 Expression CVCLParser.valueExp60()
           
 Expression CVCLParser.valueExp50()
           
 Expression CVCLParser.valueExp45()
           
 Expression CVCLParser.valueExp43()
           
 Expression CVCLParser.valueExp40()
           
 Expression CVCLParser.valueExp30()
           
 Expression CVCLParser.valueExp20()
           
 Expression CVCLParser.valueExp10()
           
 Expression CVCLParser.valueExp5()
           
 Expression CVCLParser.valueExp3()
           
 Expression CVCLParser.valueExp0()
           
 Expression CVCL.simplifyExpression(Expression exp)
          simplify expression
 

Methods in fmrisc.Proving.CVCL with parameters of type Expression
 void CVCL.assertFormula(Expression formula)
          assert truth of formula.
 Answer CVCL.queryFormula(Expression formula)
          query truth of formula.
 Expression CVCL.simplifyExpression(Expression exp)
          simplify expression
 

Uses of Expression in fmrisc.Semantics
 

Methods in fmrisc.Semantics that return Expression
 Expression FormulaTable.getFormula(Identifier key)
          returns formula associated to key
 Expression FormulaTableEntry.getFormula()
          return formula of entry
 Expression TypeExpression.getExpression()
          get exp
 Expression Context.getFormula()
          return the formula currently on the top of the stack
 Expression ValueTableEntry.getValue()
          return value of entry
 

Methods in fmrisc.Semantics with parameters of type Expression
 boolean FormulaTable.put(FormulaDeclIdentifier key, Expression formula, Environment env)
          put formula in formula table
 void FormulaTableEntry.setFormula(Expression formula)
          set formula of entry
 void TypeExpression.setExpression(Expression exp)
          set exp
 void Context.assume(Expression formula)
          add an assumption to the current (sub)context
 void Context.implies(Expression formula)
          conjoin formula to the current formula on the top of the stack
 boolean Environment.putValue(ValueDeclIdentifier name, Type type, Expression value)
          put named value in value table
 boolean Environment.putFormula(FormulaDeclIdentifier name, Expression formula)
          put formula in environment
static Type TypeChecking.typeCheck(Expression value)
          type check value
static boolean TypeChecking.hasType(Expression exp, Type etype, Type type, boolean tcc)
          returns true iff expr of type etype matches type.
static TypeExpression TypeChecking.clearSubtypes(Type type, Expression exp)
          return version of type where subtypes and subranges are replaced by their base types; the corresponding constraints are returned as a formula which a corresponding expression exp has to fulfill
 void ValueTableEntry.setValue(Expression value)
          set value of entry
 boolean ValueTable.put(ValueDeclIdentifier name, Type type, Expression value, int depth, int varnum)
          put named value in value table
 

Constructors in fmrisc.Semantics with parameters of type Expression
TypeExpression(Type type, Expression exp)
          Construct pair of type and exp