niko
1520 lines
34 KiB
C#
1520 lines
34 KiB
C#
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;
|
|
}
|
|
}
|