private static Expression ParseSlice(Parser parser, Expression left, Token token, Expression start = null)
{
parser.Take(TokenType.Colon);
if (parser.MatchAndTake(TokenType.RightSquare))
return new SliceExpression(token, left, start, null, null);
Expression end = null;
if (!parser.Match(TokenType.Colon))
{
end = parser.ParseExpression();
if (parser.MatchAndTake(TokenType.RightSquare))
return new SliceExpression(token, left, start, end, null);
}
parser.Take(TokenType.Colon);
var step = parser.ParseExpression();
parser.Take(TokenType.RightSquare);
return new SliceExpression(token, left, start, end, step);
}
public override Expression Simplify()
{
Left = Left.Simplify();
Index = Index.Simplify();
return this;
}
public TernaryExpression(Token token, Expression condition, Expression ifTrue, Expression ifFalse)
: base(token.FileName, token.Line)
{
Condition = condition;
IfTrue = ifTrue;
IfFalse = ifFalse;
}
public BinaryOperatorExpression(Token token, Expression left, Expression right)
: base(token.FileName, token.Line)
{
Operation = token.Type;
Left = left;
Right = right;
}
public override void SetParent(Expression parent)
{
base.SetParent(parent);
Condition.SetParent(this);
IfTrue.SetParent(this);
IfFalse.SetParent(this);
}
public Expression Parse(Parser parser, Expression left, Token token)
{
var trueExpr = parser.ParseExpession();
parser.Take(TokenType.Colon);
var falseExpr = parser.ParseExpession();
return new TernaryExpression(token, left, trueExpr, falseExpr);
}
public override void SetParent(Expression parent)
{
base.SetParent(parent);
foreach (var statement in Statements)
{
statement.SetParent(this);
}
}
public override void SetParent(Expression parent)
{
base.SetParent(parent);
Method.SetParent(this);
foreach (var arg in Arguments)
{
arg.SetParent(this);
}
}
public Expression Parse(Parser parser, Expression left, Token token)
{
if (parser.Match(TokenType.Colon))
return ParseSlice(parser, left, token);
var index = parser.ParseExpression();
if (parser.Match(TokenType.Colon))
return ParseSlice(parser, left, token, index);
parser.Take(TokenType.RightSquare);
return new IndexerExpression(token, left, index);
}
public Expression Parse(Parser parser, Expression left, Token token)
{
var args = new List<Expression>();
if (!parser.MatchAndTake(TokenType.RightParen))
{
do
{
args.Add(parser.ParseExpession());
} while (parser.MatchAndTake(TokenType.Comma));
parser.Take(TokenType.RightParen);
}
return new CallExpression(token, left, args);
}
public MondProgram Compile(Expression expression)
{
PushFrame();
var context = MakeFunction(null);
context.Function(expression.FileName, "#main");
context.Enter();
expression.Compile(context);
context.LoadUndefined();
context.Return();
PopFrame();
var length = PatchLabels();
var bytecode = GenerateBytecode(length);
var debugInfo = GenerateDebugInfo();
return new MondProgram(bytecode, NumberPool.Items, StringPool.Items, debugInfo);
}
public override void SetParent(Expression parent)
{
base.SetParent(parent);
Left.SetParent(this);
Right.SetParent(this);
}
public Expression Parse(Parser parser, Expression left, Token token)
{
var identifier = parser.Take(TokenType.Identifier);
return new FieldExpression(identifier, left);
}
public override Expression Simplify()
{
Method = Method.Simplify();
Arguments = Arguments
.Select(a => a.Simplify())
.ToList()
.AsReadOnly();
return this;
}
public IndexerExpression(Token token, Expression left, Expression index)
: base(token.FileName, token.Line)
{
Left = left;
Index = index;
}
public CallExpression(Token token, Expression method, List<Expression> arguments)
: base(token.FileName, token.Line)
{
Method = method;
Arguments = arguments.AsReadOnly();
}
internal MondCompilerException(Expression expression, string format, params object[] args)
: this(expression.Token.FileName, expression.Token.Line, expression.Token.Column, format, args)
{
}
public Expression Parse(Parser parser, Expression left, Token token)
{
return new PostfixOperatorExpression(token, left);
}
public PrefixOperatorExpression(Token token, Expression right)
: base(token.FileName, token.Line)
{
Operation = token.Type;
Right = right;
}
public override Expression Simplify()
{
Right = Right.Simplify();
if (Operation == TokenType.Subtract)
{
var number = Right as NumberExpression;
if (number != null)
{
var token = new Token(Right.FileName, Right.Line, TokenType.Number, null);
Right = new NumberExpression(token, -number.Value);
}
}
return this;
}
public Expression Parse(Parser parser, Expression left, Token token)
{
var index = parser.ParseExpession();
parser.Take(TokenType.RightSquare);
return new IndexerExpression(token, left, index);
}
public Expression Parse(Parser parser, Expression left, Token token)
{
var right = parser.ParseExpression(Precedence);
return new PipelineExpression(token, left, right);
}
public override Expression Simplify()
{
Condition = Condition.Simplify();
IfTrue = IfTrue.Simplify();
IfFalse = IfFalse.Simplify();
return this;
}
public override Expression Simplify()
{
Left = Left.Simplify();
Right = Right.Simplify();
Func<double, double, double> simplifyOp;
if (_simplifyMap.TryGetValue(Operation, out simplifyOp))
{
var leftNum = Left as NumberExpression;
var rigthNum = Right as NumberExpression;
if (leftNum != null && rigthNum != null)
{
var result = simplifyOp(leftNum.Value, rigthNum.Value);
var token = new Token(FileName, Line, TokenType.Number, null);
return new NumberExpression(token, result);
}
}
return this;
}
public FieldExpression(Token token, Expression left)
: base(token.FileName, token.Line)
{
Left = left;
Name = token.Contents;
}
public PostfixOperatorExpression(Token token, Expression left)
: base(token.FileName, token.Line)
{
Operation = token.Type;
Left = left;
}
public Expression Parse(Parser parser, Expression left, Token token)
{
var right = parser.ParseExpession(Precedence - (_isRight ? 1 : 0));
return new BinaryOperatorExpression(token, left, right);
}
