summaryrefslogtreecommitdiff
path: root/Build/source/texk/bibtexu/bibtex.h
diff options
context:
space:
mode:
authorPeter Breitenlohner <peb@mppmu.mpg.de>2013-03-19 12:41:14 +0000
committerPeter Breitenlohner <peb@mppmu.mpg.de>2013-03-19 12:41:14 +0000
commitcf03be0bec33856ec8d7264260f5be52badb330a (patch)
tree11cc591bdcb10d71fd581083af531305b18ab025 /Build/source/texk/bibtexu/bibtex.h
parentec18b43c24d72b1722bb939706424e0d6e92de25 (diff)
Merge texk/bibtex8/ into texk/bibtex-x/.
git-svn-id: svn://tug.org/texlive/trunk@29434 c570f23f-e606-0410-a88d-b1316a301751
Diffstat (limited to 'Build/source/texk/bibtexu/bibtex.h')
-rw-r--r--Build/source/texk/bibtexu/bibtex.h1506
1 files changed, 0 insertions, 1506 deletions
diff --git a/Build/source/texk/bibtexu/bibtex.h b/Build/source/texk/bibtexu/bibtex.h
deleted file mode 100644
index c1c65d4fc09..00000000000
--- a/Build/source/texk/bibtexu/bibtex.h
+++ /dev/null
@@ -1,1506 +0,0 @@
-/*-
-******************************************************************************
-******************************************************************************
-**
-** 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__ */
-