public override void ReportError(RecognitionException e) { if (currentScope.EnclosingScope != null) { currentScope = currentScope.EnclosingScope; currentScope = currentScope.EnclosingScope; } ParserException syntaxError = ThrowHelper.SyntaxError(SourceName, e.Line, e.CharPositionInLine, input.ToString(), GetErrorMessage(e, tokenNames), e); if (e.Token != null && e.Token.Type == EOF) { PartialStatement error = new PartialStatement(syntaxError); ErrorList.Add(error); if (StopOnError) { throw error; } return; } base.ReportError(e); ErrorList.Add(syntaxError); if (StopOnError) { throw syntaxError; } }
// Throw an exception private void ThrowError(Token token, string messageFormat, params object[] arguments) { ParserException exception; string msg = System.String.Format(messageFormat, arguments); if (token.LineNumber.HasValue) { exception = new ParserException("Line " + token.LineNumber + ": " + msg) { Index = token.Range[0], LineNumber = token.LineNumber.Value, Column = token.Range[0] - _lineStart + 1 }; } else { exception = new ParserException("Line " + _lineNumber + ": " + msg) { Index = _index, LineNumber = _lineNumber, Column = _index - _lineStart + 1 }; } exception.Description = msg; throw exception; }
public static ParserException CreateParserException03() { Error errorCode = Error.ErrorDoubleFormat; int pos = int.MinValue; ParserException parserException = new ParserException(errorCode, pos); return(parserException); }
public static ParserException CreateParserException02() { Error errorCode = Error.NoParenBefore; int pos = 1; ParserException parserException = new ParserException(errorCode, pos); return(parserException); }
public static ParserException CreateParserException01() { Error errorCode = Error.UnrecogniseChar; int pos = 0; ParserException parserException = new ParserException(errorCode, pos); return(parserException); }
private ParserException GenerateParserException() { ParserException pe = new ParserException("Fout tijdens het verwerken van de gegevens."); pe.Data["TrafficPage"] = trafficPage; return(pe); }
public GherkinParserException(ParserException PE) { ErrorType = eErrorType.Error; this.mParserException = PE; Line = mParserException.Location.Line; Column = mParserException.Location.Column; Error = mParserException.Message; }
public void TestBuildException02() { Parser parser = new Parser(); Accessor parserAccesor = ReflectionAccessor.Wrap(parser); //Test Procedure Call ParserException parExcept = (ParserException)parserAccesor.Call("BuildException", Error.CharNotEnd, new Context()); //Post Condition Check }
private void StartSendTalkback(ParserException pe) { if ((SendTalkbackThread == null) || (SendTalkbackThread.ThreadState != System.Threading.ThreadState.Running)) { SendTalkbackThread = new Thread(SendTalkback); UpdateThreadCount(1); SendTalkbackThread.Start(pe); } }
public void TestParseErrorResponse() { string rawResponse = "{\n\"Message\": \"An error has occurred.\"\n}"; TestDelegate action = () => ScItemsParser.Parse(rawResponse, "web", CancellationToken.None); ParserException exception = Assert.Throws <ParserException>(action, "ParserException should be here"); Assert.AreEqual("[Sitecore Mobile SDK] Data from the internet has unexpected format{\n \"Message\": \"An error has occurred.\"\n}", exception.Message); }
private static void DoWriteError(ParserException e) { Console.Error.WriteLine(e.Message); if (e.Context != null) { Console.Error.WriteLine(e.Context); Console.Error.WriteLine("{0}^", new string(' ', e.Col - 1)); } }
private void WriteRuleObject(TransportRule transportRule) { JournalingRule journalingRule = null; ParserException ex = null; try { journalingRule = (JournalingRule)JournalingRuleParser.Instance.GetRule(transportRule.Xml); } catch (ParserException ex2) { ex = ex2; } Exception ex3 = null; if (journalingRule != null && journalingRule.GccRuleType != GccType.None && !this.LawfulInterception) { return; } if (journalingRule != null && journalingRule.GccRuleType == GccType.None && this.LawfulInterception) { return; } JournalRuleObject journalRuleObject; if (journalingRule == null) { journalRuleObject = JournalRuleObject.CreateCorruptJournalRuleObject(transportRule, Strings.CorruptRule(transportRule.Name, ex.Message)); } else if (journalingRule.IsTooAdvancedToParse) { journalRuleObject = JournalRuleObject.CreateCorruptJournalRuleObject(transportRule, Strings.CannotParseRuleDueToVersion(transportRule.Name)); } else { journalRuleObject = new JournalRuleObject(); try { journalRuleObject.Deserialize(journalingRule); } catch (RecipientInvalidException ex4) { ex3 = ex4; } catch (JournalRuleCorruptException ex5) { ex3 = ex5; } } if (ex3 != null) { journalRuleObject = JournalRuleObject.CreateCorruptJournalRuleObject(transportRule, Strings.CorruptRule(transportRule.Name, ex3.Message)); } journalRuleObject.SetTransportRule(transportRule); this.WriteResult(journalRuleObject); }
private static void WarnError(ParserException E) { Console.Clear(); //COLORZ Console.ForegroundColor = ConsoleColor.DarkYellow; Console.WriteLine(E.Message); Console.ForegroundColor = ConsoleColor.White; }
public void Print(ParserException e) { for (int i = 0; i < e.Messages.Count; i++) { PrintError(e.Lines[i], e.Letters[i], e.Messages[i], GetLine(e.Lines[i] - 1)); } }
public void Tolerate(ParserException error) { if (Tolerant) { RecordError(error); } else { throw CreateException(error.Index, error.Message); } }
public void Tolerate(ParserException error) { if (Tolerant) { RecordError(error); } else { throw error; } }
public static ParserException[] GetParserExceptions(this ParserException parserException) { var composite = parserException as CompositeParserException; if (composite != null) { return(composite.Errors.ToArray()); } return(new[] { parserException }); }
private static void PardonOrDeath(ParserException e, bool forgive) { if (forgive) { Debug.WriteLine("Warning: Finishing Acf file parsing because an error was encountered."); } e.LogErrorString(); if (!forgive) { throw e; } }
public void JumpToErrorLocation() { if (!Enabled || m_ExpressionTextBox == null || m_PrevFinishedJob == null || m_PrevFinishedJob.Error == null || m_PrevFinishedJob.UserData != (IntPtr)m_MostRecentUndoEntryId) { return; } ParserException pex = m_PrevFinishedJob.Error as ParserException; m_ExpressionTextBox.Select(Math.Min(m_ExpressionTextBox.TextLength, pex.ErrorPos), 0); }
/* * Handles a ParserException. * Sets error indicator to true, * prints the error message and * skips to the beginning of the next statement. */ void Error(ParserException e) { errored = true; if (e.lexeme == null) { io.WriteLine("Parser error at <end of file>: {0}, got no token", e.Message); } else { io.WriteLine("Parser error at {0}: {1}, got token: {2}", e.lexeme.position, e.Message, e.lexeme.ToString()); } SkipToNextStatement(); }
protected void OnParserException(ParserException pEx) { //Change color of text : http://stackoverflow.com/questions/29008274/how-to-change-text-color-at-icsharpcode-avalonedit-texteditor this.HighlightedLine.ErrorLines.Add(pEx.ParserErrorLine + 1); this.Dispatcher.Invoke(new Action(() => { this.InternTextEdit.TextArea.Caret.Line = pEx.ParserErrorLine + 1; this.InternTextEdit.TextArea.TextView.Redraw(); })); MessageBox.Show(pEx.Message); }
private void RaiseParserExceptionEvent(Exception exception) { if (ParserException == null) { return; } ParserExceptionEventArgs e = new ParserExceptionEventArgs(exception); foreach (EventHandler <ParserExceptionEventArgs> del in ParserException.GetInvocationList()) { del.BeginInvoke(this, e, AsyncCallBackRaiseParserExceptionEvent, del); } }
public void TestInternalError01() { ParserException parserException = ParserException.InternalError(); #region Record State ValueRecorder recorder = new ValueRecorder(); recorder.Record <string>(delegate { return((string)parserException.HelpLink); }); recorder.Record <string>(delegate { return((string)parserException.Message); }); recorder.Record <string>(delegate { return((string)parserException.Source); }); recorder.Record <string>(delegate { return((string)parserException.StackTrace); }); recorder.FinishRecording(); #endregion }
public override void ReportError(RecognitionException e) { ParserException syntaxError = ThrowHelper.SyntaxError(SourceName, e.Line, e.CharPositionInLine, input.ToString(), "Invalid syntax", e); if (e.UnexpectedType == EOF) { throw new PartialStatement(syntaxError); } base.ReportError(e); //Console.WriteLine("Error in lexer at line " + e.Line + ":" + e.CharPositionInLine); throw syntaxError; }
/// <summary>Create the parser to read grammar definition</summary> /// <exclude/> private static void CreateMetaParser() { if (_instance != null) { return; } int step = 1; TextBuffer buffer = new FlatBuffer(MetaParser.SoftMetaGrammarAndSettings); CodeDocument metaGrammarDoc = null; try { // Hard coded parser Parser hardcodeParser = GetHardCodeParser(buffer.Status); if (buffer.Status.Error == null) { step = 2; // Use hard coded grammar to read meta grammar. metaGrammarDoc = hardcodeParser.ParseString(buffer); string gg = metaGrammarDoc.ToMarkup(); step = 3; } if (buffer.Status.Error == null) { _instance = new Parser() { Level = 2 }; ParserBuilder.BuildRules(_instance, metaGrammarDoc, buffer.Status); } } catch (Exception e) { // if an exception occurs under parsing MetaGrammar it is an HardGrammar error var e2 = new ParserException((step <= 2 ? HardGrammar_ : MetaGrammar_) + " " + e.Message); if (e is ParserException) { e2.AllErrors = ((ParserException)e).AllErrors; } throw e2; } if (buffer.Status.Error != null) { // if an proces-error occurs under parsing MetaGrammar it is an MetaGrammar error var e2 = new ParserException((step == 1 ? HardGrammar_ : MetaGrammar_) + " " + buffer.Status.Error.Message); e2.AllErrors = buffer.Status.AllErrors; throw e2; } }
// Throw an exception private void ThrowError(Token token, string messageFormat, params object[] arguments) { string msg = System.String.Format(messageFormat, arguments); int lineNumber = token.LineNumber ?? _lineNumber; var error = new ParseError( description: msg, source: _source, index: token.Range[0], position: new Position(token.LineNumber ?? _lineNumber, token.Range[0] - _lineStart + 1)); var exception = new ParserException("Line " + lineNumber + ": " + msg, error); throw exception; }
public static ParserException CreateError(this IErrorHandler handler, int index, int line, int col, string description) { var msg = $"Line {line}': {description}"; var error = new ParserException(msg) { Index = index, Column = col, LineNumber = line, Description = description, Source = handler.Source }; return(error); }
public void TestParenNotMatch01() { char paren = char.MinValue; ParserException parserException = ParserException.ParenNotMatch(paren); #region Record State ValueRecorder recorder = new ValueRecorder(); recorder.Record <string>(delegate { return((string)parserException.HelpLink); }); recorder.Record <string>(delegate { return((string)parserException.Message); }); recorder.Record <string>(delegate { return((string)parserException.Source); }); recorder.Record <string>(delegate { return((string)parserException.StackTrace); }); recorder.FinishRecording(); #endregion }
public void TestNoParenBefore01() { string paren = string.Empty; ParserException parserException = ParserException.NoParenBefore(paren); #region Record State ValueRecorder recorder = new ValueRecorder(); recorder.Record <string>(delegate { return((string)parserException.HelpLink); }); recorder.Record <string>(delegate { return((string)parserException.Message); }); recorder.Record <string>(delegate { return((string)parserException.Source); }); recorder.Record <string>(delegate { return((string)parserException.StackTrace); }); recorder.FinishRecording(); #endregion }
public void TestParserExceptionConstructor01() { string msg = string.Empty; ParserException parserException = new ParserException(msg); #region Record State ValueRecorder recorder = new ValueRecorder(); recorder.Record((string)parserException.HelpLink); recorder.Record((string)parserException.Message); recorder.Record((string)parserException.Source); recorder.Record((string)parserException.StackTrace); recorder.FinishRecording(); #endregion }
// Unfortunately, due to a debugger "bug", the exception has to be caught and transferred into a cancelled event // this cancel event type is AsyncParserResultType. It is passed to AsyncParser_RunWorkerCompleted(). void AsyncParser_DoWork(object sender, System.ComponentModel.DoWorkEventArgs e) { AsyncParserResultType Result = new AsyncParserResultType(); //make sure that double typed numbers are converted with decimal point (not comma!) to string System.Threading.Thread.CurrentThread.CurrentCulture = System.Globalization.CultureInfo.CreateSpecificCulture("en-US"); try { AsyncParserJob job = e.Argument as AsyncParserJob; Tikz_ParseTree tp = TikzParser.Parse(job.code); Result.ParseTree = tp; Result.DocumentID = job.DocumentID; //include any styles from include files via \input cmd string inputfile = ""; try { //find input files using Regex Regex InputsRegex = new Regex(@"(^[^%]*|\n[^\n%]*?)\\input{(?<file>.*)}", RegexOptions.Compiled); MatchCollection files = InputsRegex.Matches(job.code); foreach (Match file in files) { //open, read, parse, and close each included file. inputfile = file.Groups["file"].ToString(); if (File.Exists(inputfile)) { StreamReader sr = new StreamReader(inputfile); string inputcode = sr.ReadToEnd(); sr.Close(); Tikz_ParseTree tp2 = TikzParser.ParseInputFile(inputcode); //if tp2 == null there probably was nothing useful included. if (tp2 != null) { //every style that was found in included file, add it to parse tree of main file. foreach (KeyValuePair<string, Tikz_Option> style in tp2.styles) { if(! Result.ParseTree.styles.ContainsKey(style.Key)) { Result.ParseTree.styles.Add(style.Key, style.Value); } else { ParserException pe = new ParserException(""); TexOutputParser.TexError te = new TexOutputParser.TexError(); te.Message = "Style [" + style.Key + "] is defined multiple times. Check position " + style.Value.StartPosition() + " in " + inputfile + " and this definition."; te.pos = Result.ParseTree.styles[style.Key].StartPosition(); te.severity = Severity.WARNING; pe.e = te; throw pe; } } } } } } catch (Exception ex) { Result.Warning = ex; Result.WarningSource = inputfile; } } catch (Exception ex) { //never set e.Cancel = true; //if you do, you cannot access e.Result from AsyncParser_RunWorkerCompleted. Result.Error = ex; Result.WarningSource = CurFile; } finally { e.Result = Result; } }