// ------------------------ ScanFirstWord -------------------------
public static WordCursor ScanFirstWord(string InString, TextTraits InTraits)
{
BoundedString boundedString = new BoundedString(InString);
WordCursor res = ScanFirstWord(boundedString, InTraits);
return(res);
}
/// <summary>
/// Scan with the bounded string for a char equal any of the pattern characters.
/// </summary>
/// <param name="InBounded"></param>
/// <param name="InBx"></param>
/// <param name="InPatternChars"></param>
/// <returns></returns>
public static ScanCharResults ScanEqualAny(
BoundedString InBounded,
int InBx,
char[] InPatternChars)
{
int Ix;
InBounded.ThrowBeforeBounds(InBx);
int Lx = InBounded.Ex - InBx + 1;
if (Lx <= 0)
{
Ix = -1;
}
else
{
Ix = InBounded.String.IndexOfAny(InPatternChars, InBx, Lx);
}
if (Ix == -1)
{
return(new ScanCharResults(-1));
}
else
{
char ch1 = InBounded.String[Ix];
return(new ScanCharResults(ch1, Ix));
}
}
/// <summary>
/// calc if the char at location in string is a word char or not ( is not a
/// NonWordChar )
/// </summary>
/// <param name="InBoundedString"></param>
/// <param name="InIx"></param>
/// <returns></returns>
public bool IsWordChar(
BoundedString InBoundedString, int InIx)
{
bool isWordChar = false;
if (InBoundedString.IsOutsideBounds(InIx))
{
isWordChar = false;
}
else
{
ScanPattern pat = NonWordPatterns.FindPatternAtSubstring(
InBoundedString, InIx);
if (pat == null)
{
isWordChar = true;
}
else
{
isWordChar = false;
}
}
return(isWordChar);
}
/// <summary>
/// scan for pattern string within string.
/// </summary>
/// <param name="InBounded"></param>
/// <param name="InBx"></param>
/// <param name="InPattern"></param>
/// <returns></returns>
public static ScanStringResults ScanEqual(
BoundedString InBounded, int InBx, string InPattern)
{
int Ix;
InBounded.ThrowBeforeBounds(InBx);
int remLx = InBounded.GetRemainingLength(InBx);
if (remLx < InPattern.Length)
{
Ix = -1;
}
else
{
Ix = InBounded.String.IndexOf(InPattern, InBx);
}
if (Ix == -1)
{
return(new ScanStringResults(-1));
}
else
{
char ch1 = InBounded.String[Ix];
return(new ScanStringResults(InPattern, Ix));
}
}
/// <summary>
/// calc if the char at location in string is a word char or not ( is not a
/// NonWordChar )
/// </summary>
/// <param name="InBoundedString"></param>
/// <param name="InIx"></param>
/// <returns></returns>
public bool IsWordChar(
BoundedString InBoundedString, int InIx)
{
bool isWordChar = false;
if (InBoundedString.IsOutsideBounds(InIx))
{
isWordChar = false;
}
else
{
var rv = NonWordPatterns.FindPatternAtSubstring(
InBoundedString, InIx);
var pat = rv.Item1;
var matchLx = rv.Item2;
if (pat == null)
{
isWordChar = true;
}
else
{
isWordChar = false;
}
}
return(isWordChar);
}
/// <summary>
/// return the NonWord info of path sep char which is classified as being a
/// path part delimiter ( it could be a division expression symbol )
/// </summary>
/// <param name="InBoundedString"></param>
/// <param name="InIx"></param>
/// <returns></returns>
public ScanPattern GetPathPartDelim(BoundedString InBoundedString, int InIx)
{
ScanPattern pat = null;
int matchLx = 0;
if (InBoundedString.IsOutsideBounds(InIx))
{
}
else if (IsPathSepChar(InBoundedString[InIx]) == true)
{
var rv = NonWordPatterns.MatchPatternsAtStringLocation(
InBoundedString.String, InIx, InBoundedString.Ex);
pat = rv.Item1;
matchLx = rv.Item2;
// the nonword is a path sep char. but is it a pathPart delim?
// It is if there is a word char before or after the path sep char.
// ex: /abc/efg vs. a = b / c ;
if ((IsWordChar(InBoundedString, InIx - 1) == false) &&
(IsWordChar(InBoundedString, InIx + 1) == false))
{
pat = null;
}
}
return(pat);
}
// ------------------ ScanWord_IsolatedWord_CommentToEnd -------------------
private static ScanPatternResults ScanWord_IsolateWord_CommentToEnd(
BoundedString InBoundedString,
int InWordBx,
ref WordCursor InOutResults, TextTraits InTraits)
{
string wordText;
ScanPatternResults spr = null;
// look for end of comment. ( either end of line or end of string )
int fx = Scanner.ScanEqual(InBoundedString, InWordBx, Environment.NewLine).ResultPos;
if (fx >= 0)
{
int Lx = fx - InWordBx;
wordText = InBoundedString.Substring(InWordBx, Lx);
ScanPattern pat =
InTraits.NonWordPatterns.FindPatternAtSubstring(InBoundedString, fx);
spr = new ScanPatternResults(fx, pat);
}
else
{
wordText = InBoundedString.Substring(InWordBx);
spr = new ScanPatternResults(-1);
}
// store info on the word found in the return WordCursor argument.
InOutResults.SetWord(wordText, WordClassification.CommentToEnd, InWordBx);
// return value of method contains info on the word delim.
return(spr);
}
// ----------------------- ScanWord_IsolatedWord_Braced -----------------------
private static void ScanWord_IsolateWord_Braced(
BoundedString InBoundedString,
int InWordBx,
ScanPatternResults InNonWordResults,
ref WordCursor InOutResults,
TextTraits InTraits)
{
string wordText;
int Lx, Ix;
int braceIx = InNonWordResults.FoundPos;
char braceChar = InNonWordResults.FoundPat.LeadChar;
if (InTraits.BracedTreatment == ScannerBracedTreatment.Parts)
{
// a standalone open brace char. the brace char is the word ( and it will
// also be the delim )
if (InWordBx == braceIx)
{
InOutResults.SetWord(
InNonWordResults.FoundPat.PatternValue,
WordClassification.OpenContentBraced, InWordBx, braceChar);
}
else
{
wordText =
InBoundedString.String.Substring(InWordBx, braceIx - InWordBx);
InOutResults.SetWord(
wordText, WordClassification.OpenNamedBraced, InWordBx, braceChar);
}
}
// the whole braced word. braced word runs all the way to the closing brace.
else if (InTraits.BracedTreatment == ScannerBracedTreatment.Whole)
{
Ix = ScanCloseBrace(
InBoundedString.String,
braceIx, InBoundedString.Ex, InTraits.QuoteEncapsulation);
if (Ix == -1)
{
throw new ApplicationException(
"Closing brace not found starting at position " +
braceIx + " in " + InBoundedString.String);
}
Lx = Ix - InWordBx + 1;
wordText = InBoundedString.String.Substring(InWordBx, Lx);
if (InWordBx == braceIx)
{
InOutResults.SetWord(
wordText, WordClassification.ContentBraced, InWordBx, braceChar);
}
else
{
InOutResults.SetWord(
wordText, WordClassification.NamedBraced, InWordBx, braceChar);
}
}
}
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);
}
public static int ScanCloseQuote(
BoundedString Text, int Bx, VerbatimLiteralPattern LitPattern)
{
char quoteChar = LitPattern.QuoteChar;
return(-1);
}
// ------------------------ ScanNextWord -------------------------
// Scans to the next word in the string. ( a word being the text bounded by the
// delimeter and whitespace characters as spcfd in the TextTraits argument )
// Return null when end of string.
public static WordCursor ScanNextWord(
string Text,
WordCursor CurrentWord)
{
BoundedString boundedString = new BoundedString(Text);
WordCursor res = ScanNextWord(boundedString, CurrentWord);
return(res);
}
// ------------------------ ScanFirstWord -------------------------
public static WordCursor ScanFirstWord(
BoundedString InBoundedString, TextTraits InTraits)
{
WordCursor csr = new WordCursor();
csr.Position = RelativePosition.Begin;
csr.TextTraits = InTraits;
WordCursor res = ScanNextWord(InBoundedString, csr);
return(res);
}
/// <summary>
/// calc if the word starting at InBx is part of a path.
/// </summary>
/// <param name="InBoundedString"></param>
/// <param name="InTraits"></param>
/// <param name="InBx"></param>
/// <returns></returns>
private static bool ScanWord_IsolateDelim_IsPathPart(
BoundedString InBoundedString, TextTraits InTraits, int InBx)
{
bool rc = false;
WordCursor csr = InBoundedString.PositionBefore(InBx, InTraits);
csr = ScanNextWord(InBoundedString, csr);
if ((csr.IsPathPart == true))
{
rc = true;
}
return(rc);
}
// ----------------------------------- SetDelim ------------------------------------
public void SetDelim(
BoundedString InBoundedString,
ScanPatternResults InScanResults, DelimClassification InDelimClass)
{
if (InScanResults.IsNotFound == true)
{
mDelim = null;
mDelimBx = -1;
this.DelimClass = DelimClassification.EndOfString;
}
else
{
SetDelim(
InBoundedString, InScanResults.FoundPat.PatternValue, InScanResults.FoundPos,
InDelimClass);
}
}
// --------------------------- ScanWord_IsolateDelim_SetDelimIsWhitespace ----------
private static void ScanWord_IsolateDelim_SetDelimIsWhitespace(
BoundedString InBoundedString, TextTraits InTraits,
WordCursor InOutResults, int InWsIx)
{
// store the actual string of whitespace characters. ( the whitespace can be
// checked later to see if it contains tabs or newlines )
ScanPatternResults spr = ScanNotEqual(
InBoundedString.String, InWsIx, InBoundedString.Ex,
InTraits.WhitespacePatterns);
string delimVlu = spr.ScannedOverString;
InOutResults.SetDelim(
InBoundedString, delimVlu, InWsIx, DelimClassification.Whitespace);
InOutResults.DelimIsWhitespace = true;
}
/// <summary>
/// Scan the bounded string for any of the pattern characters,
/// bypassing quoted strings within the scan space.
/// </summary>
/// <param name="InBounded"></param>
/// <param name="InBx"></param>
/// <param name="InPatternChars"></param>
/// <param name="InQem"></param>
/// <returns></returns>
public static ScanCharResults ScanEqualAny_BypassQuoted(
BoundedString InBounded,
int InBx,
char[] InPatternChars,
QuoteEncapsulation InQem)
{
ScanCharResults res;
int Fx;
char[] patternChars = Arrayer.Concat <char>(InPatternChars, new char[] { '"', '\'' });
int Ix = InBx;
while (true)
{
res = ScanEqualAny(InBounded, Ix, patternChars);
if (res.ResultPos == -1)
{
break;
}
else if (IsOpenQuoteChar(res.ResultChar) == true)
{
Fx = ScanCloseQuote(InBounded, res.ResultPos, InQem);
if (Fx == -1)
{
throw new ApplicationException("End of quoted string not found");
}
else if (Fx == InBounded.Ex)
{
res = new ScanCharResults(-1);
break;
}
else
{
Ix = Fx + 1;
}
}
else
{
break;
}
}
return(res);
}
// ----------------------- ScanWord_CalcStartBx ---------------------------
// calc start position from which to start scan to the next word.
private static int ScanWord_CalcStartBx(
BoundedString BoundedString, WordCursor Word)
{
int Bx;
switch (Word.Position)
{
case RelativePosition.Begin:
Bx = BoundedString.Bx;
break;
case RelativePosition.Before:
Bx = Word.ScanBx;
break;
case RelativePosition.After:
Bx = Word.ScanEx + 1;
break;
case RelativePosition.At:
Bx = Word.ScanEx + 1;
break;
case RelativePosition.End:
Bx = BoundedString.Ex + 1;
break;
case RelativePosition.None:
Bx = -1;
break;
default:
Bx = -1;
break;
}
if (Bx > BoundedString.Ex)
{
Bx = -1;
}
return(Bx);
}
// ------------------------ AdvanceNextWord -------------------------
// Scans to the next word in the string. ( a word being the text bounded by the
// delimeter and whitespace characters as spcfd in the TextTraits argument )
// Return null when end of string.
public static void AdvancexNextWord(
string InString,
WordCursor InOutWordCursor,
TextTraits InTraits)
{
int Bx;
BoundedString boundedString = new BoundedString(InString);
ScanPatternResults spr = null;
// calc scan start position
Bx = ScanWord_CalcStartBx(boundedString, InOutWordCursor);
// empty the word parts of the cursor.
InOutWordCursor.EmptyWordParts();
// advance past whitespace
if (Bx <= boundedString.Ex)
{
Bx = ScanNotEqual(
boundedString.String, Bx, boundedString.Ex,
InTraits.WhitespacePatterns).FoundPos;
}
// got the start of something. scan for the delimeter ( could be the current char )
spr = null;
if (Bx <= boundedString.Ex)
{
spr = ScanWord_IsolateWord(boundedString, Bx, ref InOutWordCursor, InTraits);
}
// depending on the word, isolate and store the delim that follows.
ScanWord_IsolateDelim(boundedString, spr, ref InOutWordCursor, InTraits);
// current word position.
if (InOutWordCursor.ScanEx == -1)
{
InOutWordCursor.Position = RelativePosition.End;
}
else
{
InOutWordCursor.Position = RelativePosition.At;
}
}
// --------------------------- ScanCloseQuote ------------------------------
public static int ScanCloseQuote(
BoundedString InBounded, int InBx, QuoteEncapsulation InQem)
{
char QuoteChar = InBounded.String[InBx];
int cloqIx = -1;
for (int Ix = InBx + 1; Ix <= InBounded.Ex; ++Ix)
{
char ch1 = InBounded.String[Ix];
// using the escape method to enclose quote chars. This means the escape char
// is used to encapsulate other special characters in the quoted string.
// todo: dequote using "QuotedStringTraits" rules.
if ((ch1 == '\\') &&
(InQem == QuoteEncapsulation.Escape) &&
(Ix < InBounded.Ex))
{
++Ix;
}
// quote char enquoted using the "double the char" method.
else if (
(ch1 == QuoteChar) &&
(InQem == QuoteEncapsulation.Double) &&
(Ix < InBounded.Ex) &&
(InBounded.String[Ix + 1] == QuoteChar))
{
++Ix;
}
// found the closing quote char.
else if (ch1 == QuoteChar)
{
cloqIx = Ix;
break;
}
}
return(cloqIx);
}
// ------------------------------ SetDelim ---------------------------------
public WordCursor SetDelim(
BoundedString InBoundedString,
string InDelim, int InDelimBx, DelimClassification InDelimClass)
{
mDelim = InDelim;
mDelimBx = InDelimBx;
this.DelimClass = InDelimClass;
// check if whitespace after the delim.
if ((InDelim != null) &&
(InDelimClass != DelimClassification.Whitespace) &&
(InDelimClass != DelimClassification.EndOfString))
{
int Nx = InDelimBx + InDelim.Length;
if ((Nx <= InBoundedString.Ex) &&
(mTraits.IsWhitespace(InBoundedString, Nx)))
{
mWhitespaceFollowsDelim = true;
}
}
return(this);
}
/// <summary>
/// calc if the
/// </summary>
/// <param name="InBoundedString"></param>
/// <param name="InBx"></param>
/// <returns></returns>
public bool IsPathPartDelim(BoundedString InBoundedString, int InIx)
{
if (InBoundedString.IsOutsideBounds(InIx))
{
return(false);
}
else if (IsPathSepChar(InBoundedString[InIx]) == false)
{
return(false);
}
else if (IsWordChar(InBoundedString, InIx - 1) == true)
{
return(true);
}
else if (IsWordChar(InBoundedString, InIx + 1) == true)
{
return(true);
}
else
{
return(false);
}
}
/// <summary>
/// return the NonWord info of path sep char which is classified as being a
/// path part delimiter ( it could be a division expression symbol )
/// </summary>
/// <param name="InBoundedString"></param>
/// <param name="InIx"></param>
/// <returns></returns>
public ScanPattern GetPathPartDelim(BoundedString InBoundedString, int InIx)
{
ScanPattern pat = null;
if (InBoundedString.IsOutsideBounds(InIx))
{
}
else if (IsPathSepChar(InBoundedString[InIx]) == true)
{
pat = NonWordPatterns.FindPatternAtSubstring(
InBoundedString.String, InIx, InBoundedString.Ex);
// the nonword is a path sep char. but is it a pathPart delim?
// It is if there is a word char before or after the path sep char.
// ex: /abc/efg vs. a = b / c ;
if ((IsWordChar(InBoundedString, InIx - 1) == false) &&
(IsWordChar(InBoundedString, InIx + 1) == false))
{
pat = null;
}
}
return(pat);
}
public bool IsWhitespace(
BoundedString InBoundedString, int InIx)
{
return(IsWhitespace(InBoundedString.String, InIx, InBoundedString.Ex));
}
// ------------------------ ScanNextWord -------------------------
// Scans to the next word in the string. ( a word being the text bounded by the
// delimeter and whitespace characters as spcfd in the TextTraits argument )
// Return null when end of string.
public static WordCursor ScanNextWord(
BoundedString BoundedString,
WordCursor CurrentWord)
{
int Bx;
WordCursor results = null;
ScanPatternResults spr = null;
// stay at the current location.
if (CurrentWord.StayAtFlag == true)
{
if ((CurrentWord.Position != RelativePosition.At) &&
(CurrentWord.Position != RelativePosition.End))
{
throw new ApplicationException("cursor not position at location to stay at");
}
results = new WordCursor(CurrentWord);
results.StayAtFlag = false;
}
else
{
results = new WordCursor()
.SetString(BoundedString.String)
.SetTraits(CurrentWord.TextTraits);
results.VirtualCursor = WordCursor.enumVirtualCursor.None;
// calc scan start position
Bx = ScanWord_CalcStartBx(BoundedString, CurrentWord);
// advance past whitespace
if ((Bx != -1) && (Bx <= BoundedString.Ex))
{
Bx = ScanNotEqual(
BoundedString.String, Bx, BoundedString.Ex,
CurrentWord.TextTraits.WhitespacePatterns).FoundPos;
}
// got the start of something. scan for the delimeter (could be the current char)
spr = null;
DelimClassification sprdc = DelimClassification.None;
if ((Bx != -1) && (Bx <= BoundedString.Ex))
{
spr =
ScanWord_IsolateWord(
BoundedString, Bx, ref results, CurrentWord.TextTraits);
if (spr.IsNotFound == true)
{
sprdc = DelimClassification.EndOfString;
}
else
{
sprdc = spr.FoundPat.DelimClassification;
}
}
if (spr == null)
{
results.Position = RelativePosition.End;
results.SetDelim(BoundedString, null, -1, DelimClassification.EndOfString);
}
else
{
// depending on the word, isolate and store the delim that follows.
// OpenNamedBraced. delim is the open brace char.
if (results.WordClassification == WordClassification.OpenNamedBraced)
{
ScanPatternResults spr2;
spr2 = ScanEqualAny(
BoundedString, Bx, CurrentWord.TextTraits.OpenNamedBracedPatterns);
results.SetDelim(
BoundedString,
spr2.FoundPat.PatternValue,
spr2.FoundPos, DelimClassification.OpenNamedBraced);
}
// OpenContentBraced. word and delim are the same.
else if (results.WordClassification == WordClassification.OpenContentBraced)
{
results.SetDelim(
BoundedString,
results.Word.Value, results.WordBx, DelimClassification.OpenContentBraced);
}
// word is CommentToEnd. delim is end of line.
else if (results.WordClassification == WordClassification.CommentToEnd)
{
results.SetDelim(BoundedString, spr, sprdc);
}
// process the NonWordResults returned by "ScanWord_IsolateWord"
else
{
ScanWord_IsolateDelim(
BoundedString, spr, ref results, CurrentWord.TextTraits);
}
}
// current word position.
if (results.ScanEx == -1)
{
results.Position = RelativePosition.End;
results.SetDelim(BoundedString, null, -1, DelimClassification.EndOfString);
}
else
{
results.Position = RelativePosition.At;
}
}
return(results);
}
// -------------------- ScanWord_IsolateWord ---------------------------
// We have a word starting at InBx. Scan to the end of the word.
// Returns the word in the InOutResults parm.
// Returns the word delim in the return argument.
private static ScanPatternResults ScanWord_IsolateWord(
BoundedString InBoundedString,
int InBx,
ref WordCursor InOutResults,
TextTraits Traits)
{
int Bx, Ix, Lx;
string wordText;
ScanPatternResults spr = null;
Bx = InBx;
char ch1 = InBoundedString.String[Bx];
// is start of a verbatim string literal
if ((Traits.VerbatimLiteralPattern != null) &&
(Traits.VerbatimLiteralPattern.Match(InBoundedString, Bx)))
{
}
// is quoted. the word runs to the closing quote.
else if (IsOpenQuoteChar(ch1) == true)
{
Ix = ScanCloseQuote(InBoundedString.String, Bx, Traits.QuoteEncapsulation);
if ((Ix == -1) || (Ix > InBoundedString.Ex))
{
throw (new ApplicationException(
"Closing quote not found starting at position " +
Bx.ToString() + " in " + InBoundedString.String));
}
Lx = Ix - Bx + 1;
wordText = InBoundedString.String.Substring(Bx, Lx);
InOutResults.SetWord(wordText, WordClassification.Quoted, Bx);
// setup the non word which follows the closing quote.
Bx = Ix + 1;
if (InBoundedString.IsOutsideBounds(Bx))
{
spr = new ScanPatternResults(-1);
}
else
{
// the char that follows the closing quote must be a delim
spr = ScanEqualAny(InBoundedString, Bx, Traits.NonWordPatterns);
if (spr.FoundPos != Bx)
{
throw new ApplicationException(
"invalid char follows close quote at pos " + Ix.ToString() +
" in " + Stringer.Head(InBoundedString.String, 80));
}
}
}
else
{
// Scan the string for any of the non word patterns spcfd in Traits.
DelimClassification sprdc = DelimClassification.None;
spr = ScanEqualAny(InBoundedString, Bx, Traits.NonWordPatterns);
if (spr.IsNotFound == false)
{
sprdc = spr.FoundPat.DelimClassification;
}
// a quote character within the name. this is an error.
if (sprdc == DelimClassification.Quote)
{
throw new ApplicationException(
"quote character immed follows name character at position " +
spr.FoundPos.ToString() + " in " + InBoundedString.String);
}
// no delim found. all word to the end of the string.
else if (spr.IsNotFound)
{
wordText = InBoundedString.Substring(Bx);
InOutResults.SetWord(wordText, WordClassification.Identifier, InBx);
}
// found an open named brace char
else if (sprdc == DelimClassification.OpenNamedBraced)
{
ScanWord_IsolateWord_Braced(
InBoundedString, Bx, spr, ref InOutResults, Traits);
}
// delim is same position as the word. so there is no word, only a delim.
else if (spr.FoundPos == InBx)
{
if (Scanner.IsOpenBraced(sprdc))
{
InOutResults.SetWord(
spr.FoundPat.PatternValue, WordClassification.OpenContentBraced, Bx,
spr.FoundPat.LeadChar);
}
// start of CommentToEnd comment. This is a word, not a delim. Find the
// end of the comment and set the delim to that end position.
else if (sprdc == DelimClassification.CommentToEnd)
{
spr = ScanWord_IsolateWord_CommentToEnd(
InBoundedString, spr.FoundPos, ref InOutResults, Traits);
}
else
{
InOutResults.SetNullWord();
}
}
// we have a word that ends with a delim.
else
{
Lx = spr.FoundPos - InBx;
wordText = InBoundedString.Substring(InBx, Lx);
InOutResults.SetWord(wordText, WordClassification.Identifier, InBx);
}
}
// return ScanPatternResults of the delim that ends the word.
return(spr);
}
// -------------------- ScanWord_IsolateDelim ---------------------------
private static void ScanWord_IsolateDelim(
BoundedString InBoundedString,
ScanPatternResults InPatternResults,
ref WordCursor InOutResults,
TextTraits InTraits)
{
// did not find a nonword char. must have hit end of string.
if (InPatternResults.IsNotFound)
{
InOutResults.DelimClass = DelimClassification.EndOfString;
}
// we have a delimiter of some kind.
else
{
DelimClassification sprdc = InPatternResults.FoundPat.DelimClassification;
InOutResults.WhitespaceFollowsWord = false;
InOutResults.WhitespaceFollowsDelim = false;
InOutResults.DelimIsWhitespace = false;
// the delim is a hard delim ( not whitespace )
if (sprdc != DelimClassification.Whitespace)
{
// Want the openContent brace to be processed as a standalone word. Use
// virtual whitespace so the word that this open brace is the delim of will
// have what appears to be a whitespace delim. Then the following word will
// be the standalone open content brace char.
if (sprdc == DelimClassification.OpenContentBraced)
{
InOutResults.SetDelim(
InBoundedString,
null, InPatternResults.FoundPos, DelimClassification.VirtualWhitespace);
}
else
{
// delim is either as classified in the collection of NonWords or is
// a PathPart delim.
ScanPattern pat = InTraits.GetPathPartDelim(
InBoundedString, InPatternResults.FoundPos);
if (pat != null)
{
InOutResults.SetDelim(
InBoundedString,
pat.PatternValue,
InPatternResults.FoundPos,
DelimClassification.PathSep);
}
else
{
InOutResults.SetDelim(
InBoundedString,
InPatternResults.FoundPat.PatternValue,
InPatternResults.FoundPos,
sprdc);
}
}
}
// whitespace immed follows the word text
else
{
ScanWord_IsolateDelim_WhitespaceFollows(
InBoundedString, InPatternResults, ref InOutResults, InTraits);
}
}
}
/// <summary>
/// The delim after the word is whitspace. If what follows the whitespace
/// is a delim char, then this whitspace is disregarded as the delim, and
/// the delim is what follows the whitespace.
/// </summary>
/// <param name="InBoundedString"></param>
/// <param name="InNonWordResults"></param>
/// <param name="InOutResults"></param>
/// <param name="InTraits"></param>
private static void ScanWord_IsolateDelim_WhitespaceFollows(
BoundedString InBoundedString,
ScanPatternResults InPatternResults,
ref WordCursor InOutResults,
TextTraits InTraits)
{
InOutResults.WhitespaceFollowsWord = true;
ScanPattern nwPat = null;
// Look for hard delim after the ws.
ScanPatternResults scanResults =
ScanNotEqual(
InBoundedString.String, InPatternResults.FoundPos,
InBoundedString.Ex, InTraits.WhitespacePatterns);
// look that the char after the ws is a nonword.
if (scanResults.FoundPos != -1)
{
nwPat = InTraits.NonWordPatterns.FindPatternAtSubstring(
InBoundedString, scanResults.FoundPos);
}
// the char after the whitespace is a non word (delim) char.
if (nwPat != null)
{
DelimClassification nwdc = nwPat.DelimClassification;
// is the delim actually a sep char in a path name.
// so the delim is the whitespace.
if (InTraits.IsPathPartDelim(InBoundedString, scanResults.FoundPos))
{
ScanWord_IsolateDelim_SetDelimIsWhitespace(
InBoundedString, InTraits, InOutResults, InPatternResults.FoundPos);
}
// is a content open brace char. delim stays as whitespace because
// content braces are considered standalone words.
else if (nwPat.DelimClassification.IsOpenBraced( ))
{
ScanWord_IsolateDelim_SetDelimIsWhitespace(
InBoundedString, InTraits, InOutResults, InPatternResults.FoundPos);
}
// is a quote char. the quoted string is considered a word.
else if (nwdc == DelimClassification.Quote)
{
ScanWord_IsolateDelim_SetDelimIsWhitespace(
InBoundedString, InTraits, InOutResults, InPatternResults.FoundPos);
}
// is an actual delim.
else
{
InOutResults.SetDelim(
InBoundedString,
nwPat.PatternValue, scanResults.FoundPos, nwdc);
}
}
// the whitespace char is the delim of record.
else
{
ScanWord_IsolateDelim_SetDelimIsWhitespace(
InBoundedString, InTraits, InOutResults, InPatternResults.FoundPos);
}
}