/* SC A Spreadsheet Calculator * Expression interpreter and assorted support routines. * * original by James Gosling, September 1982 * modified by Mark Weiser and Bruce Israel, * University of Maryland * * More mods Robert Bond, 12/86 * More mods by Alan Silverstein, 3-4/88, see list of changes. * $Revision: 6.8 $ */ #define DEBUGDTS 1 /* REMOVE ME */ /* #define EXPRTREE /* expr. dependency tree stuff, not ready yet */ #ifdef aiws #undef _C_func /* Fixes for undefined symbols on AIX */ #endif #ifdef IEEE_MATH #include <ieeefp.h> #endif /* IEEE_MATH */ #include <math.h> #include <signal.h> #include <setjmp.h> #include <stdio.h> extern int errno; /* set by math functions */ #ifdef BSD42 #include <strings.h> #include <sys/time.h> #ifndef strchr #define strchr index #endif #else #include <time.h> #ifndef SYSIII #include <string.h> #endif #endif #include <curses.h> #include "sc.h" #if defined(BSD42) || defined(BSD43) char *re_comp(); #endif #if defined(SYSV2) || defined(SYSV3) char *regcmp(); char *regex(); #endif #ifdef SIGVOID void quit(); #else int quit(); #endif /* Use this structure to save the the last 'g' command */ struct go_save { int g_type; double g_n; char *g_s; int g_row; int g_col; } gs; /* g_type can be: */ #define G_NONE 0 /* Starting value - must be 0*/ #define G_NUM 1 #define G_STR 2 #define G_CELL 3 #define ISVALID(r,c) ((r)>=0 && (r)<maxrows && (c)>=0 && (c)<maxcols) extern FILE *popen(); jmp_buf fpe_save; int exprerr; /* Set by eval() and seval() if expression errors */ double prescale = 1.0; /* Prescale for constants in let() */ int extfunc = 0; /* Enable/disable external functions */ int loading = 0; /* Set when readfile() is active */ double fn1_eval(); double fn2_eval(); struct ent *firstev = (struct ent *)0; /* first expr in the eval list */ #define PI (double)3.14159265358979323846 #define dtr(x) ((x)*(PI/(double)180.0)) #define rtd(x) ((x)*(180.0/(double)PI)) double finfunc(fun,v1,v2,v3) int fun; double v1,v2,v3; { double answer,p; p = fn2_eval(pow, 1 + v2, v3); switch(fun) { case PV: answer = v1 * (1 - 1/p) / v2; break; case FV: answer = v1 * (p - 1) / v2; break; case PMT: answer = v1 * v2 / (1 - 1/p); break; default: error("Unknown function in finfunc"); return((double)0); } return(answer); } char * dostindex( val, minr, minc, maxr, maxc) double val; int minr, minc, maxr, maxc; { register r,c; register struct ent *p; char *pr; int x; x = (int) val; r = minr; c = minc; p = (struct ent *)0; if ( minr == maxr ) { /* look along the row */ c = minc + x - 1; if (c <= maxc && c >=minc) p = *ATBL(tbl, r, c); } else if ( minc == maxc ) { /* look down the column */ r = minr + x - 1; if (r <= maxr && r >=minr) p = *ATBL(tbl, r, c); } else { error ("range specified to @stindex"); return((char *)0); } if (p && p->label) { pr = xmalloc((unsigned)(strlen(p->label)+1)); (void)strcpy(pr, p->label); return (pr); } else return((char *)0); } double doindex( val, minr, minc, maxr, maxc) double val; int minr, minc, maxr, maxc; { double v; register r,c; register struct ent *p; int x; x = (int) val; v = (double)0; r = minr; c = minc; if ( minr == maxr ) { /* look along the row */ c = minc + x - 1; if (c <= maxc && c >=minc && (p = *ATBL(tbl, r, c)) && p->flags&is_valid ) return p->v; } else if ( minc == maxc ){ /* look down the column */ r = minr + x - 1; if (r <= maxr && r >=minr && (p = *ATBL(tbl, r, c)) && p->flags&is_valid ) return p->v; } else error(" range specified to @index"); return v; } double dolookup( val, minr, minc, maxr, maxc, offr, offc) struct enode * val; int minr, minc, maxr, maxc, offr, offc; { double v, ret = (double)0; register r,c; register struct ent *p = (struct ent *)0; int incr,incc,fndr,fndc; char *s; incr = (offc != 0); incc = (offr != 0); if (etype(val) == NUM) { v = eval(val); for (r = minr, c = minc; r <= maxr && c <= maxc; r+=incr, c+=incc) { if ( (p = *ATBL(tbl, r, c)) && p->flags&is_valid ) { if (p->v <= v) { fndr = incc ? (minr + offr) : r; fndc = incr ? (minc + offc) : c; if (ISVALID(fndr,fndc)) p = *ATBL(tbl, fndr, fndc); else error(" range specified to @[hv]lookup"); if ( p && p->flags&is_valid) ret = p->v; } else break; } } } else { s = seval(val); for (r = minr, c = minc; r <= maxr && c <= maxc; r+=incr, c+=incc) { if ( (p = *ATBL(tbl, r, c)) && p->label ) { if (strcmp(p->label,s) == 0) { fndr = incc ? (minr + offr) : r; fndc = incr ? (minc + offc) : c; if (ISVALID(fndr,fndc)) p = *ATBL(tbl, fndr, fndc); else error(" range specified to @[hv]lookup"); break; } } } if ( p && p->flags&is_valid) ret = p->v; xfree(s); } return ret; } double docount(minr, minc, maxr, maxc) int minr, minc, maxr, maxc; { int v; register r,c; register struct ent *p; v = 0; for (r = minr; r<=maxr; r++) for (c = minc; c<=maxc; c++) if ((p = *ATBL(tbl, r, c)) && p->flags&is_valid) v++; return v; } double dosum(minr, minc, maxr, maxc) int minr, minc, maxr, maxc; { double v; register r,c; register struct ent *p; v = (double)0; for (r = minr; r<=maxr; r++) for (c = minc; c<=maxc; c++) if ((p = *ATBL(tbl, r, c)) && p->flags&is_valid) v += p->v; return v; } double doprod(minr, minc, maxr, maxc) int minr, minc, maxr, maxc; { double v; register r,c; register struct ent *p; v = 1; for (r = minr; r<=maxr; r++) for (c = minc; c<=maxc; c++) if ((p = *ATBL(tbl, r, c)) && p->flags&is_valid) v *= p->v; return v; } double doavg(minr, minc, maxr, maxc) int minr, minc, maxr, maxc; { double v; register r,c,count; register struct ent *p; v = (double)0; count = 0; for (r = minr; r<=maxr; r++) for (c = minc; c<=maxc; c++) if ((p = *ATBL(tbl, r, c)) && p->flags&is_valid) { v += p->v; count++; } if (count == 0) return ((double) 0); return (v / (double)count); } double dostddev(minr, minc, maxr, maxc) int minr, minc, maxr, maxc; { double lp, rp, v, nd; register r,c,n; register struct ent *p; n = 0; lp = 0; rp = 0; for (r = minr; r<=maxr; r++) for (c = minc; c<=maxc; c++) if ((p = *ATBL(tbl, r, c)) && p->flags&is_valid) { v = p->v; lp += v*v; rp += v; n++; } if ((n == 0) || (n == 1)) return ((double) 0); nd = (double)n; return (sqrt((nd*lp-rp*rp)/(nd*(nd-1)))); } double domax(minr, minc, maxr, maxc) int minr, minc, maxr, maxc; { double v = (double)0; register r,c,count; register struct ent *p; count = 0; for (r = minr; r<=maxr; r++) for (c = minc; c<=maxc; c++) if ((p = *ATBL(tbl, r, c)) && p->flags&is_valid) { if (!count) { v = p->v; count++; } else if (p->v > v) v = p->v; } if (count == 0) return ((double) 0); return (v); } double domin(minr, minc, maxr, maxc) int minr, minc, maxr, maxc; { double v = (double)0; register r,c,count; register struct ent *p; count = 0; for (r = minr; r<=maxr; r++) for (c = minc; c<=maxc; c++) if ((p = *ATBL(tbl, r, c)) && p->flags&is_valid) { if (!count) { v = p->v; count++; } else if (p->v < v) v = p->v; } if (count == 0) return ((double) 0); return (v); } #define sec_min 60 #define sec_hr 3600L #define sec_day 86400L #define sec_yr 31471200L /* 364.25 days/yr */ #define sec_mo 2622600L /* sec_yr/12: sort of an average */ int mdays[12]={ 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }; double dodts(mo, day, yr) int mo, day, yr; { long trial; register struct tm *tp; register int i; register long jdate; mdays[1] = 28 + (yr%4 == 0); if (mo < 1 || mo > 12 || day < 1 || day > mdays[--mo] || yr > 1999 || yr < 1970) { error("@dts: invalid argument"); return(0.0); } jdate = day-1; for (i=0; i<mo; i++) jdate += mdays[i]; for (i = 1970; i < yr; i++) jdate += 365 + (i%4 == 0); trial = jdate * sec_day; yr -= 1900; tp = localtime(&trial); if (tp->tm_year != yr) { /* * We may fail this test once a year because of time zone * and daylight savings time errors. This bounces the * trial time past the boundary. The error introduced is * corrected below. */ trial += sec_day*(yr - tp->tm_year); tp = localtime(&trial); } if (tp->tm_mon != mo) { /* We may fail this test once a month. */ trial += sec_day*(mo - tp->tm_mon); tp = localtime(&trial); } if (tp->tm_mday + tp->tm_hour + tp->tm_min + tp->tm_sec != day) { trial -= (tp->tm_mday - day)*sec_day + tp->tm_hour*sec_hr + tp->tm_min*sec_min + tp->tm_sec; } #ifdef DEBUGDTS tp = localtime(&trial); if (tp->tm_mday + tp->tm_hour + tp->tm_min + tp->tm_sec + tp->tm_year + tp->tm_mon != yr+mo+day) error("Dts broke down"); #endif return ((double)trial); } double dotts(hr, min, sec) int hr, min, sec; { if (hr < 0 || hr > 23 || min < 0 || min > 59 || sec < 0 || sec > 59) { error ("@tts: Invalid argument"); return ((double)0); } return ((double)(sec+min*60+hr*3600)); } double dotime(which, when) int which; double when; { long time(); static long t_cache; static struct tm tm_cache; struct tm *tp; long tloc; if (which == NOW) return (double)time((long *)0); tloc = (long)when; if (tloc != t_cache) { tp = localtime(&tloc); tm_cache = *tp; tm_cache.tm_mon += 1; tm_cache.tm_year += 1900; t_cache = tloc; } switch (which) { case HOUR: return((double)(tm_cache.tm_hour)); case MINUTE: return((double)(tm_cache.tm_min)); case SECOND: return((double)(tm_cache.tm_sec)); case MONTH: return((double)(tm_cache.tm_mon)); case DAY: return((double)(tm_cache.tm_mday)); case YEAR: return((double)(tm_cache.tm_year)); } /* Safety net */ return ((double)0); } double doston(s) char *s; { char *strtof(); double v; if (!s) return((double)0); (void)strtof(s, &v); xfree(s); return(v); } double doeqs(s1, s2) char *s1, *s2; { double v; if (!s1 && !s2) return((double)1.0); if (!s1 || !s2) v = 0.0; else if (strcmp(s1, s2) == 0) v = 1.0; else v = 0.0; if (s1) xfree(s1); if (s2) xfree(s2); return(v); } /* * Given a string representing a column name and a value which is a column * number, return a pointer to the selected cell's entry, if any, else 0. Use * only the integer part of the column number. Always free the string. */ struct ent * getent (colstr, rowdoub) char *colstr; double rowdoub; { int collen; /* length of string */ int row, col; /* integer values */ struct ent *ep = (struct ent *)0; /* selected entry */ if (((row = (int) floor (rowdoub)) >= 0) && (row < maxrows) /* in range */ && ((collen = strlen (colstr)) <= 2) /* not too long */ && ((col = atocol (colstr, collen)) >= 0) && (col < maxcols)) /* in range */ { ep = *ATBL(tbl, row, col); } xfree (colstr); return (ep); } /* * Given a string representing a column name and a value which is a column * number, return the selected cell's numeric value, if any. */ double donval (colstr, rowdoub) char *colstr; double rowdoub; { struct ent *ep; return (((ep = getent (colstr, rowdoub)) && ((ep -> flags) & is_valid)) ? (ep -> v) : (double)0); } /* * The list routines (e.g. dolmax) are called with an LMAX enode. * The left pointer is a chain of ELIST nodes, the right pointer * is a value. */ double dolmax(ep) struct enode *ep; { register int count = 0; register double maxval = 0; /* Assignment to shut up lint */ register struct enode *p; register double v; for (p = ep; p; p = p->e.o.left) { v = eval(p->e.o.right); if (!count || v > maxval) { maxval = v; count++; } } if (count) return maxval; else return (double)0; } double dolmin(ep) struct enode *ep; { register int count = 0; register double minval = 0; /* Assignment to shut up lint */ register struct enode *p; register double v; for (p = ep; p; p = p->e.o.left) { v = eval(p->e.o.right); if (!count || v < minval) { minval = v; count++; } } if (count) return minval; else return (double)0; } double eval(e) register struct enode *e; { if (e == (struct enode *)0) return (double)0; switch (e->op) { case '+': return (eval(e->e.o.left) + eval(e->e.o.right)); case '-': return (eval(e->e.o.left) - eval(e->e.o.right)); case '*': return (eval(e->e.o.left) * eval(e->e.o.right)); case '/': return (eval(e->e.o.left) / eval(e->e.o.right)); case '%': { double num, denom; num = floor(eval(e->e.o.left)); denom = floor(eval (e->e.o.right)); return denom ? num - floor(num/denom)*denom : (double)0; } case '^': return (fn2_eval(pow,eval(e->e.o.left),eval(e->e.o.right))); case '<': return (eval(e->e.o.left) < eval(e->e.o.right)); case '=': return (eval(e->e.o.left) == eval(e->e.o.right)); case '>': return (eval(e->e.o.left) > eval(e->e.o.right)); case '&': return (eval(e->e.o.left) && eval(e->e.o.right)); case '|': return (eval(e->e.o.left) || eval(e->e.o.right)); case IF: case '?': return eval(e->e.o.left) ? eval(e->e.o.right->e.o.left) : eval(e->e.o.right->e.o.right); case 'm': return (-eval(e->e.o.right)); case 'f': return (eval(e->e.o.right)); case '~': return (eval(e->e.o.right) == 0.0); case 'k': return (e->e.k); case 'v': return (e->e.v.vp->v); case INDEX: case LOOKUP: case HLOOKUP: case VLOOKUP: { register r,c; register maxr, maxc; register minr, minc; maxr = e->e.o.right->e.r.right.vp -> row; maxc = e->e.o.right->e.r.right.vp -> col; minr = e->e.o.right->e.r.left.vp -> row; minc = e->e.o.right->e.r.left.vp -> col; if (minr>maxr) r = maxr, maxr = minr, minr = r; if (minc>maxc) c = maxc, maxc = minc, minc = c; switch(e->op){ case LOOKUP: return dolookup(e->e.o.left, minr, minc, maxr, maxc, minr==maxr, minc==maxc); case HLOOKUP: return dolookup(e->e.o.left->e.o.left, minr,minc,maxr,maxc, (int) eval(e->e.o.left->e.o.right), 0); case VLOOKUP: return dolookup(e->e.o.left->e.o.left, minr,minc,maxr,maxc, 0, (int) eval(e->e.o.left->e.o.right)); case INDEX: return doindex(eval(e->e.o.left), minr, minc, maxr, maxc); } } case REDUCE | '+': case REDUCE | '*': case REDUCE | 'a': case REDUCE | 'c': case REDUCE | 's': case REDUCE | MAX: case REDUCE | MIN: { register r,c; register maxr, maxc; register minr, minc; maxr = e->e.r.right.vp -> row; maxc = e->e.r.right.vp -> col; minr = e->e.r.left.vp -> row; minc = e->e.r.left.vp -> col; if (minr>maxr) r = maxr, maxr = minr, minr = r; if (minc>maxc) c = maxc, maxc = minc, minc = c; switch (e->op) { case REDUCE | '+': return dosum(minr, minc, maxr, maxc); case REDUCE | '*': return doprod(minr, minc, maxr, maxc); case REDUCE | 'a': return doavg(minr, minc, maxr, maxc); case REDUCE | 'c': return docount(minr, minc, maxr, maxc); case REDUCE | 's': return dostddev(minr, minc, maxr, maxc); case REDUCE | MAX: return domax(minr, minc, maxr, maxc); case REDUCE | MIN: return domin(minr, minc, maxr, maxc); } } case ABS: return (fn1_eval( fabs, eval(e->e.o.right))); case ACOS: return (fn1_eval( acos, eval(e->e.o.right))); case ASIN: return (fn1_eval( asin, eval(e->e.o.right))); case ATAN: return (fn1_eval( atan, eval(e->e.o.right))); case ATAN2: return (fn2_eval( atan2, eval(e->e.o.left), eval(e->e.o.right))); case CEIL: return (fn1_eval( ceil, eval(e->e.o.right))); case COS: return (fn1_eval( cos, eval(e->e.o.right))); case EXP: return (fn1_eval( exp, eval(e->e.o.right))); case FABS: return (fn1_eval( fabs, eval(e->e.o.right))); case FLOOR: return (fn1_eval( floor, eval(e->e.o.right))); case HYPOT: return (fn2_eval( hypot, eval(e->e.o.left), eval(e->e.o.right))); case LOG: return (fn1_eval( log, eval(e->e.o.right))); case LOG10: return (fn1_eval( log10, eval(e->e.o.right))); case POW: return (fn2_eval( pow, eval(e->e.o.left), eval(e->e.o.right))); case SIN: return (fn1_eval( sin, eval(e->e.o.right))); case SQRT: return (fn1_eval( sqrt, eval(e->e.o.right))); case TAN: return (fn1_eval( tan, eval(e->e.o.right))); case DTR: return (dtr(eval(e->e.o.right))); case RTD: return (rtd(eval(e->e.o.right))); case RND: { double temp; temp = eval(e->e.o.right); return(temp-floor(temp) < 0.5 ? floor(temp) : ceil(temp)); } case ROUND: { double temp = eval(e->e.o.left); int prec = (int) eval(e->e.o.right), scal = 1; while (prec-- > 0) scal *= 10; temp *= scal; temp = ((temp-floor(temp)) < 0.5 ? floor(temp) : ceil(temp)); return(temp / scal); } case FV: case PV: case PMT: return(finfunc(e->op,eval(e->e.o.left), eval(e->e.o.right->e.o.left), eval(e->e.o.right->e.o.right))); case HOUR: return (dotime(HOUR, eval(e->e.o.right))); case MINUTE: return (dotime(MINUTE, eval(e->e.o.right))); case SECOND: return (dotime(SECOND, eval(e->e.o.right))); case MONTH: return (dotime(MONTH, eval(e->e.o.right))); case DAY: return (dotime(DAY, eval(e->e.o.right))); case YEAR: return (dotime(YEAR, eval(e->e.o.right))); case NOW: return (dotime(NOW, (double)0.0)); case DTS: return (dodts((int)eval(e->e.o.left), (int)eval(e->e.o.right->e.o.left), (int)eval(e->e.o.right->e.o.right))); case TTS: return (dotts((int)eval(e->e.o.left), (int)eval(e->e.o.right->e.o.left), (int)eval(e->e.o.right->e.o.right))); case STON: return (doston(seval(e->e.o.right))); case EQS: return (doeqs(seval(e->e.o.right),seval(e->e.o.left))); case LMAX: return dolmax(e); case LMIN: return dolmin(e); case NVAL: return (donval(seval(e->e.o.left),eval(e->e.o.right))); default: error ("Illegal numeric expression"); exprerr = 1; } return((double)0.0); } #ifdef SIGVOID void #endif eval_fpe(signo) /* Trap for FPE errors in eval */ int signo; { #ifdef IEEE_MATH (void)fpsetsticky((fp_except)0); /* Clear exception */ #endif /* IEEE_MATH */ longjmp(fpe_save, 1); } double fn1_eval(fn, arg) double (*fn)(); double arg; { double res; errno = 0; res = (*fn)(arg); if(errno) eval_fpe(0); return res; } double fn2_eval(fn, arg1, arg2) double (*fn)(); double arg1, arg2; { double res; errno = 0; res = (*fn)(arg1, arg2); if(errno) eval_fpe(0); return res; } /* * Rules for string functions: * Take string arguments which they xfree. * All returned strings are assumed to be xalloced. */ char * docat(s1, s2) register char *s1, *s2; { register char *p; char *arg1, *arg2; if (!s1 && !s2) return((char *)0); arg1 = s1 ? s1 : ""; arg2 = s2 ? s2 : ""; p = xmalloc((unsigned)(strlen(arg1)+strlen(arg2)+1)); (void) strcpy(p, arg1); (void) strcat(p, arg2); if (s1) xfree(s1); if (s2) xfree(s2); return(p); } char * dodate(tloc) long tloc; { char *tp; char *p; tp = ctime(&tloc); tp[24] = '\0'; p = xmalloc((unsigned)25); (void) strcpy(p, tp); return(p); } char * dofmt(fmtstr, v) char *fmtstr; double v; { char buff[FBUFLEN]; char *p; if (!fmtstr) return((char *)0); (void)sprintf(buff, fmtstr, v); p = xmalloc((unsigned)(strlen(buff)+1)); (void) strcpy(p, buff); xfree(fmtstr); return(p); } /* * Given a command name and a value, run the command with the given value and * read and return its first output line (only) as an allocated string, always * a copy of prevstr, which is set appropriately first unless external * functions are disabled, in which case the previous value is used. The * handling of prevstr and freeing of command is tricky. Returning an * allocated string in all cases, even if null, insures cell expressions are * written to files, etc. */ #ifdef VMS char * doext(command, value) char *command; double value; { error("Warning: External functions unavailable on VMS"); if (command) xfree(command); return (strcpy (xmalloc((unsigned) 1), "\0")); } #else /* VMS */ char * doext (command, value) char *command; double value; { static char *prevstr = (char *)0; /* previous result */ char buff[FBUFLEN]; /* command line/return, not permanently alloc */ if (!prevstr) { prevstr = xmalloc((unsigned)1); *prevstr = '\0'; } if (!extfunc) { error ("Warning: external functions disabled; using %s value", prevstr ? "previous" : "null"); if (command) xfree (command); } else { if (prevstr) xfree (prevstr); /* no longer needed */ prevstr = '\0'; if ((! command) || (! *command)) { error ("Warning: external function given null command name"); if (command) xfree (command); } else { FILE *pp; (void) sprintf (buff, "%s %g", command, value); /* build cmd line */ xfree (command); error ("Running external function..."); (void) refresh(); if ((pp = popen (buff, "r")) == (FILE *) NULL) /* run it */ error ("Warning: running \"%s\" failed", buff); else { if (fgets (buff, sizeof(buff)-1, pp) == NULL) /* one line */ error ("Warning: external function returned nothing"); else { char *cp; error (""); /* erase notice */ buff[sizeof(buff)-1] = '\0'; if (cp = strchr (buff, '\n')) /* contains newline */ *cp = '\0'; /* end string there */ (void) strcpy (prevstr = xmalloc ((unsigned) (strlen (buff) + 1)), buff); /* save alloc'd copy */ } (void) pclose (pp); } /* else */ } /* else */ } /* else */ return (strcpy (xmalloc ((unsigned) (strlen (prevstr) + 1)), prevstr)); } #endif /* VMS */ /* * Given a string representing a column name and a value which is a column * number, return the selected cell's string value, if any. Even if none, * still allocate and return a null string so the cell has a label value so * the expression is saved in a file, etc. */ char * dosval (colstr, rowdoub) char *colstr; double rowdoub; { struct ent *ep; char *label; label = (ep = getent (colstr, rowdoub)) ? (ep -> label) : ""; return (strcpy (xmalloc ((unsigned) (strlen (label) + 1)), label)); } /* * Substring: Note that v1 and v2 are one-based to users, but zero-based * when calling this routine. */ char * dosubstr(s, v1, v2) char *s; register int v1,v2; { register char *s1, *s2; char *p; if (!s) return((char *)0); if (v2 >= strlen (s)) /* past end */ v2 = strlen (s) - 1; /* to end */ if (v1 < 0 || v1 > v2) { /* out of range, return null string */ xfree(s); p = xmalloc((unsigned)1); p[0] = '\0'; return(p); } s2 = p = xmalloc((unsigned)(v2-v1+2)); s1 = &s[v1]; for(; v1 <= v2; s1++, s2++, v1++) *s2 = *s1; *s2 = '\0'; xfree(s); return(p); } char * seval(se) register struct enode *se; { register char *p; if (se == (struct enode *)0) return (char *)0; switch (se->op) { case O_SCONST: p = xmalloc((unsigned)(strlen(se->e.s)+1)); (void) strcpy(p, se->e.s); return(p); case O_VAR: { struct ent *ep; ep = se->e.v.vp; if (!ep->label) return((char *)0); p = xmalloc((unsigned)(strlen(ep->label)+1)); (void) strcpy(p, ep->label); return(p); } case '#': return(docat(seval(se->e.o.left), seval(se->e.o.right))); case 'f': return(seval(se->e.o.right)); case IF: case '?': return(eval(se->e.o.left) ? seval(se->e.o.right->e.o.left) : seval(se->e.o.right->e.o.right)); case DATE: return(dodate((long)(eval(se->e.o.right)))); case FMT: return(dofmt(seval(se->e.o.left), eval(se->e.o.right))); case STINDEX: { register r,c; register maxr, maxc; register minr, minc; maxr = se->e.o.right->e.r.right.vp -> row; maxc = se->e.o.right->e.r.right.vp -> col; minr = se->e.o.right->e.r.left.vp -> row; minc = se->e.o.right->e.r.left.vp -> col; if (minr>maxr) r = maxr, maxr = minr, minr = r; if (minc>maxc) c = maxc, maxc = minc, minc = c; return dostindex(eval(se->e.o.left), minr, minc, maxr, maxc); } case EXT: return(doext(seval(se->e.o.left), eval(se->e.o.right))); case SVAL: return(dosval(seval(se->e.o.left), eval(se->e.o.right))); case SUBSTR: return(dosubstr(seval(se->e.o.left), (int)eval(se->e.o.right->e.o.left) - 1, (int)eval(se->e.o.right->e.o.right) - 1)); default: error ("Illegal string expression"); exprerr = 1; return((char *)0); } } /* * The graph formed by cell expressions which use other cells's values is not * evaluated "bottom up". The whole table is merely re-evaluated cell by cell, * top to bottom, left to right, in RealEvalAll(). Each cell's expression uses * constants in other cells. However, RealEvalAll() notices when a cell gets a * new numeric or string value, and reports if this happens for any cell. * EvalAll() repeats calling RealEvalAll() until there are no changes or the * evaluation count expires. */ int propagation = 10; /* max number of times to try calculation */ void setiterations(i) int i; { if(i<1) { error("iteration count must be at least 1"); propagation = 1; } else propagation = i; } void EvalAll () { int lastcnt, repct = 0; while ((lastcnt = RealEvalAll()) && (repct++ <= propagation)); if((propagation>1)&& (lastcnt >0 )) error("Still changing after %d iterations",propagation-1); } /* * Evaluate all cells which have expressions and alter their numeric or string * values. Return the number of cells which changed. */ int RealEvalAll () { register int i,j; int chgct = 0; register struct ent *p; (void) signal(SIGFPE, eval_fpe); #ifdef EXPRTREE for (p = firstev; p; p = p->evnext) RealEvalOne(p, &chgct); #else if(calc_order == BYROWS ) { for (i=0; i<=maxrow; i++) for (j=0; j<=maxcol; j++) if ((p=tbl[i][j]) && p->expr) RealEvalOne(p,i,j, &chgct); } else if ( calc_order == BYCOLS ) { for (j=0; j<=maxcol; j++) { for (i=0; i<=maxrow; i++) if ((p=tbl[i][j]) && p->expr) RealEvalOne(p,i,j, &chgct); } } else error("Internal error calc_order"); #endif (void) signal(SIGFPE, quit); return(chgct); } void #ifdef EXPRTREE RealEvalOne(p, chgct) register struct ent *p; int *chgct; #else RealEvalOne(p, i, j, chgct) register struct ent *p; int i, j, *chgct; #endif { if (p->flags & is_strexpr) { char *v; if (setjmp(fpe_save)) { #ifdef EXPRTREE error("Floating point exception %s", v_name(p->row, p->col)); #else error("Floating point exception %s", v_name(i, j)); #endif v = ""; } else { v = seval(p->expr); } if (!v && !p->label) /* Everything's fine */ return; if (!p->label || !v || strcmp(v, p->label) != 0) { (*chgct)++; p->flags |= is_changed; changed++; } if(p->label) xfree(p->label); p->label = v; } else { double v; if (setjmp(fpe_save)) { #ifdef EXPRTREE error("Floating point exception %s", v_name(p->row, p->col)); #else error("Floating point exception %s", v_name(i, j)); #endif v = (double)0.0; } else { v = eval (p->expr); } if (v != p->v) { p->v = v; (*chgct)++; p->flags |= is_changed|is_valid; changed++; } } } struct enode * new(op, a1, a2) int op; struct enode *a1, *a2; { register struct enode *p; p = (struct enode *) xmalloc ((unsigned)sizeof (struct enode)); p->op = op; p->e.o.left = a1; p->e.o.right = a2; return p; } struct enode * new_var(op, a1) int op; struct ent_ptr a1; { register struct enode *p; p = (struct enode *) xmalloc ((unsigned)sizeof (struct enode)); p->op = op; p->e.v = a1; return p; } struct enode * new_range(op, a1) int op; struct range_s a1; { register struct enode *p; p = (struct enode *) xmalloc ((unsigned)sizeof (struct enode)); p->op = op; p->e.r = a1; return p; } struct enode * new_const(op, a1) int op; double a1; { register struct enode *p; p = (struct enode *) xmalloc ((unsigned)sizeof (struct enode)); p->op = op; p->e.k = a1; return p; } struct enode * new_str(s) char *s; { register struct enode *p; p = (struct enode *) xmalloc ((unsigned)sizeof(struct enode)); p->op = O_SCONST; p->e.s = s; return(p); } void copy(dv1, dv2, v1, v2) struct ent *dv1, *dv2, *v1, *v2; { int minsr, minsc; int maxsr, maxsc; int mindr, mindc; int maxdr, maxdc; int vr, vc; int r, c; mindr = dv1->row; mindc = dv1->col; maxdr = dv2->row; maxdc = dv2->col; if (mindr>maxdr) r = maxdr, maxdr = mindr, mindr = r; if (mindc>maxdc) c = maxdc, maxdc = mindc, mindc = c; maxsr = v2->row; maxsc = v2->col; minsr = v1->row; minsc = v1->col; if (minsr>maxsr) r = maxsr, maxsr = minsr, minsr = r; if (minsc>maxsc) c = maxsc, maxsc = minsc, minsc = c; checkbounds(&maxdr, &maxdc); erase_area(mindr, mindc, maxdr, maxdc); if (minsr == maxsr && minsc == maxsc) { /* Source is a single cell */ for(vr = mindr; vr <= maxdr; vr++) for (vc = mindc; vc <= maxdc; vc++) copyrtv(vr, vc, minsr, minsc, maxsr, maxsc); } else if (minsr == maxsr) { /* Source is a single row */ for (vr = mindr; vr <= maxdr; vr++) copyrtv(vr, mindc, minsr, minsc, maxsr, maxsc); } else if (minsc == maxsc) { /* Source is a single column */ for (vc = mindc; vc <= maxdc; vc++) copyrtv(mindr, vc, minsr, minsc, maxsr, maxsc); } else { /* Everything else */ copyrtv(mindr, mindc, minsr, minsc, maxsr, maxsc); } sync_refs(); } void copyrtv(vr, vc, minsr, minsc, maxsr, maxsc) int vr, vc, minsr, minsc, maxsr, maxsc; { register struct ent *p; register struct ent *n; register int sr, sc; register int dr, dc; for (dr=vr, sr=minsr; sr<=maxsr; sr++, dr++) for (dc=vc, sc=minsc; sc<=maxsc; sc++, dc++) { if (p = *ATBL(tbl, sr, sc)) { n = lookat (dr, dc); (void) clearent(n); copyent( n, p, dr - sr, dc - sc); } else if (n = *ATBL(tbl, dr, dc)) (void) clearent(n); } } void eraser(v1, v2) struct ent *v1, *v2; { FullUpdate++; flush_saved(); erase_area(v1->row, v1->col, v2->row, v2->col); sync_refs(); } /* Goto subroutines */ void g_free() { switch (gs.g_type) { case G_STR: xfree(gs.g_s); break; default: break; } gs.g_type = G_NONE; } void go_last() { switch (gs.g_type) { case G_NONE: error("Nothing to repeat"); break; case G_NUM: num_search(gs.g_n); break; case G_CELL: moveto(gs.g_row, gs.g_col); break; case G_STR: gs.g_type = G_NONE; /* Don't free the string */ str_search(gs.g_s); break; default: error("go_last: internal error"); } } void moveto(row, col) int row, col; { currow = row; curcol = col; g_free(); gs.g_type = G_CELL; gs.g_row = currow; gs.g_col = curcol; } void num_search(n) double n; { register struct ent *p; register int r,c; int endr, endc; g_free(); gs.g_type = G_NUM; gs.g_n = n; if (currow > maxrow) endr = maxrow ? maxrow-1 : 0; else endr = currow; if (curcol > maxcol) endc = maxcol ? maxcol-1 : 0; else endc = curcol; r = endr; c = endc; do { if (c < maxcol) c++; else { if (r < maxrow) { while(++r < maxrow && row_hidden[r]) /* */; c = 0; } else { r = 0; c = 0; } } if (r == endr && c == endc) { error("Number not found"); return; } p = *ATBL(tbl, r, c); } while(col_hidden[c] || !p || p && (!(p->flags & is_valid) || (p->flags&is_valid) && p->v != n)); currow = r; curcol = c; } void str_search(s) char *s; { register struct ent *p; register int r,c; int endr, endc; char *tmp; #if defined(BSD42) || defined(BSD43) if ((tmp = re_comp(s)) != (char *)0) { xfree(s); error(tmp); return; } #endif #if defined(SYSV2) || defined(SYSV3) if ((tmp = regcmp(s, (char *)0)) == (char *)0) { xfree(s); error("Invalid search string"); return; } #endif g_free(); gs.g_type = G_STR; gs.g_s = s; if (currow > maxrow) endr = maxrow ? maxrow-1 : 0; else endr = currow; if (curcol > maxcol) endc = maxcol ? maxcol-1 : 0; else endc = curcol; r = endr; c = endc; do { if (c < maxcol) c++; else { if (r < maxrow) { while(++r < maxrow && row_hidden[r]) /* */; c = 0; } else { r = 0; c = 0; } } if (r == endr && c == endc) { error("String not found"); #if defined(SYSV2) || defined(SYSV3) free(tmp); #endif return; } p = *ATBL(tbl, r, c); } while(col_hidden[c] || !p || p && (!(p->label) #if defined(BSD42) || defined(BSD43) || (re_exec(p->label) == 0))); #else #if defined(SYSV2) || defined(SYSV3) || (regex(tmp, p->label) == (char *)0))); #else || (strcmp(s, p->label) != 0))); #endif #endif currow = r; curcol = c; #if defined(SYSV2) || defined(SYSV3) free(tmp); #endif } void fill (v1, v2, start, inc) struct ent *v1, *v2; double start, inc; { register r,c; register struct ent *n; int maxr, maxc; int minr, minc; maxr = v2->row; maxc = v2->col; minr = v1->row; minc = v1->col; if (minr>maxr) r = maxr, maxr = minr, minr = r; if (minc>maxc) c = maxc, maxc = minc, minc = c; checkbounds(&maxr, &maxc); if (minr < 0) minr = 0; if (minr < 0) minr = 0; FullUpdate++; if( calc_order == BYROWS ) { for (r = minr; r<=maxr; r++) for (c = minc; c<=maxc; c++) { n = lookat (r, c); (void) clearent(n); n->v = start; start += inc; n->flags |= (is_changed|is_valid); } } else if ( calc_order == BYCOLS ) { for (c = minc; c<=maxc; c++) for (r = minr; r<=maxr; r++) { n = lookat (r, c); (void) clearent(n); n->v = start; start += inc; n->flags |= (is_changed|is_valid); } } else error(" Internal error calc_order"); changed++; } void let (v, e) struct ent *v; struct enode *e; { double val; exprerr = 0; (void) signal(SIGFPE, eval_fpe); if (setjmp(fpe_save)) { error ("Floating point exception in cell %s", v_name(v->row, v->col)); val = (double)0.0; } else { val = eval(e); } (void) signal(SIGFPE, quit); if (exprerr) { efree((struct ent *)0, e); return; } if (constant(e)) { if (!loading) v->v = val * prescale; else v->v = val; if (!(v->flags & is_strexpr)) { efree(v, v->expr); v->expr = (struct enode *)0; } efree((struct ent *)0, e); v->flags |= (is_changed|is_valid); changed++; modflg++; return; } efree (v, v->expr); v->expr = e; v->flags |= (is_changed|is_valid); v->flags &= ~is_strexpr; #ifdef EXPRTREE totoptree(v); #endif changed++; modflg++; } void slet (v, se, flushdir) struct ent *v; struct enode *se; int flushdir; { char *p; exprerr = 0; (void) signal(SIGFPE, eval_fpe); if (setjmp(fpe_save)) { error ("Floating point exception in cell %s", v_name(v->row, v->col)); p = ""; } else { p = seval(se); } (void) signal(SIGFPE, quit); if (exprerr) { efree((struct ent *)0, se); return; } if (constant(se)) { label(v, p, flushdir); if (p) xfree(p); efree((struct ent *)0, se); if (v->flags & is_strexpr) { efree (v, v->expr); v->expr = (struct enode *)0; v->flags &= ~is_strexpr; } return; } efree (v, v->expr); v->expr = se; v->flags |= (is_changed|is_strexpr); if (flushdir<0) v->flags |= is_leftflush; else v->flags &= ~is_leftflush; #ifdef EXPRTREE totoptree(); #endif FullUpdate++; changed++; modflg++; } #ifdef EXPRTREE /* * put an expression in the expression tree, only the top of each branch is * in the firstev list */ totoptree(v) struct ent *v; { int right; int left; if (!v->expr) return; #ifdef notdef right = FALSE; left = FALSE; switch(v->expr->op) { /* no real expression */ case 'v': if (v->expr->o.v->evnext) evdel(v->expr->o.v); case 'k': case LMAX: case LMIN: case NOW: case O_SCONST: case O_VAR: default: return; /* left && right */ case '#': case '%': case '&': case '*': case '+': case '-': case '/': case '<': case '=': case '>': case '?': case '^': case '|': case ATAN2: case DTS: case EQS: case EXT: case FMT: case FV: case HYPOT: case IF: case NVAL: case PMT: case POW: case PV: case REDUCE | '*': case REDUCE | '+': case REDUCE | 'a': case REDUCE | 'c': case REDUCE | 's': case REDUCE | MAX: case REDUCE | MIN: case ROUND: case STINDEX: case SUBSTR: case SVAL: case TTS: left = right = TRUE; break; /* right only */ case 'f': case 'm': case '~': case ABS: case ACOS: case ASIN: case ATAN: case CEIL: case COS: case DATE: case DAY: case DTR: case EXP: case FABS: case FLOOR: case HLOOKUP: case HOUR: case IF: case INDEX: case LOG10: case LOG: case LOOKUP: case MINUTE: case MONTH: case RND: case RTD: case SECOND: case SIN: case SQRT: case STON: case TAN: case VLOOKUP: case YEAR: right = TRUE; break; } /* for now insert at the beginning of the list */ v->evnext = firstev; v->evprev = (struct ent *)0; if (firstev) firstev->evprev = v; firstev = v; #endif firstev = v; } #endif /* EXPRTREE*/ void hide_row(arg) int arg; { if (arg < 0) { error("Invalid Range"); return; } if (arg >= maxrows-1) { if (!growtbl(GROWROW, arg+1, 0)) { error("You can't hide the last row"); return; } } FullUpdate++; row_hidden[arg] = 1; } void hide_col(arg) int arg; { if (arg < 0) { error("Invalid Range"); return; } if (arg >= maxcols-1) { if ((arg >= ABSMAXCOLS-1) || !growtbl(GROWCOL, 0, arg+1)) { error("You can't hide the last col"); return; } } FullUpdate++; col_hidden[arg] = 1; } void clearent (v) struct ent *v; { if (!v) return; label(v,"",-1); v->v = (double)0; if (v->expr) efree(v, v->expr); v->expr = (struct enode *)0; v->flags |= (is_changed); v->flags &= ~(is_valid); changed++; modflg++; } /* * Say if an expression is a constant (return 1) or not. */ int constant (e) register struct enode *e; { return ((e == (struct enode *)0) || ((e -> op) == O_CONST) || ((e -> op) == O_SCONST) || (((e -> op) != O_VAR) && (((e -> op) & REDUCE) != REDUCE) && constant (e -> e.o.left) && constant (e -> e.o.right) && (e -> op != EXT) /* functions look like constants but aren't */ && (e -> op != NVAL) && (e -> op != SVAL) && (e -> op != NOW))); } void efree (v, e) struct ent *v; struct enode *e; { if (e) { if (e->op != O_VAR && e->op !=O_CONST && e->op != O_SCONST && (e->op & REDUCE) != REDUCE) { efree(v, e->e.o.left); efree(v, e->e.o.right); } if (e->op == O_SCONST && e->e.s) xfree(e->e.s); xfree ((char *)e); #ifdef EXPRTREE /* delete this cell from the eval list */ if (v) { if (v->evprev) v->evprev->evnext = v->evnext; if (v->evnext) v->evnext->evprev = v->evprev; } #endif /* EXPRTREE */ } } void label (v, s, flushdir) register struct ent *v; register char *s; int flushdir; { if (v) { if (flushdir==0 && v->flags&is_valid) { register struct ent *tv; if (v->col>0 && ((tv=lookat(v->row,v->col-1))->flags&is_valid)==0) v = tv, flushdir = 1; else if (((tv=lookat (v->row,v->col+1))->flags&is_valid)==0) v = tv, flushdir = -1; else flushdir = -1; } if (v->label) xfree((char *)(v->label)); if (s && s[0]) { v->label = xmalloc ((unsigned)(strlen(s)+1)); (void) strcpy (v->label, s); } else v->label = (char *)0; if (flushdir<0) v->flags |= is_leftflush; else v->flags &= ~is_leftflush; FullUpdate++; modflg++; } } void decodev (v) struct ent_ptr v; { register struct range *r; if (!v.vp) (void)sprintf (line+linelim,"VAR?"); else if ((r = find_range((char *)0, 0, v.vp, v.vp)) && !r->r_is_range) (void)sprintf(line+linelim, "%s", r->r_name); else (void)sprintf (line+linelim, "%s%s%s%d", v.vf & FIX_COL ? "$" : "", coltoa(v.vp->col), v.vf & FIX_ROW ? "$" : "", v.vp->row); linelim += strlen (line+linelim); } char * coltoa(col) int col; { static char rname[3]; register char *p = rname; if (col > 25) { *p++ = col/26 + 'A' - 1; col %= 26; } *p++ = col+'A'; *p = '\0'; return(rname); } /* * To make list elements come out in the same order * they were entered, we must do a depth-first eval * of the ELIST tree */ static void decompile_list(p) struct enode *p; { if (!p) return; decompile_list(p->e.o.left); /* depth first */ decompile(p->e.o.right, 0); line[linelim++] = ','; } void decompile(e, priority) register struct enode *e; int priority; { register char *s; if (e) { int mypriority; switch (e->op) { default: mypriority = 99; break; case '?': mypriority = 1; break; case ':': mypriority = 2; break; case '|': mypriority = 3; break; case '&': mypriority = 4; break; case '<': case '=': case '>': mypriority = 6; break; case '+': case '-': case '#': mypriority = 8; break; case '*': case '/': case '%': mypriority = 10; break; case '^': mypriority = 12; break; } if (mypriority<priority) line[linelim++] = '('; switch (e->op) { case 'f': for (s="fixed "; line[linelim++] = *s++;); linelim--; decompile (e->e.o.right, 30); break; case 'm': line[linelim++] = '-'; decompile (e->e.o.right, 30); break; case '~': line[linelim++] = '~'; decompile (e->e.o.right, 30); break; case 'v': decodev (e->e.v); break; case 'k': (void)sprintf (line+linelim,"%.15g",e->e.k); linelim += strlen (line+linelim); break; case '$': (void)sprintf (line+linelim, "\"%s\"", e->e.s); linelim += strlen(line+linelim); break; case REDUCE | '+': range_arg( "@sum(", e); break; case REDUCE | '*': range_arg( "@prod(", e); break; case REDUCE | 'a': range_arg( "@avg(", e); break; case REDUCE | 'c': range_arg( "@count(", e); break; case REDUCE | 's': range_arg( "@stddev(", e); break; case REDUCE | MAX: range_arg( "@max(", e); break; case REDUCE | MIN: range_arg( "@min(", e); break; case ABS: one_arg( "@abs(", e); break; case ACOS: one_arg( "@acos(", e); break; case ASIN: one_arg( "@asin(", e); break; case ATAN: one_arg( "@atan(", e); break; case ATAN2: two_arg( "@atan2(", e); break; case CEIL: one_arg( "@ceil(", e); break; case COS: one_arg( "@cos(", e); break; case EXP: one_arg( "@exp(", e); break; case FABS: one_arg( "@fabs(", e); break; case FLOOR: one_arg( "@floor(", e); break; case HYPOT: two_arg( "@hypot(", e); break; case LOG: one_arg( "@ln(", e); break; case LOG10: one_arg( "@log(", e); break; case POW: two_arg( "@pow(", e); break; case SIN: one_arg( "@sin(", e); break; case SQRT: one_arg( "@sqrt(", e); break; case TAN: one_arg( "@tan(", e); break; case DTR: one_arg( "@dtr(", e); break; case RTD: one_arg( "@rtd(", e); break; case RND: one_arg( "@rnd(", e); break; case ROUND: two_arg( "@round(", e); break; case HOUR: one_arg( "@hour(", e); break; case MINUTE: one_arg( "@minute(", e); break; case SECOND: one_arg( "@second(", e); break; case MONTH: one_arg( "@month(", e); break; case DAY: one_arg( "@day(", e); break; case YEAR: one_arg( "@year(", e); break; case DATE: one_arg( "@date(", e); break; case DTS: three_arg( "@dts(", e); break; case TTS: three_arg( "@tts(", e); break; case STON: one_arg( "@ston(", e); break; case FMT: two_arg( "@fmt(", e); break; case EQS: two_arg( "@eqs(", e); break; case NOW: for ( s = "@now"; line[linelim++] = *s++;); linelim--; break; case LMAX: list_arg("@max(", e); break; case LMIN: list_arg("@min(", e); break; case FV: three_arg("@fv(", e); break; case PV: three_arg("@pv(", e); break; case PMT: three_arg("@pmt(", e); break; case NVAL: two_arg("@nval(", e); break; case SVAL: two_arg("@sval(", e); break; case EXT: two_arg("@ext(", e); break; case SUBSTR: three_arg("@substr(", e); break; case STINDEX: index_arg("@stindex(", e); break; case INDEX: index_arg("@index(", e); break; case LOOKUP: index_arg("@lookup(", e); break; case HLOOKUP: two_arg_index("@hlookup(", e); break; case VLOOKUP: two_arg_index("@vlookup(", e); break; case IF: three_arg("@if(", e); break; default: decompile (e->e.o.left, mypriority); line[linelim++] = e->op; decompile (e->e.o.right, mypriority+1); break; } if (mypriority<priority) line[linelim++] = ')'; } else line[linelim++] = '?'; } void index_arg(s, e) char *s; struct enode *e; { for (; line[linelim++] = *s++;); linelim--; decompile( e-> e.o.left, 0 ); range_arg(", ", e->e.o.right); } void two_arg_index(s, e) char *s; struct enode *e; { for (; line[linelim++] = *s++;); linelim--; decompile( e->e.o.left->e.o.left, 0 ); range_arg(",", e->e.o.right); linelim--; line[linelim++] = ','; decompile( e->e.o.left->e.o.right, 0 ); line[linelim++] = ')'; } void list_arg(s, e) char *s; struct enode *e; { for (; line[linelim++] = *s++;); linelim--; decompile (e->e.o.right, 0); line[linelim++] = ','; decompile_list(e->e.o.left); line[linelim - 1] = ')'; } void one_arg(s, e) char *s; struct enode *e; { for (; line[linelim++] = *s++;); linelim--; decompile (e->e.o.right, 0); line[linelim++] = ')'; } void two_arg(s,e) char *s; struct enode *e; { for (; line[linelim++] = *s++;); linelim--; decompile (e->e.o.left, 0); line[linelim++] = ','; decompile (e->e.o.right, 0); line[linelim++] = ')'; } void three_arg(s,e) char *s; struct enode *e; { for (; line[linelim++] = *s++;); linelim--; decompile (e->e.o.left, 0); line[linelim++] = ','; decompile (e->e.o.right->e.o.left, 0); line[linelim++] = ','; decompile (e->e.o.right->e.o.right, 0); line[linelim++] = ')'; } void range_arg(s,e) char *s; struct enode *e; { struct range *r; for (; line[linelim++] = *s++;); linelim--; if ((r = find_range((char *)0, 0, e->e.r.left.vp, e->e.r.right.vp)) && r->r_is_range) { (void)sprintf(line+linelim, "%s", r->r_name); linelim += strlen(line+linelim); } else { decodev (e->e.r.left); line[linelim++] = ':'; decodev (e->e.r.right); } line[linelim++] = ')'; } void editv (row, col) int row, col; { register struct ent *p; p = lookat (row, col); (void)sprintf (line, "let %s = ", v_name(row, col)); linelim = strlen(line); if (p->flags & is_strexpr || p->expr == 0) { (void)sprintf (line+linelim, "%.15g", p->v); linelim += strlen (line+linelim); } else { editexp(row,col); } } void editexp(row,col) int row, col; { register struct ent *p; p = lookat (row, col); decompile (p->expr, 0); line[linelim] = '\0'; } void edits (row, col) int row, col; { register struct ent *p; p = lookat (row, col); (void)sprintf (line, "%sstring %s = ", ((p->flags&is_leftflush) ? "left" : "right"), v_name(row, col)); linelim = strlen(line); if (p->flags & is_strexpr && p->expr) { editexp(row, col); } else if (p->label) { (void)sprintf (line+linelim, "\"%s\"", p->label); linelim += strlen (line+linelim); } else { (void)sprintf (line+linelim, "\""); linelim += 1; } }