public override Node VisitUnknownNodeType(Node node){
if (node == null) return null;
switch (((SpecSharpNodeType)node.NodeType)){
default:
return base.VisitUnknownNodeType(node);
}
}
/// <summary>
/// Within "node", replace occurrences of identifiers matching oldName (by
/// value) with the given newNode. newNode must be an expression.
/// </summary>
/// <param name="node"></param>
/// <param name="oldName"></param>
/// <param name="newNode"></param>
public static void Replace(Node node, Identifier oldName, Node newNode)
{
if (!(newNode is Expression))
throw new ArgumentException("Replace: newNode must be an Expression");
Replacer replacer = new Replacer(oldName, newNode);
replacer.Visit(node);
}
public static int Count(Node node)
{
var counter = new CountPopExpressions();
counter.Visit(node);
return counter.PopOccurrences;
}
public static bool UsesModel(Node node, ContractNodes contractNodes)
{
CodeInspector ifrv = new CodeInspector(ContractNodes.ModelAttributeName, contractNodes, null, false);
ifrv.Visit(node);
return ifrv.foundAttribute;
}
public override void HandleTypeExpected(Node offendingNode)
{
encounteredTypeRefError = true;
if (ignoreTypeRefErrors)
return;
base.HandleTypeExpected(offendingNode);
}
public static bool IsRuntimeIgnored(Node node, ContractNodes contractNodes, TypeNode referencingType, bool skipQuantifiers)
{
CodeInspector ifrv = new CodeInspector(
ContractNodes.RuntimeIgnoredAttributeName, contractNodes, referencingType, skipQuantifiers);
ifrv.Visit(node);
return ifrv.foundAttribute;
}
/// <summary>
/// actualReturn type is null if Task is not generic, otherwise ,the Task result type.
/// </summary>
public static bool Contains(Node node, ContractNodes contractNodes, Method currentMethod,
TypeNode actualReturnType)
{
var v = new AsyncReturnValueQuery(contractNodes, currentMethod, actualReturnType);
v.Visit(node);
return v.foundReturnValueTaskResult;
}
public override Node VisitUnknownNodeType(Node node){
if (node == null) return null;
switch (((SpecSharpNodeType)node.NodeType)){
case SpecSharpNodeType.KeywordList:
this.AddNodePositionAndInfo(node, node, IdentifierContexts.AllContext);
return null;
default:
return base.VisitUnknownNodeType(node);
}
}
public override Node Visit(Node node)
{
if (node == null) return null;
TypeNode tn = node as TypeNode;
if (tn != null)
tn.DeclaringModule = targetModule;
return base.Visit(node);
}
public static void GenerateCodeFileFromIR(Node node, string path,
string indent, bool blankLines, string bracingStyle)
{
CodeGeneratorOptions o = new CodeGeneratorOptions();
o.IndentString = indent;
o.BlankLinesBetweenMembers = blankLines;
o.BracingStyle = bracingStyle;
StreamWriter sw = File.CreateText(path);
GenerateCodeFromIR(node, sw, o);
sw.Close();
}
public override Node VisitUnknownNodeType(Node node){
if (node == null) return null;
switch (((SpecSharpNodeType)node.NodeType)){
#if Xaml
case SpecSharpNodeType.XamlSnippet:
return this.VisitXamlSnippet((XamlSnippet)node);
#endif
default:
return base.VisitUnknownNodeType(node);
}
}
// used to be private
internal Replacer(Identifier oldName, Node newNode)
{
this.oldName = oldName;
this.newNode = newNode;
if (newNode is Expression)
replaceType = ReplaceType.Identifier;
else if (newNode is Block)
replaceType = ReplaceType.LabeledStatement;
else
throw new ArgumentException("Replacer: newNode must be Expression or Block");
}
public override Node VisitUnknownNodeType(Node node)
{
if (node == null) return null;
switch ((ZingNodeType)node.NodeType)
{
case ZingNodeType.Array:
case ZingNodeType.Chan:
case ZingNodeType.Set:
case ZingNodeType.Range:
return base.VisitTypeNode((TypeNode)node);
default:
return base.VisitUnknownNodeType(node);
}
}
public virtual Node VisitUnknownNodeType(Node node)
{
Visitor visitor = this.GetVisitorFor(node);
if (visitor == null) return node;
if (this.callingVisitor != null)
//Allow specialized state (unknown to this visitor) to propagate all the way down to the new visitor
this.callingVisitor.TransferStateTo(visitor);
this.TransferStateTo(visitor);
node = visitor.Visit(node);
visitor.TransferStateTo(this);
if (this.callingVisitor != null)
//Propagate specialized state (unknown to this visitor) all the way up the chain
visitor.TransferStateTo(this.callingVisitor);
return node;
}
public override Node Visit(Node node)
{
if (node == null) return null;
switch (((ZingNodeType)node.NodeType))
{
// None of these nodes may contain variable declarations, so we don't need to
// explore them. If an atomic block (erroneously) contains declarations, we'll
// discover that in the "checker" phase.
case ZingNodeType.Array:
case ZingNodeType.Accept:
case ZingNodeType.Assert:
case ZingNodeType.Assume:
case ZingNodeType.Async:
case ZingNodeType.Atomic:
case ZingNodeType.Chan:
case ZingNodeType.Choose:
case ZingNodeType.Event:
case ZingNodeType.EventPattern:
case ZingNodeType.JoinStatement:
case ZingNodeType.InvokePlugin:
case ZingNodeType.InvokeSched:
case ZingNodeType.Range:
case ZingNodeType.ReceivePattern:
case ZingNodeType.Select:
case ZingNodeType.Self:
case ZingNodeType.Send:
case ZingNodeType.Set:
case ZingNodeType.TimeoutPattern:
case ZingNodeType.Trace:
case ZingNodeType.Try:
case ZingNodeType.WaitPattern:
case ZingNodeType.With:
case ZingNodeType.Yield:
case ZingNodeType.In:
return node;
case ZingNodeType.AttributedStatement:
return this.VisitAttributedStatement((AttributedStatement)node);
default:
return base.Visit(node);
}
}
public override Node Visit(Node node)
{
if (node == null) return null;
switch (((ZingNodeType)node.NodeType))
{
case ZingNodeType.Array:
return this.VisitArray((ZArray)node);
case ZingNodeType.Accept:
return this.VisitAccept((AcceptStatement)node);
case ZingNodeType.Assert:
return this.VisitAssert((AssertStatement)node);
case ZingNodeType.Assume:
return this.VisitAssume((AssumeStatement)node);
case ZingNodeType.Async:
return this.VisitAsync((AsyncMethodCall)node);
case ZingNodeType.Atomic:
return this.VisitAtomic((AtomicBlock)node);
case ZingNodeType.AttributedStatement:
return this.VisitAttributedStatement((AttributedStatement)node);
case ZingNodeType.Chan:
return this.VisitChan((Chan)node);
case ZingNodeType.Choose:
return this.VisitChoose((UnaryExpression)node);
case ZingNodeType.Event:
return this.VisitEventStatement((EventStatement)node);
case ZingNodeType.EventPattern:
return this.VisitEventPattern((EventPattern)node);
case ZingNodeType.In:
return this.VisitIn((BinaryExpression)node);
case ZingNodeType.JoinStatement:
return this.VisitJoinStatement((JoinStatement)node);
case ZingNodeType.InvokePlugin:
return this.VisitInvokePlugin((InvokePluginStatement)node);
case ZingNodeType.InvokeSched:
return this.VisitInvokeShed((InvokeSchedulerStatement)node);
case ZingNodeType.Range:
return this.VisitRange((Range)node);
case ZingNodeType.ReceivePattern:
return this.VisitReceivePattern((ReceivePattern)node);
case ZingNodeType.Select:
return this.VisitSelect((Select)node);
case ZingNodeType.Send:
return this.VisitSend((SendStatement)node);
case ZingNodeType.Set:
return this.VisitSet((Set)node);
case ZingNodeType.Self:
return this.VisitSelf((SelfExpression)node);
case ZingNodeType.TimeoutPattern:
return this.VisitTimeoutPattern((TimeoutPattern)node);
case ZingNodeType.Trace:
return this.VisitTrace((TraceStatement)node);
case ZingNodeType.Try:
return this.VisitZTry((ZTry)node);
case ZingNodeType.WaitPattern:
return this.VisitWaitPattern((WaitPattern)node);
case ZingNodeType.With:
return this.VisitWith((With)node);
case ZingNodeType.Yield:
return this.VisitYield((YieldStatement)node);
default:
return base.Visit(node);
}
}
private void HandleError(Node errorNode, Error error, params string[] messageParameters)
{
ErrorNode enode = new ZingErrorNode(error, messageParameters);
enode.SourceContext = errorNode.SourceContext;
this.ErrorHandler.Errors.Add(enode);
}
public override void ConstructMethodForNestedFunction(Node func, Method method, TypeNode returnType, ParameterList parList, Block body){
base.ConstructMethodForNestedFunction(func, method, returnType, parList, body);
if (method != null && body != null)
method.SourceContext.EndPos = body.SourceContext.EndPos+1;
}
/// <summary>
/// Error handler. Only file an error if it has not been filed yet.
///
/// Requires: the node has proper source context. Otherwise, it does not help.
/// </summary>
/// <param name="stat"></param>
/// <param name="node"></param>
/// <param name="error"></param>
/// <param name="m"></param>
private void HandleError(Statement stat, Node node, Error error, params string[] m){
Node offendingNode = node;
if (offendingNode.SourceContext.Document == null)
{
offendingNode = stat;
}
if(reportedErrors.Contains(offendingNode.SourceContext))
return;
//Analyzer.WriteLine("!!! " + error+ " : "+node);
if(m==null)
ts.HandleError(offendingNode,error);
else
ts.HandleError(offendingNode,error,m);
reportedErrors.Add(offendingNode.SourceContext,null);
}
internal void HandleError(Node offendingNode, Error error, params string[] messageParameters){
if (this.ErrorHandler == null) return;
((ErrorHandler)this.ErrorHandler).HandleError(offendingNode, error, messageParameters);
}
private void HandleError(Statement stat, Node node, Error error, TypeNode t){
Node offendingNode = node;
if (offendingNode.SourceContext.Document == null)
{
offendingNode = stat;
}
Debug.Assert(t!=null);
if(reportedErrors.Contains(offendingNode.SourceContext))
return;
//Analyzer.WriteLine("!!! " + error+ " : "+node);
ts.HandleError(offendingNode,error,ts.GetTypeName(t));
reportedErrors.Add(offendingNode.SourceContext,null);
}
internal void HandleError(Node offendingNode, Error error, params string[] messageParameters) {
hasError = true;
if (st.ReportedError || ReportWFErrorOnly || DontReportError) return;
((ErrorHandler)this.ErrorHandler).HandleError(offendingNode, error, messageParameters);
st.ReportedError = true;
}
public static TypeNode Find(Node expression)
{
var visitor = new FindExceptionThrown();
visitor.Visit(expression);
if (visitor.foundExceptionType == null)
{
return SystemTypes.ArgumentException;
}
return visitor.foundExceptionType;
}
public override Node Visit(Node node)
{
if (node == null) return null;
switch (node.NodeType)
{
case NodeType.Acquire:
return this.VisitAcquire((Acquire)node);
case NodeType.AddressDereference:
return this.VisitAddressDereference((AddressDereference)node);
case NodeType.AliasDefinition:
return this.VisitAliasDefinition((AliasDefinition)node);
case NodeType.AnonymousNestedFunction:
return this.VisitAnonymousNestedFunction((AnonymousNestedFunction)node);
case NodeType.ApplyToAll:
return this.VisitApplyToAll((ApplyToAll)node);
case NodeType.Arglist:
return this.VisitExpression((Expression)node);
case NodeType.ArglistArgumentExpression:
return this.VisitArglistArgumentExpression((ArglistArgumentExpression)node);
case NodeType.ArglistExpression:
return this.VisitArglistExpression((ArglistExpression)node);
case NodeType.ArrayType:
Debug.Assert(false); return null;
case NodeType.Assembly:
return this.VisitAssembly((AssemblyNode)node);
case NodeType.AssemblyReference:
return this.VisitAssemblyReference((AssemblyReference)node);
case NodeType.Assertion:
return this.VisitAssertion((Assertion)node);
case NodeType.Assumption:
return this.VisitAssumption((Assumption)node);
case NodeType.AssignmentExpression:
return this.VisitAssignmentExpression((AssignmentExpression)node);
case NodeType.AssignmentStatement:
return this.VisitAssignmentStatement((AssignmentStatement)node);
case NodeType.Attribute:
return this.VisitAttributeNode((AttributeNode)node);
case NodeType.Base:
return this.VisitBase((Base)node);
case NodeType.Block:
return this.VisitBlock((Block)node);
case NodeType.BlockExpression:
return this.VisitBlockExpression((BlockExpression)node);
case NodeType.Branch:
return this.VisitBranch((Branch)node);
case NodeType.Compilation:
return this.VisitCompilation((Compilation)node);
case NodeType.CompilationUnit:
return this.VisitCompilationUnit((CompilationUnit)node);
case NodeType.CompilationUnitSnippet:
return this.VisitCompilationUnitSnippet((CompilationUnitSnippet)node);
case NodeType.Continue:
return this.VisitContinue((Continue)node);
case NodeType.CurrentClosure:
return this.VisitCurrentClosure((CurrentClosure)node);
case NodeType.DebugBreak:
return node;
case NodeType.Call:
case NodeType.Calli:
case NodeType.Callvirt:
case NodeType.Jmp:
case NodeType.MethodCall:
return this.VisitMethodCall((MethodCall)node);
case NodeType.Catch:
return this.VisitCatch((Catch)node);
case NodeType.Class:
return this.VisitClass((Class)node);
case NodeType.CoerceTuple:
return this.VisitCoerceTuple((CoerceTuple)node);
case NodeType.CollectionEnumerator:
return this.VisitCollectionEnumerator((CollectionEnumerator)node);
case NodeType.Composition:
return this.VisitComposition((Composition)node);
case NodeType.Construct:
return this.VisitConstruct((Construct)node);
case NodeType.ConstructArray:
return this.VisitConstructArray((ConstructArray)node);
case NodeType.ConstructDelegate:
return this.VisitConstructDelegate((ConstructDelegate)node);
case NodeType.ConstructFlexArray:
return this.VisitConstructFlexArray((ConstructFlexArray)node);
case NodeType.ConstructIterator:
return this.VisitConstructIterator((ConstructIterator)node);
case NodeType.ConstructTuple:
return this.VisitConstructTuple((ConstructTuple)node);
case NodeType.DelegateNode:
return this.VisitDelegateNode((DelegateNode)node);
case NodeType.DoWhile:
return this.VisitDoWhile((DoWhile)node);
case NodeType.Dup:
return this.VisitExpression((Expression)node);
case NodeType.EndFilter:
return this.VisitEndFilter((EndFilter)node);
case NodeType.EndFinally:
return this.VisitEndFinally((EndFinally)node);
case NodeType.EnumNode:
return this.VisitEnumNode((EnumNode)node);
case NodeType.Event:
return this.VisitEvent((Event)node);
case NodeType.Exit:
return this.VisitExit((Exit)node);
case NodeType.Read:
case NodeType.Write:
return this.VisitExpose((Expose)node);
case NodeType.ExpressionSnippet:
return this.VisitExpressionSnippet((ExpressionSnippet)node);
case NodeType.ExpressionStatement:
return this.VisitExpressionStatement((ExpressionStatement)node);
case NodeType.FaultHandler:
return this.VisitFaultHandler((FaultHandler)node);
case NodeType.Field:
return this.VisitField((Field)node);
case NodeType.FieldInitializerBlock:
return this.VisitFieldInitializerBlock((FieldInitializerBlock)node);
case NodeType.Finally:
return this.VisitFinally((Finally)node);
case NodeType.Filter:
return this.VisitFilter((Filter)node);
case NodeType.Fixed:
return this.VisitFixed((Fixed)node);
case NodeType.For:
return this.VisitFor((For)node);
case NodeType.ForEach:
return this.VisitForEach((ForEach)node);
case NodeType.FunctionDeclaration:
return this.VisitFunctionDeclaration((FunctionDeclaration)node);
case NodeType.Goto:
return this.VisitGoto((Goto)node);
case NodeType.GotoCase:
return this.VisitGotoCase((GotoCase)node);
case NodeType.Identifier:
return this.VisitIdentifier((Identifier)node);
case NodeType.If:
return this.VisitIf((If)node);
case NodeType.ImplicitThis:
return this.VisitImplicitThis((ImplicitThis)node);
case NodeType.Indexer:
return this.VisitIndexer((Indexer)node);
case NodeType.InstanceInitializer:
return this.VisitInstanceInitializer((InstanceInitializer)node);
case NodeType.StaticInitializer:
return this.VisitStaticInitializer((StaticInitializer)node);
case NodeType.Method:
return this.VisitMethod((Method)node);
case NodeType.TemplateInstance:
return this.VisitTemplateInstance((TemplateInstance)node);
case NodeType.StackAlloc:
return this.VisitStackAlloc((StackAlloc)node);
case NodeType.Interface:
return this.VisitInterface((Interface)node);
case NodeType.LabeledStatement:
return this.VisitLabeledStatement((LabeledStatement)node);
case NodeType.Literal:
return this.VisitLiteral((Literal)node);
case NodeType.Local:
return this.VisitLocal((Local)node);
case NodeType.LocalDeclaration:
return this.VisitLocalDeclaration((LocalDeclaration)node);
case NodeType.LocalDeclarationsStatement:
return this.VisitLocalDeclarationsStatement((LocalDeclarationsStatement)node);
case NodeType.Lock:
return this.VisitLock((Lock)node);
case NodeType.LRExpression:
return this.VisitLRExpression((LRExpression)node);
case NodeType.MemberBinding:
return this.VisitMemberBinding((MemberBinding)node);
case NodeType.Module:
return this.VisitModule((Module)node);
case NodeType.ModuleReference:
return this.VisitModuleReference((ModuleReference)node);
case NodeType.NameBinding:
return this.VisitNameBinding((NameBinding)node);
case NodeType.NamedArgument:
return this.VisitNamedArgument((NamedArgument)node);
case NodeType.Namespace:
return this.VisitNamespace((Namespace)node);
case NodeType.Nop:
case NodeType.SwitchCaseBottom:
return node;
case NodeType.OptionalModifier:
case NodeType.RequiredModifier:
//TODO: type modifiers should only be visited via VisitTypeReference
return this.VisitTypeModifier((TypeModifier)node);
case NodeType.Parameter:
return this.VisitParameter((Parameter)node);
case NodeType.Pop:
return this.VisitExpression((Expression)node);
case NodeType.PrefixExpression:
return this.VisitPrefixExpression((PrefixExpression)node);
case NodeType.PostfixExpression:
return this.VisitPostfixExpression((PostfixExpression)node);
case NodeType.Property:
return this.VisitProperty((Property)node);
case NodeType.Quantifier:
return this.VisitQuantifier((Quantifier)node);
case NodeType.Comprehension:
return this.VisitComprehension((Comprehension)node);
case NodeType.ComprehensionBinding:
return this.VisitComprehensionBinding((ComprehensionBinding)node);
case NodeType.QualifiedIdentifer:
return this.VisitQualifiedIdentifier((QualifiedIdentifier)node);
case NodeType.Rethrow:
case NodeType.Throw:
return this.VisitThrow((Throw)node);
case NodeType.RefValueExpression:
return this.VisitRefValueExpression((RefValueExpression)node);
case NodeType.RefTypeExpression:
return this.VisitRefTypeExpression((RefTypeExpression)node);
case NodeType.Return:
return this.VisitReturn((Return)node);
case NodeType.Repeat:
return this.VisitRepeat((Repeat)node);
case NodeType.ResourceUse:
return this.VisitResourceUse((ResourceUse)node);
case NodeType.SecurityAttribute:
return this.VisitSecurityAttribute((SecurityAttribute)node);
case NodeType.SetterValue:
return this.VisitSetterValue((SetterValue)node);
case NodeType.StatementSnippet:
return this.VisitStatementSnippet((StatementSnippet)node);
case NodeType.Struct:
return this.VisitStruct((Struct)node);
case NodeType.Switch:
return this.VisitSwitch((Switch)node);
case NodeType.SwitchCase:
return this.VisitSwitchCase((SwitchCase)node);
case NodeType.SwitchInstruction:
return this.VisitSwitchInstruction((SwitchInstruction)node);
case NodeType.Typeswitch:
return this.VisitTypeswitch((Typeswitch)node);
case NodeType.TypeswitchCase:
return this.VisitTypeswitchCase((TypeswitchCase)node);
case NodeType.This:
return this.VisitThis((This)node);
case NodeType.Try:
return this.VisitTry((Try)node);
case NodeType.TypeMemberSnippet:
return this.VisitTypeMemberSnippet((TypeMemberSnippet)node);
case NodeType.ClassParameter:
case NodeType.TypeParameter:
return this.VisitTypeParameter((TypeNode)node);
case NodeType.TypeReference:
return this.VisitTypeReference((TypeReference)node);
case NodeType.UsedNamespace:
return this.VisitUsedNamespace((UsedNamespace)node);
case NodeType.VariableDeclaration:
return this.VisitVariableDeclaration((VariableDeclaration)node);
case NodeType.While:
return this.VisitWhile((While)node);
case NodeType.Yield:
return this.VisitYield((Yield)node);
case NodeType.Conditional:
case NodeType.Cpblk:
case NodeType.Initblk:
return this.VisitTernaryExpression((TernaryExpression)node);
case NodeType.Add:
case NodeType.Add_Ovf:
case NodeType.Add_Ovf_Un:
case NodeType.AddEventHandler:
case NodeType.And:
case NodeType.As:
case NodeType.Box:
case NodeType.Castclass:
case NodeType.Ceq:
case NodeType.Cgt:
case NodeType.Cgt_Un:
case NodeType.Clt:
case NodeType.Clt_Un:
case NodeType.Comma:
case NodeType.Div:
case NodeType.Div_Un:
case NodeType.Eq:
case NodeType.ExplicitCoercion:
case NodeType.Ge:
case NodeType.Gt:
case NodeType.Is:
case NodeType.Iff:
case NodeType.Implies:
case NodeType.Isinst:
case NodeType.Ldvirtftn:
case NodeType.Le:
case NodeType.LogicalAnd:
case NodeType.LogicalOr:
case NodeType.Lt:
case NodeType.Mkrefany:
case NodeType.Maplet:
case NodeType.Mul:
case NodeType.Mul_Ovf:
case NodeType.Mul_Ovf_Un:
case NodeType.Ne:
case NodeType.Or:
case NodeType.NullCoalesingExpression:
case NodeType.Range:
case NodeType.Refanyval:
case NodeType.Rem:
case NodeType.Rem_Un:
case NodeType.RemoveEventHandler:
case NodeType.Shl:
case NodeType.Shr:
case NodeType.Shr_Un:
case NodeType.Sub:
case NodeType.Sub_Ovf:
case NodeType.Sub_Ovf_Un:
case NodeType.Unbox:
case NodeType.UnboxAny:
case NodeType.Xor:
return this.VisitBinaryExpression((BinaryExpression)node);
case NodeType.AddressOf:
case NodeType.OutAddress:
case NodeType.RefAddress:
case NodeType.Ckfinite:
case NodeType.Conv_I:
case NodeType.Conv_I1:
case NodeType.Conv_I2:
case NodeType.Conv_I4:
case NodeType.Conv_I8:
case NodeType.Conv_Ovf_I:
case NodeType.Conv_Ovf_I1:
case NodeType.Conv_Ovf_I1_Un:
case NodeType.Conv_Ovf_I2:
case NodeType.Conv_Ovf_I2_Un:
case NodeType.Conv_Ovf_I4:
case NodeType.Conv_Ovf_I4_Un:
case NodeType.Conv_Ovf_I8:
case NodeType.Conv_Ovf_I8_Un:
case NodeType.Conv_Ovf_I_Un:
case NodeType.Conv_Ovf_U:
case NodeType.Conv_Ovf_U1:
case NodeType.Conv_Ovf_U1_Un:
case NodeType.Conv_Ovf_U2:
case NodeType.Conv_Ovf_U2_Un:
case NodeType.Conv_Ovf_U4:
case NodeType.Conv_Ovf_U4_Un:
case NodeType.Conv_Ovf_U8:
case NodeType.Conv_Ovf_U8_Un:
case NodeType.Conv_Ovf_U_Un:
case NodeType.Conv_R4:
case NodeType.Conv_R8:
case NodeType.Conv_R_Un:
case NodeType.Conv_U:
case NodeType.Conv_U1:
case NodeType.Conv_U2:
case NodeType.Conv_U4:
case NodeType.Conv_U8:
case NodeType.Decrement:
case NodeType.DefaultValue:
case NodeType.Increment:
case NodeType.Ldftn:
case NodeType.Ldlen:
case NodeType.Ldtoken:
case NodeType.Localloc:
case NodeType.LogicalNot:
case NodeType.Neg:
case NodeType.Not:
case NodeType.Parentheses:
case NodeType.Refanytype:
case NodeType.ReadOnlyAddressOf:
case NodeType.Sizeof:
case NodeType.SkipCheck:
case NodeType.Typeof:
case NodeType.UnaryPlus:
return this.VisitUnaryExpression((UnaryExpression)node);
default:
return this.VisitUnknownNodeType(node);
}
}
public virtual Visitor GetVisitorFor(Node node)
{
if (node == null) return null;
return (Visitor)node.GetVisitorFor(this, this.GetType().Name);
}
/// <summary> /// Switches on node.NodeType to call a visitor method that has been specialized for node. /// </summary> /// <param name="node">The node to be visited.</param> /// <returns> Returns null if node is null. Otherwise returns an updated node (possibly a different object).</returns> public abstract Node Visit(Node node);
public void Decompile(Node node, TextWriter tw)
{
lines = new List<string>(1000);
indentLevel = 0;
this.Visit(node);
foreach (string s in lines)
tw.WriteLine(s);
}
public override Node Visit(Node node)
{
if (node == null) return null;
switch (((ZingNodeType)node.NodeType))
{
case ZingNodeType.Array:
case ZingNodeType.Atomic:
case ZingNodeType.Chan:
case ZingNodeType.Choose:
case ZingNodeType.Range:
case ZingNodeType.Set:
case ZingNodeType.Try:
case ZingNodeType.With:
case ZingNodeType.Select:
Debug.Assert(false, "Invalid node type in Microsoft.Zing.Normalizer");
return null;
case ZingNodeType.Accept:
return this.VisitAccept((AcceptStatement)node);
case ZingNodeType.Assert:
return this.VisitAssert((AssertStatement)node);
case ZingNodeType.Assume:
return this.VisitAssume((AssumeStatement)node);
case ZingNodeType.Async:
return this.VisitAsync((AsyncMethodCall)node);
case ZingNodeType.EventPattern:
return this.VisitEventPattern((EventPattern)node);
case ZingNodeType.Event:
return this.VisitEventStatement((EventStatement)node);
case ZingNodeType.In:
return this.VisitIn((BinaryExpression)node);
case ZingNodeType.JoinStatement:
return this.VisitJoinStatement((JoinStatement)node);
case ZingNodeType.InvokePlugin:
return this.VisitInvokePlugin((InvokePluginStatement)node);
case ZingNodeType.InvokeSched:
return this.VisitInvokeSched((InvokeSchedulerStatement)node);
case ZingNodeType.ReceivePattern:
return this.VisitReceivePattern((ReceivePattern)node);
case ZingNodeType.Self:
return this.VisitSelf((SelfExpression)node);
case ZingNodeType.Send:
return this.VisitSend((SendStatement)node);
case ZingNodeType.TimeoutPattern:
return this.VisitTimeoutPattern((TimeoutPattern)node);
case ZingNodeType.Trace:
return this.VisitTrace((TraceStatement)node);
case ZingNodeType.WaitPattern:
return this.VisitWaitPattern((WaitPattern)node);
case ZingNodeType.Yield:
return this.VisitYield((YieldStatement)node);
default:
return base.Visit(node);
}
}
public override Node Visit(Node node)
{
if (node == null) return null;
//
// Short-circuit unsupported node types here and throw an exception
//
switch (node.NodeType)
{
case NodeType.Yield:
case NodeType.AddressDereference:
case NodeType.AliasDefinition:
case NodeType.Assembly:
case NodeType.AssemblyReference:
case NodeType.Attribute:
case NodeType.Base:
case NodeType.BlockExpression:
case NodeType.Branch:
case NodeType.Catch:
case NodeType.Composition:
case NodeType.ConstrainedType:
case NodeType.ConstructArray:
case NodeType.ConstructDelegate:
case NodeType.ConstructFlexArray:
case NodeType.ConstructIterator:
case NodeType.ConstructTuple:
case NodeType.Continue:
case NodeType.DelegateNode:
case NodeType.DoWhile:
case NodeType.EndFilter:
case NodeType.EndFinally:
case NodeType.Event:
case NodeType.Exit:
case NodeType.ExpressionSnippet:
case NodeType.FaultHandler:
case NodeType.FieldInitializerBlock:
case NodeType.Filter:
case NodeType.Finally:
case NodeType.For:
case NodeType.Interface:
case NodeType.InterfaceExpression:
case NodeType.InstanceInitializer:
case NodeType.Local:
case NodeType.LRExpression:
case NodeType.Module:
case NodeType.NameBinding:
case NodeType.NamedArgument:
case NodeType.PrefixExpression:
case NodeType.PostfixExpression:
case NodeType.Property:
case NodeType.Repeat:
case NodeType.SetterValue:
case NodeType.StatementSnippet:
case NodeType.StaticInitializer:
case NodeType.Switch:
case NodeType.SwitchCase:
case NodeType.SwitchInstruction:
case NodeType.Typeswitch:
case NodeType.TypeswitchCase:
case NodeType.Try:
case NodeType.TypeAlias:
case NodeType.TypeMemberSnippet:
case NodeType.TypeParameter:
throw new InvalidOperationException(
string.Format(CultureInfo.CurrentUICulture,
"Invalid node type for Zing ({0})", node.NodeType));
default:
break;
}
switch (((ZingNodeType)node.NodeType))
{
case ZingNodeType.Array:
return this.VisitArray((ZArray)node);
case ZingNodeType.Accept:
return this.VisitAccept((AcceptStatement)node);
case ZingNodeType.Assert:
return this.VisitAssert((AssertStatement)node);
case ZingNodeType.Assume:
return this.VisitAssume((AssumeStatement)node);
case ZingNodeType.Async:
return this.VisitAsync((AsyncMethodCall)node);
case ZingNodeType.Atomic:
return this.VisitAtomic((AtomicBlock)node);
case ZingNodeType.AttributedStatement:
return this.VisitAttributedStatement((AttributedStatement)node);
case ZingNodeType.Chan:
return this.VisitChan((Chan)node);
case ZingNodeType.Choose:
return this.VisitChoose((UnaryExpression)node);
case ZingNodeType.EventPattern:
return this.VisitEventPattern((EventPattern)node);
case ZingNodeType.Event:
return this.VisitEventStatement((EventStatement)node);
case ZingNodeType.In:
return this.VisitIn((BinaryExpression)node);
case ZingNodeType.JoinStatement:
return this.VisitJoinStatement((JoinStatement)node);
case ZingNodeType.InvokePlugin:
return this.VisitInvokePlugin((InvokePluginStatement)node);
case ZingNodeType.Range:
return this.VisitRange((Range)node);
case ZingNodeType.ReceivePattern:
return this.VisitReceivePattern((ReceivePattern)node);
case ZingNodeType.Select:
return this.VisitSelect((Select)node);
case ZingNodeType.Send:
return this.VisitSend((SendStatement)node);
case ZingNodeType.Set:
return this.VisitSet((Set)node);
case ZingNodeType.Trace:
return this.VisitTrace((TraceStatement)node);
case ZingNodeType.TimeoutPattern:
return this.VisitTimeoutPattern((TimeoutPattern)node);
case ZingNodeType.Try:
return this.VisitZTry((ZTry)node);
case ZingNodeType.WaitPattern:
return this.VisitWaitPattern((WaitPattern)node);
case ZingNodeType.With:
return this.VisitWith((With)node);
default:
if (node.NodeType == NodeType.TypeExpression)
return this.VisitTypeExpression((TypeExpression)node);
return base.Visit(node);
}
}
internal void HandleWarning(Node offendingNode, string str) {
hasError = true;
if (st.ReportedError || ReportWFErrorOnly || DontReportError) return;
((ErrorHandler)this.ErrorHandler).HandleError(offendingNode, Error.GenericWarning, str);
// st.ReportedError = true;
}
