示例#1
0
            static InstructionStream()
            {
                var instructions = new TInstruction[PageSize];
                var operands     = new int[PageSize];

                for (var i = 0; i < PageSize; i++)
                {
                    operands[i] = int.MinValue;
                }

                NullPage = new InstructionPage(instructions, operands, 0, PageSize)
                {
                    ReferenceCount = int.MaxValue
                };
            }
示例#2
0
            private InstructionPage LoadPage(int pageIndex)
            {
                EnsurePagesCapacity(pageIndex + 1);
                CleanHeadPage();

                InstructionPage page = null;

                if (pageIndex < PageCount)
                {
                    page = Pages[pageIndex];

                    if (page.PageLength < PageSize)
                    {
                        LoadPosition();

                        page.PageLength += InstructionReader.ReadPage(page.PageLength, PageSize, page.InstructionsBuffer, page.OperandsBuffer);

                        SavePosition();
                    }

                    return(page);
                }

                if (Finished)
                {
                    return(NullPage);
                }

                for (var iPage = PageCount - 1; iPage < pageIndex; iPage++)
                {
                    page = ReadNextPage(PageCount);

                    Pages[page.PageIndex] = page;
                    PageCount++;

                    if (Finished)
                    {
                        break;
                    }
                }

                return(page);
            }
示例#3
0
            private void AdvanceInstructionPosition(LexemeStream lexemeStream, int instructionPointer)
            {
                StartPosition           = SeekableInstructionReader.Position;
                StartInstructionPointer = instructionPointer;

                var lexemeIndex     = instructionPointer & LocalIndexMask;
                var lexemePageIndex = instructionPointer >> PageIndexShift;

                EnsurePagesCapacity(lexemePageIndex + 1);

                for (var iPage = lexemeStream.HeadPage; iPage <= lexemePageIndex; iPage++)
                {
                    InstructionReader.RentBuffers(PageSize, out var instructionsBuffer, out var operandsBuffer);

                    var pageSource = lexemeStream.Pages[iPage];
                    var pageCopy   = new InstructionPage(instructionsBuffer, operandsBuffer, pageSource.PageIndex, pageSource.PageLength);

                    Array.Copy(pageSource.InstructionsBuffer, 0, pageCopy.InstructionsBuffer, 0, pageCopy.PageLength);
                    Array.Copy(pageSource.OperandsBuffer, 0, pageCopy.OperandsBuffer, 0, pageCopy.PageLength);

                    pageCopy.ReferenceCount = pageSource.ReferenceCount;

                    Pages[pageCopy.PageIndex] = pageCopy;
                }

                var lexemePage = Pages[lexemePageIndex];

                lexemePage.PageLength = lexemeIndex;

                for (var i = lexemeIndex; i < PageSize; i++)
                {
                    lexemePage.OperandsBuffer[i]     = int.MinValue;
                    lexemePage.InstructionsBuffer[i] = default;
                }

                HeadPage  = lexemeStream.HeadPage;
                PageCount = lexemePageIndex + 1;

                ReadOperand(ref instructionPointer);
            }