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