private static OperatorTable <T> BuildOperatorsTable <T>(TokenParser <T> lexer)
where T : Token
{
Func <T, T, ReservedOpToken, T> fn = (lhs, rhs, op) =>
{
return(new BinaryOp(lhs, rhs, op) as T);
};
Func <ReservedOpToken, Func <T, T, T> > binop = op => new Func <T, T, T>((T lhs, T rhs) =>
{
return(fn(lhs, rhs, op));
});
Func <string, Parser <Func <T, T, T> > > resOp = name => from op in lexer.ReservedOp(name) select binop(op);
var equals = new Infix <T>("=", resOp("="), Assoc.Left);
var mult = new Infix <T>("*", resOp("*"), Assoc.Left);
var divide = new Infix <T>("/", resOp("/"), Assoc.Left);
var plus = new Infix <T>("+", resOp("+"), Assoc.Left);
var minus = new Infix <T>("-", resOp("-"), Assoc.Left);
var lessThan = new Infix <T>("<", resOp("<"), Assoc.Left);
var binops = new OperatorTable <T>();
binops.AddRow().Add(equals)
.AddRow().Add(mult).Add(divide)
.AddRow().Add(plus).Add(minus)
.AddRow().Add(lessThan);
return(binops);
}
public DiceGrammar()
{
DefaultParserFlags = ParserFlags.IGNORE_LEADING_WHITESPACE | ParserFlags.IGNORE_TRAILING_WHITESPACE;
var digits = "0123456789";
var d = Keyword("d");
var number = Token(c => digits.Contains(c)).CreateAst("NUMBERLIT");
var die = ((d + number).CreateAst("SINGLE_DIE") | (number + d + number).CreateAst("MULTIPLE_DICE"));
var opTable = new OperatorTable();
opTable.AddOperator("+", 2);
opTable.AddOperator("-", 2);
opTable.AddOperator("*", 3);
var statement = LateBound();
var expression = LateBound();
var term = LateBound();
var op = Operator(opTable).CreateAst("OP");
expression.SetSubParser(Expression(term, op, opTable));
term.SetSubParser((die.PassThrough() | number.PassThrough()).CreateAst("TERM"));
this.Root = expression;
//Console.WriteLine("Result: " + CalculateDieRoll(TestParse("4d6"), new Random()));
//Console.WriteLine("Result: " + CalculateDieRoll(TestParse("4d6+8"), new Random()));
//Console.WriteLine("Result: " + CalculateDieRoll(TestParse("4d6+5d10+3-1d6"), new Random()));
//Console.WriteLine("Result: " + CalculateDieRoll(TestParse("4d6+d10"), new Random()));
}
public TokenSeqToTerm(OperatorTable opTable)
{
IS = new TokenStack("IS");
OS = new TokenStack("OS"); // operator stack
PS = new TokenStack("PS");
IS.Push(SeqStartToken);
inOpAtBoS = false;
}
/// <summary>
/// 新規にパーサーを作成します。
/// </summary>
private Grammar CreateParser(AngleMode angleMode)
{
var sDelim = Scanners.IsWhitespaces().Many_();
var OPs = Terms.GetOperatorsInstance(
"+", "-", "**", "*", "/", "%", "(", ")", ",", "#");
var lToken = OPs.Lexer | Lexers.LexDecimal() | Lexers.LexWord();
var lexeme = Lexers.Lexeme(sDelim, lToken).FollowedBy(Parsers.Eof());
var pNumber = Terms.OnDecimal((from, len, s) => double.Parse(s));
var pWord = Terms.OnWord((from, len, s) => s);
Terms.FromSimpleToken <string, string>((from, len, s) => s);
var pPlus = GetOperator(OPs, "+", new Binary((a, b) => (a + b)));
var pMinus = GetOperator(OPs, "-", new Binary((a, b) => (a - b)));
var pMul = GetOperator(OPs, "*", new Binary((a, b) => (a * b)));
var pDiv = GetOperator(OPs, "/", new Binary((a, b) => (a / b)));
var pMod = GetOperator(OPs, "%", new Binary((a, b) => (a % b)));
var pPow = GetOperator(OPs, "**", new Binary((a, b) => Math.Pow(a, b)));
var pNone = GetOperator(OPs, "+", new Unary(n => n));
var pNeg = GetOperator(OPs, "-", new Unary(n => - n));
var opTable = new OperatorTable <double>()
.Infixl(pPlus, 10)
.Infixl(pMinus, 10)
.Infixl(pMul, 20)
.Infixl(pDiv, 20)
.Infixl(pMod, 20)
.Infixr(pPow, 30)
.Prefix(pNone, 40)
.Prefix(pNeg, 40);
var pLParen = OPs.GetParser("(");
var pRParen = OPs.GetParser(")");
var pComma = OPs.GetParser(new string[] { ",", "#" });
var lazyExpr = new Grammar[1];
var pLazyExpr = Parsers.Lazy <double>(() => lazyExpr[0]);
var pArg
= pLazyExpr.SepEndBy(pComma).Between(pLParen, pRParen)
| pLParen.Seq(pRParen).Seq(Parsers.Return(new double[0]));
var pTerm
= pLazyExpr.Between(pLParen, pRParen)
| pWord.And(pArg.Optional(), new Map <string, double[], double>(CalcFunc))
| pNumber;
var pExpr = Expressions.BuildExpressionParser(pTerm, opTable);
lazyExpr[0] = pExpr;
return(Parsers.ParseTokens(lexeme, pExpr.FollowedBy(Parsers.Eof()), "calculator"));
}
public Dependency(String uniqueName, String operatorToken, Version version)
{
UniqueName = uniqueName;
OperatorToken = operatorToken;
Version = version;
TestDelegate d;
if (!OperatorTable.TryGetValue(operatorToken, out d))
{
throw new ArgumentOutOfRangeException("Unrecognized constraint operator: " + operatorToken);
}
_testDelegate = d;
}
public void Init(OperatorTable ot)
{
IComparer <string> comparer = new OTMComp();
this.map = new SortedList <string, List <Operator> >(comparer);
foreach (Operator @operator in ot.GetOperators())
{
string symbol = @operator.GetSymbol();
Operator item = @operator;
if (!item.NotInParser())
{
List <Operator> list;
if (this.map.ContainsKey(symbol))
{
list = this.map[symbol];
list.Add(item);
}
else
{
list = new List <Operator> {
item
};
this.map.Add(symbol, list);
}
if (item.IsTernary())
{
string rhsSymbol = ((TernaryOperator)@operator).GetRhsSymbol();
if (!item.NotInParser())
{
list = this.map[rhsSymbol];
if (list == null)
{
list = new List <Operator>();
}
list.Add(((TernaryOperator)@operator).GetRhsOperator());
this.map.Add(rhsSymbol, list);
}
}
}
}
this.tokens = new SortedList <string, OperatorToken>(comparer);
foreach (string str3 in this.map.Keys)
{
this.tokens.Add(str3, new OperatorToken(this.map[str3]));
}
}
/// <summary> Creates a Parser object based on information described by OperatorTable.</summary>
/// <param name="term">parser for the terminals.
/// </param>
/// <param name="table">the operator table.
/// </param>
/// <returns> the expression parser.
/// </returns>
public static Parser <T> BuildExpressionParser <T>(Parser <T> term, OperatorTable <T> table)
{
OperatorTable <T> .Operator[] ops = table.Operators;
if (ops.Length == 0)
{
return(term);
}
int begin = 0;
int prec = ops[0].Precedence;
OperatorKind kind = ops[0].Kind;
int end = 0;
Parser <T> ret = term;
for (int i = 1; i < ops.Length; i++)
{
OperatorTable <T> .Operator op = ops[i];
end = i;
if (op.Precedence == prec && op.Kind == kind)
{
continue;
}
else
{
end = i;
Parser p = slice <T>(kind, ops, begin, end);
ret = build(p, kind, ret);
begin = i;
prec = ops[i].Precedence;
kind = ops[i].Kind;
}
}
if (end != ops.Length)
{
end = ops.Length;
kind = ops[begin].Kind;
Parser p = slice <T>(kind, ops, begin, end);
ret = build(p, kind, ret);
}
return(ret);
}
public async Task <IActionResult> Calculate(string meansOfCalculation, int firstNumber, int secondNumber)
{
if (!OperatorTable.ContainsKey(meansOfCalculation))
{
return(BadRequest());
}
var targetEndpoint = OperatorTable[meansOfCalculation];
var request = CreateHttpRequest(HttpMethod.Get, targetEndpoint, firstNumber, secondNumber);
var responseContent = await SendRequestAndReadResponse(request);
var result = HandleResponse(meansOfCalculation, firstNumber, secondNumber, responseContent);
var saveRequest = SendResultToDatabase(new Calculation
{
NumberOne = firstNumber,
NumberTwo = secondNumber,
Result = result,
TypeOfCalculation = ChangeStringValue(meansOfCalculation)
});
var jsonOptions = new JsonSerializerOptions
{
PropertyNameCaseInsensitive = true
};
var json = await(await _client.SendAsync(saveRequest)).Content.ReadAsStringAsync();
var entity = JsonSerializer.Deserialize <Calculation>(json, jsonOptions);
var id = entity.CalculationId;
TempData["result"] = result;
TempData["entityId"] = id.ToString();
return(View("Index"));
}
public Operator(OperatorTable OperatorTable)
{
this.OperatorTable = OperatorTable;
}
public Expression(Parser TermParser, Parser OperatorParser, OperatorTable OperatorTable)
{
this.TermParser = TermParser;
this.OperatorParser = OperatorParser;
this.OperatorTable = OperatorTable;
}
/// <summary>
/// Execute operator
/// </summary>
/// <param name="n">tree node</param>
public void ExecOp(TreeNode n)
{
NetLogoObject obj = null;
//create parse tree to get operator list THIS IS A HACK
ParseTree t = new ParseTree("");
try
{
if (nodeFull(n))
{
if (t.IsOperator(n.left))
{
ExecOp(n.left);
}
if (t.IsOperator(n.right))
{
ExecOp(n.right);
}
#if OPTRACK || ALLTRACK
Performance.PeformanceTracker.StartStopWatch(n.data);
#endif
obj = OperatorTable.Call <NetLogoObject>(sys.Assign(n.left.data, false),
sys.Assign(n.right.data, false), n.data);
}
else if (n.left != null)
{
obj = OperatorTable.Call <NetLogoObject>(sys.Assign(n.left.data, false),
new NetLogoObject()
{
ptrID = "NULLPTR"
}, n.data);
}
else
{
obj = OperatorTable.Call <NetLogoObject>(new NetLogoObject()
{
ptrID = "NULLPTR"
},
new NetLogoObject()
{
ptrID = "NULLPTR"
}, n.data);
}
//place results of the operation on tree
TreeNode tempNode = new TreeNode(obj.value.ToString());
#if OPTRACK || ALLTRACK
Performance.PeformanceTracker.Stop(n.data);
#endif
//replace node
if (n.parent != null)
{
if (n.parent.left == n)
{
n.parent.left = tempNode;
}
else if (n.parent.right == n)
{
n.parent.right = tempNode;
}
tempNode.parent = n.parent;
}
}
catch (Exception e)
{
throw e;
}
}
public static BaseTerm FindRegexMatches(
OperatorTable opTable, string source, string matchPattern, string[] options)
{
Regex re = null;
RegexOptions reOptions = RegexOptions.None;
if (options != null)
{
foreach (string o in options)
{
switch (o.ToLower())
{
case "ignorecase":
reOptions |= RegexOptions.IgnoreCase;
break;
case "multiline":
reOptions |= RegexOptions.Multiline;
break;
case "singleline":
reOptions |= RegexOptions.Singleline;
break;
case "explicitcapture":
reOptions |= RegexOptions.ExplicitCapture;
break;
case "cultureinvariant":
reOptions |= RegexOptions.CultureInvariant;
break;
default:
IO.Error("match_regex -- unsupported option '{0}'", o);
break;
}
}
;
}
try
{
re = new Regex(matchPattern, reOptions); //, RegexOptions.Multiline);
}
catch (Exception x)
{
IO.Error("Error in regular expression '{0}'\r\nMessage: {1}", matchPattern, x.Message);
}
Match m = re.Match(source);
if (!m.Success)
{
return(null);
}
int[] gnums = re.GetGroupNumbers();
BaseTerm groups = new ListTerm();
while (m.Success)
{
for (int i = 1; i < gnums.Length; i++) // start at group 1 (0 is the fully captured match string)
{
Group g = m.Groups[gnums[i]];
BaseTerm captures = new ListTerm();
string groupId = re.GetGroupNames()[i];
int groupNo;
BaseTerm groupIdTerm;
foreach (Capture c in g.Captures)
{
captures = ((ListTerm)captures).AppendElement(new StringTerm(c.ToString()));
}
if (int.TryParse(groupId, out groupNo))
{
groupIdTerm = new DecimalTerm(groupNo);
}
else
{
groupIdTerm = new StringTerm(re.GetGroupNames()[i]);
}
groups = ((ListTerm)groups).AppendElement(
new OperatorTerm(opTable, ":", groupIdTerm, captures));
}
m = m.NextMatch();
}
if (((ListTerm)groups).ProperLength == 1)
{
groups = groups.Arg(0); // groups is <groupname>:[<captures>]
if (groups.Arg(0) is DecimalTerm)
{
groups = groups.Arg(1); // anonymous group, just return the list of captures
}
}
return(groups);
}
public void Init(JepInstance jep)
{
this.nf = jep.NodeFac;
this.ot = jep.OpTab;
}
