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

#ifdef _MSC_VER
#	define _POSIX_
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifdef __hpux
#	define _HPUX_SOURCE
#endif
#if defined(__IBMC__) || defined(__EMX__)
#   define PATH_MAX _MAX_PATH
#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)
    {
        /* macro with args */
        int narg = 0;

        tp += 1;
        args = new(Tokenrow);
        maketokenrow(2, args);
        if (tp->type != RP)
        {
            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);
        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, 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
			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)
{
//	Token * pOldNextTp;
	Tokenrow ntr;
	int ntokc, narg, i;
	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
	{
		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 dont 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]);
		}
	}

/* old
	np->flag |= ISACTIVE;
*/

/* rh
*/
	doconcat(&ntr);                     /* execute ## operators */
	ntr.tp = ntr.bp;
	makespace(&ntr, trp->tp);

/* old
//	expandrow(&ntr, "<expand>");
//	insertrow(trp, ntokc, &ntr);
//	dofree(ntr.bp);
//	np->flag &= ~ISACTIVE;
*/

/* NP
		// Replace macro by its value:
*/
//	pOldNextTp = trp->tp+ntokc;
	tokenrow_zeroTokenIdentifiers(&ntr);
	insertrow(trp, ntokc, &ntr);
		/* Reassign old macro validators:
		*/
//	mvl_move(pValidators, trp->tp - pOldNextTp);

		/* 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,0);
	}
		/* 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)
		{
			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)
			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 + (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;
    int 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 concatination 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	// Leerzeichen um ## herum entfernen:
					{
						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);
                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, 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 * 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 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, 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;
}