/*-
******************************************************************************
******************************************************************************
**
**  MODULE
**
**      $RCSfile: bibtex.h,v $
**      $Revision: 3.71 $
**      $Date: 1996/08/18 20:47:30 $
**
**  DESCRIPTION
**
**      A 32-bit implementation of BibTeX v0.99c for MS-DOS, OS/2 2.x, 
**      Unix and VMS.  This C language implementation is based on the 
**      original WEB source but it has been enhanced to support 8-bit input
**      characters and a very large processing capacity.
**
**      For documentation describing how to use and build this program, 
**      see the 00README.TXT file that accompanies this distribution.
**
**  MODULE CONTENTS
**
**      This module defines the macros used in the BibTeX WEB source.  
**      This file also contains the definitions that determine BibTeX's 
**      processing capacity.
**
**  AUTHORS
**
**      Original WEB translation to C, conversion to "big" (32-bit) capacity,
**      addition of run-time selectable capacity and 8-bit support extensions
**      by:
**
**          Niel Kempson
**          Snowy Owl Systems Limited, Cheltenham, England
**          E-mail: kempson@snowyowl.co.uk
**      
**      8-bit support extensions also by:
**
**          Alejandro Aguilar-Sierra
**          Centro de Ciencias de la Atm\'osfera, 
**          Universidad Nacional Aut\'onoma de M\'exico, M\'exico
**          E-mail: asierra@servidor.unam.mx
**
**  COPYRIGHT
**
**      This implementation copyright (c) 1991-1995 by Niel Kempson
**           and copyright (c) 1995 by Alejandro Aguilar-Sierra.
**
**      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 1, 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., 675 Mass Ave, Cambridge, MA 02139, USA.
**
**      In other words, you are welcome to use, share and improve this
**      program.  You are forbidden to forbid anyone else to use, share
**      and improve what you give them.  Help stamp out software-hoarding!
**
**  ACKNOWLEDGEMENT
**      
**      The original BibTeX was written by Oren Patashnik using Donald 
**      Knuth's WEB system.  This format produces a PASCAL program for 
**      execution and a TeX documented version of the source code. This 
**      program started as a (manual) translation of the WEB source into C.
**  
**  CHANGE LOG
**
**      $Log: bibtex.h,v $
**      Revision 3.71  1996/08/18  20:47:30  kempson
**      Official release 3.71 (see HISTORY file for details).
**
**      Revision 3.70  1996/04/08  10:08:40  kempson
**      Final documentation & cosmetic changes for official release 3.70.
**
**      Revision 3.5  1995/09/24  20:44:37  kempson
**      Many changes for final beta test version.
**
**      Revision 3.4  1995/04/09  22:15:43  kempson
**      Placed under RCS control
**
******************************************************************************
******************************************************************************
*/
#ifndef __BIBTEX_H__
#define __BIBTEX_H__                1


/***************************************************************************
 * WEB section number:   1
 * ~~~~~~~~~~~~~~~~~~~
 * The BANNER string is defined here and should be changed whenever BibTeX
 * is modified.
 ***************************************************************************/
#ifdef UTF_8
# define BANNER     "This is BibTeXu: a UTF-8 Big BibTeX version 0.99d"
# define PROGNAME "bibtexu"
# define SUPPORT_8BIT
#else
# ifdef SUPPORT_8BIT
#  define BANNER     "This is 8-bit Big BibTeX version 0.99d"
# else
#  define BANNER     "This is Big BibTeX version 0.99d"
# endif
# define PROGNAME "bibtex8"
#endif


/***************************************************************************
 * WEB section number:   2
 * ~~~~~~~~~~~~~~~~~~~
 * Terminal output goes to the file |TERM_OUT|, while terminal input comes
 * from |TERM_IN|.  On our system, these (system-dependent) files are
 * already opened at the beginning of the program.
 ***************************************************************************/
#define TERM_OUT                    stdout
#define TERM_IN                     stdin

/***************************************************************************
 * WEB section number:   3
 * ~~~~~~~~~~~~~~~~~~~
 * This program uses the term |print| instead of |write| when writing on
 * both the |log_file| and (system-dependent) |term_out| file, and it
 * uses |trace_pr| when in |trace| mode, for which it writes on just the
 * |log_file|.  If you want to change where either set of macros writes
 * to, you should also change the other macros in this program for that
 * set; each such macro begins with |print_| or |trace_pr_|.
 ***************************************************************************/
#define PRINT_NEWLINE               print_a_newline ()

#define PRINT(X) \
            {\
                if (log_file != NULL)\
                    FPRINTF (log_file, X);\
                FPRINTF (TERM_OUT, X);\
            }

#define PRINT2(X, Y) \
            {\
                if (log_file != NULL)\
                    FPRINTF (log_file, X, Y);\
                FPRINTF (TERM_OUT, X, Y);\
            }

#define PRINT3(X, Y, Z) \
            {\
                if (log_file != NULL)\
                    FPRINTF (log_file, X, Y, Z);\
                FPRINTF (TERM_OUT, X, Y, Z);\
            }

#define PRINT4(W, X, Y, Z) \
            {\
                if (log_file != NULL)\
                    FPRINTF (log_file, W, X, Y, Z);\
                FPRINTF (TERM_OUT, W, X, Y, Z);\
            }

#define PRINT_LN(X) \
            {\
                if (log_file != NULL) {\
                    FPRINTF (log_file, X); FPUTC ('\n', log_file);\
                }\
                FPRINTF (TERM_OUT, X); FPUTC('\n', TERM_OUT);\
            }

#define PRINT_LN2(X, Y) \
            {\
                if (log_file != NULL) {\
                    FPRINTF (log_file, X, Y); FPUTC ('\n', log_file);\
                }\
                FPRINTF (TERM_OUT, X, Y); FPUTC('\n', TERM_OUT);\
            }

#define PRINT_LN3(X, Y, Z) \
            {\
                if (log_file != NULL) {\
                    FPRINTF (log_file, X, Y, Z); FPUTC ('\n', log_file);\
                }\
                FPRINTF (TERM_OUT, X, Y, Z); FPUTC('\n', TERM_OUT);\
            }

#define PRINT_LN4(W, X, Y, Z) \
            {\
                if (log_file != NULL) {\
                    FPRINTF (log_file, W, X, Y, Z); FPUTC ('\n', log_file);\
                }\
                FPRINTF (TERM_OUT, W, X, Y, Z); FPUTC('\n', TERM_OUT);\
            }

#define TRACE_PR(X) \
            if (log_file != NULL) FPRINTF (log_file, X);

#define TRACE_PR2(X, Y) \
            if (log_file != NULL) FPRINTF (log_file, X, Y);

#define TRACE_PR3(X, Y, Z) \
            if (log_file != NULL) FPRINTF (log_file, X, Y, Z);

#define TRACE_PR_LN(X) \
            {\
                if (log_file != NULL) {\
                    FPRINTF (log_file, X);  FPUTC ('\n', log_file);\
                }\
            }

#define TRACE_PR_LN2(X, Y) \
            {\
                if (log_file != NULL) {\
                    FPRINTF (log_file, X, Y); FPUTC ('\n', log_file);\
                }\
            }

#define TRACE_PR_LN3(X, Y, Z) \
            {\
                if (log_file != NULL) {\
                    FPRINTF (log_file, X, Y, Z); FPUTC ('\n', log_file);\
                }\
            }

#define TRACE_PR_NEWLINE \
            {\
                if (log_file != NULL)\
                    FPUTC ('\n', log_file);\
            }


/***************************************************************************
 * WEB section number:   4
 * ~~~~~~~~~~~~~~~~~~~
 * Some of the code is intended to be used only when diagnosing the strange
 * behaviour that sometimes occurs when BibTeX is being installed or when
 * system wizards are fooling around with BibTeX without quite knowing what
 * they are doing. Such code will not normally be compiled; it is delimited
 * by the preprocessor conditionals `#ifdef DEBUG ... #endif'. Similarly,
 * there is some conditional code delimited by `#ifdef STAT ... #endif'
 * that is intended only for use when statistics are to be kept about
 * BibTeX's memory/CPU usage, and there is conditional code delimited by
 * `#ifdef TRACE ... #endif' that is intended to be a trace facility for
 * use mainly when debugging .BST files.
 ***************************************************************************/
#define DEBUG                       1
#define STAT                        1
#define TRACE                       1

/***************************************************************************
 * WEB section number:   9
 * ~~~~~~~~~~~~~~~~~~~
 * Here are some macros for common programming idioms.
 ***************************************************************************/
#define INCR(X)                     ++(X)
#define DECR(X)                     --(X)
#define LOOP                        while (TRUE)
#define DO_NOTHING                  ;
#define EMPTY                       0
#define ANY_VALUE                   0

/***************************************************************************
 * WEB section number:   14
 * ~~~~~~~~~~~~~~~~~~~
 * These parameters may be changed at compile time to extend or reduce
 * BiBTeX's capacity. They are set to accommodate a maximum of about 750
 * cites when used with the standard styles.
 ***************************************************************************/
#define MIN_PRINT_LINE              3
#define MAX_PRINT_LINE              79
#define AUX_STACK_SIZE              20
#define MAX_BIB_FILES               20

#define BUF_SIZE                   20000
#define MAX_CITES                  750
#define MAX_FIELDS                 5000
#define MAX_STRINGS                4000
#define POOL_SIZE                  65000L

#define MIN_CROSSREFS               2
#define WIZ_FN_SPACE                3000
#define SINGLE_FN_SPACE             50
#define ENT_STR_SIZE                100
#define GLOB_STR_SIZE               1000
#define LIT_STK_SIZE                50


/***************************************************************************
 * WEB section number:   15
 * ~~~~~~~~~~~~~~~~~~~
 * These parameters can also be changed at compile time, but they're
 * needed to define some WEB numeric macros so they must be defined
 * themselves.
 ***************************************************************************/
#define HASH_SIZE                  5000

#ifdef MSDOS
# define FILE_NAME_SIZE             64
#else                           /* NOT MSDOS */
# define FILE_NAME_SIZE             255
#endif                          /* MSDOS */

#define MAX_GLOB_STRS               10

/***************************************************************************
 * WEB section number:   18
 * ~~~~~~~~~~~~~~~~~~~
 * A global variable called |history| will contain one of four values at
 * the end of every run: |spotless| means that no unusual messages were
 * printed; |warning_message| means that a message of possible interest
 * was printed but no serious errors were detected; |error_message| means
 * that at least one error was found; |fatal_message| means that the
 * program terminated abnormally. The value of |history| does not
 * influence the behavior of the program; it is simply computed for the
 * convenience of systems that might want to use such information.
 ***************************************************************************/
#define SPOTLESS                    0
#define WARNING_MESSAGE             1
#define ERROR_MESSAGE               2
#define FATAL_MESSAGE               3

/***************************************************************************
 * WEB section number:   23
 * ~~~~~~~~~~~~~~~~~~~
 * We shall use the |text_char| to stand for the data type of the
 * characters that are converted to and from |ASCIICode_T| when they are
 * input and output. We shall also assume that |text_char| consists of the
 * elements |chr[FIRST_TEXT_CHAR]| through |chr[LAST_TEXT_CHAR]| inclusive.
 * The following definitions should be adjusted if necessary.
 ***************************************************************************/
#define FIRST_TEXT_CHAR             0
#define LAST_TEXT_CHAR              255

#ifdef SUPPORT_8BIT
#define LAST_ASCII_CHAR             255
#else
#define LAST_ASCII_CHAR             127
#endif                          /* SUPPORT_8BIT */


/***************************************************************************
 * WEB section number:   26
 * ~~~~~~~~~~~~~~~~~~~
 * Some of the ASCII codes without visible characters have been given
 * symbolic names in this program because they are used with a special
 * meaning.  The |tab| character may be system dependent.
 ***************************************************************************/
#define NULL_CODE                   0
#define TAB                         9
#define SPACE                       32
#define INVALID_CODE                127

/***************************************************************************
 * WEB section number:   29
 * ~~~~~~~~~~~~~~~~~~~
 * Also, various characters are given symbolic names; all the ones this
 * program uses are collected here.  We use the sharp sign as the
 * |concat_char|, rather than something more natural (like an ampersand),
 * for uniformity of database syntax (ampersand is a valid character in
 * identifiers).
 ***************************************************************************/
#define DOUBLE_QUOTE                '"'
#define NUMBER_SIGN                 '#'
#define COMMENT                     '%'
#define SINGLE_QUOTE                '\''
#define LEFT_PAREN                  '('
#define RIGHT_PAREN                 ')'
#define COMMA                       ','
#define MINUS_SIGN                  '-'
#define EQUALS_SIGN                 '='
#define AT_SIGN                     '@'
#define LEFT_BRACE                  '{'
#define RIGHT_BRACE                 '}'
#define PERIOD                      '.'
#define QUESTION_MARK               '?'
#define EXCLAMATION_MARK            '!'
#define TIE                         '~'
#define HYPHEN                      '-'
#define STAR                        '*'
#define CONCAT_CHAR                 '#'
#define COLON                       ':'
#define BACKSLASH                   '\\'

/***************************************************************************
 * WEB section number:   31
 * ~~~~~~~~~~~~~~~~~~~~
 * Every character has two types of the lexical classifications.  The
 * first type is general, and the second type tells whether the character
 * is legal in identifiers.
 ***************************************************************************/
#define ILLEGAL                     0
#define WHITE_SPACE                 1
#define ALPHA                       2
#define NUMERIC                     3
#define SEP_CHAR                    4
#define OTHER_LEX                   5
#define LAST_LEX                    5
#define ILLEGAL_ID_CHAR             0
#define LEGAL_ID_CHAR               1

/***************************************************************************
 * WEB section number:   35
 * ~~~~~~~~~~~~~~~~~~~~
 * Now we initialize the system-dependent |char_width| array, for which
 * |space| is the only |white_space| character given a nonzero printing
 * width.  The widths here are taken from Stanford's June '87 cmr10 font
 * and represent hundredths of a point (rounded), but since they're used
 * only for relative comparisons, the units have no meaning.
 ***************************************************************************/
#define SS_WIDTH                    500
#define AE_WIDTH                    722
#define OE_WIDTH                    778
#define UPPER_AE_WIDTH              903
#define UPPER_OE_WIDTH              1014

/***************************************************************************
 * WEB section number:   44
 * ~~~~~~~~~~~~~~~~~~~~
 * When something in the program wants to be bigger or something out
 * there wants to be smaller, it's time to call it a run.  Here's the
 * first of several macros that have associated procedures so that they
 * produce less inline code.
 ***************************************************************************/
#define BIBTEX_OVERFLOW(X, Y)              {\
    print_overflow ();\
    PRINT_LN3 ("%s%ld\n", (X), (long) (Y));\
    longjmp (Close_Up_Shop_Flag, 1);}

/***************************************************************************
 * WEB section number:   45
 * ~~~~~~~~~~~~~~~~~~~~
 * When something happens that the program thinks is impossible, call the
 * maintainer.
 ***************************************************************************/
#define CONFUSION(X)                {\
            PRINT (X); print_confusion();\
            longjmp (Close_Up_Shop_Flag, 1);}
#define CONFUSION2(X, Y)            {\
            PRINT2 (X, Y); print_confusion();\
            longjmp (Close_Up_Shop_Flag, 1);}

/***************************************************************************
 * WEB section number:   50
 * ~~~~~~~~~~~~~~~~~~~~
 * These macros send a string in |str_pool| to an output file.
 ***************************************************************************/
#define MAX_POP                     3
#define PRINT_POOL_STR(X)           print_a_pool_str(X)
#define TRACE_PR_POOL_STR(X)        { out_pool_str(log_file, X);}

/***************************************************************************
 * WEB section number:  52
 * ~~~~~~~~~~~~~~~~~~~
 * Several of the elementary string operations are performed using WEB
 * macros instead of using PASCAL procedures, because many of the operations
 * are done quite frequently and we want to avoid the overhead of procedure
 * calls. For example, here's a simple macro that computes the length of a
 * string.
 ***************************************************************************/
#define LENGTH(s)                   (str_start[(s)+1] - str_start[s])

/***************************************************************************
 * WEB section number:   53
 * ~~~~~~~~~~~~~~~~~~~
 * Strings are created by appending character codes to |str_pool|. The macro
 * called |append_char|, defined here, does not check to see if the value
 * of |pool_ptr| is too high; this test is supposed to be made before
 * |append_char| is used.
 ***************************************************************************/
#define APPEND_CHAR(X)              {str_pool[pool_ptr] = (X);\
                                     INCR(pool_ptr);}
#define STR_ROOM(X)                 {while((pool_ptr+(X))>Pool_Size)\
                                        pool_overflow();}

/***************************************************************************
 * WEB section number:   55
 * ~~~~~~~~~~~~~~~~~~~
 * These macros destroy an recreate the string at the end of the pool.
 ***************************************************************************/
#define FLUSH_STRING                {DECR(str_ptr);\
                                     pool_ptr=str_start[str_ptr];}
#define UNFLUSH_STRING              {INCR(str_ptr);\
                                     pool_ptr=str_start[str_ptr];}

/***************************************************************************
 * WEB section number:  62
 * ~~~~~~~~~~~~~~~~~~~
 * This system-independent procedure converts upper-case characters to
 * lower case for the specified part of |buf|.  It is system independent
 * because it uses only the internal representation for characters.
 ***************************************************************************/
#define CASE_DIFFERENCE             ('a' - 'A')

/***************************************************************************
 * WEB section number:   64
 * ~~~~~~~~~~~~~~~~~~~
 * All static strings that BibTeX might have to search for, generally
 * identifiers, are stored and retrieved by means of a fairly standard
 * hash-table algorithm (but slightly altered here) called the method of
 * ``coalescing lists'' (cf.\ Algorithm 6.4C in The Art of Computer
 * Programming).  Once a string enters the table, it is never removed.
 * The actual sequence of characters forming a string is stored in the
 * |str_pool| array.
 ***************************************************************************/
#define HASH_BASE                   (EMPTY + 1)
#define HASH_MAX                    (HASH_BASE + Hash_Size - 1)
#define HASH_IS_FULL                ((hash_used) == (HASH_BASE))
#define TEXT_ILK                    0
#define INTEGER_ILK                 1
#define AUX_COMMAND_ILK             2
#define AUX_FILE_ILK                3
#define BST_COMMAND_ILK             4
#define BST_FILE_ILK                5
#define BIB_FILE_ILK                6
#define FILE_EXT_ILK                7
#define FILE_AREA_ILK               8
#define CITE_ILK                    9
#define LC_CITE_ILK                 10
#define BST_FN_ILK                  11
#define BIB_COMMAND_ILK             12
#define MACRO_ILK                   13
#define CONTROL_SEQ_ILK             14
#define LAST_ILK                    14

/***************************************************************************
 * WEB section number:   68
 * ~~~~~~~~~~~~~~~~~~~
 * Here is the subroutine that searches the the hash table for a (string,
 * str_ilk) pair, where the string is of length l >= 0 and appears in
 * |buffer[j..(j+l-1)]|. If it finds the pair, it returns the corresponding
 * hash table location and sets the global variable |hash_found| to |TRUE|.
 * Otherwise is sets |hash_found| to |FALSE|, and if the parameter
 * |insert_it| is |TRUE|, it inserts the pair into the hash table, inserts
 * the string into |str_pool| if not previously encountered, and returns its
 * location. Note that two different pairs can have the same string but
 * different |str_ilks|, in which case the second pair encountered, if
 * |insert_it| were |TRUE|, would be inserted into the hash table though its
 * string wouldn't be inserted into |str_pool| because it would already be
 * there.
 ***************************************************************************/
#define MAX_HASH_VALUE              (Hash_Prime + Hash_Prime - 2 + 127)
#define DO_INSERT                   TRUE
#define DONT_INSERT                 FALSE

/***************************************************************************
 * WEB section number:   73
 * ~~~~~~~~~~~~~~~~~~~
 * The longest pre-defined string determines type definitions used to
 * insert the pre-defined strings into |str_pool|.
 * Set to accommodate the longest translations of the environment variables.
 ***************************************************************************/
#define LONGEST_PDS                 MAX_FILE_NAME

/***************************************************************************
 * WEB section number:   78
 * ~~~~~~~~~~~~~~~~~~~
 * These constants all begin with |n_| and are used for the |case|
 * statement that determines which command to execute.  The variable
 * |command_num| is set to one of these and is used to do the branching,
 * but it must have the full |integer| range because at times it can
 * assume an arbitrary |ilk_info| value (though it will be one of the
 * values here when we actually use it).
 ***************************************************************************/
#define N_AUX_BIBDATA               0
#define N_AUX_BIBSTYLE              1
#define N_AUX_CITATION              2
#define N_AUX_INPUT                 3

#define N_BST_ENTRY                 0
#define N_BST_EXECUTE               1
#define N_BST_FUNCTION              2
#define N_BST_INTEGERS              3
#define N_BST_ITERATE               4
#define N_BST_MACRO                 5
#define N_BST_READ                  6
#define N_BST_REVERSE               7
#define N_BST_SORT                  8
#define N_BST_STRINGS               9

#define N_BIB_COMMENT               0
#define N_BIB_PREAMBLE              1
#define N_BIB_STRING                2

/***************************************************************************
 * WEB section number:   80
 * ~~~~~~~~~~~~~~~~~~~
 * This section describes the various |buffer| scanning routines.  The
 * two global variables |buf_ptr1| and |buf_ptr2| are used in scanning an
 * input line.  Between scans, |buf_ptr1| points to the first character
 * of the current token and |buf_ptr2| points to that of the next.  The
 * global variable |last|, set by the function |input_ln|, marks the end
 * of the current line; it equals 0 at the end of the current file.  All
 * the procedures and functions in this section will indicate an
 * end-of-line when it's the end of the file.
 ***************************************************************************/
#define TOKEN_LEN                   (buf_ptr2 - buf_ptr1)
#define SCAN_CHAR                   buffer[buf_ptr2]

/***************************************************************************
 * WEB section number:  81
 * ~~~~~~~~~~~~~~~~~~~
 * These macros send the current token, in |buffer[buf_ptr1]| to
 * |buffer[buf_ptr2-1]|, to an output file.
 ***************************************************************************/
#define PRINT_TOKEN                 print_a_token ();
#define TRACE_PR_TOKEN              out_token (log_file);

/***************************************************************************
 * WEB section number:   89
 * ~~~~~~~~~~~~~~~~~~~
 * These are the possible values for |scan_result|; they're set by the
 * |scan_identifier| procedure and are described in the next section.
 ***************************************************************************/
#define ID_NULL                     0
#define SPECIFIED_CHAR_ADJACENT     1
#define OTHER_CHAR_ADJACENT         2
#define WHITE_ADJACENT              3

/***************************************************************************
 * WEB section number:  91
 * ~~~~~~~~~~~~~~~~~~~
 * The next two procedures scan for an integer, setting the global
 * variable |token_value| to the corresponding integer.
 ***************************************************************************/
#define CHAR_VALUE                  (SCAN_CHAR - '0')

/***************************************************************************
 * WEB section number:  93
 * ~~~~~~~~~~~~~~~~~~~
 * This procedure scans for an integer, stopping at the first nondigit;
 * it sets the value of |token_value| accordingly.  It returns |true| if
 * the token was a legal integer (i.e., consisted of an optional
 * |minus_sign| followed by one or more digits).
 ***************************************************************************/
#define NEGATIVE                    (sign_length == 1)

/***************************************************************************
 * WEB section number:  98
 * ~~~~~~~~~~~~~~~~~~~
 * I mean, this is truly disgraceful ...
 *
 * Note: The |term_out| file is system dependent.
 ***************************************************************************/
#define SAM_YOU_MADE_THE_FILE_NAME_TOO {\
            sam_too_long_file_name_print ();\
            goto Aux_Not_Found_Label;}

/***************************************************************************
 * WEB section number:  99
 * ~~~~~~~~~~~~~~~~~~~
 * We've abused the user enough for one section; suffice it to
 * say here that most of what we said last module still applies.
 * Note: The |term_out| file is system dependent.
 ***************************************************************************/
#define SAM_YOU_MADE_THE_FILE_NAME_WRON {\
            sam_wrong_file_name_print ();\
            goto Aux_Not_Found_Label;}

/***************************************************************************
 * WEB section number:  104
 * ~~~~~~~~~~~~~~~~~~~
 * Here we set up definitions and declarations for files opened in this
 * section.  Each element in |aux_list| (except for
 * |aux_list[aux_stack_size]|, which is always unused) is a pointer to
 * the appropriate |str_pool| string representing the \.{.aux} file name.
 * The array |aux_file| contains the corresponding \PASCAL\ |file|
 * variables.
 ***************************************************************************/
#define CUR_AUX_STR                 aux_list[aux_ptr]
#define CUR_AUX_FILE                aux_file[aux_ptr]
#define CUR_AUX_LINE                aux_ln_stack[aux_ptr]

/***************************************************************************
 * WEB section number:  111
 * ~~~~~~~~~~~~~~~~~~~
 * When we find a bug, we print a message and flush the rest of the line.
 * This macro must be called from within a procedure that has an |exit|
 * label.
 ***************************************************************************/
#define AUX_ERR_RETURN              {aux_err_print(); goto Exit_Label;}

/***************************************************************************
 * WEB section number:  112
 * ~~~~~~~~~~~~~~~~~~~
 * Here are a bunch of macros whose print statements are used at least
 * twice.  Thus we save space by making the statements procedures.  This
 * macro complains when there's a repeated command that's to be used just
 * once.
 ***************************************************************************/
#define AUX_ERR_ILLEGAL_ANOTHER(X)  {aux_err_illegal_another_print (X);\
                                     AUX_ERR_RETURN;}

/***************************************************************************
 * WEB section number:  113
 * ~~~~~~~~~~~~~~~~~~~
 * This one complains when a command is missing its |right_brace|.
 ***************************************************************************/
#define AUX_ERR_NO_RIGHT_BRACE      {\
            PRINT2 ("No \"%c\"", xchr[RIGHT_BRACE]);\
            AUX_ERR_RETURN;}

/***************************************************************************
 * WEB section number:  114
 * ~~~~~~~~~~~~~~~~~~~
 * This one complains when a command has stuff after its |right_brace|.
 ***************************************************************************/
#define AUX_ERR_STUFF_AFTER_RIGHT_BRACE {\
            PRINT2 ("Stuff after \"%c\"", xchr[RIGHT_BRACE]);\
            AUX_ERR_RETURN;}

/***************************************************************************
 * WEB section number:  115
 * ~~~~~~~~~~~~~~~~~~~
 * And this one complains when a command has white space in its argument.
 ***************************************************************************/
#define AUX_ERR_WHITE_SPACE_IN_ARGUMENT {\
            PRINT ("White space in argument");\
            AUX_ERR_RETURN;}

/***************************************************************************
 * WEB section number:  117
 * ~~~~~~~~~~~~~~~~~~~
 * Here we introduce some variables for processing a \.{\\bibdata}
 * command.  Each element in |bib_list| (except for
 * |bib_list[max_bib_files]|, which is always unused) is a pointer to the
 * appropriate |str_pool| string representing the \.{.bib} file name.
 * The array |bib_file| contains the corresponding \PASCAL\ |file|
 * variables.
 ***************************************************************************/
#define CUR_BIB_STR                 bib_list[bib_ptr]
#define CUR_BIB_FILE                bib_file[bib_ptr]

/***************************************************************************
 * WEB section number:  122
 * ~~~~~~~~~~~~~~~~~~~
 * This macro is very similar to aux_err but it complains specifically about
 * opening a file for a \bibdata command.
 ***************************************************************************/
#define OPEN_BIBDATA_AUX_ERR(X)     {\
            PRINT (X);\
            print_bib_name();\
            AUX_ERR_RETURN;}

/***************************************************************************
 * WEB section number:  129
 * ~~~~~~~~~~~~~~~~~~~
 * Here we introduce some variables for processing a \.{\\citation}
 * command.  Each element in |cite_list| (except for
 * |cite_list[Max_Cites]|, which is always unused) is a pointer to the
 * appropriate |str_pool| string.  The cite-key list is kept in order of
 * occurrence with duplicates removed.
 ***************************************************************************/
#define CUR_CITE_STR                cite_list[cite_ptr]

/***************************************************************************
 * WEB section number:  133
 * ~~~~~~~~~~~~~~~~~~~
 * We must check if (the lower-case version of) this cite key has been
 * previously encountered, and proceed accordingly.  The alias kludge
 * helps make the stack space not overflow on some machines.
 ***************************************************************************/
#define EX_BUF1                     ex_buf

/***************************************************************************
 * WEB section number:  144
 * ~~~~~~~~~~~~~~~~~~~
 * We must complain if anything's amiss.
 ***************************************************************************/
#define AUX_END_ERR(X)              {\
            aux_end1_err_print();\
            PRINT (X);\
            aux_end2_err_print();}

/***************************************************************************
 * WEB section number:   149
 * ~~~~~~~~~~~~~~~~~~~
 * When there's a serious error parsing the .bst file, we flush the rest of
 * the current command; a blank line is assumed to mark the end of a command
 * (but for the purposes of error recovery only). Thus, error recovery will
 * be better if style designers leave blank lines between .bst commands.
 * This macro must be called from within a procedure that has an 'exit'
 * label.
 ***************************************************************************/
#define BST_ERR_PRINT_AND_LOOK_FOR_BLAN {\
            bst_err_print_and_look_for_blan();\
            goto Exit_Label;}

#define BST_ERR(X)                  {\
            PRINT (X);\
            bst_err_print_and_look_for_blan ();\
            goto Exit_Label;}

#define BST_ERR2(X, Y)              {\
            PRINT2 (X, Y);\
            bst_err_print_and_look_for_blan ();\
            goto Exit_Label;}

/***************************************************************************
 * WEB section number:   150
 * ~~~~~~~~~~~~~~~~~~~
 * When there's a harmless error parsing the .bst file (harmless
 * syntactically, at least) we give just a warning message.
 ***************************************************************************/
#define BST_WARN(X)                 {\
            PRINT (X); bst_warn_print();}

/***************************************************************************
 * WEB section number:   153
 * ~~~~~~~~~~~~~~~~~~~
 * It's often illegal to end a .bst command in certain places, and this is
 * where we come to check.
 ***************************************************************************/
#define EAT_BST_WHITE_AND_EOF_CHECK(X)  {\
            if (! eat_bst_white_space()) {\
                PRINT (X); BST_ERR(X);}}

/***************************************************************************
 * WEB section number:   156
 * ~~~~~~~~~~~~~~~~~~~
 * We need data structures for the function definitions, the entry
 * variables, the global variables, and the actual entries corresponding
 * to the cite-key list.  First we define the classes of `function's used.
 * Functions in all classes are of |bst_fn_ilk| except for |int_literal|s,
 * which are of |integer_ilk|; and |str_literal|s, which are of
 * |text_ilk|.
 ***************************************************************************/
#define BUILT_IN                    0
#define WIZ_DEFINED                 1
#define INT_LITERAL                 2
#define STR_LITERAL                 3
#define FIELD                       4
#define INT_ENTRY_VAR               5
#define STR_ENTRY_VAR               6
#define INT_GLOBAL_VAR              7
#define STR_GLOBAL_VAR              8
#define LAST_FN_CLASS               8

/***************************************************************************
 * WEB section number:  160
 * ~~~~~~~~~~~~~~~~~~~
 * Besides the function classes, we have types based on \BibTeX's
 * capacity limitations and one based on what can go into the array
 * |wiz_functions| explained below.
 ***************************************************************************/
#define QUOTE_NEXT_FN               (HASH_BASE - 1)
#define END_OF_DEF                  (HASH_MAX + 1)

/***************************************************************************
 * WEB section number:  161
 * ~~~~~~~~~~~~~~~~~~~
 * We store information about the \.{.bst} functions in arrays the same
 * size as the hash-table arrays and in locations corresponding to their
 * hash-table locations.  The two arrays |fn_info| (an alias of
 * |ilk_info| described earlier) and |fn_type| accomplish this: |fn_type|
 * specifies one of the above classes, and |fn_info| gives information
 * dependent on the class.
 ***************************************************************************/
#define FN_INFO                     ilk_info
#define MISSING                     EMPTY

/***************************************************************************
 * WEB section number:  166
 * ~~~~~~~~~~~~~~~~~~~
 * This macro is used to scan all .bst identifiers. The argument supplies
 * .bst command name. The associated procedure simply prints an error
 * message.
 ***************************************************************************/
#define BST_IDENTIFIER_SCAN(X)      {\
        scan_identifier (RIGHT_BRACE, COMMENT, COMMENT);\
        if ((scan_result == WHITE_ADJACENT) \
            || (scan_result == SPECIFIED_CHAR_ADJACENT)) {DO_NOTHING;}\
        else {bst_id_print(); BST_ERR(X)}}

/***************************************************************************
 * WEB section number:  167
 * ~~~~~~~~~~~~~~~~~~~
 * This macro just makes sure we're at a |left_brace|.
 ***************************************************************************/
#define BST_GET_AND_CHECK_LEFT_BRACE(X) {\
        if (SCAN_CHAR != LEFT_BRACE) \
                {bst_left_brace_print(); BST_ERR(X);}\
        INCR (buf_ptr2);}

/***************************************************************************
 * WEB section number:  168
 * ~~~~~~~~~~~~~~~~~~~
 * This macro just makes sure we're at a |right_brace|.
 ***************************************************************************/
#define BST_GET_AND_CHECK_RIGHT_BRACE(X)        {\
        if (SCAN_CHAR != RIGHT_BRACE) \
                {bst_right_brace_print(); BST_ERR(X);}\
        INCR (buf_ptr2);}

/***************************************************************************
 * WEB section number:  169
 * ~~~~~~~~~~~~~~~~~~~
 * This macro complains if we've already encountered a function to be
 * inserted into the hash table.
 ***************************************************************************/
#define CHECK_FOR_ALREADY_SEEN_FUNCTION(X)      {\
        if (hash_found) {\
            already_seen_function_print(X);\
            goto Exit_Label;}}

/***************************************************************************
 * WEB section number:  183
 * ~~~~~~~~~~~~~~~~~~~
 * We're about to start scanning tokens in a function definition.  When a
 * function token is illegal, we skip until it ends; a |white_space|
 * character, an end-of-line, a |right_brace|, or a |comment| marks the
 * end of the current token.
 ***************************************************************************/
#define SKIP_TOKEN(X)               {\
            PRINT (X);\
            skip_token_print ();\
            goto Next_Token_Label;}
#define SKIP_TOKEN2(X, Y)           {\
            PRINT2 (X, Y);\
            skip_token_print ();\
            goto Next_Token_Label;}

/***************************************************************************
 * WEB section number:  184
 * ~~~~~~~~~~~~~~~~~~~
 * This macro is similar to the last one but is specifically for
 * recursion in a |wiz_defined| function, which is illegal; it helps save
 * space.
 ***************************************************************************/
#define SKIP_RECURSIVE_TOKEN        { print_recursion_illegal (); \
                                      goto Next_Token_Label;}

/***************************************************************************
 * WEB section number:  185
 * ~~~~~~~~~~~~~~~~~~~
 * Here's another macro for saving some space when there's a problem with
 * a token.
 ***************************************************************************/
#define SKIP_TOKEN_UNKNOWN_FUNCTION {skp_token_unknown_function_prin ();\
                                     goto Next_Token_Label;}

/***************************************************************************
 * WEB section number:  186
 * ~~~~~~~~~~~~~~~~~~~
 * And another.
 ***************************************************************************/
#define SKIP_TOKEN_ILLEGAL_STUFF_AFTER {\
            skip_illegal_stuff_after_token ();\
            goto Next_Token_Label;}

/***************************************************************************
 * WEB section number:  194
 * ~~~~~~~~~~~~~~~~~~~
 * This module marks the implicit function as being quoted, generates a
 * name, and stores it in the hash table.  This name is strictly internal
 * to this program, starts with a |single_quote| (since that will make
 * this function name unique), and ends with the variable |impl_fn_num|
 * converted to ASCII.  The alias kludge helps make the stack space not
 * overflow on some machines.
 ***************************************************************************/
#define EX_BUF2                     ex_buf

/***************************************************************************
 * WEB section number:  197
 * ~~~~~~~~~~~~~~~~~~~
 * This module appends a character to |int_buf| after checking to make
 * sure it will fit; for use in |int_to_ASCII|.
 ***************************************************************************/
#define APPEND_INT_CHAR(X)          {\
            if (int_ptr == Buf_Size)\
                { buffer_overflow ();}\
            int_buf[int_ptr] = (X);\
            INCR (int_ptr); }

/***************************************************************************
 * WEB section number:  216
 * ~~~~~~~~~~~~~~~~~~~
 * Here we insert the just found |int_global_var| name into the hash
 * table and record it as an |int_global_var|.  Also, we initialize it by
 * setting |fn_info[fn_loc]| to 0.
 ***************************************************************************/
#define END_OF_STRING               INVALID_CODE

/***************************************************************************
 * WEB section number:  219
 * ~~~~~~~~~~~~~~~~~~~
 * These global variables are used ...
 ***************************************************************************/
#define UNDEFINED                   (HASH_MAX + 1)

/***************************************************************************
 * WEB section number:  221
 * ~~~~~~~~~~~~~~~~~~~
 * When there's a serious error parsing a \.{.bib} file, we flush
 * everything up to the beginning of the next entry.
 ***************************************************************************/
#define BIB_ERR(X)                  {\
            PRINT (X);\
            bib_err_print ();\
            goto Exit_Label;}
#define BIB_ERR2(X, Y)              {\
            PRINT2 (X, Y);\
            bib_err_print ();\
            goto Exit_Label;}
#define BIB_ERR3(X, Y, Z)                   {\
            PRINT3 (X, Y, Z);\
            bib_err_print ();\
            goto Exit_Label;}

/***************************************************************************
 * WEB section number:  222
 * ~~~~~~~~~~~~~~~~~~~
 * When there's a harmless error parsing a \.{.bib} file, we just give a
 * warning message.  This is always called after other stuff has been
 * printed out.
 ***************************************************************************/
#define BIB_WARN(X)                 {\
            PRINT (X);\
            bib_warn_print ();}
#define BIB_WARN_NEWLINE(X)         {\
            PRINT_LN (X);\
            bib_warn_print ();}

/***************************************************************************
 * WEB section number:  229
 * ~~~~~~~~~~~~~~~~~~~
 * It's often illegal to end a \.{.bib} command in certain places, and
 * this is where we come to check.
 ***************************************************************************/
#define EAT_BIB_WHITE_AND_EOF_CHECK {\
            if (! eat_bib_white_space())\
                {eat_bib_print();\
                goto Exit_Label;}}

/***************************************************************************
 * WEB section number:  230
 * ~~~~~~~~~~~~~~~~~~~
 * And here are a bunch of error-message macros, each called more than
 * once, that thus save space as implemented.  This one is for when one
 * of two possible characters is expected while scanning.
 ***************************************************************************/
#define BIB_ONE_OF_TWO_EXPECTED_ERR(X, Y)       {\
            bib_one_of_two_print (X, Y);\
            goto Exit_Label;}

/***************************************************************************
 * WEB section number:  231
 * ~~~~~~~~~~~~~~~~~~~
 * This one's for an unexpected equals sign.
 ***************************************************************************/
#define BIB_EQUALS_SIGN_EXPECTED_ERR    {\
            bib_equals_sign_print ();\
            goto Exit_Label;}

/***************************************************************************
 * WEB section number:  232
 * ~~~~~~~~~~~~~~~~~~~
 * This complains about unbalanced braces.
 ***************************************************************************/
#define BIB_UNBALANCED_BRACES_ERR       {\
            bib_unbalanced_braces_print ();\
            goto Exit_Label;}

/***************************************************************************
 * WEB section number:  233
 * ~~~~~~~~~~~~~~~~~~~
 * And this one about an overly exuberant field.
 ***************************************************************************/
#define BIB_FIELD_TOO_LONG_ERR      {\
            bib_field_too_long_print ();\
            goto Exit_Label;}

/***************************************************************************
 * WEB section number:  234
 * ~~~~~~~~~~~~~~~~~~~
 * This one is just a warning, not an error.  It's for when something
 * isn't (or might not be) quite right with a macro name.
 ***************************************************************************/
#define MACRO_NAME_WARNING(X)       {\
            macro_warn_print ();\
            BIB_WARN_NEWLINE (X);}

/***************************************************************************
 * WEB section number:  235
 * ~~~~~~~~~~~~~~~~~~~
 * This macro is used to scan all \.{.bib} identifiers.  The argument
 * tells what was happening at the time.  The associated procedure simply
 * prints an error message.
 ***************************************************************************/
#define BIB_IDENTIFIER_SCAN_CHECK(X)    {\
            if ((scan_result == WHITE_ADJACENT) \
                || (scan_result == SPECIFIED_CHAR_ADJACENT)) {DO_NOTHING;}\
            else {bib_id_print(); BIB_ERR (X);}}

/***************************************************************************
 * WEB section number:  247
 * ~~~~~~~~~~~~~~~~~~~
 * The variables for the function
 * |scan_and_store_the_field_value_and_eat_white| must be global since
 * the functions it calls use them too.  The alias kludge helps make the
 * stack space not overflow on some machines.
 ***************************************************************************/
#define FIELD_VL_STR                ex_buf
#define FIELD_END                   ex_buf_ptr
#define FIELD_START                 ex_buf_xptr

/***************************************************************************
 * WEB section number:  251
 * ~~~~~~~~~~~~~~~~~~~
 * Now we come to the stuff that actually accumulates the field value to
 * be stored.  This module copies a character into |field_vl_str| if it
 * will fit; since it's so low level, it's implemented as a macro.
 ***************************************************************************/
#define COPY_CHAR(X)                {\
            if (FIELD_END == Buf_Size)\
                { BIB_FIELD_TOO_LONG_ERR; }\
            else\
                { FIELD_VL_STR[FIELD_END] = (X);\
                INCR (FIELD_END);}}

/***************************************************************************
 * WEB section number:  252
 * ~~~~~~~~~~~~~~~~~~~
 * The \.{.bib}-specific scanning function |compress_bib_white| skips
 * over |white_space| characters within a string until hitting a nonwhite
 * character; in fact, it does everything |eat_bib_white_space| does, but
 * it also adds a |space| to |field_vl_str|.  This function is never
 * called if there are no |white_space| characters (or ends-of-line) to
 * be scanned (though the associated macro might be).  The function
 * returns |false| if there is a serious syntax error.
 ***************************************************************************/
#define CHECK_FOR_AND_COMPRESS_BIB_WHIT {\
            if ((lex_class[SCAN_CHAR] == WHITE_SPACE) || (buf_ptr2 == last)){\
                if (! compress_bib_white ()) { goto Exit_Label;}}}

/***************************************************************************
 * WEB section number:  264
 * ~~~~~~~~~~~~~~~~~~~
 * If the cross-referenced entry isn't already on |cite_list| we add it
 * (at least temporarily); if it is already on |cite_list| we update the
 * cross-reference count, if necessary.  Note that |all_entries| is
 * |false| here.  The alias kludge helps make the stack space not
 * overflow on some machines.
 ***************************************************************************/
#define EXTRA_BUF                   out_buf

/***************************************************************************
 * WEB section number:  267
 * ~~~~~~~~~~~~~~~~~~~
 * The lower-case version of this database key must correspond to one in
 * |cite_list|, or else |all_entries| must be |true|, if this entry is to
 * be included in the reference list.  Accordingly, this module sets
 * |store_entry|, which determines whether the relevant information for
 * this entry is stored.  The alias kludge helps make the stack space not
 * overflow on some machines.
 ***************************************************************************/
#define EX_BUF3                     ex_buf

/***************************************************************************
 * WEB section number:  270
 * ~~~~~~~~~~~~~~~~~~~
 * This module, a simpler version of the
 * |find_cite_locs_for_this_cite_key| function, exists primarily to
 * compute |lc_xcite_loc|.  When this code is executed we have
 * |(all_entries) and (entry_cite_ptr >= all_marker) and (not
 * entry_exists[entry_cite_ptr])|.  The alias kludge helps make the stack
 * space not overflow on some machines.
 ***************************************************************************/
#define EX_BUF4                     ex_buf
#define EX_BUF4_PTR                 ex_buf_ptr

/***************************************************************************
 * WEB section number:  277
 * ~~~~~~~~~~~~~~~~~~~
 * Occasionally we need to figure out the hash-table location of a given
 * cite-key string and its lower-case equivalent.  This function does
 * that.  To perform the task it needs to borrow a buffer, a need that
 * gives rise to the alias kludge---it helps make the stack space not
 * overflow on some machines (and while it's at it, it'll borrow a
 * pointer, too).  Finally, the function returns |true| if the cite key
 * exists on |cite_list|, and its sets |cite_hash_found| according to
 * whether or not it found the actual version (before |lower_case|ing) of
 * the cite key; however, its {\sl raison d'\^$\mkern-8mu$etre\/}
 * (literally, ``to eat a raisin'') is to compute |cite_loc| and
 * |lc_cite_loc|.
 ***************************************************************************/
#define EX_BUF5                     ex_buf
#define EX_BUF5_PTR                 ex_buf_ptr

/***************************************************************************
 * WEB section number:  289
 * ~~~~~~~~~~~~~~~~~~~
 * The array |sorted_cites| initially specifies that the entries are to
 * be processed in order of cite-key occurrence.  The \.{sort} command
 * may change this to whatever it likes (which, we hope, is whatever the
 * style-designer instructs it to like).  We make |sorted_cites| an alias
 * to save space; this works fine because we're done with |cite_info|.
 ***************************************************************************/
#define SORTED_CITES                cite_info

/***************************************************************************
 * WEB section number:  291
 * ~~~~~~~~~~~~~~~~~~~
 * Where |lit_stk_loc| is a stack location, and where |stk_type| gives
 * one of the three types of literals (an integer, a string, or a
 * function) or a special marker.  If a |lit_stk_type| element is a
 * |stk_int| then the corresponding |lit_stack| element is an integer; if
 * a |stk_str|, then a pointer to a |str_pool| string; and if a |stk_fn|,
 * then a pointer to the function's hash-table location.  However, if the
 * literal should have been a |stk_str| that was the value of a field
 * that happened to be |missing|, then the special value
 * |stk_field_missing| goes on the stack instead; its corresponding
 * |lit_stack| element is a pointer to the field-name's string.  Finally,
 * |stk_empty| is the type of a literal popped from an empty stack.
 ***************************************************************************/
#define STK_INT                     0
#define STK_STR                     1
#define STK_FN                      2
#define STK_FIELD_MISSING           3
#define STK_EMPTY                   4
#define LAST_LIT_TYPE               4

/***************************************************************************
 * WEB section number:  293
 * ~~~~~~~~~~~~~~~~~~~
 * When there's an error while executing \.{.bst} functions, what we do
 * depends on whether the function is messing with the entries.
 * Furthermore this error is serious enough to classify as an
 * |error_message| instead of a |warning_message|.  These messages (that
 * is, from |bst_ex_warn|) are meant both for the user and for the style
 * designer while debugging.
 ***************************************************************************/
#define BST_EX_WARN(X)              {\
            PRINT (X); bst_ex_warn_print ();}
#define BST_EX_WARN2(X, Y)          {\
            PRINT2 (X, Y); bst_ex_warn_print ();}

/***************************************************************************
 * WEB section number:  294
 * ~~~~~~~~~~~~~~~~~~~
 * When an error is so harmless, we print a warning message instead of an
 * error message.
 ***************************************************************************/
#define BST_MILD_EX_WARN(X)                 {\
            PRINT (X); bst_mild_ex_warn_print ();}

/***************************************************************************
 * WEB section number:  301
 * ~~~~~~~~~~~~~~~~~~~
 * The function |less_than| compares the two \.{sort.key\$}s indirectly
 * pointed to by its arguments and returns |true| if the first argument's
 * \.{sort.key\$} is lexicographically less than the second's (that is,
 * alphabetically earlier).  In case of ties the function compares the
 * indices |arg1| and |arg2|, which are assumed to be different, and
 * returns |true| if the first is smaller.  This function uses
 * |ASCII_code|s to compare, so it might give ``interesting'' results
 * when handling nonletters.
 ***************************************************************************/
#define COMPARE_RETURN(X)           {\
            less_than = (X);\
            goto Exit_Label;}

/***************************************************************************
 * WEB section number:  302
 * ~~~~~~~~~~~~~~~~~~~
 * The recursive procedure |quick_sort| sorts ...
 ***************************************************************************/
#define SHORT_LIST                  10
#define END_OFFSET                  4

/***************************************************************************
 * WEB section number:  308
 * ~~~~~~~~~~~~~~~~~~~
 * This macro pushes the last thing, necessarily a string, that was
 * popped.  And this module, along with others that push the literal
 * stack without explicitly calling |push_lit_stack|, have an index entry
 * under ``push the literal stack''; these implicit pushes collectively
 * speed up the program by about ten percent.
 ***************************************************************************/
#define REPUSH_STRING               {\
            if (lit_stack[lit_stk_ptr] >= cmd_str_ptr)\
                { UNFLUSH_STRING; }\
            INCR (lit_stk_ptr);}

/***************************************************************************
 * WEB section number:  319
 * ~~~~~~~~~~~~~~~~~~~
 * These macros append a character to |ex_buf|.  Which is called depends
 * on whether the character is known to fit.
 ***************************************************************************/
#define APPEND_EX_BUF_CHAR(X)       {\
            ex_buf[ex_buf_ptr] = (X);\
            INCR(ex_buf_ptr);}
#define APPEND_EX_BUF_CHAR_AND_CHECK(X)    {\
            if (ex_buf_ptr == Buf_Size) {buffer_overflow ();}; \
            APPEND_EX_BUF_CHAR(X)}

/***************************************************************************
 * WEB section number:   333
 * ~~~~~~~~~~~~~~~~~~~
 * These constants all begin with |n_| and are used for the |case|
 * statement that determines which |built_in| function to execute.
 ***************************************************************************/
#define N_EQUALS                    0
#define N_GREATER_THAN              1
#define N_LESS_THAN                 2
#define N_PLUS                      3
#define N_MINUS                     4
#define N_CONCATENATE               5
#define N_GETS                      6
#define N_ADD_PERIOD                7
#define N_CALL_TYPE                 8
#define N_CHANGE_CASE               9
#define N_CHR_TO_INT                10
#define N_CITE                      11
#define N_DUPLICATE                 12
#define N_EMPTY                     13
#define N_FORMAT_NAME               14
#define N_IF                        15
#define N_INT_TO_CHR                16
#define N_INT_TO_STR                17
#define N_MISSING                   18
#define N_NEWLINE                   19
#define N_NUM_NAMES                 20
#define N_POP                       21
#define N_PREAMBLE                  22
#define N_PURIFY                    23
#define N_QUOTE                     24
#define N_SKIP                      25
#define N_STACK                     26
#define N_SUBSTRING                 27
#define N_SWAP                      28
#define N_TEXT_LENGTH               29
#define N_TEXT_PREFIX               30
#define N_TOP_STACK                 31
#define N_TYPE                      32
#define N_WARNING                   33
#define N_WHILE                     34
#define N_WIDTH                     35
#define N_WRITE                     36
#define NUM_BLT_IN_FNS              37

/***************************************************************************
 * WEB section number:  338
 * ~~~~~~~~~~~~~~~~~~~
 * These constants all begin with |n_| and are used for the |case|
 * statement that determines which, if any, control sequence we're
 * dealing with; a control sequence of interest will be either one of the
 * undotted characters `\.{\\i}' or `\.{\\j}' or one of the foreign
 * characters in Table~3.2 of the \LaTeX\ manual.
 ***************************************************************************/
#define N_I                         0
#define N_J                         1
#define N_OE                        2
#define N_OE_UPPER                  3
#define N_AE                        4
#define N_AE_UPPER                  5
#define N_AA                        6
#define N_AA_UPPER                  7
#define N_O                         8
#define N_O_UPPER                   9
#define N_L                         10
#define N_L_UPPER                   11
#define N_SS                        12

/***************************************************************************
 * WEB section number:  344
 * ~~~~~~~~~~~~~~~~~~~
 * These are nonrecursive variables that |execute_fn| uses.  Declaring
 * them here (instead of in the previous module) saves execution time and
 * stack space on most machines.
 ***************************************************************************/
#define NAME_BUF                    sv_buffer

/***************************************************************************
 * WEB section number:  356
 * ~~~~~~~~~~~~~~~~~~~
 * It's time for a complaint if either of the two (entry or global) string
 * lengths is exceeded.
 ***************************************************************************/
#define BST_STRING_SIZE_EXCEEDED(X, Y)  {\
            bst_1print_string_size_exceeded ();\
            PRINT3 ("%ld%s", (long) (X), Y);\
            bst_2print_string_size_exceeded ();}

/***************************************************************************
 * WEB section number:  365
 * ~~~~~~~~~~~~~~~~~~~
 * First we define a few variables for case conversion.  The constant
 * definitions, to be used in |case| statements, are in order of probable
 * frequency.
 ***************************************************************************/
#define TITLE_LOWERS                0
#define ALL_LOWERS                  1
#define ALL_UPPERS                  2
#define BAD_CONVERSION              3

/***************************************************************************
 * WEB section number:  397
 * ~~~~~~~~~~~~~~~~~~~
 * It's a von token if there exists a first brace-level-0 letter (or
 * brace-level-1 special character), and it's in lower case; in this case
 * we return |true|.  The token is in |name_buf|, starting at
 * |name_bf_ptr| and ending just before |name_bf_xptr|.
 ***************************************************************************/
#define RETURN_VON_FOUND            {\
            von_token_found = TRUE;\
            goto Exit_Label;}

/***************************************************************************
 * WEB section number:  417
 * ~~~~~~~~~~~~~~~~~~~
 * Here we output either the \.{.bst} given string if it exists, or else
 * the \.{.bib} |sep_char| if it exists, or else the default string.  A
 * |tie| is the default space character between the last two tokens of
 * the name part, and between the first two tokens if the first token is
 * short enough; otherwise, a |space| is the default.
 ***************************************************************************/
#define LONG_TOKEN                  3

/***************************************************************************
 * WEB section number:  419
 * ~~~~~~~~~~~~~~~~~~~
 * If the last character output for this name part is a |tie| but the
 * previous character it isn't, we're dealing with a discretionary |tie|;
 * thus we replace it by a |space| if there are enough characters in the
 * rest of the name part.
 ***************************************************************************/
#define LONG_NAME                   3

/***************************************************************************
 * WEB section number:  465
 * ~~~~~~~~~~~~~~~~~~~
 * These statistics can help determine how large some of the constants
 * should be and can tell how useful certain |built_in| functions are.
 * They are written to the same files as tracing information.
 ***************************************************************************/
#define STAT_PR                     TRACE_PR
#define STAT_PR2                    TRACE_PR2
#define STAT_PR3                    TRACE_PR3

#define STAT_PR_LN                  TRACE_PR_LN
#define STAT_PR_LN2                 TRACE_PR_LN2
#define STAT_PR_LN3                 TRACE_PR_LN3

#define STAT_PR_POOL_STR            TRACE_PR_POOL_STR


/***************************************************************************
 * WEB section number:  N/A
 * ~~~~~~~~~~~~~~~~~~~
 * C isn't very good at declaring two dimensional arrays whose sizes are
 * determined at run time.  Here we create a useful macro to simulate
 * accessing a 2D array by converting the row/col into an offset from the
 * beginning of a 1D array.
 ***************************************************************************/
#define ENTRY_STRS(_r,_c)       entry_strs[(_r * (Ent_Str_Size+1)) + _c]
#define GLOBAL_STRS(_r,_c)      global_strs[(_r * (Glob_Str_Size+1)) + _c]


/***************************************************************************
 * WEB section number:  N/A
 * ~~~~~~~~~~~~~~~~~~~
 * Define a macro to handle 1-, 2-, 3-, and 4-byte UTF-8 codes.
 ***************************************************************************/
#define DO_UTF8(ch, do_1, do_2, do_3, do_4) \
  if (ch <= 0x7F) { do_1; } \
  else if ((ch >= 0xC2) && (ch <= 0xDF)) { do_2; } \
  else if ((ch >= 0xE0) && (ch <= 0xEF)) { do_3; } \
  else if ((ch >= 0xF0) && (ch <= 0xF4)) { do_4; } \
  else printf("this isn't a right UTF-8 char!\n")


/***************************************************************************
 * WEB section number:  N/A
 * ~~~~~~~~~~~~~~~~~~~
 * Macros adapted from Kpathsea (lib.h) and Web2C (cpascal.h) to dynamically
 * resize arrays.
 ***************************************************************************/
/* Reallocate N items of type T for ARRAY using myrealloc.  */
#define MYRETALLOC(array, addr, n, t) ((addr) = (t *) myrealloc(addr, (n) * sizeof(t), array))
/* BibTeX needs this to dynamically reallocate arrays.  Too bad we can't
   rely on stringification, or we could avoid the ARRAY_NAME arg.
   Actually allocate one more than requests, so we can index the last
   entry, as Pascal wants to do.  */
#define BIB_XRETALLOC_NOSET(array_name, array_var, type, size_var, new_size) \
  if (log_file != NULL)\
    fprintf (log_file, "Reallocated %s (elt_size=%d) to %ld items from %ld.\n", \
             array_name, (int) sizeof (type), new_size, size_var); \
  MYRETALLOC (array_name, array_var, new_size + 1, type)
/* Same as above, but also increase SIZE_VAR for the last (or only) array.  */
#define BIB_XRETALLOC(array_name, array_var, type, size_var, new_size) do { \
  BIB_XRETALLOC_NOSET(array_name, array_var, type, size_var, new_size); \
  size_var = new_size; \
} while (0)
/* Same as above, but for the pseudo-TYPE ASCIICode_T[LENGTH+1].  */
#define BIB_XRETALLOC_STRING(array_name, array_var, length, size_var, new_size) \
  if (log_file != NULL)\
    fprintf (log_file, "Reallocated %s (elt_size=%d) to %ld items from %ld.\n", \
             array_name, (int) (length + 1), new_size, size_var); \
  MYRETALLOC (array_name, array_var, (new_size) * (length + 1), ASCIICode_T)

#endif                          /* __BIBTEX_H__ */

