xproc.rnc

default namespace p = "http://www.w3.org/ns/xproc"
namespace c = "http://www.w3.org/ns/xproc-step"
namespace s = "http://www.ascc.net/xml/schematron"
namespace local = ""
namespace sa = "http://xproc.org/ns/syntax-annotations"
namespace xs = "http://www.w3.org/2001/XMLSchema"

# This is schema version $Id: xproc.rnc,v 1.84 2010/05/03 20:31:46 NormanWalsh Exp $

# This schema neither supports nor requires the use of RELAX NG DTD Compatibility

[
   sa:model = "XPathExpression"
]
XPathExpression = text

[
   sa:model = "XSLTMatchPattern"
]
XSLTMatchPattern = text

[
   sa:model = "XPathSequenceType"
]
XPathSequenceType = text

[
   sa:model = "MediaTypes"
]
MediaTypes = text

name.ncname.attr = attribute name { xsd:NCName }
name.qname.attr = attribute name { xsd:QName }
as.attr = attribute as { XPathSequenceType }
port.attr = attribute port { xsd:NCName }
required.attr = attribute required { xsd:boolean }
sequence.attr = attribute sequence { xsd:boolean }
primary.attr = attribute primary { xsd:boolean }
select.attr = attribute select { XPathExpression }
xpath-version.attr = attribute xpath-version { text }
psvi-required.attr = attribute psvi-required { xsd:boolean }

exclude-inline-prefixes.attr =
   attribute exclude-inline-prefixes { ExcludeInlinePrefixes }

# Bah, humbug. The ExcludeInlinePrefixes pattern should 
# really be ("#all" | (PrefixList & "#default"?)) or
# maybe ("#all" | (PrefixList | "#default")+), but neither
# one of those is allowed by RELAX NG.
[
   sa:model = "ExcludeInlinePrefixes"
]
ExcludeInlinePrefixes = text

[
   sa:model = "PrefixList"
]
PrefixList = xsd:NMTOKENS

[
   sa:model = "QNameList"
]
QNameList = xsd:NMTOKENS

[
   sa:ignore = "yes"
]
xmlid.attr = attribute xml:id { xsd:ID }

[
   sa:ignore = "yes"
]
xmlbase.attr = attribute xml:base { xsd:anyURI }
href.attr = attribute href { xsd:anyURI }

[
   sa:ignore = "yes"
]
use-when.attr = attribute use-when { XPathExpression }

[
   sa:ignore = "yes"
]
p_use-when.attr = attribute p:use-when { XPathExpression }

version.attr = attribute version { text }

common.attributes = xmlid.attr?, xmlbase.attr?, extension.attr*

inline.attributes = exclude-inline-prefixes.attr?, attribute expand-text { xsd:boolean }?

decl.attributes = psvi-required.attr?,
   xpath-version.attr?,
   exclude-inline-prefixes.attr?,
   version.attr?

# ============================================================

start = Pipeline | Library | DeclareStep
 | VocabParam | VocabParamSet | VocabResult | VocabHttpRequest
 | VocabHeader | VocabMultipart | VocabBody | VocabHttpResponse | VocabQuery
 | VocabLine | VocabData | VocabDirectory | Errors | StandardStep

# ============================================================

[
   sa:class = "language-construct"
]
Library =
   element library {
      decl.attributes,
      common.attributes,
      use-when.attr?,
      (Import|DeclareStep|Pipeline|Documentation|PipeInfo)*
   }

[
   sa:class = "language-construct"
]
Import =
   element import {
      common.attributes,
      use-when.attr?,
      href.attr,
      (Documentation|PipeInfo)*
   }

[
   sa:class = "language-construct"
]
Pipeline =
   element pipeline {
      name.ncname.attr?,
      attribute type { xsd:QName }?,
      common.attributes,
      use-when.attr?,
      decl.attributes,
      (Input|Output|Option|Log
       |Serialization|Documentation|PipeInfo)*,
      (DeclareStep|Pipeline|Import|Documentation|PipeInfo)*,
      Subpipeline
   }

[
   sa:model = "subpipeline"
]
Subpipeline = Variable*,(ForEach|Viewport|Choose|Group|Try|OtherStep|Documentation|PipeInfo)+

# ============================================================

[
   sa:class = "language-construct"
]
InputDeclaration =
   element input {
      port.attr,
      sequence.attr?,
      primary.attr?,
      attribute content-types { MediaTypes }?,
      select.attr?,
      common.attributes,
      inline.attributes,
      use-when.attr?,
      (((\Empty|(Document|Inline)+)? & (Documentation|PipeInfo)*)|Any)
   }

[
   sa:class = "language-construct"
]
InputConnection =
   element input {
      port.attr?,
      select.attr?,
      common.attributes,
      inline.attributes,
      use-when.attr?,
      (((\Empty|(Document|Inline)+)? & (Documentation|PipeInfo)*)|Any)
   }

[
   sa:element = "input"
]
Input = InputDeclaration | InputConnection

# ============================================================

[
   sa:class = "language-construct"
]
OutputDeclaration =
   element output {
      port.attr?,
      sequence.attr?,
      primary.attr?,
      common.attributes,
      use-when.attr?,
      (Documentation|PipeInfo)*
   }

[
   sa:class = "language-construct"
]
OutputConnection =
   element output {
      port.attr?,
      sequence.attr?,
      primary.attr?,
      common.attributes,
      inline.attributes,
      use-when.attr?,
      (((\Empty|(Pipe|Document|Inline)+)? & (Documentation|PipeInfo)*)|Any)
   }

[
   sa:element = "output"
]
Output = OutputDeclaration | OutputConnection

[
   sa:class = "language-construct"
]
Pipe =
   element pipe {
      attribute step { xsd:NCName }?,
      port.attr?,
      common.attributes,
      use-when.attr?,
      (Documentation|PipeInfo)*
   }

[
   sa:class = "language-construct"
]
Document =
   element document {
      href.attr,
      attribute override-content-type { text }?,
      common.attributes,
      use-when.attr?,
      (Documentation|PipeInfo)*
   }

[
   sa:class = "language-construct"
]
Inline =
   element inline {
      common.attributes,
      inline.attributes,
      use-when.attr?,
      Any
   }

[
   sa:class = "language-construct"
]
\Empty =
   element empty {
      (Documentation|PipeInfo)*
   }

[
   sa:class = "language-construct"
]
Log =
   element log {
      common.attributes,
      use-when.attr?,
      port.attr?,
      href.attr?,
      (Documentation|PipeInfo)*
   }

[
   sa:class = "language-construct"
]
Serialization =
   element serialization {
      common.attributes,
      use-when.attr?,
      port.attr,
      attribute byte-order-mark { xsd:boolean }?,
      attribute cdata-section-elements { xsd:NMTOKENS }?,
      attribute doctype-public { text }?,
      attribute doctype-system { text }?,
      attribute encoding { text }?,
      attribute escape-uri-attributes { xsd:boolean }?,
      attribute include-content-type { xsd:boolean }?,
      attribute indent { xsd:boolean }?,
      attribute media-type { text }?,
      attribute method { xsd:QName }?,
      attribute normalization-form { 'NFC'|'NFD'|'NFKC'|'NFKD'|'fully-normalized'|'none'|xsd:NMTOKEN }?,
      attribute omit-xml-declaration { xsd:boolean }?,
      attribute standalone { "true" | "false" | "omit" }?,
      attribute undeclare-prefixes { xsd:boolean }?,
      attribute version { text }?,
      (Documentation|PipeInfo)*
   }

# ============================================================

[
   sa:class = "language-construct"
]
OptionDeclaration =
   element option {
      name.qname.attr,
      as.attr?,
      required.attr?,
      common.attributes,
      use-when.attr?,
      (Documentation|PipeInfo)*
   }

[
   sa:class = "language-construct"
]
OptionSelect =
   element option {
      name.qname.attr,
      as.attr?,
      required.attr?,
      select.attr,
      common.attributes,
      use-when.attr?,
      (Documentation|PipeInfo)*
   }

[
   sa:element = "option"
]
Option = OptionDeclaration | OptionSelect

# ============================================================

[
   sa:class = "language-construct"
]
WithOptionSelect =
   element with-option {
      name.qname.attr,
      as.attr?,
      select.attr,
      common.attributes,
      inline.attributes,
      use-when.attr?,
      (((\Empty|Pipe|Document|Inline)? & (Namespaces|Documentation|PipeInfo)*)|Any)
   }

[
   sa:element = "with-option"
]
WithOption = WithOptionSelect

# ============================================================

[
   sa:class = "language-construct"
]
VariableSelect =
   element variable {
      name.qname.attr,
      as.attr?,
      select.attr,
      common.attributes,
      inline.attributes,
      use-when.attr?,
      (((\Empty|Pipe|Document|Inline)? & (Namespaces|Documentation|PipeInfo)*)|Any)
   }

[
   sa:element = "variable"
]
Variable = VariableSelect

# ============================================================

[
   sa:class = "language-construct"
]
Namespaces =
   element namespaces {
      attribute binding { xsd:QName }?,
      attribute element { XPathExpression }?,
      attribute except-prefixes { PrefixList }?,
      (Documentation|PipeInfo)*
   }


# ============================================================

[
   sa:class = "language-construct"
]
DeclareStep =
   element declare-step {
      name.ncname.attr?,
      attribute type { xsd:QName }?,
      decl.attributes,
      common.attributes,
      use-when.attr?,
      (Input|Output|Option|Log
       |Serialization|Documentation|PipeInfo)*,
      ((DeclareStep|Pipeline|Import|Documentation|PipeInfo)*,Subpipeline)?
   }

# ============================================================

[
   sa:class = "language-construct"
]
ForEach =
   element for-each {
      name.ncname.attr?,
      common.attributes,
      use-when.attr?,
      ((Input? & (Output|Log|Documentation|PipeInfo)*), Subpipeline)
   }

# ============================================================

[
   sa:class = "language-construct"
]
Viewport =
   element viewport {
      name.ncname.attr?,
      attribute match { XSLTMatchPattern },
      common.attributes,
      use-when.attr?,
      ((Input? & Output? & Log? & Documentation* & PipeInfo*), Subpipeline)
   }

# ============================================================

[
   sa:class = "language-construct"
]
Choose =
   element choose {
      name.ncname.attr?,
      common.attributes,
      use-when.attr?,
      ((Documentation|PipeInfo)*,
         Input?,
         Variable*,
         (When|Documentation|PipeInfo)*,
         Otherwise?,
         (Documentation|PipeInfo)*)
   }

[
   sa:class = "language-construct"
]
When =
   element when {
      attribute test { XPathExpression },
      common.attributes,
      use-when.attr?,
      ((Documentation|PipeInfo)*,
         Input?,
         (Output|Log|Documentation|PipeInfo)*,
         Subpipeline)
   }

[
   sa:class = "language-construct"
]
Otherwise =
   element otherwise {
      common.attributes,
      use-when.attr?,
      ((Output|Log|Documentation|PipeInfo)*, Subpipeline)
   }

# ============================================================

[
   sa:class = "language-construct"
]
Group =
   element group {
      name.ncname.attr?,
      common.attributes,
      use-when.attr?,
      ((Output|Log|Documentation|PipeInfo)*, Subpipeline)
   }

# ============================================================

[
   sa:class = "language-construct"
]
Try =
   element try {
      name.ncname.attr?,
      common.attributes,
      use-when.attr?,
      ((Variable*, TryGroup, Catch+, Finally?) & (Documentation|PipeInfo)*)
   }

[
   sa:class = "language-construct"
]
TryGroup =
   element group {
      common.attributes,
      use-when.attr?,
      ((Output|Log|Documentation|PipeInfo)*, Subpipeline)
   }

[
   sa:class = "language-construct"
]
Catch =
   element catch {
      name.ncname.attr?,
      attribute code { QNameList }?,
      common.attributes,
      use-when.attr?,
      ((Output|Log|Documentation|PipeInfo)*, Subpipeline)
   }

[
   sa:class = "language-construct"
]
Finally =
   element finally {
      name.ncname.attr?,
      common.attributes,
      use-when.attr?,
      ((Documentation|PipeInfo)*, Subpipeline)
   }

# ============================================================

[
   sa:class = "language-construct"
]
OtherAtomicStep =
   element * - (p:*) {
      name.ncname.attr?,
      option.attr*,
      common.attributes,
      p_use-when.attr?,
      (InputConnection|WithOption|Log|Documentation|PipeInfo)*
   }

[
   sa:class = "language-construct"
]
OtherCompoundStep =
   element * - (p:*) {
      name.ncname.attr?,
      common.attributes,
      p_use-when.attr?,
      ((Output|Log|Documentation|PipeInfo)*, Subpipeline)
   }

OtherStep = StandardStep | OtherAtomicStep | OtherCompoundStep

# ============================================================
[
   sa:ignore = "yes"
   sa:class = "language-construct"
]
Documentation =
   element documentation {
      common.attributes,
      use-when.attr?,
      DocContent*
   }

[
   sa:model = "any-well-formed-content"
]
DocContent = (text | Any)

# ============================================================
[
   sa:ignore = "yes"
   sa:class = "language-construct"
]
PipeInfo =
   element pipeinfo {
      common.attributes,
      use-when.attr?,
      DocContent*
   }

# ============================================================

_any.attr =
   attribute * { text }

option.attr =
   attribute (local:* - local:name) { text }

extension.attr =
   attribute (* - (local:*|xml:*|p:*)) { text }

[
   sa:model = "anyElement"
]
Any =
   element * {
      (_any.attr | text | Any)*
   }

# ============================================================

[
   sa:class = "step-vocabulary"
]
VocabParam =
   element c:param {
      name.qname.attr,
      attribute namespace { xsd:anyURI }?,
      attribute value { text },
      empty
   }

[
   sa:class = "step-vocabulary"
]
VocabParamSet =
   element c:param-set {
      VocabParam*
   }

[
   sa:class = "step-vocabulary"
]
VocabDirectory =
   element c:directory {
      attribute name { text },
      ((VocabFile|VocabDirectory|VocabOther)*)
   }
[
   sa:class = "step-vocabulary"
]
VocabFile =
   element c:file {
      attribute name { text },
      empty
   }
[
   sa:class = "step-vocabulary"
]
VocabOther =
   element c:other {
      attribute name { text },
      empty
   }
[
   sa:class = "step-vocabulary"
]
VocabResult =
   element c:result {
      text
   }
[
   sa:class = "step-vocabulary"
]
VocabHttpRequest =
   element c:request {
      attribute method { xsd:NCName },
      attribute href { xsd:anyURI }?,
      attribute detailed { xsd:boolean }?,
      attribute status-only { xsd:boolean }?,
      attribute username { text }?,
      attribute password { text }?,
      attribute auth-method { text }?,
      attribute send-authorization { xsd:boolean }?,
      attribute override-content-type { text }?,
      (VocabHeader*,(VocabMultipart|VocabBody)?)
   }

[
   sa:class = "step-vocabulary"
]
VocabHeader =
   element c:header {
      attribute name { text },
      attribute value { text },
      empty
   }

[
   sa:class = "step-vocabulary"
]
VocabMultipart =
   element c:multipart {
      attribute content-type { text },
      attribute boundary { text },
      (VocabBody)+
   }

[
   sa:class = "step-vocabulary"
]
VocabBody =
   element c:body {
      attribute content-type { text },
      attribute encoding { text }?,
      attribute id { text }?,
      attribute description { text }?,
      attribute disposition { text }?,
      Any*
   }

[
   sa:class = "step-vocabulary"
]
VocabHttpResponse =
   element c:response {
      attribute status { xsd:integer }?,
      (VocabHeader*,(VocabMultipart|VocabBody)?)
   }

[
   sa:class = "step-vocabulary"
]
VocabQuery =
   element c:query {
      text
   }

[
   sa:class = "step-vocabulary"
]
VocabLine =
   element c:line {
      text
   }

[
   sa:class = "step-vocabulary"
]
VocabData =
   element c:data {
      attribute content-type { text }?,
      attribute charset { text }?,
      attribute encoding { text }?,
      text
   }

# ============================================================

[
   sa:class = "error-vocabulary"
]
Errors =
   element c:errors {
      Error*
   }

[
   sa:class = "error-vocabulary"
]
Error =
   element c:error {
      name.ncname.attr?,
      attribute type { xsd:QName }?,
      attribute code { xsd:QName }?,
      attribute href { xsd:anyURI }?,
      attribute line { xsd:integer }?,
      attribute column { xsd:integer }?,
      attribute offset { xsd:integer }?,
      (text|Any)*
   }

Charset = text
Encoding = text
MIMEContentType = text
MIMEMediaType = text
RegularExpression = text
NormalizationForm = 'NFC'|'NFD'|'NFKC'|'NFKD'|'fully-normalized'|'none'|xsd:NMTOKEN
ListOfQNames = text

include "steps.rnc"