public void PushItemCountIs1()
{
var stack = new StackAsList <string>();
stack.Push("test");
Assert.AreEqual(1, stack.Count);
}
public void PushItemCanPeekItem()
{
var stack = new StackAsList <string>();
stack.Push("test");
Assert.AreEqual("test", stack.Peek());
}
public void PushTwoItemsPopTopItem()
{
var stack = new StackAsList <string>();
stack.Push("test");
stack.Push("other test");
Assert.AreEqual("other test", stack.Pop());
}
public void PushTwoItemsCountIs2()
{
var stack = new StackAsList <string>();
stack.Push("test");
stack.Push("other test");
Assert.AreEqual(2, stack.Count);
}
public void ClearListCantPopItem()
{
var stack = new StackAsList <string>();
stack.Push("test");
stack.Clear();
stack.Pop();
}
public void ClearListResetsCountTo0()
{
var stack = new StackAsList <string>();
stack.Push("test");
stack.Clear();
Assert.AreEqual(0, stack.Count);
}
public void StackOneItemCanIterate()
{
var stack = new StackAsList <string>();
stack.Push("test");
foreach (var item in stack)
{
Assert.AreEqual("test", item);
}
}
public void PushTwoItemsPopRemainsSecond()
{
var stack = new StackAsList <string>();
stack.Push("test");
stack.Push("other test");
stack.Pop();
Assert.AreEqual(1, stack.Count);
Assert.AreEqual("test", stack.Peek());
}
public void StackAddFiveItemsIterateInReverseOrder()
{
var stack = new StackAsList <int>();
for (int i = 0; i < 5; i++)
{
stack.Push(i);
}
var num = 4;
foreach (var item in stack)
{
Assert.AreEqual(num, item);
num--;
}
}
public void StackAddFiveItemsIterateCountRemains5()
{
var stack = new StackAsList <int>();
for (int i = 0; i < 5; i++)
{
stack.Push(i);
}
var num = 4;
foreach (var item in stack)
{
Assert.AreEqual(num, item);
num--;
}
Assert.AreEqual(5, stack.Count);
}
private void GLR_Parse(List <Dictionary <string, List <Tuple <string, int, string> > > > parseTable, ref TreeNode productionTreeRoot)
{
List <StackAsList> stacks = new List <StackAsList>();
List <StackAsList> nextStacks = new List <StackAsList>();
Dictionary <int, Node> active = new Dictionary <int, Node>();
StackAsList root = null;
stacks.Add(new StackAsList(new Node(states[0], null, null))); //add start state
int tokenIndex = 0;
Stack <int> stateStack = new Stack <int>();
Stack <TreeNode> nodeStack = new Stack <TreeNode>();
stateStack.Push(0);
bool notDone = true;
try
{
while (notDone)
{
string sym;
if (tokenIndex == tokens.Count)
{
sym = "$";
}
else
{
sym = tokens[tokenIndex].Symbol;
}
int stackIndex = 0;
Node refrence;
if (stacks.Count == 0)
{
throw new Exception("ERROR!! Stack is empty!!");
}
Console.WriteLine("Token{0} out of {1}: {2}", tokenIndex, tokens.Count, sym);
while (stackIndex < stacks.Count) //reduce
{
StackAsList stk = stacks[stackIndex];
refrence = stk.getTop();
int stateNumber = stk.getTopValue();
foreach (Tuple <string, int, string> action in parseTable[stateNumber][sym])
{
if (action.Item1 == "R")
{
Console.WriteLine("Action: {0}", action);
int numPop = action.Item2;
string tSym = action.Item3;
StackAsList stk2 = stk.clone();
stk2.pop(numPop); //reduce number of items
stk2.push(states[stk2.getTopValue()], new Tuple <string, Node, int, string>("R", refrence, numPop, sym));
if (!active.Contains(stk2.key()))
{
if (action.Item3 == "S'" || action.Item3 == "program")
{
if (tokenIndex == tokens.Count && sym == "$")
{
root = stk2;
notDone = false;
return;
}
}
else
{
active.Add(stk2.getTopValue(), stk2.getTop().nextNode);
nextStacks.Add(stk2);
stacks.Add(stk2);
}
}
}
else if (action.Item1 == "S")
{
if (!active.Contains(stk.key()))
{
nextStacks.Add(stk);
active.Add(stk.getTopValue(), stk.getTop().nextNode);
}
}
}
stackIndex++;
}
stackIndex = 0;
var newNextStack = new List <StackAsList>();
while (stackIndex < nextStacks.Count) //shift
{
StackAsList stk = nextStacks[stackIndex];
int stateNumber = stk.getTopValue();
foreach (Tuple <string, int, string> action in parseTable[stateNumber][sym])
{
if (action.Item1 == "S")//shift
{
refrence = stk.getTop();
Console.WriteLine("\tNextAction: {0}", action);
StackAsList stk2 = stk.clone();
stk2.push(states[action.Item2], new Tuple <string, Node, int, string>("S", refrence, tokenIndex, ""));
newNextStack.Add(stk2);
}
}
stackIndex++;
stacks = nextStacks;
}
stacks = newNextStack;
nextStacks = new List <StackAsList>();
tokenIndex++;
}
}
catch (Exception e)
{
Console.WriteLine("--------------------------\nStacks:");
printStackAsList(stacks);
Console.WriteLine("--------------------------\nNextStacks:");
printStackAsList(nextStacks);
throw new Exception(e.Message);
}
List <Tuple <Tuple <string, Node, int, string>, Node> > actions = new List <Tuple <Tuple <string, Node, int, string>, Node> >();
Node N = root.getTop();
while (N.how != null)
{
actions.Add(new Tuple <Tuple <string, Node, int, string>, Node>(N.how, N));
N = N.how.Item2;
}
Stack <TreeNode> treeNodeStack = new Stack <TreeNode>();
for (int i = actions.Count - 1; i >= 0; i--)
{
Tuple <string, Node, int, string> how = actions[i].Item1;
if (how.Item1 == "S")//shift
{
Token token = tokens[how.Item3];
TreeNode newNode = new TreeNode(token.Symbol, token);
treeNodeStack.Push(newNode);
}
else if (how.Item1 == "R")
{
int numPop = how.Item3;
string tSym = how.Item4;
TreeNode node = new TreeNode(tSym);
while (numPop-- > 0)
{
node.Children.Insert(0, treeNodeStack.Pop());
}
treeNodeStack.Push(node);
}
}
productionTreeRoot = treeNodeStack.Peek();
}
public void CreateStackCountIs0()
{
var stack = new StackAsList <string>();
Assert.AreEqual(0, stack.Count);
}
public void CreateCannotPeek()
{
var stack = new StackAsList <string>();
stack.Peek();
}
