public void NormalizeTest()
{
//
// Using reflection, verify for all keyword constants
//
FieldInfo[] keywordFields = typeof(VBKeyword).GetFields(
BindingFlags.Static | BindingFlags.Public);
foreach (FieldInfo keyword in keywordFields)
{
if (keyword.FieldType == typeof(string))
{
string fieldValue = (string)keyword.GetValue(null);
string lower = fieldValue.ToLower();
string normalized = VBKeyword.Normalize(lower);
Assert.AreEqual(
fieldValue, normalized, "Normalize did not correct casing for {0}", fieldValue);
}
}
//
// Normalize a non-VB keyword
//
Assert.AreEqual("Testit", VBKeyword.Normalize("testit"));
}
private void TestKeyword(string keyword, VBKeyword keywordType)
{
TestTokenizer(keyword, new VBSymbol(0, 0, 0, keyword, VBSymbolType.Keyword)
{
Keyword = keywordType
});
}
protected bool Optional(VBKeyword keyword)
{
if (At(keyword))
{
AcceptAndMoveNext();
return(true);
}
return(false);
}
protected void HandleExitOrContinue(VBKeyword keyword)
{
Assert(VBSymbolType.Keyword);
Debug.Assert(CurrentSymbol.Keyword == VBKeyword.Continue || CurrentSymbol.Keyword == VBKeyword.Exit);
// Accept, read whitespace and look for the next keyword
AcceptAndMoveNext();
AcceptWhile(VBSymbolType.WhiteSpace);
// If this is the start keyword, skip it and continue (to avoid starting a nested statement block)
Optional(keyword);
}
protected virtual Func <bool> EndTerminatedStatement(
VBKeyword keyword,
bool supportsExit,
bool supportsContinue
)
{
return(EndTerminatedStatement(
keyword,
supportsExit,
supportsContinue,
blockName: keyword.ToString()
));
}
protected virtual Func <bool> KeywordTerminatedStatement(VBKeyword start, VBKeyword terminator, bool supportsExit, bool supportsContinue)
{
return(() =>
{
using (PushSpanConfig(StatementBlockSpanConfiguration(new StatementCodeGenerator())))
{
SourceLocation blockStart = CurrentLocation;
Assert(start);
AcceptAndMoveNext();
while (!EndOfFile)
{
VBSymbol lastWhitespace = AcceptWhiteSpaceInLines();
if (IsAtEmbeddedTransition(allowTemplatesAndComments: true, allowTransitions: true))
{
HandleEmbeddedTransition(lastWhitespace);
}
else
{
Accept(lastWhitespace);
if ((supportsExit && At(VBKeyword.Exit)) || (supportsContinue && At(VBKeyword.Continue)))
{
HandleExitOrContinue(start);
}
else if (At(start))
{
// Parse nested statement
KeywordTerminatedStatement(start, terminator, supportsExit, supportsContinue)();
}
else if (At(terminator))
{
AcceptUntil(VBSymbolType.NewLine);
Optional(VBSymbolType.NewLine);
Span.EditHandler.AcceptedCharacters = AcceptedCharacters.AnyExceptNewline;
return false;
}
else if (!EndOfFile)
{
AcceptAndMoveNext();
}
}
}
Context.OnError(blockStart,
RazorResources.ParseError_BlockNotTerminated,
start, terminator);
return false;
}
});
}
public void IsVBKeywordTest()
{
//
// Using reflection, verify that all string constants are determined
// to be keywords.
//
FieldInfo[] wordFields = typeof(VBSymbol).GetFields(
BindingFlags.Static | BindingFlags.Public);
foreach (FieldInfo wordField in wordFields)
{
if (wordField.FieldType == typeof(string))
{
string fieldValue = (string)wordField.GetValue(null);
Assert.IsTrue(VBKeyword.IsVBKeyword(fieldValue), "Field value should be considered a VB keyword.");
}
}
Assert.IsFalse(VBKeyword.IsVBKeyword("Test"));
Assert.IsFalse(VBKeyword.IsVBKeyword("unknown"));
Assert.IsFalse(VBKeyword.IsVBKeyword("Find"));
Assert.IsFalse(VBKeyword.IsVBKeyword(string.Empty));
Assert.IsFalse(VBKeyword.IsVBKeyword(null));
}
protected virtual Func <bool> EndTerminatedStatement(VBKeyword keyword, bool supportsExit, bool supportsContinue, string blockName)
{
return(() =>
{
using (PushSpanConfig(StatementBlockSpanConfiguration(new StatementCodeGenerator())))
{
SourceLocation blockStart = CurrentLocation;
Assert(keyword);
AcceptAndMoveNext();
while (!EndOfFile)
{
VBSymbol lastWhitespace = AcceptWhiteSpaceInLines();
if (IsAtEmbeddedTransition(allowTemplatesAndComments: true, allowTransitions: true))
{
HandleEmbeddedTransition(lastWhitespace);
}
else
{
Accept(lastWhitespace);
if ((supportsExit && At(VBKeyword.Exit)) || (supportsContinue && At(VBKeyword.Continue)))
{
HandleExitOrContinue(keyword);
}
else if (At(VBKeyword.End))
{
AcceptAndMoveNext();
AcceptVBSpaces();
if (At(keyword))
{
AcceptAndMoveNext();
if (!Context.DesignTimeMode)
{
Optional(VBSymbolType.NewLine);
}
Span.EditHandler.AcceptedCharacters = AcceptedCharacters.None;
return false;
}
}
else if (At(keyword))
{
// Parse nested statement
EndTerminatedStatement(keyword, supportsExit, supportsContinue)();
}
else if (!EndOfFile)
{
AcceptAndMoveNext();
}
}
}
Context.OnError(blockStart,
RazorResources.ParseError_BlockNotTerminated,
blockName,
// This is a language keyword, so it does not need to be localized
String.Concat(VBKeyword.End, " ", keyword));
return false;
}
});
}
protected bool At(VBKeyword keyword)
{
return(At(VBSymbolType.Keyword) && CurrentSymbol.Keyword == keyword);
}
protected void Assert(VBKeyword keyword)
{
Debug.Assert(CurrentSymbol.Type == VBSymbolType.Keyword && CurrentSymbol.Keyword == keyword);
}
protected void MapKeyword(VBKeyword keyword, Func <bool> action)
{
_keywordHandlers[keyword] = action;
Keywords.Add(keyword.ToString());
}
private void TestKeyword(string keyword, VBKeyword keywordType)
{
TestTokenizer(keyword, new VBSymbol(0, 0, 0, keyword, VBSymbolType.Keyword) { Keyword = keywordType });
}
