[Emacs-diffs] Changes to etc/schema/xslt.rnc

[Mark A. Hershberger]

CVSROOT:        /sources/emacs
Module name:    emacs
Changes by:     Mark A. Hershberger <hexmode>   07/11/23 06:58:00

Index: etc/schema/xslt.rnc
===================================================================
RCS file: etc/schema/xslt.rnc
diff -N etc/schema/xslt.rnc
--- /dev/null   1 Jan 1970 00:00:00 -0000
+++ etc/schema/xslt.rnc 23 Nov 2007 06:57:47 -0000      1.1
@@ -0,0 +1,356 @@
+# $Id: xslt.rnc,v 1.1 2007/11/23 06:57:47 hexmode Exp $
+
+# This was mostly generated from the syntax summary in the XSLT
+# Recommendation (using XSLT of course).
+
+# Issues: this validates extension elements as literal result
+# elements, which is overly restrictive.
+
+namespace local = ""
+default namespace xsl = "http://www.w3.org/1999/XSL/Transform";
+
+start =
+  stylesheet.element
+  | transform.element
+  | literal-result-element-as-stylesheet
+version = "1.0"
+top-level-elements.model =
+  (top-level-element.category | top-level-extension)*
+top-level-extension =
+  element * - (xsl:* | local:*) {
+    grammar {
+      start = any
+      any =
+        (attribute * { text }
+         | text
+         | element * { any })*
+    }
+  }
+template.model = (instruction.category | literal-result-element | text)*
+literal-result-element-as-stylesheet =
+  element * - xsl:* {
+    attribute xsl:version { version },
+    literal-result-element-no-version.atts,
+    template.model
+  }
+literal-result-element =
+  element * - xsl:* { literal-result-element.atts, template.model }
+literal-result-element.atts =
+  literal-result-element-no-version.atts,
+  attribute xsl:version { version }?
+literal-result-element-no-version.atts =
+  (attribute * - xsl:* { avt.datatype }
+   | attribute xsl:extension-element-prefixes { prefixes.datatype }
+   | attribute xsl:exclude-result-prefixes { prefixes.datatype }
+   | attribute xsl:use-attribute-sets { qnames.datatype })*
+top-level-element.category =
+  include.element
+  | strip-space.element
+  | preserve-space.element
+  | template.element
+  | namespace-alias.element
+  | attribute-set.element
+  | variable.element
+  | param.element
+  | key.element
+  | decimal-format.element
+  | output.element
+instruction.category =
+  apply-templates.element
+  | apply-imports.element
+  | call-template.element
+  | element.element
+  | attribute.element
+  | text.element
+  | processing-instruction.element
+  | comment.element
+  | copy.element
+  | value-of.element
+  | number.element
+  | for-each.element
+  | if.element
+  | choose.element
+  | variable.element
+  | copy-of.element
+  | message.element
+  | fallback.element
+extension.atts = attribute * - (xsl:* | local:*) { text }*
+stylesheet.element = element stylesheet { stylesheet.model }
+transform.element = element transform { stylesheet.model }
+stylesheet.model =
+  extension.atts,
+  attribute id { xsd:NCName }?,
+  attribute extension-element-prefixes { prefixes.datatype }?,
+  attribute exclude-result-prefixes { prefixes.datatype }?,
+  attribute version { version },
+  (import.element*, top-level-elements.model)
+include.element =
+  element include {
+    extension.atts,
+    attribute href { xsd:anyURI }
+  }
+import.element =
+  element import {
+    extension.atts,
+    attribute href { xsd:anyURI }
+  }
+strip-space.element =
+  element strip-space {
+    extension.atts,
+    attribute elements { wildcards.datatype }
+  }
+preserve-space.element =
+  element preserve-space {
+    extension.atts,
+    attribute elements { wildcards.datatype }
+  }
+template.element =
+  element template {
+    extension.atts,
+    attribute match { pattern.datatype }?,
+    attribute name { qname.datatype }?,
+    attribute priority { number.datatype }?,
+    attribute mode { qname.datatype }?,
+    (param.element*, template.model)
+  }
+apply-templates.element =
+  element apply-templates {
+    extension.atts,
+    attribute select { expression.datatype }?,
+    attribute mode { qname.datatype }?,
+    (sort.element | with-param.element)*
+  }
+apply-imports.element = element apply-imports { extension.atts }
+call-template.element =
+  element call-template {
+    extension.atts,
+    attribute name { qname.datatype },
+    with-param.element*
+  }
+namespace-alias.element =
+  element namespace-alias {
+    extension.atts,
+    attribute stylesheet-prefix { prefix.datatype },
+    attribute result-prefix { prefix.datatype }
+  }
+element.element =
+  element element {
+    extension.atts,
+    attribute name { qname.datatype | expr-avt.datatype },
+    attribute namespace { xsd:anyURI | brace-avt.datatype }?,
+    attribute use-attribute-sets { qnames.datatype }?,
+    template.model
+  }
+attribute.element =
+  element attribute {
+    extension.atts,
+    attribute name { qname.datatype | expr-avt.datatype },
+    attribute namespace { xsd:anyURI | brace-avt.datatype }?,
+    template.model
+  }
+attribute-set.element =
+  element attribute-set {
+    extension.atts,
+    attribute name { qname.datatype },
+    attribute use-attribute-sets { qnames.datatype }?,
+    attribute.element*
+  }
+text.element =
+  element text {
+    extension.atts,
+    attribute disable-output-escaping {
+      xsd:string "yes" | xsd:string "no"
+    }?,
+    text
+  }
+processing-instruction.element =
+  element processing-instruction {
+    extension.atts,
+    attribute name { xsd:NCName | expr-avt.datatype },
+    template.model
+  }
+comment.element = element comment { extension.atts, template.model }
+copy.element =
+  element copy {
+    extension.atts,
+    attribute use-attribute-sets { qnames.datatype }?,
+    template.model
+  }
+value-of.element =
+  element value-of {
+    extension.atts,
+    attribute select { expression.datatype },
+    attribute disable-output-escaping {
+      xsd:string "yes" | xsd:string "no"
+    }?
+  }
+number.element =
+  element number {
+    extension.atts,
+    attribute level {
+      xsd:string "single" | xsd:string "multiple" | xsd:string "any"
+    }?,
+    attribute count { pattern.datatype }?,
+    attribute from { pattern.datatype }?,
+    attribute value { expression.datatype }?,
+    attribute format { avt.datatype }?,
+    attribute lang { xsd:NMTOKEN | expr-avt.datatype }?,
+    attribute letter-value {
+      xsd:string "alphabetic"
+      | xsd:string "traditional"
+      | expr-avt.datatype
+    }?,
+    attribute grouping-separator { char.datatype | expr-avt.datatype }?,
+    attribute grouping-size { number.datatype | expr-avt.datatype }?
+  }
+for-each.element =
+  element for-each {
+    extension.atts,
+    attribute select { expression.datatype },
+    (sort.element*, template.model)
+  }
+if.element =
+  element if {
+    extension.atts,
+    attribute test { expression.datatype },
+    template.model
+  }
+choose.element =
+  element choose { extension.atts, (when.element+, otherwise.element?) }
+when.element =
+  element when {
+    extension.atts,
+    attribute test { expression.datatype },
+    template.model
+  }
+otherwise.element = element otherwise { extension.atts, template.model }
+sort.element =
+  element sort {
+    extension.atts,
+    attribute select { expression.datatype }?,
+    attribute lang { xsd:NMTOKEN | expr-avt.datatype }?,
+    attribute data-type {
+      xsd:string "text"
+      | xsd:string "number"
+      | qname-but-not-ncname.datatype
+      | expr-avt.datatype
+    }?,
+    attribute order {
+      xsd:string "ascending"
+      | xsd:string "descending"
+      | expr-avt.datatype
+    }?,
+    attribute case-order {
+      xsd:string "upper-first"
+      | xsd:string "lower-first"
+      | expr-avt.datatype
+    }?
+  }
+variable.element =
+  element variable {
+    extension.atts,
+    attribute name { qname.datatype },
+    (attribute select { expression.datatype }
+     | template.model)
+  }
+param.element =
+  element param {
+    extension.atts,
+    attribute name { qname.datatype },
+    (attribute select { expression.datatype }
+     | template.model)
+  }
+copy-of.element =
+  element copy-of {
+    extension.atts,
+    attribute select { expression.datatype }
+  }
+with-param.element =
+  element with-param {
+    extension.atts,
+    attribute name { qname.datatype },
+    (attribute select { expression.datatype }
+     | template.model)
+  }
+key.element =
+  element key {
+    extension.atts,
+    attribute name { qname.datatype },
+    attribute match { pattern.datatype },
+    attribute use { expression.datatype }
+  }
+decimal-format.element =
+  element decimal-format {
+    extension.atts,
+    attribute name { qname.datatype }?,
+    attribute decimal-separator { char.datatype }?,
+    attribute grouping-separator { char.datatype }?,
+    attribute infinity { text }?,
+    attribute minus-sign { char.datatype }?,
+    attribute NaN { text }?,
+    attribute percent { char.datatype }?,
+    attribute per-mille { char.datatype }?,
+    attribute zero-digit { char.datatype }?,
+    attribute digit { char.datatype }?,
+    attribute pattern-separator { char.datatype }?
+  }
+message.element =
+  element message {
+    extension.atts,
+    attribute terminate { xsd:string "yes" | xsd:string "no" }?,
+    template.model
+  }
+fallback.element = element fallback { extension.atts, template.model }
+output.element =
+  element output {
+    extension.atts,
+    attribute method {
+      xsd:string "xml"
+      | xsd:string "html"
+      | xsd:string "text"
+      | qname-but-not-ncname.datatype
+    }?,
+    attribute version { xsd:NMTOKEN }?,
+    attribute encoding { text }?,
+    attribute omit-xml-declaration {
+      xsd:string "yes" | xsd:string "no"
+    }?,
+    attribute standalone { xsd:string "yes" | xsd:string "no" }?,
+    attribute doctype-public { text }?,
+    attribute doctype-system { text }?,
+    attribute cdata-section-elements { qnames.datatype }?,
+    attribute indent { xsd:string "yes" | xsd:string "no" }?,
+    attribute media-type { text }?
+  }
+prefixes.datatype = list { (xsd:NCName | "#default")* }
+prefix.datatype = xsd:NCName | "#default"
+wildcards.datatype =
+  list {
+    (xsd:QName
+     | xsd:token { pattern = "\*|\i\c*:\*" })*
+  }
+qname.datatype = xsd:QName
+qnames.datatype = list { xsd:QName* }
+char.datatype = xsd:string { length = "1" }
+number.datatype = xsd:decimal
+expression.datatype = text
+pattern.datatype = text
+qname-but-not-ncname.datatype = xsd:QName { pattern = ".*:.*" }
+# An AVT containing at least one expression.
+expr-avt.datatype =
+  xsd:string {
+    pattern =
+      
"""([^\{\}]|\{\{|\}\})*\{([^"'\{\}]|"[^"]*"|'[^']*')+\}([^\{\}]|\{\{|\}\}|\{([^"'\{\}]|"[^"]*"|'[^']*')+\})*"""
+  }
+# An AVT containing at least one brace; ie where instantiated AVT
+# is not the same as the literal AVT.
+brace-avt.datatype =
+  xsd:string {
+    pattern =
+      
"""[^\{\}]*(\{\{|\}\}|\{([^"'\{\}]|"[^"]*"|'[^']*')+\})([^\{\}]|\{\{|\}\}|\{([^"'\{\}]|"[^"]*"|'[^']*')+\})*"""
+  }
+avt.datatype =
+  xsd:string {
+    pattern =
+      """([^\{\}]|\{\{|\}\}|\{([^"'\{\}]|"[^"]*"|'[^']*')+\})*"""
+  }