etc/schema/xslt.rnc

   1 # Copyright (C) 2001-2008 World Wide Web Consortium, (Massachusetts
   2 # Institute of Technology, European Research Consortium for
   3 # Informatics and Mathematics, Keio University).  All Rights Reserved.
   4 # This work is distributed under the W3C(R) Software License in the
   5 # hope that it will be useful, but WITHOUT ANY WARRANTY; without even
   6 # the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
   7 # PURPOSE.
   8
   9 # This was mostly generated from the syntax summary in the XSLT
  10 # Recommendation (using XSLT of course).
  11
  12 # Issues: this validates extension elements as literal result
  13 # elements, which is overly restrictive.
  14
  15 namespace local = ""
  16 default namespace xsl = "http://www.w3.org/1999/XSL/Transform"
  17
  18 start =
  19   stylesheet.element
  20   | transform.element
  21   | literal-result-element-as-stylesheet
  22 version = "1.0"
  23 top-level-elements.model =
  24   (top-level-element.category | top-level-extension)*
  25 top-level-extension =
  26   element * - (xsl:* | local:*) {
  27     grammar {
  28       start = any
  29       any =
  30         (attribute * { text }
  31          | text
  32          | element * { any })*
  33     }
  34   }
  35 template.model = (instruction.category | literal-result-element | text)*
  36 literal-result-element-as-stylesheet =
  37   element * - xsl:* {
  38     attribute xsl:version { version },
  39     literal-result-element-no-version.atts,
  40     template.model
  41   }
  42 literal-result-element =
  43   element * - xsl:* { literal-result-element.atts, template.model }
  44 literal-result-element.atts =
  45   literal-result-element-no-version.atts,
  46   attribute xsl:version { version }?
  47 literal-result-element-no-version.atts =
  48   (attribute * - xsl:* { avt.datatype }
  49    | attribute xsl:extension-element-prefixes { prefixes.datatype }
  50    | attribute xsl:exclude-result-prefixes { prefixes.datatype }
  51    | attribute xsl:use-attribute-sets { qnames.datatype })*
  52 top-level-element.category =
  53   include.element
  54   | strip-space.element
  55   | preserve-space.element
  56   | template.element
  57   | namespace-alias.element
  58   | attribute-set.element
  59   | variable.element
  60   | param.element
  61   | key.element
  62   | decimal-format.element
  63   | output.element
  64 instruction.category =
  65   apply-templates.element
  66   | apply-imports.element
  67   | call-template.element
  68   | element.element
  69   | attribute.element
  70   | text.element
  71   | processing-instruction.element
  72   | comment.element
  73   | copy.element
  74   | value-of.element
  75   | number.element
  76   | for-each.element
  77   | if.element
  78   | choose.element
  79   | variable.element
  80   | copy-of.element
  81   | message.element
  82   | fallback.element
  83 extension.atts = attribute * - (xsl:* | local:*) { text }*
  84 stylesheet.element = element stylesheet { stylesheet.model }
  85 transform.element = element transform { stylesheet.model }
  86 stylesheet.model =
  87   extension.atts,
  88   attribute id { xsd:NCName }?,
  89   attribute extension-element-prefixes { prefixes.datatype }?,
  90   attribute exclude-result-prefixes { prefixes.datatype }?,
  91   attribute version { version },
  92   (import.element*, top-level-elements.model)
  93 include.element =
  94   element include {
  95     extension.atts,
  96     attribute href { xsd:anyURI }
  97   }
  98 import.element =
  99   element import {
 100     extension.atts,
 101     attribute href { xsd:anyURI }
 102   }
 103 strip-space.element =
 104   element strip-space {
 105     extension.atts,
 106     attribute elements { wildcards.datatype }
 107   }
 108 preserve-space.element =
 109   element preserve-space {
 110     extension.atts,
 111     attribute elements { wildcards.datatype }
 112   }
 113 template.element =
 114   element template {
 115     extension.atts,
 116     attribute match { pattern.datatype }?,
 117     attribute name { qname.datatype }?,
 118     attribute priority { number.datatype }?,
 119     attribute mode { qname.datatype }?,
 120     (param.element*, template.model)
 121   }
 122 apply-templates.element =
 123   element apply-templates {
 124     extension.atts,
 125     attribute select { expression.datatype }?,
 126     attribute mode { qname.datatype }?,
 127     (sort.element | with-param.element)*
 128   }
 129 apply-imports.element = element apply-imports { extension.atts }
 130 call-template.element =
 131   element call-template {
 132     extension.atts,
 133     attribute name { qname.datatype },
 134     with-param.element*
 135   }
 136 namespace-alias.element =
 137   element namespace-alias {
 138     extension.atts,
 139     attribute stylesheet-prefix { prefix.datatype },
 140     attribute result-prefix { prefix.datatype }
 141   }
 142 element.element =
 143   element element {
 144     extension.atts,
 145     attribute name { qname.datatype | expr-avt.datatype },
 146     attribute namespace { xsd:anyURI | brace-avt.datatype }?,
 147     attribute use-attribute-sets { qnames.datatype }?,
 148     template.model
 149   }
 150 attribute.element =
 151   element attribute {
 152     extension.atts,
 153     attribute name { qname.datatype | expr-avt.datatype },
 154     attribute namespace { xsd:anyURI | brace-avt.datatype }?,
 155     template.model
 156   }
 157 attribute-set.element =
 158   element attribute-set {
 159     extension.atts,
 160     attribute name { qname.datatype },
 161     attribute use-attribute-sets { qnames.datatype }?,
 162     attribute.element*
 163   }
 164 text.element =
 165   element text {
 166     extension.atts,
 167     attribute disable-output-escaping {
 168       xsd:string "yes" | xsd:string "no"
 169     }?,
 170     text
 171   }
 172 processing-instruction.element =
 173   element processing-instruction {
 174     extension.atts,
 175     attribute name { xsd:NCName | expr-avt.datatype },
 176     template.model
 177   }
 178 comment.element = element comment { extension.atts, template.model }
 179 copy.element =
 180   element copy {
 181     extension.atts,
 182     attribute use-attribute-sets { qnames.datatype }?,
 183     template.model
 184   }
 185 value-of.element =
 186   element value-of {
 187     extension.atts,
 188     attribute select { expression.datatype },
 189     attribute disable-output-escaping {
 190       xsd:string "yes" | xsd:string "no"
 191     }?
 192   }
 193 number.element =
 194   element number {
 195     extension.atts,
 196     attribute level {
 197       xsd:string "single" | xsd:string "multiple" | xsd:string "any"
 198     }?,
 199     attribute count { pattern.datatype }?,
 200     attribute from { pattern.datatype }?,
 201     attribute value { expression.datatype }?,
 202     attribute format { avt.datatype }?,
 203     attribute lang { xsd:NMTOKEN | expr-avt.datatype }?,
 204     attribute letter-value {
 205       xsd:string "alphabetic"
 206       | xsd:string "traditional"
 207       | expr-avt.datatype
 208     }?,
 209     attribute grouping-separator { char.datatype | expr-avt.datatype }?,
 210     attribute grouping-size { number.datatype | expr-avt.datatype }?
 211   }
 212 for-each.element =
 213   element for-each {
 214     extension.atts,
 215     attribute select { expression.datatype },
 216     (sort.element*, template.model)
 217   }
 218 if.element =
 219   element if {
 220     extension.atts,
 221     attribute test { expression.datatype },
 222     template.model
 223   }
 224 choose.element =
 225   element choose { extension.atts, (when.element+, otherwise.element?) }
 226 when.element =
 227   element when {
 228     extension.atts,
 229     attribute test { expression.datatype },
 230     template.model
 231   }
 232 otherwise.element = element otherwise { extension.atts, template.model }
 233 sort.element =
 234   element sort {
 235     extension.atts,
 236     attribute select { expression.datatype }?,
 237     attribute lang { xsd:NMTOKEN | expr-avt.datatype }?,
 238     attribute data-type {
 239       xsd:string "text"
 240       | xsd:string "number"
 241       | qname-but-not-ncname.datatype
 242       | expr-avt.datatype
 243     }?,
 244     attribute order {
 245       xsd:string "ascending"
 246       | xsd:string "descending"
 247       | expr-avt.datatype
 248     }?,
 249     attribute case-order {
 250       xsd:string "upper-first"
 251       | xsd:string "lower-first"
 252       | expr-avt.datatype
 253     }?
 254   }
 255 variable.element =
 256   element variable {
 257     extension.atts,
 258     attribute name { qname.datatype },
 259     (attribute select { expression.datatype }
 260      | template.model)
 261   }
 262 param.element =
 263   element param {
 264     extension.atts,
 265     attribute name { qname.datatype },
 266     (attribute select { expression.datatype }
 267      | template.model)
 268   }
 269 copy-of.element =
 270   element copy-of {
 271     extension.atts,
 272     attribute select { expression.datatype }
 273   }
 274 with-param.element =
 275   element with-param {
 276     extension.atts,
 277     attribute name { qname.datatype },
 278     (attribute select { expression.datatype }
 279      | template.model)
 280   }
 281 key.element =
 282   element key {
 283     extension.atts,
 284     attribute name { qname.datatype },
 285     attribute match { pattern.datatype },
 286     attribute use { expression.datatype }
 287   }
 288 decimal-format.element =
 289   element decimal-format {
 290     extension.atts,
 291     attribute name { qname.datatype }?,
 292     attribute decimal-separator { char.datatype }?,
 293     attribute grouping-separator { char.datatype }?,
 294     attribute infinity { text }?,
 295     attribute minus-sign { char.datatype }?,
 296     attribute NaN { text }?,
 297     attribute percent { char.datatype }?,
 298     attribute per-mille { char.datatype }?,
 299     attribute zero-digit { char.datatype }?,
 300     attribute digit { char.datatype }?,
 301     attribute pattern-separator { char.datatype }?
 302   }
 303 message.element =
 304   element message {
 305     extension.atts,
 306     attribute terminate { xsd:string "yes" | xsd:string "no" }?,
 307     template.model
 308   }
 309 fallback.element = element fallback { extension.atts, template.model }
 310 output.element =
 311   element output {
 312     extension.atts,
 313     attribute method {
 314       xsd:string "xml"
 315       | xsd:string "html"
 316       | xsd:string "text"
 317       | qname-but-not-ncname.datatype
 318     }?,
 319     attribute version { xsd:NMTOKEN }?,
 320     attribute encoding { text }?,
 321     attribute omit-xml-declaration {
 322       xsd:string "yes" | xsd:string "no"
 323     }?,
 324     attribute standalone { xsd:string "yes" | xsd:string "no" }?,
 325     attribute doctype-public { text }?,
 326     attribute doctype-system { text }?,
 327     attribute cdata-section-elements { qnames.datatype }?,
 328     attribute indent { xsd:string "yes" | xsd:string "no" }?,
 329     attribute media-type { text }?
 330   }
 331 prefixes.datatype = list { (xsd:NCName | "#default")* }
 332 prefix.datatype = xsd:NCName | "#default"
 333 wildcards.datatype =
 334   list {
 335     (xsd:QName
 336      | xsd:token { pattern = "\*|\i\c*:\*" })*
 337   }
 338 qname.datatype = xsd:QName
 339 qnames.datatype = list { xsd:QName* }
 340 char.datatype = xsd:string { length = "1" }
 341 number.datatype = xsd:decimal
 342 expression.datatype = text
 343 pattern.datatype = text
 344 qname-but-not-ncname.datatype = xsd:QName { pattern = ".*:.*" }
 345 # An AVT containing at least one expression.
 346 expr-avt.datatype =
 347   xsd:string {
 348     pattern =
 349       """([^\{\}]|\{\{|\}\})*\{([^"'\{\}]|"[^"]*"|'[^']*')+\}([^\{\}]|\{\{|\}\}|\{([^"'\{\}]|"[^"]*"|'[^']*')+\})*"""
 350   }
 351 # An AVT containing at least one brace; ie where instantiated AVT
 352 # is not the same as the literal AVT.
 353 brace-avt.datatype =
 354   xsd:string {
 355     pattern =
 356       """[^\{\}]*(\{\{|\}\}|\{([^"'\{\}]|"[^"]*"|'[^']*')+\})([^\{\}]|\{\{|\}\}|\{([^"'\{\}]|"[^"]*"|'[^']*')+\})*"""
 357   }
 358 avt.datatype =
 359   xsd:string {
 360     pattern =
 361       """([^\{\}]|\{\{|\}\}|\{([^"'\{\}]|"[^"]*"|'[^']*')+\})*"""
 362   }