public bool TryParse(string formula, out FormulaNode node)
{
if (new UnaryMinusParser(child).TryParse(formula, out node))
{
return(true);
}
node = null;
return(false);
}
public bool TryParse(string formula, out FormulaNode node)
{
if (formula == "+")
{
node = new BinaryAdd(leftNode, rightNode);
return(true);
}
else
{
node = null;
return(false);
}
}
public bool TryParse(string formula, out FormulaNode node)
{
if (formula == "~")
{
node = new UnaryMinus(number);
return(true);
}
else
{
node = null;
return(false);
}
}
public bool TryParse(string formula, out FormulaNode node)
{
node = null;
string[] splitedFormula = formula.Split(' ');
List <String> formulaParts = splitedFormula.ToList <string>();
while (formulaParts.Count != 0)
{
bool validFormat = false;
if (new ConstantParser().TryParse(formulaParts[formulaParts.Count - 1], out node))
{
validFormat = true;
stack.Push(node);
formulaParts.RemoveAt(formulaParts.Count - 1);
continue;
}
if (new UnaryMasterParser(stack.Peek()).TryParse(formulaParts[formulaParts.Count - 1], out node))
{
validFormat = true;
stack.Pop();
stack.Push(node);
formulaParts.RemoveAt(formulaParts.Count - 1);
continue;
}
if (new BinaryMasterParser(stack.Peek(), stack.ElementAt(1)).TryParse(formulaParts[formulaParts.Count - 1], out node))
{
validFormat = true;
stack.Pop();
stack.Pop();
stack.Push(node);
formulaParts.RemoveAt(formulaParts.Count - 1);
continue;
}
if (!validFormat)
{
return(false);
}
}
if (stack.Count == 1)
{
node = stack.Pop();
return(true);
}
else
{
return(false);
}
}
public bool TryParse(string formula, out FormulaNode node)
{
int value;
if (int.TryParse(formula, out value))
{
node = new ConstantNode(value);
return(true);
}
else
{
node = null;
return(false);
}
}
public bool TryParse(string formula, out FormulaNode node)
{
if (new BinaryAddParser(leftNode, rightNode).TryParse(formula, out node))
{
return(true);
}
if (new BinarySubParser(leftNode, rightNode).TryParse(formula, out node))
{
return(true);
}
if (new BinaryMulParser(leftNode, rightNode).TryParse(formula, out node))
{
return(true);
}
if (new BinaryDivParser(leftNode, rightNode).TryParse(formula, out node))
{
return(true);
}
node = null;
return(false);
}
public void ProcessCommand(string formula)
{
try
{
switch (formula)
{
case null:
{
end = true;
break;
}
case "end":
{
end = true;
break;
}
case "p":
{
if (formulaNode != null)
{
IAlgorithm algorithm = new InfixBracketsMaker();
formulaNode.Accept(algorithm);
algorithm.CallResultWriter(writer);
}
else
{
writer.WriteError(ExpressionMissingError.Instance);
}
break;
}
case "P":
{
if (formulaNode != null)
{
IAlgorithm algorithm = new InfixMinBracketsMaker();
formulaNode.Accept(algorithm);
algorithm.CallResultWriter(writer);
}
else
{
writer.WriteError(ExpressionMissingError.Instance);
}
break;
}
case "i":
{
if (formulaNode != null)
{
if (intAlgo == null)
{
intAlgo = new IntegerCalculator();
formulaNode.Accept(intAlgo);
}
intAlgo.CallResultWriter(writer);
}
else
{
writer.WriteError(ExpressionMissingError.Instance);
}
break;
}
case "":
{
break;
}
case "d":
{
if (formulaNode != null)
{
if (doubleAlgo == null)
{
doubleAlgo = new DoubleCalculator();
}
formulaNode.Accept(doubleAlgo);
doubleAlgo.CallResultWriter(writer);
}
else
{
writer.WriteError(ExpressionMissingError.Instance);
}
break;
}
default:
{
if (formula.StartsWith("="))
{
formulaNode = null;
doubleAlgo = null;
intAlgo = null;
if (!new PreorderParser().TryParse(formula.Remove(0, 2), out formulaNode))
{
writer.WriteError(FormatError.Instance);
}
}
else
{
writer.WriteError(FormatError.Instance);
}
break;
}
}
}
catch (DivideByZeroException)
{
writer.WriteError(DivisionError.Instance);
}
catch (OverflowException)
{
writer.WriteError(OverflowError.Instance);
}
catch (FormatException)
{
writer.WriteError(FormatError.Instance);
}
catch (InvalidOperationException)
{
writer.WriteError(FormatError.Instance);
}
catch (ArgumentOutOfRangeException)
{
writer.WriteError(FormatError.Instance);
}
}
public UnaryMinus(FormulaNode child) : base(child)
{
}
public BinaryAddParser(FormulaNode leftNode, FormulaNode rightNode)
{
this.leftNode = leftNode;
this.rightNode = rightNode;
}
public UnaryMinusParser(FormulaNode node)
{
number = node;
}
public UnaryOperationNode(FormulaNode child)
{
this.child = child;
}
public BinaryMul(FormulaNode leftChild, FormulaNode rightChild) : base(leftChild, rightChild)
{
}
public UnaryMasterParser(FormulaNode child)
{
this.child = child;
}
