5084 lines
139 KiB
Plaintext
5084 lines
139 KiB
Plaintext
# 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., Δ
|
|
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 ......................
|
|
|
|
# ......................................................................
|