source: branches/PersistentDataStructures/HeuristicLab.ExtLibs/HeuristicLab.AvalonEdit/5.0.1/AvalonEdit-5.0.1/Highlighting/Xshd/V1Loader.cs @ 14648

// Copyright (c) 2014 AlphaSierraPapa for the SharpDevelop Team
// 
// Permission is hereby granted, free of charge, to any person obtaining a copy of this
// software and associated documentation files (the "Software"), to deal in the Software
// without restriction, including without limitation the rights to use, copy, modify, merge,
// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
// to whom the Software is furnished to do so, subject to the following conditions:
// 
// The above copyright notice and this permission notice shall be included in all copies or
// substantial portions of the Software.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.

using System;
using System.Globalization;
using System.Text;
using System.Text.RegularExpressions;
using System.Windows;
using System.Windows.Media;
using System.Xml;
using System.Xml.Schema;

using ICSharpCode.AvalonEdit.Utils;

namespace ICSharpCode.AvalonEdit.Highlighting.Xshd
{
  /// <summary>
  /// Loads .xshd files, version 1.0.
  /// </summary>
  sealed class V1Loader
  {
    static XmlSchemaSet schemaSet;
    
    static XmlSchemaSet SchemaSet {
      get {
        if (schemaSet == null) {
          schemaSet = HighlightingLoader.LoadSchemaSet(new XmlTextReader(
            Resources.OpenStream("ModeV1.xsd")));
        }
        return schemaSet;
      }
    }
    
    public static XshdSyntaxDefinition LoadDefinition(XmlReader reader, bool skipValidation)
    {
      reader = HighlightingLoader.GetValidatingReader(reader, false, skipValidation ? null : SchemaSet);
      XmlDocument document = new XmlDocument();
      document.Load(reader);
      V1Loader loader = new V1Loader();
      return loader.ParseDefinition(document.DocumentElement);
    }
    
    XshdSyntaxDefinition ParseDefinition(XmlElement syntaxDefinition)
    {
      XshdSyntaxDefinition def = new XshdSyntaxDefinition();
      def.Name = syntaxDefinition.GetAttributeOrNull("name");
      if (syntaxDefinition.HasAttribute("extensions")) {
        def.Extensions.AddRange(syntaxDefinition.GetAttribute("extensions").Split(';', '|'));
      }
      
      XshdRuleSet mainRuleSetElement = null;
      foreach (XmlElement element in syntaxDefinition.GetElementsByTagName("RuleSet")) {
        XshdRuleSet ruleSet = ImportRuleSet(element);
        def.Elements.Add(ruleSet);
        if (ruleSet.Name == null)
          mainRuleSetElement = ruleSet;
        
        if (syntaxDefinition["Digits"] != null) {
          // create digit highlighting rule
          
          const string optionalExponent = @"([eE][+-]?[0-9]+)?";
          const string floatingPoint = @"\.[0-9]+";
          ruleSet.Elements.Add(
            new XshdRule {
              ColorReference = GetColorReference(syntaxDefinition["Digits"]),
              RegexType = XshdRegexType.IgnorePatternWhitespace,
              Regex = @"\b0[xX][0-9a-fA-F]+"
                + @"|"
                + @"(\b\d+(" + floatingPoint + ")?"
                + @"|" + floatingPoint + ")"
                + optionalExponent
            });
        }
      }
      
      if (syntaxDefinition.HasAttribute("extends") && mainRuleSetElement != null) {
        // convert 'extends="HTML"' to '<Import ruleSet="HTML/" />' in main rule set.
        mainRuleSetElement.Elements.Add(
          new XshdImport { RuleSetReference = new XshdReference<XshdRuleSet>(
            syntaxDefinition.GetAttribute("extends"), string.Empty
          ) });
      }
      return def;
    }
    
    static XshdColor GetColorFromElement(XmlElement element)
    {
      if (!element.HasAttribute("bold") && !element.HasAttribute("italic") && !element.HasAttribute("color") && !element.HasAttribute("bgcolor"))
        return null;
      XshdColor color = new XshdColor();
      if (element.HasAttribute("bold"))
        color.FontWeight = XmlConvert.ToBoolean(element.GetAttribute("bold")) ? FontWeights.Bold : FontWeights.Normal;
      if (element.HasAttribute("italic"))
        color.FontStyle = XmlConvert.ToBoolean(element.GetAttribute("italic")) ? FontStyles.Italic : FontStyles.Normal;
      if (element.HasAttribute("color"))
        color.Foreground = ParseColor(element.GetAttribute("color"));
      if (element.HasAttribute("bgcolor"))
        color.Background = ParseColor(element.GetAttribute("bgcolor"));
      return color;
    }
    
    static XshdReference<XshdColor> GetColorReference(XmlElement element)
    {
      XshdColor color = GetColorFromElement(element);
      if (color != null)
        return new XshdReference<XshdColor>(color);
      else
        return new XshdReference<XshdColor>();
    }
    
    static HighlightingBrush ParseColor(string c)
    {
      if (c.StartsWith("#", StringComparison.Ordinal)) {
        int a = 255;
        int offset = 0;
        if (c.Length > 7) {
          offset = 2;
          a = Int32.Parse(c.Substring(1,2), NumberStyles.HexNumber, CultureInfo.InvariantCulture);
        }
        
        int r = Int32.Parse(c.Substring(1 + offset,2), NumberStyles.HexNumber, CultureInfo.InvariantCulture);
        int g = Int32.Parse(c.Substring(3 + offset,2), NumberStyles.HexNumber, CultureInfo.InvariantCulture);
        int b = Int32.Parse(c.Substring(5 + offset,2), NumberStyles.HexNumber, CultureInfo.InvariantCulture);
        return new SimpleHighlightingBrush(Color.FromArgb((byte)a, (byte)r, (byte)g, (byte)b));
      } else if (c.StartsWith("SystemColors.", StringComparison.Ordinal)) {
        return V2Loader.GetSystemColorBrush(null, c);
      } else {
        return new SimpleHighlightingBrush((Color)V2Loader.ColorConverter.ConvertFromInvariantString(c));
      }
    }
    
    char ruleSetEscapeCharacter;
    
    XshdRuleSet ImportRuleSet(XmlElement element)
    {
      XshdRuleSet ruleSet = new XshdRuleSet();
      ruleSet.Name = element.GetAttributeOrNull("name");
      
      if (element.HasAttribute("escapecharacter")) {
        ruleSetEscapeCharacter = element.GetAttribute("escapecharacter")[0];
      } else {
        ruleSetEscapeCharacter = '\0';
      }
      
      if (element.HasAttribute("reference")) {
        ruleSet.Elements.Add(
          new XshdImport { RuleSetReference = new XshdReference<XshdRuleSet>(
            element.GetAttribute("reference"), string.Empty
          ) });
      }
      ruleSet.IgnoreCase = element.GetBoolAttribute("ignorecase");
      
      foreach (XmlElement el in element.GetElementsByTagName("KeyWords")) {
        XshdKeywords keywords = new XshdKeywords();
        keywords.ColorReference = GetColorReference(el);
        // we have to handle old syntax highlighting definitions that contain
        // empty keywords or empty keyword groups
        foreach (XmlElement node in el.GetElementsByTagName("Key")) {
          string word = node.GetAttribute("word");
          if (!string.IsNullOrEmpty(word))
            keywords.Words.Add(word);
        }
        if (keywords.Words.Count > 0) {
          ruleSet.Elements.Add(keywords);
        }
      }
      
      foreach (XmlElement el in element.GetElementsByTagName("Span")) {
        ruleSet.Elements.Add(ImportSpan(el));
      }
      
      foreach (XmlElement el in element.GetElementsByTagName("MarkPrevious")) {
        ruleSet.Elements.Add(ImportMarkPrevNext(el, false));
      }
      foreach (XmlElement el in element.GetElementsByTagName("MarkFollowing")) {
        ruleSet.Elements.Add(ImportMarkPrevNext(el, true));
      }
      
      return ruleSet;
    }
    
    static XshdRule ImportMarkPrevNext(XmlElement el, bool markFollowing)
    {
      bool markMarker = el.GetBoolAttribute("markmarker") ?? false;
      string what = Regex.Escape(el.InnerText);
      const string identifier = @"[\d\w_]+";
      const string whitespace = @"\s*";
      
      string regex;
      if (markFollowing) {
        if (markMarker) {
          regex = what + whitespace + identifier;
        } else {
          regex = "(?<=(" + what + whitespace + "))" + identifier;
        }
      } else {
        if (markMarker) {
          regex = identifier + whitespace + what;
        } else {
          regex = identifier + "(?=(" + whitespace + what + "))";
        }
      }
      return new XshdRule {
        ColorReference = GetColorReference(el),
        Regex = regex,
        RegexType = XshdRegexType.IgnorePatternWhitespace
      };
    }
    
    XshdSpan ImportSpan(XmlElement element)
    {
      XshdSpan span = new XshdSpan();
      if (element.HasAttribute("rule")) {
        span.RuleSetReference = new XshdReference<XshdRuleSet>(null, element.GetAttribute("rule"));
      }
      char escapeCharacter = ruleSetEscapeCharacter;
      if (element.HasAttribute("escapecharacter")) {
        escapeCharacter = element.GetAttribute("escapecharacter")[0];
      }
      span.Multiline = !(element.GetBoolAttribute("stopateol") ?? false);
      
      span.SpanColorReference = GetColorReference(element);
      
      span.BeginRegexType = XshdRegexType.IgnorePatternWhitespace;
      span.BeginRegex = ImportRegex(element["Begin"].InnerText,
                                    element["Begin"].GetBoolAttribute("singleword") ?? false,
                                    element["Begin"].GetBoolAttribute("startofline"));
      span.BeginColorReference = GetColorReference(element["Begin"]);
      
      string endElementText = string.Empty;
      if (element["End"] != null) {
        span.EndRegexType = XshdRegexType.IgnorePatternWhitespace;
        endElementText = element["End"].InnerText;
        span.EndRegex = ImportRegex(endElementText,
                                    element["End"].GetBoolAttribute("singleword") ?? false,
                                    null);
        span.EndColorReference = GetColorReference(element["End"]);
      }
      
      if (escapeCharacter != '\0') {
        XshdRuleSet ruleSet = new XshdRuleSet();
        if (endElementText.Length == 1 && endElementText[0] == escapeCharacter) {
          // ""-style escape
          ruleSet.Elements.Add(new XshdSpan {
                                BeginRegex = Regex.Escape(endElementText + endElementText),
                                EndRegex = ""
                               });
        } else {
          // \"-style escape
          ruleSet.Elements.Add(new XshdSpan {
                                BeginRegex = Regex.Escape(escapeCharacter.ToString()),
                                EndRegex = "."
                               });
        }
        if (span.RuleSetReference.ReferencedElement != null) {
          ruleSet.Elements.Add(new XshdImport { RuleSetReference = span.RuleSetReference });
        }
        span.RuleSetReference = new XshdReference<XshdRuleSet>(ruleSet);
      }
      return span;
    }
    
    static string ImportRegex(string expr, bool singleWord, bool? startOfLine)
    {
      StringBuilder b = new StringBuilder();
      if (startOfLine != null) {
        if (startOfLine.Value) {
          b.Append(@"(?<=(^\s*))");
        } else {
          b.Append(@"(?<!(^\s*))");
        }
      } else {
        if (singleWord)
          b.Append(@"\b");
      }
      for (int i = 0; i < expr.Length; i++) {
        char c = expr[i];
        if (c == '@') {
          ++i;
          if (i == expr.Length)
            throw new HighlightingDefinitionInvalidException("Unexpected end of @ sequence, use @@ to look for a single @.");
          switch (expr[i]) {
            case 'C': // match whitespace or punctuation
              b.Append(@"[^\w\d_]");
              break;
            case '!': // negative lookahead
              {
                StringBuilder whatmatch = new StringBuilder();
                ++i;
                while (i < expr.Length && expr[i] != '@') {
                  whatmatch.Append(expr[i++]);
                }
                b.Append("(?!(");
                b.Append(Regex.Escape(whatmatch.ToString()));
                b.Append("))");
              }
              break;
            case '-': // negative lookbehind
              {
                StringBuilder whatmatch = new StringBuilder();
                ++i;
                while (i < expr.Length && expr[i] != '@') {
                  whatmatch.Append(expr[i++]);
                }
                b.Append("(?<!(");
                b.Append(Regex.Escape(whatmatch.ToString()));
                b.Append("))");
              }
              break;
            case '@':
              b.Append("@");
              break;
            default:
              throw new HighlightingDefinitionInvalidException("Unknown character in @ sequence.");
          }
        } else {
          b.Append(Regex.Escape(c.ToString()));
        }
      }
      if (singleWord)
        b.Append(@"\b");
      return b.ToString();
    }
  }
}