public static void WalkSourceCode(string code, AssemblyBuilder assemblyBuilder) { var inputStream = new AntlrInputStream(code); var lexer = new DaedalusLexer(inputStream); var commonTokenStream = new CommonTokenStream(lexer); var parser = new DaedalusParser(commonTokenStream); ParseTreeWalker.Default.Walk(new DaedalusListener(assemblyBuilder, 0), parser.daedalusFile()); }
public void RunCode(string code, string zenContent) { ZenLoader zenLoader = new ZenLoader(); if (zenLoader.Load(zenContent) != 0) { return; } List <ZenFileNode> zenFileNodes = zenLoader.ZenFileNodes; List <IParseTree> parseTrees = new List <IParseTree>(); List <string> filesPaths = new List <string>(); List <string[]> filesContentsLines = new List <string[]>(); List <HashSet <string> > suppressedWarningCodes = new List <HashSet <string> >(); _syntaxErrorsCount = 0; _syntaxErrorsPerFile = new List <List <SyntaxError> >(); if (code != "") { DaedalusParser parser = Compiler.GetParserForText(code); SyntaxErrorListener syntaxErrorListener = new SyntaxErrorListener(); parser.AddErrorListener(syntaxErrorListener); parseTrees.Add(parser.daedalusFile()); _syntaxErrorsCount += syntaxErrorListener.SyntaxErrors.Count; _syntaxErrorsPerFile.Add(syntaxErrorListener.SyntaxErrors); string[] fileContentLines = code.Split(Environment.NewLine); filesPaths.Add("test.d"); filesContentsLines.Add(fileContentLines); suppressedWarningCodes.Add(SemanticErrorsCollectingVisitor.GetWarningCodesToSuppress(fileContentLines[0])); } if (_syntaxErrorsCount > 0) { for (int i = 0; i < _syntaxErrorsPerFile.Count; ++i) { List <SyntaxError> syntaxErrors = _syntaxErrorsPerFile[i]; if (syntaxErrors.Count > 0) { string filePath = filesPaths[i]; string fileName = Path.GetFileName(filePath); _errorLogger.LogLine(filePath); foreach (SyntaxError syntaxError in syntaxErrors) { string line = filesContentsLines[i][syntaxError.LineNo - 1]; syntaxError.Print(fileName, line, _errorLogger); } } } _errorLogger.LogLine($"{_syntaxErrorsCount} syntax {(_syntaxErrorsCount == 1 ? "error" : "errors")} generated."); return; } SemanticAnalyzer semanticAnalyzer = new SemanticAnalyzer( zenFileNodes, parseTrees, filesPaths, filesContentsLines, suppressedWarningCodes ); semanticAnalyzer.Run(); SymbolTable = semanticAnalyzer.SymbolTable; SemanticErrorsCollectingVisitor semanticErrorsCollectingVisitor = new SemanticErrorsCollectingVisitor(_errorLogger, _strictSyntax, _globallySuppressedCodes); semanticErrorsCollectingVisitor.FilePathDisplayStatus = FilePathDisplayStatus.NeverDisplay; semanticErrorsCollectingVisitor.VisitTree(semanticAnalyzer.AbstractSyntaxTree); int errorsCount = semanticErrorsCollectingVisitor.ErrorsCount; int warningsCount = semanticErrorsCollectingVisitor.WarningsCount; string error = errorsCount == 1 ? "error" : "errors"; string warning = warningsCount == 1 ? "warning" : "warnings"; if (errorsCount > 0) { if (warningsCount > 0) { _errorLogger.LogLine($"{errorsCount} {error}, {warningsCount} {warning} generated."); } else { _errorLogger.LogLine($"{errorsCount} {error} generated."); } return; } if (warningsCount > 0) { _errorLogger.LogLine($"{warningsCount} {warning} generated."); } SymbolUpdatingVisitor symbolUpdatingVisitor = new SymbolUpdatingVisitor(); symbolUpdatingVisitor.VisitTree(semanticAnalyzer.AbstractSyntaxTree); AssemblyBuildingVisitor assemblyBuildingVisitor = new AssemblyBuildingVisitor(semanticAnalyzer.SymbolTable); assemblyBuildingVisitor.VisitTree(semanticAnalyzer.AbstractSyntaxTree); }
public bool CompileFromSrc( string srcFilePath, bool compileToAssembly, bool verbose = true, bool generateOutputUnits = true ) { var absoluteSrcFilePath = Path.GetFullPath(srcFilePath); try { string[] paths = SrcFileHelper.LoadScriptsFilePaths(absoluteSrcFilePath).ToArray(); string srcFileName = Path.GetFileNameWithoutExtension(absoluteSrcFilePath).ToLower(); string runtimePath = Path.Combine(GetBuiltinsPath(), srcFileName + ".d"); if (File.Exists(runtimePath)) { _assemblyBuilder.IsCurrentlyParsingExternals = true; if (verbose) { Console.WriteLine($"[0/{paths.Length}]Compiling runtime: {runtimePath}"); } DaedalusParser parser = GetParserForScriptsFile(runtimePath); ParseTreeWalker.Default.Walk(new DaedalusListener(_assemblyBuilder, 0), parser.daedalusFile()); _assemblyBuilder.IsCurrentlyParsingExternals = false; } for (int i = 0; i < paths.Length; i++) { if (verbose) { Console.WriteLine($"[{i + 1}/{paths.Length}]Compiling: {paths[i]}"); } string fileContent = GetFileContent(paths[i]); DaedalusParser parser = GetParserForText(fileContent); _assemblyBuilder.ErrorContext.FileContentLines = fileContent.Split(Environment.NewLine); _assemblyBuilder.ErrorContext.FilePath = paths[i]; _assemblyBuilder.ErrorContext.FileIndex = i; ParseTreeWalker.Default.Walk(new DaedalusListener(_assemblyBuilder, i), parser.daedalusFile()); if (generateOutputUnits) { _ouBuilder.ParseText(fileContent); } } if (!compileToAssembly) { Directory.CreateDirectory(_outputDirPath); } if (generateOutputUnits) { _ouBuilder.SaveOutputUnits(_outputDirPath); } _assemblyBuilder.Finish(); if (_assemblyBuilder.Errors.Any()) { _assemblyBuilder.Errors.Sort((x, y) => x.CompareTo(y)); string lastErrorFilePath = ""; string lastErrorBlockName = null; var logger = new StdErrorLogger(); foreach (CompilationMessage error in _assemblyBuilder.Errors) { if (lastErrorFilePath != error.FilePath) { lastErrorFilePath = error.FilePath; Console.WriteLine(error.FilePath); } if (lastErrorBlockName != error.ExecBlockName) { lastErrorBlockName = error.ExecBlockName; if (error.ExecBlockName == null) { Console.WriteLine($"{error.FileName}: In global scope:"); } else { Console.WriteLine($"{error.FileName}: In {error.ExecBlockType} ‘{error.ExecBlockName}’:"); } } error.Print(logger); } return(false); } if (compileToAssembly) { Console.WriteLine(_assemblyBuilder.GetAssembler()); } else { Directory.CreateDirectory(_outputDirPath); string datPath = Path.Combine(_outputDirPath, srcFileName + ".dat"); _assemblyBuilder.SaveToDat(datPath); } return(true); } catch (Exception exc) { Console.WriteLine("SRC compilation failed"); Console.WriteLine($"{exc}"); return(false); } }
public DaedalusStatefulDetailedParseTreeListener(DaedalusParser parser, IEnumerable <ParseResult> currentParseResults = null) : base(parser, currentParseResults) { }
public DaedalusStatefulParseTreeListener(DaedalusParser parser, IEnumerable <ParseResult> currentParseResults) { this.parser = parser; this.currentParseResults = currentParseResults ?? Enumerable.Empty <ParseResult>();; }
public ParseResult Parse() { ZenLoader zenLoader = new ZenLoader(_zenPaths, _verbose); if (zenLoader.Load() != 0) { return(null); } List <IParseTree> parseTrees = new List <IParseTree>(); List <string> filesPaths = new List <string>(); List <string[]> filesContentsLines = new List <string[]>(); List <string> filesContents = new List <string>(); List <HashSet <string> > suppressedWarningCodes = new List <HashSet <string> >(); int syntaxErrorsCount = 0; List <List <SyntaxError> > syntaxErrorsPerFile = new List <List <SyntaxError> >(); int runtimeIndex = -1; if (File.Exists(_runtimePath)) { runtimeIndex = 0; } for (int i = 0; i < _scriptPaths.Count; i++) { if (_verbose) { Console.WriteLine($"[{i + 1}/{_scriptPaths.Count}]Parsing{(runtimeIndex==i ? " runtime":"")}: {_scriptPaths[i]}"); } string fileContent = GetFileContent(_scriptPaths[i]); DaedalusParser parser = GetParserForText(fileContent); SyntaxErrorListener syntaxErrorListener = new SyntaxErrorListener(); parser.RemoveErrorListeners(); parser.AddErrorListener(syntaxErrorListener); parseTrees.Add(parser.daedalusFile()); syntaxErrorsCount += syntaxErrorListener.SyntaxErrors.Count; syntaxErrorsPerFile.Add(syntaxErrorListener.SyntaxErrors); string[] fileContentLines = fileContent.Split(Environment.NewLine); filesPaths.Add(_scriptPaths[i]); filesContentsLines.Add(fileContentLines); filesContents.Add(fileContent); suppressedWarningCodes.Add( SemanticErrorsCollectingVisitor.GetWarningCodesToSuppress(fileContentLines[0])); } if (syntaxErrorsCount > 0) { for (int i = 0; i < syntaxErrorsPerFile.Count; ++i) { List <SyntaxError> syntaxErrors = syntaxErrorsPerFile[i]; if (syntaxErrors.Count > 0) { string filePath = filesPaths[i]; string fileName = Path.GetFileName(filePath); _errorLogger.LogLine(filePath); foreach (SyntaxError syntaxError in syntaxErrors) { string line = filesContentsLines[i][syntaxError.LineNo - 1]; syntaxError.Print(fileName, line, _errorLogger); } } } _errorLogger.LogLine( $"{syntaxErrorsCount} syntax {(syntaxErrorsCount == 1 ? "error" : "errors")} generated."); return(null); } return(new ParseResult { ZenFileNodes = zenLoader.ZenFileNodes, ParseTrees = parseTrees, FilesPaths = filesPaths, FilesContentsLines = filesContentsLines, FilesContents = filesContents, SuppressedWarningCodes = suppressedWarningCodes }); }