public void OrTokenTest()
{
LexicalAnalyzer lexer = new LexicalAnalyzer("or");
TokenType token = lexer.MoveNext();
Assert.AreEqual(TokenType.Or, token);
Assert.AreEqual("or", lexer.Current);
}
public void LeftParenthesisTest()
{
LexicalAnalyzer lexer = new LexicalAnalyzer("(");
TokenType token = lexer.MoveNext();
Assert.AreEqual(TokenType.LeftParenthesis, token);
Assert.AreEqual("(", lexer.Current);
}
public void NotTokenTest()
{
LexicalAnalyzer lexer = new LexicalAnalyzer("not");
TokenType token = lexer.MoveNext();
Assert.AreEqual(TokenType.Not, token);
Assert.AreEqual("not", lexer.Current);
}
public void AndTokenTest()
{
LexicalAnalyzer lexer = new LexicalAnalyzer("and");
TokenType token = lexer.MoveNext();
Assert.AreEqual(TokenType.And, token);
Assert.AreEqual("and", lexer.Current);
}
public void IdentityTokenTest()
{
LexicalAnalyzer lexer = new LexicalAnalyzer("i:user1");
TokenType token = lexer.MoveNext();
Assert.AreEqual(TokenType.Identity, token);
Assert.AreEqual("i:", lexer.Current);
}
public void IdentityTokenTest()
{
LexicalAnalyzer lexer = new LexicalAnalyzer("i:user1");
TokenType token = lexer.MoveNext();
Assert.AreEqual(TokenType.Identity, token);
Assert.AreEqual("i:", lexer.Current);
}
public void LeftParenthesisTest()
{
LexicalAnalyzer lexer = new LexicalAnalyzer("(");
TokenType token = lexer.MoveNext();
Assert.AreEqual(TokenType.LeftParenthesis, token);
Assert.AreEqual("(", lexer.Current);
}
public void NotTokenTest()
{
LexicalAnalyzer lexer = new LexicalAnalyzer("not");
TokenType token = lexer.MoveNext();
Assert.AreEqual(TokenType.Not, token);
Assert.AreEqual("not", lexer.Current);
}
public void OrTokenTest()
{
LexicalAnalyzer lexer = new LexicalAnalyzer("or");
TokenType token = lexer.MoveNext();
Assert.AreEqual(TokenType.Or, token);
Assert.AreEqual("or", lexer.Current);
}
public void AndTokenTest()
{
LexicalAnalyzer lexer = new LexicalAnalyzer("and");
TokenType token = lexer.MoveNext();
Assert.AreEqual(TokenType.And, token);
Assert.AreEqual("and", lexer.Current);
}
public void RoleTokenTest()
{
LexicalAnalyzer lexer = new LexicalAnalyzer("r:role1");
TokenType token = lexer.MoveNext();
Assert.AreEqual(TokenType.Role, token);
Assert.AreEqual("r:", lexer.Current);
}
public AnalyzerLEDEER(string xsentences)
{
//Set sentencias
sentences = xsentences;
//Construir análisis
lexan = new LexicalAnalyzer(); //Analizador léxico
synan = new SyntaxAnalyzer(lexan.createTableSymbol(sentences)); //Crear tabla de símbolo
}
/// <summary>
/// Parses the the specified expression into a
/// <see cref="BooleanExpression"/>.
/// </summary>
/// <param name="expression">An expression.</param>
/// <returns>A <see cref="BooleanExpression"/>
/// object that is the root of the parse tree.</returns>
public BooleanExpression Parse(string expression)
{
this.lexer = new LexicalAnalyzer(expression);
this.MoveNext();
BooleanExpression c = this.ParseOrOperator();
this.AssertTokenType(TokenType.EndOfFile);
return c;
}
public void QuotedStringTest()
{
const string tokenString = "\"Quoted string\"";
LexicalAnalyzer lexer = new LexicalAnalyzer(tokenString);
TokenType token = lexer.MoveNext();
Assert.AreEqual(TokenType.QuotedString, token);
Assert.AreEqual(tokenString, lexer.Current);
}
public void TestIsLiteral()
{
Assert.AreEqual(true, LexicalAnalyzer.isLiteral("\"hoi dit is een string\""));
Assert.AreEqual(true, LexicalAnalyzer.isLiteral("5.1234"));
Assert.AreEqual(true, LexicalAnalyzer.isLiteral("3"));
Assert.AreEqual(true, LexicalAnalyzer.isLiteral("true"));
Assert.AreEqual(true, LexicalAnalyzer.isLiteral("false"));
}
public void QuotedStringTest()
{
const string tokenString = "\"Quoted string\"";
LexicalAnalyzer lexer = new LexicalAnalyzer(tokenString);
TokenType token = lexer.MoveNext();
Assert.AreEqual(TokenType.QuotedString, token);
Assert.AreEqual(tokenString, lexer.Current);
}
private static void Case1(string fileName)
{
var hello = File.Open(fileName, FileMode.Open);
var lexicalAnalyzer = new LexicalAnalyzer(hello);
var tokens = lexicalAnalyzer.GetTokens(200);
Console.WriteLine(tokens.Length);
hello.Close();
}
public Tree <CellBase> ParseOne(LexicalAnalyzer theAnalyzer)
{
theAnalyzer.GoToNextToken(myKeyword);
if (theAnalyzer.Token.Length == 0)
{
return(null);
}
return(ParseElement(theAnalyzer));
}
public void TestSimpleGrouping()
{
List <string> control = new List <string> {
@"[L]", @"\", @"[T]"
};
List <string> test = LexicalAnalyzer.GroupConversionTokens(@"([L])\([T])");
CollectionAssert.AreEqual(test, control);
}
static void Main(string[] args)
{
ILexicalAnalyzer lexicalAnalyzer = new LexicalAnalyzer();
ITranspiler transpiler = new Transpiler(lexicalAnalyzer);
transpiler.Transpile(Directory.GetCurrentDirectory() + @"\Program.vm");
Console.ReadLine();
}
public void EofTokenTest()
{
LexicalAnalyzer lexer = new LexicalAnalyzer(String.Empty);
lexer.MoveNext();
TokenType token = lexer.MoveNext();
Assert.AreEqual(TokenType.EndOfFile, token);
}
public ByteCodeWriter(LexicalAnalyzer lexer)
{
// Bytecode size must not change (won't be able to read saved compiled data)
Debug.Assert(sizeof(OpCode) == sizeof(Int32));
ByteCodeEntries = new List <ByteCodeEntry>();
Counters = new List <int>();
Counters.Add(0);
Lexer = lexer ?? throw new ArgumentNullException(nameof(lexer));
}
public Compiler(LexicalAnalyzer lexicalAnalyzer,
SyntaxAnalyzer syntaxAnalyer,
SemanticsAnalyzer semanticsAnalyzer,
ObjectCodeGenerator objCodeGenerator)
{
this._lexicalAnalyzer = lexicalAnalyzer;
this._syntaxAnalyer = syntaxAnalyer;
this._semanticsAnalyer = semanticsAnalyzer;
this._objCodeGenerator = objCodeGenerator;
}
/// <summary>
/// 字句分割
/// "[1] あ [2] いうえ "を"[1]"," ", "あ"," ","[2]"," ","いうえ"," "に分割
/// </summary>
/// <param name="st"></param>
/// <returns></returns>
private static List <string> lex(StringStream st)
{
var strs = new List <string>();
var state = 0;
var startIndex = 0;
VoidMethod reduce = delegate
{
if (st.CurrentPosition == startIndex)
{
return;
}
var length = st.CurrentPosition - startIndex;
strs.Add(st.Substring(startIndex, length));
startIndex = st.CurrentPosition;
};
while (!st.EOS)
{
if (st.Current == '[')
{
if (state == 1) //"["内部
{
goto unanalyzable;
}
reduce();
state = 1;
st.ShiftNext();
}
else if (st.Current == ']')
{
if (state != 1) //"["外部
{
goto unanalyzable;
}
st.ShiftNext();
reduce();
state = 0;
}
else if (state == 0 && LexicalAnalyzer.IsWhiteSpace(st.Current))
{
reduce();
LexicalAnalyzer.SkipAllSpace(st);
reduce();
}
else
{
st.ShiftNext();
}
}
reduce();
return(strs);
unanalyzable:
return(null);
}
public string Render(string paragraph)
{
var analyzer = new LexicalAnalyzer();
var tokens = analyzer.Analyze(paragraph);
var parser = new TokenParser(tokens, paragraph);
var tags = parser.Parse();
var tagInserter = new TagInserter();
var HTMLtext = tagInserter.Insert(paragraph, tags);
return(HTMLtext);
}
private static void Case2(string fileName)
{
var hello = File.Open(fileName, FileMode.Open);
var lexicalAnalyzer = new LexicalAnalyzer(hello);
while (!lexicalAnalyzer.IsEnded)
{
Console.WriteLine(lexicalAnalyzer.GetNextToken());
}
hello.Close();
}
/// <summary>
/// Initializes a new instance of the <see cref="SyntacticAnalyzer"/> class with the specified <see cref="LexicalAnalyzer"/>.
/// </summary>
/// <param name="lexical">The lexical analyzer.</param>
public SyntacticAnalyzer(LexicalAnalyzer lexical)
{
if (lexical == null)
{
throw new ArgumentNullException(nameof(lexical));
}
_lexical = lexical;
_symbolTable = new VectorSymbolTable();
_codeGenerator = new CodeGenerator();
}
private void Button_Click(object sender, RoutedEventArgs e)
{
try
{
Stopwatch s1 = new Stopwatch();
s1.Start();
var textToTest = txtXml.Text;
var size = System.Text.ASCIIEncoding.ASCII.GetByteCount(textToTest);
if (size > 1024 * 100)
{
throw new Exception();
}
// MessageBox.Show(size.ToString() + " bytes");
LexicalAnalyzer lexicalAnalyzer = new LexicalAnalyzer();
Tokens = lexicalAnalyzer.FindTokensInText(textToTest.Trim());
this.DataGrid1.ItemsSource = Tokens;
SyntaxAnalyzerPDA syntaxAnalyzer = new SyntaxAnalyzerPDA();
var valid = syntaxAnalyzer.Validate(Tokens);
if (valid)
{
s1.Stop();
MessageBox.Show("Yes, valid - " + s1.ElapsedMilliseconds.ToString() + "ms");
}
else
{
MessageBox.Show("No, invalid");
}
}
catch (Exception ex)
{
var x = ex;
MessageBox.Show("Error, Invalid");
}
// textToTest = textToTest.Replace(" ", string.Empty);
// [LEXER] 1. get each character as a lexeme
// [LEXER] 2. based on each lexeme, deterministically produce a token based on the rules (or grammar) of each lexeme
// 2.1, each lexeme is a non-terminal, which can be further evaluated/derived until it becomes a terminal. when it has been exhaustively derived, we will consider that as a token
// For example for the simple xml <course name="automata"/>,
// when we read the "<" opening tag, that's already one token because sigma will always point to an opening tag,
// when we read the "c" in "course", we will keep reading "o", "u", "r", "s", "e" until the next space, and treat the "course" string as one token.
// when we read the "name" that's a token
// when we read "=", that's a token
// when we read the double quotes (") that's a token"
// etc.
// 3. When we are traversing the string and figuring out the tokens, we look at a dictionary that stores key-value pairs for each token and its terminator. a
// 3.1 For example, for the "<" token, the dictionary can contain the "/>" terminator for self-closing tags
// 3.2 For the double quotes, the dictionary can contain double quotes to enclose attribute values
// [SYNTAX/PARSER] 4. As we are identifying tokens, push it to a stack, and if we encounter a terminator token, we will pop the token in the top of stack which the terminator terminates.
// 4.1 we are guaranteed that the item at the top of the stack will always terminate first if it is a valid XML. if not, then the xml is invalid. If the stack becomes empty and there are no more tokens, then the XML is accepted
}
private void LexicalAnalyzerItem_Click(object sender, EventArgs e)
{
LexicalAnalyzer lexicalAnalyzer = new LexicalAnalyzer(this.CodeTextBox.Text);
lexicalAnalyzer.Analyses(out tokenList, out errorList);
int record_mouse = CodeTextBox.SelectionStart;
ColorWord();
CodeTextBox.Select(record_mouse, record_mouse);
PrintResult(tokenList, errorList);
}
private void CheckVariablesUsage()
{
LexicalAnalyzer lexAnalyzer = new LexicalAnalyzer();
SyntaxAnalyzer syntaxAnalyzer;
foreach (Transition trans in TransitionsList)
{
if (trans is SimpleTransition strans)
{
lexAnalyzer.Source = strans.Condition;
syntaxAnalyzer = new SyntaxAnalyzer(lexAnalyzer, VariableCollection.GetConditionDictionary(trans.OwnerDraw.OwnerSheet).Keys.ToList());
foreach (SyntaxToken token in syntaxAnalyzer.Tokens)
{
if (token.Qualifier != SyntaxToken.Qualifiers.Correct)
{
MessagesList.Add(new CheckMessage(CheckMessage.MessageTypes.Error, string.Format("{0}: {1}.", trans.Name, token.ToString()), trans));
}
}
foreach (string outputOperation in strans.OutputsList)
{
string outputName = LexicalRules.GetOutputId(outputOperation);
if (!trans.OwnerDraw.OwnerSheet.Variables.InternalOutputs.Exists(output => output.Name == outputName))
{
MessagesList.Add(new CheckMessage(CheckMessage.MessageTypes.Error, "Output " + outputName + " is not defined in variables list.", trans));
}
}
}
}
foreach (DrawableObject obj in ObjectsTable)
{
if (obj is State state)
{
//state.EnterOutputsList.RemoveAll(str => !state.OwnerDraw.OwnerSheet.Variables.InternalOutputs.Exists(var => var.Name == LexicalAnalyzer.GetId(str)));
foreach (string outputOperation in state.EnterOutputsList)
{
string outputName = LexicalRules.GetOutputId(outputOperation);
if (!state.OwnerDraw.OwnerSheet.Variables.InternalOutputs.Exists(var => var.Name == LexicalAnalyzer.GetId(outputName)))
{
MessagesList.Add(new CheckMessage(CheckMessage.MessageTypes.Error, "Output " + outputName + " is not defined in variables list.", state));
}
}
//state.ExitOutputsList.RemoveAll(str => !state.OwnerDraw.OwnerSheet.Variables.InternalOutputs.Exists(var => var.Name == LexicalAnalyzer.GetId(str)));
foreach (string outputOperation in state.ExitOutputsList)
{
string outputName = LexicalRules.GetOutputId(outputOperation);
if (!state.OwnerDraw.OwnerSheet.Variables.InternalOutputs.Exists(var => var.Name == LexicalAnalyzer.GetId(outputName)))
{
MessagesList.Add(new CheckMessage(CheckMessage.MessageTypes.Error, "Output " + outputName + " is not defined in variables list.", state));
}
}
}
}
}
public void LoadRulesLA_test2()
{
LexicalAnalyzer la = new LexicalAnalyzer();
if (!la.LoadRules(path))
{
Assert.Fail();
}
la.Analyze("=2.5;\n");
Assert.AreEqual(la.data[1].property, "Num");
Assert.AreEqual(la.data[1].value, "2.5");
}
static void Main(string[] args)
{
KeywordHashing keywordHashing = new KeywordHashing(Keyword.keywords);
FileHandler fileHandler = new FileHandler();
StreamReader reader = fileHandler.ReadData();
LexicalAnalyzer lexicalAnalyzer = new LexicalAnalyzer(reader, keywordHashing);
lexicalAnalyzer.PerformAnalysis();
lexicalAnalyzer.print();
}
private void ThompsonToolStripMenuItem_Click(object sender, EventArgs e)
{
RichTextBox richTextBox = tabControl1.SelectedTab.Controls.Cast <RichTextBox>().FirstOrDefault(x => x is RichTextBox);
string content = richTextBox.Text;
indexImage = 0;
images = new List <string>();
if (automataImage.Image != null)
{
automataImage.Image.Dispose();
}
automataImage.Image = null;
indexTable = 0;
tables = new List <string>();
if (tableBox.Image != null)
{
tableBox.Image.Dispose();
}
tableBox.Image = null;
lexicalAnalyzer = new LexicalAnalyzer();
lexicalAnalyzer.Scanner(content);
if (lexicalAnalyzer.ListError.Count() == 0)
{
syntacticAnalyzer = new SyntacticAnalyzer(lexicalAnalyzer.ListToken);
if (syntacticAnalyzer.ListError.Count() == 0)
{
interpreter = new Interpreter(lexicalAnalyzer.ListToken);
images.AddRange(interpreter.RoutesNFA);
if (images.Count > 0)
{
LoadImage(0);
}
tables.AddRange(interpreter.RoutesTables);
if (tables.Count > 0)
{
LoadTable(0);
}
commandLineTextBox.Text = interpreter.ConsoleMessage.ToString();
}
else
{
syntacticAnalyzer.GenerateReports();
}
}
}
private void intelliSense()
{
LexicalAnalyzer lexicalAnalyzer = new LexicalAnalyzer();
RichTextBox richTextBox = tabControl1.SelectedTab.Controls.Cast <RichTextBox>().FirstOrDefault(x => x is RichTextBox);
string content = richTextBox.Text;
lexicalAnalyzer.scanner(content);
foreach (Token item in lexicalAnalyzer.ListToken)
{
if (item.TypeToken.Equals("Reservada Grafica") || item.TypeToken.Equals("Reservada Nombre") ||
item.TypeToken.Equals("Reservada Continente") || item.TypeToken.Equals("Reservada Pais") ||
item.TypeToken.Equals("Reservada Poblacion") || item.TypeToken.Equals("Reservada Saturacion") ||
item.TypeToken.Equals("Reservada Bandera"))
{
wordColor(item.Value, Color.FromArgb(41, 83, 131), richTextBox);
}
}
foreach (Token item in lexicalAnalyzer.ListToken)
{
if (item.TypeToken.Equals("Numero"))
{
wordColor(item.Value, Color.FromArgb(30, 232, 190), richTextBox);
}
}
foreach (Token item in lexicalAnalyzer.ListToken)
{
if (item.TypeToken.Equals("Simbolo Llave Izquierda") || item.TypeToken.Equals("Simbolo Llave Derecha"))
{
wordColor(item.Value, Color.FromArgb(227, 103, 149), richTextBox);
}
}
foreach (Token item in lexicalAnalyzer.ListToken)
{
if (item.TypeToken.Equals("Simbolo Punto y Coma"))
{
wordColor(item.Value, Color.FromArgb(207, 113, 65), richTextBox);
}
}
foreach (Token item in lexicalAnalyzer.ListToken)
{
if (item.TypeToken.Equals("Cadena"))
{
wordColor(item.Value, Color.FromArgb(217, 171, 103), richTextBox);
}
}
}
private void VarDecl(LexicalAnalyzer la)
{
(token, lexeme) = la.GetNextToken();
if (token == "finalt")
{
Type(la);
(token, lexeme) = la.GetNextToken();
if (token == "idt")
{
if (token == "assignOpt")
{
if (token == "numt")
{
if (token == "semit")
{
VarDecl(la);
}
else
{
Console.WriteLine("Expected ; ");
}
}
else
{
Console.WriteLine("Expected num token ");
}
}
else
{
Console.WriteLine("Expected = ");
}
}
else
{
Console.WriteLine("Expected id token ");
}
}
else
{
Type(la);
IdentifierList(la);
(token, lexeme) = la.GetNextToken();
if (token == "semit")
{
VarDecl(la);
}
else
{
Console.WriteLine("Expected ; ");
}
}
}
public BottomUpParser Parse(LexicalAnalyzer lexicalAnalyzer)
{
Current = null;
Stack.Clear();
ParsingNodes.Clear();
TopLevelAST = null;
LexicalAnalyzer = lexicalAnalyzer;
Parse();
return(this);
}
public void TestCodeGenerated()
{
const string expression = "1+2+3";
var lexicalAnalyser = new LexicalAnalyzer(expression, 0);
var syntaxAnalyzer = new SyntaxAnalyzer(lexicalAnalyser);
var node = syntaxAnalyzer.Expression(0);
var fileWriter = new FileWriter("");
var semanticAnalyzer = new SemanticAnalyzer(syntaxAnalyzer);
var codeGenerator = new CodeGenerator(semanticAnalyzer, fileWriter);
codeGenerator.GenerateCode(node);
Assert.True(File.Exists(path) && new FileInfo(path).Length != 0);
}
public List<Tree<CellBase>> Parse(LexicalAnalyzer theAnalyzer) {
var list = new List<Tree<CellBase>>();
Tree<CellBase> first = ParseOne(theAnalyzer);
if (first != null) {
list.Add(first);
List<Tree<CellBase>> rest = Parse(theAnalyzer);
list.AddRange(rest);
if (rest.Count == 0) {
var trailer = theAnalyzer.Trailer;
if (trailer.Length > 0) first.Value.SetAttribute(CellAttribute.Trailer, trailer);
}
}
return list;
}
Tree<CellBase> ParseElement(LexicalAnalyzer theAnalyzer) {
string tag = theAnalyzer.Token;
string leader = theAnalyzer.Leader;
theAnalyzer.PushEnd("/" + myKeyword);
List<Tree<CellBase>> children = myChildParser.Parse(theAnalyzer);
if (IRequireChildren && children.Count == 0) {
throw new ApplicationException(string.Format("Can't find tag: {0}", myChildParser.Keyword));
}
theAnalyzer.PopEnd();
theAnalyzer.GoToNextToken("/" + myKeyword);
if (theAnalyzer.Token.Length == 0) throw new ApplicationException("expected /" + myKeyword + " tag");
var result = new TreeList<CellBase>(new CellBase(HtmlToText(theAnalyzer.Leader)));
result.Value.SetAttribute(CellAttribute.Body, theAnalyzer.Leader);
result.Value.SetAttribute(CellAttribute.EndTag, theAnalyzer.Token);
if (leader.Length > 0) result.Value.SetAttribute(CellAttribute.Leader, leader);
result.Value.SetAttribute(CellAttribute.StartTag, tag);
foreach (Tree<CellBase> child in children) result.AddBranch(child);
return result;
}
static void Main(string[] args)
{
TokenQueue = new Queue<Token>();
LexicalAnalyzer scanner = new LexicalAnalyzer();
scanner.OpenFile(args[0]);
Token token = new Token();
string output;
try
{
bool done = false;
while (!done)
{
token = scanner.GetNextToken();
if (token.tag != null)
{
output = string.Format("{0,-20} {1,-5} {2,-5} {3}",
token.tag, scanner.line, (scanner.column - token.lexeme.Length - 1),
token.lexeme);
TokenQueue.Enqueue(token);
}
if(token.tag.Equals(Tags.MP_EOF))
{
done = true;
}
}
Parser parser = new Parser(TokenQueue, scanner, args[0]);
parser.SystemGoal();
Console.WriteLine("Program Parsed Correctly");
}
catch(SyntaxException e)
{
Console.WriteLine(e.ErrorMessage);
}
Console.WriteLine("Press Any Key To Exit");
Console.Read();
}
public Tree<CellBase> ParseOne(LexicalAnalyzer theAnalyzer) {
theAnalyzer.GoToNextToken(myKeyword);
if (theAnalyzer.Token.Length == 0) return null;
return ParseElement(theAnalyzer);
}
private void HighlightTokens()
{
this.SelectionStart = 0;
this.SelectionLength = this.Text.Length;
this.SelectionUnderlineColor = UnderlineColor.None;
this.SelectionUnderlineStyle = UnderlineStyle.None;
LexicalAnalyzer lexer = new LexicalAnalyzer(this.Text);
TokenType lastToken = TokenType.Any;
for (TokenType tokenType = lexer.MoveNext(); tokenType != TokenType.EndOfFile; tokenType = lexer.MoveNext())
{
this.SelectionStart = lexer.CurrentMatch.Index;
this.SelectionLength = lexer.CurrentMatch.Length;
switch (tokenType)
{
case TokenType.And:
case TokenType.Or:
case TokenType.Not:
this.SelectionColor = Color.Blue;
break;
case TokenType.Identity:
case TokenType.Role:
this.SelectionColor = Color.Navy;
break;
case TokenType.Word:
case TokenType.QuotedString:
if (lastToken == TokenType.Identity || lastToken == TokenType.Role)
{
this.SelectionColor = Color.Navy;
}
else
{
this.SelectionColor = Color.Black;
}
break;
default:
this.SelectionColor = Color.Black;
break;
}
lastToken = tokenType;
}
}
public void ComplexExpressionTest()
{
string input = "((Role1 And \"Super User\" And Role3) Or Not(Role2)";
LexicalAnalyzer lexer = new LexicalAnalyzer(input);
ArrayList list = new ArrayList();
for (TokenType tokenType = lexer.MoveNext(); tokenType != TokenType.EndOfFile; tokenType = lexer.MoveNext())
{
list.Add(new Item(tokenType, lexer.Current));
}
Item item = (Item)list[0];
Assert.AreEqual(TokenType.LeftParenthesis, item.TokenType);
Assert.AreEqual("(", item.Token);
item = (Item)list[1];
Assert.AreEqual(TokenType.LeftParenthesis, item.TokenType);
Assert.AreEqual("(", item.Token);
item = (Item)list[2];
Assert.AreEqual(TokenType.Word, item.TokenType);
Assert.AreEqual("Role1", item.Token);
item = (Item)list[3];
Assert.AreEqual(TokenType.And, item.TokenType);
Assert.AreEqual("And", item.Token);
item = (Item)list[4];
Assert.AreEqual(TokenType.QuotedString, item.TokenType);
Assert.AreEqual("\"Super User\"", item.Token);
item = (Item)list[5];
Assert.AreEqual(TokenType.And, item.TokenType);
Assert.AreEqual("And", item.Token);
item = (Item)list[6];
Assert.AreEqual(TokenType.Word, item.TokenType);
Assert.AreEqual("Role3", item.Token);
item = (Item)list[7];
Assert.AreEqual(TokenType.RightParenthesis, item.TokenType);
Assert.AreEqual(")", item.Token);
item = (Item)list[8];
Assert.AreEqual(TokenType.Or, item.TokenType);
Assert.AreEqual("Or", item.Token);
item = (Item)list[9];
Assert.AreEqual(TokenType.Not, item.TokenType);
Assert.AreEqual("Not", item.Token);
item = (Item)list[10];
Assert.AreEqual(TokenType.LeftParenthesis, item.TokenType);
Assert.AreEqual("(", item.Token);
item = (Item)list[11];
Assert.AreEqual(TokenType.Word, item.TokenType);
Assert.AreEqual("Role2", item.Token);
item = (Item)list[12];
Assert.AreEqual(TokenType.RightParenthesis, item.TokenType);
Assert.AreEqual(")", item.Token);
Assert.AreEqual(13, list.Count);
}
public List<Tree<CellBase>> Parse(LexicalAnalyzer theAnalyzer) {
var result = new List<Tree<CellBase>>();
ListParser firstChildParser = null;
int firstPosition = int.MaxValue;
foreach (ListParser childParser in myChildParsers) {
int contentPosition = theAnalyzer.FindPosition(childParser.Keyword);
if (contentPosition >= 0 && contentPosition < firstPosition) {
firstPosition = contentPosition;
firstChildParser = childParser;
}
}
if (firstChildParser != null) {
result.Add(firstChildParser.ParseOne(theAnalyzer));
result.AddRange(Parse(theAnalyzer));
}
return result;
}
public void WhitespaceTest()
{
LexicalAnalyzer lexer = new LexicalAnalyzer(" \n\r");
TokenType token = lexer.MoveNext();
Assert.AreEqual(TokenType.EndOfFile, token);
}
public void RoleTokenTest()
{
LexicalAnalyzer lexer = new LexicalAnalyzer("r:role1");
TokenType token = lexer.MoveNext();
Assert.AreEqual(TokenType.Role, token);
Assert.AreEqual("r:", lexer.Current);
}
public void EofTokenTest()
{
LexicalAnalyzer lexer = new LexicalAnalyzer(String.Empty);
lexer.MoveNext();
TokenType token = lexer.MoveNext();
Assert.AreEqual(TokenType.EndOfFile, token);
}
public Сompiler(LexicalAnalyzer lexicalAnalizer)
{
_lexicalAnalizer = lexicalAnalizer;
}