Example #1
0
        public virtual void Parse()
        {
            Workspaces.Document item = Item;
            string code        = item.Code;
            string ffn         = item.FullPath;
            bool   has_changed = item.Changed;

            item.Changed = false;
            if (!has_changed)
            {
                return;
            }

            IGrammarDescription gd = GrammarDescriptionFactory.Create(ffn);

            if (gd == null)
            {
                throw new Exception();
            }

            gd.Parse(this);

            AllNodes   = DFSVisitor.DFS(ParseTree as ParserRuleContext);
            Comments   = gd.ExtractComments(code);
            Defs       = new Dictionary <TerminalNodeImpl, int>();
            Refs       = new Dictionary <TerminalNodeImpl, int>();
            Tags       = new Dictionary <TerminalNodeImpl, int>();
            Errors     = new HashSet <IParseTree>();
            Imports    = new HashSet <string>();
            Attributes = new Dictionary <IParseTree, IList <CombinedScopeSymbol> >();
            Cleanup();
        }
Example #2
0
        internal void Initialize(
            IBufferTagAggregatorFactoryService aggregatorFactory,
            IClassificationTypeRegistryService service,
            IClassificationFormatMapService ClassificationFormatMapService)
        {
            try
            {
                if (initialized)
                {
                    return;
                }
                var ffn = _buffer.GetFFN().Result;
                if (ffn == null)
                {
                    return;
                }
                _grammar_description = LanguageServer.GrammarDescriptionFactory.Create(ffn);
                if (_grammar_description == null)
                {
                    return;
                }
                var document = Workspaces.Workspace.Instance.FindDocument(ffn);
                if (document == null)
                {
                    Workspaces.Loader.LoadAsync().Wait();
                    var to_do = LanguageServer.Module.Compile();
                    document = Workspaces.Workspace.Instance.FindDocument(ffn);
                }
                _aggregator = aggregatorFactory.CreateTagAggregator <AntlrTokenTag>(_buffer);
                _antlrtype_to_classifiertype = new Dictionary <int, IClassificationType>();
                for (int i = 0; i < _grammar_description.Map.Length; ++i)
                {
                    var key = i;
                    var val = _grammar_description.Map[i];
                    var identiferClassificationType = service.GetClassificationType(val);
                    var classificationType          = identiferClassificationType == null?service.CreateClassificationType(val, new IClassificationType[] { })
                                                          : identiferClassificationType;

                    var classificationFormatMap = ClassificationFormatMapService.GetClassificationFormatMap(category: "text");
                    var identifierProperties    = classificationFormatMap
                                                  .GetExplicitTextProperties(classificationType);
                    var color = !Themes.IsInvertedTheme() ? _grammar_description.MapColor[key]
                        : _grammar_description.MapInvertedColor[key];
                    System.Windows.Media.Color newColor = System.Windows.Media.Color.FromArgb(color.A, color.R, color.G, color.B);
                    var newProperties = identifierProperties.SetForeground(newColor);
                    classificationFormatMap.AddExplicitTextProperties(classificationType, newProperties);
                }
                for (int i = 0; i < _grammar_description.Map.Length; ++i)
                {
                    var key = i;
                    var val = _grammar_description.Map[i];
                    _antlrtype_to_classifiertype[key] = service.GetClassificationType(val);
                }
                initialized = true;
            }
            catch (Exception exception)
            {
                Logger.Log.Notify(exception.StackTrace);
            }
        }
Example #3
0
        public static ParserDetails Create(Workspaces.Document item)
        {
            if (item == null)
            {
                return(null);
            }

            string ffn = item.FullPath;

            foreach (KeyValuePair <string, ParserDetails> pd in _per_file_parser_details)
            {
                if (pd.Key == ffn)
                {
                    return(pd.Value);
                }
            }
            IGrammarDescription gd = GrammarDescriptionFactory.Create(ffn);

            if (gd == null)
            {
                return(null);
            }

            ParserDetails result = gd.CreateParserDetails(item);

            result.Gd = gd;
            _per_file_parser_details[ffn] = result;
            return(result);
        }
Example #4
0
        public virtual List <string> Candidates(int char_index)
        {
            Workspaces.Document item = Item;
            string ffn             = item.FullPath;
            IGrammarDescription gd = GrammarDescriptionFactory.Create(ffn);

            if (gd == null)
            {
                throw new Exception();
            }

            string code = Code.Substring(0, char_index);

            gd.Parse(code, out CommonTokenStream tok_stream, out Parser parser, out Lexer lexer, out IParseTree pt);
            LASets        la_sets = new LASets();
            IntervalSet   int_set = la_sets.Compute(parser, tok_stream);
            List <string> result  = new List <string>();

            foreach (int r in int_set.ToList())
            {
                string rule_name = Lexer.RuleNames[r];
                result.Add(rule_name);
            }
            return(result);
        }
Example #5
0
        internal AntlrClassifier(ITextBuffer buffer)
        {
            try
            {
                _buffer          = buffer;
                _buffer.Changed += new EventHandler <TextContentChangedEventArgs>(OnTextChanged);

                var ffn = _buffer.GetFFN().Result;
                if (ffn == null)
                {
                    return;
                }
                _grammar_description = LanguageServer.GrammarDescriptionFactory.Create(ffn);
                if (_grammar_description == null)
                {
                    return;
                }
                var document = Workspaces.Workspace.Instance.FindDocument(ffn);
                if (document == null)
                {
                    Workspaces.Loader.LoadAsync().Wait();
                    var to_do = LanguageServer.Module.Compile();
                    document = Workspaces.Workspace.Instance.FindDocument(ffn);
                }
                AntlrLanguagePackage package = AntlrLanguagePackage.Instance;
            }
            catch (Exception exception)
            {
                Logger.Log.Notify(exception.ToString());
            }
        }
Example #6
0
        public AntlrQuickInfoSource(ITextBuffer buffer, ITagAggregator <AntlrTokenTag> aggregator)
        {
            _aggregator = aggregator;
            _buffer     = buffer;
            var path = buffer.GetFFN().Result;

            _grammar_description = LanguageServer.GrammarDescriptionFactory.Create(path);
        }
Example #7
0
        public virtual void GatherDefs()
        {
            Workspaces.Document item = Item;
            string ffn             = item.FullPath;
            IGrammarDescription gd = GrammarDescriptionFactory.Create(ffn);

            if (gd == null)
            {
                throw new Exception();
            }

            for (int classification = 0; classification < gd.IdentifyDefinition.Count; ++classification)
            {
                Func <IGrammarDescription, Dictionary <IParseTree, IList <CombinedScopeSymbol> >, IParseTree, bool> fun = gd.IdentifyDefinition[classification];
                if (fun == null)
                {
                    continue;
                }

                IEnumerable <IParseTree> it = AllNodes.Where(t => fun(gd, Attributes, t));
                foreach (IParseTree t in it)
                {
                    TerminalNodeImpl x = (t as TerminalNodeImpl);
                    if (x == null)
                    {
                        continue;
                    }

                    if (x.Symbol == null)
                    {
                        continue;
                    }

                    try
                    {
                        Defs.Add(x, classification);
                        Tags.Add(x, classification);
                    }
                    catch (ArgumentException)
                    {
                        // Duplicate
                    }
                }
            }
        }
Example #8
0
        public virtual List <string> Candidates(int index)
        {
            var item = Item;
            var ffn  = item.FullPath;
            IGrammarDescription gd = GrammarDescriptionFactory.Create(ffn);

            if (gd == null)
            {
                throw new Exception();
            }
            string code = this.Code.Substring(0, index);

            gd.Parse(code, out CommonTokenStream tok_stream, out Parser parser, out Lexer lexer, out IParseTree pt);
            LASets la_sets = new LASets();
            var    result  = la_sets.Compute(parser, tok_stream);

            return(null);
        }
Example #9
0
        public virtual void GatherErrors()
        {
            var item = Item;
            var ffn  = item.FullPath;
            IGrammarDescription gd = GrammarDescriptionFactory.Create(ffn);

            if (gd == null)
            {
                throw new Exception();
            }
            {
                var it = this.AllNodes.Where(t => t as Antlr4.Runtime.Tree.ErrorNodeImpl != null);
                foreach (var t in it)
                {
                    this.Errors.Add(t);
                }
            }
        }
Example #10
0
        public virtual void GatherErrors()
        {
            Workspaces.Document item = Item;
            string ffn             = item.FullPath;
            IGrammarDescription gd = GrammarDescriptionFactory.Create(ffn);

            if (gd == null)
            {
                throw new Exception();
            }

            {
                IEnumerable <IParseTree> it = AllNodes.Where(t => t as Antlr4.Runtime.Tree.ErrorNodeImpl != null);
                foreach (IParseTree t in it)
                {
                    Errors.Add(t);
                }
            }
        }
Example #11
0
        public HighlightTagger(ITextView view, ITextBuffer sourceBuffer, ITextSearchService textSearchService,
                               ITextStructureNavigator textStructureNavigator,
                               IClassifier aggregator)
        {
            _view   = view;
            _buffer = sourceBuffer;
            var ffn = _buffer.GetFFN().Result;

            if (ffn == null)
            {
                return;
            }
            _grammar_description   = LanguageServer.GrammarDescriptionFactory.Create(ffn);
            TextSearchService      = textSearchService;
            TextStructureNavigator = textStructureNavigator;
            _aggregator            = aggregator;
            WordSpans             = new NormalizedSnapshotSpanCollection();
            CurrentWord           = null;
            _view_to_tagger[view] = this;
        }
Example #12
0
        public virtual void GatherDefs()
        {
            var item = Item;
            var ffn  = item.FullPath;
            IGrammarDescription gd = GrammarDescriptionFactory.Create(ffn);

            if (gd == null)
            {
                throw new Exception();
            }
            for (int classification = 0; classification < gd.IdentifyDefinition.Count; ++classification)
            {
                var fun = gd.IdentifyDefinition[classification];
                if (fun == null)
                {
                    continue;
                }
                var it = this.AllNodes.Where(t => fun(gd, this.Attributes, t));
                foreach (var t in it)
                {
                    var x = (t as TerminalNodeImpl);
                    if (x == null)
                    {
                        continue;
                    }
                    if (x.Symbol == null)
                    {
                        continue;
                    }
                    try
                    {
                        this.Defs.Add(x, classification);
                        this.Tags.Add(x, classification);
                    }
                    catch (ArgumentException)
                    {
                        // Duplicate
                    }
                }
            }
        }
Example #13
0
        public static int GetTag(int index, Document doc)
        {
            ParserDetails pd = ParserDetailsFactory.Create(doc);

            if (pd.ParseTree == null)
            {
                LanguageServer.Module.Compile();
            }

            Antlr4.Runtime.Tree.IParseTree pt = LanguageServer.Util.Find(index, doc);
            IGrammarDescription            gd = GrammarDescriptionFactory.Create(doc.FullPath);

            if (pt == null)
            {
                return(-1);
            }

            Antlr4.Runtime.Tree.IParseTree p = pt;
            TerminalNodeImpl q     = p as Antlr4.Runtime.Tree.TerminalNodeImpl;
            bool             found = pd.Tags.TryGetValue(q, out int tag_type);

            if (found)
            {
                return(tag_type);
            }

            if (q.Symbol == null)
            {
                return(-1);
            }

            bool found2 = pd.Comments.TryGetValue(q.Symbol, out int tag2);

            if (found2)
            {
                return(tag2);
            }

            return(-1);
        }
Example #14
0
        public static DocumentSymbol GetDocumentSymbol(int index, Document doc)
        {
            ParserDetails pd = ParserDetailsFactory.Create(doc);

            if (pd.ParseTree == null)
            {
                LanguageServer.Module.Compile();
            }

            Antlr4.Runtime.Tree.IParseTree pt = LanguageServer.Util.Find(index, doc);
            IGrammarDescription            gd = GrammarDescriptionFactory.Create(doc.FullPath);

            if (pt == null)
            {
                return(default(DocumentSymbol));
            }

            Antlr4.Runtime.Tree.IParseTree p = pt;
            TerminalNodeImpl q     = p as Antlr4.Runtime.Tree.TerminalNodeImpl;
            bool             found = pd.Tags.TryGetValue(q, out int tag_type);

            if (!found)
            {
                return(null);
            }

            if (q.Symbol == null)
            {
                return(null);
            }

            return(new DocumentSymbol()
            {
                name = q.Symbol.Text,
                range = new Workspaces.Range(q.Symbol.StartIndex, q.Symbol.StopIndex),
                kind = tag_type
            });
        }
Example #15
0
        public static void ResetMenus()
        {
            if (GoToDefinitionCommand.Instance == null ||
                FindAllReferencesCommand.Instance == null ||
                RenameCommand.Instance == null ||
                Reformat.ReformatCommand.Instance == null)
            {
                return;
            }

            IWpfTextView view = AntlrLanguagePackage.Instance.GetActiveView();

            if (view == null)
            {
                return;
            }

            // First, find out what this view is, and what the file is.
            ITextBuffer         buffer = view.TextBuffer;
            string              path   = buffer.GetFFN().Result;
            IGrammarDescription grammar_description = LanguageServer.GrammarDescriptionFactory.Create(path);

            // Whack any old values that cursor points to.
            GoToDefinitionCommand.Instance.Enabled    = false;
            FindAllReferencesCommand.Instance.Enabled = false;
            NextSymCommand.Instance.Enabled           = true;
            RenameCommand.Instance.Enabled            = false;
            ReformatCommand.Instance.Enabled          = false;
            GoToVisitorCommand.Instance.Enabled       = false;

            AntlrLanguagePackage.Instance.Span           = default(SnapshotSpan);
            AntlrLanguagePackage.Instance.Classification = default(string);
            AntlrLanguagePackage.Instance.View           = view;

            if (grammar_description == null)
            {
                return;
            }

            var fp = view.GetFilePath().Result;

            if (fp != null)
            {
                var gd = LanguageServer.GrammarDescriptionFactory.Create(fp);
                if (gd != null && gd.CanNextRule)
                {
                    NextSymCommand.Instance.Enabled = true;
                }
                if (gd != null && gd.CanReformat)
                {
                    Reformat.ReformatCommand.Instance.Enabled = true;
                }
            }
            else
            {
                return;
            }

            // Find details of the Antlr symbol pointed to.
            ITextCaret    car    = view.Caret;
            CaretPosition cp     = car.Position;
            SnapshotPoint bp     = cp.BufferPosition;
            TextExtent    extent = AntlrVSIX.Package.AntlrLanguagePackage.Instance.Navigator[view].GetExtentOfWord(bp);
            SnapshotSpan  span   = extent.Span;

            AntlrLanguagePackage.Instance.Span = span;

            HighlightTagger.Update(view, bp);

            //  Now, check for valid classification type.
            ClassificationSpan[] c1 = AntlrVSIX.Package.AntlrLanguagePackage.Instance.Aggregator[view].GetClassificationSpans(span).ToArray();
            foreach (ClassificationSpan classification in c1)
            {
                var name = classification.ClassificationType.Classification;
                if (!grammar_description.InverseMap.TryGetValue(name, out int type))
                {
                    continue;
                }
                if (grammar_description.CanFindAllRefs[type])
                {
                    FindAllReferencesCommand.Instance.Enabled = true;
                }
                if (grammar_description.CanRename[type])
                {
                    RenameCommand.Instance.Enabled = true;
                }
                if (grammar_description.CanGotodef[type])
                {
                    GoToDefinitionCommand.Instance.Enabled = true;
                }
                if (grammar_description.CanGotovisitor[type])
                {
                    GoToVisitorCommand.Instance.Enabled = true;
                }
                if (grammar_description.CanReformat)
                {
                    ReformatCommand.Instance.Enabled = true;
                }
            }
        }
Example #16
0
        public static TextEdit[] Reformat(Document doc)
        {
            ParserDetails ref_pd          = ParserDetailsFactory.Create(doc);
            string        code            = doc.Code;
            string        corpus_location = Options.Option.GetString("CorpusLocation");

            if (corpus_location == null)
            {
                TextEdit[] result = new TextEdit[] { };
                return(result);
            }

            string ffn = doc.FullPath;

            if (ffn == null)
            {
                TextEdit[] result = new TextEdit[] { };
                return(result);
            }
            IGrammarDescription grammar_description = LanguageServer.GrammarDescriptionFactory.Create(ffn);

            if (grammar_description == null)
            {
                TextEdit[] result = new TextEdit[] { };
                return(result);
            }
            org.antlr.codebuff.Tool.unformatted_input = code;
            try
            {
                string result = org.antlr.codebuff.Tool.Main(
                    new object[]
                {
                    "-g", grammar_description.Name,
                    "-lexer", grammar_description.Lexer,
                    "-parser", grammar_description.Parser,
                    "-rule", grammar_description.StartRule,
                    "-files", grammar_description.FileExtension,
                    "-corpus", corpus_location,
                    "-inoutstring",
                    ""
                });
                List <TextEdit>  edits = new List <TextEdit>();
                diff_match_patch diff  = new diff_match_patch();
                List <Diff>      diffs = diff.diff_main(code, result);
                List <Patch>     patch = diff.patch_make(diffs);
                //patch.Reverse();

                // Start edit session.
                int times = 0;
                int delta = 0;
                foreach (Patch p in patch)
                {
                    times++;
                    int start = p.start1 - delta;

                    int offset = 0;
                    foreach (Diff ed in p.diffs)
                    {
                        if (ed.operation == Operation.EQUAL)
                        {
                            //// Let's verify that.
                            int len = ed.text.Length;
                            //var tokenSpan = new SnapshotSpan(buffer.CurrentSnapshot,
                            //  new Span(start + offset, len));
                            //var tt = tokenSpan.GetText();
                            //if (ed.text != tt)
                            //{ }
                            offset = offset + len;
                        }
                        else if (ed.operation == Operation.DELETE)
                        {
                            int len = ed.text.Length;
                            //var tokenSpan = new SnapshotSpan(buffer.CurrentSnapshot,
                            //  new Span(start + offset, len));
                            //var tt = tokenSpan.GetText();
                            //if (ed.text != tt)
                            //{ }
                            TextEdit edit = new TextEdit()
                            {
                                range = new Workspaces.Range(
                                    new Workspaces.Index(start + offset),
                                    new Workspaces.Index(start + offset + len)),
                                NewText = ""
                            };
                            offset = offset + len;
                            edits.Add(edit);
                        }
                        else if (ed.operation == Operation.INSERT)
                        {
                            int      len  = ed.text.Length;
                            TextEdit edit = new TextEdit()
                            {
                                range = new Workspaces.Range(
                                    new Workspaces.Index(start + offset),
                                    new Workspaces.Index(start + offset)),
                                NewText = ed.text
                            };
                            edits.Add(edit);
                        }
                    }
                    delta = delta + (p.length2 - p.length1);
                }
                return(edits.ToArray());
            }
            catch (Exception)
            {
                TextEdit[] result = new TextEdit[] { };
                return(result);
            }
        }
Example #17
0
        public static List <ParserDetails> Compile()
        {
            try
            {
                Workspace ws = Workspaces.Workspace.Instance;

                // Get all changed files.
                HashSet <ParserDetails> to_do = new HashSet <ParserDetails>();

DoAgain:

                // Get current directory, and add all grammar files.
                foreach (Document document in Workspaces.DFSContainer.DFS(ws))
                {
                    string file_name = document.FullPath;
                    if (file_name == null)
                    {
                        continue;
                    }

                    Container           parent = document.Parent;
                    IGrammarDescription gd     = LanguageServer.GrammarDescriptionFactory.Create(file_name);
                    if (gd == null)
                    {
                        continue;
                    }

                    // Get suffix of file_name.
                    string extension = System.IO.Path.GetExtension(file_name);
                    string directory = System.IO.Path.GetDirectoryName(file_name);

                    foreach (string file in System.IO.Directory.GetFiles(directory))
                    {
                        if (System.IO.Path.GetExtension(file) != extension)
                        {
                            continue;
                        }

                        IGrammarDescription g2 = LanguageServer.GrammarDescriptionFactory.Create(file);
                        if (g2 == null)
                        {
                            continue;
                        }

                        Document x = Workspaces.Workspace.Instance.FindDocument(file);
                        if (x == null)
                        {
                            // Add document.
                            Container proj    = parent;
                            Document  new_doc = new Workspaces.Document(file);
                            proj.AddChild(new_doc);
                        }
                        ParserDetails p2 = ParserDetailsFactory.Create(document);
                        if (!p2.Changed)
                        {
                            continue;
                        }

                        to_do.Add(p2);
                    }
                }

                foreach (Document document in Workspaces.DFSContainer.DFS(ws))
                {
                    string file_name = document.FullPath;
                    if (file_name == null)
                    {
                        continue;
                    }

                    IGrammarDescription gd = LanguageServer.GrammarDescriptionFactory.Create(file_name);
                    if (gd == null)
                    {
                        continue;
                    }
                    // file_name can be a URI, so this doesn't make sense.
                    //if (!System.IO.File.Exists(file_name)) continue;
                    ParserDetails pd = ParserDetailsFactory.Create(document);
                    if (!pd.Changed)
                    {
                        continue;
                    }

                    to_do.Add(pd);
                }
                Digraph <ParserDetails> g = ConstructGraph(to_do);
                foreach (ParserDetails v in g.Vertices)
                {
                    v.Item.Changed = true; // Force.
                    v.Parse();
                }
                bool changed = true;
                for (int pass = 0; changed; pass++)
                {
                    changed = false;
                    foreach (ParserDetails v in g.Vertices)
                    {
                        int number_of_passes = v.Passes.Count;
                        if (pass < number_of_passes)
                        {
                            bool reset = v.Pass(pass);
                            if (reset)
                            {
                                goto DoAgain;
                            }
                            changed = true;
                        }
                    }
                }
                foreach (ParserDetails v in g.Vertices)
                {
                    v.GatherDefs();
                }
                foreach (ParserDetails v in g.Vertices)
                {
                    v.GatherRefs();
                }
                foreach (ParserDetails v in g.Vertices)
                {
                    v.GatherErrors();
                }
                return(g.Vertices.ToList());
            }
            catch (Exception e)
            {
                Logger.Log.Notify(e.ToString());
            }
            return(new List <ParserDetails>());
        }
Example #18
0
        public static QuickInfo GetQuickInfo(int index, Document doc)
        {
            ParserDetails pd = ParserDetailsFactory.Create(doc);

            if (pd.ParseTree == null)
            {
                LanguageServer.Module.Compile();
            }

            Antlr4.Runtime.Tree.IParseTree pt = LanguageServer.Util.Find(index, doc);
            IGrammarDescription            gd = GrammarDescriptionFactory.Create(doc.FullPath);

            if (pt == null)
            {
                return(null);
            }

            Antlr4.Runtime.Tree.IParseTree p = pt;
            pd.Attributes.TryGetValue(p, out IList <CombinedScopeSymbol> list_value);
            if (list_value == null)
            {
                return(null);
            }

            TerminalNodeImpl q     = p as Antlr4.Runtime.Tree.TerminalNodeImpl;
            Range            range = new Workspaces.Range(new Workspaces.Index(q.Symbol.StartIndex), new Workspaces.Index(q.Symbol.StopIndex + 1));
            bool             found = pd.Tags.TryGetValue(q, out int tag_type);

            if (!found)
            {
                return(null);
            }

            if (list_value == null || list_value.Count == 0)
            {
                return(new QuickInfo()
                {
                    Display = gd.Map[tag_type], Range = range
                });
            }
            if (list_value.Count == 1)
            {
                CombinedScopeSymbol value = list_value.First();
                ISymbol             name  = value as Symtab.ISymbol;
                string show = name?.Name;
                if (value is Symtab.Literal)
                {
                    show = ((Symtab.Literal)value).Cleaned;
                }
                if (gd.PopUpDefinition[tag_type] != null)
                {
                    Func <ParserDetails, IParseTree, string> fun = gd.PopUpDefinition[tag_type];
                    string mess = fun(pd, p);
                    if (mess != null)
                    {
                        return(new QuickInfo()
                        {
                            Display = mess, Range = range
                        });
                    }
                }
                string display = gd.Map[tag_type]
                                 + "\n"
                                 + show;
                return(new QuickInfo()
                {
                    Display = display, Range = range
                });
            }
            {
                string display = "Ambiguous -- ";
                foreach (CombinedScopeSymbol value in list_value)
                {
                    ISymbol name = value as Symtab.ISymbol;
                    string  show = name?.Name;
                    if (value is Symtab.Literal)
                    {
                        show = ((Symtab.Literal)value).Cleaned;
                    }
                    if (gd.PopUpDefinition[tag_type] != null)
                    {
                        Func <ParserDetails, IParseTree, string> fun = gd.PopUpDefinition[tag_type];
                        string mess = fun(pd, p);
                        if (mess != null)
                        {
                            display = display + mess;
                        }
                    }
                    else
                    {
                        display = display + gd.Map[tag_type]
                                  + "\n"
                                  + show;
                    }
                }
                return(new QuickInfo()
                {
                    Display = display, Range = range
                });
            }
        }
Example #19
0
        public virtual void GatherRefs()
        {
            var item = Item;
            var ffn  = item.FullPath;
            IGrammarDescription gd = GrammarDescriptionFactory.Create(ffn);

            if (gd == null)
            {
                throw new Exception();
            }
            for (int classification = 0; classification < gd.Identify.Count; ++classification)
            {
                var fun = gd.Identify[classification];
                if (fun == null)
                {
                    continue;
                }
                var it = this.AllNodes.Where(t => fun(gd, this.Attributes, t));
                foreach (var t in it)
                {
                    var x = (t as TerminalNodeImpl);
                    if (x == null)
                    {
                        continue;
                    }
                    if (x.Symbol == null)
                    {
                        continue;
                    }
                    try
                    {
                        this.Attributes.TryGetValue(x, out IList <CombinedScopeSymbol> attr_list);
                        if (attr_list == null)
                        {
                            continue;
                        }
                        foreach (var attr in attr_list)
                        {
                            this.Tags.Add(x, classification);
                            if (attr == null)
                            {
                                continue;
                            }
                            var sym = attr as Symtab.ISymbol;
                            if (sym == null)
                            {
                                continue;
                            }
                            var def = sym.resolve();
                            if (def != null && def.file != null && def.file != "" &&
                                def.file != ffn)
                            {
                                var def_item = Workspaces.Workspace.Instance.FindDocument(def.file);
                                var def_pd   = ParserDetailsFactory.Create(def_item);
                                def_pd.PropagateChangesTo.Add(ffn);
                            }
                            this.Refs.Add(x, classification);
                        }
                    }
                    catch (ArgumentException)
                    {
                        // Duplicate
                    }
                }
            }
        }
Example #20
0
        public virtual void GatherRefs()
        {
            Workspaces.Document item = Item;
            string ffn             = item.FullPath;
            IGrammarDescription gd = GrammarDescriptionFactory.Create(ffn);

            if (gd == null)
            {
                throw new Exception();
            }

            for (int classification = 0; classification < gd.Identify.Count; ++classification)
            {
                Func <IGrammarDescription, Dictionary <IParseTree, IList <CombinedScopeSymbol> >, IParseTree, bool> fun = gd.Identify[classification];
                if (fun == null)
                {
                    continue;
                }

                IEnumerable <IParseTree> it = AllNodes.Where(t => fun(gd, Attributes, t));
                foreach (IParseTree t in it)
                {
                    TerminalNodeImpl x = (t as TerminalNodeImpl);
                    if (x == null)
                    {
                        continue;
                    }

                    if (x.Symbol == null)
                    {
                        continue;
                    }

                    try
                    {
                        Attributes.TryGetValue(x, out IList <CombinedScopeSymbol> attr_list);
                        if (attr_list == null)
                        {
                            continue;
                        }

                        foreach (CombinedScopeSymbol attr in attr_list)
                        {
                            Tags.Add(x, classification);
                            if (attr == null)
                            {
                                continue;
                            }

                            ISymbol sym = attr as Symtab.ISymbol;
                            if (sym == null)
                            {
                                continue;
                            }

                            ISymbol def = sym.resolve();
                            if (def != null && def.file != null && def.file != "" &&
                                def.file != ffn)
                            {
                                Workspaces.Document def_item = Workspaces.Workspace.Instance.FindDocument(def.file);
                                ParserDetails       def_pd   = ParserDetailsFactory.Create(def_item);
                                def_pd.PropagateChangesTo.Add(ffn);
                            }
                            Refs.Add(x, classification);
                        }
                    }
                    catch (ArgumentException)
                    {
                        // Duplicate
                    }
                }
            }
        }
Example #21
0
        private void MenuItemCallback(object sender, EventArgs e, bool visitor)
        {
            try
            {
                // Return if I can't determine what application this is.
                DTE application = Workspaces.Help.GetApplication();
                if (application == null)
                {
                    return;
                }

                // Get active view and determine if it's a grammar file.
                var grammar_view = AntlrLanguagePackage.Instance.GetActiveView();
                if (grammar_view == null)
                {
                    return;
                }
                ITextCaret    car          = grammar_view.Caret;
                CaretPosition cp           = car.Position;
                SnapshotPoint bp           = cp.BufferPosition;
                int           pos          = bp.Position;
                ITextBuffer   buffer       = grammar_view.TextBuffer;
                var           g4_file_path = buffer.GetFFN().Result;
                if (g4_file_path == null)
                {
                    return;
                }
                IGrammarDescription grammar_description = LanguageServer.GrammarDescriptionFactory.Create(g4_file_path);
                if (!grammar_description.IsFileType(g4_file_path))
                {
                    return;
                }

                // Get name of base class for listener and visitor. These are generated by Antlr,
                // constructed from the name of the file.
                var grammar_name = Path.GetFileName(g4_file_path);
                grammar_name = Path.GetFileNameWithoutExtension(grammar_name);
                var listener_baseclass_name = visitor ? (grammar_name + "BaseVisitor") : (grammar_name + "BaseListener");
                var listener_class_name     = visitor ? ("My" + grammar_name + "Visitor") : ("My" + grammar_name + "Listener");

                // In the current view, find the details of the Antlr symbol at the cursor.
                TextExtent extent = AntlrVSIX.Package.AntlrLanguagePackage.Instance.Navigator[grammar_view]
                                    .GetExtentOfWord(bp);
                SnapshotSpan span = extent.Span;
                AntlrLanguagePackage.Instance.Span = span;

                //  Now, check for valid classification type.
                var  cla             = -1;
                bool can_gotovisitor = AntlrVSIX.Package.AntlrLanguagePackage.Instance.Aggregator[grammar_view].GetClassificationSpans(span).Where(
                    classification =>
                {
                    var name = classification.ClassificationType.Classification;
                    if (!grammar_description.InverseMap.TryGetValue(name, out int c))
                    {
                        return(false);
                    }
                    cla = c;
                    return(grammar_description.CanGotovisitor[cla]);
                }).Any();
                if (!can_gotovisitor)
                {
                    return;
                }

                // Find defining occurrence.
                List <Antlr4.Runtime.Tree.TerminalNodeImpl> where = new List <Antlr4.Runtime.Tree.TerminalNodeImpl>();
                List <ParserDetails> where_details         = new List <ParserDetails>();
                Antlr4.Runtime.Tree.TerminalNodeImpl token = null;
                foreach (var kvp in ParserDetailsFactory.AllParserDetails)
                {
                    string        file_name = kvp.Key;
                    ParserDetails details   = kvp.Value;
                    {
                        var it = details.Defs.Where(
                            (t) => t.Value == cla && t.Key.Symbol.Text == span.GetText()).Select(t => t.Key);
                        where.AddRange(it);
                        foreach (var i in it)
                        {
                            where_details.Add(details);
                        }
                    }
                }

                if (where.Any())
                {
                    token = where.First();
                }
                else
                {
                    System.Windows.Forms.MessageBox.Show(
                        "Symbol '" + span.GetText() + "' definer not found.");
                    return;
                }

                // Get the symbol name as a string.
                var symbol_name             = token.Symbol.Text;
                var capitalized_symbol_name = Capitalized(symbol_name);

                // Parse all the C# files in the solution.
                Dictionary <string, SyntaxTree> trees = new Dictionary <string, SyntaxTree>();
                foreach (var item in DteExtensions.SolutionFiles(application))
                {
                    string file_name = item.Name;
                    if (file_name != null)
                    {
                        string prefix = file_name.TrimSuffix(".cs");
                        if (prefix == file_name)
                        {
                            continue;
                        }
                        try
                        {
                            object       prop = item.Properties.Item("FullPath").Value;
                            string       ffn  = (string)prop;
                            StreamReader sr   = new StreamReader(ffn);
                            string       code = sr.ReadToEnd();
                            SyntaxTree   tree = CSharpSyntaxTree.ParseText(code);
                            trees[ffn] = tree;
                        }
                        catch (Exception)
                        {
                        }
                    }
                }

                // Find all occurrences of visitor class.
                List <ClassDeclarationSyntax> found_class = new List <ClassDeclarationSyntax>();
                string class_file_path = null;
                try
                {
                    foreach (var kvp in trees)
                    {
                        var file_name = kvp.Key;
                        var tree      = kvp.Value;

                        // Look for IParseTreeListener or IParseTreeVisitor classes.
                        var root = (CompilationUnitSyntax)tree.GetRoot();
                        if (root == null)
                        {
                            continue;
                        }
                        foreach (var nm in root.Members)
                        {
                            var namespace_member = nm as NamespaceDeclarationSyntax;
                            if (namespace_member == null)
                            {
                                continue;
                            }
                            foreach (var cm in namespace_member.Members)
                            {
                                var class_member = cm as ClassDeclarationSyntax;
                                if (class_member == null)
                                {
                                    continue;
                                }
                                var bls = class_member.BaseList;
                                if (bls == null)
                                {
                                    continue;
                                }
                                var   types = bls.Types;
                                Regex reg   = new Regex("[<].+[>]");
                                foreach (var type in types)
                                {
                                    var s = type.ToString();
                                    s = reg.Replace(s, "");
                                    if (s.ToString() == listener_baseclass_name)
                                    {
                                        // Found the right class.
                                        found_class.Add(class_member);
                                        throw new Exception();
                                    }
                                }
                            }
                        }
                    }
                }
                catch
                {
                }

                if (found_class.Count == 0)
                {
                    if (!global::Options.POptions.GetBoolean("GenerateVisitorListener"))
                    {
                        return;
                    }

                    // Look in grammar directory for any C# files.
                    string name_space = null;
                    string ffn        = Path.GetFullPath(g4_file_path);
                    ffn = Path.GetDirectoryName(ffn);
                    foreach (var i in DteExtensions.SolutionFiles(application))
                    {
                        string file_name = i.Name;
                        if (file_name != null)
                        {
                            string prefix = file_name.TrimSuffix(".cs");
                            if (prefix == file_name)
                            {
                                continue;
                            }
                            try
                            {
                                object prop  = i.Properties.Item("FullPath").Value;
                                string ffncs = (string)prop;
                                // Look for namespace.
                                var t = trees[ffncs];
                                if (t == null)
                                {
                                    continue;
                                }
                                var root = t.GetCompilationUnitRoot();
                                foreach (var nm in root.Members)
                                {
                                    var namespace_member = nm as NamespaceDeclarationSyntax;
                                    if (namespace_member == null)
                                    {
                                        continue;
                                    }
                                    name_space = namespace_member.Name.ToString();
                                    break;
                                }
                            }
                            catch (Exception)
                            {
                            }
                        }
                    }
                    if (name_space == null)
                    {
                        name_space = "Generated";
                    }

                    // Create class.
                    string clazz = visitor ? $@"
using System;
using System.Collections.Generic;
using System.Text;

namespace {name_space}
{{
    class {listener_class_name}<Result> : {listener_baseclass_name}<Result>
    {{
        //public override Result VisitA([NotNull] A3Parser.AContext context)
        //{{
        //  return VisitChildren(context);
        //}}
    }}
}}
"
                    : $@"
using System;
using System.Collections.Generic;
using System.Text;

namespace {name_space}
{{
    class {listener_class_name} : {listener_baseclass_name}
    {{
        //public override void EnterA(A3Parser.AContext context)
        //{{
        //    base.EnterA(context);
        //}}
        //public override void ExitA(A3Parser.AContext context)
        //{{
        //    base.ExitA(context);
        //}}
    }}
}}
";

                    class_file_path = ffn + Path.DirectorySeparatorChar + listener_class_name + ".cs";
                    System.IO.File.WriteAllText(class_file_path, clazz);
                    var    item   = ProjectHelpers.GetSelectedItem();
                    string folder = FindFolder(item);
                    if (string.IsNullOrEmpty(folder) || !Directory.Exists(folder))
                    {
                        return;
                    }
                    var file         = new FileInfo(class_file_path);
                    var selectedItem = Workspaces.Workspace.Instance.FindDocument(class_file_path);
                    if (selectedItem == null)
                    {
                        //var selectedProject = item as Project;
                        //Project project = selectedItem?.ContainingProject ?? selectedProject ?? null;
                        //var projectItem = project.AddFileToProject(file);
                    }
                    // Redo parse.
                    try
                    {
                        StreamReader sr   = new StreamReader(class_file_path);
                        string       code = sr.ReadToEnd();
                        SyntaxTree   tree = CSharpSyntaxTree.ParseText(code);
                        trees[class_file_path] = tree;
                    }
                    catch (Exception)
                    {
                    }
                    // Redo find class.
                    try
                    {
                        var tree = trees[class_file_path];
                        var save = class_file_path;
                        class_file_path = null;
                        // Look for IParseTreeListener or IParseTreeVisitor classes.
                        var root = (CompilationUnitSyntax)tree.GetRoot();
                        foreach (var nm in root.Members)
                        {
                            var namespace_member = nm as NamespaceDeclarationSyntax;
                            if (namespace_member == null)
                            {
                                continue;
                            }
                            foreach (var cm in namespace_member.Members)
                            {
                                var class_member = cm as ClassDeclarationSyntax;
                                if (class_member == null)
                                {
                                    continue;
                                }
                                var bls = class_member.BaseList;
                                if (bls == null)
                                {
                                    continue;
                                }
                                var   types = bls.Types;
                                Regex reg   = new Regex("[<].+[>]");
                                foreach (var type in types)
                                {
                                    var s = type.ToString();
                                    s = reg.Replace(s, "");
                                    if (s.ToString() == listener_baseclass_name)
                                    {
                                        // Found the right class.
                                        found_class.Add(class_member);
                                        throw new Exception();
                                    }
                                }
                            }
                        }
                    }
                    catch
                    {
                    }
                }

                // Look for enter or exit method for symbol.
                MethodDeclarationSyntax found_member = null;
                var ctl = CtrlKeyState.GetStateForView(grammar_view).Enabled;
                var capitalized_member_name = "";
                if (visitor)
                {
                    capitalized_member_name = "Visit" + capitalized_symbol_name;
                }
                else if (ctl)
                {
                    capitalized_member_name = "Exit" + capitalized_symbol_name;
                }
                else
                {
                    capitalized_member_name = "Enter" + capitalized_symbol_name;
                }
                var capitalized_grammar_name = Capitalized(grammar_name);
                try
                {
                    foreach (var fc in found_class)
                    {
                        foreach (var me in fc.Members)
                        {
                            var method_member = me as MethodDeclarationSyntax;
                            if (method_member == null)
                            {
                                continue;
                            }
                            if (method_member.Identifier.ValueText.ToLower() == capitalized_member_name.ToLower())
                            {
                                found_member = method_member;
                                throw new Exception();
                            }
                        }
                    }
                }
                catch
                {
                }
                if (found_member == null)
                {
                    if (!global::Options.POptions.GetBoolean("GenerateVisitorListener"))
                    {
                        return;
                    }

                    // Find point for edit.
                    var fc   = found_class.First();
                    var here = fc.OpenBraceToken;
                    var spn  = here.FullSpan;
                    var end  = spn.End;

                    IVsTextView vstv = IVsTextViewExtensions.FindTextViewFor(class_file_path);
                    if (vstv == null)
                    {
                        IVsTextViewExtensions.ShowFrame(class_file_path);
                        vstv = IVsTextViewExtensions.FindTextViewFor(class_file_path);
                    }
                    IWpfTextView wpftv = vstv.GetIWpfTextView();
                    if (wpftv == null)
                    {
                        return;
                    }
                    ITextSnapshot cc = wpftv.TextBuffer.CurrentSnapshot;

                    var res = vstv.GetBuffer(out IVsTextLines ppBuffer);

                    var nss      = new SnapshotSpan(cc, spn.End + 1, 0);
                    var txt_span = nss.Span;

                    int line_number;
                    int colum_number;
                    vstv.GetLineAndColumn(txt_span.Start, out line_number, out colum_number);
                    res = ppBuffer.CreateEditPoint(line_number, colum_number, out object ppEditPoint);
                    EditPoint editPoint = ppEditPoint as EditPoint;
                    // Create class.
                    string member = visitor ? $@"
public override Result {capitalized_member_name}([NotNull] {capitalized_grammar_name}Parser.{capitalized_symbol_name}Context context)
{{
    return VisitChildren(context);
}}
"
                        : $@"
public override void {capitalized_member_name}({capitalized_grammar_name}Parser.{capitalized_symbol_name}Context context)
{{
    base.{capitalized_member_name}(context);
}}
";
                    editPoint.Insert(member);
                    // Redo parse.
                    try
                    {
                        vstv = IVsTextViewExtensions.FindTextViewFor(class_file_path);
                        if (vstv == null)
                        {
                            IVsTextViewExtensions.ShowFrame(class_file_path);
                            vstv = IVsTextViewExtensions.FindTextViewFor(class_file_path);
                        }
                        var        text_buffer = vstv.GetITextBuffer();
                        var        code        = text_buffer.GetBufferText();
                        SyntaxTree tree        = CSharpSyntaxTree.ParseText(code);
                        trees[class_file_path] = tree;
                    }
                    catch (Exception)
                    {
                    }
                    // Redo find class.
                    try
                    {
                        var tree = trees[class_file_path];
                        var save = class_file_path;
                        class_file_path = null;
                        // Look for IParseTreeListener or IParseTreeVisitor classes.
                        var root = (CompilationUnitSyntax)tree.GetRoot();
                        foreach (var nm in root.Members)
                        {
                            var namespace_member = nm as NamespaceDeclarationSyntax;
                            if (namespace_member == null)
                            {
                                continue;
                            }
                            foreach (var cm in namespace_member.Members)
                            {
                                var class_member = cm as ClassDeclarationSyntax;
                                if (class_member == null)
                                {
                                    continue;
                                }
                                var bls = class_member.BaseList;
                                if (bls == null)
                                {
                                    continue;
                                }
                                var   types = bls.Types;
                                Regex reg   = new Regex("[<].+[>]");
                                foreach (var type in types)
                                {
                                    var s = type.ToString();
                                    s = reg.Replace(s, "");
                                    if (s.ToString() == listener_baseclass_name)
                                    {
                                        // Found the right class.
                                        found_class.Add(class_member);
                                        class_file_path = save;
                                        throw new Exception();
                                    }
                                }
                            }
                        }
                    }
                    catch
                    {
                    }
                    try
                    {
                        foreach (var fcc in found_class)
                        {
                            foreach (var me in fcc.Members)
                            {
                                var method_member = me as MethodDeclarationSyntax;
                                if (method_member == null)
                                {
                                    continue;
                                }
                                if (method_member.Identifier.ValueText.ToLower() == capitalized_member_name.ToLower())
                                {
                                    found_member = method_member;
                                    throw new Exception();
                                }
                            }
                        }
                    }
                    catch
                    {
                    }
                }

                {
                    // Open to this line in editor.
                    IVsTextView vstv = IVsTextViewExtensions.FindTextViewFor(class_file_path);
                    {
                        IVsTextViewExtensions.ShowFrame(class_file_path);
                        vstv = IVsTextViewExtensions.FindTextViewFor(class_file_path);
                    }

                    IWpfTextView wpftv = vstv.GetIWpfTextView();
                    if (wpftv == null)
                    {
                        return;
                    }

                    int line_number;
                    int colum_number;
                    var txt_span = found_member.Identifier.Span;
                    vstv.GetLineAndColumn(txt_span.Start, out line_number, out colum_number);

                    // Create new span in the appropriate view.
                    ITextSnapshot cc = wpftv.TextBuffer.CurrentSnapshot;
                    SnapshotSpan  ss = new SnapshotSpan(cc, txt_span.Start, txt_span.Length);
                    SnapshotPoint sp = ss.Start;
                    // Put cursor on symbol.
                    wpftv.Caret.MoveTo(sp); // This sets cursor, bot does not center.
                                            // Center on cursor.
                                            //wpftv.Caret.EnsureVisible(); // This works, sort of. It moves the scroll bar, but it does not CENTER! Does not really work!
                    if (line_number > 0)
                    {
                        vstv.CenterLines(line_number - 1, 2);
                    }
                    else
                    {
                        vstv.CenterLines(line_number, 1);
                    }
                    return;
                }
            }
            catch (Exception exception)
            {
                Logger.Log.Notify(exception.StackTrace);
            }
        }