public override LuryObject Evaluate(LuryContext context) { return context[this.reference]; }
public LuryContext(LuryContext parent) { this.parent = parent; }
public override void Assign(LuryObject value, LuryContext context) { this.lvalue.Assign(value, context); }
public override LuryObject Evaluate(LuryContext context) { if (!(this.target is LValueNode)) throw new LuryException(LuryExceptionType.WrongLValue); var lvalue = (LValueNode)this.target; var dr_value = lvalue.Evaluate(context); switch (this.operation) { case UnaryAssignOperator.IncrementPostfix: lvalue.Assign(dr_value.Inc(), context); return dr_value; case UnaryAssignOperator.DecrementPostfix: lvalue.Assign(dr_value.Dec(), context); return dr_value; case UnaryAssignOperator.IncrementPrefix: dr_value = dr_value.Inc(); lvalue.Assign(dr_value, context); return dr_value; case UnaryAssignOperator.DecrementPrefix: dr_value = dr_value.Dec(); lvalue.Assign(dr_value, context); return dr_value; default: throw new InvalidOperationException(); } }
public override StatementExit Evaluate(LuryContext context) { StatementExit exit; var newContext = new LuryContext(context); while (true) { var cond = this.condition.Evaluate(newContext); if (cond == null) throw new LuryException(LuryExceptionType.NilReference); if (!(cond is LuryBoolean)) throw new LuryException(LuryExceptionType.ConditionValueIsNotBoolean); if (cond == LuryBoolean.True) { exit = this.suite.Evaluate(newContext); if (exit.ExitReason == StatementExitReason.Break) break; else if (exit.ExitReason == StatementExitReason.Continue || exit.ExitReason == StatementExitReason.NormalExit) continue; else return exit; } else { if (this.elseSuite != null) return this.elseSuite.Evaluate(new LuryContext(context)); break; } } return StatementExit.NormalExit; }
public StatementExit Evaluate(LuryContext context) { var ret = StatementExit.NormalExit; foreach (var statement in this.statements) { ret = statement.Evaluate(context); if (ret.ExitReason != StatementExitReason.NormalExit) break; } return ret; }
public override LuryObject Evaluate(LuryContext context) { if (!(this.lvalue is LValueNode)) throw new LuryException(LuryExceptionType.WrongLValue); var dst = (LValueNode)lvalue; var value = this.rvalue.Evaluate(context); if (this.operation == BinaryAssignOperator.Assign) { dst.Assign(value, context); return value; } var dstValue = dst.Evaluate(context); switch (this.operation) { case BinaryAssignOperator.Power: value = dstValue.Pow(value); break; case BinaryAssignOperator.Multiplication: value = dstValue.Mul(value); break; case BinaryAssignOperator.Division: value = dstValue.Div(value); break; case BinaryAssignOperator.IntDivision: value = dstValue.IDiv(value); break; case BinaryAssignOperator.Modulo: value = dstValue.Mod(value); break; case BinaryAssignOperator.Addition: value = dstValue.Add(value); break; case BinaryAssignOperator.Subtraction: value = dstValue.Sub(value); break; case BinaryAssignOperator.Concatenation: value = dstValue.Con(value); break; case BinaryAssignOperator.LeftShift: value = dstValue.Shl(value); break; case BinaryAssignOperator.RightShift: value = dstValue.Shr(value); break; case BinaryAssignOperator.ArithmeticAnd: value = dstValue.BAnd(value); break; case BinaryAssignOperator.ArithmeticXor: value = dstValue.BXor(value); break; case BinaryAssignOperator.ArithmeticOr: value = dstValue.BOr(value); break; default: throw new InvalidOperationException(); } dst.Assign(value, context); return value; }
public override LuryObject Evaluate(LuryContext context) { var parentObj = this.parent.Evaluate(context); if (parentObj == null) throw new LuryException(LuryExceptionType.NilReference); return parentObj[this.child]; }
public override StatementExit Evaluate(LuryContext context) { this.expression.Evaluate(context); return StatementExit.NormalExit; }
public override StatementExit Evaluate(LuryContext context) { return new StatementExit(null, StatementExitReason.Continue); }
public override void Assign(LuryObject value, LuryContext context) { var parentObj = this.parent.Evaluate(context); if (parentObj == null) throw new LuryException(LuryExceptionType.NilReference); if (parentObj.Has(this.child)) parentObj[this.child] = value; else throw new LuryException(LuryExceptionType.AttributeIsNotFound); }
public override LuryObject Evaluate(LuryContext context) { return this.constant; }
public override LuryObject Evaluate(LuryContext context) { var objects = this.param.Select(p => p == null ? null : p.Evaluate(context)).ToArray(); var func = this.function.Evaluate(context); if (func == null) throw new LuryException(LuryExceptionType.NilReference); return func.Call(objects); }
public override LuryObject Evaluate(LuryContext context) { var obj = this.lvalue.Evaluate(context); if (obj == null) throw new LuryException(LuryExceptionType.NilReference); if (obj is LuryFunction) return obj.Call(); else return obj; }
public override StatementExit Evaluate(LuryContext context) { return StatementExit.NormalExit; }
public override StatementExit Evaluate(LuryContext context) { this.name.Assign(new LuryFunction(args => { var newContext = new LuryContext(context); var paramCount = (this.parameters == null ? 0 : this.parameters.Count); if (args.Length != paramCount) throw new LuryException(LuryExceptionType.NotEnoughFunctionArgumentNumber); for (int i = 0; i < args.Length; i++) newContext.SetMemberNoRecursion(this.parameters[i], args[i]); return this.Invoke(newContext); }), context); return StatementExit.NormalExit; }
public override StatementExit Evaluate(LuryContext context) { if (this.returnValue == null) return new StatementExit(null, StatementExitReason.Return); else return new StatementExit(this.returnValue.Evaluate(context), StatementExitReason.Return); }
private LuryObject Invoke(LuryContext context) { var exit = this.suite.Evaluate(context); if (exit.ExitReason == StatementExitReason.Return) return exit.ReturnValue; else if (exit.ExitReason == StatementExitReason.NormalExit) return null; else throw new LuryException(LuryExceptionType.WrongBreak); }
public virtual StatementExit Evaluate(LuryContext context) { return null; }
public override StatementExit Evaluate(LuryContext context) { if (this.condition == null) { // else block return this.suite.Evaluate(new LuryContext(context)); } else { // if block var cond = this.condition.Evaluate(new LuryContext(context)); if (cond == null) throw new LuryException(LuryExceptionType.NilReference); if (!(cond is LuryBoolean)) throw new LuryException(LuryExceptionType.ConditionValueIsNotBoolean); if (cond == LuryBoolean.True) // if suite return this.suite.Evaluate(new LuryContext(context)); else if (this.nextIf != null) // elif block return this.nextIf.Evaluate(new LuryContext(context)); } return StatementExit.NormalExit; }
public override LuryObject Evaluate(LuryContext context) { var x = this.x.Evaluate(context); if (x == null) throw new LuryException(LuryExceptionType.NilReference); switch (this.operation) { case TernaryOperator.Condition: if (!(x is LuryBoolean)) throw new LuryException(LuryExceptionType.ConditionValueIsNotBoolean); if (((LuryBoolean)x).Value) return this.y.Evaluate(context); else return this.z.Evaluate(context); default: throw new InvalidOperationException(); } }
public abstract void Assign(LuryObject value, LuryContext context);
public override LuryObject Evaluate(LuryContext context) { if (this.operation == UnaryOperator.Reference) { if (!(this.target is LValueNode)) throw new LuryException(LuryExceptionType.WrongRefReference); return this.target.Evaluate(context); } var value = this.target.Evaluate(context); if (value == null) throw new LuryException(LuryExceptionType.NilReference); switch (this.operation) { case UnaryOperator.SignNegative: return value.Neg(); case UnaryOperator.SignPositive: return value.Pos(); case UnaryOperator.BitwiseNot: return value.BNot(); case UnaryOperator.LogicalNot: return value.LNot(); default: throw new InvalidOperationException(); } }
public abstract LuryObject Evaluate(LuryContext context);
/// <summary> /// コンパイルするコードを指定してコンパイルし、実行します。 /// </summary> /// <param name="code">コンパイルされるコード文字列。</param> /// <returns>コンパイルに成功したとき true、それ以外のとき false。</returns> public LuryObject Evaluate(string code) { var lexer = new Lexer.Lexer(code + '\n'); var succeedTokenize = lexer.Tokenize(); lexer.Logger.CopyTo(this.OutputLogger); if (!succeedTokenize) return null; var globalContext = new LuryContext(); Intrinsic.SetBuiltInFunctions(globalContext); var parser = new Parser(); Routine routine = null; // parsing try { routine = (Routine)parser.yyparse(new Lex2yyInput(lexer), new yydebug.yyDebugSimple()); } catch (yyParser.yyException ex) { this.ReportyyException(ex, code); return null; } // running if (routine == null) return null; else { try { var exit = routine.Evaluate(globalContext); if (exit.ExitReason == StatementExitReason.Break) throw new LuryException(LuryExceptionType.WrongBreak); return exit.ReturnValue; } catch (LuryException ex) { Console.Error.WriteLine(ex.Message); return null; } } }
public override void Assign(LuryObject value, LuryContext context) { context[this.reference] = value; }
public LuryContext(LuryContext parent) { this.parent = parent; }
public override LuryObject Evaluate(LuryContext context) { var x = this.x.Evaluate(context); var y = this.y.Evaluate(context); if (x == null) throw new LuryException(LuryExceptionType.NilReference); switch (this.operation) { case BinaryOperator.Power: return x.Pow(y); case BinaryOperator.Multiplication: return x.Mul(y); case BinaryOperator.Division: return x.Div(y); case BinaryOperator.IntDivision: return x.IDiv(y); case BinaryOperator.Modulo: return x.Mod(y); case BinaryOperator.Addition: return x.Add(y); case BinaryOperator.Subtraction: return x.Sub(y); case BinaryOperator.Concatenation: return x.Con(y); case BinaryOperator.LeftShift: return x.Shl(y); case BinaryOperator.RightShift: return x.Shl(y); case BinaryOperator.ArithmeticAnd: return x.BAnd(y); case BinaryOperator.ArithmeticXor: return x.BXor(y); case BinaryOperator.ArithmeticOr: return x.BOr(y); case BinaryOperator.LogicalAnd: return x.LAnd(y); case BinaryOperator.LogicalOr: return x.LOr(y); case BinaryOperator.LessThan: return x.CLt(y); case BinaryOperator.GreaterThan: return x.CGt(y); case BinaryOperator.LessThanEqual: return x.CELt(y); case BinaryOperator.GreaterThanEqual: return x.CEGt(y); case BinaryOperator.Equal: return x.CEq(y); case BinaryOperator.NotEqual: return x.CNe(y); case BinaryOperator.Is: return x.Is(y); case BinaryOperator.IsNot: return x.IsNot(y); default: throw new InvalidOperationException(); } }