ParseRemaining()

unsafe void System.Uri.ParseRemaining ( )

inlineprivate

Definition at line 2215 of file Uri.cs.

    {
        EnsureUriInfo();
        Flags flags = Flags.Zero;
        if (!UserDrivenParsing)
        {
            bool flag = (_flags & (Flags.HasUnicode | Flags.RestUnicodeNormalized)) == Flags.HasUnicode;
            int scheme = _info.Offset.Scheme;
            int length = _string.Length;
            Check check = Check.None;
            UriSyntaxFlags flags2 = _syntax.Flags;
            fixed (char* ptr = _string)
            {
                GetLengthWithoutTrailingSpaces(_string, ref length, scheme);
                if (IsImplicitFile)
                {
                    flags |= Flags.SchemeNotCanonical;
                }
                else
                {
                    string schemeName = _syntax.SchemeName;
                    int i;
                    for (i = 0; i < schemeName.Length; i++)
                    {
                        if (schemeName[i] != ptr[scheme + i])
                        {
                            flags |= Flags.SchemeNotCanonical;
                        }
                    }
                    if ((_flags & Flags.AuthorityFound) != Flags.Zero && (scheme + i + 3 >= length || ptr[scheme + i + 1] != '/' || ptr[scheme + i + 2] != '/'))
                    {
                        flags |= Flags.SchemeNotCanonical;
                    }
                }
                if ((_flags & Flags.HasUserInfo) != Flags.Zero)
                {
                    scheme = _info.Offset.User;
                    check = CheckCanonical(ptr, ref scheme, _info.Offset.Host, '@');
                    if ((check & Check.DisplayCanonical) == 0)
                    {
                        flags |= Flags.UserNotCanonical;
                    }
                    if ((check & (Check.EscapedCanonical | Check.BackslashInPath)) != Check.EscapedCanonical)
                    {
                        flags |= Flags.E_UserNotCanonical;
                    }
                    if (IriParsing && (check & (Check.EscapedCanonical | Check.DisplayCanonical | Check.BackslashInPath | Check.NotIriCanonical | Check.FoundNonAscii)) == (Check.DisplayCanonical | Check.FoundNonAscii))
                    {
                        flags |= Flags.UserIriCanonical;
                    }
                }
            }
            scheme = _info.Offset.Path;
            int num = _info.Offset.Path;
            if (flag)
            {
                if (IsFile && !IsUncPath)
                {
                    if (IsImplicitFile)
                    {
                        _string = string.Empty;
                    }
                    else
                    {
                        _string = _syntax.SchemeName + SchemeDelimiter;
                    }
                }
                _info.Offset.Path = (ushort)_string.Length;
                scheme = _info.Offset.Path;
            }
            if (DisablePathAndQueryCanonicalization)
            {
                if (flag)
                {
                    _string += _originalUnicodeString.Substring(num);
                }
                string @string = _string;
                if (IsImplicitFile || (flags2 & UriSyntaxFlags.MayHaveQuery) == 0)
                {
                    scheme = @string.Length;
                }
                else
                {
                    scheme = @string.IndexOf('?');
                    if (scheme == -1)
                    {
                        scheme = @string.Length;
                    }
                }
                _info.Offset.Query = (ushort)scheme;
                _info.Offset.Fragment = (ushort)@string.Length;
                _info.Offset.End = (ushort)@string.Length;
            }
            else
            {
                if (flag)
                {
                    int start = num;
                    if (IsImplicitFile || (flags2 & (UriSyntaxFlags.MayHaveQuery | UriSyntaxFlags.MayHaveFragment)) == 0)
                    {
                        num = _originalUnicodeString.Length;
                    }
                    else
                    {
                        ReadOnlySpan<char> span = _originalUnicodeString.AsSpan(num);
                        int num2 = ((!_syntax.InFact(UriSyntaxFlags.MayHaveQuery)) ? span.IndexOf('#') : ((!_syntax.InFact(UriSyntaxFlags.MayHaveFragment)) ? span.IndexOf('?') : span.IndexOfAny('?', '#')));
                        num = ((num2 == -1) ? _originalUnicodeString.Length : (num2 + num));
                    }
                    _string += EscapeUnescapeIri(_originalUnicodeString, start, num, UriComponents.Path);
                    if (_string.Length > 65535)
                    {
                        UriFormatException exception = GetException(ParsingError.SizeLimit);
                        throw exception;
                    }
                    length = _string.Length;
                    if (_string == _originalUnicodeString)
                    {
                        GetLengthWithoutTrailingSpaces(_string, ref length, scheme);
                    }
                }
                fixed (char* ptr2 = _string)
                {
                    check = ((!IsImplicitFile && (flags2 & (UriSyntaxFlags.MayHaveQuery | UriSyntaxFlags.MayHaveFragment)) != 0) ? CheckCanonical(ptr2, ref scheme, length, ((flags2 & UriSyntaxFlags.MayHaveQuery) != 0) ? '?' : (_syntax.InFact(UriSyntaxFlags.MayHaveFragment) ? '#' : '\ufffe')) : CheckCanonical(ptr2, ref scheme, length, '\uffff'));
                    if ((_flags & Flags.AuthorityFound) != Flags.Zero && (flags2 & UriSyntaxFlags.PathIsRooted) != 0 && (_info.Offset.Path == length || (ptr2[(int)_info.Offset.Path] != '/' && ptr2[(int)_info.Offset.Path] != '\\')))
                    {
                        flags |= Flags.FirstSlashAbsent;
                    }
                }
                bool flag2 = false;
                if (IsDosPath || ((_flags & Flags.AuthorityFound) != Flags.Zero && ((flags2 & (UriSyntaxFlags.ConvertPathSlashes | UriSyntaxFlags.CompressPath)) != 0 || _syntax.InFact(UriSyntaxFlags.UnEscapeDotsAndSlashes))))
                {
                    if ((check & Check.DotSlashEscaped) != 0 && _syntax.InFact(UriSyntaxFlags.UnEscapeDotsAndSlashes))
                    {
                        flags |= Flags.PathNotCanonical | Flags.E_PathNotCanonical;
                        flag2 = true;
                    }
                    if ((flags2 & UriSyntaxFlags.ConvertPathSlashes) != 0 && (check & Check.BackslashInPath) != 0)
                    {
                        flags |= Flags.PathNotCanonical | Flags.E_PathNotCanonical;
                        flag2 = true;
                    }
                    if ((flags2 & UriSyntaxFlags.CompressPath) != 0 && ((flags & Flags.E_PathNotCanonical) != Flags.Zero || (check & Check.DotSlashAttn) != 0))
                    {
                        flags |= Flags.ShouldBeCompressed;
                    }
                    if ((check & Check.BackslashInPath) != 0)
                    {
                        flags |= Flags.BackslashInPath;
                    }
                }
                else if ((check & Check.BackslashInPath) != 0)
                {
                    flags |= Flags.E_PathNotCanonical;
                    flag2 = true;
                }
                if ((check & Check.DisplayCanonical) == 0 && ((_flags & Flags.ImplicitFile) == Flags.Zero || (_flags & Flags.UserEscaped) != Flags.Zero || (check & Check.ReservedFound) != 0))
                {
                    flags |= Flags.PathNotCanonical;
                    flag2 = true;
                }
                if ((_flags & Flags.ImplicitFile) != Flags.Zero && (check & (Check.EscapedCanonical | Check.ReservedFound)) != 0)
                {
                    check &= ~Check.EscapedCanonical;
                }
                if ((check & Check.EscapedCanonical) == 0)
                {
                    flags |= Flags.E_PathNotCanonical;
                }
                if (IriParsing && !flag2 && (check & (Check.EscapedCanonical | Check.DisplayCanonical | Check.NotIriCanonical | Check.FoundNonAscii)) == (Check.DisplayCanonical | Check.FoundNonAscii))
                {
                    flags |= Flags.PathIriCanonical;
                }
                if (flag)
                {
                    int start2 = num;
                    if (num < _originalUnicodeString.Length && _originalUnicodeString[num] == '?')
                    {
                        if ((flags2 & UriSyntaxFlags.MayHaveFragment) != 0)
                        {
                            num++;
                            int num3 = _originalUnicodeString.AsSpan(num).IndexOf('#');
                            num = ((num3 == -1) ? _originalUnicodeString.Length : (num3 + num));
                        }
                        else
                        {
                            num = _originalUnicodeString.Length;
                        }
                        _string += EscapeUnescapeIri(_originalUnicodeString, start2, num, UriComponents.Query);
                        if (_string.Length > 65535)
                        {
                            UriFormatException exception2 = GetException(ParsingError.SizeLimit);
                            throw exception2;
                        }
                        length = _string.Length;
                        if (_string == _originalUnicodeString)
                        {
                            GetLengthWithoutTrailingSpaces(_string, ref length, scheme);
                        }
                    }
                }
                _info.Offset.Query = (ushort)scheme;
                fixed (char* ptr3 = _string)
                {
                    if (scheme < length && ptr3[scheme] == '?')
                    {
                        scheme++;
                        check = CheckCanonical(ptr3, ref scheme, length, ((flags2 & UriSyntaxFlags.MayHaveFragment) != 0) ? '#' : '\ufffe');
                        if ((check & Check.DisplayCanonical) == 0)
                        {
                            flags |= Flags.QueryNotCanonical;
                        }
                        if ((check & (Check.EscapedCanonical | Check.BackslashInPath)) != Check.EscapedCanonical)
                        {
                            flags |= Flags.E_QueryNotCanonical;
                        }
                        if (IriParsing && (check & (Check.EscapedCanonical | Check.DisplayCanonical | Check.BackslashInPath | Check.NotIriCanonical | Check.FoundNonAscii)) == (Check.DisplayCanonical | Check.FoundNonAscii))
                        {
                            flags |= Flags.QueryIriCanonical;
                        }
                    }
                }
                if (flag)
                {
                    int start3 = num;
                    if (num < _originalUnicodeString.Length && _originalUnicodeString[num] == '#')
                    {
                        num = _originalUnicodeString.Length;
                        _string += EscapeUnescapeIri(_originalUnicodeString, start3, num, UriComponents.Fragment);
                        if (_string.Length > 65535)
                        {
                            UriFormatException exception3 = GetException(ParsingError.SizeLimit);
                            throw exception3;
                        }
                        length = _string.Length;
                        GetLengthWithoutTrailingSpaces(_string, ref length, scheme);
                    }
                }
                _info.Offset.Fragment = (ushort)scheme;
                fixed (char* ptr4 = _string)
                {
                    if (scheme < length && ptr4[scheme] == '#')
                    {
                        scheme++;
                        check = CheckCanonical(ptr4, ref scheme, length, '\ufffe');
                        if ((check & Check.DisplayCanonical) == 0)
                        {
                            flags |= Flags.FragmentNotCanonical;
                        }
                        if ((check & (Check.EscapedCanonical | Check.BackslashInPath)) != Check.EscapedCanonical)
                        {
                            flags |= Flags.E_FragmentNotCanonical;
                        }
                        if (IriParsing && (check & (Check.EscapedCanonical | Check.DisplayCanonical | Check.BackslashInPath | Check.NotIriCanonical | Check.FoundNonAscii)) == (Check.DisplayCanonical | Check.FoundNonAscii))
                        {
                            flags |= Flags.FragmentIriCanonical;
                        }
                    }
                }
                _info.Offset.End = (ushort)scheme;
            }
        }
        flags |= Flags.AllUriInfoSet | Flags.RestUnicodeNormalized;
        InterlockedSetFlags(flags);
    }

References System.Uri._flags, System.Uri._info, System.Uri._originalUnicodeString, System.Uri._string, System.Uri._syntax, System.Uri.CheckCanonical(), System.Runtime.Serialization.Dictionary, System.Uri.DisablePathAndQueryCanonicalization, System.Uri.EnsureUriInfo(), System.Uri.EscapeUnescapeIri(), System.exception, System.UriParser.Flags, System.Uri.GetException(), System.Uri.GetLengthWithoutTrailingSpaces(), System.Uri.Offset.Host, System.UriParser.InFact(), System.Uri.InterlockedSetFlags(), System.Uri.IriParsing, System.Uri.IsDosPath, System.Uri.IsFile, System.Uri.IsImplicitFile, System.Uri.IsUncPath, System.length, System.Uri.UriInfo.Offset, System.Uri.Offset.Path, System.Uri.Offset.Scheme, System.Uri.SchemeDelimiter, System.UriParser.SchemeName, System.start, System.Uri.Offset.User, and System.Uri.UserDrivenParsing.

Referenced by System.Uri.EnsureParseRemaining().