usr/src/contrib/sc/cmds.c

/*      SC      A Spreadsheet Calculator
 *              Command routines
 *
 *              original by James Gosling, September 1982
 *              modifications by Mark Weiser and Bruce Israel,
 *                      University of Maryland
 *
 *              More mods Robert Bond, 12/86
 *
 *              $Revision: 6.8 $
 */

#include <curses.h>
#if defined(BSD42) || defined(BSD43)
#include <sys/file.h>
#else
#include <fcntl.h>
#endif
#include "sc.h"
#include <signal.h>
#include <errno.h>

#ifdef BSD42
#include <strings.h>
#else
#ifndef SYSIII
#include <string.h>
#endif
#endif

#ifdef SYSV3
extern void exit();
#else
extern int exit();
#endif

extern  int     errno;

#define DEFCOLDELIM ':'

void
duprow()
{
    if (currow >= maxrows - 1 || maxrow >= maxrows - 1) {
        if (!growtbl(GROWROW, 0, 0))
                return;
    }
    modflg++;
    currow++;
    openrow (currow);
    for (curcol = 0; curcol <= maxcol; curcol++) {
        register struct ent *p = *ATBL(tbl, currow - 1, curcol);
        if (p) {
            register struct ent *n;
            n = lookat (currow, curcol);
            (void)copyent ( n, p, 1, 0);
        }
    }
    for (curcol = 0; curcol <= maxcol; curcol++) {
        register struct ent *p = *ATBL(tbl, currow, curcol);
        if (p && (p -> flags & is_valid) && !p -> expr)
            break;
    }
    if (curcol > maxcol)
        curcol = 0;
}

void
dupcol()
{
    if (curcol >= maxcols - 1 || maxcol >= maxcols - 1) {
        if (!growtbl(GROWCOL, 0, 0))
                return;
    }
    modflg++;
    curcol++;
    opencol (curcol, 1);
    for (currow = 0; currow <= maxrow; currow++) {
        register struct ent *p = *ATBL(tbl, currow, curcol - 1);
        if (p) {
            register struct ent *n;
            n = lookat (currow, curcol);
            copyent ( n, p, 0, 1);
        }
    }
    for (currow = 0; currow <= maxrow; currow++) {
        register struct ent *p = *ATBL(tbl, currow, curcol);
        if (p && (p -> flags & is_valid) && !p -> expr)
            break;
    }
    if (currow > maxrow)
        currow = 0;
}

void
insertrow(arg)
register int arg;
{
    while (--arg>=0) openrow (currow);
}

void
deleterow(arg)
register int arg;
{
    flush_saved();
    erase_area(currow, 0, currow + arg - 1, maxcol);
    currow += arg;
    while (--arg>=0) closerow (--currow);
    sync_refs();
}

void
rowvalueize(arg)
register int arg;
{
    valueize_area(currow, 0, currow + arg - 1, maxcol);
}

void
colvalueize(arg)
register int arg;
{
    valueize_area(0, curcol, maxrow, curcol + arg - 1);
}

void
erase_area(sr, sc, er, ec)
int sr, sc, er, ec;
{
    register int r, c;
    register struct ent **pp;

    if (sr > er) {
        r = sr; sr = er; er= r;
    }

    if (sc > ec) {
        c = sc; sc = ec; ec= c;
    }

    if (sr < 0)
        sr = 0;
    if (sc < 0)
        sc = 0;
    checkbounds(&er, &ec);

    for (r = sr; r <= er; r++) {
        for (c = sc; c <= ec; c++) {
            pp = ATBL(tbl, r, c);
            if (*pp) {
                free_ent(*pp);
                *pp = (struct ent *)0;
            }
        }
    }
}

void
valueize_area(sr, sc, er, ec)
int sr, sc, er, ec;
{
    register int r, c;
    register struct ent *p;

    if (sr > er) {
        r = sr; sr = er; er= r;
    }

    if (sc > ec) {
        c = sc; sc = ec; ec= c;
    }

    if (sr < 0)
        sr = 0;
    if (sc < 0)
        sc = 0;
    checkbounds(&er, &ec);

    for (r = sr; r <= er; r++) {
        for (c = sc; c <= ec; c++) {
            p = *ATBL(tbl, r, c);
            if (p && p->expr) {
                efree(p, p->expr);
                p->expr = (struct enode *)0;
                p->flags &= ~is_strexpr;
            }
        }
    }

}

void
pullcells(to_insert)
int to_insert;
{
    register struct ent *p, *n;
    register int deltar, deltac;
    int minrow, mincol;
    int mxrow, mxcol;
    int numrows, numcols;

    if (! to_fix)
    {
        error ("No data to pull");
        return;
    }

    minrow = maxrows;
    mincol = maxcols;
    mxrow = 0;
    mxcol = 0;

    for (p = to_fix; p; p = p->next) {
        if (p->row < minrow)
            minrow = p->row;
        if (p->row > mxrow)
            mxrow = p->row;
        if (p->col < mincol)
            mincol = p->col;
        if (p->col > mxcol)
            mxcol = p->col;
    }

    numrows = mxrow - minrow + 1;
    numcols = mxcol - mincol + 1;
    deltar = currow - minrow;
    deltac = curcol - mincol;

    if (to_insert == 'r') {
        insertrow(numrows);
        deltac = 0;
    } else if (to_insert == 'c') {
        opencol(curcol, numcols);
        deltar = 0;
    }

    FullUpdate++;
    modflg++;

    for (p = to_fix; p; p = p->next) {
        n = lookat (p->row + deltar, p->col + deltac);
        (void) clearent(n);
        copyent( n, p, deltar, deltac);
        n -> flags = p -> flags & ~is_deleted;
    }
}

void
colshow_op()
{
    register int i,j;
    for (i=0; i<maxcols; i++)
        if (col_hidden[i])
            break;
    for(j=i; j<maxcols; j++)
        if (!col_hidden[j])
            break;
    j--;
    if (i>=maxcols)
        error ("No hidden columns to show");
    else {
        (void) sprintf(line,"show %s:", coltoa(i));
        (void) sprintf(line + strlen(line),"%s",coltoa(j));
        linelim = strlen (line);
    }
}

void
rowshow_op()
{
    register int i,j;
    for (i=0; i<maxrows; i++)
        if (row_hidden[i])
            break;
    for(j=i; j<maxrows; j++)
        if (!row_hidden[j]) {
            break;
        }
    j--;

    if (i>=maxrows)
        error ("No hidden rows to show");
    else {
        (void) sprintf(line,"show %d:%d", i, j);
        linelim = strlen (line);
    }
}

/*
 * Given a row/column command letter, emit a small menu, then read a qualifier
 * character for a row/column command and convert it to 'r' (row), 'c'
 * (column), or 0 (unknown).  If ch is 'p', an extra qualifier 'm' is allowed.
 */

int
get_rcqual (ch)
    int ch;
{
    error ("%sow/column:  r: row  c: column%s",

            (ch == 'i') ? "Insert r" :
            (ch == 'a') ? "Append r" :
            (ch == 'd') ? "Delete r" :
            (ch == 'p') ? "Pull r" :
            (ch == 'v') ? "Values r" :
            (ch == 'z') ? "Zap r" :
            (ch == 's') ? "Show r" : "R",

            (ch == 'p') ? "  m: merge" : "");

    (void) refresh();

    switch (nmgetch())
    {
        case 'r':
        case 'l':
        case 'h':
        case ctl('f'):
        case ctl('b'):  return ('r');

        case 'c':
        case 'j':
        case 'k':
        case ctl('p'):
        case ctl('n'):  return ('c');

        case 'm':       return ((ch == 'p') ? 'm' : 0);

        case ESC:
        case ctl('g'):  return (ESC);

        default:        return (0);
    }
    /*NOTREACHED*/
}

void
openrow (rs)
int     rs;
{
    register    r, c;
    struct ent  **tmprow, **pp;

    if (rs > maxrow) maxrow = rs;
    if (maxrow >= maxrows - 1 || rs > maxrows - 1) {
        if (!growtbl(GROWROW, rs, 0))
                return;
    }
        /*
         * save the last active row+1, shift the rows downward, put the last
         * row in place of the first
         */
    tmprow = tbl[++maxrow];
    for (r = maxrow; r > rs; r--) {
        row_hidden[r] = row_hidden[r-1];
        tbl[r] = tbl[r-1];
        pp = ATBL(tbl, r, 0);
        for (c = 0; c < maxcols; c++, pp++)
                if (*pp)
                        (*pp)->row = r;
    }
    tbl[r] = tmprow;    /* the last row was never used.... */
    FullUpdate++;
    modflg++;
}

void
closerow (r)
register r;
{
    register struct ent **pp;
    register c;
    struct ent  **tmprow;

    if (r > maxrow) return;

    /* save the row and empty it out */
    tmprow = tbl[r];
    pp = ATBL(tbl, r, 0);
    for (c=maxcol+1; --c>=0; pp++) {
        if (*pp)
        {       free_ent(*pp);
                *pp = (struct ent *)0;
        }
    }

    /* move the rows, put the deleted row at the end */
    for (; r < maxrows - 1; r++) {
        row_hidden[r] = row_hidden[r+1];
        tbl[r] = tbl[r+1];
        pp = ATBL(tbl, r, 0);
        for (c = 0; c < maxcols; c++, pp++)
                if (*pp)
                        (*pp)->row = r;
    }
    tbl[r] = tmprow;

    maxrow--;
    FullUpdate++;
    modflg++;
}

void
opencol (cs, numcol)
int     cs;
int     numcol;
{
    register r;
    register struct ent **pp;
    register c;
    register lim = maxcol-cs+1;
    int i;

    if (cs > maxcol)
        maxcol = cs;
    maxcol += numcol;

    if ((maxcol >= maxcols - 1) && !growtbl(GROWCOL, 0, maxcol))
                return;

    for (i = maxcol; i > cs; i--) {
        fwidth[i] = fwidth[i-numcol];
        precision[i] = precision[i-numcol];
        col_hidden[i] = col_hidden[i-numcol];
    }
    for (c = cs; c - cs < numcol; c++)
    {   fwidth[c] = DEFWIDTH;
        precision[c] =  DEFPREC;
    }

    for (r=0; r<=maxrow; r++) {
        pp = ATBL(tbl, r, maxcol);
        for (c=lim; --c>=0; pp--)
            if (pp[0] = pp[-numcol])
                pp[0]->col += numcol;

        pp = ATBL(tbl, r, cs);
        for (c = cs; c - cs < numcol; c++, pp++)
                *pp = (struct ent *)0;
    }
    FullUpdate++;
    modflg++;
}

void
closecol (cs, numcol)
int cs;
int     numcol;
{
    register r;
    register struct ent **pp;
    register struct ent *q;
    register c;
    register lim = maxcol-cs;
    int i;
    char buf[50];

    if (lim - numcol < -1)
    {   sprintf(buf, "Can't delete %d column%s %d columns left", numcol,
                        (numcol > 1 ? "s," : ","), lim+1);
        error(buf);
        return;
    }
    flush_saved();
    erase_area(0, curcol, maxrow, curcol + numcol - 1);
    sync_refs();

    /* clear then copy the block left */
    lim = maxcols - numcol - 1;
    for (r=0; r<=maxrow; r++) {
        for (c = cs; c - cs < numcol; c++)
                if (q = *ATBL(tbl, r, c))
                        free_ent(q);

        pp = ATBL(tbl, r, cs);
        for (c=cs; c <= lim; c++, pp++)
        {   if (c > lim)
                *pp = (struct ent *)0;
            else
            if (pp[0] = pp[numcol])
                pp[0]->col -= numcol;
        }

        c = numcol;
        for (; --c >= 0; pp++)
                *pp = (struct ent *)0;
    }

    for (i = cs; i < maxcols - numcol - 1; i++) {
        fwidth[i] = fwidth[i+numcol];
        precision[i] = precision[i+numcol];
        col_hidden[i] = col_hidden[i+numcol];
    }
    for (; i < maxcols - 1; i++) {
        fwidth[i] = DEFWIDTH;
        precision[i] = DEFPREC;
        col_hidden[i] = 0;
    }

    maxcol -= numcol;
    FullUpdate++;
    modflg++;
}

void
doend(rowinc, colinc)
int rowinc, colinc;
{
    register struct ent *p;
    int r, c;

    if (VALID_CELL(p, currow, curcol)) {
        r = currow + rowinc;
        c = curcol + colinc;
        if (r >= 0 && r < maxrows &&
            c >= 0 && c < maxcols &&
            !VALID_CELL(p, r, c)) {
                currow = r;
                curcol = c;
        }
    }

    if (!VALID_CELL(p, currow, curcol)) {
        switch (rowinc) {
        case -1:
            while (!VALID_CELL(p, currow, curcol) && currow > 0)
                currow--;
            break;
        case  1:
            while (!VALID_CELL(p, currow, curcol) && currow < maxrows-1)
                currow++;
            break;
        case  0:
            switch (colinc) {
            case -1:
                while (!VALID_CELL(p, currow, curcol) && curcol > 0)
                    curcol--;
                break;
            case  1:
                while (!VALID_CELL(p, currow, curcol) && curcol < maxcols-1)
                    curcol++;
                break;
            }
            break;
        }

        error ("");     /* clear line */
        return;
    }

    switch (rowinc) {
    case -1:
        while (VALID_CELL(p, currow, curcol) && currow > 0)
            currow--;
        break;
    case  1:
        while (VALID_CELL(p, currow, curcol) && currow < maxrows-1)
            currow++;
        break;
    case  0:
        switch (colinc) {
        case -1:
            while (VALID_CELL(p, currow, curcol) && curcol > 0)
                curcol--;
            break;
        case  1:
            while (VALID_CELL(p, currow, curcol) && curcol < maxcols-1)
                curcol++;
            break;
        }
        break;
    }
    if (!VALID_CELL(p, currow, curcol)) {
        currow -= rowinc;
        curcol -= colinc;
    }
}

void
doformat(c1,c2,w,p)
int c1,c2,w,p;
{
    register int i;

    if (w > COLS - RESCOL - 2) {
        error("Format too large - Maximum = %d", COLS - RESCOL - 2);
        w = COLS-RESCOL-2;
    }

    if (p > w) {
        error("Precision too large");
        p = w;
    }

    for(i = c1; i<=c2; i++)
        fwidth[i] = w, precision[i] = p;

    FullUpdate++;
    modflg++;
}

void
print_options(f)
FILE *f;
{
    if(
       autocalc &&
       propagation == 10 &&
       calc_order == BYROWS &&
       !numeric &&
       prescale == 1.0 &&
       !extfunc &&
       showcell &&
       showtop &&
       tbl_style == 0
      )
                return;         /* No reason to do this */

    (void) fprintf(f, "set");
    if(!autocalc)
        (void) fprintf(f," !autocalc");
    if(propagation != 10)
        (void) fprintf(f, " iterations = %d", propagation);
    if(calc_order != BYROWS )
        (void) fprintf(f, " bycols");
    if (numeric)
        (void) fprintf(f, " numeric");
    if (prescale != 1.0)
        (void) fprintf(f, " prescale");
    if (extfunc)
        (void) fprintf(f, " extfun");
    if (!showcell)
        (void) fprintf(f, " !cellcur");
    if (!showtop)
        (void) fprintf(f, " !toprow");
    if (tbl_style)
        (void) fprintf(f, " tblstyle = %s", tbl_style == TBL ? "tbl" :
                                        tbl_style == LATEX ? "latex" :
                                        tbl_style == TEX ? "tex" : "0" );
    (void) fprintf(f, "\n");
}

void
printfile (fname, r0, c0, rn, cn)
char *fname;
int r0, c0, rn, cn;
{
    FILE *f;
    char pline[FBUFLEN];
    int plinelim;
    int pid;
    int fieldlen, nextcol;
    register row, col;
    register struct ent **pp;

    if ((strcmp(fname, curfile) == 0) &&
        !yn_ask("Confirm that you want to destroy the data base: (y,n)"))
        return;

    if ((f = openout(fname, &pid)) == (FILE *)0)
    {   error ("Can't create file \"%s\"", fname);
        return;
    }
    for (row=r0;row<=rn; row++) {
        register c = 0;

        if (row_hidden[row])
            continue;

        pline[plinelim=0] = '\0';
        for (pp = ATBL(tbl, row, col=c0); col<=cn;
                pp += nextcol-col, col = nextcol, c += fieldlen) {

            nextcol = col+1;
            if (col_hidden[col]) {
                fieldlen = 0;
                continue;
            }

            fieldlen = fwidth[col];
            if (*pp) {
                char *s;

                while (plinelim<c) pline[plinelim++] = ' ';
                plinelim = c;
                if ((*pp)->flags&is_valid) {
                    (void)sprintf (pline+plinelim,"%*.*f",fwidth[col],
                                                precision[col], (*pp)->v);
                    plinelim += strlen (pline+plinelim);
                }
                if (s = (*pp)->label) {
                    int slen;
                    char *start, *last;
                    register char *fp;
                    struct ent *nc;

                    /* Figure out if the label slops over to a blank field */
                    slen = strlen(s);
                    while (slen > fieldlen && nextcol <= cn &&
                            !((nc = lookat(row,nextcol))->flags & is_valid) &&
                            !(nc->label)) {

                        if (!col_hidden[nextcol])
                            fieldlen += fwidth[nextcol];

                        nextcol++;
                    }
                    if (slen > fieldlen)
                        slen = fieldlen;

                    /* Now justify and print */
                    start = (*pp)->flags & is_leftflush ? pline + c
                                        : pline + c + fieldlen - slen;
                    last = pline + c + fieldlen;
                    fp = plinelim < c ? pline + plinelim : pline + c;
                    while (fp < start)
                        *fp++ = ' ';
                    while (slen--)
                        *fp++ = *s++;
                    if (!((*pp)->flags & is_valid) || fieldlen != fwidth[col])
                        while(fp < last)
                            *fp++ = ' ';
                    if (plinelim < fp - pline)
                        plinelim = fp - pline;
                }
            }
        }
        pline[plinelim++] = '\n';
        pline[plinelim] = '\0';
        (void) fputs (pline, f);
    }

    closeout(f, pid);
}

void
tblprintfile (fname, r0, c0, rn, cn)
char *fname;
int r0, c0, rn, cn;
{
    FILE *f;
    int pid;
    register row, col;
    register struct ent **pp;
    char coldelim = DEFCOLDELIM;

    if ((strcmp(fname, curfile) == 0) &&
        !yn_ask("Confirm that you want to destroy the data base: (y,n)"))
            return;

    if ((f = openout(fname, &pid)) == (FILE *)0)
    {   error ("Can't create file \"%s\"", fname);
        return;
    }

    if ( tbl_style == TBL ) {
        fprintf(f,".\\\" ** %s spreadsheet output \n.TS\n",progname);
        fprintf(f,"tab(%c);\n",coldelim);
        for (col=c0;col<=cn; col++) fprintf(f," n");
        fprintf(f, ".\n");
        }
    else if ( tbl_style == LATEX ) {
        fprintf(f,"%% ** %s spreadsheet output\n\\begin{tabular}{",progname);
        for (col=c0;col<=cn; col++) fprintf(f,"c");
        fprintf(f, "}\n");
        coldelim = '&';
        }
    else if ( tbl_style == TEX ) {
        fprintf(f,"{\t%% ** %s spreadsheet output\n\\settabs %d \\columns\n",
                progname, cn-c0+1);
        coldelim = '&';
        }

    for (row=r0; row<=rn; row++) {
        if ( tbl_style == TEX )
            (void) fprintf (f, "\\+");

        for (pp = ATBL(tbl, row, col=c0); col<=cn; col++, pp++) {
            if (*pp) {
                char *s;
                if ((*pp)->flags&is_valid) {
                    (void) fprintf (f,"%.*f",precision[col],
                                (*pp)->v);
                }
                if (s = (*pp)->label) {
                    (void) fprintf (f,"%s",s);
                }
            }
            if ( col < cn )
                (void) fprintf(f,"%c",coldelim);
        }
        if ( tbl_style == LATEX ) {
            if ( row < rn ) (void) fprintf (f, "\\\\");
            }
        else if ( tbl_style == TEX ) {
            (void) fprintf (f, "\\cr");
            }
        (void) fprintf (f,"\n");
    }

    if ( tbl_style == TBL )
    (void) fprintf (f,".TE\n.\\\" ** end of %s spreadsheet output\n", progname);
    else if ( tbl_style == LATEX )
    (void) fprintf (f,"\\end{tabular}\n%% ** end of %s spreadsheet output\n", progname);
    else if ( tbl_style == TEX )
    (void) fprintf (f,"}\n%% ** end of %s spreadsheet output\n", progname);

    closeout(f, pid);
}

struct enode *
copye (e, Rdelta, Cdelta)
register struct enode *e;
int Rdelta, Cdelta;
{
    register struct enode *ret;

    if (e == (struct enode *)0) {
        ret = (struct enode *)0;
    } else if (e->op & REDUCE) {
        int newrow, newcol;
        ret = (struct enode *) xmalloc ((unsigned) sizeof (struct enode));
        ret->op = e->op;
        newrow=e->e.r.left.vf & FIX_ROW ? e->e.r.left.vp->row :
                                          e->e.r.left.vp->row+Rdelta;
        newcol=e->e.r.left.vf & FIX_COL ? e->e.r.left.vp->col :
                                          e->e.r.left.vp->col+Cdelta;
        ret->e.r.left.vp = lookat (newrow, newcol);
        ret->e.r.left.vf = e->e.r.left.vf;
        newrow=e->e.r.right.vf & FIX_ROW ? e->e.r.right.vp->row :
                                           e->e.r.right.vp->row+Rdelta;
        newcol=e->e.r.right.vf & FIX_COL ? e->e.r.right.vp->col :
                                           e->e.r.right.vp->col+Cdelta;
        ret->e.r.right.vp = lookat (newrow, newcol);
        ret->e.r.right.vf = e->e.r.right.vf;
    } else {
        ret = (struct enode *) xmalloc ((unsigned) sizeof (struct enode));
        ret->op = e->op;
        switch (ret->op) {
        case 'v':
                {
                    int newrow, newcol;
                    newrow=e->e.v.vf & FIX_ROW ? e->e.v.vp->row :
                                                 e->e.v.vp->row+Rdelta;
                    newcol=e->e.v.vf & FIX_COL ? e->e.v.vp->col :
                                                 e->e.v.vp->col+Cdelta;
                    ret->e.v.vp = lookat (newrow, newcol);
                    ret->e.v.vf = e->e.v.vf;
                    break;
                }
        case 'k':
                ret->e.k = e->e.k;
                break;
        case 'f':
                ret->e.o.right = copye (e->e.o.right,0,0);
                ret->e.o.left = (struct enode *)0;
                break;
        case '$':
                ret->e.s = xmalloc((unsigned) strlen(e->e.s)+1);
                (void) strcpy(ret->e.s, e->e.s);
                break;
        default:
                ret->e.o.right = copye (e->e.o.right,Rdelta,Cdelta);
                ret->e.o.left = copye (e->e.o.left,Rdelta,Cdelta);
                break;
        }
    }
    return ret;
}

/*
 * sync_refs and syncref are used to remove references to
 * deleted struct ents.  Note that the deleted structure must still
 * be hanging around before the call, but not referenced by an entry
 * in tbl.  Thus the free_ent, fix_ent calls in sc.c
 */
void
sync_refs ()
{
    register i,j;
    register struct ent *p;
    sync_ranges();
    for (i=0; i<=maxrow; i++)
        for (j=0; j<=maxcol; j++)
            if ((p = *ATBL(tbl, i, j)) && p->expr)
                syncref(p->expr);
}

void
syncref(e)
register struct enode *e;
{
    if (e == (struct enode *)0)
        return;
    else if (e->op & REDUCE) {
        e->e.r.right.vp = lookat(e->e.r.right.vp->row, e->e.r.right.vp->col);
        e->e.r.left.vp = lookat(e->e.r.left.vp->row, e->e.r.left.vp->col);
    } else {
        switch (e->op) {
        case 'v':
                e->e.v.vp = lookat(e->e.v.vp->row, e->e.v.vp->col);
                break;
        case 'k':
                break;
        case '$':
                break;
        default:
                syncref(e->e.o.right);
                syncref(e->e.o.left);
                break;
        }
    }
}

void
hiderow(arg)
int arg;
{
    register int r1;
    register int r2;

    r1 = currow;
    r2 = r1 + arg - 1;
    if (r1 < 0 || r1 > r2) {
        error ("Invalid range");
        return;
    }
    if (r2 >= maxrows-1)
    {   if (!growtbl(GROWROW, arg+1, 0))
        {       error("You can't hide the last row");
                return;
        }
    }
    FullUpdate++;
    modflg++;
    while (r1 <= r2)
        row_hidden[r1++] = 1;
}

void
hidecol(arg)
int arg;
{
    register int c1;
    register int c2;

    c1 = curcol;
    c2 = c1 + arg - 1;
    if (c1 < 0 || c1 > c2) {
        error ("Invalid range");
        return;
    }
    if (c2 >= maxcols-1)
    {   if ((arg >= ABSMAXCOLS-1) || !growtbl(GROWCOL, 0, arg+1))
        {       error("You can't hide the last col");
                return;
        }
    }
    FullUpdate++;
    modflg++;
    while (c1 <= c2)
        col_hidden[c1++] = 1;
}

void
showrow(r1, r2)
int r1, r2;
{
    if (r1 < 0 || r1 > r2) {
        error ("Invalid range");
        return;
    }
    if (r2 > maxrows-1) {
        r2 = maxrows-1;
    }
    FullUpdate++;
    modflg++;
    while (r1 <= r2)
        row_hidden[r1++] = 0;
}

void
showcol(c1, c2)
int c1, c2;
{
    if (c1 < 0 || c1 > c2) {
        error ("Invalid range");
        return;
    }
    if (c2 > maxcols-1) {
        c2 = maxcols-1;
    }
    FullUpdate++;
    modflg++;
    while (c1 <= c2)
        col_hidden[c1++] = 0;
}

/* Open the output file, setting up a pipe if needed */

FILE *
openout(fname, rpid)
char *fname;
int *rpid;
{
    int pipefd[2];
    int pid;
    FILE *f;
    char *efname;

    while (*fname && (*fname == ' '))  /* Skip leading blanks */
        fname++;

    if (*fname != '|') {                /* Open file if not pipe */
        *rpid = 0;

        efname = findhome(fname);
#ifdef DOBACKUPS
        if (!backup_file(efname) &&
            (yn_ask("Could not create backup copy, Save anyhow?: (y,n)") != 1))
                return(0);
#endif
        return(fopen(efname, "w"));
    }

    fname++;                            /* Skip | */
    if ( pipe (pipefd) < 0) {
        error("Can't make pipe to child");
        *rpid = 0;
        return(0);
    }

    deraw();
#ifdef VMS
    fprintf(stderr, "No son tasks available yet under VMS--sorry\n");
#else /* VMS */

    if ((pid=fork()) == 0)                        /* if child  */
    {
        (void) close (0);                         /* close stdin */
        (void) close (pipefd[1]);
        (void) dup (pipefd[0]);           /* connect to pipe input */
        (void) signal (SIGINT, SIG_DFL);          /* reset */
        (void) execl ("/bin/sh", "sh", "-c", fname, 0);
        exit (-127);
    }
    else                                  /* else parent */
    {
        *rpid = pid;
        if ((f = fdopen (pipefd[1], "w")) == (FILE *)0)
        {
            (void) kill (pid, -9);
            error ("Can't fdopen output");
            (void) close (pipefd[1]);
            *rpid = 0;
            return(0);
        }
    }
#endif /* VMS */
    return(f);
}

void
closeout(f, pid)
FILE *f;
int pid;
{
    int temp;

    (void) fclose (f);
    if (pid) {
         while (pid != wait(&temp)) /**/;
         (void) printf("Press RETURN to continue ");
         (void) fflush(stdout);
         (void) nmgetch();
         goraw();
    }
}

void
copyent(n,p,dr,dc)
            register struct ent *n, *p;
            int dr, dc;
{
    if(!n||!p){error("internal error");return;}
    n -> v = p -> v;
    n -> flags = p -> flags;
    n -> expr = copye (p -> expr, dr, dc);
    n -> label = (char *)0;
    if (p -> label) {
        n -> label = (char *)
                xmalloc  ((unsigned) (strlen (p -> label) + 1));
        (void) strcpy (n -> label, p -> label);
    }
}

void
write_fd (f, r0, c0, rn, cn)
register FILE *f;
int r0, c0, rn, cn;
{
    register struct ent **pp;
    register r, c;

    (void) fprintf (f, "# This data file was generated by the Spreadsheet ");
    (void) fprintf (f, "Calculator.\n");
    (void) fprintf (f, "# You almost certainly shouldn't edit it.\n\n");
    print_options(f);
    for (c=0; c<maxcols; c++)
        if (fwidth[c] != DEFWIDTH || precision[c] != DEFPREC)
            (void) fprintf (f, "format %s %d %d\n",coltoa(c),fwidth[c],precision[c]);
    for (c=c0; c<cn; c++) {
        if (col_hidden[c]) {
            (void) fprintf(f, "hide %s\n", coltoa(c));
        }
    }
    for (r=r0; r<=rn; r++) {
        if (row_hidden[r]) {
            (void) fprintf(f, "hide %d\n", r);
        }
    }

    write_range(f);

    if (mdir)
            (void) fprintf(f, "mdir \"%s\"\n", mdir);
    for (r=r0; r<=rn; r++) {
        pp = ATBL(tbl, r, c0);
        for (c=c0; c<=cn; c++, pp++)
            if (*pp) {
                if ((*pp)->label) {
                    edits(r,c);
                    (void) fprintf(f, "%s\n",line);
                }
                if ((*pp)->flags&is_valid) {
                    editv (r, c);
                    (void) fprintf (f, "%s\n",line);
                }
            }
    }
}

int
writefile (fname, r0, c0, rn, cn)
char *fname;
int r0, c0, rn, cn;
{
    register FILE *f;
    char save[PATHLEN];
    int pid;

#ifndef VMS
    if (Crypt) {
        return (cwritefile(fname, r0, c0, rn, cn));
    }
#endif /* VMS */

    if (*fname == '\0') fname = curfile;

    (void) strcpy(save,fname);

    if ((f= openout(fname, &pid)) == (FILE *)0)
    {   error ("Can't create file \"%s\"", fname);
        return (-1);
    }

    write_fd(f, r0, c0, rn, cn);

    closeout(f, pid);

    if (!pid) {
        (void) strcpy(curfile, save);
        modflg = 0;
        error("File \"%s\" written.",curfile);
    }

    return (0);
}

void
readfile (fname,eraseflg)
char *fname;
int eraseflg;
{
    register FILE *f;
    char save[PATHLEN];

    if (*fname == '*' && mdir) {
       (void) strcpy(save, mdir);
       *fname = '/';
       (void) strcat(save, fname);
    } else {
        if (*fname == '\0')
            fname = curfile;
        (void) strcpy(save,fname);
    }

#ifndef VMS
    if (Crypt)  {
        creadfile(save, eraseflg);
        return;
    }
#endif /* VMS */

    if (eraseflg && strcmp(fname,curfile) && modcheck(" first")) return;

    if ((f = fopen(findhome(save), "r")) == (FILE *)0)
    {   error ("Can't read file \"%s\"", save);
        return;
    }

    if (eraseflg) erasedb ();

    loading++;
    while (fgets(line,sizeof line,f)) {
        linelim = 0;
        if (line[0] != '#') (void) yyparse ();
    }
    --loading;
    (void) fclose (f);
    linelim = -1;
    modflg++;
    if (eraseflg) {
        (void) strcpy(curfile,save);
        modflg = 0;
    }
    EvalAll();
}

void
erasedb ()
{
    register r, c;
    for (c = 0; c<=maxcol; c++) {
        fwidth[c] = DEFWIDTH;
        precision[c] = DEFPREC;
    }

    for (r = 0; r<=maxrow; r++) {
        register struct ent **pp = ATBL(tbl, r, 0);
        for (c=0; c++<=maxcol; pp++)
            if (*pp) {
                if ((*pp)->expr) efree (*pp, (*pp) -> expr);
                if ((*pp)->label) xfree ((char *)((*pp) -> label));
                xfree ((char *)(*pp));
                *pp = (struct ent *)0;
            }
    }
    maxrow = 0;
    maxcol = 0;
    clean_range();
    FullUpdate++;
}

void
backcol(arg)
        int arg;
{
    while (--arg>=0) {
        if (curcol)
            curcol--;
        else
            {error ("At column A"); break;}
        while(col_hidden[curcol] && curcol)
            curcol--;
    }
}

void
forwcol(arg)
        int arg;
{
    while (--arg>=0) {
        if (curcol < maxcols - 1)
            curcol++;
        else
        if (!growtbl(GROWCOL, 0, arg))  /* get as much as needed */
                break;
        while(col_hidden[curcol]&&(curcol<maxcols-1))
            curcol++;
    }
}

void
forwrow(arg)
        int arg;
{
    while (--arg>=0) {
        if (currow < maxrows - 1)
            currow++;
        else
        if (!growtbl(GROWROW, arg, 0))  /* get as much as needed */
                break;
        while (row_hidden[currow]&&(currow<maxrows-1))
            currow++;
    }
}

void
backrow(arg)
        int arg;
{
    while (--arg>=0) {
        if (currow)
            currow--;
        else
            {error ("At row zero"); break;}
        while (row_hidden[currow] && currow)
            currow--;
    }
}


/*
 * Show a cell's label string or expression value.  May overwrite value if
 * there is one already displayed in the cell.  Created from old code in
 * update(), copied with minimal changes.
 */

void
showstring (string, leftflush, hasvalue, row, col, nextcolp, mxcol, fieldlenp, r, c)
    char *string;       /* to display */
    int leftflush;      /* or rightflush */
    int hasvalue;       /* is there a numeric value? */
    int row, col;       /* spreadsheet location */
    int *nextcolp;      /* value returned through it */
    int mxcol;          /* last column displayed? */
    int *fieldlenp;     /* value returned through it */
    int r, c;           /* screen row and column */
{
    register int nextcol  = *nextcolp;
    register int fieldlen = *fieldlenp;

    char field[FBUFLEN];
    int  slen;
    char *start, *last;
    register char *fp;
    struct ent *nc;

    /* This figures out if the label is allowed to
       slop over into the next blank field */

    slen = strlen (string);
    while ((slen > fieldlen) && (nextcol <= mxcol) &&
           !((nc = lookat (row, nextcol)) -> flags & is_valid) &&
           !(nc->label)) {

        if (! col_hidden [nextcol])
            fieldlen += fwidth [nextcol];

        nextcol++;
    }
    if (slen > fieldlen)
        slen = fieldlen;

    /* Now justify and print */
    start = leftflush ? field : field + fieldlen - slen;
    last = field+fieldlen;
    fp = field;
    while (fp < start)
        *fp++ = ' ';
    while (slen--)
        *fp++ = *string++;
    if ((! hasvalue) || fieldlen != fwidth[col])
        while (fp < last)
            *fp++ = ' ';
    *fp = '\0';
#ifdef VMS
    mvaddstr(r, c, field);      /* this is a macro */
#else
    (void) mvaddstr(r, c, field);
#endif

    *nextcolp  = nextcol;
    *fieldlenp = fieldlen;
}

int
etype(e)
register struct enode *e;
{
    if (e == (struct enode *)0)
        return NUM;
    switch (e->op) {
    case O_SCONST: case '#': case DATE: case FMT: case STINDEX:
    case EXT: case SVAL: case SUBSTR:
        return (STR);

    case '?':
    case IF:
        return(etype(e->e.o.right->e.o.left));

    case 'f':
        return(etype(e->e.o.right));

    case O_VAR: {
        register struct ent *p;
        p = e->e.v.vp;
        if (p->expr)
            return(p->flags & is_strexpr ? STR : NUM);
        else if (p->label)
            return(STR);
        else
            return(NUM);
        }

    default:
        return(NUM);
    }
}

/* return 1 if yes given, 0 otherwise */
int
yn_ask(msg)
char    *msg;
{       char ch;

        (void) move (0, 0);
        (void) clrtoeol ();
        (void) addstr (msg);
        (void) refresh();
        ch = nmgetch();
        if ( ch != 'y' && ch != 'Y' && ch != 'n' && ch != 'N' ) {
                if (ch == ctl('g') || ch == ESC)
                        return(-1);
                error("y or n response required");
                return (-1);
        }
        if (ch == 'y' || ch == 'Y')
                return(1);
        else
                return(0);
}

#include <pwd.h>
char    *
findhome(path)
char    *path;
{
        static  char    *HomeDir = NULL;
        extern  char    *getenv();

        if (*path == '~')
        {       char    *pathptr;
                char    tmppath[PATHLEN];

                if (HomeDir == NULL)
                {       HomeDir = getenv("HOME");
                        if (HomeDir == NULL)
                                HomeDir = "/";
                }
                pathptr = path + 1;
                if ((*pathptr == '/') || (*pathptr == '\0'))
                {       strcpy(tmppath, HomeDir);
                }
                else
                {       struct  passwd *pwent;
                        extern  struct  passwd *getpwnam();
                        char    *namep;
                        char    name[50];

                        namep = name;
                        while ((*pathptr != '\0') && (*pathptr != '/'))
                                *(namep++) = *(pathptr++);
                        *namep = '\0';
                        if ((pwent = getpwnam(name)) == NULL)
                        {       sprintf(path, "Can't find user %s", name);
                                return(NULL);
                        }
                        strcpy(tmppath, pwent->pw_dir);
                }

                strcat(tmppath, pathptr);
                strcpy(path, tmppath);
        }
        return(path);
}

#ifdef DOBACKUPS
#include <sys/types.h>
#include <sys/stat.h>

/*
 * make a backup copy of a file, use the same mode and name in the format
 * [path/]#file~
 * return 1 if we were successful, 0 otherwise
 */
int
backup_file(path)
char    *path;
{
        struct  stat    statbuf;
        char    fname[PATHLEN];
        char    tpath[PATHLEN];
#ifdef sequent
        char    *buf;
#else
        char    buf[BUFSIZ];
#endif
        char    *tpp;
        int     infd, outfd;
        int     count;

        /* tpath will be the [path/]file ---> [path/]#file~ */
        strcpy(tpath, path);
        if ((tpp = strrchr(tpath, '/')) == NULL)
                tpp = tpath;
        else
                tpp++;
        strcpy(fname, tpp);
        sprintf(tpp, "#%s~", fname);

        if (stat(path, &statbuf) == 0)
        {
#ifdef sequent
                if ((buf = xmalloc(statbuf.st_blksize)) == (char *)0)
                        return(0);
#endif

                if ((infd = open(path, O_RDONLY, 0)) < 0)
                {
#ifdef sequent
                        xfree(buf);
#endif
                        return(0);
                }
                if ((outfd = open(tpath, O_TRUNC|O_WRONLY|O_CREAT,
                                        statbuf.st_mode)) < 0)
                {
#ifdef sequent
                        xfree(buf);
#endif
                        return(0);
                }
#ifdef sequent
                while((count = read(infd, buf, statbuf.st_blksize)) > 0)
#else
                while((count = read(infd, buf, sizeof(buf))) > 0)
#endif
                {       if (write(outfd, buf, count) != count)
                        {       count = -1;
                                break;
                        }
                }
                close(infd);
                close(outfd);
#ifdef sequent
                xfree(buf);
#endif
                return((count < 0) ? 0 : 1);
        }
        else
        if (errno == ENOENT)
                return(1);
        return(0);
}
#endif