scripts
This commit is contained in:
niko
@@ -0,0 +1,1519 @@
|
||||
using System;
|
||||
using System.Collections;
|
||||
using System.Globalization;
|
||||
|
||||
namespace System.Text.RegularExpressions.Syntax
|
||||
{
|
||||
// Token: 0x020002D5 RID: 725
|
||||
internal class Parser
|
||||
{
|
||||
// Token: 0x06001A61 RID: 6753 RVA: 0x0005F7D0 File Offset: 0x0005D9D0
|
||||
public Parser()
|
||||
{
|
||||
this.caps = new ArrayList();
|
||||
this.refs = new Hashtable();
|
||||
}
|
||||
|
||||
// Token: 0x06001A62 RID: 6754 RVA: 0x0005F7F0 File Offset: 0x0005D9F0
|
||||
public static int ParseDecimal(string str, ref int ptr)
|
||||
{
|
||||
return Parser.ParseNumber(str, ref ptr, 10, 1, int.MaxValue);
|
||||
}
|
||||
|
||||
// Token: 0x06001A63 RID: 6755 RVA: 0x0005F804 File Offset: 0x0005DA04
|
||||
public static int ParseOctal(string str, ref int ptr)
|
||||
{
|
||||
return Parser.ParseNumber(str, ref ptr, 8, 1, 3);
|
||||
}
|
||||
|
||||
// Token: 0x06001A64 RID: 6756 RVA: 0x0005F810 File Offset: 0x0005DA10
|
||||
public static int ParseHex(string str, ref int ptr, int digits)
|
||||
{
|
||||
return Parser.ParseNumber(str, ref ptr, 16, digits, digits);
|
||||
}
|
||||
|
||||
// Token: 0x06001A65 RID: 6757 RVA: 0x0005F820 File Offset: 0x0005DA20
|
||||
public static int ParseNumber(string str, ref int ptr, int b, int min, int max)
|
||||
{
|
||||
int num = ptr;
|
||||
int num2 = 0;
|
||||
int num3 = 0;
|
||||
if (max < min)
|
||||
{
|
||||
max = int.MaxValue;
|
||||
}
|
||||
while (num3 < max && num < str.Length)
|
||||
{
|
||||
int num4 = Parser.ParseDigit(str[num++], b, num3);
|
||||
if (num4 < 0)
|
||||
{
|
||||
num--;
|
||||
break;
|
||||
}
|
||||
num2 = num2 * b + num4;
|
||||
num3++;
|
||||
}
|
||||
if (num3 < min)
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
ptr = num;
|
||||
return num2;
|
||||
}
|
||||
|
||||
// Token: 0x06001A66 RID: 6758 RVA: 0x0005F898 File Offset: 0x0005DA98
|
||||
public static string ParseName(string str, ref int ptr)
|
||||
{
|
||||
if (char.IsDigit(str[ptr]))
|
||||
{
|
||||
int num = Parser.ParseNumber(str, ref ptr, 10, 1, 0);
|
||||
if (num > 0)
|
||||
{
|
||||
return num.ToString();
|
||||
}
|
||||
return null;
|
||||
}
|
||||
else
|
||||
{
|
||||
int num2 = ptr;
|
||||
while (Parser.IsNameChar(str[ptr]))
|
||||
{
|
||||
ptr++;
|
||||
}
|
||||
if (ptr - num2 > 0)
|
||||
{
|
||||
return str.Substring(num2, ptr - num2);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x06001A67 RID: 6759 RVA: 0x0005F918 File Offset: 0x0005DB18
|
||||
public static string Escape(string str)
|
||||
{
|
||||
string text = string.Empty;
|
||||
int i = 0;
|
||||
while (i < str.Length)
|
||||
{
|
||||
char c = str[i];
|
||||
char c2 = c;
|
||||
switch (c2)
|
||||
{
|
||||
case ' ':
|
||||
case '#':
|
||||
case '$':
|
||||
case '(':
|
||||
case ')':
|
||||
case '*':
|
||||
case '+':
|
||||
case '.':
|
||||
goto IL_AF;
|
||||
default:
|
||||
switch (c2)
|
||||
{
|
||||
case '\t':
|
||||
text += "\\t";
|
||||
break;
|
||||
case '\n':
|
||||
text += "\\n";
|
||||
break;
|
||||
default:
|
||||
switch (c2)
|
||||
{
|
||||
case '[':
|
||||
case '\\':
|
||||
case '^':
|
||||
goto IL_AF;
|
||||
default:
|
||||
if (c2 == '{' || c2 == '|' || c2 == '?')
|
||||
{
|
||||
goto IL_AF;
|
||||
}
|
||||
text += c;
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case '\f':
|
||||
text += "\\f";
|
||||
break;
|
||||
case '\r':
|
||||
text += "\\r";
|
||||
break;
|
||||
}
|
||||
break;
|
||||
}
|
||||
IL_11C:
|
||||
i++;
|
||||
continue;
|
||||
IL_AF:
|
||||
text = text + "\\" + c;
|
||||
goto IL_11C;
|
||||
}
|
||||
return text;
|
||||
}
|
||||
|
||||
// Token: 0x06001A68 RID: 6760 RVA: 0x0005FA54 File Offset: 0x0005DC54
|
||||
public static string Unescape(string str)
|
||||
{
|
||||
if (str.IndexOf('\\') == -1)
|
||||
{
|
||||
return str;
|
||||
}
|
||||
return new Parser().ParseString(str);
|
||||
}
|
||||
|
||||
// Token: 0x06001A69 RID: 6761 RVA: 0x0005FA74 File Offset: 0x0005DC74
|
||||
public RegularExpression ParseRegularExpression(string pattern, RegexOptions options)
|
||||
{
|
||||
this.pattern = pattern;
|
||||
this.ptr = 0;
|
||||
this.caps.Clear();
|
||||
this.refs.Clear();
|
||||
this.num_groups = 0;
|
||||
RegularExpression regularExpression2;
|
||||
try
|
||||
{
|
||||
RegularExpression regularExpression = new RegularExpression();
|
||||
this.ParseGroup(regularExpression, options, null);
|
||||
this.ResolveReferences();
|
||||
regularExpression.GroupCount = this.num_groups;
|
||||
regularExpression2 = regularExpression;
|
||||
}
|
||||
catch (IndexOutOfRangeException)
|
||||
{
|
||||
throw this.NewParseException("Unexpected end of pattern.");
|
||||
}
|
||||
return regularExpression2;
|
||||
}
|
||||
|
||||
// Token: 0x06001A6A RID: 6762 RVA: 0x0005FB08 File Offset: 0x0005DD08
|
||||
public int GetMapping(Hashtable mapping)
|
||||
{
|
||||
int count = this.caps.Count;
|
||||
mapping.Add("0", 0);
|
||||
for (int i = 0; i < count; i++)
|
||||
{
|
||||
CapturingGroup capturingGroup = (CapturingGroup)this.caps[i];
|
||||
string text = ((capturingGroup.Name == null) ? capturingGroup.Index.ToString() : capturingGroup.Name);
|
||||
if (mapping.Contains(text))
|
||||
{
|
||||
if ((int)mapping[text] != capturingGroup.Index)
|
||||
{
|
||||
throw new SystemException("invalid state");
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
mapping.Add(text, capturingGroup.Index);
|
||||
}
|
||||
}
|
||||
return this.gap;
|
||||
}
|
||||
|
||||
// Token: 0x06001A6B RID: 6763 RVA: 0x0005FBC8 File Offset: 0x0005DDC8
|
||||
private void ParseGroup(Group group, RegexOptions options, Assertion assertion)
|
||||
{
|
||||
bool flag = group is RegularExpression;
|
||||
Alternation alternation = null;
|
||||
string text = null;
|
||||
Group group2 = new Group();
|
||||
Expression expression = null;
|
||||
bool flag2 = false;
|
||||
do
|
||||
{
|
||||
this.ConsumeWhitespace(Parser.IsIgnorePatternWhitespace(options));
|
||||
if (this.ptr >= this.pattern.Length)
|
||||
{
|
||||
break;
|
||||
}
|
||||
char c = this.pattern[this.ptr++];
|
||||
char c2 = c;
|
||||
switch (c2)
|
||||
{
|
||||
case '$':
|
||||
{
|
||||
Position position = ((!Parser.IsMultiline(options)) ? Position.End : Position.EndOfLine);
|
||||
expression = new PositionAssertion(position);
|
||||
break;
|
||||
}
|
||||
default:
|
||||
switch (c2)
|
||||
{
|
||||
case '[':
|
||||
expression = this.ParseCharacterClass(options);
|
||||
break;
|
||||
case '\\':
|
||||
{
|
||||
int num = this.ParseEscape();
|
||||
if (num >= 0)
|
||||
{
|
||||
c = (char)num;
|
||||
}
|
||||
else
|
||||
{
|
||||
expression = this.ParseSpecial(options);
|
||||
if (expression == null)
|
||||
{
|
||||
c = this.pattern[this.ptr++];
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
default:
|
||||
if (c2 == '?')
|
||||
{
|
||||
goto IL_25F;
|
||||
}
|
||||
if (c2 == '|')
|
||||
{
|
||||
if (text != null)
|
||||
{
|
||||
group2.AppendExpression(new Literal(text, Parser.IsIgnoreCase(options)));
|
||||
text = null;
|
||||
}
|
||||
if (assertion != null)
|
||||
{
|
||||
if (assertion.TrueExpression == null)
|
||||
{
|
||||
assertion.TrueExpression = group2;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (assertion.FalseExpression != null)
|
||||
{
|
||||
goto IL_230;
|
||||
}
|
||||
assertion.FalseExpression = group2;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (alternation == null)
|
||||
{
|
||||
alternation = new Alternation();
|
||||
}
|
||||
alternation.AddAlternative(group2);
|
||||
}
|
||||
group2 = new Group();
|
||||
continue;
|
||||
}
|
||||
break;
|
||||
case '^':
|
||||
{
|
||||
Position position2 = ((!Parser.IsMultiline(options)) ? Position.Start : Position.StartOfLine);
|
||||
expression = new PositionAssertion(position2);
|
||||
break;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case '(':
|
||||
{
|
||||
bool flag3 = Parser.IsIgnoreCase(options);
|
||||
expression = this.ParseGroupingConstruct(ref options);
|
||||
if (expression == null)
|
||||
{
|
||||
if (text != null && Parser.IsIgnoreCase(options) != flag3)
|
||||
{
|
||||
group2.AppendExpression(new Literal(text, Parser.IsIgnoreCase(options)));
|
||||
text = null;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case ')':
|
||||
goto IL_1DA;
|
||||
case '*':
|
||||
case '+':
|
||||
goto IL_25F;
|
||||
case '.':
|
||||
{
|
||||
Category category = ((!Parser.IsSingleline(options)) ? Category.Any : Category.AnySingleline);
|
||||
expression = new CharacterClass(category, false);
|
||||
break;
|
||||
}
|
||||
}
|
||||
this.ConsumeWhitespace(Parser.IsIgnorePatternWhitespace(options));
|
||||
if (this.ptr < this.pattern.Length)
|
||||
{
|
||||
char c3 = this.pattern[this.ptr];
|
||||
int num2 = 0;
|
||||
int num3 = 0;
|
||||
bool flag4 = false;
|
||||
bool flag5 = false;
|
||||
if (c3 == '?' || c3 == '*' || c3 == '+')
|
||||
{
|
||||
this.ptr++;
|
||||
flag5 = true;
|
||||
c2 = c3;
|
||||
if (c2 != '*')
|
||||
{
|
||||
if (c2 != '+')
|
||||
{
|
||||
if (c2 == '?')
|
||||
{
|
||||
num2 = 0;
|
||||
num3 = 1;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
num2 = 1;
|
||||
num3 = int.MaxValue;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
num2 = 0;
|
||||
num3 = int.MaxValue;
|
||||
}
|
||||
}
|
||||
else if (c3 == '{' && this.ptr + 1 < this.pattern.Length)
|
||||
{
|
||||
int num4 = this.ptr;
|
||||
this.ptr++;
|
||||
flag5 = this.ParseRepetitionBounds(out num2, out num3, options);
|
||||
if (!flag5)
|
||||
{
|
||||
this.ptr = num4;
|
||||
}
|
||||
}
|
||||
if (flag5)
|
||||
{
|
||||
this.ConsumeWhitespace(Parser.IsIgnorePatternWhitespace(options));
|
||||
if (this.ptr < this.pattern.Length && this.pattern[this.ptr] == '?')
|
||||
{
|
||||
this.ptr++;
|
||||
flag4 = true;
|
||||
}
|
||||
Repetition repetition = new Repetition(num2, num3, flag4);
|
||||
if (expression == null)
|
||||
{
|
||||
repetition.Expression = new Literal(c.ToString(), Parser.IsIgnoreCase(options));
|
||||
}
|
||||
else
|
||||
{
|
||||
repetition.Expression = expression;
|
||||
}
|
||||
expression = repetition;
|
||||
}
|
||||
}
|
||||
if (expression == null)
|
||||
{
|
||||
if (text == null)
|
||||
{
|
||||
text = string.Empty;
|
||||
}
|
||||
text += c;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (text != null)
|
||||
{
|
||||
group2.AppendExpression(new Literal(text, Parser.IsIgnoreCase(options)));
|
||||
text = null;
|
||||
}
|
||||
group2.AppendExpression(expression);
|
||||
expression = null;
|
||||
}
|
||||
}
|
||||
while (!flag || this.ptr < this.pattern.Length);
|
||||
goto IL_484;
|
||||
IL_1DA:
|
||||
flag2 = true;
|
||||
goto IL_484;
|
||||
IL_230:
|
||||
throw this.NewParseException("Too many | in (?()|).");
|
||||
IL_25F:
|
||||
throw this.NewParseException("Bad quantifier.");
|
||||
IL_484:
|
||||
if (flag && flag2)
|
||||
{
|
||||
throw this.NewParseException("Too many )'s.");
|
||||
}
|
||||
if (!flag && !flag2)
|
||||
{
|
||||
throw this.NewParseException("Not enough )'s.");
|
||||
}
|
||||
if (text != null)
|
||||
{
|
||||
group2.AppendExpression(new Literal(text, Parser.IsIgnoreCase(options)));
|
||||
}
|
||||
if (assertion != null)
|
||||
{
|
||||
if (assertion.TrueExpression == null)
|
||||
{
|
||||
assertion.TrueExpression = group2;
|
||||
}
|
||||
else
|
||||
{
|
||||
assertion.FalseExpression = group2;
|
||||
}
|
||||
group.AppendExpression(assertion);
|
||||
}
|
||||
else if (alternation != null)
|
||||
{
|
||||
alternation.AddAlternative(group2);
|
||||
group.AppendExpression(alternation);
|
||||
}
|
||||
else
|
||||
{
|
||||
group.AppendExpression(group2);
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x06001A6C RID: 6764 RVA: 0x000600F4 File Offset: 0x0005E2F4
|
||||
private Expression ParseGroupingConstruct(ref RegexOptions options)
|
||||
{
|
||||
if (this.pattern[this.ptr] != '?')
|
||||
{
|
||||
Group group;
|
||||
if (Parser.IsExplicitCapture(options))
|
||||
{
|
||||
group = new Group();
|
||||
}
|
||||
else
|
||||
{
|
||||
group = new CapturingGroup();
|
||||
this.caps.Add(group);
|
||||
}
|
||||
this.ParseGroup(group, options, null);
|
||||
return group;
|
||||
}
|
||||
this.ptr++;
|
||||
char c = this.pattern[this.ptr];
|
||||
switch (c)
|
||||
{
|
||||
case '!':
|
||||
break;
|
||||
default:
|
||||
{
|
||||
switch (c)
|
||||
{
|
||||
case 'i':
|
||||
case 'm':
|
||||
case 'n':
|
||||
break;
|
||||
default:
|
||||
switch (c)
|
||||
{
|
||||
case ':':
|
||||
{
|
||||
this.ptr++;
|
||||
Group group2 = new Group();
|
||||
this.ParseGroup(group2, options, null);
|
||||
return group2;
|
||||
}
|
||||
default:
|
||||
if (c != '-' && c != 's' && c != 'x')
|
||||
{
|
||||
throw this.NewParseException("Bad grouping construct.");
|
||||
}
|
||||
break;
|
||||
case '<':
|
||||
case '=':
|
||||
goto IL_1E5;
|
||||
case '>':
|
||||
{
|
||||
this.ptr++;
|
||||
Group group3 = new NonBacktrackingGroup();
|
||||
this.ParseGroup(group3, options, null);
|
||||
return group3;
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
RegexOptions regexOptions = options;
|
||||
this.ParseOptions(ref regexOptions, false);
|
||||
if (this.pattern[this.ptr] == '-')
|
||||
{
|
||||
this.ptr++;
|
||||
this.ParseOptions(ref regexOptions, true);
|
||||
}
|
||||
if (this.pattern[this.ptr] == ':')
|
||||
{
|
||||
this.ptr++;
|
||||
Group group4 = new Group();
|
||||
this.ParseGroup(group4, regexOptions, null);
|
||||
return group4;
|
||||
}
|
||||
if (this.pattern[this.ptr] == ')')
|
||||
{
|
||||
this.ptr++;
|
||||
options = regexOptions;
|
||||
return null;
|
||||
}
|
||||
throw this.NewParseException("Bad options");
|
||||
}
|
||||
case '#':
|
||||
this.ptr++;
|
||||
while (this.pattern[this.ptr++] != ')')
|
||||
{
|
||||
if (this.ptr >= this.pattern.Length)
|
||||
{
|
||||
throw this.NewParseException("Unterminated (?#...) comment.");
|
||||
}
|
||||
}
|
||||
return null;
|
||||
case '\'':
|
||||
goto IL_21C;
|
||||
case '(':
|
||||
{
|
||||
this.ptr++;
|
||||
int num = this.ptr;
|
||||
string text = this.ParseName();
|
||||
Assertion assertion;
|
||||
if (text == null || this.pattern[this.ptr] != ')')
|
||||
{
|
||||
this.ptr = num;
|
||||
ExpressionAssertion expressionAssertion = new ExpressionAssertion();
|
||||
if (this.pattern[this.ptr] == '?')
|
||||
{
|
||||
this.ptr++;
|
||||
if (!this.ParseAssertionType(expressionAssertion))
|
||||
{
|
||||
throw this.NewParseException("Bad conditional.");
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
expressionAssertion.Negate = false;
|
||||
expressionAssertion.Reverse = false;
|
||||
}
|
||||
Group group5 = new Group();
|
||||
this.ParseGroup(group5, options, null);
|
||||
expressionAssertion.TestExpression = group5;
|
||||
assertion = expressionAssertion;
|
||||
}
|
||||
else
|
||||
{
|
||||
this.ptr++;
|
||||
assertion = new CaptureAssertion(new Literal(text, Parser.IsIgnoreCase(options)));
|
||||
this.refs.Add(assertion, text);
|
||||
}
|
||||
Group group6 = new Group();
|
||||
this.ParseGroup(group6, options, assertion);
|
||||
return group6;
|
||||
}
|
||||
}
|
||||
IL_1E5:
|
||||
ExpressionAssertion expressionAssertion2 = new ExpressionAssertion();
|
||||
if (this.ParseAssertionType(expressionAssertion2))
|
||||
{
|
||||
Group group7 = new Group();
|
||||
this.ParseGroup(group7, options, null);
|
||||
expressionAssertion2.TestExpression = group7;
|
||||
return expressionAssertion2;
|
||||
}
|
||||
IL_21C:
|
||||
char c2;
|
||||
if (this.pattern[this.ptr] == '<')
|
||||
{
|
||||
c2 = '>';
|
||||
}
|
||||
else
|
||||
{
|
||||
c2 = '\'';
|
||||
}
|
||||
this.ptr++;
|
||||
string text2 = this.ParseName();
|
||||
if (this.pattern[this.ptr] == c2)
|
||||
{
|
||||
if (text2 == null)
|
||||
{
|
||||
throw this.NewParseException("Bad group name.");
|
||||
}
|
||||
this.ptr++;
|
||||
CapturingGroup capturingGroup = new CapturingGroup();
|
||||
capturingGroup.Name = text2;
|
||||
this.caps.Add(capturingGroup);
|
||||
this.ParseGroup(capturingGroup, options, null);
|
||||
return capturingGroup;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (this.pattern[this.ptr] != '-')
|
||||
{
|
||||
throw this.NewParseException("Bad group name.");
|
||||
}
|
||||
this.ptr++;
|
||||
string text3 = this.ParseName();
|
||||
if (text3 == null || this.pattern[this.ptr] != c2)
|
||||
{
|
||||
throw this.NewParseException("Bad balancing group name.");
|
||||
}
|
||||
this.ptr++;
|
||||
BalancingGroup balancingGroup = new BalancingGroup();
|
||||
balancingGroup.Name = text2;
|
||||
if (balancingGroup.IsNamed)
|
||||
{
|
||||
this.caps.Add(balancingGroup);
|
||||
}
|
||||
this.refs.Add(balancingGroup, text3);
|
||||
this.ParseGroup(balancingGroup, options, null);
|
||||
return balancingGroup;
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x06001A6D RID: 6765 RVA: 0x000605EC File Offset: 0x0005E7EC
|
||||
private bool ParseAssertionType(ExpressionAssertion assertion)
|
||||
{
|
||||
if (this.pattern[this.ptr] == '<')
|
||||
{
|
||||
char c = this.pattern[this.ptr + 1];
|
||||
if (c != '!')
|
||||
{
|
||||
if (c != '=')
|
||||
{
|
||||
return false;
|
||||
}
|
||||
assertion.Negate = false;
|
||||
}
|
||||
else
|
||||
{
|
||||
assertion.Negate = true;
|
||||
}
|
||||
assertion.Reverse = true;
|
||||
this.ptr += 2;
|
||||
}
|
||||
else
|
||||
{
|
||||
char c = this.pattern[this.ptr];
|
||||
if (c != '!')
|
||||
{
|
||||
if (c != '=')
|
||||
{
|
||||
return false;
|
||||
}
|
||||
assertion.Negate = false;
|
||||
}
|
||||
else
|
||||
{
|
||||
assertion.Negate = true;
|
||||
}
|
||||
assertion.Reverse = false;
|
||||
this.ptr++;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
// Token: 0x06001A6E RID: 6766 RVA: 0x000606C8 File Offset: 0x0005E8C8
|
||||
private void ParseOptions(ref RegexOptions options, bool negate)
|
||||
{
|
||||
for (;;)
|
||||
{
|
||||
char c = this.pattern[this.ptr];
|
||||
switch (c)
|
||||
{
|
||||
case 'i':
|
||||
if (negate)
|
||||
{
|
||||
options &= ~RegexOptions.IgnoreCase;
|
||||
}
|
||||
else
|
||||
{
|
||||
options |= RegexOptions.IgnoreCase;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
if (c != 's')
|
||||
{
|
||||
if (c != 'x')
|
||||
{
|
||||
return;
|
||||
}
|
||||
if (negate)
|
||||
{
|
||||
options &= ~RegexOptions.IgnorePatternWhitespace;
|
||||
}
|
||||
else
|
||||
{
|
||||
options |= RegexOptions.IgnorePatternWhitespace;
|
||||
}
|
||||
}
|
||||
else if (negate)
|
||||
{
|
||||
options &= ~RegexOptions.Singleline;
|
||||
}
|
||||
else
|
||||
{
|
||||
options |= RegexOptions.Singleline;
|
||||
}
|
||||
break;
|
||||
case 'm':
|
||||
if (negate)
|
||||
{
|
||||
options &= ~RegexOptions.Multiline;
|
||||
}
|
||||
else
|
||||
{
|
||||
options |= RegexOptions.Multiline;
|
||||
}
|
||||
break;
|
||||
case 'n':
|
||||
if (negate)
|
||||
{
|
||||
options &= ~RegexOptions.ExplicitCapture;
|
||||
}
|
||||
else
|
||||
{
|
||||
options |= RegexOptions.ExplicitCapture;
|
||||
}
|
||||
break;
|
||||
}
|
||||
this.ptr++;
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x06001A6F RID: 6767 RVA: 0x000607C8 File Offset: 0x0005E9C8
|
||||
private Expression ParseCharacterClass(RegexOptions options)
|
||||
{
|
||||
bool flag = false;
|
||||
if (this.pattern[this.ptr] == '^')
|
||||
{
|
||||
flag = true;
|
||||
this.ptr++;
|
||||
}
|
||||
bool flag2 = Parser.IsECMAScript(options);
|
||||
CharacterClass characterClass = new CharacterClass(flag, Parser.IsIgnoreCase(options));
|
||||
if (this.pattern[this.ptr] == ']')
|
||||
{
|
||||
characterClass.AddCharacter(']');
|
||||
this.ptr++;
|
||||
}
|
||||
int num = -1;
|
||||
bool flag3 = false;
|
||||
bool flag4 = false;
|
||||
while (this.ptr < this.pattern.Length)
|
||||
{
|
||||
int num2 = (int)this.pattern[this.ptr++];
|
||||
if (num2 == 93)
|
||||
{
|
||||
flag4 = true;
|
||||
break;
|
||||
}
|
||||
if (num2 == 45 && num >= 0 && !flag3)
|
||||
{
|
||||
flag3 = true;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (num2 == 92)
|
||||
{
|
||||
num2 = this.ParseEscape();
|
||||
if (num2 < 0)
|
||||
{
|
||||
num2 = (int)this.pattern[this.ptr++];
|
||||
int num3 = num2;
|
||||
switch (num3)
|
||||
{
|
||||
case 80:
|
||||
goto IL_1D1;
|
||||
default:
|
||||
switch (num3)
|
||||
{
|
||||
case 112:
|
||||
goto IL_1D1;
|
||||
default:
|
||||
switch (num3)
|
||||
{
|
||||
case 98:
|
||||
num2 = 8;
|
||||
goto IL_212;
|
||||
default:
|
||||
if (num3 != 68)
|
||||
{
|
||||
if (num3 != 87 && num3 != 119)
|
||||
{
|
||||
goto IL_212;
|
||||
}
|
||||
characterClass.AddCategory((!flag2) ? Category.Word : Category.EcmaWord, num2 == 87);
|
||||
goto IL_1EC;
|
||||
}
|
||||
break;
|
||||
case 100:
|
||||
break;
|
||||
}
|
||||
characterClass.AddCategory((!flag2) ? Category.Digit : Category.EcmaDigit, num2 == 68);
|
||||
break;
|
||||
case 115:
|
||||
goto IL_1B3;
|
||||
}
|
||||
break;
|
||||
case 83:
|
||||
goto IL_1B3;
|
||||
}
|
||||
IL_1EC:
|
||||
if (flag3)
|
||||
{
|
||||
throw this.NewParseException("character range cannot have category \\" + num2);
|
||||
}
|
||||
num = -1;
|
||||
continue;
|
||||
IL_1B3:
|
||||
characterClass.AddCategory((!flag2) ? Category.WhiteSpace : Category.EcmaWhiteSpace, num2 == 83);
|
||||
goto IL_1EC;
|
||||
IL_1D1:
|
||||
characterClass.AddCategory(this.ParseUnicodeCategory(), num2 == 80);
|
||||
goto IL_1EC;
|
||||
}
|
||||
}
|
||||
IL_212:
|
||||
if (flag3)
|
||||
{
|
||||
if (num2 < num)
|
||||
{
|
||||
throw this.NewParseException(string.Concat(new object[] { "[", num, "-", num2, "] range in reverse order." }));
|
||||
}
|
||||
characterClass.AddRange((char)num, (char)num2);
|
||||
num = -1;
|
||||
flag3 = false;
|
||||
}
|
||||
else
|
||||
{
|
||||
characterClass.AddCharacter((char)num2);
|
||||
num = num2;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (!flag4)
|
||||
{
|
||||
throw this.NewParseException("Unterminated [] set.");
|
||||
}
|
||||
if (flag3)
|
||||
{
|
||||
characterClass.AddCharacter('-');
|
||||
}
|
||||
return characterClass;
|
||||
}
|
||||
|
||||
// Token: 0x06001A70 RID: 6768 RVA: 0x00060A90 File Offset: 0x0005EC90
|
||||
private bool ParseRepetitionBounds(out int min, out int max, RegexOptions options)
|
||||
{
|
||||
min = (max = 0);
|
||||
this.ConsumeWhitespace(Parser.IsIgnorePatternWhitespace(options));
|
||||
int num;
|
||||
if (this.pattern[this.ptr] == ',')
|
||||
{
|
||||
num = -1;
|
||||
}
|
||||
else
|
||||
{
|
||||
num = this.ParseNumber(10, 1, 0);
|
||||
this.ConsumeWhitespace(Parser.IsIgnorePatternWhitespace(options));
|
||||
}
|
||||
char c = this.pattern[this.ptr++];
|
||||
int num2;
|
||||
if (c != ',')
|
||||
{
|
||||
if (c != '}')
|
||||
{
|
||||
return false;
|
||||
}
|
||||
num2 = num;
|
||||
}
|
||||
else
|
||||
{
|
||||
this.ConsumeWhitespace(Parser.IsIgnorePatternWhitespace(options));
|
||||
num2 = this.ParseNumber(10, 1, 0);
|
||||
this.ConsumeWhitespace(Parser.IsIgnorePatternWhitespace(options));
|
||||
if (this.pattern[this.ptr++] != '}')
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
if (num > 2147483647 || num2 > 2147483647)
|
||||
{
|
||||
throw this.NewParseException("Illegal {x, y} - maximum of 2147483647.");
|
||||
}
|
||||
if (num2 >= 0 && num2 < num)
|
||||
{
|
||||
throw this.NewParseException("Illegal {x, y} with x > y.");
|
||||
}
|
||||
min = num;
|
||||
if (num2 > 0)
|
||||
{
|
||||
max = num2;
|
||||
}
|
||||
else
|
||||
{
|
||||
max = int.MaxValue;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
// Token: 0x06001A71 RID: 6769 RVA: 0x00060BC8 File Offset: 0x0005EDC8
|
||||
private Category ParseUnicodeCategory()
|
||||
{
|
||||
if (this.pattern[this.ptr++] != '{')
|
||||
{
|
||||
throw this.NewParseException("Incomplete \\p{X} character escape.");
|
||||
}
|
||||
string text = Parser.ParseName(this.pattern, ref this.ptr);
|
||||
if (text == null)
|
||||
{
|
||||
throw this.NewParseException("Incomplete \\p{X} character escape.");
|
||||
}
|
||||
Category category = CategoryUtils.CategoryFromName(text);
|
||||
if (category == Category.None)
|
||||
{
|
||||
throw this.NewParseException("Unknown property '" + text + "'.");
|
||||
}
|
||||
if (this.pattern[this.ptr++] != '}')
|
||||
{
|
||||
throw this.NewParseException("Incomplete \\p{X} character escape.");
|
||||
}
|
||||
return category;
|
||||
}
|
||||
|
||||
// Token: 0x06001A72 RID: 6770 RVA: 0x00060C7C File Offset: 0x0005EE7C
|
||||
private Expression ParseSpecial(RegexOptions options)
|
||||
{
|
||||
int num = this.ptr;
|
||||
bool flag = Parser.IsECMAScript(options);
|
||||
char c = this.pattern[this.ptr++];
|
||||
Expression expression;
|
||||
switch (c)
|
||||
{
|
||||
case '1':
|
||||
case '2':
|
||||
case '3':
|
||||
case '4':
|
||||
case '5':
|
||||
case '6':
|
||||
case '7':
|
||||
case '8':
|
||||
case '9':
|
||||
{
|
||||
this.ptr--;
|
||||
int num2 = this.ParseNumber(10, 1, 0);
|
||||
if (num2 < 0)
|
||||
{
|
||||
this.ptr = num;
|
||||
return null;
|
||||
}
|
||||
Reference reference = new BackslashNumber(Parser.IsIgnoreCase(options), flag);
|
||||
this.refs.Add(reference, num2.ToString());
|
||||
expression = reference;
|
||||
break;
|
||||
}
|
||||
default:
|
||||
switch (c)
|
||||
{
|
||||
case 'P':
|
||||
expression = new CharacterClass(this.ParseUnicodeCategory(), true);
|
||||
break;
|
||||
default:
|
||||
switch (c)
|
||||
{
|
||||
case 'W':
|
||||
expression = new CharacterClass((!flag) ? Category.Word : Category.EcmaWord, true);
|
||||
break;
|
||||
default:
|
||||
switch (c)
|
||||
{
|
||||
case 'p':
|
||||
expression = new CharacterClass(this.ParseUnicodeCategory(), false);
|
||||
break;
|
||||
default:
|
||||
switch (c)
|
||||
{
|
||||
case 'w':
|
||||
expression = new CharacterClass((!flag) ? Category.Word : Category.EcmaWord, false);
|
||||
break;
|
||||
default:
|
||||
switch (c)
|
||||
{
|
||||
case 'b':
|
||||
expression = new PositionAssertion(Position.Boundary);
|
||||
break;
|
||||
default:
|
||||
if (c != 'k')
|
||||
{
|
||||
expression = null;
|
||||
}
|
||||
else
|
||||
{
|
||||
char c2 = this.pattern[this.ptr++];
|
||||
if (c2 == '<')
|
||||
{
|
||||
c2 = '>';
|
||||
}
|
||||
else if (c2 != '\'')
|
||||
{
|
||||
throw this.NewParseException("Malformed \\k<...> named backreference.");
|
||||
}
|
||||
string text = this.ParseName();
|
||||
if (text == null || this.pattern[this.ptr] != c2)
|
||||
{
|
||||
throw this.NewParseException("Malformed \\k<...> named backreference.");
|
||||
}
|
||||
this.ptr++;
|
||||
Reference reference2 = new Reference(Parser.IsIgnoreCase(options));
|
||||
this.refs.Add(reference2, text);
|
||||
expression = reference2;
|
||||
}
|
||||
break;
|
||||
case 'd':
|
||||
expression = new CharacterClass((!flag) ? Category.Digit : Category.EcmaDigit, false);
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case 'z':
|
||||
expression = new PositionAssertion(Position.EndOfString);
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case 's':
|
||||
expression = new CharacterClass((!flag) ? Category.WhiteSpace : Category.EcmaWhiteSpace, false);
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case 'Z':
|
||||
expression = new PositionAssertion(Position.End);
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case 'S':
|
||||
expression = new CharacterClass((!flag) ? Category.WhiteSpace : Category.EcmaWhiteSpace, true);
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case 'A':
|
||||
expression = new PositionAssertion(Position.StartOfString);
|
||||
break;
|
||||
case 'B':
|
||||
expression = new PositionAssertion(Position.NonBoundary);
|
||||
break;
|
||||
case 'D':
|
||||
expression = new CharacterClass((!flag) ? Category.Digit : Category.EcmaDigit, true);
|
||||
break;
|
||||
case 'G':
|
||||
expression = new PositionAssertion(Position.StartOfScan);
|
||||
break;
|
||||
}
|
||||
if (expression == null)
|
||||
{
|
||||
this.ptr = num;
|
||||
}
|
||||
return expression;
|
||||
}
|
||||
|
||||
// Token: 0x06001A73 RID: 6771 RVA: 0x00060FC8 File Offset: 0x0005F1C8
|
||||
private int ParseEscape()
|
||||
{
|
||||
int num = this.ptr;
|
||||
if (num >= this.pattern.Length)
|
||||
{
|
||||
throw new ArgumentException(string.Format("Parsing \"{0}\" - Illegal \\ at end of pattern.", this.pattern), this.pattern);
|
||||
}
|
||||
char c = this.pattern[this.ptr++];
|
||||
switch (c)
|
||||
{
|
||||
case 'n':
|
||||
return 10;
|
||||
default:
|
||||
switch (c)
|
||||
{
|
||||
case 'a':
|
||||
return 7;
|
||||
default:
|
||||
if (c != '0')
|
||||
{
|
||||
if (c != '\\')
|
||||
{
|
||||
this.ptr = num;
|
||||
return -1;
|
||||
}
|
||||
return 92;
|
||||
}
|
||||
else
|
||||
{
|
||||
this.ptr--;
|
||||
int num2 = this.ptr;
|
||||
int num3 = Parser.ParseOctal(this.pattern, ref this.ptr);
|
||||
if (num3 == -1 && num2 == this.ptr)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
return num3;
|
||||
}
|
||||
break;
|
||||
case 'c':
|
||||
{
|
||||
int num4 = (int)this.pattern[this.ptr++];
|
||||
if (num4 >= 64 && num4 <= 95)
|
||||
{
|
||||
return num4 - 64;
|
||||
}
|
||||
throw this.NewParseException("Unrecognized control character.");
|
||||
}
|
||||
case 'e':
|
||||
return 27;
|
||||
case 'f':
|
||||
return 12;
|
||||
}
|
||||
break;
|
||||
case 'r':
|
||||
return 13;
|
||||
case 't':
|
||||
return 9;
|
||||
case 'u':
|
||||
{
|
||||
int num4 = Parser.ParseHex(this.pattern, ref this.ptr, 4);
|
||||
if (num4 < 0)
|
||||
{
|
||||
throw this.NewParseException("Insufficient hex digits");
|
||||
}
|
||||
return num4;
|
||||
}
|
||||
case 'v':
|
||||
return 11;
|
||||
case 'x':
|
||||
{
|
||||
int num4 = Parser.ParseHex(this.pattern, ref this.ptr, 2);
|
||||
if (num4 < 0)
|
||||
{
|
||||
throw this.NewParseException("Insufficient hex digits");
|
||||
}
|
||||
return num4;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x06001A74 RID: 6772 RVA: 0x00061188 File Offset: 0x0005F388
|
||||
private string ParseName()
|
||||
{
|
||||
return Parser.ParseName(this.pattern, ref this.ptr);
|
||||
}
|
||||
|
||||
// Token: 0x06001A75 RID: 6773 RVA: 0x0006119C File Offset: 0x0005F39C
|
||||
private static bool IsNameChar(char c)
|
||||
{
|
||||
UnicodeCategory unicodeCategory = char.GetUnicodeCategory(c);
|
||||
return unicodeCategory != UnicodeCategory.ModifierLetter && (unicodeCategory == UnicodeCategory.ConnectorPunctuation || char.IsLetterOrDigit(c));
|
||||
}
|
||||
|
||||
// Token: 0x06001A76 RID: 6774 RVA: 0x000611CC File Offset: 0x0005F3CC
|
||||
private int ParseNumber(int b, int min, int max)
|
||||
{
|
||||
return Parser.ParseNumber(this.pattern, ref this.ptr, b, min, max);
|
||||
}
|
||||
|
||||
// Token: 0x06001A77 RID: 6775 RVA: 0x000611E4 File Offset: 0x0005F3E4
|
||||
private static int ParseDigit(char c, int b, int n)
|
||||
{
|
||||
switch (b)
|
||||
{
|
||||
case 8:
|
||||
if (c >= '0' && c <= '7')
|
||||
{
|
||||
return (int)(c - '0');
|
||||
}
|
||||
return -1;
|
||||
default:
|
||||
if (b != 16)
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
if (c >= '0' && c <= '9')
|
||||
{
|
||||
return (int)(c - '0');
|
||||
}
|
||||
if (c >= 'a' && c <= 'f')
|
||||
{
|
||||
return (int)('\n' + c - 'a');
|
||||
}
|
||||
if (c >= 'A' && c <= 'F')
|
||||
{
|
||||
return (int)('\n' + c - 'A');
|
||||
}
|
||||
return -1;
|
||||
case 10:
|
||||
if (c >= '0' && c <= '9')
|
||||
{
|
||||
return (int)(c - '0');
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x06001A78 RID: 6776 RVA: 0x0006128C File Offset: 0x0005F48C
|
||||
private void ConsumeWhitespace(bool ignore)
|
||||
{
|
||||
while (this.ptr < this.pattern.Length)
|
||||
{
|
||||
if (this.pattern[this.ptr] == '(')
|
||||
{
|
||||
if (this.ptr + 3 >= this.pattern.Length)
|
||||
{
|
||||
return;
|
||||
}
|
||||
if (this.pattern[this.ptr + 1] != '?' || this.pattern[this.ptr + 2] != '#')
|
||||
{
|
||||
return;
|
||||
}
|
||||
this.ptr += 3;
|
||||
while (this.ptr < this.pattern.Length && this.pattern[this.ptr++] != ')')
|
||||
{
|
||||
}
|
||||
}
|
||||
else if (ignore && this.pattern[this.ptr] == '#')
|
||||
{
|
||||
while (this.ptr < this.pattern.Length && this.pattern[this.ptr++] != '\n')
|
||||
{
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (!ignore || !char.IsWhiteSpace(this.pattern[this.ptr]))
|
||||
{
|
||||
return;
|
||||
}
|
||||
while (this.ptr < this.pattern.Length && char.IsWhiteSpace(this.pattern[this.ptr]))
|
||||
{
|
||||
this.ptr++;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x06001A79 RID: 6777 RVA: 0x00061438 File Offset: 0x0005F638
|
||||
private string ParseString(string pattern)
|
||||
{
|
||||
this.pattern = pattern;
|
||||
this.ptr = 0;
|
||||
StringBuilder stringBuilder = new StringBuilder(pattern.Length);
|
||||
while (this.ptr < pattern.Length)
|
||||
{
|
||||
int num = (int)pattern[this.ptr++];
|
||||
if (num == 92)
|
||||
{
|
||||
num = this.ParseEscape();
|
||||
if (num < 0)
|
||||
{
|
||||
num = (int)pattern[this.ptr++];
|
||||
if (num == 98)
|
||||
{
|
||||
num = 8;
|
||||
}
|
||||
}
|
||||
}
|
||||
stringBuilder.Append((char)num);
|
||||
}
|
||||
return stringBuilder.ToString();
|
||||
}
|
||||
|
||||
// Token: 0x06001A7A RID: 6778 RVA: 0x000614D4 File Offset: 0x0005F6D4
|
||||
private void ResolveReferences()
|
||||
{
|
||||
int num = 1;
|
||||
Hashtable hashtable = new Hashtable();
|
||||
ArrayList arrayList = null;
|
||||
foreach (object obj in this.caps)
|
||||
{
|
||||
CapturingGroup capturingGroup = (CapturingGroup)obj;
|
||||
if (capturingGroup.Name == null)
|
||||
{
|
||||
hashtable.Add(num.ToString(), capturingGroup);
|
||||
capturingGroup.Index = num++;
|
||||
this.num_groups++;
|
||||
}
|
||||
}
|
||||
foreach (object obj2 in this.caps)
|
||||
{
|
||||
CapturingGroup capturingGroup2 = (CapturingGroup)obj2;
|
||||
if (capturingGroup2.Name != null)
|
||||
{
|
||||
if (hashtable.Contains(capturingGroup2.Name))
|
||||
{
|
||||
CapturingGroup capturingGroup3 = (CapturingGroup)hashtable[capturingGroup2.Name];
|
||||
capturingGroup2.Index = capturingGroup3.Index;
|
||||
if (capturingGroup2.Index == num)
|
||||
{
|
||||
num++;
|
||||
}
|
||||
else if (capturingGroup2.Index > num)
|
||||
{
|
||||
arrayList.Add(capturingGroup2);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (char.IsDigit(capturingGroup2.Name[0]))
|
||||
{
|
||||
int num2 = 0;
|
||||
int num3 = Parser.ParseDecimal(capturingGroup2.Name, ref num2);
|
||||
if (num2 == capturingGroup2.Name.Length)
|
||||
{
|
||||
capturingGroup2.Index = num3;
|
||||
hashtable.Add(capturingGroup2.Name, capturingGroup2);
|
||||
this.num_groups++;
|
||||
if (num3 == num)
|
||||
{
|
||||
num++;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (arrayList == null)
|
||||
{
|
||||
arrayList = new ArrayList(4);
|
||||
}
|
||||
arrayList.Add(capturingGroup2);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
}
|
||||
string text = num.ToString();
|
||||
while (hashtable.Contains(text))
|
||||
{
|
||||
int num4;
|
||||
num = (num4 = num + 1);
|
||||
text = num4.ToString();
|
||||
}
|
||||
hashtable.Add(text, capturingGroup2);
|
||||
hashtable.Add(capturingGroup2.Name, capturingGroup2);
|
||||
capturingGroup2.Index = num++;
|
||||
this.num_groups++;
|
||||
}
|
||||
}
|
||||
}
|
||||
this.gap = num;
|
||||
if (arrayList != null)
|
||||
{
|
||||
this.HandleExplicitNumericGroups(arrayList);
|
||||
}
|
||||
foreach (object obj3 in this.refs.Keys)
|
||||
{
|
||||
Expression expression = (Expression)obj3;
|
||||
string text2 = (string)this.refs[expression];
|
||||
if (!hashtable.Contains(text2))
|
||||
{
|
||||
if (!(expression is CaptureAssertion) || char.IsDigit(text2[0]))
|
||||
{
|
||||
BackslashNumber backslashNumber = expression as BackslashNumber;
|
||||
if (backslashNumber == null || !backslashNumber.ResolveReference(text2, hashtable))
|
||||
{
|
||||
throw this.NewParseException("Reference to undefined group " + ((!char.IsDigit(text2[0])) ? "name " : "number ") + text2);
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
CapturingGroup capturingGroup4 = (CapturingGroup)hashtable[text2];
|
||||
if (expression is Reference)
|
||||
{
|
||||
((Reference)expression).CapturingGroup = capturingGroup4;
|
||||
}
|
||||
else if (expression is CaptureAssertion)
|
||||
{
|
||||
((CaptureAssertion)expression).CapturingGroup = capturingGroup4;
|
||||
}
|
||||
else if (expression is BalancingGroup)
|
||||
{
|
||||
((BalancingGroup)expression).Balance = capturingGroup4;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x06001A7B RID: 6779 RVA: 0x000618C4 File Offset: 0x0005FAC4
|
||||
private void HandleExplicitNumericGroups(ArrayList explicit_numeric_groups)
|
||||
{
|
||||
int num = this.gap;
|
||||
int i = 0;
|
||||
int count = explicit_numeric_groups.Count;
|
||||
explicit_numeric_groups.Sort();
|
||||
while (i < count)
|
||||
{
|
||||
CapturingGroup capturingGroup = (CapturingGroup)explicit_numeric_groups[i];
|
||||
if (capturingGroup.Index > num)
|
||||
{
|
||||
break;
|
||||
}
|
||||
if (capturingGroup.Index == num)
|
||||
{
|
||||
num++;
|
||||
}
|
||||
i++;
|
||||
}
|
||||
this.gap = num;
|
||||
int num2 = num;
|
||||
while (i < count)
|
||||
{
|
||||
CapturingGroup capturingGroup2 = (CapturingGroup)explicit_numeric_groups[i];
|
||||
if (capturingGroup2.Index == num2)
|
||||
{
|
||||
capturingGroup2.Index = num - 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
num2 = capturingGroup2.Index;
|
||||
capturingGroup2.Index = num++;
|
||||
}
|
||||
i++;
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x06001A7C RID: 6780 RVA: 0x00061980 File Offset: 0x0005FB80
|
||||
private static bool IsIgnoreCase(RegexOptions options)
|
||||
{
|
||||
return (options & RegexOptions.IgnoreCase) != RegexOptions.None;
|
||||
}
|
||||
|
||||
// Token: 0x06001A7D RID: 6781 RVA: 0x0006198C File Offset: 0x0005FB8C
|
||||
private static bool IsMultiline(RegexOptions options)
|
||||
{
|
||||
return (options & RegexOptions.Multiline) != RegexOptions.None;
|
||||
}
|
||||
|
||||
// Token: 0x06001A7E RID: 6782 RVA: 0x00061998 File Offset: 0x0005FB98
|
||||
private static bool IsExplicitCapture(RegexOptions options)
|
||||
{
|
||||
return (options & RegexOptions.ExplicitCapture) != RegexOptions.None;
|
||||
}
|
||||
|
||||
// Token: 0x06001A7F RID: 6783 RVA: 0x000619A4 File Offset: 0x0005FBA4
|
||||
private static bool IsSingleline(RegexOptions options)
|
||||
{
|
||||
return (options & RegexOptions.Singleline) != RegexOptions.None;
|
||||
}
|
||||
|
||||
// Token: 0x06001A80 RID: 6784 RVA: 0x000619B0 File Offset: 0x0005FBB0
|
||||
private static bool IsIgnorePatternWhitespace(RegexOptions options)
|
||||
{
|
||||
return (options & RegexOptions.IgnorePatternWhitespace) != RegexOptions.None;
|
||||
}
|
||||
|
||||
// Token: 0x06001A81 RID: 6785 RVA: 0x000619BC File Offset: 0x0005FBBC
|
||||
private static bool IsECMAScript(RegexOptions options)
|
||||
{
|
||||
return (options & RegexOptions.ECMAScript) != RegexOptions.None;
|
||||
}
|
||||
|
||||
// Token: 0x06001A82 RID: 6786 RVA: 0x000619CC File Offset: 0x0005FBCC
|
||||
private ArgumentException NewParseException(string msg)
|
||||
{
|
||||
msg = "parsing \"" + this.pattern + "\" - " + msg;
|
||||
return new ArgumentException(msg, this.pattern);
|
||||
}
|
||||
|
||||
// Token: 0x0400159F RID: 5535
|
||||
private string pattern;
|
||||
|
||||
// Token: 0x040015A0 RID: 5536
|
||||
private int ptr;
|
||||
|
||||
// Token: 0x040015A1 RID: 5537
|
||||
private ArrayList caps;
|
||||
|
||||
// Token: 0x040015A2 RID: 5538
|
||||
private Hashtable refs;
|
||||
|
||||
// Token: 0x040015A3 RID: 5539
|
||||
private int num_groups;
|
||||
|
||||
// Token: 0x040015A4 RID: 5540
|
||||
private int gap;
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user