public XSharpParser.SourceContext Parse() { System.Diagnostics.Trace.WriteLine("-->> SourceWalker.Parse()"); ITokenStream tokenStream; XSharpParser.SourceContext tree; var options = _file.Project.ProjectNode.ParseOptions; if (options == null) { options = XSharpParseOptions.Default; } _errors = new List <XError>(); bool ok = XSharp.Parser.VsParser.Parse(_source, _file.SourcePath, _file.Project.ProjectNode.ParseOptions, this, out tokenStream, out tree); lock (this) { _hasParseErrors = !ok; if (ok) { _tokenStream = tokenStream; _tree = tree; } else { _tokenStream = null; _tree = null; } _file.HasParseErrors = _hasParseErrors; } System.Diagnostics.Trace.WriteLine("<<-- SourceWalker.Parse()"); return(_tree); }
public override void EnterSource([NotNull] XSharpParser.SourceContext context) { var source = (XSharpLexer)context.Start.TokenSource; source.Reset(); _tokens = source.GetAllTokens(); }
public ITokenStream Lex() { System.Diagnostics.Trace.WriteLine("-->> SourceWalker.Lex()"); ITokenStream tokenStream; _errors = new List <XError>(); bool ok = XSharp.Parser.VsParser.Lex(_source, _file.SourcePath, _file.Project.ProjectNode.ParseOptions, this, out tokenStream); lock (this) { _hasParseErrors = !ok; if (ok) { _tree = null; _tokenStream = tokenStream; } else { _tree = null; _tokenStream = null; _hasParseErrors = false; } _file.HasParseErrors = _hasParseErrors; } System.Diagnostics.Trace.WriteLine("<<-- SourceWalker.Lex()"); return(this._tokenStream); }
public XSharpModelDiscover(XFile file, XSharpParser.SourceContext ctx, IEnumerable <XError> errors) { // To store intermediate declarations this._file = file; this._xSource = ctx; this._errors = errors; // this._currentTypes = new Stack <XType>(); this._currentNSpaces = new Stack <XType>(); // this._options = file.Project.ProjectNode.ParseOptions; this._types = new Dictionary <string, XType>(); this._usings = new List <string>(); this._staticusings = new List <String>(); this._globalType = XType.CreateGlobalType(_file); this._classVars = new List <XTypeMember>(); _types.Add(_globalType.Name, _globalType); if (this._file != null && this._file.Project != null) { if (this._file.Project.Loaded) // this will fail if the project file is already unloaded { if (this._file.Project.ProjectNode.PrefixClassesWithDefaultNamespace) { this._defaultNS = this._file.Project.ProjectNode.RootNameSpace; } } } }
public override void ExitSource([NotNull] XSharpParser.SourceContext context) { var lastEnt = context._Entities.LastOrDefault(); if (lastEnt != null) { writeTrivia(CodeCompileUnit, lastEnt, true); } }
protected virtual void Dispose(bool disposing) { if (disposing) { _errors = null; _file = null; _prjNode = null; _tree = null; _tokenStream = null; _snapshot = null; } }
public override void EnterSource([NotNull] XSharpParser.SourceContext context) { // Default namespaces addUsing("System", false); if (_file?.Project?.ProjectNode?.ParseOptions != null) { if (_file.Project.ProjectNode.ParseOptions.IsDialectVO) { addUsing("Vulcan", false); } } }
public void BuildModel(XSharpParser.SourceContext xTree, bool buildLocals) { // abort when the project is unloaded or when no project // because in these cases there is no need to build a model if (_prjNode == null || !_file.Project.Loaded) { return; } // if (xTree != null) { try { XSharpModelDiscover mdiscover; if (buildLocals) { mdiscover = new XSharpModelDiscoverWithLocals(_file, xTree, _errors); } else { mdiscover = new XSharpModelDiscover(_file, xTree, _errors); } var walker = new LanguageService.SyntaxTree.Tree.ParseTreeWalker(); // // Walk the tree. The XSharpModelDiscover class will build the model. walker.Walk(mdiscover, xTree); // Callback for LibraryManager // Disabled for Now RvdH //if ( _file.Project != null) // _file.Project.FileWalkComplete?.Invoke(_file); // } catch (Exception e) { Support.Debug("SourceWalker.BuildModel failed: " + e.Message); } } }
public override void ExitSource([NotNull] XSharpParser.SourceContext context) { // Reset TypeList for this file this.File.SetTypes(_types, _usings, _staticusings, true); }
public XSharpModelDiscoverWithLocals(XFile file, XSharpParser.SourceContext ctx, IEnumerable <XError> errors) : base(file, ctx, errors) { this._localDecls = new Stack <XSharpParser.LocalvarContext>(); }
public static bool Parse(string sourceText, string fileName, CSharpParseOptions options, IErrorListener listener, out ITokenStream tokens, out XSharpParser.SourceContext tree) { tree = null; tokens = null; var parseErrors = ParseErrorData.NewBag(); try { var lexer = XSharpLexer.Create(sourceText, fileName, options); lexer.Options = options; BufferedTokenStream tokenStream = lexer.GetTokenStream(); tokenStream.Fill(); tokens = (ITokenStream)tokenStream; GetLexerErrors(lexer, tokenStream, parseErrors); // do we need to preprocess #region Determine if we really need the preprocessor bool mustPreprocess = true; if (lexer.HasPreprocessorTokens || !options.NoStdDef) { // no need to pre process in partial compilation // if lexer does not contain UDCs, Messages or Includes mustPreprocess = lexer.MustBeProcessed; } else { mustPreprocess = false; } #endregion XSharpPreprocessor pp = null; BufferedTokenStream ppStream = null; pp = new XSharpPreprocessor(lexer, tokenStream, options, fileName, Encoding.Unicode, SourceHashAlgorithm.None, parseErrors); if (mustPreprocess) { var ppTokens = pp.PreProcess(); ppStream = new CommonTokenStream(new XSharpListTokenSource(lexer, ppTokens)); } else { // No Standard Defs and no preprocessor tokens in the lexer // so we bypass the preprocessor and use the lexer token stream ppStream = new CommonTokenStream(new XSharpListTokenSource(lexer, tokenStream.GetTokens())); } ppStream.Fill(); var parser = new XSharpParser(ppStream); parser.Interpreter.tail_call_preserves_sll = false; // default = true Setting to FALSE will reduce memory used by parser parser.Options = options; tree = null; parser.RemoveErrorListeners(); parser.Interpreter.PredictionMode = PredictionMode.Sll; parser.ErrorHandler = new BailErrorStrategy(); try { tree = parser.source(); } catch (Exception) { var errorListener = new XSharpErrorListener(fileName, parseErrors); parser.AddErrorListener(errorListener); parser.ErrorHandler = new XSharpErrorStrategy(); parser.Interpreter.PredictionMode = PredictionMode.Ll; ppStream.Reset(); parser.Reset(); try { tree = parser.source(); } catch (Exception) { tree = null; } } } catch (Exception) { tree = null; } ReportErrors(parseErrors, listener); return(tree != null); }