/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * awk -- functions
 *
 * Copyright (c) 1995, 1996 by Sun Microsystems, Inc.
 * All rights reserved.
 *
 * Copyright 1986, 1994 by Mortice Kern Systems Inc.  All rights reserved.
 *
 * Based on MKS awk(1) ported to be /usr/xpg4/bin/awk with POSIX/XCU4 changes
 */

#include "awk.h"
#include "y.tab.h"
#include <time.h>
#include <sys/wait.h>

static uint     nargs(NODE *np);
static NODE     *dosub(NODE *np, int glob);
static NODE     *docasetr(NODE *np, int upper);
static int      asortcmp(const void *npp1, const void *npp2);

static char     nargerr[] = "wrong number of arguments to function \"%s\"";
static NODE     *asortfunc;             /* Function call for asort() */
static NODE     *asnp1, *asnp2;         /* index1, index2 nodes */
static int      asarraylen;             /* strlen(array)+1 for asort */

/*
 * Return the value of exp(x).
 * Usage:       y = exp(x)
 *              y = exp()
 */
NODE *
f_exp(NODE *np)
{
        register uint na;

        if ((na = nargs(np)) > 1)
                awkerr(nargerr, s_exp);
        return (realnode(exp(exprreal(na==0 ? field0 : getlist(&np)))));
}

/*
 * Return the integer part of the argument.
 * Usage:       i = int(r)
 *              i = int()
 */
NODE *
f_int(NODE *np)
{
        register uint na;

        if ((na = nargs(np)) > 1)
                awkerr(nargerr, s_int);
        return (intnode(exprint(na==0 ? field0 : getlist(&np))));
}

/*
 * Logarithm function.
 * Usage:       y = log(x)
 *              y = log()
 */
NODE *
f_log(NODE *np)
{
        register uint na;

        if ((na = nargs(np)) > 1)
                awkerr(nargerr, s_log);
        return (realnode(log(exprreal(na==0 ? field0 : getlist(&np)))));
}

/*
 * Square root function.
 * Usage:       y = sqrt(x)
 *              y = sqrt()
 */
NODE *
f_sqrt(NODE *np)
{
        register uint na;

        if ((na = nargs(np)) > 1)
                awkerr(nargerr, s_sqrt);
        return (realnode(sqrt(exprreal(na==0 ? field0 : getlist(&np)))));
}

/*
 * Trigonometric sine function.
 * Usage:       y = sin(x)
 */
NODE *
f_sin(NODE *np)
{
        if (nargs(np) != 1)
                awkerr(nargerr, s_sin);
        return (realnode(sin(exprreal(getlist(&np)))));
}

/*
 * Trigonometric cosine function.
 * Usage:       y = cos(x)
 */
NODE *
f_cos(NODE *np)
{
        if (nargs(np) != 1)
                awkerr(nargerr, s_cos);
        return (realnode(cos(exprreal(getlist(&np)))));
}

/*
 * Arctangent of y/x.
 * Usage:       z = atan2(y, x)
 */
NODE *
f_atan2(NODE *np)
{
        double y, x;

        if (nargs(np) != 2)
                awkerr(nargerr, s_atan2);
        y = (double)exprreal(getlist(&np));
        x = (double)exprreal(getlist(&np));
        return (realnode(atan2(y, x)));
}

/*
 * Set the seed for the random number generator function -- rand.
 * Usage:       srand(x)
 *              srand()
 */
NODE *
f_srand(NODE *np)
{
        register uint na;
        register uint seed;
        static uint oldseed = 0;

        if ((na = nargs(np)) > 1)
                awkerr(nargerr, s_srand);
        if (na == 0)
                seed = (uint)time((time_t *)0); else
                seed = (uint)exprint(getlist(&np));
        srand(seed);
        na = oldseed;
        oldseed = seed;
        return (intnode((INT)na));
}

/*
 * Generate a random number.
 * Usage:       x = rand()
 */
NODE *
f_rand(NODE *np)
{
        double result;
        int expon;
        ushort rint;

        if (nargs(np) != 0)
                awkerr(nargerr, s_rand);
        rint = rand() & SHRT_MAX;
        result = frexp((double)rint, &expon);
        return (realnode((REAL)ldexp(result, expon-15)));
}

/*
 * Substitute function.
 * Usage:       n = sub(regex, replace, target)
 *              n = sub(regex, replace)
 */
NODE *
f_sub(NODE *np)
{
        return (dosub(np, 1));
}

/*
 * Global substitution function.
 * Usage:       n = gsub(regex, replace, target)
 *              n = gsub(regex, replace)
 */
NODE *
f_gsub(NODE *np)
{
        return (dosub(np, 0));
}

/*
 * Do actual substitutions.
 * `glob' is the number to substitute, 0 for all.
 */
static NODE *
dosub(NODE *np, int glob)
{
        wchar_t *text;
        register wchar_t *sub;
        register uint n;
        register uint na;
        register REGEXP rp;
        NODE *left;
        static wchar_t *buf;

        if ((na = nargs(np)) != 2 && na != 3)
                awkerr(nargerr, glob==0 ? s_gsub : s_sub);
        rp = getregexp(getlist(&np));
        sub = exprstring(getlist(&np));
        if (na == 3) {
                left = getlist(&np);
                text = exprstring(left);
        } else {
                left = field0;
                text = linebuf;
        }
        switch (REGWDOSUBA(rp, sub, text, &buf, 256, &glob)) {
        case REG_OK:
        case REG_NOMATCH:
                n = glob;
                break;
        case REG_ESPACE:
                if (buf != NULL)
                        free(buf);
                awkerr(nomem);
        default:
                awkerr(gettext("regular expression error"));
        }
        (void)assign(left, stringnode(buf, FNOALLOC, wcslen(buf)));
        return (intnode((INT)n));
}

/*
 * Match function.  Return position (origin 1) or 0 for regular
 * expression match in string.  Set new variables RSTART and RLENGTH
 * as well.
 * Usage:       pos = match(string, re)
 */
NODE *
f_match(NODE *np)
{
        register wchar_t *text;
        register REGEXP rp;
        register int pos, length;
        REGWMATCH_T match[10];

        if (nargs(np) != 2)
                awkerr(nargerr, s_match);
        text = exprstring(getlist(&np));
        rp = getregexp(getlist(&np));
        if (REGWEXEC(rp, text, 10, match, 0) == REG_OK) {
                pos = match[0].rm_sp-text+1;
                length = match[0].rm_ep - match[0].rm_sp;
        } else {
                pos = 0;
                length = -1;
        }
        constant->n_int = length;
        (void)assign(vlook(M_MB_L("RLENGTH")), constant);
        return (assign(vlook(M_MB_L("RSTART")), intnode((INT)pos)));
}

/*
 * Call shell or command interpreter.
 * Usage:       status = system(command)
 */
NODE *
f_system(NODE *np)
{
        int retcode;

        if (nargs(np) != 1)
                awkerr(nargerr, s_system);
        (void) fflush(stdout);
        retcode = system(mbunconvert(exprstring(getlist(&np))));
        return (intnode((INT)WEXITSTATUS(retcode)));
}

/*
 * Search for string within string.
 * Usage:       pos = index(string1, string2)
 */
NODE *
f_index(NODE *np)
{
        register wchar_t *s1, *s2;
        register int l1, l2;
        register int result;

        if (nargs(np) != 2)
                awkerr(nargerr, s_index);
        s1 = (wchar_t *)exprstring(getlist(&np));
        s2 = (wchar_t *)exprstring(getlist(&np));
        l1 = wcslen(s1);
        l2 = wcslen(s2);
        result = 1;
        while (l2 <= l1) {
                if (memcmp(s1, s2, l2 * sizeof(wchar_t)) == 0)
                        break;
                result++;
                s1++;
                l1--;
        }
        if (l2 > l1)
                result = 0;
        return (intnode((INT)result));
}

/*
 * Return length of argument or $0
 * Usage:       n = length(string)
 *              n = length()
 *              n = length
 */
NODE *
f_length(NODE *np)
{
        register uint na;

        if ((na = nargs(np)) > 1)
                awkerr(nargerr, s_length);
        if (na == 0)
                na = lbuflen; else
                na = wcslen((wchar_t *)exprstring(getlist(&np)));
        return (intnode((INT)na));
}

/*
 * Split string into fields.
 * Usage: nfields = split(string, array [, separator]);
 */
NODE *
f_split(NODE *np)
{
        register wchar_t *cp;
        wchar_t *ep, *saved = 0;
        register NODE *tnp, *snp, *otnp;
        register NODE *sep;
        REGEXP old_resep = 0;
        size_t seplen;
        uint n;
        wint_t c;
        wchar_t savesep[20];
        wchar_t  *(*old_awkfield)(wchar_t **) = 0;

        if ((n = nargs(np))<2 || n>3)
                awkerr(nargerr, s_split);
        ep = exprstring(snp = getlist(&np));
        tnp = getlist(&np);
        if (snp->n_type == INDEX && snp->n_left == tnp)
                ep = saved = wsdup(ep);
        if (n == 3) {
                sep = getlist(&np);
        } else
                sep = NNULL;
        switch (tnp->n_type) {
        case ARRAY:
                delarray(tnp);
                break;

        case PARM:
                break;

        case VAR:
                if (isstring(tnp->n_flags) && tnp->n_string==_null)
                        break;
                /* FALLTHROUGH */

        default:
                awkerr(gettext(
                        "second parameter to \"split\" must be an array"));
        }
        /*
         * If an argument has been passed in to be used as the
         * field separator check to see if it is a constant regular
         * expression. If so, use it directly otherwise reduce the
         * expression, convert the result into a string and assign it
         * to "FS" (after saving the old value for FS.)
         */
        if (sep != NNULL) {
                if (sep->n_type == PARM)
                        sep = sep->n_next;
                if (sep->n_type == RE) {
                        old_resep = resep;
                        resep = sep->n_regexp;
                        old_awkfield = awkfield;
                        awkfield = refield;
                } else {
                        sep = exprreduce(sep);
                        seplen = wcslen(cp = (wchar_t *)exprstring(varFS));
                        (void) memcpy(savesep, cp,
                                (seplen+1) * sizeof(wchar_t));
                        (void) assign(varFS, sep);
                }
        }
        /*
         * Iterate over the record, extracting each field and assigning it to
         * the corresponding element in the array.
         */
        otnp = tnp;     /* save tnp for possible promotion */
        tnp = node(INDEX, tnp, constant);
        fcount = 0;
        for (;;) {
                if ((cp = (*awkfield)(&ep)) == NULL) {
                        if (fcount == 0) {
                                if (otnp->n_type == PARM)
                                        otnp = otnp->n_next;
                                promote(otnp);
                        }
                        break;
                }
                c = *ep;
                *ep = '\0';
                constant->n_int = ++fcount;
                (void)assign(tnp, stringnode(cp,FALLOC|FSENSE,(size_t)(ep-cp)));
                *ep = c;
        }
        /*
         * Restore the old record separator/and or regular expression.
         */
        if (sep != NNULL) {
                if (old_awkfield != 0) {
                        resep = old_resep;
                        awkfield = old_awkfield;
                } else {
                        (void)assign(varFS,
                                stringnode(savesep, FSTATIC, seplen));
                }
        }
        if (saved)
                free(saved);
        return (intnode((INT)fcount));
}

/*
 * Sprintf function.
 * Usage:       string = sprintf(format, arg, ...)
 */
NODE *
f_sprintf(NODE *np)
{
        wchar_t *cp;
        size_t length;

        if (nargs(np) == 0)
                awkerr(nargerr, s_sprintf);
        length = xprintf(np, (FILE *)NULL, &cp);
        np = stringnode(cp, FNOALLOC, length);
        return (np);
}

/*
 * Substring.
 * newstring = substr(string, start, [length])
 */
NODE *
f_substr(NODE *np)
{
        register STRING str;
        register size_t n;
        register int start;
        register size_t len;

        if ((n = nargs(np))<2 || n>3)
                awkerr(nargerr, s_substr);
        str = exprstring(getlist(&np));
        if ((start = (int)exprint(getlist(&np))-1) < 0)
                start = 0;
        if (n == 3) {
                int x;
                x = (int)exprint(getlist(&np));
                if (x < 0)
                        len = 0;
                else
                        len = (size_t)x;
        } else
                len = LARGE;
        n = wcslen((wchar_t *)str);
        if (start > n)
                start = n;
        n -= start;
        if (len > n)
                len = n;
        str += start;
        n = str[len];
        str[len] = '\0';
        np = stringnode(str, FALLOC, len);
        str[len] = n;
        return (np);
}

/*
 * Close an output or input file stream.
 */
NODE *
f_close(NODE *np)
{
        register OFILE *op;
        register char *name;

        if (nargs(np) != 1)
                awkerr(nargerr, s_close);
        name = mbunconvert(exprstring(getlist(&np)));
        for (op = &ofiles[0]; op < &ofiles[NIOSTREAM]; op++)
                if (op->f_fp!=FNULL && strcmp(name, op->f_name)==0) {
                        awkclose(op);
                        break;
                }
        if (op >= &ofiles[NIOSTREAM])
                return (const1);
        return (const0);
}

/*
 * Return the integer value of the first character of a string.
 * Usage:       char = ord(string)
 */
NODE *
f_ord(NODE *np)
{
        if (nargs(np) != 1)
                awkerr(nargerr, s_ord);
        return (intnode((INT)*exprstring(getlist(&np))));
}

/*
 * Return the argument string in lower case:
 * Usage:
 *      lower = tolower(upper)
 */
NODE *
f_tolower(NODE *np)
{
        return (docasetr(np, 0));
}

/*
 * Return the argument string in upper case:
 * Usage:
 *      upper = toupper(lower)
 */
NODE *
f_toupper(NODE *np)
{
        return (docasetr(np, 1));
}

/*
 * Sort the array into traversal order by the next "for (i in array)" loop.
 * Usage:
 *      asort(array, "cmpfunc")
 *      cmpfunc(array, index1, index2)
 *              returns:
 *              <0              if      array[index1] <  array[index2]
 *               0              if      array[index1] == array[index2]
 *              >0              if      array[index1] >  array[index2]
 */
NODE *
f_asort(NODE *np)
{
        NODE *array;
        STRING funcname;
        register size_t nel;
        register NODE *tnp;
        register NODE *funcnp;
        register NODE **alist, **npp;

        if (nargs(np) != 2)
                awkerr(nargerr, s_asort);
        array = getlist(&np);
        if (array->n_type == PARM)
                array = array->n_next;
        if (array->n_type != ARRAY)
                awkerr(gettext("%s function requires an array"),
                        s_asort);
        funcname = exprstring(getlist(&np));
        if ((funcnp = vlookup(funcname, 1)) == NNULL
         || funcnp->n_type != UFUNC)
                awkerr(gettext("%s: %s is not a function\n"),
                    s_asort, funcname);
        /*
         * Count size of array, allowing one extra for NULL at end
         */
        nel = 1;
        for (tnp = array->n_alink; tnp != NNULL; tnp = tnp->n_alink)
                ++nel;
        /*
         * Create UFUNC node that points at the funcnp on left and the
         * list of three variables on right (array, index1, index2)
         *                              UFUNC
         *                              /    \
         *                         funcnp    COMMA
         *                                    /   \
         *                              array     COMMA
         *                                        /    \
         *                                      index1 index2
         */
        if (asortfunc == NNULL) {
                running = 0;
                asortfunc = node(CALLUFUNC, NNULL,
                                    node(COMMA, NNULL,
                                    node(COMMA,
                                        asnp1=stringnode(_null, FSTATIC, 0),
                                        asnp2=stringnode(_null, FSTATIC, 0))));
                running = 1;
        }
        asortfunc->n_left = funcnp;
        asortfunc->n_right->n_left = array;
        asarraylen = wcslen(array->n_name)+1;
        alist = (NODE **) emalloc(nel*sizeof(NODE *));
        /*
         * Copy array into alist.
         */
        npp = alist;
        for (tnp = array->n_alink; tnp != NNULL; tnp = tnp->n_alink)
                *npp++ = tnp;
        *npp = NNULL;
        /*
         * Re-order array to this list
         */
        qsort((wchar_t *)alist, nel-1, sizeof (NODE *), asortcmp);
        tnp = array;
        npp = alist;
        do {
                tnp = tnp->n_alink = *npp;
        } while (*npp++ != NNULL);
        free((wchar_t *)alist);
        return (constundef);
}

/*
 * Return the number of arguments of a function.
 */
static uint
nargs(NODE *np)
{
        register int n;

        if (np == NNULL)
                return (0);
        n = 1;
        while (np!=NNULL && np->n_type==COMMA) {
                np = np->n_right;
                n++;
        }
        return (n);
}

/*
 * Do case translation.
 */
static NODE *
docasetr(NODE *np, int upper)
{
        register int c;
        register wchar_t *cp;
        register wchar_t *str;
        register uint na;

        if ((na = nargs(np)) > 1)
                awkerr(nargerr, upper ? s_toupper : s_tolower);
        str = strsave(na==0 ? linebuf : exprstring(getlist(&np)));
        cp = str;
        if (upper) {
                while ((c = *cp++) != '\0')
                        cp[-1] = towupper(c);
        } else {
                while ((c = *cp++) != '\0')
                        cp[-1] = towlower(c);
        }
        return (stringnode((STRING)str, FNOALLOC, (size_t)(cp-str-1)));
}

/*
 * The comparison routine used by qsort inside f_asort()
 */
static int
asortcmp(const void *npp1, const void *npp2)
{
        asnp1->n_strlen =
            wcslen(asnp1->n_string = (*(NODE **)npp1)->n_name+asarraylen);
        asnp2->n_strlen =
            wcslen(asnp2->n_string = (*(NODE **)npp2)->n_name+asarraylen);
        return ((int)exprint(asortfunc));
}

#if M_MATHERR
#if !defined(__BORLANDC__)&&defined(__TURBOC__)&&__COMPACT__&&__EMULATE__
/* So it won't optimize registers our FP is using */
#define flushesbx()     (_BX = 0, _ES = _BX)
#else
#define flushesbx()     (0)
#endif

/*
 * Math error for awk.
 */
int
matherr(struct exception *ep)
{
        register uint type;
        static char msgs[7][256];
        static int first_time = 1;

        if (first_time) {
                msgs[0] = gettext("Unknown FP error"),
                msgs[1] = gettext("Domain"),
                msgs[2] = gettext("Singularity"),
                msgs[3] = gettext("Overflow"),
                msgs[4] = gettext("Underflow"),
                msgs[5] = gettext("Total loss of precision"),
                msgs[6] = gettext("Partial loss of precision")
                first_time = 0;
        }

        if ((type = ep->type) > (uint)PLOSS)
                type = 0;
        (void)fprintf(stderr, "awk: %s", strmsg(msgs[type]));
        (void)fprintf(stderr, gettext(
                " error in function %s(%g) at NR=%lld\n"),
                ((void) flushesbx(), ep->name), ep->arg1, (INT)exprint(varNR));
        return (1);
}
#endif  /*M_MATHERR*/