diff options
Diffstat (limited to 'externs.h')
| -rw-r--r-- | externs.h | 3407 |
1 files changed, 3407 insertions, 0 deletions
diff --git a/externs.h b/externs.h new file mode 100644 index 0000000..a68ff4c --- /dev/null +++ b/externs.h @@ -0,0 +1,3407 @@ +/*@externs.h:External Declarations:Directories and file conventions@**********/ +/* */ +/* THE LOUT DOCUMENT FORMATTING SYSTEM (VERSION 3.17) */ +/* COPYRIGHT (C) 1991, 1999 Jeffrey H. Kingston */ +/* */ +/* Jeffrey H. Kingston (jeff@cs.usyd.edu.au) */ +/* Basser Department of Computer Science */ +/* The University of Sydney 2006 */ +/* AUSTRALIA */ +/* */ +/* This program is free software; you can redistribute it and/or modify */ +/* it under the terms of the GNU General Public License as published by */ +/* the Free Software Foundation; either Version 2, or (at your option) */ +/* any later version. */ +/* */ +/* This program is distributed in the hope that it will be useful, */ +/* but WITHOUT ANY WARRANTY; without even the implied warranty of */ +/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */ +/* GNU General Public License for more details. */ +/* */ +/* You should have received a copy of the GNU General Public License */ +/* along with this program; if not, write to the Free Software */ +/* Foundation, Inc., 59 Temple Place, Suite 330, Boston MA 02111-1307 USA */ +/* */ +/* FILE: externs.h */ +/* MODULE: External Declarations */ +/* */ +/*****************************************************************************/ +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <stdarg.h> +#include <locale.h> + +#if LOCALE_ON +#include <nl_types.h> +extern nl_catd MsgCat; +#define condcatgets(cat, set, msg, s) catgets(cat, set, msg, s) +#else +#define condcatgets(cat, set, msg, s) s +#endif + + +/*****************************************************************************/ +/* */ +/* Include, font and database directories, and the DEBUG_ON and ASSERT_ON */ +/* flags (defined by -D options on the cc command line in the makefile). */ +/* */ +/* LATIN Non-zero means compile for ISO-LATIN-1 char set. */ +/* LIB_DIR The system directory where library files are kept */ +/* INCL_DIR The subdirectory of LIB_DIR where @Include files are kept */ +/* FONT_DIR The subdirectory of LIB_DIR where .AFM font files are kept */ +/* MAPS_DIR The subdirectory of LIB_DIR where .LCM files are kept */ +/* DATA_DIR The subdirectory of LIB_DIR where database files are kept */ +/* HYPH_DIR The subdirectory of LIB_DIR where hyphenation files kept */ +/* LOCALE_DIR The subdirectory of LIB_DIR where locale files are kept */ +/* CHAR_IN Determines assignment of input chars to lex classes */ +/* CHAR_OUT Determines appearance of literal chars in output */ +/* DEBUG_ON Non-zero means compile debug code (lout -d) */ +/* ASSERT_ON Non-zero means test assertions */ +/* LOCALE_ON Non-zero means compile setlocale() etc. code */ +/* */ +/* #define LIB_DIR "/usr/local/lib/lout" */ +/* #define INCL_DIR "include" */ +/* #define FONT_DIR "font" */ +/* #define MAPS_DIR "maps" */ +/* #define DATA_DIR "data" */ +/* #define HYPH_DIR "hyph" */ +/* #define LOCALE_DIR "locale" (only used if LOCALE_ON) */ +/* #define CHAR_IN 0 */ +/* #define CHAR_OUT 0 */ +/* #define DEBUG_ON 0 */ +/* #define ASSERT_ON 1 */ +/* #define LOCALE_ON 1 */ +/* */ +/*****************************************************************************/ + + +/*@::File naming conventions and version@*************************************/ +/* */ +/* File naming conventions and version */ +/* */ +/* LOUT_VERSION Version information */ +/* CROSS_DB The default name of the cross reference database */ +/* SOURCE_SUFFIX Optional suffix of source files and include files */ +/* INDEX_SUFFIX The suffix of database index files */ +/* NEW_INDEX_SUFFIX The suffix of new database index files */ +/* DATA_SUFFIX The suffix of database data files */ +/* NEW_DATA_SUFFIX The additional suffix of new database data files */ +/* HYPH_SUFFIX The suffix of unpacked hyphenation files */ +/* HYPH_PACKED_SUFFIX The suffix of packed hyphenation files */ +/* FILTER_IN The prefix of the name of the input file to filters */ +/* FILTER_OUT The prefix of the name of the output file to filters */ +/* FILTER_ERR The name of the error file to filters */ +/* */ +/*****************************************************************************/ + +#define LOUT_VERSION AsciiToFull("Basser Lout Version 3.17 (September 1999)") +#define CROSS_DB AsciiToFull("lout") +#define SOURCE_SUFFIX AsciiToFull(".lt") +#define INDEX_SUFFIX AsciiToFull(".li") +#define NEW_INDEX_SUFFIX AsciiToFull(".lix") +#define DATA_SUFFIX AsciiToFull(".ld") +#define NEW_DATA_SUFFIX AsciiToFull("x") +#define HYPH_SUFFIX AsciiToFull(".lh") +#define HYPH_PACKED_SUFFIX AsciiToFull(".lp") +#define FILTER_IN AsciiToFull("louti") +#define FILTER_OUT AsciiToFull("lout") +#define FILTER_ERR AsciiToFull("lout.err") + + +/*****************************************************************************/ +/* */ +/* Operating system dependent things */ +/* */ +/* (1) File read and write modes for binary files, and directory character */ +/* */ +/* MS-DOS text file line endings differ from Unix line endings. This is */ +/* usually ignorable but causes problems with binary files and files where */ +/* you do arithmetic on fseek() values. In Lout the problematic files are */ +/* compressed trie and hyphenation files, and database index files. So */ +/* we must read and write these files in "binary mode" in MS-DOS. For */ +/* completeness we have included synonyms for all file modes used by Lout: */ +/* */ +/* READ_BINARY Mode passed to fopen() when reading a "binary file" */ +/* WRITE_BINARY Mode passed to fopen() when writing a "binary file" */ +/* READ_TEXT Mode passed to fopen() when reading a "text file" */ +/* APPEND_TEXT Mode passed to fopen() when appending to "text file" */ +/* WRITE_TEXT Mode passed to fopen() when writing a "text file" */ +/* STR_DIR Directory character used in file path names */ +/* */ +/* (2) System command and file name for uncompressing EPS files */ +/* */ +/* UNCOMPRESS_COM System command for uncompressing compressed EPS file */ +/* LOUT_EPS Name of temporary uncompressed EPS file */ +/* */ +/* There is one further call to system() in the Lout source code: the one */ +/* that implements filtered parameters such as c2lout. The strings passed */ +/* to this call to system() are the values of @Filter symbols within Lout */ +/* definitions. */ +/* */ +/*****************************************************************************/ + +#if OS_UNIX +#define READ_BINARY "r" +#define WRITE_BINARY "w" +#define READ_TEXT "r" +#define APPEND_TEXT "a" +#define WRITE_TEXT "w" +#define STR_DIR AsciiToFull("/") +#define UNCOMPRESS_COM "gunzip -c %s > %s" +#define LOUT_EPS "lout.eps" +#else +#if OS_DOS +#define READ_BINARY "rb" +#define WRITE_BINARY "wb" +#define READ_TEXT "rt" +#define APPEND_TEXT "at" +#define WRITE_TEXT "wt" +#define STR_DIR AsciiToFull("/") +#define UNCOMPRESS_COM "gunzip -c %s > %s" +#define LOUT_EPS "lout.eps" +#else +#if OS_MAC +#define READ_BINARY "r" +#define WRITE_BINARY "w" +#define READ_TEXT "r" +#define APPEND_TEXT "a" +#define WRITE_TEXT "w" +#define STR_DIR AsciiToFull(":") +#define UNCOMPRESS_COM "gunzip -c %s > %s" +#define LOUT_EPS "lout.eps" +#else +If you're compiling this, you've got the wrong settings in the makefile! +#endif +#endif +#endif + +/*@::Significant limits@******************************************************/ +/* */ +/* Significant Limits (other insignificant ones appear in other files) */ +/* */ +/* MAX_FULL_LENGTH The maximum value storable in type FULL_LENGTH. */ +/* NB this cannot be 2**31 - 1 because there are */ +/* intermediate results that exceed MAX_FULL_LENGTH */ +/* and are subsequently reduced to MAX_FULL_LENGTH. */ +/* For example, some intermediate results may exceed */ +/* MAX_FULL_LENGTH by a factor of SF, which is defined */ +/* below to be 128 (2**7). The value given is 2**23-1, */ +/* which is about 148 metres in Lout's precision. */ +/* */ +/* MAX_SHORT_LENGTH The maximum value storable in type SHORT_LENGTH. */ +/* */ +/* MAX_FILES The maximum number of files. This could only be */ +/* increased if the file_num() field of type FILE_POS */ +/* is enlarged beyond its present 16 bits. */ +/* */ +/* MAX_LINE 1 + the maximum length of an input line in source */ +/* and database files. This is used for the lexical */ +/* analyser's input line buffer only, and could be */ +/* increased immediately to 4096, and even further if */ +/* more than the current 12 bits was assigned to the */ +/* col_num() field of type FILE_POS. */ +/* */ +/* MAX_WORD 1 + the maximum length of a word storable in an */ +/* object record, which includes all file path names */ +/* too. It is reasonable to make this MAX_LINE, since */ +/* a word longer than MAX_LINE cannot be read in. */ +/* */ +/* MAX_OBJECT_REC 1 + the maximum size of an object record, measured */ +/* in ALIGNs. The value chosen should exceed */ +/* ceiling( (wr + MAX_WORD - 4) / sizeof(ALIGN) ) */ +/* where wr = sizeof(struct word_rec), so that words of */ +/* length MAX_WORD-1 can be stored in an object record. */ +/* */ +/* MAX_BUFF 1 + the maximum length of a "standard buffer"; these */ +/* buffers are used in a variety of places throughout */ +/* the program for holding one line of a font file, */ +/* one file path name, one symbol full name, etc. This */ +/* may be increased immediately without limit. */ +/* */ +/* MAX_FONT The maximum number of sized fonts allowed. This */ +/* can be increased beyond 4096 only by setting aside */ +/* a larger word_font() field. */ +/* */ +/* MAX_COLOUR The maximum number of distinct left parameters of */ +/* @SetColour and @SetColor symbols allowed (after */ +/* evaluation). This can be increased beyond 4096 */ +/* only by setting aside a larger word_colour() field. */ +/* */ +/* MAX_LANGUAGE The maximum number of distinct languages allowed. */ +/* This can be increased beyond 256 only by setting */ +/* aside a larger word_language() field. */ +/* */ +/* MAX_LEX_STACK The maximum depth of @Includes and @Databases. This */ +/* can be increased immediately by any small amount. */ +/* */ +/* MAX_CHARS The maximimum number of characters in a font. This */ +/* cannot be increased easily. */ +/* */ +/*****************************************************************************/ + +#define MAX_FULL_LENGTH 8388607 /* 2**23 - 1, about 148 metres */ +#define MAX_SHORT_LENGTH 32767 +#define MAX_FILES 65535 +#define MAX_LINE 2048 +#define MAX_WORD 2048 +#define MAX_OBJECT_REC ceiling(sizeof(struct word_type)+MAX_WORD,sizeof(ALIGN)) +#define MAX_BUFF 512 +#define MAX_FONT 4096 +#define MAX_COLOUR 4096 +#define MAX_LANGUAGE 64 +#define MAX_LEX_STACK 10 +#define MAX_CHARS 256 + +/*****************************************************************************/ +/* */ +/* Miscellaneous Macros */ +/* */ +/*****************************************************************************/ + +#define BOOLEAN unsigned +#define FALSE 0 +#define TRUE 1 +#define bool(x) (x ? AsciiToFull("TRUE") : AsciiToFull("FALSE") ) +#define CHILD 0 +#define PARENT 1 +#define COLM 0 +#define ROWM 1 +#define dimen(x) (x == COLM ? AsciiToFull("COLM") : AsciiToFull("ROWM") ) +#define nilobj ( (OBJECT) NULL ) +#define null ( (FILE *) NULL ) + +#define find_max(a, b) ((a) < (b) ? (b) : (a)) +#define find_min(a, b) ((a) < (b) ? (a) : (b)) +#define ceiling(a, b) ( ((a) - 1)/(b) + 1 ) /* ceiling(a/b) */ +#define is_odd(x) ( (x) & 1 ) /* TRUE if x is odd number */ + +/*@::ALIGN, FULL_LENGTH, FONT_NUM, COLOUR_NUM, LANGUAGE_NUM, FULL_CHAR@*******/ +/* */ +/* typedef ALIGN - used for forcing record alignment. */ +/* */ +/*****************************************************************************/ + +typedef char *ALIGN; + + +/*****************************************************************************/ +/* */ +/* typedef FULL_LENGTH - an integer physical distance. */ +/* */ +/*****************************************************************************/ + +typedef int FULL_LENGTH; + + +/*****************************************************************************/ +/* */ +/* typedef SHORT_LENGTH - an short integer physical distance. */ +/* */ +/*****************************************************************************/ + +typedef short int SHORT_LENGTH; + + +/*****************************************************************************/ +/* */ +/* FONT_NUM - internal name for a font. */ +/* */ +/*****************************************************************************/ + +typedef unsigned FONT_NUM; + + +/*****************************************************************************/ +/* */ +/* COLOUR_NUM - internal name for a colour. */ +/* */ +/*****************************************************************************/ + +typedef unsigned COLOUR_NUM; + + +/*****************************************************************************/ +/* */ +/* LANGUAGE_NUM - internal name for a language. */ +/* */ +/*****************************************************************************/ + +typedef unsigned LANGUAGE_NUM; + + +/*****************************************************************************/ +/* */ +/* MAPPING - internal name for a character mapping vector. */ +/* */ +/*****************************************************************************/ + +typedef unsigned MAPPING; + + +/*****************************************************************************/ +/* */ +/* LINE - a line from a database index file. */ +/* */ +/*****************************************************************************/ + +typedef char *LINE; + + +/*****************************************************************************/ +/* */ +/* typedef FULL_CHAR - one of the characters manipulated by Lout. */ +/* */ +/* This program does not deal with 7-bit ASCII characters. Instead, its */ +/* characters are defined by the FULL_CHAR typedef, and could be anything */ +/* from 7-bit ASCII to 8-bit ISO-LATIN-1 to 16-bit UNICODE and beyond. */ +/* */ +/* Unfortunately C favours signed 8-bit characters: literal strings are */ +/* pointers to them, argv[] and the standard libraries assume them. We get */ +/* around these problems by using our own library, including AsciiToFull() */ +/* to convert an ASCII string (such as a C string) into a FULL_CHAR string. */ +/* */ +/* Formally this library appears in module z39.c; however since this */ +/* implementation uses 8-bit unsigned characters, most of the routines */ +/* can be implemented by macros containing type-cast calls to C standard */ +/* library routines. These appear in the z39.c externs list below. */ +/* */ +/*****************************************************************************/ + +typedef unsigned char FULL_CHAR; + +/*****************************************************************************/ +/* */ +/* typedef POINTER- name for type of generic pointer */ +/* */ +/*****************************************************************************/ + +typedef void *POINTER; + + +/*@::Character literals@******************************************************/ +/* */ +/* Character Literals */ +/* */ +/* The following macros ensure that no Lout source is ever compared to a */ +/* literal character other than '\0': */ +/* */ +/*****************************************************************************/ + +#define CH_FLAG_ALTERR 'a' /* the -a command line flag */ +#define CH_FLAG_CROSS 'c' /* the -c command line flag */ +#define CH_FLAG_ENCPATH 'C' /* the -C command line flag */ +#define CH_FLAG_DEBUG 'd' /* the -d command line flag */ +#define CH_FLAG_DIRPATH 'D' /* the -D command line flag */ +#define CH_FLAG_ERRFILE 'e' /* the -e command line flag */ +#define CH_FLAG_EPSFIRST 'E' /* first letter of the -EPS flag */ +#define CH_FLAG_FNTPATH 'F' /* the -F command line flag */ +#define CH_FLAG_HYPHEN 'h' /* the -h command line flag */ +#define CH_FLAG_HYPPATH 'H' /* the -H command line flag */ +#define CH_FLAG_INCLUDE 'i' /* the -i command line flag */ +#define CH_FLAG_INCPATH 'I' /* the -I command line flag */ +#define CH_FLAG_NOKERN 'k' /* the -k command line flag */ +#define CH_FLAG_NOCOLLATE 'l' /* the -l command line flag */ +#define CH_FLAG_COLLATE 'L' /* the -L command line flag */ +#define CH_FLAG_MEMCHECK 'm' /* the -m command line flag */ +#define CH_FLAG_MEMCR 'M' /* the -M command line flag */ +#define CH_FLAG_OUTFILE 'o' /* the -o command line flag */ +#define CH_FLAG_PLAIN 'p' /* the -p command line flag */ +#define CH_FLAG_FFPLAIN 'P' /* the -P command line flag */ +#define CH_FLAG_SUPPRESS 's' /* the -s command line flag */ +#define CH_FLAG_SAFE 'S' /* the -S command line flag */ +#define CH_FLAG_USAGE 'u' /* the -u command line flag */ +#define CH_FLAG_UNSAFE 'U' /* the -U command line flag */ +#define CH_FLAG_VERSION 'V' /* the -V command line flag */ +#define CH_FLAG_INITALL 'x' /* the -x command line flag */ +#define CH_FLAG_OPTION '-' /* the -- command line flag */ +#define CH_FLAG_WORDS 'w' /* the -w command line flag */ +#define CH_FLAG_PDF 'Z' /* the -Z command line flag */ + +#define CH_SPACE ' ' /* space character */ +#define CH_NEWLINE '\n' /* the newline character */ +#define CH_SYMSTART '@' /* extra letter symbols may have */ +#define CH_UNDERSCORE '_' /* extra letter symbols may have */ +#define CH_QUOTE '"' /* the quote character */ +#define CH_ZERO '0' /* the first digit character, zero */ +#define CH_EIGHT '8' /* the last even digit character */ +#define CH_NINE '9' /* the last odd digit character */ +#define CH_INCGAP '+' /* begins an incrementing gap */ +#define CH_DECGAP '-' /* begins a decrementing gap */ +#define CH_MINUS '-' /* minus sign */ +#define CH_HYPHEN '-' /* the hyphen character */ +#define CH_NOBREAK 'u' /* `unbreakable' character for gaps */ + +#define CH_UNIT_CM 'c' /* unit of measurement: centimetres */ +#define CH_UNIT_IN 'i' /* unit of measurement: inches */ +#define CH_UNIT_PT 'p' /* unit of measurement: points */ +#define CH_UNIT_EM 'm' /* unit of measurement: ems */ +#define CH_UNIT_FT 'f' /* unit of measurement: fontsizes */ +#define CH_UNIT_SP 's' /* unit of measurement: spacewidths */ +#define CH_UNIT_VS 'v' /* unit of measurement: vspaces */ +#define CH_UNIT_WD 'w' /* unit of measurement: follwidths */ +#define CH_UNIT_BD 'b' /* unit of measurement: boundwidths */ +#define CH_UNIT_RL 'r' /* unit of measurement: relwidths */ +#define CH_UNIT_DG 'd' /* unit of measurement: degrees */ +#define CH_UNIT_YU 'y' /* unit of measurement: y unit */ +#define CH_UNIT_ZU 'z' /* unit of measurement: z unit */ + +#define CH_MODE_EDGE 'e' /* spacing mode: edge-to-edge */ +#define CH_MODE_HYPH 'h' /* spacing mode: hyphenation */ +#define CH_MODE_MARK 'x' /* spacing mode: mark-to-mark */ +#define CH_MODE_OVER 'o' /* spacing mode: overstrike */ +#define CH_MODE_KERN 'k' /* spacing mode: kerning */ +#define CH_MODE_TABL 't' /* spacing mode: tabulation */ + +#define octaldigit(ch) ( (ch) >= '0' && (ch) <= '7' ) +#define decimaldigit(ch) ( (ch) >= '0' && (ch) <= '9' ) +#define digitchartonum(ch) ( (ch) - '0' ) +#define numtodigitchar(ch) ( (ch) + '0' ) +#define beginsbreakstyle(ch) ( (ch) >= 'a' && (ch) <= 'z' ) +#define numericchar(ch) ( decimaldigit(ch) || (ch) == '.' ) + + +/*@::String literals, FULL_CHAR type@*****************************************/ +/* */ +/* String Literals. */ +/* */ +/* All significant string literals are defined here. The program has many */ +/* others, however: format strings, debug output, etc. */ +/* */ +/*****************************************************************************/ + +#define STR_EMPTY AsciiToFull("") +#define STR_QUOTE AsciiToFull("\"") +#define STR_ESCAPE AsciiToFull("\\") +#define STR_COMMENT AsciiToFull("#") +#define STR_SPACE AsciiToFull(" ") +#define STR_FORMFEED AsciiToFull("\f") +#define STR_TAB AsciiToFull("\t") +#define STR_NEWLINE AsciiToFull("\n") +#define STR_LETTERS_LOWER AsciiToFull("abcdefghijklmnopqrstuvwxyz") +#define STR_LETTERS_UPPER AsciiToFull("ABCDEFGHIJKLMNOPQRSTUVWXYZ") +#define STR_LETTERS_SYMSTART AsciiToFull("@") +#define STR_LETTERS_UNDERSCORE AsciiToFull("_") + +#if CHAR_IN==0 +#define STR_LETTERS_EXTRA0 AsciiToFull("") +#define STR_LETTERS_EXTRA1 AsciiToFull("") +#define STR_LETTERS_EXTRA2 AsciiToFull("") +#define STR_LETTERS_EXTRA3 AsciiToFull("") +#define STR_LETTERS_EXTRA4 AsciiToFull("") +#define STR_LETTERS_EXTRA5 AsciiToFull("") +#define STR_LETTERS_EXTRA6 AsciiToFull("") +#define STR_LETTERS_EXTRA7 AsciiToFull("") +#else +#define STR_LETTERS_EXTRA0 AsciiToFull("\300\301\302\303\304\305\306\307") +#define STR_LETTERS_EXTRA1 AsciiToFull("\310\311\312\313\314\315\316\317") +#define STR_LETTERS_EXTRA2 AsciiToFull("\320\321\322\323\324\325\326") +#define STR_LETTERS_EXTRA3 AsciiToFull("\330\331\332\333\334\335\336\337") +#define STR_LETTERS_EXTRA4 AsciiToFull("\340\341\342\343\344\345\346\347") +#define STR_LETTERS_EXTRA5 AsciiToFull("\350\351\352\353\354\355\356\357") +#define STR_LETTERS_EXTRA6 AsciiToFull("\360\361\362\363\364\365\366") +#define STR_LETTERS_EXTRA7 AsciiToFull("\370\371\372\373\374\375\376\377") +#endif + +#define STR_STDIN AsciiToFull("-") +#define STR_STDOUT AsciiToFull("-") +#define STR_HYPHEN AsciiToFull("-") +#define STR_EPS AsciiToFull("EPS") +#define STR_POSTSCRIPT AsciiToFull("PostScript") +#define STR_PLAINTEXT AsciiToFull("PlainText") +#define STR_PDF AsciiToFull("PDF") +#define STR_ELSE AsciiToFull("else") +#define STR_NOCROSS AsciiToFull("??") +#define STR_BADKEY AsciiToFull("badkey") +#define STR_NONE AsciiToFull("none") +#define STR_NOCHAR AsciiToFull("-none-") +#define STR_ZERO AsciiToFull("0") +#define STR_PS_SPACENAME AsciiToFull("space") +#define STR_FONT_RECODE AsciiToFull("Recode") +#define STR_FONT_NORECODE AsciiToFull("NoRecode") +#define STR_COLOUR_NOCHANGE AsciiToFull("nochange") + +#define STR_BREAK_HYPHEN AsciiToFull("hyphen") +#define STR_BREAK_NOHYPHEN AsciiToFull("nohyphen") +#define STR_BREAK_ADJUST AsciiToFull("adjust") +#define STR_BREAK_OUTDENT AsciiToFull("outdent") +#define STR_BREAK_RAGGED AsciiToFull("ragged") +#define STR_BREAK_CRAGGED AsciiToFull("cragged") +#define STR_BREAK_RRAGGED AsciiToFull("rragged") +#define STR_BREAK_ORAGGED AsciiToFull("oragged") +#define STR_BREAK_LINES AsciiToFull("lines") +#define STR_BREAK_CLINES AsciiToFull("clines") +#define STR_BREAK_RLINES AsciiToFull("rlines") +#define STR_BREAK_NOFIRST AsciiToFull("unbreakablefirst") +#define STR_BREAK_FIRST AsciiToFull("breakablefirst") +#define STR_BREAK_NOLAST AsciiToFull("unbreakablelast") +#define STR_BREAK_LAST AsciiToFull("breakablelast") + +#define STR_SPACE_LOUT AsciiToFull("lout") +#define STR_SPACE_COMPRESS AsciiToFull("compress") +#define STR_SPACE_SEPARATE AsciiToFull("separate") +#define STR_SPACE_TROFF AsciiToFull("troff") +#define STR_SPACE_TEX AsciiToFull("tex") + +#define STR_SMALL_CAPS_ON AsciiToFull("smallcaps") +#define STR_SMALL_CAPS_OFF AsciiToFull("nosmallcaps") + +#define STR_GAP_RJUSTIFY AsciiToFull("1rt") +#define STR_GAP_ZERO_HYPH AsciiToFull("0ch") + + +/*@::GAP, STYLE@**************************************************************/ +/* */ +/* typedef GAP - what separates one object from another. */ +/* */ +/*****************************************************************************/ + +typedef struct +{ unsigned ospare : 7; /* left for other things in STYLE */ + BOOLEAN onobreak : 1; /* TRUE if this gap is unbreakable */ + BOOLEAN omark : 1; /* TRUE if this gap is marked */ + BOOLEAN ojoin : 1; /* TRUE if joins exist across gap */ + unsigned ounits : 3; /* units of measurement: fixed, etc */ + unsigned omode : 3; /* spacing mode: edge-to-edge, etc */ + SHORT_LENGTH owidth; /* width of the gap */ +} GAP; + +#define nobreak(x) (x).onobreak +#define mark(x) (x).omark +#define join(x) (x).ojoin +#define units(x) (x).ounits +#define mode(x) (x).omode +#define width(x) (x).owidth + +#define SetGap(x, xnobreak, xmark, xjoin, xunits, xmode, xwidth) \ +( nobreak(x) = xnobreak, mark(x) = xmark, join(x) = xjoin, \ + units(x) = xunits, mode(x) = xmode, width(x) = xwidth \ +) + +#define GapCopy(x, y) \ +( nobreak(x) = nobreak(y), mark(x) = mark(y), join(x) = join(y), \ + units(x) = units(y), mode(x) = mode(y), width(x) = width(y) \ +) + +#define ClearGap(x) SetGap(x, FALSE, FALSE, TRUE, FIXED_UNIT, NO_MODE, 0) + + +/*****************************************************************************/ +/* */ +/* typedef STYLE - information about how to break text, etc. */ +/* */ +/*****************************************************************************/ + +typedef struct +{ union { + GAP oline_gap; /* separation between lines */ + struct { + BOOLEAN ovadjust : 1; /* @VAdjust in effect */ + BOOLEAN ohadjust : 1; /* @HAdjust in effect */ + BOOLEAN opadjust : 1; /* @PAdjust in effect */ + unsigned osmall_caps : 1; /* small capitals */ + unsigned ospace_style : 3; /* space style: lout, troff, tex, .. */ + } oss1; + } osu1; + union { + GAP ospace_gap; /* separation induced by white space */ + struct { + unsigned ohyph_style : 2; /* hyphenation off or on */ + unsigned ofill_style : 2; /* fill lines with text off/on */ + unsigned odisplay_style : 3; /* display lines adjusted, ragged... */ + } oss2; + } osu2; + SHORT_LENGTH oyunit; /* value of y unit of measurement */ + SHORT_LENGTH ozunit; /* value of z unit of measurement */ + FONT_NUM ofont : 12; /* current font */ + COLOUR_NUM ocolour : 12; /* current colour */ + LANGUAGE_NUM olanguage : 6; /* current language */ + BOOLEAN onobreakfirst : 1; /* no break after first line of para */ + BOOLEAN onobreaklast : 1; /* no break after last line of para */ +} STYLE; + +#define line_gap(x) (x).osu1.oline_gap +#define vadjust(x) (x).osu1.oss1.ovadjust +#define hadjust(x) (x).osu1.oss1.ohadjust +#define padjust(x) (x).osu1.oss1.opadjust +#define small_caps(x) (x).osu1.oss1.osmall_caps +#define space_style(x) (x).osu1.oss1.ospace_style +#define space_gap(x) (x).osu2.ospace_gap +#define hyph_style(x) (x).osu2.oss2.ohyph_style +#define fill_style(x) (x).osu2.oss2.ofill_style +#define display_style(x)(x).osu2.oss2.odisplay_style +#define font(x) (x).ofont +#define colour(x) (x).ocolour +#define language(x) (x).olanguage +#define nobreakfirst(x) (x).onobreaklast +#define nobreaklast(x) (x).onobreakfirst +#define yunit(x) (x).oyunit +#define zunit(x) (x).ozunit + +#define StyleCopy(x, y) \ +( GapCopy(line_gap(x), line_gap(y)), \ + hyph_style(x) = hyph_style(y), \ + fill_style(x) = fill_style(y), \ + display_style(x) = display_style(y), \ + small_caps(x) = small_caps(y), \ + GapCopy(space_gap(x), space_gap(y)), \ + font(x) = font(y), \ + colour(x) = colour(y), \ + language(x) = language(y), \ + nobreakfirst(x) = nobreakfirst(y), \ + nobreaklast(x) = nobreaklast(y), \ + vadjust(x) = vadjust(y), \ + hadjust(x) = hadjust(y), \ + padjust(x) = padjust(y), \ + space_style(x) = space_style(y), \ + yunit(x) = yunit(y), \ + zunit(x) = zunit(y) \ +) + + +/*@::CONSTRAINT, FILE_NUM, FILE_POS, LIST@************************************/ +/* */ +/* typedef CONSTRAINT - a size constraint. */ +/* */ +/*****************************************************************************/ + +typedef struct +{ FULL_LENGTH obc; + FULL_LENGTH obfc; + FULL_LENGTH ofc; + FULL_LENGTH osparec; +} CONSTRAINT; + +#define bc(x) (x).obc +#define bfc(x) (x).obfc +#define fc(x) (x).ofc +#define sparec(x) (x).osparec +#define constrained(x) (bc(x) != MAX_FULL_LENGTH || \ + bfc(x) != MAX_FULL_LENGTH || fc(x) != MAX_FULL_LENGTH) + +#define SetConstraint(c,x,y,z) (bc(c) = (x), bfc(c) = (y), fc(c) = (z)) +#define CopyConstraint(x, y) (bc(x) = bc(y), bfc(x) = bfc(y), fc(x) = fc(y)) +#define FitsConstraint(b, f, c) (b <= bc(c) && b + f <= bfc(c) && f <= fc(c)) + +#define ig_fnum(x) bc(constraint(x)) +#define ig_xtrans(x) bfc(constraint(x)) +#define ig_ytrans(x) fc(constraint(x)) + + +/*****************************************************************************/ +/* */ +/* typedef FILE_NUM - the internal representation of a file. */ +/* */ +/*****************************************************************************/ + +typedef unsigned short FILE_NUM; +#define NO_FILE 0 + + +/*****************************************************************************/ +/* */ +/* typedef FILE_POS - a position in the set of input files. */ +/* */ +/*****************************************************************************/ + +typedef struct +{ unsigned char otype; /* space for object type field */ + unsigned char orec_size; /* space for object record size */ + FILE_NUM ofile_num; /* no. of file this record is from */ + unsigned oline_num : 20; /* the line number of this record */ + unsigned ocol_num : 12; /* column number this is related to */ +} FILE_POS; + +#define file_num(x) (x).ofile_num +#define col_num(x) (x).ocol_num +#define line_num(x) (x).oline_num + +#define FposCopy(x, y) \ +( file_num(x) = file_num(y), \ + line_num(x) = line_num(y), \ + col_num(x) = col_num(y) \ +) + + +/*****************************************************************************/ +/* */ +/* typedef LIST - two pointers used to make one doubly linked list */ +/* */ +/*****************************************************************************/ + +typedef struct { union rec *opred, *osucc; } LIST; + + +/*@::FIRST_UNION@*************************************************************/ +/* */ +/* typedef FIRST_UNION - first eight bytes of object record (after LISTs). */ +/* */ +/* The fpos is overwritten in WORDs and QWORDs during FixAndPrintObject by */ +/* the horizontal coordinate of the word, which has to be remembered. */ +/* */ +/*****************************************************************************/ + +typedef union +{ + FILE_POS ofpos; + struct + { unsigned char otype, orec_size; + int oword_save_mark; + } os11; + +} FIRST_UNION; + + +/*@::SECOND_UNION, THIRD_UNION, FOURTH_UNION@*********************************/ +/* */ +/* typedef SECOND_UNION - four bytes holding various flags etc. */ +/* */ +/*****************************************************************************/ + +typedef union +{ + struct /* used by all tokens */ + { unsigned char oprecedence; + unsigned char ohspace, ovspace; + } os21; + + struct /* used by WORD objects only, except underline used by all */ + /* objects, including GAP_OBJ */ + { FONT_NUM oword_font : 12; + COLOUR_NUM oword_colour : 11; + LANGUAGE_NUM oword_language : 6; + unsigned ounderline : 2; + unsigned oword_hyph : 1; + } os22; + + struct /* used by non-WORD objects */ + { unsigned char ofoll_or_prec; + unsigned char ocross_type; /* CROSS objects only */ + BOOLEAN onon_blocking: 1; + BOOLEAN osized : 1; + BOOLEAN othreaded : 1; + BOOLEAN oexternal_hor: 1; + BOOLEAN oexternal_ver: 1; + BOOLEAN oblocked : 1; + BOOLEAN otrigger_ext : 1; + BOOLEAN omust_expand : 1; + BOOLEAN ogall_dir : 1; + BOOLEAN oopt_hyph : 1; + BOOLEAN oopt_gazumped: 1; + BOOLEAN oadjust_cat : 1; + BOOLEAN oforce_gall : 1; + unsigned ounderline : 2; + /* don't forget ounderline from os22 applies in this union! */ + } os23; + + struct /* used by WORD and QWORD when they are database nodes */ + { unsigned short oleft_pos; + unsigned char oreading; + unsigned char oin_memory; + } os24; + + struct /* used by WORD and QWORD when they are font records */ + { FONT_NUM ofont_num : 12; + unsigned short ofont_page; + } os25; + + struct /* used by symbol table entries */ + { unsigned char oprecedence; + BOOLEAN ois_tag : 1; + BOOLEAN ohas_tag : 1; + BOOLEAN ohas_lpar : 1; + BOOLEAN ohas_rpar : 1; + BOOLEAN oright_assoc : 1; + BOOLEAN ois_target : 1; + BOOLEAN ohas_target : 1; + BOOLEAN oforce_target : 1; + BOOLEAN ohas_body : 1; + BOOLEAN oindefinite : 1; + BOOLEAN orecursive : 1; + BOOLEAN ouses_extern_target : 1; + BOOLEAN ois_extern_target : 1; + BOOLEAN ois_key : 1; + BOOLEAN ohas_key : 1; + BOOLEAN odirty : 1; + BOOLEAN ovisible : 1; + BOOLEAN ohas_mark : 1; + BOOLEAN ohas_join : 1; + BOOLEAN ohas_par : 1; + BOOLEAN ouses_galley : 1; + BOOLEAN ohoriz_galley : 1; + BOOLEAN oimports_encl : 1; + } os26; + +} SECOND_UNION; + + +/*****************************************************************************/ +/* */ +/* typedef THIRD_UNION - eight bytes usually holding an object size. */ +/* */ +/* In database records this space is used for a file pointer, or a pointer */ +/* to a LINE array if the database is in-memory; in certain */ +/* WORD objects used privately in z10.c it is used for a galley-position. */ +/* In font records it holds the font size, space width, etc. In filter */ +/* words it holds a pointer to the symbol being filtered. */ +/* */ +/*****************************************************************************/ + +typedef union +{ + struct + { FULL_LENGTH oback[2]; + FULL_LENGTH ofwd[2]; + } os31; + + FILE *odb_filep; + LINE *odb_lines; + + struct + { FULL_LENGTH ofont_size; + FULL_LENGTH ofont_xheight2; + FULL_LENGTH ofont_spacewidth; + MAPPING ofont_mapping : 7; + BOOLEAN ofont_recoded : 1; + BOOLEAN ofont_firstpage : 1; + } os32; + + struct + { unsigned char ocs_type; + FILE_NUM ocs_fnum; + int ocs_pos; + int ocs_lnum; + } os33; + + union rec *ofilter_actual; + +} THIRD_UNION; + + +/*****************************************************************************/ +/* */ +/* typedef FOURTH_UNION - twelve bytes holding a STYLE or CONSTRAINT. */ +/* */ +/*****************************************************************************/ + +typedef union +{ + STYLE osave_style; + CONSTRAINT oconstraint; + +} FOURTH_UNION; + + +/*@::OBJECT@******************************************************************/ +/* */ +/* typedef OBJECT - the general-purpose record used throughout Lout. */ +/* */ +/* This record is a complex union type. Which fields are defined in any */ +/* given record depends on its type() tag field, as follows. But first */ +/* we define some collections of fields that are commonly defined together. */ +/* */ +/* ALL - these fields are defined in all objects. They won't be mentioned */ +/* again, but they are always there. */ +/* */ +/* type Tag field for the record */ +/* rec_size Size of this record, in words (for memory allocator) */ +/* succ Next element on list of parents, children */ +/* pred Previous element on list of parents, children */ +/* fpos Position in input file which gave rise to this */ +/* object (could be null; overwritten by word_save_mark */ +/* locally in FixAndPrintOjbect). It sub-fields are: */ +/* */ +/* file_num internal file number */ +/* line_num line number in that file */ +/* col_num column number on that line */ +/* */ +/* Lout attempts to put a meaningful fpos into every */ +/* object, so that error messages related to that */ +/* object can have meaningful line numbers. This has */ +/* not been done in every case; it ought to be. */ +/* */ +/* TOKEN - these fields are defined for all objects that are input tokens, */ +/* They may be overwritten after parsing is completed. */ +/* */ +/* precedence Precedence of this token (0 if has no parameters) */ +/* hspace Horizontal space preceding this token */ +/* vspace Vertical space preceding this token */ +/* */ +/* SIZED - these fields are defined for all objects that represent Lout */ +/* objects and hence have a horizontal and vertical size. They */ +/* will be undefined until after MinSize() is called on the object, */ +/* and defined thereafter. */ +/* */ +/* back[COLM] Horizontal size to left of object's mark */ +/* fwd[COLM] Horizontal size to right of object's mark */ +/* back[ROWM] Vertical size above object's mark */ +/* fwd[ROWM] Vertical size below object's mark */ +/* */ +/* GAP - a gap between two Lout objects. */ +/* */ +/* nobreak TRUE if gap is unbreakable (has u tag) */ +/* mark TRUE if gap is marked (has ^ tag) */ +/* join TRUE if a mark-joining gap (e.g. | not ||) */ +/* units units of measurement (fixed, or r or d etc) */ +/* mode gap mode (mark-to-mark, etc.) */ +/* width width of gap in the given units */ +/* */ +/* STYLE - the style (attributes affecting the appearance) of an object. */ +/* */ +/* line_gap How much to separate lines by */ +/* vadjust TRUE when @VAdjust is in effect */ +/* hadjust TRUE when @HAdjust is in effect */ +/* padjust TRUE when @PAdjust is in effect */ +/* small_caps TRUE when small capitals wanted */ +/* space_style Spacing style (lout, troff etc. from @Space) */ +/* space_gap Object separation given a white space, i.e. "1s" */ +/* hyph_style Hyphenation (undefined, off, on) */ +/* fill_style Fill lines (undefined, off, on) */ +/* display_style Display style for lines (adjust, centre, etc.) */ +/* yunit Value of y unit of measurement */ +/* zunit Value of z unit of measurement */ +/* font Which internal font (including size) to use */ +/* colour Which internal colour to use */ +/* language Which internal language to use */ +/* nobreakfirst TRUE if break not allowed after first line of para */ +/* nobreaklastt TRUE if break not allowed before last line of para */ +/* */ +/* CONSTRAINT - a constraint on how large some object is allowed to be, */ +/* either horizontally or vertically */ +/* */ +/* bc how large back may be (MAX_FULL_LEN if infinite) */ +/* fc how large fwd may be (MAX_FULL_LEN if infinite) */ +/* bfc how large back + fwd may be (MAX_FULL_LEN if inf.) */ +/* */ +/* */ +/* Here now is the list of all object types, what they represent, and */ +/* what fields they contain. The list also indicates what children each */ +/* object of the given type can expect to have. */ +/* */ +/* LINK - one link in the directed acyclic graph which is Lout's universal */ +/* internal data structure. All the other types below are various */ +/* types of nodes. Has ALL only (and no fpos) except see CROSS_SYM */ +/* */ +/* GAP_OBJ - a gap between two Lout objects */ +/* */ +/* gap The gap itself (type GAP) */ +/* underline TRUE if continuous underlining crosses this gap */ +/* save_* These fields used by optimum paragraph breaker only */ +/* first child If the gap is not just white space, the gap object */ +/* */ +/* CLOSURE - an invocation of a user-defined symbol, not yet expanded */ +/* */ +/* TOKEN While still being parsed */ +/* SIZED After sizing if indefinite (the sizes will be zero) */ +/* save_style Style to print this invocation in when expanded */ +/* actual The symbol table record defining this symbol */ +/* threaded TRUE if symbol lies on a vertical thread */ +/* external_ver TRUE if symbol is external in a vertical galley */ +/* external_hor TRUE if symbol is external in a horizontal galley */ +/* children PAR objects whose children are the actual parameters */ +/* */ +/* UNDER_REC - a temporary object inserted by FixAndPrintObject to help */ +/* with working out continuous underlining */ +/* */ +/* back(COLM) Horizontal position of start of underline */ +/* fwd(COLM) Horizontal position of end of underline */ +/* back(ROWM) [type clash] font determining underline appearance */ +/* */ +/* PAGE_LABEL - a @PageLabel object */ +/* */ +/* TOKEN While still being parsed */ +/* SIZED Indefinite, so all sizes will be zero */ +/* first child The parameter of the @PageLabel object */ +/* */ +/* NULL_CLOS - a @Null object */ +/* */ +/* TOKEN While still being parsed */ +/* SIZED Indefinite, so all sizes will be zero */ +/* */ +/* CROSS, FORCE_CROSS - a cross reference (or forcing cross reference) obj */ +/* */ +/* TOKEN While still being parsed */ +/* SIZED Indefinite, so all sizes will be zero */ +/* cross_type Type of cross reference (preceding, following, etc.) */ +/* children The two parameters of the cross reference */ +/* */ +/* HEAD - the header record for a galley invocation */ +/* */ +/* force_gall TRUE if this is a forcing galley (i.e. "force into") */ +/* actual The symbol table record defining this galley */ +/* enclose_obj If galley has @Enclose, the enclose object */ +/* limiter Helps decide whether to break off or scale if stuck */ +/* opt_components If optimizing, the sequence of components */ +/* opt_constraints If optimizing, the sequence of size constraints */ +/* opt_counts If optimizing, the sequence of numbers of components */ +/* In each child of opt_counts, comp_count has the num */ +/* opt_comps_permitted number of components left before opt break */ +/* opt_hyph If optimizing, whether to hyphenate the galley */ +/* opt_gazumped If optimizing, galley has been gazumped recently */ +/* gall_dir Promotion direction (COLM for horizontal galleys) */ +/* ready_galls Galleys read in from cross reference database */ +/* must_expand TRUE if must expand galley object even if indefinite */ +/* sized TRUE after galley object has been sized */ +/* foll_or_prec Direction of search for target (forward, back, etc.) */ +/* whereto Symbol this galley is targeted at */ +/* seen_nojoin TRUE if // op found within galley anywhere */ +/* */ +/* SPLIT - a split object, used for building tables */ +/* */ +/* SIZED The size of the whole object */ +/* first child An object whose horizontal size is the overall size */ +/* second child An object whose vertical size is the overall size */ +/* */ +/* PAR - actual parameter of a symbol invocation (always child of CLOSURE) */ +/* */ +/* TOKEN While still being parsed */ +/* actual The symbol table record defining this parameter */ +/* first child A Lout object, the value of this parameter */ +/* */ +/* WORD, QWORD - a literal word, or a literal word entered in quotes "" */ +/* */ +/* TOKEN While still being parsed */ +/* SIZED The size of the word */ +/* word_font Font to print this word in (from style) */ +/* word_colour Colour to print this word in (from style) */ +/* word_language Language (for hyphenation) of this word (from style) */ +/* underline TRUE if continuous underlining goes under this word */ +/* word_hyph Hyphenation wanted for this word (from style) */ +/* word_save_mark Coord of column mark, temporarily in FixAndPrint */ +/* string[] The characters of the word, null-terminated */ +/* */ +/* WORD, QWORD when used as database header records */ +/* */ +/* string[] Database index file name */ +/* reading TRUE if this database can be read from */ +/* in_memory TRUE if this database's index is held in memory */ +/* db_filep Pointer to database file (if not in_memory) */ +/* left_pos Seek pos of 1st entry in db_filep (if not in_memory) */ +/* db_lines Pointer to database index lines (if in_memory) */ +/* db_lineslen Number of database index lines (if in_memory) */ +/* first child List of symbols held in this database */ +/* other children CROSS_SYM symbols of symbols in this database */ +/* The *links* to these have the following fields: */ +/* number An ID number for this sym in this db */ +/* db_targ TRUE if sym is a galley target */ +/* */ +/* WORD, QWORD when used as font records */ +/* */ +/* string[] Font name */ +/* font_num The number of this font */ +/* font_page Number of most recent page using this font */ +/* font_size Size of this font */ +/* font_xheight2 Half-x height of this font */ +/* font_spacewidth Preferred width of space between words in this font */ +/* font_mapping The mapping to apply with this font */ +/* font_recoded TRUE if font needs recoding in PostScript output */ +/* font_firstpage TRUE if this font is used on the very first page */ +/* */ +/* WORD, QWORD when used in hash table to check whether crs defined twice */ +/* */ +/* db_checksym Symbol of the cross reference */ +/* string[] Tag of the cross reference */ +/* */ +/* HSPANNER (VSPANNER) - An object that spans columns (rows) */ +/* */ +/* TOKEN While still being parsed */ +/* SIZED The size of the object */ +/* spanner_broken TRUE after BreakObject() applied to this object */ +/* spanner_count Number of columns (rows) spanned by this spanner */ +/* spanner_sized Number of cols (rows) of this spanner sized so far */ +/* first child The object that is doing the spanning */ +/* */ +/* COL_THR (ROW_THR) - object representing all objects on a col (row) mark */ +/* */ +/* SIZED The horizontal (vertical) size only */ +/* thr_state Tells whether thread is sized or not yet */ +/* children The objects on the mark */ +/* parents The parents of the children (one-to-one) */ +/* */ +/* ACAT - a paragraph (sequence of objects separated by & or white space) */ +/* */ +/* SIZED The size of the object */ +/* save_style The style to print this paragraph in */ +/* children The paragraph's objects and gaps (obj-gap-obj...obj) */ +/* */ +/* HCAT (VCAT) - a horizontal (vertical) sequence of objects */ +/* */ +/* SIZED The size of the object */ +/* save_style The style to print this object in */ +/* children The objects and gaps (obj-gap-obj...obj) */ +/* adjust_cat Whether to perform adjustment (@VAdjust, etc.) */ +/* */ +/* WIDE (HIGH) - @Wide (@High) object */ +/* */ +/* TOKEN While still being parsed */ +/* SIZED The size of the object */ +/* constraint The horizontal (vertical) size constraint */ +/* first child The right parameter of this symbol */ +/* */ +/* HSHIFT (VSHIFT) - @HShift (@VShift) object */ +/* */ +/* TOKEN While still being parsed */ +/* SIZED The size of the object */ +/* shift_type left, right etc. */ +/* shift_gap The amount to shift */ +/* first child The right parameter of this symbol */ +/* */ +/* HSCALE (VSCALE) - @HScale (@VScale) object */ +/* */ +/* TOKEN While still being parsed */ +/* SIZED The size of the object */ +/* save_mark used temporarily by FixAndPrintObject */ +/* constraint used temporarily by FixAndPrintObject */ +/* first child The right parameter of this symbol */ +/* */ +/* SCALE - @Scale object */ +/* */ +/* TOKEN While still being parsed */ +/* SIZED The size of the object */ +/* bc(constraint) The horizontal scale factor */ +/* fc(constraint) The vertical scale factor */ +/* save_mark used temporarily by FixAndPrintObject */ +/* vert_sized TRUE if vertical size of object is known */ +/* first child The right parameter of this symbol */ +/* */ +/* ONE_COL (ONE_ROW) - @OneCol (@OneRow) object */ +/* HCOVER (VCOVER) - @HCover (@VCover) object */ +/* HCONTRACT (VCONTRACT) - @HContract (@VContract) object */ +/* HEXPAND (VEXPAND) - @HExpand (@VExpand) object */ +/* START_HSPAN, START_VSPAN - @StartHSpan, @StartVSpan */ +/* START_HVSPAN - @StartHVSpan */ +/* HSPAN (VSPAN) - @HSpan (@VSpan) symbols */ +/* KERN_SHRINK - @KernShrink object */ +/* */ +/* TOKEN While still being parsed */ +/* SIZED The size of the object */ +/* first child The right parameter of this symbol */ +/* */ +/* PADJUST (HADJUST, VADJUST) - @PAdjust (@HAdjust, @VAdjust) symbols */ +/* */ +/* TOKEN While still being parsed */ +/* first child The right parameter of this symbol */ +/* */ +/* ROTATE - @Rotate symbol */ +/* */ +/* TOKEN While still being parsed */ +/* SIZED The size of the object */ +/* save_mark used temporarily by FixAndPrintObject */ +/* sparec(cons) Amount to rotate by (after manifesting) */ +/* first child Amount to rotate by (before manifesting) */ +/* last child The right parameter of this symbol */ +/* */ +/* BACKGROUND - @Background symbol */ +/* */ +/* TOKEN While still being parsed */ +/* SIZED The size of the object */ +/* children The two parameters of this symbol */ +/* */ +/* GRAPHIC, PLAIN_GRAPHIC - @Graphic, @PlainGraphic symbols */ +/* */ +/* TOKEN While still being parsed */ +/* SIZED The size of the object */ +/* save_mark used temporarily by FixAndPrintObject */ +/* children The two parameters of this symbol */ +/* */ +/* CASE - @Case symbol */ +/* */ +/* TOKEN While still being parsed */ +/* first child The left parameter of @Case */ +/* last child The right parameter (sequence of @Yield objects) */ +/* */ +/* VERBATIM (RAWVERBATIM) - @Verbatim (@RawVerbatim) symbol */ +/* */ +/* TOKEN While still being parsed */ +/* first child The right parameter of this symbol */ +/* */ +/* FILTERED - object recording filtered Lout object */ +/* */ +/* filter_use_begin TRUE if filter enclosed in @Begin ... @End */ +/* filter_actual The symbol this is an invocation of */ +/* first child WORD containing file name of filter output */ +/* */ +/* XCHAR - @Char symbol */ +/* NEXT - @Next symbol */ +/* ONE_OF - @OneOf symbol */ +/* UNDERLINE - @Underline symbol */ +/* */ +/* TOKEN While still being parsed */ +/* last child The right parameter of this symbol */ +/* */ +/* FONT, SPACE, BREAK - @Font, @Space, @Break symbols */ +/* YUNIT, ZUNIT, COLOUR, LANGUAGE - @YUnit, @ZUnit, @Colour, @Language syms */ +/* PLUS, MINUS, - @Plus, @Minus symbols */ +/* MELD, COMMON, RUMP, INSERT - @Meld, @Common, @Rump, @Insert symbols */ +/* OPEN, TAGGED - @Open, @Tagged symbols */ +/* YIELD - @Yield symbol */ +/* */ +/* TOKEN While still being parsed */ +/* first child The left parameter of this symbol */ +/* last child The right parameter of this symbol */ +/* */ +/* ENV_OBJ - a Lout object with environment attached */ +/* */ +/* first child The Lout object */ +/* last child Its environment (ENV object) */ +/* */ +/* ENV - environment of some Lout object */ +/* */ +/* children Components of the environment */ +/* */ +/* INCGRAPHIC, SINCGRAPHIC - @IncludeGraphic, @SysIncludeGraphic symbols */ +/* */ +/* TOKEN While still being parsed */ +/* SIZED The size of the object */ +/* save_mark used temporarily by FixAndPrintObject */ +/* incgraphic_ok TRUE if file name pans out OK */ +/* last child The right parameter of this symbol */ +/* */ +/* TSPACE, TJUXTA - tokens representing white space */ +/* */ +/* TOKEN While still being parsed */ +/* mark(gap) FALSE */ +/* join(gap) TRUE */ +/* */ +/* BEGIN - @Begin symbol */ +/* */ +/* TOKEN While still being parsed */ +/* actual Symbol this @Begin starts parameter of */ +/* */ +/* END - @End symbol */ +/* LBR, RBR - tokens representing left brace and right brace */ +/* USE, NOT_REVEALED - @Use, @NotRevealed symbols */ +/* GSTUB_EXT, GSTUB_INT, GSTUB_NONE - stubs for transferred galleys */ +/* UNEXPECTED_EOF - unexpected end of file token */ +/* INCLUDE, SYS_INCLUDE - @Include, @SysInclude symbols */ +/* PREPEND, SYS_PREPEND - @PrependGraphic, @SysPrependGraphic symbols */ +/* ENVA, ENVB, ENVC, ENVD - @LEnvA, @LEnvB, @LEnvC, @LEnvD tokens only */ +/* CENV, CLOS, LVIS, LUSE, LEO - @LCEnv, @LClos, @LVis, @LUse, @LEO tokens */ +/* BACKEND - @BackEnd symbol */ +/* CURR_LANG, CURR_FAMILY, CURR_FACE - @CurrLang, @CurrFamily, @CurrFace */ +/* */ +/* TOKEN While still being parsed */ +/* */ +/* DEAD - an index of a dead galley */ +/* */ +/* UNATTACHED - the index of an unattached galley */ +/* */ +/* actual The galley referred to */ +/* non_blocking TRUE if this index should not block galley flushing */ +/* blocked TRUE if this index is now blocking galley flushing */ +/* pinpoint Exact anchor point of this index */ +/* */ +/* RECEPTIVE, RECEIVING - the index of a receptive or receiving object */ +/* */ +/* actual The object (symbol invocation) referred to */ +/* trigger_externs TRUE is this index's galley has external galleys */ +/* non_blocking TRUE if this index should not block galley flushing */ +/* blocked TRUE if this index is now blocking galley flushing */ +/* */ +/* RECURSIVE - the index of a recursive but definite object */ +/* */ +/* actual The recursive symbol invocation referred to */ +/* */ +/* PRECEDES - an index recording a precedes/follows flushing constraint */ +/* */ +/* first child Other parent of this is the corresponding FOLLOWS */ +/* */ +/* FOLLOWS - an index recording a precedes/follows flushing constraint */ +/* */ +/* blocked TRUE if this index is now blocking galley flushing */ +/* first child Other parent of this is the corresponding PRECEDES */ +/* */ +/* CROSS_LIT - not actually an object at all */ +/* */ +/* CROSS_PREC, CROSS_FOLL, CROSS_FOLL_OR_PREC - the index of a cross ref */ +/* */ +/* actual The cross reference referred to */ +/* underline TRUE if continuous underline goes through here */ +/* first child Equal to actual */ +/* */ +/* GALL_PREC, GALL_FOLL, GALL_FOLL_OR_PREC - index of a galley */ +/* */ +/* actual The galley referred to */ +/* underline TRUE if continuous underline goes through here */ +/* pinpoint Exact anchor point of this index */ +/* */ +/* GALL_TARG - index of the target of a galley */ +/* */ +/* actual The galley target (symbol invocation) referred to */ +/* underline TRUE if continuous underline goes through here */ +/* */ +/* PAGE_LABEL_IND - the index of a @PageLabel object */ +/* */ +/* actual The @PageLabel object referred to */ +/* underline TRUE if continuous underline goes through here */ +/* first child Equal to actual */ +/* */ +/* SCALE_IND - the index of a @Scale symbol with empty left parameter */ +/* COVER_IND - the index of an @HCover or @VCover object */ +/* EXPAND_IND - the index of an @HExpand or @VExpand object */ +/* */ +/* actual The object referred to */ +/* underline TRUE if continuous underline goes through here */ +/* */ +/* THREAD - a sequence of threads (basically local to Manifest) */ +/* */ +/* children The threads */ +/* */ +/* CROSS_SYM - a record of the cross reference state of some symbol */ +/* */ +/* target_state Whether we currently have a preceding target */ +/* target_file Which file target is written to */ +/* target_val Value of target (if target_state == SEEN_TARGET) */ +/* target_seq A sequence number */ +/* target_pos Seek position of target in target_file */ +/* target_lnum Line number of target in target_file */ +/* gall_seq Sequence number for galleys targeted to here */ +/* symb The symbol table record of the symbol this is for */ +/* gall_tag I forget! */ +/* gall_tfile The most recent cr database file for this sym */ +/* children Cross references and galleys waiting for a target */ +/* These children have the following fields: */ +/* */ +/* string[] The sequence number */ +/* cs_type The cross reference type */ +/* cs_fnum File number where value written */ +/* cs_pos File seek position */ +/* cs_lnum File line number */ +/* */ +/* CR_ROOT - all CROSS_SYM objects are children of this singleton */ +/* */ +/* children All CROSS_SYM symbols */ +/* */ +/* MACRO - a symbol table entry for a symbol which is a macro */ +/* LOCAL - a symbol table entry for a symbol which is a local symbol */ +/* LPAR - a symbol table entry for a symbol which is a left parameter */ +/* RPAR - a symbol table entry for a symbol which is a right parameter */ +/* NPAR - a symbol table entry for a symbol which is a named parameter */ +/* */ +/* enclosing The symbol that this one is defined within, if any */ +/* sym_body The symbol body (token sequence if MACRO) */ +/* base_uses Local to symbol table, for calculating call graph */ +/* uses Call graph info */ +/* marker For call graph calculation */ +/* imports The import list preceding this symbol, if any */ +/* filter Child @Filter symbol, if any */ +/* use_invocation A @Use clause containing this symbol, if any */ +/* predefined If predefined symbol, its non-zero enum code */ +/* has_compulsory Number of parameters with "compulsory" tag */ +/* uses_count Number of times this symbol is used */ +/* npar_code One-letter abbreviation for this NPAR */ +/* cross_sym The CROSS_SYM record for this symbol, if any */ +/* recursive TRUE if symbol is recursive */ +/* has_body TRUE if symbol has a body parameter */ +/* imports_encl TRUE if symbol imports the symbol enclosing itself */ +/* right_assoc TRUE if this symbol has "associativity right" */ +/* precedence The precedence of this symbol */ +/* indefinite TRUE if this symbol is indefinite (e.g. receptive) */ +/* recursive TRUE if symbol is recursive */ +/* is_extern_target TRUE if symbol is the target of external galley */ +/* uses_extern_target TRUE if symbol uses target of an external galley */ +/* visible TRUE if symbol is exported */ +/* uses_galley TRUE if symbol uses a galley */ +/* horiz_galley if galley, ROWM if vertical, COLM if horizontal */ +/* is_compulsory TRUE if this is a parameter with "compulsory" tag */ +/* dirty TRUE if must copy this parameter, not link it */ +/* has_par TRUE if this symbol has at least one parameter */ +/* has_lpar TRUE if this symbol has a left parameter */ +/* has_rpar TRUE if this symbol has a right or body parameter */ +/* has_target TRUE if this symbol has a target (is a galley) */ +/* force_target TRUE if this symbol has a forcing target */ +/* is_target TRUE if this symbol is @Target, defining a target */ +/* has_tag TRUE if this symbol has a @Tag parameter */ +/* is_tag TRUE if this symbol is a @Tag parameter */ +/* has_key TRUE if this symbol has a @Key parameter */ +/* is_key TRUE if this symbol is a @Key parameter */ +/* has_optimize TRUE if this symbol has an @Optimize parameter */ +/* is_optimize TRUE if this symbol is an @Optimize parameter */ +/* has_merge TRUE if this symbol has a @Merge parameter */ +/* is_merge TRUE if this symbol is a @Merge parameter */ +/* has_enclose TRUE if this symbol has an @Enclose parameter */ +/* is_enclose TRUE if this symbol is an @Enclose parameter */ +/* */ +/* EXT_GALL - a record of an external galley, not actually read in yet */ +/* */ +/* eg_fnum Number of file read from */ +/* eg_fpos Position in that file */ +/* eg_lnum Line number in that file */ +/* eg_cont Continuation (where to look for next galley) */ +/* eg_symbol The symbol that is the target of this galley */ +/* first child The galley tag */ +/* second child The galley sequence string */ +/* */ +/* CR_LIST - a list of cross references */ +/* */ +/* children The cross-references */ +/* */ +/* DISPOSED - a disposed object (available for reallocation) */ +/* */ +/*****************************************************************************/ + +typedef union rec +{ + struct word_type /* all fields of WORD and QWORD, token and object */ + { LIST olist[2]; + FIRST_UNION ou1; + SECOND_UNION ou2; + THIRD_UNION ou3; + FULL_CHAR ostring[4]; + } os1; + + struct closure_type /* all fields of CLOSURE, both as token and object */ + { LIST olist[2]; + FIRST_UNION ou1; + SECOND_UNION ou2; + THIRD_UNION ou3; + FOURTH_UNION ou4; + union rec *oactual; + union + { union rec *owhereto; + union rec *opinpoint; + FULL_LENGTH osave_mark; + } oux; + /* union rec *oready_galls; */ + } os2; + + struct head_type /* all fields of HEAD, both as token and object */ + { LIST olist[2]; + FIRST_UNION ou1; + SECOND_UNION ou2; + THIRD_UNION ou3; + FOURTH_UNION ou4; + union rec *oactual; + union + { union rec *owhereto; + union rec *opinpoint; + FULL_LENGTH osave_mark; + } oux; + union rec *oready_galls; + union rec *oopt_components; + union rec *oopt_constraints; + union rec *oopt_counts; + union rec *olimiter; + union rec *oenclose_obj; + int oopt_comps_permitted; + } os2a; + + struct object_type /* the general OBJECT */ + { LIST olist[2]; + FIRST_UNION ou1; + SECOND_UNION ou2; + THIRD_UNION ou3; + FOURTH_UNION ou4; + } os3; + + struct link_type /* LINK */ + { LIST olist[2]; + unsigned char otype; + unsigned char onumber; + unsigned char odb_targ; + } os4; + + struct gapobj_type /* GAP_OBJ */ + { LIST olist[2]; + FIRST_UNION ou1; + SECOND_UNION ou2; + GAP ogap; + int osave_badness; /* optimum paragraph breaker */ + SHORT_LENGTH osave_space; /* optimum paragraph breaker */ + SHORT_LENGTH osave_actual_gap; /* optimum paragraph breaker */ + union rec *osave_prev; /* optimum paragraph breaker */ + union rec *osave_cwid; /* optimum paragraph breaker */ + } os5; + + struct symbol_type + { LIST olist[2]; + FIRST_UNION ou1; + SECOND_UNION ou2; + union rec *oenclosing; + union rec *osym_body; + union rec *obase_uses; + union rec *ouses; + union rec *omarker; + union rec *ocross_sym; + union rec *oimports; + union rec *ofilter; + union rec *ouse_invocation; + short unsigned opredefined; + short unsigned ohas_compulsory; + unsigned char ouses_count; + unsigned char onpar_code; + BOOLEAN ois_optimize : 1; + BOOLEAN ohas_optimize : 1; + BOOLEAN ois_merge : 1; + BOOLEAN ohas_merge : 1; + BOOLEAN ois_enclose : 1; + BOOLEAN ohas_enclose : 1; + BOOLEAN ois_compulsory : 1; + } os6; + + struct cr_type + { LIST olist[2]; + unsigned char otype; + unsigned char otarget_state; + FILE_NUM otarget_file; + /* FILE_NUM ocr_file; unused */ + union rec *otarget_val; + int otarget_seq; + int otarget_pos; + int otarget_lnum; + /* int ocr_seq; unused */ + int ogall_seq; + union rec *osymb; + union rec *ogall_tag; + FILE_NUM ogall_tfile; + } os7; + + struct ext_gall_type + { LIST olist[2]; + unsigned char otype; + FILE_NUM oeg_fnum; + int oeg_lnum; + long oeg_fpos; + long oeg_cont; + union rec *oeg_symbol; + } os8; + + struct uses_type + { union rec *oitem; + union rec *onext; + } os9; +#define USES_SIZE ceiling( sizeof(struct uses_type), sizeof(ALIGN) ) + + struct hash_entry_type + { LIST olist[1]; + } os10; + +} *OBJECT; + + +/*@::macros for fields of OBJECT@*********************************************/ +/* */ +/* Macros for fields of OBJECT. */ +/* */ +/*****************************************************************************/ + +#define succ(x, dim) (x)->os1.olist[dim].osucc +#define pred(x, dim) (x)->os1.olist[dim].opred + +#define type(x) (x)->os1.ou1.os11.otype +#define rec_size(x) (x)->os1.ou1.os11.orec_size +#define precedence(x) (x)->os1.ou2.os21.oprecedence +#define hspace(x) (x)->os1.ou2.os21.ohspace +#define vspace(x) (x)->os1.ou2.os21.ovspace + +#define word_font(x) (x)->os1.ou2.os22.oword_font +#define spanner_count(x) word_font(x) +#define word_colour(x) (x)->os1.ou2.os22.oword_colour +#define spanner_sized(x) word_colour(x) +#define word_language(x) (x)->os1.ou2.os22.oword_language +#define spanner_broken(x) word_language(x) +#define underline(x) (x)->os1.ou2.os22.ounderline +#define word_hyph(x) (x)->os1.ou2.os22.oword_hyph +#define filter_use_begin(x) (x)->os1.ou2.os22.oword_colour + +#define non_blocking(x) (x)->os1.ou2.os23.onon_blocking +#define vert_sized(x) non_blocking(x) +#define sized(x) (x)->os1.ou2.os23.osized +#define threaded(x) (x)->os1.ou2.os23.othreaded +#define external_ver(x) (x)->os1.ou2.os23.oexternal_ver +#define external_hor(x) (x)->os1.ou2.os23.oexternal_hor +#define blocked(x) (x)->os1.ou2.os23.oblocked +#define seen_nojoin(x) blocked(x) +#define trigger_externs(x) (x)->os1.ou2.os23.otrigger_ext +#define must_expand(x) (x)->os1.ou2.os23.omust_expand +#define gall_dir(x) (x)->os1.ou2.os23.ogall_dir +#define opt_hyph(x) (x)->os1.ou2.os23.oopt_hyph +#define opt_gazumped(x) (x)->os1.ou2.os23.oopt_gazumped +#define adjust_cat(x) (x)->os1.ou2.os23.oadjust_cat +#define force_gall(x) (x)->os1.ou2.os23.oforce_gall +#define cross_type(x) (x)->os1.ou2.os23.ocross_type +#define foll_or_prec(x) (x)->os1.ou2.os23.ofoll_or_prec +#define thr_state(x) cross_type(x) +#define incgraphic_ok(x) cross_type(x) + +#define left_pos(x) (x)->os1.ou2.os24.oleft_pos +#define db_lineslen(x) left_pos(x) +#define reading(x) (x)->os1.ou2.os24.oreading +#define in_memory(x) (x)->os1.ou2.os24.oin_memory + +#define is_tag(x) (x)->os1.ou2.os26.ois_tag +#define has_tag(x) (x)->os1.ou2.os26.ohas_tag +#define has_lpar(x) (x)->os1.ou2.os26.ohas_lpar +#define has_rpar(x) (x)->os1.ou2.os26.ohas_rpar +#define right_assoc(x) (x)->os1.ou2.os26.oright_assoc +#define is_target(x) (x)->os1.ou2.os26.ois_target +#define has_target(x) (x)->os1.ou2.os26.ohas_target +#define force_target(x) (x)->os1.ou2.os26.oforce_target +#define has_body(x) (x)->os1.ou2.os26.ohas_body +#define indefinite(x) (x)->os1.ou2.os26.oindefinite +#define recursive(x) (x)->os1.ou2.os26.orecursive +#define uses_extern_target(x) (x)->os1.ou2.os26.ouses_extern_target +#define is_extern_target(x) (x)->os1.ou2.os26.ois_extern_target +#define is_key(x) (x)->os1.ou2.os26.ois_key +#define has_key(x) (x)->os1.ou2.os26.ohas_key +#define dirty(x) (x)->os1.ou2.os26.odirty +#define visible(x) (x)->os1.ou2.os26.ovisible +#define has_mark(x) (x)->os1.ou2.os26.ohas_mark +#define has_join(x) (x)->os1.ou2.os26.ohas_join +#define has_par(x) (x)->os1.ou2.os26.ohas_par +#define uses_galley(x) (x)->os1.ou2.os26.ouses_galley +#define horiz_galley(x) (x)->os1.ou2.os26.ohoriz_galley +#define imports_encl(x) (x)->os1.ou2.os26.oimports_encl + +#define fpos(x) (x)->os1.ou1.ofpos +#define word_save_mark(x) (x)->os1.ou1.os11.oword_save_mark + +#define back(x, dim) (x)->os1.ou3.os31.oback[dim] +#define comp_count(x) back(x, COLM) +#define fwd(x, dim) (x)->os1.ou3.os31.ofwd[dim] +#define size(x, dim) (back(x, dim) + fwd(x, dim)) +#define db_filep(x) (x)->os1.ou3.odb_filep +#define db_lines(x) (x)->os1.ou3.odb_lines +#define filter_actual(x) (x)->os1.ou3.ofilter_actual +#define db_checksym(x) filter_actual(x) + +#define cs_type(x) (x)->os1.ou3.os33.ocs_type +#define cs_fnum(x) (x)->os1.ou3.os33.ocs_fnum +#define cs_pos(x) (x)->os1.ou3.os33.ocs_pos +#define cs_lnum(x) (x)->os1.ou3.os33.ocs_lnum + +#define gall_rec(x) (x)->os1.ou3.os33.ogall_rec +#define gall_type(x) (x)->os1.ou3.os33.ogall_type +#define gall_pos(x) (x)->os1.ou3.os33.ogall_pos + +#define string(x) (x)->os1.ostring + +#define save_style(x) (x)->os2.ou4.osave_style +#define constraint(x) (x)->os2.ou4.oconstraint +#define shift_type(x) width(space_gap(save_style(x))) +#define shift_gap(x) line_gap(save_style(x)) + +#define actual(x) (x)->os2.oactual +#define whereto(x) (x)->os2.oux.owhereto +#define pinpoint(x) (x)->os2.oux.opinpoint +#define save_mark(x) (x)->os2.oux.osave_mark +#define ready_galls(x) (x)->os2a.oready_galls +#define opt_components(x) (x)->os2a.oopt_components +#define opt_constraints(x) (x)->os2a.oopt_constraints +#define opt_counts(x) (x)->os2a.oopt_counts +#define limiter(x) (x)->os2a.olimiter +#define enclose_obj(x) (x)->os2a.oenclose_obj +#define opt_comps_permitted(x) (x)->os2a.oopt_comps_permitted + +#define number(x) (x)->os4.onumber +#define db_targ(x) (x)->os4.odb_targ + +#define gap(x) (x)->os5.ogap +#define save_badness(x) (x)->os5.osave_badness +#define save_space(x) (x)->os5.osave_space +#define save_actual_gap(x) (x)->os5.osave_actual_gap +#define save_prev(x) (x)->os5.osave_prev +#define save_cwid(x) (x)->os5.osave_cwid + +#define enclosing(x) (x)->os6.oenclosing +#define sym_body(x) (x)->os6.osym_body +#define base_uses(x) (x)->os6.obase_uses +#define uses(x) (x)->os6.ouses +#define marker(x) (x)->os6.omarker +#define cross_sym(x) (x)->os6.ocross_sym +#define imports(x) (x)->os6.oimports +#define filter(x) (x)->os6.ofilter +#define use_invocation(x) (x)->os6.ouse_invocation +#define predefined(x) (x)->os6.opredefined +#define has_compulsory(x) (x)->os6.ohas_compulsory +#define uses_count(x) (x)->os6.ouses_count +#define npar_code(x) (x)->os6.onpar_code +#define is_optimize(x) (x)->os6.ois_optimize +#define has_optimize(x) (x)->os6.ohas_optimize +#define is_merge(x) (x)->os6.ois_merge +#define has_merge(x) (x)->os6.ohas_merge +#define is_enclose(x) (x)->os6.ois_enclose +#define has_enclose(x) (x)->os6.ohas_enclose +#define is_compulsory(x) (x)->os6.ois_compulsory + +#define target_state(x) (x)->os7.otarget_state +#define target_file(x) (x)->os7.otarget_file +/* #define cr_file(x) (x)->os7.ocr_file unused */ +#define target_val(x) (x)->os7.otarget_val +#define target_seq(x) (x)->os7.otarget_seq +#define target_pos(x) (x)->os7.otarget_pos +#define target_lnum(x) (x)->os7.otarget_lnum +/* #define cr_seq(x) (x)->os7.ocr_seq unused */ +#define gall_seq(x) (x)->os7.ogall_seq +#define symb(x) (x)->os7.osymb +#define gall_tag(x) (x)->os7.ogall_tag +#define gall_tfile(x) (x)->os7.ogall_tfile + +#define eg_fnum(x) (x)->os8.oeg_fnum +#define eg_fpos(x) (x)->os8.oeg_fpos +#define eg_lnum(x) (x)->os8.oeg_lnum +#define eg_cont(x) (x)->os8.oeg_cont +#define eg_symbol(x) (x)->os8.oeg_symbol + +#define item(x) (x)->os9.oitem +#define next(x) (x)->os9.onext + +#define font_num(x) (x)->os1.ou2.os25.ofont_num +#define font_page(x) (x)->os1.ou2.os25.ofont_page +#define font_size(x) (x)->os1.ou3.os32.ofont_size +#define font_xheight2(x) (x)->os1.ou3.os32.ofont_xheight2 +#define font_spacewidth(x) (x)->os1.ou3.os32.ofont_spacewidth +#define font_mapping(x) (x)->os1.ou3.os32.ofont_mapping +#define font_recoded(x) (x)->os1.ou3.os32.ofont_recoded +#define font_firstpage(x) (x)->os1.ou3.os32.ofont_firstpage + + +/*@::FONT_INFO@***************************************************************/ +/* */ +/* typedef FONT_INFO - information about font metrics etc. Really private */ +/* but shared between z37.c and z24.c */ +/* */ +/*****************************************************************************/ + +struct metrics { + SHORT_LENGTH up; + SHORT_LENGTH down; + SHORT_LENGTH left; + SHORT_LENGTH right; + SHORT_LENGTH last_adjust; +}; + +typedef struct font_rec { + struct metrics *size_table; /* metrics of sized fonts */ + FULL_CHAR *lig_table; /* ligatures */ + OBJECT font_table; /* record of sized fonts */ + OBJECT original_font; /* font rec before resizing */ + SHORT_LENGTH underline_pos; /* position of underline */ + SHORT_LENGTH underline_thick; /* thickness of underline */ + unsigned short *kern_table; /* first kerning chars */ + FULL_CHAR *kern_chars; /* second kerning chars */ + unsigned char *kern_value; /* points into kern_lengths */ + SHORT_LENGTH *kern_sizes; /* sizes of kernings */ +} FONT_INFO; + + +/*@::MAP_VEC@*****************************************************************/ +/* */ +/* typedef MAP_VEC - information about character mappings. Really private */ +/* to z38.c but (for efficiency) shared with z37.c and z24.c */ +/* */ +/*****************************************************************************/ + +#define MAX_CHASH 353 /* size of hash table */ +#define MAP_UPPERCASE 0 /* the map to upper case */ +#define MAP_LOWERCASE 1 /* the map to lower case */ +#define MAP_UNACCENTED 2 /* the map to unaccented */ +#define MAP_ACCENT 3 /* the map to the accent character */ +#define MAPS 4 /* the number of maps in each file */ + +typedef struct mapvec { + OBJECT file_name; /* name of file containing the vec */ + FILE_NUM fnum; /* the file number of this file */ + BOOLEAN must_print; /* TRUE if this vec must be printed */ + OBJECT name; /* PostScript name of encoding vec */ + OBJECT vector[MAX_CHARS]; /* character names */ + FULL_CHAR hash_table[MAX_CHASH]; /* character hash table for inverse */ + FULL_CHAR map[MAPS][MAX_CHARS]; /* the mappings */ +} *MAP_VEC; + + +/*@::object types@************************************************************/ +/* */ +/* OBJECT, TOKEN AND OTHER TYPES inhabiting type(x) and predefined(x) */ +/* */ +/* Key letters in the adjacent comment indicate where the tag is legal: */ +/* */ +/* t a token type, pushed on token stack */ +/* o an object type (returned by reduce(), inserted by Manifest) */ +/* i an index type (a child of a galley header other than an object) */ +/* s a predefined symbol (some symbol table entry has this predefined()) */ +/* n an indefinite object i.e. one which is ignored in catenation ops */ +/* */ +/*****************************************************************************/ + +#define LINK 0 /* a link between objects */ +#define GAP_OBJ 1 /* o a gap object */ +#define CLOSURE 2 /* to n a closure of a symbol */ +#define UNDER_REC 3 /* o n record of underlining */ +#define PAGE_LABEL 4 /* to sn @PageLabel */ +#define NULL_CLOS 5 /* to sn @Null */ +#define CROSS 6 /* to sn && (a cross reference obj) */ +#define FORCE_CROSS 7 /* to sn &&& (a forcing cross ref.) */ +#define HEAD 8 /* o n a galley header */ +#define SPLIT 9 /* o @Split */ +#define PAR 10 /* o a parameter of a closure */ +#define WORD 11 /* o a word */ +#define QWORD 12 /* o a word (was quoted in i/p) */ +#define HSPANNER 13 /* o a horizontal spanner */ +#define VSPANNER 14 /* o a vertical spanner */ +#define ROW_THR 15 /* o a row thread */ +#define COL_THR 16 /* o a column thread */ +#define ACAT 17 /* to s a sequence of &-ed objs */ +#define HCAT 18 /* to s a sequence of |-ed objs */ +#define VCAT 19 /* to s a sequence of /-ed objs */ +#define ONE_COL 20 /* to s @OneCol */ +#define ONE_ROW 21 /* to s @OneRow */ +#define WIDE 22 /* to s @Wide */ +#define HIGH 23 /* to s @High */ +#define HSHIFT 24 /* to s @HShift */ +#define VSHIFT 25 /* to s @VShift */ +#define HSCALE 26 /* to s @HScale */ +#define VSCALE 27 /* to s @VScale */ +#define HCOVER 28 /* to s @HCover */ +#define VCOVER 29 /* to s @VCover */ +#define SCALE 30 /* to s @Scale */ +#define KERN_SHRINK 31 /* to s @KernShrink */ +#define HCONTRACT 32 /* to s @HContract */ +#define VCONTRACT 33 /* to s @VContract */ +#define HLIMITED 34 /* to s @HLimited */ +#define VLIMITED 35 /* to s @VLimited */ +#define HEXPAND 36 /* to s @HExpand */ +#define VEXPAND 37 /* to s @VExpand */ +#define START_HSPAN 38 /* to s @StartHSpan */ +#define START_VSPAN 39 /* to s @StartVSpan */ +#define START_HVSPAN 40 /* to s @StartHVSpan */ +#define HSPAN 41 /* to s @HSpan */ +#define VSPAN 42 /* to s @VSpan */ +#define PADJUST 43 /* to s @PAdjust */ +#define HADJUST 44 /* to s @HAdjust */ +#define VADJUST 45 /* to s @VAdjust */ +#define ROTATE 46 /* to s @Rotate */ +#define BACKGROUND 47 /* to s @Background */ +#define CASE 48 /* to s @Case */ +#define VERBATIM 49 /* to s @Verbatim */ +#define RAW_VERBATIM 50 /* to s @RawVerbatim */ +#define YIELD 51 /* to s @Yield */ +#define BACKEND 52 /* to s @BackEnd */ +#define FILTERED 53 /* to s filtered object (no name) */ +#define XCHAR 54 /* to s @Char */ +#define FONT 55 /* to s @Font */ +#define SPACE 56 /* to s @Space */ +#define YUNIT 57 /* to s @YUnit */ +#define ZUNIT 58 /* to s @ZUnit */ +#define BREAK 59 /* to s @Break */ +#define UNDERLINE 60 /* to s @Underline */ +#define COLOUR 61 /* to s @SetColour and @SetColor */ +#define LANGUAGE 62 /* to s @Language */ +#define CURR_LANG 63 /* to s @CurrLang */ +#define CURR_FAMILY 64 /* to s @CurrFamily */ +#define CURR_FACE 65 /* to s @CurrFace */ +#define COMMON 66 /* to s @Common */ +#define RUMP 67 /* to s @Rump */ +#define MELD 68 /* to s @Meld */ +#define INSERT 69 /* to s @Insert */ +#define ONE_OF 70 /* to s @OneOf */ +#define NEXT 71 /* to s @Next */ +#define PLUS 72 /* to s @Plus */ +#define MINUS 73 /* to s @Minus */ +#define ENV_OBJ 74 /* to s object with envt (no name) */ +#define ENV 75 /* to s @LEnv */ +#define ENVA 76 /* to s @LEnvA */ +#define ENVB 77 /* to s @LEnvB */ +#define ENVC 78 /* to s @LEnvC */ +#define ENVD 79 /* to s @LEnvD */ +#define CENV 80 /* to s @LCEnv */ +#define CLOS 81 /* to s @LClos */ +#define LVIS 82 /* to s @LVis */ +#define LUSE 83 /* to s @LUse */ +#define LEO 84 /* to s @LEO */ +#define OPEN 85 /* to s @Open */ +#define TAGGED 86 /* to s @Tagged */ +#define INCGRAPHIC 87 /* to s @IncludeGraphic */ +#define SINCGRAPHIC 88 /* to s @SysIncludeGraphic */ +#define PLAIN_GRAPHIC 89 /* to s @PlainGraphic */ +#define GRAPHIC 90 /* to s @Graphic */ +#define TSPACE 91 /* t a space token, parser only */ +#define TJUXTA 92 /* t a juxta token, parser only */ +#define LBR 93 /* t s left brace token */ +#define RBR 94 /* t s right brace token */ +#define BEGIN 95 /* t s @Begin token */ +#define END 96 /* t s @End token */ +#define USE 97 /* t s @Use */ +#define NOT_REVEALED 98 /* t s @NotRevealed */ +#define GSTUB_NONE 99 /* t a galley stub, no rpar */ +#define GSTUB_INT 100 /* t galley stub internal rpar */ +#define GSTUB_EXT 101 /* t galley stub external rpar */ +#define UNEXPECTED_EOF 102 /* t unexpected end of file */ +#define INCLUDE 103 /* s @Include */ +#define SYS_INCLUDE 104 /* s @SysInclude */ +#define PREPEND 105 /* s @Prepend */ +#define SYS_PREPEND 106 /* s @SysPrepend */ +#define DATABASE 107 /* s @Database */ +#define SYS_DATABASE 108 /* s @SysDatabase */ +/* #define START 109 */ /* s \Start */ +#define DEAD 110 /* i a dead galley */ +#define UNATTACHED 111 /* i an inner, unsized galley */ +#define RECEPTIVE 112 /* i a receptive object index */ +#define RECEIVING 113 /* i a receiving object index */ +#define RECURSIVE 114 /* i a recursive definite obj. */ +#define PRECEDES 115 /* i an ordering constraint */ +#define FOLLOWS 116 /* i other end of ordering c. */ +#define CROSS_LIT 117 /* i literal word cross-ref */ +#define CROSS_FOLL 118 /* i following type cross-ref */ +#define CROSS_FOLL_OR_PREC 119 /* i follorprec type cross-ref */ +#define GALL_FOLL 120 /* i galley with &&following */ +#define GALL_FOLL_OR_PREC 121 /* i galley with &&following */ +#define CROSS_TARG 122 /* i value of cross-ref */ +#define GALL_TARG 123 /* i target of these galleys */ +#define GALL_PREC 124 /* i galley with &&preceding */ +#define CROSS_PREC 125 /* i preceding type cross-ref */ +#define PAGE_LABEL_IND 126 /* i index of PAGE_LABEL */ +#define SCALE_IND 127 /* i index of auto SCALE */ +#define COVER_IND 128 /* i index of HCOVER or VCOVER */ +#define EXPAND_IND 129 /* i index of HEXPAND or VEXPD */ +#define THREAD 130 /* a sequence of threads */ +#define CROSS_SYM 131 /* cross-ref info */ +#define CR_ROOT 132 /* RootCross */ +#define MACRO 133 /* a macro symbol */ +#define LOCAL 134 /* a local symbol */ +#define LPAR 135 /* a left parameter */ +#define NPAR 136 /* a named parameter */ +#define RPAR 137 /* a right parameter */ +#define EXT_GALL 138 /* an external galley */ +#define CR_LIST 139 /* a list of cross references */ +#define DISPOSED 140 /* a disposed record */ + +#define is_indefinite(x) ((x) >= CLOSURE && (x) <= HEAD) +#define is_definite(x) ((x) >= SPLIT && (x) <= GRAPHIC) +#define is_par(x) ((x) >= LPAR && (x) <= RPAR) +#define is_index(x) ((x) >= DEAD && (x) <= EXPAND_IND) +#define is_type(x) ((x) >= LINK && (x) < DISPOSED) +#define is_word(x) ((x) == WORD || (x) == QWORD) +#define is_cross(x) ((x) == CROSS || (x) == FORCE_CROSS) +#define is_cat_op(x) (((x)>=ACAT && (x)<=VCAT) || (x)==TSPACE || (x)<=TJUXTA) + + +/*@::miscellaneous constants@*************************************************/ +/* */ +/* Miscellaneous globally defined constants */ +/* */ +/*****************************************************************************/ + +/* gap modes occupying mode(x) */ +#define NO_MODE 0 /* for error detection: no mode */ +#define EDGE_MODE 1 /* edge-to-edge spacing */ +#define HYPH_MODE 2 /* edge-to-edge with hyphenation */ +#define MARK_MODE 3 /* mark-to-mark spacing */ +#define OVER_MODE 4 /* overstrike spacing */ +#define KERN_MODE 5 /* kerning spacing */ +#define TAB_MODE 6 /* tabulation spacing */ +#define ADD_HYPH 7 /* temp value used by FillObject */ + +/* hyph_style(style) options */ +#define HYPH_UNDEF 0 /* hyphenation option undefined */ +#define HYPH_OFF 1 /* hyphenation off */ +#define HYPH_ON 2 /* hyphenation on */ + +/* fill_style(style) options */ +#define FILL_UNDEF 0 /* fill option undefined */ +#define FILL_OFF 1 /* no filling of lines */ +#define FILL_ON 2 /* fill lines with text */ + +/* underline(obj) options */ +#define UNDER_UNDEF 0 /* underline undefined */ +#define UNDER_OFF 1 /* no underlining */ +#define UNDER_ON 2 /* underline this */ + +/* space_style(style) options */ +#define SPACE_LOUT 0 /* interpret white space Lout's way */ +#define SPACE_COMPRESS 1 /* compress multiple white spaces */ +#define SPACE_SEPARATE 2 /* compress an separate */ +#define SPACE_TROFF 3 /* interpret white space troff's way */ +#define SPACE_TEX 4 /* interpret white space TeX's way */ + +/* display_style(style) options */ +#define DISPLAY_UNDEF 0 /* display option undefined */ +#define DISPLAY_ADJUST 1 /* adjust lines (except last) */ +#define DISPLAY_OUTDENT 2 /* outdent lines (except first) */ +#define DISPLAY_ORAGGED 3 /* outdent but don't adjust */ +#define DISPLAY_LEFT 4 /* left-justify lines, no adjust */ +#define DISPLAY_CENTRE 5 /* centre lines, no adjust */ +#define DISPLAY_RIGHT 6 /* right-justify lines, no adjust */ +#define DO_ADJUST 7 /* placed in ACATs when adjust need */ + +/* small_caps(style) options */ +#define SMALL_CAPS_OFF 0 /* don't want small capitals */ +#define SMALL_CAPS_ON 1 /* small capitals */ + +/* sides of a mark */ +#define BACK 141 /* means lies to left of mark */ +#define ON 142 /* means lies on mark */ +#define FWD 143 /* means lies to right of mark */ + +/* statuses of thread objects */ +#define NOTSIZED 0 /* this thread object is not sized */ +#define SIZED 1 /* thread is sized but not printed */ +#define FINALSIZE 2 /* thread object size is now final */ + +/* constraint statuses */ +#define PROMOTE 144 /* this component may be promoted */ +#define CLOSE 145 /* must close dest before promoting */ +#define BLOCK 146 /* cannot promote this component */ +#define CLEAR 147 /* this constraint is now satisfied */ + +/* gap increment types */ +#define GAP_ABS 148 /* absolute, e.g. 3p */ +#define GAP_INC 149 /* increment, e.g. +3p */ +#define GAP_DEC 150 /* decrement, e.g. -3p */ + +/* file types */ +#define SOURCE_FILE 0 /* input file from command line */ +#define INCLUDE_FILE 1 /* @Include file */ +#define INCGRAPHIC_FILE 2 /* @IncludeGraphic file */ +#define DATABASE_FILE 3 /* database file */ +#define INDEX_FILE 4 /* database index file */ +#define FONT_FILE 5 /* font file */ +#define PREPEND_FILE 6 /* PostScript prologue file */ +#define HYPH_FILE 7 /* hyphenation file */ +#define HYPH_PACKED_FILE 8 /* packed hyphenation file */ +#define MAPPING_FILE 9 /* character mapping file */ +#define FILTER_FILE 10 /* filter output file */ +#define MAX_TYPES 11 /* number of file types */ + +/* path types (i.e. sequences of directories for file searching) */ +#define SOURCE_PATH 0 /* path to search for source files */ +#define INCLUDE_PATH 1 /* path for @Include files */ +#define SYSINCLUDE_PATH 2 /* path for @SysInclude files */ +#define DATABASE_PATH 3 /* path for @Database files */ +#define SYSDATABASE_PATH 4 /* path for @SysDatabase files */ +#define FONT_PATH 5 /* path for font metrics (AFM) files */ +#define HYPH_PATH 6 /* path for hyphenation files */ +#define MAPPING_PATH 7 /* path for mapping (LCM) files */ +#define MAX_PATHS 8 /* number of mapping paths */ + +/* units of measurement */ +#define NO_UNIT 0 /* no unit - for error detection */ +#define FIXED_UNIT 1 /* inches, cm, points, ems, y, z */ +#define FRAME_UNIT 2 /* b unit (frame widths) */ +#define AVAIL_UNIT 3 /* r unit (available spaces) */ +#define DEG_UNIT 4 /* d unit (degrees) */ +#define NEXT_UNIT 5 /* w unit (inners) */ + +/* units of distance as multiples of the basic unit */ +#define CM 567 /* 1 centimetre */ +#define IN 1440 /* 1 inch */ +#define EM 120 /* 1 em (= 1/12 inch) */ +#define PT 20 /* 1 point (= 1/72 inch) */ +#define FR 4096 /* virtual unit for frame units */ +#define DG 128 /* virtual unit for degrees */ +#define SF 128 /* virtual unit for @Scale factors */ + +/* default size of characters for the PLAINTEXT back end */ +#define PLAIN_WIDTH 144 /* default char width, 10 per inch */ +#define PLAIN_HEIGHT 240 /* default char height, 6 per inch */ + +/* precedences */ +#define NO_PREC 0 /* lower than any precedence */ +#define BEGIN_PREC 1 /* precedence of @Begin */ +#define END_PREC 2 /* precedence of @End */ +#define LBR_PREC 3 /* precedence of { */ +#define RBR_PREC 4 /* precedence of } */ +#define VCAT_PREC 5 /* precedence of / */ +#define HCAT_PREC 6 /* precedence of | */ +#define ACAT_PREC 7 /* precedence of & and white space */ +#define MIN_PREC 10 /* minimum precedence of user ops */ +#define MAX_PREC 100 /* maximim precedence of user ops */ +#define DEFAULT_PREC 100 /* default precedence of user ops */ +#define CROSSOP_PREC 101 /* precedence of && and &&& ops */ +#define GAP_PREC 102 /* precedence of gap op after cat op */ +#define JUXTA_PREC 103 /* precedence of juxtaposition & */ +#define FILTER_PREC 104 /* precedence of filter symbol ops */ +#define FORCE_PREC 105 /* higher than any precedence */ + +/* back ends */ +#define POSTSCRIPT 0 /* PostScript back end */ +#define PLAINTEXT 1 /* plain text back end */ +#define PDF 2 + +/* error types */ +#define INTERN 0 /* internal error (i.e. bug) */ +#define FATAL 1 /* fatal error, abort now */ +#define WARN 2 /* warning, non-fatal */ + +/* status values returned by AttachGalley() */ +#define ATTACH_KILLED 0 +#define ATTACH_INPUT 1 +#define ATTACH_NOTARGET 2 +#define ATTACH_SUSPEND 3 +#define ATTACH_NULL 4 +#define ATTACH_ACCEPT 5 + +/* types of memory usage, used to debug memory consumption */ +#define MEM_BINARY 0 /* the executable binary */ +#define MEM_OBJECTS 1 /* objects currently in free list */ +#define MEM_FONTS 2 /* fonts */ +#define MEM_LEX 3 /* lexical analyser file buffers */ +#define MEM_FILES 4 /* table of file names */ +#define MEM_CROSSREF 5 /* table of file names */ +#define MEM_PAGES 6 /* page grids (-p only) */ +#define MEM_DBCHECK 7 /* database checks */ +#define MEM_DB 8 /* in_memory database */ +#define MEM_HYPH_PATS 9 /* hyphenation patterns */ +#define MEM_CMAPS 10 /* character maps */ +#define MEM_COLOUR_TAB 11 /* colour table */ +#define MEM_LANG_TAB 12 /* language table */ +#define MEM_USAGE_MAX 13 /* number of memory usage types */ + +/*@::Keywords@****************************************************************/ +/* */ +/* Keywords. */ +/* */ +/*****************************************************************************/ + +#define KW_START AsciiToFull("\\Start") +#define KW_PRINT AsciiToFull("\\Print") +#define KW_OPTGALL AsciiToFull("@OptGall") +#define KW_DEF AsciiToFull("def") +#define KW_FONTDEF AsciiToFull("fontdef") +#define KW_LANGDEF AsciiToFull("langdef") +#define KW_FORCE AsciiToFull("force") +#define KW_HORIZ AsciiToFull("horizontally") +#define KW_INTO AsciiToFull("into") +#define KW_EXTEND AsciiToFull("extend") +#define KW_IMPORT AsciiToFull("import") +#define KW_EXPORT AsciiToFull("export") +#define KW_PRECEDENCE AsciiToFull("precedence") +#define KW_ASSOC AsciiToFull("associativity") +#define KW_LEFT AsciiToFull("left") +#define KW_RIGHT AsciiToFull("right") +#define KW_BODY AsciiToFull("body") +#define KW_FILTER AsciiToFull("@Filter") +#define KW_FILTERIN AsciiToFull("@FilterIn") +#define KW_FILTEROUT AsciiToFull("@FilterOut") +#define KW_FILTERERR AsciiToFull("@FilterErr") +#define KW_MACRO AsciiToFull("macro") +#define KW_NAMED AsciiToFull("named") +#define KW_COMPULSORY AsciiToFull("compulsory") +#define KW_COMMON AsciiToFull("@Common") +#define KW_RUMP AsciiToFull("@Rump") +#define KW_MELD AsciiToFull("@Meld") +#define KW_INSERT AsciiToFull("@Insert") +#define KW_ONE_OF AsciiToFull("@OneOf") +#define KW_NEXT AsciiToFull("@Next") +#define KW_PLUS AsciiToFull("@Plus") +#define KW_MINUS AsciiToFull("@Minus") +#define KW_WIDE AsciiToFull("@Wide") +#define KW_HIGH AsciiToFull("@High") +#define KW_HSHIFT AsciiToFull("@HShift") +#define KW_VSHIFT AsciiToFull("@VShift") +#define KW_ONE_COL AsciiToFull("@OneCol") +#define KW_ONE_ROW AsciiToFull("@OneRow") +#define KW_HSCALE AsciiToFull("@HScale") +#define KW_VSCALE AsciiToFull("@VScale") +#define KW_HCOVER AsciiToFull("@HCover") +#define KW_VCOVER AsciiToFull("@VCover") +#define KW_SCALE AsciiToFull("@Scale") +#define KW_KERN_SHRINK AsciiToFull("@KernShrink") +#define KW_HCONTRACT AsciiToFull("@HContract") +#define KW_VCONTRACT AsciiToFull("@VContract") +#define KW_HLIMITED AsciiToFull("@HLimited") +#define KW_VLIMITED AsciiToFull("@VLimited") +#define KW_HEXPAND AsciiToFull("@HExpand") +#define KW_VEXPAND AsciiToFull("@VExpand") +#define KW_STARTHVSPAN AsciiToFull("@StartHVSpan") +#define KW_STARTHSPAN AsciiToFull("@StartHSpan") +#define KW_STARTVSPAN AsciiToFull("@StartVSpan") +#define KW_HSPAN AsciiToFull("@HSpan") +#define KW_VSPAN AsciiToFull("@VSpan") +#define KW_PADJUST AsciiToFull("@PAdjust") +#define KW_HADJUST AsciiToFull("@HAdjust") +#define KW_VADJUST AsciiToFull("@VAdjust") +#define KW_ROTATE AsciiToFull("@Rotate") +#define KW_BACKGROUND AsciiToFull("@Background") +#define KW_INCGRAPHIC AsciiToFull("@IncludeGraphic") +#define KW_SINCGRAPHIC AsciiToFull("@SysIncludeGraphic") +#define KW_GRAPHIC AsciiToFull("@Graphic") +#define KW_PLAINGRAPHIC AsciiToFull("@PlainGraphic") +#define KW_VERBATIM AsciiToFull("@Verbatim") +#define KW_RAWVERBATIM AsciiToFull("@RawVerbatim") +#define KW_CASE AsciiToFull("@Case") +#define KW_YIELD AsciiToFull("@Yield") +#define KW_BACKEND AsciiToFull("@BackEnd") +#define KW_XCHAR AsciiToFull("@Char") +#define KW_FONT AsciiToFull("@Font") +#define KW_SPACE AsciiToFull("@Space") +#define KW_YUNIT AsciiToFull("@YUnit") +#define KW_ZUNIT AsciiToFull("@ZUnit") +#define KW_BREAK AsciiToFull("@Break") +#define KW_UNDERLINE AsciiToFull("@Underline") +#define KW_COLOUR AsciiToFull("@SetColour") +#define KW_COLOR AsciiToFull("@SetColor") +#define KW_LANGUAGE AsciiToFull("@Language") +#define KW_CURR_LANG AsciiToFull("@CurrLang") +#define KW_CURR_FAMILY AsciiToFull("@CurrFamily") +#define KW_CURR_FACE AsciiToFull("@CurrFace") +#define KW_ENV AsciiToFull("@LEnv") +#define KW_ENVA AsciiToFull("@@A") +#define KW_ENVB AsciiToFull("@@B") +#define KW_ENVC AsciiToFull("@@C") +#define KW_ENVD AsciiToFull("@@D") +#define KW_CENV AsciiToFull("@@E") +#define KW_CLOS AsciiToFull("@LClos") +#define KW_LVIS AsciiToFull("@@V") +#define KW_LUSE AsciiToFull("@LUse") +#define KW_LEO AsciiToFull("@LEO") +#define KW_OPEN AsciiToFull("@Open") +#define KW_USE AsciiToFull("@Use") +#define KW_NOT_REVEALED AsciiToFull("@NotRevealed") +#define KW_TAGGED AsciiToFull("@Tagged") +#define KW_DATABASE AsciiToFull("@Database") +#define KW_SYSDATABASE AsciiToFull("@SysDatabase") +#define KW_INCLUDE AsciiToFull("@Include") +#define KW_SYSINCLUDE AsciiToFull("@SysInclude") +#define KW_PREPEND AsciiToFull("@PrependGraphic") +#define KW_SYSPREPEND AsciiToFull("@SysPrependGraphic") +#define KW_TARGET AsciiToFull("@Target") +#define KW_FOLLOWING AsciiToFull("following") +#define KW_PRECEDING AsciiToFull("preceding") +#define KW_FOLL_OR_PREC AsciiToFull("foll_or_prec") +#define KW_NOW AsciiToFull("now") +#define KW_NULL AsciiToFull("@Null") +#define KW_PAGE_LABEL AsciiToFull("@PageLabel") +#define KW_GALLEY AsciiToFull("@Galley") +#define KW_FORCE_GALLEY AsciiToFull("@ForceGalley") +#define KW_INPUT AsciiToFull("@LInput") +#define KW_SPLIT AsciiToFull("@Split") +#define KW_TAG AsciiToFull("@Tag") +#define KW_KEY AsciiToFull("@Key") +#define KW_OPTIMIZE AsciiToFull("@Optimize") +#define KW_MERGE AsciiToFull("@Merge") +#define KW_ENCLOSE AsciiToFull("@Enclose") +#define KW_CROSS AsciiToFull("&&") +#define KW_FORCE_CROSS AsciiToFull("&&&") +#define KW_LBR AsciiToFull("{") +#define KW_RBR AsciiToFull("}") +#define KW_BEGIN AsciiToFull("@Begin") +#define KW_END AsciiToFull("@End") +#define KW_VCAT_NN AsciiToFull("//") +#define KW_VCAT_MN AsciiToFull("^//") +#define KW_VCAT_NJ AsciiToFull("/") +#define KW_VCAT_MJ AsciiToFull("^/") +#define KW_HCAT_NN AsciiToFull("||") +#define KW_HCAT_MN AsciiToFull("^||") +#define KW_HCAT_NJ AsciiToFull("|") +#define KW_HCAT_MJ AsciiToFull("^|") +#define KW_ACAT_NJ AsciiToFull("&") +#define KW_ACAT_MJ AsciiToFull("^&") +#define KW_MOMENT AsciiToFull("@Moment") +#define KW_SECOND AsciiToFull("@Second") +#define KW_MINUTE AsciiToFull("@Minute") +#define KW_HOUR AsciiToFull("@Hour") +#define KW_DAY AsciiToFull("@Day") +#define KW_MONTH AsciiToFull("@Month") +#define KW_YEAR AsciiToFull("@Year") +#define KW_CENTURY AsciiToFull("@Century") +#define KW_WEEKDAY AsciiToFull("@WeekDay") +#define KW_YEARDAY AsciiToFull("@YearDay") +#define KW_DAYLIGHTSAVING AsciiToFull("@DaylightSaving") + +/*@::GetMem(), New(), NewWord()@**********************************************/ +/* */ +/* GetMem(x, siz, pos) */ +/* New(x, typ) */ +/* NewWord(x, typ, len, pos) */ +/* */ +/* Set x to point to a new record, of appropriate length (in ALIGNs). */ +/* The New and NewWord versions initialise LIST, type and rec_size fields. */ +/* NewWord must be used for WORD and QWORD objects. */ +/* */ +/*****************************************************************************/ + +#if DEBUG_ON +#define newcount zz_newcount++ +#define freecount zz_listcount-- + +#define checknew(typ) \ +{ assert1( is_type(typ), "New: type", Image(typ) ); \ + assert( zz_lengths[typ] > 0, "New: zero length!" ); \ +} + +#define checkmem(z, typ) \ +{ if( (MemCheck != 0) && ( (POINTER) z == MemCheck) ) \ + fprintf(stderr, "%ld = New(%s)\n", (long) z, Image(type(z))); \ +} + +#else +#define newcount +#define freecount +#define checknew(typ) +#define checkmem(z, typ) +#endif + +#define GetMem(x, siz, pos) \ +{ newcount; \ + if( (zz_size=(siz)) >= MAX_OBJECT_REC ) \ + Error(1, 1, "word is too long", FATAL, pos); \ + else if( zz_free[zz_size] == nilobj ) \ + x = GetMemory(zz_size, pos); \ + else \ + { x = zz_hold = zz_free[zz_size]; \ + freecount; \ + zz_free[zz_size] = pred(zz_hold, CHILD); \ + } \ +} + +#define New(x, typ) \ +{ checknew(typ); \ + GetMem(zz_hold, zz_lengths[typ], no_fpos); \ + type(zz_hold) = typ; \ + checkmem(zz_hold, typ); \ + x = pred(zz_hold, CHILD) = succ(zz_hold, CHILD) = \ + pred(zz_hold, PARENT) = succ(zz_hold, PARENT) = zz_hold; \ +} + +#define NewWord(x, typ, len, pos) \ +{ zz_size = sizeof(struct word_type) - 4 + ((len)+1)*sizeof(FULL_CHAR); \ + /* NB the following line RESETS zz_size */ \ + GetMem(zz_hold, ceiling(zz_size, sizeof(ALIGN)), pos); \ + checkmem(zz_hold, typ); \ + rec_size(zz_hold) = zz_size; \ + type(zz_hold) = typ; \ + x = pred(zz_hold, CHILD) = succ(zz_hold, CHILD) = \ + pred(zz_hold, PARENT) = succ(zz_hold, PARENT) = zz_hold; \ +} + +/*@::PutMem(), Dispose()@*****************************************************/ +/* */ +/* PutMem(x, siz) */ +/* Dispose(x) */ +/* */ +/* Dispose x, which is of size siz. Dispose works out the size itself. */ +/* */ +/*****************************************************************************/ +#if DEBUG_ON +#define disposecount zz_disposecount++; zz_listcount++; + +#define disposecheck \ +{ assert( zz_size >= 0 && zz_size < MAX_OBJECT_REC, "Dispose: size" ); \ +} + +#define setdisposed \ +{ if( (MemCheck != 0) && ((POINTER) zz_hold == MemCheck) ) \ + fprintf(stderr, "Dispose(%ld, %s)\n", (long) zz_hold, \ + Image(type(zz_hold))); \ + type(zz_hold) = DISPOSED; \ +} + +#else +#define disposecount +#define disposecheck +#define setdisposed +#endif + +#define PutMem(x, siz) \ +{ disposecount; \ + zz_hold = (x); \ + zz_size = (siz); \ + disposecheck; \ + pred(zz_hold, CHILD) = zz_free[zz_size]; \ + zz_free[zz_size] = zz_hold; \ +} + +#define Dispose(x) \ +{ zz_hold = (x); \ + PutMem(zz_hold, is_word(type(zz_hold)) ? \ + rec_size(zz_hold) : zz_lengths[type(zz_hold)]); \ + setdisposed; \ +} + +/*@::Append(), Delete()@******************************************************/ +/* */ +/* OBJECT Append(x, y, dir) */ +/* */ +/* Return the append of lists x and y (dir is PARENT or CHILD). */ +/* */ +/*****************************************************************************/ + +#define Append(x, y, dir) \ +( zz_res = (x), zz_hold = (y), \ + zz_hold == nilobj ? zz_res : \ + zz_res == nilobj ? zz_hold : \ + ( zz_tmp = pred(zz_hold, dir), \ + pred(zz_hold, dir) = pred(zz_res, dir), \ + succ(pred(zz_res, dir), dir) = zz_hold, \ + pred(zz_res, dir) = zz_tmp, \ + succ(zz_tmp, dir) = zz_res \ + ) \ +) + + +/*****************************************************************************/ +/* */ +/* OBJECT Delete(x, dir) */ +/* */ +/* Delete x from its dir list, and return succ(x, dir) or nilobj if none. */ +/* */ +/*****************************************************************************/ + +#define Delete(x, dir) \ +( zz_hold = (x), \ + succ(zz_hold, dir) == zz_hold ? nilobj : \ + ( zz_res = succ(zz_hold, dir), \ + pred(zz_res, dir) = pred(zz_hold, dir), \ + succ(pred(zz_hold, dir), dir) = zz_res, \ + pred(zz_hold, dir) = succ(zz_hold, dir) = zz_hold, \ + zz_res \ + ) \ +) + +#define Down(x) succ(x, CHILD) +#define NextDown(x) succ(x, CHILD) +#define LastDown(x) pred(x, CHILD) +#define PrevDown(x) pred(x, CHILD) +#define Up(x) succ(x, PARENT) +#define NextUp(x) succ(x, PARENT) +#define LastUp(x) pred(x, PARENT) +#define PrevUp(x) pred(x, PARENT) + +#define Child(y, link) \ +for( y = pred(link, PARENT); type(y) == LINK; y = pred(y, PARENT) ) + +#define CountChild(y, link, i) \ +for( y=pred(link, PARENT), i=1; type(y)==LINK; y = pred(y, PARENT), i++ ) + +#define Parent(y, link) \ +for( y = pred(link, CHILD); type(y) == LINK; y = pred(y, CHILD) ) + + +/*@::UpDim(), DownDim(), Link(), DeleteLink(), etc.@**************************/ +/* */ +/* UpDim(x, dim) */ +/* DownDim(x, dim) */ +/* */ +/* Returns the dim child or parent link of node x (dim == COLM or ROWM). */ +/* */ +/*****************************************************************************/ + +#define UpDim(x, dim) ( (dim) == COLM ? succ(x, PARENT) : pred(x, PARENT) ) +#define DownDim(x, dim) ( (dim) == COLM ? succ(x, CHILD) : pred(x, CHILD) ) + + +/*****************************************************************************/ +/* */ +/* OBJECT Link(x, y) */ +/* */ +/* Make y a child of x in the directed graph, using a new link. */ +/* The link node is returned. */ +/* */ +/*****************************************************************************/ + +#define Link(x, y) \ +{ New(xx_link, LINK); \ + Append(xx_link, (x), CHILD); \ + Append(xx_link, (y), PARENT); \ +} + + +/*****************************************************************************/ +/* */ +/* DeleteLink(link) */ +/* */ +/* Cut the link between nodes x and y of the directed graph. */ +/* Returns the link node of the next child of x, or x if none. */ +/* */ +/*****************************************************************************/ + +#define DeleteLink(link) \ +{ xx_link = (link); \ + Delete(xx_link, PARENT); \ + Delete(xx_link, CHILD); \ + Dispose(xx_link); \ +} + + +/*****************************************************************************/ +/* */ +/* DisposeChild(link) */ +/* */ +/* Delete link, and if its child is thereby unattached, dispose it. */ +/* */ +/*****************************************************************************/ + +#define DisposeChild(link) \ +{ xx_link = (link); \ + xx_tmp = Delete(xx_link, PARENT); \ + Delete(xx_link, CHILD); \ + Dispose(xx_link); \ + if( succ(xx_tmp, PARENT) == xx_tmp ) DisposeObject(xx_tmp); \ +} /* end DisposeChild */ + + +/*****************************************************************************/ +/* */ +/* MoveLink(link, x, dir) */ +/* */ +/* Move the dir end of link from wherever it is now to node x. */ +/* */ +/*****************************************************************************/ + +#define MoveLink(link, x, dir) \ +( xx_link = (link), \ + Delete(xx_link, 1 - (dir) ), \ + Append(xx_link, (x), 1 - (dir) ) \ +) /* end MoveLink */ + + +/*@::TransferLinks(), DeleteNode(), etc.@*************************************/ +/* */ +/* TransferLinks(start_link, stop_link, dest_link) */ +/* */ +/* Move parent end of links start_link (inclusive) to stop_link (exclusive) */ +/* to just before dest_link. */ +/* */ +/*****************************************************************************/ + +#define TransferLinks(start_link, stop_link, dest_link) \ +{ OBJECT xxstart = start_link, xxstop = stop_link, xxdest = dest_link; \ + if( xxstart != xxstop ) \ + { assert( type(xxstart) == LINK, "TransferLinks: start_link!" ); \ + Append(xxstart, xxstop, CHILD); /* actually a split */ \ + Append(xxstart, xxdest, CHILD); \ + } \ +} + + +/*****************************************************************************/ +/* */ +/* DeleteNode(x) */ +/* */ +/* Delete node x and every edge attaching to x. */ +/* */ +/*****************************************************************************/ + +#define DeleteNode(x) \ +{ xx_hold = (x); \ + while( Up(xx_hold) != xx_hold ) DeleteLink( Up(xx_hold) ); \ + while( Down(xx_hold) != xx_hold ) DeleteLink( Down(xx_hold) ); \ + Dispose(xx_hold); \ +} + + +/*****************************************************************************/ +/* */ +/* MergeNode(x, y) */ +/* */ +/* Take all the children of y and make them children of x. */ +/* Take all the parents of y and make them parents of x. Dispose y. */ +/* */ +/*****************************************************************************/ + +#define MergeNode(x, y) \ +{ xx_res = (x); xx_hold = (y); \ + xx_tmp = Delete(xx_hold, PARENT); \ + Append(xx_res, xx_tmp, PARENT); \ + xx_tmp = Delete(xx_hold, CHILD); \ + Append(xx_res, xx_tmp, CHILD); \ + Dispose(xx_hold); \ +} /* end MergeNode */ + + +/*****************************************************************************/ +/* */ +/* ReplaceNode(x, y) */ +/* */ +/* Move all the parent links of y to x. */ +/* */ +/*****************************************************************************/ + +#define ReplaceNode(x, y) \ +( xx_tmp = Delete((y), PARENT), \ + Append((x), xx_tmp, PARENT) \ +) /* end ReplaceNode */ + + +/*@::FirstDefinite(), NextDefinite(), etc.@***********************************/ +/* */ +/* FirstDefinite(x, link, y, jn) */ +/* */ +/* On input, x is an object and link and y are undefined. On output there */ +/* are two cases: */ +/* */ +/* link != x. Then y is first definite child of x and link is its link; */ +/* jn is TRUE iff all gaps on the way to link were joined. */ +/* */ +/* link == x. Then x has no definite child and y is undefined. */ +/* */ +/* A SPLIT object is considered to be definite if both its children are */ +/* definite. This condition is returned by SplitIsDefinite. */ +/* */ +/*****************************************************************************/ + +#define FirstDefinite(x, link, y, jn) \ +{ jn = TRUE; \ + for( link = Down(x); link != x; link = NextDown(link) ) \ + { Child(y, link); \ + if( type(y) == GAP_OBJ ) jn = jn && join(gap(y)); \ + else if( type(y)==SPLIT ? SplitIsDefinite(y) : is_definite(type(y)))\ + break; \ + } \ +} /* end FirstDefinite */ + + +/*****************************************************************************/ +/* */ +/* NextDefinite(x, link, y) */ +/* */ +/* On input, x is an object and link is a link to one of its children; y */ +/* is undefined. On output there are two cases: */ +/* */ +/* link != x. Then y is the first definite child of x following link, and */ +/* link is changed to be the link of y. */ +/* */ +/* link == x. Then x has no definite child following link, and y remains */ +/* undefined. */ +/* */ +/*****************************************************************************/ + +#define NextDefinite(x, link, y) \ +{ for( link = NextDown(link); link != x; link = NextDown(link) ) \ + { Child(y, link); \ + if( type(y) == SPLIT ? SplitIsDefinite(y) : is_definite(type(y)) ) \ + break; \ + } \ +} /* end NextDefinite */ + + +/*****************************************************************************/ +/* */ +/* NextDefiniteWithGap(x, link, y, g, jn) */ +/* */ +/* On input, x is an object and link is a link to one of its children; y */ +/* and g are undefined. On output there are two cases: */ +/* */ +/* link != x. Then y is the first definite child of x following link, and */ +/* link is changed to be the link of y. Also, g is defined */ +/* to be the gap just before y; this must exist and is tested */ +/* by an assert test; and jn is true iff all of the gaps on */ +/* the way from old link to new link are join gaps. */ +/* */ +/* link == x. Then x has no definite child following link, and y and g */ +/* remain undefined. */ +/* */ +/*****************************************************************************/ + +#define NextDefiniteWithGap(x, link, y, g, jn) \ +{ g = nilobj; jn = TRUE; \ + for( link = NextDown(link); link != x; link = NextDown(link) ) \ + { Child(y, link); \ + if( type(y) == GAP_OBJ ) g = y, jn = jn && join(gap(y)); \ + else if( type(y)==SPLIT ? SplitIsDefinite(y):is_definite(type(y)) ) \ + { \ + debug2(DFS, D, " NextDefiniteWithGap at %s %s", \ + Image(type(y)), EchoObject(y)); \ + assert( g != nilobj, "NextDefiniteWithGap: g == nilobj!" ); \ + break; \ + } \ + } \ +} /* end NextDefiniteWithGap */ + +/*@@**************************************************************************/ +/* */ +/* LastDefinite(x, link, y) */ +/* */ +/* On input, x is an object and link and y are undefined. On output there */ +/* are two cases: */ +/* */ +/* link != x. Then y is the last definite child of x and link is its link. */ +/* */ +/* link == x. Then x has no definite child and y is undefined. */ +/* */ +/* A SPLIT object is considered to be definite if both its children are */ +/* definite. This condition is returned by SplitIsDefinite. */ +/* */ +/*****************************************************************************/ + +#define LastDefinite(x, link, y) \ +{ for( link = LastDown(x); link != x; link = PrevDown(link) ) \ + { Child(y, link); \ + if( type(y) == SPLIT ? SplitIsDefinite(y) : is_definite(type(y)) ) \ + break; \ + } \ +} /* end LastDefinite */ + + +/*****************************************************************************/ +/* */ +/* PrevDefinite(x, link, y) */ +/* */ +/* On input, x is an object and link is a link to one of its children; y */ +/* is undefined. On output there are two cases: */ +/* */ +/* link != x. Then y is the first definite child of x preceding link, and */ +/* link is changed to be the link of y. */ +/* */ +/* link == x. Then x has no definite child preceding link, and y remains */ +/* undefined. */ +/* */ +/*****************************************************************************/ + +#define PrevDefinite(x, link, y) \ +{ for( link = PrevDown(link); link != x; link = PrevDown(link) ) \ + { Child(y, link); \ + if( type(y) == SPLIT ? SplitIsDefinite(y) : is_definite(type(y)) ) \ + break; \ + } \ +} /* end PrevDefinite */ + + +/*@::Module Declarations@*****************************************************/ +/* */ +/* MODULE DECLARATIONS */ +/* */ +/*****************************************************************************/ + +/***** z01.c Supervise **************************************/ +extern int main(int argc, char *argv[]); +extern POINTER MemCheck; +extern OBJECT StartSym; +extern OBJECT GalleySym; +extern OBJECT ForceGalleySym; +extern OBJECT InputSym; +extern OBJECT PrintSym; +extern OBJECT FilterInSym; +extern OBJECT FilterOutSym; +extern OBJECT FilterErrSym; +extern OBJECT VerbatimSym; +extern OBJECT RawVerbatimSym; +extern OBJECT OptGallSym; +extern OBJECT CommandOptions; +extern BOOLEAN AllowCrossDb; +extern BOOLEAN UseCollate; +extern BOOLEAN InMemoryDbIndexes; +extern BOOLEAN Encapsulated; +extern BOOLEAN Kern; +extern BOOLEAN SafeExecution; +extern BOOLEAN AltErrorFormat; +extern int BackEnd; +extern int TotalWordCount; +extern FULL_CHAR *BackEndWord; +extern FULL_LENGTH PlainCharWidth; +extern FULL_LENGTH PlainCharHeight; +extern BOOLEAN PlainFormFeed; +extern BOOLEAN InitializeAll; +#if LOCALE_ON +extern nl_catd MsgCat; +#endif + +/***** z02.c Lexical Analyser **************************************/ +extern BOOLEAN LexLegalName(FULL_CHAR *str); +extern void LexInit(void); +extern void LexPush(FILE_NUM x, int offs, int ftyp, int lnum, BOOLEAN same); +extern void LexPop(void); +extern long LexNextTokenPos(void); +extern OBJECT LexGetToken(void); +extern OBJECT LexScanVerbatim(FILE *fp, BOOLEAN end_stop, FILE_POS *err_pos, + BOOLEAN lessskip); + +/***** z03.c File Service **************************************/ +extern FILE_POS *no_fpos; +extern void InitFiles(void); +extern void AddToPath(int fpath, OBJECT dirname); +extern FILE_NUM DefineFile(FULL_CHAR *str, FULL_CHAR *suffix, + FILE_POS *xfpos, int ftype, int fpath); +extern FILE_NUM FirstFile(int ftype); +extern FILE_NUM NextFile(FILE_NUM i); +extern FILE_NUM FileNum(FULL_CHAR *str, FULL_CHAR *suffix); +extern FILE_NUM DatabaseFileNum(FILE_POS *xfpos); +extern FULL_CHAR *FileName(FILE_NUM fnum); +extern FULL_CHAR *FullFileName(FILE_NUM fnum); +extern FULL_CHAR *EchoFilePos(FILE_POS *pos); +extern FULL_CHAR *EchoAltFilePos(FILE_POS *pos); +extern FULL_CHAR *EchoFileSource(FILE_NUM fnum); +extern FULL_CHAR *EchoFileLine(FILE_POS *pos); +extern FILE_POS *PosOfFile(FILE_NUM fnum); +extern FILE *OpenFile(FILE_NUM fnum, BOOLEAN check_ld, BOOLEAN check_lt); +extern FILE *OpenIncGraphicFile(FULL_CHAR *str, unsigned char typ, + OBJECT *full_name, FILE_POS *xfpos, BOOLEAN *compressed); +extern void FileSetUpdated(FILE_NUM fnum, int newlines); +extern int FileGetLineCount(FILE_NUM fnum); +extern BOOLEAN FileTestUpdated(FILE_NUM fnum); + +/***** z04.c Token Service **************************************/ +extern OBJECT NewToken(unsigned char xtype, FILE_POS *xfpos, + unsigned char xvspace, unsigned char xhspace, + unsigned char xprec, OBJECT xactual); +extern OBJECT CopyTokenList(OBJECT x, FILE_POS *pos); +extern FULL_CHAR *EchoCatOp(unsigned xtype, BOOLEAN xmark, BOOLEAN xjoin); +extern FULL_CHAR *EchoToken(OBJECT x); + +/***** z05.c Read Definitions **************************************/ +extern void ReadPrependDef(unsigned typ, OBJECT encl); +extern void ReadDatabaseDef(unsigned typ, OBJECT encl); +extern void ReadDefinitions(OBJECT *token, OBJECT encl, + unsigned char res_type); + +/***** z06.c Object Parser **************************************/ +extern void SetScope(OBJECT env, int *count, BOOLEAN vis_only); +extern void InitParser(FULL_CHAR *cross_db); +extern OBJECT Parse(OBJECT *token, OBJECT encl, BOOLEAN defs_allowed, + BOOLEAN transfer_allowed); + +/***** z07.c Object Service **************************************/ +extern BOOLEAN SplitIsDefinite(OBJECT x); +extern int DisposeObject(OBJECT x); +extern OBJECT MakeWord(unsigned typ, FULL_CHAR *str, FILE_POS *pos); +extern OBJECT MakeWordTwo(unsigned typ, FULL_CHAR *str1, FULL_CHAR *str2, + FILE_POS *pos); +extern OBJECT MakeWordThree(FULL_CHAR *s1, FULL_CHAR *s2, FULL_CHAR *s3); +extern OBJECT CopyObject(OBJECT x, FILE_POS *pos); +extern OBJECT InsertObject(OBJECT x, OBJECT *ins, STYLE *style); +extern OBJECT Meld(OBJECT x, OBJECT y); + +/***** z08.c Object Manifest **************************************/ +extern OBJECT ReplaceWithTidy(OBJECT x, BOOLEAN one_word); +extern OBJECT Manifest(OBJECT x, OBJECT env, STYLE *style, OBJECT bthr[2], + OBJECT fthr[2], OBJECT *target, OBJECT *crs, BOOLEAN ok, + BOOLEAN need_expand, OBJECT *enclose, BOOLEAN fcr); + +/***** z09.c Closure Expansion **************************************/ +extern OBJECT SearchEnv(OBJECT env, OBJECT sym); +extern OBJECT SetEnv(OBJECT x, OBJECT y); +extern void AttachEnv(OBJECT env, OBJECT x); +extern OBJECT GetEnv(OBJECT x); +extern OBJECT DetachEnv(OBJECT x); +extern OBJECT ClosureExpand(OBJECT x, OBJECT env, BOOLEAN crs_wanted, + OBJECT *crs, OBJECT *res_env); +extern OBJECT ParameterCheck(OBJECT x, OBJECT env); + +/***** z10.c Cross References **************************************/ +extern void CrossInit(OBJECT sym); +extern OBJECT CrossMake(OBJECT sym, OBJECT val, int ctype); +extern OBJECT GallTargEval(OBJECT sym, FILE_POS *dfpos); +extern void CrossAddTag(OBJECT x); +extern OBJECT CrossExpand(OBJECT x, OBJECT env, STYLE *style, + OBJECT *crs, OBJECT *res_env); +extern void CrossSequence(OBJECT x); +extern void CrossClose(void); + +/***** z11.c Style Service **************************************/ +extern FULL_CHAR *EchoStyle(STYLE *style); +extern void SpaceChange(STYLE *style, OBJECT x); +extern void BreakChange(STYLE *style, OBJECT x); +extern void YUnitChange(STYLE *style, OBJECT x); +extern void ZUnitChange(STYLE *style, OBJECT x); + +/***** z12.c Size Finder **************************************/ +extern void SpannerAvailableSpace(OBJECT y, int dim, FULL_LENGTH *resb, + FULL_LENGTH *resf); +extern OBJECT MinSize(OBJECT x, int dim, OBJECT *extras); + +/***** z13.c Object Breaking **************************************/ +extern OBJECT BreakObject(OBJECT x, CONSTRAINT *c); + +/***** z14.c Object Filling **************************************/ +extern OBJECT FillObject(OBJECT x, CONSTRAINT *c, OBJECT multi, + BOOLEAN can_hyphenate, BOOLEAN allow_shrink, + BOOLEAN extend_unbreakable, BOOLEAN *hyph_used); + +/***** z15.c Size Constraints **************************************/ +extern void MinConstraint(CONSTRAINT *xc, CONSTRAINT *yc); +extern void SetSizeToMaxForwardConstraint(FULL_LENGTH *b, FULL_LENGTH *f, + CONSTRAINT *c); +extern void EnlargeToConstraint(FULL_LENGTH *b, FULL_LENGTH *f, + CONSTRAINT *c); +extern int ScaleToConstraint(FULL_LENGTH b, FULL_LENGTH f, + CONSTRAINT *c); +extern void InvScaleConstraint(CONSTRAINT *yc, FULL_LENGTH sf, + CONSTRAINT*xc); +extern void RotateConstraint(CONSTRAINT *c, OBJECT y, FULL_LENGTH angle, + CONSTRAINT *hc, CONSTRAINT *vc, int dim); +extern BOOLEAN InsertScale(OBJECT x, CONSTRAINT *c); +extern void Constrained(OBJECT x, CONSTRAINT *xc, int dim, OBJECT *why); +extern FULL_CHAR *EchoConstraint(CONSTRAINT *c); +extern void DebugConstrained(OBJECT x); + +/***** z16.c Size Adjustments **************************************/ +extern FULL_LENGTH FindShift(OBJECT x, OBJECT y, int dim); +extern void SetNeighbours(OBJECT link, BOOLEAN ratm, OBJECT *pg, + OBJECT *pdef, OBJECT *sg, OBJECT *sdef, int *side); +extern void AdjustSize(OBJECT x, FULL_LENGTH b, FULL_LENGTH f, int dim); + +/***** z17.c Gap Widths **************************************/ +extern void GetGap(OBJECT x, STYLE *style, GAP *res_gap, + unsigned *res_inc); +extern FULL_LENGTH MinGap(FULL_LENGTH a, FULL_LENGTH b, FULL_LENGTH c, GAP *xgap); +extern FULL_LENGTH ExtraGap(FULL_LENGTH a, FULL_LENGTH b, GAP *xgap, int dir); +extern FULL_LENGTH ActualGap(FULL_LENGTH a, FULL_LENGTH b, FULL_LENGTH c, + GAP *xgap, FULL_LENGTH f, FULL_LENGTH mk); +extern FULL_CHAR *EchoGap(GAP *xgap); + +/***** z18.c Galley Transfer **************************************/ +extern STYLE InitialStyle; +extern OBJECT InitialEnvironment; +extern void TransferInit(OBJECT InitEnv); +extern OBJECT TransferBegin(OBJECT x); +extern void TransferComponent(OBJECT x); +extern void TransferEnd(OBJECT x); +extern void TransferClose(void); + +/***** z19.c Galley Attaching **************************************/ +extern void DetachGalley(OBJECT hd); +extern OBJECT SearchGalley(OBJECT start, OBJECT sym, BOOLEAN forwards, + BOOLEAN subgalleys, BOOLEAN closures, BOOLEAN input); +extern int AttachGalley(OBJECT hd, OBJECT *inners, OBJECT *suspend_pt); + +/***** z20.c Galley Flushing **************************************/ +extern FULL_CHAR *DebugInnersNames(OBJECT inners); +extern void FlushGalley(OBJECT hd); + +/*** z21.c Galley Maker **************************************/ +extern void SizeGalley(OBJECT hd, OBJECT env, BOOLEAN rows, + BOOLEAN joined, BOOLEAN nonblock, BOOLEAN trig, + STYLE *style, CONSTRAINT *c, OBJECT target, + OBJECT *dest_index, OBJECT *recs, OBJECT *inners, + OBJECT enclose); + +/*** z22.c Galley Service **************************************/ +extern void Interpose(OBJECT z, int typ, OBJECT x, OBJECT y); +extern void FlushInners(OBJECT inners, OBJECT hd); +extern void ExpandRecursives(OBJECT recs); +extern void Promote(OBJECT hd, OBJECT stop_link, OBJECT dest_index, + BOOLEAN join_after); +extern void KillGalley(OBJECT hd, BOOLEAN optimize); +extern void FreeGalley(OBJECT hd, OBJECT stop_link, OBJECT *inners, + OBJECT relocate_link, OBJECT sym); +extern void SetTarget(OBJECT hd); +extern int CheckComponentOrder(OBJECT preceder, OBJECT follower); + +/***** z23.c Galley Printer **************************************/ +extern void FixAndPrintObject(OBJECT x, FULL_LENGTH xmk, FULL_LENGTH xb, + FULL_LENGTH xf, int dim, BOOLEAN suppress, FULL_LENGTH pg,int count); + +/***** z24.c Print Service **************************************/ +extern void PrintInit(FILE *file_ptr); +extern void PrintBeforeFirst(FULL_LENGTH h, FULL_LENGTH v, FULL_CHAR *label); +extern void PrintBetween(FULL_LENGTH h, FULL_LENGTH v, FULL_CHAR *label); +extern void PrintWord(OBJECT x, int hpos, int vpos); +extern void PrintPlainGraphicObject(OBJECT x, FULL_LENGTH xmk, + FULL_LENGTH ymk, OBJECT z); +extern void PrintUnderline(FONT_NUM fnum, FULL_LENGTH xstart, + FULL_LENGTH xstop, FULL_LENGTH ymk); +extern void PrintAfterLast(void); +extern void CoordTranslate(FULL_LENGTH xdist, FULL_LENGTH ydist); +extern void CoordRotate(FULL_LENGTH amount); +extern void CoordScale(float hfactor, float vfactor); +extern void SaveGraphicState(OBJECT x); +extern void RestoreGraphicState(void); +extern void PrintGraphicObject(OBJECT x); +extern void DefineGraphicNames(OBJECT x); +extern void SaveTranslateDefineSave(OBJECT x, + FULL_LENGTH xdist, FULL_LENGTH ydist); +extern void PrintGraphicInclude(OBJECT x, FULL_LENGTH colmark, + FULL_LENGTH rowmark); + +/***** z25.c Object Echo **************************************/ +extern FULL_CHAR *EchoObject(OBJECT x); +extern void DebugObject(OBJECT x); +extern FULL_CHAR *EchoIndex(OBJECT index); +extern void DebugGalley(OBJECT hd, OBJECT pinpt, int indent); + +/***** z26.c Echo Service **************************************/ +extern void BeginString(void); +extern void AppendString(FULL_CHAR *str); +extern FULL_CHAR *EndString(void); +extern FULL_CHAR *EchoLength(int len); +extern FULL_CHAR *Image(unsigned int c); +extern void SetLengthDim(int dim); + +/***** z27.c Debug Service **************************************/ +#if DEBUG_ON +extern void DebugInit(FULL_CHAR *str); +extern void Debug(int category, int urgency, char *str, ...); +extern void ProfileOn(char *str); +extern void ProfileOff(char *str); +extern void ProfilePrint(void); +#endif + +/***** z28.c Error Service **************************************/ +extern void ErrorInit(FULL_CHAR *str); +extern BOOLEAN ErrorSeen(void); +extern void EnterErrorBlock(BOOLEAN ok_to_print); +extern void LeaveErrorBlock(BOOLEAN commit); +extern void CheckErrorBlocks(void); +extern POINTER Error(int set_num, int msg_num, char *str, int etype, + FILE_POS *pos, ...); + +/***** z29.c Symbol Table **************************************/ +extern void InitSym(void); +extern void PushScope(OBJECT x, BOOLEAN npars, BOOLEAN vis); +extern void PopScope(void); +extern void SuppressVisible(void); +extern void UnSuppressVisible(void); +extern void SuppressScope(void); +extern void UnSuppressScope(void); +extern void SwitchScope(OBJECT sym); +extern void UnSwitchScope(OBJECT sym); +extern void BodyParAllowed(void); +extern void BodyParNotAllowed(void); +extern OBJECT InsertSym(FULL_CHAR *str, unsigned char xtype, + FILE_POS *xfpos, unsigned char xprecedence, + BOOLEAN xindefinite, BOOLEAN xrecursive, + unsigned xpredefined, OBJECT xenclosing, OBJECT xbody); +extern void InsertAlternativeName(FULL_CHAR *str, OBJECT s, + FILE_POS *xfpos); +extern OBJECT SearchSym(FULL_CHAR *str, int len); +extern FULL_CHAR *SymName(OBJECT s); +extern FULL_CHAR *FullSymName(OBJECT x, FULL_CHAR *str); +extern OBJECT ChildSym(OBJECT s, unsigned typ); +extern OBJECT ChildSymWithCode(OBJECT s, unsigned char code); +extern void CheckSymSpread(void); +extern void DeleteEverySym(void); +extern void DebugScope(void); + +/***** z30.c Symbol Uses **************************************/ +extern void InsertUses(OBJECT x, OBJECT y); +extern void FlattenUses(void); +extern BOOLEAN SearchUses(OBJECT x, OBJECT y); +extern OBJECT FirstExternTarget(OBJECT sym, OBJECT *cont); +extern OBJECT NextExternTarget(OBJECT sym, OBJECT *cont); + +/***** z31.c Memory Allocator **************************************/ +extern void DebugRegisterUsage(int typ, int delta_num, int delta_size); +extern void DebugMemory(void); +extern void MemInit(void); +extern OBJECT GetMemory(int siz, FILE_POS *pos); +extern OBJECT zz_free[]; +extern unsigned char zz_lengths[]; +extern int zz_newcount; +extern int zz_disposecount; +extern int zz_listcount; +extern OBJECT zz_hold; +extern OBJECT zz_tmp; +extern OBJECT zz_res; +extern int zz_size; +extern OBJECT xx_link, xx_tmp; +extern OBJECT xx_hold, xx_res; + +/***** z32.c Counter Service **********************************/ +extern OBJECT Next(OBJECT x, int inc, BOOLEAN *done); + +/***** z33.c Database Service **************************************/ +extern OBJECT OldCrossDb; +extern OBJECT NewCrossDb; +extern OBJECT DbCreate(OBJECT x); +extern void DbInsert(OBJECT db, BOOLEAN gall, OBJECT sym, FULL_CHAR *tag, + FILE_POS *tagfpos, FULL_CHAR *seq, FILE_NUM dfnum, + long dfpos, int dlnum, BOOLEAN check); +extern void DbConvert(OBJECT db, BOOLEAN full_name); +extern void DbClose(OBJECT db); +extern OBJECT DbLoad(OBJECT stem, int fpath, BOOLEAN create, OBJECT symbs, + BOOLEAN in_memory); +extern BOOLEAN DbRetrieve(OBJECT db, BOOLEAN gall, OBJECT sym, + FULL_CHAR *tag, FULL_CHAR *seq, FILE_NUM *dfnum, + long *dfpos, int *dlnum, long *cont); +extern BOOLEAN DbRetrieveNext(OBJECT db, BOOLEAN *gall, OBJECT *sym, + FULL_CHAR *tag, FULL_CHAR *seq, FILE_NUM *dfnum, + long *dfpos, int *dlnum, long *cont); + +/***** z34.c Rotation Service **************************************/ +extern void RotateSize(FULL_LENGTH *xcb, FULL_LENGTH *xcf, + FULL_LENGTH *xrb, FULL_LENGTH *xrf, OBJECT y, + FULL_LENGTH theta); + +/***** z35.c Time Keeper **************************************/ +extern FULL_CHAR *TimeString(void); +extern void InitTime(void); +extern OBJECT MomentSym; +extern OBJECT StartMoment(void); + +/***** z36.c Hyphenation **************************************/ +extern BOOLEAN ReadHyphTable(LANGUAGE_NUM lnum); +extern OBJECT Hyphenate(OBJECT x); + +/***** z37.c Font Service *************************************/ +extern FONT_INFO *finfo; +extern int font_curr_page; +extern void FontInit(void); +extern void FontDefine(OBJECT family, OBJECT face, OBJECT inside); +extern void FontChange(STYLE *style, OBJECT x); +extern void FontWordSize(OBJECT x); +extern FULL_LENGTH FontSize(FONT_NUM fnum, OBJECT x); +extern FULL_LENGTH FontHalfXHeight(FONT_NUM fnum); +extern MAPPING FontMapping(FONT_NUM fnum, FILE_POS *xfpos); +extern FULL_CHAR *FontName(FONT_NUM fnum); +extern FULL_CHAR *FontFamily(FONT_NUM fnum); +extern FULL_CHAR *FontFace(FONT_NUM fnum); +extern FULL_CHAR *FontFamilyAndFace(FONT_NUM fnum); +extern void FontPrintAll(FILE *fp); +extern void FontPrintPageSetup(FILE *fp); +extern void FontPrintPageResources(FILE *fp); +extern void FontAdvanceCurrentPage(void); +extern void FontPageUsed(OBJECT face); +extern BOOLEAN FontNeeded(FILE *fp); + +/***** z38.c Character Mappings **************************************/ +extern MAP_VEC MapTable[]; +extern MAPPING MapLoad(OBJECT filename, BOOLEAN must_print); +extern FULL_CHAR MapCharEncoding(FULL_CHAR *str, MAPPING m); +extern FULL_CHAR *MapEncodingName(MAPPING m); +extern void MapPrintEncodings(FILE *fp); +extern void MapPrintResources(FILE *fp); +extern OBJECT MapSmallCaps(OBJECT x, STYLE *style); +extern BOOLEAN MapIsLowerCase(FULL_CHAR ch, MAPPING m); + + +/***** z39.c String Handler **************************************/ +#define AsciiToFull(x) ( (FULL_CHAR *) (x) ) +#define StringEqual(a, b) (strcmp((char *)(a), (char *)(b))==0) +extern int strcollcmp(char *a, char *b); +#define StringLessEqual(a, b) \ + ( UseCollate ? strcollcmp((char *)(a),(char *)(b)) <= 0 \ + : strcmp((char *)(a),(char *)(b)) <= 0 ) +#define StringCat(a, b) strcat((char *)(a),(char *)(b)) +#define StringCopy(a, b) strcpy((char *)(a),(char *)(b)) +#define StringLength(a) strlen((char *)(a)) +#define StringFOpen(a, b) fopen( (char *) (a), (b) ) +#define StringFPuts(a, b) fputs( (char *) (a), (b) ) +#define StringFGets(a, b, c) fgets( (char *) (a), (b), (c) ) +#define StringRemove(a) remove((char *)(a)) +#define StringRename(a, b) rename((char *)(a),(char *)(b)) +extern BOOLEAN StringBeginsWith(FULL_CHAR *str, FULL_CHAR *pattern); +extern BOOLEAN StringEndsWith(FULL_CHAR *str, FULL_CHAR *pattern); +extern BOOLEAN StringContains(FULL_CHAR *str, FULL_CHAR *pattern); +extern FULL_CHAR *StringInt(int i); +extern FULL_CHAR *StringFiveInt(int i); +extern FULL_CHAR *StringQuotedWord(OBJECT x); + +/***** z40.c Filter Handler **************************************/ +extern void FilterInit(void); +extern OBJECT FilterCreate(BOOLEAN use_begin, OBJECT act, FILE_POS *xfpos); +extern void FilterSetFileNames(OBJECT x); +extern OBJECT FilterExecute(OBJECT x, FULL_CHAR *command, OBJECT env); +extern void FilterWrite(OBJECT x, FILE *fp, int *linecount); +extern void FilterScavenge(BOOLEAN all); + +/***** z41.c Object Input-Output **************************************/ +extern OBJECT ReadFromFile(FILE_NUM fnum, long pos, int lnum); +extern void AppendToFile(OBJECT x, FILE_NUM fnum, int *pos, int *lnum); +extern void CloseFiles(void); + +/***** z42.c Colour Service **************************************/ +extern void ColourInit(void); +extern void ColourChange(STYLE *style, OBJECT x); +extern FULL_CHAR *ColourCommand(COLOUR_NUM cnum); + +/***** z43.c Language Service **************************************/ +extern void LanguageInit(void); +extern BOOLEAN LanguageWordEndsSentence(OBJECT wd, BOOLEAN lc_prec); +extern void LanguageDefine(OBJECT names, OBJECT hyph_file); +extern void LanguageChange(STYLE *style, OBJECT x); +extern FULL_CHAR *LanguageString(LANGUAGE_NUM lnum); +extern OBJECT LanguageHyph(LANGUAGE_NUM lnum); +extern BOOLEAN LanguageSentenceEnds[]; + +/***** z44.c Vertical Hyphenation **************************************/ +extern BOOLEAN VerticalHyphenate(OBJECT y); +extern OBJECT ConvertGalleyList(OBJECT x); +extern OBJECT BuildEnclose(OBJECT hd); + +/***** z45.c External Sort **************************************/ +extern LINE *ReadLines(FILE *fp, FULL_CHAR *fname, FULL_CHAR *first_line, int *len); +extern void WriteLines(FILE *fp, LINE *lines, int len); +extern void SortLines(LINE *lines, int lines_len); +extern void SortFile(FULL_CHAR *infile, FULL_CHAR *outfile); + +/***** z46.c Optimal Galleys **************************************/ +extern BOOLEAN FindOptimize(OBJECT x, OBJECT env); +extern void SetOptimize(OBJECT hd, STYLE *style); +extern void GazumpOptimize(OBJECT hd, OBJECT dest); +extern void CalculateOptimize(OBJECT hd); +extern void DebugOptimize(OBJECT hd); + +/***** z47.c Environment Table **************************************/ +extern void EnvInit(void); +extern BOOLEAN EnvWriteRetrieve(OBJECT env, FILE_NUM fnum, int *offset, + int *lnum); +extern void EnvWriteInsert(OBJECT env, FILE_NUM fnum, int offset,int lnum); +extern BOOLEAN EnvReadRetrieve(FILE_NUM fnum, int offset, OBJECT *env); +extern void EnvReadInsert(FILE_NUM fnum, int offset, OBJECT env); +extern void EnvDebug(void); + +/***** z48.c PDF back end **************************************/ +extern void PDFFile_Init(FILE* in_fp, int in_h_bound, int in_v_bound, + int in_IN, int in_CM, int in_PT, int in_EM); +extern void PDFFile_BeginFontEncoding(FILE* in_fp, + const char* in_encoding_name); +extern void PDFFile_EndFontEncoding(FILE* in_fp); +extern void PDFFile_Cleanup(FILE* in_fp); +extern void PDFPage_Init(FILE* in_fp, float in_scale_factor, + int in_line_width); +extern void PDFPage_Cleanup(FILE* in_fp); +extern void PDFPage_Write(FILE* in_fp, char* in_str); +extern void PDFPage_Push(FILE* in_fp); +extern void PDFPage_Pop(FILE* in_fp); +extern void PDFPage_Scale(FILE* in_fp, float in_h_scale_factor, + float in_v_scale_factor); +extern void PDFPage_Translate(FILE* in_fp, float in_delta_h, + float in_delta_v); +extern void PDFPage_Rotate(FILE* in_fp, float in_angle_in_radians); +extern void PDFPage_SetVars(int xsize, int ysize, int xmark, int ymark, + int loutf, int loutv, int louts); +extern void PDFPage_WriteGraphic(FILE* in_fp, FULL_CHAR* in_str); +extern void PDFPage_PrintUnderline(FILE* in_fp, int in_x1, int in_x2, + int in_y, int in_thickness); + +extern void PDFFont_AddFont( + FILE* in_fp, + const FULL_CHAR* in_short_font_name, + const FULL_CHAR* in_real_font_name, + const FULL_CHAR* in_font_encoding_name); +extern void PDFFont_Set(FILE* in_fp, FULL_LENGTH in_font_size, + FULL_CHAR * in_short_font_name); +extern void PDFText_OpenXY(FILE* in_fp, int hpos, int vpos); +extern void PDFText_OpenX(FILE* in_fp, int hpos); +extern void PDFText_Open(FILE* in_fp); +extern void PDFText_Kern(FILE* in_fp, int in_kern); +extern void PDFText_Close(FILE* in_fp); +extern BOOLEAN PDFHasValidTextMatrix(void); + + +/*@::assert(), debug(), debug flags@******************************************/ +/* */ +/* ASSERT AND DEBUG CODE */ +/* */ +/*****************************************************************************/ + +#if ASSERT_ON +#define assert(c, m) \ + { if( !(c) ) Error(1, 2, "assert failed in %s", INTERN, no_fpos, m); } +#define assert1(c, m, p1) \ + { if( !(c) ) Error(1, 3, "assert failed in %s %s", INTERN,no_fpos,m, p1); } +#else +#define assert(c, m) +#define assert1(c, m, p1) +#endif + +#if DEBUG_ON + +struct dbs +{ char *flag; /* external names for debug flags */ + BOOLEAN on[3]; /* the debug flags */ +}; +extern struct dbs dbg[]; + +/* debug routines */ +#define debug0(cat, urg, str) \ + { if( dbg[cat].on[urg] ) Debug(cat, urg, str); } +#define debug1(cat, urg, str, p1) \ + { if( dbg[cat].on[urg] ) Debug(cat, urg, str, p1); } +#define debug2(cat, urg, str, p1, p2) \ + { if( dbg[cat].on[urg] ) Debug(cat, urg, str, p1, p2); } +#define debug3(cat, urg, str, p1, p2, p3) \ + { if( dbg[cat].on[urg] ) Debug(cat, urg, str, p1, p2, p3); } +#define debug4(cat, urg, str, p1, p2, p3, p4) \ + { if( dbg[cat].on[urg] ) Debug(cat, urg, str, p1, p2, p3, p4); } +#define debug5(cat, urg, str, p1, p2, p3, p4, p5) \ + { if( dbg[cat].on[urg] ) Debug(cat, urg, str, p1, p2, p3, p4, p5); } +#define debug6(cat, urg, str, p1, p2, p3, p4, p5, p6) \ + { if( dbg[cat].on[urg] ) Debug(cat, urg, str, p1, p2, p3, p4, p5, p6); } +#define debug7(cat, urg, str, p1, p2, p3, p4, p5, p6, p7) \ + { if( dbg[cat].on[urg] ) Debug(cat, urg, str, p1, p2, p3, p4, p5,p6,p7); } +#define debug8(cat, urg, str, p1, p2, p3, p4, p5, p6, p7, p8) \ + { if( dbg[cat].on[urg] ) Debug(cat, urg, str, p1, p2,p3,p4,p5,p6,p7,p8); } +#define ifdebug(cat, urg, x) \ + { if( dbg[cat].on[urg] ) { x; } } + +#define debugcond0(cat, urg, cond, str) \ + { if( dbg[cat].on[urg] && cond ) Debug(cat, urg, str); } +#define debugcond1(cat, urg, cond, str, p1) \ + { if( dbg[cat].on[urg] && cond ) Debug(cat, urg, str, p1); } +#define debugcond2(cat, urg, cond, str, p1, p2) \ + { if( dbg[cat].on[urg] && cond ) Debug(cat, urg, str, p1, p2); } +#define debugcond3(cat, urg, cond, str, p1, p2, p3) \ + { if( dbg[cat].on[urg] && cond ) Debug(cat, urg, str, p1, p2, p3); } +#define debugcond4(cat, urg, cond, str, p1, p2, p3, p4) \ + { if( dbg[cat].on[urg] && cond ) Debug(cat, urg, str, p1, p2, p3, p4); } +#define debugcond5(cat, urg, cond, str, p1, p2, p3, p4, p5) \ + { if( dbg[cat].on[urg] && cond ) Debug(cat, urg, str, p1, p2, p3, p4, p5);} +#define debugcond6(cat, urg, cond, str, p1, p2, p3, p4, p5, p6) \ + { if( dbg[cat].on[urg] && cond ) Debug(cat, urg, str, p1, p2,p3,p4,p5,p6);} +#define ifdebugcond(cat, urg, cond, x) \ + { if( dbg[cat].on[urg] && cond ) { x; } } +#define debug_init(str) \ + DebugInit(str) + +/* debug styles */ +#define D 0 +#define DD 1 +#define DDD 2 + +/* debug flags */ +#define DSP 1 /* z01.c -dsp Supervise */ +#define DLA 2 /* z02.c -dla Lexical Analyser */ +#define DFS 3 /* z03.c -dfs File Service */ +#define DTS 4 /* z04.c -dts Token Service */ +#define DRD 5 /* z05.c -drd Read Definitions */ +#define DOP 6 /* z06.c -dop Object Parser */ +#define DOS 7 /* z07.c -dos Object Service */ +#define DOM 8 /* z08.c -dom Object Manifest */ +#define DCE 9 /* z09.c -dce Closure Expansion */ +#define DCR 10 /* z10.c -dcr Cross References */ +#define DSS 11 /* z11.c -dss Style Service */ +#define DSF 12 /* z12.c -dsf Size Finder */ +#define DOB 13 /* z13.c -dob Object Breaking */ +#define DOF 14 /* z14.c -dof Object Filling */ +#define DSC 15 /* z15.c -dsc Size Constraints */ +#define DSA 16 /* z16.c -dsa Size Adjustments */ +#define DGW 17 /* z17.c -dgw Gap Widths */ +#define DGT 18 /* z18.c -dgt Galley Transfer */ +#define DGA 19 /* z19.c -dgf Galley Attaching */ +#define DGF 20 /* z20.c -dgf Galley Flushing */ +#define DGM 21 /* z21.c -dgm Galley Maker */ +#define DGS 22 /* z22.c -dgs Galley Service */ +#define DGP 23 /* z23.c -dgp Galley Printer */ +#define DPS 24 /* z24.c -dps Print Service */ +#define DOE 25 /* z25.c -doe Object Echo */ +#define DES 26 /* z26.c -des Echo Service */ +#define DZZ 27 /* z27.c -dzz Debug Service */ +#define DYY 28 /* z28.c -dyy Error Service */ +#define DST 29 /* z29.c -dst Symbol Table */ +#define DSU 30 /* z30.c -dsu Symbol Uses */ +#define DMA 31 /* z31.c -dma Memory Allocator */ +#define DCS 32 /* z32.c -dcs Counter Service */ +#define DBS 33 /* z33.c -dbs Database Service */ +#define DRS 34 /* z34.c -drs Rotation Service */ +#define DTK 35 /* z35.c -dtk Time Keeper */ +#define DHY 36 /* z36.c -dhy Hyphenation */ +#define DFT 37 /* z37.c -dft Font Service */ +#define DCM 38 /* z38.c -dcm Character Mapping */ +#define DSH 39 /* z39.c -dsh String Handler */ +#define DFH 40 /* z40.c -dsh Filter Handler */ +#define DIO 41 /* z41.c -dio Object Input-Output */ +#define DCO 42 /* z42.c -dco Colour Service */ +#define DLS 43 /* z43.c -dls Language Service */ +#define DVH 44 /* z44.c -dvh Vertical Hyphenation */ +#define DEX 45 /* z45.c -dex External Sort */ +#define DOG 46 /* z46.c -dex Optimal Galleys */ +#define DET 47 /* z47.c -det Environment Table */ +#define DPD 48 /* z48.c -dpd PDF Back End */ +#define DPP 49 /* -dpp Profiling */ +#define ANY 50 /* -d any */ + +#else +#define ifdebug(cat, urg, x) +#define debug0(cat, urg, str) +#define debug1(cat, urg, str, p1) +#define debug2(cat, urg, str, p1, p2) +#define debug3(cat, urg, str, p1, p2, p3) +#define debug4(cat, urg, str, p1, p2, p3, p4) +#define debug5(cat, urg, str, p1, p2, p3, p4, p5) +#define debug6(cat, urg, str, p1, p2, p3, p4, p5, p6) +#define debug7(cat, urg, str, p1, p2, p3, p4, p5, p6, p7) +#define debug8(cat, urg, str, p1, p2, p3, p4, p5, p6, p7, p8) + +#define debugcond0(cat, urg, cond, str) +#define debugcond1(cat, urg, cond, str, p1) +#define debugcond2(cat, urg, cond, str, p1, p2) +#define debugcond3(cat, urg, cond, str, p1, p2, p3) +#define debugcond4(cat, urg, cond, str, p1, p2, p3, p4) +#define debugcond5(cat, urg, cond, str, p1, p2, p3, p4, p5) +#define debugcond6(cat, urg, cond, str, p1, p2, p3, p4, p5, p6) +#define ifdebugcond(cat, urg, cond, x) +#define debug_init(str) Error(1, 4, "%s - debug flags not implemented", \ + FATAL, no_fpos, str) +#endif |