/*
 * Copyright (C) Lucent Technologies 1997
 * All Rights Reserved
 *
 * Permission to use, copy, modify, and distribute this software and
 * its documentation for any purpose and without fee is hereby
 * granted, provided that the above copyright notice appear in all
 * copies and that both that the copyright notice and this
 * permission notice and warranty disclaimer appear in supporting
 * documentation, and that the name Lucent Technologies or any of
 * its entities not be used in advertising or publicity pertaining
 * to distribution of the software without specific, written prior
 * permission.
 *
 * LUCENT DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
 * IN NO EVENT SHALL LUCENT OR ANY OF ITS ENTITIES BE LIABLE FOR ANY
 * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
 * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
 * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
 * THIS SOFTWARE.
 */

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (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
 */

/*
 * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*      Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
/*        All Rights Reserved   */

/*      Copyright (c) Lucent Technologies 1997  */
/*        All Rights Reserved   */

#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>
#include <stdlib.h>
#include <stdarg.h>
#include "awk.h"
#include "y.tab.h"

static FILE     *infile = NULL;
static char     *file   = "";
char    *record;
size_t  recsize = RECSIZE;
static char     *fields;
static size_t   fieldssize = RECSIZE;
static char     *rtbuf;
static size_t   rtbufsize = RECSIZE;

Cell    **fldtab;       /* pointers to Cells */
char    inputFS[100] = " ";

#define MAXFLD  2
int     nfields = MAXFLD;       /* last allocated slot for $i */

int     donefld;        /* 1 = implies rec broken into fields */
int     donerec;        /* 1 = record is valid (no flds have changed) */

static int      lastfld = 0;    /* last used field */
static int      argno   = 1;    /* current input argument number */

static Cell dollar0 = { OCELL, CFLD, NULL, "", 0.0, REC|STR|DONTFREE };
static Cell dollar1 = { OCELL, CFLD, NULL, "", 0.0, FLD|STR|DONTFREE };

static  char    *getargv(int);
static  void    cleanfld(int, int);
static  int     refldbld(const char *, const char *);
static  void    bcheck2(int, int, int);
static  void    eprint(void);
static  void    bclass(int);

void
recinit(unsigned int n)
{
        if ((record = (char *)malloc(n)) == NULL ||
            (fields = (char *)malloc(n+2)) == NULL ||
            (fldtab = (Cell **)malloc((nfields+1) * sizeof (Cell *))) == NULL ||
            (fldtab[0] = (Cell *)malloc(sizeof (Cell))) == NULL)
                FATAL("out of space for $0 and fields");
        *fldtab[0] = dollar0;
        fldtab[0]->sval = record;
        fldtab[0]->nval = tostring("0");
        makefields(1, nfields);
}

void
makefields(int n1, int n2)              /* create $n1..$n2 inclusive */
{
        char temp[50];
        int i;

        for (i = n1; i <= n2; i++) {
                fldtab[i] = (Cell *)malloc(sizeof (Cell));
                if (fldtab[i] == NULL)
                        FATAL("out of space in makefields %d", i);
                *fldtab[i] = dollar1;
                (void) sprintf(temp, "%d", i);
                fldtab[i]->nval = tostring(temp);
        }
}

static void
initgetrec(void)
{
        int i;
        char *p;

        for (i = 1; i < *ARGC; i++) {
                p = getargv(i); /* find 1st real filename */
                if (p == NULL || *p == '\0') {  /* deleted or zapped */
                        argno++;
                        continue;
                }
                if (!isclvar(p)) {
                        (void) setsval(lookup("FILENAME", symtab), p);
                        return;
                }
                setclvar(p);    /* a commandline assignment before filename */
                argno++;
        }
        infile = stdin;         /* no filenames, so use stdin */
}

/*
 * POSIX specifies that fields are supposed to be evaluated as if they were
 * split using the value of FS at the time that the record's value ($0) was
 * read.
 *
 * Since field-splitting is done lazily, we save the current value of FS
 * whenever a new record is read in (implicitly or via getline), or when
 * a new value is assigned to $0.
 */
void
savefs(void)
{
        if (strlen(getsval(fsloc)) >= sizeof (inputFS))
                FATAL("field separator %.10s... is too long", *FS);
        (void) strcpy(inputFS, *FS);
}

static int firsttime = 1;

/*
 * get next input record
 * note: cares whether buf == record
 */
int
getrec(char **pbuf, size_t *pbufsize, int isrecord)
{
        int c;
        char *buf = *pbuf;
        uschar saveb0;
        size_t bufsize = *pbufsize, savebufsize = bufsize;

        if (firsttime) {
                firsttime = 0;
                initgetrec();
        }
        dprintf(("RS=<%s>, FS=<%s>, ARGC=%f, FILENAME=%s\n",
            *RS, *FS, *ARGC, *FILENAME));
        if (isrecord) {
                donefld = 0;
                donerec = 1;
                savefs();
        }
        saveb0 = buf[0];
        buf[0] = '\0';
        while (argno < *ARGC || infile == stdin) {
                dprintf(("argno=%d, file=|%s|\n", argno, file));
                if (infile == NULL) {   /* have to open a new file */
                        file = getargv(argno);
                        if (file == NULL || *file == '\0') {
                                /* deleted or zapped */
                                argno++;
                                continue;
                        }
                        if (isclvar(file)) {
                                /* a var=value arg */
                                setclvar(file);
                                argno++;
                                continue;
                        }
                        *FILENAME = file;
                        dprintf(("opening file %s\n", file));
                        if (*file == '-' && *(file+1) == '\0')
                                infile = stdin;
                        else if ((infile = fopen(file, "rF")) == NULL)
                                FATAL("can't open file %s", file);
                        (void) setfval(fnrloc, 0.0);
                }
                c = readrec(&buf, &bufsize, infile);

                if (c != 0 || buf[0] != '\0') { /* normal record */
                        if (isrecord) {
                                if (freeable(recloc))
                                        xfree(recloc->sval);
                                recloc->sval = buf;     /* buf == record */
                                recloc->tval = REC | STR | DONTFREE;
                                if (is_number(recloc->sval)) {
                                        recloc->fval =
                                            atof(recloc->sval);
                                        recloc->tval |= NUM;
                                }
                        }
                        (void) setfval(nrloc, nrloc->fval+1);
                        (void) setfval(fnrloc, fnrloc->fval+1);
                        *pbuf = buf;
                        *pbufsize = bufsize;
                        return (1);
                }
                /* EOF arrived on this file; set up next */
                if (infile != stdin)
                        (void) fclose(infile);
                infile = NULL;
                argno++;
        }
        buf[0] = saveb0;
        *pbuf = buf;
        *pbufsize = savebufsize;
        return (0);     /* true end of file */
}

void
nextfile(void)
{
        if (infile != NULL && infile != stdin)
                (void) fclose(infile);
        infile = NULL;
        argno++;
}

/*
 * read one record into buf
 */
int
readrec(char **pbuf, size_t *pbufsize, FILE *inf)
{
        int sep, c;
        char *rr, *rt, *buf = *pbuf;
        size_t bufsize = *pbufsize;
        char *rs = getsval(rsloc);

        if (rtbuf == NULL && (rtbuf = malloc(rtbufsize)) == NULL)
                FATAL("out of memory in readrec");

        rr = buf;
        rt = rtbuf;

        if ((sep = *rs) == '\0') {
                sep = '\n';
                /* skip leading \n's */
                while ((c = getc(inf)) == '\n' && c != EOF)
                        ;
                if (c != EOF)
                        (void) ungetc(c, inf);
        }
        while ((c = getc(inf)) != EOF) {
                if (c != sep) {
                        if (rr-buf+1 > bufsize) {
                                (void) adjbuf(&buf, &bufsize,
                                    1+rr-buf, recsize, &rr, "readrec1");
                        }
                        *rr++ = c;
                        continue;
                }

                /*
                 * Ensure enough space for either a single separator
                 * character, or at least two '\n' chars (when RS is
                 * the empty string).
                 */
                (void) adjbuf(&rtbuf, &rtbufsize,
                    2+rt-rtbuf, recsize, &rt, "readrec2");

                if (*rs == sep) {
                        *rt++ = sep;
                        break;
                }

                if ((c = getc(inf)) == '\n') { /* 2 in a row */
                        *rt++ = '\n';
                        *rt++ = '\n';
                        while ((c = getc(inf)) == '\n' && c != EOF) {
                                /* Read any further \n's and add them to RT. */
                                (void) adjbuf(&rtbuf, &rtbufsize,
                                    1+rt-rtbuf, recsize, &rt, "readrec3");
                                *rt++ = '\n';
                        }
                        if (c != EOF)
                                (void) ungetc(c, inf);
                        break;
                }

                if (c == EOF) {
                        *rt++ = '\n';
                        break;
                }

                (void) adjbuf(&buf, &bufsize,
                    2+rr-buf, recsize, &rr, "readrec4");
                *rr++ = '\n';
                *rr++ = c;
        }
        (void) adjbuf(&buf, &bufsize, 1+rr-buf, recsize, &rr, "readrec5");
        (void) adjbuf(&rtbuf, &rtbufsize, 1+rt-rtbuf, recsize, &rt, "readrec6");
        *rr = '\0';
        *rt = '\0';
        dprintf(("readrec saw <%s>, returns %d\n",
            buf, c == EOF && rr == buf ? 0 : 1));
        *pbuf = buf;
        *pbufsize = bufsize;
        if (c == EOF && rr == buf) {
                return (0);
        } else {
                (void) setsval(rtloc, rtbuf);
                return (1);
        }
}

/* get ARGV[n] */
static char *
getargv(int n)
{
        Cell *x;
        char *s, temp[50];
        extern Array *ARGVtab;

        (void) sprintf(temp, "%d", n);
        if (lookup(temp, ARGVtab) == NULL)
                return (NULL);
        x = setsymtab(temp, "", 0.0, STR, ARGVtab);
        s = getsval(x);
        dprintf(("getargv(%d) returns |%s|\n", n, s));
        return (s);
}

void
setclvar(char *s)       /* set var=value from s */
{
        char *p;
        Cell *q;

        for (p = s; *p != '='; p++)
                ;
        *p++ = 0;
        p = qstring(p, '\0');
        q = setsymtab(s, p, 0.0, STR, symtab);
        (void) setsval(q, p);
        if (is_number(q->sval)) {
                q->fval = atof(q->sval);
                q->tval |= NUM;
        }
        dprintf(("command line set %s to |%s|\n", s, p));
        free(p);
}

void
fldbld(void)    /* create fields from current record */
{
        /* this relies on having fields[] the same length as $0 */
        /* the fields are all stored in this one array with \0's */
        /* possibly with a final trailing \0 not associated with any field */
        char *r, *fr, sep;
        Cell *p;
        int i, j, n;

        if (donefld)
                return;
        if (!isstr(fldtab[0]))
                (void) getsval(fldtab[0]);
        r = fldtab[0]->sval;
        n = strlen(r);
        if (n > fieldssize) {
                xfree(fields);
                /* possibly 2 final \0s */
                if ((fields = (char *)malloc(n + 2)) == NULL)
                        FATAL("out of space for fields in fldbld %d", n);
                fieldssize = n;
        }
        fr = fields;

        i = 0;  /* number of fields accumulated here */
        if (strlen(inputFS) > 1) {      /* it's a regular expression */
                i = refldbld(r, inputFS);
        } else if ((sep = *inputFS) == ' ') {   /* default whitespace */
                for (i = 0; ; ) {
                        while (*r == ' ' || *r == '\t' || *r == '\n')
                                r++;
                        if (*r == '\0')
                                break;
                        i++;
                        if (i > nfields)
                                growfldtab(i);
                        if (freeable(fldtab[i]))
                                xfree(fldtab[i]->sval);
                        fldtab[i]->sval = fr;
                        fldtab[i]->tval = FLD | STR | DONTFREE;
                        do
                                *fr++ = *r++;
                        while (*r != ' ' && *r != '\t' && *r != '\n' &&
                            *r != '\0')
                                ;
                        *fr++ = '\0';
                }
                *fr = '\0';
        } else if ((sep = *inputFS) == '\0') {
                /* new: FS="" => 1 char/field */
                for (i = 0; *r != '\0'; r++) {
                        char buf[2];
                        i++;
                        if (i > nfields)
                                growfldtab(i);
                        if (freeable(fldtab[i]))
                                xfree(fldtab[i]->sval);
                        buf[0] = *r;
                        buf[1] = '\0';
                        fldtab[i]->sval = tostring(buf);
                        fldtab[i]->tval = FLD | STR;
                }
                *fr = '\0';
        } else if (*r != '\0') {        /* if 0, it's a null field */
                /*
                 * subtlecase : if length(FS) == 1 && length(RS > 0)
                 * \n is NOT a field separator (cf awk book 61,84).
                 * this variable is tested in the inner while loop.
                 */
                int rtest = '\n';  /* normal case */
                if (strlen(*RS) > 0)
                        rtest = '\0';
                for (;;) {
                        i++;
                        if (i > nfields)
                                growfldtab(i);
                        if (freeable(fldtab[i]))
                                xfree(fldtab[i]->sval);
                        fldtab[i]->sval = fr;
                        fldtab[i]->tval = FLD | STR | DONTFREE;
                        /* \n is always a separator */
                        while (*r != sep && *r != rtest && *r != '\0')
                                *fr++ = *r++;
                        *fr++ = '\0';
                        if (*r++ == '\0')
                                break;
                }
                *fr = '\0';
        }
        if (i > nfields)
                FATAL("record `%.30s...' has too many fields; can't happen", r);
        /* clean out junk from previous record */
        cleanfld(i+1, lastfld);
        lastfld = i;
        donefld = 1;
        for (j = 1; j <= lastfld; j++) {
                p = fldtab[j];
                if (is_number(p->sval)) {
                        p->fval = atof(p->sval);
                        p->tval |= NUM;
                }
        }
        (void) setfval(nfloc, (Awkfloat)lastfld);
        donerec = 1; /* restore */
        if (dbg) {
                for (j = 0; j <= lastfld; j++) {
                        p = fldtab[j];
                        (void) printf("field %d (%s): |%s|\n",
                            j, p->nval, p->sval);
                }
        }
}

/* clean out fields n1 .. n2 inclusive; nvals remain intact */
static void
cleanfld(int n1, int n2)
{
        Cell *p;
        int i;

        for (i = n1; i <= n2; i++) {
                p = fldtab[i];
                if (freeable(p))
                        xfree(p->sval);
                p->sval = "";
                p->tval = FLD | STR | DONTFREE;
        }
}

void
newfld(int n)   /* add field n after end of existing lastfld */
{
        if (n > nfields)
                growfldtab(n);
        cleanfld(lastfld+1, n);
        lastfld = n;
        (void) setfval(nfloc, (Awkfloat)n);
}

void
setlastfld(int n)       /* set lastfld cleaning fldtab cells if necessary */
{
        if (n < 0)
                FATAL("cannot set NF to a negative value");
        if (n > nfields)
                growfldtab(n);

        if (lastfld < n)
                cleanfld(lastfld+1, n);
        else
                cleanfld(n+1, lastfld);

        lastfld = n;
}

Cell *
fieldadr(int n) /* get nth field */
{
        if (n < 0)
                FATAL("trying to access out of range field %d", n);
        if (n > nfields)        /* fields after NF are empty */
                growfldtab(n);  /* but does not increase NF */
        return (fldtab[n]);
}

void
growfldtab(int n)       /* make new fields up to at least $n */
{
        int nf = 2 * nfields;
        size_t s;

        if (n > nf)
                nf = n;
        s = (nf+1) * (sizeof (Cell *));  /* freebsd: how much do we need? */
        if (s / sizeof (Cell *) - 1 == nf) /* didn't overflow */
                fldtab = (Cell **)realloc(fldtab, s);
        else                                    /* overflow sizeof int */
                xfree(fldtab);  /* make it null */
        if (fldtab == NULL)
                FATAL("out of space creating %d fields", nf);
        makefields(nfields+1, nf);
        nfields = nf;
}

/* build fields from reg expr in FS */
static int
refldbld(const char *rec, const char *fs)
{
        /* this relies on having fields[] the same length as $0 */
        /* the fields are all stored in this one array with \0's */
        char *fr;
        int i, tempstat, n;
        fa *pfa;

        n = strlen(rec);
        if (n > fieldssize) {
                xfree(fields);
                if ((fields = (char *)malloc(n+1)) == NULL)
                        FATAL("out of space for fields in refldbld %d", n);
                fieldssize = n;
        }
        fr = fields;
        *fr = '\0';
        if (*rec == '\0')
                return (0);
        pfa = makedfa(fs, 1);
        dprintf(("into refldbld, rec = <%s>, pat = <%s>\n", rec, fs));
        tempstat = pfa->initstat;
        for (i = 1; ; i++) {
                if (i > nfields)
                        growfldtab(i);
                if (freeable(fldtab[i]))
                        xfree(fldtab[i]->sval);
                fldtab[i]->tval = FLD | STR | DONTFREE;
                fldtab[i]->sval = fr;
                dprintf(("refldbld: i=%d\n", i));
                if (nematch(pfa, rec)) {
                        pfa->initstat = 2;      /* horrible coupling to b.c */
                        dprintf(("match %s (%d chars)\n", patbeg, patlen));
                        (void) strncpy(fr, rec, patbeg-rec);
                        fr += patbeg - rec + 1;
                        *(fr-1) = '\0';
                        rec = patbeg + patlen;
                } else {
                        dprintf(("no match %s\n", rec));
                        (void) strcpy(fr, rec);
                        pfa->initstat = tempstat;
                        break;
                }
        }
        return (i);
}

void
recbld(void)    /* create $0 from $1..$NF if necessary */
{
        int i;
        char *p;
        size_t cnt, len, olen;
        char *sep = getsval(ofsloc);

        if (donerec == 1)
                return;
        cnt = 0;
        olen = strlen(sep);
        for (i = 1; i <= *NF; i++) {
                p = getsval(fldtab[i]);
                len = strlen(p);
                expand_buf(&record, &recsize, cnt + len + olen);
                (void) memcpy(&record[cnt], p, len);
                cnt += len;
                if (i < *NF) {
                        (void) memcpy(&record[cnt], sep, olen);
                        cnt += olen;
                }
        }
        record[cnt] = '\0';
        dprintf(("in recbld inputFS=%s, recloc=%p\n", inputFS, (void *)recloc));
        if (freeable(recloc))
                xfree(recloc->sval);
        recloc->tval = REC | STR | DONTFREE;
        recloc->sval = record;
        dprintf(("in recbld inputFS=%s, recloc=%p\n", inputFS, (void *)recloc));
        dprintf(("recbld = |%s|\n", record));
        donerec = 1;
}

int     errorflag       = 0;

int
yyerror(const char *s)
{
        SYNTAX("%s", s);
        return (0);
}

void
SYNTAX(const char *fmt, ...)
{
        extern char *cmdname, *curfname;
        static int been_here = 0;
        va_list varg;

        if (been_here++ > 2)
                return;
        (void) fprintf(stderr, "%s: ", cmdname);
        va_start(varg, fmt);
        (void) vfprintf(stderr, fmt, varg);
        va_end(varg);
        (void) fprintf(stderr, " at source line %lld", lineno);
        if (curfname != NULL)
                (void) fprintf(stderr, " in function %s", curfname);
        if (compile_time == 1 && cursource() != NULL)
                (void) fprintf(stderr, " source file %s", cursource());
        (void) fprintf(stderr, "\n");
        errorflag = 2;
        eprint();
}

void
fpecatch(int n)
{
        FATAL("floating point exception %d", n);
}

extern int bracecnt, brackcnt, parencnt;

void
bracecheck(void)
{
        int c;
        static int beenhere = 0;

        if (beenhere++)
                return;
        while ((c = input()) != EOF && c != '\0')
                bclass(c);
        bcheck2(bracecnt, '{', '}');
        bcheck2(brackcnt, '[', ']');
        bcheck2(parencnt, '(', ')');
}

/*ARGSUSED*/
static void
bcheck2(int n, int c1, int c2)
{
        if (n == 1)
                (void) fprintf(stderr, gettext("\tmissing %c\n"), c2);
        else if (n > 1)
                (void) fprintf(stderr, gettext("\t%d missing %c's\n"), n, c2);
        else if (n == -1)
                (void) fprintf(stderr, gettext("\textra %c\n"), c2);
        else if (n < -1)
                (void) fprintf(stderr, gettext("\t%d extra %c's\n"), -n, c2);
}

void
FATAL(const char *fmt, ...)
{
        extern char *cmdname;
        va_list varg;

        (void) fflush(stdout);
        (void) fprintf(stderr, "%s: ", cmdname);
        va_start(varg, fmt);
        (void) vfprintf(stderr, fmt, varg);
        va_end(varg);
        error();
        if (dbg > 1)            /* core dump if serious debugging on */
                abort();
        exit(2);
}

void
WARNING(const char *fmt, ...)
{
        extern char *cmdname;
        va_list varg;

        (void) fflush(stdout);
        (void) fprintf(stderr, "%s: ", cmdname);
        va_start(varg, fmt);
        (void) vfprintf(stderr, fmt, varg);
        va_end(varg);
        error();
}

void
error(void)
{
        extern Node *curnode;

        (void) fprintf(stderr, "\n");
        if (compile_time != 2 && NR && *NR > 0) {
                (void) fprintf(stderr,
                    gettext(" input record number %g"), *FNR);
                if (strcmp(*FILENAME, "-") != 0)
                        (void) fprintf(stderr, gettext(", file %s"), *FILENAME);
                (void) fprintf(stderr, "\n");
        }
        if (compile_time != 2 && curnode)
                (void) fprintf(stderr, gettext(" source line number %lld"),
                    curnode->lineno);
        else if (compile_time != 2 && lineno) {
                (void) fprintf(stderr,
                    gettext(" source line number %lld"), lineno);
        }
        if (compile_time == 1 && cursource() != NULL)
                (void) fprintf(stderr, gettext(" source file %s"), cursource());
        (void) fprintf(stderr, "\n");
        eprint();
}

static void
eprint(void)    /* try to print context around error */
{
        char *p, *q;
        int c;
        static int been_here = 0;
        extern char ebuf[], *ep;

        if (compile_time == 2 || compile_time == 0 || been_here++ > 0)
                return;
        if (ebuf == ep)
                return;
        p = ep - 1;
        if (p > ebuf && *p == '\n')
                p--;
        for (; p > ebuf && *p != '\n' && *p != '\0'; p--)
                ;
        while (*p == '\n')
                p++;
        (void) fprintf(stderr, gettext(" context is\n\t"));
        for (q = ep-1; q >= p && *q != ' ' && *q != '\t' && *q != '\n'; q--)
                ;
        for (; p < q; p++)
                if (*p)
                        (void) putc(*p, stderr);
        (void) fprintf(stderr, " >>> ");
        for (; p < ep; p++)
                if (*p)
                        (void) putc(*p, stderr);
        (void) fprintf(stderr, " <<< ");
        if (*ep)
                while ((c = input()) != '\n' && c != '\0' && c != EOF) {
                        (void) putc(c, stderr);
                        bclass(c);
                }
        (void) putc('\n', stderr);
        ep = ebuf;
}

static void
bclass(int c)
{
        switch (c) {
        case '{': bracecnt++; break;
        case '}': bracecnt--; break;
        case '[': brackcnt++; break;
        case ']': brackcnt--; break;
        case '(': parencnt++; break;
        case ')': parencnt--; break;
        }
}

double
errcheck(double x, const char *s)
{
        if (errno == EDOM) {
                errno = 0;
                WARNING("%s argument out of domain", s);
                x = 1;
        } else if (errno == ERANGE) {
                errno = 0;
                WARNING("%s result out of range", s);
                x = 1;
        }
        return (x);
}

int
isclvar(const char *s)  /* is s of form var=something ? */
{
        if (s != NULL) {

                /* Must begin with an underscore or alphabetic character */
                if (isalpha(*s) || (*s == '_')) {

                        for (s++; *s; s++) {
                                /*
                                 * followed by a sequence of underscores,
                                 * digits, and alphabetics
                                 */
                                if (!(isalnum(*s) || *s == '_')) {
                                        break;
                                }
                        }
                        return (*s == '=' && *(s + 1) != '=');
                }
        }

        return (0);
}

#include <math.h>
int
is_number(const char *s)
{
        double r;
        char *ep;
        errno = 0;
        r = strtod(s, &ep);
        if (ep == s || r == HUGE_VAL || errno == ERANGE)
                return (0);
        while (*ep == ' ' || *ep == '\t' || *ep == '\n')
                ep++;
        if (*ep == '\0')
                return (1);
        else
                return (0);
}

void
r_expand_buf(char **optr, size_t *sizep, size_t req)
{
        char    *nptr;
        size_t  amt, size = *sizep;

        if (size != 0 && req < (size - 1))
                return;
        amt = req + 1 - size;
        amt = (amt / LINE_INCR + 1) * LINE_INCR;

        if ((nptr = realloc(*optr, size + amt)) == NULL)
                FATAL("out of space in expand_buf");
        /* initial buffer should have NULL terminated */
        if (size == 0)
                *nptr = '\0';
        *sizep += amt;
        *optr = nptr;
}