public override TranslationResult Translate(TranslationContext context)
{
var expr = this.Expression.Translate(context.ChangePurityContext(PurityContext.Purifiable));
var errors = new List <Error>();
errors.AddRange(expr.Errors);
if (context.IsFunctionOrPredicateBlock)
{
return(TranslationResult.FromSilvernode(expr.Silvernode, errors));
}
StatementsSequenceSilvernode statements = new StatementsSequenceSilvernode(this.OriginalNode);
statements.List.AddRange(expr.PrependTheseSilvernodes);
statements.List.Add(
new AssignmentSilvernode(
new TextSilvernode(Constants.SilverReturnVariableName, this.OriginalNode),
expr.Silvernode, this.OriginalNode
));
statements.List.Add(
new GotoSilvernode(Constants.SilverMethodEndLabel, this.OriginalNode)
);
return(TranslationResult.FromSilvernode(statements, errors));
}
public override TranslationResult Translate(TranslationContext context)
{
var left = this.Left.Translate(new TranslationContext(context)
{
LValueNeeded = true
});
var right = this.Right.Translate(context.ChangePurityContext(PurityContext.Purifiable));
List <Error> errors = CommonUtils.CombineErrors(left, right).ToList();
StatementsSequenceSilvernode sequence;
if (left.ArraysContainer != null)
{
errors.AddRange(left.ArraysContainer.Errors);
errors.AddRange(left.ArraysIndex.Errors);
var arrayWrite = context.Process.ArraysTranslator.ArrayWrite(this.OriginalNode, left.ArraysContainer.Silvernode,
left.ArraysIndex.Silvernode, right.Silvernode);
sequence = new StatementsSequenceSilvernode(null,
right.PrependTheseSilvernodes.Concat(new[] { arrayWrite }).ToArray());
}
else
{
var assignment = new AssignmentSilvernode(left.Silvernode, right.Silvernode, this.OriginalNode);
sequence = new StatementsSequenceSilvernode(null,
right.PrependTheseSilvernodes.Concat(new[] { assignment }).ToArray());
}
return(TranslationResult.FromSilvernode(sequence, errors));
}
public override TranslationResult Translate(TranslationContext context)
{
var symbol = context.Semantics.GetDeclaredSymbol(this.Self);
var identifier = context.Process.IdentifierTranslator.RegisterAndGetIdentifier(symbol);
var statementResult = this.Statement.Translate(context);
StatementsSequenceSilvernode seq = new StatementsSequenceSilvernode(this.OriginalNode,
new LabelSilvernode(identifier, this.OriginalNode),
(StatementSilvernode)statementResult.Silvernode
);
return(TranslationResult.FromSilvernode(seq, statementResult.Errors));
}
public override TranslationResult Translate(TranslationContext context)
{
List <StatementSilvernode> statements = new List <StatementSilvernode>();
List <Error> diagnostics = new List <Error>();
foreach (var declaration in this.Declarations)
{
var statementResult = declaration.Translate(context);
if (statementResult.Silvernode != null)
{
statements.Add(statementResult.Silvernode as StatementSilvernode);
}
diagnostics.AddRange(statementResult.Errors);
}
StatementsSequenceSilvernode statementsSequence = new StatementsSequenceSilvernode(this.OriginalNode, statements.ToArray());
return(TranslationResult.FromSilvernode(statementsSequence, diagnostics));
}
public override TranslationResult Translate(TranslationContext context)
{
var exResult = this.Expression.Translate(context);
if (exResult.Silvernode.IsContract())
{
return(exResult);
}
else if (exResult.Silvernode is CallSilvernode)
{
// It is a method call -- and the result is ignored.
CallSilvernode call = (CallSilvernode)(exResult.Silvernode);
if (call.Type != SilverType.Void)
{
var tempVar = context.Process.IdentifierTranslator.RegisterNewUniqueIdentifier();
var sequence = new StatementsSequenceSilvernode(this.OriginalNode,
new VarStatementSilvernode(tempVar, call.Type, null),
new AssignmentSilvernode(
new IdentifierSilvernode(tempVar),
call, null)
);
return(TranslationResult.FromSilvernode(sequence, exResult.Errors));
}
else
{
return(TranslationResult.FromSilvernode(call, exResult.Errors));
}
}
else if (exResult.Silvernode is BinaryExpressionSilvernode)
{
return(exResult);
}
else if (exResult.Silvernode is AssignmentSilvernode)
{
return(exResult);
}
else if (exResult.Silvernode is StatementSilvernode)
{
return(exResult);
}
return(TranslationResult.Error(this.Expression.OriginalNode, Diagnostics.SSIL107_ThisExpressionCannotBeStatement));
}
public override TranslationResult Translate(TranslationContext context)
{
// Translate parts
var conditionResult = this.Condition.Translate(context.ChangePurityContext(PurityContext.Purifiable));
var statementResult = this.Statement.Translate(context);
var statementBlock = ((StatementSilvernode)statementResult.Silvernode).EncloseInBlockIfNotAlready();
// Put them together
var errors = new List <Error>();
errors.AddRange(conditionResult.Errors);
foreach (var incrementor in this.Incrementors)
{
var incrementorResult = incrementor.Translate(context);
statementBlock.Add(incrementorResult.Silvernode as StatementSilvernode);
errors.AddRange(incrementorResult.Errors);
}
errors.AddRange(statementResult.Errors);
statementBlock.Statements.AddRange(conditionResult.PrependTheseSilvernodes);
WhileSilvernode whileNode =
new WhileSilvernode(
conditionResult.Silvernode,
statementResult.Contracts,
statementBlock, this.OriginalNode
);
var sequence = new StatementsSequenceSilvernode(this.OriginalNode);
foreach (var initializer in this.Initializers)
{
var initializerResult = initializer.Translate(context);
errors.AddRange(initializerResult.Errors);
sequence.List.Add(initializerResult.Silvernode as StatementSilvernode);
}
sequence.List.AddRange(conditionResult.PrependTheseSilvernodes);
sequence.List.Add(whileNode);
return(TranslationResult.FromSilvernode(sequence, errors));
}
