TITLE: LTX2X: A LaTeX to X Auto-tagger AUTHOR(S): Peter R. Wilson Catholic University of America (This work was performed while a Guest Researcher at the National Institute of Standards and Technology) Email: pwilson@cme.nist.gov DATE: January 1997 ABSTRACT: L2X is a table-driven program that will replace LaTeX commands by user defined text. This report describes the beta version of the system. L2X supports both a declaritive command style and an interpreted procedural language tentatively called EXPRESS-A. Details are given of the program functionality including examples. System installation instructions are provided. SECTION: Introduction (sec:introduction) LaTeX [ LAMPORT94], which is built on top of TeX [ KNUTH84a], is a document tagging system that is very popular in the academic and scientific publishing communities because of the high quality typeset material that the system outputs for normal text and especially for mathematics. In particular, many of the documents forming the International Standard ISO 10303, commonly referred to as STEP [ STEPIS], have been written using LaTeX as the document tagging language. Lately there have been moves towards converting the STEP documents to embody SGML [ GOLDFARB90] rather than LaTeX markup. This has led to an interest in the automatic conversion from LaTeX to SGML documents. The L2X system is an initial attempt to provide a generic capability for converting LaTeX tags into other kinds of tags. The L2X system described below is in a beta release state. That is, there is probably some more work to be done on it but experience from use is needed to determine desirable additional functionality. However, the code has been stable for some time. Bug reports or suggested enhancements (especially if the suggestions are accompanied by working code) are encouraged, as are constructive comments about this document. Essentially, L2X reads a file containing LaTeX markup, replaces the LaTeX commands by user-defined text, and writes the result out to another file. The program operates from a command table that specifies the replacement text. In general, no programming knowledge or skills are required to write a command table, which L2X will then interpret. Some knowledge of LaTeX is required, but no more than is necessary for authoring a LaTeX document. L2X has proved capable of performing such functions as: o Conversion of documents marked up according to a specific LaTeX documentclass to documents tagged according to a specific SGML DTD. o Removal of LaTeX commands to produce deTeXed source. o Conversion of simple LaTeX documents to HTML [ MUSCIANO96] tagged documents for publication on the World Wide Web. The remainder of this introduction gives an overview of the L2X program. The command table is described in more detail in section (sec:command-table) and information on running the L2X program is provided in section (sec:program). Section (sec:expressa) gives an overview of the EXPRESS-A language. (Footnote: The overview is necessarily rather brief as I am shortly moving to a new place of employment and EXPRESS-A is the latest addition to the system.) Although the functionality available through the command table facility is suitable for many tasks, especially since an interpreter for the EXPRESS-A general programming language is included within L2X, section (sec:special) gives details on how the system can be extended for cases where this proves to be inadequate. The report ends with several appendices. An example command table for deTeXing a document is reproduced in (sec:detexing) and some of the issues in converting from LaTeX to HTML are discussed in (sec:htmling). The known limitations of L2X are listed in (sec:limitations) and a summary of the command table facilities are given in (sec:summary). Appendix (sec:install) provides instructions on installing the L2X program, together with copyright and warranty information. Finally, (sec:ctabgrammar) and (sec:expgrammar)provide grammars for the command table and EXPRESS-A, respectively. SUB-SECTION: Overview The intent of Leslie Lamport, the author of LaTeX, was to provide a document tagging system that enabled the capture of the logical structure of a document. This system uses Donald Knuth's TeX system as its typesetting engine [ KNUTH84a], and thus has an inherent capability for high quality typesetting. All LaTeX commands are distinguished by starting with a backslash (\). Generally speaking, the name of a command is a string of alphabetic characters (e.g. \acommand). Commands may take arguments. Required arguments are enclosed in curly braces (i.e. { and }). Optional arguments are enclosed in square brackets (i.e. [ and ]). The general syntax for a command is the command name (preceded by a backslash) followed by the argument list with a maximum (Footnote: Under very unusual circumstances this limit may be exceeded.) of nine arguments. The L2X program reads a LaTeX document file and outputs a transformation of this file. By default it outputs the normal text while for each LaTeX command and argument performs some user-specified actions; typically these actions involve the output of specific text corresponding to the particular command. The actions are specified in a command table file, written by the user, which is read into the L2X system before document processing is begun. A command table consists of a listing of the LaTeX commands of interest together with the desired actiond for each of these commands and their arguments. Different effects may be easily obtained by changing the command table file. For example, a simple command table file may be written that will delete all the LaTeX commands from a document, resulting in a plain ASCII file with no embedded markup. (Footnote: To afficionados, this process is known as de-TeX ing.) A more complex command table may be written that will replace LaTeX tags with appropriate SGML tags. In some circles it is traditional to introduce a programming language by providing an example program that prints `Hello world'. In contrast, the following command table file called bye.ct, when used in conjunction with a typical vanilla LaTeX file, will transform the LaTeX file to a file that consists only of the words `Goodbye document'. C= bye.ct "Goodbye document" for ltx2x TYPE= COMMAND NAME= \documentclass START_TAG= "Goodbye document" PC_AT_END= NO_PRINT END_TYPE C= just in case a LaTeX v2.09 document TYPE= COMMAND NAME= \documentstyle START_TAG= "Goodbye document" PC_AT_END= NO_PRINT END_TYPE C= just in case there is no \documentclass/style command TYPE= BEGIN_DOCUMENT START_TAG= "Goodbye document" PC_AT_END= NO_PRINT END_TYPE TYPE= OTHER_COMMAND PRINT_CONTROL= NO_PRINT END_TYPE TYPE= OTHER_BEGIN PRINT_CONTROL= NO_PRINT END_TYPE TYPE= OTHER_END PRINT_CONTROL= NO_PRINT END_TYPE END_CTFILE= end of bye.ct Essentially the command table instructs L2X what to print for each LaTeX command. A command table file consists of a series of commands, one per line and introduced by a keyword such as TYPE=. Keywords are case insensitive but by convention are written in upper case. Comments in a command table are introduced by the keyword C=. The main body of a command table consists of the specification of LaTeX commands of interest and the actions to be taken for these. Each specification commences with the keyword TYPE= and is completed by the keyword END_TYPE, the relevant actions being listed between these two keywords. L2X treats some LaTeX commands specially; among these are \begin{document} and \end{document}. In a command table these are specified by the types TYPE= BEGIN_DOCUMENT and TYPE= END_DOCUMENT. The actions at \begin{document} are firstly to print the string `Goodbye document' (specified in the line START_TAG= "Goodbye document") and secondly to stop printing any output (specified in the line PC_AT_END= NO_PRINT). By not specifying the END_DOCUMENT entry, the default action is used for the \end{document} command. The command table entries for the commands \documentclass and \documentstyle specify that, if either of these is in the source document, then it is to be replaced by the text string "Goodbye document", and then all further printing is to be switched off. The other three entries in the command table specify the actions for any other kind of LaTeX command. The keyword OTHER_BEGIN signifies a LaTeX command of the form \begin{name} and OTHER_END signifies a command of the form \end{name}. The keyword OTHER_COMMAND signifies any other kind of LaTeX command (e.g., \acommand ... ). The actions declared for these are all PRINT_CONTROL= NO_PRINT which shuts off any printing of the command or its arguments. In the command table bye.ct these are only included to prevent printing before the \begin{document}. To run L2X with the above command table, type the following (where > is assumed to be the system prompt): > ltx2x -f bye.ct input.tex output.tex where bye.ct is the name of the command table, and input.tex and output.tex are the names of the input LaTeX file and the resulting processed file respectively. As an example of a more useful command table file, the following one called decomm.ct will remove all LaTeX comments from a typical LaTeX source file. C= decomm.ct Command table file for ltx2x to de-comment LaTeX source C= ------------------------------------ set newline characters ESCAPE_CHAR= ? NEWLINE_CHAR= N C= ----------------------------------- built in commands TYPE= BEGIN_DOCUMENT START_TAG= "\begin{document}" END_TYPE TYPE= END_DOCUMENT START_TAG= "\end{document}" END_TYPE TYPE= BEGIN_VERB START_TAG= "\verb|" END_TYPE TYPE= END_VERB START_TAG= "|" END_TYPE TYPE= BEGIN_VERBATIM START_TAG= "\begin{verbatim}" END_TYPE TYPE= END_VERBATIM START_TAG= "\end{verbatim}" END_TYPE TYPE= LBRACE START_TAG= "{" END_TYPE TYPE= RBRACE START_TAG= "}" END_TYPE TYPE= PARAGRAPH START_TAG= "?N?N " END_TYPE C= ------------------- define '\item' tags within lists TYPE= BEGIN_LIST_ENV NAME= itemize START_TAG= "\begin{itemize}" START_ITEM= "\item " END_TYPE TYPE= BEGIN_LIST_ENV NAME= enumerate START_TAG= "\begin{enumerate}" START_ITEM= "\item " END_TYPE TYPE= BEGIN_LIST_ENV NAME= description START_TAG= "\begin{description}" START_ITEM= "\item" START_ITEM_PARAM= "[" END_ITEM_PARAM= "] " END_TYPE TYPE= END_LIST_ENV NAME= itemize END_TYPE TYPE= END_LIST_ENV NAME= enumerate END_TYPE TYPE= END_LIST_ENV NAME= description END_TYPE C= --------------------- pass through all other LaTeX commands TYPE= OTHER_COMMAND END_TYPE TYPE= OTHER_BEGIN END_TYPE TYPE= OTHER_END END_TYPE END_CTFILE= end of file decomm.ct In the above command table file, the first pair of commands (ESCAPE_CHAR= and NEWLINE_CHAR=) define the character pair that are to be used to signify a `newline' within a tag. An example of their use is later in the file in the PARAGRAPH command type. As indicated above, L2X treats some LaTeX commands specially. These are listed next in the command table. The special LaTeX commands are the begin and end of the document and verbatim environments, together with the \verb command, left and right braces, the \ command, and the L2X PARAGRAPH specification. There are default actions for these, but apart from the \ command the defaults are not appropriate in this case. Above, the actions are to replace the LaTeX command by the string forming the LaTeX command. The exception is that paragraphs (the PARAGRAPH specification) should start with at least one blank line and be indented some spaces. The LaTeX \item command is used within lists. L2X has to be told how to treat the \item command within each kind of list. This has been done above for the itemize, enumerate and description environments. The final instructions in the command table file tell L2X to pass through the text of all other commands and their arguments. The end of the command table file is either the physical end of the file or the command END_CTFILE=, whichever comes first. The END_CTFILE= command acts like the C= command in that arbitrary text can be put after the command. To use the decomm.ct command table to de-comment a LaTeX file, type the following (where > is assumed to be the system prompt): > ltx2x -f decomm.ct input.tex output.tex where input.tex and output.tex are the names of the input LaTeX file for de-commenting and the resulting de-commented version respectively. SECTION: The command table file (sec:command-table) By default, L2X does not output any LaTeX comments. Otherwise, whenever it comes across a LaTeX command it looks at the data in the command table file to determine what actions it should take. The two most typical actions are either to print out the command as read in, or to replace the command by some (possibly empty) text. Each line in a command table file is either blank or starts with a keyword followed by one or more blanks. For example, a comment in the file is a line that starts with C= ; the remainder of the line is any comment text. Comments may be placed anywhere in the file. SUB-SECTION: Special print characters in tags L2X is written in C [ KERNIGHAN88]. The C language enables certain non-printing characters to be defined. These are typically written in the form \c where \ is the C escape character and c is a particular character. L2X understands some of these special printing characters and the command table enables these to be given non-default values. The default escape character (\) may be redefined via the ESCAPE_CHAR= command. For example, ESCAPE_CHAR= ? will make the question mark character the escape character. Typically, the escape character is changed in most command table s to avoid clashing with the LaTeX \ character. The following commands can be used to redefine the C special characters. Each of these commands takes a single character as its value. If a relevant command is not given, then the default value is used. NEWLINE_CHAR= : a new line (default is n) HORIZONTAL_TAB_CHAR= : horizontal tab (default is t) VERTICAL_TAB_CHAR= : vertical tab (default is v) BACKSPACE_CHAR= : backspace (default is b) CARRIAGE_RETURN_CHAR= : carriage return (default is r) FORMFEED_CHAR= : formfeed (default is f) AUDIBLE_ALLERT_CHAR= : beep the terminal (default is a) HEX_CHAR= : following characters form the hexadecimal number of the character to be printed (default is x) (e.g. ?xA3) These command lines are all optional within a command table and their ordering is immaterial. However, if any are present then they must be at the beginning of the command table. The above special characters are useful when specifying the replacement text for LaTeX commands. SUB-SECTION: LaTeX command types The commands for controlling the actions performed on LaTeX commands are enclosed between the command lines TYPE= and END_TYPE, as below. TYPE= CommandType C= a possibly empty set of commands END_TYPE where CommandType is an L2X keyword signifying the kind of LaTeX command being specified. SUB-SUB-SECTION: Built in command types Some LaTeX commands are pre-defined within L2X. Default actions are provided for these but it is recommended that type specifications for each of these commands be put in the command table anyway. The keywords for these commands are: BEGIN_DOCUMENT : Corresponds to the LaTeX command \begin{document}. END_DOCUMENT : Corresponds to the LaTeX command \end{document}. BEGIN_VERBATIM : Corresponds to the LaTeX commands \begin{verbatim} and \begin{verbatim*}. END_VERBATIM : Corresponds to the LaTeX commands \end{verbatim} and \end{verbatim*}. BEGIN_VERB : Corresponds to the LaTeX commands \verb and \verb*, together with the succeeding character. END_VERB : Corresponds to the appearance of the character that completes the LaTeX commands \verb and \verb*. LBRACE : Corresponds to the LaTeX left brace character {. RBRACE : Corresponds to the LaTeX right brace character }. BEGIN_DOLLAR : Corresponds to the LaTeX $ symbol signalling the start of an in-text math formula. END_DOLLAR : Corresponds to the LaTeX $ symbol signalling the end of an in-text math formula. PARAGRAPH : Corresponds to the LaTeX protocol of a blank line signalling the start/end of a paragraph. SLASH_SPACE : Corresponds to the LaTeX \ command. OTHER_COMMAND : Corresponds to any LaTeX command of the form \command not specified elsewhere within the command table. OTHER_BEGIN : Corresponds to any LaTeX command of the form \begin{environment} not specified elsewhere within the command table. OTHER_END : Corresponds to any LaTeX command of the form \end{environment} not specified elsewhere within the command table. The ordering of these built in type specifications is immaterial. If any of the above are not specified within the command table then L2X will use their default action. With the exception of the SLASH_SPACE command type, the default action is to do nothing (i.e., produce no output). The default action for the SLASH_SPACE command type is to output a space. SUB-SUB-SECTION: Optional command types For the purposes of L2X, LaTeX commands are divided into various classes. The keywords for these clases, and the class descriptions, are listed below. TEX_CHAR : Corresponding to LaTeX's special characters (with the exception of the $, { and } characters). CHAR_COMMAND : Corresponding to LaTeX commands of the type \c where c is a single non-alphabetic character. COMMAND : Corresponding to LaTeX commands of the type \command, where command is the name of the command (except for \begin, \end and \item). BEGIN_ENV : Corresponding to LaTeX commands of the type \begin{environment} where environment is the name of the environment, except for those list environments whose bodies consist of \item commands. END_ENV : Corresponding to LaTeX commands of the type \end{environment}, with the same restrictions as for BEGIN_ENV. BEGIN_LIST_ENV : Corresponding to LaTeX commands of the type \begin{environment} where environment is the name of an environment whose body consists of \item commands. END_LIST_ENV : Corresponding to LaTeX commands of the type \end{environment} to match BEGIN_LIST_ENV. VCOMMAND : Corresponding to a LaTeX \verb-like command. BEGIN_VENV : Corresponding to the start of a verbatim-like environment. END_VENV : Corresponding to the end of a verbatim-like environment. SECTIONING : Corresponding to LaTeX commands of the type \command, where command is a document sectioning command such as chapter or subsection. SPECIAL : Reserved for possible future use. SPECIAL_COMMAND : Corresponding to the COMMAND keyword, except that some special output processing is to be defined. SPECIAL_BEGIN_ENV : Corresponding to the BEGIN_ENV keyword, except that some special output processing is to be defined. SPECIAL_END_ENV : Corresponding to the END_ENV keyword, except that some special output processing is to be defined. SPECIAL_BEGIN_LIST : Corresponding to the BEGIN_LIST_ENV keyword, except that some special output processing is to be defined. SPECIAL_END_LIST : Corresponding to the END_LIST_ENV keyword, except that some special output processing is to be defined. SPECIAL_SECTIONING : Corresponding to the SECTIONING keyword, except that some special output processing is to be defined. _PICTURE_ : Corresponding to some of the LaTeX picture drawing commands. COMMAND_... : Corresponding to some of the LaTeX commands whose arrangements of required and optional arguments are untypical. The ordering of these types within a command table is immaterial. Each of the above type specifications requires a NAME= command, whose value is the name of the relevant command or environment being specified. For example, the following is a (partial) specification of the figure environment and the caption command. TYPE= BEGIN_ENV NAME= figure END_TYPE TYPE= END_ENV NAME= figure END_TYPE TYPE= COMMAND NAME= \caption END_TYPE SUB-SECTION: Command action tags When L2X reads a LaTeX command it performs the following actions: (#) Looks up the name of the command or environment in the command table. If it is not found, then the appropriate default type is used. (#) Sets the printing mode according to the PC_AT_START= command. (#) Performs the actions specified in the command table by the START_TAG= command. (#) Processes any specified arguments to the command. (#) Performs the actions specified in the command table by the END_TAG= command. (#) Sets the printing mode according to the PC_AT_END= command. NOTES : : (#) Except for the default processing of OTHER_ types, it does not output the command itself. (#) If a tag action is not specified, then the default action is null (e.g., nothing will appear in the output). Within a command table all text strings for output are enclosed within double quotes. For example: START_TAG= "Some "text" string\n another line of text." Assuming that \n means a newline, when this string action is performed by L2X it will appear in the output file as: Some "text" string another line of text. A text string starts with the first double quote and ends with the last double quote on the command line. A text string has to be written on a single line within the command table. C language special print characters can be embedded within the text string (e.g. the \n for a newline in the above example). Remember that the first section of the command table is used for specifying the particular command table version of these. If a text string is too long to fit comfortably on a single line in the command table, it may be continued via the STRING: command. As many of these can be used in succession as required (subject to internal limitations within L2X). For instance, START_TAG= "Some "text" string\n" STRING: "another line of text." has the same effect as the previous example. The following specification is designed to write out the contents of the \caption command (Footnote: Strictly speaking, the specification does not do this exactly, but this simplified illustration will be corrected in the next sections.) , preceded by the word `CAPTION' and followed by at least one blank line (assuming that the escape character has been set to ?). TYPE= COMMAND NAME= \caption START_TAG= "?n CAPTION " END_TAG= "?n?n" END_TYPE Assuming that somewhere in a LaTeX file there is the command stuff \caption{This is a caption.} more stuff then the expected effect (see footnote) is stuff CAPTION This is a caption. more stuff SUB-SECTION: Argument actions LaTeX commands can take arguments. The text for a required argument is enclosed in curly braces, while the text for an optional argument is enclosed in square brackets. L2X can be directed to perform actions at the start and end of each argument. The number of required arguments is specified by the command line REQPARAMS= where the value of the command is a digit between 1 and 9 inclusive. L2X assumes that a command can have only one optional argument, and that this is either first or last in the argument list. The potential presence of an optional argument is indicated by the command line OPT_PARAM=, where the value is either the keyword FIRST (for first in the list) or LAST (for last in the list). The actions to be performed at the start and end of each required argument are specified via the commands START_TAG_1= and END_TAG_1= for the first required argument, through START_TAG_9= and END_TAG_9= for the ninth argument. The actions to be performed at the start and end of the optional argument are specified by the command lines START_OPT= and END_OPT=. The argument delimiters (the braces or brackets) are not printed. In the simplest case, the action is to print a specified text string (enclosed in double quotes, and continued with STRING: commands if necessary). Other kinds of actions are also possible. An unspecified tag defaults to doing no action. SUB-SUB-SECTION: Print options SUB-SUB-SUB-SECTION: Argument processing By default, L2X processes (i.e. outputs as appropriate) the text of a argument. Printing of the argument text may be disabled, if required. The command line that controls argument printing is of the form PRINT_P1= through PRINT_P9= for required arguments and PRINT_OPT= for the optional argument. The value of these commands is one from several keywords, the most common being NO_PRINT; this switches off printing of the text of the indicated argument. Default printing is resumed after the indicated argument. Continuing the caption example from earlier, we can now complete it. The full syntax of the LaTeX command is: \caption[optional table of contents entry]{Caption in the text} That is, it has one required argument, which prints the caption text both in the body of the document and in the table of contents, unless the first optional argument is present, in which case its value gets printed in the table of contents instead. Assume that an instance of the caption command in a document is: Some stuff \caption[Short caption]{Long caption for the body of the text.} More stuff Recall the previous command table caption specification. The actual output from processing this would be Some stuff CAPTION [Short caption]{Long caption for the body of the text.} More stuff because, unless L2X is told that there are command arguments and how they should be treated, it will just print them out together with their surrounding delimiters. The following command table entry will give more acceptable results. TYPE= COMMAND NAME= \caption START_TAG= "?n CAPTION " END_TAG= "?n?n" OPT_PARAM= FIRST PRINT_OPT= NO_PRINT REQPARAMS= 1 END_TYPE For the above captioning instance, the output will now be: Some stuff CAPTION Long caption for the body of the text. More stuff The default print mode is to print text to the output file. The keywords that can be used to control argument printing are: NO_PRINT : Do not print anything. TO_SYSBUF : Print to the L2X system buffer. TO_BUFFER num : Print to the L2X buffer number num. TO_FILE name : Print to the file called name. NO_OP : Skip all processing of the argument. Note that even if the print mode is set to NO_PRINT, the argument text will still be processed. Only the NO_OP specification temporarly turns off the processing. SUB-SUB-SUB-SECTION: General printing Just as the printing mode can be set for each argument, it can also be set at the start and end of processing a LaTeX command or environment. The specifications PC_AT_START= and PC_AT_END= can be used to set the printing mode at the start of processing a command and at the end, respectively. The keywords that can be used in these specifications are: NO_PRINT : Do not print anything. TO_SYSBUF : Print to the L2X system buffer. TO_BUFFER num : Print to the L2X buffer number num. TO_FILE name : Print to the file called name. RESET : Reset the print mode back to what it was. Unlike the argument printing controls, the print mode is not automatically reset. This has to be explicitly specified. As an example, assume that it is required to remove all figure environments from a LaTeX source and put them into a file on their own. The following command table code could be used to accomplish this. TYPE= BEGIN_ENV NAME= figure PC_AT_START= TO_FILE allfigs.tex START_TAG= "?n\begin{figure}" END_TYPE TYPE= END_ENV NAME= figure START_TAG= "\end{figure}" PC_AT_END= RESET END_TYPE When a LaTeX figure environment is started, printing is switched to go to the file called allfigs.tex. At the end of the figure environment, the print mode is reset back to what it was before the environment began. If at the first figure environment the allfigs.tex file did not exist, then L2X would create it automatically. SUB-SUB-SUB-SECTION: Read actions As noted above, one of the actions that can be specified for a LaTeX comand's argument is to set the print mode for printing to a buffer or a file. Similarly there are actions which will read from a buffer or a file and print the contents. Within an argument tag these kinds of actions are specified via the keyword SOURCE:. This can take one of several values: SYSBUF : Print the contents of the L2X system buffer. BUFFER num : Print the contents of the L2X buffer number num. FILE name : Print the contents of the file called name. In a previous example, the LaTeX figure environments were all written to the file allfig.tex. This file could be read in again just before the end of the document so that all figures will be typeset after everything else. TYPE= END_DOCUMENT END_TAG= "?n % figures collected here by LTX2X ?n" SOURCE: FILE allfigs.tex STRING: "?n\end{document}?n" END_TYPE As another example of the use of the print actions consider the LaTeX \maketitle command. This typesets the arguments of the \title, \author and \date commands, which must have been previously specified but not necessarily in this ordering. Here is one way this can be simulated using L2X. TYPE= COMMAND NAME= \title START_TAG= RESET_BUFFER: 1 REQPARAMS= 1 PRINT_P1= TO_BUFFER 1 END_TYPE TYPE= COMMAND NAME= \author START_TAG= RESET_BUFFER: 2 REQPARAMS= 1 PRINT_P1= TO_BUFFER 2 END_TYPE TYPE= COMMAND NAME= \date START_TAG= RESET_BUFFER: 3 REQPARAMS= 1 PRINT_P1= TO_BUFFER 3 END_TYPE TYPE= COMMAND NAME= \maketitle START_TAG= "?n" SOURCE: BUFFER 1 STRING: "?n?n" SOURCE: BUFFER 2 STRING: "?n?n" SOURCE: BUFFER 3 STRING: "?n?n" END_TAG= RESET_BUFFER: 1 RESET_BUFFER: 2 RESET_BUFFER: 3 END_TYPE For the \title command, the print mode for its argument is set for printing to the buffer number 1. The single action at the start of the command is to make sure that buffer 1 is empty (the line RESET_BUFFER: 1). The actions for the \author and \date commands are similar, except that they print their argument texts to buffers 2 and 3 respectively. The \maketitle command takes no arguments, so all actions must be placed under START_TAG= and/or END_TAG=. There are a set of actions specified for START_TAG=. Firstly a newline is printed and this is followed by the contents of buffer 1 (i.e., the text of the argument of the \title command). Then two new lines are printed, followed by the contents of buffer 2 (the author). Finally another two newlines are printed, the contents of buffer 3 (the date), and another two newlines. The actions for END_TAG= are to clear the contents of the three buffers. Just to extend the example, here is a specification for the LaTeX \thanks command. L2X is not designed to do footnoting (as it does not do page breaking) so instead the thanks text will be placed inside parentheses on a new line. TYPE= COMMAND NAME= \thanks START_TAG= "?n (" REQPARAMS= 1 END_TAG= ") " END_TYPE Given these command table specification and the following portion of a LaTeX document \date{29 February 2000} \title{The Calculation of Leap Days\thanks{Originally published in JIR}} \author{A. N. Other} ... \maketitle then output from L2X will be: The Calculation of Leap Days (Originally published in JIR) A. N. Other 29 February 2000 Note that as the \thanks command appears within the argument of the \title command, it is written to the same place as the text of the argument of \title. Thus, it also gets written to the output file when \maketitle is processed. SUB-SUB-SECTION: Print switching There are individual actions that enable the printing destination to be changed at will within the action set for any particular tag. SWITCH_TO_BUFFER: num : Direct any following printing to the L2X buffer number num. SWITCH_TO_FILE: name : Direct any following printing to the file called name. SWITCH_TO_SYSBUF : Direct any following printing to the L2X system buffer. SWITCH_BACK: : Undo the effect of the last SWITCH_TO... action. As an example of the utility of this type of action, consider again the LaTeX \maketitle command. When LaTeX processes this command, it typesets the date as specified by the \date command, or if this has not been specified then it prints the current date instead. We can arrange for L2X to do something similar by adding the following to the command table shown earlier for the \date and \maketitle commands. TYPE= COMMAND NAME= \documentclass OPT_PARAM= FIRST REQPARAMS= 1 PRINT_OPT= NO_PRINT PRINT_P1= NO_PRINT START_TAG= c= Initialise buffer 3 to `Today' RESET_BUFFER: 3 SWITCH_TO_BUFFER: 3 STRING: "Today" SWITCH_BACK: END_TYPE At the start of the document, the above actions put the string Today into BUFFER 3, having first ensured that it is empty. If the LaTeX source includes a \date command, then the contents of the buffer will be overwritten, otherwise it will be as initialised. In any event, when the \maketitle command is processed, the value output for the date will be either Today or whatever the argument was of the \date command. SUB-SUB-SECTION: Notes on the use of buffers and files Resetting a buffer or a file always has the effect of emptying it of an prior contents. When printing from a buffer or a file, the entire contents are printed. There is no limit to the number of times that a buffer or a file can be used as a printing source. When printing to a buffer, the new strings are appended at the end of the current contents of the buffer, at least until it overflows. Unlike the behaviour of files, this is independant of any intervening prints from the buffer. When printing to a file, the new strings are appended at the end of the current contents of the file. However, if a file is printed to after it has been printed from, the prior contents of the file are lost, and the new string is added at the start of the file. In general, it is safest to treat files as either read-only or write-only. SUB-SUB-SECTION: User specified modes Consider the LaTeX command \\. In normal text this signifies that a line break must occur. In a tabular environment, though, it signifies the end of a row in a table. Suppose that in the L2X procesing of a tabular environment it is required to start and end each row with a vertical bar and to seperate each column also with a vertical bar. However, in normal text a \\ command should just translate into a newline. Just to complicate matters further, assume that in an eqnarray environment, the & column seperator is to be translated to some spaces, and that the string `(X)' is to be put at the end of every row. In other words, we need to process some commands differently according to where they appear in the LaTeX source. An L2X command table provides this capability through mode setting and mode-dependent actions. Here is an example of using this facility to solve the requirements outlined above. TYPE= BEGIN_ENV NAME= tabular C= starting actions, etc., here END_TAG= SET_MODE: tabular END_TYPE TYPE= END_ENV NAME= tabular START_TAG= RESET_MODE: END_TYPE TYPE= BEGIN_ENV NAME= eqnarry C= starting actions, etc., here END_TAG= SET_MODE: eqn END_TYPE TYPE= END_ENV NAME= eqnarray START_TAG= " (X)?n" RESET_MODE: END_TYPE TYPE= TEX_CHAR NAME= & START_TAG= " | " IN_MODE= eqn START_TAG= " " END_MODE END_TYPE TYPE= CHAR_COMMAND NAME= \\ START_TAG= "?n" IN_MODE= tabular START_TAG= " |?n" STRING: " | " END_MODE IN_MODE= eqn START_TAG= " (X)?n" END_MODE END_TYPE Let us look at the specification for the \tabular environment first. The END_TAG= action is specified by the single command line SET_MODE: tabular, where tabular is any convenient name for identifying a mode. Thus, this will set the mode to be tabular. The action at the end of the environment is to reset the mode (RESET_MODE:) to whatever its previous value was. It is assumed that the last row in any tabular environment is finished by \\. Similar actions are performed for the eqnarray environment, except that the mode is called eqn instead of tabular. The other difference is that it is assumed that the last row is not ended by \\, so the end of the eqnarray environment has to also act like the \\. Turning now to the specification for the & command, the first part of the specification identifies the type and name of the LaTeX command. This is then followed by the mode-independent set of actions, which in this case consists of printing a vertical bar with some spaces on either side of it. Following these are any mode-dependent actions, bracketed between IN_MODE= and END_MODE. The value for IN_MODE= is the name of the relevent mode. In this case the only mode-dependent action occurs when MODE eqn is in effect and it is to print some spaces instead of the default spaces and vertical bar. The specification for the \\ command has its set of mode-independent default actions, namely just to print a newline, and two sets of mode-dependent actions. When the tabular mode is in effect, it prints some spaces, a vertical bar, a newline, more spaces, a vertical bar, and finally some more spaces. On the other hand, when the eqn mode is in effect, it prints some spaces, the string `(X)' and a newline. If a mode is in effect that is not defined within the specification (e.g., mode anon) it performs the default mode-independent actions. As a perhaps more practical example, the following command table code will convert simple LaTeX tabular environments to appropriate mark-up for HTML tables. It is assumed that the tabular environment is always within a table environment. To set the perspective a little, here is the code for a simple table in LaTeX: \begin{table}[tbp] \centering \caption{A simple table typeset by \LaTeX.} \label{tab:lxtab} \begin{tabular}{|l||r|r||r|r|} \hline Stock & \multicolumn{2}{c||}{1994} & \multicolumn{2}{c|}{1995} \\ \cline{2-5} & low & high & low & high \\ \hline ABC & 27 & 36 & 23 & 45 \\ DEF & 53 & 72 & 19 & 54 \\ GHI & 28 & 49 & 17 & 79 \\ \hline \end{tabular} \end{table} This will be typeset as shown in table (tab:lxtab). CAPTION: A simple table typeset by LaTeX. (Table: tab:lxtab) Stock | 1994 | 1995 | low | high | low | high ABC | 27 | 36 | 23 | 45 DEF | 53 | 72 | 19 | 54 GHI | 28 | 49 | 17 | 79 The corresponding HTML code for the table after translation is:

A simple table typeset by LaTeX.
Stock 1994 1995
low high low high
ABC 27 36 23 45
DEF 53 72 19 54
GHI 28 49 17 79
In the HTML browser that I use this is displayed approximately as shown for table (tab:httab). CAPTION: A simple table typeset after translation to HTML. (Table: tab:httab) Stock | 1994 | 1995 | low | high | low | high ABC | 27 | 36 | 23 | 45 DEF | 53 | 72 | 19 | 54 GHI | 28 | 49 | 17 | 79 In HTML a table is enclosed between and
tags. Each row of the table is enclosed between and tags, and each element in a row is enclosed between and tags. Under certain circumstances the closing tags (i.e., those like ) can be inferred by the HTML procesors and need not be explicitly put into the source text. The equivalent HTML tags to a LaTeX \multicolumn{num}{col}{text} command are text . The general actions that L2X has to perform in doing the LaTeX to HTML translation are: o The start and end of a table environment has to translate to the HTML start and end table tags and
. (Actually this also needs to handle the centering of the HTML table and drawing a border round it as well.) o The start and end of the tabular environment has to translate into a row start and end in the HTML table (and set the mode for the LaTeX \\ command). o The \\ command must end one row of the HTML table and start the next row (?n). It need not end a data element as this is automatically closed by the end of the row. o The & column delimeter must end one HTML data element and start another one (i.e., ). o The difficulty is in handling the \multicolumn command. In the easy case the LaTeX to HTML translation is: ... & text & ... maps to ... text .... However, when a multicolumn is involved the translation is ... & \multicolumn{N}{P}{text} & ... maps to ... text .... As there is no look-ahead in L2X we have to be careful about starting a data element after a & because at that point L2X cannot know whether or not a \multicolumn command comes next, or just an ordinary data element. We solve this last problem partly by using buffers (numbers 8 and 9 in the specification below) as temporary storage, and partly by a subtle specification for the \multicolumn command. C= start of a table TYPE= BEGIN_ENV NAME= table START_TAG= "
" OPT_PARAM= FIRST C= ignore the optional positioning argument PRINT_OPT= NO_PRINT END_TYPE C= end a table TYPE= END_ENV NAME= table START_TAG= "
" END_TYPE C= start a tabular TYPE= BEGIN_ENV NAME= tabular START_TAG= "?n " RESET_BUFFER: 8 SOURCE: BUFFER 9 END_TAG= "?n " RESET_BUFFER: 8 SOURCE: BUFFER 9 END_TAG= " and for sections, for clauses, etc., and surround the headings with tags and . Further, the first optional argument is of no interest as the output is going to be used by a processing system unable to automatically handle tables of contents. Part of an appropriate command table for doing this is: TYPE= SECTIONING NAME= \section SECTIONING_LEVEL= SECT START_TAG= "?n?n?n" END_TAG= "?n" OPT_PARAM= FIRST PRINT_OPT= NO_PRINT REQPARAMS= 1 START_TAG_1= "" END_TAG_1= "?n" END_TYPE TYPE= SECTIONING NAME= \clause SECTIONING_LEVEL= SUBSECT START_TAG= "?n?n?n" END_TAG= "?n" OPT_PARAM= FIRST PRINT_OPT= NO_PRINT REQPARAMS= 1 START_TAG_1= "" END_TAG_1= "?n" END_TYPE An example output resulting from this command table (if it had been applied to this document) is: ... The command table file By default, ... SUB-SECTION: List environment types In LaTeX the use of the \item command is restricted to within a list environment. The typeset appearance of an \item typically depends on the particular environment in which it is used. L2X has a limited capability of modifying its \item tagging output. It can also provide an `end item' tag for those tagging systems that require such a thing. For such list environments, identified by the command type keyword BEGIN_LIST_ENV, the following command lines should be included within the type specification. START_ITEM= : Actions to be performed at the start of each \item command in the list. END_ITEM= : Actions to be performed after processing all the \item's text. START_ITEM_PARAM= : Actions to be performed at the start of an \item's optional argument text. END_ITEM_PARAM= : Actions to be performed at the end of an \item's optional argument text. As usual, an unspecified tag defaults to no actions. For example, assume that we are not interested in tagging the end of an item, but we do want to mark each item in an itemize environment with the lowercase letter `o', each enumerate item with `(N)' and put a colon after the optional argument in a description environment. Also, each item should have some indentation from the left hand margin. TYPE= BEGIN_LIST_ENV NAME= itemize START_ITEM= "?n o " END_TYPE TYPE= END_LIST_ENV NAME= itemize END_TYPE TYPE= BEGIN_LIST_ENV NAME= enumerate START_ITEM= "?n (N) " END_TYPE TYPE= END_LIST_ENV NAME= enumerate END_TYPE TYPE= BEGIN_LIST_ENV NAME= description START_ITEM= "?n " END_ITEM_PARAM= " : " END_TYPE TYPE= END_LIST_ENV NAME= description END_TYPE With the above commands, this LaTeX text: \begin{description} \item[An example] \begin{itemize} \item the first item; \item the second item. \end{itemize} \end{description} will be transformed into: An example : o the first item; o the second item. SUB-SECTION: Character types LaTeX treats some characters specially. These special characters are: #, $, %, &, ~, _, ^, \, {, }, and, under some circumstances, also the character @. L2X recognizes these special characters and, if directed, will perform specified actions; otherwise it treats them as it treats any alphanumeric character, which is just to print it. It has already been stated that commands for the left and right braces (i.e. { and }) must be given within the command table as command types LBRACE, RBRACE respectively. The dollar symbol ($) must also be specified via the two command types BEGIN_DOLLAR and END_DOLLAR. Here is an example of replacing the dollar signs by tags intended to indicate the start and end of a mathematical phrase. TYPE= BEGIN_DOLLAR START_TAG= "" END_TYPE TYPE= END_DOLLAR START_TAG= "" END_TYPE Commands for the other special LaTeX characters are specified with the TEX_CHAR command type keyword. The characters _ (underscore) and ^ (caret) are used in LaTeX math mode to indicate subscripting and superscripting respectively. The following will replace ^ by , print the superscript text (which must be enclosed in braces (Footnote: It is good practice to always enclose superscript and subscript text in braces, even though TeX does not always require this.) ) and at the end close with . TYPE= TEX_CHAR NAME= ^ START_TAG= "" REQPARAMS= 1 END_TAG= "" END_TYPE Given the above specifications, then $(2^{15} - 1)$ will be transformed into (215 - 1). SUB-SECTION: Verbatim like types The command type VCOMMAND is for the procesing of LaTeX \verb-like commands where the argument of the command is to be typeset as-is. For example, there might be a command called \url which takes one argument which is meant to be an Internet URL. If the application was the conversion of a LaTeX document to HTML, then the following specification could be useful. TYPE= VCOMMAND NAME= \url REQPARAMS= 1 PRINT_P1= TO_BUFFER 7 START_TAG= RESET_BUFFER: 7 END_TAG= "" SOURCE: BUFFER 7 STRING: "" RESET_BUFFER: 7 END_TYPE If the LaTeX source included: ... obtainable from \url{http://www.cdrom.com/pub/tex} then the resulting L2X output would be: ... obtainable from http://www.cdrom.com/pub/tex which, if this was then read via an appropriate browser, a link to the URL would be automatically established. Similarly verbatim-like environments can also be specified with the types BEGIN_VENV and END_VENV. For example, the html.sty package defines three LaTeX environments for documents that might be converted from LaTeX tagging to HTML tagging. One of these, latexonly is for LaTeX code that is not to occur in the HTMLed document and another is htmlonly which contains HTML code that is required for an HTML version of the document but which is not to appear in the LaTeX ed document. The third one is rawhtml which is for HTML code to be output verbatim to the HTML document source. These could be simulated by: TYPE= BEGIN_VENV NAME= latexonly PC_AT_START= NO_PRINT END_TYPE TYPE= END_VENV NAME= latexonly PC_AT_END= RESET END_TYPE TYPE= BEGIN_ENV NAME= htmlonly END_TYPE TYPE= END_ENV NAME= htmlonly END_TYPE TYPE= BEGIN_VENV NAME= rawhtml END_TYPE TYPE= END_VENV NAME= rawhtml END_TYPE SUB-SECTION: Odd command types The majority of commands in LaTeX that take optional arguments have only a single optional argument that is either immediately after the command or after all the required arguments. There are, however, some commands that do not fit this pattern. This set of command types enables at least some of these `odd' commands to be handled. The command type keyword is of the form COMMAND_code, where code indicates the type and ordering of the arguments. The code is composed from combinations of the letters O (for an optional argument) and P (for a required parameter (i.e., argument)). The ordering of these letters in the code specifies the type and ordering of the command's arguments. The `odd' command types are: COMMAND_OOP : Corresponding to a LaTeX command of the form \com[OptParam][OptParam]{ReqParam}. For example, the \makebox command falls into this category. COMMAND_OOOPP : Corresponding to a LaTeX command of the form \com[OptParam][OptParam][OptParam]{ReqParam}{ReqParam}. For example, the \parbox command falls into this category. COMMAND_OPO : Corresponding to a LaTeX command of the form \com[OptParam]{ReqParam}[OptParam]. For example, the \RequirePackage and \LoadClass commands fall into this category. COMMAND_POOOP : Corresponding to a LaTeX command of the form \com{ReqParam}[OptParam][OptParam][OptParam]{ReqParam}. COMMAND_POOP : Corresponding to a LaTeX command of the form \com{ReqParam}[OptParam][OptParam]{ReqParam}. For example, the \newcommand and its companion commands fall into this category. COMMAND_POOPP : Corresponding to a LaTeX command of the form \com{ReqParam}[OptParam][OptParam]{ReqParam}{ReqParam}. For example, the \newenvironment and its companion command fall into this category. As usual, the command name is required, as are any actions. However, it is not necessary to specify the number of required arguments (i.e. REQPARAMS=) nor the position of the optional argument (i.e. OPT_PARAM=), as L2X already has this information. The tag actions are according to the argument ordering given in the code and are specified by the required argument tags (e.g. START_TAG_n= and END_TAG_n=). Do not use any of the command lines for optional arguments. Argument actions are controlled in the usual manner. A typical example of the use of these commands is to supress any processing of the LaTeX \newcommand and its ilk. For example: TYPE= COMMAND_POOP NAME= \providecommand PRINT_P1= NO_OP PRINT_P2= NO_OP PRINT_P3= NO_OP PRINT_P4= NO_OP END_TYPE TYPE= COMMAND_POOPP NAME= \renewenvironment PRINT_P1= NO_OP PRINT_P2= NO_OP PRINT_P3= NO_OP PRINT_P4= NO_OP PRINT_P5= NO_OP END_TYPE SUB-SECTION: Other command types The OTHER_ command types (OTHER_COMMAND, OTHER_BEGIN and OTHER_END) are very limited in what can be affected. Basically, these provide for default printing actions if the corresponding LaTeX command has not been identified elsewhere in the command table. If there are no commands within the specification, the name of the command and all its arguments will be printed verbatim. The command lines START_TAG= and END_TAG= cause the corresponding actions to be performed before and after the name of the command is printed. Any arguments are printed verbatim. The command line PRINT_CONTROL= with a value of NO_PRINT causes the command name not to be printed, nor any arguments that L2X may find associated with the command. SUB-SECTION: Picture types The _PICTURE_ command types differ from all the other types in L2X, just as they do in LaTeX. In LaTeX some of the picture drawing commands take arguments of the form (number, number), representing a coordinate pair, as well as the usual required arguments enclosed in curly braces and possibly an optional argument enclosed in square brackets. Within L2X, commands that take coordinate arguments are treated specially in the command table. Generally speaking, the L2X command types are of the form PICTURE_code, where code indicates the type and ordering of the arguments. The code is composed from combinations of the letters C (for a coordinate argument), O (for an optional argument) and P (for a required argument). For example, PICTURE_PCOP indicates a picture command that has a required argument, followed by a coordinate argument, followed by an optional argument and finally another required argument. The provided picture types are: BEGIN_PICTURE_CC : Corresponding to a LaTeX command of the form \begin{PictureEnv}(coords)(coords), where the final coordinate argument is optional. PICTURE_CCPP : Corresponding to a LaTeX command of the form \com(coords)(coords){ReqParam}{ReqParam}. For example, the \multiput command falls into this category. PICTURE_CO : Corresponding to a LaTeX command of the form \com(coords)[OptParam]. For example, the standard LaTeX \oval command falls into this category. PICTURE_COP : Corresponding to a LaTeX command of the form \com(coords)[OptParam]{ReqParam}. For example, the \makebox and \framebox commands fall into this category. PICTURE_CP : Corresponding to a LaTeX command of the form \com(coords){ReqParam}. For example, the \put, \line and \vector commands fall into this category. PICTURE_OCC : Corresponding to a LaTeX command of the form \com[OptParam](coords)(coords). For example, the \graphpaper command from the graphpap package falls into this category. PICTURE_OCCC : Corresponding to a LaTeX command of the form \com[OptParam](coords)(coords)(coords). For example, the \qbezier command falls into this category. PICTURE_OCO : Corresponding to a LaTeX command of the form \com[OptParam](coords)[OptParam]. For example, the \oval command from the pict2e package falls into this category. PICTURE_PCOP : Corresponding to a LaTeX command of the form \com{ReqParam}(coords)[OptParam]{ReqParam}. For example, the \dashbox and \savebox commands fall into this category. END_PICTURE : Corresponding to a LaTeX command of the form \end{PictureEnv}. As usual, the command name is required, as are any actions. However, it is not necessary to specify the number of required arguments (i.e. REQPARAMS=) nor the position of the optional argument (i.e. OPT_PARAM=), as L2X already has this information. The tag actions are according to the argument ordering given in the code and are specified by the required argument tags (e.g. START_TAG_n= and END_TAG_n=). Do not use any of the command lines for optional arguments. Argument actions controlled in the usual manner. As an example, the following specifications within a command table should be sufficient to ensure that any picture commands in a source file are not passed through to the output file. TYPE= BEGIN_PICTURE_CC NAME= picture PRINT_P1= NO_PRINT PRINT_P2 = NO_PRINT END_TYPE TYPE= PICTURE_CP NAME= \put PRINT_P1= NO_PRINT PRINT_P2= NO_OP END_TYPE TYPE= PICTURE_CCPP NAME= \multiput PRINT_P1= NO_PRINT PRINT_P2= NO_PRINT PRINT_P3= NO_OP PRINT_P4= NO_OP END_TYPE TYPE= PICTURE_PCOP NAME= \savebox PRINT_P1= NO_OP PRINT_P2= NO_PRINT PRINT_P3= NO_OP PRINT_P4= NO_OP END_TYPE TYPE= PICTURE_OCC NAME= \graphpaper PRINT_P1= NO_OP PRINT_P2= NO_PRINT PRINT_P3= NO_PRINT END_TYPE TYPE= PICTURE_OCCC NAME= \qbezier PRINT_P1= NO_OP PRINT_P2= NO_PRINT PRINT_P3= NO_PRINT PRINT_P4= NO_PRINT END_TYPE TYPE= END_PICTURE NAME= picture END_TYPE NOTE 1: : The action NO_OP cannot be applied to an argument that is a coordinate pair. NOTE 2: : As L2X is essentially limited to printing actions, and cannot actually process any LaTeX picture drawing commands, the suppression of picture printing is probably the most usual use of the picture commands. SUB-SECTION: Special command types The SPECIAL_ commands, namely SPECIAL_COMMAND, SPECIAL_BEGIN_ENV, SPECIAL_BEGIN_LIST, SPECIAL_END_ENV, SPECIAL_END_LIST and SPECIAL_SECTIONING, are provided for cases where some special kind of output processing is required that is not built into L2X. In order to implement any commands of these types, it is necessary to modify the internals of L2X and recompile the source code. This is not recommended. SUB-SECTION: File inclusion A command table file can include other command table files. In turn an included file can recursively include other command table files. The file inclusion command line is INCLUDE= FileName where FileName is the name of the command table file to be included. The effect is that the above line is replaced by the contents of FileName. For example, assume that there are three command table files called respectively detex.ct, detex.l2x and detex.fl. The contents of these files are: C= ----------file detex.ct ... INCLUDE= detex.l2x ... C= ----------end of detex.ct END_CTFILE= end of detex.ct and for detex.l2x as: C= ---------- file detex.l2x TYPE= COMMAND NAME= \lx START_TAG= "LTX2X" END_TYPE INCLUDE= detex.fl TYPE= COMMAND NAME= \ctab START_TAG= "command table" END_TYPE C= ---------- end of file detex.l2x END_CTFILE= end of file detex.l2x and lastly detex.fl is: C= ---------- file detex.fl TYPE= COMMAND NAME= \fl START_TAG= "FLaTTeN" END_TYPE C= ---------- end file detex.fl END_CTFILE= end file detex.fl Then, as far as L2X is concerned, the original detex.ct file is treated as though it had been written as: C= ----------file detex.ct ... C= ---------- file detex.l2x TYPE= COMMAND NAME= \lx START_TAG= "LTX2X" END_TYPE C= ---------- file detex.fl TYPE= COMMAND NAME= \fl START_TAG= "FLaTTeN" END_TYPE C= ---------- end file detex.fl TYPE= COMMAND NAME= \ctab START_TAG= "command table" END_TYPE C= ---------- end of file detex.l2x ... C= ----------end of detex.ct END_CTFILE= end of detex.ct Note that nasty things will happen if you have a cycle of inclusions. That is, you must not have anything similar to file A including file B which includes file C which in turn includes either file A or B. SUB-SECTION: Interpreter commands (sec:intcom) L2X includes an interpreter for a procedural programming language that is based on the ISO international standard EXPRESS information modeling language [ EBOOK, EXPRESSIS]. At the moment the programming language within L2X is anonymous, but for ease of reference I will call it EXPRESS-A (EXPRESS -Almost? -Approximate? -Anonymous?). The EXPRESS-A language is described later in section (sec:expressa), but for now it is sufficient to know the commands that signify the start and end of this code. The command CODE_SETUP= indicates the commencement of code to be run before any document processing occurs. The END_CODE command signifies the end of this code block. This block should be placed in the command table before any other commands except for the ESCAPE... commands, if any. This block can contain variable declarations, function and procedure declarations, and statements. Code consisting purely of statements can be placed anywhere that a tagging action may be specified. These statements are enclosed between a CODE: and END_CODE pair of commands. The EXPRESS-A language is described in detail in (sec:expressa), but to give a flavour of it here is a simple possible application. It has been noted that L2X will find difficulty in processing the contents of the LaTeX picture environment. The following portions of a command table write the contents of a figure environment to an external file and uses the programming language to keep a count of the number of figures so processed. c= declare and initialise a variable CODE_SETUP= LOCAL fignum : INTEGER; END_LOCAL; fignum := 0; END_CODE c= write figure contents to an external file TYPE= BEGIN_ENV NAME= figure OPT_PARAM= FIRST PRINT_OPT= NO_PRINT PC_AT_START= TO_FILE figs.tmp START_TAG= CODE: fignum := fignum + 1; -- increment figure counter println; -- print a blank line println('%%% FIGURE ', fignum); -- write counter as a LaTeX comment END_CODE STRING: "\begin{figure}" END_TYPE c= close figure environment, back to normal output, and output c= text indicating that a figure should be here TYPE= END_ENV NAME= figure PC_AT_START= RESET START_TAG= SWITCH_TO_FILE: figs.tmp STRING: "\end{figure}?n?n" SWITCH_BACK: CODE: println; println('PLACE FOR FIGURE ', fignum); println; END_CODE END_TYPE SECTION: The LTX2X program (sec:program) L2X is written using flex and bison. The resulting C code should compile on any system. More details are given later, but for the end-user the next section describes how to run the program, assuming that is available on your system. SUB-SECTION: Running LTX2X The syntax for running the compiled version of L2X is: ltx2x [-c] [-f table-file] [-p number] [-w] [-D dir_cat_char] [-P path_seperators] [-S] [-i number] [-l number] [-t] [-y number] [-C] [-E] input-file output-file where elements in square brackets are options. The options fall into two groups, one for the casual user and the other for those who may be interested in the internals of L2X. The first group of options includes: -c : By default, L2X ignores all LaTeX comments in the input file. This option causes L2X to write the comments to the output file. -f : By default, L2X reads the command table from a file called ltx2x.ct. If the required command table is in a file with another name this option is used to change from the default file. For example, > ltx2x in.tex out.l2x reads a command table from ltx2x.ct, while > ltx2x -f detex.ct in.tex out.l2x reads a command table from file detex.ct. -p : This option causes L2X to `pretty print' the output file (as far as it is able to). The number is required and it indicates the desired maximum number of characters per output line. If this is considered to be too small, then L2X chooses a value. Note that pretty printing is only applied to the source file --- not to any replacement tags. That is, it only tries to format the running text from the source file. -w : By default, L2X outputs source white space just at it reads it. This option causes L2X to collapse any amount of contiguous white space to a single space. The -p option includes the -w option. -D : The value of this option is the character that the operating system uses to catenate directory names to form a path (see (sec:search)). The default value is a slash (i.e. /). The default could be changed to a backslash, for example, by -D \. -P : The environment variable (see (sec:search)) contains a list of directories (also known as path names). In the operating system that I use, these are separated by the colon (:) character which, together with the semi-colon and space characters, form the L2X default separators. The path separator characters can be changed with this option. For example, -P : will make the separators be a colon or a space (space is automatically included in the separator list). -S : This option enables the source level debugger (see (sec:sld)) for any embedded EXPRESS-A code. The second group of options are principally for those who might be extending the L2X system. -i : This produces information that may be useful for debugging the EXPRESS-A interpreter. number is an integer between 1 and 9 inclusive. The greater the number, the more diagnostics are generated. -l : This produces information that may be useful for debugging the L2X program. number is an integer between 1 and 9 inclusive. The greater the number, the more diagnostics are generated. -t : This generates diagnostics related to the processing of the command table file. -y : Like the l option, but produces diagnostic information from the parser (this is actually a null option, but may be useful in the future). -C : Disable any interpreter debugging information during the code generation pass. This is not necessary unless the -i option is used. -E : Disable any interpreter debugging information during the code execution processing.This is not necessary unless the -i option is used. L2X first reads the specified command table file, together with any included files, looking first in the current directory, then in the directories specified by the environment variable (if it exists). It then reads the input-file from the current directory, performs the actions specified in the command table and outputs the results to the output-file. Three other files are also generated. o ltx2xct.lis --- This contains a human-readable form of the internal representation of the command table. It may be useful if there are any errors in the original command table. o ltx2x.err --- This contains any error or warning messages generated by L2X. It also contains any diagnostic information that may have been requested via a command line option. o interp.csg --- This contains a human readable listing of the internal byte code generated by the EXPRESS-A interpreter. When L2X is running normally it prints out a counter to the terminal indicating how many hundreds of input source file lines it has processed. Lack of such output is an indication that the program may be in a loop and chewing up CPU cycles to no avail. In this case, stop the program and examine the output for indications of where the trouble is occurring. A limited number of errors are allowed when processing the command table and the input LaTeX file before L2X gives up and quits. In particular, if it is reading a command table file that includes another file, say one called zilch, that it cannot read, it prints the following message to the user's terminal. Can't open file zilch Enter new file name, or I to ignore, or Q to quit : A Q (or q) response stops L2X from any further processing. An I (or i) response causes L2X to stop looking for the included file and continue processing the current file. Any other response is taken to be the name of an included file, which L2X then tries to read. If it fails, then the above message is repeated. The user is given a limited number of opportunities to identify a readable file before L2X quits altogether with this message: Last attempt. Can't open file zilch. I'm giving up. Regarding performance, the time taken by L2X to process a document does not appear to be significantly different from the time to LaTeX the same document. SUB-SUB-SECTION: Directory searching (sec:search) The program employs a search algorithm to find files that are not in the current directory. It first looks in the current directory and if a file of the given name is found, then that is used. If the file is not found, then it searches for it among directories that are specified in a system environment variable. This variable specifies a list of pathnames, where the directories forming the path are combined using a catenation character. For example, dir1/dir2/dir3 could be a pathname, where the slash (/) is the catenation character. If it is looking for file afile.txt it will catenate the file name to the path name (e.g. dir1/dir2/dir3/afile.txt) and look for that. The pathnames in the list are separated by another character (in fact it can be one from a list of characters). For example here is a list of two pathnames; dir1/dir2;dir1/dir4, where the semi-colon (;) is the pathname separator. By default, the program uses a slash (/) as the directory catenation character and the pathname separators can be a space, or a colon or a semi-colon (i.e., any of :;). All these characters can be altered via the program command line options, and should be set to match the conventions of your operating system. The environment variable used by the program is LTX2XTABLES. On the operating system that I use, I set this in my login file like: setenv LTX2XTABLES .:/dir1/dir2:/dir3/dir4 Your system may have different conventions. Note that if the environment variable is not set, only files in the current directory are considered. SUB-SECTION: System components The system consists of five main components --- a lexer, a parser, a library of support functions and command table parsing code, a user-defined library of functions, and an interpreter for the EXPRESS-A language. SUB-SUB-SECTION: The lexer The lexer is generated by flex [ LEVINE92] (a more functional version of lex [ LESK75]). The source for the lexer is in file l2x.l. Its principal function is to read a LaTeX source file and recognize LaTeX commands. In general, it passes off the relevant command tokens to the parser for performing appropriate actions. However, the lexer does do some processing of the source itself. o It recognizes LaTeX comments (i.e. any text starting with a percent sign and ending with a newline). It silently ignores these comments, unless run with the -c option. o It recognizes the `standard' LaTeX verbatims. It will write out the appropriate tags at the start and end of the verbatim text, while writing the verbatim text directly to the output file, bypassing the parser. It does not distinguish between the unstarred and starred versions of the verbatims. o Newlines and whitespace are directly written to the output file, again bypassing the parser. The -p and -w options control the final appearance of whitespace, newlines and paragraphing. o It recognizes the command \ i.e. a backslash followed by a space, and writes the tags defined in the SLASH_SPACE specification directly to the output file. The lexer is designed to recognize four kinds of LaTeX commands. o Commands of the form \begin{environment} o Commands of the form \end{environment} o Any other command of the form \command o As special cases, commands that are 'verbatim-like' or `verb-like'. When it finds a command, it looks up the command or environment name in the command table and sends the appropriate token and its command table location to the parser. As a special case the contents of verbatim-like environments and the argument of verb-like coommands are processesd within the lexer and not sent to the parser. SUB-SUB-SECTION: The parser The parser is generated by bison [ LEVINE92] (a more powerful version of YACC [ JOHNSON75]). The source for the parser is in file l2x.y. Essentially it defines a very simple grammar for a LaTeX document. That is, the grammar is limited to generic kinds of commands and command arguments. It does not understand the `meaning' of any of the commands or arguments. When the parser receives a token from the lexer it tries to match it with one of the grammar rules, performing the actions specified by the command table. Here is an extract from the parser grammar file, l2x.y, for a LaTeX command that has two required arguments followed by an optional argument. l2xComm2Opt: COMMAND_2_OPT { start_with_req($1); } ReqParam { action_p_p1($1,1); } ReqParam { action_p_opt($1,2); } OptParam { action_last_opt($1); } ; The actions are enclosed in braces, and are interspersed with the elements of the grammar. The token COMMAND_2_OPT indicates that the lexer has found a command that takes two required arguments followed by an optional argument. The parser then performs some actions. The start_with_req function is the standard L2X function for the first action in a command production where the final argument is optional. The $1 refers to the location of the particular command in the command table, and its value is passed to the parser by the lexer. The parser then expects a required argument (i.e. {, token LBRACE) as the start of the required argument, followed by the text of the argument and finished off by a right brace (i.e. }, token RBRACE); the grammar for all of this is specified in the production called ReqParam). If it finds these it performs some further actions, otherwise it reports an error. In this case the action is defined by the function action_p_p1, which is the standard action performed between two required arguments (the second argument in the function call specifies the Pth argument that has been recognized). Another required argument is then expected. In this case the action is defined by the function action_p_opt, which is the standard action performed between the end of the Pth required argument and the start of an optional argument. It then looks for an optional argument, the grammar for which is specified in the production called OptParam. The final action is specified by the standard function action_last_opt for finishing off a command that ends with an optional argument. The grammar for a command that that has two required arguments, and possibly an initial optional argument is similar: l2xComm2: COMMAND_2 { start_with_opt($1); } OptParam { action_opt_first($1); } ReqParam { action_p_p1($1,1); } ReqParam { action_last_p($1,2); } ; SUB-SUB-SECTION: The support libraries Source code for the C main program and support functions is in file l2xlib.c. The main program is responsible for reading in the command table and calling the lexer and parser to do the appropriate processing. The file also contains a variety of support functions that are, or could be, used in the lexer, parser, action library, or user-defined library. The standard actions for the grammar are contained in file l2xacts.c. SUB-SUB-SECTION: The user-defined library The intent of this library is that masochistic users can define their own functions for use within L2X when processing their SPECIAL_ commands, without having to modify the L2X support or action libraries. Source code for the user-defined library should be maintained in a file called l2xusrlb.c and a corresponding header file called l2xusrlb.h. SUB-SUB-SECTION: The EXPRESS-A interpreter The EXPRESS-A interpreter is based on algorithms originally developed by Ronald Mak [ MAKR91] for interpreting Pascal. His original algorithms have been modified and extended to cater for EXPRESS-A. The interpreter module has a minimal interface with the rest of the L2X system, and could easily be modified to be a stand-alone program (in fact it started that way in the first place). The interface between L2X and the interpreter is confined to the small l2xistup.c file. SECTION: The EXPRESS-A programming language (sec:expressa) EXPRESS is a language for information modeling and includes both declarative and procedural aspects [ EBOOK]. There are also two other companion languages called respectively EXPRESS-G and EXPRESS-I. The former of these is a graphical form of the declaritive aspects of EXPRESS, and the later is an instiation and test case specification language. These languages are either ISO international standards [ EXPRESSIS] or on the way to becoming so [ EXPRESSITR]. Certain of the procedural aspects of EXPRESS and EXPRESS-I are relevent to the L2X concepts and so, together with some other reasons, it seemed appropriate to provide an interpreter for a similar language for use within L2X. EXPRESS-A provides a major subset of the EXPRESS procedural language, together with some Pascal-like additions for input and output. Of particular note, strings are a built-in type in EXPRESS-A. The language also supports three-valued logic and the concept of an `indeterminate' value of any type. Earlier I gave an example command table to replace the text of a LaTeX document with the words `Goodbye document'. Here is an EXPRESS-A program that outputs `Goodbye document'. println('Goodbye document'); END_CODE The following gives a brief overview of EXPRESS-A. For more details consult Schenck & Wilson [ EBOOK]. SUB-SECTION: Basic elements EXPRESS-A is a case-insensitive language and uses the ASCII character set. Two kinds of comments are supported --- an end of line comment, which starts with a -- pair and continues until the end of the current line --- and an extended comment. An extended comment starts with a (* pair and is ended by a matching *) pair; extended comments may be nested. The language contains many reserved words, some of which are only applicable to the EXPRESS and EXPRESS-I languages. Identifiers are composed of an initial letter, possibly followed by any number of letters, digits, and the underscore character. Literals are self defining constant values. An integer literal consists of one or more digits, the first of which shall not be zero. Real numbers start with one or more digits, followed by a decimal point. Further digits may occur after the point, and finaly there may be an exponent in the `e' notation format (e.g., 123.456e-78). A string literal is any sequence of characters enclosed by single quote marks. If a single quote mark is meant to form part of the string, two quote marks must be used at that point. Logical literals consists of one of these keywords: FALSE, UNKNOWN or TRUE. EXPRESS-A also includes some other constants. PI stands for the value of the mathematical constant (3.1415...), and CONST_E stands for the value of the mathematical constant e (2.7182...), the base of natural logarithms. The special token ? stands for an indeterminate value of any type. The three constants THE_DAY, THE_MONTH and THE_YEAR are integer values for the current date holding the day of the month (1--31), the month of the year (1--12) and the year (four digits), respectively. SUB-SECTION: Data types EXPRESS-A is a typed language. The simple data types are: INTEGER, REAL, STRING and LOGICAL. The aggregation data types are ARRAY, BAG, LIST, and SET. The array data type is of a fixed size and must have declared lower and upper bounds (index range), such as ARRAY [-7:10] OF. The other aggregate data types are dynamic in size, but may have lower and upper bounds specified for the number of elements, such as SET [2:5] OF, meaning a set that should have between two and five members. For the dynamic aggregates the upper bound may be given as ?, which means an unlimited upper bound, such as LIST [2:?] OF. If a bound specification is absent, then the dynamic aggregate can hold from zero to any number of elements. (Footnote: The dynamic aggregates may not be fully implemented due to lack of time.) Aggregates are one dimensional, but can be chained together for multi-dimensional aggregates, like ARRAY [1:4] OF LIST OF INTEGER; The enumeration data type is a parenthesised comma seperated list of identifiers. These identifiers represent the values of the enumerated type; for instance ENUMERATION OF (red, green, blue) A defined data type is one declared and named by the user using the TYPE and END_TYPE construct. For example TYPE length = REAL; END_TYPE; TYPE crowd_size = INTEGER; END_TYPE; TYPE signal_colour = ENUMERATION OF (red, amber, green); END_TYPE; An entity data type consists of a list of attributes and their types, enclosed in a ENTITY and END_ENTITY pair. An entity type is named. ENTITY an_ent; auditorium_width : length; audience : crowd_size; title : STRING; profit : REAL; END_ENTITY; EXPRESS-A provides for algorithms in the form of functions and procedures. A FUNCTION is an algorithm that operates on parameters and returns a single resultant value of a specified data type. An invocation of a function in an expression evaluates to the resultant value at the point of invocation. For example: FUNCTION func (par1 : INTEGER; par2 : STRING) : STRING; LOCAL str : STRING; -- other variable declarations END_LOCAL; -- the algorithm statements are here RETURN(str); END_FUNCTION; Note that the parameters are typed. A PROCEDURE is an algorithm that receives parameters from the point of invocation and operates on them in some manner. Changes to the parameters within the procedure are only reflected to the point of invocation when the formal parameter is preceded by the keyword VAR. For example: PROCEDURE proc (par1 : INTEGER; VAR par2 : STRING); -- local declarations and the algorithm statements END_PROCEDURE; Note that the parameters are typed. In this case the value of par2 may be changed. Variables are declared in a local block, enclosed by the keywords LOCAL and END_LOCAL. A variable declaration consists of an identifer and its type, such as: LOCAL str : STRING; e1, e2 : an_ent; -- e1 and e2 are both of type an_ent e3 : an_ent; -- so is e3 num : INTEGER; col : signal_colour; matrix : ARRAY [1:15] OF ARRAY [1:15] OF REAL; END_LOCAL; The above declarations must be in the following order: (#) ENTITY and/or TYPE declarations (#) FUNCTION and/or PROCEDURE declarations (#) a LOCAL declaration block After the above can come any number of statements. SUB-SECTION: Statements EXPRESS-A supports the following statements: o Null statement o Assignment statement o Call statement o BEGIN ... END compound statement o CASE ... END_CASE statement o IF ... THEN ... ELSE ... END_IF statement o REPEAT ... WHILE ... UNTIL ... END_REPEAT statement. This also includes the ESCAPE and SKIP statements o RETURN statement All the above statements are completed by a ; (semicolon). The null statement just consists of a semicolon. The assignment statement is used to assign an instance to a local variable or parameter. The data types must be compatible. LOCAL a, b, c : REAL; END_LOCAL; ... a := 2.3E-6; b := a; a := -27.0; c := 33.3*b; The call statement invokes a procedure or a function. The actual parameters provided with the call must agree in number, order and type with the formal parameters specified in the procedure or function declaration. The supplied parameter values must be assignment compatible with the formal parameters. This is an example of calling the EXPRESS-A defined INSERT procedure which takes three parameters: INSERT(my_list, list_element, 0); The compound statement consists of one or more statements enclosed between a BEGIN and END pair. The enclosed statements are treated as a single statement. ... BEGIN a := 2.3e-7; b := a; c := b*33.3; END; The case statement is a means of selectively executing statements based on the value of an expresion. LOCAL a : INTEGER; x, y : REAL; END_LOCAL; ... a := 2; x := 21.9; CASE 2*a OF 1 : x := SIN{x}; 2 : x := SQRT(x); 3 : x := LOG(x); 4 : x := COS(x); -- this is executed 5, 6 : y := y**x; OTHERWISE : x := 0.0; END_CASE; The integer expression following the CASE keyword is evaluated. The result is compared to the values of the case labels and the statement following the first matching label is executed. Execution then continues at the statement following the END_CASE;. If no label matches, then no statements within the case block are executed, except if an OTHERWISE label is included, which will match anything. All other labels are examined before looking for the OTHERWISE. The if ... then ... else statement allows the conditional execution of statements depending on the value of a LOGICAL expression. When the expression evaluates to TRUE the statement(s) following the THEN are executed, after which control passes to the statement following the closing END_IF. When the logical expression evaluates to FALSE or UNKNOWN the THEN statements are jumped over and execution starts at the statement(s) following the ELSE keyword if present, or at the statement following the END_IF keyword. IF a > 20 THEN b := a + 2; c := c - 1; ELSE IF a > 10 THEN b := a + 1; ELSE c := c + 1; END_IF; END_IF; The repeat statement is used to control the conditional repetition of a series of statements. The control conditions are: o finite iteration until an integer expression reaches a specified value; o WHILE a logical condition is TRUE; o UNTIL a logical condition is TRUE. REPEAT i := 100 TO 0 BY -7 WHILE r >= 0.0 UNTIL err < 1.0e-8; ... r := ...; err := ...; END_REPEAT; At entry to the REPEAT statement the iteration variable is initialized to the first bound. If the variable less than or equal to the TO bound and the increment is positive, or the variable is less than the TO bound and the increment is negative, processing jumps to after the END_REPEAT, otherwise processing continues. The WHILE condition is checked and if TRUE then the statements in the body are executed. After these have been executed the UNTIL condition is checked. If this is not TRUE then processing continues by incrementing the iteration variable by either unity or by the BY value if present. The whole process then starts again with the checking of the iteration variable against the TO bound. All three types of controls are optional. If none are given then the REPEAT statement will loop for ever. The escape statement causes an immediate transfer out of the REPEAT statement in which it occurs. The skip statement causes a jump to the end of the REPEAT statement in which it occurs (i.e., to the point where the UNTIL expression is tested). REPEAT UNTIL (a = 1); ... IF a = 0 THEN ESCAPE; END_IF; ... IF a > 10 THEN SKIP; END_IF; ... ... -- SKIP transfers control to here END_REPEAT; -- ESCAPE transfers control to here The return statement terminates the execution of a FUNCTION or PROCEDURE. The RETURN statement within a function must specify an expression, the value of which is the value returned by the function. A RETURN in a procedure must not specify an expression. RETURN(a <> b); -- example for within a function RETURN; -- example for within a procedure SUB-SECTION: Expressions Expressions are combinations of operators, operands and function calls which are evaluated to produce a value. The simplest expression is either a literal value or the name of a variable. SUB-SUB-SECTION: Arithmetic operators The arithmetic operators act on number values and produce a number result. If any operand is indeterminate (i.e., ?) then the result is also indeterminate. The operators are: Unary : The operators + and -, the latter of which negates its following operand. Binary : Addition (+), subtraction (-), multiplication (*), real division (/), exponentiation (**), integer division (DIV), and modulo (MOD). SUB-SUB-SECTION: Relational operators The result of a relational expression is a LOGICAL value. If either operand is indeterminate, the expression evaluates to UNKNOWN. Value comparison : Equal (=), not equal (<>), greater than (>), less than (<), greater than or equal (>=), and less than or equal (<=). Membership : The IN operator tests an item for membership in a dynamic aggregate (e.g., IF fred IN mylist THEN ...). Matching : The LIKE operator compares a string against a pattern, evaluating to TRUE if they match. The pattern characters are: o @ Matches any letter. o ^ Matches any upper-case letter. o ? Matches any character. o & Matches remainder of string. o # Matches any digit. o $ Matches a substring terminated by a space character or end-of-string. o * Matches any number of characters. o \ Begins a pattern escape sequence. o ! Negation character (used with the other characters). o Any other character matches itself. Some examples: o 'The quick red fox' LIKE '$$$$' is TRUE. o 'Page 231' LIKE '$ ###' is TRUE. o 'Page 27' LIKE 'Page ###' is FALSE. o '\aaaa' LIKE '\\aaaa' is TRUE. o '\aaaa' LIKE '\aaaa' is FALSE. o 'aaaa' LIKE 'a@@a' is TRUE. SUB-SUB-SECTION: Logical operators The logical operators produce a logical result. Except for the NOT operator which takes one logical operand (e.g., NOT op), they take two logical operands (e.g., op1 XOR op2). The evaluation of the NOT operator is given in table (tab:not). CAPTION: The NOT logical operator (Table: tab:not) Operand value | Result value TRUE | FALSE UNKNOWN | UNKNOWN FALSE | TRUE The evaluation of the AND, OR and XOR operators is given in table (tab:andorxor). CAPTION: The AND, OR and XOR logical operators (Table: tab:andorxor) Op1 | Op2 | Op1 AND Op2 | Op1 OR Op2 | Op1 XOR Op2 TRUE | TRUE | TRUE | TRUE | FALSE TRUE | UNKNOWN | UNKNOWN | TRUE | UNKNOWN TRUE | FALSE | FALSE | TRUE | TRUE UNKNOWN | TRUE | UNKNOWN | TRUE | UNKNOWN UNKNOWN | UNKNOWN | UNKNOWN | UNKNOWN | UNKNOWN UNKNOWN | FALSE | FALSE | UNKNOWN | UNKNOWN FALSE | TRUE | FALSE | TRUE | TRUE FALSE | UNKNOWN | FALSE | UNKNOWN | UNKNOWN FALSE | FALSE | FALSE | FALSE | FALSE SUB-SUB-SECTION: Miscellaneous Function call : A function may be called without the result necessarily being assigned to a variable. If fun is a function with two arguments (for simplicitly integer arguments) and returning a logical value, then log := fun(i1, i2); fun(i3, 24*i4); are both legitimate calls. Dot operator : The dot operator is used to access an attribute from an entity. If ent is an ENTITY type with an attribute att, then ent.attr evaluates to the value of the attr attribute within the ent. String operators : The + operator takes two strings as its operands and evaluates to the string that is the concatenation of its operands. For example: str1 := 'string1'; str2 := 'string2'; str1 := str1 + str2; -- str1 = 'string1string2' is TRUE The substring operator [i1:i2] is a postfix operator that when applied to a string, evalutes to the string whose characters are composed of the i1'th through the i2'th characters, inclusively, of its operand. Note that i2 must be greater than or equal to i1, and both must be within the limits of the number of characters in the string. For example: str1 := 'string'; str2 := str1[2:4]; str1 := str1 + str2; -- str1 = 'tristring' is TRUE Aggregate operators : The index operator [i] is a postfix operator that can be applied to an aggregate operand; the expression evaluates to the value of the aggregate at the index position. For example, if lagg is a list of integers: insert(lagg, 20, 0); insert(lagg, 40, 0); insert(lagg, 60, 0); insert(lagg, 80, 0); -- lagg[2] = 60 is TRUE Interval expression : An interval expression is a LOGICAL expression consisting of three operands and two operators. It has the form: { low op1 test op2 high } where op1 and op2 are either of the two relational operators < or <=, and low, test and high are expressions of the same type. The interval expression is equivalent to: ((low op1 test) AND (test op2 high)) The value of the interval expression is given by (#) If any operand is indeterminate, then it evauates to UNKNOWN. (#) If either of the logical relationships evaluates to FALSE, then it evauates to FALSE. (#) If both logical relationships evalute to TRUE, then it evauates to TRUE. (#) Otherwise it evaluates to UNKNOWN. For example: i := 10; {1 <= i < 20} -- is TRUE {1 <= i < 10} -- is FALSE i := ?; {1 <= i < 10} -- is UNKNOWN SUB-SECTION: Built in procedures and functions SUB-SUB-SECTION: Procedures The following procedures are an integral part of EXPRESS-A. They are shown as signatures to inidicate the data types of the formal parameters. For convenience, GENERIC is used to indicate any type. o INSERT (VAR L:LIST OF GENERIC; E:GENERIC; P:INTEGER) INSERT inserts the element E into a list L at position P. The insertion follows the existing element at P, so that if P=0, E will become the first element. o REMOVE (VAR L:LIST OF GENERIC; P:INTEGER) REMOVE modifies the list L by deleting the element at position P. o SYSTEM (V:STRING) SYSTEM passes the string V to the operating system. This is typically used to get the operating system to perform some action. o READ(VAR V1, V2,...:GENERIC), READLN(VAR V1, V2,...:GENERIC) These two procedures are similar to the Pascal procedures of the same name and put data from standard input into the variable(s) V1, etc. The argument is a comma-seperated list of variables. The variables may be of different types, but the types are limited to INTEGER, REAL, LOGICAL, and STRING. The procedure gets the next value of the variable's type from standard input and assigns it to the variable. An integer is recognised as a set of digits, optinally preceeded by a sign. A real is in either decimal or scientific notation (e.g., 12.34 or 1.234e1). A logical is TRUE, FALSE or UNKNOWN (case independent, so TRUE could also be tRuE). A string is any non-empty set of characters ended by white space (e.g., string is one string but ball of str8 string is four strings). The difference between READ and READLN is that the former performs the actions described above, while the latter will discard any remaining characters in the input line after processing its arguments. o WRITE(format), WRITELN(format) These two procedures are similar to the Pascal procedures of the same name. They write data to standard output. The format consists of a comma-seperated list of variables with optional spacing specifications. The variable types may be INTEGER, REAL, LOGICAL, or STRING. The LOGICAL and STRING types take no spacing declarations. An INTEGER variable can take one optional space specification which is an integer number specifying the minimum field width for printing the value (e.g., int:6 to specify a minimum field width of 6 characters). A REAL variable can take two optional space specifications. The first is the field width and the second is the number of digits to be printed (e.g., r:10:5 for printing with a field width of 10 characters and to a pecision of 5 digits). For example: BEGIN_LOCAL int : INTEGER; r : REAL; log : LOGICAL; str : STRING; END_LOCAL; int := 23; r := 23.0; log := true; str := 'This is a string.'; WRITE('Example', int, r:10:5, ' ', log, ' ', str); will produce: Example 23 23.000 TRUE This is a string. The difference between WRITE and WRITELN is that the latter will end the output line after it has output the values of its arguments. (WRITELN need take no arguments, in which case it justs ends the current output line). o PRINT(format), PRINTLN(format) These PRINT procedures are the same as the WRITE procedures, except that they send the data to the current L2X output destination. SUB-SUB-SECTION: Functions The following functions are supplied as part of EXPRESS-A. They are exhibited as signatures to show the formal parameters. For convenience, NUMBER is being used to denote either an INTEGER or a REAL number. o ABS (V:NUMBER) : NUMBER; ABS returns the absolute value of its argument. o COS (V:NUMBER) : REAL; Returns the cosine of an an angle specified in radians. o EOF () : LOGICAL; Returns TRUE if the next character from standard input is `end-of-file', otherwise it returns FALSE. o EOLN () : LOGICAL; Returns TRUE if the next character from standard input is `end-of-line', otherwise it returns FALSE. o EXISTS (V:GENERIC) : LOGICAL; The function EXISTS returns FALSE if its argument is indeterminate or does not exist, otherwise it returns TRUE. o EXP (V:NUMBER) : REAL; Returns e (the base of natural logarithms (CONST_E)) raised to the power of V. o HIBOUND (V:AGGREGATE OF GENERIC) : INTEGER; HIBOUND returns the declared upper index of an ARRAY or the declared upper bound of a BAG, LIST or SET. o HIINDEX (V:AGGREGATE OF GENERIC) : INTEGER; HIINDEX returns the declared upper index of an ARRAY or the number of elements in a BAG, LIST or SET. o LENGTH (V:STRING) : INTEGER; Returns the number of characters in its argument. o LOBOUND (V:AGGREGATE OF GENERIC) : INTEGER; LOBOUND returns the declared lower index of an ARRAY or the declared lower bound of a BAG, LIST or SET. o LOG (V:NUMBER) : REAL; Returns the natural logarithm of its argument. o LOG2 (V:NUMBER) : REAL; Returns the base 2 logarithm of its argument. o LOG10 (V:NUMBER) : REAL; Returns the base 10 logarithm of its argument. o LOINDEX (V:AGGREGATE OF GENERIC) : INTEGER; LOINDEX returns the declared lower index of an ARRAY or the value 1 for a BAG, LIST or SET. The ..INDEX functions are useful for iterating over aggregates. For example, if lagg is a list of integer, then all the elements can be printed out as a comma-seperated list enclosed in parentheses by: writeln; write('lagg = ('); REPEAT i := LOINDEX(lagg) TO HIINDEX(lagg); IF (i = HIINDEX(lagg)) THEN write(lagg[i]:1); ELSE write(lagg[i]:1, ', '); END_IF; END_REPEAT; writeln(')'); o NVL (V:GENERIC; SUBS:GENERIC) : GENERIC; If the argument V exists then it is returned, otherwise the argument SUBS is returned. Both arguments must be of the same type. o ODD (V:INTEGER) : LOGICAL; Returns TRUE or FALSE depending on whether or not its argument is odd or even. o REXPR (V:STRING; E:STRING) : LOGICAL; This function tests whether the V string parameter matches a regular expression E. REXPR returns TRUE if there is a match, FALSE if there is not a match, or UNKNOWN if the regular expression is ill-formed. In the regular expression, most characters stand for themselves, but \ can be used to escape any of the meta-characters. o The meta-characters ( and ) are used for grouping sub-expressions. o | between expressions means one or the other. o + following an expression means match one or more times. o * following an expression means match zero or more times. o ? following an expression means match zero or one times. o [...] is an expression indicating that any of the enclosed characters are acceptable. o [^...] is an expression indicating that any characters except those enclosed are acceptable. o Within a bracket expression a range of characters can be specified by providing the first and last with a seperating hyphen. For instance, [a-zA-Z] will match any alphabetic character. Some examples: o [a-zA-Z]+ match one or more letters. o [0-9]+.[0-9]+([eE][\-\+]?[0-9]+)? match a floating point number (e.g., 1.23e-27 or 0.987) o [a-zA-Z][0-9a-zA-Z_]* match an EXPRESS-A variable. o [^0-9a-zA-Z] match anything except letters or digits. o (I|i)(F|f) case insensitive match for the word IF. o ROUND (V:NUMBER) : INTEGER; Returns the nearest integer to its argument value. o SIN (V:NUMBER) : REAL; Returns the sine of an an angle specified in radians. o SIZEOF (V:AGGREGATE OF GENERIC) : INTEGER; SIZEOF returns the number of elements in its argument. When V is an ARRAY this is the declared number of elements. When V is a BAG, LIST or SET this is the actual number of elements. o SQRT (V:NUMBER) : REAL; Returns the square root of its argument. o TAN (V:NUMBER) : REAL; Returns the tangent of an an angle specified in radians. o TRUNC (V:NUMBER) : INTEGER; Chops off any decimal part of its argument, returning the corresponding integer value. SUB-SECTION: Source level debugger (sec:sld) The EXPRESS-A interpreter includes a source level debugger for use when your code appears to be misbehaving. When in operation the debugger will prompt for a command to be entered. It understands the following commands. o Continue processing. o break Place a breakpoint at the statement on line . o break Print the line numbers of all the breakpoints. o unbreak Remove the breakpoint from line . o unbreak Remove all breakpoints. o trace Turn on statement tracing. o untrace Turn off statement tracing. o entry Turn on tracing of entry to procedures and functions. o unentry Turn off entry tracing. o exit Turn on tracing of exits from procedures and functions. o unexit Turn off exit tracing. o traceall Turn on all tracing. o untraceall Turn off all tracing. o stack Turn on display of the runtime stack accesses. o unstack Turn off stack display. o step Turn on single-stepping. o unstep Turn off single stepping. o fetch Print data fetches for . o store Print data stores for . o watch Print both data fetches and stores for . o watch Print the names of all variables being watched. o unwatch Remove the watch from . o unwatch Remove all watches. o show Print the value of the EXPRESS-A expresion . The variables in the expression must have been declared in the EXPRESS-A code. For example: show (23.0 + LOG(num))/(PI*r**2) o assign Assign the value of to the EXPRESS-A variable . For example: assign num := SIN(theta/300.0) o where Print the current line number and the text of the next statement to be executed. o kill Terminate the execution of the L2X program. SUB-SECTION: Example EXPRESS-A code The following demonstrates most of the functionality of EXPRESS-A. Most of this is not particularly interesting, except possibly for the algorithms for calculating the date of Easter and for generating magic squares. c= fun.ct Test of CODE ltx2x CODE_SETUP= ENTITY ent; attr1, attr3 : INTEGER; attr2 : STRING; END_ENTITY; TYPE joe = INTEGER; END_TYPE; TYPE colour = ENUMERATION OF (red, blue, green); END_TYPE; PROCEDURE easter; (* calculates the date of Easter for the present year The algorithm can be applied to any year between 1900 and 2099 inclusive, but if so, then the year should be checked to ensure that it is within this range. *) LOCAL n, a, b, m, q, w : INTEGER; day : INTEGER; month : STRING; END_LOCAL; n := THE_YEAR - 1900; a := n MOD 19; b := (7*a + 1) DIV 19; m := (11*a + 4 - b) MOD 29; q := n DIV 4; w := (n + q + 31 - m) MOD 7; day := 25 - m - w; month := 'April'; IF (day < 1) THEN month := 'March'; day := day + 31; END_IF; writeln('In ', THE_YEAR:1, ' Easter is on ', month, day:3); END_PROCEDURE; FUNCTION magic_square(order:INTEGER): LOGICAL; (* calculates magic squares from order 1 through 15. The order must be an odd number. *) LOCAL row, col, num : INTEGER; sqr_order : INTEGER; magic : ARRAY[1:15] OF ARRAY[1:15] OF INTEGER; END_LOCAL; IF (order > 15) THEN -- only squares up to order 15 RETURN(FALSE); ELSE IF (order < 1) THEN -- squares have at least one entry RETURN(FALSE); ELSE IF (NOT ODD(order)) THEN -- squares are odd RETURN(FALSE); END_IF; END_IF; END_IF; sqr_order := order**2; row := 1; col := (order + 1) DIV 2; REPEAT num := 1 TO sqr_order; magic[row][col] := num; IF ((num MOD order) <> 0) THEN IF (row = 1) THEN row := order; ELSE row := row - 1; END_IF; IF (col = order) THEN col := 1; ELSE col := col + 1; END_IF; ELSE IF (num <> sqr_order) THEN row := row + 1; END_IF; END_IF; END_REPEAT; writeln(Magic square of order ',order:2); REPEAT row := 1 TO order; REPEAT col := 1 TO order; write(magic[row][col]:4); END_REPEAT; writeln; END_REPEAT; writeln; RETURN(TRUE); END_FUNCTION; FUNCTION month(mnum:INTEGER) : STRING; (* Given an integer representing the month in a year, returns the name of the month. *) LOCAL str : STRING; END_LOCAL; CASE mnum OF 1 : str := 'January'; 2 : str := 'February'; 3 : str := 'March'; 4 : str := 'April'; 5 : str := 'May'; 6 : str := 'June'; 7 : str := 'July'; 8 : str := 'August'; 9 : str := 'September'; 10 : str := 'October'; 11 : str := 'November'; 12 : str := 'December'; OTHERWISE : str := ''; END_CASE; RETURN(str); END_FUNCTION; LOCAL a : array[1:3] of integer; lagg : list [0:5] of integer; a23 : array[1:2] of array[1:3] of integer; i, n : integer; s1, s2 : string; b : logical; r1, r2 : real; nega : array[-3:-1] of integer; posa : array[3:5] of integer; j : joe; ex : ent; END_LOCAL; -- start with a massive compound statement BEGIN writeln; println; (* write today's date *) writeln('Today is ', THE_DAY:1, ' ', month(THE_MONTH), ' ', THE_YEAR:1); writeln; (* The user might be interested in Easter *) easter; writeln; (* Call some math functions *) r1 := PI/4; writeln('r1 = PI/4 (0.78539...)', r1); writeln('cos(r1) (0.70710...)', cos(r1)); writeln('sin(r1) (0.70710...)', sin(r1)); writeln('tan(r1) (1.0)', tan(r1)); r1 := CONST_E; writeln('r1 = CONST_E (2.7182...)', r1); writeln('log(4.5) (1.50407...)', log(4.5)); writeln('log2(8) (3.0)', log2(8)); writeln('log10(10) (1.0)', log10(10)); r2 := exp(10); writeln('exp(10) (2.203...e4)', r2); r2 := sqrt(121); writeln('sqrt(121) (11.0)', r2); (* populate and print some arrays *) writeln; posa[3] := 10; posa[4] := 20; posa[5] := 30; REPEAT i := LOINDEX(posa) TO HIINDEX(posa); writeln('posa[', i:1, '] = ', posa[i]); END_REPEAT; writeln; nega[-3] := 1; nega[-2] := 2; nega[-1] := 3; REPEAT i := LOINDEX(nega) TO HIINDEX(nega); writeln('nega[', i:1, '] = ', nega[i]); END_REPEAT; (* Do some things with a list *) -- check the initial size (should be empty) i := SIZEOF(lagg); writeln('no. of els in lagg = ', i); -- insert elements at the front INSERT(lagg, 10, 0); i := SIZEOF(lagg); writeln('no. of els in lagg = ', i); INSERT(lagg, 20, 0); writeln('no. of els in lagg = ', SIZEOF(lagg)); -- print some of the elements i := lagg[1]; writeln('first in lagg = ', i); writeln('lagg[2] = ', lagg[2]); -- check if a value in in the list b := 10 IN lagg; writeln(b); -- should be TRUE b := 30 IN lagg; writeln(b); -- should be FALSE -- write all the elements REPEAT i := LOINDEX(lagg) TO HIINDEX(lagg); writeln('lagg[', i:1, '] = ', lagg[i]); println('lagg[', i:1, '] = ', lagg[i]); END_REPEAT; (* see what happens with an indeterminate value *) b := FALSE; b := ?; writeln(b); println(b); (* Some more attempts with indeterminate *) i := 2; n := 3*i; writeln(i, n); -- should be 2 6 n := 3*?; writeln(i, n); -- should be 2 ? i := ?; n := 3*i; writeln(i, n); -- should be ? ? END; -- end of compound statement -- but we can have individual statements (* Try to provide some excitement by making a magic square *) writeln; write('Enter an odd number between 1 and 15: '); readln(n); IF NOT magic_square(n) THEN writeln('I did not like your number which was ', n:1); writeln('If you get it right next time, something magic will happen.'); write('Enter an odd number between 1 and 15: '); readln(n); magic_square(n); END_IF; (* Try a couple of REPEAT statements *) writeln('Test REPEAT (should print -2)'); i := -2; REPEAT UNTIL i = 0; writeln(i); println(i); ESCAPE; i := i + 1; END_REPEAT; writeln('Test REPEAT (should print 3, 2, 1)'); REPEAT i := 3 TO 1 BY -1; writeln(i); END_REPEAT; (* Try the LIKE operator *) writeln('Test LIKE'); writeln(('A' LIKE 'A')); -- should be TRUE writeln(('A' LIKE 'b')); -- should be FALSE writeln(('Page 407' LIKE '$###')); -- should be TRUE writeln(('Page 23' LIKE '$###')); -- should be FALSE (* Try the REXPR function *) writeln('Test rexpr'); writeln(rexpr('A', 'A')); -- should be TRUE writeln(rexpr('A', 'b')); -- should be FALSE writeln(rexpr('Page 407', '[a-zA-Z]+\ [0-9]+')); -- should be TRUE writeln(rexpr('Page 23', '[a-zA-Z]+\ [0-9]')); -- should be FALSE (* Try an ARRAY OF ARRAY *) a23[1][1] := 11; a23[1][2] := 12; a23[1][3] := 13; a23[2][1] := 21; a23[2][2] := 22; a23[2][3] := 23; writeln('Test REPEAT (should be 1 1 11, 1 2 12, 1 3 13, 2 1 21, 2 2 22 etc)'); REPEAT n := 1 TO 2; REPEAT i := 1 TO 3; writeln(n, i, a23[n][i]); END_REPEAT; END_REPEAT; (* do some simple string operations *) s1 := 'string'; writeln(s1); -- should be string s2 := s1[2:4]; writeln(s2); -- should be tri b := s1 <> s2; writeln(b); -- should be TRUE writeln(s2 + s1); -- should be tristring (* Assign and print to a user-defined type *) j := 33; writeln(j*3); -- should be 99 (* Do something with a variable of type ENTITY */ ex.attr1 := 33; ex.attr2 := 'The attribute named attr2'; ex.attr3 := ex.attr1/3; writeln('ex.attr1 should be 33 and is: ', ex.attr1); writeln('ex.attr2 is: ', ex.attr2); writeln('ex.attr3 should be 11 and is: ', ex.attr3); END_CODE SECTION: Specifying a SPECIAL_ command (sec:special) This section gives some hints on how to specify a LaTeX command that requires some special processing. The faint-hearted should skip this. It is assumed that the implementor will have knowledge of LaTeX, C programming, and lex and YACC style lexer and parser generator systems. There are two ways of defining SPECIAL_ kinds of commands though neither is particularly simple. The easiest is by what is termed the coding method. This involves modifying the standard actions. The more complicated means is by the grammar method, which involves extending the production grammar and, typically, also coding new kinds of actions. The process of specifying one of the SPECIAL_ kinds of command actions is: o Seriously question the need for the special command. One is only required if the standard actions cannot be coerced into serving the needs of the command processing and/or the command grammar is not supported by the L2X system. o Design the required entry for the command table. o Decide whether the coding or the grammar method is to be used for extending L2X. Coding method : Modify the actions in l2xusrlb.c, and possibly add new functions in l2xusrlb.c and l2xusrlb.h. Grammar method : Extend the grammar in l2x.y. Typically it be necessary to add new functions to the user-defined library l2xusrlb as well. o Compile the modified L2X system. A make file for this is given in Appendix (sec:install). o Test the extensions and debug the program. The l2xlib has many functions that may be of use in this process. Some of these are indicated below. o char *strsave(char s[]) saves a string somewhere o void myprint(char s[]) writes a string to the output medium. Its particular action is controlled by the set_print and reset_print functions, as well as the -p option. o void verbatim_print(char s[]) like myprint, writes a string to the output medium. Its actions are controlled by the current print mode, and newlines are obeyed (i.e., it ignores any pretty-printing option). o void yyerror(char s[]) used by the lexer and parser to print an error message string. o void warning(char s[]) writes a warning message string. o void do_newline() used within the lexer to set internal variables whenever a newline is encountered in the input. o void initialise_sysbuf() initialises the system supplied string buffer. o void print_sysbuf() writes the content of the system string buffer to the output file. o void copy_sysbuf(char s[]) copies the contents of the system string buffer to the user-supplied string. It is the user's responsibility to ensure that the string is big enough. o void set_print(PSTRWC pswitch) controls the action of myprint, print_newline and verbatim_print. If the input argument is p_default_print then the print functions should write to the output file; this is the default behavior. If the argument is p_no_print, then no writing occurs. If the argument is p_print_to_sysbuf, then the print functions write to the system string buffer. o void reset_print() resets the behavior of the print functions. This function should always be used after a call to set_print. o int lookup_entry(char s[], int kind) returns the location within the command table of the command name given in s of the command type given in kind. If kind is DONT_CARE then the position of the first occurrence of s is returned. o void get_env_name(char s[]) extracts the name of a LaTeX environment from s, which is assumed to have the form \something { environment }. The name of the environment is put into the global string env_name. o PSENTRY get_mode_sym(int loc) returns a pointer to the symbol table entry at position loc in the command table for the current mode. o int command_type(int loc) returns the system defined kind of command at location loc in the command table. o int get_user_type(int loc) returns the user input (TYPE=) kind of command at location loc in the command table. o PSTRWC get_t(PSENTRY loc) returns a pointer to the START_TAG= specification for symbol entry loc. There are similar functions for other tagging specifications. o PSTRWC get_tag_t(PSENTRY loc, int n) returns a pointer to the START_TAG_n specification for the n'th argument for symbol entry loc. There are similar functions for other argument tagging specifications. o PSTRWC get_param_print(PSENTRY loc, int n) returns a pointer to the print control specification for the n'th required argument for symbol entry loc. There are similar functions for other print controls. o int get_level(PSENTRY loc) returns the SECTIONING_LEVEL= value for symbol entry loc. The process of specifying a SPECIAL_ is best described via an example. SUB-SECTION: Example Assume that there is a `non-standard' LaTeX command which has one required argument. When this command is processed by LaTeX its effect is to start a new section in a document entitled Normative References. Some boilerplate text is then typeset (specified within the definition of the command). This boilerplate includes two instances of the text from the argument of the command. Finally, a description list environment is started. In LaTeX terms, this command could have been defined as: \newcommand{\XXspecial}[1]{\section{Normative References} Some boilerplate text with #1 in the middle. Now there is some more boilerplate with #1 in the middle of it. \begin{description} } For the purposes of the example, it is desired to replace the occurrence of the \XXspecial command by the `normal' section heading for the output tagged style, and also print out the boilerplate text including the argument text in the right places. The start of the list environment has also to be taken into account. The \item optional argument text is to be enclosed in parentheses, with a dash before the main text. These requirements are not something that can be currently accomplished with the standard L2X system. To make the requirements more concrete, if the input LaTeX source includes: .... \XXspecial{REQ PARAM TEXT} \item[Ref 1] Text 1. \item[Ref 2] Text 2. \end{description} .... then the desired output is to look like: .... Normative References Some boilerplate text with REQ PARAM TEXT in the middle. Now there is some more boilerplate with REQ PARAM TEXT in the middle of it. (Ref 1) -- Text 1. (Ref 2) -- Text 2. .... Now, let's write a specification for the command table, which we will do in pieces, starting with the sectioning tags. In this tagging style, end tags for sections take the form , and start tags the form . The titles of sections are enclosed between and tags. We also want some newlines in the output to set things off. If ? is used as the escape character, then we can specify for the sectioning tagging: SECTIONING_LEVEL= SECT START_TAG= "?n?n?n" STRING: "Normative References?n" END_TAG= "?n" There is one required argument and no optional arguments, so we need: REQPARAMS= 1 The LaTeX command also starts off a description environment, so we have to set the tags for the \item commands that will follow. This is done by: START_ITEM= "?n" START_ITEM_PARAM= " (" END_ITEM_PARAM= ") -- " Most of the work is now completed though we still have to give the command name, decide what sort of SPECIAL_ it will be and set the SPECIAL_TOKEN value. None of the provided SPECIAL_ types exactly fit this entry as it is a mixture of sectioning and list environment, so we will just call it a SPECIAL_COMMAND type. To summarize, the effective state of the command table entry is: TYPE= SPECIAL_COMMAND C= NAME= to be specified C= SPECIAL_TOKEN= to be specified SECTIONING_LEVEL= SECT START_TAG= "?n?n?n" STRING: "Normative References?n" END_TAG= "?n" REQPARAMS= 1 START_ITEM= "?n" START_ITEM_PARAM= " (" END_ITEM_PARAM= ") -- " END_TYPE For pedagogical purposes, this special will be implemented using both the grammar and code methods, and the command names used will be \GRAMMspecial and \CODEspecial respectively. SUB-SUB-SECTION: Grammar method implementation The command name for this implementation will be \GRAMMspecial. The grammar method requires changes to the grammar specified in l2x.y. (#) A new token has to be defined, call it GRAMMSPECIAL, in the first part of the file. There is a slot for this under the comment /* specials */. An integer number, greater than or equal to 10,000 (ten thousand) and less than 32,768 (2^15), has to be associated with this token. (Footnote: The upper limit of (2^15-1) is set by the bison processor.) Further, this number must not be the same as any other number associated with any other token. Let us use the maximum number 32,767. The relevant portion of l2x.y will look like /* specials */ %token /* other specials here */ %token GRAMMSPECIAL 32767 /* precedences */ This number is used for communication within the L2X system, and is the number set as the value of the SPECIAL_TOKEN in the command table. We can now finalize the command table entry as: TYPE= SPECIAL_COMMAND NAME= \GRAMMspecial SPECIAL_TOKEN= 32767 SECTIONING_LEVEL= SECT START_TAG= "?n?n?n" STRING: "Normative References?n" END_TAG= "?n" REQPARAMS= 1 START_ITEM= "?n" START_ITEM_PARAM= " (" END_ITEM_PARAM= ") -- " END_TYPE (#) A new production, or productions, has to be added to the grammar. There is a place for this at the end of the rules section in the file, under the predefined production l2xSpecials. Let us call our new production GrammSpecial, and add it as: l2xSpecials: ASpecial | AnotherSpecial | GrammSpecial ; where the ASpecial and AnotherSpecial are pre-existing specials. (#) The production now has to be defined, specifying the expected syntax and required actions. This looks like: GrammSpecial: GRAMMSPECIAL { start_section($1); myprint(get_t($1)); myprint(get_tag_t($1,1)); initialise_sysbuf(); set_print(p_print_to_sysbuf); } ReqParam { initialise_string(grammbuf); copy_sysbuf(grammbuf); reset_print(); prwboiler1(); print_sysbuf(); prwboiler2(); myprint(grammbuf); prwboiler3(); start_list($1); } ; The actions are enclosed in braces and are defined in terms of C code. Once the parser has been given the GRAMMSPECIAL token from the lexer, it will attempt to perform the actions within the first set of braces. The first of these, start_section($1), is the L2X action for starting a sectioning command. Basically, this deals with any closing of prior sections of the document and remembering the closing tag for this section. The next two actions print the start tags for the command and its required argument, taking the strings from the command table. initialise_sysbuf() initializes the system string buffer ready for new input. Then the print control is set so that any output will be directed into the system string buffer rather than the output file. This finishes the first set of actions. The production grammar for the required argument comes next. If this is incorrect, the parser automatically gives an (uninformative) error message. Otherwise, the last set of actions are done. At this point, the text of the required argument will be contained in the system string buffer. This is then copied to a temporary buffer grammbuf, that we have yet to define, by calling copy_sysbuf(grammbuf) having first made sure that this buffer has been cleared of any previous contents (the initialise_string(grammbuf) action). The printing control must now be reset (reset_print()), or things might get corrupted later. A function prwboiler1() is called to print the first part of the boilerplate text, followed by printing the contents of the system buffer by the action print_sysbuf() (remember that this should contain the text of the required argument). The second part of the boilerplate is written by the function prwboiler2(). Just for pedagogical purposes, the required argument text is written out using the text stored in the temporary buffer (myprint(grammbuf)) rather than from the system buffer. The penultimate action is the printing of the last piece of boilerplate. The final action --- start_list($1) --- is the standard L2X action at the start of a list environment. This remembers the various tags for the list items to follow. A character buffer, grammbuf, is now defined in the initial section of the l2x.y file, as: char grammbuf[80]; which is intended to be large enough to hold the text of the required argument of the command. This completes the changes to the grammar file. (#) The three functions called out in the above actions for printing the boilerplate are coded and placed in the user library file l2xusrlb.c and are also added to l2xusrlb.h. Here is the relevant code as it would appear in l2xusrlb.c. /* demonstration string definition */ STRING boiler_string_3 = "\nin the middle of it.\n\n"; /* demonstration functions */ /* PRWBOILER1 print some demonstration boilerplate */ void prwboiler1() { myprint("\nSome boilerplate text with "); } /* end PRWBOILER1 */ /* PRWBOILER2 print some demonstration boilerplate */ void prwboiler2() { myprint("\nin the middle. Now there is\n"); myprint("some more boilerplate with "); } /* end PRWBOILER2 */ /* PRWBOILER3 yet more demonstration boilerplate */ void prwboiler3() { myprint(boiler_string_3); } /* end PRWBOILER1 */ (#) The system is recompiled, using make, and tested on some example LaTeX files. SUB-SUB-SECTION: Code method implementation This method `merely' requires extending the standard actions to account for the new requirements. First, however, we must complete the definition of the command table entry. We will call the new command \CODEspecial. Also a unique value has to be assigned to the SPECIAL_TOKEN. This must have a value greater than or equal to 50,000 (fifty thousand). We will use a value 59,999. Later this value is u