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