The GELLMU Manual

3.1.  \documenttype

A document prepared in GELLMU source usually begins with a documenttype command. For example,

is used to begin a document prepared for the most common form of classical HTML.

The syntactic translator has two public variables gellmu-doctype-keylist and gellmu-doctype-info, which are Elisp associative lists, that enable one to match XML or SGML “<!DOCTYPE ... >” declarations with LaTeX-like

commands, where my-optional-key is available to override a default key for my-doctype. Thus, for example, “\documenttype{html}” points to the default key for “html”, which is “html-4.01” and which points to the W3C HTML 4.01 Transitional document type, while

indicates W3C XHTML 1.0 Strict.

A user may configure these variables without modifying the source code for the GELLMU syntactic translator, but minimal knowledge of Elisp will be required. A future release might provide a configuration file for this purpose.

A second option for the documenttype metacommand, which must follow the single required argument, is provided for writing an internal declaration subset. The contents of an internal declaration subset constructed this way may be any internal declaration subset material. However, some care is required for entering characters that are special. To ease the handling of special characters four metacommands have been provided for use inside the internal declaration subset:

\attlist{...}

\element{...}

\entity{...}

\notation{...}

For example, a user who wishes to be able in source to use “&quo;” to reference the ASCII quotation mark when writing consciously in basic mode for TEI.2 would begin the source file with:

\documenttype{TEI.2}[

\entity{quo "&#x22;"}

]

3.2.  \newcommand

From a user's viewpoint this provides emulation of LaTeX's newcommand. But it is a simple facility providing macro substitution with arguments forward in a source file from the point of its occurrence. It differs from the newcommand facility in LaTeX in that it does not add the name of a newcommand to any namespace. Instead, as the syntactic translator encounters each newcommand definition, it performs the corresponding expansions and then forgets the name.⁴

The general construction of a newcommand definition is

where name is the name of the newcommand, nargs optionally specifies the number of its arguments, first is an optionally-provided default value for the first argument, and value denotes the value string.

In the value string the character ‘#’ is used to reference an argument by the numeric value of its position. Thus, “#1” refers to the first argument that is provided at an invocation of the newcommand, “#2” the second, etc., and there is no limit on the number of arguments. It is not required that nargs be supplied in order to define and use a newcommand taking arguments. However, for the sake of automatic error checking the use of nargs is strongly recommended when the definition of a newcommand taking arguments is entered.

Example. In writing HTML one might use

\newcommand{\href}[2][http://www.w3.org/]{\a[href="#1"]{#2}}

for brevity in writing many HTML anchors. With this definition the invocation

gives rise to the HTML markup

while the invocation “\href{Web Central}” gives rise to

Rules.

1. The name of a newcommand may not be referenced in its value string.⁵

2. A newcommand may not be invoked before it is defined unless the invocation occurs in the value string of another newcommand definition in which case the definition of the latter may be first and must be first if the invocation of the former in the definition of the latter involves argument substitutions.

Failure to observe these rules may cause the syntactic translator to enter an infinite recursive loop. If a user suspects this may have happened, then the invocation of the syntactic translator should be interrupted (section 7.4.3).

3.3.  \begin{} … \end{}

These provide emulation of LaTeX environment notation without actually providing anything that is not otherwise available. Markup which resembles that for a LaTeX environment simply resolves to an SGML element. This usage may be convenient for SGML elements of large scope such as, for example, the body of an HTML document.

With advanced mode the special form

may be used to emulate the corresponding feature of LaTeX for a document type, such as the didactic article document type, that in the large consists of a preamble and a body.

3.4.  \macro and \Macro

Use of these is discouraged in the absence of a need. One situation that presents a need is name “fronting”: see the discussion below in section 3.5. Please note that in most situations one may use newcommand without an argument for simple macro substitutions.

macro and Macro do very much the same thing except for the order of expansions. Every macro is expanded forward as encountered before any newcommand definition is expanded. Every Macro is expanded forward after every newcommand has been expanded.

There are four primary differences between macro and Macro, on the one hand, and newcommand, on the other hand.

1. Neither macro nor Macro can be used to define a macro that takes arguments.

2. The name of a newcommand must consist of word characters, but there is no restriction on the characters, apart from unbalanced brace characters (‘{’ and ‘}’), that may appear in the name field of a macro or Macro metacommand.

3. If the name of a macro or Macro does not begin with the command sequence introducer, i.e., the character ‘\’, then an invocation of that metacommand is given by every forward match of its name. The use of such names is strongly discouraged because document segments can then become opaque much too easily.

4. A newcommand invocation, absent the use of a semi-colon for termination, is only effective at the whole word level — with word here denoting a maximal string of successive word characters — whereas macro and Macro invocations are effective regardless of word boundaries.

Elaboration on the last point: If x is the name of a newcommand, then invocations are only considered by the syntactic translator on the string “\x” when it is followed by a non-word character. For example, if the locale is us-ascii, then the word characters are the 52 upper and lower case letters and the ten numerals. Therefore with newcommand, as with its namesake in regular LaTeX, the use of “x” as a name will not intercept the occasions of “\x” as an initial substring of “\xy”. With either macro or Macro such interception does take place. One may block it at the point of an invocation with the markup “\x;”, and when this is done, the terminating semi-colon is removed.

Human authors using either macro or Macro may find unanticipated interactions between the three forms of macro substitution.

Unbalanced brace characters, i.e., the characters ‘{’ and ‘}’, may not be used in the name field or the value field of any form of macro metacommand.

3.5.  Macro-Level Fronting of SGML Element Names

The word fronting as used here describes the practice of modifying the meaning of an SGML element name by using one or more of the macro facilities to generate usage of the same name as an element combined with other markup using the syntax that would otherwise correspond to basic use of the element.

Suppose, for example, one wants all paragraphs in HTML (marked with \p in GELLMU source) to be placed in a (style) class called custom.

Recommended procedure: Create a new unique name and then use macro to front it.

\newcommand{\cp}[1][]{\p[class="custom"]{#1}}

\macro{\p}{\cp}

Each invocation of “\p{...}” will first be replaced by “\cp{...}” because all macro definitions are expanded before any newcommand definition is expanded. Subsequent expansion of the newcommand will yield

This will not intercept the alternate, otherwise nearly equivalent, markup given with \begin{p} … \end{p} since newcommand is based on simple macro substitution and does not operate at the level of namespaces.

4.1.  Illustrations.

One might want to be able to use blank lines, as in LaTeX, for introducing new paragraphs in a document type that provides paragraphs.

In some article-level document types each sectional unit has a unit header providing markup for various, often optional, unit descriptors. It is convenient to be able to use LaTeX-like multiple argument/option syntax (section 4.2) for these.

If the document type provides authoring-level mathematical markup beyond inclusions of the World Wide Web Consortium's Mathematical Markup Language (MathML) under its XML namespace regime, then one might want to be able to use the ‘$’ character to toggle in and out of inline math, and if the document provides for math displays, then one might want to use, as in LaTeX, the strings “\[” and “\]” as delimiters for unstructured mathematical displays, and markup such as

for a single equation, and markup such as

for a list of equations.

It is important to emphasize, however, that by overall system design the syntactic translator operates without substantial knowledge of vocabulary. While it is true that if ‘$’ is to provide a toggle for an inline element containing math, say, tmath, then the syntactic translator needs to have that association made, but the association is provided as the value of a configuration variable in the syntactic translator that can be changed between documents so that the syntactic translator may be used with many document types.

One way to make such configuration convenient is to use an array of Elisp functions that are fronts with various variable configuration packages for the basic function gellmu-trans in the syntactic translator.

The general outline for advanced GELLMU with arbitrary document types is not fully developed in the present release. Instead the project has concentrated on the realization of these ideas for the project's didactic article document type, which is the subject of the next section.

As the syntactic translator stands now, basic mode is characterized in the syntactic translator by the true setting for its Boolean variable gellmu-straight-sgml, while the configuration used by default for the didactic document type (which could be handled in basic mode with more verbose source markup) has that variable set false and also the variable gellmu-regular-sgml set false.

The term regular GELLMU refers to use of the syntactic translator with the default configuration for the didactic document type. It involves nearly maximal emulation of LaTeX-like markup; it implies both advanced mode and the didactic document type (section 5) article.

4.2.  Multiple Argument/Option Syntax

An essential point in the present design is that the whole system is built from components, each of which has its own function⁶. Consistent with this design the syntactic translator operates with knowledge of syntax but little or no knowledge of language.

Multiple argument/option syntax has been built into advanced mode as part of the overall idea of providing, where sensible, LaTeX-like features in a precise user markup interface for writing in document types under SGML and XML.

What are the rules for converting the multiple argument/option syntax in source markup into SGML? Direct conversion by the syntactic translator of this type of usage into XML is not available because such conversion requires some language knowledge and the program does not operate with knowledge of language at that level⁷. One obtains an XML version of a document in the didactic production system by using a translator with minimal knowledge of the command vocabulary to create the XML version from an SGML version that is the immediate output of the syntactic translator.

In multiple argument/option syntax, which is much like that of LaTeX, arguments and options follow command names. Arguments are delimited by braces, i.e., ‘{’ and ‘}’ and options by square brackets, i.e., ‘[’ and ‘]’. There must be no white space between the arguments and options nor between the command name and the first member of an argument/option sequence.

Each command with a multiple argument/option sequence is translated to an open tag whose name is the name of the command. Each argument is translated to an ag0 element and each option to an op0 element. (Both ag0 and op0 lie in GELLMU's reserved name space.) There are two exceptional cases.

1. The first argument or option is an option inside which the very first character is a colon, i.e., ‘:’. This is the method provided in advanced mode for the direct entry of an SGML attribute sequence.⁸ The entire contents of the option string, apart from the leading ‘:’, which is discarded, are understood to be a sequence of SGML attributes for the SGML element whose name is the name of the command. There is no syntax check of the attribute contents by the syntactic translator. Such an attribute option is not treated as an op0 element. In particular, an attribute option is correctly followed immediately by a semi-colon, i.e., the character ‘;’, if and only if the corresponding SGML element is a defined-empty element under the SGML document type. Since SGML attributes correspond to very little of classical LaTeX⁹, attribute options are seldom used¹⁰ in the didactic production system. One such use is for the GELLMU equivalent of latex's equation* and eqnarray* environments, which is marked up this way:

   \begin{equation}[:nonum="true"]

   e = mc^2

   \end{equation}

   to produce:

   e  =  mc^{2}

2. The first argument is the only argument and there are no options apart from a possible attribute option. This case, which is extremely common, is exceptional relative to argument/option handling since the sole argument simply becomes element content without an ag0 wrapper.

When a command has a multiple argument/option sequence, the question arises whether the ag0 and op0 elements that arise from the arguments and options are the only content of the element corresponding to the command. The syntax does not provide a way to determine this. On the other hand, the SGML document type definition does provide information that indicates whether other content is possible. It is beyond the scope of the design of the syntactic translator for the syntactic translator to read a document type definition. The syntactic translator does, however, have a configurable list variable gellmu-autoclose-list that contains the names of elements for which no content beyond the elements arising from arguments and options is possible. While it is not necessary that every such command be entered in this list, when such a command not in the list is not explicitly followed by an element closing command, it is possible in some instances for an SGML parser to infer incorrectly the location of end of the element. Thus, the didactic production system provides a command anch for making anchors. The document type definition provides for one option, a reference, and one argument, the anchored text.¹¹ Because the syntactic translator does not consider the document type definition, if one enters the markup

unless the name anch is in the list¹² gellmu-autoclose-list, an SGML parser will not have reason to close the anch until it sees the space following the anchored text “W3C”, and so that space will be considered insignificant white space with the result that there will be no space between the anchored text and the following “HQ”.

4.3.  Limitation in Regard to XML

A final general comment about advanced mode is that the features it can provide beyond basic mode when one is writing consciously for an XML document type are somewhat limited. For example, blank lines cannot easily be made adequate for paragraph markup with the XML form of the didactic article document type. Although it is not a specific limitation for future editions of the syntactic translator, the vision is that use of advanced mode will be specifically for a somewhat rich SGML version of a document type.

5.1.  Suggestions and Caveats

Although this is the manual for a software release, it is not a book. A document of book size would be required for a full description of the didactic production system.

Much of the markup vocabulary is copied from LaTeX. There are some instances where there is some deviation from LaTeX usage, and many of those instances are mentioned here.

Definitive information about the didactic document type may be derived by consulting the document type definition. Because the didactic production system is conceived as a base for future development there are sketches in the document type definition that are not covered by the didactic processors. For example, although there is sketched code for the analogues of LaTeX's paragraph and subparagraph commands, which are sectional in nature, that is found in the translation from SGML to XML, there is no sketched code for these elements in the two formatters.

Another way to obtain information about the didactic production system is by studying examples including this manual and the examples in the project archive (appendix A).

5.2.  Markup Fundamentals

There are several kinds of commands:

5.3.  Large Structure

Overall an article consists of a preamble followed by a body. As noted previously (section 3.3) advanced mode provides a special form of usage

with the paired metacommands begin and end that with an article delimit its body. This is enabled with the gellmu-trans call for the syntactic translator, and, consistent with regular LaTeX usage the preamble is present without explicit tagging.

The only required markup in a preamble is a title, and it is formally correct for its content to be empty. The SGML content model for a body is somewhat loose, but is usually understood to consist of sections and may contain ordinary paragraphs (par, which must be marked up explicitly, or parb, which is begun with a blank line). Although a body may be entirely empty (likely not useful) or may consist only of par and parb elements, all inline text must be within one of these basic paragraph containers.

For example this formally correct textless document is handled without noise by the didactic production system:

\documenttype{article}

\title{}

\begin{document}\end{document}

while the following document with text outside of a paragraph fails initial validation in the didactic production system:

\documenttype{article}

\title{}

\begin{document}

x

\end{document}

The error may be corrected by placing a blank line before the character ‘x’.

The content model for preamble is tighter than that for body. This makes it possible to have a greater level of error-checking than would otherwise be possible. For example, a preamble must have exactly one title although it is not specified where in the preamble a title might be. There may be at most one of each of the elements surtitle, subtitle, and date. Although newcommand, which is a metacommand, does not affect the document type definition and may be used at different locations in the preamble, the small number of actual elements that may be multiply used in the preamble, such as mathsym (which is partly a metacommand) must be located together.

5.4.  Sectioning

In classical LaTeX one writes simply

to begin a new section. While this markup specifically delineates the section title, LaTeX understands that a section has begun. The section command has an option whose content is an alternate title for the table of contents, and the starred form of the command suppresses an otherwise automatic section number.

With SGML the classical approach is something along the following lines:

<section><sectiontitle>Some title for a section</sectiontitle>

<para> A paragraph.

<para> Another paragraph.

     . . .

</section>

Basic GELLMU markup corresponding to this would be:²³

\begin{section}\sectiontitle{Some title for a section}

\para A paragraph.

\para Another paragraph.

    . . .

\end{section}

If, moreover, the markup is to be well-formed XML markup, then each para tag would need explicit closure with </para>.

The main point here is that the open and close tags for a section in a classical SGML document type encompass the whole contents of a section, and separate markup is required for the section title.²⁴

The didactic SGML document type under advanced GELLMU seeks to model classical LaTeX as closely as possible in order to provide a bridge for authors from LaTeX to SGML (and, indeed, XML). For this reason a command section similar to the classical LaTeX command that delineates a section title is provided in the didactic SGML document type. At the same time this document type has a whole section container Section (upper case S) that in the simplest case consists of a shead container for its title (or header) followed by any number of paragraphs. The XML form of the didactic document type supports only this latter tag, which means that the translation script that converts SGML to XML has an unambiguous way of performing the conversion from section to Section provided that the author's source leads to an SGML instance which is valid²⁵ under the didactic document type.

5.5.  Labels, References, and Anchors

A label command may be placed anywhere that text may be placed in order to mark a location and associate a symbolic “key” with that location. A ref command may be placed anywhere that text may be placed to generate a visible allusion called its reference value, for example a section number, to the location associated with a label key. An anch command may be placed anywhere that text may be placed to provide a hypertext reference either by key to an internal location or by uniform resource identifier (URI) to an external resource.

At this point the discussion will become descriptive of of the entire didactic production system rather than simply of its document type.

5.6.  General Usage for Sectional Units

This describes the content model in the GELLMU didactic document type for the “whole” sectional units Section, Subsection, … as fully tagged.

5.7.  verbatim, verblist, and manmac

The ordinary notion of “verbatim” is complicated in the context of a document type that is intended for processing toward multiple output formats. There is no special provision for verbatim markup under basic GELLMU³³, but there are two layers, one simplistic and one sophisticated, in the didactic production system with each layer having provision for both inline and block-level verbatim markup.

The simplistic approach involves the provision of an inline element verb and a block-level element verbatim in the didactic document type. With these the author is responsible for entering special characters in ways that are safe for input source notation, safe for syntactic translator output, and safe for each output format that is envisioned.³⁴ In the simplistic layer the formatting program in the didactic production system for HTML output renders verb as an HTML kbd element and verbatim as an HTML pre element. In formatting for regular LaTeX output each of these SGML elements is rendered as its LaTeX namesake. Neither the pre element in HTML nor the (basic) verbatim command in LaTeX is context-sensitive, and typically are formatted with left margin justification.

The sophisticated layer in the syntactic translator for verbatim is enabled by setting the variable gellmu-verbatim-clean true. If this is the case, then a user should input verbatim material literally between \begin{verbatim} and \end{verbatim} markers occupying whole lines and the syntactic translator will convert each of the 33 non-alphanumeric printable ASCII characters therein to the corresponding empty element in the didactic document type, and render each line of the converted material as a list item bearing the item name nln in a list element verblist.³⁵

Similar arrangements pertain to the sophisticated inline analogue of verb, which is enabled in the syntactic translator by setting the variable gellmu-manmac-bar-name to a non-empty string value that is to become the name of the element, such as quostr, to contain the content, which should be delimited in source by successive ‘|’ characters. By default the user must enter a verbatim string in “safe” form, but may enter it, apart from any occurrence of the character ‘|’, literally if the variable gellmu-manmac-literal is true. The term “manmac” is derived from an old plain TeX package for writing documentation by that name in which the character ‘|’ is used to delimit inline literal material for verbatim presentation. Moreover, consistent with usage observed in LaTeX documentation markup of the form

is translated by the syntactic translator to an element named as with simple “|...|” having a setting for its attribute with name the value of the string variable gellmu-manmac-attribute, which for quostr in the didactic document type would appropriately be its attribute inv.

Variable settings to provide for the use of literal input both for verbatim as a metacommand front for the list element verblist and manmac configuration for the element quostr, as described, are default when the syntactic translator is begun with the non-default function gellmu-latex-faq. This function also sets the variable gellmu-squophrase-name, which otherwise defaults to the empty string, to the value “squophrase”. This causes the syntactic translator to attempt to interpret balancing character pairs consisting of the character ‘`’ and the character ‘'’ as delimiters for the element squophrase, an alternate form along with quophrase, for “quoted phrase”, with odd instances of the character ‘'’ set as the empty element apos, which represents an apostrophe.

5.8.  Accents

Traditional LaTeX markup employs accent commands for modifying ASCII characters in order to produce non-ASCII characters. On the other hand characters from 16 “byte-planes” of Unicode are now available in HTML and XML as ordinary characters, with treatment as the atoms of ordinary strings of text not requiring any special attention or notice from the viewpoint of markup. It may happen that this will affect development in the LaTeX project, and it is, therefore, unclear what the long term role might be of LaTeX's accent commands.

Nonetheless, the didactic document type provides element names corresponding to the 14 classical LaTeX accents although it does not provide classical markup notations such as “\'”, “\"”, “\~”, … inasmuch as names are required in syntactic translator output.³⁶ The names for the accents may be seen by locating the word “accent” in the didactic production system file gellmu.dtd and reading the following 14 lines.

An author, particularly an author residing in an English language locale, may introduce, for example, the character é in several ways:

1. by using an algorithmic accent command — in this case \acute{e}: é.

2. by direct Unicode-based entity reference – in this case &#xE9;: é.

3. by simple direct entry of the Unicode point in a file having the UTF-8 text encoding.

Note that Unicode values are numbers represented in hexadecimal notation (base 16); the digits are 0–9 and A–F. Thus, E9 is 233, and one could also use the entity reference &#233;.

While for the long term, the largely equivalent³⁷ second or third methods are superior, there are caveats for their use in 2007:

• One's LaTeX back end must have a suitably robust way of handling Unicode, presumably via the inputenc package or possibly via Omega/Lambda.

• Even when fonts are available, some web browsers seem only to handle Unicode via entity references.

5.9.  Tabular Environment Emulation

At this point (2006-7) the didactic document type is able to accomodate emulation of LaTeX's tabular environment with “l”, “c”, “r”, and “p” column cell specifiers with, where robust CSS support is available for HTML, “|” indicators for vertical cell rules and “\hline” commands for horizontal rules between rows. While multicol, and multirow are not modeled, cells may contain other tabulars recursively.

A “p” column specifier optionally takes a decimal argument that represents the fraction of available width to be made available for the cells in that column. When is no fractional width specifier, the default fractional width is {1}/{n+1} where n is the total of number of columns.

What may be viewed as a shortcoming of the tabular emulation is that in each tabular row the first cell must contain some markup in order for the document to be structurally correct. This arises from a rule associated with SGML document types that might be overcome if GELLMU source were processed by a monolithic program. Instead, however, it is an assemby of separate components (appendix 7.5.2) in which the first stage has knowledge of syntax but not of the markup vocabulary.

One thing to keep in mind with tabular is that in the current, though probably not future, design of HTML tables are not allowed in paragraph content. The didactic production system works hard to deal with this. In most web browsers there will be a line break before an HTML table and again after an HTML table. (One way to finesse that is to place a table in a cell in a sur-table, which is abuse of markup.) This author generally places a tabular inside a display, which is the GELLMU object corresponding to LaTeX's center.

The document type does not offer “floating” objects, and, therefore, the name table is not used as as in LaTeX.

The name table is used for emulation in regular GELLMU source of HTML tables. A table, like a tabular, takes a required argument consisting of column specifiers. In the didactic production system at the point where an article is spun to the elaborated XML version of article, there is no longer a distinction between tabular and table.

There is also array, which, as in LaTeX, is the in-math version of tabular, except that in GELLMU its emulation of LaTeX's array survives translation to the XML version of article. An array has only “l”, “r”, and “c” cells.

Example: The markup for the table of DTD's in Appendix B.2.2 is this:

\begin{display}

\begin{tabular}{l|cc}

~                       & Latin-1              & \abbr{UTF-8}          \\

\hline

First stage \abbr{SGML} &  \quostr{gellmu.dtd} &  \quostr{ugellmu.dtd} \\

Author Level \abbr{XML} &  ~                   & \quostr{axgellmu.dtd} \\

Elaborated \abbr{XML}   & \quostr{xgellmu.dtd} & \quostr{uxgellmu.dtd}

\end{tabular}

\end{display}

Because the one horizontal divider and the one vertical divider rely on CSS support in HTML, these dividers might not be seen in a web browser with weak CSS support.

5.10.  Graphic Inclusions

There is basic support for graphics inclusions suitable for the HTML backend and the LaTeX backend with both DVI and PDF outputs. The arrangements are not unlike those required for the use of the includegraphics command provided by LaTeX's graphicx package. This means that, apart from the didactic production system's chain of processors, one needs to provide several different versions of a given graphic object in order to accommodate the needs of the three different output formats (HTML, PDF, and DVI). A reliable graphics format converter such as that provided by ImageMagick (http://www.imagemagick.org/) or the netpbm utilities (http://netpbm.sourceforge.net/) and a broad TeX support environment similar to that provided by TUG's TeXLive are essential for work with included graphics.

For example, if one begins with an encapsulated PostScript image glmy.eps made, say, with Metapost, then one might run the commands

   epstopdf glmy.eps

   convert glmy.pdf glmy.png

before making PDF with pdflatex and PNG (for inclusion in HTML). In this case the PDF version of the graphic should be regarded as best for use with pdflatex, and so one wants to have the PNG version out of view from pdflatex when building the GELLMU source glman.glm for this document. With the new mmkg drivers one may prepare a tiny file glman.prx that is a list of names of image files, one file per line, that should be out of view at the point in the pipeline when pdflatex is active. Thus, a line in the file glman.prx should contain the name glmy.png.

In glman.glm one has the code:

\begin{quotation}

   Sometimes a picture is worth a thousand words.

   \display[:frame="1.1"]{\includegraphics[:scale="0.2"]{glmy}}

\end{quotation}

which yields:

Sometimes a picture is worth a thousand words.

In this markup one sees, first of all, two uses of SGML attributes — frame and scale. Attribute options are opened with “[:” rather than simply with “[”. Whereas options generally may contain markup, attribute options may not.

The meaning in this example of scale is that the width of the graphic in DVI and PDF outputs will be the result of multiplying the scale by LaTeX's value of \textwidth.³⁸ The HTML formatter will link to the PNG without a width specification. Thus, the brower window width of the graphic will be the actual width of the PNG image unless, perhaps, it's too large for the browser's window. The meaning of frame is that for print outputs the graphic image will be surrounded by a LaTeX framebox with diameter that is 1.1 times the diameter of the display's content. In the current HTML formatter no use is made of the numeric value of frame although a default frame is constructed via an HTML attribute giving values for the CSS properties border and padding. When image framing is desired, another approach is to incorporate framing in the graphic itself.

6.1.  General

There was previous mention of the basic mathematical container element tmath in the discussion of single string (section 5.2.2) markup and the math and displaymath elements in the discussion of certain strings (section 5.2.3) of special markup significance.

The markup used inside these containers is very similar to that which is used in LaTeX although far from all of LaTeX's math markup, as extended by the amsmath package, has any analogue in the didactic production system.

There are a few things that deserve short mention:

\sum, \int, and \prod

are all similar to their LaTeX namesakes except that each requires explicit closure. For example,

\[ \sum_{0}^{\infty} \frac{x^k}{k!} \sum: \]

produces

SUM_{0}^{INFTY}[{x^{k}}/{k!} ]    .

\regch, \mbox, and \text

The didactic document type provides regch, for “regular character” that is a one character version of mbox provided for separating from general mbox matter the content to which a non-math algorithmic accent (section 5.8), may be applied. For example,

\newcommand{\Q}{\regch{\bold{Q}}}  % intended for use in math

\newcommand{\galQ}{\mbox{Gal}(\ovbar{\Q}/\Q)}  % only in math

$\galQ$\aos;

produces Gal(\={Q}/Q).

Both regch and mbox should be used only for symbols. Note that “Gal” in the foregoing is a symbol. The command \text is provided for the use of text phrases – usually conjunctive in nature – inside math zones. For example, the markup

\[ \absval{x} = \lbalbr{\begin{array}{rl}

             x & \text{\ if\ } x \geq 0 \\

            -x & \text{\ if\ } x < 0

            \end{array}} \]

produces

|x|   =

{ x   if  x  >=  0 -x  if  x < 0

In this example note that the command name lbalbr stands for “left balanced brace”. It corresponds to the use of \left\{  ...  \right. in LaTeX³⁹.

\aos;, \aoc; \aoq;, and \aoe;

are the named forms of the LaTeX space adjustment commands “\@.”, “\@,”, “\@?”, and “\@!”, which provide correct placement of inline punctuation immediately following inline mathematical markup. There is now also default provision in the didactic production system for the more LaTeX-like “\@” usage. Note that the use of \@ is seldom necessary.

6.2.  Assertions: Near Emulation of LaTeX's Theorem-Like Environments

6.3.  Equations and Equation Arrays

The general usage for equation is the following:

\begin{equation}[key][series]

  .  .  . 

\end{equation}

The options key and series represent the same things as the corresponding label (section 5.5.1) options. In order to use the series option, a key option, which may simply be empty, must be present. The use of “equation*” as a name for an equation display that is not numbered is not permitted, but one may instead use the nonum attribute as follows:

General usage for an equation array (name eqnarray) is:

\begin{eqnarray}[key][series]

  .  .  . 

\end{eqnarray}

where the content is an eqnabody consisting of eqnrow's, each row may be terminated in LaTeX-like markup, as in LaTeX, with the string “\\” and consists of three parts, corresponding to elements eqnleft, eqncenter, and eqnright, that may be separated in LaTeX-like markup with the character ‘&’.

Support for numbering in eqnarrays is only minimally developed although there is suggestive sketching in the didactic document type that is not supported in the formatters. By default the equations in equation arrays are numbered consecutively throughout an article. This behavior can be altered by using the series attribute of an eqnarray. If that is done, then, as things have been sketched, numbering applies to whole arrays rather than to the equations within arrays. Numbering in an equation array may be suppressed by setting its attribute nonum to the string “true”.

6.4.  The \mathsym Metacommand

mathsym is a macro substitution metacommand that is available in the didactic production system for enabling an author to declare that a macro name represents a mathematical symbol. It is a formal way of recording statements commonly made by authors in introducing notation.

Unlike regular metacommands, which may appear at any point in GELLMU source, mathsym may only appear in the preamble of an article, or, equivalently with defaults in the syntactic translator, mathsym may only appear before the LaTeX-like “\begin{document}”.

Its usage is:

Here symbol-name is an alphanumeric string (case-sensitive) beginning with a letter. The second argument is the presentation rendering of the symbol in GELLMU markup. It is like the definition of a newcommand except that it may not involve arguments.⁴¹ The optional third argument symbol-meta-info is an alpha-numeric string that might also include possibly a few other string characters such as ‘/’, ‘-’, ‘,’, ‘.’, ‘*’, etc. Its exact structure depends on the typing system. (No typing system is part of the didactic production system.) For example, it might consist of (name, value) pairs for conveying meta-information about the symbol.

The syntactic translator replaces each invocation of a given mathsym with the specified rendering and writes for each mathsym definition a corresponding element in the SGML output whose content consists solely of the declared symbol name if there is no meta information but otherwise consists of the symbol name followed by a blank space and then whatever string of meta information is provided in the optional argument. Additionally, each invocation is wrapped in a rendering-inert Sym element whose key attribute reveals the name given to the symbol at the point of declaration (and by which the symbol is invoked). This makes it possible for a downstream authoring platform processor that has remembered the list of declared symbol names to match each invocation of a declared symbol with its associated meta information, if any, provided by the author in the symbol declaration.

A related feature in the didactic GELLMU document type is the mlg tag for marking mathematical logical groups. This is somewhat akin to the lgg tag for TeX-like logical groups, traditionally created in TeX markup with braces that are not attached to a command.⁴² As with lgg there is no obvious evidence of an mlg tag in a typeset rendering, but the presence of such a tag is intended as a signal to downstream mathematical parsers that the contents of the tag be given grouping priority as, say, with visible parentheses. Furthermore, the mtype and mml attributes of the mlg tag may be used to pass semantic information about the tag's contents to a processor.

7.1.  Permission

The items of the didactic production system are copyrighted free software released under the GNU General Public License.

7.2.  Materials

The release contains everything originating with the author that is currently used in “building” GELLMU documents.

It also contains a slightly modified version of David Megginson's Perl module “SGMLS.pm” based on another slightly modified version that was furnished to me by Dave Holden in a very quick early 1999 response to my posted request for a modification that handles the labels provided (optionally) by nsgmls for SGML elements that are defined empty. A similar slight modification was also supplied a few days later by Vassilii Kachaturov and had been available at his web site.

Although the materials offered in this package aside from the syntactic translator pertain only to the didactic document type and the didactic production system, it should be understood that the larger design for GELLMU envisions other parties, on the one hand, building in various ways to extend the functionality of the didactic system, and, on the other hand, applying the methods of the didactic system to other document types and other formatting programs for those document types.

The basic items originating with the author, aside from the document type definition files (section B.2.2) are:

gellmu.el

the GELLMU syntactic translator, which makes SGML

xplaingart.pl

converts SGML to author-level XML

xmlgart.pl

converts author-level XML to elaborated XML

ltxgart.pl

translates elaborated XML to LaTeX

htmlgart.pl

translates elaborated XML to classical HTML and translates specially prepared XML to XHTML+MathML

mathcdata.pl

first of two special preparations for translation toward XHTML+MathML

mathprep.pl

second of two special preparations for translation toward XHTML+MathML

mval.pl

check for certain types of MathML errors

Since some users will only be interested in the syntactic translator, additional description of these materials is found below in “Using the didactic production system” (section 7.5) and in the Release Notes (appendix B).

7.3.  Other Required Software

To make use of the GELLMU syntactic translator a user must have or separately acquire Emacs.⁴³ (“Windows” users should look at the special FAQ.) Emacs is commonly found on GNU/Linux systems and on *ix systems. It may be found on other systems when provided by system managers.⁴⁴

To make use of the didactic production system beyond the syntactic translator a user must have or acquire the following items of free cross-platform software

• an ESIS generating SGML parser such as found in the cross-platform package SP by James Clark, which has stood the test of years, or the newer variant OpenSP, which is internationalized, from the OpenJade Team.

• Perl at CPAN.

• a complete TeX system, for which one may look to The TeX Users Group (TUG) or The Comprehensive TeX Archive Network (CTAN).

• xmlwf — a basic utility that is part of the release of James Clark's expat.

7.4.  Using the syntactic translator

This explains how to use the syntactic translator, which is the Emacs Lisp program contained in the file gellmu.el.

7.5.  Using the didactic production system

7.5.2.  Default Staging

The release includes bin/linux/lmkg and bin/linux/mmkg as example driver scripts for running the following sequence. (The bin/win32 directory contains old driver scripts for the MS Windows command line that might someday be worth updating.) The behavior of these driver scripts depends on the way they are called though the specific of this are somewhat different for lmkg than for mmkg. The older lmkg scripts do not generate XHTML+MathML at this point they are provided primarily for backward compatibility.

The mmkg scripts by default make XHTML+MathML but not if called by a name, e.g., via a symbolic link, without the substring “mm”. If an mmkg script is called with a name ending in the string “froms” or “fromx”, then it will take as starting point, respectively, an SGML, i.e., “.sgml”, or author-level XML, i.e., “.xml”, version of the document. Thus, for example, mmkgfromx might be used to operate on a document that is an author-level XML translation from a non-GELLMU source.

Caution. These scripts, like all shell scripts, should be examined for file system locations, system environmental variables, and other platform-specific and location-specific issues. The user who introduces a script on a platform should understand the script. A user who does not understand a script should not attempt to introduce it on a local platform.

Flow in the didactic production system is portrayed in the following diagram:

These are the stages in the didactic production system pipeline:

1. Prepare GELLMU source using a text editor.

2. Process the source with the syntactic translator to obtain an SGML document under the didactic document type.

3. Use nsgmls to validate the SGML document and obtain an ESIS for it as output.

4. Submit the SGML ESIS as input⁴⁷ to the Perl program sgmlspl with the script xplaingart.pl as file argument, obtaining an author-level XML document.

5. Use nsgmls to validate the author-level XML document and then submit its ESIS as input to to sgmlspl with the script xmlgart.pl, obtaining an elaborated XML document. This document, which is accompanied by several auxiliary files⁴⁸, has things such as sectional unit numbers and cross references fully resolved so that there will be consistency in these across the various output formats.

6. Use nsgmls to validate the elaborated XML document and submit its ESIS as input multiply to sgmlspl:

   1. with the script htmlgart.pl to obtain a classical HTML document that then will be validated if an HTML validation program is identified in the driver script.

   2. with the script ltxgart.pl as file argument, obtaining a LaTeX document. The LaTeX document is then built with latex to make a DVI file and with pdflatex to make a PDF file.

   3. for a pipeline using successive runs of sgmlspl with 3 scripts, mathcdata.pl, mathprep.pl, and htmlgart.pl (called in a special way) to make a XHTML+MathML file that is then checked for XML well-formedness using xmlwf, checked for certain kinds of MathML errors using sgmlspl with mval.pl, and validated if a suitable validation program is identified in the driver script.

B.1.  Comments on the Syntactic Translator

The GELLMU syntactic translator is more mature than the other components. The following comments pertain to it.

internationalization

Internationalization has a considerable and evolving level of support in Emacs. The concept is that an author resides in a locale. When the author enters a character from a locale, it gives rise in Emacs to a somewhat complicated multibyte entity that can have “properties”. Particularly relevant variables in Emacs are: coding-system-for-write and buffer-file-coding-system. GELLMU provides the user variable gellmu-sgml-default-coding, which should be properly coordinated via driver script settings with one's SGML parser.

inclusions

It is not actually a limitation that a GELLMU source file cannot be included in another. The primary reason is that one should make use of the inclusion mechanism of SGML. For that one needs to define the included pieces as entities in the direct internal subset ⁵⁰ of the source file and then reference each as an entity, e.g., “&sect2;” at the appropriate location in the source file where it is to be included. Because the inclusion happens at the SGML level there are two points to observe:

1. Macro information is local to each source file.

2. The situation is optimal for the location of validation errors provided that one's parser reports such errors by filename and line number since the syntactic translator provides line number alignment between source and generated SGML.

A second reason is that source inclusion would disturb line number alignment between source and SGML output. This is important for the interpretation of SGML validation error messages. Such validation is considered routine, and plays an important role in detecting an author's mistakes. Some author errors are diagnosed in the syntactic translator.

A third reason, which at the same time might be considered also a disadvantage, is that all of GELLMU's macro facilities are local to each source file. This adds both robustness and flexibility at the price of the inconvenience of physical inclusion of common macro definitions.

variable management

This refers to the management of user variables in the syntactic translator. These are Elisp variables. One who is familiar with Elisp should be able to provide values in batch mode without making changes in the Elisp source.⁵¹ Setting values interactively in the Emacs editing interface can be done easily using “M-x set-variable”.

With a future release it is likely that additionally a user resource file for custom variable settings without the need for writing Elisp code will be provided.

Bugs

No serious existing problem is known in the GELLMU syntactic translator at the time of this release. Of course, as stated in source code comments, there is no warranty of any kind. Please report bugs to the author: [email protected].

• Reserved element names. The GELLMU syntactic translator reserves for its own internal use all SGML or XML element names in which the first numeric character in the range “0–9” is the character “0”.

• Limitation on braces in macros. Unbalanced braces are not permitted in either the name or the value field of any form of macro metacommand.

• First cell limitation. In the LaTeX-like emulation of an array or tabular environment the first cell in each row must have something other than whitespace. Of course, sometimes no content is wanted, and then \empty (for nil markup, not to be confused with the mathematical \emptyset) is one way to handle it, but this author usually uses something that is mostly inconsequential like “~” or “\,”. Another way to handle it is to invoke the names of the SGML elements, i.e., \firstcell{} for tabular or \firstacell{} for array.

• Concept of advanced GELLMU immature. Inasmuch as didactic article is the only document type for which the idea of advanced GELLMU has been implemented, the general concept of advanced GELLMU is not fully developed in the GELLMU syntactic translator. Basic GELLMU is characterized in the GELLMU syntactic translator by the evaluation of the Boolean variable gellmu-straight-sgml to “true”. This automatically make the Boolean variable gellmu-regular-sgml true. Full LaTeX-like support for the didactic production system is realized only by both of these Booleans being false. Thus, advanced GELLMU will need to evolve in the space in between, probably after the introduction of further such Boolean variables, some public and some private. This technique will make it possible for the code to continue performing as now when the variable gellmu-straight-sgml, the flag for basic GELLMU, is true and also when both of these flags are false.

• Reserved strings. The strings “<<” and “>>” have been reserved as future notation for mathematical objects. Although it might seem at first glance that this type of short hand has no place apart from the fully LaTeX-like environment of the GELLMU syntactic translator in the context of the didactic production system, in which they have not yet been used, it is actually not so clear that one could not make sensible use of such notation in the context of “XHTML plus MathML” under advanced GELLMU along with other features such as blank lines for new paragraphs and many other mathematical shortcuts. It awaits the further development of advanced GELLMU, and reserving this notation is necessary to ensure backward compatibility.

  Consequently, for example, entering “<<a>>” is problematical, because only the first “<” or “>” will be converted to something appropriate. In basic mode “&lt;” and “&gt;” are one-step ways of circumventing this when these entities are available, which is guaranteed for any form of HTML as well as for any form of XML. In the didactic production system one should use “\ltc;” and “\gtc;”. For other cases the one-step circumvention is to use entity references to the numeric character codes, e.g., in ASCII “&#3C;” and “&#3E;”, and for convenience these may be brought up as macros, perhaps “\lt” and “\gt”.

B.2.  Comments on the Didactic Production System

The didactic production system is to be understood as a potential base for development. As such it is not intended ever to offer everything that might be imagined. The following comments pertain to it.