[mapguide-commits] r5361 - in sandbox/maestro-3.0: MaestroAPITests
OSGeo.MapGuide.MaestroAPI OSGeo.MapGuide.MaestroAPI/Exceptions
OSGeo.MapGuide.MaestroAPI/Expression
OSGeo.MapGuide.MaestroAPI/Feature Thirdparty Thirdparty/Flee
Thirdparty/Flee/lib
svn_mapguide at osgeo.org
svn_mapguide at osgeo.org
Fri Oct 29 02:33:36 EDT 2010
Author: jng
Date: 2010-10-28 23:33:36 -0700 (Thu, 28 Oct 2010)
New Revision: 5361
Added:
sandbox/maestro-3.0/MaestroAPITests/ExpressionTests.cs
sandbox/maestro-3.0/OSGeo.MapGuide.MaestroAPI/Exceptions/ExpressionException.cs
sandbox/maestro-3.0/OSGeo.MapGuide.MaestroAPI/Expression/
sandbox/maestro-3.0/OSGeo.MapGuide.MaestroAPI/Expression/ExpressionEngine.cs
sandbox/maestro-3.0/OSGeo.MapGuide.MaestroAPI/Expression/ExpressionFeatureReader.cs
sandbox/maestro-3.0/OSGeo.MapGuide.MaestroAPI/Expression/FdoFunctionNamespace.cs
sandbox/maestro-3.0/OSGeo.MapGuide.MaestroAPI/Expression/MgFunctionNamespace.cs
sandbox/maestro-3.0/Thirdparty/Flee/
sandbox/maestro-3.0/Thirdparty/Flee/ReleaseNotes.txt
sandbox/maestro-3.0/Thirdparty/Flee/lib/
sandbox/maestro-3.0/Thirdparty/Flee/lib/Ciloci.Flee.chm
sandbox/maestro-3.0/Thirdparty/Flee/lib/Ciloci.Flee.dll
sandbox/maestro-3.0/Thirdparty/Flee/lib/Ciloci.Flee.xml
sandbox/maestro-3.0/Thirdparty/Flee/license.txt
sandbox/maestro-3.0/Thirdparty/Flee/readme.txt
Modified:
sandbox/maestro-3.0/MaestroAPITests/MaestroAPITests.csproj
sandbox/maestro-3.0/OSGeo.MapGuide.MaestroAPI/Feature/FeatureSetReader.cs
sandbox/maestro-3.0/OSGeo.MapGuide.MaestroAPI/OSGeo.MapGuide.MaestroAPI.csproj
Log:
3.0 sandbox changes:
- Make MaestroAPITests project launch nunit-console.exe for quick unit test runs
- Add FLEE (Fast Lightweight Expression Evaluator) (http://flee.codeplex.com) to Thirdparty
- Add an experimental expression engine allowing for evaluation of most FDO functions. To protect the innocent, these APIs are internal until such time where I think it's ready to be let out of the bag.
Added: sandbox/maestro-3.0/MaestroAPITests/ExpressionTests.cs
===================================================================
--- sandbox/maestro-3.0/MaestroAPITests/ExpressionTests.cs (rev 0)
+++ sandbox/maestro-3.0/MaestroAPITests/ExpressionTests.cs 2010-10-29 06:33:36 UTC (rev 5361)
@@ -0,0 +1,836 @@
+#region Disclaimer / License
+// Copyright (C) 2010, Jackie Ng
+// http://trac.osgeo.org/mapguide/wiki/maestro, jumpinjackie at gmail.com
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+//
+#endregion
+using System;
+using System.Collections.Generic;
+using System.Text;
+using NUnit.Framework;
+using OSGeo.MapGuide.MaestroAPI;
+using System.IO;
+using OSGeo.MapGuide.MaestroAPI.Expression;
+using System.Threading;
+using System.Diagnostics;
+using OSGeo.MapGuide.MaestroAPI.Exceptions;
+
+namespace MaestroAPITests
+{
+ // Test data schema (for reference in these unit tests)
+ //
+ // ID (int32) | Name(string) | URL(string)
+ //
+ // 1 | Foobar | http://foobar.com
+ // 2 | snafu | (null)
+ // 2 | (null) | (null)
+
+ [TestFixture]
+ public class ExpressionTests
+ {
+ [Test]
+ public void TestMismatch()
+ {
+ //Simulate post-#708 SELECTFEATURES output and test our expression engine reader
+ var bytes = Encoding.UTF8.GetBytes(Properties.Resources.SelectFeatureSample);
+ var reader = new XmlFeatureSetReader(new MemoryStream(bytes));
+
+ var exprReader = new ExpressionFeatureReader(reader);
+
+ Assert.IsTrue(exprReader.Read());
+ Assert.Catch<ExpressionException>(() => exprReader.Evaluate<bool>("CurrentDate()"));
+ Assert.Catch<ExpressionException>(() => exprReader.Evaluate<bool>("'Foobar'"));
+ Assert.Catch<ExpressionException>(() => exprReader.Evaluate<bool>("Power(2, 4)"));
+ Assert.Catch<ExpressionException>(() => exprReader.Evaluate<string>("Foobar"));
+
+ var dt = exprReader.Evaluate<DateTime>("CurrentDate()");
+ var str = exprReader.Evaluate<string>("'Foobar'");
+ var num = exprReader.Evaluate<int>("Power(2, 4)");
+ var num2 = exprReader.Evaluate<float>("Power(2, 4)");
+
+ exprReader.Close();
+ }
+
+ [Test]
+ public void TestCurrentDateAndAddMonths()
+ {
+ //TODO: Know how to calculate diffs between 2 DateTimes in months?
+
+ var dtNow = DateTime.Now;
+
+ //Simulate post-#708 SELECTFEATURES output and test our expression engine reader
+ var bytes = Encoding.UTF8.GetBytes(Properties.Resources.SelectFeatureSample);
+ var reader = new XmlFeatureSetReader(new MemoryStream(bytes));
+
+ var exprReader = new ExpressionFeatureReader(reader);
+
+ Assert.IsTrue(exprReader.Read());
+
+ var dt1 = exprReader.Evaluate("CurrentDate()");
+ Assert.NotNull(dt1);
+ Trace.WriteLine("dt1: " + dt1.ToString());
+ Assert.AreEqual(typeof(DateTime), dt1.GetType());
+ Assert.IsTrue((DateTime)dt1 > dtNow);
+
+ var fut1 = exprReader.Evaluate("AddMonths(CurrentDate(), 3)");
+ Assert.NotNull(fut1);
+ Trace.WriteLine("fut1: " + fut1.ToString());
+
+ var past1 = exprReader.Evaluate("AddMonths(CurrentDate(), -3)");
+ Assert.NotNull(past1);
+ Trace.WriteLine("past1: " + past1.ToString());
+
+ Thread.Sleep(50);
+
+ Assert.IsTrue(exprReader.Read());
+
+ var dt2 = exprReader.Evaluate("CurrentDate()");
+ Assert.NotNull(dt2);
+ Trace.WriteLine("dt2: " + dt2.ToString());
+ Assert.AreEqual(typeof(DateTime), dt2.GetType());
+ Assert.IsTrue((DateTime)dt2 > (DateTime)dt1);
+
+ var fut2 = exprReader.Evaluate("AddMonths(CurrentDate(), 3)");
+ Assert.NotNull(fut2);
+ Trace.WriteLine("fut2: " + fut2.ToString());
+
+ var past2 = exprReader.Evaluate("AddMonths(CurrentDate(), -3)");
+ Assert.NotNull(past2);
+ Trace.WriteLine("past2: " + past2.ToString());
+
+ Thread.Sleep(50);
+
+ Assert.IsTrue(exprReader.Read());
+
+ var dt3 = exprReader.Evaluate("CurrentDate()");
+ Assert.NotNull(dt3);
+ Trace.WriteLine("dt2: " + dt3.ToString());
+ Assert.AreEqual(typeof(DateTime), dt3.GetType());
+ Assert.IsTrue((DateTime)dt3 > (DateTime)dt2);
+
+ var fut3 = exprReader.Evaluate("AddMonths(CurrentDate(), 3)");
+ Assert.NotNull(fut3);
+ Trace.WriteLine("fut3: " + fut3.ToString());
+
+ var past3 = exprReader.Evaluate("AddMonths(CurrentDate(), -3)");
+ Assert.NotNull(past3);
+ Trace.WriteLine("past3: " + past3.ToString());
+
+ Thread.Sleep(50);
+
+ Assert.IsFalse(exprReader.Read()); //end of stream
+
+ exprReader.Close();
+ }
+
+ [Test]
+ public void TestNullValue()
+ {
+ //Simulate post-#708 SELECTFEATURES output and test our expression engine reader
+ var bytes = Encoding.UTF8.GetBytes(Properties.Resources.SelectFeatureSample);
+ var reader = new XmlFeatureSetReader(new MemoryStream(bytes));
+
+ var exprReader = new ExpressionFeatureReader(reader);
+
+ Assert.IsTrue(exprReader.Read());
+
+ Assert.IsTrue(!exprReader.IsDBNull(exprReader.GetOrdinal("URL")));
+
+ var url = exprReader["URL"];
+ var value = exprReader.Evaluate("NullValue(URL, 'http://www.snafu.com')");
+ Assert.NotNull(url);
+ Assert.NotNull(value);
+ Assert.AreEqual(url.ToString(), value.ToString());
+
+ Assert.IsTrue(exprReader.Read());
+
+ var value2 = exprReader.Evaluate("NullValue(URL, 'http://www.foo.com')");
+ Assert.NotNull(value2);
+ Assert.AreEqual("http://www.foo.com", value2);
+
+ Assert.IsTrue(exprReader.Read());
+
+ var value3 = exprReader.Evaluate("NullValue(URL, 'http://www.bar.com')");
+ Assert.NotNull(value3);
+ Assert.AreEqual("http://www.bar.com", value3);
+
+ Assert.IsFalse(exprReader.Read());
+ exprReader.Close();
+ }
+
+ [Test]
+ public void TestMathAbs()
+ {
+ //Simulate post-#708 SELECTFEATURES output and test our expression engine reader
+ var bytes = Encoding.UTF8.GetBytes(Properties.Resources.SelectFeatureSample);
+ var reader = new XmlFeatureSetReader(new MemoryStream(bytes));
+
+ var exprReader = new ExpressionFeatureReader(reader);
+
+ Assert.IsTrue(exprReader.Read());
+
+ var orig = (int)exprReader["ID"];
+ var value = Convert.ToInt32(exprReader.Evaluate("Abs(-ID)"));
+
+ Assert.AreEqual(orig, value);
+
+ Assert.IsTrue(exprReader.Read());
+
+ var orig2 = (int)exprReader["ID"];
+ var value2 = Convert.ToInt32(exprReader.Evaluate("Abs(-ID)"));
+
+ Assert.AreEqual(orig2, value2);
+
+ Assert.IsTrue(exprReader.Read());
+
+ var orig3 = (int)exprReader["ID"];
+ var value3 = Convert.ToInt32(exprReader.Evaluate("Abs(-ID)"));
+
+ Assert.AreEqual(orig3, value3);
+
+ Assert.IsFalse(exprReader.Read());
+
+ exprReader.Close();
+ }
+
+ [Test]
+ public void TestMathAcos()
+ {
+ //The numbers in this sample are way too large for Acos() so trim them down to size
+
+ //Simulate post-#708 SELECTFEATURES output and test our expression engine reader
+ var bytes = Encoding.UTF8.GetBytes(Properties.Resources.SelectFeatureSample);
+ var reader = new XmlFeatureSetReader(new MemoryStream(bytes));
+
+ var exprReader = new ExpressionFeatureReader(reader);
+
+ Assert.IsTrue(exprReader.Read());
+
+ var orig = (int)exprReader["ID"];
+ var value = Convert.ToDouble(exprReader.Evaluate("Acos(ID * 0.1)"));
+
+ Assert.AreEqual(Math.Acos(orig * 0.1), value);
+
+ Assert.IsTrue(exprReader.Read());
+
+ var orig2 = (int)exprReader["ID"];
+ var value2 = Convert.ToDouble(exprReader.Evaluate("Acos(ID * 0.1)"));
+
+ Assert.AreEqual(Math.Acos(orig2 * 0.1), value2);
+
+ Assert.IsTrue(exprReader.Read());
+
+ var orig3 = (int)exprReader["ID"];
+ var value3 = Convert.ToDouble(exprReader.Evaluate("Acos(ID * 0.1)"));
+
+ Assert.AreEqual(Math.Acos(orig3 * 0.1), value3);
+
+ Assert.IsFalse(exprReader.Read());
+
+ exprReader.Close();
+ }
+
+ [Test]
+ public void TestMathAsin()
+ {
+ //The numbers in this sample are way too large for Asin() so trim them down to size
+
+ //Simulate post-#708 SELECTFEATURES output and test our expression engine reader
+ var bytes = Encoding.UTF8.GetBytes(Properties.Resources.SelectFeatureSample);
+ var reader = new XmlFeatureSetReader(new MemoryStream(bytes));
+
+ var exprReader = new ExpressionFeatureReader(reader);
+
+ Assert.IsTrue(exprReader.Read());
+
+ var orig = (int)exprReader["ID"];
+ var value = Convert.ToDouble(exprReader.Evaluate("Asin(ID * 0.1)"));
+
+ Assert.AreEqual(Math.Asin(orig * 0.1), value);
+
+ Assert.IsTrue(exprReader.Read());
+
+ var orig2 = (int)exprReader["ID"];
+ var value2 = Convert.ToDouble(exprReader.Evaluate("Asin(ID * 0.1)"));
+
+ Assert.AreEqual(Math.Asin(orig2 * 0.1), value2);
+
+ Assert.IsTrue(exprReader.Read());
+
+ var orig3 = (int)exprReader["ID"];
+ var value3 = Convert.ToDouble(exprReader.Evaluate("Asin(ID * 0.1)"));
+
+ Assert.AreEqual(Math.Asin(orig3 * 0.1), value3);
+
+ Assert.IsFalse(exprReader.Read());
+
+ exprReader.Close();
+ }
+
+ public void TestMathAtan2()
+ {
+ //Simulate post-#708 SELECTFEATURES output and test our expression engine reader
+ var bytes = Encoding.UTF8.GetBytes(Properties.Resources.SelectFeatureSample);
+ var reader = new XmlFeatureSetReader(new MemoryStream(bytes));
+
+ var exprReader = new ExpressionFeatureReader(reader);
+
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsFalse(exprReader.Read());
+
+ exprReader.Close();
+ }
+
+ [Test]
+ public void TestMathCos()
+ {
+ //Simulate post-#708 SELECTFEATURES output and test our expression engine reader
+ var bytes = Encoding.UTF8.GetBytes(Properties.Resources.SelectFeatureSample);
+ var reader = new XmlFeatureSetReader(new MemoryStream(bytes));
+
+ var exprReader = new ExpressionFeatureReader(reader);
+
+ Assert.IsTrue(exprReader.Read());
+
+ var orig = (int)exprReader["ID"];
+ var value = Convert.ToDouble(exprReader.Evaluate("Cos(ID)"));
+
+ Assert.AreEqual(Math.Cos(orig), value);
+
+ Assert.IsTrue(exprReader.Read());
+
+ var orig2 = (int)exprReader["ID"];
+ var value2 = Convert.ToDouble(exprReader.Evaluate("Cos(ID)"));
+
+ Assert.AreEqual(Math.Cos(orig2), value2);
+
+ Assert.IsTrue(exprReader.Read());
+
+ var orig3 = (int)exprReader["ID"];
+ var value3 = Convert.ToDouble(exprReader.Evaluate("Cos(ID)"));
+
+ Assert.AreEqual(Math.Cos(orig3), value3);
+
+ Assert.IsFalse(exprReader.Read());
+
+ exprReader.Close();
+ }
+
+ [Test]
+ public void TestMathExp()
+ {
+ //Simulate post-#708 SELECTFEATURES output and test our expression engine reader
+ var bytes = Encoding.UTF8.GetBytes(Properties.Resources.SelectFeatureSample);
+ var reader = new XmlFeatureSetReader(new MemoryStream(bytes));
+
+ var exprReader = new ExpressionFeatureReader(reader);
+
+ Assert.IsTrue(exprReader.Read());
+
+ var orig = (int)exprReader["ID"];
+ var value = Convert.ToDouble(exprReader.Evaluate("Exp(ID)"));
+
+ Assert.AreEqual(Math.Exp(orig), value);
+
+ Assert.IsTrue(exprReader.Read());
+
+ var orig2 = (int)exprReader["ID"];
+ var value2 = Convert.ToDouble(exprReader.Evaluate("Exp(ID)"));
+
+ Assert.AreEqual(Math.Exp(orig2), value2);
+
+ Assert.IsTrue(exprReader.Read());
+
+ var orig3 = (int)exprReader["ID"];
+ var value3 = Convert.ToDouble(exprReader.Evaluate("Exp(ID)"));
+
+ Assert.AreEqual(Math.Exp(orig3), value3);
+
+ Assert.IsFalse(exprReader.Read());
+
+ exprReader.Close();
+ }
+
+ [Test]
+ public void TestMathLn()
+ {
+ //Simulate post-#708 SELECTFEATURES output and test our expression engine reader
+ var bytes = Encoding.UTF8.GetBytes(Properties.Resources.SelectFeatureSample);
+ var reader = new XmlFeatureSetReader(new MemoryStream(bytes));
+
+ var exprReader = new ExpressionFeatureReader(reader);
+
+ Assert.IsTrue(exprReader.Read());
+
+ var orig = (int)exprReader["ID"];
+ var value = Convert.ToDouble(exprReader.Evaluate("Ln(ID)"));
+
+ Assert.AreEqual(Math.Log(orig), value);
+
+ Assert.IsTrue(exprReader.Read());
+
+ var orig2 = (int)exprReader["ID"];
+ var value2 = Convert.ToDouble(exprReader.Evaluate("Ln(ID)"));
+
+ Assert.AreEqual(Math.Log(orig2), value2);
+
+ Assert.IsTrue(exprReader.Read());
+
+ var orig3 = (int)exprReader["ID"];
+ var value3 = Convert.ToDouble(exprReader.Evaluate("Ln(ID)"));
+
+ Assert.AreEqual(Math.Log(orig3), value3);
+
+ Assert.IsFalse(exprReader.Read());
+
+ exprReader.Close();
+ }
+
+ [Test]
+ public void TestMathLog()
+ {
+
+ }
+
+ public void TestMathMod()
+ {
+ //Simulate post-#708 SELECTFEATURES output and test our expression engine reader
+ var bytes = Encoding.UTF8.GetBytes(Properties.Resources.SelectFeatureSample);
+ var reader = new XmlFeatureSetReader(new MemoryStream(bytes));
+
+ var exprReader = new ExpressionFeatureReader(reader);
+
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsFalse(exprReader.Read());
+
+ exprReader.Close();
+ }
+
+ [Test]
+ public void TestMathPower()
+ {
+ //Simulate post-#708 SELECTFEATURES output and test our expression engine reader
+ var bytes = Encoding.UTF8.GetBytes(Properties.Resources.SelectFeatureSample);
+ var reader = new XmlFeatureSetReader(new MemoryStream(bytes));
+
+ var exprReader = new ExpressionFeatureReader(reader);
+
+ Assert.IsTrue(exprReader.Read());
+
+ var orig = (int)exprReader["ID"];
+ var value = Convert.ToDouble(exprReader.Evaluate("Power(ID, 2)"));
+
+ Assert.AreEqual(Math.Pow(orig, 2), value);
+
+ Assert.IsTrue(exprReader.Read());
+
+ var orig2 = (int)exprReader["ID"];
+ var value2 = Convert.ToDouble(exprReader.Evaluate("Power(ID, 4)"));
+
+ Assert.AreEqual(Math.Pow(orig2, 4), value2);
+
+ Assert.IsTrue(exprReader.Read());
+
+ var orig3 = (int)exprReader["ID"];
+ var value3 = Convert.ToDouble(exprReader.Evaluate("Power(ID, 8)"));
+
+ Assert.AreEqual(Math.Pow(orig3, 8), value3);
+
+ Assert.IsFalse(exprReader.Read());
+
+ exprReader.Close();
+ }
+
+ public void TestMathRemainder()
+ {
+ //Simulate post-#708 SELECTFEATURES output and test our expression engine reader
+ var bytes = Encoding.UTF8.GetBytes(Properties.Resources.SelectFeatureSample);
+ var reader = new XmlFeatureSetReader(new MemoryStream(bytes));
+
+ var exprReader = new ExpressionFeatureReader(reader);
+
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsFalse(exprReader.Read());
+
+ exprReader.Close();
+ }
+
+ public void TestMathSin()
+ {
+ //Simulate post-#708 SELECTFEATURES output and test our expression engine reader
+ var bytes = Encoding.UTF8.GetBytes(Properties.Resources.SelectFeatureSample);
+ var reader = new XmlFeatureSetReader(new MemoryStream(bytes));
+
+ var exprReader = new ExpressionFeatureReader(reader);
+
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsFalse(exprReader.Read());
+
+ exprReader.Close();
+ }
+
+ public void TestMathSqrt()
+ {
+ //Simulate post-#708 SELECTFEATURES output and test our expression engine reader
+ var bytes = Encoding.UTF8.GetBytes(Properties.Resources.SelectFeatureSample);
+ var reader = new XmlFeatureSetReader(new MemoryStream(bytes));
+
+ var exprReader = new ExpressionFeatureReader(reader);
+
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsFalse(exprReader.Read());
+
+ exprReader.Close();
+ }
+
+ public void TestMathTan()
+ {
+ //Simulate post-#708 SELECTFEATURES output and test our expression engine reader
+ var bytes = Encoding.UTF8.GetBytes(Properties.Resources.SelectFeatureSample);
+ var reader = new XmlFeatureSetReader(new MemoryStream(bytes));
+
+ var exprReader = new ExpressionFeatureReader(reader);
+
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsFalse(exprReader.Read());
+
+ exprReader.Close();
+ }
+
+ public void TestMathCeil()
+ {
+ //Simulate post-#708 SELECTFEATURES output and test our expression engine reader
+ var bytes = Encoding.UTF8.GetBytes(Properties.Resources.SelectFeatureSample);
+ var reader = new XmlFeatureSetReader(new MemoryStream(bytes));
+
+ var exprReader = new ExpressionFeatureReader(reader);
+
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsFalse(exprReader.Read());
+
+ exprReader.Close();
+ }
+
+ public void TestMathFloor()
+ {
+ //Simulate post-#708 SELECTFEATURES output and test our expression engine reader
+ var bytes = Encoding.UTF8.GetBytes(Properties.Resources.SelectFeatureSample);
+ var reader = new XmlFeatureSetReader(new MemoryStream(bytes));
+
+ var exprReader = new ExpressionFeatureReader(reader);
+
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsFalse(exprReader.Read());
+
+ exprReader.Close();
+ }
+
+ public void TestMathRound()
+ {
+ //Simulate post-#708 SELECTFEATURES output and test our expression engine reader
+ var bytes = Encoding.UTF8.GetBytes(Properties.Resources.SelectFeatureSample);
+ var reader = new XmlFeatureSetReader(new MemoryStream(bytes));
+
+ var exprReader = new ExpressionFeatureReader(reader);
+
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsFalse(exprReader.Read());
+
+ exprReader.Close();
+ }
+
+ public void TestMathSign()
+ {
+ //Simulate post-#708 SELECTFEATURES output and test our expression engine reader
+ var bytes = Encoding.UTF8.GetBytes(Properties.Resources.SelectFeatureSample);
+ var reader = new XmlFeatureSetReader(new MemoryStream(bytes));
+
+ var exprReader = new ExpressionFeatureReader(reader);
+
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsFalse(exprReader.Read());
+
+ exprReader.Close();
+ }
+
+ public void TestMathTrunc()
+ {
+ //Simulate post-#708 SELECTFEATURES output and test our expression engine reader
+ var bytes = Encoding.UTF8.GetBytes(Properties.Resources.SelectFeatureSample);
+ var reader = new XmlFeatureSetReader(new MemoryStream(bytes));
+
+ var exprReader = new ExpressionFeatureReader(reader);
+
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsFalse(exprReader.Read());
+
+ exprReader.Close();
+ }
+
+ [Test]
+ public void TestConcat()
+ {
+ //Test nested and variadic forms of Concat()
+
+ //Simulate post-#708 SELECTFEATURES output and test our expression engine reader
+ var bytes = Encoding.UTF8.GetBytes(Properties.Resources.SelectFeatureSample);
+ var reader = new XmlFeatureSetReader(new MemoryStream(bytes));
+
+ var exprReader = new ExpressionFeatureReader(reader);
+
+ Assert.IsTrue(exprReader.Read());
+
+ var orig = exprReader["Name"].ToString();
+ var value = exprReader.Evaluate("Concat(Concat(Name, 'Foo'), 'Bar')");
+ var valueV = exprReader.Evaluate("Concat(Name, 'Foo', 'Bar', 'Snafu')");
+ Assert.AreEqual(orig + "FooBar", value);
+ Assert.AreEqual(orig + "FooBarSnafu", valueV);
+
+ Assert.IsTrue(exprReader.Read());
+
+ var orig2 = exprReader["Name"].ToString();
+ var value2 = exprReader.Evaluate("Concat(Concat(Name, 'Foo'), 'Bar')");
+ var valueV2 = exprReader.Evaluate("Concat(Name, 'Foo', 'Bar', 'Snafu')");
+ Assert.AreEqual(orig2 + "FooBar", value2);
+ Assert.AreEqual(orig2 + "FooBarSnafu", valueV2);
+
+ Assert.IsTrue(exprReader.Read());
+
+ var value3 = exprReader.Evaluate("Concat(Concat(Name, 'Foo'), 'Bar')");
+ var valueV3 = exprReader.Evaluate("Concat(Name, 'Foo', 'Bar', 'Snafu')");
+ Assert.AreEqual("FooBar", value3);
+ Assert.AreEqual("FooBarSnafu", valueV3);
+
+ Assert.IsFalse(exprReader.Read());
+
+ exprReader.Close();
+ }
+
+ public void TestInstr()
+ {
+ //Simulate post-#708 SELECTFEATURES output and test our expression engine reader
+ var bytes = Encoding.UTF8.GetBytes(Properties.Resources.SelectFeatureSample);
+ var reader = new XmlFeatureSetReader(new MemoryStream(bytes));
+
+ var exprReader = new ExpressionFeatureReader(reader);
+
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsFalse(exprReader.Read());
+
+ exprReader.Close();
+ }
+
+ public void TestLength()
+ {
+ //Simulate post-#708 SELECTFEATURES output and test our expression engine reader
+ var bytes = Encoding.UTF8.GetBytes(Properties.Resources.SelectFeatureSample);
+ var reader = new XmlFeatureSetReader(new MemoryStream(bytes));
+
+ var exprReader = new ExpressionFeatureReader(reader);
+
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsFalse(exprReader.Read());
+
+ exprReader.Close();
+ }
+
+ public void TestLower()
+ {
+ //Simulate post-#708 SELECTFEATURES output and test our expression engine reader
+ var bytes = Encoding.UTF8.GetBytes(Properties.Resources.SelectFeatureSample);
+ var reader = new XmlFeatureSetReader(new MemoryStream(bytes));
+
+ var exprReader = new ExpressionFeatureReader(reader);
+
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsFalse(exprReader.Read());
+
+ exprReader.Close();
+ }
+
+ public void TestLpad()
+ {
+ //Simulate post-#708 SELECTFEATURES output and test our expression engine reader
+ var bytes = Encoding.UTF8.GetBytes(Properties.Resources.SelectFeatureSample);
+ var reader = new XmlFeatureSetReader(new MemoryStream(bytes));
+
+ var exprReader = new ExpressionFeatureReader(reader);
+
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsFalse(exprReader.Read());
+
+ exprReader.Close();
+ }
+
+ public void TestLtrim()
+ {
+ //Simulate post-#708 SELECTFEATURES output and test our expression engine reader
+ var bytes = Encoding.UTF8.GetBytes(Properties.Resources.SelectFeatureSample);
+ var reader = new XmlFeatureSetReader(new MemoryStream(bytes));
+
+ var exprReader = new ExpressionFeatureReader(reader);
+
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsFalse(exprReader.Read());
+
+ exprReader.Close();
+ }
+
+ public void TestRpad()
+ {
+ //Simulate post-#708 SELECTFEATURES output and test our expression engine reader
+ var bytes = Encoding.UTF8.GetBytes(Properties.Resources.SelectFeatureSample);
+ var reader = new XmlFeatureSetReader(new MemoryStream(bytes));
+
+ var exprReader = new ExpressionFeatureReader(reader);
+
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsFalse(exprReader.Read());
+
+ exprReader.Close();
+ }
+
+ public void TestRtrim()
+ {
+ //Simulate post-#708 SELECTFEATURES output and test our expression engine reader
+ var bytes = Encoding.UTF8.GetBytes(Properties.Resources.SelectFeatureSample);
+ var reader = new XmlFeatureSetReader(new MemoryStream(bytes));
+
+ var exprReader = new ExpressionFeatureReader(reader);
+
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsFalse(exprReader.Read());
+
+ exprReader.Close();
+ }
+
+ public void TestSoundex()
+ {
+ //Simulate post-#708 SELECTFEATURES output and test our expression engine reader
+ var bytes = Encoding.UTF8.GetBytes(Properties.Resources.SelectFeatureSample);
+ var reader = new XmlFeatureSetReader(new MemoryStream(bytes));
+
+ var exprReader = new ExpressionFeatureReader(reader);
+
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsFalse(exprReader.Read());
+
+ exprReader.Close();
+ }
+
+ public void TestSubstr()
+ {
+ //Simulate post-#708 SELECTFEATURES output and test our expression engine reader
+ var bytes = Encoding.UTF8.GetBytes(Properties.Resources.SelectFeatureSample);
+ var reader = new XmlFeatureSetReader(new MemoryStream(bytes));
+
+ var exprReader = new ExpressionFeatureReader(reader);
+
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsFalse(exprReader.Read());
+
+ exprReader.Close();
+ }
+
+ public void TestTranslate()
+ {
+ //Simulate post-#708 SELECTFEATURES output and test our expression engine reader
+ var bytes = Encoding.UTF8.GetBytes(Properties.Resources.SelectFeatureSample);
+ var reader = new XmlFeatureSetReader(new MemoryStream(bytes));
+
+ var exprReader = new ExpressionFeatureReader(reader);
+
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsFalse(exprReader.Read());
+
+ exprReader.Close();
+ }
+
+ public void TestTrim()
+ {
+ //Simulate post-#708 SELECTFEATURES output and test our expression engine reader
+ var bytes = Encoding.UTF8.GetBytes(Properties.Resources.SelectFeatureSample);
+ var reader = new XmlFeatureSetReader(new MemoryStream(bytes));
+
+ var exprReader = new ExpressionFeatureReader(reader);
+
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsFalse(exprReader.Read());
+
+ exprReader.Close();
+ }
+
+ public void TestUpper()
+ {
+ //Simulate post-#708 SELECTFEATURES output and test our expression engine reader
+ var bytes = Encoding.UTF8.GetBytes(Properties.Resources.SelectFeatureSample);
+ var reader = new XmlFeatureSetReader(new MemoryStream(bytes));
+
+ var exprReader = new ExpressionFeatureReader(reader);
+
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsTrue(exprReader.Read());
+ Assert.IsFalse(exprReader.Read());
+
+ exprReader.Close();
+ }
+ }
+}
Modified: sandbox/maestro-3.0/MaestroAPITests/MaestroAPITests.csproj
===================================================================
--- sandbox/maestro-3.0/MaestroAPITests/MaestroAPITests.csproj 2010-10-29 03:11:03 UTC (rev 5360)
+++ sandbox/maestro-3.0/MaestroAPITests/MaestroAPITests.csproj 2010-10-29 06:33:36 UTC (rev 5361)
@@ -45,6 +45,7 @@
</ItemGroup>
<ItemGroup>
<Compile Include="CapabilityTests.cs" />
+ <Compile Include="ExpressionTests.cs" />
<Compile Include="FeatureReaderTests.cs" />
<Compile Include="HttpConnectionTests.cs" />
<Compile Include="ObjectTests.cs" />
Added: sandbox/maestro-3.0/OSGeo.MapGuide.MaestroAPI/Exceptions/ExpressionException.cs
===================================================================
--- sandbox/maestro-3.0/OSGeo.MapGuide.MaestroAPI/Exceptions/ExpressionException.cs (rev 0)
+++ sandbox/maestro-3.0/OSGeo.MapGuide.MaestroAPI/Exceptions/ExpressionException.cs 2010-10-29 06:33:36 UTC (rev 5361)
@@ -0,0 +1,70 @@
+#region Disclaimer / License
+// Copyright (C) 2010, Jackie Ng
+// http://trac.osgeo.org/mapguide/wiki/maestro, jumpinjackie at gmail.com
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+//
+#endregion
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace OSGeo.MapGuide.MaestroAPI.Exceptions
+{
+ /// <summary>
+ /// Thrown when evaluating an expression fails
+ /// </summary>
+ [global::System.Serializable]
+ public class ExpressionException : MaestroException
+ {
+ //
+ // For guidelines regarding the creation of new exception types, see
+ // http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpgenref/html/cpconerrorraisinghandlingguidelines.asp
+ // and
+ // http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dncscol/html/csharp07192001.asp
+ //
+
+ /// <summary>
+ /// Initializes a new instance of the <see cref="ExpressionException"/> class.
+ /// </summary>
+ public ExpressionException() { }
+ /// <summary>
+ /// Initializes a new instance of the <see cref="ExpressionException"/> class.
+ /// </summary>
+ /// <param name="message">The message.</param>
+ public ExpressionException(string message) : base(message) { }
+ /// <summary>
+ /// Initializes a new instance of the <see cref="ExpressionException"/> class.
+ /// </summary>
+ /// <param name="message">The message.</param>
+ /// <param name="inner">The inner.</param>
+ public ExpressionException(string message, Exception inner) : base(message, inner) { }
+ /// <summary>
+ /// Initializes a new instance of the <see cref="ExpressionException"/> class.
+ /// </summary>
+ /// <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds the serialized object data about the exception being thrown.</param>
+ /// <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that contains contextual information about the source or destination.</param>
+ /// <exception cref="T:System.ArgumentNullException">
+ /// The <paramref name="info"/> parameter is null.
+ /// </exception>
+ /// <exception cref="T:System.Runtime.Serialization.SerializationException">
+ /// The class name is null or <see cref="P:System.Exception.HResult"/> is zero (0).
+ /// </exception>
+ protected ExpressionException(
+ System.Runtime.Serialization.SerializationInfo info,
+ System.Runtime.Serialization.StreamingContext context)
+ : base(info, context) { }
+ }
+}
Added: sandbox/maestro-3.0/OSGeo.MapGuide.MaestroAPI/Expression/ExpressionEngine.cs
===================================================================
--- sandbox/maestro-3.0/OSGeo.MapGuide.MaestroAPI/Expression/ExpressionEngine.cs (rev 0)
+++ sandbox/maestro-3.0/OSGeo.MapGuide.MaestroAPI/Expression/ExpressionEngine.cs 2010-10-29 06:33:36 UTC (rev 5361)
@@ -0,0 +1,146 @@
+#region Disclaimer / License
+// Copyright (C) 2010, Jackie Ng
+// http://trac.osgeo.org/mapguide/wiki/maestro, jumpinjackie at gmail.com
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+//
+#endregion
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Ciloci.Flee;
+using System.Reflection;
+using System.Globalization;
+
+namespace OSGeo.MapGuide.MaestroAPI.Expression
+{
+ /// <summary>
+ /// A FDO expression evaluation engine
+ /// </summary>
+ internal class ExpressionEngine
+ {
+ private FeatureSetReader _reader;
+ private ExpressionContext _context;
+
+ public ExpressionEngine(FeatureSetReader reader, CultureInfo ci)
+ {
+ _reader = reader;
+ //_cls = cls;
+ _context = new ExpressionContext();
+ _context.Options.ParseCulture = ci;
+ //Register standard FDO functions
+ _context.Imports.AddType(typeof(FdoFunctionNamespace));
+ //Register standard MapGuide function
+ _context.Imports.AddType(typeof(MgFunctionNamespace));
+ }
+
+ public void RegisterFunction(MethodInfo method, string @namespace)
+ {
+ _context.Imports.AddMethod(method, @namespace);
+ }
+
+ public void RegisterFunctions(Type functionType)
+ {
+ _context.Imports.AddType(functionType);
+ }
+
+ /*
+ public ExpressionEngine(FeatureSetReader reader, object customFunctions)
+ : this(reader)
+ {
+
+ }*/
+
+ /// <summary>
+ /// Updates the variables in the expression context. This is called by the reader
+ /// as part of advancing to the next feature.
+ /// </summary>
+ internal void UpdateVariables()
+ {
+ if (_reader.Row == null)
+ throw new InvalidOperationException("Current row is empty"); //LOCALIZEME
+
+ _context.Variables.Clear();
+ var row = _reader.Row;
+ for (int i = 0; i < row.FieldCount; i++)
+ {
+ string name = row.GetName(i);
+ object value = row[i];
+
+ _context.Variables.Add(name, value ?? DBNull.Value);
+ }
+ }
+
+ /// <summary>
+ /// Evalutes the expression against the current row
+ /// </summary>
+ /// <param name="expression"></param>
+ /// <returns></returns>
+ internal object Evaluate(string expression)
+ {
+ //Under FDO expression syntax:
+ //
+ // Double-quoted string literals represent identifiers
+ // Single-quoted string literals represent string literals
+ //
+ // So convert this to FLEE-compatible format by:
+ //
+ // Stripping double quotes (variables are not quoted)
+ // Convert single to double quotes (string literals are just CLR strings)
+ var exprText = expression.Replace("\"", string.Empty)
+ .Replace("'", "\"");
+
+ if (_reader.Row == null)
+ throw new InvalidOperationException("Unable to evaluate. Current row is empty"); //LOCALIZEME
+
+ try
+ {
+ var expr = _context.CompileDynamic(exprText);
+ return expr.Evaluate();
+ }
+ catch
+ {
+ return null;
+ }
+ }
+
+ /// <summary>
+ ///
+ /// </summary>
+ /// <typeparam name="T"></typeparam>
+ /// <param name="expression"></param>
+ /// <returns></returns>
+ internal T Evaluate<T>(string expression)
+ {
+ //Under FDO expression syntax:
+ //
+ // Double-quoted string literals represent identifiers
+ // Single-quoted string literals represent string literals
+ //
+ // So convert this to FLEE-compatible format by:
+ //
+ // Stripping double quotes (variables are not quoted)
+ // Convert single to double quotes (string literals are just CLR strings)
+ var exprText = expression.Replace("\"", string.Empty)
+ .Replace("'", "\"");
+
+ if (_reader.Row == null)
+ throw new InvalidOperationException("Unable to evaluate. Current row is empty"); //LOCALIZEME
+
+ var expr = _context.CompileGeneric<T>(exprText);
+ return expr.Evaluate();
+ }
+ }
+}
Added: sandbox/maestro-3.0/OSGeo.MapGuide.MaestroAPI/Expression/ExpressionFeatureReader.cs
===================================================================
--- sandbox/maestro-3.0/OSGeo.MapGuide.MaestroAPI/Expression/ExpressionFeatureReader.cs (rev 0)
+++ sandbox/maestro-3.0/OSGeo.MapGuide.MaestroAPI/Expression/ExpressionFeatureReader.cs 2010-10-29 06:33:36 UTC (rev 5361)
@@ -0,0 +1,154 @@
+#region Disclaimer / License
+// Copyright (C) 2010, Jackie Ng
+// http://trac.osgeo.org/mapguide/wiki/maestro, jumpinjackie at gmail.com
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+//
+#endregion
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Globalization;
+using OSGeo.MapGuide.MaestroAPI.Exceptions;
+
+namespace OSGeo.MapGuide.MaestroAPI.Expression
+{
+ /// <summary>
+ /// A <see cref="FeatureSetReader"/> that supports expression evaluation
+ /// </summary>
+ internal class ExpressionFeatureReader : FeatureSetReader
+ {
+ private ExpressionEngine _exprEngine;
+
+ private FeatureSetReader _reader;
+
+ /// <summary>
+ /// Initializes a new instance of the <see cref="ExpressionFeatureReader"/> class.
+ /// </summary>
+ /// <param name="reader">The reader.</param>
+ public ExpressionFeatureReader(FeatureSetReader reader)
+ : this(reader, System.Threading.Thread.CurrentThread.CurrentCulture)
+ {
+
+ }
+
+ /// <summary>
+ /// Initializes a new instance of the <see cref="ExpressionFeatureReader"/> class.
+ /// </summary>
+ /// <param name="reader">The reader.</param>
+ public ExpressionFeatureReader(FeatureSetReader reader, CultureInfo ci)
+ : base()
+ {
+ _reader = reader;
+ InitColumns(reader.Columns);
+ _exprEngine = new ExpressionEngine(_reader, ci);
+ }
+
+ /// <summary>
+ /// Advances the internal reader
+ /// </summary>
+ /// <returns></returns>
+ protected override bool ReadInternal()
+ {
+ return _reader.Read();
+ }
+
+ /// <summary>
+ /// Processes the feature row.
+ /// </summary>
+ /// <returns></returns>
+ protected override FeatureSetRow ProcessFeatureRow()
+ {
+ _exprEngine.UpdateVariables();
+ return _reader.Row;
+ }
+
+ /// <summary>
+ /// Closes the internal.
+ /// </summary>
+ protected override void CloseInternal()
+ {
+ _reader.Close();
+ }
+
+ /// <summary>
+ /// Gets a value indicating the depth of nesting for the current row.
+ /// </summary>
+ /// <value></value>
+ /// <returns>
+ /// The level of nesting.
+ /// </returns>
+ public override int Depth
+ {
+ get { return _reader.Depth; }
+ }
+
+ /// <summary>
+ /// Returns a <see cref="T:System.Data.DataTable"/> that describes the column metadata of the <see cref="T:System.Data.IDataReader"/>.
+ /// </summary>
+ /// <returns>
+ /// A <see cref="T:System.Data.DataTable"/> that describes the column metadata.
+ /// </returns>
+ /// <exception cref="T:System.InvalidOperationException">
+ /// The <see cref="T:System.Data.IDataReader"/> is closed.
+ /// </exception>
+ public override System.Data.DataTable GetSchemaTable()
+ {
+ return _reader.GetSchemaTable();
+ }
+
+ /// <summary>
+ /// Gets the number of rows changed, inserted, or deleted by execution of the SQL statement.
+ /// </summary>
+ /// <value></value>
+ /// <returns>
+ /// The number of rows changed, inserted, or deleted; 0 if no rows were affected or the statement failed; and -1 for SELECT statements.
+ /// </returns>
+ public override int RecordsAffected
+ {
+ get { return _reader.RecordsAffected; }
+ }
+
+ /// <summary>
+ /// Evaluates the specified expression against the current row. If evaluation
+ /// fails, null is returned.
+ /// </summary>
+ /// <param name="expression">The expression.</param>
+ /// <returns></returns>
+ public object Evaluate(string expression)
+ {
+ return _exprEngine.Evaluate(expression);
+ }
+
+ /// <summary>
+ /// Evaluates the specified expression returning a strongly-typed value
+ /// </summary>
+ /// <typeparam name="T"></typeparam>
+ /// <param name="expression"></param>
+ /// <returns>The evaluated result</returns>
+ /// <exception cref="ExpressionException">Thrown if evaluation fails</exception>
+ public T Evaluate<T>(string expression)
+ {
+ try
+ {
+ return _exprEngine.Evaluate<T>(expression);
+ }
+ catch
+ {
+ throw new ExpressionException(expression);
+ }
+ }
+ }
+}
Added: sandbox/maestro-3.0/OSGeo.MapGuide.MaestroAPI/Expression/FdoFunctionNamespace.cs
===================================================================
--- sandbox/maestro-3.0/OSGeo.MapGuide.MaestroAPI/Expression/FdoFunctionNamespace.cs (rev 0)
+++ sandbox/maestro-3.0/OSGeo.MapGuide.MaestroAPI/Expression/FdoFunctionNamespace.cs 2010-10-29 06:33:36 UTC (rev 5361)
@@ -0,0 +1,441 @@
+#region Disclaimer / License
+// Copyright (C) 2010, Jackie Ng
+// http://trac.osgeo.org/mapguide/wiki/maestro, jumpinjackie at gmail.com
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+//
+#endregion
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Topology.Geometries;
+
+namespace OSGeo.MapGuide.MaestroAPI.Expression
+{
+ /// <summary>
+ /// Expression class that implements the standard FDO expression functions.
+ ///
+ /// Despite the modifier. This class is for Expression Engine use only.
+ /// </summary>
+ public static class FdoFunctionNamespace
+ {
+ //
+ // NOTE: ExpressionEngine will auto-coerce null values to DBNull.Value so when
+ // testing for nulls, test for DBNull.Value
+ //
+
+ #region Aggregate
+ #endregion
+
+ #region Conversion
+ public static object NullValue(object first, object second)
+ {
+ return first == DBNull.Value ? second : first;
+ }
+
+ public static DateTime ToDate(string str)
+ {
+ return DateTime.Parse(str);
+ }
+
+ public static double ToDouble(object value)
+ {
+ return Convert.ToDouble(value);
+ }
+
+ public static float ToFloat(object value)
+ {
+ return Convert.ToSingle(value);
+ }
+
+ public static int ToInt32(object value)
+ {
+ return Convert.ToInt32(value);
+ }
+
+ public static long ToInt64(object value)
+ {
+ return Convert.ToInt64(value);
+ }
+
+ public static string ToString(object value)
+ {
+ return Coalesce(value);
+ }
+ #endregion
+
+ #region Date
+ public static DateTime AddMonths(object value, object months)
+ {
+ return Convert.ToDateTime(value).AddMonths(Convert.ToInt32(months));
+ }
+
+ public static DateTime CurrentDate()
+ {
+ return DateTime.Now;
+ }
+
+ public static DateTime Extract(object date, object fromDate)
+ {
+ throw new NotImplementedException();
+ }
+
+ public static double ExtractToDouble(object date, object fromDate)
+ {
+ throw new NotImplementedException();
+ }
+
+ public static int ExtractToInt(object date, object fromDate)
+ {
+ throw new NotImplementedException();
+ }
+ #endregion
+
+ #region Geometry
+
+ public static double Area2D(IGeometry geom)
+ {
+ return geom.Area;
+ }
+
+ public static double Length2D(IGeometry geom)
+ {
+ return geom.Length;
+ }
+
+ public static double M(IGeometry geom)
+ {
+ return double.NaN; //M dimensions not supported
+ }
+
+ public static double X(IGeometry geom)
+ {
+ var pt = geom as IPoint;
+ if (pt != null)
+ return pt.X;
+
+ return double.NaN;
+ }
+
+ public static double Y(IGeometry geom)
+ {
+ var pt = geom as IPoint;
+ if (pt != null)
+ return pt.Y;
+
+ return double.NaN;
+ }
+
+ public static double Z(IGeometry geom)
+ {
+ var pt = geom as IPoint;
+ if (pt != null)
+ return pt.Z;
+
+ return double.NaN;
+ }
+
+ #endregion
+
+ #region Math
+ public static double Abs(object value)
+ {
+ return Math.Abs(Convert.ToDouble(value));
+ }
+
+ public static double Acos(object value)
+ {
+ return Math.Acos(Convert.ToDouble(value));
+ }
+
+ public static double Asin(object value)
+ {
+ return Math.Asin(Convert.ToDouble(value));
+ }
+
+ public static double Atan(object value)
+ {
+ return Math.Atan(Convert.ToDouble(value));
+ }
+
+ public static double Atan2(object y, object x)
+ {
+ return Math.Atan2(Convert.ToDouble(y), Convert.ToDouble(x));
+ }
+
+ public static double Cos(object value)
+ {
+ return Math.Cos(Convert.ToDouble(value));
+ }
+
+ public static double Exp(object value)
+ {
+ return Math.Exp(Convert.ToDouble(value));
+ }
+
+ public static double Ln(object value)
+ {
+ return Math.Log(Convert.ToDouble(value));
+ }
+
+ public static double Log(object @base, object value)
+ {
+ return Math.Log(Convert.ToDouble(value), Convert.ToDouble(@base));
+ }
+
+ public static double Mod(object value, object divisor)
+ {
+ return Convert.ToDouble(value) % Convert.ToDouble(divisor);
+ }
+
+ public static double Power(double value, double power)
+ {
+ return Math.Pow(value, power);
+ }
+
+ public static int Power(int value, int power)
+ {
+ return Convert.ToInt32(Math.Pow(value, power));
+ }
+
+ public static double Remainder(object value, object divisor)
+ {
+ return Convert.ToDouble(value) % Convert.ToDouble(divisor);
+ }
+
+ public static double Sin(object value)
+ {
+ return Math.Sin(Convert.ToDouble(value));
+ }
+
+ public static double Sqrt(object value)
+ {
+ return Math.Sqrt(Convert.ToDouble(value));
+ }
+
+ public static double Tan(object value)
+ {
+ return Math.Tan(Convert.ToDouble(value));
+ }
+ #endregion
+
+ #region Numeric
+
+ public static double Ceil(double value)
+ {
+ return Math.Ceiling(value);
+ }
+
+ public static double Floor(double value)
+ {
+ return Math.Floor(value);
+ }
+
+ public static double Round(double value)
+ {
+ return Math.Round(value);
+ }
+
+ public static double Sign(double value)
+ {
+ return Math.Sign(value);
+ }
+
+ public static double Trunc(double value)
+ {
+ return Math.Truncate(value);
+ }
+ #endregion
+
+ #region String
+ /// <summary>
+ /// Returns a concatenated result of 2 string expressions
+ /// </summary>
+ /// <param name="a"></param>
+ /// <param name="b"></param>
+ /// <returns></returns>
+ public static string Concat(object a, object b)
+ {
+ return Coalesce(a) + Coalesce(b);
+ }
+
+ private static string Coalesce(object obj)
+ {
+ return (obj == null || obj == DBNull.Value) ? string.Empty : obj.ToString();
+ }
+
+ /// <summary>
+ /// Returns a concatentated result of 2 or more string expressions
+ /// </summary>
+ /// <param name="a"></param>
+ /// <param name="args"></param>
+ /// <returns></returns>
+ public static string Concat(object a, params object[] args)
+ {
+ StringBuilder sb = new StringBuilder(Coalesce(a));
+ foreach (var str in args)
+ {
+ sb.Append(Coalesce(str));
+ }
+ return sb.ToString();
+ }
+
+ /// <summary>
+ /// Returns the position of a string within a base string
+ /// </summary>
+ /// <param name="str"></param>
+ /// <param name="searchText"></param>
+ /// <returns></returns>
+ public static int Instr(object str, object searchText)
+ {
+ return Coalesce(str).IndexOf(Coalesce(searchText));
+ }
+
+ /// <summary>
+ /// Determines the length of a string expression
+ /// </summary>
+ /// <param name="str"></param>
+ /// <returns></returns>
+ public static int Length(object str)
+ {
+ return Coalesce(str).Length;
+ }
+
+ /// <summary>
+ /// Converts all upper case letters in the string expression to lower case
+ /// </summary>
+ /// <param name="str"></param>
+ /// <returns></returns>
+ public static string Lower(object str)
+ {
+ return Coalesce(str).ToLower();
+ }
+
+ /// <summary>
+ /// Pads a string expression as directed to the left
+ /// </summary>
+ /// <param name="str"></param>
+ /// <returns></returns>
+ public static string Lpad(object str)
+ {
+ throw new NotImplementedException();
+ }
+
+ /// <summary>
+ /// Trims a string expression to the left
+ /// </summary>
+ /// <param name="str"></param>
+ /// <returns></returns>
+ public static string Ltrim(object str)
+ {
+ return Coalesce(str).TrimStart();
+ }
+
+ /// <summary>
+ /// Pads a string expression as directed to the right
+ /// </summary>
+ /// <param name="str"></param>
+ /// <returns></returns>
+ public static string Rpad(object str)
+ {
+ throw new NotImplementedException();
+ }
+
+ /// <summary>
+ /// Trims a string expression to the right
+ /// </summary>
+ /// <param name="str"></param>
+ /// <returns></returns>
+ public static string Rtrim(object str)
+ {
+ return Coalesce(str).TrimEnd();
+ }
+
+ /// <summary>
+ /// Returns the phonetic representation of a string expression
+ /// </summary>
+ /// <param name="str"></param>
+ /// <returns></returns>
+ public static string Soundex(object str)
+ {
+ // +---------------------------------------------------------------------------
+ // | The function processes a call to the function SOUNDEX.
+ // | NOTE:
+ // | The implementation of the function utilizes the following algorithm:
+ // |
+ // | Step 1: Capitalize all letters in the word and remove all punctation
+ // | marks and digits.
+ // | Step 2: Retain the first letter of the word.
+ // | Step 3: Replace any letter from the set {A, E, I, O, U, H, W, Y} with
+ // | a 0 (zero).
+ // | Step 4: Replace any letter from the set {B, F, P, V} with a 1.
+ // | Replace any letter from the set {C, G, J, K, Q, S, X, Z) with
+ // | a 2
+ // | Replace any letter from the set {D, T) with a 3
+ // | Replace any letter from the set {L) with a 4
+ // | Replace any letter from the set {M, N) with a 5
+ // | Replace any letter from the set {R) with a 6
+ // | Step 5: Remove all pairs of digits which occur beside each other from
+ // | the that resulted from step 4.
+ // | Step 6: Remove all the zeros from the string that resulted from step 5.
+ // | Step 7: Pad the string resulting from step 6 with trailing zeros and
+ // | return the first 4 positions (resulting in a string of the
+ // | structure <letter><number><number><number>).
+ // +---------------------------------------------------------------------------
+ throw new NotImplementedException();
+ }
+
+ /// <summary>
+ /// Returns a substring from the provided string as defined
+ /// </summary>
+ /// <param name="str"></param>
+ /// <param name="position"></param>
+ /// <returns></returns>
+ public static string Substr(object str, object position)
+ {
+ return Coalesce(str).Substring(Convert.ToInt32(position));
+ }
+
+ public static string Translate(object str, object from, object to)
+ {
+ // Navigate through the source string and execute the replacement. The
+ // following rules apply:
+ //
+ // - any character in the from-set is replaced with the character in
+ // the to-set at the same position.
+ // - if the character in the from-set does not have a replacement
+ // character in the to-set at the same position, the character is
+ // deleted.
+ //
+ // NOTE: It is not possible to use the function REPLACE offered with the
+ // class FdoStringP because this may result in incorrect results.
+ // For example, if the call is TRANSLATE('abcd', 'ae', 'eS'), the
+ // result should be 'ebcd', not 'Sbcd' which would be the case if
+ // the mentioned function is used to do the job.
+ throw new NotImplementedException();
+ }
+
+ public static string Trim(object str)
+ {
+ return Coalesce(str).Trim();
+ }
+
+ public static string Upper(object str)
+ {
+ return Coalesce(str).ToUpper();
+ }
+ #endregion
+ }
+}
Added: sandbox/maestro-3.0/OSGeo.MapGuide.MaestroAPI/Expression/MgFunctionNamespace.cs
===================================================================
--- sandbox/maestro-3.0/OSGeo.MapGuide.MaestroAPI/Expression/MgFunctionNamespace.cs (rev 0)
+++ sandbox/maestro-3.0/OSGeo.MapGuide.MaestroAPI/Expression/MgFunctionNamespace.cs 2010-10-29 06:33:36 UTC (rev 5361)
@@ -0,0 +1,41 @@
+#region Disclaimer / License
+// Copyright (C) 2010, Jackie Ng
+// http://trac.osgeo.org/mapguide/wiki/maestro, jumpinjackie at gmail.com
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+//
+#endregion
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace OSGeo.MapGuide.MaestroAPI.Expression
+{
+ /// <summary>
+ /// Expression class that implements the standard MapGuide FDO expression functions
+ ///
+ /// Despite the modifier. This class is for Expression Engine use only.
+ /// </summary>
+ public static class MgFunctionNamespace
+ {
+ public static object If(bool condition, object trueValue, object falseValue)
+ {
+ return condition ? trueValue : falseValue;
+ }
+
+ // Lookup()
+ // Range()
+ }
+}
Modified: sandbox/maestro-3.0/OSGeo.MapGuide.MaestroAPI/Feature/FeatureSetReader.cs
===================================================================
--- sandbox/maestro-3.0/OSGeo.MapGuide.MaestroAPI/Feature/FeatureSetReader.cs 2010-10-29 03:11:03 UTC (rev 5360)
+++ sandbox/maestro-3.0/OSGeo.MapGuide.MaestroAPI/Feature/FeatureSetReader.cs 2010-10-29 06:33:36 UTC (rev 5361)
@@ -515,7 +515,7 @@
/// Gets the <see cref="System.Object"/> with the specified name.
/// </summary>
/// <value></value>
- public object this[string name]
+ public virtual object this[string name]
{
get { return m_row[name]; }
}
Modified: sandbox/maestro-3.0/OSGeo.MapGuide.MaestroAPI/OSGeo.MapGuide.MaestroAPI.csproj
===================================================================
--- sandbox/maestro-3.0/OSGeo.MapGuide.MaestroAPI/OSGeo.MapGuide.MaestroAPI.csproj 2010-10-29 03:11:03 UTC (rev 5360)
+++ sandbox/maestro-3.0/OSGeo.MapGuide.MaestroAPI/OSGeo.MapGuide.MaestroAPI.csproj 2010-10-29 06:33:36 UTC (rev 5361)
@@ -32,6 +32,10 @@
<DocumentationFile>..\SDK\bin\Release\OSGeo.MapGuide.MaestroAPI.XML</DocumentationFile>
</PropertyGroup>
<ItemGroup>
+ <Reference Include="Ciloci.Flee, Version=0.9.26.0, Culture=neutral, PublicKeyToken=c8526a021ef298ed, processorArchitecture=MSIL">
+ <SpecificVersion>False</SpecificVersion>
+ <HintPath>..\Thirdparty\Flee\lib\Ciloci.Flee.dll</HintPath>
+ </Reference>
<Reference Include="System" />
<Reference Include="System.Data" />
<Reference Include="System.Drawing" />
@@ -169,12 +173,17 @@
<Compile Include="Commands\ExecuteLoadProcedure.cs" />
<Compile Include="Commands\ICommand.cs" />
<Compile Include="Exceptions\CustomPropertyNotFoundException.cs" />
+ <Compile Include="Exceptions\ExpressionException.cs" />
<Compile Include="Exceptions\MaestroException.cs" />
<Compile Include="Exceptions\NestedExceptionMessageProcessor.cs" />
<Compile Include="Exceptions\ResourceConversionException.cs" />
<Compile Include="Exceptions\SerializationException.cs" />
<Compile Include="Exceptions\UnsupportedResourceTypeException.cs" />
<Compile Include="Exceptions\UnsupportedServiceTypeException.cs" />
+ <Compile Include="Expression\ExpressionEngine.cs" />
+ <Compile Include="Expression\ExpressionFeatureReader.cs" />
+ <Compile Include="Expression\FdoFunctionNamespace.cs" />
+ <Compile Include="Expression\MgFunctionNamespace.cs" />
<Compile Include="Feature\ClassDefinition.cs" />
<Compile Include="IConnectionCapabilities.cs" />
<Compile Include="MaestroApiProviderAttribute.cs" />
Added: sandbox/maestro-3.0/Thirdparty/Flee/ReleaseNotes.txt
===================================================================
--- sandbox/maestro-3.0/Thirdparty/Flee/ReleaseNotes.txt (rev 0)
+++ sandbox/maestro-3.0/Thirdparty/Flee/ReleaseNotes.txt 2010-10-29 06:33:36 UTC (rev 5361)
@@ -0,0 +1,17 @@
+Flee - Fast Lightweight Expression Evaluator
+Eugene Ciloci
+http://www.codeplex.com/Flee
+-------------
+
+Version: 0.9.26.0
+Release Date: June 17, 2009
+
+New features:
+-ExpressionOptions.RealLiteralDataType: Specify the data type used to store real literals
+-Decimal literals (ie: 123.45M + 3.45M)
+-Optimization: A number raised to a constant integral power (ie: num1 ^ 2) will be optimized to a sequence of multiplications instead of a call to the Pow function
+
+Breaking Changes:
+-The result of the power operator is now of the same type as its first argument. Example: 100 ^ 2 will return an integer; 1.5 ^ 2 will return a double. Previously, the power operator always returned a double.
+
+Bug fixes:
Added: sandbox/maestro-3.0/Thirdparty/Flee/lib/Ciloci.Flee.chm
===================================================================
(Binary files differ)
Property changes on: sandbox/maestro-3.0/Thirdparty/Flee/lib/Ciloci.Flee.chm
___________________________________________________________________
Added: svn:mime-type
+ application/octet-stream
Added: sandbox/maestro-3.0/Thirdparty/Flee/lib/Ciloci.Flee.dll
===================================================================
(Binary files differ)
Property changes on: sandbox/maestro-3.0/Thirdparty/Flee/lib/Ciloci.Flee.dll
___________________________________________________________________
Added: svn:mime-type
+ application/octet-stream
Added: sandbox/maestro-3.0/Thirdparty/Flee/lib/Ciloci.Flee.xml
===================================================================
--- sandbox/maestro-3.0/Thirdparty/Flee/lib/Ciloci.Flee.xml (rev 0)
+++ sandbox/maestro-3.0/Thirdparty/Flee/lib/Ciloci.Flee.xml 2010-10-29 06:33:36 UTC (rev 5361)
@@ -0,0 +1,2172 @@
+<?xml version="1.0"?>
+<doc>
+<assembly>
+<name>
+Ciloci.Flee
+</name>
+</assembly>
+<members>
+<member name="T:Ciloci.Flee.CompileErrorResourceKeys">
+ <summary>
+ Resource keys for compile error messages
+ </summary>
+ <remarks></remarks>
+</member><member name="E:Ciloci.Flee.VariableCollection.ResolveVariableType">
+ <summary>
+ Occurs when an expression needs the type of a variable.
+ </summary>
+ <remarks>This event is raised when an expression references a variable that doesn't exist in its variable collection. You can handle this event to provide on-demand variables.</remarks>
+</member><member name="E:Ciloci.Flee.VariableCollection.ResolveVariableValue">
+ <summary>
+ Occurs when an expression needs the value of a variable.
+ </summary>
+ <remarks>This event is raised when an expression references a variable that doesn't exist in its variable collection. You can handle this event to provide on-demand variables.</remarks>
+</member><member name="E:Ciloci.Flee.VariableCollection.ResolveFunction">
+ <summary>
+ Occurs when an expression needs the return type of a function.
+ </summary>
+ <remarks>
+ This event is raised when an expression references a function that doesn't exist on the expression owner or imports. By handling this event and providing a value for the <see cref="P:Ciloci.Flee.ResolveFunctionEventArgs.ReturnType"/> property, you can implement an on-demand function.
+ </remarks>
+</member><member name="E:Ciloci.Flee.VariableCollection.InvokeFunction">
+ <summary>
+ Occurs when an expression needs the return value of a function.
+ </summary>
+ <remarks>
+ This event is raised when an expression needs the return value of an on-demand function. By handling this event and providing a value for the <see cref="P:Ciloci.Flee.InvokeFunctionEventArgs.Result"/> property, you can invoke your on-demand function.
+ </remarks>
+</member><member name="M:Ciloci.Flee.VariableCollection.CreateVariable(System.Type,System.Object)">
+ <summary>
+ Create a variable
+ </summary>
+ <param name="variableValueType">The variable's type</param>
+ <param name="variableValue">The actual value; may be null</param>
+ <returns>A new variable for the value</returns>
+ <remarks></remarks>
+</member><member name="M:Ciloci.Flee.VariableCollection.GetVariableType(System.String)">
+ <summary>
+ Gets the type of a variable.
+ </summary>
+ <param name="name">The name of the variable</param>
+ <returns>The type of the variable's value</returns>
+ <remarks>Use this method to get the type of the value of a variable.</remarks>
+</member><member name="M:Ciloci.Flee.VariableCollection.DefineVariable(System.String,System.Type)">
+ <summary>
+ Defines a variable with a specific type.
+ </summary>
+ <param name="name">The name of the variable</param>
+ <param name="variableType">The type of the new variable</param>
+ <remarks>Use this method when you want to add a variable with a type that is different than what would be inferred from defining it using the indexer.</remarks>
+</member><member name="M:Ciloci.Flee.VariableCollection.GetVariableValueInternal``1(System.String)">
+ <summary>Gets the value of a variable</summary>
+ <typeparam name="T">The type of the variable's value</typeparam>
+ <param name="name">The name of the variable</param>
+ <returns>The variable's value</returns>
+ <remarks>This method is used by the expression to retrieve the values of variables during evaluation. It must be public so that all expressions
+ can access it. It is meant for internal use and you shouldn't depend on any of its functionality.</remarks>
+</member><member name="M:Ciloci.Flee.VariableCollection.GetVirtualPropertyValueInternal``1(System.String,System.Object)">
+ <summary>Gets the result of a virtual property</summary>
+ <typeparam name="T">The type of the result's value</typeparam>
+ <param name="name">The name of the property</param>
+ <returns>The property's value</returns>
+ <remarks>
+ This method is used by the expression to retrieve the values of virtual properties during evaluation. It must be public so that all expressions
+ can access it. It is meant for internal use and you shouldn't depend on any of its functionality.
+ </remarks>
+</member><member name="M:Ciloci.Flee.VariableCollection.GetFunctionResultInternal``1(System.String,System.Object[])">
+ <summary>Gets the result of an on-demand function</summary>
+ <typeparam name="T">The type of the result's value</typeparam>
+ <param name="name">The name of the function</param>
+ <returns>The function's result</returns>
+ <remarks>
+ This method is used by the expression to retrieve the values of on-demand functions during evaluation. It must be public so that all expressions
+ can access it. It is meant for internal use and you shouldn't depend on any of its functionality.
+ </remarks>
+</member><member name="M:Ciloci.Flee.VariableCollection.Clear">
+ <summary>Removes all variables from the collection.</summary>
+ <remarks>Use this method to remove all variables from the collection</remarks>
+</member><member name="M:Ciloci.Flee.VariableCollection.Add(System.String,System.Object)">
+ <summary>Adds a variable to the collection.</summary>
+ <param name="name">The name of the variable</param>
+ <param name="value">The value of the variable</param>
+ <remarks>Use this method to add a variable to the collection</remarks>
+</member><member name="M:Ciloci.Flee.VariableCollection.ContainsKey(System.String)">
+ <summary>Determines if the collection contains a variable.</summary>
+ <param name="name">The name of the variable</param>
+ <returns>True if the collection has a variable with the given name; False otherwise</returns>
+ <remarks>Use this method to determine if the collection contains a variable</remarks>
+</member><member name="M:Ciloci.Flee.VariableCollection.Remove(System.String)">
+ <summary>Removes a variable from the collection.</summary>
+ <param name="name">The name of the variable</param>
+ <remarks>Use this method to remove a variable from the collection</remarks>
+</member><member name="M:Ciloci.Flee.VariableCollection.TryGetValue(System.String,System.Object@)">
+ <summary>Gets the value of a variable in the collection.</summary>
+ <param name="name">The name of the variable</param>
+ <param name="value">The location to store the value of the variable</param>
+ <returns>True if the collection contains a variable with the given name; False otherwise</returns>
+ <remarks>Use this method to get the value of a variable in the collection</remarks>
+</member><member name="P:Ciloci.Flee.VariableCollection.Count">
+ <summary>Gets the number of variables defined in the collection.</summary>
+ <returns>The number of variables in the collection</returns>
+ <remarks>Use this method to get a count of the number of variables in the collection</remarks>
+</member><member name="P:Ciloci.Flee.VariableCollection.Item(System.String)">
+ <summary>Gets or sets the value of a variable.</summary>
+ <param name="name">The name of the variable</param>
+ <returns>The value of the variable</returns>
+ <remarks>
+ Use this method to get or set the value of a variable. If a variable with the given name does not exist, a new variable will be defined. Otherwise, the
+ value of the existing variable will be overwritten.
+ </remarks>
+ <exception cref="T:System.ArgumentException">The type of the new value is not compatible with the type of the existing variable</exception>
+</member><member name="P:Ciloci.Flee.VariableCollection.Keys">
+ <summary>Gets a collection with the names of all variables.</summary>
+ <returns>A collection with all the names</returns>
+ <remarks>Use this method to access all the variable names in the collection</remarks>
+</member><member name="P:Ciloci.Flee.VariableCollection.Values">
+ <summary>Gets a collection with the values of all variables.</summary>
+ <returns>A collection with all the values</returns>
+ <remarks>Use this method to access all the variable values in the collection</remarks>
+</member><member name="T:Ciloci.Flee.VariableCollection">
+ <summary>
+ Manages the variables available to an expression
+ </summary>
+ <remarks>
+ Use this class to manage the variables that an expression can use
+ </remarks>
+</member><member name="M:Ciloci.Flee.ExpressionTokenizer.#ctor(System.IO.TextReader,Ciloci.Flee.ExpressionContext)">
+ <summary>Creates a new tokenizer for the specified input
+stream.</summary>
+ <param name="input">the input stream to read</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParserCreationException">if the tokenizer
+couldn't be initialized correctly</exception>
+</member><member name="M:Ciloci.Flee.ExpressionTokenizer.#ctor(System.IO.TextReader)">
+ <summary>Creates a new tokenizer for the specified input
+stream.</summary>
+ <param name="input">the input stream to read</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParserCreationException">if the tokenizer
+couldn't be initialized correctly</exception>
+</member><member name="M:Ciloci.Flee.ExpressionTokenizer.CreatePatterns">
+ <summary>Initializes the tokenizer by creating all the token
+patterns.</summary>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParserCreationException">if the tokenizer
+couldn't be initialized correctly</exception>
+</member><member name="T:Ciloci.Flee.ExpressionTokenizer">
+ <remarks>A character stream tokenizer.</remarks>
+</member><member name="T:Ciloci.Flee.ExpressionParser.SynteticPatterns">
+ <summary>An enumeration with the generated production node
+identity constants.</summary>
+</member><member name="M:Ciloci.Flee.ExpressionParser.#ctor(System.IO.TextReader)">
+ <summary>Creates a new parser.</summary>
+ <param name="input">the input stream to read from</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParserCreationException">if the parser
+couldn't be initialized correctly</exception>
+</member><member name="M:Ciloci.Flee.ExpressionParser.#ctor(System.IO.TextReader,Ciloci.Flee.PerCederberg.Grammatica.Runtime.Analyzer)">
+ <summary>Creates a new parser.</summary>
+ <param name="input">the input stream to read from</param>
+ <param name="analyzer">the analyzer to parse with</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParserCreationException">if the parser
+couldn't be initialized correctly</exception>
+</member><member name="M:Ciloci.Flee.ExpressionParser.CreatePatterns">
+ <summary>Initializes the parser by creating all the production
+patterns.</summary>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParserCreationException">if the parser
+couldn't be initialized correctly</exception>
+</member><member name="T:Ciloci.Flee.ExpressionParser">
+ <remarks>A token stream parser.</remarks>
+</member><member name="T:Ciloci.Flee.ExpressionConstants">
+ <remarks>An enumeration with token and production node
+constants.</remarks>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.Enter(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Node)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.Exit(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Node)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.Child(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production,Ciloci.Flee.PerCederberg.Grammatica.Runtime.Node)">
+ <summary>Called when adding a child to a parse tree
+node.</summary>
+ <param name="node">the parent node</param>
+ <param name="child">the child node, or null</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterAdd(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitAdd(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterSub(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitSub(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterMul(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitMul(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterDiv(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitDiv(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterPower(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitPower(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterMod(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitMod(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterLeftParen(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitLeftParen(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterRightParen(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitRightParen(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterLeftBrace(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitLeftBrace(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterRightBrace(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitRightBrace(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterEq(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitEq(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterLt(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitLt(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterGt(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitGt(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterLte(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitLte(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterGte(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitGte(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterNe(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitNe(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterAnd(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitAnd(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterOr(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitOr(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterXor(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitXor(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterNot(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitNot(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterIn(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitIn(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterDot(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitDot(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterArgumentSeparator(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitArgumentSeparator(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterArrayBraces(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitArrayBraces(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterLeftShift(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitLeftShift(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterRightShift(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitRightShift(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterInteger(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitInteger(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterReal(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitReal(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterStringLiteral(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitStringLiteral(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterCharLiteral(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitCharLiteral(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterTrue(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitTrue(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterFalse(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitFalse(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterIdentifier(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitIdentifier(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterHexLiteral(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitHexLiteral(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterNullLiteral(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitNullLiteral(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterTimespan(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitTimespan(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterDatetime(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitDatetime(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterIf(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitIf(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterCast(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitCast(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Token)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ChildExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production,Ciloci.Flee.PerCederberg.Grammatica.Runtime.Node)">
+ <summary>Called when adding a child to a parse tree
+node.</summary>
+ <param name="node">the parent node</param>
+ <param name="child">the child node, or null</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterXorExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitXorExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ChildXorExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production,Ciloci.Flee.PerCederberg.Grammatica.Runtime.Node)">
+ <summary>Called when adding a child to a parse tree
+node.</summary>
+ <param name="node">the parent node</param>
+ <param name="child">the child node, or null</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterOrExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitOrExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ChildOrExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production,Ciloci.Flee.PerCederberg.Grammatica.Runtime.Node)">
+ <summary>Called when adding a child to a parse tree
+node.</summary>
+ <param name="node">the parent node</param>
+ <param name="child">the child node, or null</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterAndExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitAndExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ChildAndExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production,Ciloci.Flee.PerCederberg.Grammatica.Runtime.Node)">
+ <summary>Called when adding a child to a parse tree
+node.</summary>
+ <param name="node">the parent node</param>
+ <param name="child">the child node, or null</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterNotExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitNotExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ChildNotExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production,Ciloci.Flee.PerCederberg.Grammatica.Runtime.Node)">
+ <summary>Called when adding a child to a parse tree
+node.</summary>
+ <param name="node">the parent node</param>
+ <param name="child">the child node, or null</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterInExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitInExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ChildInExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production,Ciloci.Flee.PerCederberg.Grammatica.Runtime.Node)">
+ <summary>Called when adding a child to a parse tree
+node.</summary>
+ <param name="node">the parent node</param>
+ <param name="child">the child node, or null</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterInTargetExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitInTargetExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ChildInTargetExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production,Ciloci.Flee.PerCederberg.Grammatica.Runtime.Node)">
+ <summary>Called when adding a child to a parse tree
+node.</summary>
+ <param name="node">the parent node</param>
+ <param name="child">the child node, or null</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterInListTargetExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitInListTargetExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ChildInListTargetExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production,Ciloci.Flee.PerCederberg.Grammatica.Runtime.Node)">
+ <summary>Called when adding a child to a parse tree
+node.</summary>
+ <param name="node">the parent node</param>
+ <param name="child">the child node, or null</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterCompareExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitCompareExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ChildCompareExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production,Ciloci.Flee.PerCederberg.Grammatica.Runtime.Node)">
+ <summary>Called when adding a child to a parse tree
+node.</summary>
+ <param name="node">the parent node</param>
+ <param name="child">the child node, or null</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterShiftExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitShiftExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ChildShiftExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production,Ciloci.Flee.PerCederberg.Grammatica.Runtime.Node)">
+ <summary>Called when adding a child to a parse tree
+node.</summary>
+ <param name="node">the parent node</param>
+ <param name="child">the child node, or null</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterAdditiveExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitAdditiveExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ChildAdditiveExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production,Ciloci.Flee.PerCederberg.Grammatica.Runtime.Node)">
+ <summary>Called when adding a child to a parse tree
+node.</summary>
+ <param name="node">the parent node</param>
+ <param name="child">the child node, or null</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterMultiplicativeExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitMultiplicativeExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ChildMultiplicativeExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production,Ciloci.Flee.PerCederberg.Grammatica.Runtime.Node)">
+ <summary>Called when adding a child to a parse tree
+node.</summary>
+ <param name="node">the parent node</param>
+ <param name="child">the child node, or null</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterPowerExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitPowerExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ChildPowerExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production,Ciloci.Flee.PerCederberg.Grammatica.Runtime.Node)">
+ <summary>Called when adding a child to a parse tree
+node.</summary>
+ <param name="node">the parent node</param>
+ <param name="child">the child node, or null</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterNegateExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitNegateExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ChildNegateExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production,Ciloci.Flee.PerCederberg.Grammatica.Runtime.Node)">
+ <summary>Called when adding a child to a parse tree
+node.</summary>
+ <param name="node">the parent node</param>
+ <param name="child">the child node, or null</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterMemberExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitMemberExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ChildMemberExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production,Ciloci.Flee.PerCederberg.Grammatica.Runtime.Node)">
+ <summary>Called when adding a child to a parse tree
+node.</summary>
+ <param name="node">the parent node</param>
+ <param name="child">the child node, or null</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterMemberAccessExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitMemberAccessExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ChildMemberAccessExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production,Ciloci.Flee.PerCederberg.Grammatica.Runtime.Node)">
+ <summary>Called when adding a child to a parse tree
+node.</summary>
+ <param name="node">the parent node</param>
+ <param name="child">the child node, or null</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterBasicExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitBasicExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ChildBasicExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production,Ciloci.Flee.PerCederberg.Grammatica.Runtime.Node)">
+ <summary>Called when adding a child to a parse tree
+node.</summary>
+ <param name="node">the parent node</param>
+ <param name="child">the child node, or null</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterMemberFunctionExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitMemberFunctionExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ChildMemberFunctionExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production,Ciloci.Flee.PerCederberg.Grammatica.Runtime.Node)">
+ <summary>Called when adding a child to a parse tree
+node.</summary>
+ <param name="node">the parent node</param>
+ <param name="child">the child node, or null</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterFieldPropertyExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitFieldPropertyExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ChildFieldPropertyExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production,Ciloci.Flee.PerCederberg.Grammatica.Runtime.Node)">
+ <summary>Called when adding a child to a parse tree
+node.</summary>
+ <param name="node">the parent node</param>
+ <param name="child">the child node, or null</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterSpecialFunctionExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitSpecialFunctionExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ChildSpecialFunctionExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production,Ciloci.Flee.PerCederberg.Grammatica.Runtime.Node)">
+ <summary>Called when adding a child to a parse tree
+node.</summary>
+ <param name="node">the parent node</param>
+ <param name="child">the child node, or null</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterIfExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitIfExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ChildIfExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production,Ciloci.Flee.PerCederberg.Grammatica.Runtime.Node)">
+ <summary>Called when adding a child to a parse tree
+node.</summary>
+ <param name="node">the parent node</param>
+ <param name="child">the child node, or null</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterCastExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitCastExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ChildCastExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production,Ciloci.Flee.PerCederberg.Grammatica.Runtime.Node)">
+ <summary>Called when adding a child to a parse tree
+node.</summary>
+ <param name="node">the parent node</param>
+ <param name="child">the child node, or null</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterCastTypeExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitCastTypeExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ChildCastTypeExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production,Ciloci.Flee.PerCederberg.Grammatica.Runtime.Node)">
+ <summary>Called when adding a child to a parse tree
+node.</summary>
+ <param name="node">the parent node</param>
+ <param name="child">the child node, or null</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterIndexExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitIndexExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ChildIndexExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production,Ciloci.Flee.PerCederberg.Grammatica.Runtime.Node)">
+ <summary>Called when adding a child to a parse tree
+node.</summary>
+ <param name="node">the parent node</param>
+ <param name="child">the child node, or null</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterFunctionCallExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitFunctionCallExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ChildFunctionCallExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production,Ciloci.Flee.PerCederberg.Grammatica.Runtime.Node)">
+ <summary>Called when adding a child to a parse tree
+node.</summary>
+ <param name="node">the parent node</param>
+ <param name="child">the child node, or null</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterArgumentList(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitArgumentList(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ChildArgumentList(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production,Ciloci.Flee.PerCederberg.Grammatica.Runtime.Node)">
+ <summary>Called when adding a child to a parse tree
+node.</summary>
+ <param name="node">the parent node</param>
+ <param name="child">the child node, or null</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterLiteralExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitLiteralExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ChildLiteralExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production,Ciloci.Flee.PerCederberg.Grammatica.Runtime.Node)">
+ <summary>Called when adding a child to a parse tree
+node.</summary>
+ <param name="node">the parent node</param>
+ <param name="child">the child node, or null</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterBooleanLiteralExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitBooleanLiteralExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ChildBooleanLiteralExpression(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production,Ciloci.Flee.PerCederberg.Grammatica.Runtime.Node)">
+ <summary>Called when adding a child to a parse tree
+node.</summary>
+ <param name="node">the parent node</param>
+ <param name="child">the child node, or null</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.EnterExpressionGroup(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production)">
+ <summary>Called when entering a parse tree node.</summary>
+ <param name="node">the node being entered</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ExitExpressionGroup(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production)">
+ <summary>Called when exiting a parse tree node.</summary>
+ <param name="node">the node being exited</param>
+ <returns>the node to add to the parse tree, or
+ null if no parse tree should be created</returns>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="M:Ciloci.Flee.ExpressionAnalyzer.ChildExpressionGroup(Ciloci.Flee.PerCederberg.Grammatica.Runtime.Production,Ciloci.Flee.PerCederberg.Grammatica.Runtime.Node)">
+ <summary>Called when adding a child to a parse tree
+node.</summary>
+ <param name="node">the parent node</param>
+ <param name="child">the child node, or null</param>
+ <exception cref="T:Ciloci.Flee.PerCederberg.Grammatica.Runtime.ParseException">if the node analysis
+discovered errors</exception>
+</member><member name="T:Ciloci.Flee.ExpressionAnalyzer">
+ <remarks>A class providing callback methods for the
+parser.</remarks>
+</member><member name="M:Ciloci.Flee.IExpression.Clone">
+ <summary>
+ Creates a clone of the current expression
+ </summary>
+ <returns>A copy of the current expression with its own set of variables</returns>
+ <remarks>Use this method when you need to create a copy of an existing expression without the parsing/compilation overhead</remarks>
+</member><member name="P:Ciloci.Flee.IExpression.Text">
+ <summary>Gets the text the expression was created with</summary>
+ <value>A string with the expression's text</value>
+ <remarks>Use this property to get the text that was used to compile the expression.</remarks>
+</member><member name="P:Ciloci.Flee.IExpression.Info">
+ <summary>
+ Gets the expression's <see cref="T:Ciloci.Flee.ExpressionInfo"/> instance.
+ </summary>
+ <value>The ExpressionInfo instance.</value>
+ <remarks>
+ Use this property to access the expression's ExpressionInfo instance which holds information about the expression.
+ </remarks>
+</member><member name="P:Ciloci.Flee.IExpression.Context">
+ <summary>Gets the context the expression was created with</summary>
+ <value>
+ The expression's <see cref="T:Ciloci.Flee.ExpressionContext"/> instance
+ </value>
+ <remarks>Use this property to get the context that was used to compile the expression.</remarks>
+</member><member name="P:Ciloci.Flee.IExpression.Owner">
+ <summary>Gets or sets the expression's owner</summary>
+ <value>
+ The expression's owner instance. Must be of the same type as the expression's original owner.
+ </value>
+ <remarks>Use this property to get or set the instance of the expression's owner.</remarks>
+</member><member name="T:Ciloci.Flee.IExpression">
+ <summary>Interface implemented by all expressions</summary>
+ <remarks>This is the base interface that exposes members common to both dynamic and generic expressions.</remarks>
+</member><member name="M:Ciloci.Flee.IDynamicExpression.Evaluate">
+ <summary>Evaluates the dynamic expression</summary>
+ <returns>An Object instance that represents the result of evaluating the expression</returns>
+ <remarks>Use this method to evaluate the expression.</remarks>
+</member><member name="T:Ciloci.Flee.IDynamicExpression">
+ <summary>Interface implemented by all expressions that evaluate to an Object</summary>
+ <remarks>This is the interface that dynamic expressions must implement</remarks>
+</member><member name="M:Ciloci.Flee.IGenericExpression`1.Evaluate">
+ <summary>Evaluates the generic expression</summary>
+ <returns>The result of evaluating the expression</returns>
+ <remarks>Use this method to evaluate the expression.</remarks>
+</member><member name="T:Ciloci.Flee.IGenericExpression`1">
+ <summary>Interface implemented by all expressions that evaluate to a specific type</summary>
+ <typeparam name="T">The type that the expression will evaluate to</typeparam>
+ <remarks>This is the interface that generic expressions must implement</remarks>
+</member><member name="M:Ciloci.Flee.ExpressionInfo.GetReferencedVariables">
+ <summary>
+ Gets the variables that are used in an expression.
+ </summary>
+ <returns>A string array containing all the variables used in the expression.</returns>
+ <remarks>Use this method when you need to get a list of all variables used in an expression.</remarks>
+</member><member name="T:Ciloci.Flee.ExpressionInfo">
+ <summary>
+ Holds information about a compiled expression.
+ </summary>
+ <remarks>
+ This class holds information about an expression after it has been compiled. For example: you can use this class to find out what variables
+ an expression uses.
+ </remarks>
+</member><member name="M:Ciloci.Flee.ExpressionOwnerMemberAccessAttribute.#ctor(System.Boolean)">
+ <summary>
+ Initializes the attribute with the desired access.
+ </summary>
+ <param name="allowAccess">True to allow the member to be used in an expression;False otherwise</param>
+ <remarks>Initializes the attribute with the desired access.</remarks>
+</member><member name="T:Ciloci.Flee.ExpressionOwnerMemberAccessAttribute">
+ <summary>
+ Specifies whether access to a member on the expression owner is allowed.
+ </summary>
+ <remarks>
+ Use this attribute to control the accessibility of individual members on the expression owner. The access specified in
+ this attribute overrides the access level specified using the <see cref="P:Ciloci.Flee.ExpressionOptions.OwnerMemberAccess"/> property.
+ </remarks>
+</member><member name="P:Ciloci.Flee.ResolveVariableTypeEventArgs.VariableName">
+ <summary>
+ Gets the name of an on-demand variable.
+ </summary>
+ <value>The name of the variable</value>
+ <remarks>
+ Use this property to get the name of the variable whose type needs to be resolved.
+ </remarks>
+</member><member name="P:Ciloci.Flee.ResolveVariableTypeEventArgs.VariableType">
+ <summary>
+ Gets or sets the type of an on-demand variable.
+ </summary>
+ <value>The type of the variable</value>
+ <remarks>
+ Use this property to get or set the type of the on-demand variable.
+ </remarks>
+</member><member name="T:Ciloci.Flee.ResolveVariableTypeEventArgs">
+ <summary>
+ Provides the data for the ResolveVariableType event.
+ </summary>
+ <remarks>Use this class to provide the type of an on-demand variable.</remarks>
+</member><member name="P:Ciloci.Flee.ResolveVariableValueEventArgs.VariableName">
+ <summary>
+ Gets the name of an on-demand variable.
+ </summary>
+ <value>The name of the variable</value>
+ <remarks>
+ Use this property to get the name of the variable whose value needs to be resolved.
+ </remarks>
+</member><member name="P:Ciloci.Flee.ResolveVariableValueEventArgs.VariableType">
+ <summary>
+ Gets the type of an on-demand variable.
+ </summary>
+ <value>The type of the variable</value>
+ <remarks>
+ Use this property to get the type of the variable whose value needs to be resolved.
+ </remarks>
+</member><member name="P:Ciloci.Flee.ResolveVariableValueEventArgs.VariableValue">
+ <summary>
+ Gets or sets the value of an on-demand variable.
+ </summary>
+ <value>The value of the variable</value>
+ <remarks>
+ Use this property to get or set the value of an on-demand variable.
+ </remarks>
+</member><member name="T:Ciloci.Flee.ResolveVariableValueEventArgs">
+ <summary>
+ Provides the data for the ResolveVariableValue event.
+ </summary>
+ <remarks>Use this class to provide the value of an on-demand variable.</remarks>
+</member><member name="P:Ciloci.Flee.ResolveFunctionEventArgs.FunctionName">
+ <summary>
+ Gets the name of the on-demand function being resolved.
+ </summary>
+ <value>The name of the function</value>
+ <remarks>
+ Use this property to get the name of the on-demand function being resolved.
+ </remarks>
+</member><member name="P:Ciloci.Flee.ResolveFunctionEventArgs.ArgumentTypes">
+ <summary>
+ Gets the types of the arguments to the on-demand function being resolved.
+ </summary>
+ <value>An array with the type of each argument</value>
+ <remarks>
+ Use this property to get the types of the arguments to the on-demand function being resolved.
+ </remarks>
+</member><member name="P:Ciloci.Flee.ResolveFunctionEventArgs.ReturnType">
+ <summary>
+ Gets or sets the return type of the on-demand function being resolved.
+ </summary>
+ <value>The return type of the function</value>
+ <remarks>
+ Use this property to set the return type of the on-demand function being resolved.
+ </remarks>
+</member><member name="T:Ciloci.Flee.ResolveFunctionEventArgs">
+ <summary>
+ Provides the data for the ResolveFunction event.
+ </summary>
+ <remarks>Use this class to provide the return type of an on-demand function.</remarks>
+</member><member name="P:Ciloci.Flee.InvokeFunctionEventArgs.FunctionName">
+ <summary>
+ Gets the name of the on-demand function being invoked.
+ </summary>
+ <value>The name of the function</value>
+ <remarks>
+ Use this property to get the name of the on-demand function being invoked.
+ </remarks>
+</member><member name="P:Ciloci.Flee.InvokeFunctionEventArgs.Arguments">
+ <summary>
+ Gets the values of the arguments to the on-demand function being invoked.
+ </summary>
+ <value>An array with the values of each argument</value>
+ <remarks>
+ Use this property to get the values of the arguments to the on-demand function being invoked.
+ </remarks>
+</member><member name="P:Ciloci.Flee.InvokeFunctionEventArgs.Result">
+ <summary>
+ Gets or sets the result of the on-demand function being invoked.
+ </summary>
+ <value>The return value of the function</value>
+ <remarks>
+ Use this property to set the return value of the on-demand function being invoked.
+ </remarks>
+</member><member name="T:Ciloci.Flee.InvokeFunctionEventArgs">
+ <summary>
+ Provides the data for the InvokeFunction event.
+ </summary>
+ <remarks>Use this class to provide the return value of an on-demand function.</remarks>
+</member><member name="F:Ciloci.Flee.RealLiteralDataType.Single">
+ <summary>Specifies that real literals will be stored using the <see cref="T:System.Single"/> data type.</summary>
+</member><member name="F:Ciloci.Flee.RealLiteralDataType.Double">
+ <summary>
+ Specifies that real literals will be stored using the <see cref="T:System.Double"/> data type.
+ </summary>
+</member><member name="F:Ciloci.Flee.RealLiteralDataType.Decimal">
+ <summary>
+ Specifies that real literals will be stored using the <see cref="T:System.Decimal"/> data type.
+ </summary>
+</member><member name="T:Ciloci.Flee.RealLiteralDataType">
+ <summary>
+ Defines values to indicate the data type to use for storing real literals.
+ </summary>
+</member><member name="P:Ciloci.Flee.ExpressionOptions.ResultType">
+ <summary>Gets or sets the type of the expression's result.</summary>
+ <value>
+ A <see cref="T:System.Type"/> indicating the desired result type.
+ </value>
+ <remarks>
+ Use this property to convert the result of an expression to a particular type. Essentially, it acts as an implicit conversion from the final
+ result of the expression to the given type. When this property is set, the expression will attempt to convert its result to the set value.
+ If the conversion is invalid, an <see cref="T:Ciloci.Flee.ExpressionCompileException"/> will be thrown.
+ </remarks>
+</member><member name="P:Ciloci.Flee.ExpressionOptions.Checked">
+ <summary>
+ Gets or sets whether arithmetic and conversion operations check for overflow.
+ </summary>
+ <value>True to emit overflow checks. False to emit no overflow checks.</value>
+ <remarks>
+ Setting this property to true will cause all arithmetic and conversion operations to emit overflow checks. When
+ one of those operations is executed and the resultant value cannot fit into the result type, an <see cref="T:System.OverflowException">OverflowException</see>
+ will be thrown.
+ </remarks>
+</member><member name="P:Ciloci.Flee.ExpressionOptions.StringComparison">
+ <summary>
+ Gets or sets a value that determines how strings will be compared.
+ </summary>
+ <value>The type of string comparison to use.</value>
+ <remarks>
+ Use this property to control the type of string comparison used in an expression that compares two strings. For example: the result of
+ the expression <span style="font-family: monospace;">"string" = "STRING"</span> will be <b>true</b> if the string comparison is set to ignore case
+ and <b>false</b> otherwise. The default is Ordinal.
+ </remarks>
+</member><member name="P:Ciloci.Flee.ExpressionOptions.EmitToAssembly">
+ <summary>
+ Determines if the expression's IL will be saved to an assembly on disk.
+ </summary>
+ <value>True to save the expression's IL to an assembly; false otherwise.</value>
+ <remarks>
+ Use this method when you want to inspect the IL that an expression emits. When set to true, the expression will save its IL to the assembly "Expression.dll"
+ on disk. You can then view the IL with a disassembler.
+ </remarks>
+</member><member name="P:Ciloci.Flee.ExpressionOptions.OwnerMemberAccess">
+ <summary>
+ Determines which members on the expression owner are accessible.
+ </summary>
+ <value>A combination of BindingFlags that determine which members are accessible.</value>
+ <remarks>
+ Using this property, you can control which members on the expression owner are accessible from an expression. For example: if users
+ will be inputing expressions, you can prevent private members on the expression owner from being used. You can use the
+ <see cref="T:Ciloci.Flee.ExpressionOwnerMemberAccessAttribute"/> attribute on individual members to override the access set using this property.
+ <note>
+ The default is to only allow access to public members on the expression owner. Currently, only the Public and NonPublic values of the BindingFlags enumeration
+ are used.
+ </note>
+ </remarks>
+</member><member name="P:Ciloci.Flee.ExpressionOptions.CaseSensitive">
+ <summary>
+ Determines how an expression matches member and variable names
+ </summary>
+ <value>True to respect case when matching; False to ignore case</value>
+ <remarks>
+ Use this property to control how an expression resolves member and variable names. If set to true, variable and member
+ names will be matched in a case-sensitive manner. When false, case will be ignored.
+ </remarks>
+</member><member name="P:Ciloci.Flee.ExpressionOptions.IntegersAsDoubles">
+ <summary>Gets or sets whether all integer literals are treated as doubles</summary>
+ <value>True to treat all integer literals as doubles; False to use integers for integral numbers and floating point for real numbers (ie: any number with a decimal point)</value>
+ <remarks>
+ Use this property to force all integer literals to doubles. When set to true, an expression like "1/2" will return 0.5 since both integer
+ literals are treated as doubles. When false, the same expression will return 0 since an integer division will be performed.
+ </remarks>
+</member><member name="P:Ciloci.Flee.ExpressionOptions.ParseCulture">
+ <summary>Gets or sets the culture to use when parsing expressions</summary>
+ <value>The culture to use</value>
+ <remarks>
+ Use this property to allow for parsing of expressions using culture-specific tokens. This is useful, for example, when you
+ wish to parse numbers using a culture-specific decimal separator.
+ </remarks>
+</member><member name="P:Ciloci.Flee.ExpressionOptions.RealLiteralDataType">
+ <summary>Gets or sets the data type used for real literals when no explicit type is specified.</summary>
+ <value>A value specifying the type to use</value>
+ <remarks>
+ Use this property to set the data type that will be used to represent real literals. For example: if set to Decimal, all real literals (ie: 100.45) will be parsed into
+ a System.Decimal value.
+ </remarks>
+</member><member name="T:Ciloci.Flee.ExpressionOptions">
+ <summary>
+ Allows customization of expression compilation.
+ </summary>
+ <remarks>
+ Use this class when you need to customize how an expression is compiled. For example: by setting
+ the <see cref="P:Ciloci.Flee.ExpressionOptions.Checked">Checked</see> property to true,
+ you can cause all arithmetic and conversion operations to check for overflow.
+ </remarks>
+</member><member name="T:Ciloci.Flee.PropertyDictionary">
+ <summary>
+ Helper class for storing strongly-typed properties
+ </summary>
+ <remarks></remarks>
+</member><member name="M:Ciloci.Flee.ExpressionImports.AddType(System.Type,System.String)">
+ <overloads>Makes the static and public members of a type available for use in an expression</overloads>
+ <summary>Imports all public and static members of a type into a specific namespace and makes them available to an expression.</summary>
+ <param name="t">The type to import</param>
+ <param name="ns">The namespace to import the type into -or- the empty string to import into the default namespace</param>
+ <remarks>
+ Use this method to import a type into an expression. All static and public methods, fields, and properties of the type will be
+ directly accessible in the expression. If the namespace parameter is the empty string, the type's members will be able to be referenced
+ without any qualification. Otherwise, they will be imported into the specified namespace and will need to be qualified with it before being accessed. The
+ imported type is deemed accessible if it is either public or in the same module as the expression owner.
+ </remarks>
+ <example>
+ If you import the Math type into the default namespace, you can reference its members in the expression: "cos(1.0)".
+ If you import same type into the "Math" namespace, you will need to qualify its members like so: "math.cos(1.0)".
+ </example>
+ <exception cref="T:System.ArgumentException">The imported type is not accessible</exception>
+</member><member name="M:Ciloci.Flee.ExpressionImports.AddType(System.Type)">
+ <!--Unable to include XML fragment 'DocComments/ExpressionImports/Addtype2/*' of file 'Resources/DocComments.xml'.--></member><member name="M:Ciloci.Flee.ExpressionImports.AddMethod(System.String,System.Type,System.String)">
+ <overloads>Imports a single public and static method into an expression.</overloads>
+ <summary>Imports a public and static method of a type into a given namespace and makes it available to an expression.</summary>
+ <param name="methodName">The name of the method to import</param>
+ <param name="t">The type on which to lookup the method</param>
+ <param name="ns">The namespace to import the method into -or- the empty string to import into the default namespace</param>
+ <remarks>
+ Use this method to import a single static, public method into an expression. The method with the given name will be looked
+ up on the type argument and added into the specified namespace.
+ </remarks>
+ <exception cref="T:System.ArgumentException">The type the method belongs to is not accessible</exception>
+</member><member name="M:Ciloci.Flee.ExpressionImports.AddMethod(System.Reflection.MethodInfo,System.String)">
+ <summary>Imports a public and static method of a type into a given namespace and makes it available to an expression.</summary>
+ <param name="mi">The method to import</param>
+ <param name="ns">The namespace to import the method into -or- the empty string to import into the default namespace</param>
+ <remarks>
+ Use this method to import a single static, public method into an expression. This overload is used when you already have a specific
+ MethodInfo available.
+ </remarks>
+ <exception cref="T:System.ArgumentException">The type the method belongs to is not accessible</exception>
+</member><member name="M:Ciloci.Flee.ExpressionImports.ImportBuiltinTypes">
+ <summary>
+ Imports the builtin types into an expression
+ </summary>
+ <remarks>
+ Call this method to import the builtin types (int, string, double) into an expression. After this method is called, you can use members of the
+ builtin types in an expression ie: <pre>int.maxvalue * 2</pre>
+ </remarks>
+</member><member name="P:Ciloci.Flee.ExpressionImports.RootImport">
+ <summary>
+ Gets the root import of the context.
+ </summary>
+ <value>The root import.</value>
+ <remarks>
+ Use this property to access the root import of an expression.
+ </remarks>
+</member><member name="T:Ciloci.Flee.ExpressionImports">
+ <summary>
+ Holds all the types whose static members can be used in an expression.
+ </summary>
+ <remarks>
+ Use this class to allow the static functions, methods, and properties of a type
+ to be used in an expression. By default, no types are imported.
+ </remarks>
+ <example>
+ This example shows how to use this class to let an expression use all the static members of the Math class:
+ <code lang="C#">
+ // Define the context of our expression
+ ExpressionContext context = new ExpressionContext();
+ // Import all members of the Math type into the default namespace
+ context.Imports.AddType(typeof(Math));
+ </code>
+ </example>
+</member><member name="F:Ciloci.Flee.ExpressionContext.MyVariables">
+ <remarks>Keep variables as a field to make access fast</remarks>
+</member><member name="M:Ciloci.Flee.ExpressionContext.#ctor">
+ <summary>Creates a new expression context with the default expression owner.</summary>
+ <remarks>Use this constructor to create an expression context when you don't plan to use an expression owner.</remarks>
+</member><member name="M:Ciloci.Flee.ExpressionContext.#ctor(System.Object)">
+ <summary>Creates a new expression context with a specified expression owner.</summary>
+ <param name="expressionOwner">The expression owner instance to use</param>
+ <remarks>Use this constructor to create an expression context when you want to supply an expression owner.</remarks>
+</member><member name="M:Ciloci.Flee.ExpressionContext.Clone">
+ <summary>Creates a copy of the current context.</summary>
+ <returns>An identical copy of the current context</returns>
+ <remarks>Use this method when you need an indentical copy of an existing context. Note that</remarks>
+</member><member name="M:Ciloci.Flee.ExpressionContext.CompileDynamic(System.String)">
+ <summary>Creates a dynamic expression (one that evaluates to Object) from an expression text string and the current context</summary>
+ <param name="expression">The expression text to parse</param>
+ <returns>A new dynamic expression</returns>
+ <remarks>
+ Use this method when you want to create an expression that evaluates to an Object. "Dynamic" means that the result type
+ of the expression can be anything and is not fixed as with a generic expression.
+ <note>
+ The context, imports, and options of the compiled expression will be a clone of the originals. The variables however
+ are not cloned and will point to the same instance.
+ </note>
+ </remarks>
+ <exception cref="T:Ciloci.Flee.ExpressionCompileException">The expression could not be compiled</exception>
+</member><member name="M:Ciloci.Flee.ExpressionContext.CompileGeneric``1(System.String)">
+ <summary>Creates a generic expression from an expression text string and the current context</summary>
+ <typeparam name="TResultType">The type that the expression evaluates to</typeparam>
+ <param name="expression">The expression text to parse</param>
+ <returns>A new generic expression</returns>
+ <remarks>
+ Use this method when you want to create an expression that evaluates to a strongly-typed value.
+ <note>
+ The context, imports, and options of the compiled expression will be a clone of the originals. The variables however
+ are not cloned and will point to the same instance.
+ </note>
+ </remarks>
+ <exception cref="T:Ciloci.Flee.ExpressionCompileException">The expression could not be compiled</exception>
+</member><member name="P:Ciloci.Flee.ExpressionContext.Options">
+ <summary>Gets the ExpressionOptions to be used in an expression</summary>
+ <value>The ExpressionOptions instance</value>
+ <remarks>Use this property to access the options to be used in an expression.</remarks>
+</member><member name="P:Ciloci.Flee.ExpressionContext.Imports">
+ <summary>
+ Gets the types imported by an expression.
+ </summary>
+ <value>The collection of imported types.</value>
+ <remarks>
+ Use this property to get the imports that will be used by an expression.<seealso cref="T:Ciloci.Flee.ImportsCollection"/>
+ </remarks>
+</member><member name="P:Ciloci.Flee.ExpressionContext.Variables">
+ <summary>Gets the variables available to an expression</summary>
+ <value>The VariableCollection instance</value>
+ <remarks>Use this property to get collection of variables available to an expression.</remarks>
+</member><member name="P:Ciloci.Flee.ExpressionContext.CalculationEngine">
+ <summary>Gets the CalculationEngine instance used by the expression.</summary>
+ <value>The CalculationEngine instance</value>
+ <remarks>Use this property to get CalculationEngine instance used by an expression</remarks>
+</member><member name="P:Ciloci.Flee.ExpressionContext.ParserOptions">
+ <summary>Gets the ExpressionParserOptions for this context.</summary>
+ <value>The ExpressionParserOptions instance</value>
+ <remarks>Use this property to customize the expression parser.</remarks>
+</member><member name="T:Ciloci.Flee.ExpressionContext">
+ <summary>Class that holds all information required to create an expression</summary>
+ <remarks>This class holds all information required to create an expression.</remarks>
+ <threadsafety instance="true">The CompileDynamic and CompileGeneric methods are thread-safe.</threadsafety>
+ <example>
+ This example shows how to create an evaluate an expression:
+ <code lang="C#">
+// Define the context of our expression
+ExpressionContext context = new ExpressionContext();
+// Allow the expression to use all static public methods of System.Math
+context.Imports.AddType(typeof(Math));
+
+// Define an int variable
+context.Variables["a"] = 100;
+
+// Create a dynamic expression that evaluates to an Object
+IDynamicExpression eDynamic = context.CompileDynamic("sqrt(a) + pi");
+// Create a generic expression that evaluates to a double
+IGenericExpression<double> eGeneric = context.CompileGeneric<double>("sqrt(a) + pi");
+
+// Evaluate the expressions
+double result = (double)eDynamic.Evaluate();
+result = eGeneric.Evaluate();
+
+// Update the value of our variable
+context.Variables["a"] = 144;
+// Evaluate again to get the updated result
+result = eGeneric.Evaluate();</code>
+ </example>
+</member><member name="F:Ciloci.Flee.CompileExceptionReason.SyntaxError">
+ <summary>The expression text is not parsable because it does not meet the syntax rules of the expression grammar.</summary>
+</member><member name="F:Ciloci.Flee.CompileExceptionReason.ConstantOverflow">
+ <summary>A constant expression cannot be represented in its type.</summary>
+</member><member name="F:Ciloci.Flee.CompileExceptionReason.TypeMismatch">
+ <summary>The operation is invalid for the given type.</summary>
+</member><member name="F:Ciloci.Flee.CompileExceptionReason.UndefinedName">
+ <summary>The expression references a name that cannot be resolved.</summary>
+</member><member name="F:Ciloci.Flee.CompileExceptionReason.FunctionHasNoReturnValue">
+ <summary>The expression calls a function that does not return a value.</summary>
+</member><member name="F:Ciloci.Flee.CompileExceptionReason.InvalidExplicitCast">
+ <summary>The requested explicit cast is not valid for the given types.</summary>
+</member><member name="F:Ciloci.Flee.CompileExceptionReason.AmbiguousMatch">
+ <summary>More than one member matches the required criteria.</summary>
+</member><member name="F:Ciloci.Flee.CompileExceptionReason.AccessDenied">
+ <summary>Access to the specified member is not allowed.</summary>
+</member><member name="F:Ciloci.Flee.CompileExceptionReason.InvalidFormat">
+ <summary>The given value is not in the required format.</summary>
+</member><member name="T:Ciloci.Flee.CompileExceptionReason">
+ <summary>
+ Defines values to indicate why compilation of an expression failed.
+ </summary>
+ <remarks>
+ When compilation of an expression fails, an <see cref="T:Ciloci.Flee.ExpressionCompileException"/> will be thrown.
+ The <see cref="P:Ciloci.Flee.ExpressionCompileException.Reason">Reason</see> property
+ on the exception will contain a value from this enumeration. You can use that value to determine how to handle the exception.
+ For example: if the Reason is a SyntaxError, you can display an error message tailored to syntax errors.
+ </remarks>
+</member><member name="P:Ciloci.Flee.ExpressionCompileException.Reason">
+ <summary>
+ Gets the reason why compilation failed.
+ </summary>
+ <value>A value indicating the cause of the exception</value>
+ <remarks>Use this property to determine the reason why compilation failed.</remarks>
+</member><member name="T:Ciloci.Flee.ExpressionCompileException">
+ <summary>
+ The exception thrown when an expression cannot be compiled.
+ </summary>
+ <remarks>
+ This exception is thrown whenever an expression cannot be compiled.
+ The <see cref="P:Ciloci.Flee.ExpressionCompileException.Reason">Reason</see> property
+ will contain a value indicating the specific cause of the exception.
+ </remarks>
+</member><member name="E:Ciloci.Flee.CalcEngine.CalculationEngine.NodeRecalculated">
+ <summary>
+ Occurs when the calculation engine recalculates a node.
+ </summary>
+ <remarks>You can listen to this event to be notified when a node in the calculation engine is recalculated.</remarks>
+</member><member name="M:Ciloci.Flee.CalcEngine.CalculationEngine.Add(System.String,System.String,Ciloci.Flee.ExpressionContext)">
+ <summary>
+ Adds an expression to the calculation engine.
+ </summary>
+ <param name="atomName">The name that the expression will be associated with</param>
+ <param name="expression">The expression to add</param>
+ <param name="context">The context for the expression</param>
+ <remarks>Use this method to add an expression to the engine and associate it with a name</remarks>
+</member><member name="M:Ciloci.Flee.CalcEngine.CalculationEngine.Remove(System.String)">
+ <summary>
+ Removes an expression and all its dependents from the calculation engine.
+ </summary>
+ <param name="name">The name whose expression to remove</param>
+ <returns>True if the name was removed from the engine; False otherwise</returns>
+ <remarks>Use this method to remove an expression and all its dependents from the calculation engine. No exception is thrown if the
+ name does not exist in the engine.</remarks>
+</member><member name="M:Ciloci.Flee.CalcEngine.CalculationEngine.CreateBatchLoader">
+ <summary>
+ Creates a BatchLoader that can be used to populate the calculation engine in one batch.
+ </summary>
+ <returns>A new instance of the BatchLoader class</returns>
+ <remarks>
+ Use this method to create a BatchLoader instance.
+ </remarks>
+</member><member name="M:Ciloci.Flee.CalcEngine.CalculationEngine.BatchLoad(Ciloci.Flee.CalcEngine.BatchLoader)">
+ <summary>
+ Populates the calculation engine from the given BatchLoader.
+ </summary>
+ <param name="loader">The batch loader instance to use</param>
+ <remarks>
+ Call this method to load the calculation engine with all the expressions in the given batch loader.
+ </remarks>
+</member><member name="M:Ciloci.Flee.CalcEngine.CalculationEngine.GetResult``1(System.String)">
+ <summary>
+ Gets the cached result of a contained expression.
+ </summary>
+ <typeparam name="T">The type of the expression's result.</typeparam>
+ <param name="name">The name that the expression is associated with</param>
+ <returns>The cached result of evaluating the expression</returns>
+ <remarks>Use this method after a recalculate to get the updated value of an expression.</remarks>
+</member><member name="M:Ciloci.Flee.CalcEngine.CalculationEngine.GetResult(System.String)">
+ <summary>
+ Gets the cached result of a contained expression.
+ </summary>
+ <param name="name">The name that the expression is associated with</param>
+ <returns>The cached result of evaluating the expression</returns>
+ <remarks>Use this method after a recalculate to get the updated value of an expression.</remarks>
+</member><member name="M:Ciloci.Flee.CalcEngine.CalculationEngine.GetExpression(System.String)">
+ <summary>
+ Gets the expression associated with a name.
+ </summary>
+ <param name="name">The name that the expression is associated with</param>
+ <returns>The expression associated with the given name</returns>
+ <remarks>Use this method to obtain the expression associated with a name.</remarks>
+</member><member name="M:Ciloci.Flee.CalcEngine.CalculationEngine.GetDependents(System.String)">
+ <summary>
+ Gets the names of the expressions that depend on a given name.
+ </summary>
+ <param name="name">The name of the expression to look up</param>
+ <returns>The names of all expressions that depend on the expression with the given name</returns>
+ <remarks>Use this method to obtain all the expressions that depend on a given name. For example: if a=100, b=200, and c=a+b, then calling
+ GetDependents("a") will return "c" since when the value of "a" changes, the value of "c" will also change. This method is not recursive, so it
+ will only return the names that directly depend on the given name. This method is the inverse of <see cref="M:Ciloci.Flee.CalculationEngine.GetPrecedents(System.String)"/>
+ </remarks>
+</member><member name="M:Ciloci.Flee.CalcEngine.CalculationEngine.GetPrecedents(System.String)">
+ <summary>
+ Gets the names of the expressions that a given name depends on.
+ </summary>
+ <param name="name">The name of the expression to look up</param>
+ <returns>The names of all expressions that the given name depends on</returns>
+ <remarks>
+ Use this method to obtain all the expressions that a given name depends on. For example: if a=100, b=200, and c=a+b, then calling
+ GetPrecedents("c") will return "a, b" since when either "a" or "b" change, the value of "c" will also change. This method is not recursive, so it
+ will only return the names that the given name directly depends on. This method is the inverse of <see cref="M:Ciloci.Flee.CalculationEngine.GetDependents(System.String)"/>
+ </remarks>
+</member><member name="M:Ciloci.Flee.CalcEngine.CalculationEngine.HasDependents(System.String)">
+ <summary>
+ Determines if an expression with a given name is referenced by any other expressions in the engine.
+ </summary>
+ <param name="name">The name of the expression to look up</param>
+ <returns>True if the engine has expressions that depend on it; False otherwise</returns>
+ <remarks>
+ Use this method to determine if the expression associated with a given name has any expressions that depend on it. For example: you can use this method to allow
+ a user to remove an expression only when no other expressions depend on it.
+ </remarks>
+</member><member name="M:Ciloci.Flee.CalcEngine.CalculationEngine.HasPrecedents(System.String)">
+ <summary>
+ Determines if an expression with a given name depends on any other expression.
+ </summary>
+ <param name="name">The name of the expression to look up</param>
+ <returns>True if the name has expressions that it depends on; False otherwise</returns>
+ <remarks>
+ Use this method to determine if an expression depends on any other expressions.
+ </remarks>
+</member><member name="M:Ciloci.Flee.CalcEngine.CalculationEngine.Contains(System.String)">
+ <summary>
+ Determines if the engine contains an expression with a given name.
+ </summary>
+ <param name="name">The name of the expression to look up</param>
+ <returns>True if the engine has an expression with the name; False otherwise</returns>
+ <remarks>
+ Use this method to determine if the calculation engine contains an expression with a given name.
+ </remarks>
+</member><member name="M:Ciloci.Flee.CalcEngine.CalculationEngine.Recalculate(System.String[])">
+ <summary>
+ Performs a natural order recalculation of the engine.
+ </summary>
+ <param name="roots">The names representing the starting points of the recalculation</param>
+ <remarks>This method will perform a natural order recalculate on the expressions in the engine. The recalculation will start at the given roots
+ and continue with all their dependents. If no roots are given, then a recalculation of all expressions is performed.</remarks>
+ <exception cref="T:Ciloci.Flee.CircularReferenceException">A recalculate is requested on an engine containing a circular reference</exception>
+</member><member name="M:Ciloci.Flee.CalcEngine.CalculationEngine.Clear">
+ <summary>
+ Clears all expressions from the CalculationEngine
+ </summary>
+ <remarks>Use this method to reset the CalculationEngine to the empty state.</remarks>
+</member><member name="P:Ciloci.Flee.CalcEngine.CalculationEngine.Count">
+ <summary>
+ Gets the number of expressions contained in the calculation engine.
+ </summary>
+ <value>The number of expressions in the calculation engine</value>
+ <remarks>
+ Use this property to see how many expressions are contained in the calculation engine.
+ </remarks>
+</member><member name="P:Ciloci.Flee.CalcEngine.CalculationEngine.DependencyGraph">
+ <summary>
+ Gets a string representation of the engine's dependency graph.
+ </summary>
+ <value>A string representing the graph.</value>
+ <remarks>Use this property to get a string version of the engine's dependency graph. There will be one line for each dependency. Each line will
+ be of the format "[reference] -> [dependant1, dependant2]" and is read as "A change in [reference] will cause a change in [dependant]".</remarks>
+</member><member name="T:Ciloci.Flee.CalcEngine.CalculationEngine">
+ <summary>
+ Creates a calculation network which allows expressions to refer to the result of other expressions, tracks dependencies, and enables natural order recalculation.
+ </summary>
+ <remarks>
+ This class acts as a container for expressions. As expressions are added to it, their dependencies are tracked and their result is cached. Expressions defined
+ in this class can reference other contained expressions. Once all expressions are added, a natural order recalculate can be performed.
+ </remarks>
+ <example>This example shows how to add expressions to the engine and have them reference other contained expressions:
+ <code lang="C#">
+ExpressionContext context = new ExpressionContext();
+VariableCollection variables = context.Variables;
+
+// Add some variables
+variables.Add("x", 100);
+variables.Add("y", 200);
+
+// Add an expression to the calculation engine as "a"
+engine.Add("a", "x * 2", context);
+
+// Add an expression to the engine as "b"
+engine.Add("b", "y + 100", context);
+
+// Add an expression at "c" that uses the results of "a" and "b"
+// Notice that we have to prefix the expression names with a '$'
+engine.Add("c", "$a + $b", context);
+
+// Get the value of "c"
+int result = engine.GetResult<int>("c");
+
+// Update a variable on the "a" expression
+variables["x"] = 200;
+
+// Recalculate it
+engine.Recalculate("a");
+
+// Get the updated result
+result = engine.GetResult<int>("c");
+ </code>
+ </example>
+</member><member name="M:Ciloci.Flee.Utility.GetSimpleOverloadedOperator(System.String,System.Type,System.Type)">
+ <summary>
+ Find a simple (unary) overloaded operator
+ </summary>
+ <param name="name">The name of the operator</param>
+ <param name="sourceType">The type to convert from</param>
+ <param name="destType">The type to convert to</param>
+ <returns>The operator's method or null of no match is found</returns>
+</member><member name="M:Ciloci.Flee.Utility.SimpleOverloadedOperatorFilter(System.Reflection.MemberInfo,System.Object)">
+ <summary>
+ Matches simple overloaded operators
+ </summary>
+ <param name="member"></param>
+ <param name="value"></param>
+ <returns></returns>
+ <remarks></remarks>
+</member><member name="T:Ciloci.Flee.Utility">
+ <summary>
+ Holds various shared utility methods
+ </summary>
+ <remarks></remarks>
+</member><member name="P:Ciloci.Flee.ImportBase.Name">
+ <summary>Gets the name of the import</summary>
+ <value>The name of the current import instance</value>
+ <remarks>Use this property to get the name of the import</remarks>
+</member><member name="P:Ciloci.Flee.ImportBase.IsContainer">
+ <summary>Determines if this import can contain other imports</summary>
+ <value>True if this import can contain other imports; False otherwise</value>
+ <remarks>Use this property to determine if this import contains other imports</remarks>
+</member><member name="T:Ciloci.Flee.ImportBase">
+ <summary>Base class for all expression imports</summary>
+</member><member name="M:Ciloci.Flee.TypeImport.#ctor(System.Type)">
+ <summary>Creates a new import with a given type</summary>
+ <param name="importType">The type to import</param>
+</member><member name="M:Ciloci.Flee.TypeImport.#ctor(System.Type,System.Boolean)">
+ <summary>Creates a new import with a given type</summary>
+ <param name="importType">The type to import</param>
+ <param name="useTypeNameAsNamespace">True to use the type's name as a namespace; False otherwise</param>
+ <remarks>When useTypeNameAsNamespace is set to True, the type will act as a namespace in an expression. For example: If
+ you import the DayOfWeek enum and set the flag to true, you can reference it as DayOfWeek.Sunday in an expression. When the flag is false,
+ you would reference it as simply Sunday.</remarks>
+</member><member name="P:Ciloci.Flee.TypeImport.Target">
+ <summary>Gets the type that this import represents</summary>
+ <value>The type that this import represents</value>
+ <remarks>Use this property to retrieve the imported type</remarks>
+</member><member name="T:Ciloci.Flee.TypeImport">
+ <summary>Represents an imported type</summary>
+ <remarks>Use this class when you want to make the members of a type available to an expression</remarks>
+</member><member name="M:Ciloci.Flee.MethodImport.#ctor(System.Reflection.MethodInfo)">
+ <summary>Creates a new method import with a given method</summary>
+ <param name="importMethod">The method to import</param>
+</member><member name="P:Ciloci.Flee.MethodImport.Target">
+ <summary>Gets the method that this import represents</summary>
+ <value>The method that this import represents</value>
+ <remarks>Use this property to retrieve the imported method</remarks>
+</member><member name="T:Ciloci.Flee.MethodImport">
+ <summary>Represents an imported method</summary>
+ <remarks>Use this class when you want to make a single method available to an expression</remarks>
+</member><member name="M:Ciloci.Flee.NamespaceImport.#ctor(System.String)">
+ <summary>Creates a new namespace import with a given namespace name</summary>
+ <param name="importNamespace">The name of the namespace to import</param>
+</member><member name="T:Ciloci.Flee.NamespaceImport">
+ <summary>Represents an imported namespace</summary>
+ <remarks>This class acts as a container for other imports. Use it when you want to logically group expression imports.</remarks>
+</member><member name="M:Ciloci.Flee.ExpressionParserOptions.RecreateParser">
+ <summary>
+ Updates the expression parser using the settings provided in this class.
+ </summary>
+</member><member name="P:Ciloci.Flee.ExpressionParserOptions.DateTimeFormat">
+ <summary>Gets or sets the format to use for parsing DateTime literals</summary>
+ <value>The format to use</value>
+ <remarks>
+ Use this property to set the format that will be used to parse DateTime literals. Expressions which have DateTime literals that are not parseable using this format will fail to compile.
+ </remarks>
+ <example>When set to "dd-MM-yyyy", an expression such as "#04-07-2008#" would be parsed to the corresponding DateTime value.</example>
+</member><member name="P:Ciloci.Flee.ExpressionParserOptions.RequireDigitsBeforeDecimalPoint">
+ <summary>Gets or sets a value that determines if literals for real numbers must have digits before the decimal point.</summary>
+ <value>True to require digits (ie: 0.56); False otherwise (ie: .56)</value>
+</member><member name="P:Ciloci.Flee.ExpressionParserOptions.DecimalSeparator">
+ <summary>Gets or sets the character to use as the decimal separator for real number literals.</summary>
+</member><member name="P:Ciloci.Flee.ExpressionParserOptions.FunctionArgumentSeparator">
+ <summary>Gets or sets the character to use to separate function arguments.</summary>
+</member><member name="T:Ciloci.Flee.ExpressionParserOptions">
+ <summary>
+ Holds settings which enable customization of the expression parser.
+ </summary>
+</member><member name="T:Ciloci.Flee.FleeILGenerator">
+ <summary>
+ Wraps a regular IL generator and provides additional functionality we need
+ </summary>
+ <remarks></remarks>
+</member><member name="M:Ciloci.Flee.BranchManager.ComputeBranches">
+ <summary>
+ Determine whether to use short or long branches
+ </summary>
+ <remarks></remarks>
+</member><member name="M:Ciloci.Flee.BranchManager.CountLongBranches(System.Collections.Generic.ICollection{Ciloci.Flee.BranchInfo})">
+ <summary>
+ Count the number of long branches in a set
+ </summary>
+ <param name="dest"></param>
+ <returns></returns>
+ <remarks></remarks>
+</member><member name="M:Ciloci.Flee.BranchManager.FindBetweenBranches(Ciloci.Flee.BranchInfo,System.Collections.Generic.ICollection{Ciloci.Flee.BranchInfo})">
+ <summary>
+ Find all the branches between the start and end locations of a target branch
+ </summary>
+ <param name="target"></param>
+ <param name="dest"></param>
+ <remarks></remarks>
+</member><member name="M:Ciloci.Flee.BranchManager.IsLongBranch(Ciloci.Flee.FleeILGenerator,System.Reflection.Emit.Label)">
+ <summary>
+ Determine if a branch from a point to a label will be long
+ </summary>
+ <param name="ilg"></param>
+ <param name="target"></param>
+ <returns></returns>
+ <remarks></remarks>
+</member><member name="M:Ciloci.Flee.BranchManager.AddBranch(Ciloci.Flee.FleeILGenerator,System.Reflection.Emit.Label)">
+ <summary>
+ Add a branch from a location to a target label
+ </summary>
+ <param name="ilg"></param>
+ <param name="target"></param>
+ <remarks></remarks>
+</member><member name="M:Ciloci.Flee.BranchManager.FindLabel(System.Object)">
+ <summary>
+ Get a label by a key
+ </summary>
+ <param name="key"></param>
+ <returns></returns>
+ <remarks></remarks>
+</member><member name="M:Ciloci.Flee.BranchManager.GetLabel(System.Object,Ciloci.Flee.FleeILGenerator)">
+ <summary>
+ Get a label by a key. Create the label if it is not present.
+ </summary>
+ <param name="key"></param>
+ <param name="ilg"></param>
+ <returns></returns>
+ <remarks></remarks>
+</member><member name="M:Ciloci.Flee.BranchManager.HasLabel(System.Object)">
+ <summary>
+ Determines if we have a label for a key
+ </summary>
+ <param name="key"></param>
+ <returns></returns>
+ <remarks></remarks>
+</member><member name="M:Ciloci.Flee.BranchManager.MarkLabel(Ciloci.Flee.FleeILGenerator,System.Reflection.Emit.Label)">
+ <summary>
+ Set the position for a label
+ </summary>
+ <param name="ilg"></param>
+ <param name="target"></param>
+ <remarks></remarks>
+</member><member name="T:Ciloci.Flee.BranchManager">
+ <summary>
+ Manages branch information and allows us to determine if we should emit a short or long branch
+ </summary>
+</member><member name="F:Ciloci.Flee.ILLocation.LongBranchAdjust">
+ <summary>
+ ' Long branch is 5 bytes; short branch is 2; so we adjust by the difference
+ </summary>
+</member><member name="F:Ciloci.Flee.ILLocation.Br_s_Length">
+ <summary>
+ Length of the Br_s opcode
+ </summary>
+</member><member name="M:Ciloci.Flee.ILLocation.AdjustForLongBranch(System.Int32)">
+ <summary>
+ Adjust our position by a certain amount of long branches
+ </summary>
+ <param name="longBranchCount"></param>
+ <remarks></remarks>
+</member><member name="M:Ciloci.Flee.ILLocation.IsLongBranch(Ciloci.Flee.ILLocation)">
+ <summary>
+ Determine if this branch is long
+ </summary>
+ <param name="target"></param>
+ <returns></returns>
+ <remarks></remarks>
+</member><member name="T:Ciloci.Flee.ILLocation">
+ <summary>
+ Represents a location in an IL stream
+ </summary>
+</member><member name="T:Ciloci.Flee.BranchInfo">
+ <summary>
+ Represents a branch from a start location to an end location
+ </summary>
+</member><member name="P:Ciloci.Flee.FunctionCallElement.Method">
+ <summary>
+ The method info we will be calling
+ </summary>
+</member><member name="T:Ciloci.Flee.FunctionCallElement">
+ <summary>
+ Represents a function call
+ </summary>
+ <remarks></remarks>
+</member><member name="T:Ciloci.Flee.ArgumentList">
+ <summary>
+ Encapsulates an argument list
+ </summary>
+ <remarks></remarks>
+</member><member name="M:Ciloci.Flee.CalcEngine.BatchLoader.Add(System.String,System.String,Ciloci.Flee.ExpressionContext)">
+ <summary>
+ Adds an expression to the batch loader.
+ </summary>
+ <param name="atomName">The name that the expression will be associated with</param>
+ <param name="expression">The expression to add</param>
+ <param name="context">The context for the expression</param>
+ <remarks>Use this method to add an expression to the batch loader and associate it with a name</remarks>
+</member><member name="M:Ciloci.Flee.CalcEngine.BatchLoader.Contains(System.String)">
+ <summary>
+ Determines if the loader contains an expression with a given name.
+ </summary>
+ <param name="name">The name of the expression to look up</param>
+ <returns>True if the loader has an expression with the name; False otherwise</returns>
+ <remarks>
+ Use this method to determine if the loader contains an expression with a given name.
+ </remarks>
+</member><member name="T:Ciloci.Flee.CalcEngine.BatchLoader">
+ <summary>
+ Represents a class that can be used to populate the calculation engine in one batch.
+ </summary>
+ <remarks>
+ Normally, you have to add an expression to the calculation engine after any expressions it depends on. By using this class, you can load expressions in any order and
+ then have them be loaded into the calculation engine in one call.
+ </remarks>
+</member><member name="P:Ciloci.Flee.CalcEngine.NodeEventArgs.Name">
+ <summary>
+ Gets the name of the recalculated node.
+ </summary>
+ <value>The name of the node</value>
+ <remarks>
+ Use this property to get the name of the recalculated node.
+ </remarks>
+</member><member name="P:Ciloci.Flee.CalcEngine.NodeEventArgs.Result">
+ <summary>
+ Gets the recalculated result of the node.
+ </summary>
+ <value>The value of the result</value>
+ <remarks>
+ Use this property to get the recalculated result of the node.
+ </remarks>
+</member><member name="T:Ciloci.Flee.CalcEngine.NodeEventArgs">
+ <summary>
+ Provides the data for the NodeRecalculated event.
+ </summary>
+ <remarks>Use the members of this class to get additional information about the recalculated node.</remarks>
+</member><member name="T:Ciloci.Flee.CalcEngine.CircularReferenceException">
+ <summary>
+ Represents the exception thrown when a circular reference is detected in the calculation engine.
+ </summary>
+ <remarks>
+ This exception will be thrown when Recalculate is called on the CalculationEngine and there is a circular reference present.
+ </remarks>
+</member><member name="P:Ciloci.Flee.CalcEngine.BatchLoadCompileException.AtomName">
+ <summary>
+ Gets the name of the expression that could not be compiled.
+ </summary>
+ <value>The name of the expression</value>
+ <remarks>Use this property to determine the name of the expression that caused the exception.</remarks>
+</member><member name="P:Ciloci.Flee.CalcEngine.BatchLoadCompileException.ExpressionText">
+ <summary>
+ Gets the text of the expression that could not be compiled.
+ </summary>
+ <value>The text of the expression</value>
+ <remarks>Use this property to determine the text of the expression that caused the exception.</remarks>
+</member><member name="T:Ciloci.Flee.CalcEngine.BatchLoadCompileException">
+ <summary>
+ The exception thrown when an batch loaded expression cannot be compiled.
+ </summary>
+ <remarks>
+ This exception is thrown whenever a batch loaded expression cannot be compiled. You use the AtomName and ExpressionText properties
+ to get more information about the source of the exception.
+ </remarks>
+</member>
+</members>
+</doc>
\ No newline at end of file
Added: sandbox/maestro-3.0/Thirdparty/Flee/license.txt
===================================================================
--- sandbox/maestro-3.0/Thirdparty/Flee/license.txt (rev 0)
+++ sandbox/maestro-3.0/Thirdparty/Flee/license.txt 2010-10-29 06:33:36 UTC (rev 5361)
@@ -0,0 +1,504 @@
+ GNU LESSER GENERAL PUBLIC LICENSE
+ Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+ 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL. It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+ Preamble
+
+ The licenses for most software are designed to take away your
+freedom to share and change it. By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+ This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it. You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations below.
+
+ When we speak of free software, we are referring to freedom of use,
+not price. Our General Public Licenses are designed to make sure that
+you have the freedom to distribute copies of free software (and charge
+for this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+ To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights. These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+ For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you. You must make sure that they, too, receive or can get the source
+code. If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it. And you must show them these terms so they know their rights.
+
+ We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+ To protect each distributor, we want to make it very clear that
+there is no warranty for the free library. Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+
+ Finally, software patents pose a constant threat to the existence of
+any free program. We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder. Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+ Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License. This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License. We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+ When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library. The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom. The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+ We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License. It also provides other free software developers Less
+of an advantage over competing non-free programs. These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries. However, the Lesser license provides advantages in certain
+special circumstances.
+
+ For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it becomes
+a de-facto standard. To achieve this, non-free programs must be
+allowed to use the library. A more frequent case is that a free
+library does the same job as widely used non-free libraries. In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+ In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software. For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+ Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+ The precise terms and conditions for copying, distribution and
+modification follow. Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library". The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+
+ GNU LESSER GENERAL PUBLIC LICENSE
+ TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+ 0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+ A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+ The "Library", below, refers to any such software library or work
+which has been distributed under these terms. A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language. (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+ "Source code" for a work means the preferred form of the work for
+making modifications to it. For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+ Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope. The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it). Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+
+ 1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+ You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+ 2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+ a) The modified work must itself be a software library.
+
+ b) You must cause the files modified to carry prominent notices
+ stating that you changed the files and the date of any change.
+
+ c) You must cause the whole of the work to be licensed at no
+ charge to all third parties under the terms of this License.
+
+ d) If a facility in the modified Library refers to a function or a
+ table of data to be supplied by an application program that uses
+ the facility, other than as an argument passed when the facility
+ is invoked, then you must make a good faith effort to ensure that,
+ in the event an application does not supply such function or
+ table, the facility still operates, and performs whatever part of
+ its purpose remains meaningful.
+
+ (For example, a function in a library to compute square roots has
+ a purpose that is entirely well-defined independent of the
+ application. Therefore, Subsection 2d requires that any
+ application-supplied function or table used by this function must
+ be optional: if the application does not supply it, the square
+ root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole. If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works. But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+ 3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library. To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License. (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.) Do not make any other change in
+these notices.
+
+ Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+ This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+ 4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+ If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+ 5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library". Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+ However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library". The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+ When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library. The
+threshold for this to be true is not precisely defined by law.
+
+ If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work. (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+ Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+ 6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+ You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License. You must supply a copy of this License. If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License. Also, you must do one
+of these things:
+
+ a) Accompany the work with the complete corresponding
+ machine-readable source code for the Library including whatever
+ changes were used in the work (which must be distributed under
+ Sections 1 and 2 above); and, if the work is an executable linked
+ with the Library, with the complete machine-readable "work that
+ uses the Library", as object code and/or source code, so that the
+ user can modify the Library and then relink to produce a modified
+ executable containing the modified Library. (It is understood
+ that the user who changes the contents of definitions files in the
+ Library will not necessarily be able to recompile the application
+ to use the modified definitions.)
+
+ b) Use a suitable shared library mechanism for linking with the
+ Library. A suitable mechanism is one that (1) uses at run time a
+ copy of the library already present on the user's computer system,
+ rather than copying library functions into the executable, and (2)
+ will operate properly with a modified version of the library, if
+ the user installs one, as long as the modified version is
+ interface-compatible with the version that the work was made with.
+
+ c) Accompany the work with a written offer, valid for at
+ least three years, to give the same user the materials
+ specified in Subsection 6a, above, for a charge no more
+ than the cost of performing this distribution.
+
+ d) If distribution of the work is made by offering access to copy
+ from a designated place, offer equivalent access to copy the above
+ specified materials from the same place.
+
+ e) Verify that the user has already received a copy of these
+ materials or that you have already sent this user a copy.
+
+ For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it. However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+ It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system. Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+ 7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+ a) Accompany the combined library with a copy of the same work
+ based on the Library, uncombined with any other library
+ facilities. This must be distributed under the terms of the
+ Sections above.
+
+ b) Give prominent notice with the combined library of the fact
+ that part of it is a work based on the Library, and explaining
+ where to find the accompanying uncombined form of the same work.
+
+ 8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License. Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License. However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+ 9. You are not required to accept this License, since you have not
+signed it. However, nothing else grants you permission to modify or
+distribute the Library or its derivative works. These actions are
+prohibited by law if you do not accept this License. Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+ 10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions. You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties with
+this License.
+
+ 11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License. If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all. For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices. Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+ 12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded. In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+ 13. The Free Software Foundation may publish revised and/or new
+versions of the Lesser General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number. If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation. If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+ 14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission. For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this. Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+ NO WARRANTY
+
+ 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+ 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+ END OF TERMS AND CONDITIONS
+
+ How to Apply These Terms to Your New Libraries
+
+ If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change. You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+ To apply these terms, attach the following notices to the library. It is
+safest to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+ <one line to give the library's name and a brief idea of what it does.>
+ Copyright (C) <year> <name of author>
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary. Here is a sample; alter the names:
+
+ Yoyodyne, Inc., hereby disclaims all copyright interest in the
+ library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+ <signature of Ty Coon>, 1 April 1990
+ Ty Coon, President of Vice
+
+That's all there is to it!
+
+
Added: sandbox/maestro-3.0/Thirdparty/Flee/readme.txt
===================================================================
--- sandbox/maestro-3.0/Thirdparty/Flee/readme.txt (rev 0)
+++ sandbox/maestro-3.0/Thirdparty/Flee/readme.txt 2010-10-29 06:33:36 UTC (rev 5361)
@@ -0,0 +1,26 @@
+Flee - Fast Lightweight Expression Evaluator
+-------------
+
+Version: 0.9.26.0
+Release Date: June 17, 2009
+Author: Eugene Ciloci
+
+What is it?
+-----------
+A .NET library that allows you to parse, compile, and evaluate expressions. Its main distinguishing feature is that it uses a custom compiler to convert expressions to IL and then emits them to a dynamic method at runtime. This ensures that expression evaluation is fast and efficient.
+
+What license does it use?
+-------------------------
+The library is licensed under the LGPL.
+
+Dependencies
+------------
+The library uses the excellent grammatica parser generator to handle formula parsing.
+It is also licensed under the LGPL and you can get the latest version at: http://grammatica.percederberg.net/
+The tests use NUnit.
+
+Additional Information
+----------------------
+The project is hosted on CodePlex. You can find the project page at: http://www.codeplex.com/Flee
+
+I hope you find it useful
\ No newline at end of file
More information about the mapguide-commits
mailing list