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) { }