code.delx.au - gnu-emacs/blob - etc/schema/dbpool.rnc

   1 # This file was generated automatically by Trang.  The table model
   2 # dependent definitions have been moved into separate files.
   3
   4 # ......................................................................
   5
   6 # DocBook XML information pool module V4.2 .............................
   7
   8 # File dbpoolx.mod .....................................................
   9
  10 # Copyright 1992-2002 HaL Computer Systems, Inc.,
  11 # O'Reilly & Associates, Inc., ArborText, Inc., Fujitsu Software
  12 # Corporation, Norman Walsh, Sun Microsystems, Inc., and the
  13 # Organization for the Advancement of Structured Information
  14 # Standards (OASIS).
  15 #
  16 # $Id: dbpool.rnc,v 1.4 2003/08/30 07:48:31 jjc Exp $
  17 #
  18 # Permission to use, copy, modify and distribute the DocBook XML DTD
  19 # and its accompanying documentation for any purpose and without fee
  20 # is hereby granted in perpetuity, provided that the above copyright
  21 # notice and this paragraph appear in all copies.  The copyright
  22 # holders make no representation about the suitability of the DTD for
  23 # any purpose.  It is provided "as is" without expressed or implied
  24 # warranty.
  25 #
  26 # If you modify the DocBook XML DTD in any way, except for declaring and
  27 # referencing additional sets of general entities and declaring
  28 # additional notations, label your DTD as a variant of DocBook.  See
  29 # the maintenance documentation for more information.
  30 #
  31 # Please direct all questions, bug reports, or suggestions for
  32 # changes to the docbook@lists.oasis-open.org mailing list. For more
  33 # information, see http://www.oasis-open.org/docbook/.
  34
  35 # ......................................................................
  36
  37 # This module contains the definitions for the objects, inline
  38 # elements, and so on that are available to be used as the main
  39 # content of DocBook documents.  Some elements are useful for general
  40 # publishing, and others are useful specifically for computer
  41 # documentation.
  42 #
  43 # This module has the following dependencies on other modules:
  44 #
  45 # o It assumes that a %notation.class; entity is defined by the
  46 #   driver file or other high-level module.  This entity is
  47 #   referenced in the NOTATION attributes for the graphic-related and
  48 #   ModeSpec elements.
  49 #
  50 # o It assumes that an appropriately parameterized table module is
  51 #   available for use with the table-related elements.
  52 #
  53 # In DTD driver files referring to this module, please use an entity
  54 # declaration that uses the public identifier shown below:
  55 #
  56 # <!ENTITY % dbpool PUBLIC
  57 # "-//OASIS//ELEMENTS DocBook XML Information Pool V4.2//EN"
  58 # "dbpoolx.mod">
  59 # %dbpool;
  60 #
  61 # See the documentation for detailed information on the parameter
  62 # entity and module scheme used in DocBook, customizing DocBook and
  63 # planning for interchange, and changes made since the last release
  64 # of DocBook.
  65
  66 # ......................................................................
  67
  68 # General-purpose semantics entities ...................................
  69
  70 namespace a = "http://relaxng.org/ns/compatibility/annotations/1.0"
  71
  72 yesorno.attvals = string
  73 # ......................................................................
  74
  75 # Entities for module inclusions .......................................
  76
  77 # ......................................................................
  78
  79 # Entities for element classes and mixtures ............................
  80
  81 # "Ubiquitous" classes: ndxterm.class and beginpage
  82 local.ndxterm.class = notAllowed
  83 ndxterm.class = indexterm | local.ndxterm.class
  84 # Object-level classes .................................................
  85 local.list.class = notAllowed
  86 list.class =
  87   calloutlist
  88   | glosslist
  89   | itemizedlist
  90   | orderedlist
  91   | segmentedlist
  92   | simplelist
  93   | variablelist
  94   | local.list.class
  95 local.admon.class = notAllowed
  96 admon.class =
  97   caution | important | note | tip | warning | local.admon.class
  98 local.linespecific.class = notAllowed
  99 linespecific.class =
 100   literallayout
 101   | programlisting
 102   | programlistingco
 103   | screen
 104   | screenco
 105   | screenshot
 106   | local.linespecific.class
 107 local.method.synop.class = notAllowed
 108 method.synop.class =
 109   constructorsynopsis
 110   | destructorsynopsis
 111   | methodsynopsis
 112   | local.method.synop.class
 113 local.synop.class = notAllowed
 114 synop.class =
 115   synopsis
 116   | cmdsynopsis
 117   | funcsynopsis
 118   | classsynopsis
 119   | fieldsynopsis
 120   | method.synop.class
 121   | local.synop.class
 122 local.para.class = notAllowed
 123 para.class = formalpara | para | simpara | local.para.class
 124 local.informal.class = notAllowed
 125 informal.class =
 126   address
 127   | blockquote
 128   | graphic
 129   | graphicco
 130   | mediaobject
 131   | mediaobjectco
 132   | informalequation
 133   | informalexample
 134   | informalfigure
 135   | informaltable
 136   | local.informal.class
 137 local.formal.class = notAllowed
 138 formal.class = equation | example | figure | table | local.formal.class
 139 # The DocBook TC may produce an official EBNF module for DocBook.
 140
 141 # This PE provides the hook by which it can be inserted into the DTD.
 142 ebnf.block.hook = notAllowed
 143 local.compound.class = notAllowed
 144 compound.class =
 145   msgset
 146   | procedure
 147   | sidebar
 148   | qandaset
 149   | ebnf.block.hook
 150   | local.compound.class
 151 local.genobj.class = notAllowed
 152 genobj.class =
 153   anchor | bridgehead | remark | highlights | local.genobj.class
 154 local.descobj.class = notAllowed
 155 descobj.class = abstract | authorblurb | epigraph | local.descobj.class
 156 # Character-level classes ..............................................
 157 local.xref.char.class = notAllowed
 158 xref.char.class = footnoteref | xref | local.xref.char.class
 159 local.gen.char.class = notAllowed
 160 gen.char.class =
 161   abbrev
 162   | acronym
 163   | citation
 164   | citerefentry
 165   | citetitle
 166   | emphasis
 167   | firstterm
 168   | foreignphrase
 169   | glossterm
 170   | footnote
 171   | phrase
 172   | quote
 173   | trademark
 174   | wordasword
 175   | personname
 176   | local.gen.char.class
 177 local.link.char.class = notAllowed
 178 link.char.class = link | olink | ulink | local.link.char.class
 179 # The DocBook TC may produce an official EBNF module for DocBook.
 180
 181 # This PE provides the hook by which it can be inserted into the DTD.
 182 ebnf.inline.hook = notAllowed
 183 local.tech.char.class = notAllowed
 184 tech.char.class =
 185   action
 186   | application
 187   | classname
 188   | methodname
 189   | interfacename
 190   | exceptionname
 191   | ooclass
 192   | oointerface
 193   | ooexception
 194   | command
 195   | computeroutput
 196   | database
 197   | email
 198   | envar
 199   | errorcode
 200   | errorname
 201   | errortype
 202   | errortext
 203   | filename
 204   | function
 205   | guibutton
 206   | guiicon
 207   | guilabel
 208   | guimenu
 209   | guimenuitem
 210   | guisubmenu
 211   | hardware
 212   | interface
 213   | keycap
 214   | keycode
 215   | keycombo
 216   | keysym
 217   | literal
 218   | constant
 219   | markup
 220   | medialabel
 221   | menuchoice
 222   | mousebutton
 223   | option
 224   | optional
 225   | parameter
 226   | prompt
 227   | property
 228   | replaceable
 229   | returnvalue
 230   | sgmltag
 231   | structfield
 232   | structname
 233   | symbol
 234   | systemitem
 235   | \token
 236   | type
 237   | userinput
 238   | varname
 239   | ebnf.inline.hook
 240   | local.tech.char.class
 241 local.base.char.class = notAllowed
 242 base.char.class = anchor | local.base.char.class
 243 local.docinfo.char.class = notAllowed
 244 docinfo.char.class =
 245   author
 246   | authorinitials
 247   | corpauthor
 248   | modespec
 249   | othercredit
 250   | productname
 251   | productnumber
 252   | revhistory
 253   | local.docinfo.char.class
 254 local.other.char.class = notAllowed
 255 other.char.class =
 256   remark | subscript | superscript | local.other.char.class
 257 local.inlineobj.char.class = notAllowed
 258 inlineobj.char.class =
 259   inlinegraphic
 260   | inlinemediaobject
 261   | inlineequation
 262   | local.inlineobj.char.class
 263 # ......................................................................
 264
 265 # Entities for content models ..........................................
 266 formalobject.title.content = title, titleabbrev?
 267 # Redeclaration placeholder ............................................
 268
 269 # For redeclaring entities that are declared after this point while
 270 # retaining their references to the entities that are declared before
 271 # this point
 272
 273 # Object-level mixtures ................................................
 274
 275 #                       list admn line synp para infm form cmpd gen  desc
 276 # Component mixture       X    X    X    X    X    X    X    X    X    X
 277 # Sidebar mixture         X    X    X    X    X    X    X    a    X
 278 # Footnote mixture        X         X    X    X    X
 279 # Example mixture         X         X    X    X    X
 280 # Highlights mixture      X    X              X
 281 # Paragraph mixture       X         X    X         X
 282 # Admonition mixture      X         X    X    X    X    X    b    c
 283 # Figure mixture                    X    X         X
 284 # Table entry mixture     X    X    X         X    d
 285 # Glossary def mixture    X         X    X    X    X         e
 286 # Legal notice mixture    X    X    X         X    f
 287 #
 288 # a. Just Procedure; not Sidebar itself or MsgSet.
 289 # b. No MsgSet.
 290 # c. No Highlights.
 291 # d. Just Graphic; no other informal objects.
 292 # e. No Anchor, BridgeHead, or Highlights.
 293 # f. Just BlockQuote; no other informal objects.
 294 local.component.mix = notAllowed
 295 component.mix =
 296   list.class
 297   | admon.class
 298   | linespecific.class
 299   | synop.class
 300   | para.class
 301   | informal.class
 302   | formal.class
 303   | compound.class
 304   | genobj.class
 305   | descobj.class
 306   | ndxterm.class
 307   | beginpage
 308   | local.component.mix
 309 local.sidebar.mix = notAllowed
 310 sidebar.mix =
 311   list.class
 312   | admon.class
 313   | linespecific.class
 314   | synop.class
 315   | para.class
 316   | informal.class
 317   | formal.class
 318   | procedure
 319   | genobj.class
 320   | ndxterm.class
 321   | beginpage
 322   | local.sidebar.mix
 323 local.qandaset.mix = notAllowed
 324 qandaset.mix =
 325   list.class
 326   | admon.class
 327   | linespecific.class
 328   | synop.class
 329   | para.class
 330   | informal.class
 331   | formal.class
 332   | procedure
 333   | genobj.class
 334   | ndxterm.class
 335   | local.qandaset.mix
 336 local.revdescription.mix = notAllowed
 337 revdescription.mix =
 338   list.class
 339   | admon.class
 340   | linespecific.class
 341   | synop.class
 342   | para.class
 343   | informal.class
 344   | formal.class
 345   | procedure
 346   | genobj.class
 347   | ndxterm.class
 348   | local.revdescription.mix
 349 local.footnote.mix = notAllowed
 350 footnote.mix =
 351   list.class
 352   | linespecific.class
 353   | synop.class
 354   | para.class
 355   | informal.class
 356   | local.footnote.mix
 357 local.example.mix = notAllowed
 358 example.mix =
 359   list.class
 360   | linespecific.class
 361   | synop.class
 362   | para.class
 363   | informal.class
 364   | ndxterm.class
 365   | beginpage
 366   | local.example.mix
 367 local.highlights.mix = notAllowed
 368 highlights.mix =
 369   list.class
 370   | admon.class
 371   | para.class
 372   | ndxterm.class
 373   | local.highlights.mix
 374 # %formal.class; is explicitly excluded from many contexts in which
 375 # paragraphs are used
 376 local.para.mix = notAllowed
 377 para.mix =
 378   list.class
 379   | admon.class
 380   | linespecific.class
 381   | informal.class
 382   | formal.class
 383   | local.para.mix
 384 local.admon.mix = notAllowed
 385 admon.mix =
 386   list.class
 387   | linespecific.class
 388   | synop.class
 389   | para.class
 390   | informal.class
 391   | formal.class
 392   | procedure
 393   | sidebar
 394   | anchor
 395   | bridgehead
 396   | remark
 397   | ndxterm.class
 398   | beginpage
 399   | local.admon.mix
 400 local.figure.mix = notAllowed
 401 figure.mix =
 402   linespecific.class
 403   | synop.class
 404   | informal.class
 405   | ndxterm.class
 406   | beginpage
 407   | local.figure.mix
 408 local.tabentry.mix = notAllowed
 409 tabentry.mix =
 410   list.class
 411   | admon.class
 412   | linespecific.class
 413   | para.class
 414   | graphic
 415   | mediaobject
 416   | local.tabentry.mix
 417 local.glossdef.mix = notAllowed
 418 glossdef.mix =
 419   list.class
 420   | linespecific.class
 421   | synop.class
 422   | para.class
 423   | informal.class
 424   | formal.class
 425   | remark
 426   | ndxterm.class
 427   | beginpage
 428   | local.glossdef.mix
 429 local.legalnotice.mix = notAllowed
 430 legalnotice.mix =
 431   list.class
 432   | admon.class
 433   | linespecific.class
 434   | para.class
 435   | blockquote
 436   | ndxterm.class
 437   | beginpage
 438   | local.legalnotice.mix
 439 local.textobject.mix = notAllowed
 440 textobject.mix =
 441   list.class
 442   | admon.class
 443   | linespecific.class
 444   | para.class
 445   | blockquote
 446   | local.textobject.mix
 447 local.mediaobject.mix = notAllowed
 448 mediaobject.mix =
 449   videoobject
 450   | audioobject
 451   | imageobject
 452   | textobject
 453   | local.mediaobject.mix
 454 local.listpreamble.mix = notAllowed
 455 listpreamble.mix =
 456   admon.class
 457   | linespecific.class
 458   | synop.class
 459   | para.class
 460   | informal.class
 461   | genobj.class
 462   | descobj.class
 463   | ndxterm.class
 464   | beginpage
 465   | local.listpreamble.mix
 466 # Character-level mixtures .............................................
 467
 468 # sgml.features
 469
 470 # not [sgml.features[
 471
 472 # ]] not sgml.features
 473
 474 #                     #PCD xref word link cptr base dnfo othr inob (synop)
 475 # para.char.mix         X    X    X    X    X    X    X    X    X
 476 # title.char.mix        X    X    X    X    X    X    X    X    X
 477 # ndxterm.char.mix      X    X    X    X    X    X    X    X    a
 478 # cptr.char.mix         X              X    X    X         X    a
 479 # smallcptr.char.mix    X                   b                   a
 480 # word.char.mix         X         c    X         X         X    a
 481 # docinfo.char.mix      X         d    X    b              X    a
 482 #
 483 # a. Just InlineGraphic; no InlineEquation.
 484 # b. Just Replaceable; no other computer terms.
 485 # c. Just Emphasis and Trademark; no other word elements.
 486 # d. Just Acronym, Emphasis, and Trademark; no other word elements.
 487
 488 # The DocBook TC may produce an official forms module for DocBook.
 489
 490 # This PE provides the hook by which it can be inserted into the DTD.
 491 forminlines.hook = notAllowed
 492 local.para.char.mix = notAllowed
 493 para.char.mix =
 494   text
 495   | xref.char.class
 496   | gen.char.class
 497   | link.char.class
 498   | tech.char.class
 499   | base.char.class
 500   | docinfo.char.class
 501   | other.char.class
 502   | inlineobj.char.class
 503   | synop.class
 504   | ndxterm.class
 505   | beginpage
 506   | forminlines.hook
 507   | local.para.char.mix
 508 local.title.char.mix = notAllowed
 509 title.char.mix =
 510   text
 511   | xref.char.class
 512   | gen.char.class
 513   | link.char.class
 514   | tech.char.class
 515   | base.char.class
 516   | docinfo.char.class
 517   | other.char.class
 518   | inlineobj.char.class
 519   | ndxterm.class
 520   | local.title.char.mix
 521 local.ndxterm.char.mix = notAllowed
 522 ndxterm.char.mix =
 523   text
 524   | xref.char.class
 525   | gen.char.class
 526   | link.char.class
 527   | tech.char.class
 528   | base.char.class
 529   | docinfo.char.class
 530   | other.char.class
 531   | inlinegraphic
 532   | inlinemediaobject
 533   | local.ndxterm.char.mix
 534 local.cptr.char.mix = notAllowed
 535 cptr.char.mix =
 536   text
 537   | link.char.class
 538   | tech.char.class
 539   | base.char.class
 540   | other.char.class
 541   | inlinegraphic
 542   | inlinemediaobject
 543   | ndxterm.class
 544   | beginpage
 545   | local.cptr.char.mix
 546 local.smallcptr.char.mix = notAllowed
 547 smallcptr.char.mix =
 548   text
 549   | replaceable
 550   | inlinegraphic
 551   | inlinemediaobject
 552   | ndxterm.class
 553   | beginpage
 554   | local.smallcptr.char.mix
 555 local.word.char.mix = notAllowed
 556 word.char.mix =
 557   text
 558   | acronym
 559   | emphasis
 560   | trademark
 561   | link.char.class
 562   | base.char.class
 563   | other.char.class
 564   | inlinegraphic
 565   | inlinemediaobject
 566   | ndxterm.class
 567   | beginpage
 568   | local.word.char.mix
 569 local.docinfo.char.mix = notAllowed
 570 docinfo.char.mix =
 571   text
 572   | link.char.class
 573   | emphasis
 574   | trademark
 575   | replaceable
 576   | other.char.class
 577   | inlinegraphic
 578   | inlinemediaobject
 579   | ndxterm.class
 580   | local.docinfo.char.mix
 581 # ENTITY % bibliocomponent.mix (see Bibliographic section, below)
 582
 583 # ENTITY % person.ident.mix (see Bibliographic section, below)
 584
 585 # ......................................................................
 586
 587 # Entities for attributes and attribute components .....................
 588
 589 # Effectivity attributes ...............................................
 590
 591 # Arch: Computer or chip architecture to which element applies; no
 592 # default
 593 arch.attrib = attribute arch { text }?
 594 # Condition: General-purpose effectivity attribute
 595 condition.attrib = attribute condition { text }?
 596 # Conformance: Standards conformance characteristics
 597 conformance.attrib = attribute conformance { xsd:NMTOKENS }?
 598 # OS: Operating system to which element applies; no default
 599 os.attrib = attribute os { text }?
 600 # Revision: Editorial revision to which element belongs; no default
 601 revision.attrib = attribute revision { text }?
 602 # Security: Security classification; no default
 603 security.attrib = attribute security { text }?
 604 # UserLevel: Level of user experience to which element applies; no
 605 # default
 606 userlevel.attrib = attribute userlevel { text }?
 607 # Vendor: Computer vendor to which element applies; no default
 608 vendor.attrib = attribute vendor { text }?
 609 local.effectivity.attrib = empty
 610 effectivity.attrib =
 611   arch.attrib,
 612   condition.attrib,
 613   conformance.attrib,
 614   os.attrib,
 615   revision.attrib,
 616   security.attrib,
 617   userlevel.attrib,
 618   vendor.attrib,
 619   local.effectivity.attrib
 620 # Common attributes ....................................................
 621
 622 # Id: Unique identifier of element; no default
 623 id.attrib = attribute id { xsd:ID }?
 624 # Id: Unique identifier of element; a value must be supplied; no
 625 # default
 626 idreq.attrib = attribute id { xsd:ID }
 627 # Lang: Indicator of language in which element is written, for
 628 # translation, character set management, etc.; no default
 629 lang.attrib = attribute lang { text }?
 630 # Remap: Previous role of element before conversion; no default
 631 remap.attrib = attribute remap { text }?
 632 # Role: New role of element in local environment; no default
 633 role.attrib = attribute role { text }?
 634 # XRefLabel: Alternate labeling string for XRef text generation;
 635 # default is usually title or other appropriate label text already
 636 # contained in element
 637 xreflabel.attrib = attribute xreflabel { text }?
 638 # RevisionFlag: Revision status of element; default is that element
 639 # wasn't revised
 640 revisionflag.attrib =
 641   attribute revisionflag { "changed" | "added" | "deleted" | "off" }?
 642 local.common.attrib = empty
 643 # Role is included explicitly on each element
 644 common.attrib =
 645   id.attrib,
 646   lang.attrib,
 647   remap.attrib,
 648   xreflabel.attrib,
 649   revisionflag.attrib,
 650   effectivity.attrib,
 651   local.common.attrib
 652 # Role is included explicitly on each element
 653 idreq.common.attrib =
 654   idreq.attrib,
 655   lang.attrib,
 656   remap.attrib,
 657   xreflabel.attrib,
 658   revisionflag.attrib,
 659   effectivity.attrib,
 660   local.common.attrib
 661 # Semi-common attributes and other attribute entities ..................
 662 local.graphics.attrib = empty
 663 # EntityRef: Name of an external entity containing the content
 664 # of the graphic
 665
 666 # FileRef: Filename, qualified by a pathname if desired,
 667 # designating the file containing the content of the graphic
 668
 669 # Format: Notation of the element content, if any
 670
 671 # SrcCredit: Information about the source of the Graphic
 672
 673 # Width: Same as CALS reprowid (desired width)
 674
 675 # Depth: Same as CALS reprodep (desired depth)
 676
 677 # Align: Same as CALS hplace with 'none' removed; #IMPLIED means
 678 # application-specific
 679
 680 # Scale: Conflation of CALS hscale and vscale
 681
 682 # Scalefit: Same as CALS scalefit
 683 graphics.attrib =
 684   attribute entityref { xsd:ENTITY }?,
 685   attribute fileref { text }?,
 686   attribute format { notation.class }?,
 687   attribute srccredit { text }?,
 688   attribute width { text }?,
 689   attribute contentwidth { text }?,
 690   attribute depth { text }?,
 691   attribute contentdepth { text }?,
 692   attribute align { "left" | "right" | "center" }?,
 693   attribute valign { "top" | "middle" | "bottom" }?,
 694   attribute scale { text }?,
 695   attribute scalefit { yesorno.attvals }?,
 696   local.graphics.attrib
 697 local.keyaction.attrib = empty
 698 # Action: Key combination type; default is unspecified if one
 699 # child element, Simul if there is more than one; if value is
 700 # Other, the OtherAction attribute must have a nonempty value
 701
 702 # OtherAction: User-defined key combination type
 703 keyaction.attrib =
 704   attribute action {
 705     "click" | "double-click" | "press" | "seq" | "simul" | "other"
 706   }?,
 707   attribute otheraction { text }?,
 708   local.keyaction.attrib
 709 # Label: Identifying number or string; default is usually the
 710 # appropriate number or string autogenerated by a formatter
 711 label.attrib = attribute label { text }?
 712 # Format: whether element is assumed to contain significant white
 713 # space
 714 linespecific.attrib =
 715   [ a:defaultValue = "linespecific" ]
 716   attribute format { "linespecific" }?,
 717   attribute linenumbering { "numbered" | "unnumbered" }?
 718 # Linkend: link to related information; no default
 719 linkend.attrib = attribute linkend { xsd:IDREF }?
 720 # Linkend: required link to related information
 721 linkendreq.attrib = attribute linkend { xsd:IDREF }
 722 # Linkends: link to one or more sets of related information; no
 723 # default
 724 linkends.attrib = attribute linkends { xsd:IDREFS }?
 725 local.mark.attrib = empty
 726 mark.attrib =
 727   attribute mark { text }?,
 728   local.mark.attrib
 729 # MoreInfo: whether element's content has an associated RefEntry
 730 moreinfo.attrib =
 731   [ a:defaultValue = "none" ]
 732   attribute moreinfo { "refentry" | "none" }?
 733 # Pagenum: number of page on which element appears; no default
 734 pagenum.attrib = attribute pagenum { text }?
 735 local.status.attrib = empty
 736 # Status: Editorial or publication status of the element
 737 # it applies to, such as "in review" or "approved for distribution"
 738 status.attrib =
 739   attribute status { text }?,
 740   local.status.attrib
 741 # Width: width of the longest line in the element to which it
 742 # pertains, in number of characters
 743 width.attrib = attribute width { text }?
 744 # ......................................................................
 745
 746 # Title elements .......................................................
 747 local.title.attrib = empty
 748 title.role.attrib = role.attrib
 749 title = element title { title.attlist, title.char.mix* }
 750 # end of title.element
 751 title.attlist &=
 752   pagenum.attrib, common.attrib, title.role.attrib, local.title.attrib
 753 # end of title.attlist
 754
 755 # end of title.module
 756 local.titleabbrev.attrib = empty
 757 titleabbrev.role.attrib = role.attrib
 758 titleabbrev =
 759   element titleabbrev { titleabbrev.attlist, title.char.mix* }
 760 # end of titleabbrev.element
 761 titleabbrev.attlist &=
 762   common.attrib, titleabbrev.role.attrib, local.titleabbrev.attrib
 763 # end of titleabbrev.attlist
 764
 765 # end of titleabbrev.module
 766 local.subtitle.attrib = empty
 767 subtitle.role.attrib = role.attrib
 768 subtitle = element subtitle { subtitle.attlist, title.char.mix* }
 769 # end of subtitle.element
 770 subtitle.attlist &=
 771   common.attrib, subtitle.role.attrib, local.subtitle.attrib
 772 # end of subtitle.attlist
 773
 774 # end of subtitle.module
 775
 776 # ......................................................................
 777
 778 # Bibliographic entities and elements ..................................
 779
 780 # The bibliographic elements are typically used in the document
 781 # hierarchy. They do not appear in content models of information
 782 # pool elements.  See also the document information elements,
 783 # below.
 784 local.person.ident.mix = notAllowed
 785 person.ident.mix =
 786   honorific
 787   | firstname
 788   | surname
 789   | lineage
 790   | othername
 791   | affiliation
 792   | authorblurb
 793   | contrib
 794   | local.person.ident.mix
 795 local.bibliocomponent.mix = notAllowed
 796 bibliocomponent.mix =
 797   abbrev
 798   | abstract
 799   | address
 800   | artpagenums
 801   | author
 802   | authorgroup
 803   | authorinitials
 804   | bibliomisc
 805   | biblioset
 806   | collab
 807   | confgroup
 808   | contractnum
 809   | contractsponsor
 810   | copyright
 811   | corpauthor
 812   | corpname
 813   | date
 814   | edition
 815   | editor
 816   | invpartnumber
 817   | isbn
 818   | issn
 819   | issuenum
 820   | orgname
 821   | biblioid
 822   | citebiblioid
 823   | bibliosource
 824   | bibliorelation
 825   | bibliocoverage
 826   | othercredit
 827   | pagenums
 828   | printhistory
 829   | productname
 830   | productnumber
 831   | pubdate
 832   | publisher
 833   | publishername
 834   | pubsnumber
 835   | releaseinfo
 836   | revhistory
 837   | seriesvolnums
 838   | subtitle
 839   | title
 840   | titleabbrev
 841   | volumenum
 842   | citetitle
 843   | personname
 844   | person.ident.mix
 845   | ndxterm.class
 846   | local.bibliocomponent.mix
 847 # I don't think this is well placed, but it needs to be here because of
 848
 849 # the reference to bibliocomponent.mix
 850 local.info.class = notAllowed
 851 info.class =
 852   graphic
 853   | mediaobject
 854   | legalnotice
 855   | modespec
 856   | subjectset
 857   | keywordset
 858   | itermset
 859   | bibliocomponent.mix
 860   | local.info.class
 861 local.biblioentry.attrib = empty
 862 biblioentry.role.attrib = role.attrib
 863 biblioentry =
 864   element biblioentry {
 865     biblioentry.attlist, (articleinfo | bibliocomponent.mix)+
 866   }
 867 # end of biblioentry.element
 868 biblioentry.attlist &=
 869   common.attrib, biblioentry.role.attrib, local.biblioentry.attrib
 870 # end of biblioentry.attlist
 871
 872 # end of biblioentry.module
 873 local.bibliomixed.attrib = empty
 874 bibliomixed.role.attrib = role.attrib
 875 bibliomixed =
 876   element bibliomixed {
 877     bibliomixed.attlist, (text | bibliocomponent.mix | bibliomset)*
 878   }
 879 # end of bibliomixed.element
 880 bibliomixed.attlist &=
 881   common.attrib, bibliomixed.role.attrib, local.bibliomixed.attrib
 882 # end of bibliomixed.attlist
 883
 884 # end of bibliomixed.module
 885 local.articleinfo.attrib = empty
 886 articleinfo.role.attrib = role.attrib
 887 articleinfo = element articleinfo { articleinfo.attlist, info.class+ }
 888 # end of articleinfo.element
 889 articleinfo.attlist &=
 890   common.attrib, articleinfo.role.attrib, local.articleinfo.attrib
 891 # end of articleinfo.attlist
 892
 893 # end of articleinfo.module
 894 local.biblioset.attrib = empty
 895 biblioset.role.attrib = role.attrib
 896 biblioset =
 897   element biblioset { biblioset.attlist, bibliocomponent.mix+ }
 898 # end of biblioset.element
 899
 900 # Relation: Relationship of elements contained within BiblioSet
 901 biblioset.attlist &=
 902   attribute relation { text }?,
 903   common.attrib,
 904   biblioset.role.attrib,
 905   local.biblioset.attrib
 906 # end of biblioset.attlist
 907
 908 # end of biblioset.module
 909 bibliomset.role.attrib = role.attrib
 910 local.bibliomset.attrib = empty
 911 bibliomset =
 912   element bibliomset {
 913     bibliomset.attlist, (text | bibliocomponent.mix | bibliomset)*
 914   }
 915 # end of bibliomset.element
 916
 917 # Relation: Relationship of elements contained within BiblioMSet
 918 bibliomset.attlist &=
 919   attribute relation { text }?,
 920   common.attrib,
 921   bibliomset.role.attrib,
 922   local.bibliomset.attrib
 923 # end of bibliomset.attlist
 924
 925 # end of bibliomset.module
 926 local.bibliomisc.attrib = empty
 927 bibliomisc.role.attrib = role.attrib
 928 bibliomisc = element bibliomisc { bibliomisc.attlist, para.char.mix* }
 929 # end of bibliomisc.element
 930 bibliomisc.attlist &=
 931   common.attrib, bibliomisc.role.attrib, local.bibliomisc.attrib
 932 # end of bibliomisc.attlist
 933
 934 # end of bibliomisc.module
 935
 936 # ......................................................................
 937
 938 # Subject, Keyword, and ITermSet elements ..............................
 939 local.subjectset.attrib = empty
 940 subjectset.role.attrib = role.attrib
 941 subjectset = element subjectset { subjectset.attlist, subject+ }
 942 # end of subjectset.element
 943
 944 # Scheme: Controlled vocabulary employed in SubjectTerms
 945 subjectset.attlist &=
 946   attribute scheme { xsd:NMTOKEN }?,
 947   common.attrib,
 948   subjectset.role.attrib,
 949   local.subjectset.attrib
 950 # end of subjectset.attlist
 951
 952 # end of subjectset.module
 953 local.subject.attrib = empty
 954 subject.role.attrib = role.attrib
 955 subject = element subject { subject.attlist, subjectterm+ }
 956 # end of subject.element
 957
 958 # Weight: Ranking of this group of SubjectTerms relative
 959 # to others, 0 is low, no highest value specified
 960 subject.attlist &=
 961   attribute weight { text }?,
 962   common.attrib,
 963   subject.role.attrib,
 964   local.subject.attrib
 965 # end of subject.attlist
 966
 967 # end of subject.module
 968 local.subjectterm.attrib = empty
 969 subjectterm.role.attrib = role.attrib
 970 subjectterm = element subjectterm { subjectterm.attlist, text }
 971 # end of subjectterm.element
 972 subjectterm.attlist &=
 973   common.attrib, subjectterm.role.attrib, local.subjectterm.attrib
 974 # end of subjectterm.attlist
 975
 976 # end of subjectterm.module
 977
 978 # end of subjectset.content.module
 979 local.keywordset.attrib = empty
 980 keywordset.role.attrib = role.attrib
 981 keywordset = element keywordset { keywordset.attlist, keyword+ }
 982 # end of keywordset.element
 983 keywordset.attlist &=
 984   common.attrib, keywordset.role.attrib, local.keywordset.attrib
 985 # end of keywordset.attlist
 986
 987 # end of keywordset.module
 988 local.keyword.attrib = empty
 989 keyword.role.attrib = role.attrib
 990 keyword = element keyword { keyword.attlist, text }
 991 # end of keyword.element
 992 keyword.attlist &=
 993   common.attrib, keyword.role.attrib, local.keyword.attrib
 994 # end of keyword.attlist
 995
 996 # end of keyword.module
 997
 998 # end of keywordset.content.module
 999 local.itermset.attrib = empty
1000 itermset.role.attrib = role.attrib
1001 itermset = element itermset { itermset.attlist, indexterm+ }
1002 # end of itermset.element
1003 itermset.attlist &=
1004   common.attrib, itermset.role.attrib, local.itermset.attrib
1005 # end of itermset.attlist
1006
1007 # end of itermset.module
1008
1009 # Bibliographic info for "blocks"
1010 local.blockinfo.attrib = empty
1011 blockinfo.role.attrib = role.attrib
1012 blockinfo = element blockinfo { blockinfo.attlist, info.class+ }
1013 # end of blockinfo.element
1014 blockinfo.attlist &=
1015   common.attrib, blockinfo.role.attrib, local.blockinfo.attrib
1016 # end of blockinfo.attlist
1017
1018 # end of blockinfo.module
1019
1020 # ......................................................................
1021
1022 # Compound (section-ish) elements ......................................
1023
1024 # Message set ......................
1025 local.msgset.attrib = empty
1026 msgset.role.attrib = role.attrib
1027 msgset =
1028   element msgset {
1029     msgset.attlist,
1030     blockinfo?,
1031     formalobject.title.content?,
1032     (msgentry+ | simplemsgentry+)
1033   }
1034 # end of msgset.element
1035 msgset.attlist &= common.attrib, msgset.role.attrib, local.msgset.attrib
1036 # end of msgset.attlist
1037
1038 # end of msgset.module
1039 local.msgentry.attrib = empty
1040 msgentry.role.attrib = role.attrib
1041 msgentry =
1042   element msgentry { msgentry.attlist, msg+, msginfo?, msgexplan* }
1043 # end of msgentry.element
1044 msgentry.attlist &=
1045   common.attrib, msgentry.role.attrib, local.msgentry.attrib
1046 # end of msgentry.attlist
1047
1048 # end of msgentry.module
1049 local.simplemsgentry.attrib = empty
1050 simplemsgentry.role.attrib = role.attrib
1051 simplemsgentry =
1052   element simplemsgentry { simplemsgentry.attlist, msgtext, msgexplan+ }
1053 # end of simplemsgentry.element
1054 simplemsgentry.attlist &=
1055   attribute audience { text }?,
1056   attribute level { text }?,
1057   attribute origin { text }?,
1058   common.attrib,
1059   simplemsgentry.role.attrib,
1060   local.simplemsgentry.attrib
1061 # end of simplemsgentry.attlist
1062
1063 # end of simplemsgentry.module
1064 local.msg.attrib = empty
1065 msg.role.attrib = role.attrib
1066 msg = element msg { msg.attlist, title?, msgmain, (msgsub | msgrel)* }
1067 # end of msg.element
1068 msg.attlist &= common.attrib, msg.role.attrib, local.msg.attrib
1069 # end of msg.attlist
1070
1071 # end of msg.module
1072 local.msgmain.attrib = empty
1073 msgmain.role.attrib = role.attrib
1074 msgmain = element msgmain { msgmain.attlist, title?, msgtext }
1075 # end of msgmain.element
1076 msgmain.attlist &=
1077   common.attrib, msgmain.role.attrib, local.msgmain.attrib
1078 # end of msgmain.attlist
1079
1080 # end of msgmain.module
1081 local.msgsub.attrib = empty
1082 msgsub.role.attrib = role.attrib
1083 msgsub = element msgsub { msgsub.attlist, title?, msgtext }
1084 # end of msgsub.element
1085 msgsub.attlist &= common.attrib, msgsub.role.attrib, local.msgsub.attrib
1086 # end of msgsub.attlist
1087
1088 # end of msgsub.module
1089 local.msgrel.attrib = empty
1090 msgrel.role.attrib = role.attrib
1091 msgrel = element msgrel { msgrel.attlist, title?, msgtext }
1092 # end of msgrel.element
1093 msgrel.attlist &= common.attrib, msgrel.role.attrib, local.msgrel.attrib
1094 # end of msgrel.attlist
1095
1096 # end of msgrel.module
1097
1098 #  MsgText (defined in the Inlines section, below)
1099 local.msginfo.attrib = empty
1100 msginfo.role.attrib = role.attrib
1101 msginfo =
1102   element msginfo { msginfo.attlist, (msglevel | msgorig | msgaud)* }
1103 # end of msginfo.element
1104 msginfo.attlist &=
1105   common.attrib, msginfo.role.attrib, local.msginfo.attrib
1106 # end of msginfo.attlist
1107
1108 # end of msginfo.module
1109 local.msglevel.attrib = empty
1110 msglevel.role.attrib = role.attrib
1111 msglevel = element msglevel { msglevel.attlist, smallcptr.char.mix* }
1112 # end of msglevel.element
1113 msglevel.attlist &=
1114   common.attrib, msglevel.role.attrib, local.msglevel.attrib
1115 # end of msglevel.attlist
1116
1117 # end of msglevel.module
1118 local.msgorig.attrib = empty
1119 msgorig.role.attrib = role.attrib
1120 msgorig = element msgorig { msgorig.attlist, smallcptr.char.mix* }
1121 # end of msgorig.element
1122 msgorig.attlist &=
1123   common.attrib, msgorig.role.attrib, local.msgorig.attrib
1124 # end of msgorig.attlist
1125
1126 # end of msgorig.module
1127 local.msgaud.attrib = empty
1128 msgaud.role.attrib = role.attrib
1129 msgaud = element msgaud { msgaud.attlist, para.char.mix* }
1130 # end of msgaud.element
1131 msgaud.attlist &= common.attrib, msgaud.role.attrib, local.msgaud.attrib
1132 # end of msgaud.attlist
1133
1134 # end of msgaud.module
1135 local.msgexplan.attrib = empty
1136 msgexplan.role.attrib = role.attrib
1137 msgexplan =
1138   element msgexplan { msgexplan.attlist, title?, component.mix+ }
1139 # end of msgexplan.element
1140 msgexplan.attlist &=
1141   common.attrib, msgexplan.role.attrib, local.msgexplan.attrib
1142 # end of msgexplan.attlist
1143
1144 # end of msgexplan.module
1145
1146 # end of msgset.content.module
1147
1148 # QandASet ........................
1149 local.qandaset.attrib = empty
1150 qandaset.role.attrib = role.attrib
1151 qandaset =
1152   element qandaset {
1153     qandaset.attlist,
1154     blockinfo?,
1155     formalobject.title.content?,
1156     qandaset.mix*,
1157     (qandadiv+ | qandaentry+)
1158   }
1159 # end of qandaset.element
1160 qandaset.attlist &=
1161   attribute defaultlabel { "qanda" | "number" | "none" }?,
1162   common.attrib,
1163   qandaset.role.attrib,
1164   local.qandaset.attrib
1165 # end of qandaset.attlist
1166
1167 # end of qandaset.module
1168 local.qandadiv.attrib = empty
1169 qandadiv.role.attrib = role.attrib
1170 qandadiv =
1171   element qandadiv {
1172     qandadiv.attlist,
1173     blockinfo?,
1174     formalobject.title.content?,
1175     qandaset.mix*,
1176     (qandadiv+ | qandaentry+)
1177   }
1178 # end of qandadiv.element
1179 qandadiv.attlist &=
1180   common.attrib, qandadiv.role.attrib, local.qandadiv.attrib
1181 # end of qandadiv.attlist
1182
1183 # end of qandadiv.module
1184 local.qandaentry.attrib = empty
1185 qandaentry.role.attrib = role.attrib
1186 qandaentry =
1187   element qandaentry {
1188     qandaentry.attlist, blockinfo?, revhistory?, question, answer*
1189   }
1190 # end of qandaentry.element
1191 qandaentry.attlist &=
1192   common.attrib, qandaentry.role.attrib, local.qandaentry.attrib
1193 # end of qandaentry.attlist
1194
1195 # end of qandaentry.module
1196 local.question.attrib = empty
1197 question.role.attrib = role.attrib
1198 question = element question { question.attlist, label?, qandaset.mix+ }
1199 # end of question.element
1200 question.attlist &=
1201   common.attrib, question.role.attrib, local.question.attrib
1202 # end of question.attlist
1203
1204 # end of question.module
1205 local.answer.attrib = empty
1206 answer.role.attrib = role.attrib
1207 answer =
1208   element answer { answer.attlist, label?, qandaset.mix*, qandaentry* }
1209 # end of answer.element
1210 answer.attlist &= common.attrib, answer.role.attrib, local.answer.attrib
1211 # end of answer.attlist
1212
1213 # end of answer.module
1214 local.label.attrib = empty
1215 label.role.attrib = role.attrib
1216 label = element label { label.attlist, word.char.mix* }
1217 # end of label.element
1218 label.attlist &= common.attrib, label.role.attrib, local.label.attrib
1219 # end of label.attlist
1220
1221 # end of label.module
1222
1223 # end of qandaset.content.module
1224
1225 # Procedure ........................
1226 local.procedure.attrib = empty
1227 procedure.role.attrib = role.attrib
1228 procedure =
1229   element procedure {
1230     procedure.attlist,
1231     blockinfo?,
1232     formalobject.title.content?,
1233     component.mix*,
1234     step+
1235   }
1236 # end of procedure.element
1237 procedure.attlist &=
1238   common.attrib, procedure.role.attrib, local.procedure.attrib
1239 # end of procedure.attlist
1240
1241 # end of procedure.module
1242 local.step.attrib = empty
1243 step.role.attrib = role.attrib
1244 step =
1245   element step {
1246     step.attlist,
1247     title?,
1248     ((component.mix+, (substeps, component.mix*)?)
1249      | (substeps, component.mix*))
1250   }
1251 # end of step.element
1252
1253 # Performance: Whether the Step must be performed
1254
1255 # not #REQUIRED!
1256 step.attlist &=
1257   [ a:defaultValue = "required" ]
1258   attribute performance { "optional" | "required" }?,
1259   common.attrib,
1260   step.role.attrib,
1261   local.step.attrib
1262 # end of step.attlist
1263
1264 # end of step.module
1265 local.substeps.attrib = empty
1266 substeps.role.attrib = role.attrib
1267 substeps = element substeps { substeps.attlist, step+ }
1268 # end of substeps.element
1269
1270 # Performance: whether entire set of substeps must be performed
1271
1272 # not #REQUIRED!
1273 substeps.attlist &=
1274   [ a:defaultValue = "required" ]
1275   attribute performance { "optional" | "required" }?,
1276   common.attrib,
1277   substeps.role.attrib,
1278   local.substeps.attrib
1279 # end of substeps.attlist
1280
1281 # end of substeps.module
1282
1283 # end of procedure.content.module
1284
1285 # Sidebar ..........................
1286 local.sidebarinfo.attrib = empty
1287 sidebarinfo.role.attrib = role.attrib
1288 sidebarinfo = element sidebarinfo { sidebarinfo.attlist, info.class+ }
1289 # end of sidebarinfo.element
1290 sidebarinfo.attlist &=
1291   common.attrib, sidebarinfo.role.attrib, local.sidebarinfo.attrib
1292 # end of sidebarinfo.attlist
1293
1294 # end of sidebarinfo.module
1295 local.sidebar.attrib = empty
1296 sidebar.role.attrib = role.attrib
1297 sidebar =
1298   element sidebar {
1299     sidebar.attlist,
1300     sidebarinfo?,
1301     formalobject.title.content?,
1302     sidebar.mix+
1303   }
1304 # end of sidebar.element
1305 sidebar.attlist &=
1306   common.attrib, sidebar.role.attrib, local.sidebar.attrib
1307 # end of sidebar.attlist
1308
1309 # end of sidebar.module
1310
1311 # end of sidebar.content.model
1312
1313 # ......................................................................
1314
1315 # Paragraph-related elements ...........................................
1316 local.abstract.attrib = empty
1317 abstract.role.attrib = role.attrib
1318 abstract = element abstract { abstract.attlist, title?, para.class+ }
1319 # end of abstract.element
1320 abstract.attlist &=
1321   common.attrib, abstract.role.attrib, local.abstract.attrib
1322 # end of abstract.attlist
1323
1324 # end of abstract.module
1325 local.authorblurb.attrib = empty
1326 authorblurb.role.attrib = role.attrib
1327 authorblurb =
1328   element authorblurb { authorblurb.attlist, title?, para.class+ }
1329 # end of authorblurb.element
1330 authorblurb.attlist &=
1331   common.attrib, authorblurb.role.attrib, local.authorblurb.attrib
1332 # end of authorblurb.attlist
1333
1334 # end of authorblurb.module
1335 local.personblurb.attrib = empty
1336 personblurb.role.attrib = role.attrib
1337 personblurb =
1338   element personblurb { personblurb.attlist, title?, para.class+ }
1339 # end of personblurb.element
1340 personblurb.attlist &=
1341   common.attrib, personblurb.role.attrib, local.personblurb.attrib
1342 # end of personblurb.attlist
1343
1344 # end of personblurb.module
1345 local.blockquote.attrib = empty
1346 blockquote.role.attrib = role.attrib
1347 blockquote =
1348   element blockquote {
1349     blockquote.attlist, title?, attribution?, component.mix+
1350   }
1351 # end of blockquote.element
1352 blockquote.attlist &=
1353   common.attrib, blockquote.role.attrib, local.blockquote.attrib
1354 # end of blockquote.attlist
1355
1356 # end of blockquote.module
1357 local.attribution.attrib = empty
1358 attribution.role.attrib = role.attrib
1359 attribution =
1360   element attribution { attribution.attlist, para.char.mix* }
1361 # end of attribution.element
1362 attribution.attlist &=
1363   common.attrib, attribution.role.attrib, local.attribution.attrib
1364 # end of attribution.attlist
1365
1366 # end of attribution.module
1367 local.bridgehead.attrib = empty
1368 bridgehead.role.attrib = role.attrib
1369 bridgehead = element bridgehead { bridgehead.attlist, title.char.mix* }
1370 # end of bridgehead.element
1371
1372 # Renderas: Indicates the format in which the BridgeHead
1373 # should appear
1374 bridgehead.attlist &=
1375   attribute renderas {
1376     "other" | "sect1" | "sect2" | "sect3" | "sect4" | "sect5"
1377   }?,
1378   common.attrib,
1379   bridgehead.role.attrib,
1380   local.bridgehead.attrib
1381 # end of bridgehead.attlist
1382
1383 # end of bridgehead.module
1384 local.remark.attrib = empty
1385 remark.role.attrib = role.attrib
1386 remark = element remark { remark.attlist, para.char.mix* }
1387 # end of remark.element
1388 remark.attlist &= common.attrib, remark.role.attrib, local.remark.attrib
1389 # end of remark.attlist
1390
1391 # end of remark.module
1392 local.epigraph.attrib = empty
1393 epigraph.role.attrib = role.attrib
1394 epigraph =
1395   element epigraph {
1396     epigraph.attlist, attribution?, (para.class | literallayout)+
1397   }
1398 # end of epigraph.element
1399 epigraph.attlist &=
1400   common.attrib, epigraph.role.attrib, local.epigraph.attrib
1401 # end of epigraph.attlist
1402
1403 #  Attribution (defined above)
1404
1405 # end of epigraph.module
1406 local.footnote.attrib = empty
1407 footnote.role.attrib = role.attrib
1408 footnote = element footnote { footnote.attlist, footnote.mix+ }
1409 # end of footnote.element
1410 footnote.attlist &=
1411   label.attrib,
1412   common.attrib,
1413   footnote.role.attrib,
1414   local.footnote.attrib
1415 # end of footnote.attlist
1416
1417 # end of footnote.module
1418 local.highlights.attrib = empty
1419 highlights.role.attrib = role.attrib
1420 highlights = element highlights { highlights.attlist, highlights.mix+ }
1421 # end of highlights.element
1422 highlights.attlist &=
1423   common.attrib, highlights.role.attrib, local.highlights.attrib
1424 # end of highlights.attlist
1425
1426 # end of highlights.module
1427 local.formalpara.attrib = empty
1428 formalpara.role.attrib = role.attrib
1429 formalpara =
1430   element formalpara { formalpara.attlist, title, ndxterm.class*, para }
1431 # end of formalpara.element
1432 formalpara.attlist &=
1433   common.attrib, formalpara.role.attrib, local.formalpara.attrib
1434 # end of formalpara.attlist
1435
1436 # end of formalpara.module
1437 local.para.attrib = empty
1438 para.role.attrib = role.attrib
1439 para = element para { para.attlist, (para.char.mix | para.mix)* }
1440 # end of para.element
1441 para.attlist &= common.attrib, para.role.attrib, local.para.attrib
1442 # end of para.attlist
1443
1444 # end of para.module
1445 local.simpara.attrib = empty
1446 simpara.role.attrib = role.attrib
1447 simpara = element simpara { simpara.attlist, para.char.mix* }
1448 # end of simpara.element
1449 simpara.attlist &=
1450   common.attrib, simpara.role.attrib, local.simpara.attrib
1451 # end of simpara.attlist
1452
1453 # end of simpara.module
1454 local.admon.attrib = empty
1455 admon.role.attrib = role.attrib
1456 caution = element caution { caution.attlist, title?, admon.mix+ }
1457 # end of caution.element
1458 caution.attlist &= common.attrib, admon.role.attrib, local.admon.attrib
1459 # end of caution.attlist
1460 important = element important { important.attlist, title?, admon.mix+ }
1461 # end of important.element
1462 important.attlist &=
1463   common.attrib, admon.role.attrib, local.admon.attrib
1464 # end of important.attlist
1465 note = element note { note.attlist, title?, admon.mix+ }
1466 # end of note.element
1467 note.attlist &= common.attrib, admon.role.attrib, local.admon.attrib
1468 # end of note.attlist
1469 tip = element tip { tip.attlist, title?, admon.mix+ }
1470 # end of tip.element
1471 tip.attlist &= common.attrib, admon.role.attrib, local.admon.attrib
1472 # end of tip.attlist
1473 warning = element warning { warning.attlist, title?, admon.mix+ }
1474 # end of warning.element
1475 warning.attlist &= common.attrib, admon.role.attrib, local.admon.attrib
1476 # end of warning.attlist
1477
1478 # end of admon.module
1479
1480 # ......................................................................
1481
1482 # Lists ................................................................
1483
1484 # GlossList ........................
1485 local.glosslist.attrib = empty
1486 glosslist.role.attrib = role.attrib
1487 glosslist = element glosslist { glosslist.attlist, glossentry+ }
1488 # end of glosslist.element
1489 glosslist.attlist &=
1490   common.attrib, glosslist.role.attrib, local.glosslist.attrib
1491 # end of glosslist.attlist
1492
1493 # end of glosslist.module
1494 local.glossentry.attrib = empty
1495 glossentry.role.attrib = role.attrib
1496 glossentry =
1497   element glossentry {
1498     glossentry.attlist,
1499     glossterm,
1500     acronym?,
1501     abbrev?,
1502     ndxterm.class*,
1503     revhistory?,
1504     (glosssee | glossdef+)
1505   }
1506 # end of glossentry.element
1507
1508 # SortAs: String by which the GlossEntry is to be sorted
1509 # (alphabetized) in lieu of its proper content
1510 glossentry.attlist &=
1511   attribute sortas { text }?,
1512   common.attrib,
1513   glossentry.role.attrib,
1514   local.glossentry.attrib
1515 # end of glossentry.attlist
1516
1517 # end of glossentry.module
1518
1519 #  GlossTerm (defined in the Inlines section, below)
1520 local.glossdef.attrib = empty
1521 glossdef.role.attrib = role.attrib
1522 glossdef =
1523   element glossdef { glossdef.attlist, glossdef.mix+, glossseealso* }
1524 # end of glossdef.element
1525
1526 # Subject: List of subjects; keywords for the definition
1527 glossdef.attlist &=
1528   attribute subject { text }?,
1529   common.attrib,
1530   glossdef.role.attrib,
1531   local.glossdef.attrib
1532 # end of glossdef.attlist
1533
1534 # end of glossdef.module
1535 local.glosssee.attrib = empty
1536 glosssee.role.attrib = role.attrib
1537 glosssee = element glosssee { glosssee.attlist, para.char.mix* }
1538 # end of glosssee.element
1539
1540 # OtherTerm: Reference to the GlossEntry whose GlossTerm
1541 # should be displayed at the point of the GlossSee
1542 glosssee.attlist &=
1543   attribute otherterm { xsd:IDREF }?,
1544   common.attrib,
1545   glosssee.role.attrib,
1546   local.glosssee.attrib
1547 # end of glosssee.attlist
1548
1549 # end of glosssee.module
1550 local.glossseealso.attrib = empty
1551 glossseealso.role.attrib = role.attrib
1552 glossseealso =
1553   element glossseealso { glossseealso.attlist, para.char.mix* }
1554 # end of glossseealso.element
1555
1556 # OtherTerm: Reference to the GlossEntry whose GlossTerm
1557 # should be displayed at the point of the GlossSeeAlso
1558 glossseealso.attlist &=
1559   attribute otherterm { xsd:IDREF }?,
1560   common.attrib,
1561   glossseealso.role.attrib,
1562   local.glossseealso.attrib
1563 # end of glossseealso.attlist
1564
1565 # end of glossseealso.module
1566
1567 # end of glossentry.content.module
1568
1569 # ItemizedList and OrderedList .....
1570 local.itemizedlist.attrib = empty
1571 itemizedlist.role.attrib = role.attrib
1572 itemizedlist =
1573   element itemizedlist {
1574     itemizedlist.attlist,
1575     blockinfo?,
1576     formalobject.title.content?,
1577     listpreamble.mix*,
1578     listitem+
1579   }
1580 # end of itemizedlist.element
1581
1582 # Spacing: Whether the vertical space in the list should be
1583 # compressed
1584
1585 # Mark: Keyword, e.g., bullet, dash, checkbox, none;
1586 # list of keywords and defaults are implementation specific
1587 itemizedlist.attlist &=
1588   attribute spacing { "normal" | "compact" }?,
1589   mark.attrib,
1590   common.attrib,
1591   itemizedlist.role.attrib,
1592   local.itemizedlist.attrib
1593 # end of itemizedlist.attlist
1594
1595 # end of itemizedlist.module
1596 local.orderedlist.attrib = empty
1597 orderedlist.role.attrib = role.attrib
1598 orderedlist =
1599   element orderedlist {
1600     orderedlist.attlist,
1601     blockinfo?,
1602     formalobject.title.content?,
1603     listpreamble.mix*,
1604     listitem+
1605   }
1606 # end of orderedlist.element
1607
1608 # Numeration: Style of ListItem numbered; default is expected
1609 # to be Arabic
1610
1611 # InheritNum: Specifies for a nested list that the numbering
1612 # of ListItems should include the number of the item
1613 # within which they are nested (e.g., 1a and 1b within 1,
1614 # rather than a and b)
1615
1616 # Continuation: Where list numbering begins afresh (Restarts,
1617 # the default) or continues that of the immediately preceding
1618 # list (Continues)
1619
1620 # Spacing: Whether the vertical space in the list should be
1621 # compressed
1622 orderedlist.attlist &=
1623   attribute numeration {
1624     "arabic" | "upperalpha" | "loweralpha" | "upperroman" | "lowerroman"
1625   }?,
1626   [ a:defaultValue = "ignore" ]
1627   attribute inheritnum { "inherit" | "ignore" }?,
1628   [ a:defaultValue = "restarts" ]
1629   attribute continuation { "continues" | "restarts" }?,
1630   attribute spacing { "normal" | "compact" }?,
1631   common.attrib,
1632   orderedlist.role.attrib,
1633   local.orderedlist.attrib
1634 # end of orderedlist.attlist
1635
1636 # end of orderedlist.module
1637 local.listitem.attrib = empty
1638 listitem.role.attrib = role.attrib
1639 listitem = element listitem { listitem.attlist, component.mix+ }
1640 # end of listitem.element
1641
1642 # Override: Indicates the mark to be used for this ListItem
1643 # instead of the default mark or the mark specified by
1644 # the Mark attribute on the enclosing ItemizedList
1645 listitem.attlist &=
1646   attribute override { text }?,
1647   common.attrib,
1648   listitem.role.attrib,
1649   local.listitem.attrib
1650 # end of listitem.attlist
1651
1652 # end of listitem.module
1653
1654 # SegmentedList ....................
1655 local.segmentedlist.attrib = empty
1656 segmentedlist.role.attrib = role.attrib
1657 segmentedlist =
1658   element segmentedlist {
1659     segmentedlist.attlist,
1660     formalobject.title.content?,
1661     segtitle+,
1662     seglistitem+
1663   }
1664 # end of segmentedlist.element
1665 segmentedlist.attlist &=
1666   common.attrib, segmentedlist.role.attrib, local.segmentedlist.attrib
1667 # end of segmentedlist.attlist
1668
1669 # end of segmentedlist.module
1670 local.segtitle.attrib = empty
1671 segtitle.role.attrib = role.attrib
1672 segtitle = element segtitle { segtitle.attlist, title.char.mix* }
1673 # end of segtitle.element
1674 segtitle.attlist &=
1675   common.attrib, segtitle.role.attrib, local.segtitle.attrib
1676 # end of segtitle.attlist
1677
1678 # end of segtitle.module
1679 local.seglistitem.attrib = empty
1680 seglistitem.role.attrib = role.attrib
1681 seglistitem = element seglistitem { seglistitem.attlist, seg+ }
1682 # end of seglistitem.element
1683 seglistitem.attlist &=
1684   common.attrib, seglistitem.role.attrib, local.seglistitem.attrib
1685 # end of seglistitem.attlist
1686
1687 # end of seglistitem.module
1688 local.seg.attrib = empty
1689 seg.role.attrib = role.attrib
1690 seg = element seg { seg.attlist, para.char.mix* }
1691 # end of seg.element
1692 seg.attlist &= common.attrib, seg.role.attrib, local.seg.attrib
1693 # end of seg.attlist
1694
1695 # end of seg.module
1696
1697 # end of segmentedlist.content.module
1698
1699 # SimpleList .......................
1700 local.simplelist.attrib = empty
1701 simplelist.role.attrib = role.attrib
1702 simplelist = element simplelist { simplelist.attlist, member+ }
1703 # end of simplelist.element
1704
1705 # Columns: The number of columns the array should contain
1706
1707 # Type: How the Members of the SimpleList should be
1708 # formatted: Inline (members separated with commas etc.
1709 # inline), Vert (top to bottom in n Columns), or Horiz (in
1710 # the direction of text flow) in n Columns.  If Column
1711 # is 1 or implied, Type=Vert and Type=Horiz give the same
1712 # results.
1713 simplelist.attlist &=
1714   attribute columns { text }?,
1715   [ a:defaultValue = "vert" ]
1716   attribute type { "inline" | "vert" | "horiz" }?,
1717   common.attrib,
1718   simplelist.role.attrib,
1719   local.simplelist.attrib
1720 # end of simplelist.attlist
1721
1722 # end of simplelist.module
1723 local.member.attrib = empty
1724 member.role.attrib = role.attrib
1725 member = element member { member.attlist, para.char.mix* }
1726 # end of member.element
1727 member.attlist &= common.attrib, member.role.attrib, local.member.attrib
1728 # end of member.attlist
1729
1730 # end of member.module
1731
1732 # end of simplelist.content.module
1733
1734 # VariableList .....................
1735 local.variablelist.attrib = empty
1736 variablelist.role.attrib = role.attrib
1737 variablelist =
1738   element variablelist {
1739     variablelist.attlist,
1740     blockinfo?,
1741     formalobject.title.content?,
1742     listpreamble.mix*,
1743     varlistentry+
1744   }
1745 # end of variablelist.element
1746
1747 # TermLength: Length beyond which the presentation engine
1748 # may consider the Term too long and select an alternate
1749 # presentation of the Term and, or, its associated ListItem.
1750 variablelist.attlist &=
1751   attribute termlength { text }?,
1752   common.attrib,
1753   variablelist.role.attrib,
1754   local.variablelist.attrib
1755 # end of variablelist.attlist
1756
1757 # end of variablelist.module
1758 local.varlistentry.attrib = empty
1759 varlistentry.role.attrib = role.attrib
1760 varlistentry =
1761   element varlistentry { varlistentry.attlist, term+, listitem }
1762 # end of varlistentry.element
1763 varlistentry.attlist &=
1764   common.attrib, varlistentry.role.attrib, local.varlistentry.attrib
1765 # end of varlistentry.attlist
1766
1767 # end of varlistentry.module
1768 local.term.attrib = empty
1769 term.role.attrib = role.attrib
1770 term = element term { term.attlist, para.char.mix* }
1771 # end of term.element
1772 term.attlist &= common.attrib, term.role.attrib, local.term.attrib
1773 # end of term.attlist
1774
1775 # end of term.module
1776
1777 #  ListItem (defined above)
1778
1779 # end of variablelist.content.module
1780
1781 # CalloutList ......................
1782 local.calloutlist.attrib = empty
1783 calloutlist.role.attrib = role.attrib
1784 calloutlist =
1785   element calloutlist {
1786     calloutlist.attlist, formalobject.title.content?, callout+
1787   }
1788 # end of calloutlist.element
1789 calloutlist.attlist &=
1790   common.attrib, calloutlist.role.attrib, local.calloutlist.attrib
1791 # end of calloutlist.attlist
1792
1793 # end of calloutlist.module
1794 local.callout.attrib = empty
1795 callout.role.attrib = role.attrib
1796 callout = element callout { callout.attlist, component.mix+ }
1797 # end of callout.element
1798
1799 # AreaRefs: IDs of one or more Areas or AreaSets described
1800 # by this Callout
1801 callout.attlist &=
1802   attribute arearefs { xsd:IDREFS },
1803   common.attrib,
1804   callout.role.attrib,
1805   local.callout.attrib
1806 # end of callout.attlist
1807
1808 # end of callout.module
1809
1810 # end of calloutlist.content.module
1811
1812 # ......................................................................
1813
1814 # Objects ..............................................................
1815
1816 # Examples etc. ....................
1817 local.example.attrib = empty
1818 example.role.attrib = role.attrib
1819 example =
1820   element example {
1821     example.attlist,
1822     blockinfo?,
1823     formalobject.title.content,
1824     example.mix+
1825   }
1826 # end of example.element
1827 example.attlist &=
1828   label.attrib,
1829   width.attrib,
1830   common.attrib,
1831   example.role.attrib,
1832   local.example.attrib
1833 # end of example.attlist
1834
1835 # end of example.module
1836 local.informalexample.attrib = empty
1837 informalexample.role.attrib = role.attrib
1838 informalexample =
1839   element informalexample {
1840     informalexample.attlist, blockinfo?, example.mix+
1841   }
1842 # end of informalexample.element
1843 informalexample.attlist &=
1844   width.attrib,
1845   common.attrib,
1846   informalexample.role.attrib,
1847   local.informalexample.attrib
1848 # end of informalexample.attlist
1849
1850 # end of informalexample.module
1851 local.programlistingco.attrib = empty
1852 programlistingco.role.attrib = role.attrib
1853 programlistingco =
1854   element programlistingco {
1855     programlistingco.attlist, areaspec, programlisting, calloutlist*
1856   }
1857 # end of programlistingco.element
1858 programlistingco.attlist &=
1859   common.attrib,
1860   programlistingco.role.attrib,
1861   local.programlistingco.attrib
1862 # end of programlistingco.attlist
1863
1864 #  CalloutList (defined above in Lists)
1865
1866 # end of informalexample.module
1867 local.areaspec.attrib = empty
1868 areaspec.role.attrib = role.attrib
1869 areaspec = element areaspec { areaspec.attlist, (area | areaset)+ }
1870 # end of areaspec.element
1871
1872 # Units: global unit of measure in which coordinates in
1873 # this spec are expressed:
1874 #
1875 # - CALSPair "x1,y1 x2,y2": lower-left and upper-right
1876 # coordinates in a rectangle describing repro area in which
1877 # graphic is placed, where X and Y dimensions are each some
1878 # number 0..10000 (taken from CALS graphic attributes)
1879 #
1880 # - LineColumn "line column": line number and column number
1881 # at which to start callout text in "linespecific" content
1882 #
1883 # - LineRange "startline endline": whole lines from startline
1884 # to endline in "linespecific" content
1885 #
1886 # - LineColumnPair "line1 col1 line2 col2": starting and ending
1887 # points of area in "linespecific" content that starts at
1888 # first position and ends at second position (including the
1889 # beginnings of any intervening lines)
1890 #
1891 # - Other: directive to look at value of OtherUnits attribute
1892 # to get implementation-specific keyword
1893 #
1894 # The default is implementation-specific; usually dependent on
1895 # the parent element (GraphicCO gets CALSPair, ProgramListingCO
1896 # and ScreenCO get LineColumn)
1897
1898 # OtherUnits: User-defined units
1899 areaspec.attlist &=
1900   attribute units {
1901     "calspair" | "linecolumn" | "linerange" | "linecolumnpair" | "other"
1902   }?,
1903   attribute otherunits { xsd:NMTOKEN }?,
1904   common.attrib,
1905   areaspec.role.attrib,
1906   local.areaspec.attrib
1907 # end of areaspec.attlist
1908
1909 # end of areaspec.module
1910 local.area.attrib = empty
1911 area.role.attrib = role.attrib
1912 area = element area { area.attlist, empty }
1913 # end of area.element
1914
1915 # bug number/symbol override or initialization
1916
1917 # to any related information
1918
1919 # Units: unit of measure in which coordinates in this
1920 # area are expressed; inherits from AreaSet and AreaSpec
1921
1922 # OtherUnits: User-defined units
1923 area.attlist &=
1924   label.attrib,
1925   linkends.attrib,
1926   attribute units {
1927     "calspair" | "linecolumn" | "linerange" | "linecolumnpair" | "other"
1928   }?,
1929   attribute otherunits { xsd:NMTOKEN }?,
1930   attribute coords { text },
1931   idreq.common.attrib,
1932   area.role.attrib,
1933   local.area.attrib
1934 # end of area.attlist
1935
1936 # end of area.module
1937 local.areaset.attrib = empty
1938 areaset.role.attrib = role.attrib
1939 areaset = element areaset { areaset.attlist, area+ }
1940 # end of areaset.element
1941
1942 # bug number/symbol override or initialization
1943
1944 # Units: unit of measure in which coordinates in this
1945 # area are expressed; inherits from AreaSpec
1946 areaset.attlist &=
1947   label.attrib,
1948   attribute units {
1949     "calspair" | "linecolumn" | "linerange" | "linecolumnpair" | "other"
1950   }?,
1951   attribute otherunits { xsd:NMTOKEN }?,
1952   attribute coords { text },
1953   idreq.common.attrib,
1954   areaset.role.attrib,
1955   local.areaset.attrib
1956 # end of areaset.attlist
1957
1958 # end of areaset.module
1959
1960 # end of areaspec.content.module
1961 local.programlisting.attrib = empty
1962 programlisting.role.attrib = role.attrib
1963 programlisting =
1964   element programlisting {
1965     programlisting.attlist,
1966     (para.char.mix | co | coref | lineannotation | textobject)*
1967   }
1968 # end of programlisting.element
1969 programlisting.attlist &=
1970   width.attrib,
1971   linespecific.attrib,
1972   common.attrib,
1973   programlisting.role.attrib,
1974   local.programlisting.attrib
1975 # end of programlisting.attlist
1976
1977 # end of programlisting.module
1978 local.literallayout.attrib = empty
1979 literallayout.role.attrib = role.attrib
1980 literallayout =
1981   element literallayout {
1982     literallayout.attlist,
1983     (para.char.mix | co | coref | textobject | lineannotation)*
1984   }
1985 # end of literallayout.element
1986 literallayout.attlist &=
1987   width.attrib,
1988   linespecific.attrib,
1989   [ a:defaultValue = "normal" ]
1990   attribute class { "monospaced" | "normal" }?,
1991   common.attrib,
1992   literallayout.role.attrib,
1993   local.literallayout.attrib
1994 # end of literallayout.attlist
1995
1996 #  LineAnnotation (defined in the Inlines section, below)
1997
1998 # end of literallayout.module
1999 local.screenco.attrib = empty
2000 screenco.role.attrib = role.attrib
2001 screenco =
2002   element screenco { screenco.attlist, areaspec, screen, calloutlist* }
2003 # end of screenco.element
2004 screenco.attlist &=
2005   common.attrib, screenco.role.attrib, local.screenco.attrib
2006 # end of screenco.attlist
2007
2008 #  AreaSpec (defined above)
2009
2010 #  CalloutList (defined above in Lists)
2011
2012 # end of screenco.module
2013 local.screen.attrib = empty
2014 screen.role.attrib = role.attrib
2015 screen =
2016   element screen {
2017     screen.attlist,
2018     (para.char.mix | co | coref | textobject | lineannotation)*
2019   }
2020 # end of screen.element
2021 screen.attlist &=
2022   width.attrib,
2023   linespecific.attrib,
2024   common.attrib,
2025   screen.role.attrib,
2026   local.screen.attrib
2027 # end of screen.attlist
2028
2029 # end of screen.module
2030 local.screenshot.attrib = empty
2031 screenshot.role.attrib = role.attrib
2032 screenshot =
2033   element screenshot {
2034     screenshot.attlist,
2035     screeninfo?,
2036     (graphic | graphicco | mediaobject | mediaobjectco)
2037   }
2038 # end of screenshot.element
2039 screenshot.attlist &=
2040   common.attrib, screenshot.role.attrib, local.screenshot.attrib
2041 # end of screenshot.attlist
2042
2043 # end of screenshot.module
2044 local.screeninfo.attrib = empty
2045 screeninfo.role.attrib = role.attrib
2046 screeninfo = element screeninfo { screeninfo.attlist, para.char.mix* }
2047 # end of screeninfo.element
2048 screeninfo.attlist &=
2049   common.attrib, screeninfo.role.attrib, local.screeninfo.attrib
2050 # end of screeninfo.attlist
2051
2052 # end of screeninfo.module
2053
2054 # end of screenshot.content.module
2055
2056 # Figures etc. .....................
2057 local.figure.attrib = empty
2058 figure.role.attrib = role.attrib
2059 figure =
2060   element figure {
2061     figure.attlist,
2062     blockinfo?,
2063     formalobject.title.content,
2064     (figure.mix | link.char.class)+
2065   }
2066 # end of figure.element
2067
2068 # Float: Whether the Figure is supposed to be rendered
2069 # where convenient (yes (1) value) or at the place it occurs
2070 # in the text (no (0) value, the default)
2071 figure.attlist &=
2072   [ a:defaultValue = "0" ] attribute float { yesorno.attvals }?,
2073   attribute pgwide { yesorno.attvals }?,
2074   label.attrib,
2075   common.attrib,
2076   figure.role.attrib,
2077   local.figure.attrib
2078 # end of figure.attlist
2079
2080 # end of figure.module
2081 local.informalfigure.attrib = empty
2082 informalfigure.role.attrib = role.attrib
2083 informalfigure =
2084   element informalfigure {
2085     informalfigure.attlist, blockinfo?, (figure.mix | link.char.class)+
2086   }
2087 # end of informalfigure.element
2088
2089 # Float: Whether the Figure is supposed to be rendered
2090 # where convenient (yes (1) value) or at the place it occurs
2091 # in the text (no (0) value, the default)
2092 informalfigure.attlist &=
2093   [ a:defaultValue = "0" ] attribute float { yesorno.attvals }?,
2094   attribute pgwide { yesorno.attvals }?,
2095   label.attrib,
2096   common.attrib,
2097   informalfigure.role.attrib,
2098   local.informalfigure.attrib
2099 # end of informalfigure.attlist
2100
2101 # end of informalfigure.module
2102 local.graphicco.attrib = empty
2103 graphicco.role.attrib = role.attrib
2104 graphicco =
2105   element graphicco {
2106     graphicco.attlist, areaspec, graphic, calloutlist*
2107   }
2108 # end of graphicco.element
2109 graphicco.attlist &=
2110   common.attrib, graphicco.role.attrib, local.graphicco.attrib
2111 # end of graphicco.attlist
2112
2113 #  AreaSpec (defined above in Examples)
2114
2115 #  CalloutList (defined above in Lists)
2116
2117 # end of graphicco.module
2118
2119 # Graphical data can be the content of Graphic, or you can reference
2120 # an external file either as an entity (Entitref) or a filename
2121 # (Fileref).
2122 local.graphic.attrib = empty
2123 graphic.role.attrib = role.attrib
2124 graphic = element graphic { graphic.attlist, empty }
2125 # end of graphic.element
2126 graphic.attlist &=
2127   graphics.attrib,
2128   common.attrib,
2129   graphic.role.attrib,
2130   local.graphic.attrib
2131 # end of graphic.attlist
2132
2133 # end of graphic.module
2134 local.inlinegraphic.attrib = empty
2135 inlinegraphic.role.attrib = role.attrib
2136 inlinegraphic = element inlinegraphic { inlinegraphic.attlist, empty }
2137 # end of inlinegraphic.element
2138 inlinegraphic.attlist &=
2139   graphics.attrib,
2140   common.attrib,
2141   inlinegraphic.role.attrib,
2142   local.inlinegraphic.attrib
2143 # end of inlinegraphic.attlist
2144
2145 # end of inlinegraphic.module
2146 local.mediaobject.attrib = empty
2147 mediaobject.role.attrib = role.attrib
2148 mediaobject =
2149   element mediaobject {
2150     mediaobject.attlist, objectinfo?, mediaobject.mix+, caption?
2151   }
2152 # end of mediaobject.element
2153 mediaobject.attlist &=
2154   common.attrib, mediaobject.role.attrib, local.mediaobject.attrib
2155 # end of mediaobject.attlist
2156
2157 # end of mediaobject.module
2158 local.inlinemediaobject.attrib = empty
2159 inlinemediaobject.role.attrib = role.attrib
2160 inlinemediaobject =
2161   element inlinemediaobject {
2162     inlinemediaobject.attlist, objectinfo?, mediaobject.mix+
2163   }
2164 # end of inlinemediaobject.element
2165 inlinemediaobject.attlist &=
2166   common.attrib,
2167   inlinemediaobject.role.attrib,
2168   local.inlinemediaobject.attrib
2169 # end of inlinemediaobject.attlist
2170
2171 # end of inlinemediaobject.module
2172 local.videoobject.attrib = empty
2173 videoobject.role.attrib = role.attrib
2174 videoobject =
2175   element videoobject { videoobject.attlist, objectinfo?, videodata }
2176 # end of videoobject.element
2177 videoobject.attlist &=
2178   common.attrib, videoobject.role.attrib, local.videoobject.attrib
2179 # end of videoobject.attlist
2180
2181 # end of videoobject.module
2182 local.audioobject.attrib = empty
2183 audioobject.role.attrib = role.attrib
2184 audioobject =
2185   element audioobject { audioobject.attlist, objectinfo?, audiodata }
2186 # end of audioobject.element
2187 audioobject.attlist &=
2188   common.attrib, audioobject.role.attrib, local.audioobject.attrib
2189 # end of audioobject.attlist
2190
2191 # end of audioobject.module
2192 local.imageobject.attrib = empty
2193 imageobject.role.attrib = role.attrib
2194 imageobject =
2195   element imageobject { imageobject.attlist, objectinfo?, imagedata }
2196 # end of imageobject.element
2197 imageobject.attlist &=
2198   common.attrib, imageobject.role.attrib, local.imageobject.attrib
2199 # end of imageobject.attlist
2200
2201 # end of imageobject.module
2202 local.textobject.attrib = empty
2203 textobject.role.attrib = role.attrib
2204 textobject =
2205   element textobject {
2206     textobject.attlist,
2207     objectinfo?,
2208     (phrase | textdata | textobject.mix+)
2209   }
2210 # end of textobject.element
2211 textobject.attlist &=
2212   common.attrib, textobject.role.attrib, local.textobject.attrib
2213 # end of textobject.attlist
2214
2215 # end of textobject.module
2216 local.objectinfo.attrib = empty
2217 objectinfo.role.attrib = role.attrib
2218 objectinfo = element objectinfo { objectinfo.attlist, info.class+ }
2219 # end of objectinfo.element
2220 objectinfo.attlist &=
2221   common.attrib, objectinfo.role.attrib, local.objectinfo.attrib
2222 # end of objectinfo.attlist
2223
2224 # end of objectinfo.module
2225
2226 # EntityRef: Name of an external entity containing the content
2227 # of the object data
2228
2229 # FileRef: Filename, qualified by a pathname if desired,
2230 # designating the file containing the content of the object data
2231
2232 # Format: Notation of the element content, if any
2233
2234 # SrcCredit: Information about the source of the image
2235 local.objectdata.attrib = empty
2236 objectdata.attrib =
2237   attribute entityref { xsd:ENTITY }?,
2238   attribute fileref { text }?,
2239   attribute format { notation.class }?,
2240   attribute srccredit { text }?,
2241   local.objectdata.attrib
2242 local.videodata.attrib = empty
2243 videodata.role.attrib = role.attrib
2244 videodata = element videodata { videodata.attlist, empty }
2245 # end of videodata.element
2246
2247 # Width: Same as CALS reprowid (desired width)
2248
2249 # Depth: Same as CALS reprodep (desired depth)
2250
2251 # Align: Same as CALS hplace with 'none' removed; #IMPLIED means
2252 # application-specific
2253
2254 # Scale: Conflation of CALS hscale and vscale
2255
2256 # Scalefit: Same as CALS scalefit
2257 videodata.attlist &=
2258   attribute width { text }?,
2259   attribute contentwidth { text }?,
2260   attribute depth { text }?,
2261   attribute contentdepth { text }?,
2262   attribute align { "left" | "right" | "center" }?,
2263   attribute valign { "top" | "middle" | "bottom" }?,
2264   attribute scale { text }?,
2265   attribute scalefit { yesorno.attvals }?,
2266   objectdata.attrib,
2267   common.attrib,
2268   videodata.role.attrib,
2269   local.videodata.attrib
2270 # end of videodata.attlist
2271
2272 # end of videodata.module
2273 local.audiodata.attrib = empty
2274 audiodata.role.attrib = role.attrib
2275 audiodata = element audiodata { audiodata.attlist, empty }
2276 # end of audiodata.element
2277 audiodata.attlist &=
2278   objectdata.attrib,
2279   common.attrib,
2280   audiodata.role.attrib,
2281   local.audiodata.attrib
2282 # end of audiodata.attlist
2283
2284 # end of audiodata.module
2285 local.imagedata.attrib = empty
2286 imagedata.role.attrib = role.attrib
2287 imagedata = element imagedata { imagedata.attlist, empty }
2288 # end of imagedata.element
2289
2290 # Width: Same as CALS reprowid (desired width)
2291
2292 # Depth: Same as CALS reprodep (desired depth)
2293
2294 # Align: Same as CALS hplace with 'none' removed; #IMPLIED means
2295 # application-specific
2296
2297 # Scale: Conflation of CALS hscale and vscale
2298
2299 # Scalefit: Same as CALS scalefit
2300 imagedata.attlist &=
2301   attribute width { text }?,
2302   attribute contentwidth { text }?,
2303   attribute depth { text }?,
2304   attribute contentdepth { text }?,
2305   attribute align { "left" | "right" | "center" }?,
2306   attribute valign { "top" | "middle" | "bottom" }?,
2307   attribute scale { text }?,
2308   attribute scalefit { yesorno.attvals }?,
2309   objectdata.attrib,
2310   common.attrib,
2311   imagedata.role.attrib,
2312   local.imagedata.attrib
2313 # end of imagedata.attlist
2314
2315 # end of imagedata.module
2316 local.textdata.attrib = empty
2317 textdata.role.attrib = role.attrib
2318 textdata = element textdata { textdata.attlist, empty }
2319 # end of textdata.element
2320 textdata.attlist &=
2321   attribute encoding { text }?,
2322   objectdata.attrib,
2323   common.attrib,
2324   textdata.role.attrib,
2325   local.textdata.attrib
2326 # end of textdata.attlist
2327
2328 # end of textdata.module
2329 local.caption.attrib = empty
2330 caption.role.attrib = role.attrib
2331 caption = element caption { caption.attlist, textobject.mix* }
2332 # end of caption.element
2333 caption.attlist &=
2334   common.attrib, caption.role.attrib, local.caption.attrib
2335 # end of caption.attlist
2336
2337 # end of caption.module
2338 local.mediaobjectco.attrib = empty
2339 mediaobjectco.role.attrib = role.attrib
2340 mediaobjectco =
2341   element mediaobjectco {
2342     mediaobjectco.attlist,
2343     objectinfo?,
2344     imageobjectco,
2345     (imageobjectco | textobject)*
2346   }
2347 # end of mediaobjectco.element
2348 mediaobjectco.attlist &=
2349   common.attrib, mediaobjectco.role.attrib, local.mediaobjectco.attrib
2350 # end of mediaobjectco.attlist
2351
2352 # end of mediaobjectco.module
2353 local.imageobjectco.attrib = empty
2354 imageobjectco.role.attrib = role.attrib
2355 imageobjectco =
2356   element imageobjectco {
2357     imageobjectco.attlist, areaspec, imageobject, calloutlist*
2358   }
2359 # end of imageobjectco.element
2360 imageobjectco.attlist &=
2361   common.attrib, imageobjectco.role.attrib, local.imageobjectco.attrib
2362 # end of imageobjectco.attlist
2363
2364 # end of imageobjectco.module
2365
2366 # end of mediaobject.content.module
2367
2368 # Equations ........................
2369
2370 # This PE provides a mechanism for replacing equation content,
2371
2372 # perhaps adding a new or different model (e.g., MathML)
2373 equation.content = alt?, (graphic+ | mediaobject+)
2374 inlineequation.content = alt?, (graphic+ | inlinemediaobject+)
2375 local.equation.attrib = empty
2376 equation.role.attrib = role.attrib
2377 equation =
2378   element equation {
2379     equation.attlist,
2380     blockinfo?,
2381     formalobject.title.content?,
2382     (informalequation | equation.content)
2383   }
2384 # end of equation.element
2385 equation.attlist &=
2386   label.attrib,
2387   common.attrib,
2388   equation.role.attrib,
2389   local.equation.attrib
2390 # end of equation.attlist
2391
2392 # end of equation.module
2393 local.informalequation.attrib = empty
2394 informalequation.role.attrib = role.attrib
2395 informalequation =
2396   element informalequation {
2397     informalequation.attlist, blockinfo?, equation.content
2398   }
2399 # end of informalequation.element
2400 informalequation.attlist &=
2401   common.attrib,
2402   informalequation.role.attrib,
2403   local.informalequation.attrib
2404 # end of informalequation.attlist
2405
2406 # end of informalequation.module
2407 local.inlineequation.attrib = empty
2408 inlineequation.role.attrib = role.attrib
2409 inlineequation =
2410   element inlineequation {
2411     inlineequation.attlist, inlineequation.content
2412   }
2413 # end of inlineequation.element
2414 inlineequation.attlist &=
2415   common.attrib, inlineequation.role.attrib, local.inlineequation.attrib
2416 # end of inlineequation.attlist
2417
2418 # end of inlineequation.module
2419 local.alt.attrib = empty
2420 alt.role.attrib = role.attrib
2421 alt = element alt { alt.attlist, text }
2422 # end of alt.element
2423 alt.attlist &= common.attrib, alt.role.attrib, local.alt.attrib
2424 # end of alt.attlist
2425
2426 # end of alt.module
2427
2428 # Tables ...........................
2429
2430 tables.role.attrib = role.attrib
2431
2432 # Note that InformalTable is dependent on some of the entity
2433 # declarations that customize Table.
2434 local.informaltable.attrib = empty
2435 informaltable =
2436   element informaltable {
2437     informaltable.attlist,
2438     blockinfo?,
2439     textobject*,
2440     (graphic+ | mediaobject+ | tgroup+)
2441   }
2442 # end of informaltable.element
2443
2444 # Frame, Colsep, and Rowsep must be repeated because
2445 # they are not in entities in the table module.
2446
2447 # includes TabStyle, ToCentry, ShortEntry,
2448 # Orient, PgWide
2449
2450 # includes Label
2451
2452 # includes common attributes
2453 informaltable.attlist &=
2454   attribute frame {
2455     "top" | "bottom" | "topbot" | "all" | "sides" | "none"
2456   }?,
2457   attribute colsep { yesorno.attvals }?,
2458   attribute rowsep { yesorno.attvals }?,
2459   common.table.attribs,
2460   tbl.table.att,
2461   local.informaltable.attrib
2462 # end of informaltable.attlist
2463
2464 # end of informaltable.module
2465
2466 # ......................................................................
2467
2468 # Synopses .............................................................
2469
2470 # Synopsis .........................
2471 local.synopsis.attrib = empty
2472 synopsis.role.attrib = role.attrib
2473 synopsis =
2474   element synopsis {
2475     synopsis.attlist,
2476     (para.char.mix
2477      | graphic
2478      | mediaobject
2479      | co
2480      | coref
2481      | textobject
2482      | lineannotation)*
2483   }
2484 # end of synopsis.element
2485 synopsis.attlist &=
2486   label.attrib,
2487   linespecific.attrib,
2488   common.attrib,
2489   synopsis.role.attrib,
2490   local.synopsis.attrib
2491 # end of synopsis.attlist
2492
2493 #  LineAnnotation (defined in the Inlines section, below)
2494
2495 # end of synopsis.module
2496
2497 # CmdSynopsis ......................
2498 local.cmdsynopsis.attrib = empty
2499 cmdsynopsis.role.attrib = role.attrib
2500 cmdsynopsis =
2501   element cmdsynopsis {
2502     cmdsynopsis.attlist, (command | arg | group | sbr)+, synopfragment*
2503   }
2504 # end of cmdsynopsis.element
2505
2506 # Sepchar: Character that should separate command and all
2507 # top-level arguments; alternate value might be e.g., &Delta;
2508 cmdsynopsis.attlist &=
2509   label.attrib,
2510   [ a:defaultValue = " " ] attribute sepchar { text }?,
2511   attribute cmdlength { text }?,
2512   common.attrib,
2513   cmdsynopsis.role.attrib,
2514   local.cmdsynopsis.attrib
2515 # end of cmdsynopsis.attlist
2516
2517 # end of cmdsynopsis.module
2518 local.arg.attrib = empty
2519 arg.role.attrib = role.attrib
2520 arg =
2521   element arg {
2522     arg.attlist,
2523     (text
2524      | arg
2525      | group
2526      | option
2527      | synopfragmentref
2528      | replaceable
2529      | sbr)*
2530   }
2531 # end of arg.element
2532
2533 # Choice: Whether Arg must be supplied: Opt (optional to
2534 # supply, e.g. [arg]; the default), Req (required to supply,
2535 # e.g. {arg}), or Plain (required to supply, e.g. arg)
2536
2537 # Rep: whether Arg is repeatable: Norepeat (e.g. arg without
2538 # ellipsis; the default), or Repeat (e.g. arg...)
2539 arg.attlist &=
2540   [ a:defaultValue = "opt" ]
2541   attribute choice { "opt" | "req" | "plain" }?,
2542   [ a:defaultValue = "norepeat" ]
2543   attribute rep { "norepeat" | "repeat" }?,
2544   common.attrib,
2545   arg.role.attrib,
2546   local.arg.attrib
2547 # end of arg.attlist
2548
2549 # end of arg.module
2550 local.group.attrib = empty
2551 group.role.attrib = role.attrib
2552 group =
2553   element group {
2554     group.attlist,
2555     (arg | group | option | synopfragmentref | replaceable | sbr)+
2556   }
2557 # end of group.element
2558
2559 # Choice: Whether Group must be supplied: Opt (optional to
2560 # supply, e.g.  [g1|g2|g3]; the default), Req (required to
2561 # supply, e.g.  {g1|g2|g3}), Plain (required to supply,
2562 # e.g.  g1|g2|g3), OptMult (can supply zero or more, e.g.
2563 # [[g1|g2|g3]]), or ReqMult (must supply one or more, e.g.
2564 # {{g1|g2|g3}})
2565
2566 # Rep: whether Group is repeatable: Norepeat (e.g. group
2567 # without ellipsis; the default), or Repeat (e.g. group...)
2568 group.attlist &=
2569   [ a:defaultValue = "opt" ]
2570   attribute choice { "opt" | "req" | "plain" }?,
2571   [ a:defaultValue = "norepeat" ]
2572   attribute rep { "norepeat" | "repeat" }?,
2573   common.attrib,
2574   group.role.attrib,
2575   local.group.attrib
2576 # end of group.attlist
2577
2578 # end of group.module
2579 local.sbr.attrib = empty
2580 # Synopsis break
2581 sbr.role.attrib = role.attrib
2582 sbr = element sbr { sbr.attlist, empty }
2583 # end of sbr.element
2584 sbr.attlist &= common.attrib, sbr.role.attrib, local.sbr.attrib
2585 # end of sbr.attlist
2586
2587 # end of sbr.module
2588 local.synopfragmentref.attrib = empty
2589 synopfragmentref.role.attrib = role.attrib
2590 synopfragmentref =
2591   element synopfragmentref { synopfragmentref.attlist, text }
2592 # end of synopfragmentref.element
2593
2594 # to SynopFragment of complex synopsis
2595 # material for separate referencing
2596 synopfragmentref.attlist &=
2597   linkendreq.attrib,
2598   common.attrib,
2599   synopfragmentref.role.attrib,
2600   local.synopfragmentref.attrib
2601 # end of synopfragmentref.attlist
2602
2603 # end of synopfragmentref.module
2604 local.synopfragment.attrib = empty
2605 synopfragment.role.attrib = role.attrib
2606 synopfragment =
2607   element synopfragment { synopfragment.attlist, (arg | group)+ }
2608 # end of synopfragment.element
2609 synopfragment.attlist &=
2610   idreq.common.attrib,
2611   synopfragment.role.attrib,
2612   local.synopfragment.attrib
2613 # end of synopfragment.attlist
2614
2615 # end of synopfragment.module
2616
2617 #  Command (defined in the Inlines section, below)
2618
2619 #  Option (defined in the Inlines section, below)
2620
2621 #  Replaceable (defined in the Inlines section, below)
2622
2623 # end of cmdsynopsis.content.module
2624
2625 # FuncSynopsis .....................
2626 local.funcsynopsis.attrib = empty
2627 funcsynopsis.role.attrib = role.attrib
2628 funcsynopsis =
2629   element funcsynopsis {
2630     funcsynopsis.attlist, (funcsynopsisinfo | funcprototype)+
2631   }
2632 # end of funcsynopsis.element
2633 funcsynopsis.attlist &=
2634   label.attrib,
2635   common.attrib,
2636   funcsynopsis.role.attrib,
2637   local.funcsynopsis.attrib
2638 # end of funcsynopsis.attlist
2639
2640 # end of funcsynopsis.module
2641 local.funcsynopsisinfo.attrib = empty
2642 funcsynopsisinfo.role.attrib = role.attrib
2643 funcsynopsisinfo =
2644   element funcsynopsisinfo {
2645     funcsynopsisinfo.attlist,
2646     (cptr.char.mix | textobject | lineannotation)*
2647   }
2648 # end of funcsynopsisinfo.element
2649 funcsynopsisinfo.attlist &=
2650   linespecific.attrib,
2651   common.attrib,
2652   funcsynopsisinfo.role.attrib,
2653   local.funcsynopsisinfo.attrib
2654 # end of funcsynopsisinfo.attlist
2655
2656 # end of funcsynopsisinfo.module
2657 local.funcprototype.attrib = empty
2658 funcprototype.role.attrib = role.attrib
2659 funcprototype =
2660   element funcprototype {
2661     funcprototype.attlist, funcdef, (void | varargs | paramdef+)
2662   }
2663 # end of funcprototype.element
2664 funcprototype.attlist &=
2665   common.attrib, funcprototype.role.attrib, local.funcprototype.attrib
2666 # end of funcprototype.attlist
2667
2668 # end of funcprototype.module
2669 local.funcdef.attrib = empty
2670 funcdef.role.attrib = role.attrib
2671 funcdef =
2672   element funcdef {
2673     funcdef.attlist, (text | type | replaceable | function)*
2674   }
2675 # end of funcdef.element
2676 funcdef.attlist &=
2677   common.attrib, funcdef.role.attrib, local.funcdef.attrib
2678 # end of funcdef.attlist
2679
2680 # end of funcdef.module
2681 local.void.attrib = empty
2682 void.role.attrib = role.attrib
2683 void = element void { void.attlist, empty }
2684 # end of void.element
2685 void.attlist &= common.attrib, void.role.attrib, local.void.attrib
2686 # end of void.attlist
2687
2688 # end of void.module
2689 local.varargs.attrib = empty
2690 varargs.role.attrib = role.attrib
2691 varargs = element varargs { varargs.attlist, empty }
2692 # end of varargs.element
2693 varargs.attlist &=
2694   common.attrib, varargs.role.attrib, local.varargs.attrib
2695 # end of varargs.attlist
2696
2697 # end of varargs.module
2698
2699 # Processing assumes that only one Parameter will appear in a
2700 # ParamDef, and that FuncParams will be used at most once, for
2701 # providing information on the "inner parameters" for parameters that
2702 # are pointers to functions.
2703 local.paramdef.attrib = empty
2704 paramdef.role.attrib = role.attrib
2705 paramdef =
2706   element paramdef {
2707     paramdef.attlist,
2708     (text | type | replaceable | parameter | funcparams)*
2709   }
2710 # end of paramdef.element
2711 paramdef.attlist &=
2712   common.attrib, paramdef.role.attrib, local.paramdef.attrib
2713 # end of paramdef.attlist
2714
2715 # end of paramdef.module
2716 local.funcparams.attrib = empty
2717 funcparams.role.attrib = role.attrib
2718 funcparams = element funcparams { funcparams.attlist, cptr.char.mix* }
2719 # end of funcparams.element
2720 funcparams.attlist &=
2721   common.attrib, funcparams.role.attrib, local.funcparams.attrib
2722 # end of funcparams.attlist
2723
2724 # end of funcparams.module
2725
2726 #  LineAnnotation (defined in the Inlines section, below)
2727
2728 #  Replaceable (defined in the Inlines section, below)
2729
2730 #  Function (defined in the Inlines section, below)
2731
2732 #  Parameter (defined in the Inlines section, below)
2733
2734 # end of funcsynopsis.content.module
2735
2736 # ClassSynopsis .....................
2737 local.classsynopsis.attrib = empty
2738 classsynopsis.role.attrib = role.attrib
2739 classsynopsis =
2740   element classsynopsis {
2741     classsynopsis.attlist,
2742     (ooclass | oointerface | ooexception)+,
2743     (classsynopsisinfo | fieldsynopsis | method.synop.class)*
2744   }
2745 # end of classsynopsis.element
2746 classsynopsis.attlist &=
2747   attribute language { text }?,
2748   [ a:defaultValue = "class" ]
2749   attribute class { "class" | "interface" }?,
2750   common.attrib,
2751   classsynopsis.role.attrib,
2752   local.classsynopsis.attrib
2753 # end of classsynopsis.attlist
2754
2755 # end of classsynopsis.module
2756 local.classsynopsisinfo.attrib = empty
2757 classsynopsisinfo.role.attrib = role.attrib
2758 classsynopsisinfo =
2759   element classsynopsisinfo {
2760     classsynopsisinfo.attlist,
2761     (cptr.char.mix | textobject | lineannotation)*
2762   }
2763 # end of classsynopsisinfo.element
2764 classsynopsisinfo.attlist &=
2765   linespecific.attrib,
2766   common.attrib,
2767   classsynopsisinfo.role.attrib,
2768   local.classsynopsisinfo.attrib
2769 # end of classsynopsisinfo.attlist
2770
2771 # end of classsynopsisinfo.module
2772 local.ooclass.attrib = empty
2773 ooclass.role.attrib = role.attrib
2774 ooclass = element ooclass { ooclass.attlist, modifier*, classname }
2775 # end of ooclass.element
2776 ooclass.attlist &=
2777   common.attrib, ooclass.role.attrib, local.ooclass.attrib
2778 # end of ooclass.attlist
2779
2780 # end of ooclass.module
2781 local.oointerface.attrib = empty
2782 oointerface.role.attrib = role.attrib
2783 oointerface =
2784   element oointerface { oointerface.attlist, modifier*, interfacename }
2785 # end of oointerface.element
2786 oointerface.attlist &=
2787   common.attrib, oointerface.role.attrib, local.oointerface.attrib
2788 # end of oointerface.attlist
2789
2790 # end of oointerface.module
2791 local.ooexception.attrib = empty
2792 ooexception.role.attrib = role.attrib
2793 ooexception =
2794   element ooexception { ooexception.attlist, modifier*, exceptionname }
2795 # end of ooexception.element
2796 ooexception.attlist &=
2797   common.attrib, ooexception.role.attrib, local.ooexception.attrib
2798 # end of ooexception.attlist
2799
2800 # end of ooexception.module
2801 local.modifier.attrib = empty
2802 modifier.role.attrib = role.attrib
2803 modifier = element modifier { modifier.attlist, smallcptr.char.mix* }
2804 # end of modifier.element
2805 modifier.attlist &=
2806   common.attrib, modifier.role.attrib, local.modifier.attrib
2807 # end of modifier.attlist
2808
2809 # end of modifier.module
2810 local.interfacename.attrib = empty
2811 interfacename.role.attrib = role.attrib
2812 interfacename =
2813   element interfacename { interfacename.attlist, cptr.char.mix* }
2814 # end of interfacename.element
2815 interfacename.attlist &=
2816   common.attrib, interfacename.role.attrib, local.interfacename.attrib
2817 # end of interfacename.attlist
2818
2819 # end of interfacename.module
2820 local.exceptionname.attrib = empty
2821 exceptionname.role.attrib = role.attrib
2822 exceptionname =
2823   element exceptionname { exceptionname.attlist, smallcptr.char.mix* }
2824 # end of exceptionname.element
2825 exceptionname.attlist &=
2826   common.attrib, exceptionname.role.attrib, local.exceptionname.attrib
2827 # end of exceptionname.attlist
2828
2829 # end of exceptionname.module
2830 local.fieldsynopsis.attrib = empty
2831 fieldsynopsis.role.attrib = role.attrib
2832 fieldsynopsis =
2833   element fieldsynopsis {
2834     fieldsynopsis.attlist, modifier*, type?, varname, initializer?
2835   }
2836 # end of fieldsynopsis.element
2837 fieldsynopsis.attlist &=
2838   attribute language { text }?,
2839   common.attrib,
2840   fieldsynopsis.role.attrib,
2841   local.fieldsynopsis.attrib
2842 # end of fieldsynopsis.attlist
2843
2844 # end of fieldsynopsis.module
2845 local.initializer.attrib = empty
2846 initializer.role.attrib = role.attrib
2847 initializer =
2848   element initializer { initializer.attlist, smallcptr.char.mix* }
2849 # end of initializer.element
2850 initializer.attlist &=
2851   common.attrib, initializer.role.attrib, local.initializer.attrib
2852 # end of initializer.attlist
2853
2854 # end of initializer.module
2855 local.constructorsynopsis.attrib = empty
2856 constructorsynopsis.role.attrib = role.attrib
2857 constructorsynopsis =
2858   element constructorsynopsis {
2859     constructorsynopsis.attlist,
2860     modifier*,
2861     methodname?,
2862     (methodparam+ | void),
2863     exceptionname*
2864   }
2865 # end of constructorsynopsis.element
2866 constructorsynopsis.attlist &=
2867   attribute language { text }?,
2868   common.attrib,
2869   constructorsynopsis.role.attrib,
2870   local.constructorsynopsis.attrib
2871 # end of constructorsynopsis.attlist
2872
2873 # end of constructorsynopsis.module
2874 local.destructorsynopsis.attrib = empty
2875 destructorsynopsis.role.attrib = role.attrib
2876 destructorsynopsis =
2877   element destructorsynopsis {
2878     destructorsynopsis.attlist,
2879     modifier*,
2880     methodname?,
2881     (methodparam+ | void),
2882     exceptionname*
2883   }
2884 # end of destructorsynopsis.element
2885 destructorsynopsis.attlist &=
2886   attribute language { text }?,
2887   common.attrib,
2888   destructorsynopsis.role.attrib,
2889   local.destructorsynopsis.attrib
2890 # end of destructorsynopsis.attlist
2891
2892 # end of destructorsynopsis.module
2893 local.methodsynopsis.attrib = empty
2894 methodsynopsis.role.attrib = role.attrib
2895 methodsynopsis =
2896   element methodsynopsis {
2897     methodsynopsis.attlist,
2898     modifier*,
2899     (type | void)?,
2900     methodname,
2901     (methodparam+ | void),
2902     exceptionname*,
2903     modifier*
2904   }
2905 # end of methodsynopsis.element
2906 methodsynopsis.attlist &=
2907   attribute language { text }?,
2908   common.attrib,
2909   methodsynopsis.role.attrib,
2910   local.methodsynopsis.attrib
2911 # end of methodsynopsis.attlist
2912
2913 # end of methodsynopsis.module
2914 local.methodname.attrib = empty
2915 methodname.role.attrib = role.attrib
2916 methodname =
2917   element methodname { methodname.attlist, smallcptr.char.mix* }
2918 # end of methodname.element
2919 methodname.attlist &=
2920   common.attrib, methodname.role.attrib, local.methodname.attrib
2921 # end of methodname.attlist
2922
2923 # end of methodname.module
2924 local.methodparam.attrib = empty
2925 methodparam.role.attrib = role.attrib
2926 methodparam =
2927   element methodparam {
2928     methodparam.attlist,
2929     modifier*,
2930     type?,
2931     ((parameter, initializer?) | funcparams),
2932     modifier*
2933   }
2934 # end of methodparam.element
2935 methodparam.attlist &=
2936   [ a:defaultValue = "req" ]
2937   attribute choice { "opt" | "req" | "plain" }?,
2938   [ a:defaultValue = "norepeat" ]
2939   attribute rep { "norepeat" | "repeat" }?,
2940   common.attrib,
2941   methodparam.role.attrib,
2942   local.methodparam.attrib
2943 # end of methodparam.attlist
2944
2945 # end of methodparam.module
2946
2947 # end of classsynopsis.content.module
2948
2949 # ......................................................................
2950
2951 # Document information entities and elements ...........................
2952
2953 # The document information elements include some elements that are
2954 # currently used only in the document hierarchy module. They are
2955 # defined here so that they will be available for use in customized
2956 # document hierarchies.
2957
2958 # ..................................
2959
2960 # Ackno ............................
2961 local.ackno.attrib = empty
2962 ackno.role.attrib = role.attrib
2963 ackno = element ackno { ackno.attlist, docinfo.char.mix* }
2964 # end of ackno.element
2965 ackno.attlist &= common.attrib, ackno.role.attrib, local.ackno.attrib
2966 # end of ackno.attlist
2967
2968 # end of ackno.module
2969
2970 # Address ..........................
2971 local.address.attrib = empty
2972 address.role.attrib = role.attrib
2973 address =
2974   element address {
2975     address.attlist,
2976     (text
2977      | personname
2978      | person.ident.mix
2979      | street
2980      | pob
2981      | postcode
2982      | city
2983      | state
2984      | country
2985      | phone
2986      | fax
2987      | email
2988      | otheraddr)*
2989   }
2990 # end of address.element
2991 address.attlist &=
2992   linespecific.attrib,
2993   common.attrib,
2994   address.role.attrib,
2995   local.address.attrib
2996 # end of address.attlist
2997
2998 # end of address.module
2999 local.street.attrib = empty
3000 street.role.attrib = role.attrib
3001 street = element street { street.attlist, docinfo.char.mix* }
3002 # end of street.element
3003 street.attlist &= common.attrib, street.role.attrib, local.street.attrib
3004 # end of street.attlist
3005
3006 # end of street.module
3007 local.pob.attrib = empty
3008 pob.role.attrib = role.attrib
3009 pob = element pob { pob.attlist, docinfo.char.mix* }
3010 # end of pob.element
3011 pob.attlist &= common.attrib, pob.role.attrib, local.pob.attrib
3012 # end of pob.attlist
3013
3014 # end of pob.module
3015 local.postcode.attrib = empty
3016 postcode.role.attrib = role.attrib
3017 postcode = element postcode { postcode.attlist, docinfo.char.mix* }
3018 # end of postcode.element
3019 postcode.attlist &=
3020   common.attrib, postcode.role.attrib, local.postcode.attrib
3021 # end of postcode.attlist
3022
3023 # end of postcode.module
3024 local.city.attrib = empty
3025 city.role.attrib = role.attrib
3026 city = element city { city.attlist, docinfo.char.mix* }
3027 # end of city.element
3028 city.attlist &= common.attrib, city.role.attrib, local.city.attrib
3029 # end of city.attlist
3030
3031 # end of city.module
3032 local.state.attrib = empty
3033 state.role.attrib = role.attrib
3034 state = element state { state.attlist, docinfo.char.mix* }
3035 # end of state.element
3036 state.attlist &= common.attrib, state.role.attrib, local.state.attrib
3037 # end of state.attlist
3038
3039 # end of state.module
3040 local.country.attrib = empty
3041 country.role.attrib = role.attrib
3042 country = element country { country.attlist, docinfo.char.mix* }
3043 # end of country.element
3044 country.attlist &=
3045   common.attrib, country.role.attrib, local.country.attrib
3046 # end of country.attlist
3047
3048 # end of country.module
3049 local.phone.attrib = empty
3050 phone.role.attrib = role.attrib
3051 phone = element phone { phone.attlist, docinfo.char.mix* }
3052 # end of phone.element
3053 phone.attlist &= common.attrib, phone.role.attrib, local.phone.attrib
3054 # end of phone.attlist
3055
3056 # end of phone.module
3057 local.fax.attrib = empty
3058 fax.role.attrib = role.attrib
3059 fax = element fax { fax.attlist, docinfo.char.mix* }
3060 # end of fax.element
3061 fax.attlist &= common.attrib, fax.role.attrib, local.fax.attrib
3062 # end of fax.attlist
3063
3064 # end of fax.module
3065
3066 #  Email (defined in the Inlines section, below)
3067 local.otheraddr.attrib = empty
3068 otheraddr.role.attrib = role.attrib
3069 otheraddr = element otheraddr { otheraddr.attlist, docinfo.char.mix* }
3070 # end of otheraddr.element
3071 otheraddr.attlist &=
3072   common.attrib, otheraddr.role.attrib, local.otheraddr.attrib
3073 # end of otheraddr.attlist
3074
3075 # end of otheraddr.module
3076
3077 # end of address.content.module
3078
3079 # Affiliation ......................
3080 local.affiliation.attrib = empty
3081 affiliation.role.attrib = role.attrib
3082 affiliation =
3083   element affiliation {
3084     affiliation.attlist,
3085     shortaffil?,
3086     jobtitle*,
3087     orgname?,
3088     orgdiv*,
3089     address*
3090   }
3091 # end of affiliation.element
3092 affiliation.attlist &=
3093   common.attrib, affiliation.role.attrib, local.affiliation.attrib
3094 # end of affiliation.attlist
3095
3096 # end of affiliation.module
3097 local.shortaffil.attrib = empty
3098 shortaffil.role.attrib = role.attrib
3099 shortaffil =
3100   element shortaffil { shortaffil.attlist, docinfo.char.mix* }
3101 # end of shortaffil.element
3102 shortaffil.attlist &=
3103   common.attrib, shortaffil.role.attrib, local.shortaffil.attrib
3104 # end of shortaffil.attlist
3105
3106 # end of shortaffil.module
3107 local.jobtitle.attrib = empty
3108 jobtitle.role.attrib = role.attrib
3109 jobtitle = element jobtitle { jobtitle.attlist, docinfo.char.mix* }
3110 # end of jobtitle.element
3111 jobtitle.attlist &=
3112   common.attrib, jobtitle.role.attrib, local.jobtitle.attrib
3113 # end of jobtitle.attlist
3114
3115 # end of jobtitle.module
3116
3117 #  OrgName (defined elsewhere in this section)
3118 local.orgdiv.attrib = empty
3119 orgdiv.role.attrib = role.attrib
3120 orgdiv = element orgdiv { orgdiv.attlist, docinfo.char.mix* }
3121 # end of orgdiv.element
3122 orgdiv.attlist &= common.attrib, orgdiv.role.attrib, local.orgdiv.attrib
3123 # end of orgdiv.attlist
3124
3125 # end of orgdiv.module
3126
3127 #  Address (defined elsewhere in this section)
3128
3129 # end of affiliation.content.module
3130
3131 # ArtPageNums ......................
3132 local.artpagenums.attrib = empty
3133 artpagenums.role.attrib = role.attrib
3134 artpagenums =
3135   element artpagenums { artpagenums.attlist, docinfo.char.mix* }
3136 # end of artpagenums.element
3137 artpagenums.attlist &=
3138   common.attrib, artpagenums.role.attrib, local.artpagenums.attrib
3139 # end of artpagenums.attlist
3140
3141 # end of artpagenums.module
3142
3143 # PersonName
3144 local.personname.attrib = empty
3145 personname.role.attrib = role.attrib
3146 personname =
3147   element personname {
3148     personname.attlist,
3149     (honorific | firstname | surname | lineage | othername)+
3150   }
3151 # end of personname.element
3152 personname.attlist &=
3153   common.attrib, personname.role.attrib, local.personname.attrib
3154 # end of personname.attlist
3155
3156 # end of personname.module
3157
3158 # Author ...........................
3159 local.author.attrib = empty
3160 author.role.attrib = role.attrib
3161 author =
3162   element author {
3163     author.attlist,
3164     (personname | person.ident.mix+),
3165     (personblurb | email | address)*
3166   }
3167 # end of author.element
3168 author.attlist &= common.attrib, author.role.attrib, local.author.attrib
3169 # end of author.attlist
3170
3171 # (see "Personal identity elements" for %person.ident.mix;)
3172
3173 # end of author.module
3174
3175 # AuthorGroup ......................
3176 local.authorgroup.attrib = empty
3177 authorgroup.role.attrib = role.attrib
3178 authorgroup =
3179   element authorgroup {
3180     authorgroup.attlist,
3181     (author | editor | collab | corpauthor | othercredit)+
3182   }
3183 # end of authorgroup.element
3184 authorgroup.attlist &=
3185   common.attrib, authorgroup.role.attrib, local.authorgroup.attrib
3186 # end of authorgroup.attlist
3187
3188 # end of authorgroup.module
3189
3190 #  Author (defined elsewhere in this section)
3191
3192 #  Editor (defined elsewhere in this section)
3193 local.collab.attrib = empty
3194 collab.role.attrib = role.attrib
3195 collab = element collab { collab.attlist, collabname, affiliation* }
3196 # end of collab.element
3197 collab.attlist &= common.attrib, collab.role.attrib, local.collab.attrib
3198 # end of collab.attlist
3199
3200 # end of collab.module
3201 local.collabname.attrib = empty
3202 collabname.role.attrib = role.attrib
3203 collabname =
3204   element collabname { collabname.attlist, docinfo.char.mix* }
3205 # end of collabname.element
3206 collabname.attlist &=
3207   common.attrib, collabname.role.attrib, local.collabname.attrib
3208 # end of collabname.attlist
3209
3210 # end of collabname.module
3211
3212 #  Affiliation (defined elsewhere in this section)
3213
3214 # end of collab.content.module
3215
3216 #  CorpAuthor (defined elsewhere in this section)
3217
3218 #  OtherCredit (defined elsewhere in this section)
3219
3220 # end of authorgroup.content.module
3221
3222 # AuthorInitials ...................
3223 local.authorinitials.attrib = empty
3224 authorinitials.role.attrib = role.attrib
3225 authorinitials =
3226   element authorinitials { authorinitials.attlist, docinfo.char.mix* }
3227 # end of authorinitials.element
3228 authorinitials.attlist &=
3229   common.attrib, authorinitials.role.attrib, local.authorinitials.attrib
3230 # end of authorinitials.attlist
3231
3232 # end of authorinitials.module
3233
3234 # ConfGroup ........................
3235 local.confgroup.attrib = empty
3236 confgroup.role.attrib = role.attrib
3237 confgroup =
3238   element confgroup {
3239     confgroup.attlist,
3240     (confdates | conftitle | confnum | address | confsponsor)*
3241   }
3242 # end of confgroup.element
3243 confgroup.attlist &=
3244   common.attrib, confgroup.role.attrib, local.confgroup.attrib
3245 # end of confgroup.attlist
3246
3247 # end of confgroup.module
3248 local.confdates.attrib = empty
3249 confdates.role.attrib = role.attrib
3250 confdates = element confdates { confdates.attlist, docinfo.char.mix* }
3251 # end of confdates.element
3252 confdates.attlist &=
3253   common.attrib, confdates.role.attrib, local.confdates.attrib
3254 # end of confdates.attlist
3255
3256 # end of confdates.module
3257 local.conftitle.attrib = empty
3258 conftitle.role.attrib = role.attrib
3259 conftitle = element conftitle { conftitle.attlist, docinfo.char.mix* }
3260 # end of conftitle.element
3261 conftitle.attlist &=
3262   common.attrib, conftitle.role.attrib, local.conftitle.attrib
3263 # end of conftitle.attlist
3264
3265 # end of conftitle.module
3266 local.confnum.attrib = empty
3267 confnum.role.attrib = role.attrib
3268 confnum = element confnum { confnum.attlist, docinfo.char.mix* }
3269 # end of confnum.element
3270 confnum.attlist &=
3271   common.attrib, confnum.role.attrib, local.confnum.attrib
3272 # end of confnum.attlist
3273
3274 # end of confnum.module
3275
3276 #  Address (defined elsewhere in this section)
3277 local.confsponsor.attrib = empty
3278 confsponsor.role.attrib = role.attrib
3279 confsponsor =
3280   element confsponsor { confsponsor.attlist, docinfo.char.mix* }
3281 # end of confsponsor.element
3282 confsponsor.attlist &=
3283   common.attrib, confsponsor.role.attrib, local.confsponsor.attrib
3284 # end of confsponsor.attlist
3285
3286 # end of confsponsor.module
3287
3288 # end of confgroup.content.module
3289
3290 # ContractNum ......................
3291 local.contractnum.attrib = empty
3292 contractnum.role.attrib = role.attrib
3293 contractnum =
3294   element contractnum { contractnum.attlist, docinfo.char.mix* }
3295 # end of contractnum.element
3296 contractnum.attlist &=
3297   common.attrib, contractnum.role.attrib, local.contractnum.attrib
3298 # end of contractnum.attlist
3299
3300 # end of contractnum.module
3301
3302 # ContractSponsor ..................
3303 local.contractsponsor.attrib = empty
3304 contractsponsor.role.attrib = role.attrib
3305 contractsponsor =
3306   element contractsponsor { contractsponsor.attlist, docinfo.char.mix* }
3307 # end of contractsponsor.element
3308 contractsponsor.attlist &=
3309   common.attrib,
3310   contractsponsor.role.attrib,
3311   local.contractsponsor.attrib
3312 # end of contractsponsor.attlist
3313
3314 # end of contractsponsor.module
3315
3316 # Copyright ........................
3317 local.copyright.attrib = empty
3318 copyright.role.attrib = role.attrib
3319 copyright = element copyright { copyright.attlist, year+, holder* }
3320 # end of copyright.element
3321 copyright.attlist &=
3322   common.attrib, copyright.role.attrib, local.copyright.attrib
3323 # end of copyright.attlist
3324
3325 # end of copyright.module
3326 local.year.attrib = empty
3327 year.role.attrib = role.attrib
3328 year = element year { year.attlist, docinfo.char.mix* }
3329 # end of year.element
3330 year.attlist &= common.attrib, year.role.attrib, local.year.attrib
3331 # end of year.attlist
3332
3333 # end of year.module
3334 local.holder.attrib = empty
3335 holder.role.attrib = role.attrib
3336 holder = element holder { holder.attlist, docinfo.char.mix* }
3337 # end of holder.element
3338 holder.attlist &= common.attrib, holder.role.attrib, local.holder.attrib
3339 # end of holder.attlist
3340
3341 # end of holder.module
3342
3343 # end of copyright.content.module
3344
3345 # CorpAuthor .......................
3346 local.corpauthor.attrib = empty
3347 corpauthor.role.attrib = role.attrib
3348 corpauthor =
3349   element corpauthor { corpauthor.attlist, docinfo.char.mix* }
3350 # end of corpauthor.element
3351 corpauthor.attlist &=
3352   common.attrib, corpauthor.role.attrib, local.corpauthor.attrib
3353 # end of corpauthor.attlist
3354
3355 # end of corpauthor.module
3356
3357 # CorpName .........................
3358 local.corpname.attrib = empty
3359 corpname = element corpname { corpname.attlist, docinfo.char.mix* }
3360 # end of corpname.element
3361 corpname.role.attrib = role.attrib
3362 corpname.attlist &=
3363   common.attrib, corpname.role.attrib, local.corpname.attrib
3364 # end of corpname.attlist
3365
3366 # end of corpname.module
3367
3368 # Date .............................
3369 local.date.attrib = empty
3370 date.role.attrib = role.attrib
3371 date = element date { date.attlist, docinfo.char.mix* }
3372 # end of date.element
3373 date.attlist &= common.attrib, date.role.attrib, local.date.attrib
3374 # end of date.attlist
3375
3376 # end of date.module
3377
3378 # Edition ..........................
3379 local.edition.attrib = empty
3380 edition.role.attrib = role.attrib
3381 edition = element edition { edition.attlist, docinfo.char.mix* }
3382 # end of edition.element
3383 edition.attlist &=
3384   common.attrib, edition.role.attrib, local.edition.attrib
3385 # end of edition.attlist
3386
3387 # end of edition.module
3388
3389 # Editor ...........................
3390 local.editor.attrib = empty
3391 editor.role.attrib = role.attrib
3392 editor =
3393   element editor {
3394     editor.attlist,
3395     (personname | person.ident.mix+),
3396     (personblurb | email | address)*
3397   }
3398 # end of editor.element
3399 editor.attlist &= common.attrib, editor.role.attrib, local.editor.attrib
3400 # end of editor.attlist
3401
3402 # (see "Personal identity elements" for %person.ident.mix;)
3403
3404 # end of editor.module
3405
3406 # ISBN .............................
3407 local.isbn.attrib = empty
3408 isbn.role.attrib = role.attrib
3409 isbn = element isbn { isbn.attlist, docinfo.char.mix* }
3410 # end of isbn.element
3411 isbn.attlist &= common.attrib, isbn.role.attrib, local.isbn.attrib
3412 # end of isbn.attlist
3413
3414 # end of isbn.module
3415
3416 # ISSN .............................
3417 local.issn.attrib = empty
3418 issn.role.attrib = role.attrib
3419 issn = element issn { issn.attlist, docinfo.char.mix* }
3420 # end of issn.element
3421 issn.attlist &= common.attrib, issn.role.attrib, local.issn.attrib
3422 # end of issn.attlist
3423
3424 # end of issn.module
3425
3426 # BiblioId .................
3427 biblio.class.attrib =
3428   attribute class {
3429     "uri"
3430     | "doi"
3431     | "isbn"
3432     | "issn"
3433     | "libraryofcongress"
3434     | "pubnumber"
3435     | "other"
3436   }?,
3437   attribute otherclass { text }?
3438 local.biblioid.attrib = empty
3439 biblioid.role.attrib = role.attrib
3440 biblioid = element biblioid { biblioid.attlist, docinfo.char.mix* }
3441 # end of biblioid.element
3442 biblioid.attlist &=
3443   biblio.class.attrib,
3444   common.attrib,
3445   biblioid.role.attrib,
3446   local.biblioid.attrib
3447 # end of biblioid.attlist
3448
3449 # end of biblioid.module
3450
3451 # CiteBiblioId .................
3452 local.citebiblioid.attrib = empty
3453 citebiblioid.role.attrib = role.attrib
3454 citebiblioid =
3455   element citebiblioid { citebiblioid.attlist, docinfo.char.mix* }
3456 # end of citebiblioid.element
3457 citebiblioid.attlist &=
3458   biblio.class.attrib,
3459   common.attrib,
3460   citebiblioid.role.attrib,
3461   local.citebiblioid.attrib
3462 # end of citebiblioid.attlist
3463
3464 # end of citebiblioid.module
3465
3466 # BiblioSource .................
3467 local.bibliosource.attrib = empty
3468 bibliosource.role.attrib = role.attrib
3469 bibliosource =
3470   element bibliosource { bibliosource.attlist, docinfo.char.mix* }
3471 # end of bibliosource.element
3472 bibliosource.attlist &=
3473   biblio.class.attrib,
3474   common.attrib,
3475   bibliosource.role.attrib,
3476   local.bibliosource.attrib
3477 # end of bibliosource.attlist
3478
3479 # end of bibliosource.module
3480
3481 # BiblioRelation .................
3482 local.bibliorelation.attrib = empty
3483 local.bibliorelation.types = notAllowed
3484 bibliorelation.type.attrib =
3485   attribute type {
3486     "isversionof"
3487     | "hasversion"
3488     | "isreplacedby"
3489     | "replaces"
3490     | "isrequiredby"
3491     | "requires"
3492     | "ispartof"
3493     | "haspart"
3494     | "isreferencedby"
3495     | "references"
3496     | "isformatof"
3497     | "hasformat"
3498     | "othertype"
3499     | local.bibliorelation.types
3500   }?,
3501   attribute othertype { text }?
3502 bibliorelation.role.attrib = role.attrib
3503 bibliorelation =
3504   element bibliorelation { bibliorelation.attlist, docinfo.char.mix* }
3505 # end of bibliorelation.element
3506 bibliorelation.attlist &=
3507   biblio.class.attrib,
3508   bibliorelation.type.attrib,
3509   common.attrib,
3510   bibliorelation.role.attrib,
3511   local.bibliorelation.attrib
3512 # end of bibliorelation.attlist
3513
3514 # end of bibliorelation.module
3515
3516 # BiblioCoverage .................
3517 local.bibliocoverage.attrib = empty
3518 bibliocoverage.role.attrib = role.attrib
3519 bibliocoverage =
3520   element bibliocoverage { bibliocoverage.attlist, docinfo.char.mix* }
3521 # end of bibliocoverage.element
3522 bibliocoverage.attlist &=
3523   attribute spatial {
3524     "dcmipoint" | "iso3166" | "dcmibox" | "tgn" | "otherspatial"
3525   }?,
3526   attribute otherspatial { text }?,
3527   attribute temporal { "dcmiperiod" | "w3c-dtf" | "othertemporal" }?,
3528   attribute othertemporal { text }?,
3529   common.attrib,
3530   bibliocoverage.role.attrib,
3531   local.bibliocoverage.attrib
3532 # end of bibliocoverage.attlist
3533
3534 # end of bibliocoverage.module
3535
3536 # InvPartNumber ....................
3537 local.invpartnumber.attrib = empty
3538 invpartnumber.role.attrib = role.attrib
3539 invpartnumber =
3540   element invpartnumber { invpartnumber.attlist, docinfo.char.mix* }
3541 # end of invpartnumber.element
3542 invpartnumber.attlist &=
3543   common.attrib, invpartnumber.role.attrib, local.invpartnumber.attrib
3544 # end of invpartnumber.attlist
3545
3546 # end of invpartnumber.module
3547
3548 # IssueNum .........................
3549 local.issuenum.attrib = empty
3550 issuenum.role.attrib = role.attrib
3551 issuenum = element issuenum { issuenum.attlist, docinfo.char.mix* }
3552 # end of issuenum.element
3553 issuenum.attlist &=
3554   common.attrib, issuenum.role.attrib, local.issuenum.attrib
3555 # end of issuenum.attlist
3556
3557 # end of issuenum.module
3558
3559 # LegalNotice ......................
3560 local.legalnotice.attrib = empty
3561 legalnotice.role.attrib = role.attrib
3562 legalnotice =
3563   element legalnotice {
3564     legalnotice.attlist, blockinfo?, title?, legalnotice.mix+
3565   }
3566 # end of legalnotice.element
3567 legalnotice.attlist &=
3568   common.attrib, legalnotice.role.attrib, local.legalnotice.attrib
3569 # end of legalnotice.attlist
3570
3571 # end of legalnotice.module
3572
3573 # ModeSpec .........................
3574 local.modespec.attrib = empty
3575 modespec.role.attrib = role.attrib
3576 modespec = element modespec { modespec.attlist, docinfo.char.mix* }
3577 # end of modespec.element
3578
3579 # Application: Type of action required for completion
3580 # of the links to which the ModeSpec is relevant (e.g.,
3581 # retrieval query)
3582 modespec.attlist &=
3583   attribute application { notation.class }?,
3584   common.attrib,
3585   modespec.role.attrib,
3586   local.modespec.attrib
3587 # end of modespec.attlist
3588
3589 # end of modespec.module
3590
3591 # OrgName ..........................
3592 local.orgname.attrib = empty
3593 orgname.role.attrib = role.attrib
3594 orgname = element orgname { orgname.attlist, docinfo.char.mix* }
3595 # end of orgname.element
3596 orgname.attlist &=
3597   common.attrib,
3598   attribute class {
3599     "corporation" | "nonprofit" | "consortium" | "informal" | "other"
3600   }?,
3601   attribute otherclass { text }?,
3602   orgname.role.attrib,
3603   local.orgname.attrib
3604 # end of orgname.attlist
3605
3606 # end of orgname.module
3607
3608 # OtherCredit ......................
3609 local.othercredit.attrib = empty
3610 othercredit.role.attrib = role.attrib
3611 othercredit =
3612   element othercredit {
3613     othercredit.attlist,
3614     (personname | person.ident.mix+),
3615     (personblurb | email | address)*
3616   }
3617 # end of othercredit.element
3618 othercredit.attlist &=
3619   common.attrib, othercredit.role.attrib, local.othercredit.attrib
3620 # end of othercredit.attlist
3621
3622 # (see "Personal identity elements" for %person.ident.mix;)
3623
3624 # end of othercredit.module
3625
3626 # PageNums .........................
3627 local.pagenums.attrib = empty
3628 pagenums.role.attrib = role.attrib
3629 pagenums = element pagenums { pagenums.attlist, docinfo.char.mix* }
3630 # end of pagenums.element
3631 pagenums.attlist &=
3632   common.attrib, pagenums.role.attrib, local.pagenums.attrib
3633 # end of pagenums.attlist
3634
3635 # end of pagenums.module
3636
3637 # Personal identity elements .......
3638
3639 # These elements are used only within Author, Editor, and
3640 # OtherCredit.
3641 local.contrib.attrib = empty
3642 contrib.role.attrib = role.attrib
3643 contrib = element contrib { contrib.attlist, docinfo.char.mix* }
3644 # end of contrib.element
3645 contrib.attlist &=
3646   common.attrib, contrib.role.attrib, local.contrib.attrib
3647 # end of contrib.attlist
3648
3649 # end of contrib.module
3650 local.firstname.attrib = empty
3651 firstname.role.attrib = role.attrib
3652 firstname = element firstname { firstname.attlist, docinfo.char.mix* }
3653 # end of firstname.element
3654 firstname.attlist &=
3655   common.attrib, firstname.role.attrib, local.firstname.attrib
3656 # end of firstname.attlist
3657
3658 # end of firstname.module
3659 local.honorific.attrib = empty
3660 honorific.role.attrib = role.attrib
3661 honorific = element honorific { honorific.attlist, docinfo.char.mix* }
3662 # end of honorific.element
3663 honorific.attlist &=
3664   common.attrib, honorific.role.attrib, local.honorific.attrib
3665 # end of honorific.attlist
3666
3667 # end of honorific.module
3668 local.lineage.attrib = empty
3669 lineage.role.attrib = role.attrib
3670 lineage = element lineage { lineage.attlist, docinfo.char.mix* }
3671 # end of lineage.element
3672 lineage.attlist &=
3673   common.attrib, lineage.role.attrib, local.lineage.attrib
3674 # end of lineage.attlist
3675
3676 # end of lineage.module
3677 local.othername.attrib = empty
3678 othername.role.attrib = role.attrib
3679 othername = element othername { othername.attlist, docinfo.char.mix* }
3680 # end of othername.element
3681 othername.attlist &=
3682   common.attrib, othername.role.attrib, local.othername.attrib
3683 # end of othername.attlist
3684
3685 # end of othername.module
3686 local.surname.attrib = empty
3687 surname.role.attrib = role.attrib
3688 surname = element surname { surname.attlist, docinfo.char.mix* }
3689 # end of surname.element
3690 surname.attlist &=
3691   common.attrib, surname.role.attrib, local.surname.attrib
3692 # end of surname.attlist
3693
3694 # end of surname.module
3695
3696 # end of person.ident.module
3697
3698 # PrintHistory .....................
3699 local.printhistory.attrib = empty
3700 printhistory.role.attrib = role.attrib
3701 printhistory =
3702   element printhistory { printhistory.attlist, para.class+ }
3703 # end of printhistory.element
3704 printhistory.attlist &=
3705   common.attrib, printhistory.role.attrib, local.printhistory.attrib
3706 # end of printhistory.attlist
3707
3708 # end of printhistory.module
3709
3710 # ProductName ......................
3711 local.productname.attrib = empty
3712 productname.role.attrib = role.attrib
3713 productname =
3714   element productname { productname.attlist, para.char.mix* }
3715 # end of productname.element
3716
3717 # Class: More precisely identifies the item the element names
3718 productname.attlist &=
3719   [ a:defaultValue = "trade" ]
3720   attribute class { "service" | "trade" | "registered" | "copyright" }?,
3721   common.attrib,
3722   productname.role.attrib,
3723   local.productname.attrib
3724 # end of productname.attlist
3725
3726 # end of productname.module
3727
3728 # ProductNumber ....................
3729 local.productnumber.attrib = empty
3730 productnumber.role.attrib = role.attrib
3731 productnumber =
3732   element productnumber { productnumber.attlist, docinfo.char.mix* }
3733 # end of productnumber.element
3734 productnumber.attlist &=
3735   common.attrib, productnumber.role.attrib, local.productnumber.attrib
3736 # end of productnumber.attlist
3737
3738 # end of productnumber.module
3739
3740 # PubDate ..........................
3741 local.pubdate.attrib = empty
3742 pubdate.role.attrib = role.attrib
3743 pubdate = element pubdate { pubdate.attlist, docinfo.char.mix* }
3744 # end of pubdate.element
3745 pubdate.attlist &=
3746   common.attrib, pubdate.role.attrib, local.pubdate.attrib
3747 # end of pubdate.attlist
3748
3749 # end of pubdate.module
3750
3751 # Publisher ........................
3752 local.publisher.attrib = empty
3753 publisher.role.attrib = role.attrib
3754 publisher =
3755   element publisher { publisher.attlist, publishername, address* }
3756 # end of publisher.element
3757 publisher.attlist &=
3758   common.attrib, publisher.role.attrib, local.publisher.attrib
3759 # end of publisher.attlist
3760
3761 # end of publisher.module
3762 local.publishername.attrib = empty
3763 publishername.role.attrib = role.attrib
3764 publishername =
3765   element publishername { publishername.attlist, docinfo.char.mix* }
3766 # end of publishername.element
3767 publishername.attlist &=
3768   common.attrib, publishername.role.attrib, local.publishername.attrib
3769 # end of publishername.attlist
3770
3771 # end of publishername.module
3772
3773 #  Address (defined elsewhere in this section)
3774
3775 # end of publisher.content.module
3776
3777 # PubsNumber .......................
3778 local.pubsnumber.attrib = empty
3779 pubsnumber.role.attrib = role.attrib
3780 pubsnumber =
3781   element pubsnumber { pubsnumber.attlist, docinfo.char.mix* }
3782 # end of pubsnumber.element
3783 pubsnumber.attlist &=
3784   common.attrib, pubsnumber.role.attrib, local.pubsnumber.attrib
3785 # end of pubsnumber.attlist
3786
3787 # end of pubsnumber.module
3788
3789 # ReleaseInfo ......................
3790 local.releaseinfo.attrib = empty
3791 releaseinfo.role.attrib = role.attrib
3792 releaseinfo =
3793   element releaseinfo { releaseinfo.attlist, docinfo.char.mix* }
3794 # end of releaseinfo.element
3795 releaseinfo.attlist &=
3796   common.attrib, releaseinfo.role.attrib, local.releaseinfo.attrib
3797 # end of releaseinfo.attlist
3798
3799 # end of releaseinfo.module
3800
3801 # RevHistory .......................
3802 local.revhistory.attrib = empty
3803 revhistory.role.attrib = role.attrib
3804 revhistory = element revhistory { revhistory.attlist, revision+ }
3805 # end of revhistory.element
3806 revhistory.attlist &=
3807   common.attrib, revhistory.role.attrib, local.revhistory.attrib
3808 # end of revhistory.attlist
3809
3810 # end of revhistory.module
3811 local.revision.attrib = empty
3812 revision.role.attrib = role.attrib
3813 revision =
3814   element revision {
3815     revision.attlist,
3816     revnumber,
3817     date,
3818     authorinitials*,
3819     (revremark | revdescription)?
3820   }
3821 # end of revision.element
3822 revision.attlist &=
3823   common.attrib, revision.role.attrib, local.revision.attrib
3824 # end of revision.attlist
3825
3826 # end of revision.module
3827 local.revnumber.attrib = empty
3828 revnumber.role.attrib = role.attrib
3829 revnumber = element revnumber { revnumber.attlist, docinfo.char.mix* }
3830 # end of revnumber.element
3831 revnumber.attlist &=
3832   common.attrib, revnumber.role.attrib, local.revnumber.attrib
3833 # end of revnumber.attlist
3834
3835 # end of revnumber.module
3836
3837 #  Date (defined elsewhere in this section)
3838
3839 #  AuthorInitials (defined elsewhere in this section)
3840 local.revremark.attrib = empty
3841 revremark.role.attrib = role.attrib
3842 revremark = element revremark { revremark.attlist, docinfo.char.mix* }
3843 # end of revremark.element
3844 revremark.attlist &=
3845   common.attrib, revremark.role.attrib, local.revremark.attrib
3846 # end of revremark.attlist
3847
3848 # end of revremark.module
3849 local.revdescription.attrib = empty
3850 revdescription.role.attrib = role.attrib
3851 revdescription =
3852   element revdescription { revdescription.attlist, revdescription.mix+ }
3853 # end of revdescription.element
3854 revdescription.attlist &=
3855   common.attrib, revdescription.role.attrib, local.revdescription.attrib
3856 # end of revdescription.attlist
3857
3858 # end of revdescription.module
3859
3860 # end of revhistory.content.module
3861
3862 # SeriesVolNums ....................
3863 local.seriesvolnums.attrib = empty
3864 seriesvolnums.role.attrib = role.attrib
3865 seriesvolnums =
3866   element seriesvolnums { seriesvolnums.attlist, docinfo.char.mix* }
3867 # end of seriesvolnums.element
3868 seriesvolnums.attlist &=
3869   common.attrib, seriesvolnums.role.attrib, local.seriesvolnums.attrib
3870 # end of seriesvolnums.attlist
3871
3872 # end of seriesvolnums.module
3873
3874 # VolumeNum ........................
3875 local.volumenum.attrib = empty
3876 volumenum.role.attrib = role.attrib
3877 volumenum = element volumenum { volumenum.attlist, docinfo.char.mix* }
3878 # end of volumenum.element
3879 volumenum.attlist &=
3880   common.attrib, volumenum.role.attrib, local.volumenum.attrib
3881 # end of volumenum.attlist
3882
3883 # end of volumenum.module
3884
3885 # ..................................
3886
3887 # end of docinfo.content.module
3888
3889 # ......................................................................
3890
3891 # Inline, link, and ubiquitous elements ................................
3892
3893 # Technical and computer terms .........................................
3894 local.accel.attrib = empty
3895 accel.role.attrib = role.attrib
3896 accel = element accel { accel.attlist, smallcptr.char.mix* }
3897 # end of accel.element
3898 accel.attlist &= common.attrib, accel.role.attrib, local.accel.attrib
3899 # end of accel.attlist
3900
3901 # end of accel.module
3902 local.action.attrib = empty
3903 action.role.attrib = role.attrib
3904 action = element action { action.attlist, cptr.char.mix* }
3905 # end of action.element
3906 action.attlist &=
3907   moreinfo.attrib,
3908   common.attrib,
3909   action.role.attrib,
3910   local.action.attrib
3911 # end of action.attlist
3912
3913 # end of action.module
3914 local.application.attrib = empty
3915 application.role.attrib = role.attrib
3916 application =
3917   element application { application.attlist, para.char.mix* }
3918 # end of application.element
3919 application.attlist &=
3920   attribute class { "hardware" | "software" }?,
3921   moreinfo.attrib,
3922   common.attrib,
3923   application.role.attrib,
3924   local.application.attrib
3925 # end of application.attlist
3926
3927 # end of application.module
3928 local.classname.attrib = empty
3929 classname.role.attrib = role.attrib
3930 classname = element classname { classname.attlist, smallcptr.char.mix* }
3931 # end of classname.element
3932 classname.attlist &=
3933   common.attrib, classname.role.attrib, local.classname.attrib
3934 # end of classname.attlist
3935
3936 # end of classname.module
3937 local.co.attrib = empty
3938 # CO is a callout area of the LineColumn unit type (a single character
3939 # position); the position is directly indicated by the location of CO.
3940 co.role.attrib = role.attrib
3941 co = element co { co.attlist, empty }
3942 # end of co.element
3943
3944 # bug number/symbol override or initialization
3945
3946 # to any related information
3947 co.attlist &=
3948   label.attrib,
3949   linkends.attrib,
3950   idreq.common.attrib,
3951   co.role.attrib,
3952   local.co.attrib
3953 # end of co.attlist
3954
3955 # end of co.module
3956 local.coref.attrib = empty
3957 # COREF is a reference to a CO
3958 coref.role.attrib = role.attrib
3959 coref = element coref { coref.attlist, empty }
3960 # end of coref.element
3961
3962 # bug number/symbol override or initialization
3963
3964 # to any related information
3965 coref.attlist &=
3966   label.attrib,
3967   linkendreq.attrib,
3968   common.attrib,
3969   coref.role.attrib,
3970   local.coref.attrib
3971 # end of coref.attlist
3972
3973 # end of coref.module
3974 local.command.attrib = empty
3975 command.role.attrib = role.attrib
3976 command = element command { command.attlist, cptr.char.mix* }
3977 # end of command.element
3978 command.attlist &=
3979   moreinfo.attrib,
3980   common.attrib,
3981   command.role.attrib,
3982   local.command.attrib
3983 # end of command.attlist
3984
3985 # end of command.module
3986 local.computeroutput.attrib = empty
3987 computeroutput.role.attrib = role.attrib
3988 computeroutput =
3989   element computeroutput {
3990     computeroutput.attlist, (cptr.char.mix | co)*
3991   }
3992 # end of computeroutput.element
3993 computeroutput.attlist &=
3994   moreinfo.attrib,
3995   common.attrib,
3996   computeroutput.role.attrib,
3997   local.computeroutput.attrib
3998 # end of computeroutput.attlist
3999
4000 # end of computeroutput.module
4001 local.database.attrib = empty
4002 database.role.attrib = role.attrib
4003 database = element database { database.attlist, cptr.char.mix* }
4004 # end of database.element
4005
4006 # Class: Type of database the element names; no default
4007 database.attlist &=
4008   attribute class {
4009     "name" | "table" | "field" | "key1" | "key2" | "record"
4010   }?,
4011   moreinfo.attrib,
4012   common.attrib,
4013   database.role.attrib,
4014   local.database.attrib
4015 # end of database.attlist
4016
4017 # end of database.module
4018 local.email.attrib = empty
4019 email.role.attrib = role.attrib
4020 email = element email { email.attlist, docinfo.char.mix* }
4021 # end of email.element
4022 email.attlist &= common.attrib, email.role.attrib, local.email.attrib
4023 # end of email.attlist
4024
4025 # end of email.module
4026 local.envar.attrib = empty
4027 envar.role.attrib = role.attrib
4028 envar = element envar { envar.attlist, smallcptr.char.mix* }
4029 # end of envar.element
4030 envar.attlist &= common.attrib, envar.role.attrib, local.envar.attrib
4031 # end of envar.attlist
4032
4033 # end of envar.module
4034 local.errorcode.attrib = empty
4035 errorcode.role.attrib = role.attrib
4036 errorcode = element errorcode { errorcode.attlist, smallcptr.char.mix* }
4037 # end of errorcode.element
4038 errorcode.attlist &=
4039   moreinfo.attrib,
4040   common.attrib,
4041   errorcode.role.attrib,
4042   local.errorcode.attrib
4043 # end of errorcode.attlist
4044
4045 # end of errorcode.module
4046 local.errorname.attrib = empty
4047 errorname.role.attrib = role.attrib
4048 errorname = element errorname { errorname.attlist, smallcptr.char.mix* }
4049 # end of errorname.element
4050 errorname.attlist &=
4051   common.attrib, errorname.role.attrib, local.errorname.attrib
4052 # end of errorname.attlist
4053
4054 # end of errorname.module
4055 local.errortext.attrib = empty
4056 errortext.role.attrib = role.attrib
4057 errortext = element errortext { errortext.attlist, smallcptr.char.mix* }
4058 # end of errortext.element
4059 errortext.attlist &=
4060   common.attrib, errortext.role.attrib, local.errortext.attrib
4061 # end of errortext.attlist
4062
4063 # end of errortext.module
4064 local.errortype.attrib = empty
4065 errortype.role.attrib = role.attrib
4066 errortype = element errortype { errortype.attlist, smallcptr.char.mix* }
4067 # end of errortype.element
4068 errortype.attlist &=
4069   common.attrib, errortype.role.attrib, local.errortype.attrib
4070 # end of errortype.attlist
4071
4072 # end of errortype.module
4073 local.filename.attrib = empty
4074 filename.role.attrib = role.attrib
4075 filename = element filename { filename.attlist, cptr.char.mix* }
4076 # end of filename.element
4077
4078 # Class: Type of filename the element names; no default
4079
4080 # Path: Search path (possibly system-specific) in which
4081 # file can be found
4082 filename.attlist &=
4083   attribute class {
4084     "headerfile"
4085     | "partition"
4086     | "devicefile"
4087     | "libraryfile"
4088     | "directory"
4089     | "extension"
4090     | "symlink"
4091   }?,
4092   attribute path { text }?,
4093   moreinfo.attrib,
4094   common.attrib,
4095   filename.role.attrib,
4096   local.filename.attrib
4097 # end of filename.attlist
4098
4099 # end of filename.module
4100 local.function.attrib = empty
4101 function.role.attrib = role.attrib
4102 function = element function { function.attlist, cptr.char.mix* }
4103 # end of function.element
4104 function.attlist &=
4105   moreinfo.attrib,
4106   common.attrib,
4107   function.role.attrib,
4108   local.function.attrib
4109 # end of function.attlist
4110
4111 # end of function.module
4112 local.guibutton.attrib = empty
4113 guibutton.role.attrib = role.attrib
4114 guibutton =
4115   element guibutton { guibutton.attlist, (smallcptr.char.mix | accel)* }
4116 # end of guibutton.element
4117 guibutton.attlist &=
4118   moreinfo.attrib,
4119   common.attrib,
4120   guibutton.role.attrib,
4121   local.guibutton.attrib
4122 # end of guibutton.attlist
4123
4124 # end of guibutton.module
4125 local.guiicon.attrib = empty
4126 guiicon.role.attrib = role.attrib
4127 guiicon =
4128   element guiicon { guiicon.attlist, (smallcptr.char.mix | accel)* }
4129 # end of guiicon.element
4130 guiicon.attlist &=
4131   moreinfo.attrib,
4132   common.attrib,
4133   guiicon.role.attrib,
4134   local.guiicon.attrib
4135 # end of guiicon.attlist
4136
4137 # end of guiicon.module
4138 local.guilabel.attrib = empty
4139 guilabel.role.attrib = role.attrib
4140 guilabel =
4141   element guilabel { guilabel.attlist, (smallcptr.char.mix | accel)* }
4142 # end of guilabel.element
4143 guilabel.attlist &=
4144   moreinfo.attrib,
4145   common.attrib,
4146   guilabel.role.attrib,
4147   local.guilabel.attrib
4148 # end of guilabel.attlist
4149
4150 # end of guilabel.module
4151 local.guimenu.attrib = empty
4152 guimenu.role.attrib = role.attrib
4153 guimenu =
4154   element guimenu { guimenu.attlist, (smallcptr.char.mix | accel)* }
4155 # end of guimenu.element
4156 guimenu.attlist &=
4157   moreinfo.attrib,
4158   common.attrib,
4159   guimenu.role.attrib,
4160   local.guimenu.attrib
4161 # end of guimenu.attlist
4162
4163 # end of guimenu.module
4164 local.guimenuitem.attrib = empty
4165 guimenuitem.role.attrib = role.attrib
4166 guimenuitem =
4167   element guimenuitem {
4168     guimenuitem.attlist, (smallcptr.char.mix | accel)*
4169   }
4170 # end of guimenuitem.element
4171 guimenuitem.attlist &=
4172   moreinfo.attrib,
4173   common.attrib,
4174   guimenuitem.role.attrib,
4175   local.guimenuitem.attrib
4176 # end of guimenuitem.attlist
4177
4178 # end of guimenuitem.module
4179 local.guisubmenu.attrib = empty
4180 guisubmenu.role.attrib = role.attrib
4181 guisubmenu =
4182   element guisubmenu {
4183     guisubmenu.attlist, (smallcptr.char.mix | accel)*
4184   }
4185 # end of guisubmenu.element
4186 guisubmenu.attlist &=
4187   moreinfo.attrib,
4188   common.attrib,
4189   guisubmenu.role.attrib,
4190   local.guisubmenu.attrib
4191 # end of guisubmenu.attlist
4192
4193 # end of guisubmenu.module
4194 local.hardware.attrib = empty
4195 hardware.role.attrib = role.attrib
4196 hardware = element hardware { hardware.attlist, cptr.char.mix* }
4197 # end of hardware.element
4198 hardware.attlist &=
4199   moreinfo.attrib,
4200   common.attrib,
4201   hardware.role.attrib,
4202   local.hardware.attrib
4203 # end of hardware.attlist
4204
4205 # end of hardware.module
4206 local.interface.attrib = empty
4207 interface.role.attrib = role.attrib
4208 interface =
4209   element interface { interface.attlist, (smallcptr.char.mix | accel)* }
4210 # end of interface.element
4211
4212 # Class: Type of the Interface item; no default
4213 interface.attlist &=
4214   moreinfo.attrib,
4215   common.attrib,
4216   interface.role.attrib,
4217   local.interface.attrib
4218 # end of interface.attlist
4219
4220 # end of interface.module
4221 local.keycap.attrib = empty
4222 keycap.role.attrib = role.attrib
4223 keycap = element keycap { keycap.attlist, cptr.char.mix* }
4224 # end of keycap.element
4225 keycap.attlist &=
4226   moreinfo.attrib,
4227   common.attrib,
4228   keycap.role.attrib,
4229   local.keycap.attrib
4230 # end of keycap.attlist
4231
4232 # end of keycap.module
4233 local.keycode.attrib = empty
4234 keycode.role.attrib = role.attrib
4235 keycode = element keycode { keycode.attlist, smallcptr.char.mix* }
4236 # end of keycode.element
4237 keycode.attlist &=
4238   common.attrib, keycode.role.attrib, local.keycode.attrib
4239 # end of keycode.attlist
4240
4241 # end of keycode.module
4242 local.keycombo.attrib = empty
4243 keycombo.role.attrib = role.attrib
4244 keycombo =
4245   element keycombo {
4246     keycombo.attlist, (keycap | keycombo | keysym | mousebutton)+
4247   }
4248 # end of keycombo.element
4249 keycombo.attlist &=
4250   keyaction.attrib,
4251   moreinfo.attrib,
4252   common.attrib,
4253   keycombo.role.attrib,
4254   local.keycombo.attrib
4255 # end of keycombo.attlist
4256
4257 # end of keycombo.module
4258 local.keysym.attrib = empty
4259 keysysm.role.attrib = role.attrib
4260 keysym = element keysym { keysym.attlist, smallcptr.char.mix* }
4261 # end of keysym.element
4262 keysym.attlist &=
4263   common.attrib, keysysm.role.attrib, local.keysym.attrib
4264 # end of keysym.attlist
4265
4266 # end of keysym.module
4267 local.lineannotation.attrib = empty
4268 lineannotation.role.attrib = role.attrib
4269 lineannotation =
4270   element lineannotation { lineannotation.attlist, para.char.mix* }
4271 # end of lineannotation.element
4272 lineannotation.attlist &=
4273   common.attrib, lineannotation.role.attrib, local.lineannotation.attrib
4274 # end of lineannotation.attlist
4275
4276 # end of lineannotation.module
4277 local.literal.attrib = empty
4278 literal.role.attrib = role.attrib
4279 literal = element literal { literal.attlist, cptr.char.mix* }
4280 # end of literal.element
4281 literal.attlist &=
4282   moreinfo.attrib,
4283   common.attrib,
4284   literal.role.attrib,
4285   local.literal.attrib
4286 # end of literal.attlist
4287
4288 # end of literal.module
4289 local.constant.attrib = empty
4290 constant.role.attrib = role.attrib
4291 constant = element constant { constant.attlist, smallcptr.char.mix* }
4292 # end of constant.element
4293 constant.attlist &=
4294   attribute class { "limit" }?,
4295   common.attrib,
4296   constant.role.attrib,
4297   local.constant.attrib
4298 # end of constant.attlist
4299
4300 # end of constant.module
4301 local.varname.attrib = empty
4302 varname.role.attrib = role.attrib
4303 varname = element varname { varname.attlist, smallcptr.char.mix* }
4304 # end of varname.element
4305 varname.attlist &=
4306   common.attrib, varname.role.attrib, local.varname.attrib
4307 # end of varname.attlist
4308
4309 # end of varname.module
4310 local.markup.attrib = empty
4311 markup.role.attrib = role.attrib
4312 markup = element markup { markup.attlist, smallcptr.char.mix* }
4313 # end of markup.element
4314 markup.attlist &= common.attrib, markup.role.attrib, local.markup.attrib
4315 # end of markup.attlist
4316
4317 # end of markup.module
4318 local.medialabel.attrib = empty
4319 medialabel.role.attrib = role.attrib
4320 medialabel =
4321   element medialabel { medialabel.attlist, smallcptr.char.mix* }
4322 # end of medialabel.element
4323
4324 # Class: Type of medium named by the element; no default
4325 medialabel.attlist &=
4326   attribute class { "cartridge" | "cdrom" | "disk" | "tape" }?,
4327   common.attrib,
4328   medialabel.role.attrib,
4329   local.medialabel.attrib
4330 # end of medialabel.attlist
4331
4332 # end of medialabel.module
4333 local.menuchoice.attrib = empty
4334 menuchoice.role.attrib = role.attrib
4335 menuchoice =
4336   element menuchoice {
4337     menuchoice.attlist,
4338     shortcut?,
4339     (guibutton
4340      | guiicon
4341      | guilabel
4342      | guimenu
4343      | guimenuitem
4344      | guisubmenu
4345      | interface)+
4346   }
4347 # end of menuchoice.element
4348 menuchoice.attlist &=
4349   moreinfo.attrib,
4350   common.attrib,
4351   menuchoice.role.attrib,
4352   local.menuchoice.attrib
4353 # end of menuchoice.attlist
4354
4355 # end of menuchoice.module
4356
4357 # See also KeyCombo
4358 local.shortcut.attrib = empty
4359 shortcut.role.attrib = role.attrib
4360 shortcut =
4361   element shortcut {
4362     shortcut.attlist, (keycap | keycombo | keysym | mousebutton)+
4363   }
4364 # end of shortcut.element
4365 shortcut.attlist &=
4366   keyaction.attrib,
4367   moreinfo.attrib,
4368   common.attrib,
4369   shortcut.role.attrib,
4370   local.shortcut.attrib
4371 # end of shortcut.attlist
4372
4373 # end of shortcut.module
4374
4375 # end of menuchoice.content.module
4376 local.mousebutton.attrib = empty
4377 mousebutton.role.attrib = role.attrib
4378 mousebutton =
4379   element mousebutton { mousebutton.attlist, smallcptr.char.mix* }
4380 # end of mousebutton.element
4381 mousebutton.attlist &=
4382   moreinfo.attrib,
4383   common.attrib,
4384   mousebutton.role.attrib,
4385   local.mousebutton.attrib
4386 # end of mousebutton.attlist
4387
4388 # end of mousebutton.module
4389 local.msgtext.attrib = empty
4390 msgtext.role.attrib = role.attrib
4391 msgtext = element msgtext { msgtext.attlist, component.mix+ }
4392 # end of msgtext.element
4393 msgtext.attlist &=
4394   common.attrib, msgtext.role.attrib, local.msgtext.attrib
4395 # end of msgtext.attlist
4396
4397 # end of msgtext.module
4398 local.option.attrib = empty
4399 option.role.attrib = role.attrib
4400 option = element option { option.attlist, cptr.char.mix* }
4401 # end of option.element
4402 option.attlist &= common.attrib, option.role.attrib, local.option.attrib
4403 # end of option.attlist
4404
4405 # end of option.module
4406 local.optional.attrib = empty
4407 optional.role.attrib = role.attrib
4408 optional = element optional { optional.attlist, cptr.char.mix* }
4409 # end of optional.element
4410 optional.attlist &=
4411   common.attrib, optional.role.attrib, local.optional.attrib
4412 # end of optional.attlist
4413
4414 # end of optional.module
4415 local.parameter.attrib = empty
4416 parameter.role.attrib = role.attrib
4417 parameter = element parameter { parameter.attlist, cptr.char.mix* }
4418 # end of parameter.element
4419
4420 # Class: Type of the Parameter; no default
4421 parameter.attlist &=
4422   attribute class { "command" | "function" | "option" }?,
4423   moreinfo.attrib,
4424   common.attrib,
4425   parameter.role.attrib,
4426   local.parameter.attrib
4427 # end of parameter.attlist
4428
4429 # end of parameter.module
4430 local.prompt.attrib = empty
4431 prompt.role.attrib = role.attrib
4432 prompt = element prompt { prompt.attlist, (smallcptr.char.mix | co)* }
4433 # end of prompt.element
4434 prompt.attlist &=
4435   moreinfo.attrib,
4436   common.attrib,
4437   prompt.role.attrib,
4438   local.prompt.attrib
4439 # end of prompt.attlist
4440
4441 # end of prompt.module
4442 local.property.attrib = empty
4443 property.role.attrib = role.attrib
4444 property = element property { property.attlist, cptr.char.mix* }
4445 # end of property.element
4446 property.attlist &=
4447   moreinfo.attrib,
4448   common.attrib,
4449   property.role.attrib,
4450   local.property.attrib
4451 # end of property.attlist
4452
4453 # end of property.module
4454 local.replaceable.attrib = empty
4455 replaceable.role.attrib = role.attrib
4456 replaceable =
4457   element replaceable {
4458     replaceable.attlist,
4459     (text
4460      | link.char.class
4461      | optional
4462      | base.char.class
4463      | other.char.class
4464      | inlinegraphic
4465      | inlinemediaobject
4466      | co)*
4467   }
4468 # end of replaceable.element
4469
4470 # Class: Type of information the element represents; no
4471 # default
4472 replaceable.attlist &=
4473   attribute class { "command" | "function" | "option" | "parameter" }?,
4474   common.attrib,
4475   replaceable.role.attrib,
4476   local.replaceable.attrib
4477 # end of replaceable.attlist
4478
4479 # end of replaceable.module
4480 local.returnvalue.attrib = empty
4481 returnvalue.role.attrib = role.attrib
4482 returnvalue =
4483   element returnvalue { returnvalue.attlist, smallcptr.char.mix* }
4484 # end of returnvalue.element
4485 returnvalue.attlist &=
4486   common.attrib, returnvalue.role.attrib, local.returnvalue.attrib
4487 # end of returnvalue.attlist
4488
4489 # end of returnvalue.module
4490 local.sgmltag.attrib = empty
4491 sgmltag.role.attrib = role.attrib
4492 sgmltag = element sgmltag { sgmltag.attlist, smallcptr.char.mix* }
4493 # end of sgmltag.element
4494
4495 # Class: Type of SGML construct the element names; no default
4496 sgmltag.attlist &=
4497   attribute class {
4498     "attribute"
4499     | "attvalue"
4500     | "element"
4501     | "endtag"
4502     | "emptytag"
4503     | "genentity"
4504     | "numcharref"
4505     | "paramentity"
4506     | "pi"
4507     | "xmlpi"
4508     | "starttag"
4509     | "sgmlcomment"
4510   }?,
4511   common.attrib,
4512   sgmltag.role.attrib,
4513   local.sgmltag.attrib
4514 # end of sgmltag.attlist
4515
4516 # end of sgmltag.module
4517 local.structfield.attrib = empty
4518 structfield.role.attrib = role.attrib
4519 structfield =
4520   element structfield { structfield.attlist, smallcptr.char.mix* }
4521 # end of structfield.element
4522 structfield.attlist &=
4523   common.attrib, structfield.role.attrib, local.structfield.attrib
4524 # end of structfield.attlist
4525
4526 # end of structfield.module
4527 local.structname.attrib = empty
4528 structname.role.attrib = role.attrib
4529 structname =
4530   element structname { structname.attlist, smallcptr.char.mix* }
4531 # end of structname.element
4532 structname.attlist &=
4533   common.attrib, structname.role.attrib, local.structname.attrib
4534 # end of structname.attlist
4535
4536 # end of structname.module
4537 local.symbol.attrib = empty
4538 symbol.role.attrib = role.attrib
4539 symbol = element symbol { symbol.attlist, smallcptr.char.mix* }
4540 # end of symbol.element
4541
4542 # Class: Type of symbol; no default
4543 symbol.attlist &=
4544   attribute class { "limit" }?,
4545   common.attrib,
4546   symbol.role.attrib,
4547   local.symbol.attrib
4548 # end of symbol.attlist
4549
4550 # end of symbol.module
4551 local.systemitem.attrib = empty
4552 systemitem.role.attrib = role.attrib
4553 systemitem =
4554   element systemitem {
4555     systemitem.attlist, (cptr.char.mix | acronym | co)*
4556   }
4557 # end of systemitem.element
4558
4559 # Class: Type of system item the element names; no default
4560 systemitem.attlist &=
4561   attribute class {
4562     "constant"
4563     | "event"
4564     | "eventhandler"
4565     | "domainname"
4566     | "fqdomainname"
4567     | "ipaddress"
4568     | "netmask"
4569     | "etheraddress"
4570     | "groupname"
4571     | "library"
4572     | "macro"
4573     | "osname"
4574     | "filesystem"
4575     | "resource"
4576     | "systemname"
4577     | "username"
4578     | "newsgroup"
4579   }?,
4580   moreinfo.attrib,
4581   common.attrib,
4582   systemitem.role.attrib,
4583   local.systemitem.attrib
4584 # end of systemitem.attlist
4585
4586 # end of systemitem.module
4587 local.token.attrib = empty
4588 token.role.attrib = role.attrib
4589 \token = element token { token.attlist, smallcptr.char.mix* }
4590 # end of token.element
4591 token.attlist &= common.attrib, token.role.attrib, local.token.attrib
4592 # end of token.attlist
4593
4594 # end of token.module
4595 local.type.attrib = empty
4596 type.role.attrib = role.attrib
4597 type = element type { type.attlist, smallcptr.char.mix* }
4598 # end of type.element
4599 type.attlist &= common.attrib, type.role.attrib, local.type.attrib
4600 # end of type.attlist
4601
4602 # end of type.module
4603 local.userinput.attrib = empty
4604 userinput.role.attrib = role.attrib
4605 userinput =
4606   element userinput { userinput.attlist, (cptr.char.mix | co)* }
4607 # end of userinput.element
4608 userinput.attlist &=
4609   moreinfo.attrib,
4610   common.attrib,
4611   userinput.role.attrib,
4612   local.userinput.attrib
4613 # end of userinput.attlist
4614
4615 # end of userinput.module
4616
4617 # General words and phrases ............................................
4618 local.abbrev.attrib = empty
4619 abbrev.role.attrib = role.attrib
4620 abbrev = element abbrev { abbrev.attlist, word.char.mix* }
4621 # end of abbrev.element
4622 abbrev.attlist &= common.attrib, abbrev.role.attrib, local.abbrev.attrib
4623 # end of abbrev.attlist
4624
4625 # end of abbrev.module
4626 local.acronym.attrib = empty
4627 acronym.role.attrib = role.attrib
4628 acronym = element acronym { acronym.attlist, word.char.mix* }
4629 # end of acronym.element
4630 acronym.attlist &=
4631   common.attrib, acronym.role.attrib, local.acronym.attrib
4632 # end of acronym.attlist
4633
4634 # end of acronym.module
4635 local.citation.attrib = empty
4636 citation.role.attrib = role.attrib
4637 citation = element citation { citation.attlist, para.char.mix* }
4638 # end of citation.element
4639 citation.attlist &=
4640   common.attrib, citation.role.attrib, local.citation.attrib
4641 # end of citation.attlist
4642
4643 # end of citation.module
4644 local.citerefentry.attrib = empty
4645 citerefentry.role.attrib = role.attrib
4646 citerefentry =
4647   element citerefentry {
4648     citerefentry.attlist, refentrytitle, manvolnum?
4649   }
4650 # end of citerefentry.element
4651 citerefentry.attlist &=
4652   common.attrib, citerefentry.role.attrib, local.citerefentry.attrib
4653 # end of citerefentry.attlist
4654
4655 # end of citerefentry.module
4656 local.refentrytitle.attrib = empty
4657 refentrytitle.role.attrib = role.attrib
4658 refentrytitle =
4659   element refentrytitle { refentrytitle.attlist, para.char.mix* }
4660 # end of refentrytitle.element
4661 refentrytitle.attlist &=
4662   common.attrib, refentrytitle.role.attrib, local.refentrytitle.attrib
4663 # end of refentrytitle.attlist
4664
4665 # end of refentrytitle.module
4666 local.manvolnum.attrib = empty
4667 namvolnum.role.attrib = role.attrib
4668 manvolnum = element manvolnum { manvolnum.attlist, word.char.mix* }
4669 # end of manvolnum.element
4670 manvolnum.attlist &=
4671   common.attrib, namvolnum.role.attrib, local.manvolnum.attrib
4672 # end of manvolnum.attlist
4673
4674 # end of manvolnum.module
4675 local.citetitle.attrib = empty
4676 citetitle.role.attrib = role.attrib
4677 citetitle = element citetitle { citetitle.attlist, para.char.mix* }
4678 # end of citetitle.element
4679
4680 # Pubwork: Genre of published work cited; no default
4681 citetitle.attlist &=
4682   attribute pubwork {
4683     "article"
4684     | "book"
4685     | "chapter"
4686     | "part"
4687     | "refentry"
4688     | "section"
4689     | "journal"
4690     | "series"
4691     | "set"
4692     | "manuscript"
4693   }?,
4694   common.attrib,
4695   citetitle.role.attrib,
4696   local.citetitle.attrib
4697 # end of citetitle.attlist
4698
4699 # end of citetitle.module
4700 local.emphasis.attrib = empty
4701 emphasis.role.attrib = role.attrib
4702 emphasis = element emphasis { emphasis.attlist, para.char.mix* }
4703 # end of emphasis.element
4704 emphasis.attlist &=
4705   common.attrib, emphasis.role.attrib, local.emphasis.attrib
4706 # end of emphasis.attlist
4707
4708 # end of emphasis.module
4709 local.firstterm.attrib = empty
4710 firstterm.role.attrib = role.attrib
4711 firstterm = element firstterm { firstterm.attlist, word.char.mix* }
4712 # end of firstterm.element
4713
4714 # to GlossEntry or other explanation
4715 firstterm.attlist &=
4716   linkend.attrib,
4717   common.attrib,
4718   firstterm.role.attrib,
4719   local.firstterm.attrib
4720 # end of firstterm.attlist
4721
4722 # end of firstterm.module
4723 local.foreignphrase.attrib = empty
4724 foreignphrase.role.attrib = role.attrib
4725 foreignphrase =
4726   element foreignphrase { foreignphrase.attlist, para.char.mix* }
4727 # end of foreignphrase.element
4728 foreignphrase.attlist &=
4729   common.attrib, foreignphrase.role.attrib, local.foreignphrase.attrib
4730 # end of foreignphrase.attlist
4731
4732 # end of foreignphrase.module
4733 local.glossterm.attrib = empty
4734 glossterm.role.attrib = role.attrib
4735 glossterm = element glossterm { glossterm.attlist, para.char.mix* }
4736 # end of glossterm.element
4737
4738 # to GlossEntry if Glossterm used in text
4739
4740 # BaseForm: Provides the form of GlossTerm to be used
4741 # for indexing
4742 glossterm.attlist &=
4743   linkend.attrib,
4744   attribute baseform { text }?,
4745   common.attrib,
4746   glossterm.role.attrib,
4747   local.glossterm.attrib
4748 # end of glossterm.attlist
4749
4750 # end of glossterm.module
4751 local.phrase.attrib = empty
4752 phrase.role.attrib = role.attrib
4753 phrase = element phrase { phrase.attlist, para.char.mix* }
4754 # end of phrase.element
4755 phrase.attlist &= common.attrib, phrase.role.attrib, local.phrase.attrib
4756 # end of phrase.attlist
4757
4758 # end of phrase.module
4759 local.quote.attrib = empty
4760 quote.role.attrib = role.attrib
4761 quote = element quote { quote.attlist, para.char.mix* }
4762 # end of quote.element
4763 quote.attlist &= common.attrib, quote.role.attrib, local.quote.attrib
4764 # end of quote.attlist
4765
4766 # end of quote.module
4767 local.ssscript.attrib = empty
4768 ssscript.role.attrib = role.attrib
4769 subscript =
4770   element subscript {
4771     subscript.attlist,
4772     (text
4773      | link.char.class
4774      | emphasis
4775      | replaceable
4776      | symbol
4777      | inlinegraphic
4778      | inlinemediaobject
4779      | base.char.class
4780      | other.char.class)*
4781   }
4782 # end of subscript.element
4783 subscript.attlist &=
4784   common.attrib, ssscript.role.attrib, local.ssscript.attrib
4785 # end of subscript.attlist
4786 superscript =
4787   element superscript {
4788     superscript.attlist,
4789     (text
4790      | link.char.class
4791      | emphasis
4792      | replaceable
4793      | symbol
4794      | inlinegraphic
4795      | inlinemediaobject
4796      | base.char.class
4797      | other.char.class)*
4798   }
4799 # end of superscript.element
4800 superscript.attlist &=
4801   common.attrib, ssscript.role.attrib, local.ssscript.attrib
4802 # end of superscript.attlist
4803
4804 # end of ssscript.module
4805 local.trademark.attrib = empty
4806 trademark.role.attrib = role.attrib
4807 trademark =
4808   element trademark {
4809     trademark.attlist,
4810     (text
4811      | link.char.class
4812      | tech.char.class
4813      | base.char.class
4814      | other.char.class
4815      | inlinegraphic
4816      | inlinemediaobject
4817      | emphasis)*
4818   }
4819 # end of trademark.element
4820
4821 # Class: More precisely identifies the item the element names
4822 trademark.attlist &=
4823   [ a:defaultValue = "trade" ]
4824   attribute class { "service" | "trade" | "registered" | "copyright" }?,
4825   common.attrib,
4826   trademark.role.attrib,
4827   local.trademark.attrib
4828 # end of trademark.attlist
4829
4830 # end of trademark.module
4831 local.wordasword.attrib = empty
4832 wordasword.role.attrib = role.attrib
4833 wordasword = element wordasword { wordasword.attlist, word.char.mix* }
4834 # end of wordasword.element
4835 wordasword.attlist &=
4836   common.attrib, wordasword.role.attrib, local.wordasword.attrib
4837 # end of wordasword.attlist
4838
4839 # end of wordasword.module
4840
4841 # Links and cross-references ...........................................
4842 local.link.attrib = empty
4843 link.role.attrib = role.attrib
4844 link = element link { link.attlist, para.char.mix* }
4845 # end of link.element
4846
4847 # Endterm: ID of element containing text that is to be
4848 # fetched from elsewhere in the document to appear as
4849 # the content of this element
4850
4851 # to linked-to object
4852
4853 # Type: Freely assignable parameter
4854 link.attlist &=
4855   attribute endterm { xsd:IDREF }?,
4856   linkendreq.attrib,
4857   attribute type { text }?,
4858   common.attrib,
4859   link.role.attrib,
4860   local.link.attrib
4861 # end of link.attlist
4862
4863 # end of link.module
4864 local.olink.attrib = empty
4865 olink.role.attrib = role.attrib
4866 olink = element olink { olink.attlist, para.char.mix* }
4867 # end of olink.element
4868
4869 # TargetDocEnt: Name of an entity to be the target of the link
4870
4871 # LinkMode: ID of a ModeSpec containing instructions for
4872 # operating on the entity named by TargetDocEnt
4873
4874 # LocalInfo: Information that may be passed to ModeSpec
4875
4876 # Type: Freely assignable parameter
4877 olink.attlist &=
4878   attribute targetdocent { xsd:ENTITY }?,
4879   attribute linkmode { xsd:IDREF }?,
4880   attribute localinfo { text }?,
4881   attribute type { text }?,
4882   attribute targetdoc { text }?,
4883   attribute targetptr { text }?,
4884   common.attrib,
4885   olink.role.attrib,
4886   local.olink.attrib
4887 # end of olink.attlist
4888
4889 # end of olink.module
4890 local.ulink.attrib = empty
4891 ulink.role.attrib = role.attrib
4892 ulink = element ulink { ulink.attlist, para.char.mix* }
4893 # end of ulink.element
4894
4895 # URL: uniform resource locator; the target of the ULink
4896
4897 # Type: Freely assignable parameter
4898 ulink.attlist &=
4899   attribute url { text },
4900   attribute type { text }?,
4901   common.attrib,
4902   ulink.role.attrib,
4903   local.ulink.attrib
4904 # end of ulink.attlist
4905
4906 # end of ulink.module
4907 local.footnoteref.attrib = empty
4908 footnoteref.role.attrib = role.attrib
4909 footnoteref = element footnoteref { footnoteref.attlist, empty }
4910 # end of footnoteref.element
4911
4912 # to footnote content supplied elsewhere
4913 footnoteref.attlist &=
4914   linkendreq.attrib,
4915   label.attrib,
4916   common.attrib,
4917   footnoteref.role.attrib,
4918   local.footnoteref.attrib
4919 # end of footnoteref.attlist
4920
4921 # end of footnoteref.module
4922 local.xref.attrib = empty
4923 xref.role.attrib = role.attrib
4924 xref = element xref { xref.attlist, empty }
4925 # end of xref.element
4926
4927 # Endterm: ID of element containing text that is to be
4928 # fetched from elsewhere in the document to appear as
4929 # the content of this element
4930
4931 # to linked-to object
4932 xref.attlist &=
4933   attribute endterm { xsd:IDREF }?,
4934   linkendreq.attrib,
4935   common.attrib,
4936   xref.role.attrib,
4937   local.xref.attrib
4938 # end of xref.attlist
4939
4940 # end of xref.module
4941
4942 # Ubiquitous elements ..................................................
4943 local.anchor.attrib = empty
4944 anchor.role.attrib = role.attrib
4945 anchor = element anchor { anchor.attlist, empty }
4946 # end of anchor.element
4947
4948 # required
4949
4950 # replaces Lang
4951 anchor.attlist &=
4952   idreq.attrib,
4953   pagenum.attrib,
4954   remap.attrib,
4955   xreflabel.attrib,
4956   revisionflag.attrib,
4957   effectivity.attrib,
4958   anchor.role.attrib,
4959   local.anchor.attrib
4960 # end of anchor.attlist
4961
4962 # end of anchor.module
4963 local.beginpage.attrib = empty
4964 beginpage.role.attrib = role.attrib
4965 beginpage = element beginpage { beginpage.attlist, empty }
4966 # end of beginpage.element
4967
4968 # PageNum: Number of page that begins at this point
4969 beginpage.attlist &=
4970   pagenum.attrib,
4971   common.attrib,
4972   beginpage.role.attrib,
4973   local.beginpage.attrib
4974 # end of beginpage.attlist
4975
4976 # end of beginpage.module
4977
4978 # IndexTerms appear in the text flow for generating or linking an
4979 # index.
4980 local.indexterm.attrib = empty
4981 indexterm.role.attrib = role.attrib
4982 indexterm =
4983   element indexterm {
4984     indexterm.attlist,
4985     primary?,
4986     ((secondary,
4987       ((tertiary, (see | seealso+)?)
4988        | see
4989        | seealso+)?)
4990      | see
4991      | seealso+)?
4992   }
4993 # end of indexterm.element
4994
4995 # Scope: Indicates which generated indices the IndexTerm
4996 # should appear in: Global (whole document set), Local (this
4997 # document only), or All (both)
4998
4999 # Significance: Whether this IndexTerm is the most pertinent
5000 # of its series (Preferred) or not (Normal, the default)
5001
5002 # Class: Indicates type of IndexTerm; default is Singular,
5003 # or EndOfRange if StartRef is supplied; StartOfRange value
5004 # must be supplied explicitly on starts of ranges
5005
5006 # StartRef: ID of the IndexTerm that starts the indexing
5007 # range ended by this IndexTerm
5008
5009 # Zone: IDs of the elements to which the IndexTerm applies,
5010 # and indicates that the IndexTerm applies to those entire
5011 # elements rather than the point at which the IndexTerm
5012 # occurs
5013 indexterm.attlist &=
5014   pagenum.attrib,
5015   attribute scope { "all" | "global" | "local" }?,
5016   [ a:defaultValue = "normal" ]
5017   attribute significance { "preferred" | "normal" }?,
5018   attribute class { "singular" | "startofrange" | "endofrange" }?,
5019   attribute startref { xsd:IDREF }?,
5020   attribute zone { xsd:IDREFS }?,
5021   common.attrib,
5022   indexterm.role.attrib,
5023   local.indexterm.attrib
5024 # end of indexterm.attlist
5025
5026 # end of indexterm.module
5027 local.primsecter.attrib = empty
5028 primsecter.role.attrib = role.attrib
5029 primary = element primary { primary.attlist, ndxterm.char.mix* }
5030 # end of primary.element
5031
5032 # SortAs: Alternate sort string for index sorting, e.g.,
5033 # "fourteen" for an element containing "14"
5034 primary.attlist &=
5035   attribute sortas { text }?,
5036   common.attrib,
5037   primsecter.role.attrib,
5038   local.primsecter.attrib
5039 # end of primary.attlist
5040 secondary = element secondary { secondary.attlist, ndxterm.char.mix* }
5041 # end of secondary.element
5042
5043 # SortAs: Alternate sort string for index sorting, e.g.,
5044 # "fourteen" for an element containing "14"
5045 secondary.attlist &=
5046   attribute sortas { text }?,
5047   common.attrib,
5048   primsecter.role.attrib,
5049   local.primsecter.attrib
5050 # end of secondary.attlist
5051 tertiary = element tertiary { tertiary.attlist, ndxterm.char.mix* }
5052 # end of tertiary.element
5053
5054 # SortAs: Alternate sort string for index sorting, e.g.,
5055 # "fourteen" for an element containing "14"
5056 tertiary.attlist &=
5057   attribute sortas { text }?,
5058   common.attrib,
5059   primsecter.role.attrib,
5060   local.primsecter.attrib
5061 # end of tertiary.attlist
5062
5063 # end of primsecter.module
5064 local.seeseealso.attrib = empty
5065 seeseealso.role.attrib = role.attrib
5066 see = element see { see.attlist, ndxterm.char.mix* }
5067 # end of see.element
5068 see.attlist &=
5069   common.attrib, seeseealso.role.attrib, local.seeseealso.attrib
5070 # end of see.attlist
5071 seealso = element seealso { seealso.attlist, ndxterm.char.mix* }
5072 # end of seealso.element
5073 seealso.attlist &=
5074   common.attrib, seeseealso.role.attrib, local.seeseealso.attrib
5075 # end of seealso.attlist
5076
5077 # end of seeseealso.module
5078
5079 # end of indexterm.content.module
5080
5081 # End of DocBook XML information pool module V4.2 ......................
5082
5083 # ......................................................................