// 這裡包含了 MUTAN 語法的所有定義
// 定義是利用一個判斷方法來實現的
// 任何字串都可以用判斷方法來判斷是否符合某定義
//MUTAN 語法的形式定義
//expr := * (任何不為空的表達式, 例如 1+1, (1>2)&(VAR=3), !(true&true|false) 實施時利用表達式解析器判斷是否合法)
//decla := [$]ID=expr (變量宣告, 變量名如以 $ 開頭表示是臨時變量, AZUSA 在退出時不會保存)
//exec := RID(expr|"") (函式調用, RID 是函式名, 參數可以是表達式或空白字串)
//term := "END"|"BREAK" (中斷執行用)
//basic := decla|exec|term
//multi := basic{;basic}
//cond := expr?multi
//stmt := multi|cond
//loop := @stmt
//resp := ?stmt
//line := stmt|loop|resp
//(區塊的定義)
//namedblock :=
//.ID{
//block
//}
//respblock :=
//?{
//block
//}
//condblock :=
//expr{
//block
//}
//loopblock :=
//@{
//block
//}
//block := (line|namedblock|respblock|condblock|loopblock)* (最終定義, 只要是 block 就是 MUTAN)
//判斷是否一個 decla (宣告)
static public bool IsDecla(string line)
{
//首先得有一個等號
//first there has to be an equal sign
if (line.Contains('='))
{
//暫存運算結果
string tmp;
//以等號為界分割字串
string[] split = line.Split('=');
//等號的左手邊應為變數名
//變數名必須是一個簡單字串, 不能含有運算符或者其他表達式, 我們可以利用表達式運算器算一下, 如果算出來跟原來一樣, 就是合法字串
//或者左手邊可以是一個已經宣告過的變數名
//second the left hand side must be a simple string that is not further evaluable ,ie an expression cannot be used as an ID
// or it can be an existing ID
if (ExprParser.TryParse(split[0], out tmp) && tmp == split[0].Trim() || Variables.Exist(split[0].Trim()))
{
return(true);
}
}
return(false);
}
//接下來就是區塊的定義
//判斷是否一個 namedblock (命名區塊)
static public bool IsNamedBlock(string[] lines)
{
//首先要以 .(名稱){ 的格式開頭, 以 } 結束
//first the first line has to start with '.', ends with '{'
//the last line should be "}"
if (lines[0].Trim().StartsWith(".") && lines[0].Trim().EndsWith("{") && lines[lines.Length - 1].Trim() == "}")
{
//取得區塊名
string ID = lines[0].Trim().Trim('.', '{');
//暫存運算結果
string tmp;
//區塊名必須是一個簡單字串, 不能含有運算符或者其他表達式, 我們可以利用表達式運算器算一下, 如果算出來跟原來一樣, 就是合法字串
//second the ID should not be further evaluable, and also should not start/end with spaces
if (ExprParser.TryParse(ID, out tmp) && tmp == ID)
{
//把第一行和最後一行去掉後的內容應該要是一個 block (歸遞定義)
//lastly the content should be a block
string[] content = new string[lines.Length - 2];
for (int i = 1; i < lines.Length - 1; i++)
{
content[i - 1] = lines[i];
}
return(IsBlock(content));
}
}
return(false);
}
public void TrailingZerosOnDecimal()
{
var f = ExprParser.ParseOrThrow("1.2340000");
Assert.AreEqual(f, new One() + (Literal.Create(234) / Literal.Create(1000)));
Assert.AreEqual(f, (Literal.Create(234) / Literal.Create(1000)) + new One());
}
public virtual Expr parseStatement(string paramString)
{
paramString = StringUtils.escapeParametricExpression(paramString);
ExprParser exprParser = new ExprParser();
try
{
exprParser.parse(new ExprLexer(paramString));
}
catch (IOException iOException)
{
Console.WriteLine(iOException.ToString());
Console.Write(iOException.StackTrace);
throw new ExprException(iOException.Message);
}
Expr expr = exprParser.get();
Exprs.ToUpper(expr);
if (expr is ExprEvaluatable)
{
expr = ((ExprEvaluatable)expr).evaluate(this);
}
else
{
throw new ExprException("Not Evaluatable result for: " + paramString);
}
return(expr);
}
public void Beta1()
{
var actual = ExprParser.ParseOrThrow("β_1");
var expected = new Identifier("β_1");
Assert.AreEqual(expected, actual);
}
static void Main(string[] args)
{
do
{
Console.Write("> ");
string expr = Console.ReadLine();
AntlrInputStream inputStream = new AntlrInputStream(expr);
ExprLexer exprLexer = new ExprLexer(inputStream);
CommonTokenStream tokenStream = new CommonTokenStream(exprLexer);
ExprParser exprParser = new ExprParser(tokenStream);
exprParser.BuildParseTree = true;
var cst = exprParser.compileUnit();
try
{
var ast = new BuildAstVisitor().VisitCompileUnit(cst);
#if DEBUG
PrintAst(ast, 0);
#endif
Console.WriteLine($"= {new AstEvaluator().Visit(ast)}");
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
} while (true);
}
public void Pi()
{
var actual = ExprParser.ParseOrThrow("2×π");
var expected = Literal.Create(2) * new Identifier("π");
Assert.AreEqual(expected, actual);
}
public AstNode Parse(ExprParser parser, Token.Token token)
{
var expr = parser.Parse(0);
parser.Consume(Token.Token.TokenType.RightParen);
return(expr);
}
public async Task <IActionResult> Get7([FromBody] ConditionsRequest request)
{
List <Entity> listTest = request.entities;
ListOfConditions conditionsList = request.ListOfConditions;
foreach (var item in conditionsList.conditions)
{
item.result = validateCondition(entities: listTest, condition: item);
}
string[] arrayOfResult = conditionsList.conditions.Select(c => c.result.ToString().ToLower()).ToArray();
string newResult = string.Format(conditionsList.fullCondition, arrayOfResult);
var ep = new ExprParser();
string lambdaExpression = newResult.Replace("OR", "||").Replace("AND", "&&");
LambdaExpression lambda; // = ep.Parse(lambdaExpression);
lambda = ep.Parse("(10 * 15 – 11) > 100 ? 'right result' : 'wrong result'"); // string constant is enclosed by either ‘ or \”
int result = (int)ep.Run(lambda);
//string result = (string)ep.Run(lambda);
_presenter.Populate(result.ToString());
return(_presenter.ViewModel);
}
public void NestedEqualsOpTest()
{
var e = ExprParser.ParseOrThrow("a=b=c");
if (e is EqualsOp eo)
{
if (eo.Left is EqualsOp oo && oo.Left is Identifier i1 && oo.Right is Identifier i2)
{
Assert.AreEqual(i1.Definition, "a");
Assert.AreEqual(i2.Definition, "b");
}
else
{
Assert.Fail($"{eo.Left} not an equalsop.");
}
if (eo.Right is Identifier i)
{
Assert.AreEqual(i.Definition, "c");
}
else
{
Assert.Fail($"{eo.Right} is not an identifier.");
Assert.Fail();
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public java.util.List<nomitech.common.db.local.FunctionArgumentTable> getReferringVariablesForStatement(String paramString) throws java.io.IOException, org.boris.expr.ExprException
public virtual IList <FunctionArgumentTable> getReferringVariablesForStatement(string paramString)
{
this.refArgsIns = new List <object>();
ExprParser exprParser = new ExprParser();
exprParser.ParserVisitor = this;
exprParser.parse(new ExprLexer(paramString));
System.Collections.IList list = this.refArgsIns;
this.refArgsIns = null;
List <object> arrayList1 = new List <object>();
List <object> arrayList2 = new List <object>();
foreach (FunctionArgumentTable functionArgumentTable in list)
{
arrayList1.Add(functionArgumentTable);
if (functionArgumentTable.Type.Equals("datatype.calcvalue") && !arrayList2.Contains(functionArgumentTable.ValidationStatement))
{
arrayList2.Add(functionArgumentTable.ValidationStatement);
}
}
foreach (string str in arrayList2)
{
list = getReferringVariablesForStatement(str);
foreach (FunctionArgumentTable functionArgumentTable in list)
{
if (!arrayList1.Contains(functionArgumentTable))
{
arrayList1.Add(functionArgumentTable);
}
}
}
return(list);
}
public void PowerOpTest()
{
var actual = PowerOp.Create(Two, D);
Assert.AreEqual(ExprParser.ParseOrThrow("2^d"), actual);
Assert.AreEqual(Two.Raise(D), actual);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: protected org.boris.expr.Expr parseExpression(String paramString) throws org.boris.expr.ExprException
protected internal virtual Expr parseExpression(string paramString)
{
Expr expr;
if (!paramString.StartsWith("=", StringComparison.Ordinal))
{
expr = Exprs.parseValue(paramString);
}
else
{
paramString = paramString.Substring(1);
ExprParser exprParser = new ExprParser();
exprParser.ParserVisitor = this;
try
{
exprParser.parse(new ExprLexer(paramString));
}
catch (IOException iOException)
{
throw new ExprException(iOException);
}
expr = exprParser.get();
}
return(expr);
}
public void ExprTest()
{
const string input = "12 * 3 + foo(-3, x)() * (2 + 1)";
var actual = AddOp.Create(
MultiplyOp.Create(
Literal.Create(12),
Literal.Create(3)
),
MultiplyOp.Create(
Call.Create(
Call.Create(
new Identifier("foo"),
NegativeOp.Create(Literal.Create(3)),
new Identifier("x")
)
),
AddOp.Create(
new Two(),
new One()
)
)
).Simplify();
var expected = ExprParser.ParseOrThrow(input);
Assert.AreEqual(expected.Simplify(), actual);
}
public void Test6()
{
const string input = "(1-a*(3-4)*x/21)^3-(1/2)^5+11-(16.31^3-a)*r*f(x)";
var ex2 = ExprParser.ParseOrThrow("16.31^3");
ex2 = ex2.Simplify();
Assert.AreEqual(ex2, DivideOp.Create(4338722591, 1000000));
var a = new Identifier("a");
var one = new One();
var three = Literal.Create(3);
var four = Literal.Create(4);
var x = new Identifier("x");
var twentyone = Literal.Create(21);
var two = new Two();
var five = Literal.Create(5);
var eleven = Literal.Create(11);
var sixteenPthirtyone = ExprParser.ParseOrThrow("16.31");
var r = new Identifier("r");
var fOfx = Call.Create(new Identifier("f"), x);
var expected = ExprParser.ParseOrThrow(input);
var actual = (one - (a * (three - four) * x / twentyone)).Raise(three) - (one / two).Raise(five) + eleven - ((sixteenPthirtyone.Raise(three) - a) * r * fOfx).Simplify();
Assert.AreEqual(expected.Simplify(), actual);
Assert.AreEqual((a * r * fOfx) - (Literal.Create(4338722591) * r * fOfx / Literal.Create(1000000)) + (a.Raise(three) * x.Raise(three) / Literal.Create(9261)) + (a.Raise(two) * x.Raise(two) / Literal.Create(147)) + (a * x / Literal.Create(7)) + (Literal.Create(383) / Literal.Create(32)), actual);
}
public void QuantityTwoMinus_a_raisedTo1DividedBy3Test()
{
var actual = DivideOp.Create(PowerOp.Create(SubtractOp.Create(new Two(), new Identifier("a")), new One()), Literal.Create(3)).Simplify();
var expected = ExprParser.ParseOrThrow("(2-a)^1/3").Simplify();
Assert.AreEqual(expected, actual);
}
public void ParseSciNotWithParenTest()
{
var f = ExprParser.ParseOrThrow("1.2340000E(4)");
Assert.AreEqual(f, (new One() * Literal.Create(10000)) + Literal.Create(2340));
Assert.AreEqual(f, Literal.Create(2340) + (Literal.Create(10000) * new One()));
}
public void A_RaiseToQuantity1Plus2Test()
{
var actual = new Identifier("a").Raise(new One() + new Two()).Simplify();
var expected = ExprParser.ParseOrThrow("a^(1+2)").Simplify();
Assert.AreEqual(expected.Simplify(), actual);
}
public void ExpressionWithLogicTest(string text, int nexp)
{
var expr = ExprParser.Parse(text);
Assert.IsNotNull(expr);
Assert.AreEqual(nexp, expr.ExprEntries.Count);
}
public void RaisedToNumberThenAddTest()
{
var actual = AddOp.Create(PowerOp.Create(A, One), Two);
Assert.AreEqual(ExprParser.ParseOrThrow("a^1+2"), actual);
Assert.AreEqual(A.Raise(One) + Two, actual.Simplify());
}
public void TestNamedPlaceholders()
{
ExprParser parser = new ExprParser("a = :a and b = :b and (c = 'x' or d = :b)");
Assert.Equal("IDENT(a)", parser.tokens[0].ToString());
Assert.Equal("EQ", parser.tokens[1].ToString());
Expr e = parser.Parse();
Assert.Equal(0, parser.placeholderNameToPosition["a"]);
Assert.Equal(1, parser.placeholderNameToPosition["b"]);
Assert.Equal(2, parser.positionalPlaceholderCount);
Expr aEqualsPlaceholder = e.Operator.Param[0].Operator.Param[0].Operator.Param[1];
Assert.Equal(Expr.Types.Type.Placeholder, aEqualsPlaceholder.Type);
Assert.Equal((uint)0, aEqualsPlaceholder.Position);
Expr bEqualsPlaceholder = e.Operator.Param[0].Operator.Param[1].Operator.Param[1];
Assert.Equal(Expr.Types.Type.Placeholder, bEqualsPlaceholder.Type);
Assert.Equal((uint)1, bEqualsPlaceholder.Position);
Expr dEqualsPlaceholder = e.Operator.Param[1].Operator.Param[1].Operator.Param[1];
Assert.Equal(Expr.Types.Type.Placeholder, dEqualsPlaceholder.Type);
Assert.Equal((uint)1, dEqualsPlaceholder.Position);
}
public void TrailingZerosOnSciNo()
{
var f = ExprParser.ParseOrThrow("1.2340000E4");
Assert.AreEqual(f, (new One() * Literal.Create(10000)) + Literal.Create(2340));
Assert.AreEqual(f, Literal.Create(2340) + (Literal.Create(10000) * new One()));
}
public void TestExprAsPathDocumentProjection()
{
List <Projection> projList = new ExprParser("$.a as b, (1 + 1) * 100 as x, 2 as j42").ParseDocumentProjection();
Assert.Equal(3, projList.Count);
// check $.a as b
Projection proj = projList[0];
IList <DocumentPathItem> paths = proj.Source.Identifier.DocumentPath;
Assert.Equal(1, paths.Count);
Assert.Equal(DocumentPathItem.Types.Type.Member, paths[0].Type);
Assert.Equal("a", paths[0].Value);
Assert.Equal("b", proj.Alias);
// check (1 + 1) * 100 as x
proj = projList[1];
Assert.Equal("((1 + 1) * 100)", ExprUnparser.ExprToString(proj.Source));
Assert.Equal("x", proj.Alias);
// check 2 as j42
proj = projList[2];
Assert.Equal("2", ExprUnparser.ExprToString(proj.Source));
Assert.Equal("j42", proj.Alias);
}
//判斷是否一個 cond (條件判斷)
static public bool IsCond(string line)
{
//首先得有個問號
//first there has to be a question mark
if (line.Contains('?'))
{
//以問題分隔開條件和語句
string[] split = line.Split('?');
string tmp;
//左手邊必須是合法條件式
if (!ExprParser.TryParse(split[0], out tmp))
{
return(false);
}
//右手邊的語句必須是一個合法的 multi (留 multi 也包含了所有次級的定義: decla, exec, basic)
//lastly the right hand side has to be a multi
if (IsMulti(line.Replace(split[0] + "?", "")))
{
return(true);
}
}
return(false);
}
public void EmptyGroupsTest(string text, int grpn)
{
var expr = ExprParser.Parse(text);
Assert.IsNotNull(expr);
Assert.AreEqual(grpn, expr.ExprEntries.Count);
}
public void EmptyStringTest(string text)
{
var expr = ExprParser.Parse(text);
Assert.IsNotNull(expr);
Assert.False(expr.ExprEntries.Any());
}
public void BracketsTest()
{
var actual = ExprParser.ParseOrThrow("1+[2+y]/{x*(y+4)}");
var expected = new One() + (AddOp.Create(new Two(), new Identifier("y")) / MultiplyOp.Create(new Identifier("x"), AddOp.Create(4, new Identifier("y"))));
Assert.AreEqual(expected, actual);
}
public void FractionRaisedToNegative()
{
var expected = ExprParser.ParseOrThrow("(a/b)^-1");
var actual = DivideOp.Create(new Identifier("b"), new Identifier("a"));
Assert.AreEqual(expected.Simplify(), actual);
}
public void TestNumberedPlaceholders()
{
ExprParser parser = new ExprParser("a == :1 and b == :3 and (c == :2 or d == :2)");
Expr e = parser.Parse();
Assert.Equal(0, parser.placeholderNameToPosition["1"]);
Assert.Equal(1, parser.placeholderNameToPosition["3"]);
Assert.Equal(2, parser.placeholderNameToPosition["2"]);
Assert.Equal(3, parser.positionalPlaceholderCount);
Expr aEqualsPlaceholder = e.Operator.Param[0].Operator.Param[0].Operator.Param[1];
Assert.Equal(Expr.Types.Type.Placeholder, aEqualsPlaceholder.Type);
Assert.Equal((uint)0, aEqualsPlaceholder.Position);
Expr bEqualsPlaceholder = e.Operator.Param[0].Operator.Param[1].Operator.Param[1];
Assert.Equal(Expr.Types.Type.Placeholder, bEqualsPlaceholder.Type);
Assert.Equal((uint)1, bEqualsPlaceholder.Position);
Expr cEqualsPlaceholder = e.Operator.Param[1].Operator.Param[0].Operator.Param[1];
Assert.Equal(Expr.Types.Type.Placeholder, cEqualsPlaceholder.Type);
Assert.Equal((uint)2, cEqualsPlaceholder.Position);
Expr dEqualsPlaceholder = e.Operator.Param[1].Operator.Param[1].Operator.Param[1];
Assert.Equal(Expr.Types.Type.Placeholder, dEqualsPlaceholder.Type);
Assert.Equal((uint)2, dEqualsPlaceholder.Position);
}
public void TwoMinus_a_PowerOf1Test()
{
var actual = SubtractOp.Create(new Two(), PowerOp.Create(new Identifier("a"), new One()));
var expected = ExprParser.ParseOrThrow("2-a^1");
Assert.AreEqual(expected, actual);
}
static void Main(string[] args)
{
var input = new ANTLRStringStream("a=(3+4)*5\r\na+1\r\n");
var lexer = new ExprLexer(input);
var tokens = new CommonTokenStream(lexer);
var parser = new ExprParser(tokens);
parser.prog();
}
static void Main(string[] args)
{
using (var stardardInput = Console.OpenStandardInput())
{
ANTLRInputStream input = new ANTLRInputStream(stardardInput);
ExprLexer lexer = new ExprLexer(input);
CommonTokenStream tokens = new CommonTokenStream(lexer);
ExprParser parser = new ExprParser(tokens);
parser.prog();
}
Console.ReadKey();
}
public static void Main(string[] args)
{
try
{
ICharStream input = new ANTLRReaderStream(System.Console.In);
ExprLexer lexer = new ExprLexer(input);
CommonTokenStream tokens = new CommonTokenStream(lexer);
ExprParser parser = new ExprParser(tokens);
parser.prog();
}
catch (System.Exception e)
{
Console.Error.WriteLine("exception: " + e);
Console.Error.WriteLine(e.StackTrace);
}
}
public static void Main(string[] args)
{
try {
ExprLexer lexer = new ExprLexer(new CharBuffer(Console.In));
ExprParser parser = new ExprParser(lexer);
// set the type of tree node to create; this is default action
// so it is unnecessary to do it here, but demos capability.
parser.setASTNodeClass("antlr.CommonAST");
parser.expr();
antlr.CommonAST ast = (antlr.CommonAST)parser.getAST();
if (ast != null) {
Console.Out.WriteLine(ast.ToStringList());
} else {
Console.Out.WriteLine("null AST");
}
} catch(Exception e) {
Console.Error.WriteLine("exception: "+e);
}
}
