home *** CD-ROM | disk | FTP | other *** search
/ pc.louisiana.edu/pub/unix/ / Louisiana_UNIX.tar / Louisiana_UNIX / pch619-621.part2 < prev    next >
Internet Message Format  |  1992-06-01  |  45KB
  1. From nstar!sawmill!prslnk!buhrt@iuvax.cs.indiana.edu Fri May  8 16:02:43 1992
  2. Received: from usl.edu (rouge-gw.usl.edu) by armagnac.ucs.usl.edu with SMTP id AA15641
  3.   (5.65c/IDA-1.4.4 for <jpd@ucs>); Fri, 8 May 1992 16:02:34 -0500
  4. Received: from rex.cs.tulane.edu by usl.edu (4.1/BSS-3.4)
  5.     id AA20795; Fri, 8 May 92 16:02:17 CDT
  6. Received:  by rex.cs.tulane.edu; Fri, 8 May 92 16:01:55 -0500
  7. Received:  from iuvax.cs.indiana.edu by rex.cs.tulane.edu; Fri, 8 May 92 16:01:40 -0500
  8. Received: by iuvax.cs.indiana.edu 
  9. Received: by gator.rn.com (/\==/\ Smail3.1.25.1 #25.5)
  10.     id <m0ljbja-0000C7C@gator.rn.com>; Fri, 8 May 92 15:40 EST
  11. Received: by sawmill.uucp (/\==/\ Smail3.1.21.1 #21.8)
  12.     id <m0ljazS-000BGhC@sawmill.uucp>; Fri, 8 May 92 14:52 EST
  13. Received: by prslnk.uucp (/\==/\ Smail3.1.21.1 #21.3)
  14.     id <m0ljais-0001UXC@prslnk.uucp>; Fri, 8 May 92 14:35 EST
  15. Message-Id: <m0ljais-0001UXC@prslnk.uucp>
  16. Date: Fri, 8 May 92 14:35 EST
  17. From: prslnk!buhrt@iuvax.cs.indiana.edu (Jeff Buhrt)
  18. To: rutgers!retix!uunet!sawmill!nstar!decwrl!vixie@iuvax.cs.indiana.edu,
  19.         marc@dumbcat.sf.ca.us, jpd@usl.edu, sources-misc@uunet.uu.net
  20. Subject: sc - The SC Spreadsheet: patch5b (2of2)
  21. Status: RO
  22.  
  23.  
  24. Submitted-By: nstar!sawmill!prslnk!buhrt (Jeff Buhrt)
  25. Archive-name: sc/patch04b
  26. Patch-To: sc - The SC Spreadsheet, release 6.16: Volume 20, Issue 035-041
  27. Environment: Curses, good yacc/bison1.18 (anything but bison1.16), sed
  28. Windowing Support: Curses
  29.  
  30. *** ../619/interp.c    Mon Mar 16 10:09:40 1992
  31. --- interp.c    Fri May  8 12:31:27 1992
  32. ***************
  33. *** 7,13 ****
  34.    *
  35.    *              More mods Robert Bond, 12/86
  36.    *        More mods by Alan Silverstein, 3-4/88, see list of changes.
  37. !  *        $Revision: 6.19 $
  38.    */
  39.   
  40.   #define DEBUGDTS 1        /* REMOVE ME */
  41. --- 7,13 ----
  42.    *
  43.    *              More mods Robert Bond, 12/86
  44.    *        More mods by Alan Silverstein, 3-4/88, see list of changes.
  45. !  *        $Revision: 6.21 $
  46.    */
  47.   
  48.   #define DEBUGDTS 1        /* REMOVE ME */
  49. ***************
  50. *** 53,66 ****
  51.   #endif
  52.   
  53.   #ifdef SIGVOID
  54. !     void quit();
  55.   #else
  56. !     int quit();
  57.   #endif
  58.   
  59. - /* Suffixes for engineering notation THA 9/19/88 */
  60. - extern char engmult[];
  61. - 
  62.   /* Use this structure to save the the last 'g' command */
  63.   struct go_save {
  64.       int g_type;
  65. --- 53,63 ----
  66.   #endif
  67.   
  68.   #ifdef SIGVOID
  69. !     void doquit();
  70.   #else
  71. !     int doquit();
  72.   #endif
  73.   
  74.   /* Use this structure to save the the last 'g' command */
  75.   struct go_save {
  76.       int g_type;
  77. ***************
  78. *** 113,119 ****
  79. --- 110,118 ----
  80.   double    rint();
  81.   int    cellerror = CELLOK;    /* is there an error in this cell */
  82.   
  83. + #ifndef PI
  84.   #define PI (double)3.14159265358979323846
  85. + #endif
  86.   #define dtr(x) ((x)*(PI/(double)180.0))
  87.   #define rtd(x) ((x)*(180.0/(double)PI))
  88.   
  89. ***************
  90. *** 189,195 ****
  91.       }
  92.   
  93.       if (p && p->label) {
  94. !     pr = xmalloc((unsigned)(strlen(p->label)+1));
  95.       (void) strcpy(pr, p->label);
  96.       if (p->cellerror)
  97.           cellerror = CELLINVALID;
  98. --- 188,194 ----
  99.       }
  100.   
  101.       if (p && p->label) {
  102. !     pr = scxmalloc((unsigned)(strlen(p->label)+1));
  103.       (void) strcpy(pr, p->label);
  104.       if (p->cellerror)
  105.           cellerror = CELLINVALID;
  106. ***************
  107. *** 293,299 ****
  108.       }
  109.       if ( p && p->flags&is_valid)
  110.           ret = p->v;
  111. !     xfree(s);
  112.       }
  113.       return ret;
  114.   }
  115. --- 292,298 ----
  116.       }
  117.       if ( p && p->flags&is_valid)
  118.           ret = p->v;
  119. !     scxfree(s);
  120.       }
  121.       return ret;
  122.   }
  123. ***************
  124. *** 598,604 ****
  125.       return((double)0);
  126.   
  127.       (void)strtof(s, &v);
  128. !     xfree(s);
  129.       return(v);
  130.   }
  131.   
  132. --- 597,603 ----
  133.       return((double)0);
  134.   
  135.       (void)strtof(s, &v);
  136. !     scxfree(s);
  137.       return(v);
  138.   }
  139.   
  140. ***************
  141. *** 619,628 ****
  142.       v = 0.0;
  143.   
  144.       if (s1)
  145. !         xfree(s1);
  146.   
  147.       if (s2)
  148. !         xfree(s2);
  149.   
  150.       return(v);
  151.   }
  152. --- 618,627 ----
  153.       v = 0.0;
  154.   
  155.       if (s1)
  156. !         scxfree(s1);
  157.   
  158.       if (s2)
  159. !         scxfree(s2);
  160.   
  161.       return(v);
  162.   }
  163. ***************
  164. *** 630,637 ****
  165.   
  166.   /*
  167.    * Given a string representing a column name and a value which is a column
  168. !  * number, return a pointer to the selected cell's entry, if any, else 0.  Use
  169. !  * only the integer part of the column number.  Always free the string.
  170.    */
  171.   
  172.   struct ent *
  173. --- 629,636 ----
  174.   
  175.   /*
  176.    * Given a string representing a column name and a value which is a column
  177. !  * number, return a pointer to the selected cell's entry, if any, else NULL.
  178. !  * Use only the integer part of the column number.  Always free the string.
  179.    */
  180.   
  181.   struct ent *
  182. ***************
  183. *** 655,664 ****
  184.        && (col < maxcols))            /* in range */
  185.       {
  186.       p = *ATBL(tbl, row, col);
  187. !     if (p->cellerror)
  188.           cellerror = CELLINVALID;
  189.       }
  190. !     xfree (colstr);
  191.       return (p);
  192.   }
  193.   
  194. --- 654,663 ----
  195.        && (col < maxcols))            /* in range */
  196.       {
  197.       p = *ATBL(tbl, row, col);
  198. !     if ((p != NULL) && p->cellerror)
  199.           cellerror = CELLINVALID;
  200.       }
  201. !     scxfree (colstr);
  202.       return (p);
  203.   }
  204.   
  205. ***************
  206. *** 897,902 ****
  207. --- 896,902 ----
  208.       case NVAL:      return (donval(seval(e->e.o.left),eval(e->e.o.right)));
  209.       case MYROW:    return ((double) gmyrow);
  210.       case MYCOL:    return ((double) gmycol);
  211. +     case NUMITER:    return ((double) repct);
  212.       default:    error ("Illegal numeric expression");
  213.               exprerr = 1;
  214.       }
  215. ***************
  216. *** 955,961 ****
  217.   
  218.   /* 
  219.    * Rules for string functions:
  220. !  * Take string arguments which they xfree.
  221.    * All returned strings are assumed to be xalloced.
  222.    */
  223.   
  224. --- 955,961 ----
  225.   
  226.   /* 
  227.    * Rules for string functions:
  228. !  * Take string arguments which they scxfree.
  229.    * All returned strings are assumed to be xalloced.
  230.    */
  231.   
  232. ***************
  233. *** 970,982 ****
  234.       return((char *)0);
  235.       arg1 = s1 ? s1 : "";
  236.       arg2 = s2 ? s2 : "";
  237. !     p = xmalloc((unsigned)(strlen(arg1)+strlen(arg2)+1));
  238.       (void) strcpy(p, arg1);
  239.       (void) strcat(p, arg2);
  240.       if (s1)
  241. !         xfree(s1);
  242.       if (s2)
  243. !         xfree(s2);
  244.       return(p);
  245.   }
  246.   
  247. --- 970,982 ----
  248.       return((char *)0);
  249.       arg1 = s1 ? s1 : "";
  250.       arg2 = s2 ? s2 : "";
  251. !     p = scxmalloc((unsigned)(strlen(arg1)+strlen(arg2)+1));
  252.       (void) strcpy(p, arg1);
  253.       (void) strcat(p, arg2);
  254.       if (s1)
  255. !         scxfree(s1);
  256.       if (s2)
  257. !         scxfree(s2);
  258.       return(p);
  259.   }
  260.   
  261. ***************
  262. *** 989,995 ****
  263.   
  264.       tp = ctime(&tloc);
  265.       tp[24] = '\0';
  266. !     p = xmalloc((unsigned)25);
  267.       (void) strcpy(p, tp);
  268.       return(p);
  269.   }
  270. --- 989,995 ----
  271.   
  272.       tp = ctime(&tloc);
  273.       tp[24] = '\0';
  274. !     p = scxmalloc((unsigned)25);
  275.       (void) strcpy(p, tp);
  276.       return(p);
  277.   }
  278. ***************
  279. *** 1006,1014 ****
  280.       if (!fmtstr)
  281.       return((char *)0);
  282.       (void) sprintf(buff, fmtstr, v);
  283. !     p = xmalloc((unsigned)(strlen(buff)+1));
  284.       (void) strcpy(p, buff);
  285. !     xfree(fmtstr);
  286.       return(p);
  287.   }
  288.   
  289. --- 1006,1014 ----
  290.       if (!fmtstr)
  291.       return((char *)0);
  292.       (void) sprintf(buff, fmtstr, v);
  293. !     p = scxmalloc((unsigned)(strlen(buff)+1));
  294.       (void) strcpy(p, buff);
  295. !     scxfree(fmtstr);
  296.       return(p);
  297.   }
  298.   
  299. ***************
  300. *** 1032,1039 ****
  301.       error("Warning: External functions unavailable on VMS");
  302.       cellerror = CELLERROR;    /* not sure if this should be a cellerror */
  303.       if (command)
  304. !     xfree(command);
  305. !     return (strcpy (xmalloc((unsigned) 1), "\0"));
  306.   }
  307.   
  308.   #else /* VMS */
  309. --- 1032,1039 ----
  310.       error("Warning: External functions unavailable on VMS");
  311.       cellerror = CELLERROR;    /* not sure if this should be a cellerror */
  312.       if (command)
  313. !     scxfree(command);
  314. !     return (strcpy (scxmalloc((unsigned) 1), "\0"));
  315.   }
  316.   
  317.   #else /* VMS */
  318. ***************
  319. *** 1053,1069 ****
  320.           ((prevstr == NULL) || (*prevstr == '\0')) ?
  321.               "null" : "previous");
  322.   
  323. !     if (command) xfree (command);
  324.       } else {
  325.       if ((! command) || (! *command)) {
  326.           error ("Warning: external function given null command name");
  327.           cellerror = CELLERROR;
  328. !         if (command) xfree (command);
  329.       } else {
  330.           FILE *pp;
  331.   
  332.           (void) sprintf (buff, "%s %g", command, value); /* build cmd line */
  333. !         xfree (command);
  334.   
  335.           error ("Running external function...");
  336.           (void) refresh();
  337. --- 1053,1069 ----
  338.           ((prevstr == NULL) || (*prevstr == '\0')) ?
  339.               "null" : "previous");
  340.   
  341. !     if (command) scxfree (command);
  342.       } else {
  343.       if ((! command) || (! *command)) {
  344.           error ("Warning: external function given null command name");
  345.           cellerror = CELLERROR;
  346. !         if (command) scxfree (command);
  347.       } else {
  348.           FILE *pp;
  349.   
  350.           (void) sprintf (buff, "%s %g", command, value); /* build cmd line */
  351. !         scxfree (command);
  352.   
  353.           error ("Running external function...");
  354.           (void) refresh();
  355. ***************
  356. *** 1086,1092 ****
  357.   
  358.               if (strlen(buff) + 1 > prevlen)
  359.               {    prevlen = strlen(buff) + 40;
  360. !             prevstr = xrealloc(prevstr, prevlen);
  361.               }
  362.               (void) strcpy (prevstr, buff);
  363.                /* save alloc'd copy */
  364. --- 1086,1092 ----
  365.   
  366.               if (strlen(buff) + 1 > prevlen)
  367.               {    prevlen = strlen(buff) + 40;
  368. !             prevstr = scxrealloc(prevstr, prevlen);
  369.               }
  370.               (void) strcpy (prevstr, buff);
  371.                /* save alloc'd copy */
  372. ***************
  373. *** 1097,1105 ****
  374.       } /* else */
  375.       } /* else */
  376.       if (prevstr)
  377. !     return (strcpy (xmalloc ((unsigned) (strlen (prevstr) + 1)), prevstr));
  378.       else
  379. !     return (strcpy(xmalloc((unsigned)1), ""));
  380.   }
  381.   
  382.   #endif /* VMS */
  383. --- 1097,1105 ----
  384.       } /* else */
  385.       } /* else */
  386.       if (prevstr)
  387. !     return (strcpy (scxmalloc ((unsigned) (strlen (prevstr) + 1)), prevstr));
  388.       else
  389. !     return (strcpy(scxmalloc((unsigned)1), ""));
  390.   }
  391.   
  392.   #endif /* VMS */
  393. ***************
  394. *** 1121,1127 ****
  395.       char *llabel;
  396.   
  397.       llabel = (ep = getent (colstr, rowdoub)) ? (ep -> label) : "";
  398. !     return (strcpy (xmalloc ((unsigned) (strlen (llabel) + 1)), llabel));
  399.   }
  400.   
  401.   
  402. --- 1121,1127 ----
  403.       char *llabel;
  404.   
  405.       llabel = (ep = getent (colstr, rowdoub)) ? (ep -> label) : "";
  406. !     return (strcpy (scxmalloc ((unsigned) (strlen (llabel) + 1)), llabel));
  407.   }
  408.   
  409.   
  410. ***************
  411. *** 1145,1161 ****
  412.       v2 =  strlen (s) - 1;        /* to end   */
  413.   
  414.       if (v1 < 0 || v1 > v2) {        /* out of range, return null string */
  415. !     xfree(s);
  416. !     p = xmalloc((unsigned)1);
  417.       p[0] = '\0';
  418.       return(p);
  419.       }
  420. !     s2 = p = xmalloc((unsigned)(v2-v1+2));
  421.       s1 = &s[v1];
  422.       for(; v1 <= v2; s1++, s2++, v1++)
  423.       *s2 = *s1;
  424.       *s2 = '\0';
  425. !     xfree(s);
  426.       return(p);
  427.   }
  428.   
  429. --- 1145,1161 ----
  430.       v2 =  strlen (s) - 1;        /* to end   */
  431.   
  432.       if (v1 < 0 || v1 > v2) {        /* out of range, return null string */
  433. !     scxfree(s);
  434. !     p = scxmalloc((unsigned)1);
  435.       p[0] = '\0';
  436.       return(p);
  437.       }
  438. !     s2 = p = scxmalloc((unsigned)(v2-v1+2));
  439.       s1 = &s[v1];
  440.       for(; v1 <= v2; s1++, s2++, v1++)
  441.       *s2 = *s1;
  442.       *s2 = '\0';
  443. !     scxfree(s);
  444.       return(p);
  445.   }
  446.   
  447. ***************
  448. *** 1233,1239 ****
  449.   
  450.       if (se == (struct enode *)0) return (char *)0;
  451.       switch (se->op) {
  452. !     case O_SCONST: p = xmalloc((unsigned)(strlen(se->e.s)+1));
  453.                (void) strcpy(p, se->e.s);
  454.                return(p);
  455.       case O_VAR:    {
  456. --- 1233,1239 ----
  457.   
  458.       if (se == (struct enode *)0) return (char *)0;
  459.       switch (se->op) {
  460. !     case O_SCONST: p = scxmalloc((unsigned)(strlen(se->e.s)+1));
  461.                (void) strcpy(p, se->e.s);
  462.                return(p);
  463.       case O_VAR:    {
  464. ***************
  465. *** 1242,1248 ****
  466.   
  467.               if (!ep->label)
  468.                   return((char *)0);
  469. !             p = xmalloc((unsigned)(strlen(ep->label)+1));
  470.               (void) strcpy(p, ep->label);
  471.               return(p);
  472.                }
  473. --- 1242,1248 ----
  474.   
  475.               if (!ep->label)
  476.                   return((char *)0);
  477. !             p = scxmalloc((unsigned)(strlen(ep->label)+1));
  478.               (void) strcpy(p, ep->label);
  479.               return(p);
  480.                }
  481. ***************
  482. *** 1273,1280 ****
  483.       case SUBSTR: return(dosubstr(seval(se->e.o.left),
  484.                   (int)eval(se->e.o.right->e.o.left) - 1,
  485.                   (int)eval(se->e.o.right->e.o.right) - 1));
  486. !     case COLTOA: return(strcpy(xmalloc((unsigned)10),
  487. !                    coltoa(eval(se->e.o.right)+1)));
  488.       default:
  489.                error ("Illegal string expression");
  490.                exprerr = 1;
  491. --- 1273,1280 ----
  492.       case SUBSTR: return(dosubstr(seval(se->e.o.left),
  493.                   (int)eval(se->e.o.right->e.o.left) - 1,
  494.                   (int)eval(se->e.o.right->e.o.right) - 1));
  495. !     case COLTOA: return(strcpy(scxmalloc((unsigned)10),
  496. !                    coltoa((int)eval(se->e.o.right)+1)));
  497.       default:
  498.                error ("Illegal string expression");
  499.                exprerr = 1;
  500. ***************
  501. *** 1293,1298 ****
  502. --- 1293,1300 ----
  503.    */
  504.   
  505.   int propagation = 10;    /* max number of times to try calculation */
  506. + int repct = 1;        /* Make repct a global variable so that the 
  507. +                 function @numiter can access it */
  508.   
  509.   void
  510.   setiterations(i)
  511. ***************
  512. *** 1307,1314 ****
  513.   
  514.   void
  515.   EvalAll () {
  516. !      int lastcnt, repct = 1;
  517.     
  518.        (void) signal(SIGFPE, eval_fpe);
  519.   
  520.        while ((lastcnt = RealEvalAll()) && (++repct <= propagation));
  521. --- 1309,1317 ----
  522.   
  523.   void
  524.   EvalAll () {
  525. !      int lastcnt;
  526.     
  527. +      repct = 1;
  528.        (void) signal(SIGFPE, eval_fpe);
  529.   
  530.        while ((lastcnt = RealEvalAll()) && (++repct <= propagation));
  531. ***************
  532. *** 1315,1321 ****
  533.        if((propagation>1)&& (lastcnt >0 ))
  534.            error("Still changing after %d iterations",propagation-1);
  535.   
  536. !     (void) signal(SIGFPE, quit);
  537.   }
  538.   
  539.   /*
  540. --- 1318,1324 ----
  541.        if((propagation>1)&& (lastcnt >0 ))
  542.            error("Still changing after %d iterations",propagation-1);
  543.   
  544. !     (void) signal(SIGFPE, doquit);
  545.   }
  546.   
  547.   /*
  548. ***************
  549. *** 1369,1375 ****
  550.           changed++;
  551.           }
  552.           if(p->label)
  553. !         xfree(p->label);
  554.           p->label = v;
  555.       } else {
  556.           double v;
  557. --- 1372,1378 ----
  558.           changed++;
  559.           }
  560.           if(p->label)
  561. !         scxfree(p->label);
  562.           p->label = v;
  563.       } else {
  564.           double v;
  565. ***************
  566. *** 1403,1409 ****
  567.       freeenodes = p->e.o.left;
  568.       }
  569.       else
  570. !     p = (struct enode *) xmalloc ((unsigned)sizeof (struct enode));
  571.       p->op = op;
  572.       p->e.o.left = a1;
  573.       p->e.o.right = a2;
  574. --- 1406,1412 ----
  575.       freeenodes = p->e.o.left;
  576.       }
  577.       else
  578. !     p = (struct enode *) scxmalloc ((unsigned)sizeof (struct enode));
  579.       p->op = op;
  580.       p->e.o.left = a1;
  581.       p->e.o.right = a2;
  582. ***************
  583. *** 1421,1427 ****
  584.       freeenodes = p->e.o.left;
  585.       }
  586.       else
  587. !     p = (struct enode *) xmalloc ((unsigned)sizeof (struct enode));
  588.       p->op = op;
  589.       p->e.v = a1;
  590.       return p;
  591. --- 1424,1430 ----
  592.       freeenodes = p->e.o.left;
  593.       }
  594.       else
  595. !     p = (struct enode *) scxmalloc ((unsigned)sizeof (struct enode));
  596.       p->op = op;
  597.       p->e.v = a1;
  598.       return p;
  599. ***************
  600. *** 1438,1444 ****
  601.       freeenodes = p->e.o.left;
  602.       }
  603.       else
  604. !     p = (struct enode *) xmalloc ((unsigned)sizeof (struct enode));
  605.       p->op = op;
  606.       p->e.r = a1;
  607.       return p;
  608. --- 1441,1447 ----
  609.       freeenodes = p->e.o.left;
  610.       }
  611.       else
  612. !     p = (struct enode *) scxmalloc ((unsigned)sizeof (struct enode));
  613.       p->op = op;
  614.       p->e.r = a1;
  615.       return p;
  616. ***************
  617. *** 1455,1461 ****
  618.       freeenodes = p->e.o.left;
  619.       }
  620.       else
  621. !     p = (struct enode *) xmalloc ((unsigned)sizeof (struct enode));
  622.       p->op = op;
  623.       p->e.k = a1;
  624.       return p;
  625. --- 1458,1464 ----
  626.       freeenodes = p->e.o.left;
  627.       }
  628.       else
  629. !     p = (struct enode *) scxmalloc ((unsigned)sizeof (struct enode));
  630.       p->op = op;
  631.       p->e.k = a1;
  632.       return p;
  633. ***************
  634. *** 1472,1478 ****
  635.       freeenodes = p->e.o.left;
  636.       }
  637.       else
  638. !     p = (struct enode *) xmalloc ((unsigned)sizeof(struct enode));
  639.       p->op = O_SCONST;
  640.       p->e.s = s;
  641.       return(p);
  642. --- 1475,1481 ----
  643.       freeenodes = p->e.o.left;
  644.       }
  645.       else
  646. !     p = (struct enode *) scxmalloc ((unsigned)sizeof(struct enode));
  647.       p->op = O_SCONST;
  648.       p->e.s = s;
  649.       return(p);
  650. ***************
  651. *** 1564,1570 ****
  652.   g_free()
  653.   {
  654.       switch (gs.g_type) {
  655. !     case G_STR: xfree(gs.g_s); break;
  656.       default: break;
  657.       }
  658.       gs.g_type = G_NONE;
  659. --- 1567,1573 ----
  660.   g_free()
  661.   {
  662.       switch (gs.g_type) {
  663. !     case G_STR: scxfree(gs.g_s); break;
  664.       default: break;
  665.       }
  666.       gs.g_type = G_NONE;
  667. ***************
  668. *** 1675,1681 ****
  669.   
  670.   #if defined(RE_COMP)
  671.       if ((tmp = re_comp(s)) != (char *)0) {
  672. !     xfree(s);
  673.       error(tmp);
  674.       return;
  675.       }
  676. --- 1678,1684 ----
  677.   
  678.   #if defined(RE_COMP)
  679.       if ((tmp = re_comp(s)) != (char *)0) {
  680. !     scxfree(s);
  681.       error(tmp);
  682.       return;
  683.       }
  684. ***************
  685. *** 1682,1688 ****
  686.   #endif
  687.   #if defined(REGCMP)
  688.       if ((tmp = regcmp(s, (char *)0)) == (char *)0) {
  689. !     xfree(s);
  690.       cellerror = CELLERROR;
  691.       error("Invalid search string");
  692.       return;
  693. --- 1685,1691 ----
  694.   #endif
  695.   #if defined(REGCMP)
  696.       if ((tmp = regcmp(s, (char *)0)) == (char *)0) {
  697. !     scxfree(s);
  698.       cellerror = CELLERROR;
  699.       error("Invalid search string");
  700.       return;
  701. ***************
  702. *** 1870,1876 ****
  703.           FullUpdate++;
  704.           v->cellerror = cellerror;
  705.       }
  706. !     (void) signal(SIGFPE, quit);
  707.       if (exprerr) {
  708.           efree(e);
  709.           return;
  710. --- 1873,1879 ----
  711.           FullUpdate++;
  712.           v->cellerror = cellerror;
  713.       }
  714. !     (void) signal(SIGFPE, doquit);
  715.       if (exprerr) {
  716.           efree(e);
  717.           return;
  718. ***************
  719. *** 1931,1937 ****
  720.       FullUpdate++;
  721.       v->cellerror = cellerror;
  722.       }
  723. !     (void) signal(SIGFPE, quit);
  724.       if (exprerr) {
  725.       efree(se);
  726.       return;
  727. --- 1934,1940 ----
  728.       FullUpdate++;
  729.       v->cellerror = cellerror;
  730.       }
  731. !     (void) signal(SIGFPE, doquit);
  732.       if (exprerr) {
  733.       efree(se);
  734.       return;
  735. ***************
  736. *** 1939,1945 ****
  737.       if (constant(se)) {
  738.       label(v, p, flushdir);
  739.       if (p)
  740. !         xfree(p);
  741.       efree(se);
  742.       if (v->flags & is_strexpr) {
  743.               efree(v->expr);
  744. --- 1942,1948 ----
  745.       if (constant(se)) {
  746.       label(v, p, flushdir);
  747.       if (p)
  748. !         scxfree(p);
  749.       efree(se);
  750.       if (v->flags & is_strexpr) {
  751.               efree(v->expr);
  752. ***************
  753. *** 1992,2001 ****
  754.           continue;
  755.           }
  756.           if (n->format)
  757. !         xfree(n->format);
  758.           n->format = 0;
  759.           if (s && *s != '\0')
  760. !         n->format = strcpy(xmalloc((unsigned)(strlen(s)+1)), s);
  761.           n->flags |= is_changed;
  762.          }
  763.   }
  764. --- 1995,2004 ----
  765.           continue;
  766.           }
  767.           if (n->format)
  768. !         scxfree(n->format);
  769.           n->format = 0;
  770.           if (s && *s != '\0')
  771. !         n->format = strcpy(scxmalloc((unsigned)(strlen(s)+1)), s);
  772.           n->flags |= is_changed;
  773.          }
  774.   }
  775. ***************
  776. *** 2034,2040 ****
  777.       }
  778.       }
  779.       FullUpdate++;
  780. !     col_hidden[arg] = 1;
  781.   }
  782.   
  783.   void
  784. --- 2037,2043 ----
  785.       }
  786.       }
  787.       FullUpdate++;
  788. !     col_hidden[arg] = TRUE;
  789.   }
  790.   
  791.   void
  792. ***************
  793. *** 2049,2055 ****
  794.       efree(v->expr);
  795.       v->expr = (struct enode *)0;
  796.       if (v->format)
  797. !     xfree(v->format);
  798.       v->format = (char *)0;
  799.       v->flags |= (is_changed);
  800.       v->flags &=  (is_valid);
  801. --- 2052,2058 ----
  802.       efree(v->expr);
  803.       v->expr = (struct enode *)0;
  804.       if (v->format)
  805. !     scxfree(v->format);
  806.       v->format = (char *)0;
  807.       v->flags |= (is_changed);
  808.       v->flags &=  (is_valid);
  809. ***************
  810. *** 2079,2084 ****
  811. --- 2082,2088 ----
  812.            && e -> op != NOW
  813.            && e -> op != MYROW
  814.            && e -> op != MYCOL
  815. +          && e -> op != NUMITER
  816.       )
  817.       );
  818.   }
  819. ***************
  820. *** 2094,2100 ****
  821.           efree(e->e.o.right);
  822.       }
  823.       if (e->op == O_SCONST && e->e.s)
  824. !         xfree(e->e.s);
  825.       e->e.o.left = freeenodes;
  826.       freeenodes = e;
  827.       }
  828. --- 2098,2104 ----
  829.           efree(e->e.o.right);
  830.       }
  831.       if (e->op == O_SCONST && e->e.s)
  832. !         scxfree(e->e.s);
  833.       e->e.o.left = freeenodes;
  834.       freeenodes = e;
  835.       }
  836. ***************
  837. *** 2115,2123 ****
  838.           v = tv, flushdir = -1;
  839.           else flushdir = -1;
  840.       }
  841. !     if (v->label) xfree((char *)(v->label));
  842.       if (s && s[0]) {
  843. !         v->label = xmalloc ((unsigned)(strlen(s)+1));
  844.           (void) strcpy (v->label, s);
  845.       } else
  846.           v->label = (char *)0;
  847. --- 2119,2127 ----
  848.           v = tv, flushdir = -1;
  849.           else flushdir = -1;
  850.       }
  851. !     if (v->label) scxfree((char *)(v->label));
  852.       if (s && s[0]) {
  853. !         v->label = scxmalloc ((unsigned)(strlen(s)+1));
  854.           (void) strcpy (v->label, s);
  855.       } else
  856.           v->label = (char *)0;
  857. ***************
  858. *** 2288,2293 ****
  859. --- 2292,2300 ----
  860.               linelim--;
  861.               break;
  862.       case COLTOA:    one_arg( "@coltoa(", e); break;
  863. +     case NUMITER:    for ( s = "@numiter"; line[linelim++] = *s++;);
  864. +                         linelim--;
  865. +                         break;
  866.       default:    decompile (e->e.o.left, mypriority);
  867.               line[linelim++] = e->op;
  868.               decompile (e->e.o.right, mypriority+1);
  869. *** ../619/lex.c    Mon Mar 16 10:09:42 1992
  870. --- lex.c    Fri May  8 12:31:28 1992
  871. ***************
  872. *** 7,13 ****
  873.    *
  874.    *              More mods Robert Bond, 12/86
  875.    *        More mods by Alan Silverstein, 3/88, see list of changes.
  876. !  *        $Revision: 6.19 $
  877.    *
  878.    */
  879.   
  880. --- 7,13 ----
  881.    *
  882.    *              More mods Robert Bond, 12/86
  883.    *        More mods by Alan Silverstein, 3/88, see list of changes.
  884. !  *        $Revision: 6.21 $
  885.    *
  886.    */
  887.   
  888. ***************
  889. *** 216,222 ****
  890.           ptr = p+1;    /* "string" or "string\"quoted\"" */
  891.           while(*ptr && ((*ptr != '"') || (*(ptr-1) == '\\')))
  892.           ptr++;
  893. !         ptr = xmalloc((unsigned)(ptr-p));
  894.       yylval.sval = ptr;
  895.       p += 1;
  896.       while (*p && ((*p != '"') || (*(p-1) == '\\')))
  897. --- 216,222 ----
  898.           ptr = p+1;    /* "string" or "string\"quoted\"" */
  899.           while(*ptr && ((*ptr != '"') || (*(ptr-1) == '\\')))
  900.           ptr++;
  901. !         ptr = scxmalloc((unsigned)(ptr-p));
  902.       yylval.sval = ptr;
  903.       p += 1;
  904.       while (*p && ((*p != '"') || (*(p-1) == '\\')))
  905. ***************
  906. *** 411,416 ****
  907. --- 411,417 ----
  908.       km[1].k_str = tgetstr("kr", &p); km[1].k_val = ctl('f');
  909.       km[2].k_str = tgetstr("ku", &p); km[2].k_val = ctl('p');
  910.       km[3].k_str = tgetstr("kd", &p); km[3].k_val = ctl('n');
  911. + 
  912.       ktmp = tgetstr("ks",&p);
  913.       if (ktmp)  {
  914.       (void) strcpy(ks_buf, ktmp);
  915. ***************
  916. *** 597,602 ****
  917. --- 598,615 ----
  918.   #ifdef KEY_HOME
  919.       case KEY_HOME:    break;
  920.   #endif
  921. + #ifdef KEY_DC
  922. +     case KEY_DC:    c = 'x'; break;
  923. + #endif
  924. + #ifdef KEY_FIND
  925. +     case KEY_FIND:  c = 'g'; break;
  926. + #endif
  927. + #ifdef KEY_HELP
  928. +     case KEY_HELP:  c = '?'; break;
  929. + #endif
  930. + #ifdef KEY_SELECT
  931. +     case KEY_SELECT:c = 'm'; break;
  932. + #endif
  933.   #ifdef KEY_C1
  934.   /* This stuff works for a wyse wy75 in ANSI mode under 5.3.  Good luck. */
  935.   /* It is supposed to map the curses keypad back to the numeric equiv. */
  936. ***************
  937. *** 613,619 ****
  938.       case KEY_C3:    c = '.'; break;
  939.       case KEY_ENTER: c = ctl('m'); break;
  940.   #endif
  941. !     default:   c = toascii(c); 
  942.       break;
  943.       }
  944.       return (c);
  945. --- 626,632 ----
  946.       case KEY_C3:    c = '.'; break;
  947.       case KEY_ENTER: c = ctl('m'); break;
  948.   #endif
  949. !     default:        c = toascii(c); 
  950.       break;
  951.       }
  952.       return (c);
  953. *** ../619/psc.c    Mon Mar 16 10:09:42 1992
  954. --- psc.c    Fri May  8 12:31:29 1992
  955. ***************
  956. *** 17,23 ****
  957.    *  Author: Robert Bond
  958.    *  Adjustments: Jeff Buhrt and Eric Putz
  959.    */
  960. ! char *rev = "$Revision: 6.19 $";
  961.   
  962.   #include <ctype.h>
  963.   #include <stdio.h>
  964. --- 17,23 ----
  965.    *  Author: Robert Bond
  966.    *  Adjustments: Jeff Buhrt and Eric Putz
  967.    */
  968. ! char *rev = "$Revision: 6.21 $";
  969.   
  970.   #include <ctype.h>
  971.   #include <stdio.h>
  972. *** ../619/range.c    Mon Mar 16 10:09:43 1992
  973. --- range.c    Fri May  8 12:31:29 1992
  974. ***************
  975. *** 4,10 ****
  976.    *
  977.    *              Robert Bond, 4/87
  978.    *
  979. !  *        $Revision: 6.19 $
  980.    */
  981.   
  982.   #include <sys/types.h>
  983. --- 4,10 ----
  984.    *
  985.    *              Robert Bond, 4/87
  986.    *
  987. !  *        $Revision: 6.21 $
  988.    */
  989.   
  990.   #include <sys/types.h>
  991. ***************
  992. *** 59,71 ****
  993.   
  994.       if (find_range(name, strlen(name), (struct ent *)0, (struct ent *)0)) {
  995.       error("Error: range name already defined");
  996. !     xfree(name);
  997.       return;
  998.       }
  999.   
  1000.       if (strlen(name) <= 2) {
  1001.       error("Invalid range name - too short");
  1002. !     xfree(name);
  1003.       return;
  1004.       }
  1005.   
  1006. --- 59,71 ----
  1007.   
  1008.       if (find_range(name, strlen(name), (struct ent *)0, (struct ent *)0)) {
  1009.       error("Error: range name already defined");
  1010. !     scxfree(name);
  1011.       return;
  1012.       }
  1013.   
  1014.       if (strlen(name) <= 2) {
  1015.       error("Invalid range name - too short");
  1016. !     scxfree(name);
  1017.       return;
  1018.       }
  1019.   
  1020. ***************
  1021. *** 73,79 ****
  1022.       if (!((isalpha(*p) && (len<=2)) ||
  1023.           ((isdigit(*p) || isalpha(*p) || (*p == '_')) && (len>2)))) {
  1024.           error("Invalid range name - illegal combination");
  1025. !         xfree(name);
  1026.           return;
  1027.       }
  1028.    
  1029. --- 73,79 ----
  1030.       if (!((isalpha(*p) && (len<=2)) ||
  1031.           ((isdigit(*p) || isalpha(*p) || (*p == '_')) && (len>2)))) {
  1032.           error("Invalid range name - illegal combination");
  1033. !         scxfree(name);
  1034.           return;
  1035.       }
  1036.    
  1037. ***************
  1038. *** 83,89 ****
  1039.           label(rcp, name, 0);
  1040.       }
  1041.   
  1042. !     r = (struct range *)xmalloc((unsigned)sizeof(struct range));
  1043.       r->r_name = name;
  1044.       r->r_left = left;
  1045.       r->r_right = right;
  1046. --- 83,89 ----
  1047.           label(rcp, name, 0);
  1048.       }
  1049.   
  1050. !     r = (struct range *)scxmalloc((unsigned)sizeof(struct range));
  1051.       r->r_name = name;
  1052.       r->r_left = left;
  1053.       r->r_right = right;
  1054. ***************
  1055. *** 119,126 ****
  1056.           r->r_prev->r_next = r->r_next;
  1057.       else
  1058.       rng_base = r->r_next;
  1059. !     xfree((char *)(r->r_name));
  1060. !     xfree((char *)r);
  1061.   }
  1062.   
  1063.   void
  1064. --- 119,126 ----
  1065.           r->r_prev->r_next = r->r_next;
  1066.       else
  1067.       rng_base = r->r_next;
  1068. !     scxfree((char *)(r->r_name));
  1069. !     scxfree((char *)r);
  1070.   }
  1071.   
  1072.   void
  1073. ***************
  1074. *** 134,141 ****
  1075.   
  1076.       while (r) {
  1077.       nextr = r->r_next;
  1078. !     xfree((char *)(r->r_name));
  1079. !     xfree((char *)r);
  1080.       r = nextr;
  1081.       }
  1082.   }
  1083. --- 134,141 ----
  1084.   
  1085.       while (r) {
  1086.       nextr = r->r_next;
  1087. !     scxfree((char *)(r->r_name));
  1088. !     scxfree((char *)r);
  1089.       r = nextr;
  1090.       }
  1091.   }
  1092. *** ../619/sc.c    Mon Mar 16 10:09:44 1992
  1093. --- sc.c    Fri May  8 12:31:31 1992
  1094. ***************
  1095. *** 8,14 ****
  1096.    *              More mods Robert Bond, 12/86
  1097.    *        More mods by Alan Silverstein, 3-4/88, see list of changes.
  1098.    *        Currently supported by sequent!sawmill!buhrt (Jeff Buhrt)
  1099. !  *        $Revision: 6.19 $
  1100.    *
  1101.    */
  1102.   
  1103. --- 8,14 ----
  1104.    *              More mods Robert Bond, 12/86
  1105.    *        More mods by Alan Silverstein, 3-4/88, see list of changes.
  1106.    *        Currently supported by sequent!sawmill!buhrt (Jeff Buhrt)
  1107. !  *        $Revision: 6.21 $
  1108.    *
  1109.    */
  1110.   
  1111. ***************
  1112. *** 126,132 ****
  1113.           freeents = freeents->next;
  1114.       }
  1115.       else
  1116. !         *pp = (struct ent *) xmalloc((unsigned)sizeof(struct ent));
  1117.       if (row>maxrow) maxrow = row;
  1118.       if (col>maxcol) maxcol = col;
  1119.       (*pp)->label = (char *)0;
  1120. --- 126,132 ----
  1121.           freeents = freeents->next;
  1122.       }
  1123.       else
  1124. !         *pp = (struct ent *) scxmalloc((unsigned)sizeof(struct ent));
  1125.       if (row>maxrow) maxrow = row;
  1126.       if (col>maxcol) maxcol = col;
  1127.       (*pp)->label = (char *)0;
  1128. ***************
  1129. *** 224,231 ****
  1130.       argc--;
  1131.           switch (argv[0][1]) {
  1132.           case 'x':
  1133. ! #if defined(VMS) || defined(MSDOS)
  1134. !             (void) fprintf(stderr, "Crypt not available for VMS or MS-DOS\n");
  1135.               exit(1);
  1136.   #else 
  1137.               Crypt = 1;
  1138. --- 224,231 ----
  1139.       argc--;
  1140.           switch (argv[0][1]) {
  1141.           case 'x':
  1142. ! #if defined(VMS) || defined(MSDOS) || !defined(CRYPT_PATH)
  1143. !             (void) fprintf(stderr, "Crypt not available\n");
  1144.               exit(1);
  1145.   #else 
  1146.               Crypt = 1;
  1147. ***************
  1148. *** 343,349 ****
  1149.   #if    pyr
  1150.          if ( iscntrl(c) || (c >= 011 && c <= 015) )    /* iscntrl broken in OSx4.1 */
  1151.   #else
  1152. !        if ( iscntrl(c) || (c == 020 ) )    /* iscntrl broken in OSx4.1 */
  1153.   #endif
  1154.           switch (c) {
  1155.   #ifdef SIGTSTP
  1156. --- 343,349 ----
  1157.   #if    pyr
  1158.          if ( iscntrl(c) || (c >= 011 && c <= 015) )    /* iscntrl broken in OSx4.1 */
  1159.   #else
  1160. !        if (isascii(c) && (iscntrl(c) || (c == 020)) )    /* iscntrl broken in OSx4.1 */
  1161.   #endif
  1162.           switch (c) {
  1163.   #ifdef SIGTSTP
  1164. ***************
  1165. *** 509,516 ****
  1166. --- 509,521 ----
  1167.               break;    /* ignore flow control */
  1168.   
  1169.           case ctl('t'):
  1170. + #if !defined(VMS) && !defined(MSDOS) && defined(CRYPT_PATH)
  1171.               error(
  1172.   "Toggle: a:auto,c:cell,e:ext funcs,n:numeric,t:top,x:encrypt,$:pre-scale,<MORE>");
  1173. + #else                 /* no encryption available */
  1174. +             error(
  1175. + "Toggle: a:auto,c:cell,e:ext funcs,n:numeric,t:top,$:pre-scale,<MORE>");
  1176. + #endif
  1177.               (void) refresh();
  1178.   
  1179.               switch (nmgetch()) {
  1180. ***************
  1181. *** 536,543 ****
  1182. --- 541,552 ----
  1183.                       showcell ? "en" : "dis");
  1184.                   break;
  1185.               case 'x': case 'X':
  1186. + #if defined(VMS) || defined(MSDOS) || !defined(CRYPT_PATH)
  1187. +                 error ("Encryption not available.");
  1188. + #else 
  1189.                   Crypt = (! Crypt);
  1190.                   error ("Encryption %sabled.", Crypt? "en" : "dis");
  1191. + #endif
  1192.                   break;
  1193.               case 'l': case 'L':
  1194.                   autolabel = (! autolabel);
  1195. ***************
  1196. *** 609,620 ****
  1197.               static    unsigned    templen = 0;
  1198.               int templim;
  1199.   
  1200. !             /* xrealloc will xmalloc if needed */
  1201.               if (strlen(line)+1 > templen)
  1202.               {    templen = strlen(line)+40;
  1203.   
  1204. !                 temp = xrealloc(temp, templen);
  1205. !                 temp1= xrealloc(temp1, templen);
  1206.               }
  1207.               strcpy(temp, line);
  1208.               templim = linelim;
  1209. --- 618,629 ----
  1210.               static    unsigned    templen = 0;
  1211.               int templim;
  1212.   
  1213. !             /* scxrealloc will scxmalloc if needed */
  1214.               if (strlen(line)+1 > templen)
  1215.               {    templen = strlen(line)+40;
  1216.   
  1217. !                 temp = scxrealloc(temp, templen);
  1218. !                 temp1= scxrealloc(temp1, templen);
  1219.               }
  1220.               strcpy(temp, line);
  1221.               templim = linelim;
  1222. ***************
  1223. *** 641,647 ****
  1224.               break;
  1225.   
  1226.           } /* End of the control char switch stmt */
  1227. !     else if (isdigit(c) && ((numeric && edistate >= 0) ||
  1228.               (!numeric && (linelim < 0 || edistate >= 0)))) {
  1229.           /* we got a leading number */
  1230.           if (edistate != 0) {
  1231. --- 650,656 ----
  1232.               break;
  1233.   
  1234.           } /* End of the control char switch stmt */
  1235. !     else if (isascii(c) && isdigit(c) && ((numeric && edistate >= 0) ||
  1236.               (!numeric && (linelim < 0 || edistate >= 0)))) {
  1237.           /* we got a leading number */
  1238.           if (edistate != 0) {
  1239. ***************
  1240. *** 1121,1137 ****
  1241.               break;
  1242.           case 'W':
  1243.               (void) sprintf (line, "write [\"dest\" range] \"");
  1244.               linelim = strlen (line);
  1245.               insert_mode();
  1246.               break;
  1247.           case 'S':    /* set options */
  1248.               (void) sprintf (line, "set ");
  1249. !             error("Options:byrows,bycols,iterations=n,tblstyle=(0|tbl|latex|slatex|tex),<MORE>");
  1250.               linelim = strlen (line);
  1251.               insert_mode();
  1252.               break;
  1253.           case 'T':    /* tbl output */
  1254.               (void) sprintf (line, "tbl [\"dest\" range] \"");
  1255.               linelim = strlen (line);
  1256.               insert_mode();
  1257.               break;
  1258. --- 1130,1158 ----
  1259.               break;
  1260.           case 'W':
  1261.               (void) sprintf (line, "write [\"dest\" range] \"");
  1262. +             if (*curfile)
  1263. +                        error ("Default file is \"%s.asc\"",curfile);
  1264.               linelim = strlen (line);
  1265.               insert_mode();
  1266.               break;
  1267.           case 'S':    /* set options */
  1268.               (void) sprintf (line, "set ");
  1269. !             error("Options:byrows,bycols,iterations=n,tblstyle=(0|tbl|latex|slatex|tex|frame),<MORE>");
  1270.               linelim = strlen (line);
  1271.               insert_mode();
  1272.               break;
  1273.           case 'T':    /* tbl output */
  1274.               (void) sprintf (line, "tbl [\"dest\" range] \"");
  1275. +             if (*curfile && tbl_style == 0)
  1276. +                        error ("Default file is \"%s.cln\"",curfile);
  1277. +                     else if (*curfile && tbl_style == TBL)
  1278. +                        error ("Default file is \"%s.tbl\"",curfile);
  1279. +                     else if (*curfile && tbl_style == LATEX)
  1280. +                        error ("Default file is \"%s.lat\"",curfile);
  1281. +                     else if (*curfile && tbl_style == SLATEX)
  1282. +                        error ("Default file is \"%s.stx\"",curfile);
  1283. +                     else if (*curfile && tbl_style == TEX)
  1284. +                        error ("Default file is \"%s.tex\"",curfile);
  1285.               linelim = strlen (line);
  1286.               insert_mode();
  1287.               break;
  1288. ***************
  1289. *** 1293,1299 ****
  1290.   signals()
  1291.   {
  1292.   #ifdef SIGVOID
  1293. !     void quit();
  1294.       void time_out();
  1295.       void dump_me();
  1296.   #ifdef    SIGWINCH
  1297. --- 1314,1320 ----
  1298.   signals()
  1299.   {
  1300.   #ifdef SIGVOID
  1301. !     void doquit();
  1302.       void time_out();
  1303.       void dump_me();
  1304.   #ifdef    SIGWINCH
  1305. ***************
  1306. *** 1300,1306 ****
  1307.       void winchg();
  1308.   #endif
  1309.   #else
  1310. !     int quit();
  1311.       int time_out();
  1312.       int dump_me();
  1313.   #ifdef    SIGWINCH
  1314. --- 1321,1327 ----
  1315.       void winchg();
  1316.   #endif
  1317.   #else
  1318. !     int doquit();
  1319.       int time_out();
  1320.       int dump_me();
  1321.   #ifdef    SIGWINCH
  1322. ***************
  1323. *** 1311,1322 ****
  1324.       (void) signal(SIGINT, SIG_IGN);
  1325.   #if !defined(MSDOS)
  1326.       (void) signal(SIGQUIT, dump_me);
  1327. !     (void) signal(SIGPIPE, quit);
  1328.       (void) signal(SIGALRM, time_out);
  1329. !     (void) signal(SIGBUS, quit);
  1330.   #endif
  1331. !     (void) signal(SIGTERM, quit);
  1332. !     (void) signal(SIGFPE, quit);
  1333.   #ifdef    SIGWINCH
  1334.       (void) signal(SIGWINCH, winchg);
  1335.   #endif
  1336. --- 1332,1343 ----
  1337.       (void) signal(SIGINT, SIG_IGN);
  1338.   #if !defined(MSDOS)
  1339.       (void) signal(SIGQUIT, dump_me);
  1340. !     (void) signal(SIGPIPE, doquit);
  1341.       (void) signal(SIGALRM, time_out);
  1342. !     (void) signal(SIGBUS, doquit);
  1343.   #endif
  1344. !     (void) signal(SIGTERM, doquit);
  1345. !     (void) signal(SIGFPE, doquit);
  1346.   #ifdef    SIGWINCH
  1347.       (void) signal(SIGWINCH, winchg);
  1348.   #endif
  1349. ***************
  1350. *** 1339,1345 ****
  1351.   #else
  1352.   int
  1353.   #endif
  1354. ! quit()
  1355.   {
  1356.       diesave();
  1357.       stopdisp();
  1358. --- 1360,1366 ----
  1359.   #else
  1360.   int
  1361.   #endif
  1362. ! doquit()
  1363.   {
  1364.       diesave();
  1365.       stopdisp();
  1366. *** ../619/sc.h    Mon Mar 16 10:09:44 1992
  1367. --- sc.h    Fri May  8 12:31:32 1992
  1368. ***************
  1369. *** 6,12 ****
  1370.    *            University of Maryland
  1371.    *        R. Bond  12/86
  1372.    *        More mods by Alan Silverstein, 3-4/88, see list of changes.
  1373. !  *        $Revision: 6.19 $
  1374.    *
  1375.    */
  1376.   
  1377. --- 6,12 ----
  1378.    *            University of Maryland
  1379.    *        R. Bond  12/86
  1380.    *        More mods by Alan Silverstein, 3-4/88, see list of changes.
  1381. !  *        $Revision: 6.21 $
  1382.    *
  1383.    */
  1384.   
  1385. ***************
  1386. *** 129,134 ****
  1387. --- 129,135 ----
  1388.   struct enode {
  1389.       int op;
  1390.       union {
  1391. +     int gram_match;         /* some compilers (hp9000ipc) need this */
  1392.       double k;        /* constant # */
  1393.       struct ent_ptr v;    /* ref. another cell */
  1394.       struct range_s r;    /* op is on a range */
  1395. ***************
  1396. *** 205,210 ****
  1397. --- 206,212 ----
  1398.   #define UPPER OP_BASE + 55
  1399.   #define LOWER OP_BASE + 56
  1400.   #define CAPITAL OP_BASE + 57
  1401. + #define NUMITER    OP_BASE + 58
  1402.   
  1403.   /* flag values */
  1404.   #define is_valid     0001
  1405. ***************
  1406. *** 233,238 ****
  1407. --- 235,241 ----
  1408.   #define    LATEX    2        /* 'LaTeX' */
  1409.   #define    TEX    3        /* 'TeX' */
  1410.   #define    SLATEX    4        /* 'SLaTeX' (Scandinavian LaTeX) */
  1411. + #define    FRAME    5        /* tblprint style output for FrameMaker */
  1412.   
  1413.   /* Types for etype() */
  1414.   #define NUM    1
  1415. ***************
  1416. *** 269,278 ****
  1417.   extern    char *coltoa();
  1418.   extern    char *findhome();
  1419.   extern    char *r_name();
  1420.   extern    char *strrchr();
  1421.   extern    char *v_name();
  1422. - extern    char *xmalloc();
  1423. - extern    char *xrealloc();
  1424.   extern    int any_locked_cells();
  1425.   extern    int are_ranges();
  1426.   extern    int atocol();
  1427. --- 272,281 ----
  1428.   extern    char *coltoa();
  1429.   extern    char *findhome();
  1430.   extern    char *r_name();
  1431. + extern    char *scxmalloc();
  1432. + extern    char *scxrealloc();
  1433.   extern    char *strrchr();
  1434.   extern    char *v_name();
  1435.   extern    int any_locked_cells();
  1436.   extern    int are_ranges();
  1437.   extern    int atocol();
  1438. ***************
  1439. *** 357,362 ****
  1440. --- 360,366 ----
  1441.   extern    void readfile();
  1442.   extern    void resetkbd();
  1443.   extern    void rowshow_op();
  1444. + extern    void scxfree();
  1445.   extern    void setauto();
  1446.   extern    void setiterations();
  1447.   extern    void setorder();
  1448. ***************
  1449. *** 376,382 ****
  1450.   extern    void write_fd();
  1451.   extern    void write_line();
  1452.   extern    void write_range();
  1453. - extern    void xfree();
  1454.   extern    void yyerror();
  1455.   #ifdef DOBACKUPS
  1456.   extern    int backup_file();
  1457. --- 380,385 ----
  1458. ***************
  1459. *** 383,393 ****
  1460. --- 386,399 ----
  1461.   #endif
  1462.   
  1463.   extern    int modflg;
  1464. + #if !defined(VMS) && !defined(MSDOS) && defined(CRYPT_PATH)
  1465.   extern    int Crypt;
  1466. + #endif
  1467.   extern    char *mdir;
  1468.   extern    double prescale;
  1469.   extern    int extfunc;
  1470.   extern    int propagation;
  1471. + extern    int repct;
  1472.   extern    int calc_order;
  1473.   extern    int autocalc;
  1474.   extern    int autolabel;
  1475. ***************
  1476. *** 415,418 ****
  1477. --- 421,426 ----
  1478.   #if defined(BSD42) || defined(BSD43) && !defined(ultrix)
  1479.   #define    memcpy(dest, source, len)    bcopy(source, dest, (unsigned int)len);
  1480.   #define    memset(dest, zero, len)        bzero((dest), (unsigned int)(len));
  1481. + #else
  1482. + #include <memory.h>
  1483.   #endif
  1484. *** ../619/screen.c    Mon Mar 16 10:09:45 1992
  1485. --- screen.c    Fri May  8 12:31:33 1992
  1486. ***************
  1487. *** 8,14 ****
  1488.    *              More mods Robert Bond, 12/86
  1489.    *        More mods by Alan Silverstein, 3-4/88, see list of changes.
  1490.    *        Currently supported by sequent!sawmill!buhrt (Jeff Buhrt)
  1491. !  *        $Revision: 6.19 $
  1492.    *
  1493.    */
  1494.   
  1495. --- 8,14 ----
  1496.    *              More mods Robert Bond, 12/86
  1497.    *        More mods by Alan Silverstein, 3-4/88, see list of changes.
  1498.    *        Currently supported by sequent!sawmill!buhrt (Jeff Buhrt)
  1499. !  *        $Revision: 6.21 $
  1500.    *
  1501.    */
  1502.   
  1503. ***************
  1504. *** 543,550 ****
  1505.       initkbd();
  1506.       scrollok(stdscr, 1);
  1507.   
  1508. ! #ifndef IDLOKBAD
  1509. ! # ifdef SYSV3
  1510.       /*
  1511.        * turn hardware insert/delete on, if possible.
  1512.        * turn on scrolling for systems with SYSVr3.{1,2} (SYSVr3.0 has this set
  1513. --- 543,550 ----
  1514.       initkbd();
  1515.       scrollok(stdscr, 1);
  1516.   
  1517. ! #if defined(SYSV3) && !defined(NOIDLOK)
  1518. ! # ifndef IDLOKBAD
  1519.       /*
  1520.        * turn hardware insert/delete on, if possible.
  1521.        * turn on scrolling for systems with SYSVr3.{1,2} (SYSVr3.0 has this set
  1522. ***************
  1523. *** 551,558 ****
  1524.        * as the default)
  1525.        */
  1526.        idlok(stdscr,TRUE);
  1527. ! # endif
  1528. ! #else    /*
  1529.        * This seems to fix (with an empty spreadsheet):
  1530.        *    a) Redrawing the bottom half of the screen when you
  1531.        *        move between row 9 <-> 10
  1532. --- 551,557 ----
  1533.        * as the default)
  1534.        */
  1535.        idlok(stdscr,TRUE);
  1536. ! # else    /*
  1537.        * This seems to fix (with an empty spreadsheet):
  1538.        *    a) Redrawing the bottom half of the screen when you
  1539.        *        move between row 9 <-> 10
  1540. ***************
  1541. *** 566,571 ****
  1542. --- 565,571 ----
  1543.        *     noticing the rows become 2, 3, 40, 41, 42... (etc).
  1544.        */
  1545.        idlok(stdscr,FALSE);
  1546. + # endif
  1547.   #endif
  1548.   
  1549.       FullUpdate++;
  1550. *** ../619/version.c    Mon Mar 16 10:09:45 1992
  1551. --- version.c    Fri May  8 12:31:33 1992
  1552. ***************
  1553. *** 4,7 ****
  1554.    * The part after the first colon, except the last char, appears on the screen.
  1555.    */
  1556.   
  1557. ! char *rev = "$Revision: 6.19 $";
  1558. --- 4,7 ----
  1559.    * The part after the first colon, except the last char, appears on the screen.
  1560.    */
  1561.   
  1562. ! char *rev = "$Revision: 6.21 $";
  1563. *** ../619/vi.c    Mon Mar 16 10:09:46 1992
  1564. --- vi.c    Fri May  8 12:31:34 1992
  1565. ***************
  1566. *** 1,7 ****
  1567.   /*    SC    A Spreadsheet Calculator
  1568.    *
  1569.    *    One line vi emulation
  1570. !  *    $Revision: 6.19 $
  1571.    */
  1572.   
  1573.   #include <sys/types.h>
  1574. --- 1,7 ----
  1575.   /*    SC    A Spreadsheet Calculator
  1576.    *
  1577.    *    One line vi emulation
  1578. !  *    $Revision: 6.21 $
  1579.    */
  1580.   
  1581.   #include <sys/types.h>
  1582. ***************
  1583. *** 104,109 ****
  1584. --- 104,110 ----
  1585.       case 'R':    replace_mode();            break;
  1586.       case 'X':    u_save(c); back_space();    break;
  1587.       case 'a':    u_save(c); append_line();    break;
  1588. +     case 'A':    u_save(c);last_col();append_line();    break;
  1589.       case 'b':    linelim = back_word();        break;
  1590.       case 'c':    u_save(c); change_cmd();    break;
  1591.       case 'd':    u_save(c); delete_cmd();    break;
  1592. ***************
  1593. *** 251,257 ****
  1594.       if (strlen(line)+1 > undolen)
  1595.       {    undolen = strlen(line)+40;
  1596.   
  1597. !     undo_line = xrealloc(undo_line, undolen);
  1598.       }
  1599.       (void) strcpy(undo_line, line);
  1600.   
  1601. --- 252,258 ----
  1602.       if (strlen(line)+1 > undolen)
  1603.       {    undolen = strlen(line)+40;
  1604.   
  1605. !     undo_line = scxrealloc(undo_line, undolen);
  1606.       }
  1607.       (void) strcpy(undo_line, line);
  1608.   
  1609. ***************
  1610. *** 278,284 ****
  1611.   
  1612.       if (strlen(line)+1 > templen)
  1613.       {    templen = strlen(line)+40;
  1614. !     tempc = xrealloc(tempc, templen);
  1615.       }
  1616.   
  1617.       strcpy(tempc, line);
  1618. --- 279,285 ----
  1619.   
  1620.       if (strlen(line)+1 > templen)
  1621.       {    templen = strlen(line)+40;
  1622. !     tempc = scxrealloc(tempc, templen);
  1623.       }
  1624.   
  1625.       strcpy(tempc, line);
  1626. ***************
  1627. *** 595,601 ****
  1628.   
  1629.       if (history[lasthist].len < strlen(line)+1)
  1630.       {    history[lasthist].len = strlen(line)+40;
  1631. !     history[lasthist].histline = xrealloc(history[lasthist].histline,
  1632.                             history[lasthist].len);
  1633.       }
  1634.       (void) strcpy(history[lasthist].histline, line);
  1635. --- 596,602 ----
  1636.   
  1637.       if (history[lasthist].len < strlen(line)+1)
  1638.       {    history[lasthist].len = strlen(line)+40;
  1639. !     history[lasthist].histline = scxrealloc(history[lasthist].histline,
  1640.                             history[lasthist].len);
  1641.       }
  1642.       (void) strcpy(history[lasthist].histline, line);
  1643. ***************
  1644. *** 636,642 ****
  1645.   
  1646.       if (strlen(line)+1 > lastsrchlen)
  1647.       {    lastsrchlen = strlen(line)+40;
  1648. !     last_search = xrealloc(last_search, lastsrchlen);
  1649.       }
  1650.       (void)strcpy(last_search, line+1);
  1651.       search_again();
  1652. --- 637,643 ----
  1653.   
  1654.       if (strlen(line)+1 > lastsrchlen)
  1655.       {    lastsrchlen = strlen(line)+40;
  1656. !     last_search = scxrealloc(last_search, lastsrchlen);
  1657.       }
  1658.       (void)strcpy(last_search, line+1);
  1659.       search_again();
  1660. *** ../619/vmtbl.c    Mon Mar 16 10:09:47 1992
  1661. --- vmtbl.c    Fri May  8 12:31:35 1992
  1662. ***************
  1663. *** 8,14 ****
  1664.    *              More mods Robert Bond, 12/86
  1665.    *        More mods by Alan Silverstein, 3-4/88, see list of changes.
  1666.    *        Currently supported by sequent!sawmill!buhrt (Jeff Buhrt)
  1667. !  *        $Revision: 6.19 $
  1668.    *
  1669.    */
  1670.   #ifdef PSC
  1671. --- 8,14 ----
  1672.    *              More mods Robert Bond, 12/86
  1673.    *        More mods by Alan Silverstein, 3-4/88, see list of changes.
  1674.    *        Currently supported by sequent!sawmill!buhrt (Jeff Buhrt)
  1675. !  *        $Revision: 6.21 $
  1676.    *
  1677.    */
  1678.   #ifdef PSC
  1679. ***************
  1680. *** 54,62 ****
  1681.   }
  1682.   #endif /* !PSC */
  1683.       
  1684. ! /* xrealloc will just xmalloc if oldptr is == NULL */
  1685.   #define GROWALLOC(newptr, oldptr, nelem, type, msg) \
  1686. !     newptr = (type *)xrealloc((char *)oldptr, \
  1687.                        (unsigned)(nelem*sizeof(type))); \
  1688.       if (newptr == (type *)NULL) \
  1689.       {   error(msg); \
  1690. --- 54,62 ----
  1691.   }
  1692.   #endif /* !PSC */
  1693.       
  1694. ! /* scxrealloc will just scxmalloc if oldptr is == NULL */
  1695.   #define GROWALLOC(newptr, oldptr, nelem, type, msg) \
  1696. !     newptr = (type *)scxrealloc((char *)oldptr, \
  1697.                        (unsigned)(nelem*sizeof(type))); \
  1698.       if (newptr == (type *)NULL) \
  1699.       {   error(msg); \
  1700. ***************
  1701. *** 177,183 ****
  1702.           /* [re]alloc the space for each row */
  1703.           for (i = 0; i < maxrows; i++)
  1704.           {
  1705. !             if ((tbl[i] = (struct ent **)xrealloc((char *)tbl[i],
  1706.               (unsigned)(newcols * sizeof(struct ent **)))) == (struct ent **)0)
  1707.               {    error(nowider);
  1708.                   return(FALSE);
  1709. --- 177,183 ----
  1710.           /* [re]alloc the space for each row */
  1711.           for (i = 0; i < maxrows; i++)
  1712.           {
  1713. !             if ((tbl[i] = (struct ent **)scxrealloc((char *)tbl[i],
  1714.               (unsigned)(newcols * sizeof(struct ent **)))) == (struct ent **)0)
  1715.               {    error(nowider);
  1716.                   return(FALSE);
  1717. ***************
  1718. *** 195,201 ****
  1719.   
  1720.       /* fill in the bottom of the table */
  1721.       for (; i < newrows; i++)
  1722. !     {    if ((tbl[i] = (struct ent **)xmalloc((unsigned)(newcols *
  1723.                   sizeof(struct ent **)))) == (struct ent **)0)
  1724.           {    error(nowider);
  1725.               return(FALSE);
  1726. --- 195,201 ----
  1727.   
  1728.       /* fill in the bottom of the table */
  1729.       for (; i < newrows; i++)
  1730. !     {    if ((tbl[i] = (struct ent **)scxmalloc((unsigned)(newcols *
  1731.                   sizeof(struct ent **)))) == (struct ent **)0)
  1732.           {    error(nowider);
  1733.               return(FALSE);
  1734. *** ../619/xmalloc.c    Mon Mar 16 10:09:47 1992
  1735. --- xmalloc.c    Fri May  8 12:31:35 1992
  1736. ***************
  1737. *** 1,6 ****
  1738.   /*
  1739.    * A safer saner malloc, for careless programmers
  1740. !  * $Revision: 6.19 $
  1741.    */
  1742.   
  1743.   #include <stdio.h>
  1744. --- 1,6 ----
  1745.   /*
  1746.    * A safer saner malloc, for careless programmers
  1747. !  * $Revision: 6.21 $
  1748.    */
  1749.   
  1750.   #include <stdio.h>
  1751. ***************
  1752. *** 17,32 ****
  1753.   extern void exit();
  1754.   #endif
  1755.   
  1756. ! #define    MAGIC    (double)1234567890.1234456789
  1757.   
  1758.   char *
  1759. ! xmalloc(n)
  1760.   unsigned n;
  1761.   {
  1762.       register char *ptr;
  1763.   
  1764.       if ((ptr = malloc(n + sizeof(double))) == NULL)
  1765. !         fatal("xmalloc: no memory");
  1766.       *((double *) ptr) = MAGIC;        /* magic number */
  1767.       return(ptr + sizeof(double));
  1768.   }
  1769. --- 17,32 ----
  1770.   extern void exit();
  1771.   #endif
  1772.   
  1773. ! #define    MAGIC    (double)1234567890.12344
  1774.   
  1775.   char *
  1776. ! scxmalloc(n)
  1777.   unsigned n;
  1778.   {
  1779.       register char *ptr;
  1780.   
  1781.       if ((ptr = malloc(n + sizeof(double))) == NULL)
  1782. !         fatal("scxmalloc: no memory");
  1783.       *((double *) ptr) = MAGIC;        /* magic number */
  1784.       return(ptr + sizeof(double));
  1785.   }
  1786. ***************
  1787. *** 33,64 ****
  1788.   
  1789.   /* we make sure realloc will do a malloc if needed */
  1790.   char *
  1791. ! xrealloc(ptr, n)
  1792.   char    *ptr;
  1793.   unsigned n;
  1794.   {
  1795.       if (ptr == NULL)
  1796. !         return(xmalloc(n));
  1797.   
  1798.       ptr -= sizeof(double);
  1799.       if (*((double *) ptr) != MAGIC)
  1800. !         fatal("xrealloc: storage not xmalloc'ed");
  1801.   
  1802.       if ((ptr = realloc(ptr, n + sizeof(double))) == NULL)
  1803. !         fatal("xmalloc: no memory");
  1804.       *((double *) ptr) = MAGIC;        /* magic number */
  1805.       return(ptr + sizeof(double));
  1806.   }
  1807.   
  1808.   void
  1809. ! xfree(p)
  1810.   char *p;
  1811.   {
  1812.       if (p == NULL)
  1813. !         fatal("xfree: NULL");
  1814.       p -= sizeof(double);
  1815.       if (*((double *) p) != MAGIC)
  1816. !         fatal("xfree: storage not malloc'ed");
  1817.       free(p);
  1818.   }
  1819.   
  1820. --- 33,64 ----
  1821.   
  1822.   /* we make sure realloc will do a malloc if needed */
  1823.   char *
  1824. ! scxrealloc(ptr, n)
  1825.   char    *ptr;
  1826.   unsigned n;
  1827.   {
  1828.       if (ptr == NULL)
  1829. !         return(scxmalloc(n));
  1830.   
  1831.       ptr -= sizeof(double);
  1832.       if (*((double *) ptr) != MAGIC)
  1833. !         fatal("scxrealloc: storage not scxmalloc'ed");
  1834.   
  1835.       if ((ptr = realloc(ptr, n + sizeof(double))) == NULL)
  1836. !         fatal("scxmalloc: no memory");
  1837.       *((double *) ptr) = MAGIC;        /* magic number */
  1838.       return(ptr + sizeof(double));
  1839.   }
  1840.   
  1841.   void
  1842. ! scxfree(p)
  1843.   char *p;
  1844.   {
  1845.       if (p == NULL)
  1846. !         fatal("scxfree: NULL");
  1847.       p -= sizeof(double);
  1848.       if (*((double *) p) != MAGIC)
  1849. !         fatal("scxfree: storage not malloc'ed");
  1850.       free(p);
  1851.   }
  1852.   
  1853.  
  1854.