public static void VisitTreeNodes(TreeNodeCollection nodes, NodeVisitor visitNode)
{
foreach (TreeNode n in nodes) {
visitNode(n);
VisitTreeNodes(n.Nodes, visitNode);
}
}
public void accept(NodeVisitor visitor)
{
foreach (Statement child in Children)
{
child.accept(visitor);
}
visitor.visit(this);
}
/// <summary>Visits the iterator expression and the iterated object expression.</summary>
/// <remarks>
/// Visits the iterator expression and the iterated object expression.
/// There is no body-expression for this loop type.
/// </remarks>
public override void Visit(NodeVisitor v)
{
if (v.Visit(this))
{
iterator.Visit(v);
iteratedObject.Visit(v);
}
}
public override void Accept(NodeVisitor visitor)
{
if (call == null) {
visitor.VisitAssign(this);
}
else {
call.Accept(visitor);
}
}
public override void Visit(NodeVisitor v)
{
if (v.Visit(this))
{
foreach (Node kid in this)
{
((AstNode)kid).Visit(v);
}
}
}
public static void ConvertRoslynToCCI(
IMetadataHost host,
Microsoft.CodeAnalysis.CSharp.SyntaxTree tree,
Microsoft.CodeAnalysis.CSharp.Semantics.SemanticModel semanticModel,
out IModule module,
out ISourceLocationProvider sourceLocationProvider) {
sourceLocationProvider = new SourceLocationProvider();
var transformer = new NodeVisitor(host, semanticModel, sourceLocationProvider);
var assembly = (Module)transformer.Visit(tree.GetRoot());
assembly.Location = Path.GetFullPath(tree.FilePath);
module = assembly;
}
public override void Accept(NodeVisitor visitor)
{
visitor.VisitAbstractRoutine(this);
}
public override void Accept(NodeVisitor visitor)
{
visitor.VisitSharedAttr(this);
}
/// <summary>
/// Visits this node, the initializer expression, the loop condition
/// expression, the increment expression, and then the loop body.
/// </summary>
/// <remarks>
/// Visits this node, the initializer expression, the loop condition
/// expression, the increment expression, and then the loop body.
/// </remarks>
public override void Visit(NodeVisitor v)
{
if (v.Visit(this))
{
initializer.Visit(v);
condition.Visit(v);
increment.Visit(v);
body.Visit(v);
}
}
/// <summary>Defines an accept operation</summary>
/// <param name="nodeVisitor">The visitor to invoke</param>
/// <returns>The modified AST node if modified otherwise the original node</returns>
public override AstNode Accept(NodeVisitor nodeVisitor)
{
return(nodeVisitor.VisitAttribNode(this));
}
public abstract void Accept(NodeVisitor visitor);
/// <summary>
/// Visits this node, then the switch-expression, then the cases
/// in lexical order.
/// </summary>
/// <remarks>
/// Visits this node, then the switch-expression, then the cases
/// in lexical order.
/// </remarks>
public override void Visit(NodeVisitor v)
{
if (v.Visit(this))
{
expression.Visit(v);
foreach (SwitchCase sc in GetCases())
{
sc.Visit(v);
}
}
}
/// <summary>
/// Visits this node, then the try-block, then any catch clauses,
/// and then any finally block.
/// </summary>
/// <remarks>
/// Visits this node, then the try-block, then any catch clauses,
/// and then any finally block.
/// </remarks>
public override void Visit(NodeVisitor v)
{
if (v.Visit(this))
{
tryBlock.Visit(v);
foreach (CatchClause cc in GetCatchClauses())
{
cc.Visit(v);
}
if (finallyBlock != null)
{
finallyBlock.Visit(v);
}
}
}
public override void Accept(NodeVisitor nodeVisitor) => nodeVisitor.Visit(this);
/// <summary>Defines an accept operation</summary>
/// <param name="nodeVisitor">The visitor to invoke</param>
/// <returns>The modified AST node if modified otherwise the original node</returns>
public override AstNode Accept(NodeVisitor nodeVisitor)
{
return(nodeVisitor.VisitNamespaceNode(this));
}
/// <summary>Defines an accept operation</summary>
/// <param name="nodeVisitor">The visitor to invoke</param>
/// <returns>The modified AST node if modified otherwise the original node</returns>
public override AstNode Accept(NodeVisitor nodeVisitor)
{
return(nodeVisitor.VisitKeyFramesBlockNode(this));
}
public void Accept(NodeVisitor visitor)
{
}
protected internal override Node VisitChildren(NodeVisitor visitor)
{
return(this);
}
/// <summary>
/// Dispatches the visitor to the correct visit-method.
/// </summary>
/// <param name="visitor">
/// The visitor.
/// </param>
/// <returns>
/// The <see cref="Node"/>.
/// </returns>
protected internal override Node Accept([NotNull] NodeVisitor visitor)
{
return(visitor.VisitTriggerStatement(this));
}
/// <summary> Visit this node.</summary> /// <param name="visitor">The visitor that is visiting this node. /// </param> public abstract void Accept(NodeVisitor visitor);
/// <summary>Visits this node, then the child expression.</summary>
/// <remarks>Visits this node, then the child expression.</remarks>
public override void Visit(NodeVisitor v)
{
if (v.Visit(this))
{
expression.Visit(v);
}
}
public override void accept(NodeVisitor v)
{
((CFGVisitor)v).visitBasicBlock(this);
}
internal override void AcceptVisitor(NodeVisitor visitor)
{
visitor.Visit(this);
}
/// <summary>Visits this node, then visits its element expressions in order.</summary>
/// <remarks>
/// Visits this node, then visits its element expressions in order.
/// Any empty elements are represented by
/// <see cref="EmptyExpression">EmptyExpression</see>
/// objects, so the callback will never be passed
/// <code>null</code>
/// .
/// </remarks>
public override void Visit(NodeVisitor v)
{
if (v.Visit(this))
{
foreach (AstNode e in GetElements())
{
e.Visit(v);
}
}
}
/// <summary>Defines an accept operation</summary>
/// <param name="nodeVisitor">The visitor to invoke</param>
/// <returns>The modified AST node if modified otherwise the original node</returns>
public override AstNode Accept(NodeVisitor nodeVisitor)
{
return(nodeVisitor.VisitNegationNode(this));
}
public virtual R Accept <R>(NodeVisitor <R> vis)
{
return(vis.VisitAttribute(this));
}
protected internal abstract Node Accept(NodeVisitor visitor);
public override void Accept(NodeVisitor visitor)
{
visitor.VisitSourceFile(this);
}
/// <summary> /// Visits the children of this node. /// </summary> /// <param name="visitor"> /// The visitor. /// </param> /// <returns> /// The <see cref="Node"/>. /// </returns> protected internal abstract Node VisitChildren(NodeVisitor visitor);
/// <summary>
/// Jumps are only used directly during code generation, and do
/// not support this interface.
/// </summary>
/// <remarks>
/// Jumps are only used directly during code generation, and do
/// not support this interface.
/// </remarks>
/// <exception cref="System.NotSupportedException">System.NotSupportedException</exception>
public override void Visit(NodeVisitor visitor)
{
throw new NotSupportedException(this.ToString());
}
public override void Accept(NodeVisitor vis)
{
vis.Visit(this);
}
public override void Accept(NodeVisitor visitor)
{
visitor.VisitParameterDeclaration(this);
}
/// <summary>Defines an accept operation</summary>
/// <param name="nodeVisitor">The visitor to invoke</param>
/// <returns>The modified AST node if modified otherwise the original node</returns>
public override AstNode Accept(NodeVisitor nodeVisitor)
{
return(nodeVisitor.VisitSelectorsGroupNode(this));
}
public override void Accept(NodeVisitor visitor)
{
visitor.VisitAbstractIter(this);
}
/// <summary>Perform a depth-first traversal through this node and its descendants.</summary>
/// <param name="nodeVisitor">the visitor callbacks to perform on each node</param>
/// <returns>this node, for chaining</returns>
public virtual iText.StyledXmlParser.Jsoup.Nodes.Node Traverse(NodeVisitor nodeVisitor) {
Validate.NotNull(nodeVisitor);
NodeTraversor traversor = new NodeTraversor(nodeVisitor);
traversor.Traverse(this);
return this;
}
public override void Accept(NodeVisitor visitor)
{
}
internal abstract void AcceptVisitor(NodeVisitor visitor);
public override void Accept(NodeVisitor visitor)
{
visitor.VisitTypeSpecifier(this);
}
/// <summary>Defines an accept operation</summary>
/// <param name="nodeVisitor">The visitor to invoke</param>
/// <returns>The modified AST node if modified otherwise the original node</returns>
public override AstNode Accept(NodeVisitor nodeVisitor)
{
return(nodeVisitor.VisitTermWithOperatorNode(this));
}
public override void accept(NodeVisitor v)
{
((CFGVisitor)v).visitExit(this);
}
/// <summary>
/// Increments the age of each of the nodes in the given list, and all their children. Also sets the rendering
/// style of each node to "full."
///
/// All nodes are aged every time a new ProgressRecord is received.
/// </summary>
private void AgeNodesAndResetStyle()
{
AgeAndResetStyleVisitor arsv = new AgeAndResetStyleVisitor();
NodeVisitor.VisitNodes(_topLevelNodes, arsv);
}
/// <summary>
/// Visits this node, the function name node if supplied,
/// the parameters, and the body.
/// </summary>
/// <remarks>
/// Visits this node, the function name node if supplied,
/// the parameters, and the body. If there is a member-expr node,
/// it is visited last.
/// </remarks>
public override void Visit(NodeVisitor v)
{
if (v.Visit(this))
{
if (functionName != null)
{
functionName.Visit(v);
}
foreach (AstNode param in GetParams())
{
param.Visit(v);
}
GetBody().Visit(v);
if (!isExpressionClosure)
{
if (memberExprNode != null)
{
memberExprNode.Visit(v);
}
}
}
}
public override R Accept <R>(NodeVisitor <R> vis)
{
return(vis.VisitAttribute(this));
}
VisitNodes(ArrayList nodes, NodeVisitor v)
{
if (nodes == null)
{
return;
}
for (int i = 0; i < nodes.Count; ++i)
{
ProgressNode node = (ProgressNode)nodes[i];
Dbg.Assert(node != null, "nodes should not contain null elements");
if (!v.Visit(node, nodes, i))
{
return;
}
if (node.Children != null)
{
VisitNodes(node.Children, v);
}
}
}
public override void Accept(NodeVisitor vis)
{
vis.VisitAttribute(this);
}
/// <summary>
/// Visits this node, then each label in the label-list, and finally the
/// statement.
/// </summary>
/// <remarks>
/// Visits this node, then each label in the label-list, and finally the
/// statement.
/// </remarks>
public override void Visit(NodeVisitor v)
{
if (v.Visit(this))
{
foreach (AstNode label in labels)
{
label.Visit(v);
}
statement.Visit(v);
}
}
public override void Accept(NodeVisitor visitor)
{
visitor.Visit (this);
}
/// <summary>Visits this node.</summary>
/// <remarks>Visits this node. There are no children to visit.</remarks>
public override void Visit(NodeVisitor v)
{
v.Visit(this);
}
public virtual void Accept(NodeVisitor vis)
{
vis.VisitAttribute(this);
}
/// <summary>
/// Visits this node, then the target expression, then the initializer
/// expression if present.
/// </summary>
/// <remarks>
/// Visits this node, then the target expression, then the initializer
/// expression if present.
/// </remarks>
public override void Visit(NodeVisitor v)
{
if (v.Visit(this))
{
target.Visit(v);
if (initializer != null)
{
initializer.Visit(v);
}
}
}
/// <summary>Create a new traversor.</summary>
/// <param name="visitor">
/// a class implementing the
/// <see cref="NodeVisitor"/>
/// interface, to be called when visiting each node.
/// </param>
public NodeTraversor(NodeVisitor visitor)
{
this.visitor = visitor;
}
/// <summary>
/// Visits this node, then each
/// <see cref="VariableInitializer">VariableInitializer</see>
/// child.
/// </summary>
public override void Visit(NodeVisitor v)
{
if (v.Visit(this))
{
foreach (AstNode var in variables)
{
var.Visit(v);
}
}
}
/// <summary>Defines an accept operation</summary>
/// <param name="nodeVisitor">The visitor to invoke</param>
/// <returns>The modified AST node if modified otherwise the original node</returns>
public override AstNode Accept(NodeVisitor nodeVisitor)
{
return(nodeVisitor.VisitUniversalSelectorNode(this));
}
/// <summary>Visits this node, the target expression, and the property name.</summary>
/// <remarks>Visits this node, the target expression, and the property name.</remarks>
public override void Visit(NodeVisitor v)
{
if (v.Visit(this))
{
GetTarget().Visit(v);
GetProperty().Visit(v);
}
}
private int Apply(ref object owner, NodeVisitor visitor)
{
int count = 0;
FARLogger.TraceFormat("Applying visitor to config node {0}[{1}]", Id, Name ?? "{null}");
foreach (ValueReflection value in Values)
{
FARLogger.TraceFormat("Visiting value {0}[{1}].{2}", Id, Name, value.Name);
try
{
visitor.VisitValue(owner, value);
}
catch (Exception e)
{
FARLogger.ExceptionFormat(e, "Exception loading value {0} in {1}", value.Name, value.DeclaringType);
count++;
}
}
foreach (ListValueReflection reflection in ListValues)
{
if (reflection.IsNodeValue)
{
NodeReflection nodeReflection = GetReflection(reflection.ValueType);
FARLogger.TraceFormat("Visiting list nodes {0}[{1}].{2}[{3}]",
Id,
Name ?? "{null}",
reflection.NodeId,
reflection.Name ?? "{null}");
try
{
visitor.VisitNodeList(owner, reflection, nodeReflection);
}
catch (Exception e)
{
FARLogger.ExceptionFormat(e,
"Exception loading node ({2}) list {0} in {1}",
reflection.Name,
reflection.DeclaringType,
reflection.NodeId);
count++;
}
}
else
{
FARLogger.TraceFormat("Visiting list values {0}[{1}].{2}", Id, Name ?? "{null}", reflection.Name);
try
{
visitor.VisitValueList(owner, reflection);
}
catch (Exception e)
{
FARLogger.ExceptionFormat(e,
"Exception loading value list {0} in {1}",
reflection.Name,
reflection.DeclaringType);
count++;
}
}
}
foreach (NodeReflection node in Nodes)
{
FARLogger.TraceFormat("Visiting subnode {0}[{1}].{2}[{3}]",
Id,
Name ?? "{null}",
node.Id,
node.Name ?? "{null}");
try
{
visitor.VisitNode(owner, node);
}
catch (Exception e)
{
FARLogger.ExceptionFormat(e,
"Exception loading node {2}[{0}] in {1}",
node.Name,
node.DeclaringType,
node.Id);
count++;
}
}
return(count);
}
