コード例 #1
0
            public IEnumerable <ITagSpan <IClassificationTag> > GetTags(NormalizedSnapshotSpanCollection spans)
            {
                foreach (SnapshotSpan span in spans)
                {
                    for (int line = span.Snapshot.GetLineNumberFromPosition(span.Start.Position); line <= span.Snapshot.GetLineNumberFromPosition(span.End.Position); line++)
                    {
                        ITextSnapshotLine l = span.Snapshot.GetLineFromLineNumber(line);

                        /*List<Token> tokens = Lexer.Lex(l.GetText(), true);
                         * foreach (Token t in tokens)
                         * {
                         *  yield return new TagSpan<IClassificationTag>(new SnapshotSpan(span.Snapshot, l.Start.Position + t.StartIndex, t.Length), ClassifyToken(t));
                         * }*/
                        List <SAGESharp.LSS.Token> tokens        = SAGESharp.LSS.Scanner.Scan(l.GetText(), "", new List <SAGESharp.LSS.SyntaxError>(), false, false);
                        SAGESharp.LSS.Token        previousToken = null;
                        foreach (SAGESharp.LSS.Token t in tokens)
                        {
                            IClassificationTag tag = ClassifyToken(t, previousToken);
                            if (tag != null)
                            {
                                yield return(new TagSpan <IClassificationTag>(new SnapshotSpan(span.Snapshot, l.Start.Position + (int)t.Span.Start.Offset, (int)t.Span.Length), tag));
                            }
                            if (t.Type != SAGESharp.LSS.TokenType.Comment && t.Type != SAGESharp.LSS.TokenType.MultilineComment && t.Type != SAGESharp.LSS.TokenType.Whitespace)
                            {
                                previousToken = t;
                            }
                        }
                    }
                }
            }
コード例 #2
0
            private void Apply()
            {
                Regions.Clear();

                List <SAGESharp.LSS.Token> tokens = SAGESharp.LSS.Scanner.Scan(Snapshot.GetText(), "", new List <SyntaxError>(), true, true);

                Stack <SAGESharp.LSS.Token> stack = new Stack <SAGESharp.LSS.Token>();

                foreach (SAGESharp.LSS.Token token in tokens)
                {
                    if (token.Type == SAGESharp.LSS.TokenType.OpenBrace)
                    {
                        stack.Push(token);
                    }
                    else if (token.Type == SAGESharp.LSS.TokenType.CloseBrace && stack.Count > 0)
                    {
                        SAGESharp.LSS.Token start = stack.Pop();
                        Regions.Add(new FoldRegion((int)start.Span.Start.Offset, (int)(token.Span.End - start.Span.Start.Offset), "...", ""));
                    }
                }

                Regions.Reverse();

                this.TagsChanged?.Invoke(this, new SnapshotSpanEventArgs(new SnapshotSpan(Snapshot, new Span(0, Snapshot.Length))));
            }
コード例 #3
0
            private IClassificationTag ClassifyToken(SAGESharp.LSS.Token token, SAGESharp.LSS.Token previousToken)
            {
                IClassificationType classification = null;

                if (token.Type == SAGESharp.LSS.TokenType.Comment ||
                    token.Type == SAGESharp.LSS.TokenType.MultilineComment)
                {
                    classification = StandardClassifications.Comment;
                }
                else if (token.Type == SAGESharp.LSS.TokenType.StringLiteral)
                {
                    classification = StandardClassifications.StringLiteral;
                }
                else if (token.Type == SAGESharp.LSS.TokenType.Whitespace)
                {
                    classification = StandardClassifications.WhiteSpace;
                }
                else if (token.Type == SAGESharp.LSS.TokenType.IntegerLiteral ||
                         token.Type == SAGESharp.LSS.TokenType.FloatLiteral)
                {
                    classification = StandardClassifications.NumberLiteral;
                }
                else if (token.Type >= SAGESharp.LSS.TokenType.KeywordClass &&
                         token.Type <= SAGESharp.LSS.TokenType.KeywordClassID)
                {
                    classification = StandardClassifications.Keyword;
                }
                else if (token.Type == SAGESharp.LSS.TokenType.Symbol &&
                         (previousToken?.Type == SAGESharp.LSS.TokenType.KeywordClass ||
                          previousToken?.Type == SAGESharp.LSS.TokenType.KeywordNew))
                {
                    classification = ClassificationRegistry.GetClassificationType("type"); // "class name", "type"
                }
                else if (token.Type == SAGESharp.LSS.TokenType.Symbol &&
                         previousToken?.Type == SAGESharp.LSS.TokenType.Period)
                {
                    classification = StandardClassifications.NumberLiteral;
                }
                else if ((token.Type >= SAGESharp.LSS.TokenType.Period &&
                          token.Type <= SAGESharp.LSS.TokenType.ColonColonDollarSign) ||
                         (token.Type >= SAGESharp.LSS.TokenType.Exclamation &&
                          token.Type <= SAGESharp.LSS.TokenType.LessEquals))
                {
                    classification = StandardClassifications.Operator;
                }

                return(classification == null ? null : new ClassificationTag(classification));
            }