Mercurial > emacs
view etc/schema/dbpool.rnc @ 111046:f0ba7e7104ca
* net/tramp.el (tramp-do-file-attributes-with-stat)
(tramp-do-directory-files-and-attributes-with-stat): Use "e0" in
order to make stat results a float. Patch by Andreas Schwab
<schwab@linux-m68k.org>.
author | Michael Albinus <michael.albinus@gmx.de> |
---|---|
date | Tue, 19 Oct 2010 11:26:21 +0200 |
parents | 38f93f3d00a2 |
children | 53108e6cea98 |
line wrap: on
line source
# 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 ...................... # ......................................................................