/*-

 * 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.

 * cnv_trigraph()   Maps trigraph sequence to C character.

 * cnv_digraph()    Maps digraph sequence to C character.

 * id_operator()    See whether the identifier is an operator in C++.

 * 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.

 */

#if PREPROCESSED

#include    "mcpp.H"

#else

#include    "system.H"

#include    "internal.H"

#endif

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_number_prestd( int c, char * out, char * out_end);

                /* scan_number() for pre-Standard mode  */

#if OK_UCN

static char *   scan_ucn( int cnt, char * out);

                /* Scan an UCN sequence         */

#endif

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 char *   cat_line( int del_bsl);

                /* Splice the line              */

static void     put_line( char * out, FILE * fp);

                /* Put out a logical line       */

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  */

#if MCPP_LIB

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;

        }

    }

}

int    using_mem_buffers( void)

{

    return use_mem_buffers;

}

#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) {  /* 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;

}

#endif  /* MCPP_LIB */

#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 MCPP_LIB

    if (use_mem_buffers) {

        return mem_putc( c, od);

    } else {

#endif

        FILE *  stream = DEST2FP( od);

        return (stream != NULL) ? fputc( c, stream) : EOF;

#if MCPP_LIB

    }

#endif

}

int (* mcpp_fputc)( int c, OUTDEST od) = mcpp_lib_fputc;

int    mcpp_lib_fputs(

    const char *    s,

    OUTDEST od

)

{

#if MCPP_LIB

    if (use_mem_buffers) {

        return mem_puts( s, od);

    } else {

#endif

        FILE *  stream = DEST2FP( od);

        return (stream != NULL) ? fputs( s, stream) : EOF;

#if MCPP_LIB

    }

#endif

}

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 MCPP_LIB

        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 {

#endif

            rc = vfprintf( stream, format, ap);

#if MCPP_LIB

        }

#endif

        va_end( ap);

        return rc;

    } else {

        return EOF;

    }

}

int (* mcpp_fprintf)( OUTDEST od, const char * format, ...) = mcpp_lib_fprintf;

#if MCPP_LIB

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;

}

#endif

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);

            if (! option_flags.no_source_line)

                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 (standard && str_eq( identifier, "defined")) {

                cwarn( "Macro \"%s\" is expanded to \"defined\""    /* _W1_ */

                        , defp->name, 0L, NULL);

                break;

            }

            if (! standard && str_eq( identifier, "sizeof")) {

                cwarn( "Macro \"%s\" is expanded to \"sizeof\""     /* _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;

    if (standard)

        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':

            if (! standard)

                goto  ident;

            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            */

ident:

            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 = (standard ? scan_number( c, out, out_end)

                : scan_number_prestd( 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 OK_UCN

        if (mcpp_mode == STD && c == '\\' && stdc2) {

            ch = get_ch();

            unget_ch();

            if (ch == 'U' || ch == 'u')

                goto  ident;            /* Universal-Characte-Name  */

        }

#endif

#if OK_MBIDENT

        if (mcpp_mode == STD && (char_type[ c] & mbchk) && stdc3) {

            char *  bptr = infile->bptr;

            mb_read( c, &infile->bptr, &out;;

            infile->bptr = bptr;

            out = *out_pp;

            goto  ident;        /* An identifier with multi-byte characters */

            /* Mbchar cheking has been done in scan_quote() and others. */

        }

#endif

        if ((standard && (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);

    if (mcpp_mode == POST_STD && token_type != SEP && infile->fp != NULL

            && (char_type[ *infile->bptr & UCHARMAX] & SPA) == 0)

        insert_sep = INSERT_SEP;    /* Insert token separator       */

    *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];

    static int      dollar_diagnosed = FALSE;   /* Flag of diagnosing '$'   */

#if OK_UCN

    int     uc2 = 0, uc4 = 0;           /* Count of UCN16, UCN32    */

#endif

#if OK_MBIDENT

    int     mb = 0;                     /* Count of MBCHAR  */

#endif

    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;

#if OK_UCN

        if (mcpp_mode == STD && c == '\\' && stdc2) {

            int     cnt;

            char *  tp = bp;

            if ((c = get_ch()) == 'u') {

                cnt = 4;

            } else if (c == 'U') {

                cnt = 8;

            } else {

                unget_ch();

                bp--;

                break;

            }

            *bp++ = c;

            if ((bp = scan_ucn( cnt, bp)) == NULL)      /* Error    */

                return;

            if (cnt == 4)

                uc2++;

            else if (cnt == 8)

                uc4++;

            if (limit <= tp)            /* Too long identifier      */

                bp = tp;                /* Back the pointer         */

            goto  next_c;

        }

#endif  /* OK_UCN   */

#if OK_MBIDENT

        if (mcpp_mode == STD && (char_type[ c] & mbchk) && stdc3) {

            len = mb_read( c, &infile->bptr, &bp);

            if (len & MB_ERROR) {

                if (infile->fp)

                    cerror(

                    "Illegal multi-byte character sequence."    /* _E_  */

                            , NULL, 0L, NULL);

            } else {

                mb += len;

            }

        }

#endif  /* OK_MBIDENT   */

#if OK_UCN

next_c:

#endif

        c = get_ch();

    } while ((char_type[ c] & (LET | DIG))      /* Letter or digit  */

#if OK_UCN

            || (mcpp_mode == STD && c == '\\' && stdc2)

#endif

#if OK_MBIDENT

            || (mcpp_mode == STD && (char_type[ c] & mbchk) && stdc3)

#endif

        );

    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 OK_UCN

    if (mcpp_mode == STD)

        len -= (uc2 * 5) - (uc4 * 9);

#endif

#if OK_MBIDENT

    if (mcpp_mode == STD)

        len -= mb;

#endif

    if (standard && 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   */

    if (option_flags.dollar_in_name && dollar_diagnosed == FALSE

            && (warn_level & 2) && strchr( identifier, '$') != NULL) {

        cwarn( "'$' in identifier \"%s\"", identifier, 0L, NULL); /* _W2_ */

        dollar_diagnosed = TRUE;            /* Diagnose only once   */

    }

}

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%.0ld%s";

    const char * const      empty_const

                        = "Empty character constant %s%.0ld%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().   */

    if (standard)

        in_token = TRUE;

    *out_p++ = delim;

    if (delim == '<')

        delim = '>';

scan:

    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    */

#if OK_UCN

            if (mcpp_mode == STD && stdc2) {

                int         cnt;

                char *      tp;

                *out_p++ = c;

                if ((c = get_ch()) == 'u') {

                    cnt = 4;

                } else if (c == 'U') {

                    cnt = 8;

                } else {

                    goto  escape;

                }

                *out_p++ = c;

                if ((tp = scan_ucn( cnt, out_p)) != NULL)

                    out_p = tp;

                /* Else error   */

                continue;       /* Error or not, anyway continue    */

            }

#endif  /* OK_UCN   */

            *out_p++ = c;                   /* Escape sequence      */

            c = get_ch();

escape:

#if MBCHAR

            if (char_type[ c] & mbchk) {

                                /* '\\' followed by multi-byte char */

                unget_ch();

                continue;

            }

#endif

            if (! standard && c == '\n') {  /* <backslash><newline> */

                out_p--;                    /* Splice the lines     */

                if (cat_line( TRUE) == NULL)        /* End of file  */

                    break;

                c = get_ch();

            }

        } else if (mcpp_mode == POST_STD && c == ' ' && delim == '>'

                && infile->fp == NULL) {

            continue;   /* Skip space possibly inserted by macro expansion  */

        } else if (c == '\n') {

            break;

        }

        if (diag && iscntrl( c) && ((char_type[ c] & SPA) == 0)

                && (warn_level & 1))

            cwarn(

            "Illegal control character %.0s0lx%02x 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 (mcpp_mode == OLD_PREP   /* Implicit closing of quote*/

                    && (delim == '"' || delim == '\''))

                goto  done;

            if (delim == '"') {

                if (mcpp_mode != POST_STD && option_flags.lang_asm) {

                    /* STD, KR      */

                    /* Concatenate the unterminated string to the next line */

                    if (warn_level & 1)

                        cwarn( unterm_string

                                , ", catenated to the next line"    /* _W1_ */

                                , 0L, NULL);

                    if (cat_line( FALSE) != NULL)

                        goto  scan;         /* Splice the lines     */

                    /* Else end of file     */

                } else {

                    cerror( unterm_string, skip, 0L, NULL); /* _E_  */

                }

            } else if (delim == '\'') {

                if (mcpp_mode != POST_STD && option_flags.lang_asm) {

                    /* STD, KR      */

                    if (warn_level & 1)

                        cwarn( unterm_char, out, 0L, NULL); /* _W1_ */

                    goto  done;

                } else {

                    cerror( unterm_char, out, 0L, skip);    /* _E_  */

                }

            } else {

                cerror( "Unterminated header name %s%.0ld%s"        /* _E_  */

                        , out, 0L, skip);

            }

            out_p = NULL;

        } else if (delim == '\'' && out_p - out <= 2) {

            if (mcpp_mode != POST_STD && option_flags.lang_asm) {

                /* STD, KR      */

                if (warn_level & 1)

                    cwarn( empty_const, out, 0L, skip);     /* _W1_ */

            } else {

                cerror( empty_const, out, 0L, skip);        /* _E_  */