Example #1
0
        internal unsafe static int Tokenize_Unroll_Unsafe(ReadOnlySpan <byte> token, TokenSegment *pSegments)
        {
            int start;
            var span = token;
            int last = span.LastIndexOf(ByteDot);
            int end  = span.IndexOf(ByteDot);

            if (end < 0)
            {
                return(0);
            }

            *pSegments = new TokenSegment(0, end);
            start = end + 1;
            span  = token.Slice(start);
            end   = span.IndexOf(ByteDot);
            if (end < 0)
            {
                return(0);
            }

            *(pSegments + 1) = new TokenSegment(start, end);
            start           += end + 1;
            if (last == start - 1)
            {
                *(pSegments + 2) = new TokenSegment(last + 1, token.Length - last - 1);
                return(3);
            }

            span = token.Slice(start);
            end  = span.IndexOf(ByteDot);
            if (end < 0)
            {
                return(0);
            }

            *(pSegments + 2) = new TokenSegment(start, end);
            start           += end + 1;
            span             = token.Slice(start);

            end = span.IndexOf(ByteDot);
            if (end < 0)
            {
                return(0);
            }

            *(pSegments + 3) = new TokenSegment(start, end);
            start           += end + 1;
            if (last == start - 1)
            {
                *(pSegments + 4) = new TokenSegment(last + 1, token.Length - last - 1);
                return(5);
            }

            return(0);
        }
Example #2
0
        internal unsafe static int Tokenize_Unsafe(ReadOnlySpan <byte> token, TokenSegment *pSegments)
        {
            int count = 0;
            int start = 0;
            int end;
            var span = token;

            while ((end = span.IndexOf(ByteDot)) >= 0 && count < 5)
            {
                *(pSegments + count++) = new TokenSegment(start, end);
                start += end + 1;
                span   = token.Slice(start);
            }

            // Residue
            if (count < 5)
            {
                *(pSegments + count++) = new TokenSegment(start, span.Length);
            }

            return(count);
        }
Example #3
0
        internal static unsafe int Tokenize_AvoidLastSlice_Unsafe(ReadOnlySpan <byte> token, TokenSegment *pSegments)
        {
            int count = 0;
            int start = 0;
            int end;
            int last = token.LastIndexOf(ByteDot);
            var span = token;

            while ((end = span.IndexOf(ByteDot)) >= 0 && count < 5)
            {
                *(pSegments + count++) = new TokenSegment(start, end);
                start += end + 1;
                if (last == start - 1)
                {
                    *(pSegments + count++) = new TokenSegment(last + 1, token.Length - last - 1);
                    break;
                }

                span = token.Slice(start);
            }

            return(count);
        }