xref: /aoo42x/main/rsc/source/rscpp/cpp2.c (revision cdf0e10c)

/*************************************************************************
 *
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * Copyright 2000, 2010 Oracle and/or its affiliates.
 *
 * OpenOffice.org - a multi-platform office productivity suite
 *
 * This file is part of OpenOffice.org.
 *
 * OpenOffice.org is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License version 3
 * only, as published by the Free Software Foundation.
 *
 * OpenOffice.org is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License version 3 for more details
 * (a copy is included in the LICENSE file that accompanied this code).
 *
 * You should have received a copy of the GNU Lesser General Public License
 * version 3 along with OpenOffice.org.  If not, see
 * <http://www.openoffice.org/license.html>
 * for a copy of the LGPLv3 License.
 *
 ************************************************************************/

#include        <stdio.h>
#include        <ctype.h>
#include        "cppdef.h"
#include        "cpp.h"
#if HOST == SYS_VMS
/*
 * Include the rms stuff.  (We can't just include rms.h as it uses the
 * VaxC-specific library include syntax that Decus CPP doesn't support.
 * By including things by hand, we can CPP ourself.)
 */
#include        <nam.h>
#include        <fab.h>
#include        <rab.h>
#include        <rmsdef.h>
#endif

/*
 * Generate (by hand-inspection) a set of unique values for each control
 * operator.  Note that this is not guaranteed to work for non-Ascii
 * machines.  CPP won't compile if there are hash conflicts.
 */

#define L_assert        ('a' + ('s' << 1))
#define L_define        ('d' + ('f' << 1))
#define L_elif          ('e' + ('i' << 1))
#define L_else          ('e' + ('s' << 1))
#define L_endif         ('e' + ('d' << 1))
#define L_if            ('i' + (EOS << 1))
#define L_ifdef         ('i' + ('d' << 1))
#define L_ifndef        ('i' + ('n' << 1))
#define L_include       ('i' + ('c' << 1))
#define L_line          ('l' + ('n' << 1))
#define L_nogood        (EOS + (EOS << 1))      /* To catch #i          */
#define L_pragma        ('p' + ('a' << 1))
#define L_undef         ('u' + ('d' << 1))
#define L_error         ('e' + ('r' << 1))      /* BP 5.3.92, #error */
#define MAXLINE 80                              /* BP 5.3.92, #error */
#if OSL_DEBUG_LEVEL > 1
#define L_debug         ('d' + ('b' << 1))      /* #debug               */
#define L_nodebug       ('n' + ('d' << 1))      /* #nodebug             */
#endif


void InitCpp2()
{

}


int
control(int counter)
/*
 * Process #control lines.  Simple commands are processed inline,
 * while complex commands have their own subroutines.
 *
 * The counter is used to force out a newline before #line, and
 * #pragma commands.  This prevents these commands from ending up at
 * the end of the previous line if cpp is invoked with the -C option.
 */
{
        register int            c;
        register char           *tp;
        register int            hash;
        char                    *ep;

        c = skipws();
        if (c == '\n' || c == EOF_CHAR)
            return (counter + 1);
        if (!isdigit(c))
            scanid(c);                  /* Get #word to token[]         */
        else {
            unget();                    /* Hack -- allow #123 as a      */
            strcpy(token, "line");      /* synonym for #line 123        */
        }
        hash = (token[1] == EOS) ? L_nogood : (token[0] + (token[2] << 1));
        switch (hash) {
        case L_assert:  tp = "assert";          break;
        case L_define:  tp = "define";          break;
        case L_elif:    tp = "elif";            break;
        case L_else:    tp = "else";            break;
        case L_endif:   tp = "endif";           break;
        case L_if:      tp = "if";              break;
        case L_ifdef:   tp = "ifdef";           break;
        case L_ifndef:  tp = "ifndef";          break;
        case L_include: tp = "include";         break;
        case L_line:    tp = "line";            break;
        case L_pragma:  tp = "pragma";          break;
        case L_undef:   tp = "undef";           break;
        case L_error:   tp = "error";           break;
#if OSL_DEBUG_LEVEL > 1
        case L_debug:   tp = "debug";           break;
        case L_nodebug: tp = "nodebug";         break;
#endif
        default:        hash = L_nogood;
        case L_nogood:  tp = "";                break;
        }
        if (!streq(tp, token))
            hash = L_nogood;
        /*
         * hash is set to a unique value corresponding to the
         * control keyword (or L_nogood if we think it's nonsense).
         */
        if (infile->fp == NULL)
            cwarn("Control line \"%s\" within macro expansion", token);
        if (!compiling) {                       /* Not compiling now    */
            switch (hash) {
            case L_if:                          /* These can't turn     */
            case L_ifdef:                       /*  compilation on, but */
            case L_ifndef:                      /*   we must nest #if's */
                if (++ifptr >= &ifstack[BLK_NEST])
                    goto if_nest_err;
                *ifptr = 0;                     /* !WAS_COMPILING       */
            case L_line:                        /* Many                 */
            /*
             * Are pragma's always processed?
             */
            case L_pragma:                      /*  options             */
            case L_include:                     /*   are uninteresting  */
            case L_define:                      /*    if we             */
            case L_undef:                       /*     aren't           */
            case L_assert:                      /*      compiling.      */
            case L_error:                       /* BP 5.3.92, #error */
dump_line:      skipnl();                       /* Ignore rest of line  */
                return (counter + 1);
            }
        }
        /*
         * Make sure that #line and #pragma are output on a fresh line.
         */
        if (counter > 0 && (hash == L_line || hash == L_pragma)) {
            PUTCHAR('\n');
            counter--;
        }
        switch (hash) {
        case L_line:
            /*
             * Parse the line to update the line number and "progname"
             * field and line number for the next input line.
             * Set wrongline to force it out later.
             */
            c = skipws();
            workp = work;                       /* Save name in work    */
            while (c != '\n' && c != EOF_CHAR) {
                save(c);
                c = get();
            }
            unget();
            save(EOS);
            /*
             * Split #line argument into <line-number> and <name>
             * We subtract 1 as we want the number of the next line.
             */
            line = atoi(work) - 1;              /* Reset line number    */
            for (tp = work; isdigit(*tp) || type[(int)*tp] == SPA; tp++)
                ;                               /* Skip over digits     */
            if (*tp != EOS) {                   /* Got a filename, so:  */
                if (*tp == '"' && (ep = strrchr(tp + 1, '"')) != NULL) {
                    tp++;                       /* Skip over left quote */
                    *ep = EOS;                  /* And ignore right one */
                }
                if (infile->progname != NULL)   /* Give up the old name */
                    free(infile->progname);     /* if it's allocated.   */
                infile->progname = savestring(tp);
            }
            wrongline = TRUE;                   /* Force output later   */
            break;

        case L_include:
            doinclude();
            break;

        case L_define:
            dodefine();
            break;

        case L_undef:
            doundef();
            break;

        case L_else:
            if (ifptr == &ifstack[0])
                goto nest_err;
            else if ((*ifptr & ELSE_SEEN) != 0)
                goto else_seen_err;
            *ifptr |= ELSE_SEEN;
            if ((*ifptr & WAS_COMPILING) != 0) {
                if (compiling || (*ifptr & TRUE_SEEN) != 0)
                    compiling = FALSE;
                else {
                    compiling = TRUE;
                }
            }
            break;

        case L_elif:
            if (ifptr == &ifstack[0])
                goto nest_err;
            else if ((*ifptr & ELSE_SEEN) != 0) {
else_seen_err:  cerror("#%s may not follow #else", token);
                goto dump_line;
            }
            if ((*ifptr & (WAS_COMPILING | TRUE_SEEN)) != WAS_COMPILING) {
                compiling = FALSE;              /* Done compiling stuff */
                goto dump_line;                 /* Skip this clause     */
            }
            doif(L_if);
            break;

        case L_if:
        case L_ifdef:
        case L_ifndef:
            if (++ifptr >= &ifstack[BLK_NEST])
if_nest_err:    cfatal("Too many nested #%s statements", token);
            *ifptr = WAS_COMPILING;
            doif(hash);
            break;

        case L_endif:
            if (ifptr == &ifstack[0]) {
nest_err:       cerror("#%s must be in an #if", token);
                goto dump_line;
            }
            if (!compiling && (*ifptr & WAS_COMPILING) != 0)
                wrongline = TRUE;
            compiling = ((*ifptr & WAS_COMPILING) != 0);
            --ifptr;
            break;

        case L_assert:
            if (eval() == 0)
                cerror("Preprocessor assertion failure", NULLST);
            break;

        case L_pragma:
            /*
             * #pragma is provided to pass "options" to later
             * passes of the compiler.  cpp doesn't have any yet.
             */
            fprintf( pCppOut, "#pragma ");
            while ((c = get()) != '\n' && c != EOF_CHAR)
                cput(c);
            unget();
            break;

#if OSL_DEBUG_LEVEL > 1
        case L_debug:
            if (debug == 0)
                dumpdef("debug set on");
            debug++;
            break;

        case L_nodebug:
            debug--;
            break;
#endif
        case L_error:                       /* BP 5.3.92, #error */
        {
            fprintf( pCppOut, "cpp: line %u, Error directive: ", line );
            while ((c = get()) != '\n' && c != EOF_CHAR)
                cput(c);
            fprintf( pCppOut, "\n" );
            exit( 1 );
            break;
        }
        default:
            /*
             * Undefined #control keyword.
             * Note: the correct behavior may be to warn and
             * pass the line to a subsequent compiler pass.
             * This would allow #asm or similar extensions.
             */
            cerror("Illegal # command \"%s\"", token);
            break;
        }
        if (hash != L_include) {
#if OLD_PREPROCESSOR
            /*
             * Ignore the rest of the #control line so you can write
             *          #if     foo
             *          #endif  foo
             */
            goto dump_line;                     /* Take common exit     */
#else
            if (skipws() != '\n') {
                cwarn("Unexpected text in #control line ignored", NULLST);
                skipnl();
            }
#endif
        }
        return (counter + 1);
}

FILE_LOCAL
void doif(int hash)
/*
 * Process an #if, #ifdef, or #ifndef.  The latter two are straightforward,
 * while #if needs a subroutine of its own to evaluate the expression.
 *
 * doif() is called only if compiling is TRUE.  If false, compilation
 * is always supressed, so we don't need to evaluate anything.  This
 * supresses unnecessary warnings.
 */
{
        register int            c;
        register int            found;

        if ((c = skipws()) == '\n' || c == EOF_CHAR) {
            unget();
            goto badif;
        }
        if (hash == L_if) {
            unget();
            found = (eval() != 0);      /* Evaluate expr, != 0 is  TRUE */
            hash = L_ifdef;             /* #if is now like #ifdef       */
        }
        else {
            if (type[c] != LET)         /* Next non-blank isn't letter  */
                goto badif;             /* ... is an error              */
            found = (lookid(c) != NULL); /* Look for it in symbol table */
        }
        if (found == (hash == L_ifdef)) {
            compiling = TRUE;
            *ifptr |= TRUE_SEEN;
        }
        else {
            compiling = FALSE;
        }
        return;

badif:  cerror("#if, #ifdef, or #ifndef without an argument", NULLST);
#if !OLD_PREPROCESSOR
        skipnl();                               /* Prevent an extra     */
        unget();                                /* Error message        */
#endif
        return;
}

FILE_LOCAL
void doinclude()
/*
 * Process the #include control line.
 * There are three variations:
 *      #include "file"         search somewhere relative to the
 *                              current source file, if not found,
 *                              treat as #include <file>.
 *      #include <file>         Search in an implementation-dependent
 *                              list of places.
 *      #include token          Expand the token, it must be one of
 *                              "file" or <file>, process as such.
 *
 * Note: the November 12 draft forbids '>' in the #include <file> format.
 * This restriction is unnecessary and not implemented.
 */
{
        register int            c;
        register int            delim;
#if HOST == SYS_VMS
        char                    def_filename[NAM$C_MAXRSS + 1];
#endif

        delim = macroid(skipws());
        if (delim != '<' && delim != '"')
            goto incerr;
        if (delim == '<')
            delim = '>';
        workp = work;
        instring = TRUE;                /* Accept all characters        */
#ifdef CONTROL_COMMENTS_NOT_ALLOWED
        while ((c = get()) != '\n' && c != EOF_CHAR)
            save(c);                    /* Put it away.                 */
        unget();                        /* Force nl after includee      */
        /*
         * The draft is unclear if the following should be done.
         */
        while (--workp >= work && *workp == ' ')
            ;                           /* Trim blanks from filename    */
        if (*workp != delim)
            goto incerr;
#else
        while ((c = get()) != delim && c != EOF_CHAR)
            save(c);
#endif
        *workp = EOS;                   /* Terminate filename           */
        instring = FALSE;
#if HOST == SYS_VMS
        /*
         * Assume the default .h filetype.
         */
        if (!vmsparse(work, ".H", def_filename)) {
            perror(work);               /* Oops.                        */
            goto incerr;
        }
        else if (openinclude(def_filename, (delim == '"')))
            return;
#else
        if (openinclude(work, (delim == '"')))
            return;
#endif
        /*
         * No sense continuing if #include file isn't there.
         */
        cfatal("Cannot open include file \"%s\"", work);

incerr: cerror("#include syntax error", NULLST);
        return;
}

FILE_LOCAL int
openinclude(char* filename, int searchlocal)
/*
 * Actually open an include file.  This routine is only called from
 * doinclude() above, but was written as a separate subroutine for
 * programmer convenience.  It searches the list of directories
 * and actually opens the file, linking it into the list of
 * active files.  Returns TRUE if the file was opened, FALSE
 * if openinclude() fails.  No error message is printed.
 */
{
        register char           **incptr;
#if HOST == SYS_VMS
#if NFWORK < (NAM$C_MAXRSS + 1)
    << error, NFWORK is not greater than NAM$C_MAXRSS >>
#endif
#endif
        char                    tmpname[NFWORK]; /* Filename work area   */

        if (searchlocal) {
            /*
             * Look in local directory first
             */
#if HOST == SYS_UNIX
            /*
             * Try to open filename relative to the directory of the current
             * source file (as opposed to the current directory). (ARF, SCK).
             */
            if (filename[0] != '/'
             && hasdirectory(infile->filename, tmpname))
                strcat(tmpname, filename);
            else {
                strcpy(tmpname, filename);
            }
#else
            if (!hasdirectory(filename, tmpname)
             && hasdirectory(infile->filename, tmpname))
                strcat(tmpname, filename);
            else {
                strcpy(tmpname, filename);
            }
#endif
            if (openfile(tmpname))
                return (TRUE);
        }
        /*
         * Look in any directories specified by -I command line
         * arguments, then in the builtin search list.
         */
        for (incptr = incdir; incptr < incend; incptr++) {
            if (strlen(*incptr) + strlen(filename) >= (NFWORK - 1))
                cfatal("Filename work buffer overflow", NULLST);
            else {
#if HOST == SYS_UNIX
                if (filename[0] == '/')
                    strcpy(tmpname, filename);
                else {
                    sprintf(tmpname, "%s/%s", *incptr, filename);
                }
#elif HOST == SYS_UNKNOWN
                if (filename[0] == '\\')
                    strcpy(tmpname, filename);
                else {
                    sprintf(tmpname, "%s\\%s", *incptr, filename);
                }
#else
                if (!hasdirectory(filename, tmpname))
                    sprintf(tmpname, "%s%s", *incptr, filename);
#endif
                if (openfile(tmpname))
                    return (TRUE);
            }
        }
        return (FALSE);
}

FILE_LOCAL int
hasdirectory(char* source, char* result)
/*
 * If a device or directory is found in the source filename string, the
 * node/device/directory part of the string is copied to result and
 * hasdirectory returns TRUE.  Else, nothing is copied and it returns FALSE.
 */
{
#if HOST == SYS_UNIX
        register char           *tp;

        if ((tp = strrchr(source, '/')) == NULL)
            return (FALSE);
        else {
            strncpy(result, source, tp - source + 1);
            result[tp - source + 1] = EOS;
            return (TRUE);
        }
#else
#if HOST == SYS_VMS
        if (vmsparse(source, NULLST, result)
         && result[0] != EOS)
            return (TRUE);
        else {
            return (FALSE);
        }
#else
        /*
         * Random DEC operating system (RSX, RT11, RSTS/E)
         */
        register char           *tp;

        if ((tp = strrchr(source, ']')) == NULL
         && (tp = strrchr(source, ':')) == NULL)
            return (FALSE);
        else {
            strncpy(result, source, tp - source + 1);
            result[tp - source + 1] = EOS;
            return (TRUE);
        }
#endif
#endif
}

#if HOST == SYS_VMS

/*
 * EXP_DEV is set if a device was specified, EXP_DIR if a directory
 * is specified.  (Both set indicate a file-logical, but EXP_DEV
 * would be set by itself if you are reading, say, SYS$INPUT:)
 */
#define DEVDIR (NAM$M_EXP_DEV | NAM$M_EXP_DIR)

FILE_LOCAL int
vmsparse(source, defstring, result)
char            *source;
char            *defstring;     /* non-NULL -> default string.          */
char            *result;        /* Size is at least NAM$C_MAXRSS + 1    */
/*
 * Parse the source string, applying the default (properly, using
 * the system parse routine), storing it in result.
 * TRUE if it parsed, FALSE on error.
 *
 * If defstring is NULL, there are no defaults and result gets
 * (just) the node::[directory] part of the string (possibly "")
 */
{
        struct FAB      fab = cc$rms_fab;       /* File access block    */
        struct NAM      nam = cc$rms_nam;       /* File name block      */
        char            fullname[NAM$C_MAXRSS + 1];
        register char   *rp;                    /* Result pointer       */

        fab.fab$l_nam = &nam;                   /* fab -> nam           */
        fab.fab$l_fna = source;                 /* Source filename      */
        fab.fab$b_fns = strlen(source);         /* Size of source       */
        fab.fab$l_dna = defstring;              /* Default string       */
        if (defstring != NULLST)
            fab.fab$b_dns = strlen(defstring);  /* Size of default      */
        nam.nam$l_esa = fullname;               /* Expanded filename    */
        nam.nam$b_ess = NAM$C_MAXRSS;           /* Expanded name size   */
        if (sys$parse(&fab) == RMS$_NORMAL) {   /* Parse away           */
            fullname[nam.nam$b_esl] = EOS;      /* Terminate string     */
            result[0] = EOS;                    /* Just in case         */
            rp = &result[0];
            /*
             * Remove stuff added implicitly, accepting node names and
             * dev:[directory] strings (but not process-permanent files).
             */
            if ((nam.nam$l_fnb & NAM$M_PPF) == 0) {
                if ((nam.nam$l_fnb & NAM$M_NODE) != 0) {
                    strncpy(result, nam.nam$l_node, nam.nam$b_node);
                    rp += nam.nam$b_node;
                    *rp = EOS;
                }
                if ((nam.nam$l_fnb & DEVDIR) == DEVDIR) {
                    strncpy(rp, nam.nam$l_dev, nam.nam$b_dev + nam.nam$b_dir);
                    rp += nam.nam$b_dev + nam.nam$b_dir;
                    *rp = EOS;
                }
            }
            if (defstring != NULLST) {
                strncpy(rp, nam.nam$l_name, nam.nam$b_name + nam.nam$b_type);
                rp += nam.nam$b_name + nam.nam$b_type;
                *rp = EOS;
                if ((nam.nam$l_fnb & NAM$M_EXP_VER) != 0) {
                    strncpy(rp, nam.nam$l_ver, nam.nam$b_ver);
                    rp[nam.nam$b_ver] = EOS;
                }
            }
            return (TRUE);
        }
        return (FALSE);
}
#endif