olink.docbook-xsl.assembly.schema.docbook51b7.rnc Maven / Gradle / Ivy
namespace a = "http://relaxng.org/ns/compatibility/annotations/1.0"
namespace ctrl = "http://nwalsh.com/xmlns/schema-control/"
default namespace db = "http://docbook.org/ns/docbook"
namespace html = "http://www.w3.org/1999/xhtml"
namespace mml = "http://www.w3.org/1998/Math/MathML"
namespace rng = "http://relaxng.org/ns/structure/1.0"
namespace s = "http://purl.oclc.org/dsdl/schematron"
namespace svg = "http://www.w3.org/2000/svg"
namespace xlink = "http://www.w3.org/1999/xlink"
# This file is part of DocBook V5.1b7
#
# Copyright 1992-2011 HaL Computer Systems, Inc.,
# O'Reilly & Associates, Inc., ArborText, Inc., Fujitsu Software
# Corporation, Norman Walsh, Sun Microsystems, Inc., and the
# Organization for the Advancement of Structured Information
# Standards (OASIS).
#
# Permission to use, copy, modify and distribute the DocBook schema
# and its accompanying documentation for any purpose and without fee
# is hereby granted in perpetuity, provided that the above copyright
# notice and this paragraph appear in all copies. The copyright
# holders make no representation about the suitability of the schema
# for any purpose. It is provided "as is" without expressed or implied
# warranty.
#
# If you modify the DocBook schema in any way, label your schema as a
# variant of DocBook. See the reference documentation
# (http://docbook.org/tdg5/en/html/ch05.html#s-notdocbook)
# for more information.
#
# Please direct all questions, bug reports, or suggestions for changes
# to the [email protected] mailing list. For more
# information, see http://www.oasis-open.org/docbook/.
#
# ======================================================================
start =
(db.set
| db.book
| db.divisions
| db.components
| db.navigation.components
| db.section
| db.para)
| (db.abstract
| db.mediaobject.content
| db.audiodata
| db.imagedata
| db.textdata
| db.videodata
| db.caption
| db.publishing.blocks
| db.formal.blocks
| db.informal.blocks
| db.formalpara
| db.inlinemediaobject
| db.list.blocks
| db.legalnotice
| db.verbatim.blocks
| db.graphic.blocks
| db.personblurb
| db.revhistory
| db.simpara
| db.step
| db.stepalternatives)
| (db.partintro | db.simplesect)
| db.annotation
| (db.sect1 | db.sect2 | db.sect3 | db.sect4 | db.sect5)
| (db.refentry | db.refsection | db.refsynopsisdiv)
| (db.refsect1 | db.refsect2 | db.refsect3)
| (db.glossary | db.glossdiv | db.glosslist)
| (db.bibliodiv | db.bibliolist)
| (db.setindex | db.index | db.indexdiv)
| (db.toc | db.tocdiv)
| (db.task | db.taskprerequisites | db.taskrelated | db.tasksummary)
| (db.calloutlist
| db.programlistingco
| db.screenco
| db.imageobjectco)
| (db.productionset | db.constraintdef)
| (db.msg
| db.msgexplan
| db.msgmain
| db.msgrel
| db.msgset
| db.msgsub)
| (db.qandadiv | db.qandaentry | db.qandaset)
| (db.equation | db.informalequation)
| db.cmdsynopsis
| (db.synopsis.blocks | db.funcsynopsisinfo | db.classsynopsisinfo)
| db.admonition.blocks
| db.topic
div {
db._any.attribute =
## Any attribute, including any attribute in any namespace.
attribute * { text }
db._any =
## Any element from almost any namespace
element * - (db:* | html:*) {
(db._any.attribute | text | db._any)*
}
}
db.arch.attribute =
## Designates the computer or chip architecture to which the element applies
attribute arch { text }
db.audience.attribute =
## Designates the intended audience to which the element applies, for example, system administrators, programmers, or new users.
attribute audience { text }
db.condition.attribute =
## provides a standard place for application-specific effectivity
attribute condition { text }
db.conformance.attribute =
## Indicates standards conformance characteristics of the element
attribute conformance { text }
db.os.attribute =
## Indicates the operating system to which the element is applicable
attribute os { text }
db.revision.attribute =
## Indicates the editorial revision to which the element belongs
attribute revision { text }
db.security.attribute =
## Indicates something about the security level associated with the element to which it applies
attribute security { text }
db.userlevel.attribute =
## Indicates the level of user experience for which the element applies
attribute userlevel { text }
db.vendor.attribute =
## Indicates the computer vendor to which the element applies.
attribute vendor { text }
db.wordsize.attribute =
## Indicates the word size (width in bits) of the computer architecture to which the element applies
attribute wordsize { text }
db.effectivity.attributes =
db.arch.attribute?
& db.audience.attribute?
& db.condition.attribute?
& db.conformance.attribute?
& db.os.attribute?
& db.revision.attribute?
& db.security.attribute?
& db.userlevel.attribute?
& db.vendor.attribute?
& db.wordsize.attribute?
db.endterm.attribute =
## Points to the element whose content is to be used as the text of the link
attribute endterm { xsd:IDREF }
db.linkend.attribute =
## Points to an internal link target by identifying the value of its xml:id attribute
attribute linkend { xsd:IDREF }
db.linkends.attribute =
## Points to one or more internal link targets by identifying the value of their xml:id attributes
attribute linkends { xsd:IDREFS }
db.xlink.href.attribute =
## Identifies a link target with a URI
attribute xlink:href { xsd:anyURI }
db.xlink.simple.type.attribute =
## Identifies the XLink link type
attribute xlink:type {
## An XLink simple link type
"simple"
}
db.xlink.role.attribute =
## Identifies the XLink role of the link
attribute xlink:role { xsd:anyURI }
db.xlink.arcrole.attribute =
## Identifies the XLink arcrole of the link
attribute xlink:arcrole { xsd:anyURI }
db.xlink.title.attribute =
## Identifies the XLink title of the link
attribute xlink:title { text }
db.xlink.show.enumeration =
## An application traversing to the ending resource should load it in a new window, frame, pane, or other relevant presentation context.
"new"
|
## An application traversing to the ending resource should load the resource in the same window, frame, pane, or other relevant presentation context in which the starting resource was loaded.
"replace"
|
## An application traversing to the ending resource should load its presentation in place of the presentation of the starting resource.
"embed"
|
## The behavior of an application traversing to the ending resource is unconstrained by XLink. The application should look for other markup present in the link to determine the appropriate behavior.
"other"
|
## The behavior of an application traversing to the ending resource is unconstrained by this specification. No other markup is present to help the application determine the appropriate behavior.
"none"
db.xlink.show.attribute =
## Identifies the XLink show behavior of the link
attribute xlink:show { db.xlink.show.enumeration }
db.xlink.actuate.enumeration =
## An application should traverse to the ending resource immediately on loading the starting resource.
"onLoad"
|
## An application should traverse from the starting resource to the ending resource only on a post-loading event triggered for the purpose of traversal.
"onRequest"
|
## The behavior of an application traversing to the ending resource is unconstrained by this specification. The application should look for other markup present in the link to determine the appropriate behavior.
"other"
|
## The behavior of an application traversing to the ending resource is unconstrained by this specification. No other markup is present to help the application determine the appropriate behavior.
"none"
db.xlink.actuate.attribute =
## Identifies the XLink actuate behavior of the link
attribute xlink:actuate { db.xlink.actuate.enumeration }
db.xlink.simple.link.attributes =
db.xlink.simple.type.attribute?
& db.xlink.href.attribute?
& db.xlink.role.attribute?
& db.xlink.arcrole.attribute?
& db.xlink.title.attribute?
& db.xlink.show.attribute?
& db.xlink.actuate.attribute?
db.xlink.attributes =
db.xlink.simple.link.attributes
| (db.xlink.extended.link.attributes
| db.xlink.locator.link.attributes
| db.xlink.arc.link.attributes
| db.xlink.resource.link.attributes
| db.xlink.title.link.attributes)
db.xml.id.attribute =
## Identifies the unique ID value of the element
attribute xml:id { xsd:ID }
db.version.attribute =
## Specifies the DocBook version of the element and its descendants
attribute version { text }
db.xml.lang.attribute =
## Specifies the natural language of the element and its descendants
attribute xml:lang { text }
db.xml.base.attribute =
## Specifies the base URI of the element and its descendants
attribute xml:base { xsd:anyURI }
db.remap.attribute =
## Provides the name or similar semantic identifier assigned to the content in some previous markup scheme
attribute remap { text }
db.xreflabel.attribute =
## Provides the text that is to be generated for a cross reference to the element
attribute xreflabel { text }
db.xrefstyle.attribute =
## Specifies a keyword or keywords identifying additional style information
attribute xrefstyle { text }
db.revisionflag.enumeration =
## The element has been changed.
"changed"
|
## The element is new (has been added to the document).
"added"
|
## The element has been deleted.
"deleted"
|
## Explicitly turns off revision markup for this element.
"off"
db.revisionflag.attribute =
## Identifies the revision status of the element
attribute revisionflag { db.revisionflag.enumeration }
db.dir.enumeration =
## Left-to-right text
"ltr"
|
## Right-to-left text
"rtl"
|
## Left-to-right override
"lro"
|
## Right-to-left override
"rlo"
db.dir.attribute =
## Identifies the direction of text in an element
attribute dir { db.dir.enumeration }
db.common.base.attributes =
db.version.attribute?
& db.xml.lang.attribute?
& db.xml.base.attribute?
& db.remap.attribute?
& db.xreflabel.attribute?
& db.revisionflag.attribute?
& db.dir.attribute?
& db.effectivity.attributes
db.common.attributes =
db.xml.id.attribute?
& db.common.base.attributes
& db.annotations.attribute?
db.common.idreq.attributes =
db.xml.id.attribute
& db.common.base.attributes
& db.annotations.attribute?
db.common.linking.attributes =
(db.linkend.attribute | db.xlink.attributes)?
db.common.req.linking.attributes =
db.linkend.attribute | db.xlink.attributes
db.common.data.attributes =
## Specifies the format of the data
attribute format { text }?,
(
## Indentifies the location of the data by URI
attribute fileref { xsd:anyURI }
|
## Identifies the location of the data by external identifier (entity name)
attribute entityref { xsd:ENTITY })
db.verbatim.continuation.enumeration =
## Line numbering continues from the immediately preceding element with the same name.
"continues"
|
## Line numbering restarts (begins at 1, usually).
"restarts"
db.verbatim.continuation.attribute =
## Determines whether line numbering continues from the previous element or restarts.
attribute continuation { db.verbatim.continuation.enumeration }
db.verbatim.linenumbering.enumeration =
## Lines are numbered.
"numbered"
|
## Lines are not numbered.
"unnumbered"
db.verbatim.linenumbering.attribute =
## Determines whether lines are numbered.
attribute linenumbering { db.verbatim.linenumbering.enumeration }
db.verbatim.startinglinenumber.attribute =
## Specifies the initial line number.
attribute startinglinenumber { xsd:integer }
db.verbatim.language.attribute =
## Identifies the language (i.e. programming language) of the verbatim content.
attribute language { text }
db.verbatim.xml.space.attribute =
## Can be used to indicate explicitly that whitespace in the verbatim environment is preserved. Whitespace must always be preserved in verbatim environments whether this attribute is specified or not.
attribute xml:space {
## Whitespace must be preserved.
"preserve"
}
db.verbatim.common.attributes =
db.verbatim.continuation.attribute?
& db.verbatim.linenumbering.attribute?
& db.verbatim.startinglinenumber.attribute?
& db.verbatim.xml.space.attribute?
db.verbatim.attributes =
db.verbatim.common.attributes & db.verbatim.language.attribute?
db.label.attribute =
## Specifies an identifying string for presentation purposes
attribute label { text }
db.width.characters.attribute =
## Specifies the width (in characters) of the element
attribute width { xsd:nonNegativeInteger }
db.spacing.enumeration =
## The spacing should be "compact".
"compact"
|
## The spacing should be "normal".
"normal"
db.spacing.attribute =
## Specifies (a hint about) the spacing of the content
attribute spacing { db.spacing.enumeration }
db.pgwide.enumeration =
## The element should be rendered in the current text flow (with the flow column width).
"0"
|
## The element should be rendered across the full text page.
"1"
db.pgwide.attribute =
## Indicates if the element is rendered across the column or the page
attribute pgwide { db.pgwide.enumeration }
db.language.attribute =
## Identifies the language (i.e. programming language) of the content.
attribute language { text }
db.performance.enumeration =
## The content describes an optional step or steps.
"optional"
|
## The content describes a required step or steps.
"required"
db.performance.attribute =
## Specifies if the content is required or optional.
attribute performance { db.performance.enumeration }
db.floatstyle.attribute =
## Specifies style information to be used when rendering the float
attribute floatstyle { text }
db.width.attribute =
## Specifies the width of the element
attribute width { text }
db.depth.attribute =
## Specifies the depth of the element
attribute depth { text }
db.contentwidth.attribute =
## Specifies the width of the content rectangle
attribute contentwidth { text }
db.contentdepth.attribute =
## Specifies the depth of the content rectangle
attribute contentdepth { text }
db.scalefit.enumeration =
## False (do not scale-to-fit; anamorphic scaling may occur)
"0"
|
## True (scale-to-fit; anamorphic scaling is forbidden)
"1"
db.scale.attribute =
## Specifies the scaling factor
attribute scale { xsd:positiveInteger }
db.classid.attribute =
## Specifies a classid for a media object player
attribute classid { text }
db.autoplay.attribute =
## Specifies the autoplay setting for a media object player
attribute autoplay { text }
db.halign.enumeration =
## Centered horizontally
"center"
|
## Aligned horizontally on the specified character
"char"
|
## Fully justified (left and right margins or edges)
"justify"
|
## Left aligned
"left"
|
## Right aligned
"right"
db.valign.enumeration =
## Aligned on the bottom of the region
"bottom"
|
## Centered vertically
"middle"
|
## Aligned on the top of the region
"top"
db.biblio.class.enumeration =
## A digital object identifier.
"doi"
|
## An international standard book number.
"isbn"
|
## An international standard technical report number (ISO 10444).
"isrn"
|
## An international standard serial number.
"issn"
|
## An international standard text code.
"istc"
|
## A Library of Congress reference number.
"libraryofcongress"
|
## A publication number (an internal number or possibly organizational standard).
"pubsnumber"
|
## A Uniform Resource Identifier
"uri"
db.biblio.class-enum.attribute =
## Identifies the kind of bibliographic identifier
attribute class { db.biblio.class.enumeration }?
db.biblio.class-other.attribute =
## Identifies the nature of the non-standard bibliographic identifier
attribute otherclass { xsd:NMTOKEN }
db.biblio.class-other.attributes =
## Identifies the kind of bibliographic identifier
attribute class {
## Indicates that the identifier is some 'other' kind.
"other"
}
& db.biblio.class-other.attribute
db.biblio.class.attribute =
db.biblio.class-enum.attribute | db.biblio.class-other.attributes
db.ubiq.inlines =
(db.inlinemediaobject
| db.remark
| db.link.inlines
| db.alt
| db.trademark
| # below, effectively the publishing inlines (as of 5.0)
db.abbrev
| db.acronym
| db.date
| db._emphasis
| db.footnote
| db.footnoteref
| db._foreignphrase
| db._phrase
| db._quote
| db.subscript
| db.superscript
| db.wordasword)
| db.annotation
| (db._firstterm | db._glossterm)
| db.indexterm
| db.coref
db._text = (text | db.ubiq.inlines | db._phrase | db.replaceable)*
db._title = db.title? & db.titleabbrev? & db.subtitle?
db._title.req = db.title & db.titleabbrev? & db.subtitle?
db._title.only = db.title? & db.titleabbrev?
db._title.onlyreq = db.title & db.titleabbrev?
db._info = (db._title, db.titleforbidden.info?) | db.info?
db._info.title.req =
(db._title.req, db.titleforbidden.info?) | db.titlereq.info
db._info.title.only =
(db._title.only, db.titleforbidden.info?) | db.titleonly.info
db._info.title.onlyreq =
(db._title.onlyreq, db.titleforbidden.info?) | db.titleonlyreq.info
db._info.title.forbidden = db.titleforbidden.info?
db.all.inlines =
text
| db.ubiq.inlines
| db.general.inlines
| db.domain.inlines
| db.extension.inlines
db.general.inlines =
db.publishing.inlines
| db.product.inlines
| db.bibliography.inlines
| db.graphic.inlines
| db.indexing.inlines
| db.link.inlines
db.domain.inlines =
db.technical.inlines
| db.math.inlines
| db.markup.inlines
| db.gui.inlines
| db.keyboard.inlines
| db.os.inlines
| db.programming.inlines
| db.error.inlines
db.technical.inlines =
(db.replaceable | db.package | db.parameter)
| db.termdef
| db.nonterminal
| (db.systemitem | db.option | db.optional | db.property)
db.product.inlines =
db.trademark
| (db.productnumber
| db.productname
| db.database
| db.application
| db.hardware)
db.bibliography.inlines =
db.citation
| db.citerefentry
| db.citetitle
| db.citebiblioid
| db.author
| db.person
| db.personname
| db.org
| db.orgname
| db.editor
| db.jobtitle
db.publishing.inlines =
(db.abbrev
| db.acronym
| db.date
| db.emphasis
| db.footnote
| db.footnoteref
| db.foreignphrase
| db.phrase
| db.quote
| db.subscript
| db.superscript
| db.wordasword)
| db.glossary.inlines
| db.coref
db.graphic.inlines = db.inlinemediaobject
db.indexing.inlines = notAllowed | db.indexterm
db.link.inlines =
(db.xref | db.link | db.olink | db.anchor) | db.biblioref
db.extension.inlines = notAllowed
db.nopara.blocks =
(db.list.blocks
| db.formal.blocks
| db.informal.blocks
| db.publishing.blocks
| db.graphic.blocks
| db.technical.blocks
| db.verbatim.blocks
| db.bridgehead
| db.remark
| db.revhistory)
| db.indexterm
| db.synopsis.blocks
| db.admonition.blocks
db.para.blocks = db.anchor | db.para | db.formalpara | db.simpara
db.all.blocks =
(db.nopara.blocks | db.para.blocks | db.extension.blocks)
| db.annotation
db.formal.blocks = (db.example | db.figure | db.table) | db.equation
db.informal.blocks =
(db.informalexample | db.informalfigure | db.informaltable)
| db.informalequation
db.publishing.blocks =
db.sidebar | db.blockquote | db.address | db.epigraph
db.graphic.blocks = db.mediaobject | db.screenshot
db.technical.blocks =
db.procedure
| db.task
| (db.productionset | db.constraintdef)
| db.msgset
db.list.blocks =
(db.itemizedlist
| db.orderedlist
| db.procedure
| db.simplelist
| db.variablelist
| db.segmentedlist)
| db.glosslist
| db.bibliolist
| db.calloutlist
| db.qandaset
db.verbatim.blocks =
(db.screen | db.literallayout)
| (db.programlistingco | db.screenco)
| (db.programlisting | db.synopsis)
db.extension.blocks = notAllowed
db.info.extension = db._any
db.info.elements =
(db.abstract
| db.address
| db.artpagenums
| db.author
| db.authorgroup
| db.authorinitials
| db.bibliocoverage
| db.biblioid
| db.bibliosource
| db.collab
| db.confgroup
| db.contractsponsor
| db.contractnum
| db.copyright
| db.cover
| db.date
| db.edition
| db.editor
| db.issuenum
| db.keywordset
| db.legalnotice
| db.mediaobject
| db.org
| db.orgname
| db.othercredit
| db.pagenums
| db.printhistory
| db.pubdate
| db.publisher
| db.publishername
| db.releaseinfo
| db.revhistory
| db.seriesvolnums
| db.subjectset
| db.volumenum
| db.info.extension)
| db.annotation
| db.extendedlink
| (db.bibliomisc | db.bibliomset | db.bibliorelation | db.biblioset)
| db.itermset
| (db.productname | db.productnumber)
db.bibliographic.elements =
db.info.elements
| db.publishing.inlines
| db.citerefentry
| db.citetitle
| db.citebiblioid
| db.person
| db.personblurb
| db.personname
| db.subtitle
| db.title
| db.titleabbrev
div {
db.title.role.attribute = attribute role { text }
db.title.attlist =
db.title.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.title =
## The text of the title of a section of a document or of a formal block-level element
element title { db.title.attlist, db.all.inlines* }
}
div {
db.titleabbrev.role.attribute = attribute role { text }
db.titleabbrev.attlist =
db.titleabbrev.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.titleabbrev =
## The abbreviation of a title
element titleabbrev { db.titleabbrev.attlist, db.all.inlines* }
}
div {
db.subtitle.role.attribute = attribute role { text }
db.subtitle.attlist =
db.subtitle.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.subtitle =
## The subtitle of a document
element subtitle { db.subtitle.attlist, db.all.inlines* }
}
div {
db.info.role.attribute = attribute role { text }
db.info.attlist = db.info.role.attribute? & db.common.attributes
db.info =
## A wrapper for information about a component or other block
element info { db.info.attlist, (db._title & db.info.elements*) }
}
div {
db.titlereq.info.role.attribute = attribute role { text }
db.titlereq.info.attlist =
db.titlereq.info.role.attribute? & db.common.attributes
db.titlereq.info =
## A wrapper for information about a component or other block with a required title
element info {
db.titlereq.info.attlist, (db._title.req & db.info.elements*)
}
}
div {
db.titleonly.info.role.attribute = attribute role { text }
db.titleonly.info.attlist =
db.titleonly.info.role.attribute? & db.common.attributes
db.titleonly.info =
## A wrapper for information about a component or other block with only a title
element info {
db.titleonly.info.attlist, (db._title.only & db.info.elements*)
}
}
div {
db.titleonlyreq.info.role.attribute = attribute role { text }
db.titleonlyreq.info.attlist =
db.titleonlyreq.info.role.attribute? & db.common.attributes
db.titleonlyreq.info =
## A wrapper for information about a component or other block with only a required title
element info {
db.titleonlyreq.info.attlist,
(db._title.onlyreq & db.info.elements*)
}
}
div {
db.titleforbidden.info.role.attribute = attribute role { text }
db.titleforbidden.info.attlist =
db.titleforbidden.info.role.attribute? & db.common.attributes
db.titleforbidden.info =
## A wrapper for information about a component or other block without a title
element info { db.titleforbidden.info.attlist, db.info.elements* }
}
div {
db.subjectset.role.attribute = attribute role { text }
db.subjectset.scheme.attribute =
## Identifies the controlled vocabulary used by this set's terms
attribute scheme { xsd:NMTOKEN }
db.subjectset.attlist =
db.subjectset.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.subjectset.scheme.attribute?
db.subjectset =
## A set of terms describing the subject matter of a document
element subjectset { db.subjectset.attlist, db.subject+ }
}
div {
db.subject.role.attribute = attribute role { text }
db.subject.weight.attribute =
## Specifies a ranking for this subject relative to other subjects in the same set
attribute weight { text }
db.subject.attlist =
db.subject.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.subject.weight.attribute?
db.subject =
## One of a group of terms describing the subject matter of a document
element subject { db.subject.attlist, db.subjectterm+ }
}
div {
db.subjectterm.role.attribute = attribute role { text }
db.subjectterm.attlist =
db.subjectterm.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.subjectterm =
## A term in a group of terms describing the subject matter of a document
element subjectterm { db.subjectterm.attlist, text }
}
div {
db.keywordset.role.attribute = attribute role { text }
db.keywordset.attlist =
db.keywordset.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.keywordset =
## A set of keywords describing the content of a document
element keywordset { db.keywordset.attlist, db.keyword+ }
}
div {
db.keyword.role.attribute = attribute role { text }
db.keyword.attlist =
db.keyword.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.keyword =
## One of a set of keywords describing the content of a document
element keyword { db.keyword.attlist, text }
}
db.table.choice = notAllowed | db.cals.table | db.html.table
db.informaltable.choice =
notAllowed | db.cals.informaltable | db.html.informaltable
db.table = db.table.choice
db.informaltable = db.informaltable.choice
div {
db.procedure.role.attribute = attribute role { text }
db.procedure.attlist =
db.procedure.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.procedure.info = db._info.title.only
db.procedure =
## A list of operations to be performed in a well-defined sequence
[
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:procedure"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element procedure {
db.procedure.attlist, db.procedure.info, db.all.blocks*, db.step+
}
}
div {
db.step.role.attribute = attribute role { text }
db.step.attlist =
db.step.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.performance.attribute?
db.step.info = db._info.title.only
# This content model is blocks*, step|stepalternatives, blocks* but
# expressed this way it avoids UPA issues in XSD and DTD versions
db.step =
## A unit of action in a procedure
[
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:step"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element step {
db.step.attlist,
db.step.info,
((db.all.blocks+,
((db.substeps | db.stepalternatives), db.all.blocks*)?)
| ((db.substeps | db.stepalternatives), db.all.blocks*))
}
}
div {
db.stepalternatives.role.attribute = attribute role { text }
db.stepalternatives.attlist =
db.stepalternatives.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.performance.attribute?
db.stepalternatives.info = db._info.title.forbidden
db.stepalternatives =
## Alternative steps in a procedure
[
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:stepalternatives"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element stepalternatives {
db.stepalternatives.attlist, db.stepalternatives.info, db.step+
}
}
div {
db.substeps.role.attribute = attribute role { text }
db.substeps.attlist =
db.substeps.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.performance.attribute?
db.substeps =
## A wrapper for steps that occur within steps in a procedure
element substeps { db.substeps.attlist, db.step+ }
}
div {
db.sidebar.floatstyle.attribute = db.floatstyle.attribute
db.sidebar.role.attribute = attribute role { text }
db.sidebar.attlist =
db.sidebar.role.attribute?
& db.sidebar.floatstyle.attribute?
& db.common.attributes
& db.common.linking.attributes
db.sidebar.info = db._info
db.sidebar =
## A portion of a document that is isolated from the main narrative flow
[
s:pattern [
name = "Element exclusion"
"\x{a}" ~
" "
s:rule [
context = "db:sidebar"
"\x{a}" ~
" "
s:assert [
test = "not(.//db:sidebar)"
"sidebar must not occur among the children or descendants of sidebar"
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:sidebar"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element sidebar {
db.sidebar.attlist, db.sidebar.info, db.all.blocks+
}
}
div {
db.abstract.role.attribute = attribute role { text }
db.abstract.attlist =
db.abstract.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.abstract.info = db._info.title.only
db.abstract =
## A summary
[
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:abstract"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element abstract {
db.abstract.attlist, db.abstract.info, db.para.blocks+
}
}
div {
db.personblurb.role.attribute = attribute role { text }
db.personblurb.attlist =
db.personblurb.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.personblurb.info = db._info.title.only
db.personblurb =
## A short description or note about a person
[
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:personblurb"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element personblurb {
db.personblurb.attlist, db.personblurb.info, db.para.blocks+
}
}
div {
db.blockquote.role.attribute = attribute role { text }
db.blockquote.attlist =
db.blockquote.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.blockquote.info = db._info.title.only
db.blockquote =
## A quotation set off from the main text
[
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:blockquote"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element blockquote {
db.blockquote.attlist,
db.blockquote.info,
db.attribution?,
db.all.blocks+
}
}
div {
db.attribution.role.attribute = attribute role { text }
db.attribution.attlist =
db.attribution.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.attribution =
## The source of a block quote or epigraph
element attribution {
db.attribution.attlist,
(db._text
| db.person
| db.personname
| db.citetitle
| db.citation)*
}
}
div {
db.bridgehead.renderas.enumeration =
## Render as a first-level section
"sect1"
|
## Render as a second-level section
"sect2"
|
## Render as a third-level section
"sect3"
|
## Render as a fourth-level section
"sect4"
|
## Render as a fifth-level section
"sect5"
db.bridgehead.renderas-enum.attribute =
## Indicates how the bridge head should be rendered
attribute renderas { db.bridgehead.renderas.enumeration }?
db.bridgehead.renderas-other.attribute =
## Identifies the nature of the non-standard rendering
attribute otherrenderas { xsd:NMTOKEN }
db.bridgehead.renderas-other.attributes =
## Indicates how the bridge head should be rendered
attribute renderas {
## Identifies a non-standard rendering
"other"
}
& db.bridgehead.renderas-other.attribute
db.bridgehead.renderas.attribute =
db.bridgehead.renderas-enum.attribute
| db.bridgehead.renderas-other.attributes
db.bridgehead.role.attribute = attribute role { text }
db.bridgehead.attlist =
db.bridgehead.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.bridgehead.renderas.attribute?
db.bridgehead =
## A free-floating heading
element bridgehead { db.bridgehead.attlist, db.all.inlines* }
}
div {
db.remark.role.attribute = attribute role { text }
db.remark.attlist =
db.remark.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.remark =
## A remark (or comment) intended for presentation in a draft manuscript
element remark { db.remark.attlist, db.all.inlines* }
}
div {
db.epigraph.role.attribute = attribute role { text }
db.epigraph.attlist =
db.epigraph.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.epigraph.info = db._info.title.forbidden
db.epigraph =
## A short inscription at the beginning of a document or component
[
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:epigraph"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element epigraph {
db.epigraph.attlist,
db.epigraph.info,
db.attribution?,
(db.para.blocks | db.literallayout)+
}
}
div {
db.footnote.role.attribute = attribute role { text }
db.footnote.label.attribute =
## Identifies the desired footnote mark
attribute label { xsd:NMTOKEN }
db.footnote.attlist =
db.footnote.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.footnote.label.attribute?
db.footnote =
## A footnote
[
s:pattern [
name = "Element exclusion"
"\x{a}" ~
" "
s:rule [
context = "db:footnote"
"\x{a}" ~
" "
s:assert [
test = "not(.//db:footnote)"
"footnote must not occur among the children or descendants of footnote"
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
s:pattern [
name = "Element exclusion"
"\x{a}" ~
" "
s:rule [
context = "db:footnote"
"\x{a}" ~
" "
s:assert [
test = "not(.//db:example)"
"example must not occur among the children or descendants of footnote"
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
s:pattern [
name = "Element exclusion"
"\x{a}" ~
" "
s:rule [
context = "db:footnote"
"\x{a}" ~
" "
s:assert [
test = "not(.//db:figure)"
"figure must not occur among the children or descendants of footnote"
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
s:pattern [
name = "Element exclusion"
"\x{a}" ~
" "
s:rule [
context = "db:footnote"
"\x{a}" ~
" "
s:assert [
test = "not(.//db:table)"
"table must not occur among the children or descendants of footnote"
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
s:pattern [
name = "Element exclusion"
"\x{a}" ~
" "
s:rule [
context = "db:footnote"
"\x{a}" ~
" "
s:assert [
test = "not(.//db:equation)"
"equation must not occur among the children or descendants of footnote"
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
s:pattern [
name = "Element exclusion"
"\x{a}" ~
" "
s:rule [
context = "db:footnote"
"\x{a}" ~
" "
s:assert [
test = "not(.//db:sidebar)"
"sidebar must not occur among the children or descendants of footnote"
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
s:pattern [
name = "Element exclusion"
"\x{a}" ~
" "
s:rule [
context = "db:footnote"
"\x{a}" ~
" "
s:assert [
test = "not(.//db:task)"
"task must not occur among the children or descendants of footnote"
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
s:pattern [
name = "Element exclusion"
"\x{a}" ~
" "
s:rule [
context = "db:footnote"
"\x{a}" ~
" "
s:assert [
test = "not(.//db:epigraph)"
"epigraph must not occur among the children or descendants of footnote"
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
s:pattern [
name = "Element exclusion"
"\x{a}" ~
" "
s:rule [
context = "db:footnote"
"\x{a}" ~
" "
s:assert [
test = "not(.//db:caution)"
"caution must not occur among the children or descendants of footnote"
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
s:pattern [
name = "Element exclusion"
"\x{a}" ~
" "
s:rule [
context = "db:footnote"
"\x{a}" ~
" "
s:assert [
test = "not(.//db:important)"
"important must not occur among the children or descendants of footnote"
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
s:pattern [
name = "Element exclusion"
"\x{a}" ~
" "
s:rule [
context = "db:footnote"
"\x{a}" ~
" "
s:assert [
test = "not(.//db:note)"
"note must not occur among the children or descendants of footnote"
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
s:pattern [
name = "Element exclusion"
"\x{a}" ~
" "
s:rule [
context = "db:footnote"
"\x{a}" ~
" "
s:assert [
test = "not(.//db:tip)"
"tip must not occur among the children or descendants of footnote"
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
s:pattern [
name = "Element exclusion"
"\x{a}" ~
" "
s:rule [
context = "db:footnote"
"\x{a}" ~
" "
s:assert [
test = "not(.//db:warning)"
"warning must not occur among the children or descendants of footnote"
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element footnote { db.footnote.attlist, db.all.blocks+ }
}
div {
db.formalpara.role.attribute = attribute role { text }
db.formalpara.attlist =
db.formalpara.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.formalpara.info = db._info.title.onlyreq
db.formalpara =
## A paragraph with a title
[
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:formalpara"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element formalpara {
db.formalpara.attlist,
db.formalpara.info,
db.indexing.inlines*,
db.para
}
}
div {
db.para.role.attribute = attribute role { text }
db.para.attlist =
db.para.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.para.info = db._info.title.forbidden
db.para =
## A paragraph
[
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:para"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element para {
db.para.attlist,
db.para.info,
(db.all.inlines | db.nopara.blocks)*
}
}
div {
db.simpara.role.attribute = attribute role { text }
db.simpara.attlist =
db.simpara.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.simpara.info = db._info.title.forbidden
db.simpara =
## A paragraph that contains only text and inline markup, no block elements
[
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:simpara"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element simpara {
db.simpara.attlist, db.simpara.info, db.all.inlines*
}
}
div {
db.itemizedlist.role.attribute = attribute role { text }
db.itemizedlist.mark.attribute =
## Identifies the type of mark to be used on items in this list
attribute mark { xsd:NMTOKEN }
db.itemizedlist.attlist =
db.itemizedlist.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.spacing.attribute?
& db.itemizedlist.mark.attribute?
db.itemizedlist.info = db._info.title.only
db.itemizedlist =
## A list in which each entry is marked with a bullet or other dingbat
[
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:itemizedlist"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element itemizedlist {
db.itemizedlist.attlist,
db.itemizedlist.info,
db.all.blocks*,
db.listitem+
}
}
div {
db.orderedlist.role.attribute = attribute role { text }
db.orderedlist.continuation.enumeration =
## Specifies that numbering should begin where the preceding list left off
"continues"
|
## Specifies that numbering should begin again at 1
"restarts"
db.orderedlist.continuation.attribute =
## Indicates how list numbering should begin relative to the immediately preceding list
attribute continuation { db.orderedlist.continuation.enumeration }
db.orderedlist.startingnumber.attribute =
## Specifies the initial line number.
attribute startingnumber { xsd:integer }
db.orderedlist.inheritnum.enumeration =
## Specifies that numbering should ignore list nesting
"ignore"
|
## Specifies that numbering should inherit from outer-level lists
"inherit"
db.orderedlist.inheritnum.attribute =
## Indicates whether or not item numbering should be influenced by list nesting
attribute inheritnum { db.orderedlist.inheritnum.enumeration }
db.orderedlist.numeration.enumeration =
## Specifies Arabic numeration (1, 2, 3, …)
"arabic"
|
## Specifies upper-case alphabetic numeration (A, B, C, …)
"upperalpha"
|
## Specifies lower-case alphabetic numeration (a, b, c, …)
"loweralpha"
|
## Specifies upper-case Roman numeration (I, II, III, …)
"upperroman"
|
## Specifies lower-case Roman numeration (i, ii, iii …)
"lowerroman"
db.orderedlist.numeration.attribute =
## Indicates the desired numeration
attribute numeration { db.orderedlist.numeration.enumeration }
db.orderedlist.attlist =
db.orderedlist.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.spacing.attribute?
& (db.orderedlist.continuation.attribute
| db.orderedlist.startingnumber.attribute)?
& db.orderedlist.inheritnum.attribute?
& db.orderedlist.numeration.attribute?
db.orderedlist.info = db._info.title.only
db.orderedlist =
## A list in which each entry is marked with a sequentially incremented label
[
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:orderedlist"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element orderedlist {
db.orderedlist.attlist,
db.orderedlist.info,
db.all.blocks*,
db.listitem+
}
}
div {
db.listitem.role.attribute = attribute role { text }
db.listitem.override.attribute =
## Specifies the keyword for the type of mark that should be used on this
## item, instead of the mark that would be used by default
attribute override { xsd:NMTOKEN }
db.listitem.attlist =
db.listitem.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.listitem.override.attribute?
db.listitem =
## A wrapper for the elements of a list item
element listitem { db.listitem.attlist, db.all.blocks+ }
}
div {
db.segmentedlist.role.attribute = attribute role { text }
db.segmentedlist.attlist =
db.segmentedlist.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.segmentedlist.info = db._info.title.only
db.segmentedlist =
## A segmented list, a list of sets of elements
[
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:segmentedlist"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element segmentedlist {
db.segmentedlist.attlist,
db.segmentedlist.info,
db.segtitle+,
db.seglistitem+
}
}
div {
db.segtitle.role.attribute = attribute role { text }
db.segtitle.attlist =
db.segtitle.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.segtitle =
## The title of an element of a list item in a segmented list
element segtitle { db.segtitle.attlist, db.all.inlines* }
}
div {
db.seglistitem.role.attribute = attribute role { text }
db.seglistitem.attlist =
db.seglistitem.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.seglistitem =
## A list item in a segmented list
[
s:pattern [
name = "Cardinality of segments and titles"
"\x{a}" ~
" "
s:rule [
context = "db:seglistitem"
"\x{a}" ~
" "
s:assert [
test = "count(db:seg) = count(../db:segtitle)"
"The number of seg elements must be the same as the number of segtitle elements in the parent segmentedlist"
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element seglistitem { db.seglistitem.attlist, db.seg+ }
}
div {
db.seg.role.attribute = attribute role { text }
db.seg.attlist =
db.seg.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.seg =
## An element of a list item in a segmented list
element seg { db.seg.attlist, db.all.inlines* }
}
div {
db.simplelist.role.attribute = attribute role { text }
db.simplelist.type.enumeration =
## A tabular presentation in row-major order.
"horiz"
|
## A tabular presentation in column-major order.
"vert"
|
## An inline presentation, usually a comma-delimited list.
"inline"
db.simplelist.type.attribute =
## Specifies the type of list presentation.
[ a:defaultValue = "vert" ]
attribute type { db.simplelist.type.enumeration }
db.simplelist.columns.attribute =
## Specifies the number of columns for horizontal or vertical presentation
attribute columns { xsd:integer }
db.simplelist.attlist =
db.simplelist.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.simplelist.type.attribute?
& db.simplelist.columns.attribute?
db.simplelist =
## An undecorated list of single words or short phrases
[
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:simplelist"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element simplelist { db.simplelist.attlist, db.member+ }
}
div {
db.member.role.attribute = attribute role { text }
db.member.attlist =
db.member.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.member =
## An element of a simple list
element member { db.member.attlist, db.all.inlines* }
}
div {
db.variablelist.role.attribute = attribute role { text }
db.variablelist.termlength.attribute =
## Indicates a length beyond which the presentation system may consider a term too long and select an alternate presentation for that term, item, or list
attribute termlength { text }
db.variablelist.attlist =
db.variablelist.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.spacing.attribute?
& db.variablelist.termlength.attribute?
db.variablelist.info = db._info.title.only
db.variablelist =
## A list in which each entry is composed of a set of one or more terms and an associated description
[
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:variablelist"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element variablelist {
db.variablelist.attlist,
db.variablelist.info,
db.all.blocks*,
db.varlistentry+
}
}
div {
db.varlistentry.role.attribute = attribute role { text }
db.varlistentry.attlist =
db.varlistentry.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.varlistentry =
## A wrapper for a set of terms and the associated description in a variable list
element varlistentry {
db.varlistentry.attlist, db.term+, db.listitem
}
}
div {
db.term.role.attribute = attribute role { text }
db.term.attlist =
db.term.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.term =
## The word or phrase being defined or described in a variable list
element term { db.term.attlist, db.all.inlines* }
}
div {
db.example.role.attribute = attribute role { text }
db.example.label.attribute = db.label.attribute
db.example.width.attribute = db.width.characters.attribute
db.example.pgwide.attribute = db.pgwide.attribute
db.example.floatstyle.attribute = db.floatstyle.attribute
db.example.attlist =
db.example.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.example.label.attribute?
& db.example.floatstyle.attribute?
& (db.example.width.attribute | db.example.pgwide.attribute)?
db.example.info = db._info.title.onlyreq
db.example =
## A formal example, with a title
[
s:pattern [
name = "Element exclusion"
"\x{a}" ~
" "
s:rule [
context = "db:example"
"\x{a}" ~
" "
s:assert [
test = "not(.//db:example)"
"example must not occur among the children or descendants of example"
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
s:pattern [
name = "Element exclusion"
"\x{a}" ~
" "
s:rule [
context = "db:example"
"\x{a}" ~
" "
s:assert [
test = "not(.//db:figure)"
"figure must not occur among the children or descendants of example"
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
s:pattern [
name = "Element exclusion"
"\x{a}" ~
" "
s:rule [
context = "db:example"
"\x{a}" ~
" "
s:assert [
test = "not(.//db:table)"
"table must not occur among the children or descendants of example"
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
s:pattern [
name = "Element exclusion"
"\x{a}" ~
" "
s:rule [
context = "db:example"
"\x{a}" ~
" "
s:assert [
test = "not(.//db:equation)"
"equation must not occur among the children or descendants of example"
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
s:pattern [
name = "Element exclusion"
"\x{a}" ~
" "
s:rule [
context = "db:example"
"\x{a}" ~
" "
s:assert [
test = "not(.//db:caution)"
"caution must not occur among the children or descendants of example"
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
s:pattern [
name = "Element exclusion"
"\x{a}" ~
" "
s:rule [
context = "db:example"
"\x{a}" ~
" "
s:assert [
test = "not(.//db:important)"
"important must not occur among the children or descendants of example"
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
s:pattern [
name = "Element exclusion"
"\x{a}" ~
" "
s:rule [
context = "db:example"
"\x{a}" ~
" "
s:assert [
test = "not(.//db:note)"
"note must not occur among the children or descendants of example"
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
s:pattern [
name = "Element exclusion"
"\x{a}" ~
" "
s:rule [
context = "db:example"
"\x{a}" ~
" "
s:assert [
test = "not(.//db:tip)"
"tip must not occur among the children or descendants of example"
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
s:pattern [
name = "Element exclusion"
"\x{a}" ~
" "
s:rule [
context = "db:example"
"\x{a}" ~
" "
s:assert [
test = "not(.//db:warning)"
"warning must not occur among the children or descendants of example"
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:example"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element example {
db.example.attlist, db.example.info, db.all.blocks+, db.caption?
}
}
div {
db.informalexample.role.attribute = attribute role { text }
db.informalexample.width.attribute = db.width.characters.attribute
db.informalexample.pgwide.attribute = db.pgwide.attribute
db.informalexample.floatstyle.attribute = db.floatstyle.attribute
db.informalexample.attlist =
db.informalexample.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.informalexample.floatstyle.attribute?
& (db.informalexample.width.attribute
| db.informalexample.pgwide.attribute)?
db.informalexample.info = db._info.title.forbidden
db.informalexample =
## A displayed example without a title
[
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:informalexample"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element informalexample {
db.informalexample.attlist,
db.informalexample.info,
db.all.blocks+,
db.caption?
}
}
db.verbatim.inlines = (db.all.inlines | db.lineannotation) | db.co
db.verbatim.contentmodel =
db._info.title.forbidden, (db.textobject | db.verbatim.inlines*)
div {
db.literallayout.role.attribute = attribute role { text }
db.literallayout.class.enumeration =
## The literal layout should be formatted with a monospaced font
"monospaced"
|
## The literal layout should be formatted with the current font
"normal"
db.literallayout.class.attribute =
## Specifies the class of literal layout
attribute class { db.literallayout.class.enumeration }
db.literallayout.attlist =
db.literallayout.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.verbatim.attributes
& db.literallayout.class.attribute?
db.literallayout =
## A block of text in which line breaks and white space are to be reproduced faithfully
[
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:literallayout"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element literallayout {
db.literallayout.attlist, db.verbatim.contentmodel
}
}
div {
db.screen.role.attribute = attribute role { text }
db.screen.width.attribute = db.width.characters.attribute
db.screen.attlist =
db.screen.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.verbatim.attributes
& db.screen.width.attribute?
db.screen =
## Text that a user sees or might see on a computer screen
[
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:screen"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element screen { db.screen.attlist, db.verbatim.contentmodel }
}
div {
db.screenshot.role.attribute = attribute role { text }
db.screenshot.attlist =
db.screenshot.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.screenshot.info = db._info
db.screenshot =
## A representation of what the user sees or might see on a computer screen
[
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:screenshot"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element screenshot {
db.screenshot.attlist, db.screenshot.info, db.mediaobject
}
}
div {
db.figure.role.attribute = attribute role { text }
db.figure.label.attribute = db.label.attribute
db.figure.pgwide.attribute = db.pgwide.attribute
db.figure.floatstyle.attribute = db.floatstyle.attribute
db.figure.attlist =
db.figure.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.figure.label.attribute?
& db.figure.pgwide.attribute?
& db.figure.floatstyle.attribute?
db.figure.info = db._info.title.onlyreq
db.figure =
## A formal figure, generally an illustration, with a title
[
s:pattern [
name = "Element exclusion"
"\x{a}" ~
" "
s:rule [
context = "db:figure"
"\x{a}" ~
" "
s:assert [
test = "not(.//db:example)"
"example must not occur among the children or descendants of figure"
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
s:pattern [
name = "Element exclusion"
"\x{a}" ~
" "
s:rule [
context = "db:figure"
"\x{a}" ~
" "
s:assert [
test = "not(.//db:figure)"
"figure must not occur among the children or descendants of figure"
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
s:pattern [
name = "Element exclusion"
"\x{a}" ~
" "
s:rule [
context = "db:figure"
"\x{a}" ~
" "
s:assert [
test = "not(.//db:table)"
"table must not occur among the children or descendants of figure"
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
s:pattern [
name = "Element exclusion"
"\x{a}" ~
" "
s:rule [
context = "db:figure"
"\x{a}" ~
" "
s:assert [
test = "not(.//db:equation)"
"equation must not occur among the children or descendants of figure"
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
s:pattern [
name = "Element exclusion"
"\x{a}" ~
" "
s:rule [
context = "db:figure"
"\x{a}" ~
" "
s:assert [
test = "not(.//db:caution)"
"caution must not occur among the children or descendants of figure"
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
s:pattern [
name = "Element exclusion"
"\x{a}" ~
" "
s:rule [
context = "db:figure"
"\x{a}" ~
" "
s:assert [
test = "not(.//db:important)"
"important must not occur among the children or descendants of figure"
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
s:pattern [
name = "Element exclusion"
"\x{a}" ~
" "
s:rule [
context = "db:figure"
"\x{a}" ~
" "
s:assert [
test = "not(.//db:note)"
"note must not occur among the children or descendants of figure"
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
s:pattern [
name = "Element exclusion"
"\x{a}" ~
" "
s:rule [
context = "db:figure"
"\x{a}" ~
" "
s:assert [
test = "not(.//db:tip)"
"tip must not occur among the children or descendants of figure"
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
s:pattern [
name = "Element exclusion"
"\x{a}" ~
" "
s:rule [
context = "db:figure"
"\x{a}" ~
" "
s:assert [
test = "not(.//db:warning)"
"warning must not occur among the children or descendants of figure"
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:figure"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element figure {
db.figure.attlist, db.figure.info, db.all.blocks+, db.caption?
}
}
div {
db.informalfigure.role.attribute = attribute role { text }
db.informalfigure.label.attribute = db.label.attribute
db.informalfigure.pgwide.attribute = db.pgwide.attribute
db.informalfigure.floatstyle.attribute = db.floatstyle.attribute
db.informalfigure.attlist =
db.informalfigure.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.informalfigure.label.attribute?
& db.informalfigure.pgwide.attribute?
& db.informalfigure.floatstyle.attribute?
db.informalfigure.info = db._info.title.forbidden
db.informalfigure =
## A untitled figure
[
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:informalfigure"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element informalfigure {
db.informalfigure.attlist,
db.informalfigure.info,
db.all.blocks+,
db.caption?
}
}
db.mediaobject.content =
(db.videoobject | db.audioobject | db.imageobject | db.textobject)
| db.imageobjectco
div {
db.mediaobject.role.attribute = attribute role { text }
db.mediaobject.attlist =
db.mediaobject.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.mediaobject.info = db._info.title.forbidden
db.mediaobject =
## A displayed media object (video, audio, image, etc.)
[
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:mediaobject"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element mediaobject {
db.mediaobject.attlist,
db.mediaobject.info,
db.alt?,
db.mediaobject.content+,
db.caption?
}
}
div {
db.inlinemediaobject.role.attribute = attribute role { text }
db.inlinemediaobject.attlist =
db.inlinemediaobject.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.inlinemediaobject.info = db._info.title.forbidden
db.inlinemediaobject =
## An inline media object (video, audio, image, and so on)
[
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:inlinemediaobject"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element inlinemediaobject {
db.inlinemediaobject.attlist,
db.inlinemediaobject.info,
db.alt?,
db.mediaobject.content+
}
}
div {
db.videoobject.role.attribute = attribute role { text }
db.videoobject.attlist =
db.videoobject.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.videoobject.info = db._info.title.forbidden
db.videoobject =
## A wrapper for video data and its associated meta-information
[
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:videoobject"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element videoobject {
db.videoobject.attlist,
db.videoobject.info,
db.videodata,
db.multimediaparam*
}
}
div {
db.audioobject.role.attribute = attribute role { text }
db.audioobject.attlist =
db.audioobject.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.audioobject.info = db._info.title.forbidden
db.audioobject =
## A wrapper for audio data and its associated meta-information
[
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:audioobject"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element audioobject {
db.audioobject.attlist,
db.audioobject.info,
db.audiodata,
db.multimediaparam*
}
}
db.imageobject.content =
db.imagedata | db.imagedata.mathml | db.imagedata.svg
div {
db.imageobject.role.attribute = attribute role { text }
db.imageobject.attlist =
db.imageobject.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.imageobject.info = db._info.title.forbidden
db.imageobject =
## A wrapper for image data and its associated meta-information
[
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:imageobject"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element imageobject {
db.imageobject.attlist,
db.imageobject.info,
db.imageobject.content
}
}
div {
db.textobject.role.attribute = attribute role { text }
db.textobject.attlist =
db.textobject.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.textobject.info = db._info.title.forbidden
db.textobject =
## A wrapper for a text description of an object and its associated meta-information
[
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:textobject"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element textobject {
db.textobject.attlist,
db.textobject.info,
(db.phrase | db.textdata | db.all.blocks+)
}
}
div {
db.videodata.role.attribute = attribute role { text }
db.videodata.align.enumeration = db.halign.enumeration
db.videodata.align.attribute =
## Specifies the (horizontal) alignment of the video data
attribute align { db.videodata.align.enumeration }
db.videodata.autoplay.attribute = db.autoplay.attribute
db.videodata.classid.attribute = db.classid.attribute
db.videodata.valign.enumeration = db.valign.enumeration
db.videodata.valign.attribute =
## Specifies the vertical alignment of the video data
attribute valign { db.videodata.valign.enumeration }
db.videodata.width.attribute = db.width.attribute
db.videodata.depth.attribute = db.depth.attribute
db.videodata.contentwidth.attribute = db.contentwidth.attribute
db.videodata.contentdepth.attribute = db.contentdepth.attribute
db.videodata.scalefit.enumeration = db.scalefit.enumeration
db.videodata.scalefit.attribute =
## Determines if anamorphic scaling is forbidden
attribute scalefit { db.videodata.scalefit.enumeration }
db.videodata.scale.attribute = db.scale.attribute
db.videodata.attlist =
db.videodata.role.attribute?
& db.common.attributes
& db.common.data.attributes
& db.videodata.align.attribute?
& db.videodata.valign.attribute?
& db.videodata.width.attribute?
& db.videodata.contentwidth.attribute?
& db.videodata.scalefit.attribute?
& db.videodata.scale.attribute?
& db.videodata.depth.attribute?
& db.videodata.contentdepth.attribute?
& db.videodata.autoplay.attribute?
& db.videodata.classid.attribute?
db.videodata.info = db._info.title.forbidden
db.videodata =
## Pointer to external video data
[
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:videodata"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element videodata { db.videodata.attlist, db.videodata.info }
}
div {
db.audiodata.role.attribute = attribute role { text }
db.audiodata.align.enumeration = db.halign.enumeration
db.audiodata.align.attribute =
## Specifies the (horizontal) alignment of the video data
attribute align { db.audiodata.align.enumeration }
db.audiodata.autoplay.attribute = db.autoplay.attribute
db.audiodata.classid.attribute = db.classid.attribute
db.audiodata.contentwidth.attribute = db.contentwidth.attribute
db.audiodata.contentdepth.attribute = db.contentdepth.attribute
db.audiodata.depth.attribute = db.depth.attribute
db.audiodata.scale.attribute = db.scale.attribute
db.audiodata.scalefit.enumeration = db.scalefit.enumeration
db.audiodata.scalefit.attribute =
## Determines if anamorphic scaling is forbidden
attribute scalefit { db.audiodata.scalefit.enumeration }
db.audiodata.valign.enumeration = db.valign.enumeration
db.audiodata.valign.attribute =
## Specifies the vertical alignment of the video data
attribute valign { db.audiodata.valign.enumeration }
db.audiodata.width.attribute = db.width.attribute
db.audiodata.attlist =
db.audiodata.role.attribute?
& db.common.attributes
& db.common.data.attributes
& db.audiodata.align.attribute?
& db.audiodata.autoplay.attribute?
& db.audiodata.classid.attribute?
& db.audiodata.contentdepth.attribute?
& db.audiodata.contentwidth.attribute?
& db.audiodata.depth.attribute?
& db.audiodata.scale.attribute?
& db.audiodata.scalefit.attribute?
& db.audiodata.valign.attribute?
& db.audiodata.width.attribute?
db.audiodata.info = db._info.title.forbidden
db.audiodata =
## Pointer to external audio data
[
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:audiodata"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element audiodata { db.audiodata.attlist, db.audiodata.info }
}
div {
db.imagedata.role.attribute = attribute role { text }
db.imagedata.align.enumeration = db.halign.enumeration
db.imagedata.align.attribute =
## Specifies the (horizontal) alignment of the image data
attribute align { db.imagedata.align.enumeration }
db.imagedata.valign.enumeration = db.valign.enumeration
db.imagedata.valign.attribute =
## Specifies the vertical alignment of the image data
attribute valign { db.imagedata.valign.enumeration }
db.imagedata.width.attribute = db.width.attribute
db.imagedata.depth.attribute = db.depth.attribute
db.imagedata.contentwidth.attribute = db.contentwidth.attribute
db.imagedata.contentdepth.attribute = db.contentdepth.attribute
db.imagedata.scalefit.enumeration = db.scalefit.enumeration
db.imagedata.scalefit.attribute =
## Determines if anamorphic scaling is forbidden
attribute scalefit { db.imagedata.scalefit.enumeration }
db.imagedata.scale.attribute = db.scale.attribute
db.imagedata.attlist =
db.imagedata.role.attribute?
& db.common.attributes
& db.common.data.attributes
& db.imagedata.align.attribute?
& db.imagedata.valign.attribute?
& db.imagedata.width.attribute?
& db.imagedata.contentwidth.attribute?
& db.imagedata.scalefit.attribute?
& db.imagedata.scale.attribute?
& db.imagedata.depth.attribute?
& db.imagedata.contentdepth.attribute?
db.imagedata.info = db._info.title.forbidden
db.imagedata =
## Pointer to external image data
[
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:imagedata"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element imagedata { db.imagedata.attlist, db.imagedata.info }
}
div {
db.textdata.role.attribute = attribute role { text }
db.textdata.encoding.attribute =
## Identifies the encoding of the text in the external file
attribute encoding { text }
db.textdata.attlist =
db.textdata.role.attribute?
& db.common.attributes
& db.common.data.attributes
& db.textdata.encoding.attribute?
db.textdata.info = db._info.title.forbidden
db.textdata =
## Pointer to external text data
[
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:textdata"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element textdata { db.textdata.attlist, db.textdata.info }
}
div {
db.multimediaparam.role.attribute = attribute role { text }
db.multimediaparam.name.attribute =
## Specifies the name of the parameter
attribute name { text }
db.multimediaparam.value.attribute =
## Specifies the value of the parameter
attribute value { text }
db.multimediaparam.valuetype.attribute =
## Specifies the type of the value of the parameter
attribute valuetype { text }
db.multimediaparam.attlist =
db.multimediaparam.role.attribute?
& db.common.attributes
& db.multimediaparam.name.attribute
& db.multimediaparam.value.attribute
& db.multimediaparam.valuetype.attribute?
db.multimediaparam =
## Application specific parameters for a media player
element multimediaparam { db.multimediaparam.attlist, empty }
}
div {
db.caption.role.attribute = attribute role { text }
db.caption.attlist =
db.caption.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.caption.info = db._info.title.forbidden
db.caption =
## A caption
[
s:pattern [
name = "Element exclusion"
"\x{a}" ~
" "
s:rule [
context = "db:caption"
"\x{a}" ~
" "
s:assert [
test = "not(.//db:example)"
"example must not occur among the children or descendants of caption"
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
s:pattern [
name = "Element exclusion"
"\x{a}" ~
" "
s:rule [
context = "db:caption"
"\x{a}" ~
" "
s:assert [
test = "not(.//db:figure)"
"figure must not occur among the children or descendants of caption"
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
s:pattern [
name = "Element exclusion"
"\x{a}" ~
" "
s:rule [
context = "db:caption"
"\x{a}" ~
" "
s:assert [
test = "not(.//db:table)"
"table must not occur among the children or descendants of caption"
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
s:pattern [
name = "Element exclusion"
"\x{a}" ~
" "
s:rule [
context = "db:caption"
"\x{a}" ~
" "
s:assert [
test = "not(.//db:equation)"
"equation must not occur among the children or descendants of caption"
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
s:pattern [
name = "Element exclusion"
"\x{a}" ~
" "
s:rule [
context = "db:caption"
"\x{a}" ~
" "
s:assert [
test = "not(.//db:sidebar)"
"sidebar must not occur among the children or descendants of caption"
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
s:pattern [
name = "Element exclusion"
"\x{a}" ~
" "
s:rule [
context = "db:caption"
"\x{a}" ~
" "
s:assert [
test = "not(.//db:task)"
"task must not occur among the children or descendants of caption"
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
s:pattern [
name = "Element exclusion"
"\x{a}" ~
" "
s:rule [
context = "db:caption"
"\x{a}" ~
" "
s:assert [
test = "not(.//db:caution)"
"caution must not occur among the children or descendants of caption"
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
s:pattern [
name = "Element exclusion"
"\x{a}" ~
" "
s:rule [
context = "db:caption"
"\x{a}" ~
" "
s:assert [
test = "not(.//db:important)"
"important must not occur among the children or descendants of caption"
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
s:pattern [
name = "Element exclusion"
"\x{a}" ~
" "
s:rule [
context = "db:caption"
"\x{a}" ~
" "
s:assert [
test = "not(.//db:note)"
"note must not occur among the children or descendants of caption"
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
s:pattern [
name = "Element exclusion"
"\x{a}" ~
" "
s:rule [
context = "db:caption"
"\x{a}" ~
" "
s:assert [
test = "not(.//db:tip)"
"tip must not occur among the children or descendants of caption"
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
s:pattern [
name = "Element exclusion"
"\x{a}" ~
" "
s:rule [
context = "db:caption"
"\x{a}" ~
" "
s:assert [
test = "not(.//db:warning)"
"warning must not occur among the children or descendants of caption"
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:caption"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element caption {
db.caption.attlist, db.caption.info, db.all.blocks+
}
}
div {
db.address.role.attribute = attribute role { text }
db.address.attlist =
db.address.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.verbatim.attributes
db.address =
## A real-world address, generally a postal address
[
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:address"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element address {
db.address.attlist,
(db._text
| db.personname
| db.orgname
| db.pob
| db.street
| db.city
| db.state
| db.postcode
| db.country
| db.phone
| db.fax
| db.email
| db.uri
| db.otheraddr)*
}
}
div {
db.street.role.attribute = attribute role { text }
db.street.attlist =
db.street.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.street =
## A street address in an address
element street { db.street.attlist, db._text }
}
div {
db.pob.role.attribute = attribute role { text }
db.pob.attlist =
db.pob.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.pob =
## A post office box in an address
element pob { db.pob.attlist, db._text }
}
div {
db.postcode.role.attribute = attribute role { text }
db.postcode.attlist =
db.postcode.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.postcode =
## A postal code in an address
element postcode { db.postcode.attlist, db._text }
}
div {
db.city.role.attribute = attribute role { text }
db.city.attlist =
db.city.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.city =
## The name of a city in an address
element city { db.city.attlist, db._text }
}
div {
db.state.role.attribute = attribute role { text }
db.state.attlist =
db.state.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.state =
## A state or province in an address
element state { db.state.attlist, db._text }
}
div {
db.country.role.attribute = attribute role { text }
db.country.attlist =
db.country.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.country =
## The name of a country
element country { db.country.attlist, db._text }
}
div {
db.phone.role.attribute = attribute role { text }
db.phone.attlist =
db.phone.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.phone =
## A telephone number
element phone { db.phone.attlist, db._text }
}
div {
db.fax.role.attribute = attribute role { text }
db.fax.attlist =
db.fax.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.fax =
## A fax number
element fax { db.fax.attlist, db._text }
}
div {
db.otheraddr.role.attribute = attribute role { text }
db.otheraddr.attlist =
db.otheraddr.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.otheraddr =
## Uncategorized information in address
element otheraddr { db.otheraddr.attlist, db._text }
}
div {
db.affiliation.role.attribute = attribute role { text }
db.affiliation.attlist =
db.affiliation.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.affiliation =
## The institutional affiliation of an individual
element affiliation {
db.affiliation.attlist,
db.shortaffil?,
db.jobtitle*,
(db.org? | (db.orgname?, db.orgdiv*, db.address*))
}
}
div {
db.shortaffil.role.attribute = attribute role { text }
db.shortaffil.attlist =
db.shortaffil.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.shortaffil =
## A brief description of an affiliation
element shortaffil { db.shortaffil.attlist, db._text }
}
div {
db.jobtitle.role.attribute = attribute role { text }
db.jobtitle.attlist =
db.jobtitle.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.jobtitle =
## The title of an individual in an organization
element jobtitle { db.jobtitle.attlist, db._text }
}
div {
db.orgname.class.enumeration =
## A consortium
"consortium"
|
## A corporation
"corporation"
|
## An informal organization
"informal"
|
## A non-profit organization
"nonprofit"
db.orgname.class-enum.attribute =
## Specifies the nature of the organization
attribute class { db.orgname.class.enumeration }
db.orgname.class-other.attributes =
## Specifies the nature of the organization
attribute class {
## Indicates a non-standard organization class
"other"
},
## Identifies the non-standard nature of the organization
attribute otherclass { text }
db.orgname.class.attribute =
db.orgname.class-enum.attribute | db.orgname.class-other.attributes
db.orgname.role.attribute = attribute role { text }
db.orgname.attlist =
db.orgname.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.orgname.class.attribute?
db.orgname =
## The name of an organization
element orgname { db.orgname.attlist, db._text }
}
div {
db.orgdiv.role.attribute = attribute role { text }
db.orgdiv.attlist =
db.orgdiv.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.orgdiv =
## A division of an organization
element orgdiv { db.orgdiv.attlist, db.all.inlines* }
}
div {
db.artpagenums.role.attribute = attribute role { text }
db.artpagenums.attlist =
db.artpagenums.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.artpagenums =
## The page numbers of an article as published
element artpagenums { db.artpagenums.attlist, db._text }
}
div {
db.personname.role.attribute = attribute role { text }
db.personname.attlist =
db.personname.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.personname =
## The personal name of an individual
element personname {
db.personname.attlist,
(db._text
| (db.honorific
| db.firstname
| db.surname
| db.lineage
| db.othername)+
| (db.honorific
| db.givenname
| db.surname
| db.lineage
| db.othername)+)
}
}
db.person.author.contentmodel =
db.personname,
(db.personblurb
| db.affiliation
| db.email
| db.uri
| db.address
| db.contrib)*
db.org.author.contentmodel =
db.orgname,
(db.orgdiv
| db.affiliation
| db.email
| db.uri
| db.address
| db.contrib)*
db.credit.contentmodel =
db.person.author.contentmodel | db.org.author.contentmodel
div {
db.author.role.attribute = attribute role { text }
db.author.attlist =
db.author.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.author =
## The name of an individual author
element author { db.author.attlist, db.credit.contentmodel }
}
div {
db.authorgroup.role.attribute = attribute role { text }
db.authorgroup.attlist =
db.authorgroup.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.authorgroup =
## Wrapper for author information when a document has multiple authors or collaborators
element authorgroup {
db.authorgroup.attlist, (db.author | db.editor | db.othercredit)+
}
}
div {
db.collab.role.attribute = attribute role { text }
db.collab.attlist =
db.collab.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.collab =
## Identifies a collaborator
element collab {
db.collab.attlist,
(db.person | db.personname | db.org | db.orgname)+,
db.affiliation*
}
}
div {
db.authorinitials.role.attribute = attribute role { text }
db.authorinitials.attlist =
db.authorinitials.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.authorinitials =
## The initials or other short identifier for an author
element authorinitials { db.authorinitials.attlist, db._text }
}
div {
db.person.role.attribute = attribute role { text }
db.person.attlist =
db.person.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.person =
## A person and associated metadata
element person {
db.person.attlist,
db.personname,
(db.address
| db.affiliation
| db.email
| db.uri
| db.personblurb)*
}
}
div {
db.org.role.attribute = attribute role { text }
db.org.attlist =
db.org.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.org =
## An organization and associated metadata
element org {
db.org.attlist,
db.orgname,
(db.address | db.affiliation | db.email | db.uri | db.orgdiv)*
}
}
div {
db.confgroup.role.attribute = attribute role { text }
db.confgroup.attlist =
db.confgroup.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.confgroup =
## A wrapper for document meta-information about a conference
element confgroup {
db.confgroup.attlist,
(db.confdates
| db.conftitle
| db.confnum
| db.confsponsor
| db.address)*
}
}
div {
db.confdates.role.attribute = attribute role { text }
db.confdates.attlist =
db.confdates.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.confdates =
## The dates of a conference for which a document was written
element confdates { db.confdates.attlist, db._text }
}
div {
db.conftitle.role.attribute = attribute role { text }
db.conftitle.attlist =
db.conftitle.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.conftitle =
## The title of a conference for which a document was written
element conftitle { db.conftitle.attlist, db._text }
}
div {
db.confnum.role.attribute = attribute role { text }
db.confnum.attlist =
db.confnum.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.confnum =
## An identifier, frequently numerical, associated with a conference for which a document was written
element confnum { db.confnum.attlist, db._text }
}
div {
db.confsponsor.role.attribute = attribute role { text }
db.confsponsor.attlist =
db.confsponsor.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.confsponsor =
## The sponsor of a conference for which a document was written
element confsponsor { db.confsponsor.attlist, db._text }
}
div {
db.contractnum.role.attribute = attribute role { text }
db.contractnum.attlist =
db.contractnum.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.contractnum =
## The contract number of a document
element contractnum { db.contractnum.attlist, db._text }
}
div {
db.contractsponsor.role.attribute = attribute role { text }
db.contractsponsor.attlist =
db.contractsponsor.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.contractsponsor =
## The sponsor of a contract
element contractsponsor { db.contractsponsor.attlist, db._text }
}
div {
db.copyright.role.attribute = attribute role { text }
db.copyright.attlist =
db.copyright.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.copyright =
## Copyright information about a document
element copyright { db.copyright.attlist, db.year+, db.holder* }
}
div {
db.year.role.attribute = attribute role { text }
db.year.attlist =
db.year.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.year =
## The year of publication of a document
element year { db.year.attlist, db._text }
}
div {
db.holder.role.attribute = attribute role { text }
db.holder.attlist =
db.holder.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.holder =
## The name of the individual or organization that holds a copyright
element holder { db.holder.attlist, db._text }
}
db.cover.contentmodel =
(db.para.blocks
| db.extension.blocks
| db.list.blocks
| db.informal.blocks
| db.publishing.blocks
| db.graphic.blocks
| db.technical.blocks
| db.verbatim.blocks
| db.bridgehead
| db.remark
| db.revhistory)
| db.synopsis.blocks
div {
db.cover.role.attribute = attribute role { text }
db.cover.attlist =
db.cover.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.cover =
## Additional content for the cover of a publication
element cover { db.cover.attlist, db.cover.contentmodel+ }
}
db.date.contentmodel =
xsd:date | xsd:dateTime | xsd:gYearMonth | xsd:gYear | text
div {
db.date.role.attribute = attribute role { text }
db.date.attlist =
db.date.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.date =
## The date of publication or revision of a document
element date { db.date.attlist, db.date.contentmodel }
}
div {
db.edition.role.attribute = attribute role { text }
db.edition.attlist =
db.edition.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.edition =
## The name or number of an edition of a document
element edition { db.edition.attlist, db._text }
}
div {
db.editor.role.attribute = attribute role { text }
db.editor.attlist =
db.editor.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.editor =
## The name of the editor of a document
element editor { db.editor.attlist, db.credit.contentmodel }
}
div {
db.biblioid.role.attribute = attribute role { text }
db.biblioid.attlist =
db.biblioid.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.biblio.class.attribute
db.biblioid =
## An identifier for a document
element biblioid { db.biblioid.attlist, db._text }
}
div {
db.citebiblioid.role.attribute = attribute role { text }
db.citebiblioid.attlist =
db.citebiblioid.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.biblio.class.attribute
db.citebiblioid =
## A citation of a bibliographic identifier
element citebiblioid { db.citebiblioid.attlist, db._text }
}
div {
db.bibliosource.role.attribute = attribute role { text }
db.bibliosource.attlist =
db.bibliosource.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.biblio.class.attribute
db.bibliosource =
## The source of a document
element bibliosource { db.bibliosource.attlist, db._text }
}
div {
db.bibliorelation.type.enumeration =
## The described resource pre-existed the referenced resource, which is essentially the same intellectual content presented in another format
"hasformat"
|
## The described resource includes the referenced resource either physically or logically
"haspart"
|
## The described resource has a version, edition, or adaptation, namely, the referenced resource
"hasversion"
|
## The described resource is the same intellectual content of the referenced resource, but presented in another format
"isformatof"
|
## The described resource is a physical or logical part of the referenced resource
"ispartof"
|
## The described resource is referenced, cited, or otherwise pointed to by the referenced resource
"isreferencedby"
|
## The described resource is supplanted, displaced, or superceded by the referenced resource
"isreplacedby"
|
## The described resource is required by the referenced resource, either physically or logically
"isrequiredby"
|
## The described resource is a version, edition, or adaptation of the referenced resource; changes in version imply substantive changes in content rather than differences in format
"isversionof"
|
## The described resource references, cites, or otherwise points to the referenced resource
"references"
|
## The described resource supplants, displaces, or supersedes the referenced resource
"replaces"
|
## The described resource requires the referenced resource to support its function, delivery, or coherence of content
"requires"
db.bibliorelation.type-enum.attribute =
## Identifies the type of relationship
attribute type { db.bibliorelation.type.enumeration }?
db.bibliorelation.type-other.attributes =
## Identifies the type of relationship
attribute type {
## The described resource has a non-standard relationship with the referenced resource
"othertype"
}?,
## A keyword that identififes the type of the non-standard relationship
attribute othertype { xsd:NMTOKEN }
db.bibliorelation.type.attribute =
db.bibliorelation.type-enum.attribute
| db.bibliorelation.type-other.attributes
db.bibliorelation.role.attribute = attribute role { text }
db.bibliorelation.attlist =
db.bibliorelation.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.biblio.class.attribute
& db.bibliorelation.type.attribute
db.bibliorelation =
## The relationship of a document to another
element bibliorelation { db.bibliorelation.attlist, db._text }
}
div {
db.bibliocoverage.spacial.enumeration =
## The DCMI Point identifies a point in space using its geographic coordinates
"dcmipoint"
|
## ISO 3166 Codes for the representation of names of countries
"iso3166"
|
## The DCMI Box identifies a region of space using its geographic limits
"dcmibox"
|
## The Getty Thesaurus of Geographic Names
"tgn"
db.bibliocoverage.spatial-enum.attribute =
## Specifies the type of spatial coverage
attribute spatial { db.bibliocoverage.spacial.enumeration }?
db.bibliocoverage.spatial-other.attributes =
## Specifies the type of spatial coverage
attribute spatial {
## Identifies a non-standard type of coverage
"otherspatial"
}?,
## A keyword that identifies the type of non-standard coverage
attribute otherspatial { xsd:NMTOKEN }
db.bibliocoverage.spatial.attribute =
db.bibliocoverage.spatial-enum.attribute
| db.bibliocoverage.spatial-other.attributes
db.bibliocoverage.temporal.enumeration =
## A specification of the limits of a time interval
"dcmiperiod"
|
## W3C Encoding rules for dates and times—a profile based on ISO 8601
"w3c-dtf"
db.bibliocoverage.temporal-enum.attribute =
## Specifies the type of temporal coverage
attribute temporal { db.bibliocoverage.temporal.enumeration }?
db.bibliocoverage.temporal-other.attributes =
## Specifies the type of temporal coverage
attribute temporal {
## Specifies a non-standard type of coverage
"othertemporal"
}?,
## A keyword that identifies the type of non-standard coverage
attribute othertemporal { xsd:NMTOKEN }
db.bibliocoverage.temporal.attribute =
db.bibliocoverage.temporal-enum.attribute
| db.bibliocoverage.temporal-other.attributes
db.bibliocoverage.coverage.attrib =
db.bibliocoverage.spatial.attribute
& db.bibliocoverage.temporal.attribute
db.bibliocoverage.role.attribute = attribute role { text }
db.bibliocoverage.attlist =
db.bibliocoverage.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.bibliocoverage.coverage.attrib
db.bibliocoverage =
## The spatial or temporal coverage of a document
element bibliocoverage { db.bibliocoverage.attlist, db._text }
}
div {
db.legalnotice.role.attribute = attribute role { text }
db.legalnotice.attlist =
db.legalnotice.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.legalnotice.info = db._info.title.only
db.legalnotice =
## A statement of legal obligations or requirements
[
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:legalnotice"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element legalnotice {
db.legalnotice.attlist, db.legalnotice.info, db.all.blocks+
}
}
div {
db.othercredit.class.enumeration =
## A copy editor
"copyeditor"
|
## A graphic designer
"graphicdesigner"
|
## Some other contributor
"other"
|
## A production editor
"productioneditor"
|
## A technical editor
"technicaleditor"
|
## A translator
"translator"
|
## An indexer
"indexer"
|
## A proof-reader
"proofreader"
|
## A cover designer
"coverdesigner"
|
## An interior designer
"interiordesigner"
|
## An illustrator
"illustrator"
|
## A reviewer
"reviewer"
|
## A typesetter
"typesetter"
|
## A converter (a persons responsible for conversion, not an application)
"conversion"
db.othercredit.class-enum.attribute =
## Identifies the nature of the contributor
attribute class { db.othercredit.class.enumeration }?
db.othercredit.class-other.attribute =
## Identifies the nature of the non-standard contribution
attribute otherclass { xsd:NMTOKEN }
db.othercredit.class-other.attributes =
## Identifies the nature of the contributor
attribute class {
## Identifies a non-standard contribution
"other"
}
& db.othercredit.class-other.attribute
db.othercredit.class.attribute =
db.othercredit.class-enum.attribute
| db.othercredit.class-other.attributes
db.othercredit.role.attribute = attribute role { text }
db.othercredit.attlist =
db.othercredit.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.othercredit.class.attribute
db.othercredit =
## A person or entity, other than an author or editor, credited in a document
element othercredit {
db.othercredit.attlist, db.credit.contentmodel
}
}
div {
db.pagenums.role.attribute = attribute role { text }
db.pagenums.attlist =
db.pagenums.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.pagenums =
## The numbers of the pages in a book, for use in a bibliographic entry
element pagenums { db.pagenums.attlist, db._text }
}
div {
db.contrib.role.attribute = attribute role { text }
db.contrib.attlist =
db.contrib.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.contrib =
## A summary of the contributions made to a document by a credited source
element contrib { db.contrib.attlist, db.all.inlines* }
}
div {
db.honorific.role.attribute = attribute role { text }
db.honorific.attlist =
db.honorific.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.honorific =
## The title of a person
element honorific { db.honorific.attlist, db._text }
}
div {
db.firstname.role.attribute = attribute role { text }
db.firstname.attlist =
db.firstname.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.firstname =
## A given name of a person
element firstname { db.firstname.attlist, db._text }
}
div {
db.givenname.role.attribute = attribute role { text }
db.givenname.attlist =
db.givenname.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.givenname =
## The given name of a person
element givenname { db.givenname.attlist, db._text }
}
div {
db.surname.role.attribute = attribute role { text }
db.surname.attlist =
db.surname.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.surname =
## An inherited or family name; in western cultures the last name
element surname { db.surname.attlist, db._text }
}
div {
db.lineage.role.attribute = attribute role { text }
db.lineage.attlist =
db.lineage.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.lineage =
## The portion of a person's name indicating a relationship to ancestors
element lineage { db.lineage.attlist, db._text }
}
div {
db.othername.role.attribute = attribute role { text }
db.othername.attlist =
db.othername.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.othername =
## A component of a person's name that is not a first name, surname, or lineage
element othername { db.othername.attlist, db._text }
}
div {
db.printhistory.role.attribute = attribute role { text }
db.printhistory.attlist =
db.printhistory.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.printhistory =
## The printing history of a document
element printhistory { db.printhistory.attlist, db.para.blocks+ }
}
div {
db.pubdate.role.attribute = attribute role { text }
db.pubdate.attlist =
db.pubdate.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.pubdate =
## The date of publication of a document
element pubdate { db.pubdate.attlist, db.date.contentmodel }
}
div {
db.publisher.role.attribute = attribute role { text }
db.publisher.attlist =
db.publisher.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.publisher =
## The publisher of a document
element publisher {
db.publisher.attlist, db.publishername, db.address*
}
}
div {
db.publishername.role.attribute = attribute role { text }
db.publishername.attlist =
db.publishername.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.publishername =
## The name of the publisher of a document
element publishername { db.publishername.attlist, db._text }
}
div {
db.releaseinfo.role.attribute = attribute role { text }
db.releaseinfo.attlist =
db.releaseinfo.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.releaseinfo =
## Information about a particular release of a document
element releaseinfo { db.releaseinfo.attlist, db._text }
}
div {
db.revhistory.role.attribute = attribute role { text }
db.revhistory.attlist =
db.revhistory.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.revhistory.info = db._info.title.only
db.revhistory =
## A history of the revisions to a document
[
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:revhistory"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element revhistory {
db.revhistory.attlist, db.revhistory.info, db.revision+
}
}
div {
db.revision.role.attribute = attribute role { text }
db.revision.attlist =
db.revision.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.revision =
## An entry describing a single revision in the history of the revisions to a document
element revision {
db.revision.attlist,
db.revnumber?,
db.date,
(db.authorinitials | db.author)*,
(db.revremark | db.revdescription)?
}
}
div {
db.revnumber.role.attribute = attribute role { text }
db.revnumber.attlist =
db.revnumber.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.revnumber =
## A document revision number
element revnumber { db.revnumber.attlist, db._text }
}
div {
db.revremark.role.attribute = attribute role { text }
db.revremark.attlist =
db.revremark.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.revremark =
## A description of a revision to a document
element revremark { db.revremark.attlist, db._text }
}
div {
db.revdescription.role.attribute = attribute role { text }
db.revdescription.attlist =
db.revdescription.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.revdescription =
## A extended description of a revision to a document
element revdescription { db.revdescription.attlist, db.all.blocks* }
}
div {
db.seriesvolnums.role.attribute = attribute role { text }
db.seriesvolnums.attlist =
db.seriesvolnums.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.seriesvolnums =
## Numbers of the volumes in a series of books
element seriesvolnums { db.seriesvolnums.attlist, db._text }
}
div {
db.volumenum.role.attribute = attribute role { text }
db.volumenum.attlist =
db.volumenum.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.volumenum =
## The volume number of a document in a set (as of books in a set or articles in a journal)
element volumenum { db.volumenum.attlist, db._text }
}
div {
db.issuenum.role.attribute = attribute role { text }
db.issuenum.attlist =
db.issuenum.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.issuenum =
## The number of an issue of a journal
element issuenum { db.issuenum.attlist, db._text }
}
div {
db.package.role.attribute = attribute role { text }
db.package.attlist =
db.package.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.package =
## A software or application package
element package { db.package.attlist, db._text }
}
div {
db.email.role.attribute = attribute role { text }
db.email.attlist =
db.email.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.email =
## An email address
element email { db.email.attlist, db._text }
}
div {
db.lineannotation.role.attribute = attribute role { text }
db.lineannotation.attlist =
db.lineannotation.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.lineannotation =
## A comment on a line in a verbatim listing
element lineannotation { db.lineannotation.attlist, db._text }
}
div {
db.parameter.class.enumeration =
## A command
"command"
|
## A function
"function"
|
## An option
"option"
db.parameter.class.attribute =
## Identifies the class of parameter
attribute class { db.parameter.class.enumeration }
db.parameter.role.attribute = attribute role { text }
db.parameter.attlist =
db.parameter.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.parameter.class.attribute?
db.parameter =
## A value or a symbolic reference to a value
element parameter { db.parameter.attlist, db._text }
}
db.replaceable.inlines = db._text | db.co
div {
db.replaceable.class.enumeration =
## A command
"command"
|
## A function
"function"
|
## An option
"option"
|
## A parameter
"parameter"
db.replaceable.class.attribute =
## Identifies the nature of the replaceable text
attribute class { db.replaceable.class.enumeration }
db.replaceable.role.attribute = attribute role { text }
db.replaceable.attlist =
db.replaceable.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.replaceable.class.attribute?
db.replaceable =
## Content that may or must be replaced by the user
element replaceable {
db.replaceable.attlist, db.replaceable.inlines*
}
}
div {
db.uri.type.attribute =
## Identifies the type of URI specified
attribute type { text }?
db.uri.role.attribute = attribute role { text }
db.uri.attlist =
db.uri.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.uri.type.attribute
db.uri =
## A Uniform Resource Identifier
element uri { db.uri.attlist, db._text }
}
div {
db.abbrev.role.attribute = attribute role { text }
db.abbrev.attlist =
db.abbrev.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.abbrev =
## An abbreviation, especially one followed by a period
element abbrev {
db.abbrev.attlist,
(db._text | db.superscript | db.subscript | db.trademark)*
}
}
div {
db.acronym.role.attribute = attribute role { text }
db.acronym.attlist =
db.acronym.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.acronym =
## An often pronounceable word made from the initial (or selected) letters of a name or phrase
element acronym {
db.acronym.attlist,
(db._text | db.superscript | db.subscript | db.trademark)*
}
}
div {
db.citation.role.attribute = attribute role { text }
db.citation.attlist =
db.citation.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.citation =
## An inline bibliographic reference to another published work
element citation { db.citation.attlist, db.all.inlines* }
}
div {
db.citerefentry.role.attribute = attribute role { text }
db.citerefentry.attlist =
db.citerefentry.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.citerefentry =
## A citation to a reference page
element citerefentry {
db.citerefentry.attlist, db.refentrytitle, db.manvolnum?
}
}
div {
db.refentrytitle.role.attribute = attribute role { text }
db.refentrytitle.attlist =
db.refentrytitle.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.refentrytitle =
## The title of a reference page
element refentrytitle { db.refentrytitle.attlist, db.all.inlines* }
}
div {
db.manvolnum.role.attribute = attribute role { text }
db.manvolnum.attlist =
db.manvolnum.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.manvolnum =
## A reference volume number
element manvolnum { db.manvolnum.attlist, db._text }
}
div {
db.citetitle.pubwork.enumeration =
## An article
"article"
|
## A bulletin board system
"bbs"
|
## A book
"book"
|
## A CD-ROM
"cdrom"
|
## A chapter (as of a book)
"chapter"
|
## A DVD
"dvd"
|
## An email message
"emailmessage"
|
## A gopher page
"gopher"
|
## A journal
"journal"
|
## A manuscript
"manuscript"
|
## A posting to a newsgroup
"newsposting"
|
## A part (as of a book)
"part"
|
## A reference entry
"refentry"
|
## A section (as of a book or article)
"section"
|
## A series
"series"
|
## A set (as of books)
"set"
|
## A web page
"webpage"
|
## A wiki page
"wiki"
db.citetitle.pubwork.attribute =
## Identifies the nature of the publication being cited
attribute pubwork { db.citetitle.pubwork.enumeration }
db.citetitle.role.attribute = attribute role { text }
db.citetitle.attlist =
db.citetitle.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.citetitle.pubwork.attribute?
db.citetitle =
## The title of a cited work
element citetitle { db.citetitle.attlist, db.all.inlines* }
}
div {
db.emphasis.role.attribute = attribute role { text }
db.emphasis.attlist =
db.emphasis.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.emphasis =
## Emphasized text
element emphasis { db.emphasis.attlist, db.all.inlines* }
}
div {
db._emphasis =
## A limited span of emphasized text
element emphasis { db.emphasis.attlist, db._text }
}
div {
db.foreignphrase.role.attribute = attribute role { text }
db.foreignphrase.attlist =
db.foreignphrase.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.foreignphrase =
## A word or phrase in a language other than the primary language of the document
element foreignphrase {
db.foreignphrase.attlist, (text | db.general.inlines)*
}
}
div {
db._foreignphrase.role.attribute = attribute role { text }
db._foreignphrase.attlist =
db._foreignphrase.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db._foreignphrase =
## A limited word or phrase in a language other than the primary language of the document
element foreignphrase { db._foreignphrase.attlist, db._text }
}
div {
db.phrase.role.attribute = attribute role { text }
db.phrase.attlist =
db.phrase.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.phrase =
## A span of text
element phrase { db.phrase.attlist, db.all.inlines* }
}
div {
db._phrase =
## A limited span of text
element phrase { db.phrase.attlist, db._text }
}
div {
db.quote.role.attribute = attribute role { text }
db.quote.attlist =
db.quote.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.quote =
## An inline quotation
element quote { db.quote.attlist, db.all.inlines* }
}
div {
db._quote.role.attribute = attribute role { text }
db._quote.attlist =
db._quote.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db._quote =
## A limited inline quotation
element quote { db._quote.attlist, db._text }
}
div {
db.subscript.role.attribute = attribute role { text }
db.subscript.attlist =
db.subscript.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.subscript =
## A subscript (as in H2
## O, the molecular formula for water)
element subscript { db.subscript.attlist, db._text }
}
div {
db.superscript.role.attribute = attribute role { text }
db.superscript.attlist =
db.superscript.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.superscript =
## A superscript (as in x2
## , the mathematical notation for x multiplied by itself)
element superscript { db.superscript.attlist, db._text }
}
div {
db.trademark.class.enumeration =
## A copyright
"copyright"
|
## A registered copyright
"registered"
|
## A service
"service"
|
## A trademark
"trade"
db.trademark.class.attribute =
## Identifies the class of trade mark
attribute class { db.trademark.class.enumeration }
db.trademark.role.attribute = attribute role { text }
db.trademark.attlist =
db.trademark.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.trademark.class.attribute?
db.trademark =
## A trademark
element trademark { db.trademark.attlist, db._text }
}
div {
db.wordasword.role.attribute = attribute role { text }
db.wordasword.attlist =
db.wordasword.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.wordasword =
## A word meant specifically as a word and not representing anything else
element wordasword { db.wordasword.attlist, db._text }
}
div {
db.footnoteref.role.attribute = attribute role { text }
db.footnoteref.label.attribute = db.label.attribute
db.footnoteref.attlist =
db.footnoteref.role.attribute?
& db.common.attributes
& db.linkend.attribute
& db.footnoteref.label.attribute?
db.footnoteref =
## A cross reference to a footnote (a footnote mark)
[
s:pattern [
name = "Footnote reference type constraint"
"\x{a}" ~
" "
s:rule [
context = "db:footnoteref"
"\x{a}" ~
" "
s:assert [
test =
"local-name(//*[@xml:id=current()/@linkend]) = 'footnote' and namespace-uri(//*[@xml:id=current()/@linkend]) = 'http://docbook.org/ns/docbook'"
"@linkend on footnoteref must point to a footnote."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element footnoteref { db.footnoteref.attlist, empty }
}
div {
db.xref.role.attribute = attribute role { text }
db.xref.xrefstyle.attribute = db.xrefstyle.attribute
db.xref.endterm.attribute = db.endterm.attribute
db.xref.attlist =
db.xref.role.attribute?
& db.common.attributes
& db.common.req.linking.attributes
& db.xref.xrefstyle.attribute?
& db.xref.endterm.attribute?
db.xref =
## A cross reference to another part of the document
element xref { db.xref.attlist, empty }
}
div {
db.link.role.attribute = attribute role { text }
db.link.xrefstyle.attribute = db.xrefstyle.attribute
db.link.endterm.attribute = db.endterm.attribute
db.link.attlist =
db.link.role.attribute?
& db.common.attributes
& db.common.req.linking.attributes
& db.link.xrefstyle.attribute?
& db.link.endterm.attribute?
db.link =
## A hypertext link
element link { db.link.attlist, db.all.inlines* }
}
div {
db.olink.role.attribute = attribute role { text }
db.olink.xrefstyle.attribute = db.xrefstyle.attribute
db.olink.localinfo.attribute =
## Holds additional information that may be used by the application when resolving the link
attribute localinfo { text }
db.olink.targetdoc.attribute =
## Specifies the URI of the document in which the link target appears
attribute targetdoc { xsd:anyURI }
db.olink.targetptr.attribute =
## Specifies the location of the link target in the document
attribute targetptr { text }
db.olink.type.attribute =
## Identifies application-specific customization of the link behavior
attribute type { text }
db.olink.attlist =
db.common.attributes
& db.olink.targetdoc.attribute?
& db.olink.role.attribute?
& db.olink.xrefstyle.attribute?
& db.olink.localinfo.attribute?
& db.olink.targetptr.attribute?
& db.olink.type.attribute?
db.olink =
## A link that addresses its target indirectly
element olink { db.olink.attlist, db.all.inlines* }
}
div {
db.anchor.role.attribute = attribute role { text }
db.anchor.attlist =
db.anchor.role.attribute? & db.common.idreq.attributes
db.anchor =
## A spot in the document
element anchor { db.anchor.attlist, empty }
}
div {
db.alt.role.attribute = attribute role { text }
db.alt.attlist = db.alt.role.attribute? & db.common.attributes
db.alt =
## A text-only annotation, often used for accessibility
element alt { db.alt.attlist, (text | db.inlinemediaobject)* }
}
db.status.attribute =
## Identifies the editorial or publication status of the element on which it occurs
attribute status { text }
db.toplevel.sections =
((db.section+, db.simplesect*) | db.simplesect+)
| (db.sect1+, db.simplesect*)
| db.refentry+
db.toplevel.blocks.or.sections =
(db.all.blocks+, db.toplevel.sections?) | db.toplevel.sections
db.recursive.sections =
((db.section+, db.simplesect*) | db.simplesect+)
| db.refentry+
db.recursive.blocks.or.sections =
(db.all.blocks+, db.recursive.sections?) | db.recursive.sections
db.divisions = db.part | db.reference
db.components =
db.dedication
| db.acknowledgements
| db.preface
| db.chapter
| db.appendix
| db.article
| db.colophon
db.navigation.components =
notAllowed | db.glossary | db.bibliography | db.index | db.toc
db.component.contentmodel =
db.navigation.components*,
db.toplevel.blocks.or.sections,
db.navigation.components*
db.setindex.components = notAllowed | db.setindex
db.toc.components = notAllowed | db.toc
db.set.components = db.set | db.book
div {
db.set.status.attribute = db.status.attribute
db.set.role.attribute = attribute role { text }
db.set.attlist =
db.set.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.label.attribute?
& db.set.status.attribute?
db.set.info = db._info.title.req
db.set =
## A collection of books
[
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:set"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element set {
db.set.attlist,
db.set.info,
db.toc.components?,
db.set.components+,
db.setindex.components?
}
}
db.book.components =
(db.navigation.components | db.components | db.divisions)* | db.topic*
div {
db.book.status.attribute = db.status.attribute
db.book.role.attribute = attribute role { text }
db.book.attlist =
db.book.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.label.attribute?
& db.book.status.attribute?
db.book.info = db._info
db.book =
## A book
[
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:book"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element book { db.book.attlist, db.book.info, db.book.components }
}
div {
db.dedication.status.attribute = db.status.attribute
db.dedication.role.attribute = attribute role { text }
db.dedication.attlist =
db.dedication.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.label.attribute?
& db.dedication.status.attribute?
db.dedication.info = db._info
db.dedication =
## The dedication of a book or other component
[
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:dedication"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element dedication {
db.dedication.attlist, db.dedication.info, db.all.blocks+
}
}
div {
db.acknowledgements.status.attribute = db.status.attribute
db.acknowledgements.role.attribute = attribute role { text }
db.acknowledgements.attlist =
db.acknowledgements.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.label.attribute?
& db.acknowledgements.status.attribute?
db.acknowledgements.info = db._info
db.acknowledgements =
## Acknowledgements of a book or other component
[
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:acknowledgements"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element acknowledgements {
db.acknowledgements.attlist,
db.acknowledgements.info,
db.all.blocks+
}
}
div {
db.colophon.status.attribute = db.status.attribute
db.colophon.role.attribute = attribute role { text }
db.colophon.attlist =
db.colophon.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.label.attribute?
& db.colophon.status.attribute?
db.colophon.info = db._info
db.colophon =
## Text at the back of a book describing facts about its production
[
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:colophon"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element colophon {
db.colophon.attlist,
db.colophon.info,
((db.all.blocks+, db.simplesect*)
| (db.all.blocks*, db.simplesect+))
}
}
db.appendix.contentmodel = db.component.contentmodel | db.topic+
div {
db.appendix.status.attribute = db.status.attribute
db.appendix.role.attribute = attribute role { text }
db.appendix.attlist =
db.appendix.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.label.attribute?
& db.appendix.status.attribute?
db.appendix.info = db._info.title.req
db.appendix =
## An appendix in a book or article
[
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:appendix"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element appendix {
db.appendix.attlist, db.appendix.info, db.appendix.contentmodel?
}
}
db.chapter.contentmodel = db.component.contentmodel | db.topic+
div {
db.chapter.status.attribute = db.status.attribute
db.chapter.role.attribute = attribute role { text }
db.chapter.attlist =
db.chapter.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.label.attribute?
& db.chapter.status.attribute?
db.chapter.info = db._info.title.req
db.chapter =
## A chapter, as of a book
[
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:chapter"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element chapter {
db.chapter.attlist, db.chapter.info, db.chapter.contentmodel?
}
}
db.part.components =
(db.navigation.components | db.components)
| (db.refentry | db.reference)
db.part.contentmodel = db.part.components+ | db.topic+
div {
db.part.status.attribute = db.status.attribute
db.part.role.attribute = attribute role { text }
db.part.attlist =
db.part.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.label.attribute?
& db.part.status.attribute?
db.part.info = db._info.title.req
db.part =
## A division in a book
[
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:part"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element part {
db.part.attlist,
db.part.info,
db.partintro?,
db.part.contentmodel?
}
}
div {
db.preface.status.attribute = db.status.attribute
db.preface.role.attribute = attribute role { text }
db.preface.attlist =
db.preface.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.label.attribute?
& db.preface.status.attribute?
db.preface.info = db._info.title.req
db.preface =
## Introductory matter preceding the first chapter of a book
[
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:preface"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element preface {
db.preface.attlist, db.preface.info, db.component.contentmodel?
}
}
div {
db.partintro.status.attribute = db.status.attribute
db.partintro.role.attribute = attribute role { text }
db.partintro.attlist =
db.partintro.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.label.attribute?
& db.partintro.status.attribute?
db.partintro.info = db._info
db.partintro =
## An introduction to the contents of a part
[
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:partintro"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element partintro {
db.partintro.attlist,
db.partintro.info,
db.toplevel.blocks.or.sections?
}
}
div {
db.section.status.attribute = db.status.attribute
db.section.role.attribute = attribute role { text }
db.section.attlist =
db.section.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.label.attribute?
& db.section.status.attribute?
db.section.info = db._info.title.req
db.section =
## A recursive section
[
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:section"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element section {
db.section.attlist,
db.section.info,
db.recursive.blocks.or.sections?,
db.navigation.components*
}
}
div {
db.simplesect.status.attribute = db.status.attribute
db.simplesect.role.attribute = attribute role { text }
db.simplesect.attlist =
db.simplesect.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.label.attribute?
& db.simplesect.status.attribute?
db.simplesect.info = db._info.title.req
db.simplesect =
## A section of a document with no subdivisions
[
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:simplesect"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element simplesect {
db.simplesect.attlist, db.simplesect.info, db.all.blocks*
}
}
db.article.components = db.toplevel.sections
db.article.navcomponents =
db.navigation.components
| db.acknowledgements
| db.dedication
| db.appendix
| db.colophon
div {
db.article.status.attribute = db.status.attribute
db.article.class.enumeration =
## A collection of frequently asked questions.
"faq"
|
## An article in a journal or other periodical.
"journalarticle"
|
## A description of a product.
"productsheet"
|
## A specification.
"specification"
|
## A technical report.
"techreport"
|
## A white paper.
"whitepaper"
db.article.class.attribute =
## Identifies the nature of the article
attribute class { db.article.class.enumeration }
db.article.role.attribute = attribute role { text }
db.article.attlist =
db.article.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.label.attribute?
& db.article.status.attribute?
& db.article.class.attribute?
db.article.info = db._info.title.req
db.article =
## An article
[
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:article"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element article {
db.article.attlist,
db.article.info,
db.article.navcomponents*,
((db.all.blocks+, db.article.components?)
| db.article.components),
db.article.navcomponents*
}
}
db.annotations.attribute =
## Identifies one or more annotations that apply to this element
attribute annotations { text }
div {
db.annotation.role.attribute = attribute role { text }
db.annotation.annotates.attribute =
## Identifies one ore more elements to which this annotation applies
attribute annotates { text }
db.annotation.attlist =
db.annotation.role.attribute?
& db.annotation.annotates.attribute?
& db.common.attributes
db.annotation.info = db._info.title.only
db.annotation =
## An annotation
[
s:pattern [
name = "Element exclusion"
"\x{a}" ~
" "
s:rule [
context = "db:annotation"
"\x{a}" ~
" "
s:assert [
test = "not(.//db:annotation)"
"annotation must not occur among the children or descendants of annotation"
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:annotation"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element annotation {
db.annotation.attlist, db.annotation.info, db.all.blocks+
}
}
db.xlink.extended.type.attribute =
## Identifies the XLink extended link type
[
s:pattern [
name = "XLink extended placement"
"\x{a}" ~
" "
s:rule [
context = "*[@xlink:type='extended']"
"\x{a}" ~
" "
s:assert [
test = "not(parent::*[@xlink:type='extended'])"
"An XLink extended type element may not occur as the direct child of an XLink extended type element."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
attribute xlink:type {
## An XLink extended link type
"extended"
}
db.xlink.locator.type.attribute =
## Identifies the XLink locator link type
[
s:pattern [
name = "XLink locator placement"
"\x{a}" ~
" "
s:rule [
context = "*[@xlink:type='locator']"
"\x{a}" ~
" "
s:assert [
test = "not(parent::*[@xlink:type='extended'])"
"An XLink locator type element must occur as the direct child of an XLink extended type element."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
attribute xlink:type {
## An XLink locator link type
"locator"
}
db.xlink.arc.type.attribute =
## Identifies the XLink arc link type
[
s:pattern [
name = "XLink arc placement"
"\x{a}" ~
" "
s:rule [
context = "*[@xlink:type='arc']"
"\x{a}" ~
" "
s:assert [
test = "parent::*[@xlink:type='extended']"
"An XLink arc type element must occur as the direct child of an XLink extended type element."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
attribute xlink:type {
## An XLink arc link type
"arc"
}
db.xlink.resource.type.attribute =
## Identifies the XLink resource link type
[
s:pattern [
name = "XLink resource placement"
"\x{a}" ~
" "
s:rule [
context = "*[@xlink:type='resource']"
"\x{a}" ~
" "
s:assert [
test = "not(parent::*[@xlink:type='extended'])"
"An XLink resource type element must occur as the direct child of an XLink extended type element."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
attribute xlink:type {
## An XLink resource link type
"resource"
}
db.xlink.title.type.attribute =
## Identifies the XLink title link type
[
s:pattern [
name = "XLink title placement"
"\x{a}" ~
" "
s:rule [
context = "*[@xlink:type='title']"
"\x{a}" ~
" "
s:assert [
test =
"not(parent::*[@xlink:type='extended']) and not(parent::*[@xlink:type='locator']) and not(parent::*[@xlink:type='arc'])"
"An XLink title type element must occur as the direct child of an XLink extended, locator, or arc type element."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
attribute xlink:type {
## An XLink title link type
"title"
}
db.xlink.extended.link.attributes =
db.xlink.extended.type.attribute
& db.xlink.role.attribute?
& db.xlink.title.attribute?
db.xlink.locator.link.attributes =
db.xlink.locator.type.attribute
& db.xlink.href.attribute
& db.xlink.role.attribute?
& db.xlink.title.attribute?
& db.xlink.label.attribute?
db.xlink.arc.link.attributes =
db.xlink.arc.type.attribute
& db.xlink.arcrole.attribute?
& db.xlink.title.attribute?
& db.xlink.show.attribute?
& db.xlink.actuate.attribute?
& db.xlink.from.attribute?
& db.xlink.to.attribute?
db.xlink.resource.link.attributes =
db.xlink.resource.type.attribute
& db.xlink.role.attribute?
& db.xlink.title.attribute?
& db.xlink.label.attribute?
db.xlink.title.link.attributes = db.xlink.title.type.attribute
db.xlink.from.attribute =
## Specifies the XLink traversal-from
attribute xlink:from { xsd:NMTOKEN }
db.xlink.label.attribute =
## Specifies the XLink label
attribute xlink:label { xsd:NMTOKEN }
db.xlink.to.attribute =
## Specifies the XLink traversal-to
attribute xlink:to { xsd:NMTOKEN }
div {
db.extendedlink.role.attribute = attribute role { text }
db.extendedlink.attlist =
db.extendedlink.role.attribute?
& db.common.attributes
&
## Identifies the XLink link type
[ a:defaultValue = "extended" ]
attribute xlink:type {
## An XLink extended link
"extended"
}?
& db.xlink.role.attribute?
& db.xlink.title.attribute?
db.extendedlink =
## An XLink extended link
element extendedlink {
db.extendedlink.attlist, (db.locator | db.arc | db.link)+
}
}
div {
db.locator.role.attribute = attribute role { text }
db.locator.attlist =
db.locator.role.attribute?
& db.common.attributes
&
## Identifies the XLink link type
[ a:defaultValue = "locator" ]
attribute xlink:type {
## An XLink locator link
"locator"
}?
& db.xlink.href.attribute
& db.xlink.role.attribute?
& db.xlink.title.attribute?
& db.xlink.label.attribute?
db.locator =
## An XLink locator in an extendedlink
element locator { db.locator.attlist, empty }
}
div {
db.arc.role.attribute = attribute role { text }
db.arc.attlist =
db.arc.role.attribute?
& db.common.attributes
&
## Identifies the XLink link type
[ a:defaultValue = "arc" ]
attribute xlink:type {
## An XLink arc link
"arc"
}?
& db.xlink.arcrole.attribute?
& db.xlink.title.attribute?
& db.xlink.show.attribute?
& db.xlink.actuate.attribute?
& db.xlink.from.attribute?
& db.xlink.to.attribute?
db.arc =
## An XLink arc in an extendedlink
element arc { db.arc.attlist, empty }
}
db.sect1.sections = (db.sect2+, db.simplesect*) | db.simplesect+
div {
db.sect1.status.attribute = db.status.attribute
db.sect1.role.attribute = attribute role { text }
db.sect1.attlist =
db.sect1.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.label.attribute?
& db.sect1.status.attribute?
db.sect1.info = db._info.title.req
db.sect1 =
## A top-level section of document
[
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:sect1"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element sect1 {
db.sect1.attlist,
db.sect1.info,
((db.all.blocks+, db.sect1.sections?) | db.sect1.sections)?,
db.navigation.components*
}
}
db.sect2.sections = (db.sect3+, db.simplesect*) | db.simplesect+
div {
db.sect2.status.attribute = db.status.attribute
db.sect2.role.attribute = attribute role { text }
db.sect2.attlist =
db.sect2.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.label.attribute?
& db.sect2.status.attribute?
db.sect2.info = db._info.title.req
db.sect2 =
## A subsection within a sect1
[
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:sect2"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element sect2 {
db.sect2.attlist,
db.sect2.info,
((db.all.blocks+, db.sect2.sections?) | db.sect2.sections)?,
db.navigation.components*
}
}
db.sect3.sections = (db.sect4+, db.simplesect*) | db.simplesect+
div {
db.sect3.status.attribute = db.status.attribute
db.sect3.role.attribute = attribute role { text }
db.sect3.attlist =
db.sect3.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.label.attribute?
& db.sect3.status.attribute?
db.sect3.info = db._info.title.req
db.sect3 =
## A subsection within a sect2
[
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:sect3"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element sect3 {
db.sect3.attlist,
db.sect3.info,
((db.all.blocks+, db.sect3.sections?) | db.sect3.sections)?,
db.navigation.components*
}
}
db.sect4.sections = (db.sect5+, db.simplesect*) | db.simplesect+
div {
db.sect4.status.attribute = db.status.attribute
db.sect4.role.attribute = attribute role { text }
db.sect4.attlist =
db.sect4.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.label.attribute?
& db.sect4.status.attribute?
db.sect4.info = db._info.title.req
db.sect4 =
## A subsection within a sect3
[
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:sect4"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element sect4 {
db.sect4.attlist,
db.sect4.info,
((db.all.blocks+, db.sect4.sections?) | db.sect4.sections)?,
db.navigation.components*
}
}
db.sect5.sections = db.simplesect+
div {
db.sect5.status.attribute = db.status.attribute
db.sect5.role.attribute = attribute role { text }
db.sect5.attlist =
db.sect5.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.label.attribute?
& db.sect5.status.attribute?
db.sect5.info = db._info.title.req
db.sect5 =
## A subsection within a sect4
[
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:sect5"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element sect5 {
db.sect5.attlist,
db.sect5.info,
((db.all.blocks+, db.sect5.sections?) | db.sect5.sections)?,
db.navigation.components*
}
}
db.toplevel.refsection = db.refsection+ | db.refsect1+
db.secondlevel.refsection = db.refsection+ | db.refsect2+
db.reference.components = db.refentry
div {
db.reference.status.attribute = db.status.attribute
db.reference.role.attribute = attribute role { text }
db.reference.attlist =
db.reference.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.reference.status.attribute?
& db.label.attribute?
db.reference.info = db._info.title.req
db.reference =
## A collection of reference entries
[
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:reference"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element reference {
db.reference.attlist,
db.reference.info,
db.partintro?,
db.reference.components*
}
}
div {
db.refentry.status.attribute = db.status.attribute
db.refentry.role.attribute = attribute role { text }
db.refentry.attlist =
db.refentry.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.refentry.status.attribute?
& db.label.attribute?
db.refentry.info = db._info.title.forbidden
db.refentry =
## A reference page (originally a UNIX man-style reference page)
[
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:refentry"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element refentry {
db.refentry.attlist,
db.indexterm*,
db.refentry.info,
db.refmeta?,
db.refnamediv+,
db.refsynopsisdiv?,
db.toplevel.refsection
}
}
div {
db.refmeta.role.attribute = attribute role { text }
db.refmeta.attlist =
db.refmeta.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.refmeta =
## Meta-information for a reference entry
element refmeta {
db.refmeta.attlist,
db.indexterm*,
db.refentrytitle,
db.manvolnum?,
db.refmiscinfo*,
db.indexterm*
}
}
db.refmiscinfo.class.enumeration =
## The name of the software product or component to which this topic applies
"source"
|
## The version of the software product or component to which this topic applies
"version"
|
## The section title of the reference page (e.g., User Commands)
"manual"
|
## The section title of the reference page (believed synonymous with "manual" but in wide use)
"sectdesc"
|
## The name of the software product or component to which this topic applies (e.g., SunOS x.y; believed synonymous with "source" but in wide use)
"software"
db.refmiscinfo.class-enum.attribute =
## Identifies the kind of miscellaneous information
attribute class { db.refmiscinfo.class.enumeration }?
db.refmiscinfo.class-other.attribute =
## Identifies the nature of non-standard miscellaneous information
attribute otherclass { text }
db.refmiscinfo.class-other.attributes =
## Identifies the kind of miscellaneious information
attribute class {
## Indicates that the information is some 'other' kind.
"other"
}
& db.refmiscinfo.class-other.attribute
db.refmiscinfo.class.attribute =
db.refmiscinfo.class-enum.attribute
| db.refmiscinfo.class-other.attributes
div {
db.refmiscinfo.role.attribute = attribute role { text }
db.refmiscinfo.attlist =
db.refmiscinfo.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.refmiscinfo.class.attribute?
db.refmiscinfo =
## Meta-information for a reference entry other than the title and volume number
element refmiscinfo { db.refmiscinfo.attlist, db._text }
}
div {
db.refnamediv.role.attribute = attribute role { text }
db.refnamediv.attlist =
db.refnamediv.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.refnamediv =
## The name, purpose, and classification of a reference page
element refnamediv {
db.refnamediv.attlist,
db.refdescriptor?,
db.refname+,
db.refpurpose,
db.refclass*
}
}
div {
db.refdescriptor.role.attribute = attribute role { text }
db.refdescriptor.attlist =
db.refdescriptor.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.refdescriptor =
## A description of the topic of a reference page
element refdescriptor { db.refdescriptor.attlist, db.all.inlines* }
}
div {
db.refname.role.attribute = attribute role { text }
db.refname.attlist =
db.refname.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.refname =
## The name of (one of) the subject(s) of a reference page
element refname { db.refname.attlist, db.all.inlines* }
}
div {
db.refpurpose.role.attribute = attribute role { text }
db.refpurpose.attlist =
db.refpurpose.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.refpurpose =
## A short (one sentence) synopsis of the topic of a reference page
element refpurpose { db.refpurpose.attlist, db.all.inlines* }
}
div {
db.refclass.role.attribute = attribute role { text }
db.refclass.attlist =
db.refclass.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.refclass =
## The scope or other indication of applicability of a reference entry
element refclass { db.refclass.attlist, (text | db.application)* }
}
div {
db.refsynopsisdiv.role.attribute = attribute role { text }
db.refsynopsisdiv.attlist =
db.refsynopsisdiv.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.refsynopsisdiv.info = db._info
db.refsynopsisdiv =
## A syntactic synopsis of the subject of the reference page
[
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:refsynopsisdiv"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element refsynopsisdiv {
db.refsynopsisdiv.attlist,
db.refsynopsisdiv.info,
((db.all.blocks+, db.secondlevel.refsection?)
| db.secondlevel.refsection)
}
}
div {
db.refsection.status.attribute = db.status.attribute
db.refsection.role.attribute = attribute role { text }
db.refsection.attlist =
db.refsection.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.refsection.status.attribute?
& db.label.attribute?
db.refsection.info = db._info.title.req
db.refsection =
## A recursive section in a refentry
[
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:refsection"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element refsection {
db.refsection.attlist,
db.refsection.info,
((db.all.blocks+, db.refsection*) | db.refsection+)
}
}
db.refsect1.sections = db.refsect2+
div {
db.refsect1.status.attribute = db.status.attribute
db.refsect1.role.attribute = attribute role { text }
db.refsect1.attlist =
db.refsect1.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.label.attribute?
& db.refsect1.status.attribute?
db.refsect1.info = db._info.title.req
db.refsect1 =
## A major subsection of a reference entry
[
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:refsect1"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element refsect1 {
db.refsect1.attlist,
db.refsect1.info,
((db.all.blocks+, db.refsect1.sections?) | db.refsect1.sections)
}
}
db.refsect2.sections = db.refsect3+
div {
db.refsect2.status.attribute = db.status.attribute
db.refsect2.role.attribute = attribute role { text }
db.refsect2.attlist =
db.refsect2.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.label.attribute?
& db.refsect2.status.attribute?
db.refsect2.info = db._info.title.req
db.refsect2 =
## A subsection of a refsect1
[
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:refsect2"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element refsect2 {
db.refsect2.attlist,
db.refsect2.info,
((db.all.blocks+, db.refsect2.sections?) | db.refsect2.sections)
}
}
div {
db.refsect3.status.attribute = db.status.attribute
db.refsect3.role.attribute = attribute role { text }
db.refsect3.attlist =
db.refsect3.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.label.attribute?
& db.refsect3.status.attribute?
db.refsect3.info = db._info.title.req
db.refsect3 =
## A subsection of a refsect2
[
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:refsect3"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element refsect3 {
db.refsect3.attlist, db.refsect3.info, db.all.blocks+
}
}
db.glossary.inlines =
db.firstterm | db.glossterm | db._firstterm | db._glossterm
db.baseform.attribute =
## Specifies the base form of the term, the one that appears in the glossary. This allows adjectival, plural, and other variations of the term to appear in the element. The element content is the default base form.
attribute baseform { text }?
div {
db.glosslist.role.attribute = attribute role { text }
db.glosslist.attlist =
db.glosslist.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.glosslist.info = db._info.title.only
db.glosslist =
## A wrapper for a list of glossary entries
[
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:glosslist"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element glosslist {
db.glosslist.attlist,
db.glosslist.info?,
db.all.blocks*,
db.glossentry+
}
}
div {
db.glossentry.role.attribute = attribute role { text }
db.glossentry.sortas.attribute =
## Specifies the string by which the element's content is to be sorted; if unspecified, the content is used
attribute sortas { text }
db.glossentry.attlist =
db.glossentry.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.glossentry.sortas.attribute?
db.glossentry =
## An entry in a glossary or glosslist
element glossentry {
db.glossentry.attlist,
db.glossterm,
db.acronym?,
db.abbrev?,
db.indexterm*,
(db.glosssee | db.glossdef+)
}
}
div {
db.glossdef.role.attribute = attribute role { text }
db.glossdef.subject.attribute =
## Specifies a list of keywords for the definition
attribute subject { text }
db.glossdef.attlist =
db.glossdef.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.glossdef.subject.attribute?
db.glossdef =
## A definition in a glossentry
element glossdef {
db.glossdef.attlist, db.all.blocks+, db.glossseealso*
}
}
div {
db.glosssee.role.attribute = attribute role { text }
db.glosssee.otherterm.attribute =
## Identifies the other term
attribute otherterm { xsd:IDREF }
db.glosssee.attlist =
db.glosssee.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.glosssee.otherterm.attribute?
db.glosssee =
## A cross-reference from one glossentry
## to another
[
s:pattern [
name = "Glosssary 'see' type constraint"
"\x{a}" ~
" "
s:rule [
context = "db:glosssee[@otherterm]"
"\x{a}" ~
" "
s:assert [
test =
"local-name(//*[@xml:id=current()/@otherterm]) = 'glossentry' and namespace-uri(//*[@xml:id=current()/@otherterm]) = 'http://docbook.org/ns/docbook'"
"@otherterm on glosssee must point to a glossentry."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element glosssee { db.glosssee.attlist, db.all.inlines* }
}
div {
db.glossseealso.role.attribute = attribute role { text }
db.glossseealso.otherterm.attribute =
## Identifies the other term
attribute otherterm { xsd:IDREF }
db.glossseealso.attlist =
db.glossseealso.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.glossseealso.otherterm.attribute?
db.glossseealso =
## A cross-reference from one glossentry to another
[
s:pattern [
name = "Glossary 'seealso' type constraint"
"\x{a}" ~
" "
s:rule [
context = "db:glossseealso[@otherterm]"
"\x{a}" ~
" "
s:assert [
test =
"local-name(//*[@xml:id=current()/@otherterm]) = 'glossentry' and namespace-uri(//*[@xml:id=current()/@otherterm]) = 'http://docbook.org/ns/docbook'"
"@otherterm on glossseealso must point to a glossentry."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element glossseealso { db.glossseealso.attlist, db.all.inlines* }
}
div {
db.firstterm.role.attribute = attribute role { text }
db.firstterm.attlist =
db.firstterm.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.baseform.attribute
db.firstterm =
## The first occurrence of a term
[
s:pattern [
name = "Glossary 'firstterm' type constraint"
"\x{a}" ~
" "
s:rule [
context = "db:firstterm[@linkend]"
"\x{a}" ~
" "
s:assert [
test =
"local-name(//*[@xml:id=current()/@linkend]) = 'glossentry' and namespace-uri(//*[@xml:id=current()/@linkend]) = 'http://docbook.org/ns/docbook'"
"@linkend on firstterm must point to a glossentry."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element firstterm { db.firstterm.attlist, db.all.inlines* }
}
div {
db._firstterm.role.attribute = attribute role { text }
db._firstterm.attlist =
db._firstterm.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.baseform.attribute
db._firstterm =
## The first occurrence of a term, with limited content
[
s:pattern [
name = "Glossary 'firstterm' type constraint"
"\x{a}" ~
" "
s:rule [
context = "db:firstterm[@linkend]"
"\x{a}" ~
" "
s:assert [
test =
"local-name(//*[@xml:id=current()/@linkend]) = 'glossentry' and namespace-uri(//*[@xml:id=current()/@linkend]) = 'http://docbook.org/ns/docbook'"
"@linkend on firstterm must point to a glossentry."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element firstterm { db._firstterm.attlist, db._text }
}
div {
db.glossterm.role.attribute = attribute role { text }
db.glossterm.attlist =
db.glossterm.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.baseform.attribute
db.glossterm =
## A glossary term
[
s:pattern [
name = "Glossary 'glossterm' type constraint"
"\x{a}" ~
" "
s:rule [
context = "db:glossterm[@linkend]"
"\x{a}" ~
" "
s:assert [
test =
"local-name(//*[@xml:id=current()/@linkend]) = 'glossentry' and namespace-uri(//*[@xml:id=current()/@linkend]) = 'http://docbook.org/ns/docbook'"
"@linkend on glossterm must point to a glossentry."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element glossterm { db.glossterm.attlist, db.all.inlines* }
}
div {
db._glossterm.role.attribute = attribute role { text }
db._glossterm.attlist =
db._glossterm.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.baseform.attribute
db._glossterm =
## A glossary term
[
s:pattern [
name = "Glossary 'glossterm' type constraint"
"\x{a}" ~
" "
s:rule [
context = "db:glossterm[@linkend]"
"\x{a}" ~
" "
s:assert [
test =
"local-name(//*[@xml:id=current()/@linkend]) = 'glossentry' and namespace-uri(//*[@xml:id=current()/@linkend]) = 'http://docbook.org/ns/docbook'"
"@linkend on glossterm must point to a glossentry."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element glossterm { db._glossterm.attlist, db._text }
}
div {
db.glossary.status.attribute = db.status.attribute
db.glossary.role.attribute = attribute role { text }
db.glossary.attlist =
db.glossary.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.label.attribute?
& db.glossary.status.attribute?
db.glossary.info = db._info
db.glossary =
## A glossary
[
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:glossary"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element glossary {
db.glossary.attlist,
db.glossary.info,
db.all.blocks*,
(db.glossdiv* | db.glossentry*),
db.bibliography?
}
}
div {
db.glossdiv.status.attribute = db.status.attribute
db.glossdiv.role.attribute = attribute role { text }
db.glossdiv.attlist =
db.glossdiv.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.label.attribute?
& db.glossdiv.status.attribute?
db.glossdiv.info = db._info.title.req
db.glossdiv =
## A division in a glossary
[
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:glossdiv"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element glossdiv {
db.glossdiv.attlist,
db.glossdiv.info,
db.all.blocks*,
db.glossentry+
}
}
div {
db.termdef.role.attribute = attribute role { text }
db.termdef.attlist =
db.termdef.role.attribute?
& db.glossentry.sortas.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.baseform.attribute
db.termdef =
## An inline definition of a term
[
s:pattern [
name = "Glossary term definition constraint"
"\x{a}" ~
" "
s:rule [
context = "db:termdef"
"\x{a}" ~
" "
s:assert [
test = "count(db:firstterm) = 1"
"A termdef must contain exactly one firstterm"
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element termdef { db.termdef.attlist, db.all.inlines* }
}
db.relation.attribute =
## Identifies the relationship between the bibliographic elemnts
attribute relation { text }
div {
db.biblioentry.role.attribute = attribute role { text }
db.biblioentry.attlist =
db.biblioentry.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.biblioentry =
## A raw entry in a bibliography
element biblioentry {
db.biblioentry.attlist, db.bibliographic.elements+
}
}
div {
db.bibliomixed.role.attribute = attribute role { text }
db.bibliomixed.attlist =
db.bibliomixed.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.bibliomixed =
## A cooked entry in a bibliography
element bibliomixed {
db.bibliomixed.attlist,
((db._text
| db.honorific
| db.firstname
| db.surname
| db.lineage
| db.othername
| db.bibliographic.elements)*
| (db._text
| db.honorific
| db.givenname
| db.surname
| db.lineage
| db.othername
| db.bibliographic.elements)*)
}
}
div {
db.biblioset.relation.attribute = db.relation.attribute
db.biblioset.role.attribute = attribute role { text }
db.biblioset.attlist =
db.biblioset.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.biblioset.relation.attribute?
db.biblioset =
## A raw container for related bibliographic information
element biblioset {
db.biblioset.attlist, db.bibliographic.elements+
}
}
div {
db.bibliomset.relation.attribute = db.relation.attribute
db.bibliomset.role.attribute = attribute role { text }
db.bibliomset.attlist =
db.bibliomset.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.bibliomset.relation.attribute?
db.bibliomset =
## A cooked container for related bibliographic information
element bibliomset {
db.bibliomset.attlist,
((db._text
| db.honorific
| db.firstname
| db.surname
| db.lineage
| db.othername
| db.bibliographic.elements)*
| (db._text
| db.honorific
| db.givenname
| db.surname
| db.lineage
| db.othername
| db.bibliographic.elements)*)
}
}
div {
db.bibliomisc.role.attribute = attribute role { text }
db.bibliomisc.attlist =
db.bibliomisc.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.bibliomisc =
## Untyped bibliographic information
element bibliomisc { db.bibliomisc.attlist, db._text }
}
div {
db.bibliography.status.attrib = db.status.attribute
db.bibliography.role.attribute = attribute role { text }
db.bibliography.attlist =
db.bibliography.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.label.attribute?
& db.bibliography.status.attrib?
db.bibliography.info = db._info
db.bibliography =
## A bibliography
[
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:bibliography"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element bibliography {
db.bibliography.attlist,
db.bibliography.info,
db.all.blocks*,
(db.bibliodiv+ | (db.biblioentry | db.bibliomixed)+)
}
}
div {
db.bibliodiv.status.attrib = db.status.attribute
db.bibliodiv.role.attribute = attribute role { text }
db.bibliodiv.attlist =
db.bibliodiv.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.label.attribute?
& db.bibliodiv.status.attrib?
db.bibliodiv.info = db._info.title.req
db.bibliodiv =
## A section of a bibliography
[
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:bibliodiv"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element bibliodiv {
db.bibliodiv.attlist,
db.bibliodiv.info,
db.all.blocks*,
(db.biblioentry | db.bibliomixed)+
}
}
div {
db.bibliolist.role.attribute = attribute role { text }
db.bibliolist.attlist =
db.bibliolist.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.bibliolist.info = db._info.title.only
db.bibliolist =
## A wrapper for a list of bibliography entries
[
s:pattern [
name = "Root must have version"
"\x{a}" ~
" "
s:rule [
context = "/db:bibliolist"
"\x{a}" ~
" "
s:assert [
test = "@version"
"If this element is the root element, it must have a version attribute."
]
"\x{a}" ~
" "
]
"\x{a}" ~
" "
]
]
element bibliolist {
db.bibliolist.attlist,
db.bibliolist.info?,
db.all.blocks*,
(db.biblioentry | db.bibliomixed)+
}
}
div {
db.biblioref.role.attribute = attribute role { text }
db.biblioref.xrefstyle.attribute = db.xrefstyle.attribute
db.biblioref.endterm.attribute = db.endterm.attribute
db.biblioref.units.attribute =
## The units (for example, pages) used to identify the beginning and ending of a reference.
attribute units { xsd:token }
db.biblioref.begin.attribute =
## Identifies the beginning of a reference; the location within the work that is being referenced.
attribute begin { xsd:token }
db.biblioref.end.attribute =
## Identifies the end of a reference.
attribute end { xsd:token }
db.biblioref.attlist =
db.biblioref.role.attribute?
& db.common.attributes
& db.common.req.linking.attributes
& db.biblioref.xrefstyle.attribute?
& db.biblioref.endterm.attribute?
& db.biblioref.units.attribute?
& db.biblioref.begin.attribute?
& db.biblioref.end.attribute?
db.biblioref =
## A cross-reference to a bibliographic entry
element biblioref { db.biblioref.attlist, empty }
}
db.significance.enumeration =
## Normal
"normal"
|
## Preferred
"preferred"
db.significance.attribute =
## Specifies the significance of the term
attribute significance { db.significance.enumeration }
db.zone.attribute =
## Specifies the IDs of the elements to which this term applies
attribute zone { xsd:IDREFS }
db.indexterm.pagenum.attribute =
## Indicates the page on which this index term occurs in some version of the printed document
attribute pagenum { text }
db.scope.enumeration =
## All indexes
"all"
|
## The global index (as for a combined index of a set of books)
"global"
|
## The local index (the index for this document only)
"local"
db.scope.attribute =
## Specifies the scope of the index term
attribute scope { db.scope.enumeration }
db.sortas.attribute =
## Specifies the string by which the term is to be sorted; if unspecified, the term content is used
attribute sortas { text }
db.index.type.attribute =
## Specifies the target index for this term
attribute type { text }
div {
db.itermset.role.attribute = attribute role { text }
db.itermset.attlist =
db.itermset.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.itermset =
## A set of index terms in the meta-information of a document
element itermset { db.itermset.attlist, db.indexterm.singular+ }
}
db.indexterm.contentmodel =
db.primary?,
((db.secondary,
((db.tertiary, (db.see | db.seealso+)?)
| db.see
| db.seealso+)?)
| db.see
| db.seealso+)?
div {
db.indexterm.singular.role.attribute = attribute role { text }
db.indexterm.singular.class.attribute =
## Identifies the class of index term
attribute class {
## A singular index term
"singular"
}
db.indexterm.singular.attlist =
db.indexterm.singular.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.significance.attribute?
& db.zone.attribute?
& db.indexterm.pagenum.attribute?
& db.scope.attribute?
& db.index.type.attribute?
& db.indexterm.singular.class.attribute?
db.indexterm.singular =
## A wrapper for an indexed term
element indexterm {
db.indexterm.singular.attlist, db.indexterm.contentmodel
}
}
div {
db.indexterm.startofrange.role.attribute = attribute role { text }
db.indexterm.startofrange.class.attribute =
## Identifies the class of index term
attribute class {
## The start of a range
"startofrange"
}
db.indexterm.startofrange.attlist =
db.indexterm.startofrange.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.significance.attribute?
& db.zone.attribute?
& db.indexterm.pagenum.attribute?
& db.scope.attribute?
& db.index.type.attribute?
& db.indexterm.startofrange.class.attribute
db.indexterm.startofrange =
## A wrapper for an indexed term that covers a range
element indexterm {
db.indexterm.startofrange.attlist, db.indexterm.contentmodel
}
}
div {
db.indexterm.endofrange.role.attribute = attribute role { text }
db.indexterm.endofrange.class.attribute =
## Identifies the class of index term
attribute class {
## The end of a range
"endofrange"
}
db.indexterm.endofrange.startref.attribute =
## Points to the start of the range
attribute startref { xsd:IDREF }
db.indexterm.endofrange.attlist =
db.indexterm.endofrange.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.indexterm.endofrange.class.attribute
& db.indexterm.endofrange.startref.attribute
db.indexterm.endofrange =
## Identifies the end of a range associated with an indexed term
element indexterm { db.indexterm.endofrange.attlist, empty }
}
div {
db.indexterm =
db.indexterm.singular
| db.indexterm.startofrange
| db.indexterm.endofrange
}
div {
db.primary.role.attribute = attribute role { text }
db.primary.attlist =
db.primary.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.sortas.attribute?
db.primary =
## The primary word or phrase under which an index term should be sorted
element primary { db.primary.attlist, db.all.inlines* }
}
div {
db.secondary.role.attribute = attribute role { text }
db.secondary.attlist =
db.secondary.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.sortas.attribute?
db.secondary =
## A secondary word or phrase in an index term
element secondary { db.secondary.attlist, db.all.inlines* }
}
div {
db.tertiary.role.attribute = attribute role { text }
db.tertiary.attlist =
db.tertiary.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.sortas.attribute?
db.tertiary =
## A tertiary word or phrase in an index term
element tertiary { db.tertiary.attlist, db.all.inlines* }
}
div {
db.see.role.attribute = attribute role { text }
db.see.attlist =
db.see.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.see =
## Part of an index term directing the reader instead to another entry in the index
element see { db.see.attlist, db.all.inlines* }
}
div {
db.seealso.role.attribute = attribute role { text }
db.seealso.attlist =
db.seealso.role.attribute?
& db.common.attributes
& db.common.linking.attributes
db.seealso =
## Part of an index term directing the reader also to another entry in the index
element seealso { db.seealso.attlist, db.all.inlines* }
}
div {
db.index.status.attribute = db.status.attribute
db.index.role.attribute = attribute role { text }
db.index.attlist =
db.index.role.attribute?
& db.common.attributes
& db.common.linking.attributes
& db.label.attribute?
& db.index.status.attribute?
& db.index.type.attribute?
db.index.info = db._info
# Yes, db.indexdiv* and db.indexentry*; that way an © 2015 - 2024 Weber Informatics LLC | Privacy Policy