private static Expression BuildLiteralExpression(BoundLiteralExpression expression)
{
return
(BuildLiftedExpression(
Expression.Constant(expression.Value, expression.Type)
));
}
protected override BoundExpression RewriteBinaryExpression(BoundBinaryExpression node)
{
if (!(node.Constant is null))
{
return(node);
}
if (node.Op == BoundBinaryOperator.LogicalAnd)
{
return(RewriteLogicalAnd(node));
}
if (node.Op == BoundBinaryOperator.LogicalOr)
{
return(RewriteLogicalOr(node));
}
var left = RewriteExpression(node.Left);
var right = RewriteExpression(node.Right);
var leftType = left.ResultType;
var rightType = right.ResultType;
var oneLiteral = (BoundLiteralExpression?)null;
if (node.Op == BoundBinaryOperator.Root)
{
oneLiteral = new BoundLiteralExpression(1.0d, TypeSymbol.Float, true);
}
switch (node.Op, leftType.Name, rightType.Name)
{
private object EvaluateLiteralExpression(BoundLiteralExpression n)
{
// HACK
if (n.Type == BuiltinTypes.String)
{
return(((string)n.Value).Replace("\"", ""));
}
return(n.Value);
}
protected override object EvaluateExpression(BoundExpression node)
{
try
{
BoundLiteralExpression boundLiteralExpression = (BoundLiteralExpression)node;
return(EvaluateLiteralExpression(boundLiteralExpression));
}
catch
{
try
{
BoundVariableExpression boundVariableExpression = (BoundVariableExpression)node;
return(EvaluateVariableExpression(boundVariableExpression));
}
catch
{
try
{
BoundAssignmentExpression boundAssignmentExpression = (BoundAssignmentExpression)node;
return(EvaluateAssignmentExpression(boundAssignmentExpression));
}
catch
{
try
{
BoundUnaryExpression boundUnaryExpression = (BoundUnaryExpression)node;
return(EvaluateUnaryExpression(boundUnaryExpression));
}
catch
{
try
{
BoundBinaryExpression boundBinaryExpression = (BoundBinaryExpression)node;
return(EvaluateBinaryExpression(boundBinaryExpression));
}
catch
{
return(null);
}
}
}
}
}
}
public override void VisitLiteralExpression(BoundLiteralExpression node)
{
var value = node.Value.ToString() ?? "";
if (node.Type == Type.Bool)
{
_writer.WriteKeyword(value);
}
else if (node.Type == Type.Int)
{
_writer.WriteNumber(value);
}
else if (node.Type == Type.String)
{
_writer.WriteString("\"" + value.Replace("\"", "\"\"") + "\"");
}
else
{
throw new Exception($"Unexpected kind for literal expression: {node.Kind}");
}
}
private void EmitLiteralExpression(ILProcessor ilProcessor, BoundLiteralExpression node)
{
if (node.Type == TypeSymbol.Bool)
{
var value = (bool)node.Value;
var instruction = value ? OpCodes.Ldc_I4_1 : OpCodes.Ldc_I4_0;
ilProcessor.Emit(instruction);
}
else if (node.Type == TypeSymbol.Int)
{
var value = (int)node.Value;
ilProcessor.Emit(OpCodes.Ldc_I4, value);
}
else if (node.Type == TypeSymbol.String)
{
var value = (string)node.Value;
ilProcessor.Emit(OpCodes.Ldstr, value);
}
else
{
throw new Exception($"Unexpected literal type: {node.Type}");
}
}
private static object EvaluateLiteralExpression(BoundLiteralExpression boundLiteralExpression)
{
return(boundLiteralExpression.Value);
}
protected override BoundStatement RewriteForStatement(BoundForStatement node)
{
// for <var> = <lower> to <upper> by <incriment>
// <body>
//
// ---->
//
// {
// var <var> = <lower>
// while (<var> <= <upper>)
// {
// <body>
// continue:
// <var> = <var> + 1
// }
// }
var variableDeclaration = new BoundVeriableDeclaration(node.Variable, node.LowerBound);
var variableExpression = new BoundVariableExpression(node.Variable);
var upperBoundSybmle = new LocalVariableSymbol("upperBound", true, TypeSymbol.Int);
var upperBoundDeclaration = new BoundVeriableDeclaration(upperBoundSybmle, node.UpperBound);
var condition = new BoundBinaryExpression(
variableExpression,
BoundBinaryOperator.Bind(SyntaxKind.LessOrEqualToken, TypeSymbol.Int, TypeSymbol.Int),
new BoundVariableExpression(upperBoundSybmle)
);
var Ittertator = node.Itterator;
var Operator = SyntaxKind.PlusToken;
if (Ittertator == null)
{
Ittertator = new BoundLiteralExpression(1);
}
var continueLabelStatement = new BoundLabelStatement(node.ContinueLabel);
var increment = new BoundExpressionStatemnet(
new BoundAssignmentExpression(
node.Variable,
new BoundBinaryExpression(
variableExpression,
BoundBinaryOperator.Bind(Operator, TypeSymbol.Int, TypeSymbol.Int),
Ittertator
)
)
);
var whileBody = new BoundBlockStatemnet(ImmutableArray.Create <BoundStatement>(
node.Body,
continueLabelStatement,
increment)
);
var whileStatement = new BoundWhileStatement(condition, whileBody, node.BodyLabel, node.BreakLabel, GenerateLabel());
var result = new BoundBlockStatemnet(ImmutableArray.Create <BoundStatement>(
variableDeclaration,
upperBoundDeclaration,
whileStatement));
return(RewriteStatement(result));
}
private object EvaluateLiteralExpression(BoundLiteralExpression n)
{
return(n.Value);
}
/// <inheritdoc/>
protected override BoundStatement RewriteForEllipsisStatement(BoundForEllipsisStatement node)
{
// for <var> := <lower> ... <upper>
// <body>
//
// ---->
//
// {
// var <var> = <lower>
// const upperBound = <upper>
// var step = 1
// if <var> greaterthan upperBound {
// step = -1
// }
// goto start
// body:
// <body>
// continue:
// <var> = <var> + step
// start:
// gotoTrue ((step > 0 && lower < upper) || (step < 0 && lower > upper)) body
// break:
// }
var variableDeclaration = new BoundVariableDeclaration(node.Variable, node.LowerBound);
var upperBoundSymbol = new LocalVariableSymbol("upperBound", isReadOnly: true, type: TypeSymbol.Int);
var upperBoundDeclaration = new BoundVariableDeclaration(upperBoundSymbol, node.UpperBound);
var stepBoundSymbol = new LocalVariableSymbol("step", isReadOnly: false, type: TypeSymbol.Int);
var stepBoundDeclaration = new BoundVariableDeclaration(
variable: stepBoundSymbol,
initializer: new BoundLiteralExpression(1));
var variableExpression = new BoundVariableExpression(node.Variable);
var upperBoundExpression = new BoundVariableExpression(upperBoundSymbol);
var stepBoundExpression = new BoundVariableExpression(stepBoundSymbol);
var ifLowerIsGreaterThanUpperExpression = new BoundBinaryExpression(
left: variableExpression,
op: BoundBinaryOperator.Bind(SyntaxKind.GreaterToken, TypeSymbol.Int, TypeSymbol.Int),
right: upperBoundExpression);
var stepBoundAssingment = new BoundExpressionStatement(
expression: new BoundAssignmentExpression(
variable: stepBoundSymbol,
expression: new BoundLiteralExpression(-1)));
var ifLowerIsGreaterThanUpperIfStatement = new BoundIfStatement(
condition: ifLowerIsGreaterThanUpperExpression,
thenStatement: stepBoundAssingment,
elseStatement: null);
var startLabel = GenerateLabel();
var gotoStart = new BoundGotoStatement(startLabel);
var bodyLabel = GenerateLabel();
var bodyLabelStatement = new BoundLabelStatement(bodyLabel);
var continueLabelStatement = new BoundLabelStatement(node.ContinueLabel);
var increment = new BoundExpressionStatement(
expression: new BoundAssignmentExpression(
variable: node.Variable,
expression: new BoundBinaryExpression(
left: variableExpression,
op: BoundBinaryOperator.Bind(SyntaxKind.PlusToken, TypeSymbol.Int, TypeSymbol.Int),
right: stepBoundExpression)));
var startLabelStatement = new BoundLabelStatement(startLabel);
var zeroLiteralExpression = new BoundLiteralExpression(0);
var stepGreaterThanZeroExpression = new BoundBinaryExpression(
left: stepBoundExpression,
op: BoundBinaryOperator.Bind(SyntaxKind.GreaterToken, TypeSymbol.Int, TypeSymbol.Int),
right: zeroLiteralExpression);
var lowerLessThanUpperExpression = new BoundBinaryExpression(
left: variableExpression,
op: BoundBinaryOperator.Bind(SyntaxKind.LessToken, TypeSymbol.Int, TypeSymbol.Int),
right: upperBoundExpression);
var positiveStepAndLowerLessThanUpper = new BoundBinaryExpression(
left: stepGreaterThanZeroExpression,
op: BoundBinaryOperator.Bind(SyntaxKind.AmpersandAmpersandToken, TypeSymbol.Bool, TypeSymbol.Bool),
right: lowerLessThanUpperExpression);
var stepLessThanZeroExpression = new BoundBinaryExpression(
left: stepBoundExpression,
op: BoundBinaryOperator.Bind(SyntaxKind.LessToken, TypeSymbol.Int, TypeSymbol.Int),
right: zeroLiteralExpression);
var lowerGreaterThanUpperExpression = new BoundBinaryExpression(
left: variableExpression,
op: BoundBinaryOperator.Bind(SyntaxKind.GreaterToken, TypeSymbol.Int, TypeSymbol.Int),
right: upperBoundExpression);
var negativeStepAndLowerGreaterThanUpper = new BoundBinaryExpression(
left: stepLessThanZeroExpression,
op: BoundBinaryOperator.Bind(SyntaxKind.AmpersandAmpersandToken, TypeSymbol.Bool, TypeSymbol.Bool),
right: lowerGreaterThanUpperExpression);
var condition = new BoundBinaryExpression(
positiveStepAndLowerLessThanUpper,
BoundBinaryOperator.Bind(SyntaxKind.PipePipeToken, TypeSymbol.Bool, TypeSymbol.Bool),
negativeStepAndLowerGreaterThanUpper);
var gotoTrue = new BoundConditionalGotoStatement(bodyLabel, condition, jumpIfTrue: true);
var breakLabelStatement = new BoundLabelStatement(node.BreakLabel);
var result = new BoundBlockStatement(ImmutableArray.Create <BoundStatement>(
variableDeclaration,
upperBoundDeclaration,
stepBoundDeclaration,
ifLowerIsGreaterThanUpperIfStatement,
gotoStart,
bodyLabelStatement,
node.Body,
continueLabelStatement,
increment,
startLabelStatement,
gotoTrue,
breakLabelStatement));
return(RewriteStatement(result));
}
private static void WriteBoundLiteralExpression(this IndentedTextWriter writer, BoundLiteralExpression node)
{
switch (node.Value)
{
case int i:
case float f:
writer.WriteNumber(node.Value); break;
case bool b:
writer.WriteBlueKeyword(b.ToString().ToLower()); break;
case string s:
writer.WriteStringWithoutEscapeSequences(s);
break;
}
}
protected virtual void VisitLiteralExpression(BoundLiteralExpression node)
{
}
public virtual void VisitLiteralExpression(BoundLiteralExpression node) => this.DefaultVisit(node);
private static object EvaluateLiteralExpression(BoundLiteralExpression literal)
{
return(literal.Value);
}
private object Evaluate(BoundLiteralExpression literalExpression) => literalExpression.Value;
private DustObject EvaluateLiteralExpression(BoundLiteralExpression literalExpression)
{
return(literalExpression.Value);
}
