Yodl macros(7)            Your Own Document Language            Yodl macros(7)



NAME
       yodlmacros - Macros for the Yodl converters

SYNOPSIS
       This manual page lists the standard macros of the Yodl package.

DESCRIPTION
       The following list shows the macros defined by the Yodl converters
       define and which can be used in Yodl documents. Refer to the Yodl user
       guide, distributed with the Yodl package, for a full description.

       The following list shows all macros of the package in alphabetical
       order.

       `abstract(text)'
              Defines an abstract for an article or report type of document.
              Abstracts are not implemented for books or manpages. Must appear
              before starting the document using the `article' or `report'
              macro.

       `addntosymbol(symbol)(n)(text)'
              Adds `text' `n' times to `symbol'. The value `n' may also be the
              name of a defined counter (which is not modified).

       `affiliation(site)'
              Defines an affiliation, to appear in the document titlepage
              below the author field. Must appear before starting the document
              with `article', `report' or `book'. The affiliation is only
              printed when the author field is not empty. When converting to
              html the way the affiliation is displayed can be tuned using CSS
              id selector specifications. The affiliation has
              `id="affiliation"'.

       `AfourEnlarged()'
              Enlarges the usable height of A4 paper by 2 cm.: the top margin
              is reduced by 2 cm. This macro should be called in the preamble.
              The macro is available only for LaTeX conversions.
              This macros is somewhat obsolete. Instead, using `PageEnlarged'
              is advised

       `appendix()'
              Starts appendices

       `article(title)(author)(date)'
              Starts an article. The top-level sectioning command is
              `(n)sect'. In HTML conversions only one output file is written,
              while the way the headings are displayed can be tuned using CSS
              id selector specifications: the title has `id="title"', the
              author `id="author"', and the date `id="date"'.)

       `attrib(text)'
              In html, pushes `text' as an attribute for the next html tag
              supporting `attrib'.  E.g, to set a blue color and 30 pixel
              left-hand side margin for a section use

                  attrib(style="color:blue;margin-left:30px;")\
                  sect(Section name)

              This results in the html markup

                  <h1 style="color:blue;margin-left:30px;">Section name</h1>

              This macro is only effective with html conversions. It is
              applied in a stack-wise fashion: when multiple `attrib' calls
              are used, then the topmost attrib-string is added to the first
              macro calling the `attribinsert' macro, with subsequent macros
              using subsequent elements on the attrib-stack.

              Commonly used attributes are `id="idname"', expecting a
              `#idname' CSS label in either internal or external CSS
              specifications, or `style="spec"' (as shown in the example).

              Example: when using

                  attrib(width = "100" height = "100")
                  attrib(id = "#fig")
                  figure(imgfile)(Caption)(IMG)

              then the `#id' attribute is applied to `<figure>', and the
              `width' and `height' attributes are applied to `<img>', which
              html markup is inserted by the `figure' macro.

              The `attrib' macro is supported by the following predefined
              macros (between parentheses the number of attribute strings that
              are inserted by these macros; if only 1 attribute string is
              inserted no number is shown):

              `bf cell cells center chapter code dashes dit em figure(3) file
              htmltag itdesc lchapter link lref lsect lsubsect lsubsubsect
              nchapter npart nsect nsubsect nsubsubsect paragraph part quote
              row sc sect strong subs subsect subsubsect subsubsubsect sups
              tableatt tbl tac tc tnac tnc tr tt ttbegin url verb verborg
              verbinclude'.

       `attribclear()'
              Removes any existing contents from the attrib-stack. This macro
              is only active when converting to html

       `attribinsert()'
              In html, if the attrib-stack is not empty, inserts the value on
              top of the attrib-stack and then pops the topmost value.  If the
              attrib-stack is empty, nothing happens.

       `bf(text)'
              Sets `text' in boldface.

       `bind(text)'
              Generate a binding character (non-breaking space) after text.

       `book(title)(author)(date)'
              Starts a book document. The top-level sectioning command is
              `(n)chapter', `(n)part' being optional. In HTML output files are
              created for each chapter, while the way the headings are
              displayed can be tuned using CSS id selector specifications: the
              title has `id="title"', the author `id="author"', and the date
              `id="date"'.)

       `cell(contents)'
              Sets a table cell, i.e., one element in a row. With the man/ms
              converters multiple blanks between `cell()' macro calls are
              merged into a single blank character.

              Instead of using `cell' in `table', consider using `tc' in
              `tbl'.

       `cells(nColumns)(contents)'
              Set a table cell over `nColumns' columns. With LaTeX and xml the
              information in the combined cells is centered.

              With man/ms conversions the `cells()' macro simply calls the
              `cell()' macro, but here the `setmanalign()' macro can be used
              to determine the alignment of multiple cells.

              With html the macro `attrib' can be used, but when it contains a
              `style' specification the macro's default `style="text-align:
              center"' is ignored (but it can optionally be specified using
              the `attrib' macro).

              Instead of using `cells' in `table', consider using `tnc' in
              `tbl'.

       `cellsline(from)(count)'
              Sets a horizontal line starting at column number `from' over
              `count' columns in a row. If `from' is less then the number of
              columns already added to a row then it is ignored. This macro
              must be embedded in a `row' macro defining a table row.  To put
              a line across the table's full width use `rowline'. To set
              horizontal lines across columns 1 until 2 and columns 4 until 5
              table of a table use:

                  row(cellsline(1)(2)cellsline(4)(2))

              Combining `cellsline' and `cell' or `cells' calls in one row
              produces undefined results.

              Instead of using `cellsline' in `table', consider using `tline'
              in `tbl'.

       `center(text)'
              Centers `text'. Use `nl()' in the text to break lines.  In html
              the `attrib' macro is not supported, but a division (`div') with
              style definition `text-align: center' is used. To center a table
              in html use the `tableatt' macro. If a `table' or `tableatt'
              macro is used inside a `center' macro then the contents of
              columns are column-wise centered.

              Inside a `center(...)' context the counter `XXcenter' is unequal
              0.

       `chapter(title)'
              Starts a new chapter in books or reports.

       `cindex()'
              Generate an index entry for LaTex() or texinfo c-indices. Its
              argument is the index entry.  See also the `[fptv]index' macro.

       `cite(text)'
              Sets `text' as a citation or quotation

       `clearpage()'
              Starts a new page, when the output format permits. Under HTML a
              horizontal line is drawn.

       `code(text)'
              Sets `text' in code font, and prevents it from being expanded.
              For unbalanced parameter lists, use `CHAR(40)' to get `(' and
              `CHAR(41)' to get `)'.

       `columnline(from)(through)'
              Sets a horizontal line over some columns in a row. Note that
              `columnline' defines a row by itself, consisting of just a
              horizontal line spanning some of its columns, rather than the
              table's full width, like `rowline'. The two arguments represent
              column numbers. It is the responsibility of the author to make
              sure that the `from' and `through' values are sensible. I.e.,

                  1 <= from <= through <= ncolumns

              To set a horizontal line in just one column select `through'
              equal to `from'.

              Note: this macro cannot be used if multiple lines must be set in
              one row. In those cases the macros `tline, tskip', and
              `tendline' should be used.

              Instead of using `columnline' in `table', consider using `tline'
              in `tbl'.

       `dashes()'
              Inserts two dashes in teletype font, and prevents them from
              being expanded.

              In html the `attrib' macro is recognized by the `<code>' tag
              that is used to embed the two dashes.

       `def(macroname)(nrofargs)(redefinition)'
              Defines `macroname' as a macro, having `nrofargs' arguments, and
              expanding to `redefinition'. This macro is a shorthand for
              `DEFINEMACRO'. An error occurs when the macro is already
              defined. Use `redef()' to unconditionally define or redefine a
              macro.

       `description(list)'
              Sets `list' as a description list. Use `dit(item)' to indicate
              items in the list.

       `dit(itemname)'
              Starts an item named `itemname' in a description list. The list
              should be used in `description' macros. With `html' conversions
              the contents of a description item is separated from the item
              itself. The `dit' macro only defines the item, and not the
              description itself. This macro sets the item in bold-face
              (`strong' font). The macro `itdesc', available since Yodl 3.05,
              can be used to defines an item and its description, using its
              suggested format (i.e., indenting the description relative to
              the item).

       `eit()'
              Indicates an item in an enumerated list. The `eit' macro should
              be used as an argument in `enumeration' macros.

       `ellipsis()'
              Sets ellipsis (...).

       `em(text)'
              Sets `text' as emphasized, usually italics.

       `email(address)'
              In HTML, this macro sets the `address' in a `<a
              href="mailto=..">' locator. In other output formats, the
              `address' is sent to the output. The `email' macro is a special
              case of `url'.

       `enumeration(list)'
              `enumeration()' starts an enumerated list. Use `eit()' in the
              list to indicate items in the list.

       `euro()'
              Sets the euro currency symbol in latex, html, (and possibly sgml
              and xml). In all other conversions EUR which is the official
              textual abbreviation (cf. http://ec.europa.eu/euro/entry.html)
              is written. Note that LaTeX may require latexpackage()(eurosym).

       `evalsymbol(symbol)(expression)'
              Symbol symbol receives the value resulting from evaluating
              expression. E.g., if `sym' is a defined symbol, then

                  evalsymbol(sym)(SUBSTR(hello world)(3)(2))

              assigns the value `lo' to `sym'.

       `fig(label)'
              This macro is a shorthand for `figure ref(label)' and just makes
              the typing shorter, as in `see fig(schematic) for ..' See
              `getfigurestring()' and `setfigurestring()' for the `figure'
              text.

       `figure(file)(caption)(label)'
              Sets the picture in `file' as a figure in the current document,
              using the descriptive text `caption'. The `label' is defined as
              a placeholder for the figure number and can be used in a
              corresponding `ref' statement. Note that the `file' must be the
              filename without extension: By default, Yodl will supply `.gif'
              when in HTML mode, or `.ps' when in LaTeX mode. Figures in other
              modes may not (yet) haven been implemented.

              When converting to html, this macro uses three attribute-strings
              (if available). The string pushed first using an attrib-call
              defines the attributes for its `<figcaption>' html-markup; the
              string pushed next defines the attributes for its `<img>'
              html-markup; the string pushed last defines the attributes for
              its `<figure>' html-markup. The `figure' macro's html output is
              organized like this:

                  <figure -attrib-string pushed last (if any)>
                      <img ... -attrib-string pushed last but one>
                      <figcaption -attrib-string pushed 2nd to last>
                          ...
                      </figcaption>
                  </figure>

              Starting with Yodl 3.07.00 no `alt="Figure # is shown here..."'
              attribute is defined anymore for the `img' markup: an
              `alt'-attribute can easily be defined at the last attrib-call,
              using `getfigurestring()' to obtain `Figure' or its
              language-specific translation, and
              `COUNTERVALUE(XXfigurecounter)' to obtain the order-number of
              the figure shown in the next `figure'-macro call.

       `file(text)'
              Sets `text' as filename, usually boldface.  In html `attrib'
              macro applies to the `<strong>' tag.

       `findex()'
              Generate an index entry for LaTex() or texinfo f-indices. Its
              argument is the index entry.  See also the `[cptv]index' macro.

       `footnote(text)'
              Sets `text' as a footnote, or between parentheses when the
              output format does not allow footnotes.

       `gagmacrowarning(name name ...)'
              Prevents the `yodl' program from printing cannot expand possible
              user macro. E.g., if you have in your document `the file(s) are
              ..' then you might want to put before that:
              `gagmacrowarning(file)'. Calls `NOUSERMACRO'.

       `getaffilstring()'
              Expands to the string that defines the name of Affiliation
              Information, by default AFFILIATION INFORMATION. Can be
              redefined for national language support by `setaffilstring()'.
              Currently, it is relevant only for txt.

       `getauthorstring()'
              Expands to the string that defines the name of Author
              Information, by default AUTHOR INFORMATION. Can be redefined for
              national language support by `setauthorstring()'. Currently, it
              is relevant only for txt.

       `getchapterstring()'
              Expands to the string that defines a `chapter' entry, by default
              Chapter.  Can be redefined for national language support by
              `setchapterstring()'.

       `getdatestring()'
              Expands to the string that defines the name of Date Information,
              by default DATE INFORMATION. Can be redefined for national
              language support by `setdatestring()'. Currently, it is relevant
              only for txt.

       `getfigurestring()'
              Returns the string that defines a `figure' text, in captions or
              in the `fig()' macro. The string can be redefined using the
              `setfiguretext()' macro.

       `getpartstring()'
              Expands to the string that defines a `part' entry, by default
              Part. Can be redefined for national language support by
              `setpartstring()'.

       `gettitlestring()'
              Expands to the string that defines the name of Title
              Information, by default TITLE INFORMATION. Can be redefined for
              national language support by `settitlestring()'. Currently, it
              is relevant only for txt.

       `gettocstring()'
              Expands to the string that defines the name of the table of
              contents, by default Table of Contents. Can be redefined for
              national language support by `settocstring()'.

       `htmlcommand(cmd)'
              Writes `cmd' to the output when converting to html. The `cmd' is
              not further expanded by Yodl.

       `htmlheadfile(file)'
              Adds the contents of `file' to the `head' section of an HTML
              document. The contents of file are not interpreted and should
              contain plain html text. This option can be useful when large
              bodies of text, like the contents of `<script>' sections, must
              be included into the head section of html documents. This macro
              is only active in the preamble, should only specified once, and
              is only interpreted for html conversions.

       `htmlheadopt(option)'
              Adds the literal text `option' to the current information in the
              `head' section of an HTML document. `Option' may (or: should)
              contain plain html text. A commonly occurring head option is
              `link', defining, e.g., a style sheet. Since that option is
              frequently used, it has received a dedicated macro:
              `htmlstylesheet'. When large bodies of html-text must be added
              to html documents the macro `htmlheadfile' should be used. This
              macro is only active in the preamble and is only interpreted for
              html conversions.

       `htmlnewfile()'
              In HTML output, starts a new file. All other formats are not
              affected. Note that you must take your own provisions to access
              the new file; say via links.  Also, it's safe to start a new
              file just befoore opening a new section, since sections are
              accessible from the clickable table of contents. The HTML
              converter normally only starts new files prior to a `chapter'
              definition.

       `htmlstyle(tag)(definition)'
              Adds a `<style type="text/css"> ... </style>' element to the
              head section of an HTML document.
              Use `htmlstyle' to specify one or more CSS definitions which are
              eventually inserted at the ellipsis (`...') in the generic
              `style' definition shown above. E.g., (using `#rrggbb' to
              specify a color, where `rr' are two hexadecimal digits
              specifying the color's red component, `gg' two hexadecimal
              digits specifying the color's green component, and `bb' two
              hexadecimal digits specifying the color's blue component)
              specifying

                  htmlstyle(body)(color: #rrggbb; background-color: #rrggbb)
                  htmlstyle(h1)(color: blue; text-align: center)
                  htmlstyle(h2)(color: green)

              results in the element

                  <style type="text/css">
                      body {color: #rrggbb; background-color: #rrggbb;}
                      h1 {color: blue; text-align: center;}
                      h2 {color: green;}
                  </style>

              The macros `htmlheadopt' and `htmlstylesheet' could also be used
              to put information into the head-section of an HTML document,
              but `htmlheadopt' is of a much more general nature, while
              `htmlstylesheet' refers to CSS elements stored in an external
              file. The macro `attrib' can be used to define inline styles.

              The `htmlstyle' macro is only active in the preamble and is only
              interpreted for html conversions.
              Refer to available CSS specifications (cf.,
              http://www.w3schools.com/cssref/ for an overview of how CSS
              specifications are used, and which CSS specifications are
              available).

              By default the internal style specification
              `figure {text-align: center;} img {vertical-align: center;}'
              is used. If this is not appropriate, specify `nohtmlimgstyle()'
              in the preamble.

       `htmlstylesheet(url)'
              Adds a `<link rel="stylesheet" type="text/css" ...>' element to
              the head section of an HTML document, using `url' in its `href'
              field. The argument `url' is not expanded, and should be plain
              HTML text, without surrounding quotes. The macro `htmlheadopt'
              can also be used to put information in the head-section of an
              HTML document, but `htmlheadopt' is of a much more general
              nature.  This macro is only active in the preamble and is only
              interpreted for html conversions.

       `htmltag(tagname)(start)'
              Sets `tagname' as a HTML tag, enclosed by `<' and `>'. When
              `start' is zero, the `tagname' is prefixed with `/'. As not all
              html tags are available through predefined Yodl-macros (there
              are too many of them, some are used very infrequently, and you
              can easily define macros for the tags for which Yodl doesn't
              offer predefined ones), the `htmltag' macro can be used to
              handle your own set of macros. In html the `attrib' macro is
              supported. E.g.,

              attrib(title="World Health Organization")    htmltag(abbr)()WHO+htmltag(abbr)(0)



       `ifnewparagraph(truelist)(falselist)'
              The macro `ifnewparagraph' should be called from the `PARAGRAPH'
              macro, if defined. It will insert `truelist' if a new paragraph
              is inserted, otherwise `falselist' is inserted (e.g., following
              two consecutive calls of PARAGRAPH). This macro can be used to
              prevent outputting multiple blank lines.

       `includefile(file)'
              Includes `file'. The default extension `.yo' is supplied if
              necessary.

              Since Yodl version 3.00.0 Yodl's default file inclusion behavior
              has changed. The current working directory no longer remains
              fixed at the directory in which Yodl is called, but is volatile,
              changing to the directory in which a yodl-file is located. This
              has the advantage that Yodl's file inclusion behavior now
              matches the way C's `#include' directive operates. The
              originally implemented file inclusion behavior is used when
              Yodl's `-L' (`--legacy-include') option is used.

       `includeverbatim(file)'
              Include `file' into the output.  No processing is done, `file'
              should be in preformatted form, e.g.:
              whenhtml(includeverbatim(foo.html))


       `it()' Indicates an item in an itemized list. Items in `it' macros are
              arguments of `itemization' macros.

       `itdesc(itemname)(contents)'
              Starts an item and its description in a description list. Its
              name is `itemname', the contents of the item is defined by
              `contents'. The `itemname' is defined by using the `dit' macro.

              With `html' conversions the contents are surrounded by `<dd>'
              and `</dd>' tags, resulting in contents which are indented
              relative to the itemname. When the `attrib' macro is used it is
              applied to the itemname (`dt'-tags).

              With other conversions the `contents' are quoted (as if using
              `quote(contents)').

       `itemization(list)'
              Sets `list' as an itemizationd list. Use `it()' to indicate
              items in the list.

       `kindex()'
              Generate an index entry for LaTex() or texinfo k-indices. Its
              argument is the index entry.  See also the `[cfptv]vindex'
              macro.

       `label(labelname)'
              Defines `labelname' as an anchor for a `link' command, or to
              stand for the last numbering of a section or figure in a `ref'
              command.

       `langle()'
              Character <

       `languagedutch()'
              Defines the Dutch-language specific headers. Active this macro
              via setlanguage(dutch).

       `languageenglish()'
              Defines the English-language specific headers. Active this macro
              via setlanguage(english).

       `languageportugese()'
              Defines the Portugese-language specific headers. Active this
              macro via setlanguage(portugese).

       `LaTeX()'
              The LaTeX symbol.

       `latexaddlayout(arg)'
              This macro is provided to add Yodl-interpreted text to  your own
              LaTeX layout commands. The command is terminated with an
              end-of-line.  See also the macro `latexlayoutcmds()'

       `latexcommand(cmd)'
              Writes `cmd' plus a white space to the output when converting to
              LaTeX. The `cmd' is not further expanded by Yodl.

       `latexdocumentclass(class)'
              Forces the LaTeX `\documentclass{...}' setting to `class'.
              Normally the class is defined by the macros `article', `report'
              or `book'.  This macro is an escape route in case you need to
              specify your own document class for LaTeX. This option is a
              modifier and must appear before the `article', `report' or
              `book' macros.

       `latexlayoutcmds(NOTRANSs)'
              This macro is provided in case you want to put your own LaTeX
              layout commands into LaTeX output. The `NOTRANSs' are pasted
              right after the `\documentclass' stanza. The default is, of
              course, no local LaTeX commands. Note that this macro does not
              overrule my favorite LaTeX layout. Use `nosloppyhfuzz()' and
              `standardlayout()' to disable my favorite LaTeX layout.

       `latexoptions(options)'
              Set latex options: `documentclass[options]'.  This command must
              appear before the document type is stated by `article',
              `report', etc..

       `latexpackage(options)(name)'
              Include latex package(s), a useful package is, e.g., `epsf'.
              This command must appear before the document type is stated by
              `article', `report', etc..

       `lchapter(label)(title)'
              Starts a new chapter in books or reports, setting a label at the
              beginning of the chapter.

       `letter(language)(date)(subject)(opening)(salutation)(author)'
              Starts a letter written in the indicated language. The date of
              the letter is set to `date', the subject of the letter will be
              `subject'. The letter starts with `opening'. It is based on the
              `letter.cls' document class definition.  The macro is available
              for LaTeX only. Preamble command suggestions:

       o      `latexoptions(11pt)'

       o      `PageEnlarged(2cm)(2cm)(1.5cm)(3cm)'

       o      `letterreplyto(name)(address)(postalcode/city)'

       o      `letterfootitem(phone)(number)', maybe e-mail too.

       o      `letteradmin(yourdate)(yourref)'

       o      `letterto(addressitem)'. Use a separate `letterto()' macro call
              for each new line of the address.


       `letteraddenda(type)(value)'
              Adds an addendum at the end of a letter. `type' should be
              `bijlagen', `cc' or `ps'.

       `letteradmin(yourdate)(yourref)'
              Puts `yourletterfrom' and `yourreference' elements in the
              letter. If left empty, two dashes are inserted.

       `letterfootitem(name)(value)'
              Puts a footer at the bottom of letter-pages. Up to three will
              usually fit.  LaTeX only.

       `letterreplyto(name)(address)(zip city)'
              Defines the `reply to' address in LaTeX or txt-letters.

       `letterto(element)'
              Adds `element' as an additional line to the address in LaTeX
              letters.

       `link(description)(labelname)'
              In HTML output a clickable link with the text `description' is
              created that points to the place where `labelname' is defined
              using the `label' macro, and `attrib' macro applies to the `<a>'
              tag.  Using `link' is similar to `url', except that a hyperlink
              is set pointing to a location in the same document. For output
              formats other than HTML, only the `description' appears.

       `lref(description)(labelname)'
              This macro is a combination of the `ref' and `link' macros. In
              HTML output a clickable link with the text `description' and the
              label value is created that points to the place where
              `labelname' is defined using the `label' macro, and `attrib'
              macro applies to the `<a>' tag. For output formats other than
              HTML, only the `description' and the label value appears.

       `lsect(label)(title)'
              Starts a new section, setting a label at the beginning of the
              section.  In html `attrib' macro applies to the `<h2>' tag.

       `lsubsect(label)(title)'
              Starts a new subsection. Other sectioning commands are
              `subsubsect' and `subsubsubsect'. A label is added just before
              the subsection.  In html `attrib' macro applies to the `<h3>'
              tag.

       `lsubsubsect(label)(title)'
              Starts a sub-subsection, a label is added just before the
              section In html `attrib' macro applies to the `<h4>' tag.

       `lsubsubsubsect(label)(title)'
              Starts a sub-sub-sub section. This level of sectioning is not
              numbered, in contrast to `higher' sectionings. A label is added
              just before the subsubsubection.

       `lurl(locator)'
              An url described by its Locator.  For small urls with readable
              addresses.

       `mailto(address)'
              Defines the default `mailto' address for HTML output. Must
              appear before the document type is stated by `article',
              `report', etc..

       `makeindex()'
              Make index for latex.

       `mancommand(cmd)'
              Writes `cmd' to the output when converting to man. The `cmd' is
              not further expanded by Yodl.

       `manpage(title)(section)(date)(source)(manual)'
              Starts a manual page document. The `section' argument must be a
              number, stating to which section the manpage belongs to. Most
              often used are commands (1), file formats (5) and macro packages
              (7). The sectioning commands in a manpage are not `(n)sect'
              etc., but `manpage...()'. The first section must be the
              `manpagename', the last section must be the `manpageauthor'. The
              standard manpage for section 1 contains the following sections
              (in the given order): `manpagename', `manpagesynopsis',
              `manpagedescription', `manpageoptions', `manpagefiles',
              `manpageseealso', `manpagediagnostics', `manpagebugs',
              `manpageauthor'. Optional extra sections can be added with
              `manpagesection'. Standard manpageframes for several
              manpagesections are provided in
              `/usr/local/share/yodl/manframes'. YODL manual pages can be
              converted to `groff, html', or plain ascii text formats.

       `manpageauthor()'
              Starts the AUTHOR entry in a `manpage' document. Must be the
              last section of a `manpage'.

       `manpagebugs()'
              Starts the BUGS entry in a `manpage' document.

       `manpagedescription()'
              Starts the DESCRIPTION entry in a `manpage' document.

       `manpagediagnostics()'
              Starts the DIAGNOSTICS entry in a `manpage' document.

       `manpagefiles()'
              Starts the FILES entry in a `manpage' document.

       `manpagename(name)(short description)'
              Starts the NAME entry in a `manpage' document. The short
              description is used by, e.g., the `whatis' database.

       `manpageoptions()'
              Starts the OPTIONS entry in a `manpage' document.

       `manpagesection(SECTIONNAME)'
              Inserts a non-required section named `SECTIONNAME' in a
              `manpage' document. This macro can be used to augment `standard'
              manual pages with extra sections, e.g., EXAMPLES. Note that the
              name of the extra section should appear in upper case, which is
              consistent with the normal typesetting of manual pages.

       `manpageseealso()'
              Starts the SEE ALSO entry in a `manpage' document.

       `manpagesynopsis()'
              Starts the SYNOPSIS entry in a `manpage' document.

       `manttquoted(onOff)'
              With man-conversions arguments of tt macros are displayed as
              normal text. To enhance their visibility arguments of tt macros
              may be quoted, in which case they are surrounded by backtics and
              normal quotes. By default arguments of tt macros are not quoted.
              Quotation is used after calling `manttquoted(1)', and is
              suppressed after calling `manttquoted(0)'. The macro is only
              active when converting to man.

       `mbox()'
              Unbreakable box in LaTeX. Other formats may have different
              opitions on our unbreakable boxex.

       `metaC(text)'
              Put a line comment in the output.

       `metaCOMMENT(text)'
              Write format-specific comment to the output.

       `mscommand(cmd)'
              Writes `cmd' to the output when converting to ms. The `cmd' is
              not further expanded by Yodl.

       `nbsp(count)'
              Inserts `count' `non-breaking space' characters into the
              generated output; i.e., the space character is not optimized
              away. If the argument list is empty one non-breaking space is
              inserted.

       `nchapter(title)'
              Starts a chapter (in a `book' or `report') without generating a
              number before the title and without placing an entry for the
              chapter in the table of contents.  In html `attrib' macro
              applies to the `<h1>' tag.

       `nemail(name)(address)'
              Named email.  A more consistent naming for url, lurl, email and
              nemail would be nice.

       `nl()' Forces a newline; i.e., breaks the current line in two.

       `nodeprefix(text)'
              Prepend text to node names, e.g.
              nodeprefix(LilyPond) sect(Overview)
              Currently used in texinfo descriptions only.

       `nodeprefix(text)'
              Prepend text to node names, e.g.
              nodeprefix(LilyPond) sect(Overview)
              Currently used in texinfo descriptions only.

       `nodetext(text)'
              Use text as description for the next node, e.g.
              nodetext(The GNU Music Typesetter)chapter(LilyPond)
              Currently used in texinfo descriptions only.

       `nohtmlfive()'
              Starting yodl 3.05 html-conversions by default use html5. This
              can be suppressed (in favor of using html4) by calling this
              macro. This macro merely suppresses writing the initial
              `<!DOCTYPE html>' to generated html files; it is only active in
              the preamble and is only interpreted for html conversions.

       `nohtmlimgstyle()'
              By default html-pages specify
              `(<style type="text/css" img {vertical-align:
              bottom;}></style>)'
              This macro suppresses this `img' CSS style specification. This
              macro is only active in the preamble and is only interpreted for
              html conversions.

       `nop(text)'
              Expand to text, to avoid spaces before macros e.g.: a. Although
              a+sups(2) should have the same effect.

       `nosloppyhfuzz()'
              By default, LaTeX output contains commands that cause it to shut
              up about hboxes that are less than 4pt overfull. When
              `nosloppyhfuzz()' appears before stating the document type,
              LaTeX complaints are `vanilla'.

       `notableofcontents()'
              Prevents the generation of a table of contents. This is default
              in, e.g., `manpage' and `plainhtml' documents. When present,
              this option must appear before stating the document type with
              `article', `report' etc..

       `notitleclearpage()'
              Prevents the generation of a `clearpage()' instruction after the
              typesetting of title information. This instruction is default in
              all non `article' documents. When present, must appear before
              stating the document type with `article', `book' or `report'.

       `notocclearpage()'
              With the LaTeX converter, no `clearpage()' instruction is
              inserted immediately beyond the document's table of contents.
              The `clearpage()' instruction is default in all but the
              `article' document type. When present, must appear before
              stating the document type with `article', `book' or `report'.
              With other converters than the LaTeX converter, it is ignored.

       `notransinclude(filename)'
              Reads filename and inserts it literally in the text not subject
              to macro expansion or character translation.  No information is
              written either before or after the file's contents, not even a
              newline.

       `noxlatin()'
              When used in the preamble, the LaTeX converter disables the
              inclusion of the file `xlatin1.tex'. Normally this file gets
              included in the LateX output files to ensure the conversion of
              high ASCII characters (like e) to LaTeX-understandable codes.
              (The file `xlatin1.tex' comes with the YODL distribution.)

       `nparagraph(title)'
              Starts a non-numbered paragraph (duh, corresponds to
              subparagraph in latex).

       `npart(title)'
              Starts a part in a `book' document, but without numbering it and
              without entering the title of the part in the table of contents.
              In html `attrib' macro applies to the `<h1>' tag.

       `nsect(title)'
              Starts a section, but does not generate a number before the
              `title' nor an entry in the table of contents. Further
              sectioning commands are `nsubsect', `nsubsubsect' and
              `nsubsubsubsect'.  In html `attrib' macro applies to the `<h2>'
              tag.

       `nsubsect(title)'
              Starts a non-numbered subsection.  In html the `attrib' macro
              applies to the `<h3>' tag.

       `nsubsubsect(title)'
              Starts a non-numbered sub-sub section.  In html `attrib' macro
              applies to the `<p>' tag.

       `nsubsubsect(title)'
              Starts a non-numbered sub-subsection.

       `PageEnlarged(up)(height)(left)(width)'
              Enlarges the usable width and height of printed pages: the first
              line printed on paper is moved up by `up' units, the usable
              paper height is enlarged by `height' units, the left margin is
              moved to the left by t(left) units, and the usable paper width
              is enlarged by (width) units.  E.g., A4 pages are by default
              using relatively small text blocks. Instead the pages can be
              used more efficiently by specifying .  his macro should be
              called in the preamble. The macro is available only for LaTeX
              conversions.

       `paragraph(title)'
              Starts a paragraph. This level of sectioning is not numbered, in
              contrast to `higher' sectionings (duh, corresponds to
              subparagraph in latex).  In html `attrib' macro applies to the
              `<p>' tag.

       `part(title)'
              Starts a new part in a `book' document.  In html `attrib' macro
              applies to the `<h1>' tag.

       `pindex()'
              Generate an index entry for LaTex() or texinfo p-indices. Its
              argument is the index entry.  See also the `[cftv]index' macro.

       `plainhtml(title)'
              Starts a document for only a plain HTML conversion. Not
              available in other output formats. Similar to `article', except
              that an author- and date field are not needed.

       `printindex()'
              Make index for texinfo (?).

       `quote(text)'
              Sets the text as a quotation. Usually, the text is indented,
              depending on the output format. In html the `attrib' macro is
              recognized by the `<blockquote>' tag.

       `rangle()'
              Inserts the right angle character (>).

       `redef(macro)(nrofargs)(redefinition)'
              Defines macro `macro' to expand to `redefinition'.  Similar to
              `def', but any pre-existing definition is overruled. Use `ARG'x
              in the redefinition part to indicate where the arguments should
              be pasted. E.g., `ARG1' places the first argument, `ARG2' the
              second argument, etc...

       `redefinemacro(macro)(nrofargs)(redefinition)'
              Defines macro `macro' to expand to `redefinition'.  Similar to
              `def', but any pre-existing definition is overruled. Use `ARG'x
              in the redefinition part to indicate where the arguments should
              be pasted. E.g., `ARG1' places the first argument, `ARG2' the
              second argument, etc... This commands is actually calling
              redef().

       `ref(labelname)'
              Sets the reference for `labelname'. Use `label' to define a
              label.

       `report(title)(author)(date)'
              Starts a report type document. The top-level sectioning command
              in a report is `chapter'. In html the way the headings are
              displayed can be tuned using CSS id selector specifications: the
              title has `id="title"', the author `id="author"', and the date
              `id="date"'.

       `roffcmd(dotcmd)(sameline)(secondline)(thirdline)'
              Sets a t/nroff command that starts with a dot, on its own line.
              The arguments are: `dotcmd' - the command itself, e.g., `.IP';
              `sameline' - when not empty, `sameline' is set on the same line,
              following the `dotcmd'; `secondline' - when not empty, is set on
              the next line; `thirdline' - when not empty, is set on the third
              line. Note: `dotcmd' and `thirdline' are not further expanded by
              YODL, the other arguments are.

       `row(contents)'
              The argument `contents' may contain a man-page alignment
              specification (only one specification can be entered per row),
              using `setmanalign()'. If omitted, the standard alignment is
              used. Furthermore it contains the contents of the elements of
              the row, using `cell()' or `cells()' macros. If `cells()' is
              used, `setmanalign()' should have been used too. In this macro
              call only the `cell()', `cells()' and `setmanalign()' macros
              should be called. Any other macro call may produce unexpected
              results.

              The `row' macro defines a counter `XXcol' that can be inspected
              and is incremented by predefined macros adding columns to a row.
              The counter is initially 0. Predefined macros adding columns to
              a row add the number of columns they add to the row inserting
              the contents of those columns.  These macros rely on the correct
              value of this counter and any user-defined macros adding columns
              to table rows should correctly update `XXcol'.  In html `attrib'
              macro applies to the `<tr>' tag.

              Instead of using `row' in `table', consider using `tr' in `tbl'.

       `rowline()'
              Sets a horizontal line over the full width of the table. See
              also the `columnline' macro. Use `rowline' instead of a `row'
              macro call to provide a table with a horizontal line-separator.

              Instead of using `rowline' consider using `tline' in a `tbl'
              argument.

       `sc(text)'
              Set `text' in the tt (code) font, using small caps.  In html the
              `attrib' macro is not supported, while the code section is
              embedded in a `<div style="font-size: 90%">' section.

       `sect(title)'
              Starts a new section. In html the `attrib' macro is recognized
              by the `<h2>' tag.

       `setaffilstring(name)'
              Defines `name' as the `affiliation information' string, by
              default AFFILIATION INFORMATION. E.g., after
              `setaffilstring(AFILIACION)', YODL outputs this Spanish string
              to describe the affiliation information.  Currently, it is
              relevant only for txt.

       `setauthorstring(name)'
              Defines `name' as the `Author information' string, by default
              AUTHOR INFORMATION. E.g., after `setauthorstring(AUTOR)', YODL
              outputs this portuguese string to describe the author
              information.  Currently, it is relevant only for txt.

       `setchapterstring(name)'
              Defines `name' as the `chapter' string, by default Chapter.
              E.g., after `setchapterstring(Hoofdstuk)', YODL gains some
              measure of national language support for Dutch. Note that LaTeX
              support has its own NLS, this macro doesn't affect the way LaTeX
              output looks.

       `setdatestring(name)'
              Defines `name' as the `date information' string, by default DATE
              INFORMATION. E.g., after `setdatestring(DATA)', YODL outputs
              this portuguese string to describe the date information.
              Currently, it is relevant only for txt.

       `setfigureext(name)'
              Defines the `name' as the `figure' extension. The extension
              should include the period, if used. E.g., use setfigureext(.ps)
              if the extensions of the figure-images should end in `.ps'

       `setfigurestring(name)'
              Defines the `name' as the `figure' text, used e.g. in figure
              captions. E.g., after `setfigurestring(Figuur)', Yodl uses Dutch
              names for figures.

       `sethtmlfigureext(ext)'
              Defines the filename extension for HTML figures, defaults to
              `.jpg'. Note that a leading dot must be included in `ext'. The
              new extension takes effect starting with the following usage of
              the `figure' macro.  It is only active in html, but otherwise
              acts identically as setfigureext().

              See also the `setlatexfigureext' macro.

       `htmlmetacharset(meta-charset)'
              Adds `<meta charset="meta-charset">' to the head of html
              documents. By default `<meta charset="UTF-8">' is used. This
              macro is only active in the preamble and is only interpreted for
              html conversions.

       `setincludepath(name)'
              Sets a new value of the include-path specification used when
              opening .yo files. A warning is issued when the path
              specification does not include a .: element. Note that the local
              directory may still be an element of the new include path, as
              the local directory may be the only or the last element of the
              specification. For these eventualities the new path
              specification is not checked.

       `setlanguage(name)'
              Installs the headers specific to a language. The argument must
              be the name of a language, whose headers have been set by a
              corresponding languageXXX() call. For example: languagedutch().
              The language macros should set the names of the headers of the
              following elements: table of contents, affiliation, author,
              chapter, date, figure, part and title

       `setlatexalign(alignment)'
              This macro defines the table alignment used when setting tables
              in LaTeX.  Use as many `l' (for left-alignment), `r' (for right
              alignment), and `c' (for centered-alignment) characters as there
              are columns in the table. See also `table()'.

              Instead of using the `table' macro consider using the `tbl'
              macro.

       `setlatexfigureext(ext)'
              Defines the filename extension for encapsulated PostScript
              figures in LaTeX, defaults to `.ps'. The dot must be included in
              t new extension `ext'. The new extension takes effect starting
              with a following usage of the `figure' macro. It is only active
              in LaTeX, but otherwise acts identically as setfigureext().

              See also the `sethtmlfigureext' macro.

       `setlatexverbchar(char)'
              Set the char used to quote LaTeX \verb sequences

       `setmanalign(alignment)'
              This macro defines the table alignment in the context of the
              `table' macro, and is used when setting tables in man-pages (see
              tbl(1)).

              Use as many `l' (for left-alignment), `r' (for right alignment),
              and `c' (for centered-alignment) characters as there are columns
              in the table.

              Use `s' to indicate that the column to its left is combined
              (spans into) the current column. Use this specification when
              cells spanning multiple columns must be defined.

              Each row in a table which must be convertible to a manpage may
              be preceded by its own `setmanalign' call.

              Note that neither `rowline' nor `columnline' requires
              `setmanalign' specifications, as these macros define rows by
              themselves. It is the responsibility of the author to ensure
              that the number of alignment characters is equal to the number
              of columns of the table.

              Instead of using the `table' macro consider using the `tbl'
              macro.

       `setpartstring(name)'
              Defines `name' as the `part' string, by default Part. E.g.,
              after `setpartstring(Teil)', Yodl identifies parts in the German
              way. Note that LaTeX output does its own national language
              support; this macro doesn't affect the way LaTeX output looks.

       `setrofftab(x)'
              Sets the character separating items in a line of input data of a
              `roff' (manpage) table. By default it is set to `~'. This
              separator is used internally, and needs only be changed (into
              some unique character) if the table elements themselves contain
              `~' characters.

              This macro can be used in the context of the `table' and `tbl'
              macros.

       `setrofftableoptions(optionlist)'
              Set options used for man-conversion, as used by the `tbl' and
              `table' macros. By default no options are used. Multiple options
              should be separated by blanks. From the tbl(1) manpage, the
              following options are available:

       o      `center' Centers the table; default is left-justified. In the
              context of the `tbl' macro this is implied when the `tbl' macro
              is specified as argument of the `center' macro.

       o      `expand' Makes the table as wide as the current line length

       o      `box' Encloses the table in a box

       o      `allbox' Encloses each item of the table in a box


              See also `setrofftab' which is used to set the character
              separating items in a line of input data.

       `settitlestring(name)'
              Defines `name' as the `title information' string, by default
              TITLE INFORMATION. E.g., after `settitlestring(TITEL)', YODL
              outputs this Dutch string to describe the title information.
              Currently, it is relevant only for txt.

       `settocstring(name)'
              Defines `name' as the `table of contents' string, by default
              Table of Contents. E.g., after `settocstring(Inhalt)', YODL
              identifies the table of contents in the German way. Note that
              LaTeX output does its own national language support; this macro
              doesn't affect the way LaTeX output looks.

       `sgmlcommand(cmd)'
              Writes `cmd' to the output when converting to sgml. The `cmd' is
              not further expanded by Yodl.

       `sgmltag(tag)(onoff)'
              Similar to `htmltag', but used in the SGML converter.

       `sloppyhfuzz(points)'
              By default, LaTeX output contains commands that cause it to shut
              up about hboxes that are less than 4pt overfull. When
              `sloppyhfuzz()' appears before stating the document type, LaTeX
              complaints occur only if hboxes are overfull by more than
              `points'.

       `standardlayout()'
              Enables the default LaTeX layout. When this macro is absent,
              then the first lines of paragraphs are not indented and the
              space between paragraphs is somewhat larger. The
              `standardlayout()' directive must appear before stating the
              document type as `article', `report', etc..

       `strong(contents)'
              In html and xml the `contents' are set between `<strong>' and
              `</strong>' tags.  In html `attrib' macro applies to the
              `<strong>' tag.

       `subs(text)'
              Sets text in subscript in supporting formats.  In html the
              `attrib' macro is recognized by the `<sub>' tag.

              For superscripting, the `sups' macro can be used.

       `subsect(title)'
              Starts a new subsection. Other sectioning commands are
              `subsubsect' and `subsubsubsect'.  In html `attrib' macro
              applies to the `<h3>' tag.

       `subsubsect(title)'
              Starts a sub-subsection.  In html `attrib' macro applies to the
              `<h4>' tag.

       `subsubsubsect(title)'
              Starts a sub-sub-sub-subsection. This level of sectioning is not
              numbered, in contrast to `higher' sectionings.

       `sups(text)'
              Sets text in superscript in supporting formats In html the
              `attrib' macro is recognized by the `<sup>' tag.

              For subscripting, the `subs' macro can be used.

       `table(nColumns)(alignment)(Contents)'
              Instead of using the `table' macro, consider using the `tbl'
              macro.

              The `table()'-macro defines a table. Its first argument
              specifies the number of columns in the table.

              Its second argument specifies the (standard) alignment of the
              information within the cells as used by LaTeX or man/ms. Use `l'
              for left-alignment, `c' for centered-alignment and `r' for right
              alignment.

              Its third argument defines the contents of the table which are
              the rows, each containing column-specifications and optionally
              man/ms alignment definitions for this row.

              See also the `tableatt' macro and the specialized
              `setmanalign()' macro.

       `tableatt(nColumns)(alignment)(Contents)'
              Instead of using the `tableatt' macro, consider using the `tbl'
              macro.

              The `tableatt()'-macro defines a table. The last `attrib' call
              that was specified before using the `tableatt()'-macro is used
              to specify html attributes for the table. E.g., to center a
              table in html use

                  attrib(style="margin-left:auto;margin-right:auto;")
                  tableatt(...)

              The macro's first argument specifies the number of columns in
              the table.  Its second argument specifies the (standard)
              alignment of the information within the cells as used by LaTeX
              or man/ms. Use `l' for left-alignment, `c' for
              centered-alignment and `r' for right alignment. Its third
              argument defines the contents of the table which are the rows,
              each containing column-specifications and optionally man/ms
              alignment definitions for this row.

              See also the `table' macro and the specialized `setmanalign()'
              macro.

       `tac(alignment)(contents)'
              This macro is one of the four macros that can be used to define
              column contents of rows of tables defined by the `tbl' macro.
              Alternatively, `tc, tnc', and `tnac' can be used.

              The `tac' macro is used as argument of the `tr' macro. The
              cell's alignment is defined by the `alignment' specification,
              containing at most two alignment specifications: a horizontal
              alignment (one of c, l, r (centered, left-aligned,
              right-aligned)) and a vertical alignment (one of t, b (vertical
              top- and bottom-alignment)) (not all conversion types may
              support all alignment types, e.g., man-conversion does not
              support vertical bottom alignment). Specifications other than c,
              l, r, b, and t and specifications beyond the second one are
              ignored. The result of specifying conflicting alignment types
              (e.g., `lr' or `tb') is not defined.

              When converting to `man', if the table's contents should span
              multiple rows, then a groff/troff(1) text block must be used.
              Since most tables do not use this, a text block is not generated
              by default. To actually wrap the contents of column elements in
              a text block while converting to `man' prefix the first text
              block requiring a text-block wrapping by `twrap(1)', and end the
              last text block requiring a text-block wrapping by `wrap(0)'.

              The `tao' macro can be used to overrule the specified alignment
              for a specific conversion type.

              The macro `tac' recognizes `attrib'.

       `tao(type)(specification)'
              This macro is used inside the `tbl' macro to override the
              alignment specification that would otherwise be used for the
              next table element. It is only active for the next `tc, tnc,
              tac,' or `tnac' call. Its first argument defines the conversion
              type for which the override should be used, its second argument
              defines the alignment specification to use.

              Here are some examples:

              tbl(lr)(
                  tr(
                      tc(left aligned)
                      tc(right aligned)
                  )
                  tr(
                      tao(html)(c)
                        tc(left aligned, centered with html)
                      tao(latex)(l)
                      tao(man)(l)
                        tac(c)(centered, latex and man: left aligned)
                  )
              )



              Further details about the `tao' macro are provided in the
              yodltables(7) man-page.

       `tbl(align)(contents)'
              The `tbl' macro refines the more basic `table' macro. It was
              named after the tbl(1) table formatting program used with
              troff(1) documents.

              The `tbl' macro currently is available for `html, man/ms, latex'
              and `txt' conversions.

              Its first argument defines the alignment of the information in
              the table's columns, and is used by all conversions except
              `txt'. Use `l' for left-alignment, `c' for centered-alignment
              and `r' for right-alignment. Individual cells of the table may
              override these default settings using the macros `tac' and
              `tnac'.

              Its second argument defines the contents of the table consisting
              of rows (using `tr'), and horizontal lines (using `tline'),
              which may extend over the full table width or may cover one or
              more individual columns. With `txt' conversion rough
              approximations of horizontal lines are used.

              Tables defined by the `tbl' macro are centered (pseudo centering
              (8 space characters) is used for `txt' conversion) when used as
              argument of the `center' macro.

              See also the `tao' macro for information about how to realize
              specific alignments for specific conversion types.

              When defining `tbl' tables it is advised to clearly layout the
              table specification. To avoid inadvertently introducing new
              lines lines should end in a backslash (or The macro `tbl'
              recognizes `attrib'.

       `tc(contents)'
              This macro is one of the four macros that can be used to define
              column contents of rows of tables defined by the `tbl' macro.
              Alternatively, `tnc, tac', and `tnac' can be used.

              The `tc' macro is used as argument of the `tr' macro. Its order
              within a row defines its type attribute, using the alignment
              specification defined by the first argument of the `tbl' call.
              E.g., if `tbl(clr)(...)' was used, then the contents of the
              first `tc' call in a `tr' is centered in the table's first
              column; the contents of the second `tc' call is left-aligned in
              the table's second column; and the contents of the third `tc'
              call is right-aligned in the table's third column.

              When converting to `man', if the table's contents should span
              multiple rows, then a groff/troff(1) text block must be used.
              Since most tables do not use this, a text block is not generated
              by default. To actually wrap the contents of column elements in
              a text block while converting to `man' prefix the first text
              block requiring a text-block wrapping by `twrap(1)', and end the
              last text block requiring a text-block wrapping by `wrap(0)'.

              The `tao' macro can be used to overrule the default alignment
              specification for a specific conversion type.

              The macro `tc' recognizes `attrib'.

       `tcell(text)'
              Roff helper to set a table text-cell, i.e., a paragraph.  For
              LaTeX special table formatting p{} should be used.

              When using the `tbl' macro for defining tables the `twrap' macro
              can be used to set table elements in text-blocks (i.e.,
              enclosing text, possibly containing newlines in `T{' and `T}'
              sequences).

       `telycommand(cmd)'
              Writes `cmd' to the output when converting to tely. The `cmd' is
              not further expanded by Yodl.

       `TeX()'
              The TeX symbol.

       `texinfocommand(cmd)'
              Writes `cmd' to the output when converting to texinfo. The `cmd'
              is not further expanded by Yodl.

       `tindex()'
              Generate an index entry for LaTex() or texinfo t-indices. Its
              argument is the index entry.  See also the `[cfpv]index' macro.

       `titleclearpage()'
              Forces a new page (using `clearpage') following the title of a
              document. This is already the default in books and reports, but
              can be overruled using `notitleclearpage'. When present, it must
              appear in the preamble, i.e., before the document type is stated
              as article, book or report.

       `tline(beginNr)(endNr)'
              This macro is used to insert a horizontal line spanning one or
              more columns of a table defined by the `tbl' macro.

              If `endNr' is not specified, and the `tline' call does not
              follow a previous `line' call in which `endNr' was specified,
              then a horizontal line spanning the full width of the table is
              defined (except when converting to plain text in which case a
              line of `beginNr' - (minus) characters is written; if `beginNr'
              is not specified then a line of 60 - characters is written).

              If `endNr' is not specified, but the `tline' call follows
              previous `tline' calls that did specify `endNr' then the current
              row is ended.

              If `endNr' is specified, then a horizontal line is set, starting
              at column number `beginNr' continuing through column number
              `endNr'. Note that these are numbers, not offsets: `beginNr'
              should be at least 1, `endNr' must at least be equal to
              `beginNr' and should be at most equal to the number of columns
              in the table. The `beginNr' values of subsequent `tline' calls
              refer to the same row as the first `tline' call, and must exceed
              `endNr' of the previous `tline' call.

              Examples:

                  tline()()       sets a line spanning the full table width
                  tline(1)(1)     sets a line in column 1
                  tline(3)(4)     sets another line in column 3 and 4
                  tline()()       ends the previous line
                  tline()()       sets a line spanning the full table width



       `tnac(nCells)(alignment)(contents)'
              This macro is one of the four macros that can be used to define
              column contents of rows of tables defined by the `tbl' macro.
              Alternatively, `tc, tac', and `tnc' can be used.

              The `tnac' macro is used as argument of the `tr' macro. Its
              first argument defines the number of columns spanned by the
              contents (2nd argument) of the `tnc' macro.

              The cell's alignment is defined by the macro's second
              (`alignment') specification, containing at most two alignment
              specifications: a horizontal alignment (one of c, l, r
              (centered, left-aligned, right-aligned)) and a vertical
              alignment (one of t, b (vertical top- and bottom-alignment))
              (not all conversion types may support all alignment types).
              Specifications other than c, l, r, b, and t and specifications
              beyond the second one are ignored. The result of specifying
              conflicting alignment types (e.g., `lr' or `tb') is not defined.

              When converting to `man', if the table's contents should span
              multiple rows, then a groff/troff(1) text block must be used.
              Since most tables do not use this, a text block is not generated
              by default. To actually wrap the contents of column elements in
              a text block while converting to `man' prefix the first text
              block requiring a text-block wrapping by `twrap(1)', and end the
              last text block requiring a text-block wrapping by `wrap(0)'.
              Multiple rows in a text block are top-aligned with left and righ
              neighboring cells.

              The `tao' macro can be used to overrule the default alignment
              specification for a specific conversion type.

              The macro `tnac' recognizes `attrib'.

       `tnc(nCells)(contents)'
              This macro is one of the four macros that can be used to define
              the column contents of rows of tables that are defined by the
              `tbl' macro. Alternatively, `tc, tac', and `tnac' can be used.

              The `tnc' macro is used as argument to the `tr' macro. Its first
              argument defines the number of columns spanned by the contents
              (2nd argument) of the `tnc' macro. The contents are centered in
              the `nCells' columns.

              When converting to `man', if the table's contents should span
              multiple rows, then a groff/troff(1) text block must be used.
              Since most tables do not use this, a text block is not generated
              by default. To actually wrap the contents of column elements in
              a text block while converting to `man' prefix the first text
              block requiring a text-block wrapping by `twrap(1)', and end the
              last text block requiring a text-block wrapping by `wrap(0)'.
              Multiple rows in a text block are top-aligned with left and righ
              neighboring cells.

              The `tao' macro can be used to overrule the default alignment
              specification for a specific conversion type.

              The macro `tc' recognizes `attrib'.

       `tocclearpage()'
              With the LaTeX converter, a `clearpage()' directive if inserted,
              immediately following the document's table of contents. This is
              already the default in all but the `article' document type, but
              it can be overruled by `notocclearpage()'. When present, it must
              appear in the preamble; i.e., before the document type is stated
              with `article', `book' or `report'. With other converters than
              the LaTeX converter, it is ignored.

       `tr(contents)'
              This macro defines the rows of a table that is defined by the
              `tbl' macro.

              The macro `tr' expects one argument: the contents of the row,
              defining the row's column elements. It is not used for defining
              a (partial) horizontal line: to set horizontal lines in a table
              defined by the `tbl' macro use the macro `tline'.

              Normally the contents of the columns in a (`tr') row is defined
              by of one or more calls to the macros `tc, tac, tnc,' and/or
              `tnac'.

              The macro `tr' recognizes `attrib'.

       `tt(text)'
              Sets `text' in teletype font, and prevents it from being
              expanded.  When converting to man, `text' is surrounded by a
              backtick and a single quote character.

              For unbalanced parameter lists, use `CHAR(40)' to get `(' and
              `CHAR(41)' to get `)'.

              The `tt' macro does interpret character tables as well as any
              `SUBST' definitions. This is usually what is intended. In
              situations where this is unwelcome the `ttbegin' and `ttend'
              pair of macros can be used, between which the builtin commands
              `PUSHSUBST, POPSUBST, NOEXPAND' and/or `NOTRANS' can be used.
              E.g., to clearly show two hyphens in LaTeX teletype font use

                  ttbegin()--ttend()

              rather than

                  tt(--)

              Likewise, use `ttbegin' and `ttend' if the teletype text
              contains accented letters like e. To set this in teletype font
              use `ttbegin()\"'`e+ttend()'.

              With html conversions the `attrib' macro applies to the `<code>'
              tag.

              With man conversions the arguments of tt macros can be quoted.
              See the `manttquoted' macro for details.

       `ttbegin()'
              Initiates text set in teletype font. Following the text to set
              in teletype font a `ttend()' macro should be called.

              Usually the `tt' macro can be used instead of the `ttbegin' --
              `ttend' combination. However, `tt' interprets character tables
              as well as `SUBST' definitions. In situations where this is
              unwelcome the `ttbegin' and `ttend' pair of macros can be used,
              between which builtin commands like `PUSHSUBST, POPSUBST,
              NOEXPAND' and/or `NOTRANS' can be used.

              In html the `attrib' macro applies to the `<code>' tag.

       `ttend()'
              Ends text set in teletype font following `ttbegin'. Refer to the
              `ttbegin' macro's description for details.

       `twrap(value)'
              Used for man/ms conversions only: when called with a non-zero
              argument before using the `tc, tnc, tac', and `tnac' macros then
              their contents are wrapped in text blocks (`T{ ... T}' blocks).
              To end the wrapping `twrap(0)' must be called. E.g., in the
              following row-definition the contents of columns three and four
              are set in T-blocks when converting to man/ms:

                  tr(tc(one)tc(two)twrap(1)tc(one)tc(two)twrap(0))


       `txtcommand(cmd)'
              Writes `cmd' to the output when converting to txt. The `cmd' is
              not further expanded by Yodl.

       `url(description)(locator)'
              In LaTeX documents the `description' is sent to the output. For
              HTML, a link is created with the descriptive text `description'
              and pointing to `locator'. The `locator' should be the full URL,
              including service; e.g, `http://www.icce.rug.nl', but excluding
              the double quotes that are necessary in plain HTML. Use the
              macro `link' to create links within the same document. For other
              formats, something like description [locator] will appear.  In
              html `attrib' macro applies to the `<a>' tag.

       `verb(text)'
              Sets `text' in verbatim mode: not subject to macro expansion or
              character table expansion, and starting with Yodl version
              4.00.00: not using `SUBST' definitions. See also `verborg',
              which does not provide the protection against `SUBST'
              definitions.

              While converting Yodl-documents to target document types Yodl
              frequently uses the (not further documented) builtin function
              `XXSUBST'. In the unlikely event that the text `XXSUBST(...)'
              must be written in a document, the sequence

                  XXSUBST+CHAR(40)...CHAR(41)

              can be used.

              The text that is passed as argument to the `verb'-macro appears
              literally on the output, usually in a teletype font (that
              depends on the output format). This macro is for larger chunks,
              e.g., listings.

              When starting the `verb(' macro on a line by itself and writing
              the closing parenthesis on a line by itself then those newlines
              also appear in the resulting verbatim text. To omit those lines
              immediately start the first line of text after `verb' and append
              the closing parenthesis to the last line of verbatim text. E.g.,
              verb(    First line of indented literal text
                  Last line of indented literal text)


              When unbalanced parameter lists are required, use `CHAR(40)' to
              get `(' and `CHAR(41)' to get `)'.

       `verbinclude(filename)'
              Reads filename and inserts it literally in the text, set in
              verbatim mode.  not subject to macro expansion. The text appears
              literally on the output, usually in a teletype font (that
              depends on the output format). This macro is an alternative to
              `verb(...)', when the text to set in verbatim mode is better
              kept in a separate file.

       `verbinsert(args)'
              Passes `args' to yodlverbinsert(1), inserting its output into
              the converted file. This macro can be used to insert, e.g., a
              line-numbered indented file, or a labeled subsection of a file,
              into the file that's currently being written by `yodl'. E.g,

              verbinsert(-ans4 file)       -- inserts file, showing line
                                              numbers, using a 4 blank-space
                                              character wide indentation.

              verbinsert(-ns4 //SECT file) -- inserts the section of file,
                                              labeled //SECT file, showing
                                              line numbers, using a 4
                                              blank-space character wide
                                              indentation.



       `verborg(text)'
              Sets `text' in verbatim mode: not subject to macro expansion or
              character table expansion, and starting with Yodl version
              4.00.00: this macro replaces the previously defined `verb'
              macro. The current `verb' macro surrounds this macro by
              `PUSHSUBST' and `POPSUBST'.

              The text that is passed as argument to the `verborg'-macro
              appears literally on the output, albeit that `SUBST' definitions
              are processed, usually in a teletype font (that depends on the
              output format). This macro is for larger chunks, e.g., listings.

              When unbalanced parameter lists are required, use `CHAR(40)' to
              get `(' and `CHAR(41)' to get `)'.

       `verbpipe(command)(text)'
              Pipe text through command, but don't expand the output.

       `vindex()'
              Generate an index entry for LaTex() or texinfo v-indices.  Its
              argument is the index entry.  See also the `[cfkpt]index' macro.

       `whenhtml(text)'
              Sends `text' to the output when in HTML conversion mode. The
              text is further expanded if necessary.

       `whenlatex(text)'
              Sends `text' to the output when in LATEX conversion mode. The
              text is further expanded if necessary.

       `whenman(text)'
              Sends `text' to the output when in MAN conversion mode. The text
              is further expanded if necessary.

       `whenms(text)'
              Sends `text' to the output when in MS conversion mode. The text
              is further expanded if necessary.

       `whensgml(text)'
              Sends `text' to the output when in SGML conversion mode. The
              text is further expanded if necessary.

       `whentely(text)'
              Sends `text' to the output when in TELY conversion mode. The
              text is further expanded if necessary.

       `whentexinfo(text)'
              Sends `text' to the output when in TEXINFO conversion mode. The
              text is further expanded if necessary.

       `whentxt(text)'
              Sends `text' to the output when in TXT conversion mode. The text
              is further expanded if necessary.

       `whenxml(text)'
              Sends `text' to the output when in XML conversion mode. The text
              is further expanded if necessary.

       `xit(itemname)'
              Starts an xml menu item where the file to which the menu refers
              to is the argument of the xit() macro. It should be used as
              argument to xmlmenu(), which has a 3rd argument: the default
              path prefixed to the xit() elements.

              This macro is only available within the xml-conversion mode. The
              argument must be a full filename, including .xml extension, if
              applicable.

              No .xml extension indicates a subdirectory, containing another
              sub-menu.

       `xmlcommand(cmd)'
              Writes `cmd' to the output when converting to xml. The `cmd' is
              not further expanded by Yodl.

       `xmlmenu(order)(title)(menulist)'
              Starts an xmlmenu. Use itemization() to define the items. Only
              available in xml conversion. The menutitle appears in the menu
              as the heading of the menu.  The menulist is a series of xit()
              elements, containing the name of the file to which the menu
              refers as their argument (including a final /).  Prefixed to
              evert every xit()-element is the value of XXdocumentbase.

              Order is the the `order' of the menu. If omitted, no order is
              defined.

       `xmlnewfile()'
              In XML output, starts a new file. All other formats are not
              affected. Note that you must take your own provisions to access
              the new file; say via links.  Also, it's safe to start a new
              file just befoore opening a new section, since sections are
              accessible from the clickable table of contents. The XML
              converter normally only starts new files prior to a `chapter'
              definition.

       `xmlsetdocumentbase(name)'
              Defines `name' as the XML document base. No default.  Only
              interpreted with xml conversions. It is used with the figure and
              xmlmenu macros.

       `xmltag(tag)(onoff)'
              Similar to `htmltag', but used in the XML converter.

OPTIONS
       No options are relevant in respect to the macros.

FILES
       The files in tmp/wip/macros define the converter's macro packages. The
       scripts yodl2tex, yodl2html, yodl2man etc. perform the conversions.

SEE ALSO
       yodl(1), yodlbuiltins(7), yodlconverters(1), yodlletter(7),
       yodlmanpage(7), yodlpost(1), yodlstriproff(1), yodltables(7),
       yodlverbinsert(1).

BUGS
       -

AUTHOR
       Frank B. Brokken (f.b.brokken@rug.nl),

yodl_4.05.01                       1996-2025                    Yodl macros(7)