public static StatementSyntax BuildStatement(IEnumerable<IStatement> statements,
IStatementBlock parent, WhitespaceKindLookup whitespaceLookup)
{
StatementSyntax statementBlock;
var statementSyntaxList = statements
.SelectMany(x => RDom.CSharp.GetSyntaxGroup(x))
.ToList();
var hasBlock = parent.HasBlock;
if (hasBlock || statements.Count() > 1)
{
statementBlock = SyntaxFactory.Block(SyntaxFactory.List(statementSyntaxList));
statementBlock = BuildSyntaxHelpers.AttachWhitespace(statementBlock, parent.Whitespace2Set, whitespaceLookup);
// Block tokens are held in parent
}
else if (statements.Count() == 1)
{
statementBlock = (StatementSyntax)statementSyntaxList.First();
//statementBlock = BuildSyntaxHelpers.AttachWhitespace(statementBlock, parent.Whitespace2Set, whitespaceLookup);
}
else
{
statementBlock = SyntaxFactory.EmptyStatement();
statementBlock = BuildSyntaxHelpers.AttachWhitespace(statementBlock, parent.Whitespace2Set, whitespaceLookup);
}
return statementBlock;
}
public static StatementSyntax BuildStatement(IEnumerable <IStatement> statements,
IStatementBlock parent, WhitespaceKindLookup whitespaceLookup)
{
StatementSyntax statementBlock;
var statementSyntaxList = statements
.SelectMany(x => RDom.CSharp.GetSyntaxGroup(x))
.ToList();
var hasBlock = parent.HasBlock;
if (hasBlock || statements.Count() > 1)
{
statementBlock = SyntaxFactory.Block(SyntaxFactory.List(statementSyntaxList));
statementBlock = BuildSyntaxHelpers.AttachWhitespace(statementBlock, parent.Whitespace2Set, whitespaceLookup);
// Block tokens are held in parent
}
else if (statements.Count() == 1)
{
statementBlock = (StatementSyntax)statementSyntaxList.First();
//statementBlock = BuildSyntaxHelpers.AttachWhitespace(statementBlock, parent.Whitespace2Set, whitespaceLookup);
}
else
{
statementBlock = SyntaxFactory.EmptyStatement();
statementBlock = BuildSyntaxHelpers.AttachWhitespace(statementBlock, parent.Whitespace2Set, whitespaceLookup);
}
return(statementBlock);
}
private void ModifyStatement(IStatement ist, IStatementBlock isb)
{
if (isb is IfBlock)
{
IfBlock ib = (IfBlock)isb;
var condVar = ib.ConditionVariable;
if (!negatedConditionVariables.Contains(condVar))
{
if (condVar.definition != null)
{
MethodInvoke mi = condVar.definition;
if (mi.method.Equals(new Func <int, int, bool>(Factor.AreEqual).Method))
{
if (mi.Arguments[1] is Variable)
{
Variable arg1 = (Variable)mi.Arguments[1];
if (arg1.IsObserved || arg1.IsLoopIndex)
{
// convert 'if(vbool1)' into 'if(x==value)' where value is observed (or a loop index) and vbool1 is never negated.
// if vbool1 is negated, then we cannot make this substitution since we need to match the corresponding 'if(!vbool1)' condition.
IConditionStatement ics = (IConditionStatement)ist;
ics.Condition = Builder.BinaryExpr(mi.Arguments[0].GetExpression(), BinaryOperator.ValueEquality, arg1.GetExpression());
}
}
}
}
}
}
}
public BreakStatement(IStatementBlock sourceBlock)
: base(sourceBlock)
{
IStatementBlockLocalMember local = null;
IBreakTargetExitPoint exitPoint = null;
IDeclarationTarget parent = sourceBlock;
//Search up for the block that needs the break.
while (parent != null && local == null)
{
if (parent is IBreakTargetStatement)
{
local = ((IBreakTargetStatement)parent).BreakLocal;
exitPoint = ((IBreakTargetStatement)parent).ExitLabel;
((IBreakTargetStatement)parent).UtilizeBreakMeasures = true;
break;
}
parent = parent.ParentTarget;
}
if (local == null && !(sourceBlock.Parent is ISwitchStatementCase))
{
throw new InvalidOperationException("Cannot insert a break into a non-terminable block.");
}
this.terminalVariable = local;
this.exitSymbol = exitPoint;
}
private ExpressionStatementNode BindExpressionStatement(IStatementBlock parent, Scanner <CommonTree> parentChildren)
{
return(CreateNode <ExpressionStatementNode>((SyntaxNode)parent, parentChildren, (node, children) =>
{
node.Expression = BindExpression(node, parentChildren);
}));
}
private SyntaxNode BindStatement(IStatementBlock parent, Scanner <CommonTree> parentChildren)
{
var astType = parentChildren.Current.GetAstType();
if (astType.ToAssignmentOperatorType() != AssignmentOperatorType.None)
{
return(BindAssignmentStatement(parent, parentChildren));
}
switch (astType)
{
case AstType.While:
return(BindWhileStatement(parent, parentChildren));
case AstType.If:
return(BindIfStatement(parent, parentChildren));
case AstType.Variable:
return(BindDeclareStatement(parent, parentChildren));
case AstType.Return:
return(BindReturnStatement(parent, parentChildren));
default:
return(BindExpressionStatement(parent, parentChildren));
}
}
public SwitchStatementCase(IStatementBlock parentBlock, IExpression firstCase)
{
if (firstCase == null)
{
throw new ArgumentNullException("firstCase");
}
this.parentBlock = parentBlock;
this.Cases.Add(firstCase);
}
public void Dispose()
{
if (this.parentTarget == null || this.statements == null)
{
return;
}
this.parentTarget = null;
this.statements.Dispose();
this.statements = null;
}
public EnumeratorStatement(IStatementBlock sourceBlock)
: base(sourceBlock)
{
enumMember = this.Statements.Locals.AddNew(this.Statements.Locals.GetUnusedName("__enumerator"), typeof(IEnumerator).GetTypeReference());
enumMember.AutoDeclare = false;
currentMember = this.Statements.Locals.AddNew(this.Statements.Locals.GetUnusedName("__current"), typeof(void).GetTypeReference());
currentMember.AutoDeclare = true;
currentMemberInit = new CastExpression(enumMember.GetReference().GetProperty("Current"), itemType);
currentMember.InitializationExpression = currentMemberInit;
}
private WhileStatementNode BindWhileStatement(IStatementBlock parent, Scanner <CommonTree> parentChildren)
{
return(CreateNode <WhileStatementNode>((SyntaxNode)parent, parentChildren, (node, children) =>
{
children.Next();
node.Expression = BindExpression(node, children);
children.Next();
BindStatementsToBlock(node, children);
}));
}
private ReturnStatementNode BindReturnStatement(IStatementBlock parent, Scanner <CommonTree> parentChildren)
{
return(CreateNode <ReturnStatementNode>((SyntaxNode)parent, parentChildren, (node, children) =>
{
children.Next();
if (!children.Done)
{
node.ReturnValue = BindExpression(node, children);
}
}));
}
private AssignmentStatementNode BindAssignmentStatement(IStatementBlock parent, Scanner <CommonTree> parentChildren)
{
return(CreateNode <AssignmentStatementNode>((SyntaxNode)parent, parentChildren, (node, children) =>
{
node.Operation = node.CompilerNode.GetAstType().ToAssignmentOperatorType();
children.Next();
node.LeftValue = BindExpression(node, children);
children.Next();
node.RightValue = BindExpression(node, children);
}));
}
public void Dispose()
{
if (this.isDisposed)
{
return;
}
if (this.statements != null)
{
this.statements.Dispose();
}
this.statements = null;
isDisposed = true;
}
public virtual void TranslateStatementBlock(IStatementBlock statementBlock)
{
foreach (IStatementBlockLocalMember isblm in statementBlock.Locals.Values)
{
if (isblm.AutoDeclare)
{
TranslateStatement(isblm.GetDeclarationStatement());
}
}
foreach (IStatement ist in statementBlock)
{
this.TranslateStatement(ist);
}
}
private IfStatementNode BindIfStatement(IStatementBlock parent, Scanner <CommonTree> parentChildren)
{
return(CreateNode <IfStatementNode>((SyntaxNode)parent, parentChildren, (node, children) =>
{
node.Bodies.Add(BindIfStatementBody(node, parentChildren));
children.Next();
children.Next();
while (children.Next())
{
node.Bodies.Add(BindIfStatementBody(node, children));
}
}));
}
public void Dispose()
{
if (this.statements != null)
{
this.Statements.Dispose();
this.statements = null;
}
this.parentBlock = null;
this.lastIsDefault = false;
if (this.definedLabelNames != null)
{
this.definedLabelNames.Clear();
this.definedLabelNames = null;
}
}
private DeclareStatementNode BindDeclareStatement(IStatementBlock parent, Scanner <CommonTree> parentChildren)
{
return(CreateNode <DeclareStatementNode>((SyntaxNode)parent, parentChildren, (node, children) =>
{
children.Next();
node.TypeIdentifier = BindTypeIdentifier(node, children);
children.Next();
node.Identifier = BindIdentifier(node, children);
if (children.Next())
{
node.InitialValue = BindExpression(node, children);
}
}));
}
public SwitchStatementCase(IStatementBlock parentBlock, IExpressionCollection cases, bool lastIsDefault)
{
if (parentBlock == null)
{
throw new ArgumentNullException("parentBlock");
}
if (cases == null)
{
throw new ArgumentNullException("cases");
}
this.parentBlock = parentBlock;
this.lastIsDefault = lastIsDefault;
foreach (IExpression expression in cases)
{
this.Cases.Add(expression);
}
}
private void BindStatementsToBlock(IStatementBlock parent, Scanner <CommonTree> parentChildren)
{
if (parentChildren.Done)
{
return;
}
var blockChildren = new Scanner <CommonTree>(parentChildren.Current.GetChildren());
while (blockChildren.Next())
{
var statement = BindStatement(parent, blockChildren);
if (statement != null)
{
parent.Statements.Add(statement);
}
}
}
public void InitializeStatements(IStatementBlock itemAsStatement, SyntaxNode syntaxNode, IDom parent, SemanticModel model)
{
if (syntaxNode == null)
{
return;
}
if (itemAsStatement == null)
{
return;
}
var blockSyntax = syntaxNode as BlockSyntax;
if (blockSyntax != null)
{
itemAsStatement.StatementsAll.CreateAndAdd(blockSyntax.Statements, x => Corporation.Create(x, parent, model).Cast <IStatementAndDetail>());
itemAsStatement.HasBlock = true;
return;
}
var statementSyntax = syntaxNode as StatementSyntax;
if (statementSyntax != null)
{
var statements = Corporation.Create(statementSyntax, parent, model).OfType <IStatementAndDetail>();
if (statements.Count() > 1)
{
throw new NotImplementedException();
}
var statement = statements.First();
var statementAsBlockStatement = statement as IBlockStatement;
if (statementAsBlockStatement != null)
{
itemAsStatement.HasBlock = true;
foreach (var st in statementAsBlockStatement.Statements)
{
itemAsStatement.StatementsAll.AddOrMove(st);
}
}
else
{
itemAsStatement.StatementsAll.AddOrMove(statement);
}
}
}
private static string GetName(IStatementBlock sourceBlock)
{
if (sourceBlock.Parent.DefinedLabelNames != null)
{
string baseName = "__exit";
string itemName = baseName;
int i = 0;
while (sourceBlock.Parent.DefinedLabelNames.Contains(itemName))
{
i++;
itemName = string.Format("{0}_{1}", baseName, i);
}
sourceBlock.Parent.DefinedLabelNames.Add(itemName);
return(itemName);
}
else
{
return("__exit");
}
}
public AssignStatement(IStatementBlock sourceBlock, IAssignStatementTarget reference, IExpression value)
: base(sourceBlock)
{
this.reference = reference;
this.value = value;
}
internal SwitchStatementCases(IStatementBlock sourceBlock)
{
this.sourceBlock = sourceBlock;
}
protected Statement(IStatementBlock sourceBlock)
{
this.sourceBlock = sourceBlock;
}
public SwitchStatement(IStatementBlock sourceBlock)
: base(sourceBlock)
{
}
public BlockStatement(IStatementBlock sourceBlock)
: base(sourceBlock)
{
}
/// <summary>
/// Creates a new <see cref="CommentStatement"/> with the <paramref name="comment"/>
/// provided.
/// </summary>
/// <param name="comment">The comment represented by the <see cref="CommentStatement"/>.</param>
public CommentStatement(string comment, IStatementBlock sourceBlock)
: base(sourceBlock)
{
this.comment = comment;
}
//
/// <summary>
/// Returns a <see cref="String"/> that represents the current <see cref="Declaration{TParent, TDom}"/>.
/// </summary>
/// <returns>A <see cref="String"/> that represents the current <see cref="Declaration{TParent, TDom}"/>.</returns>
public override string ToString()
{
if (this is IType)
{
return(((IType)this).GetTypeName(CodeGeneratorHelper.DefaultDomOptions));
}
List <string> members = new List <string>();
List <string> types = new List <string>();
List <string> nameSpaces = new List <string>();
IDeclaration current = this;
while (current != null)
{
if (current is INameSpaceDeclaration)
{
nameSpaces.Add(current.GetUniqueIdentifier());
}
else if (current is IType)
{
types.Add(current.GetUniqueIdentifier());
}
else if (current is IDeclaration)
{
members.Add(current.GetUniqueIdentifier());
}
if (current.ParentTarget is IIntermediateProject)
{
break;
}
if (current.ParentTarget is IStatementBlock)
{
IStatementBlock statementBlock = ((IStatementBlock)current.ParentTarget);
if (statementBlock.Parent is IDeclaration)
{
current = (IDeclaration)statementBlock.Parent;
continue;
}
IBlockedStatement parent = (IBlockedStatement)statementBlock.Parent;
while (parent is IBlockedStatement)
{
if (parent.SourceBlock is IStatementBlock)
{
IStatementBlock currentBlock = ((IStatementBlock)parent.SourceBlock);
if (currentBlock.Parent is IBlockedStatement)
{
parent = (IBlockedStatement)((IStatementBlock)parent.SourceBlock).Parent;
}
else if (currentBlock.Parent is IDeclaration)
{
current = (IDeclaration)currentBlock.Parent;
break;
}
else if (currentBlock.Parent is IPropertyBodyMember)
{
current = ((IPropertyBodyMember)currentBlock.Parent).ParentTarget;
break;
}
}
}
continue;
}
current = (IDeclaration)current.ParentTarget;
}
members.Reverse();
types.Reverse();
nameSpaces.Reverse();
if (members.Count > 0)
{
return(String.Format("{0}.{1}::{2}", String.Join(".", nameSpaces.ToArray()), String.Join("+", types.ToArray()), string.Join("]]", members.ToArray())));
}
else if (types.Count > 0)
{
return(String.Format("{0}.{1}", String.Join(".", nameSpaces.ToArray()), String.Join("+", types.ToArray())));
}
else
{
return(String.Format("{0}", String.Join(".", nameSpaces.ToArray())));
}
}
public ReturnStatement(IStatementBlock sourceBlock)
: base(sourceBlock)
{
}
public ReturnStatement(IExpression result, IStatementBlock sourceBlock)
: base(sourceBlock)
{
this.result = result;
}
public BreakableBlockedStatement(IStatementBlock sourceBlock)
: base(sourceBlock)
{
}
