zeroc-ice 3.7.10 → 3.7.11

data/dist/ice/mcpp/support.c

@@ -0,0 +1,1985 @@
+/*-
+ * 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.
+ */
+
+/*
+ *                          S U P P O R T . C
+ *                  S u p p o r t   R o u t i n e s
+ *
+ * The common routines used by several source files are placed here.
+ */
+
+/*
+ * The following are global functions.
+ *
+ * get_unexpandable()   Gets the next unexpandable token in the line, expanding
+ *              macros.
+ *              Called from #if, #line and #include processing routines.
+ * skip_nl()    Skips over a line.
+ * skip_ws()    Skips over white spaces but not skip over the end of the line.
+ *              skip_ws() skips also COM_SEP and TOK_SEP.
+ * scan_token() Reads the next token of any type into the specified output
+ *              pointer, advances the pointer, returns the type of token.
+ * scan_quote() Reads a string literal, character constant or header-name from
+ *              the input stream, writes out to the specified buffer and
+ *              returns the advanced output pointer.
+ * get_ch()     Reads the next byte from the current input stream, handling
+ *              end of (macro/file) input and embedded comments appropriately.
+ * unget_ch()   Pushs last gotten character back on the input stream.
+ * unget_string()   Pushs sequence on the input stream.
+ * save_string() Saves a string in malloc() memory.
+ * get_file()   Initializes a new FILEINFO structure, called when #include
+ *              opens a new file, or from unget_string().
+ * xmalloc()    Gets a specified number of bytes from heap memory.
+ *              If malloc() returns NULL, exits with a message.
+ * xrealloc()   realloc().  If it fails, exits with a message.
+ * get_src_location()   Trace back line-column datum into pre-line-splicing
+ *              phase.  A function for -K option.
+ * cfatal(), cerror(), cwarn()
+ *              These routines format print messages to the user.
+ * mcpp_fputc(), mcpp_fputs(), mcpp_fprintf()
+ *              Wrap library functions to support alternate output to memory
+ *              buffer.
+ */
+
+#include    "system.H"
+#include    "internal.H"
+
+static void     scan_id( int c);
+                /* Scan an identifier           */
+static char *   scan_number( int c, char * out, char * out_end);
+                /* Scan a preprocessing number  */
+static char *   scan_op( int c, char * out);
+                /* Scan an operator or a punctuator     */
+static char *   parse_line( void);
+                /* Parse a logical line and convert comments    */
+static char *   read_a_comment( char * sp, size_t * sizp);
+                /* Read over a comment          */
+static char *   get_line( int in_comment);
+                /* Get a logical line from file, handle line-splicing   */
+static char *   at_eof( int in_comment);
+                /* Check erroneous end of file  */
+static void     do_msg( const char * severity, const char * format
+        , const char * arg1, long arg2, const char * arg3);
+                /* Putout diagnostic message    */
+static void     dump_token( int token_type, const char * cp);
+                /* Dump a token and its type    */
+
+#define EXP_MAC_IND_MAX     16
+/* Information of current expanding macros for diagnostic   */
+static struct {
+    const char *    name;       /* Name of the macro just expanded  */
+    int             to_be_freed;    /* Name should be freed later   */
+} expanding_macro[ EXP_MAC_IND_MAX];
+static int  exp_mac_ind = 0;        /* Index into expanding_macro[] */
+
+static int  in_token = FALSE;       /* For token scanning functions */
+static int  in_string = FALSE;      /* For get_ch() and parse_line()*/
+static int  squeezews = FALSE;
+
+#define MAX_CAT_LINE    256
+/* Information on line catenated by <backslash><newline>    */
+/* and by line-crossing comment.  This is for -K option.    */
+typedef struct catenated_line {
+    long    start_line;         /* Starting line of catenation      */
+    long    last_line;          /* Ending line of catanation        */
+    size_t  len[ MAX_CAT_LINE + 1];
+                        /* Length of successively catenated lines   */
+} CAT_LINE;
+static CAT_LINE bsl_cat_line;
+        /* Datum on the last catenated line by <backslash><newline> */
+static CAT_LINE com_cat_line;
+        /* Datum on the last catenated line by a line-crossing comment  */
+
+static int  use_mem_buffers = FALSE;
+
+void    init_support( void)
+{
+    in_token = in_string = squeezews = FALSE;
+    bsl_cat_line.len[ 0] = com_cat_line.len[ 0] = 0;
+    clear_exp_mac();
+}
+
+typedef struct  mem_buf {
+    char *  buffer;
+    char *  entry_pt;
+    size_t  size;
+    size_t  bytes_avail;
+} MEMBUF;
+
+static MEMBUF   mem_buffers[ NUM_OUTDEST];
+
+void    mcpp_use_mem_buffers(
+    int    tf
+)
+{
+    int i;
+
+    use_mem_buffers = tf ? TRUE : FALSE;
+
+    for (i = 0; i < NUM_OUTDEST; ++i) {
+        if (mem_buffers[ i].buffer)
+            /* Free previously allocated memory buffer  */
+            free( mem_buffers[ i].buffer);
+        if (use_mem_buffers) {
+            /* Output to memory buffers instead of files    */
+            mem_buffers[ i].buffer = NULL;
+            mem_buffers[ i].entry_pt = NULL;
+            mem_buffers[ i].size = 0;
+            mem_buffers[ i].bytes_avail = 0;
+        }
+    }
+}
+
+#define BUF_INCR_SIZE   (NWORK * 2)
+#define MAX( a, b)      (((a) > (b)) ? (a) : (b))
+
+static char *   append_to_buffer(
+    MEMBUF *    mem_buf_p,
+    const char *    string,
+    size_t      length
+)
+{
+    if (mem_buf_p->bytes_avail < length + 1) {  /* Need to allocate more memory */
+        size_t size = MAX( BUF_INCR_SIZE, length);
+
+        if (mem_buf_p->buffer == NULL) {            /* 1st append   */
+            mem_buf_p->size = size;
+            mem_buf_p->bytes_avail = size;
+            mem_buf_p->buffer = xmalloc( mem_buf_p->size);
+            mem_buf_p->entry_pt = mem_buf_p->buffer;
+        } else {
+            mem_buf_p->size += size;
+            mem_buf_p->bytes_avail += size;
+            mem_buf_p->buffer = xrealloc( mem_buf_p->buffer, mem_buf_p->size);
+            mem_buf_p->entry_pt = mem_buf_p->buffer + mem_buf_p->size
+                    - mem_buf_p->bytes_avail;
+        }
+    }
+
+    /* Append the string to the tail of the buffer  */
+    memcpy( mem_buf_p->entry_pt, string, length);
+    mem_buf_p->entry_pt += length;
+    mem_buf_p->entry_pt[ 0] = '\0';     /* Terminate the string buffer  */
+    mem_buf_p->bytes_avail -= length;
+
+    return mem_buf_p->buffer;
+}
+
+static int  mem_putc(
+    int     c,
+    OUTDEST od
+)
+{
+    char string[ 1];
+
+    string[ 0] = (char) c;
+
+    if (append_to_buffer( &(mem_buffers[ od]), string, 1) != NULL)
+        return 0;
+    else
+        return !0;
+}
+
+static int  mem_puts(
+    const char *    s,
+    OUTDEST od
+)
+{
+    if (append_to_buffer( &(mem_buffers[od]), s, strlen(s)) != NULL)
+        return 0;
+    else
+        return !0;
+}
+
+char *  mcpp_get_mem_buffer(
+    OUTDEST od
+)
+{
+    return mem_buffers[ od].buffer;
+}
+
+
+#define DEST2FP(od) \
+    (od == OUT) ? fp_out : \
+    ((od == ERR) ? fp_err : \
+    ((od == DBG) ? fp_debug : \
+    (NULL)))
+
+/*
+ * The following mcpp_*() wrapper functions are intended to centralize
+ * the output generated by MCPP.  They support memory buffer alternates to
+ * each of the primary output streams: out, err, debug.  The memory buffer
+ * output option would be used in a setup where MCPP has been built as a
+ * function call - i.e. mcpp_lib_main().
+ */
+
+int    mcpp_lib_fputc(
+    int     c,
+    OUTDEST od
+)
+{
+    if (use_mem_buffers) {
+        return mem_putc( c, od);
+    } else {
+        FILE *  stream = DEST2FP( od);
+
+        return (stream != NULL) ? fputc( c, stream) : EOF;
+    }
+}
+
+int (* mcpp_fputc)( int c, OUTDEST od) = mcpp_lib_fputc;
+
+int    mcpp_lib_fputs(
+    const char *    s,
+    OUTDEST od
+)
+{
+    if (use_mem_buffers) {
+        return mem_puts( s, od);
+    } else {
+        FILE *  stream = DEST2FP( od);
+
+        return (stream != NULL) ? fputs( s, stream) : EOF;
+    }
+}
+
+int (* mcpp_fputs)( const char * s, OUTDEST od) = mcpp_lib_fputs;
+
+#include <stdarg.h>
+
+int    mcpp_lib_fprintf(
+    OUTDEST od,
+    const char *    format,
+    ...
+)
+{
+    va_list ap;
+    FILE *  stream = DEST2FP( od);
+
+    if (stream != NULL) {
+        int rc;
+
+        va_start( ap, format);
+        if (use_mem_buffers) {
+            static char     mem_buffer[ NWORK];
+
+            rc = vsprintf( mem_buffer, format, ap);
+
+            if (rc != 0) {
+                rc = mem_puts( mem_buffer, od);
+            }
+        } else {
+            rc = vfprintf( stream, format, ap);
+        }
+        va_end( ap);
+
+        return rc;
+
+    } else {
+        return EOF;
+    }
+}
+
+int (* mcpp_fprintf)( OUTDEST od, const char * format, ...) = mcpp_lib_fprintf;
+
+void    mcpp_reset_def_out_func( void)
+{
+    mcpp_fputc = mcpp_lib_fputc;
+    mcpp_fputs = mcpp_lib_fputs;
+    mcpp_fprintf = mcpp_lib_fprintf;
+}
+
+void    mcpp_set_out_func(
+    int (* func_fputc)( int c, OUTDEST od),
+    int (* func_fputs)( const char * s, OUTDEST od),
+    int (* func_fprintf)( OUTDEST od, const char * format, ...)
+)
+{
+    mcpp_fputc = func_fputc;
+    mcpp_fputs = func_fputs;
+    mcpp_fprintf = func_fprintf;
+}
+
+int     get_unexpandable(
+    int     c,                              /* First char of token  */
+    int     diag                            /* Flag of diagnosis    */
+)
+/*
+ * Get the next unexpandable token in the line, expanding macros.
+ * Return the token type.  The token is written in work_buf[].
+ * The once expanded macro is never expanded again.
+ * Called only from the routines processing #if (#elif, #assert), #line and
+ * #include directives in order to diagnose some subtle macro expansions.
+ */
+{
+    DEFBUF *    defp = NULL;
+    FILEINFO *  file;
+    FILE *  fp = NULL;
+    LINE_COL    line_col = { 0L, 0};
+    int     token_type = NO_TOKEN;
+    int     has_pragma;
+
+    while (c != EOS && c != '\n'                /* In a line        */
+            && (fp = infile->fp         /* Preserve current state   */
+                , (token_type
+                    = scan_token( c, (workp = work_buf, &workp), work_end))
+                    == NAM)                     /* Identifier       */
+            && fp != NULL                       /* In source !      */
+            && (defp = is_macro( NULL)) != NULL) {      /* Macro    */
+        expand_macro( defp, work_buf, work_end, line_col, & has_pragma);
+                                                /* Expand macro     */
+        if (has_pragma)
+            cerror( "_Pragma operator found in directive line"      /* _E_  */
+                    , NULL, 0L, NULL);
+        file = unget_string( work_buf, defp->name);     /* Stack to re-read */
+        c = skip_ws();                          /* Skip TOK_SEP     */
+        if (file != infile && macro_line != MACRO_ERROR && (warn_level & 1)) {
+            /* This diagnostic is issued even if "diag" is FALSE.   */
+            cwarn( "Macro \"%s\" is expanded to 0 token"    /* _W1_ */
+                    , defp->name, 0L, NULL);
+            dump_a_def( "    macro", defp, FALSE, TRUE, fp_err);
+        }
+    }
+
+    if (c == '\n' || c == EOS) {
+        unget_ch();
+        return  NO_TOKEN;
+    }
+
+    if (diag && fp == NULL && defp && (warn_level & 1)) {
+        char    tmp[ NWORK + 16];
+        char *  tmp_end = tmp + NWORK;
+        char *  tmp_p;
+        file = unget_string( infile->buffer, defp->name);   /* To diagnose  */
+        c = get_ch();
+        while (file == infile) {    /* Search the expanded macro    */
+            if (scan_token( c, (tmp_p = tmp, &tmp_p), tmp_end) != NAM) {
+                c = get_ch();
+                continue;
+            }
+            if (str_eq( identifier, "defined")) {
+                cwarn( "Macro \"%s\" is expanded to \"defined\""    /* _W1_ */
+                        , defp->name, 0L, NULL);
+                break;
+            }
+            c = get_ch();
+        }
+        if (file == infile) {
+            infile->bptr += strlen( infile->bptr);
+            get_ch();
+        }
+        unget_ch();
+        if (token_type == OPE) {
+            unget_string( work_buf, NULL);  /* Set again 'openum'   */
+            scan_token( get_ch(), (workp = work_buf, &workp), work_end);
+        }
+    }
+
+    return  token_type;
+}
+
+void    skip_nl( void)
+/*
+ * Skip to the end of the current input line.
+ */
+{
+    insert_sep = NO_SEP;
+    while (infile && infile->fp == NULL) {  /* Stacked text         */
+        infile->bptr += strlen( infile->bptr);
+        get_ch();                           /* To the parent        */
+    }
+    if (infile)
+        infile->bptr += strlen( infile->bptr);  /* Source line      */
+}
+
+int     skip_ws( void)
+/*
+ * Skip over horizontal whitespaces.
+ */
+{
+    int     c;
+
+    do {
+        c = get_ch();
+    } while (char_type[ c] & HSP);
+
+    return  c;
+}
+
+#define MBMASK          0xFF    /* Mask to hide multibyte char      */
+
+int     scan_token(
+    int     c,                  /* The first character of the token */
+    char ** out_pp,             /* Pointer to pointer to output buf */
+    char *  out_end             /* End of output buffer             */
+)
+/*
+ *   Scan the next token of any type.
+ *   The token is written out to the specified buffer and the output pointer
+ * is advanced.  Token is terminated by EOS.  Return the type of token.
+ *   If the token is an identifier, the token is also in identifier[].
+ *   If the token is a operator or punctuator, return OPE.
+ *   If 'c' is token separator, then return SEP.
+ *   If 'c' is not the first character of any known token and not a token
+ * separator, return SPE.
+ *   In POST_STD mode, inserts token separator (a space) between any tokens of
+ * source.
+ */
+{
+    char *  out = *out_pp;              /* Output pointer           */
+    int     ch_type;                    /* Type of character        */
+    int     token_type = 0;             /* Type of token            */
+    int     ch;
+
+    in_token = TRUE;                /* While a token is scanned */
+    c = c & UCHARMAX;
+    ch_type = char_type[ c] & MBMASK;
+
+    switch (ch_type) {
+    case LET:                           /* Probably an identifier   */
+        switch (c) {
+        case 'L':
+            ch = get_ch();
+            if (char_type[ ch] & QUO) { /* char_type[ ch] == QUO    */
+                if (ch == '"')
+                    token_type = WSTR;  /* Wide-char string literal */
+                else
+                    token_type = WCHR;  /* Wide-char constant       */
+                c = ch;
+                *out++ = 'L';
+                break;                  /* Fall down to "case QUO:" */
+            } else {
+                unget_ch();
+            }                           /* Fall through             */
+        default:                        /* An identifier            */
+            scan_id( c);
+            out = stpcpy( out, identifier);
+            token_type = NAM;
+            break;
+        }
+        if (token_type == NAM)
+            break;
+        /* Else fall through    -- i.e. WSTR, WCHR  */
+    case QUO:                   /* String or character constant     */
+        out = scan_quote( c, out, out_end, FALSE);
+        if (token_type == 0) {                  /* Without prefix L */
+            if (c == '"')
+                token_type = STR;
+            else
+                token_type = CHR;
+        }   /* Else WSTR or WCHR    */
+        break;
+    case DOT:
+        ch = get_ch();
+        unget_ch();
+        if ((char_type[ ch] & DIG) == 0)        /* Operator '.' or '...'    */
+            goto  operat;
+        /* Else fall through    */
+    case DIG:                           /* Preprocessing number     */
+        out = scan_number( c, out, out_end);
+        token_type = NUM;
+        break;
+    case PUNC:
+operat: out = scan_op( c, out);         /* Operator or punctuator   */
+        token_type = OPE;       /* Number is set in global "openum" */
+        break;
+    default:                /* Special tokens or special characters */
+        if (((c == CAT || c == ST_QUOTE)) || (char_type[ c] & SPA))
+            token_type = SEP;       /* Token separator or magic char*/
+        else
+            token_type = SPE;
+            /* Unkown token ($, @, multi-byte character or Latin    */
+        *out++ = c;
+        *out = EOS;
+        break;
+    }
+
+    if (out_end < out)
+        cfatal( "Buffer overflow scanning token \"%s\""     /* _F_  */
+                , *out_pp, 0L, NULL);
+    if (mcpp_debug & TOKEN)
+        dump_token( token_type, *out_pp);
+    *out_pp = out;
+
+    in_token = FALSE;               /* Token scanning has been done */
+    return  token_type;
+}
+
+static void scan_id(
+    int     c                               /* First char of id     */
+)
+/*
+ * Reads the next identifier and put it into identifier[].
+ * The caller has already read the first character of the identifier.
+ */
+{
+    static char * const     limit = &identifier[ IDMAX];
+    size_t  len;                        /* Length of identifier     */
+    char *  bp = identifier;
+
+    if (c == IN_SRC) {                  /* Magic character  */
+        *bp++ = c;
+        if ((mcpp_debug & MACRO_CALL) && ! in_directive) {
+            *bp++ = get_ch();           /* Its 2-bytes      */
+            *bp++ = get_ch();           /*      argument    */
+        }
+        c = get_ch();
+    }
+
+    do {
+        if (bp < limit)
+            *bp++ = c;
+
+        c = get_ch();
+    } while ((char_type[ c] & (LET | DIG))      /* Letter or digit  */
+        );
+
+    unget_ch();
+    *bp = EOS;
+
+    if (bp >= limit && (warn_level & 1))        /* Limit of token   */
+        cwarn( "Too long identifier truncated to \"%s\""    /* _W1_ */
+                , identifier, 0L, NULL);
+
+    len = bp - identifier;
+#if IDMAX > IDLEN90MIN
+    /* UCN16, UCN32, MBCHAR are counted as one character for each.  */
+    if (infile->fp && len > std_limits.id_len && (warn_level & 4))
+        cwarn( "Identifier longer than %.0s%ld characters \"%s\""   /* _W4_ */
+                , NULL, (long) std_limits.id_len, identifier);
+#endif  /* IDMAX > IDLEN90MIN   */
+}
+
+char *  scan_quote(
+    int         delim,              /* ', " or < (header-name)      */
+    char *      out,                /* Output buffer                */
+    char *      out_end,            /* End of output buffer         */
+    int         diag                /* Diagnostic should be output  */
+)
+/*
+ * Scan off a string literal or character constant to the output buffer.
+ * Report diagnosis if the quotation is terminated by newline or character
+ * constant is empty (provided 'diag' is TRUE).
+ * Return the next output pointer or NULL (on error).
+ */
+{
+    const char * const      skip_line = ", skipped the line";   /* _E_  */
+    const char * const      unterm_string
+                        = "Unterminated string literal%s";
+    const char * const      unterm_char
+                        = "Unterminated character constant%s";
+    const char * const      empty_const
+                        = "Empty character constant%s";
+    const char *    skip;
+    size_t      len;
+    int         c;
+    char *      out_p = out;
+
+    /* Set again in case of called from routines other than scan_token().   */
+    in_token = TRUE;
+    *out_p++ = delim;
+    if (delim == '<')
+        delim = '>';
+
+    while ((c = get_ch()) != EOS) {
+
+#if MBCHAR
+        if (char_type[ c] & mbchk) {
+            /* First of multi-byte character (or shift-sequence)    */
+            char *  bptr = infile->bptr;
+            len = mb_read( c, &infile->bptr, (*out_p++ = c, &out_p));
+            if (len & MB_ERROR) {
+                if (infile->fp != NULL && compiling && diag) {
+                    if (warn_level & 1) {
+                        char *  buf;
+                        size_t  chlen;
+                        buf = xmalloc( chlen = infile->bptr - bptr + 2);
+                        memcpy( buf, bptr, chlen - 1);
+                        buf[ chlen - 1] = EOS;
+                        cwarn(
+    "Illegal multi-byte character sequence \"%s\" in quotation",    /* _W1_ */
+                        buf, 0L, NULL);
+                        free( buf);
+                    }
+                }
+                continue;
+            } else {        /* Valid multi-byte character (or sequence) */
+                goto  chk_limit;
+            }
+        }
+#endif
+        if (c == delim) {
+            break;
+        } else if (c == '\\' && delim != '>') { /* In string literal    */
+            *out_p++ = c;                   /* Escape sequence      */
+            c = get_ch();
+#if MBCHAR
+            if (char_type[ c] & mbchk) {
+                                /* '\\' followed by multi-byte char */
+                unget_ch();
+                continue;
+            }
+#endif
+        } else if (c == '\n') {
+            break;
+        }
+        if (diag && iscntrl( c) && ((char_type[ c] & SPA) == 0)
+                && (warn_level & 1))
+            cwarn(
+            "Illegal control character %.0s0x%02lx in quotation"    /* _W1_ */
+                    , NULL, (long) c, NULL);
+        *out_p++ = c;
+chk_limit:
+        if (out_end < out_p) {
+            *out_end = EOS;
+            cfatal( "Too long quotation", NULL, 0L, NULL);  /* _F_  */
+        }
+    }
+
+    if (c == '\n' || c == EOS)
+        unget_ch();
+    if (c == delim)
+        *out_p++ = delim;
+    *out_p = EOS;
+    if (diag) {                         /* At translation phase 3   */
+        skip = (infile->fp == NULL) ? NULL : skip_line;
+        if (c != delim) {
+            if (delim == '"') {
+                cerror( unterm_string, skip, 0L, NULL); /* _E_  */
+            } else if (delim == '\'') {
+                cerror( unterm_char, skip, 0L, NULL);   /* _E_  */
+            } else {
+                cerror( "Unterminated header name %s%.0ld%s"        /* _E_  */
+                        , out, 0L, skip);
+            }
+            out_p = NULL;
+        } else if (delim == '\'' && out_p - out <= 2) {
+            cerror( empty_const, skip, 0L, NULL);       /* _E_  */
+            out_p = NULL;
+            goto  done;
+        }
+#if NWORK-2 > SLEN90MIN
+        if (out_p - out > std_limits.str_len && (warn_level & 4))
+            cwarn( "Quotation longer than %.0s%ld bytes"    /* _W4_ */
+                    , NULL, std_limits.str_len, NULL);
+#endif
+    }
+
+done:
+    in_token = FALSE;
+    return  out_p;
+}
+
+static char *   scan_number(
+    int     c,                              /* First char of number */
+    char *  out,                            /* Output buffer        */
+    char *  out_end                 /* Limit of output buffer       */
+)
+/*
+ * Read a preprocessing number.
+ * By scan_token() we know already that the first c is from 0 to 9 or dot,
+ * and if c is dot then the second character is digit.
+ * Returns the advanced output pointer.
+ * Note: preprocessing number permits non-numeric forms such as 3E+xy,
+ *   which are used in stringization or token-concatenation.
+ */
+{
+    char *      out_p = out;        /* Current output pointer       */
+
+    do {
+        *out_p++ = c;
+        if (c == 'E' || c == 'e'    /* Sign should follow 'E', 'e', */
+                ) {
+            c = get_ch();
+            if (c == '+' || c == '-') {
+                *out_p++ = c;
+                c = get_ch();
+            }
+        } else {
+            c = get_ch();
+        }
+    } while ((char_type[ c] & (DIG | DOT | LET))    /* Digit, dot or letter */
+        );
+
+    *out_p = EOS;
+    if (out_end < out_p)
+        cfatal( "Too long pp-number token \"%s\""           /* _F_  */
+                , out, 0L, NULL);
+    unget_ch();
+    return  out_p;
+}
+
+static char *   scan_op(
+    int     c,                          /* First char of the token  */
+    char *  out                         /* Output buffer            */
+)
+/*
+ * Scan C operator or punctuator into the specified buffer.
+ * Return the advanced output pointer.
+ * The code-number of the operator is stored to global variable 'openum'.
+ * Note: '#' is not an operator nor a punctuator in other than directive line,
+ *   nevertheless is handled as a punctuator in this cpp for convenience.
+ */
+{
+    int     c2, c3;
+
+    *out++ = c;
+
+    switch (c) {
+    case '~':   openum = OP_COM;    break;
+    case '(':   openum = OP_LPA;    break;
+    case ')':   openum = OP_RPA;    break;
+    case '?':   openum = OP_QUE;    break;
+    case ';':    case '[':    case ']':    case '{':
+    case '}':    case ',':
+        openum = OP_1;
+        break;
+    default:
+        openum = OP_2;                  /* Tentative guess          */
+    }
+
+    if (openum != OP_2) {               /* Single byte operators    */
+        *out = EOS;
+        return  out;
+    }
+
+    c2 = get_ch();                      /* Possibly two bytes ops   */
+    *out++ = c2;
+
+    switch (c) {
+    case '=':
+        openum = ((c2 == '=') ? OP_EQ : OP_1);          /* ==, =    */
+        break;
+    case '!':
+        openum = ((c2 == '=') ? OP_NE : OP_NOT);        /* !=, !    */
+        break;
+    case '&':
+        switch (c2) {
+        case '&':   openum = OP_ANA;        break;      /* &&       */
+        case '=':   /* openum = OP_2; */    break;      /* &=       */
+        default :   openum = OP_AND;        break;      /* &        */
+        }
+        break;
+    case '|':
+        switch (c2) {
+        case '|':   openum = OP_ORO;        break;      /* ||       */
+        case '=':   /* openum = OP_2; */    break;      /* |=       */
+        default :   openum = OP_OR;         break;      /* |        */
+        }
+        break;
+    case '<':
+        switch (c2) {
+        case '<':   c3 = get_ch();
+            if (c3 == '=') {
+                openum = OP_3;                          /* <<=      */
+                *out++ = c3;
+            } else {
+                openum = OP_SL;                         /* <<       */
+                unget_ch();
+            }
+            break;
+        case '=':   openum = OP_LE;         break;      /* <=       */
+        case ':':                                   /* <: i.e. [    */
+            openum = OP_LT;
+            break;
+        case '%':                                   /* <% i.e. {    */
+            openum = OP_LT;
+            break;
+        default :   openum = OP_LT;         break;      /* <        */
+        }
+        break;
+    case '>':
+        switch (c2) {
+        case '>':   c3 = get_ch();
+            if (c3 == '=') {
+                openum = OP_3;                          /* >>=      */
+                *out++ = c3;
+            } else {
+                openum = OP_SR;                         /* >>       */
+                unget_ch();
+            }
+            break;
+        case '=':   openum = OP_GE;     break;          /* >=       */
+        default :   openum = OP_GT;     break;          /* >        */
+        }
+        break;
+    case '#':
+        if ((in_define || macro_line))  /* in #define or macro  */
+            openum = ((c2 == '#') ? OP_CAT : OP_STR);   /* ##, #    */
+        else
+            openum = OP_1;                              /* #        */
+        break;
+    case '+':
+        switch (c2) {
+        case '+':                                       /* ++       */
+        case '=':   /* openum = OP_2; */    break;      /* +=       */
+        default :   openum = OP_ADD;        break;      /* +        */
+        }
+        break;
+    case '-':
+        switch (c2) {
+        case '-':                                       /* --       */
+        case '=':                                       /* -=       */
+            /* openum = OP_2;   */
+            break;
+        case '>':
+           /* else openum = OP_2;  */              /* ->       */
+            /* else openum = OP_2;      */
+            break;
+        default :   openum = OP_SUB;        break;      /* -        */
+        }
+        break;
+    case '%':
+        switch (c2) {
+        case '=':                           break;      /* %=       */
+        case '>':                                   /* %> i.e. }    */
+            openum = OP_MOD;
+            break;
+        case ':':
+            openum = OP_MOD;
+            break;
+        default :   openum = OP_MOD;        break;      /* %        */
+        }
+        break;
+    case '*':
+        if (c2 != '=')                                  /* *        */
+            openum = OP_MUL;
+        /* else openum = OP_2;  */                      /* *=       */
+        break;
+    case '/':
+        if (c2 != '=')                                  /* /        */
+            openum = OP_DIV;
+        /* else openum = OP_2;  */                      /* /=       */
+        break;
+    case '^':
+        if (c2 != '=')                                  /* ^        */
+            openum = OP_XOR;
+        /* else openum = OP_2;  */                      /* ^=       */
+        break;
+    case '.':
+        if (c2 == '.') {
+            c3 = get_ch();
+            if (c3 == '.') {
+                openum = OP_ELL;                    /* ...      */
+                *out++ = c3;
+                break;
+            } else {
+                unget_ch();
+                openum = OP_1;
+            }
+        } else {                                    /* .        */
+            openum = OP_1;
+        }
+        break;
+    case ':':
+        openum = OP_COL;
+        break;
+    default:                                    /* Never reach here */
+        cfatal( "Bug: Punctuator is mis-implemented %.0s0lx%x"      /* _F_  */
+                , NULL, (long) c, NULL);
+        openum = OP_1;
+        break;
+    }
+
+    switch (openum) {
+    case OP_STR:
+        if (c == '%')    break;              /* %:   */
+    case OP_1:
+    case OP_NOT:    case OP_AND:    case OP_OR:     case OP_LT:
+    case OP_GT:     case OP_ADD:    case OP_SUB:    case OP_MOD:
+    case OP_MUL:    case OP_DIV:    case OP_XOR:    case OP_COM:
+    case OP_COL:    /* Any single byte operator or punctuator       */
+        unget_ch();
+        out--;
+        break;
+    default:        /* Two or more bytes operators or punctuators   */
+        break;
+    }
+
+    *out = EOS;
+    return  out;
+}
+
+void    expanding(
+    const char *    name,       /* The name of (nested) macro just expanded. */
+    int             to_be_freed /* The name should be freed later.  */
+)
+/*
+ * Remember used macro name for diagnostic.
+ */
+{
+    if (exp_mac_ind < EXP_MAC_IND_MAX - 1) {
+        exp_mac_ind++;
+    } else {
+        clear_exp_mac();
+        exp_mac_ind++;
+    }
+    expanding_macro[ exp_mac_ind].name = name;
+    expanding_macro[ exp_mac_ind].to_be_freed = to_be_freed;
+}
+
+void    clear_exp_mac( void)
+/*
+ * Initialize expanding_macro[] freeing names registered in
+ * name_to_be_freed[].
+ */
+{
+    int     i;
+
+    for (i = 1; i < EXP_MAC_IND_MAX; i++) {
+        if (expanding_macro[ i].to_be_freed) {
+            free( (void *) expanding_macro[ i].name);
+            expanding_macro[ i].to_be_freed = FALSE;
+        }
+    }
+    exp_mac_ind = 0;
+}
+
+int     get_ch( void)
+/*
+ * Return the next character from a macro or the current file.
+ * Always return the value representable by unsigned char.
+ */
+{
+    int             len;
+    int             c;
+    FILEINFO *      file;
+
+    /*
+     * 'in_token' is set to TRUE while scan_token() is executed (and
+     * scan_id(), scan_quote(), scan_number(), scan_ucn() and scan_op()
+     * via scan_token()) in Standard mode to simplify tokenization.
+     * Any token cannot cross "file"s.
+     */
+    if (in_token)
+        return (*infile->bptr++ & UCHARMAX);
+
+    if ((file = infile) == NULL)
+        return  CHAR_EOF;                   /* End of all input     */
+
+    if (mcpp_debug & GETC) {
+        mcpp_fprintf( DBG, "get_ch(%s) '%c' line %ld, bptr = %d, buffer"
+            , file->fp ? cur_fullname : file->real_fname ? file->real_fname
+            : file->filename ? file->filename : "NULL"
+            , *file->bptr & UCHARMAX
+            , src_line, (int) (file->bptr - file->buffer));
+        dump_string( NULL, file->buffer);
+        dump_unget( "get entrance");
+    }
+
+    /*
+     * Read a character from the current input logical line or macro.
+     * At EOS, either finish the current macro (freeing temporary storage)
+     * or get another logical line by parse_line().
+     * At EOF, exit the current file (#included) or, at EOF from the MCPP input
+     * file, return CHAR_EOF to finish processing.
+     * The character is converted to int with no sign-extension.
+     */
+    if ((c = (*file->bptr++ & UCHARMAX)) != EOS) {
+        return  c;                      /* Just a character     */
+    }
+
+    /*
+     * Nothing in current line or macro.  Get next line (if input from a
+     * file), or do end of file/macro processing, and reenter get_ch() to
+     * restart from the top.
+     */
+    if (file->fp &&                         /* In source file       */
+            parse_line() != NULL)           /* Get line from file   */
+        return  get_ch();
+    /*
+     * Free up space used by the (finished) file or macro and restart
+     * input from the parent file/macro, if any.
+     */
+    infile = file->parent;                  /* Unwind file chain    */
+    free( file->buffer);                    /* Free buffer          */
+    if (infile == NULL) {                   /* If at end of input   */
+        free( file->filename);
+        free( file->src_dir);
+        free( file);    /* full_fname is the same with filename for main file*/
+        return  CHAR_EOF;                   /* Return end of file   */
+    }
+    if (file->fp) {                         /* Source file included */
+        free( file->filename);              /* Free filename        */
+        free( file->src_dir);               /* Free src_dir         */
+        fclose( file->fp);                  /* Close finished file  */
+        /* Do not free file->real_fname and file->full_fname        */
+        cur_fullname = infile->full_fname;
+        cur_fname = infile->real_fname;     /* Restore current fname*/
+        if (infile->pos != 0L) {            /* Includer was closed  */
+            infile->fp = mcpp_fopen( cur_fullname, "r");
+            fseek( infile->fp, infile->pos, SEEK_SET);
+        }   /* Re-open the includer and restore the file-position   */
+        len = (int) (infile->bptr - infile->buffer);
+        infile->buffer = xrealloc( infile->buffer, NBUFF);
+            /* Restore full size buffer to get the next line        */
+        infile->bptr = infile->buffer + len;
+        src_line = infile->line;            /* Reset line number    */
+        inc_dirp = infile->dirp;            /* Includer's directory */
+        mcpp_set_out_func( infile->last_fputc, infile->last_fputs,
+                           infile->last_fprintf);
+        include_nest--;
+        src_line++;                         /* Next line to #include*/
+        sharp( NULL, infile->include_opt ? 1 : (file->include_opt ? 0 : 2));
+            /* Need a #line now.  Marker depends on include_opt.    */
+            /* The file of include_opt should be marked as 1.       */
+            /* Else if returned from include_opt file, it is the    */
+            /* main input file, and should not be marked.           */
+            /* Else, it is normal includer file, and marked as 2.   */
+        src_line--;
+        newlines = 0;                       /* Clear the blank lines*/
+        if (mcpp_debug & MACRO_CALL)    /* Should be re-initialized */
+            com_cat_line.last_line = bsl_cat_line.last_line = 0L;
+    } else if (file->filename) {            /* Expanding macro      */
+        if (macro_name)     /* file->filename should be freed later */
+            expanding( file->filename, TRUE);
+        else
+            free( file->filename);
+    }
+    free( file);                            /* Free file space      */
+    return  get_ch();                       /* Get from the parent  */
+}
+
+static char *   parse_line( void)
+/*
+ * ANSI (ISO) C: translation phase 3.
+ * Parse a logical line.
+ * Check illegal control characters.
+ * Check unterminated string literal, character constant or comment.
+ * Convert each comment to one space (or spaces of the comment length on
+ * 'keep_spaces' mode)..
+ * Squeeze succeding white spaces other than <newline> (including comments) to
+ * one space (unless keep_spaces == TRUE).
+ * The lines might be spliced by comments which cross the lines.
+ */
+{
+    char *      temp;                       /* Temporary buffer     */
+    char *      limit;                      /* Buffer end           */
+    char *      tp;     /* Current pointer into temporary buffer    */
+    char *      sp;                 /* Pointer into input buffer    */
+    size_t      com_size;
+    int         c;
+
+    if ((sp = get_line( FALSE)) == NULL)    /* Next logical line    */
+        return  NULL;                       /* End of a file        */
+    tp = temp = xmalloc( (size_t) NBUFF);
+    limit = temp + NBUFF - 2;
+
+    while (char_type[ c = *sp++ & UCHARMAX] & HSP) {
+        /* Preserve line top horizontal white spaces    */
+        /*      as they are for human-readability       */
+        *tp++ = c;
+    }
+    sp--;
+
+    while ((c = *sp++ & UCHARMAX) != '\n') {
+
+        switch (c) {
+        case '/':
+            switch (*sp++) {
+            case '*':                       /* Start of a comment   */
+                if ((sp = read_a_comment( sp, &com_size)) == NULL) {
+                    free( temp);            /* End of file with un- */
+                    return  NULL;           /*   terminated comment */
+                }
+                if (temp == tp ||
+                        ! (char_type[ *(tp - 1) & UCHARMAX] & HSP))
+                    *tp++ = ' ';        /* Squeeze white spaces */
+                break;
+            case '/':                                       /* //   */
+                /* Comment when C++ or __STDC_VERSION__ >= 199901L      */
+                /* Need not to convert to a space because '\n' follows  */
+                if ((warn_level & 2))
+                    cwarn( "Parsed \"//\" as comment"       /* _W2_ */
+                            , NULL, 0L, NULL);
+                if (keep_comments) {
+                    sp -= 2;
+                    while (*sp != '\n')     /* Until end of line    */
+                        mcpp_fputc( *sp++, OUT);
+                    mcpp_fputc( '\n', OUT);
+                    wrong_line = TRUE;
+                }
+                goto  end_line;
+            default:                        /* Not a comment        */
+                *tp++ = '/';
+                sp--;                       /* To re-read           */
+                break;
+            }
+            break;
+        case '\r':                          /* Vertical white spaces*/
+                /* Note that [CR+LF] is already converted to [LF].  */
+        case '\f':
+        case '\v':
+            if (warn_level & 4)
+                cwarn( "Converted %.0s0x%02lx to a space"   /* _W4_ */
+                    , NULL, (long) c, NULL);
+        case '\t':                          /* Horizontal space     */
+        case ' ':
+            if (! (char_type[ *(tp - 1) & UCHARMAX] & HSP)) {
+                *tp++ = ' ';                /* Squeeze white spaces */
+            }
+            break;
+        case '"':                           /* String literal       */
+        case '\'':                          /* Character constant   */
+            infile->bptr = sp;
+            tp = scan_quote( c, tp, limit, TRUE);
+            if (tp == NULL) {
+                free( temp);                /* Unbalanced quotation */
+                return  parse_line();       /* Skip the line        */
+            }
+            sp = infile->bptr;
+            break;
+        default:
+            if (iscntrl( c)) {
+                cerror(             /* Skip the control character   */
+    "Illegal control character %.0s0x%02lx, skipped the character"  /* _E_  */
+                        , NULL, (long) c, NULL);
+            } else {                        /* Any valid character  */
+                *tp++ = c;
+            }
+            break;
+        }
+
+        if (limit < tp) {
+            *tp = EOS;
+            cfatal( "Too long line spliced by comments"     /* _F_  */
+                    , NULL, 0L, NULL);
+        }
+    }
+
+end_line:
+    if (temp < tp && (char_type[ *(tp - 1) & UCHARMAX] & HSP))
+        tp--;                       /* Remove trailing white space  */
+    *tp++ = '\n';
+    *tp = EOS;
+    infile->bptr = strcpy( infile->buffer, temp);   /* Write back to buffer */
+    free( temp);
+    if (macro_line != 0 && macro_line != MACRO_ERROR) { /* Expanding macro  */
+        temp = infile->buffer;
+        while (char_type[ *temp & UCHARMAX] & HSP)
+            temp++;
+        if (*temp == '#'        /* This line starts with # token    */
+                || (*temp == '%' && *(temp + 1) == ':'))
+            if (warn_level & 1)
+                cwarn(
+    "Macro started at line %.0s%ld swallowed directive-like line"   /* _W1_ */
+                    , NULL, macro_line, NULL);
+    }
+    return  infile->buffer;
+}
+
+static char *   read_a_comment(
+    char *      sp,                         /* Source               */
+    size_t *    sizp                        /* Size of the comment  */
+)
+/*
+ * Read over a comment (which may cross the lines).
+ */
+{
+    int         c;
+    char *      saved_sp;
+    int         cat_line = 0;       /* Number of catenated lines    */
+
+    if (keep_comments)                      /* If writing comments  */
+        mcpp_fputs( "/*", OUT);             /* Write the initializer*/
+    c = *sp++;
+
+    while (1) {                             /* Eat a comment        */
+        if (keep_comments)
+            mcpp_fputc( c, OUT);
+
+        switch (c) {
+        case '/':
+            if ((c = *sp++) != '*')         /* Don't let comments   */
+                continue;                   /*   nest.              */
+            if (warn_level & 1)
+                cwarn( "\"/*\" within comment", NULL, 0L, NULL);    /* _W1_ */
+            if (keep_comments)
+                mcpp_fputc( c, OUT);
+                                            /* Fall into * stuff    */
+        case '*':
+            if ((c = *sp++) != '/')         /* If comment doesn't   */
+                continue;                   /*   end, look at next. */
+            if (keep_comments) {            /* Put out comment      */
+                mcpp_fputc( c, OUT);        /*   terminator, too.   */
+                mcpp_fputc( '\n', OUT);     /* Append '\n' to avoid */
+                    /*  trouble on some other tools such as rpcgen. */
+                wrong_line = TRUE;
+            }
+            if ((mcpp_debug & MACRO_CALL) && compiling) {
+                if (cat_line) {
+                    cat_line++;
+                    com_cat_line.len[ cat_line]         /* Catenated length */
+                            = com_cat_line.len[ cat_line - 1]
+                                + strlen( infile->buffer) - 1;
+                                            /* '-1' for '\n'        */
+                    com_cat_line.last_line = src_line;
+                }
+            }
+            return  sp;                     /* End of comment       */
+        case '\n':                          /* Line-crossing comment*/
+            if ((mcpp_debug & MACRO_CALL) && compiling) {
+                                    /* Save location informations   */
+                if (cat_line == 0)  /* First line of catenation     */
+                    com_cat_line.start_line = src_line;
+                if (cat_line >= MAX_CAT_LINE - 1) {
+                    *sizp = 0;      /* Discard the too long comment */
+                    cat_line = 0;
+                    if (warn_level & 4)
+                        cwarn(
+                        "Too long comment, discarded up to here"    /* _W4_ */
+                                , NULL, 0L, NULL);
+                }
+                cat_line++;
+                com_cat_line.len[ cat_line]
+                        = com_cat_line.len[ cat_line - 1]
+                            + strlen( infile->buffer) - 1;
+            }
+            if ((saved_sp = sp = get_line( TRUE)) == NULL)
+                return  NULL;       /* End of file within comment   */
+                /* Never happen, because at_eof() supplement closing*/
+            wrong_line = TRUE;      /* We'll need a #line later     */
+            break;
+        default:                            /* Anything else is     */
+            break;                          /*   just a character   */
+        }                                   /* End switch           */
+
+        c = *sp++;
+    }                                       /* End comment loop     */
+
+    return  sp;                             /* Never reach here     */
+}
+
+static char *   mcpp_fgets(
+    char *  s,
+    int     size,
+    FILE *  stream
+)
+{
+    return fgets( s, size, stream);
+}
+
+static char *   get_line(
+    int     in_comment
+)
+/*
+ * ANSI (ISO) C: translation phase 1, 2.
+ * Get the next logical line from source file.
+ * Convert [CR+LF] to [LF].
+ */
+{
+#define cr_warn_level 1
+    static int  cr_converted;
+    int     converted = FALSE;
+    int     len;                            /* Line length - alpha  */
+    char *  ptr;
+    int     cat_line = 0;           /* Number of catenated lines    */
+
+    if (infile == NULL)                     /* End of a source file */
+        return  NULL;
+    ptr = infile->bptr = infile->buffer;
+    if ((mcpp_debug & MACRO_CALL) && src_line == 0) /* Initialize   */
+        com_cat_line.last_line = bsl_cat_line.last_line = 0L;
+
+    while (mcpp_fgets( ptr, (int) (infile->buffer + NBUFF - ptr), infile->fp)
+            != NULL) {
+        /* Translation phase 1  */
+        src_line++;                 /* Gotten next physical line    */
+        if (src_line == std_limits.line_num + 1
+                && (warn_level & 1))
+            cwarn( "Line number %.0s\"%ld\" got beyond range"       /* _W1_ */
+                    , NULL, src_line, NULL);
+        if (mcpp_debug & (TOKEN | GETC)) {  /* Dump it to DBG       */
+            mcpp_fprintf( DBG, "\n#line %ld (%s)", src_line, cur_fullname);
+            dump_string( NULL, ptr);
+        }
+        len = strlen( ptr);
+        if (NBUFF - 1 <= ptr - infile->buffer + len
+                && *(ptr + len - 1) != '\n') {
+                /* The line does not yet end, though the buffer is full.    */
+            if (NBUFF - 1 <= len)
+                cfatal( "Too long source line"              /* _F_  */
+                        , NULL, 0L, NULL);
+            else
+                cfatal( "Too long logical line"             /* _F_  */
+                        , NULL, 0L, NULL);
+        }
+        if (*(ptr + len - 1) != '\n')   /* Unterminated source line */
+            break;
+        if (len >= 2 && *(ptr + len - 2) == '\r') {         /* [CR+LF]      */
+            *(ptr + len - 2) = '\n';
+            *(ptr + --len) = EOS;
+            if (! cr_converted && (warn_level & cr_warn_level)) {
+                cwarn( "Converted [CR+LF] to [LF]"  /* _W1_ _W2_    */
+                        , NULL, 0L, NULL);
+                cr_converted = TRUE;
+            }
+        }
+        if (converted)
+            len = strlen( ptr);
+        /* Translation phase 2  */
+        len -= 2;
+        if (len >= 0) {
+            if (*(ptr + len) == '\\') {
+                        /* <backslash><newline> (not MBCHAR)    */
+                ptr = infile->bptr += len;  /* Splice the lines */
+                wrong_line = TRUE;
+                if ((mcpp_debug & MACRO_CALL) && compiling) {
+                                /* Save location informations   */
+                    if (cat_line == 0)      /* First line of catenation */
+                        bsl_cat_line.start_line = src_line;
+                    if (cat_line < MAX_CAT_LINE)
+                                /* Record the catenated length  */
+                        bsl_cat_line.len[ ++cat_line]
+                                = strlen( infile->buffer) - 2;
+                    /* Else ignore  */
+                }
+                continue;
+            }
+        }
+#if NBUFF-2 > SLEN90MIN
+        if (ptr - infile->buffer + len + 2 > std_limits.str_len + 1
+                && (warn_level & 4))    /* +1 for '\n'          */
+        cwarn( "Logical source line longer than %.0s%ld bytes"  /* _W4_ */
+                    , NULL, std_limits.str_len, NULL);
+#endif
+        if ((mcpp_debug & MACRO_CALL) && compiling) {
+            if (cat_line && cat_line < MAX_CAT_LINE) {
+                bsl_cat_line.len[ ++cat_line] = strlen( infile->buffer) - 1;
+                                /* Catenated length: '-1' for '\n'  */
+                bsl_cat_line.last_line = src_line;
+            }
+        }
+        return  infile->bptr = infile->buffer;      /* Logical line */
+    }
+
+    /* End of a (possibly included) source file */
+    if (ferror( infile->fp))
+        cfatal( "File read error", NULL, 0L, NULL);         /* _F_  */
+    if ((ptr = at_eof( in_comment)) != NULL)        /* Check at end of file */
+        return  ptr;                        /* Partial line supplemented    */
+    return  NULL;
+}
+
+static char *   at_eof(
+    int     in_comment
+)
+/*
+ * Check the partial line, unterminated comment, unbalanced #if block,
+ * uncompleted macro call at end of a file or at end of input.
+ * Supplement the line terminator, if possible.
+ * Return the supplemented line or NULL on unrecoverable error.
+ */
+{
+    const char * const  format
+            = "End of %s with %.0ld%s";                 /* _E_ _W1_ */
+    const char * const  unterm_if_format
+= "End of %s within #if (#ifdef) section started at line %ld";  /* _E_ _W1_ */
+    const char * const  unterm_macro_format
+            = "End of %s within macro call started at line %ld";/* _E_ _W1_ */
+    const char * const  input
+            = infile->parent ? "file" : "input";        /* _E_ _W1_ */
+    const char * const  no_newline
+            = "no newline, supplemented newline";       /* _W1_     */
+    const char * const  unterm_com
+            = "unterminated comment, terminated the comment";   /* _W1_     */
+    const char * const  backsl = "\\, deleted the \\";  /* _W1_     */
+    size_t  len;
+    char *  cp;
+
+    cp = infile->buffer;
+    len = strlen( cp);
+    if (len && *(cp += (len - 1)) != '\n') {
+        *++cp = '\n';                       /* Supplement <newline> */
+        *++cp = EOS;
+        if ((warn_level & 1))
+            cwarn( format, input, 0L, no_newline);
+        return  infile->bptr = infile->buffer;
+    }
+    if (infile->buffer < infile->bptr) {
+                            /* No line after <backslash><newline>   */
+        cp = infile->bptr;
+        *cp++ = '\n';                       /* Delete the \\        */
+        *cp = EOS;
+        if (warn_level & 1)
+            cwarn( format, input, 0L, backsl);
+        return  infile->bptr = infile->buffer;
+    }
+    if (in_comment) {               /* End of file within a comment */
+        if ((warn_level & 1))
+            cwarn( format, input, 0L, unterm_com);
+        /* The partial comment line has been already read by        */
+        /* read_a_comment(), so supplement the  next line.          */
+        strcpy( infile->buffer, "*/\n");
+        return  infile->bptr = infile->buffer;
+    }
+
+    if (infile->initif < ifptr) {
+        IFINFO *    ifp = infile->initif + 1;
+        cerror( unterm_if_format, input, ifp->ifline, NULL);
+        ifptr = infile->initif;         /* Clear information of */
+        compiling = ifptr->stat;        /*   erroneous grouping */
+    }
+
+    if (macro_line != 0 && macro_line != MACRO_ERROR
+            && in_getarg) {
+        cerror( unterm_macro_format, input, macro_line, NULL);
+        macro_line = MACRO_ERROR;
+    }
+
+    return  NULL;
+}
+
+void    unget_ch( void)
+/*
+ * Back the pointer to reread the last character.  Fatal error (code bug)
+ * if we back too far.  unget_ch() may be called, without problems, at end of
+ * file.  Only one character may be ungotten.  If you need to unget more,
+ * call unget_string().
+ */
+{
+    if (in_token) {
+        infile->bptr--;
+        return;
+    }
+
+    if (infile != NULL) {
+        --infile->bptr;
+        if (infile->bptr < infile->buffer)      /* Shouldn't happen */
+            cfatal( "Bug: Too much pushback", NULL, 0L, NULL);      /* _F_  */
+    }
+
+    if (mcpp_debug & GETC)
+        dump_unget( "after unget");
+}
+
+FILEINFO *  unget_string(
+    const char *    text,               /* Text to unget            */
+    const char *    name                /* Name of the macro, if any*/
+)
+/*
+ * Push a string back on the input stream.  This is done by treating
+ * the text as if it were a macro or a file.
+ */
+{
+    FILEINFO *      file;
+    size_t          size;
+
+    if (text)
+        size = strlen( text) + 1;
+    else
+        size = 1;
+    file = get_file( name, NULL, NULL, size, FALSE);
+    if (text)
+        memcpy( file->buffer, text, size);
+    else
+        *file->buffer = EOS;
+    return  file;
+}
+
+char *  save_string(
+    const char *      text
+)
+/*
+ * Store a string into free memory.
+ */
+{
+    char *      result;
+    size_t      size;
+
+    size = strlen( text) + 1;
+    result = xmalloc( size);
+    memcpy( result, text, size);
+    return  result;
+}
+
+FILEINFO *  get_file(
+    const char *    name,                   /* File or macro name   */
+    const char *    src_dir,                /* Source file directory*/
+    const char *    fullname,               /* Full path list       */
+    size_t      bufsize,                    /* Line buffer size     */
+    int         include_opt         /* Specified by -include opt (for GCC)  */
+)
+/*
+ * Common FILEINFO buffer initialization for a new file or macro.
+ */
+{
+    FILEINFO *  file;
+
+    file = (FILEINFO *) xmalloc( sizeof (FILEINFO));
+    file->buffer = xmalloc( bufsize);
+    file->bptr = file->buffer;              /* Initialize line ptr  */
+    file->buffer[ 0] = EOS;                 /* Force first read     */
+    file->line = 0L;                        /* (Not used just yet)  */
+    file->fp = NULL;                        /* No file yet          */
+    file->pos = 0L;                         /* No pos to remember   */
+    file->parent = infile;                  /* Chain files together */
+    file->initif = ifptr;                   /* Initial ifstack      */
+    file->include_opt = include_opt;        /* Specified by -include*/
+    file->dirp = NULL;                      /* No include dir yet   */
+    file->real_fname = name;                /* Save file/macro name */
+    file->full_fname = fullname;            /* Full path list       */
+    if (name) {
+        file->filename = xmalloc( strlen( name) + 1);
+        strcpy( file->filename, name);      /* Copy for #line       */
+    } else {
+        file->filename = NULL;
+    }
+    if (src_dir) {
+        file->src_dir = xmalloc( strlen( src_dir) + 1);
+        strcpy( file->src_dir, src_dir);
+    } else {
+        file->src_dir = NULL;
+    }
+    file->last_fputc = mcpp_lib_fputc;
+    file->last_fputs = mcpp_lib_fputs;
+    file->last_fprintf = mcpp_lib_fprintf;
+    if (infile != NULL) {                   /* If #include file     */
+        infile->line = src_line;            /* Save current line    */
+        infile->last_fputc = mcpp_fputc;
+        infile->last_fputs = mcpp_fputs;
+        infile->last_fprintf = mcpp_fprintf;
+    }
+    infile = file;                          /* New current file     */
+
+    return  file;                           /* All done.            */
+}
+
+static const char * const   out_of_memory
+    = "Out of memory (required size is %.0s0x%lx bytes)";   /* _F_  */
+
+char *
+(xmalloc)(
+    size_t      size
+)
+/*
+ * Get a block of free memory.
+ */
+{
+    char *      result;
+
+    if ((result = (char *) malloc( size)) == NULL) {
+        if (mcpp_debug & MEMORY)
+            print_heap();
+       cfatal( out_of_memory, NULL, (long) size, NULL);
+    }
+    return  result;
+}
+
+char *  (xrealloc)(
+    char *      ptr,
+    size_t      size
+)
+/*
+ * Reallocate malloc()ed memory.
+ */
+{
+    char *      result;
+
+    if ((result = (char *) realloc( ptr, size)) == NULL && size != 0) {
+        /* 'size != 0' is necessary to cope with some               */
+        /*   implementation of realloc( ptr, 0) which returns NULL. */
+        if (mcpp_debug & MEMORY)
+            print_heap();
+        cfatal( out_of_memory, NULL, (long) size, NULL);
+    }
+    return  result;
+}
+
+LINE_COL *  get_src_location(
+    LINE_COL *  p_line_col          /* Line and column on phase 4   */
+)
+/*
+ * Convert line-column datum of just after translation phase 3 into that of
+ * phase 2, tracing back line splicing by a comment and <backslash><newline>.
+ * Note: This conversion does not give correct datum on a line catenated by
+ * both of <backslash><newline> and line-crossing-comment at the same time.
+ *
+ * com_cat_line and bsl_cat_line have data only on last catenated line.
+ * com_cat_line.len[] and bsl_cat_line.len[] have the length of catenated
+ * line, and len[ 0] is always 0, followed by len[ 1], len[ 2], ..., as
+ * accumulated length of successively catenated lines.
+ */
+{
+    long        line;
+    size_t      col;
+    size_t *    cols;
+    CAT_LINE *  l_col_p;
+    int         i;
+
+    line = p_line_col->line;
+    col = p_line_col->col;
+
+    for (i = 0; i <= 1; i++) {
+        l_col_p = i ? & bsl_cat_line : & com_cat_line;
+        if (l_col_p->last_line != line)
+            continue;
+        /* Else just catenated line */
+        cols = l_col_p->len + 1;
+        while (*cols < col)
+            cols++;
+        if (col <= *cols) {
+            cols--;
+            col -= *cols;
+        }
+        line = l_col_p->start_line + (cols - l_col_p->len);
+    }
+
+    p_line_col->line = line;
+    p_line_col->col = col + 1;
+                    /* col internally start at 0, output start at 1 */
+
+    return  p_line_col;
+}
+
+static void do_msg(
+    const char *    severity,       /* "fatal", "error", "warning"  */
+    const char *    format,         /* Format for the error message */
+    const char *    arg1,           /* String arg. for the message  */
+    long            arg2,           /* Integer argument             */
+    const char *    arg3            /* Second string argument       */
+)
+/*
+ * Print filenames, macro names, line numbers and error messages.
+ * Also print macro definitions on macro expansion problems.
+ */
+{
+    FILEINFO *  file;
+    DEFBUF *    defp;
+    int         i;
+    size_t      slen;
+    const char *    arg_s[ 2];
+    char *      arg_t[ 2];
+    char *      tp;
+    const char *    sp;
+    int         c;
+    int         ind;
+
+    fflush( fp_out);                /* Synchronize output and diagnostics   */
+    arg_s[ 0] = arg1;  arg_s[ 1] = arg3;
+
+    for (i = 0; i < 2; i++) {   /* Convert special characters to visible    */
+        sp = arg_s[ i];
+        if (sp != NULL)
+            slen = strlen( sp) + 1;
+        else
+            slen = 1;
+        tp = arg_t[ i] = (char *) malloc( slen);
+            /* Don't use xmalloc() so as not to cause infinite recursion    */
+        if (sp == NULL || *sp == EOS) {
+            *tp = EOS;
+            continue;
+        }
+
+        while ((c = *sp++) != EOS) {
+            switch (c) {
+            case TOK_SEP:
+            case RT_END:
+            case CAT:
+            case ST_QUOTE:
+            case DEF_MAGIC:
+                break;                  /* Skip the magic characters*/
+            case IN_SRC:
+                if ((mcpp_debug & MACRO_CALL) && ! in_directive)
+                    sp += 2;            /* Skip two more bytes      */
+                break;
+            case MAC_INF:
+                switch (*sp++) {    /* Skip the magic characters*/
+                case MAC_ARG_START  :
+                    sp++;
+                    /* Fall through */
+                case MAC_CALL_START :
+                    sp += 2;
+                    break;
+                case MAC_ARG_END    :
+                    break;
+                case MAC_CALL_END   :
+                    break;
+                }
+                break;
+            case '\n':
+                *tp++ = ' ';            /* Convert '\n' to a space  */
+                break;
+            default:
+                *tp++ = c;
+                break;
+            }
+        }
+
+        if (*(sp - 2) == '\n')
+            tp--;
+        *tp = EOS;
+    }
+
+    /* Print source location and diagnostic */
+    file = infile;
+    while (file != NULL && (file->fp == NULL || file->fp == (FILE *)-1))
+        file = file->parent;                        /* Skip macro   */
+    if (file != NULL) {
+        file->line = src_line;
+        mcpp_fprintf( ERR, "%s:%ld: %s: ", cur_fullname, src_line, severity);
+    }
+    mcpp_fprintf( ERR, format, arg_t[ 0], arg2, arg_t[ 1]);
+    mcpp_fputc( '\n', ERR);
+
+    /* Print source line, includers and expanding macros    */
+    file = infile;
+    if (file != NULL && file->fp != NULL) {
+        mcpp_fprintf( ERR, "    %s", file->buffer);
+                                        /* Current source line  */
+        file = file->parent;
+    }
+    while (file != NULL) {                  /* Print #includes, too */
+        if (file->fp == NULL) {             /* Macro                */
+            if (file->filename) {
+                defp = look_id( file->filename);
+                if ((defp->nargs > DEF_NOARGS_STANDARD)
+                    && ! (file->parent && file->parent->filename
+                        && str_eq( file->filename, file->parent->filename)))
+                        /* If the name is not duplicate of parent   */
+                    dump_a_def( "    macro", defp, FALSE, TRUE, fp_err);
+            }
+        } else {                            /* Source file          */
+            if (file->buffer[ 0] == '\0')
+                strcpy( file->buffer, "\n");
+            mcpp_fprintf( ERR, "    from %s: %ld:    %s",
+                file->line ? file->full_fname       /* Full-path-list   */
+                    : "<stdin>",        /* Included by -include */
+                file->line,             /* Current line number  */
+                file->buffer);          /* The source line      */
+        }
+        file = file->parent;
+    }
+
+    if (! macro_name)
+        goto  free_arg;
+    /* Additional information of macro definitions  */
+    expanding_macro[ 0].name = macro_name;
+    for (ind = 0; ind <= exp_mac_ind; ind++) {
+        int         ind_done;
+
+        for (ind_done = 0; ind_done < ind; ind_done++)
+            if (str_eq( expanding_macro[ ind].name
+                    , expanding_macro[ ind_done].name))
+                break;                      /* Already reported     */
+        if (ind_done < ind)
+            continue;
+        for (file = infile; file; file = file->parent)
+            if (file->fp == NULL && file->filename
+                    && str_eq( expanding_macro[ ind].name, file->filename))
+                break;                      /* Already reported     */
+        if (file)
+            continue;
+        if ((defp = look_id( expanding_macro[ ind].name)) != NULL) {
+            if (defp->nargs <= DEF_NOARGS_STANDARD)
+                continue;                   /* Standard predefined  */
+            dump_a_def( "    macro", defp, FALSE, TRUE, fp_err);
+            /* Macro already read over  */
+        }
+    }
+
+free_arg:
+    for (i = 0; i < 2; i++)
+        free( arg_t[ i]);
+}
+
+void    cfatal(
+    const char *    format,
+    const char *    arg1,
+    long    arg2,
+    const char *    arg3
+)
+/*
+ * A real disaster.
+ */
+{
+    do_msg( "fatal error", format, arg1, arg2, arg3);
+    longjmp( error_exit, -1);
+}
+
+void    cerror(
+    const char *    format,
+    const char *    arg1,
+    long    arg2,
+    const char *    arg3
+)
+/*
+ * Print a error message.
+ */
+{
+    do_msg( "error", format, arg1, arg2, arg3);
+    errors++;
+}
+
+void    cwarn(
+    const char *    format,
+    const char *    arg1,
+    long    arg2,
+    const char *    arg3
+)
+/*
+ * Maybe an error.
+ */
+{
+    do_msg( "warning", format, arg1, arg2, arg3);
+}
+
+void    dump_string(
+    const char *    why,
+    const char *    text
+)
+/*
+ * Dump text readably.
+ * Bug: macro argument number may be putout as a control character or any
+ * other character, just after MAC_PARM has been read away.
+ */
+{
+    const char *    cp;
+    const char *    chr;
+    int     c, c1, c2;
+
+    if (why != NULL)
+        mcpp_fprintf( DBG, " (%s)", why);
+    mcpp_fputs( " => ", DBG);
+
+    if (text == NULL) {
+        mcpp_fputs( "NULL", DBG);
+        return;
+    }
+
+    for (cp = text; (c = *cp++ & UCHARMAX) != EOS; ) {
+        chr = NULL;
+
+        switch (c) {
+        case MAC_PARM:
+            c = *cp++ & UCHARMAX;       /* Macro parameter number   */
+            mcpp_fprintf( DBG, "<%d>", c);
+            break;
+        case MAC_INF:
+            if (! ((mcpp_debug & MACRO_CALL)))
+                goto  no_magic;
+            /* Macro informations inserted by -K option */
+            c2 = *cp++ & UCHARMAX;
+            if (c2 == MAC_CALL_START || c2 == MAC_ARG_START) {
+                c = ((*cp++ & UCHARMAX) - 1) * UCHARMAX;
+                c += (*cp++ & UCHARMAX) - 1;
+            }
+            switch (c2) {
+            case MAC_CALL_START:
+                mcpp_fprintf( DBG, "<MAC%d>", c);
+                break;
+            case MAC_CALL_END:
+                chr = "<MAC_END>";
+                break;
+            case MAC_ARG_START:
+                c1 = *cp++ & UCHARMAX;
+                mcpp_fprintf( DBG, "<MAC%d:ARG%d>", c, c1 - 1);
+                break;
+            case MAC_ARG_END:
+                chr = "<ARG_END>";
+                break;
+            }
+            break;
+        case DEF_MAGIC:
+            chr = "<MAGIC>";
+            break;
+        case CAT:
+            chr = "##";
+            break;
+        case ST_QUOTE:
+            chr = "#";
+            break;
+        case RT_END:
+            chr = "<RT_END>";
+            break;
+        case IN_SRC:
+            if ((mcpp_debug & MACRO_CALL) && ! in_directive) {
+                int     num;
+                num = ((*cp++ & UCHARMAX) - 1) * UCHARMAX;
+                num += (*cp++ & UCHARMAX) - 1;
+                mcpp_fprintf( DBG, "<SRC%d>", num);
+            } else {
+                chr = "<SRC>";
+            }
+            break;
+        case TOK_SEP:
+            chr = "<TSEP>";
+            break;
+        default:
+no_magic:
+            if (c < ' ')
+                mcpp_fprintf( DBG, "<^%c>", c + '@');
+            else
+                mcpp_fputc( c, DBG);
+            break;
+        }
+
+        if (chr)
+            mcpp_fputs( chr, DBG);
+    }
+
+    mcpp_fputc( '\n', DBG);
+}
+
+void    dump_unget(
+    const char *    why
+)
+/*
+ * Dump all ungotten junk (pending macros and current input lines).
+ */
+{
+    const FILEINFO *    file;
+
+    mcpp_fputs( "dump of pending input text", DBG);
+    if (why != NULL) {
+        mcpp_fputs( "-- ", DBG);
+        mcpp_fputs( why, DBG);
+    }
+    mcpp_fputc( '\n', DBG);
+
+    for (file = infile; file != NULL; file = file->parent)
+        dump_string( file->real_fname ? file->real_fname
+                : file->filename ? file->filename : "NULL", file->bptr);
+}
+
+static void dump_token(
+    int     token_type,
+    const char *    cp                              /* Token        */
+)
+/*
+ * Dump a token.
+ */
+{
+    static const char * const   t_type[]
+            = { "NAM", "NUM", "STR", "WSTR", "CHR", "WCHR", "OPE", "SPE"
+            , "SEP", };
+
+    mcpp_fputs( "token", DBG);
+    dump_string( t_type[ token_type - NAM], cp);
+}