private Expression DoEval(FloatExpression lhs, FloatExpression rhs)
{
double result;
switch (Operator)
{
case "+":
result = lhs.Value + rhs.Value;
break;
case "-":
result = lhs.Value - rhs.Value;
break;
case "*":
result = lhs.Value * rhs.Value;
break;
case "/":
result = lhs.Value / rhs.Value;
break;
default:
throw new InvalidOperationException("Bad binary operator: " + Operator);
}
return(new FloatExpression(result));
}
/// <summary>
/// 处理数字
/// </summary>
/// <returns></returns>
private Expression ParseNumber()
{
Expression expression;
switch (Tokens.Current)
{
case IntegerToken integerToken:
expression = new IntegerExpression(integerToken.Position)
{
Value = integerToken.Content
};
break;
case FloatToken floatToken:
expression = new FloatExpression(floatToken.Position)
{
Value = floatToken.Content
};
break;
default:
throw new CompileException(Identifier, Tokens.Current.Position, "Expected Number (like 123, 1.23, 0x7B or 0b1111011)");
}
Tokens.MoveToNext();
return(expression);
}
private IExpression ReadConstant()
{
var token = Reader.DiscardToken();
IExpression output = null;
switch (token.TokenType)
{
case TokenType.NumberValue:
output = new NumberExpression()
{
Value = int.Parse(token.Value)
};
break;
case TokenType.StringValue:
output = new StringExpression()
{
Value = token.Value
};
break;
case TokenType.FloatValue:
output = new FloatExpression()
{
Value = float.Parse(token.Value)
};
break;
default:
throw new Exception("Unexpected token for constant!");
}
return(output);
}
private Expression DoEval(FloatExpression lhs, FloatExpression rhs)
{
double result;
switch (Operator)
{
case "+":
result = lhs.Value + rhs.Value;
break;
case "-":
result = lhs.Value - rhs.Value;
break;
case "*":
result = lhs.Value * rhs.Value;
break;
case "/":
result = lhs.Value / rhs.Value;
break;
default:
throw new InvalidOperationException("Bad binary operator: " + Operator);
}
return new FloatExpression(result);
}
private void VerifyPartialResult(MpirRandom rnd, FloatExpression expr, long expected)
{
rnd.Seed(123);
using (var r = new HugeFloat())
{
using (var exp = new HugeFloat(expected))
using (var epsilon = new HugeFloat("0.001"))
{
r.Value = expr;
Assert.IsTrue(r - epsilon <exp && r + epsilon> exp, "Expected {0}, Actual {1}", exp, r);
}
}
}
// Value := [0-9]+ '.' [0-9]+ (('e' / 'E') [0-9]+)? S
private State DoParseValue1Rule(State _state, List <Result> _outResults)
{
State _start = _state;
List <Result> results = new List <Result>();
_state = DoSequence(_state, results,
delegate(State s, List <Result> r) { return(DoRepetition(s, r, 1, 2147483647,
delegate(State s2, List <Result> r2) { return DoParseRange(s2, r2, false, string.Empty, "09", null, "[0-9]"); })); },
delegate(State s, List <Result> r) { return(DoParseLiteral(s, r, ".")); },
delegate(State s, List <Result> r) { return(DoRepetition(s, r, 1, 2147483647,
delegate(State s2, List <Result> r2) { return DoParseRange(s2, r2, false, string.Empty, "09", null, "[0-9]"); })); },
delegate(State s, List <Result> r) { return(DoRepetition(s, r, 0, 1,
delegate(State s2, List <Result> r2) { return DoSequence(s2, r2,
delegate(State s3, List <Result> r3) { return DoChoice(s3, r3,
delegate(State s4, List <Result> r4) { return DoParseLiteral(s4, r4, "e"); },
delegate(State s4, List <Result> r4) { return DoParseLiteral(s4, r4, "E"); }); },
delegate(State s3, List <Result> r3) { return DoRepetition(s3, r3, 1, 2147483647,
delegate(State s4, List <Result> r4) { return DoParseRange(s4, r4, false, string.Empty, "09", null, "[0-9]"); }); }); })); },
delegate(State s, List <Result> r) { return(DoParse(s, r, "S")); });
if (_state.Parsed)
{
Expression value = results.Count > 0 ? results[0].Value : default(Expression);
string text = m_input.Substring(_start.Index, _state.Index - _start.Index);
value = new FloatExpression(text.Trim());
if (text != null)
{
_outResults.Add(new Result(this, _start.Index, _state.Index - _start.Index, m_input, value));
}
}
else
{
string expected = null;
expected = "number";
if (expected != null)
{
_state = new State(_start.Index, false, ErrorSet.Combine(_start.Errors, new ErrorSet(_state.Errors.Index, expected)));
}
}
return(_state);
}
private void MarkExpressionsUsed(List <Type> allExpressions, FloatExpression expr)
{
var type = expr.GetType();
allExpressions.Remove(type);
var children = type.GetFields(BindingFlags.NonPublic | BindingFlags.Instance)
.Where(x => typeof(FloatExpression).IsAssignableFrom(x.FieldType))
.Select(x => (FloatExpression)x.GetValue(expr))
.Where(x => x != null)
.ToList();
foreach (var childExpr in children)
{
MarkExpressionsUsed(allExpressions, childExpr);
}
}
public override void Accept(FloatExpression num)
{
num.Visit(parentVisitor);
methodBuilder.EmitInstruction(num.Location, Opcode.LoadLocal, temporary);
methodBuilder.EmitInstruction(num.Location, Opcode.BinOp, (int)BinaryOperation.Equals);
}
public override void Accept(FloatExpression num)
{
methodBuilder.EmitInstruction(num.Location, Opcode.LoadConst,
methodBuilder.Module.DefineConstant(new IodineFloat(num.Value)));
}
public override void Accept(FloatExpression num)
{
num.Visit(functionCompiler);
}
public virtual void Accept(FloatExpression dec)
{
}
protected override string VisitFloatExpression(FloatExpression exp, out object retObject)
{
retObject = null;
return(exp.ToString());
}
protected virtual string VisitFloatExpression(FloatExpression exp, out object resultObj)
{
resultObj = null;
return(null);
}
private void MarkExpressionsUsed(List<Type> allExpressions, FloatExpression expr)
{
var type = expr.GetType();
allExpressions.Remove(type);
var children = type.GetFields(BindingFlags.NonPublic | BindingFlags.Instance)
.Where(x => typeof(FloatExpression).IsAssignableFrom(x.FieldType))
.Select(x => (FloatExpression)x.GetValue(expr))
.Where(x => x != null)
.ToList();
foreach (var childExpr in children)
MarkExpressionsUsed(allExpressions, childExpr);
}
private void VerifyPartialResult(MpirRandom rnd, FloatExpression expr, long expected)
{
rnd.Seed(123);
using (var r = new HugeFloat())
{
using (var exp = new HugeFloat(expected))
using (var epsilon = new HugeFloat("0.001"))
{
r.Value = expr;
Assert.IsTrue(r - epsilon < exp && r + epsilon > exp, "Expected {0}, Actual {1}", exp, r);
}
}
}
