source: BOOK/schema/docbook/4.5/rng/dbpoolx.rnc@ aa3b549

# ......................................................................

# DocBook XML information pool module V4.5 .............................

# File dbpoolx.mod .....................................................

# Copyright 1992-2004 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).
# 
# $Id: dbpoolx.mod 6340 2006-10-03 13:23:24Z nwalsh $
# 
# Permission to use, copy, modify and distribute the DocBook XML DTD
# 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 DTD for
# any purpose.  It is provided "as is" without expressed or implied
# warranty.
# 
# If you modify the DocBook XML DTD in any way, except for declaring and
# referencing additional sets of general entities and declaring
# additional notations, label your DTD as a variant of DocBook.  See
# the maintenance documentation for more information.
# 
# Please direct all questions, bug reports, or suggestions for
# changes to the docbook@lists.oasis-open.org mailing list. For more
# information, see http://www.oasis-open.org/docbook/.

# ......................................................................

# This module contains the definitions for the objects, inline
# elements, and so on that are available to be used as the main
# content of DocBook documents.  Some elements are useful for general
# publishing, and others are useful specifically for computer
# documentation.
# 
# This module has the following dependencies on other modules:
# 
# o It assumes that a %notation.class; entity is defined by the
#   driver file or other high-level module.  This entity is
#   referenced in the NOTATION attributes for the graphic-related and
#   ModeSpec elements.
# 
# o It assumes that an appropriately parameterized table module is
#   available for use with the table-related elements.
# 
# In DTD driver files referring to this module, please use an entity
# declaration that uses the public identifier shown below:
# 
# <!ENTITY % dbpool PUBLIC
# "-//OASIS//ELEMENTS DocBook XML Information Pool V4.5//EN"
# "dbpoolx.mod">
# %dbpool;
# 
# See the documentation for detailed information on the parameter
# entity and module scheme used in DocBook, customizing DocBook and
# planning for interchange, and changes made since the last release
# of DocBook.

# ......................................................................

# Forms entities .......................................................

# These PEs provide the hook by which the forms module can be inserted

# into the DTD.

namespace a = "http://relaxng.org/ns/compatibility/annotations/1.0"

forminlines.hook = notAllowed
forms.hook = notAllowed
# ......................................................................

# General-purpose semantics entities ...................................
yesorno.attvals = string
# ......................................................................

# Entities for module inclusions .......................................

# ......................................................................

# Entities for element classes and mixtures ............................

# "Ubiquitous" classes: ndxterm.class and beginpage
local.ndxterm.class = notAllowed
ndxterm.class = indexterm | local.ndxterm.class
# Object-level classes .................................................
local.list.class = notAllowed
list.class =
  calloutlist
  | glosslist
  | bibliolist
  | itemizedlist
  | orderedlist
  | segmentedlist
  | simplelist
  | variablelist
  | local.list.class
local.admon.class = notAllowed
admon.class =
  caution | important | note | tip | warning | local.admon.class
local.linespecific.class = notAllowed
linespecific.class =
  literallayout
  | programlisting
  | programlistingco
  | screen
  | screenco
  | screenshot
  | local.linespecific.class
local.method.synop.class = notAllowed
method.synop.class =
  constructorsynopsis
  | destructorsynopsis
  | methodsynopsis
  | local.method.synop.class
local.synop.class = notAllowed
synop.class =
  synopsis
  | cmdsynopsis
  | funcsynopsis
  | classsynopsis
  | fieldsynopsis
  | method.synop.class
  | local.synop.class
local.para.class = notAllowed
para.class = formalpara | para | simpara | local.para.class
local.informal.class = notAllowed
informal.class =
  address
  | blockquote
  | graphic
  | graphicco
  | mediaobject
  | mediaobjectco
  | informalequation
  | informalexample
  | informalfigure
  | informaltable
  | local.informal.class
local.formal.class = notAllowed
formal.class = equation | example | figure | table | local.formal.class
# The DocBook TC may produce an official EBNF module for DocBook.

# This PE provides the hook by which it can be inserted into the DTD.
ebnf.block.hook = notAllowed
local.compound.class = notAllowed
compound.class =
  msgset
  | procedure
  | sidebar
  | qandaset
  | task
  | ebnf.block.hook
  | local.compound.class
local.genobj.class = notAllowed
genobj.class =
  anchor | bridgehead | remark | highlights | local.genobj.class
local.descobj.class = notAllowed
descobj.class = abstract | authorblurb | epigraph | local.descobj.class
# Character-level classes ..............................................
local.xref.char.class = notAllowed
xref.char.class = footnoteref | xref | biblioref | local.xref.char.class
local.gen.char.class = notAllowed
gen.char.class =
  abbrev
  | acronym
  | citation
  | citerefentry
  | citetitle
  | citebiblioid
  | emphasis
  | firstterm
  | foreignphrase
  | glossterm
  | termdef
  | footnote
  | phrase
  | orgname
  | quote
  | trademark
  | wordasword
  | personname
  | local.gen.char.class
local.link.char.class = notAllowed
link.char.class = link | olink | ulink | local.link.char.class
# The DocBook TC may produce an official EBNF module for DocBook.

# This PE provides the hook by which it can be inserted into the DTD.
ebnf.inline.hook = notAllowed
local.tech.char.class = notAllowed
tech.char.class =
  action
  | application
  | classname
  | methodname
  | interfacename
  | exceptionname
  | ooclass
  | oointerface
  | ooexception
  | package
  | command
  | computeroutput
  | database
  | email
  | envar
  | errorcode
  | errorname
  | errortype
  | errortext
  | filename
  | function
  | guibutton
  | guiicon
  | guilabel
  | guimenu
  | guimenuitem
  | guisubmenu
  | hardware
  | interface
  | keycap
  | keycode
  | keycombo
  | keysym
  | literal
  | code
  | constant
  | markup
  | medialabel
  | menuchoice
  | mousebutton
  | option
  | optional
  | parameter
  | prompt
  | property
  | replaceable
  | returnvalue
  | sgmltag
  | structfield
  | structname
  | symbol
  | systemitem
  | uri
  | \token
  | type
  | userinput
  | varname
  | ebnf.inline.hook
  | local.tech.char.class
local.base.char.class = notAllowed
base.char.class = anchor | local.base.char.class
local.docinfo.char.class = notAllowed
docinfo.char.class =
  author
  | authorinitials
  | corpauthor
  | corpcredit
  | modespec
  | othercredit
  | productname
  | productnumber
  | revhistory
  | local.docinfo.char.class
local.other.char.class = notAllowed
other.char.class =
  remark | subscript | superscript | local.other.char.class
local.inlineobj.char.class = notAllowed
inlineobj.char.class =
  inlinegraphic
  | inlinemediaobject
  | inlineequation
  | local.inlineobj.char.class
# ......................................................................

# Entities for content models ..........................................
formalobject.title.content = title, titleabbrev?
# Redeclaration placeholder ............................................

# For redeclaring entities that are declared after this point while
# retaining their references to the entities that are declared before
# this point

# Object-level mixtures ................................................

#                       list admn line synp para infm form cmpd gen  desc
# Component mixture       X    X    X    X    X    X    X    X    X    X
# Sidebar mixture         X    X    X    X    X    X    X    a    X
# Footnote mixture        X         X    X    X    X
# Example mixture         X         X    X    X    X
# Highlights mixture      X    X              X
# Paragraph mixture       X         X    X         X
# Admonition mixture      X         X    X    X    X    X    b    c
# Figure mixture                    X    X         X
# Table entry mixture     X    X    X         X    d
# Glossary def mixture    X         X    X    X    X         e
# Legal notice mixture    X    X    X         X    f
# 
# a. Just Procedure; not Sidebar itself or MsgSet.
# b. No MsgSet.
# c. No Highlights.
# d. Just Graphic; no other informal objects.
# e. No Anchor, BridgeHead, or Highlights.
# f. Just BlockQuote; no other informal objects.
local.component.mix = notAllowed
component.mix =
  list.class
  | admon.class
  | linespecific.class
  | synop.class
  | para.class
  | informal.class
  | formal.class
  | compound.class
  | genobj.class
  | descobj.class
  | ndxterm.class
  | beginpage
  | forms.hook
  | local.component.mix
local.sidebar.mix = notAllowed
sidebar.mix =
  list.class
  | admon.class
  | linespecific.class
  | synop.class
  | para.class
  | informal.class
  | formal.class
  | procedure
  | genobj.class
  | ndxterm.class
  | beginpage
  | forms.hook
  | local.sidebar.mix
local.qandaset.mix = notAllowed
qandaset.mix =
  list.class
  | admon.class
  | linespecific.class
  | synop.class
  | para.class
  | informal.class
  | formal.class
  | procedure
  | genobj.class
  | ndxterm.class
  | forms.hook
  | local.qandaset.mix
local.revdescription.mix = notAllowed
revdescription.mix =
  list.class
  | admon.class
  | linespecific.class
  | synop.class
  | para.class
  | informal.class
  | formal.class
  | procedure
  | genobj.class
  | ndxterm.class
  | local.revdescription.mix
local.footnote.mix = notAllowed
footnote.mix =
  list.class
  | linespecific.class
  | synop.class
  | para.class
  | informal.class
  | local.footnote.mix
local.example.mix = notAllowed
example.mix =
  list.class
  | linespecific.class
  | synop.class
  | para.class
  | informal.class
  | ndxterm.class
  | beginpage
  | procedure
  | forms.hook
  | local.example.mix
local.highlights.mix = notAllowed
highlights.mix =
  list.class
  | admon.class
  | para.class
  | ndxterm.class
  | local.highlights.mix
# %formal.class; is explicitly excluded from many contexts in which
# paragraphs are used
local.para.mix = notAllowed
para.mix =
  list.class
  | admon.class
  | linespecific.class
  | informal.class
  | formal.class
  | local.para.mix
local.admon.mix = notAllowed
admon.mix =
  list.class
  | linespecific.class
  | synop.class
  | para.class
  | informal.class
  | formal.class
  | procedure
  | sidebar
  | anchor
  | bridgehead
  | remark
  | ndxterm.class
  | beginpage
  | forms.hook
  | local.admon.mix
local.figure.mix = notAllowed
figure.mix =
  linespecific.class
  | synop.class
  | informal.class
  | ndxterm.class
  | beginpage
  | forms.hook
  | local.figure.mix
local.tabentry.mix = notAllowed
tabentry.mix =
  list.class
  | admon.class
  | linespecific.class
  | para.class
  | graphic
  | mediaobject
  | forms.hook
  | local.tabentry.mix
local.glossdef.mix = notAllowed
glossdef.mix =
  list.class
  | linespecific.class
  | synop.class
  | para.class
  | informal.class
  | formal.class
  | remark
  | ndxterm.class
  | beginpage
  | local.glossdef.mix
local.legalnotice.mix = notAllowed
legalnotice.mix =
  list.class
  | admon.class
  | linespecific.class
  | para.class
  | blockquote
  | ndxterm.class
  | beginpage
  | local.legalnotice.mix
local.textobject.mix = notAllowed
textobject.mix =
  list.class
  | admon.class
  | linespecific.class
  | para.class
  | blockquote
  | local.textobject.mix
local.mediaobject.mix = notAllowed
mediaobject.mix =
  videoobject
  | audioobject
  | imageobject
  | imageobjectco
  | textobject
  | local.mediaobject.mix
local.listpreamble.mix = notAllowed
listpreamble.mix =
  admon.class
  | linespecific.class
  | synop.class
  | para.class
  | informal.class
  | genobj.class
  | descobj.class
  | ndxterm.class
  | beginpage
  | forms.hook
  | local.listpreamble.mix
# Character-level mixtures .............................................

# sgml.features

# not [sgml.features[

# ]] not sgml.features

#                     #PCD xref word link cptr base dnfo othr inob (synop)
# para.char.mix         X    X    X    X    X    X    X    X    X
# title.char.mix        X    X    X    X    X    X    X    X    X
# ndxterm.char.mix      X    X    X    X    X    X    X    X    a
# cptr.char.mix         X              X    X    X         X    a
# smallcptr.char.mix    X                   b                   a
# word.char.mix         X         c    X         X         X    a
# docinfo.char.mix      X         d    X    b              X    a
# 
# a. Just InlineGraphic; no InlineEquation.
# b. Just Replaceable; no other computer terms.
# c. Just Emphasis and Trademark; no other word elements.
# d. Just Acronym, Emphasis, and Trademark; no other word elements.
local.para.char.mix = notAllowed
para.char.mix =
  text
  | xref.char.class
  | gen.char.class
  | link.char.class
  | tech.char.class
  | base.char.class
  | docinfo.char.class
  | other.char.class
  | inlineobj.char.class
  | synop.class
  | ndxterm.class
  | beginpage
  | forminlines.hook
  | local.para.char.mix
local.title.char.mix = notAllowed
title.char.mix =
  text
  | xref.char.class
  | gen.char.class
  | link.char.class
  | tech.char.class
  | base.char.class
  | docinfo.char.class
  | other.char.class
  | inlineobj.char.class
  | ndxterm.class
  | local.title.char.mix
local.ndxterm.char.mix = notAllowed
ndxterm.char.mix =
  text
  | xref.char.class
  | gen.char.class
  | link.char.class
  | tech.char.class
  | base.char.class
  | docinfo.char.class
  | other.char.class
  | inlinegraphic
  | inlinemediaobject
  | local.ndxterm.char.mix
local.cptr.char.mix = notAllowed
cptr.char.mix =
  text
  | link.char.class
  | tech.char.class
  | base.char.class
  | other.char.class
  | inlinegraphic
  | inlinemediaobject
  | ndxterm.class
  | beginpage
  | local.cptr.char.mix
local.smallcptr.char.mix = notAllowed
smallcptr.char.mix =
  text
  | replaceable
  | inlinegraphic
  | inlinemediaobject
  | ndxterm.class
  | beginpage
  | local.smallcptr.char.mix
local.word.char.mix = notAllowed
word.char.mix =
  text
  | acronym
  | emphasis
  | trademark
  | link.char.class
  | base.char.class
  | other.char.class
  | inlinegraphic
  | inlinemediaobject
  | ndxterm.class
  | beginpage
  | local.word.char.mix
local.docinfo.char.mix = notAllowed
docinfo.char.mix =
  text
  | link.char.class
  | emphasis
  | trademark
  | replaceable
  | other.char.class
  | inlinegraphic
  | inlinemediaobject
  | ndxterm.class
  | local.docinfo.char.mix
# ENTITY % bibliocomponent.mix (see Bibliographic section, below)

# ENTITY % person.ident.mix (see Bibliographic section, below)

# ......................................................................

# Entities for attributes and attribute components .....................

# Effectivity attributes ...............................................

# Arch: Computer or chip architecture to which element applies; no
# default
arch.attrib = attribute arch { text }?
# Condition: General-purpose effectivity attribute
condition.attrib = attribute condition { text }?
# Conformance: Standards conformance characteristics
conformance.attrib = attribute conformance { xsd:NMTOKENS }?
# OS: Operating system to which element applies; no default
os.attrib = attribute os { text }?
# Revision: Editorial revision to which element belongs; no default
revision.attrib = attribute revision { text }?
# Security: Security classification; no default
security.attrib = attribute security { text }?
# UserLevel: Level of user experience to which element applies; no
# default
userlevel.attrib = attribute userlevel { text }?
# Vendor: Computer vendor to which element applies; no default
vendor.attrib = attribute vendor { text }?
# Wordsize: Computer word size (32 bit, 64 bit, etc.); no default
wordsize.attrib = attribute wordsize { text }?
local.effectivity.attrib = empty
effectivity.attrib =
  arch.attrib,
  condition.attrib,
  conformance.attrib,
  os.attrib,
  revision.attrib,
  security.attrib,
  userlevel.attrib,
  vendor.attrib,
  wordsize.attrib,
  local.effectivity.attrib
# Common attributes ....................................................

# Id: Unique identifier of element; no default
id.attrib = attribute id { xsd:ID }?
# Id: Unique identifier of element; a value must be supplied; no
# default
idreq.attrib = attribute id { xsd:ID }
# Lang: Indicator of language in which element is written, for
# translation, character set management, etc.; no default
lang.attrib = attribute lang { text }?
# Remap: Previous role of element before conversion; no default
remap.attrib = attribute remap { text }?
# Role: New role of element in local environment; no default
role.attrib = attribute role { text }?
# XRefLabel: Alternate labeling string for XRef text generation;
# default is usually title or other appropriate label text already
# contained in element
xreflabel.attrib = attribute xreflabel { text }?
# RevisionFlag: Revision status of element; default is that element
# wasn't revised
revisionflag.attrib =
  attribute revisionflag { "changed" | "added" | "deleted" | "off" }?
local.common.attrib = empty
# dir: Bidirectional override
dir.attrib = attribute dir { "ltr" | "rtl" | "lro" | "rlo" }?
# xml:base: base URI
xml-base.attrib = attribute xml:base { text }?
# Role is included explicitly on each element
common.attrib =
  id.attrib,
  lang.attrib,
  remap.attrib,
  xreflabel.attrib,
  revisionflag.attrib,
  effectivity.attrib,
  dir.attrib,
  xml-base.attrib,
  local.common.attrib
# Role is included explicitly on each element
idreq.common.attrib =
  idreq.attrib,
  lang.attrib,
  remap.attrib,
  xreflabel.attrib,
  revisionflag.attrib,
  effectivity.attrib,
  dir.attrib,
  xml-base.attrib,
  local.common.attrib
# Semi-common attributes and other attribute entities ..................
local.graphics.attrib = empty
# EntityRef: Name of an external entity containing the content
# of the graphic

# FileRef: Filename, qualified by a pathname if desired,
# designating the file containing the content of the graphic

# Format: Notation of the element content, if any

# SrcCredit: Information about the source of the Graphic

# Width: Same as CALS reprowid (desired width)

# Depth: Same as CALS reprodep (desired depth)

# Align: Same as CALS hplace with 'none' removed; #IMPLIED means
# application-specific

# Scale: Conflation of CALS hscale and vscale

# Scalefit: Same as CALS scalefit
graphics.attrib =
  attribute entityref { xsd:ENTITY }?,
  attribute fileref { text }?,
  attribute format { notation.class }?,
  attribute srccredit { text }?,
  attribute width { text }?,
  attribute contentwidth { text }?,
  attribute depth { text }?,
  attribute contentdepth { text }?,
  attribute align { "left" | "right" | "center" }?,
  attribute valign { "top" | "middle" | "bottom" }?,
  attribute scale { text }?,
  attribute scalefit { yesorno.attvals }?,
  local.graphics.attrib
local.keyaction.attrib = empty
# Action: Key combination type; default is unspecified if one
# child element, Simul if there is more than one; if value is
# Other, the OtherAction attribute must have a nonempty value

# OtherAction: User-defined key combination type
keyaction.attrib =
  attribute action {
    "click" | "double-click" | "press" | "seq" | "simul" | "other"
  }?,
  attribute otheraction { text }?,
  local.keyaction.attrib
# Label: Identifying number or string; default is usually the
# appropriate number or string autogenerated by a formatter
label.attrib = attribute label { text }?
# xml:space: whitespace treatment
xml-space.attrib = attribute xml:space { "preserve" }?
# Format: whether element is assumed to contain significant white
# space
linespecific.attrib =
  [ a:defaultValue = "linespecific" ]
  attribute format { "linespecific" }?,
  xml-space.attrib,
  attribute linenumbering { "numbered" | "unnumbered" }?,
  attribute continuation { "continues" | "restarts" }?,
  attribute startinglinenumber { text }?,
  attribute language { text }?
# Linkend: link to related information; no default
linkend.attrib = attribute linkend { xsd:IDREF }?
# Linkend: required link to related information
linkendreq.attrib = attribute linkend { xsd:IDREF }
# Linkends: link to one or more sets of related information; no
# default
linkends.attrib = attribute linkends { xsd:IDREFS }?
local.mark.attrib = empty
mark.attrib =
  attribute mark { text }?,
  local.mark.attrib
# MoreInfo: whether element's content has an associated RefEntry
moreinfo.attrib =
  [ a:defaultValue = "none" ]
  attribute moreinfo { "refentry" | "none" }?
# Pagenum: number of page on which element appears; no default
pagenum.attrib = attribute pagenum { text }?
local.status.attrib = empty
# Status: Editorial or publication status of the element
# it applies to, such as "in review" or "approved for distribution"
status.attrib =
  attribute status { text }?,
  local.status.attrib
# Width: width of the longest line in the element to which it
# pertains, in number of characters
width.attrib = attribute width { text }?
# ......................................................................

# Title elements .......................................................
local.title.attrib = empty
title.role.attrib = role.attrib
# doc:The text of the title of a section of a document or of a formal block-level element.
title = element title { title.attlist, title.char.mix* }
# end of title.element
title.attlist &=
  pagenum.attrib, common.attrib, title.role.attrib, local.title.attrib
# end of title.attlist

# end of title.module
local.titleabbrev.attrib = empty
titleabbrev.role.attrib = role.attrib
# doc:The abbreviation of a Title.
titleabbrev =
  element titleabbrev { titleabbrev.attlist, title.char.mix* }
# end of titleabbrev.element
titleabbrev.attlist &=
  common.attrib, titleabbrev.role.attrib, local.titleabbrev.attrib
# end of titleabbrev.attlist

# end of titleabbrev.module
local.subtitle.attrib = empty
subtitle.role.attrib = role.attrib
# doc:The subtitle of a document.
subtitle = element subtitle { subtitle.attlist, title.char.mix* }
# end of subtitle.element
subtitle.attlist &=
  common.attrib, subtitle.role.attrib, local.subtitle.attrib
# end of subtitle.attlist

# end of subtitle.module

# ......................................................................

# Bibliographic entities and elements ..................................

# The bibliographic elements are typically used in the document
# hierarchy. They do not appear in content models of information
# pool elements.  See also the document information elements,
# below.
local.person.ident.mix = notAllowed
person.ident.mix =
  honorific
  | firstname
  | surname
  | lineage
  | othername
  | affiliation
  | authorblurb
  | contrib
  | local.person.ident.mix
local.bibliocomponent.mix = notAllowed
bibliocomponent.mix =
  abbrev
  | abstract
  | address
  | artpagenums
  | author
  | authorgroup
  | authorinitials
  | bibliomisc
  | biblioset
  | collab
  | confgroup
  | contractnum
  | contractsponsor
  | copyright
  | corpauthor
  | corpname
  | corpcredit
  | date
  | edition
  | editor
  | invpartnumber
  | isbn
  | issn
  | issuenum
  | orgname
  | biblioid
  | citebiblioid
  | bibliosource
  | bibliorelation
  | bibliocoverage
  | othercredit
  | pagenums
  | printhistory
  | productname
  | productnumber
  | pubdate
  | publisher
  | publishername
  | pubsnumber
  | releaseinfo
  | revhistory
  | seriesvolnums
  | subtitle
  | title
  | titleabbrev
  | volumenum
  | citetitle
  | personname
  | person.ident.mix
  | ndxterm.class
  | local.bibliocomponent.mix
# I don't think this is well placed, but it needs to be here because of

# the reference to bibliocomponent.mix
local.info.class = notAllowed
info.class =
  graphic
  | mediaobject
  | legalnotice
  | modespec
  | subjectset
  | keywordset
  | itermset
  | bibliocomponent.mix
  | local.info.class
# BiblioList ........................
local.bibliolist.attrib = empty
bibliolist.role.attrib = role.attrib
# doc:A wrapper for a set of bibliography entries.
bibliolist =
  element bibliolist {
    bibliolist.attlist,
    blockinfo?,
    formalobject.title.content?,
    (biblioentry | bibliomixed)+
  }
# end of bibliolist.element
bibliolist.attlist &=
  common.attrib, bibliolist.role.attrib, local.bibliolist.attrib
# end of bibliolist.attlist

# end of bibliolist.module
local.biblioentry.attrib = empty
biblioentry.role.attrib = role.attrib
# doc:An entry in a Bibliography.
biblioentry =
  element biblioentry {
    biblioentry.attlist, (articleinfo | bibliocomponent.mix)+
  }
# end of biblioentry.element
biblioentry.attlist &=
  common.attrib, biblioentry.role.attrib, local.biblioentry.attrib
# end of biblioentry.attlist

# end of biblioentry.module
local.bibliomixed.attrib = empty
bibliomixed.role.attrib = role.attrib
# doc:An entry in a Bibliography.
bibliomixed =
  element bibliomixed {
    bibliomixed.attlist, (text | bibliocomponent.mix | bibliomset)*
  }
# end of bibliomixed.element
bibliomixed.attlist &=
  common.attrib, bibliomixed.role.attrib, local.bibliomixed.attrib
# end of bibliomixed.attlist

# end of bibliomixed.module
local.articleinfo.attrib = empty
articleinfo.role.attrib = role.attrib
# doc:Meta-information for an Article.
articleinfo = element articleinfo { articleinfo.attlist, info.class+ }
# end of articleinfo.element
articleinfo.attlist &=
  common.attrib, articleinfo.role.attrib, local.articleinfo.attrib
# end of articleinfo.attlist

# end of articleinfo.module
local.biblioset.attrib = empty
biblioset.role.attrib = role.attrib
# doc:A "raw" container for related bibliographic information.
biblioset =
  element biblioset { biblioset.attlist, bibliocomponent.mix+ }
# end of biblioset.element

# Relation: Relationship of elements contained within BiblioSet
biblioset.attlist &=
  attribute relation { text }?,
  common.attrib,
  biblioset.role.attrib,
  local.biblioset.attrib
# end of biblioset.attlist

# end of biblioset.module
bibliomset.role.attrib = role.attrib
local.bibliomset.attrib = empty
# doc:A "cooked" container for related bibliographic information.
bibliomset =
  element bibliomset {
    bibliomset.attlist, (text | bibliocomponent.mix | bibliomset)*
  }
# end of bibliomset.element

# Relation: Relationship of elements contained within BiblioMSet
bibliomset.attlist &=
  attribute relation { text }?,
  common.attrib,
  bibliomset.role.attrib,
  local.bibliomset.attrib
# end of bibliomset.attlist

# end of bibliomset.module
local.bibliomisc.attrib = empty
bibliomisc.role.attrib = role.attrib
# doc:Untyped bibliographic information.
bibliomisc = element bibliomisc { bibliomisc.attlist, para.char.mix* }
# end of bibliomisc.element
bibliomisc.attlist &=
  common.attrib, bibliomisc.role.attrib, local.bibliomisc.attrib
# end of bibliomisc.attlist

# end of bibliomisc.module

# ......................................................................

# Subject, Keyword, and ITermSet elements ..............................
local.subjectset.attrib = empty
subjectset.role.attrib = role.attrib
# doc:A set of terms describing the subject matter of a document.
subjectset = element subjectset { subjectset.attlist, subject+ }
# end of subjectset.element

# Scheme: Controlled vocabulary employed in SubjectTerms
subjectset.attlist &=
  attribute scheme { xsd:NMTOKEN }?,
  common.attrib,
  subjectset.role.attrib,
  local.subjectset.attrib
# end of subjectset.attlist

# end of subjectset.module
local.subject.attrib = empty
subject.role.attrib = role.attrib
# doc:One of a group of terms describing the subject matter of a document.
subject = element subject { subject.attlist, subjectterm+ }
# end of subject.element

# Weight: Ranking of this group of SubjectTerms relative
# to others, 0 is low, no highest value specified
subject.attlist &=
  attribute weight { text }?,
  common.attrib,
  subject.role.attrib,
  local.subject.attrib
# end of subject.attlist

# end of subject.module
local.subjectterm.attrib = empty
subjectterm.role.attrib = role.attrib
# doc:A term in a group of terms describing the subject matter of a document.
subjectterm = element subjectterm { subjectterm.attlist, text }
# end of subjectterm.element
subjectterm.attlist &=
  common.attrib, subjectterm.role.attrib, local.subjectterm.attrib
# end of subjectterm.attlist

# end of subjectterm.module

# end of subjectset.content.module
local.keywordset.attrib = empty
keywordset.role.attrib = role.attrib
# doc:A set of keywords describing the content of a document.
keywordset = element keywordset { keywordset.attlist, keyword+ }
# end of keywordset.element
keywordset.attlist &=
  common.attrib, keywordset.role.attrib, local.keywordset.attrib
# end of keywordset.attlist

# end of keywordset.module
local.keyword.attrib = empty
keyword.role.attrib = role.attrib
# doc:One of a set of keywords describing the content of a document.
keyword = element keyword { keyword.attlist, text }
# end of keyword.element
keyword.attlist &=
  common.attrib, keyword.role.attrib, local.keyword.attrib
# end of keyword.attlist

# end of keyword.module

# end of keywordset.content.module
local.itermset.attrib = empty
itermset.role.attrib = role.attrib
# doc:A set of index terms in the meta-information of a document.
itermset = element itermset { itermset.attlist, indexterm+ }
# end of itermset.element
itermset.attlist &=
  common.attrib, itermset.role.attrib, local.itermset.attrib
# end of itermset.attlist

# end of itermset.module

# Bibliographic info for "blocks"
local.blockinfo.attrib = empty
blockinfo.role.attrib = role.attrib
# doc:Meta-information for a block element.
blockinfo = element blockinfo { blockinfo.attlist, info.class+ }
# end of blockinfo.element
blockinfo.attlist &=
  common.attrib, blockinfo.role.attrib, local.blockinfo.attrib
# end of blockinfo.attlist

# end of blockinfo.module

# ......................................................................

# Compound (section-ish) elements ......................................

# Message set ......................
local.msgset.attrib = empty
msgset.role.attrib = role.attrib
# doc:A detailed set of messages, usually error messages.
msgset =
  element msgset {
    msgset.attlist,
    blockinfo?,
    formalobject.title.content?,
    (msgentry+ | simplemsgentry+)
  }
# end of msgset.element
msgset.attlist &= common.attrib, msgset.role.attrib, local.msgset.attrib
# end of msgset.attlist

# end of msgset.module
local.msgentry.attrib = empty
msgentry.role.attrib = role.attrib
# doc:A wrapper for an entry in a message set.
msgentry =
  element msgentry { msgentry.attlist, msg+, msginfo?, msgexplan* }
# end of msgentry.element
msgentry.attlist &=
  common.attrib, msgentry.role.attrib, local.msgentry.attrib
# end of msgentry.attlist

# end of msgentry.module
local.simplemsgentry.attrib = empty
simplemsgentry.role.attrib = role.attrib
# doc:A wrapper for a simpler entry in a message set.
simplemsgentry =
  element simplemsgentry { simplemsgentry.attlist, msgtext, msgexplan+ }
# end of simplemsgentry.element
simplemsgentry.attlist &=
  attribute audience { text }?,
  attribute level { text }?,
  attribute origin { text }?,
  common.attrib,
  simplemsgentry.role.attrib,
  local.simplemsgentry.attrib
# end of simplemsgentry.attlist

# end of simplemsgentry.module
local.msg.attrib = empty
msg.role.attrib = role.attrib
# doc:A message in a message set.
msg = element msg { msg.attlist, title?, msgmain, (msgsub | msgrel)* }
# end of msg.element
msg.attlist &= common.attrib, msg.role.attrib, local.msg.attrib
# end of msg.attlist

# end of msg.module
local.msgmain.attrib = empty
msgmain.role.attrib = role.attrib
# doc:The primary component of a message in a message set.
msgmain = element msgmain { msgmain.attlist, title?, msgtext }
# end of msgmain.element
msgmain.attlist &=
  common.attrib, msgmain.role.attrib, local.msgmain.attrib
# end of msgmain.attlist

# end of msgmain.module
local.msgsub.attrib = empty
msgsub.role.attrib = role.attrib
# doc:A subcomponent of a message in a message set.
msgsub = element msgsub { msgsub.attlist, title?, msgtext }
# end of msgsub.element
msgsub.attlist &= common.attrib, msgsub.role.attrib, local.msgsub.attrib
# end of msgsub.attlist

# end of msgsub.module
local.msgrel.attrib = empty
msgrel.role.attrib = role.attrib
# doc:A related component of a message in a message set.
msgrel = element msgrel { msgrel.attlist, title?, msgtext }
# end of msgrel.element
msgrel.attlist &= common.attrib, msgrel.role.attrib, local.msgrel.attrib
# end of msgrel.attlist

# end of msgrel.module

# MsgText (defined in the Inlines section, below)
local.msginfo.attrib = empty
msginfo.role.attrib = role.attrib
# doc:Information about a message in a message set.
msginfo =
  element msginfo { msginfo.attlist, (msglevel | msgorig | msgaud)* }
# end of msginfo.element
msginfo.attlist &=
  common.attrib, msginfo.role.attrib, local.msginfo.attrib
# end of msginfo.attlist

# end of msginfo.module
local.msglevel.attrib = empty
msglevel.role.attrib = role.attrib
# doc:The level of importance or severity of a message in a message set.
msglevel = element msglevel { msglevel.attlist, smallcptr.char.mix* }
# end of msglevel.element
msglevel.attlist &=
  common.attrib, msglevel.role.attrib, local.msglevel.attrib
# end of msglevel.attlist

# end of msglevel.module
local.msgorig.attrib = empty
msgorig.role.attrib = role.attrib
# doc:The origin of a message in a message set.
msgorig = element msgorig { msgorig.attlist, smallcptr.char.mix* }
# end of msgorig.element
msgorig.attlist &=
  common.attrib, msgorig.role.attrib, local.msgorig.attrib
# end of msgorig.attlist

# end of msgorig.module
local.msgaud.attrib = empty
msgaud.role.attrib = role.attrib
# doc:The audience to which a message in a message set is relevant.
msgaud = element msgaud { msgaud.attlist, para.char.mix* }
# end of msgaud.element
msgaud.attlist &= common.attrib, msgaud.role.attrib, local.msgaud.attrib
# end of msgaud.attlist

# end of msgaud.module
local.msgexplan.attrib = empty
msgexplan.role.attrib = role.attrib
# doc:Explanatory material relating to a message in a message set.
msgexplan =
  element msgexplan { msgexplan.attlist, title?, component.mix+ }
# end of msgexplan.element
msgexplan.attlist &=
  common.attrib, msgexplan.role.attrib, local.msgexplan.attrib
# end of msgexplan.attlist

# end of msgexplan.module

# end of msgset.content.module
local.task.attrib = empty
task.role.attrib = role.attrib
# doc:A task to be completed.
task =
  element task {
    task.attlist,
    blockinfo?,
    ndxterm.class*,
    formalobject.title.content,
    tasksummary?,
    taskprerequisites?,
    procedure,
    example*,
    taskrelated?
  }
# end of task.element
task.attlist &= common.attrib, task.role.attrib, local.task.attrib
# end of task.attlist

# end of task.module
local.tasksummary.attrib = empty
tasksummary.role.attrib = role.attrib
# doc:A summary of a task.
tasksummary =
  element tasksummary {
    tasksummary.attlist,
    blockinfo?,
    formalobject.title.content?,
    component.mix+
  }
# end of tasksummary.element
tasksummary.attlist &=
  common.attrib, tasksummary.role.attrib, local.tasksummary.attrib
# end of tasksummary.attlist

# end of tasksummary.module
local.taskprerequisites.attrib = empty
taskprerequisites.role.attrib = role.attrib
# doc:The prerequisites for a task.
taskprerequisites =
  element taskprerequisites {
    taskprerequisites.attlist,
    blockinfo?,
    formalobject.title.content?,
    component.mix+
  }
# end of taskprerequisites.element
taskprerequisites.attlist &=
  common.attrib,
  taskprerequisites.role.attrib,
  local.taskprerequisites.attrib
# end of taskprerequisites.attlist

# end of taskprerequisites.module
local.taskrelated.attrib = empty
taskrelated.role.attrib = role.attrib
# doc:Information related to a task.
taskrelated =
  element taskrelated {
    taskrelated.attlist,
    blockinfo?,
    formalobject.title.content?,
    component.mix+
  }
# end of taskrelated.element
taskrelated.attlist &=
  common.attrib, taskrelated.role.attrib, local.taskrelated.attrib
# end of taskrelated.attlist

# end of taskrelated.module

# end of task.content.module

# QandASet ........................
local.qandaset.attrib = empty
qandaset.role.attrib = role.attrib
# doc:A question-and-answer set.
qandaset =
  element qandaset {
    qandaset.attlist,
    blockinfo?,
    formalobject.title.content?,
    qandaset.mix*,
    (qandadiv+ | qandaentry+)
  }
# end of qandaset.element
qandaset.attlist &=
  attribute defaultlabel { "qanda" | "number" | "none" }?,
  common.attrib,
  qandaset.role.attrib,
  local.qandaset.attrib
# end of qandaset.attlist

# end of qandaset.module
local.qandadiv.attrib = empty
qandadiv.role.attrib = role.attrib
# doc:A titled division in a QandASet.
qandadiv =
  element qandadiv {
    qandadiv.attlist,
    blockinfo?,
    formalobject.title.content?,
    qandaset.mix*,
    (qandadiv+ | qandaentry+)
  }
# end of qandadiv.element
qandadiv.attlist &=
  common.attrib, qandadiv.role.attrib, local.qandadiv.attrib
# end of qandadiv.attlist

# end of qandadiv.module
local.qandaentry.attrib = empty
qandaentry.role.attrib = role.attrib
# doc:A question/answer set within a QandASet.
qandaentry =
  element qandaentry {
    qandaentry.attlist, blockinfo?, revhistory?, question, answer*
  }
# end of qandaentry.element
qandaentry.attlist &=
  common.attrib, qandaentry.role.attrib, local.qandaentry.attrib
# end of qandaentry.attlist

# end of qandaentry.module
local.question.attrib = empty
question.role.attrib = role.attrib
# doc:A question in a QandASet.
question = element question { question.attlist, label?, qandaset.mix+ }
# end of question.element
question.attlist &=
  common.attrib, question.role.attrib, local.question.attrib
# end of question.attlist

# end of question.module
local.answer.attrib = empty
answer.role.attrib = role.attrib
# doc:An answer to a question posed in a QandASet.
answer =
  element answer { answer.attlist, label?, qandaset.mix*, qandaentry* }
# end of answer.element
answer.attlist &= common.attrib, answer.role.attrib, local.answer.attrib
# end of answer.attlist

# end of answer.module
local.label.attrib = empty
label.role.attrib = role.attrib
# doc:A label on a Question or Answer.
label = element label { label.attlist, word.char.mix* }
# end of label.element
label.attlist &= common.attrib, label.role.attrib, local.label.attrib
# end of label.attlist

# end of label.module

# end of qandaset.content.module

# Procedure ........................
local.procedure.attrib = empty
procedure.role.attrib = role.attrib
# doc:A list of operations to be performed in a well-defined sequence.
procedure =
  element procedure {
    procedure.attlist,
    blockinfo?,
    formalobject.title.content?,
    component.mix*,
    step+
  }
# end of procedure.element
procedure.attlist &=
  common.attrib, procedure.role.attrib, local.procedure.attrib
# end of procedure.attlist

# end of procedure.module
local.step.attrib = empty
step.role.attrib = role.attrib
# doc:A unit of action in a procedure.
step =
  element step {
    step.attlist,
    title?,
    ((component.mix+,
      ((substeps | stepalternatives), component.mix*)?)
     | ((substeps | stepalternatives), component.mix*))
  }
# end of step.element

# Performance: Whether the Step must be performed

# not #REQUIRED!
step.attlist &=
  [ a:defaultValue = "required" ]
  attribute performance { "optional" | "required" }?,
  common.attrib,
  step.role.attrib,
  local.step.attrib
# end of step.attlist

# end of step.module
local.substeps.attrib = empty
substeps.role.attrib = role.attrib
# doc:A wrapper for steps that occur within steps in a procedure.
substeps = element substeps { substeps.attlist, step+ }
# end of substeps.element

# Performance: whether entire set of substeps must be performed

# not #REQUIRED!
substeps.attlist &=
  [ a:defaultValue = "required" ]
  attribute performance { "optional" | "required" }?,
  common.attrib,
  substeps.role.attrib,
  local.substeps.attrib
# end of substeps.attlist

# end of substeps.module
local.stepalternatives.attrib = empty
stepalternatives.role.attrib = role.attrib
# doc:Alternative steps in a procedure.
stepalternatives =
  element stepalternatives { stepalternatives.attlist, step+ }
# end of stepalternatives.element

# Performance: Whether (one of) the alternatives must be performed

# not #REQUIRED!
stepalternatives.attlist &=
  [ a:defaultValue = "required" ]
  attribute performance { "optional" | "required" }?,
  common.attrib,
  stepalternatives.role.attrib,
  local.stepalternatives.attrib
# end of stepalternatives.attlist

# end of stepalternatives.module

# end of procedure.content.module

# Sidebar ..........................
local.sidebarinfo.attrib = empty
sidebarinfo.role.attrib = role.attrib
# doc:Meta-information for a Sidebar.
sidebarinfo = element sidebarinfo { sidebarinfo.attlist, info.class+ }
# end of sidebarinfo.element
sidebarinfo.attlist &=
  common.attrib, sidebarinfo.role.attrib, local.sidebarinfo.attrib
# end of sidebarinfo.attlist

# end of sidebarinfo.module
local.sidebar.attrib = empty
sidebar.role.attrib = role.attrib
# doc:A portion of a document that is isolated from the main narrative flow.
sidebar =
  element sidebar {
    sidebar.attlist,
    sidebarinfo?,
    formalobject.title.content?,
    sidebar.mix+
  }
# end of sidebar.element
sidebar.attlist &=
  common.attrib, sidebar.role.attrib, local.sidebar.attrib
# end of sidebar.attlist

# end of sidebar.module

# end of sidebar.content.model

# ......................................................................

# Paragraph-related elements ...........................................
local.abstract.attrib = empty
abstract.role.attrib = role.attrib
# doc:A summary.
abstract = element abstract { abstract.attlist, title?, para.class+ }
# end of abstract.element
abstract.attlist &=
  common.attrib, abstract.role.attrib, local.abstract.attrib
# end of abstract.attlist

# end of abstract.module
local.authorblurb.attrib = empty
authorblurb.role.attrib = role.attrib
# doc:A short description or note about an author.
authorblurb =
  element authorblurb { authorblurb.attlist, title?, para.class+ }
# end of authorblurb.element
authorblurb.attlist &=
  common.attrib, authorblurb.role.attrib, local.authorblurb.attrib
# end of authorblurb.attlist

# end of authorblurb.module
local.personblurb.attrib = empty
personblurb.role.attrib = role.attrib
# doc:A short description or note about a person.
personblurb =
  element personblurb { personblurb.attlist, title?, para.class+ }
# end of personblurb.element
personblurb.attlist &=
  common.attrib, personblurb.role.attrib, local.personblurb.attrib
# end of personblurb.attlist

# end of personblurb.module
local.blockquote.attrib = empty
blockquote.role.attrib = role.attrib
# doc:A quotation set off from the main text.
blockquote =
  element blockquote {
    blockquote.attlist, blockinfo?, title?, attribution?, component.mix+
  }
# end of blockquote.element
blockquote.attlist &=
  common.attrib, blockquote.role.attrib, local.blockquote.attrib
# end of blockquote.attlist

# end of blockquote.module
local.attribution.attrib = empty
attribution.role.attrib = role.attrib
# doc:The source of a block quote or epigraph.
attribution =
  element attribution { attribution.attlist, para.char.mix* }
# end of attribution.element
attribution.attlist &=
  common.attrib, attribution.role.attrib, local.attribution.attrib
# end of attribution.attlist

# end of attribution.module
local.bridgehead.attrib = empty
bridgehead.role.attrib = role.attrib
# doc:A free-floating heading.
bridgehead = element bridgehead { bridgehead.attlist, title.char.mix* }
# end of bridgehead.element

# Renderas: Indicates the format in which the BridgeHead
# should appear
bridgehead.attlist &=
  attribute renderas {
    "other" | "sect1" | "sect2" | "sect3" | "sect4" | "sect5"
  }?,
  common.attrib,
  bridgehead.role.attrib,
  local.bridgehead.attrib
# end of bridgehead.attlist

# end of bridgehead.module
local.remark.attrib = empty
remark.role.attrib = role.attrib
# doc:A remark (or comment) intended for presentation in a draft manuscript.
remark = element remark { remark.attlist, para.char.mix* }
# end of remark.element
remark.attlist &= common.attrib, remark.role.attrib, local.remark.attrib
# end of remark.attlist

# end of remark.module
local.epigraph.attrib = empty
epigraph.role.attrib = role.attrib
# doc:A short inscription at the beginning of a document or component.
epigraph =
  element epigraph {
    epigraph.attlist, attribution?, (para.class | literallayout)+
  }
# end of epigraph.element
epigraph.attlist &=
  common.attrib, epigraph.role.attrib, local.epigraph.attrib
# end of epigraph.attlist

# Attribution (defined above)

# end of epigraph.module
local.footnote.attrib = empty
footnote.role.attrib = role.attrib
# doc:A footnote.
footnote = element footnote { footnote.attlist, footnote.mix+ }
# end of footnote.element
footnote.attlist &=
  label.attrib,
  common.attrib,
  footnote.role.attrib,
  local.footnote.attrib
# end of footnote.attlist

# end of footnote.module
local.highlights.attrib = empty
highlights.role.attrib = role.attrib
# doc:A summary of the main points of the discussed component.
highlights = element highlights { highlights.attlist, highlights.mix+ }
# end of highlights.element
highlights.attlist &=
  common.attrib, highlights.role.attrib, local.highlights.attrib
# end of highlights.attlist

# end of highlights.module
local.formalpara.attrib = empty
formalpara.role.attrib = role.attrib
# doc:A paragraph with a title.
formalpara =
  element formalpara { formalpara.attlist, title, ndxterm.class*, para }
# end of formalpara.element
formalpara.attlist &=
  common.attrib, formalpara.role.attrib, local.formalpara.attrib
# end of formalpara.attlist

# end of formalpara.module
local.para.attrib = empty
para.role.attrib = role.attrib
# doc:A paragraph.
para = element para { para.attlist, (para.char.mix | para.mix)* }
# end of para.element
para.attlist &= common.attrib, para.role.attrib, local.para.attrib
# end of para.attlist

# end of para.module
local.simpara.attrib = empty
simpara.role.attrib = role.attrib
# doc:A paragraph that contains only text and inline markup, no block elements.
simpara = element simpara { simpara.attlist, para.char.mix* }
# end of simpara.element
simpara.attlist &=
  common.attrib, simpara.role.attrib, local.simpara.attrib
# end of simpara.attlist

# end of simpara.module
local.admon.attrib = empty
admon.role.attrib = role.attrib
# doc:A note of caution.
caution = element caution { caution.attlist, title?, admon.mix+ }
# end of caution.element
caution.attlist &= common.attrib, admon.role.attrib, local.admon.attrib
# end of caution.attlist

# doc:An admonition set off from the text.
important = element important { important.attlist, title?, admon.mix+ }
# end of important.element
important.attlist &=
  common.attrib, admon.role.attrib, local.admon.attrib
# end of important.attlist

# doc:A message set off from the text.
note = element note { note.attlist, title?, admon.mix+ }
# end of note.element
note.attlist &= common.attrib, admon.role.attrib, local.admon.attrib
# end of note.attlist

# doc:A suggestion to the user, set off from the text.
tip = element tip { tip.attlist, title?, admon.mix+ }
# end of tip.element
tip.attlist &= common.attrib, admon.role.attrib, local.admon.attrib
# end of tip.attlist

# doc:An admonition set off from the text.
warning = element warning { warning.attlist, title?, admon.mix+ }
# end of warning.element
warning.attlist &= common.attrib, admon.role.attrib, local.admon.attrib
# end of warning.attlist

# end of admon.module

# ......................................................................

# Lists ................................................................

# GlossList ........................
local.glosslist.attrib = empty
glosslist.role.attrib = role.attrib
# doc:A wrapper for a set of GlossEntrys.
glosslist =
  element glosslist {
    glosslist.attlist,
    blockinfo?,
    formalobject.title.content?,
    glossentry+
  }
# end of glosslist.element
glosslist.attlist &=
  common.attrib, glosslist.role.attrib, local.glosslist.attrib
# end of glosslist.attlist

# end of glosslist.module
local.glossentry.attrib = empty
glossentry.role.attrib = role.attrib
# doc:An entry in a Glossary or GlossList.
glossentry =
  element glossentry {
    glossentry.attlist,
    glossterm,
    acronym?,
    abbrev?,
    ndxterm.class*,
    revhistory?,
    (glosssee | glossdef+)
  }
# end of glossentry.element

# SortAs: String by which the GlossEntry is to be sorted
# (alphabetized) in lieu of its proper content
glossentry.attlist &=
  attribute sortas { text }?,
  common.attrib,
  glossentry.role.attrib,
  local.glossentry.attrib
# end of glossentry.attlist

# end of glossentry.module

# GlossTerm (defined in the Inlines section, below)
local.glossdef.attrib = empty
glossdef.role.attrib = role.attrib
# doc:A definition in a GlossEntry.
glossdef =
  element glossdef { glossdef.attlist, glossdef.mix+, glossseealso* }
# end of glossdef.element

# Subject: List of subjects; keywords for the definition
glossdef.attlist &=
  attribute subject { text }?,
  common.attrib,
  glossdef.role.attrib,
  local.glossdef.attrib
# end of glossdef.attlist

# end of glossdef.module
local.glosssee.attrib = empty
glosssee.role.attrib = role.attrib
# doc:A cross-reference from one GlossEntry to another.
glosssee = element glosssee { glosssee.attlist, para.char.mix* }
# end of glosssee.element

# OtherTerm: Reference to the GlossEntry whose GlossTerm
# should be displayed at the point of the GlossSee
glosssee.attlist &=
  attribute otherterm { xsd:IDREF }?,
  common.attrib,
  glosssee.role.attrib,
  local.glosssee.attrib
# end of glosssee.attlist

# end of glosssee.module
local.glossseealso.attrib = empty
glossseealso.role.attrib = role.attrib
# doc:A cross-reference from one GlossEntry to another.
glossseealso =
  element glossseealso { glossseealso.attlist, para.char.mix* }
# end of glossseealso.element

# OtherTerm: Reference to the GlossEntry whose GlossTerm
# should be displayed at the point of the GlossSeeAlso
glossseealso.attlist &=
  attribute otherterm { xsd:IDREF }?,
  common.attrib,
  glossseealso.role.attrib,
  local.glossseealso.attrib
# end of glossseealso.attlist

# end of glossseealso.module

# end of glossentry.content.module

# ItemizedList and OrderedList .....
local.itemizedlist.attrib = empty
itemizedlist.role.attrib = role.attrib
# doc:A list in which each entry is marked with a bullet or other dingbat.
itemizedlist =
  element itemizedlist {
    itemizedlist.attlist,
    blockinfo?,
    formalobject.title.content?,
    listpreamble.mix*,
    listitem+
  }
# end of itemizedlist.element

# Spacing: Whether the vertical space in the list should be
# compressed

# Mark: Keyword, e.g., bullet, dash, checkbox, none;
# list of keywords and defaults are implementation specific
itemizedlist.attlist &=
  attribute spacing { "normal" | "compact" }?,
  mark.attrib,
  common.attrib,
  itemizedlist.role.attrib,
  local.itemizedlist.attrib
# end of itemizedlist.attlist

# end of itemizedlist.module
local.orderedlist.attrib = empty
orderedlist.role.attrib = role.attrib
# doc:A list in which each entry is marked with a sequentially incremented label.
orderedlist =
  element orderedlist {
    orderedlist.attlist,
    blockinfo?,
    formalobject.title.content?,
    listpreamble.mix*,
    listitem+
  }
# end of orderedlist.element

# Numeration: Style of ListItem numbered; default is expected
# to be Arabic

# InheritNum: Specifies for a nested list that the numbering
# of ListItems should include the number of the item
# within which they are nested (e.g., 1a and 1b within 1,
# rather than a and b)

# Continuation: Where list numbering begins afresh (Restarts,
# the default) or continues that of the immediately preceding
# list (Continues)

# Spacing: Whether the vertical space in the list should be
# compressed
orderedlist.attlist &=
  attribute numeration {
    "arabic" | "upperalpha" | "loweralpha" | "upperroman" | "lowerroman"
  }?,
  [ a:defaultValue = "ignore" ]
  attribute inheritnum { "inherit" | "ignore" }?,
  [ a:defaultValue = "restarts" ]
  attribute continuation { "continues" | "restarts" }?,
  attribute spacing { "normal" | "compact" }?,
  common.attrib,
  orderedlist.role.attrib,
  local.orderedlist.attrib
# end of orderedlist.attlist

# end of orderedlist.module
local.listitem.attrib = empty
listitem.role.attrib = role.attrib
# doc:A wrapper for the elements of a list item.
listitem = element listitem { listitem.attlist, component.mix+ }
# end of listitem.element

# Override: Indicates the mark to be used for this ListItem
# instead of the default mark or the mark specified by
# the Mark attribute on the enclosing ItemizedList
listitem.attlist &=
  attribute override { text }?,
  common.attrib,
  listitem.role.attrib,
  local.listitem.attrib
# end of listitem.attlist

# end of listitem.module

# SegmentedList ....................
local.segmentedlist.attrib = empty
segmentedlist.role.attrib = role.attrib
# doc:A segmented list, a list of sets of elements.
segmentedlist =
  element segmentedlist {
    segmentedlist.attlist,
    formalobject.title.content?,
    segtitle+,
    seglistitem+
  }
# end of segmentedlist.element
segmentedlist.attlist &=
  common.attrib, segmentedlist.role.attrib, local.segmentedlist.attrib
# end of segmentedlist.attlist

# end of segmentedlist.module
local.segtitle.attrib = empty
segtitle.role.attrib = role.attrib
# doc:The title of an element of a list item in a segmented list.
segtitle = element segtitle { segtitle.attlist, title.char.mix* }
# end of segtitle.element
segtitle.attlist &=
  common.attrib, segtitle.role.attrib, local.segtitle.attrib
# end of segtitle.attlist

# end of segtitle.module
local.seglistitem.attrib = empty
seglistitem.role.attrib = role.attrib
# doc:A list item in a segmented list.
seglistitem = element seglistitem { seglistitem.attlist, seg+ }
# end of seglistitem.element
seglistitem.attlist &=
  common.attrib, seglistitem.role.attrib, local.seglistitem.attrib
# end of seglistitem.attlist

# end of seglistitem.module
local.seg.attrib = empty
seg.role.attrib = role.attrib
# doc:An element of a list item in a segmented list.
seg = element seg { seg.attlist, para.char.mix* }
# end of seg.element
seg.attlist &= common.attrib, seg.role.attrib, local.seg.attrib
# end of seg.attlist

# end of seg.module

# end of segmentedlist.content.module

# SimpleList .......................
local.simplelist.attrib = empty
simplelist.role.attrib = role.attrib
# doc:An undecorated list of single words or short phrases.
simplelist = element simplelist { simplelist.attlist, member+ }
# end of simplelist.element

# Columns: The number of columns the array should contain

# Type: How the Members of the SimpleList should be
# formatted: Inline (members separated with commas etc.
# inline), Vert (top to bottom in n Columns), or Horiz (in
# the direction of text flow) in n Columns.  If Column
# is 1 or implied, Type=Vert and Type=Horiz give the same
# results.
simplelist.attlist &=
  attribute columns { text }?,
  [ a:defaultValue = "vert" ]
  attribute type { "inline" | "vert" | "horiz" }?,
  common.attrib,
  simplelist.role.attrib,
  local.simplelist.attrib
# end of simplelist.attlist

# end of simplelist.module
local.member.attrib = empty
member.role.attrib = role.attrib
# doc:An element of a simple list.
member = element member { member.attlist, para.char.mix* }
# end of member.element
member.attlist &= common.attrib, member.role.attrib, local.member.attrib
# end of member.attlist

# end of member.module

# end of simplelist.content.module

# VariableList .....................
local.variablelist.attrib = empty
variablelist.role.attrib = role.attrib
# doc:A list in which each entry is composed of a set of one or more terms and an associated description.
variablelist =
  element variablelist {
    variablelist.attlist,
    blockinfo?,
    formalobject.title.content?,
    listpreamble.mix*,
    varlistentry+
  }
# end of variablelist.element

# TermLength: Length beyond which the presentation engine
# may consider the Term too long and select an alternate
# presentation of the Term and, or, its associated ListItem.
variablelist.attlist &=
  attribute termlength { text }?,
  attribute spacing { "normal" | "compact" }?,
  common.attrib,
  variablelist.role.attrib,
  local.variablelist.attrib
# end of variablelist.attlist

# end of variablelist.module
local.varlistentry.attrib = empty
varlistentry.role.attrib = role.attrib
# doc:A wrapper for a set of terms and the associated description in a variable list.
varlistentry =
  element varlistentry { varlistentry.attlist, term+, listitem }
# end of varlistentry.element
varlistentry.attlist &=
  common.attrib, varlistentry.role.attrib, local.varlistentry.attrib
# end of varlistentry.attlist

# end of varlistentry.module
local.term.attrib = empty
term.role.attrib = role.attrib
# doc:The word or phrase being defined or described in a variable list.
term = element term { term.attlist, para.char.mix* }
# end of term.element
term.attlist &= common.attrib, term.role.attrib, local.term.attrib
# end of term.attlist

# end of term.module

# ListItem (defined above)

# end of variablelist.content.module

# CalloutList ......................
local.calloutlist.attrib = empty
calloutlist.role.attrib = role.attrib
# doc:A list of Callouts.
calloutlist =
  element calloutlist {
    calloutlist.attlist, formalobject.title.content?, callout+
  }
# end of calloutlist.element
calloutlist.attlist &=
  common.attrib, calloutlist.role.attrib, local.calloutlist.attrib
# end of calloutlist.attlist

# end of calloutlist.module
local.callout.attrib = empty
callout.role.attrib = role.attrib
# doc:A &ldquo;called out&rdquo; description of a marked Area.
callout = element callout { callout.attlist, component.mix+ }
# end of callout.element

# AreaRefs: IDs of one or more Areas or AreaSets described
# by this Callout
callout.attlist &=
  attribute arearefs { xsd:IDREFS },
  common.attrib,
  callout.role.attrib,
  local.callout.attrib
# end of callout.attlist

# end of callout.module

# end of calloutlist.content.module

# ......................................................................

# Objects ..............................................................

# Examples etc. ....................
local.example.attrib = empty
example.role.attrib = role.attrib
# doc:A formal example, with a title.
example =
  element example {
    example.attlist,
    blockinfo?,
    formalobject.title.content,
    example.mix+
  }
# end of example.element
example.attlist &=
  attribute floatstyle { text }?,
  label.attrib,
  width.attrib,
  common.attrib,
  example.role.attrib,
  local.example.attrib
# end of example.attlist

# end of example.module
local.informalexample.attrib = empty
informalexample.role.attrib = role.attrib
# doc:A displayed example without a title.
informalexample =
  element informalexample {
    informalexample.attlist, blockinfo?, example.mix+
  }
# end of informalexample.element
informalexample.attlist &=
  attribute floatstyle { text }?,
  width.attrib,
  common.attrib,
  informalexample.role.attrib,
  local.informalexample.attrib
# end of informalexample.attlist

# end of informalexample.module
local.programlistingco.attrib = empty
programlistingco.role.attrib = role.attrib
# doc:A program listing with associated areas used in callouts.
programlistingco =
  element programlistingco {
    programlistingco.attlist, areaspec, programlisting, calloutlist*
  }
# end of programlistingco.element
programlistingco.attlist &=
  common.attrib,
  programlistingco.role.attrib,
  local.programlistingco.attrib
# end of programlistingco.attlist

# CalloutList (defined above in Lists)

# end of informalexample.module
local.areaspec.attrib = empty
areaspec.role.attrib = role.attrib
# doc:A collection of regions in a graphic or code example.
areaspec = element areaspec { areaspec.attlist, (area | areaset)+ }
# end of areaspec.element

# Units: global unit of measure in which coordinates in
# this spec are expressed:
# 
# - CALSPair "x1,y1 x2,y2": lower-left and upper-right
# coordinates in a rectangle describing repro area in which
# graphic is placed, where X and Y dimensions are each some
# number 0..10000 (taken from CALS graphic attributes)
# 
# - LineColumn "line column": line number and column number
# at which to start callout text in "linespecific" content
# 
# - LineRange "startline endline": whole lines from startline
# to endline in "linespecific" content
# 
# - LineColumnPair "line1 col1 line2 col2": starting and ending
# points of area in "linespecific" content that starts at
# first position and ends at second position (including the
# beginnings of any intervening lines)
# 
# - Other: directive to look at value of OtherUnits attribute
# to get implementation-specific keyword
# 
# The default is implementation-specific; usually dependent on
# the parent element (GraphicCO gets CALSPair, ProgramListingCO
# and ScreenCO get LineColumn)

# OtherUnits: User-defined units
areaspec.attlist &=
  attribute units {
    "calspair" | "linecolumn" | "linerange" | "linecolumnpair" | "other"
  }?,
  attribute otherunits { xsd:NMTOKEN }?,
  common.attrib,
  areaspec.role.attrib,
  local.areaspec.attrib
# end of areaspec.attlist

# end of areaspec.module
local.area.attrib = empty
area.role.attrib = role.attrib
# doc:A region defined for a Callout in a graphic or code example.
area = element area { area.attlist, empty }
# end of area.element

# bug number/symbol override or initialization

# to any related information

# Units: unit of measure in which coordinates in this
# area are expressed; inherits from AreaSet and AreaSpec

# OtherUnits: User-defined units
area.attlist &=
  label.attrib,
  linkends.attrib,
  attribute units {
    "calspair" | "linecolumn" | "linerange" | "linecolumnpair" | "other"
  }?,
  attribute otherunits { xsd:NMTOKEN }?,
  attribute coords { text },
  idreq.common.attrib,
  area.role.attrib,
  local.area.attrib
# end of area.attlist

# end of area.module
local.areaset.attrib = empty
areaset.role.attrib = role.attrib
# doc:A set of related areas in a graphic or code example.
areaset = element areaset { areaset.attlist, area+ }
# end of areaset.element

# bug number/symbol override or initialization

# Units: unit of measure in which coordinates in this
# area are expressed; inherits from AreaSpec
areaset.attlist &=
  label.attrib,
  attribute units {
    "calspair" | "linecolumn" | "linerange" | "linecolumnpair" | "other"
  }?,
  attribute otherunits { xsd:NMTOKEN }?,
  attribute coords { text },
  idreq.common.attrib,
  areaset.role.attrib,
  local.areaset.attrib
# end of areaset.attlist

# end of areaset.module

# end of areaspec.content.module
local.programlisting.attrib = empty
programlisting.role.attrib = role.attrib
# doc:A literal listing of all or part of a program.
programlisting =
  element programlisting {
    programlisting.attlist,
    (para.char.mix | co | coref | lineannotation | textobject)*
  }
# end of programlisting.element
programlisting.attlist &=
  width.attrib,
  linespecific.attrib,
  common.attrib,
  programlisting.role.attrib,
  local.programlisting.attrib
# end of programlisting.attlist

# end of programlisting.module
local.literallayout.attrib = empty
literallayout.role.attrib = role.attrib
# doc:A block of text in which line breaks and white space are to be reproduced faithfully.
literallayout =
  element literallayout {
    literallayout.attlist,
    (para.char.mix | co | coref | textobject | lineannotation)*
  }
# end of literallayout.element
literallayout.attlist &=
  width.attrib,
  linespecific.attrib,
  [ a:defaultValue = "normal" ]
  attribute class { "monospaced" | "normal" }?,
  common.attrib,
  literallayout.role.attrib,
  local.literallayout.attrib
# end of literallayout.attlist

# LineAnnotation (defined in the Inlines section, below)

# end of literallayout.module
local.screenco.attrib = empty
screenco.role.attrib = role.attrib
# doc:A screen with associated areas used in callouts.
screenco =
  element screenco { screenco.attlist, areaspec, screen, calloutlist* }
# end of screenco.element
screenco.attlist &=
  common.attrib, screenco.role.attrib, local.screenco.attrib
# end of screenco.attlist

# AreaSpec (defined above)

# CalloutList (defined above in Lists)

# end of screenco.module
local.screen.attrib = empty
screen.role.attrib = role.attrib
# doc:Text that a user sees or might see on a computer screen.
screen =
  element screen {
    screen.attlist,
    (para.char.mix | co | coref | textobject | lineannotation)*
  }
# end of screen.element
screen.attlist &=
  width.attrib,
  linespecific.attrib,
  common.attrib,
  screen.role.attrib,
  local.screen.attrib
# end of screen.attlist

# end of screen.module
local.screenshot.attrib = empty
screenshot.role.attrib = role.attrib
# doc:A representation of what the user sees or might see on a computer screen.
screenshot =
  element screenshot {
    screenshot.attlist,
    screeninfo?,
    (graphic | graphicco | mediaobject | mediaobjectco)
  }
# end of screenshot.element
screenshot.attlist &=
  common.attrib, screenshot.role.attrib, local.screenshot.attrib
# end of screenshot.attlist

# end of screenshot.module
local.screeninfo.attrib = empty
screeninfo.role.attrib = role.attrib
# doc:Information about how a screen shot was produced.
screeninfo = element screeninfo { screeninfo.attlist, para.char.mix* }
# end of screeninfo.element
screeninfo.attlist &=
  common.attrib, screeninfo.role.attrib, local.screeninfo.attrib
# end of screeninfo.attlist

# end of screeninfo.module

# end of screenshot.content.module

# Figures etc. .....................
local.figure.attrib = empty
figure.role.attrib = role.attrib
# doc:A formal figure, generally an illustration, with a title.
figure =
  element figure {
    figure.attlist,
    blockinfo?,
    formalobject.title.content,
    (figure.mix | link.char.class)+
  }
# end of figure.element

# Float: Whether the Figure is supposed to be rendered
# where convenient (yes (1) value) or at the place it occurs
# in the text (no (0) value, the default)
figure.attlist &=
  [ a:defaultValue = "0" ] attribute float { yesorno.attvals }?,
  attribute floatstyle { text }?,
  attribute pgwide { yesorno.attvals }?,
  label.attrib,
  common.attrib,
  figure.role.attrib,
  local.figure.attrib
# end of figure.attlist

# end of figure.module
local.informalfigure.attrib = empty
informalfigure.role.attrib = role.attrib
# doc:A untitled figure.
informalfigure =
  element informalfigure {
    informalfigure.attlist, blockinfo?, (figure.mix | link.char.class)+
  }
# end of informalfigure.element

# Float: Whether the Figure is supposed to be rendered
# where convenient (yes (1) value) or at the place it occurs
# in the text (no (0) value, the default)
informalfigure.attlist &=
  [ a:defaultValue = "0" ] attribute float { yesorno.attvals }?,
  attribute floatstyle { text }?,
  attribute pgwide { yesorno.attvals }?,
  label.attrib,
  common.attrib,
  informalfigure.role.attrib,
  local.informalfigure.attrib
# end of informalfigure.attlist

# end of informalfigure.module
local.graphicco.attrib = empty
graphicco.role.attrib = role.attrib
# doc:A graphic that contains callout areas.
graphicco =
  element graphicco {
    graphicco.attlist, areaspec, graphic, calloutlist*
  }
# end of graphicco.element
graphicco.attlist &=
  common.attrib, graphicco.role.attrib, local.graphicco.attrib
# end of graphicco.attlist

# AreaSpec (defined above in Examples)

# CalloutList (defined above in Lists)

# end of graphicco.module

# Graphical data can be the content of Graphic, or you can reference
# an external file either as an entity (Entitref) or a filename
# (Fileref).
local.graphic.attrib = empty
graphic.role.attrib = role.attrib
# doc:A displayed graphical object (not an inline).
graphic = element graphic { graphic.attlist, empty }
# end of graphic.element
graphic.attlist &=
  graphics.attrib,
  common.attrib,
  graphic.role.attrib,
  local.graphic.attrib
# end of graphic.attlist

# end of graphic.module
local.inlinegraphic.attrib = empty
inlinegraphic.role.attrib = role.attrib
# doc:An object containing or pointing to graphical data that will be rendered inline.
inlinegraphic = element inlinegraphic { inlinegraphic.attlist, empty }
# end of inlinegraphic.element
inlinegraphic.attlist &=
  graphics.attrib,
  common.attrib,
  inlinegraphic.role.attrib,
  local.inlinegraphic.attrib
# end of inlinegraphic.attlist

# end of inlinegraphic.module
local.mediaobject.attrib = empty
mediaobject.role.attrib = role.attrib
# doc:A displayed media object (video, audio, image, etc.).
mediaobject =
  element mediaobject {
    mediaobject.attlist, objectinfo?, mediaobject.mix+, caption?
  }
# end of mediaobject.element
mediaobject.attlist &=
  common.attrib, mediaobject.role.attrib, local.mediaobject.attrib
# end of mediaobject.attlist

# end of mediaobject.module
local.inlinemediaobject.attrib = empty
inlinemediaobject.role.attrib = role.attrib
# doc:An inline media object (video, audio, image, and so on).
inlinemediaobject =
  element inlinemediaobject {
    inlinemediaobject.attlist, objectinfo?, mediaobject.mix+
  }
# end of inlinemediaobject.element
inlinemediaobject.attlist &=
  common.attrib,
  inlinemediaobject.role.attrib,
  local.inlinemediaobject.attrib
# end of inlinemediaobject.attlist

# end of inlinemediaobject.module
local.videoobject.attrib = empty
videoobject.role.attrib = role.attrib
# doc:A wrapper for video data and its associated meta-information.
videoobject =
  element videoobject { videoobject.attlist, objectinfo?, videodata }
# end of videoobject.element
videoobject.attlist &=
  common.attrib, videoobject.role.attrib, local.videoobject.attrib
# end of videoobject.attlist

# end of videoobject.module
local.audioobject.attrib = empty
audioobject.role.attrib = role.attrib
# doc:A wrapper for audio data and its associated meta-information.
audioobject =
  element audioobject { audioobject.attlist, objectinfo?, audiodata }
# end of audioobject.element
audioobject.attlist &=
  common.attrib, audioobject.role.attrib, local.audioobject.attrib
# end of audioobject.attlist

# end of audioobject.module
local.imageobject.attrib = empty
imageobject.role.attrib = role.attrib
# doc:A wrapper for image data and its associated meta-information.
imageobject =
  element imageobject { imageobject.attlist, objectinfo?, imagedata }
# end of imageobject.element
imageobject.attlist &=
  common.attrib, imageobject.role.attrib, local.imageobject.attrib
# end of imageobject.attlist

# end of imageobject.module
local.textobject.attrib = empty
textobject.role.attrib = role.attrib
# doc:A wrapper for a text description of an object and its associated meta-information.
textobject =
  element textobject {
    textobject.attlist,
    objectinfo?,
    (phrase | textdata | textobject.mix+)
  }
# end of textobject.element
textobject.attlist &=
  common.attrib, textobject.role.attrib, local.textobject.attrib
# end of textobject.attlist

# end of textobject.module
local.objectinfo.attrib = empty
objectinfo.role.attrib = role.attrib
# doc:Meta-information for an object.
objectinfo = element objectinfo { objectinfo.attlist, info.class+ }
# end of objectinfo.element
objectinfo.attlist &=
  common.attrib, objectinfo.role.attrib, local.objectinfo.attrib
# end of objectinfo.attlist

# end of objectinfo.module

# EntityRef: Name of an external entity containing the content
# of the object data

# FileRef: Filename, qualified by a pathname if desired,
# designating the file containing the content of the object data

# Format: Notation of the element content, if any

# SrcCredit: Information about the source of the image
local.objectdata.attrib = empty
objectdata.attrib =
  attribute entityref { xsd:ENTITY }?,
  attribute fileref { text }?,
  attribute format { notation.class }?,
  attribute srccredit { text }?,
  local.objectdata.attrib
local.videodata.attrib = empty
videodata.role.attrib = role.attrib
# doc:Pointer to external video data.
videodata = element videodata { videodata.attlist, empty }
# end of videodata.element

# Width: Same as CALS reprowid (desired width)

# Depth: Same as CALS reprodep (desired depth)

# Align: Same as CALS hplace with 'none' removed; #IMPLIED means
# application-specific

# Scale: Conflation of CALS hscale and vscale

# Scalefit: Same as CALS scalefit
videodata.attlist &=
  attribute width { text }?,
  attribute contentwidth { text }?,
  attribute depth { text }?,
  attribute contentdepth { text }?,
  attribute align { "left" | "right" | "center" }?,
  attribute valign { "top" | "middle" | "bottom" }?,
  attribute scale { text }?,
  attribute scalefit { yesorno.attvals }?,
  objectdata.attrib,
  common.attrib,
  videodata.role.attrib,
  local.videodata.attrib
# end of videodata.attlist

# end of videodata.module
local.audiodata.attrib = empty
audiodata.role.attrib = role.attrib
# doc:Pointer to external audio data.
audiodata = element audiodata { audiodata.attlist, empty }
# end of audiodata.element
audiodata.attlist &=
  objectdata.attrib,
  common.attrib,
  audiodata.role.attrib,
  local.audiodata.attrib
# end of audiodata.attlist

# end of audiodata.module
local.imagedata.attrib = empty
imagedata.role.attrib = role.attrib
# doc:Pointer to external image data.
imagedata = element imagedata { imagedata.attlist, empty }
# end of imagedata.element

# Width: Same as CALS reprowid (desired width)

# Depth: Same as CALS reprodep (desired depth)

# Align: Same as CALS hplace with 'none' removed; #IMPLIED means
# application-specific

# Scale: Conflation of CALS hscale and vscale

# Scalefit: Same as CALS scalefit
imagedata.attlist &=
  attribute width { text }?,
  attribute contentwidth { text }?,
  attribute depth { text }?,
  attribute contentdepth { text }?,
  attribute align { "left" | "right" | "center" }?,
  attribute valign { "top" | "middle" | "bottom" }?,
  attribute scale { text }?,
  attribute scalefit { yesorno.attvals }?,
  objectdata.attrib,
  common.attrib,
  imagedata.role.attrib,
  local.imagedata.attrib
# end of imagedata.attlist

# end of imagedata.module
local.textdata.attrib = empty
textdata.role.attrib = role.attrib
# doc:Pointer to external text data.
textdata = element textdata { textdata.attlist, empty }
# end of textdata.element
textdata.attlist &=
  attribute encoding { text }?,
  objectdata.attrib,
  common.attrib,
  textdata.role.attrib,
  local.textdata.attrib
# end of textdata.attlist

# end of textdata.module
local.mediaobjectco.attrib = empty
mediaobjectco.role.attrib = role.attrib
# doc:A media object that contains callouts.
mediaobjectco =
  element mediaobjectco {
    mediaobjectco.attlist,
    objectinfo?,
    imageobjectco,
    (imageobjectco | textobject)*
  }
# end of mediaobjectco.element
mediaobjectco.attlist &=
  common.attrib, mediaobjectco.role.attrib, local.mediaobjectco.attrib
# end of mediaobjectco.attlist

# end of mediaobjectco.module
local.imageobjectco.attrib = empty
imageobjectco.role.attrib = role.attrib
# doc:A wrapper for an image object with callouts.
imageobjectco =
  element imageobjectco {
    imageobjectco.attlist, areaspec, imageobject, calloutlist*
  }
# end of imageobjectco.element
imageobjectco.attlist &=
  common.attrib, imageobjectco.role.attrib, local.imageobjectco.attrib
# end of imageobjectco.attlist

# end of imageobjectco.module

# end of mediaobject.content.module

# Equations ........................

# This PE provides a mechanism for replacing equation content,

# perhaps adding a new or different model (e.g., MathML)
equation.content = alt?, (graphic+ | mediaobject+ | mathphrase+)
inlineequation.content =
  alt?, (graphic+ | inlinemediaobject+ | mathphrase+)
local.equation.attrib = empty
equation.role.attrib = role.attrib
# doc:A displayed mathematical equation.
equation =
  element equation {
    equation.attlist,
    blockinfo?,
    formalobject.title.content?,
    (informalequation | equation.content)
  }
# end of equation.element
equation.attlist &=
  attribute floatstyle { text }?,
  label.attrib,
  common.attrib,
  equation.role.attrib,
  local.equation.attrib
# end of equation.attlist

# end of equation.module
local.informalequation.attrib = empty
informalequation.role.attrib = role.attrib
# doc:A displayed mathematical equation without a title.
informalequation =
  element informalequation {
    informalequation.attlist, blockinfo?, equation.content
  }
# end of informalequation.element
informalequation.attlist &=
  attribute floatstyle { text }?,
  common.attrib,
  informalequation.role.attrib,
  local.informalequation.attrib
# end of informalequation.attlist

# end of informalequation.module
local.inlineequation.attrib = empty
inlineequation.role.attrib = role.attrib
# doc:A mathematical equation or expression occurring inline.
inlineequation =
  element inlineequation {
    inlineequation.attlist, inlineequation.content
  }
# end of inlineequation.element
inlineequation.attlist &=
  common.attrib, inlineequation.role.attrib, local.inlineequation.attrib
# end of inlineequation.attlist

# end of inlineequation.module
local.alt.attrib = empty
alt.role.attrib = role.attrib
# doc:Text representation for a graphical element.
alt = element alt { alt.attlist, text }
# end of alt.element
alt.attlist &= common.attrib, alt.role.attrib, local.alt.attrib
# end of alt.attlist

# end of alt.module
local.mathphrase.attrib = empty
mathphrase.role.attrib = role.attrib
# doc:A mathematical phrase, an expression that can be represented with ordinary text and a small amount of markup.
mathphrase =
  element mathphrase {
    mathphrase.attlist, (text | subscript | superscript | emphasis)*
  }
# end of mathphrase.element
mathphrase.attlist &=
  common.attrib, mathphrase.role.attrib, local.mathphrase.attrib
# end of mathphrase.attlist

# end of mathphrase.module

# Tables ...........................

# Choose a table model. CALS or OASIS XML Exchange

# Do we allow the HTML table model as well?

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

# xhtmltbl.mod defines HTML tables and sets parameter
# entities so that, when the CALS table module is read,
# we end up allowing any table to be CALS or HTML.
# i.e. This include must come first!

# ======================================================
include "htmltblx.rnc"
# end of allow.html.tables

# Add label and role attributes to table and informaltable

# Add common attributes to Table, TGroup, TBody, THead, TFoot, Row,
# EntryTbl, and Entry (and InformalTable element).

# Content model for Table.

# Allow either objects or inlines; beware of REs between elements.

# Reference CALS Table Model
include "calstblx.rnc"
# end of table.module

# Note that InformalTable is dependent on some of the entity
# declarations that customize Table.
local.informaltable.attrib = empty
# the following entity may have been declared by the XHTML table module

# doc:A table without a title.
informaltable =
  element informaltable {
    informaltable.attlist, blockinfo?, informal.tbl.table.mdl
  }
# end of informaltable.element

# Frame, Colsep, and Rowsep must be repeated because
# they are not in entities in the table module.

# includes TabStyle, ToCentry, ShortEntry,
# Orient, PgWide

# includes Label

# includes common attributes
informaltable.attlist &=
  attribute frame { tbl.frame.attval }?,
  attribute colsep { yesorno.attvals }?,
  attribute rowsep { yesorno.attvals }?,
  common.table.attribs,
  tbl.table.att,
  local.informaltable.attrib
# end of informaltable.attlist

# end of informaltable.module
local.caption.attrib = empty
caption.role.attrib = role.attrib
# doc:A caption.
caption = element caption { caption.attlist, (text | textobject.mix)* }
# end of caption.element

# attrs comes from HTML tables ...

# common.attrib, but without ID because ID is in attrs
caption.attlist.content =
  caption.role.attrib,
  attrs,
  attribute align { "top" | "bottom" | "left" | "right" }?,
  local.caption.attrib
caption.attlist &= caption.attlist.content
# end of caption.attlist

# end of caption.module

# ......................................................................

# Synopses .............................................................

# Synopsis .........................
local.synopsis.attrib = empty
synopsis.role.attrib = role.attrib
# doc:A general-purpose element for representing the syntax of commands or functions.
synopsis =
  element synopsis {
    synopsis.attlist,
    (para.char.mix
     | graphic
     | mediaobject
     | co
     | coref
     | textobject
     | lineannotation)*
  }
# end of synopsis.element
synopsis.attlist &=
  label.attrib,
  linespecific.attrib,
  common.attrib,
  synopsis.role.attrib,
  local.synopsis.attrib
# end of synopsis.attlist

# LineAnnotation (defined in the Inlines section, below)

# end of synopsis.module

# CmdSynopsis ......................
local.cmdsynopsis.attrib = empty
cmdsynopsis.role.attrib = role.attrib
# doc:A syntax summary for a software command.
cmdsynopsis =
  element cmdsynopsis {
    cmdsynopsis.attlist, (command | arg | group | sbr)+, synopfragment*
  }
# end of cmdsynopsis.element

# Sepchar: Character that should separate command and all
# top-level arguments; alternate value might be e.g., &Delta;
cmdsynopsis.attlist &=
  label.attrib,
  [ a:defaultValue = " " ] attribute sepchar { text }?,
  attribute cmdlength { text }?,
  common.attrib,
  cmdsynopsis.role.attrib,
  local.cmdsynopsis.attrib
# end of cmdsynopsis.attlist

# end of cmdsynopsis.module
local.arg.attrib = empty
arg.role.attrib = role.attrib
# doc:An argument in a CmdSynopsis.
arg =
  element arg {
    arg.attlist,
    (text
     | arg
     | group
     | option
     | synopfragmentref
     | replaceable
     | sbr)*
  }
# end of arg.element

# Choice: Whether Arg must be supplied: Opt (optional to
# supply, e.g. [arg]; the default), Req (required to supply,
# e.g. {arg}), or Plain (required to supply, e.g. arg)

# Rep: whether Arg is repeatable: Norepeat (e.g. arg without
# ellipsis; the default), or Repeat (e.g. arg...)
arg.attlist &=
  [ a:defaultValue = "opt" ]
  attribute choice { "opt" | "req" | "plain" }?,
  [ a:defaultValue = "norepeat" ]
  attribute rep { "norepeat" | "repeat" }?,
  common.attrib,
  arg.role.attrib,
  local.arg.attrib
# end of arg.attlist

# end of arg.module
local.group.attrib = empty
group.role.attrib = role.attrib
# doc:A group of elements in a CmdSynopsis.
group =
  element group {
    group.attlist,
    (arg | group | option | synopfragmentref | replaceable | sbr)+
  }
# end of group.element

# Choice: Whether Group must be supplied: Opt (optional to
# supply, e.g.  [g1|g2|g3]; the default), Req (required to
# supply, e.g.  {g1|g2|g3}), Plain (required to supply,
# e.g.  g1|g2|g3), OptMult (can supply zero or more, e.g.
# [[g1|g2|g3]]), or ReqMult (must supply one or more, e.g.
# {{g1|g2|g3}})

# Rep: whether Group is repeatable: Norepeat (e.g. group
# without ellipsis; the default), or Repeat (e.g. group...)
group.attlist &=
  [ a:defaultValue = "opt" ]
  attribute choice { "opt" | "req" | "plain" }?,
  [ a:defaultValue = "norepeat" ]
  attribute rep { "norepeat" | "repeat" }?,
  common.attrib,
  group.role.attrib,
  local.group.attrib
# end of group.attlist

# end of group.module
local.sbr.attrib = empty
# Synopsis break
sbr.role.attrib = role.attrib
# doc:An explicit line break in a command synopsis.
sbr = element sbr { sbr.attlist, empty }
# end of sbr.element
sbr.attlist &= common.attrib, sbr.role.attrib, local.sbr.attrib
# end of sbr.attlist

# end of sbr.module
local.synopfragmentref.attrib = empty
synopfragmentref.role.attrib = role.attrib
# doc:A reference to a fragment of a command synopsis.
synopfragmentref =
  element synopfragmentref { synopfragmentref.attlist, text }
# end of synopfragmentref.element

# to SynopFragment of complex synopsis
# material for separate referencing
synopfragmentref.attlist &=
  linkendreq.attrib,
  common.attrib,
  synopfragmentref.role.attrib,
  local.synopfragmentref.attrib
# end of synopfragmentref.attlist

# end of synopfragmentref.module
local.synopfragment.attrib = empty
synopfragment.role.attrib = role.attrib
# doc:A portion of a CmdSynopsis broken out from the main body of the synopsis.
synopfragment =
  element synopfragment { synopfragment.attlist, (arg | group)+ }
# end of synopfragment.element
synopfragment.attlist &=
  idreq.common.attrib,
  synopfragment.role.attrib,
  local.synopfragment.attrib
# end of synopfragment.attlist

# end of synopfragment.module

# Command (defined in the Inlines section, below)

# Option (defined in the Inlines section, below)

# Replaceable (defined in the Inlines section, below)

# end of cmdsynopsis.content.module

# FuncSynopsis .....................
local.funcsynopsis.attrib = empty
funcsynopsis.role.attrib = role.attrib
# doc:The syntax summary for a function definition.
funcsynopsis =
  element funcsynopsis {
    funcsynopsis.attlist, (funcsynopsisinfo | funcprototype)+
  }
# end of funcsynopsis.element
funcsynopsis.attlist &=
  label.attrib,
  common.attrib,
  funcsynopsis.role.attrib,
  local.funcsynopsis.attrib
# end of funcsynopsis.attlist

# end of funcsynopsis.module
local.funcsynopsisinfo.attrib = empty
funcsynopsisinfo.role.attrib = role.attrib
# doc:Information supplementing the FuncDefs of a FuncSynopsis.
funcsynopsisinfo =
  element funcsynopsisinfo {
    funcsynopsisinfo.attlist,
    (cptr.char.mix | textobject | lineannotation)*
  }
# end of funcsynopsisinfo.element
funcsynopsisinfo.attlist &=
  linespecific.attrib,
  common.attrib,
  funcsynopsisinfo.role.attrib,
  local.funcsynopsisinfo.attrib
# end of funcsynopsisinfo.attlist

# end of funcsynopsisinfo.module
local.funcprototype.attrib = empty
funcprototype.role.attrib = role.attrib
# doc:The prototype of a function.
funcprototype =
  element funcprototype {
    funcprototype.attlist,
    modifier*,
    funcdef,
    (void | varargs | (paramdef+, varargs?)),
    modifier*
  }
# end of funcprototype.element
funcprototype.attlist &=
  common.attrib, funcprototype.role.attrib, local.funcprototype.attrib
# end of funcprototype.attlist

# end of funcprototype.module
local.funcdef.attrib = empty
funcdef.role.attrib = role.attrib
# doc:A function (subroutine) name and its return type.
funcdef =
  element funcdef {
    funcdef.attlist, (text | type | replaceable | function)*
  }
# end of funcdef.element
funcdef.attlist &=
  common.attrib, funcdef.role.attrib, local.funcdef.attrib
# end of funcdef.attlist

# end of funcdef.module
local.void.attrib = empty
void.role.attrib = role.attrib
# doc:An empty element in a function synopsis indicating that the function in question takes no arguments.
void = element void { void.attlist, empty }
# end of void.element
void.attlist &= common.attrib, void.role.attrib, local.void.attrib
# end of void.attlist

# end of void.module
local.varargs.attrib = empty
varargs.role.attrib = role.attrib
# doc:An empty element in a function synopsis indicating a variable number of arguments.
varargs = element varargs { varargs.attlist, empty }
# end of varargs.element
varargs.attlist &=
  common.attrib, varargs.role.attrib, local.varargs.attrib
# end of varargs.attlist

# end of varargs.module

# Processing assumes that only one Parameter will appear in a
# ParamDef, and that FuncParams will be used at most once, for
# providing information on the "inner parameters" for parameters that
# are pointers to functions.
local.paramdef.attrib = empty
paramdef.role.attrib = role.attrib
# doc:Information about a function parameter in a programming language.
paramdef =
  element paramdef {
    paramdef.attlist,
    (text | initializer | type | replaceable | parameter | funcparams)*
  }
# end of paramdef.element
paramdef.attlist &=
  attribute choice { "opt" | "req" }?,
  common.attrib,
  paramdef.role.attrib,
  local.paramdef.attrib
# end of paramdef.attlist

# end of paramdef.module
local.funcparams.attrib = empty
funcparams.role.attrib = role.attrib
# doc:Parameters for a function referenced through a function pointer in a synopsis.
funcparams = element funcparams { funcparams.attlist, cptr.char.mix* }
# end of funcparams.element
funcparams.attlist &=
  common.attrib, funcparams.role.attrib, local.funcparams.attrib
# end of funcparams.attlist

# end of funcparams.module

# LineAnnotation (defined in the Inlines section, below)

# Replaceable (defined in the Inlines section, below)

# Function (defined in the Inlines section, below)

# Parameter (defined in the Inlines section, below)

# end of funcsynopsis.content.module

# ClassSynopsis .....................
local.classsynopsis.attrib = empty
classsynopsis.role.attrib = role.attrib
# doc:The syntax summary for a class definition.
classsynopsis =
  element classsynopsis {
    classsynopsis.attlist,
    (ooclass | oointerface | ooexception)+,
    (classsynopsisinfo | fieldsynopsis | method.synop.class)*
  }
# end of classsynopsis.element
classsynopsis.attlist &=
  attribute language { text }?,
  [ a:defaultValue = "class" ]
  attribute class { "class" | "interface" }?,
  common.attrib,
  classsynopsis.role.attrib,
  local.classsynopsis.attrib
# end of classsynopsis.attlist

# end of classsynopsis.module
local.classsynopsisinfo.attrib = empty
classsynopsisinfo.role.attrib = role.attrib
# doc:Information supplementing the contents of a ClassSynopsis.
classsynopsisinfo =
  element classsynopsisinfo {
    classsynopsisinfo.attlist,
    (cptr.char.mix | textobject | lineannotation)*
  }
# end of classsynopsisinfo.element
classsynopsisinfo.attlist &=
  linespecific.attrib,
  common.attrib,
  classsynopsisinfo.role.attrib,
  local.classsynopsisinfo.attrib
# end of classsynopsisinfo.attlist

# end of classsynopsisinfo.module
local.ooclass.attrib = empty
ooclass.role.attrib = role.attrib
# doc:A class in an object-oriented programming language.
ooclass =
  element ooclass { ooclass.attlist, (modifier | package)*, classname }
# end of ooclass.element
ooclass.attlist &=
  common.attrib, ooclass.role.attrib, local.ooclass.attrib
# end of ooclass.attlist

# end of ooclass.module
local.oointerface.attrib = empty
oointerface.role.attrib = role.attrib
# doc:An interface in an object-oriented programming language.
oointerface =
  element oointerface {
    oointerface.attlist, (modifier | package)*, interfacename
  }
# end of oointerface.element
oointerface.attlist &=
  common.attrib, oointerface.role.attrib, local.oointerface.attrib
# end of oointerface.attlist

# end of oointerface.module
local.ooexception.attrib = empty
ooexception.role.attrib = role.attrib
# doc:An exception in an object-oriented programming language.
ooexception =
  element ooexception {
    ooexception.attlist, (modifier | package)*, exceptionname
  }
# end of ooexception.element
ooexception.attlist &=
  common.attrib, ooexception.role.attrib, local.ooexception.attrib
# end of ooexception.attlist

# end of ooexception.module
local.modifier.attrib = empty
modifier.role.attrib = role.attrib
# doc:Modifiers in a synopsis.
modifier = element modifier { modifier.attlist, smallcptr.char.mix* }
# end of modifier.element
modifier.attlist &=
  common.attrib, modifier.role.attrib, local.modifier.attrib
# end of modifier.attlist

# end of modifier.module
local.interfacename.attrib = empty
interfacename.role.attrib = role.attrib
# doc:The name of an interface.
interfacename =
  element interfacename { interfacename.attlist, cptr.char.mix* }
# end of interfacename.element
interfacename.attlist &=
  common.attrib, interfacename.role.attrib, local.interfacename.attrib
# end of interfacename.attlist

# end of interfacename.module
local.exceptionname.attrib = empty
exceptionname.role.attrib = role.attrib
# doc:The name of an exception.
exceptionname =
  element exceptionname { exceptionname.attlist, smallcptr.char.mix* }
# end of exceptionname.element
exceptionname.attlist &=
  common.attrib, exceptionname.role.attrib, local.exceptionname.attrib
# end of exceptionname.attlist

# end of exceptionname.module
local.fieldsynopsis.attrib = empty
fieldsynopsis.role.attrib = role.attrib
# doc:The name of a field in a class definition.
fieldsynopsis =
  element fieldsynopsis {
    fieldsynopsis.attlist, modifier*, type?, varname, initializer?
  }
# end of fieldsynopsis.element
fieldsynopsis.attlist &=
  attribute language { text }?,
  common.attrib,
  fieldsynopsis.role.attrib,
  local.fieldsynopsis.attrib
# end of fieldsynopsis.attlist

# end of fieldsynopsis.module
local.initializer.attrib = empty
initializer.role.attrib = role.attrib
# doc:The initializer for a FieldSynopsis.
initializer =
  element initializer { initializer.attlist, smallcptr.char.mix* }
# end of initializer.element
initializer.attlist &=
  common.attrib, initializer.role.attrib, local.initializer.attrib
# end of initializer.attlist

# end of initializer.module
local.constructorsynopsis.attrib = empty
constructorsynopsis.role.attrib = role.attrib
# doc:A syntax summary for a constructor.
constructorsynopsis =
  element constructorsynopsis {
    constructorsynopsis.attlist,
    modifier*,
    methodname?,
    (methodparam+ | void?),
    exceptionname*
  }
# end of constructorsynopsis.element
constructorsynopsis.attlist &=
  attribute language { text }?,
  common.attrib,
  constructorsynopsis.role.attrib,
  local.constructorsynopsis.attrib
# end of constructorsynopsis.attlist

# end of constructorsynopsis.module
local.destructorsynopsis.attrib = empty
destructorsynopsis.role.attrib = role.attrib
# doc:A syntax summary for a destructor.
destructorsynopsis =
  element destructorsynopsis {
    destructorsynopsis.attlist,
    modifier*,
    methodname?,
    (methodparam+ | void?),
    exceptionname*
  }
# end of destructorsynopsis.element
destructorsynopsis.attlist &=
  attribute language { text }?,
  common.attrib,
  destructorsynopsis.role.attrib,
  local.destructorsynopsis.attrib
# end of destructorsynopsis.attlist

# end of destructorsynopsis.module
local.methodsynopsis.attrib = empty
methodsynopsis.role.attrib = role.attrib
# doc:A syntax summary for a method.
methodsynopsis =
  element methodsynopsis {
    methodsynopsis.attlist,
    modifier*,
    (type | void)?,
    methodname,
    (methodparam+ | void?),
    exceptionname*,
    modifier*
  }
# end of methodsynopsis.element
methodsynopsis.attlist &=
  attribute language { text }?,
  common.attrib,
  methodsynopsis.role.attrib,
  local.methodsynopsis.attrib
# end of methodsynopsis.attlist

# end of methodsynopsis.module
local.methodname.attrib = empty
methodname.role.attrib = role.attrib
# doc:The name of a method.
methodname =
  element methodname { methodname.attlist, smallcptr.char.mix* }
# end of methodname.element
methodname.attlist &=
  common.attrib, methodname.role.attrib, local.methodname.attrib
# end of methodname.attlist

# end of methodname.module
local.methodparam.attrib = empty
methodparam.role.attrib = role.attrib
# doc:Parameters to a method.
methodparam =
  element methodparam {
    methodparam.attlist,
    modifier*,
    type?,
    ((parameter, initializer?) | funcparams),
    modifier*
  }
# end of methodparam.element
methodparam.attlist &=
  [ a:defaultValue = "req" ]
  attribute choice { "opt" | "req" | "plain" }?,
  [ a:defaultValue = "norepeat" ]
  attribute rep { "norepeat" | "repeat" }?,
  common.attrib,
  methodparam.role.attrib,
  local.methodparam.attrib
# end of methodparam.attlist

# end of methodparam.module

# end of classsynopsis.content.module

# ......................................................................

# Document information entities and elements ...........................

# The document information elements include some elements that are
# currently used only in the document hierarchy module. They are
# defined here so that they will be available for use in customized
# document hierarchies.

# ..................................

# Ackno ............................
local.ackno.attrib = empty
ackno.role.attrib = role.attrib
# doc:Acknowledgements in an Article.
ackno = element ackno { ackno.attlist, docinfo.char.mix* }
# end of ackno.element
ackno.attlist &= common.attrib, ackno.role.attrib, local.ackno.attrib
# end of ackno.attlist

# end of ackno.module

# Address ..........................
local.address.attrib = empty
address.role.attrib = role.attrib
# doc:A real-world address, generally a postal address.
address =
  element address {
    address.attlist,
    (text
     | personname
     | person.ident.mix
     | street
     | pob
     | postcode
     | city
     | state
     | country
     | phone
     | fax
     | email
     | otheraddr)*
  }
# end of address.element
address.attlist &=
  linespecific.attrib,
  common.attrib,
  address.role.attrib,
  local.address.attrib
# end of address.attlist

# end of address.module
local.street.attrib = empty
street.role.attrib = role.attrib
# doc:A street address in an address.
street = element street { street.attlist, docinfo.char.mix* }
# end of street.element
street.attlist &= common.attrib, street.role.attrib, local.street.attrib
# end of street.attlist

# end of street.module
local.pob.attrib = empty
pob.role.attrib = role.attrib
# doc:A post office box in an address.
pob = element pob { pob.attlist, docinfo.char.mix* }
# end of pob.element
pob.attlist &= common.attrib, pob.role.attrib, local.pob.attrib
# end of pob.attlist

# end of pob.module
local.postcode.attrib = empty
postcode.role.attrib = role.attrib
# doc:A postal code in an address.
postcode = element postcode { postcode.attlist, docinfo.char.mix* }
# end of postcode.element
postcode.attlist &=
  common.attrib, postcode.role.attrib, local.postcode.attrib
# end of postcode.attlist

# end of postcode.module
local.city.attrib = empty
city.role.attrib = role.attrib
# doc:The name of a city in an address.
city = element city { city.attlist, docinfo.char.mix* }
# end of city.element
city.attlist &= common.attrib, city.role.attrib, local.city.attrib
# end of city.attlist

# end of city.module
local.state.attrib = empty
state.role.attrib = role.attrib
# doc:A state or province in an address.
state = element state { state.attlist, docinfo.char.mix* }
# end of state.element
state.attlist &= common.attrib, state.role.attrib, local.state.attrib
# end of state.attlist

# end of state.module
local.country.attrib = empty
country.role.attrib = role.attrib
# doc:The name of a country.
country = element country { country.attlist, docinfo.char.mix* }
# end of country.element
country.attlist &=
  common.attrib, country.role.attrib, local.country.attrib
# end of country.attlist

# end of country.module
local.phone.attrib = empty
phone.role.attrib = role.attrib
# doc:A telephone number.
phone = element phone { phone.attlist, docinfo.char.mix* }
# end of phone.element
phone.attlist &= common.attrib, phone.role.attrib, local.phone.attrib
# end of phone.attlist

# end of phone.module
local.fax.attrib = empty
fax.role.attrib = role.attrib
# doc:A fax number.
fax = element fax { fax.attlist, docinfo.char.mix* }
# end of fax.element
fax.attlist &= common.attrib, fax.role.attrib, local.fax.attrib
# end of fax.attlist

# end of fax.module

# Email (defined in the Inlines section, below)
local.otheraddr.attrib = empty
otheraddr.role.attrib = role.attrib
# doc:Uncategorized information in address.
otheraddr = element otheraddr { otheraddr.attlist, docinfo.char.mix* }
# end of otheraddr.element
otheraddr.attlist &=
  common.attrib, otheraddr.role.attrib, local.otheraddr.attrib
# end of otheraddr.attlist

# end of otheraddr.module

# end of address.content.module

# Affiliation ......................
local.affiliation.attrib = empty
affiliation.role.attrib = role.attrib
# doc:The institutional affiliation of an individual.
affiliation =
  element affiliation {
    affiliation.attlist,
    shortaffil?,
    jobtitle*,
    orgname?,
    orgdiv*,
    address*
  }
# end of affiliation.element
affiliation.attlist &=
  common.attrib, affiliation.role.attrib, local.affiliation.attrib
# end of affiliation.attlist

# end of affiliation.module
local.shortaffil.attrib = empty
shortaffil.role.attrib = role.attrib
# doc:A brief description of an affiliation.
shortaffil =
  element shortaffil { shortaffil.attlist, docinfo.char.mix* }
# end of shortaffil.element
shortaffil.attlist &=
  common.attrib, shortaffil.role.attrib, local.shortaffil.attrib
# end of shortaffil.attlist

# end of shortaffil.module
local.jobtitle.attrib = empty
jobtitle.role.attrib = role.attrib
# doc:The title of an individual in an organization.
jobtitle = element jobtitle { jobtitle.attlist, docinfo.char.mix* }
# end of jobtitle.element
jobtitle.attlist &=
  common.attrib, jobtitle.role.attrib, local.jobtitle.attrib
# end of jobtitle.attlist

# end of jobtitle.module

# OrgName (defined elsewhere in this section)
local.orgdiv.attrib = empty
orgdiv.role.attrib = role.attrib
# doc:A division of an organization.
orgdiv = element orgdiv { orgdiv.attlist, docinfo.char.mix* }
# end of orgdiv.element
orgdiv.attlist &= common.attrib, orgdiv.role.attrib, local.orgdiv.attrib
# end of orgdiv.attlist

# end of orgdiv.module

# Address (defined elsewhere in this section)

# end of affiliation.content.module

# ArtPageNums ......................
local.artpagenums.attrib = empty
artpagenums.role.attrib = role.attrib
# doc:The page numbers of an article as published.
artpagenums =
  element artpagenums { artpagenums.attlist, docinfo.char.mix* }
# end of artpagenums.element
artpagenums.attlist &=
  common.attrib, artpagenums.role.attrib, local.artpagenums.attrib
# end of artpagenums.attlist

# end of artpagenums.module

# PersonName
local.personname.attrib = empty
personname.role.attrib = role.attrib
# doc:The personal name of an individual.
personname =
  element personname {
    personname.attlist,
    (honorific | firstname | surname | lineage | othername)+
  }
# end of personname.element
personname.attlist &=
  common.attrib, personname.role.attrib, local.personname.attrib
# end of personname.attlist

# end of personname.module

# Author ...........................
local.author.attrib = empty
author.role.attrib = role.attrib
# doc:The name of an individual author.
author =
  element author {
    author.attlist,
    (personname | person.ident.mix+),
    (personblurb | email | address)*
  }
# end of author.element
author.attlist &= common.attrib, author.role.attrib, local.author.attrib
# end of author.attlist

# (see "Personal identity elements" for %person.ident.mix;)

# end of author.module

# AuthorGroup ......................
local.authorgroup.attrib = empty
authorgroup.role.attrib = role.attrib
# doc:Wrapper for author information when a document has multiple authors or collabarators.
authorgroup =
  element authorgroup {
    authorgroup.attlist,
    (author | editor | collab | corpauthor | corpcredit | othercredit)+
  }
# end of authorgroup.element
authorgroup.attlist &=
  common.attrib, authorgroup.role.attrib, local.authorgroup.attrib
# end of authorgroup.attlist

# end of authorgroup.module

# Author (defined elsewhere in this section)

# Editor (defined elsewhere in this section)
local.collab.attrib = empty
collab.role.attrib = role.attrib
# doc:Identifies a collaborator.
collab = element collab { collab.attlist, collabname, affiliation* }
# end of collab.element
collab.attlist &= common.attrib, collab.role.attrib, local.collab.attrib
# end of collab.attlist

# end of collab.module
local.collabname.attrib = empty
collabname.role.attrib = role.attrib
# doc:The name of a collaborator.
collabname =
  element collabname { collabname.attlist, docinfo.char.mix* }
# end of collabname.element
collabname.attlist &=
  common.attrib, collabname.role.attrib, local.collabname.attrib
# end of collabname.attlist

# end of collabname.module

# Affiliation (defined elsewhere in this section)

# end of collab.content.module

# CorpAuthor (defined elsewhere in this section)

# OtherCredit (defined elsewhere in this section)

# end of authorgroup.content.module

# AuthorInitials ...................
local.authorinitials.attrib = empty
authorinitials.role.attrib = role.attrib
# doc:The initials or other short identifier for an author.
authorinitials =
  element authorinitials { authorinitials.attlist, docinfo.char.mix* }
# end of authorinitials.element
authorinitials.attlist &=
  common.attrib, authorinitials.role.attrib, local.authorinitials.attrib
# end of authorinitials.attlist

# end of authorinitials.module

# ConfGroup ........................
local.confgroup.attrib = empty
confgroup.role.attrib = role.attrib
# doc:A wrapper for document meta-information about a conference.
confgroup =
  element confgroup {
    confgroup.attlist,
    (confdates | conftitle | confnum | address | confsponsor)*
  }
# end of confgroup.element
confgroup.attlist &=
  common.attrib, confgroup.role.attrib, local.confgroup.attrib
# end of confgroup.attlist

# end of confgroup.module
local.confdates.attrib = empty
confdates.role.attrib = role.attrib
# doc:The dates of a conference for which a document was written.
confdates = element confdates { confdates.attlist, docinfo.char.mix* }
# end of confdates.element
confdates.attlist &=
  common.attrib, confdates.role.attrib, local.confdates.attrib
# end of confdates.attlist

# end of confdates.module
local.conftitle.attrib = empty
conftitle.role.attrib = role.attrib
# doc:The title of a conference for which a document was written.
conftitle = element conftitle { conftitle.attlist, docinfo.char.mix* }
# end of conftitle.element
conftitle.attlist &=
  common.attrib, conftitle.role.attrib, local.conftitle.attrib
# end of conftitle.attlist

# end of conftitle.module
local.confnum.attrib = empty
confnum.role.attrib = role.attrib
# doc:An identifier, frequently numerical, associated with a conference for which a document was written.
confnum = element confnum { confnum.attlist, docinfo.char.mix* }
# end of confnum.element
confnum.attlist &=
  common.attrib, confnum.role.attrib, local.confnum.attrib
# end of confnum.attlist

# end of confnum.module

# Address (defined elsewhere in this section)
local.confsponsor.attrib = empty
confsponsor.role.attrib = role.attrib
# doc:The sponsor of a conference for which a document was written.
confsponsor =
  element confsponsor { confsponsor.attlist, docinfo.char.mix* }
# end of confsponsor.element
confsponsor.attlist &=
  common.attrib, confsponsor.role.attrib, local.confsponsor.attrib
# end of confsponsor.attlist

# end of confsponsor.module

# end of confgroup.content.module

# ContractNum ......................
local.contractnum.attrib = empty
contractnum.role.attrib = role.attrib
# doc:The contract number of a document.
contractnum =
  element contractnum { contractnum.attlist, docinfo.char.mix* }
# end of contractnum.element
contractnum.attlist &=
  common.attrib, contractnum.role.attrib, local.contractnum.attrib
# end of contractnum.attlist

# end of contractnum.module

# ContractSponsor ..................
local.contractsponsor.attrib = empty
contractsponsor.role.attrib = role.attrib
# doc:The sponsor of a contract.
contractsponsor =
  element contractsponsor { contractsponsor.attlist, docinfo.char.mix* }
# end of contractsponsor.element
contractsponsor.attlist &=
  common.attrib,
  contractsponsor.role.attrib,
  local.contractsponsor.attrib
# end of contractsponsor.attlist

# end of contractsponsor.module

# Copyright ........................
local.copyright.attrib = empty
copyright.role.attrib = role.attrib
# doc:Copyright information about a document.
copyright = element copyright { copyright.attlist, year+, holder* }
# end of copyright.element
copyright.attlist &=
  common.attrib, copyright.role.attrib, local.copyright.attrib
# end of copyright.attlist

# end of copyright.module
local.year.attrib = empty
year.role.attrib = role.attrib
# doc:The year of publication of a document.
year = element year { year.attlist, docinfo.char.mix* }
# end of year.element
year.attlist &= common.attrib, year.role.attrib, local.year.attrib
# end of year.attlist

# end of year.module
local.holder.attrib = empty
holder.role.attrib = role.attrib
# doc:The name of the individual or organization that holds a copyright.
holder = element holder { holder.attlist, docinfo.char.mix* }
# end of holder.element
holder.attlist &= common.attrib, holder.role.attrib, local.holder.attrib
# end of holder.attlist

# end of holder.module

# end of copyright.content.module

# CorpAuthor .......................
local.corpauthor.attrib = empty
corpauthor.role.attrib = role.attrib
# doc:A corporate author, as opposed to an individual.
corpauthor =
  element corpauthor { corpauthor.attlist, docinfo.char.mix* }
# end of corpauthor.element
corpauthor.attlist &=
  common.attrib, corpauthor.role.attrib, local.corpauthor.attrib
# end of corpauthor.attlist

# end of corpauthor.module

# CorpCredit ......................
local.corpcredit.attrib = empty
corpcredit.role.attrib = role.attrib
# doc:A corporation or organization credited in a document.
corpcredit =
  element corpcredit { corpcredit.attlist, docinfo.char.mix* }
# end of corpcredit.element
corpcredit.attlist &=
  attribute class {
    "graphicdesigner"
    | "productioneditor"
    | "copyeditor"
    | "technicaleditor"
    | "translator"
    | "other"
  }?,
  common.attrib,
  corpcredit.role.attrib,
  local.corpcredit.attrib
# end of corpcredit.attlist

# end of corpcredit.module

# CorpName .........................
local.corpname.attrib = empty
# doc:The name of a corporation.
corpname = element corpname { corpname.attlist, docinfo.char.mix* }
# end of corpname.element
corpname.role.attrib = role.attrib
corpname.attlist &=
  common.attrib, corpname.role.attrib, local.corpname.attrib
# end of corpname.attlist

# end of corpname.module

# Date .............................
local.date.attrib = empty
date.role.attrib = role.attrib
# doc:The date of publication or revision of a document.
date = element date { date.attlist, docinfo.char.mix* }
# end of date.element
date.attlist &= common.attrib, date.role.attrib, local.date.attrib
# end of date.attlist

# end of date.module

# Edition ..........................
local.edition.attrib = empty
edition.role.attrib = role.attrib
# doc:The name or number of an edition of a document.
edition = element edition { edition.attlist, docinfo.char.mix* }
# end of edition.element
edition.attlist &=
  common.attrib, edition.role.attrib, local.edition.attrib
# end of edition.attlist

# end of edition.module

# Editor ...........................
local.editor.attrib = empty
editor.role.attrib = role.attrib
# doc:The name of the editor of a document.
editor =
  element editor {
    editor.attlist,
    (personname | person.ident.mix+),
    (personblurb | email | address)*
  }
# end of editor.element
editor.attlist &= common.attrib, editor.role.attrib, local.editor.attrib
# end of editor.attlist

# (see "Personal identity elements" for %person.ident.mix;)

# end of editor.module

# ISBN .............................
local.isbn.attrib = empty
isbn.role.attrib = role.attrib
# doc:The International Standard Book Number of a document.
isbn = element isbn { isbn.attlist, docinfo.char.mix* }
# end of isbn.element
isbn.attlist &= common.attrib, isbn.role.attrib, local.isbn.attrib
# end of isbn.attlist

# end of isbn.module

# ISSN .............................
local.issn.attrib = empty
issn.role.attrib = role.attrib
# doc:The International Standard Serial Number of a periodical.
issn = element issn { issn.attlist, docinfo.char.mix* }
# end of issn.element
issn.attlist &= common.attrib, issn.role.attrib, local.issn.attrib
# end of issn.attlist

# end of issn.module

# BiblioId .................
biblio.class.attrib =
  attribute class {
    "uri"
    | "doi"
    | "isbn"
    | "isrn"
    | "issn"
    | "libraryofcongress"
    | "pubnumber"
    | "other"
  }?,
  attribute otherclass { text }?
local.biblioid.attrib = empty
biblioid.role.attrib = role.attrib
# doc:An identifier for a document.
biblioid = element biblioid { biblioid.attlist, docinfo.char.mix* }
# end of biblioid.element
biblioid.attlist &=
  biblio.class.attrib,
  common.attrib,
  biblioid.role.attrib,
  local.biblioid.attrib
# end of biblioid.attlist

# end of biblioid.module

# CiteBiblioId .................
local.citebiblioid.attrib = empty
citebiblioid.role.attrib = role.attrib
# doc:A citation of a bibliographic identifier.
citebiblioid =
  element citebiblioid { citebiblioid.attlist, docinfo.char.mix* }
# end of citebiblioid.element
citebiblioid.attlist &=
  biblio.class.attrib,
  common.attrib,
  citebiblioid.role.attrib,
  local.citebiblioid.attrib
# end of citebiblioid.attlist

# end of citebiblioid.module

# BiblioSource .................
local.bibliosource.attrib = empty
bibliosource.role.attrib = role.attrib
# doc:The source of a document.
bibliosource =
  element bibliosource { bibliosource.attlist, docinfo.char.mix* }
# end of bibliosource.element
bibliosource.attlist &=
  biblio.class.attrib,
  common.attrib,
  bibliosource.role.attrib,
  local.bibliosource.attrib
# end of bibliosource.attlist

# end of bibliosource.module

# BiblioRelation .................
local.bibliorelation.attrib = empty
local.bibliorelation.types = notAllowed
bibliorelation.type.attrib =
  attribute type {
    "isversionof"
    | "hasversion"
    | "isreplacedby"
    | "replaces"
    | "isrequiredby"
    | "requires"
    | "ispartof"
    | "haspart"
    | "isreferencedby"
    | "references"
    | "isformatof"
    | "hasformat"
    | "othertype"
    | local.bibliorelation.types
  }?,
  attribute othertype { text }?
bibliorelation.role.attrib = role.attrib
# doc:The relationship of a document to another.
bibliorelation =
  element bibliorelation { bibliorelation.attlist, docinfo.char.mix* }
# end of bibliorelation.element
bibliorelation.attlist &=
  biblio.class.attrib,
  bibliorelation.type.attrib,
  common.attrib,
  bibliorelation.role.attrib,
  local.bibliorelation.attrib
# end of bibliorelation.attlist

# end of bibliorelation.module

# BiblioCoverage .................
local.bibliocoverage.attrib = empty
bibliocoverage.role.attrib = role.attrib
# doc:The spatial or temporal coverage of a document.
bibliocoverage =
  element bibliocoverage { bibliocoverage.attlist, docinfo.char.mix* }
# end of bibliocoverage.element
bibliocoverage.attlist &=
  attribute spatial {
    "dcmipoint" | "iso3166" | "dcmibox" | "tgn" | "otherspatial"
  }?,
  attribute otherspatial { text }?,
  attribute temporal { "dcmiperiod" | "w3c-dtf" | "othertemporal" }?,
  attribute othertemporal { text }?,
  common.attrib,
  bibliocoverage.role.attrib,
  local.bibliocoverage.attrib
# end of bibliocoverage.attlist

# end of bibliocoverage.module

# InvPartNumber ....................
local.invpartnumber.attrib = empty
invpartnumber.role.attrib = role.attrib
# doc:An inventory part number.
invpartnumber =
  element invpartnumber { invpartnumber.attlist, docinfo.char.mix* }
# end of invpartnumber.element
invpartnumber.attlist &=
  common.attrib, invpartnumber.role.attrib, local.invpartnumber.attrib
# end of invpartnumber.attlist

# end of invpartnumber.module

# IssueNum .........................
local.issuenum.attrib = empty
issuenum.role.attrib = role.attrib
# doc:The number of an issue of a journal.
issuenum = element issuenum { issuenum.attlist, docinfo.char.mix* }
# end of issuenum.element
issuenum.attlist &=
  common.attrib, issuenum.role.attrib, local.issuenum.attrib
# end of issuenum.attlist

# end of issuenum.module

# LegalNotice ......................
local.legalnotice.attrib = empty
legalnotice.role.attrib = role.attrib
# doc:A statement of legal obligations or requirements.
legalnotice =
  element legalnotice {
    legalnotice.attlist, blockinfo?, title?, legalnotice.mix+
  }
# end of legalnotice.element
legalnotice.attlist &=
  common.attrib, legalnotice.role.attrib, local.legalnotice.attrib
# end of legalnotice.attlist

# end of legalnotice.module

# ModeSpec .........................
local.modespec.attrib = empty
modespec.role.attrib = role.attrib
# doc:Application-specific information necessary for the completion of an OLink.
modespec = element modespec { modespec.attlist, docinfo.char.mix* }
# end of modespec.element

# Application: Type of action required for completion
# of the links to which the ModeSpec is relevant (e.g.,
# retrieval query)
modespec.attlist &=
  attribute application { notation.class }?,
  common.attrib,
  modespec.role.attrib,
  local.modespec.attrib
# end of modespec.attlist

# end of modespec.module

# OrgName ..........................
local.orgname.attrib = empty
orgname.role.attrib = role.attrib
# doc:The name of an organization other than a corporation.
orgname = element orgname { orgname.attlist, docinfo.char.mix* }
# end of orgname.element
orgname.attlist &=
  common.attrib,
  attribute class {
    "corporation" | "nonprofit" | "consortium" | "informal" | "other"
  }?,
  attribute otherclass { text }?,
  orgname.role.attrib,
  local.orgname.attrib
# end of orgname.attlist

# end of orgname.module

# OtherCredit ......................
local.othercredit.attrib = empty
othercredit.role.attrib = role.attrib
# doc:A person or entity, other than an author or editor, credited in a document.
othercredit =
  element othercredit {
    othercredit.attlist,
    (personname | person.ident.mix+),
    (personblurb | email | address)*
  }
# end of othercredit.element
othercredit.attlist &=
  attribute class {
    "graphicdesigner"
    | "productioneditor"
    | "copyeditor"
    | "technicaleditor"
    | "translator"
    | "other"
  }?,
  common.attrib,
  othercredit.role.attrib,
  local.othercredit.attrib
# end of othercredit.attlist

# (see "Personal identity elements" for %person.ident.mix;)

# end of othercredit.module

# PageNums .........................
local.pagenums.attrib = empty
pagenums.role.attrib = role.attrib
# doc:The numbers of the pages in a book, for use in a bibliographic entry.
pagenums = element pagenums { pagenums.attlist, docinfo.char.mix* }
# end of pagenums.element
pagenums.attlist &=
  common.attrib, pagenums.role.attrib, local.pagenums.attrib
# end of pagenums.attlist

# end of pagenums.module

# Personal identity elements .......

# These elements are used only within Author, Editor, and
# OtherCredit.
local.contrib.attrib = empty
contrib.role.attrib = role.attrib
# doc:A summary of the contributions made to a document by a credited source.
contrib = element contrib { contrib.attlist, docinfo.char.mix* }
# end of contrib.element
contrib.attlist &=
  common.attrib, contrib.role.attrib, local.contrib.attrib
# end of contrib.attlist

# end of contrib.module
local.firstname.attrib = empty
firstname.role.attrib = role.attrib
# doc:The first name of a person.
firstname = element firstname { firstname.attlist, docinfo.char.mix* }
# end of firstname.element
firstname.attlist &=
  common.attrib, firstname.role.attrib, local.firstname.attrib
# end of firstname.attlist

# end of firstname.module
local.honorific.attrib = empty
honorific.role.attrib = role.attrib
# doc:The title of a person.
honorific = element honorific { honorific.attlist, docinfo.char.mix* }
# end of honorific.element
honorific.attlist &=
  common.attrib, honorific.role.attrib, local.honorific.attrib
# end of honorific.attlist

# end of honorific.module
local.lineage.attrib = empty
lineage.role.attrib = role.attrib
# doc:The portion of a person's name indicating a relationship to ancestors.
lineage = element lineage { lineage.attlist, docinfo.char.mix* }
# end of lineage.element
lineage.attlist &=
  common.attrib, lineage.role.attrib, local.lineage.attrib
# end of lineage.attlist

# end of lineage.module
local.othername.attrib = empty
othername.role.attrib = role.attrib
# doc:A component of a persons name that is not a first name, surname, or lineage.
othername = element othername { othername.attlist, docinfo.char.mix* }
# end of othername.element
othername.attlist &=
  common.attrib, othername.role.attrib, local.othername.attrib
# end of othername.attlist

# end of othername.module
local.surname.attrib = empty
surname.role.attrib = role.attrib
# doc:A family name; in western cultures the last name.
surname = element surname { surname.attlist, docinfo.char.mix* }
# end of surname.element
surname.attlist &=
  common.attrib, surname.role.attrib, local.surname.attrib
# end of surname.attlist

# end of surname.module

# end of person.ident.module

# PrintHistory .....................
local.printhistory.attrib = empty
printhistory.role.attrib = role.attrib
# doc:The printing history of a document.
printhistory =
  element printhistory { printhistory.attlist, para.class+ }
# end of printhistory.element
printhistory.attlist &=
  common.attrib, printhistory.role.attrib, local.printhistory.attrib
# end of printhistory.attlist

# end of printhistory.module

# ProductName ......................
local.productname.attrib = empty
productname.role.attrib = role.attrib
# doc:The formal name of a product.
productname =
  element productname { productname.attlist, para.char.mix* }
# end of productname.element

# Class: More precisely identifies the item the element names
productname.attlist &=
  [ a:defaultValue = "trade" ]
  attribute class { "service" | "trade" | "registered" | "copyright" }?,
  common.attrib,
  productname.role.attrib,
  local.productname.attrib
# end of productname.attlist

# end of productname.module

# ProductNumber ....................
local.productnumber.attrib = empty
productnumber.role.attrib = role.attrib
# doc:A number assigned to a product.
productnumber =
  element productnumber { productnumber.attlist, docinfo.char.mix* }
# end of productnumber.element
productnumber.attlist &=
  common.attrib, productnumber.role.attrib, local.productnumber.attrib
# end of productnumber.attlist

# end of productnumber.module

# PubDate ..........................
local.pubdate.attrib = empty
pubdate.role.attrib = role.attrib
# doc:The date of publication of a document.
pubdate = element pubdate { pubdate.attlist, docinfo.char.mix* }
# end of pubdate.element
pubdate.attlist &=
  common.attrib, pubdate.role.attrib, local.pubdate.attrib
# end of pubdate.attlist

# end of pubdate.module

# Publisher ........................
local.publisher.attrib = empty
publisher.role.attrib = role.attrib
# doc:The publisher of a document.
publisher =
  element publisher { publisher.attlist, publishername, address* }
# end of publisher.element
publisher.attlist &=
  common.attrib, publisher.role.attrib, local.publisher.attrib
# end of publisher.attlist

# end of publisher.module
local.publishername.attrib = empty
publishername.role.attrib = role.attrib
# doc:The name of the publisher of a document.
publishername =
  element publishername { publishername.attlist, docinfo.char.mix* }
# end of publishername.element
publishername.attlist &=
  common.attrib, publishername.role.attrib, local.publishername.attrib
# end of publishername.attlist

# end of publishername.module

# Address (defined elsewhere in this section)

# end of publisher.content.module

# PubsNumber .......................
local.pubsnumber.attrib = empty
pubsnumber.role.attrib = role.attrib
# doc:A number assigned to a publication other than an ISBN or ISSN or inventory part number.
pubsnumber =
  element pubsnumber { pubsnumber.attlist, docinfo.char.mix* }
# end of pubsnumber.element
pubsnumber.attlist &=
  common.attrib, pubsnumber.role.attrib, local.pubsnumber.attrib
# end of pubsnumber.attlist

# end of pubsnumber.module

# ReleaseInfo ......................
local.releaseinfo.attrib = empty
releaseinfo.role.attrib = role.attrib
# doc:Information about a particular release of a document.
releaseinfo =
  element releaseinfo { releaseinfo.attlist, docinfo.char.mix* }
# end of releaseinfo.element
releaseinfo.attlist &=
  common.attrib, releaseinfo.role.attrib, local.releaseinfo.attrib
# end of releaseinfo.attlist

# end of releaseinfo.module

# RevHistory .......................
local.revhistory.attrib = empty
revhistory.role.attrib = role.attrib
# doc:A history of the revisions to a document.
revhistory = element revhistory { revhistory.attlist, revision+ }
# end of revhistory.element
revhistory.attlist &=
  common.attrib, revhistory.role.attrib, local.revhistory.attrib
# end of revhistory.attlist

# end of revhistory.module
local.revision.attrib = empty
revision.role.attrib = role.attrib
# doc:An entry describing a single revision in the history of the revisions to a document.
revision =
  element revision {
    revision.attlist,
    revnumber?,
    date,
    (author | authorinitials)*,
    (revremark | revdescription)?
  }
# end of revision.element
revision.attlist &=
  common.attrib, revision.role.attrib, local.revision.attrib
# end of revision.attlist

# end of revision.module
local.revnumber.attrib = empty
revnumber.role.attrib = role.attrib
# doc:A document revision number.
revnumber = element revnumber { revnumber.attlist, docinfo.char.mix* }
# end of revnumber.element
revnumber.attlist &=
  common.attrib, revnumber.role.attrib, local.revnumber.attrib
# end of revnumber.attlist

# end of revnumber.module

# Date (defined elsewhere in this section)

# AuthorInitials (defined elsewhere in this section)
local.revremark.attrib = empty
revremark.role.attrib = role.attrib
# doc:A description of a revision to a document.
revremark = element revremark { revremark.attlist, docinfo.char.mix* }
# end of revremark.element
revremark.attlist &=
  common.attrib, revremark.role.attrib, local.revremark.attrib
# end of revremark.attlist

# end of revremark.module
local.revdescription.attrib = empty
revdescription.role.attrib = role.attrib
# doc:A extended description of a revision to a document.
revdescription =
  element revdescription { revdescription.attlist, revdescription.mix+ }
# end of revdescription.element
revdescription.attlist &=
  common.attrib, revdescription.role.attrib, local.revdescription.attrib
# end of revdescription.attlist

# end of revdescription.module

# end of revhistory.content.module

# SeriesVolNums ....................
local.seriesvolnums.attrib = empty
seriesvolnums.role.attrib = role.attrib
# doc:Numbers of the volumes in a series of books.
seriesvolnums =
  element seriesvolnums { seriesvolnums.attlist, docinfo.char.mix* }
# end of seriesvolnums.element
seriesvolnums.attlist &=
  common.attrib, seriesvolnums.role.attrib, local.seriesvolnums.attrib
# end of seriesvolnums.attlist

# end of seriesvolnums.module

# VolumeNum ........................
local.volumenum.attrib = empty
volumenum.role.attrib = role.attrib
# doc:The volume number of a document in a set (as of books in a set or articles in a journal).
volumenum = element volumenum { volumenum.attlist, docinfo.char.mix* }
# end of volumenum.element
volumenum.attlist &=
  common.attrib, volumenum.role.attrib, local.volumenum.attrib
# end of volumenum.attlist

# end of volumenum.module

# ..................................

# end of docinfo.content.module

# ......................................................................

# Inline, link, and ubiquitous elements ................................

# Technical and computer terms .........................................
local.accel.attrib = empty
accel.role.attrib = role.attrib
# doc:A graphical user interface (GUI) keyboard shortcut.
accel = element accel { accel.attlist, smallcptr.char.mix* }
# end of accel.element
accel.attlist &= common.attrib, accel.role.attrib, local.accel.attrib
# end of accel.attlist

# end of accel.module
local.action.attrib = empty
action.role.attrib = role.attrib
# doc:A response to a user event.
action = element action { action.attlist, cptr.char.mix* }
# end of action.element
action.attlist &=
  moreinfo.attrib,
  common.attrib,
  action.role.attrib,
  local.action.attrib
# end of action.attlist

# end of action.module
local.application.attrib = empty
application.role.attrib = role.attrib
# doc:The name of a software program.
application =
  element application { application.attlist, para.char.mix* }
# end of application.element
application.attlist &=
  attribute class { "hardware" | "software" }?,
  moreinfo.attrib,
  common.attrib,
  application.role.attrib,
  local.application.attrib
# end of application.attlist

# end of application.module
local.classname.attrib = empty
classname.role.attrib = role.attrib
# doc:The name of a class, in the object-oriented programming sense.
classname = element classname { classname.attlist, smallcptr.char.mix* }
# end of classname.element
classname.attlist &=
  common.attrib, classname.role.attrib, local.classname.attrib
# end of classname.attlist

# end of classname.module
local.package.attrib = empty
package.role.attrib = role.attrib
# doc:A package.
package = element package { package.attlist, smallcptr.char.mix* }
# end of package.element
package.attlist &=
  common.attrib, package.role.attrib, local.package.attrib
# end of package.attlist

# end of package.module
local.co.attrib = empty
# CO is a callout area of the LineColumn unit type (a single character
# position); the position is directly indicated by the location of CO.
co.role.attrib = role.attrib
# doc:The location of a callout embedded in text.
co = element co { co.attlist, empty }
# end of co.element

# bug number/symbol override or initialization

# to any related information
co.attlist &=
  label.attrib,
  linkends.attrib,
  idreq.common.attrib,
  co.role.attrib,
  local.co.attrib
# end of co.attlist

# end of co.module
local.coref.attrib = empty
# COREF is a reference to a CO
coref.role.attrib = role.attrib
# doc:A cross reference to a co.
coref = element coref { coref.attlist, empty }
# end of coref.element

# bug number/symbol override or initialization

# to any related information
coref.attlist &=
  label.attrib,
  linkendreq.attrib,
  common.attrib,
  coref.role.attrib,
  local.coref.attrib
# end of coref.attlist

# end of coref.module
local.command.attrib = empty
command.role.attrib = role.attrib
# doc:The name of an executable program or other software command.
command = element command { command.attlist, cptr.char.mix* }
# end of command.element
command.attlist &=
  moreinfo.attrib,
  common.attrib,
  command.role.attrib,
  local.command.attrib
# end of command.attlist

# end of command.module
local.computeroutput.attrib = empty
computeroutput.role.attrib = role.attrib
# doc:Data, generally text, displayed or presented by a computer.
computeroutput =
  element computeroutput {
    computeroutput.attlist, (cptr.char.mix | co)*
  }
# end of computeroutput.element
computeroutput.attlist &=
  moreinfo.attrib,
  common.attrib,
  computeroutput.role.attrib,
  local.computeroutput.attrib
# end of computeroutput.attlist

# end of computeroutput.module
local.database.attrib = empty
database.role.attrib = role.attrib
# doc:The name of a database, or part of a database.
database = element database { database.attlist, cptr.char.mix* }
# end of database.element

# Class: Type of database the element names; no default
database.attlist &=
  attribute class {
    "name"
    | "table"
    | "field"
    | "key1"
    | "key2"
    | "record"
    | "index"
    | "view"
    | "primarykey"
    | "secondarykey"
    | "foreignkey"
    | "altkey"
    | "procedure"
    | "datatype"
    | "constraint"
    | "rule"
    | "user"
    | "group"
  }?,
  moreinfo.attrib,
  common.attrib,
  database.role.attrib,
  local.database.attrib
# end of database.attlist

# end of database.module
local.email.attrib = empty
email.role.attrib = role.attrib
# doc:An email address.
email = element email { email.attlist, docinfo.char.mix* }
# end of email.element
email.attlist &= common.attrib, email.role.attrib, local.email.attrib
# end of email.attlist

# end of email.module
local.envar.attrib = empty
envar.role.attrib = role.attrib
# doc:A software environment variable.
envar = element envar { envar.attlist, smallcptr.char.mix* }
# end of envar.element
envar.attlist &= common.attrib, envar.role.attrib, local.envar.attrib
# end of envar.attlist

# end of envar.module
local.errorcode.attrib = empty
errorcode.role.attrib = role.attrib
# doc:An error code.
errorcode = element errorcode { errorcode.attlist, smallcptr.char.mix* }
# end of errorcode.element
errorcode.attlist &=
  moreinfo.attrib,
  common.attrib,
  errorcode.role.attrib,
  local.errorcode.attrib
# end of errorcode.attlist

# end of errorcode.module
local.errorname.attrib = empty
errorname.role.attrib = role.attrib
# doc:An error name.
errorname = element errorname { errorname.attlist, smallcptr.char.mix* }
# end of errorname.element
errorname.attlist &=
  common.attrib, errorname.role.attrib, local.errorname.attrib
# end of errorname.attlist

# end of errorname.module
local.errortext.attrib = empty
errortext.role.attrib = role.attrib
# doc:An error message..
errortext = element errortext { errortext.attlist, smallcptr.char.mix* }
# end of errortext.element
errortext.attlist &=
  common.attrib, errortext.role.attrib, local.errortext.attrib
# end of errortext.attlist

# end of errortext.module
local.errortype.attrib = empty
errortype.role.attrib = role.attrib
# doc:The classification of an error message.
errortype = element errortype { errortype.attlist, smallcptr.char.mix* }
# end of errortype.element
errortype.attlist &=
  common.attrib, errortype.role.attrib, local.errortype.attrib
# end of errortype.attlist

# end of errortype.module
local.filename.attrib = empty
filename.role.attrib = role.attrib
# doc:The name of a file.
filename = element filename { filename.attlist, cptr.char.mix* }
# end of filename.element

# Class: Type of filename the element names; no default

# Path: Search path (possibly system-specific) in which
# file can be found
filename.attlist &=
  attribute class {
    "headerfile"
    | "partition"
    | "devicefile"
    | "libraryfile"
    | "directory"
    | "extension"
    | "symlink"
  }?,
  attribute path { text }?,
  moreinfo.attrib,
  common.attrib,
  filename.role.attrib,
  local.filename.attrib
# end of filename.attlist

# end of filename.module
local.function.attrib = empty
function.role.attrib = role.attrib
# doc:The name of a function or subroutine, as in a programming language.
function = element function { function.attlist, cptr.char.mix* }
# end of function.element
function.attlist &=
  moreinfo.attrib,
  common.attrib,
  function.role.attrib,
  local.function.attrib
# end of function.attlist

# end of function.module
local.guibutton.attrib = empty
guibutton.role.attrib = role.attrib
# doc:The text on a button in a GUI.
guibutton =
  element guibutton {
    guibutton.attlist,
    (smallcptr.char.mix | accel | superscript | subscript)*
  }
# end of guibutton.element
guibutton.attlist &=
  moreinfo.attrib,
  common.attrib,
  guibutton.role.attrib,
  local.guibutton.attrib
# end of guibutton.attlist

# end of guibutton.module
local.guiicon.attrib = empty
guiicon.role.attrib = role.attrib
# doc:Graphic and/or text appearing as a icon in a GUI.
guiicon =
  element guiicon {
    guiicon.attlist,
    (smallcptr.char.mix | accel | superscript | subscript)*
  }
# end of guiicon.element
guiicon.attlist &=
  moreinfo.attrib,
  common.attrib,
  guiicon.role.attrib,
  local.guiicon.attrib
# end of guiicon.attlist

# end of guiicon.module
local.guilabel.attrib = empty
guilabel.role.attrib = role.attrib
# doc:The text of a label in a GUI.
guilabel =
  element guilabel {
    guilabel.attlist,
    (smallcptr.char.mix | accel | superscript | subscript)*
  }
# end of guilabel.element
guilabel.attlist &=
  moreinfo.attrib,
  common.attrib,
  guilabel.role.attrib,
  local.guilabel.attrib
# end of guilabel.attlist

# end of guilabel.module
local.guimenu.attrib = empty
guimenu.role.attrib = role.attrib
# doc:The name of a menu in a GUI.
guimenu =
  element guimenu {
    guimenu.attlist,
    (smallcptr.char.mix | accel | superscript | subscript)*
  }
# end of guimenu.element
guimenu.attlist &=
  moreinfo.attrib,
  common.attrib,
  guimenu.role.attrib,
  local.guimenu.attrib
# end of guimenu.attlist

# end of guimenu.module
local.guimenuitem.attrib = empty
guimenuitem.role.attrib = role.attrib
# doc:The name of a terminal menu item in a GUI.
guimenuitem =
  element guimenuitem {
    guimenuitem.attlist,
    (smallcptr.char.mix | accel | superscript | subscript)*
  }
# end of guimenuitem.element
guimenuitem.attlist &=
  moreinfo.attrib,
  common.attrib,
  guimenuitem.role.attrib,
  local.guimenuitem.attrib
# end of guimenuitem.attlist

# end of guimenuitem.module
local.guisubmenu.attrib = empty
guisubmenu.role.attrib = role.attrib
# doc:The name of a submenu in a GUI.
guisubmenu =
  element guisubmenu {
    guisubmenu.attlist,
    (smallcptr.char.mix | accel | superscript | subscript)*
  }
# end of guisubmenu.element
guisubmenu.attlist &=
  moreinfo.attrib,
  common.attrib,
  guisubmenu.role.attrib,
  local.guisubmenu.attrib
# end of guisubmenu.attlist

# end of guisubmenu.module
local.hardware.attrib = empty
hardware.role.attrib = role.attrib
# doc:A physical part of a computer system.
hardware = element hardware { hardware.attlist, cptr.char.mix* }
# end of hardware.element
hardware.attlist &=
  moreinfo.attrib,
  common.attrib,
  hardware.role.attrib,
  local.hardware.attrib
# end of hardware.attlist

# end of hardware.module
local.interface.attrib = empty
interface.role.attrib = role.attrib
# doc:An element of a GUI.
interface =
  element interface { interface.attlist, (smallcptr.char.mix | accel)* }
# end of interface.element

# Class: Type of the Interface item; no default
interface.attlist &=
  moreinfo.attrib,
  common.attrib,
  interface.role.attrib,
  local.interface.attrib
# end of interface.attlist

# end of interface.module
local.keycap.attrib = empty
keycap.role.attrib = role.attrib
# doc:The text printed on a key on a keyboard.
keycap = element keycap { keycap.attlist, cptr.char.mix* }
# end of keycap.element
keycap.attlist &=
  attribute function {
    "alt"
    | "control"
    | "shift"
    | "meta"
    | "escape"
    | "enter"
    | "tab"
    | "backspace"
    | "command"
    | "option"
    | "space"
    | "delete"
    | "insert"
    | "up"
    | "down"
    | "left"
    | "right"
    | "home"
    | "end"
    | "pageup"
    | "pagedown"
    | "other"
  }?,
  attribute otherfunction { text }?,
  moreinfo.attrib,
  common.attrib,
  keycap.role.attrib,
  local.keycap.attrib
# end of keycap.attlist

# end of keycap.module
local.keycode.attrib = empty
keycode.role.attrib = role.attrib
# doc:The internal, frequently numeric, identifier for a key on a keyboard.
keycode = element keycode { keycode.attlist, smallcptr.char.mix* }
# end of keycode.element
keycode.attlist &=
  common.attrib, keycode.role.attrib, local.keycode.attrib
# end of keycode.attlist

# end of keycode.module
local.keycombo.attrib = empty
keycombo.role.attrib = role.attrib
# doc:A combination of input actions.
keycombo =
  element keycombo {
    keycombo.attlist, (keycap | keycombo | keysym | mousebutton)+
  }
# end of keycombo.element
keycombo.attlist &=
  keyaction.attrib,
  moreinfo.attrib,
  common.attrib,
  keycombo.role.attrib,
  local.keycombo.attrib
# end of keycombo.attlist

# end of keycombo.module
local.keysym.attrib = empty
keysysm.role.attrib = role.attrib
# doc:The symbolic name of a key on a keyboard.
keysym = element keysym { keysym.attlist, smallcptr.char.mix* }
# end of keysym.element
keysym.attlist &=
  common.attrib, keysysm.role.attrib, local.keysym.attrib
# end of keysym.attlist

# end of keysym.module
local.lineannotation.attrib = empty
lineannotation.role.attrib = role.attrib
# doc:A comment on a line in a verbatim listing.
lineannotation =
  element lineannotation { lineannotation.attlist, para.char.mix* }
# end of lineannotation.element
lineannotation.attlist &=
  common.attrib, lineannotation.role.attrib, local.lineannotation.attrib
# end of lineannotation.attlist

# end of lineannotation.module
local.literal.attrib = empty
literal.role.attrib = role.attrib
# doc:Inline text that is some literal value.
literal = element literal { literal.attlist, cptr.char.mix* }
# end of literal.element
literal.attlist &=
  moreinfo.attrib,
  common.attrib,
  literal.role.attrib,
  local.literal.attrib
# end of literal.attlist

# end of literal.module
local.code.attrib = empty
code.role.attrib = role.attrib
# doc:An inline code fragment.
code = element code { code.attlist, cptr.char.mix* }
# end of code.element
code.attlist &=
  attribute language { text }?,
  common.attrib,
  code.role.attrib,
  local.code.attrib
# end of code.attlist

# end of code.module
local.constant.attrib = empty
constant.role.attrib = role.attrib
# doc:A programming or system constant.
constant = element constant { constant.attlist, smallcptr.char.mix* }
# end of constant.element
constant.attlist &=
  attribute class { "limit" }?,
  common.attrib,
  constant.role.attrib,
  local.constant.attrib
# end of constant.attlist

# end of constant.module
local.varname.attrib = empty
varname.role.attrib = role.attrib
# doc:The name of a variable.
varname = element varname { varname.attlist, smallcptr.char.mix* }
# end of varname.element
varname.attlist &=
  common.attrib, varname.role.attrib, local.varname.attrib
# end of varname.attlist

# end of varname.module
local.markup.attrib = empty
markup.role.attrib = role.attrib
# doc:A string of formatting markup in text that is to be represented literally.
markup = element markup { markup.attlist, smallcptr.char.mix* }
# end of markup.element
markup.attlist &= common.attrib, markup.role.attrib, local.markup.attrib
# end of markup.attlist

# end of markup.module
local.medialabel.attrib = empty
medialabel.role.attrib = role.attrib
# doc:A name that identifies the physical medium on which some information resides.
medialabel =
  element medialabel { medialabel.attlist, smallcptr.char.mix* }
# end of medialabel.element

# Class: Type of medium named by the element; no default
medialabel.attlist &=
  attribute class { "cartridge" | "cdrom" | "disk" | "tape" }?,
  common.attrib,
  medialabel.role.attrib,
  local.medialabel.attrib
# end of medialabel.attlist

# end of medialabel.module
local.menuchoice.attrib = empty
menuchoice.role.attrib = role.attrib
# doc:A selection or series of selections from a menu.
menuchoice =
  element menuchoice {
    menuchoice.attlist,
    shortcut?,
    (guibutton
     | guiicon
     | guilabel
     | guimenu
     | guimenuitem
     | guisubmenu
     | interface)+
  }
# end of menuchoice.element
menuchoice.attlist &=
  moreinfo.attrib,
  common.attrib,
  menuchoice.role.attrib,
  local.menuchoice.attrib
# end of menuchoice.attlist

# end of menuchoice.module

# See also KeyCombo
local.shortcut.attrib = empty
shortcut.role.attrib = role.attrib
# doc:A key combination for an action that is also accessible through a menu.
shortcut =
  element shortcut {
    shortcut.attlist, (keycap | keycombo | keysym | mousebutton)+
  }
# end of shortcut.element
shortcut.attlist &=
  keyaction.attrib,
  moreinfo.attrib,
  common.attrib,
  shortcut.role.attrib,
  local.shortcut.attrib
# end of shortcut.attlist

# end of shortcut.module

# end of menuchoice.content.module
local.mousebutton.attrib = empty
mousebutton.role.attrib = role.attrib
# doc:The conventional name of a mouse button.
mousebutton =
  element mousebutton { mousebutton.attlist, smallcptr.char.mix* }
# end of mousebutton.element
mousebutton.attlist &=
  moreinfo.attrib,
  common.attrib,
  mousebutton.role.attrib,
  local.mousebutton.attrib
# end of mousebutton.attlist

# end of mousebutton.module
local.msgtext.attrib = empty
msgtext.role.attrib = role.attrib
# doc:The actual text of a message component in a message set.
msgtext = element msgtext { msgtext.attlist, component.mix+ }
# end of msgtext.element
msgtext.attlist &=
  common.attrib, msgtext.role.attrib, local.msgtext.attrib
# end of msgtext.attlist

# end of msgtext.module
local.option.attrib = empty
option.role.attrib = role.attrib
# doc:An option for a software command.
option = element option { option.attlist, cptr.char.mix* }
# end of option.element
option.attlist &= common.attrib, option.role.attrib, local.option.attrib
# end of option.attlist

# end of option.module
local.optional.attrib = empty
optional.role.attrib = role.attrib
# doc:Optional information.
optional = element optional { optional.attlist, cptr.char.mix* }
# end of optional.element
optional.attlist &=
  common.attrib, optional.role.attrib, local.optional.attrib
# end of optional.attlist

# end of optional.module
local.parameter.attrib = empty
parameter.role.attrib = role.attrib
# doc:A value or a symbolic reference to a value.
parameter = element parameter { parameter.attlist, cptr.char.mix* }
# end of parameter.element

# Class: Type of the Parameter; no default
parameter.attlist &=
  attribute class { "command" | "function" | "option" }?,
  moreinfo.attrib,
  common.attrib,
  parameter.role.attrib,
  local.parameter.attrib
# end of parameter.attlist

# end of parameter.module
local.prompt.attrib = empty
prompt.role.attrib = role.attrib
# doc:A character or string indicating the start of an input field in a  computer display.
prompt = element prompt { prompt.attlist, (smallcptr.char.mix | co)* }
# end of prompt.element
prompt.attlist &=
  moreinfo.attrib,
  common.attrib,
  prompt.role.attrib,
  local.prompt.attrib
# end of prompt.attlist

# end of prompt.module
local.property.attrib = empty
property.role.attrib = role.attrib
# doc:A unit of data associated with some part of a computer system.
property = element property { property.attlist, cptr.char.mix* }
# end of property.element
property.attlist &=
  moreinfo.attrib,
  common.attrib,
  property.role.attrib,
  local.property.attrib
# end of property.attlist

# end of property.module
local.replaceable.attrib = empty
replaceable.role.attrib = role.attrib
# doc:Content that may or must be replaced by the user.
replaceable =
  element replaceable {
    replaceable.attlist,
    (text
     | link.char.class
     | optional
     | base.char.class
     | other.char.class
     | inlinegraphic
     | inlinemediaobject
     | co)*
  }
# end of replaceable.element

# Class: Type of information the element represents; no
# default
replaceable.attlist &=
  attribute class { "command" | "function" | "option" | "parameter" }?,
  common.attrib,
  replaceable.role.attrib,
  local.replaceable.attrib
# end of replaceable.attlist

# end of replaceable.module
local.returnvalue.attrib = empty
returnvalue.role.attrib = role.attrib
# doc:The value returned by a function.
returnvalue =
  element returnvalue { returnvalue.attlist, smallcptr.char.mix* }
# end of returnvalue.element
returnvalue.attlist &=
  common.attrib, returnvalue.role.attrib, local.returnvalue.attrib
# end of returnvalue.attlist

# end of returnvalue.module
local.sgmltag.attrib = empty
sgmltag.role.attrib = role.attrib
# doc:A component of SGML markup.
sgmltag = element sgmltag { sgmltag.attlist, smallcptr.char.mix* }
# end of sgmltag.element

# Class: Type of SGML construct the element names; no default
sgmltag.attlist &=
  attribute class {
    "attribute"
    | "attvalue"
    | "element"
    | "endtag"
    | "emptytag"
    | "genentity"
    | "numcharref"
    | "paramentity"
    | "pi"
    | "xmlpi"
    | "starttag"
    | "sgmlcomment"
    | "prefix"
    | "namespace"
    | "localname"
  }?,
  attribute namespace { text }?,
  common.attrib,
  sgmltag.role.attrib,
  local.sgmltag.attrib
# end of sgmltag.attlist

# end of sgmltag.module
local.structfield.attrib = empty
structfield.role.attrib = role.attrib
# doc:A field in a structure (in the programming language sense).
structfield =
  element structfield { structfield.attlist, smallcptr.char.mix* }
# end of structfield.element
structfield.attlist &=
  common.attrib, structfield.role.attrib, local.structfield.attrib
# end of structfield.attlist

# end of structfield.module
local.structname.attrib = empty
structname.role.attrib = role.attrib
# doc:The name of a structure (in the programming language sense).
structname =
  element structname { structname.attlist, smallcptr.char.mix* }
# end of structname.element
structname.attlist &=
  common.attrib, structname.role.attrib, local.structname.attrib
# end of structname.attlist

# end of structname.module
local.symbol.attrib = empty
symbol.role.attrib = role.attrib
# doc:A name that is replaced by a value before processing.
symbol = element symbol { symbol.attlist, smallcptr.char.mix* }
# end of symbol.element

# Class: Type of symbol; no default
symbol.attlist &=
  attribute class { "limit" }?,
  common.attrib,
  symbol.role.attrib,
  local.symbol.attrib
# end of symbol.attlist

# end of symbol.module
local.systemitem.attrib = empty
systemitem.role.attrib = role.attrib
# doc:A system-related item or term.
systemitem =
  element systemitem {
    systemitem.attlist, (cptr.char.mix | acronym | co)*
  }
# end of systemitem.element

# Class: Type of system item the element names; no default
systemitem.attlist &=
  attribute class {
    "constant"
    | "daemon"
    | "domainname"
    | "etheraddress"
    | "event"
    | "eventhandler"
    | "filesystem"
    | "fqdomainname"
    | "groupname"
    | "ipaddress"
    | "library"
    | "macro"
    | "netmask"
    | "newsgroup"
    | "osname"
    | "protocol"
    | "resource"
    | "systemname"
    | "username"
    | "process"
    | "server"
    | "service"
  }?,
  moreinfo.attrib,
  common.attrib,
  systemitem.role.attrib,
  local.systemitem.attrib
# end of systemitem.attlist

# end of systemitem.module
local.uri.attrib = empty
uri.role.attrib = role.attrib
# doc:A Uniform Resource Identifier.
uri = element uri { uri.attlist, smallcptr.char.mix* }
# end of uri.element

# Type: Type of URI; no default
uri.attlist &=
  attribute type { text }?,
  common.attrib,
  uri.role.attrib,
  local.uri.attrib
# end of uri.attlist

# end of uri.module
local.token.attrib = empty
token.role.attrib = role.attrib
# doc:A unit of information.
\token = element token { token.attlist, smallcptr.char.mix* }
# end of token.element
token.attlist &= common.attrib, token.role.attrib, local.token.attrib
# end of token.attlist

# end of token.module
local.type.attrib = empty
type.role.attrib = role.attrib
# doc:The classification of a value.
type = element type { type.attlist, smallcptr.char.mix* }
# end of type.element
type.attlist &= common.attrib, type.role.attrib, local.type.attrib
# end of type.attlist

# end of type.module
local.userinput.attrib = empty
userinput.role.attrib = role.attrib
# doc:Data entered by the user.
userinput =
  element userinput { userinput.attlist, (cptr.char.mix | co)* }
# end of userinput.element
userinput.attlist &=
  moreinfo.attrib,
  common.attrib,
  userinput.role.attrib,
  local.userinput.attrib
# end of userinput.attlist

# end of userinput.module
local.termdef.attrib = empty
termdef.role.attrib = role.attrib
# doc:An inline definition of a term.
termdef = element termdef { termdef.attlist, para.char.mix* }
# end of termdef.element
termdef.attlist &=
  common.attrib, termdef.role.attrib, local.termdef.attrib
# end of termdef.attlist

# end of termdef.module

# General words and phrases ............................................
local.abbrev.attrib = empty
abbrev.role.attrib = role.attrib
# doc:An abbreviation, especially one followed by a period.
abbrev = element abbrev { abbrev.attlist, word.char.mix* }
# end of abbrev.element
abbrev.attlist &= common.attrib, abbrev.role.attrib, local.abbrev.attrib
# end of abbrev.attlist

# end of abbrev.module
local.acronym.attrib = empty
acronym.role.attrib = role.attrib
# doc:An often pronounceable word made from the initial (or selected) letters of a name or phrase.
acronym = element acronym { acronym.attlist, word.char.mix* }
# end of acronym.element
acronym.attlist &=
  common.attrib, acronym.role.attrib, local.acronym.attrib
# end of acronym.attlist

# end of acronym.module
local.citation.attrib = empty
citation.role.attrib = role.attrib
# doc:An inline bibliographic reference to another published work.
citation = element citation { citation.attlist, para.char.mix* }
# end of citation.element
citation.attlist &=
  common.attrib, citation.role.attrib, local.citation.attrib
# end of citation.attlist

# end of citation.module
local.citerefentry.attrib = empty
citerefentry.role.attrib = role.attrib
# doc:A citation to a reference page.
citerefentry =
  element citerefentry {
    citerefentry.attlist, refentrytitle, manvolnum?
  }
# end of citerefentry.element
citerefentry.attlist &=
  common.attrib, citerefentry.role.attrib, local.citerefentry.attrib
# end of citerefentry.attlist

# end of citerefentry.module
local.refentrytitle.attrib = empty
refentrytitle.role.attrib = role.attrib
# doc:The title of a reference page.
refentrytitle =
  element refentrytitle { refentrytitle.attlist, para.char.mix* }
# end of refentrytitle.element
refentrytitle.attlist &=
  common.attrib, refentrytitle.role.attrib, local.refentrytitle.attrib
# end of refentrytitle.attlist

# end of refentrytitle.module
local.manvolnum.attrib = empty
namvolnum.role.attrib = role.attrib
# doc:A reference volume number.
manvolnum = element manvolnum { manvolnum.attlist, word.char.mix* }
# end of manvolnum.element
manvolnum.attlist &=
  common.attrib, namvolnum.role.attrib, local.manvolnum.attrib
# end of manvolnum.attlist

# end of manvolnum.module
local.citetitle.attrib = empty
citetitle.role.attrib = role.attrib
# doc:The title of a cited work.
citetitle = element citetitle { citetitle.attlist, para.char.mix* }
# end of citetitle.element

# Pubwork: Genre of published work cited; no default
citetitle.attlist &=
  attribute pubwork {
    "article"
    | "book"
    | "chapter"
    | "part"
    | "refentry"
    | "section"
    | "journal"
    | "series"
    | "set"
    | "manuscript"
    | "cdrom"
    | "dvd"
    | "wiki"
    | "gopher"
    | "bbs"
    | "emailmessage"
    | "webpage"
    | "newsposting"
  }?,
  common.attrib,
  citetitle.role.attrib,
  local.citetitle.attrib
# end of citetitle.attlist

# end of citetitle.module
local.emphasis.attrib = empty
emphasis.role.attrib = role.attrib
# doc:Emphasized text.
emphasis = element emphasis { emphasis.attlist, para.char.mix* }
# end of emphasis.element
emphasis.attlist &=
  common.attrib, emphasis.role.attrib, local.emphasis.attrib
# end of emphasis.attlist

# end of emphasis.module
local.foreignphrase.attrib = empty
foreignphrase.role.attrib = role.attrib
# doc:A word or phrase in a language other than the primary language of the document.
foreignphrase =
  element foreignphrase { foreignphrase.attlist, para.char.mix* }
# end of foreignphrase.element
foreignphrase.attlist &=
  common.attrib, foreignphrase.role.attrib, local.foreignphrase.attrib
# end of foreignphrase.attlist

# end of foreignphrase.module
local.glossterm.attrib = empty
glossterm.role.attrib = role.attrib
# doc:A glossary term.
glossterm = element glossterm { glossterm.attlist, para.char.mix* }
# end of glossterm.element

# to GlossEntry if Glossterm used in text

# BaseForm: Provides the form of GlossTerm to be used
# for indexing
glossterm.attlist &=
  attribute baseform { text }?,
  linkend.attrib,
  common.attrib,
  glossterm.role.attrib,
  local.glossterm.attrib
# end of glossterm.attlist

# end of glossterm.module
local.firstterm.attrib = empty
firstterm.role.attrib = role.attrib
# doc:The first occurrence of a term.
firstterm = element firstterm { firstterm.attlist, para.char.mix* }
# end of firstterm.element

# to GlossEntry or other explanation
firstterm.attlist &=
  attribute baseform { text }?,
  linkend.attrib,
  common.attrib,
  firstterm.role.attrib,
  local.firstterm.attrib
# end of firstterm.attlist

# end of firstterm.module
local.phrase.attrib = empty
phrase.role.attrib = role.attrib
# doc:A span of text.
phrase = element phrase { phrase.attlist, para.char.mix* }
# end of phrase.element
phrase.attlist &= common.attrib, phrase.role.attrib, local.phrase.attrib
# end of phrase.attlist

# end of phrase.module
local.quote.attrib = empty
quote.role.attrib = role.attrib
# doc:An inline quotation.
quote = element quote { quote.attlist, para.char.mix* }
# end of quote.element
quote.attlist &= common.attrib, quote.role.attrib, local.quote.attrib
# end of quote.attlist

# end of quote.module
local.ssscript.attrib = empty
ssscript.role.attrib = role.attrib
# doc:A subscript (as in H{^2}O, the molecular formula for water).
subscript =
  element subscript {
    subscript.attlist,
    (text
     | link.char.class
     | emphasis
     | replaceable
     | symbol
     | inlinegraphic
     | inlinemediaobject
     | base.char.class
     | other.char.class)*
  }
# end of subscript.element
subscript.attlist &=
  common.attrib, ssscript.role.attrib, local.ssscript.attrib
# end of subscript.attlist

# doc:A superscript (as in x^2, the mathematical notation for x multiplied by itself).
superscript =
  element superscript {
    superscript.attlist,
    (text
     | link.char.class
     | emphasis
     | replaceable
     | symbol
     | inlinegraphic
     | inlinemediaobject
     | base.char.class
     | other.char.class)*
  }
# end of superscript.element
superscript.attlist &=
  common.attrib, ssscript.role.attrib, local.ssscript.attrib
# end of superscript.attlist

# end of ssscript.module
local.trademark.attrib = empty
trademark.role.attrib = role.attrib
# doc:A trademark.
trademark =
  element trademark {
    trademark.attlist,
    (text
     | link.char.class
     | tech.char.class
     | base.char.class
     | other.char.class
     | inlinegraphic
     | inlinemediaobject
     | emphasis)*
  }
# end of trademark.element

# Class: More precisely identifies the item the element names
trademark.attlist &=
  [ a:defaultValue = "trade" ]
  attribute class { "service" | "trade" | "registered" | "copyright" }?,
  common.attrib,
  trademark.role.attrib,
  local.trademark.attrib
# end of trademark.attlist

# end of trademark.module
local.wordasword.attrib = empty
wordasword.role.attrib = role.attrib
# doc:A word meant specifically as a word and not representing anything else.
wordasword = element wordasword { wordasword.attlist, word.char.mix* }
# end of wordasword.element
wordasword.attlist &=
  common.attrib, wordasword.role.attrib, local.wordasword.attrib
# end of wordasword.attlist

# end of wordasword.module

# Links and cross-references ...........................................
local.link.attrib = empty
link.role.attrib = role.attrib
# doc:A hypertext link.
link = element link { link.attlist, para.char.mix* }
# end of link.element

# Endterm: ID of element containing text that is to be
# fetched from elsewhere in the document to appear as
# the content of this element

# to linked-to object

# Type: Freely assignable parameter
link.attlist &=
  attribute endterm { xsd:IDREF }?,
  attribute xrefstyle { text }?,
  attribute type { text }?,
  linkendreq.attrib,
  common.attrib,
  link.role.attrib,
  local.link.attrib
# end of link.attlist

# end of link.module
local.olink.attrib = empty
olink.role.attrib = role.attrib
# doc:A link that addresses its target indirectly, through an entity.
olink = element olink { olink.attlist, para.char.mix* }
# end of olink.element

# TargetDocEnt: Name of an entity to be the target of the link

# LinkMode: ID of a ModeSpec containing instructions for
# operating on the entity named by TargetDocEnt

# LocalInfo: Information that may be passed to ModeSpec

# Type: Freely assignable parameter
olink.attlist &=
  attribute targetdocent { xsd:ENTITY }?,
  attribute linkmode { xsd:IDREF }?,
  attribute localinfo { text }?,
  attribute type { text }?,
  attribute targetdoc { text }?,
  attribute targetptr { text }?,
  attribute xrefstyle { text }?,
  common.attrib,
  olink.role.attrib,
  local.olink.attrib
# end of olink.attlist

# end of olink.module
local.ulink.attrib = empty
ulink.role.attrib = role.attrib
# doc:A link that addresses its target by means of a URL (Uniform Resource Locator).
ulink = element ulink { ulink.attlist, para.char.mix* }
# end of ulink.element

# URL: uniform resource locator; the target of the ULink

# Type: Freely assignable parameter
ulink.attlist &=
  attribute url { text },
  attribute type { text }?,
  attribute xrefstyle { text }?,
  common.attrib,
  ulink.role.attrib,
  local.ulink.attrib
# end of ulink.attlist

# end of ulink.module
local.footnoteref.attrib = empty
footnoteref.role.attrib = role.attrib
# doc:A cross reference to a footnote (a footnote mark).
footnoteref = element footnoteref { footnoteref.attlist, empty }
# end of footnoteref.element

# to footnote content supplied elsewhere
footnoteref.attlist &=
  linkendreq.attrib,
  label.attrib,
  common.attrib,
  footnoteref.role.attrib,
  local.footnoteref.attrib
# end of footnoteref.attlist

# end of footnoteref.module
local.xref.attrib = empty
xref.role.attrib = role.attrib
# doc:A cross reference to another part of the document.
xref = element xref { xref.attlist, empty }
# end of xref.element

# Endterm: ID of element containing text that is to be
# fetched from elsewhere in the document to appear as
# the content of this element

# to linked-to object
xref.attlist &=
  attribute endterm { xsd:IDREF }?,
  attribute xrefstyle { text }?,
  common.attrib,
  linkendreq.attrib,
  xref.role.attrib,
  local.xref.attrib
# end of xref.attlist

# end of xref.module
local.biblioref.attrib = empty
biblioref.role.attrib = role.attrib
# doc:A cross reference to a bibliographic entry.
biblioref = element biblioref { biblioref.attlist, empty }
# end of biblioref.element
biblioref.attlist &=
  attribute endterm { xsd:IDREF }?,
  attribute xrefstyle { text }?,
  attribute units { text }?,
  attribute begin { text }?,
  attribute end { text }?,
  common.attrib,
  linkendreq.attrib,
  biblioref.role.attrib,
  local.biblioref.attrib
# end of biblioref.attlist

# end of biblioref.module

# Ubiquitous elements ..................................................
local.anchor.attrib = empty
anchor.role.attrib = role.attrib
# doc:A spot in the document.
anchor = element anchor { anchor.attlist, empty }
# end of anchor.element

# required

# replaces Lang
anchor.attlist &=
  idreq.attrib,
  pagenum.attrib,
  remap.attrib,
  xreflabel.attrib,
  revisionflag.attrib,
  effectivity.attrib,
  anchor.role.attrib,
  local.anchor.attrib
# end of anchor.attlist

# end of anchor.module
local.beginpage.attrib = empty
beginpage.role.attrib = role.attrib
# doc:The location of a page break in a print version of the document.
beginpage = element beginpage { beginpage.attlist, empty }
# end of beginpage.element

# PageNum: Number of page that begins at this point
beginpage.attlist &=
  pagenum.attrib,
  common.attrib,
  beginpage.role.attrib,
  local.beginpage.attrib
# end of beginpage.attlist

# end of beginpage.module

# IndexTerms appear in the text flow for generating or linking an
# index.
local.indexterm.attrib = empty
indexterm.role.attrib = role.attrib
# doc:A wrapper for terms to be indexed.
indexterm =
  element indexterm {
    indexterm.attlist,
    primary?,
    ((secondary,
      ((tertiary, (see | seealso+)?)
       | see
       | seealso+)?)
     | see
     | seealso+)?
  }
# end of indexterm.element

# Scope: Indicates which generated indices the IndexTerm
# should appear in: Global (whole document set), Local (this
# document only), or All (both)

# Significance: Whether this IndexTerm is the most pertinent
# of its series (Preferred) or not (Normal, the default)

# Class: Indicates type of IndexTerm; default is Singular,
# or EndOfRange if StartRef is supplied; StartOfRange value
# must be supplied explicitly on starts of ranges

# StartRef: ID of the IndexTerm that starts the indexing
# range ended by this IndexTerm

# Zone: IDs of the elements to which the IndexTerm applies,
# and indicates that the IndexTerm applies to those entire
# elements rather than the point at which the IndexTerm
# occurs
indexterm.attlist &=
  pagenum.attrib,
  attribute scope { "all" | "global" | "local" }?,
  [ a:defaultValue = "normal" ]
  attribute significance { "preferred" | "normal" }?,
  attribute class { "singular" | "startofrange" | "endofrange" }?,
  attribute startref { xsd:IDREF }?,
  attribute zone { xsd:IDREFS }?,
  attribute type { text }?,
  common.attrib,
  indexterm.role.attrib,
  local.indexterm.attrib
# end of indexterm.attlist

# end of indexterm.module
local.primsecter.attrib = empty
primsecter.role.attrib = role.attrib
# doc:The primary word or phrase under which an index term should be sorted.
primary = element primary { primary.attlist, ndxterm.char.mix* }
# end of primary.element

# SortAs: Alternate sort string for index sorting, e.g.,
# "fourteen" for an element containing "14"
primary.attlist &=
  attribute sortas { text }?,
  common.attrib,
  primsecter.role.attrib,
  local.primsecter.attrib
# end of primary.attlist

# doc:A secondary word or phrase in an index term.
secondary = element secondary { secondary.attlist, ndxterm.char.mix* }
# end of secondary.element

# SortAs: Alternate sort string for index sorting, e.g.,
# "fourteen" for an element containing "14"
secondary.attlist &=
  attribute sortas { text }?,
  common.attrib,
  primsecter.role.attrib,
  local.primsecter.attrib
# end of secondary.attlist

# doc:A tertiary word or phrase in an index term.
tertiary = element tertiary { tertiary.attlist, ndxterm.char.mix* }
# end of tertiary.element

# SortAs: Alternate sort string for index sorting, e.g.,
# "fourteen" for an element containing "14"
tertiary.attlist &=
  attribute sortas { text }?,
  common.attrib,
  primsecter.role.attrib,
  local.primsecter.attrib
# end of tertiary.attlist

# end of primsecter.module
local.seeseealso.attrib = empty
seeseealso.role.attrib = role.attrib
# doc:Part of an index term directing the reader instead to another entry in the index.
see = element see { see.attlist, ndxterm.char.mix* }
# end of see.element
see.attlist &=
  common.attrib, seeseealso.role.attrib, local.seeseealso.attrib
# end of see.attlist

# doc:Part of an index term directing the reader also to another entry in the index.
seealso = element seealso { seealso.attlist, ndxterm.char.mix* }
# end of seealso.element
seealso.attlist &=
  common.attrib, seeseealso.role.attrib, local.seeseealso.attrib
# end of seealso.attlist

# end of seeseealso.module

# end of indexterm.content.module

# End of DocBook XML information pool module V4.5 ......................

# ......................................................................