Node Expression()
{
// Expr := Term {('+' | '-') Term}
Node result = Term();
TokenType token = scanner.Token;
if (token == TokenType.TokenPlus || token == TokenType.TokenMinus)
{
SumNode node = new SumNode(result);
do
{
scanner.Accept();
Node child = Term();
if (token == TokenType.TokenMinus)
{
child = new MultiNode(new NumberNode(new Number(-1)), child);
}
node.Children.Add(child);
token = scanner.Token;
} while (token == TokenType.TokenPlus || token == TokenType.TokenMinus);
result = node;
}
return(result);
}
Node SimpleFactor()
{
// SimpFactor := '(' Expr ')'
// or '|' Expr '|'
// or Number
// or Identifier
// or '-' Factor
Node result;
TokenType token = scanner.Token;
if (token == TokenType.TokenLParen)
{
scanner.Accept();
result = Expression();
if (scanner.Token == TokenType.TokenRParen)
{
scanner.Accept();
}
else
{
status = Status.Error;
}
}
else if (token == TokenType.TokenTube)
{
scanner.Accept();
result = new AbsoluteValueNode(Expression());
if (scanner.Token == TokenType.TokenTube)
{
scanner.Accept();
}
else
{
status = Status.Error;
}
}
else if (token == TokenType.TokenNumber)
{
result = new NumberNode(new Number(scanner.Number));
scanner.Accept();
}
else if (token == TokenType.TokenIdentifer)
{
result = new UnknownNode(scanner.Symbol);
scanner.Accept();
}
else if (token == TokenType.TokenMinus)
{
scanner.Accept();
result = new MultiNode(new NumberNode(new Number(-1)), Factor());
}
else
{
status = Status.Error;
result = null;
}
return(result);
}
public override SimplifyResult Replace(out Node node)
{
if (typeof(NumberNode).IsInstanceOfType(RChild))
{
node = new MultiNode(LChild, new NumberNode(new Number(1) / ((NumberNode)RChild).Value));
return(new SimplifyResult(true, true));
}
// FIXME: because of DirectEqualsTo is no longer availible, we have to set up some new
// NodeHelper.DirectEquals(), and NodeHelper.FindCommonFactor(a, b, out c).
/*
* if (typeof(UnknownNode).IsInstanceOfType(RChild))
* if (typeof(MultiNode).IsInstanceOfType(LChild))
* {
* MultiNode l = (MultiNode)LChild;
* UnknownNode r = (UnknownNode)RChild;
* l.Children.Remove(l.Children.First((x) =>
* typeof(UnknownNode).IsInstanceOfType(x) && x.DirectEqualsTo(r)));
*
* node = l;
* return true;
* }
*/
node = null;
return(new SimplifyResult(false));
}
public override SimplifyResult Replace(out Node node)
{
if (Children.Count == 0)
{
node = new NumberNode(Number.One);
return(new SimplifyResult(true));
}
node = Children[0];
for (int i = 1; i < Children.Count; i++)
{
if (Sign[i])
{
node = new MultiNode(Children[i], node);
}
else
{
node = new DivideNode(node, Children[i]);
}
}
return(new SimplifyResult(true));
}
public override SimplifyResult Replace(out Node node)
{
if (typeof(NumberNode).IsInstanceOfType(RChild) ||
((NumberNode)RChild).Value.M == 1)
{
NumberNode n = (NumberNode)RChild;
if (n.Value.N == 0)
{
node = new NumberNode(Number.One);
return(new SimplifyResult(true));
}
else
{
MultiNode result = new MultiNode();
long x = Math.Abs(n.Value.N);
for (long i = 0; i < x; i++)
{
result.Children.Add(LChild);
}
if (n.Value.N < 0)
{
node = new DivideNode(new NumberNode(Number.One), result);
}
else
{
node = result;
}
return(new SimplifyResult(true, true));
}
}
else
{
node = null;
return(new SimplifyResult(false));
}
}
