zeroc-ice 3.6b1

data/ext/ice/mcpp/directive.c

@@ -0,0 +1,1699 @@
+/*-
+ * Copyright (c) 1998, 2002-2008 Kiyoshi Matsui <kmatsui@t3.rim.or.jp>
+ * All rights reserved.
+ *
+ * Some parts of this code are derived from the public domain software
+ * DECUS cpp (1984,1985) written by Martin Minow.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/*
+ *                          D I R E C T I V E . C
+ *              P r o c e s s   D i r e c t i v e  L i n e s
+ *
+ * The routines to handle directives other than #include and #pragma
+ * are placed here.
+ */
+
+#if PREPROCESSED
+#include    "mcpp.H"
+#else
+#include    "system.H"
+#include    "internal.H"
+#endif
+
+static int      do_if( int hash, const char * directive_name);
+                /* #if, #elif, #ifdef, #ifndef      */
+static void     sync_linenum( void);
+                /* Synchronize number of newlines   */
+static long     do_line( void);
+                /* Process #line directive          */
+static int      get_parm( void);
+                /* Get parameters of macro, its nargs, names, lengths       */
+static int      get_repl( const char * macroname);
+                /* Get replacement text embedding parameter number  */
+static char *   is_formal( const char * name, int conv);
+                /* If formal parameter, save the number     */
+static char *   def_stringization( char * repl_cur);
+                /* Define stringization     */
+static char *   mgtoken_save( const char * macroname);
+                /* Prefix DEF_MAGIC to macro name in repl-text      */
+static char *   str_parm_scan( char * string_end);
+                /* Scan the parameter in quote      */
+static void     do_undef( void);
+                /* Process #undef directive         */
+static void     dump_repl( const DEFBUF * dp, FILE * fp, int gcc2_va);
+                /* Dump replacement text            */
+
+/*
+ * Generate (by hand-inspection) a set of unique values for each directive.
+ * MCPP won't compile if there are hash conflicts.
+ */
+#define L_if            ('i' ^ (EOS << 1))
+#define L_ifdef         ('i' ^ ('d' << 1))
+#define L_ifndef        ('i' ^ ('n' << 1))
+#define L_elif          ('e' ^ ('i' << 1))
+#define L_else          ('e' ^ ('s' << 1))
+#define L_endif         ('e' ^ ('d' << 1))
+#define L_define        ('d' ^ ('f' << 1))
+#define L_undef         ('u' ^ ('d' << 1))
+#define L_line          ('l' ^ ('n' << 1))
+#define L_include       ('i' ^ ('c' << 1))
+#if COMPILER == GNUC
+#define L_include_next  ('i' ^ ('c' << 1) ^ ('_' << 1))
+#endif
+#if SYSTEM == SYS_MAC
+#define L_import        ('i' ^ ('p' << 1))
+#endif
+#define L_error         ('e' ^ ('r' << 1))
+#define L_pragma        ('p' ^ ('a' << 1))
+
+static const char * const   not_ident
+            = "Not an identifier \"%s\"";               /* _E_      */
+static const char * const   no_arg = "No argument";     /* _E_      */
+static const char * const   excess
+            = "Excessive token sequence \"%s\"";        /* _E_ _W1_ */
+
+void    directive( void)
+/*
+ * Process #directive lines.  Each directive have their own subroutines.
+ */
+{
+    const char * const  many_nesting =
+"More than %.0s%ld nesting of #if (#ifdef) sections%s"; /* _F_ _W4_ _W8_    */
+    const char * const  not_in_section
+    = "Not in a #if (#ifdef) section in a source file"; /* _E_ _W1_ */
+    const char * const  illeg_dir
+            = "Illegal #directive \"%s%.0ld%s\"";       /* _E_ _W1_ _W8_    */
+    const char * const  in_skipped = " (in skipped block)"; /* _W8_ */
+    FILEINFO *  file;
+    int     token_type;
+    int     hash;
+    int     c;
+    char *  tp;
+
+    in_directive = TRUE;
+    if (keep_comments) {
+        mcpp_fputc( '\n', OUT);     /* Possibly flush out comments  */
+        newlines--;
+    }
+    c = skip_ws();
+    if (c == '\n')                              /* 'null' directive */
+        goto  ret;
+    token_type = scan_token( c, (workp = work_buf, &workp), work_end);
+    if (in_asm && (token_type != NAM
+            || (! str_eq( identifier, "asm")
+                && ! str_eq( identifier, "endasm"))))
+        /* In #asm block, ignore #anything other than #asm or #endasm       */
+        goto  skip_line;
+    if (token_type != NAM) {
+        if (mcpp_mode == OLD_PREP && token_type == NUM) {   /* # 123 [fname]*/
+            strcpy( identifier, "line");
+        } else {
+            if (compiling) {
+                if (option_flags.lang_asm) {
+                    if (warn_level & 1)
+                        cwarn( illeg_dir, work_buf, 0L, NULL);
+                } else {
+                    cerror( illeg_dir, work_buf, 0L, NULL);
+                }
+            } else if (warn_level & 8) {
+                cwarn( illeg_dir, work_buf, 0L, in_skipped);
+            }
+            goto  skip_line;
+        }
+    }
+    hash = (identifier[ 1] == EOS) ? identifier[ 0]
+            : (identifier[ 0] ^ (identifier[ 2] << 1));
+    if (strlen( identifier) > 7)
+        hash ^= (identifier[ 7] << 1);
+
+    /* hash is set to a unique value corresponding to the directive.*/
+    switch (hash) {
+    case L_if:      tp = "if";      break;
+    case L_ifdef:   tp = "ifdef";   break;
+    case L_ifndef:  tp = "ifndef";  break;
+    case L_elif:    tp = "elif";    break;
+    case L_else:    tp = "else";    break;
+    case L_endif:   tp = "endif";   break;
+    case L_define:  tp = "define";  break;
+    case L_undef:   tp = "undef";   break;
+    case L_line:    tp = "line";    break;
+    case L_include: tp = "include"; break;
+#if COMPILER == GNUC
+    case L_include_next:    tp = "include_next";    break;
+#endif
+#if SYSTEM == SYS_MAC
+    case L_import:  tp = "import";  break;
+#endif
+    case L_error:   tp = "error";   break;
+    case L_pragma:  tp = "pragma";  break;
+    default:        tp = NULL;      break;
+    }
+
+    if (tp != NULL && ! str_eq( identifier, tp)) {  /* Hash conflict*/
+        hash = 0;                       /* Unknown directive, will  */
+        tp = NULL;                      /*   be handled by do_old() */
+    }
+
+    if (! compiling) {                      /* Not compiling now    */
+        switch (hash) {
+        case L_elif :
+            if (! standard) {
+                if (warn_level & 8)
+                    do_old();               /* Unknown directive    */
+                goto  skip_line;            /* Skip the line        */
+            }   /* Else fall through    */
+        case L_else :       /* Test the #if's nest, if 0, compile   */
+        case L_endif:                       /* Un-nest #if          */
+            break;
+        case L_if   :                       /* These can't turn     */
+        case L_ifdef:                       /*  compilation on, but */
+        case L_ifndef   :                   /*   we must nest #if's.*/
+            if (&ifstack[ BLK_NEST] < ++ifptr)
+                goto  if_nest_err;
+            if (standard && (warn_level & 8)
+                    && &ifstack[ std_limits.blk_nest + 1] == ifptr)
+                cwarn( many_nesting, NULL, (long) std_limits.blk_nest
+                        , in_skipped);
+            ifptr->stat = 0;                /* !WAS_COMPILING       */
+            ifptr->ifline = src_line;       /* Line at section start*/
+            goto  skip_line;
+        default :                           /* Other directives     */
+            if (tp == NULL && (warn_level & 8))
+                do_old();                   /* Unknown directive ?  */
+            goto  skip_line;                /* Skip the line        */
+        }
+    }
+
+    macro_line = 0;                         /* Reset error flag     */
+    file = infile;                  /* Remember the current file    */
+
+    switch (hash) {
+
+    case L_if:
+    case L_ifdef:
+    case L_ifndef:
+        if (&ifstack[ BLK_NEST] < ++ifptr)
+            goto  if_nest_err;
+        if (standard && (warn_level & 4) &&
+                &ifstack[ std_limits.blk_nest + 1] == ifptr)
+            cwarn( many_nesting, NULL , (long) std_limits.blk_nest, NULL);
+        ifptr->stat = WAS_COMPILING;
+        ifptr->ifline = src_line;
+        goto  ifdo;
+
+    case L_elif:
+        if (! standard) {
+            do_old();               /* Unrecognized directive       */
+            break;
+        }
+        if (ifptr == &ifstack[0])
+            goto  nest_err;
+        if (ifptr == infile->initif) {
+            goto  in_file_nest_err;
+        }
+        if (ifptr->stat & ELSE_SEEN)
+            goto  else_seen_err;
+        if ((ifptr->stat & (WAS_COMPILING | TRUE_SEEN)) != WAS_COMPILING) {
+            compiling = FALSE;              /* Done compiling stuff */
+            goto  skip_line;                /* Skip this group      */
+        }
+        hash = L_if;
+ifdo:
+        c = do_if( hash, tp);
+        if (mcpp_debug & IF) {
+            mcpp_fprintf( DBG
+                    , "#if (#elif, #ifdef, #ifndef) evaluate to %s.\n"
+                    , compiling ? "TRUE" : "FALSE");
+            mcpp_fprintf( DBG, "line %ld: %s", src_line, infile->buffer);
+        }
+        if (c == FALSE) {                   /* Error                */
+            compiling = FALSE;              /* Skip this group      */
+            goto  skip_line;    /* Prevent an extra error message   */
+        }
+        break;
+
+    case L_else:
+        if (ifptr == &ifstack[0])
+            goto  nest_err;
+        if (ifptr == infile->initif) {
+            if (standard)
+                goto  in_file_nest_err;
+            else if (warn_level & 1)
+                cwarn( not_in_section, NULL, 0L, NULL);
+        }
+        if (ifptr->stat & ELSE_SEEN)
+            goto  else_seen_err;
+        ifptr->stat |= ELSE_SEEN;
+        ifptr->elseline = src_line;
+        if (ifptr->stat & WAS_COMPILING) {
+            if (compiling || (ifptr->stat & TRUE_SEEN) != 0)
+                compiling = FALSE;
+            else
+                compiling = TRUE;
+        }
+        if ((mcpp_debug & MACRO_CALL) && (ifptr->stat & WAS_COMPILING)) {
+            sync_linenum();
+            mcpp_fprintf( OUT, "/*else %ld:%c*/\n", src_line
+                    , compiling ? 'T' : 'F');   /* Show that #else is seen  */
+        }
+        break;
+
+    case L_endif:
+        if (ifptr == &ifstack[0])
+            goto  nest_err;
+        if (ifptr <= infile->initif) {
+            if (standard)
+                goto  in_file_nest_err;
+            else if (warn_level & 1)
+                cwarn( not_in_section, NULL, 0L, NULL);
+        }
+        if (! compiling && (ifptr->stat & WAS_COMPILING))
+            wrong_line = TRUE;
+        compiling = (ifptr->stat & WAS_COMPILING);
+        if ((mcpp_debug & MACRO_CALL) && compiling) {
+            sync_linenum();
+            mcpp_fprintf( OUT, "/*endif %ld*/\n", src_line);
+            /* Show that #if block has ended    */
+        }
+        --ifptr;
+        break;
+
+    case L_define:
+        do_define( FALSE, 0);
+        break;
+
+    case L_undef:
+        do_undef();
+        break;
+
+    case L_line:
+        if ((c = do_line()) > 0) {
+            src_line = c;
+            sharp( NULL, 0);    /* Putout the new line number and file name */
+            infile->line = --src_line;  /* Next line number is 'src_line'   */
+            newlines = -1;
+        } else {            /* Error already diagnosed by do_line() */
+            skip_nl();
+        }
+        break;
+
+    case L_include:
+        in_include = TRUE;
+        if (do_include( FALSE) == TRUE && file != infile)
+            newlines = -1;  /* File has been included. Clear blank lines    */
+        in_include = FALSE;
+        break;
+
+    case L_error:
+        if (! standard) {
+            do_old();               /* Unrecognized directive       */
+            break;
+        }
+        cerror( infile->buffer, NULL, 0L, NULL);            /* _E_  */
+        break;
+
+    case L_pragma:
+        if (! standard) {
+            do_old();               /* Unrecognized directive       */
+            break;
+        }
+        do_pragma();
+        newlines = -1;              /* Do not putout excessive '\n' */
+        break;
+
+    default:                /* Non-Standard or unknown directives   */
+        do_old();
+        break;
+    }
+
+    switch (hash) {
+    case L_if       :
+    case L_elif     :
+    case L_define   :
+    case L_line     :
+        goto  skip_line;    /* To prevent duplicate error message   */
+#if COMPILER == GNUC
+    case L_include_next  :
+        if (file != infile)             /* File has been included   */
+            newlines = -1;
+#endif
+#if SYSTEM == SYS_MAC
+    case L_import   :
+        if (file != infile)             /* File has been included   */
+            newlines = -1;
+#endif
+    case L_error    :
+        if (standard)
+            goto  skip_line;
+        /* Else fall through    */
+    case L_include  :
+    case L_pragma   :
+        if (standard)
+            break;          /* Already read over the line           */
+        /* Else fall through    */
+    default :               /* L_else, L_endif, L_undef, etc.       */
+        if (mcpp_mode == OLD_PREP) {
+        /*
+         * Ignore the rest of the #directive line so you can write
+         *          #if     foo
+         *          #endif  foo
+         */
+            ;
+        } else if (skip_ws() != '\n') {
+#if COMPILER == GNUC
+            if (standard && hash != L_endif)
+#else
+            if (standard)
+#endif
+                cerror( excess, infile->bptr-1, 0L, NULL);
+            else if (warn_level & 1)
+                cwarn( excess, infile->bptr-1, 0L, NULL);
+        }
+        skip_nl();
+    }
+    goto  ret;
+
+in_file_nest_err:
+    cerror( not_in_section, NULL, 0L, NULL);
+    goto  skip_line;
+nest_err:
+    cerror( "Not in a #if (#ifdef) section", NULL, 0L, NULL);       /* _E_  */
+    goto  skip_line;
+else_seen_err:
+    cerror( "Already seen #else at line %.0s%ld"            /* _E_  */
+            , NULL, ifptr->elseline, NULL);
+skip_line:
+    skip_nl();                              /* Ignore rest of line  */
+    goto  ret;
+
+if_nest_err:
+    cfatal( many_nesting, NULL, (long) BLK_NEST, NULL);
+
+ret:
+    in_directive = FALSE;
+    keep_comments = option_flags.c && compiling && !no_output;
+    keep_spaces = option_flags.k && compiling;
+       /* keep_spaces is on for #define line even if no_output is TRUE  */
+    if (! wrong_line)
+        newlines++;
+}
+
+static int  do_if( int hash, const char * directive_name)
+/*
+ * Process an #if (#elif), #ifdef or #ifndef.  The latter two are straight-
+ * forward, while #if needs a subroutine to evaluate the expression.
+ * do_if() is called only if compiling is TRUE.  If false, compilation is
+ * always supressed, so we don't need to evaluate anything.  This supresses
+ * unnecessary warnings.
+ */
+{
+    int     c;
+    int     found;
+    DEFBUF *    defp;
+
+    if ((c = skip_ws()) == '\n') {
+        unget_ch();
+        cerror( no_arg, NULL, 0L, NULL);
+        return  FALSE;
+    }
+    if (mcpp_debug & MACRO_CALL) {
+        sync_linenum();
+        mcpp_fprintf( OUT, "/*%s %ld*/", directive_name, src_line);
+    }
+    if (hash == L_if) {                 /* #if or #elif             */
+        unget_ch();
+        found = (eval_if() != 0L);      /* Evaluate expression      */
+        if (mcpp_debug & MACRO_CALL)
+            in_if = FALSE;      /* 'in_if' is dynamically set in eval_lex() */
+        hash = L_ifdef;                 /* #if is now like #ifdef   */
+    } else {                            /* #ifdef or #ifndef        */
+        if (scan_token( c, (workp = work_buf, &workp), work_end) != NAM) {
+            cerror( not_ident, work_buf, 0L, NULL);
+            return  FALSE;      /* Next token is not an identifier  */
+        }
+        found = ((defp = look_id( identifier)) != NULL);    /* Look in table*/
+        if (mcpp_debug & MACRO_CALL) {
+            if (found)
+                mcpp_fprintf( OUT, "/*%s*/", defp->name);
+        }
+    }
+    if (found == (hash == L_ifdef)) {
+        compiling = TRUE;
+        ifptr->stat |= TRUE_SEEN;
+    } else {
+        compiling = FALSE;
+    }
+    if (mcpp_debug & MACRO_CALL) {
+        mcpp_fprintf( OUT, "/*i %c*/\n", compiling ? 'T' : 'F');
+        /* Report wheather the directive is evaluated TRUE or FALSE */
+    }
+    return  TRUE;
+}
+
+static void sync_linenum( void)
+/*
+ * Put out newlines or #line line to synchronize line number with the
+ * annotations about #if, #elif, #ifdef, #ifndef, #else or #endif on -K option.
+ */
+{
+    if (wrong_line || newlines > 10) {
+        sharp( NULL, 0);
+    } else {
+        while (newlines-- > 0)
+            mcpp_fputc('\n', OUT);
+    }
+    newlines = -1;
+}
+
+static long do_line( void)
+/*
+ * Parse the line to update the line number and "filename" field for the next
+ * input line.
+ * Values returned are as follows:
+ *  -1:     syntax error or out-of-range error (diagnosed by do_line(),
+ *          eval_num()).
+ *  [1,32767]:  legal line number for C90, [1,2147483647] for C99.
+ * Line number [32768,2147483647] in C90 mode is only warned (not an error).
+ * do_line() always absorbs the line (except the <newline>).
+ */
+{
+    const char * const  not_digits
+        = "Line number \"%s\" isn't a decimal digits sequence"; /* _E_ _W1_ */
+    const char * const  out_of_range
+        = "Line number \"%s\" is out of range of [1,%ld]";      /* _E_ _W1_ */
+    int     token_type;
+    VAL_SIGN *      valp;
+    char *  save;
+    int     c;
+
+    if ((c = skip_ws()) == '\n') {
+        cerror( no_arg, NULL, 0L, NULL);
+        unget_ch();                         /* Push back <newline>  */
+        return  -1L;                /* Line number is not changed   */
+    }
+
+    if (standard) {
+        token_type = get_unexpandable( c, FALSE);
+        if (macro_line == MACRO_ERROR)      /* Unterminated macro   */
+            return  -1L;                    /*   already diagnosed. */
+        if (token_type == NO_TOKEN) /* Macro expanded to 0 token    */
+            goto  no_num;
+        if (token_type != NUM)
+            goto  illeg_num;
+    } else if (scan_token( c, (workp = work_buf, &workp), work_end) != NUM) {
+        goto  illeg_num;
+    }
+    for (workp = work_buf; *workp != EOS; workp++) {
+        if (! isdigit( *workp & UCHARMAX)) {
+            if (standard) {
+                cerror( not_digits, work_buf, 0L, NULL);
+                return  -1L;
+            } else if (warn_level & 1) {
+                cwarn( not_digits, work_buf, 0L, NULL);
+            }
+        }
+    }
+    valp = eval_num( work_buf);             /* Evaluate number      */
+    if (valp->sign == VAL_ERROR) {  /* Error diagnosed by eval_num()*/
+        return  -1;
+    } else if (standard
+            && (std_limits.line_num < valp->val || valp->val <= 0L)) {
+        if (valp->val < LINE99LIMIT && valp->val > 0L) {
+            if (warn_level & 1)
+                cwarn( out_of_range, work_buf, std_limits.line_num, NULL);
+        } else {
+            cerror( out_of_range, work_buf, std_limits.line_num, NULL);
+            return  -1L;
+        }
+    }
+
+    if (standard) {
+        token_type = get_unexpandable( skip_ws(), FALSE);
+        if (macro_line == MACRO_ERROR)
+            return  -1L;
+        if (token_type != STR) {
+            if (token_type == NO_TOKEN) {   /* Filename is absent   */
+                return  (long) valp->val;
+            } else {    /* Expanded macro should be a quoted string */
+                goto  not_fname;
+            }
+        }
+    } else {
+        if ((c = skip_ws()) == '\n') {
+            unget_ch();
+            return  (long) valp->val;
+        }
+        if (scan_token( c, (workp = work_buf, &workp), work_end) != STR)
+            goto  not_fname;
+    }
+#if COMPILER == GNUC
+    if (memcmp( workp - 3, "//", 2) == 0) { /* "/cur-dir//"         */
+        save = infile->filename;    /* Do not change the file name  */
+    } else
+#endif
+    {
+        *(workp - 1) = EOS;                 /* Ignore right '"'     */
+        save = save_string( &work_buf[ 1]); /* Ignore left '"'      */
+    }
+
+    if (standard) {
+        if (get_unexpandable( skip_ws(), FALSE) != NO_TOKEN) {
+            cerror( excess, work_buf, 0L, NULL);
+            free( save);
+            return  -1L;
+        }
+    } else if (mcpp_mode == OLD_PREP) {
+        skip_nl();
+        unget_ch();
+    } else if ((c = skip_ws()) == '\n') {
+        unget_ch();
+    } else {
+        if (warn_level & 1) {
+            scan_token( c, (workp = work_buf, &workp), work_end);
+            cwarn( excess, work_buf, 0, NULL);
+        }
+        skip_nl();
+        unget_ch();
+    }
+
+    if (infile->filename)
+        free( infile->filename);
+    infile->filename = save;                /* New file name        */
+            /* Note that this does not change infile->real_fname    */
+    return  (long) valp->val;               /* New line number      */
+
+no_num:
+    cerror( "No line number", NULL, 0L, NULL);              /* _E_  */
+    return  -1L;
+illeg_num:
+    cerror( "Not a line number \"%s\"", work_buf, 0L, NULL);        /* _E_  */
+    return  -1L;
+not_fname:
+    cerror( "Not a file name \"%s\"", work_buf, 0L, NULL);  /* _E_  */
+    return  -1L;
+}
+
+/*
+ *                  M a c r o  D e f i n i t i o n s
+ */
+
+/*
+ * look_id()    Looks for the name in the defined symbol table.  Returns a
+ *              pointer to the definition if found, or NULL if not present.
+ * install_macro()  Installs the definition.  Updates the symbol table.
+ * undefine()   Deletes the definition from the symbol table.
+ */
+
+/*
+ * Global work_buf[] are used to store #define parameter lists and
+ * parms[].name point to them.
+ * 'nargs' contains the actual number of parameters stored.
+ */
+typedef struct {
+    char *  name;                   /* -> Start of each parameter   */
+    size_t  len;                    /* Length of parameter name     */
+} PARM;
+static PARM     parms[ NMACPARS];
+static int      nargs;              /* Number of parameters         */
+static char *   token_p;            /* Pointer to the token scanned */
+static char *   repl_base;          /* Base of buffer for repl-text */
+static char *   repl_end;           /* End of buffer for repl-text  */
+static const char * const   no_ident = "No identifier";     /* _E_  */
+#if COMPILER == GNUC
+static int      gcc2_va_arg;        /* GCC2-spec variadic macro     */
+#endif
+
+DEFBUF *    do_define(
+    int     ignore_redef,       /* Do not redefine   */
+    int     predefine           /* Predefine compiler-specific name */
+    /*
+     * Note: The value of 'predefine' should be one of 0, DEF_NOARGS_PREDEF
+     *      or DEF_NOARGS_PREDEF_OLD, the other values cause errors.
+     */
+)
+/*
+ * Called from directive() when a #define is scanned or called from
+ *      do_options() when a -D option is scanned.  This module parses formal
+ *      parameters by get_parm() and the replacement text by get_repl().
+ *
+ * There is some special case code to distinguish
+ *      #define foo     bar     --  object-like macro
+ * from #define foo()   bar     --  function-like macro with no parameter
+ *
+ * Also, we make sure that
+ *      #define foo     foo
+ * expands to "foo" but doesn't put MCPP into an infinite loop.
+ *
+ * A warning is printed if you redefine a symbol with a non-identical
+ * text.  I.e,
+ *      #define foo     123
+ *      #define foo     123
+ * is ok, but
+ *      #define foo     123
+ *      #define foo     +123
+ * is not.
+ *
+ * The following subroutines are called from do_define():
+ * get_parm()   parsing and remembering parameter names.
+ * get_repl()   parsing and remembering replacement text.
+ *
+ * The following subroutines are called from get_repl():
+ * is_formal()  is called when an identifier is scanned.  It checks through
+ *              the array of formal parameters.  If a match is found, the
+ *              identifier is replaced by a control byte which will be used
+ *              to locate the parameter when the macro is expanded.
+ * def_stringization()  is called when '#' operator is scanned.  It surrounds
+ *              the token to stringize with magic-codes.
+ *
+ * modes other than STD ignore difference of parameter names in macro
+ * redefinition.
+ */
+{
+    const char * const  predef = "\"%s\" shouldn't be redefined";   /* _E_  */
+    char    repl_list[ NMACWORK + IDMAX];   /* Replacement text     */
+    char    macroname[ IDMAX + 1];  /* Name of the macro defining   */
+    DEFBUF *    defp;               /* -> Old definition            */
+    DEFBUF **   prevp;      /* -> Pointer to previous def in list   */
+    int     c;
+    int     redefined;                      /* TRUE if redefined    */
+    int     dnargs = 0;                     /* defp->nargs          */
+    int     cmp;                    /* Result of name comparison    */
+    size_t  def_start, def_end;     /* Column of macro definition   */
+
+    repl_base = repl_list;
+    repl_end = & repl_list[ NMACWORK];
+    c = skip_ws();
+    if ((mcpp_debug & MACRO_CALL) && src_line)      /* Start of definition  */
+        def_start = infile->bptr - infile->buffer - 1;
+    if (c == '\n') {
+        cerror( no_ident, NULL, 0L, NULL);
+        unget_ch();
+        return  NULL;
+    } else if (scan_token( c, (workp = work_buf, &workp), work_end) != NAM) {
+        cerror( not_ident, work_buf, 0L, NULL);
+        return  NULL;
+    } else {
+        prevp = look_prev( identifier, &cmp);
+                /* Find place in the macro list to insert the definition    */
+        defp = *prevp;
+        if (standard) {
+            if (cmp || defp->push) {    /* Not known or 'pushed' macro      */
+                if (str_eq( identifier, "defined")
+                        || ((stdc_val || cplus_val)
+                            &&  str_eq( identifier, "__VA_ARGS__"))) {
+                    cerror(
+            "\"%s\" shouldn't be defined", identifier, 0L, NULL);   /* _E_  */
+                    return  NULL;
+                }
+                redefined = FALSE;          /* Quite new definition */
+            } else {                        /* It's known:          */
+                if (ignore_redef)
+                    return  defp;
+                dnargs = (defp->nargs == DEF_NOARGS_STANDARD
+                            || defp->nargs == DEF_NOARGS_PREDEF
+                            || defp->nargs == DEF_NOARGS_PREDEF_OLD) 
+                        ? DEF_NOARGS : defp->nargs;
+                if (dnargs <= DEF_NOARGS_DYNAMIC    /* __FILE__ and such    */
+                        || dnargs == DEF_PRAGMA /* _Pragma() pseudo-macro   */
+                        ) {
+                    cerror( predef, identifier, 0L, NULL);
+                    return  NULL;
+                } else {
+                    redefined = TRUE;       /* Remember this fact   */
+                }
+            }
+        } else {
+            if (cmp) {
+                redefined = FALSE;          /* Quite new definition */
+            } else {                        /* It's known:          */
+                if (ignore_redef)
+                    return  defp;
+                dnargs = (defp->nargs == DEF_NOARGS_STANDARD 
+                            || defp->nargs == DEF_NOARGS_PREDEF
+                            || defp->nargs == DEF_NOARGS_PREDEF_OLD) 
+                        ? DEF_NOARGS : defp->nargs;
+                redefined = TRUE;
+            }
+        }
+    }
+    strcpy( macroname, identifier);         /* Remember the name    */
+
+    in_define = TRUE;                       /* Recognize '#', '##'  */
+    if (get_parm() == FALSE) {              /* Get parameter list   */
+        in_define = FALSE;
+        return  NULL;                       /* Syntax error         */
+    }
+    if (get_repl( macroname) == FALSE) {    /* Get replacement text */
+        in_define = FALSE;
+        return  NULL;                       /* Syntax error         */
+    }
+    if ((mcpp_debug & MACRO_CALL) && src_line) {
+                                    /* Remember location on source  */
+        char *  cp;
+        cp = infile->bptr - 1;              /* Before '\n'          */
+        while (char_type[ *cp & UCHARMAX] & HSP)
+            cp--;                           /* Trailing space       */
+        cp++;                       /* Just after the last token    */
+        def_end = cp - infile->buffer;      /* End of definition    */
+    }
+
+    in_define = FALSE;
+    if (redefined) {
+        if (dnargs != nargs || ! str_eq( defp->repl, repl_list)
+                || (mcpp_mode == STD && ! str_eq( defp->parmnames, work_buf))
+                ) {             /* Warn if differently redefined    */
+            if (warn_level & 1) {
+                cwarn(
+            "The macro is redefined", NULL, 0L, NULL);      /* _W1_ */
+                if (! option_flags.no_source_line)
+                    dump_a_def( "    previously macro", defp, FALSE, TRUE
+                            , fp_err);
+            }
+        } else {                        /* Identical redefinition   */
+            return  defp;
+        }
+    }                                   /* Else new or re-definition*/
+    defp = install_macro( macroname, nargs, work_buf, repl_list, prevp, cmp
+            , predefine);
+    if ((mcpp_debug & MACRO_CALL) && src_line) {
+                                    /* Get location on source file  */        
+        LINE_COL    s_line_col, e_line_col;
+        s_line_col.line = src_line;
+        s_line_col.col = def_start;
+        get_src_location( & s_line_col);
+                            /* Convert to pre-line-splicing data    */
+        e_line_col.line = src_line;
+        e_line_col.col = def_end;
+        get_src_location( & e_line_col);
+        /* Putout the macro definition information embedded in comment  */
+        mcpp_fprintf( OUT, "/*m%s %ld:%d-%ld:%d*/\n", defp->name
+                , s_line_col.line, s_line_col.col
+                , e_line_col.line, e_line_col.col);
+        wrong_line = TRUE;                      /* Need #line later */
+    }
+    if (mcpp_mode == STD && cplus_val && id_operator( macroname)
+            && (warn_level & 1))
+        /* These are operators, not identifiers, in C++98   */
+        cwarn( "\"%s\" is defined as macro", macroname      /* _W1_ */
+                , 0L, NULL);
+    return  defp;
+}
+
+static int  get_parm( void)
+/*
+ *   Get parameters i.e. numbers into nargs, name into work_buf[], name-length
+ * into parms[].len.  parms[].name point into work_buf.
+ *   Return TRUE if the parameters are legal, else return FALSE.
+ *   In STD mode preprocessor must remember the parameter names, only for
+ * checking the validity of macro redefinitions.  This is required by the
+ * Standard (what an overhead !).
+ */
+{
+    const char * const  many_parms
+            = "More than %.0s%ld parameters";       /* _E_ _W4_     */
+    const char * const  illeg_parm
+            = "Illegal parameter \"%s\"";           /* _E_          */
+    const char * const  misplaced_ellip
+            = "\"...\" isn't the last parameter";   /* _E_          */
+    int     token_type;
+    int     c;
+
+    parms[ 0].name = workp = work_buf;
+    work_buf[ 0] = EOS;
+#if COMPILER == GNUC
+    gcc2_va_arg = FALSE;
+#endif
+
+    /* POST_STD mode    */
+    insert_sep = NO_SEP;    /* Clear the inserted token separator   */
+    c = get_ch();
+
+    if (c == '(') {                         /* With arguments?      */
+        nargs = 0;                          /* Init parms counter   */
+        if (skip_ws() == ')')
+            return  TRUE;                   /* Macro with 0 parm    */
+        else
+            unget_ch();
+
+        do {                                /* Collect parameters   */
+            if (nargs >= NMACPARS) {
+                cerror( many_parms, NULL, (long) NMACPARS, NULL);
+                return  FALSE;
+            }
+            parms[ nargs].name = workp;     /* Save its start       */
+            if ((token_type = scan_token( c = skip_ws(), &workp, work_end))
+                    != NAM) {
+                if (c == '\n') {
+                    break;
+                } else if (c == ',' || c == ')') {
+                    cerror( "Empty parameter", NULL, 0L, NULL);     /* _E_  */
+                    return  FALSE;
+                } else if (standard && (stdc_val || cplus_val)
+                        && token_type == OPE && openum == OP_ELL) {
+                    /*
+                     * Enable variable argument macro which is a feature of
+                     * C99.  We enable this even on C90 or C++ for GCC
+                     * compatibility.
+                     */
+                    if (skip_ws() != ')') {
+                        cerror( misplaced_ellip, NULL, 0L, NULL);
+                        return  FALSE;
+                    }
+                    parms[ nargs++].len = 3;
+                    nargs |= VA_ARGS;
+                    goto  ret;
+                } else {
+                    cerror( illeg_parm, parms[ nargs].name, 0L, NULL);
+                    return  FALSE;          /* Bad parameter syntax */
+                }
+            }
+            if (standard && (stdc_val || cplus_val)
+                    && str_eq( identifier, "__VA_ARGS__")) {
+                cerror( illeg_parm, parms[ nargs].name, 0L, NULL);
+                return  FALSE;
+                /* __VA_ARGS__ should not be used as a parameter    */
+            }
+            if (is_formal( parms[ nargs].name, FALSE)) {
+                cerror( "Duplicate parameter name \"%s\""   /* _E_  */
+                        , parms[ nargs].name, 0L, NULL);
+                return  FALSE;
+            }
+            parms[ nargs].len = (size_t) (workp - parms[ nargs].name);
+                                            /* Save length of param */
+            *workp++ = ',';
+            nargs++;
+        } while ((c = skip_ws()) == ',');   /* Get another parameter*/
+
+        *--workp = EOS;                     /* Remove excessive ',' */
+        if (c != ')') {                     /* Must end at )        */
+#if COMPILER == GNUC
+            /* Handle GCC2 variadic params like par...  */
+            char *  tp = workp;
+            if (mcpp_mode == STD
+                    &&(token_type = scan_token( c, &workp, work_end)) == OPE
+                    && openum == OP_ELL) {
+                if ((c = skip_ws()) != ')') {
+                    cerror( misplaced_ellip, NULL, 0L, NULL);
+                    return  FALSE;
+                }
+                *tp = EOS;                  /* Remove "..."         */
+                nargs |= VA_ARGS;
+                gcc2_va_arg = TRUE;
+                goto  ret;
+            }
+#endif
+            unget_ch();                     /* Push back '\n'       */
+            cerror(
+        "Missing \",\" or \")\" in parameter list \"(%s\""  /* _E_  */
+                    , work_buf, 0L, NULL);
+            return  FALSE;
+        }
+    } else {
+        /*
+         * DEF_NOARGS is needed to distinguish between
+         * "#define foo" and "#define foo()".
+         */
+        nargs = DEF_NOARGS;                 /* Object-like macro    */
+        unget_ch();
+    }
+ret:
+#if NMACPARS > NMACPARS90MIN
+    if ((warn_level & 4) && (nargs & ~AVA_ARGS) > std_limits.n_mac_pars)
+        cwarn( many_parms, NULL , (long) std_limits.n_mac_pars, NULL);
+#endif
+    return  TRUE;
+}
+
+static int  get_repl( 
+    const char * macroname
+)
+/*
+ *   Get replacement text i.e. names of formal parameters are converted to
+ * the magic numbers, and operators #, ## is converted to magic characters.
+ *   Return TRUE if replacement list is legal, else return FALSE.
+ *   Any token separator in the text is converted to a single space, no token
+ * sepatator is inserted by MCPP.  Those are required by the Standard for
+ * stringizing of an argument by # operator.
+ *   In POST_STD mode, inserts a space between any tokens in source (except a
+ * macro name and the next '(' in macro definition), hence presence or absence
+ * of token separator makes no difference.
+ */
+{
+    const char * const  mixed_ops
+    = "Macro with mixing of ## and # operators isn't portable";     /* _W4_ */
+    const char * const  multiple_cats
+    = "Macro with multiple ## operators isn't portable";    /* _W4_ */
+    char *  prev_token = NULL;              /* Preceding token      */
+    char *  prev_prev_token = NULL;         /* Pre-preceding token  */
+    int     multi_cats = FALSE;             /* Multiple ## operators*/
+    int     c;
+    int     token_type;                     /* Type of token        */
+    char *  temp;
+    char *  repl_cur = repl_base;   /* Pointer into repl-text buffer*/
+
+    *repl_cur = EOS;
+    token_p = NULL;
+    if (mcpp_mode == STD) {
+        c = get_ch();
+        unget_ch();
+        if (((char_type[ c] & SPA) == 0) && (nargs < 0) && (warn_level & 1))
+            cwarn( "No space between macro name \"%s\" and repl-text"/* _W1_ */
+                , macroname, 0L, NULL);
+    }
+    c = skip_ws();                          /* Get to the body      */
+
+    while (c != '\n') {
+        if (standard) {
+            prev_prev_token = prev_token;
+            prev_token = token_p;
+        }
+        token_p = repl_cur;                 /* Remember the pointer */
+        token_type = scan_token( c, &repl_cur, repl_end);
+
+        switch (token_type) {
+        case OPE:                   /* Operator or punctuator       */
+            if (! standard)
+                break;
+            switch (openum) {
+            case OP_CAT:                    /* ##                   */
+                if (prev_token == NULL) {
+                    cerror( "No token before ##"            /* _E_  */
+                            , NULL, 0L, NULL);
+                    return  FALSE;
+                } else if (*prev_token == CAT) {
+                    cerror( "## after ##", NULL, 0L, NULL); /* _E_  */
+                    return  FALSE;
+                } else if (prev_prev_token && *prev_prev_token == CAT) {
+                    multi_cats = TRUE;
+                } else if (prev_prev_token && *prev_prev_token == ST_QUOTE
+                        && (warn_level & 4)) {      /* # parm ##    */
+                    cwarn( mixed_ops, NULL, 0L, NULL);
+                }
+                repl_cur = token_p;
+                *repl_cur++ = CAT;          /* Convert to CAT       */
+                break;
+            case OP_STR:                    /* #                    */
+                if (nargs < 0)              /* In object-like macro */
+                    break;                  /* '#' is an usual char */
+                if (prev_token && *prev_token == CAT
+                        && (warn_level & 4))        /* ## #         */
+                    cwarn( mixed_ops, NULL, 0L, NULL);
+                repl_cur = token_p;         /* Overwrite on #       */
+                if ((temp = def_stringization( repl_cur)) == NULL) {
+                    return  FALSE;          /* Error                */
+                } else {
+                    repl_cur = temp;
+                }
+                break;
+            default:                    /* Any operator as it is    */
+                break;
+            }
+            break;
+        case NAM:
+        /*
+         * Replace this name if it's a parm.  Note that the macro name is a
+         * possible replacement token.  We stuff DEF_MAGIC in front of the
+         * token which is treated as a LETTER by the token scanner and eaten
+         * by the macro expanding routine.  This prevents the macro expander
+         * from looping if someone writes "#define foo foo".
+         */
+            temp = is_formal( identifier, TRUE);
+            if (temp == NULL) {             /* Not a parameter name */
+                if (! standard)
+                    break;
+                if ((stdc_val || cplus_val)
+                            && str_eq( identifier, "__VA_ARGS__")) {
+#if COMPILER == GNUC
+                    if (gcc2_va_arg) {
+        cerror( "\"%s\" cannot be used in GCC2-spec variadic macro" /* _E_  */
+                            , identifier, 0L, NULL);
+                        return  FALSE;
+                    }
+#endif
+                    cerror( "\"%s\" without corresponding \"...\""  /* _E_  */
+                            , identifier, 0L, NULL);
+                    return  FALSE;
+                }
+                if ((temp = mgtoken_save( macroname)) != NULL)
+                    repl_cur = temp;        /* Macro name           */
+            } else {                        /* Parameter name       */
+                repl_cur = temp;
+#if COMPILER == GNUC
+                if (mcpp_mode == STD && (nargs & VA_ARGS)
+                        && *(repl_cur - 1) == (nargs & ~AVA_ARGS)) {
+                    if (! str_eq( identifier, "__VA_ARGS__")
+                            && (warn_level & 2))
+                        cwarn(
+                            "GCC2-spec variadic macro is defined"   /* _W2_ */
+                                    , NULL, 0L, NULL);
+                    if (prev_token && *prev_token == CAT
+                            && prev_prev_token && *prev_prev_token == ',')
+                        /* ", ## __VA_ARGS__" is sequence peculiar  */
+                        /* to GCC3-spec variadic macro.             */
+                        /* Or ", ## last_arg" is sequence peculiar  */
+                        /* to GCC2-spec variadic macro.             */
+                        nargs |= GVA_ARGS;
+                        /* Mark as sequence peculiar to GCC         */
+                        /* This will be warned at expansion time    */
+                }
+#endif
+            }
+            break;
+
+        case STR:                           /* String in mac. body  */
+        case CHR:                           /* Character constant   */
+            if (mcpp_mode == OLD_PREP)
+                repl_cur = str_parm_scan( repl_cur);
+            break;
+        case SEP:
+            if (mcpp_mode == OLD_PREP && c == COM_SEP)
+                repl_cur--;                 /* Skip comment now     */
+            break;
+        default:                            /* Any token as it is   */
+            break;
+        }
+
+        if ((c = get_ch()) == ' ' || c == '\t') {
+            *repl_cur++ = ' ';              /* Space                */
+            while ((c = get_ch()) == ' ' || c == '\t')
+                ;                   /* Skip excessive spaces        */
+        }
+    }
+
+    while (repl_base < repl_cur
+            && (*(repl_cur - 1) == ' ' || *(repl_cur - 1) == '\t'))
+        repl_cur--;                     /* Remove trailing spaces   */
+    *repl_cur = EOS;                        /* Terminate work       */
+
+    unget_ch();                             /* For syntax check     */
+    if (standard) {
+        if (token_p && *token_p == CAT) {
+            cerror( "No token after ##", NULL, 0L, NULL);   /* _E_  */
+            return  FALSE;
+        }
+        if (multi_cats && (warn_level & 4))
+            cwarn( multiple_cats, NULL, 0L, NULL);
+        if ((nargs & VA_ARGS) && stdc_ver < 199901L && (warn_level & 2))
+            /* Variable arg macro is the spec of C99, not C90 nor C++98     */
+            cwarn( "Variable argument macro is defined",    /* _W2_ */
+                    NULL, 0L, NULL);
+    }
+
+    return  TRUE;
+}
+
+static char *   is_formal(
+    const char *    name,
+    int         conv                    /* Convert to magic number? */
+)
+/*
+ * If the identifier is a formal parameter, save the MAC_PARM and formal
+ * offset, returning the advanced pointer into the replacement text.
+ * Else, return NULL.
+ */
+{
+    char *  repl_cur;
+    const char *    va_arg = "__VA_ARGS__";
+    PARM    parm;
+    size_t  len;
+    int     i;
+
+    len = strlen( name);
+    for (i = 0; i < (nargs & ~AVA_ARGS); i++) {     /* For each parameter   */
+        parm = parms[ i];
+        if ((len == parm.len
+                /* Note: parms[].name are comma separated  */
+                    && memcmp( name, parm.name, parm.len) == 0)
+                || (standard && (nargs & VA_ARGS)
+                    && i == (nargs & ~AVA_ARGS) - 1 && conv
+                    && str_eq( name, va_arg))) {    /* __VA_ARGS__  */
+                                            /* If it's known        */
+#if COMPILER == GNUC
+            if (gcc2_va_arg && str_eq( name, va_arg))
+                return  NULL;               /* GCC2 variadic macro  */
+#endif
+            if (conv) {
+                repl_cur = token_p;         /* Overwrite on the name*/
+                *repl_cur++ = MAC_PARM;     /* Save the signal      */
+                *repl_cur++ = i + 1;        /* Save the parm number */
+                return  repl_cur;           /* Return "gotcha"      */
+            } else {
+                return  parm.name;          /* Duplicate parm name  */
+            }
+        }
+    }
+
+    return  NULL;                           /* Not a formal param   */
+}
+
+static char *   def_stringization( char * repl_cur)
+/*
+ * Define token stringization.
+ * We store a magic cookie (which becomes surrouding " on expansion) preceding
+ * the parameter as an operand of # operator.
+ * Return the current pointer into replacement text if the token following #
+ * is a parameter name, else return NULL.
+ */
+{
+    int     c;
+    char *  temp;
+
+    *repl_cur++ = ST_QUOTE;                 /* Prefix               */
+    if (char_type[ c = get_ch()] & HSP) {   /* There is a space     */
+        *repl_cur++ = ' ';
+        while (char_type[ c = get_ch()] & HSP)      /* Skip excessive spaces*/
+            ;
+    }
+    token_p = repl_cur;                     /* Remember the pointer */
+    if (scan_token( c, &repl_cur, repl_end) == NAM) {
+        if ((temp = is_formal( identifier, TRUE)) != NULL) {
+            repl_cur = temp;
+            return  repl_cur;
+        }
+    }
+    cerror( "Not a formal parameter \"%s\"", token_p, 0L, NULL);    /* _E_  */
+    return  NULL;
+}
+
+static char *   mgtoken_save( const char * macroname)
+/*
+ * A magic cookie is inserted if the token is identical to the macro name,
+ * so the expansion doesn't recurse.
+ * Return the advanced pointer into the replacement text or NULL.
+ */
+{
+    char *   repl_cur;
+
+    if (str_eq( macroname, identifier)) {   /* Macro name in body   */
+        repl_cur = token_p;                 /* Overwrite on token   */
+        *repl_cur++ = DEF_MAGIC;            /* Save magic marker    */
+        repl_cur = stpcpy( repl_cur, identifier);
+                                            /* And save the token   */
+        return  repl_cur;
+    } else {
+        return  NULL;
+    }
+}
+
+static char *   str_parm_scan( char * string_end)
+/*
+ * String parameter scan.
+ * This code -- if enabled -- recognizes a formal parameter in a string
+ * literal or in a character constant.
+ *      #define foo(bar, v) printf("%bar\n", v)
+ *      foo( d, i)
+ * expands to:
+ *      printf("%d\n", i)
+ * str_parm_scan() return the advanced pointer into the replacement text.
+ * This has been superceded by # stringizing and string concatenation.
+ * This routine is called only in OLD_PREP mode.
+ */
+{
+    int     delim;
+    int     c;
+    char *  tp;
+    char *  wp;             /* Pointer into the quoted literal  */
+
+    delim = *token_p;
+    unget_string( ++token_p, NULL);
+    /* Pseudo-token-parsing in a string literal */
+    wp = token_p;
+    while ((c = get_ch()) != delim) {
+        token_p = wp;
+        if (scan_token( c, &wp, string_end) != NAM)
+            continue;
+        if ((tp = is_formal( token_p, TRUE)) != NULL)
+            wp = tp;
+    }
+    *wp++ = delim;
+    return  wp;
+}
+
+static void do_undef( void)
+/*
+ * Remove the symbol from the defined list.
+ * Called from directive().
+ */
+{
+    DEFBUF *    defp;
+    int     c;
+
+    if ((c = skip_ws()) == '\n') {
+        cerror( no_ident, NULL, 0L, NULL);
+        unget_ch();
+        return;
+    }
+    if (scan_token( c, (workp = work_buf, &workp), work_end) != NAM) {
+        cerror( not_ident, work_buf, 0L, NULL);
+        skip_nl();
+        unget_ch();
+    } else {
+        if ((defp = look_id( identifier)) == NULL) {
+            if (warn_level & 8)
+                cwarn( "\"%s\" wasn't defined"              /* _W8_ */
+                        , identifier, 0L, NULL);
+        } else if (standard && (defp->nargs <= DEF_NOARGS_STANDARD
+                                                /* Standard predef  */
+                    || defp->nargs == DEF_PRAGMA)) {
+                                        /* _Pragma() pseudo-macro   */
+            cerror( "\"%s\" shouldn't be undefined"         /* _E_  */
+                    , identifier, 0L, NULL);
+        } else if (standard) {
+            c = skip_ws();
+            unget_ch();
+            if (c != '\n')                      /* Trailing junk    */
+                return;
+            else
+                undefine( identifier);
+        } else {
+            undefine( identifier);
+        }
+    }
+}
+
+/*
+ *                  C P P   S y m b o l   T a b l e s
+ *
+ * SBSIZE defines the number of hash-table slots for the symbol table.
+ * It must be a power of 2.
+ */
+
+/* Symbol table queue headers.  */
+static DEFBUF *     symtab[ SBSIZE];
+static long         num_of_macro = 0;
+
+#if MCPP_LIB
+void    init_directive( void)
+/* Initialize static variables. */
+{
+    num_of_macro = 0;
+}
+#endif
+
+DEFBUF *    look_id( const char * name)
+/*
+ * Look for the identifier in the symbol table.
+ * If found, return the table pointer;  Else return NULL.
+ */
+{
+    DEFBUF **   prevp;
+    int         cmp;
+
+    prevp = look_prev( name, &cmp);
+
+    if (standard)
+        return ((cmp == 0 && (*prevp)->push == 0) ? *prevp : NULL);
+    else
+        return ((cmp == 0) ? *prevp : NULL);
+}
+
+DEFBUF **   look_prev(
+    const char *    name,                   /* Name of the macro    */
+    int *   cmp                             /* Result of comparison */
+)
+/*
+ * Look for the place to insert the macro definition.
+ * Return a pointer to the previous member in the linked list.
+ */
+{
+    const char *    np;
+    DEFBUF **   prevp;
+    DEFBUF *    dp;
+    size_t      s_name;
+    int         hash;
+
+    for (hash = 0, np = name; *np != EOS; )
+        hash += *np++;
+    hash += s_name = (size_t)(np - name);
+    s_name++;
+    prevp = & symtab[ hash & SBMASK];
+    *cmp = -1;                              /* Initialize           */
+
+    while ((dp = *prevp) != NULL) {
+        if ((*cmp = memcmp( dp->name, name, s_name)) >= 0)
+            break;
+        prevp = &dp->link;
+    }
+
+    return  prevp;
+}
+
+DEFBUF *    look_and_install(
+    const char *    name,                   /* Name of the macro    */
+    int     numargs,                        /* The numbers of parms */
+    const char *    parmnames,  /* Names of parameters concatenated */
+    const char *    repl                    /* Replacement text     */
+)
+/*
+ * Look for the name and (re)define it.
+ * Returns a pointer to the definition block.
+ * Returns NULL if the symbol was Standard-predefined.
+ */
+{
+    DEFBUF **   prevp;          /* Place to insert definition       */
+    DEFBUF *    defp;                       /* New definition block */
+    int         cmp;    /* Result of comparison of new name and old */
+
+    prevp = look_prev( name, &cmp);
+    defp = install_macro( name, numargs, parmnames, repl, prevp, cmp, 0);
+    return  defp;
+}
+
+DEFBUF *    install_macro(
+    const char *    name,                   /* Name of the macro    */
+    int     numargs,                        /* The numbers of parms */
+    const char *    parmnames,  /* Names of parameters concatenated */
+    const char *    repl,                   /* Replacement text     */
+    DEFBUF **  prevp,           /* The place to insert definition   */
+    int     cmp,        /* Result of comparison of new name and old */
+    int     predefine   /* Predefined macro without leading '_'     */
+)
+/*
+ * Enter this name in the lookup table.
+ * Returns a pointer to the definition block.
+ * Returns NULL if the symbol was Standard-predefined.
+ * Note that predefinedness can be specified by either of 'numargs' or
+ * 'predefine'.
+ */
+{
+    DEFBUF *    dp;
+    DEFBUF *    defp;
+    size_t      s_name, s_parmnames, s_repl;
+
+    defp = *prevp;                  /* Old definition, if cmp == 0  */
+    if (cmp == 0 && defp->nargs < DEF_NOARGS - 1)
+        return  NULL;                       /* Standard predefined  */
+    if (parmnames == NULL || repl == NULL || (predefine && numargs > 0)
+            || (predefine && predefine != DEF_NOARGS_PREDEF
+                    && predefine != DEF_NOARGS_PREDEF_OLD))
+                                                /* Shouldn't happen */
+        cfatal( "Bug: Illegal macro installation of \"%s\"" /* _F_  */
+                , name, 0L, NULL);      /* Use "" instead of NULL   */
+    s_name = strlen( name);
+    if (mcpp_mode == STD)
+        s_parmnames = strlen( parmnames) + 1;
+    else
+        s_parmnames = 0;
+    s_repl = strlen( repl) + 1;
+    dp = (DEFBUF *)
+        xmalloc( sizeof (DEFBUF) + s_name + s_parmnames + s_repl);
+    if (cmp || (standard && (*prevp)->push)) {  /* New definition   */
+        dp->link = defp;                /* Insert to linked list    */
+        *prevp = dp;
+    } else {                            /* Redefinition             */
+        dp->link = defp->link;          /* Replace old def with new */
+        *prevp = dp;
+        free( defp);
+    }
+    dp->nargs = predefine ? predefine : numargs;
+    if (standard) {
+        dp->push = 0;
+        dp->parmnames = (char *)dp + sizeof (DEFBUF) + s_name;
+        dp->repl = dp->parmnames + s_parmnames;
+        if (mcpp_mode == STD)
+            memcpy( dp->parmnames, parmnames, s_parmnames);
+    } else {
+        dp->repl = (char *)dp + sizeof (DEFBUF) + s_name;
+    }
+    memcpy( dp->name, name, s_name + 1);
+    memcpy( dp->repl, repl, s_repl);
+    /* Remember where the macro is defined  */
+    dp->fname = cur_fullname;   /* Full-path-list of current file   */
+    dp->mline = src_line;
+    if (standard && cmp && ++num_of_macro == std_limits.n_macro + 1
+            && std_limits.n_macro && (warn_level & 4))
+        /* '&& std_limits.n_macro' to avoid warning before initialization   */
+        cwarn( "More than %.0s%ld macros defined"           /* _W4_ */
+                , NULL , std_limits.n_macro, NULL);
+    return  dp;
+}
+
+int undefine(
+    const char *  name                      /* Name of the macro    */
+)
+/*
+ * Delete the macro definition from the symbol table.
+ * Returns TRUE, if deleted;
+ * Else returns FALSE (when the macro was not defined or was Standard
+ * predefined).
+ */
+{
+    DEFBUF **   prevp;          /* Preceding definition in list     */
+    DEFBUF *    dp;                     /* Definition to delete     */
+    int         cmp;            /* 0 if defined, else not defined   */
+
+    prevp = look_prev( name, &cmp);
+    dp = *prevp;                        /* Definition to delete     */
+    if (cmp || dp->nargs <= DEF_NOARGS_STANDARD)
+        return  FALSE;      /* Not defined or Standard predefined   */
+    if (standard && dp->push)
+        return  FALSE;                  /* 'Pushed' macro           */
+    *prevp = dp->link;          /* Link the previous and the next   */
+    if ((mcpp_debug & MACRO_CALL) && dp->mline) {
+        /* Notice this directive unless the macro is predefined     */
+        mcpp_fprintf( OUT, "/*undef %ld*//*%s*/\n", src_line, dp->name);
+        wrong_line = TRUE;
+    }
+    free( dp);                          /* Delete the definition    */
+    if (standard)
+        num_of_macro--;
+    return  TRUE;
+}
+
+static void dump_repl( 
+    const DEFBUF *  dp,
+    FILE *  fp,
+    int     gcc2_va
+)
+/*
+ * Dump replacement text.
+ */
+{
+    int     numargs = dp->nargs;
+    char *  cp1;
+    size_t  i;
+    int     c;
+    const char *    cp;
+
+    for (cp = dp->repl; (c = *cp++ & UCHARMAX) != EOS; ) {
+
+        switch (c) {
+        case MAC_PARM:                              /* Parameter    */
+            c = (*cp++ & UCHARMAX) - 1;
+            if (standard) {
+                PARM    parm = parms[ c];
+                if ((numargs & VA_ARGS) && c == (numargs & ~AVA_ARGS) - 1) {
+                    mcpp_fputs( gcc2_va ? parm.name : "__VA_ARGS__"
+                            , FP2DEST( fp));
+                    /* gcc2_va is possible only in STD mode */
+                } else {
+                    if (mcpp_mode == STD) {
+                        for (i = 0, cp1 = parm.name; i < parm.len; i++)
+                            mcpp_fputc( *cp1++, FP2DEST( fp));
+                    } else {
+                        mcpp_fputc( 'a' + c % 26, FP2DEST( fp));
+                        if (c > 26)
+                            mcpp_fputc( '0' + c / 26, FP2DEST( fp));
+                    }
+                }
+            } else {
+                mcpp_fputc( 'a' + c % 26, FP2DEST( fp));
+                if (c > 26)
+                    mcpp_fputc( '0' + c / 26, FP2DEST( fp));
+            }
+            break;
+        case DEF_MAGIC:
+            if (! standard)
+                mcpp_fputc( c, FP2DEST( fp));
+            /* Else skip    */
+            break;
+        case CAT:
+            if (standard)
+                mcpp_fputs( "##", FP2DEST( fp));
+            else
+                mcpp_fputc( c, FP2DEST( fp));
+            break;
+        case ST_QUOTE:
+            if (standard)
+                mcpp_fputs( "#", FP2DEST( fp));
+            else
+                mcpp_fputc( c, FP2DEST( fp));
+            break;
+        case COM_SEP:
+            /*
+             * Though TOK_SEP coincides to COM_SEP, this cannot appear in
+             * Standard mode.
+             */
+            if (mcpp_mode == OLD_PREP)
+                mcpp_fputs( "/**/", FP2DEST( fp));
+            break;
+        default:
+            mcpp_fputc( c, FP2DEST( fp));
+            break;
+        }
+    }
+}
+
+/*
+ * If the compiler is so-called "one-pass" compiler, compiler-predefined
+ * macros are commented out to avoid redefinition.
+ */
+#if ONE_PASS
+#define CAN_REDEF   DEF_NOARGS
+#else
+#define CAN_REDEF   DEF_NOARGS_PREDEF
+#endif
+
+void    dump_a_def(
+    const char *    why,
+    const DEFBUF *  dp,
+    int     newdef,         /* TRUE if parmnames are currently in parms[] */
+    int     comment,        /* Show location of the definition in comment   */
+    FILE *  fp
+)
+/*
+ * Dump a macro definition.
+ */
+{
+    char *  cp, * cp1;
+    int     numargs = dp->nargs & ~AVA_ARGS;
+    int     commented;                      /* To be commented out  */
+    int     gcc2_va = FALSE;                /* GCC2-spec variadic   */
+    int     i;
+
+    if (standard && numargs == DEF_PRAGMA)  /* _Pragma pseudo-macro */
+        return;
+    if ((numargs < CAN_REDEF) || (standard && dp->push))
+        commented = TRUE;
+    else
+        commented = FALSE;
+    if (! comment && commented)             /* For -dM option       */
+        return;
+    if (why)
+        mcpp_fprintf( FP2DEST( fp), "%s \"%s\" defined as: ", why, dp->name);
+    mcpp_fprintf( FP2DEST( fp), "%s#define %s", commented ? "/* " : "",
+            dp->name);                      /* Macro name           */
+    if (numargs >= 0) {                     /* Parameter list       */
+        if (mcpp_mode == STD) {
+            const char *    appendix = null;
+            if (! newdef) {
+                /* Make parms[] for dump_repl() */
+                for (i = 0, cp = dp->parmnames; i < numargs;
+                        i++, cp = cp1 + 1) {
+                    if ((cp1 = strchr( cp, ',')) == NULL)   /* The last arg */
+                        parms[ i].len = strlen( cp);
+                    else
+                        parms[ i].len = (size_t) (cp1 - cp);
+                    parms[ i].name = cp;
+                }
+            }
+#if COMPILER == GNUC
+            if ((dp->nargs & VA_ARGS)
+                    && memcmp( parms[ numargs - 1].name, "...", 3) != 0) {
+                appendix = "...";   /* Append ... so as to become 'args...' */
+                gcc2_va = TRUE;
+            }
+#endif
+            mcpp_fprintf( FP2DEST( fp), "(%s%s)", dp->parmnames, appendix);
+        } else {
+            if (newdef) {
+                mcpp_fprintf( FP2DEST( fp), "(%s)", parms[ 0].name);
+            } else if (numargs == 0) {
+                mcpp_fputs( "()", FP2DEST( fp));
+            } else {
+                /* Print parameter list automatically made as:      */
+                /* a, b, c, ..., a0, b0, c0, ..., a1, b1, c1, ...   */
+                mcpp_fputc( '(', FP2DEST( fp));
+                for (i = 0; i < numargs; i++) {     /* Make parameter list  */
+                    mcpp_fputc( 'a' + i % 26, FP2DEST( fp));
+                    if (i >= 26)
+                        mcpp_fputc( '0' + i / 26, FP2DEST( fp));
+                    if (i + 1 < numargs)
+                        mcpp_fputc( ',', FP2DEST( fp));
+                }
+                mcpp_fputc( ')', FP2DEST( fp));
+            }
+        }
+    }
+    if (*dp->repl) {
+        mcpp_fputc( ' ', FP2DEST( fp));
+        dump_repl( dp, fp, gcc2_va);        /* Replacement text     */
+    }
+    if (commented)
+            /* Standard predefined or one-pass-compiler-predefined  */
+        mcpp_fputs( " */", FP2DEST( fp));
+    if (comment)                            /* Not -dM option       */
+        mcpp_fprintf( FP2DEST( fp), " \t/* %s:%ld\t*/", dp->fname, dp->mline);
+    mcpp_fputc( '\n', FP2DEST( fp));
+}
+
+void    dump_def(
+    int     comment,        /* Location of definition in comment    */
+    int     K_opt                       /* -K option is specified   */
+)
+/*
+ * Dump all the current macro definitions to output stream.
+ */
+{
+    DEFBUF *    dp;
+    DEFBUF **   symp;
+
+    sharp( NULL, 0);    /* Report the current source file & line    */
+    if (comment)
+        mcpp_fputs( "/* Currently defined macros. */\n", OUT);
+    for (symp = symtab; symp < &symtab[ SBSIZE]; symp++) {
+        if ((dp = *symp) != NULL) {
+            do {
+                if (K_opt)
+                    mcpp_fprintf( OUT, "/*m%s*/\n", dp->name);
+                else
+                    dump_a_def( NULL, dp, FALSE, comment, fp_out);
+            } while ((dp = dp->link) != NULL);
+        }
+    }
+    wrong_line = TRUE;               /* Line number is out of sync  */
+}
+
+#if MCPP_LIB
+void    clear_symtable( void)
+/*
+ * Free all the macro definitions.
+ */
+{
+    DEFBUF *    next;
+    DEFBUF *    dp;
+    DEFBUF **   symp;
+
+    for (symp = symtab; symp < &symtab[ SBSIZE]; symp++) {
+        for (next = *symp; next != NULL; ) {
+            dp = next;
+            next = dp->link;
+            free( dp);                      /* Free the symbol      */
+        }
+        *symp = NULL;
+    }
+}
+#endif
+