public MathExpParser()
{
_operatorStack = countOperators(_inputEquation);
_operatorsStackCopy = new Stack<nodeValue>(_operatorStack);
_operatorStack = new Stack<nodeValue>(_operatorStack);
_variable = new Stack<string>();
}
/// <summary>
/// Function converts stack with two-address instruction commands into pbStack with one-address instruction commands.
/// </summary>
/// <returns>Stack with one-address instruction commands.</returns>
public Stack<Command> populateStack()
{
Stack<Command> returnVal = new Stack<Command>();
Stack<Command> tempStack ;
Command loadCommand;
Command OperationCommand;
Command SaveCommand;
foreach (Command currCommand in CommandStack)
{
if (currCommand.leftOperand == null)
{
if (currCommand.rightOperand == null)
{
// if Right points direct to value and Left operand stores in MemoryCell
// Save result to Memory Cell
// KOP |MEM |M{#}|
SaveCommand = new Command(CommandBase.commVals.Mem, currCommand.MemoryCellUsed);
returnVal.Push(SaveCommand);
// Load Right operand and Evaluate Operation
// KOP |OP |RO|
OperationCommand = new Command((CommandBase.commVals)currCommand.Code, currCommand.MemoryCellNeededExtra, true);
returnVal.Push(OperationCommand);
// Load left operand
// KOP |LOAD |M{#}|
loadCommand = new Command(CommandBase.commVals.Load, currCommand.MemoryCellNeeded);
returnVal.Push(loadCommand);
}
else
{
// if Right points direct to value and Left operand stores in MemoryCell
// Save result to Memory Cell
// KOP |MEM |M{#}|
SaveCommand = new Command(CommandBase.commVals.Mem, currCommand.MemoryCellUsed);
returnVal.Push(SaveCommand);
// Load Right operand and Evaluate Operation
// KOP |OP |RO|
OperationCommand = new Command((CommandBase.commVals)currCommand.Code, currCommand.MemoryCellNeeded);
returnVal.Push(OperationCommand);
// Load left operand
// KOP |LOAD |M{#}|
loadCommand = new Command(CommandBase.commVals.Load, currCommand.MemoryCellNeeded);
returnVal.Push(loadCommand);
}
}
else
if (currCommand.rightOperand == null)
{
// if Left points direct to value and Right operand stores in MemoryCell
// Save result to Memory Cell
// KOP |MEM |M{#}|
SaveCommand = new Command(CommandBase.commVals.Mem, currCommand.MemoryCellUsed);
returnVal.Push(SaveCommand);
// Load Right operand and Evaluate Operation
// KOP |OP |M{#}|
OperationCommand = new Command((CommandBase.commVals)currCommand.Code, currCommand.MemoryCellNeeded);
returnVal.Push(OperationCommand);
// Load left operand
// KOP |LOAD |LO|
loadCommand = new Command(CommandBase.commVals.Load, currCommand.leftOperand);
returnVal.Push(loadCommand);
}
else
{
// if Left and Right Operands are points direct to their values.
// Save result to Memory Cell
// KOP |MEM |M{#}|
SaveCommand = new Command(CommandBase.commVals.Mem, currCommand.MemoryCellUsed);
returnVal.Push(SaveCommand);
// Load Right operand and Evaluate Operation
// KOP |OP |RO|
OperationCommand = new Command((CommandBase.commVals)currCommand.Code, currCommand.rightOperand);
returnVal.Push(OperationCommand);
// Load left operand
// KOP |LOAD |LO|
loadCommand = new Command(CommandBase.commVals.Load, currCommand.leftOperand);
returnVal.Push(loadCommand);
}
}// foreach
//tempStack = new Stack<Command>(returnVal);
//return tempStack;
return returnVal;
}
public Stack()
{
CommandStack = new Stack<Command>();
StackMemory = new List<MemoryCell>();
}
public int compile(String equation)
{
_inputEquation = equation;
Console.WriteLine("Analizing... \n\r \tEquation=[" + _inputEquation + "]");
_curStackValue = new nodeValue();
// Creating root
DTreeNode<String> root = new DTreeNode<String>();
//DTreeBuilder<nodeValue> trB = new DTreeBuilder<nodeValue>();
// Initing root
root.Value = "Root";//_operatorStack.Peek();
// Position to add next Node
DTreeNode<String> curNode = null;
// Position where were added last Node
DTreeNode<String> lastNode = null;
// Temporary data storage
DTreeNode<String> tempNode = null;
// Temporary data storage
DTreeNode<String>[] tempNodeArray = null;
// DEBUG Operators position and index
if (verifyAlpha())
{
}
while (_operatorStack.Count > 0)
{
_curStackValue.ind = _operatorStack.Peek().ind;
_curStackValue.pos = _operatorStack.Peek().pos;
_curStackValue.priority = _operatorStack.Pop().priority;
Console.WriteLine("Ind= " + _curStackValue.ind + " Pos= " + _curStackValue.pos + " Prior= " + _curStackValue.priority);
}
Console.WriteLine("_________________________________________");
if (verifyParentheses())
{
if (verifyParenthesesExp())
{
// Verify all brackets
nodeValue[] allOperators = _operatorsStackCopy.ToArray();
_tempOperStack = new Stack<nodeValue>();
// DEBUG Operators nesting
for (int i = 0; i < allOperators.Length; i++)
{
allOperators[i].nested = getPriorForOperator(allOperators[i].pos);
_tempOperStack.Push(allOperators[i]);
Console.WriteLine("Nesting= " + allOperators[i].nested + " Op" + allOperators[i].operatorSym);
}
Console.WriteLine("_________________________________________");
int curPos, operBeginPos, operEndPos;
bool foundBegin;
char[] sym = { '-', '/', '*', '+', ')', '(' };
// Setting operators operands
for (int i = 0; i < allOperators.Length; i++)
{
foundBegin = false;
// Find left operand
if (_inputEquation[allOperators[i].pos - 1] != ')')
{
operBeginPos = operEndPos = allOperators[i].pos - 1;
while (operBeginPos > 0 && !foundBegin)
{
if (_inputEquation.IndexOfAny(sym, operBeginPos - 1, 1) != -1)
foundBegin = true;
else
operBeginPos--;
}
allOperators[i].operandLeft = _inputEquation.Substring(operBeginPos, operEndPos - operBeginPos + 1);
}
else
{
// Find nested
}
foundBegin = false;
// Find right operand
if (_inputEquation[allOperators[i].pos + 1] != '(')
{
operBeginPos = operEndPos = allOperators[i].pos + 1;
while (operEndPos < _inputEquation.Length - 1 && !foundBegin)
{
if (_inputEquation.IndexOfAny(sym, operEndPos + 1, 1) != -1)
foundBegin = true;
else
operEndPos++;
}
allOperators[i].operandRight = _inputEquation.Substring(operBeginPos, operEndPos - operBeginPos + 1);
}
}
/*
// DEBUG Tree
MainForm testForm = new MainForm();
TreeView testTV = new TreeView();
testForm.Controls.Add(testTV);
testForm.Controls[0].Width = 500;
testForm.Controls[0].Height = 1500;
testTV.Width = 500;
testTV.Height = 1500;
bool first = false;
int lastNested = 0;
int lastPrior = 0;
int curNested = 0;
int curPrior = 0;
string tempString;
TreeViewController<String> treeViewController = new TreeViewController<String>((TreeView)testForm.Controls[0], root);
while (_tempOperStack.Count > 0)
{
curStackValue = _tempOperStack.Pop();
if (!first)
{
// Lowest priority, means last in evaluation
if (curNode != null)
lastNode = curNode.Nodes.Add(curStackValue.toString());
else
curNode = lastNode = root.Nodes.Add(curStackValue.toString());
first = true;
}
else
{
// Lowest priority, means last in evaluation
// The same nesting, adding to to this leave
if (lastNested == curStackValue.nested)
{
if (lastPrior <= curStackValue.priority)
{
lastNode = curNode.Nodes.Add(curStackValue.toString());
//CopyNodeToNode(lastNode, curNode);
//lastNode.Remove();
//lastNode = curNode;
}
else
{
//curNode = root.Nodes.InsertBefore(lastNode, curStackValue.toString());
//CopyNodeToNode(curNode, lastNode);
lastNode = curNode.Nodes.Add(curStackValue.toString());//tempString
}
}
else
{
if (lastNested > curStackValue.nested)
{
if (curNode.Nodes.Count < 2)
{
curNode = curNode.Nodes.Add(curStackValue.toString());
curNested = curStackValue.nested;
curPrior = curStackValue.priority;
tempString = lastNode.Value;
lastNode.Remove();
curNode.Nodes.Add(tempString);
}
else
{
if (curNode.Parent.Parent == null)
{
lastNode = root.Nodes.InsertBefore(curNode, curStackValue.toString());
CopyNodeToNode(curNode, lastNode);
curNode.Remove();
curNode = lastNode;
}
else
{
lastNode = curNode.Parent.Nodes.Add(curStackValue.toString());
curNode = curNode.Parent;
}
}
}
else
{
lastNode = curNode.Nodes.Add(curStackValue.toString());
}
}
}
lastNested = curStackValue.nested;
lastPrior = curStackValue.priority;
}
testForm.ShowDialog();
*/
}
else
{
Console.WriteLine("validation Error! Operator Missing!");
return -1;
}
}
else
{
Console.WriteLine("validation Error! Parentheses Missing!");
return -1;
}
return 0;
}
public Stack<String> getVars()
{
Stack<String> tempStack = new Stack<string>();
MatchCollection mc = Regex.Matches(_inputEquation, @"[a-zA-z]");
if (mc.Count > 0)
{
foreach (Match match in mc)
{
foreach (Capture capture in match.Captures)
{
tempStack.Push(capture.Value);
}
}
return tempStack;
}
else
return null;
}
public Stack<nodeValue> countOperators(string equation)
{
Stack<nodeValue> count = new Stack<nodeValue>();
char[] sym = { '-', '/', '*', '+' };
int n = 0, ind = 0;
int prior;
while ((n = equation.IndexOfAny(sym, n)) != -1)
{
prior = equation[n] == '/' || equation[n] == '*' ? 1 : 0;
count.Push(new nodeValue(0, n, prior, equation[n].ToString()));
n++;
ind++;
}
return count;
}
