示例#1
0
        /// <summary>
        /// Initializes a new instance of the <see cref="BisonClassifier"/> class.
        /// </summary>
        /// <param name="registry">Classification registry.</param>
        internal BisonClassifier(ITextBuffer buffer, IStandardClassificationService classification, IClassificationTypeRegistryService registry)
        {
            ClassificationRegistry = registry;
            Classification         = classification;
            Buffer = buffer;

            if (registry.GetClassificationType("Bison Token") != null)
            {
                BisonToken = registry.GetClassificationType("Bison Token");
            }
            else
            {
                BisonToken = registry.CreateClassificationType("Bison Token", new IClassificationType[0]);
            }

            if (registry.GetClassificationType("Block Name") != null)
            {
                BlockName = registry.GetClassificationType("Block Name");
            }
            else
            {
                BlockName = registry.CreateClassificationType("Block Name", new IClassificationType[0]);
            }

            _multiLineTokens = new List <MultiLineToken>();

            tokenizer = new BisonTokenizer(classification);
        }
示例#2
0
        private void AddDotNetClassificationTypes()
        {
            if (!_customClassificationTypesAdded)
            {
                _customClassificationTypesAdded = true;

                var identiferClassificationType = _classifications.GetClassificationType("identifier");
                var classificationFormatMap     = _classificationFormatMapService.GetClassificationFormatMap(category: "text");
                var spanClasses          = DotNetLang.Instance.GetSpanClasses();
                var identifierProperties = classificationFormatMap.GetExplicitTextProperties(identiferClassificationType);

                foreach (var spanClass in spanClasses)
                {
                    if (_classifications.GetClassificationType(spanClass.FullName) != null)
                    {
                        continue;
                    }

                    var classificationType = _classifications.CreateClassificationType(spanClass.FullName, new[] { identiferClassificationType });
                    var argb  = spanClass.Style.ForegroundColor;
                    var color = Color.FromArgb((byte)(argb >> 24), (byte)(argb >> 16), (byte)(argb >> 8), (byte)argb);
                    var classificationTypeProperties = identifierProperties.SetForeground(color);

                    classificationFormatMap.AddExplicitTextProperties(classificationType, classificationTypeProperties);
                }

                var textClassificationType = _classifications.GetClassificationType("text");
                var textProperties         = classificationFormatMap.GetExplicitTextProperties(textClassificationType);

                //CommonForegroundBrush = textProperties.ForegroundBrush;
            }
        }
        private ColorizedIdentifier GenerateIdentifier(string text)
        {
            var    identifier = new ColorizedIdentifier(text);
            Prefix prefix     = GetPrefix(identifier.Text);

            identifier.Prefix = prefix;

            identifier.Color = GenerateColor(identifier);

            var classificationName = ClassificationPrefix + identifier.Text;
            IClassificationType classification;

            if (_typeRegistry.GetClassificationType(classificationName) != null)
            {
                classification = _typeRegistry.GetClassificationType(classificationName);
            }
            else
            {
                classification     = _typeRegistry.CreateClassificationType(classificationName, new[] { _baseClassification });
                identifier.IsDirty = true;
            }

            identifier.Classification = classification;
            return(identifier);
        }
示例#4
0
 public static void SyncWithConfigs(this IClassificationTypeRegistryService service)
 {
     foreach (var cls in ConfigService.Current.CommentConfiguration.Classifications)
     {
         if (service.GetClassificationType(cls.Key) == null)
         {
             service.CreateClassificationType(cls.Key, Array.Empty <IClassificationType>());
         }
     }
 }
示例#5
0
        public static IClassificationType GetOrCreateClassificationType(this IClassificationTypeRegistryService classificationTypeRegistryService, string type)
        {
            var classificationType = classificationTypeRegistryService.GetClassificationType(type);

            if (classificationType == null)
            {
                classificationType = classificationTypeRegistryService.CreateClassificationType(type, new IClassificationType[] { });
            }

            return(classificationType);
        }
示例#6
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);
            }
        }
示例#7
0
        internal void Initialize(IClassificationTypeRegistryService service,
                                 IClassificationFormatMapService ClassificationFormatMapService)
        {
            try
            {
                if (initialized)
                {
                    return;
                }

                string ffn = _buffer.GetFFN().Result;
                if (ffn == null)
                {
                    return;
                }

                LanguageServer.IGrammarDescription _grammar_description = LanguageServer.GrammarDescriptionFactory.Create(ffn);
                if (_grammar_description == null)
                {
                    return;
                }

                Workspaces.Document document = Workspaces.Workspace.Instance.FindDocument(ffn);
                _lsptype_to_classifiertype = new Dictionary <int, IClassificationType>();
                for (int i = 0; i < _grammar_description.Map.Length; ++i)
                {
                    int    key = i;
                    string val = _grammar_description.Map[i];
                    IClassificationType identiferClassificationType = service.GetClassificationType(val);
                    IClassificationType classificationType          = identiferClassificationType == null?service.CreateClassificationType(val, new IClassificationType[] { })
                                                                          : identiferClassificationType;

                    IClassificationFormatMap classificationFormatMap = ClassificationFormatMapService.GetClassificationFormatMap(category: "text");
                    Microsoft.VisualStudio.Text.Formatting.TextFormattingRunProperties identifierProperties = classificationFormatMap
                                                                                                              .GetExplicitTextProperties(classificationType);
                    System.Drawing.Color 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);
                    Microsoft.VisualStudio.Text.Formatting.TextFormattingRunProperties newProperties = identifierProperties.SetForeground(newColor);
                    classificationFormatMap.AddExplicitTextProperties(classificationType, newProperties);
                }
                {
                    int    key = (int)SymbolKind.Variable;
                    string val = _grammar_description.Map[0];
                    _lsptype_to_classifiertype[key] = service.GetClassificationType(val);
                }
                {
                    int    key = (int)SymbolKind.Enum;
                    string val = _grammar_description.Map[1];
                    _lsptype_to_classifiertype[key] = service.GetClassificationType(val);
                }
                initialized = true;
            }
            catch (Exception)
            {
                //Logger.Log.Notify(exception.StackTrace);
            }
        }
示例#8
0
        internal void Initialize(IClassificationTypeRegistryService service,
                                 IClassificationFormatMapService ClassificationFormatMapService)
        {
            try
            {
                if (initialized)
                {
                    return;
                }

                string ffn = _buffer.GetFFN();
                if (ffn == null)
                {
                    return;
                }

                Workspaces.Document document = Workspaces.Workspace.Instance.FindDocument(ffn);
                LanguageServer.IParserDescription _grammar_description = LanguageServer.ParserDescriptionFactory.Create(document);
                if (_grammar_description == null)
                {
                    return;
                }

                _to_classifiertype = new Dictionary <int, IClassificationType>();

                IClassificationFormatMap classificationFormatMap = ClassificationFormatMapService.GetClassificationFormatMap(category: "text");
                // hardwire colors to VS's colors of selected types.
                System.Collections.ObjectModel.ReadOnlyCollection <IClassificationType> list_of_formats = classificationFormatMap.CurrentPriorityOrder;

                {
                    int    i   = (int)LanguageServer.Antlr4ParsingResults.AntlrClassifications.ClassificationNonterminalDef;
                    string val = _grammar_description.Map[i];
                    IClassificationType identiferClassificationType = service.GetClassificationType(val);
                    IClassificationType classificationType          = identiferClassificationType ?? service.CreateClassificationType(val, Array.Empty <IClassificationType>());
                    IClassificationType t = list_of_formats.Where(f => f != null && f.Classification == Options.Option.GetString("AntlrNonterminalDef")).FirstOrDefault();
                    if (t != null)
                    {
                        try
                        {
                            Microsoft.VisualStudio.Text.Formatting.TextFormattingRunProperties identifierProperties = classificationFormatMap
                                                                                                                      .GetExplicitTextProperties(t);
                            classificationFormatMap.AddExplicitTextProperties(classificationType, identifierProperties);
                        }
#pragma warning disable CS0168 // Variable is declared but never used
                        catch (Exception eeks) { }
#pragma warning restore CS0168 // Variable is declared but never used
                    }
                    _to_classifiertype[i] = classificationType;
                }
                {
                    int    i   = (int)LanguageServer.Antlr4ParsingResults.AntlrClassifications.ClassificationNonterminalRef;
                    string val = _grammar_description.Map[i];
                    IClassificationType identiferClassificationType = service.GetClassificationType(val);
                    IClassificationType classificationType          = identiferClassificationType ?? service.CreateClassificationType(val, Array.Empty <IClassificationType>());
                    IClassificationType t = list_of_formats.Where(f => f != null && f.Classification == Options.Option.GetString("AntlrNonterminalRef")).FirstOrDefault();
                    if (t != null)
                    {
                        try
                        {
                            Microsoft.VisualStudio.Text.Formatting.TextFormattingRunProperties identifierProperties = classificationFormatMap
                                                                                                                      .GetExplicitTextProperties(t);
                            classificationFormatMap.AddExplicitTextProperties(classificationType, identifierProperties);
                        }
#pragma warning disable 0168
                        catch (Exception eeks) { }
#pragma warning restore 0168
                    }
                    _to_classifiertype[i] = classificationType;
                }
                {
                    int    i   = (int)LanguageServer.Antlr4ParsingResults.AntlrClassifications.ClassificationTerminalDef;
                    string val = _grammar_description.Map[i];
                    IClassificationType identiferClassificationType = service.GetClassificationType(val);
                    IClassificationType classificationType          = identiferClassificationType ?? service.CreateClassificationType(val, Array.Empty <IClassificationType>());
                    IClassificationType t = list_of_formats.Where(f => f != null && f.Classification == Options.Option.GetString("AntlrTerminalDef")).FirstOrDefault();
                    if (t != null)
                    {
                        try
                        {
                            Microsoft.VisualStudio.Text.Formatting.TextFormattingRunProperties identifierProperties = classificationFormatMap
                                                                                                                      .GetExplicitTextProperties(t);
                            classificationFormatMap.AddExplicitTextProperties(classificationType, identifierProperties);
                        }
#pragma warning disable 0168
                        catch (Exception eeks) { }
#pragma warning restore 0168
                    }
                    _to_classifiertype[i] = classificationType;
                }
                {
                    int    i   = (int)LanguageServer.Antlr4ParsingResults.AntlrClassifications.ClassificationTerminalRef;
                    string val = _grammar_description.Map[i];
                    IClassificationType identiferClassificationType = service.GetClassificationType(val);
                    IClassificationType classificationType          = identiferClassificationType ?? service.CreateClassificationType(val, Array.Empty <IClassificationType>());
                    IClassificationType t = list_of_formats.Where(f => f != null && f.Classification == Options.Option.GetString("AntlrTerminalRef")).FirstOrDefault();
                    if (t != null)
                    {
                        try
                        {
                            Microsoft.VisualStudio.Text.Formatting.TextFormattingRunProperties identifierProperties = classificationFormatMap
                                                                                                                      .GetExplicitTextProperties(t);
                            classificationFormatMap.AddExplicitTextProperties(classificationType, identifierProperties);
                        }
#pragma warning disable 0168
                        catch (Exception eeks) { }
#pragma warning restore 0168
                    }
                    _to_classifiertype[i] = classificationType;
                }
                {
                    int    i   = (int)LanguageServer.Antlr4ParsingResults.AntlrClassifications.ClassificationComment;
                    string val = _grammar_description.Map[i];
                    IClassificationType identiferClassificationType = service.GetClassificationType(val);
                    IClassificationType classificationType          = identiferClassificationType ?? service.CreateClassificationType(val, Array.Empty <IClassificationType>());
                    IClassificationType t = list_of_formats.Where(f => f != null && f.Classification == Options.Option.GetString("AntlrComment")).FirstOrDefault();
                    if (t != null)
                    {
                        try
                        {
                            Microsoft.VisualStudio.Text.Formatting.TextFormattingRunProperties identifierProperties = classificationFormatMap
                                                                                                                      .GetExplicitTextProperties(t);
                            classificationFormatMap.AddExplicitTextProperties(classificationType, identifierProperties);
                        }
#pragma warning disable 0168
                        catch (Exception eeks) { }
#pragma warning restore 0168
                    }
                    _to_classifiertype[i] = classificationType;
                }
                {
                    int    i   = (int)LanguageServer.Antlr4ParsingResults.AntlrClassifications.ClassificationKeyword;
                    string val = _grammar_description.Map[i];
                    IClassificationType identiferClassificationType = service.GetClassificationType(val);
                    IClassificationType classificationType          = identiferClassificationType ?? service.CreateClassificationType(val, Array.Empty <IClassificationType>());
                    IClassificationType t = list_of_formats.Where(f => f != null && f.Classification == Options.Option.GetString("AntlrKeyword")).FirstOrDefault();
                    if (t != null)
                    {
                        try
                        {
                            Microsoft.VisualStudio.Text.Formatting.TextFormattingRunProperties identifierProperties = classificationFormatMap
                                                                                                                      .GetExplicitTextProperties(t);
                            classificationFormatMap.AddExplicitTextProperties(classificationType, identifierProperties);
                        }
#pragma warning disable 0168
                        catch (Exception eeks) { }
#pragma warning restore 0168
                    }
                    _to_classifiertype[i] = classificationType;
                }
                {
                    int    i   = (int)LanguageServer.Antlr4ParsingResults.AntlrClassifications.ClassificationLiteral;
                    string val = _grammar_description.Map[i];
                    IClassificationType identiferClassificationType = service.GetClassificationType(val);
                    IClassificationType classificationType          = identiferClassificationType ?? service.CreateClassificationType(val, Array.Empty <IClassificationType>());
                    IClassificationType t = list_of_formats.Where(f => f != null && f.Classification == Options.Option.GetString("AntlrLiteral")).FirstOrDefault();
                    if (t != null)
                    {
                        try
                        {
                            Microsoft.VisualStudio.Text.Formatting.TextFormattingRunProperties identifierProperties = classificationFormatMap
                                                                                                                      .GetExplicitTextProperties(t);
                            classificationFormatMap.AddExplicitTextProperties(classificationType, identifierProperties);
                        }
#pragma warning disable 0168
                        catch (Exception eeks) { }
#pragma warning restore 0168
                    }
                    _to_classifiertype[i] = classificationType;
                }
                {
                    int    i   = (int)LanguageServer.Antlr4ParsingResults.AntlrClassifications.ClassificationModeDef;
                    string val = _grammar_description.Map[i];
                    IClassificationType identiferClassificationType = service.GetClassificationType(val);
                    IClassificationType classificationType          = identiferClassificationType ?? service.CreateClassificationType(val, Array.Empty <IClassificationType>());
                    IClassificationType t = list_of_formats.Where(f => f != null && f.Classification == Options.Option.GetString("AntlrModeDef")).FirstOrDefault();
                    if (t != null)
                    {
                        try
                        {
                            Microsoft.VisualStudio.Text.Formatting.TextFormattingRunProperties identifierProperties = classificationFormatMap
                                                                                                                      .GetExplicitTextProperties(t);
                            classificationFormatMap.AddExplicitTextProperties(classificationType, identifierProperties);
                        }
#pragma warning disable 0168
                        catch (Exception eeks) { }
#pragma warning restore 0168
                    }
                    _to_classifiertype[i] = classificationType;
                }
                {
                    int    i   = (int)LanguageServer.Antlr4ParsingResults.AntlrClassifications.ClassificationModeRef;
                    string val = _grammar_description.Map[i];
                    IClassificationType identiferClassificationType = service.GetClassificationType(val);
                    IClassificationType classificationType          = identiferClassificationType ?? service.CreateClassificationType(val, Array.Empty <IClassificationType>());
                    IClassificationType t = list_of_formats.Where(f => f != null && f.Classification == Options.Option.GetString("AntlrModeRef")).FirstOrDefault();
                    if (t != null)
                    {
                        try
                        {
                            Microsoft.VisualStudio.Text.Formatting.TextFormattingRunProperties identifierProperties = classificationFormatMap
                                                                                                                      .GetExplicitTextProperties(t);
                            classificationFormatMap.AddExplicitTextProperties(classificationType, identifierProperties);
                        }
#pragma warning disable 0168
                        catch (Exception eeks) { }
#pragma warning restore 0168
                    }
                    _to_classifiertype[i] = classificationType;
                }
                {
                    int    i   = (int)LanguageServer.Antlr4ParsingResults.AntlrClassifications.ClassificationChannelDef;
                    string val = _grammar_description.Map[i];
                    IClassificationType identiferClassificationType = service.GetClassificationType(val);
                    IClassificationType classificationType          = identiferClassificationType ?? service.CreateClassificationType(val, Array.Empty <IClassificationType>());
                    IClassificationType t = list_of_formats.Where(f => f != null && f.Classification == Options.Option.GetString("AntlrChannelDef")).FirstOrDefault();
                    if (t != null)
                    {
                        try
                        {
                            Microsoft.VisualStudio.Text.Formatting.TextFormattingRunProperties identifierProperties = classificationFormatMap
                                                                                                                      .GetExplicitTextProperties(t);
                            classificationFormatMap.AddExplicitTextProperties(classificationType, identifierProperties);
                        }
#pragma warning disable 0168
                        catch (Exception eeks) { }
#pragma warning restore 0168
                    }
                    _to_classifiertype[i] = classificationType;
                }
                {
                    int    i   = (int)LanguageServer.Antlr4ParsingResults.AntlrClassifications.ClassificationChannelRef;
                    string val = _grammar_description.Map[i];
                    IClassificationType identiferClassificationType = service.GetClassificationType(val);
                    IClassificationType classificationType          = identiferClassificationType ?? service.CreateClassificationType(val, Array.Empty <IClassificationType>());
                    IClassificationType t = list_of_formats.Where(f => f != null && f.Classification == Options.Option.GetString("AntlrChannelRef")).FirstOrDefault();
                    if (t != null)
                    {
                        try
                        {
                            Microsoft.VisualStudio.Text.Formatting.TextFormattingRunProperties identifierProperties = classificationFormatMap
                                                                                                                      .GetExplicitTextProperties(t);
                            classificationFormatMap.AddExplicitTextProperties(classificationType, identifierProperties);
                        }
#pragma warning disable 0168
                        catch (Exception eeks) { }
#pragma warning restore 0168
                    }
                    _to_classifiertype[i] = classificationType;
                }
                {
                    int    i   = (int)LanguageServer.Antlr4ParsingResults.AntlrClassifications.ClassificationPunctuation;
                    string val = _grammar_description.Map[i];
                    IClassificationType identiferClassificationType = service.GetClassificationType(val);
                    IClassificationType classificationType          = identiferClassificationType ?? service.CreateClassificationType(val, Array.Empty <IClassificationType>());
                    IClassificationType t = list_of_formats.Where(f => f != null && f.Classification == Options.Option.GetString("AntlrPunctuation")).FirstOrDefault();
                    if (t != null)
                    {
                        try
                        {
                            Microsoft.VisualStudio.Text.Formatting.TextFormattingRunProperties identifierProperties = classificationFormatMap
                                                                                                                      .GetExplicitTextProperties(t);
                            classificationFormatMap.AddExplicitTextProperties(classificationType, identifierProperties);
                        }
#pragma warning disable 0168
                        catch (Exception eeks) { }
#pragma warning restore 0168
                    }
                    _to_classifiertype[i] = classificationType;
                }
                {
                    int    i   = (int)LanguageServer.Antlr4ParsingResults.AntlrClassifications.ClassificationOperator;
                    string val = _grammar_description.Map[i];
                    IClassificationType identiferClassificationType = service.GetClassificationType(val);
                    IClassificationType classificationType          = identiferClassificationType ?? service.CreateClassificationType(val, Array.Empty <IClassificationType>());
                    IClassificationType t = list_of_formats.Where(f => f != null && f.Classification == Options.Option.GetString("AntlrOperator")).FirstOrDefault();
                    if (t != null)
                    {
                        try
                        {
                            Microsoft.VisualStudio.Text.Formatting.TextFormattingRunProperties identifierProperties = classificationFormatMap
                                                                                                                      .GetExplicitTextProperties(t);
                            classificationFormatMap.AddExplicitTextProperties(classificationType, identifierProperties);
                        }
#pragma warning disable 0168
                        catch (Exception eeks) { }
#pragma warning restore 0168
                    }
                    _to_classifiertype[i] = classificationType;
                }
                initialized = true;
            }
#pragma warning disable 0168
            catch (Exception eeks) { }
#pragma warning restore 0168
        }