/*****************************************************************************
 *
 * builtin.c
 *
 *  Builtin macros.
 *
 *****************************************************************************/

#include "m4.h"

extern TOK tokColonTab;
extern TOK tokEol;

/*****************************************************************************
 *
 *  opIfdef
 *
 *      If $1 is defined, then return $2, else $3.
 *
 *      If $# < 2, then there's no point in returning anything at all.
 *
 *      The extra ptokNil covers us in the case where $# is 2.
 *
 *      QUIRK!  GNU m4 emits a warning if $# < 2.  AT&T remains silent.
 *      I side with AT&T on this one.
 *
 *      QUIRK!  GNU m4 emits `$0' if $# = 0.  AT&T silently ignores
 *      the entire macro call.  I side with GNU on this one.
 *
 *****************************************************************************/

DeclareOp(opIfdef)
{
    if (ctokArgv >= 2) {
        if (pmacFindPtok(ptokArgv(1))) {
            PushPtok(ptokArgv(2));
        } else {
            PushPtok(ptokArgv(3));
        }
    } else if (ctokArgv == 0) {
        PushQuotedPtok(ptokArgv(0));
    } else {
#ifdef STRICT_M4
        Warn("wrong number of arguments to %P", ptokArgv(0));
#endif
    }
}

/*****************************************************************************
 *
 *  opIfelse
 *
 *      If $1 and $2 are identical, then return $3.
 *      If there are only four arguments, then return $4.
 *      Else, shift three and restart.
 *
 *      If there are fewer than three arguments, then return nothing.
 *
 *      The extra ptokNil saves us in the cases where $# = 2 + 3n.
 *
 *      QUIRK!  GNU m4 emits a warning if $# = 2 + 3n.  AT&T remains silent.
 *      I side with AT&T on this one.
 *
 *****************************************************************************/

DeclareOp(opIfelse)
{
    if (ctokArgv >= 3) {                /* Need at least three for starters */
        ITOK itok = 1;
        do {
            if (fEqPtokPtok(ptokArgv(itok), ptokArgv(itok+1))) {
                PushPtok(ptokArgv(itok+2)); /* ptokNil saves us here */
                return;
            }
            itok += 3;
        } while (itok <= ctokArgv - 1); /* While at least two args left */
        if (itok == ctokArgv) {         /* If only one left... */
            PushPtok(ptokArgv(itok));
        } else {
            Assert(itok == ctokArgv + 1); /* Else must be zero left */
        }
        return;
    }
}

/*****************************************************************************
 *
 *  opShift
 *
 *      Return all but the first argument, quoted and pushed back with
 *      commas in between.  We push them in reverse order so that they
 *      show up properly.
 *
 *****************************************************************************/

DeclareOpc(opcShift)
{
    if (itok > 1) {
        PushQuotedPtok(ptok);
        if (itok > 2) {
            PushTch(tchComma);
        }
    }
}

DeclareOp(opShift)
{
    EachReverseOpcArgvDw(opcShift, argv, 0);
}

/*****************************************************************************
 *
 *  opLen
 *
 *  Returns the length of its argument.
 *  The extra ptokNil covers us in the case where $# is zero.
 *
 *  QUIRK!  AT&T m4 silently ignores the case where $# is zero, but
 *  GNU m4 will emit `$0' so as to reduce potential conflict with an
 *  identically-spelled language keyword.  I side with GNU on this one.
 *
 *  SOMEDAY! -- this quirk should be an op attribute.
 *
 *
 *****************************************************************************/

DeclareOp(opLen)
{
    if (ctokArgv) {
#ifdef STRICT_M4
        if (ctokArgv != 1) {
            Warn("wrong number of arguments to %P", ptokArgv(0));
        }
#endif
        PushAt(ctchArgv(1));
    } else {
        PushQuotedPtok(ptokArgv(0));
    }
}

/*****************************************************************************
 *
 *  opTraceon
 *
 *  With no arguments, turns on global tracing.
 *  Otherwise, turns on local tracing on the specified macros.
 *
 *  opTraceoff
 *
 *  Turns off global tracing, and also turns off local tracing on the
 *  specified macros (if any).
 *
 *****************************************************************************/

DeclareOpc(opcTraceonoff)
{
    PMAC pmac = pmacFindPtok(ptok);
    if (pmac) {
        pmac->pval->fTrace = dw;
    }
}

DeclareOp(opTraceon)
{
    if (ctokArgv == 0) {
        g_fTrace = 1;
    } else {
        EachOpcArgvDw(opcTraceonoff, argv, 1);
    }
}

DeclareOp(opTraceoff)
{
    g_fTrace = 0;
    EachOpcArgvDw(opcTraceonoff, argv, 0);
}


/*****************************************************************************
 *
 *  opDnl
 *
 *  Gobbles all characters up to and including the next newline.
 *
 *  If EOF is reached, push the EOF back and stop.
 *
 *  QUIRK!  AT&T m4 silently ignores the case where $# > 0.  GNU m4
 *  issues a warning.  I side with AT&T on this one.
 *
 *****************************************************************************/

DeclareOp(opDnl)
{
    TCH tch;
#ifdef STRICT_M4
    if (ctokArgv != 0) {
        Warn("wrong number of arguments to %P", ptokArgv(0));
    }
#endif
    while ((tch = tchGet()) != '\n') {
        if (tch == tchMagic) {
            TCH tch = tchGet();
            if (tch == tchEof) {
                PushPtok(&tokEof);      /* Eek!  Does this actually work? */
                break;
            }
        }
    }
}

/*****************************************************************************
 *
 *  opChangequote - not implemented
 *  opChangecom - not implemented
 *  opUndivert - not implemented
 *  opSyscmd - not implemented
 *  opSysval - not implemented
 *  opMaketemp - not implemented
 *  opM4exit - not implemented
 *  opM4wrap - not implemented
 *
 *****************************************************************************/

/*****************************************************************************
 *
 *  opDivert
 *
 *  We currently support only two diversions:
 *
 *   0      = stdout
 *   1-9    = unsupported
 *  <anything else> = /dev/null
 *
 *  This is just barely enough to get DirectX building.
 *
 *****************************************************************************/

DeclareOp(opDivert)
{
#ifdef STRICT_M4
    if (ctokArgv != 1) {
        Warn("wrong number of arguments to divert");
    }
#endif

    if (ctokArgv > 0) {
        PTOK ptok = ptokArgv(1);
        if (ptok->ctch == 1 && ptok->u.ptch[0] == TEXT('0')) {
            g_pdivCur = g_pdivOut;
        } else {
            g_pdivCur = g_pdivNul;
        }
    }
}

/*****************************************************************************
 *
 *  opDivnum
 *
 *  We currently support only two diversions:
 *
 *   0      = stdout
 *   1-9    = unsupported
 *  <anything else> = /dev/null
 *
 *  This is just barely enough to get DirectX building.
 *
 *****************************************************************************/

DeclareOp(opDivnum)
{
#ifdef STRICT_M4
    if (ctokArgv != 0) {
        Warn("wrong number of arguments to %P", ptokArgv(0));
    }
#endif
    PushAt(g_pdivCur == g_pdivOut ? 0 : -1);
}

/*****************************************************************************
 *
 *  opErrprint
 *
 *  Prints its argument on the dianostic output file.
 *  The extra ptokNil covers us in the case where $# is zero.
 *
 *  QUIRK!  AT&T m4 silently ignores excess arguments.  GNU m4 emits
 *  all arguments, separated by spaces.  I side with AT&T on this one.
 *
 *****************************************************************************/

DeclareOp(opErrprint)
{
#ifdef STRICT_M4
    if (ctokArgv != 1) {
        Warn("wrong number of arguments to errprint");
    }
#endif
    AddPdivPtok(g_pdivErr, ptokArgv(1));
    FlushPdiv(g_pdivErr);
}

/*****************************************************************************
 *
 *  opDumpdef
 *
 *  With no arguments, dumps all definitions.
 *  Otherwise, dumps only the specified macros.
 *
 *  QUIRK!  When given multiple arguments, AT&T m4 dumps the macros in
 *  the order listed.  GNU m4 dumps them in reverse order.  (!)
 *  I side with AT&T on this one.
 *
 *****************************************************************************/

void STDCALL
DumpdefPmac(PMAC pmac)
{
    PTCH ptch, ptchMax;

    AddPdivPtok(g_pdivErr, &pmac->tokName);
    AddPdivPtok(g_pdivErr, &tokColonTab);

    ptch = ptchPtok(&pmac->pval->tok);
    ptchMax = ptchMaxPtok(&pmac->pval->tok);
    for ( ; ptch < ptchMax; ptch++) {
        AddPdivTch(g_pdivErr, *ptch);   /* SOMEDAY -- internals! - do they show up okay? */
    }
    AddPdivPtok(g_pdivErr, &tokEol);
}

DeclareOpc(opcDumpdef)
{
    PMAC pmac = pmacFindPtok(ptok);
    if (pmac) {
        DumpdefPmac(pmac);
    }
}

DeclareOp(opDumpdef)
{
    if (ctokArgv == 0) {
        EachMacroOp(DumpdefPmac);
    } else {
        EachOpcArgvDw(opcDumpdef, argv, 0);
    }
    FlushPdiv(g_pdivErr);
}

/*****************************************************************************
 *
 *  opInclude
 *  opSinclude
 *
 *  Pushes the contents of the file named in the argument.
 *  Sinclude says nothing if the file is inaccessible.
 *
 *  QUIRK!  AT&T m4 silently ignores the case where $1 is null, but
 *  GNU m4 issues an error (no such file or directory).  I side with
 *  GNU on this one.
 *
 *  QUIRK!  AT&T m4 silently ignores the case where $# is zero, but
 *  GNU m4 will emit `$0' so as to reduce potential conflict with an
 *  identically-spelled language keyword.  I side with GNU on this one.
 *
 *  QUIRK!  AT&T m4 silently ignores arguments $2 onward.  GNU emits
 *  a warning but continues.  I side with AT&T on this one.
 *
 *****************************************************************************/

void STDCALL
opIncludeF(ARGV argv, BOOL fFatal)
{
    if (ctokArgv) {
        PTCH ptch = ptchDupPtok(ptokArgv(1));
        if (ptch) {
            if (hfInputPtchF(ptch, fFatal) == hfNil) {
                FreePv(ptch);
            }
#ifdef STRICT_M4
            if (ctokArgv != 1) {
                Warn("excess arguments to built-in %P ignored", ptokArgv(0));
            }
#endif
        }
    } else {
        PushQuotedPtok(ptokArgv(0));
    }
}

DeclareOp(opInclude)
{
    opIncludeF(argv, 1);
}

DeclareOp(opSinclude)
{
    opIncludeF(argv, 0);
}