After unpacking YODL's source archive, the following directories are available:
    itemization(
    it() tt(yodl): the root-directory of the YODL tree. All sources and
program maintenance scripts are found in or below this directory.
    it() tt(yodl/macros): This directory contains all the macro
definitions of the standard macro package. It contains the following
subdirectories: 
        itemization(
        it() tt(yodl/macros/in): This directory contains 
generic macro files. These macro files contain the word tt(@STD_INCLUDE@),
which is replaced by the standard include directory used in a particular
distribution.
        it() tt(yodl/macros/rawmacros): This directory contains the raw
macro definition files themselves. One file per raw macro. A raw macro
contains the implementations of that macro for em(all) supported conversion
types, and has the extension tt(.raw). Furthermore, this directory contains
some support scripts: tt(create, separator.pl, startdoc.pl).
        it() tt(yodl/macros/yodl): this is the directory to contain YODL's
standard macros. The (recursive) contents of this directory is eventually
copied by the installation procedure to the tt(.../share/yodl) directory,
which then becomes YODL's standard include directory.
        it() tt(yodl/macros/yodl/chartables): This directory contains 
character-translation tables for various target languages.
        it() tt(yodl/macros/yodl/xml): This directory contains the XML frame
files, used to convert YODL documents to XML, as implemented by the
`webplatform' of the University of Groningen. All these frame files have the
extensions tt(.xml).
        )
    it() tt(yodl/man): The raw source files of all man-pages:
manpages of the YODL program itself, of the yodl post-processor, of the
conversion scripts, of the builtin-functions, of the standard macros and of
YODL's tt(manpage) and tt(letter) document types. These raw source files have
the extensions tt(.in), indicating that they may contain tt(@STD_INCLUDE@)
words, which is replaced by the eventually used standard include path.
        itemization(
        it() tt(yodl/man/1): The destination for YODL's manual pages in
section 1 (programs).
        it() tt(yodl/man/7): The destination for YODL's manual pages in
section 7 (macro packages and conventions).
        )
    it() tt(yodl/manual): The source files of the complete
YODL manual, as well as the directories for the various converted formats.
    The script tt(build), found in this directory, constructs the manual in
the subdirectories:
        itemization(
        it() tt(yodl/manual/html): the HTML-converted manual;
        it() tt(yodl/manual/latex): the LaTeX()-version of the manual;
        it() tt(yodl/manual/pdf): the pdf-version of the manual;
        it() tt(yodl/manual/ps): the PostScript-version of the manual;
        it() tt(yodl/manual/txt): the plain text-version of the manual;
        )
    it() tt(yodl/manual/): The source files of the complete
    The YODL document files themselves are located in subdirectories of this
directory. They are:
        itemization(
        it() tt(yodl/manual/converters)
        it() tt(yodl/manual/intro)
        it() tt(yodl/manual/macros)
        it() tt(yodl/manual/technical)
        it() tt(yodl/manual/userguide) (and various subdirectories)
        )
    it() tt(yodl/scripts): support scripts used by the building process:
tt(configreplacements) replaces tt(@XXX@) words by their actual values as
found in tt(yodl/src/config.h); tt(yodl2whatever.in) is the generic
yodl-converter, calling macros specific for a particular conversion type. This
generic converter is installed in tt(.../bin/), together with specific
converters, installed as soft-links to this generic converter.
    it() YODL's base directory contains sub-directories holding the source
files of the bf(C) programs YODL and tt(yodl-post), as well as all auxiliary
directories containing sources of the (logical) components of these
programs. Most of these components are like bf(C++) classes in that they
define a building block of the YODL and/or tt(yodl-post) program. Their
organization, interaction and relationship is described below. They are:
        itemization(
        it() tt(yodl/args): the component handling the command-line
arguments; 
        it() tt(yodl/builtin): the component handling YODL's builtin
functions;
        it() tt(yodl/chartab): the component handling YODL's
character table type;
        it() tt(yodl/counter): the component handling YODL's
counter type;
        it() tt(yodl/file):  the component handling all file
operations (locating, opening, etc.);
        it() tt(yodl/hashitem): key/value combinations stored in
YODL's hashtable;
        it() tt(yodl/hashmap): YODL's hashtable;
        it() tt(yodl/lexer): YODL's lexical scanner: this component
consumes the tt(.yo) file, and produces a continuous stream of tokens to be
handled by another component: the parser.
        it() tt(yodl/lines): the component storing lines of text,
used by tt(yodl-post). 
        it() tt(yodl/macro): the component handling YODL's
macro type;
        it() tt(yodl/message): the component handling all messages
(warnings, errors, verbosity settings, etc.).
        it() tt(yodl/new): the component handling all memory
allocations (except for duplicating em(strings), which is handled by the
root-component). 
        it() tt(yodl/ostream): the component handling all YODL's
output to its output-file (YODL may also output to strings, which is not
handled by the ostream component). 
        it() tt(yodl/parser): the component handling the tokens
produced by the lexer-component. This component governs all actions to be
taken during a conversion. Its actions all derive from its function
tt(parser_process()). 
        it() tt(yodl/postqueue): the component handling the
postprocessing required by most conversions.
        it() tt(yodl/process): the component handling the execution
of child- or system-processes.
        it() tt(yodl/queue): the component allowing the lexical
scanner to queue its input, awaiting further processing. 
        it() tt(yodl/root): the component defining some basic
typedefs and enumerations, as well as the tt(new_str()) function duplicating a
string, and the tt(out_of_memory()) function handling memory allocation
failures. 
        it() tt(yodl/stack): the component implementing a stack
data structure.
        it() tt(yodl/string):  the component implementing a
text-storage data structure and its functionality.
        it() tt(yodl/strvector):  the component implementing a table of
tt(SUBST) key-value pairs.
        it() tt(yodl/subst):  the component handling YODL's
SUBST definitions;
        it() tt(yodl/symbol):  the component handling YODL's
symbol type;
        it() tt(yodl/yodl): the sources of the YODL program
itself. This directory also contains the implementations of all builtin
functions, whose filenames all start with tt(gram_) (E.g.,
tt(gramaddtocounter.c)). 
        it() tt(yodl/yodlpost): the sources of the tt(yodl-post)
program. 
        )
    The script tt(build), found in this directory, compiles  the programs
and macros, storing them in:
        itemization(
        it() tt(tmp/install/usr/bin) (the binary programs)
        it() tt(tmp/install/usr/share/yodl) (the macros)
        it() tt(tmp/install/usr/share/man) (the man-pages)
        it() tt(tmp/install/usr/share/doc) (the manual and additional
                documentation) 
        )
    )
