public BaseOperation(
string name,
IEmittable.Emitter emitter,
OperationTypeDescriptor descriptor,
IBaseExpression[] args,
Delegate evaluator = null
)
{
this.evaluator = evaluator;
if (args.Length != descriptor.ArgTypes.Length)
{
throw new ArgumentsNumberMismatchException(
name,
descriptor.ArgTypes.Length, args.Length
);
}
if (args != null)
{
int i = 0;
Array.ForEach(args,
arg => IBaseExpression.CheckTypes(
name, "operation argument #" + i,
descriptor.ArgTypes[i], arg.GetResultType()
)
);
}
this.name = name;
this.descriptor = descriptor;
this.emitter = emitter;
this.args = args;
}
public ReturnStatement(IBaseExpression expr)
{
IBaseExpression.CheckTypes(
"return statement", "",
typeof(long), expr.GetResultType()
);
this.expr = expr;
}
public VarAssignStatement(Variable lhs, IBaseExpression rhs)
{
IBaseExpression.CheckTypes(
"assignment to " + lhs.ToString(), "",
typeof(long), rhs.GetResultType()
);
this.lhs = lhs;
this.rhs = rhs;
}
public ReturnStatement Parse()
{
PeekToken();
if (!Test(Token.Type.Return, ReturnState.PreExpr))
{
return(null);
}
Expect(Token.Type.Expression, ReturnState.PostExpr);
IBaseExpression expr = lastToken.GetData <IBaseExpression>();
Expect(Token.Type.Semicolon, ReturnState.End);
return(new ReturnStatement(expr));
}
public IfStatement(
IBaseExpression condition,
IBaseStatement ifBranch,
IBaseStatement elseBranch = null
)
{
IBaseExpression.CheckTypes(
"if condition", "",
typeof(bool), condition.GetResultType()
);
this.condition = condition;
precalc = (bool?)condition.Evaluate();
this.ifBranch = ifBranch;
this.elseBranch = elseBranch;
}
public VarAssignStatement Parse()
{
PeekToken();
if (!Test(Token.Type.Name, VarAssignState.PreAssign))
{
return(null);
}
string name = lastToken.str;
if (!Test(Token.Type.Assign, VarAssignState.PostAssign))
{
return(null);
}
Variable var = GetVar(name);
Expect(Token.Type.Expression, VarAssignState.PostExpr);
IBaseExpression expr = lastToken.GetData <IBaseExpression>();
Expect(Token.Type.Semicolon, VarAssignState.End);
return(new VarAssignStatement(var, expr));
}
public BaseExpressionCompiler(IBaseExpression baseExpression, AbstractILCompilerParams @params) : base(@params)
{
myBaseExpression = baseExpression;
}
public ExpressionStatement(IBaseExpression expr) => this.expr = expr;
private IBaseExpression ParseSubexpression(int lastPriority)
{
IBaseExpression left = null;
if (Test(Token.Type.LeftPar, State.Pre))
{
left = ParseSubexpression(int.MaxValue);
Expect(Token.Type.RightPar, State.Post);
}
else if (Test(Token.Type.Name, State.Pre))
{
string name = lastToken.str;
// try read left_par
if (Test(Token.Type.LeftPar, State.Post))
{
// success - function call
List <IBaseExpression> args = new List <IBaseExpression>();
// try read right_par right now
if (!Test(Token.Type.RightPar, State.Post))
{
// some arguments, read them
RePeekToken(State.Pre);
while (true)
{
args.Add(ParseSubexpression(int.MaxValue));
if (Test(Token.Type.RightPar, State.Post))
{
break;
}
Expect(Token.Type.Comma, State.Pre);
}
}
left = GetFunc(name)(args.ToArray());
}
else
{
// otherwise - variable name
RePeekToken(State.Post);
left = GetVar(lastToken.str);
}
}
else if (Test(Token.Type.UnaryOperator, State.Pre))
{
var(factory, oper) =
lastToken.GetData <
KeyValuePair <UnaryOperation.Factory, UnaryOperation.Type>
>();
left = factory(ParseSubexpression(oper.GetPriority()));
}
else
{
Expect(Token.Type.Number, State.Post);
if (lastToken.IsOfType(typeof(long)))
{
left = new Const(lastToken.GetData <long>());
}
else
{
left = new Const(lastToken.GetData <bool>());
}
}
while (true)
{
if (!TestNoShift(Token.Type.BinaryOperator))
{
break;
}
var(factory, oper) =
token.GetData <KeyValuePair <BinaryOperation.Factory, BinaryOperation.Type> >();
if (oper.GetPriority() >= lastPriority)
{
break;
}
PeekToken(State.Pre);
left = factory(left, ParseSubexpression(oper.GetPriority()));
}
return(left);
}
