public void CreatesParsersFromLambdas() { var succeeds = new LambdaParser<string>(tokens => new Parsed<string>("AA", tokens.Advance().Advance())); succeeds.PartiallyParses(new CharLexer().Tokenize("AABB")).LeavingUnparsedTokens("B", "B").WithValue("AA"); var fails = new LambdaParser<string>(tokens => new Error<string>(tokens, ErrorMessage.Unknown())); fails.FailsToParse(new CharLexer().Tokenize("AABB")).LeavingUnparsedTokens("A", "A", "B", "B").WithMessage("(1, 1): Parse error."); }
public void Parse_WhenOnlyMemberIsPassed_ThrowsException() { var parser = new LambdaParser(); var ex = Assert.Throws<SisoDbException>( () => parser.Parse<MyClass>(i => i.Bool1)); Assert.AreEqual(ExceptionMessages.LambdaParser_NoMemberExpressions, ex.Message); }
public void Parse_WhenByteArray_NotSupportedException() { var parser = new LambdaParser(); var ex = Assert.Throws<NotSupportedException>( () => parser.Parse<MyClass>(i => i.Bytes1 == new byte[] { 1, 2 })); Assert.AreEqual(ExceptionMessages.LambdaParser_MemberIsBytes.Inject("Bytes1"), ex.Message); }
public void ConditionTest() { TryAction(() => { Expression <Func <int, int, int> > srcExp = (x, y) => x > y ? x : y; Expression <Func <int, int, int> > targetExp = LambdaParser.Parse <Func <int, int, int> >("(x, y) => x > y ? x : y"); IsTrue(srcExp, targetExp, 1, 2); IsTrue(srcExp, targetExp, 2, 1); }); }
public void Parse_WhenUnsupportedMethodInvocation_NotSupportedException() { var parser = new LambdaParser(); var ex = Assert.Throws<NotSupportedException>( () => parser.Parse<MyClass>(i => i.String1 == Convert.ToString(i.Int1))); Assert.AreEqual( ExceptionMessages.LambdaParser_UnsupportedMethodCall.Inject("ToString(i.Int1)"), ex.Message); }
public void IndexTest() { TryAction(() => { List <int> list = new List <int> { 1, 2, 3, 4 }; Expression <Func <List <int>, int> > srcExp = (l) => l[1] + l[2]; Expression <Func <List <int>, int> > targetExp = LambdaParser.Parse <Func <List <int>, int> >("(l) => l[1] + l[2]"); Assert.IsTrue(srcExp.Compile().Invoke(list) == targetExp.Compile().Invoke(list)); }); }
public void FuncTestNReco4() { var lambdaParser = new LambdaParser(); var varContext = new Dictionary <string, object> { ["A"] = 10, ["B"] = 12 }; var result = lambdaParser.Eval("A * (B + 10)", varContext); Console.WriteLine(result); }
public bool LambdaParser(Parameter parameter) { StringBuilder statementBuilder = new StringBuilder() .AppendLine("new [] {") .AppendJoin("," + Environment.NewLine, parameter.Statements) .AppendLine("}"); LambdaParser lambdaParser = new LambdaParser(); object[] results = (object[])lambdaParser.Eval(statementBuilder.ToString(), _ => null); return(Assert(results.Select(Convert.ToInt32), parameter.Sum)); }
public void CustomObjTest() { TryAction(() => { Expression <Func <TestObj, long> > srcExp = (t) => t.Count + 8L; Expression <Func <TestObj, long> > targetExp = LambdaParser.Parse <Func <TestObj, long> >("(t) => t.Count + 8L"); var test = new TestObj { Count = 15 }; Assert.IsTrue(srcExp.Compile().Invoke(test) == targetExp.Compile().Invoke(test)); }); }
public void CompareTest() { TryAction(() => { Expression <Func <TestObj, bool> > srcExp = (t) => !(t.Count > 5) || (t.Count < 100 && t.Count > 10); Expression <Func <TestObj, bool> > targetExp = LambdaParser.Parse <Func <TestObj, bool> >("(t) => !(t.Count > 5) || (t.Count < 100 && t.Count > 10)"); var test = new TestObj { Count = 15 }; Assert.IsTrue(srcExp.Compile().Invoke(test) == targetExp.Compile().Invoke(test)); }); }
public void GenericTest() { TryAction(() => { Expression <Func <TestObj, string> > srcExp = (t) => t.Func <int, string>(4); Expression <Func <TestObj, string> > targetExp = LambdaParser.Parse <Func <TestObj, string> >("(t) => t.Func<int, string>(4)"); var test = new TestObj { Count = 15 }; Assert.IsTrue(srcExp.Compile().Invoke(test) == targetExp.Compile().Invoke(test)); }); }
private void ExecuteLuaRule(RuleInfo rule, IIotEntity entity) { var lParser = new LambdaParser(); var context = new Dictionary <string, object> { { "entity", entity }, { "rule", rule } }; var bResult = (bool)lParser.Eval((string)rule.RuleCondition, context); if (bResult) { _logger.LogInformation($"Executing rule {rule.RuleName}"); rule.Action.Invoke(entity); } }
public void MergesPotentialErrorMessagesWhenParserSucceedsWithoutConsumingInput() { //Choice really shouldn't be used with parsers that can succeed without //consuming input. These tests simply describe the behavior under that //unusual situation. Parser<Token> succeedWithoutConsuming = new LambdaParser<Token>(tokens => new Parsed<Token>(null, tokens)); var reply = Choice(A, succeedWithoutConsuming).Parses(Tokenize("")); reply.ErrorMessages.ToString().ShouldEqual("A expected"); reply = Choice(A, B, succeedWithoutConsuming).Parses(Tokenize("")); reply.ErrorMessages.ToString().ShouldEqual("A or B expected"); reply = Choice(A, succeedWithoutConsuming, B).Parses(Tokenize("")); reply.ErrorMessages.ToString().ShouldEqual("A expected"); }
public void NullComparison() { var varContext = getContext(); var lambdaParser = new LambdaParser(); Assert.True((bool)lambdaParser.Eval("null == nullVar", varContext)); Assert.True((bool)lambdaParser.Eval("5>nullVar", varContext)); Assert.True((bool)lambdaParser.Eval("testObj!=null", varContext)); Assert.Equal(0, LambdaParser.GetExpressionParameters(lambdaParser.Parse("20 == null")).Length); lambdaParser = new LambdaParser(new ValueComparer() { NullComparison = ValueComparer.NullComparisonMode.Sql }); Assert.False((bool)lambdaParser.Eval("null == nullVar", varContext)); Assert.False((bool)lambdaParser.Eval("nullVar<5", varContext)); Assert.False((bool)lambdaParser.Eval("nullVar>5", varContext)); }
public void MergesPotentialErrorMessagesWhenParserSucceedsWithoutConsumingInput() { //Choice really shouldn't be used with parsers that can succeed without //consuming input. These tests simply describe the behavior under that //unusual situation. IParser <string> succeedWithoutConsuming = new LambdaParser <string>(tokens => new Success <string>(null, tokens)); var reply = Choice(A, succeedWithoutConsuming).Parses(Tokenize("")); reply.FailureMessages.ToString().ShouldBe("A expected"); reply = Choice(A, B, succeedWithoutConsuming).Parses(Tokenize("")); reply.FailureMessages.ToString().ShouldBe("A or B expected"); reply = Choice(A, succeedWithoutConsuming, B).Parses(Tokenize("")); reply.FailureMessages.ToString().ShouldBe("A expected"); }
public override Verb CreateVerb(string[] tokens) { var lengthLessBracket = length - 1; Color(position, lengthLessBracket, IDEColor.EntityType.Operators); var parser = new LambdaParser(); if (parser.Scan(source, position + lengthLessBracket)) { Conditional = new Conditional((Lambda)parser.Result.Value); overridePosition = parser.Result.Position; } else { Conditional = new Unconditional(); } return(new NullOp()); }
public void EvalCachePerf() { var lambdaParser = new LambdaParser(); var varContext = new Dictionary <string, object>(); varContext["a"] = 55; varContext["b"] = 2; var sw = new Stopwatch(); sw.Start(); for (int i = 0; i < 10000; i++) { Assert.AreEqual(105, lambdaParser.Eval("(a*2 + 100)/b", varContext)); } sw.Stop(); Console.WriteLine("10000 iterations: {0}", sw.Elapsed); }
public override void TraverseChildren(IMethodCall methodCall) { var mutableMethodCall = methodCall as MethodCall; var callsToOverloads = reflector.From(typeof(Replace)).GetAllOverloadsOf("CallsTo"); if (mutableMethodCall.MethodCallMatchesAnOverload(callsToOverloads)) { var lambda = mutableMethodCall.Arguments[0] as AnonymousDelegate; var parser = new LambdaParser(lambda, host, log, registry); var replacement = parser.GetReplacementFactory(); var registrar = replacement.GetRegistrar(); registrar.RegisterReplacement(); } base.TraverseChildren(methodCall); }
public void EvalCachePerfNReco() { decimal result = decimal.MinValue; var sw = new Stopwatch(); sw.Start(); for (var i = 0; i < 10000; i++) { var varContext = new Dictionary <string, object> { ["a"] = 55, ["b"] = 2 }; var lambdaParser = new LambdaParser(); result = (decimal)lambdaParser.Eval("(a*2 + 100)/b", varContext); } sw.Stop(); Console.WriteLine("10000 iterations: {0}", sw.Elapsed); Assert.AreEqual(105M, result); }
public void ApplyingARuleOneOrMoreTimes() { var parser = OneOrMore(AB); parser.FailsToParse(Tokenize("")).AtEndOfInput().WithMessage("(1, 1): A expected"); parser.PartiallyParses(Tokenize("AB!")) .LeavingUnparsedTokens("!") .WithValue(Literals("AB")); parser.PartiallyParses(Tokenize("ABAB!")) .LeavingUnparsedTokens("!") .WithValue(Literals("AB", "AB")); parser.FailsToParse(Tokenize("ABABA!")) .LeavingUnparsedTokens("!") .WithMessage("(1, 6): B expected"); Parser <Token> succeedWithoutConsuming = new LambdaParser <Token>(tokens => new Parsed <Token>(null, tokens)); Action infiniteLoop = () => OneOrMore(succeedWithoutConsuming).Parse(new TokenStream(Tokenize(""))); infiniteLoop.ShouldThrow <Exception>("Parser encountered a potential infinite loop at position (1, 1)."); }
public void ApplyingARuleOneOrMoreTimes() { var parser = OneOrMore(AB); parser.FailsToParse(Tokenize("")).AtEndOfInput().WithMessage("(1, 1): <BIND2 <'A'> TO System.String TO System.String> occurring 1+ times expected"); parser.PartiallyParses(Tokenize("AB!")) .LeavingUnparsedTokens("!") .WithValues("AB"); parser.PartiallyParses(Tokenize("ABAB!")) .LeavingUnparsedTokens("!") .WithValues("AB", "AB"); parser.FailsToParse(Tokenize("ABABA!")) .LeavingUnparsedTokens("!") .WithMessage("(1, 6): B expected"); IParser <Token> succeedWithoutConsuming = new LambdaParser <Token>(tokens => new Success <Token>(null, tokens)); Action infiniteLoop = () => OneOrMore(succeedWithoutConsuming).Parse(new TokenStream(Tokenize(""))); infiniteLoop.ShouldThrow <Exception>("Item parser <(t) Lexepars.Token> encountered a potential infinite loop at position (1, 1)."); }
public void ApplyingARuleZeroOrMoreTimes() { var parser = ZeroOrMore(AB); parser.Parses(Tokenize("")).ParsedValue.ShouldBeEmpty(); parser.PartiallyParses(Tokenize("AB!")) .LeavingUnparsedTokens("!") .WithValues("AB"); parser.PartiallyParses(Tokenize("ABAB!")) .LeavingUnparsedTokens("!") .WithValues("AB", "AB"); parser.FailsToParse(Tokenize("ABABA!")) .LeavingUnparsedTokens("!") .WithMessage("(1, 6): B expected"); var succeedWithoutConsuming = new LambdaParser <string>(t => new Success <string>(null, t)); Action infiniteLoop = () => ZeroOrMore(succeedWithoutConsuming).Parse(new TokenStream(Tokenize(""))); infiniteLoop.ShouldThrow <Exception>("Item parser <(t) System.String> encountered a potential infinite loop at position (1, 1)."); }
/// <summary> /// 分页查询 + 条件查询 + 排序 /// </summary> /// <param name="pager">分页对象</param> /// <param name="condition">过滤条件</param> /// <returns></returns> public PagerEntity <DictionaryDetailEntity> QueryDictionaryDetailByPagers(PagerInfo pager, List <SearchCondition> condition = null) { var entity = CurrentDbSet.Where(it => true); //动态增加过滤条件 if (condition != null && condition.Count > 0) { var parser = new LambdaParser <DictionaryDetailEntity>(); entity = entity.Where(parser.ParserConditions(condition)); } var total = entity.Count(); entity = pager.Sort == "ASC" ? entity.OrderBy(pager.SortFiled) : entity.OrderByDescending(pager.SortFiled); entity = entity.Skip(pager.PageSize * (pager.PageIndex - 1)) .Take(pager.PageSize); return(new PagerEntity <DictionaryDetailEntity> { Entity = entity.ToList(), Total = total }); }
public void Eval() { var lambdaParser = new LambdaParser(); var varContext = getContext(); Assert.Equal("st", lambdaParser.Eval("test.Substring(2)", varContext)); Assert.Equal(true, lambdaParser.Eval("NOT(NOT(1==1))", varContext)); Assert.Equal(3M, lambdaParser.Eval("1+2", varContext)); Assert.Equal(6M, lambdaParser.Eval("1+2+3", varContext)); Assert.Equal("b{0}_", lambdaParser.Eval("\"b{0}_\"", varContext)); Assert.Equal(3M, lambdaParser.Eval("(1+(3-1)*4)/3", varContext)); Assert.Equal(1M, lambdaParser.Eval("one*5*one-(-1+5*5%10)", varContext)); Assert.Equal("ab", lambdaParser.Eval("\"a\"+\"b\"", varContext)); Assert.Equal(4.14M, lambdaParser.Eval("pi + 1", varContext)); Assert.Equal(5.14M, lambdaParser.Eval("2 +pi", varContext)); Assert.Equal(2.14M, lambdaParser.Eval("pi + -one", varContext)); Assert.Equal("test1", lambdaParser.Eval("test + \"1\"", varContext)); Assert.Equal("a_b_a_b", lambdaParser.Eval(" name_with_underscore + _name_with_underscore ", varContext)); Assert.Equal(1M, lambdaParser.Eval("true or false ? 1 : 0", varContext)); Assert.Equal(true, lambdaParser.Eval("5<=3 ? false : true", varContext)); Assert.Equal(5M, lambdaParser.Eval("pi>one && 0<one ? (1+8)/3+1*two : 0", varContext)); Assert.Equal(4M, lambdaParser.Eval("pi>0 ? one+two+one : 0", varContext)); Assert.Equal(DateTime.Now.Year, lambdaParser.Eval("now.Year", varContext)); Assert.Equal(true, lambdaParser.Eval(" (1+testObj.IntProp)==2 ? testObj.FldTrue : false ", varContext)); Assert.Equal("ab2_3", lambdaParser.Eval(" \"a\"+testObj.Format(\"b{0}_{1}\", 2, \"3\".ToString() ).ToString() ", varContext)); Assert.Equal(true, lambdaParser.Eval(" testObj.Hash[\"a\"] == \"1\"", varContext)); Assert.Equal(true, lambdaParser.Eval(" (testObj.Hash[\"a\"]-1)==testObj.Hash[\"b\"].Length ", varContext)); Assert.Equal(4.0M, lambdaParser.Eval(" arr1[0]+arr1[1] ", varContext)); Assert.Equal(2M, lambdaParser.Eval(" (new[]{1,2})[1] ", varContext)); Assert.Equal(true, lambdaParser.Eval(" new[]{ one } == new[] { 1 } ", varContext)); Assert.Equal(3, lambdaParser.Eval(" new dictionary{ {\"a\", 1}, {\"b\", 2}, {\"c\", 3} }.Count ", varContext)); Assert.Equal(2M, lambdaParser.Eval(" new dictionary{ {\"a\", 1}, {\"b\", 2}, {\"c\", 3} }[\"b\"] ", varContext)); var arr = ((Array)lambdaParser.Eval(" new []{ new dictionary{{\"test\",2}}, new[] { one } }", varContext)); Assert.Equal(2M, ((IDictionary)arr.GetValue(0))["test"]); Assert.Equal(1M, ((Array)arr.GetValue(1)).GetValue(0)); Assert.Equal("str", lambdaParser.Eval(" testObj.GetDelegNoParam()() ", varContext)); Assert.Equal("zzz", lambdaParser.Eval(" testObj.GetDelegOneParam()(\"zzz\") ", varContext)); Assert.Equal(false, lambdaParser.Eval("(testObj.FldTrue and false) || (testObj.FldTrue && false)", varContext)); Assert.Equal(true, lambdaParser.Eval("false or testObj.FldTrue", varContext)); Assert.Equal("True", lambdaParser.Eval("testObj.BoolParam(true)", varContext)); Assert.Equal("True", lambdaParser.Eval("getTestObj().BoolParam(true)", varContext)); Assert.Equal("NReco.Linq.Tests.LambdaParserTests+TestClass", lambdaParser.Eval("toString(testObj)", varContext)); Assert.True((bool)lambdaParser.Eval("true && NOT( false )", varContext)); Assert.True((bool)lambdaParser.Eval("true && !( false )", varContext)); Assert.False((bool)lambdaParser.Eval("!Yes", varContext)); Assert.True((bool)lambdaParser.Eval("5>two && (5>7 || test.Contains(\"t\") )", varContext)); Assert.True((bool)lambdaParser.Eval("null!=test && test!=null && test.Contains(\"t\") && true == Yes && false==!Yes && false!=Yes", varContext)); Assert.Equal(new DateTime().AddDays(2), lambdaParser.Eval("day1 + oneDay", varContext)); Assert.Equal(new DateTime().AddDays(2), lambdaParser.Eval("oneDay + day1", varContext)); Assert.Equal(new DateTime().AddDays(1), lambdaParser.Eval("day2 - oneDay", varContext)); Assert.Equal(new DateTime().AddDays(1), lambdaParser.Eval("day2 + -oneDay", varContext)); Assert.Equal(new DateTime().AddDays(1), lambdaParser.Eval("-oneDay + day2", varContext)); Assert.Equal(new TimeSpan(1, 0, 0, 0), lambdaParser.Eval("day2 - day1", varContext)); Assert.Equal(new TimeSpan(1, 0, 0, 0).Negate(), lambdaParser.Eval("day1 - day2", varContext)); Assert.Equal(new TimeSpan(1, 0, 0, 0), lambdaParser.Eval("day2 - day1", varContext)); Assert.Equal(new TimeSpan(2, 0, 0, 0), lambdaParser.Eval("oneDay + oneDay", varContext)); Assert.Equal(new TimeSpan(1, 0, 0, 0), lambdaParser.Eval("twoDays - oneDay", varContext)); Assert.Equal(new TimeSpan(1, 0, 0, 0), lambdaParser.Eval("twoDays + -oneDay", varContext)); Assert.Equal(new TimeSpan(1, 0, 0, 0).Negate(), lambdaParser.Eval("oneDay - twoDays", varContext)); Assert.Equal(new TimeSpan(1, 0, 0, 0).Negate(), lambdaParser.Eval("-twoDays + oneDay", varContext)); }
public ExpressionHelper(string expression) { var parser = new LambdaParser(); m_compiledExpression = parser.CompileExpression(expression); }
public void Eval() { var lambdaParser = new LambdaParser(); var varContext = new Dictionary <string, object>(); varContext["pi"] = 3.14M; varContext["one"] = 1M; varContext["two"] = 2M; varContext["test"] = "test"; varContext["now"] = DateTime.Now; varContext["testObj"] = new TestClass(); varContext["arr1"] = new double[] { 1.5, 2.5 }; Assert.AreEqual(3, lambdaParser.Eval("1+2", varContext)); Assert.AreEqual(6, lambdaParser.Eval("1+2+3", varContext)); Assert.AreEqual("b{0}_", lambdaParser.Eval("\"b{0}_\"", varContext)); Assert.AreEqual(3, lambdaParser.Eval("(1+(3-1)*4)/3", varContext)); Assert.AreEqual(1, lambdaParser.Eval("one*5*one-(-1+5*5%10)", varContext)); Assert.AreEqual("ab", lambdaParser.Eval("\"a\"+\"b\"", varContext)); Assert.AreEqual(4.14, lambdaParser.Eval("pi + 1", varContext)); Assert.AreEqual(5.14, lambdaParser.Eval("2 +pi", varContext)); Assert.AreEqual(2.14, lambdaParser.Eval("pi + -one", varContext)); Assert.AreEqual("test1", lambdaParser.Eval("test + \"1\"", varContext)); Assert.AreEqual(1, lambdaParser.Eval("true or false ? 1 : 0", varContext)); Assert.AreEqual(true, lambdaParser.Eval("5<=3 ? false : true", varContext)); Assert.AreEqual(5, lambdaParser.Eval("pi>one && 0<one ? (1+8)/3+1*two : 0", varContext)); Assert.AreEqual(4, lambdaParser.Eval("pi==true ? one+two+one : 0", varContext)); Assert.AreEqual(DateTime.Now.Year, lambdaParser.Eval("now.Year", varContext)); Assert.AreEqual(true, lambdaParser.Eval(" (1+testObj.IntProp)==2 ? testObj.FldTrue : false ", varContext)); Assert.AreEqual("ab2_3", lambdaParser.Eval(" \"a\"+testObj.Format(\"b{0}_{1}\", 2, \"3\".ToString() ).ToString() ", varContext)); Assert.AreEqual(true, lambdaParser.Eval(" testObj.Hash[\"a\"] == \"1\"", varContext)); Assert.AreEqual(true, lambdaParser.Eval(" (testObj.Hash[\"a\"]-1)==testObj.Hash[\"b\"].Length ", varContext)); Assert.AreEqual(4.0, lambdaParser.Eval(" arr1[0]+arr1[1] ", varContext)); Assert.AreEqual(2, lambdaParser.Eval(" (new[]{1,2})[1] ", varContext)); Assert.AreEqual(true, lambdaParser.Eval(" new[]{ one } == new[] { 1 } ", varContext)); Assert.AreEqual(3, lambdaParser.Eval(" new dictionary{ {\"a\", 1}, {\"b\", 2}, {\"c\", 3} }.Count ", varContext)); Assert.AreEqual(2, lambdaParser.Eval(" new dictionary{ {\"a\", 1}, {\"b\", 2}, {\"c\", 3} }[\"b\"] ", varContext)); var arr = ((Array)lambdaParser.Eval(" new []{ new dictionary{{\"test\",2}}, new[] { one } }", varContext)); Assert.AreEqual(2, ((IDictionary)arr.GetValue(0))["test"]); Assert.AreEqual(1, ((Array)arr.GetValue(1)).GetValue(0)); Assert.AreEqual("str", lambdaParser.Eval(" testObj.GetDelegNoParam()() ", varContext)); Assert.AreEqual("zzz", lambdaParser.Eval(" testObj.GetDelegOneParam()(\"zzz\") ", varContext)); Assert.AreEqual(false, lambdaParser.Eval("(testObj.FldTrue and false) || (testObj.FldTrue && false)", varContext)); Assert.AreEqual(true, lambdaParser.Eval("false or testObj.FldTrue", varContext)); Assert.AreEqual("True", lambdaParser.Eval("testObj.BoolParam(true)", varContext)); }
public void ApplyingARuleZeroOrMoreTimes() { var parser = ZeroOrMore(AB); parser.Parses(Tokenize("")).Value.ShouldBeEmpty(); parser.PartiallyParses(Tokenize("AB!")) .LeavingUnparsedTokens("!") .WithValue(Literals("AB")); parser.PartiallyParses(Tokenize("ABAB!")) .LeavingUnparsedTokens("!") .WithValue(Literals("AB", "AB")); parser.FailsToParse(Tokenize("ABABA!")) .LeavingUnparsedTokens("!") .WithMessage("(1, 6): B expected"); Parser<Token> succeedWithoutConsuming = new LambdaParser<Token>(tokens => new Parsed<Token>(null, tokens)); Action infiniteLoop = () => ZeroOrMore(succeedWithoutConsuming).Parse(new TokenStream(Tokenize(""))); infiniteLoop.ShouldThrow<Exception>("Parser encountered a potential infinite loop at position (1, 1)."); }
private void Run(string name) { string outDir = "ExprParser"; string text = GetResText(InResName(name)); string inName = name + "Input.txt"; string outName = name + "Output.txt"; string outNameAssem = name + "Output.Assem.txt"; string outPath = DeleteOutputPath(outDir, outName); string outPathAssem = DeleteOutputPath(outDir, outNameAssem); using (var wr = OpenWriter(outPath)) { var wrt = new IndentedTextWriter(wr, " "); // Individual scripts are separated by $. // Inputs start after #. int count = 0; int ichLim = 0; int lineLim = 1; for (; ichLim < text.Length; ichLim++) { int ichMin = ichLim; int lineMin = lineLim; while (ichLim < text.Length && text[ichLim] != '$') { if (text[ichLim] == '\n') { lineLim++; } ichLim++; } while (ichMin < ichLim && char.IsWhiteSpace(text[ichMin])) { if (text[ichMin] == '\n') { lineMin++; } ichMin++; } if (ichMin >= ichLim) { continue; } // Process the script. count++; string scriptName = string.Format("Script {0}, lines {1} to {2}", count, lineMin, lineLim); wrt.WriteLine("===== Start {0} =====", scriptName); var types = ParseTypes(text, ref ichMin, ichLim); int ichLimChars = text.IndexOf('#', ichMin); if (ichLimChars < 0 || ichLimChars >= ichLim) { ichLimChars = ichLim; } else { Contracts.Assert(ichMin < ichLimChars && ichLimChars < ichLim); } CharCursor chars = new CharCursor(text, ichMin, ichLimChars); Delegate del = null; lock (_sync) { try { LambdaNode node; List <Error> errors; List <int> lineMap; var perm = Utils.GetIdentityPermutation(types.Length); using (wrt.Nest()) { node = LambdaParser.Parse(out errors, out lineMap, chars, perm, types); } Check(node != null, "Null LambdaNode"); if (Utils.Size(errors) > 0) { DumpErrors(wrt, lineMap, lineMin, inName, "Parsing", errors); goto LDone; } LambdaBinder.Run(Env, ref errors, node, msg => wr.WriteLine(msg)); if (Utils.Size(errors) > 0) { DumpErrors(wrt, lineMap, lineMin, inName, "Binding", errors); goto LDone; } wrt.WriteLine("Binding succeeded. Output type: {0}", node.ResultType); del = LambdaCompiler.Compile(out errors, node); Contracts.Assert(TestFuncs1.Writer == null); TestFuncs1.Writer = wr; if (Utils.Size(errors) > 0) { DumpErrors(wrt, lineMap, lineMin, inName, "Compiling", errors); goto LDone; } wrt.WriteLine("Compiling succeeded."); if (ichLimChars < ichLim) { Evaluate(wrt, del, node.ResultType, types, text, ichLimChars + 1, ichLim); } } catch (Exception ex) { if (!ex.IsMarked()) { wrt.WriteLine("Unknown Exception: {0}!", del != null ? del.GetMethodInfo().DeclaringType : (object)"<null>"); } wrt.WriteLine("Exception: {0}", ex.Message); } finally { TestFuncs1.Writer = null; } LDone: wrt.WriteLine("===== End {0} =====", scriptName); } } } CheckEquality(outDir, outName, digitsOfPrecision: 6); Done(); }
public void Eval() { var lambdaParser = new LambdaParser(); var varContext = new Dictionary <string, object>(); varContext["pi"] = 3.14M; varContext["one"] = 1M; varContext["two"] = 2M; varContext["test"] = "test"; varContext["now"] = DateTime.Now; varContext["testObj"] = new TestClass(); varContext["arr1"] = new double[] { 1.5, 2.5 }; varContext["NOT"] = (Func <bool, bool>)((t) => !t); varContext["Yes"] = true; varContext["nullVar"] = null; varContext["name_with_underscore"] = "a_b"; varContext["_name_with_underscore"] = "_a_b"; Assert.AreEqual("st", lambdaParser.Eval("test.Substring(2)", varContext)); Assert.AreEqual(3, lambdaParser.Eval("1+2", varContext)); Assert.AreEqual(6, lambdaParser.Eval("1+2+3", varContext)); Assert.AreEqual("b{0}_", lambdaParser.Eval("\"b{0}_\"", varContext)); Assert.AreEqual(3, lambdaParser.Eval("(1+(3-1)*4)/3", varContext)); Assert.AreEqual(1, lambdaParser.Eval("one*5*one-(-1+5*5%10)", varContext)); Assert.AreEqual("ab", lambdaParser.Eval("\"a\"+\"b\"", varContext)); Assert.AreEqual(4.14, lambdaParser.Eval("pi + 1", varContext)); Assert.AreEqual(5.14, lambdaParser.Eval("2 +pi", varContext)); Assert.AreEqual(2.14, lambdaParser.Eval("pi + -one", varContext)); Assert.AreEqual("test1", lambdaParser.Eval("test + \"1\"", varContext)); Assert.AreEqual("a_b_a_b", lambdaParser.Eval(" name_with_underscore + _name_with_underscore ", varContext)); Assert.AreEqual(1, lambdaParser.Eval("true or false ? 1 : 0", varContext)); Assert.AreEqual(true, lambdaParser.Eval("5<=3 ? false : true", varContext)); Assert.AreEqual(5, lambdaParser.Eval("pi>one && 0<one ? (1+8)/3+1*two : 0", varContext)); Assert.AreEqual(4, lambdaParser.Eval("pi>0 ? one+two+one : 0", varContext)); Assert.AreEqual(DateTime.Now.Year, lambdaParser.Eval("now.Year", varContext)); Assert.AreEqual(true, lambdaParser.Eval(" (1+testObj.IntProp)==2 ? testObj.FldTrue : false ", varContext)); Assert.AreEqual("ab2_3", lambdaParser.Eval(" \"a\"+testObj.Format(\"b{0}_{1}\", 2, \"3\".ToString() ).ToString() ", varContext)); Assert.AreEqual(true, lambdaParser.Eval(" testObj.Hash[\"a\"] == \"1\"", varContext)); Assert.AreEqual(true, lambdaParser.Eval(" (testObj.Hash[\"a\"]-1)==testObj.Hash[\"b\"].Length ", varContext)); Assert.AreEqual(4.0, lambdaParser.Eval(" arr1[0]+arr1[1] ", varContext)); Assert.AreEqual(2, lambdaParser.Eval(" (new[]{1,2})[1] ", varContext)); Assert.AreEqual(true, lambdaParser.Eval(" new[]{ one } == new[] { 1 } ", varContext)); Assert.AreEqual(3, lambdaParser.Eval(" new dictionary{ {\"a\", 1}, {\"b\", 2}, {\"c\", 3} }.Count ", varContext)); Assert.AreEqual(2, lambdaParser.Eval(" new dictionary{ {\"a\", 1}, {\"b\", 2}, {\"c\", 3} }[\"b\"] ", varContext)); var arr = ((Array)lambdaParser.Eval(" new []{ new dictionary{{\"test\",2}}, new[] { one } }", varContext)); Assert.AreEqual(2, ((IDictionary)arr.GetValue(0))["test"]); Assert.AreEqual(1, ((Array)arr.GetValue(1)).GetValue(0)); Assert.AreEqual("str", lambdaParser.Eval(" testObj.GetDelegNoParam()() ", varContext)); Assert.AreEqual("zzz", lambdaParser.Eval(" testObj.GetDelegOneParam()(\"zzz\") ", varContext)); Assert.AreEqual(false, lambdaParser.Eval("(testObj.FldTrue and false) || (testObj.FldTrue && false)", varContext)); Assert.AreEqual(true, lambdaParser.Eval("false or testObj.FldTrue", varContext)); Assert.AreEqual("True", lambdaParser.Eval("testObj.BoolParam(true)", varContext)); Assert.IsTrue((bool)lambdaParser.Eval("true && NOT( false )", varContext)); Assert.IsTrue((bool)lambdaParser.Eval("true && !( false )", varContext)); Assert.IsFalse((bool)lambdaParser.Eval("!Yes", varContext)); Assert.IsTrue((bool)lambdaParser.Eval("null == nullVar", varContext)); Assert.IsTrue((bool)lambdaParser.Eval("5>nullVar", varContext)); Assert.IsTrue((bool)lambdaParser.Eval("testObj!=null", varContext)); Assert.AreEqual(0, LambdaParser.GetExpressionParameters(lambdaParser.Parse("20 == null")).Length); lambdaParser = new LambdaParser(new ValueComparer() { NullComparison = ValueComparer.NullComparisonMode.Sql }); Assert.IsFalse((bool)lambdaParser.Eval("null == nullVar", varContext)); Assert.IsFalse((bool)lambdaParser.Eval("nullVar<5", varContext)); Assert.IsFalse((bool)lambdaParser.Eval("nullVar>5", varContext)); }