Changeset 2123


Ignore:
Timestamp:
Nov 30, 2012, 6:40:43 PM (7 years ago)
Author:
sam
Message:

vslol: add licensing information to important files.

Location:
trunk/tools/vslol
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/tools/vslol/CppKeywordClassifier.cs

    r2122 r2123  
     1//
     2// Lol Engine - VsLol add-in for Visual Studio
     3//
     4// Copyright: (c) 2010-2012 Sam Hocevar <sam@hocevar.net>
     5//   This program is free software; you can redistribute it and/or
     6//   modify it under the terms of the Do What The Fuck You Want To
     7//   Public License, Version 2, as published by Sam Hocevar. See
     8//   http://www.wtfpl.net/ for more details.
     9//
     10
    111using System;
    212using System.Collections.Generic;
    … …  
    1121using Microsoft.VisualStudio.Utilities;
    1222
    13 namespace Lol.VisualStudio.Plugin
    14 {
    15     [Export(typeof(IClassifierProvider))]
    16     [ContentType("c/c++")]
    17     [ContentType("csharp")]
    18     [ContentType("lolfx")]
    19     internal class LolClassifierProvider : IClassifierProvider
    20     {
    21         [Import]
    22         internal IClassificationTypeRegistryService m_type_registry = null; /* Set via MEF */
    23         [Import]
    24         internal IClassifierAggregatorService m_aggregator = null;
    25         [Import]
    26         internal IClassificationFormatMapService m_format_map = null;
    27 
    28         internal static bool m_inprogress = false;
    29 
    30         public IClassifier GetClassifier(ITextBuffer buffer)
    31         {
    32             /* Avoid infinite recursion */
    33             if (m_inprogress)
    34                 return null;
    35 
    36             LolGenericFormat.SetRegistry(m_type_registry, m_format_map);
    37 
    38             try
     23namespace lol
     24{
     25
     26[Export(typeof(IClassifierProvider))]
     27[ContentType("c/c++")]
     28[ContentType("csharp")]
     29[ContentType("lolfx")]
     30internal class LolClassifierProvider : IClassifierProvider
     31{
     32    [Import]
     33    internal IClassificationTypeRegistryService m_type_registry = null; /* Set via MEF */
     34    [Import]
     35    internal IClassifierAggregatorService m_aggregator = null;
     36    [Import]
     37    internal IClassificationFormatMapService m_format_map = null;
     38
     39    internal static bool m_inprogress = false;
     40
     41    public IClassifier GetClassifier(ITextBuffer buffer)
     42    {
     43        /* Avoid infinite recursion */
     44        if (m_inprogress)
     45            return null;
     46
     47        LolGenericFormat.SetRegistry(m_type_registry, m_format_map);
     48
     49        try
     50        {
     51            m_inprogress = true;
     52            return buffer.Properties.GetOrCreateSingletonProperty<CppKeywordClassifier>(delegate { return new CppKeywordClassifier(m_type_registry, m_aggregator.GetClassifier(buffer), buffer.ContentType); });
     53        }
     54        finally { m_inprogress = false; }
     55    }
     56}
     57
     58class CppKeywordClassifier : IClassifier
     59{
     60    private IClassifier m_classifier;
     61
     62    private IClassificationType m_customclass_type, m_constant_type;
     63    private Regex m_customclass_regex, m_constant_regex;
     64
     65    internal CppKeywordClassifier(IClassificationTypeRegistryService registry,
     66                                  IClassifier classifier,
     67                                  IContentType type)
     68    {
     69        m_classifier = classifier;
     70
     71        /* Regex for types and specifiers */
     72        m_customclass_type = registry.GetClassificationType("LolCustomClass");
     73
     74        string tmp = @"\b(";
     75        tmp += "void|bool|int|unsigned|char|short|long|float|double|ldouble|";
     76        tmp += "class|struct|union|template|const|static|extern|volatile|inline|namespace|";
     77        if (type.IsOfType("lolfx"))
     78            tmp += "attribute|varying|uniform|in|out|";
     79        if (type.IsOfType("csharp"))
     80            tmp += "var|out|ref|string|internal|sealed|public|private|protected|override|";
     81        if (!type.IsOfType("csharp"))
     82            tmp += "(f(16|128)||d|[ui](8|16||64)|r)(vec[234]|mat[234]|quat|cmplx)|";
     83        if (type.IsOfType("c/c++"))
     84        {
     85            tmp += "u?int(8|16|32|64|ptr)_t|";
     86            tmp += "(wchar|size|ssize)_t|";
     87            tmp += "real|half|explicit|typename|typedef|auto|";
     88        }
     89        tmp = tmp.Remove(tmp.Length - 1);
     90        tmp += @")\b";
     91        m_customclass_regex = new Regex(tmp);
     92
     93        /* Regex for constant words */
     94        m_constant_type = registry.GetClassificationType("LolCppConstant");
     95
     96        if (type.IsOfType("csharp"))
     97            m_constant_regex = new Regex(@"\b(null|true|false)\b");
     98        else if (type.IsOfType("c/c++"))
     99            m_constant_regex = new Regex(@"\b(NULL|nullptr|true|false|M_PI)\b");
     100        else if (type.IsOfType("lolfx"))
     101            m_constant_regex = new Regex(@"\b(gl_Position|gl_FragColor)\b");
     102        else
     103            m_constant_regex = new Regex(@"\b(NULL)\b");
     104
     105    }
     106
     107    public IList<ClassificationSpan> GetClassificationSpans(SnapshotSpan span)
     108    {
     109        List<ClassificationSpan> ret = new List<ClassificationSpan>();
     110
     111        foreach (ClassificationSpan cs in m_classifier.GetClassificationSpans(span))
     112        {
     113            string cs_class = cs.ClassificationType.Classification.ToLower();
     114
     115            /* Only apply our rules if we found a keyword or an identifier */
     116            if (cs_class == "keyword" || cs_class == "identifier")
    39117            {
    40                 m_inprogress = true;
    41                 return buffer.Properties.GetOrCreateSingletonProperty<CppKeywordClassifier>(delegate { return new CppKeywordClassifier(m_type_registry, m_aggregator.GetClassifier(buffer), buffer.ContentType); });
     118                if (m_customclass_regex.IsMatch(cs.Span.GetText()))
     119                {
     120                    ret.Add(new ClassificationSpan(cs.Span, m_customclass_type));
     121                    continue;
     122                }
     123
     124                if (m_constant_regex.IsMatch(cs.Span.GetText()))
     125                {
     126                    ret.Add(new ClassificationSpan(cs.Span, m_constant_type));
     127                    continue;
     128                }
    42129            }
    43             finally { m_inprogress = false; }
    44         }
    45     }
    46 
    47     class CppKeywordClassifier : IClassifier
    48     {
    49         private IClassifier m_classifier;
    50 
    51         private IClassificationType m_customclass_type;
    52         private Regex m_customclass_regex;
    53 
    54         internal CppKeywordClassifier(IClassificationTypeRegistryService registry,
    55                                       IClassifier classifier,
    56                                       IContentType type)
    57         {
    58             m_classifier = classifier;
    59 
    60             m_customclass_type = registry.GetClassificationType("LolCustomClass");
    61 
    62             string tmp = @"\b(";
    63             tmp += "void|bool|int|unsigned|char|short|long|float|double|ldouble|";
    64             tmp += "class|struct|union|template|const|static|extern|volatile|inline|namespace|";
    65             if (type.IsOfType("lolfx"))
    66                 tmp += "attribute|varying|uniform|in|out|";
    67             if (type.IsOfType("csharp"))
    68                 tmp += "var|string|internal|sealed|public|private|protected|";
    69             if (!type.IsOfType("csharp"))
    70                 tmp += "(f(16|128)||d|[ui](8|16||64)|r)(vec[234]|mat[234]|quat|cmplx)|";
    71             if (type.IsOfType("c/c++"))
    72             {
    73                 tmp += "u?int(8|16|32|64|ptr)_t|";
    74                 tmp += "real|half|explicit|typename|typedef|";
    75             }
    76             tmp = tmp.Remove(tmp.Length - 1);
    77             tmp += @")\b";
    78             m_customclass_regex = new Regex(tmp);
    79         }
    80 
    81         public IList<ClassificationSpan> GetClassificationSpans(SnapshotSpan span)
    82         {
    83             List<ClassificationSpan> ret = new List<ClassificationSpan>();
    84 
    85             foreach (ClassificationSpan cs in m_classifier.GetClassificationSpans(span))
    86             {
    87                 string cs_class = cs.ClassificationType.Classification.ToLower();
    88 
    89                 /* Only apply our rules if we found a keyword or an identifier */
    90                 if (cs_class == "keyword" || cs_class == "identifier")
    91                 {
    92                     if (m_customclass_regex.IsMatch(cs.Span.GetText()))
    93                     {
    94                         ret.Add(new ClassificationSpan(cs.Span, m_customclass_type));
    95                         continue;
    96                     }
    97                 }
    98 
    99                 ret.Add(cs);
    100             }
    101 
    102             return ret;
    103         }
    104 
    105         public event EventHandler<ClassificationChangedEventArgs> ClassificationChanged;
    106     }
    107 
    108     internal class LolGenericFormat : ClassificationFormatDefinition
    109     {
    110         static IClassificationTypeRegistryService m_type_registry;
    111         static IClassificationFormatMapService m_format_map;
    112 
    113         public static void SetRegistry(IClassificationTypeRegistryService type_registry,
    114                                        IClassificationFormatMapService format_map)
    115         {
    116             m_type_registry = type_registry;
    117             m_format_map = format_map;
    118         }
    119 
    120         protected void CopyStyleColor(string category)
    121         {
    122             if (m_type_registry == null || m_format_map == null)
    123                 return;
    124 
    125             var map = m_format_map.GetClassificationFormatMap("Text Editor");
    126             if (map == null)
    127                 return;
    128 
    129             //string[] foo = { "Comment", "Keyword", "C/C++ User Keywords", "Call Return", "HTML Comment" , "User Types", "User Types (Type parameters)", "User Types (Value types)"};
    130 
    131             var type = m_type_registry.GetClassificationType(category);
    132             if (type == null)
    133                 return;
    134 
    135             var prop = map.GetExplicitTextProperties(type);
    136             if (prop == null)
    137                 return;
    138 
    139             var c1 = prop.ForegroundBrush as SolidColorBrush;
    140             if (c1 != null && c1.Color != Colors.Transparent)
    141                 this.ForegroundColor = c1.Color;
    142             var c2 = prop.BackgroundBrush as SolidColorBrush;
    143             if (c2 != null && c2.Color != Colors.Transparent)
    144                 this.BackgroundColor = c1.Color;
    145         }
    146     }
    147 
    148     internal static class LolClassifierClassificationDefinition
    149     {
    150         [Export(typeof(ClassificationTypeDefinition))]
    151         [Name(LolCppTypeFormat.m_name)]
    152         internal static ClassificationTypeDefinition LolCustomClassType = null;
    153     }
    154 
    155     [Export(typeof(EditorFormatDefinition))]
    156     [ClassificationType(ClassificationTypeNames = LolCppTypeFormat.m_name)]
     130
     131            ret.Add(cs);
     132        }
     133
     134        return ret;
     135    }
     136
     137    public event EventHandler<ClassificationChangedEventArgs> ClassificationChanged;
     138}
     139
     140internal class LolGenericFormat : ClassificationFormatDefinition
     141{
     142    static IClassificationTypeRegistryService m_type_registry;
     143    static IClassificationFormatMapService m_format_map;
     144
     145    public static void SetRegistry(IClassificationTypeRegistryService type_registry,
     146                                   IClassificationFormatMapService format_map)
     147    {
     148        m_type_registry = type_registry;
     149        m_format_map = format_map;
     150    }
     151
     152    protected void CopyStyleColor(string category)
     153    {
     154        if (m_type_registry == null || m_format_map == null)
     155            return;
     156
     157        var map = m_format_map.GetClassificationFormatMap("Text Editor");
     158        if (map == null)
     159            return;
     160
     161        //string[] foo = { "Comment", "Keyword", "C/C++ User Keywords", "Call Return", "HTML Comment" , "User Types", "User Types (Type parameters)", "User Types (Value types)"};
     162
     163        var type = m_type_registry.GetClassificationType(category);
     164        if (type == null)
     165            return;
     166
     167        var prop = map.GetExplicitTextProperties(type);
     168        if (prop == null)
     169            return;
     170
     171        var c1 = prop.ForegroundBrush as SolidColorBrush;
     172        if (c1 != null && c1.Color != Colors.Transparent)
     173        {
     174            this.ForegroundColor = c1.Color;
     175            this.ForegroundOpacity = 1.0;
     176        }
     177        var c2 = prop.BackgroundBrush as SolidColorBrush;
     178        if (c2 != null && c2.Color != Colors.Transparent)
     179        {
     180            this.BackgroundColor = c2.Color;
     181            this.BackgroundOpacity = 1.0;
     182        }
     183    }
     184}
     185
     186internal static class LolClassifierClassificationDefinition
     187{
     188    [Export(typeof(ClassificationTypeDefinition))]
    157189    [Name(LolCppTypeFormat.m_name)]
    158     [UserVisible(true)]
    159     [Order(After = Priority.Default)] /* Override the Visual Studio classifiers */
    160     internal sealed class LolCppTypeFormat : LolGenericFormat
    161     {
    162         public const string m_name = "LolCustomClass";
    163         public LolCppTypeFormat()
    164         {
    165             this.DisplayName = "C/C++ Types and Qualifiers";
    166             this.ForegroundColor = Colors.Lime;
    167             this.IsBold = true;
    168             //CopyStyleColor("User Types");
    169         }
    170     }
    171 }
     190    internal static ClassificationTypeDefinition LolCustomClassType = null;
     191
     192    [Export(typeof(ClassificationTypeDefinition))]
     193    [Name(LolCppConstantFormat.m_name)]
     194    internal static ClassificationTypeDefinition LolCustomConstantType = null;
     195}
     196
     197[Export(typeof(EditorFormatDefinition))]
     198[ClassificationType(ClassificationTypeNames = LolCppTypeFormat.m_name)]
     199[Name(LolCppTypeFormat.m_name)]
     200[UserVisible(true)]
     201[Order(After = Priority.Default)] /* Override the Visual Studio classifiers */
     202internal sealed class LolCppTypeFormat : LolGenericFormat
     203{
     204    public const string m_name = "LolCustomClass";
     205    public LolCppTypeFormat()
     206    {
     207        this.DisplayName = "C/C++ Types and Qualifiers";
     208        this.ForegroundColor = Colors.Lime;
     209        this.ForegroundOpacity = 1.0;
     210        this.IsBold = true;
     211        //CopyStyleColor("User Types");
     212    }
     213}
     214
     215[Export(typeof(EditorFormatDefinition))]
     216[ClassificationType(ClassificationTypeNames = LolCppConstantFormat.m_name)]
     217[Name(LolCppConstantFormat.m_name)]
     218[UserVisible(true)]
     219[Order(After = Priority.Default)] /* Override the Visual Studio classifiers */
     220internal sealed class LolCppConstantFormat : LolGenericFormat
     221{
     222    public const string m_name = "LolCppConstant";
     223    public LolCppConstantFormat()
     224    {
     225        this.DisplayName = "C/C++ Constants";
     226        this.ForegroundColor = Colors.Magenta;
     227        this.ForegroundOpacity = 1.0;
     228        this.IsBold = true;
     229        //CopyStyleColor("User Types");
     230    }
     231}
     232
     233} /* namespace lol */

  • trunk/tools/vslol/LolFxLanguageService.cs

    r2118 r2123  
    1 using System;
     1//
     2// Lol Engine - VsLol add-in for Visual Studio
     3//
     4// Copyright: (c) 2010-2012 Sam Hocevar <sam@hocevar.net>
     5//   This program is free software; you can redistribute it and/or
     6//   modify it under the terms of the Do What The Fuck You Want To
     7//   Public License, Version 2, as published by Sam Hocevar. See
     8//   http://www.wtfpl.net/ for more details.
     9//
     10
    211using System.Collections.Generic;
    312using System.Linq;
    … …  
    918using Microsoft.VisualStudio.OLE.Interop;
    1019
    11 namespace Lol.VisualStudio.Plugin
     20namespace lol
    1221{
    13     class LolFxLanguageService : LanguageService
     22
     23class LolFxLanguageService : LanguageService
     24{
     25    public override string GetFormatFilterList()
    1426    {
    15         public override string GetFormatFilterList()
     27        throw new NotImplementedException();
     28    }
     29
     30    public override LanguagePreferences GetLanguagePreferences()
     31    {
     32        if (m_preferences == null)
    1633        {
    17             throw new NotImplementedException();
     34            m_preferences = new LanguagePreferences(this.Site,
     35                             typeof(LolFxLanguageService).GUID, this.Name);
     36            m_preferences.Init();
     37        }
     38        return m_preferences;
     39    }
     40
     41    public override IScanner GetScanner(IVsTextLines buffer)
     42    {
     43        if (m_scanner == null)
     44        {
     45             m_scanner = new LolFxScanner(buffer);
     46        }
     47        return m_scanner;
     48    }
     49
     50    public override string Name
     51    {
     52        get { return "LolFx"; }
     53    }
     54
     55    public override AuthoringScope ParseSource(ParseRequest req)
     56    {
     57        return new LolFxAuthoringScope();
     58    }
     59
     60    private LanguagePreferences m_preferences;
     61    private LolFxScanner m_scanner;
     62
     63    internal class LolFxScanner : IScanner
     64    {
     65        public LolFxScanner(IVsTextBuffer buffer)
     66        {
     67            m_buffer = buffer;
    1868        }
    1969
    20         public override LanguagePreferences GetLanguagePreferences()
     70        bool IScanner.ScanTokenAndProvideInfoAboutIt(TokenInfo tokeninfo, ref int state)
    2171        {
    22             if (m_preferences == null)
     72            while (m_offset < m_source.Length)
    2373            {
    24                 m_preferences = new LanguagePreferences(this.Site,
    25                                  typeof(LolFxLanguageService).GUID, this.Name);
    26                 m_preferences.Init();
     74                if (m_source[m_offset] == ' ' || m_source[m_offset] == '\t')
     75                   {
     76                    ++m_offset;
     77                    continue;
     78                   }
     79
     80                tokeninfo.StartIndex = m_offset;
     81                tokeninfo.EndIndex = m_offset;
     82                tokeninfo.Type = TokenType.Unknown;
     83                switch (state % 4)
     84                   {
     85                    case 0: tokeninfo.Color = TokenColor.Number; break;
     86                    case 1: tokeninfo.Color = TokenColor.Text; break;
     87                    case 2: tokeninfo.Color = TokenColor.Keyword; break;
     88                    case 3: tokeninfo.Color = TokenColor.Comment; break;
     89                }
     90                ++m_offset;
     91                ++state;
     92                return true;
    2793            }
    28             return m_preferences;
     94
     95            return false;
    2996        }
    3097
    31         public override IScanner GetScanner(IVsTextLines buffer)
     98        enum State
    3299        {
    33             if (m_scanner == null)
    34             {
    35                  m_scanner = new LolFxScanner(buffer);
    36             }
    37             return m_scanner;
     100            Default,
     101            CComment,
     102            CppComment,
     103            String,
    38104        }
    39105
    40         public override string Name
     106        void IScanner.SetSource(string source, int offset)
    41107        {
    42             get { return "LolFx"; }
     108            m_source = source;
     109            m_offset = offset;
    43110        }
    44111
    45         public override AuthoringScope ParseSource(ParseRequest req)
     112        private IVsTextBuffer m_buffer;
     113        string m_source;
     114        int m_offset;
     115    }
     116
     117    internal class LolFxAuthoringScope : AuthoringScope
     118    {
     119        public override string GetDataTipText(int line, int col, out TextSpan span)
    46120        {
    47             return new LolFxAuthoringScope();
     121            span = new TextSpan();
     122            return null;
    48123        }
    49124
    50         private LanguagePreferences m_preferences;
    51         private LolFxScanner m_scanner;
    52 
    53         internal class LolFxScanner : IScanner
     125        public override Declarations GetDeclarations(IVsTextView view,
     126                                                     int line,
     127                                                     int col,
     128                                                     TokenInfo info,
     129                                                     ParseReason reason)
    54130        {
    55             public LolFxScanner(IVsTextBuffer buffer)
    56             {
    57                 m_buffer = buffer;
    58             }
    59 
    60             bool IScanner.ScanTokenAndProvideInfoAboutIt(TokenInfo tokeninfo, ref int state)
    61             {
    62                 while (m_offset < m_source.Length)
    63                 {
    64                     if (m_source[m_offset] == ' ' || m_source[m_offset] == '\t')
    65                        {
    66                         ++m_offset;
    67                         continue;
    68                        }
    69 
    70                     tokeninfo.StartIndex = m_offset;
    71                     tokeninfo.EndIndex = m_offset;
    72                     tokeninfo.Type = TokenType.Unknown;
    73                     switch (state % 4)
    74                        {
    75                         case 0: tokeninfo.Color = TokenColor.Number; break;
    76                         case 1: tokeninfo.Color = TokenColor.Text; break;
    77                         case 2: tokeninfo.Color = TokenColor.Keyword; break;
    78                         case 3: tokeninfo.Color = TokenColor.Comment; break;
    79                     }
    80                     ++m_offset;
    81                     ++state;
    82                     return true;
    83                 }
    84 
    85                 return false;
    86             }
    87 
    88             enum State
    89             {
    90                 Default,
    91                 CComment,
    92                 CppComment,
    93                 String,
    94             }
    95 
    96             void IScanner.SetSource(string source, int offset)
    97             {
    98                 m_source = source;
    99                 m_offset = offset;
    100             }
    101 
    102             private IVsTextBuffer m_buffer;
    103             string m_source;
    104             int m_offset;
     131            return null;
    105132        }
    106133
    107         internal class LolFxAuthoringScope : AuthoringScope
     134        public override string Goto(VSConstants.VSStd97CmdID cmd, IVsTextView textView, int line, int col, out TextSpan span)
    108135        {
    109             public override string GetDataTipText(int line, int col, out TextSpan span)
    110             {
    111                 span = new TextSpan();
    112                 return null;
    113             }
     136            span = new TextSpan();
     137            return null;
     138        }
    114139
    115             public override Declarations GetDeclarations(IVsTextView view,
    116                                                          int line,
    117                                                          int col,
    118                                                          TokenInfo info,
    119                                                          ParseReason reason)
    120             {
    121                 return null;
    122             }
    123 
    124             public override string Goto(VSConstants.VSStd97CmdID cmd, IVsTextView textView, int line, int col, out TextSpan span)
    125             {
    126                 span = new TextSpan();
    127                 return null;
    128             }
    129 
    130             public override Methods GetMethods(int line, int col, string name)
    131             {
    132                 return null;
    133             }
     140        public override Methods GetMethods(int line, int col, string name)
     141        {
     142            return null;
    134143        }
    135144    }
    136145}
    137146
     147} /* namespace lol */

  • trunk/tools/vslol/MenuGenerateCompilers.cs

    r2118 r2123  
     1//
     2// Lol Engine - VsLol add-in for Visual Studio
     3//
     4// Copyright: (c) 2010-2012 Sam Hocevar <sam@hocevar.net>
     5//   This program is free software; you can redistribute it and/or
     6//   modify it under the terms of the Do What The Fuck You Want To
     7//   Public License, Version 2, as published by Sam Hocevar. See
     8//   http://www.wtfpl.net/ for more details.
     9//
     10
    111using System;
    212using System.Collections;
    … …  
    1626using VSConstants = Microsoft.VisualStudio.VSConstants;
    1727
    18 namespace Lol.VisualStudio.Plugin
     28namespace lol
    1929{
    20     internal class MenuGenerateCompilers : OleMenuCommand
    21     {
    22         public MenuGenerateCompilers(ServiceProvider sp, CommandID id) :
    23             base(new EventHandler(ClickCallback), id, VsLol.ResourceManager.GetString("GenerateCompilersText"))
    24         {
    25             this.sp = sp;
    26             this.projects = new List<Project>();
    27             this.BeforeQueryStatus += new EventHandler(OnBeforeQueryStatus);
    28         }
    29 
    30         private void OnBeforeQueryStatus(object sender, EventArgs e)
    31         {
    32             projects.Clear();
    33 
    34             var cmd = sender as OleMenuCommand;
    35             if (cmd == null)
    36                 return;
    37 
    38             IVsMonitorSelection monitorSelection = sp.GetService(typeof(IVsMonitorSelection)) as IVsMonitorSelection;
    39             if (monitorSelection == null)
    40                 return;
    41 
    42             IntPtr hier = IntPtr.Zero;
    43             UInt32 itemid;
    44             IVsMultiItemSelect multiitem = null;
    45             IntPtr container = IntPtr.Zero;
    46 
     30
     31internal class MenuGenerateCompilers : OleMenuCommand
     32{
     33    public MenuGenerateCompilers(ServiceProvider sp, CommandID id) :
     34        base(new EventHandler(ClickCallback), id, VsLol.ResourceManager.GetString("GenerateCompilersText"))
     35    {
     36        this.sp = sp;
     37        this.projects = new List<Project>();
     38        this.BeforeQueryStatus += new EventHandler(OnBeforeQueryStatus);
     39    }
     40
     41    private void OnBeforeQueryStatus(object sender, EventArgs e)
     42    {
     43        projects.Clear();
     44
     45        var cmd = sender as OleMenuCommand;
     46        if (cmd == null)
     47            return;
     48
     49        IVsMonitorSelection monitorSelection = sp.GetService(typeof(IVsMonitorSelection)) as IVsMonitorSelection;
     50        if (monitorSelection == null)
     51            return;
     52
     53        IntPtr hier = IntPtr.Zero;
     54        UInt32 itemid;
     55        IVsMultiItemSelect multiitem = null;
     56        IntPtr container = IntPtr.Zero;
     57
     58        try
     59        {
     60            monitorSelection.GetCurrentSelection(out hier, out itemid, out multiitem, out container);
     61
     62            /* Bail out if nothing is selected */
     63            if (itemid != VSConstants.VSITEMID_SELECTION && itemid != VSConstants.VSITEMID_NIL)
     64            {
     65                if (hier == IntPtr.Zero)
     66                {
     67                    /* FIXME: parse the whole solution */
     68                }
     69                else
     70                {
     71                    object project = null;
     72
     73                    IVsHierarchy hierarchy = (IVsHierarchy)Marshal.GetObjectForIUnknown(hier);
     74                    hierarchy.GetProperty(VSConstants.VSITEMID_ROOT, (int)__VSHPROPID.VSHPROPID_ExtObject, out project);
     75                    projects.Add(project as Project);
     76                }
     77            }
     78        }
     79        finally
     80        {
     81            if (hier != IntPtr.Zero)
     82                Marshal.Release(hier);
     83
     84            if (container != IntPtr.Zero)
     85                Marshal.Release(container);
     86        }
     87
     88        // If there are .l or .y files in this project, display the context menu
     89        Visible = false;
     90        foreach (Project project in projects)
     91            foreach (ProjectItem item in ParseProjectItems(project))
     92            {
     93                if (item.Name.EndsWith("-scanner.l")
     94                     || item.Name.EndsWith("-parser.y"))
     95                    Visible = true;
     96            }
     97    }
     98
     99    private static void ClickCallback(object sender, EventArgs args)
     100    {
     101        MenuGenerateCompilers cmd = sender as MenuGenerateCompilers;
     102        if (cmd == null)
     103            return;
     104
     105        Logger.Clear();
     106        Logger.Info("------ Build started: Generating Compilers ------\n");
     107
     108        int scanner_count = 0, parser_count = 0, error_count = 0;
     109
     110        foreach (Project project in cmd.projects)
     111        {
     112            Logger.Info("Project " + project.Name + "\n");
     113
     114            string project_path = Path.GetDirectoryName(project.FullName);
     115
     116            /* FIXME: find this using the solution globals! */
     117            string external_path = project_path;
     118            for (int i = 0; i < 10; ++i)
     119            {
     120                external_path += "\\..";
     121                if (Directory.Exists(external_path + "\\external"))
     122                    break;
     123            }
     124
     125            /* FIXME: do not hardcode shit! */
     126            string flex_path = external_path + "\\external\\flex-2.5.35";
     127            string bison_path = external_path + "\\external\\bison-2.4.2";
     128
     129            /* Workaround for an MSYS bug. If these directories don't
     130             * exist, fork() will fail. Yeah, wtf. */
    47131            try
    48132            {
    49                 monitorSelection.GetCurrentSelection(out hier, out itemid, out multiitem, out container);
    50 
    51                 /* Bail out if nothing is selected */
    52                 if (itemid != VSConstants.VSITEMID_SELECTION && itemid != VSConstants.VSITEMID_NIL)
    53                 {
    54                     if (hier == IntPtr.Zero)
    55                     {
    56                         /* FIXME: parse the whole solution */
    57                     }
    58                     else
    59                     {
    60                         object project = null;
    61 
    62                         IVsHierarchy hierarchy = (IVsHierarchy)Marshal.GetObjectForIUnknown(hier);
    63                         hierarchy.GetProperty(VSConstants.VSITEMID_ROOT, (int)__VSHPROPID.VSHPROPID_ExtObject, out project);
    64                         projects.Add(project as Project);
    65                     }
    66                 }
    67             }
    68             finally
    69             {
    70                 if (hier != IntPtr.Zero)
    71                     Marshal.Release(hier);
    72 
    73                 if (container != IntPtr.Zero)
    74                     Marshal.Release(container);
    75             }
    76 
    77             // If there are .l or .y files in this project, display the context menu
    78             Visible = false;
    79             foreach (Project project in projects)
    80                 foreach (ProjectItem item in ParseProjectItems(project))
    81                 {
    82                     if (item.Name.EndsWith("-scanner.l")
    83                          || item.Name.EndsWith("-parser.y"))
    84                         Visible = true;
    85                 }
    86         }
    87 
    88         private static void ClickCallback(object sender, EventArgs args)
    89         {
    90             MenuGenerateCompilers cmd = sender as MenuGenerateCompilers;
    91             if (cmd == null)
    92                 return;
    93 
    94             Logger.Clear();
    95             Logger.Info("------ Build started: Generating Compilers ------\n");
    96 
    97             int scanner_count = 0, parser_count = 0, error_count = 0;
    98 
    99             foreach (Project project in cmd.projects)
    100             {
    101                 Logger.Info("Project " + project.Name + "\n");
    102 
    103                 string project_path = Path.GetDirectoryName(project.FullName);
    104 
    105                 /* FIXME: find this using the solution globals! */
    106                 string external_path = project_path;
    107                 for (int i = 0; i < 10; ++i)
    108                 {
    109                     external_path += "\\..";
    110                     if (Directory.Exists(external_path + "\\external"))
    111                         break;
    112                 }
    113 
    114                 /* FIXME: do not hardcode shit! */
    115                 string flex_path = external_path + "\\external\\flex-2.5.35";
    116                 string bison_path = external_path + "\\external\\bison-2.4.2";
    117 
    118                 /* Workaround for an MSYS bug. If these directories don't
    119                  * exist, fork() will fail. Yeah, wtf. */
    120                 try
    121                 {
    122                     Directory.CreateDirectory(flex_path + "\\etc");
    123                     Directory.CreateDirectory(bison_path + "\\etc");
    124                 }
    125                 catch (Exception e) { }
    126 
    127                 // Run flex on all the .l files
    128                 foreach (ProjectItem item in ParseProjectItems(project))
    129                 {
    130                     string filename = item.get_FileNames(0);
    131 
    132                     if (filename.StartsWith(project_path + "\\"))
    133                     {
    134                         filename = filename.Substring(project_path.Length + 1);
    135                         filename = filename.Replace("\\", "/");
    136                     }
    137 
    138                     if (item.Name.EndsWith("-scanner.l"))
    139                     {
    140                         Logger.Info("flex.exe " + filename + "\n");
    141 
    142                         string basename = Path.GetFileName(filename.Substring(0, filename.LastIndexOf("-scanner.l")));
    143                         if (!cmd.Run(project_path,
    144                                      flex_path + "\\bin\\flex.exe",
    145                                      "-v -o "
    146                                       + "generated/" + basename + "-scanner.cpp "
    147                                       + filename,
    148                                      ""))
    149                             ++error_count;
    150 
    151                         ++scanner_count;
    152                     }
    153 
    154                     if (item.Name.EndsWith("-parser.y"))
    155                     {
    156                         Logger.Info("bison.exe " + filename + "\n");
    157 
    158                         string basename = Path.GetFileName(filename.Substring(0, filename.LastIndexOf("-parser.y")));
    159                         if (!cmd.Run(project_path,
    160                                      bison_path + "\\bin\\bison.exe",
    161                                      "-v -o "
    162                                       + "generated/" + basename + "-parser.cpp "
    163                                       + "--defines=generated/" + basename + "-parser.h "
    164                                       + "-d "
    165                                       + "-b "
    166                                       + "generated/" + basename + " "
    167                                       + filename,
    168                                      "BISON_PKGDATADIR=" + bison_path + "\\share\\bison"))
    169                             ++error_count;
    170 
    171                         ++parser_count;
    172                     }
    173                 }
    174             }
    175 
    176             Logger.Info(string.Format("========== Done: {0} scanner(s), {1} parser(s), {2} error(s) ==========\n",
    177                                   scanner_count, parser_count, error_count));
    178         }
    179 
    180         bool Run(string directory, string executable, string arguments, string env)
    181         {
    182             System.Diagnostics.Process p = new System.Diagnostics.Process();
    183             p.StartInfo.FileName = executable;
    184             p.StartInfo.Arguments = arguments;
    185             foreach (string s in env.Split(new char[]{'\n'}, StringSplitOptions.RemoveEmptyEntries))
    186             {
    187                 int i = s.IndexOf("=");
    188                 if (i > 0 && i < s.Length - 1)
    189                     p.StartInfo.EnvironmentVariables[s.Substring(0, i - 1)] = s.Substring(i + 1);
    190             }
    191             p.StartInfo.WorkingDirectory = directory;
    192             p.StartInfo.CreateNoWindow = true;
    193             p.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
    194             p.StartInfo.RedirectStandardError = true;
    195             p.StartInfo.RedirectStandardOutput = true;
    196             p.StartInfo.RedirectStandardInput = true;
    197             p.StartInfo.UseShellExecute = false;
    198 
    199             try
    200             {
    201                 p.Start();
    202                 string output = p.StandardError.ReadToEnd()
    203                               + p.StandardOutput.ReadToEnd();
    204                 p.WaitForExit();
    205                 Logger.Info(output);
    206                 if (p.ExitCode != 0)
    207                 {
    208                     Logger.Info("Error: " + executable + " exited with code " + p.ExitCode + "\n");
    209                     if (arguments != "")
    210                         Logger.Info("Error: args: " + arguments + "\n");
    211                     if (env != "")
    212                         Logger.Info("Error: env: " + env + "\n");
    213                     return false;
    214                 }
    215             }
    216             catch (Exception e)
    217             {
    218                 Logger.Info("Error: failed to launch " + executable + "\n");
     133                Directory.CreateDirectory(flex_path + "\\etc");
     134                Directory.CreateDirectory(bison_path + "\\etc");
     135            }
     136            catch (Exception e) { }
     137
     138            // Run flex on all the .l files
     139            foreach (ProjectItem item in ParseProjectItems(project))
     140            {
     141                string filename = item.get_FileNames(0);
     142
     143                if (filename.StartsWith(project_path + "\\"))
     144                {
     145                    filename = filename.Substring(project_path.Length + 1);
     146                    filename = filename.Replace("\\", "/");
     147                }
     148
     149                if (item.Name.EndsWith("-scanner.l"))
     150                {
     151                    Logger.Info("flex.exe " + filename + "\n");
     152
     153                    string basename = Path.GetFileName(filename.Substring(0, filename.LastIndexOf("-scanner.l")));
     154                    if (!cmd.Run(project_path,
     155                                 flex_path + "\\bin\\flex.exe",
     156                                 "-v -o "
     157                                  + "generated/" + basename + "-scanner.cpp "
     158                                  + filename,
     159                                 ""))
     160                        ++error_count;
     161
     162                    ++scanner_count;
     163                }
     164
     165                if (item.Name.EndsWith("-parser.y"))
     166                {
     167                    Logger.Info("bison.exe " + filename + "\n");
     168
     169                    string basename = Path.GetFileName(filename.Substring(0, filename.LastIndexOf("-parser.y")));
     170                    if (!cmd.Run(project_path,
     171                                 bison_path + "\\bin\\bison.exe",
     172                                 "-v -o "
     173                                  + "generated/" + basename + "-parser.cpp "
     174                                  + "--defines=generated/" + basename + "-parser.h "
     175                                  + "-d "
     176                                  + "-b "
     177                                  + "generated/" + basename + " "
     178                                  + filename,
     179                                 "BISON_PKGDATADIR=" + bison_path + "\\share\\bison"))
     180                        ++error_count;
     181
     182                    ++parser_count;
     183                }
     184            }
     185        }
     186
     187        Logger.Info(string.Format("========== Done: {0} scanner(s), {1} parser(s), {2} error(s) ==========\n",
     188                              scanner_count, parser_count, error_count));
     189    }
     190
     191    bool Run(string directory, string executable, string arguments, string env)
     192    {
     193        System.Diagnostics.Process p = new System.Diagnostics.Process();
     194        p.StartInfo.FileName = executable;
     195        p.StartInfo.Arguments = arguments;
     196        foreach (string s in env.Split(new char[]{'\n'}, StringSplitOptions.RemoveEmptyEntries))
     197        {
     198            int i = s.IndexOf("=");
     199            if (i > 0 && i < s.Length - 1)
     200                p.StartInfo.EnvironmentVariables[s.Substring(0, i - 1)] = s.Substring(i + 1);
     201        }
     202        p.StartInfo.WorkingDirectory = directory;
     203        p.StartInfo.CreateNoWindow = true;
     204        p.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
     205        p.StartInfo.RedirectStandardError = true;
     206        p.StartInfo.RedirectStandardOutput = true;
     207        p.StartInfo.RedirectStandardInput = true;
     208        p.StartInfo.UseShellExecute = false;
     209
     210        try
     211        {
     212            p.Start();
     213            string output = p.StandardError.ReadToEnd()
     214                          + p.StandardOutput.ReadToEnd();
     215            p.WaitForExit();
     216            Logger.Info(output);
     217            if (p.ExitCode != 0)
     218            {
     219                Logger.Info("Error: " + executable + " exited with code " + p.ExitCode + "\n");
     220                if (arguments != "")
     221                    Logger.Info("Error: args: " + arguments + "\n");
     222                if (env != "")
     223                    Logger.Info("Error: env: " + env + "\n");
    219224                return false;
    220225            }
    221 
    222             return true;
    223         }
    224 
    225         private static IEnumerable<ProjectItem> ParseProjectItems(object o)
    226         {
    227             ProjectItems subitems;
    228             if (o is Project)
    229             {
    230                 subitems = (o as Project).ProjectItems;
    231             }
    232             else
    233             {
    234                 yield return (o as ProjectItem);
    235                 subitems = (o as ProjectItem).ProjectItems;
    236             }
    237 
    238             foreach (ProjectItem item in subitems)
    239                 foreach (ProjectItem i in ParseProjectItems(item))
    240                     yield return i;
    241         }
    242 
    243         private ServiceProvider sp;
    244 
    245         private List<Project> projects;
    246     }
     226        }
     227        catch (Exception e)
     228        {
     229            Logger.Info("Error: failed to launch " + executable + "\n");
     230            return false;
     231        }
     232
     233        return true;
     234    }
     235
     236    private static IEnumerable<ProjectItem> ParseProjectItems(object o)
     237    {
     238        ProjectItems subitems;
     239        if (o is Project)
     240        {
     241            subitems = (o as Project).ProjectItems;
     242        }
     243        else
     244        {
     245            yield return (o as ProjectItem);
     246            subitems = (o as ProjectItem).ProjectItems;
     247        }
     248
     249        foreach (ProjectItem item in subitems)
     250            foreach (ProjectItem i in ParseProjectItems(item))
     251                yield return i;
     252    }
     253
     254    private ServiceProvider sp;
     255
     256    private List<Project> projects;
    247257}
    248258
     259} /* namespace lol */

  • trunk/tools/vslol/Properties/AssemblyInfo.cs

    r2122 r2123  
    1 
     1//
     2// Lol Engine - VsLol add-in for Visual Studio
     3//
     4// Copyright: (c) 2010-2012 Sam Hocevar <sam@hocevar.net>
     5//   This program is free software; you can redistribute it and/or
     6//   modify it under the terms of the Do What The Fuck You Want To
     7//   Public License, Version 2, as published by Sam Hocevar. See
     8//   http://www.wtfpl.net/ for more details.
     9//
     10
    211using System.Reflection;
    312using System.Runtime.CompilerServices;

  • trunk/tools/vslol/VsLol.Designer.cs

    r1932 r2123  
    99//------------------------------------------------------------------------------
    1010
    11 namespace Lol.VisualStudio.Plugin {
     11namespace lol {
    1212    using System;
    1313   
    … …  
    4040            get {
    4141                if (object.ReferenceEquals(resourceMan, null)) {
    42                     global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("Lol.VisualStudio.Plugin.VsLol", typeof(VsLol).Assembly);
     42                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("lol.VsLol", typeof(VsLol).Assembly);
    4343                    resourceMan = temp;
    4444                }

  • trunk/tools/vslol/VsLol.cs

    r2119 r2123  
     1//
     2// Lol Engine - VsLol add-in for Visual Studio
     3//
     4// Copyright: (c) 2010-2012 Sam Hocevar <sam@hocevar.net>
     5//   This program is free software; you can redistribute it and/or
     6//   modify it under the terms of the Do What The Fuck You Want To
     7//   Public License, Version 2, as published by Sam Hocevar. See
     8//   http://www.wtfpl.net/ for more details.
     9//
     10
    111using System;
    212using System.ComponentModel.Design;
    … …  
    1020using Microsoft.VisualStudio.Shell.Interop;
    1121
    12 namespace Lol.VisualStudio.Plugin
     22namespace lol
    1323{
    14     [PackageRegistration(UseManagedResourcesOnly = true)]
    1524
    16     /* LolFx syntax highlighting */
    17     [ProvideServiceAttribute(typeof(LolFxLanguageService),
    18                              ServiceName = "LolFx Service")]
    19     [ProvideLanguageServiceAttribute(typeof(LolFxLanguageService),
    20                                      "LolFx", 106 /* resource ID */,
    21                                      CodeSense = true,
    22                                      RequestStockColors = true,
    23                                      EnableCommenting = true,
    24                                      EnableAsyncCompletion = true)]
    25     [ProvideLanguageExtensionAttribute(typeof(LolFxLanguageService),
    26                                        ".lolfx")]
     25[PackageRegistration(UseManagedResourcesOnly = true)]
    2726
    28     [ProvideMenuResource(1000, 1)]
    29     [Guid("f96f7ac5-16ac-4061-8b92-0a02bb455ae9")]
    30     [InstalledProductRegistration("#110", "#112", "1.0", IconResourceID = 400)]
    31     [ComVisible(true)]
     27/* LolFx syntax highlighting */
     28[ProvideServiceAttribute(typeof(LolFxLanguageService),
     29                         ServiceName = "LolFx Service")]
     30[ProvideLanguageServiceAttribute(typeof(LolFxLanguageService),
     31                                 "LolFx", 106 /* resource ID */,
     32                                 CodeSense = true,
     33                                 RequestStockColors = true,
     34                                 EnableCommenting = true,
     35                                 EnableAsyncCompletion = true)]
     36[ProvideLanguageExtensionAttribute(typeof(LolFxLanguageService),
     37                                   ".lolfx")]
    3238
    33     /* Autoload package */
    34     [ProvideAutoLoad("f1536ef8-92ec-443c-9ed7-fdadf150da82")]
     39[ProvideMenuResource(1000, 1)]
     40[Guid("f96f7ac5-16ac-4061-8b92-0a02bb455ae9")]
     41[InstalledProductRegistration("#110", "#112", "1.0", IconResourceID = 400)]
     42[ComVisible(true)]
    3543
    36     public sealed class PluginPackage : Package
     44/* Autoload package */
     45[ProvideAutoLoad("f1536ef8-92ec-443c-9ed7-fdadf150da82")]
     46
     47public sealed class PluginPackage : Package
     48{
     49    public PluginPackage()
    3750    {
    38         public PluginPackage()
     51        Trace.WriteLine(String.Format("Entering constructor for: {0}", this.ToString()));
     52    }
     53
     54    [SecurityPermission(SecurityAction.Demand, Flags=SecurityPermissionFlag.UnmanagedCode)]
     55    protected override void Initialize()
     56    {
     57        // Trace the beginning of this method and call the base implementation.
     58        Trace.WriteLine(String.Format("Entering Initialize() of: {0}", this.ToString()));
     59        base.Initialize();
     60
     61        Logger.Initialize(GetService(typeof(SVsOutputWindow)) as IVsOutputWindow);
     62
     63        /* Register the "Generate Compilers" context menu */
     64        OleMenuCommandService mcs = GetService(typeof(IMenuCommandService)) as OleMenuCommandService;
     65        if (null != mcs)
    3966        {
    40             Trace.WriteLine(String.Format(CultureInfo.CurrentUICulture, "Entering constructor for: {0}", this.ToString()));
     67            CommandID id = new CommandID(GuidsList.guidVsLolCmdSet,
     68                                         VsLolIDList.cmdidGenerateCompilers);
     69            OleMenuCommand command = new MenuGenerateCompilers(new ServiceProvider((IOleServiceProvider)this.GetService(typeof(IOleServiceProvider))), id);
     70            mcs.AddCommand(command);
    4171        }
    4272
    43         [SecurityPermission(SecurityAction.Demand, Flags=SecurityPermissionFlag.UnmanagedCode)]
    44         protected override void Initialize()
     73        /* Register the LolFx language service */
     74        IServiceContainer serviceContainer = this as IServiceContainer;
     75        LolFxLanguageService lolfxserv = new LolFxLanguageService();
     76        lolfxserv.SetSite(this);
     77        serviceContainer.AddService(typeof(LolFxLanguageService),
     78                                    lolfxserv, true);
     79    }
     80}
     81
     82internal static class Logger
     83{
     84    public static void Initialize(IVsOutputWindow window)
     85    {
     86        m_window = window;
     87
     88        OpenBuildPane();
     89
     90        if (m_pane == null)
     91            Trace.WriteLine("Failed to get a reference to the Output window Build pane");
     92    }
     93
     94    private static void OpenBuildPane()
     95    {
     96        /* Ensure the "Build" output pane exists */
     97        if (m_window != null)
    4598        {
    46             // Trace the beginning of this method and call the base implementation.
    47             Trace.WriteLine(String.Format(CultureInfo.CurrentUICulture, "Entering Initialize() of: {0}", this.ToString()));
    48             base.Initialize();
     99            Guid guidBuild = Microsoft.VisualStudio.VSConstants.OutputWindowPaneGuid.BuildOutputPane_guid;
     100            m_window.CreatePane(guidBuild, "Build", 1, 0);
    49101
    50             Logger.Initialize(GetService(typeof(SVsOutputWindow)) as IVsOutputWindow);
    51 
    52             /* Register the "Generate Compilers" context menu */
    53             OleMenuCommandService mcs = GetService(typeof(IMenuCommandService)) as OleMenuCommandService;
    54             if (null != mcs)
    55             {
    56                 CommandID id = new CommandID(GuidsList.guidVsLolCmdSet,
    57                                              VsLolIDList.cmdidGenerateCompilers);
    58                 OleMenuCommand command = new MenuGenerateCompilers(new ServiceProvider((IOleServiceProvider)this.GetService(typeof(IOleServiceProvider))), id);
    59                 mcs.AddCommand(command);
    60             }
    61 
    62             /* Register the LolFx language service */
    63             IServiceContainer serviceContainer = this as IServiceContainer;
    64             LolFxLanguageService lolfxserv = new LolFxLanguageService();
    65             lolfxserv.SetSite(this);
    66             serviceContainer.AddService(typeof(LolFxLanguageService),
    67                                         lolfxserv, true);
     102            if (Microsoft.VisualStudio.ErrorHandler.Failed(m_window.GetPane(ref guidBuild, out m_pane)))
     103                m_pane = null;
    68104        }
    69105
     106        if (m_pane != null)
     107            m_pane.Activate();
    70108    }
    71109
    72     internal static class Logger
     110    public static void Clear()
    73111    {
    74         public static void Initialize(IVsOutputWindow window)
     112        OpenBuildPane();
     113
     114        if (m_pane == null)
    75115        {
    76             m_window = window;
    77 
    78             OpenBuildPane();
    79 
    80             if (m_pane == null)
    81                 Trace.WriteLine("Failed to get a reference to the Output window Build pane");
     116            m_backlog = "";
     117            return;
    82118        }
    83119
    84         private static void OpenBuildPane()
     120        m_pane.Clear();
     121    }
     122
     123    public static void Info(string s)
     124    {
     125        OpenBuildPane();
     126
     127        if (m_pane == null)
    85128        {
    86             /* Ensure the "Build" output pane exists */
    87             if (m_window != null)
    88             {
    89                 Guid guidBuild = Microsoft.VisualStudio.VSConstants.OutputWindowPaneGuid.BuildOutputPane_guid;
    90                 m_window.CreatePane(guidBuild, "Build", 1, 0);
    91 
    92                 if (Microsoft.VisualStudio.ErrorHandler.Failed(m_window.GetPane(ref guidBuild, out m_pane)))
    93                     m_pane = null;
    94             }
    95 
    96             if (m_pane != null)
    97                 m_pane.Activate();
     129            m_backlog += s;
     130            return;
    98131        }
    99132
    100         public static void Clear()
    101         {
    102             OpenBuildPane();
    103 
    104             if (m_pane == null)
    105             {
    106                 m_backlog = "";
    107                 return;
    108             }
    109 
    110             m_pane.Clear();
    111         }
    112 
    113         public static void Info(string s)
    114         {
    115             OpenBuildPane();
    116 
    117             if (m_pane == null)
    118             {
    119                 m_backlog += s;
    120                 return;
    121             }
    122 
    123             m_pane.OutputString(m_backlog);
    124             m_backlog = "";
    125             m_pane.OutputString(s);
    126         }
    127 
    128         private static IVsOutputWindow m_window = null;
    129         private static IVsOutputWindowPane m_pane = null;
    130         private static string m_backlog = "";
     133        m_pane.OutputString(m_backlog);
     134        m_backlog = "";
     135        m_pane.OutputString(s);
    131136    }
    132137
    133     internal static class GuidsList
    134     {
    135         // Now define the list of guids as public static members.
    136         [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1823:AvoidUnusedPrivateFields")]
    137         public static readonly Guid guidVsLolPkg = new Guid("{f96f7ac5-16ac-4061-8b92-0a02bb455ae9}");
     138    private static IVsOutputWindow m_window = null;
     139    private static IVsOutputWindowPane m_pane = null;
     140    private static string m_backlog = "";
     141}
    138142
    139         public static readonly Guid guidVsLolCmdSet = new Guid("{ce508d12-530e-45d0-8b52-1e9ee3f8eaaf}");
     143internal static class GuidsList
     144{
     145    // Now define the list of guids as public static members.
     146    [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1823:AvoidUnusedPrivateFields")]
     147    public static readonly Guid guidVsLolPkg = new Guid("{f96f7ac5-16ac-4061-8b92-0a02bb455ae9}");
    140148
    141         [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1823:AvoidUnusedPrivateFields")]
    142         public static readonly Guid guidGearBmp = new Guid("{560dba06-c26b-4731-8229-b816818e5992}");
    143     }
     149    public static readonly Guid guidVsLolCmdSet = new Guid("{ce508d12-530e-45d0-8b52-1e9ee3f8eaaf}");
    144150
    145     internal static class VsLolIDList
    146     {
    147         public const int cmdidGenerateCompilers = 0x2001;
    148         public const int cmdidUnused1 = 0x2002;
    149         public const int cmdidUnused2 = 0x2003;
    150     }
     151    [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1823:AvoidUnusedPrivateFields")]
     152    public static readonly Guid guidGearBmp = new Guid("{560dba06-c26b-4731-8229-b816818e5992}");
    151153}
     154
     155internal static class VsLolIDList
     156{
     157    public const int cmdidGenerateCompilers = 0x2001;
     158    public const int cmdidUnused1 = 0x2002;
     159    public const int cmdidUnused2 = 0x2003;
     160}
     161
     162} /* namespace lol */

  • trunk/tools/vslol/VsLol.csproj

    r2119 r2123  
    99    <OutputType>Library</OutputType>
    1010    <AppDesignerFolder>Properties</AppDesignerFolder>
    11     <RootNamespace>Lol.VisualStudio.Plugin</RootNamespace>
     11    <RootNamespace>lol</RootNamespace>
    1212    <AssemblyName>Lol.VisualStudio.VsLol</AssemblyName>
    1313    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
Note: See TracChangeset for help on using the changeset viewer.