private IAstNodeValidator FindValidatorForVisitor(IAstNodeVisitor nodeVisitor)
{
foreach (IAstNodeValidator nodeValidator in nodeValidators) {
foreach (Type type in nodeValidator.NodeType) {
if (IsTypeInTypeArray(type, nodeVisitor.NodeType)) {
return nodeValidator;
}
}
}
return null;
}
public void Accept(IAstNodeVisitor visitor)
{
visitor.VisitEnter(this);
Boolean isFirstTime = true;
foreach (AstNode node in Children)
{
if (!isFirstTime)
{
visitor.VisitExecute(this);
}
isFirstTime = false;
node.Accept(visitor);
}
visitor.VisitLeave(this);
}
public void Accept(IAstNodeVisitor visitor)
{
visitor.VisitEnter(this);
Boolean isFirstTime = true;
foreach (AstNode node in Children)
{
if (!isFirstTime)
{
visitor.VisitExecute(this);
}
isFirstTime = false;
node.Accept(visitor);
}
visitor.VisitLeave(this);
}
/// <summary>
/// Performs the specified action on an expression tree.
/// </summary>
/// <returns>The top node of the results.</returns>
/// <exception>ApplicationException</exception>
/// <param name="node">The top node of the tree.</param>
/// <param name="data">Data passed to the visitor (Typically not used).</param>
/// <param name="pv">Visitor object that can be used to descend the tree.</param>
/// <param name="stack">The stack to operate on.</param>
/// <exception cref="ApplicationException">If operator must have 3 arguments.</exception>
public virtual object Evaluate( AstNode node, object data, IAstNodeVisitor pv, Stack< double? > stack )
{
if ( node.NumChildren != 3 )
throw new ApplicationException( "If operator must have 3 arguments." );
AstNode condition = node.GetChild( 0 );
condition.Accept( pv, data );
CheckStack( stack );
double? condVal = stack.Pop();
if ( condVal.HasValue && ( condVal > 0.0 ) )
{
AstNode trueNode = node.GetChild( 1 );
trueNode.Accept( pv, data );
return data;
}
AstNode falseNode = node.GetChild( 2 );
falseNode.Accept( pv, data );
return data;
}
public override T Accept <T>(IAstNodeVisitor <T> visitor)
{
return(visitor.Visit(this));
}
public void Accept(IAstNodeVisitor visitor)
{
visitor.Visit(this);
}
public void Accept(IAstNodeVisitor visitor)
{
visitor.Visit(this);
}
public abstract T Accept <T>(IAstNodeVisitor <T> visitor);
/// <summary>
/// Accept a visitor object. The visitor must be of type IAstNodeVisitor, however
/// if the visitor also implements the most type-specific IAstLiteralNodeVisitor,
/// or the next most type-specific IAstValueNodeVisitor interface, it uses the
/// interface for the visit callback. Note that it uses the most type-specific
/// interface as per its own inheritence tree. ie.
/// <p/>
/// AstLiteralNode -> AstValueNode -> SimpleNode <br/>
/// IAstLiteralNodeVisitor -> IAstValueNodeVisitor -> IAstNodeVisitor
/// <p/>
/// This is an implementation of the AcyclicVisitor pattern by Robert C. Martin.
/// Details of the pattern and its usage can be found at ObjectMentor.com.<br/>
/// URL: http://www.objectmentor.com/resources/articles/acv.pdf
/// </summary>
/// <param name="visitor"> The object visiting this node. </param>
/// <param name="sessionData"> Misc sessionData to use during this visit. </param>
/// <returns> The session data object. </returns>
internal override object Accept( IAstNodeVisitor visitor, object sessionData )
{
if ( visitor is IAstLiteralNodeVisitor )
return ( (IAstLiteralNodeVisitor)visitor ).Visit( this, sessionData );
if ( visitor is IAstValueNodeVisitor )
return ( (IAstValueNodeVisitor)visitor ).Visit( this, sessionData );
return visitor.Visit( this, sessionData );
}
/// <inheritdoc /> public override TOut Accept <TState, TOut>(IAstNodeVisitor <TInstruction, TState, TOut> visitor, TState state) => visitor.Visit(this, state);
public abstract void Accept(IAstNodeVisitor visitor);
/// <summary> /// Implements the visitor pattern /// </summary> public abstract TOut Accept <TState, TOut>(IAstNodeVisitor <TInstruction, TState, TOut> visitor, TState state);
/// <inheritdoc /> public override void Accept <TState>(IAstNodeVisitor <TInstruction, TState> visitor, TState state) => visitor.Visit(this, state);
/// <summary>
/// Accept a visitor object to all the child nodes of this node.
/// </summary>
/// <param name="visitor">Visitor object to call the "visit" upon.</param>
/// <param name="data">Data relevant to the visitor's visit.</param>
/// <returns>The context object.</returns>
internal virtual object ChildrenAccept( IAstNodeVisitor visitor, object data )
{
if ( _children != null )
{
foreach ( AstNode t in _children )
t.Accept( visitor, data );
}
return data;
}
/// <summary>
/// Accept a visitor object. The visitor must be of type IAstNodeVisitor, however
/// if the visitor also implements the more type-specific IAstFunctionNodeVisitor,
/// it uses its interface for the visit callback.
/// <p/>
/// This is an implementation of the AcyclicVisitor pattern by Robert C. Martin.
/// Details of the pattern and its usage can be found at ObjectMentor.com.<br/>
/// URL: http://www.objectmentor.com/resources/articles/acv.pdf
/// </summary>
/// <param name="visitor">
/// The object visiting this node.
/// </param>
/// <param name="sessionData">
/// Misc data to use during this visit.
/// </param>
/// <returns>
/// The session data object.
/// </returns>
internal override object Accept( IAstNodeVisitor visitor, object sessionData )
{
if ( visitor is IAstFunctionNodeVisitor )
return ( (IAstFunctionNodeVisitor)visitor ).Visit( this, sessionData );
return visitor.Visit( this, sessionData );
}
/// <summary> /// Accept a visitor object. /// <p> This is an implementation of the AcyclicVisitor pattern by Robert C. Martin. /// Details of the pattern and its usage can be found at ObjectMentor.com.<br /> URL: /// http://www.objectmentor.com/resources/articles/acv.pdf /// </p> /// </summary> /// <param name="visitor">Visitor object to call the "visit" upon.</param> /// <param name="sessionData">Data relevant to the visitor's visit.</param> /// <returns>The visitor context object.</returns> internal abstract object Accept( IAstNodeVisitor visitor, object sessionData );
public abstract TResult Accept <TResult, T>(IAstNodeVisitor <TResult, T> visitor, T value);
public abstract TResult Accept <TResult>(IAstNodeVisitor <TResult> visitor);
public override TResult Accept <TResult, T>(IAstNodeVisitor <TResult, T> visitor, T value)
{
return(visitor.Visit(this, value));
}
public override TResult Accept <TResult>(IAstNodeVisitor <TResult> visitor)
{
return(visitor.Visit(this));
}
public override void Accept(IAstNodeVisitor visitor)
{
visitor.Visit(this);
}
/// <summary> /// Implements the visitor pattern /// </summary> public abstract void Accept <TState>(IAstNodeVisitor <TInstruction, TState> visitor, TState state);
