xref: /aoo41x/main/rsc/source/rscpp/cpp6.c (revision 8e2a856b)

/**************************************************************
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/



#include        <stdio.h>
#include        <ctype.h>
#include        <string.h>
#include        "cppdef.h"
#include        "cpp.h"

/*ER evaluate macros to pDefOut */

/*
 * skipnl()     skips over input text to the end of the line.
 * skipws()     skips over "whitespace" (spaces or tabs), but
 *              not skip over the end of the line.  It skips over
 *              TOK_SEP, however (though that shouldn't happen).
 * scanid()     reads the next token (C identifier) into token[].
 *              The caller has already read the first character of
 *              the identifier.  Unlike macroid(), the token is
 *              never expanded.
 * macroid()    reads the next token (C identifier) into token[].
 *              If it is a #defined macro, it is expanded, and
 *              macroid() returns TRUE, otherwise, FALSE.
 * catenate()   Does the dirty work of token concatenation, TRUE if it did.
 * scanstring() Reads a string from the input stream, calling
 *              a user-supplied function for each character.
 *              This function may be output() to write the
 *              string to the output file, or save() to save
 *              the string in the work buffer.
 * scannumber() Reads a C numeric constant from the input stream,
 *              calling the user-supplied function for each
 *              character.  (output() or save() as noted above.)
 * save()       Save one character in the work[] buffer.
 * savestring() Saves a string in malloc() memory.
 * getfile()    Initialize a new FILEINFO structure, called when
 *              #include opens a new file, or a macro is to be
 *              expanded.
 * getmem()     Get a specified number of bytes from malloc memory.
 * output()     Write one character to stdout (calling PUTCHAR) --
 *              implemented as a function so its address may be
 *              passed to scanstring() and scannumber().
 * lookid()     Scans the next token (identifier) from the input
 *              stream.  Looks for it in the #defined symbol table.
 *              Returns a pointer to the definition, if found, or NULL
 *              if not present.  The identifier is stored in token[].
 * defnedel()   Define enter/delete subroutine.  Updates the
 *              symbol table.
 * get()        Read the next byte from the current input stream,
 *              handling end of (macro/file) input and embedded
 *              comments appropriately.  Note that the global
 *              instring is -- essentially -- a parameter to get().
 * cget()       Like get(), but skip over TOK_SEP.
 * unget()      Push last gotten character back on the input stream.
 * cerror(), cwarn(), cfatal(), cierror(), ciwarn()
 *              These routines format an print messages to the user.
 *              cerror & cwarn take a format and a single string argument.
 *              cierror & ciwarn take a format and a single int (char) argument.
 *              cfatal takes a format and a single string argument.
 */

/*
 * This table must be rewritten for a non-Ascii machine.
 *
 * Note that several "non-visible" characters have special meaning:
 * Hex 1D DEF_MAGIC -- a flag to prevent #define recursion.
 * Hex 1E TOK_SEP   -- a delimiter for token concatenation
 * Hex 1F COM_SEP   -- a zero-width whitespace for comment concatenation
 */
#if TOK_SEP != 0x1E || COM_SEP != 0x1F || DEF_MAGIC != 0x1D
        << error type table is not correct >>
#endif

#if OK_DOLLAR
#define DOL     LET
#else
#define DOL     000
#endif

#ifdef EBCDIC

char type[256] = {              /* Character type codes    Hex          */
   END,   000,   000,   000,   000,   SPA,   000,   000, /* 00          */
   000,   000,   000,   000,   000,   000,   000,   000, /* 08          */
   000,   000,   000,   000,   000,   000,   000,   000, /* 10          */
   000,   000,   000,   000,   000,   LET,   000,   SPA, /* 18          */
   000,   000,   000,   000,   000,   000,   000,   000, /* 20          */
   000,   000,   000,   000,   000,   000,   000,   000, /* 28          */
   000,   000,   000,   000,   000,   000,   000,   000, /* 30          */
   000,   000,   000,   000,   000,   000,   000,   000, /* 38          */
   SPA,   000,   000,   000,   000,   000,   000,   000, /* 40          */
   000,   000,   000,   DOT, OP_LT,OP_LPA,OP_ADD, OP_OR, /* 48    .<(+| */
OP_AND,   000,   000,   000,   000,   000,   000,   000, /* 50 &        */
   000,   000,OP_NOT,   DOL,OP_MUL,OP_RPA,   000,OP_XOR, /* 58   !$*);^ */
OP_SUB,OP_DIV,   000,   000,   000,   000,   000,   000, /* 60 -/       */
   000,   000,   000,   000,OP_MOD,   LET, OP_GT,OP_QUE, /* 68    ,%_>? */
   000,   000,   000,   000,   000,   000,   000,   000, /* 70          */
   000,   000,OP_COL,   000,   000,   QUO, OP_EQ,   QUO, /* 78  `:#@'=" */
   000,   LET,   LET,   LET,   LET,   LET,   LET,   LET, /* 80  abcdefg */
   LET,   LET,   000,   000,   000,   000,   000,   000, /* 88 hi       */
   000,   LET,   LET,   LET,   LET,   LET,   LET,   LET, /* 90  jklmnop */
   LET,   LET,   000,   000,   000,   000,   000,   000, /* 98 qr       */
   000,OP_NOT,   LET,   LET,   LET,   LET,   LET,   LET, /* A0  ~stuvwx */
   LET,   LET,   000,   000,   000,   000,   000,   000, /* A8 yz   [   */
   000,   000,   000,   000,   000,   000,   000,   000, /* B0          */
   000,   000,   000,   000,   000,   000,   000,   000, /* B8      ]   */
   000,   LET,   LET,   LET,   LET,   LET,   LET,   LET, /* C0 {ABCDEFG */
   LET,   LET,   000,   000,   000,   000,   000,   000, /* C8 HI       */
   000,   LET,   LET,   LET,   LET,   LET,   LET,   LET, /* D0 }JKLMNOP */
   LET,   LET,   000,   000,   000,   000,   000,   000, /* D8 QR       */
   BSH,   000,   LET,   LET,   LET,   LET,   LET,   LET, /* E0 \ STUVWX */
   LET,   LET,   000,   000,   000,   000,   000,   000, /* E8 YZ       */
   DIG,   DIG,   DIG,   DIG,   DIG,   DIG,   DIG,   DIG, /* F0 01234567 */
   DIG,   DIG,   000,   000,   000,   000,   000,   000, /* F8 89       */
};

#else

char type[256] = {              /* Character type codes    Hex          */
   END,   000,   000,   000,   000,   000,   000,   000, /* 00          */
   000,   SPA,   000,   000,   000,   000,   000,   000, /* 08          */
   000,   000,   000,   000,   000,   000,   000,   000, /* 10          */
   000,   000,   000,   000,   000,   LET,   000,   SPA, /* 18          */
   SPA,OP_NOT,   QUO,   000,   DOL,OP_MOD,OP_AND,   QUO, /* 20  !"#$%&' */
OP_LPA,OP_RPA,OP_MUL,OP_ADD,   000,OP_SUB,   DOT,OP_DIV, /* 28 ()*+,-./ */
   DIG,   DIG,   DIG,   DIG,   DIG,   DIG,   DIG,   DIG, /* 30 01234567 */
   DIG,   DIG,OP_COL,   000, OP_LT, OP_EQ, OP_GT,OP_QUE, /* 38 89:;<=>? */
   000,   LET,   LET,   LET,   LET,   LET,   LET,   LET, /* 40 @ABCDEFG */
   LET,   LET,   LET,   LET,   LET,   LET,   LET,   LET, /* 48 HIJKLMNO */
   LET,   LET,   LET,   LET,   LET,   LET,   LET,   LET, /* 50 PQRSTUVW */
   LET,   LET,   LET,   000,   BSH,   000,OP_XOR,   LET, /* 58 XYZ[\]^_ */
   000,   LET,   LET,   LET,   LET,   LET,   LET,   LET, /* 60 `abcdefg */
   LET,   LET,   LET,   LET,   LET,   LET,   LET,   LET, /* 68 hijklmno */
   LET,   LET,   LET,   LET,   LET,   LET,   LET,   LET, /* 70 pqrstuvw */
   LET,   LET,   LET,   000, OP_OR,   000,OP_NOT,   000, /* 78 xyz{|}~  */
   000,   000,   000,   000,   000,   000,   000,   000, /*   80 .. FF  */
   000,   000,   000,   000,   000,   000,   000,   000, /*   80 .. FF  */
   000,   000,   000,   000,   000,   000,   000,   000, /*   80 .. FF  */
   000,   000,   000,   000,   000,   000,   000,   000, /*   80 .. FF  */
   000,   000,   000,   000,   000,   000,   000,   000, /*   80 .. FF  */
   000,   000,   000,   000,   000,   000,   000,   000, /*   80 .. FF  */
   000,   000,   000,   000,   000,   000,   000,   000, /*   80 .. FF  */
   000,   000,   000,   000,   000,   000,   000,   000, /*   80 .. FF  */
};

#endif


/*
 *                      C P P   S y m b o l   T a b l e s
 */

/*
 * SBSIZE defines the number of hash-table slots for the symbol table.
 * It must be a power of 2.
 */
#ifndef SBSIZE
#define SBSIZE  64
#endif
#define SBMASK  (SBSIZE - 1)
#if (SBSIZE ^ SBMASK) != ((SBSIZE * 2) - 1)
        << error, SBSIZE must be a power of 2 >>
#endif


static DEFBUF   *symtab[SBSIZE];        /* Symbol table queue headers   */

void InitCpp6()
{
    int i;
    for( i = 0; i < SBSIZE; i++ )
        symtab[ i ] = NULL;
}



void skipnl()
/*
 * Skip to the end of the current input line.
 */
{
        register int            c;

        do {                            /* Skip to newline      */
            c = get();
        } while (c != '\n' && c != EOF_CHAR);
}

int
skipws()
/*
 * Skip over whitespace
 */
{
        register int            c;

        do {                            /* Skip whitespace      */
            c = get();
#if COMMENT_INVISIBLE
        } while (type[c] == SPA || c == COM_SEP);
#else
        } while (type[c] == SPA);
#endif
        return (c);
}

void scanid(int c)
/*
 * Get the next token (an id) into the token buffer.
 * Note: this code is duplicated in lookid().
 * Change one, change both.
 */
{
        register char   *bp;

        if (c == DEF_MAGIC)                     /* Eat the magic token  */
            c = get();                          /* undefiner.           */
        bp = token;
        do {
            if (bp < &token[IDMAX])             /* token dim is IDMAX+1 */
                *bp++ = (char)c;
            c = get();
        } while (type[c] == LET || type[c] == DIG);
        unget();
        *bp = EOS;
}

int
macroid(int c)
/*
 * If c is a letter, scan the id.  if it's #defined, expand it and scan
 * the next character and try again.
 *
 * Else, return the character.  If type[c] is a LET, the token is in token.
 */
{
        register DEFBUF *dp;

        if (infile != NULL && infile->fp != NULL)
            recursion = 0;
        while (type[c] == LET && (dp = lookid(c)) != NULL) {
            expand(dp);
            c = get();
        }
        return (c);
}

int
catenate()
/*
 * A token was just read (via macroid).
 * If the next character is TOK_SEP, concatenate the next token
 * return TRUE -- which should recall macroid after refreshing
 * macroid's argument.  If it is not TOK_SEP, unget() the character
 * and return FALSE.
 */
{
        register int            c;
        register char           *token1;

#if OK_CONCAT
        if (get() != TOK_SEP) {                 /* Token concatenation  */
            unget();
            return (FALSE);
        }
        else {
            token1 = savestring(token);         /* Save first token     */
            c = macroid(get());                 /* Scan next token      */
            switch(type[c]) {                   /* What was it?         */
            case LET:                           /* An identifier, ...   */
                if (strlen(token1) + strlen(token) >= NWORK)
                    cfatal("work buffer overflow doing %s #", token1);
                sprintf(work, "%s%s", token1, token);
                break;

            case DIG:                           /* A digit string       */
                strcpy(work, token1);
                workp = work + strlen(work);
                do {
                    save(c);
                } while ((c = get()) != TOK_SEP);
                /*
                 * The trailing TOK_SEP is no longer needed.
                 */
                save(EOS);
                break;

            default:                            /* An error, ...        */
#if ! COMMENT_INVISIBLE
                if (isprint(c))
                    cierror("Strange character '%c' after #", c);
                else
                    cierror("Strange character (%d.) after #", c);
#endif
                strcpy(work, token1);
                unget();
                break;
            }
            /*
             * work has the concatenated token and token1 has
             * the first token (no longer needed).  Unget the
             * new (concatenated) token after freeing token1.
             * Finally, setup to read the new token.
             */
            free(token1);                       /* Free up memory       */
            ungetstring(work);                  /* Unget the new thing, */
            return (TRUE);
        }
#else
        return (FALSE);                         /* Not supported        */
#endif
}

int
scanstring(int delim,
#ifndef _NO_PROTO
void             (*outfun)( int ) /* BP */    /* Output function              */
#else
void         (*outfun)() /* BP */
#endif
)
/*
 * Scan off a string.  Warning if terminated by newline or EOF.
 * outfun() outputs the character -- to a buffer if in a macro.
 * TRUE if ok, FALSE if error.
 */
{
        register int            c;

        instring = TRUE;                /* Don't strip comments         */
        (*outfun)(delim);
        while ((c = get()) != delim
             && c != '\n'
             && c != EOF_CHAR) {

            if (c != DEF_MAGIC)
            (*outfun)(c);
            if (c == '\\')
                (*outfun)(get());
        }
        instring = FALSE;
        if (c == delim) {
            (*outfun)(c);
            return (TRUE);
        }
        else {
            cerror("Unterminated string", NULLST);
            unget();
            return (FALSE);
        }
}

void scannumber(int c,
#ifndef _NO_PROTO
register void    (*outfun)( int )  /* BP */    /* Output/store func    */
#else
register void    (*outfun)() /* BP */
#endif
)
/*
 * Process a number.  We know that c is from 0 to 9 or dot.
 * Algorithm from Dave Conroy's Decus C.
 */
{
        register int    radix;                  /* 8, 10, or 16         */
        int             expseen;                /* 'e' seen in floater  */
        int             signseen;               /* '+' or '-' seen      */
        int             octal89;                /* For bad octal test   */
        int             dotflag;                /* TRUE if '.' was seen */

        expseen = FALSE;                        /* No exponent seen yet */
        signseen = TRUE;                        /* No +/- allowed yet   */
        octal89 = FALSE;                        /* No bad octal yet     */
        radix = 10;                             /* Assume decimal       */
        if ((dotflag = (c == '.')) != FALSE) {  /* . something?         */
            (*outfun)('.');                     /* Always out the dot   */
            if (type[(c = get())] != DIG) {     /* If not a float numb, */
                unget();                        /* Rescan strange char  */
                return;                         /* All done for now     */
            }
        }                                       /* End of float test    */
        else if (c == '0') {                    /* Octal or hex?        */
            (*outfun)(c);                       /* Stuff initial zero   */
            radix = 8;                          /* Assume it's octal    */
            c = get();                          /* Look for an 'x'      */
            if (c == 'x' || c == 'X') {         /* Did we get one?      */
                radix = 16;                     /* Remember new radix   */
                (*outfun)(c);                   /* Stuff the 'x'        */
                c = get();                      /* Get next character   */
            }
        }
        for (;;) {                              /* Process curr. char.  */
            /*
             * Note that this algorithm accepts "012e4" and "03.4"
             * as legitimate floating-point numbers.
             */
            if (radix != 16 && (c == 'e' || c == 'E')) {
                if (expseen)                    /* Already saw 'E'?     */
                    break;                      /* Exit loop, bad nbr.  */
                expseen = TRUE;                 /* Set exponent seen    */
                signseen = FALSE;               /* We can read '+' now  */
                radix = 10;                     /* Decimal exponent     */
            }
            else if (radix != 16 && c == '.') {
                if (dotflag)                    /* Saw dot already?     */
                    break;                      /* Exit loop, two dots  */
                dotflag = TRUE;                 /* Remember the dot     */
                radix = 10;                     /* Decimal fraction     */
            }
            else if (c == '+' || c == '-') {    /* 1.0e+10              */
                if (signseen)                   /* Sign in wrong place? */
                    break;                      /* Exit loop, not nbr.  */
                /* signseen = TRUE; */          /* Remember we saw it   */
            }
            else {                              /* Check the digit      */
                switch (c) {
                case '8': case '9':             /* Sometimes wrong      */
                    octal89 = TRUE;             /* Do check later       */
                case '0': case '1': case '2': case '3':
                case '4': case '5': case '6': case '7':
                    break;                      /* Always ok            */

                case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
                case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
                    if (radix == 16)            /* Alpha's are ok only  */
                        break;                  /* if reading hex.      */
                default:                        /* At number end        */
                    goto done;                  /* Break from for loop  */
                }                               /* End of switch        */
            }                                   /* End general case     */
            (*outfun)(c);                       /* Accept the character */
            signseen = TRUE;                    /* Don't read sign now  */
            c = get();                          /* Read another char    */
        }                                       /* End of scan loop     */
        /*
         * When we break out of the scan loop, c contains the first
         * character (maybe) not in the number.  If the number is an
         * integer, allow a trailing 'L' for long and/or a trailing 'U'
         * for unsigned.  If not those, push the trailing character back
         * on the input stream.  Floating point numbers accept a trailing
         * 'L' for "long double".
         */
done:   if (dotflag || expseen) {               /* Floating point?      */
            if (c == 'l' || c == 'L') {
                (*outfun)(c);
                c = get();                      /* Ungotten later       */
            }
        }
        else {                                  /* Else it's an integer */
            /*
             * We know that dotflag and expseen are both zero, now:
             * dotflag signals "saw 'L'", and
             * expseen signals "saw 'U'".
             */
            for (;;) {
                switch (c) {
                case 'l':
                case 'L':
                    if (dotflag)
                        goto nomore;
                    dotflag = TRUE;
                    break;

                case 'u':
                case 'U':
                    if (expseen)
                        goto nomore;
                    expseen = TRUE;
                    break;

                default:
                    goto nomore;
                }
                (*outfun)(c);                   /* Got 'L' or 'U'.      */
                c = get();                      /* Look at next, too.   */
            }
        }
nomore: unget();                                /* Not part of a number */
        if (octal89 && radix == 8)
            cwarn("Illegal digit in octal number", NULLST);
}

void save(int c)
{
        if (workp >= &work[NWORK]) {
            work[NWORK-1] = '\0';
            cfatal("Work buffer overflow:  %s", work);
        }
        else *workp++ = (char)c;
}

char *
savestring(char* text)
/*
 * Store a string into free memory.
 */
{
        register char   *result;

        result = getmem(strlen(text) + 1);
        strcpy(result, text);
        return (result);
}

FILEINFO        *
getfile(int bufsize, char* name)
/*
 * Common FILEINFO buffer initialization for a new file or macro.
 */
{
        register FILEINFO       *file;
        register int            size;

        size = strlen(name);                    /* File/macro name      */
        file = (FILEINFO *) getmem(sizeof (FILEINFO) + bufsize + size);
        file->parent = infile;                  /* Chain files together */
        file->fp = NULL;                        /* No file yet          */
        file->filename = savestring(name);      /* Save file/macro name */
        file->progname = NULL;                  /* No #line seen yet    */
        file->unrecur = 0;                      /* No macro fixup       */
        file->bptr = file->buffer;              /* Initialize line ptr  */
        file->buffer[0] = EOS;                  /* Force first read     */
        file->line = 0;                         /* (Not used just yet)  */
        if (infile != NULL)                     /* If #include file     */
            infile->line = line;                /* Save current line    */
        infile = file;                          /* New current file     */
        line = 1;                               /* Note first line      */
        return (file);                          /* All done.            */
}

char *
getmem(int size)
/*
 * Get a block of free memory.
 */
{
        register char   *result;

        if ((result = malloc((unsigned) size)) == NULL)
            cfatal("Out of memory", NULLST);
        return (result);
}


DEFBUF *
lookid(int c)
/*
 * Look for the next token in the symbol table.  Returns token in "token".
 * If found, returns the table pointer;  Else returns NULL.
 */
{
        register int            nhash;
        register DEFBUF         *dp;
        register char           *np;
        int                     temp = 0;
        int                     isrecurse;      /* For #define foo foo  */

        np = token;
        nhash = 0;
        if (0 != (isrecurse = (c == DEF_MAGIC)))     /* If recursive macro   */
            c = get();                          /* hack, skip DEF_MAGIC */
        do {
            if (np < &token[IDMAX]) {           /* token dim is IDMAX+1 */
                *np++ = (char)c;                /* Store token byte     */
                nhash += c;                     /* Update hash value    */
            }
            c = get();                          /* And get another byte */
        } while (type[c] == LET || type[c] == DIG);
        unget();                                /* Rescan terminator    */
        *np = EOS;                              /* Terminate token      */
        if (isrecurse)                          /* Recursive definition */
            return (NULL);                      /* undefined just now   */
        nhash += (np - token);                  /* Fix hash value       */
        dp = symtab[nhash & SBMASK];            /* Starting bucket      */
        while (dp != (DEFBUF *) NULL) {         /* Search symbol table  */
            if (dp->hash == nhash               /* Fast precheck        */
             && (temp = strcmp(dp->name, token)) >= 0)
                break;
            dp = dp->link;                      /* Nope, try next one   */
        }
        return ((temp == 0) ? dp : NULL);
}

DEFBUF *
defendel(char* name, int delete)
/*
 * Enter this name in the lookup table (delete = FALSE)
 * or delete this name (delete = TRUE).
 * Returns a pointer to the define block (delete = FALSE)
 * Returns NULL if the symbol wasn't defined (delete = TRUE).
 */
{
        register DEFBUF         *dp;
        register DEFBUF         **prevp;
        register char           *np;
        int                     nhash;
        int                     temp;
        int                     size;

        for (nhash = 0, np = name; *np != EOS;)
            nhash += *np++;
        size = (np - name);
        nhash += size;
        prevp = &symtab[nhash & SBMASK];
        while ((dp = *prevp) != (DEFBUF *) NULL) {
            if (dp->hash == nhash
             && (temp = strcmp(dp->name, name)) >= 0) {
                if (temp > 0)
                    dp = NULL;                  /* Not found            */
                else {
                    *prevp = dp->link;          /* Found, unlink and    */
                    if (dp->repl != NULL)       /* Free the replacement */
                        free(dp->repl);         /* if any, and then     */
                    free((char *) dp);          /* Free the symbol      */
                }
                break;
            }
            prevp = &dp->link;
        }
        if (!delete) {
            dp = (DEFBUF *) getmem(sizeof (DEFBUF) + size);
            dp->link = *prevp;
            *prevp = dp;
            dp->hash = nhash;
            dp->repl = NULL;
            dp->nargs = 0;
            strcpy(dp->name, name);
        }
        return (dp);
}

#if OSL_DEBUG_LEVEL > 1

void dumpdef(char *why)
{
        register DEFBUF         *dp;
        register DEFBUF         **syp;
		FILE *pRememberOut = NULL;

		if ( bDumpDefs )	/*ER */
		{
			pRememberOut = pCppOut;
			pCppOut = pDefOut;
		}
        fprintf( pCppOut, "CPP symbol table dump %s\n", why);
        for (syp = symtab; syp < &symtab[SBSIZE]; syp++) {
            if ((dp = *syp) != (DEFBUF *) NULL) {
                fprintf( pCppOut, "symtab[%d]\n", (syp - symtab));
                do {
                    dumpadef((char *) NULL, dp);
                } while ((dp = dp->link) != (DEFBUF *) NULL);
            }
        }
		if ( bDumpDefs )
		{
            fprintf( pCppOut, "\n");
			pCppOut = pRememberOut;
		}
}

void dumpadef(char *why, register DEFBUF *dp)
{
        register char           *cp;
        register int            c;
		FILE *pRememberOut = NULL;

/*ER dump #define's to pDefOut */
		if ( bDumpDefs )
		{
			pRememberOut = pCppOut;
			pCppOut = pDefOut;
		}
        fprintf( pCppOut, " \"%s\" [%d]", dp->name, dp->nargs);
        if (why != NULL)
            fprintf( pCppOut, " (%s)", why);
        if (dp->repl != NULL) {
            fprintf( pCppOut, " => ");
            for (cp = dp->repl; (c = *cp++ & 0xFF) != EOS;) {
#ifdef SOLAR
                if (c == DEL) {
                    c = *cp++ & 0xFF;
                    if( c == EOS ) break;
                    fprintf( pCppOut, "<%%%d>", c - MAC_PARM);
                }
#else
                if (c >= MAC_PARM && c <= (MAC_PARM + PAR_MAC))
                    fprintf( pCppOut, "<%%%d>", c - MAC_PARM);
#endif
                else if (isprint(c) || c == '\n' || c == '\t')
                    PUTCHAR(c);
                else if (c < ' ')
                    fprintf( pCppOut, "<^%c>", c + '@');
                else
                    fprintf( pCppOut, "<\\0%o>", c);
            }
/*ER evaluate macros to pDefOut */
#ifdef EVALDEFS
			if ( bDumpDefs && !bIsInEval && dp->nargs <= 0 )
			{
				FILEINFO *infileSave = infile;
				char *tokenSave = savestring( token );
				char *workSave = savestring( work );
				int lineSave = line;
				int wronglineSave = wrongline;
				int recursionSave = recursion;
				FILEINFO *file;
				EVALTYPE valEval;

				bIsInEval = 1;
				infile = NULL;			/* start from scrap */
				line = 0;
				wrongline = 0;
				*token = EOS;
				*work = EOS;
				recursion = 0;
				file = getfile( strlen( dp->repl ), dp->name );
				strcpy( file->buffer, dp->repl );
	            fprintf( pCppOut, " ===> ");
				nEvalOff = 0;
				cppmain();				/* get() frees also *file */
				valEval = 0;
				if ( 0 == evaluate( EvalBuf, &valEval ) )
				{
#ifdef EVALFLOATS
					if ( valEval != (EVALTYPE)((long)valEval ) )
		            	fprintf( pCppOut, " ==eval=> %f", valEval );
					else
#endif
		            	fprintf( pCppOut, " ==eval=> %ld", (long)valEval );
				}
				recursion = recursionSave;
				wrongline = wronglineSave;
				line = lineSave;
				strcpy( work, workSave );
				free( workSave );
				strcpy( token, tokenSave );
				free( tokenSave );
				infile = infileSave;
				bIsInEval = 0;
			}
#endif
        }
        else {
            fprintf( pCppOut, ", no replacement.");
        }
        PUTCHAR('\n');
		if ( bDumpDefs )
			pCppOut = pRememberOut;
}
#endif

/*
 *                      G E T
 */

int
get()
/*
 * Return the next character from a macro or the current file.
 * Handle end of file from #include files.
 */
{
        register int            c;
        register FILEINFO       *file;
        register int            popped;         /* Recursion fixup      */

        popped = 0;
get_from_file:
        if ((file = infile) == NULL)
            return (EOF_CHAR);
newline:
#if 0
        fprintf( pCppOut, "get(%s), recursion %d, line %d, bptr = %d, buffer \"%s\"\n",
            file->filename, recursion, line,
            file->bptr - file->buffer, file->buffer);
#endif
        /*
         * Read a character from the current input line or macro.
         * At EOS, either finish the current macro (freeing temp.
         * storage) or read another line from the current input file.
         * At EOF, exit the current file (#include) or, at EOF from
         * the cpp input file, return EOF_CHAR to finish processing.
         */
        if ((c = *file->bptr++ & 0xFF) == EOS) {
            /*
             * Nothing in current line or macro.  Get next line (if
             * input from a file), or do end of file/macro processing.
             * In the latter case, jump back to restart from the top.
             */
            if (file->fp == NULL) {             /* NULL if macro        */
                popped++;
                recursion -= file->unrecur;
                if (recursion < 0)
                    recursion = 0;
                infile = file->parent;          /* Unwind file chain    */
            }
            else {                              /* Else get from a file */
                if ((file->bptr = fgets(file->buffer, NBUFF, file->fp))
                        != NULL) {
#if OSL_DEBUG_LEVEL > 1
                    if (debug > 1) {            /* Dump it to stdout    */
                        fprintf( pCppOut, "\n#line %d (%s), %s",
                            line, file->filename, file->buffer);
                    }
#endif
                    goto newline;               /* process the line     */
                }
                else {
		    if( file->fp != stdin )
                        fclose(file->fp);           /* Close finished file  */
                    if ((infile = file->parent) != NULL) {
                        /*
                         * There is an "ungotten" newline in the current
                         * infile buffer (set there by doinclude() in
                         * cpp1.c).  Thus, we know that the mainline code
                         * is skipping over blank lines and will do a
                         * #line at its convenience.
                         */
                        wrongline = TRUE;       /* Need a #line now     */
                    }
                }
            }
            /*
             * Free up space used by the (finished) file or macro and
             * restart input from the parent file/macro, if any.
             */
            free(file->filename);               /* Free name and        */
            if (file->progname != NULL)         /* if a #line was seen, */
                free(file->progname);           /* free it, too.        */
            free((char *) file);                /* Free file space      */
            if (infile == NULL)                 /* If at end of file    */
                return (EOF_CHAR);              /* Return end of file   */
            line = infile->line;                /* Reset line number    */
            goto get_from_file;                 /* Get from the top.    */
        }
        /*
         * Common processing for the new character.
         */
        if (c == DEF_MAGIC && file->fp != NULL) /* Don't allow delete   */
            goto newline;                       /* from a file          */
        if (file->parent != NULL) {             /* Macro or #include    */
            if (popped != 0)
                file->parent->unrecur += popped;
            else {
                recursion -= file->parent->unrecur;
                if (recursion < 0)
                    recursion = 0;
                file->parent->unrecur = 0;
            }
        }
#if (HOST == SYS_UNIX)
/*ER*/	if (c == '\r')
/*ER*/		return get();						/* DOS fuck				*/
#endif
        if (c == '\n')                          /* Maintain current     */
            ++line;                             /* line counter         */
        if (instring)                           /* Strings just return  */
            return (c);                         /* the character.       */
        else if (c == '/') {                    /* Comment?             */
            instring = TRUE;                    /* So get() won't loop  */
/*MM c++ comments  */
/*MM*/      c = get();
/*MM*/      if ((c != '*') && (c != '/')) {     /* Next byte '*'?       */
                instring = FALSE;               /* Nope, no comment     */
                unget();                        /* Push the char. back  */
                return ('/');                   /* Return the slash     */
            }
            if (keepcomments) {                 /* If writing comments  */
                PUTCHAR('/');                   /* Write out the        */
                                                /*   initializer        */
/*MM*/          if( '*' == c )
                    PUTCHAR('*');
/*MM*/          else
/*MM*/              PUTCHAR('/');

            }
/*MM*/      if( '*' == c ){
                for (;;) {                          /* Eat a comment        */
                    c = get();
    test:           if (keepcomments && c != EOF_CHAR)
                        cput(c);
                    switch (c) {
                    case EOF_CHAR:
                        cerror("EOF in comment", NULLST);
                        return (EOF_CHAR);

                    case '/':
                        if ((c = get()) != '*')     /* Don't let comments   */
                            goto test;              /* Nest.                */
#ifdef STRICT_COMMENTS
                        cwarn("Nested comments", NULLST);
#endif
                                                    /* Fall into * stuff    */
                    case '*':
                        if ((c = get()) != '/')     /* If comment doesn't   */
                            goto test;              /* end, look at next    */
                        instring = FALSE;           /* End of comment,      */
                        if (keepcomments) {         /* Put out the comment  */
                            cput(c);                /* terminator, too      */
                        }
                        /*
                         * A comment is syntactically "whitespace" --
                         * however, there are certain strange sequences
                         * such as
                         *          #define foo(x)  (something)
                         *                  foo|* comment *|(123)
                         *       these are '/' ^           ^
                         * where just returning space (or COM_SEP) will cause
                         * problems.  This can be "fixed" by overwriting the
                         * '/' in the input line buffer with ' ' (or COM_SEP)
                         * but that may mess up an error message.
                         * So, we peek ahead -- if the next character is
                         * "whitespace" we just get another character, if not,
                         * we modify the buffer.  All in the name of purity.
                         */
                        if (*file->bptr == '\n'
                         || type[*file->bptr & 0xFF] == SPA)
                            goto newline;
#if COMMENT_INVISIBLE
                        /*
                         * Return magic (old-fashioned) syntactic space.
                         */
                        return ((file->bptr[-1] = COM_SEP));
#else
                        return ((file->bptr[-1] = ' '));
#endif

                    case '\n':                      /* we'll need a #line   */
                        if (!keepcomments)
                            wrongline = TRUE;       /* later...             */
                    default:                        /* Anything else is     */
                        break;                      /* Just a character     */
                    }                               /* End switch           */
                }                                   /* End comment loop     */
            }
            else{                                   /* c++ comment          */
/*MM c++ comment*/
                for (;;) {                          /* Eat a comment        */
                    c = get();
                    if (keepcomments && c != EOF_CHAR)
                        cput(c);
                    if( EOF_CHAR == c )
                        return (EOF_CHAR);
                    else if( '\n' == c ){
                        instring = FALSE;           /* End of comment,      */
                        return( c );
                    }
                }
            }
        }                                       /* End if in comment    */
        else if (!inmacro && c == '\\') {       /* If backslash, peek   */
            if ((c = get()) == '\n') {          /* for a <nl>.  If so,  */
                wrongline = TRUE;
                goto newline;
            }
            else {                              /* Backslash anything   */
                unget();                        /* Get it later         */
                return ('\\');                  /* Return the backslash */
            }
        }
        else if (c == '\f' || c == VT)          /* Form Feed, Vertical  */
            c = ' ';                            /* Tab are whitespace   */
        else if (c == 0xef)						/* eat up UTF-8 BOM */
        {
            if((c = get()) == 0xbb)
            {
                if((c = get()) == 0xbf)
                {
                    c = get();
                    return c;
                }
                else
                {
                    unget();
                    unget();
                    return 0xef;
                }
            }
            else
            {
                unget();
                return 0xef;
            }
        }
        return (c);                             /* Just return the char */
}

void unget()
/*
 * Backup the pointer to reread the last character.  Fatal error
 * (code bug) if we backup too far.  unget() may be called,
 * without problems, at end of file.  Only one character may
 * be ungotten.  If you need to unget more, call ungetstring().
 */
{
        register FILEINFO       *file;

        if ((file = infile) == NULL)
            return;                     /* Unget after EOF              */
        if (--file->bptr < file->buffer)
            cfatal("Too much pushback", NULLST);
        if (*file->bptr == '\n')        /* Ungetting a newline?         */
            --line;                     /* Unget the line number, too   */
}

void ungetstring(char* text)
/*
 * Push a string back on the input stream.  This is done by treating
 * the text as if it were a macro.
 */
{
        register FILEINFO       *file;
#ifndef ZTC /* BP */
        extern FILEINFO         *getfile();
#endif
        file = getfile(strlen(text) + 1, "");
        strcpy(file->buffer, text);
}

int
cget()
/*
 * Get one character, absorb "funny space" after comments or
 * token concatenation
 */
{
        register int    c;

        do {
            c = get();
#if COMMENT_INVISIBLE
        } while (c == TOK_SEP || c == COM_SEP);
#else
        } while (c == TOK_SEP);
#endif
        return (c);
}

/*
 * Error messages and other hacks.  The first byte of severity
 * is 'S' for string arguments and 'I' for int arguments.  This
 * is needed for portability with machines that have int's that
 * are shorter than  char *'s.
 */

static void domsg(char* severity, char* format, void* arg)
/*
 * Print filenames, macro names, and line numbers for error messages.
 */
{
        register char           *tp;
        register FILEINFO       *file;

        fprintf(stderr, "%sline %d, %s: ", MSG_PREFIX, line, &severity[1]);
        if (*severity == 'S')
            fprintf(stderr, format, (char *)arg);
        else
            fprintf(stderr, format, *((int *)arg) );
        putc('\n', stderr);
        if ((file = infile) == NULL)
            return;                             /* At end of file       */
        if (file->fp != NULL) {
            tp = file->buffer;                  /* Print current file   */
            fprintf(stderr, "%s", tp);          /* name, making sure    */
            if (tp[strlen(tp) - 1] != '\n')     /* there's a newline    */
                putc('\n', stderr);
        }
        while ((file = file->parent) != NULL) { /* Print #includes, too */
            if (file->fp == NULL)
                fprintf(stderr, "from macro %s\n", file->filename);
            else {
                tp = file->buffer;
                fprintf(stderr, "from file %s, line %d:\n%s",
                    (file->progname != NULL)
                        ? file->progname : file->filename,
                    file->line, tp);
                if (tp[strlen(tp) - 1] != '\n')
                    putc('\n', stderr);
            }
        }
}

void cerror(char* format, char* sarg)
/*
 * Print a normal error message, string argument.
 */
{
        domsg("SError", format, sarg);
        errors++;
}

void cierror(char* format, int narg)
/*
 * Print a normal error message, numeric argument.
 */
{
        domsg("IError", format, &narg);
        errors++;
}

void cfatal(char* format, char* sarg)
/*
 * A real disaster
 */
{
        domsg("SFatal error", format, sarg);
        exit(IO_ERROR);
}

void cwarn(char* format, char* sarg)
/*
 * A non-fatal error, string argument.
 */
{
        domsg("SWarning", format, sarg);
}

void ciwarn(char* format, int narg)
/*
 * A non-fatal error, numeric argument.
 */
{
        domsg("IWarning", format, &narg);
}