Example #1
0
        internal void PopSequenceFrameTo(ref EvalStack dest)
        {
            StackFrame topFrame = this.TopArg;

            dest.PushFrame();
            int argCount = topFrame.Count;

            switch (argCount)
            {
            default:
                dest.Push(this.buffer.buffer, topFrame.basePtr, argCount);
                break;

            case 0:
                break;

            case 1:
                dest.Push(this.buffer.buffer[topFrame.basePtr].Sequence);
                break;
            }

            // Pop original fame
            this.stack.stackPtr = topFrame.basePtr - 1;
            this.frames.stackPtr--;
        }
Example #2
0
        internal void TransferSequenceSizeTo(ref EvalStack stack)
        {
            StackFrame topArg = this.TopArg;

            stack.PushFrame();
            for (int i = topArg.basePtr; i <= topArg.endPtr; i++)
            {
                NodeSequence sequence = this.buffer.buffer[i].Sequence;
                int          count    = sequence.Count;
                if ((this.stack.stackPtr + count) > this.stack.bounds.end)
                {
                    this.GrowStack(count);
                }
                for (int j = 0; j < count; j++)
                {
                    stack.Push((double)NodeSequence.GetContextSize(sequence, j));
                }
            }
        }
Example #3
0
        internal void TransferPositionsTo(ref EvalStack stack)
        {
            StackFrame topArg = this.TopArg;

            stack.PushFrame();
            for (int i = topArg.basePtr; i <= topArg.endPtr; i++)
            {
                NodeSequence sequence = this.buffer.buffer[i].Sequence;
                int          count    = sequence.Count;
                if ((this.stack.stackPtr + count) > this.stack.bounds.end)
                {
                    this.GrowStack(count);
                }
                for (int j = 0; j < count; j++)
                {
                    stack.Push((double)sequence.Items[j].Position);
                }
            }
        }
Example #4
0
        internal void TransferSequenceSizeTo(ref EvalStack stack)
        {
            StackFrame arg = this.TopArg;

            stack.PushFrame();
            for (int i = arg.basePtr; i <= arg.endPtr; ++i)
            {
                NodeSequence seq       = this.buffer.buffer[i].Sequence;
                int          nodeCount = seq.Count;

                if ((this.stack.stackPtr + nodeCount) > this.stack.bounds.end)
                {
                    this.GrowStack(nodeCount);
                }

                for (int n = 0; n < nodeCount; ++n)
                {
                    stack.Push((double)NodeSequence.GetContextSize(seq, n));
                }
            }
        }
Example #5
0
        internal void TransferPositionsTo(ref EvalStack stack)
        {
            StackFrame arg = this.TopArg;

            stack.PushFrame();
            for (int i = arg.basePtr; i <= arg.endPtr; ++i)
            {
                NodeSequence seq       = this.buffer.buffer[i].Sequence;
                int          nodeCount = seq.Count;

                if ((this.stack.stackPtr + nodeCount) > this.stack.bounds.end)
                {
                    this.GrowStack(nodeCount);
                }

                for (int n = 0; n < nodeCount; ++n)
                {
                    stack.Push((double)seq.Items[n].Position);
                }
            }
        }
Example #6
0
        internal void PopSequenceFrameTo(ref EvalStack dest)
        {
            StackFrame topArg = this.TopArg;

            dest.PushFrame();
            int count = topArg.Count;

            switch (count)
            {
            case 0:
                break;

            case 1:
                dest.Push(this.buffer.buffer[topArg.basePtr].Sequence);
                break;

            default:
                dest.Push(this.buffer.buffer, topArg.basePtr, count);
                break;
            }
            this.stack.stackPtr = topArg.basePtr - 1;
            this.frames.stackPtr--;
        }
 internal void TransferSequenceSizeTo(ref EvalStack stack)
 {
     StackFrame topArg = this.TopArg;
     stack.PushFrame();
     for (int i = topArg.basePtr; i <= topArg.endPtr; i++)
     {
         NodeSequence sequence = this.buffer.buffer[i].Sequence;
         int count = sequence.Count;
         if ((this.stack.stackPtr + count) > this.stack.bounds.end)
         {
             this.GrowStack(count);
         }
         for (int j = 0; j < count; j++)
         {
             stack.Push((double) NodeSequence.GetContextSize(sequence, j));
         }
     }
 }
 internal void TransferPositionsTo(ref EvalStack stack)
 {
     StackFrame topArg = this.TopArg;
     stack.PushFrame();
     for (int i = topArg.basePtr; i <= topArg.endPtr; i++)
     {
         NodeSequence sequence = this.buffer.buffer[i].Sequence;
         int count = sequence.Count;
         if ((this.stack.stackPtr + count) > this.stack.bounds.end)
         {
             this.GrowStack(count);
         }
         for (int j = 0; j < count; j++)
         {
             stack.Push((double) sequence.Items[j].Position);
         }
     }
 }
        internal void PopSequenceFrameTo(ref EvalStack dest)
        {
            StackFrame topArg = this.TopArg;
            dest.PushFrame();
            int count = topArg.Count;
            switch (count)
            {
                case 0:
                    break;

                case 1:
                    dest.Push(this.buffer.buffer[topArg.basePtr].Sequence);
                    break;

                default:
                    dest.Push(this.buffer.buffer, topArg.basePtr, count);
                    break;
            }
            this.stack.stackPtr = topArg.basePtr - 1;
            this.frames.stackPtr--;
        }