protected override void OnRenderEnd(RegExpr defaultTokenWs, RegExpr parent,
StringBuilder pattern, ref RenderMode mode)
{
base.OnRenderEnd(defaultTokenWs, parent, pattern, ref mode);
pattern.Append(")");
mode &= ~RenderMode.Assert;
}
protected override void OnRenderNext(RegExpr defaultTokenWs, RegExpr parent,
StringBuilder pattern, ref RenderMode mode, Stack <Token> tokenStack)
{
base.OnRenderNext(defaultTokenWs, parent, pattern, ref mode, tokenStack);
var tokenWs = GetTokenWhitespace(defaultTokenWs);
if (NeedsWhitespaceGroup(tokenWs, mode))
{
pattern.Append(")");
}
if (Expr != null)
{
if (!mode.HasFlag(RenderMode.Assert) && !string.IsNullOrEmpty(Id))
{
string captureId = GenerateCaptureId(Id);
Parents.Add(captureId, tokenStack.Peek());
tokenStack.Peek().Children.Add(this);
pattern.AppendFormat("(?<{0}>", captureId);
}
else
{
pattern.Append("(?:");
}
}
tokenStack.Push(this);
}
protected override IEnumerable <RegExpr> OnRender(RegExpr defaultTokenWs, RegExpr parent,
StringBuilder pattern, ref RenderMode mode)
{
base.OnRender(defaultTokenWs, parent, pattern, ref mode);
pattern.Append(LiteralExpr);
return(null);
}
protected override void OnRenderEnd(RegExpr defaultTokenWs, RegExpr parent,
StringBuilder pattern, ref RenderMode mode, Stack<Token> tokenStack)
{
base.OnRenderEnd(defaultTokenWs, parent, pattern, ref mode, tokenStack);
if (parent == null || !(parent is CharClass))
pattern.Append("]");
}
public void Refresh(RegExpr expr, RegExpr defaultTokenWs = null)
{
// Render Regex string
Pattern = Renderer.RenderPattern(expr, defaultTokenWs);
// Compile Regex
Regex = new Regex(Pattern.ExprRender, RegexOptions.Multiline);
}
protected override void OnRenderNext(RegExpr defaultTokenWs, RegExpr parent,
StringBuilder pattern, ref RenderMode mode)
{
base.OnRenderNext(defaultTokenWs, parent, pattern, ref mode);
if (!IsSubSet && HasPositive && HasNegative)
{
pattern.Append("-[");
}
}
public Token(string id, SkipWhitespace skipWs, RegExpr expr)
{
Id = id;
SkipLeadingWhitespace = (skipWs == SkipWhitespace.Enable);
Expr = expr;
Rules = new TokenRules();
Children = new HashSet <Token>();
Parents = new Dictionary <string, Token>();
}
public Token(string id, SkipWhitespace skipWs, RegExpr expr)
{
Id = id;
SkipLeadingWhitespace = (skipWs == SkipWhitespace.Enable);
Expr = expr;
Rules = new TokenRules();
CaptureId = GenerateCaptureId(Id);
Children = new List <Token>();
}
protected override IEnumerable<RegExpr> OnRender(RegExpr defaultTokenWs, RegExpr parent,
StringBuilder pattern, ref RenderMode mode, Stack<Token> tokenStack)
{
base.OnRender(defaultTokenWs, parent, pattern, ref mode, tokenStack);
if (parent == null || !(parent is CharClass))
pattern.Append("[");
return Items(LowerBound, UpperBound);
}
public Token(string id, RegExpr skipWs, RegExpr expr)
{
Id = id;
SkipLeadingWhitespace = true;
LeadingWhitespace = skipWs;
Expr = expr;
Rules = new TokenRules();
CaptureId = GenerateCaptureId(Id);
Children = new List <Token>();
}
public Token(string id, RegExpr skipWs, RegExpr expr)
{
Id = id;
SkipLeadingWhitespace = true;
LeadingWhitespace = skipWs;
Expr = expr;
Rules = new TokenRules();
Children = new HashSet <Token>();
Parents = new Dictionary <string, Token>();
}
protected override void OnRenderEnd(RegExpr defaultTokenWs, RegExpr parent,
StringBuilder pattern, ref RenderMode mode, Stack <Token> tokenStack)
{
base.OnRenderEnd(defaultTokenWs, parent, pattern, ref mode, tokenStack);
pattern.Append(")");
if (!(parent is Token))
{
pattern.Append(")");
}
}
public static RegExprAssert AssertLookBehind(RegExpr expr)
{
var assert = expr.AsAssert();
return(new RegExprAssert
{
Context = AssertLook.Behind,
Negative = assert.Negative,
Expr = assert.Expr
});
}
public static RegExprAssert AssertNegated(RegExpr expr)
{
var assert = expr.AsAssert();
return(new RegExprAssert
{
Context = assert.Context,
Negative = !assert.Negative,
Expr = assert.Expr
});
}
protected override IEnumerable <RegExpr> OnRender(RegExpr defaultTokenWs, RegExpr parent,
StringBuilder pattern, ref RenderMode mode, Stack <Token> tokenStack)
{
base.OnRender(defaultTokenWs, parent, pattern, ref mode, tokenStack);
if (!(parent is Token))
{
pattern.Append("(?:");
}
pattern.Append("(?:");
return(Exprs);
}
protected override IEnumerable <RegExpr> OnRender(RegExpr defaultTokenWs, RegExpr parent,
StringBuilder pattern, ref RenderMode mode, Stack <Token> tokenStack)
{
base.OnRender(defaultTokenWs, parent, pattern, ref mode, tokenStack);
if (ExprNeedsGroup)
{
pattern.Append("(?:");
}
return(Items(Expr));
}
RegExpr GetTokenWhitespace(RegExpr defaultTokenWs)
{
if (!SkipLeadingWhitespace)
{
return(null);
}
var tokenWs = LeadingWhitespace;
if (tokenWs == null)
{
tokenWs = defaultTokenWs;
}
return(tokenWs);
}
protected override IEnumerable <RegExpr> OnRender(RegExpr defaultTokenWs, RegExpr parent,
StringBuilder pattern, ref RenderMode mode, Stack <Token> tokenStack)
{
base.OnRender(defaultTokenWs, parent, pattern, ref mode, tokenStack);
if ((parent == null || !(parent is CharClass)) && NeedsGroup(LiteralChars))
{
pattern.AppendFormat("[{0}]", LiteralChars);
}
else
{
pattern.Append(LiteralChars);
}
return(null);
}
protected override IEnumerable <RegExpr> OnRender(RegExpr defaultTokenWs, RegExpr parent,
StringBuilder pattern, ref RenderMode mode)
{
base.OnRender(defaultTokenWs, parent, pattern, ref mode);
if (!HasPositive && !HasNegative)
{
return(null);
}
if (!IsSubSet)
{
if (HasPositive)
{
pattern.Append("[");
}
else
{
pattern.Append("[^");
}
}
IEnumerable <RegExpr> children = null;
if (HasPositive && HasNegative)
{
children = Items(
new CharClassSet(positives: Positives)
{
IsSubSet = true
},
new CharClassSet(negatives: Negatives)
{
IsSubSet = true
});
}
else
{
if (HasPositive)
{
children = Positives;
}
else if (HasNegative)
{
children = Negatives;
}
}
return(children);
}
protected override void OnRenderEnd(RegExpr defaultTokenWs, RegExpr parent,
StringBuilder pattern, ref RenderMode mode)
{
base.OnRenderEnd(defaultTokenWs, parent, pattern, ref mode);
if (Expr != null)
{
pattern.Append(")");
}
var tokenWs = GetTokenWhitespace(defaultTokenWs);
if (tokenWs != null)
{
pattern.Append(")");
}
}
protected override void OnRenderEnd(RegExpr defaultTokenWs, RegExpr parent,
StringBuilder pattern, ref RenderMode mode, Stack <Token> tokenStack)
{
base.OnRenderEnd(defaultTokenWs, parent, pattern, ref mode, tokenStack);
if (!IsSubSet)
{
if (HasPositive && HasNegative)
{
pattern.Append("]]");
}
else
{
pattern.Append("]");
}
}
}
protected override IEnumerable <RegExpr> OnRender(RegExpr defaultTokenWs, RegExpr parent,
StringBuilder pattern, ref RenderMode mode)
{
base.OnRender(defaultTokenWs, parent, pattern, ref mode);
var tokenWs = GetTokenWhitespace(defaultTokenWs);
if (tokenWs != null)
{
pattern.Append("(?:");
}
if (NeedsWhitespaceGroup(tokenWs, mode))
{
pattern.Append("(?:");
}
return(Items(tokenWs, Expr));
}
protected override void OnRenderEnd(RegExpr defaultTokenWs, RegExpr parent,
StringBuilder pattern, ref RenderMode mode, Stack <Token> tokenStack)
{
base.OnRenderEnd(defaultTokenWs, parent, pattern, ref mode, tokenStack);
if (ExprNeedsGroup)
{
pattern.Append(")");
}
if (AtLeast == 0 && AtMost == 1)
{
pattern.Append("?");
}
else if (AtLeast == 0 && AtMost == int.MaxValue)
{
pattern.Append("*");
}
else if (AtLeast == 1 && AtMost == int.MaxValue)
{
pattern.Append("+");
}
else if (AtLeast == AtMost)
{
pattern.AppendFormat("{{{0}}}", AtLeast);
}
else if (AtMost == int.MaxValue)
{
pattern.AppendFormat("{{{0},}}", AtLeast);
}
else if (AtLeast == 0)
{
pattern.AppendFormat("{{,{0}}}", AtMost);
}
else
{
pattern.AppendFormat("{{{0},{1}}}", AtLeast, AtMost);
}
}
protected override void OnRenderNext(RegExpr defaultTokenWs, RegExpr parent,
StringBuilder pattern, ref RenderMode mode)
{
base.OnRenderNext(defaultTokenWs, parent, pattern, ref mode);
var tokenWs = GetTokenWhitespace(defaultTokenWs);
if (NeedsWhitespaceGroup(tokenWs, mode))
{
pattern.Append(")");
}
if (Expr != null)
{
if (!mode.HasFlag(RenderMode.Assert) && !string.IsNullOrEmpty(Id))
{
pattern.AppendFormat("(?<{0}>", CaptureId);
}
else
{
pattern.Append("(?:");
}
}
}
protected override IEnumerable <RegExpr> OnRender(RegExpr defaultTokenWs, RegExpr parent,
StringBuilder pattern, ref RenderMode mode)
{
base.OnRender(defaultTokenWs, parent, pattern, ref mode);
if (mode.HasFlag(RenderMode.Assert))
{
throw new NestedAssertException();
}
switch (Context)
{
case AssertLook.Ahead:
if (Negative)
{
pattern.Append("(?!");
}
else
{
pattern.Append("(?=");
}
break;
case AssertLook.Behind:
if (Negative)
{
pattern.Append("(?<!");
}
else
{
pattern.Append("(?<=");
}
break;
}
mode |= RenderMode.Assert;
return(Items(Expr));
}
public Token(string id, RegExpr expr)
: this(id, SkipWhitespace.Enable, expr)
{
}
bool NeedsWhitespaceGroup(RegExpr tokenWs, RenderMode mode)
{
return(tokenWs != null && !mode.HasFlag(RenderMode.Assert) &&
(tokenWs is RegExprLiteral || tokenWs is RegExprSequence));
}
public Token(Enum id, SkipWhitespace skipWs, RegExpr expr)
: this(id.ToString(), skipWs, expr)
{
}
public Token(Enum id, RegExpr skipWs, RegExpr expr)
: this(id.ToString(), skipWs, expr)
{
}
public Token(RegExpr expr)
: this(string.Empty, SkipWhitespace.Enable, expr)
{
}
