public XmlHighlightingDefinition(XshdSyntaxDefinition xshd, IHighlightingDefinitionReferenceResolver resolver)
        {
            this.Name = xshd.Name;
            // Create HighlightingRuleSet instances
            var rnev = new RegisterNamedElementsVisitor(this);

            xshd.AcceptElements(rnev);
            // Assign MainRuleSet so that references can be resolved
            foreach (XshdElement element in xshd.Elements)
            {
                XshdRuleSet xrs = element as XshdRuleSet;
                if (xrs != null && xrs.Name == null)
                {
                    if (MainRuleSet != null)
                    {
                        throw Error(element, "Duplicate main RuleSet. There must be only one nameless RuleSet!");
                    }
                    else
                    {
                        MainRuleSet = rnev.ruleSets[xrs];
                    }
                }
            }
            if (MainRuleSet == null)
            {
                throw new HighlightingDefinitionInvalidException("Could not find main RuleSet.");
            }
            // Translate elements within the rulesets (resolving references and processing imports)
            xshd.AcceptElements(new TranslateElementVisitor(this, rnev.ruleSets, resolver));
        }
Esempio n. 2
0
 /// <summary>
 /// Creates a highlighting definition from the XSHD file.
 /// </summary>
 public static IHighlightingDefinition Load(XshdSyntaxDefinition syntaxDefinition, IHighlightingDefinitionReferenceResolver resolver)
 {
     if (syntaxDefinition == null)
     {
         throw new ArgumentNullException("syntaxDefinition");
     }
     return(new XmlHighlightingDefinition(syntaxDefinition, resolver));
 }
Esempio n. 3
0
        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);
        }
Esempio n. 4
0
        static XshdSyntaxDefinition ParseDefinition(XmlReader reader)
        {
            Debug.Assert(reader.LocalName == "SyntaxDefinition");
            XshdSyntaxDefinition def = new XshdSyntaxDefinition();

            def.Name = reader.GetAttribute("name");
            string extensions = reader.GetAttribute("extensions");

            if (extensions != null)
            {
                def.Extensions.AddRange(extensions.Split(';'));
            }
            ParseElements(def.Elements, reader);
            Debug.Assert(reader.NodeType == XmlNodeType.EndElement);
            Debug.Assert(reader.LocalName == "SyntaxDefinition");
            return(def);
        }
        /// <summary>
        /// Writes the specified syntax definition.
        /// </summary>
        public void WriteDefinition(XshdSyntaxDefinition definition)
        {
            if (definition == null)
            {
                throw new ArgumentNullException("definition");
            }
            writer.WriteStartElement("SyntaxDefinition", Namespace);
            if (definition.Name != null)
            {
                writer.WriteAttributeString("name", definition.Name);
            }
            if (definition.Extensions != null)
            {
                writer.WriteAttributeString("extensions", string.Join(";", definition.Extensions.ToArray()));
            }

            definition.AcceptElements(this);

            writer.WriteEndElement();
        }