Initial merge of nxml

51 files changed, 9059 insertions, 0 deletions

diff --git a/etc/ChangeLog b/etc/ChangeLog
index 67bf2d8e9df..419522c810a 100644
--- a/etc/ChangeLog
+++ b/etc/ChangeLog
@@ -1,3 +1,7 @@
+2007-11-23  Mark A. Hershberger  <mah@everybody.org>
+
+        * schema: Initial merge of nxml.
+
 2007-11-22  Francesco Potort,Al(B  <pot@gnu.org>
 
         * NEWS: etags: the --members option is now the default.
diff --git a/etc/schema/calstbl.rnc b/etc/schema/calstbl.rnc
new file mode 100644
index 00000000000..5d334e8ebd2
--- /dev/null
+++ b/etc/schema/calstbl.rnc
@@ -0,0 +1,184 @@
+# This file was generated automatically by Trang, and then manually
+# edited to add back definitions for overridden parameter entities and
+# undefined elements, specifically: bodyatt, secur, paracon,
+# tbl.table.mdl, tbl.entry.mdl, caution, graphic, legend, note, para,
+# title, warning.  This makes the semantics of this module as close as
+# possible to the original DTD and also allows this schema to be used
+# independently of DocBook.
+
+# ......................................................................
+
+# DocBook CALS Table Model V4.2 ........................................
+
+# File calstblx.mod ....................................................
+
+# Copyright 1992-2002 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).
+# 
+# This DTD is based on the CALS Table Model
+# PUBLIC "-//USA-DOD//DTD Table Model 951010//EN"
+# 
+# $Id: calstbl.rnc,v 1.2 2003/08/30 06:04:02 jjc Exp $
+# 
+# Permission to use, copy, modify and distribute the DocBook 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 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 CALS Table Model
+# converted to XML.
+
+# These definitions are not directly related to the table model, but are
+# used in the default CALS table model and are usually defined elsewhere
+# (and prior to the inclusion of this table module) in a CALS DTD.
+
+bodyatt = empty
+secur = empty
+
+# no if zero(s),
+# yes if any other digits value
+
+yesorno = string
+titles = title?
+# default for use in entry content
+paracon = text
+
+# The parameter entities as defined below provide the CALS table model
+# as published (as part of the Example DTD) in MIL-HDBK-28001.
+# 
+# These following declarations provide the CALS-compliant default definitions
+# for these entities.  However, these entities can and should be redefined
+# (by giving the appropriate parameter entity declaration(s) prior to the
+# reference to this Table Model declaration set entity) to fit the needs
+# of the current application.
+tbl.table-titles.mdl = titles
+tbl.table-main.mdl = tgroup+ | graphic+
+tbl.table.mdl = tbl.table-titles.mdl | tbl.table-main.mdl
+tbl.table.att =
+  attribute tabstyle { text }?,
+  attribute tocentry { yesorno }?,
+  attribute shortentry { yesorno }?,
+  attribute orient { "port" | "land" }?,
+  attribute pgwide { yesorno }?
+tbl.tgroup.mdl = colspec*, spanspec*, thead?, tfoot?, tbody
+tbl.tgroup.att = attribute tgroupstyle { text }?
+tbl.hdft.mdl = colspec*, row+
+tbl.row.mdl = (entry | entrytbl)+
+tbl.entrytbl.mdl = colspec*, spanspec*, thead?, tbody
+tbl.entry.mdl = paracon | para | warning | caution | note | legend
+# =====  Element and attribute declarations follow. =====
+start = table
+table = element table { table.attlist, tbl.table.mdl }
+table.attlist &=
+  attribute frame {
+    "top" | "bottom" | "topbot" | "all" | "sides" | "none"
+  }?,
+  attribute colsep { yesorno }?,
+  attribute rowsep { yesorno }?,
+  tbl.table.att,
+  bodyatt,
+  secur
+tgroup = element tgroup { tgroup.attlist, tbl.tgroup.mdl }
+tgroup.attlist &=
+  attribute cols { text },
+  tbl.tgroup.att,
+  attribute colsep { yesorno }?,
+  attribute rowsep { yesorno }?,
+  attribute align { "left" | "right" | "center" | "justify" | "char" }?,
+  attribute char { text }?,
+  attribute charoff { text }?,
+  secur
+colspec = element colspec { colspec.attlist, empty }
+colspec.attlist &=
+  attribute colnum { text }?,
+  attribute colname { text }?,
+  attribute colwidth { text }?,
+  attribute colsep { yesorno }?,
+  attribute rowsep { yesorno }?,
+  attribute align { "left" | "right" | "center" | "justify" | "char" }?,
+  attribute char { text }?,
+  attribute charoff { text }?
+spanspec = element spanspec { spanspec.attlist, empty }
+spanspec.attlist &=
+  attribute namest { text },
+  attribute nameend { text },
+  attribute spanname { text },
+  attribute colsep { yesorno }?,
+  attribute rowsep { yesorno }?,
+  attribute align { "left" | "right" | "center" | "justify" | "char" }?,
+  attribute char { text }?,
+  attribute charoff { text }?
+thead = element thead { thead.attlist, tbl.hdft.mdl }
+thead.attlist &=
+  attribute valign { "top" | "middle" | "bottom" }?,
+  secur
+tfoot = element tfoot { tfoot.attlist, tbl.hdft.mdl }
+tfoot.attlist &=
+  attribute valign { "top" | "middle" | "bottom" }?,
+  secur
+tbody = element tbody { tbody.attlist, row+ }
+tbody.attlist &=
+  attribute valign { "top" | "middle" | "bottom" }?,
+  secur
+row = element row { row.attlist, tbl.row.mdl }
+row.attlist &=
+  attribute rowsep { yesorno }?,
+  attribute valign { "top" | "middle" | "bottom" }?,
+  secur
+entrytbl = element entrytbl { entrytbl.attlist, tbl.entrytbl.mdl }
+entrytbl.attlist &=
+  attribute cols { text },
+  tbl.tgroup.att,
+  attribute colname { text }?,
+  attribute spanname { text }?,
+  attribute namest { text }?,
+  attribute nameend { text }?,
+  attribute colsep { yesorno }?,
+  attribute rowsep { yesorno }?,
+  attribute align { "left" | "right" | "center" | "justify" | "char" }?,
+  attribute char { text }?,
+  attribute charoff { text }?,
+  secur
+entry = element entry { entry.attlist, tbl.entry.mdl* }
+entry.attlist &=
+  attribute colname { text }?,
+  attribute namest { text }?,
+  attribute nameend { text }?,
+  attribute spanname { text }?,
+  attribute morerows { text }?,
+  attribute colsep { yesorno }?,
+  attribute rowsep { yesorno }?,
+  attribute align { "left" | "right" | "center" | "justify" | "char" }?,
+  attribute char { text }?,
+  attribute charoff { text }?,
+  attribute rotate { yesorno }?,
+  attribute valign { "top" | "middle" | "bottom" }?,
+  secur
+caution |= notAllowed
+graphic |= notAllowed
+legend |= notAllowed
+note |= notAllowed
+para |= notAllowed
+title |= notAllowed
+warning |= notAllowed
+
+# End of DocBook CALS Table Model V4.2 .................................
+
+# ......................................................................
diff --git a/etc/schema/dbcalstbl.rnc b/etc/schema/dbcalstbl.rnc
new file mode 100644
index 00000000000..9841df2d734
--- /dev/null
+++ b/etc/schema/dbcalstbl.rnc
@@ -0,0 +1,25 @@
+# Definitions specific to the CALS Table Model.
+
+# Reference CALS Table Model
+include "calstbl.rnc" {
+  # Override definition of start
+  start |= notAllowed
+  # Add label and role attributes to table and informaltable
+  bodyatt = label.attrib
+  # Add common attributes to Table, TGroup, TBody, THead, TFoot, Row,
+  # EntryTbl, and Entry (and InformalTable element).
+  secur = common.attrib, tables.role.attrib
+  # Content model for Table.
+  tbl.table.mdl =
+    blockinfo?,
+    formalobject.title.content,
+    ndxterm.class*,
+    textobject*,
+    (graphic+ | mediaobject+ | tgroup+)
+  # Allow either objects or inlines; beware of REs between elements.
+  tbl.entry.mdl = para.char.mix | tabentry.mix
+}
+
+common.table.attribs = bodyatt, secur
+
+# end of table.module
diff --git a/etc/schema/dbdyntbl.rnc b/etc/schema/dbdyntbl.rnc
new file mode 100644
index 00000000000..8e859145fd0
--- /dev/null
+++ b/etc/schema/dbdyntbl.rnc
@@ -0,0 +1,116 @@
+# This is an alternative to dbsoextbl.rnc and dbcalstbl.rnc that
+# allows the table model to be selected dynamically based on the
+# definitions of cals.table.module and exchange.table.module.
+#
+# To use this copy, docbook.rnc to docbook-dyntbl.rnc replacing
+# "dbcalstbl.rnc" by "dbdyntbl.rnc".  Then, you can override the
+# choice of table model by doing
+#
+# include "docbook-dyntbl.rnc" {
+#   cals.table.model = IGNORE
+#   exchange.table.model = INCLUDE
+# }
+
+INCLUDE = empty
+IGNORE = notAllowed
+cals.table.module = INCLUDE
+exchange.table.module = IGNORE
+
+# Add common attributes and the Label attribute to Table and
+# InformalTable.
+bodyatt = common.attrib, label.attrib, tables.role.attrib
+
+# Content model for Table.
+tbl.table.mdl =
+  blockinfo?,
+  formalobject.title.content,
+  ndxterm.class*,
+  textobject*,
+  (graphic+ | mediaobject+ | tgroup+)
+
+table = cals.table | exchange.table
+
+cals.table =
+  cals.table.module,
+  grammar {
+    # Reference CALS Table Model
+    include "calstbl.rnc" {
+      # Add label and role attributes to table and informaltable
+      bodyatt = parent label.attrib
+      # Add common attributes to Table, TGroup, TBody, THead, TFoot, Row,
+      # EntryTbl, and Entry (and InformalTable element).
+      secur = parent common.attrib, parent tables.role.attrib
+      tbl.table.mdl = parent tbl.table.mdl
+    }
+  }
+
+exchange.table =
+  exchange.table.module,
+  grammar {
+    # Reference OASIS Exchange Table Model
+    include "soextbl.rnc" {
+      # Add common attributes and the Label attribute to Table and
+      # InformalTable.
+      bodyatt = parent bodyatt
+      tbl.table.mdl = parent tbl.table.mdl
+    }
+  }
+
+tgroup = cals.tgroup | exchange.tgroup
+
+cals.tgroup =
+  cals.table.module,
+  grammar {
+    # Reference CALS Table Model
+    include "calstbl.rnc" {
+      start = tgroup
+      # Add label and role attributes to table and informaltable
+      bodyatt = parent label.attrib
+      # Add common attributes to Table, TGroup, TBody, THead, TFoot, Row,
+      # EntryTbl, and Entry (and InformalTable element).
+      secur = parent common.attrib, parent tables.role.attrib
+      # Allow either objects or inlines; beware of REs between elements.
+      tbl.entry.mdl = parent para.char.mix | parent tabentry.mix
+    }
+  }
+
+exchange.tgroup =
+  exchange.table.module,
+  grammar {
+    # Reference OASIS Exchange Table Model
+    include "soextbl.rnc" {
+      start = tgroup
+      bodyatt = parent bodyatt
+      # Add common attributes to TGroup, ColSpec, TBody, THead, Row, Entry
+      tbl.tgroup.att = parent common.attrib
+      tbl.colspec.att = parent common.attrib
+      tbl.tbody.att = parent common.attrib
+      tbl.thead.att = parent common.attrib
+      tbl.row.att = parent common.attrib
+      tbl.entry.att = parent common.attrib
+      # Allow either objects or inlines; beware of REs between elements.
+      tbl.entry.mdl = (parent para.char.mix | parent tabentry.mix)*
+    }
+  }
+
+tbl.table.att = cals.tbl.table.att | exchange.tbl.table.att
+
+cals.tbl.table.att =
+  cals.table.module,
+  grammar {
+    include "calstbl.rnc" {
+      start = tbl.table.att
+    }
+  }
+
+exchange.tbl.table.att =
+  exchange.table.module,
+  grammar {
+    include "soextbl.rnc" {
+      start = tbl.table.att
+    }
+  }
+
+common.table.attribs = bodyatt
+
+# end of table.module
diff --git a/etc/schema/dbhier.rnc b/etc/schema/dbhier.rnc
new file mode 100644
index 00000000000..1671b01fbce
--- /dev/null
+++ b/etc/schema/dbhier.rnc
@@ -0,0 +1,1467 @@
+# ......................................................................
+
+# DocBook document hierarchy module V4.2 ...............................
+
+# File dbhierx.mod .....................................................
+
+# Copyright 1992-2002 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: dbhier.rnc,v 1.1 2003/08/30 04:19:27 jjc Exp $
+# 
+# Permission to use, copy, modify and distribute the DocBook 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 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 overall document
+# hierarchies of DocBook documents.  It covers computer documentation
+# manuals and manual fragments, as well as reference entries (such as
+# man pages) and technical journals or anthologies containing
+# articles.
+# 
+# This module depends on the DocBook information pool module.  All
+# elements and entities referenced but not defined here are assumed
+# to be defined in the information pool module.
+# 
+# In DTD driver files referring to this module, please use an entity
+# declaration that uses the public identifier shown below:
+# 
+# <!ENTITY % dbhier PUBLIC
+# "-//OASIS//ELEMENTS DocBook Document Hierarchy V4.2//EN"
+# "dbhierx.mod">
+# %dbhier;
+# 
+# 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.
+
+# ......................................................................
+
+# Entities for module inclusions .......................................
+
+# ......................................................................
+
+# Entities for element classes .........................................
+
+local.appendix.class = notAllowed
+appendix.class = appendix | local.appendix.class
+local.article.class = notAllowed
+article.class = article | local.article.class
+local.book.class = notAllowed
+book.class = book | local.book.class
+local.chapter.class = notAllowed
+chapter.class = chapter | local.chapter.class
+local.index.class = notAllowed
+index.class = index | setindex | local.index.class
+local.refentry.class = notAllowed
+refentry.class = refentry | local.refentry.class
+local.section.class = notAllowed
+section.class = section | local.section.class
+local.nav.class = notAllowed
+nav.class =
+  toc | lot | index | glossary | bibliography | local.nav.class
+# Redeclaration placeholder ............................................
+
+# For redeclaring entities that are declared after this point while
+# retaining their references to the entities that are declared before
+# this point
+
+# ......................................................................
+
+# Entities for element mixtures ........................................
+
+# The DocBook TC may produce an official forms module for DocBook.
+
+# This PE provides the hook by which it can be inserted into the DTD.
+forms.hook = notAllowed
+local.divcomponent.mix = notAllowed
+divcomponent.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.divcomponent.mix
+local.refcomponent.mix = notAllowed
+refcomponent.mix =
+  list.class
+  | admon.class
+  | linespecific.class
+  | synop.class
+  | para.class
+  | informal.class
+  | formal.class
+  | compound.class
+  | genobj.class
+  | descobj.class
+  | ndxterm.class
+  | beginpage
+  | local.refcomponent.mix
+local.indexdivcomponent.mix = notAllowed
+indexdivcomponent.mix =
+  itemizedlist
+  | orderedlist
+  | variablelist
+  | simplelist
+  | linespecific.class
+  | synop.class
+  | para.class
+  | informal.class
+  | anchor
+  | remark
+  | link.char.class
+  | beginpage
+  | local.indexdivcomponent.mix
+local.refname.char.mix = notAllowed
+refname.char.mix = text | tech.char.class | local.refname.char.mix
+local.partcontent.mix = notAllowed
+partcontent.mix =
+  appendix.class
+  | chapter.class
+  | nav.class
+  | article.class
+  | preface
+  | refentry.class
+  | reference
+  | local.partcontent.mix
+local.refinline.char.mix = notAllowed
+refinline.char.mix =
+  text
+  | xref.char.class
+  | gen.char.class
+  | link.char.class
+  | tech.char.class
+  | base.char.class
+  | docinfo.char.class
+  | other.char.class
+  | ndxterm.class
+  | beginpage
+  | local.refinline.char.mix
+local.refclass.char.mix = notAllowed
+refclass.char.mix = text | application | local.refclass.char.mix
+# Redeclaration placeholder 2 ..........................................
+
+# For redeclaring entities that are declared after this point while
+# retaining their references to the entities that are declared before
+# this point
+
+# ......................................................................
+
+# Entities for content models ..........................................
+div.title.content = title, subtitle?, titleabbrev?
+bookcomponent.title.content = title, subtitle?, titleabbrev?
+sect.title.content = title, subtitle?, titleabbrev?
+refsect.title.content = title, subtitle?, titleabbrev?
+bookcomponent.content =
+  (divcomponent.mix+,
+   (sect1* | refentry.class* | simplesect* | section.class*))
+  | (sect1+ | refentry.class+ | simplesect+ | section.class+)
+# ......................................................................
+
+# Set and SetInfo ......................................................
+local.set.attrib = empty
+set.role.attrib = role.attrib
+set =
+  element set {
+    set.attlist,
+    div.title.content?,
+    setinfo?,
+    toc?,
+    book.class+,
+    setindex?
+  }
+# end of set.element
+
+# FPI: SGML formal public identifier
+set.attlist &=
+  attribute fpi { text }?,
+  status.attrib,
+  common.attrib,
+  set.role.attrib,
+  local.set.attrib
+# end of set.attlist
+
+# end of set.module
+local.setinfo.attrib = empty
+setinfo.role.attrib = role.attrib
+setinfo = element setinfo { setinfo.attlist, info.class+ }
+# end of setinfo.element
+
+# Contents: IDs of the ToC, Books, and SetIndex that comprise
+# the set, in the order of their appearance
+setinfo.attlist &=
+  attribute contents { xsd:IDREFS }?,
+  common.attrib,
+  setinfo.role.attrib,
+  local.setinfo.attrib
+# end of setinfo.attlist
+
+# end of setinfo.module
+
+# end of set.content.module
+
+# ......................................................................
+
+# Book and BookInfo ....................................................
+local.book.attrib = empty
+book.role.attrib = role.attrib
+book =
+  element book {
+    book.attlist,
+    div.title.content?,
+    bookinfo?,
+    (dedication
+     | toc
+     | lot
+     | glossary
+     | bibliography
+     | preface
+     | chapter.class
+     | reference
+     | part
+     | article.class
+     | appendix.class
+     | index.class
+     | colophon)*
+  }
+# end of book.element
+
+# FPI: SGML formal public identifier
+book.attlist &=
+  attribute fpi { text }?,
+  label.attrib,
+  status.attrib,
+  common.attrib,
+  book.role.attrib,
+  local.book.attrib
+# end of book.attlist
+
+# end of book.module
+local.bookinfo.attrib = empty
+bookinfo.role.attrib = role.attrib
+bookinfo = element bookinfo { bookinfo.attlist, info.class+ }
+# end of bookinfo.element
+
+# Contents: IDs of the ToC, LoTs, Prefaces, Parts, Chapters,
+# Appendixes, References, GLossary, Bibliography, and indexes
+# comprising the Book, in the order of their appearance
+bookinfo.attlist &=
+  attribute contents { xsd:IDREFS }?,
+  common.attrib,
+  bookinfo.role.attrib,
+  local.bookinfo.attrib
+# end of bookinfo.attlist
+
+# end of bookinfo.module
+
+# end of book.content.module
+
+# ......................................................................
+
+# Dedication, ToC, and LoT .............................................
+local.dedication.attrib = empty
+dedication.role.attrib = role.attrib
+dedication =
+  element dedication {
+    dedication.attlist, sect.title.content?, legalnotice.mix+
+  }
+# end of dedication.element
+dedication.attlist &=
+  status.attrib,
+  common.attrib,
+  dedication.role.attrib,
+  local.dedication.attrib
+# end of dedication.attlist
+
+# end of dedication.module
+local.colophon.attrib = empty
+colophon.role.attrib = role.attrib
+colophon =
+  element colophon {
+    colophon.attlist, sect.title.content?, textobject.mix+
+  }
+# end of colophon.element
+colophon.attlist &=
+  status.attrib,
+  common.attrib,
+  colophon.role.attrib,
+  local.colophon.attrib
+# end of colophon.attlist
+
+# end of colophon.module
+local.toc.attrib = empty
+toc.role.attrib = role.attrib
+toc =
+  element toc {
+    toc.attlist,
+    beginpage?,
+    bookcomponent.title.content?,
+    tocfront*,
+    (tocpart | tocchap)*,
+    tocback*
+  }
+# end of toc.element
+toc.attlist &=
+  pagenum.attrib, common.attrib, toc.role.attrib, local.toc.attrib
+# end of toc.attlist
+
+# end of toc.module
+local.tocfront.attrib = empty
+tocfront.role.attrib = role.attrib
+tocfront = element tocfront { tocfront.attlist, para.char.mix* }
+# end of tocfront.element
+
+# to element that this entry represents
+tocfront.attlist &=
+  label.attrib,
+  linkend.attrib,
+  pagenum.attrib,
+  common.attrib,
+  tocfront.role.attrib,
+  local.tocfront.attrib
+# end of tocfront.attlist
+
+# end of tocfront.module
+local.tocentry.attrib = empty
+tocentry.role.attrib = role.attrib
+tocentry = element tocentry { tocentry.attlist, para.char.mix* }
+# end of tocentry.element
+
+# to element that this entry represents
+tocentry.attlist &=
+  linkend.attrib,
+  pagenum.attrib,
+  common.attrib,
+  tocentry.role.attrib,
+  local.tocentry.attrib
+# end of tocentry.attlist
+
+# end of tocentry.module
+local.tocpart.attrib = empty
+tocpart.role.attrib = role.attrib
+tocpart = element tocpart { tocpart.attlist, tocentry+, tocchap* }
+# end of tocpart.element
+tocpart.attlist &=
+  common.attrib, tocpart.role.attrib, local.tocpart.attrib
+# end of tocpart.attlist
+
+# end of tocpart.module
+local.tocchap.attrib = empty
+tocchap.role.attrib = role.attrib
+tocchap = element tocchap { tocchap.attlist, tocentry+, toclevel1* }
+# end of tocchap.element
+tocchap.attlist &=
+  label.attrib, common.attrib, tocchap.role.attrib, local.tocchap.attrib
+# end of tocchap.attlist
+
+# end of tocchap.module
+local.toclevel1.attrib = empty
+toclevel1.role.attrib = role.attrib
+toclevel1 =
+  element toclevel1 { toclevel1.attlist, tocentry+, toclevel2* }
+# end of toclevel1.element
+toclevel1.attlist &=
+  common.attrib, toclevel1.role.attrib, local.toclevel1.attrib
+# end of toclevel1.attlist
+
+# end of toclevel1.module
+local.toclevel2.attrib = empty
+toclevel2.role.attrib = role.attrib
+toclevel2 =
+  element toclevel2 { toclevel2.attlist, tocentry+, toclevel3* }
+# end of toclevel2.element
+toclevel2.attlist &=
+  common.attrib, toclevel2.role.attrib, local.toclevel2.attrib
+# end of toclevel2.attlist
+
+# end of toclevel2.module
+local.toclevel3.attrib = empty
+toclevel3.role.attrib = role.attrib
+toclevel3 =
+  element toclevel3 { toclevel3.attlist, tocentry+, toclevel4* }
+# end of toclevel3.element
+toclevel3.attlist &=
+  common.attrib, toclevel3.role.attrib, local.toclevel3.attrib
+# end of toclevel3.attlist
+
+# end of toclevel3.module
+local.toclevel4.attrib = empty
+toclevel4.role.attrib = role.attrib
+toclevel4 =
+  element toclevel4 { toclevel4.attlist, tocentry+, toclevel5* }
+# end of toclevel4.element
+toclevel4.attlist &=
+  common.attrib, toclevel4.role.attrib, local.toclevel4.attrib
+# end of toclevel4.attlist
+
+# end of toclevel4.module
+local.toclevel5.attrib = empty
+toclevel5.role.attrib = role.attrib
+toclevel5 = element toclevel5 { toclevel5.attlist, tocentry+ }
+# end of toclevel5.element
+toclevel5.attlist &=
+  common.attrib, toclevel5.role.attrib, local.toclevel5.attrib
+# end of toclevel5.attlist
+
+# end of toclevel5.module
+local.tocback.attrib = empty
+tocback.role.attrib = role.attrib
+tocback = element tocback { tocback.attlist, para.char.mix* }
+# end of tocback.element
+
+# to element that this entry represents
+tocback.attlist &=
+  label.attrib,
+  linkend.attrib,
+  pagenum.attrib,
+  common.attrib,
+  tocback.role.attrib,
+  local.tocback.attrib
+# end of tocback.attlist
+
+# end of tocback.module
+
+# end of toc.content.module
+local.lot.attrib = empty
+lot.role.attrib = role.attrib
+lot =
+  element lot {
+    lot.attlist, beginpage?, bookcomponent.title.content?, lotentry*
+  }
+# end of lot.element
+lot.attlist &=
+  label.attrib, common.attrib, lot.role.attrib, local.lot.attrib
+# end of lot.attlist
+
+# end of lot.module
+local.lotentry.attrib = empty
+lotentry.role.attrib = role.attrib
+lotentry = element lotentry { lotentry.attlist, para.char.mix* }
+# end of lotentry.element
+
+# SrcCredit: Information about the source of the entry,
+# as for a list of illustrations
+
+#  linkend: to element that this entry represents
+lotentry.attlist &=
+  linkend.attrib,
+  pagenum.attrib,
+  attribute srccredit { text }?,
+  common.attrib,
+  lotentry.role.attrib,
+  local.lotentry.attrib
+# end of lotentry.attlist
+
+# end of lotentry.module
+
+# end of lot.content.module
+
+# ......................................................................
+
+# Appendix, Chapter, Part, Preface, Reference, PartIntro ...............
+local.appendix.attrib = empty
+appendix.role.attrib = role.attrib
+appendix =
+  element appendix {
+    appendix.attlist,
+    beginpage?,
+    appendixinfo?,
+    bookcomponent.title.content,
+    nav.class*,
+    tocchap?,
+    bookcomponent.content,
+    nav.class*
+  }
+# end of appendix.element
+appendix.attlist &=
+  label.attrib,
+  status.attrib,
+  common.attrib,
+  appendix.role.attrib,
+  local.appendix.attrib
+# end of appendix.attlist
+
+# end of appendix.module
+local.chapter.attrib = empty
+chapter.role.attrib = role.attrib
+chapter =
+  element chapter {
+    chapter.attlist,
+    beginpage?,
+    chapterinfo?,
+    bookcomponent.title.content,
+    nav.class*,
+    tocchap?,
+    bookcomponent.content,
+    nav.class*
+  }
+# end of chapter.element
+chapter.attlist &=
+  label.attrib,
+  status.attrib,
+  common.attrib,
+  chapter.role.attrib,
+  local.chapter.attrib
+# end of chapter.attlist
+
+# end of chapter.module
+
+# Note that Part was to have its content model reduced in V4.2.  This
+# change will not be made after all.
+local.part.attrib = empty
+part.role.attrib = role.attrib
+part =
+  element part {
+    part.attlist,
+    beginpage?,
+    partinfo?,
+    bookcomponent.title.content,
+    partintro?,
+    partcontent.mix+
+  }
+# end of part.element
+part.attlist &=
+  label.attrib,
+  status.attrib,
+  common.attrib,
+  part.role.attrib,
+  local.part.attrib
+# end of part.attlist
+
+# ELEMENT PartIntro (defined below)
+
+# end of part.module
+local.preface.attrib = empty
+preface.role.attrib = role.attrib
+preface =
+  element preface {
+    preface.attlist,
+    beginpage?,
+    prefaceinfo?,
+    bookcomponent.title.content,
+    nav.class*,
+    tocchap?,
+    bookcomponent.content,
+    nav.class*
+  }
+# end of preface.element
+preface.attlist &=
+  status.attrib,
+  common.attrib,
+  preface.role.attrib,
+  local.preface.attrib
+# end of preface.attlist
+
+# end of preface.module
+local.reference.attrib = empty
+reference.role.attrib = role.attrib
+reference =
+  element reference {
+    reference.attlist,
+    beginpage?,
+    referenceinfo?,
+    bookcomponent.title.content,
+    partintro?,
+    refentry.class+
+  }
+# end of reference.element
+reference.attlist &=
+  label.attrib,
+  status.attrib,
+  common.attrib,
+  reference.role.attrib,
+  local.reference.attrib
+# end of reference.attlist
+
+# ELEMENT PartIntro (defined below)
+
+# end of reference.module
+local.partintro.attrib = empty
+partintro.role.attrib = role.attrib
+partintro =
+  element partintro {
+    partintro.attlist, div.title.content?, bookcomponent.content
+  }
+# end of partintro.element
+partintro.attlist &=
+  label.attrib,
+  common.attrib,
+  partintro.role.attrib,
+  local.partintro.attrib
+# end of partintro.attlist
+
+# end of partintro.module
+
+# ......................................................................
+
+# Other Info elements ..................................................
+local.appendixinfo.attrib = empty
+appendixinfo.role.attrib = role.attrib
+appendixinfo =
+  element appendixinfo { appendixinfo.attlist, info.class+ }
+# end of appendixinfo.element
+appendixinfo.attlist &=
+  common.attrib, appendixinfo.role.attrib, local.appendixinfo.attrib
+# end of appendixinfo.attlist
+
+# end of appendixinfo.module
+local.bibliographyinfo.attrib = empty
+bibliographyinfo.role.attrib = role.attrib
+bibliographyinfo =
+  element bibliographyinfo { bibliographyinfo.attlist, info.class+ }
+# end of bibliographyinfo.element
+bibliographyinfo.attlist &=
+  common.attrib,
+  bibliographyinfo.role.attrib,
+  local.bibliographyinfo.attrib
+# end of bibliographyinfo.attlist
+
+# end of bibliographyinfo.module
+local.chapterinfo.attrib = empty
+chapterinfo.role.attrib = role.attrib
+chapterinfo = element chapterinfo { chapterinfo.attlist, info.class+ }
+# end of chapterinfo.element
+chapterinfo.attlist &=
+  common.attrib, chapterinfo.role.attrib, local.chapterinfo.attrib
+# end of chapterinfo.attlist
+
+# end of chapterinfo.module
+local.glossaryinfo.attrib = empty
+glossaryinfo.role.attrib = role.attrib
+glossaryinfo =
+  element glossaryinfo { glossaryinfo.attlist, info.class+ }
+# end of glossaryinfo.element
+glossaryinfo.attlist &=
+  common.attrib, glossaryinfo.role.attrib, local.glossaryinfo.attrib
+# end of glossaryinfo.attlist
+
+# end of glossaryinfo.module
+local.indexinfo.attrib = empty
+indexinfo.role.attrib = role.attrib
+indexinfo = element indexinfo { indexinfo.attlist, info.class+ }
+# end of indexinfo.element
+indexinfo.attlist &=
+  common.attrib, indexinfo.role.attrib, local.indexinfo.attrib
+# end of indexinfo.attlist
+
+# end of indexinfo.module
+local.setindexinfo.attrib = empty
+setindexinfo.role.attrib = role.attrib
+setindexinfo =
+  element setindexinfo { setindexinfo.attlist, info.class+ }
+# end of setindexinfo.element
+setindexinfo.attlist &=
+  common.attrib, setindexinfo.role.attrib, local.setindexinfo.attrib
+# end of setindexinfo.attlist
+
+# end of setindexinfo.module
+local.partinfo.attrib = empty
+partinfo.role.attrib = role.attrib
+partinfo = element partinfo { partinfo.attlist, info.class+ }
+# end of partinfo.element
+partinfo.attlist &=
+  common.attrib, partinfo.role.attrib, local.partinfo.attrib
+# end of partinfo.attlist
+
+# end of partinfo.module
+local.prefaceinfo.attrib = empty
+prefaceinfo.role.attrib = role.attrib
+prefaceinfo = element prefaceinfo { prefaceinfo.attlist, info.class+ }
+# end of prefaceinfo.element
+prefaceinfo.attlist &=
+  common.attrib, prefaceinfo.role.attrib, local.prefaceinfo.attrib
+# end of prefaceinfo.attlist
+
+# end of prefaceinfo.module
+local.refentryinfo.attrib = empty
+refentryinfo.role.attrib = role.attrib
+refentryinfo =
+  element refentryinfo { refentryinfo.attlist, info.class+ }
+# end of refentryinfo.element
+refentryinfo.attlist &=
+  common.attrib, refentryinfo.role.attrib, local.refentryinfo.attrib
+# end of refentryinfo.attlist
+
+# end of refentryinfo.module
+local.refsectioninfo.attrib = empty
+refsectioninfo.role.attrib = role.attrib
+refsectioninfo =
+  element refsectioninfo { refsectioninfo.attlist, info.class+ }
+# end of refsectioninfo.element
+refsectioninfo.attlist &=
+  common.attrib, refsectioninfo.role.attrib, local.refsectioninfo.attrib
+# end of refsectioninfo.attlist
+
+# end of refsectioninfo.module
+local.refsect1info.attrib = empty
+refsect1info.role.attrib = role.attrib
+refsect1info =
+  element refsect1info { refsect1info.attlist, info.class+ }
+# end of refsect1info.element
+refsect1info.attlist &=
+  common.attrib, refsect1info.role.attrib, local.refsect1info.attrib
+# end of refsect1info.attlist
+
+# end of refsect1info.module
+local.refsect2info.attrib = empty
+refsect2info.role.attrib = role.attrib
+refsect2info =
+  element refsect2info { refsect2info.attlist, info.class+ }
+# end of refsect2info.element
+refsect2info.attlist &=
+  common.attrib, refsect2info.role.attrib, local.refsect2info.attrib
+# end of refsect2info.attlist
+
+# end of refsect2info.module
+local.refsect3info.attrib = empty
+refsect3info.role.attrib = role.attrib
+refsect3info =
+  element refsect3info { refsect3info.attlist, info.class+ }
+# end of refsect3info.element
+refsect3info.attlist &=
+  common.attrib, refsect3info.role.attrib, local.refsect3info.attrib
+# end of refsect3info.attlist
+
+# end of refsect3info.module
+local.refsynopsisdivinfo.attrib = empty
+refsynopsisdivinfo.role.attrib = role.attrib
+refsynopsisdivinfo =
+  element refsynopsisdivinfo { refsynopsisdivinfo.attlist, info.class+ }
+# end of refsynopsisdivinfo.element
+refsynopsisdivinfo.attlist &=
+  common.attrib,
+  refsynopsisdivinfo.role.attrib,
+  local.refsynopsisdivinfo.attrib
+# end of refsynopsisdivinfo.attlist
+
+# end of refsynopsisdivinfo.module
+local.referenceinfo.attrib = empty
+referenceinfo.role.attrib = role.attrib
+referenceinfo =
+  element referenceinfo { referenceinfo.attlist, info.class+ }
+# end of referenceinfo.element
+referenceinfo.attlist &=
+  common.attrib, referenceinfo.role.attrib, local.referenceinfo.attrib
+# end of referenceinfo.attlist
+
+# end of referenceinfo.module
+local.sect1info.attrib = empty
+sect1info.role.attrib = role.attrib
+sect1info = element sect1info { sect1info.attlist, info.class+ }
+# end of sect1info.element
+sect1info.attlist &=
+  common.attrib, sect1info.role.attrib, local.sect1info.attrib
+# end of sect1info.attlist
+local.sect2info.attrib = empty
+sect2info.role.attrib = role.attrib
+sect2info = element sect2info { sect2info.attlist, info.class+ }
+# end of sect2info.element
+sect2info.attlist &=
+  common.attrib, sect2info.role.attrib, local.sect2info.attrib
+# end of sect2info.attlist
+local.sect3info.attrib = empty
+sect3info.role.attrib = role.attrib
+sect3info = element sect3info { sect3info.attlist, info.class+ }
+# end of sect3info.element
+sect3info.attlist &=
+  common.attrib, sect3info.role.attrib, local.sect3info.attrib
+# end of sect3info.attlist
+local.sect4info.attrib = empty
+sect4info.role.attrib = role.attrib
+sect4info = element sect4info { sect4info.attlist, info.class+ }
+# end of sect4info.element
+sect4info.attlist &=
+  common.attrib, sect4info.role.attrib, local.sect4info.attrib
+# end of sect4info.attlist
+local.sect5info.attrib = empty
+sect5info.role.attrib = role.attrib
+sect5info = element sect5info { sect5info.attlist, info.class+ }
+# end of sect5info.element
+sect5info.attlist &=
+  common.attrib, sect5info.role.attrib, local.sect5info.attrib
+# end of sect5info.attlist
+
+# ......................................................................
+
+# Section (parallel to Sect*) .........................................
+local.section.attrib = empty
+section.role.attrib = role.attrib
+section =
+  element section {
+    section.attlist,
+    sectioninfo?,
+    sect.title.content,
+    nav.class*,
+    ((divcomponent.mix+,
+      (refentry.class* | section.class* | simplesect*))
+     | refentry.class+
+     | section.class+
+     | simplesect+),
+    nav.class*
+  }
+# end of section.element
+section.attlist &=
+  label.attrib,
+  status.attrib,
+  common.attrib,
+  section.role.attrib,
+  local.section.attrib
+# end of section.attlist
+
+# end of section.module
+sectioninfo.role.attrib = role.attrib
+local.sectioninfo.attrib = empty
+sectioninfo = element sectioninfo { sectioninfo.attlist, info.class+ }
+# end of sectioninfo.element
+sectioninfo.attlist &=
+  common.attrib, sectioninfo.role.attrib, local.sectioninfo.attrib
+# end of sectioninfo.attlist
+
+# end of sectioninfo.module
+
+# end of section.content.module
+
+# ......................................................................
+
+# Sect1, Sect2, Sect3, Sect4, Sect5 ....................................
+local.sect1.attrib = empty
+sect1.role.attrib = role.attrib
+sect1 =
+  element sect1 {
+    sect1.attlist,
+    sect1info?,
+    sect.title.content,
+    nav.class*,
+    ((divcomponent.mix+, (refentry.class* | sect2* | simplesect*))
+     | refentry.class+
+     | sect2+
+     | simplesect+),
+    nav.class*
+  }
+# end of sect1.element
+
+# Renderas: Indicates the format in which the heading should
+# appear
+sect1.attlist &=
+  attribute renderas { "sect2" | "sect3" | "sect4" | "sect5" }?,
+  label.attrib,
+  status.attrib,
+  common.attrib,
+  sect1.role.attrib,
+  local.sect1.attrib
+# end of sect1.attlist
+
+# end of sect1.module
+local.sect2.attrib = empty
+sect2.role.attrib = role.attrib
+sect2 =
+  element sect2 {
+    sect2.attlist,
+    sect2info?,
+    sect.title.content,
+    nav.class*,
+    ((divcomponent.mix+, (refentry.class* | sect3* | simplesect*))
+     | refentry.class+
+     | sect3+
+     | simplesect+),
+    nav.class*
+  }
+# end of sect2.element
+
+# Renderas: Indicates the format in which the heading should
+# appear
+sect2.attlist &=
+  attribute renderas { "sect1" | "sect3" | "sect4" | "sect5" }?,
+  label.attrib,
+  status.attrib,
+  common.attrib,
+  sect2.role.attrib,
+  local.sect2.attrib
+# end of sect2.attlist
+
+# end of sect2.module
+local.sect3.attrib = empty
+sect3.role.attrib = role.attrib
+sect3 =
+  element sect3 {
+    sect3.attlist,
+    sect3info?,
+    sect.title.content,
+    nav.class*,
+    ((divcomponent.mix+, (refentry.class* | sect4* | simplesect*))
+     | refentry.class+
+     | sect4+
+     | simplesect+),
+    nav.class*
+  }
+# end of sect3.element
+
+# Renderas: Indicates the format in which the heading should
+# appear
+sect3.attlist &=
+  attribute renderas { "sect1" | "sect2" | "sect4" | "sect5" }?,
+  label.attrib,
+  status.attrib,
+  common.attrib,
+  sect3.role.attrib,
+  local.sect3.attrib
+# end of sect3.attlist
+
+# end of sect3.module
+local.sect4.attrib = empty
+sect4.role.attrib = role.attrib
+sect4 =
+  element sect4 {
+    sect4.attlist,
+    sect4info?,
+    sect.title.content,
+    nav.class*,
+    ((divcomponent.mix+, (refentry.class* | sect5* | simplesect*))
+     | refentry.class+
+     | sect5+
+     | simplesect+),
+    nav.class*
+  }
+# end of sect4.element
+
+# Renderas: Indicates the format in which the heading should
+# appear
+sect4.attlist &=
+  attribute renderas { "sect1" | "sect2" | "sect3" | "sect5" }?,
+  label.attrib,
+  status.attrib,
+  common.attrib,
+  sect4.role.attrib,
+  local.sect4.attrib
+# end of sect4.attlist
+
+# end of sect4.module
+local.sect5.attrib = empty
+sect5.role.attrib = role.attrib
+sect5 =
+  element sect5 {
+    sect5.attlist,
+    sect5info?,
+    sect.title.content,
+    nav.class*,
+    ((divcomponent.mix+, (refentry.class* | simplesect*))
+     | refentry.class+
+     | simplesect+),
+    nav.class*
+  }
+# end of sect5.element
+
+# Renderas: Indicates the format in which the heading should
+# appear
+sect5.attlist &=
+  attribute renderas { "sect1" | "sect2" | "sect3" | "sect4" }?,
+  label.attrib,
+  status.attrib,
+  common.attrib,
+  sect5.role.attrib,
+  local.sect5.attrib
+# end of sect5.attlist
+
+# end of sect5.module
+local.simplesect.attrib = empty
+simplesect.role.attrib = role.attrib
+simplesect =
+  element simplesect {
+    simplesect.attlist, sect.title.content, divcomponent.mix+
+  }
+# end of simplesect.element
+simplesect.attlist &=
+  common.attrib, simplesect.role.attrib, local.simplesect.attrib
+# end of simplesect.attlist
+
+# end of simplesect.module
+
+# ......................................................................
+
+# Bibliography .........................................................
+local.bibliography.attrib = empty
+bibliography.role.attrib = role.attrib
+bibliography =
+  element bibliography {
+    bibliography.attlist,
+    bibliographyinfo?,
+    bookcomponent.title.content?,
+    component.mix*,
+    (bibliodiv+ | (biblioentry | bibliomixed)+)
+  }
+# end of bibliography.element
+bibliography.attlist &=
+  status.attrib,
+  common.attrib,
+  bibliography.role.attrib,
+  local.bibliography.attrib
+# end of bibliography.attlist
+
+# end of bibliography.module
+local.bibliodiv.attrib = empty
+bibliodiv.role.attrib = role.attrib
+bibliodiv =
+  element bibliodiv {
+    bibliodiv.attlist,
+    sect.title.content?,
+    component.mix*,
+    (biblioentry | bibliomixed)+
+  }
+# end of bibliodiv.element
+bibliodiv.attlist &=
+  status.attrib,
+  common.attrib,
+  bibliodiv.role.attrib,
+  local.bibliodiv.attrib
+# end of bibliodiv.attlist
+
+# end of bibliodiv.module
+
+# end of bibliography.content.module
+
+# ......................................................................
+
+# Glossary .............................................................
+local.glossary.attrib = empty
+glossary.role.attrib = role.attrib
+glossary =
+  element glossary {
+    glossary.attlist,
+    glossaryinfo?,
+    bookcomponent.title.content?,
+    component.mix*,
+    (glossdiv+ | glossentry+),
+    bibliography?
+  }
+# end of glossary.element
+glossary.attlist &=
+  status.attrib,
+  common.attrib,
+  glossary.role.attrib,
+  local.glossary.attrib
+# end of glossary.attlist
+
+# end of glossary.module
+local.glossdiv.attrib = empty
+glossdiv.role.attrib = role.attrib
+glossdiv =
+  element glossdiv {
+    glossdiv.attlist, sect.title.content, component.mix*, glossentry+
+  }
+# end of glossdiv.element
+glossdiv.attlist &=
+  status.attrib,
+  common.attrib,
+  glossdiv.role.attrib,
+  local.glossdiv.attrib
+# end of glossdiv.attlist
+
+# end of glossdiv.module
+
+# end of glossary.content.module
+
+# ......................................................................
+
+# Index and SetIndex ...................................................
+local.indexes.attrib = empty
+indexes.role.attrib = role.attrib
+index =
+  element index {
+    index.attlist,
+    indexinfo?,
+    bookcomponent.title.content?,
+    component.mix*,
+    (indexdiv* | indexentry*)
+  }
+# end of index.element
+index.attlist &=
+  common.attrib, indexes.role.attrib, local.indexes.attrib
+# end of index.attlist
+setindex =
+  element setindex {
+    setindex.attlist,
+    setindexinfo?,
+    bookcomponent.title.content?,
+    component.mix*,
+    (indexdiv* | indexentry*)
+  }
+# end of setindex.element
+setindex.attlist &=
+  common.attrib, indexes.role.attrib, local.indexes.attrib
+# end of setindex.attlist
+
+# end of indexes.module
+
+# SegmentedList in this content is useful for marking up permuted
+# indices.
+local.indexdiv.attrib = empty
+indexdiv.role.attrib = role.attrib
+indexdiv =
+  element indexdiv {
+    indexdiv.attlist,
+    sect.title.content?,
+    (indexdivcomponent.mix*, (indexentry+ | segmentedlist))
+  }
+# end of indexdiv.element
+indexdiv.attlist &=
+  common.attrib, indexdiv.role.attrib, local.indexdiv.attrib
+# end of indexdiv.attlist
+
+# end of indexdiv.module
+
+# Index entries appear in the index, not the text.
+local.indexentry.attrib = empty
+indexentry.role.attrib = role.attrib
+indexentry =
+  element indexentry {
+    indexentry.attlist,
+    primaryie,
+    (seeie | seealsoie)*,
+    (secondaryie, (seeie | seealsoie | tertiaryie)*)*
+  }
+# end of indexentry.element
+indexentry.attlist &=
+  common.attrib, indexentry.role.attrib, local.indexentry.attrib
+# end of indexentry.attlist
+
+# end of indexentry.module
+local.primsecterie.attrib = empty
+primsecterie.role.attrib = role.attrib
+primaryie = element primaryie { primaryie.attlist, ndxterm.char.mix* }
+# end of primaryie.element
+
+# to IndexTerms that these entries represent
+primaryie.attlist &=
+  linkends.attrib,
+  common.attrib,
+  primsecterie.role.attrib,
+  local.primsecterie.attrib
+# end of primaryie.attlist
+secondaryie =
+  element secondaryie { secondaryie.attlist, ndxterm.char.mix* }
+# end of secondaryie.element
+
+# to IndexTerms that these entries represent
+secondaryie.attlist &=
+  linkends.attrib,
+  common.attrib,
+  primsecterie.role.attrib,
+  local.primsecterie.attrib
+# end of secondaryie.attlist
+tertiaryie =
+  element tertiaryie { tertiaryie.attlist, ndxterm.char.mix* }
+# end of tertiaryie.element
+
+# to IndexTerms that these entries represent
+tertiaryie.attlist &=
+  linkends.attrib,
+  common.attrib,
+  primsecterie.role.attrib,
+  local.primsecterie.attrib
+# end of tertiaryie.attlist
+
+# end of primsecterie.module
+local.seeie.attrib = empty
+seeie.role.attrib = role.attrib
+seeie = element seeie { seeie.attlist, ndxterm.char.mix* }
+# end of seeie.element
+
+# to IndexEntry to look up
+seeie.attlist &=
+  linkend.attrib, common.attrib, seeie.role.attrib, local.seeie.attrib
+# end of seeie.attlist
+
+# end of seeie.module
+local.seealsoie.attrib = empty
+seealsoie.role.attrib = role.attrib
+seealsoie = element seealsoie { seealsoie.attlist, ndxterm.char.mix* }
+# end of seealsoie.element
+
+# to related IndexEntries
+seealsoie.attlist &=
+  linkends.attrib,
+  common.attrib,
+  seealsoie.role.attrib,
+  local.seealsoie.attrib
+# end of seealsoie.attlist
+
+# end of seealsoie.module
+
+# end of index.content.module
+
+# ......................................................................
+
+# RefEntry .............................................................
+local.refentry.attrib = empty
+refentry.role.attrib = role.attrib
+refentry =
+  element refentry {
+    refentry.attlist,
+    beginpage?,
+    ndxterm.class*,
+    refentryinfo?,
+    refmeta?,
+    (remark | link.char.class)*,
+    refnamediv,
+    refsynopsisdiv?,
+    (refsect1+ | refsection+)
+  }
+# end of refentry.element
+refentry.attlist &=
+  status.attrib,
+  common.attrib,
+  refentry.role.attrib,
+  local.refentry.attrib
+# end of refentry.attlist
+
+# end of refentry.module
+local.refmeta.attrib = empty
+refmeta.role.attrib = role.attrib
+refmeta =
+  element refmeta {
+    refmeta.attlist,
+    ndxterm.class*,
+    refentrytitle,
+    manvolnum?,
+    refmiscinfo*,
+    ndxterm.class*
+  }
+# end of refmeta.element
+refmeta.attlist &=
+  common.attrib, refmeta.role.attrib, local.refmeta.attrib
+# end of refmeta.attlist
+
+# end of refmeta.module
+local.refmiscinfo.attrib = empty
+refmiscinfo.role.attrib = role.attrib
+refmiscinfo =
+  element refmiscinfo { refmiscinfo.attlist, docinfo.char.mix* }
+# end of refmiscinfo.element
+
+# Class: Freely assignable parameter; no default
+refmiscinfo.attlist &=
+  attribute class { text }?,
+  common.attrib,
+  refmiscinfo.role.attrib,
+  local.refmiscinfo.attrib
+# end of refmiscinfo.attlist
+
+# end of refmiscinfo.module
+local.refnamediv.attrib = empty
+refnamediv.role.attrib = role.attrib
+refnamediv =
+  element refnamediv {
+    refnamediv.attlist,
+    refdescriptor?,
+    refname+,
+    refpurpose,
+    refclass*,
+    (remark | link.char.class)*
+  }
+# end of refnamediv.element
+refnamediv.attlist &=
+  common.attrib, refnamediv.role.attrib, local.refnamediv.attrib
+# end of refnamediv.attlist
+
+# end of refnamediv.module
+local.refdescriptor.attrib = empty
+refdescriptor.role.attrib = role.attrib
+refdescriptor =
+  element refdescriptor { refdescriptor.attlist, refname.char.mix* }
+# end of refdescriptor.element
+refdescriptor.attlist &=
+  common.attrib, refdescriptor.role.attrib, local.refdescriptor.attrib
+# end of refdescriptor.attlist
+
+# end of refdescriptor.module
+local.refname.attrib = empty
+refname.role.attrib = role.attrib
+refname = element refname { refname.attlist, refname.char.mix* }
+# end of refname.element
+refname.attlist &=
+  common.attrib, refname.role.attrib, local.refname.attrib
+# end of refname.attlist
+
+# end of refname.module
+local.refpurpose.attrib = empty
+refpurpose.role.attrib = role.attrib
+refpurpose =
+  element refpurpose { refpurpose.attlist, refinline.char.mix* }
+# end of refpurpose.element
+refpurpose.attlist &=
+  common.attrib, refpurpose.role.attrib, local.refpurpose.attrib
+# end of refpurpose.attlist
+
+# end of refpurpose.module
+local.refclass.attrib = empty
+refclass.role.attrib = role.attrib
+refclass = element refclass { refclass.attlist, refclass.char.mix* }
+# end of refclass.element
+refclass.attlist &=
+  common.attrib, refclass.role.attrib, local.refclass.attrib
+# end of refclass.attlist
+
+# end of refclass.module
+local.refsynopsisdiv.attrib = empty
+refsynopsisdiv.role.attrib = role.attrib
+refsynopsisdiv =
+  element refsynopsisdiv {
+    refsynopsisdiv.attlist,
+    refsynopsisdivinfo?,
+    refsect.title.content?,
+    ((refcomponent.mix+, refsect2*) | refsect2+)
+  }
+# end of refsynopsisdiv.element
+refsynopsisdiv.attlist &=
+  common.attrib, refsynopsisdiv.role.attrib, local.refsynopsisdiv.attrib
+# end of refsynopsisdiv.attlist
+
+# end of refsynopsisdiv.module
+local.refsection.attrib = empty
+refsection.role.attrib = role.attrib
+refsection =
+  element refsection {
+    refsection.attlist,
+    refsectioninfo?,
+    refsect.title.content,
+    ((refcomponent.mix+, refsection*) | refsection+)
+  }
+# end of refsection.element
+refsection.attlist &=
+  status.attrib,
+  common.attrib,
+  refsection.role.attrib,
+  local.refsection.attrib
+# end of refsection.attlist
+
+# end of refsection.module
+local.refsect1.attrib = empty
+refsect1.role.attrib = role.attrib
+refsect1 =
+  element refsect1 {
+    refsect1.attlist,
+    refsect1info?,
+    refsect.title.content,
+    ((refcomponent.mix+, refsect2*) | refsect2+)
+  }
+# end of refsect1.element
+refsect1.attlist &=
+  status.attrib,
+  common.attrib,
+  refsect1.role.attrib,
+  local.refsect1.attrib
+# end of refsect1.attlist
+
+# end of refsect1.module
+local.refsect2.attrib = empty
+refsect2.role.attrib = role.attrib
+refsect2 =
+  element refsect2 {
+    refsect2.attlist,
+    refsect2info?,
+    refsect.title.content,
+    ((refcomponent.mix+, refsect3*) | refsect3+)
+  }
+# end of refsect2.element
+refsect2.attlist &=
+  status.attrib,
+  common.attrib,
+  refsect2.role.attrib,
+  local.refsect2.attrib
+# end of refsect2.attlist
+
+# end of refsect2.module
+local.refsect3.attrib = empty
+refsect3.role.attrib = role.attrib
+refsect3 =
+  element refsect3 {
+    refsect3.attlist,
+    refsect3info?,
+    refsect.title.content,
+    refcomponent.mix+
+  }
+# end of refsect3.element
+refsect3.attlist &=
+  status.attrib,
+  common.attrib,
+  refsect3.role.attrib,
+  local.refsect3.attrib
+# end of refsect3.attlist
+
+# end of refsect3.module
+
+# end of refentry.content.module
+
+# ......................................................................
+
+# Article ..............................................................
+
+# An Article is a chapter-level, stand-alone document that is often,
+# but need not be, collected into a Book.
+local.article.attrib = empty
+article.role.attrib = role.attrib
+article =
+  element article {
+    article.attlist,
+    div.title.content?,
+    articleinfo?,
+    tocchap?,
+    lot*,
+    bookcomponent.content,
+    (nav.class | appendix.class | ackno)*
+  }
+# end of article.element
+
+# Class: Indicates the type of a particular article;
+# all articles have the same structure and general purpose.
+# No default.
+
+# ParentBook: ID of the enclosing Book
+article.attlist &=
+  attribute class {
+    "journalarticle"
+    | "productsheet"
+    | "whitepaper"
+    | "techreport"
+    | "specification"
+    | "faq"
+  }?,
+  attribute parentbook { xsd:IDREF }?,
+  status.attrib,
+  common.attrib,
+  article.role.attrib,
+  local.article.attrib
+# end of article.attlist
+
+# end of article.module
+
+# End of DocBook document hierarchy module V4.2 ........................
+
+# ......................................................................
diff --git a/etc/schema/dbnotn.rnc b/etc/schema/dbnotn.rnc
new file mode 100644
index 00000000000..2a6185f27fd
--- /dev/null
+++ b/etc/schema/dbnotn.rnc
@@ -0,0 +1,84 @@
+# ......................................................................
+
+# DocBook notations module V4.2 ........................................
+
+# File dbnotnx.mod .....................................................
+
+# Copyright 1992-2002 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: dbnotn.rnc,v 1.1 2003/08/30 04:19:27 jjc Exp $
+# 
+# Permission to use, copy, modify and distribute the DocBook 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 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 entity declarations for the standard ISO
+# entity sets used by DocBook.
+# 
+# In DTD driver files referring to this module, please use an entity
+# declaration that uses the public identifier shown below:
+# 
+# <!ENTITY % dbnotn PUBLIC
+# "-//OASIS//ENTITIES DocBook Notations V4.2//EN"
+# "dbnotnx.mod">
+# %dbnotn;
+# 
+# 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.
+
+local.notation.class = notAllowed
+notation.class =
+  "BMP"
+  | "CGM-CHAR"
+  | "CGM-BINARY"
+  | "CGM-CLEAR"
+  | "DITROFF"
+  | "DVI"
+  | "EPS"
+  | "EQN"
+  | "FAX"
+  | "GIF"
+  | "GIF87a"
+  | "GIF89a"
+  | "JPG"
+  | "JPEG"
+  | "IGES"
+  | "PCX"
+  | "PIC"
+  | "PNG"
+  | "PS"
+  | "SGML"
+  | "TBL"
+  | "TEX"
+  | "TIFF"
+  | "WMF"
+  | "WPG"
+  | "SVG"
+  | "linespecific"
+  | local.notation.class
+# WordPerfect Graphic format
+
+# End of DocBook notations module V4.2 .................................
+
+# ......................................................................
diff --git a/etc/schema/dbpool.rnc b/etc/schema/dbpool.rnc
new file mode 100644
index 00000000000..46236eb7b7b
--- /dev/null
+++ b/etc/schema/dbpool.rnc
@@ -0,0 +1,5083 @@
+# This file was generated automatically by Trang.  The table model
+# dependent definitions have been moved into separate files.
+
+# ......................................................................
+
+# DocBook XML information pool module V4.2 .............................
+
+# File dbpoolx.mod .....................................................
+
+# Copyright 1992-2002 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: dbpool.rnc,v 1.4 2003/08/30 07:48:31 jjc Exp $
+# 
+# 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.2//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.
+
+# ......................................................................
+
+# General-purpose semantics entities ...................................
+
+namespace a = "http://relaxng.org/ns/compatibility/annotations/1.0"
+
+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
+  | 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
+  | 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 | local.xref.char.class
+local.gen.char.class = notAllowed
+gen.char.class =
+  abbrev
+  | acronym
+  | citation
+  | citerefentry
+  | citetitle
+  | emphasis
+  | firstterm
+  | foreignphrase
+  | glossterm
+  | footnote
+  | phrase
+  | 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
+  | command
+  | computeroutput
+  | database
+  | email
+  | envar
+  | errorcode
+  | errorname
+  | errortype
+  | errortext
+  | filename
+  | function
+  | guibutton
+  | guiicon
+  | guilabel
+  | guimenu
+  | guimenuitem
+  | guisubmenu
+  | hardware
+  | interface
+  | keycap
+  | keycode
+  | keycombo
+  | keysym
+  | literal
+  | constant
+  | markup
+  | medialabel
+  | menuchoice
+  | mousebutton
+  | option
+  | optional
+  | parameter
+  | prompt
+  | property
+  | replaceable
+  | returnvalue
+  | sgmltag
+  | structfield
+  | structname
+  | symbol
+  | systemitem
+  | \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
+  | 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
+  | 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
+  | 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
+  | 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
+  | 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
+  | local.admon.mix
+local.figure.mix = notAllowed
+figure.mix =
+  linespecific.class
+  | synop.class
+  | informal.class
+  | ndxterm.class
+  | beginpage
+  | local.figure.mix
+local.tabentry.mix = notAllowed
+tabentry.mix =
+  list.class
+  | admon.class
+  | linespecific.class
+  | para.class
+  | graphic
+  | mediaobject
+  | 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
+  | 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
+  | 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.
+
+# The DocBook TC may produce an official forms module for DocBook.
+
+# This PE provides the hook by which it can be inserted into the DTD.
+forminlines.hook = notAllowed
+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 }?
+local.effectivity.attrib = empty
+effectivity.attrib =
+  arch.attrib,
+  condition.attrib,
+  conformance.attrib,
+  os.attrib,
+  revision.attrib,
+  security.attrib,
+  userlevel.attrib,
+  vendor.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
+# Role is included explicitly on each element
+common.attrib =
+  id.attrib,
+  lang.attrib,
+  remap.attrib,
+  xreflabel.attrib,
+  revisionflag.attrib,
+  effectivity.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,
+  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 }?
+# Format: whether element is assumed to contain significant white
+# space
+linespecific.attrib =
+  [ a:defaultValue = "linespecific" ]
+  attribute format { "linespecific" }?,
+  attribute linenumbering { "numbered" | "unnumbered" }?
+# 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
+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
+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
+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
+  | 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
+local.biblioentry.attrib = empty
+biblioentry.role.attrib = role.attrib
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+
+# QandASet ........................
+local.qandaset.attrib = empty
+qandaset.role.attrib = role.attrib
+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
+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
+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
+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
+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
+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
+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
+step =
+  element step {
+    step.attlist,
+    title?,
+    ((component.mix+, (substeps, component.mix*)?)
+     | (substeps, 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
+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
+
+# end of procedure.content.module
+
+# Sidebar ..........................
+local.sidebarinfo.attrib = empty
+sidebarinfo.role.attrib = role.attrib
+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
+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
+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
+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
+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
+blockquote =
+  element blockquote {
+    blockquote.attlist, 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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+glosslist = element glosslist { glosslist.attlist, 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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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 }?,
+  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
+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
+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
+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
+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
+example =
+  element example {
+    example.attlist,
+    blockinfo?,
+    formalobject.title.content,
+    example.mix+
+  }
+# end of example.element
+example.attlist &=
+  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
+informalexample =
+  element informalexample {
+    informalexample.attlist, blockinfo?, example.mix+
+  }
+# end of informalexample.element
+informalexample.attlist &=
+  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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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 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
+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 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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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.caption.attrib = empty
+caption.role.attrib = role.attrib
+caption = element caption { caption.attlist, textobject.mix* }
+# end of caption.element
+caption.attlist &=
+  common.attrib, caption.role.attrib, local.caption.attrib
+# end of caption.attlist
+
+# end of caption.module
+local.mediaobjectco.attrib = empty
+mediaobjectco.role.attrib = role.attrib
+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
+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+)
+inlineequation.content = alt?, (graphic+ | inlinemediaobject+)
+local.equation.attrib = empty
+equation.role.attrib = role.attrib
+equation =
+  element equation {
+    equation.attlist,
+    blockinfo?,
+    formalobject.title.content?,
+    (informalequation | equation.content)
+  }
+# end of equation.element
+equation.attlist &=
+  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
+informalequation =
+  element informalequation {
+    informalequation.attlist, blockinfo?, equation.content
+  }
+# end of informalequation.element
+informalequation.attlist &=
+  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
+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
+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
+
+# Tables ...........................
+
+tables.role.attrib = role.attrib
+
+# Note that InformalTable is dependent on some of the entity
+# declarations that customize Table.
+local.informaltable.attrib = empty
+informaltable =
+  element informaltable {
+    informaltable.attlist,
+    blockinfo?,
+    textobject*,
+    (graphic+ | mediaobject+ | tgroup+)
+  }
+# 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 {
+    "top" | "bottom" | "topbot" | "all" | "sides" | "none"
+  }?,
+  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
+
+# ......................................................................
+
+# Synopses .............................................................
+
+# Synopsis .........................
+local.synopsis.attrib = empty
+synopsis.role.attrib = role.attrib
+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
+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
+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
+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
+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
+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
+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
+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
+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
+funcprototype =
+  element funcprototype {
+    funcprototype.attlist, funcdef, (void | varargs | paramdef+)
+  }
+# 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
+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
+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
+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
+paramdef =
+  element paramdef {
+    paramdef.attlist,
+    (text | type | replaceable | parameter | funcparams)*
+  }
+# end of paramdef.element
+paramdef.attlist &=
+  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
+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
+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
+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
+ooclass = element ooclass { ooclass.attlist, modifier*, 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
+oointerface =
+  element oointerface { oointerface.attlist, modifier*, 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
+ooexception =
+  element ooexception { ooexception.attlist, modifier*, 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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+authorgroup =
+  element authorgroup {
+    authorgroup.attlist,
+    (author | editor | collab | corpauthor | 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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+
+# CorpName .........................
+local.corpname.attrib = empty
+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
+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
+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
+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
+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
+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"
+    | "issn"
+    | "libraryofcongress"
+    | "pubnumber"
+    | "other"
+  }?,
+  attribute otherclass { text }?
+local.biblioid.attrib = empty
+biblioid.role.attrib = role.attrib
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+othercredit =
+  element othercredit {
+    othercredit.attlist,
+    (personname | person.ident.mix+),
+    (personblurb | email | address)*
+  }
+# end of othercredit.element
+othercredit.attlist &=
+  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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+revision =
+  element revision {
+    revision.attlist,
+    revnumber,
+    date,
+    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
+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
+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
+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
+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
+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
+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
+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
+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
+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.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
+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
+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
+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
+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
+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"
+  }?,
+  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
+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
+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
+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
+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
+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
+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
+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
+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
+guibutton =
+  element guibutton { guibutton.attlist, (smallcptr.char.mix | accel)* }
+# 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
+guiicon =
+  element guiicon { guiicon.attlist, (smallcptr.char.mix | accel)* }
+# 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
+guilabel =
+  element guilabel { guilabel.attlist, (smallcptr.char.mix | accel)* }
+# 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
+guimenu =
+  element guimenu { guimenu.attlist, (smallcptr.char.mix | accel)* }
+# 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
+guimenuitem =
+  element guimenuitem {
+    guimenuitem.attlist, (smallcptr.char.mix | accel)*
+  }
+# 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
+guisubmenu =
+  element guisubmenu {
+    guisubmenu.attlist, (smallcptr.char.mix | accel)*
+  }
+# 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
+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
+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
+keycap = element keycap { keycap.attlist, cptr.char.mix* }
+# end of keycap.element
+keycap.attlist &=
+  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
+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
+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
+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
+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
+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.constant.attrib = empty
+constant.role.attrib = role.attrib
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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"
+  }?,
+  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
+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
+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
+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
+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"
+    | "event"
+    | "eventhandler"
+    | "domainname"
+    | "fqdomainname"
+    | "ipaddress"
+    | "netmask"
+    | "etheraddress"
+    | "groupname"
+    | "library"
+    | "macro"
+    | "osname"
+    | "filesystem"
+    | "resource"
+    | "systemname"
+    | "username"
+    | "newsgroup"
+  }?,
+  moreinfo.attrib,
+  common.attrib,
+  systemitem.role.attrib,
+  local.systemitem.attrib
+# end of systemitem.attlist
+
+# end of systemitem.module
+local.token.attrib = empty
+token.role.attrib = role.attrib
+\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
+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
+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
+
+# General words and phrases ............................................
+local.abbrev.attrib = empty
+abbrev.role.attrib = role.attrib
+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
+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
+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
+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
+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
+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
+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"
+  }?,
+  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
+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.firstterm.attrib = empty
+firstterm.role.attrib = role.attrib
+firstterm = element firstterm { firstterm.attlist, word.char.mix* }
+# end of firstterm.element
+
+# to GlossEntry or other explanation
+firstterm.attlist &=
+  linkend.attrib,
+  common.attrib,
+  firstterm.role.attrib,
+  local.firstterm.attrib
+# end of firstterm.attlist
+
+# end of firstterm.module
+local.foreignphrase.attrib = empty
+foreignphrase.role.attrib = role.attrib
+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
+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 &=
+  linkend.attrib,
+  attribute baseform { text }?,
+  common.attrib,
+  glossterm.role.attrib,
+  local.glossterm.attrib
+# end of glossterm.attlist
+
+# end of glossterm.module
+local.phrase.attrib = empty
+phrase.role.attrib = role.attrib
+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
+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
+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
+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
+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
+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
+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 }?,
+  linkendreq.attrib,
+  attribute type { text }?,
+  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
+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 }?,
+  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
+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 }?,
+  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
+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
+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 }?,
+  linkendreq.attrib,
+  common.attrib,
+  xref.role.attrib,
+  local.xref.attrib
+# end of xref.attlist
+
+# end of xref.module
+
+# Ubiquitous elements ..................................................
+local.anchor.attrib = empty
+anchor.role.attrib = role.attrib
+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
+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
+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 }?,
+  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
+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
+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
+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
+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
+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.2 ......................
+
+# ......................................................................
diff --git a/etc/schema/dbsoextbl.rnc b/etc/schema/dbsoextbl.rnc
new file mode 100644
index 00000000000..a547586ca17
--- /dev/null
+++ b/etc/schema/dbsoextbl.rnc
@@ -0,0 +1,30 @@
+# Definitions specific to the OASIS XML Exchange Table Model.
+
+# Reference OASIS Exchange Table Model
+include "soextbl.rnc" {
+  # Override definition of start
+  start |= notAllowed
+  # Add common attributes and the Label attribute to Table and
+  # InformalTable.
+  bodyatt = common.attrib, label.attrib, tables.role.attrib
+  # Add common attributes to TGroup, ColSpec, TBody, THead, Row, Entry
+  tbl.tgroup.att = common.attrib
+  tbl.colspec.att = common.attrib
+  tbl.tbody.att = common.attrib
+  tbl.thead.att = common.attrib
+  tbl.row.att = common.attrib
+  tbl.entry.att = common.attrib
+  # Content model for Table.
+  tbl.table.mdl =
+    blockinfo?,
+    formalobject.title.content,
+    ndxterm.class*,
+    textobject*,
+    (graphic+ | mediaobject+ | tgroup+)
+  # Allow either objects or inlines; beware of REs between elements.
+  tbl.entry.mdl = (para.char.mix | tabentry.mix)*
+}
+
+common.table.attribs = bodyatt
+
+# end of table.module
diff --git a/etc/schema/dbstart.rnc b/etc/schema/dbstart.rnc
new file mode 100644
index 00000000000..284f9b5b5a5
--- /dev/null
+++ b/etc/schema/dbstart.rnc
@@ -0,0 +1,23 @@
+# This choice of root elements comes from the 1.0b1 RNG schema at
+# http://www.oasis-open.org/docbook/relaxng/1.0b1/index.shtml
+
+start = 
+  set
+  | setindex
+  | book
+  | part
+  | reference
+  | preface
+  | chapter
+  | appendix
+  | article
+  | bibliography
+  | glossary
+  | index
+  | refentry
+  | sect1
+  | sect2
+  | sect3
+  | sect4
+  | sect5
+  | section
diff --git a/etc/schema/docbook-dyntbl.rnc b/etc/schema/docbook-dyntbl.rnc
new file mode 100644
index 00000000000..9bb997ff734
--- /dev/null
+++ b/etc/schema/docbook-dyntbl.rnc
@@ -0,0 +1,18 @@
+# Variant of docbook.rnc that allows the table model to be selected
+# dynamically based on the definitions of cals.table.module and
+# exchange.table.module.  See dbdyntbl.rnc.
+
+# Document (root) elements
+include "dbstart.rnc"
+
+# Notation declarations
+include "dbnotn.rnc"
+
+# Information pool
+include "dbpool.rnc"
+
+# Dynamic Table Model
+include "dbdyntbl.rnc"
+
+# Document hierarchy
+include "dbhier.rnc"
diff --git a/etc/schema/docbook-soextbl.rnc b/etc/schema/docbook-soextbl.rnc
new file mode 100644
index 00000000000..945a6219dba
--- /dev/null
+++ b/etc/schema/docbook-soextbl.rnc
@@ -0,0 +1,17 @@
+# Variant of docbook.rnc that uses the OASIS XML Exchange Table Model
+# rather than the CALS Table Model.
+
+# Document (root) elements
+include "dbstart.rnc"
+
+# Notation declarations
+include "dbnotn.rnc"
+
+# Information pool
+include "dbpool.rnc"
+
+# OASIS XML Exchange Table Model
+include "dbsoextbl.rnc"
+
+# Document hierarchy
+include "dbhier.rnc"
diff --git a/etc/schema/docbook.rnc b/etc/schema/docbook.rnc
new file mode 100644
index 00000000000..d10f614b286
--- /dev/null
+++ b/etc/schema/docbook.rnc
@@ -0,0 +1,48 @@
+# Unofficial DocBook RELAX NG Compact Syntax schema
+
+# This file was generated automatically by Trang
+# (http://www.thaiopensource.com/relaxng/trang.html) from the DocBook
+# XML DTD V4.2 (http://www.oasis-open.org/docbook/xml/4.2/), then
+# changing the definition of start, changing the filenames,
+# editing the comments and adding includes of dbstart.rnc
+# and dbcalstbl.rnc.
+
+# The following copyright applies to the DocBook XML DTD V4.2.
+
+# Copyright 1992-2002 HaL Computer Systems, Inc.,
+# O'Reilly & Associates, Inc., ArborText, Inc., Fujitsu Software
+# Corporation, Norman Walsh, Sun Microsystems, Inc., and the
+# Organization for the Advancement of Structured Information
+# Standards (OASIS).
+# 
+# Permission to use, copy, modify and distribute the DocBook 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 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/.
+
+# Document (root) elements
+include "dbstart.rnc"
+
+# Notation declarations
+include "dbnotn.rnc"
+
+# Information pool
+include "dbpool.rnc"
+
+# CALS Table Model
+include "dbcalstbl.rnc"
+
+# Document hierarchy
+include "dbhier.rnc"
diff --git a/etc/schema/locate.rnc b/etc/schema/locate.rnc
new file mode 100644
index 00000000000..89230adf9c0
--- /dev/null
+++ b/etc/schema/locate.rnc
@@ -0,0 +1,200 @@
+default namespace this = "http://thaiopensource.com/ns/locating-rules/1.0"
+namespace local = ""
+
+start = locatingRules
+
+locatingRules =  element locatingRules { common, rule* }
+
+rule =
+  \include
+  # | group
+  | applyFollowingRules
+  | documentElement
+  # | doctypePublicId
+  | \namespace
+  | uri
+  | transformURI
+  # | typeIdProcessingInstruction
+  | \default
+  | typeId
+  # | typeIdBase
+  | extensionRule
+ 
+## Group of rules. Useful with xml:base.
+group = element group { common, rule* }
+
+\include =
+  element include {
+    common,
+    attribute rules { xsd:anyURI }
+  }
+
+applyFollowingRules =
+  element applyFollowingRules {
+    common,
+    attribute ruleType {
+      "documentElement"
+      | "doctypePublicId"
+      | "namespace"
+      | "uri"
+      | "transformURI"
+      | "typeIdProcessingInstruction"
+      | "default"
+    }
+  }
+
+documentElement =
+  ## Matches if the prefix and/or local name of document element
+  ## match the values of the prefix and localName attributes.
+  element documentElement {
+    common,
+    nameAtts,
+    targetAtt
+  }
+
+## If there's no prefix attribute, then only the local name must match.
+## If there's no local name attribute, then only the prefix must match.
+nameAtts = (prefixAtt, localNameAtt?) | localNameAtt
+
+## prefix="" matches if the document element has no prefix.
+prefixAtt = attribute prefix { (xsd:NCName - "xmlns") | "" }
+localNameAtt = attribute localName { xsd:NCName - "xmlns" }
+
+doctypePublicId =
+  ## Matches if the document has a DOCTYPE declaration with a public
+  ## identifier that, after normalization, matches the value of the
+  ## publicId attribute.
+  element doctypePublicId {
+    common,
+    attribute publicId { publicIdValue },
+    targetAtt
+  }
+
+publicIdValue =
+  xsd:token {
+    ## Newline and tab are excluded, because pattern applies to
+    ## the post-normalization value.
+    pattern = "[\-'()+,./:=?;!*#@$_%a-zA-Z0-9 ]*"
+  }
+
+# This is separate from documentElement so it can be distinguished
+# by applyFollowingRules.
+\namespace =
+  ## Matches if the document element has a namespace URI equal to the value
+  ## of the ns attribute.  A document element with no namespace matches if
+  ## the value of the ns attribute is the empty string.
+  element namespace {
+    common,
+    attribute ns { xsd:string },
+    targetAtt
+  }
+
+uri =
+  ## Matches based on the URI of the document.
+  element uri {
+    common,
+    (resourceAtt | patternAtt),
+    targetAtt
+  }
+
+## Matches if it can be determined that the document resource is
+## the same resource as that identified by the value of the resource
+## attribute.  In determining this, the implementation should apply
+## the semantics of the URI scheme used by the URI.
+resourceAtt = attribute resource { xsd:anyURI }
+
+## Matches if the document's URI matches the pattern specified
+## by the pattern attribute.  A * in the path component matches
+## zero or more characters other than / (after resolving escapes).
+## If the pattern is a relative URI, it means that there must
+## be some URI such that when the pattern is resolved relative
+## to that URI, it matches the document's URI. Thus an empty
+## pattern will always match.
+patternAtt = attribute pattern { uriPattern }
+
+## A pattern for a URI. Same syntax as a URI, except that a * in
+## the path component has a special meaning.
+uriPattern = xsd:anyURI
+
+transformURI =
+  ## Generates a URI for the related resource by transforming
+  ## the URI of the document. Matches if the transformation
+  ## yields a valid URI that identifies an existing resource.
+  element transformURI {
+    common,
+    ## Semantics are the same as the pattern attribute of the uri element.
+    attribute fromPattern { uriPattern },
+    ## The result of the transformation is produced from the toPattern
+    ## by replacing each * by the string that matched the corresponding
+    ## * in the toPattern.  The toPattern is appended to the initial
+    ## part of the document's URI that was not explicitly matched
+    ## by fromPattern.
+    attribute toPattern { uriPattern }
+  }
+
+\default =
+  ## Always matches.
+  element default {
+    common,
+    targetAtt
+  }
+
+## A document can be mapped onto a URI either indirectly via a typeId
+## or directly.
+targetAtt = uriAtt | typeIdAtt
+
+## Specifies the URI of the related resource.
+## xml:base is used if it's relative.
+uriAtt = attribute uri { xsd:anyURI }
+
+## Specifies an identifier of the type of document. typeId and
+## typeIdBase rules will be used to map this to a URI.
+typeIdAtt = attribute typeId { typeIdValue }
+
+## A type identifier can be anything convenient (e.g. a public identifier,
+## a URL or just a string with no formal structure).  Whitespace is
+## normalized like a public identifier before comparing type identifiers
+## for equality.
+typeIdValue = xsd:token
+
+typeIdProcessingInstruction =
+  ## Matches if there's a processing instruction in the prolog
+  ## before any DOCTYPE declaration whose target is the value of
+  ## the target attribute.  The value of the processing instruction
+  ## is interpreted as a typeId, which will be mapped to a
+  ## URI as normal.
+  element typeIdProcessingInstruction {
+    common,
+    attribute target { xsd:NCName }
+  }
+
+typeId =
+  ## Maps a typeId onto a URI.
+  element typeId {
+    common,
+    attribute id { typeIdValue },
+    targetAtt
+  }
+
+typeIdBase =
+  ## Used to map a typeId onto a URI. First, any URI reserved characters
+  ## are URI encoded. If the append attribute is specified, it is appended.
+  ## This is then treated as a URI. If relative, it is resolved using
+  ## the applicable base URI as usual.  If the resulting URI identifies
+  ## an existing resource, then the typeId is mapped to this resource.
+  ## This is intended to be useful with file URIs.
+  element typeIdBase {
+    common,
+    attribute append { xsd:string }?
+  }
+
+extensionRule =
+  element * - this:* {
+    attribute * { text }*, (text|anyElement)*
+  }
+
+anyElement = element * { attribute * { text }*, (text|anyElement)* }
+
+common = 
+  # attribute xml:base { xsd:anyURI }?,
+  attribute * - (xml:base|this:*|local:*) { text }*
diff --git a/etc/schema/rdfxml.rnc b/etc/schema/rdfxml.rnc
new file mode 100644
index 00000000000..9730322cfdd
--- /dev/null
+++ b/etc/schema/rdfxml.rnc
@@ -0,0 +1,205 @@
+#
+# RELAX NG Compact Schema for RDF/XML Syntax
+#
+# This schema is for information only and NON-NORMATIVE
+#
+# It is based on one originally written by James Clark in
+# http://lists.w3.org/Archives/Public/www-rdf-comments/2001JulSep/0248.html
+# and updated with later changes.
+#
+
+namespace local = ""
+namespace rdf = "http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+datatypes xsd = "http://www.w3.org/2001/XMLSchema-datatypes"
+
+
+start = doc
+
+
+# I cannot seem to do this in RNGC so they are expanded in-line
+
+# coreSyntaxTerms = rdf:RDF | rdf:ID | rdf:about | rdf:parseType | rdf:resource | rdf:nodeID | rdf:datatype
+# syntaxTerms = coreSyntaxTerms | rdf:Description | rdf:li
+# oldTerms    = rdf:aboutEach | rdf:aboutEachPrefix | rdf:bagID
+# nodeElementURIs       = * - ( coreSyntaxTerms | rdf:li | oldTerms )
+# propertyElementURIs   = * - ( coreSyntaxTerms | rdf:Description | oldTerms )
+# propertyAttributeURIs = * - ( coreSyntaxTerms | rdf:Description | rdf:li | oldTerms )
+
+# Also needed to allow rdf:li on all property element productions
+# since we can't capture the rdf:li rewriting to rdf_<n> in relaxng
+
+# Need to add these explicitly
+xmllang = attribute xml:lang { text }
+xmlbase = attribute xml:base { text }
+# and to forbid every other xml:* attribute, element
+
+doc = 
+  RDF
+
+RDF =
+  element rdf:RDF { 
+     xmllang?, xmlbase?, nodeElementList
+}
+
+nodeElementList = 
+  nodeElement*
+
+  # Should be something like:
+  #  ws* , (  nodeElement , ws* )*
+  # but RELAXNG does this by default, ignoring whitespace separating tags.
+
+nodeElement =
+  element * - ( local:* | rdf:RDF | rdf:ID | rdf:about | rdf:parseType |
+                rdf:resource | rdf:nodeID | rdf:datatype | rdf:li |
+                rdf:aboutEach | rdf:aboutEachPrefix | rdf:bagID ) {
+      (idAttr | nodeIdAttr | aboutAttr )?, xmllang?, xmlbase?, propertyAttr*, propertyEltList
+  }
+
+  # It is not possible to say "and not things
+  # beginning with _ in the rdf: namespace" in RELAX NG.
+
+ws = 
+  " "
+
+  # Not used in this RELAX NG schema; but should be any legal XML
+  # whitespace defined by http://www.w3.org/TR/2000/REC-xml-20001006#NT-S
+
+
+propertyEltList = 
+  propertyElt*
+
+  # Should be something like:
+  #  ws* , ( propertyElt , ws* )*
+  # but RELAXNG does this by default, ignoring whitespace separating tags.
+
+propertyElt = 
+  resourcePropertyElt | 
+  literalPropertyElt | 
+  parseTypeLiteralPropertyElt |
+  parseTypeResourcePropertyElt |
+  parseTypeCollectionPropertyElt |
+  parseTypeOtherPropertyElt |
+  emptyPropertyElt
+
+resourcePropertyElt = 
+  element * - ( local:* | rdf:RDF | rdf:ID | rdf:about | rdf:parseType |
+                rdf:resource | rdf:nodeID | rdf:datatype |
+                rdf:Description | rdf:aboutEach | rdf:aboutEachPrefix | rdf:bagID |
+                xml:* ) {
+      idAttr?, xmllang?, xmlbase?, nodeElement
+  }
+
+literalPropertyElt =
+  element * - ( local:* | rdf:RDF | rdf:ID | rdf:about | rdf:parseType |
+                rdf:resource | rdf:nodeID | rdf:datatype |
+                rdf:Description | rdf:aboutEach | rdf:aboutEachPrefix | rdf:bagID |
+                xml:* ) {
+      (idAttr | datatypeAttr )?, xmllang?, xmlbase?, text 
+  }
+
+parseTypeLiteralPropertyElt = 
+  element * - ( local:* | rdf:RDF | rdf:ID | rdf:about | rdf:parseType |
+                rdf:resource | rdf:nodeID | rdf:datatype |
+                rdf:Description | rdf:aboutEach | rdf:aboutEachPrefix | rdf:bagID |
+                xml:* ) {
+      idAttr?, parseLiteral, xmllang?, xmlbase?, literal 
+  }
+
+parseTypeResourcePropertyElt = 
+  element * - ( local:* | rdf:RDF | rdf:ID | rdf:about | rdf:parseType |
+                rdf:resource | rdf:nodeID | rdf:datatype |
+                rdf:Description | rdf:aboutEach | rdf:aboutEachPrefix | rdf:bagID |
+                xml:* ) {
+      idAttr?, parseResource, xmllang?, xmlbase?, propertyEltList
+  }
+
+parseTypeCollectionPropertyElt = 
+  element * - ( local:* | rdf:RDF | rdf:ID | rdf:about | rdf:parseType |
+                rdf:resource | rdf:nodeID | rdf:datatype |
+                rdf:Description | rdf:aboutEach | rdf:aboutEachPrefix | rdf:bagID |
+                xml:* ) {
+      idAttr?, xmllang?, xmlbase?, parseCollection, nodeElementList
+  }
+
+parseTypeOtherPropertyElt = 
+  element * - ( local:* | rdf:RDF | rdf:ID | rdf:about | rdf:parseType |
+                rdf:resource | rdf:nodeID | rdf:datatype |
+                rdf:Description | rdf:aboutEach | rdf:aboutEachPrefix | rdf:bagID |
+                xml:* ) {
+      idAttr?, xmllang?, xmlbase?, parseOther, any
+  }
+
+emptyPropertyElt =
+   element * - ( local:* | rdf:RDF | rdf:ID | rdf:about | rdf:parseType |
+                 rdf:resource | rdf:nodeID | rdf:datatype |
+                 rdf:Description | rdf:aboutEach | rdf:aboutEachPrefix | rdf:bagID |
+                 xml:* ) {
+       idAttr?, (resourceAttr | nodeIdAttr)?, xmllang?, xmlbase?, propertyAttr*
+   }
+
+idAttr = 
+  attribute rdf:ID { 
+      IDsymbol 
+  }
+
+nodeIdAttr = 
+  attribute rdf:nodeID { 
+      IDsymbol 
+  }
+
+aboutAttr = 
+  attribute rdf:about { 
+      URI-reference 
+  }
+
+propertyAttr = 
+  attribute * - ( local:* | rdf:RDF | rdf:ID | rdf:about | rdf:parseType |
+                  rdf:resource | rdf:nodeID | rdf:datatype | rdf:li |
+                  rdf:Description | rdf:aboutEach |
+                  rdf:aboutEachPrefix | rdf:bagID |
+                  xml:* ) {
+      string
+  }
+
+resourceAttr = 
+  attribute rdf:resource {
+      URI-reference 
+  }
+
+datatypeAttr = 
+  attribute rdf:datatype {
+      URI-reference 
+  }
+
+parseLiteral = 
+  attribute rdf:parseType {
+      "Literal" 
+  }
+
+parseResource = 
+  attribute rdf:parseType {
+      "Resource"
+  }
+
+parseCollection = 
+  attribute rdf:parseType {
+      "Collection"
+  }
+
+parseOther = 
+  attribute rdf:parseType {
+      text
+  }
+
+URI-reference = 
+  string
+
+literal =
+  any
+
+IDsymbol = 
+  xsd:NMTOKEN
+
+any =
+  mixed { element * { attribute * { text }*, any }* }
+
diff --git a/etc/schema/relaxng.rnc b/etc/schema/relaxng.rnc
new file mode 100644
index 00000000000..08686ac5598
--- /dev/null
+++ b/etc/schema/relaxng.rnc
@@ -0,0 +1,63 @@
+# RELAX NG XML syntax expressed in RELAX NG Compact syntax.
+
+default namespace rng = "http://relaxng.org/ns/structure/1.0"
+namespace local = ""
+datatypes xsd = "http://www.w3.org/2001/XMLSchema-datatypes"
+
+start = pattern
+
+pattern =
+  element element { (nameQName | nameClass), (common & pattern+) }
+  | element attribute { (nameQName | nameClass), (common & pattern?) }
+  | element group|interleave|choice|optional
+            |zeroOrMore|oneOrMore|list|mixed { common & pattern+ }
+  | element ref|parentRef { nameNCName, common }
+  | element empty|notAllowed|text { common }
+  | element data { type, param*, (common & exceptPattern?) }
+  | element value { commonAttributes, type?, xsd:string }
+  | element externalRef { href, common }
+  | element grammar { common & grammarContent* }
+
+param = element param { commonAttributes, nameNCName, xsd:string }
+
+exceptPattern = element except { common & pattern+ }
+
+grammarContent = 
+  definition
+  | element div { common & grammarContent* }
+  | element include { href, (common & includeContent*) }
+
+includeContent =
+  definition
+  | element div { common & includeContent* }
+
+definition =
+  element start { combine?, (common & pattern+) }
+  | element define { nameNCName, combine?, (common & pattern+) }
+
+combine = attribute combine { "choice" | "interleave" }
+
+nameClass = 
+  element name { commonAttributes, xsd:QName }
+  | element anyName { common & exceptNameClass? }
+  | element nsName { common & exceptNameClass? }
+  | element choice { common & nameClass+ }
+
+exceptNameClass = element except { common & nameClass+ }
+
+nameQName = attribute name { xsd:QName }
+nameNCName = attribute name { xsd:NCName }
+href = attribute href { xsd:anyURI }
+type = attribute type { xsd:NCName }
+
+common = commonAttributes, foreignElement*
+
+commonAttributes = 
+  attribute ns { xsd:string }?,
+  attribute datatypeLibrary { xsd:anyURI }?,
+  foreignAttribute*
+
+foreignElement = element * - rng:* { (anyAttribute | text | anyElement)* }
+foreignAttribute = attribute * - (rng:*|local:*) { text }
+anyElement = element * { (anyAttribute | text | anyElement)* }
+anyAttribute = attribute * { text }
diff --git a/etc/schema/schemas.xml b/etc/schema/schemas.xml
new file mode 100644
index 00000000000..e17b063f6fe
--- /dev/null
+++ b/etc/schema/schemas.xml
@@ -0,0 +1,36 @@
+<locatingRules xmlns="http://thaiopensource.com/ns/locating-rules/1.0">
+  <transformURI fromPattern="*.xml" toPattern="*.rnc"/>
+
+  <uri pattern="*.xsl" typeId="XSLT"/>
+  <uri pattern="*.html" typeId="XHTML"/>
+  <uri pattern="*.rng" typeId="RELAX NG"/>
+  <uri pattern="*.rdf" typeId="RDF"/>
+  
+  <namespace ns="http://www.w3.org/1999/XSL/Transform" typeId="XSLT"/>
+  <namespace ns="http://www.w3.org/1999/02/22-rdf-syntax-ns#" typeId="RDF"/>
+  <namespace ns="http://www.w3.org/1999/xhtml" typeId="XHTML"/>
+  <namespace ns="http://relaxng.org/ns/structure/1.0" typeId="RELAX NG"/>
+  <namespace ns="http://thaiopensource.com/ns/locating-rules/1.0"
+             uri="locate.rnc"/>
+
+  <documentElement localName="stylesheet" typeId="XSLT"/>
+  <documentElement prefix="xsl" localName="transform" typeId="XSLT"/>
+
+  <documentElement localName="html" typeId="XHTML"/>
+
+  <documentElement localName="grammar" typeId="RELAX NG"/>
+
+  <documentElement prefix="" localName="article" typeId="DocBook"/>
+  <documentElement prefix="" localName="book" typeId="DocBook"/>
+
+  <documentElement localName="RDF" typeId="RDF"/>
+  <documentElement prefix="rdf" typeId="RDF"/>
+  
+  <documentElement localName="locatingRules" uri="locate.rnc"/>
+
+  <typeId id="XSLT" uri="xslt.rnc"/>
+  <typeId id="RELAX NG" uri="relaxng.rnc"/>
+  <typeId id="XHTML" uri="xhtml.rnc"/>
+  <typeId id="DocBook" uri="docbook.rnc"/>
+  <typeId id="RDF" uri="rdfxml.rnc"/>
+</locatingRules>
diff --git a/etc/schema/soextbl.rnc b/etc/schema/soextbl.rnc
new file mode 100644
index 00000000000..2e69127b4a2
--- /dev/null
+++ b/etc/schema/soextbl.rnc
@@ -0,0 +1,260 @@
+# XML EXCHANGE TABLE MODEL DECLARATION MODULE
+
+# This set of declarations defines the XML version of the Exchange
+# Table Model as of the date shown in the Formal Public Identifier
+# (FPI) for this entity.
+# 
+# This set of declarations may be referred to using a public external
+# entity declaration and reference as shown in the following three
+# lines:
+# 
+# <!ENTITY % calstblx
+#   PUBLIC "-//OASIS//DTD XML Exchange Table Model 19990315//EN">
+#   %calstblx;
+# 
+# If various parameter entities used within this set of declarations
+# are to be given non-default values, the appropriate declarations
+# should be given before calling in this package (i.e., before the
+# "%calstblx;" reference).
+
+# The motivation for this XML version of the Exchange Table Model
+# is simply to create an XML version of the SGML Exchange Table
+# Model. By design, no effort has been made to "improve" the model.
+# 
+# This XML version incorporates the logical bare minimum changes
+# necessary to make the Exchange Table Model a valid XML DTD.
+
+# The XML version of the Exchange Table Model differs from
+# the SGML version in the following ways:
+# 
+# The following parameter entities have been removed:
+# 
+#   - tbl.table.excep, tbl.hdft.excep, tbl.row.excep, tbl.entry.excep
+#     There are no exceptions in XML. The following normative statement
+#     is made in lieu of exceptions: the exchange table model explicitly
+#     forbids a table from occurring within another table. If the
+#     content model of an entry includes a table element, then this
+#     cannot be enforced by the DTD, but it is a deviation from the
+#     exchange table model to include a table within a table.
+# 
+#   - tbl.hdft.name, tbl.hdft.mdl, tbl.hdft.excep, tbl.hdft.att
+#     The motivation for these elements was to change the table
+#     header/footer elements. Since XML does not allow element declarations
+#     to contain name groups, and the exchange table model does not
+#     allow a table to contain footers, the continued presence of these
+#     attributes seems unnecessary.
+# 
+# The following parameter entity has been added:
+# 
+#   - tbl.thead.att
+#     This entity parameterizes the attributes on thead. It replaces
+#     the tbl.hdft.att parameter entity.
+# 
+# Other miscellaneous changes:
+# 
+#   - Tag ommission indicators have been removed
+#   - Comments have been removed from declarations
+#   - NUMBER attributes have been changed to NMTOKEN
+#   - NUTOKEN attributes have been to changed to NMTOKEN
+#   - Removed the grouping characters around the content model
+#     parameter entry for the 'entry' element. This is necessary
+#     so that an entry can contain #PCDATA and be defined as an
+#     optional, repeatable OR group beginning with #PCDATA.
+
+# This entity includes a set of element and attribute declarations
+# that partially defines the Exchange table model.  However, the model
+# is not well-defined without the accompanying natural language
+# description of the semantics (meanings) of these various elements,
+# attributes, and attribute values.  The semantic writeup, also available
+# from SGML Open, should be used in conjunction with this entity.
+
+# In order to use the Exchange table model, various parameter entity
+# declarations are required.  A brief description is as follows:
+# 
+# ENTITY NAME      WHERE USED              WHAT IT IS
+# 
+# %yesorno         In ATTLIST of:          An attribute declared value
+#                  almost all elements     for a "boolean" attribute
+# 
+# %paracon         In content model of:    The "text" (logical content)
+#                  <entry>                 of the model group for <entry>
+# 
+# %titles          In content model of:    The "title" part of the model
+#                  table element           group for the table element
+# 
+# %tbl.table.name  In declaration of:      The name of the "table"
+#                  table element           element
+# 
+# %tbl.table-titles.mdl In content model of: The model group for the title
+#                  table elements          part of the content model for
+#                                          table element
+# 
+# %tbl.table.mdl   In content model of:    The model group for the content
+#                  table elements          model for table element,
+#                                          often (and by default) defined
+#                                          in terms of %tbl.table-titles.mdl
+#                                          and tgroup
+# 
+# %tbl.table.att   In ATTLIST of:          Additional attributes on the
+#                  table element           table element
+# 
+# %bodyatt         In ATTLIST of:          Additional attributes on the
+#                  table element           table element (for backward
+#                                          compatibility with the SGML
+#                                          model)
+# 
+# %tbl.tgroup.mdl  In content model of:    The model group for the content
+#                  <tgroup>                model for <tgroup>
+# 
+# %tbl.tgroup.att  In ATTLIST of:          Additional attributes on the
+#                  <tgroup>                <tgroup> element
+# 
+# %tbl.thead.att   In ATTLIST of:          Additional attributes on the
+#                  <thead>                 <thead> element
+# 
+# %tbl.tbody.att   In ATTLIST of:          Additional attributes on the
+#                  <tbody>                 <tbody> element
+# 
+# %tbl.colspec.att In ATTLIST of:          Additional attributes on the
+#                  <colspec>               <colspec> element
+# 
+# %tbl.row.mdl     In content model of:    The model group for the content
+#                  <row>                   model for <row>
+# 
+# %tbl.row.att     In ATTLIST of:          Additional attributes on the
+#                  <row>                   <row> element
+# 
+# %tbl.entry.mdl   In content model of:    The model group for the content
+#                  <entry>                 model for <entry>
+# 
+# %tbl.entry.att   In ATTLIST of:          Additional attributes on the
+#                  <entry>                 <entry> element
+# 
+# This set of declarations will use the default definitions shown below
+# for any of these parameter entities that are not declared before this
+# set of declarations is referenced.
+
+# These definitions are not directly related to the table model, but are
+# used in the default CALS table model and may be defined elsewhere (and
+# prior to the inclusion of this table module) in the referencing DTD.
+
+yesorno = xsd:NMTOKEN
+# no if zero(s), yes if any other value
+pcd = text
+paracon = pcd
+# default for use in entry content
+
+# The parameter entities as defined below change and simplify the CALS table
+# model as published (as part of the Example DTD) in MIL-HDBK-28001.  The
+# resulting simplified DTD has support from the SGML Open vendors and is
+# therefore more interoperable among different systems.
+# 
+# These following declarations provide the Exchange default definitions
+# for these entities.  However, these entities can be redefined (by giving
+# the appropriate parameter entity declaration(s) prior to the reference
+# to this Table Model declaration set entity) to fit the needs of the
+# current application.
+# 
+# Note, however, that changes may have significant effect on the ability to
+# interchange table information.  These changes may manifest themselves
+# in useability, presentation, and possible structure information degradation.
+tbl.table-titles.mdl = title
+tbl.table-main.mdl = tgroup+
+tbl.table.mdl = tbl.table-titles.mdl | tbl.table-main.mdl
+tbl.table.att = attribute pgwide { yesorno }?
+bodyatt = empty
+tbl.tgroup.mdl = colspec*, thead?, tbody
+tbl.tgroup.att = empty
+tbl.thead.att = empty
+tbl.tbody.att = empty
+tbl.colspec.att = empty
+tbl.row.mdl = entry+
+tbl.row.att = empty
+tbl.entry.mdl = paracon*
+tbl.entry.att = empty
+# =====  Element and attribute declarations follow. =====
+
+# Default declarations previously defined in this entity and
+# referenced below include:
+# ENTITY % tbl.table.name       "table"
+# ENTITY % tbl.table-titles.mdl "%titles;,"
+# ENTITY % tbl.table.mdl        "%tbl.table-titles; tgroup+"
+# ENTITY % tbl.table.att        "
+#                    pgwide          %yesorno;       #IMPLIED "
+table = element table { table.attlist, tbl.table.mdl }
+table.attlist &=
+  attribute frame {
+    "top" | "bottom" | "topbot" | "all" | "sides" | "none"
+  }?,
+  attribute colsep { yesorno }?,
+  attribute rowsep { yesorno }?,
+  tbl.table.att,
+  bodyatt
+# Default declarations previously defined in this entity and
+# referenced below include:
+# ENTITY % tbl.tgroup.mdl    "colspec*,thead?,tbody"
+# ENTITY % tbl.tgroup.att    ""
+tgroup = element tgroup { tgroup.attlist, tbl.tgroup.mdl }
+tgroup.attlist &=
+  attribute cols { xsd:NMTOKEN },
+  attribute colsep { yesorno }?,
+  attribute rowsep { yesorno }?,
+  attribute align { "left" | "right" | "center" | "justify" | "char" }?,
+  tbl.tgroup.att
+# Default declarations previously defined in this entity and
+# referenced below include:
+# ENTITY % tbl.colspec.att   ""
+colspec = element colspec { colspec.attlist, empty }
+colspec.attlist &=
+  attribute colnum { xsd:NMTOKEN }?,
+  attribute colname { xsd:NMTOKEN }?,
+  attribute colwidth { text }?,
+  attribute colsep { yesorno }?,
+  attribute rowsep { yesorno }?,
+  attribute align { "left" | "right" | "center" | "justify" | "char" }?,
+  attribute char { text }?,
+  attribute charoff { xsd:NMTOKEN }?,
+  tbl.colspec.att
+# Default declarations previously defined in this entity and
+# referenced below include:
+# ENTITY % tbl.thead.att      ""
+thead = element thead { thead.attlist, row+ }
+thead.attlist &=
+  attribute valign { "top" | "middle" | "bottom" }?,
+  tbl.thead.att
+# Default declarations previously defined in this entity and
+# referenced below include:
+# ENTITY % tbl.tbody.att     ""
+tbody = element tbody { tbody.attlist, row+ }
+tbody.attlist &=
+  attribute valign { "top" | "middle" | "bottom" }?,
+  tbl.tbody.att
+# Default declarations previously defined in this entity and
+# referenced below include:
+# ENTITY % tbl.row.mdl       "entry+"
+# ENTITY % tbl.row.att       ""
+row = element row { row.attlist, tbl.row.mdl }
+row.attlist &=
+  attribute rowsep { yesorno }?,
+  attribute valign { "top" | "middle" | "bottom" }?,
+  tbl.row.att
+# Default declarations previously defined in this entity and
+# referenced below include:
+# ENTITY % paracon           "#PCDATA"
+# ENTITY % tbl.entry.mdl     "(%paracon;)*"
+# ENTITY % tbl.entry.att     ""
+entry = element entry { entry.attlist, tbl.entry.mdl }
+entry.attlist &=
+  attribute colname { xsd:NMTOKEN }?,
+  attribute namest { xsd:NMTOKEN }?,
+  attribute nameend { xsd:NMTOKEN }?,
+  attribute morerows { xsd:NMTOKEN }?,
+  attribute colsep { yesorno }?,
+  attribute rowsep { yesorno }?,
+  attribute align { "left" | "right" | "center" | "justify" | "char" }?,
+  attribute char { text }?,
+  attribute charoff { xsd:NMTOKEN }?,
+  attribute valign { "top" | "middle" | "bottom" }?,
+  tbl.entry.att
+title |= notAllowed
+start = table
diff --git a/etc/schema/xhtml-applet.rnc b/etc/schema/xhtml-applet.rnc
new file mode 100644
index 00000000000..115f1cbda7d
--- /dev/null
+++ b/etc/schema/xhtml-applet.rnc
@@ -0,0 +1,19 @@
+# Applet Module
+
+applet =
+  element applet {
+    applet.attlist,
+    # No restrictions on mixed content in TREX.
+    param*,
+    Flow.model
+  }
+applet.attlist =
+  Core.attrib,
+  attribute alt { Text.datatype },
+  attribute archive { text }?,
+  attribute code { text }?,
+  attribute codebase { URI.datatype }?,
+  attribute object { text }?,
+  attribute height { Length.datatype },
+  attribute width { Length.datatype }
+Inline.class |= applet
diff --git a/etc/schema/xhtml-attribs.rnc b/etc/schema/xhtml-attribs.rnc
new file mode 100644
index 00000000000..ef653c70dbb
--- /dev/null
+++ b/etc/schema/xhtml-attribs.rnc
@@ -0,0 +1,14 @@
+# Common Attributes Module
+
+id.attrib = attribute id { ID.datatype }?
+class.attrib = attribute class { NMTOKENS.datatype }?
+title.attrib = attribute title { Text.datatype }?
+Core.attrib = id.attrib, class.attrib, title.attrib
+lang.attrib = attribute xml:lang { LanguageCode.datatype }?
+I18n.attrib = lang.attrib
+Common.attrib = Core.attrib, I18n.attrib
+CommonIdRequired.attrib =
+  attribute id { ID.datatype },
+  class.attrib,
+  title.attrib,
+  I18n.attrib
diff --git a/etc/schema/xhtml-base.rnc b/etc/schema/xhtml-base.rnc
new file mode 100644
index 00000000000..154dfce1c5a
--- /dev/null
+++ b/etc/schema/xhtml-base.rnc
@@ -0,0 +1,5 @@
+# Base Module
+
+base = element base { base.attlist }
+base.attlist = attribute href { URI.datatype }
+head.content &= base?
diff --git a/etc/schema/xhtml-basic-form.rnc b/etc/schema/xhtml-basic-form.rnc
new file mode 100644
index 00000000000..c0a78a1d72e
--- /dev/null
+++ b/etc/schema/xhtml-basic-form.rnc
@@ -0,0 +1,63 @@
+# Simplified Forms Module
+
+form =
+  element form {
+    form.attlist,
+    # Don't use Block.model, because this gets redefined by the
+    # legacy module.
+    Block.class+
+  }
+form.attlist =
+  Common.attrib,
+  attribute action { URI.datatype },
+  attribute method { "get" | "post" }?,
+  attribute enctype { ContentType.datatype }?
+label = element label { label.attlist, Inline.model }
+label.attlist =
+  Common.attrib,
+  attribute for { IDREF.datatype }?,
+  attribute accesskey { Character.datatype }?
+input = element input { input.attlist }
+input.attlist =
+  Common.attrib,
+  attribute type { InputType.class }?,
+  attribute name { text }?,
+  attribute value { text }?,
+  attribute checked { "checked" }?,
+  attribute size { text }?,
+  attribute maxlength { Number.datatype }?,
+  attribute src { URI.datatype }?,
+  attribute accesskey { Character.datatype }?
+InputType.class =
+  "text"
+  | "password"
+  | "checkbox"
+  | "radio"
+  | "submit"
+  | "reset"
+  | "hidden"
+select = element select { select.attlist, option+ }
+select.attlist =
+  Common.attrib,
+  attribute name { text }?,
+  attribute size { Number.datatype }?,
+  attribute multiple { "multiple" }?
+option =
+  element option {
+    Common.attrib,
+    attribute selected { "selected" }?,
+    attribute value { text }?,
+    text
+  }
+textarea = element textarea { textarea.attlist }
+textarea.attlist =
+  Common.attrib,
+  attribute name { text }?,
+  attribute rows { Number.datatype },
+  attribute cols { Number.datatype },
+  attribute accesskey { Character.datatype }?,
+  text
+Form.class = form
+Formctrl.class = input | label | select | textarea
+Block.class |= Form.class
+Inline.class |= Formctrl.class
diff --git a/etc/schema/xhtml-basic-table.rnc b/etc/schema/xhtml-basic-table.rnc
new file mode 100644
index 00000000000..97e10a56743
--- /dev/null
+++ b/etc/schema/xhtml-basic-table.rnc
@@ -0,0 +1,28 @@
+# Basic Tables Module
+
+table = element table { table.attlist, caption?, tr+ }
+table.attlist =
+  Common.attrib,
+  attribute summary { Text.datatype }?
+caption = element caption { caption.attlist, Inline.model }
+caption.attlist = Common.attrib
+tr = element tr { tr.attlist, (th | td)+ }
+tr.attlist = Common.attrib, CellHAlign.attrib, CellVAlign.attrib
+th = element th { th.attlist, Flow.model }
+th.attlist = Cell.attrib
+td = element td { td.attlist, Flow.model }
+td.attlist = Cell.attrib
+Cell.attrib =
+  Common.attrib,
+  attribute abbr { Text.datatype }?,
+  attribute axis { text }?,
+  attribute headers { IDREFS.datatype }?,
+  scope.attrib,
+  attribute rowspan { Number.datatype }?,
+  attribute colspan { Number.datatype }?,
+  CellHAlign.attrib,
+  CellVAlign.attrib
+CellHAlign.attrib = attribute align { "left" | "center" | "right" }?
+CellVAlign.attrib = attribute valign { "top" | "middle" | "bottom" }?
+scope.attrib = attribute scope { "row" | "col" }?
+Block.class |= table
diff --git a/etc/schema/xhtml-bdo.rnc b/etc/schema/xhtml-bdo.rnc
new file mode 100644
index 00000000000..5658be36ecb
--- /dev/null
+++ b/etc/schema/xhtml-bdo.rnc
@@ -0,0 +1,7 @@
+# Bi-directional Module
+
+bdo = element bdo { bdo.attlist, Inline.model }
+bdo.attlist = Core.attrib, lang.attrib, dir.attrib
+dir.attrib = attribute dir { "ltr" | "rtl" }
+I18n.attrib &= dir.attrib?
+Inline.class |= bdo
diff --git a/etc/schema/xhtml-csismap.rnc b/etc/schema/xhtml-csismap.rnc
new file mode 100644
index 00000000000..abd51f1a441
--- /dev/null
+++ b/etc/schema/xhtml-csismap.rnc
@@ -0,0 +1,29 @@
+# Client-side Image Map Module
+
+area = element area { area.attlist }
+area.attlist =
+  Common.attrib,
+  attribute href { URI.datatype }?,
+  shape.attrib,
+  coords.attrib,
+  attribute nohref { "nohref" }?,
+  attribute alt { Text.datatype },
+  attribute tabindex { Number.datatype }?,
+  attribute accesskey { Character.datatype }?
+map =
+  element map {
+    map.attlist,
+    (# This does not use Block.mix
+     # because loose.dtd doesn't use %Flow;
+     Block.class
+     | area)+
+  }
+map.attlist = CommonIdRequired.attrib
+a.attlist &= shape.attrib, coords.attrib
+img.attlist &= usemap.attlist
+object.attlist &= usemap.attlist
+usemap.attlist = attribute usemap { IDREF.datatype }?
+shape.attrib =
+  attribute shape { "rect" | "circle" | "poly" | "default" }?
+coords.attrib = attribute coords { text }?
+Inline.class |= map
diff --git a/etc/schema/xhtml-datatypes.rnc b/etc/schema/xhtml-datatypes.rnc
new file mode 100644
index 00000000000..596598039dd
--- /dev/null
+++ b/etc/schema/xhtml-datatypes.rnc
@@ -0,0 +1,47 @@
+# Datatypes Module
+
+# Length defined for cellpadding/cellspacing
+
+# nn for pixels or nn% for percentage length
+Length.datatype = text
+# space-separated list of link types
+LinkTypes.datatype = NMTOKENS.datatype
+# single or comma-separated list of media descriptors
+MediaDesc.datatype = text
+# pixel, percentage, or relative
+MultiLength.datatype = text
+# one or more digits (NUMBER)
+Number.datatype = text
+# integer representing length in pixels
+Pixels.datatype = text
+# script expression
+Script.datatype = text
+# textual content
+Text.datatype = text
+# Imported Datatypes ................................
+
+# a single character from [ISO10646]
+Character.datatype = text
+# a character encoding, as per [RFC2045]
+Charset.datatype = text
+# a space separated list of character encodings, as per [RFC2045]
+Charsets.datatype = text
+# media type, as per [RFC2045]
+ContentType.datatype = text
+# comma-separated list of media types, as per [RFC2045]
+ContentTypes.datatype = text
+# date and time information. ISO date format
+Datetime.datatype = text
+# formal public identifier, as per [ISO8879]
+FPI.datatype = text
+# a language code, as per [RFC1766]
+LanguageCode.datatype = xsd:language
+# a Uniform Resource Identifier, see [URI]
+URI.datatype = xsd:anyURI
+# a space-separated list of Uniform Resource Identifiers, see [URI]
+URIs.datatype = text
+NMTOKEN.datatype = xsd:NMTOKEN
+NMTOKENS.datatype = xsd:NMTOKENS
+ID.datatype = xsd:ID
+IDREF.datatype = xsd:IDREF
+IDREFS.datatype = xsd:IDREFS
diff --git a/etc/schema/xhtml-edit.rnc b/etc/schema/xhtml-edit.rnc
new file mode 100644
index 00000000000..4301fc27f74
--- /dev/null
+++ b/etc/schema/xhtml-edit.rnc
@@ -0,0 +1,12 @@
+# Edit Module
+
+del = element del { del.attlist, Inline.model }
+del.attlist = Edit.attrib
+ins = element ins { ins.attlist, Inline.model }
+ins.attlist = Edit.attrib
+Edit.attrib =
+  attribute cite { URI.datatype }?,
+  attribute datetime { Datetime.datatype }?
+Edit.class = del | ins
+Inline.class |= Edit.class
+Block.class |= Edit.class
diff --git a/etc/schema/xhtml-events.rnc b/etc/schema/xhtml-events.rnc
new file mode 100644
index 00000000000..536874201e1
--- /dev/null
+++ b/etc/schema/xhtml-events.rnc
@@ -0,0 +1,47 @@
+# Events Module
+
+a.attlist &=
+  attribute onblur { Script.datatype }?,
+  attribute onfocus { Script.datatype }?
+area.attlist &=
+  attribute onblur { Script.datatype }?,
+  attribute onfocus { Script.datatype }?
+form.attlist &=
+  attribute onreset { Script.datatype }?,
+  attribute onsubmit { Script.datatype }?
+body.attlist &=
+  attribute onload { Script.datatype }?,
+  attribute onunload { Script.datatype }?
+label.attlist &=
+  attribute onblur { Script.datatype }?,
+  attribute onfocus { Script.datatype }?
+input.attlist &=
+  attribute onblur { Script.datatype }?,
+  attribute onchange { Script.datatype }?,
+  attribute onfocus { Script.datatype }?,
+  attribute onselect { Script.datatype }?
+select.attlist &=
+  attribute onblur { Script.datatype }?,
+  attribute onchange { Script.datatype }?,
+  attribute onfocus { Script.datatype }?
+textarea.attlist &=
+  attribute onblur { Script.datatype }?,
+  attribute onchange { Script.datatype }?,
+  attribute onfocus { Script.datatype }?,
+  attribute onselect { Script.datatype }?
+button.attlist &=
+  attribute onblur { Script.datatype }?,
+  attribute onfocus { Script.datatype }?
+Events.attrib =
+  attribute onclick { Script.datatype }?,
+  attribute ondblclick { Script.datatype }?,
+  attribute onmousedown { Script.datatype }?,
+  attribute onmouseup { Script.datatype }?,
+  attribute onmouseover { Script.datatype }?,
+  attribute onmousemove { Script.datatype }?,
+  attribute onmouseout { Script.datatype }?,
+  attribute onkeypress { Script.datatype }?,
+  attribute onkeydown { Script.datatype }?,
+  attribute onkeyup { Script.datatype }?
+Common.attrib &= Events.attrib
+CommonIdRequired.attrib &= Events.attrib
diff --git a/etc/schema/xhtml-form.rnc b/etc/schema/xhtml-form.rnc
new file mode 100644
index 00000000000..f5544190b01
--- /dev/null
+++ b/etc/schema/xhtml-form.rnc
@@ -0,0 +1,49 @@
+# Forms Module
+
+# Unlike the DTD implementation, this builds on the basic-form module
+
+include "xhtml-basic-form.rnc" {
+  select = element select { select.attlist, (option | optgroup)+ }
+}
+form.attlist &=
+  attribute accept-charset { Charsets.datatype }?,
+  attribute accept { ContentTypes.datatype }?
+input.attlist &=
+  attribute disabled { "disabled" }?,
+  attribute readonly { "readonly" }?,
+  attribute alt { text }?,
+  attribute tabindex { Number.datatype }?,
+  attribute accept { ContentTypes.datatype }?
+InputType.class |= "image" | "button"
+select.attlist &=
+  attribute disabled { "disabled" }?,
+  attribute tabindex { Number.datatype }?
+option.attlist &=
+  attribute disabled { "disabled" }?,
+  attribute label { Text.datatype }?
+optgroup = element optgroup { optgroup.attlist, option+ }
+optgroup.attlist =
+  Common.attrib,
+  attribute disabled { "disabled" }?,
+  attribute label { Text.datatype }
+textarea.attlist &=
+  attribute disabled { "disabled" }?,
+  attribute readonly { "readonly" }?,
+  attribute tabindex { Number.datatype }?
+fieldset = element fieldset { fieldset.attlist, legend, Flow.model }
+fieldset.attlist = Common.attrib
+button = element button { button.attlist, Flow.model }
+button.attlist =
+  Common.attrib,
+  attribute name { text }?,
+  attribute value { text }?,
+  attribute type { "button" | "submit" | "reset" }?,
+  attribute disabled { "disabled" }?,
+  attribute tabindex { Number.datatype }?,
+  attribute accesskey { Character.datatype }?
+legend = element legend { legend.attlist, Inline.model }
+legend.attlist =
+  Common.attrib,
+  attribute accesskey { Character.datatype }?
+Form.class |= fieldset
+Formctrl.class |= button
diff --git a/etc/schema/xhtml-frames.rnc b/etc/schema/xhtml-frames.rnc
new file mode 100644
index 00000000000..9b9f9ba1465
--- /dev/null
+++ b/etc/schema/xhtml-frames.rnc
@@ -0,0 +1,26 @@
+# Frames Module
+
+include "xhtml-struct.rnc" {
+  html = element html { html.attlist, head, frameset }
+}
+frameset =
+  element frameset {
+    frameset.attlist,
+    ((frameset | frame)+ & noframes?)
+  }
+frameset.attlist =
+  Core.attrib,
+  attribute cols { MultiLength.datatype }?,
+  attribute rows { MultiLength.datatype }?
+frame = element frame { frame.attlist }
+frame.attlist =
+  Core.attrib,
+  attribute longdesc { URI.datatype }?,
+  attribute src { URI.datatype }?,
+  attribute frameborder { "1" | "0" }?,
+  attribute marginwidth { Pixels.datatype }?,
+  attribute marginheight { Pixels.datatype }?,
+  attribute noresize { "noresize" }?,
+  attribute scrolling { "yes" | "no" | "auto" }?
+noframes = element noframes { noframes.attlist, body }
+noframes.attlist = Common.attrib
diff --git a/etc/schema/xhtml-hypertext.rnc b/etc/schema/xhtml-hypertext.rnc
new file mode 100644
index 00000000000..82e7686d648
--- /dev/null
+++ b/etc/schema/xhtml-hypertext.rnc
@@ -0,0 +1,16 @@
+# Hypertext Module
+
+# Depends on text module.
+
+a = element a { a.attlist, Inline.model }
+a.attlist =
+  Common.attrib,
+  attribute href { URI.datatype }?,
+  attribute charset { Charset.datatype }?,
+  attribute type { ContentType.datatype }?,
+  attribute hreflang { LanguageCode.datatype }?,
+  attribute rel { LinkTypes.datatype }?,
+  attribute rev { LinkTypes.datatype }?,
+  attribute accesskey { Character.datatype }?,
+  attribute tabindex { Number.datatype }?
+Inline.class |= a
diff --git a/etc/schema/xhtml-iframe.rnc b/etc/schema/xhtml-iframe.rnc
new file mode 100644
index 00000000000..bbcdd441bb3
--- /dev/null
+++ b/etc/schema/xhtml-iframe.rnc
@@ -0,0 +1,14 @@
+# Iframe Module
+
+iframe = element iframe { iframe.attlist, Flow.model }
+iframe.attlist =
+  Core.attrib,
+  attribute longdesc { URI.datatype }?,
+  attribute src { URI.datatype }?,
+  attribute frameborder { "1" | "0" }?,
+  attribute width { Length.datatype }?,
+  attribute height { Length.datatype }?,
+  attribute marginwidth { Pixels.datatype }?,
+  attribute marginheight { Pixels.datatype }?,
+  attribute scrolling { "yes" | "no" | "auto" }?
+Inline.class |= iframe
diff --git a/etc/schema/xhtml-image.rnc b/etc/schema/xhtml-image.rnc
new file mode 100644
index 00000000000..e1d6e5662f7
--- /dev/null
+++ b/etc/schema/xhtml-image.rnc
@@ -0,0 +1,11 @@
+# Image Module
+
+img = element img { img.attlist }
+img.attlist =
+  Common.attrib,
+  attribute src { URI.datatype },
+  attribute alt { Text.datatype },
+  attribute longdesc { URI.datatype }?,
+  attribute height { Length.datatype }?,
+  attribute width { Length.datatype }?
+Inline.class |= img
diff --git a/etc/schema/xhtml-inlstyle.rnc b/etc/schema/xhtml-inlstyle.rnc
new file mode 100644
index 00000000000..aa69b75ab61
--- /dev/null
+++ b/etc/schema/xhtml-inlstyle.rnc
@@ -0,0 +1,3 @@
+# Inline Style Module
+
+Core.attrib &= attribute style { text }?
diff --git a/etc/schema/xhtml-legacy.rnc b/etc/schema/xhtml-legacy.rnc
new file mode 100644
index 00000000000..b15061f6d9b
--- /dev/null
+++ b/etc/schema/xhtml-legacy.rnc
@@ -0,0 +1,100 @@
+# Legacy Module
+
+lang.attrib &= attribute lang { LanguageCode.datatype }?
+basefont = element basefont { basefont.attlist }
+basefont.attlist = id.attrib, Font.attrib
+center = element center { center.attlist, Flow.model }
+center.attlist = Common.attrib
+font = element font { font.attlist, Inline.model }
+font.attlist = Core.attrib, I18n.attrib, Font.attrib
+Font.attrib =
+  attribute size { text }?,
+  attribute color { Color.datatype }?,
+  attribute face { text }?
+s = element s { s.attlist, Inline.model }
+s.attlist = Common.attrib
+strike = element strike { strike.attlist, Inline.model }
+strike.attlist = Common.attrib
+u = element u { u.attlist, Inline.model }
+u.attlist = Common.attrib
+dir = element dir { dir.attlist, li.noblock+ }
+dir.attlist =
+  Common.attrib,
+  attribute compact { "compact" }?
+menu = element menu { menu.attlist, li.noblock+ }
+menu.attlist =
+  Common.attrib,
+  attribute compact { "compact" }?
+li.noblock = element li { li.attlist, Inline.model }
+isindex = element isindex { isindex.attlist }
+isindex.attlist =
+  Core.attrib,
+  I18n.attrib,
+  attribute prompt { Text.datatype }?
+applet.attlist &=
+  attribute align { "top" | "middle" | "bottom" | "left" | "right" }?,
+  attribute hspace { Pixels.datatype }?,
+  attribute vspace { Pixels.datatype }?
+body.attlist &=
+  attribute background { URI.datatype }?,
+  attribute bgcolor { Color.datatype }?,
+  attribute text { Color.datatype }?,
+  attribute link { Color.datatype }?,
+  attribute vlink { Color.datatype }?,
+  attribute alink { Color.datatype }?
+br.attlist &= attribute clear { "left" | "all" | "right" | "none" }?
+caption.attlist &= align.attrib
+div.attlist &= align.attrib
+# Not in the CR, but surely an error.
+dl.attlist &= attribute compact { "compact" }?
+Heading.attrib &= align.attrib
+hr.attlist &=
+  attribute align { "left" | "center" | "right" }?,
+  attribute noshade { "noshade" }?,
+  attribute size { Pixels.datatype }?,
+  attribute width { Pixels.datatype }?
+img.attlist &=
+  attribute align { "top" | "middle" | "bottom" | "left" | "right" }?,
+  attribute border { Pixels.datatype }?,
+  attribute hspace { Pixels.datatype }?,
+  attribute vspace { Pixels.datatype }?
+input.attlist &= align.attrib
+legend.attlist &=
+  attribute align { "top" | "bottom" | "left" | "right" }?
+li.attlist &=
+  attribute type { text }?,
+  attribute value { text }?
+object.attlist &=
+  attribute align { "top" | "middle" | "bottom" | "left" | "right" }?,
+  attribute border { Pixels.datatype }?,
+  attribute hspace { Pixels.datatype }?,
+  attribute vspace { Pixels.datatype }?
+ol.attlist &=
+  attribute type { text }?,
+  attribute compact { "compact" }?,
+  attribute start { text }?
+p.attlist &= align.attrib
+pre.attlist &= attribute width { Length.datatype }?
+script.attlist &= attribute language { ContentType.datatype }?
+table.attlist &=
+  align.attrib,
+  attribute bgcolor { Color.datatype }?
+tr.attlist &= attribute bgcolor { Color.datatype }?
+Cell.attrib &=
+  attribute nowrap { "nowrap" }?,
+  attribute bgcolor { Color.datatype }?,
+  attribute width { Pixels.datatype }?,
+  attribute height { Pixels.datatype }?
+ul.attlist &=
+  attribute type { text }?,
+  attribute compact { "compact" }?
+align.attrib = attribute align { "left" | "all" | "right" | "none" }?
+Color.datatype = text
+Inline.class |= font | basefont | s | strike | u
+Block.class |= center | isindex
+List.class |= dir | menu
+head.content &= isindex?
+Block.mix |= text | Inline.class
+# With the legacy module and the frames modules, the html
+# element can contain either body or frameset.
+frameset |= body
diff --git a/etc/schema/xhtml-link.rnc b/etc/schema/xhtml-link.rnc
new file mode 100644
index 00000000000..9d0d6f1cc75
--- /dev/null
+++ b/etc/schema/xhtml-link.rnc
@@ -0,0 +1,13 @@
+# Link Module
+
+link = element link { link.attlist }
+link.attlist =
+  Common.attrib,
+  attribute charset { Charset.datatype }?,
+  attribute href { URI.datatype }?,
+  attribute hreflang { LanguageCode.datatype }?,
+  attribute type { ContentType.datatype }?,
+  attribute rel { LinkTypes.datatype }?,
+  attribute rev { LinkTypes.datatype }?,
+  attribute media { MediaDesc.datatype }?
+head.content &= link*
diff --git a/etc/schema/xhtml-list.rnc b/etc/schema/xhtml-list.rnc
new file mode 100644
index 00000000000..8b994041eaa
--- /dev/null
+++ b/etc/schema/xhtml-list.rnc
@@ -0,0 +1,16 @@
+# List Module
+
+dl = element dl { dl.attlist, (dt | dd)+ }
+dl.attlist = Common.attrib
+dt = element dt { dt.attlist, Inline.model }
+dt.attlist = Common.attrib
+dd = element dd { dd.attlist, Flow.model }
+dd.attlist = Common.attrib
+ol = element ol { ol.attlist, li+ }
+ol.attlist = Common.attrib
+ul = element ul { ul.attlist, li+ }
+ul.attlist = Common.attrib
+li = element li { li.attlist, Flow.model }
+li.attlist = Common.attrib
+List.class = ul | ol | dl
+Block.class |= List.class
diff --git a/etc/schema/xhtml-meta.rnc b/etc/schema/xhtml-meta.rnc
new file mode 100644
index 00000000000..ab0b5eb318a
--- /dev/null
+++ b/etc/schema/xhtml-meta.rnc
@@ -0,0 +1,10 @@
+# Meta Module
+
+meta = element meta { meta.attlist }
+meta.attlist =
+  I18n.attrib,
+  attribute http-equiv { NMTOKEN.datatype }?,
+  attribute name { NMTOKEN.datatype }?,
+  attribute content { text }?,
+  attribute scheme { text }?
+head.content &= meta*
diff --git a/etc/schema/xhtml-nameident.rnc b/etc/schema/xhtml-nameident.rnc
new file mode 100644
index 00000000000..ef4ad7065e7
--- /dev/null
+++ b/etc/schema/xhtml-nameident.rnc
@@ -0,0 +1,10 @@
+# Name Identification Module
+
+a.attlist &= name.attlist
+applet.attlist &= name.attlist
+form.attlist &= name.attlist
+frame.attrib &= name.attlist
+iframe.attlist &= name.attlist
+img.attlist &= name.attlist
+map.attlist &= name.attlist
+name.attlist = attribute name { text }?
diff --git a/etc/schema/xhtml-object.rnc b/etc/schema/xhtml-object.rnc
new file mode 100644
index 00000000000..ac65238db9d
--- /dev/null
+++ b/etc/schema/xhtml-object.rnc
@@ -0,0 +1,24 @@
+# Object Module
+
+object =
+  element object {
+    object.attlist,
+    # No restrictions on mixed content in TREX.
+    param*,
+    Flow.model
+  }
+object.attlist =
+  Common.attrib,
+  attribute declare { "declare" }?,
+  attribute classid { URI.datatype }?,
+  attribute codebase { URI.datatype }?,
+  attribute data { URI.datatype }?,
+  attribute type { ContentType.datatype }?,
+  attribute codetype { ContentType.datatype }?,
+  attribute archive { URIs.datatype }?,
+  attribute standby { Text.datatype }?,
+  attribute height { Length.datatype }?,
+  attribute width { Length.datatype }?,
+  attribute name { text }?,
+  attribute tabindex { Number.datatype }?
+Inline.class |= object
diff --git a/etc/schema/xhtml-param.rnc b/etc/schema/xhtml-param.rnc
new file mode 100644
index 00000000000..8a921ca9b34
--- /dev/null
+++ b/etc/schema/xhtml-param.rnc
@@ -0,0 +1,9 @@
+# Param Module
+
+param = element param { param.attlist }
+param.attlist =
+  id.attrib,
+  attribute name { text },
+  attribute value { text }?,
+  attribute valuetype { "data" | "ref" | "object" }?,
+  attribute type { ContentType.datatype }?
diff --git a/etc/schema/xhtml-pres.rnc b/etc/schema/xhtml-pres.rnc
new file mode 100644
index 00000000000..677372b2dd0
--- /dev/null
+++ b/etc/schema/xhtml-pres.rnc
@@ -0,0 +1,18 @@
+hr = element hr { hr.attlist }
+hr.attlist = Common.attrib
+Block.class |= hr
+b = element b { b.attlist, Inline.model }
+b.attlist = Common.attrib
+big = element big { big.attlist, Inline.model }
+big.attlist = Common.attrib
+i = element i { i.attlist, Inline.model }
+i.attlist = Common.attrib
+small = element small { small.attlist, Inline.model }
+small.attlist = Common.attrib
+sub = element sub { sub.attlist, Inline.model }
+sub.attlist = Common.attrib
+sup = element sup { sup.attlist, Inline.model }
+sup.attlist = Common.attrib
+tt = element tt { tt.attlist, Inline.model }
+tt.attlist = Common.attrib
+Inline.class |= b | big | i | small | sub | sup | tt
diff --git a/etc/schema/xhtml-ruby.rnc b/etc/schema/xhtml-ruby.rnc
new file mode 100644
index 00000000000..e55614dfb95
--- /dev/null
+++ b/etc/schema/xhtml-ruby.rnc
@@ -0,0 +1,21 @@
+ruby =
+  element ruby {
+    ruby.attlist,
+    ((rb,
+      (rt | (rp, rt, rp)))
+     | (rbc, rtc, rtc?))
+  }
+ruby.attlist = Common.attrib
+rbc = element rbc { rbc.attlist, rb+ }
+rbc.attlist = Common.attrib
+rtc = element rtc { rtc.attlist, rt+ }
+rtc.attlist = Common.attrib
+rb = element rb { rb.attlist, Inline.model }
+rb.attlist = Common.attrib
+rt = element rt { rt.attlist, Inline.model }
+rt.attlist =
+  Common.attrib,
+  attribute rt { Number.datatype }?
+rp = element rp { rp.attlist, text }
+rp.attlist = Common.attrib
+Inline.class |= ruby
diff --git a/etc/schema/xhtml-script.rnc b/etc/schema/xhtml-script.rnc
new file mode 100644
index 00000000000..fcf35b02714
--- /dev/null
+++ b/etc/schema/xhtml-script.rnc
@@ -0,0 +1,15 @@
+# Script Module
+
+script = element script { script.attlist, text }
+script.attlist =
+  attribute charset { Charset.datatype }?,
+  attribute type { ContentType.datatype },
+  attribute src { URI.datatype }?,
+  attribute defer { "defer" }?,
+  attribute xml:space { "preserve" }?
+noscript = element noscript { noscript.attlist, Block.model }
+noscript.attlist = Common.attrib
+head.content &= script*
+Script.class = noscript | script
+Inline.class |= Script.class
+Block.class |= Script.class
diff --git a/etc/schema/xhtml-ssismap.rnc b/etc/schema/xhtml-ssismap.rnc
new file mode 100644
index 00000000000..21a7496d307
--- /dev/null
+++ b/etc/schema/xhtml-ssismap.rnc
@@ -0,0 +1,5 @@
+# Server-side Image Map Module
+
+# Depends on image module.
+
+img.attlist &= attribute ismap { "ismap" }?
diff --git a/etc/schema/xhtml-struct.rnc b/etc/schema/xhtml-struct.rnc
new file mode 100644
index 00000000000..4c919c2371a
--- /dev/null
+++ b/etc/schema/xhtml-struct.rnc
@@ -0,0 +1,14 @@
+# Structure Module
+
+start = html
+title = element title { title.attlist, text }
+title.attlist = I18n.attrib
+head = element head { head.attlist, head.content }
+head.attlist = I18n.attrib, profile.attlist
+head.content = title
+profile.attlist = attribute profile { URI.datatype }?
+body = element body { body.attlist, Block.model }
+body.attlist = Common.attrib
+html = element html { html.attlist, head, body }
+html.attlist = XHTML.version.attrib, I18n.attrib
+XHTML.version.attrib = attribute version { FPI.datatype }?
diff --git a/etc/schema/xhtml-style.rnc b/etc/schema/xhtml-style.rnc
new file mode 100644
index 00000000000..93a52d5e2ad
--- /dev/null
+++ b/etc/schema/xhtml-style.rnc
@@ -0,0 +1,10 @@
+# Style Module
+
+style = element style { style.attlist, text }
+style.attlist =
+  title.attrib,
+  I18n.attrib,
+  attribute type { ContentType.datatype },
+  attribute media { MediaDesc.datatype }?,
+  attribute xml:space { "preserve" }?
+head.content &= style*
diff --git a/etc/schema/xhtml-table.rnc b/etc/schema/xhtml-table.rnc
new file mode 100644
index 00000000000..70055b1598f
--- /dev/null
+++ b/etc/schema/xhtml-table.rnc
@@ -0,0 +1,67 @@
+# Tables Module
+
+# This builds on the basic tables module, unlike with the DTD
+# implementation.
+
+include "xhtml-basic-table.rnc" {
+  table =
+    element table {
+      table.attlist,
+      caption?,
+      (col* | colgroup*),
+      ((thead?, tfoot?, tbody+) | tr+)
+    }
+  th = element th { th.attlist, Flow.model }
+  td = element td { td.attlist, Flow.model }
+  CellHAlign.attrib =
+    attribute align {
+      "left" | "center" | "right" | "justify" | "char"
+    }?,
+    attribute char { Character.datatype }?,
+    attribute charoff { Length.datatype }?
+  CellVAlign.attrib =
+    attribute valign { "top" | "middle" | "bottom" | "baseline" }?
+  scope.attrib =
+    attribute scope { "row" | "col" | "rowgroup" | "colgroup" }?
+}
+table.attlist &=
+  attribute width { Length.datatype }?,
+  attribute border { Pixels.datatype }?,
+  frame.attrib,
+  rules.attrib,
+  attribute cellspacing { Length.datatype }?,
+  attribute cellpadding { Length.datatype }?
+col = element col { col.attlist }
+col.attlist =
+  Common.attrib,
+  attribute span { Number.datatype }?,
+  attribute width { MultiLength.datatype }?,
+  CellHAlign.attrib,
+  CellVAlign.attrib
+colgroup = element colgroup { colgroup.attlist, col* }
+colgroup.attlist =
+  Common.attrib,
+  attribute span { Number.datatype }?,
+  attribute width { MultiLength.datatype }?,
+  CellHAlign.attrib,
+  CellVAlign.attrib
+tbody = element tbody { tbody.attlist, tr+ }
+tbody.attlist = Common.attrib, CellHAlign.attrib, CellVAlign.attrib
+thead = element thead { thead.attlist, tr+ }
+thead.attlist = Common.attrib, CellHAlign.attrib, CellVAlign.attrib
+tfoot = element tfoot { tfoot.attlist, tr+ }
+tfoot.attlist = Common.attrib, CellHAlign.attrib, CellVAlign.attrib
+frame.attrib =
+  attribute frame {
+    "void"
+    | "above"
+    | "below"
+    | "hsides"
+    | "lhs"
+    | "rhs"
+    | "vsides"
+    | "box"
+    | "border"
+  }?
+rules.attrib =
+  attribute rules { "none" | "groups" | "rows" | "cols" | "all" }?
diff --git a/etc/schema/xhtml-target.rnc b/etc/schema/xhtml-target.rnc
new file mode 100644
index 00000000000..505b37963a9
--- /dev/null
+++ b/etc/schema/xhtml-target.rnc
@@ -0,0 +1,8 @@
+# Target Module
+
+a.attlist &= target.attrib
+area.attlist &= target.attrib
+base.attlist &= target.attrib
+link.attrib &= target.attrib
+form.attlist &= target.attrib
+target.attrib = attribute target { text }?
diff --git a/etc/schema/xhtml-text.rnc b/etc/schema/xhtml-text.rnc
new file mode 100644
index 00000000000..c4283d44179
--- /dev/null
+++ b/etc/schema/xhtml-text.rnc
@@ -0,0 +1,73 @@
+# Text Module
+
+br = element br { br.attlist, empty }
+br.attlist = Core.attrib
+span = element span { span.attlist, Inline.model }
+span.attlist = Common.attrib
+abbr = element abbr { abbr.attlist, Inline.model }
+abbr.attlist = Common.attrib
+acronym = element acronym { acronym.attlist, Inline.model }
+acronym.attlist = Common.attrib
+cite = element cite { cite.attlist, Inline.model }
+cite.attlist = Common.attrib
+code = element code { code.attlist, Inline.model }
+code.attlist = Common.attrib
+dfn = element dfn { dfn.attlist, Inline.model }
+dfn.attlist = Common.attrib
+em = element em { em.attlist, Inline.model }
+em.attlist = Common.attrib
+kbd = element kbd { kbd.attlist, Inline.model }
+kbd.attlist = Common.attrib
+q = element q { q.attlist, Inline.model }
+q.attlist =
+  Common.attrib,
+  attribute cite { URI.datatype }?
+samp = element samp { samp.attlist, Inline.model }
+samp.attlist = Common.attrib
+strong = element strong { strong.attlist, Inline.model }
+strong.attlist = Common.attrib
+var = element var { var.attlist, Inline.model }
+var.attlist = Common.attrib
+\div = element div { div.attlist, Flow.model }
+div.attlist = Common.attrib
+p = element p { p.attlist, Inline.model }
+p.attlist = Common.attrib
+address = element address { address.attlist, Inline.model }
+address.attlist = Common.attrib
+blockquote = element blockquote { blockquote.attlist, Block.model }
+blockquote.attlist =
+  Common.attrib,
+  attribute cite { URI.datatype }?
+pre = element pre { pre.attlist, Inline.model }
+pre.attlist =
+  Common.attrib,
+  attribute xml:space { "preserve" }?
+h1 = element h1 { Heading.attrib, Heading.content }
+h2 = element h2 { Heading.attrib, Heading.content }
+h3 = element h3 { Heading.attrib, Heading.content }
+h4 = element h4 { Heading.attrib, Heading.content }
+h5 = element h5 { Heading.attrib, Heading.content }
+h6 = element h6 { Heading.attrib, Heading.content }
+Heading.attrib = Common.attrib
+Heading.content = Inline.model
+Heading.class = h1 | h2 | h3 | h4 | h5 | h6
+Block.class = address | blockquote | \div | p | pre | Heading.class
+Inline.class =
+  abbr
+  | acronym
+  | br
+  | cite
+  | code
+  | dfn
+  | em
+  | kbd
+  | q
+  | samp
+  | span
+  | strong
+  | var
+Inline.model = (text | Inline.class)*
+# This is redefined by the legacy module to include inlines.
+Block.mix = Block.class
+Block.model = Block.mix+
+Flow.model = (text | Inline.class | Block.class)*
diff --git a/etc/schema/xhtml.rnc b/etc/schema/xhtml.rnc
new file mode 100644
index 00000000000..3218cd71e5b
--- /dev/null
+++ b/etc/schema/xhtml.rnc
@@ -0,0 +1,37 @@
+# XHTML
+
+# This corresponds to the union of transitional and frameset.
+
+default namespace = "http://www.w3.org/1999/xhtml"
+
+include "xhtml-datatypes.rnc"
+include "xhtml-attribs.rnc"
+# include "xhtml-struct.rnc"
+include "xhtml-frames.rnc"
+include "xhtml-text.rnc"
+include "xhtml-hypertext.rnc"
+include "xhtml-list.rnc"
+include "xhtml-image.rnc"
+include "xhtml-ssismap.rnc"
+include "xhtml-base.rnc"
+include "xhtml-link.rnc"
+include "xhtml-meta.rnc"
+include "xhtml-param.rnc"
+include "xhtml-object.rnc"
+include "xhtml-bdo.rnc"
+include "xhtml-pres.rnc"
+include "xhtml-edit.rnc"
+include "xhtml-applet.rnc"
+# include "xhtml-basic-form.rnc"
+include "xhtml-form.rnc"
+include "xhtml-style.rnc"
+include "xhtml-script.rnc"
+# include "xhtml-basic-table.rnc"
+include "xhtml-table.rnc"
+include "xhtml-csismap.rnc"
+include "xhtml-events.rnc"
+include "xhtml-inlstyle.rnc"
+include "xhtml-target.rnc"
+include "xhtml-iframe.rnc"
+include "xhtml-nameident.rnc"
+include "xhtml-legacy.rnc"
diff --git a/etc/schema/xslt.rnc b/etc/schema/xslt.rnc
new file mode 100644
index 00000000000..eaa332f86b3
--- /dev/null
+++ b/etc/schema/xslt.rnc
@@ -0,0 +1,356 @@
+# $Id: xslt.rnc,v 1.2 2003/08/30 08:09:03 jjc Exp $
+
+# This was mostly generated from the syntax summary in the XSLT
+# Recommendation (using XSLT of course).
+
+# Issues: this validates extension elements as literal result
+# elements, which is overly restrictive.
+
+namespace local = ""
+default namespace xsl = "http://www.w3.org/1999/XSL/Transform"
+
+start =
+  stylesheet.element
+  | transform.element
+  | literal-result-element-as-stylesheet
+version = "1.0"
+top-level-elements.model =
+  (top-level-element.category | top-level-extension)*
+top-level-extension =
+  element * - (xsl:* | local:*) {
+    grammar {
+      start = any
+      any =
+        (attribute * { text }
+         | text
+         | element * { any })*
+    }
+  }
+template.model = (instruction.category | literal-result-element | text)*
+literal-result-element-as-stylesheet =
+  element * - xsl:* {
+    attribute xsl:version { version },
+    literal-result-element-no-version.atts,
+    template.model
+  }
+literal-result-element =
+  element * - xsl:* { literal-result-element.atts, template.model }
+literal-result-element.atts =
+  literal-result-element-no-version.atts,
+  attribute xsl:version { version }?
+literal-result-element-no-version.atts =
+  (attribute * - xsl:* { avt.datatype }
+   | attribute xsl:extension-element-prefixes { prefixes.datatype }
+   | attribute xsl:exclude-result-prefixes { prefixes.datatype }
+   | attribute xsl:use-attribute-sets { qnames.datatype })*
+top-level-element.category =
+  include.element
+  | strip-space.element
+  | preserve-space.element
+  | template.element
+  | namespace-alias.element
+  | attribute-set.element
+  | variable.element
+  | param.element
+  | key.element
+  | decimal-format.element
+  | output.element
+instruction.category =
+  apply-templates.element
+  | apply-imports.element
+  | call-template.element
+  | element.element
+  | attribute.element
+  | text.element
+  | processing-instruction.element
+  | comment.element
+  | copy.element
+  | value-of.element
+  | number.element
+  | for-each.element
+  | if.element
+  | choose.element
+  | variable.element
+  | copy-of.element
+  | message.element
+  | fallback.element
+extension.atts = attribute * - (xsl:* | local:*) { text }*
+stylesheet.element = element stylesheet { stylesheet.model }
+transform.element = element transform { stylesheet.model }
+stylesheet.model =
+  extension.atts,
+  attribute id { xsd:NCName }?,
+  attribute extension-element-prefixes { prefixes.datatype }?,
+  attribute exclude-result-prefixes { prefixes.datatype }?,
+  attribute version { version },
+  (import.element*, top-level-elements.model)
+include.element =
+  element include {
+    extension.atts,
+    attribute href { xsd:anyURI }
+  }
+import.element =
+  element import {
+    extension.atts,
+    attribute href { xsd:anyURI }
+  }
+strip-space.element =
+  element strip-space {
+    extension.atts,
+    attribute elements { wildcards.datatype }
+  }
+preserve-space.element =
+  element preserve-space {
+    extension.atts,
+    attribute elements { wildcards.datatype }
+  }
+template.element =
+  element template {
+    extension.atts,
+    attribute match { pattern.datatype }?,
+    attribute name { qname.datatype }?,
+    attribute priority { number.datatype }?,
+    attribute mode { qname.datatype }?,
+    (param.element*, template.model)
+  }
+apply-templates.element =
+  element apply-templates {
+    extension.atts,
+    attribute select { expression.datatype }?,
+    attribute mode { qname.datatype }?,
+    (sort.element | with-param.element)*
+  }
+apply-imports.element = element apply-imports { extension.atts }
+call-template.element =
+  element call-template {
+    extension.atts,
+    attribute name { qname.datatype },
+    with-param.element*
+  }
+namespace-alias.element =
+  element namespace-alias {
+    extension.atts,
+    attribute stylesheet-prefix { prefix.datatype },
+    attribute result-prefix { prefix.datatype }
+  }
+element.element =
+  element element {
+    extension.atts,
+    attribute name { qname.datatype | expr-avt.datatype },
+    attribute namespace { xsd:anyURI | brace-avt.datatype }?,
+    attribute use-attribute-sets { qnames.datatype }?,
+    template.model
+  }
+attribute.element =
+  element attribute {
+    extension.atts,
+    attribute name { qname.datatype | expr-avt.datatype },
+    attribute namespace { xsd:anyURI | brace-avt.datatype }?,
+    template.model
+  }
+attribute-set.element =
+  element attribute-set {
+    extension.atts,
+    attribute name { qname.datatype },
+    attribute use-attribute-sets { qnames.datatype }?,
+    attribute.element*
+  }
+text.element =
+  element text {
+    extension.atts,
+    attribute disable-output-escaping {
+      xsd:string "yes" | xsd:string "no"
+    }?,
+    text
+  }
+processing-instruction.element =
+  element processing-instruction {
+    extension.atts,
+    attribute name { xsd:NCName | expr-avt.datatype },
+    template.model
+  }
+comment.element = element comment { extension.atts, template.model }
+copy.element =
+  element copy {
+    extension.atts,
+    attribute use-attribute-sets { qnames.datatype }?,
+    template.model
+  }
+value-of.element =
+  element value-of {
+    extension.atts,
+    attribute select { expression.datatype },
+    attribute disable-output-escaping {
+      xsd:string "yes" | xsd:string "no"
+    }?
+  }
+number.element =
+  element number {
+    extension.atts,
+    attribute level {
+      xsd:string "single" | xsd:string "multiple" | xsd:string "any"
+    }?,
+    attribute count { pattern.datatype }?,
+    attribute from { pattern.datatype }?,
+    attribute value { expression.datatype }?,
+    attribute format { avt.datatype }?,
+    attribute lang { xsd:NMTOKEN | expr-avt.datatype }?,
+    attribute letter-value {
+      xsd:string "alphabetic"
+      | xsd:string "traditional"
+      | expr-avt.datatype
+    }?,
+    attribute grouping-separator { char.datatype | expr-avt.datatype }?,
+    attribute grouping-size { number.datatype | expr-avt.datatype }?
+  }
+for-each.element =
+  element for-each {
+    extension.atts,
+    attribute select { expression.datatype },
+    (sort.element*, template.model)
+  }
+if.element =
+  element if {
+    extension.atts,
+    attribute test { expression.datatype },
+    template.model
+  }
+choose.element =
+  element choose { extension.atts, (when.element+, otherwise.element?) }
+when.element =
+  element when {
+    extension.atts,
+    attribute test { expression.datatype },
+    template.model
+  }
+otherwise.element = element otherwise { extension.atts, template.model }
+sort.element =
+  element sort {
+    extension.atts,
+    attribute select { expression.datatype }?,
+    attribute lang { xsd:NMTOKEN | expr-avt.datatype }?,
+    attribute data-type {
+      xsd:string "text"
+      | xsd:string "number"
+      | qname-but-not-ncname.datatype
+      | expr-avt.datatype
+    }?,
+    attribute order {
+      xsd:string "ascending"
+      | xsd:string "descending"
+      | expr-avt.datatype
+    }?,
+    attribute case-order {
+      xsd:string "upper-first"
+      | xsd:string "lower-first"
+      | expr-avt.datatype
+    }?
+  }
+variable.element =
+  element variable {
+    extension.atts,
+    attribute name { qname.datatype },
+    (attribute select { expression.datatype }
+     | template.model)
+  }
+param.element =
+  element param {
+    extension.atts,
+    attribute name { qname.datatype },
+    (attribute select { expression.datatype }
+     | template.model)
+  }
+copy-of.element =
+  element copy-of {
+    extension.atts,
+    attribute select { expression.datatype }
+  }
+with-param.element =
+  element with-param {
+    extension.atts,
+    attribute name { qname.datatype },
+    (attribute select { expression.datatype }
+     | template.model)
+  }
+key.element =
+  element key {
+    extension.atts,
+    attribute name { qname.datatype },
+    attribute match { pattern.datatype },
+    attribute use { expression.datatype }
+  }
+decimal-format.element =
+  element decimal-format {
+    extension.atts,
+    attribute name { qname.datatype }?,
+    attribute decimal-separator { char.datatype }?,
+    attribute grouping-separator { char.datatype }?,
+    attribute infinity { text }?,
+    attribute minus-sign { char.datatype }?,
+    attribute NaN { text }?,
+    attribute percent { char.datatype }?,
+    attribute per-mille { char.datatype }?,
+    attribute zero-digit { char.datatype }?,
+    attribute digit { char.datatype }?,
+    attribute pattern-separator { char.datatype }?
+  }
+message.element =
+  element message {
+    extension.atts,
+    attribute terminate { xsd:string "yes" | xsd:string "no" }?,
+    template.model
+  }
+fallback.element = element fallback { extension.atts, template.model }
+output.element =
+  element output {
+    extension.atts,
+    attribute method {
+      xsd:string "xml"
+      | xsd:string "html"
+      | xsd:string "text"
+      | qname-but-not-ncname.datatype
+    }?,
+    attribute version { xsd:NMTOKEN }?,
+    attribute encoding { text }?,
+    attribute omit-xml-declaration {
+      xsd:string "yes" | xsd:string "no"
+    }?,
+    attribute standalone { xsd:string "yes" | xsd:string "no" }?,
+    attribute doctype-public { text }?,
+    attribute doctype-system { text }?,
+    attribute cdata-section-elements { qnames.datatype }?,
+    attribute indent { xsd:string "yes" | xsd:string "no" }?,
+    attribute media-type { text }?
+  }
+prefixes.datatype = list { (xsd:NCName | "#default")* }
+prefix.datatype = xsd:NCName | "#default"
+wildcards.datatype =
+  list {
+    (xsd:QName
+     | xsd:token { pattern = "\*|\i\c*:\*" })*
+  }
+qname.datatype = xsd:QName
+qnames.datatype = list { xsd:QName* }
+char.datatype = xsd:string { length = "1" }
+number.datatype = xsd:decimal
+expression.datatype = text
+pattern.datatype = text
+qname-but-not-ncname.datatype = xsd:QName { pattern = ".*:.*" }
+# An AVT containing at least one expression.
+expr-avt.datatype =
+  xsd:string {
+    pattern =
+      """([^\{\}]|\{\{|\}\})*\{([^"'\{\}]|"[^"]*"|'[^']*')+\}([^\{\}]|\{\{|\}\}|\{([^"'\{\}]|"[^"]*"|'[^']*')+\})*"""
+  }
+# An AVT containing at least one brace; ie where instantiated AVT
+# is not the same as the literal AVT.
+brace-avt.datatype =
+  xsd:string {
+    pattern =
+      """[^\{\}]*(\{\{|\}\}|\{([^"'\{\}]|"[^"]*"|'[^']*')+\})([^\{\}]|\{\{|\}\}|\{([^"'\{\}]|"[^"]*"|'[^']*')+\})*"""
+  }
+avt.datatype =
+  xsd:string {
+    pattern =
+      """([^\{\}]|\{\{|\}\}|\{([^"'\{\}]|"[^"]*"|'[^']*')+\})*"""
+  }