/// <summary>
/// 准备生成代码
/// </summary>
private IParseTree prepareForCodeGen()
{
errorPanel.Errors = null;
textEditor.Errors = null;
String input = textEditor.Text;
if (String.IsNullOrEmpty(input))
{
return(null);
}
var listener = new CMMErrorListener();
ICharStream stream = CharStreams.fromstring(input);
ITokenSource lexer = new ExceptionLexer(stream, listener);
ITokenStream tokens = new CommonTokenStream(lexer);
CMMParser parser = new CMMParser(tokens);
parser.RemoveErrorListeners();
parser.AddErrorListener(listener);
parser.ErrorHandler = new CMMErrorStrategy();
parser.BuildParseTree = true;
IParseTree tree = parser.statements();
//如果出错，转到错误面板并返回null
if (listener.errors.Count != 0)
{
handleCompileTimeError(listener.errors);
return(null);
}
var graph = new ParseTreeGrapher().CreateGraph(tree, CMMParser.ruleNames);
drawTreePanel.Graph = graph;
return(tree);
}
// ReSharper disable once MethodTooLong
private static void Main(string[] args)
{
try
{
LoadApplicationSettings();
//Console.BackgroundColor = _Settings.EditorBackgroundColor;
//Console.ForegroundColor = _Settings.EditorTextColor;
//FillCurrentLineBackground();
var parser = new Parser(with => with.HelpWriter = null);
var parserResult = parser.ParseArguments <Options>(args);
parserResult
.WithParsed(o =>
{
var options = Grammar.ParseOption.None;
var loadGui = false;
var showParseTree = false;
var writeSvg = false;
ISyntaxHighlightingGuide guide = null;
if (o.Tokens)
{
options |= Grammar.ParseOption.Tokens;
}
if (o.Diagnostics)
{
options |= Grammar.ParseOption.Diagnostics;
}
if (o.Trace)
{
options |= Grammar.ParseOption.Trace;
}
if (o.Tree)
{
options |= Grammar.ParseOption.Tree;
showParseTree = true;
}
if (!string.IsNullOrEmpty(o.SvgFileName))
{
writeSvg = true;
options |= Grammar.ParseOption.Tree;
}
if (o.Sll)
{
options |= Grammar.ParseOption.Sll;
}
if (o.Gui)
{
loadGui = true;
options |= Grammar.ParseOption.Tree;
}
var workingDirectory = Environment.CurrentDirectory;
var scanner = new Grammar.Scanner();
var grammar = scanner.LocateGrammar(workingDirectory, o.GrammarName);
if (grammar == null)
{
Console.WriteLine(Resources.GrammarNotFoundErrorMessage, o.GrammarName);
return;
}
// To be used later once syntax highlighting for the console is enabled.
//var guideResult = grammar.LoadSyntaxHighlightingGuide();
//guide = guideResult != null ? guideResult.Item2 : new HeuristicSyntaxHighlightingGuide(_Settings);
string data;
if (!string.IsNullOrEmpty(o.FileName))
{
if (!File.Exists(o.FileName))
{
Console.WriteLine(Resources.FileNotFoundErrorMessage, o.FileName);
return;
}
var encodingToUse = !string.IsNullOrEmpty(o.EncodingName) ? Encoding.GetEncoding(o.EncodingName) : Encoding.Default;
using (var reader = new StreamReader(o.FileName, encodingToUse))
data = reader.ReadToEnd();
}
else
{
//var analyzer = new Analyzer();
var builder = new StringBuilder();
Console.WriteLine(Resources.ReadingFromStandardInputPromptMessage);
var currentLine = Console.CursorTop;
var keepReading = true;
while (keepReading)
{
if (Console.KeyAvailable)
{
while (Console.KeyAvailable)
{
var typed = Console.ReadKey(true);
if ((typed.Modifiers & ConsoleModifiers.Control) == ConsoleModifiers.Control &&
typed.Key == ConsoleKey.Z)
{
Console.Write("^Z");
keepReading = false;
break;
}
if (typed.Key == ConsoleKey.Enter)
{
if (Console.CursorTop == Console.BufferHeight - 1)
{
_ScrollFadeCount++;
}
Console.WriteLine();
FillCurrentLineBackground();
builder.Append("\r\n");
}
else if (typed.Key == ConsoleKey.Tab)
{
var spaces = new string(' ', _Settings.EditorTabLength);
Console.Write(spaces);
builder.Append(spaces);
}
else if (typed.Key == ConsoleKey.Backspace)
{
if (Console.CursorLeft > 0)
{
Console.Write(typed.KeyChar);
Console.Write(' ');
Console.Write(typed.KeyChar);
builder.Remove(builder.Length - 1, 1);
_Cache.FlushTokensForLine(currentLine - (_ScrollFadeCount + 1));
}
}
else
{
Console.Write(typed.KeyChar);
builder.Append(typed.KeyChar);
}
}
//analyzer.Tokenize(grammar, builder.ToString());
//HighlightSyntaxInConsole(currentLine - (_ScrollFadeCount + 1), analyzer, guide);
}
}
Console.WriteLine();
data = builder.ToString();
}
// If tokens are the only option we've received, we don't need to parse
if (options == Grammar.ParseOption.Tokens)
{
DisplayTokens(grammar, data);
return;
}
// Now we attempt to parse, but still handle a lexer-only grammar.
if (grammar.Parser != null)
{
var analyzer = new Analyzer();
var grammarParser = analyzer.BuildParserWithOptions(grammar, data, options);
analyzer.ExecuteParsing(grammarParser, o.RuleName);
if (showParseTree)
{
Console.WriteLine(analyzer.ParserContext.ToStringTree(grammarParser));
}
if (writeSvg)
{
var rules = scanner.GetParserRulesForGrammarParser(grammar.Parser);
var grapher = new ParseTreeGrapher()
{
BackgroundColor = _Settings.GraphNodeBackgroundColor.GetMsAglColor(),
BorderColor = _Settings.GraphNodeBorderColor.GetMsAglColor(),
TextColor = _Settings.GraphNodeTextColor.GetMsAglColor()
};
var graph = grapher.CreateGraph(analyzer.ParserContext, rules.ToList());
graph.LayoutAlgorithmSettings = new SugiyamaLayoutSettings();
GraphRenderer renderer = new GraphRenderer(graph);
renderer.CalculateLayout();
graph.EscapeNodesForSvg();
SvgGraphWriter.Write(graph, o.SvgFileName, null, null, 4);
}
}
else
{
if (options.HasFlag(ParseOption.Tokens))
{
DisplayTokens(grammar, data);
}
if (showParseTree || writeSvg)
{
Console.WriteLine(Resources.GrammarHasNoParserErrorMessage, grammar.GrammarName);
}
if (showParseTree)
{
Console.WriteLine(Resources.UnableToDisplayParseTree);
}
if (writeSvg)
{
Console.WriteLine(Resources.SvgWritingAbortedErrorMessage);
}
}
if (loadGui)
{
LoadGui(data, grammar, o.RuleName);
}
})
.WithNotParsed(errs => DisplayHelp(parserResult, errs));
#if DEBUG
Console.WriteLine(Resources.PressAnyKeyMessage);
Console.ReadKey();
#endif
}
// ReSharper disable once CatchAllClause
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Console.WriteLine(ex.StackTrace);
#if DEBUG
Console.WriteLine(Resources.PressAnyKeyMessage);
Console.ReadKey();
#endif
}
}
