public void EmptyStackExceptionTest()
{
var stack = new ListStack<int>();
stack.Push(1010101);
stack.Pop();
stack.Pop();
}
public static TreeNode <char> MakeExpressionTree(string expression)
{
ListStack <TreeNode <char> > stack = new ListStack <TreeNode <char> >();
foreach (char character in expression)
{
TreeNode <char> currentNode = new TreeNode <char>();
if (char.IsDigit(character))
{
currentNode.Data = character;
}
else
{
currentNode.RightNode = new TreeNode <char> {
Data = stack.Pop().Data
};
currentNode.LeftNode = new TreeNode <char> {
Data = stack.Pop().Data
};
currentNode.Data = character;
}
stack.Push(currentNode);
}
return(stack.Pop());
}
public void EmptyStackExceptionTest()
{
var stack = new ListStack <int>();
stack.Push(1010101);
stack.Pop();
stack.Pop();
}
public void PopTest()
{
list.Push(1);
list.Push(2);
list.Push(3);
Assert.AreEqual(list.Pop(), 3);
Assert.IsFalse(list.IsContaining(3));
}
public void ObjectStackTest()
{
var stack = new ListStack<object>();
stack.Push(1010101);
stack.Push(-Math.PI);
stack.Push("ya");
Assert.AreEqual("ya", stack.Pop());
Assert.AreEqual(-Math.PI, stack.Pop());
Assert.AreEqual(1010101, stack.Pop());
}
public void ObjectStackTest()
{
var stack = new ListStack <object>();
stack.Push(1010101);
stack.Push(-Math.PI);
stack.Push("ya");
Assert.AreEqual("ya", stack.Pop());
Assert.AreEqual(-Math.PI, stack.Pop());
Assert.AreEqual(1010101, stack.Pop());
}
public void ListStackTest()
{
var stack = new ListStack<int>();
stack.Push(0);
stack.Push(10);
stack.Push(-10);
Assert.AreEqual(-10, stack.Pop());
Assert.IsFalse(stack.IsEmpty());
Assert.AreEqual(10, stack.Pop());
Assert.AreEqual(0, stack.Pop());
Assert.IsTrue(stack.IsEmpty());
}
public void ListStackTest()
{
var stack = new ListStack <int>();
stack.Push(0);
stack.Push(10);
stack.Push(-10);
Assert.AreEqual(-10, stack.Pop());
Assert.IsFalse(stack.IsEmpty());
Assert.AreEqual(10, stack.Pop());
Assert.AreEqual(0, stack.Pop());
Assert.IsTrue(stack.IsEmpty());
}
/// <summary>
/// 分析当前的符号。
/// </summary>
/// <param name="token">要分析的符号。</param>
public override void Parse(Token <T> token)
{
if (token.IsEndOfFile)
{
if (stateStack.Count == 1)
{
return;
}
}
while (true)
{
int state = stateStack.Peek();
ParseAction action = GetAction(state, token.Id);
switch (action.ActionType)
{
case ParseActionType.Shift:
Shift(token, action.Index);
goto ReduceByUnique;
case ParseActionType.Reduce:
Reduce(action.Index);
break;
case ParseActionType.Accept:
stateStack.Pop();
result = tokenStack.Pop();
return;
case ParseActionType.Error:
ReportError(state, token);
// ErrorRecovery(state, token.Id);
return;
}
}
ReduceByUnique:
// 尝试根据唯一归约进行归约。
while (true)
{
int state = stateStack.Peek();
ParseAction action = rule.States[state].Actions[Constants.UniqueIdx];
switch (action.ActionType)
{
case ParseActionType.Reduce:
Reduce(action.Index);
break;
case ParseActionType.Error:
return;
}
}
}
public void TestPop()
{
IStack <int> sut = new ListStack <int>();
sut.Push(1);
sut.Push(2);
sut.Push(3);
sut.Push(4);
Assert.Equal(4, sut.Pop());
Assert.Equal(3, sut.Top());
sut.Pop();
sut.Pop();
Assert.Equal(1, sut.Pop());
Assert.True(sut.IsEmpty());
}
public void ShowVertexGraphWithDepth(GraphVertex vertexStart)
{
Console.Write(vertexStart + "부터 탐색 : ");
GraphVertex vertexVisit = vertexStart;
VisitVertex(vertexVisit);
ListStack <GraphVertex> stack = new ListStack <GraphVertex>();
stack.Push(vertexVisit);
while (_lists[(int)vertexVisit].ReadFirst())
{
bool visitFlag = false;
var vertexNext = _lists[(int)vertexVisit].CurrentNode.Data;
if (VisitVertex(vertexNext))
{
stack.Push(vertexVisit);
vertexVisit = vertexNext;
visitFlag = true;
}
else
{
while (_lists[(int)vertexVisit].ReadNext())
{
vertexNext = _lists[(int)vertexVisit].CurrentNode.Data;
if (!VisitVertex(vertexNext))
{
continue;
}
stack.Push(vertexVisit);
vertexVisit = vertexNext;
visitFlag = true;
break;
}
}
if (visitFlag)
{
continue;
}
if (stack.IsEmpty())
{
break;
}
vertexVisit = stack.Pop();
}
Console.WriteLine();
InitializeVisitInformation();
}
private static void SafePopFromStack(ListStack<string> stack, Activity activity)
{
if (stack.Count == 0)
throw new InvalidOperationException("Стек пуст");
var top = stack.Peek();
if (string.CompareOrdinal(top, activity.Name) != 0)
throw new InvalidOperationException("На вершине стека другое действие: " + top);
stack.Pop();
}
private void ExecutingActivitiesStackPop()
{
lock (s_activitiesStackSync)
{
var popName = _executingActivitiesStack.Pop();
if (_trackingActivitiesStack.Count > 0 &&
string.CompareOrdinal(_trackingActivitiesStack.Peek(), popName) == 0)
_trackingActivitiesStack.Pop();
}
}
private static List <Exprent> GetDimensions(int arrayDim, ListStack <Exprent> stack
)
{
List <Exprent> lstDims = new List <Exprent>();
for (int i = 0; i < arrayDim; i++)
{
lstDims.Add(0, stack.Pop());
}
return(lstDims);
}
/// <summary>
/// Removes the last spawned step block like an undo button
/// </summary>
public void RemoveLastBlock()
{
if (spawnedSteps.items.Count != 0)
{
// Remove from stack
var remove = spawnedSteps.Pop();
remove.GetComponent <StepBlock>().DestroyStep();
spawned--;
// Update UI
SelectDropdown.RemoveLastStep();
SelectSlider.RemoveLastStep();
}
}
public void CheckCountWhenPopElement_ShouldSameAsBeforePush()
{
// Arrange
ListStack<int> nums = new ListStack<int>();
nums.Push(4);
nums.Pop();
// Act
int count = nums.Count;
// Assert
Assert.AreEqual(0, count);
}
public static void Main(string[] args)
{
ListStack s = new ListStack();
for (int i = 1; i <= 100; i++)
{
s.Push(i);
}
for (int i = 1; i <= 50; i++)
{
s.Pop();
}
s.print();
}
public static void DisplayListStack()
{
ListStack <int> stack = new ListStack <int>();
for (int i = 1; i <= 5; i++)
{
stack.Push(i);
}
while (!stack.IsEmpty())
{
stack.Pop();
Console.Write(stack.CurrentData + " ");
}
}
public static void ListStackTest(int quantity)
{
var stack = new ListStack <int>();
var start = DateTime.Now;
for (var i = 0; i < quantity; i++)
{
stack.Push(i);
}
for (var i = 0; i < quantity; i++)
{
stack.Pop();
}
var duration = DateTime.Now.Ticks - start.Ticks;
Console.WriteLine($"\t ListStack \t {quantity} \t {duration / 10000}ms");
}
private void Visit(Statement stat)
{
lstack.Push(stat);
Sharpen.Collections.Put(dfsnummap, stat, ncounter);
Sharpen.Collections.Put(lowmap, stat, ncounter);
ncounter++;
List <Statement> lstSuccs = stat.GetNeighbours(StatEdge.Type_Regular, Statement.Direction_Forward
);
// TODO: set?
lstSuccs.RemoveAll(setProcessed);
foreach (Statement succ in lstSuccs)
{
int?secvalue;
if (tset.Contains(succ))
{
secvalue = dfsnummap.GetOrNullable(succ);
}
else
{
tset.Add(succ);
Visit(succ);
secvalue = lowmap.GetOrNullable(succ);
}
Sharpen.Collections.Put(lowmap, stat, System.Math.Min(lowmap.GetOrNullable(stat) ?? 0,
secvalue ?? 0));
}
if (lowmap.GetOrNullable(stat) == dfsnummap.GetOrNullable(stat))
{
List <Statement> lst = new List <Statement>();
Statement v;
do
{
v = lstack.Pop();
lst.Add(v);
}while (v != stat);
components.Add(lst);
}
}
public IfExprent(int ifType, ListStack <Exprent> stack, HashSet <int> bytecodeOffsets
)
: this(null, bytecodeOffsets)
{
//public static final int IF_CAND = 16;
//public static final int IF_COR = 17;
//public static final int IF_NOT = 18;
if (ifType <= If_Le)
{
stack.Push(new ConstExprent(0, true, null));
}
else if (ifType <= If_Nonnull)
{
stack.Push(new ConstExprent(VarType.Vartype_Null, null, null));
}
if (ifType == If_Value)
{
condition = stack.Pop();
}
else
{
condition = new FunctionExprent(Func_Types[ifType], stack, bytecodeOffsets);
}
}
public void PopElement_FromEmptyStack_ShouldThrowException()
{
// Arrange
ListStack<int> nums = new ListStack<int>();
// Act
nums.Pop();
// Assert: expected exception
}
public void TestAutoGrowFunctionality_With1000Elemenets()
{
// Arrange
ListStack<string> words = new ListStack<string>();
var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
var random = new Random();
int boundary = 1000;
// Act and Assert
Assert.AreEqual(0, words.Count);
for (int i = 0; i < boundary; i++)
{
var result = new string(
Enumerable.Repeat(chars, 8)
.Select(s => s[random.Next(s.Length)])
.ToArray());
words.Push(result);
Assert.AreEqual(i + 1, words.Count);
}
while (words.Count > 0)
{
Assert.AreEqual(boundary, words.Count);
words.Pop();
boundary--;
}
}
public void PushPopElement_FromStackWithCapacityOne_CheckCount()
{
// Arrange
ListStack<int> nums = new ListStack<int>();
// Act and Assert
Assert.AreEqual(0, nums.Count);
int expectedElementSecond = 1;
nums.Push(expectedElementSecond);
Assert.AreEqual(1, nums.Count);
int expectedElementFirst = 3;
nums.Push(expectedElementFirst);
Assert.AreEqual(2, nums.Count);
Assert.AreEqual(expectedElementFirst, nums.Pop());
Assert.AreEqual(1, nums.Count);
Assert.AreEqual(expectedElementSecond, nums.Pop());
Assert.AreEqual(0, nums.Count);
}
public virtual string PopIndentation()
{
return(_indents.Pop());
}
public InvocationExprent(int opcode, LinkConstant cn, List <PooledConstant> bootstrapArguments
, ListStack <Exprent> stack, HashSet <int> bytecodeOffsets)
: this()
{
name = cn.elementname;
classname = cn.classname;
this.bootstrapArguments = bootstrapArguments;
switch (opcode)
{
case ICodeConstants.opc_invokestatic:
{
invocationTyp = Invoke_Static;
break;
}
case ICodeConstants.opc_invokespecial:
{
invocationTyp = Invoke_Special;
break;
}
case ICodeConstants.opc_invokevirtual:
{
invocationTyp = Invoke_Virtual;
break;
}
case ICodeConstants.opc_invokeinterface:
{
invocationTyp = Invoke_Interface;
break;
}
case ICodeConstants.opc_invokedynamic:
{
invocationTyp = Invoke_Dynamic;
classname = "java/lang/Class";
// dummy class name
invokeDynamicClassSuffix = "##Lambda_" + cn.index1 + "_" + cn.index2;
break;
}
}
if (ICodeConstants.Init_Name.Equals(name))
{
functype = Typ_Init;
}
else if (ICodeConstants.Clinit_Name.Equals(name))
{
functype = Typ_Clinit;
}
stringDescriptor = cn.descriptor;
descriptor = MethodDescriptor.ParseDescriptor(cn.descriptor);
foreach (VarType ignored in descriptor.@params)
{
lstParameters.Add(0, stack.Pop());
}
if (opcode == ICodeConstants.opc_invokedynamic)
{
int dynamicInvocationType = -1;
if (bootstrapArguments != null)
{
if (bootstrapArguments.Count > 1)
{
// INVOKEDYNAMIC is used not only for lambdas
PooledConstant link = bootstrapArguments[1];
if (link is LinkConstant)
{
dynamicInvocationType = ((LinkConstant)link).index1;
}
}
}
if (dynamicInvocationType == ICodeConstants.CONSTANT_MethodHandle_REF_invokeStatic)
{
isStatic__ = true;
}
else if (!(lstParameters.Count == 0))
{
// FIXME: remove the first parameter completely from the list. It's the object type for a virtual lambda method.
instance = lstParameters[0];
}
}
else if (opcode == ICodeConstants.opc_invokestatic)
{
isStatic__ = true;
}
else
{
instance = stack.Pop();
}
AddBytecodeOffsets(bytecodeOffsets);
}
private bool CheckVertexConnection(GraphVertex vertex1, GraphVertex vertex2)
{
GraphVertex visit = vertex1;
ListStack <GraphVertex> stack = new ListStack <GraphVertex>();
VisitVertex(visit);
stack.Push(visit);
while (_lists[(int)visit].ReadFirst())
{
GraphVertex next = _lists[(int)visit].CurrentNode.Data;
bool visited = false;
if (next == vertex2)
{
InitializeVisitInformation();
return(true);
}
if (VisitVertex(next))
{
stack.Push(visit);
visit = next;
visited = true;
}
else
{
while (_lists[(int)visit].ReadNext())
{
next = _lists[(int)visit].CurrentNode.Data;
if (next == vertex2)
{
InitializeVisitInformation();
return(true);
}
if (!VisitVertex(next))
{
continue;
}
stack.Push(visit);
visit = next;
visited = true;
break;
}
}
if (visited)
{
continue;
}
if (stack.IsEmpty())
{
break;
}
visit = stack.Pop();
}
InitializeVisitInformation();
return(false);
}
public override void Release(int marker)
{
base.Release(marker);
_realTokens.Pop();
}
/// <summary>
/// 读取输入流中的下一个词法单元并提升输入流的字符位置。
/// </summary>
/// <param name="state">DFA 的起始状态。</param>
/// <returns>词法单元读入是否成功。</returns>
protected override bool InternalReadToken(int state)
{
stateStack.Clear();
int startIndex = Source.Index;
while (true)
{
state = TransitionState(state, base.Source.Read());
if (state == -1)
{
// 没有合适的转移，退出。
break;
}
IList <int> symbolIndex = base.LexerRule.States[state].SymbolIndex;
if (symbolIndex.Count > 0)
{
// 将接受状态记录在堆栈中。
stateStack.Push(new AcceptState(symbolIndex, Source.Index));
}
}
// 遍历终结状态，执行相应动作。
while (stateStack.Count > 0)
{
AcceptState astate = stateStack.Pop();
for (int i = 0; i < astate.SymbolIndex.Count; i++)
{
int acceptState = astate.SymbolIndex[i];
if (acceptState >= base.LexerRule.SymbolCount)
{
// 跳过向前看的头状态。
break;
}
int lastIndex = astate.Index;
int?trailing = base.LexerRule.Symbols[acceptState].Trailing;
if (trailing.HasValue)
{
// 是向前看状态。
int index = trailing.Value;
if (index > 0)
{
// 前面长度固定。
lastIndex = startIndex + index;
}
else if (index < 0)
{
// 后面长度固定，注意此时 index 是负数。
lastIndex += index;
}
else
{
// 前后长度都不固定，需要沿着堆栈向前找。
int target = int.MaxValue - acceptState;
for (int j = stateStack.Count - 1; j >= 0; j--)
{
if (ContainsTrailingHead(stateStack[j].SymbolIndex, target))
{
lastIndex = stateStack[j].Index;
break;
}
}
}
}
// 将文本和流调整到与接受状态匹配的状态。
Source.Index = lastIndex;
DoAction(base.LexerRule.Symbols[acceptState].Action, acceptState);
if (!base.IsReject)
{
return(true);
}
}
}
return(false);
}
public FunctionExprent(int funcType, ListStack <Exprent> stack, HashSet <int> bytecodeOffsets
)
: this(funcType, new List <Exprent>(), bytecodeOffsets)
{
// FUNCTION_ADD
// FUNCTION_SUB
// FUNCTION_MUL
// FUNCTION_DIV
// FUNCTION_AND
// FUNCTION_OR
// FUNCTION_XOR
// FUNCTION_REM
// FUNCTION_SHL
// FUNCTION_SHR
// FUNCTION_USHR
// FUNCTION_BIT_NOT
// FUNCTION_BOOL_NOT
// FUNCTION_NEG
// FUNCTION_I2L
// FUNCTION_I2F
// FUNCTION_I2D
// FUNCTION_L2I
// FUNCTION_L2F
// FUNCTION_L2D
// FUNCTION_F2I
// FUNCTION_F2L
// FUNCTION_F2D
// FUNCTION_D2I
// FUNCTION_D2L
// FUNCTION_D2F
// FUNCTION_I2B
// FUNCTION_I2C
// FUNCTION_I2S
// FUNCTION_CAST
// FUNCTION_INSTANCEOF
// FUNCTION_ARRAY_LENGTH
// FUNCTION_IMM
// FUNCTION_MMI
// FUNCTION_IPP
// FUNCTION_PPI
// FUNCTION_IFF
// FUNCTION_LCMP
// FUNCTION_FCMPL
// FUNCTION_FCMPG
// FUNCTION_DCMPL
// FUNCTION_DCMPG
// FUNCTION_EQ = 41;
// FUNCTION_NE = 42;
// FUNCTION_LT = 43;
// FUNCTION_GE = 44;
// FUNCTION_GT = 45;
// FUNCTION_LE = 46;
// FUNCTION_CADD = 47;
// FUNCTION_COR = 48;
// FUNCTION_STR_CONCAT = 49;
if (funcType >= Function_Bit_Not && funcType <= Function_Ppi && funcType != Function_Cast &&
funcType != Function_Instanceof)
{
lstOperands.Add(stack.Pop());
}
else if (funcType == Function_Iif)
{
throw new Exception("no direct instantiation possible");
}
else
{
Exprent expr = stack.Pop();
lstOperands.Add(stack.Pop());
lstOperands.Add(expr);
}
}
