pax_global_header00006660000000000000000000000064123056255350014520gustar00rootroot0000000000000052 comment=1e43dedd0027c1c371489a55440def09802990c6 cduce-0.6.0/000077500000000000000000000000001230562553500126065ustar00rootroot00000000000000cduce-0.6.0/.gitmodules000066400000000000000000000001141230562553500147570ustar00rootroot00000000000000[submodule "ocaml"] path = ocaml url = https://github.com/ocaml/ocaml.git cduce-0.6.0/AUTHORS000066400000000000000000000005431230562553500136600ustar00rootroot00000000000000Main developer: Alain Frisch Research project leaders, documentation: Alain Frisch Giuseppe Castagna Véronique Benzaken Code contribution: Cédric Miachon (author and maintainer of the CQL subset) Julien Demouth (original implementation of the OCaml/CDuce interface) Stefano Zacchiroli (original implementation of the XML Schema support) cduce-0.6.0/CHANGES000066400000000000000000000254201230562553500136040ustar00rootroot000000000000000.5.5 * Added load_xml_subst and print_xml_subst for namespaces substitution. (necessary for Web Services with OcCDuce and CDuce_WS). 0.5.4 * Added Services for Ocsigen. * Fixed a bug with wildcard for namespaces (ns:*) * Corrected whitespace normalization in atomic types before validation * Fixed 2 bugs in the cduce-ocaml interface * Changed packaging script since it forgot dtd2cduce.ml 0.5.3 * Port to OCaml 3.11 (courtesy of Richard Jones) * fixed to work with ocaml-curl library >= 0.5 - Tools * Fixed dtd2cduce bug when handling of "FIXED" attributes * Fixed bug in building: PXP was not build if GCI not present 0.5.2_1 * Fixed packaging error 0.5.2 - Tools * New Mac OSX build * bugfix in the build. New cgi package optional detection and now the netcgi1 is directly used (fix distributions that provide only netcgi1 and not cgi). 0.5.1 - Tools: * New windows binary package - Implementation: * support for cdata sections * automatic mapping of ocaml data types to cduce types 0.5.0 * Port to OCaml 3.10, with the help of Nicolas Pouillard 0.4.2 - Language: * Added int_of_char - Bug fix: * "match 1 with (x := `nil) -> x" raised an assert failure 0.4.1 - Tools: * Error message when using --mlstub without the built-in OCaml interface * Improvements to the type pretty-printer * "include" uses the -I options - Language: * New Caml_int builtin type * The // construction no longer stops at the first matched subtree on each branch * New "dump_xml" and "dump_xml_utf8", equivalent to the composition of print and print_xml, but more efficient - Implementation: * New subtyping algorithm * Small improvement to the pattern matching compiler * Improve type-checking time for map * Improve type-checking of record expressions * Don't display warnings for unused branches in ghost (generated) pattern matching - Bug fix: * "eval" can now be called several times and use the toplevel environment * use "open_out_bin" (needed for Cygwin installation) * "open" allowed as tag name * exceptions raised by the expat parser and by the dump_to_file primitives are now catchable * work-around the double close bug in OCaml 0.4.0pl1 - Packaging bug 0.4.0 - Adapted to OCaml 3.09. - To build the OCaml/CDuce interface, OCaml sources are now needed. 0.3.92 - Tools: * Build and install dtd2cduce when PXP is available. * Display of location for errors and warnings compatible with OCaml. - Language: * Better error messages for xtransform. - Bug fix: * Forgot PLIST.godi in the package. 0.3.91 - Tools: * Get rid of cdo2ml and mlcduce_wrapper. Now included in cduce. - Bug fix: * Internal uid collision when using OCaml externals. * Makes "String.length" works (String used to resolve to the CDuce type). 0.3.9 - Language: * Added split_atom, make_atom. Removed atom_of. * Added char_of_int built_in function. * Now int_of also accepts octal binary and hexadecimals. * The field access also works for XML element attributes. * More catchable exceptions (for load_xml, load_file, etc). * namespaces, schemas, "using" identifiers are now exported. * "open" statement. - Implementation: * More efficient implementation of records at runtime. * Clean-up of the internal representation. * The XML Schemas are now parsed only at compile time. * The automata for pattern matching are now produced at compile time. - Tools: * The functionality of cdo2ml is now assured by cduce itself, with the --mlstub option. * Remove the --dump option (which was deprecated). * Remove support for sessions in the web prototype. - Bug fixes: * Correct handling of external references with expat. * Installation problem under some BSD (using "install -c"). 0.3.2 * Bug fix in configure 0.3.1 - Bug fix: * configure must not require pxp * inclusion of external entities with expat * META.in, cduce_mktop missing in package * several bugfixes for XML Schema * Adapt to ocaml-expat 0.9.1 * don't build cdo2ml, mlcduce_wrapper when ocaml iface not available - Language: * Can now preserve namespaces when parsing XML or when creating XML elements * "or" is now equivalent to || 0.3.0 - Language: * Warning for capture variables and projections that always return the empty sequence. * Major rewrite of the support for XML Schema * removed print_schema directive * removed the "kind" selector (e.g. S # t as element) * include,import implemented * support wildcards any,anyAttrivbute * support xsi:nil * support xsd:decimal,xsd:float * many bug fixes * Removed the syntax "external {...}", replaced with "unit.val with { ty1 ty2 ... }". * Removed the syntax H:val, replaced with H.val. * Removed the syntax S#t, replaced with S.t. * Overloaded the dot (record field acces, CDuce, OCaml, Schema units). A dot in an identifier must now be escaped with a backslash, e.g. x\.y * Identifiers (for types, values) are now qualified names. * float_of: String -> Float * Syntax modifications for records and attributes: - ".." to denote open record types/patterns: open record: { l1=t1 l2=t2 .. } closed record: { l1=t1 l2=t2 } - the ";" between fields is optional even for records (used to be optional only for attributes) * Keywords are now allowed as type names * Concatenation @ allowed in types * Record concatenation + allowed in types * Changed "string://" URL-pseudo schema to "string:" * Better resolution of external entities for PXP and expat - Tools: * A new tool cduce_mktop produces customized CDuce toplevels with embedded OCaml externals. * Removed the validate tool. * Don't build dtd2cduce by default (it requires PXP). An online version is available at http://www.cduce.org/dtd2cduce.html - Implementation: * Various bug fixes. * More efficient hash-consing of types. * improved #print_type (does not use the abbreviation for the printed type). - Distribution: * MIT license. * CDuce can be built without support for PXP. - CQL: * Rewrote the optimization (pushing projections). * The syntax for "where" clause is now simply an "and"-separated list of conditions ("or" is no longer supported). * Better types for "min","max","distinct_values" operators. 0.2.2 - Language: * Runtime type-check: (e :? t) raises an exception when e doesn't have type t; the exception is an explanation of why this is not the case. (The actual message may change in the future.) * Better return type for load_xml, defined as: AnyXml=<(Atom) (Record)>[ (AnyXml|Char)* ] * New style for comments: /* ... */ Simple and double quotes within these comments are not handled specially. Moreover, these comments cannot be nested. The new style should be used for textual comments (which can include the simple quote); the old style is better for ignoring pieces of code. * Pattern guard /p in regexps to match the current tail. This can be used for setting "markers" without capturing anything, e.g.: [ (/(x:=1) ...) | (/(x:=2) ...) ] Back to the old semantics for default value patterns in regexps (they do capture an element). * New syntax {...; l = p else p'; ... }. p' is applied to the whole matched record when p does not match (or when the field is missing). Equivalent to: { ...; l = p; ...} | ({...;...} & p') * Punning in record/attribute expressions and patterns. { x; y } is a shorthand for {x=x;y=y}. * New syntax for R**n in regular expressions, equivalent to R...R (n times), where n > 0. * Interval arithmetic for the * operator. * Warning for potential division by 0. * New "system", "exit", "getenv" built-in functions. - Toplevel, interpreter, compiler: * New #silent, #verbose directives. * New --script option. * Removed the warning "no caml interface". - Compilation: * Better compilation of sequence capture variables. Now, [ ... x::Any* ] is as efficient as [ ... ; x ]. Can also be written [ ... /x _* ]. The [ ... ; ... ] syntax is no longer necessary and might be deprecated. - Bug fixes, including: * Bug fixes in configure/Makefile for Cygwin. * Bug fix for the compilation of complex patterns with records. * Fixed a little bit support for XML Schema, but still largely broken. * Fix --stdin. * Bug fix in print_xml (do not create a namespace decl for "xml:"). - Distribution: * apps-cduce-cvs GODI package is updatable. * The release tarball does not contain the CDuce website, only the HTML documentation (memento, tutorial, manual). 0.2.1 - string:// scheme for load_xml and others - code updated to OCaml 3.08.1, PXP 1.1.95 - NOTE: support for namespaces in XML Schema may be broken 0.2.0 - OCaml/CDuce interface. - Language: * Support for URLs in load_xml, load_html, load_file, and schemas: e.g. you can write `` load_html "http://www.cduce.org/" '' (need either the ocurl package or the netclient package). * More advanced (and documented) support for XML Schemas. * Preliminary integration of CQL query language that is: select e from p1 in e1, ... ,pn in en where e'. * Allow structured constants in default value patterns (p := c). * Default value patterns in regexps don't consume an element. * Logical operators &&, ||, and not. * New syntax for currified functions fun (p1 : t1)...(pn : tn) : t = ... - Incompatible changes: * argv is now an operator of type [] -> [ String* ]. * The --dump, --load, --save options are deprecated. * Changes to the command line. "--pxp" is replaced with "--no expat". - Implementation: * Code upgraded to Ocaml 3.07. * Major cleaning in progress. * Added internal support for abstract data types. * Using ulex instead of wlex. * Sources can now be in utf8. * Separate compilation. * Lazy implementation of @. - Other: * Added configure script. * Various Makefile improvements. - Bug fixes: * Bug fixes in the parser. Tuples are now ok in regexps. 0.1.1 * Various bug fixes (expat might now work) * Sequencing operator e1;e2 (equivalent to: let [] = e1 in e2) * Encoded references 0.1.0 * Support for XML Namespaces * Better support for expat; clean Makefile * Get rid of ;; and let fun in examples * Optional ; for record in attribute position (values and types/patterns) * Split --dump into --load and --save * Better handling of strings (specific node in AST) * Map, transform: tail-recursive implementation * Preliminary support for XML Schema * Various bug fixes 0.0.91 * Second alpha release * Bug fixes and syntax changes (e.g. making "fun" optional in "let fun") * Experimenting with expat support (see expat/README) 0.0.9 * First public release (alpha release) cduce-0.6.0/INSTALL000066400000000000000000000147521230562553500136500ustar00rootroot00000000000000Installation Notes for CDuce ============================ CDuce is written in the OCaml programming language. It has been successfully compiled under Intel Linux, Mac OSX, SunOS 5.7, FreeBSD 4.7. and Windows XP. (See INSTALL.WIN32 for installation under Windows) ------------------------------------------------------------------------------ Prerequisites ------------------------------------------------------------------------------ An easy way to get a system ready to compile CDuce is to use the GODI distribution: http://www.ocaml-programming.de/godi/ It includes all the mandatory and optional packages listed below, and also the special modules needed to build the OCaml/CDuce interface. Mandatory packages: ------------------- Before compiling CDuce, you need to install recent releases of the following packages: ocaml >= 3.10 http://caml.inria.fr/ocaml/distrib.html findlib >= 1.0.3 http://www.ocaml-programming.de/packages ulex >= 1.0 http://www.cduce.org/download.html pcre-ocaml >= 5.13.0 http://ocaml.info/home/ocaml_sources.html#toc16 ocamlnet >= 0.98 http://www.ocaml-programming.de/packages Additional optional packages: ----------------------------- * You'll probably want to build CDuce with an XML parser. You will need one of: pxp >= 1.1.95 http://www.ocaml-programming.de/packages/documentation/pxp/index_dev.html ocaml-expat >= 0.9.1 http://home.wanadoo.nl/maas/ocaml/ * CDuce can use one the the ocurl and netclient library to fetch external URLs. You will need one of: ocurl >= 0.15 http://sourceforge.net/projects/ocurl/ netclient >= 0.90.1 http://www.ocaml-programming.de/programming/netclient.html netclient support only the http protocol. curl supports in addition https, ftp, and other protocols. Important notes: ---------------- - pcre-ocaml: you may also need to install the PCRE library from http://www.pcre.org/ (use version >=4.4) [red-hat users: pcre (rawhide) packages may not work with the latest pcre-ocaml versions, use tarballs] In this case, configure it with the --enable-utf8 option. >= 5.03 recommended but previous versions may work - PXP: It is enough to build support for UTF8 and ISO-8859-1 ocamllex-lexers: ./configure -without-wlex -without-wlex-compat -lexlist utf8,iso88591 You can also build pxp with wlex support (more compact code). This can be done by installing wlex runtime support library *before* pxp http://www.eleves.ens.fr/home/frisch/soft.html#wlex and build pxp -with-wlex*. When building CDuce you still have the choice whether to use wlex or ocamllex (to choose wlex, do ./configure --with-pxp_wlex or set PXP_WLEX=true in Makefile.conf). - ocurl: you may also need to install libcurl (http://curl.haxx.se/libcurl/) - ocaml-expat: you may also need to install libexpat (http://expat.sourceforge.net/) ------------------------------------------------------------------------------ Compilation ------------------------------------------------------------------------------ There is a configure script. It will check for the presence of mandatory packages, and detect automatically optional ones. It will also set installation directories. Running the script produces a Makefile.conf file. You can get usage information about the script with: ./configure --help Alternatively, it is also possible to copy Makefile.conf.template to Makefile.conf and modify it by hand. The usual command line for configuring and building CDuce: ./configure && make all && make install To see all the configuration options: ./configure --help You need a GNU Make (or equivalent). The Makefile defines the following goals: - make help print a summary of what follows - make all build binaries and libraries (does not build dtd2cduce) - make cduce compiles the CDuce command line interpreter - make dtd2cduce compiles the dtd2cduce tools (converts DTD to CDuce types). The PXP package must be available to build dtd2cduce. If you cannot build dtd2cduce locally, you can use on online version available at this URL: http://www.cduce.org/dtd2cduce.html - make doc compiles in the subdirectory web/doc the HTML documentation for CDuce - make all - make install installs binaries into $(BINDIR), manpages into $(MANDIR)/man1, and registers the cduce_lib library with findlib. - make clean back to the starting point - make uninstall removes installed files ------------------------------------------------------------------------------ Building the CDuce/OCaml interface ------------------------------------------------------------------------------ If you want to build the OCaml/CDuce interface, you need a copy of the OCaml source tree matching your current OCaml version. You must pass the location of this tree to the configure script: ./configure --mliface=$HOME/ocaml-3.09 ------------------------------------------------------------------------------ Note on XML parsers ------------------------------------------------------------------------------ When CDuce is built with support for both expat and PXP, it uses by default expat to parse XML files. You can still use PXP by adding "--no expat" to the CDuce command line. - error messages: The error messages provided by expat when parsing ill-formed XML documents are less informative than those given by PXP. - efficiency: * expat is more efficient than PXP, and produces smaller executables. * for PXP, ocamllex lexers are more efficient than wlex lexers. ------------------------------------------------------------------------------ Compile Cduce 0.5.5 using ocaml 3.12.1 and opam ------------------------------------------------------------------------------ The lastest stable version compatible with ocaml 3.12.1 is cudce 0.5.5 the git branch ocamlinterface is a fork from tag 0.5.5 and links the ocaml source code (tags/3.12.1) via a git submodule. To correctly setup the environment, first you need to switch on the ocamlinterface and setup the ocaml submodule. git clone -b ocamlinterface https://git.cduce.org/cduce git submodule init git submodule update Then using OPAM you need to install and configure the correct compiler and modules needed to build cduce. Ocamlfind will take care of installing the cduce libraries and make them available. ./opam_config.sh 3.12.1 ./configure --mliface=ocaml --prefix=$LOCALSWDIR make make install ocamlfind list | grep cduce find $HOME/.opam/ -name cduce_lib\* which cduce The directory tests contains few tests to check if the ocaml interface was compiled correctly. cd tests/ocaml make cduce-0.6.0/INSTALL.RPM000066400000000000000000000022031230562553500142710ustar00rootroot00000000000000ftp://ftp.leo.org/pub/altlinux/Sisyphus/files/i586/RPMS/findlib-0.8-alt2s.i586.rpm ftp://ftp.leo.org/pub/altlinux/Sisyphus/files/i586/RPMS/pxp-1.1.93-alt2s.i586.rpm ftp://ftp.leo.org/pub/altlinux/Sisyphus/files/i586/RPMS/pcre-ocaml-4.28.3-alt3s.i586.rpm

In order to install the cduce rpm packages you will need to install the following packages 

ocaml >= 3.06    
findlib >= 0.8   
pcre-ocaml>= 4.22 
ocamlnet  >= 0.96
pxp >= 1.1.93
expat >= 1.95.6 (just for the expat package)




 All these packages can be found in the Altlinux distribution: for Asia
i586, 
src; European mirror i586,  src






N.B. rpm will check that you installed all these packages. If you have them installed but not via rpm then install CDuce by rpm -Uvh --nodeps cduce-X.X.X-X.rpm


cduce-0.6.0/INSTALL.WIN32000066400000000000000000000072461230562553500144510ustar00rootroot00000000000000                 Installation Notes for Windows NT/2000/XP
                 =========================================


CDuce can be executed on Microsoft Windows by using the
RedHat/Cygnus environment Cygwin freely available at

http://www.cygwin.com/

The executable needs the cygwin1.dll that is distributed 
under GPL license. This is not compatible with the CDuce license.
For this reason we do not provide binaries but give here detailed 
instructions about how to compile CDuce sources under Cygwin/Windows.


------------------------------------------------------------------------------
Prerequisites
------------------------------------------------------------------------------

Before compiling CDuce on Windows, you need to install the
following releases of the these packages (newer releases may
work):


cygwin
  http://www.cygwin.com
ocaml 3.10.0
  http://caml.inria.fr/ocaml/distrib.html
findlib 1.2.1   
  http://www.ocaml-programming.de/packages
ulex 1.0
  http://www.cduce.org/download.html
pcre-ocaml
  http://ocaml.info/home/ocaml_sources.html
ocamlnet 2.2.9
  http://www.ocaml-programming.de/packages
pxp 1.2.0
  http://www.ocaml-programming.de/packages/documentation/pxp/index_dev.html


Installation notes (you are advised to follow this order):


1) Download and execute cygwin setup.exe.
   - Choose Internet installation
   - Choose a root directory whose path has no blanks in it
   - Choose as Local Package Directory /usr/src (optional)
   - Choose the mirror closest to you
   - When asked to select the packages to install add to the default
     choices the following packages:
       Devel/
         autoconf*
         automake*
         binutils
         gcc*
         make
         patchutils
       Interpreters/
         m4
       Lib/
	 libpcre
         pcre
	 pcre-devel
     you may also find useful to install the following packages
       Editors/
         emacs or vim (no trolls)
       Net/
         ncftp
         openssh
       Devel/
         binutils
	 subversion
       Utils/
         bc
	 bzip2
         diff
	 diffutils
         file
         patch
	 patchutils
     then proceed with installation


2) Download (we suggest in /usr/src) and install Ocaml
   [For the impatient:
     ./configure
     make world.opt
     make install]


3) Download (guess where) and install findlib.

   A plain 

     ./configure
     make all
     make opt
     make install

   should work, but it is worth checking that the paths that come
   out looking right in Makefile.config after ./configure.
   Otherwise correct paths in findlib.conf and re-run configure.
   E.g.: ./configure -bindir /usr/local/bin -mandir /usr/local/man


4) Download and install ulex 
   The ocaml 3.10.0 version of ulex on cygwin requires to add the
   "-classic-display" option to ocamlbuild in the Makefile.
     make all
     make all.opt
     make install


5) Download and install pcre-ocaml. 
   If you get an error regarding dynmaically loaded library try to
   add STATIC=yes in Makefile.conf

     make
     make install
   

6) Download and install ocamlnet

   ./configure
   make all
   make opt
   make install


7) PXP:
   CDuce requires a development version >= 1.1.93.

   ./configure -without-wlex -without-wlex-compat -lexlist utf8,iso88591 -without-pp
   (there is a problem with the preprocessor in cygwin, so you
   get an error if you don't add the -without-pp)

   make all
   make opt
   make install


Now you can compile CDuce sources as indicated in the INSTALL file 
namely 

  
------------------------------------------------------------------------------
Compilation, installation
------------------------------------------------------------------------------

See the INSTALL file.




cduce-0.6.0/INSTALL.mingw000077500000000000000000000172271230562553500147730ustar00rootroot00000000000000                 Installation Notes for Windows XP/MinGW
                 =======================================

It is possible to compile CDuce under cygwin with the MinGW toolchain.
Currently, the resulting executable still depends on the cygwin1.dll.
The suspect is pcre, but the source of the "pollution" has not been
determined.

The dependencies can be checked with the "cygcheck" command under
cygwin.  Note that cygcheck searches in the PATH, i.e., if a binary is
not in the path, one must give the full path.  To check a binary in
the mingw directory (e.g., C:\ocamlmgw\bin\cduce), one must give the
Mingw path (C:/ocamlmgw/bin/cduce) to cygcheck, not the cygwin path
(/cygdrive/c/ocamlmgw/bin).


When compiling under the MinGW toolchain, the option -mno-cygwin must
always be passed to the C compiler and linker.  It is also necessary
to ensure that one is not linking against any cygwin libraries at any
point.  The MinGW libraries are located in /usr/lib/...


Steps:

----------------------------------------------------------------------
1) In Cygwin, add the packages for MinGW support to the ones already
   mentioned in INSTALL.WIN32.

   gcc-mingw-core
   mingw-runtime
   w32-api
   
   
   Remove the prce packages from Cygwin, to make sure that the pcre
   used is the one installed under Mingw.


----------------------------------------------------------------------
2) Install tcl/tk in Windows

   Install Tcl/Tk in a windows top directory, eg, C:\Tcl

   binaries available as described in ocaml notes (README.win32).


----------------------------------------------------------------------
3) OCAML

Build ocaml 3.10 for the mingw toolchain as specified in README.win32,
but with the following addition from the ocaml mailing list:

    From: Arnold Guillaumot  snef.ro>
    Subject: Re: Compiling with Cygwin/MinGW
    Newsgroups: gmane.comp.lang.ocaml.lib.gtk
    Date: 2007-09-05 18:55:39 GMT

    Hi,

    I succeeded in the past to build ocaml and lablgtk with MinGW/MSYS
    (without Cygwin), together with ocamlmklib.
    In the ocaml tree, change the following files:

    1) ocamlmklib

    The 'trick' is to copy the Makefile part of ocamlmklib in the Makefile.nt

    edit tools/Makefile.nt and change the Line 26
         all: ocamldep ocamlprof ocamlcp.exe ocamlmktop.exe primreq
         in
         all: ocamldep ocamlprof ocamlcp.exe ocamlmktop.exe primreq
    ocamlmklib.exe

    append the following lines after the ocamlmktop part:

    # To help building mixed-mode libraries (Caml + C)

    ocamlmklib.exe: myocamlbuild_config.cmo ocamlmklib.cmo
        $(CAMLC) $(LINKFLAGS) -o ocamlmklib.exe myocamlbuild_config.cmo
    ocamlmklib.cmo

    ocamlmklib.cmo: myocamlbuild_config.cmi
    myocamlbuild_config.ml: ../config/Makefile
        ../build/mkmyocamlbuild_config.sh
        cp ../myocamlbuild_config.ml .

    install::
        cp ocamlmklib.exe $(BINDIR)/ocamlmklib.exe

    clean::
        rm -f ocamlmklib.exe

    ocamlmklib.ml: ocamlmklib.mlp ../config/Makefile
        echo '(* THIS FILE IS GENERATED FROM ocamlmklib.mlp *)' >ocamlmklib.ml
        sed -e "s|%%BINDIR%%|$(BINDIR)|" \
                -e
    "s|%%SUPPORTS_SHARED_LIBRARIES%%|$(SUPPORTS_SHARED_LIBRARIES)|" \
                -e "s|%%MKSHAREDLIB%%|$(MKSHAREDLIB)|" \
                -e "s|%%BYTECCRPATH%%|$(BYTECCRPATH)|" \
                -e "s|%%NATIVECCRPATH%%|$(NATIVECCRPATH)|" \
                -e "s|%%MKSHAREDLIBRPATH%%|$(MKSHAREDLIBRPATH)|" \
                -e "s|%%RANLIB%%|$(RANLIB)|" \
              ocamlmklib.mlp >> ocamlmklib.ml

    beforedepend:: ocamlmklib.ml

    clean::
        rm -f ocamlmklib.ml

It seems that this is not in the ocaml distribution because it doesn't
work under MSVS, only under MinGW, and since there is only one
Makefile.nt...


adjust PATH:

PATH=$PATH:/cygdrive/c/ocamlmgw/bin


----------------------------------------------------------------------
4) findlib

  Patch configure replacing 
    stdlib = `get_stdlib`
  with 
    stdlib = /cygdrive/c/ocamlmgw/lib

  ./configure -bindir /cygdrive/c/ocamlmgw/bin

  Patch Makefile.config replacing
    OCAML_CORE_MAN = /usr/local/man
  with
    OCAML_CORE_MAN = /cygdrive/c/ocamlmgw/man
  (since ocaml for mingw does not install the man directories, the
  mandir option does not work).

  make all
  make opt
  make install


----------------------------------------------------------------------
5) ulex

This gets stuck with the error "can't found ocamlbuildlib.cma in
ocamlbuild -where", which is not surprising, since ocamlbuild -where
returns /ocamlbuildlib/lib, which doesn't exist.  See ocaml bug 4379.
This is supposedly fixed in ocaml 3.10.1, but it still doesn't seem to
work.

Until this bug is fixed, patch Makefile to use 

  ocamlbuild -install-lib-dir "C:\ocamlmgw\lib\ocamlbuild"

(or whereever your mingw installation is).  This workaround is
suitable for cygwin, but it may not work in Mingw/MSYS.

Remember to also add -classic-display to ocamlbuild, since we are
building with ocaml 3.10.

  make all
  make all.opt
  make install


----------------------------------------------------------------------
6) PCRE:

Since the pcre that comes with cygwin cannot be used in mingw, install
pcre before pcre-ocaml.  This is simpler if pcre is not installed in
cygwin.

Go back to cygwin's setup.exe and install gcc-g++ (C++ compiler).

Download pcre-7.2 from www.pcre.org or
ftp://ftp.csx.cam.ac.uk/pub/software/programming/pcre

To configure pcre-7.2:

If pcre is installed in cygwin, patch ltmain.sh so that need_relink is
always "no", that may avoid the cygwin dependency.

./configure --prefix="C:/ocamlmgw" --exec-prefix="C:/ocamlmgw" --includedir=/usr/include/mingw --disable-cpp --enable-utf8 CFLAGS="-mno-cygwin -I /usr/include/w32api -I /usr/include/mingw"

Patch the Makefile to replace cygwin with mingw everywhere it occurs
(except in -mno-cygwin).

Patch the libtool file similarly.

make

make install

This installs the libs in the ocaml mingw directory
(e.g. C:\ocamlmgw\lib, but the .h files in /usr/include/mingw.  This
should be suitable for continued compilation using the mingw
toolchain, but not for a pure mingw compilation.

Check with cygcheck whether, eg, pcregrep.exe, depends on the
cygwin1.dll and cygpcre-0.dll.
----------------------------------------------------------------------
7) pcre-ocaml:

Edit Makefile.conf to contain

export STATIC = yes
export INCDIRS := /usr/include/mingw
export LIBDIRS := C:/ocamlmgw/lib
MINGW=1
CC=gcc
export GCC
export MINGW

(If cc is not set, it defaults to cc, which causes 'make' to fail
spectacularly during

ocamlc -c -cc "cc" -ccopt "-fPIC -O2 -DPIC -mno-cygwin -I /usr/include/mingw -o pcre_stubs.o" pcre_stubs.c

sometimes even to the point of crashing cygwin.)

make
make install

The file pcre_make.win32/Makefile.mingw does not seem to work, either
it is for Mingw/MSYS or it has not been updated.

The file README.win32 concerns MS Visual Studio, i.e., it is
irrelevant.

To check that pcre actually works in ocaml:

  make a file foo.ml that uses Pcre, eg

  open Prce;;
  qreplace;;

  compile it with 

  ocamlc -I "C:/ocamlmgw/lib/site-lib/pcre" foo.ml

----------------------------------------------------------------------
8) pxp

   ./configure -without-wlex -without-wlex-compat -lexlist utf8,iso88591 -without-pp

   make all
   make opt
   make install


----------------------------------------------------------------------
9) CDuce

./configure --prefix="C:/ocamlmgw" --mliface="C:/cygwin/usr/src/ocaml-3.10.0/" 

patch Makefile.conf to set FORPACK=true
(For some reason that fails in configure.ml)

Patch Makefile.distrib to set

LINK = $(CAMLOPT) -custom -linkpkg

in line 71 to statically link the library.


make all
make install
cduce-0.6.0/LICENSE000066400000000000000000000021701230562553500136130ustar00rootroot00000000000000The package CDuce is released under the terms of an MIT-like license.

Copyright 2005 by Alain Frisch and contributors.

Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:

The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
cduce-0.6.0/META.in000066400000000000000000000002651230562553500136670ustar00rootroot00000000000000version="%VER%"
requires="%REQ%"
description="Runtime support for CDuce"
archive(byte)="+camlp4/camlp4lib.cma cduce_lib.cma"
archive(native)="+camlp4/camlp4lib.cmxa cduce_lib.cmxa"
cduce-0.6.0/Makefile000066400000000000000000000106061230562553500142510ustar00rootroot00000000000000include Makefile.distrib

# For development

pull: tools/pull.$(EXTENSION)
	$(LINK) -o $@ $^

PREPRO = camlp4o -I `ocamlfind query ulex` pa_ulex.cma pr_o.cmo $(SYNTAX) -sep "\n"

profile: misc/q_symbol.cmo
	rm -Rf prepro
	mkdir prepro
	for i in $(DIRS); do \
	mkdir prepro/$$i; \
	for j in $$i/*.ml $$i/*.mli; do \
	if [ -f "$$j" ]; then \
	 echo $$j; \
	 $(PREPRO) $$j -o prepro/$$j; \
	fi; \
	done; \
	done
	cp Makefile.distrib Makefile Makefile.conf prepro/
	(cd prepro;  \
	touch depend; \
	$(MAKE) compute_depend PROFILE=true SYNTAX_PARSER= ; \
	$(MAKE) cduce PROFILE=true SYNTAX_PARSER= NATIVE=false)


SCRIPT =
INCLUDES_DEB = $(INCLUDES) $(shell ocamlfind query -i-format -recursive $(PACKAGES))
DEBUGGER = ocamldebug
debug:
	ledit $(DEBUGGER) $(INCLUDES_DEB) ./cduce $(SCRIPT)

# Packaging

DISTRIB = $(DIRS) web cduce.spec depend INSTALL INSTALL.WIN32 CHANGES \
 LICENSE README AUTHORS Makefile.conf.template configure configure.ml doc \
 META.in cduce_mktop VERSION PLIST.godi Makefile.macosx tools/make-package-macosx

DISTRIB_DOC = doc.xml memento.xml tutorial.xml manual.xml tutorial manual \
 xhtml.cd xhtml-categ.cd xhtml-strict.cd site.cd siteTypes.cd

PACKAGE = cduce-$(VERSION)
.PHONY: package
package: clean
	rm -Rf $(PACKAGE)
	mkdir $(PACKAGE)
	cp -R $(DISTRIB) $(PACKAGE)/
	cp Makefile.distrib $(PACKAGE)/Makefile
	mkdir $(PACKAGE)/tools
	cp tools/dtd2cduce.ml  $(PACKAGE)/tools/
	(cd $(PACKAGE); \
	rm -f types/IDEAS; \
        for F in $(DEPEND); do headache -h ../header $$F; done)
	tar czf $(PACKAGE).tar.gz --exclude .svn --exclude ".#*" $(PACKAGE)
	rm -Rf $(PACKAGE)

OCAML_STDLIBDIR := $(shell ocamlc -where)
.PHONY: .ocamlinit
.ocamlinit:
	echo '(* AUTOMATICALLY GENERATED by Makefile: DO NOT EDIT! *)' > $@
	echo '#load "$(OCAML_STDLIBDIR)/pcre/pcre.cma";;' >> $@
	echo '#load "$(OCAML_STDLIBDIR)/unix.cma";;' >> $@
	echo '#load "$(OCAML_STDLIBDIR)/netstring/netstring.cma";;' >> $@
# 	echo '#load "$(OCAML_STDLIBDIR)/netstring/netstring_top.cmo";;' >> $@
	echo '#load "$(OCAML_STDLIBDIR)/pxp-engine/pxp_engine.cma";;' >> $@
# 	echo '#load "$(OCAML_STDLIBDIR)/pxp-engine/pxp_top.cmo";;' *)' >> $@
	echo '#load "$(OCAML_STDLIBDIR)/pxp-lex-iso88591/pxp_lex_iso88591.cma";;' >> $@
	echo '#load "$(OCAML_STDLIBDIR)/pxp-lex-iso88591/pxp_lex_link_iso88591.cmo";;' >> $@
	echo '#load "$(OCAML_STDLIBDIR)/ulex/ulexing.cma";;' >> $@
	echo '#load "$(OCAML_STDLIBDIR)/nums.cma";;' >> $@
# 	echo '#load "$(OCAML_STDLIBDIR)/num_top.cma";;' >> $@
	echo '#load "$(OCAML_STDLIBDIR)/cgi/cgi.cma";;' >> $@
	for o in $(VALIDATE_OBJECTS); do echo "prerr_endline \"Loading $$o ...\";;" >> $@; echo "#load \"$$o\";;" >> $@; done
	for d in $(DIRS); do echo "#directory \"$$d\";;" >> $@; done
	for p in pcre netstring pxp-engine ulex cgi; do echo "#directory \"`$(OCAMLFIND) query $$p`\";;" >> $@; done
	echo "prerr_endline \"All done!\"" >> $@
	echo '(* vim: set ft=ocaml: *)' >> $@

CVS_DISTRIB = web CHANGES LICENSE README AUTHORS cduce dtd2cduce
CVS_DOC = doc/cdo2ml.1 doc/cduce.1 doc/cduce_mktop.1  doc/cduce_validate.1 doc/dtd2cduce.1 doc/fomanual/tutorial.pdf doc/fomanual/manual.pdf
cvs_snapshot_bin: clean
	if [[ `uname` != Linux ]]; then echo "Not a Linux box!"; exit 2; fi
	$(MAKE) cduce dtd2cduce NATIVE=true EXTRA_LINK_OPTS="-ccopt -static" VERSION=cvs`date +%Y%m%d`
	rm -Rf cduce-cvs
	mkdir cduce-cvs
	mkdir cduce-cvs/doc
	cp -R $(CVS_DISTRIB) cduce-cvs
	cp $(CVS_DOC) cduce-cvs/doc
	cp Makefile.binary cduce-cvs/Makefile
	tar czf cduce-cvs-linux-static.tar.gz --exclude CVS cduce-cvs
	rm -Rf cduce-cvs
	scp cduce-cvs-linux-static.tar.gz cduce@di.ens.fr:public_html/download

.PHONY: test
test: all
	@tests/test.sh

extendedtest: all
	@tests/test.sh -e

############ CGI DEMO ###################

cgi: webiface evaluator

driver/examples.ml: cduce web/xhtml.cdo web/examples/build.cd web/examples/examples.xml
	(cd web/examples; ../../cduce build.cd -I .. --arg examples.xml)

WEBIFACE  = $(OBJECTS) driver/examples.cmo driver/webiface.cmo
EVALUATOR = $(OBJECTS) driver/evaluator.cmo

webiface: $(WEBIFACE:.cmo=.$(EXTENSION))
	@echo "Build $@"
	$(HIDE)$(LINK) -verbose $(INCLUDES) -o $@ $^ $(EXTRA_OPTS_WEBIFACE)

evaluator: $(EVALUATOR:.cmo=.$(EXTENSION))
	@echo "Build $@"
	$(HIDE)$(LINK) -verbose $(INCLUDES) -o $@ $^ $(EXTRA_OPTS_WEBIFACE)

# webiface can be made static to be able to move it more easily
# (to compile it on a machine which is not the web server)
# Seems to be some problems with statically linking curl
# EXTRA_OPTS_WEBIFACE += -ccopt -static

cduce-0.6.0/Makefile.binary000066400000000000000000000004051230562553500155300ustar00rootroot00000000000000# User Makefile for binary releases

webpages: web/site.cdo
	(cd web; ../cduce --run site.cdo --arg site.xml)

web/site.cdo: web/xhtml.cdo web/site.cd
	./cduce -I web/ --compile web/site.cd

web/xhtml.cdo: web/xhtml.cd
	./cduce -I web/ --compile web/xhtml.cd


cduce-0.6.0/Makefile.conf.template000066400000000000000000000027441230562553500170130ustar00rootroot00000000000000## CDuce compilation options
##
## You can either modify this file, or run the configure script

# build CDuce using OCaml native code compiler
NATIVE = true

# profiling support
PROFILE = false

# .mli/.cmi file support to interface CDuce with OCaml.
# possible values: false, flat, tree
# - if ML_INTERFACE=flat, set ML_MODULES to a directory that
#   contains all the compiled modules from the directory
#   utils, parsing, typing of the OCaml compilers
# - if ML_INTERFACE=tree, set ML_MODULES to a directory
#   with three subdirectories utils/ parsing/ typing/
#   that contain the compiled modules
# (see cdo2cmo/Makefile for more details)
ML_INTERFACE = false


# use wlex lexers for parsing XML files with PXP
PXP_WLEX = false

# include support for expat
EXPAT = false

# use curl library to load remote xml files and schemas
CURL = false

# use netclient library to load remote xml files and schemas
NETCLIENT = true

# Installation directories
PREFIX = /usr/local
BINDIR = $(PREFIX)/bin
MANDIR = $(PREFIX)/man

# Customize the following variables to match the settings
# of your local web server

# Root directory of your local web-server
WEB_PREFIX = /var/www

# directory for installing the cgi-bin of the cduce interpreter
CGI_DIR = $(WEB_PREFIX)/cgi-bin

# installation directory for the website and man-pages
HTML_DIR = $(WEB_PREFIX)/html

# where temporary files of local interactive interpreter are put
SESSION_DIR = /tmp/cduce_sessions

# extension for programs (.exe under Cygwin)
EXE =
cduce-0.6.0/Makefile.distrib000066400000000000000000000221121230562553500157030ustar00rootroot00000000000000default: cduce

include Makefile.conf
include VERSION


ALL_TARGET=cduce cduce_lib.cma
INSTALL_BINARIES=cduce$(EXE)

ifneq ($(ML_INTERFACE), false)
  INSTALL_BINARIES += cduce_mktop
endif

OUNIT_TESTS=eval cdnum cdsdl misc

ifeq ($(NATIVE),true)
all: cduce_lib.cmxa
endif

PACKAGES = dynlink camlp4 ulex pcre num netstring 

# Call make with VERBOSE=true to get a trace of commands

VERBOSE?=false

ifneq ($(VERBOSE), true)
   HIDE=@
else
   HIDE=
endif


SYNTAX = -I misc/ q_symbol.cmo \
  -symbol cduce_version=\"$(VERSION)\" \
  -symbol build_date=\"$(shell date +%Y-%m-%d)\" \
  -symbol session_dir=\"$(SESSION_DIR)\" \
  -loc "_loc"

SYNTAX_PARSER = -syntax camlp4o $(SYNTAX:%=-ppopt %)

CAMLC_P = ocamlc -g
DEPEND_OCAMLDEP = misc/q_symbol.cmo
ifeq ($(PROFILE), true)
  CAMLOPT_P = ocamlopt -p -inline 10000
  ifeq ($(NATIVE), false) 
    CAMLC_P = ocamlcp -p a
    SYNTAX_PARSER = 
    DEPEND_OCAMLDEP =
  endif
else
  CAMLOPT_P = ocamlopt -inline 10000
endif

OPT = -warn-error FPSXY
ANNOT =
INTERFACE =
ifeq ($(ANNOT), true)
	OPT += -passopt -dtypes
endif
ifeq ($(INTERFACE), true)
	OPT += -passopt -i
endif

OCAMLFIND = ocamlfind
CAMLC = $(OCAMLFIND) $(CAMLC_P) $(OPT) -package "$(PACKAGES)"
CAMLOPT = $(OCAMLFIND) $(CAMLOPT_P) $(OPT) -package "$(PACKAGES)"

ifeq ($(NATIVE), true)
  EXTENSION = cmx
  EXTENSION_LIB = cmxa
  CAML=ocamlopt
  COMPILE = $(CAMLOPT)
  LINK = $(CAMLOPT) -linkpkg
  ifeq ($(NATDYNLINK), true)
    LINK += dynlink.cmxa
  endif
  ifeq ($(ADDICON), true)
    LINK += cduceres.o
  endif
  LINK += camlp4lib.cmxa
  SYNTAX += -symbol ocaml_compiler=\"native\"
else
  EXTENSION = cmo
  EXTENSION_LIB = cma
  COMPILE = $(CAMLC)
  CAML=ocamlc
  LINK = $(CAMLC) -custom -linkpkg camlp4lib.cma
  SYNTAX += -symbol ocaml_compiler=\"bytecode\"
endif

ifeq ($(FORPACK),true)
  FORPACKOPT=-passopt -for-pack -passopt Cduce_lib
else
  FORPACKOPT=
endif

INSTALL := install -c

ifeq ($(NATIVE),true)
.PHONY: cduce_lib.cma
cduce_lib.cma:
	$(HIDE)$(MAKE) NATIVE=false $@
endif

install: all install_bin install_lib install_doc

install_bin:
	@echo "Install binaries"
	$(HIDE)mkdir -p $(BINDIR)
	$(HIDE)$(INSTALL) -m755 $(INSTALL_BINARIES) $(BINDIR)/


install_lib:
	@echo "Build META"
	$(HIDE)(sed "s/%REQ%/$(PACKAGES)/" < META.in | sed "s/%VER%/$(VERSION)/" > META)
	$(HIDE)-$(OCAMLFIND) remove cduce
	$(HIDE)-$(OCAMLFIND) install cduce META \
         lib/cduce_lib.cmi lib/cduce_lib.cma lib/cduce_lib.cmxa lib/cduce_lib.a \


uninstall:
	rm -f $(BINDIR)/cduce$(EXE) $(BINDIR)/cduce_mktop
	rm -f $(MANDIR)/man1/cduce.1
	rm -Rf $(DOCDIR)
	ocamlfind remove cduce

help:
	@echo "GOALS"
	@echo "  cduce : compiles the CDuce command line interpreter"
	@echo "  dtd2cduce: compiles the dtd2cduce tools"
	@echo "  doc : build the documentation"
	@echo "  all : build binaries and libraries"
	@echo "  install : install binaries, man pages, documentation"
	@echo "  clean :  back to the starting point"
	@echo "  uninstall : remove installed files"

# Source directories 

DIRS = misc parser schema typing types compile runtime driver query ocamliface win32
CLEAN_DIRS = $(DIRS) tools tests

# Objects to build

OBJECTS = \
 driver/cduce_config.cmo misc/stats.cmo misc/custom.cmo misc/encodings.cmo \
 misc/upool.cmo misc/pretty.cmo misc/ns.cmo misc/imap.cmo misc/html.cmo \
 \
 types/compunit.cmo types/sortedList.cmo misc/bool.cmo types/ident.cmo \
 types/intervals.cmo types/chars.cmo types/atoms.cmo types/normal.cmo \
 types/types.cmo compile/auto_pat.cmo \
 types/sequence.cmo types/builtin_defs.cmo \
 \
 runtime/value.cmo \
 \
 schema/schema_pcre.cmo schema/schema_types.cmo \
 schema/schema_xml.cmo schema/schema_common.cmo \
 schema/schema_builtin.cmo schema/schema_validator.cmo \
 \
 types/patterns.cmo \
 compile/print_auto.cmo \
 \
 compile/lambda.cmo \
 runtime/run_dispatch.cmo runtime/explain.cmo runtime/eval.cmo \
 \
 parser/cduce_loc.cmo  parser/url.cmo \
 parser/ulexer.cmo parser/ast.cmo parser/parser.cmo \
 \
 typing/typed.cmo typing/typepat.cmo types/externals.cmo typing/typer.cmo \
 compile/compile.cmo \
 \
 schema/schema_parser.cmo schema/schema_converter.cmo \
 runtime/load_xml.cmo runtime/print_xml.cmo compile/operators.cmo types/builtin.cmo \
 driver/librarian.cmo types/sample.cmo \
 driver/cduce.cmo \
 \
 runtime/system.cmo query/query_aggregates.cmo

schema/schema_types.ml: schema/schema_types.mli
	cp $^ $@
compile/auto_pat.ml: compile/auto_pat.mli
	cp $^ $@
compile/lambda.ml: compile/lambda.mli
	cp $^ $@

ML_INTERFACE_OBJS = \
  ocamliface/caml_cduce.cmo \
  ocamliface/mltypes.cmo ocamliface/mlstub.cmo

ifneq ($(ML_INTERFACE), false)
  OBJECTS += $(ML_INTERFACE_OBJS)
endif

ifneq ($(CURL), false)
  OBJECTS += parser/cduce_curl.cmo
  PACKAGES += curl
endif
ifneq ($(NETCLIENT), false)
  OBJECTS += parser/cduce_netclient.cmo
  PACKAGES += netclient
endif

PXP_PACK=pxp-engine pxp-lex-iso88591
ifeq ($(PXP_WLEX), true)
  PXP_PACK += pxp-wlex-utf8
else
  PXP_PACK += pxp-lex-utf8
endif

ifeq ($(PXP),true)
    OBJECTS += runtime/cduce_pxp.cmo
    PACKAGES += $(PXP_PACK)
    ifeq ($(CGI),true)
      OBJECTS += runtime/cduce_pxp.cmo
      PACKAGES += netcgi1
      ALL_TARGET += dtd2cduce
      INSTALL_BINARIES += dtd2cduce
  endif
endif

ifeq ($(EXPAT), true)
  OBJECTS += runtime/cduce_expat.cmo
  PACKAGES += expat
endif

ifeq ($(ADDICON), true)
  OBJECTS += cduceres.o
endif

all: $(ALL_TARGET)

OBJECTS += driver/run.cmo
CDUCE = $(OBJECTS) driver/start.cmo 

ALL_OBJECTS = $(OBJECTS) \
 driver/start.cmo driver/examples.cmo \
 driver/webiface.cmo driver/evaluator.cmo \
 tools/validate.cmo \
 $(ML_INTERFACE_OBJS) parser/cduce_curl.cmo \
 parser/cduce_netclient.cmo \
 runtime/cduce_expat.cmo runtime/cduce_pxp.cmo

ALL_INTERFACES = schema/schema_types.mli 

DEPEND = $(ALL_OBJECTS:.cmo=.ml) $(ALL_OBJECTS:.cmo=.mli) $(ALL_INTERFACES)

INCLUDES = $(DIRS:%=-I %)
# -I +camlp4

cduce: $(CDUCE:.cmo=.$(EXTENSION))
	@echo "Build $@"
	$(HIDE)$(LINK) $(INCLUDES) -o $@ $^ $(EXTRA_LINK_OPTS)

cduce_packed.ml: $(CDUCE:.cmo=.ml)
	rm -f cduce_packed.ml
	ocaml tools/pack.ml $^ > cduce_packed.ml

cduce_packed: cduce_packed.$(EXTENSION)
	$(LINK) $(INCLUDES) -o $@ $^ $(EXTRA_LINK_OPTS)


cduce_lib.$(EXTENSION_LIB): $(OBJECTS:.cmo=.$(EXTENSION))
	@echo "Pack cduce_lib.$(EXTENSION)"
	@test -e lib || mkdir lib
	$(HIDE)$(COMPILE) -o lib/cduce_lib.$(EXTENSION) $(INCLUDES) -pack $^
	@echo "Build $@"
	$(HIDE)$(COMPILE) -a -o lib/$@ lib/cduce_lib.$(EXTENSION)

dtd2cduce: tools/dtd2cduce.ml
	@echo "Build $@"
	$(HIDE)$(OCAMLFIND) $(CAML) -o $@ -package "$(PXP_PACK) netcgi1" -linkpkg $^

.PHONY: compute_depend
compute_depend: $(DEPEND_OCAMLDEP)
	@echo "Computing dependencies ..."
	ocamlfind ocamldep -package "$(PACKAGES)" \
		$(INCLUDES) $(SYNTAX_PARSER) $(DEPEND) > depend
clean:
	for i in $(CLEAN_DIRS); do \
	(cd $$i; rm -f *.cmi *.cmo *.cma *.cmx *.o *.a *.cmxa *~); \
	done
	(cd ocamliface; $(MAKE) clean)
	rm -f `find . -name "*~"`
	rm -f *.cmi *.cmo *.cma *.cmx *.a *.cmxa *.o *~ META
	rm -f cduce$(EXE) ocamlprof.dump
	rm -f dtd2cduce$(EXE) webiface$(EXE) evaluator$(EXE)
	rm -Rf prepro package
	rm -f web/www/*.html web/*~
	rm -f web/*.cdo
	rm -f configure.log
	rm -rf web/doc
	rm -f META
	rm -rf lib
	$(RM) tests/schema/regtest/test.cd tests/schema/regtest/test.log
	$(RM) tests/schema/test.cd tests/schema/test.log tests/misc/log tests/misc/memento.html tests/xsltmark/log tests/cql/log
	$(RM) oUnit-* tests/ocaml/misc/consts.ml tests/ocaml/misc/consts.cdo tests/ocaml/misc/consts.cmi tests/ocaml/misc/consts.cmo tests/ocaml/latypes/latypes2* tests/ocaml/latypes/latypes tests/ocaml/latypes/latypes.c[dm][oxi] tests/ocaml/latypes/latypestest.cm[io]
	for i in $(OUNIT_TESTS); do $(RM) `echo tests/ocaml/$$i/$$i tests/ocaml/$$i/$$i.ml tests/ocaml/$$i/$$i.c[dm][oxi] tests/ocaml/$$i/$${i}test.cm[io]`; done

distclean: clean
	rm -f Makefile.conf

ocamliface/mltypes.$(EXTENSION): ocamliface/caml_cduce.$(EXTENSION)

$(ALL_OBJECTS:.cmo=.$(EXTENSION)): misc/q_symbol.cmo
$(ALL_INTERFACES): misc/q_symbol.cmo

.SUFFIXES: .ml .mli .cmo .cmi .cmx

misc/q_symbol.cmo: misc/q_symbol.ml
	@echo "Build $@"		  
	$(HIDE)$(CAMLC) -c -pp camlp4orf $<

.ml.cmo:
	@echo "Build $@"
	$(HIDE)$(CAMLC) -c $(INCLUDES) $(SYNTAX_PARSER) $<

.ml.cmx:
	@echo "Build $@"
	$(HIDE)$(CAMLOPT) $(FORPACKOPT) -c $(SYNTAX_PARSER) $(INCLUDES) $<

.mli.cmi:
	@echo "Build $@"
	$(HIDE)$(CAMLC) -c $(SYNTAX_PARSER) $(INCLUDES) $<

include depend

cduceres.o: win32/cduce.rc win32/cduce_logo-bw.ico
	(cd win32; windres -i cduce.rc -o cduceres.o; mv cduceres.o ..)

# Documentation

doc: cduce web/site.cdo
	mkdir -p web/doc
	(cd web; ../cduce --run site.cdo --arg doc.xml -o doc)

web/site.cdo: cduce web/xhtml.cdo web/site.cd web/siteTypes.cd
	./cduce -I web/ --compile web/site.cd

web/xhtml.cdo: cduce web/xhtml.cd
	./cduce -I web/ --compile web/xhtml.cd

install_doc: doc
	$(HIDE)mkdir -p $(MANDIR)/man1
	$(HIDE)(cd doc; $(MAKE) install INSTALL="$(INSTALL)" MANDIR=$(MANDIR) HIDE=$(HIDE))
	mkdir -p $(DOCDIR)/img
	cp web/doc/*.html $(DOCDIR)/
	cp CHANGES INSTALL INSTALL.WIN32 README AUTHORS LICENSE $(DOCDIR)/
	cp web/img/left.gif web/img/right.gif $(DOCDIR)/img


### Pack OCaml modules for the CDuce/OCaml interface


ocamliface/caml_cduce.cmo:
	@cd ocamliface; \
	$(MAKE) caml_cduce.cmo

ocamliface/caml_cduce.cmx:
	@cd ocamliface; \
	$(MAKE) caml_cduce.cmx

cduce-0.6.0/Makefile.macosx000066400000000000000000000005121230562553500155350ustar00rootroot00000000000000
include VERSION

.PHONY: package-macosx

package-macosx: 
	mkdir -p package-macosx/root
	mkdir -p package-macosx/root/lib/ocaml
	sh configure --prefix=`pwd`/package-macosx/root
	OCAMLFIND_DESTDIR=package-macosx/root/lib/ocaml make install
	VERSION=$(VERSION) tools/make-package-macosx

clean-macosx:
	sudo rm -rf package-macosx

cduce-0.6.0/Makefile.types000066400000000000000000000032331230562553500154120ustar00rootroot00000000000000DIRS= cduce/misc cduce/types cduce/compile cduce/runtime

ML_SRC= \
 cduce/misc/serialize.ml \
 cduce/misc/custom.ml \
 cduce/misc/encodings.ml \
 cduce/misc/imap.ml \
 cduce/misc/state.ml \
 cduce/misc/pool.ml \
 cduce/misc/ns.ml \
 cduce/types/sortedList.ml \
 cduce/types/atoms.ml \
 cduce/misc/bool.ml \
 cduce/types/chars.ml \
 cduce/types/ident.ml \
 cduce/types/intervals.ml \
 cduce/misc/inttbl.ml \
 cduce/types/normal.ml \
 cduce/misc/pretty.ml \
 cduce/misc/stats.ml \
 cduce/types/types.ml \
 cduce/types/sequence.ml \
 cduce/types/sample.ml \
 cduce/types/patterns.ml \
 cduce/compile/lambda.ml \
 cduce/runtime/value.ml \
 cduce/runtime/run_dispatch.ml \
 cduce/runtime/explain.ml \
 cduce/runtime/serial.ml

CMO_OBJECTS=$(ML_SRC:.ml=.cmo)
CMX_OBJECTS=$(ML_SRC:.ml=.cmx)

$(CMO_OBJECTS) $(CMX_OBJECTS): $(COMPILER)
$(CMX_OBJECTS): $(OPTCOMPILER)

cduce_types.cmo: $(CMO_OBJECTS)
	$(CAMLC) $(COMPFLAGS) -pack -o cduce_types.cmo $(CDUCE_INCLUDES) $(CMO_OBJECTS)

cduce_types.cmx: $(CMX_OBJECTS)
	$(CAMLOPT) $(OPTCOMPFLAGS) -pack -o cduce_types.cmx $(CDUCE_INCLUDES) $(CMX_OBJECTS)

cduce_types.p.cmx: cduce_types.cmx
	cp cduce_types.cmx cduce_types.p.cmx
	cp cduce_types.o cduce_types.p.o

CDUCE_INCLUDES = $(DIRS:%=-I %)


.SUFFIXES: .ml .mli .cmo .cmi .cmx

.ml.cmo:
	$(CAMLC) $(COMPFLAGS) -c $(CDUCE_INCLUDES) $<

.ml.cmx:
	$(CAMLOPT) $(OPTCOMPFLAGS) -c $(CDUCE_INCLUDES) $<

.mli.cmi:
	$(CAMLC) $(COMPFLAGS) -c $(CDUCE_INCLUDES) $<


.PHONY: compute_depend
compute_depend:
	ocamldep $(CDUCE_INCLUDES) $(SRC) $(SRC:.ml=.mli) > cduce/types_depend

include cduce/types_depend



clean:
	for i in $(DIRS); do \
	(cd $$i; rm -f *.cmi *.cmo *.cma *.cmx *.o *.a *.cmxa *~); \
	done
cduce-0.6.0/PLIST.godi000066400000000000000000000002421230562553500143430ustar00rootroot00000000000000@comment $GODI$
bin/cduce
bin/cduce_mktop
@glob bin/dtd2cduce
man/man1/cduce.1
man/man1/cduce_mktop.1
man/man1/dtd2cduce.1
@deepdir doc/apps-cduce
@findlib cduce
cduce-0.6.0/README000066400000000000000000000100331230562553500134630ustar00rootroot00000000000000README - CDuce

This package is distributed under the terms of an MIT-like License
(see the LICENSE file).


------------------------------------------------------------------------------
Abstract
------------------------------------------------------------------------------

CDuce is a programming language adapted to the manipulation of XML
documents.  It has been designed and developed as a joint research
project between the Languages group at ENS (Paris) and the Database
group at LRI (Orsay) (http://www.lri.fr/bd).

The current implementation has been written to demonstrate the
innovative features of the language and to validate design choices.
It is a research prototype, not a robust application. However, it has 
been reported to work properly in a production environment.

Further information about CDuce is available at

  http://www.cduce.org


------------------------------------------------------------------------------
Source distribution
------------------------------------------------------------------------------

See the INSTALL file for Installation instructions.

1. CDuce command-line interpreter / toplevel

For performance reasons, it is advised to build it using OCaml native code
compiler (by default in the Makefile).

See the man page or HTML manual for usage.

When no CDuce file is given on the command line, the interpreter
behaves as a toplevel. Phrases are interpreted when the user type
";;". Of course, mutually recursive definition (types or functions)
must be entirely contained in an adjacent sequence of phrases
(without ";;" inbetween).


2. CDuce CGI interface

It is also possible to play with CDuce in a web browser, using the
webiface CGI interface (or webiface.opt) program. Of course, You will
need a web server with CGI support. 

There is usually a running version at:

http://www.cduce.org/cgi-bin/cduce

Some features are disabled in the web interface (including
file manipulation).


3. dtd2cduce

dtd2cduce is small tool that generates CDuce type declarations from
a DTD.

Usage: dtd2cduce  <.dtd file>

 is a string prepended to tag names to form CDuce type names.
The generated declarations are sent to the standard output.

dtd2cduce can also operates as a cgi-bin. You can access it using
the form at this URL:

http://www.cduce.org/dtd2cduce.html


4. CDuce web site

The source files (XML + CDuce) for the CDuce web site
(http://www.cduce.org/) are included in the web/ subdirectory.

------------------------------------------------------------------------------
Binary distribution
------------------------------------------------------------------------------

If you have downloaded the "linux static" binary distribution, you got
the cduce and dtd2cduce executables, the man pages, and the web/
subdirectory. To build the website, just do "make".


------------------------------------------------------------------------------
Documentation
------------------------------------------------------------------------------

There are several sources of information concerning CDuce:

- we started to write a manual and a tutorial as part of the web site. 
  You can find the manual at:

  http://www.cduce.org/manual.html

  or generate it locally (make local_website). Note that the online
  version is probably more up-to-date than the one included in the
  distribution.


- papers about CDuce:

  http://www.cduce.org/papers.html


- code examples:

  In the web site:
  http://www.cduce.org/examples.html
  http://www.cduce.org/bench.html
  
  In the distribution: 
  web/site.cd
  web/examples/build.cd

  Online prototype:
  http://www.cduce.org/cgi-bin/cduce

- the CDuce users' mailing-list:
  http://www.cduce.org/mailing.html


- and of course the source code!


------------------------------------------------------------------------------
Feedback
------------------------------------------------------------------------------

We'll appreciate any feedback (comments, suggestions, questions,
bug reports, ...) concerning the CDuce language or this early release
of the interpreter at info@cduce.org



  -- The CDuce team
cduce-0.6.0/TODO000066400000000000000000000051041230562553500132760ustar00rootroot00000000000000
- Define a small library to pretty print xml documents
  e.g.  pretty_dump_xml_to_file (shorter name of course)


- Dans l'evaluateur, pour les appels en position terminale, essayer de rutiliser
  l'environnement (si c'est la bonne taille, rutiliser le bloc; si c'est les bonnes
  valeurs, juste utiliser le mme bloc).

- Problem: a custom toplevel doesn't find ./cdo2ml (should put the path
  to cduce's directory in the toplevel?)


======================================================================
Alain 2005-06-18

Simplifier la srialisation/dserialisation des structures internes;
utiliser les fonctions de srialisation de Caml.

Plan d'attaque:

- utiliser des cls de hachage au lieu d'entiers squentiels pour reprsenter
  les namespaces, tags, labels, identificateurs; signaler quand mme 
  les collisions dans chaque espace de nommage.

    type 'a t
    val mk: int -> 'a t = "%identity"
    val get: 'a t -> int = "%identity"

  (autre avantage: possibilit de generer statiquement tables de dispatch
  sur les atomes)

  
- pour les structures cycliques (types, patterns, automates): attacher
  un identifiant unique d'unit de compilation dans chaque noeud;
  interdire deux units avec mme id. Accepter que les mmes noeuds
  se retrouvent dupliqus en mmoire (on peut quand detecter l'galit
  en regardant id d'unit + id squentiel).


Autres ides:

- applatir la representation des valeurs.
  | Atom of ns * local
  | Xml of ns * local * fields * v

  (support du systme de types pour interdire autre chose en position
  de tag / attribut - bonne chose de toute manire).

- reprsentation plus compacte des descriptions de types, liste
  chaine par ordre croissant des constructeurs:

   type descr =
    | Prod of BoolPair.t * descr
    | Times of BoolPair.t * descr
    | ...
    | Empty

  Avantage: oprations plus rapides ? ( vrifier)   Bien choisir
  l'ordre.
  Supprimer cl de hash stocke.

- Utiliser un gnrateur automatique pour les fonctions de hash/comparaison.

======================================================================
Alain 2005-03-04

Handle OCaml exception in the OCaml/CDuce interface

======================================================================
Beppe 2003-11-30

Add url support for non selfcontained documents and expat


======================================================================
Beppe 2003-01-23

Add the following types. 

 String
 String
 String

Alain 2003-05-15
  Il faut faire attention: on ne veut pas de commentaires dans la
  representation interne, on ne veut pas distinguer section CDATA, etc...

cduce-0.6.0/VERSION000066400000000000000000000000161230562553500136530ustar00rootroot00000000000000VERSION=0.6.0
cduce-0.6.0/benchmarks/000077500000000000000000000000001230562553500147235ustar00rootroot00000000000000cduce-0.6.0/benchmarks/Makefile000066400000000000000000000004621230562553500163650ustar00rootroot00000000000000split:
	ocaml unix.cma bench.ml split 0,10,50,100,500,1000 \
	split*.cd split*.xsl \
	| tee split.results

addrbook:
	ocaml unix.cma bench.ml addrbook 0,1000,5000,10000,50000,100000 \
	addrbook*.cd addrbook*.xsl \
	| tee addrbook.results
clean:
	rm -f split.*.xml addrbook.*.xml
	rm -f *~
	rm -f *.results
cduce-0.6.0/benchmarks/addrbook.ml000066400000000000000000000010671230562553500170460ustar00rootroot00000000000000let random_string n =
  let s = String.create n in
  for i = 0 to n - 1 do
    s.[i] <- Char.chr (65 + (Random.int 26))
  done;
  s;;
    
let nb = int_of_string Sys.argv.(1);;

print_string "";;

for i = 1 to nb do
 Printf.printf "%s" (random_string 20);
 if Random.int 2 = 0 then Printf.printf "%s" (random_string 20);
 for j = 1 to (Random.int 4) do 
   Printf.printf "%s" (random_string 20) 
 done;
 Printf.printf ""
done;;

print_string "";;

cduce-0.6.0/benchmarks/addrbook1.cd000066400000000000000000000010511230562553500170760ustar00rootroot00000000000000type Addrbook = [Person*]
type Person = [(Name Tel? Email* )]
type Name = String
type Tel = String
type Email = String

let mkTelbook ([Person*] -> [[Name Tel] *])
  | [ [ (n & Name) (t & Tel) ; _ ]; rest] ->  
      [ [n t]; mkTelbook rest ]
  | [ [ Name ; _ ] ; rest] ->  mkTelbook rest
  | [] -> []
 

match argv [] with
  | [ f ] -> 
   (match load_xml f with
    | (x & [Person*]) -> mkTelbook x
    | _ -> raise "Invalid document") 
  | _ -> raise "Invalid command line"
cduce-0.6.0/benchmarks/addrbook1.q000066400000000000000000000012111230562553500167460ustar00rootroot00000000000000import "xml.q"

type Addrbook = addrbook[Person*]
type Person = person[(Name,Tel?,Email* )]
type Name = name[String]
type Tel = tel[String]
type Email = email[String]

fun mkTelbook (val ps as Person* ) : entry[(Name,Tel)]* =
  match ps with
    person[name[val n], tel[val t],val e],val rest
        -> entry[name[n], tel[t]], mkTelbook(rest)
  | person[name[val n],val e],val rest 
        -> mkTelbook(rest)
  | () 
        -> ()

let val _ = 
 match argv() with
  val fn as String ->
   ( match load_xml(fn) with
       addrbook[val p as Person*] -> mkTelbook(p)
     | Any -> raise("Invalid document") )
 | Any -> raise("Invalid command line")
cduce-0.6.0/benchmarks/addrbook1.xsl000066400000000000000000000007761230562553500173330ustar00rootroot00000000000000


  
    
      
    
  

  
  


  
    
      
        
      
      
        
      
    
  


cduce-0.6.0/benchmarks/addrbook2.cd000066400000000000000000000010031230562553500170740ustar00rootroot00000000000000type Addrbook = [Person*]
type Person = [(Name Tel? Email* )]
type Name = String
type Tel = String
type Email = String

let mkTelbook ([Person*] -> [[Name Tel] *])
  | [ <_>[ n (t & _) ; _ ]; rest] -> [ [n t]; mkTelbook rest ]
  | [ _ ; rest] ->  mkTelbook rest
  | [] -> []
 

match argv [] with
  | [ f ] -> 
   (match load_xml f with
    | (x & [Person*]) -> mkTelbook x
    | _ -> raise "Invalid document") 
  | _ -> raise "Invalid command line"
cduce-0.6.0/benchmarks/addrbook2.q000066400000000000000000000011501230562553500167510ustar00rootroot00000000000000import "xml.q"

type Addrbook = addrbook[Person*]
type Person = person[(Name,Tel?,Email* )]
type Name = name[String]
type Tel = tel[String]
type Email = email[String]

fun mkTelbook (val ps as Person* ) : entry[(Name,Tel)]* =
  filter ps {
    ( person[name[val n], tel[val t], val e]
          { entry[name[n], tel[t]] }
    | person[name[val n], val e as Email*]
          { () }
    )*      
  } 

let val _ = 
 match argv() with
  val fn as String ->
   ( match load_xml(fn) with
       addrbook[val p as Person*] -> mkTelbook(p)
     | Any -> raise("Invalid document") )
 | Any -> raise("Invalid command line")
cduce-0.6.0/benchmarks/addrbook2.xsl000066400000000000000000000007731230562553500173310ustar00rootroot00000000000000


  
    
      
    
  

  
    
      
        
          
        
        
          
        
      
    
  


cduce-0.6.0/benchmarks/addrbook3.cd000066400000000000000000000007441230562553500171100ustar00rootroot00000000000000type Addrbook = [Person*]
type Person = [(Name Tel? Email* )]
type Name = String
type Tel = String
type Email = String

let mkTelbook (l : [Person*]) : [[Name Tel] *] =
 transform l with [ (n & Name) (t & Tel) ; _ ] -> [ [n t] ]
 

match argv [] with
  | [ f ] -> 
   (match load_xml f with
    | (x & [Person*]) -> (mkTelbook x)
    | _ -> raise "Invalid document") 
  | _ -> raise "Invalid command line"
cduce-0.6.0/benchmarks/addrbook3.q000066400000000000000000000011721230562553500167560ustar00rootroot00000000000000import "xml.q"

type Addrbook = addrbook[Person*]
type Person = person[(Name,Tel?,Email* )]
type Name = name[String]
type Tel = tel[String]
type Email = email[String]

fun mkTelbook (val ps as Person* ) : entry[(Name,Tel)]* =
  filter ps {
    person[Name,Email*]*, 
        person[name[val n], tel[val t], val e], val rest
      { entry[name[n], tel[t]], mkTelbook(rest) }
  | person[Name,Email*]* 
      { () }
  } 

let val _ = 
 match argv() with
  val fn as String ->
   ( match load_xml(fn) with
       addrbook[val p as Person*] -> mkTelbook(p)
     | Any -> raise("Invalid document") )
 | Any -> raise("Invalid command line")
cduce-0.6.0/benchmarks/addrbook4.cd000066400000000000000000000007131230562553500171050ustar00rootroot00000000000000type Addrbook = [Person*]
type Person = [(Name Tel? Email* )]
type Name = String
type Tel = String
type Email = String

let mkTelbook (l : [Person*]) : [[Name Tel] *] =
 transform l with <_>[ n (t & _) ; _ ] -> [ [n t] ]

match argv [] with
  | [ f ] -> 
   (match load_xml f with
    | (x & [Person*]) -> mkTelbook x
    | _ -> raise "Invalid document") 
  | _ -> raise "Invalid command line"
cduce-0.6.0/benchmarks/bench.ml000066400000000000000000000060471230562553500163430ustar00rootroot00000000000000open Printf

let time_cmd = "/usr/bin/time"
let cduce_cmd = "../cduce"
let xduce_cmd = "/home/frisch/xduce-0.4.0/xduce.opt"
let xduce_024_cmd = "/home/frisch/xduce-0.2.4/xduce.opt"
let xslt_cmd = "xsltproc"

let rec split c s =
  try 
    let i = String.index s c in
    (String.sub s 0 i) :: 
    (split c (String.sub s (i + 1) (String.length s - i - 1)))
  with Not_found -> [ s ]

let has_prefix pre s =
  let ls = String.length s in
  let lpre = String.length pre in
  (ls >= lpre) && (String.sub s 0 lpre) = pre

let extract_prefix pre s =
  let ls = String.length s in
  let lpre = String.length pre in
  if (ls >= lpre) && (String.sub s 0 lpre) = pre 
  then (String.sub s lpre (ls - lpre))
  else failwith "Invalid string"

let has_suffix pre s = 
  let ls = String.length s in
  let lpre = String.length pre in
  (ls >= lpre) && (String.sub s (ls - lpre) lpre) = pre

let name, args, scripts = 
  match (Array.to_list Sys.argv) with
    | _ :: name :: args :: scripts -> (name,args,scripts)
    | _ -> 
	Printf.eprintf "Please specify bench name and size list";
	exit 1

let scripts ext = List.filter (has_suffix ext) scripts

let gen = name ^ ".ml"
let xml = name

let args =  List.map int_of_string (split ',' args)

let sp = sprintf
let langs = 
  [
(*    "CDuce PXP", ".cd",
    (fun script xml -> 
       sp "%s --pxp --quiet %s --arg %s" cduce_cmd script xml);  *)

    "CDuce", ".cd",
    (fun script xml -> 
       sp "%s %s --no ocaml --arg %s" cduce_cmd script xml);
(*    "CDuce.old", ".cd",
    (fun script xml -> 
       sp "%s --quiet %s --arg %s" (cduce_cmd^".old") script xml);*)

    "XDuce 0.4.0", ".q",
    (fun script xml -> 
       sp "%s %s %s" xduce_cmd script xml); 

    "XDuce 0.2.4", ".q",
    (fun script xml -> 
       sp "%s %s %s" xduce_024_cmd script xml); 

    "XDuce 0.2.4 - patopt", ".q",
    (fun script xml -> 
       sp "%s %s -patopt %s" xduce_024_cmd script xml);

    "XSLT", ".xsl",
    (fun script xml -> 
       sp "%s --noout %s %s" xslt_cmd script xml);
  ]
  

let pr = printf
let rep = 3

let time s =
  let s = sp "%s -p %s 2>&1" time_cmd s in
(*  pr "Running: %s\n" s;  *)
  flush stdout;
  for i = 1 to rep do
    let ic = Unix.open_process_in s in
    let real = input_line ic in
    let user = input_line ic in
    let sys  = input_line ic in
    match  (Unix.close_process_in ic) with
      | Unix.WEXITED 0 ->
	  pr "%s,%s " 
	    (extract_prefix "user " user)
	    (extract_prefix "real " real); 
	  flush stdout;
      | _ ->
	  pr "err"
  done;
  pr "\n"

let run s = 
  flush stdout; 
  ignore (Sys.command s)

let () =
  List.iter
    (fun s ->
       let fn = sp "%s.%i.xml" xml s in
       if not (Sys.file_exists fn) then
	 run (sp "ocaml %s %i > %s" gen s fn);
       let ic = open_in fn in
       let size = in_channel_length ic in
       close_in ic;
       pr "XML size = %i; records = %i\n" size s;
       List.iter
	 (fun (lang, ext, cmd) ->
	    List.iter
	      (fun file ->
		 pr "%20s[%20s] " lang file;
		 time (cmd file fn)
	      ) (scripts ext)
	 )
	 langs;
       pr "====================================\n"
    )
    args
cduce-0.6.0/benchmarks/split.ml000066400000000000000000000010731230562553500164110ustar00rootroot00000000000000let random_string n =
  let s = String.create n in
  for i = 0 to n - 1 do
    s.[i] <- Char.chr (65 + (Random.int 26))
  done;
  s;;
    
let nb = int_of_string Sys.argv.(1);;

print_string "";;

let rec person p =
  Printf.printf "%s\n"
    (if Random.int 2 = 0 then "M" else "F")
    (random_string 20);
  if p < 5 then  for i = 1 to Random.int 5 do person (p+1) done;
  Printf.printf "\n";;

for i = 1 to nb do
  person 0;
done;;

print_string "";;
cduce-0.6.0/benchmarks/split0.cd000066400000000000000000000013661230562553500164540ustar00rootroot00000000000000type Person = FPerson | MPerson
type FPerson = [ Name Children ]
type MPerson = [ Name Children ]
type Children = [Person*]
type Name = [ PCDATA ]

type Man = [ Sons Daughters ]
type Woman = [ Sons Daughters ]
type Sons = [ Man* ]
type Daughters = [ Woman* ]

let split (MPerson -> Man ; FPerson -> Woman)
 [ n [(mc::MPerson | fc::FPerson)*] ] ->
   let tag = match g with "F" -> `woman | "M" -> `man in
   let s = map mc with x -> split x in
   let d = map fc with x -> split x in       
   <(tag) name=n>[ s  d ] 

match argv [] with
  | [ f ] -> load_xml f
  | _ -> raise "Invalid command line"
cduce-0.6.0/benchmarks/split1.cd000066400000000000000000000015251230562553500164520ustar00rootroot00000000000000type Person = FPerson | MPerson
type FPerson = [ Name Children ]
type MPerson = [ Name Children ]
type Children = [Person*]
type Name = [ PCDATA ]

type Man = [ Sons Daughters ]
type Woman = [ Sons Daughters ]
type Sons = [ Man* ]
type Daughters = [ Woman* ]

let split (MPerson -> Man ; FPerson -> Woman)
 [ n [(mc::MPerson | fc::FPerson)*] ] ->
   let tag = match g with "F" -> `woman | "M" -> `man in
   let s = map mc with x -> split x in
   let d = map fc with x -> split x in       
   <(tag) name=n>[ s  d ] 

match argv [] with
  | [ f ] -> 
   (match (load_xml f :? [ Person* ]) with
    |  <_>l -> print_xml ((map l with x -> split x)))
  | _ -> raise "Invalid command line"
cduce-0.6.0/benchmarks/split1.q000066400000000000000000000024241230562553500163230ustar00rootroot00000000000000import "xml.q"

type Person = FPerson | MPerson
type FPerson = person[ @gender["F"], Name, Children ]
type MPerson = person[ @gender["M"], Name, Children ]
type Children = children[Person*]
type Name = name[ String ]

type Man = man[  @name[String], Sons,Daughters ]
type Woman = woman[ @name[String], Sons,Daughters ]
type Sons = sons[ Man* ]
type Daughters = daughters[ Woman* ]

fun split_children (val c as Person* ) : (Sons,Daughters) =
 let val s = filter c {( val m as MPerson { split_m(m) } | FPerson { () })*} in
 let val d = filter c {( MPerson { () } | val f as FPerson { split_f(f) })*} in
 sons[s], daughters[d]

fun split_m (val p as MPerson) : Man =
 match p with
  person[ @gender[String], name[val n], children[val c] ] ->
   man[ @name[n], split_children(c) ] 

fun split_f (val p as FPerson) : Woman =
 match p with
  person[ @gender[String], name[val n], children[val c] ] ->
   woman[ @name[n], split_children(c) ]

fun split_seq (val p as Person* ) : (Man|Woman)* =
 filter p { 
   ( val f as FPerson { split_f(f) } 
   | val m as MPerson { split_m(m) })* 
 }

let val _ = 
 match argv() with
  val fn as String ->
   ( match load_xml(fn) with
       doc[val p as Person*] -> doc[ split_seq(p) ]
     | Any -> raise("Invalid document") )
 | Any -> raise("Invalid command line")
cduce-0.6.0/benchmarks/split1.xsl000066400000000000000000000013271230562553500166720ustar00rootroot00000000000000



  
    
      
    
    
      
    
  



  
    
      
    
    
      
    
  



cduce-0.6.0/benchmarks/split2.cd000066400000000000000000000015331230562553500164520ustar00rootroot00000000000000type Person = FPerson | MPerson
type FPerson = [ Name Children ]
type MPerson = [ Name Children ]
type Children = [Person*]
type Name = [ PCDATA ]

type Man = [ Sons Daughters ]
type Woman = [ Sons Daughters ]
type Sons = [ Man* ]
type Daughters = [ Woman* ]

let split (MPerson -> Man ; FPerson -> Woman)
 <_ gender=g>[ <_>n <_>[(mc::<_ gender="M">_ | fc::_)*] ] ->
   let tag = match g with "F" -> `woman | "M" -> `man in
   let s = map mc with x -> split x in
   let d = map fc with x -> split x in       
   <(tag) name=n>[ s  d ] 

match argv [] with
  | [ f ] -> 
   (match load_xml f with
    |  (l & [Person*]) -> (map l with x -> split x)
    | _ -> raise "Invalid document") 
  | _ -> raise "Invalid command line"
cduce-0.6.0/benchmarks/split2.q000066400000000000000000000025171230562553500163270ustar00rootroot00000000000000import "xml.q"

type Person = FPerson | MPerson
type MPerson = person[ @gender["M"], Name, Children ]
type FPerson = person[ @gender["F"], Name, Children ]
type Children = children[Person*]
type Name = name[ String ]

type Man = man[  @name[String], Sons,Daughters ]
type Woman = woman[ @name[String], Sons,Daughters ]
type Sons = sons[ Man* ]
type Daughters = daughters[ Woman* ]

fun split_children (val c as Person* ) : (Sons,Daughters) =
 let val s = filter c {( val m as ~[ @gender["M"], ~[Any]* ] { split_m(m) } | ~[Any] { () })*} in
 let val d = filter c {( val f as ~[ @gender["F"], ~[Any]* ] { split_f(f) } | ~[Any] { () })*} in
 sons[s], daughters[d]

fun split_m (val p as MPerson) : Man =
 match p with
  ~[ @gender[String], ~[val n], ~[val c] ] ->
   man[ @name[n], split_children(c) ] 

fun split_f (val p as FPerson) : Woman =
 match p with
  ~[ @gender[String], ~[val n], ~[val c] ] ->
   woman[ @name[n], split_children(c) ]

fun split_seq (val p as Person* ) : (Man|Woman)* =
 filter p { 
   ( val f as ~[ @gender["F"], ~[Any], ~[Any] ] { split_f(f) } 
   | val m as ~[ @gender["M"], ~[Any], ~[Any] ] { split_m(m) })* 
 }

let val _ = 
 match argv() with
  val fn as String ->
   ( match load_xml(fn) with
       doc[val p as Person*] -> doc[ split_seq(p) ]
     | Any -> raise("Invalid document") )
 | Any -> raise("Invalid command line")

cduce-0.6.0/benchmarks/split2.xsl000066400000000000000000000013011230562553500166630ustar00rootroot00000000000000



  
    
      man
      women
    
  
  
    
      
    
    
      
    
    
      
    
  



cduce-0.6.0/benchmarks/split3.cd000066400000000000000000000020321230562553500164460ustar00rootroot00000000000000type Person = FPerson | MPerson
type FPerson = [ Name Children ]
type MPerson = [ Name Children ]
type Children = [Person*]
type Name = [ PCDATA ]

type Man = [ Sons Daughters ]
type Woman = [ Sons Daughters ]
type Sons = [ Man* ]
type Daughters = [ Woman* ]

let split_m (MPerson -> Man)
 <_ ..>[ <_>n <_>[(mc::<_ gender="M">_ | fc::_)*] ] ->
   let s = map mc with x -> split_m x in
   let d = map fc with x -> split_f x in       
   [ s  d ] 

let split_f (FPerson -> Woman)
 <_ ..>[ <_>n <_>[(mc::<_ gender="M">_ | fc::_)*] ] ->
   let s = map mc with x -> split_m x in
   let d = map fc with x -> split_f x in       
   [ s  d ] 

match argv [] with
  | [ f ] -> 
   (match load_xml f with
    |  (l & [Person*]) -> 
         (map l with x & MPerson -> split_m x | x & FPerson -> split_f x)
    | _ -> raise "Invalid document") 
  | _ -> raise "Invalid command line"
cduce-0.6.0/benchmarks/split3.q000066400000000000000000000031751230562553500163310ustar00rootroot00000000000000import "xml.q"

type Person = FPerson | MPerson
type MPerson = person[ @gender["M"], Name, Children ]
type FPerson = person[ @gender["F"], Name, Children ]
type Children = children[Person*]
type Name = name[ String ]

type Man = man[  @name[String], Sons,Daughters ]
type Woman = woman[ @name[String], Sons,Daughters ]
type Sons = sons[ Man* ]
type Daughters = daughters[ Woman* ]

fun split_mpersons (val c as Person* ) : Man* = match c with
  val m as ~[ @gender["M"], ~[Any]* ], val rest -> 
    split_m(m), split_mpersons(rest)
| ~[Any], val rest ->
    split_mpersons(rest)
| () -> 
    ()

fun split_fpersons (val c as Person* ) : Woman* = match c with
  val f as ~[ @gender["F"], ~[Any]* ], val rest -> 
    split_f(f), split_fpersons(rest)
| ~[Any], val rest ->
    split_fpersons(rest)
| () -> 
    ()

fun split_children (val c as Person* ) : (Sons,Daughters) =
 let val s = split_mpersons(c) in
 let val d = split_fpersons(c) in
 sons[s], daughters[d]

fun split_m (val p as MPerson) : Man =
 match p with
  ~[ @gender[String], ~[val n], ~[val c] ] ->
   man[ @name[n], split_children(c) ] 

fun split_f (val p as FPerson) : Woman =
 match p with
  ~[ @gender[String], ~[val n], ~[val c] ] ->
   woman[ @name[n], split_children(c) ]

fun split_seq (val p as Person* ) : (Man|Woman)* =
 filter p { 
   ( val f as ~[ @gender["F"], ~[Any], ~[Any] ] { split_f(f) } 
   | val m as ~[ @gender["M"], ~[Any], ~[Any] ] { split_m(m) })* 
 }

let val _ = 
 match argv() with
  val fn as String ->
   ( match load_xml(fn) with
       doc[val p as Person*] -> doc[ split_seq(p) ]
     | Any -> raise("Invalid document") )
 | Any -> raise("Invalid command line")

cduce-0.6.0/cdo2cmo/000077500000000000000000000000001230562553500141345ustar00rootroot00000000000000cduce-0.6.0/cdo2cmo/.cvsignore000066400000000000000000000000371230562553500161340ustar00rootroot00000000000000*.cmi
*.cmo
*.cmx
*.cma
*.cmxa
cduce-0.6.0/cduce-expat.spec000066400000000000000000000042561230562553500156730ustar00rootroot00000000000000Summary: a language for fast and type safe processing of XML documents.
Name: cduce
Version: 0.1.0
Release: 1
URL: http://www.cduce.org/
Source : http://www.cduce.org/download/%{name}-%{version}.tar.gz
License: MIT
Group: Development/Languages
BuildRoot: %{_tmppath}/%{name}-root
Requires: ocaml >= 3.06    
Requires: findlib >= 0.8   
Requires: pcre-ocaml 
Requires: ocamlnet  >= 0.96
Requires: pxp >= 1.1.9
Requires: expat >= 1.95.6

%description

CDuce,  is a functional language for fast and type safe
processing  of XML documents.

A  complete  documentation,  reference  manual,  tutorial,
technical   articles  on  implementation  and  theoretical
issues, benchmarks, source code, mailing lists and  forums
can be found on the CDuce website: http://www.cduce.org.

%prep
rm -rf $RPM_BUILD_ROOT
%setup -q

%build
cd expat
make all   
make install
cd ..
make cduce dtd2cduce webpages EXPAT=true PHP=false NATIVE=true PXP_WLEX=false

%install
rm -rf $RPM_BUILD_ROOT
mkdir -p $RPM_BUILD_ROOT%{_bindir}
mkdir -p $RPM_BUILD_ROOT%{_mandir}/man1

install -s -m 755 cduce $RPM_BUILD_ROOT%{_bindir}/cduce
install -s -m 755 dtd2cduce $RPM_BUILD_ROOT%{_bindir}/dtd2cduce
install -m 644 doc/cduce.1 $RPM_BUILD_ROOT%{_mandir}/man1/cduce.1

%post
cd %{_docdir}/%{name}-%{version}/www
ln -s ../img ./
cd ..
ln -s www/manual.html ./


%postun
rm -rf  %{_docdir}/%{name}-%{version}

%clean
rm -rf $RPM_BUILD_ROOT

%files
%defattr(-,root,root)
%doc README CHANGES web/www web/img

%{_bindir}/cduce
%{_bindir}/dtd2cduce
%{_mandir}/man1/cduce.1*

%changelog
* Mon Sep  1 2003 Giuseppe Castagna 
0.1.1
  * Various bug fixes  (expat might now work)
  * Sequencing operator   e1;e2  (equivalent to: let [] = e1 in e2)
  * Encoded references

* Fri Jul  4 2003 Giuseppe Castagna 
0.1.0
  * Support for XML Namespaces
  * Better support for expat; clean Makefile
  * Get rid of ;; and let fun in examples
  * Optional ; for record in attribute position (values and types/patterns)
  * Split --dump into --load and --save
  * Better handling of strings (specific node in AST)
  * Map, transform: tail-recursive implementation
  * Preliminary support for XML Schema
  * Various bug fixes



cduce-0.6.0/cduce.spec000066400000000000000000000042441230562553500145510ustar00rootroot00000000000000Summary: a language for fast and type safe processing of XML documents.
Name: cduce
Version: 0.4.0
Release: 1
URL: http://www.cduce.org/
Source: cduce-%{version}.tar.gz
License: MIT
Group: Development/Languages
BuildRoot: %{_tmppath}/%{name}-root
Requires: pcre >= 4.5

%description

CDuce is a functional language for fast and type safe
processing  of XML documents.

A  complete  documentation,  reference  manual,  tutorial,
technical   articles  on  implementation  and  theoretical
issues, benchmarks, source code, mailing lists and  forums
can be found on the CDuce website: http://www.cduce.org.

%prep
%setup -D -q
cat > find_requires.sh << EOF
#!/bin/sh
/usr/lib/rpm/find-requires | fgrep -v libpcre.so.3
exit 0
EOF
chmod +x find_requires.sh

%define __find_requires %_builddir/%name-%version/find_requires.sh

%build
./configure --without-expat --without-curl --with-ocamlopt
make 

%install
rm -rf %{buildroot}
make install_bin BINDIR=%{buildroot}%{_bindir}
make install_doc MANDIR=%{buildroot}%{_mandir} DOCDIR=%{buildroot}%{_docdir}/cduce

%post
[ -a /lib/libpcre.so.3 -o -a /usr/lib/libpcre.so.3 ] || {
  { { LIBPCRE0=/lib/libpcre.so.0 && [ -a $LIBPCRE0 ]; } ||
    { LIBPCRE0=/usr/lib/libpcre.so.0 && [ -a $LIBPCRE0 ]; }
  } && ln -s $LIBPCRE0 /usr/lib/libpcre.so.3
}

%clean
rm -rf %{buildroot}

%files
%defattr(-,root,root)
%{_docdir}/cduce
%{_bindir}/cduce
%{_bindir}/dtd2cduce
%{_mandir}/man1/*cduce.1*

%changelog
* Fri Apr  7 2006 Nils Gesbert  0.4.0
  Updated the spec file for cduce 0.4.0

* Mon Sep  1 2003 Giuseppe Castagna 
0.1.1
  * Various bug fixes  (expat might now work)
  * Sequencing operator   e1;e2  (equivalent to: let [] = e1 in e2)
  * Encoded references

* Fri Jul  4 2003 Giuseppe Castagna 
0.1.0
  * Support for XML Namespaces
  * Better support for expat; clean Makefile
  * Get rid of ;; and let fun in examples
  * Optional ; for record in attribute position (values and types/patterns)
  * Split --dump into --load and --save
  * Better handling of strings (specific node in AST)
  * Map, transform: tail-recursive implementation
  * Preliminary support for XML Schema
  * Various bug fixes



cduce-0.6.0/cduce_mktop000077500000000000000000000014571230562553500150400ustar00rootroot00000000000000#!/bin/sh

FLAGS=
LINK=
NATIVE=true

while true; do
 case "$1" in
   -I)
    FLAGS="$FLAGS -I $2"
    shift
    shift
    ;;
   -p)
    FLAGS="$FLAGS -I `ocamlfind query $2`"
    LINK="$LINK -package $2"
    shift
    shift
    ;;
   -l)
    LINK="$LINK $2"
    shift
    shift
    ;;
  -byte)
    NATIVE=false
    shift
    ;;
  *)
    break
    ;;
 esac
done

TARG=$1
PRIMS=$2

if [ "${TARG}" = "" ] || [ "${PRIMS}" = "" ]; then
  echo "Usage: cduce_mktop [(-I path | -p package | -l unit.cmo/cma/cmx/cmxa) ...]  "
  exit 2
fi


if [ ${NATIVE} = "true" ]; then
 CAML=ocamlopt
else
 CAML=ocamlc
fi

echo "Effective flags for CDuce: $FLAGS"
echo "Effective flags for OCaml: $LINK"

exec ocamlfind $CAML -package cduce -o $TARG $FLAGS -linkpkg -pp "cduce --topstub $FLAGS" $LINK -impl $PRIMS
cduce-0.6.0/compile/000077500000000000000000000000001230562553500142365ustar00rootroot00000000000000cduce-0.6.0/compile/.cvsignore000066400000000000000000000000261230562553500162340ustar00rootroot00000000000000*.cmi
*.cmo
*.cmx
*.o
cduce-0.6.0/compile/auto_opt.ml000066400000000000000000000076571230562553500164410ustar00rootroot00000000000000open Ident
open Patterns.Compile

type node = ptr ref
and ptr = Disp of descr | Link of node
and descr = { disp: dispatcher; mutable minimized: bool }

let rec repr n = match !n with Disp _ -> n | Link n -> repr n
let descr n = match !n with Disp d -> d | _ -> assert false
let log = ref []
let link n1 n2 = log := (n1, !n1) :: !log; n1 := Link n2
let backtrack n0 =
  let rec aux = function
    | (n,d)::rest -> n := d; if (n != n0) then aux rest else log := rest
    | _ -> assert false
  in
  aux !log

let nodes = Hashtbl.create 64

let node_of d =
  try Hashtbl.find nodes (id d)
  with Not_found ->
    let n = ref (Disp { disp = d; minimized = false }) in
    Hashtbl.add nodes (id d) n;
    n

exception Not_equal

let rec check_equal_nodes n1 n2 =
  let n1 = repr n1 and n2 = repr n2 in
  if (n1 != n2) then (
    let d1 = descr n1 and d2 = descr n2 in
    if d1.minimized && d2.minimized then raise Not_equal;
    let n1,n2 = if d1.minimized then (n2,n1) else (n1,n2) in
    link n1 n2;
    try check_equal_actions (actions d1.disp) (actions d2.disp)
    with Not_equal -> backtrack n1; raise Not_equal
  )
and check_equal_actions a1 a2 = match a1,a2 with
  | AIgnore r1, AIgnore r2 -> check_equal_results r1 r2
  | AKind k1, AKind k2 -> 
      (check_equal_basics k1.basic k2.basic;
       check_equal_prods k1.prod k2.prod;
       check_equal_prods k1.xml k2.xml;
       match k1.record,k2.record with
	 | Some(RecLabel(l1,p1)), Some(RecLabel(l2,p2)) 
	     when Label.equal l1 l2 ->
	     check_equal_prods p1 p2
	 | Some(RecNolabel (a1,b1)), Some(RecNolabel (a2,b2)) -> 
	     check_equal_result_options a1 a2;
	     check_equal_result_options b1 b2;
	 | None, None -> ()
	 | _ -> raise Not_equal)
  | _ -> raise Not_equal
and check_equal_result_options a1 a2 = match a1,a2 with
  | Some r1, Some r2 -> check_equal_results r1 r2
  | None, None -> ()
  | _ -> raise Not_equal
and check_equal_prods a1 a2 = match a1,a2 with
  | Dispatch (d1,r1), Dispatch (d2,r2) when Array.length r1 = Array.length r2 ->
      check_equal_disps d1 d2;
      Array.iteri (fun i x -> check_equal_prod2 x r2.(i)) r1
  | TailCall d1, TailCall d2 -> check_equal_disps d1 d2
  | Ignore c1, Ignore c2 -> check_equal_prod2 c1 c2
  | Impossible, Impossible -> ()
  | _ -> raise Not_equal
and check_equal_prod2 a1 a2 = match a1,a2 with
  | Dispatch (d1,r1), Dispatch (d2,r2) when Array.length r1 = Array.length r2 ->
      check_equal_disps d1 d2;
      Array.iteri (fun i x -> check_equal_results x r2.(i)) r1
  | TailCall d1, TailCall d2 -> check_equal_disps d1 d2
  | Ignore c1, Ignore c2 -> check_equal_results c1 c2
  | Impossible, Impossible -> ()
  | _ -> raise Not_equal
and check_equal_disps d1 d2 =
  if d1 == d2 then ()
  else check_equal_nodes (node_of d1) (node_of d2)
and check_equal_results (c1,s1,p1) (c2,s2,p2) =
  if (c1 != c2) || (p1 != p2) || (Array.length s1 != Array.length s2) 
  then raise Not_equal;
  Array.iteri (fun i x -> check_equal_source x s2.(i)) s1
and check_equal_source s1 s2 = if (s1 != s2) then match s1,s2 with
  | Const c1, Const c2 when Types.Const.equal c1 c2 -> ()
  | Stack i1, Stack i2 when i1 == i2 -> ()
  | Recompose (i1,j1), Recompose (i2,j2) when i1 == i2 && j1 == j2 -> ()
  | _ -> raise Not_equal
and check_equal_basics a1 a2 =
  if (List.length a1 != List.length a2) then raise Not_equal;
  List.iter2 (fun (t1,r1) (t2,r2) -> 
		if not (Types.equiv t1 t2) then raise Not_equal;
		check_equal_results r1 r2) a1 a2

let equal_nodes n1 n2 =
  try check_equal_nodes n1 n2; true
  with Not_equal -> false

let minimized = ref []

let rec auto d =
  let n = node_of d in
  if not (List.exists (equal_nodes n) !minimized) then
    let n = repr n in
    (descr n).minimized <- true;
    minimized := n :: !minimized;
    iter_disp_actions auto (actions d)

let make_branches t brs =
  let d,r = make_branches t brs in
  auto d;
  d,r

let () =
  Stats.register Stats.Summary
    (fun ppf ->
       Format.fprintf ppf 
	 "Number of minimized states:%i@." 
	 (List.length !minimized));
cduce-0.6.0/compile/auto_opt.mli000066400000000000000000000001621230562553500165720ustar00rootroot00000000000000open Patterns
open Patterns.Compile

val make_branches : Types.t -> (node * 'a) list -> dispatcher * 'a rhs array
cduce-0.6.0/compile/auto_pat.ml000066400000000000000000000016361230562553500164120ustar00rootroot00000000000000(* The automata for pattern matching *)
open Ident

type source =
  | Catch | Const of Types.const 
  | Stack of int | Left | Right | Nil | Recompose of int * int

type result = int * source array * int
    (* Return code, result values, number of values to pop *)

type actions =
  | AIgnore of result
  | AKind of actions_kind
and actions_kind = {
  basic: (Types.t * result) list;
  atoms: result Atoms.map;
  chars: result Chars.map;
  prod: result dispatch dispatch;
  xml: result dispatch dispatch;
  record: record option;
}
and record =
  | RecLabel of label * result dispatch dispatch
  | RecNolabel of result option * result option
and 'a dispatch =
  | Dispatch of state * 'a array
  | TailCall of state
  | Ignore of 'a
  | Impossible

and state = {
  uid : int;
  arity : int array;
  mutable actions: actions;
  mutable fail_code: int;
  mutable expected_type: string;
}


type 'a rhs = Match of int * 'a | Fail
cduce-0.6.0/compile/auto_pat.mli000066400000000000000000000016361230562553500165630ustar00rootroot00000000000000(* The automata for pattern matching *)
open Ident

type source =
  | Catch | Const of Types.const 
  | Stack of int | Left | Right | Nil | Recompose of int * int

type result = int * source array * int
    (* Return code, result values, number of values to pop *)

type actions =
  | AIgnore of result
  | AKind of actions_kind
and actions_kind = {
  basic: (Types.t * result) list;
  atoms: result Atoms.map;
  chars: result Chars.map;
  prod: result dispatch dispatch;
  xml: result dispatch dispatch;
  record: record option;
}
and record =
  | RecLabel of label * result dispatch dispatch
  | RecNolabel of result option * result option
and 'a dispatch =
  | Dispatch of state * 'a array
  | TailCall of state
  | Ignore of 'a
  | Impossible

and state = {
  uid : int;
  arity : int array;
  mutable actions: actions;
  mutable fail_code: int;
  mutable expected_type: string;
}


type 'a rhs = Match of int * 'a | Fail
cduce-0.6.0/compile/compile.ml000066400000000000000000000224241230562553500162240ustar00rootroot00000000000000open Ident
open Lambda

type env = {
  cu: Compunit.t option;  (* None: toplevel *)
  vars: var_loc Env.t;
  stack_size: int;
  max_stack: int ref;
  global_size: int
}

let global_size env = env.global_size

let mk cu = { cu = cu; vars = Env.empty; stack_size = 0; max_stack = ref 0; global_size = 0 }
let empty_toplevel = mk None
let empty x = mk (Some x)

let find x env =
  try Env.find x env.vars
  with Not_found -> 
    failwith ("Compile: cannot find " ^ (Ident.to_string x))

let find_slot x env =
  match find x env with
    | Ext (_,slot) -> slot
    | _ -> assert false
 
let from_comp_unit = ref (fun cu -> assert false)

let find_ext cu x =
  let env = !from_comp_unit cu in
  find x env

let enter_local env x =
  let new_size = env.stack_size + 1 in
  if new_size > !(env.max_stack) then (env.max_stack) := new_size;
  { env with 
      vars = Env.add x (Local env.stack_size) env.vars;
      stack_size = new_size }

let enter_global_toplevel env x =
  { env with 
      vars = Env.add x (Global env.global_size) env.vars;
      global_size = env.global_size + 1 }

let enter_global_cu cu env x =
  { env with 
      vars = Env.add x (Ext (cu,env.global_size)) env.vars;
      global_size = env.global_size + 1 }

let rec compile env e = compile_aux env e.Typed.exp_descr
and compile_aux env = function
  | Typed.Forget (e,_) -> compile env e
  | Typed.Check (t0,e,t) -> 
      let d = Patterns.Compile.make_checker !t0 (Types.descr t) in
      Check (compile env e, d)
  | Typed.Var x -> Var (find x env)
  | Typed.ExtVar (cu,x,_) -> Var (find_ext cu x)
  | Typed.Apply (e1,e2) -> Apply (compile env e1, compile env e2)
  | Typed.Abstraction a -> compile_abstr env a
  | Typed.Cst c -> Const (Value.const c)
  | Typed.Pair (e1,e2) -> Pair(compile env e1, compile env e2)
  | Typed.Xml (e1, { Typed.exp_descr = Typed.Pair (e2,e3) }, None) -> 
      Xml (compile env e1, compile env e2, compile env e3)
  | Typed.Xml (e1, { Typed.exp_descr = Typed.Pair (e2,e3) }, Some t) -> 
      XmlNs (compile env e1, compile env e2, compile env e3,t)
  | Typed.Xml _ -> assert false
  | Typed.RecordLitt r -> 
      let r = List.map (fun (l,e) -> (Upool.int l, compile env e)) 
	(LabelMap.get r)
      in
      Record (Imap.create (Array.of_list r))
  | Typed.String (i,j,s,q) -> String (i,j,s,compile env q)
  | Typed.Match (e,brs) -> Match (compile env e, compile_branches env brs)
  | Typed.Map (e,brs) -> Map (compile env e, compile_branches env brs)
  | Typed.Transform (e,brs) -> Transform (compile env e, compile_branches env brs)
  | Typed.Xtrans (e,brs) -> Xtrans (compile env e, compile_branches env brs)
  | Typed.Validate (e,_,validator) -> Validate (compile env e, validator)
  | Typed.RemoveField (e,l) -> RemoveField (compile env e,l)
  | Typed.Dot (e,l) -> Dot (compile env e, l)
  | Typed.Try (e,brs) -> Try (compile env e, compile_branches env brs)
  | Typed.Ref (e,t) ->  Ref (compile env e, t)
  | Typed.External (t,`Ext i) -> 
      (match env.cu with
	 | Some cu -> Var (External (cu,i))
	 | None -> failwith "Cannot compile externals in the toplevel")
  | Typed.External (t,`Builtin s) -> 
      Var (Builtin s)
  | Typed.Op (op,_,args) -> 
      let rec aux = function
	| [arg] -> [ compile env arg ]
	| arg::l -> (compile env arg) :: (aux l)
	| [] -> [] in
      Op (op, aux args)
  | Typed.NsTable (ns,e) ->
      NsTable (ns, compile_aux env e)

and compile_abstr env a =
  let fun_env = 
    match a.Typed.fun_name with
      | Some x -> Env.add x (Env 0) Env.empty
      | None -> Env.empty in

  let (slots,nb_slots,fun_env) = 
    List.fold_left 
      (fun (slots,nb_slots,fun_env) x ->
	 match find x env with
	   | (Local _ | Env _) as p -> 
	       p::slots,
	       succ nb_slots,
	       Env.add x (Env nb_slots) fun_env;
	   | Global _ | Ext _ | External _ | Builtin _ as p -> 
	       slots,
	       nb_slots,
	       Env.add x p fun_env
	   | Dummy -> assert false
      )
      ([Dummy],1,fun_env) (IdSet.get a.Typed.fun_fv) in


  let slots = Array.of_list (List.rev slots) in  
  let env = { env with vars = fun_env; stack_size = 0; max_stack = ref 0 } in
  let body = compile_branches env a.Typed.fun_body in
  Abstraction (slots, a.Typed.fun_iface, body, !(env.max_stack))

and compile_branches env (brs : Typed.branches) =
  (* Don't compile unused branches, because they have not been
     type checked. *)
  let used = List.filter (fun br -> br.Typed.br_used) brs.Typed.br_branches in
  let b = List.map (compile_branch env) used in
  let (disp,rhs) = Patterns.Compile.make_branches brs.Typed.br_typ b in
  { brs_stack_pos = env.stack_size;
    brs_accept_chars = not (Types.Char.is_empty brs.Typed.br_accept);
    brs_disp = disp;
    brs_rhs = rhs }

and compile_branch env br =
  let env = List.fold_left enter_local env (Patterns.fv br.Typed.br_pat) in
  (br.Typed.br_pat, compile env br.Typed.br_body)

let enter_globals env n =  match env.cu with
  | None -> List.fold_left enter_global_toplevel env n
  | Some cu -> List.fold_left (enter_global_cu cu) env n

let compile_expr env e =
  let env = { env with max_stack = ref 0; stack_size = 0 } in
  let e = compile env e in
  (e,!(env.max_stack))

let compile_let_decl env decl =
  let pat = decl.Typed.let_pat in
  let e,lsize = compile_expr env decl.Typed.let_body in
  let env = enter_globals env (Patterns.fv pat) in

  let te = decl.Typed.let_body.Typed.exp_typ in 
  let comp = Patterns.Compile.make_branches te [ pat, () ] in
  let (disp, n) = 
    match comp with
      | (disp, [| Auto_pat.Match (n, ()) |]) -> (disp,n)
      | _ -> assert false in
  (env, [ LetDecls (e,lsize,disp,n) ])

let compile_rec_funs env funs =
  let fun_name = function
    | { Typed.exp_descr=Typed.Abstraction{Typed.fun_name = Some x}} -> x
    | _ -> assert false in
  let fun_a env e =
    let e,lsize = compile_expr env e in
    LetDecl (e,lsize) in
  let env = enter_globals env (List.map fun_name funs) in
  let code= List.map (fun_a env) funs in
  (env, code)


(****************************************)

open Cduce_loc

let eval ~run ~show (tenv,cenv,codes) e =
  let (e,t) = Typer.type_expr tenv e in
  let e,lsize = compile_expr cenv e in
  if run then
    let v = Eval.expr e lsize in
    show None t (Some v)
  else
    show None t None;
  (tenv,cenv, Eval (e,lsize) :: codes)

let run_show ~run ~show tenv cenv codes ids =
  if run then
    let () = Eval.eval_toplevel codes in
    List.iter 
      (fun (id,_) -> show (Some id) 
	 (Typer.find_value id tenv)
	 (Some (Eval.eval_var (find id cenv)))) ids
  else
    List.iter 
      (fun (id,_) -> show (Some id) 
	 (Typer.find_value id tenv)
	 None) ids
  
let let_decl ~run ~show (tenv,cenv,codes) p e =
  let (tenv,decl,ids) = Typer.type_let_decl tenv p e in
  let (cenv,code) = compile_let_decl cenv decl in
  run_show ~run ~show tenv cenv code ids;
  (tenv,cenv,List.rev_append code codes)
  
let let_funs ~run ~show (tenv,cenv,codes) funs =
  let (tenv,funs,ids) = Typer.type_let_funs tenv funs in
  let (cenv,code) = compile_rec_funs cenv funs in
  run_show ~run ~show tenv cenv code ids;
  (tenv,cenv,List.rev_append code codes)
  
let type_defs (tenv,cenv,codes) typs =
  let tenv = Typer.type_defs tenv typs in
  (tenv,cenv,codes)

let namespace (tenv,cenv,codes) loc pr ns =
  let tenv = Typer.type_ns tenv loc pr ns in
  (tenv,cenv,codes)

let keep_ns (tenv,cenv,codes) k =
  let tenv = Typer.type_keep_ns tenv k in
  (tenv,cenv,codes)

let schema (tenv,cenv,codes) loc x sch =
  let tenv = Typer.type_schema tenv loc x sch in
  (tenv,cenv,codes)

let using (tenv,cenv,codes) loc x cu =
  let tenv = Typer.type_using tenv loc x cu in
  (tenv,cenv,codes)

let do_open (tenv,cenv,codes) loc path =
  let tenv = Typer.type_open tenv loc path in
  (tenv,cenv,codes)

let rec collect_funs accu = function
  | { descr = Ast.FunDecl e } :: rest -> collect_funs (e::accu) rest
  | rest -> (List.rev accu,rest)

let rec collect_types accu = function
  | { descr = Ast.TypeDecl ((loc,x),t) } :: rest -> 
      collect_types ((loc,x,t) :: accu) rest
  | rest -> (accu,rest)

let rec phrases ~run ~show ~directive =
  let rec loop accu phs =
    match phs with
      | { descr = Ast.FunDecl _ } :: _ -> 
	  let (funs,rest) = collect_funs [] phs in
	  loop (let_funs ~run ~show accu funs) rest
      | { descr = Ast.TypeDecl (_,_) } :: _ ->
	  let (typs,rest) = collect_types [] phs in
	  loop (type_defs accu typs) rest
      | { descr = Ast.SchemaDecl (name, uri); loc = loc } :: rest ->
	  loop (schema accu loc name uri) rest
      | { descr = Ast.Namespace (pr,ns); loc = loc } :: rest ->
	  loop (namespace accu loc pr ns) rest
      | { descr = Ast.KeepNs b } :: rest ->
	  loop (keep_ns accu b) rest
      | { descr = Ast.Using (x,cu); loc = loc } :: rest ->
	  loop (using accu loc x cu) rest
      | { descr = Ast.Open path; loc = loc } :: rest ->
	  loop (do_open accu loc path) rest
      | { descr = Ast.EvalStatement e } :: rest ->
	  loop (eval ~run ~show accu e) rest
      | { descr = Ast.LetDecl (p,e) } :: rest ->
	  loop (let_decl ~run ~show accu p e) rest
      | { descr = Ast.Directive d } :: rest ->
	  let (tenv,cenv,_) = accu in
	  directive tenv cenv d;
	  loop accu rest
      | [] -> 
	  accu
  in
  loop

let comp_unit ?(run=false) 
  ?(show=fun _ _ _ -> ()) 
  ?(directive=fun _ _ _ -> ())  tenv cenv phs =
  let (tenv,cenv,codes) = phrases ~run ~show ~directive (tenv,cenv,[]) phs in
  (tenv,cenv,List.rev codes)


let compile_eval_expr env e =
  let e,lsize = compile_expr env e in
  Eval.expr e lsize
cduce-0.6.0/compile/compile.mli000066400000000000000000000011121230562553500163640ustar00rootroot00000000000000(* From Ast to Lambda. *)

open Ident 
open Lambda

type env
val global_size: env -> int

val empty : Compunit.t -> env
val empty_toplevel : env

val find : id -> env -> var_loc
val find_slot : id -> env -> int

val compile_eval_expr : env -> Typed.texpr -> Value.t

val comp_unit:
  ?run:bool ->
  ?show:(id option -> Types.t -> Value.t option -> unit) ->
  ?directive:(Typer.t -> env -> Ast.toplevel_directive -> unit) ->

  Typer.t -> env -> Ast.pmodule_item list -> 
  Typer.t * env * Lambda.code_item list


val from_comp_unit: (Compunit.t -> env) ref
  (* Defined in Librarian *)
cduce-0.6.0/compile/lambda.ml000066400000000000000000000036241230562553500160150ustar00rootroot00000000000000(* Representation of programs used by the runtime evaluator.
   Similar to the typed abstract syntax tree representation, but:
   - the pattern matching is compiled;
   - the identifiers locations are resolved. *)

open Ident

type var_loc =
  | Local of int
      (* Slot in the table of locals *)
  | Env of int
      (* Slot in the environment *)
  | Ext of Compunit.t * int 
      (* Global slot from a given compilation unit *)
      (* If pos < 0, the first arg is the value *)
  | External of Compunit.t * int 
      (* OCaml External *)
      (* If pos < 0, the first arg is the value *)
  | Builtin of string
      (* OCaml external embedded in the runtime *)
  | Global of int 
      (* Only for the toplevel *)
  | Dummy

type expr = 
  | Var of var_loc
  | Apply of expr * expr
  | Abstraction of var_loc array * (Types.t * Types.t) list * branches * int
      (* environment, interface, branches, size of locals *)
  | Check of expr * Auto_pat.state
  | Const of Value.t
  | Pair of expr * expr
  | Xml of expr * expr * expr
  | XmlNs of expr * expr * expr * Ns.table
  | Record of expr Imap.t
  | String of U.uindex * U.uindex * U.t * expr
  | Match of expr * branches
  | Map of expr * branches
  | Transform of expr * branches
  | Xtrans of expr * branches
  | Try of expr * branches
  | Validate of expr * Schema_validator.t
  | RemoveField of expr * label
  | Dot of expr * label
  | Ref of expr * Types.Node.t
  | Op of string * expr list  
  | OpResolved of (Value.t list -> Value.t) * expr list
  | NsTable of Ns.table * expr

and branches = {
  brs_accept_chars: bool;
  brs_disp: Auto_pat.state;
  brs_rhs: expr Auto_pat.rhs array;
  brs_stack_pos: int
}

type code_item =
  | Eval of expr * int
      (* expression, size of locals *)
  | LetDecls of expr * int * Auto_pat.state * int
      (* expression, size of locals, dispatcher, number of globals to set *)
  | LetDecl of expr * int


type code = code_item list
cduce-0.6.0/compile/lambda.mli000066400000000000000000000036241230562553500161660ustar00rootroot00000000000000(* Representation of programs used by the runtime evaluator.
   Similar to the typed abstract syntax tree representation, but:
   - the pattern matching is compiled;
   - the identifiers locations are resolved. *)

open Ident

type var_loc =
  | Local of int
      (* Slot in the table of locals *)
  | Env of int
      (* Slot in the environment *)
  | Ext of Compunit.t * int 
      (* Global slot from a given compilation unit *)
      (* If pos < 0, the first arg is the value *)
  | External of Compunit.t * int 
      (* OCaml External *)
      (* If pos < 0, the first arg is the value *)
  | Builtin of string
      (* OCaml external embedded in the runtime *)
  | Global of int 
      (* Only for the toplevel *)
  | Dummy

type expr = 
  | Var of var_loc
  | Apply of expr * expr
  | Abstraction of var_loc array * (Types.t * Types.t) list * branches * int
      (* environment, interface, branches, size of locals *)
  | Check of expr * Auto_pat.state
  | Const of Value.t
  | Pair of expr * expr
  | Xml of expr * expr * expr
  | XmlNs of expr * expr * expr * Ns.table
  | Record of expr Imap.t
  | String of U.uindex * U.uindex * U.t * expr
  | Match of expr * branches
  | Map of expr * branches
  | Transform of expr * branches
  | Xtrans of expr * branches
  | Try of expr * branches
  | Validate of expr * Schema_validator.t
  | RemoveField of expr * label
  | Dot of expr * label
  | Ref of expr * Types.Node.t
  | Op of string * expr list  
  | OpResolved of (Value.t list -> Value.t) * expr list
  | NsTable of Ns.table * expr

and branches = {
  brs_accept_chars: bool;
  brs_disp: Auto_pat.state;
  brs_rhs: expr Auto_pat.rhs array;
  brs_stack_pos: int
}

type code_item =
  | Eval of expr * int
      (* expression, size of locals *)
  | LetDecls of expr * int * Auto_pat.state * int
      (* expression, size of locals, dispatcher, number of globals to set *)
  | LetDecl of expr * int


type code = code_item list
cduce-0.6.0/compile/operators.ml000066400000000000000000000032141230562553500166060ustar00rootroot00000000000000open Cduce_loc
type type_fun = Types.t -> bool -> Types.t

let register op arity typ eval =
  Typer.register_op op arity typ;
  Eval.register_op op eval

let register_unary op typ eval =
  register op 1
    (function
       | [ tf ] -> 
	   typ tf
       | _ ->
	   raise (Typer.Error (
	     ("Built-in operator " ^ op ^ " needs exactly one argument")))
    )
    (function
       | [ v ] -> eval v
       | _ -> assert false
    )

let register_binary op typ eval =
  register op 2
    (function
       | [ tf1; tf2 ] -> 
	   typ tf1 tf2
       | _ ->
	   raise (Typer.Error (
	     ("Built-in operator " ^ op ^ " needs exactly two arguments")))
    )
    (function
       | [ v1; v2 ] -> eval v1 v2
       | _ -> assert false
    )

let register_cst op t v =
  register op 0
    (function
       | [ ] -> fun _ _  -> t
       | _ -> assert false)
    (function
       | [ ] -> v
       | _ -> assert false
    )

let register_fun op dom codom eval =
  register_cst op
    (Types.arrow (Types.cons dom) (Types.cons codom))
    (Value.Abstraction (Some [(dom,codom)],eval))

let register_fun2 op dom1 dom2 codom eval =
  let t2 = Types.arrow (Types.cons dom2) (Types.cons codom) in
  let iface2 = Some [(dom2,codom)] in
  register_cst op
    (Types.arrow (Types.cons dom1) (Types.cons t2))
    (Value.Abstraction (Some [(dom1,t2)],(fun v1 ->
					    Value.Abstraction (iface2,
							       eval v1))))
let register_op op ?(expect=Types.any) typ eval =
  register_unary op 
    (fun tf _ _ -> let t = tf expect true in typ t)
    eval

let register_op2 op t1 t2 s eval =
  register_binary op
    (fun tf1 tf2 _ _ -> ignore (tf1 t1 false); ignore (tf2 t2 false); s)
    eval
cduce-0.6.0/compile/operators.mli000066400000000000000000000013551230562553500167630ustar00rootroot00000000000000open Cduce_loc
type type_fun = Types.t -> bool -> Types.t

val register: 
  string -> int -> (type_fun list -> type_fun) -> (Value.t list -> Value.t) -> unit

val register_unary: 
  string -> (type_fun -> type_fun) -> (Value.t -> Value.t) -> unit
val register_binary: 
  string -> (type_fun -> type_fun -> type_fun) -> (Value.t -> Value.t -> Value.t) -> unit

val register_fun: string -> Types.t -> Types.t -> (Value.t -> Value.t) -> unit
val register_fun2: string -> Types.t -> Types.t -> Types.t -> (Value.t -> Value.t -> Value.t) -> unit

val register_op: 
  string -> ?expect:Types.t -> (Types.t -> Types.t) -> (Value.t -> Value.t) -> unit

val register_op2: 
  string -> Types.t -> Types.t -> Types.t -> (Value.t -> Value.t -> Value.t) -> unit
cduce-0.6.0/compile/print_auto.ml000066400000000000000000000073511230562553500167620ustar00rootroot00000000000000open Auto_pat
open Ident

let queue = ref []
let printed = Hashtbl.create 1024

let rec_state ppf d =
  Format.fprintf ppf "disp_%i" d.uid;
  queue := d :: !queue

let rec print_source lhs ppf = function
  | Catch  -> Format.fprintf ppf "v"
  | Const c -> Types.Print.print_const ppf c
  | Nil -> Format.fprintf ppf "`nil"
  | Left -> Format.fprintf ppf "v1"
  | Right -> Format.fprintf ppf "v2"
  | Stack i -> Format.fprintf ppf "%s" (List.nth lhs (i-1))
  | Recompose (i,j) -> 
      Format.fprintf ppf "(%s,%s)" 
	(match i with (-1) -> "v1" | (-2) -> "nil" 
	   | i -> List.nth lhs (i-1))
	(match j with (-1) -> "v2" | (-2) -> "nil" 
	   | j -> List.nth lhs (j-1))
	
let print_result lhs ppf =
  Array.iteri 
    (fun i s ->
       if i > 0 then Format.fprintf ppf ",";
       print_source lhs ppf s; 
    )
    
let print_ret lhs ppf (code,ret,ar) = 
  Format.fprintf ppf "$%i" code;
  if Array.length ret <> 0 then 
    Format.fprintf ppf "(%a)" (print_result lhs) ret
      
let print_ret_opt ppf = function
  | None -> Format.fprintf ppf "*"
  | Some r -> print_ret [] ppf r
      
let gen_lhs prefix d code =
  let arity = d.arity.(code) in
  let r = ref [] in
  for i = 0 to arity - 1 do r := Format.sprintf "%s%i" prefix i :: !r done;
  !r
    
let print_kind ppf actions =
  let print_lhs ppf (code,lhs) =
    Format.fprintf ppf "$%i(" code;
    let rec aux = function
      | [] -> ()
      | [x] -> Format.fprintf ppf "%s" x
      | x::r -> Format.fprintf ppf "%s,x" x; aux r
    in aux lhs;
    Format.fprintf ppf ")" in
  let print_basic (t,ret) =
    Format.fprintf ppf " | %a -> %a@\n"
      Types.Print.print t
      (print_ret []) ret
  in
  let print_prod2 lhs = function
    | Impossible -> assert false
    | Ignore r ->
	Format.fprintf ppf "%a\n" 
	  (print_ret lhs) r
    | TailCall d ->
	Format.fprintf ppf "%a v2@\n" rec_state d
    | Dispatch (d, branches) ->
	Format.fprintf ppf "@\n        match %a v2 with@\n" rec_state d;
	Array.iteri 
	  (fun code r ->
	     let rhs = gen_lhs "r" d code in
	     Format.fprintf ppf "        | %a -> %a@\n" 
	       print_lhs (code,rhs)
	       (print_ret (rhs@lhs)) r;
   	  )
	  branches
  in
  let print_prod prefix ppf = function
    | Impossible -> ()
    | Ignore d2 ->
	Format.fprintf ppf " | %s(v1,v2) -> " prefix;
	print_prod2 [] d2
    | TailCall d ->
	Format.fprintf ppf " | %s(v1,v2) -> %a v1@\n" prefix rec_state d
    | Dispatch (d,branches) ->
	Format.fprintf ppf " | %s(v1,v2) -> @\n" prefix;
	Format.fprintf ppf "      match %a v1 with@\n" rec_state d;
	Array.iteri 
	  (fun code d2 ->
	     let lhs = gen_lhs "l" d code in
             Format.fprintf ppf "      | %a -> " print_lhs (code,lhs);
	     print_prod2 lhs d2;
   	  )
	  branches
  in
  let rec print_record_opt ppf = function
    | None -> ()
    | Some (RecLabel (l,d)) ->
	print_prod ("record:"^(Label.string_of_attr l)) ppf d
    | Some (RecNolabel (r1,r2)) ->
	Format.fprintf ppf " | Record -> @\n";
	Format.fprintf ppf "     SomeField:%a;NoField:%a@\n" 
          print_ret_opt r1 print_ret_opt r2
  in
  
  List.iter print_basic actions.basic;
  print_prod "" ppf actions.prod;
  print_prod "XML" ppf actions.xml;
  print_record_opt ppf actions.record
    
let print_actions ppf = function
  | AKind k -> print_kind ppf k
  | AIgnore r -> Format.fprintf ppf "v -> %a@\n" (print_ret []) r

let print_state_opt ppf d =
  if Hashtbl.mem printed d.uid then () 
  else (
    Hashtbl.add printed d.uid ();
    Format.fprintf ppf "State %i = function@\n" d.uid;
    print_actions ppf d.actions;
    Format.fprintf ppf "====================================@."
  )

let print_state ppf d =
  Hashtbl.clear printed;
  queue := [ d ];
  while !queue <> [] do
    let d = List.hd !queue in
    queue := List.tl !queue;
    print_state_opt ppf d
  done;
  Hashtbl.clear printed
 
cduce-0.6.0/compile/print_auto.mli000066400000000000000000000000741230562553500171260ustar00rootroot00000000000000val print_state: Format.formatter -> Auto_pat.state -> unit
cduce-0.6.0/configure000077500000000000000000000000421230562553500145110ustar00rootroot00000000000000#! /bin/sh
ocaml configure.ml $@

cduce-0.6.0/configure.ml000066400000000000000000000215351230562553500151270ustar00rootroot00000000000000(*
#use "topfind";;
#require "findlib";;
*)

open Printf

let not_distrib = Sys.file_exists "Makefile.distrib"

let usage () =
  print_string "\
Configuration of CDuce.

Usage: ./configure [OPTION]...

Defaults for the options are specified in brackets.

Options:
 --help                display this help and exit

Optional features:
 --with-FEATURE        force support for FEATURE [default: autodetect]
 --without-FEATURE     disable support for FEATURE [default: autodetect]

 Available features:
 ocamlopt              use ocamlopt instead of ocamlc to build CDuce
 pxp_wlex              use wlexers for parsing utf8 with PXP [default: false]
 pxp                   support for the PXP XML parser
 expat                 support for the expat XML parser
 curl                  support for the libcurl library
 netclient             support for the netclient library
 cgi                   support for the cgi library 

OCaml/CDuce interface:
 --mliface=DIR         build the interface with the OCaml sources in DIR

Installation directories:
 --prefix=PREFIX       install files in PREFIX [/usr/local]
 --bindir=DIR          install user executables in DIR [PREFIX/bin]
 --mandir=DIR          install man documentation in DIR [PREFIX/man]
 --docdir=DIR          install the rest of the doc in DIR [PREFIX/doc/cduce]
";
if not_distrib then print_string "
 --wprefix=WPREFIX     root directory of the web-server [/var/www]
 --cgidir=DIR          install the cgi-bin interpreter in DIR [WPREFIX/cgi-bin]
 --htmldir=DIR         install the website in DIR [WPREFIX/html]
 --sessiondir=DIR      store the open sessions of the cgi-bin in DIR 
                       [/tmp/cduce_sessions]
"

let features = 
  [ "ocamlopt", ref `auto;
    "mliface", ref `auto;
    "pxp", ref `auto;
    "expat", ref `auto;
    "curl", ref `auto;
    "netclient", ref `auto;
    "cgi", ref `auto;
    "pxp_wlex", ref `no ]
  
let vars = 
  [ "prefix", ref "/usr/local";
    "bindir", ref "";
    "mandir", ref "";
    "docdir", ref "";

    "wprefix", ref "/var/www";
    "cgidir", ref "";
    "htmldir", ref "";

    "sessiondir", ref "/tmp/cduce_sessions";
    "mliface", ref ""
  ]


let src_dirs = ["/usr/src"; "/usr/local/src"; "/tmp"]
	
let fatal s = printf "*** Fatal error: %s\n" s; exit 1
let warning s = printf "* Warning: %s\n" s

let log s =
  let oc = open_out_gen [ Open_append; Open_creat ] 0o600 "configure.log" in
  output_string oc s;
  output_char oc '\n';
  close_out oc;
  flush stdout

let command s =
  log ("==> " ^ s);
  Sys.command (sprintf "%s 2>> configure.log" s) = 0

let start_with s p =
  let ls = String.length s and lp = String.length p in
  if (ls >= lp) && (String.sub s 0 lp = p)
  then Some (String.sub s lp (ls - lp)) else None
    
let parse_arg s =
  if s = "--help" then (usage (); exit 0)
  else
    match start_with s "--with-" with
      | Some f -> (List.assoc f features) := `yes
      | None ->
    match start_with s "--without-" with
      | Some f -> (List.assoc f features) := `no
      | None ->
    let i = String.index s '=' in
    if i < 2 then raise Not_found;
    let n = String.sub s 2 (i - 2) in
    let v = String.sub s (succ i) (String.length s - i - 1) in
    (List.assoc n vars) := v

let () =
  print_endline "Configuring CDuce for compilation...\n";
  (try for i = 1 to Array.length Sys.argv - 1 do parse_arg Sys.argv.(i) done
  with Not_found -> usage (); fatal "Incorrect command line");
  (try Sys.remove "configure.log" with Sys_error _ -> ());
  ignore (Sys.command "uname -a >> configure.log")

let print s = print_string s; flush stdout

let check_feature f p =
  printf "%s: " f;
  match !(List.assoc f features) with
    | `no -> 
	print "disabled\n"; false
    | `yes -> 
	print "checking... ";
	if p () 
	then (print "ok\n"; true) 
	else (print "failed !\n"; fatal "Required feature is not available")
    | `auto -> 
	print "autodetecting... ";
	if p () 
	then (print "enabled\n"; true)
	else (print "disabled\n"; false)

let native = 
  check_feature "ocamlopt" (fun () -> command "ocamlfind ocamlopt")

let check_pkg p () =
  try
(*    ignore (Findlib.package_property
      [ (if native then "native" else "bytecode") ]
      p "archive"); *)
    command 
      (sprintf 
	 "ocamlfind ocaml%s -package %s -linkpkg -o configure.try && rm -f configure.try"
	 (if native then "opt" else "c")
	 p)
  with Not_found -> false

let need_pkg p =
  printf "Checking for package %s... " p; flush stdout;
  if not (check_pkg p ()) 
  then (print "failed !\n"; fatal "Required package is not available")
  else (print "ok\n")

let dir ?def d = 
  let s = !(List.assoc d vars) in
  if s <> "" then s
  else match def with 
    | Some x -> x 
    | None -> fatal (sprintf "%s cannot be empty" d)


let exe = match Sys.os_type with 
  | "Win32" ->
      print "Win32 detected... executable will have .exe extension\n"; ".exe" 
  | "Cygwin" ->
      print "Cygwin detected... executable will have .exe extension\n"; ".exe" 
  | _ -> ""

let add_icon = match Sys.os_type with 
  | "Win32" | "Cygwin" -> true
  | _ -> false

let check_mliface dir =
(*  Sys.file_exists (Filename.concat dir "typing/types.ml") *)
  Sys.file_exists (Filename.concat dir "typing/types.ml") 

let ocaml_stdlib () =
  if (Sys.command "ocamlc -where > ocaml_stdlib" <> 0) then
    fatal "Can't run ocamlc to get OCaml standard library path";
  let ic = open_in "ocaml_stdlib" in
  let s = input_line ic in
  close_in ic;
  Sys.remove "ocaml_stdlib";
  s

let make_absolute dir =
  if Filename.is_relative dir 
  then Filename.concat (Sys.getcwd ()) dir
  else dir

let ml_interface = 
  let dir1 = !(List.assoc "mliface" vars) in
  let dirs = if dir1 = "" then [] else [ make_absolute dir1 ] in
  print "ocaml sources... ";
  let rec loop = function
    | [] -> 
	print "not found (the interface will not be built)\n";
	None
    | d::dirs ->
	if check_mliface d then
	  (print ("found: " ^ d ^ "\n"); Some d)
	else loop dirs
  in
  loop dirs
  
let pxp = check_feature "pxp" (check_pkg "pxp")
let expat = check_feature "expat" (check_pkg "expat")
let curl = check_feature "curl" (check_pkg "curl")
let netclient = check_feature "netclient" (check_pkg "netclient")
let cgi = check_feature "cgi" (check_pkg "netcgi1")
let pxp_wlex = check_feature "pxp_wlex" (check_pkg "pxp-wlex-utf8")
let prefix = dir "prefix"
let bindir = dir ~def:(prefix^"/bin") "bindir"
let mandir = dir ~def:(prefix^"/man") "mandir"
let docdir = dir ~def:(prefix^"/doc/cduce") "docdir"
let wprefix = dir "wprefix"
let cgidir = dir ~def:(wprefix^"/cgi-bin") "cgidir"
let htmldir = dir ~def:(wprefix^"/html") "htmldir"
let sessiondir = dir "sessiondir"

let curl,netclient = 
  match curl,netclient with
    | true,true -> 
	warning "Both netclient and curl are available. Will use curl.";
	true,false
    | false,false ->
	warning "No package for loading external URLs.";
	false,false
    | c,n -> c,n

let pxp,expat = 
  match pxp,expat with
    | true,true -> 
	warning "Both PXP and expat are available. Will build both and use expat by default.";
	true,true
    | false,false ->
	warning "No package for parsing XML documents.";
	false,false
    | c,n -> c,n

let cgi =
    if not(cgi) then
        (warning "No cgi package found: dtd2cduce and the web interface won't be built";
        false)
    else true

let required_packages = ["camlp4"; "num"; "pcre"; "ulex"; "netstring"]

let has_forpack =
  print "testing for -for-pack option: ";
  let comm =
    match Sys.os_type with
      | "Win32" -> "ocamlc -for-pack foo"
      | _ -> "ocamlc -for-pack foo 2> /dev/null" in
    if Sys.command comm = 0 then
      (print "available\n"; true)
    else
      (print "not available\n"; false)

let has_natdynlink =
  print "testing for native dynlink: ";
  if Sys.command "ocamlopt -o foo dynlink.cmxa && rm -f foo" = 0 then
    (printf "available\n"; true)
  else
    (print "not available\n"; false)

let () =
  List.iter need_pkg required_packages;
  if pxp then (
    need_pkg "pxp-engine";
    need_pkg "pxp-lex-iso88591";
    if not pxp_wlex then need_pkg "pxp-lex-utf8";
  );

  print "Creating Makefile.conf...\n";

  let out = open_out "Makefile.conf" in
  fprintf out "# This file has been generated by the configure script\n";
  fprintf out "NATIVE=%b\n" native;
  (match ml_interface with
    | Some d -> fprintf out "ML_INTERFACE=true\nOCAML_SRC=%s\n" d
    | None -> fprintf out "ML_INTERFACE=false\n");
  fprintf out "PXP=%b\n" pxp;
  fprintf out "EXPAT=%b\n" expat;
  fprintf out "CURL=%b\n" curl;
  fprintf out "NETCLIENT=%b\n" netclient;
  fprintf out "CGI=%b\n" cgi;
  fprintf out "PXP_WLEX=%b\n" pxp_wlex;
  fprintf out "BINDIR=%s\n" bindir;
  fprintf out "MANDIR=%s\n" mandir;
  fprintf out "DOCDIR=%s\n" docdir;
  fprintf out "CGI_DIR=%s\n" cgidir;
  fprintf out "HTML_DIR=%s\n" htmldir;
  fprintf out "SESSION_DIR=%s\n" sessiondir;
  fprintf out "EXE=%s\n" exe;
  fprintf out "ADDICON=%b\n" add_icon;
  fprintf out "PROFILE=false\n";
  fprintf out "FORPACK=%b\n" has_forpack;
  fprintf out "NATDYNLINK=%b\n" has_natdynlink;
  close_out out
cduce-0.6.0/depend000066400000000000000000000577711230562553500140110ustar00rootroot00000000000000driver/cduce_config.cmo: driver/cduce_config.cmi 
driver/cduce_config.cmx: driver/cduce_config.cmi 
misc/stats.cmo: misc/stats.cmi 
misc/stats.cmx: misc/stats.cmi 
misc/encodings.cmo: misc/custom.cmo misc/encodings.cmi 
misc/encodings.cmx: misc/custom.cmx misc/encodings.cmi 
misc/upool.cmo: misc/custom.cmo misc/upool.cmi 
misc/upool.cmx: misc/custom.cmx misc/upool.cmi 
misc/pretty.cmo: misc/pretty.cmi 
misc/pretty.cmx: misc/pretty.cmi 
misc/ns.cmo: misc/upool.cmi misc/encodings.cmi misc/custom.cmo misc/ns.cmi 
misc/ns.cmx: misc/upool.cmx misc/encodings.cmx misc/custom.cmx misc/ns.cmi 
misc/imap.cmo: misc/imap.cmi 
misc/imap.cmx: misc/imap.cmi 
misc/html.cmo: misc/html.cmi 
misc/html.cmx: misc/html.cmi 
types/compunit.cmo: types/compunit.cmi 
types/compunit.cmx: types/compunit.cmi 
types/sortedList.cmo: misc/custom.cmo types/sortedList.cmi 
types/sortedList.cmx: misc/custom.cmx types/sortedList.cmi 
misc/bool.cmo: misc/custom.cmo misc/bool.cmi 
misc/bool.cmx: misc/custom.cmx misc/bool.cmi 
types/ident.cmo: types/sortedList.cmi misc/ns.cmi misc/encodings.cmi 
types/ident.cmx: types/sortedList.cmx misc/ns.cmx misc/encodings.cmx 
types/intervals.cmo: types/intervals.cmi 
types/intervals.cmx: types/intervals.cmi 
types/chars.cmo: misc/custom.cmo types/chars.cmi 
types/chars.cmx: misc/custom.cmx types/chars.cmi 
types/atoms.cmo: misc/upool.cmi types/sortedList.cmi misc/ns.cmi \
    misc/imap.cmi misc/encodings.cmi types/atoms.cmi 
types/atoms.cmx: misc/upool.cmx types/sortedList.cmx misc/ns.cmx \
    misc/imap.cmx misc/encodings.cmx types/atoms.cmi 
types/normal.cmo: types/normal.cmi 
types/normal.cmx: types/normal.cmi 
types/types.cmo: misc/stats.cmi types/sortedList.cmi misc/pretty.cmi \
    misc/ns.cmi types/normal.cmi types/intervals.cmi types/ident.cmo \
    misc/encodings.cmi misc/custom.cmo types/compunit.cmi types/chars.cmi \
    misc/bool.cmi types/atoms.cmi types/types.cmi 
types/types.cmx: misc/stats.cmx types/sortedList.cmx misc/pretty.cmx \
    misc/ns.cmx types/normal.cmx types/intervals.cmx types/ident.cmx \
    misc/encodings.cmx misc/custom.cmx types/compunit.cmx types/chars.cmx \
    misc/bool.cmx types/atoms.cmx types/types.cmi 
compile/auto_pat.cmo: types/types.cmi types/ident.cmo types/chars.cmi \
    types/atoms.cmi compile/auto_pat.cmi 
compile/auto_pat.cmx: types/types.cmx types/ident.cmx types/chars.cmx \
    types/atoms.cmx compile/auto_pat.cmi 
types/sequence.cmo: types/types.cmi misc/custom.cmo types/chars.cmi \
    types/atoms.cmi types/sequence.cmi 
types/sequence.cmx: types/types.cmx misc/custom.cmx types/chars.cmx \
    types/atoms.cmx types/sequence.cmi 
types/builtin_defs.cmo: types/types.cmi types/sequence.cmi \
    types/intervals.cmi types/ident.cmo misc/encodings.cmi types/chars.cmi \
    types/atoms.cmi types/builtin_defs.cmi 
types/builtin_defs.cmx: types/types.cmx types/sequence.cmx \
    types/intervals.cmx types/ident.cmx misc/encodings.cmx types/chars.cmx \
    types/atoms.cmx types/builtin_defs.cmi 
runtime/value.cmo: misc/upool.cmi types/types.cmi types/sequence.cmi \
    misc/ns.cmi types/intervals.cmi misc/imap.cmi types/ident.cmo \
    misc/encodings.cmi types/chars.cmi types/atoms.cmi runtime/value.cmi 
runtime/value.cmx: misc/upool.cmx types/types.cmx types/sequence.cmx \
    misc/ns.cmx types/intervals.cmx misc/imap.cmx types/ident.cmx \
    misc/encodings.cmx types/chars.cmx types/atoms.cmx runtime/value.cmi 
schema/schema_pcre.cmo: misc/encodings.cmi schema/schema_pcre.cmi 
schema/schema_pcre.cmx: misc/encodings.cmx schema/schema_pcre.cmi 
schema/schema_types.cmo: runtime/value.cmi misc/ns.cmi misc/encodings.cmi \
    types/atoms.cmi schema/schema_types.cmi 
schema/schema_types.cmx: runtime/value.cmx misc/ns.cmx misc/encodings.cmx \
    types/atoms.cmx schema/schema_types.cmi 
schema/schema_xml.cmo: schema/schema_pcre.cmi misc/ns.cmi misc/encodings.cmi \
    schema/schema_xml.cmi 
schema/schema_xml.cmx: schema/schema_pcre.cmx misc/ns.cmx misc/encodings.cmx \
    schema/schema_xml.cmi 
schema/schema_common.cmo: runtime/value.cmi types/types.cmi \
    schema/schema_xml.cmi schema/schema_types.cmi schema/schema_pcre.cmi \
    misc/ns.cmi misc/encodings.cmi types/atoms.cmi schema/schema_common.cmi 
schema/schema_common.cmx: runtime/value.cmx types/types.cmx \
    schema/schema_xml.cmx schema/schema_types.cmx schema/schema_pcre.cmx \
    misc/ns.cmx misc/encodings.cmx types/atoms.cmx schema/schema_common.cmi 
schema/schema_builtin.cmo: runtime/value.cmi types/types.cmi \
    types/sequence.cmi schema/schema_xml.cmi schema/schema_types.cmi \
    schema/schema_pcre.cmi schema/schema_common.cmi misc/ns.cmi \
    types/intervals.cmi misc/encodings.cmi types/builtin_defs.cmi \
    types/atoms.cmi schema/schema_builtin.cmi 
schema/schema_builtin.cmx: runtime/value.cmx types/types.cmx \
    types/sequence.cmx schema/schema_xml.cmx schema/schema_types.cmx \
    schema/schema_pcre.cmx schema/schema_common.cmx misc/ns.cmx \
    types/intervals.cmx misc/encodings.cmx types/builtin_defs.cmx \
    types/atoms.cmx schema/schema_builtin.cmi 
schema/schema_validator.cmo: runtime/value.cmi schema/schema_types.cmi \
    schema/schema_pcre.cmi schema/schema_common.cmi schema/schema_builtin.cmi \
    misc/ns.cmi misc/encodings.cmi types/atoms.cmi \
    schema/schema_validator.cmi 
schema/schema_validator.cmx: runtime/value.cmx schema/schema_types.cmx \
    schema/schema_pcre.cmx schema/schema_common.cmx schema/schema_builtin.cmx \
    misc/ns.cmx misc/encodings.cmx types/atoms.cmx \
    schema/schema_validator.cmi 
types/patterns.cmo: types/types.cmi types/sortedList.cmi types/sequence.cmi \
    types/ident.cmo misc/custom.cmo types/chars.cmi compile/auto_pat.cmi \
    types/atoms.cmi types/patterns.cmi 
types/patterns.cmx: types/types.cmx types/sortedList.cmx types/sequence.cmx \
    types/ident.cmx misc/custom.cmx types/chars.cmx compile/auto_pat.cmx \
    types/atoms.cmx types/patterns.cmi 
compile/print_auto.cmo: types/types.cmi types/ident.cmo compile/auto_pat.cmi \
    compile/print_auto.cmi 
compile/print_auto.cmx: types/types.cmx types/ident.cmx compile/auto_pat.cmx \
    compile/print_auto.cmi 
compile/lambda.cmo: runtime/value.cmi types/types.cmi \
    schema/schema_validator.cmi misc/ns.cmi misc/imap.cmi types/ident.cmo \
    types/compunit.cmi compile/auto_pat.cmi compile/lambda.cmi 
compile/lambda.cmx: runtime/value.cmx types/types.cmx \
    schema/schema_validator.cmx misc/ns.cmx misc/imap.cmx types/ident.cmx \
    types/compunit.cmx compile/auto_pat.cmx compile/lambda.cmi 
runtime/run_dispatch.cmo: runtime/value.cmi misc/upool.cmi types/types.cmi \
    misc/imap.cmi types/ident.cmo misc/encodings.cmi types/chars.cmi \
    compile/auto_pat.cmi types/atoms.cmi runtime/run_dispatch.cmi 
runtime/run_dispatch.cmx: runtime/value.cmx misc/upool.cmx types/types.cmx \
    misc/imap.cmx types/ident.cmx misc/encodings.cmx types/chars.cmx \
    compile/auto_pat.cmx types/atoms.cmx runtime/run_dispatch.cmi 
runtime/explain.cmo: runtime/value.cmi misc/upool.cmi types/types.cmi \
    runtime/run_dispatch.cmi misc/imap.cmi types/ident.cmo misc/encodings.cmi \
    types/chars.cmi compile/auto_pat.cmi types/atoms.cmi runtime/explain.cmi 
runtime/explain.cmx: runtime/value.cmx misc/upool.cmx types/types.cmx \
    runtime/run_dispatch.cmx misc/imap.cmx types/ident.cmx misc/encodings.cmx \
    types/chars.cmx compile/auto_pat.cmx types/atoms.cmx runtime/explain.cmi 
runtime/eval.cmo: runtime/value.cmi misc/upool.cmi types/types.cmi \
    schema/schema_validator.cmi schema/schema_common.cmi \
    runtime/run_dispatch.cmi misc/ns.cmi compile/lambda.cmi misc/imap.cmi \
    types/ident.cmo runtime/explain.cmi compile/auto_pat.cmi runtime/eval.cmi 
runtime/eval.cmx: runtime/value.cmx misc/upool.cmx types/types.cmx \
    schema/schema_validator.cmx schema/schema_common.cmx \
    runtime/run_dispatch.cmx misc/ns.cmx compile/lambda.cmx misc/imap.cmx \
    types/ident.cmx runtime/explain.cmx compile/auto_pat.cmx runtime/eval.cmi 
parser/cduce_loc.cmo: misc/html.cmi parser/cduce_loc.cmi 
parser/cduce_loc.cmx: misc/html.cmx parser/cduce_loc.cmi 
parser/url.cmo: runtime/value.cmi parser/cduce_loc.cmi parser/url.cmi 
parser/url.cmx: runtime/value.cmx parser/cduce_loc.cmx parser/url.cmi 
parser/ulexer.cmo: parser/ulexer.cmi 
parser/ulexer.cmx: parser/ulexer.cmi 
parser/ast.cmo: types/types.cmi types/sequence.cmi misc/ns.cmi \
    types/intervals.cmi types/ident.cmo types/chars.cmi parser/cduce_loc.cmi \
    types/builtin_defs.cmi 
parser/ast.cmx: types/types.cmx types/sequence.cmx misc/ns.cmx \
    types/intervals.cmx types/ident.cmx types/chars.cmx parser/cduce_loc.cmx \
    types/builtin_defs.cmx 
parser/parser.cmo: parser/ulexer.cmi types/types.cmi types/sequence.cmi \
    misc/ns.cmi types/intervals.cmi types/ident.cmo misc/encodings.cmi \
    types/chars.cmi parser/cduce_loc.cmi types/atoms.cmi parser/ast.cmo \
    parser/parser.cmi 
parser/parser.cmx: parser/ulexer.cmx types/types.cmx types/sequence.cmx \
    misc/ns.cmx types/intervals.cmx types/ident.cmx misc/encodings.cmx \
    types/chars.cmx parser/cduce_loc.cmx types/atoms.cmx parser/ast.cmx \
    parser/parser.cmi 
typing/typed.cmo: types/types.cmi schema/schema_validator.cmi \
    types/patterns.cmi misc/ns.cmi types/ident.cmo types/compunit.cmi \
    parser/cduce_loc.cmi 
typing/typed.cmx: types/types.cmx schema/schema_validator.cmx \
    types/patterns.cmx misc/ns.cmx types/ident.cmx types/compunit.cmx \
    parser/cduce_loc.cmx 
typing/typepat.cmo: types/types.cmi types/sequence.cmi types/patterns.cmi \
    types/ident.cmo misc/encodings.cmi types/chars.cmi typing/typepat.cmi 
typing/typepat.cmx: types/types.cmx types/sequence.cmx types/patterns.cmx \
    types/ident.cmx misc/encodings.cmx types/chars.cmx typing/typepat.cmi 
types/externals.cmo: parser/cduce_loc.cmi types/externals.cmi 
types/externals.cmx: parser/cduce_loc.cmx types/externals.cmi 
typing/typer.cmo: types/types.cmi typing/typepat.cmi typing/typed.cmo \
    types/sequence.cmi schema/schema_validator.cmi types/patterns.cmi \
    misc/ns.cmi types/ident.cmo misc/html.cmi types/externals.cmi \
    types/compunit.cmi types/chars.cmi parser/cduce_loc.cmi \
    types/builtin_defs.cmi types/atoms.cmi parser/ast.cmo typing/typer.cmi 
typing/typer.cmx: types/types.cmx typing/typepat.cmx typing/typed.cmx \
    types/sequence.cmx schema/schema_validator.cmx types/patterns.cmx \
    misc/ns.cmx types/ident.cmx misc/html.cmx types/externals.cmx \
    types/compunit.cmx types/chars.cmx parser/cduce_loc.cmx \
    types/builtin_defs.cmx types/atoms.cmx parser/ast.cmx typing/typer.cmi 
compile/compile.cmo: runtime/value.cmi misc/upool.cmi types/types.cmi \
    typing/typer.cmi typing/typed.cmo types/patterns.cmi compile/lambda.cmi \
    misc/imap.cmi types/ident.cmo runtime/eval.cmi types/compunit.cmi \
    parser/cduce_loc.cmi compile/auto_pat.cmi parser/ast.cmo \
    compile/compile.cmi 
compile/compile.cmx: runtime/value.cmx misc/upool.cmx types/types.cmx \
    typing/typer.cmx typing/typed.cmx types/patterns.cmx compile/lambda.cmx \
    misc/imap.cmx types/ident.cmx runtime/eval.cmx types/compunit.cmx \
    parser/cduce_loc.cmx compile/auto_pat.cmx parser/ast.cmx \
    compile/compile.cmi 
schema/schema_parser.cmo: parser/url.cmi schema/schema_xml.cmi \
    schema/schema_validator.cmi schema/schema_types.cmi \
    schema/schema_pcre.cmi schema/schema_common.cmi schema/schema_builtin.cmi \
    misc/ns.cmi misc/encodings.cmi types/atoms.cmi schema/schema_parser.cmi 
schema/schema_parser.cmx: parser/url.cmx schema/schema_xml.cmx \
    schema/schema_validator.cmx schema/schema_types.cmx \
    schema/schema_pcre.cmx schema/schema_common.cmx schema/schema_builtin.cmx \
    misc/ns.cmx misc/encodings.cmx types/atoms.cmx schema/schema_parser.cmi 
schema/schema_converter.cmo: runtime/value.cmi types/types.cmi \
    typing/typer.cmi typing/typepat.cmi types/sequence.cmi \
    schema/schema_xml.cmi schema/schema_validator.cmi schema/schema_types.cmi \
    schema/schema_parser.cmi schema/schema_common.cmi \
    schema/schema_builtin.cmi misc/ns.cmi types/ident.cmo misc/encodings.cmi \
    types/builtin_defs.cmi types/atoms.cmi 
schema/schema_converter.cmx: runtime/value.cmx types/types.cmx \
    typing/typer.cmx typing/typepat.cmx types/sequence.cmx \
    schema/schema_xml.cmx schema/schema_validator.cmx schema/schema_types.cmx \
    schema/schema_parser.cmx schema/schema_common.cmx \
    schema/schema_builtin.cmx misc/ns.cmx types/ident.cmx misc/encodings.cmx \
    types/builtin_defs.cmx types/atoms.cmx 
runtime/load_xml.cmo: runtime/value.cmi parser/url.cmi misc/upool.cmi \
    misc/ns.cmi misc/imap.cmi types/ident.cmo misc/encodings.cmi \
    parser/cduce_loc.cmi types/atoms.cmi runtime/load_xml.cmi 
runtime/load_xml.cmx: runtime/value.cmx parser/url.cmx misc/upool.cmx \
    misc/ns.cmx misc/imap.cmx types/ident.cmx misc/encodings.cmx \
    parser/cduce_loc.cmx types/atoms.cmx runtime/load_xml.cmi 
runtime/print_xml.cmo: runtime/value.cmi types/sequence.cmi \
    schema/schema_builtin.cmi misc/ns.cmi types/intervals.cmi misc/imap.cmi \
    types/ident.cmo misc/encodings.cmi types/atoms.cmi runtime/print_xml.cmi 
runtime/print_xml.cmx: runtime/value.cmx types/sequence.cmx \
    schema/schema_builtin.cmx misc/ns.cmx types/intervals.cmx misc/imap.cmx \
    types/ident.cmx misc/encodings.cmx types/atoms.cmx runtime/print_xml.cmi 
compile/operators.cmo: runtime/value.cmi types/types.cmi typing/typer.cmi \
    runtime/eval.cmi parser/cduce_loc.cmi compile/operators.cmi 
compile/operators.cmx: runtime/value.cmx types/types.cmx typing/typer.cmx \
    runtime/eval.cmx parser/cduce_loc.cmx compile/operators.cmi 
types/builtin.cmo: runtime/value.cmi parser/url.cmi types/types.cmi \
    typing/typer.cmi types/sequence.cmi runtime/print_xml.cmi \
    compile/operators.cmi misc/ns.cmi runtime/load_xml.cmi \
    types/intervals.cmi types/ident.cmo runtime/eval.cmi types/chars.cmi \
    parser/cduce_loc.cmi types/builtin_defs.cmi types/atoms.cmi \
    types/builtin.cmi 
types/builtin.cmx: runtime/value.cmx parser/url.cmx types/types.cmx \
    typing/typer.cmx types/sequence.cmx runtime/print_xml.cmx \
    compile/operators.cmx misc/ns.cmx runtime/load_xml.cmx \
    types/intervals.cmx types/ident.cmx runtime/eval.cmx types/chars.cmx \
    parser/cduce_loc.cmx types/builtin_defs.cmx types/atoms.cmx \
    types/builtin.cmi 
driver/librarian.cmo: runtime/value.cmi parser/ulexer.cmi types/types.cmi \
    typing/typer.cmi parser/parser.cmi compile/lambda.cmi types/ident.cmo \
    types/externals.cmi runtime/eval.cmi types/compunit.cmi \
    compile/compile.cmi parser/cduce_loc.cmi types/builtin.cmi \
    driver/librarian.cmi 
driver/librarian.cmx: runtime/value.cmx parser/ulexer.cmx types/types.cmx \
    typing/typer.cmx parser/parser.cmx compile/lambda.cmx types/ident.cmx \
    types/externals.cmx runtime/eval.cmx types/compunit.cmx \
    compile/compile.cmx parser/cduce_loc.cmx types/builtin.cmx \
    driver/librarian.cmi 
types/sample.cmo: types/types.cmi types/intervals.cmi types/ident.cmo \
    types/chars.cmi types/atoms.cmi types/sample.cmi 
types/sample.cmx: types/types.cmx types/intervals.cmx types/ident.cmx \
    types/chars.cmx types/atoms.cmx types/sample.cmi 
driver/cduce.cmo: runtime/value.cmi parser/ulexer.cmi types/types.cmi \
    typing/typer.cmi misc/stats.cmi types/sequence.cmi types/sample.cmi \
    compile/print_auto.cmi types/patterns.cmi parser/parser.cmi \
    compile/operators.cmi misc/ns.cmi driver/librarian.cmi types/ident.cmo \
    runtime/eval.cmi compile/compile.cmi parser/cduce_loc.cmi \
    types/builtin_defs.cmi types/builtin.cmi compile/auto_pat.cmi \
    types/atoms.cmi parser/ast.cmo driver/cduce.cmi 
driver/cduce.cmx: runtime/value.cmx parser/ulexer.cmx types/types.cmx \
    typing/typer.cmx misc/stats.cmx types/sequence.cmx types/sample.cmx \
    compile/print_auto.cmx types/patterns.cmx parser/parser.cmx \
    compile/operators.cmx misc/ns.cmx driver/librarian.cmx types/ident.cmx \
    runtime/eval.cmx compile/compile.cmx parser/cduce_loc.cmx \
    types/builtin_defs.cmx types/builtin.cmx compile/auto_pat.cmx \
    types/atoms.cmx parser/ast.cmx driver/cduce.cmi 
runtime/system.cmo: runtime/value.cmi types/types.cmi types/sequence.cmi \
    compile/operators.cmi types/ident.cmo parser/cduce_loc.cmi \
    types/builtin_defs.cmi types/builtin.cmi types/atoms.cmi 
runtime/system.cmx: runtime/value.cmx types/types.cmx types/sequence.cmx \
    compile/operators.cmx types/ident.cmx parser/cduce_loc.cmx \
    types/builtin_defs.cmx types/builtin.cmx types/atoms.cmx 
query/query_aggregates.cmo: runtime/value.cmi types/sequence.cmi \
    compile/operators.cmi types/intervals.cmi types/builtin_defs.cmi 
query/query_aggregates.cmx: runtime/value.cmx types/sequence.cmx \
    compile/operators.cmx types/intervals.cmx types/builtin_defs.cmx 
ocamliface/mltypes.cmo: types/ident.cmo ocamliface/config.cmo \
    parser/cduce_loc.cmi ocamliface/mltypes.cmi 
ocamliface/mltypes.cmx: types/ident.cmx ocamliface/config.cmx \
    parser/cduce_loc.cmx ocamliface/mltypes.cmi 
ocamliface/mlstub.cmo: types/types.cmi typing/typer.cmi types/sequence.cmi \
    misc/ns.cmi ocamliface/mltypes.cmi driver/librarian.cmi types/ident.cmo \
    types/externals.cmi ocamliface/config.cmo compile/compile.cmi \
    parser/cduce_loc.cmi types/builtin_defs.cmi types/atoms.cmi \
    parser/ast.cmo ocamliface/mlstub.cmi 
ocamliface/mlstub.cmx: types/types.cmx typing/typer.cmx types/sequence.cmx \
    misc/ns.cmx ocamliface/mltypes.cmx driver/librarian.cmx types/ident.cmx \
    types/externals.cmx ocamliface/config.cmx compile/compile.cmx \
    parser/cduce_loc.cmx types/builtin_defs.cmx types/atoms.cmx \
    parser/ast.cmx ocamliface/mlstub.cmi 
parser/cduce_netclient.cmo: runtime/value.cmi parser/url.cmi \
    driver/cduce_config.cmi 
parser/cduce_netclient.cmx: runtime/value.cmx parser/url.cmx \
    driver/cduce_config.cmx 
runtime/cduce_pxp.cmo: runtime/value.cmi parser/url.cmi schema/schema_xml.cmi \
    runtime/load_xml.cmi driver/cduce_config.cmi runtime/cduce_pxp.cmi 
runtime/cduce_pxp.cmx: runtime/value.cmx parser/url.cmx schema/schema_xml.cmx \
    runtime/load_xml.cmx driver/cduce_config.cmx runtime/cduce_pxp.cmi 
driver/run.cmo: runtime/value.cmi parser/ulexer.cmi misc/stats.cmi \
    driver/librarian.cmi types/ident.cmo misc/html.cmi parser/cduce_loc.cmi \
    driver/cduce_config.cmi driver/cduce.cmi types/builtin.cmi 
driver/run.cmx: runtime/value.cmx parser/ulexer.cmx misc/stats.cmx \
    driver/librarian.cmx types/ident.cmx misc/html.cmx parser/cduce_loc.cmx \
    driver/cduce_config.cmx driver/cduce.cmx types/builtin.cmx 
driver/start.cmo: driver/run.cmo 
driver/start.cmx: driver/run.cmx 
driver/webiface.cmo: misc/html.cmi driver/examples.cmo parser/cduce_loc.cmi \
    driver/cduce.cmi 
driver/webiface.cmx: misc/html.cmx driver/examples.cmx parser/cduce_loc.cmx \
    driver/cduce.cmx 
driver/evaluator.cmo: misc/html.cmi parser/cduce_loc.cmi \
    driver/cduce_config.cmi driver/cduce.cmi 
driver/evaluator.cmx: misc/html.cmx parser/cduce_loc.cmx \
    driver/cduce_config.cmx driver/cduce.cmx 
tools/validate.cmo: schema/schema_types.cmi schema/schema_parser.cmi \
    schema/schema_common.cmi 
tools/validate.cmx: schema/schema_types.cmx schema/schema_parser.cmx \
    schema/schema_common.cmx 
ocamliface/mltypes.cmo: types/ident.cmo ocamliface/config.cmo \
    parser/cduce_loc.cmi ocamliface/mltypes.cmi 
ocamliface/mltypes.cmx: types/ident.cmx ocamliface/config.cmx \
    parser/cduce_loc.cmx ocamliface/mltypes.cmi 
ocamliface/mlstub.cmo: types/types.cmi typing/typer.cmi types/sequence.cmi \
    misc/ns.cmi ocamliface/mltypes.cmi driver/librarian.cmi types/ident.cmo \
    types/externals.cmi ocamliface/config.cmo compile/compile.cmi \
    parser/cduce_loc.cmi types/builtin_defs.cmi types/atoms.cmi \
    parser/ast.cmo ocamliface/mlstub.cmi 
ocamliface/mlstub.cmx: types/types.cmx typing/typer.cmx types/sequence.cmx \
    misc/ns.cmx ocamliface/mltypes.cmx driver/librarian.cmx types/ident.cmx \
    types/externals.cmx ocamliface/config.cmx compile/compile.cmx \
    parser/cduce_loc.cmx types/builtin_defs.cmx types/atoms.cmx \
    parser/ast.cmx ocamliface/mlstub.cmi 
parser/cduce_curl.cmo: runtime/value.cmi parser/url.cmi \
    driver/cduce_config.cmi 
parser/cduce_curl.cmx: runtime/value.cmx parser/url.cmx \
    driver/cduce_config.cmx 
parser/cduce_netclient.cmo: runtime/value.cmi parser/url.cmi \
    driver/cduce_config.cmi 
parser/cduce_netclient.cmx: runtime/value.cmx parser/url.cmx \
    driver/cduce_config.cmx 
runtime/cduce_expat.cmo: runtime/value.cmi parser/url.cmi \
    schema/schema_xml.cmi runtime/load_xml.cmi driver/cduce_config.cmi \
    runtime/cduce_expat.cmi 
runtime/cduce_expat.cmx: runtime/value.cmx parser/url.cmx \
    schema/schema_xml.cmx runtime/load_xml.cmx driver/cduce_config.cmx \
    runtime/cduce_expat.cmi 
runtime/cduce_pxp.cmo: runtime/value.cmi parser/url.cmi schema/schema_xml.cmi \
    runtime/load_xml.cmi driver/cduce_config.cmi runtime/cduce_pxp.cmi 
runtime/cduce_pxp.cmx: runtime/value.cmx parser/url.cmx schema/schema_xml.cmx \
    runtime/load_xml.cmx driver/cduce_config.cmx runtime/cduce_pxp.cmi 
misc/encodings.cmi: misc/custom.cmo 
misc/upool.cmi: misc/custom.cmo 
misc/ns.cmi: misc/upool.cmi misc/encodings.cmi misc/custom.cmo 
types/sortedList.cmi: misc/custom.cmo 
misc/bool.cmi: misc/custom.cmo 
types/intervals.cmi: misc/custom.cmo 
types/chars.cmi: misc/custom.cmo 
types/atoms.cmi: misc/ns.cmi misc/encodings.cmi misc/custom.cmo 
types/types.cmi: misc/ns.cmi types/intervals.cmi types/ident.cmo \
    misc/custom.cmo types/chars.cmi types/atoms.cmi 
compile/auto_pat.cmi: types/types.cmi types/ident.cmo types/chars.cmi \
    types/atoms.cmi 
types/sequence.cmi: types/types.cmi types/atoms.cmi 
types/builtin_defs.cmi: types/types.cmi types/ident.cmo types/atoms.cmi 
runtime/value.cmi: types/types.cmi misc/ns.cmi types/intervals.cmi \
    misc/imap.cmi types/ident.cmo misc/encodings.cmi types/chars.cmi \
    types/atoms.cmi 
schema/schema_pcre.cmi: misc/encodings.cmi 
schema/schema_types.cmi: runtime/value.cmi misc/ns.cmi misc/encodings.cmi \
    types/atoms.cmi 
schema/schema_xml.cmi: misc/ns.cmi misc/encodings.cmi 
schema/schema_common.cmi: runtime/value.cmi types/types.cmi \
    schema/schema_types.cmi misc/ns.cmi types/ident.cmo misc/encodings.cmi \
    types/atoms.cmi 
schema/schema_builtin.cmi: runtime/value.cmi types/types.cmi \
    schema/schema_types.cmi misc/ns.cmi misc/encodings.cmi 
schema/schema_validator.cmi: runtime/value.cmi schema/schema_types.cmi \
    misc/encodings.cmi 
types/patterns.cmi: types/types.cmi types/ident.cmo misc/custom.cmo \
    compile/auto_pat.cmi 
compile/print_auto.cmi: compile/auto_pat.cmi 
compile/lambda.cmi: runtime/value.cmi types/types.cmi \
    schema/schema_validator.cmi misc/ns.cmi misc/imap.cmi types/ident.cmo \
    types/compunit.cmi compile/auto_pat.cmi 
runtime/run_dispatch.cmi: runtime/value.cmi compile/auto_pat.cmi 
runtime/explain.cmi: runtime/value.cmi compile/auto_pat.cmi 
runtime/eval.cmi: runtime/value.cmi misc/ns.cmi compile/lambda.cmi \
    types/ident.cmo types/compunit.cmi 
parser/cduce_loc.cmi: misc/html.cmi 
parser/parser.cmi: parser/ast.cmo 
typing/typepat.cmi: types/types.cmi types/patterns.cmi types/ident.cmo \
    misc/encodings.cmi 
types/externals.cmi: types/types.cmi 
typing/typer.cmi: types/types.cmi typing/typed.cmo \
    schema/schema_validator.cmi types/patterns.cmi misc/ns.cmi \
    types/ident.cmo types/compunit.cmi parser/cduce_loc.cmi parser/ast.cmo 
compile/compile.cmi: runtime/value.cmi types/types.cmi typing/typer.cmi \
    typing/typed.cmo compile/lambda.cmi types/ident.cmo types/compunit.cmi \
    parser/ast.cmo 
schema/schema_parser.cmi: schema/schema_types.cmi 
runtime/load_xml.cmi: runtime/value.cmi 
runtime/print_xml.cmi: runtime/value.cmi misc/ns.cmi 
compile/operators.cmi: runtime/value.cmi types/types.cmi parser/cduce_loc.cmi 
types/builtin.cmi: runtime/value.cmi typing/typer.cmi 
driver/librarian.cmi: runtime/value.cmi types/types.cmi typing/typer.cmi \
    types/ident.cmo types/externals.cmi types/compunit.cmi \
    compile/compile.cmi 
types/sample.cmi: types/types.cmi 
driver/cduce.cmi: runtime/value.cmi types/atoms.cmi 
ocamliface/mltypes.cmi: types/types.cmi 
ocamliface/mlstub.cmi: parser/ast.cmo 
ocamliface/mltypes.cmi: types/types.cmi 
ocamliface/mlstub.cmi: parser/ast.cmo 
schema/schema_types.cmi: runtime/value.cmi misc/ns.cmi misc/encodings.cmi \
    types/atoms.cmi 
cduce-0.6.0/doc/000077500000000000000000000000001230562553500133535ustar00rootroot00000000000000cduce-0.6.0/doc/Makefile000066400000000000000000000004601230562553500150130ustar00rootroot00000000000000# MAN = cduce.1 dtd2cduce.1 cduce_validate.1 cdo2ml.1 cduce_mktop.1
INSTALL_MAN = cduce.1 cduce_mktop.1 dtd2cduce.1
MAN = $(INSTALL_MAN)

all: $(MAN)

.SUFFIXES: .1 .docbook

.docbook.1:
	docbook-to-man $< > $@

install:
	@echo "Install man pages"
	$(HIDE)$(INSTALL) -m644 $(INSTALL_MAN) $(MANDIR)/man1/
cduce-0.6.0/doc/cduce.1000066400000000000000000000022571230562553500145260ustar00rootroot00000000000000.TH "cduce" "1" 
.SH "NAME" 
cduce \(em The CDuce compiler/interpreter/toplevel 
.SH "SYNOPSIS" 
.PP 
\fBcduce\fR [  \fBOPTIONS\fP \&...]  [\fB\-\-arg \fBargument\fP\fP \&...]  
.PP 
\fBcduce\fR [  \fBOPTIONS\fP \&...]  [\fB \fBfile.cd\fP | \-\-stdin \fP]  [\fB\-\-arg \fBargument\fP\fP \&...]  
.PP 
\fBcduce \-\-compile\fR [  \fBOPTIONS\fP \&...]  [ \fB\fBfile.cd\fP\fP ]  
.PP 
\fBcduce \-\-run\fR [  \fBOPTIONS\fP \&...]  [  \fB\fBfile.cdo\fP\fP \&...]  [\fB\-\-arg \fBargument\fP\fP \&...]  
.SH "Description" 
.PP 
See the CDuce users' manual: 
 
\fBhttp://www.cduce.org/manual_interpreter.html\fP. 
.SH "Reporting bugs" 
.PP 
Report bugs to devel@cduce.org. 
.SH "See also" 
.PP 
A complete documentation, reference manual, tutorial, technical articles on 
implementation and theoretical issues, benchmarks, source code, mailing lists 
and forums can be found on the \fICDuce\fP website: 
\fBhttp://www.cduce.org/\fP. 
.SH "Authors" 
.PP 
Alain Frisch . Small contributions by 
Giuseppe Castagna , Julien Demouth , and Stefano Zacchiroli . 
.\" created by instant / docbook-to-man, Fri 08 Jul 2005, 11:52 
cduce-0.6.0/doc/cduce.docbook000066400000000000000000000043661230562553500160110ustar00rootroot00000000000000




cduce
1



cduce
The CDuce compiler/interpreter/toplevel






cduce

  





cduce

  






cduce --compile

  

  



cduce --run

  


  






Description

See the CDuce users' manual:

http://www.cduce.org/manual_interpreter.html.


	

Reporting bugs

Report bugs to devel@cduce.org.



	

See also

A complete documentation, reference manual, tutorial, technical articles on
implementation and theoretical issues, benchmarks, source code, mailing lists
and forums can be found on the CDuce website:
http://www.cduce.org/.





Authors

Alain Frisch <Alain.Frisch@ens.fr>. Small contributions by
Giuseppe Castagna <Giuseppe.Castagna@ens.fr>, Julien Demouth <Julien.Demouth@ens.fr>, and Stefano Zacchiroli <zack@di.ens.fr>.








cduce-0.6.0/doc/cduce_mktop.1000066400000000000000000000006611230562553500157350ustar00rootroot00000000000000.TH "cduce_mktop" "1" 
.SH "NAME" 
cduce_mktop \(em Produce a customized CDuce toplevel/compiler. 
.SH "SYNOPSIS" 
.PP 
\fBcduce_mktop\fR [\fB\fBtarget\fP\fP]  [\fB\fBprimitive file\fP\fP]  
.SH "Description" 
.PP 
See the CDuce users' manual: 
 
\fBhttp://www.cduce.org/manual_interfacewithocaml.html#link\fP. 
.SH "Author" 
.PP 
Alain Frisch . 
.\" created by instant / docbook-to-man, Fri 08 Jul 2005, 11:52 
cduce-0.6.0/doc/cduce_mktop.docbook000066400000000000000000000014771230562553500172230ustar00rootroot00000000000000




cduce_mktop
1



cduce_mktop
Produce a customized CDuce toplevel/compiler.






cduce_mktop







Description

See the CDuce users' manual:

http://www.cduce.org/manual_interfacewithocaml.html#link.




Author

Alain Frisch <Alain.Frisch@ens.fr>.







cduce-0.6.0/doc/docbook/000077500000000000000000000000001230562553500147735ustar00rootroot00000000000000cduce-0.6.0/doc/docbook/docbook-categ.cd000066400000000000000000000014661230562553500200130ustar00rootroot00000000000000type Special = Xbr | Xspan | Xbdo | Xmap | Xobject | Ximg;;
type Fontstyle = Xtt | Xi | Xb | Xbig | Xsmall;;
type Phrase = Xem | Xstrong | Xdfn | Xcode | Xq |
                   Xsamp | Xkbd | Xvar | Xcite | Xabbr | Xacronym | Xsub | Xsup;;
type InlineForms = Xinput | Xselect | Xtextarea | Xlabel | Xbutton;;
type MiscInline = Xins | Xdel | Xscript;;
type Misc = Xnoscript | MiscInline;;
type Inline = Xa | Special | Fontstyle | Phrase | InlineForms;;
type Inlines = [ (Char | Inline | MiscInline)* ];;

type Heading = Xh1 | Xh2 | Xh3 | Xh4 | Xh5 | Xh6;;
type Lists = Xul | Xol | Xdl;;
type Blocktext = Xpre | Xhr | Xblockquote | Xaddress;;
type Block =  Xp | Heading | Xdiv | Lists | Blocktext | Xfieldset | Xtable;;
type Blocks = [ (Block | Xform | Misc)* ];;

type Flow = [ (Char | Block | Xform | Inline | Misc)* ];;
cduce-0.6.0/doc/docbook/docbook-intro.sgml000066400000000000000000002122111230562553500204270ustar00rootroot00000000000000
  
  
  
  
  
  Cygnus Solutions


1325 Chesapeake Terrace
Sunnyvale
CA
 94089


">
  1997, 1998Cygnus
            Solutions">
  
  
]>


  
  
    1998-10-19
    Get Going With DocBook
    DocBook
    Notes for Hackers
    documentation in progress
    
      
	Mark
	
	Galassi
	
	  &cygnus-full;
	
	
      
    
    

      rosalia@galassi.org
    

    
      1998
      Mark Galassi
    
    
      This document can be freely redistributed according to the terms
      of the GNU General Public License.
    
    
      
	0.0
	1997-10-11
	rosalia@galassi.org
	Initial revision; mostly just an
	  outline
      
      
	0.1
	1997-11-01
	rosalia@galassi.org
	Firmed up the outline, based on the evolution of
	&cygnus;'s DocBook effort
      
      
	0.2
	1997-11-09
	rosalia@galassi.org
	Have enough meat in there that I have announced
	  it.
      
      
	0.3
	1997-12-31
	rosalia@galassi.org
	Separated the tutorial (this document) from the
	  style guide for my project at Cygnus.  This tutorial can now
	  be distributed on its own.
      
      
	0.4
	1998-02-14
	rosalia@galassi.org
	Added some blurbs on descriptions and made the
	  first web release of this document.
      
      
	0.5
	1998-06-12
	rosalia@galassi.org
	Added Sara Mitchell's brief essay on SGML marked
	  sections as its own chapter.
      
      
	0.6
	1998-10-19
	rosalia@galassi.org
	Mentioned that this document is GPLed, did a bit of
	  cleanup, and added mention of my FrameMaker+SGML
	  EDD.
      
    
  
  
  
  
    What is this?
    
	A tutorial for hacker–writers
      
	This booklet has two main goals:
      
      
	The first is present a tutorial on writing documentation that
	will be used in a particular project at Cygnus.
      
      
	The second is for me to clarify my thoughts on how I think the
	books we ship with should be structured.
      
      
	A third goal, which is not as pressing, is that this booklet
	should become a tutorial for all people
	at Cygnus (and elsewhere; the GNOME project, for example is
	using DocBook) who will be writing notes for future
	incorporation into Cygnus documentation.
      
      
	If you just want the tutorial with no further background
	information, please jump right to .
      
    
    
      An example of how to use DocBook structure
      
	This booklet is a valid demonstration of how to use DocBook
	elements for writing Cygnus documentation.  As the &cygnus;
	tag team refines the &cygnus; style and
	typical tag usage, this document will be updated to reflect
	that style and usage.
      
	Whenever I mention &cygnus;, please note that the &cygnus;
	stylesheets and all the tools we use are being made available
	to the world at large, so projects outside of &cygnus; can
	also use these stylesheets, our tools, and this tutorial.
      
      
	If you are a hacker working on a project and you need to write
	an essay, or if you would like to document your portion of the
	project, you can use this booklet as an example of how to
	structure your document and what DocBook elements you should
	use to mark up your text.
      
    
    
      <emphasis>Not</emphasis> an example for all
	situations
      
	This booklet is a tutorial written in quasi–slapstick
	style — I use the words I and
	you liberally.  You should not treat it
	as an example of how to write a reference manual, or as an
	example of how to write a more stuffy tutorial.
      
    
  
  
    Get going
    
      Here is a brutal sequence of steps that will get you started
      writing DocBook documents.
    
    
      If you actually want to understand what is
      going on, you might want to read  first
      and then come back to this chapter.
    
    
      This chapter will not tell you how to get the tools installed
      — it is assumed that your system administrator has done
      that for you.  If she or he has not done so, there is an
      appendix that gives instructions to get DocBook editing and
      processing tools.  There are sections for  (with free tools),
       (with free
      tools) and .
    
    
	Hello, world
      
	Here's a simple DocBook document to get going.  I will show
	you how to write this document using explicit element tags,
	but if you are using an authoring tool that provides a high
	level interface, just choose the same tags using that
	interface.
      
      
	Bare bones DocBook document — the source
      
<!doctype book PUBLIC "-//Davenport//DTD DocBook V3.0//EN" [
]>
<book>
  <bookinfo>
    <date>1997-10-11</date>
    <title>My first booklet</title>
    <subtitle>it even has a subtitle</subtitle>
  </bookinfo>
  <toc></toc>
  <!-- We are done with the preliminaries, now we can start with
          the body of the document -->
  <chapter>
    <title>My first chapter</title>
    <para>Here's a paragraph of text because it is stylistically
      poor to start a section right after the chapter title.</para>
    <sect1>
      <title>A section in that first chapter</title>
      <para>All I need is a single paragraph of text to make the
        section valid.</para>
    </sect1>
  </chapter>
  <appendix>
    <title>Remaining details</title>
    <para>Although this booklet is quite complete, here I will
      mention some details I never got to.</para>
    <sect1>
      <title>Use of the word dude</title>
      <para>Here's an example of how to say
        <emphasis>dude</emphasis>: DUDE.</para>
    </sect1>
  </appendix>
</book>
      
      
      Brief explanation
      
	This example, and the others in this chapter, are meant to get
	you used to SGML/DocBook markup, but a
	minimal explanation should be given here.
      
      
	The first line, with the <!doctype book
	stuff, is boiler plate.  You can ignore it except to note that
	it says book, and the document then begins
	with the <book> tag.  These must
	agree.
      
      
	The special words wrapped with < and > symbols are
	called tags, and they are used to
	delimit elements.  Elements are
	structural parts of the the document, like chapters, titles,
	paragraphs and so forth.
      
      
	Another feature of interest in this brief document is the fact
	that the <chapter> and
	<sect1> have to be followed by a
	<title> element.
      
      Process and view it
      
	You might be curious to see how your SGML
	document will be rendered in both a hardcopy–oriented
	typesetting output, and in online hypertext output.
      
      
	
	  I will outline the steps you should carry out on UNIX to
	  generate postscript and HTML output using
	  the program jade and the
	  DSSSL stylesheets we use at &cygnus;.
	  Assuming your file is called
	  myfile.sgml, you can type the following
	  steps:
	
	
	  Use jade with the
	  transformation DSSSL to convert DocBook
	    to HTML.
	  $  jade -d /usr/lib/sgml/stylesheets/dbtohtml.dsl -t sgml myfile.sgml > myfile.html
	  
	  The free tools also provide a utility shell script
	  db2html which does the same.  So you can
	  just run:
	  $  db2html myfile.sgml
	
	
	  Use jade with the real
	    DSSSL to convert DocBook to
	    TeX.
	  $  jade -d /usr/lib/sgml/stylesheets/docbook.dsl -t tex myfile.sgml > myfile.tex
	
	
	  Use TeX with the jadetex
	  macros to process myfile.tex.
	  $  jadetex myfile.tex
	
	
	  Use dvips to generate a
	    postscript file from myfile.dvi.
	  $  dvips myfile.dvi
	  The steps to create the postscript file can be
	    replaced by:
	  $  db2ps myfile.sgml
	
	
	  
	    You can now view the HTML file with
	    your favourite browser, and you can print the postscript
	    file, or view it with
	    ghostscript, or its front end
	    gv.
	  
	
      
    
    
	A slightly more complex example
      
	Let us add some body to the trivial example.  The
	beefed–up example begins to demonstrate how
	exaggeratedly strict you should be when you write your
	documents.  If this makes you nervous,  will try to reassure you that it is a
	good thing to do(TM).
      

      
	Fleshier DocBook document — the source
      
<!doctype book PUBLIC "-//Davenport//DTD DocBook V3.0//EN" [
]>
<book>
  <bookinfo>
    <date>1997-10-11</date>
    <title>My first booklet</title>
    <subtitle>it even has a subtitle</subtitle>
    <authorgroup>
      <author>
        <firstname>Joe</firstname>
        <othername>“dude”</othername>
        <surname>Smith</surname>
      </author>
    </authorgroup>
    <copyright>&cygnus-copyright;</copyright>
    <legalnotice> &cygnus-legal-notice; </legalnotice>
  </bookinfo>
  <toc></toc>
  <chapter id="my-first-chapter">
    <title>My first chapter</title>
    <para>Here's a paragraph of text because it is stylistically
        poor to start a section right after the chapter
        title.</para>
    <sect1 id="my-first-chapter-a-section">
      <title>A section in that first chapter</title>
      <titleabbrev>A section</titleabbrev>
      <para>All I need is a single paragraph of text to make the
        section valid.</para>
    </sect1>
  </chapter>
  <appendix id="Remaining-details">
    <title>Remaining details</title>
    <para>Although this booklet is quite complete, here I will
        mention some details I never got to.</para>
    <sect1 id="Use-of-the-word-dude">
      <title>Use of the word dude</title>
      <para>Here's an example of how to say
        <emphasis>dude</emphasis>: DUDE.</para>
      <caution>Saying dude too often can make your brain
        soft.</caution>
    </sect1>
  </appendix>
</book>
      
      
      Brief explanation
      
	You will noticed that I added several new elements in the
	document preamble (the bookinfo element). A
	lot of the information in bookinfo is
	meta-information, mostly to be used for
	classification and indexing, and which might or might not
	appear when the document is rendered.
      
      
	I introduced some entities (sort of
	like C preprocessor macros) such as &cygnus-copyright;.  These are
	supplied by someone else, and you should use them to get up to
	date boiler plate information in your document, such as the
	copyright statement and the legal notice.
      
      
	I also added attributes to some of the
	elements, for example in the tag
      
      
	<chapter id="my-first-chapter">
      
      
	An element's attributes allow you to pigeonhole extra
	information that may be useful when that element is processed.
	In this case, the id
	attribute identifies the chapters or sections for possible
	future cross–referencing.
      
    
    
      From here on
      
	Examples from now on will not give the entire book or article
	structure: you are supposed to use your powers of analogy to
	fit future fragments into one of the above top level
	structures.  Lengthy examples will, however, contain an
	initial doctype statement so that they will
	constitute a valid SGML file.  Remember to
	strip that away if you include the fragment in a larger
	document.
      
    
  
  
    A tour of some DocBook features
    DocBook tour
    
      This chapter gives a tour of the various DocBook features I
      expect you will need to use, and tells you how to use them.  In
      some cases DocBook allows you to do something in more than one
      way.  In those cases, I will tell you how we have agreed to do
      those things at &cygnus;.
    
	Global markups
      
	Your docbook document will always have a top level element. In
	the examples above it was book, but it can
	be article, set,
	part, chapter and one of
	many more. tags.
      
	I suspect that as a hacker, rather than a professional doc
	writer, you will usually be in one of two situations: either you
	are writing an article or essay yourself (in which case you
	will probably use article as a top level
	element) or you will be working within the structure of an
	existing book or set of books (in which case you will probably
	be using book or chapter
	as your top level element.
      
      
	Books
	
	  A book will be structured in the following way:
	  
	    book
	      meta information
	      chapter
	        sect1
	        sect1
	      chapter
	        sect1
	      appendix
	        sect1
	      appendix
	        sect1
	        …
	      glossary
	  
	
      
      
	Articles
	
	  An article will be structured in the following way:
	  
	    article
	      meta information
	      sect1
	      sect1
	        sect2
	      sect1
	      …
	  
	
      
    
    
      Examples and screen snapshots
      
	You will frequently want to report a typical session on the
	command line (sort the way I do in ), or describe how to
	interact with a GUI.
      
      
	Examples involving plain text
	
	  Command line examples are rather straightforward, since they
	  present a linear progression.  The main elements to keep in
	  mind are example,
	  programlisting,
	  screen, literal,
	  prompt and userinput.
	  Program listings will be discussed in .
	
	
	  As an example, here's how I wrote the beginning of the
	  anonymous ftp session in :
	
	
	  Documenting a typical ftp session
	  
<!doctype screen PUBLIC "-//Davenport//DTD DocBook V3.0//EN" [
]>
<screen>
  <prompt>$</prompt> <userinput>ncftp ftp://ftp.cygnus.com/pub/home/rosalia/</userinput>
  <prompt>ncftp></prompt> <userinput>cd docware/RPMS/i386/</userinput>
  <prompt>ncftp></prompt> <userinput>mget *.rpm</userinput>
  <prompt>ncftp></prompt> <userinput>quit</userinput>
</screen>
	  
	
	
	  If you process and view this snippet, you will see that the
	  HTML code has a nice gray shading for screenshots.  For now
	  the TeX/postscript output does not have a similar
	  cartouche, but it does use a
	  typewriter font.
	
      

      
	Describing GUIs
	
	  I have never described a GUI using screen shots or anything
	  like that, so I will skip this one for now.  All I know is
	  that you use tags like callout.  I'll
	  take a screen dump from xv
	  running on a Dilbert strip and experiment.
	
      
      
	Code samples
	
	  In writing technical documentation you frequently need to
	  show pieces of program source code.  You can do this with
	  DocBook's programlisting tag:
	
	  Program listings in DocBook
	  
<example>
<title>A simple C program</title>
  <programlisting role="C">
  #include <stdio.h>
  main()
  {
    printf("Hello, world!\n");
  }
  </programlisting>
</example>
	  
	
	Here's what it would look like:
	
	  A simple C program
	  
#include <stdio.h>
main()
{
  printf("Hello, world!\n");
}
	  
	
      
    
    
      Describing an API
      
	DocBook has a rather detailed way of marking up descriptions
	of function behaviour.  The tag that introduces it is
	funcsynopsis.  Here is an example:
      
	Describing a function in a C library API
	
<funcsynopsis>
  <funcsynopsisinfo>#include <stdlib.h></funcsynopsisinfo>
  <funcdef>double <function>atof</function></funcdef>
  <paramdef>const char *<parameter>nptr</parameter></paramdef>
</funcsynopsis>
	
      
      
	Here is how it looks:
      
	#include <stdlib.h>
	double atof
	const char *nptr
      
    
    
      Tables
      
	For now I am just going to play around with some examples of
	tables (so look at the source to see how they are done), after
	which I will present a few simple ways of doing tables.  These
	tables work well, and they might cover most situations in
	which you will need tables.
      
      
	A simple informal table (no title)
	
      <!doctype informaltable PUBLIC "-//Davenport//DTD DocBook V3.0//EN" [
       ]>
      <informaltable frame="all">
        <title>A fictitious description of compiler features</title>
        <tgroup cols="4">
          <thead>
            <row>
              <entry>Architecture</entry>
              <entry>Company</entry>
              <entry>Native code support</entry>
              <entry>Max optimization</entry>
            </row>
          </thead>
          <tbody>
            <row>
              <entry>i386</entry>
              <entry>Intel</entry>
              <entry>yes</entry>
              <entry>-O4</entry>
            </row>
            <row>
              <entry>alpha</entry>
              <entry>DEC</entry>
              <entry>yes</entry>
              <entry>-O3</entry>
            </row>
            <row>
              <entry>Z80</entry>
              <entry>Zilog</entry>
              <entry>no</entry>
              <entry>-O1</entry>
            </row>
          </tbody>
        </tgroup>
      </informaltable>
	
      
      
	
	  
	    
	      Architecture
	      Company
	      Native code
	      Max optimization
	    
	  
	  
	    
	      i386
	      Intel
	      yes
	      -O4
	    
	    
	      alpha
	      DEC
	      yes
	      -O3
	    
            
              Z80
              Zilog
              no
              -O1
            
	  
	
      

      
	The following table has a title, uses some mathematical
	symbols (like the &sum;
	entity.  It also uses the align attribute to specify
	alignment based on the decimal point in the floating point
	numbers.
      

      
	A more complex table
	
      <table frame="all">
	<title>Convergence of dynamical equations and constraints for
	  various choices of constrained edges</title>
        <tgroup cols=5 align="char" charoff="50" char=".">
          <thead>
	    <row>
	      <entry>Constrained edges</entry>
	      <entry>Model</entry>
	      <entry># of iter.</entry>
	      <entry>&sum;E
	        <subscript>i</subscript><superscript>2</superscript></entry>
	      <entry>&sum;C
	        <subscript>i</subscript><superscript>2</superscript></entry>
	    </row>
	    </thead>
	    <tbody>
	    <row>
	      <entry>AD, AF, AG, AA'</entry>
	      <entry>Flat space</entry>
	      <entry>5</entry>
	      <entry>1.15×10<superscript>-24</superscript></entry>
	      <entry>1.77×10<superscript>-19</superscript></entry>
	    </row>
	    <row>
	      <entry>AD, AF, AG, AA'</entry>
	      <entry>Kasner universe</entry>
	      <entry>6</entry>
	      <entry>1.43×10<superscript>-19</superscript></entry>
	      <entry>1.77×10<superscript>-8</superscript></entry>
	    </row>
	    <row>
	      <entry>AB, AC, AE, AA'</entry>
	      <entry>Flat space</entry>
	      <entry>4</entry>
	      <entry>1.15×10<superscript>-24</superscript></entry>
	      <entry>4.09×10<superscript>-24</superscript></entry>
	    </row>
	    <row>
	      <entry>AB, AC, AE, AA'</entry>
	      <entry>Kasner universe</entry>
	      <entry>7</entry>
	      <entry>1.33×10<superscript>-19</superscript></entry>
	      <entry>8.07×10<superscript>-7</superscript></entry>
	    </row>
          </tbody>
        </tgroup>
      </table>
	  
	
	  This is how that table would be rendered in the output mode
	  you are viewing now:
	
      
      Convergence of dynamical equations and constraints for
	  various choices of constrained edges
          
	      Constrained edges
	      Model
	      # of iter.
	      ∑E
		i2
	      ∑C
		i2
            
	      AD, AF, AG, AA'
	      Flat space
	      5
	      1.15×10-24
	      1.77×10-19
            
	      AD, AF, AG, AA'
	      Kasner universe
	      6
	      1.43×10-19
	      1.77×10-8
            
	      AB, AC, AE, AA'
	      Flat space
	      4
	      1.15×10-24
	      4.09×10-24
            
	      AB, AC, AE, AA'
	      Kasner universe
	      7
	      1.33×10-19
	      8.07×10-7
            

	
        
            
          
          
            
            
            
            
          
        
      

    
    
	Reference things
      library function reference things, man page reference
	things
      
    
  
  
    Concepts
    
      Now that you have written your first DocBook document, and you
      have processed it, you might actually want to understand a
      little of what goes on in this world.
    
    
      You have probably heard an incoherent babble of terms like
      SGML, DTD,
      DSSSL, DocBook, HTML, and
      so forth, and you might be wondering how they should all fit in
      to your world view.
    
    
      I will give you both a top–down explanation, illustrating
      what your world view might be, and a bottom–up explanation
      of what all the individual SGML–related
      concepts mean.
    
    
      Your world view
      
	Most people who do word processing or typesetting use a
	WYSIWYG word processor or a typesetting
	system in which they type explicit markup instructions which
	tell the typesetter how to position text on the page (such as
	TeX and
	troff).
      
	Both of these approaches suffer from a few serious problems.
	The biggest one is longevity of the document: eternal
	information (the profound things you type) is interspersed
	with information that will be obsolete (the typesetting
	information).
      
      
	Another big problem with this old approach is lack of
	structure: the markup did not express
	content, but rather page layout.  Let's say you are interested
	in indexing a bunch of papers written in
	TeX.  It would be rather easy to
	index all occurances of boldface text, but that's not
	interesting at all!  Instead, it would be really useful to
	index all function names in an API.  With old typesetting
	approaches you would need artificially intelligent software
	that could understand the text and say ``aha! this must be the
	definition of a function in the API''.
      
	So your old world view of writing a document and having the
	main challenge be how to mark it up to look good on paper is a
	poor one.  Your challenge should be how to mark your document
	up to emphasize semantic content.
    
    
      Markup based on content
      
	So how do you mark your documents such that useful information
	can be extracted and indexed?  The approach in DocBook is to
	provide a very rich set of markup tags that all relate to the
	structure and nature of the document's content.
      
	To give you a couple of examples of tags that could help with
	generating automatic indices:
	<attribution> and
	<command>.  If you have a large body
	of documentation (for example, all Sun software and hardware
	is documented with DocBook) you can do a very easy search for
	any document that discusses a command called
	mount, or a quote attributed to Ken
	Thompson.  On top of that, with such a structured search you
	would only find occurances of mount
	when it is a command name, and of
	Thompson when he is the author of a
	quote.
      
      
	Now imagine for a moment what would happen if the entire World
	Wide Web used a rich content–based markup language
	instead of HTML: a search engine would give you the
	information you need without all the extra references which
	just happen to use those words casually.  A search for
	mount on the web would almost certainly not
	find you references on the UNIX mount
	command.
      
	So a rich markup language like DocBook is a good idea from
	many points of view, but it can also be difficult to use.
	DocBook has hundreds of tags (as opposed to just a few in
	HTML), so you might find the learning curve steep.  That is
	true, and the only way around that is to write documentation
	on how to use DocBook!
      
	On the other hand, once you are quite familiar with DocBook it
	will not slow you down too much to type in markup all the
	time.  Keep in mind that most of the time a person is not
	writing, but rather worrying about meta–level problems
	with their document.  If you use DocBook well you will spend a
	bit more time writing and a lot less time worrying about other
	issues like the layout on paper.  (There is nothing you can do
	about it anyway!)
      
    
    
      Explanation of <acronym>SGML</acronym>–related
	terms
      
	You have probably already heard many
	SGML–related terms, but they are
	seldom used carefully, so people end up with misconceptions
	which can be annoying.
      
	SGML — a framework for defining markup
	  languages
	SGML — a framework
	
	  First of all: SGML (which stands for
	  Standard Genralized Markup Language) is not a
	    markup language in itself!  It is a
	  framework for describing individual
	  markup languages (such as DocBook or HTML), so it is really
	  a very different beast.  Kind of like the difference between
	  a suitcase factory and a suitcase.
	
	  DocBook and HTML are a specific instantiation of
	  SGML, sometimes called SGML
	    applications.
	
	  So when people say that they are writing documents in
	  SGML they are being quite imprecise.  To
	  be precise they could say (for example) ``We are writing our
	  documentation in DocBook, which is an
	  SGML–base markup language'', or
	  something on those lines.
	
	  The way you define a particular markup language in the
	  SGML formalism is by writing up a
	  Document Type Definition (usually
	  referred to as a
	  DTD.  The DTD
	  specifies what tags can be used in the markup language, and
	  in some cases it also specifies the hierarchy of those
	  tags.  For example, you have probably noticed that in
	  DocBook you can only put a title tag
	  immediately after certain tags (such as
	  chapter sect1 and some
	  others).
	
      
      
	What about the appearnace on output media?
	What about output?
	
      
    
  
  
    How you should structure your documents
    
      I will just leave fillers for most of this chapter for now, but
      my scope in this chapter is to describe a few writing style
      issues that are specific to computer manuals.  English writing
      style is described well in many books.
    
    
      Structure of a book
      
	dude
      
    
    
      Structure of a chapter
      
	dude
      
    
    
      Structure of sections
      
	dude
      
    
  

  
    DocBook Resources
    
      
	
	    Norman Walsh's quick reference card on DocBook
	
      
      
	
	    Mark Galassi's DocBook tutorial
	
      
      
	
	    Bob DuCharme's tips on PSGML mode for emacs
	
      
      
	
	    The official DocBook home page, now hosted by OASIS
	
      
      
	
	    Home pare for the SGMLtools project
	
      
    
  

  
    SGML entities
    
      This introduction is provided to help explain some basic
      concepts of using SGML to writers who are not yet very familiar
      with SGML and illustrate some of the strategies from SGML that
      you may use to handle common writing issues. It assumes that you
      already understand the basic concept of marking up documents in
      an SGML language that indicates what the content is and not what
      it should look like and that you know a few acronyms, like DTD
      (for document type definition) or ISO (International Standards
      Organization).
    

    
      BASIC STRUCTURE OF AN SGML DOCUMENT

      
So what does an SGML document look like? Well, there are at least three
different pieces: a main document file, the DTD for that type of document,
and the SGML Declaration for that type of document. The main document file
can also use any number of other files containing text marked up in SGML or
other types of information like graphics or multimedia files.
      
      
	The SGML declaration contains a lot of esoteric information, but basically
describes SGML conventions that are followed in documents of that type. The
DTD describes the structure for documents of that type and the set of tags
(the language) that mark up the document to define the content and
structure. SGML systems need all of this information to read the SGML
document correctly.
      
      
	When SGML systems work with SGML documents, they start with the main
document:
      
      
	
	  
	    The main document defines the start and end of your
	    document and identifies the DTD and SGML declaration to
	    use with the document. It also identifies any other files
	    with content that are included in your document.
	  
	  
	    The main document starts with a line identifying the DTD
	    for this document that looks something like this:
	  
	  
<!DOCTYPE  MyDocuments PUBLIC "-//Joan Duvall//DTD Joan's Documents//EN">
	  
	    Tags are enclosed in start/end tag characters. The most
	    common characters for this are < (start) and > (end).
	  
	  
	    The !DOCTYPE tells SGML systems that this tag identifies
	    the document type for this document.
	  
	  
	    MyDocuments is the name of the document type and is always
	    the name of the beginning and ending tags for documents
	    that use this DTD. All of the content for the document
	    comes between these tags.
	  
	  
	    PUBLIC  and the long strange name in quotes identifies the
	    file for the DTD and for the SGML declaration. This is
	    called a formal public ID, or FPI. An explanation of FPIs
	    comes later.
	  
	
	
	  Inside the document type declaration, a document can
	    also have other declarations of information that can be
	    used in the document. This is known as the internal subset
	    and is contained inside brackets [ and ] after the DTD
	    identifier and before the end tag character. It would then
	    look like this:
	  
	  
<!DOCTYPE  MyDocuments PUBLIC "-//Joan Duvall//DTD Joan's Documents//EN" [
...some other declarations here...
]>
	
	
	  
	    After the document type declaration comes the document.
	    All of the content for your document must be enclosed in a
	    beginning and ending tag that matches the document type.
	    In our example, this looks like:
	  
	  
<MyDocuments> ... the content of your document ... </MyDocuments>

	  
	    Tags that enclose contents have a start tag like
	    <MyDocuments> and an end tag </MyDocuments> that use
	    the same name but the slash identifies the end tag. Tag
	    names are also known as elements or generic identifiers
	    (gi's).
	  
	
      
    
    
      USING ENTITIES TO CONNECT OTHER FILES

      
	SGML uses something called a general entity to include other
	files inside a document. There are other types of entities in
	SGML, but this is the most common. A general entity is
	identified by an entity declaration in the internal subset of
	your main document. It looks like this:
      
      
<!DOCTYPE  MyDocuments PUBLIC "-//Joan Duvall//DTD Joan's Documents//EN" [
...
<!ENTITY Chapter1 SYSTEM "chp1.sgm">
... ]>

      
	The <!ENTITY indicates this is an entity declaration. Chapter1 is the name
you give to the entity. SYSTEM is a keyword that tells an SGML system that
the identifier for the file for this entity is specific to your computer
system - most commonly this means that you supply the file name to include
directly in the declaration. In this example chp1.sgm is the file name that
should be included and this is all the path information that the system
needs to find the file.
      
      
	With entities, the declaration simply identifies the file or content to use
- you decide where that should actually be included by inserting the entity
in your document. To include the entity, you insert an ampersand, the
entity name, and a semi-colon. For example:
      
      
<!DOCTYPE  MyDocuments PUBLIC "-//Joan Duvall//DTD Joan's Documents//EN" [
...
<!ENTITY Chapter1 SYSTEM "chp1.sgm">
... ]>
<MyDocuments>
<Title>My First Novel</Title>
<Author>Joan Duvall</Author>
&Chapter1;
</MyDocuments>

      This document has only one chapter, which is included where &Chapter1;
appears. Any file that is included that contains text and SGML tags must
also fit properly within the structure of the document, as that is defined
in the DTD. They also must be balanced - any tag that starts in a separate
file must end in that file. In this example, the file chp1.sgm contains
text marked up in SGML and the contents are all enclosed within <Chapter>
... </Chapter> tags as the Chapter element is valid content at this point
within the document.
      
    
    
	IDENTIFYING FILES WITH FORMAL PUBLIC IDS

      
	You can always identify files to include by their name and path information
(a system identifier). But there are several reasons why you may want to
use public IDs, or FPIs, instead. The biggest reason is to make it easier
to move files without having to change your documents. Another reason is to
make it easier to exchange your files with other people or groups where the
directories on their system may be different. FPIs also allow you or your
company to claim ownership of important information, such as your DTD.
      
      
	With FPIs, you identify a file by an abstract name in your document and
then supply the location of that file in a catalog, sometimes called a
mapping file or entity manager. The catalog is another, separate file from
your document.
      
      
	If a file that is used in your document moves, you simply change its
location in the catalog rather than changing the location in your document
or any other document that uses it. If you exchange files with some one
else, or simply move the files to a new computer with different
directories, you only have to change the location information once in the
catalog.
      
      
	FPIs must have a specific structure. Two slashes are used to mark the
separation between each part of the structure, such as:
      
      
"Registration//Owner//Keyword  Description//Language"

      
	
	  Registration
	  
	    
	      The first character indicates whether the FPI is
	      formally registered (+) or not (-) with an ISO approved
	      registration service. If you define your own FPIs and
	      don't register them, use the hyphen.
	    
	  
	
	
	  Owner
	  
	    The owner of the file is the second part of the FPI.
	      This can be a company, an organization, or a person.
	    
	  
	
	
	  Keyword
	  
	    There are several keywords that indicate the type of
	      information in the file. Some of the most common
	      keywords are DTD, ELEMENT, and TEXT. DTD is used only
	      for DTD files, ELEMENT is usually used for DTD fragments
	      that contain only entity or element declarations. TEXT
	      is used for SGML content (text and tags).
	    
	  
	
	
	  Description
	  
	    Any description you want to supply for the contents
	      of this file. This may include version numbers or any
	      short text that is meaningful to you and unique for the
	      SGML system.
	  

	
	
	  Language
	  
	    
	      This is an ISO two-character code that identifies the native
language for the file. EN is
          used for English.
	  
	
      
    
    
      USING ENTITIES FOR SHARED TEXT
      
	Entities can be used for other purposes. Another common usage is to define
text that is repeated in lots of places that you don't want to type every
time, or that you want to be able to easily change everywhere it is used.
These are general entities that you define in the internal subset of your
document and then use within your document.
      
      
	For example, you are writing a document that frequently refers to the ANSI
X.12 ASC 835 standard. This phrase must appear exactly as it is shown.
Rather than type it out every single time, you define this entity:
      
      
<!DOCTYPE  MyDocuments PUBLIC "-//Joan Duvall//DTD Joan's Documents//EN" [
...
<!ENTITY ansi835 "ANSI X.12 ASC 835">
... ]>

      
	Within the document, you use this entity every time you need
	to refer to the standard name. For example:

      
<paragraph>This interface follows the exchange protocols for &ansi835;
version 3070 for remittance information. </paragraph>

      
When the document is printed or processed by an SGML system for any type of
output, the &ansi835; characters are replaced with ANSI X.12 ASC 835
instead.
      
    
    
      USING MARKED SECTIONS TO HANDLE CONDITIONAL CONTENT
      
	Sometimes you need to have different versions of the content
	for different purposes. There are several ways to do this
	using SGML, one of which is called marked sections. A simple
	example of conditional content might be the description of
	keys used in a software program where they appear in boxes in
	the printed manual but are blue inside brackets on the web
	site or CD. Rather than have two separate versions of the
	conventions for each output of the manual, you can use marked
	sections to keep both variations in the same document.
      
      
	There are different types of marked sections, but the types
	that allow you to control conditional content are
	ignore/include sections.  These markers act like on/off
	switches to allow content to be included or ignored in
	different situations.
      
      
	The marker for an include marked section looks like this:
      
      
<![INCLUDE [ keys are boxed, such as <key>F1</key> ]]>

      
	while an ignore marked section looks like this:
      
<![IGNORE [ keys are blue inside brackets, such as <key>F1</key> ]]>

      
	INCLUDE and IGNORE are the keywords that tell the SGML system what to
include or skip. As this example shows, marked sections can contain both
text and tags as long as the tags within the markers are balanced (if a tag
starts inside a marker, then it ends inside the same marker).
      
      
	In this example, you leave the markers for the print version as INCLUDE and
the markers for the electronic version as IGNORE when you print a master
copy. When you create the electronic book or HTML for the web site, you
change the markers for the print version to IGNORE and the markers for the
electronic version to INCLUDE. This works just fine, unless you have
several different sections you need to include or ignore together - it's
cumbersome to change each one manually and you can easily make a mistake.
      
      
	So instead, you can define parameter entities under any names you want and
then change the entities to turn the include/ignore switches. To do this,
you add parameter entity declarations in the internal subset at the top of
your master SGML document. For example:
      
      
<!DOCTYPE  MyDocuments PUBLIC "-//Joan Duvall//DTD Joan's Documents//EN" [
...
<!ENTITY % hardcopy "INCLUDE">
<!ENTITY % softcopy "IGNORE">
...]>

      
	You then use the names for each marked section, like this:

      
<![%hardcopy; [ keys are boxed, such as <key>F1</key> ]]>
<![%softcopy; [ keys are blue inside brackets, such as <key>F1</key> ]]>

      
	To print the master copy, you leave the entity declarations as
	they are shown above. The SGML system interprets each
	%hardcopy; it finds as INCLUDE and includes those marked
	sections. The %softcopy; is interpreted as IGNORE and those
	sections are skipped. When you're ready to produce the
	electronic version, you only have to change the entity
	declarations at the top of the file, like this:

      
<!DOCTYPE  MyDocuments PUBLIC "-//Joan Duvall//DTD Joan's Documents//EN" [
...
<!ENTITY % hardcopy "IGNORE">
<!ENTITY % softcopy "INCLUDE">
...]>

      
	With this single change, the electronic versions are included and the
printed versions are skipped.
      
      
	Marked sections can be simple, but they are not always the
	best choice to manage conditional text. They are best if you
	use them sparingly and in very clear situations - it's easy to
	figure out when to use them and when to change the
	INCLUDE/IGNORE switches. Some of the problems that they can
	create include:
      

      
	
	  
	    - Marked sections can be nested (a marked section inside
	    another marked section), but this can confuse your SGML
	    system and may not produce the effect you want. For
	    example, SGML systems can't properly handle an included
	    marked section inside an ignored marked section.
	  
	
	
	  
	    - If you use lots of differently named sections, it's easy
	    to lose track of the content and can make your SGML
	    document invalid if some required structures are set to
	    IGNORE.
	  
	
	
	  
	    - Finally, they are not supported in XML, the new standard
	    subset of SGML that will be viewable directly on the World
	    Wide Web. Moving to XML could be difficult if you use
	    marked sections a lot.
	  
	
      
    
  

  
    Emacs PSGML mode tips
    
From: Mark Galassi <rosalia@galassi.org>
Sender: owner-sgml-tools@via.ecp.fr
To: sgml-tools@via.ecp.fr
Subject: Re: dtd parser!
Date: Fri, 23 Oct 1998 09:19:01 -0600 (MDT)

    Jose> My question is: Is there any available tool (parser) to
    Jose> analyse a dtd and return the same informations that is
    Jose> contained in the reference manual?

There are a few.  The one I use is emacs with PSGML mode.  It has
emacs-style completion *on tags*!!  It's really cool.

If you type "C-c C-e" it will prompt you for an element, and offer as
completions only the valid elements at that point.

Once it inserts the element, it inserts it with any required following 
elements along with a comment saying which ones you could put later
on.

As an example, I just went to a DocBook buffer and typed

C-c C-e variab<SPACE BAR><RETURN>

and it inserted this text in the buffer:

    <variablelist>
      <varlistentry>
	<term></term>
	<listitem>
	  <!-- one of (epigraph authorblurb abstract highlights comment bridgehead anchor sidebar procedure msgset table figure example equation informaltable informalexample informalequation graphicco graphic blockquote address simpara para formalpara funcsynopsis cmdsynopsis synopsis screenshot screenco screen programlistingco programlisting literallayout warning tip note important caution variablelist simplelist segmentedlist orderedlist itemizedlist glosslist calloutlist) -->
	</listitem>
      </varlistentry>
    </variablelist>

Another example:

C-c C-e i<SPACE BAR>

and it showsme the following completions:

----

Click mouse-2 on a completion to select it.
In this buffer, type RET to select the completion near point.

Possible completions are:
important			   indexterm
informalequation		   informalexample
informaltable			   itemizedlist

----
    
  
  
    Obtaining and installing DocBook tools
    Obtaining and installing
    
      Follow these instructions for your favourite platform, either
      UNIX (free tools), Win32 (free tools) or FrameMaker+SGML.
    
    
      UNIX
      
	On UNIX we are distributing these tools as RPM packages,
	providing a binary distribution for intel-baesd GNU/Linux
	systems, and a source distribution for others [FIXME: must
	clear this up a bit].
      
      
	Here is an example of a UNIX session to get and install the
	free DocBook tool set on a GNU/Linux system.  The tools can be
	found at  this
	  location  [FIXME: the DSSSL for printed output does
	the wrong thing with ulink.]
      
      
	$ ncftp ftp://ftp.cygnus.com/pub/home/rosalia/
	ncftp> cd docware/RPMS/i386/
	ncftp> mget *.rpm
	ncftp> quit
	$ su
	Password: ultra-sucure
	# rpm --install sgml-common*.rpm
	# rpm --install docbook*.rpm
	# rpm --install stylesheets*.rpm
	# rpm --install psgml*.rpm
	# rpm --install jade*.rpm
	# rpm --install jadetex*.rpm
	# rpm --install sgml-demo*.rpm
      
      
	The order of installing packages is important.
      
      
	
	  When you are upgrading, rather than installing for the first
	  time, the
	  rpm --install
	  steps should be replaced with
	  rpm --upgrade.
	
      
      
 	You are now ready to edit SGML/DocBook
	documents.
      
    
    
      Win32
      
	For Win32 we are distributing these tools as a standard
	Windows InstallShield self-extracting package.
      
    
    
      FrameMaker+SGML
      
	FrameMaker+SGML is a powerful
	WYSIWYGWYSIWYG stands for
	    “what you see is what you
	    get”. which allows you to edit
	SGML documents with all the rendering and other features of
	FrameMaker.  In FrameMaker+SGML the
	correspondence between SGML tags and printed output is
	implemented with a document called the
	EDDElement Definition Document
	 which maps SGML elements to FrameMaker formatting
	instructions.
      
      
	FrameMaker+SGML ships with an
	outdated DocBook implementation, based on the DocBook 2.2.1
	DTD (the current version is 3.0) provided by Lynne Price.
	Lynne Price then upgraded the DTD to 3.0 under contract by
	Cygnus Solutions but left most of the elements undefined in
	the EDD.
      
	In March of 1998 I started filling in the gaps by defining the
	output format for many tags in the EDD.  Later that year Alyce
	Gershenson and Frederick Geers modified the EDD and the
	FrameMaker template file to match the Cygnus publication
	styles.  In September of 1998 I defined many more tags in the
	EDD, to the point where I now think that Cygnus's EDD is a
	useful tool for FrameMaker+SGML users.
      
      
	I have finally made Cygnus's FrameMaker+SGML EDD available by
	anonymous ftp at the address ftp://ftp.cygnus.com/pub/home/rosalia/docware/framemaker/
	Please keep in mind that there are still some serious
	unresolved problems in the read/write rules and the FrameMaker
	API client, which I have not yet sat down to study.
      
      
	To use the FrameMaker+SGML support
	you should do the following:
      
	Grab all the
	    FrameMaker+SGML files from the
	    anonymous ftp site listed above.  Put them in a directory
	    (or folder on Windows) of their own.
	
	
	    Start up FrameMaker+SGML and
	    load the file Sgmlapps.fm.
	  
	
	Double-click on a line that says [FIXME: must
	    look it up] and change the variable to match the location
	    of the folder you created in .
	    
	
	
	    Go to the File menu and select
	    Developer's tools, and in there
	    select Reread SGML
	    application.  It will ask you to select a
	    file to “read in”, and you should pick
	    Sgmlapps.fm.
	  
	
	
	    Go to the File menu and select
	    Set SGML application.  You will
	    get a couple of choices.  You should choose
	    DocBook-3.0-cygnus (or whatever it was). Do
	    not choose DocBook: this is the
	    obsolete version that Adobe ships.
	  
	
	
	    Create a new document.  When
	    FrameMaker+SGML asks you for a
	    template, you should select the
	    Template.fm file that you downloaded.
	  
	
      
      
	If all went well you should now have a DocBook document open.
	You can bring up the “structure view” and
	“element catalog” windows to help you edit your
	DocBook document.

      
	  I would love it if some
	  FrameMaker+SGML were to
	  collaborate with me on the DocBook EDD.  If you are
	  interested in doing so, please send email to
	  rosalia@galassi.org
	
      
    
  

  
    Glossary
    ASCII
      
	(American Standard Code for Information Interchange)
	  This standard character encoding scheme is used extensively
	  in data transmission.
      
    
    ANSI
      
	(American National Standards Institute) This group is
	  the U.S. member organization that belongs to the ISO, the
	  International Organization for Standardization.
	
      
    
    attribute
      
	An attribute provides more information about an element
	  such as classification level, unique reference identifiers,
	  or formatting information.
      
    
    CCITT Group 4
      
	(International Consultative Committee on Telegraphy and
	  Telephony) This CALS standard for raster graphics
	  incorporates tiling, which divides a large image into
	  smaller tiles. You can exchange graphic files in CCITT/4
	  format in a compressed state so they take up much less file
	  space.
      
    
    CITIS
      
	(Contractor Integrated Technical Information Service) As
	  part of CALS Phase II, CITIS is a draft functional
	  specification for services. DoD acquisition managers
	  designed CITIS as a plan to gain access to product-related
	  digital technical information.
      
    
    CGM
      
	(Computer Graphics Metafile) CGM is one of the CALS
	  standard formats for representing 2–D technical
	  illustrations. CGM is an object-oriented graphic
	  format.
      
    
    DSSSL
      
	(Document Style Semantics and Specification Language)
	  This draft international standard (DIS 10179) applies to the
	  specification of processing information for
	  SGML documents. DSSSL
	  is expected to became an international standard. 
	
      
    
    DTD
      
	(Document Type Definition) A DTD is the formal
	  definition of the elements, structures, and rules for
	  marking up a given type of SGML document.
	  You can store a DTD at the beginning of a document or
	  externally in a separate file.
	
      
    
    EDI
      
	(Electronic Data Interchange) This is a set of computer
	  interchange standards for business documents such as
	  invoices, bills, and purchase orders.
	
      
    
    element
      
	An element is a piece of data within a document that may
	  contain either text or other subelements such as a
	  paragraph, a chapter, and so on.
      
    
    element declaration
      
	A statement in the DTD defining an element and declaring
	  the order in which it may appear in the document and what
	  other elements it may include.
	
      
    
    entity
      
	An entity is a self-contained piece of data that can be
	  referenced as a unit. You can refer to an entity by a
	  symbolic name in the DTD or the document. An entity can be a
	  string of characters, a symbol character (unavailable on a
	  standard keyboard), a separate text file, or a separate
	  graphic file.
      
    
    entity declaration
      
	A statement in the DTD or document that assigns an
	  SGML name to an entity so you can
	  reference it.
      
    
    FOSI
      
	(Formatting Output Specification Instance) A FOSI is
	  used for formatting SGML documents for
	  printing and other outputs. It is a separate file that
	  contains formatting information for each element in a
	  document.
      
    
    HTML
      
	(HyperText Markup Language) This is the format of files
	  published on the &www;. HTML is an application of
	  SGML; to author in HTML using
	  SGML-based authoring software, you simply
	  need the HTML DTD.
      
    
    IGES
      
	(Initial Graphics Exchange Specification) The IGES
	  standard for engineering, product design, and manufacturing
	  drawings is one of the CALS standard graphics
	  formats.
      
    
    Internet
      
	The Internet is a worldwide communications network
	  originally developed by the U.S. Department of Defense as a
	  distributed system with no single point of failure. The
	  Internet has seen an explosion in commercial use since the
	  development of easy-to-use software for accessing the
	  Internet.
      
    
    ISO
      
	(International Organization for Standardization) The ISO
	  is an industry-supported organization that establishes
	  worldwide standards for everything from data interchange
	  formats to film speed specifications.
      
    
    markup
      
	Markup is anything added to the content of the document
	  that describes the text.
      
    
    parser
      
	A parser is a specialized software program that
	  recognizes SGML markup in a document. A
	  parser that reads a DTD and checks and reports on markup
	  errors is a validating SGML parser. A
	  parser can be built into an SGML editor
	  to prevent incorrect tagging and to check whether a document
	  contains all the required elements.
      
    
    PDES/STEP
      
	(Product Data Exchange Standard/Standard for the
	  Exchange of Product Model Data). PDES/STEP are standards
	  under development for communicating a complete product model
	  with sufficient information content that advanced CAD/CAM
	  applications can interpret. PDES is under development as a
	  national standard and STEP is under development as its
	  international counterpart.
      
    
    tag
      
	In the world of SGML, a tag is a
	  marker embedded in a document that indicates the purpose or
	  function of the element. Each element has a beginning tag
	  and an end tag.
      
    
    &www;
      
	Often referred to as WWW or the Web, this usually refers
	  to information available on the Internet that can be easily
	  accessed with software usually called a
	  browser. Organizations publish their
	  information on the Web in a format known as HTML; this
	  information is usually referred to as their home
	    page or web site.
      
    
  


cduce-0.6.0/doc/docbook/docbook.cd000066400000000000000000000001751230562553500167260ustar00rootroot00000000000000include "docbookx.cd"        (* Docbook 4.3 DTD *)
include "docbook-categ.cd"   (* Categories (Inline, ...) from this DTD *)
cduce-0.6.0/doc/docbook/docbookx.cd000066400000000000000000012266101230562553500171230ustar00rootroot00000000000000(* This type has been automatically generated from /usr/share/sgml/docbook/xml-dtd-4.2-1.0-17/docbookx.dtd by dtd2cduce *)
type DBarticle =
       
[
          ((DBtitle DBsubtitle? DBtitleabbrev?)? DBarticleinfo? DBtocchap?
           DBlot*
           (((DBcalloutlist | DBglosslist | DBitemizedlist | DBorderedlist
              | DBsegmentedlist | DBsimplelist | DBvariablelist | DBcaution
              | DBimportant | DBnote | DBtip | DBwarning | DBliterallayout
              | DBprogramlisting | DBprogramlistingco | DBscreen | DBscreenco
              | DBscreenshot | DBsynopsis | DBcmdsynopsis | DBfuncsynopsis
              | DBclasssynopsis | DBfieldsynopsis | DBconstructorsynopsis
              | DBdestructorsynopsis | DBmethodsynopsis | DBformalpara
              | DBpara | DBsimpara | DBaddress | DBblockquote | DBgraphic
              | DBgraphicco | DBmediaobject | DBmediaobjectco
              | DBinformalequation | DBinformalexample | DBinformalfigure
              | DBinformaltable | DBequation | DBexample | DBfigure | DBtable
              | DBmsgset | DBprocedure | DBsidebar | DBqandaset | DBanchor
              | DBbridgehead | DBremark | DBhighlights | DBabstract
              | DBauthorblurb | DBepigraph | DBindexterm | DBbeginpage)+
             (DBsect1* | DBrefentry* | DBsimplesect* | DBsection*))
            | (DBsect1+ | DBrefentry+ | DBsimplesect+ | DBsection+))
           ((DBtoc | DBlot | DBindex | DBglossary | DBbibliography)
            | DBappendix | DBackno)*)
          ];;
type DBrefsect3 =
       [
          (DBrefsect3info? (DBtitle DBsubtitle? DBtitleabbrev?)
           (DBcalloutlist | DBglosslist | DBitemizedlist | DBorderedlist
            | DBsegmentedlist | DBsimplelist | DBvariablelist | DBcaution
            | DBimportant | DBnote | DBtip | DBwarning | DBliterallayout
            | DBprogramlisting | DBprogramlistingco | DBscreen | DBscreenco
            | DBscreenshot | DBsynopsis | DBcmdsynopsis | DBfuncsynopsis
            | DBclasssynopsis | DBfieldsynopsis | DBconstructorsynopsis
            | DBdestructorsynopsis | DBmethodsynopsis | DBformalpara | DBpara
            | DBsimpara | DBaddress | DBblockquote | DBgraphic | DBgraphicco
            | DBmediaobject | DBmediaobjectco | DBinformalequation
            | DBinformalexample | DBinformalfigure | DBinformaltable
            | DBequation | DBexample | DBfigure | DBtable | DBmsgset
            | DBprocedure | DBsidebar | DBqandaset | DBanchor | DBbridgehead
            | DBremark | DBhighlights | DBabstract | DBauthorblurb
            | DBepigraph | DBindexterm | DBbeginpage)+)
          ];;
type DBrefsect2 =
       [
          (DBrefsect2info? (DBtitle DBsubtitle? DBtitleabbrev?)
           (((DBcalloutlist | DBglosslist | DBitemizedlist | DBorderedlist
              | DBsegmentedlist | DBsimplelist | DBvariablelist | DBcaution
              | DBimportant | DBnote | DBtip | DBwarning | DBliterallayout
              | DBprogramlisting | DBprogramlistingco | DBscreen | DBscreenco
              | DBscreenshot | DBsynopsis | DBcmdsynopsis | DBfuncsynopsis
              | DBclasssynopsis | DBfieldsynopsis | DBconstructorsynopsis
              | DBdestructorsynopsis | DBmethodsynopsis | DBformalpara
              | DBpara | DBsimpara | DBaddress | DBblockquote | DBgraphic
              | DBgraphicco | DBmediaobject | DBmediaobjectco
              | DBinformalequation | DBinformalexample | DBinformalfigure
              | DBinformaltable | DBequation | DBexample | DBfigure | DBtable
              | DBmsgset | DBprocedure | DBsidebar | DBqandaset | DBanchor
              | DBbridgehead | DBremark | DBhighlights | DBabstract
              | DBauthorblurb | DBepigraph | DBindexterm | DBbeginpage)+
             DBrefsect3*)
            | DBrefsect3+))
          ];;
type DBrefsect1 =
       [
          (DBrefsect1info? (DBtitle DBsubtitle? DBtitleabbrev?)
           (((DBcalloutlist | DBglosslist | DBitemizedlist | DBorderedlist
              | DBsegmentedlist | DBsimplelist | DBvariablelist | DBcaution
              | DBimportant | DBnote | DBtip | DBwarning | DBliterallayout
              | DBprogramlisting | DBprogramlistingco | DBscreen | DBscreenco
              | DBscreenshot | DBsynopsis | DBcmdsynopsis | DBfuncsynopsis
              | DBclasssynopsis | DBfieldsynopsis | DBconstructorsynopsis
              | DBdestructorsynopsis | DBmethodsynopsis | DBformalpara
              | DBpara | DBsimpara | DBaddress | DBblockquote | DBgraphic
              | DBgraphicco | DBmediaobject | DBmediaobjectco
              | DBinformalequation | DBinformalexample | DBinformalfigure
              | DBinformaltable | DBequation | DBexample | DBfigure | DBtable
              | DBmsgset | DBprocedure | DBsidebar | DBqandaset | DBanchor
              | DBbridgehead | DBremark | DBhighlights | DBabstract
              | DBauthorblurb | DBepigraph | DBindexterm | DBbeginpage)+
             DBrefsect2*)
            | DBrefsect2+))
          ];;
type DBrefsection =
       [
          (DBrefsectioninfo? (DBtitle DBsubtitle? DBtitleabbrev?)
           (((DBcalloutlist | DBglosslist | DBitemizedlist | DBorderedlist
              | DBsegmentedlist | DBsimplelist | DBvariablelist | DBcaution
              | DBimportant | DBnote | DBtip | DBwarning | DBliterallayout
              | DBprogramlisting | DBprogramlistingco | DBscreen | DBscreenco
              | DBscreenshot | DBsynopsis | DBcmdsynopsis | DBfuncsynopsis
              | DBclasssynopsis | DBfieldsynopsis | DBconstructorsynopsis
              | DBdestructorsynopsis | DBmethodsynopsis | DBformalpara
              | DBpara | DBsimpara | DBaddress | DBblockquote | DBgraphic
              | DBgraphicco | DBmediaobject | DBmediaobjectco
              | DBinformalequation | DBinformalexample | DBinformalfigure
              | DBinformaltable | DBequation | DBexample | DBfigure | DBtable
              | DBmsgset | DBprocedure | DBsidebar | DBqandaset | DBanchor
              | DBbridgehead | DBremark | DBhighlights | DBabstract
              | DBauthorblurb | DBepigraph | DBindexterm | DBbeginpage)+
             DBrefsection*)
            | DBrefsection+))
          ];;
type DBrefsynopsisdiv =
       [
          (DBrefsynopsisdivinfo? (DBtitle DBsubtitle? DBtitleabbrev?)?
           (((DBcalloutlist | DBglosslist | DBitemizedlist | DBorderedlist
              | DBsegmentedlist | DBsimplelist | DBvariablelist | DBcaution
              | DBimportant | DBnote | DBtip | DBwarning | DBliterallayout
              | DBprogramlisting | DBprogramlistingco | DBscreen | DBscreenco
              | DBscreenshot | DBsynopsis | DBcmdsynopsis | DBfuncsynopsis
              | DBclasssynopsis | DBfieldsynopsis | DBconstructorsynopsis
              | DBdestructorsynopsis | DBmethodsynopsis | DBformalpara
              | DBpara | DBsimpara | DBaddress | DBblockquote | DBgraphic
              | DBgraphicco | DBmediaobject | DBmediaobjectco
              | DBinformalequation | DBinformalexample | DBinformalfigure
              | DBinformaltable | DBequation | DBexample | DBfigure | DBtable
              | DBmsgset | DBprocedure | DBsidebar | DBqandaset | DBanchor
              | DBbridgehead | DBremark | DBhighlights | DBabstract
              | DBauthorblurb | DBepigraph | DBindexterm | DBbeginpage)+
             DBrefsect2*)
            | DBrefsect2+))
          ];;
type DBrefclass =
       [
          ( Char | DBapplication )* ];;
type DBrefpurpose =
       [
          ( Char | DBfootnoteref | DBxref | DBabbrev | DBacronym | DBcitation | DBciterefentry | DBcitetitle | DBemphasis | DBfirstterm | DBforeignphrase | DBglossterm | DBfootnote | DBphrase | DBquote | DBtrademark | DBwordasword | DBpersonname | DBlink | DBolink | DBulink | DBaction | DBapplication | DBclassname | DBmethodname | DBinterfacename | DBexceptionname | DBooclass | DBoointerface | DBooexception | DBcommand | DBcomputeroutput | DBdatabase | DBemail | DBenvar | DBerrorcode | DBerrorname | DBerrortype | DBerrortext | DBfilename | DBfunction | DBguibutton | DBguiicon | DBguilabel | DBguimenu | DBguimenuitem | DBguisubmenu | DBhardware | DBinterface | DBkeycap | DBkeycode | DBkeycombo | DBkeysym | DBliteral | DBconstant | DBmarkup | DBmedialabel | DBmenuchoice | DBmousebutton | DBoption | DBoptional | DBparameter | DBprompt | DBproperty | DBreplaceable | DBreturnvalue | DBsgmltag | DBstructfield | DBstructname | DBsymbol | DBsystemitem | DBtoken | DBtype | DBuserinput | DBvarname | DBanchor | DBauthor | DBauthorinitials | DBcorpauthor | DBmodespec | DBothercredit | DBproductname | DBproductnumber | DBrevhistory | DBremark | DBsubscript | DBsuperscript | DBindexterm | DBbeginpage )*
          ];;
type DBrefname =
       [
          ( Char | DBaction | DBapplication | DBclassname | DBmethodname | DBinterfacename | DBexceptionname | DBooclass | DBoointerface | DBooexception | DBcommand | DBcomputeroutput | DBdatabase | DBemail | DBenvar | DBerrorcode | DBerrorname | DBerrortype | DBerrortext | DBfilename | DBfunction | DBguibutton | DBguiicon | DBguilabel | DBguimenu | DBguimenuitem | DBguisubmenu | DBhardware | DBinterface | DBkeycap | DBkeycode | DBkeycombo | DBkeysym | DBliteral | DBconstant | DBmarkup | DBmedialabel | DBmenuchoice | DBmousebutton | DBoption | DBoptional | DBparameter | DBprompt | DBproperty | DBreplaceable | DBreturnvalue | DBsgmltag | DBstructfield | DBstructname | DBsymbol | DBsystemitem | DBtoken | DBtype | DBuserinput | DBvarname )*
          ];;
type DBrefdescriptor =
       [
          ( Char | DBaction | DBapplication | DBclassname | DBmethodname | DBinterfacename | DBexceptionname | DBooclass | DBoointerface | DBooexception | DBcommand | DBcomputeroutput | DBdatabase | DBemail | DBenvar | DBerrorcode | DBerrorname | DBerrortype | DBerrortext | DBfilename | DBfunction | DBguibutton | DBguiicon | DBguilabel | DBguimenu | DBguimenuitem | DBguisubmenu | DBhardware | DBinterface | DBkeycap | DBkeycode | DBkeycombo | DBkeysym | DBliteral | DBconstant | DBmarkup | DBmedialabel | DBmenuchoice | DBmousebutton | DBoption | DBoptional | DBparameter | DBprompt | DBproperty | DBreplaceable | DBreturnvalue | DBsgmltag | DBstructfield | DBstructname | DBsymbol | DBsystemitem | DBtoken | DBtype | DBuserinput | DBvarname )*
          ];;
type DBrefnamediv =
       [
          (DBrefdescriptor? DBrefname+ DBrefpurpose DBrefclass*
           (DBremark | DBlink | DBolink | DBulink)*)
          ];;
type DBrefmiscinfo =
       [
          ( Char | DBlink | DBolink | DBulink | DBemphasis | DBtrademark | DBreplaceable | DBremark | DBsubscript | DBsuperscript | DBinlinegraphic | DBinlinemediaobject | DBindexterm )*
          ];;
type DBrefmeta =
       [
          (DBindexterm* DBrefentrytitle DBmanvolnum? DBrefmiscinfo*
           DBindexterm*)
          ];;
type DBrefentry =
       [
          (DBbeginpage? DBindexterm* DBrefentryinfo? DBrefmeta?
           (DBremark | DBlink | DBolink | DBulink)* DBrefnamediv
           DBrefsynopsisdiv? (DBrefsect1+ | DBrefsection+))
          ];;
type DBseealsoie =
       [
          ( Char | DBfootnoteref | DBxref | DBabbrev | DBacronym | DBcitation | DBciterefentry | DBcitetitle | DBemphasis | DBfirstterm | DBforeignphrase | DBglossterm | DBfootnote | DBphrase | DBquote | DBtrademark | DBwordasword | DBpersonname | DBlink | DBolink | DBulink | DBaction | DBapplication | DBclassname | DBmethodname | DBinterfacename | DBexceptionname | DBooclass | DBoointerface | DBooexception | DBcommand | DBcomputeroutput | DBdatabase | DBemail | DBenvar | DBerrorcode | DBerrorname | DBerrortype | DBerrortext | DBfilename | DBfunction | DBguibutton | DBguiicon | DBguilabel | DBguimenu | DBguimenuitem | DBguisubmenu | DBhardware | DBinterface | DBkeycap | DBkeycode | DBkeycombo | DBkeysym | DBliteral | DBconstant | DBmarkup | DBmedialabel | DBmenuchoice | DBmousebutton | DBoption | DBoptional | DBparameter | DBprompt | DBproperty | DBreplaceable | DBreturnvalue | DBsgmltag | DBstructfield | DBstructname | DBsymbol | DBsystemitem | DBtoken | DBtype | DBuserinput | DBvarname | DBanchor | DBauthor | DBauthorinitials | DBcorpauthor | DBmodespec | DBothercredit | DBproductname | DBproductnumber | DBrevhistory | DBremark | DBsubscript | DBsuperscript | DBinlinegraphic | DBinlinemediaobject )*
          ];;
type DBseeie =
       [
          ( Char | DBfootnoteref | DBxref | DBabbrev | DBacronym | DBcitation | DBciterefentry | DBcitetitle | DBemphasis | DBfirstterm | DBforeignphrase | DBglossterm | DBfootnote | DBphrase | DBquote | DBtrademark | DBwordasword | DBpersonname | DBlink | DBolink | DBulink | DBaction | DBapplication | DBclassname | DBmethodname | DBinterfacename | DBexceptionname | DBooclass | DBoointerface | DBooexception | DBcommand | DBcomputeroutput | DBdatabase | DBemail | DBenvar | DBerrorcode | DBerrorname | DBerrortype | DBerrortext | DBfilename | DBfunction | DBguibutton | DBguiicon | DBguilabel | DBguimenu | DBguimenuitem | DBguisubmenu | DBhardware | DBinterface | DBkeycap | DBkeycode | DBkeycombo | DBkeysym | DBliteral | DBconstant | DBmarkup | DBmedialabel | DBmenuchoice | DBmousebutton | DBoption | DBoptional | DBparameter | DBprompt | DBproperty | DBreplaceable | DBreturnvalue | DBsgmltag | DBstructfield | DBstructname | DBsymbol | DBsystemitem | DBtoken | DBtype | DBuserinput | DBvarname | DBanchor | DBauthor | DBauthorinitials | DBcorpauthor | DBmodespec | DBothercredit | DBproductname | DBproductnumber | DBrevhistory | DBremark | DBsubscript | DBsuperscript | DBinlinegraphic | DBinlinemediaobject )*
          ];;
type DBtertiaryie =
       [
          ( Char | DBfootnoteref | DBxref | DBabbrev | DBacronym | DBcitation | DBciterefentry | DBcitetitle | DBemphasis | DBfirstterm | DBforeignphrase | DBglossterm | DBfootnote | DBphrase | DBquote | DBtrademark | DBwordasword | DBpersonname | DBlink | DBolink | DBulink | DBaction | DBapplication | DBclassname | DBmethodname | DBinterfacename | DBexceptionname | DBooclass | DBoointerface | DBooexception | DBcommand | DBcomputeroutput | DBdatabase | DBemail | DBenvar | DBerrorcode | DBerrorname | DBerrortype | DBerrortext | DBfilename | DBfunction | DBguibutton | DBguiicon | DBguilabel | DBguimenu | DBguimenuitem | DBguisubmenu | DBhardware | DBinterface | DBkeycap | DBkeycode | DBkeycombo | DBkeysym | DBliteral | DBconstant | DBmarkup | DBmedialabel | DBmenuchoice | DBmousebutton | DBoption | DBoptional | DBparameter | DBprompt | DBproperty | DBreplaceable | DBreturnvalue | DBsgmltag | DBstructfield | DBstructname | DBsymbol | DBsystemitem | DBtoken | DBtype | DBuserinput | DBvarname | DBanchor | DBauthor | DBauthorinitials | DBcorpauthor | DBmodespec | DBothercredit | DBproductname | DBproductnumber | DBrevhistory | DBremark | DBsubscript | DBsuperscript | DBinlinegraphic | DBinlinemediaobject )*
          ];;
type DBsecondaryie =
       [
          ( Char | DBfootnoteref | DBxref | DBabbrev | DBacronym | DBcitation | DBciterefentry | DBcitetitle | DBemphasis | DBfirstterm | DBforeignphrase | DBglossterm | DBfootnote | DBphrase | DBquote | DBtrademark | DBwordasword | DBpersonname | DBlink | DBolink | DBulink | DBaction | DBapplication | DBclassname | DBmethodname | DBinterfacename | DBexceptionname | DBooclass | DBoointerface | DBooexception | DBcommand | DBcomputeroutput | DBdatabase | DBemail | DBenvar | DBerrorcode | DBerrorname | DBerrortype | DBerrortext | DBfilename | DBfunction | DBguibutton | DBguiicon | DBguilabel | DBguimenu | DBguimenuitem | DBguisubmenu | DBhardware | DBinterface | DBkeycap | DBkeycode | DBkeycombo | DBkeysym | DBliteral | DBconstant | DBmarkup | DBmedialabel | DBmenuchoice | DBmousebutton | DBoption | DBoptional | DBparameter | DBprompt | DBproperty | DBreplaceable | DBreturnvalue | DBsgmltag | DBstructfield | DBstructname | DBsymbol | DBsystemitem | DBtoken | DBtype | DBuserinput | DBvarname | DBanchor | DBauthor | DBauthorinitials | DBcorpauthor | DBmodespec | DBothercredit | DBproductname | DBproductnumber | DBrevhistory | DBremark | DBsubscript | DBsuperscript | DBinlinegraphic | DBinlinemediaobject )*
          ];;
type DBprimaryie =
       [
          ( Char | DBfootnoteref | DBxref | DBabbrev | DBacronym | DBcitation | DBciterefentry | DBcitetitle | DBemphasis | DBfirstterm | DBforeignphrase | DBglossterm | DBfootnote | DBphrase | DBquote | DBtrademark | DBwordasword | DBpersonname | DBlink | DBolink | DBulink | DBaction | DBapplication | DBclassname | DBmethodname | DBinterfacename | DBexceptionname | DBooclass | DBoointerface | DBooexception | DBcommand | DBcomputeroutput | DBdatabase | DBemail | DBenvar | DBerrorcode | DBerrorname | DBerrortype | DBerrortext | DBfilename | DBfunction | DBguibutton | DBguiicon | DBguilabel | DBguimenu | DBguimenuitem | DBguisubmenu | DBhardware | DBinterface | DBkeycap | DBkeycode | DBkeycombo | DBkeysym | DBliteral | DBconstant | DBmarkup | DBmedialabel | DBmenuchoice | DBmousebutton | DBoption | DBoptional | DBparameter | DBprompt | DBproperty | DBreplaceable | DBreturnvalue | DBsgmltag | DBstructfield | DBstructname | DBsymbol | DBsystemitem | DBtoken | DBtype | DBuserinput | DBvarname | DBanchor | DBauthor | DBauthorinitials | DBcorpauthor | DBmodespec | DBothercredit | DBproductname | DBproductnumber | DBrevhistory | DBremark | DBsubscript | DBsuperscript | DBinlinegraphic | DBinlinemediaobject )*
          ];;
type DBindexentry =
       [
          (DBprimaryie (DBseeie | DBseealsoie)*
           (DBsecondaryie (DBseeie | DBseealsoie | DBtertiaryie)*)*)
          ];;
type DBindexdiv =
       [
          ((DBtitle DBsubtitle? DBtitleabbrev?)?
           ((DBitemizedlist | DBorderedlist | DBvariablelist | DBsimplelist
             | DBliterallayout | DBprogramlisting | DBprogramlistingco
             | DBscreen | DBscreenco | DBscreenshot | DBsynopsis
             | DBcmdsynopsis | DBfuncsynopsis | DBclasssynopsis
             | DBfieldsynopsis | DBconstructorsynopsis | DBdestructorsynopsis
             | DBmethodsynopsis | DBformalpara | DBpara | DBsimpara
             | DBaddress | DBblockquote | DBgraphic | DBgraphicco
             | DBmediaobject | DBmediaobjectco | DBinformalequation
             | DBinformalexample | DBinformalfigure | DBinformaltable
             | DBanchor | DBremark | DBlink | DBolink | DBulink | DBbeginpage)*
            (DBindexentry+ | DBsegmentedlist)))
          ];;
type DBsetindex =
       [
          (DBsetindexinfo? (DBtitle DBsubtitle? DBtitleabbrev?)?
           (DBcalloutlist | DBglosslist | DBitemizedlist | DBorderedlist
            | DBsegmentedlist | DBsimplelist | DBvariablelist | DBcaution
            | DBimportant | DBnote | DBtip | DBwarning | DBliterallayout
            | DBprogramlisting | DBprogramlistingco | DBscreen | DBscreenco
            | DBscreenshot | DBsynopsis | DBcmdsynopsis | DBfuncsynopsis
            | DBclasssynopsis | DBfieldsynopsis | DBconstructorsynopsis
            | DBdestructorsynopsis | DBmethodsynopsis | DBformalpara | DBpara
            | DBsimpara | DBaddress | DBblockquote | DBgraphic | DBgraphicco
            | DBmediaobject | DBmediaobjectco | DBinformalequation
            | DBinformalexample | DBinformalfigure | DBinformaltable
            | DBequation | DBexample | DBfigure | DBtable | DBmsgset
            | DBprocedure | DBsidebar | DBqandaset | DBanchor | DBbridgehead
            | DBremark | DBhighlights | DBabstract | DBauthorblurb
            | DBepigraph | DBindexterm | DBbeginpage)*
           (DBindexdiv* | DBindexentry*))
          ];;
type DBindex =
       [
          (DBindexinfo? (DBtitle DBsubtitle? DBtitleabbrev?)?
           (DBcalloutlist | DBglosslist | DBitemizedlist | DBorderedlist
            | DBsegmentedlist | DBsimplelist | DBvariablelist | DBcaution
            | DBimportant | DBnote | DBtip | DBwarning | DBliterallayout
            | DBprogramlisting | DBprogramlistingco | DBscreen | DBscreenco
            | DBscreenshot | DBsynopsis | DBcmdsynopsis | DBfuncsynopsis
            | DBclasssynopsis | DBfieldsynopsis | DBconstructorsynopsis
            | DBdestructorsynopsis | DBmethodsynopsis | DBformalpara | DBpara
            | DBsimpara | DBaddress | DBblockquote | DBgraphic | DBgraphicco
            | DBmediaobject | DBmediaobjectco | DBinformalequation
            | DBinformalexample | DBinformalfigure | DBinformaltable
            | DBequation | DBexample | DBfigure | DBtable | DBmsgset
            | DBprocedure | DBsidebar | DBqandaset | DBanchor | DBbridgehead
            | DBremark | DBhighlights | DBabstract | DBauthorblurb
            | DBepigraph | DBindexterm | DBbeginpage)*
           (DBindexdiv* | DBindexentry*))
          ];;
type DBglossdiv =
       [
          ((DBtitle DBsubtitle? DBtitleabbrev?)
           (DBcalloutlist | DBglosslist | DBitemizedlist | DBorderedlist
            | DBsegmentedlist | DBsimplelist | DBvariablelist | DBcaution
            | DBimportant | DBnote | DBtip | DBwarning | DBliterallayout
            | DBprogramlisting | DBprogramlistingco | DBscreen | DBscreenco
            | DBscreenshot | DBsynopsis | DBcmdsynopsis | DBfuncsynopsis
            | DBclasssynopsis | DBfieldsynopsis | DBconstructorsynopsis
            | DBdestructorsynopsis | DBmethodsynopsis | DBformalpara | DBpara
            | DBsimpara | DBaddress | DBblockquote | DBgraphic | DBgraphicco
            | DBmediaobject | DBmediaobjectco | DBinformalequation
            | DBinformalexample | DBinformalfigure | DBinformaltable
            | DBequation | DBexample | DBfigure | DBtable | DBmsgset
            | DBprocedure | DBsidebar | DBqandaset | DBanchor | DBbridgehead
            | DBremark | DBhighlights | DBabstract | DBauthorblurb
            | DBepigraph | DBindexterm | DBbeginpage)*
           DBglossentry+)
          ];;
type DBglossary =
       [
          (DBglossaryinfo? (DBtitle DBsubtitle? DBtitleabbrev?)?
           (DBcalloutlist | DBglosslist | DBitemizedlist | DBorderedlist
            | DBsegmentedlist | DBsimplelist | DBvariablelist | DBcaution
            | DBimportant | DBnote | DBtip | DBwarning | DBliterallayout
            | DBprogramlisting | DBprogramlistingco | DBscreen | DBscreenco
            | DBscreenshot | DBsynopsis | DBcmdsynopsis | DBfuncsynopsis
            | DBclasssynopsis | DBfieldsynopsis | DBconstructorsynopsis
            | DBdestructorsynopsis | DBmethodsynopsis | DBformalpara | DBpara
            | DBsimpara | DBaddress | DBblockquote | DBgraphic | DBgraphicco
            | DBmediaobject | DBmediaobjectco | DBinformalequation
            | DBinformalexample | DBinformalfigure | DBinformaltable
            | DBequation | DBexample | DBfigure | DBtable | DBmsgset
            | DBprocedure | DBsidebar | DBqandaset | DBanchor | DBbridgehead
            | DBremark | DBhighlights | DBabstract | DBauthorblurb
            | DBepigraph | DBindexterm | DBbeginpage)*
           (DBglossdiv+ | DBglossentry+) DBbibliography?)
          ];;
type DBbibliodiv =
       [
          ((DBtitle DBsubtitle? DBtitleabbrev?)?
           (DBcalloutlist | DBglosslist | DBitemizedlist | DBorderedlist
            | DBsegmentedlist | DBsimplelist | DBvariablelist | DBcaution
            | DBimportant | DBnote | DBtip | DBwarning | DBliterallayout
            | DBprogramlisting | DBprogramlistingco | DBscreen | DBscreenco
            | DBscreenshot | DBsynopsis | DBcmdsynopsis | DBfuncsynopsis
            | DBclasssynopsis | DBfieldsynopsis | DBconstructorsynopsis
            | DBdestructorsynopsis | DBmethodsynopsis | DBformalpara | DBpara
            | DBsimpara | DBaddress | DBblockquote | DBgraphic | DBgraphicco
            | DBmediaobject | DBmediaobjectco | DBinformalequation
            | DBinformalexample | DBinformalfigure | DBinformaltable
            | DBequation | DBexample | DBfigure | DBtable | DBmsgset
            | DBprocedure | DBsidebar | DBqandaset | DBanchor | DBbridgehead
            | DBremark | DBhighlights | DBabstract | DBauthorblurb
            | DBepigraph | DBindexterm | DBbeginpage)*
           (DBbiblioentry | DBbibliomixed)+)
          ];;
type DBbibliography =
       [
          (DBbibliographyinfo? (DBtitle DBsubtitle? DBtitleabbrev?)?
           (DBcalloutlist | DBglosslist | DBitemizedlist | DBorderedlist
            | DBsegmentedlist | DBsimplelist | DBvariablelist | DBcaution
            | DBimportant | DBnote | DBtip | DBwarning | DBliterallayout
            | DBprogramlisting | DBprogramlistingco | DBscreen | DBscreenco
            | DBscreenshot | DBsynopsis | DBcmdsynopsis | DBfuncsynopsis
            | DBclasssynopsis | DBfieldsynopsis | DBconstructorsynopsis
            | DBdestructorsynopsis | DBmethodsynopsis | DBformalpara | DBpara
            | DBsimpara | DBaddress | DBblockquote | DBgraphic | DBgraphicco
            | DBmediaobject | DBmediaobjectco | DBinformalequation
            | DBinformalexample | DBinformalfigure | DBinformaltable
            | DBequation | DBexample | DBfigure | DBtable | DBmsgset
            | DBprocedure | DBsidebar | DBqandaset | DBanchor | DBbridgehead
            | DBremark | DBhighlights | DBabstract | DBauthorblurb
            | DBepigraph | DBindexterm | DBbeginpage)*
           (DBbibliodiv+ | (DBbiblioentry | DBbibliomixed)+))
          ];;
type DBsimplesect =
       [
          ((DBtitle DBsubtitle? DBtitleabbrev?)
           (DBcalloutlist | DBglosslist | DBitemizedlist | DBorderedlist
            | DBsegmentedlist | DBsimplelist | DBvariablelist | DBcaution
            | DBimportant | DBnote | DBtip | DBwarning | DBliterallayout
            | DBprogramlisting | DBprogramlistingco | DBscreen | DBscreenco
            | DBscreenshot | DBsynopsis | DBcmdsynopsis | DBfuncsynopsis
            | DBclasssynopsis | DBfieldsynopsis | DBconstructorsynopsis
            | DBdestructorsynopsis | DBmethodsynopsis | DBformalpara | DBpara
            | DBsimpara | DBaddress | DBblockquote | DBgraphic | DBgraphicco
            | DBmediaobject | DBmediaobjectco | DBinformalequation
            | DBinformalexample | DBinformalfigure | DBinformaltable
            | DBequation | DBexample | DBfigure | DBtable | DBmsgset
            | DBprocedure | DBsidebar | DBqandaset | DBanchor | DBbridgehead
            | DBremark | DBhighlights | DBabstract | DBauthorblurb
            | DBepigraph | DBindexterm | DBbeginpage)+)
          ];;
type DBsect5 =
       [
          (DBsect5info? (DBtitle DBsubtitle? DBtitleabbrev?)
           (DBtoc | DBlot | DBindex | DBglossary | DBbibliography)*
           (((DBcalloutlist | DBglosslist | DBitemizedlist | DBorderedlist
              | DBsegmentedlist | DBsimplelist | DBvariablelist | DBcaution
              | DBimportant | DBnote | DBtip | DBwarning | DBliterallayout
              | DBprogramlisting | DBprogramlistingco | DBscreen | DBscreenco
              | DBscreenshot | DBsynopsis | DBcmdsynopsis | DBfuncsynopsis
              | DBclasssynopsis | DBfieldsynopsis | DBconstructorsynopsis
              | DBdestructorsynopsis | DBmethodsynopsis | DBformalpara
              | DBpara | DBsimpara | DBaddress | DBblockquote | DBgraphic
              | DBgraphicco | DBmediaobject | DBmediaobjectco
              | DBinformalequation | DBinformalexample | DBinformalfigure
              | DBinformaltable | DBequation | DBexample | DBfigure | DBtable
              | DBmsgset | DBprocedure | DBsidebar | DBqandaset | DBanchor
              | DBbridgehead | DBremark | DBhighlights | DBabstract
              | DBauthorblurb | DBepigraph | DBindexterm | DBbeginpage)+
             (DBrefentry* | DBsimplesect*))
            | DBrefentry+ | DBsimplesect+)
           (DBtoc | DBlot | DBindex | DBglossary | DBbibliography)*)
          ];;
type DBsect4 =
       [
          (DBsect4info? (DBtitle DBsubtitle? DBtitleabbrev?)
           (DBtoc | DBlot | DBindex | DBglossary | DBbibliography)*
           (((DBcalloutlist | DBglosslist | DBitemizedlist | DBorderedlist
              | DBsegmentedlist | DBsimplelist | DBvariablelist | DBcaution
              | DBimportant | DBnote | DBtip | DBwarning | DBliterallayout
              | DBprogramlisting | DBprogramlistingco | DBscreen | DBscreenco
              | DBscreenshot | DBsynopsis | DBcmdsynopsis | DBfuncsynopsis
              | DBclasssynopsis | DBfieldsynopsis | DBconstructorsynopsis
              | DBdestructorsynopsis | DBmethodsynopsis | DBformalpara
              | DBpara | DBsimpara | DBaddress | DBblockquote | DBgraphic
              | DBgraphicco | DBmediaobject | DBmediaobjectco
              | DBinformalequation | DBinformalexample | DBinformalfigure
              | DBinformaltable | DBequation | DBexample | DBfigure | DBtable
              | DBmsgset | DBprocedure | DBsidebar | DBqandaset | DBanchor
              | DBbridgehead | DBremark | DBhighlights | DBabstract
              | DBauthorblurb | DBepigraph | DBindexterm | DBbeginpage)+
             (DBrefentry* | DBsect5* | DBsimplesect*))
            | DBrefentry+ | DBsect5+ | DBsimplesect+)
           (DBtoc | DBlot | DBindex | DBglossary | DBbibliography)*)
          ];;
type DBsect3 =
       [
          (DBsect3info? (DBtitle DBsubtitle? DBtitleabbrev?)
           (DBtoc | DBlot | DBindex | DBglossary | DBbibliography)*
           (((DBcalloutlist | DBglosslist | DBitemizedlist | DBorderedlist
              | DBsegmentedlist | DBsimplelist | DBvariablelist | DBcaution
              | DBimportant | DBnote | DBtip | DBwarning | DBliterallayout
              | DBprogramlisting | DBprogramlistingco | DBscreen | DBscreenco
              | DBscreenshot | DBsynopsis | DBcmdsynopsis | DBfuncsynopsis
              | DBclasssynopsis | DBfieldsynopsis | DBconstructorsynopsis
              | DBdestructorsynopsis | DBmethodsynopsis | DBformalpara
              | DBpara | DBsimpara | DBaddress | DBblockquote | DBgraphic
              | DBgraphicco | DBmediaobject | DBmediaobjectco
              | DBinformalequation | DBinformalexample | DBinformalfigure
              | DBinformaltable | DBequation | DBexample | DBfigure | DBtable
              | DBmsgset | DBprocedure | DBsidebar | DBqandaset | DBanchor
              | DBbridgehead | DBremark | DBhighlights | DBabstract
              | DBauthorblurb | DBepigraph | DBindexterm | DBbeginpage)+
             (DBrefentry* | DBsect4* | DBsimplesect*))
            | DBrefentry+ | DBsect4+ | DBsimplesect+)
           (DBtoc | DBlot | DBindex | DBglossary | DBbibliography)*)
          ];;
type DBsect2 =
       [
          (DBsect2info? (DBtitle DBsubtitle? DBtitleabbrev?)
           (DBtoc | DBlot | DBindex | DBglossary | DBbibliography)*
           (((DBcalloutlist | DBglosslist | DBitemizedlist | DBorderedlist
              | DBsegmentedlist | DBsimplelist | DBvariablelist | DBcaution
              | DBimportant | DBnote | DBtip | DBwarning | DBliterallayout
              | DBprogramlisting | DBprogramlistingco | DBscreen | DBscreenco
              | DBscreenshot | DBsynopsis | DBcmdsynopsis | DBfuncsynopsis
              | DBclasssynopsis | DBfieldsynopsis | DBconstructorsynopsis
              | DBdestructorsynopsis | DBmethodsynopsis | DBformalpara
              | DBpara | DBsimpara | DBaddress | DBblockquote | DBgraphic
              | DBgraphicco | DBmediaobject | DBmediaobjectco
              | DBinformalequation | DBinformalexample | DBinformalfigure
              | DBinformaltable | DBequation | DBexample | DBfigure | DBtable
              | DBmsgset | DBprocedure | DBsidebar | DBqandaset | DBanchor
              | DBbridgehead | DBremark | DBhighlights | DBabstract
              | DBauthorblurb | DBepigraph | DBindexterm | DBbeginpage)+
             (DBrefentry* | DBsect3* | DBsimplesect*))
            | DBrefentry+ | DBsect3+ | DBsimplesect+)
           (DBtoc | DBlot | DBindex | DBglossary | DBbibliography)*)
          ];;
type DBsect1 =
       [
          (DBsect1info? (DBtitle DBsubtitle? DBtitleabbrev?)
           (DBtoc | DBlot | DBindex | DBglossary | DBbibliography)*
           (((DBcalloutlist | DBglosslist | DBitemizedlist | DBorderedlist
              | DBsegmentedlist | DBsimplelist | DBvariablelist | DBcaution
              | DBimportant | DBnote | DBtip | DBwarning | DBliterallayout
              | DBprogramlisting | DBprogramlistingco | DBscreen | DBscreenco
              | DBscreenshot | DBsynopsis | DBcmdsynopsis | DBfuncsynopsis
              | DBclasssynopsis | DBfieldsynopsis | DBconstructorsynopsis
              | DBdestructorsynopsis | DBmethodsynopsis | DBformalpara
              | DBpara | DBsimpara | DBaddress | DBblockquote | DBgraphic
              | DBgraphicco | DBmediaobject | DBmediaobjectco
              | DBinformalequation | DBinformalexample | DBinformalfigure
              | DBinformaltable | DBequation | DBexample | DBfigure | DBtable
              | DBmsgset | DBprocedure | DBsidebar | DBqandaset | DBanchor
              | DBbridgehead | DBremark | DBhighlights | DBabstract
              | DBauthorblurb | DBepigraph | DBindexterm | DBbeginpage)+
             (DBrefentry* | DBsect2* | DBsimplesect*))
            | DBrefentry+ | DBsect2+ | DBsimplesect+)
           (DBtoc | DBlot | DBindex | DBglossary | DBbibliography)*)
          ];;
type DBsectioninfo =
       [
          (DBgraphic | DBmediaobject | DBlegalnotice | DBmodespec
           | DBsubjectset | DBkeywordset | DBitermset | DBabbrev | DBabstract
           | DBaddress | DBartpagenums | DBauthor | DBauthorgroup
           | DBauthorinitials | DBbibliomisc | DBbiblioset | DBcollab
           | DBconfgroup | DBcontractnum | DBcontractsponsor | DBcopyright
           | DBcorpauthor | DBcorpname | DBdate | DBedition | DBeditor
           | DBinvpartnumber | DBisbn | DBissn | DBissuenum | DBorgname
           | DBbiblioid | DBcitebiblioid | DBbibliosource | DBbibliorelation
           | DBbibliocoverage | DBothercredit | DBpagenums | DBprinthistory
           | DBproductname | DBproductnumber | DBpubdate | DBpublisher
           | DBpublishername | DBpubsnumber | DBreleaseinfo | DBrevhistory
           | DBseriesvolnums | DBsubtitle | DBtitle | DBtitleabbrev
           | DBvolumenum | DBcitetitle | DBpersonname | DBhonorific
           | DBfirstname | DBsurname | DBlineage | DBothername
           | DBaffiliation | DBauthorblurb | DBcontrib | DBindexterm)+
          ];;
type DBsection =
       
[
          (DBsectioninfo? (DBtitle DBsubtitle? DBtitleabbrev?)
           (DBtoc | DBlot | DBindex | DBglossary | DBbibliography)*
           (((DBcalloutlist | DBglosslist | DBitemizedlist | DBorderedlist
              | DBsegmentedlist | DBsimplelist | DBvariablelist | DBcaution
              | DBimportant | DBnote | DBtip | DBwarning | DBliterallayout
              | DBprogramlisting | DBprogramlistingco | DBscreen | DBscreenco
              | DBscreenshot | DBsynopsis | DBcmdsynopsis | DBfuncsynopsis
              | DBclasssynopsis | DBfieldsynopsis | DBconstructorsynopsis
              | DBdestructorsynopsis | DBmethodsynopsis | DBformalpara
              | DBpara | DBsimpara | DBaddress | DBblockquote | DBgraphic
              | DBgraphicco | DBmediaobject | DBmediaobjectco
              | DBinformalequation | DBinformalexample | DBinformalfigure
              | DBinformaltable | DBequation | DBexample | DBfigure | DBtable
              | DBmsgset | DBprocedure | DBsidebar | DBqandaset | DBanchor
              | DBbridgehead | DBremark | DBhighlights | DBabstract
              | DBauthorblurb | DBepigraph | DBindexterm | DBbeginpage)+
             (DBrefentry* | DBsection* | DBsimplesect*))
            | DBrefentry+ | DBsection+ | DBsimplesect+)
           (DBtoc | DBlot | DBindex | DBglossary | DBbibliography)*)
          ];;
type DBsect5info =
       [
          (DBgraphic | DBmediaobject | DBlegalnotice | DBmodespec
           | DBsubjectset | DBkeywordset | DBitermset | DBabbrev | DBabstract
           | DBaddress | DBartpagenums | DBauthor | DBauthorgroup
           | DBauthorinitials | DBbibliomisc | DBbiblioset | DBcollab
           | DBconfgroup | DBcontractnum | DBcontractsponsor | DBcopyright
           | DBcorpauthor | DBcorpname | DBdate | DBedition | DBeditor
           | DBinvpartnumber | DBisbn | DBissn | DBissuenum | DBorgname
           | DBbiblioid | DBcitebiblioid | DBbibliosource | DBbibliorelation
           | DBbibliocoverage | DBothercredit | DBpagenums | DBprinthistory
           | DBproductname | DBproductnumber | DBpubdate | DBpublisher
           | DBpublishername | DBpubsnumber | DBreleaseinfo | DBrevhistory
           | DBseriesvolnums | DBsubtitle | DBtitle | DBtitleabbrev
           | DBvolumenum | DBcitetitle | DBpersonname | DBhonorific
           | DBfirstname | DBsurname | DBlineage | DBothername
           | DBaffiliation | DBauthorblurb | DBcontrib | DBindexterm)+
          ];;
type DBsect4info =
       [
          (DBgraphic | DBmediaobject | DBlegalnotice | DBmodespec
           | DBsubjectset | DBkeywordset | DBitermset | DBabbrev | DBabstract
           | DBaddress | DBartpagenums | DBauthor | DBauthorgroup
           | DBauthorinitials | DBbibliomisc | DBbiblioset | DBcollab
           | DBconfgroup | DBcontractnum | DBcontractsponsor | DBcopyright
           | DBcorpauthor | DBcorpname | DBdate | DBedition | DBeditor
           | DBinvpartnumber | DBisbn | DBissn | DBissuenum | DBorgname
           | DBbiblioid | DBcitebiblioid | DBbibliosource | DBbibliorelation
           | DBbibliocoverage | DBothercredit | DBpagenums | DBprinthistory
           | DBproductname | DBproductnumber | DBpubdate | DBpublisher
           | DBpublishername | DBpubsnumber | DBreleaseinfo | DBrevhistory
           | DBseriesvolnums | DBsubtitle | DBtitle | DBtitleabbrev
           | DBvolumenum | DBcitetitle | DBpersonname | DBhonorific
           | DBfirstname | DBsurname | DBlineage | DBothername
           | DBaffiliation | DBauthorblurb | DBcontrib | DBindexterm)+
          ];;
type DBsect3info =
       [
          (DBgraphic | DBmediaobject | DBlegalnotice | DBmodespec
           | DBsubjectset | DBkeywordset | DBitermset | DBabbrev | DBabstract
           | DBaddress | DBartpagenums | DBauthor | DBauthorgroup
           | DBauthorinitials | DBbibliomisc | DBbiblioset | DBcollab
           | DBconfgroup | DBcontractnum | DBcontractsponsor | DBcopyright
           | DBcorpauthor | DBcorpname | DBdate | DBedition | DBeditor
           | DBinvpartnumber | DBisbn | DBissn | DBissuenum | DBorgname
           | DBbiblioid | DBcitebiblioid | DBbibliosource | DBbibliorelation
           | DBbibliocoverage | DBothercredit | DBpagenums | DBprinthistory
           | DBproductname | DBproductnumber | DBpubdate | DBpublisher
           | DBpublishername | DBpubsnumber | DBreleaseinfo | DBrevhistory
           | DBseriesvolnums | DBsubtitle | DBtitle | DBtitleabbrev
           | DBvolumenum | DBcitetitle | DBpersonname | DBhonorific
           | DBfirstname | DBsurname | DBlineage | DBothername
           | DBaffiliation | DBauthorblurb | DBcontrib | DBindexterm)+
          ];;
type DBsect2info =
       [
          (DBgraphic | DBmediaobject | DBlegalnotice | DBmodespec
           | DBsubjectset | DBkeywordset | DBitermset | DBabbrev | DBabstract
           | DBaddress | DBartpagenums | DBauthor | DBauthorgroup
           | DBauthorinitials | DBbibliomisc | DBbiblioset | DBcollab
           | DBconfgroup | DBcontractnum | DBcontractsponsor | DBcopyright
           | DBcorpauthor | DBcorpname | DBdate | DBedition | DBeditor
           | DBinvpartnumber | DBisbn | DBissn | DBissuenum | DBorgname
           | DBbiblioid | DBcitebiblioid | DBbibliosource | DBbibliorelation
           | DBbibliocoverage | DBothercredit | DBpagenums | DBprinthistory
           | DBproductname | DBproductnumber | DBpubdate | DBpublisher
           | DBpublishername | DBpubsnumber | DBreleaseinfo | DBrevhistory
           | DBseriesvolnums | DBsubtitle | DBtitle | DBtitleabbrev
           | DBvolumenum | DBcitetitle | DBpersonname | DBhonorific
           | DBfirstname | DBsurname | DBlineage | DBothername
           | DBaffiliation | DBauthorblurb | DBcontrib | DBindexterm)+
          ];;
type DBsect1info =
       [
          (DBgraphic | DBmediaobject | DBlegalnotice | DBmodespec
           | DBsubjectset | DBkeywordset | DBitermset | DBabbrev | DBabstract
           | DBaddress | DBartpagenums | DBauthor | DBauthorgroup
           | DBauthorinitials | DBbibliomisc | DBbiblioset | DBcollab
           | DBconfgroup | DBcontractnum | DBcontractsponsor | DBcopyright
           | DBcorpauthor | DBcorpname | DBdate | DBedition | DBeditor
           | DBinvpartnumber | DBisbn | DBissn | DBissuenum | DBorgname
           | DBbiblioid | DBcitebiblioid | DBbibliosource | DBbibliorelation
           | DBbibliocoverage | DBothercredit | DBpagenums | DBprinthistory
           | DBproductname | DBproductnumber | DBpubdate | DBpublisher
           | DBpublishername | DBpubsnumber | DBreleaseinfo | DBrevhistory
           | DBseriesvolnums | DBsubtitle | DBtitle | DBtitleabbrev
           | DBvolumenum | DBcitetitle | DBpersonname | DBhonorific
           | DBfirstname | DBsurname | DBlineage | DBothername
           | DBaffiliation | DBauthorblurb | DBcontrib | DBindexterm)+
          ];;
type DBreferenceinfo =
       [
          (DBgraphic | DBmediaobject | DBlegalnotice | DBmodespec
           | DBsubjectset | DBkeywordset | DBitermset | DBabbrev | DBabstract
           | DBaddress | DBartpagenums | DBauthor | DBauthorgroup
           | DBauthorinitials | DBbibliomisc | DBbiblioset | DBcollab
           | DBconfgroup | DBcontractnum | DBcontractsponsor | DBcopyright
           | DBcorpauthor | DBcorpname | DBdate | DBedition | DBeditor
           | DBinvpartnumber | DBisbn | DBissn | DBissuenum | DBorgname
           | DBbiblioid | DBcitebiblioid | DBbibliosource | DBbibliorelation
           | DBbibliocoverage | DBothercredit | DBpagenums | DBprinthistory
           | DBproductname | DBproductnumber | DBpubdate | DBpublisher
           | DBpublishername | DBpubsnumber | DBreleaseinfo | DBrevhistory
           | DBseriesvolnums | DBsubtitle | DBtitle | DBtitleabbrev
           | DBvolumenum | DBcitetitle | DBpersonname | DBhonorific
           | DBfirstname | DBsurname | DBlineage | DBothername
           | DBaffiliation | DBauthorblurb | DBcontrib | DBindexterm)+
          ];;
type DBrefsynopsisdivinfo =
       [
          (DBgraphic | DBmediaobject | DBlegalnotice | DBmodespec
           | DBsubjectset | DBkeywordset | DBitermset | DBabbrev | DBabstract
           | DBaddress | DBartpagenums | DBauthor | DBauthorgroup
           | DBauthorinitials | DBbibliomisc | DBbiblioset | DBcollab
           | DBconfgroup | DBcontractnum | DBcontractsponsor | DBcopyright
           | DBcorpauthor | DBcorpname | DBdate | DBedition | DBeditor
           | DBinvpartnumber | DBisbn | DBissn | DBissuenum | DBorgname
           | DBbiblioid | DBcitebiblioid | DBbibliosource | DBbibliorelation
           | DBbibliocoverage | DBothercredit | DBpagenums | DBprinthistory
           | DBproductname | DBproductnumber | DBpubdate | DBpublisher
           | DBpublishername | DBpubsnumber | DBreleaseinfo | DBrevhistory
           | DBseriesvolnums | DBsubtitle | DBtitle | DBtitleabbrev
           | DBvolumenum | DBcitetitle | DBpersonname | DBhonorific
           | DBfirstname | DBsurname | DBlineage | DBothername
           | DBaffiliation | DBauthorblurb | DBcontrib | DBindexterm)+
          ];;
type DBrefsect3info =
       [
          (DBgraphic | DBmediaobject | DBlegalnotice | DBmodespec
           | DBsubjectset | DBkeywordset | DBitermset | DBabbrev | DBabstract
           | DBaddress | DBartpagenums | DBauthor | DBauthorgroup
           | DBauthorinitials | DBbibliomisc | DBbiblioset | DBcollab
           | DBconfgroup | DBcontractnum | DBcontractsponsor | DBcopyright
           | DBcorpauthor | DBcorpname | DBdate | DBedition | DBeditor
           | DBinvpartnumber | DBisbn | DBissn | DBissuenum | DBorgname
           | DBbiblioid | DBcitebiblioid | DBbibliosource | DBbibliorelation
           | DBbibliocoverage | DBothercredit | DBpagenums | DBprinthistory
           | DBproductname | DBproductnumber | DBpubdate | DBpublisher
           | DBpublishername | DBpubsnumber | DBreleaseinfo | DBrevhistory
           | DBseriesvolnums | DBsubtitle | DBtitle | DBtitleabbrev
           | DBvolumenum | DBcitetitle | DBpersonname | DBhonorific
           | DBfirstname | DBsurname | DBlineage | DBothername
           | DBaffiliation | DBauthorblurb | DBcontrib | DBindexterm)+
          ];;
type DBrefsect2info =
       [
          (DBgraphic | DBmediaobject | DBlegalnotice | DBmodespec
           | DBsubjectset | DBkeywordset | DBitermset | DBabbrev | DBabstract
           | DBaddress | DBartpagenums | DBauthor | DBauthorgroup
           | DBauthorinitials | DBbibliomisc | DBbiblioset | DBcollab
           | DBconfgroup | DBcontractnum | DBcontractsponsor | DBcopyright
           | DBcorpauthor | DBcorpname | DBdate | DBedition | DBeditor
           | DBinvpartnumber | DBisbn | DBissn | DBissuenum | DBorgname
           | DBbiblioid | DBcitebiblioid | DBbibliosource | DBbibliorelation
           | DBbibliocoverage | DBothercredit | DBpagenums | DBprinthistory
           | DBproductname | DBproductnumber | DBpubdate | DBpublisher
           | DBpublishername | DBpubsnumber | DBreleaseinfo | DBrevhistory
           | DBseriesvolnums | DBsubtitle | DBtitle | DBtitleabbrev
           | DBvolumenum | DBcitetitle | DBpersonname | DBhonorific
           | DBfirstname | DBsurname | DBlineage | DBothername
           | DBaffiliation | DBauthorblurb | DBcontrib | DBindexterm)+
          ];;
type DBrefsect1info =
       [
          (DBgraphic | DBmediaobject | DBlegalnotice | DBmodespec
           | DBsubjectset | DBkeywordset | DBitermset | DBabbrev | DBabstract
           | DBaddress | DBartpagenums | DBauthor | DBauthorgroup
           | DBauthorinitials | DBbibliomisc | DBbiblioset | DBcollab
           | DBconfgroup | DBcontractnum | DBcontractsponsor | DBcopyright
           | DBcorpauthor | DBcorpname | DBdate | DBedition | DBeditor
           | DBinvpartnumber | DBisbn | DBissn | DBissuenum | DBorgname
           | DBbiblioid | DBcitebiblioid | DBbibliosource | DBbibliorelation
           | DBbibliocoverage | DBothercredit | DBpagenums | DBprinthistory
           | DBproductname | DBproductnumber | DBpubdate | DBpublisher
           | DBpublishername | DBpubsnumber | DBreleaseinfo | DBrevhistory
           | DBseriesvolnums | DBsubtitle | DBtitle | DBtitleabbrev
           | DBvolumenum | DBcitetitle | DBpersonname | DBhonorific
           | DBfirstname | DBsurname | DBlineage | DBothername
           | DBaffiliation | DBauthorblurb | DBcontrib | DBindexterm)+
          ];;
type DBrefsectioninfo =
       [
          (DBgraphic | DBmediaobject | DBlegalnotice | DBmodespec
           | DBsubjectset | DBkeywordset | DBitermset | DBabbrev | DBabstract
           | DBaddress | DBartpagenums | DBauthor | DBauthorgroup
           | DBauthorinitials | DBbibliomisc | DBbiblioset | DBcollab
           | DBconfgroup | DBcontractnum | DBcontractsponsor | DBcopyright
           | DBcorpauthor | DBcorpname | DBdate | DBedition | DBeditor
           | DBinvpartnumber | DBisbn | DBissn | DBissuenum | DBorgname
           | DBbiblioid | DBcitebiblioid | DBbibliosource | DBbibliorelation
           | DBbibliocoverage | DBothercredit | DBpagenums | DBprinthistory
           | DBproductname | DBproductnumber | DBpubdate | DBpublisher
           | DBpublishername | DBpubsnumber | DBreleaseinfo | DBrevhistory
           | DBseriesvolnums | DBsubtitle | DBtitle | DBtitleabbrev
           | DBvolumenum | DBcitetitle | DBpersonname | DBhonorific
           | DBfirstname | DBsurname | DBlineage | DBothername
           | DBaffiliation | DBauthorblurb | DBcontrib | DBindexterm)+
          ];;
type DBrefentryinfo =
       [
          (DBgraphic | DBmediaobject | DBlegalnotice | DBmodespec
           | DBsubjectset | DBkeywordset | DBitermset | DBabbrev | DBabstract
           | DBaddress | DBartpagenums | DBauthor | DBauthorgroup
           | DBauthorinitials | DBbibliomisc | DBbiblioset | DBcollab
           | DBconfgroup | DBcontractnum | DBcontractsponsor | DBcopyright
           | DBcorpauthor | DBcorpname | DBdate | DBedition | DBeditor
           | DBinvpartnumber | DBisbn | DBissn | DBissuenum | DBorgname
           | DBbiblioid | DBcitebiblioid | DBbibliosource | DBbibliorelation
           | DBbibliocoverage | DBothercredit | DBpagenums | DBprinthistory
           | DBproductname | DBproductnumber | DBpubdate | DBpublisher
           | DBpublishername | DBpubsnumber | DBreleaseinfo | DBrevhistory
           | DBseriesvolnums | DBsubtitle | DBtitle | DBtitleabbrev
           | DBvolumenum | DBcitetitle | DBpersonname | DBhonorific
           | DBfirstname | DBsurname | DBlineage | DBothername
           | DBaffiliation | DBauthorblurb | DBcontrib | DBindexterm)+
          ];;
type DBprefaceinfo =
       [
          (DBgraphic | DBmediaobject | DBlegalnotice | DBmodespec
           | DBsubjectset | DBkeywordset | DBitermset | DBabbrev | DBabstract
           | DBaddress | DBartpagenums | DBauthor | DBauthorgroup
           | DBauthorinitials | DBbibliomisc | DBbiblioset | DBcollab
           | DBconfgroup | DBcontractnum | DBcontractsponsor | DBcopyright
           | DBcorpauthor | DBcorpname | DBdate | DBedition | DBeditor
           | DBinvpartnumber | DBisbn | DBissn | DBissuenum | DBorgname
           | DBbiblioid | DBcitebiblioid | DBbibliosource | DBbibliorelation
           | DBbibliocoverage | DBothercredit | DBpagenums | DBprinthistory
           | DBproductname | DBproductnumber | DBpubdate | DBpublisher
           | DBpublishername | DBpubsnumber | DBreleaseinfo | DBrevhistory
           | DBseriesvolnums | DBsubtitle | DBtitle | DBtitleabbrev
           | DBvolumenum | DBcitetitle | DBpersonname | DBhonorific
           | DBfirstname | DBsurname | DBlineage | DBothername
           | DBaffiliation | DBauthorblurb | DBcontrib | DBindexterm)+
          ];;
type DBpartinfo =
       [
          (DBgraphic | DBmediaobject | DBlegalnotice | DBmodespec
           | DBsubjectset | DBkeywordset | DBitermset | DBabbrev | DBabstract
           | DBaddress | DBartpagenums | DBauthor | DBauthorgroup
           | DBauthorinitials | DBbibliomisc | DBbiblioset | DBcollab
           | DBconfgroup | DBcontractnum | DBcontractsponsor | DBcopyright
           | DBcorpauthor | DBcorpname | DBdate | DBedition | DBeditor
           | DBinvpartnumber | DBisbn | DBissn | DBissuenum | DBorgname
           | DBbiblioid | DBcitebiblioid | DBbibliosource | DBbibliorelation
           | DBbibliocoverage | DBothercredit | DBpagenums | DBprinthistory
           | DBproductname | DBproductnumber | DBpubdate | DBpublisher
           | DBpublishername | DBpubsnumber | DBreleaseinfo | DBrevhistory
           | DBseriesvolnums | DBsubtitle | DBtitle | DBtitleabbrev
           | DBvolumenum | DBcitetitle | DBpersonname | DBhonorific
           | DBfirstname | DBsurname | DBlineage | DBothername
           | DBaffiliation | DBauthorblurb | DBcontrib | DBindexterm)+
          ];;
type DBsetindexinfo =
       [
          (DBgraphic | DBmediaobject | DBlegalnotice | DBmodespec
           | DBsubjectset | DBkeywordset | DBitermset | DBabbrev | DBabstract
           | DBaddress | DBartpagenums | DBauthor | DBauthorgroup
           | DBauthorinitials | DBbibliomisc | DBbiblioset | DBcollab
           | DBconfgroup | DBcontractnum | DBcontractsponsor | DBcopyright
           | DBcorpauthor | DBcorpname | DBdate | DBedition | DBeditor
           | DBinvpartnumber | DBisbn | DBissn | DBissuenum | DBorgname
           | DBbiblioid | DBcitebiblioid | DBbibliosource | DBbibliorelation
           | DBbibliocoverage | DBothercredit | DBpagenums | DBprinthistory
           | DBproductname | DBproductnumber | DBpubdate | DBpublisher
           | DBpublishername | DBpubsnumber | DBreleaseinfo | DBrevhistory
           | DBseriesvolnums | DBsubtitle | DBtitle | DBtitleabbrev
           | DBvolumenum | DBcitetitle | DBpersonname | DBhonorific
           | DBfirstname | DBsurname | DBlineage | DBothername
           | DBaffiliation | DBauthorblurb | DBcontrib | DBindexterm)+
          ];;
type DBindexinfo =
       [
          (DBgraphic | DBmediaobject | DBlegalnotice | DBmodespec
           | DBsubjectset | DBkeywordset | DBitermset | DBabbrev | DBabstract
           | DBaddress | DBartpagenums | DBauthor | DBauthorgroup
           | DBauthorinitials | DBbibliomisc | DBbiblioset | DBcollab
           | DBconfgroup | DBcontractnum | DBcontractsponsor | DBcopyright
           | DBcorpauthor | DBcorpname | DBdate | DBedition | DBeditor
           | DBinvpartnumber | DBisbn | DBissn | DBissuenum | DBorgname
           | DBbiblioid | DBcitebiblioid | DBbibliosource | DBbibliorelation
           | DBbibliocoverage | DBothercredit | DBpagenums | DBprinthistory
           | DBproductname | DBproductnumber | DBpubdate | DBpublisher
           | DBpublishername | DBpubsnumber | DBreleaseinfo | DBrevhistory
           | DBseriesvolnums | DBsubtitle | DBtitle | DBtitleabbrev
           | DBvolumenum | DBcitetitle | DBpersonname | DBhonorific
           | DBfirstname | DBsurname | DBlineage | DBothername
           | DBaffiliation | DBauthorblurb | DBcontrib | DBindexterm)+
          ];;
type DBglossaryinfo =
       [
          (DBgraphic | DBmediaobject | DBlegalnotice | DBmodespec
           | DBsubjectset | DBkeywordset | DBitermset | DBabbrev | DBabstract
           | DBaddress | DBartpagenums | DBauthor | DBauthorgroup
           | DBauthorinitials | DBbibliomisc | DBbiblioset | DBcollab
           | DBconfgroup | DBcontractnum | DBcontractsponsor | DBcopyright
           | DBcorpauthor | DBcorpname | DBdate | DBedition | DBeditor
           | DBinvpartnumber | DBisbn | DBissn | DBissuenum | DBorgname
           | DBbiblioid | DBcitebiblioid | DBbibliosource | DBbibliorelation
           | DBbibliocoverage | DBothercredit | DBpagenums | DBprinthistory
           | DBproductname | DBproductnumber | DBpubdate | DBpublisher
           | DBpublishername | DBpubsnumber | DBreleaseinfo | DBrevhistory
           | DBseriesvolnums | DBsubtitle | DBtitle | DBtitleabbrev
           | DBvolumenum | DBcitetitle | DBpersonname | DBhonorific
           | DBfirstname | DBsurname | DBlineage | DBothername
           | DBaffiliation | DBauthorblurb | DBcontrib | DBindexterm)+
          ];;
type DBchapterinfo =
       [
          (DBgraphic | DBmediaobject | DBlegalnotice | DBmodespec
           | DBsubjectset | DBkeywordset | DBitermset | DBabbrev | DBabstract
           | DBaddress | DBartpagenums | DBauthor | DBauthorgroup
           | DBauthorinitials | DBbibliomisc | DBbiblioset | DBcollab
           | DBconfgroup | DBcontractnum | DBcontractsponsor | DBcopyright
           | DBcorpauthor | DBcorpname | DBdate | DBedition | DBeditor
           | DBinvpartnumber | DBisbn | DBissn | DBissuenum | DBorgname
           | DBbiblioid | DBcitebiblioid | DBbibliosource | DBbibliorelation
           | DBbibliocoverage | DBothercredit | DBpagenums | DBprinthistory
           | DBproductname | DBproductnumber | DBpubdate | DBpublisher
           | DBpublishername | DBpubsnumber | DBreleaseinfo | DBrevhistory
           | DBseriesvolnums | DBsubtitle | DBtitle | DBtitleabbrev
           | DBvolumenum | DBcitetitle | DBpersonname | DBhonorific
           | DBfirstname | DBsurname | DBlineage | DBothername
           | DBaffiliation | DBauthorblurb | DBcontrib | DBindexterm)+
          ];;
type DBbibliographyinfo =
       [
          (DBgraphic | DBmediaobject | DBlegalnotice | DBmodespec
           | DBsubjectset | DBkeywordset | DBitermset | DBabbrev | DBabstract
           | DBaddress | DBartpagenums | DBauthor | DBauthorgroup
           | DBauthorinitials | DBbibliomisc | DBbiblioset | DBcollab
           | DBconfgroup | DBcontractnum | DBcontractsponsor | DBcopyright
           | DBcorpauthor | DBcorpname | DBdate | DBedition | DBeditor
           | DBinvpartnumber | DBisbn | DBissn | DBissuenum | DBorgname
           | DBbiblioid | DBcitebiblioid | DBbibliosource | DBbibliorelation
           | DBbibliocoverage | DBothercredit | DBpagenums | DBprinthistory
           | DBproductname | DBproductnumber | DBpubdate | DBpublisher
           | DBpublishername | DBpubsnumber | DBreleaseinfo | DBrevhistory
           | DBseriesvolnums | DBsubtitle | DBtitle | DBtitleabbrev
           | DBvolumenum | DBcitetitle | DBpersonname | DBhonorific
           | DBfirstname | DBsurname | DBlineage | DBothername
           | DBaffiliation | DBauthorblurb | DBcontrib | DBindexterm)+
          ];;
type DBappendixinfo =
       [
          (DBgraphic | DBmediaobject | DBlegalnotice | DBmodespec
           | DBsubjectset | DBkeywordset | DBitermset | DBabbrev | DBabstract
           | DBaddress | DBartpagenums | DBauthor | DBauthorgroup
           | DBauthorinitials | DBbibliomisc | DBbiblioset | DBcollab
           | DBconfgroup | DBcontractnum | DBcontractsponsor | DBcopyright
           | DBcorpauthor | DBcorpname | DBdate | DBedition | DBeditor
           | DBinvpartnumber | DBisbn | DBissn | DBissuenum | DBorgname
           | DBbiblioid | DBcitebiblioid | DBbibliosource | DBbibliorelation
           | DBbibliocoverage | DBothercredit | DBpagenums | DBprinthistory
           | DBproductname | DBproductnumber | DBpubdate | DBpublisher
           | DBpublishername | DBpubsnumber | DBreleaseinfo | DBrevhistory
           | DBseriesvolnums | DBsubtitle | DBtitle | DBtitleabbrev
           | DBvolumenum | DBcitetitle | DBpersonname | DBhonorific
           | DBfirstname | DBsurname | DBlineage | DBothername
           | DBaffiliation | DBauthorblurb | DBcontrib | DBindexterm)+
          ];;
type DBpartintro =
       [
          ((DBtitle DBsubtitle? DBtitleabbrev?)?
           (((DBcalloutlist | DBglosslist | DBitemizedlist | DBorderedlist
              | DBsegmentedlist | DBsimplelist | DBvariablelist | DBcaution
              | DBimportant | DBnote | DBtip | DBwarning | DBliterallayout
              | DBprogramlisting | DBprogramlistingco | DBscreen | DBscreenco
              | DBscreenshot | DBsynopsis | DBcmdsynopsis | DBfuncsynopsis
              | DBclasssynopsis | DBfieldsynopsis | DBconstructorsynopsis
              | DBdestructorsynopsis | DBmethodsynopsis | DBformalpara
              | DBpara | DBsimpara | DBaddress | DBblockquote | DBgraphic
              | DBgraphicco | DBmediaobject | DBmediaobjectco
              | DBinformalequation | DBinformalexample | DBinformalfigure
              | DBinformaltable | DBequation | DBexample | DBfigure | DBtable
              | DBmsgset | DBprocedure | DBsidebar | DBqandaset | DBanchor
              | DBbridgehead | DBremark | DBhighlights | DBabstract
              | DBauthorblurb | DBepigraph | DBindexterm | DBbeginpage)+
             (DBsect1* | DBrefentry* | DBsimplesect* | DBsection*))
            | (DBsect1+ | DBrefentry+ | DBsimplesect+ | DBsection+)))
          ];;
type DBreference =
       [
          (DBbeginpage? DBreferenceinfo? (DBtitle DBsubtitle? DBtitleabbrev?)
           DBpartintro? DBrefentry+)
          ];;
type DBpreface =
       [
          (DBbeginpage? DBprefaceinfo? (DBtitle DBsubtitle? DBtitleabbrev?)
           (DBtoc | DBlot | DBindex | DBglossary | DBbibliography)*
           DBtocchap?
           (((DBcalloutlist | DBglosslist | DBitemizedlist | DBorderedlist
              | DBsegmentedlist | DBsimplelist | DBvariablelist | DBcaution
              | DBimportant | DBnote | DBtip | DBwarning | DBliterallayout
              | DBprogramlisting | DBprogramlistingco | DBscreen | DBscreenco
              | DBscreenshot | DBsynopsis | DBcmdsynopsis | DBfuncsynopsis
              | DBclasssynopsis | DBfieldsynopsis | DBconstructorsynopsis
              | DBdestructorsynopsis | DBmethodsynopsis | DBformalpara
              | DBpara | DBsimpara | DBaddress | DBblockquote | DBgraphic
              | DBgraphicco | DBmediaobject | DBmediaobjectco
              | DBinformalequation | DBinformalexample | DBinformalfigure
              | DBinformaltable | DBequation | DBexample | DBfigure | DBtable
              | DBmsgset | DBprocedure | DBsidebar | DBqandaset | DBanchor
              | DBbridgehead | DBremark | DBhighlights | DBabstract
              | DBauthorblurb | DBepigraph | DBindexterm | DBbeginpage)+
             (DBsect1* | DBrefentry* | DBsimplesect* | DBsection*))
            | (DBsect1+ | DBrefentry+ | DBsimplesect+ | DBsection+))
           (DBtoc | DBlot | DBindex | DBglossary | DBbibliography)*)
          ];;
type DBpart =
       [
          (DBbeginpage? DBpartinfo? (DBtitle DBsubtitle? DBtitleabbrev?)
           DBpartintro?
           (DBappendix | DBchapter | DBtoc | DBlot | DBindex | DBglossary
            | DBbibliography | DBarticle | DBpreface | DBrefentry
            | DBreference)+)
          ];;
type DBchapter =
       [
          (DBbeginpage? DBchapterinfo? (DBtitle DBsubtitle? DBtitleabbrev?)
           (DBtoc | DBlot | DBindex | DBglossary | DBbibliography)*
           DBtocchap?
           (((DBcalloutlist | DBglosslist | DBitemizedlist | DBorderedlist
              | DBsegmentedlist | DBsimplelist | DBvariablelist | DBcaution
              | DBimportant | DBnote | DBtip | DBwarning | DBliterallayout
              | DBprogramlisting | DBprogramlistingco | DBscreen | DBscreenco
              | DBscreenshot | DBsynopsis | DBcmdsynopsis | DBfuncsynopsis
              | DBclasssynopsis | DBfieldsynopsis | DBconstructorsynopsis
              | DBdestructorsynopsis | DBmethodsynopsis | DBformalpara
              | DBpara | DBsimpara | DBaddress | DBblockquote | DBgraphic
              | DBgraphicco | DBmediaobject | DBmediaobjectco
              | DBinformalequation | DBinformalexample | DBinformalfigure
              | DBinformaltable | DBequation | DBexample | DBfigure | DBtable
              | DBmsgset | DBprocedure | DBsidebar | DBqandaset | DBanchor
              | DBbridgehead | DBremark | DBhighlights | DBabstract
              | DBauthorblurb | DBepigraph | DBindexterm | DBbeginpage)+
             (DBsect1* | DBrefentry* | DBsimplesect* | DBsection*))
            | (DBsect1+ | DBrefentry+ | DBsimplesect+ | DBsection+))
           (DBtoc | DBlot | DBindex | DBglossary | DBbibliography)*)
          ];;
type DBappendix =
       [
          (DBbeginpage? DBappendixinfo? (DBtitle DBsubtitle? DBtitleabbrev?)
           (DBtoc | DBlot | DBindex | DBglossary | DBbibliography)*
           DBtocchap?
           (((DBcalloutlist | DBglosslist | DBitemizedlist | DBorderedlist
              | DBsegmentedlist | DBsimplelist | DBvariablelist | DBcaution
              | DBimportant | DBnote | DBtip | DBwarning | DBliterallayout
              | DBprogramlisting | DBprogramlistingco | DBscreen | DBscreenco
              | DBscreenshot | DBsynopsis | DBcmdsynopsis | DBfuncsynopsis
              | DBclasssynopsis | DBfieldsynopsis | DBconstructorsynopsis
              | DBdestructorsynopsis | DBmethodsynopsis | DBformalpara
              | DBpara | DBsimpara | DBaddress | DBblockquote | DBgraphic
              | DBgraphicco | DBmediaobject | DBmediaobjectco
              | DBinformalequation | DBinformalexample | DBinformalfigure
              | DBinformaltable | DBequation | DBexample | DBfigure | DBtable
              | DBmsgset | DBprocedure | DBsidebar | DBqandaset | DBanchor
              | DBbridgehead | DBremark | DBhighlights | DBabstract
              | DBauthorblurb | DBepigraph | DBindexterm | DBbeginpage)+
             (DBsect1* | DBrefentry* | DBsimplesect* | DBsection*))
            | (DBsect1+ | DBrefentry+ | DBsimplesect+ | DBsection+))
           (DBtoc | DBlot | DBindex | DBglossary | DBbibliography)*)
          ];;
type DBlotentry =
       [
          ( Char | DBfootnoteref | DBxref | DBabbrev | DBacronym | DBcitation | DBciterefentry | DBcitetitle | DBemphasis | DBfirstterm | DBforeignphrase | DBglossterm | DBfootnote | DBphrase | DBquote | DBtrademark | DBwordasword | DBpersonname | DBlink | DBolink | DBulink | DBaction | DBapplication | DBclassname | DBmethodname | DBinterfacename | DBexceptionname | DBooclass | DBoointerface | DBooexception | DBcommand | DBcomputeroutput | DBdatabase | DBemail | DBenvar | DBerrorcode | DBerrorname | DBerrortype | DBerrortext | DBfilename | DBfunction | DBguibutton | DBguiicon | DBguilabel | DBguimenu | DBguimenuitem | DBguisubmenu | DBhardware | DBinterface | DBkeycap | DBkeycode | DBkeycombo | DBkeysym | DBliteral | DBconstant | DBmarkup | DBmedialabel | DBmenuchoice | DBmousebutton | DBoption | DBoptional | DBparameter | DBprompt | DBproperty | DBreplaceable | DBreturnvalue | DBsgmltag | DBstructfield | DBstructname | DBsymbol | DBsystemitem | DBtoken | DBtype | DBuserinput | DBvarname | DBanchor | DBauthor | DBauthorinitials | DBcorpauthor | DBmodespec | DBothercredit | DBproductname | DBproductnumber | DBrevhistory | DBremark | DBsubscript | DBsuperscript | DBinlinegraphic | DBinlinemediaobject | DBinlineequation | DBsynopsis | DBcmdsynopsis | DBfuncsynopsis | DBclasssynopsis | DBfieldsynopsis | DBconstructorsynopsis | DBdestructorsynopsis | DBmethodsynopsis | DBindexterm | DBbeginpage )*
          ];;
type DBlot =
       [
          (DBbeginpage? (DBtitle DBsubtitle? DBtitleabbrev?)? DBlotentry*) ];;
type DBtocback =
       [
          ( Char | DBfootnoteref | DBxref | DBabbrev | DBacronym | DBcitation | DBciterefentry | DBcitetitle | DBemphasis | DBfirstterm | DBforeignphrase | DBglossterm | DBfootnote | DBphrase | DBquote | DBtrademark | DBwordasword | DBpersonname | DBlink | DBolink | DBulink | DBaction | DBapplication | DBclassname | DBmethodname | DBinterfacename | DBexceptionname | DBooclass | DBoointerface | DBooexception | DBcommand | DBcomputeroutput | DBdatabase | DBemail | DBenvar | DBerrorcode | DBerrorname | DBerrortype | DBerrortext | DBfilename | DBfunction | DBguibutton | DBguiicon | DBguilabel | DBguimenu | DBguimenuitem | DBguisubmenu | DBhardware | DBinterface | DBkeycap | DBkeycode | DBkeycombo | DBkeysym | DBliteral | DBconstant | DBmarkup | DBmedialabel | DBmenuchoice | DBmousebutton | DBoption | DBoptional | DBparameter | DBprompt | DBproperty | DBreplaceable | DBreturnvalue | DBsgmltag | DBstructfield | DBstructname | DBsymbol | DBsystemitem | DBtoken | DBtype | DBuserinput | DBvarname | DBanchor | DBauthor | DBauthorinitials | DBcorpauthor | DBmodespec | DBothercredit | DBproductname | DBproductnumber | DBrevhistory | DBremark | DBsubscript | DBsuperscript | DBinlinegraphic | DBinlinemediaobject | DBinlineequation | DBsynopsis | DBcmdsynopsis | DBfuncsynopsis | DBclasssynopsis | DBfieldsynopsis | DBconstructorsynopsis | DBdestructorsynopsis | DBmethodsynopsis | DBindexterm | DBbeginpage )*
          ];;
type DBtoclevel5 =
       [
          DBtocentry+ ];;
type DBtoclevel4 =
       [
          (DBtocentry+ DBtoclevel5*) ];;
type DBtoclevel3 =
       [
          (DBtocentry+ DBtoclevel4*) ];;
type DBtoclevel2 =
       [
          (DBtocentry+ DBtoclevel3*) ];;
type DBtoclevel1 =
       [
          (DBtocentry+ DBtoclevel2*) ];;
type DBtocchap =
       [
          (DBtocentry+ DBtoclevel1*) ];;
type DBtocpart =
       [
          (DBtocentry+ DBtocchap*) ];;
type DBtocentry =
       [
          ( Char | DBfootnoteref | DBxref | DBabbrev | DBacronym | DBcitation | DBciterefentry | DBcitetitle | DBemphasis | DBfirstterm | DBforeignphrase | DBglossterm | DBfootnote | DBphrase | DBquote | DBtrademark | DBwordasword | DBpersonname | DBlink | DBolink | DBulink | DBaction | DBapplication | DBclassname | DBmethodname | DBinterfacename | DBexceptionname | DBooclass | DBoointerface | DBooexception | DBcommand | DBcomputeroutput | DBdatabase | DBemail | DBenvar | DBerrorcode | DBerrorname | DBerrortype | DBerrortext | DBfilename | DBfunction | DBguibutton | DBguiicon | DBguilabel | DBguimenu | DBguimenuitem | DBguisubmenu | DBhardware | DBinterface | DBkeycap | DBkeycode | DBkeycombo | DBkeysym | DBliteral | DBconstant | DBmarkup | DBmedialabel | DBmenuchoice | DBmousebutton | DBoption | DBoptional | DBparameter | DBprompt | DBproperty | DBreplaceable | DBreturnvalue | DBsgmltag | DBstructfield | DBstructname | DBsymbol | DBsystemitem | DBtoken | DBtype | DBuserinput | DBvarname | DBanchor | DBauthor | DBauthorinitials | DBcorpauthor | DBmodespec | DBothercredit | DBproductname | DBproductnumber | DBrevhistory | DBremark | DBsubscript | DBsuperscript | DBinlinegraphic | DBinlinemediaobject | DBinlineequation | DBsynopsis | DBcmdsynopsis | DBfuncsynopsis | DBclasssynopsis | DBfieldsynopsis | DBconstructorsynopsis | DBdestructorsynopsis | DBmethodsynopsis | DBindexterm | DBbeginpage )*
          ];;
type DBtocfront =
       [
          ( Char | DBfootnoteref | DBxref | DBabbrev | DBacronym | DBcitation | DBciterefentry | DBcitetitle | DBemphasis | DBfirstterm | DBforeignphrase | DBglossterm | DBfootnote | DBphrase | DBquote | DBtrademark | DBwordasword | DBpersonname | DBlink | DBolink | DBulink | DBaction | DBapplication | DBclassname | DBmethodname | DBinterfacename | DBexceptionname | DBooclass | DBoointerface | DBooexception | DBcommand | DBcomputeroutput | DBdatabase | DBemail | DBenvar | DBerrorcode | DBerrorname | DBerrortype | DBerrortext | DBfilename | DBfunction | DBguibutton | DBguiicon | DBguilabel | DBguimenu | DBguimenuitem | DBguisubmenu | DBhardware | DBinterface | DBkeycap | DBkeycode | DBkeycombo | DBkeysym | DBliteral | DBconstant | DBmarkup | DBmedialabel | DBmenuchoice | DBmousebutton | DBoption | DBoptional | DBparameter | DBprompt | DBproperty | DBreplaceable | DBreturnvalue | DBsgmltag | DBstructfield | DBstructname | DBsymbol | DBsystemitem | DBtoken | DBtype | DBuserinput | DBvarname | DBanchor | DBauthor | DBauthorinitials | DBcorpauthor | DBmodespec | DBothercredit | DBproductname | DBproductnumber | DBrevhistory | DBremark | DBsubscript | DBsuperscript | DBinlinegraphic | DBinlinemediaobject | DBinlineequation | DBsynopsis | DBcmdsynopsis | DBfuncsynopsis | DBclasssynopsis | DBfieldsynopsis | DBconstructorsynopsis | DBdestructorsynopsis | DBmethodsynopsis | DBindexterm | DBbeginpage )*
          ];;
type DBtoc =
       [
          (DBbeginpage? (DBtitle DBsubtitle? DBtitleabbrev?)? DBtocfront*
           (DBtocpart | DBtocchap)* DBtocback*)
          ];;
type DBcolophon =
       [
          ((DBtitle DBsubtitle? DBtitleabbrev?)?
           (DBcalloutlist | DBglosslist | DBitemizedlist | DBorderedlist
            | DBsegmentedlist | DBsimplelist | DBvariablelist | DBcaution
            | DBimportant | DBnote | DBtip | DBwarning | DBliterallayout
            | DBprogramlisting | DBprogramlistingco | DBscreen | DBscreenco
            | DBscreenshot | DBformalpara | DBpara | DBsimpara | DBblockquote)+)
          ];;
type DBdedication =
       [
          ((DBtitle DBsubtitle? DBtitleabbrev?)?
           (DBcalloutlist | DBglosslist | DBitemizedlist | DBorderedlist
            | DBsegmentedlist | DBsimplelist | DBvariablelist | DBcaution
            | DBimportant | DBnote | DBtip | DBwarning | DBliterallayout
            | DBprogramlisting | DBprogramlistingco | DBscreen | DBscreenco
            | DBscreenshot | DBformalpara | DBpara | DBsimpara | DBblockquote
            | DBindexterm | DBbeginpage)+)
          ];;
type DBbookinfo =
       [
          (DBgraphic | DBmediaobject | DBlegalnotice | DBmodespec
           | DBsubjectset | DBkeywordset | DBitermset | DBabbrev | DBabstract
           | DBaddress | DBartpagenums | DBauthor | DBauthorgroup
           | DBauthorinitials | DBbibliomisc | DBbiblioset | DBcollab
           | DBconfgroup | DBcontractnum | DBcontractsponsor | DBcopyright
           | DBcorpauthor | DBcorpname | DBdate | DBedition | DBeditor
           | DBinvpartnumber | DBisbn | DBissn | DBissuenum | DBorgname
           | DBbiblioid | DBcitebiblioid | DBbibliosource | DBbibliorelation
           | DBbibliocoverage | DBothercredit | DBpagenums | DBprinthistory
           | DBproductname | DBproductnumber | DBpubdate | DBpublisher
           | DBpublishername | DBpubsnumber | DBreleaseinfo | DBrevhistory
           | DBseriesvolnums | DBsubtitle | DBtitle | DBtitleabbrev
           | DBvolumenum | DBcitetitle | DBpersonname | DBhonorific
           | DBfirstname | DBsurname | DBlineage | DBothername
           | DBaffiliation | DBauthorblurb | DBcontrib | DBindexterm)+
          ];;
type DBbook =
       [
          ((DBtitle DBsubtitle? DBtitleabbrev?)? DBbookinfo?
           (DBdedication | DBtoc | DBlot | DBglossary | DBbibliography
            | DBpreface | DBchapter | DBreference | DBpart | DBarticle
            | DBappendix | DBindex | DBsetindex | DBcolophon)*)
          ];;
type DBsetinfo =
       [
          (DBgraphic | DBmediaobject | DBlegalnotice | DBmodespec
           | DBsubjectset | DBkeywordset | DBitermset | DBabbrev | DBabstract
           | DBaddress | DBartpagenums | DBauthor | DBauthorgroup
           | DBauthorinitials | DBbibliomisc | DBbiblioset | DBcollab
           | DBconfgroup | DBcontractnum | DBcontractsponsor | DBcopyright
           | DBcorpauthor | DBcorpname | DBdate | DBedition | DBeditor
           | DBinvpartnumber | DBisbn | DBissn | DBissuenum | DBorgname
           | DBbiblioid | DBcitebiblioid | DBbibliosource | DBbibliorelation
           | DBbibliocoverage | DBothercredit | DBpagenums | DBprinthistory
           | DBproductname | DBproductnumber | DBpubdate | DBpublisher
           | DBpublishername | DBpubsnumber | DBreleaseinfo | DBrevhistory
           | DBseriesvolnums | DBsubtitle | DBtitle | DBtitleabbrev
           | DBvolumenum | DBcitetitle | DBpersonname | DBhonorific
           | DBfirstname | DBsurname | DBlineage | DBothername
           | DBaffiliation | DBauthorblurb | DBcontrib | DBindexterm)+
          ];;
type DBset =
       [
          ((DBtitle DBsubtitle? DBtitleabbrev?)? DBsetinfo? DBtoc? DBbook+
           DBsetindex?)
          ];;
type DBseealso =
       [
          ( Char | DBfootnoteref | DBxref | DBabbrev | DBacronym | DBcitation | DBciterefentry | DBcitetitle | DBemphasis | DBfirstterm | DBforeignphrase | DBglossterm | DBfootnote | DBphrase | DBquote | DBtrademark | DBwordasword | DBpersonname | DBlink | DBolink | DBulink | DBaction | DBapplication | DBclassname | DBmethodname | DBinterfacename | DBexceptionname | DBooclass | DBoointerface | DBooexception | DBcommand | DBcomputeroutput | DBdatabase | DBemail | DBenvar | DBerrorcode | DBerrorname | DBerrortype | DBerrortext | DBfilename | DBfunction | DBguibutton | DBguiicon | DBguilabel | DBguimenu | DBguimenuitem | DBguisubmenu | DBhardware | DBinterface | DBkeycap | DBkeycode | DBkeycombo | DBkeysym | DBliteral | DBconstant | DBmarkup | DBmedialabel | DBmenuchoice | DBmousebutton | DBoption | DBoptional | DBparameter | DBprompt | DBproperty | DBreplaceable | DBreturnvalue | DBsgmltag | DBstructfield | DBstructname | DBsymbol | DBsystemitem | DBtoken | DBtype | DBuserinput | DBvarname | DBanchor | DBauthor | DBauthorinitials | DBcorpauthor | DBmodespec | DBothercredit | DBproductname | DBproductnumber | DBrevhistory | DBremark | DBsubscript | DBsuperscript | DBinlinegraphic | DBinlinemediaobject )*
          ];;
type DBsee =
       [
          ( Char | DBfootnoteref | DBxref | DBabbrev | DBacronym | DBcitation | DBciterefentry | DBcitetitle | DBemphasis | DBfirstterm | DBforeignphrase | DBglossterm | DBfootnote | DBphrase | DBquote | DBtrademark | DBwordasword | DBpersonname | DBlink | DBolink | DBulink | DBaction | DBapplication | DBclassname | DBmethodname | DBinterfacename | DBexceptionname | DBooclass | DBoointerface | DBooexception | DBcommand | DBcomputeroutput | DBdatabase | DBemail | DBenvar | DBerrorcode | DBerrorname | DBerrortype | DBerrortext | DBfilename | DBfunction | DBguibutton | DBguiicon | DBguilabel | DBguimenu | DBguimenuitem | DBguisubmenu | DBhardware | DBinterface | DBkeycap | DBkeycode | DBkeycombo | DBkeysym | DBliteral | DBconstant | DBmarkup | DBmedialabel | DBmenuchoice | DBmousebutton | DBoption | DBoptional | DBparameter | DBprompt | DBproperty | DBreplaceable | DBreturnvalue | DBsgmltag | DBstructfield | DBstructname | DBsymbol | DBsystemitem | DBtoken | DBtype | DBuserinput | DBvarname | DBanchor | DBauthor | DBauthorinitials | DBcorpauthor | DBmodespec | DBothercredit | DBproductname | DBproductnumber | DBrevhistory | DBremark | DBsubscript | DBsuperscript | DBinlinegraphic | DBinlinemediaobject )*
          ];;
type DBtertiary =
       [
          ( Char | DBfootnoteref | DBxref | DBabbrev | DBacronym | DBcitation | DBciterefentry | DBcitetitle | DBemphasis | DBfirstterm | DBforeignphrase | DBglossterm | DBfootnote | DBphrase | DBquote | DBtrademark | DBwordasword | DBpersonname | DBlink | DBolink | DBulink | DBaction | DBapplication | DBclassname | DBmethodname | DBinterfacename | DBexceptionname | DBooclass | DBoointerface | DBooexception | DBcommand | DBcomputeroutput | DBdatabase | DBemail | DBenvar | DBerrorcode | DBerrorname | DBerrortype | DBerrortext | DBfilename | DBfunction | DBguibutton | DBguiicon | DBguilabel | DBguimenu | DBguimenuitem | DBguisubmenu | DBhardware | DBinterface | DBkeycap | DBkeycode | DBkeycombo | DBkeysym | DBliteral | DBconstant | DBmarkup | DBmedialabel | DBmenuchoice | DBmousebutton | DBoption | DBoptional | DBparameter | DBprompt | DBproperty | DBreplaceable | DBreturnvalue | DBsgmltag | DBstructfield | DBstructname | DBsymbol | DBsystemitem | DBtoken | DBtype | DBuserinput | DBvarname | DBanchor | DBauthor | DBauthorinitials | DBcorpauthor | DBmodespec | DBothercredit | DBproductname | DBproductnumber | DBrevhistory | DBremark | DBsubscript | DBsuperscript | DBinlinegraphic | DBinlinemediaobject )*
          ];;
type DBsecondary =
       [
          ( Char | DBfootnoteref | DBxref | DBabbrev | DBacronym | DBcitation | DBciterefentry | DBcitetitle | DBemphasis | DBfirstterm | DBforeignphrase | DBglossterm | DBfootnote | DBphrase | DBquote | DBtrademark | DBwordasword | DBpersonname | DBlink | DBolink | DBulink | DBaction | DBapplication | DBclassname | DBmethodname | DBinterfacename | DBexceptionname | DBooclass | DBoointerface | DBooexception | DBcommand | DBcomputeroutput | DBdatabase | DBemail | DBenvar | DBerrorcode | DBerrorname | DBerrortype | DBerrortext | DBfilename | DBfunction | DBguibutton | DBguiicon | DBguilabel | DBguimenu | DBguimenuitem | DBguisubmenu | DBhardware | DBinterface | DBkeycap | DBkeycode | DBkeycombo | DBkeysym | DBliteral | DBconstant | DBmarkup | DBmedialabel | DBmenuchoice | DBmousebutton | DBoption | DBoptional | DBparameter | DBprompt | DBproperty | DBreplaceable | DBreturnvalue | DBsgmltag | DBstructfield | DBstructname | DBsymbol | DBsystemitem | DBtoken | DBtype | DBuserinput | DBvarname | DBanchor | DBauthor | DBauthorinitials | DBcorpauthor | DBmodespec | DBothercredit | DBproductname | DBproductnumber | DBrevhistory | DBremark | DBsubscript | DBsuperscript | DBinlinegraphic | DBinlinemediaobject )*
          ];;
type DBprimary =
       [
          ( Char | DBfootnoteref | DBxref | DBabbrev | DBacronym | DBcitation | DBciterefentry | DBcitetitle | DBemphasis | DBfirstterm | DBforeignphrase | DBglossterm | DBfootnote | DBphrase | DBquote | DBtrademark | DBwordasword | DBpersonname | DBlink | DBolink | DBulink | DBaction | DBapplication | DBclassname | DBmethodname | DBinterfacename | DBexceptionname | DBooclass | DBoointerface | DBooexception | DBcommand | DBcomputeroutput | DBdatabase | DBemail | DBenvar | DBerrorcode | DBerrorname | DBerrortype | DBerrortext | DBfilename | DBfunction | DBguibutton | DBguiicon | DBguilabel | DBguimenu | DBguimenuitem | DBguisubmenu | DBhardware | DBinterface | DBkeycap | DBkeycode | DBkeycombo | DBkeysym | DBliteral | DBconstant | DBmarkup | DBmedialabel | DBmenuchoice | DBmousebutton | DBoption | DBoptional | DBparameter | DBprompt | DBproperty | DBreplaceable | DBreturnvalue | DBsgmltag | DBstructfield | DBstructname | DBsymbol | DBsystemitem | DBtoken | DBtype | DBuserinput | DBvarname | DBanchor | DBauthor | DBauthorinitials | DBcorpauthor | DBmodespec | DBothercredit | DBproductname | DBproductnumber | DBrevhistory | DBremark | DBsubscript | DBsuperscript | DBinlinegraphic | DBinlinemediaobject )*
          ];;
type DBindexterm =
       [
          (DBprimary?
           ((DBsecondary
             ((DBtertiary (DBsee | DBseealso+)?) | DBsee | DBseealso+)?)
            | DBsee | DBseealso+)?)
          ];;
type DBbeginpage =
       [
           ];;
type DBanchor =
       [
           ];;
type DBxref =
       [
           ];;
type DBfootnoteref =
       [
           ];;
type DBulink =
       [
          ( Char | DBfootnoteref | DBxref | DBabbrev | DBacronym | DBcitation | DBciterefentry | DBcitetitle | DBemphasis | DBfirstterm | DBforeignphrase | DBglossterm | DBfootnote | DBphrase | DBquote | DBtrademark | DBwordasword | DBpersonname | DBlink | DBolink | DBulink | DBaction | DBapplication | DBclassname | DBmethodname | DBinterfacename | DBexceptionname | DBooclass | DBoointerface | DBooexception | DBcommand | DBcomputeroutput | DBdatabase | DBemail | DBenvar | DBerrorcode | DBerrorname | DBerrortype | DBerrortext | DBfilename | DBfunction | DBguibutton | DBguiicon | DBguilabel | DBguimenu | DBguimenuitem | DBguisubmenu | DBhardware | DBinterface | DBkeycap | DBkeycode | DBkeycombo | DBkeysym | DBliteral | DBconstant | DBmarkup | DBmedialabel | DBmenuchoice | DBmousebutton | DBoption | DBoptional | DBparameter | DBprompt | DBproperty | DBreplaceable | DBreturnvalue | DBsgmltag | DBstructfield | DBstructname | DBsymbol | DBsystemitem | DBtoken | DBtype | DBuserinput | DBvarname | DBanchor | DBauthor | DBauthorinitials | DBcorpauthor | DBmodespec | DBothercredit | DBproductname | DBproductnumber | DBrevhistory | DBremark | DBsubscript | DBsuperscript | DBinlinegraphic | DBinlinemediaobject | DBinlineequation | DBsynopsis | DBcmdsynopsis | DBfuncsynopsis | DBclasssynopsis | DBfieldsynopsis | DBconstructorsynopsis | DBdestructorsynopsis | DBmethodsynopsis | DBindexterm | DBbeginpage )*
          ];;
type DBolink =
       [
          ( Char | DBfootnoteref | DBxref | DBabbrev | DBacronym | DBcitation | DBciterefentry | DBcitetitle | DBemphasis | DBfirstterm | DBforeignphrase | DBglossterm | DBfootnote | DBphrase | DBquote | DBtrademark | DBwordasword | DBpersonname | DBlink | DBolink | DBulink | DBaction | DBapplication | DBclassname | DBmethodname | DBinterfacename | DBexceptionname | DBooclass | DBoointerface | DBooexception | DBcommand | DBcomputeroutput | DBdatabase | DBemail | DBenvar | DBerrorcode | DBerrorname | DBerrortype | DBerrortext | DBfilename | DBfunction | DBguibutton | DBguiicon | DBguilabel | DBguimenu | DBguimenuitem | DBguisubmenu | DBhardware | DBinterface | DBkeycap | DBkeycode | DBkeycombo | DBkeysym | DBliteral | DBconstant | DBmarkup | DBmedialabel | DBmenuchoice | DBmousebutton | DBoption | DBoptional | DBparameter | DBprompt | DBproperty | DBreplaceable | DBreturnvalue | DBsgmltag | DBstructfield | DBstructname | DBsymbol | DBsystemitem | DBtoken | DBtype | DBuserinput | DBvarname | DBanchor | DBauthor | DBauthorinitials | DBcorpauthor | DBmodespec | DBothercredit | DBproductname | DBproductnumber | DBrevhistory | DBremark | DBsubscript | DBsuperscript | DBinlinegraphic | DBinlinemediaobject | DBinlineequation | DBsynopsis | DBcmdsynopsis | DBfuncsynopsis | DBclasssynopsis | DBfieldsynopsis | DBconstructorsynopsis | DBdestructorsynopsis | DBmethodsynopsis | DBindexterm | DBbeginpage )*
          ];;
type DBlink =
       [
          ( Char | DBfootnoteref | DBxref | DBabbrev | DBacronym | DBcitation | DBciterefentry | DBcitetitle | DBemphasis | DBfirstterm | DBforeignphrase | DBglossterm | DBfootnote | DBphrase | DBquote | DBtrademark | DBwordasword | DBpersonname | DBlink | DBolink | DBulink | DBaction | DBapplication | DBclassname | DBmethodname | DBinterfacename | DBexceptionname | DBooclass | DBoointerface | DBooexception | DBcommand | DBcomputeroutput | DBdatabase | DBemail | DBenvar | DBerrorcode | DBerrorname | DBerrortype | DBerrortext | DBfilename | DBfunction | DBguibutton | DBguiicon | DBguilabel | DBguimenu | DBguimenuitem | DBguisubmenu | DBhardware | DBinterface | DBkeycap | DBkeycode | DBkeycombo | DBkeysym | DBliteral | DBconstant | DBmarkup | DBmedialabel | DBmenuchoice | DBmousebutton | DBoption | DBoptional | DBparameter | DBprompt | DBproperty | DBreplaceable | DBreturnvalue | DBsgmltag | DBstructfield | DBstructname | DBsymbol | DBsystemitem | DBtoken | DBtype | DBuserinput | DBvarname | DBanchor | DBauthor | DBauthorinitials | DBcorpauthor | DBmodespec | DBothercredit | DBproductname | DBproductnumber | DBrevhistory | DBremark | DBsubscript | DBsuperscript | DBinlinegraphic | DBinlinemediaobject | DBinlineequation | DBsynopsis | DBcmdsynopsis | DBfuncsynopsis | DBclasssynopsis | DBfieldsynopsis | DBconstructorsynopsis | DBdestructorsynopsis | DBmethodsynopsis | DBindexterm | DBbeginpage )*
          ];;
type DBwordasword =
       [
          ( Char | DBacronym | DBemphasis | DBtrademark | DBlink | DBolink | DBulink | DBanchor | DBremark | DBsubscript | DBsuperscript | DBinlinegraphic | DBinlinemediaobject | DBindexterm | DBbeginpage )*
          ];;
type DBtrademark =
       [
          ( Char | DBlink | DBolink | DBulink | DBaction | DBapplication | DBclassname | DBmethodname | DBinterfacename | DBexceptionname | DBooclass | DBoointerface | DBooexception | DBcommand | DBcomputeroutput | DBdatabase | DBemail | DBenvar | DBerrorcode | DBerrorname | DBerrortype | DBerrortext | DBfilename | DBfunction | DBguibutton | DBguiicon | DBguilabel | DBguimenu | DBguimenuitem | DBguisubmenu | DBhardware | DBinterface | DBkeycap | DBkeycode | DBkeycombo | DBkeysym | DBliteral | DBconstant | DBmarkup | DBmedialabel | DBmenuchoice | DBmousebutton | DBoption | DBoptional | DBparameter | DBprompt | DBproperty | DBreplaceable | DBreturnvalue | DBsgmltag | DBstructfield | DBstructname | DBsymbol | DBsystemitem | DBtoken | DBtype | DBuserinput | DBvarname | DBanchor | DBremark | DBsubscript | DBsuperscript | DBinlinegraphic | DBinlinemediaobject | DBemphasis )*
          ];;
type DBsuperscript =
       [
          ( Char | DBlink | DBolink | DBulink | DBemphasis | DBreplaceable | DBsymbol | DBinlinegraphic | DBinlinemediaobject | DBanchor | DBremark | DBsubscript | DBsuperscript )*
          ];;
type DBsubscript =
       [
          ( Char | DBlink | DBolink | DBulink | DBemphasis | DBreplaceable | DBsymbol | DBinlinegraphic | DBinlinemediaobject | DBanchor | DBremark | DBsubscript | DBsuperscript )*
          ];;
type DBquote =
       [
          ( Char | DBfootnoteref | DBxref | DBabbrev | DBacronym | DBcitation | DBciterefentry | DBcitetitle | DBemphasis | DBfirstterm | DBforeignphrase | DBglossterm | DBfootnote | DBphrase | DBquote | DBtrademark | DBwordasword | DBpersonname | DBlink | DBolink | DBulink | DBaction | DBapplication | DBclassname | DBmethodname | DBinterfacename | DBexceptionname | DBooclass | DBoointerface | DBooexception | DBcommand | DBcomputeroutput | DBdatabase | DBemail | DBenvar | DBerrorcode | DBerrorname | DBerrortype | DBerrortext | DBfilename | DBfunction | DBguibutton | DBguiicon | DBguilabel | DBguimenu | DBguimenuitem | DBguisubmenu | DBhardware | DBinterface | DBkeycap | DBkeycode | DBkeycombo | DBkeysym | DBliteral | DBconstant | DBmarkup | DBmedialabel | DBmenuchoice | DBmousebutton | DBoption | DBoptional | DBparameter | DBprompt | DBproperty | DBreplaceable | DBreturnvalue | DBsgmltag | DBstructfield | DBstructname | DBsymbol | DBsystemitem | DBtoken | DBtype | DBuserinput | DBvarname | DBanchor | DBauthor | DBauthorinitials | DBcorpauthor | DBmodespec | DBothercredit | DBproductname | DBproductnumber | DBrevhistory | DBremark | DBsubscript | DBsuperscript | DBinlinegraphic | DBinlinemediaobject | DBinlineequation | DBsynopsis | DBcmdsynopsis | DBfuncsynopsis | DBclasssynopsis | DBfieldsynopsis | DBconstructorsynopsis | DBdestructorsynopsis | DBmethodsynopsis | DBindexterm | DBbeginpage )*
          ];;
type DBphrase =
       [
          ( Char | DBfootnoteref | DBxref | DBabbrev | DBacronym | DBcitation | DBciterefentry | DBcitetitle | DBemphasis | DBfirstterm | DBforeignphrase | DBglossterm | DBfootnote | DBphrase | DBquote | DBtrademark | DBwordasword | DBpersonname | DBlink | DBolink | DBulink | DBaction | DBapplication | DBclassname | DBmethodname | DBinterfacename | DBexceptionname | DBooclass | DBoointerface | DBooexception | DBcommand | DBcomputeroutput | DBdatabase | DBemail | DBenvar | DBerrorcode | DBerrorname | DBerrortype | DBerrortext | DBfilename | DBfunction | DBguibutton | DBguiicon | DBguilabel | DBguimenu | DBguimenuitem | DBguisubmenu | DBhardware | DBinterface | DBkeycap | DBkeycode | DBkeycombo | DBkeysym | DBliteral | DBconstant | DBmarkup | DBmedialabel | DBmenuchoice | DBmousebutton | DBoption | DBoptional | DBparameter | DBprompt | DBproperty | DBreplaceable | DBreturnvalue | DBsgmltag | DBstructfield | DBstructname | DBsymbol | DBsystemitem | DBtoken | DBtype | DBuserinput | DBvarname | DBanchor | DBauthor | DBauthorinitials | DBcorpauthor | DBmodespec | DBothercredit | DBproductname | DBproductnumber | DBrevhistory | DBremark | DBsubscript | DBsuperscript | DBinlinegraphic | DBinlinemediaobject | DBinlineequation | DBsynopsis | DBcmdsynopsis | DBfuncsynopsis | DBclasssynopsis | DBfieldsynopsis | DBconstructorsynopsis | DBdestructorsynopsis | DBmethodsynopsis | DBindexterm | DBbeginpage )*
          ];;
type DBglossterm =
       [
          ( Char | DBfootnoteref | DBxref | DBabbrev | DBacronym | DBcitation | DBciterefentry | DBcitetitle | DBemphasis | DBfirstterm | DBforeignphrase | DBglossterm | DBfootnote | DBphrase | DBquote | DBtrademark | DBwordasword | DBpersonname | DBlink | DBolink | DBulink | DBaction | DBapplication | DBclassname | DBmethodname | DBinterfacename | DBexceptionname | DBooclass | DBoointerface | DBooexception | DBcommand | DBcomputeroutput | DBdatabase | DBemail | DBenvar | DBerrorcode | DBerrorname | DBerrortype | DBerrortext | DBfilename | DBfunction | DBguibutton | DBguiicon | DBguilabel | DBguimenu | DBguimenuitem | DBguisubmenu | DBhardware | DBinterface | DBkeycap | DBkeycode | DBkeycombo | DBkeysym | DBliteral | DBconstant | DBmarkup | DBmedialabel | DBmenuchoice | DBmousebutton | DBoption | DBoptional | DBparameter | DBprompt | DBproperty | DBreplaceable | DBreturnvalue | DBsgmltag | DBstructfield | DBstructname | DBsymbol | DBsystemitem | DBtoken | DBtype | DBuserinput | DBvarname | DBanchor | DBauthor | DBauthorinitials | DBcorpauthor | DBmodespec | DBothercredit | DBproductname | DBproductnumber | DBrevhistory | DBremark | DBsubscript | DBsuperscript | DBinlinegraphic | DBinlinemediaobject | DBinlineequation | DBsynopsis | DBcmdsynopsis | DBfuncsynopsis | DBclasssynopsis | DBfieldsynopsis | DBconstructorsynopsis | DBdestructorsynopsis | DBmethodsynopsis | DBindexterm | DBbeginpage )*
          ];;
type DBforeignphrase =
       [
          ( Char | DBfootnoteref | DBxref | DBabbrev | DBacronym | DBcitation | DBciterefentry | DBcitetitle | DBemphasis | DBfirstterm | DBforeignphrase | DBglossterm | DBfootnote | DBphrase | DBquote | DBtrademark | DBwordasword | DBpersonname | DBlink | DBolink | DBulink | DBaction | DBapplication | DBclassname | DBmethodname | DBinterfacename | DBexceptionname | DBooclass | DBoointerface | DBooexception | DBcommand | DBcomputeroutput | DBdatabase | DBemail | DBenvar | DBerrorcode | DBerrorname | DBerrortype | DBerrortext | DBfilename | DBfunction | DBguibutton | DBguiicon | DBguilabel | DBguimenu | DBguimenuitem | DBguisubmenu | DBhardware | DBinterface | DBkeycap | DBkeycode | DBkeycombo | DBkeysym | DBliteral | DBconstant | DBmarkup | DBmedialabel | DBmenuchoice | DBmousebutton | DBoption | DBoptional | DBparameter | DBprompt | DBproperty | DBreplaceable | DBreturnvalue | DBsgmltag | DBstructfield | DBstructname | DBsymbol | DBsystemitem | DBtoken | DBtype | DBuserinput | DBvarname | DBanchor | DBauthor | DBauthorinitials | DBcorpauthor | DBmodespec | DBothercredit | DBproductname | DBproductnumber | DBrevhistory | DBremark | DBsubscript | DBsuperscript | DBinlinegraphic | DBinlinemediaobject | DBinlineequation | DBsynopsis | DBcmdsynopsis | DBfuncsynopsis | DBclasssynopsis | DBfieldsynopsis | DBconstructorsynopsis | DBdestructorsynopsis | DBmethodsynopsis | DBindexterm | DBbeginpage )*
          ];;
type DBfirstterm =
       [
          ( Char | DBacronym | DBemphasis | DBtrademark | DBlink | DBolink | DBulink | DBanchor | DBremark | DBsubscript | DBsuperscript | DBinlinegraphic | DBinlinemediaobject | DBindexterm | DBbeginpage )*
          ];;
type DBemphasis =
       [
          ( Char | DBfootnoteref | DBxref | DBabbrev | DBacronym | DBcitation | DBciterefentry | DBcitetitle | DBemphasis | DBfirstterm | DBforeignphrase | DBglossterm | DBfootnote | DBphrase | DBquote | DBtrademark | DBwordasword | DBpersonname | DBlink | DBolink | DBulink | DBaction | DBapplication | DBclassname | DBmethodname | DBinterfacename | DBexceptionname | DBooclass | DBoointerface | DBooexception | DBcommand | DBcomputeroutput | DBdatabase | DBemail | DBenvar | DBerrorcode | DBerrorname | DBerrortype | DBerrortext | DBfilename | DBfunction | DBguibutton | DBguiicon | DBguilabel | DBguimenu | DBguimenuitem | DBguisubmenu | DBhardware | DBinterface | DBkeycap | DBkeycode | DBkeycombo | DBkeysym | DBliteral | DBconstant | DBmarkup | DBmedialabel | DBmenuchoice | DBmousebutton | DBoption | DBoptional | DBparameter | DBprompt | DBproperty | DBreplaceable | DBreturnvalue | DBsgmltag | DBstructfield | DBstructname | DBsymbol | DBsystemitem | DBtoken | DBtype | DBuserinput | DBvarname | DBanchor | DBauthor | DBauthorinitials | DBcorpauthor | DBmodespec | DBothercredit | DBproductname | DBproductnumber | DBrevhistory | DBremark | DBsubscript | DBsuperscript | DBinlinegraphic | DBinlinemediaobject | DBinlineequation | DBsynopsis | DBcmdsynopsis | DBfuncsynopsis | DBclasssynopsis | DBfieldsynopsis | DBconstructorsynopsis | DBdestructorsynopsis | DBmethodsynopsis | DBindexterm | DBbeginpage )*
          ];;
type DBcitetitle =
       [
          ( Char | DBfootnoteref | DBxref | DBabbrev | DBacronym | DBcitation | DBciterefentry | DBcitetitle | DBemphasis | DBfirstterm | DBforeignphrase | DBglossterm | DBfootnote | DBphrase | DBquote | DBtrademark | DBwordasword | DBpersonname | DBlink | DBolink | DBulink | DBaction | DBapplication | DBclassname | DBmethodname | DBinterfacename | DBexceptionname | DBooclass | DBoointerface | DBooexception | DBcommand | DBcomputeroutput | DBdatabase | DBemail | DBenvar | DBerrorcode | DBerrorname | DBerrortype | DBerrortext | DBfilename | DBfunction | DBguibutton | DBguiicon | DBguilabel | DBguimenu | DBguimenuitem | DBguisubmenu | DBhardware | DBinterface | DBkeycap | DBkeycode | DBkeycombo | DBkeysym | DBliteral | DBconstant | DBmarkup | DBmedialabel | DBmenuchoice | DBmousebutton | DBoption | DBoptional | DBparameter | DBprompt | DBproperty | DBreplaceable | DBreturnvalue | DBsgmltag | DBstructfield | DBstructname | DBsymbol | DBsystemitem | DBtoken | DBtype | DBuserinput | DBvarname | DBanchor | DBauthor | DBauthorinitials | DBcorpauthor | DBmodespec | DBothercredit | DBproductname | DBproductnumber | DBrevhistory | DBremark | DBsubscript | DBsuperscript | DBinlinegraphic | DBinlinemediaobject | DBinlineequation | DBsynopsis | DBcmdsynopsis | DBfuncsynopsis | DBclasssynopsis | DBfieldsynopsis | DBconstructorsynopsis | DBdestructorsynopsis | DBmethodsynopsis | DBindexterm | DBbeginpage )*
          ];;
type DBmanvolnum =
       [
          ( Char | DBacronym | DBemphasis | DBtrademark | DBlink | DBolink | DBulink | DBanchor | DBremark | DBsubscript | DBsuperscript | DBinlinegraphic | DBinlinemediaobject | DBindexterm | DBbeginpage )*
          ];;
type DBrefentrytitle =
       [
          ( Char | DBfootnoteref | DBxref | DBabbrev | DBacronym | DBcitation | DBciterefentry | DBcitetitle | DBemphasis | DBfirstterm | DBforeignphrase | DBglossterm | DBfootnote | DBphrase | DBquote | DBtrademark | DBwordasword | DBpersonname | DBlink | DBolink | DBulink | DBaction | DBapplication | DBclassname | DBmethodname | DBinterfacename | DBexceptionname | DBooclass | DBoointerface | DBooexception | DBcommand | DBcomputeroutput | DBdatabase | DBemail | DBenvar | DBerrorcode | DBerrorname | DBerrortype | DBerrortext | DBfilename | DBfunction | DBguibutton | DBguiicon | DBguilabel | DBguimenu | DBguimenuitem | DBguisubmenu | DBhardware | DBinterface | DBkeycap | DBkeycode | DBkeycombo | DBkeysym | DBliteral | DBconstant | DBmarkup | DBmedialabel | DBmenuchoice | DBmousebutton | DBoption | DBoptional | DBparameter | DBprompt | DBproperty | DBreplaceable | DBreturnvalue | DBsgmltag | DBstructfield | DBstructname | DBsymbol | DBsystemitem | DBtoken | DBtype | DBuserinput | DBvarname | DBanchor | DBauthor | DBauthorinitials | DBcorpauthor | DBmodespec | DBothercredit | DBproductname | DBproductnumber | DBrevhistory | DBremark | DBsubscript | DBsuperscript | DBinlinegraphic | DBinlinemediaobject | DBinlineequation | DBsynopsis | DBcmdsynopsis | DBfuncsynopsis | DBclasssynopsis | DBfieldsynopsis | DBconstructorsynopsis | DBdestructorsynopsis | DBmethodsynopsis | DBindexterm | DBbeginpage )*
          ];;
type DBciterefentry =
       [
          (DBrefentrytitle DBmanvolnum?) ];;
type DBcitation =
       [
          ( Char | DBfootnoteref | DBxref | DBabbrev | DBacronym | DBcitation | DBciterefentry | DBcitetitle | DBemphasis | DBfirstterm | DBforeignphrase | DBglossterm | DBfootnote | DBphrase | DBquote | DBtrademark | DBwordasword | DBpersonname | DBlink | DBolink | DBulink | DBaction | DBapplication | DBclassname | DBmethodname | DBinterfacename | DBexceptionname | DBooclass | DBoointerface | DBooexception | DBcommand | DBcomputeroutput | DBdatabase | DBemail | DBenvar | DBerrorcode | DBerrorname | DBerrortype | DBerrortext | DBfilename | DBfunction | DBguibutton | DBguiicon | DBguilabel | DBguimenu | DBguimenuitem | DBguisubmenu | DBhardware | DBinterface | DBkeycap | DBkeycode | DBkeycombo | DBkeysym | DBliteral | DBconstant | DBmarkup | DBmedialabel | DBmenuchoice | DBmousebutton | DBoption | DBoptional | DBparameter | DBprompt | DBproperty | DBreplaceable | DBreturnvalue | DBsgmltag | DBstructfield | DBstructname | DBsymbol | DBsystemitem | DBtoken | DBtype | DBuserinput | DBvarname | DBanchor | DBauthor | DBauthorinitials | DBcorpauthor | DBmodespec | DBothercredit | DBproductname | DBproductnumber | DBrevhistory | DBremark | DBsubscript | DBsuperscript | DBinlinegraphic | DBinlinemediaobject | DBinlineequation | DBsynopsis | DBcmdsynopsis | DBfuncsynopsis | DBclasssynopsis | DBfieldsynopsis | DBconstructorsynopsis | DBdestructorsynopsis | DBmethodsynopsis | DBindexterm | DBbeginpage )*
          ];;
type DBacronym =
       [
          ( Char | DBacronym | DBemphasis | DBtrademark | DBlink | DBolink | DBulink | DBanchor | DBremark | DBsubscript | DBsuperscript | DBinlinegraphic | DBinlinemediaobject | DBindexterm | DBbeginpage )*
          ];;
type DBabbrev =
       [
          ( Char | DBacronym | DBemphasis | DBtrademark | DBlink | DBolink | DBulink | DBanchor | DBremark | DBsubscript | DBsuperscript | DBinlinegraphic | DBinlinemediaobject | DBindexterm | DBbeginpage )*
          ];;
type DBuserinput =
       [
          ( Char | DBlink | DBolink | DBulink | DBaction | DBapplication | DBclassname | DBmethodname | DBinterfacename | DBexceptionname | DBooclass | DBoointerface | DBooexception | DBcommand | DBcomputeroutput | DBdatabase | DBemail | DBenvar | DBerrorcode | DBerrorname | DBerrortype | DBerrortext | DBfilename | DBfunction | DBguibutton | DBguiicon | DBguilabel | DBguimenu | DBguimenuitem | DBguisubmenu | DBhardware | DBinterface | DBkeycap | DBkeycode | DBkeycombo | DBkeysym | DBliteral | DBconstant | DBmarkup | DBmedialabel | DBmenuchoice | DBmousebutton | DBoption | DBoptional | DBparameter | DBprompt | DBproperty | DBreplaceable | DBreturnvalue | DBsgmltag | DBstructfield | DBstructname | DBsymbol | DBsystemitem | DBtoken | DBtype | DBuserinput | DBvarname | DBanchor | DBremark | DBsubscript | DBsuperscript | DBinlinegraphic | DBinlinemediaobject | DBindexterm | DBbeginpage | DBco )*
          ];;
type DBtype =
       [
          ( Char | DBreplaceable | DBinlinegraphic | DBinlinemediaobject | DBindexterm | DBbeginpage )*
          ];;
type DBtoken =
       [
          ( Char | DBreplaceable | DBinlinegraphic | DBinlinemediaobject | DBindexterm | DBbeginpage )*
          ];;
type DBsystemitem =
       [
          ( Char | DBlink | DBolink | DBulink | DBaction | DBapplication | DBclassname | DBmethodname | DBinterfacename | DBexceptionname | DBooclass | DBoointerface | DBooexception | DBcommand | DBcomputeroutput | DBdatabase | DBemail | DBenvar | DBerrorcode | DBerrorname | DBerrortype | DBerrortext | DBfilename | DBfunction | DBguibutton | DBguiicon | DBguilabel | DBguimenu | DBguimenuitem | DBguisubmenu | DBhardware | DBinterface | DBkeycap | DBkeycode | DBkeycombo | DBkeysym | DBliteral | DBconstant | DBmarkup | DBmedialabel | DBmenuchoice | DBmousebutton | DBoption | DBoptional | DBparameter | DBprompt | DBproperty | DBreplaceable | DBreturnvalue | DBsgmltag | DBstructfield | DBstructname | DBsymbol | DBsystemitem | DBtoken | DBtype | DBuserinput | DBvarname | DBanchor | DBremark | DBsubscript | DBsuperscript | DBinlinegraphic | DBinlinemediaobject | DBindexterm | DBbeginpage | DBacronym | DBco )*
          ];;
type DBsymbol =
       [
          ( Char | DBreplaceable | DBinlinegraphic | DBinlinemediaobject | DBindexterm | DBbeginpage )*
          ];;
type DBstructname =
       [
          ( Char | DBreplaceable | DBinlinegraphic | DBinlinemediaobject | DBindexterm | DBbeginpage )*
          ];;
type DBstructfield =
       [
          ( Char | DBreplaceable | DBinlinegraphic | DBinlinemediaobject | DBindexterm | DBbeginpage )*
          ];;
type DBsgmltag =
       [
          ( Char | DBreplaceable | DBinlinegraphic | DBinlinemediaobject | DBindexterm | DBbeginpage )*
          ];;
type DBreturnvalue =
       [
          ( Char | DBreplaceable | DBinlinegraphic | DBinlinemediaobject | DBindexterm | DBbeginpage )*
          ];;
type DBreplaceable =
       [
          ( Char | DBlink | DBolink | DBulink | DBoptional | DBanchor | DBremark | DBsubscript | DBsuperscript | DBinlinegraphic | DBinlinemediaobject | DBco )*
          ];;
type DBproperty =
       [
          ( Char | DBlink | DBolink | DBulink | DBaction | DBapplication | DBclassname | DBmethodname | DBinterfacename | DBexceptionname | DBooclass | DBoointerface | DBooexception | DBcommand | DBcomputeroutput | DBdatabase | DBemail | DBenvar | DBerrorcode | DBerrorname | DBerrortype | DBerrortext | DBfilename | DBfunction | DBguibutton | DBguiicon | DBguilabel | DBguimenu | DBguimenuitem | DBguisubmenu | DBhardware | DBinterface | DBkeycap | DBkeycode | DBkeycombo | DBkeysym | DBliteral | DBconstant | DBmarkup | DBmedialabel | DBmenuchoice | DBmousebutton | DBoption | DBoptional | DBparameter | DBprompt | DBproperty | DBreplaceable | DBreturnvalue | DBsgmltag | DBstructfield | DBstructname | DBsymbol | DBsystemitem | DBtoken | DBtype | DBuserinput | DBvarname | DBanchor | DBremark | DBsubscript | DBsuperscript | DBinlinegraphic | DBinlinemediaobject | DBindexterm | DBbeginpage )*
          ];;
type DBprompt =
       [
          ( Char | DBreplaceable | DBinlinegraphic | DBinlinemediaobject | DBindexterm | DBbeginpage | DBco )*
          ];;
type DBparameter =
       [
          ( Char | DBlink | DBolink | DBulink | DBaction | DBapplication | DBclassname | DBmethodname | DBinterfacename | DBexceptionname | DBooclass | DBoointerface | DBooexception | DBcommand | DBcomputeroutput | DBdatabase | DBemail | DBenvar | DBerrorcode | DBerrorname | DBerrortype | DBerrortext | DBfilename | DBfunction | DBguibutton | DBguiicon | DBguilabel | DBguimenu | DBguimenuitem | DBguisubmenu | DBhardware | DBinterface | DBkeycap | DBkeycode | DBkeycombo | DBkeysym | DBliteral | DBconstant | DBmarkup | DBmedialabel | DBmenuchoice | DBmousebutton | DBoption | DBoptional | DBparameter | DBprompt | DBproperty | DBreplaceable | DBreturnvalue | DBsgmltag | DBstructfield | DBstructname | DBsymbol | DBsystemitem | DBtoken | DBtype | DBuserinput | DBvarname | DBanchor | DBremark | DBsubscript | DBsuperscript | DBinlinegraphic | DBinlinemediaobject | DBindexterm | DBbeginpage )*
          ];;
type DBoptional =
       [
          ( Char | DBlink | DBolink | DBulink | DBaction | DBapplication | DBclassname | DBmethodname | DBinterfacename | DBexceptionname | DBooclass | DBoointerface | DBooexception | DBcommand | DBcomputeroutput | DBdatabase | DBemail | DBenvar | DBerrorcode | DBerrorname | DBerrortype | DBerrortext | DBfilename | DBfunction | DBguibutton | DBguiicon | DBguilabel | DBguimenu | DBguimenuitem | DBguisubmenu | DBhardware | DBinterface | DBkeycap | DBkeycode | DBkeycombo | DBkeysym | DBliteral | DBconstant | DBmarkup | DBmedialabel | DBmenuchoice | DBmousebutton | DBoption | DBoptional | DBparameter | DBprompt | DBproperty | DBreplaceable | DBreturnvalue | DBsgmltag | DBstructfield | DBstructname | DBsymbol | DBsystemitem | DBtoken | DBtype | DBuserinput | DBvarname | DBanchor | DBremark | DBsubscript | DBsuperscript | DBinlinegraphic | DBinlinemediaobject | DBindexterm | DBbeginpage )*
          ];;
type DBoption =