← Back to branch summary

~ubuntu-branches/ubuntu/trusty/monodevelop/trusty-proposed

« back to all changes in this revision

Viewing changes to src/core/Mono.Texteditor/Mono.TextEditor.Highlighting/SyntaxModeService.cs

  • Committer: Package Import Robot
  • Author(s): Jo Shields
  • Date: 2013-05-12 09:46:03 UTC
  • mto: This revision was merged to the branch mainline in revision 29.
  • Revision ID: package-import@ubuntu.com-20130512094603-mad323bzcxvmcam0
Tags: upstream-4.0.5+dfsg
Import upstream version 4.0.5+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/core/Mono.Texteditor/Mono.TextEditor.Highlighting/SyntaxModeService.cs
41
41
        {
42
42
                static Dictionary<string, ISyntaxModeProvider> syntaxModes = new Dictionary<string, ISyntaxModeProvider> ();
43
43
                static Dictionary<string, ColorScheme> styles      = new Dictionary<string, ColorScheme> ();
44
 
                static Dictionary<string, IXmlProvider> syntaxModeLookup = new Dictionary<string, IXmlProvider> ();
45
 
                static Dictionary<string, IXmlProvider> styleLookup      = new Dictionary<string, IXmlProvider> ();
 
44
                static Dictionary<string, IStreamProvider> syntaxModeLookup = new Dictionary<string, IStreamProvider> ();
 
45
                static Dictionary<string, IStreamProvider> styleLookup      = new Dictionary<string, IStreamProvider> ();
46
46
                static Dictionary<string, string> isLoadedFromFile = new Dictionary<string, string> ();
47
47
                
48
48
                public static string[] Styles {
75
75
                        syntaxModes[mimeType] = modeProvider;
76
76
                }
77
77
                
78
 
                public static ColorScheme GetColorStyle (Gtk.Style widgetStyle, string name)
 
78
                public static ColorScheme GetColorStyle (string name)
79
79
                {
80
80
                        if (styles.ContainsKey (name))
81
81
                                return styles [name];
82
82
                        if (styleLookup.ContainsKey (name)) {
83
83
                                LoadStyle (name);
84
 
                                return GetColorStyle (widgetStyle, name);
 
84
                                return GetColorStyle (name);
85
85
                        }
86
 
                        return GetColorStyle (widgetStyle, "Default");
 
86
                        return GetColorStyle ("Default");
87
87
                }
88
88
                
89
 
                public static IXmlProvider GetProvider (SyntaxMode mode)
 
89
                public static IStreamProvider GetProvider (SyntaxMode mode)
90
90
                {
91
91
                        foreach (string mimeType in mode.MimeType.Split (';')) {
92
92
                                if (syntaxModeLookup.ContainsKey (mimeType)) 
95
95
                        return null;
96
96
                }
97
97
                
98
 
                public static IXmlProvider GetProvider (ColorScheme style)
 
98
                public static IStreamProvider GetProvider (ColorScheme style)
99
99
                {
100
100
                        if (styleLookup.ContainsKey (style.Name)) 
101
101
                                return styleLookup[style.Name];
106
106
                {
107
107
                        if (!styleLookup.ContainsKey (name))
108
108
                                throw new System.ArgumentException ("Style " + name + " not found", "name");
109
 
                        XmlReader reader = styleLookup [name].Open ();
 
109
                        var provider = styleLookup [name];
 
110
                        var stream = provider.Open ();
110
111
                        try {
111
 
                                styles [name] = ColorScheme.LoadFrom (reader);
 
112
                                if (provider is UrlStreamProvider) {
 
113
                                        var usp = provider as UrlStreamProvider;
 
114
                                        if (usp.Url.EndsWith (".vssettings", StringComparison.Ordinal)) {
 
115
                                                styles [name] = ColorScheme.Import (usp.Url, stream);
 
116
                                        } else {
 
117
                                                styles [name] = ColorScheme.LoadFrom (stream);
 
118
                                        }
 
119
                                } else {
 
120
                                        styles [name] = ColorScheme.LoadFrom (stream);
 
121
                                }
112
122
                        } catch (Exception e) {
113
123
                                throw new IOException ("Error while loading style :" + name, e);
114
124
                        } finally {
115
 
                                reader.Close ();
 
125
                                stream.Close ();
116
126
                        }
117
127
                }
118
128
                
120
130
                {
121
131
                        if (!syntaxModeLookup.ContainsKey (mimeType))
122
132
                                throw new System.ArgumentException ("Syntax mode for mime:" + mimeType + " not found", "mimeType");
123
 
                        XmlReader reader = syntaxModeLookup [mimeType].Open ();
 
133
                        var reader = syntaxModeLookup [mimeType].Open ();
124
134
                        try {
125
135
                                var mode = SyntaxMode.Read (reader);
126
136
                                foreach (string mime in mode.MimeType.Split (';')) {
133
143
                        }
134
144
                }
135
145
                
136
 
                public static SyntaxMode GetSyntaxMode (TextDocument doc)
137
 
                {
138
 
                        return GetSyntaxMode (doc, doc.MimeType);
139
 
                }
140
 
                
141
146
                public static SyntaxMode GetSyntaxMode (TextDocument doc, string mimeType)
142
147
                {
143
148
                        if (string.IsNullOrEmpty (mimeType))
146
151
                        if (syntaxModes.ContainsKey (mimeType)) {
147
152
                                result = syntaxModes [mimeType].Create (doc);
148
153
                        } else if (syntaxModeLookup.ContainsKey (mimeType)) {
149
 
                                LoadSyntaxMode (mimeType);
 
154
                                try {
 
155
                                        LoadSyntaxMode (mimeType);
 
156
                                        result = GetSyntaxMode (doc, mimeType);
 
157
                                } catch (Exception e) {
 
158
                                        Console.WriteLine (e);
 
159
                                }
150
160
                                syntaxModeLookup.Remove (mimeType);
151
 
                                result = GetSyntaxMode (doc, mimeType);
152
161
                        }
153
162
                        if (result != null) {
154
163
                                foreach (var rule in semanticRules.Where (r => r.Item1 == mimeType)) {
166
175
                        }
167
176
                        syntaxModeLookup.Clear ();
168
177
                        foreach (string style in new List<string> (styleLookup.Keys)) {
169
 
                                GetColorStyle (null, style);
 
178
                                GetColorStyle (style);
170
179
                        }
171
180
                        styleLookup.Clear ();
172
181
                        bool result = true;
247
256
                        bool EndsWithContinuation (Span span, DocumentLine line)
248
257
                        {
249
258
                                return !span.StopAtEol || span.StopAtEol && !string.IsNullOrEmpty (span.Continuation) &&
250
 
                                        line != null && doc.GetTextAt (line).Trim ().EndsWith (span.Continuation);
 
259
                                        line != null && doc.GetTextAt (line).Trim ().EndsWith (span.Continuation, StringComparison.Ordinal);
251
260
                        }
252
261
                        
253
262
                        public void InnerRun ()
262
271
                                                return;
263
272
                                        var span = lineSegment.StartSpan;
264
273
                                        if (span == null)
265
 
                                                return;
266
 
                                        var spanStack = span.Clone ();
267
 
                                        SyntaxMode.SpanParser parser = mode.CreateSpanParser(null, spanStack);
 
274
                                                return;
 
275
 
 
276
                                        var spanStack = span.Clone ();
 
277
 
 
278
                                        SyntaxMode.SpanParser parser = mode.CreateSpanParser(null, spanStack);
 
279
 
268
280
                                        foreach (var line in doc.GetLinesStartingAt (startLine)) {
269
281
                                                if (line == null)
270
 
                                                        return;
 
282
                                                        return;
 
283
 
271
284
                                                if (line.Offset > endOffset) {
272
285
                                                        span = line.StartSpan;
273
286
                                                        if (span == null)
274
 
                                                                return;
275
 
                                                        bool equal = span.Equals(spanStack);
276
 
                                                        doUpdate |= !equal;
277
 
                                                        if (equal)
278
 
                                                                break;
279
 
                                                }
280
 
                                                line.StartSpan = spanStack.Clone();
281
 
                                                parser.ParseSpans(line.Offset, line.LengthIncludingDelimiter);
282
 
                                                while (spanStack.Count > 0 && !EndsWithContinuation(spanStack.Peek(), line))
283
 
                                                        parser.PopSpan();
284
 
                                        }
 
287
                                                                return;
 
288
 
 
289
                                                        bool equal = span.Equals(spanStack);
 
290
 
 
291
                                                        doUpdate |= !equal;
 
292
 
 
293
                                                        if (equal)
 
294
 
 
295
                                                                break;
 
296
 
 
297
                                                }
 
298
 
 
299
                                                line.StartSpan = spanStack.Clone();
 
300
 
 
301
                                                parser.ParseSpans(line.Offset, line.LengthIncludingDelimiter);
 
302
 
 
303
                                                while (spanStack.Count > 0 && !EndsWithContinuation(spanStack.Peek(), line))
 
304
 
 
305
                                                        parser.PopSpan();
 
306
 
 
307
                                        }
 
308
 
285
309
                                } catch (Exception e) {
286
310
                                        Console.WriteLine ("Syntax highlighting exception:" + e);
287
311
                                }
352
376
                        }
353
377
                }
354
378
                
355
 
                static string Scan (XmlReader reader, string attribute)
 
379
                static string Scan (Stream stream, string attribute)
356
380
                {
 
381
                        var reader = XmlReader.Create (stream);
357
382
                        while (reader.Read () && !reader.IsStartElement ()) 
358
383
                                ;
359
384
                        return reader.GetAttribute (attribute);
360
385
                }
361
 
                /*
362
 
                public static bool IsValidStyle (string fileName)
363
 
                {
364
 
                        if (!fileName.EndsWith ("Style.xml"))
365
 
                                return false;
366
 
                        try {
367
 
                                using (XmlTextReader reader =  new XmlTextReader (fileName)) {
368
 
                                        string styleName = Scan (reader, Style.NameAttribute);
369
 
                                        return !String.IsNullOrEmpty (styleName);
370
 
                                }
371
 
                        } catch (Exception) {
372
 
                                return false;
373
 
                        }
374
 
                }*/
375
 
                
 
386
 
376
387
                public static List<ValidationEventArgs> ValidateStyleFile (string fileName)
377
388
                {
378
389
                        List<ValidationEventArgs> result = new List<ValidationEventArgs> ();
379
 
                        XmlReaderSettings settings = new XmlReaderSettings ();
380
 
                        settings.ValidationType = ValidationType.Schema;
381
 
                        settings.ValidationEventHandler += delegate(object sender, ValidationEventArgs e) {
382
 
                                result.Add (e);
383
 
                        };
384
 
                        settings.Schemas.Add (null, new XmlTextReader (typeof(SyntaxModeService).Assembly.GetManifestResourceStream ("Styles.xsd")));
385
 
                        
386
 
                        using (XmlReader reader = XmlReader.Create (fileName, settings)) {
387
 
                                while (reader.Read ())
388
 
                                        ;
389
 
                        }
390
390
                        return result;
391
391
                }
392
 
                
393
 
                
394
 
                
 
392
 
395
393
                public static bool IsValidSyntaxMode (string fileName)
396
394
                {
397
 
                        if (!fileName.EndsWith ("SyntaxMode.xml"))
 
395
                        if (!fileName.EndsWith ("SyntaxMode.xml", StringComparison.Ordinal))
398
396
                                return false;
399
397
                        try {
400
 
                                using (XmlTextReader reader =  new XmlTextReader (fileName)) {
401
 
                                        string mimeTypes = Scan (reader, SyntaxMode.MimeTypesAttribute);
 
398
                                using (var stream = File.OpenRead (fileName)) {
 
399
                                        string mimeTypes = Scan (stream, SyntaxMode.MimeTypesAttribute);
402
400
                                        return !String.IsNullOrEmpty (mimeTypes);
403
401
                                }
404
402
                        } catch (Exception) {
409
407
                public static void LoadStylesAndModes (string path)
410
408
                {
411
409
                        foreach (string file in Directory.GetFiles (path)) {
412
 
                                if (!file.EndsWith (".xml")) 
413
 
                                        continue;
414
 
                                if (file.EndsWith ("SyntaxMode.xml")) {
415
 
                                        using (XmlTextReader reader =  new XmlTextReader (file)) {
416
 
                                                string mimeTypes = Scan (reader, SyntaxMode.MimeTypesAttribute);
417
 
                                                foreach (string mimeType in mimeTypes.Split (';')) {
418
 
                                                        syntaxModeLookup [mimeType] = new UrlXmlProvider (file);
 
410
                                if (file.EndsWith (".xml", StringComparison.Ordinal)) {
 
411
                                        using (var stream = File.OpenRead (file)) {
 
412
                                                string mimeTypes = Scan (stream, SyntaxMode.MimeTypesAttribute);
 
413
                                                if (!string.IsNullOrEmpty (mimeTypes)) {
 
414
                                                        foreach (string mimeType in mimeTypes.Split (';')) {
 
415
                                                                syntaxModeLookup [mimeType] = new UrlStreamProvider (file);
 
416
                                                        }
419
417
                                                }
420
418
                                        }
421
 
                                } else if (file.EndsWith ("Style.xml")) {
422
 
                                        using (XmlTextReader reader =  new XmlTextReader (file)) {
423
 
                                                string styleName = Scan (reader, ColorScheme.NameAttribute);
424
 
                                                styleLookup [styleName] = new UrlXmlProvider (file);
 
419
                                } else if (file.EndsWith (".json", StringComparison.Ordinal)) {
 
420
                                        using (var stream = File.OpenRead (file)) {
 
421
                                                string styleName = ScanStyle (stream);
 
422
                                                styleLookup [styleName] = new UrlStreamProvider (file);
 
423
                                                isLoadedFromFile [styleName] = file;
 
424
                                        }
 
425
                                } else if (file.EndsWith (".vssettings", StringComparison.Ordinal)) {
 
426
                                        using (var stream = File.OpenRead (file)) {
 
427
                                                string styleName = Path.GetFileNameWithoutExtension (file);
 
428
                                                styleLookup [styleName] = new UrlStreamProvider (file);
425
429
                                                isLoadedFromFile [styleName] = file;
426
430
                                        }
427
431
                                }
428
432
                        }
429
433
                }
 
434
 
430
435
                public static void LoadStylesAndModes (Assembly assembly)
431
436
                {
432
437
                        foreach (string resource in assembly.GetManifestResourceNames ()) {
433
 
                                if (!resource.EndsWith (".xml")) 
434
 
                                        continue;
435
 
                                if (resource.EndsWith ("SyntaxMode.xml")) {
436
 
                                        using (Stream stream = assembly.GetManifestResourceStream (resource)) 
437
 
                                        using (XmlTextReader reader =  new XmlTextReader (stream)) {
438
 
                                                string mimeTypes = Scan (reader, SyntaxMode.MimeTypesAttribute);
439
 
                                                ResourceXmlProvider provider = new ResourceXmlProvider (assembly, resource);
 
438
                                if (resource.EndsWith ("SyntaxMode.xml", StringComparison.Ordinal)) {
 
439
                                        using (Stream stream = assembly.GetManifestResourceStream (resource)) {
 
440
                                                string mimeTypes = Scan (stream, SyntaxMode.MimeTypesAttribute);
 
441
                                                ResourceStreamProvider provider = new ResourceStreamProvider (assembly, resource);
440
442
                                                foreach (string mimeType in mimeTypes.Split (';')) {
441
443
                                                        syntaxModeLookup [mimeType] = provider;
442
444
                                                }
443
445
                                        }
444
 
                                } else if (resource.EndsWith ("Style.xml")) {
445
 
                                        using (Stream stream = assembly.GetManifestResourceStream (resource)) 
446
 
                                        using (XmlTextReader reader = new XmlTextReader (stream)) {
447
 
                                                string styleName = Scan (reader, ColorScheme.NameAttribute);
448
 
                                                styleLookup [styleName] = new ResourceXmlProvider (assembly, resource);
 
446
                                } else if (resource.EndsWith ("Style.json", StringComparison.Ordinal)) {
 
447
                                        using (Stream stream = assembly.GetManifestResourceStream (resource)) {
 
448
                                                string styleName = ScanStyle (stream);
 
449
                                                styleLookup [styleName] = new ResourceStreamProvider (assembly, resource);
449
450
                                        }
450
451
                                }
451
452
                        }
452
453
                }
453
 
 
454
 
                public static void AddSyntaxMode (IXmlProvider provider)
455
 
                {
456
 
                        using (XmlReader reader = provider.Open ()) {
 
454
                static System.Text.RegularExpressions.Regex nameRegex = new System.Text.RegularExpressions.Regex ("\\s*\"name\"\\s*:\\s*\"(.*)\"\\s*,");
 
455
 
 
456
                static string ScanStyle (Stream stream)
 
457
                {
 
458
                        var file = new StreamReader (stream);
 
459
                        file.ReadLine ();
 
460
                        var nameLine = file.ReadLine ();
 
461
                        var match = nameRegex.Match (nameLine);
 
462
                        if (!match.Success)
 
463
                                return null;
 
464
                        return match.Groups[1].Value;
 
465
                }
 
466
 
 
467
                public static void AddSyntaxMode (IStreamProvider provider)
 
468
                {
 
469
                        using (var reader = provider.Open ()) {
457
470
                                string mimeTypes = Scan (reader, SyntaxMode.MimeTypesAttribute);
458
471
                                foreach (string mimeType in mimeTypes.Split (';')) {
459
472
                                        syntaxModeLookup [mimeType] = provider;
461
474
                        }
462
475
                }
463
476
                
464
 
                public static void RemoveSyntaxMode (IXmlProvider provider)
 
477
                public static void RemoveSyntaxMode (IStreamProvider provider)
465
478
                {
466
 
                        using (XmlReader reader = provider.Open ()) {
 
479
                        using (var reader = provider.Open ()) {
467
480
                                string mimeTypes = Scan (reader, SyntaxMode.MimeTypesAttribute);
468
481
                                foreach (string mimeType in mimeTypes.Split (';')) {
469
482
                                        syntaxModeLookup.Remove (mimeType);
476
489
                        isLoadedFromFile [style.Name] = fileName;
477
490
                        styles [style.Name] = style;
478
491
                }
479
 
                public static void AddStyle (IXmlProvider provider)
 
492
 
 
493
                public static void AddStyle (IStreamProvider provider)
480
494
                {
481
 
                        using (XmlReader reader = provider.Open ()) {
482
 
                                string styleName = Scan (reader, ColorScheme.NameAttribute);
 
495
                        using (var stream = provider.Open ()) {
 
496
                                string styleName = ScanStyle (stream);
483
497
                                styleLookup [styleName] = provider;
484
498
                        }
485
499
                }
486
 
                public static void RemoveStyle (IXmlProvider provider)
 
500
 
 
501
                public static void RemoveStyle (IStreamProvider provider)
487
502
                {
488
 
                        using (XmlReader reader = provider.Open ()) {
489
 
                                string styleName = Scan (reader, ColorScheme.NameAttribute);
 
503
                        using (var stream = provider.Open ()) {
 
504
                                string styleName = ScanStyle (stream);
490
505
                                styleLookup.Remove (styleName);
491
506
                        }
492
507
                }
497
512
                {
498
513
                        semanticRules.Add (Tuple.Create (mime, ruleName, rule));
499
514
                }
 
515
 
 
516
                public static ColorScheme DefaultColorStyle {
 
517
                        get {
 
518
                                return GetColorStyle ("Default");
 
519
                        }
 
520
                }
500
521
                
501
522
                static SyntaxModeService ()
502
523
                {
503
524
                        StartUpdateThread ();
504
525
                        LoadStylesAndModes (typeof(SyntaxModeService).Assembly);
505
 
                        SyntaxModeService.AddSemanticRule ("text/x-csharp", "Comment", new HighlightUrlSemanticRule ("comment"));
506
 
                        SyntaxModeService.AddSemanticRule ("text/x-csharp", "XmlDocumentation", new HighlightUrlSemanticRule ("comment"));
507
 
                        SyntaxModeService.AddSemanticRule ("text/x-csharp", "String", new HighlightUrlSemanticRule ("string"));
 
526
                        SyntaxModeService.AddSemanticRule ("text/x-csharp", "Comment", new HighlightUrlSemanticRule ("Comment(Line)"));
 
527
                        SyntaxModeService.AddSemanticRule ("text/x-csharp", "XmlDocumentation", new HighlightUrlSemanticRule ("Comment(Doc)"));
 
528
                        SyntaxModeService.AddSemanticRule ("text/x-csharp", "String", new HighlightUrlSemanticRule ("String"));
508
529
                        
509
530
                        InstallSyntaxMode ("text/x-jay", new SyntaxModeProvider (doc => new JaySyntaxMode (doc)));
510
531
                }