public Object Execute(ICodeNode node)
{
ICodeNodeTypeImplementation nodeType = (ICodeNodeTypeImplementation)node.GetType();
SendSourceLineMessage(node);
switch (nodeType.ToString())
{
case "COMPOUND":
{
CompoundExecutor compoundExecutor = new CompoundExecutor(this);
return compoundExecutor;
}
case "ASSIGN":
{
AssignmentExecutor assignmentExecutor = new AssignmentExecutor(this);
return assignmentExecutor;
}
case "NO_OP": return null;
default:
{
errorHandler.flag(node, RuntimeErrorCode.UNIMPLEMENTED_FEATURE, this);
return null;
}
}
}
public override void Visit(ICodeNode node)
{
if (this.searchResult == UsageFinderSearchResult.NotFound)
{
base.Visit(node);
}
}
public override void Visit(ICodeNode node)
{
if (!found)
{
base.Visit(node);
}
}
// Parse a statement list.
protected internal void ParseList(Token token, ICodeNode parentNode, PascalTokenType terminator, PascalErrorCode errorCode)
{
// Loop to parse each statement until the END token or the end of the source file.
while (!(token is EofToken) && (token.type != terminator))
{
// Parse a statement. The parent node adopts the statement node.
ICodeNode statementNode = Parse(token);
parentNode.AddChild(statementNode);
token = CurrentToken();
TokenType tokenType = token.type;
// Look for semicolon between statements.
if (tokenType == PascalTokenType.SEMICOLON)
token = NextToken();
// If at the start of the next assignment statement, then missing a semicolon.
else if (tokenType == PascalTokenType.IDENTIFIER)
errorHandler.flag(token, PascalErrorCode.MISSING_SEMICOLON, this);
else if (tokenType != terminator)
{
errorHandler.flag(token, PascalErrorCode.UNEXPECTED_TOKEN, this);
token = NextToken();
}
}
if (token.type == terminator)
token = NextToken();
else
errorHandler.flag(token, errorCode, this);
}
private void SendSourceLineMessage(ICodeNode node)
{
Object lineNumber = node.GetAttribute(ICodeKeyImplementation.LINE);
if (lineNumber != null)
sendMessage(new Message(MessageType.SOURCE_LINE, lineNumber));
}
public override void Visit(ICodeNode node)
{
hasSideEffects = HasSideEffects(node);
if (!hasSideEffects)
{
base.Visit(node);
}
}
public Object Execute(ICodeNode node)
{
StatementExecutor statementExecutor = new StatementExecutor(this);
List<ICodeNode> children = node.GetChildren();
foreach (ICodeNode child in children)
statementExecutor.Execute(child);
return null;
}
public override ICodeNode Visit(ICodeNode node)
{
if (matcherState == MatcherState.Stopped)
{
return node;
}
return base.Visit(node);
}
public virtual void Visit (ICodeNode node)
{
if (null == node)
return;
switch (node.CodeNodeType) {
<%
for node in model.GetVisitableNodes():
%> case CodeNodeType.${node.Name}:
public override ICodeNode Visit(ICodeNode node)
{
if (this.failure)
{
return node;
}
return base.Visit(node);
}
public override void Visit(ICodeNode node)
{
if (this.IsAddressUnaryOperatorFound)
{
return;
}
base.Visit(node);
}
public override void Visit(ICodeNode node)
{
Expression expression = node as Expression;
if (expression != null)
{
MapBranches(expression);
}
else
{
base.Visit(node);
}
}
public void Emit(ICodeNode node, int si)
{
if (node == null)
return;
if(node is Expression)
EmitExpression((Expression)node, si);
else if(node is Statement)
EmitStatement((Statement)node, si);
else
Helper.Break();
}
public override void Visit(ICodeNode node)
{
if (node is Expression)
{
parentExpressions.Push(node as Expression);
}
base.Visit(node);
if (node is Expression)
{
parentExpressions.Pop();
}
}
public override ICodeNode Visit(ICodeNode node)
{
if (status == InliningResult.NotFound)
{
node = base.Visit(node);
if (valueHasSideEffects && status == InliningResult.NotFound && SideEffectsFinder.HasSideEffects(node))
{
Abort();
}
}
return node;
}
public void flag(ICodeNode node, RuntimeErrorCode errorCode, Backend backend)
{
string lineNumber = null;
while ((node != null) && (node.GetAttribute(ICodeKeyImplementation.LINE) == null))
node = node.GetParent();
backend.sendMessage(new Message(MessageType.RUNTIME_ERROR, new Object[] { errorCode.ToString(), (int)node.GetAttribute(ICodeKeyImplementation.LINE) }));
if (++errorCount > MAX_ERRORS)
{
Console.WriteLine("*** ABORTED AFTER TOO MANY RUNTIME ERRORS.");
Environment.Exit(-1);
}
}
public override void Visit (ICodeNode node)
{
var foo_node = node as IFooExpression;
if (foo_node == null) {
base.Visit (node);
return;
}
switch (foo_node.FooExpressionType) {
case FooExpressionType.Foo:
VisitFoo ((FooExpression) node);
break;
case FooExpressionType.Bar:
VisitBar ((BarExpression) node);
break;
}
}
public static bool HasSideEffects(ICodeNode node)
{
if (node == null)
{
return false;
}
switch (node.CodeNodeType)
{
case CodeNodeType.MethodInvocationExpression:
case CodeNodeType.TypeOfExpression:
case CodeNodeType.ArrayCreationExpression:
case CodeNodeType.ObjectCreationExpression:
case CodeNodeType.StackAllocExpression:
case CodeNodeType.EventReferenceExpression:
case CodeNodeType.DelegateInvokeExpression:
case CodeNodeType.BaseCtorExpression:
case CodeNodeType.ThisCtorExpression:
case CodeNodeType.BoxExpression:
case CodeNodeType.ArrayLengthExpression:
case CodeNodeType.DynamicConstructorInvocationExpression:
case CodeNodeType.DynamicIndexerExpression:
case CodeNodeType.DynamicMemberReferenceExpression:
case CodeNodeType.AnonymousObjectCreationExpression:
case CodeNodeType.AwaitExpression:
case CodeNodeType.LambdaExpression:
case CodeNodeType.DelegateCreationExpression:
return true;
case CodeNodeType.PropertyReferenceExpression:
return !(node as PropertyReferenceExpression).IsSetter;
case CodeNodeType.CastExpression:
return !(node as CastExpression).IsExplicitInterfaceCast;
case CodeNodeType.FieldReferenceExpression:
return !(node as FieldReferenceExpression).IsSimpleStore;
case CodeNodeType.ArrayIndexerExpression:
return !(node as ArrayIndexerExpression).IsSimpleStore;
case CodeNodeType.BinaryExpression:
BinaryExpression binaryExpression = node as BinaryExpression;
return binaryExpression.IsChecked || binaryExpression.Operator == BinaryOperator.Divide || binaryExpression.Operator == BinaryOperator.Modulo;
}
return false;
}
public override void Visit(ICodeNode node)
{
IPdbCodeNode pdbNode = node as IPdbCodeNode;
if(pdbNode != null)
{
foreach (Instruction instruction in pdbNode.UnderlyingSameMethodInstructions)
{
if (instruction.ContainingMethod != pdbNode.UnderlyingInstructionsMember)
{
throw new Exception("IPdbCodeNode contains instructions from different methods. After: " + previousStep);
}
}
}
if (node != null && !visitedNodes.Add(node))
{
throw new Exception("Node duplication detected after: " + previousStep);
}
base.Visit(node);
}
public bool TryInlineVariable(VariableDefinition variableDef, Expression value, ICodeNode target, bool aggressive, out ICodeNode result)
{
this.variableDef = variableDef;
this.value = value;
if (!aggressive)
{
ASTNodeCounter counter = new ASTNodeCounter();
if (counter.CountNodes(value) + counter.CountNodes(target) - 1 > MaxCount)
{
result = target;
return false;
}
}
SideEffectsFinder sideEffectsFinder = new SideEffectsFinder();
valueHasSideEffects = sideEffectsFinder.HasSideEffectsRecursive(value);
status = InliningResult.NotFound;
result = Visit(target);
return status == InliningResult.Success;
}
public void ParseList(Token token, ref ICodeNode parent, ILangTokenType terminator, ILangErrorCode error)
{
// As long as we are parseing neither endToken or terminating token
// do this
while (!(token is EndOfFileToken) && (token.TokenType.ToString() != terminator.ToString()))
{
ICodeNode statementNode = Parse(token);
parent.AddChild(statementNode);
// token have been moved; get the latest
token = CurrentToken();
if (token.TokenType == "semicolon")
{
token = NextToken(); // move beyond the statement separator.
}
else if (token.TokenType == "identifier")
{
ErrorHandler.Singleton.Flag(token, "missing_semicolon", this);
}
else if (token.TokenType != terminator)
{
ErrorHandler.Singleton.Flag(token, "unexpected_token", this);
token = NextToken();
}
}
if (token.TokenType == terminator)
{
token = NextToken();
}
else
{
ErrorHandler.Singleton.Flag(token, error, this);
}
}
public ICodeNode SetRoot(ICodeNode node)
{
root = node;
return root;
}
public override ICodeNode VisitBinaryExpression(BinaryExpression node)
{
ICodeNode result = base.VisitBinaryExpression(node);
// a -> 1
// b -> 2
// a+b -> 3
// b+a -> 3
// a-b -> 4
// b-a -> 5
if (!expressionNumbers.ContainsKey(node))
{
int value = -1;
int valueLeft = expressionNumbers[node.Left];
int valueRight = expressionNumbers[node.Right];
switch (node.Operator)
{
case BinaryOperator.Add:
foreach (var keypair in expressionNumbers)
{
if (keypair.Key.CodeNodeType == CodeNodeType.BinaryExpression)
{
BinaryExpression expr = (BinaryExpression)keypair.Key;
if (expr.Operator == BinaryOperator.Add)
{
int valueLeft1 = expressionNumbers[expr.Left];
int valueRight1 = expressionNumbers[expr.Right];
if (valueLeft == valueLeft1 && valueRight == valueRight1 ||
valueLeft == valueRight1 && valueRight == valueLeft1)
{
value = keypair.Value;
break;
}
}
}
}
break;
case BinaryOperator.Multiply:
foreach (var node1 in expressionNumbers)
{
if (node1.Key.CodeNodeType == CodeNodeType.BinaryExpression)
{
BinaryExpression expr = (BinaryExpression)node1.Key;
if (expr.Operator == BinaryOperator.Multiply)
{
int valueLeft1 = expressionNumbers[expr.Left];
int valueRight1 = expressionNumbers[expr.Right];
if (valueLeft == valueLeft1 && valueRight == valueRight1 ||
valueLeft == valueRight1 && valueRight == valueLeft1)
{
value = node1.Value;
break;
}
}
}
}
break;
}
if (value == -1)
{
value = expressionCnt++;
}
expressionNumbers.Add(node, value);
}
return(result);
}
internal ReferencedGenericParameter(IGenericParameter declaringGenericParameter, ICodeNode owner)
{
_declaringGenericParameter = declaringGenericParameter;
_owner = owner;
}
public bool FindVariable(ICodeNode node)
{
found = false;
Visit(node);
return found;
}
private List <ICodeNode> children; // Children list
public ICodeNodeImplementation(ICodeNodeType type)
{
this.type = type;
this.parent = null;
this.children = new List <ICodeNode>();
}
public bool FindContinue(ICodeNode node)
{
found = false;
Visit(node);
return(found);
}
public void ToNodes(ICodeNode parentNode)
{
// This blox won't compile to a node.
// Instead use ToObjectNode for it to be used inside other node context
// throw new System.NotImplementedException();
}
public bool ContainsTransparentIdentifiers(ICodeNode node)
{
this.contains = false;
this.Visit(node);
return(this.contains);
}
public ObjectNode(ICodeNode node, HighlightableButton highlightableBlox) : base(highlightableBlox)
{
Value = node;
}
public override void Visit(ICodeNode node)
{
count++;
base.Visit(node);
}
public NotConstantException(string message, ICodeNode node) : base(message)
{
this.Node = node;
}
public bool FindContinue(ICodeNode node)
{
this.found = false;
this.Visit(node);
return(this.found);
}
public bool HasSideEffectsRecursive(ICodeNode node)
{
hasSideEffects = false;
Visit(node);
return(hasSideEffects);
}
public bool FindContinue(ICodeNode node)
{
found = false;
Visit(node);
return found;
}
public override void Visit(ICodeNode node)
{
if (!this.containsExpressionTree)
{
base.Visit(node);
}
}
public int CountNodes(ICodeNode node)
{
count = 0;
Visit(node);
return(count);
}
public virtual void Visit(ICodeNode node)
{
visitsOnStack++;
//A good place to watch for StackOverFlowException. That one cannot be effectively caught and results in app crash.
//We replace it with our own custom exception here before it occurs. The number of allowed stack frames
//i chosen empirically
if (visitsOnStack == 600)
{
visitsOnStack = 0;
throw new Exception("Stack overflow while traversing code tree in visit.");
}
if (null == node)
{
visitsOnStack--;
return;
}
switch (node.CodeNodeType)
{
case CodeNodeType.UnsafeBlock:
VisitUnsafeBlockStatement((UnsafeBlockStatement)node);
break;
case CodeNodeType.BlockStatement:
VisitBlockStatement((BlockStatement)node);
break;
case CodeNodeType.ReturnExpression:
VisitReturnExpression((ReturnExpression)node);
break;
case CodeNodeType.GotoStatement:
VisitGotoStatement((GotoStatement)node);
break;
case CodeNodeType.IfStatement:
VisitIfStatement((IfStatement)node);
break;
case CodeNodeType.IfElseIfStatement:
VisitIfElseIfStatement((IfElseIfStatement)node);
break;
case CodeNodeType.ExpressionStatement:
VisitExpressionStatement((ExpressionStatement)node);
break;
case CodeNodeType.ThrowExpression:
VisitThrowExpression((ThrowExpression)node);
break;
case CodeNodeType.WhileStatement:
VisitWhileStatement((WhileStatement)node);
break;
case CodeNodeType.DoWhileStatement:
VisitDoWhileStatement((DoWhileStatement)node);
break;
case CodeNodeType.BreakStatement:
VisitBreakStatement((BreakStatement)node);
break;
case CodeNodeType.ContinueStatement:
VisitContinueStatement((ContinueStatement)node);
break;
case CodeNodeType.ForStatement:
VisitForStatement((ForStatement)node);
break;
case CodeNodeType.ForEachStatement:
VisitForEachStatement((ForEachStatement)node);
break;
case CodeNodeType.ConditionCase:
VisitConditionCase((ConditionCase)node);
break;
case CodeNodeType.DefaultCase:
VisitDefaultCase((DefaultCase)node);
break;
case CodeNodeType.SwitchStatement:
VisitSwitchStatement((SwitchStatement)node);
break;
case CodeNodeType.CatchClause:
VisitCatchClause((CatchClause)node);
break;
case CodeNodeType.TryStatement:
VisitTryStatement((TryStatement)node);
break;
case CodeNodeType.BlockExpression:
VisitBlockExpression((BlockExpression)node);
break;
case CodeNodeType.MethodInvocationExpression:
VisitMethodInvocationExpression((MethodInvocationExpression)node);
break;
case CodeNodeType.MethodReferenceExpression:
VisitMethodReferenceExpression((MethodReferenceExpression)node);
break;
case CodeNodeType.DelegateCreationExpression:
VisitDelegateCreationExpression((DelegateCreationExpression)node);
break;
case CodeNodeType.LiteralExpression:
VisitLiteralExpression((LiteralExpression)node);
break;
case CodeNodeType.UnaryExpression:
VisitUnaryExpression((UnaryExpression)node);
break;
case CodeNodeType.BinaryExpression:
VisitBinaryExpression((BinaryExpression)node);
break;
case CodeNodeType.ArgumentReferenceExpression:
VisitArgumentReferenceExpression((ArgumentReferenceExpression)node);
break;
case CodeNodeType.VariableReferenceExpression:
VisitVariableReferenceExpression((VariableReferenceExpression)node);
break;
case CodeNodeType.VariableDeclarationExpression:
VisitVariableDeclarationExpression((VariableDeclarationExpression)node);
break;
case CodeNodeType.ThisReferenceExpression:
VisitThisReferenceExpression((ThisReferenceExpression)node);
break;
case CodeNodeType.BaseReferenceExpression:
VisitBaseReferenceExpression((BaseReferenceExpression)node);
break;
case CodeNodeType.FieldReferenceExpression:
VisitFieldReferenceExpression((FieldReferenceExpression)node);
break;
case CodeNodeType.CastExpression:
VisitCastExpression((CastExpression)node);
break;
case CodeNodeType.SafeCastExpression:
VisitSafeCastExpression((SafeCastExpression)node);
break;
case CodeNodeType.CanCastExpression:
VisitCanCastExpression((CanCastExpression)node);
break;
case CodeNodeType.TypeOfExpression:
VisitTypeOfExpression((TypeOfExpression)node);
break;
case CodeNodeType.ConditionExpression:
VisitConditionExpression((ConditionExpression)node);
break;
case CodeNodeType.ArrayCreationExpression:
VisitArrayCreationExpression((ArrayCreationExpression)node);
break;
case CodeNodeType.ArrayIndexerExpression:
VisitArrayIndexerExpression((ArrayIndexerExpression)node);
break;
case CodeNodeType.ObjectCreationExpression:
VisitObjectCreationExpression((ObjectCreationExpression)node);
break;
case CodeNodeType.DefaultObjectExpression:
VisitDefaultObjectExpression((DefaultObjectExpression)node);
break;
case CodeNodeType.PropertyReferenceExpression:
VisitPropertyReferenceExpression((PropertyReferenceExpression)node);
break;
case CodeNodeType.TypeReferenceExpression:
VisitTypeReferenceExpression((TypeReferenceExpression)node);
break;
case CodeNodeType.UsingStatement:
VisitUsingStatement((UsingStatement)node);
break;
case CodeNodeType.FixedStatement:
VisitFixedStatement((FixedStatement)node);
break;
case CodeNodeType.StackAllocExpression:
VisitStackAllocExpression((StackAllocExpression)node);
break;
case CodeNodeType.SizeOfExpression:
VisitSizeOfExpression((SizeOfExpression)node);
break;
case CodeNodeType.MakeRefExpression:
VisitMakeRefExpression((MakeRefExpression)node);
break;
case CodeNodeType.EventReferenceExpression:
VisitEventReferenceExpression((EventReferenceExpression)node);
break;
case CodeNodeType.EnumExpression:
VisitEnumExpression((EnumExpression)node);
break;
case CodeNodeType.LambdaExpression:
VisitLambdaExpression((LambdaExpression)node);
break;
case CodeNodeType.DelegateInvokeExpression:
VisitDelegateInvokeExpression((DelegateInvokeExpression)node);
break;
case CodeNodeType.BaseCtorExpression:
VisitBaseCtorExpression((BaseCtorExpression)node);
break;
case CodeNodeType.ThisCtorExpression:
VisitThisCtorExpression((ThisCtorExpression)node);
break;
case CodeNodeType.YieldReturnExpression:
VisitYieldReturnExpression((YieldReturnExpression)node);
break;
case CodeNodeType.YieldBreakExpression:
VisitYieldBreakExpression((YieldBreakExpression)node);
break;
case CodeNodeType.LockStatement:
VisitLockStatement((LockStatement)node);
break;
case CodeNodeType.EmptyStatement:
VisitEmptyStatement((EmptyStatement)node);
break;
case CodeNodeType.DynamicMemberReferenceExpression:
VisitDynamicMemberReferenceExpression((DynamicMemberReferenceExpression)node);
break;
case CodeNodeType.DynamicConstructorInvocationExpression:
VisitDynamicConstructorInvocationExpression((DynamicConstructorInvocationExpression)node);
break;
case CodeNodeType.DynamicIndexerExpression:
VisitDynamicIndexerExpression((DynamicIndexerExpression)node);
break;
case CodeNodeType.BoxExpression:
VisitBoxExpression((BoxExpression)node);
break;
case CodeNodeType.LambdaParameterExpression:
VisitLambdaParameterExpression((LambdaParameterExpression)node);
break;
case CodeNodeType.AwaitExpression:
VisitAwaitExpression((AwaitExpression)node);
break;
case CodeNodeType.ArrayLengthExpression:
VisitArrayLengthExpression((ArrayLengthExpression)node);
break;
case CodeNodeType.ExceptionStatement:
VisitExceptionStatement((ExceptionStatement)node);
break;
case CodeNodeType.BreakSwitchCaseStatement:
VisitBreakSwitchCaseStatement((BreakSwitchCaseStatement)node);
break;
case CodeNodeType.CaseGotoStatement:
VisitCaseGotoStatement((CaseGotoStatement)node);
break;
case CodeNodeType.FinallyClause:
VisitFinallyClause((FinallyClause)node);
break;
case CodeNodeType.ShortFormReturnExpression:
VisitShortFormReturnExpression((ShortFormReturnExpression)node);
break;
case CodeNodeType.AnonymousObjectCreationExpression:
VisitAnonymousObjectCreationExpression((AnonymousObjectCreationExpression)node);
break;
case CodeNodeType.FromClause:
VisitFromClause((FromClause)node);
break;
case CodeNodeType.WhereClause:
VisitWhereClause((WhereClause)node);
break;
case CodeNodeType.SelectClause:
VisitSelectClause((SelectClause)node);
break;
case CodeNodeType.OrderByClause:
VisitOrderByClause((OrderByClause)node);
break;
case CodeNodeType.GroupClause:
VisitGroupClause((GroupClause)node);
break;
case CodeNodeType.JoinClause:
VisitJoinClause((JoinClause)node);
break;
case CodeNodeType.LetClause:
VisitLetClause((LetClause)node);
break;
case CodeNodeType.IntoClause:
VisitIntoClause((IntoClause)node);
break;
case CodeNodeType.LinqQueryExpression:
VisitLinqQueryExpression((LinqQueryExpression)node);
break;
case CodeNodeType.ArrayVariableCreationExpression:
VisitArrayVariableDeclarationExpression((ArrayVariableDeclarationExpression)node);
break;
case CodeNodeType.ArrayAssignmentVariableReferenceExpression:
VisitArrayAssignmentVariableReferenceExpression((ArrayVariableReferenceExpression)node);
break;
case CodeNodeType.ArrayAssignmentFieldReferenceExpression:
VisitArrayAssignmentFieldReferenceExpression((ArrayAssignmentFieldReferenceExpression)node);
break;
case CodeNodeType.AnonymousPropertyInitializerExpression:
VisitAnonymousPropertyInitializerExpression((AnonymousPropertyInitializerExpression)node);
break;
case CodeNodeType.PropertyInitializerExpression:
VisitPropertyInitializerExpression((PropertyInitializerExpression)node);
break;
case CodeNodeType.FieldInitializerExpression:
VisitFieldInitializerExpression((FieldInitializerExpression)node);
break;
case CodeNodeType.ParenthesesExpression:
VisitParenthesesExpression((ParenthesesExpression)node);
break;
case CodeNodeType.InitializerExpression:
VisitInitializerExpression((InitializerExpression)node);
break;
case CodeNodeType.CheckedExpression:
VisitCheckedExpression((CheckedExpression)node);
break;
case CodeNodeType.MemberHandleExpression:
VisitMemberHandleExpression((MemberHandleExpression)node);
break;
case CodeNodeType.AutoPropertyConstructorInitializerExpression:
VisitAutoPropertyConstructorInitializerExpression((AutoPropertyConstructorInitializerExpression)node);
break;
case CodeNodeType.RaiseEventExpression:
VisitRaiseEventExpression((RaiseEventExpression)node);
break;
case CodeNodeType.RefVariableDeclarationExpression:
VisitRefVariableDeclarationExpression((RefVariableDeclarationExpression)node);
break;
case CodeNodeType.RefReturnExpression:
VisitRefReturnExpression((RefReturnExpression)node);
break;
default:
throw new ArgumentException();
}
visitsOnStack--;
}
public bool TryInlineVariable(VariableDefinition variableDef, Expression value, ICodeNode target, bool aggressive, out ICodeNode result)
{
this.variableDef = variableDef;
this.value = value;
if (!aggressive)
{
ASTNodeCounter counter = new ASTNodeCounter();
if (counter.CountNodes(value) + counter.CountNodes(target) - 1 > MaxCount)
{
result = target;
return(false);
}
}
SideEffectsFinder sideEffectsFinder = new SideEffectsFinder();
valueHasSideEffects = sideEffectsFinder.HasSideEffectsRecursive(value);
status = InliningResult.NotFound;
result = Visit(target);
return(status == InliningResult.Success);
}
protected void DoVisit(ICodeNode node)
{
base.Visit(node);
}
public override void Visit(ICodeNode node)
{
if (!this.isUsed)
{
base.Visit(node);
}
}
private ICodeNode ParseFactor(Token token)
{
TokenType tokenType = token.type;
ICodeNode rootNode = null;
switch (tokenType.ToString())
{
case "IDENTIFIER":
{
// Look up the identifier in the symbol table stack.
// Flag the identifier as undefined if it's not found.
String name = token.text.ToLower();
SymbolTableEntry id = symbolTableStack.Lookup(name);
if (id == null)
{
errorHandler.flag(token, PascalErrorCode.IDENTIFIER_UNDEFINED, this);
id = symbolTableStack.EnterLocal(name);
}
rootNode = ICodeFactory.CreateICodeNode(ICodeNodeTypeImplementation.VARIABLE);
rootNode.SetAttribute(ICodeKeyImplementation.ID, id);
id.AppendLineNumber(token.lineNumber);
token = NextToken(); // consume the identifier
break;
}
case "INTEGER":
{
// Create an INTEGER_CONSTANT node as the root node.
rootNode = ICodeFactory.CreateICodeNode(ICodeNodeTypeImplementation.INTEGER_CONSTANT);
rootNode.SetAttribute(ICodeKeyImplementation.VALUE, token.value);
token = NextToken(); // consume the number
break;
}
case "REAL":
{
// Create an REAL_CONSTANT node as the root node.
rootNode = ICodeFactory.CreateICodeNode(ICodeNodeTypeImplementation.REAL_CONSTANT);
rootNode.SetAttribute(ICodeKeyImplementation.VALUE, token.value);
token = NextToken(); // consume the number
break;
}
case "STRING":
{
String value = (String)token.value;
// Create a STRING_CONSTANT node as the root node.
rootNode = ICodeFactory.CreateICodeNode(ICodeNodeTypeImplementation.STRING_CONSTANT);
rootNode.SetAttribute(ICodeKeyImplementation.VALUE, value);
token = NextToken(); // consume the string
break;
}
case "NOT":
{
token = NextToken(); // consume the NOT
// Create a NOT node as the root node.
rootNode = ICodeFactory.CreateICodeNode(ICodeNodeTypeImplementation.NOT);
// Parse the factor. The NOT node adopts the
// factor node as its child.
rootNode.AddChild(ParseFactor(token));
break;
}
case "LEFT_PAREN":
{
token = NextToken(); // consume the (
// Parse an expression and make its node the root node.
rootNode = ParseExpression(token);
// Look for the matching ) token.
token = CurrentToken();
if (token.type == PascalTokenType.RIGHT_PAREN)
{
token = NextToken(); // consume the )
}
else
{
errorHandler.flag(token, PascalErrorCode.MISSING_RIGHT_PAREN, this);
}
break;
}
default:
{
errorHandler.flag(token, PascalErrorCode.UNEXPECTED_TOKEN, this);
break;
}
}
return(rootNode);
}
public override void Visit(ICodeNode node)
{
if (!isConstant)
{
return;
}
switch (node.CodeNodeType)
{
case CodeNodeType.UnaryExpression:
UnaryExpression unaryNode = node as UnaryExpression;
switch (unaryNode.Operator)
{
case UnaryOperator.Negate:
case UnaryOperator.LogicalNot:
case UnaryOperator.BitwiseNot:
case UnaryOperator.UnaryPlus:
case UnaryOperator.None:
break;
case UnaryOperator.AddressDereference:
break;
case UnaryOperator.AddressReference:
case UnaryOperator.AddressOf:
return;
default:
isConstant = false;
return;
}
break;
case CodeNodeType.BinaryExpression:
BinaryExpression binaryExpression = node as BinaryExpression;
isConstant = !binaryExpression.IsChecked && binaryExpression.Operator != BinaryOperator.Divide && binaryExpression.Operator != BinaryOperator.Modulo;
if (!isConstant)
{
return;
}
break;
case CodeNodeType.SafeCastExpression:
case CodeNodeType.TypeOfExpression:
break;
case CodeNodeType.ArgumentReferenceExpression:
//TODO: Can be improved
isConstant = false;
return;
case CodeNodeType.ThisReferenceExpression:
//TODO: Value types
return;
case CodeNodeType.BaseReferenceExpression:
case CodeNodeType.TypeReferenceExpression:
case CodeNodeType.MethodReferenceExpression:
case CodeNodeType.LiteralExpression:
return;
default:
isConstant = false;
return;
}
base.Visit(node);
}
public bool ContainsTransparentIdentifiers(ICodeNode node)
{
contains = false;
Visit(node);
return(contains);
}
public bool FindVariable(ICodeNode node)
{
found = false;
Visit(node);
return(found);
}
public bool ContainsKey(ICodeNode node)
{
return(this.nodeToCodeMap.ContainsKey(node));
}
public virtual void Visit(ICodeNode node)
{
this.visitsOnStack = this.visitsOnStack + (long)1;
if (this.visitsOnStack == (long)0x258)
{
this.visitsOnStack = (long)0;
throw new Exception("Stack overflow while traversing code tree in visit.");
}
if (node == null)
{
this.visitsOnStack = this.visitsOnStack - (long)1;
return;
}
switch (node.get_CodeNodeType())
{
case 0:
{
this.VisitBlockStatement((BlockStatement)node);
break;
}
case 1:
{
this.VisitUnsafeBlockStatement((UnsafeBlockStatement)node);
break;
}
case 2:
{
this.VisitGotoStatement((GotoStatement)node);
break;
}
case 3:
{
this.VisitIfStatement((IfStatement)node);
break;
}
case 4:
{
this.VisitIfElseIfStatement((IfElseIfStatement)node);
break;
}
case 5:
{
this.VisitExpressionStatement((ExpressionStatement)node);
break;
}
case 6:
{
this.VisitThrowExpression((ThrowExpression)node);
break;
}
case 7:
{
this.VisitWhileStatement((WhileStatement)node);
break;
}
case 8:
{
this.VisitDoWhileStatement((DoWhileStatement)node);
break;
}
case 9:
{
this.VisitBreakStatement((BreakStatement)node);
break;
}
case 10:
{
this.VisitContinueStatement((ContinueStatement)node);
break;
}
case 11:
{
this.VisitForStatement((ForStatement)node);
break;
}
case 12:
{
this.VisitForEachStatement((ForEachStatement)node);
break;
}
case 13:
{
this.VisitConditionCase((ConditionCase)node);
break;
}
case 14:
{
this.VisitDefaultCase((DefaultCase)node);
break;
}
case 15:
{
this.VisitSwitchStatement((SwitchStatement)node);
break;
}
case 16:
{
this.VisitCatchClause((CatchClause)node);
break;
}
case 17:
{
this.VisitTryStatement((TryStatement)node);
break;
}
case 18:
{
this.VisitBlockExpression((BlockExpression)node);
break;
}
case 19:
{
this.VisitMethodInvocationExpression((MethodInvocationExpression)node);
break;
}
case 20:
{
this.VisitMethodReferenceExpression((MethodReferenceExpression)node);
break;
}
case 21:
{
this.VisitDelegateCreationExpression((DelegateCreationExpression)node);
break;
}
case 22:
{
this.VisitLiteralExpression((LiteralExpression)node);
break;
}
case 23:
{
this.VisitUnaryExpression((UnaryExpression)node);
break;
}
case 24:
{
this.VisitBinaryExpression((BinaryExpression)node);
break;
}
case 25:
{
this.VisitArgumentReferenceExpression((ArgumentReferenceExpression)node);
break;
}
case 26:
{
this.VisitVariableReferenceExpression((VariableReferenceExpression)node);
break;
}
case 27:
{
this.VisitVariableDeclarationExpression((VariableDeclarationExpression)node);
break;
}
case 28:
{
this.VisitThisReferenceExpression((ThisReferenceExpression)node);
break;
}
case 29:
{
this.VisitBaseReferenceExpression((BaseReferenceExpression)node);
break;
}
case 30:
{
this.VisitFieldReferenceExpression((FieldReferenceExpression)node);
break;
}
case 31:
{
this.VisitExplicitCastExpression((ExplicitCastExpression)node);
break;
}
case 32:
{
this.VisitImplicitCastExpression((ImplicitCastExpression)node);
break;
}
case 33:
{
this.VisitSafeCastExpression((SafeCastExpression)node);
break;
}
case 34:
{
this.VisitCanCastExpression((CanCastExpression)node);
break;
}
case 35:
{
this.VisitTypeOfExpression((TypeOfExpression)node);
break;
}
case 36:
{
this.VisitConditionExpression((ConditionExpression)node);
break;
}
case 37:
{
this.VisitFixedStatement((FixedStatement)node);
break;
}
case 38:
{
this.VisitArrayCreationExpression((ArrayCreationExpression)node);
break;
}
case 39:
{
this.VisitArrayIndexerExpression((ArrayIndexerExpression)node);
break;
}
case 40:
{
this.VisitObjectCreationExpression((ObjectCreationExpression)node);
break;
}
case 41:
{
this.VisitDefaultObjectExpression((DefaultObjectExpression)node);
break;
}
case 42:
{
this.VisitPropertyReferenceExpression((PropertyReferenceExpression)node);
break;
}
case 43:
{
this.VisitTypeReferenceExpression((TypeReferenceExpression)node);
break;
}
case 44:
{
this.VisitUsingStatement((UsingStatement)node);
break;
}
case 45:
{
this.VisitStackAllocExpression((StackAllocExpression)node);
break;
}
case 46:
{
this.VisitSizeOfExpression((SizeOfExpression)node);
break;
}
case 47:
{
this.VisitMakeRefExpression((MakeRefExpression)node);
break;
}
case 48:
{
this.VisitEventReferenceExpression((EventReferenceExpression)node);
break;
}
case 49:
{
this.VisitEnumExpression((EnumExpression)node);
break;
}
case 50:
{
this.VisitLambdaExpression((LambdaExpression)node);
break;
}
case 51:
{
this.VisitDelegateInvokeExpression((DelegateInvokeExpression)node);
break;
}
case 52:
{
this.VisitBaseCtorExpression((BaseCtorExpression)node);
break;
}
case 53:
{
this.VisitThisCtorExpression((ThisCtorExpression)node);
break;
}
case 54:
{
this.VisitYieldReturnExpression((YieldReturnExpression)node);
break;
}
case 55:
{
this.VisitYieldBreakExpression((YieldBreakExpression)node);
break;
}
case 56:
{
this.VisitLockStatement((LockStatement)node);
break;
}
case 57:
{
this.VisitReturnExpression((ReturnExpression)node);
break;
}
case 58:
{
this.VisitEmptyStatement((EmptyStatement)node);
break;
}
case 59:
{
this.VisitDynamicMemberReferenceExpression((DynamicMemberReferenceExpression)node);
break;
}
case 60:
{
this.VisitDynamicConstructorInvocationExpression((DynamicConstructorInvocationExpression)node);
break;
}
case 61:
{
this.VisitDynamicIndexerExpression((DynamicIndexerExpression)node);
break;
}
case 62:
{
this.VisitBoxExpression((BoxExpression)node);
break;
}
case 63:
{
this.VisitAnonymousPropertyInitializerExpression((AnonymousPropertyInitializerExpression)node);
break;
}
case 64:
{
this.VisitLambdaParameterExpression((LambdaParameterExpression)node);
break;
}
case 65:
{
this.VisitAwaitExpression((AwaitExpression)node);
break;
}
case 66:
{
this.VisitArrayLengthExpression((ArrayLengthExpression)node);
break;
}
case 67:
{
this.VisitExceptionStatement((ExceptionStatement)node);
break;
}
case 68:
{
this.VisitBreakSwitchCaseStatement((BreakSwitchCaseStatement)node);
break;
}
case 69:
{
this.VisitCaseGotoStatement((CaseGotoStatement)node);
break;
}
case 70:
{
this.VisitFinallyClause((FinallyClause)node);
break;
}
case 71:
{
this.VisitShortFormReturnExpression((ShortFormReturnExpression)node);
break;
}
case 72:
{
this.VisitAnonymousObjectCreationExpression((AnonymousObjectCreationExpression)node);
break;
}
case 73:
{
this.VisitFromClause((FromClause)node);
break;
}
case 74:
{
this.VisitSelectClause((SelectClause)node);
break;
}
case 75:
{
this.VisitWhereClause((WhereClause)node);
break;
}
case 76:
{
this.VisitGroupClause((GroupClause)node);
break;
}
case 77:
{
this.VisitOrderByClause((OrderByClause)node);
break;
}
case 78:
{
this.VisitJoinClause((JoinClause)node);
break;
}
case 79:
{
this.VisitLetClause((LetClause)node);
break;
}
case 80:
{
this.VisitIntoClause((IntoClause)node);
break;
}
case 81:
{
this.VisitLinqQueryExpression((LinqQueryExpression)node);
break;
}
case 82:
{
this.VisitArrayVariableDeclarationExpression((ArrayVariableDeclarationExpression)node);
break;
}
case 83:
{
this.VisitArrayAssignmentVariableReferenceExpression((ArrayVariableReferenceExpression)node);
break;
}
case 84:
{
this.VisitArrayAssignmentFieldReferenceExpression((ArrayAssignmentFieldReferenceExpression)node);
break;
}
case 85:
{
this.VisitPropertyInitializerExpression((PropertyInitializerExpression)node);
break;
}
case 86:
{
this.VisitFieldInitializerExpression((FieldInitializerExpression)node);
break;
}
case 87:
{
this.VisitParenthesesExpression((ParenthesesExpression)node);
break;
}
case 88:
{
this.VisitInitializerExpression((InitializerExpression)node);
break;
}
case 89:
{
this.VisitCheckedExpression((CheckedExpression)node);
break;
}
case 90:
{
this.VisitMemberHandleExpression((MemberHandleExpression)node);
break;
}
case 91:
{
this.VisitAutoPropertyConstructorInitializerExpression((AutoPropertyConstructorInitializerExpression)node);
break;
}
case 92:
{
this.VisitRaiseEventExpression((RaiseEventExpression)node);
break;
}
case 93:
{
this.VisitRefVariableDeclarationExpression((RefVariableDeclarationExpression)node);
break;
}
case 94:
{
this.VisitRefReturnExpression((RefReturnExpression)node);
break;
}
default:
{
goto Label0;
}
}
this.visitsOnStack = this.visitsOnStack - (long)1;
return;
Label0:
throw new ArgumentException();
}
// public override ICodeNode VisitAssignExpression(AssignExpression node)
// {
// CodeNodeCollection<Expression> collection = new CodeNodeCollection<Expression>();
// collection.Add(node.Expression);
// collection = (CodeNodeCollection<Expression>) Visit (collection);
//
// if (collection.Count > 0 && collection[0].Equals(node.Expression)) {
// return node;
// }
//
// node.Expression = collection[collection.Count - 1];
// collection[collection.Count - 1] = node;
// return collection;
// }
public override ICodeNode VisitExpressionStatement(ExpressionStatement node)
{
sideEffects.Clear();
currentSideEffect = new SideEffectInfo();
ICodeNode result = (ICodeNode)Visit(node.Expression);
CodeNodeCollection <Expression> original = result as CodeNodeCollection <Expression>;
if (original != null)
{
var collection = new CodeNodeCollection <Statement>();
for (int i = 0; i < original.Count; i++)
{
collection.Add(new ExpressionStatement(original[i]));
}
return((CodeNodeCollection <Statement>)Visit(collection));
}
else
{
node.Expression = (Expression)result;
var assignExp = result as AssignExpression;
if (assignExp != null)
{
var mInvoke = assignExp.Expression as MethodInvocationExpression;
if (mInvoke != null && IsSimpleInlineCase(mInvoke))
{
return(InlineExpansion(mInvoke, assignExp.Target, source));
}
else
{
return(node);
}
}
else
{
SideEffectInfo row;
MethodInvocationExpression mInvoke;
MethodReferenceExpression mRef;
var expansion = new CodeNodeCollection <Statement>();
for (int i = 0; i < sideEffects.Count; i++)
{
row = sideEffects[i];
VariableDefinition @var;
for (int j = 0; j < row.SideEffectsInNode.Count; j++)
{
mInvoke = row.SideEffectsInNode[j];
mRef = mInvoke.Method as MethodReferenceExpression;
//Mono.Cecil 0.9.3 migration: if (mRef.Method.ReturnType.ReturnType.Name != "Void") {
if (mRef.Method.ReturnType.Name != "Void")
{
expansion.Add(new ExpressionStatement(new AssignExpression(
new VariableReferenceExpression(row.SideEffectsInNodeVar[j]), mInvoke)));
}
else
{
expansion.Add(new ExpressionStatement(mInvoke));
}
}
mRef = row.mInvokeNode.Method as MethodReferenceExpression;
for (int j = 0; j < row.mInvokeNode.Arguments.Count; j++)
{
ParameterDefinition paramDef = mRef.Method.Parameters[j];
//enable constant folding
Expression arg = row.mInvokeNode.Arguments[j];
if (!(arg is ArgumentReferenceExpression || arg is VariableReferenceExpression ||
arg is LiteralExpression))
{
@var = RegisterVariable(paramDef.ParameterType, source.Method);
expansion.Add(new ExpressionStatement(new AssignExpression(
new VariableReferenceExpression(@var), arg)));
row.mInvokeNode.Arguments[j] = new VariableReferenceExpression(@var);
}
// @var = RegisterVariable(paramDef.ParameterType, source.Method);
// expansion.Add(new ExpressionStatement(new AssignExpression(
// new VariableReferenceExpression(@var), row.mInvokeNode.Arguments[j])));
// row.mInvokeNode.Arguments[j] = new VariableReferenceExpression(@var);
}
//TODO: Трябва да се оптимизира в случая когато има странични ефекти, а няма инлайн
//или има странични ефекти останали след последния инлайн.
for (int j = 0; j < currentSideEffect.SideEffectsInNode.Count; j++)
{
mInvoke = currentSideEffect.SideEffectsInNode[j];
mRef = mInvoke.Method as MethodReferenceExpression;
expansion.Add(new ExpressionStatement(new AssignExpression(
new VariableReferenceExpression(currentSideEffect.SideEffectsInNodeVar[j]), mInvoke)));
}
//endtodo.
mRef = row.mInvokeNode.Method as MethodReferenceExpression;
//Mono.Cecil 0.9.3 migration: if (mRef.Method.ReturnType.ReturnType.Name != "Void") {
if (mRef.Method.ReturnType.Name != "Void")
{
expansion.Add(new ExpressionStatement(new AssignExpression(
new VariableReferenceExpression(row.mInvokeNodeVar), row.mInvokeNode)));
}
else
{
expansion.Add(new ExpressionStatement(row.mInvokeNode));
}
}
expansion.Add(node);
if (expansion.Count > 1)
{
return((CodeNodeCollection <Statement>)Visit(expansion));
}
else
{
return(node);
}
}
}
}
private ICodeNode DoVisit(ICodeNode node)
{
if (node == null)
{
return(null);
}
switch (node.CodeNodeType)
{
case CodeNodeType.BlockStatement:
return(VisitBlockStatement((BlockStatement)node));
case CodeNodeType.ReturnExpression:
return(VisitReturnExpression((ReturnExpression)node));
case CodeNodeType.GotoStatement:
return(VisitGotoStatement((GotoStatement)node));
case CodeNodeType.IfStatement:
return(VisitIfStatement((IfStatement)node));
case CodeNodeType.IfElseIfStatement:
return(VisitIfElseIfStatement((IfElseIfStatement)node));
case CodeNodeType.ExpressionStatement:
return(VisitExpressionStatement((ExpressionStatement)node));
case CodeNodeType.ThrowExpression:
return(VisitThrowExpression((ThrowExpression)node));
case CodeNodeType.WhileStatement:
return(VisitWhileStatement((WhileStatement)node));
case CodeNodeType.DoWhileStatement:
return(VisitDoWhileStatement((DoWhileStatement)node));
case CodeNodeType.BreakStatement:
return(VisitBreakStatement((BreakStatement)node));
case CodeNodeType.ContinueStatement:
return(VisitContinueStatement((ContinueStatement)node));
case CodeNodeType.ForStatement:
return(VisitForStatement((ForStatement)node));
case CodeNodeType.ForEachStatement:
return(VisitForEachStatement((ForEachStatement)node));
case CodeNodeType.ConditionCase:
return(VisitConditionCase((ConditionCase)node));
case CodeNodeType.DefaultCase:
return(VisitDefaultCase((DefaultCase)node));
case CodeNodeType.SwitchStatement:
return(VisitSwitchStatement((SwitchStatement)node));
case CodeNodeType.CatchClause:
return(VisitCatchClause((CatchClause)node));
case CodeNodeType.TryStatement:
return(VisitTryStatement((TryStatement)node));
case CodeNodeType.BlockExpression:
return(VisitBlockExpression((BlockExpression)node));
case CodeNodeType.MethodInvocationExpression:
return(VisitMethodInvocationExpression((MethodInvocationExpression)node));
case CodeNodeType.MethodReferenceExpression:
return(VisitMethodReferenceExpression((MethodReferenceExpression)node));
case CodeNodeType.DelegateCreationExpression:
return(VisitDelegateCreationExpression((DelegateCreationExpression)node));
case CodeNodeType.LiteralExpression:
return(VisitLiteralExpression((LiteralExpression)node));
case CodeNodeType.UnaryExpression:
return(VisitUnaryExpression((UnaryExpression)node));
case CodeNodeType.BinaryExpression:
return(VisitBinaryExpression((BinaryExpression)node));
case CodeNodeType.ArgumentReferenceExpression:
return(VisitArgumentReferenceExpression((ArgumentReferenceExpression)node));
case CodeNodeType.VariableReferenceExpression:
return(VisitVariableReferenceExpression((VariableReferenceExpression)node));
case CodeNodeType.VariableDeclarationExpression:
return(VisitVariableDeclarationExpression((VariableDeclarationExpression)node));
case CodeNodeType.ThisReferenceExpression:
return(VisitThisReferenceExpression((ThisReferenceExpression)node));
case CodeNodeType.BaseReferenceExpression:
return(VisitBaseReferenceExpression((BaseReferenceExpression)node));
case CodeNodeType.FieldReferenceExpression:
return(VisitFieldReferenceExpression((FieldReferenceExpression)node));
case CodeNodeType.CastExpression:
return(VisitCastExpression((CastExpression)node));
case CodeNodeType.SafeCastExpression:
return(VisitSafeCastExpression((SafeCastExpression)node));
case CodeNodeType.CanCastExpression:
return(VisitCanCastExpression((CanCastExpression)node));
case CodeNodeType.TypeOfExpression:
return(VisitTypeOfExpression((TypeOfExpression)node));
case CodeNodeType.ConditionExpression:
return(VisitConditionExpression((ConditionExpression)node));
case CodeNodeType.ArrayCreationExpression:
return(VisitArrayCreationExpression((ArrayCreationExpression)node));
case CodeNodeType.ArrayIndexerExpression:
return(VisitArrayIndexerExpression((ArrayIndexerExpression)node));
case CodeNodeType.ObjectCreationExpression:
return(VisitObjectCreationExpression((ObjectCreationExpression)node));
case CodeNodeType.DefaultObjectExpression:
return(VisitDefaultObjectExpression((DefaultObjectExpression)node));
case CodeNodeType.PropertyReferenceExpression:
return(VisitPropertyReferenceExpression((PropertyReferenceExpression)node));
case CodeNodeType.TypeReferenceExpression:
return(VisitTypeReferenceExpression((TypeReferenceExpression)node));
case CodeNodeType.UsingStatement:
return(VisitUsingStatement((UsingStatement)node));
case CodeNodeType.FixedStatement:
return(VisitFixedStatement((FixedStatement)node));
case CodeNodeType.StackAllocExpression:
return(VisitStackAllocExpression((StackAllocExpression)node));
case CodeNodeType.SizeOfExpression:
return(VisitSizeOfExpression((SizeOfExpression)node));
case CodeNodeType.MakeRefExpression:
return(VisitMakeRefExpression((MakeRefExpression)node));
case CodeNodeType.EnumExpression:
return(VisitEnumExpression((EnumExpression)node));
case CodeNodeType.LambdaExpression:
return(VisitLambdaExpression((LambdaExpression)node));
case CodeNodeType.DelegateInvokeExpression:
return(VisitDelegateInvokeExpression((DelegateInvokeExpression)node));
case CodeNodeType.BaseCtorExpression:
return(VisitBaseCtorExpression((BaseCtorExpression)node));
case CodeNodeType.ThisCtorExpression:
return(VisitThisCtorExpression((ThisCtorExpression)node));
case CodeNodeType.YieldReturnExpression:
return(VisitYieldReturnExpression((YieldReturnExpression)node));
case CodeNodeType.YieldBreakExpression:
return(VisitYieldBreakExpression((YieldBreakExpression)node));
case CodeNodeType.LockStatement:
return(VisitLockStatement((LockStatement)node));
case CodeNodeType.EmptyStatement:
return(VisitEmptyStatement((EmptyStatement)node));
case CodeNodeType.DynamicMemberReferenceExpression:
return(VisitDynamicMemberReferenceExpression((DynamicMemberReferenceExpression)node));
case CodeNodeType.DynamicConstructorInvocationExpression:
return(VisitDynamicConstructorInvocationExpression((DynamicConstructorInvocationExpression)node));
case CodeNodeType.DynamicIndexerExpression:
return(VisitDynamicIndexerExpression((DynamicIndexerExpression)node));
case CodeNodeType.EventReferenceExpression:
return(VisitEventReferenceExpression((EventReferenceExpression)node));
case CodeNodeType.BoxExpression:
return(VisitBoxExpression((BoxExpression)node));
case CodeNodeType.LambdaParameterExpression:
return(VisitLambdaParameterExpression((LambdaParameterExpression)node));
case CodeNodeType.AwaitExpression:
return(VisitAwaitExpression((AwaitExpression)node));
case CodeNodeType.ArrayLengthExpression:
return(VisitArrayLengthExpression((ArrayLengthExpression)node));
case CodeNodeType.ExceptionStatement:
return(VisitExceptionStatement((ExceptionStatement)node));
case CodeNodeType.BreakSwitchCaseStatement:
return(VisitBreakSwitchCaseStatement((BreakSwitchCaseStatement)node));
case CodeNodeType.CaseGotoStatement:
return(VisitCaseGotoStatement((CaseGotoStatement)node));
case CodeNodeType.FinallyClause:
return(VisitFinallyClause((FinallyClause)node));
case CodeNodeType.ShortFormReturnExpression:
return(VisitShortFormReturnExpression((ShortFormReturnExpression)node));
case CodeNodeType.AnonymousObjectCreationExpression:
return(VisitAnonymousObjectCreationExpression((AnonymousObjectCreationExpression)node));
case CodeNodeType.FromClause:
return(VisitFromClause((FromClause)node));
case CodeNodeType.WhereClause:
return(VisitWhereClause((WhereClause)node));
case CodeNodeType.SelectClause:
return(VisitSelectClause((SelectClause)node));
case CodeNodeType.GroupClause:
return(VisitGroupClause((GroupClause)node));
case CodeNodeType.OrderByClause:
return(VisitOrderByClause((OrderByClause)node));
case CodeNodeType.JoinClause:
return(VisitJoinClause((JoinClause)node));
case CodeNodeType.LetClause:
return(VisitLetClause((LetClause)node));
case CodeNodeType.IntoClause:
return(VisitIntoClause((IntoClause)node));
case CodeNodeType.LinqQueryExpression:
return(VisitLinqQueryExpression((LinqQueryExpression)node));
case CodeNodeType.ArrayVariableCreationExpression:
return(VisitArrayVariableDeclarationExpression((ArrayVariableDeclarationExpression)node));
case CodeNodeType.ArrayAssignmentVariableReferenceExpression:
return(VisitArrayAssignmentVariableReferenceExpression((ArrayVariableReferenceExpression)node));
case CodeNodeType.ArrayAssignmentFieldReferenceExpression:
return(VisitArrayAssignmentFieldReferenceExpression((ArrayAssignmentFieldReferenceExpression)node));
case CodeNodeType.AnonymousPropertyInitializerExpression:
return(VisitAnonymousPropertyInitializerExpression((AnonymousPropertyInitializerExpression)node));
case CodeNodeType.PropertyInitializerExpression:
return(VisitPropertyInitializerExpression((PropertyInitializerExpression)node));
case CodeNodeType.FieldInitializerExpression:
return(VisitFieldInitializerExpression((FieldInitializerExpression)node));
case CodeNodeType.ParenthesesExpression:
return(VisitParenthesesExpression((ParenthesesExpression)node));
case CodeNodeType.InitializerExpression:
return(VisitInitializerExpression((InitializerExpression)node));
case CodeNodeType.CheckedExpression:
return(VisitCheckedExpression((CheckedExpression)node));
case CodeNodeType.MemberHandleExpression:
return(VisitMemberHandleExpression((MemberHandleExpression)node));
case CodeNodeType.AutoPropertyConstructorInitializerExpression:
return(VisitAutoPropertyConstructorInitializerExpression((AutoPropertyConstructorInitializerExpression)node));
case CodeNodeType.RaiseEventExpression:
return(VisitRaiseEventExpression((RaiseEventExpression)node));
default:
throw new ArgumentException();
}
}
public int CountNodes(ICodeNode node)
{
this.count = 0;
this.Visit(node);
return(this.count);
}
public override void Visit(ICodeNode node)
{
this.count = this.count + 1;
this.Visit(node);
return;
}
public bool TryInlineVariable(VariableDefinition variableDef, Expression value, ICodeNode target, bool aggressive, out ICodeNode result)
{
this.variableDef = variableDef;
this.value = value;
if (!aggressive)
{
V_1 = new SimpleVariableInliner.ASTNodeCounter();
if (V_1.CountNodes(value) + V_1.CountNodes(target) - 1 > 10)
{
result = target;
return(false);
}
}
this.valueHasSideEffects = (new SideEffectsFinder()).HasSideEffectsRecursive(value);
this.status = 0;
result = this.Visit(target);
return(this.status == 1);
}
private ICodeNode ConvertInvocation(MethodInvocationExpression invocation)
{
if (invocation.MethodExpression == null || invocation.MethodExpression.Method == null || invocation.MethodExpression.Method.HasThis ||
invocation.MethodExpression.Method.DeclaringType == null || invocation.MethodExpression.Method.DeclaringType.FullName != "System.Linq.Expressions.Expression")
{
return(null);
}
//MethodDefinition methodDef = invocation.MethodExpression.MethodDefinition;
//if (methodDef == null)
//{
// return null;
//}
if (this.conversionDepth == 0 && invocation.MethodExpression.Method.Name != "Lambda")
{
return(null);
}
ICodeNode result = null;
switch (invocation.MethodExpression.Method.Name)
{
case "Add":
result = ConvertBinaryOperator(invocation, BinaryOperator.Add, false);
break;
case "AddChecked":
result = ConvertBinaryOperator(invocation, BinaryOperator.Add, true);
break;
case "And":
result = ConvertBinaryOperator(invocation, BinaryOperator.BitwiseAnd);
break;
case "AndAlso":
result = ConvertBinaryOperator(invocation, BinaryOperator.LogicalAnd);
break;
case "ArrayAccess":
case "ArrayIndex":
result = ConvertArrayIndex(invocation);
break;
case "ArrayLength":
result = ConvertArrayLength(invocation);
break;
case "Bind":
result = ConvertBind(invocation);
break;
case "Call":
result = ConvertCall(invocation);
break;
case "Coalesce":
result = ConvertBinaryOperator(invocation, BinaryOperator.NullCoalesce);
break;
case "Condition":
result = ConvertCondition(invocation);
break;
case "Constant":
result = ConvertConstant(invocation);
break;
case "Convert":
result = ConvertCast(invocation);
break;
case "ConvertChecked":
result = ConvertCastChecked(invocation);
break;
case "Divide":
result = ConvertBinaryOperator(invocation, BinaryOperator.Divide);
break;
case "ElementInit":
result = ConvertElementInit(invocation);
break;
case "Equal":
result = ConvertBinaryOperator(invocation, BinaryOperator.ValueEquality);
break;
case "ExclusiveOr":
result = ConvertBinaryOperator(invocation, BinaryOperator.BitwiseXor);
break;
case "Field":
result = ConvertField(invocation);
break;
case "GreaterThan":
result = ConvertBinaryOperator(invocation, BinaryOperator.GreaterThan);
break;
case "GreaterThanOrEqual":
result = ConvertBinaryOperator(invocation, BinaryOperator.GreaterThanOrEqual);
break;
case "Invoke":
result = ConvertInvoke(invocation);
break;
case "Lambda":
result = ConvertLambda(invocation);
break;
case "LeftShift":
result = ConvertBinaryOperator(invocation, BinaryOperator.LeftShift);
break;
case "LessThan":
result = ConvertBinaryOperator(invocation, BinaryOperator.LessThan);
break;
case "LessThanOrEqual":
result = ConvertBinaryOperator(invocation, BinaryOperator.LessThanOrEqual);
break;
case "ListBind":
result = ConvertListBind(invocation);
break;
case "ListInit":
result = ConvertListInit(invocation);
break;
case "MemberInit":
result = ConvertMemberInit(invocation);
break;
case "Modulo":
result = ConvertBinaryOperator(invocation, BinaryOperator.Modulo);
break;
case "Multiply":
result = ConvertBinaryOperator(invocation, BinaryOperator.Multiply, false);
break;
case "MultiplyChecked":
result = ConvertBinaryOperator(invocation, BinaryOperator.Multiply, true);
break;
case "Negate":
result = ConvertUnaryOperator(invocation, UnaryOperator.Negate);
break;
case "NegateChecked":
result = ConvertUnaryOperatorChecked(invocation, UnaryOperator.Negate);
break;
case "New":
result = ConvertNewObject(invocation);
break;
case "NewArrayBounds":
result = ConvertNewArrayBounds(invocation);
break;
case "NewArrayInit":
result = ConvertNewArrayInit(invocation);
break;
case "Not":
result = ConvertUnaryOperator(invocation, UnaryOperator.LogicalNot);
break;
case "NotEqual":
result = ConvertBinaryOperator(invocation, BinaryOperator.ValueInequality);
break;
case "OnesComplement":
result = ConvertUnaryOperator(invocation, UnaryOperator.BitwiseNot);
break;
case "Or":
result = ConvertBinaryOperator(invocation, BinaryOperator.BitwiseOr);
break;
case "OrElse":
result = ConvertBinaryOperator(invocation, BinaryOperator.LogicalOr);
break;
case "Parameter":
result = ConvertParameter(invocation);
break;
case "Property":
result = ConvertProperty(invocation);
break;
case "Quote":
if (invocation.Arguments.Count == 1)
{
result = Visit(invocation.Arguments[0]);
}
break;
case "RightShift":
result = ConvertBinaryOperator(invocation, BinaryOperator.RightShift);
break;
case "Subtract":
result = ConvertBinaryOperator(invocation, BinaryOperator.Subtract, false);
break;
case "SubtractChecked":
result = ConvertBinaryOperator(invocation, BinaryOperator.Subtract, true);
break;
case "TypeAs":
result = ConvertTypeAs(invocation);
break;
case "TypeIs":
result = ConvertTypeIs(invocation);
break;
default:
return(null);
}
this.failure |= result == null;
return(result);
}
public virtual void Visit(ICodeNode node)
{
if (null == node)
{
return;
}
switch (node.CodeNodeType)
{
case CodeNodeType.BlockStatement:
VisitBlockStatement((BlockStatement)node);
break;
case CodeNodeType.ReturnStatement:
VisitReturnStatement((ReturnStatement)node);
break;
case CodeNodeType.GotoStatement:
VisitGotoStatement((GotoStatement)node);
break;
case CodeNodeType.LabeledStatement:
VisitLabeledStatement((LabeledStatement)node);
break;
case CodeNodeType.IfStatement:
VisitIfStatement((IfStatement)node);
break;
case CodeNodeType.ExpressionStatement:
VisitExpressionStatement((ExpressionStatement)node);
break;
case CodeNodeType.ThrowStatement:
VisitThrowStatement((ThrowStatement)node);
break;
case CodeNodeType.WhileStatement:
VisitWhileStatement((WhileStatement)node);
break;
case CodeNodeType.DoWhileStatement:
VisitDoWhileStatement((DoWhileStatement)node);
break;
case CodeNodeType.BreakStatement:
VisitBreakStatement((BreakStatement)node);
break;
case CodeNodeType.ContinueStatement:
VisitContinueStatement((ContinueStatement)node);
break;
case CodeNodeType.ForStatement:
VisitForStatement((ForStatement)node);
break;
case CodeNodeType.ForEachStatement:
VisitForEachStatement((ForEachStatement)node);
break;
case CodeNodeType.ConditionCase:
VisitConditionCase((ConditionCase)node);
break;
case CodeNodeType.DefaultCase:
VisitDefaultCase((DefaultCase)node);
break;
case CodeNodeType.SwitchStatement:
VisitSwitchStatement((SwitchStatement)node);
break;
case CodeNodeType.CatchClause:
VisitCatchClause((CatchClause)node);
break;
case CodeNodeType.TryStatement:
VisitTryStatement((TryStatement)node);
break;
case CodeNodeType.BlockExpression:
VisitBlockExpression((BlockExpression)node);
break;
case CodeNodeType.MethodInvocationExpression:
VisitMethodInvocationExpression((MethodInvocationExpression)node);
break;
case CodeNodeType.MethodReferenceExpression:
VisitMethodReferenceExpression((MethodReferenceExpression)node);
break;
case CodeNodeType.DelegateCreationExpression:
VisitDelegateCreationExpression((DelegateCreationExpression)node);
break;
case CodeNodeType.DelegateInvocationExpression:
VisitDelegateInvocationExpression((DelegateInvocationExpression)node);
break;
case CodeNodeType.LiteralExpression:
VisitLiteralExpression((LiteralExpression)node);
break;
case CodeNodeType.UnaryExpression:
VisitUnaryExpression((UnaryExpression)node);
break;
case CodeNodeType.BinaryExpression:
VisitBinaryExpression((BinaryExpression)node);
break;
case CodeNodeType.AssignExpression:
VisitAssignExpression((AssignExpression)node);
break;
case CodeNodeType.ArgumentReferenceExpression:
VisitArgumentReferenceExpression((ArgumentReferenceExpression)node);
break;
case CodeNodeType.VariableReferenceExpression:
VisitVariableReferenceExpression((VariableReferenceExpression)node);
break;
case CodeNodeType.VariableDeclarationExpression:
VisitVariableDeclarationExpression((VariableDeclarationExpression)node);
break;
case CodeNodeType.ThisReferenceExpression:
VisitThisReferenceExpression((ThisReferenceExpression)node);
break;
case CodeNodeType.BaseReferenceExpression:
VisitBaseReferenceExpression((BaseReferenceExpression)node);
break;
case CodeNodeType.FieldReferenceExpression:
VisitFieldReferenceExpression((FieldReferenceExpression)node);
break;
case CodeNodeType.CastExpression:
VisitCastExpression((CastExpression)node);
break;
case CodeNodeType.SafeCastExpression:
VisitSafeCastExpression((SafeCastExpression)node);
break;
case CodeNodeType.CanCastExpression:
VisitCanCastExpression((CanCastExpression)node);
break;
case CodeNodeType.TypeOfExpression:
VisitTypeOfExpression((TypeOfExpression)node);
break;
case CodeNodeType.ConditionExpression:
VisitConditionExpression((ConditionExpression)node);
break;
case CodeNodeType.NullCoalesceExpression:
VisitNullCoalesceExpression((NullCoalesceExpression)node);
break;
case CodeNodeType.AddressDereferenceExpression:
VisitAddressDereferenceExpression((AddressDereferenceExpression)node);
break;
case CodeNodeType.AddressReferenceExpression:
VisitAddressReferenceExpression((AddressReferenceExpression)node);
break;
case CodeNodeType.AddressOfExpression:
VisitAddressOfExpression((AddressOfExpression)node);
break;
case CodeNodeType.ArrayCreationExpression:
VisitArrayCreationExpression((ArrayCreationExpression)node);
break;
case CodeNodeType.ArrayIndexerExpression:
VisitArrayIndexerExpression((ArrayIndexerExpression)node);
break;
case CodeNodeType.ObjectCreationExpression:
VisitObjectCreationExpression((ObjectCreationExpression)node);
break;
case CodeNodeType.PropertyReferenceExpression:
VisitPropertyReferenceExpression((PropertyReferenceExpression)node);
break;
case CodeNodeType.TypeReferenceExpression:
VisitTypeReferenceExpression((TypeReferenceExpression)node);
break;
default:
throw new ArgumentException();
}
}
public override void Visit(ICodeNode node)
{
if (!isStopped)
{
WriteCodeNodeLabel(node);
if (node != null &&
node.CodeNodeType != CodeNodeType.EmptyStatement)
{
int beginStatement = formatter.CurrentPosition;
base.Visit(node);
int endStatement = formatter.CurrentPosition - 1;
if (node != null)
{
this.currentWritingInfo.StatementPositions.Add(node, new OffsetSpan(beginStatement, endStatement));
}
}
else
{
DoVisit(node);
}
}
}
public ICodeNode SetRoot(ICodeNode node)
{
root = node;
return(root);
}
protected void WriteCodeNodeLabel(ICodeNode node)
{
if (node is Statement &&
!(node.CodeNodeType == CodeNodeType.BlockStatement) /*the label goes before the first statement in a block*/)
{
Statement statement = node as Statement;
WriteLabel((statement).Label);
if (node.CodeNodeType != CodeNodeType.EmptyStatement && statement.Label != "") //Labeled statement. The statement should start on the next line after label
{
WriteLine();
}
}
}
public void Add(ICodeNode node, OffsetSpan span)
{
this.nodeToCodeMap.Add(node, span);
return;
}
public override void Visit (ICodeNode node)
{
if (@continue)
base.Visit (node);
}
/* AGPL */
public void Add(ICodeNode node, T span)
{
this.NodeToCodeMap.Add(node, span);
}
