private void Assign(NonTerminal head, Terminal term, Production production)
{
if (predictiveParseTable[head][term].HasValue)
throw new InvalidGrammarException("Grammar is not LL(1)");
predictiveParseTable[head][term] = production;
}
public void CorrectLineAndColumnNumbers()
{
var input = "Hello World!\nSecond line\r\nFoo";
MemoryStream m = new MemoryStream();
var w = new StreamWriter(m);
w.Write(input);
w.Flush();
m.Position = 0;
var word = new Terminal("Word", "\\S+");
var whitespace = new Terminal("Whitespace", " |\n|\r");
var lexer = new Lexer(m, word, whitespace);
Token[] tokens = lexer.ToArray();
Assert.AreEqual(10, tokens.Length);
AssertToken(tokens[0], "Word", 1, 1);
AssertToken(tokens[1], "Whitespace", 1, 6);
AssertToken(tokens[2], "Word", 1, 7);
AssertToken(tokens[3], "Whitespace", 1, 13);
AssertToken(tokens[4], "Word", 2, 1);
AssertToken(tokens[5], "Whitespace", 2, 7);
AssertToken(tokens[6], "Word", 2, 8);
AssertToken(tokens[7], "Whitespace", 2, 12);
AssertToken(tokens[8], "Whitespace", 2, 13);
AssertToken(tokens[9], "Word", 3, 1);
}
public Token(Terminal terminal, string value, int line, int column)
{
this.Terminal = terminal;
this.Value = value;
this.Line = line;
this.Column = column;
}
public void CastBnfTermIntoConcatenationRule()
{
BnfTerm a = new Terminal("a");
ConcatenationRule c = a;
Assert.IsNotNull(c);
}
public void AlternateTerms()
{
BnfTerm a = new Terminal("a");
BnfTerm b = new Terminal("b");
RuleAlternation c = a | b;
Assert.IsNotNull(c);
}
public void ConcatenateTerms()
{
BnfTerm a = new Terminal("a");
BnfTerm b = new Terminal("b");
ConcatenationRule c = a + b;
Assert.IsNotNull(c);
}
public void DoNotMatchAStringNotAtIndexZero()
{
Terminal t = new Terminal("AAA", "AAA");
string aString = "BBBAAA";
string match;
Assert.IsFalse(t.Match(aString, 0, out match));
Assert.IsNull(match);
}
public void MatchAStringNotAtIndexZeroButWithOffset()
{
Terminal t = new Terminal("AAA", "AAA");
string aString = "BBBAAA";
string match;
Assert.IsTrue(t.Match(aString, 3, out match));
Assert.AreEqual("AAA", match);
}
public void MatchAString()
{
Terminal t = new Terminal("AAA", "AAA");
const string aString = "AAABBB";
string match;
Assert.IsTrue(t.Match(aString, 0, out match));
Assert.AreEqual("AAA", match);
}
public void ConcatenationOfNonTerminalAndTerminal()
{
NonTerminal a = new NonTerminal("a");
Terminal b = new Terminal("b");
var c = a | b;
Assert.IsNotNull(c);
Assert.AreEqual(2, c.Count);
Assert.IsInstanceOfType(c, typeof(RuleAlternation));
}
private static NonTerminal ConstructGrammar(string openBracket, string closeBracket)
{
Terminal open = new Terminal(Regex.Escape(openBracket));
Terminal close = new Terminal(Regex.Escape(closeBracket));
NonTerminal s = new NonTerminal("S");
NonTerminal sPrime = new NonTerminal("S'");
s.Rules = open + sPrime + close;
sPrime.Rules = s | "a";
return s;
}
private static NonTerminal ConstructGrammar()
{
NonTerminal R = new NonTerminal("R");
NonTerminal S = new NonTerminal("S");
NonTerminal V = new NonTerminal("V");
Terminal id = new Terminal("id", @"([A-Za-z]+)([0-9A-Za-z]*)");
R.Rules = S;
S.Rules = V + "=" + V;
V.Rules = id;
return R;
}
public void InvalidInputStream()
{
var myString = "Hello World!";
MemoryStream m = new MemoryStream();
var w = new StreamWriter(m);
w.Write(myString);
w.Flush();
m.Position = 0;
Terminal singleCharacter = new Terminal("Match a single A", "A");
Lexer t = new Lexer(m, singleCharacter);
Token[] characters = t.ToArray();
}
private static NonTerminal ConstructGrammar(string openBracket, string closeBracket)
{
Terminal open = new Terminal(Regex.Escape(openBracket));
Terminal close = new Terminal(Regex.Escape(closeBracket));
NonTerminal start = new NonTerminal("start");
NonTerminal wbbList = new NonTerminal("wbb List");
NonTerminal openBracketPlusStuff = new NonTerminal("( + L|)");
NonTerminal stuffPlusClose = new NonTerminal("L + ) | )");
start.Rules = openBracketPlusStuff + wbbList;
wbbList.Rules = openBracketPlusStuff + wbbList | "";
openBracketPlusStuff.Rules = open + stuffPlusClose;
stuffPlusClose.Rules = wbbList + close | close;
return start;
}
private static NonTerminal ConstructGrammar()
{
NonTerminal expression = new NonTerminal("expression");
NonTerminal term = new NonTerminal("term");
NonTerminal factor = new NonTerminal("factor");
Terminal number = new Terminal("number", @"[0-9]+(\.[0-9]+)?");
Terminal multiply = new Terminal("*", Regex.Escape("*"));
Terminal divide = new Terminal("/", Regex.Escape("/"));
Terminal add = new Terminal("+", Regex.Escape("+"));
Terminal subtract = new Terminal("-", Regex.Escape("-"));
Terminal openBracket = new Terminal("(", Regex.Escape("("));
Terminal closeBracket = new Terminal(")", Regex.Escape(")"));
expression.Rules = expression + add + term | expression + subtract + term | term;
term.Rules = term + multiply + factor | term + divide + factor | factor;
factor.Rules = openBracket + expression + closeBracket | number;
return expression;
}
public void ConstructAGrammar()
{
NonTerminal op = new NonTerminal("Operator");
NonTerminal expr = new NonTerminal("Expression");
Terminal number = new Terminal("Number", @"\b\d+\b");
Terminal plus = new Terminal("Plus", @"\+");
Terminal multiply = @"\*";
op.Rules = plus | multiply;
expr.Rules = number + op + expr;
Terminal whitespace = new Terminal("Whitespace", " |\n|\r", true);
Grammar g = new Grammar(expr, whitespace);
Assert.AreEqual(3, g.Terminals.Count());
Assert.AreEqual(3, g.NonTerminals.Count()); //Although the grammar only specifies 2 Nonterminals, grammar creates 1 internally for the root
Lexer lexer = g.CreateLexer("1 + 2 * 3");
Assert.AreEqual(5, lexer.Count());
}
public void ConstructTerminal()
{
Terminal t = new Terminal("Test Terminal", ".*");
}
public void IsWhitespaceIgnored()
{
var input = "Hello World!\nSecond line\r\nFoo";
MemoryStream m = new MemoryStream();
var w = new StreamWriter(m);
w.Write(input);
w.Flush();
m.Position = 0;
var letter = new Terminal("Letter", "\\S");
var whitespace = new Terminal("Whitespace", " |\n|\r", true);
var lexer = new Lexer(m, letter, whitespace);
foreach (var match in lexer)
Assert.IsFalse(match.Terminal.IsIgnored);
}
public void CastTerminalIntoConcatenationRule()
{
ConcatenationRule a = new Terminal("aaa");
Assert.IsNotNull(a);
}
public void ReadATokenStream()
{
var myString = "Hello World!";
MemoryStream m = new MemoryStream();
var w = new StreamWriter(m);
w.Write(myString);
w.Flush();
m.Position = 0;
Terminal singleCharacter = new Terminal("Match a single character", ".");
Lexer t = new Lexer(m, singleCharacter);
Token[] characters = t.ToArray();
Assert.AreEqual(myString.Length, characters.Length);
for (int i = 0; i < myString.Length; i++)
Assert.AreEqual(myString[i].ToString(), characters[i].Value);
}
public void ConcatenationOfTypedTerminals()
{
Terminal a = new Terminal("a");
Terminal b = new Terminal("b");
var c = a + b;
Assert.IsNotNull(c);
Assert.AreEqual(2, c.Count);
Assert.IsInstanceOfType(c, typeof(ConcatenationRule));
}
public void ConcatenationOfStringAndTerminal()
{
Terminal b = new Terminal("b");
var c = "a" | b;
Assert.IsNotNull(c);
Assert.AreEqual(2, c.Count);
Assert.IsInstanceOfType(c, typeof(RuleAlternation));
}
public void TerminalPlusTerminalReturnsRule()
{
Terminal a = new Terminal("a");
Terminal b = new Terminal("b");
ConcatenationRule operatorResult = a + b;
ConcatenationRule methodResult = Terminal.Plus(a, b);
Assert.IsNotNull(operatorResult);
Assert.IsNotNull(methodResult);
Assert.AreEqual(operatorResult, methodResult);
}
public void ConcatenationOfTerminalAndString()
{
Terminal a = new Terminal("a");
var c = a | "b";
Assert.IsNotNull(c);
Assert.AreEqual(2, c.Count);
Assert.IsInstanceOfType(c, typeof(RuleAlternation));
}
