private static Result <FreezableStepProperty, IError> TryParse(string text) { var inputStream = new AntlrInputStream(text); var lexer = new SCLLexer(inputStream); var commonTokenStream = new CommonTokenStream(lexer); var parser = new SCLParser(commonTokenStream); var syntaxErrorListener = new SyntaxErrorListener(); parser.AddErrorListener(syntaxErrorListener); var visitor = new Visitor(); var result = visitor.Visit(parser.fullSequence()); if (result.IsFailure) { return(result); } if (syntaxErrorListener.Errors.Any()) { return(Result.Failure <FreezableStepProperty, IError>( ErrorList.Combine(syntaxErrorListener.Errors) )); } return(result); }
void ILSLSyntaxErrorListener.InvalidPrefixOperationUsedInStaticContext(LSLSourceCodeRange location, LSLPrefixOperationType type) { _errorActionQueue.Enqueue(location.StartIndex, () => SyntaxErrorListener.InvalidPrefixOperationUsedInStaticContext(location, type)); }
private IParseTree ReadAST() { var code = textEditor.Text; var inputStream = new AntlrInputStream(code); var lexer = new DDD_layout_scriptLexer(inputStream); //lexer.RemoveErrorListeners(); var tokenStream = new CommonTokenStream(lexer); var parser = new DDD_layout_scriptParser(tokenStream); var syntaxErrorListener = new SyntaxErrorListener(); parser.RemoveErrorListeners(); parser.AddErrorListener(syntaxErrorListener); var context = parser.program(); List <ErrorPaneRow> rows = new List <ErrorPaneRow>(); var syntaxAlerts = syntaxErrorListener.GetAlerts(); foreach (var alert in syntaxAlerts) { rows.Add(new ErrorPaneRow(alert.GetAlertType(), alert.LineNumber, alert.Msg)); } ErrorPane.ItemsSource = rows; if (syntaxAlerts.Count != 0) { return(null); } return(context); }
void ILSLSyntaxErrorListener.PrefixOperationOnGlobalVariableInStaticContext(LSLSourceCodeRange location, LSLPrefixOperationType type) { _errorActionQueue.Enqueue(location.StartIndex, () => SyntaxErrorListener.PrefixOperationOnGlobalVariableInStaticContext(location, type)); }
void ILSLSyntaxErrorListener.PostfixOperationOnNonVariable(LSLSourceCodeRange location, LSLPostfixOperationType type) { _errorActionQueue.Enqueue(location.StartIndex, () => SyntaxErrorListener.PostfixOperationOnNonVariable(location, type)); }
void ILSLSyntaxErrorListener.InvalidTupleComponentAccessOperation(LSLSourceCodeRange location, ILSLReadOnlyExprNode exprLvalue, string memberAccessed) { _errorActionQueue.Enqueue(location.StartIndex, () => SyntaxErrorListener.InvalidTupleComponentAccessOperation(location, exprLvalue, memberAccessed)); }
void ILSLSyntaxErrorListener.TypeMismatchInVariableDeclaration(LSLSourceCodeRange location, LSLType variableType, ILSLReadOnlyExprNode assignedExpression) { _errorActionQueue.Enqueue(location.StartIndex, () => SyntaxErrorListener.TypeMismatchInVariableDeclaration(location, variableType, assignedExpression)); }
void ILSLSyntaxErrorListener.InvalidBinaryOperation(LSLSourceCodeRange location, ILSLReadOnlyExprNode left, string operation, ILSLReadOnlyExprNode right) { _errorActionQueue.Enqueue(location.StartIndex, () => SyntaxErrorListener.InvalidBinaryOperation(location, left, operation, right)); }
void ILSLSyntaxErrorListener.RedefinedStandardLibraryFunction(LSLSourceCodeRange location, string functionName, IReadOnlyGenericArray <ILSLFunctionSignature> libraryFunctionSignatureOverloads) { _errorActionQueue.Enqueue(location.StartIndex, () => SyntaxErrorListener.RedefinedStandardLibraryFunction(location, functionName, libraryFunctionSignatureOverloads)); }
void ILSLSyntaxErrorListener.GrammarLevelParserSyntaxError(int line, int column, LSLSourceCodeRange offendingTokenRange, string offendingTokenText, string message) { _errorActionQueue.Enqueue(line, () => SyntaxErrorListener.GrammarLevelParserSyntaxError(line, column, offendingTokenRange, offendingTokenText, message)); }
void ILSLSyntaxErrorListener.IncorrectEventHandlerSignature(LSLSourceCodeRange location, ILSLEventSignature givenEventHandlerSignature, ILSLEventSignature correctEventHandlerSignature) { _errorActionQueue.Enqueue(location.StartIndex, () => SyntaxErrorListener.IncorrectEventHandlerSignature(location, givenEventHandlerSignature, correctEventHandlerSignature)); }
void ILSLSyntaxErrorListener.TupleComponentAccessOnLibraryConstant(LSLSourceCodeRange location, ILSLVariableNode libraryConstantReferenceNode, ILSLConstantSignature libraryConstantSignature, string accessedMember) { _errorActionQueue.Enqueue(location.StartIndex, () => SyntaxErrorListener.TupleComponentAccessOnLibraryConstant(location, libraryConstantReferenceNode, libraryConstantSignature, accessedMember)); }
void ILSLSyntaxErrorListener.NoSuitableLibraryFunctionOverloadFound(LSLSourceCodeRange location, string functionName, IReadOnlyGenericArray <ILSLReadOnlyExprNode> givenParameterExpressions) { _errorActionQueue.Enqueue(location.StartIndex, () => SyntaxErrorListener.NoSuitableLibraryFunctionOverloadFound(location, functionName, givenParameterExpressions)); }
void ILSLSyntaxErrorListener.RedefinedStandardLibraryConstant(LSLSourceCodeRange location, LSLType redefinitionType, ILSLConstantSignature originalSignature) { _errorActionQueue.Enqueue(location.StartIndex, () => SyntaxErrorListener.RedefinedStandardLibraryConstant(location, redefinitionType, originalSignature)); }
void ILSLSyntaxErrorListener.ParameterTypeMismatchInFunctionCall(LSLSourceCodeRange location, int parameterIndexWithError, ILSLFunctionSignature calledFunction, ILSLReadOnlyExprNode[] parameterExpressionsGiven) { _errorActionQueue.Enqueue(location.StartIndex, () => SyntaxErrorListener.ParameterTypeMismatchInFunctionCall(location, parameterIndexWithError, calledFunction, parameterExpressionsGiven)); }
void ILSLSyntaxErrorListener.ImproperParameterCountInFunctionCall(LSLSourceCodeRange location, ILSLFunctionSignature functionSignature, ILSLReadOnlyExprNode[] parameterExpressionsGiven) { _errorActionQueue.Enqueue(location.StartIndex, () => SyntaxErrorListener.ImproperParameterCountInFunctionCall(location, functionSignature, parameterExpressionsGiven)); }
void ILSLSyntaxErrorListener.TypeMismatchInReturnValue(LSLSourceCodeRange location, ILSLFunctionSignature functionSignature, ILSLReadOnlyExprNode attemptedReturnExpression) { _errorActionQueue.Enqueue(location.StartIndex, () => SyntaxErrorListener.TypeMismatchInReturnValue(location, functionSignature, attemptedReturnExpression)); }
void ILSLSyntaxErrorListener.CallToOverloadedLibraryFunctionIsAmbiguous(LSLSourceCodeRange location, string functionName, IReadOnlyGenericArray <ILSLFunctionSignature> ambiguousMatches, IReadOnlyGenericArray <ILSLReadOnlyExprNode> givenParameterExpressions) { _errorActionQueue.Enqueue(location.StartIndex, () => SyntaxErrorListener.CallToOverloadedLibraryFunctionIsAmbiguous(location, functionName, ambiguousMatches, givenParameterExpressions)); }
public static ViGaSParser GetParserForScript(string script, out List <Error> errors) { var inputStream = new AntlrInputStream(script); var lexer = new ViGaSLexer(inputStream); var tokenStream = new CommonTokenStream(lexer); var parser = new ViGaSParser(tokenStream); var syntaxErrorListener = new SyntaxErrorListener(); parser.AddErrorListener(syntaxErrorListener); errors = syntaxErrorListener.errors; return(parser); }
private List <SyntaxError> ParseAndReturnErrors(string input) { AntlrInputStream inputStream = new AntlrInputStream(input); CsharpSubsetLexer lexer = new CsharpSubsetLexer(inputStream); CommonTokenStream commonTokenStream = new CommonTokenStream(lexer); CsharpSubsetParser parser = new CsharpSubsetParser(commonTokenStream); SyntaxErrorListener listener = new SyntaxErrorListener(); parser.AddErrorListener(listener); CsharpSubsetParser.ProgramContext programContext = parser.program(); return(listener.SyntaxErrors); }
public static IParseTree MakeParseTree(string script, out List <Error> errors) { var inputStream = new AntlrInputStream(script); var lexer = new ViGaSLexer(inputStream); var tokenStream = new CommonTokenStream(lexer); var parser = new ViGaSParser(tokenStream); var syntaxErrorListener = new SyntaxErrorListener(); parser.AddErrorListener(syntaxErrorListener); var context = parser.script(); errors = syntaxErrorListener.errors; return(context); }
public void Error_on_empty_from_query() { var parser = new QueryParser(new CommonTokenStream(new QueryLexer(new AntlrInputStream("from")))); parser.AddErrorListener(_errorListener); parser.query(); Assert.Single(_errorListener.Errors); Assert.Contains("index or collection name", _errorListener.Errors[0].Message); _errorListener = new SyntaxErrorListener(); parser = new QueryParser(new CommonTokenStream(new QueryLexer(new AntlrInputStream("from foobar")))); parser.query(); Assert.Empty(_errorListener.Errors); }
public void Error_on_missing_index_name() { var parser = new QueryParser(new CommonTokenStream(new QueryLexer(new AntlrInputStream("from index")))); parser.AddErrorListener(_errorListener); parser.query(); Assert.Single(_errorListener.Errors); Assert.Contains("index name", _errorListener.Errors[0].Message); _errorListener = new SyntaxErrorListener(); parser = new QueryParser(new CommonTokenStream(new QueryLexer(new AntlrInputStream("from index 'foo/bar'")))); parser.AddErrorListener(_errorListener); parser.query(); Assert.Empty(_errorListener.Errors); }
private IParseTree Parse(string zenContent) { string[] fileContentLines = zenContent.Split(Environment.NewLine); _filesContentsLines.Add(fileContentLines); AntlrInputStream inputStream = new AntlrInputStream(zenContent); ZenLexer lexer = new ZenLexer(inputStream); CommonTokenStream commonTokenStream = new CommonTokenStream(lexer); ZenParser parser = new ZenParser(commonTokenStream); SyntaxErrorListener syntaxErrorListener = new SyntaxErrorListener(); parser.RemoveErrorListeners(); parser.AddErrorListener(syntaxErrorListener); IParseTree parseTree = parser.main(); _syntaxErrorsCount += syntaxErrorListener.SyntaxErrors.Count; _syntaxErrorsPerFile.Add(syntaxErrorListener.SyntaxErrors); return(parseTree); }
private void ParseCode(string codeString) { InputStream = new AntlrInputStream(codeString); Lexer = new CsharpSubsetLexer(InputStream); CommonTokenStream = new CommonTokenStream(Lexer); Parser = new CsharpSubsetParser(CommonTokenStream); SyntaxErrorListener errorListener = new SyntaxErrorListener(); Parser.AddErrorListener(errorListener); Tree = Parser.program(); if (errorListener.SyntaxErrors.Any()) { _logOutput.Add("Couldn't refactor, one or more syntax errors occurred:"); foreach (var error in errorListener.SyntaxErrors) { _logOutput.Add(error.AsString()); } SyntaxErrorsFound = true; Tree = null; } }
private ParseResult ParseFile(string filename, Encoding encoding, bool detailed = false, IEnumerable <ParseResult> currentParseResults = null) { using (var sw = new StringWriter()) using (var sr = new StreamReader(filename, encoding)) { var errors = new List <SyntaxError>(); var parser = GetParserForStream(sr, TextWriter.Null, sw); parser.Interpreter.PredictionMode = Antlr4.Runtime.Atn.PredictionMode.SLL; var errListener = new SyntaxErrorListener(); parser.AddErrorListener(errListener); var listener = detailed ? new DaedalusStatefulDetailedParseTreeListener(parser, currentParseResults) : new DaedalusStatefulParseTreeListener(parser, currentParseResults); DaedalusParser.DaedalusFileContext fileCtx; try { fileCtx = parser.daedalusFile(); } catch (Exception) { parser.Interpreter.PredictionMode = Antlr4.Runtime.Atn.PredictionMode.LL; fileCtx = parser.daedalusFile(); } ParseTreeWalker.Default.Walk(listener, fileCtx); return(new ParseResult { SyntaxErrors = errListener.SyntaxErrors, GlobalConstants = listener.GlobalConsts, GlobalVariables = listener.GlobalVars, GlobalFunctions = listener.GlobalFunctions, GlobalClasses = listener.GlobalClasses, GlobalPrototypes = listener.GlobalPrototypes, GlobalInstances = listener.GlobalInstances, }); } }
private ParseResult ParseText(string fileContent, bool detailed = false, IEnumerable <ParseResult> currentParseResults = null) { using (var sw = new StringWriter()) { var errors = new List <SyntaxError>(); var parser = GetParserForText(fileContent, TextWriter.Null, sw); var errListener = new SyntaxErrorListener(); parser.AddErrorListener(errListener); var listener = detailed ? new DaedalusStatefulDetailedParseTreeListener(parser, currentParseResults) : new DaedalusStatefulParseTreeListener(parser, currentParseResults); ParseTreeWalker.Default.Walk(listener, parser.daedalusFile()); return(new ParseResult { SyntaxErrors = errListener.SyntaxErrors, GlobalConstants = listener.GlobalConsts, GlobalVariables = listener.GlobalVars, GlobalFunctions = listener.GlobalFunctions, GlobalClasses = listener.GlobalClasses, GlobalPrototypes = listener.GlobalPrototypes, GlobalInstances = listener.GlobalInstances, }); } }
private void compareArrays(object[,] valueArray, object[,] formulaArray) { var x = valueArray.GetLength(0); var y = valueArray.GetLength(1); var xF = formulaArray.GetLength(0); var yF = formulaArray.GetLength(1); if (x != xF || y != yF) { Logger.DebugLine("Compare Arrays: x and y dimensions dont match between arrays", 1); Logger.DebugLine($"x: {x}, xF: {xF}, y: {y}, yF: {yF}", 1); } for (int i = 1; i <= x; i++) { for (int j = 1; j <= y; j++) { var value = valueArray[i, j]; var formula = formulaArray[i, j]; var equals = false; if (value != null && formula != null) { if (value is double) { string valueString = ((double)value).ToString("G", CultureInfo.InvariantCulture); equals = ((string)formula).Equals(valueString); var valueStringComma = valueString.Replace(".", ","); var valueStringDot = valueString.Replace(",", "."); var formulaStringComma = ((string)formula).Replace(".", ","); var formulaStringDot = ((string)formula).Replace(",", "."); Logger.DebugLine($"Value is double, value: {valueString}, formula: {(string)formula}, equals: {equals}", 1); if (!equals) { equals = ((string)formula).Equals(valueStringComma) || ((string)formula).Equals(valueStringDot); Logger.DebugLine($"Dot Comma conversion check, valueStringComma: {valueStringComma}, valueStringDot: {valueStringDot}, formula: {(string)formula}, equals: {equals}", 1); } if (!equals) { string valueStringInstalled = ((double)value).ToString("G", CultureInfo.InstalledUICulture); equals = ((string)formula).Equals(valueStringInstalled); Logger.DebugLine($"Installed UI Culture ({CultureInfo.InstalledUICulture}) Equal check, value: {valueStringInstalled}, formula: {(string)formula}, equals: {equals}", 1); } if (!equals) { var culture = CultureInfo.CreateSpecificCulture("de-DE"); string valueStringInstalled = ((double)value).ToString("G", culture); equals = ((string)formula).Equals(valueStringInstalled); Logger.DebugLine($"Specific Culture ({culture}) Equal check, value: {valueStringInstalled}, formula: {(string)formula}, equals: {equals}", 1); } if (!equals) { string valueStringDoubleFixedPoint = ((double)value).ToString(FormatStrings.DoubleFixedPoint, CultureInfo.InvariantCulture); equals = ((string)formula).Equals(valueStringDoubleFixedPoint); Logger.DebugLine($"Format DoubleFixedPoint with Culture ({CultureInfo.InvariantCulture}) Equal check, value: {valueStringDoubleFixedPoint}, formula: {(string)formula}, equals: {equals}", 1); } if (!equals && double.TryParse((string)formula, out double parsedFormula)) { equals = IsDoubleEqual((double)value, parsedFormula); Logger.DebugLine($"Parsed formula to double, value: {(double)value}, parsedFormula: {parsedFormula}, equals: {equals}", 1); } if (!equals && (double.TryParse(formulaStringComma, out parsedFormula) || double.TryParse(formulaStringDot, out parsedFormula))) { equals = IsDoubleEqual((double)value, parsedFormula); Logger.DebugLine($"Parsed formula dot comma to double, value: {(double)value}, parsedFormula: {parsedFormula}, equals: {equals}", 1); } } else if (value is DateTime) { Logger.DebugLine($"Value is Datetime, value: {value.ToString()}, formula: {(string)formula}", 1); if (int.TryParse((string)formula, out int result)) { DateTime date = new DateTime(1900, 1, 1).AddDays(result); equals = true; Logger.DebugLine($"Formula is int, date: {date.ToString()}, value date: {(DateTime)value}", 1); } else if (DateTime.TryParse((string)formula, out DateTime resultDate)) { equals = true; Logger.DebugLine($"Formula is datetime, resultDate: {resultDate.ToString()}, value date: {(DateTime)value}", 1); } else if (double.TryParse((string)formula, out double resultDouble)) { equals = true; //DateTime date = new DateTime(1900, 1, 1).AddDays(resultDouble); Logger.DebugLine($"Formula is double, resultDouble: {resultDouble.ToString()}, value date: {(DateTime)value}", 1); } else { Logger.DebugLine($"Couldnt compare DateTime, value: {value.ToString()}, formula: {(string)formula}", 2); equals = false; } } else { equals = formula.Equals(value.ToString()); } } if (equals) { Logger.DebugLine($"{j}, {i}: Value equals Formula"); addConvertedValue(value, i, j); } else if (value == formula) { Logger.DebugLine($"{j}, {i}: Value == Formula"); addConvertedValue(value, i, j); } else if (value == null && string.IsNullOrEmpty((string)formula)) { Logger.DebugLine($"{j}, {i}: Value equals Formula: Both empty"); } else { printObject(value, "Value"); Logger.Debug("----"); printObject(formula, "Formula"); Logger.DebugLine(""); Logger.DebugLine($"{j}, {i}: Value does not equal Formula", 1); SyntaxErrorListener errorListener = new SyntaxErrorListener(); AntlrInputStream inputStream = new AntlrInputStream((string)formula); ExcelFormulaLexer spreadsheetLexer = new ExcelFormulaLexer(inputStream); spreadsheetLexer.RemoveErrorListeners(); spreadsheetLexer.AddErrorListener(errorListener); CommonTokenStream commonTokenStream = new CommonTokenStream(spreadsheetLexer); ExcelFormulaParser excelFormulaParser = new ExcelFormulaParser(commonTokenStream); ExcelFormulaParser.ExcelExprContext context = excelFormulaParser.excelExpr(); if (errorListener.HasError) { Logger.DebugLine($"Found Lexer Error - Dont process formula at {i}, {j} : {(string)formula}", 5); if (GlobalSettings.ImportStopAtSyntaxError) { Console.WriteLine($"Lexer Error - Enter to continue", 10); Console.ReadLine(); } continue; } if (excelFormulaParser.NumberOfSyntaxErrors > 0) { Logger.DebugLine($"Found Syntax Error - Dont process formula at {i}, {j} : {(string)formula}", 5); if (GlobalSettings.ImportStopAtSyntaxError) { Console.WriteLine($"Syntax Error - Enter to continue", 10); Console.ReadLine(); } continue; } ExcelFormulaVisitor visitor = new ExcelFormulaVisitor(); string formulaText = visitor.Visit(context); if (visitor.Error) { continue; } Logger.DebugLine($"FormulaText: {formulaText}", 1); convertedText += $"C[{j},{i}] = {{{formulaText}}} ;\n"; } } } }
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); }
void ILSLSyntaxErrorListener.CastOnCastExpression(LSLSourceCodeRange location, ILSLReadOnlyExprNode castedExpression) { _errorActionQueue.Enqueue(location.StartIndex, () => SyntaxErrorListener.CastOnCastExpression(location, castedExpression)); }