예제 #1
0
        protected internal void WriteTo(ref Fragment fragment, ITextSink sink)
        {
            int run = fragment.head;

            if (run != fragment.tail)
            {
                int runOffset = fragment.headOffset;

                do
                {
                    RunEntry runEntry = this.runList[run];

                    if (runEntry.Type == RunType.Normal)
                    {
                        sink.Write(this.buffer, runOffset, runEntry.Length);
                    }
                    else if (runEntry.Type == RunType.Literal)
                    {
                        sink.Write(runEntry.Value);
                    }

                    runOffset += runEntry.Length;
                }while (++run != fragment.tail && !sink.IsEnough);
            }
        }
예제 #2
0
        protected internal void WriteTo(LexicalUnit unit, ITextSink sink)
        {
            int run = unit.head;

            if (run != -1)
            {
                int runOffset = unit.headOffset;

                RunEntry runEntry = this.runList[run];
                uint     kind     = runEntry.MajorKind;

                do
                {
                    if (runEntry.Type == RunType.Normal)
                    {
                        sink.Write(this.buffer, runOffset, runEntry.Length);
                    }
                    else if (runEntry.Type == RunType.Literal)
                    {
                        sink.Write(runEntry.Value);
                    }

                    runOffset += runEntry.Length;

                    runEntry = this.runList[++run];
                }while (runEntry.MajorKindPlusStartFlag == kind && !sink.IsEnough);
            }
        }
예제 #3
0
        protected internal int CalculateHashLowerCase(Fragment fragment)
        {
            int num = fragment.head;

            if (num == fragment.tail)
            {
                return(HashCode.CalculateEmptyHash());
            }
            int num2 = fragment.headOffset;

            if (num + 1 == fragment.tail && runList[num].Type == (RunType)2147483648u)
            {
                return(HashCode.CalculateLowerCase(buffer, num2, runList[num].Length));
            }
            HashCode hashCode = new HashCode(true);

            do
            {
                RunEntry runEntry = runList[num];
                if (runEntry.Type == (RunType)2147483648u)
                {
                    hashCode.AdvanceLowerCase(buffer, num2, runEntry.Length);
                }
                else if (runEntry.Type == (RunType)3221225472u)
                {
                    hashCode.AdvanceLowerCase(runEntry.Value);
                }
                num2 += runEntry.Length;
            }while (++num != fragment.tail);
            return(hashCode.FinalizeHash());
        }
예제 #4
0
        protected internal int GetLength(LexicalUnit unit)
        {
            int run    = unit.head;
            int length = 0;

            if (run != -1)
            {
                RunEntry runEntry = this.runList[run];
                uint     kind     = runEntry.MajorKind;

                do
                {
                    if (runEntry.Type == RunType.Normal)
                    {
                        length += runEntry.Length;
                    }
                    else if (runEntry.Type == RunType.Literal)
                    {
                        length += Token.LiteralLength(runEntry.Value);
                    }

                    runEntry = this.runList[++run];
                }while (runEntry.MajorKindPlusStartFlag == kind);
            }

            return(length);
        }
예제 #5
0
        protected internal int CalculateHashLowerCase(LexicalUnit unit)
        {
            int num = unit.head;

            if (num == -1)
            {
                return(HashCode.CalculateEmptyHash());
            }
            int      num2      = unit.headOffset;
            RunEntry runEntry  = runList[num];
            uint     majorKind = runEntry.MajorKind;

            if (runEntry.Type == (RunType)2147483648u && majorKind != runList[num + 1].MajorKindPlusStartFlag)
            {
                return(HashCode.CalculateLowerCase(buffer, num2, runEntry.Length));
            }
            HashCode hashCode = new HashCode(true);

            do
            {
                if (runEntry.Type == (RunType)2147483648u)
                {
                    hashCode.AdvanceLowerCase(buffer, num2, runEntry.Length);
                }
                else if (runEntry.Type == (RunType)3221225472u)
                {
                    hashCode.AdvanceLowerCase(runEntry.Value);
                }
                num2    += runEntry.Length;
                runEntry = runList[++num];
            }while (runEntry.MajorKindPlusStartFlag == majorKind);
            return(hashCode.FinalizeHash());
        }
        public void AddRun(TestCase testCase, Benchmark benchmark, string text) {
            if (string.IsNullOrEmpty(text)) return;
            var runEntry = new RunEntry() { TestCase = testCase, Benchmark = benchmark, RawLog = text };
            RunEntries.Add(runEntry);

            ParseInfolog(text, runEntry);
            if (testCase.BenchmarkArg > 0) ParseBenchmarkData(runEntry);
        }
예제 #7
0
        protected internal bool SkipLeadingWhitespace(LexicalUnit unit, ref FragmentPosition position)
        {
            int num = unit.head;

            if (num != -1)
            {
                int      num2           = unit.headOffset;
                RunEntry runEntry       = runList[num];
                uint     majorKind      = runEntry.MajorKind;
                int      runDeltaOffset = 0;
                int      i;
                do
                {
                    if (runEntry.Type == (RunType)3221225472u)
                    {
                        if (runEntry.Value > 65535)
                        {
                            break;
                        }
                        CharClass charClass = ParseSupport.GetCharClass((char)runEntry.Value);
                        if (!ParseSupport.WhitespaceCharacter(charClass))
                        {
                            break;
                        }
                    }
                    else if (runEntry.Type == (RunType)2147483648u)
                    {
                        for (i = num2; i < num2 + runEntry.Length; i++)
                        {
                            CharClass charClass = ParseSupport.GetCharClass(buffer[i]);
                            if (!ParseSupport.WhitespaceCharacter(charClass))
                            {
                                break;
                            }
                        }
                        if (i < num2 + runEntry.Length)
                        {
                            goto Block_7;
                        }
                    }
                    num2    += runEntry.Length;
                    runEntry = runList[++num];
                }while (runEntry.MajorKindPlusStartFlag == majorKind);
                goto IL_EF;
Block_7:
                runDeltaOffset = i - num2;
IL_EF:
                position.run            = num;
                position.runOffset      = num2;
                position.runDeltaOffset = runDeltaOffset;
                if (num == unit.head || runEntry.MajorKindPlusStartFlag == majorKind)
                {
                    return(true);
                }
            }
            return(false);
        }
예제 #8
0
        static void ParseInfolog(string text, RunEntry runEntry)
        {
            string gameId = null;

            foreach (var cycleline in text.Split(new[] { '\n', '\r' }, StringSplitOptions.RemoveEmptyEntries))
            {
                var line      = cycleline;
                var gameframe = 0;

                if (line.StartsWith("[f="))
                {
                    var idx = line.IndexOf("] ");
                    if (idx > 0)
                    {
                        int.TryParse(line.Substring(3, idx - 3), out gameframe);
                        if (idx >= 0)
                        {
                            line = line.Substring(idx + 2);
                        }
                    }
                }

                if (gameId != null)
                {
                    var match = Regex.Match(line, "!transmitlobby (.+):[ ]*([0-9.]+)");
                    if (match.Success)
                    {
                        var key    = match.Groups[1].Value.Trim();
                        var value  = match.Groups[2].Value.Trim();
                        var valNum = 0.0;
                        if (!invalidKeys.Contains(key) && !key.Contains(":"))
                        {
                            if (double.TryParse(value, out valNum))
                            {
                                runEntry.RawValues.Add(new ValueEntry()
                                {
                                    GameFrame = gameframe, Key = key, Value = valNum
                                });
                            }
                        }
                    }
                }

                if (line.StartsWith("GameID: ") && gameId == null)
                {
                    gameId = line.Substring(8).Trim();
                }
            }
        }
예제 #9
0
        protected internal void WriteOriginalTo(ref Fragment fragment, ITextSink sink)
        {
            int num = fragment.head;

            if (num != fragment.tail)
            {
                int num2 = fragment.headOffset;
                do
                {
                    RunEntry runEntry = runList[num];
                    if (runEntry.Type == (RunType)2147483648u || runEntry.Type == (RunType)3221225472u)
                    {
                        sink.Write(buffer, num2, runEntry.Length);
                    }
                    num2 += runEntry.Length;
                }while (++num != fragment.tail && !sink.IsEnough);
            }
        }
예제 #10
0
        public void AddRun(TestCase testCase, Benchmark benchmark, string text)
        {
            if (string.IsNullOrEmpty(text))
            {
                return;
            }
            var runEntry = new RunEntry()
            {
                TestCase = testCase, Benchmark = benchmark, RawLog = text
            };

            RunEntries.Add(runEntry);

            ParseInfolog(text, runEntry);
            if (testCase.BenchmarkArg > 0)
            {
                ParseBenchmarkData(runEntry);
            }
        }
예제 #11
0
        protected internal bool IsFragmentEmpty(ref Fragment fragment)
        {
            int run = fragment.head;

            if (run != fragment.tail)
            {
                do
                {
                    RunEntry runEntry = this.runList[run];

                    if (runEntry.Type == RunType.Normal || runEntry.Type == RunType.Literal)
                    {
                        InternalDebug.Assert(0 != runEntry.Length);
                        return(false);
                    }
                }while (++run != fragment.tail);
            }

            return(true);
        }
예제 #12
0
        protected internal bool IsFragmentEmpty(LexicalUnit unit)
        {
            int num = unit.head;

            if (num != -1)
            {
                RunEntry runEntry  = runList[num];
                uint     majorKind = runEntry.MajorKind;
                while (runEntry.Type != (RunType)2147483648u && runEntry.Type != (RunType)3221225472u)
                {
                    runEntry = runList[++num];
                    if (runEntry.MajorKindPlusStartFlag != majorKind)
                    {
                        return(true);
                    }
                }
                return(false);
            }
            return(true);
        }
예제 #13
0
        protected internal bool IsFragmentEmpty(ref Fragment fragment)
        {
            int num = fragment.head;

            if (num != fragment.tail)
            {
                while (true)
                {
                    RunEntry runEntry = runList[num];
                    if (runEntry.Type == (RunType)2147483648u || runEntry.Type == (RunType)3221225472u)
                    {
                        break;
                    }
                    if (++num == fragment.tail)
                    {
                        return(true);
                    }
                }
                return(false);
            }
            return(true);
        }
예제 #14
0
        protected internal int GetLength(ref Fragment fragment)
        {
            int num  = fragment.head;
            int num2 = 0;

            if (num != fragment.tail)
            {
                do
                {
                    RunEntry runEntry = runList[num];
                    if (runEntry.Type == (RunType)2147483648u)
                    {
                        num2 += runEntry.Length;
                    }
                    else if (runEntry.Type == (RunType)3221225472u)
                    {
                        num2 += LiteralLength(runEntry.Value);
                    }
                }while (++num != fragment.tail);
            }
            return(num2);
        }
예제 #15
0
        protected internal int CalculateHashLowerCase(LexicalUnit unit)
        {
            int run = unit.head;

            if (run != -1)
            {
                int      runOffset = unit.headOffset;
                RunEntry runEntry  = this.runList[run];
                uint     kind      = runEntry.MajorKind;

                if (runEntry.Type == RunType.Normal &&
                    kind != this.runList[run + 1].MajorKindPlusStartFlag)
                {
                    return(HashCode.CalculateLowerCase(this.buffer, runOffset, runEntry.Length));
                }

                HashCode hashCode = new HashCode(true);

                do
                {
                    if (runEntry.Type == RunType.Normal)
                    {
                        hashCode.AdvanceLowerCase(this.buffer, runOffset, runEntry.Length);
                    }
                    else if (runEntry.Type == RunType.Literal)
                    {
                        hashCode.AdvanceLowerCase(runEntry.Value);
                    }

                    runOffset += runEntry.Length;

                    runEntry = this.runList[++run];
                }while (runEntry.MajorKindPlusStartFlag == kind);

                return(hashCode.FinalizeHash());
            }

            return(HashCode.CalculateEmptyHash());
        }
예제 #16
0
        protected internal bool IsFragmentEmpty(LexicalUnit unit)
        {
            int run = unit.head;

            if (run != -1)
            {
                RunEntry runEntry = this.runList[run];
                uint     kind     = runEntry.MajorKind;

                do
                {
                    if (runEntry.Type == RunType.Normal || runEntry.Type == RunType.Literal)
                    {
                        InternalDebug.Assert(0 != runEntry.Length);
                        return(false);
                    }

                    runEntry = this.runList[++run];
                }while (runEntry.MajorKindPlusStartFlag == kind);
            }

            return(true);
        }
예제 #17
0
        void ParseBenchmarkData(RunEntry runEntry)
        {
            var path = Path.Combine(runEntry.TestCase.Config.ConfigPath, "benchmark.data");

            if (File.Exists(path))
            {
                var data    = File.ReadAllLines(path);
                var headers = data.First().Split(' ').Skip(1).ToList();

                foreach (var line in data.Skip(1))
                {
                    var lineData  = line.Split(' ').ToList();
                    var gameFrame = double.Parse(lineData[0]);
                    for (var i = 1; i < lineData.Count; i++)
                    {
                        runEntry.RawValues.Add(new ValueEntry()
                        {
                            GameFrame = gameFrame, Key = headers[i], Value = double.Parse(lineData[i])
                        });
                    }
                }
            }
        }
예제 #18
0
        protected internal void WriteTo(LexicalUnit unit, ITextSink sink)
        {
            int num = unit.head;

            if (num != -1)
            {
                int      num2      = unit.headOffset;
                RunEntry runEntry  = runList[num];
                uint     majorKind = runEntry.MajorKind;
                do
                {
                    if (runEntry.Type == (RunType)2147483648u)
                    {
                        sink.Write(buffer, num2, runEntry.Length);
                    }
                    else if (runEntry.Type == (RunType)3221225472u)
                    {
                        sink.Write(runEntry.Value);
                    }
                    num2    += runEntry.Length;
                    runEntry = runList[++num];
                }while (runEntry.MajorKindPlusStartFlag == majorKind && !sink.IsEnough);
            }
        }
예제 #19
0
        protected internal int GetLength(LexicalUnit unit)
        {
            int num  = unit.head;
            int num2 = 0;

            if (num != -1)
            {
                RunEntry runEntry  = runList[num];
                uint     majorKind = runEntry.MajorKind;
                do
                {
                    if (runEntry.Type == (RunType)2147483648u)
                    {
                        num2 += runEntry.Length;
                    }
                    else if (runEntry.Type == (RunType)3221225472u)
                    {
                        num2 += LiteralLength(runEntry.Value);
                    }
                    runEntry = runList[++num];
                }while (runEntry.MajorKindPlusStartFlag == majorKind);
            }
            return(num2);
        }
예제 #20
0
        protected internal void WriteEscapedOriginalTo(ref Fragment fragment, ITextSink sink)
        {
            int run = fragment.head;

            if (run != fragment.tail)
            {
                int runOffset = fragment.headOffset;
                do
                {
                    RunEntry runEntry = this.runList[run];

                    if (runEntry.Type == RunType.Normal || runEntry.Type == RunType.Literal)
                    {
                        this.EscapeAndWriteBuffer(
                            this.buffer,
                            runOffset,
                            runEntry.Length,
                            sink);
                    }

                    runOffset += runEntry.Length;
                }while (++run != fragment.tail && !sink.IsEnough);
            }
        }
예제 #21
0
        protected internal int CalculateHashLowerCase(Fragment fragment)
        {
            int run = fragment.head;

            if (run != fragment.tail)
            {
                int runOffset = fragment.headOffset;

                if (run + 1 == fragment.tail && this.runList[run].Type == RunType.Normal)
                {
                    return(HashCode.CalculateLowerCase(this.buffer, runOffset, this.runList[run].Length));
                }

                HashCode hashCode = new HashCode(true);

                do
                {
                    RunEntry runEntry = this.runList[run];

                    if (runEntry.Type == RunType.Normal)
                    {
                        hashCode.AdvanceLowerCase(this.buffer, runOffset, runEntry.Length);
                    }
                    else if (runEntry.Type == RunType.Literal)
                    {
                        hashCode.AdvanceLowerCase(runEntry.Value);
                    }

                    runOffset += runEntry.Length;
                }while (++run != fragment.tail);

                return(hashCode.FinalizeHash());
            }

            return(HashCode.CalculateEmptyHash());
        }
예제 #22
0
        protected internal int GetLength(ref Fragment fragment)
        {
            int run    = fragment.head;
            int length = 0;

            if (run != fragment.tail)
            {
                do
                {
                    RunEntry runEntry = this.runList[run];

                    if (runEntry.Type == RunType.Normal)
                    {
                        length += runEntry.Length;
                    }
                    else if (runEntry.Type == RunType.Literal)
                    {
                        length += Token.LiteralLength(runEntry.Value);
                    }
                }while (++run != fragment.tail);
            }

            return(length);
        }
예제 #23
0
        protected internal int Read(LexicalUnit unit, ref FragmentPosition position, char[] buffer, int offset, int count)
        {
            int num = offset;

            if (unit.head != -1)
            {
                uint majorKind = runList[unit.head].MajorKind;
                int  num2      = position.run;
                if (num2 == unit.head - 1)
                {
                    num2 = (position.run = unit.head);
                }
                RunEntry runEntry = runList[num2];
                if (num2 == unit.head || runEntry.MajorKindPlusStartFlag == majorKind)
                {
                    int num3 = position.runOffset;
                    int num4 = position.runDeltaOffset;
                    int num6;
                    while (true)
                    {
                        if (runEntry.Type == (RunType)3221225472u)
                        {
                            int num5 = LiteralLength(runEntry.Value);
                            if (num4 != num5)
                            {
                                if (num5 == 1)
                                {
                                    buffer[offset++] = (char)runEntry.Value;
                                    count--;
                                }
                                else if (num4 != 0)
                                {
                                    buffer[offset++] = LiteralLastChar(runEntry.Value);
                                    count--;
                                }
                                else
                                {
                                    buffer[offset++] = LiteralFirstChar(runEntry.Value);
                                    count--;
                                    if (count == 0)
                                    {
                                        break;
                                    }
                                    buffer[offset++] = LiteralLastChar(runEntry.Value);
                                    count--;
                                }
                            }
                        }
                        else if (runEntry.Type == (RunType)2147483648u)
                        {
                            num6 = Math.Min(count, runEntry.Length - num4);
                            Buffer.BlockCopy(this.buffer, (num3 + num4) * 2, buffer, offset * 2, num6 * 2);
                            offset += num6;
                            count  -= num6;
                            if (num4 + num6 != runEntry.Length)
                            {
                                goto Block_10;
                            }
                        }
                        num3    += runEntry.Length;
                        num4     = 0;
                        runEntry = runList[++num2];
                        if (runEntry.MajorKindPlusStartFlag != majorKind || count == 0)
                        {
                            goto IL_1CF;
                        }
                    }
                    num4 = 1;
                    goto IL_1CF;
Block_10:
                    num4 += num6;
IL_1CF:
                    position.run            = num2;
                    position.runOffset      = num3;
                    position.runDeltaOffset = num4;
                }
            }
            return(offset - num);
        }
        static void ParseInfolog(string text, RunEntry runEntry) {
            string gameId = null;

            foreach (var cycleline in text.Split(new[] { '\n', '\r' }, StringSplitOptions.RemoveEmptyEntries)) {
                var line = cycleline;
                var gameframe = 0;

                if (line.StartsWith("[f=")) {
                    var idx = line.IndexOf("] ");
                    if (idx > 0) {
                        int.TryParse(line.Substring(3, idx - 3), out gameframe);
                        if (idx >= 0) line = line.Substring(idx + 2);
                    }
                }

                if (gameId != null) {
                    var match = Regex.Match(line, "!transmitlobby (.+):[ ]*([0-9.]+)");
                    if (match.Success) {
                        var key = match.Groups[1].Value.Trim();
                        var value = match.Groups[2].Value.Trim();
                        var valNum = 0.0;
                        if (!invalidKeys.Contains(key) && !key.Contains(":")) if (double.TryParse(value, out valNum)) runEntry.RawValues.Add(new ValueEntry() { GameFrame = gameframe, Key = key, Value = valNum });
                    }
                }

                if (line.StartsWith("GameID: ") && gameId == null) gameId = line.Substring(8).Trim();
            }
        }
예제 #25
0
        protected internal bool SkipLeadingWhitespace(LexicalUnit unit, ref FragmentPosition position)
        {
            int run = unit.head;

            if (run != -1)
            {
                int       runOffset = unit.headOffset;
                CharClass charClass;

                RunEntry runEntry    = this.runList[run];
                uint     kind        = runEntry.MajorKind;
                int      deltaOffset = 0;

                do
                {
                    if (runEntry.Type == RunType.Literal)
                    {
                        if (runEntry.Value > 0xFFFF)
                        {
                            break;
                        }

                        charClass = ParseSupport.GetCharClass((char)runEntry.Value);
                        if (!ParseSupport.WhitespaceCharacter(charClass))
                        {
                            break;
                        }
                    }
                    else if (runEntry.Type == RunType.Normal)
                    {
                        int offset = runOffset;
                        while (offset < runOffset + runEntry.Length)
                        {
                            charClass = ParseSupport.GetCharClass(this.buffer[offset]);
                            if (!ParseSupport.WhitespaceCharacter(charClass))
                            {
                                break;
                            }

                            offset++;
                        }

                        if (offset < runOffset + runEntry.Length)
                        {
                            deltaOffset = offset - runOffset;
                            break;
                        }
                    }

                    runOffset += runEntry.Length;

                    runEntry = this.runList[++run];
                }while (runEntry.MajorKindPlusStartFlag == kind);

                position.run            = run;
                position.runOffset      = runOffset;
                position.runDeltaOffset = deltaOffset;

                if (run == unit.head || runEntry.MajorKindPlusStartFlag == kind)
                {
                    return(true);
                }
            }

            return(false);
        }
        void ParseBenchmarkData(RunEntry runEntry) {
            var path = Path.Combine(runEntry.TestCase.Config.ConfigPath, "benchmark.data");
            if (File.Exists(path)) {
                var data = File.ReadAllLines(path);
                var headers = data.First().Split(' ').Skip(1).ToList();

                foreach (var line in data.Skip(1)) {
                    var lineData = line.Split(' ').ToList();
                    var gameFrame = double.Parse(lineData[0]);
                    for (var i = 1; i < lineData.Count; i++) runEntry.RawValues.Add(new ValueEntry() { GameFrame = gameFrame, Key = headers[i], Value = double.Parse(lineData[i]) });
                }
            }
        }
예제 #27
0
        protected internal int Read(LexicalUnit unit, ref FragmentPosition position, char[] buffer, int offset, int count)
        {
            InternalDebug.Assert(count != 0);

            int startOffset = offset;

            if (unit.head != -1)
            {
                uint kind = this.runList[unit.head].MajorKind;

                int run = position.run;

                if (run == unit.head - 1)
                {
                    run = position.run = unit.head;
                }

                RunEntry runEntry = this.runList[run];

                if (run == unit.head || runEntry.MajorKindPlusStartFlag == kind)
                {
                    int runOffset      = position.runOffset;
                    int runDeltaOffset = position.runDeltaOffset;

                    do
                    {
                        InternalDebug.Assert(count != 0);

                        if (runEntry.Type == RunType.Literal)
                        {
                            int literalLength = Token.LiteralLength(runEntry.Value);

                            if (runDeltaOffset != literalLength)
                            {
                                if (literalLength == 1)
                                {
                                    InternalDebug.Assert(runDeltaOffset == 0);

                                    buffer[offset++] = (char)runEntry.Value;
                                    count--;
                                }
                                else
                                {
                                    InternalDebug.Assert(literalLength == 2);

                                    if (runDeltaOffset != 0)
                                    {
                                        InternalDebug.Assert(runDeltaOffset == 1);

                                        buffer[offset++] = Token.LiteralLastChar(runEntry.Value);
                                        count--;
                                    }
                                    else
                                    {
                                        buffer[offset++] = Token.LiteralFirstChar(runEntry.Value);
                                        count--;

                                        if (count == 0)
                                        {
                                            runDeltaOffset = 1;
                                            break;
                                        }

                                        buffer[offset++] = Token.LiteralLastChar(runEntry.Value);
                                        count--;
                                    }
                                }
                            }
                        }
                        else if (runEntry.Type == RunType.Normal)
                        {
                            InternalDebug.Assert(runDeltaOffset >= 0 && runDeltaOffset < runEntry.Length);

                            int copyCount = Math.Min(count, runEntry.Length - runDeltaOffset);

                            InternalDebug.Assert(copyCount != 0);

                            {
                                Buffer.BlockCopy(this.buffer, (runOffset + runDeltaOffset) * 2, buffer, offset * 2, copyCount * 2);

                                offset += copyCount;
                                count  -= copyCount;

                                if (runDeltaOffset + copyCount != runEntry.Length)
                                {
                                    runDeltaOffset += copyCount;
                                    break;
                                }
                            }
                        }

                        runOffset     += runEntry.Length;
                        runDeltaOffset = 0;

                        runEntry = this.runList[++run];
                    }while (runEntry.MajorKindPlusStartFlag == kind && count != 0);

                    position.run            = run;
                    position.runOffset      = runOffset;
                    position.runDeltaOffset = runDeltaOffset;
                }
            }

            return(offset - startOffset);
        }