Adding upstream version 4:7.4.7.upstream/4%7.4.7upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 762 insertions, 0 deletions

diff --git a/soltools/cpp/_macro.c b/soltools/cpp/_macro.c
new file mode 100644
index 000000000..ef41b992e
--- /dev/null
+++ b/soltools/cpp/_macro.c
@@ -0,0 +1,762 @@
+/* -*- 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 <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#if defined(__IBMC__) || defined(__EMX__) || defined(_MSC_VER)
+#   ifndef PATH_MAX
+#       define PATH_MAX _MAX_PATH
+#   endif
+#endif
+#include <limits.h>
+
+#include "cpp.h"
+
+#define NCONCAT 16384
+
+/*
+ * do a macro definition.  tp points to the name being defined in the line
+ */
+void
+    dodefine(Tokenrow * trp)
+{
+    Token *tp;
+    Nlist *np;
+    Source *s;
+    Tokenrow *def, *args;
+    static uchar location[(PATH_MAX + 8) * NINC], *cp;
+
+    tp = trp->tp + 1;
+    if (tp >= trp->lp || tp->type != NAME)
+    {
+        error(ERROR, "#defined token is not a name");
+        return;
+    }
+    np = lookup(tp, 1);
+    if (np->flag & ISUNCHANGE)
+    {
+        error(ERROR, "#defined token %t can't be redefined", tp);
+        return;
+    }
+    /* collect arguments */
+    tp += 1;
+    args = NULL;
+    if (tp < trp->lp && tp->type == LP && tp->wslen == 0)
+    {
+        tp += 1;
+        args = new(Tokenrow);
+        maketokenrow(2, args);
+        if (tp->type != RP)
+        {
+            /* macro with args */
+            size_t narg = 0;
+            int err = 0;
+
+            for (;;)
+            {
+                Token *atp;
+
+                if (tp->type != NAME)
+                {
+                    err++;
+                    break;
+                }
+                if (narg >= args->max)
+                    growtokenrow(args);
+                for (atp = args->bp; atp < args->lp; atp++)
+                    if (atp->len == tp->len
+                        && strncmp((char *) atp->t, (char *) tp->t, tp->len) == 0)
+                        error(ERROR, "Duplicate macro argument");
+                *args->lp++ = *tp;
+                narg++;
+                tp += 1;
+                if (tp->type == RP)
+                    break;
+                if (tp->type != COMMA)
+                {
+                    err++;
+                    break;
+                }
+                tp += 1;
+            }
+            if (err)
+            {
+                error(ERROR, "Syntax error in macro parameters");
+                return;
+            }
+        }
+        tp += 1;
+    }
+    trp->tp = tp;
+    if (((trp->lp) - 1)->type == NL)
+        trp->lp -= 1;
+    def = normtokenrow(trp);
+    if (np->flag & ISDEFINED)
+    {
+        if (comparetokens(def, np->vp)
+            || (np->ap == NULL) != (args == NULL)
+            || (np->ap && comparetokens(args, np->ap)))
+        {
+            if ( np->loc )
+                error(ERROR,
+                    "Macro redefinition of %t (already defined at %s)",
+                    trp->bp + 2, np->loc);
+            else
+                error(ERROR,
+                    "Macro redefinition of %t (already defined at %s)",
+                    trp->bp + 2, "commandline" );
+        }
+    }
+    if (args)
+    {
+        Tokenrow *tap;
+
+        tap = normtokenrow(args);
+        dofree(args->bp);
+        dofree(args);
+        args = tap;
+    }
+    np->ap = args;
+    np->vp = def;
+    np->flag |= ISDEFINED;
+
+    /* build location string of macro definition */
+    for (cp = location, s = cursource; s; s = s->next)
+        if (*s->filename)
+        {
+            if (cp != location)
+                *cp++ = ' ';
+            sprintf((char *)cp, "%s:%d", s->filename, s->line);
+            cp += strlen((char *)cp);
+        }
+
+    np->loc = newstring(location, strlen((char *)location), 0);
+
+    if (Mflag)
+    {
+        if (np->ap)
+            error(INFO, "Macro definition of %s(%r) [%r]", np->name, np->ap, np->vp);
+        else
+            error(INFO, "Macro definition of %s [%r]", np->name, np->vp);
+    }
+}
+
+/*
+ * Definition received via -D or -U
+ */
+void
+    doadefine(Tokenrow * trp, int type)
+{
+    Nlist *np;
+    static uchar onestr[2] = "1";
+    static Token onetoken[1] = {{NUMBER, 0, 1, onestr, 0}};
+    static Tokenrow onetr = {onetoken, onetoken, onetoken + 1, 1};
+
+    trp->tp = trp->bp;
+    if (type == 'U')
+    {
+        if (trp->lp - trp->tp != 2 || trp->tp->type != NAME)
+            goto syntax;
+        if ((np = lookup(trp->tp, 0)) == NULL)
+            return;
+        np->flag &= ~ISDEFINED;
+        return;
+    }
+
+    if (type == 'A')
+    {
+        if (trp->tp >= trp->lp || trp->tp->type != NAME)
+            goto syntax;
+        trp->tp->type = ARCHITECTURE;
+        np = lookup(trp->tp, 1);
+        np->flag |= ISARCHITECTURE;
+        trp->tp += 1;
+        if (trp->tp >= trp->lp || trp->tp->type == END)
+        {
+            np->vp = &onetr;
+            return;
+        }
+        else
+            error(FATAL, "Illegal -A argument %r", trp);
+    }
+
+    if (trp->tp >= trp->lp || trp->tp->type != NAME)
+        goto syntax;
+    np = lookup(trp->tp, 1);
+    np->flag |= ISDEFINED;
+    trp->tp += 1;
+    if (trp->tp >= trp->lp || trp->tp->type == END)
+    {
+        np->vp = &onetr;
+        return;
+    }
+    if (trp->tp->type != ASGN)
+        goto syntax;
+    trp->tp += 1;
+    if ((trp->lp - 1)->type == END)
+        trp->lp -= 1;
+    np->vp = normtokenrow(trp);
+    return;
+syntax:
+    error(FATAL, "Illegal -D or -U argument %r", trp);
+}
+
+
+
+/*
+ * Do macro expansion in a row of tokens.
+ * Flag is NULL if more input can be gathered.
+ */
+void
+    expandrow(Tokenrow * trp, char *flag)
+{
+    Token * tp;
+    Nlist * np;
+
+    MacroValidatorList  validators;
+    mvl_init(&validators);
+    /* Sets all token-identifiers to 0 because tokens may not be initialised (never use C!) */
+    tokenrow_zeroTokenIdentifiers(trp);
+
+    if (flag)
+        setsource(flag, -1, -1, "", 0);
+    for (tp = trp->tp; tp < trp->lp;)
+    {
+        mvl_check(&validators, tp);
+
+        if (tp->type != NAME
+            || quicklook(tp->t[0], tp->len > 1 ? tp->t[1] : 0) == 0
+            || (np = lookup(tp, 0)) == NULL
+            || (np->flag & (ISDEFINED | ISMAC)) == 0
+            || (np->flag & ISACTIVE) != 0)
+        {
+            tp++;
+            continue;
+        }
+        trp->tp = tp;
+        if (np->val == KDEFINED)
+        {
+            tp->type = DEFINED;
+            if ((tp + 1) < trp->lp && (tp + 1)->type == NAME)
+                (tp + 1)->type = NAME1;
+            else
+                if ((tp + 3) < trp->lp && (tp + 1)->type == LP
+                    && (tp + 2)->type == NAME && (tp + 3)->type == RP)
+                    (tp + 2)->type = NAME1;
+                else
+                    error(ERROR, "Incorrect syntax for `defined'");
+            tp++;
+            continue;
+        }
+        else
+            if (np->val == KMACHINE)
+            {
+                if (((tp - 1) >= trp->bp) && ((tp - 1)->type == SHARP))
+                {
+                    tp->type = ARCHITECTURE;
+                    if ((tp + 1) < trp->lp && (tp + 1)->type == NAME)
+                        (tp + 1)->type = NAME2;
+                    else
+                        if ((tp + 3) < trp->lp && (tp + 1)->type == LP
+                            && (tp + 2)->type == NAME && (tp + 3)->type == RP)
+                            (tp + 2)->type = NAME2;
+                        else
+                            error(ERROR, "Incorrect syntax for `#machine'");
+                }
+                tp++;
+                continue;
+            }
+
+        if (np->flag & ISMAC)
+            builtin(trp, np->val);
+        else
+        {
+            // coverity[overrun-buffer-arg: FALSE] - a multiple of trp->max is allocated, not trp->max itself
+            expand(trp, np, &validators);
+        }
+        tp = trp->tp;
+    }   // end for
+    if (flag)
+        unsetsource();
+
+    mvl_destruct(&validators);
+}
+
+/*
+ * Expand the macro whose name is np, at token trp->tp, in the tokenrow.
+ * Return trp->tp at the first token next to be expanded
+ * (ordinarily the beginning of the expansion)
+ * I.e.: the same position as before!
+ * Only one expansion is performed, then we return to the expandrow()
+ * loop and start at same position.
+ */
+void
+    expand(Tokenrow * trp, Nlist * np, MacroValidatorList * pValidators)
+{
+    Tokenrow ntr;
+    int ntokc, narg;
+    Tokenrow *atr[NARG + 1];
+
+    if (Mflag == 2)
+    {
+        if (np->ap)
+            error(INFO, "Macro expansion of %t with %s(%r)", trp->tp, np->name, np->ap);
+        else
+            error(INFO, "Macro expansion of %t with %s", trp->tp, np->name);
+    }
+
+    copytokenrow(&ntr, np->vp);         /* copy macro value */
+    if (np->ap == NULL)                 /* parameterless */
+        ntokc = 1;
+    else
+    {
+        int i;
+
+        ntokc = gatherargs(trp, atr, &narg);
+        if (narg < 0)
+        {                               /* not actually a call (no '(') */
+            trp->tp++;
+            return;
+        }
+        if (narg != rowlen(np->ap))
+        {
+            error(ERROR, "Disagreement in number of macro arguments");
+            trp->tp += ntokc;
+            return;
+        }
+
+        /** If gatherargs passed a macro validating token, this token
+            must become valid here.
+            trp->tp+0 was checked in expandrow(), so we don't need to do it
+            again here:
+        */
+        for (i = 1; i < ntokc; i++)
+        {
+            mvl_check(pValidators,trp->tp+i);
+        }
+
+        substargs(np, &ntr, atr);       /* put args into replacement */
+        for (i = 0; i < narg; i++)
+        {
+            dofree(atr[i]->bp);
+            dofree(atr[i]);
+        }
+    }
+
+    doconcat(&ntr);                     /* execute ## operators */
+    ntr.tp = ntr.bp;
+    makespace(&ntr, trp->tp);
+
+    tokenrow_zeroTokenIdentifiers(&ntr);
+    insertrow(trp, ntokc, &ntr);
+
+        /* add validator for just invalidated macro:
+        */
+    np->flag |= ISACTIVE;
+    if (trp->tp != trp->lp)
+    {   /* tp is a valid pointer: */
+        mvl_add(pValidators,np,trp->tp);
+    }
+    else
+    {   /* tp is == lp, therefore does not point to valid memory: */
+        mvl_add(pValidators,np,NULL);
+    }
+        /* reset trp->tp to original position:
+        */
+    trp->tp -= ntr.lp - ntr.bp;         /* so the result will be tested for macros from the same position again */
+
+    dofree(ntr.bp);
+
+    return;
+}
+
+/*
+ * Gather an arglist, starting in trp with tp pointing at the macro name.
+ * Return total number of tokens passed, stash number of args found.
+ * trp->tp is not changed relative to the tokenrow.
+ */
+int
+    gatherargs(Tokenrow * trp, Tokenrow ** atr, int *narg)
+{
+    int parens = 1;
+    int ntok = 0;
+    Token *bp, *lp;
+    Tokenrow ttr;
+    int ntokp;
+    int needspace;
+
+    *narg = -1;                         /* means that there is no macro
+                                         * call */
+    /* look for the ( */
+    for (;;)
+    {
+        trp->tp++;
+        ntok++;
+        if (trp->tp >= trp->lp)
+        {
+            // coverity[overrun-buffer-arg: FALSE] - a multiple of trp->max is allocated, not trp->max itself
+            gettokens(trp, 0);
+            if ((trp->lp - 1)->type == END)
+            {
+                trp->lp -= 1;
+                trp->tp -= ntok;
+                return ntok;
+            }
+        }
+        if (trp->tp->type == LP)
+            break;
+        if (trp->tp->type != NL)
+            return ntok;
+    }
+    *narg = 0;
+    ntok++;
+    ntokp = ntok;
+    trp->tp++;
+    /* search for the terminating ), possibly extending the row */
+    needspace = 0;
+    while (parens > 0)
+    {
+        if (trp->tp >= trp->lp)
+        {
+            // coverity[overrun-buffer-arg: FALSE] - a multiple of trp->max is allocated, not trp->max itself
+            gettokens(trp, 0);
+        }
+        if (needspace)
+        {
+            needspace = 0;
+            /* makespace(trp); [rh] */
+        }
+        if (trp->tp->type == END)
+        {
+            trp->lp -= 1;
+            trp->tp -= ntok;
+            error(ERROR, "EOF in macro arglist");
+            return ntok;
+        }
+        if (trp->tp->type == NL)
+        {
+            trp->tp += 1;
+            adjustrow(trp, -1);
+            trp->tp -= 1;
+            /* makespace(trp); [rh] */
+            needspace = 1;
+            continue;
+        }
+        if (trp->tp->type == LP)
+            parens++;
+        else
+            if (trp->tp->type == RP)
+                parens--;
+        trp->tp++;
+        ntok++;
+    }
+    trp->tp -= ntok;
+    /* Now trp->tp won't move underneath us */
+    lp = bp = trp->tp + ntokp;
+    for (; parens >= 0; lp++)
+    {
+        if (lp->type == LP)
+        {
+            parens++;
+            continue;
+        }
+        if (lp->type == RP)
+            parens--;
+        if (lp->type == DSHARP)
+            lp->type = DSHARP1;         /* ## not special in arg */
+        if ((lp->type == COMMA && parens == 0) ||
+                ( parens < 0 && ((lp - 1)->type != LP)))
+        {
+            if (*narg >= NARG - 1)
+                error(FATAL, "Sorry, too many macro arguments");
+            ttr.bp = ttr.tp = bp;
+            ttr.lp = lp;
+            atr[(*narg)++] = normtokenrow(&ttr);
+            bp = lp + 1;
+        }
+    }
+    return ntok;
+}
+
+/*
+ * substitute the argument list into the replacement string
+ *  This would be simple except for ## and #
+ */
+void
+    substargs(Nlist * np, Tokenrow * rtr, Tokenrow ** atr)
+{
+    Tokenrow tatr;
+    Token *tp;
+    int ntok, argno;
+
+    for (rtr->tp = rtr->bp; rtr->tp < rtr->lp;)
+    {
+        if (rtr->tp->type == SHARP)
+        {                               /* string operator */
+            tp = rtr->tp;
+            rtr->tp += 1;
+            if ((argno = lookuparg(np, rtr->tp)) < 0)
+            {
+                error(ERROR, "# not followed by macro parameter");
+                continue;
+            }
+            ntok = 1 + (int)(rtr->tp - tp);
+            rtr->tp = tp;
+            insertrow(rtr, ntok, stringify(atr[argno]));
+            continue;
+        }
+        if (rtr->tp->type == NAME
+            && (argno = lookuparg(np, rtr->tp)) >= 0)
+        {
+            if (((rtr->tp + 1) < rtr->lp && (rtr->tp + 1)->type == DSHARP)
+                || (rtr->tp != rtr->bp  && (rtr->tp - 1)->type == DSHARP))
+            {
+                copytokenrow(&tatr, atr[argno]);
+                makespace(&tatr, rtr->tp);
+                insertrow(rtr, 1, &tatr);
+                dofree(tatr.bp);
+            }
+            else
+            {
+                copytokenrow(&tatr, atr[argno]);
+                makespace(&tatr, rtr->tp);
+                expandrow(&tatr, "<macro>");
+                insertrow(rtr, 1, &tatr);
+                dofree(tatr.bp);
+            }
+            continue;
+        }
+        rtr->tp++;
+    }
+}
+
+/*
+ * Evaluate the ## operators in a tokenrow
+ */
+void
+    doconcat(Tokenrow * trp)
+{
+    Token *ltp, *ntp;
+    Tokenrow ntr;
+    size_t len;
+
+    for (trp->tp = trp->bp; trp->tp < trp->lp; trp->tp++)
+    {
+        if (trp->tp->type == DSHARP1)
+            trp->tp->type = DSHARP;
+        else
+            if (trp->tp->type == DSHARP)
+            {
+                int  i;
+                char tt[NCONCAT];
+
+                ltp = trp->tp - 1;
+                ntp = trp->tp + 1;
+
+                if (ltp < trp->bp || ntp >= trp->lp)
+                {
+                    error(ERROR, "## occurs at border of replacement");
+                    continue;
+                }
+
+                ntp = ltp;
+                i   = 1;
+                len = 0;
+
+                do
+                {
+                    if (len + ntp->len + ntp->wslen > sizeof(tt))
+                    {
+                        error(ERROR, "## string concatenation buffer overrun");
+                        break;
+                    }
+
+                    if (ntp != trp->tp + 1)
+                    {
+                        strncpy((char *) tt + len, (char *) ntp->t - ntp->wslen,
+                                ntp->len + ntp->wslen);
+                        len += ntp->len + ntp->wslen;
+                    }
+                    else
+                    {
+                        // remove spaces around ##
+                        strncpy((char *) tt + len, (char *) ntp->t, ntp->len);
+                        len += ntp->len;
+                    }
+
+                    ntp = trp->tp + i;
+                    i++;
+                }
+                while (ntp < trp->lp);
+
+                tt[len] = '\0';
+                setsource("<##>", -1, -1, tt, 0);
+                maketokenrow(3, &ntr);
+                // coverity[overrun-buffer-arg: FALSE] - a multiple of trp->max is allocated, not trp->max itself
+                gettokens(&ntr, 1);
+                unsetsource();
+                if (ntr.bp->type == UNCLASS)
+                    error(WARNING, "Bad token %r produced by ##", &ntr);
+                while ((ntr.lp-1)->len == 0 && ntr.lp != ntr.bp)
+                    ntr.lp--;
+
+                doconcat(&ntr);
+                trp->tp = ltp;
+                makespace(&ntr, ltp);
+                insertrow(trp, (int)(ntp - ltp), &ntr);
+                dofree(ntr.bp);
+                trp->tp--;
+            }
+    }
+}
+
+/*
+ * tp is a potential parameter name of macro mac;
+ * look it up in mac's arglist, and if found, return the
+ * corresponding index in the argname array.  Return -1 if not found.
+ */
+int
+    lookuparg(Nlist * mac, Token const * tp)
+{
+    Token *ap;
+
+    if (tp->type != NAME || mac->ap == NULL)
+        return -1;
+    for (ap = mac->ap->bp; ap < mac->ap->lp; ap++)
+    {
+        if (ap->len == tp->len && strncmp((char *) ap->t, (char *) tp->t, ap->len) == 0)
+            return (int)(ap - mac->ap->bp);
+    }
+    return -1;
+}
+
+/*
+ * Return a quoted version of the tokenrow (from # arg)
+ */
+#define STRLEN  512
+Tokenrow *
+    stringify(Tokenrow * vp)
+{
+    static Token t = {STRING, 0, 0, NULL, 0};
+    static Tokenrow tr = {&t, &t, &t + 1, 1};
+    Token *tp;
+    uchar s[STRLEN];
+    uchar *sp = s, *cp;
+    int i, instring;
+
+    *sp++ = '"';
+    for (tp = vp->bp; tp < vp->lp; tp++)
+    {
+        instring = tp->type == STRING || tp->type == CCON;
+        if (sp + 2 * tp->len + tp->wslen  >= &s[STRLEN - 10])
+        {
+            error(ERROR, "Stringified macro arg is too long");
+            break;
+        }
+
+        // Change by np 31.10.2001, #93725 - begin
+        if ( tp->wslen > 0 )
+            *sp++ = ' ';
+        // change end.
+
+        for (i = 0, cp = tp->t; (unsigned int)i < tp->len; i++)
+        {
+            if (instring && (*cp == '"' || *cp == '\\'))
+                *sp++ = '\\';
+            *sp++ = *cp++;
+        }
+    }
+    *sp++ = '"';
+    *sp = '\0';
+    sp = s;
+    t.len = strlen((char *) sp);
+    t.t = newstring(sp, t.len, 0);
+    return &tr;
+}
+
+/*
+ * expand a builtin name
+ */
+void
+    builtin(Tokenrow * trp, int biname)
+{
+    char *op;
+    Token *tp;
+    Source *s;
+
+    tp = trp->tp;
+    trp->tp++;
+    /* need to find the real source */
+    s = cursource;
+    while (s && s->fd == -1)
+        s = s->next;
+    if (s == NULL)
+        s = cursource;
+    /* most are strings */
+    tp->type = STRING;
+    if (tp->wslen)
+    {
+        *outptr++ = ' ';
+        tp->wslen = 1;
+    }
+    op = outptr;
+    *op++ = '"';
+    switch (biname)
+    {
+
+        case KLINENO:
+            tp->type = NUMBER;
+            op = outnum(op - 1, s->line);
+            break;
+
+        case KFILE:
+            {
+                char *src = s->filename;
+
+                while ((*op++ = *src++) != 0)
+                    if (src[-1] == '\\')
+                        *op++ = '\\';
+                op--;
+                break;
+            }
+
+        case KDATE:
+            strncpy(op, curtime + 4, 7);
+            strncpy(op + 7, curtime + 20, 4);
+            op += 11;
+            break;
+
+        case KTIME:
+            strncpy(op, curtime + 11, 8);
+            op += 8;
+            break;
+
+        default:
+            error(ERROR, "cpp botch: unknown internal macro");
+            return;
+    }
+    if (tp->type == STRING)
+        *op++ = '"';
+    tp->t = (uchar *) outptr;
+    tp->len = op - outptr;
+    outptr = op;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */