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); }