private ScanPatterns AssembleNonWordPatterns() { ScanPatterns pats = new ScanPatterns(); pats.Add(WhitespacePatterns); pats.AddDistinct(NewLinePatterns); pats.Add(CommentToEndPatterns); pats.AddDistinct(QuotePatterns); if (this.VerbatimLiteralPattern != null) { pats.AddDistinct(this.VerbatimLiteralPattern); } pats.AddDistinct(ExpressionPatterns); pats.AddDistinct(EndStmtPatterns); pats.AddDistinct(OpenContentBracedPatterns); pats.AddDistinct(OpenNamedBracedPatterns); pats.AddDistinct(CloseBracedPatterns); pats.AddDistinct(PathSepPatterns); // standard delimeters like "," and ":" pats.AddDistinct(DividerPatterns); return(pats); }
public TextTraits(TextTraits Traits) : this() { mWhitespacePatterns.Replace(Traits.mWhitespacePatterns); mNewLinePatterns.Replace(Traits.mNewLinePatterns); mDividerPatterns.Replace(Traits.mDividerPatterns); this.DividerDelimClasses = Traits.DividerDelimClasses; mCommentToEndPatterns.Replace(Traits.mCommentToEndPatterns); mQuotePatterns.Replace(Traits.mQuotePatterns); this.VerbatimLiteralPattern = Traits.VerbatimLiteralPattern; mExpressionPatterns.Replace(Traits.mExpressionPatterns); mEndStmtPatterns.Replace(Traits.mEndStmtPatterns); mOpenNamedBracedPatterns.Replace(Traits.mOpenNamedBracedPatterns); mOpenContentBracedPatterns.Replace(Traits.mOpenContentBracedPatterns); mOpenBracedPatterns = null; mCloseBracedPatterns = null; mPathSepPatterns.Replace(Traits.mPathSepPatterns); mNonWordPatterns = null; mQem = Traits.mQem; mFormSentencesFromWhitespaceDelimWords = Traits.mFormSentencesFromWhitespaceDelimWords; }
public static ScanPatternResults ScanEqualAny( string InString, ScanPatterns InPatterns) { ScanPatternResults spr = ScanEqualAny(InString, 0, InString.Length, InPatterns); return(spr); }
public static ScanPatternResults ScanEqualAny( BoundedString InString, int InIx, ScanPatterns InPatterns) { int lx = InString.Ex - InIx + 1; ScanPatternResults spr = ScanEqualAny(InString.String, InIx, lx, InPatterns); return(spr); }
// method called from a ScanPatterns object when the pattern is changed. Changing // any of the text patterns requires the consolidated "NonWordPatterns" to be // rebuilt on next use. void WhitespacePatterns_ScanPatternsChanged(ScanPatterns Patterns) { mNonWordPatterns = null; // Changes to OpenContent and OpenNamedBracedPatterns is signaled to this method // along with all the other patterns. Assume that all changes will take place at // startup, so repeatedly setting these dependent patterns to null will not cause // any unnecessary rebuilds. mOpenBracedPatterns = null; mCloseBracedPatterns = null; }
public TextTraits() { mWhitespacePatterns = new ScanPatterns(new string[] { " ", "\t" }, DelimClassification.Whitespace); mNewLinePatterns = new ScanPatterns(); mDividerPatterns = new ScanPatterns( new string[] { ",", ":" }, DelimClassification.DividerSymbol); mCommentToEndPatterns = new ScanPatterns(); ConstructCommon(); }
public TextTraits() { mWhitespacePatterns = new ScanPatterns(new string[] { " ", "\t" }, DelimClassification.Whitespace); mNewLinePatterns = new ScanPatterns(); mDividerPatterns = new ScanPatterns( new string[] { ",", ":", "." }, DelimClassification.DividerSymbol); mCommentToEndPatterns = new ScanPatterns(); // chars which separate names in a path. mPathSepPatterns.Add("/", DelimClassification.PathSep, DelimClassification.CommentToEnd); mPathSepPatterns.Add("\\", DelimClassification.PathSep); }
/// <summary> /// scan from the current cursor position, from line to line, until /// a char not equal any of the pattern chars is found. /// </summary> /// <param name="InCsr"></param> /// <param name="InNotEqualChars"></param> /// <returns></returns> public TextLinesScanResults ScanNotEqual( TextLinesCursor InCsr, ScanPatterns InNotEqualPatterns, ScannerEndOfLineConsider InEolConsider) { ScanPatternResults res; TextLinesScanResults rv = new TextLinesScanResults(); TextLinesCursor csr = Scanner_InitialCursorSetup(this, InCsr); while (true) { if ((csr.Position == RelativePosition.End) || (csr.Position == RelativePosition.None)) { csr.Position = RelativePosition.None; rv.Pos = csr; rv.WhatFound = ScannerWhatFound.NotFound; break; } int ex = csr.LinesNode.Value.LineData.Length - 1; res = Scanner.ScanNotEqual( csr.LinesNode.Value.LineData, csr.LineOx, ex, InNotEqualPatterns); // a char not equal to the pattern chars is found. if (res.FoundPos >= 0) { csr.LineOx = res.FoundPos; rv.Pos = csr; rv.WhatFound = ScannerWhatFound.PatternChar; break; } else if (InEolConsider == ScannerEndOfLineConsider.Found) { csr.LineOx = -1; rv.Pos = csr; rv.WhatFound = ScannerWhatFound.HardLineBreak; break; } else { csr.LineAdvance(this); } } return(rv); }
// --------------------------- ScanReverseNotEqual------------------------------- // scan reverse for the first location in string not equal to all of the // pattern characters. public static int ScanReverseNotEqual( string InString, int InBx, int InEx, int InIx, ScanPatterns InNotEqualPatterns) { int foundIx = InIx + 1; while (true) { foundIx -= 1; if (foundIx < InBx) { foundIx = -1; break; } int remLx = InEx - foundIx + 1; char ch1 = InString[foundIx]; // the current char is not equal any of the pattern lead chars. int patIx = Array.IndexOf <char>(InNotEqualPatterns.LeadChars, ch1); if (patIx == -1) { break; } // lead char matches. check the entire pattern string for equality. ScanPattern equalPat = null; ScanPattern pat = InNotEqualPatterns.ScanPatternsArray[patIx]; while (pat != null) { bool rv = Stringer.CompareSubstringEqual(InString, foundIx, InEx, pat.PatternValue); if (rv == true) { equalPat = pat; break; } pat = pat.NextSameLeadChar; } // none of the patterns fully match the substring at the current location. if (equalPat == null) { break; } } return(foundIx); }
// -------------------------------- ScanNotEqual ------------------------ public static int ScanNotEqual( string Text, ScanPatterns Patterns, int Start) { // step thru the string 1 char at a time. int ix = Start; int ex = Text.Length - 1; while (true) { if (ix > ex) { ix = -1; break; } char ch1 = Text[ix]; // the current char is not equal any of the pattern lead chars. int fx = Array.IndexOf <char>(Patterns.LeadChars, ch1); if (fx == -1) { break; } ScanPattern equalPat = null; int remLx = ex - ix + 1; foreach (var pat in Patterns) { if (pat.PatternValue.Length <= remLx) { if (pat.PatternValue == Text.Substring(ix, pat.PatternValue.Length)) { equalPat = pat; break; } } } // text at the current location is not equal any of the patterns. if (equalPat == null) { break; } ix += equalPat.Length; } return(ix); }
/// <summary> /// Scan string for any of the pattern strings in ScanPatterns. /// </summary> /// <param name="InString"></param> /// <param name="InBx"></param> /// <param name="InLx"></param> /// <param name="InPatterns"></param> /// <returns></returns> public static ScanPatternResults ScanEqualAny( string InString, int InIx, int InLx, ScanPatterns InPatterns) { ScanPattern pat = null; ScanPatternResults spr = null; int ix = InIx; int ex = InIx + InLx - 1; while (true) { spr = null; int remLx = ex - ix + 1; if (remLx <= 0) { break; } ScanCharResults scr = ScanEqualAny( InString, ix, remLx, InPatterns.LeadChars); if (scr.IsNotFound == true) { spr = new ScanPatternResults(-1); break; } pat = InPatterns.FindPatternAtSubstring(InString, scr.ResultPos, ex); if (pat != null) { spr = new ScanPatternResults(scr.ResultPos, pat); break; } // advance ix to resume scan after the found lead char. ix = scr.ResultPos + 1; } return(spr); }
public static Tuple <ScanPattern, int> ScanEqualAny( string Text, int Start, ScanPatterns Patterns) { ScanPattern pat = null; int ix = Start; while (true) { int remLx = Text.Length - ix; if (remLx <= 0) { ix = -1; break; } ScanCharResults scr = ScanEqualAny( Text, ix, remLx, Patterns.LeadChars); if (scr.IsNotFound == true) { ix = -1; break; } ix = scr.ResultPos; pat = Patterns.FindPatternAtSubstring(Text, ix, Text.Length - 1); if (pat != null) { break; } // advance ix to resume scan after the found lead char. ix = ix + 1; } return(new Tuple <ScanPattern, int>(pat, ix)); }
private ScanPatterns AssembleNonWordPatterns() { ScanPatterns pats = new ScanPatterns(); pats.Add(WhitespacePatterns); pats.AddDistinct(NewLinePatterns); pats.Add(CommentToEndPatterns); pats.AddDistinct(QuotePatterns); if (this.VerbatimLiteralPattern != null) { pats.AddDistinct(this.VerbatimLiteralPattern); } pats.AddDistinct(ExpressionPatterns); pats.AddDistinct(EndStmtPatterns); pats.AddDistinct(OpenContentBracedPatterns); pats.AddDistinct(OpenNamedBracedPatterns); pats.AddDistinct(CloseBracedPatterns); pats.AddDistinct(PathSepPatterns); // standard delimeters like "," and ":" pats.AddDistinct(DividerPatterns); // special value starter pattern. *LIBL is the special value. * is the starter // value. if (this.SpecialValueStarter != null) { ScanPattern pat = new ScanPattern(this.SpecialValueStarter, DelimClassification.SpecialValueStarter); pats.AddDistinct(pat); } // note. dont add keyword patterns to this collection of non word patterns. // Keyword patterns are a subset of the text ( identifier ) tokens found // between non word tokens. // BgnTemp // if (_KeywordPatterns != null) // { // pats.AddDistinct(KeywordPatterns); // } // EndTemp // sort the list of patterns by patternValue and DelimClass. var sortedPats = from a in pats orderby a.PatternValue, a.DelimClassification, a.UserCode select a; // build a list of patterns that are distinct on patternValue, delimClass, and // keyword code. ScanPatterns distinctPats = new ScanPatterns(); ScanPattern pvPat = null; foreach (var pat in sortedPats) { if ((pvPat == null) || (pat.Equals(pvPat) == false)) { distinctPats.Add(pat.Duplicate( )); } pvPat = pat; } return(distinctPats); }
void SentenceOpenBracedPatterns_ScanPatternsChanged(ScanPatterns InPatterns) { mComboOpenContentBracedPatterns = null; }
// -------------------------------- ScanNotEqual ------------------------ public static ScanPatternResults ScanNotEqual( string InString, int InIx, int InEx, ScanPatterns InScanPatterns) { // step thru the string 1 char at a time. int stringIx = InIx; while (true) { if (stringIx > InEx) { stringIx = -1; break; } char ch1 = InString[stringIx]; // the current char is not equal any of the pattern lead chars. int patIx = Array.IndexOf <char>(InScanPatterns.LeadChars, ch1); if (patIx == -1) { break; } ScanPattern equalPat = null; ScanPattern pat = InScanPatterns.ScanPatternsArray[patIx]; while (pat != null) { bool rv = Stringer.CompareSubstringEqual(InString, stringIx, InEx, pat.PatternValue); if (rv == true) { if (equalPat == null) { equalPat = pat; } // Matching pattern already found, but this pattern also matches and it is // longer. Always return the longer pattern. else if (pat.PatternValue.Length > equalPat.PatternValue.Length) { equalPat = pat; } } pat = pat.NextSameLeadChar; } // check for the substring at the current location in string as not equal any // of the ScanNotEqual pattern strings. if (equalPat == null) { break; } // advance past the whitespace string. stringIx += equalPat.PatternValue.Length; } // return the scan results ScanPatternResults spr = null; if (stringIx == -1) { spr = new ScanPatternResults(-1); } else { spr = new ScanPatternResults(stringIx, InString[stringIx]); } spr.ScannedString = InString; spr.ScanStartIx = InIx; spr.ScanBoundsEx = InEx; return(spr); }