Uses of Interface
edu.toronto.cs.ctl.CTLNode

Packages that use CTLNode
edu.toronto.cs.boolpg   
edu.toronto.cs.boolpg.parser   
edu.toronto.cs.ctl   
edu.toronto.cs.ctl.antlr   
edu.toronto.cs.gclang.parser   
edu.toronto.cs.modelchecker   
edu.toronto.cs.proof2   
edu.toronto.cs.tlq   
edu.toronto.cs.yasm   
edu.toronto.cs.yasm.pgenerator   
edu.toronto.cs.yasm.pprogram   
edu.toronto.cs.yasm.trace   
 

Uses of CTLNode in edu.toronto.cs.boolpg
 

Methods in edu.toronto.cs.boolpg that return CTLNode
 CTLNode BoolProgramCompiler.handleUnknownVariable(java.lang.String name)
           
 

Uses of CTLNode in edu.toronto.cs.boolpg.parser
 

Methods in edu.toronto.cs.boolpg.parser that return CTLNode
abstract  CTLNode VariableTable.Variable.toCTL(AlgebraValue[] state)
           
 CTLNode VariableTable.ProcessCounter.toCTL(AlgebraValue[] state)
           
 CTLNode VariableTable.StateVariable.toCTL(AlgebraValue[] state)
           
 

Uses of CTLNode in edu.toronto.cs.ctl
 

Classes in edu.toronto.cs.ctl that implement CTLNode
 class CTLAbstractNode
          This is an abstract CTL node.
 class CTLAFNode
          This is an AF CTL node.
 class CTLAGNode
          This is an AG CTL node.
 class CTLAndNode
          This is an And CTL node.
 class CTLARNode
          This is a universal strong until CTL node.
 class CTLAtomPropNode
          This is an atomic CTL node.
 class CTLAUiNode
          This is a universal strong until CTL node.
 class CTLAUNode
          This is a universal strong until CTL node.
 class CTLAWNode
          This is a universal strong until CTL node.
 class CTLAXNode
          This is an AX CTL node.
 class CTLBinaryNode
           
 class CTLConstantNode
          This is a CTL node representing a lattice value.
 class CTLEFNode
          This is an EF CTL node.
 class CTLEGNode
          This is an EG CTL node.
 class CTLEqualsNode
          This is an Equals CTL node.
 class CTLERNode
          This is a universal strong until CTL node.
 class CTLEUiNode
          This is an existential strong until CTL node.
 class CTLEUNode
          This is an existential strong until CTL node.
 class CTLEWNode
          This is a universal strong until CTL node.
 class CTLEXNode
          This is an EX CTL node.
 class CTLIffNode
          This is an Equivalence CTL node.
 class CTLImplNode
          This is an Implication CTL node.
 class CTLLeafNode
           
 class CTLMvSetNode
          This is a CTL node representing an MvSet.
 class CTLNegNode
          This is a Neg CTL node.
 class CTLOrNode
          This is an Or CTL node.
 class CTLOverNode
          This is an Over CTL node.
 class CTLPlaceholderNode
           
 class CTLPreEXNode
          This is a pre EX CTL node thing.
 class CTLTransitionNode
           
 class CTLUnaryNode
           
 class CTLUnderNode
          This is an Under CTL node.
 

Fields in edu.toronto.cs.ctl declared as CTLNode
static CTLNode[] CTLAbstractNode.EMPTY_ARRAY
           
 

Methods in edu.toronto.cs.ctl that return CTLNode
static CTLNode CTLFactory.alterChildren(CTLNode psi, CTLNode left, CTLNode right)
          Creates a CTL node that is the same type as the original and has the specified children.
 CTLNode[] CTLAbstractNode.getFairness()
          Retrieves the fairness of the CTLNode.
 CTLNode[] CTLNode.getFairness()
          Retrieves the fairness of the CTLNode.
 CTLNode[] CTLUnaryNode.getFairness()
           
abstract  CTLNode CTLAbstractNode.getLeft()
          Retrieves the left child of the CTLNode.
 CTLNode CTLBinaryNode.getLeft()
           
 CTLNode CTLLeafNode.getLeft()
           
 CTLNode CTLNode.getLeft()
          Retrieves the left child of the CTLNode.
 CTLNode CTLUnaryNode.getLeft()
           
abstract  CTLNode CTLAbstractNode.getRight()
          Retrieves the right child of the CTLNode.
 CTLNode CTLBinaryNode.getRight()
           
 CTLNode CTLLeafNode.getRight()
           
 CTLNode CTLNode.getRight()
          Retrieves the right child of the CTLNode.
 CTLNode CTLUnaryNode.getRight()
           
 

Methods in edu.toronto.cs.ctl with parameters of type CTLNode
 CTLAFNode CTLAbstractNode.af(CTLNode[] fairness)
           
 CTLAFNode CTLNode.af(CTLNode[] fairness)
           
 CTLAGNode CTLAbstractNode.ag(CTLNode[] fairness)
           
 CTLAGNode CTLNode.ag(CTLNode[] fairness)
           
static CTLNode CTLFactory.alterChildren(CTLNode psi, CTLNode left, CTLNode right)
          Creates a CTL node that is the same type as the original and has the specified children.
 CTLAndNode CTLAbstractNode.and(CTLNode psi)
          CTL operation - conjunction.
 CTLAndNode CTLNode.and(CTLNode psi)
          CTL operation - conjunction.
 CTLARNode CTLAbstractNode.ar(CTLNode psi)
           
 CTLARNode CTLNode.ar(CTLNode psi)
          CTL Release node A [this R psi ]
 CTLAUNode CTLAbstractNode.au(CTLNode psi)
          CTL operation - AU ( A[this U psi] ).
 CTLAUNode CTLNode.au(CTLNode psi)
          CTL operation - AU ( A[this U psi] ).
 CTLAUiNode CTLAbstractNode.au(int i, CTLNode psi)
          CTL operation - bounded AU ( A[this Ui psi] ).
 CTLAUiNode CTLNode.au(int i, CTLNode psi)
          CTL operation - bounded AU ( A[this Ui psi] ).
 CTLAWNode CTLAbstractNode.aw(CTLNode psi)
           
 CTLAWNode CTLNode.aw(CTLNode psi)
           
static CTLAFNode CTLFactory.createCTLAFNode(CTLNode right)
           
static CTLAFNode CTLFactory.createCTLAFNode(CTLNode right, CTLNode[] fairness)
           
static CTLAFNode CTLFactory.createCTLAFNode(CTLNode right, CTLNode[] fairness)
           
static CTLAGNode CTLFactory.createCTLAGNode(CTLNode right)
           
static CTLAGNode CTLFactory.createCTLAGNode(CTLNode right, CTLNode[] fairness)
           
static CTLAGNode CTLFactory.createCTLAGNode(CTLNode right, CTLNode[] fairness)
           
static CTLAndNode CTLFactory.createCTLAndNode(CTLNode left, CTLNode right)
           
static CTLARNode CTLFactory.createCTLARNode(CTLNode left, CTLNode right)
           
static CTLAUiNode CTLFactory.createCTLAUiNode(CTLNode left, int i, CTLNode right)
           
static CTLAUiNode CTLFactory.createCTLAUiNode(CTLNode left, int i, CTLNode right, CTLNode[] fairness)
           
static CTLAUiNode CTLFactory.createCTLAUiNode(CTLNode left, int i, CTLNode right, CTLNode[] fairness)
           
static CTLAUNode CTLFactory.createCTLAUNode(CTLNode left, CTLNode right)
           
static CTLAUNode CTLFactory.createCTLAUNode(CTLNode left, CTLNode right, CTLNode[] fairness)
           
static CTLAUNode CTLFactory.createCTLAUNode(CTLNode left, CTLNode right, CTLNode[] fairness)
           
static CTLAWNode CTLFactory.createCTLAWNode(CTLNode left, CTLNode right)
           
static CTLAWNode CTLFactory.createCTLAWNode(CTLNode left, CTLNode right, CTLNode[] fairness)
           
static CTLAWNode CTLFactory.createCTLAWNode(CTLNode left, CTLNode right, CTLNode[] fairness)
           
static CTLAXNode CTLFactory.createCTLAXNode(CTLNode right)
           
static CTLAXNode CTLFactory.createCTLAXNode(CTLNode right, CTLNode[] fairness)
           
static CTLAXNode CTLFactory.createCTLAXNode(CTLNode right, CTLNode[] fairness)
           
static CTLEFNode CTLFactory.createCTLEFNode(CTLNode right)
           
static CTLEFNode CTLFactory.createCTLEFNode(CTLNode right, CTLNode[] fairness)
           
static CTLEFNode CTLFactory.createCTLEFNode(CTLNode right, CTLNode[] fairness)
           
static CTLEGNode CTLFactory.createCTLEGNode(CTLNode right)
           
static CTLEGNode CTLFactory.createCTLEGNode(CTLNode right, CTLNode[] fairness)
           
static CTLEGNode CTLFactory.createCTLEGNode(CTLNode right, CTLNode[] fairness)
           
static CTLEqualsNode CTLFactory.createCTLEqualsNode(CTLNode left, CTLNode right)
           
static CTLERNode CTLFactory.createCTLERNode(CTLNode left, CTLNode right)
           
static CTLEUiNode CTLFactory.createCTLEUiNode(CTLNode left, int i, CTLNode right)
           
static CTLEUiNode CTLFactory.createCTLEUiNode(CTLNode left, int i, CTLNode right, CTLNode[] fairness)
           
static CTLEUiNode CTLFactory.createCTLEUiNode(CTLNode left, int i, CTLNode right, CTLNode[] fairness)
           
static CTLEUNode CTLFactory.createCTLEUNode(CTLNode left, CTLNode right)
           
static CTLEUNode CTLFactory.createCTLEUNode(CTLNode left, CTLNode right, CTLNode[] fairness)
           
static CTLEUNode CTLFactory.createCTLEUNode(CTLNode left, CTLNode right, CTLNode[] fairness)
           
static CTLEWNode CTLFactory.createCTLEWNode(CTLNode left, CTLNode right)
           
static CTLEWNode CTLFactory.createCTLEWNode(CTLNode left, CTLNode right, CTLNode[] fairness)
           
static CTLEWNode CTLFactory.createCTLEWNode(CTLNode left, CTLNode right, CTLNode[] fairness)
           
static CTLEXNode CTLFactory.createCTLEXNode(CTLNode right)
           
static CTLEXNode CTLFactory.createCTLEXNode(CTLNode right, CTLNode[] fairness)
           
static CTLEXNode CTLFactory.createCTLEXNode(CTLNode right, CTLNode[] fairness)
           
static CTLIffNode CTLFactory.createCTLIffNode(CTLNode left, CTLNode right)
           
static CTLImplNode CTLFactory.createCTLImplNode(CTLNode left, CTLNode right)
           
static CTLNegNode CTLFactory.createCTLNegNode(CTLNode right)
           
static CTLOrNode CTLFactory.createCTLOrNode(CTLNode left, CTLNode right)
           
static CTLOverNode CTLFactory.createCTLOverNode(CTLNode left, CTLNode right)
           
static CTLPreEXNode CTLFactory.createCTLPreEXNode(CTLNode right)
           
static CTLUnderNode CTLFactory.createCTLUnderNode(CTLNode left, CTLNode right)
           
 CTLEGNode CTLAbstractNode.eg(CTLNode[] fairness)
           
 CTLEGNode CTLNode.eg(CTLNode[] fairness)
           
 CTLEqualsNode CTLAbstractNode.eq(CTLNode psi)
          CTL operation - equals
 CTLEqualsNode CTLNode.eq(CTLNode psi)
          CTL operation - equals
 CTLERNode CTLAbstractNode.er(CTLNode psi)
           
 CTLERNode CTLNode.er(CTLNode psi)
           
 CTLEUNode CTLAbstractNode.eu(CTLNode psi)
          CTL operation - EU ( E[this U psi] ).
 CTLEUNode CTLNode.eu(CTLNode psi)
          CTL operation - EU ( E[this U psi] ).
 CTLEUiNode CTLAbstractNode.eu(int i, CTLNode psi)
          CTL operation - bounded EU ( E[this Ui psi] ).
 CTLEUiNode CTLNode.eu(int i, CTLNode psi)
          CTL operation - bounded EU ( E[this Ui psi] ).
 CTLEWNode CTLAbstractNode.ew(CTLNode psi)
           
 CTLEWNode CTLNode.ew(CTLNode psi)
           
 CTLIffNode CTLAbstractNode.iff(CTLNode psi)
          CTL operation - equivalence.
 CTLIffNode CTLNode.iff(CTLNode psi)
          CTL operation - equivalence.
 CTLImplNode CTLAbstractNode.impliedBy(CTLNode psi)
          CTL operation - backward implication.
 CTLImplNode CTLNode.impliedBy(CTLNode psi)
          CTL operation - backward implication.
 CTLImplNode CTLAbstractNode.implies(CTLNode psi)
          CTL operation - implication.
 CTLImplNode CTLNode.implies(CTLNode psi)
          CTL operation - implication.
 java.util.Map CTLTemplate.matchCTLNode(CTLNode _node)
           
 boolean CTLTemplate.matchInternal(java.util.Map map, CTLNode _node, CTLNode matchnode)
           
 CTLOrNode CTLAbstractNode.or(CTLNode psi)
          CTL operation - disjunction.
 CTLOrNode CTLNode.or(CTLNode psi)
          CTL operation - disjunction.
 CTLOverNode CTLAbstractNode.over(CTLNode psi)
          CTL operation - over
 CTLOverNode CTLNode.over(CTLNode psi)
          CTL operation - over
static void CTLStyledPrinter.print(CTLNode node, StyledDocumentPrinter styledPrinter)
           
protected  void CTLStyledPrinter.printNode(CTLNode node, java.lang.Object o)
           
 void CTLStyledPrinter.printNode(CTLNode node, StyledDocumentPrinter styledPrinter)
           
static void CTLFactory.removeCTLNode(CTLNode ctl)
           
protected abstract  void CTLAbstractNode.setLeft(CTLNode l)
          Changes the left child of the CTLNode.
protected  void CTLBinaryNode.setLeft(CTLNode v)
           
protected  void CTLLeafNode.setLeft(CTLNode v)
           
protected  void CTLUnaryNode.setLeft(CTLNode v)
           
protected abstract  void CTLAbstractNode.setRight(CTLNode r)
          Changes the right child of the CTLNode.
protected  void CTLBinaryNode.setRight(CTLNode v)
           
protected  void CTLLeafNode.setRight(CTLNode v)
           
protected  void CTLUnaryNode.setRight(CTLNode v)
           
 java.lang.String CTLPrettyPrinter.stringValue(CTLNode node)
           
static java.lang.String CTLPrettyPrinter.toString(CTLNode node)
           
static java.lang.String CTLAbstractNode.toString(CTLNode node, boolean optBrackets)
           
 CTLUnderNode CTLAbstractNode.under(CTLNode psi)
          CTL operation - under
 CTLUnderNode CTLNode.under(CTLNode psi)
          CTL operation - under
 java.lang.Object AbstractCTLVisitor.visit(CTLNode n, java.lang.Object o)
           
 java.lang.Object CTLVisitor.visit(CTLNode n, java.lang.Object stateinfo)
           
 java.lang.Object CTLVisitorDefaulterAncestor.visit(CTLNode n, java.lang.Object stateinfo)
           
 java.lang.Object AbstractCTLVisitor.visitCTLNode(CTLNode n, java.lang.Object o)
           
 java.lang.Object CTLVisitorDefaulterAncestor.visitCTLNode(CTLNode node, java.lang.Object stateinfo)
           
 java.lang.Object AbstractCTLVisitor.visitNode(CTLNode node, java.lang.Object o)
           
 java.lang.Object CTLVisitor.visitNode(CTLNode node, java.lang.Object stateinfo)
           
 java.lang.Object CTLVisitorDefaulterAncestor.visitNode(CTLNode node, java.lang.Object stateinfo)
           
 

Constructors in edu.toronto.cs.ctl with parameters of type CTLNode
CTLAFNode(CTLNode phi)
          Construct an AF CTL node from another node.
CTLAFNode(CTLNode phi, CTLNode[] fairness)
           
CTLAFNode(CTLNode phi, CTLNode[] fairness)
           
CTLAGNode(CTLNode phi)
          Construct an AG CTL node from another node.
CTLAGNode(CTLNode phi, CTLNode[] fairness)
           
CTLAGNode(CTLNode phi, CTLNode[] fairness)
           
CTLAndNode(CTLNode phi, CTLNode psi)
          Construct an And CTL node using two other nodes as its children.
CTLARNode(CTLNode phi, CTLNode psi)
          Construct a universal strong until CTL node using two other nodes as its children.
CTLARNode(CTLNode phi, CTLNode psi, CTLNode[] fairness)
           
CTLARNode(CTLNode phi, CTLNode psi, CTLNode[] fairness)
           
CTLAUiNode(CTLNode phi, int i, CTLNode psi)
          Construct a bounded universal strong until CTL node using two other nodes as its children.
CTLAUiNode(CTLNode phi, int i, CTLNode psi, CTLNode[] fairness)
           
CTLAUiNode(CTLNode phi, int i, CTLNode psi, CTLNode[] fairness)
           
CTLAUNode(CTLNode phi, CTLNode psi)
          Construct a universal strong until CTL node using two other nodes as its children.
CTLAUNode(CTLNode phi, CTLNode psi, CTLNode[] fairness)
           
CTLAUNode(CTLNode phi, CTLNode psi, CTLNode[] fairness)
           
CTLAWNode(CTLNode phi, CTLNode psi)
          Construct a universal strong until CTL node using two other nodes as its children.
CTLAWNode(CTLNode phi, CTLNode psi, CTLNode[] fairness)
           
CTLAWNode(CTLNode phi, CTLNode psi, CTLNode[] fairness)
           
CTLAXNode(CTLNode phi)
          Construct an AX CTL node from another node.
CTLAXNode(CTLNode phi, CTLNode[] fairness)
           
CTLAXNode(CTLNode phi, CTLNode[] fairness)
           
CTLBinaryNode(CTLNode _left, CTLNode _right)
           
CTLBinaryNode(CTLNode _left, CTLNode _right, CTLNode[] fairness)
           
CTLBinaryNode(CTLNode _left, CTLNode _right, CTLNode[] fairness)
           
CTLEFNode(CTLNode phi)
          Construct an EF CTL node from another node.
CTLEFNode(CTLNode phi, CTLNode[] fairness)
           
CTLEFNode(CTLNode phi, CTLNode[] fairness)
           
CTLEGNode(CTLNode phi)
          Construct an EG CTL node from another node.
CTLEGNode(CTLNode phi, CTLNode[] fairness)
           
CTLEGNode(CTLNode phi, CTLNode[] fairness)
           
CTLEqualsNode(CTLNode phi, CTLNode psi)
          Construct an Equals CTL node using two other nodes as its children.
CTLERNode(CTLNode phi, CTLNode psi)
          Construct a universal strong until CTL node using two other nodes as its children.
CTLERNode(CTLNode phi, CTLNode psi, CTLNode[] fairness)
           
CTLERNode(CTLNode phi, CTLNode psi, CTLNode[] fairness)
           
CTLEUiNode(CTLNode phi, int i, CTLNode psi)
          Construct a bounded existential strong until CTL node using two other nodes as its children.
CTLEUiNode(CTLNode phi, int i, CTLNode psi, CTLNode[] fairness)
           
CTLEUiNode(CTLNode phi, int i, CTLNode psi, CTLNode[] fairness)
           
CTLEUNode(CTLNode phi, CTLNode psi)
          Construct an existential strong until CTL node using two other nodes as its children.
CTLEUNode(CTLNode phi, CTLNode psi, CTLNode[] fairness)
           
CTLEUNode(CTLNode phi, CTLNode psi, CTLNode[] fairness)
           
CTLEWNode(CTLNode phi, CTLNode psi)
          Construct a universal strong until CTL node using two other nodes as its children.
CTLEWNode(CTLNode phi, CTLNode psi, CTLNode[] fairness)
           
CTLEWNode(CTLNode phi, CTLNode psi, CTLNode[] fairness)
           
CTLEXNode(CTLNode phi)
          Construct an EX CTL node from another node.
CTLEXNode(CTLNode phi, CTLNode[] fairness)
           
CTLEXNode(CTLNode phi, CTLNode[] fairness)
           
CTLIffNode(CTLNode phi, CTLNode psi)
          Construct an Equivalence CTL node using two other nodes as its children.
CTLImplNode(CTLNode phi, CTLNode psi)
          Construct an Implication CTL node using two other nodes as its children.
CTLNegNode(CTLNode phi)
          Construct a Neg CTL node from another node.
CTLOrNode(CTLNode phi, CTLNode psi)
          Construct an Or CTL node using two other nodes as its children.
CTLOverNode(CTLNode phi, CTLNode psi)
          Construct an Over CTL node using two other nodes as its children.
CTLPreEXNode(CTLNode phi)
          Construct a pre EX CTL node thing from another node.
CTLTemplate(CTLNode _node, java.util.Set _match)
           
CTLUnaryNode(CTLNode _right)
           
CTLUnaryNode(CTLNode _right, CTLNode[] _fairness)
           
CTLUnaryNode(CTLNode _right, CTLNode[] _fairness)
           
CTLUnderNode(CTLNode phi, CTLNode psi)
          Construct an Under CTL node using two other nodes as its children.
 

Uses of CTLNode in edu.toronto.cs.ctl.antlr
 

Methods in edu.toronto.cs.ctl.antlr that return CTLNode
 CTLNode CTLTreeBuilder.afExpression(antlr.collections.AST _t)
           
 CTLNode CTLTreeBuilder.agExpression(antlr.collections.AST _t)
           
 CTLNode CTLTreeBuilder.andExpression(antlr.collections.AST _t)
           
 CTLNode CTLTreeBuilder.axExpression(antlr.collections.AST _t)
           
 CTLNode CTLTreeBuilder.comparissonExpression(antlr.collections.AST _t)
           
 CTLNode CTLTreeBuilder.ctlTree(antlr.collections.AST _t)
           
 CTLNode CTLTreeBuilder.efExpression(antlr.collections.AST _t)
           
 CTLNode CTLTreeBuilder.egExpression(antlr.collections.AST _t)
           
 CTLNode CTLTreeBuilder.eqExpression(antlr.collections.AST _t)
           
 CTLNode CTLTreeBuilder.exExpression(antlr.collections.AST _t)
           
 CTLNode CTLTreeBuilder.forallUntil(antlr.collections.AST _t)
           
 CTLNode CTLTreeBuilder.forsomeUntil(antlr.collections.AST _t)
           
 CTLNode CTLTreeBuilder.geqExpression(antlr.collections.AST _t)
           
 CTLNode CTLTreeBuilder.impliesExpression(antlr.collections.AST _t)
           
 CTLNode CTLTreeBuilder.leqExpression(antlr.collections.AST _t)
           
 CTLNode CTLTreeBuilder.modalExpression(antlr.collections.AST _t)
           
 CTLNode CTLTreeBuilder.neqExpression(antlr.collections.AST _t)
           
 CTLNode CTLTreeBuilder.notExpression(antlr.collections.AST _t)
           
 CTLNode CTLTreeBuilder.orExpression(antlr.collections.AST _t)
           
static CTLNode CTLNodeParser.parse(java.io.Reader in)
           
static CTLNode CTLNodeParser.parse(java.io.Reader in, CTLNode[] fairness)
           
static CTLNode CTLNodeParser.parse(java.lang.String ctlStr)
           
static CTLNode CTLNodeParser.parse(java.lang.String ctlStr, CTLNode[] fairness)
           
 CTLNode CTLTreeBuilder.placeholder(antlr.collections.AST _t)
           
static CTLNode CTLNodeParser.safeParse(java.lang.String ctlStr)
          Parses a String into CTL without exceptions.
static CTLNode CTLNodeParser.safeParse(java.lang.String ctlStr, CTLNode[] fairness)
           
 CTLNode CTLTreeBuilder.untillReleaseExpression(antlr.collections.AST _t)
           
 

Methods in edu.toronto.cs.ctl.antlr with parameters of type CTLNode
static CTLNode CTLNodeParser.parse(java.io.Reader in, CTLNode[] fairness)
           
static CTLNode CTLNodeParser.parse(java.lang.String ctlStr, CTLNode[] fairness)
           
static CTLNode CTLNodeParser.safeParse(java.lang.String ctlStr, CTLNode[] fairness)
           
 

Constructors in edu.toronto.cs.ctl.antlr with parameters of type CTLNode
CTLTreeBuilder(CTLNode[] _fairness)
           
 

Uses of CTLNode in edu.toronto.cs.gclang.parser
 

Methods in edu.toronto.cs.gclang.parser that return CTLNode
 CTLNode VariableTable.handleUnknownVariable(java.lang.String name)
           
abstract  CTLNode VariableTable.Variable.toCTL(AlgebraValue[] state)
           
 CTLNode VariableTable.EnumeratedVariable.toCTL(AlgebraValue[] state)
           
 CTLNode VariableTable.StateVariable.toCTL(AlgebraValue[] state)
           
 

Uses of CTLNode in edu.toronto.cs.modelchecker
 

Methods in edu.toronto.cs.modelchecker that return CTLNode
 CTLNode CTLReWriter.rewrite(CTLNode ctl)
           
 CTLNode CloningRewriter.rewrite(CTLNode ctl)
           
 CTLNode NormalFormRewriter.rewrite(CTLNode node)
           
 CTLNode SyntaxChecker.rewrite(CTLNode node)
           
 CTLNode XKripkeStructure.rewrite(CTLNode ctlNode)
           
 CTLNode[] StatePresenter.toCTL(AlgebraValue[] state)
           
 CTLNode[][] StatePresenter.toCTL(AlgebraValue[][] states)
           
 CTLNode[] StatePresenter.toCTL(MvSet cube)
           
 

Methods in edu.toronto.cs.modelchecker with parameters of type CTLNode
 MvSet MvSetModelChecker.__checkCTL(CTLNode ctl, MvSet init)
           
 MvSet MvSetModelChecker.checkCTL(CTLNode v)
           
 MvSet MvSetModelChecker.checkCTL(CTLNode ctl, MvSet state)
           
 CTLNode CTLReWriter.rewrite(CTLNode ctl)
           
 CTLNode CloningRewriter.rewrite(CTLNode ctl)
           
 CTLNode NormalFormRewriter.rewrite(CTLNode node)
           
 CTLNode SyntaxChecker.rewrite(CTLNode node)
           
 CTLNode XKripkeStructure.rewrite(CTLNode ctlNode)
           
 

Uses of CTLNode in edu.toronto.cs.proof2
 

Methods in edu.toronto.cs.proof2 that return CTLNode
 CTLNode Formula.getConsequent()
           
 

Methods in edu.toronto.cs.proof2 with parameters of type CTLNode
 java.lang.Object DepthVisitor.binaryNontemporalVisit(CTLNode node, java.lang.Object stateinfo)
           
 java.lang.Object DepthVisitor.binaryTemporalVisit(CTLNode node, java.lang.Object stateinfo)
           
 int DepthVisitor.ctlDepth(CTLNode node)
           
static Formula Formula.duplicate(Formula f, CTLNode ctl, AlgebraValue val, MvSet state)
           
 void CTLProver.BaseEXProofRule.getSuccessorMap(MvSet state, java.lang.String name, CTLNode conseq)
           
 java.lang.Object DepthVisitor.unaryNontemporalVisit(CTLNode node, java.lang.Object stateinfo)
           
 java.lang.Object DepthVisitor.unaryTemporalVisit(CTLNode node, java.lang.Object stateinfo)
           
 

Constructors in edu.toronto.cs.proof2 with parameters of type CTLNode
AboveFormula(CTLNode _ctl, AlgebraValue _val, MvSet _state)
           
BelowFormula(CTLNode _ctl, AlgebraValue _val, MvSet _state)
           
ComparisonFormula(CTLNode _ctl, AlgebraValue _val, MvSet _state)
           
EqualFormula(CTLNode _ctl, AlgebraValue _val, MvSet _state)
           
Formula(CTLNode _ctl, AlgebraValue _val, MvSet _state)
           
 

Uses of CTLNode in edu.toronto.cs.tlq
 

Methods in edu.toronto.cs.tlq that return CTLNode
 CTLNode PlaceholderReWriter.getOneSolution(int bits, StatePresenter presenter, boolean negated)
           
 CTLNode MvSetPlaceholderReWriter.getOneSolution(MvSet v, StatePresenter presenter, boolean negated)
           
 CTLNode PlaceholderReWriter.getSolution(int bits, StatePresenter presenter)
           
 CTLNode MvSetPlaceholderReWriter.getSolution(MvSetCrossProductAlgebra.CrossProductValue v, StatePresenter presenter)
           
 CTLNode[] MvSetPlaceholderReWriter.getSolutions(AlgebraValue v, StatePresenter presenter)
           
 CTLNode[] PlaceholderReWriter.getSolutions(AlgebraValue v, StatePresenter presenter)
           
 

Uses of CTLNode in edu.toronto.cs.yasm
 

Methods in edu.toronto.cs.yasm with parameters of type CTLNode
 void YasmApp.setProp(CTLNode v)
           
 

Uses of CTLNode in edu.toronto.cs.yasm.pgenerator
 

Fields in edu.toronto.cs.yasm.pgenerator declared as CTLNode
protected  CTLNode AIntellegence.prop
          This is the property that we are asking about the whole program
 

Constructors in edu.toronto.cs.yasm.pgenerator with parameters of type CTLNode
AIntellegence(PProgram p, PrllAsmtPStmt _stmt, PredicateRefiner _refiner, WPComputer _wp, CVectorExpr _pStatePred, CVectorExpr _cStatePred, CTLNode _prop, java.util.Map _predMap)
           
 

Uses of CTLNode in edu.toronto.cs.yasm.pprogram
 

Methods in edu.toronto.cs.yasm.pprogram that return CTLNode
 CTLNode PredicateTable.AddPredicate.__toCTL(AlgebraValue[] state)
           
 CTLNode PredicateTable.Predicate.toCTL(AlgebraValue[] state)
           
 CTLNode PredicateTable.AddPredicate.toCTL(AlgebraValue[] state)
           
 CTLNode PredicateTable.IntVariable.toCTL(AlgebraValue[] state)
           
 

Uses of CTLNode in edu.toronto.cs.yasm.trace
 

Constructors in edu.toronto.cs.yasm.trace with parameters of type CTLNode
TraceGenerator(PProgram _pProgram, XKripkeStructure _xkripke, MvSetModelChecker _xchek, CTLNode prop, MvSet _result, AlgebraValue _value)
          Creates a new TraceGenerator instance.