Beispiel #1
0
		StackEntry NewEntry ()
		{
			stack = stack ?? new Stack<StackEntry> ();
			var entry = new StackEntry ();
			stack.Push (entry);
			return entry;
		}
Beispiel #2
0
 private void Start(StackEntry data, int index)
 {
     if (!Begin(data.Instructions[index]))
     {
         MarkCompleted(data, index);
     }
 }
Beispiel #3
0
        private void UpdateDisplay(ulong address, byte[] memory)
        {
            for (var i = memory.Length - NativeIntegerSize; i >= 0; i -= (int)NativeIntegerSize)
            {
                ulong value = MainForm.ToLong(memory, (uint)i, NativeIntegerSize);

                var at     = address + (ulong)i;
                var offset = StackFrame - at;

                var entry = new StackEntry()
                {
                    Address  = BasePlatform.ToHex(at, NativeIntegerSize),
                    HexValue = BasePlatform.ToHex(value, NativeIntegerSize),
                    Value    = value,
                    Offset   = Platform.StackFrame.Name.ToUpperInvariant() +
                               (offset >= 0
                                                ? "-" + BasePlatform.ToHex(offset, 1)
                                                : "+" + BasePlatform.ToHex(-(long)offset, 1)),
                    Index = stackentries.Count,
                    Info  = MainForm.GetAddressInfo(value)
                };

                stackentries.Add(entry);
            }
        }
        public void WriteObjectEnd()
        {
            if (m_state == State.PropertyName)
            {
                var obj = new JSValue(new ReadOnlyDictionary <string, JSValue>((Dictionary <string, JSValue>)m_dynamic));
                if (m_stack.Count == 0)
                {
                    m_result = obj;
                    m_state  = State.Finish;
                    return;
                }
                else
                {
                    StackEntry entry = m_stack.Pop();
                    if (entry.State == State.PropertyValue)
                    {
                        ((Dictionary <string, JSValue>)entry.Dynamic)[entry.PropertyName] = obj;
                        m_dynamic = entry.Dynamic;
                        m_state   = State.PropertyName;
                        return;
                    }
                    else if (entry.State == State.Array)
                    {
                        ((List <JSValue>)entry.Dynamic).Add(obj);
                        m_dynamic = entry.Dynamic;
                        m_state   = State.Array;
                        return;
                    }
                }
            }

            throw new InvalidOperationException();
        }
Beispiel #5
0
        private void UpdateDisplay(ulong address, byte[] memory)
        {
            uint size = NativeIntegerSize;

            for (int i = memory.Length - NativeIntegerSize; i >= 0; i -= (int)size)
            {
                // FIXME: for 64 bit
                ulong value = (ulong)(memory[i] | (memory[i + 1] << 8) | (memory[i + 2] << 16) | (memory[i + 3] << 24));

                var at = address + (ulong)i;

                var offset = (long)(Platform.StackFrame.Value - at);

                var entry = new StackEntry()
                {
                    Address  = BasePlatform.ToHex(at, size),
                    HexValue = BasePlatform.ToHex(value, size),
                    Value    = value,
                    Offset   = Platform.StackFrame.Name.ToUpper() +
                               (offset >= 0
                                                ? "-" + BasePlatform.ToHex((ulong)offset, 1)
                                                : "+" + BasePlatform.ToHex((ulong)-offset, 1)),
                    Index = stackentries.Count,
                };

                stackentries.Add(entry);
            }
        }
Beispiel #6
0
        // <summary>
        // Perform a shift action.
        // </summary>
        public virtual void Shift(ushort newState, byte major, object minor)
        {
            this._idx = (this._idx + 1);
            if ((this._idx >= 100))
            {
                this.StackOverflow(minor);
                return;
            }
            StackEntry tos = this._stack[this._idx];

            tos.stateno = newState;
            tos.major   = major;
            tos.minor   = minor;
            if (((this._tracePrompt != null) &&
                 (this._idx > 0)))
            {
                Trace.WriteLine(String.Format("{0}Shift {1}", this._tracePrompt, newState));
                b = new StringBuilder(String.Format("{0}Stack:", this._tracePrompt));
                for (i = 1; (i <= this._idx); i = (i + 1))
                {
                    b.AppendFormat(this._tokenNames[this._stack[i].major]);
                }
                b.ToString();
                Trace.WriteLine(b.ToString());
            }
        }
Beispiel #7
0
        public void WriteObjectEnd()
        {
            if (m_state == State.PropertyName)
            {
                if (m_stack.Count == 0)
                {
                    m_result = m_dynamic;
                    m_state  = State.Finish;
                    return;
                }
                else
                {
                    StackEntry entry = m_stack.Last();
                    if (entry.State == State.PropertyValue)
                    {
                        ((JObject)entry.Dynamic)[entry.PropertyName] = m_dynamic;
                        m_dynamic = entry.Dynamic;
                        m_state   = State.PropertyName;
                        m_stack.RemoveAt(m_stack.Count - 1);
                        return;
                    }
                    else if (entry.State == State.Array)
                    {
                        entry.Dynamic.Add(m_dynamic);
                        m_dynamic = entry.Dynamic;
                        m_state   = State.Array;
                        m_stack.RemoveAt(m_stack.Count - 1);
                        return;
                    }
                }
            }

            throw new InvalidOperationException();
        }
Beispiel #8
0
        private StackEntry popEntry()
        {
            StackEntry e = stack_[stack_.Count - 1];

            stack_.RemoveRange(stack_.Count - 1, 1);
            return(e);
        }
Beispiel #9
0
 protected void DoStackSelected(StackEntry stackEntry)
 {
     if (this.StackSelected != null)
     {
         this.StackSelected(this, new StackEventArgs(stackEntry));
     }
 }
Beispiel #10
0
 public AbstractStack(int nargs)
 {
     stack_ = new List<StackEntry>();
     args_ = new StackEntry[nargs];
     for (int i = 0; i < args_.Length; i++)
         args_[i] = new StackEntry(null, null);
 }
Beispiel #11
0
        StackEntry NewEntry()
        {
            stack = stack ?? new Stack <StackEntry> ();
            var entry = new StackEntry();

            stack.Push(entry);
            return(entry);
        }
Beispiel #12
0
 public Task(IEnumerator <object> e, object tag = null)
 {
     Tag       = tag;
     callStack = new StackEntry {
         Enumerator = e
     };
     InitialEnumeratorType = e.GetType();
 }
Beispiel #13
0
 public void Push(StackEntry entry)
 {
     if (entries.Count == maxSize)
     {
         throw Error("Exceeded the maximum stack size of {0}.", maxSize);
     }
     entries.Add(entry);
 }
Beispiel #14
0
 /// <nodoc />
 public DisplayStackTraceEntry(string file, int line, int position, string functionName, StackEntry entry)
 {
     File         = file;
     Line         = line;
     Position     = position;
     FunctionName = functionName;
     Entry        = entry;
 }
Beispiel #15
0
        private void HandleYieldedResult(object result)
        {
            switch (result)
            {
            case null:
                waitTime = 0;
                break;

            case int i:
                waitTime = i;
                break;

            case float f:
                waitTime = f;
                break;

            case double d:
                waitTime = (float)d;
                break;

            case IEnumerator <object> enumerator:
                callStack = new StackEntry {
                    Enumerator = enumerator, Caller = callStack
                };
                Advance(0);
                break;

            case WaitPredicate predicate:
                waitPredicate = predicate;
                break;

            case Node3D node3D: {
                var ac             = node3D.Components.Get <AnimationComponent>();
                var firstAnimation = ac != null && ac.Animations.Count > 0 ? ac.Animations[0] : null;
                waitPredicate = firstAnimation != null?WaitForAnimation(firstAnimation) : null;

                break;
            }

            case Animation animation:
                waitPredicate = WaitForAnimation(animation);
                break;

            case Node node: {
                var defaultAnimation = node.Components.Get <AnimationComponent>()?.DefaultAnimation;
                waitPredicate = defaultAnimation != null?WaitForAnimation(defaultAnimation) : null;

                break;
            }

            case IEnumerable <object> _:
                throw new InvalidOperationException("Use IEnumerator<object> instead of IEnumerable<object> for " + result);

            default:
                throw new InvalidOperationException("Invalid object yielded " + result);
            }
        }
Beispiel #16
0
 /// <summary>
 /// Calls MarkUseDef for any local variables encountered
 /// </summary>
 /// <param name="node"></param>
 private void PerNodeLocalVarLiveness(StackEntry node, IList <LocalVariableDescriptor> localVariableTable)
 {
     // For LocalVariableEntry, LocalVariableAddressEntry, StoreLocalVariableEntry, StoreIndEntry??, FieldAddressEntry?
     if (node is ILocalVariable)
     {
         var localVarNode = (ILocalVariable)node;
         MarkUseDef(localVarNode, localVariableTable);
     }
 }
Beispiel #17
0
 public AbstractStack(int nargs)
 {
     stack_ = new List <StackEntry>();
     args_  = new StackEntry[nargs];
     for (int i = 0; i < args_.Length; i++)
     {
         args_[i] = new StackEntry(null, null);
     }
 }
Beispiel #18
0
        private void MarkCompleted(StackEntry data, int index)
        {
            data.Index++;

            if (data.Type == StackEntryType.Parallel)
            {
                data.Completed.Set(index, true);
            }
        }
Beispiel #19
0
 /// <summary>
 /// Exits from all IEnumerators, sets Updating to null.
 /// </summary>
 public void Dispose()
 {
     while (callStack != null)
     {
         callStack.Enumerator.Dispose();
         callStack = callStack.Caller;
     }
     waitPredicate = null;
 }
Beispiel #20
0
        /// <summary>
        /// Executes the ON command.
        /// </summary>
        public void Execute()
        {
            var counter = _expressionEvaluator.GetExpression().ValueAsShort();

            if ((counter < 0) || (counter > 255))
            {
                throw new Exceptions.IllegalQuantityException();
            }

            var type = _runEnvironment.CurrentLine.NextToken();

            if ((type.Statement != TokenType.Goto) && (type.Statement != TokenType.Gosub))
            {
                throw new Exceptions.SyntaxErrorException();
            }

            int?   foundLine = null;
            IToken token;

            do
            {
                var lineNumber = _runEnvironment.CurrentLine.GetLineNumber();
                if (!lineNumber.HasValue)
                {
                    throw new Exceptions.SyntaxErrorException();
                }

                counter--;
                if (counter == 0)
                {
                    foundLine = lineNumber;
                }

                token = _runEnvironment.CurrentLine.NextToken();
            }while (token.Seperator == TokenType.Comma);

            // Put back next token.
            _runEnvironment.CurrentLine.PushToken(token);

            if (foundLine.HasValue)
            {
                if (type.Statement == TokenType.Gosub)
                {
                    var returnAddress = new StackEntry
                    {
                        Line      = _runEnvironment.CurrentLine,
                        LineToken = _runEnvironment.CurrentLine.CurrentToken
                    };

                    _runEnvironment.ProgramStack.Push(returnAddress);
                    _runEnvironment.TestForStackOverflow();
                }

                _runEnvironment.CurrentLine = _programRepository.GetLine(foundLine.Value);
            }
        }
Beispiel #21
0
 private void ImportAppendTree(StackEntry entry, bool spill = false)
 {
     if (spill)
     {
         ImportSpillAppendTree(entry);
     }
     else
     {
         _currentBasicBlock?.Statements.Add(entry);
     }
 }
Beispiel #22
0
 private void treeView1_DoubleClick(object sender, EventArgs e)
 {
     if (treeView1.SelectedNode != null)
     {
         StackEntry se = (StackEntry)treeView1.SelectedNode.Tag;
         if (se.Location.line >= 0)
         {
             DoStackSelected(se);
         }
     }
 }
Beispiel #23
0
 public AbstractStack(AbstractStack other)
 {
     stack_ = new List<StackEntry>();
     for (int i = 0; i < other.stack_.Count; i++)
         stack_.Add(new StackEntry(other.stack_[i].declaration, other.stack_[i].assignment));
     args_ = new StackEntry[other.args_.Length];
     for (int i = 0; i < args_.Length; i++)
         args_[i] = new StackEntry(other.args_[i].declaration, other.args_[i].assignment);
     pri_ = other.pri_;
     alt_ = other.alt_;
 }
Beispiel #24
0
        public DNode popAsTemp()
        {
            StackEntry entry = popEntry();

            if (entry.declaration.uses.Count == 0)
            {
                return(entry.assignment);
            }
            //Debug.Assert(false, "not yet handled");
            return(null);
        }
Beispiel #25
0
		void Push (IMatrix matrix)
		{
			// If we're in a SaveTransform block,
			// increment the pop count.
			current = current ?? NewEntry ();
			current.Matrices.Add (matrix);

			current.PopCount++;
			
			// push the transform
			push (matrix);
		}
Beispiel #26
0
        private static void PrintStackForDiagnostics(Stack <StackEntry> stack)
        {
            StackEntry[] clone = new StackEntry[stack.Count];
            stack.CopyTo(clone, 0);

            Console.Write("Exploring path..");
            for (int i = stack.Count - 1; i >= 0; i--)
            {
                Console.Write(clone[i].Node + " (" + clone[i].GetCurrentColor() + ")" + " ");
            }
            Console.WriteLine();
        }
Beispiel #27
0
        private void lvStackEntries_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (lvStackEntries.SelectedItems.Count == 0)
            {
                tbStackDetails.Text = "";
                return;
            }

            StackEntry o = (StackEntry)lvStackEntries.SelectedItems[0].Tag;

            tbStackDetails.Text = o.Details;
        }
Beispiel #28
0
 private void SetNext(StackEntry entry)
 {
     if (Current != null)
     {
         Current.Next = entry;
     }
     Current = entry;
     if (First == null)
     {
         First = Current;
     }
 }
Beispiel #29
0
        void Push(IMatrix matrix)
        {
            // If we're in a SaveTransform block,
            // increment the pop count.
            current = current ?? NewEntry();
            current.Matrices.Add(matrix);

            current.popCount++;

            // push the transform
            push(matrix);
        }
Beispiel #30
0
        public static int Add(string Entry)
        {
            var SE = new StackEntry
            {
                Trace     = Entry,
                StartTime = DateTime.UtcNow,
                ExitTime  = DateTime.MaxValue,
                Duration  = TimeSpan.MinValue
            };

            _StackEntries.Add(SE);
            return(_StackEntries.Count - 1);
        }
Beispiel #31
0
        private StackEntry?LowerNode(StackEntry node)
        {
            var visitorAdapter = new GenericStackEntryAdapter(this);

            _nextNode = null;
            node.Accept(visitorAdapter);
            if (_nextNode != null)
            {
                return(_nextNode);
            }

            return(node.Next);
        }
Beispiel #32
0
        private void gridStack_MouseMove(
            object sender,
            System.Windows.Forms.MouseEventArgs e)
        {
            //                 Handles gridStack.MouseMove
            System.Windows.Forms.DataGrid.HitTestInfo hit;
            hit = gridStack.HitTest(e.X, e.Y);
            StackEntry stackentry = mStackArray[hit.Row];
            string     memberName;

            memberName = gridStack.TableStyles[0].GridColumnStyles[hit.Column].MappingName;
            this.ToolTip.SetToolTip(gridStack, stackentry.GetText(memberName));
        }
Beispiel #33
0
        private StackEntry ImportSpillStackEntry(StackEntry entry, int?tempNumber = null)
        {
            if (tempNumber == null)
            {
                tempNumber = GrabTemp(entry.Kind, entry.ExactSize);
                var temp = _localVariableTable[tempNumber.Value];
            }

            var node = new StoreLocalVariableEntry(tempNumber.Value, false, entry);

            ImportAppendTree(node);

            return(new LocalVariableEntry(tempNumber.Value, entry.Kind, entry.ExactSize));
        }
Beispiel #34
0
        private void ImportSpillAppendTree(StackEntry entry)
        {
            // If we have an assignment and the variable being assigned to
            // has prior loads on the evaluation stack then we need to ensure
            // these loads are completed before the variable is modified
            if (entry is StoreLocalVariableEntry)
            {
                // TODO: Do we need to check that variable being assigned to is a struct type?

                // Convert loads into assignmented to new temps
                ImportSpillLocalReferences(entry.As <StoreLocalVariableEntry>().LocalNumber);
            }
            ImportAppendTree(entry);
        }
Beispiel #35
0
		public void RestoreTransform ()
		{
			// If there is a current entry, use it.
			if (current == null)
				throw new EtoException ("RestoreTransform called without SaveTransform");

			// Pop the drawing context
			// popCount times
			while (current.PopCount-- > 0) {
				// return a cloned matrix
				// since the caller may dispose it.
				pop ();
			}
			stack.Pop ();
			current = (stack.Count == 0) ? NewEntry () : stack.Peek ();
		}
Beispiel #36
0
 /// <summary>
 /// Append string representation of <paramref name="value"/> to <see cref="_builder"/>.
 /// </summary>
 /// <param name="value">Value to print.</param>
 private void Append(StackEntry value)
 {
     value.Append(_builder);
 }
Beispiel #37
0
        private StackEntry NewSpillSlot(StackEntry entry)
        {
            if (_spillSlots == null)
                _spillSlots = new List<SpillSlot>();

            SpillSlot spillSlot = new SpillSlot();
            spillSlot.Kind = entry.Kind;
            spillSlot.Type = entry.Type;
            spillSlot.Name = "_s" + _spillSlots.Count.ToStringInvariant();

            _spillSlots.Add(spillSlot);

            return new ExpressionEntry(entry.Kind, spillSlot.Name, entry.Type);
        }
Beispiel #38
0
 /// <summary>
 /// Generate a cast in case the stack type of source is not identical or compatible with destination type.
 /// </summary>
 /// <param name="destType">Type of destination</param>
 /// <param name="srcEntry">Source entry from stack</param>
 private void AppendCastIfNecessary(TypeDesc destType, StackEntry srcEntry)
 {
     ConstantEntry constant = srcEntry as ConstantEntry;
     if ((constant != null) && (constant.IsCastNecessary(destType)) || !destType.IsValueType)
     {
         Append("(");
         Append(_writer.GetCppSignatureTypeName(destType));
         Append(")");
     }
 }
Beispiel #39
0
        /// <summary>
        /// Push a new entry onto evaluation stack and declare a temporary local to hold its representation.
        /// </summary>
        /// <param name="entry">Entry to push onto evaluation stack.</param>
        private void PushTemp(StackEntry entry)
        {
            _stack.Push(entry);

            // Start declaration on a new line
            AppendLine();
            Append(GetStackValueKindCPPTypeName(entry.Kind, entry.Type));
            Append(" ");
            Append(entry);
            Append(" = ");
        }
Beispiel #40
0
 private LocalEntry StackToLocalEntry(Instruction instruction, StackEntry stackEntry)
 {
     return new LocalEntry(instruction, stackEntry.IsValueKnown, stackEntry.Value);
 }
Beispiel #41
0
 public void Push(StackEntry value)
 {
     _stack.Push(value);
 }
Beispiel #42
0
		public void SaveTransform ()
		{
			// Create a stack the first time.
			current = NewEntry ();
		}