public void Eval(LaxExpression s) { switch (s.Type) { case ExprType.Assignment: EvalAssignmentOperator((Assignment)s); return; case ExprType.BinaryOp: EvalBinaryOperator((BinaryOp)s); return; case ExprType.Identifier: //Get type from block var def = block.Variables[(Identifier)s]; s.ValueType = def.ValueType; return; case ExprType.Literal: return; case ExprType.FunctionCall: #warning TODO custom implementation per function. var f = (FunctionCall)s; foreach (var a in f.Arguments) Eval(a); s.ValueType = f.Arguments[0].ValueType; Debug.Assert(s.ValueType != null); return; default: throw new NotImplementedException(); } }
public ConstDefinition(CodeRange start, Identifier id, LaxExpression value) : base(start, id) { if (value == null) throw new ArgumentNullException("value"); this.Value = value; }
/// <summary> /// return a new <seealso cref="Assignment"/> with Left and Right assigned. /// </summary> /// <param name="left"></param> /// <param name="right"></param> /// <returns></returns> public Assignment WithOperands(LaxExpression left, LaxExpression right) { var op = new Assignment(this); op.Left = left; op.Right = right; op.CodeRange = CodeRange.Expand2(left).Expand2(right); return op; }
/// <summary> /// return a new <seealso cref="Assignment"/> with Left and Right assigned. /// </summary> /// <param name="left"></param> /// <param name="right"></param> /// <returns></returns> public BinaryOp WithOperands(LaxExpression left, LaxExpression right) { var op = new BinaryOp(CodeRange, Operator); op.Left = left; op.Right = right; op.CodeRange = CodeRange.Expand2(left).Expand2(right); return op; }
public Literal Evaluate(LaxExpression expr) { if (expr == null) return null; switch (expr.Type) { case ExprType.Assignment: return EvaluateAssignment((Assignment)expr); case ExprType.Literal: return (Literal)expr; case ExprType.Identifier: return EvaluateVariable((Identifier)expr); case ExprType.BinaryOp: return EvaluateBinaryOp((BinaryOp)expr); case ExprType.FunctionCall: return EvaluateFunctionCall((FunctionCall)expr); default: throw new NotImplementedException(); } }
static LaxExpression Evaluate(LaxExpression s) { switch (s.Type) { case ExprType.Identifier: case ExprType.Literal: return s; //Nothing to evaluate further case ExprType.Assignment: return EvaluateAssignment((Assignment)s); case ExprType.BinaryOp: return EvaluateOp((BinaryOp)s); case ExprType.FunctionCall: return EvaluateFunctionCall((FunctionCall)s); default: throw new NotImplementedException(); } }
public static string Format(LaxExpression expr) { var format = new CodeFormat(false); return format.FormatExpression(expr); }
/// <summary> /// Return source code representation of an expression. /// </summary> public string FormatExpression(LaxExpression expr) { if (expr == null) throw new ArgumentNullException("expr"); switch (expr.Type) { case ExprType.Assignment: return FormatAssignment((Assignment)expr); case ExprType.BinaryOp: return FormatBinaryOp((BinaryOp)expr); case ExprType.Identifier: return FormatIdentifier((Identifier)expr); case ExprType.Literal: return FormatValue((Literal)expr); case ExprType.FunctionCall: return FormatFunctionCall((FunctionCall)expr); } throw new NotImplementedException(expr.GetType().Name); }
public SemanticError(LaxExpression expr, string message) : base(expr.CodeRange, message) { }
/// <summary> /// Allow implicit multuplication /// </summary> /// <param name="exp"></param> void PushImplicitMultiplication(LaxExpression exp) { if (opStack.Count == operandStack.Count) { //Operand operandStack.Push(exp); } else { //Allow expression without "*" such as: 45 apples PushOperator(BinaryOp.UnitOp(exp.CodeRange)); //Add type to literal var l = (Literal)exp; PushLiteral(l); } }