path: root/rsc/source/rscpp/cpp6.c

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   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 .
 */

#include <sal/types.h>
#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

#define DOL     LET


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


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



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

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

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

    do {                            /* Skip whitespace      */
        c = get();
    } while (type[c] == SPA);
    return c;
}

/*
 * Get the next token (an id) into the token buffer.
 * Note: this code is duplicated in lookid().
 * Change one, change both.
 */
void scanid(int c)
{
    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;
}

/*
 * 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.
 */
int macroid(int c)
{
    DEFBUF* dp;

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

/*
 * 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.
 */
int catenate()
{
    int c;
    char* token1;

    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 (isprint(c))
                cierror("Strange character '%c' after #", c);
            else
                cierror("Strange character (%d.) after #", c);
            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;
    }
}

/*
 * 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.
 */
int scanstring(int delim,
#ifndef _NO_PROTO
           void (*outfun)( int ) /* BP */    /* Output function              */
#else
           void (*outfun)() /* BP */
#endif
    )
{
    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;
    }
}

/*
 * Process a number.  We know that c is from 0 to 9 or dot.
 * Algorithm from Dave Conroy's Decus C.
 */
void scannumber(int c,
#ifndef _NO_PROTO
                void (*outfun)( int )  /* BP */    /* Output/store func    */
#else
                void (*outfun)() /* BP */
#endif
    )
{
    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);
            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;
}

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

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

/*
 * Common FILEINFO buffer initialization for a new file or macro.
 */
FILEINFO* getfile(size_t bufsize, char* name)
{
    FILEINFO* file;
    size_t 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.            */
}

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

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

/*
 * Look for the next token in the symbol table.  Returns token in "token".
 * If found, returns the table pointer;  Else returns NULL.
 */
DEFBUF* lookid(int c)
{
    int nhash;
    DEFBUF* dp;
    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);
}

/*
 * 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).
 */
DEFBUF* defendel(char* name, int delete)
{
    DEFBUF* dp;
    DEFBUF** prevp;
    char* np;
    int nhash;
    int temp=0;
    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      */
                dp = NULL;
            }
            break;
        }
        prevp = &dp->link;
    }
    if (!delete)
    {
        dp = (DEFBUF*) getmem(sizeof (DEFBUF) + size + 1);
        dp->link = *prevp;
        *prevp = dp;
        dp->hash = nhash;
        dp->repl = NULL;
        dp->nargs = 0;
        strcpy(dp->name, name);
    }
    return dp;
}

#if OSL_DEBUG_LEVEL > 0

void dumpdef(char* why)
{
    DEFBUF* dp;
    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[%" SAL_PRI_PTRDIFFT "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, DEFBUF* dp)
{
    char* cp;
    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
 */

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

    popped = 0;
  get_from_file:
    if ((file = infile) == NULL)
        return EOF_CHAR;
  newline:

    /*
     * 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 > 0
                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)
    if (c == '\r')
        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  */

        c = get();
        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        */
            if( '*' == c )
                PUTCHAR('*');
            else
                PUTCHAR('/');
        }
        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;
                    return (file->bptr[-1] = ' ');

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

/*
 * 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().
 */
void unget()
{
    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   */
}

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

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

    do
    {
        c = get();
    }
    while (c == TOK_SEP);
    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.
 */

/*
 * Print filenames, macro names, and line numbers for error messages.
 */
static void domsg(char* severity, char* format, void* arg)
{
    char* tp;
    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);
        }
    }
}

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

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

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

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

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

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */