main/src/addins/Mono.Texteditor/Mono.TextEditor.Highlighting/SyntaxModeService.cs

   1 // SyntaxModeService.cs
   2 //
   3 // Author:
   4 //   Mike Krüger <mkrueger@novell.com>
   5 //
   6 // Copyright (c) 2007 Novell, Inc (http://www.novell.com)
   7 //
   8 // Permission is hereby granted, free of charge, to any person obtaining a copy
   9 // of this software and associated documentation files (the "Software"), to deal
  10 // in the Software without restriction, including without limitation the rights
  11 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  12 // copies of the Software, and to permit persons to whom the Software is
  13 // furnished to do so, subject to the following conditions:
  14 //
  15 // The above copyright notice and this permission notice shall be included in
  16 // all copies or substantial portions of the Software.
  17 //
  18 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  19 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  21 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  22 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  23 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  24 // THE SOFTWARE.
  25 //
  26 //
  27
  28 using System;
  29 using System.Collections.Generic;
  30 using System.Collections.ObjectModel;
  31 using System.IO;
  32 using System.Reflection;
  33 using System.Threading;
  34 using System.Xml;
  35
  36 namespace Mono.TextEditor.Highlighting
  37 {
  38         public static class SyntaxModeService
  39         {
  40                 static Dictionary<string, SyntaxMode> syntaxModes = new Dictionary<string, SyntaxMode> ();
  41                 static Dictionary<string, Style>      styles      = new Dictionary<string, Style> ();
  42                 static Dictionary<string, IXmlProvider> syntaxModeLookup = new Dictionary<string, IXmlProvider> ();
  43                 static Dictionary<string, IXmlProvider> styleLookup      = new Dictionary<string, IXmlProvider> ();
  44
  45                 public static string[] Styles {
  46                         get {
  47                                 List<string> result = new List<string> ();
  48                                 foreach (string style in styles.Keys) {
  49                                         if (!result.Contains (style))
  50                                                 result.Add (style);
  51                                 }
  52                                 foreach (string style in styleLookup.Keys) {
  53                                         if (!result.Contains (style))
  54                                                 result.Add (style);
  55                                 }
  56                                 return result.ToArray ();
  57                         }
  58                 }
  59
  60                 public static Style GetColorStyle (Gtk.Widget widget, string name)
  61                 {
  62                         if (styles.ContainsKey (name))
  63                                 return styles [name];
  64                         if (styleLookup.ContainsKey (name)) {
  65                                 LoadStyle (name);
  66                                 return GetColorStyle (widget, name);
  67                         }
  68                         return new DefaultStyle (widget);
  69                 }
  70
  71                 public static IXmlProvider GetProvider (SyntaxMode mode)
  72                 {
  73                         foreach (string mimeType in mode.MimeType.Split (';')) {
  74                                 if (syntaxModeLookup.ContainsKey (mimeType))
  75                                         return syntaxModeLookup[mimeType];
  76                         }
  77                         return null;
  78                 }
  79
  80                 public static IXmlProvider GetProvider (Style style)
  81                 {
  82                         if (styleLookup.ContainsKey (style.Name))
  83                                 return styleLookup[style.Name];
  84                         return null;
  85                 }
  86
  87                 static void LoadStyle (string name)
  88                 {
  89                         if (!styleLookup.ContainsKey (name))
  90                                 throw new System.ArgumentException ("Style " + name + " not found", "name");
  91                         XmlTextReader reader = styleLookup [name].Open ();
  92                         try {
  93                                 styles [name] = Style.LoadFrom (reader);
  94                         } finally {
  95                                 reader.Close ();
  96                         }
  97                 }
  98
  99                 static void LoadSyntaxMode (string mimeType)
 100                 {
 101                         if (!syntaxModeLookup.ContainsKey (mimeType))
 102                                 throw new System.ArgumentException ("Syntax mode for mime:" + mimeType + " not found", "mimeType");
 103                         XmlTextReader reader = syntaxModeLookup [mimeType].Open ();
 104                         try {
 105                                 SyntaxMode mode = SyntaxMode.Read (reader);
 106                                 foreach (string mime in mode.MimeType.Split (';')) {
 107                                         syntaxModes [mime] = mode;
 108                                 }
 109                         } finally {
 110                                 reader.Close ();
 111                         }
 112                 }
 113
 114                 public static SyntaxMode GetSyntaxMode (string mimeType)
 115                 {
 116                         if (syntaxModes.ContainsKey (mimeType))
 117                                 return syntaxModes [mimeType];
 118                         if (syntaxModeLookup.ContainsKey (mimeType)) {
 119                                 LoadSyntaxMode (mimeType);
 120                                 syntaxModeLookup.Remove (mimeType);
 121                                 return GetSyntaxMode (mimeType);
 122                         }
 123                         return null;
 124                 }
 125
 126                 public static bool ValidateAllSyntaxModes ()
 127                 {
 128                         foreach (string mime in new List<string> (syntaxModeLookup.Keys)) {
 129                                 GetSyntaxMode (mime);
 130                         }
 131                         syntaxModeLookup.Clear ();
 132                         foreach (string style in new List<string> (styleLookup.Keys)) {
 133                                 GetColorStyle (null, style);
 134                         }
 135                         styleLookup.Clear ();
 136                         bool result = true;
 137                         foreach (KeyValuePair<string, Style> style in styles) {
 138                                 HashSet<SyntaxMode> checkedModes = new HashSet<SyntaxMode> ();
 139                                 foreach (KeyValuePair<string, SyntaxMode> mode in syntaxModes) {
 140                                         if (checkedModes.Contains (mode.Value))
 141                                                 continue;
 142                                         if (!mode.Value.Validate (style.Value)) {
 143                                                 System.Console.WriteLine(mode.Key + " failed to validate against:" + style.Key);
 144                                                 result = false;
 145                                         }
 146                                         checkedModes.Add (mode.Value);
 147                                 }
 148                         }
 149                         return result;
 150                 }
 151
 152                 public static void Remove (Style style)
 153                 {
 154                         if (styles.ContainsKey (style.Name))
 155                                 styles.Remove (style.Name);
 156                         if (styleLookup.ContainsKey (style.Name))
 157                                 styleLookup.Remove (style.Name);
 158                 }
 159                 public static void Remove (SyntaxMode mode)
 160                 {
 161                         foreach (string mimeType in mode.MimeType.Split (';')) {
 162                                 if (syntaxModes.ContainsKey (mimeType))
 163                                         syntaxModes.Remove (mimeType);
 164                                 if (syntaxModeLookup.ContainsKey (mimeType))
 165                                         syntaxModeLookup.Remove (mimeType);
 166                         }
 167                 }
 168
 169                 public static void ScanSpans (Document doc, Rule rule, Stack<Span> spanStack, int start, int end)
 170                 {
 171                         Dictionary<char, Span[]> spanTree = rule != null ? rule.spanStarts : null;
 172                         int endOffset = 0;
 173                         end = System.Math.Min (end, doc.Length);
 174                         Span curSpan = spanStack.Count > 0 ? spanStack.Peek () : null;
 175                         Rule curRule = rule;
 176                         for (int offset = start; offset < end; offset++) {
 177                                 char ch = doc.GetCharAt (offset);
 178                                 if (curSpan != null && !String.IsNullOrEmpty (curSpan.End)) {
 179                                         if (!String.IsNullOrEmpty (curSpan.Escape) && offset + 1 < end && endOffset == 0 && doc.GetCharAt (offset + 1) == curSpan.End[0]) {
 180                                                 bool match = true;
 181                                                 for (int j = 0; j < curSpan.Escape.Length && offset + j < doc.Length; j++) {
 182                                                         if (doc.GetCharAt (offset + j) != curSpan.Escape[j]) {
 183                                                                 match = false;
 184                                                                 break;
 185                                                         }
 186                                                 }
 187                                                 if (match) {
 188                                                         offset += curSpan.Escape.Length - 1;
 189                                                         continue;
 190                                                 }
 191
 192
 193                                         }
 194                                         if (curSpan.End[endOffset] == ch) {
 195                                                 endOffset++;
 196                                                 if (endOffset >= curSpan.End.Length) {
 197                                                         spanStack.Pop ();
 198                                                         curSpan = spanStack.Count > 0 ? spanStack.Peek () : null;
 199                                                         curRule = curSpan != null ? doc.SyntaxMode.GetRule (curSpan.Rule) : rule;
 200                                                         spanTree = curRule != null ? curRule.spanStarts : null;
 201                                                         endOffset = 0;
 202                                                         continue;
 203                                                 }
 204                                         } else if (endOffset != 0) {
 205                                                 endOffset = 0;
 206                                                 if (curSpan.End[endOffset] == ch) {
 207                                                         offset--;
 208                                                         continue;
 209                                                 }
 210                                         }
 211                                         if (String.IsNullOrEmpty (curSpan.Rule))
 212                                                 continue;
 213                                 }
 214
 215                                 if (spanTree != null && spanTree.ContainsKey (ch)) {
 216                                         bool found = false;
 217                                         foreach (Span span in spanTree[ch]) {
 218                                                 bool mismatch = false;
 219                                                 for (int j = 1; j < span.Begin.Length; j++) {
 220                                                         if (offset + j >= doc.Length || span.Begin [j] != doc.GetCharAt (offset + j)) {
 221                                                                 mismatch = true;
 222                                                                 break;
 223                                                         }
 224                                                 }
 225                                                 if (!mismatch && span.BeginFlags.Contains ("firstNonWs")) {
 226                                                         LineSegment line = doc.GetLineByOffset (offset);
 227                                                         for (int k = line.Offset; k < offset; k++) {
 228                                                                 if (!Char.IsWhiteSpace (doc.GetCharAt (k))) {
 229                                                                         mismatch = true;
 230                                                                         break;
 231                                                                 }
 232                                                         }
 233                                                 }
 234
 235                                                 if (!mismatch) {
 236                                                         spanStack.Push (span);
 237                                                         curSpan = span;
 238                                                         curRule = doc.SyntaxMode.GetRule (curSpan.Rule);
 239                                                         spanTree = curRule != null ? curRule.spanStarts : null;
 240                                                         found = true;
 241                                                         offset += span.Begin.Length - 1;
 242                                                         endOffset = 0;
 243                                                         break;
 244                                                 }
 245                                         }
 246                                         if (found)
 247                                                 continue;
 248                                 } else {
 249                                         spanTree = curRule != null ? curRule.spanStarts : null;
 250                                 }
 251 //                       skip:
 252 //                                      ;
 253                         }
 254                 }
 255                 static bool IsEqual (Span[] spans1, Span[] spans2)
 256                 {
 257                         if (spans1 == null || spans1.Length == 0)
 258                                 return spans2 == null || spans2.Length == 0;
 259                         if (spans2 == null || spans1.Length != spans2.Length)
 260                                 return false;
 261                         for (int i = 0; i < spans1.Length; i++) {
 262                                 if (spans1[i] != spans2[i]) {
 263                                         return false;
 264                                 }
 265                         }
 266                         return true;
 267                 }
 268
 269                 static Queue<UpdateWorker> updateQueue = new Queue<UpdateWorker> ();
 270
 271                 class UpdateWorker
 272                 {
 273                         Document doc;
 274                         SyntaxMode mode;
 275                         int startOffset;
 276                         int endOffset;
 277
 278                         public UpdateWorker (Document doc, SyntaxMode mode, int startOffset, int endOffset)
 279                         {
 280                                 this.doc         = doc;
 281                                 this.mode        = mode;
 282                                 this.startOffset = startOffset;
 283                                 this.endOffset   = endOffset;
 284                         }
 285
 286                         protected void ScanSpansThreaded (Document doc, Rule rule, Stack<Span> spanStack, int start, int end)
 287                         {
 288                                 Dictionary<char, Span[]> spanTree = rule != null ? rule.spanStarts : null;
 289                                 int endOffset = 0;
 290                                 end = System.Math.Min (end, doc.Length);
 291                                 Span curSpan = spanStack.Count > 0 ? spanStack.Peek () : null;
 292                                 Rule curRule = rule;
 293                                 for (int offset = start; offset < end; offset++) {
 294                                         char ch;
 295                                         try {
 296                                                 // document may have been changed and the thread is still running
 297                                                 // (however a new highlighting thread will be created after each document change)
 298                                                 ch = doc.GetCharAt (offset);
 299                                         } catch (Exception) {
 300                                                 return;
 301                                         }
 302                                         if (curSpan != null && !String.IsNullOrEmpty (curSpan.End)) {
 303                                                 if (!String.IsNullOrEmpty (curSpan.Escape) && offset + 1 < end && endOffset == 0 && doc.GetCharAt (offset + 1) == curSpan.End[0]) {
 304                                                         bool match = true;
 305                                                         for (int j = 0; j < curSpan.Escape.Length && offset + j < doc.Length; j++) {
 306                                                                 if (doc.GetCharAt (offset + j) != curSpan.Escape[j]) {
 307                                                                         match = false;
 308                                                                         break;
 309                                                                 }
 310                                                         }
 311
 312                                                         if (match) {
 313                                                                 offset += curSpan.Escape.Length - 1;
 314                                                                 continue;
 315                                                         }
 316
 317
 318                                                 }
 319                                                 if (curSpan.End[endOffset] == ch) {
 320                                                         endOffset++;
 321                                                         if (endOffset >= curSpan.End.Length) {
 322                                                                 spanStack.Pop ();
 323                                                                 curSpan = spanStack.Count > 0 ? spanStack.Peek () : null;
 324                                                                 curRule = curSpan != null ? doc.SyntaxMode.GetRule (curSpan.Rule) : rule;
 325                                                                 spanTree = curRule != null ? curRule.spanStarts : null;
 326                                                                 endOffset = 0;
 327                                                                 continue;
 328                                                         }
 329                                                 } else if (endOffset != 0) {
 330                                                         endOffset = 0;
 331                                                         if (curSpan.End[endOffset] == ch) {
 332                                                                 offset--;
 333                                                                 continue;
 334                                                         }
 335                                                 }
 336                                                 if (String.IsNullOrEmpty (curSpan.Rule))
 337                                                         continue;
 338
 339                                         }
 340                                         if (spanTree != null && spanTree.ContainsKey (ch)) {
 341                                                 bool found = false;
 342                                                 foreach (Span span in spanTree[ch]) {
 343                                                         bool mismatch = false;
 344                                                         for (int j = 1; j < span.Begin.Length; j++) {
 345                                                                 if (offset + j >= doc.Length || span.Begin [j] != doc.GetCharAt (offset + j)) {
 346                                                                         mismatch = true;
 347                                                                         break;
 348                                                                 }
 349                                                         }
 350                                                         if (!mismatch && span.BeginFlags.Contains ("firstNonWs")) {
 351                                                                 LineSegment line = doc.GetLineByOffset (offset);
 352                                                                 for (int k = line.Offset; k < offset; k++) {
 353                                                                         if (!Char.IsWhiteSpace (doc.GetCharAt (k))) {
 354                                                                                 mismatch = true;
 355                                                                                 break;
 356                                                                         }
 357                                                                 }
 358                                                         }
 359
 360                                                         if (!mismatch) {
 361                                                                 spanStack.Push (span);
 362                                                                 curSpan = span;
 363                                                                 curRule = doc.SyntaxMode.GetRule (curSpan.Rule);
 364                                                                 spanTree = curRule != null ? curRule.spanStarts : null;
 365                                                                 offset += span.Begin.Length - 1;
 366                                                                 endOffset = 0;
 367
 368                                                                 found = true;
 369                                                                 break;
 370                                                         }
 371                                                 }
 372                                                 if (found)
 373                                                         continue;
 374                                         } else {
 375                                                 spanTree = curRule != null ? curRule.spanStarts : null;
 376                                         }
 377 //                               skip:
 378 //                                              ;
 379                                 }
 380                         }
 381
 382                         public void InnerRun ()
 383                         {
 384                                 bool doUpdate = false;
 385                                 RedBlackTree<LineSegmentTree.TreeNode>.RedBlackTreeIterator iter = doc.GetLineByOffset (startOffset).Iter;
 386                                 Stack<Span> spanStack = iter.Current.StartSpan != null ? new Stack<Span> (iter.Current.StartSpan) : new Stack<Span> ();
 387
 388                                 do {
 389                                         LineSegment line = iter.Current;
 390                                         if (line == null || line.Offset < 0)
 391                                                 break;
 392
 393                                         List<Span> spanList = new List<Span> (spanStack.ToArray ());
 394                                         spanList.Reverse ();
 395                                         for (int i = 0; i < spanList.Count; i++) {
 396                                                 if (spanList[i].StopAtEol) {
 397                                                         spanList.RemoveAt (i);
 398                                                         i--;
 399                                                 }
 400                                         }
 401                                         Span[] newSpans = spanList.ToArray ();
 402                                         if (line.Offset > endOffset) {
 403                                                 bool equal = IsEqual (line.StartSpan, newSpans);
 404                                                 doUpdate |= !equal;
 405                                                 if (equal)
 406                                                         break;
 407                                         }
 408                                         line.StartSpan = newSpans.Length > 0 ? newSpans : null;
 409                                         Rule rule = mode;
 410                                         if (spanStack.Count > 0 && !String.IsNullOrEmpty (spanStack.Peek ().Rule))
 411                                                 rule = mode.GetRule (spanStack.Peek ().Rule) ?? mode;
 412
 413                                         ScanSpansThreaded (doc, rule, spanStack, line.Offset, line.EndOffset);
 414                                         while (spanStack.Count > 0 && spanStack.Peek ().StopAtEol)
 415                                                 spanStack.Pop ();
 416                                 } while (iter.MoveNext ());
 417                                 if (doUpdate) {
 418                                         GLib.Timeout.Add (0, delegate {
 419                                                 doc.RequestUpdate (new UpdateAll ());
 420                                                 doc.CommitDocumentUpdate ();
 421                                                 return false;
 422                                         });
 423                                 }
 424                         }
 425                 }
 426
 427 //              static bool updateIsRunning = false;
 428 //              static void Update (object o)
 429 //              {
 430 //                      updateIsRunning = false;
 431 //              }
 432
 433         //      static readonly object syncObject  = new object();
 434                 static Thread         updateThread = null;
 435                 static AutoResetEvent queueSignal  = new AutoResetEvent (false);
 436
 437                 static void StartUpdateThread ()
 438                 {
 439                         updateThread = new Thread (ProcessQueue);
 440                         updateThread.IsBackground = true;
 441                         updateThread.Start();
 442                 }
 443
 444                 static void ProcessQueue ()
 445                 {
 446                         while (true) {
 447                                 while (updateQueue.Count > 0) {
 448                                         UpdateWorker worker = null;
 449                                         lock (updateQueue) {
 450                                                 worker = updateQueue.Dequeue ();
 451                                         }
 452                                         worker.InnerRun ();
 453                                 }
 454                                 queueSignal.WaitOne ();
 455                         }
 456                 }
 457
 458                 public static void StartUpdate (Document doc, SyntaxMode mode, int startOffset, int endOffset)
 459                 {
 460                         lock (updateQueue) {
 461                                 updateQueue.Enqueue (new UpdateWorker (doc, mode, startOffset, endOffset));
 462                         }
 463                         queueSignal.Set ();
 464                 }
 465
 466                 static string Scan (XmlTextReader reader, string attribute)
 467                 {
 468                         while (reader.Read () && !reader.IsStartElement ())
 469                                 ;
 470                         return reader.GetAttribute (attribute);
 471                 }
 472
 473                 public static bool IsValidStyle (string fileName)
 474                 {
 475                         if (!fileName.EndsWith ("Style.xml"))
 476                                 return false;
 477                         try {
 478                                 using (XmlTextReader reader =  new XmlTextReader (fileName)) {
 479                                         string styleName = Scan (reader, Style.NameAttribute);
 480                                         return !String.IsNullOrEmpty (styleName);
 481                                 }
 482                         } catch (Exception) {
 483                                 return false;
 484                         }
 485                 }
 486
 487                 public static bool IsValidSyntaxMode (string fileName)
 488                 {
 489                         if (!fileName.EndsWith ("SyntaxMode.xml"))
 490                                 return false;
 491                         try {
 492                                 using (XmlTextReader reader =  new XmlTextReader (fileName)) {
 493                                         string mimeTypes = Scan (reader, SyntaxMode.MimeTypesAttribute);
 494                                         return !String.IsNullOrEmpty (mimeTypes);
 495                                 }
 496                         } catch (Exception) {
 497                                 return false;
 498                         }
 499                 }
 500
 501                 public static void LoadStylesAndModes (string path)
 502                 {
 503                         foreach (string file in Directory.GetFiles (path)) {
 504                                 if (!file.EndsWith (".xml"))
 505                                         continue;
 506                                 if (file.EndsWith ("SyntaxMode.xml")) {
 507                                         XmlTextReader reader =  new XmlTextReader (file);
 508                                         string mimeTypes = Scan (reader, SyntaxMode.MimeTypesAttribute);
 509                                         foreach (string mimeType in mimeTypes.Split (';')) {
 510                                                 syntaxModeLookup [mimeType] = new UrlXmlProvider (file);
 511                                         }
 512                                         reader.Close ();
 513                                 } else if (file.EndsWith ("Style.xml")) {
 514                                         XmlTextReader reader =  new XmlTextReader (file);
 515                                         string styleName = Scan (reader, Style.NameAttribute);
 516                                         styleLookup [styleName] = new UrlXmlProvider (file);
 517                                         reader.Close ();
 518                                 }
 519                         }
 520                 }
 521                 public static void LoadStylesAndModes (Assembly assembly)
 522                 {
 523                         foreach (string resource in assembly.GetManifestResourceNames ()) {
 524                                 if (!resource.EndsWith (".xml"))
 525                                         continue;
 526                                 if (resource.EndsWith ("SyntaxMode.xml")) {
 527                                         XmlTextReader reader =  new XmlTextReader (assembly.GetManifestResourceStream (resource));
 528                                         string mimeTypes = Scan (reader, SyntaxMode.MimeTypesAttribute);
 529                                         ResourceXmlProvider provider = new ResourceXmlProvider (assembly, resource);
 530                                         foreach (string mimeType in mimeTypes.Split (';')) {
 531                                                 syntaxModeLookup [mimeType] = provider;
 532                                         }
 533                                         reader.Close ();
 534                                 } else if (resource.EndsWith ("Style.xml")) {
 535                                         XmlTextReader reader = new XmlTextReader (assembly.GetManifestResourceStream (resource));
 536                                         string styleName = Scan (reader, Style.NameAttribute);
 537                                         styleLookup [styleName] = new ResourceXmlProvider (assembly, resource);
 538                                         reader.Close ();
 539                                 }
 540                         }
 541                 }
 542
 543                 public static void AddSyntaxMode (IXmlProvider provider)
 544                 {
 545                         using (XmlTextReader reader = provider.Open ()) {
 546                                 string mimeTypes = Scan (reader, SyntaxMode.MimeTypesAttribute);
 547                                 foreach (string mimeType in mimeTypes.Split (';')) {
 548                                         syntaxModeLookup [mimeType] = provider;
 549                                 }
 550                         }
 551                 }
 552
 553                 public static void RemoveSyntaxMode (IXmlProvider provider)
 554                 {
 555                         using (XmlTextReader reader = provider.Open ()) {
 556                                 string mimeTypes = Scan (reader, SyntaxMode.MimeTypesAttribute);
 557                                 foreach (string mimeType in mimeTypes.Split (';')) {
 558                                         syntaxModeLookup.Remove (mimeType);
 559                                 }
 560                         }
 561                 }
 562
 563                 public static void AddStyle (IXmlProvider provider)
 564                 {
 565                         using (XmlTextReader reader = provider.Open ()) {
 566                                 string styleName = Scan (reader, Style.NameAttribute);
 567                                 styleLookup [styleName] = provider;
 568                         }
 569                 }
 570                 public static void RemoveStyle (IXmlProvider provider)
 571                 {
 572                         using (XmlTextReader reader = provider.Open ()) {
 573                                 string styleName = Scan (reader, Style.NameAttribute);
 574                                 styleLookup.Remove (styleName);
 575                         }
 576                 }
 577
 578                 static SyntaxModeService ()
 579                 {
 580                         StartUpdateThread ();
 581                         LoadStylesAndModes (typeof (SyntaxModeService).Assembly);
 582                         SyntaxModeService.GetSyntaxMode ("text/x-csharp").AddSemanticRule ("Comment", new HighlightUrlSemanticRule ("comment"));
 583                         SyntaxModeService.GetSyntaxMode ("text/x-csharp").AddSemanticRule ("XmlDocumentation", new HighlightUrlSemanticRule ("comment"));
 584                         SyntaxModeService.GetSyntaxMode ("text/x-csharp").AddSemanticRule ("String", new HighlightUrlSemanticRule ("string"));
 585                 }
 586
 587         }
 588 }