public void NumberParsing()
{
Assert.AreEqual(20.12m, ParsingReader.ParseNumber(" 20.12m"));
Assert.AreEqual(-20e12d, ParsingReader.ParseNumber(" -20e12d"));
Assert.AreEqual(0xf312, ParsingReader.ParseNumber("0xf312"));
Assert.IsNull(ParsingReader.TryParseNumber("0xf312Q"));
Assert.IsNull(ParsingReader.TryParseNumber(""));
}
private object stringMath(string d1, string d2)
{
int r;
if (_operator == OperatorType.EqualIgnoreCase || _operator == OperatorType.NotEqualIgnoreCase)
{
r = string.Compare(d1, d2, StringComparison.InvariantCultureIgnoreCase);
}
else
{
r = string.Compare(d1, d2, StringComparison.Ordinal);
}
switch (_operator)
{
case OperatorType.EqualIgnoreCase: return(r == 0);
case OperatorType.NotEqualIgnoreCase: return(r != 0);
case OperatorType.Equal: return(r == 0);
case OperatorType.NotEqual: return(r != 0);
case OperatorType.Less: return(r < 0);
case OperatorType.LessOrEqual: return(r <= 0);
case OperatorType.Greater: return(r > 0);
case OperatorType.GreaterOrEqual: return(r >= 0);
default:
if (_operator == OperatorType.Not)
{
return(string.IsNullOrEmpty(d1) || !Utils.To <bool>(d1));
}
var v1 = ParsingReader.TryParseNumber(d1);
var v2 = ParsingReader.TryParseNumber(d2);
if (v1 != null && v2 != null)
{
if (v1 is double || v2 is double || v1 is float || v2 is float || v1 is decimal || v2 is decimal)
{
return(doubleMath(Utils.To <double>(v1), Utils.To <double>(v2)));
}
var x = longMath(Utils.To <long>(v1), Utils.To <long>(v2));
if (x is long && (long)x >= int.MinValue && (long)x <= int.MaxValue)
{
return(Utils.To <int>(x));
}
return(x);
}
throw new InvalidOperationException("Cannot process operator " + _operator);
}
}
public void TestNumParsing()
{
Assert.AreEqual(0x22, ParsingReader.ParseNumber("0x22"));
Assert.AreEqual(0x22L, ParsingReader.ParseNumber("0x22l"));
Assert.AreEqual(-112.21, ParsingReader.ParseNumber("-112.21"));
Assert.IsInstanceOfType(ParsingReader.ParseNumber("500.12m"), typeof(decimal));
Assert.IsInstanceOfType(ParsingReader.ParseNumber("500.12f"), typeof(float));
Assert.IsInstanceOfType(ParsingReader.ParseNumber("0x500ul"), typeof(ulong));
Assert.IsInstanceOfType(ParsingReader.ParseNumber("0x500l"), typeof(long));
}
private void btnCalc_Click(object sender, EventArgs e)
{
BasicEvaluationContext be=new BasicEvaluationContext();
foreach (Variable var in variableBindingSource )
{
ParsingReader pr=new ParsingReader(var.Value);
be.SetVariable(var.Name, (object)pr.ReadNumber() ?? var.Value);
}
try
{
tbResult.Text = Dump.ToDump(be.Eval(tbExpression.Text));
}
catch (Exception ex)
{
tbResult.Text = ex.ToString();
}
}
private void btnCalc_Click(object sender, EventArgs e)
{
BasicEvaluationContext be = new BasicEvaluationContext();
foreach (Variable var in variableBindingSource)
{
ParsingReader pr = new ParsingReader(var.Value);
be.SetVariable(var.Name, (object)pr.ReadNumber() ?? var.Value);
}
try
{
tbResult.Text = Dump.ToDump(be.Eval(tbExpression.Text));
}
catch (Exception ex)
{
tbResult.Text = ex.ToString();
}
}
/// Read expression from string, evaluate it and return the value
public object Eval(string expression)
{
if (expression == null)
return null;
IOperation ex = _exprCache[expression];
if (ex == null)
{
using (var sr = new ParsingReader(new StringReader(expression)))
{
ex = new Parser(TokenSpecialCharacters).Parse(sr);
sr.SkipWhiteSpace();
sr.ReadAndThrowIfNot(-1);
_exprCache[expression] = ex;
}
}
if (ex == null)
return null;
return Eval(ex);
}
/// Parse command line into the list of arguments. Mimics .NET command line parsing logic where possible
public static string[] SplitArgs(string commandLine)
{
if (commandLine==null)
return null;
bool quoted = false;
List<string> args = new List<string>();
StringBuilder sb = new StringBuilder();
using (var reader = new ParsingReader(new StringReader(commandLine)))
{
int n;
do
{
n = reader.Read();
if (n == '"')
{
quoted = true;
while (!reader.IsEOF)
{
var ch = (char)reader.Read();
if (ch == '"')
break;
sb.Append(ch);
}
}
else if (n == -1 || char.IsWhiteSpace((char)n))
{
if (sb.Length > 0 || quoted)
args.Add(sb.ToString());
sb.Length = 0;
quoted = false;
}
else
sb.Append((char)n);
} while (n != -1);
}
return args.ToArray();
}
/// Read expression from stream, evaluate it and return the value
public object Eval(ParsingReader expressionReader)
{
return Eval(new Parser(TokenSpecialCharacters).Parse(expressionReader));
}
/// <summary>
/// Try to get variable value
/// </summary>
/// <param name="key">Variable name</param>
/// <param name="value">Where to store found variable value</param>
/// <returns>true if variable is set</returns>
public override bool TryGetValue(string key, out object value)
{
if (!IsCalculated(key))
return base.TryGetValue(key, out value);
using (var sr = new ParsingReader(key))
{
sr.SkipWhiteSpace();
value = sr.ReadNumber();
if (value != null)
{
sr.SkipWhiteSpace();
sr.ReadAndThrowIfNot(-1);
return true;
}
}
if (!string.IsNullOrEmpty(key))
{
switch (key[0])
{
case '%':
EnvironmentVariableTarget target = getTarget(ref key);
value = Environment.GetEnvironmentVariable(key, target);
return value!=null;
case '~':
value = Find(key.Substring(1), true);
return true;
}
}
value = EvalMulti(key);
return true;
}
/// Read multi-expression (like ${a|b|=3+5}) from the string, evaluate it and return the value
public object EvalMulti(string multiExpression)
{
if (multiExpression==null)
return null;
IOperation o = _exprCache[multiExpression];
if (o == null)
{
using (var sr = new ParsingReader(new StringReader(multiExpression)))
{
o = new Parser(TokenSpecialCharacters).ParseMulti(sr);
sr.SkipWhiteSpace();
sr.ReadAndThrowIfNot(-1);
_exprCache[multiExpression] = o;
}
}
return Eval(o);
}
/// <summary>
/// Load script from string
/// </summary>
/// <param name="scriptXml">script as XML</param>
public void Load(string scriptXml)
{
Items.Clear();
bool close = true;
var r = new ParsingReader(new StringReader(scriptXml));
try
{
r.SkipWhiteSpace();
if (r.Peek() == '<')
{
// Get a script file
XmlReaderSettings rs = new XmlReaderSettings();
rs.IgnoreWhitespace = false;
rs.ValidationType = ValidationType.None;
using (XmlReader xr = XmlReader.Create(r, new XmlReaderSettings() {ConformanceLevel = ConformanceLevel.Fragment}))
{
close = false;
Load(xr);
return;
}
}
if (r.Peek() == '=')
{
r.Read();
Items.Add(new Eval { Value=r.ReadToEnd()});
return;
}
Items.Add(new Code { Value=r.ReadToEnd() });
return;
}
finally
{
if (close)
r.Close();
}
}
public TokenQueue(Parser p, ParsingReader r)
{
_reader = r;
_parser = p;
}
/// Parse multi-expression, like ${a|b|=2+3}
public IOperation ParseMulti(ParsingReader reader)
{
Operations.OperationVariableAccess va = new Operations.OperationVariableAccess();
StringBuilder sb = new StringBuilder();
bool orMet = true;
int n;
while ((n=reader.Peek())!=-1)
{
var q = (char)n;
if (q == '}' || q == ')' || q == ']')
break;
switch (q)
{
case '|':
reader.Read();
va.AddName(sb.ToString());
sb.Length = 0;
orMet = true;
break;
case '\'':
case '\"':
case '`':
orMet = false;
if (sb.Length != 0)
reader.ThrowParsingException("Quote must be a first character");
va.AddValue(reader.ReadQuote());
reader.SkipWhiteSpaceAndComments();
if (reader.Peek() != '}' && reader.Peek() != '|')
reader.ThrowParsingException("Unexpected character '" + (char)reader.Peek() + "'");
sb.Length = 0;
break;
case '=':
orMet = false;
reader.Read();
var v = Parse(reader);
if (v != null)
va.AddExpression(v);
else
va.AddValue(null);
break;
default:
orMet = false;
sb.Append(q);
reader.Read();
break;
}
}
if (sb.Length > 0 || orMet)
va.AddName(sb.ToString());
return va;
}
/// <summary>
/// Parse stream and return the expression tree
/// </summary>
/// <param name="r">Stream</param>
/// <returns>Parsed expression or null if no expression is found on stream</returns>
public IOperation Parse(ParsingReader r)
{
List<IOperation> data = new List<IOperation>();
while (!r.IsEOF)
{
TokenQueue tokenQueue = new TokenQueue(this, r);
var ex = parseSingleStatement(tokenQueue,-1);
if (ex == null)
break;
if (data.Count > 0)
data.Add(new Operations.OperationPop());
data.Add(ex);
r.SkipWhiteSpaceAndComments();
if (r.Peek() != ';')
break;
do
{
r.Read();
r.SkipWhiteSpaceAndComments();
} while (r.Peek() == ';');
}
if (data.Count == 0)
return null;
if (data.Count == 1)
return data[0];
return new Operations.OperationExpression(data.ToArray());
}
