|
// <auto-generated/>
#nullable enable
#pragma warning disable
namespace System.Xml
{
partial class XmlConvert
{
/// <remarks>
/// Pattern:<br/>
/// <code>_[Xx][0-9a-fA-F]{4}(?:_|[0-9a-fA-F]{4}_)</code><br/>
/// Explanation:<br/>
/// <code>
/// ○ Match '_'.<br/>
/// ○ Match a character in the set [Xx].<br/>
/// ○ Match a hexadecimal digit exactly 4 times.<br/>
/// ○ Match with 2 alternative expressions, atomically.<br/>
/// ○ Match '_'.<br/>
/// ○ Match a sequence of expressions.<br/>
/// ○ Match a hexadecimal digit exactly 4 times.<br/>
/// ○ Match '_'.<br/>
/// </code>
/// </remarks>
[global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Text.RegularExpressions.Generator", "11.0.14.26904")]
private static partial global::System.Text.RegularExpressions.Regex DecodeCharRegex => global::System.Text.RegularExpressions.Generated.DecodeCharRegex_0.Instance;
}
}
namespace System.Xml
{
partial class XmlConvert
{
/// <remarks>
/// Pattern:<br/>
/// <code>(?<=_)[Xx][0-9a-fA-F]{4}(?:_|[0-9a-fA-F]{4}_)</code><br/>
/// Explanation:<br/>
/// <code>
/// ○ Zero-width positive lookbehind.<br/>
/// ○ Match '_' right-to-left.<br/>
/// ○ Match a character in the set [Xx].<br/>
/// ○ Match a hexadecimal digit exactly 4 times.<br/>
/// ○ Match with 2 alternative expressions, atomically.<br/>
/// ○ Match '_'.<br/>
/// ○ Match a sequence of expressions.<br/>
/// ○ Match a hexadecimal digit exactly 4 times.<br/>
/// ○ Match '_'.<br/>
/// </code>
/// </remarks>
[global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Text.RegularExpressions.Generator", "11.0.14.26904")]
private static partial global::System.Text.RegularExpressions.Regex EncodeCharRegex => global::System.Text.RegularExpressions.Generated.EncodeCharRegex_1.Instance;
}
}
namespace System.Xml.Schema
{
partial class StringFacetsChecker
{
/// <remarks>
/// Pattern:<br/>
/// <code>^([a-zA-Z]{1,8})(-[a-zA-Z0-9]{1,8})*$</code><br/>
/// Options:<br/>
/// <code>RegexOptions.ExplicitCapture</code><br/>
/// Explanation:<br/>
/// <code>
/// ○ Match if at the beginning of the string.<br/>
/// ○ Match an ASCII letter greedily at least 1 and at most 8 times.<br/>
/// ○ Loop greedily any number of times.<br/>
/// ○ Match '-'.<br/>
/// ○ Match an ASCII letter or digit atomically at least 1 and at most 8 times.<br/>
/// ○ Match if at the end of the string or if before an ending newline.<br/>
/// </code>
/// </remarks>
[global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Text.RegularExpressions.Generator", "11.0.14.26904")]
private static partial global::System.Text.RegularExpressions.Regex LanguageRegex => global::System.Text.RegularExpressions.Generated.LanguageRegex_2.Instance;
}
}
namespace System.Xml.Serialization
{
partial class SourceInfo
{
/// <remarks>
/// Pattern:<br/>
/// <code>([(][(](?<t>[^)]+)[)])?(?<a>[^[]+)[[](?<ia>.+)[]][)]?</code><br/>
/// Explanation:<br/>
/// <code>
/// ○ Optional (greedy).<br/>
/// ○ 1st capture group.<br/>
/// ○ Match the string "((".<br/>
/// ○ "t" capture group.<br/>
/// ○ Match a character other than ')' atomically at least once.<br/>
/// ○ Match ')'.<br/>
/// ○ "a" capture group.<br/>
/// ○ Match a character other than '[' atomically at least once.<br/>
/// ○ Match '['.<br/>
/// ○ "ia" capture group.<br/>
/// ○ Match a character other than '\n' greedily at least once.<br/>
/// ○ Match ']'.<br/>
/// ○ Match ')' atomically, optionally.<br/>
/// </code>
/// </remarks>
[global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Text.RegularExpressions.Generator", "11.0.14.26904")]
private static partial global::System.Text.RegularExpressions.Regex Regex1 => global::System.Text.RegularExpressions.Generated.Regex1_3.Instance;
}
}
namespace System.Xml.Serialization
{
partial class SourceInfo
{
/// <remarks>
/// Pattern:<br/>
/// <code>[(][(](?<cast>[^)]+)[)](?<arg>[^)]+)[)]</code><br/>
/// Explanation:<br/>
/// <code>
/// ○ Match the string "((".<br/>
/// ○ "cast" capture group.<br/>
/// ○ Match a character other than ')' atomically at least once.<br/>
/// ○ Match ')'.<br/>
/// ○ "arg" capture group.<br/>
/// ○ Match a character other than ')' atomically at least once.<br/>
/// ○ Match ')'.<br/>
/// </code>
/// </remarks>
[global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Text.RegularExpressions.Generator", "11.0.14.26904")]
private static partial global::System.Text.RegularExpressions.Regex Regex2 => global::System.Text.RegularExpressions.Generated.Regex2_4.Instance;
}
}
namespace System.Xml.Serialization
{
partial class XmlSerializationReaderILGen
{
/// <remarks>
/// Pattern:<br/>
/// <code>(?<locA1>[^ ]+) = .+EnsureArrayIndex[(](?<locA2>[^,]+), (?<locI1>[^,]+),[^;]+;(?<locA3>[^[]+)[[](?<locI2>[^+]+)[+][+][]]</code><br/>
/// Explanation:<br/>
/// <code>
/// ○ "locA1" capture group.<br/>
/// ○ Match a character other than ' ' atomically at least once.<br/>
/// ○ Match the string " = ".<br/>
/// ○ Match a character other than '\n' greedily at least once.<br/>
/// ○ Match the string "EnsureArrayIndex(".<br/>
/// ○ "locA2" capture group.<br/>
/// ○ Match a character other than ',' atomically at least once.<br/>
/// ○ Match the string ", ".<br/>
/// ○ "locI1" capture group.<br/>
/// ○ Match a character other than ',' atomically at least once.<br/>
/// ○ Match ','.<br/>
/// ○ Match a character other than ';' atomically at least once.<br/>
/// ○ Match ';'.<br/>
/// ○ "locA3" capture group.<br/>
/// ○ Match a character other than '[' atomically at least once.<br/>
/// ○ Match '['.<br/>
/// ○ "locI2" capture group.<br/>
/// ○ Match a character other than '+' atomically at least once.<br/>
/// ○ Match the string "++]".<br/>
/// </code>
/// </remarks>
[global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Text.RegularExpressions.Generator", "11.0.14.26904")]
private static partial global::System.Text.RegularExpressions.Regex EnsureArrayIndexRegex => global::System.Text.RegularExpressions.Generated.EnsureArrayIndexRegex_5.Instance;
}
}
namespace System.Xml.Serialization
{
partial class XmlSerializationReaderILGen
{
/// <remarks>
/// Pattern:<br/>
/// <code>(?<a>[^[]+)[[](?<ia>.+)[]]</code><br/>
/// Explanation:<br/>
/// <code>
/// ○ "a" capture group.<br/>
/// ○ Match a character other than '[' atomically at least once.<br/>
/// ○ Match '['.<br/>
/// ○ "ia" capture group.<br/>
/// ○ Match a character other than '\n' greedily at least once.<br/>
/// ○ Match ']'.<br/>
/// </code>
/// </remarks>
[global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Text.RegularExpressions.Generator", "11.0.14.26904")]
private static partial global::System.Text.RegularExpressions.Regex P0Regex => global::System.Text.RegularExpressions.Generated.P0Regex_6.Instance;
}
}
namespace System.Xml.Serialization
{
partial class XmlSerializationReaderILGen
{
/// <remarks>
/// Pattern:<br/>
/// <code>UnknownNode[(]null, @["](?<qnames>[^"]*)["][)];</code><br/>
/// Explanation:<br/>
/// <code>
/// ○ Match the string "UnknownNode(null, @\"".<br/>
/// ○ "qnames" capture group.<br/>
/// ○ Match a character other than '"' atomically any number of times.<br/>
/// ○ Match the string "\");".<br/>
/// </code>
/// </remarks>
[global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Text.RegularExpressions.Generator", "11.0.14.26904")]
private static partial global::System.Text.RegularExpressions.Regex UnknownNodeNullAnyTypeRegex => global::System.Text.RegularExpressions.Generated.UnknownNodeNullAnyTypeRegex_7.Instance;
}
}
namespace System.Xml.Serialization
{
partial class XmlSerializationReaderILGen
{
/// <remarks>
/// Pattern:<br/>
/// <code>UnknownNode[(][(]object[)](?<o>[^,]+), @["](?<qnames>[^"]*)["][)];</code><br/>
/// Explanation:<br/>
/// <code>
/// ○ Match the string "UnknownNode((object)".<br/>
/// ○ "o" capture group.<br/>
/// ○ Match a character other than ',' atomically at least once.<br/>
/// ○ Match the string ", @\"".<br/>
/// ○ "qnames" capture group.<br/>
/// ○ Match a character other than '"' atomically any number of times.<br/>
/// ○ Match the string "\");".<br/>
/// </code>
/// </remarks>
[global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Text.RegularExpressions.Generator", "11.0.14.26904")]
private static partial global::System.Text.RegularExpressions.Regex UnknownNodeObjectEmptyRegex => global::System.Text.RegularExpressions.Generated.UnknownNodeObjectEmptyRegex_8.Instance;
}
}
namespace System.Xml.Serialization
{
partial class XmlSerializationReaderILGen
{
/// <remarks>
/// Pattern:<br/>
/// <code>UnknownNode[(][(]object[)](?<o>[^,]+), null[)];</code><br/>
/// Explanation:<br/>
/// <code>
/// ○ Match the string "UnknownNode((object)".<br/>
/// ○ "o" capture group.<br/>
/// ○ Match a character other than ',' atomically at least once.<br/>
/// ○ Match the string ", null);".<br/>
/// </code>
/// </remarks>
[global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Text.RegularExpressions.Generator", "11.0.14.26904")]
private static partial global::System.Text.RegularExpressions.Regex UnknownNodeObjectNullRegex => global::System.Text.RegularExpressions.Generated.UnknownNodeObjectNullRegex_9.Instance;
}
}
namespace System.Xml.Serialization
{
partial class XmlSerializationReaderILGen
{
/// <remarks>
/// Pattern:<br/>
/// <code>UnknownNode[(][(]object[)](?<o>[^)]+)[)];</code><br/>
/// Explanation:<br/>
/// <code>
/// ○ Match the string "UnknownNode((object)".<br/>
/// ○ "o" capture group.<br/>
/// ○ Match a character other than ')' atomically at least once.<br/>
/// ○ Match the string ");".<br/>
/// </code>
/// </remarks>
[global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Text.RegularExpressions.Generator", "11.0.14.26904")]
private static partial global::System.Text.RegularExpressions.Regex UnknownNodeObjectRegex => global::System.Text.RegularExpressions.Generated.UnknownNodeObjectRegex_10.Instance;
}
}
namespace System.Xml.Serialization
{
partial class XmlSerializationReaderILGen
{
/// <remarks>
/// Pattern:<br/>
/// <code>paramsRead\[(?<index>[0-9]+)\]</code><br/>
/// Explanation:<br/>
/// <code>
/// ○ Match the string "paramsRead[".<br/>
/// ○ "index" capture group.<br/>
/// ○ Match a character in the set [0-9] atomically at least once.<br/>
/// ○ Match ']'.<br/>
/// </code>
/// </remarks>
[global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Text.RegularExpressions.Generator", "11.0.14.26904")]
private static partial global::System.Text.RegularExpressions.Regex ParamsReadRegex => global::System.Text.RegularExpressions.Generated.ParamsReadRegex_11.Instance;
}
}
namespace System.Text.RegularExpressions.Generated
{
using System;
using System.Buffers;
using System.CodeDom.Compiler;
using System.Collections;
using System.ComponentModel;
using System.Globalization;
using System.Runtime.CompilerServices;
using System.Text.RegularExpressions;
using System.Threading;
/// <summary>Custom <see cref="Regex"/>-derived type for the DecodeCharRegex method.</summary>
[GeneratedCodeAttribute("System.Text.RegularExpressions.Generator", "11.0.14.26904")]
[SkipLocalsInit]
file sealed class DecodeCharRegex_0 : Regex
{
/// <summary>Cached, thread-safe singleton instance.</summary>
internal static readonly DecodeCharRegex_0 Instance = new();
/// <summary>Initializes the instance.</summary>
private DecodeCharRegex_0()
{
base.pattern = "_[Xx][0-9a-fA-F]{4}(?:_|[0-9a-fA-F]{4}_)";
base.roptions = RegexOptions.None;
ValidateMatchTimeout(Utilities.s_defaultTimeout);
base.internalMatchTimeout = Utilities.s_defaultTimeout;
base.factory = new RunnerFactory();
base.capsize = 1;
}
/// <summary>Provides a factory for creating <see cref="RegexRunner"/> instances to be used by methods on <see cref="Regex"/>.</summary>
private sealed class RunnerFactory : RegexRunnerFactory
{
/// <summary>Creates an instance of a <see cref="RegexRunner"/> used by methods on <see cref="Regex"/>.</summary>
protected override RegexRunner CreateInstance() => new Runner();
/// <summary>Provides the runner that contains the custom logic implementing the specified regular expression.</summary>
private sealed class Runner : RegexRunner
{
/// <summary>Scan the <paramref name="inputSpan"/> starting from base.runtextstart for the next match.</summary>
/// <param name="inputSpan">The text being scanned by the regular expression.</param>
protected override void Scan(ReadOnlySpan<char> inputSpan)
{
// Search until we can't find a valid starting position, we find a match, or we reach the end of the input.
while (TryFindNextPossibleStartingPosition(inputSpan) &&
!TryMatchAtCurrentPosition(inputSpan) &&
base.runtextpos != inputSpan.Length)
{
base.runtextpos++;
if (Utilities.s_hasTimeout)
{
base.CheckTimeout();
}
}
}
/// <summary>Search <paramref name="inputSpan"/> starting from base.runtextpos for the next location a match could possibly start.</summary>
/// <param name="inputSpan">The text being scanned by the regular expression.</param>
/// <returns>true if a possible match was found; false if no more matches are possible.</returns>
private bool TryFindNextPossibleStartingPosition(ReadOnlySpan<char> inputSpan)
{
int pos = base.runtextpos;
// Any possible match is at least 7 characters.
if (pos <= inputSpan.Length - 7)
{
// The pattern has the literal "_x" ordinal case-insensitive at the beginning of the pattern. Find the next occurrence.
// If it can't be found, there's no match.
int i = inputSpan.Slice(pos).IndexOfAny(Utilities.s_indexOfString__x_OrdinalIgnoreCase);
if (i >= 0)
{
base.runtextpos = pos + i;
return true;
}
}
// No match found.
base.runtextpos = inputSpan.Length;
return false;
}
/// <summary>Determine whether <paramref name="inputSpan"/> at base.runtextpos is a match for the regular expression.</summary>
/// <param name="inputSpan">The text being scanned by the regular expression.</param>
/// <returns>true if the regular expression matches at the current position; otherwise, false.</returns>
private bool TryMatchAtCurrentPosition(ReadOnlySpan<char> inputSpan)
{
int pos = base.runtextpos;
int matchStart = pos;
ReadOnlySpan<char> slice = inputSpan.Slice(pos);
if ((uint)slice.Length < 6 ||
!slice.StartsWith("_x", StringComparison.OrdinalIgnoreCase) || // Match the string "_x" (ordinal case-insensitive)
!char.IsAsciiHexDigit(slice[2]) || // Match a hexadecimal digit exactly 4 times.
!char.IsAsciiHexDigit(slice[3]) ||
!char.IsAsciiHexDigit(slice[4]) ||
!char.IsAsciiHexDigit(slice[5]))
{
return false; // The input didn't match.
}
// Match with 2 alternative expressions, atomically.
{
if ((uint)slice.Length < 7)
{
return false; // The input didn't match.
}
switch (slice[6])
{
case '_':
pos += 7;
slice = inputSpan.Slice(pos);
break;
case '0' or '1' or '2' or '3' or '4' or '5' or '6' or '7' or '8' or '9' or 'A' or 'B' or 'C' or 'D' or 'E' or 'F' or 'a' or 'b' or 'c' or 'd' or 'e' or 'f':
if ((uint)slice.Length < 11 ||
!char.IsAsciiHexDigit(slice[6]) || // Match a hexadecimal digit exactly 4 times.
!char.IsAsciiHexDigit(slice[7]) ||
!char.IsAsciiHexDigit(slice[8]) ||
!char.IsAsciiHexDigit(slice[9]) ||
slice[10] != '_') // Match '_'.
{
return false; // The input didn't match.
}
pos += 11;
slice = inputSpan.Slice(pos);
break;
default:
return false; // The input didn't match.
}
}
// The input matched.
base.runtextpos = pos;
base.Capture(0, matchStart, pos);
return true;
}
}
}
}
/// <summary>Custom <see cref="Regex"/>-derived type for the EncodeCharRegex method.</summary>
[GeneratedCodeAttribute("System.Text.RegularExpressions.Generator", "11.0.14.26904")]
[SkipLocalsInit]
file sealed class EncodeCharRegex_1 : Regex
{
/// <summary>Cached, thread-safe singleton instance.</summary>
internal static readonly EncodeCharRegex_1 Instance = new();
/// <summary>Initializes the instance.</summary>
private EncodeCharRegex_1()
{
base.pattern = "(?<=_)[Xx][0-9a-fA-F]{4}(?:_|[0-9a-fA-F]{4}_)";
base.roptions = RegexOptions.None;
ValidateMatchTimeout(Utilities.s_defaultTimeout);
base.internalMatchTimeout = Utilities.s_defaultTimeout;
base.factory = new RunnerFactory();
base.capsize = 1;
}
/// <summary>Provides a factory for creating <see cref="RegexRunner"/> instances to be used by methods on <see cref="Regex"/>.</summary>
private sealed class RunnerFactory : RegexRunnerFactory
{
/// <summary>Creates an instance of a <see cref="RegexRunner"/> used by methods on <see cref="Regex"/>.</summary>
protected override RegexRunner CreateInstance() => new Runner();
/// <summary>Provides the runner that contains the custom logic implementing the specified regular expression.</summary>
private sealed class Runner : RegexRunner
{
/// <summary>Scan the <paramref name="inputSpan"/> starting from base.runtextstart for the next match.</summary>
/// <param name="inputSpan">The text being scanned by the regular expression.</param>
protected override void Scan(ReadOnlySpan<char> inputSpan)
{
// Search until we can't find a valid starting position, we find a match, or we reach the end of the input.
while (TryFindNextPossibleStartingPosition(inputSpan) &&
!TryMatchAtCurrentPosition(inputSpan) &&
base.runtextpos != inputSpan.Length)
{
base.runtextpos++;
if (Utilities.s_hasTimeout)
{
base.CheckTimeout();
}
}
}
/// <summary>Search <paramref name="inputSpan"/> starting from base.runtextpos for the next location a match could possibly start.</summary>
/// <param name="inputSpan">The text being scanned by the regular expression.</param>
/// <returns>true if a possible match was found; false if no more matches are possible.</returns>
private bool TryFindNextPossibleStartingPosition(ReadOnlySpan<char> inputSpan)
{
int pos = base.runtextpos;
// Any possible match is at least 6 characters.
if (pos <= inputSpan.Length - 6)
{
// The pattern begins with a character in the set [Xx].
// Find the next occurrence. If it can't be found, there's no match.
int i = inputSpan.Slice(pos).IndexOfAny('X', 'x');
if (i >= 0)
{
base.runtextpos = pos + i;
return true;
}
}
// No match found.
base.runtextpos = inputSpan.Length;
return false;
}
/// <summary>Determine whether <paramref name="inputSpan"/> at base.runtextpos is a match for the regular expression.</summary>
/// <param name="inputSpan">The text being scanned by the regular expression.</param>
/// <returns>true if the regular expression matches at the current position; otherwise, false.</returns>
private bool TryMatchAtCurrentPosition(ReadOnlySpan<char> inputSpan)
{
int pos = base.runtextpos;
int matchStart = pos;
int stackpos = 0;
ReadOnlySpan<char> slice = inputSpan.Slice(pos);
// Zero-width positive lookbehind.
{
slice = inputSpan.Slice(pos);
int positivelookbehind_starting_pos = pos;
if (Utilities.s_hasTimeout)
{
base.CheckTimeout();
}
int atomic_stackpos = stackpos;
// Match '_' right-to-left.
if ((uint)(pos - 1) >= inputSpan.Length || inputSpan[pos - 1] != '_')
{
return false; // The input didn't match.
}
pos--;
stackpos = atomic_stackpos;
pos = positivelookbehind_starting_pos;
slice = inputSpan.Slice(pos);
}
if ((uint)slice.Length < 5 ||
((slice[0] | 0x20) != 'x') || // Match a character in the set [Xx].
!char.IsAsciiHexDigit(slice[1]) || // Match a hexadecimal digit exactly 4 times.
!char.IsAsciiHexDigit(slice[2]) ||
!char.IsAsciiHexDigit(slice[3]) ||
!char.IsAsciiHexDigit(slice[4]))
{
return false; // The input didn't match.
}
// Match with 2 alternative expressions, atomically.
{
if ((uint)slice.Length < 6)
{
return false; // The input didn't match.
}
switch (slice[5])
{
case '_':
pos += 6;
slice = inputSpan.Slice(pos);
break;
case '0' or '1' or '2' or '3' or '4' or '5' or '6' or '7' or '8' or '9' or 'A' or 'B' or 'C' or 'D' or 'E' or 'F' or 'a' or 'b' or 'c' or 'd' or 'e' or 'f':
if ((uint)slice.Length < 10 ||
!char.IsAsciiHexDigit(slice[5]) || // Match a hexadecimal digit exactly 4 times.
!char.IsAsciiHexDigit(slice[6]) ||
!char.IsAsciiHexDigit(slice[7]) ||
!char.IsAsciiHexDigit(slice[8]) ||
slice[9] != '_') // Match '_'.
{
return false; // The input didn't match.
}
pos += 10;
slice = inputSpan.Slice(pos);
break;
default:
return false; // The input didn't match.
}
}
// The input matched.
base.runtextpos = pos;
base.Capture(0, matchStart, pos);
return true;
}
}
}
}
/// <summary>Custom <see cref="Regex"/>-derived type for the LanguageRegex method.</summary>
[GeneratedCodeAttribute("System.Text.RegularExpressions.Generator", "11.0.14.26904")]
[SkipLocalsInit]
file sealed class LanguageRegex_2 : Regex
{
/// <summary>Cached, thread-safe singleton instance.</summary>
internal static readonly LanguageRegex_2 Instance = new();
/// <summary>Initializes the instance.</summary>
private LanguageRegex_2()
{
base.pattern = "^([a-zA-Z]{1,8})(-[a-zA-Z0-9]{1,8})*$";
base.roptions = RegexOptions.ExplicitCapture;
ValidateMatchTimeout(Utilities.s_defaultTimeout);
base.internalMatchTimeout = Utilities.s_defaultTimeout;
base.factory = new RunnerFactory();
base.capsize = 1;
}
/// <summary>Provides a factory for creating <see cref="RegexRunner"/> instances to be used by methods on <see cref="Regex"/>.</summary>
private sealed class RunnerFactory : RegexRunnerFactory
{
/// <summary>Creates an instance of a <see cref="RegexRunner"/> used by methods on <see cref="Regex"/>.</summary>
protected override RegexRunner CreateInstance() => new Runner();
/// <summary>Provides the runner that contains the custom logic implementing the specified regular expression.</summary>
private sealed class Runner : RegexRunner
{
/// <summary>Scan the <paramref name="inputSpan"/> starting from base.runtextstart for the next match.</summary>
/// <param name="inputSpan">The text being scanned by the regular expression.</param>
protected override void Scan(ReadOnlySpan<char> inputSpan)
{
// The pattern is anchored. Validate the current position and try to match at it only.
if (TryFindNextPossibleStartingPosition(inputSpan) && !TryMatchAtCurrentPosition(inputSpan))
{
base.runtextpos = inputSpan.Length;
}
}
/// <summary>Search <paramref name="inputSpan"/> starting from base.runtextpos for the next location a match could possibly start.</summary>
/// <param name="inputSpan">The text being scanned by the regular expression.</param>
/// <returns>true if a possible match was found; false if no more matches are possible.</returns>
private bool TryFindNextPossibleStartingPosition(ReadOnlySpan<char> inputSpan)
{
int pos = base.runtextpos;
// Empty matches aren't possible.
if ((uint)pos < (uint)inputSpan.Length)
{
// The pattern leads with a beginning (\A) anchor.
if (pos == 0)
{
return true;
}
}
// No match found.
base.runtextpos = inputSpan.Length;
return false;
}
/// <summary>Determine whether <paramref name="inputSpan"/> at base.runtextpos is a match for the regular expression.</summary>
/// <param name="inputSpan">The text being scanned by the regular expression.</param>
/// <returns>true if the regular expression matches at the current position; otherwise, false.</returns>
private bool TryMatchAtCurrentPosition(ReadOnlySpan<char> inputSpan)
{
int pos = base.runtextpos;
int matchStart = pos;
int charloop_starting_pos = 0, charloop_ending_pos = 0;
int loop_iteration = 0;
int stackpos = 0;
ReadOnlySpan<char> slice = inputSpan.Slice(pos);
// Match if at the beginning of the string.
if (pos != 0)
{
return false; // The input didn't match.
}
// Match an ASCII letter greedily at least 1 and at most 8 times.
//{
charloop_starting_pos = pos;
int iteration = 0;
while (iteration < 8 && (uint)iteration < (uint)slice.Length && char.IsAsciiLetter(slice[iteration]))
{
iteration++;
}
if (iteration == 0)
{
return false; // The input didn't match.
}
slice = slice.Slice(iteration);
pos += iteration;
charloop_ending_pos = pos;
charloop_starting_pos++;
goto CharLoopEnd;
CharLoopBacktrack:
if (Utilities.s_hasTimeout)
{
base.CheckTimeout();
}
if (charloop_starting_pos >= charloop_ending_pos)
{
return false; // The input didn't match.
}
pos = --charloop_ending_pos;
slice = inputSpan.Slice(pos);
CharLoopEnd:
//}
// Loop greedily any number of times.
//{
loop_iteration = 0;
LoopBody:
Utilities.StackPush(ref base.runstack!, ref stackpos, pos);
loop_iteration++;
// Match '-'.
if (slice.IsEmpty || slice[0] != '-')
{
goto LoopIterationNoMatch;
}
// Match an ASCII letter or digit atomically at least 1 and at most 8 times.
{
pos++;
slice = inputSpan.Slice(pos);
int iteration1 = 0;
while (iteration1 < 8 && (uint)iteration1 < (uint)slice.Length && char.IsAsciiLetterOrDigit(slice[iteration1]))
{
iteration1++;
}
if (iteration1 == 0)
{
goto LoopIterationNoMatch;
}
slice = slice.Slice(iteration1);
pos += iteration1;
}
// The loop has no upper bound. Continue iterating greedily.
goto LoopBody;
// The loop iteration failed. Put state back to the way it was before the iteration.
LoopIterationNoMatch:
if (--loop_iteration < 0)
{
// Unable to match the remainder of the expression after exhausting the loop.
goto CharLoopBacktrack;
}
pos = base.runstack![--stackpos];
slice = inputSpan.Slice(pos);
LoopEnd:;
//}
// Match if at the end of the string or if before an ending newline.
if (pos < inputSpan.Length - 1 || ((uint)pos < (uint)inputSpan.Length && inputSpan[pos] != '\n'))
{
goto LoopIterationNoMatch;
}
// The input matched.
base.runtextpos = pos;
base.Capture(0, matchStart, pos);
return true;
}
}
}
}
/// <summary>Custom <see cref="Regex"/>-derived type for the Regex1 method.</summary>
[GeneratedCodeAttribute("System.Text.RegularExpressions.Generator", "11.0.14.26904")]
[SkipLocalsInit]
file sealed class Regex1_3 : Regex
{
/// <summary>Cached, thread-safe singleton instance.</summary>
internal static readonly Regex1_3 Instance = new();
/// <summary>Initializes the instance.</summary>
private Regex1_3()
{
base.pattern = "([(][(](?<t>[^)]+)[)])?(?<a>[^[]+)[[](?<ia>.+)[]][)]?";
base.roptions = RegexOptions.None;
ValidateMatchTimeout(Utilities.s_defaultTimeout);
base.internalMatchTimeout = Utilities.s_defaultTimeout;
base.factory = new RunnerFactory();
base.CapNames = new Hashtable { { "0", 0 } , { "1", 1 } , { "a", 3 } , { "ia", 4 } , { "t", 2 } };
base.capslist = new string[] {"0", "1", "t", "a", "ia" };
base.capsize = 5;
}
/// <summary>Provides a factory for creating <see cref="RegexRunner"/> instances to be used by methods on <see cref="Regex"/>.</summary>
private sealed class RunnerFactory : RegexRunnerFactory
{
/// <summary>Creates an instance of a <see cref="RegexRunner"/> used by methods on <see cref="Regex"/>.</summary>
protected override RegexRunner CreateInstance() => new Runner();
/// <summary>Provides the runner that contains the custom logic implementing the specified regular expression.</summary>
private sealed class Runner : RegexRunner
{
/// <summary>Scan the <paramref name="inputSpan"/> starting from base.runtextstart for the next match.</summary>
/// <param name="inputSpan">The text being scanned by the regular expression.</param>
protected override void Scan(ReadOnlySpan<char> inputSpan)
{
// Search until we can't find a valid starting position, we find a match, or we reach the end of the input.
while (TryFindNextPossibleStartingPosition(inputSpan) &&
!TryMatchAtCurrentPosition(inputSpan) &&
base.runtextpos != inputSpan.Length)
{
base.runtextpos++;
if (Utilities.s_hasTimeout)
{
base.CheckTimeout();
}
}
}
/// <summary>Search <paramref name="inputSpan"/> starting from base.runtextpos for the next location a match could possibly start.</summary>
/// <param name="inputSpan">The text being scanned by the regular expression.</param>
/// <returns>true if a possible match was found; false if no more matches are possible.</returns>
private bool TryFindNextPossibleStartingPosition(ReadOnlySpan<char> inputSpan)
{
int pos = base.runtextpos;
// Any possible match is at least 4 characters.
if (pos <= inputSpan.Length - 4)
{
// The pattern begins with a character in the set [^[].
// Find the next occurrence. If it can't be found, there's no match.
int i = inputSpan.Slice(pos).IndexOfAnyExcept('[');
if (i >= 0)
{
base.runtextpos = pos + i;
return true;
}
}
// No match found.
base.runtextpos = inputSpan.Length;
return false;
}
/// <summary>Determine whether <paramref name="inputSpan"/> at base.runtextpos is a match for the regular expression.</summary>
/// <param name="inputSpan">The text being scanned by the regular expression.</param>
/// <returns>true if the regular expression matches at the current position; otherwise, false.</returns>
private bool TryMatchAtCurrentPosition(ReadOnlySpan<char> inputSpan)
{
int pos = base.runtextpos;
int matchStart = pos;
int capture_starting_pos2 = 0;
int capture_starting_pos3 = 0;
int charloop_capture_pos = 0;
int charloop_starting_pos = 0, charloop_ending_pos = 0;
int loop_iteration = 0;
int stackpos = 0;
ReadOnlySpan<char> slice = inputSpan.Slice(pos);
// Optional (greedy).
//{
loop_iteration = 0;
LoopBody:
Utilities.StackPush(ref base.runstack!, ref stackpos, base.Crawlpos(), pos);
loop_iteration++;
// 1st capture group.
{
int capture_starting_pos = pos;
// Match the string "((".
if (!slice.StartsWith("(("))
{
goto LoopIterationNoMatch;
}
// "t" capture group.
{
pos += 2;
slice = inputSpan.Slice(pos);
int capture_starting_pos1 = pos;
// Match a character other than ')' atomically at least once.
{
int iteration = slice.IndexOf(')');
if (iteration < 0)
{
iteration = slice.Length;
}
if (iteration == 0)
{
goto LoopIterationNoMatch;
}
slice = slice.Slice(iteration);
pos += iteration;
}
base.Capture(2, capture_starting_pos1, pos);
}
// Match ')'.
if (slice.IsEmpty || slice[0] != ')')
{
goto LoopIterationNoMatch;
}
pos++;
slice = inputSpan.Slice(pos);
base.Capture(1, capture_starting_pos, pos);
}
// The loop has an upper bound of 1. Continue iterating greedily if it hasn't yet been reached.
if (loop_iteration == 0)
{
goto LoopBody;
}
goto LoopEnd;
// The loop iteration failed. Put state back to the way it was before the iteration.
LoopIterationNoMatch:
if (--loop_iteration < 0)
{
// Unable to match the remainder of the expression after exhausting the loop.
UncaptureUntil(0);
return false; // The input didn't match.
}
pos = base.runstack![--stackpos];
UncaptureUntil(base.runstack![--stackpos]);
slice = inputSpan.Slice(pos);
LoopEnd:;
//}
// "a" capture group.
{
capture_starting_pos2 = pos;
// Match a character other than '[' atomically at least once.
{
int iteration1 = slice.IndexOf('[');
if (iteration1 < 0)
{
iteration1 = slice.Length;
}
if (iteration1 == 0)
{
goto LoopIterationNoMatch;
}
slice = slice.Slice(iteration1);
pos += iteration1;
}
base.Capture(3, capture_starting_pos2, pos);
}
// Match '['.
if (slice.IsEmpty || slice[0] != '[')
{
goto LoopIterationNoMatch;
}
// "ia" capture group.
//{
pos++;
slice = inputSpan.Slice(pos);
capture_starting_pos3 = pos;
// Match a character other than '\n' greedily at least once.
//{
charloop_starting_pos = pos;
int iteration2 = slice.IndexOf('\n');
if (iteration2 < 0)
{
iteration2 = slice.Length;
}
if (iteration2 == 0)
{
goto LoopIterationNoMatch;
}
slice = slice.Slice(iteration2);
pos += iteration2;
charloop_ending_pos = pos;
charloop_starting_pos++;
goto CharLoopEnd;
CharLoopBacktrack:
UncaptureUntil(charloop_capture_pos);
if (Utilities.s_hasTimeout)
{
base.CheckTimeout();
}
if (charloop_starting_pos >= charloop_ending_pos ||
(charloop_ending_pos = inputSpan.Slice(charloop_starting_pos, charloop_ending_pos - charloop_starting_pos).LastIndexOf(']')) < 0)
{
goto LoopIterationNoMatch;
}
charloop_ending_pos += charloop_starting_pos;
pos = charloop_ending_pos;
slice = inputSpan.Slice(pos);
CharLoopEnd:
charloop_capture_pos = base.Crawlpos();
//}
base.Capture(4, capture_starting_pos3, pos);
goto CaptureSkipBacktrack;
CaptureBacktrack:
goto CharLoopBacktrack;
CaptureSkipBacktrack:;
//}
// Match ']'.
if (slice.IsEmpty || slice[0] != ']')
{
goto CaptureBacktrack;
}
// Match ')' atomically, optionally.
{
if ((uint)slice.Length > (uint)1 && slice[1] == ')')
{
slice = slice.Slice(1);
pos++;
}
}
// The input matched.
pos++;
base.runtextpos = pos;
base.Capture(0, matchStart, pos);
return true;
// <summary>Undo captures until it reaches the specified capture position.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
void UncaptureUntil(int capturePosition)
{
while (base.Crawlpos() > capturePosition)
{
base.Uncapture();
}
}
}
}
}
}
/// <summary>Custom <see cref="Regex"/>-derived type for the Regex2 method.</summary>
[GeneratedCodeAttribute("System.Text.RegularExpressions.Generator", "11.0.14.26904")]
[SkipLocalsInit]
file sealed class Regex2_4 : Regex
{
/// <summary>Cached, thread-safe singleton instance.</summary>
internal static readonly Regex2_4 Instance = new();
/// <summary>Initializes the instance.</summary>
private Regex2_4()
{
base.pattern = "[(][(](?<cast>[^)]+)[)](?<arg>[^)]+)[)]";
base.roptions = RegexOptions.None;
ValidateMatchTimeout(Utilities.s_defaultTimeout);
base.internalMatchTimeout = Utilities.s_defaultTimeout;
base.factory = new RunnerFactory();
base.CapNames = new Hashtable { { "0", 0 } , { "arg", 2 } , { "cast", 1 } };
base.capslist = new string[] {"0", "cast", "arg" };
base.capsize = 3;
}
/// <summary>Provides a factory for creating <see cref="RegexRunner"/> instances to be used by methods on <see cref="Regex"/>.</summary>
private sealed class RunnerFactory : RegexRunnerFactory
{
/// <summary>Creates an instance of a <see cref="RegexRunner"/> used by methods on <see cref="Regex"/>.</summary>
protected override RegexRunner CreateInstance() => new Runner();
/// <summary>Provides the runner that contains the custom logic implementing the specified regular expression.</summary>
private sealed class Runner : RegexRunner
{
/// <summary>Scan the <paramref name="inputSpan"/> starting from base.runtextstart for the next match.</summary>
/// <param name="inputSpan">The text being scanned by the regular expression.</param>
protected override void Scan(ReadOnlySpan<char> inputSpan)
{
// Search until we can't find a valid starting position, we find a match, or we reach the end of the input.
while (TryFindNextPossibleStartingPosition(inputSpan) &&
!TryMatchAtCurrentPosition(inputSpan) &&
base.runtextpos != inputSpan.Length)
{
base.runtextpos++;
if (Utilities.s_hasTimeout)
{
base.CheckTimeout();
}
}
}
/// <summary>Search <paramref name="inputSpan"/> starting from base.runtextpos for the next location a match could possibly start.</summary>
/// <param name="inputSpan">The text being scanned by the regular expression.</param>
/// <returns>true if a possible match was found; false if no more matches are possible.</returns>
private bool TryFindNextPossibleStartingPosition(ReadOnlySpan<char> inputSpan)
{
int pos = base.runtextpos;
// Any possible match is at least 6 characters.
if (pos <= inputSpan.Length - 6)
{
// The pattern has the literal "((" at the beginning of the pattern. Find the next occurrence.
// If it can't be found, there's no match.
int i = inputSpan.Slice(pos).IndexOfAny(Utilities.s_indexOfString_C94AE607B1711C3F90CF8B8C224548ED74A865FE986797F62276464CE6F9271D);
if (i >= 0)
{
base.runtextpos = pos + i;
return true;
}
}
// No match found.
base.runtextpos = inputSpan.Length;
return false;
}
/// <summary>Determine whether <paramref name="inputSpan"/> at base.runtextpos is a match for the regular expression.</summary>
/// <param name="inputSpan">The text being scanned by the regular expression.</param>
/// <returns>true if the regular expression matches at the current position; otherwise, false.</returns>
private bool TryMatchAtCurrentPosition(ReadOnlySpan<char> inputSpan)
{
int pos = base.runtextpos;
int matchStart = pos;
int capture_starting_pos = 0;
int capture_starting_pos1 = 0;
ReadOnlySpan<char> slice = inputSpan.Slice(pos);
// Match the string "((".
if (!slice.StartsWith("(("))
{
UncaptureUntil(0);
return false; // The input didn't match.
}
// "cast" capture group.
{
pos += 2;
slice = inputSpan.Slice(pos);
capture_starting_pos = pos;
// Match a character other than ')' atomically at least once.
{
int iteration = slice.IndexOf(')');
if (iteration < 0)
{
iteration = slice.Length;
}
if (iteration == 0)
{
UncaptureUntil(0);
return false; // The input didn't match.
}
slice = slice.Slice(iteration);
pos += iteration;
}
base.Capture(1, capture_starting_pos, pos);
}
// Match ')'.
if (slice.IsEmpty || slice[0] != ')')
{
UncaptureUntil(0);
return false; // The input didn't match.
}
// "arg" capture group.
{
pos++;
slice = inputSpan.Slice(pos);
capture_starting_pos1 = pos;
// Match a character other than ')' atomically at least once.
{
int iteration1 = slice.IndexOf(')');
if (iteration1 < 0)
{
iteration1 = slice.Length;
}
if (iteration1 == 0)
{
UncaptureUntil(0);
return false; // The input didn't match.
}
slice = slice.Slice(iteration1);
pos += iteration1;
}
base.Capture(2, capture_starting_pos1, pos);
}
// Match ')'.
if (slice.IsEmpty || slice[0] != ')')
{
UncaptureUntil(0);
return false; // The input didn't match.
}
// The input matched.
pos++;
base.runtextpos = pos;
base.Capture(0, matchStart, pos);
return true;
// <summary>Undo captures until it reaches the specified capture position.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
void UncaptureUntil(int capturePosition)
{
while (base.Crawlpos() > capturePosition)
{
base.Uncapture();
}
}
}
}
}
}
/// <summary>Custom <see cref="Regex"/>-derived type for the EnsureArrayIndexRegex method.</summary>
[GeneratedCodeAttribute("System.Text.RegularExpressions.Generator", "11.0.14.26904")]
[SkipLocalsInit]
file sealed class EnsureArrayIndexRegex_5 : Regex
{
/// <summary>Cached, thread-safe singleton instance.</summary>
internal static readonly EnsureArrayIndexRegex_5 Instance = new();
/// <summary>Initializes the instance.</summary>
private EnsureArrayIndexRegex_5()
{
base.pattern = "(?<locA1>[^ ]+) = .+EnsureArrayIndex[(](?<locA2>[^,]+), (?<locI1>[^,]+),[^;]+;(?<locA3>[^[]+)[[](?<locI2>[^+]+)[+][+][]]";
base.roptions = RegexOptions.None;
ValidateMatchTimeout(Utilities.s_defaultTimeout);
base.internalMatchTimeout = Utilities.s_defaultTimeout;
base.factory = new RunnerFactory();
base.CapNames = new Hashtable { { "0", 0 } , { "locA1", 1 } , { "locA2", 2 } , { "locA3", 4 } , { "locI1", 3 } , { "locI2", 5 } };
base.capslist = new string[] {"0", "locA1", "locA2", "locI1", "locA3", "locI2" };
base.capsize = 6;
}
/// <summary>Provides a factory for creating <see cref="RegexRunner"/> instances to be used by methods on <see cref="Regex"/>.</summary>
private sealed class RunnerFactory : RegexRunnerFactory
{
/// <summary>Creates an instance of a <see cref="RegexRunner"/> used by methods on <see cref="Regex"/>.</summary>
protected override RegexRunner CreateInstance() => new Runner();
/// <summary>Provides the runner that contains the custom logic implementing the specified regular expression.</summary>
private sealed class Runner : RegexRunner
{
/// <summary>Scan the <paramref name="inputSpan"/> starting from base.runtextstart for the next match.</summary>
/// <param name="inputSpan">The text being scanned by the regular expression.</param>
protected override void Scan(ReadOnlySpan<char> inputSpan)
{
// Search until we can't find a valid starting position, we find a match, or we reach the end of the input.
while (TryFindNextPossibleStartingPosition(inputSpan) &&
!TryMatchAtCurrentPosition(inputSpan) &&
base.runtextpos != inputSpan.Length)
{
base.runtextpos++;
if (Utilities.s_hasTimeout)
{
base.CheckTimeout();
}
}
}
/// <summary>Search <paramref name="inputSpan"/> starting from base.runtextpos for the next location a match could possibly start.</summary>
/// <param name="inputSpan">The text being scanned by the regular expression.</param>
/// <returns>true if a possible match was found; false if no more matches are possible.</returns>
private bool TryFindNextPossibleStartingPosition(ReadOnlySpan<char> inputSpan)
{
int pos = base.runtextpos;
// Any possible match is at least 35 characters.
if (pos <= inputSpan.Length - 35)
{
// The pattern begins with a character in the set [^ ].
// Find the next occurrence. If it can't be found, there's no match.
int i = inputSpan.Slice(pos).IndexOfAnyExcept(' ');
if (i >= 0)
{
base.runtextpos = pos + i;
return true;
}
}
// No match found.
base.runtextpos = inputSpan.Length;
return false;
}
/// <summary>Determine whether <paramref name="inputSpan"/> at base.runtextpos is a match for the regular expression.</summary>
/// <param name="inputSpan">The text being scanned by the regular expression.</param>
/// <returns>true if the regular expression matches at the current position; otherwise, false.</returns>
private bool TryMatchAtCurrentPosition(ReadOnlySpan<char> inputSpan)
{
int pos = base.runtextpos;
int matchStart = pos;
int capture_starting_pos = 0;
int capture_starting_pos1 = 0;
int capture_starting_pos2 = 0;
int capture_starting_pos3 = 0;
int capture_starting_pos4 = 0;
int charloop_capture_pos = 0;
int charloop_starting_pos = 0, charloop_ending_pos = 0;
ReadOnlySpan<char> slice = inputSpan.Slice(pos);
// "locA1" capture group.
{
capture_starting_pos = pos;
// Match a character other than ' ' atomically at least once.
{
int iteration = slice.IndexOf(' ');
if (iteration < 0)
{
iteration = slice.Length;
}
if (iteration == 0)
{
UncaptureUntil(0);
return false; // The input didn't match.
}
slice = slice.Slice(iteration);
pos += iteration;
}
base.Capture(1, capture_starting_pos, pos);
}
// Match the string " = ".
if (!slice.StartsWith(" = "))
{
UncaptureUntil(0);
return false; // The input didn't match.
}
// Match a character other than '\n' greedily at least once.
//{
pos += 3;
slice = inputSpan.Slice(pos);
charloop_starting_pos = pos;
int iteration1 = slice.IndexOf('\n');
if (iteration1 < 0)
{
iteration1 = slice.Length;
}
if (iteration1 == 0)
{
UncaptureUntil(0);
return false; // The input didn't match.
}
slice = slice.Slice(iteration1);
pos += iteration1;
charloop_ending_pos = pos;
charloop_starting_pos++;
goto CharLoopEnd;
CharLoopBacktrack:
UncaptureUntil(charloop_capture_pos);
if (Utilities.s_hasTimeout)
{
base.CheckTimeout();
}
if (charloop_starting_pos >= charloop_ending_pos ||
(charloop_ending_pos = inputSpan.Slice(charloop_starting_pos, Math.Min(inputSpan.Length, charloop_ending_pos + 16) - charloop_starting_pos).LastIndexOf("EnsureArrayIndex(")) < 0)
{
UncaptureUntil(0);
return false; // The input didn't match.
}
charloop_ending_pos += charloop_starting_pos;
pos = charloop_ending_pos;
slice = inputSpan.Slice(pos);
CharLoopEnd:
charloop_capture_pos = base.Crawlpos();
//}
// Match the string "EnsureArrayIndex(".
if (!slice.StartsWith("EnsureArrayIndex("))
{
goto CharLoopBacktrack;
}
// "locA2" capture group.
{
pos += 17;
slice = inputSpan.Slice(pos);
capture_starting_pos1 = pos;
// Match a character other than ',' atomically at least once.
{
int iteration2 = slice.IndexOf(',');
if (iteration2 < 0)
{
iteration2 = slice.Length;
}
if (iteration2 == 0)
{
goto CharLoopBacktrack;
}
slice = slice.Slice(iteration2);
pos += iteration2;
}
base.Capture(2, capture_starting_pos1, pos);
}
// Match the string ", ".
if (!slice.StartsWith(", "))
{
goto CharLoopBacktrack;
}
// "locI1" capture group.
{
pos += 2;
slice = inputSpan.Slice(pos);
capture_starting_pos2 = pos;
// Match a character other than ',' atomically at least once.
{
int iteration3 = slice.IndexOf(',');
if (iteration3 < 0)
{
iteration3 = slice.Length;
}
if (iteration3 == 0)
{
goto CharLoopBacktrack;
}
slice = slice.Slice(iteration3);
pos += iteration3;
}
base.Capture(3, capture_starting_pos2, pos);
}
// Match ','.
if (slice.IsEmpty || slice[0] != ',')
{
goto CharLoopBacktrack;
}
// Match a character other than ';' atomically at least once.
{
int iteration4 = slice.Slice(1).IndexOf(';');
if (iteration4 < 0)
{
iteration4 = slice.Length - 1;
}
if (iteration4 == 0)
{
goto CharLoopBacktrack;
}
slice = slice.Slice(iteration4);
pos += iteration4;
}
// Match ';'.
if ((uint)slice.Length < 2 || slice[1] != ';')
{
goto CharLoopBacktrack;
}
// "locA3" capture group.
{
pos += 2;
slice = inputSpan.Slice(pos);
capture_starting_pos3 = pos;
// Match a character other than '[' atomically at least once.
{
int iteration5 = slice.IndexOf('[');
if (iteration5 < 0)
{
iteration5 = slice.Length;
}
if (iteration5 == 0)
{
goto CharLoopBacktrack;
}
slice = slice.Slice(iteration5);
pos += iteration5;
}
base.Capture(4, capture_starting_pos3, pos);
}
// Match '['.
if (slice.IsEmpty || slice[0] != '[')
{
goto CharLoopBacktrack;
}
// "locI2" capture group.
{
pos++;
slice = inputSpan.Slice(pos);
capture_starting_pos4 = pos;
// Match a character other than '+' atomically at least once.
{
int iteration6 = slice.IndexOf('+');
if (iteration6 < 0)
{
iteration6 = slice.Length;
}
if (iteration6 == 0)
{
goto CharLoopBacktrack;
}
slice = slice.Slice(iteration6);
pos += iteration6;
}
base.Capture(5, capture_starting_pos4, pos);
}
// Match the string "++]".
if (!slice.StartsWith("++]"))
{
goto CharLoopBacktrack;
}
// The input matched.
pos += 3;
base.runtextpos = pos;
base.Capture(0, matchStart, pos);
return true;
// <summary>Undo captures until it reaches the specified capture position.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
void UncaptureUntil(int capturePosition)
{
while (base.Crawlpos() > capturePosition)
{
base.Uncapture();
}
}
}
}
}
}
/// <summary>Custom <see cref="Regex"/>-derived type for the P0Regex method.</summary>
[GeneratedCodeAttribute("System.Text.RegularExpressions.Generator", "11.0.14.26904")]
[SkipLocalsInit]
file sealed class P0Regex_6 : Regex
{
/// <summary>Cached, thread-safe singleton instance.</summary>
internal static readonly P0Regex_6 Instance = new();
/// <summary>Initializes the instance.</summary>
private P0Regex_6()
{
base.pattern = "(?<a>[^[]+)[[](?<ia>.+)[]]";
base.roptions = RegexOptions.None;
ValidateMatchTimeout(Utilities.s_defaultTimeout);
base.internalMatchTimeout = Utilities.s_defaultTimeout;
base.factory = new RunnerFactory();
base.CapNames = new Hashtable { { "0", 0 } , { "a", 1 } , { "ia", 2 } };
base.capslist = new string[] {"0", "a", "ia" };
base.capsize = 3;
}
/// <summary>Provides a factory for creating <see cref="RegexRunner"/> instances to be used by methods on <see cref="Regex"/>.</summary>
private sealed class RunnerFactory : RegexRunnerFactory
{
/// <summary>Creates an instance of a <see cref="RegexRunner"/> used by methods on <see cref="Regex"/>.</summary>
protected override RegexRunner CreateInstance() => new Runner();
/// <summary>Provides the runner that contains the custom logic implementing the specified regular expression.</summary>
private sealed class Runner : RegexRunner
{
/// <summary>Scan the <paramref name="inputSpan"/> starting from base.runtextstart for the next match.</summary>
/// <param name="inputSpan">The text being scanned by the regular expression.</param>
protected override void Scan(ReadOnlySpan<char> inputSpan)
{
// Search until we can't find a valid starting position, we find a match, or we reach the end of the input.
while (TryFindNextPossibleStartingPosition(inputSpan) &&
!TryMatchAtCurrentPosition(inputSpan) &&
base.runtextpos != inputSpan.Length)
{
base.runtextpos++;
if (Utilities.s_hasTimeout)
{
base.CheckTimeout();
}
}
}
/// <summary>Search <paramref name="inputSpan"/> starting from base.runtextpos for the next location a match could possibly start.</summary>
/// <param name="inputSpan">The text being scanned by the regular expression.</param>
/// <returns>true if a possible match was found; false if no more matches are possible.</returns>
private bool TryFindNextPossibleStartingPosition(ReadOnlySpan<char> inputSpan)
{
int pos = base.runtextpos;
// Any possible match is at least 4 characters.
if (pos <= inputSpan.Length - 4)
{
// The pattern begins with a character in the set [^[].
// Find the next occurrence. If it can't be found, there's no match.
int i = inputSpan.Slice(pos).IndexOfAnyExcept('[');
if (i >= 0)
{
base.runtextpos = pos + i;
return true;
}
}
// No match found.
base.runtextpos = inputSpan.Length;
return false;
}
/// <summary>Determine whether <paramref name="inputSpan"/> at base.runtextpos is a match for the regular expression.</summary>
/// <param name="inputSpan">The text being scanned by the regular expression.</param>
/// <returns>true if the regular expression matches at the current position; otherwise, false.</returns>
private bool TryMatchAtCurrentPosition(ReadOnlySpan<char> inputSpan)
{
int pos = base.runtextpos;
int matchStart = pos;
int capture_starting_pos = 0;
int capture_starting_pos1 = 0;
int charloop_capture_pos = 0;
int charloop_starting_pos = 0, charloop_ending_pos = 0;
ReadOnlySpan<char> slice = inputSpan.Slice(pos);
// "a" capture group.
{
capture_starting_pos = pos;
// Match a character other than '[' atomically at least once.
{
int iteration = slice.IndexOf('[');
if (iteration < 0)
{
iteration = slice.Length;
}
if (iteration == 0)
{
UncaptureUntil(0);
return false; // The input didn't match.
}
slice = slice.Slice(iteration);
pos += iteration;
}
base.Capture(1, capture_starting_pos, pos);
}
// Match '['.
if (slice.IsEmpty || slice[0] != '[')
{
UncaptureUntil(0);
return false; // The input didn't match.
}
// "ia" capture group.
//{
pos++;
slice = inputSpan.Slice(pos);
capture_starting_pos1 = pos;
// Match a character other than '\n' greedily at least once.
//{
charloop_starting_pos = pos;
int iteration1 = slice.IndexOf('\n');
if (iteration1 < 0)
{
iteration1 = slice.Length;
}
if (iteration1 == 0)
{
UncaptureUntil(0);
return false; // The input didn't match.
}
slice = slice.Slice(iteration1);
pos += iteration1;
charloop_ending_pos = pos;
charloop_starting_pos++;
goto CharLoopEnd;
CharLoopBacktrack:
UncaptureUntil(charloop_capture_pos);
if (Utilities.s_hasTimeout)
{
base.CheckTimeout();
}
if (charloop_starting_pos >= charloop_ending_pos ||
(charloop_ending_pos = inputSpan.Slice(charloop_starting_pos, charloop_ending_pos - charloop_starting_pos).LastIndexOf(']')) < 0)
{
UncaptureUntil(0);
return false; // The input didn't match.
}
charloop_ending_pos += charloop_starting_pos;
pos = charloop_ending_pos;
slice = inputSpan.Slice(pos);
CharLoopEnd:
charloop_capture_pos = base.Crawlpos();
//}
base.Capture(2, capture_starting_pos1, pos);
goto CaptureSkipBacktrack;
CaptureBacktrack:
goto CharLoopBacktrack;
CaptureSkipBacktrack:;
//}
// Match ']'.
if (slice.IsEmpty || slice[0] != ']')
{
goto CaptureBacktrack;
}
// The input matched.
pos++;
base.runtextpos = pos;
base.Capture(0, matchStart, pos);
return true;
// <summary>Undo captures until it reaches the specified capture position.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
void UncaptureUntil(int capturePosition)
{
while (base.Crawlpos() > capturePosition)
{
base.Uncapture();
}
}
}
}
}
}
/// <summary>Custom <see cref="Regex"/>-derived type for the UnknownNodeNullAnyTypeRegex method.</summary>
[GeneratedCodeAttribute("System.Text.RegularExpressions.Generator", "11.0.14.26904")]
[SkipLocalsInit]
file sealed class UnknownNodeNullAnyTypeRegex_7 : Regex
{
/// <summary>Cached, thread-safe singleton instance.</summary>
internal static readonly UnknownNodeNullAnyTypeRegex_7 Instance = new();
/// <summary>Initializes the instance.</summary>
private UnknownNodeNullAnyTypeRegex_7()
{
base.pattern = "UnknownNode[(]null, @[\"](?<qnames>[^\"]*)[\"][)];";
base.roptions = RegexOptions.None;
ValidateMatchTimeout(Utilities.s_defaultTimeout);
base.internalMatchTimeout = Utilities.s_defaultTimeout;
base.factory = new RunnerFactory();
base.CapNames = new Hashtable { { "0", 0 } , { "qnames", 1 } };
base.capslist = new string[] {"0", "qnames" };
base.capsize = 2;
}
/// <summary>Provides a factory for creating <see cref="RegexRunner"/> instances to be used by methods on <see cref="Regex"/>.</summary>
private sealed class RunnerFactory : RegexRunnerFactory
{
/// <summary>Creates an instance of a <see cref="RegexRunner"/> used by methods on <see cref="Regex"/>.</summary>
protected override RegexRunner CreateInstance() => new Runner();
/// <summary>Provides the runner that contains the custom logic implementing the specified regular expression.</summary>
private sealed class Runner : RegexRunner
{
/// <summary>Scan the <paramref name="inputSpan"/> starting from base.runtextstart for the next match.</summary>
/// <param name="inputSpan">The text being scanned by the regular expression.</param>
protected override void Scan(ReadOnlySpan<char> inputSpan)
{
// Search until we can't find a valid starting position, we find a match, or we reach the end of the input.
while (TryFindNextPossibleStartingPosition(inputSpan) &&
!TryMatchAtCurrentPosition(inputSpan) &&
base.runtextpos != inputSpan.Length)
{
base.runtextpos++;
if (Utilities.s_hasTimeout)
{
base.CheckTimeout();
}
}
}
/// <summary>Search <paramref name="inputSpan"/> starting from base.runtextpos for the next location a match could possibly start.</summary>
/// <param name="inputSpan">The text being scanned by the regular expression.</param>
/// <returns>true if a possible match was found; false if no more matches are possible.</returns>
private bool TryFindNextPossibleStartingPosition(ReadOnlySpan<char> inputSpan)
{
int pos = base.runtextpos;
// Any possible match is at least 23 characters.
if (pos <= inputSpan.Length - 23)
{
// The pattern has the literal "UnknownNode(null, @\"" at the beginning of the pattern. Find the next occurrence.
// If it can't be found, there's no match.
int i = inputSpan.Slice(pos).IndexOfAny(Utilities.s_indexOfString_A33692426CD23EBB54EC2CE470CB74EA3BB2120AA9FB6C85181C764DD117847E);
if (i >= 0)
{
base.runtextpos = pos + i;
return true;
}
}
// No match found.
base.runtextpos = inputSpan.Length;
return false;
}
/// <summary>Determine whether <paramref name="inputSpan"/> at base.runtextpos is a match for the regular expression.</summary>
/// <param name="inputSpan">The text being scanned by the regular expression.</param>
/// <returns>true if the regular expression matches at the current position; otherwise, false.</returns>
private bool TryMatchAtCurrentPosition(ReadOnlySpan<char> inputSpan)
{
int pos = base.runtextpos;
int matchStart = pos;
int capture_starting_pos = 0;
ReadOnlySpan<char> slice = inputSpan.Slice(pos);
// Match the string "UnknownNode(null, @\"".
if (!slice.StartsWith("UnknownNode(null, @\""))
{
UncaptureUntil(0);
return false; // The input didn't match.
}
// "qnames" capture group.
{
pos += 20;
slice = inputSpan.Slice(pos);
capture_starting_pos = pos;
// Match a character other than '"' atomically any number of times.
{
int iteration = slice.IndexOf('"');
if (iteration < 0)
{
iteration = slice.Length;
}
slice = slice.Slice(iteration);
pos += iteration;
}
base.Capture(1, capture_starting_pos, pos);
}
// Match the string "\");".
if (!slice.StartsWith("\");"))
{
UncaptureUntil(0);
return false; // The input didn't match.
}
// The input matched.
pos += 3;
base.runtextpos = pos;
base.Capture(0, matchStart, pos);
return true;
// <summary>Undo captures until it reaches the specified capture position.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
void UncaptureUntil(int capturePosition)
{
while (base.Crawlpos() > capturePosition)
{
base.Uncapture();
}
}
}
}
}
}
/// <summary>Custom <see cref="Regex"/>-derived type for the UnknownNodeObjectEmptyRegex method.</summary>
[GeneratedCodeAttribute("System.Text.RegularExpressions.Generator", "11.0.14.26904")]
[SkipLocalsInit]
file sealed class UnknownNodeObjectEmptyRegex_8 : Regex
{
/// <summary>Cached, thread-safe singleton instance.</summary>
internal static readonly UnknownNodeObjectEmptyRegex_8 Instance = new();
/// <summary>Initializes the instance.</summary>
private UnknownNodeObjectEmptyRegex_8()
{
base.pattern = "UnknownNode[(][(]object[)](?<o>[^,]+), @[\"](?<qnames>[^\"]*)[\"][)];";
base.roptions = RegexOptions.None;
ValidateMatchTimeout(Utilities.s_defaultTimeout);
base.internalMatchTimeout = Utilities.s_defaultTimeout;
base.factory = new RunnerFactory();
base.CapNames = new Hashtable { { "0", 0 } , { "o", 1 } , { "qnames", 2 } };
base.capslist = new string[] {"0", "o", "qnames" };
base.capsize = 3;
}
/// <summary>Provides a factory for creating <see cref="RegexRunner"/> instances to be used by methods on <see cref="Regex"/>.</summary>
private sealed class RunnerFactory : RegexRunnerFactory
{
/// <summary>Creates an instance of a <see cref="RegexRunner"/> used by methods on <see cref="Regex"/>.</summary>
protected override RegexRunner CreateInstance() => new Runner();
/// <summary>Provides the runner that contains the custom logic implementing the specified regular expression.</summary>
private sealed class Runner : RegexRunner
{
/// <summary>Scan the <paramref name="inputSpan"/> starting from base.runtextstart for the next match.</summary>
/// <param name="inputSpan">The text being scanned by the regular expression.</param>
protected override void Scan(ReadOnlySpan<char> inputSpan)
{
// Search until we can't find a valid starting position, we find a match, or we reach the end of the input.
while (TryFindNextPossibleStartingPosition(inputSpan) &&
!TryMatchAtCurrentPosition(inputSpan) &&
base.runtextpos != inputSpan.Length)
{
base.runtextpos++;
if (Utilities.s_hasTimeout)
{
base.CheckTimeout();
}
}
}
/// <summary>Search <paramref name="inputSpan"/> starting from base.runtextpos for the next location a match could possibly start.</summary>
/// <param name="inputSpan">The text being scanned by the regular expression.</param>
/// <returns>true if a possible match was found; false if no more matches are possible.</returns>
private bool TryFindNextPossibleStartingPosition(ReadOnlySpan<char> inputSpan)
{
int pos = base.runtextpos;
// Any possible match is at least 28 characters.
if (pos <= inputSpan.Length - 28)
{
// The pattern has the literal "UnknownNode((object)" at the beginning of the pattern. Find the next occurrence.
// If it can't be found, there's no match.
int i = inputSpan.Slice(pos).IndexOfAny(Utilities.s_indexOfString_49E5939642BED022FF4CCC68711C353694EC5E15398AE4B384C29A17BD819BDF);
if (i >= 0)
{
base.runtextpos = pos + i;
return true;
}
}
// No match found.
base.runtextpos = inputSpan.Length;
return false;
}
/// <summary>Determine whether <paramref name="inputSpan"/> at base.runtextpos is a match for the regular expression.</summary>
/// <param name="inputSpan">The text being scanned by the regular expression.</param>
/// <returns>true if the regular expression matches at the current position; otherwise, false.</returns>
private bool TryMatchAtCurrentPosition(ReadOnlySpan<char> inputSpan)
{
int pos = base.runtextpos;
int matchStart = pos;
int capture_starting_pos = 0;
int capture_starting_pos1 = 0;
ReadOnlySpan<char> slice = inputSpan.Slice(pos);
// Match the string "UnknownNode((object)".
if (!slice.StartsWith("UnknownNode((object)"))
{
UncaptureUntil(0);
return false; // The input didn't match.
}
// "o" capture group.
{
pos += 20;
slice = inputSpan.Slice(pos);
capture_starting_pos = pos;
// Match a character other than ',' atomically at least once.
{
int iteration = slice.IndexOf(',');
if (iteration < 0)
{
iteration = slice.Length;
}
if (iteration == 0)
{
UncaptureUntil(0);
return false; // The input didn't match.
}
slice = slice.Slice(iteration);
pos += iteration;
}
base.Capture(1, capture_starting_pos, pos);
}
// Match the string ", @\"".
if (!slice.StartsWith(", @\""))
{
UncaptureUntil(0);
return false; // The input didn't match.
}
// "qnames" capture group.
{
pos += 4;
slice = inputSpan.Slice(pos);
capture_starting_pos1 = pos;
// Match a character other than '"' atomically any number of times.
{
int iteration1 = slice.IndexOf('"');
if (iteration1 < 0)
{
iteration1 = slice.Length;
}
slice = slice.Slice(iteration1);
pos += iteration1;
}
base.Capture(2, capture_starting_pos1, pos);
}
// Match the string "\");".
if (!slice.StartsWith("\");"))
{
UncaptureUntil(0);
return false; // The input didn't match.
}
// The input matched.
pos += 3;
base.runtextpos = pos;
base.Capture(0, matchStart, pos);
return true;
// <summary>Undo captures until it reaches the specified capture position.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
void UncaptureUntil(int capturePosition)
{
while (base.Crawlpos() > capturePosition)
{
base.Uncapture();
}
}
}
}
}
}
/// <summary>Custom <see cref="Regex"/>-derived type for the UnknownNodeObjectNullRegex method.</summary>
[GeneratedCodeAttribute("System.Text.RegularExpressions.Generator", "11.0.14.26904")]
[SkipLocalsInit]
file sealed class UnknownNodeObjectNullRegex_9 : Regex
{
/// <summary>Cached, thread-safe singleton instance.</summary>
internal static readonly UnknownNodeObjectNullRegex_9 Instance = new();
/// <summary>Initializes the instance.</summary>
private UnknownNodeObjectNullRegex_9()
{
base.pattern = "UnknownNode[(][(]object[)](?<o>[^,]+), null[)];";
base.roptions = RegexOptions.None;
ValidateMatchTimeout(Utilities.s_defaultTimeout);
base.internalMatchTimeout = Utilities.s_defaultTimeout;
base.factory = new RunnerFactory();
base.CapNames = new Hashtable { { "0", 0 } , { "o", 1 } };
base.capslist = new string[] {"0", "o" };
base.capsize = 2;
}
/// <summary>Provides a factory for creating <see cref="RegexRunner"/> instances to be used by methods on <see cref="Regex"/>.</summary>
private sealed class RunnerFactory : RegexRunnerFactory
{
/// <summary>Creates an instance of a <see cref="RegexRunner"/> used by methods on <see cref="Regex"/>.</summary>
protected override RegexRunner CreateInstance() => new Runner();
/// <summary>Provides the runner that contains the custom logic implementing the specified regular expression.</summary>
private sealed class Runner : RegexRunner
{
/// <summary>Scan the <paramref name="inputSpan"/> starting from base.runtextstart for the next match.</summary>
/// <param name="inputSpan">The text being scanned by the regular expression.</param>
protected override void Scan(ReadOnlySpan<char> inputSpan)
{
// Search until we can't find a valid starting position, we find a match, or we reach the end of the input.
while (TryFindNextPossibleStartingPosition(inputSpan) &&
!TryMatchAtCurrentPosition(inputSpan) &&
base.runtextpos != inputSpan.Length)
{
base.runtextpos++;
if (Utilities.s_hasTimeout)
{
base.CheckTimeout();
}
}
}
/// <summary>Search <paramref name="inputSpan"/> starting from base.runtextpos for the next location a match could possibly start.</summary>
/// <param name="inputSpan">The text being scanned by the regular expression.</param>
/// <returns>true if a possible match was found; false if no more matches are possible.</returns>
private bool TryFindNextPossibleStartingPosition(ReadOnlySpan<char> inputSpan)
{
int pos = base.runtextpos;
// Any possible match is at least 29 characters.
if (pos <= inputSpan.Length - 29)
{
// The pattern has the literal "UnknownNode((object)" at the beginning of the pattern. Find the next occurrence.
// If it can't be found, there's no match.
int i = inputSpan.Slice(pos).IndexOfAny(Utilities.s_indexOfString_49E5939642BED022FF4CCC68711C353694EC5E15398AE4B384C29A17BD819BDF);
if (i >= 0)
{
base.runtextpos = pos + i;
return true;
}
}
// No match found.
base.runtextpos = inputSpan.Length;
return false;
}
/// <summary>Determine whether <paramref name="inputSpan"/> at base.runtextpos is a match for the regular expression.</summary>
/// <param name="inputSpan">The text being scanned by the regular expression.</param>
/// <returns>true if the regular expression matches at the current position; otherwise, false.</returns>
private bool TryMatchAtCurrentPosition(ReadOnlySpan<char> inputSpan)
{
int pos = base.runtextpos;
int matchStart = pos;
int capture_starting_pos = 0;
ReadOnlySpan<char> slice = inputSpan.Slice(pos);
// Match the string "UnknownNode((object)".
if (!slice.StartsWith("UnknownNode((object)"))
{
UncaptureUntil(0);
return false; // The input didn't match.
}
// "o" capture group.
{
pos += 20;
slice = inputSpan.Slice(pos);
capture_starting_pos = pos;
// Match a character other than ',' atomically at least once.
{
int iteration = slice.IndexOf(',');
if (iteration < 0)
{
iteration = slice.Length;
}
if (iteration == 0)
{
UncaptureUntil(0);
return false; // The input didn't match.
}
slice = slice.Slice(iteration);
pos += iteration;
}
base.Capture(1, capture_starting_pos, pos);
}
// Match the string ", null);".
if (!slice.StartsWith(", null);"))
{
UncaptureUntil(0);
return false; // The input didn't match.
}
// The input matched.
pos += 8;
base.runtextpos = pos;
base.Capture(0, matchStart, pos);
return true;
// <summary>Undo captures until it reaches the specified capture position.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
void UncaptureUntil(int capturePosition)
{
while (base.Crawlpos() > capturePosition)
{
base.Uncapture();
}
}
}
}
}
}
/// <summary>Custom <see cref="Regex"/>-derived type for the UnknownNodeObjectRegex method.</summary>
[GeneratedCodeAttribute("System.Text.RegularExpressions.Generator", "11.0.14.26904")]
[SkipLocalsInit]
file sealed class UnknownNodeObjectRegex_10 : Regex
{
/// <summary>Cached, thread-safe singleton instance.</summary>
internal static readonly UnknownNodeObjectRegex_10 Instance = new();
/// <summary>Initializes the instance.</summary>
private UnknownNodeObjectRegex_10()
{
base.pattern = "UnknownNode[(][(]object[)](?<o>[^)]+)[)];";
base.roptions = RegexOptions.None;
ValidateMatchTimeout(Utilities.s_defaultTimeout);
base.internalMatchTimeout = Utilities.s_defaultTimeout;
base.factory = new RunnerFactory();
base.CapNames = new Hashtable { { "0", 0 } , { "o", 1 } };
base.capslist = new string[] {"0", "o" };
base.capsize = 2;
}
/// <summary>Provides a factory for creating <see cref="RegexRunner"/> instances to be used by methods on <see cref="Regex"/>.</summary>
private sealed class RunnerFactory : RegexRunnerFactory
{
/// <summary>Creates an instance of a <see cref="RegexRunner"/> used by methods on <see cref="Regex"/>.</summary>
protected override RegexRunner CreateInstance() => new Runner();
/// <summary>Provides the runner that contains the custom logic implementing the specified regular expression.</summary>
private sealed class Runner : RegexRunner
{
/// <summary>Scan the <paramref name="inputSpan"/> starting from base.runtextstart for the next match.</summary>
/// <param name="inputSpan">The text being scanned by the regular expression.</param>
protected override void Scan(ReadOnlySpan<char> inputSpan)
{
// Search until we can't find a valid starting position, we find a match, or we reach the end of the input.
while (TryFindNextPossibleStartingPosition(inputSpan) &&
!TryMatchAtCurrentPosition(inputSpan) &&
base.runtextpos != inputSpan.Length)
{
base.runtextpos++;
if (Utilities.s_hasTimeout)
{
base.CheckTimeout();
}
}
}
/// <summary>Search <paramref name="inputSpan"/> starting from base.runtextpos for the next location a match could possibly start.</summary>
/// <param name="inputSpan">The text being scanned by the regular expression.</param>
/// <returns>true if a possible match was found; false if no more matches are possible.</returns>
private bool TryFindNextPossibleStartingPosition(ReadOnlySpan<char> inputSpan)
{
int pos = base.runtextpos;
// Any possible match is at least 23 characters.
if (pos <= inputSpan.Length - 23)
{
// The pattern has the literal "UnknownNode((object)" at the beginning of the pattern. Find the next occurrence.
// If it can't be found, there's no match.
int i = inputSpan.Slice(pos).IndexOfAny(Utilities.s_indexOfString_49E5939642BED022FF4CCC68711C353694EC5E15398AE4B384C29A17BD819BDF);
if (i >= 0)
{
base.runtextpos = pos + i;
return true;
}
}
// No match found.
base.runtextpos = inputSpan.Length;
return false;
}
/// <summary>Determine whether <paramref name="inputSpan"/> at base.runtextpos is a match for the regular expression.</summary>
/// <param name="inputSpan">The text being scanned by the regular expression.</param>
/// <returns>true if the regular expression matches at the current position; otherwise, false.</returns>
private bool TryMatchAtCurrentPosition(ReadOnlySpan<char> inputSpan)
{
int pos = base.runtextpos;
int matchStart = pos;
int capture_starting_pos = 0;
ReadOnlySpan<char> slice = inputSpan.Slice(pos);
// Match the string "UnknownNode((object)".
if (!slice.StartsWith("UnknownNode((object)"))
{
UncaptureUntil(0);
return false; // The input didn't match.
}
// "o" capture group.
{
pos += 20;
slice = inputSpan.Slice(pos);
capture_starting_pos = pos;
// Match a character other than ')' atomically at least once.
{
int iteration = slice.IndexOf(')');
if (iteration < 0)
{
iteration = slice.Length;
}
if (iteration == 0)
{
UncaptureUntil(0);
return false; // The input didn't match.
}
slice = slice.Slice(iteration);
pos += iteration;
}
base.Capture(1, capture_starting_pos, pos);
}
// Match the string ");".
if (!slice.StartsWith(");"))
{
UncaptureUntil(0);
return false; // The input didn't match.
}
// The input matched.
pos += 2;
base.runtextpos = pos;
base.Capture(0, matchStart, pos);
return true;
// <summary>Undo captures until it reaches the specified capture position.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
void UncaptureUntil(int capturePosition)
{
while (base.Crawlpos() > capturePosition)
{
base.Uncapture();
}
}
}
}
}
}
/// <summary>Custom <see cref="Regex"/>-derived type for the ParamsReadRegex method.</summary>
[GeneratedCodeAttribute("System.Text.RegularExpressions.Generator", "11.0.14.26904")]
[SkipLocalsInit]
file sealed class ParamsReadRegex_11 : Regex
{
/// <summary>Cached, thread-safe singleton instance.</summary>
internal static readonly ParamsReadRegex_11 Instance = new();
/// <summary>Initializes the instance.</summary>
private ParamsReadRegex_11()
{
base.pattern = "paramsRead\\[(?<index>[0-9]+)\\]";
base.roptions = RegexOptions.None;
ValidateMatchTimeout(Utilities.s_defaultTimeout);
base.internalMatchTimeout = Utilities.s_defaultTimeout;
base.factory = new RunnerFactory();
base.CapNames = new Hashtable { { "0", 0 } , { "index", 1 } };
base.capslist = new string[] {"0", "index" };
base.capsize = 2;
}
/// <summary>Provides a factory for creating <see cref="RegexRunner"/> instances to be used by methods on <see cref="Regex"/>.</summary>
private sealed class RunnerFactory : RegexRunnerFactory
{
/// <summary>Creates an instance of a <see cref="RegexRunner"/> used by methods on <see cref="Regex"/>.</summary>
protected override RegexRunner CreateInstance() => new Runner();
/// <summary>Provides the runner that contains the custom logic implementing the specified regular expression.</summary>
private sealed class Runner : RegexRunner
{
/// <summary>Scan the <paramref name="inputSpan"/> starting from base.runtextstart for the next match.</summary>
/// <param name="inputSpan">The text being scanned by the regular expression.</param>
protected override void Scan(ReadOnlySpan<char> inputSpan)
{
// Search until we can't find a valid starting position, we find a match, or we reach the end of the input.
while (TryFindNextPossibleStartingPosition(inputSpan) &&
!TryMatchAtCurrentPosition(inputSpan) &&
base.runtextpos != inputSpan.Length)
{
base.runtextpos++;
if (Utilities.s_hasTimeout)
{
base.CheckTimeout();
}
}
}
/// <summary>Search <paramref name="inputSpan"/> starting from base.runtextpos for the next location a match could possibly start.</summary>
/// <param name="inputSpan">The text being scanned by the regular expression.</param>
/// <returns>true if a possible match was found; false if no more matches are possible.</returns>
private bool TryFindNextPossibleStartingPosition(ReadOnlySpan<char> inputSpan)
{
int pos = base.runtextpos;
// Any possible match is at least 13 characters.
if (pos <= inputSpan.Length - 13)
{
// The pattern has the literal "paramsRead[" at the beginning of the pattern. Find the next occurrence.
// If it can't be found, there's no match.
int i = inputSpan.Slice(pos).IndexOfAny(Utilities.s_indexOfString_24E3F0A96FA8DE99FB25D242D87DAC774B6CA6628023D99447766181AE8B5C1F);
if (i >= 0)
{
base.runtextpos = pos + i;
return true;
}
}
// No match found.
base.runtextpos = inputSpan.Length;
return false;
}
/// <summary>Determine whether <paramref name="inputSpan"/> at base.runtextpos is a match for the regular expression.</summary>
/// <param name="inputSpan">The text being scanned by the regular expression.</param>
/// <returns>true if the regular expression matches at the current position; otherwise, false.</returns>
private bool TryMatchAtCurrentPosition(ReadOnlySpan<char> inputSpan)
{
int pos = base.runtextpos;
int matchStart = pos;
int capture_starting_pos = 0;
ReadOnlySpan<char> slice = inputSpan.Slice(pos);
// Match the string "paramsRead[".
if (!slice.StartsWith("paramsRead["))
{
UncaptureUntil(0);
return false; // The input didn't match.
}
// "index" capture group.
{
pos += 11;
slice = inputSpan.Slice(pos);
capture_starting_pos = pos;
// Match a character in the set [0-9] atomically at least once.
{
int iteration = slice.IndexOfAnyExceptInRange('0', '9');
if (iteration < 0)
{
iteration = slice.Length;
}
if (iteration == 0)
{
UncaptureUntil(0);
return false; // The input didn't match.
}
slice = slice.Slice(iteration);
pos += iteration;
}
base.Capture(1, capture_starting_pos, pos);
}
// Match ']'.
if (slice.IsEmpty || slice[0] != ']')
{
UncaptureUntil(0);
return false; // The input didn't match.
}
// The input matched.
pos++;
base.runtextpos = pos;
base.Capture(0, matchStart, pos);
return true;
// <summary>Undo captures until it reaches the specified capture position.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
void UncaptureUntil(int capturePosition)
{
while (base.Crawlpos() > capturePosition)
{
base.Uncapture();
}
}
}
}
}
}
/// <summary>Helper methods used by generated <see cref="Regex"/>-derived implementations.</summary>
[GeneratedCodeAttribute("System.Text.RegularExpressions.Generator", "11.0.14.26904")]
file static class Utilities
{
/// <summary>Default timeout value set in <see cref="AppContext"/>, or <see cref="Regex.InfiniteMatchTimeout"/> if none was set.</summary>
internal static readonly TimeSpan s_defaultTimeout = AppContext.GetData("REGEX_DEFAULT_MATCH_TIMEOUT") is TimeSpan timeout ? timeout : Regex.InfiniteMatchTimeout;
/// <summary>Whether <see cref="s_defaultTimeout"/> is non-infinite.</summary>
internal static readonly bool s_hasTimeout = s_defaultTimeout != Regex.InfiniteMatchTimeout;
/// <summary>Pushes 1 value onto the backtracking stack.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static void StackPush(ref int[] stack, ref int pos, int arg0)
{
// If there's space available for the value, store it.
int[] s = stack;
int p = pos;
if ((uint)p < (uint)s.Length)
{
s[p] = arg0;
pos++;
return;
}
// Otherwise, resize the stack to make room and try again.
WithResize(ref stack, ref pos, arg0);
// <summary>Resize the backtracking stack array and push 1 value onto the stack.</summary>
[MethodImpl(MethodImplOptions.NoInlining)]
static void WithResize(ref int[] stack, ref int pos, int arg0)
{
Array.Resize(ref stack, (pos + 0) * 2);
StackPush(ref stack, ref pos, arg0);
}
}
/// <summary>Pushes 2 values onto the backtracking stack.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static void StackPush(ref int[] stack, ref int pos, int arg0, int arg1)
{
// If there's space available for all 2 values, store them.
int[] s = stack;
int p = pos;
if ((uint)(p + 1) < (uint)s.Length)
{
s[p] = arg0;
s[p + 1] = arg1;
pos += 2;
return;
}
// Otherwise, resize the stack to make room and try again.
WithResize(ref stack, ref pos, arg0, arg1);
// <summary>Resize the backtracking stack array and push 2 values onto the stack.</summary>
[MethodImpl(MethodImplOptions.NoInlining)]
static void WithResize(ref int[] stack, ref int pos, int arg0, int arg1)
{
Array.Resize(ref stack, (pos + 1) * 2);
StackPush(ref stack, ref pos, arg0, arg1);
}
}
/// <summary>Supports searching for the string "paramsRead[".</summary>
internal static readonly SearchValues<string> s_indexOfString_24E3F0A96FA8DE99FB25D242D87DAC774B6CA6628023D99447766181AE8B5C1F = SearchValues.Create(["paramsRead["], StringComparison.Ordinal);
/// <summary>Supports searching for the string "UnknownNode((object)".</summary>
internal static readonly SearchValues<string> s_indexOfString_49E5939642BED022FF4CCC68711C353694EC5E15398AE4B384C29A17BD819BDF = SearchValues.Create(["UnknownNode((object)"], StringComparison.Ordinal);
/// <summary>Supports searching for the string "UnknownNode(null, @\"".</summary>
internal static readonly SearchValues<string> s_indexOfString_A33692426CD23EBB54EC2CE470CB74EA3BB2120AA9FB6C85181C764DD117847E = SearchValues.Create(["UnknownNode(null, @\""], StringComparison.Ordinal);
/// <summary>Supports searching for the string "((".</summary>
internal static readonly SearchValues<string> s_indexOfString_C94AE607B1711C3F90CF8B8C224548ED74A865FE986797F62276464CE6F9271D = SearchValues.Create(["(("], StringComparison.Ordinal);
/// <summary>Supports searching for the string "_x".</summary>
internal static readonly SearchValues<string> s_indexOfString__x_OrdinalIgnoreCase = SearchValues.Create(["_x"], StringComparison.OrdinalIgnoreCase);
}
}
|