|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
Packages that use CTLNode | |
---|---|
edu.toronto.cs.ctl | CTL Abstract Syntax Tree |
edu.toronto.cs.ctl.antlr | ANTLR parser for CTL |
edu.toronto.cs.gclang.parser | ANTLR parser for GCLang |
edu.toronto.cs.gui | Graphical Interaface to XChek multi-valued model-checker |
edu.toronto.cs.modelchecker | Basic CTL model-checking engine based on MvSet |
edu.toronto.cs.proof | Provides classes for representing, manipulating, and constructing proofs for CTL formulas (OLD) |
edu.toronto.cs.proof2 | Provides classes for representing, manipulating, and constructing proofs for CTL formulas (NEW) |
edu.toronto.cs.simulator | A model simulator for XChek (Victor). |
edu.toronto.cs.smv | Provides classes to represent SMV models |
edu.toronto.cs.tlq | Classes used by TLQSolver extension of XChek |
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[] |
CTLUnaryNode.getFairness()
|
CTLNode[] |
CTLAbstractNode.getFairness()
Retrieves the fairness of the CTLNode. |
CTLNode[] |
CTLNode.getFairness()
Retrieves the fairness of the CTLNode. |
CTLNode |
CTLBinaryNode.getLeft()
|
CTLNode |
CTLUnaryNode.getLeft()
|
abstract CTLNode |
CTLAbstractNode.getLeft()
Retrieves the left child of the CTLNode. |
CTLNode |
CTLLeafNode.getLeft()
|
CTLNode |
CTLNode.getLeft()
Retrieves the left child of the CTLNode. |
CTLNode |
CTLBinaryNode.getRight()
|
CTLNode |
CTLUnaryNode.getRight()
|
abstract CTLNode |
CTLAbstractNode.getRight()
Retrieves the right child of the CTLNode. |
CTLNode |
CTLLeafNode.getRight()
|
CTLNode |
CTLNode.getRight()
Retrieves the right child of the CTLNode. |
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 void |
CTLBinaryNode.setLeft(CTLNode v)
|
protected void |
CTLUnaryNode.setLeft(CTLNode v)
|
protected abstract void |
CTLAbstractNode.setLeft(CTLNode l)
Changes the left child of the CTLNode. |
protected void |
CTLLeafNode.setLeft(CTLNode v)
|
protected void |
CTLBinaryNode.setRight(CTLNode v)
|
protected void |
CTLUnaryNode.setRight(CTLNode v)
|
protected abstract void |
CTLAbstractNode.setRight(CTLNode r)
Changes the right child of the CTLNode. |
protected void |
CTLLeafNode.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 |
CTLVisitor.visit(CTLNode n,
java.lang.Object stateinfo)
|
java.lang.Object |
AbstractCTLVisitor.visit(CTLNode n,
java.lang.Object o)
|
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 |
CTLVisitor.visitNode(CTLNode node,
java.lang.Object stateinfo)
|
java.lang.Object |
AbstractCTLVisitor.visitNode(CTLNode node,
java.lang.Object o)
|
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.gui |
---|
Methods in edu.toronto.cs.gui that return CTLNode | |
---|---|
CTLNode[] |
OptionsPanel.getAllFairness()
Get all fairness conditions regardless of whether they are turned on or not. |
CTLNode[] |
OptionsPanel.getFairness()
Get fairness. |
CTLNode |
XChekGUI.parseCTL(java.lang.String ctlStr)
|
CTLNode |
XChekGUI.prepareCTL(java.lang.String ctlStr)
|
CTLNode |
XChekGUI.rewriteCTL(CTLNode ctl)
|
Methods in edu.toronto.cs.gui with parameters of type CTLNode | |
---|---|
CTLNode |
XChekGUI.rewriteCTL(CTLNode ctl)
|
Uses of CTLNode in edu.toronto.cs.modelchecker |
---|
Methods in edu.toronto.cs.modelchecker that return CTLNode | |
---|---|
CTLNode |
XKripkeStructure.rewrite(CTLNode ctlNode)
|
CTLNode |
CTLReWriter.rewrite(CTLNode ctl)
|
CTLNode |
NormalFormRewriter.rewrite(CTLNode node)
|
CTLNode |
CloningRewriter.rewrite(CTLNode ctl)
|
CTLNode |
SyntaxChecker.rewrite(CTLNode node)
|
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 |
XKripkeStructure.rewrite(CTLNode ctlNode)
|
CTLNode |
CTLReWriter.rewrite(CTLNode ctl)
|
CTLNode |
NormalFormRewriter.rewrite(CTLNode node)
|
CTLNode |
CloningRewriter.rewrite(CTLNode ctl)
|
CTLNode |
SyntaxChecker.rewrite(CTLNode node)
|
Uses of CTLNode in edu.toronto.cs.proof |
---|
Methods in edu.toronto.cs.proof that return CTLNode | |
---|---|
CTLNode |
ProofStep.getConsequent()
|
Methods in edu.toronto.cs.proof with parameters of type CTLNode | |
---|---|
java.util.BitSet |
GenericDisjStrategy.choosePaths(AlgebraValue[] vals,
CTLNode[] props)
|
java.util.BitSet |
Simple2ValDisjStrategy.choosePaths(AlgebraValue[] vals,
CTLNode[] props)
|
java.util.BitSet |
ProofStrategy.choosePaths(AlgebraValue[] vals,
CTLNode[] props)
|
static java.util.Iterator |
ProofStrategyCatalog.iterator(CTLNode type)
|
static ProofStep |
ProofStepFactory.makeProofStep(AlgebraValue _v,
MvSet _state,
CTLNode _consequent)
|
void |
Proof.searchProof(CTLNode ctl)
|
Constructors in edu.toronto.cs.proof with parameters of type CTLNode | |
---|---|
ConjProofStep(AlgebraValue _v,
MvSet _state,
java.lang.String _stateName,
CTLNode _consequent)
|
|
DisjProofStep(AlgebraValue _v,
MvSet _state,
java.lang.String stateName,
CTLNode _consequent,
DisjProofStrategy _strategy)
|
|
EGProofStep(AlgebraValue _v,
MvSet _state,
java.lang.String _stateName,
CTLNode _consequent)
|
|
EUiProofStep(AlgebraValue _v,
MvSet _state,
java.lang.String _stateName,
CTLNode _consequent,
int _bound)
|
|
EUProofStep(AlgebraValue _v,
MvSet _state,
java.lang.String _stateName,
CTLNode _consequent)
|
|
EXProofStep(AlgebraValue _v,
MvSet _state,
java.lang.String _stateName,
CTLNode _consequent)
|
|
NegProofStep(AlgebraValue _v,
MvSet _state,
java.lang.String _stateName,
CTLNode _consequent)
|
|
ProofStep(AlgebraValue _v,
MvSet _state,
java.lang.String _stateName,
CTLNode _consequent)
|
|
PropProofStep(AlgebraValue _v,
MvSet _state,
java.lang.String _stateName,
CTLNode _consequent)
|
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.simulator |
---|
Methods in edu.toronto.cs.simulator that return CTLNode | |
---|---|
CTLNode[] |
XCSimulator.getBreakCond()
Gets the break condition(s). |
CTLNode |
XCSimulator.getElseCond()
Gets the alternative condition for the current step (in case the first one fails). |
CTLNode |
XCSimulator.getStepCond()
Gets the condition for the current step. |
CTLNode |
TraceTreeBrowser.parseCTL(java.lang.String ctlStr)
Parses a String into CTL without exceptions. |
CTLNode[] |
XCTraceTree.stateToArray(XCStateInfo info)
Eventually this will allow to merge siblings into one multi-state. |
Methods in edu.toronto.cs.simulator with parameters of type CTLNode | |
---|---|
void |
XCTraceTree.expand(XCTraceState state,
CTLNode condition)
Given some initial state will add the successor states (as one multistate) satisfying the condition. |
void |
XCTraceTree.expandOne(XCTraceState state,
CTLNode condition)
Given some initial state will pick one of the successor states satisfying the condition and add it as a child. |
XCTraceState |
XCTraceTree.split(XCTraceState state,
CTLNode condition)
Given a (multi-)state will attempt to split a single state off of it, modifying the tree accordingly (add 2 siblings in place of the old state). |
Uses of CTLNode in edu.toronto.cs.smv |
---|
Methods in edu.toronto.cs.smv 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)
|
CTLNode[] |
SMVModule.SMVStatePresenter.toCTL(AlgebraValue[] state)
|
CTLNode |
SMVModule.Variable.toCTL(AlgebraValue[] state)
|
CTLNode |
SMVModule.AlgebraVariable.toCTL(AlgebraValue[] state)
|
CTLNode |
SMVModule.IntVariable.toCTL(AlgebraValue[] state)
|
CTLNode[][] |
SMVModule.SMVStatePresenter.toCTL(AlgebraValue[][] states)
|
CTLNode[] |
SMVModule.SMVStatePresenter.toCTL(MvSet cube)
|
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[] |
PlaceholderReWriter.getSolutions(AlgebraValue v,
StatePresenter presenter)
|
CTLNode[] |
MvSetPlaceholderReWriter.getSolutions(AlgebraValue v,
StatePresenter presenter)
|
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |