# $Id: tmml.dtd,v 1.8 2002/05/20 20:46:11 jenglish Exp $
# 
# Author:	Joe English, <jenglish@users.sourceforge.net>
# Created:	8 Feb 1999
# Revised:	24 Jul 1999
# Usage:
# 
# <!DOCTYPE  (manpage | manual)  PUBLIC "-//jenglish//DTD TMML 0.6//EN" >
# 
# XML DTD for TMML, Tcl Manual Markup language.
# 
# See  <URL: http://tmml.sourceforge.net/ > for more information

# ============================================================
# 
# Information pool parameter entities:
# 
# e.syntax 	Phrase-level elements that refer to Tcl syntactic entities.
# e.phrase	Other phrase-level elements
# e.block	Block-level elements
# e.struct	Structural elements that can appear directly in a section
# 
# x.block
# x.inline	Used for customization

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

e.syntax =
  m
  | l
  | o
  | i
  | b
  | br
  | term
  | cmd
  | variable
  | method
  | option
  | file
  | syscmd
  | fun
  | widget
  | package
  | type
  | class
e.phrase = emph | ref | url | samp | command | new
e.block =
  p | ul | ol | dl | sl | xl | example | syntax | commandlist | optlist
e.struct = arglist | optionlist
x.inline = notAllowed
x.block = notAllowed
# ============================================================
# Content models:
# 
# m.code	(computer) text
# m.inline	inline text
# m.mixed	mixed inline and block elements
# m.top	top-level elements (inside sections)
m.inline = (text | e.phrase | e.syntax | x.inline)*
m.code = (text | new | e.syntax | x.inline)*
m.mixed = (text | e.phrase | e.syntax | e.block | x.block | x.inline)*
m.top = (e.block | e.struct | x.block)*
# ============================================================
# Common attributes:
a.version = attribute version { text }?
# ============================================================
# Top-level element: manual
m.division =
  title,
  (division* | (manpage | subdoc | extref)*)
m.manual =
  title,
  head?,
  (division* | (manpage | subdoc | extref)*)
manual = element manual { attlist.manual, m.manual }
division = element division { attlist.division, m.division }
attlist.division &= empty
subdoc = element subdoc { attlist.subdoc, empty }
extref = element extref { attlist.extref, empty }
attlist.manual &=
  attribute package { text },
  attribute version { text }?
attlist.extref &=
  attribute href { text },
  attribute title { text },
  attribute type { text }
attlist.subdoc &= attribute href { text }
# ============================================================
# Top-level element: manpage
manpage =
  element manpage {
    attlist.manpage,
    head?,
    namesection,
    synopsis?,
    section*,
    seealso?,
    keywords?
  }
attlist.manpage &=
  attribute id { xsd:ID },
  attribute cat { text },
  attribute title { text },
  attribute package { text }?,
  a.version
section = element section { attlist.section, title, m.top, subsection* }
attlist.section &=
  attribute id { xsd:ID }?,
  a.version
subsection = element subsection { attlist.subsection, title, m.top }
attlist.subsection &=
  attribute id { xsd:ID }?,
  a.version
# ============================================================
# Standard sections:
namesection =
  element namesection {
    attlist.namesection,
    (name+ | (title, name*)),
    desc
  }
attlist.namesection &= empty
synopsis = element synopsis { attlist.synopsis, (syntax | example)+ }
attlist.synopsis &= empty
keywords = element keywords { attlist.keywords, keyword+ }
attlist.keywords &= empty
keyword = element keyword { attlist.keyword, text }
attlist.keyword &= empty
seealso = element seealso { attlist.seealso, (ref | url)+ }
attlist.seealso &= empty
# ============================================================
# Common Constructs
title = element title { attlist.title, text }
attlist.title &= empty
name = element name { attlist.name, text }
desc = element desc { attlist.desc, m.mixed }
attlist.desc &= empty
# OR: desc: %m.inline;  description:  %m.mixed;
attlist.name &=
  attribute name { text }?,
  attribute cat { text }?
# ============================================================
# Block-level elements:
ul = element ul { attlist.ul, li+ }
attlist.ul &= empty
ol = element ol { attlist.ol, li+ }
attlist.ol &= empty
li = element li { attlist.li, m.mixed }
attlist.li &= a.version
sl = element sl { attlist.sl, li+ }
attlist.sl &=
  attribute cols { text }?,
  attribute cat { text }?
dl =
  element dl {
    attlist.dl,
    (dle | (dt, dd))+
  }
dle = element dle { attlist.dle, dt+, dd }
attlist.dle &= a.version
dt = element dt { attlist.dt, m.inline }
attlist.dt &= empty
dd = element dd { attlist.dd, m.mixed }
attlist.dd &= empty
attlist.dl &=
  [ a:defaultValue = "local" ] attribute scope { "local" | "global" }?,
  attribute cat { text }?
# Extended lists:  
# Similar to DocBook SegmentedLists
xl = element xl { attlist.xl, xlh?, xle+ }
attlist.xl &= empty
xlh = element xlh { attlist.xlh, xh+ }
xh = element xh { attlist.xh, m.inline }
attlist.xh &= empty
xle = element xle { attlist.xle, xt+, desc? }
attlist.xle &= empty
xt = element xt { attlist.xt, m.inline }
attlist.xt &= empty
p = element p { attlist.p, m.inline }
attlist.p &= a.version
example = element example { attlist.example, m.code }
attlist.example &= empty
syntax = element syntax { attlist.syntax, m.code }
attlist.syntax &=
  attribute scope { "local" | "global" }?,
  attribute cat { text }?,
  attribute name { text }?
# ============================================================
# Inline elements:
i = element i { attlist.i, m.inline }
attlist.i &= attribute cat { text }?
b = element b { attlist.b, m.inline }
attlist.b &= attribute cat { text }?
emph = element emph { attlist.emph, m.inline }
attlist.emph &= empty
samp = element samp { attlist.samp, m.code }
attlist.samp &= empty
o = element o { attlist.o, m.code }
attlist.o &= empty
url = element url { attlist.url, text }
attlist.url &= empty
ref = element ref { attlist.ref, m.inline }
attlist.ref &=
  attribute refid { text }?,
  attribute href { text }?,
  attribute cat { text }?
# @@ ALSO:
#	package	CDATA	#IMPLIED
#	manpage	CDATA	#IMPLIED
#	cat	CDATA	#IMPLIED
#	name	CDATA	#IMPLIED
# Legal combinations: (package? & ((manpage? & refid?) | (name? & cat?)))
new = element new { attlist.new, m.inline }
attlist.new &= attribute version { text }
br = element br { attlist.br, empty }
attlist.br &= empty
# ============================================================
# Syntax elements:
m = element m { attlist.m, text }
attlist.m &= empty
l = element l { attlist.l, text }
attlist.l &= empty
term = element term { attlist.term, text }
attlist.term &= attribute cat { text }?
cmd = element cmd { attlist.cmd, text }
attlist.cmd &= empty
method = element method { attlist.method, text }
attlist.method &= empty
option = element option { attlist.option, text }
attlist.option &= empty
syscmd = element syscmd { attlist.syscmd, text }
attlist.syscmd &= empty
widget = element widget { attlist.widget, text }
attlist.widget &= empty
fun = element fun { attlist.fun, text }
attlist.fun &= empty
variable = element variable { attlist.variable, text }
attlist.variable &= empty
package = element package { attlist.package, text }
attlist.package &= empty
type = element type { attlist.type, text }
attlist.type &= empty
class = element class { attlist.class, text }
attlist.class &= empty
file = element file { attlist.file, text }
attlist.file &= empty
# ============================================================
# Tcl entity definition elements:
arglist = element arglist { attlist.arglist, argdef+ }
attlist.arglist &= empty
argdef =
  element argdef { attlist.argdef, argtype, name, argmode?, desc }
attlist.argdef &= a.version
argtype = element argtype { attlist.argtype, text }
attlist.argtype &= empty
argmode = element argmode { attlist.argmode, text }
attlist.argmode &= empty
commandlist = element commandlist { attlist.commandlist, commanddef+ }
attlist.commandlist &= empty
commanddef = element commanddef { attlist.commanddef, command, desc }
attlist.commanddef &= a.version
command = element command { attlist.command, m.code }
attlist.command &= empty
optlist = element optlist { attlist.optlist, optdef+ }
attlist.optlist &= empty
optdef = element optdef { attlist.optdef, optname, optarg?, desc }
attlist.optdef &= empty
optname = element optname { attlist.optname, text }
attlist.optname &= empty
optarg = element optarg { attlist.optarg, text }
attlist.optarg &= empty
optionlist = element optionlist { attlist.optionlist, optiondef+ }
optiondef =
  element optiondef { attlist.optiondef, name, dbname, dbclass, desc }
attlist.optiondef &= a.version
dbname = element dbname { attlist.dbname, text }
attlist.dbname &= empty
dbclass = element dbclass { attlist.dbclass, text }
attlist.dbclass &= empty
attlist.optionlist &=
  [ a:defaultValue = "local" ] attribute scope { "local" | "global" }?,
  attribute cat { text }?
# ============================================================
# #FIXED attributes:
# A DTD-aware processor may take advantage of these
# if it simplifies processing.

# ============================================================
# Metainformation:
# Note that these elements do not normally appear
# inside TMML documents; they're for administrative
# purposes only.
head =
  element head { attlist.head, (extensions | info | link | category)* }
attlist.head &= empty
extensions =
  element extensions { attlist.extensions, (extension | xlh)* }
attlist.extensions &= empty
extension = element extension { attlist.extension, empty }
attlist.extension &=
  attribute gi { text },
  attribute tmml { text }
attlist.xlh &= attribute gi { text }?
info = element info { attlist.info, empty }
attlist.info &=
  attribute key { text },
  attribute value { text }
link = element link { attlist.link, empty }
attlist.link &=
  attribute rel { text },
  attribute href { text }
categories = element categories { attlist.categories, category+ }
attlist.categories &= empty
category = element category { attlist.category, empty }
attlist.category &=
  attribute id { xsd:ID },
  attribute title { text }?
INDEX = element INDEX { attlist.INDEX, head?, (MAN | DEF | KWD)* }
attlist.INDEX &=
  attribute title { text },
  attribute standalone { text }?,
  attribute package { text }?
DEF = element DEF { attlist.DEF, empty }
attlist.DEF &=
  attribute name { text },
  attribute cat { text }?,
  attribute package { text }?,
  attribute manpage { text }?,
  attribute subpart { text }?
KWD = element KWD { attlist.KWD, empty }
attlist.KWD &=
  attribute name { text },
  attribute manpage { text }?
MAN = element MAN { attlist.MAN, empty }
attlist.MAN &=
  attribute id { text },
  attribute title { text }
start = INDEX | manual | manpage | categories
# EOF