/// <summary>
/// Checks the named.
/// </summary>
/// <param name="buffer">The buffer.</param>
/// <returns>bool</returns>
private bool CheckNamed(RegexBuffer buffer)
{
// look for ?<Name> or ?'Name' syntax...
Regex regex = new Regex(
@"
^ # anchor to start of string
\?(\<|') # ?< or ?'
(?<Name>[a-zA-Z0-9]+?) # Capture name
(\>|') # ?> or ?'
(?<Rest>.+) # The rest of the string
",
RegexOptions.IgnorePatternWhitespace);
Match match = regex.Match(buffer.String);
if (match.Success)
{
this.description = $"Capture to <{match.Groups["Name"]}>";
// advance buffer to the rest of the expression
buffer.Offset += match.Groups["Rest"].Index;
this.expression = new RegexExpression(buffer);
this.CheckClosingParen(buffer);
return(true);
}
return(false);
}
/// <summary>
/// Checks the non backtracking.
/// </summary>
/// <param name="buffer">The buffer.</param>
/// <returns>bool</returns>
private bool CheckNonBacktracking(RegexBuffer buffer)
{
// Look for non-backtracking sub-expression ?>
Regex regex = new Regex(
@"
^ # anchor to start of string
\?\>
(?<Rest>.+) # The rest of the expression
",
RegexOptions.IgnorePatternWhitespace);
Match match = regex.Match(buffer.String);
if (match.Success)
{
this.description = "Non-backtracking subexpression";
buffer.Offset += match.Groups["Rest"].Index;
this.expression = new RegexExpression(buffer);
this.CheckClosingParen(buffer);
return(true);
}
return(false);
}
/// <summary>
/// Checks the balanced group.
/// </summary>
/// <param name="buffer">The buffer.</param>
/// <returns>bool</returns>
private bool CheckBalancedGroup(RegexBuffer buffer)
{
// look for ?<Name1-Name2> or ?'Name1-Name2' syntax...
// look for ?<Name> or ?'Name' syntax...
Regex regex = new Regex(
@"
^ # anchor to start of string
\?[\<|'] # ?< or ?'
(?<Name1>[a-zA-Z]+?) # Capture name1
-
(?<Name2>[a-zA-Z]+?) # Capture name2
[\>|'] # ?> or ?'
(?<Rest>.+) # The rest of the expression
",
RegexOptions.IgnorePatternWhitespace);
Match match = regex.Match(buffer.String);
if (match.Success)
{
this.description = $"Balancing Group <{match.Groups["Name1"]}>-<{match.Groups["Name2"]}>";
buffer.Offset += match.Groups["Rest"].Index;
this.expression = new RegexExpression(buffer);
this.CheckClosingParen(buffer);
return(true);
}
return(false);
}
/// <summary>
/// Adds the lookup.
/// </summary>
/// <param name="item">The item.</param>
/// <param name="startLocation">The start location.</param>
/// <param name="endLocation">The end location.</param>
/// <param name="canCoalesce">if set to <c>true</c> [can coalesce].</param>
public void AddLookup(RegexItem item, int startLocation, int endLocation, bool canCoalesce)
{
if (item == null)
{
throw new ArgumentNullException("item", "RegexItem is null");
}
if (this.inseries)
{
// in a series, add character to the previous one...
if (canCoalesce)
{
RegexRef lastItem = (RegexRef)this.expressionLookup[this.expressionLookup.Count - 1];
lastItem.StringValue += item.ToString(0);
lastItem.Length += endLocation - startLocation + 1;
}
else
{
this.expressionLookup.Add(new RegexRef(item, startLocation, endLocation));
this.inseries = false;
}
}
else
{
if (canCoalesce)
{
this.inseries = true;
}
this.expressionLookup.Add(new RegexRef(item, startLocation, endLocation));
}
}
/// <summary>
/// Initializes a new instance of the <see cref="RegexRef"/> class.
/// </summary>
/// <param name="regexItem">The regex item.</param>
/// <param name="start">The start.</param>
/// <param name="end">The end.</param>
public RegexRef(RegexItem regexItem, int start, int end)
{
if (regexItem == null)
{
throw new ArgumentNullException("regexItem", "RegexItem is null");
}
this.StringValue = regexItem.ToString(0);
this.start = start;
this.end = end;
}
/// <summary>
/// Initializes a new instance of the <see cref="RegexRef"/> class.
/// </summary>
/// <param name="regexItem">The regex item.</param>
/// <param name="start">The start.</param>
/// <param name="end">The end.</param>
public RegexRef(RegexItem regexItem, int start, int end)
{
if (regexItem == null)
{
throw new ArgumentNullException(nameof(regexItem), "RegexItem is null");
}
this.StringValue = regexItem.ToString(0);
this.start = start;
this.end = end;
}
/// <summary>
/// Handles the plain old capture.
/// </summary>
/// <param name="buffer">The buffer.</param>
/// <returns>bool</returns>
private bool HandlePlainOldCapture(RegexBuffer buffer)
{
// we're already at the expression. Just create a new
// expression, and make sure that we're at a ")" when
// we're done
if (buffer.ExplicitCapture)
{
this.description = "Non-capturing Group";
}
this.expression = new RegexExpression(buffer);
this.CheckClosingParen(buffer);
return(true);
}
private bool CheckLookahead(RegexBuffer buffer)
{
Regex regex = new Regex(
@"
^ # anchor to start of string
\?
(?<Assertion><=|<!|=|!) # assertion char
(?<Rest>.+) # The rest of the expression
",
RegexOptions.IgnorePatternWhitespace);
Match match = regex.Match(buffer.String);
if (match.Success)
{
switch (match.Groups["Assertion"].Value)
{
case "=":
this.description = "zero-width positive lookahead";
break;
case "!":
this.description = "zero-width negative lookahead";
break;
case "<=":
this.description = "zero-width positive lookbehind";
break;
case "<!":
this.description = "zero-width negative lookbehind";
break;
}
buffer.Offset += match.Groups["Rest"].Index;
this.expression = new RegexExpression(buffer);
this.CheckClosingParen(buffer);
return(true);
}
return(false);
}
/// <summary>
/// Checks the conditional.
/// </summary>
/// <param name="buffer">The buffer.</param>
private void CheckConditional(RegexBuffer buffer)
{
// Look for conditional (?(name)yesmatch|nomatch)
// (name can also be an expression)
Regex regex = new Regex(
@"
^ # anchor to start of string
\?\(
(?<Rest>.+) # The rest of the expression
",
RegexOptions.IgnorePatternWhitespace);
Match match = regex.Match(buffer.String);
if (match.Success)
{
this.description = "Conditional Subexpression";
buffer.Offset += match.Groups["Rest"].Index;
this.expression = new RegexConditional(buffer);
}
}
/// <summary>
/// Checks the options.
/// </summary>
/// <param name="buffer">The buffer.</param>
/// <returns>bool</returns>
private bool CheckOptions(RegexBuffer buffer)
{
// look for ?imnsx-imnsx:
Regex regex = new Regex(
@"
^ # anchor to start of string
\?(?<Options>[imnsx-]+):
",
RegexOptions.IgnorePatternWhitespace);
Match match = regex.Match(buffer.String);
if (match.Success)
{
string option = match.Groups["Options"].Value;
this.description = $"Set options to {OptionNames[option]}";
this.expression = null;
buffer.Offset += match.Groups[0].Length;
return(true);
}
return(false);
}
/// <summary>
/// Checks the balanced group.
/// </summary>
/// <param name="buffer">The buffer.</param>
/// <returns>bool</returns>
private bool CheckBalancedGroup(RegexBuffer buffer)
{
// look for ?<Name1-Name2> or ?'Name1-Name2' syntax...
// look for ?<Name> or ?'Name' syntax...
Regex regex = new Regex(
@"
^ # anchor to start of string
\?[\<|'] # ?< or ?'
(?<Name1>[a-zA-Z]+?) # Capture name1
-
(?<Name2>[a-zA-Z]+?) # Capture name2
[\>|'] # ?> or ?'
(?<Rest>.+) # The rest of the expression
",
RegexOptions.IgnorePatternWhitespace);
Match match = regex.Match(buffer.String);
if (match.Success)
{
this.description = string.Format("Balancing Group <{0}>-<{1}>", match.Groups["Name1"], match.Groups["Name2"]);
buffer.Offset += match.Groups["Rest"].Index;
this.expression = new RegexExpression(buffer);
this.CheckClosingParen(buffer);
return true;
}
return false;
}
private bool CheckLookahead(RegexBuffer buffer)
{
Regex regex = new Regex(
@"
^ # anchor to start of string
\?
(?<Assertion><=|<!|=|!) # assertion char
(?<Rest>.+) # The rest of the expression
",
RegexOptions.IgnorePatternWhitespace);
Match match = regex.Match(buffer.String);
if (match.Success)
{
switch (match.Groups["Assertion"].Value)
{
case "=":
this.description = "zero-width positive lookahead";
break;
case "!":
this.description = "zero-width negative lookahead";
break;
case "<=":
this.description = "zero-width positive lookbehind";
break;
case "<!":
this.description = "zero-width negative lookbehind";
break;
}
buffer.Offset += match.Groups["Rest"].Index;
this.expression = new RegexExpression(buffer);
this.CheckClosingParen(buffer);
return true;
}
return false;
}
/// <summary>
/// Checks the options.
/// </summary>
/// <param name="buffer">The buffer.</param>
/// <returns>bool</returns>
private bool CheckOptions(RegexBuffer buffer)
{
// look for ?imnsx-imnsx:
Regex regex = new Regex(
@"
^ # anchor to start of string
\?(?<Options>[imnsx-]+):
",
RegexOptions.IgnorePatternWhitespace);
Match match = regex.Match(buffer.String);
if (match.Success)
{
string option = match.Groups["Options"].Value;
this.description = string.Format("Set options to {0}", OptionNames[option]);
this.expression = null;
buffer.Offset += match.Groups[0].Length;
return true;
}
return false;
}
/// <summary>
/// Checks the non backtracking.
/// </summary>
/// <param name="buffer">The buffer.</param>
/// <returns>bool</returns>
private bool CheckNonBacktracking(RegexBuffer buffer)
{
// Look for non-backtracking sub-expression ?>
Regex regex = new Regex(
@"
^ # anchor to start of string
\?\>
(?<Rest>.+) # The rest of the expression
",
RegexOptions.IgnorePatternWhitespace);
Match match = regex.Match(buffer.String);
if (match.Success)
{
this.description = string.Format("Non-backtracking subexpression");
buffer.Offset += match.Groups["Rest"].Index;
this.expression = new RegexExpression(buffer);
this.CheckClosingParen(buffer);
return true;
}
return false;
}
/// <summary>
/// Adds the lookup.
/// </summary>
/// <param name="item">The item.</param>
/// <param name="startLocation">The start location.</param>
/// <param name="endLocation">The end location.</param>
/// <param name="canCoalesce">if set to <c>true</c> [can coalesce].</param>
public void AddLookup(RegexItem item, int startLocation, int endLocation, bool canCoalesce)
{
if (item == null)
{
throw new ArgumentNullException("item", "RegexItem is null");
}
if (this.inseries)
{
// in a series, add character to the previous one...
if (canCoalesce)
{
RegexRef lastItem = (RegexRef)this.expressionLookup[this.expressionLookup.Count - 1];
lastItem.StringValue += item.ToString(0);
lastItem.Length += endLocation - startLocation + 1;
}
else
{
this.expressionLookup.Add(new RegexRef(item, startLocation, endLocation));
this.inseries = false;
}
}
else
{
if (canCoalesce)
{
this.inseries = true;
}
this.expressionLookup.Add(new RegexRef(item, startLocation, endLocation));
}
}
/// <summary>
/// Checks the named.
/// </summary>
/// <param name="buffer">The buffer.</param>
/// <returns>bool</returns>
private bool CheckNamed(RegexBuffer buffer)
{
// look for ?<Name> or ?'Name' syntax...
Regex regex = new Regex(
@"
^ # anchor to start of string
\?(\<|') # ?< or ?'
(?<Name>[a-zA-Z0-9]+?) # Capture name
(\>|') # ?> or ?'
(?<Rest>.+) # The rest of the string
",
RegexOptions.IgnorePatternWhitespace);
Match match = regex.Match(buffer.String);
if (match.Success)
{
this.description = string.Format("Capture to <{0}>", match.Groups["Name"]);
// advance buffer to the rest of the expression
buffer.Offset += match.Groups["Rest"].Index;
this.expression = new RegexExpression(buffer);
this.CheckClosingParen(buffer);
return true;
}
return false;
}
/// <summary>
/// Checks the conditional.
/// </summary>
/// <param name="buffer">The buffer.</param>
/// <returns>bool</returns>
private bool CheckConditional(RegexBuffer buffer)
{
// Look for conditional (?(name)yesmatch|nomatch)
// (name can also be an expression)
Regex regex = new Regex(
@"
^ # anchor to start of string
\?\(
(?<Rest>.+) # The rest of the expression
",
RegexOptions.IgnorePatternWhitespace);
Match match = regex.Match(buffer.String);
if (match.Success)
{
this.description = string.Format("Conditional Subexpression");
buffer.Offset += match.Groups["Rest"].Index;
this.expression = new RegexConditional(buffer);
return true;
}
return false;
}
/// <summary>
/// Adds the lookup.
/// </summary>
/// <param name="item">The item.</param>
/// <param name="startLocation">The start location.</param>
/// <param name="endLocation">The end location.</param>
public void AddLookup(RegexItem item, int startLocation, int endLocation)
{
this.AddLookup(item, startLocation, endLocation, false);
}
/// <summary>
/// Adds the lookup.
/// </summary>
/// <param name="item">The item.</param>
/// <param name="startLocation">The start location.</param>
/// <param name="endLocation">The end location.</param>
public void AddLookup(RegexItem item, int startLocation, int endLocation)
{
this.AddLookup(item, startLocation, endLocation, false);
}
/// <summary>
/// Handles the plain old capture.
/// </summary>
/// <param name="buffer">The buffer.</param>
/// <returns>bool</returns>
private bool HandlePlainOldCapture(RegexBuffer buffer)
{
// we're already at the expression. Just create a new
// expression, and make sure that we're at a ")" when
// we're done
if (buffer.ExplicitCapture)
{
this.description = string.Format("Non-capturing Group");
}
this.expression = new RegexExpression(buffer);
this.CheckClosingParen(buffer);
return true;
}
