public LexerErrorListener GetLexerErrors(string src)
{
var lexerErrorHandler = new LexerErrorListener();
var inputStream = new AntlrInputStream(src);
var lexer = new WordLangLexer(inputStream);
lexer.AddErrorListener(lexerErrorHandler);
var tokenStream = new CommonTokenStream(lexer);
var tokens = lexer.GetAllTokens();
return(lexerErrorHandler);
}
public Tuple <ParserErrorListener, LexerErrorListener> GetParseErrors(string src)
{
var lexerErrorHandler = new LexerErrorListener();
var inputStream = new AntlrInputStream(src);
var lexer = new WordLangLexer(inputStream);
lexer.AddErrorListener(lexerErrorHandler);
var tokenStream = new CommonTokenStream(lexer);
var parseErrorHandler = new ParserErrorListener();
var parser = new WordLangParser(tokenStream);
parser.AddErrorListener(parseErrorHandler);
var ctx = parser.prog();
return(new Tuple <ParserErrorListener, LexerErrorListener>(parseErrorHandler, lexerErrorHandler));
}
static bool TryExpandMacros(string input, out string output, out IEnumerable <Message> messages)
{
var inputStream = CharStreams.fromstring(input);
var lexer = new GoToLexer(inputStream);
var lexerErrorListener = new LexerErrorListener();
lexer.AddErrorListener(lexerErrorListener);
var expansionMessages = new List <Message>(lexerErrorListener.Messages);
var tokenStream = new CommonTokenStream(lexer);
var parser = new GoToParser(tokenStream);
var parserErrorListener = new ParserErrorListener();
parser.AddErrorListener(parserErrorListener);
var contextSyntaxTree = parser.program();
expansionMessages.AddRange(parserErrorListener.Messages);
var listener = new MacroExpansionListener(tokenStream);
ParseTreeWalker.Default.Walk(listener, contextSyntaxTree);
expansionMessages.AddRange(listener.Messages);
messages = expansionMessages;
if (AreThereErrors(expansionMessages))
{
output = string.Empty;
return(false);
}
var dirtyOutput = listener.RewrittenTokenStream.GetText();
output = dirtyOutput.TrimStart(Environment.NewLine.ToCharArray());
return(true);
}
public static IParseTree GenerateAST(string code, ref List <ErrorDescriptor> errors)
{
var inputStream = new AntlrInputStream(code);
var lexer = new scheme_langLexer(inputStream);
lexer.RemoveErrorListeners();
LexerErrorListener errorListener = new LexerErrorListener(errors);
lexer.AddErrorListener(errorListener);
var tokenStream = new CommonTokenStream(lexer);
var parser = new scheme_langParser(tokenStream);
parser.RemoveErrorListeners();
ParserErrorListener errorListener2 = new ParserErrorListener(errors);
parser.AddErrorListener(errorListener2);
var context = parser.doc();
return(context);
}
private void ParseMenuItem_Click(object sender, RoutedEventArgs e)
{
// Clear logs
var logs = Logs.GetInstance();
logs.Clear();
LogsListBox.Items.Clear();
TokensListBox.Items.Clear();
// Get source code
_sourceCode = SourceCodeTextEditor.Text;
_inputStream = new AntlrInputStream(_sourceCode);
_lexer = new LittleBigCLexer(_inputStream);
// Lexer error listener
var lexerErrorListener = new LexerErrorListener();
_lexer.RemoveErrorListeners();
_lexer.AddErrorListener(lexerErrorListener);
// Recognize tokens
IToken token = _lexer.NextToken();
while (token.Type != LittleBigCLexer.Eof)
{
var vocubalary = LittleBigCLexer.DefaultVocabulary;
TokensListBox.Items.Add(String.Format("{0} : {1}", token.Text, vocubalary.GetSymbolicName(token.Type)));
token = _lexer.NextToken();
}
_lexer.Reset();
var tokenStream = new CommonTokenStream(_lexer);
_parser = new LittleBigCParser(tokenStream);
// Parser error listener
var parserErrorListener = new ParserErrorListener();
_parser.RemoveErrorListeners();
_parser.AddErrorListener(parserErrorListener);
// Parser init
var root = _parser.compilationUnit();
var treeView = new TreeViewControl(root, _parser);
TreePanel.Children.Add(treeView);
// Semantic analyzer
var _newParser = new LittleBigCParser(tokenStream);
var semanticAnalyzer = new Semantic(root);
var scopes = semanticAnalyzer.Scopes;
ScopesListBox.Items.Clear();
foreach (var scope in scopes)
{
ScopesListBox.Items.Add(String.Format("{0} scope", scope.Name));
if (scope.ScopeType != ScopeType.Global)
{
ScopesListBox.Items.Add("\tParameter definitions:");
if (scope.ParameterDefinitions.Count > 0)
{
foreach (var parameter in scope.ParameterDefinitions)
{
ScopesListBox.Items.Add(String.Format("\t\t{0} : {1}", parameter.Key, parameter.Value.VariableType.ToString()));
}
}
}
ScopesListBox.Items.Add("\tVariable definitions:");
if (scope.VariableDefinitions.Count > 0)
{
foreach (var variable in scope.VariableDefinitions)
{
ScopesListBox.Items.Add(String.Format("\t\t{0} : {1}", variable.Key, variable.Value.VariableType.ToString()));
}
}
ScopesListBox.Items.Add("");
}
foreach (var error in semanticAnalyzer.Errors)
{
LogsListBox.Items.Add(error);
}
// Logs
foreach (var log in logs.LogsCollection)
{
LogsListBox.Items.Add(log);
}
// Compiler
if (semanticAnalyzer.Errors.Count == 0 && logs.LogsCollection.Count == 0)
{
var name = "HelloWorld";
var codeGenListener = new CodeGenerationListener(name);
ParseTreeWalker.Default.Walk(codeGenListener, root);
if (codeGenListener.Errors.Count != 0)
{
foreach (var error in codeGenListener.Errors)
{
LogsListBox.Items.Add(error);
}
}
else
{
var modName = String.Format("{0}.exe", name);
Process p = new Process();
p.StartInfo.FileName = @"C:\Program Files (x86)\Microsoft SDKs\Windows\v8.1A\bin\NETFX 4.5.1 Tools\ildasm.exe";
p.StartInfo.Arguments = "/text /nobar \"" + modName;
p.StartInfo.UseShellExecute = false;
p.StartInfo.CreateNoWindow = true;
p.StartInfo.RedirectStandardOutput = true;
p.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
p.Start();
string s = p.StandardOutput.ReadToEnd();
p.WaitForExit();
p.Close();
Process.Start(modName);
SourceCodeTextEditor.Text = s;
}
}
}
public static bool TryAnalyze(
string input,
out string expandedInput,
out ProgramNode program,
out IEnumerable <Message> messages)
{
program = null;
var analysisMessages = new List <Message>();
messages = analysisMessages;
var isExpansionSucceeded = TryExpandMacros(
input,
out string output,
out IEnumerable <Message> expasionMessages);
analysisMessages.AddRange(expasionMessages);
if (isExpansionSucceeded)
{
expandedInput = output;
}
else
{
expandedInput = input;
return(false);
}
var inputStream = CharStreams.fromstring(output);
var lexer = new GoToLexer(inputStream);
var lexerErrorListener = new LexerErrorListener();
lexer.AddErrorListener(lexerErrorListener);
analysisMessages.AddRange(lexerErrorListener.Messages);
var tokenStream = new CommonTokenStream(lexer);
var parser = new GoToParser(tokenStream);
var parserErrorListener = new ParserErrorListener();
parser.AddErrorListener(parserErrorListener);
var contextSyntaxTree = parser.program();
analysisMessages.AddRange(parserErrorListener.Messages);
var listener = new SemanticListener();
ParseTreeWalker.Default.Walk(listener, contextSyntaxTree);
analysisMessages.AddRange(listener.Messages);
if (AreThereErrors(messages))
{
return(false);
}
var abstractSyntaxTreeGenerator = new AbstractSyntaxTreeGenerator();
program = abstractSyntaxTreeGenerator.VisitProgram(contextSyntaxTree) as ProgramNode;
SemanticAnalyzer.Check(program, ref analysisMessages);
if (AreThereErrors(messages))
{
return(false);
}
return(true);
}
