public void Replace(
string Pattern1, string Pattern2, DelimClassification DelimClassification)
{
Clear();
Add(Pattern1, DelimClassification);
Add(Pattern2, DelimClassification);
}
public ScannerNonWord()
{
mDelimClass = DelimClassification.None;
mValue = null;
mNextLookup = null;
mNonWordChar = '\0';
}
/// <summary>
/// Add pattern to list of patterns. Return zero based position of the added
/// pattern in the pattern list.
/// </summary>
/// <param name="InPatternValue"></param>
/// <returns></returns>
public int Add(string PatternValue, DelimClassification DelimClassification)
{
ScanPattern sp = new ScanPattern(PatternValue, DelimClassification);
AddToNextSameLeadCharChain(sp);
base.Add(sp);
// add to combo string. this string is used as a quick way to determine if
// a new string being added is distinct or not.
mAllStringCombo.Append(PatternValue + '\0');
// force these two arrays to be rebuilt next time accessed thru their
// property getters.
mLeadChars = null;
mScanPatternsArray = null;
mStringArray = null;
// signal "PatternsChanged" event.
if (ScanPatternsChanged != null)
{
ScanPatternsChanged(this);
}
// mark the position of the pattern in the list of patterns.
sp.ArrayPosition = base.Count - 1;
return(sp.ArrayPosition);
}
public void Add(char[] InPatternChars, DelimClassification DelimClassification)
{
foreach (char patChar in InPatternChars)
{
Add(patChar.ToString( ), DelimClassification);
}
}
public void AddDistinct(string[] InPatterns, DelimClassification DelimClassification)
{
foreach (string pat in InPatterns)
{
AddDistinct(pat, DelimClassification);
}
}
public void Add(string[] InPatternStrings, DelimClassification DelimClassification)
{
foreach (string pat in InPatternStrings)
{
Add(pat, DelimClassification);
}
}
public static MatchScanPattern FindPattern(
this PatternScanResults Results, DelimClassification DelimClass)
{
MatchScanPattern found = null;
if (Results == null)
{
found = null;
}
else if (Results.FoundPatterns != null)
{
found = Results.FoundPatterns.FindPattern(DelimClass);
}
else if ((Results.FoundPattern != null) &&
(Results.FoundPattern.MatchPattern.DelimClassification == DelimClass))
{
found = Results.FoundPattern;
}
else
{
found = null;
}
return(found);
}
/// <summary>
/// Add pattern to list of patterns. Return zero based position of the added
/// pattern in the pattern list.
/// </summary>
/// <param name="InPatternValue"></param>
/// <returns></returns>
public int Replace(string PatternValue, DelimClassification DelimClassification)
{
Clear();
int pos = Add(PatternValue, DelimClassification);
return(pos);
}
public ScannerNonWord(DelimClassification InDelimClass, char InNonWordChar)
{
mDelimClass = InDelimClass;
mValue = null;
mNextLookup = null;
mNonWordChar = InNonWordChar;
}
public ScanPatterns(
string Pattern1, string Pattern2, DelimClassification DelimClassification)
{
ConstructCommon();
Add(Pattern1, DelimClassification);
Add(Pattern2, DelimClassification);
}
public ScannerNonWord(DelimClassification InDelimClass, string InValue)
{
mDelimClass = InDelimClass;
mValue = InValue;
mNextLookup = null;
mNonWordChar = '\0';
}
public CursorMatchPattern(
WordCompositeCode InCompositeCode, WhichEdge InEdge)
{
mCompositeCode = InCompositeCode;
mEdge = InEdge;
mDelimClass = DelimClassification.Any;
}
public ScanPatterns(
string Pattern1, string Pattern2, DelimClassification DelimClassification)
: this()
{
Add(Pattern1, DelimClassification);
Add(Pattern2, DelimClassification);
}
public static bool FoundAtPosition(
this PatternScanResults Results, DelimClassification DelimClass,
int Pos)
{
bool rc = false;
// MatchScanPattern found = null;
if (Results == null)
{
rc = false;
}
else if (Results.Position != Pos)
{
rc = false;
}
else
{
var pat = Results.FindPattern(DelimClass);
if (pat == null)
{
rc = false;
}
else
{
rc = true;
}
}
return(rc);
}
public ScanNonWordResults(
int InPosition, string InNonWordString, DelimClassification InDelimClass)
{
mPosition = InPosition;
mNonWordChar = null;
mNonWordString = InNonWordString;
mDelimClass = InDelimClass;
}
public ScanPatterns(string[] Patterns, DelimClassification DelimClassification)
: this()
{
foreach (string pat in Patterns)
{
Add(pat, DelimClassification);
}
}
public void Add(ScanPatterns InPatterns, DelimClassification InDelimClass)
{
foreach (ScanPattern pat in InPatterns)
{
base.Add(pat.PatternValue);
mWip.Add(InDelimClass);
}
}
public ScanPatterns(char[] Patterns, DelimClassification DelimClassification)
{
ConstructCommon();
foreach (char pat in Patterns)
{
Add(pat.ToString( ), DelimClassification);
}
}
public ScanPatterns(string[] Patterns, DelimClassification DelimClassification)
{
ConstructCommon();
foreach (string pat in Patterns)
{
Add(pat, DelimClassification);
}
}
public ScanPattern(string PatternValue, DelimClassification DelimClassification,
Nullable <DelimClassification> OverlapClassification)
: this()
{
this.PatternValue = PatternValue;
this.DelimClassification = DelimClassification;
this.OverlapClassification = OverlapClassification;
}
public ScanPatterns(char[] Patterns, DelimClassification DelimClassification)
: this()
{
foreach (char pat in Patterns)
{
Add(pat.ToString( ), DelimClassification);
}
}
public static WordClassification?ToWordClassification(this DelimClassification Delim)
{
switch (Delim)
{
case DelimClassification.CloseBraced:
return(WordClassification.CloseBraced);
case DelimClassification.CommentToEnd:
return(WordClassification.CommentToEnd);
// dividers, whitespace, end of line - never considered a word.
case DelimClassification.DividerSymbol:
return(null);
case DelimClassification.EmbeddedComment:
return(WordClassification.EmbeddedComment);
case DelimClassification.EndOfString:
return(null);
case DelimClassification.EndStmt:
return(null);
case DelimClassification.ExpressionSymbol:
return(WordClassification.ExpressionSymbol);
case DelimClassification.Assignment:
return(WordClassification.Assignment);
case DelimClassification.NewLine:
return(null);
case DelimClassification.OpenContentBraced:
return(WordClassification.OpenContentBraced);
case DelimClassification.OpenNamedBraced:
return(WordClassification.OpenNamedBraced);
case DelimClassification.PathSep:
return(null);
case DelimClassification.Quote:
return(null);
case DelimClassification.VirtualWhitespace:
return(null);
case DelimClassification.Whitespace:
return(null);
case DelimClassification.None:
return(null);
default:
throw new ApplicationException(
"unexpected DelimClassification " + Delim.ToString());
}
}
public void AddDistinct(ScanPattern Pattern, DelimClassification DelimClass)
{
int px = base.AddDistinct(Pattern.PatternValue);
if (px != -1)
{
mWip.Add(DelimClass);
}
}
public void AddDistinct(char[] InPatterns, DelimClassification InDelimClass)
{
foreach (char pat in InPatterns)
{
int px = base.AddDistinct(pat.ToString( ));
if (px != -1)
{
mWip.Add(InDelimClass);
}
}
}
public void AddDistinct(ScanPatterns Patterns, DelimClassification DelimClass)
{
foreach (ScanPattern pat in Patterns)
{
int px = base.AddDistinct(pat.PatternValue);
if (px != -1)
{
mWip.Add(DelimClass);
}
}
}
public ScanNonWordResults(int InPosition)
{
if (InPosition != -1)
{
throw new ApplicationException("only not found value, -1, allowed in this constructor");
}
mPosition = InPosition;
mNonWordChar = null;
mNonWordString = null;
mDelimClass = DelimClassification.None;
}
/// <summary>
/// Add pattern to list of patterns. Return zero based position of the added
/// pattern in the pattern list.
/// </summary>
/// <param name="InPatternValue"></param>
/// <returns></returns>
public int Add(
string PatternValue, DelimClassification DelimClassification,
int Priority = 0)
{
ScanPattern sp = new ScanPattern(PatternValue, DelimClassification);
sp.Priority = Priority;
var rv = Add_Common(sp);
return(rv);
}
// ------------------------- IsOpenBraced ----------------------------------
public static bool IsOpenBraced(DelimClassification InDelimClass)
{
if ((InDelimClass == DelimClassification.OpenNamedBraced) ||
(InDelimClass == DelimClassification.OpenContentBraced))
{
return(true);
}
else
{
return(false);
}
}
/// <summary>
/// test if the enum value is equal any of the compare to enum values.
/// </summary>
/// <param name="Position"></param>
/// <param name="Values"></param>
/// <returns></returns>
public static bool EqualAny(this DelimClassification Delim, params DelimClassification[] Values)
{
bool rc = false;
foreach (var vlu in Values)
{
if (vlu == Delim)
{
rc = true;
break;
}
}
return(rc);
}
public bool IsOpenBraced(ScanPattern InPattern)
{
DelimClassification dc = GetDelimClass(InPattern);
if ((dc == DelimClassification.OpenContentBraced) ||
(dc == DelimClassification.OpenNamedBraced))
{
return(true);
}
else
{
return(false);
}
}
