/*
 * 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
 */
/*
 * Copyright 2003 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

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

#include <stdio.h>
#include <signal.h>
#include <errno.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <limits.h>
#include "dc.h"
#include <locale.h>
#include <stdlib.h>

#define LASTFUN 026
long longest = 0, maxsize = 0, active = 0;
int lall = 0, lrel = 0, lcopy = 0, lmore = 0, lbytes = 0;

/*
 * Routine to handle sign extension of characters on systems that do not
 * do automatic sign extension.  This should be portable to all 2's and 1's
 * complement systems that do or do not provide automatic sign
 * extension. If the system provides automatic sign extension or the
 * value of 'c' is positive, ctoint() will always return quickly,
 * otherwise ctoint() will search for the negative value by attempting
 * to wrap 'c' to 0.  The number of increments needed to get to 0 is the
 * negative value.
 *
 * Note: This assummes that the representation of values stored in chars
 * is sequential and allowed to wrap, and that values < 128 are
 * positive.  While this is true on 1's and 2's complement machines, it
 * may vary on less common architectures.
 */

#if __STDC__
int
ctoint(char c)
#else
int
ctoint(unsigned char c)
#endif
{
        int     i;

        if ((unsigned char)c <= SCHAR_MAX)
                return ((int)c);        /* Normal promotion will work */
        for (i = 0; c++; i--);          /* Scan for negative value */
        return (i);
}

#if !defined(TEXT_DOMAIN)               /* Should be defined by cc -D */
#define TEXT_DOMAIN "SYS_TEST"  /* Use this only if it weren't. */
#endif

void    commnds(void)   __NORETURN;

int
main(int argc, char **argv)
{
        (void) setlocale(LC_ALL, "");
        (void) textdomain(TEXT_DOMAIN);

        init(argc, argv);
        commnds();
        /* NOTREACHED */
}

void
commnds(void)
{
        int c;
        struct blk *p, *q;
        long l;
        int sign;
        struct blk **ptr, *s, *t;
        struct sym *sp;
        int sk, sk1, sk2;
        int n, d;
        int scalev;     /* scaling value for converting blks to integers */

        for (; ; ) {
                if (((c = readc()) >= '0' && c <= '9') ||
                    (c >= 'A' && c <= 'F') || c == '.') {
                        unreadc(c);
                        p = readin();
                        pushp(p);
                        continue;
                }
                switch (c) {
                case ' ':
                case '\n':
                case 0377:
                case EOF:
                        continue;
                case 'Y':
                        sdump("stk", *stkptr);
                        printf(gettext
                            ("all %ld rel %ld headmor %ld\n"), all, rel,
                            headmor);
                        printf(gettext("nbytes %ld\n"), nbytes);
                        printf(gettext
                            ("longest %ld active %ld maxsize %ld\n"), longest,
                            active, maxsize);
                        printf(gettext
                            ("new all %d rel %d copy %d more %d lbytes %d\n"),
                            lall, lrel, lcopy, lmore, lbytes);
                        lall = lrel = lcopy = lmore = lbytes = 0;
                        continue;
                case '_':
                        p = readin();
                        savk = sunputc(p);
                        chsign(p);
                        sputc(p, savk);
                        pushp(p);
                        continue;
                case '-':
                        subt();
                        continue;
                case '+':
                        if (eqk() != 0)
                                continue;
                        binop('+');
                        continue;
                case '*':
                        arg1 = pop();
                        EMPTY;
                        arg2 = pop();
                        EMPTYR(arg1);
                        sk1 = sunputc(arg1);
                        sk2 = sunputc(arg2);
                        binop('*');
                        p = pop();
                        sunputc(p);
                        savk = n = sk1 + sk2;
                        if (n > k && n > sk1 && n > sk2) {
                                sk = sk1;
                                if (sk < sk2)
                                        sk = sk2;
                                if (sk < k)
                                        sk = k;
                                p = removc(p, n - sk);
                                savk = sk;
                        }
                        sputc(p, savk);
                        pushp(p);
                        continue;
                case '/':
casediv:
                        if (dscale() != 0)
                                continue;
                        binop('/');
                        if (irem != 0)
                                release(irem);
                        release(rem);
                        continue;
                case '%':
                        if (dscale() != 0)
                                continue;
                        binop('/');
                        p = pop();
                        release(p);
                        if (irem == 0) {
                                sputc(rem, skr + k);
                                pushp(rem);
                                continue;
                        }
                        p = add0(rem, skd - (skr + k));
                        q = add(p, irem);
                        release(p);
                        release(irem);
                        sputc(q, skd);
                        pushp(q);
                        continue;
                case 'v':
                        p = pop();
                        EMPTY;
                        savk = sunputc(p);
                        if (length(p) == 0) {
                                sputc(p, savk);
                                pushp(p);
                                continue;
                        }
                        if ((c = sbackc(p)) < 0) {
                                error(gettext("sqrt of neg number\n"));
                        }
                        if (k < savk)
                                n = savk;
                        else {
                                n = k * 2 - savk;
                                savk = k;
                        }
                        arg1 = add0(p, n);
                        arg2 = sqrt(arg1);
                        sputc(arg2, savk);
                        pushp(arg2);
                        continue;
                case '^':
                        neg = 0;
                        arg1 = pop();
                        EMPTY;
                        if (sunputc(arg1) != 0)
                                error(gettext("exp not an integer\n"));
                        arg2 = pop();
                        EMPTYR(arg1);
                        if (sfbeg(arg1) == 0 && sbackc(arg1) < 0) {
                                neg++;
                                chsign(arg1);
                        }
                        if (length(arg1) >= 3)
                                error(gettext("exp too big\n"));
                        savk = sunputc(arg2);
                        p = exp(arg2, arg1);
                        release(arg2);
                        rewind(arg1);
                        c = sgetc(arg1);
                        if (c == EOF)
                                c = 0;
                        else if (sfeof(arg1) == 0)
                                c = sgetc(arg1) * 100 + c;
                        d = c * savk;
                        release(arg1);
                        if (k >= savk)
                                n = k;
                        else
                                n = savk;
                        if (n < d) {
                                q = removc(p, d - n);
                                sputc(q, n);
                                pushp(q);
                        } else {
                                sputc(p, d);
                                pushp(p);
                        }
                        if (neg == 0)
                                continue;
                        p = pop();
                        q = salloc(2);
                        sputc(q, 1);
                        sputc(q, 0);
                        pushp(q);
                        pushp(p);
                        goto casediv;
                case 'z':
                        p = salloc(2);
                        n = stkptr - stkbeg;
                        if (n >= 100) {
                                sputc(p, n / 100);
                                n %= 100;
                        }
                        sputc(p, n);
                        sputc(p, 0);
                        pushp(p);
                        continue;
                case 'Z':
                        p = pop();
                        EMPTY;
                        n = (length(p) - 1) << 1;
                        fsfile(p);
                        sbackc(p);
                        if (sfbeg(p) == 0) {
                                if ((c = sbackc(p)) < 0) {
                                        n -= 2;
                                        if (sfbeg(p) == 1)
                                                n += 1;
                                        else {
                                                if ((c = sbackc(p)) == 0)
                                                        n += 1;
                                                else if (c > 90)
                                                        n -= 1;
                                        }
                                } else
                                        if (c < 10)
                                                n -= 1;
                        }
                        release(p);
                        q = salloc(1);
                        if (n >= 100) {
                                sputc(q, n%100);
                                n /= 100;
                        }
                        sputc(q, n);
                        sputc(q, 0);
                        pushp(q);
                        continue;
                case 'i':
                        p = pop();
                        EMPTY;
                        p = scalint(p);

                        /*
                         * POSIX.2
                         * input base must be between 2 and 16
                         */
                        n = length(p);
                        q = copy(p, n);
                        fsfile(q);
                        c = sbackc(q);
                        if (sfbeg(q) == 0)
                                error(gettext("input base is too large\n"));
                        if (c < 2)
                                error(gettext("input base is too small\n"));
                        if (c > 16)
                                error(gettext("input base is too large\n"));
                        release(q);

                        release(inbas);
                        inbas = p;
                        continue;
                case 'I':
                        p = copy(inbas, length(inbas) + 1);
                        sputc(p, 0);
                        pushp(p);
                        continue;
                case 'o':
                        p = pop();
                        EMPTY;
                        p = scalint(p);
                        sign = 0;
                        n = length(p);
                        q = copy(p, n);
                        fsfile(q);
                        l = c = sbackc(q);
                        if (n != 1) {
                                if (c < 0) {
                                        sign = 1;
                                        chsign(q);
                                        n = length(q);
                                        fsfile(q);
                                        l = c = sbackc(q);
                                }
                                if (n != 1) {
                                        while (sfbeg(q) == 0)
                                                l = l * 100 + sbackc(q);
                                }
                        }

                        /*
                         * POSIX.2
                         * Check that output base is less than or equal
                         * BC_BASE_MAX.
                         */
                        if (l > BC_BASE_MAX)
                                error(gettext("output base is too large\n"));

                        logo = log2(l);
                        obase = l;
                        release(basptr);
                        if (sign == 1)
                                obase = -l;
                        basptr = p;
                        outdit = bigot;
                        if (n == 1 && sign == 0) {
                                if (c <= 16) {
                                        outdit = hexot;
                                        fw = 1;
                                        fw1 = 0;

                                        /*
                                         * POSIX.2
                                         * Line length is 70 characters,
                                         * including newline.
                                         */
                                        ll = 70;
                                        release(q);
                                        continue;
                                }
                        }
                        n = 0;
                        if (sign == 1)
                                n++;
                        p = salloc(1);
                        sputc(p, -1);
                        t = add(p, q);
                        n += length(t) * 2;
                        fsfile(t);
                        if ((c = sbackc(t)) > 9)
                                n++;
                        release(t);
                        release(q);
                        release(p);
                        fw = n;
                        fw1 = n-1;

                        /*
                         * POSIX.2
                         * Line length is 70 characters including newline
                         */
                        ll = 70;
                        if (fw >= ll)
                                continue;
                        ll = (70 / fw) * fw;
                        continue;
                case 'O':
                        p = copy(basptr, length(basptr) + 1);
                        sputc(p, 0);
                        pushp(p);
                        continue;
                case '[':
                        n = 0;
                        p = salloc(0);
                        for (; ; ) {
                                if ((c = readc()) == ']') {
                                        if (n == 0)
                                                break;
                                        n--;
                                }
                                sputc(p, c);
                                if (c == '[')
                                        n++;
                        }
                        pushp(p);
                        continue;
                case 'k':
                        p = pop();
                        EMPTY;
                        p = scalint(p);

                        /*
                         * POSIX.2
                         * Make sure scaling factor is between 0 and
                         * BC_SCALE_MAX.  Copy p to q and figure the
                         * scaling factor.
                         */
                        n = length(p);
                        q = copy(p, n);
                        fsfile(q);
                        c = 0;
                        if ((sfbeg(q) == 0) && ((c = sbackc(q)) < 0))
                                error(gettext("invalid scale factor\n"));

                        scalev = 1;
                        while (c < BC_SCALE_MAX && sfbeg(q) == 0)
                                c = (c * (scalev *= 100)) + sbackc(q);

                        if (c > BC_SCALE_MAX)
                                error(gettext("scale factor is too large\n"));
                        release(q);

                        rewind(p);
                        k = sfeof(p) ? 0 : sgetc(p);
                        release(scalptr);
                        scalptr = p;
                        continue;

                case 'K':
                        p = copy(scalptr, length(scalptr) + 1);
                        sputc(p, 0);
                        pushp(p);
                        continue;
                case 'X':
                        p = pop();
                        EMPTY;
                        fsfile(p);
                        n = sbackc(p);
                        release(p);
                        p = salloc(2);
                        sputc(p, n);
                        sputc(p, 0);
                        pushp(p);
                        continue;
                case 'Q':
                        p = pop();
                        EMPTY;
                        if (length(p) > 2) {
                                error("Q?\n");
                        }
                        rewind(p);
                        if ((c =  sgetc(p)) < 0) {
                                error(gettext("neg Q\n"));
                        }
                        release(p);
                        while (c-- > 0) {
                                if (readptr == &readstk[0]) {
                                        error("readstk?\n");
                                }
                                if (*readptr != 0)
                                        release(*readptr);
                                readptr--;
                        }
                        continue;
                case 'q':
                        if (readptr <= &readstk[1])
                                exit(0);
                        if (*readptr != 0)
                                release(*readptr);
                        readptr--;
                        if (*readptr != 0)
                                release(*readptr);
                        readptr--;
                        continue;
                case 'f':
                        if (stkptr == &stack[0])
                                printf(gettext("empty stack\n"));
                        else {
                                for (ptr = stkptr; ptr > &stack[0]; ) {
                                        print(*ptr--);
                                }
                        }
                        continue;
                case 'p':
                        if (stkptr == &stack[0])
                                printf(gettext("empty stack\n"));
                        else {
                                print(*stkptr);
                        }
                        continue;
                case 'P':
                        p = pop();
                        EMPTY;
                        sputc(p, 0);
                        printf("%s", p->beg);
                        release(p);
                        continue;
                case 'd':
                        if (stkptr == &stack[0]) {
                                printf(gettext("empty stack\n"));
                                continue;
                        }
                        q = *stkptr;
                        n = length(q);
                        p = copy(*stkptr, n);
                        pushp(p);
                        continue;
                case 'c':
                        while (stkerr == 0) {
                                p = pop();
                                if (stkerr == 0)
                                        release(p);
                        }
                        continue;
                case 'S':
                        if (stkptr == &stack[0]) {
                                error(gettext("save: args\n"));
                        }
                        c = readc() & 0377;
                        sptr = stable[c];
                        sp = stable[c] = sfree;
                        sfree = sfree->next;
                        if (sfree == 0)
                                goto sempty;
                        sp->next = sptr;
                        p = pop();
                        EMPTY;
                        if (c >= ARRAYST) {
                                q = copy(p, length(p) + PTRSZ);
                                for (n = 0; n < PTRSZ; n++) {
                                        sputc(q, 0);
                                }
                                release(p);
                                p = q;
                        }
                        sp->val = p;
                        continue;
sempty:
                        error(gettext("symbol table overflow\n"));
                case 's':
                        if (stkptr == &stack[0]) {
                                error(gettext("save:args\n"));
                        }
                        c = readc() & 0377;
                        sptr = stable[c];
                        if (sptr != 0) {
                                p = sptr->val;
                                if (c >= ARRAYST) {
                                        rewind(p);
                                        while (sfeof(p) == 0)
                                                release(getwd(p));
                                }
                                release(p);
                        } else {
                                sptr = stable[c] = sfree;
                                sfree = sfree->next;
                                if (sfree == 0)
                                        goto sempty;
                                sptr->next = 0;
                        }
                        p = pop();
                        sptr->val = p;
                        continue;
                case 'l':
                        load();
                        continue;
                case 'L':
                        c = readc() & 0377;
                        sptr = stable[c];
                        if (sptr == 0) {
                                error("L?\n");
                        }
                        stable[c] = sptr->next;
                        sptr->next = sfree;
                        sfree = sptr;
                        p = sptr->val;
                        if (c >= ARRAYST) {
                                rewind(p);
                                while (sfeof(p) == 0) {
                                        q = getwd(p);
                                        if (q != 0)
                                                release(q);
                                }
                        }
                        pushp(p);
                        continue;
                case ':':
                        p = pop();
                        EMPTY;
                        q = scalint(p);
                        fsfile(q);

                        /*
                         * POSIX.2
                         * Make sure index is between 0 and BC_DIM_MAX-1
                         */
                        c = 0;
                        if ((sfbeg(q) == 0) && ((c = sbackc(q)) < 0))
                                error(gettext("invalid index\n"));
                        scalev = 1;
                        while (c < BC_DIM_MAX && sfbeg(q) == 0)
                                c = (c * (scalev *= 100)) + sbackc(q);

                        if (c >= BC_DIM_MAX)
                                error(gettext("index is too large\n"));

                        release(q);
                        n = readc() & 0377;
                        sptr = stable[n];
                        if (sptr == 0) {
                                sptr = stable[n] = sfree;
                                sfree = sfree->next;
                                if (sfree == 0)
                                        goto sempty;
                                sptr->next = 0;
                                p = salloc((c + PTRSZ) * PTRSZ);
                                zero(p);
                        } else {
                                p = sptr->val;
                                if (length(p) - PTRSZ < c * PTRSZ) {
                                        q = copy(p, (c + PTRSZ) * PTRSZ);
                                        release(p);
                                        p = q;
                                }
                        }
                        seekc(p, c * PTRSZ);
                        q = lookwd(p);
                        if (q != NULL)
                                release(q);
                        s = pop();
                        EMPTY;
                        salterwd((struct wblk *)p, s);
                        sptr->val = p;
                        continue;

                case ';':
                        p = pop();
                        EMPTY;
                        q = scalint(p);
                        fsfile(q);

                        /*
                         * POSIX.2
                         * Make sure index is between 0 and BC_DIM_MAX-1
                         */
                        c = 0;
                        if ((sfbeg(q) == 0) && ((c = sbackc(q)) < 0))
                                error(gettext("invalid index\n"));
                        scalev = 1;
                        while (c < BC_DIM_MAX && sfbeg(q) == 0)
                                c = (c * (scalev *= 100)) + sbackc(q);

                        if (c >= BC_DIM_MAX)
                                error(gettext("index is too large\n"));

                        release(q);
                        n = readc() & 0377;
                        sptr = stable[n];
                        if (sptr != 0) {
                                p = sptr->val;
                                if (length(p) - PTRSZ >= c * PTRSZ) {
                                        seekc(p, c * PTRSZ);
                                        s = getwd(p);
                                        if (s != 0) {
                                                q = copy(s, length(s));
                                                pushp(q);
                                                continue;
                                        }
                                }
                        }
                        q = salloc(1);  /* uninitializd array elt prints as 0 */
                        sputc(q, 0);
                        pushp(q);
                        continue;
                case 'x':
execute:
                        p = pop();
                        EMPTY;
                        if ((readptr != &readstk[0]) && (*readptr != 0)) {
                                if ((*readptr)->rd == (*readptr)->wt)
                                        release(*readptr);
                                else {
                                        if (readptr++ == &readstk[RDSKSZ]) {
                                                error(gettext
                                                    ("nesting depth\n"));
                                        }
                                }
                        } else
                                readptr++;
                        *readptr = p;
                        if (p != 0)
                                rewind(p);
                        else {
                                if ((c = readc()) != '\n')
                                        unreadc(c);
                        }
                        continue;
                case '?':
                        if (++readptr == &readstk[RDSKSZ]) {
                                error(gettext("nesting depth\n"));
                        }
                        *readptr = 0;
                        fsave = curfile;
                        curfile = stdin;
                        while ((c = readc()) == '!')
                                command();
                        p = salloc(0);
                        sputc(p, c);
                        while ((c = readc()) != '\n') {
                                sputc(p, c);
                                if (c == '\\')
                                        sputc(p, readc());
                        }
                        curfile = fsave;
                        *readptr = p;
                        continue;
                case '!':
                        if (command() == 1)
                                goto execute;
                        continue;
                case '<':
                case '>':
                case '=':
                        if (cond(c) == 1)
                                goto execute;
                        continue;
                default:
                        printf(gettext("%o is unimplemented\n"), c);
                }
        }
}

struct blk *
dcdiv(struct blk *ddivd, struct blk *ddivr)
{
        int divsign, remsign, offset, divcarry;
        int carry, dig, magic, d, dd, under;
        long c, td, cc;
        struct blk *ps, *px;
        struct blk *p, *divd, *divr;

        rem = 0;
        p = salloc(0);
        if (length(ddivr) == 0) {
                pushp(ddivr);
                printf(gettext("divide by 0\n"));
                return (p);
        }
        divsign = remsign = 0;
        divr = ddivr;
        fsfile(divr);
        if (sbackc(divr) == -1) {
                divr = copy(ddivr, length(ddivr));
                chsign(divr);
                divsign = ~divsign;
        }
        divd = copy(ddivd, length(ddivd));
        fsfile(divd);
        if (sfbeg(divd) == 0 && sbackc(divd) == -1) {
                chsign(divd);
                divsign = ~divsign;
                remsign = ~remsign;
        }
        offset = length(divd) - length(divr);
        if (offset < 0)
                goto ddone;
        seekc(p, offset + 1);
        sputc(divd, 0);
        magic = 0;
        fsfile(divr);
        c = sbackc(divr);
        if (c < 10)
                magic++;
        c = c * 100 + (sfbeg(divr)?0:sbackc(divr));
        if (magic > 0) {
                c = (c * 100 +(sfbeg(divr)?0:sbackc(divr)))*2;
                c /= 25;
        }
        while (offset >= 0) {
                fsfile(divd);
                td = sbackc(divd) * 100;
                dd = sfbeg(divd)?0:sbackc(divd);
                td = (td + dd) * 100;
                dd = sfbeg(divd)?0:sbackc(divd);
                td = td + dd;
                cc = c;
                if (offset == 0)
                        td++;
                else
                        cc++;
                if (magic != 0)
                        td = td<<3;
                dig = td/cc;
                under = 0;
                if (td%cc < 8 && dig > 0 && magic) {
                        dig--;
                        under = 1;
                }
                rewind(divr);
                rewind(divxyz);
                carry = 0;
                while (sfeof(divr) == 0) {
                        d = sgetc(divr) * dig + carry;
                        carry = d / 100;
                        salterc(divxyz, d % 100);
                }
                salterc(divxyz, carry);
                rewind(divxyz);
                seekc(divd, offset);
                carry = 0;
                while (sfeof(divd) == 0) {
                        d = slookc(divd);
                        d = d - (sfeof(divxyz) ? 0 : sgetc(divxyz)) - carry;
                        carry = 0;
                        if (d < 0) {
                                d += 100;
                                carry = 1;
                        }
                        salterc(divd, d);
                }
                divcarry = carry;
                sbackc(p);
                salterc(p, dig);
                sbackc(p);
                fsfile(divd);
                d = sbackc(divd);
                if ((d != 0) && /* !divcarry */ (offset != 0)) {
                        d = sbackc(divd) + 100;
                        salterc(divd, d);
                }
                if (--offset >= 0) {
                        divd->wt--;
                }
        }
        if (under) {    /* undershot last - adjust */
                px = copy(divr, length(divr));  /* 11/88 don't corrupt ddivr */
                chsign(px);
                ps = add(px, divd);
                fsfile(ps);
                if (length(ps) > 0 && sbackc(ps) < 0) {
                        release(ps);    /* only adjust in really undershot */
                } else {
                        release(divd);
                        salterc(p, dig + 1);
                        divd = ps;
                }
        }
        if (divcarry != 0) {
                salterc(p, dig - 1);
                salterc(divd, -1);
                ps = add(divr, divd);
                release(divd);
                divd = ps;
        }

        rewind(p);
        divcarry = 0;
        while (sfeof(p) == 0) {
                d = slookc(p) + divcarry;
                divcarry = 0;
                if (d >= 100) {
                        d -= 100;
                        divcarry = 1;
                }
                salterc(p, d);
        }
        if (divcarry != 0)
                salterc(p, divcarry);
        fsfile(p);
        while (sfbeg(p) == 0) {
                if (sbackc(p) == 0)
                        truncate(p);
                else break;
        }
        if (divsign < 0)
                chsign(p);
        fsfile(divd);
        while (sfbeg(divd) == 0) {
                if (sbackc(divd) == 0)
                        truncate(divd);
                else break;
        }
ddone:
        if (remsign < 0)
                chsign(divd);
        if (divr != ddivr)
                release(divr);
        rem = divd;
        return (p);
}

int
dscale(void)
{
        struct blk *dd, *dr, *r;
        int c;

        dr = pop();
        EMPTYS;
        dd = pop();
        EMPTYSR(dr);
        fsfile(dd);
        skd = sunputc(dd);
        fsfile(dr);
        skr = sunputc(dr);
        if (sfbeg(dr) == 1 || (sfbeg(dr) == 0 && sbackc(dr) == 0)) {
                sputc(dr, skr);
                pushp(dr);
                printf(gettext("divide by 0\n"));
                return (1);
        }
        if (sfbeg(dd) == 1 || (sfbeg(dd) == 0 && sbackc(dd) == 0)) {
#ifdef XPG6
                sputc(dd, k);
#else
                sputc(dd, skd);
#endif
                pushp(dd);
                return (1);
        }
        c = k-skd+skr;
        if (c < 0)
                r = removr(dd, -c);
        else {
                r = add0(dd, c);
                irem = 0;
        }
        arg1 = r;
        arg2 = dr;
        savk = k;
        return (0);
}

struct blk *
removr(struct blk *p, int n)
{
        int nn, neg;
        struct blk *q, *s, *r;
        fsfile(p);
        neg = sbackc(p);
        if (neg < 0)
                chsign(p);
        rewind(p);
        nn = (n + 1) / 2;
        q = salloc(nn);
        while (n > 1) {
                sputc(q, sgetc(p));
                n -= 2;
        }
        r = salloc(2);
        while (sfeof(p) == 0)
                sputc(r, sgetc(p));
        release(p);
        if (n == 1) {
                s = dcdiv(r, tenptr);
                release(r);
                rewind(rem);
                if (sfeof(rem) == 0)
                        sputc(q, sgetc(rem));
                release(rem);
                if (neg < 0) {
                        chsign(s);
                        chsign(q);
                        irem = q;
                        return (s);
                }
                irem = q;
                return (s);
        }
        if (neg < 0) {
                chsign(r);
                chsign(q);
                irem = q;
                return (r);
        }
        irem = q;
        return (r);
}

struct blk *
sqrt(struct blk *p)
{
        struct blk *r, *q, *s, *t;
        int c, n, nn;

        n = length(p);
        fsfile(p);
        c = sbackc(p);
        if ((n & 1) != 1)
                c = c * 100 + (sfbeg(p) ? 0 : sbackc(p));
        n = (n + 1) >> 1;
        r = salloc(n);
        zero(r);
        seekc(r, n);
        nn = 1;
        while ((c -= nn) >= 0)
                nn += 2;
        c = (nn + 1) >> 1;
        fsfile(r);
        sbackc(r);
        if (c >= 100) {
                c -= 100;
                salterc(r, c);
                sputc(r, 1);
        } else
                salterc(r, c);
        for (; ; ) {
                q = dcdiv(p, r);
                s = add(q, r);
                release(q);
                release(rem);
                q = dcdiv(s, sqtemp);
                release(s);
                release(rem);
                s = copy(r, length(r));
                chsign(s);
                t = add(s, q);
                release(s);
                fsfile(t);
                nn = sfbeg(t) ? 0 : sbackc(t);
                if (nn >= 0)
                        break;
                release(r);
                release(t);
                r = q;
        }
        release(t);
        release(q);
        release(p);
        return (r);
}

struct blk *
exp(struct blk *base, struct blk *ex)
{
        struct blk *r, *e, *p, *e1, *t, *cp;
        int temp, c, n;
        r = salloc(1);
        sputc(r, 1);
        p = copy(base, length(base));
        e = copy(ex, length(ex));
        fsfile(e);
        if (sfbeg(e) != 0)
                goto edone;
        temp = 0;
        c = sbackc(e);
        if (c < 0) {
                temp++;
                chsign(e);
        }
        while (length(e) != 0) {
                e1 = dcdiv(e, sqtemp);
                release(e);
                e = e1;
                n = length(rem);
                release(rem);
                if (n != 0) {
                        e1 = mult(p, r);
                        release(r);
                        r = e1;
                }
                t = copy(p, length(p));
                cp = mult(p, t);
                release(p);
                release(t);
                p = cp;
        }
        if (temp != 0) {
                if ((c = length(base)) == 0) {
                        goto edone;
                }
                if (c > 1)
                        create(r);
                else {
                        rewind(base);
                        if ((c = sgetc(base)) <= 1) {
                                create(r);
                                sputc(r, c);
                        } else
                                create(r);
                }
        }
edone:
        release(p);
        release(e);
        return (r);
}

void
init(int argc, char **argv)
{
        struct sym *sp;
        char *dcmalloc();
        struct stat tsb;

        if (signal(SIGINT, SIG_IGN) != SIG_IGN)
                signal(SIGINT, onintr);
        setbuf(stdout, (char *)NULL);
        svargc = --argc;
        svargv = argv;
        while (svargc > 0 && svargv[1][0] == '-') {
                switch (svargv[1][1]) {
                default:
                        dbg = 1;
                }
                svargc--;
                svargv++;
        }

        ifile = 1;

        if (svargc <= 0)
                curfile = stdin;
        else {
                if (stat(svargv[1], &tsb) < 0) {
                        printf(gettext("Cannot stat %s: "), svargv[1]);
                        perror("");
                        exit(1);
                }

                if (S_ISREG(tsb.st_mode)) {
                        if ((curfile = fopen(svargv[1], "r")) == NULL) {
                                printf(gettext("can't open file %s\n"), \
                                    svargv[1]);
                                exit(1);
                        }
                } else {
                        printf(gettext("invalid file type: %s\n"), \
                            svargv[1]);
                        exit(1);
                }
        }

        dummy = dcmalloc(0);
        scalptr = salloc(1);
        sputc(scalptr, 0);
        basptr = salloc(1);
        sputc(basptr, 10);
        obase = 10;
        log10 = log2(10L);

        /*
         * POSIX.2
         * default line length is 70 characters including newline
         */
        ll = 70;
        fw = 1;
        fw1 = 0;
        tenptr = salloc(1);
        sputc(tenptr, 10);
        obase = 10;
        inbas = salloc(1);
        sputc(inbas, 10);
        sqtemp = salloc(1);
        sputc(sqtemp, 2);
        chptr = salloc(0);
        strptr = salloc(0);
        divxyz = salloc(0);
        stkbeg = stkptr = &stack[0];
        stkend = &stack[STKSZ];
        stkerr = 0;
        readptr = &readstk[0];
        k = 0;
        sp = sptr = &symlst[0];
        while (sptr < &symlst[TBLSZ]) {
                sptr->next = ++sp;
                sptr++;
        }
        sptr->next = 0;
        sfree = &symlst[0];
}

void
onintr(int sig)
{

        signal(sig, onintr);
        while (readptr != &readstk[0]) {
                if (*readptr != 0)
                        release(*readptr);
                readptr--;
        }
        curfile = stdin;
        commnds();
}

void
pushp(struct blk *p)
{
        if (stkptr == stkend)
                printf(gettext("out of stack space\n"));
        else {
                stkerr = 0;
                *++stkptr = p;
        }
}

struct blk *
pop(void)
{
        if (stkptr == stack) {
                stkerr = 1;
                return (0);
        }
        return (*stkptr--);
}

struct blk *
readin(void)
{
        struct blk *p, *q;
        int dp, dpct;
        int c;

        dp = dpct = 0;
        p = salloc(0);
        for (; ; ) {
                c = readc();
                switch (c) {
                case '.':
                        if (dp != 0)
                                goto gotnum;
                        dp++;
                        continue;
                case '\\':
                        readc();
                        continue;
                default:
                        if (c >= 'A' && c <= 'F')
                                c = c - 'A' + 10;
                        else
                                if (c >= '0' && c <= '9')
                                        c -= '0';
                                else
                                        goto gotnum;
                        if (dp != 0) {
                                if (dpct >= 99)
                                        continue;
                                dpct++;
                        }
                        create(chptr);
                        if (c != 0)
                                sputc(chptr, c);
                        q = mult(p, inbas);
                        release(p);
                        p = add(chptr, q);
                        release(q);
                }
        }
gotnum:
        unreadc(c);
        if (dp == 0) {
                sputc(p, 0);
                return (p);
        } else {
                /* if not base 10, then scale fractional input to precision */
                if (((int)*(inbas->beg)) != 10) {
                        while (dpct < k) {
                                create(chptr);
                                q = mult(p, inbas);
                                release(p);
                                p = add(chptr, q);
                                release(q);
                                dpct++;
                        }
                }
                q = scale(p, dpct);
                return (q);
        }
}

/*
 * returns pointer to struct with ct 0's & p
 */
struct blk *
add0(struct blk *p, int ct)
{
        struct blk *q, *t;

        q = salloc(length(p) + (ct + 1) / 2);
        while (ct > 1) {
                sputc(q, 0);
                ct -= 2;
        }
        rewind(p);
        while (sfeof(p) == 0) {
                sputc(q, sgetc(p));
        }
        release(p);
        if (ct == 1) {
                t = mult(tenptr, q);
                release(q);
                return (t);
        }
        return (q);
}

struct blk *
mult(struct blk *p, struct blk *q)
{
        struct blk *mp, *mq, *mr;
        int sign, offset, carry;
        int cq, cp, mt, mcr;

        offset = sign = 0;
        fsfile(p);
        mp = p;
        if (sfbeg(p) == 0) {
                if (sbackc(p) < 0) {
                        mp = copy(p, length(p));
                        chsign(mp);
                        sign = ~sign;
                }
        }
        fsfile(q);
        mq = q;
        if (sfbeg(q) == 0) {
                if (sbackc(q) < 0) {
                        mq = copy(q, length(q));
                        chsign(mq);
                        sign = ~sign;
                }
        }
        mr = salloc(length(mp) + length(mq));
        zero(mr);
        rewind(mq);
        while (sfeof(mq) == 0) {
                cq = sgetc(mq);
                rewind(mp);
                rewind(mr);
                mr->rd += offset;
                carry = 0;
                while (sfeof(mp) == 0) {
                        cp = sgetc(mp);
                        mcr = sfeof(mr) ? 0 : slookc(mr);
                        mt = cp*cq + carry + mcr;
                        carry = mt / 100;
                        salterc(mr, mt % 100);
                }
                offset++;
                if (carry != 0) {
                        mcr = sfeof(mr) ? 0 : slookc(mr);
                        salterc(mr, mcr + carry);
                }
        }
        if (sign < 0) {
                chsign(mr);
        }
        if (mp != p)
                release(mp);
        if (mq != q)
                release(mq);
        return (mr);
}

void
chsign(struct blk *p)
{
        int carry;
        char ct;

        carry = 0;
        rewind(p);
        while (sfeof(p) == 0) {
                ct = 100 - slookc(p) - carry;
                carry = 1;
                if (ct >= 100) {
                        ct -= 100;
                        carry = 0;
                }
                salterc(p, ct);
        }
        if (carry != 0) {
                sputc(p, -1);
                fsfile(p);
                sbackc(p);
                ct = sbackc(p);
                if (ct == 99) {
                        truncate(p);
                        sputc(p, -1);
                }
        } else {
                fsfile(p);
                ct = sbackc(p);
                if (ct == 0)
                        truncate(p);
        }
}

char
readc(void)
{
loop:
        if ((readptr != &readstk[0]) && (*readptr != 0)) {
                if (sfeof(*readptr) == 0)
                        return (lastchar = sgetc(*readptr));
                release(*readptr);
                readptr--;
                goto loop;
        }
        lastchar = getc(curfile);
        if (lastchar != EOF)
                return (lastchar);
        if (readptr != &readptr[0]) {
                readptr--;
                if (*readptr == 0)
                        curfile = stdin;
                goto loop;
        }
        if (curfile != stdin) {
                fclose(curfile);
                curfile = stdin;
                goto loop;
        }
        exit(0);
}

void
unreadc(char c)
{

        if ((readptr != &readstk[0]) && (*readptr != 0)) {
                sungetc(*readptr, c);
        } else
                ungetc(c, curfile);
}

void
binop(char c)
{
        struct blk *r;

        switch (c) {
        case '+':
                r = add(arg1, arg2);
                break;
        case '*':
                r = mult(arg1, arg2);
                break;
        case '/':
                r = dcdiv(arg1, arg2);
                break;
        }
        release(arg1);
        release(arg2);
        sputc(r, savk);
        pushp(r);
}

void
print(struct blk *hptr)
{
        struct blk *p, *q, *dec;
        int sc;                         /* scale */
        int dig, dout, ct;

        rewind(hptr);
        while (sfeof(hptr) == 0) {
                if (sgetc(hptr) > 99) {
                        rewind(hptr);
                        while (sfeof(hptr) == 0) {
                                printf("%c", sgetc(hptr));
                        }
                        printf("\n");
                        return;
                }
        }
        fsfile(hptr);
        sc = sbackc(hptr);              /* read scale off end of blk */
        if (sfbeg(hptr) != 0) {
                printf("0\n");
                return;
        }
        count = ll;
        p = copy(hptr, length(hptr));
        sunputc(p);
        fsfile(p);
        if (sbackc(p) < 0) {
                chsign(p);
                OUTC('-');
        }
        if ((obase == 0) || (obase == -1)) {
                oneot(p, sc, 'd');
                return;
        }
        if (obase == 1) {
                oneot(p, sc, '1');
                return;
        }
        if (obase == 10) {
                tenot(p, sc);
                return;
        }
        create(strptr);
        dig = log10 * sc;
        dout = ((dig / 10) + dig) / logo;
        dec = getdec(p, sc);
        p = removc(p, sc);
        while (length(p) != 0) {
                q = dcdiv(p, basptr);
                release(p);
                p = q;
                (*outdit)(rem, 0);
                if (obase > 16)
                        sputc(strptr, ' ');
        }
        release(p);
        fsfile(strptr);
        while (sfbeg(strptr) == 0)
                OUTC(sbackc(strptr));
        if (sc == 0) {
                release(dec);
                printf("\n");
                return;
        }
        create(strptr);
        OUTC('.');
        ct = 0;
        do {
                if (ct != 0 && obase > 16)
                        sputc(strptr, ' ');
                q = mult(basptr, dec);
                release(dec);
                dec = getdec(q, sc);
                p = removc(q, sc);
                (*outdit)(p, 1);
        } while (++ct < dout);
        release(dec);
        rewind(strptr);
        while (sfeof(strptr) == 0)
                OUTC(sgetc(strptr));
        printf("\n");
}

struct blk *
getdec(struct blk *p, int sc)
{
        int cc;
        struct blk *q, *t, *s;

        rewind(p);
        if (length(p) * 2 < sc) {
                q = copy(p, length(p));
                return (q);
        }
        q = salloc(length(p));
        while (sc >= 1) {
                sputc(q, sgetc(p));
                sc -= 2;
        }
        if (sc != 0) {
                t = mult(q, tenptr);
                s = salloc(cc = length(q));
                release(q);
                rewind(t);
                while (cc-- > 0)
                        sputc(s, sgetc(t));
                sputc(s, 0);
                release(t);
                t = dcdiv(s, tenptr);
                release(s);
                release(rem);
                return (t);
        }
        return (q);
}

void
tenot(struct blk *p, int sc)
{
        int c, f;

        fsfile(p);

        f = 0;

        /*
         * at this point, the number is stored as base 100 (two decimal
         * digits per char) stuck in a buf (character array) backwards.
         * sc indicates the scaling factor.
         */

        while ((sfbeg(p) == 0) && ((p->rd-p->beg-1)*2 >= sc)) {
                /*
                 * get numbers from the buf until we are the beginning of
                 * the buf (i.e., there are no more numbers) or the numbers
                 * remaining fall within the scaled (to the right of the
                 * decimal point) portion.
                 */
                c = sbackc(p);

                /*
                 * POSIX.2
                 * as we output digits, we have to watch the line length (ll)
                 * which should include a '\' and a newline.
                 */
                if (c < 10) {
                        /*
                         * if the number is less than 10, we need to output
                         * a space-holding '0' (unless this is the first time
                         * through).
                         */
                        if (f == 1) {
                                CHECKEND;
                                printf("0");
                                count--;
                        }

                        CHECKEND;
                        printf("%d", c);
                        count--;
                } else  {
                        CHECKEND;
                        printf("%d", c / 10);
                        count--;

                        CHECKEND;
                        printf("%d", c % 10);
                        count--;
                }
                f = 1;
        }

        if (sc == 0) {
                /*
                 * no scaling factor, so we must have exited loop because we
                 * ran out of numbers.
                 */
                printf("\n");
                release(p);
                return;
        }

        if ((p->rd - p->beg) * 2 > sc) {
                c = sbackc(p);

                CHECKEND;
                printf("%d", c / 10);
                count--;

                CHECKEND;
                printf(".");
                count--;

                CHECKEND;
                printf("%d", c % 10);
                count--;

                sc--;
        } else {
                CHECKEND;
                printf(".");
                count--;
        }

        if (sc > (p->rd - p->beg) * 2) {
                while (sc > (p->rd - p->beg) * 2) {
                        CHECKEND;
                        printf("0");
                        count--;

                        sc--;
                }
        }

        /* now go through the scaled portion of the number */
        while (sc > 1) {
                c = sbackc(p);
                if (c < 10) {
                        CHECKEND;
                        printf("0");
                        count--;

                        CHECKEND;
                        printf("%d", c);
                        count--;
                } else {
                        CHECKEND;
                        printf("%d", c / 10);
                        count--;

                        CHECKEND;
                        printf("%d", c % 10);
                        count--;
                }
                sc -= 2;
        }

        if (sc == 1) {          /* just in case the scaling factor was odd */
                CHECKEND;
                printf("%d", sbackc(p) / 10);
        }

        printf("\n");
        release(p);
}

void
oneot(struct blk *p, int sc, char ch)
{
        struct blk *q;

        q = removc(p, sc);
        create(strptr);
        sputc(strptr, -1);
        while (length(q) > 0) {
                p = add(strptr, q);
                release(q);
                q = p;
                OUTC(ch);
        }
        release(q);
        printf("\n");
}

void
hexot(struct blk *p, int flg)
{
        int c;

        rewind(p);
        if (sfeof(p) != 0) {
                sputc(strptr, '0');
                release(p);
                return;
        }
        c = sgetc(p);
        release(p);
        if (c >= 16) {
                printf(gettext("hex digit > 16"));
                return;
        }
        sputc(strptr, c < 10 ? c + '0' : c - 10 + 'A');
}

void
bigot(struct blk *p, int flg)
{
        struct blk *t, *q;
        int l;
        int neg;

        if (flg == 1)
                t = salloc(0);
        else {
                t = strptr;
                l = length(strptr) + fw - 1;
        }
        neg = 0;
        if (length(p) != 0) {
                fsfile(p);
                if (sbackc(p) < 0) {
                        neg = 1;
                        chsign(p);
                }
                while (length(p) != 0) {
                        q = dcdiv(p, tenptr);
                        release(p);
                        p = q;
                        rewind(rem);
                        sputc(t, sfeof(rem) ? '0' : sgetc(rem) + '0');
                        release(rem);
                }
        }
        release(p);
        if (flg == 1) {
                l = fw1 - length(t);
                if (neg != 0) {
                        l--;
                        sputc(strptr, '-');
                }
                fsfile(t);
                while (l-- > 0)
                        sputc(strptr, '0');
                while (sfbeg(t) == 0)
                        sputc(strptr, sbackc(t));
                release(t);
        } else {
                l -= length(strptr);
                while (l-- > 0)
                        sputc(strptr, '0');
                if (neg != 0) {
                        sunputc(strptr);
                        sputc(strptr, '-');
                }
        }
}

struct blk *
add(struct blk *a1, struct blk *a2)
{
        struct blk *p;
        int carry, n;
        int size;
        int c, n1, n2;

        size = length(a1) > length(a2) ? length(a1) : length(a2);
        p = salloc(size);
        rewind(a1);
        rewind(a2);
        carry = 0;
        while (--size >= 0) {
                n1 = sfeof(a1) ? 0 : sgetc(a1);
                n2 = sfeof(a2) ? 0 : sgetc(a2);
                n = n1 + n2 + carry;
                if (n >= 100) {
                        carry = 1;
                        n -= 100;
                } else
                        if (n < 0) {
                                carry = -1;
                                n += 100;
                        } else
                                carry = 0;
                sputc(p, n);
        }
        if (carry != 0)
                sputc(p, carry);
        fsfile(p);
        if (sfbeg(p) == 0) {
                while (sfbeg(p) == 0 && (c = sbackc(p)) == 0);
                if (c != 0)
                        salterc(p, c);
                truncate(p);
        }
        fsfile(p);
        if (sfbeg(p) == 0 && sbackc(p) == -1) {
                while ((c = sbackc(p)) == 99) {
                        if (c == EOF)
                                break;
                }
                sgetc(p);
                salterc(p, -1);
                truncate(p);
        }
        return (p);
}

int
eqk(void) {
        struct blk *p, *q;
        int skp, skq;

        p = pop();
        EMPTYS;
        q = pop();
        EMPTYSR(p);
        skp = sunputc(p);
        skq = sunputc(q);
        if (skp == skq) {
                arg1 = p;
                arg2 = q;
                savk = skp;
                return (0);
        } else
                if (skp < skq) {
                        savk = skq;
                        p = add0(p, skq - skp);
                } else {
                        savk = skp;
                        q = add0(q, skp - skq);
                }
        arg1 = p;
        arg2 = q;
        return (0);
}

struct blk *
removc(struct blk *p, int n)
{
        struct blk *q, *r;

        rewind(p);
        while (n > 1) {
                sgetc(p);
                n -= 2;
        }
        q = salloc(2);
        while (sfeof(p) == 0)
                sputc(q, sgetc(p));
        if (n == 1) {
                r = dcdiv(q, tenptr);
                release(q);
                release(rem);
                q = r;
        }
        release(p);
        return (q);
}

struct blk *
scalint(struct blk *p)
{
        int n;

        n = sunputc(p);
        p = removc(p, n);
        return (p);
}

struct blk *
scale(struct blk *p, int n)
{
        struct blk *q, *s, *t;

        t = add0(p, n);
        q = salloc(1);
        sputc(q, n);
        s = exp(inbas, q);
        release(q);
        q = dcdiv(t, s);
        release(t);
        release(s);
        release(rem);
        sputc(q, n);
        return (q);
}

int
subt(void)
{
        arg1 = pop();
        EMPTYS;
        savk = sunputc(arg1);
        chsign(arg1);
        sputc(arg1, savk);
        pushp(arg1);
        if (eqk() != 0)
                return (1);
        binop('+');
        return (0);
}

int
command(void)
{
        int c;
        char line[100], *sl;
        void (*savint)();
        pid_t pid, rpid;
        int retcode;

        switch (c = readc()) {
        case '<':
                return (cond(NL));
        case '>':
                return (cond(NG));
        case '=':
                return (cond(NE));
        default:
                sl = line;
                *sl++ = c;
                while ((c = readc()) != '\n')
                        *sl++ = c;
                *sl = 0;
                if ((pid = fork()) == (pid_t)0) {
                        execl("/usr/bin/sh", "sh", "-c", line, 0);
                        exit(0100);
                }
                savint = signal(SIGINT, SIG_IGN);
                while ((rpid = wait(&retcode)) != pid && rpid != (pid_t)-1);
                signal(SIGINT, savint);
                printf(gettext("!\n"));
                return (0);
        }
}

int
cond(char c)
{
        struct blk *p;
        int cc;

        if (subt() != 0)
                return (1);
        p = pop();
        sunputc(p);
        if (length(p) == 0) {
                release(p);
                if (c == '<' || c == '>' || c == NE) {
                        readc();
                        return (0);
                }
                load();
                return (1);
        } else {
                if (c == '=') {
                        release(p);
                        readc();
                        return (0);
                }
        }
        if (c == NE) {
                release(p);
                load();
                return (1);
        }
        fsfile(p);
        cc = sbackc(p);
        release(p);
        if ((cc < 0 && (c == '<' || c == NG)) ||
            (cc > 0) && (c == '>' || c == NL)) {
                readc();
                return (0);
        }
        load();
        return (1);
}

void
load(void)
{
        int c;
        struct blk *p, *q, *t, *s;

        c = readc() & 0377;
        sptr = stable[c];
        if (sptr != 0) {
                p = sptr->val;
                if (c >= ARRAYST) {
                        q = salloc(length(p));
                        rewind(p);
                        while (sfeof(p) == 0) {
                                s = getwd(p);
                                if (s == 0)
                                        putwd(q, (struct blk *)NULL);
                                else {
                                        t = copy(s, length(s));
                                        putwd(q, t);
                                }
                        }
                        pushp(q);
                } else {
                        q = copy(p, length(p));
                        pushp(q);
                }
        } else {
                q = salloc(1);
                if (c <= LASTFUN) {
                        printf(gettext
                            ("function %c undefined\n"), c + 'a' - 1);
                        sputc(q, 'c');
                        sputc(q, '0');
                        sputc(q, ' ');
                        sputc(q, '1');
                        sputc(q, 'Q');
                } else
                        sputc(q, 0);
                pushp(q);
        }
}

int
log2(long n)
{
        int i;

        if (n == 0)
                return (0);
        i = 31;
        if (n < 0)
                return (i);
        while ((n = n << 1) > 0)
                i--;
        return (--i);
}

struct blk *
salloc(int size)
{
        struct blk *hdr;
        char *ptr;
        char *dcmalloc();
        all++;
        lall++;
        if (all - rel > active)
                active = all - rel;
        nbytes += size;
        lbytes += size;
        if (nbytes > maxsize)
                maxsize = nbytes;
        if (size > longest)
                longest = size;
        ptr = dcmalloc((unsigned)size);
        if (ptr == 0) {
                garbage("salloc");
                if ((ptr = dcmalloc((unsigned)size)) == 0)
                        ospace("salloc");
        }
        if ((hdr = hfree) == 0)
                hdr = morehd();
        hfree = (struct blk *)hdr->rd;
        hdr->rd = hdr->wt = hdr->beg = ptr;
        hdr->last = ptr + size;
        return (hdr);
}

struct blk *
morehd(void)
{
        struct blk *h, *kk;
        char *dcmalloc();

        headmor++;
        nbytes += HEADSZ;
        hfree = h = (struct blk *)dcmalloc(HEADSZ);
        if (hfree == 0) {
                garbage("morehd");
                if ((hfree = h = (struct blk *)dcmalloc(HEADSZ)) == 0)
                        ospace("headers");
        }
        kk = h;
        while (h < hfree + (HEADSZ/BLK))
                (h++)->rd = (char *)++kk;
        (--h)->rd = 0;
        return (hfree);
}

struct blk *
copy(struct blk *hptr, int size)
{
        struct blk *hdr;
        unsigned sz;
        char *ptr;

        all++;
        lall++;
        lcopy++;
        nbytes += size;
        lbytes += size;
        if (size > longest)
                longest = size;
        if (size > maxsize)
                maxsize = size;
        sz = length(hptr);
        ptr = nalloc(hptr->beg, (unsigned)size);
        if (ptr == 0) {
                garbage("copy");
                if ((ptr = nalloc(hptr->beg, (unsigned)size)) == NULL) {
                        printf(gettext("copy size %d\n"), size);
                        ospace("copy");
                }
        }
        if ((hdr = hfree) == 0)
                hdr = morehd();
        hfree = (struct blk *)hdr->rd;
        hdr->rd = hdr->beg = ptr;
        hdr->last = ptr + size;
        hdr->wt = ptr + sz;
        ptr = hdr->wt;
        while (ptr < hdr->last)
                *ptr++ = '\0';
        return (hdr);
}

void
sdump(char *s1, struct blk *hptr)
{
        char *p;

        if (hptr) {
                printf("%s %o rd %o wt %o beg %o last %o\n", s1, hptr,
                    hptr->rd, hptr->wt, hptr->beg, hptr->last);
                p = hptr->beg;
                while (p < hptr->wt)
                        printf("%d ", *p++);
                printf("\n");
        } else
                printf("%s %o\n", s1, hptr);
}

void
seekc(struct blk *hptr, int n)
{
        char *nn, *p;

        nn = hptr->beg + n;
        if (nn > hptr->last) {
                nbytes += nn - hptr->last;
                if (nbytes > maxsize)
                        maxsize = nbytes;
                lbytes += nn - hptr->last;
                if (n > longest)
                        longest = n;
                p = realloc(hptr->beg, (unsigned)n);
                if (p == 0) {
                        hptr->beg = realloc(hptr->beg,
                            (unsigned)(hptr->last - hptr->beg));
                        garbage("seekc");
                        if ((p = realloc(hptr->beg, (unsigned)n)) == 0)
                                ospace("seekc");
                }
                hptr->beg = p;
                hptr->wt = hptr->last = hptr->rd = p + n;
                return;
        }
        hptr->rd = nn;
        if (nn > hptr->wt)
                hptr->wt = nn;
}

void
salterwd(struct wblk *hptr, struct blk *n)
{
        if (hptr->rdw == hptr->lastw)
                more((struct blk *)hptr);
        *hptr->rdw++ = n;
        if (hptr->rdw > hptr->wtw)
                hptr->wtw = hptr->rdw;
}

void
more(struct blk *hptr)
{
        unsigned size;
        char *p;

        if ((size = (hptr->last - hptr->beg) * 2) == 0)
                size = 1;
        nbytes += size / 2;
        if (nbytes > maxsize)
                maxsize = nbytes;
        if (size > longest)
                longest = size;
        lbytes += size / 2;
        lmore++;
        p = realloc(hptr->beg, (unsigned)size);
        if (p == 0) {
                hptr->beg = realloc(hptr->beg,
                    (unsigned)(hptr->last - hptr->beg));
                garbage("more");
                if ((p = realloc(hptr->beg, size)) == 0)
                        ospace("more");
        }
        hptr->rd = hptr->rd - hptr->beg + p;
        hptr->wt = hptr->wt - hptr->beg + p;
        hptr->beg = p;
        hptr->last = p + size;
}

void
ospace(char *s)
{
        printf(gettext("out of space: %s\n"), s);
        printf(gettext("all %ld rel %ld headmor %ld\n"), all, rel, headmor);
        printf(gettext("nbytes %ld\n"), nbytes);
        sdump("stk", *stkptr);
        abort();
}

#define G1      gettext("array %o elt %d odd\n")
#define G2      gettext("tmps %o p %o\n")
void
garbage(char *s)
{
        int i;
        struct blk *p, *q;
        struct sym *tmps;
        int ct;

        printf(gettext("got to garbage %s\n"), s);
        for (i = 0; i < TBLSZ; i++) {
                tmps = stable[i];
                if (tmps != 0) {
                        if (i < ARRAYST) {
                                do {
                                        p = tmps->val;
                                        if (((int)p->beg & 01) != 0) {
                                                printf(gettext(
                                                    "string %o\n"), i);
                                                sdump("odd beg", p);
                                        }
                                        redef(p);
                                        tmps = tmps->next;
                                } while (tmps != 0);
                                continue;
                        } else {
                                do {
                                        p = tmps->val;
                                        rewind(p);
                                        ct = 0;
                                        while ((q = getwd(p)) != NULL) {
                                                ct++;
                                                if (q != 0) {
                                                        if (((int)q->beg & 01)
                                                            != 0) {
                                                                printf(G1,
                                                                    i - ARRAYST,
                                                                    ct);
                                                                printf(G2,
                                                                    tmps, p);
                                                                sdump("elt", q);
                                                        }
                                                        redef(q);
                                                }
                                        }
                                        tmps = tmps->next;
                                } while (tmps != 0);
                        }
                }
        }
}

void
redef(struct blk *p)
{
        int offset;
        char *newp;
        char *dcmalloc();

        if ((int)p->beg & 01) {
                printf(gettext("odd ptr %o hdr %o\n"), p->beg, p);
                ospace("redef-bad");
        }
        free(dummy);
        dummy = dcmalloc(0);
        if (dummy == NULL)
                ospace("dummy");
        newp = realloc(p->beg, (unsigned)(p->last - p->beg));
        if (newp == NULL)
                ospace("redef");
        offset = newp - p->beg;
        p->beg = newp;
        p->rd += offset;
        p->wt += offset;
        p->last += offset;
}

void
release(struct blk *p)
{
        rel++;
        lrel++;
        nbytes -= p->last - p->beg;
        p->rd = (char *)hfree;
        hfree = p;
        free(p->beg);
        p->beg = NULL;
}

struct blk *
getwd(struct blk *p)
{
        struct wblk *wp;

        wp = (struct wblk *)p;
        if (wp->rdw == wp->wtw)
                return (NULL);
        return (*wp->rdw++);
}

void
putwd(struct blk *p, struct blk *c)
{
        struct wblk *wp;

        wp = (struct wblk *)p;
        if (wp->wtw == wp->lastw)
                more(p);
        *wp->wtw++ = c;
}

struct blk *
lookwd(struct blk *p)
{
        struct wblk *wp;

        wp = (struct wblk *)p;
        if (wp->rdw == wp->wtw)
                return (NULL);
        return (*wp->rdw);
}

char *
nalloc(char *p, unsigned int nbytes)
{
        char *dcmalloc();
        char *q, *r;
        q = r = dcmalloc(nbytes);
        if (q == 0)
                return (0);
        while (nbytes--)
                *q++ = *p++;
        return (r);
}

char *
dcmalloc(int size)
{
        return (malloc(size ? size : 1));
}