home *** CD-ROM | disk | FTP | other *** search
/ SPACE 2 / SPACE - Library 2 - Volume 1.iso / apps / 123 / vcsrc / sc.c < prev    next >
Encoding:
C/C++ Source or Header  |  1987-05-10  |  18.8 KB  |  854 lines
  1. /*    SC    A Spreadsheet Calculator 
  2.  *        Main driver 
  3.  * 
  4.  *        original by James Gosling, September 1982 
  5.  *        modifications by Mark Weiser and Bruce Israel, 
  6.  *            University of Maryland 
  7.  * 
  8.  *              More mods Robert Bond, 12/86 
  9.  *        Major mods to run on VMS and AMIGA, 1/17/87 
  10.  * 
  11.  */ 
  12.  
  13. #include "sc.h" 
  14.  
  15. extern char *malloc(); 
  16.  
  17. /* default column width */ 
  18.  
  19. #define DEFWIDTH 10 
  20. #define DEFPREC   2 
  21.  
  22. #define RESCOL 4  /* columns reserved for row numbers */ 
  23. #define RESROW 3  /* rows reserved for prompt, error, and column numbers */ 
  24.  
  25. char curfile[1024]; 
  26.  
  27. int showme = 1;  /* 1 to display the current cell in the top line */ 
  28. int batch = 0; 
  29.  
  30. error (fmt,a,b,c,d,e) { 
  31.     if (batch) fprintf(stderr,fmt,a,b,c,d,e); 
  32.     else { 
  33.     move (1,0); 
  34.     clrtoeol (); 
  35.     printw (fmt,a,b,c,d,e); 
  36.     } 
  37. } 
  38.  
  39. int seenerr; 
  40.  
  41. yyerror (err) 
  42. char *err; { 
  43.     if (seenerr) return; 
  44.     seenerr++; 
  45.     move (1,0); 
  46.     clrtoeol (); 
  47. #ifdef TOS 
  48.     { 
  49.         char format[20]; 
  50.         sprintf(format,"%%s: %%.%ds <= %%s",linelim); 
  51.         printw(format,err,line,line+linelim); 
  52.     } 
  53. #else 
  54.     printw ("%s: %.*s <= %s",err,linelim,line,line+linelim); 
  55. #endif 
  56. } 
  57.  
  58. struct ent * 
  59. lookat(row,col){ 
  60.     register struct ent **p; 
  61.     if (row < 0) 
  62.     row = 0; 
  63.     else if (row > MAXROWS-1) 
  64.     row = MAXROWS-1; 
  65.     if (col < 0) 
  66.     col = 0; 
  67.     else if (col > MAXCOLS-1) 
  68.     col = MAXCOLS-1; 
  69.     p = &tbl[row][col]; 
  70.     if (*p==0) { 
  71.     *p = (struct ent *) malloc (sizeof (struct ent)); 
  72.     if (row>maxrow) maxrow = row; 
  73.     if (col>maxcol) maxcol = col; 
  74.     (*p)->label = 0; 
  75.     (*p)->flags = 0; 
  76.     (*p)->row = row; 
  77.     (*p)->col = col; 
  78.     (*p)->expr = 0; 
  79.     (*p)->v = (double) 0.0; 
  80.     } else if ((*p)->flags & is_deleted) 
  81.     debug("But %s%d has been deleted!", coltoa(col), row); 
  82.     return *p; 
  83. } 
  84.  
  85. /* 
  86.  * This structure is used to keep ent structs around before they 
  87.  * are deleted to allow the sync_refs routine a chance to fix the 
  88.  * variable references. 
  89.  * We also use it as a last-deleted buffer for the 'p' command. 
  90.  */ 
  91.  
  92. free_ent(p) 
  93. register struct ent *p; 
  94. { 
  95.     p->next = to_fix; 
  96.     to_fix = p; 
  97.     p->flags |= is_deleted; 
  98. } 
  99.  
  100. flush_saved() 
  101. { 
  102.     register struct ent *p; 
  103.     register struct ent *q; 
  104.  
  105.     if (!(p = to_fix)) 
  106.     return; 
  107.     while (p) { 
  108.     clearent(p); 
  109.     q = p->next; 
  110.     free(p); 
  111.     p = q; 
  112.     } 
  113.     to_fix = 0; 
  114. } 
  115.  
  116. update () { 
  117.     register    row, 
  118.                 col; 
  119.     register struct ent **p; 
  120.     static  lastmx, 
  121.             lastmy; 
  122.     static  char *under_cursor = " "; 
  123.     int     maxcol; 
  124.     int     maxrow; 
  125.     int     rows; 
  126.     int     cols; 
  127.     register r; 
  128.  
  129.     while (hidden_row[currow])   /* You can't hide the last row or col */ 
  130.     currow++; 
  131.     while (hidden_col[curcol]) 
  132.     curcol++; 
  133.     if (curcol < stcol) 
  134.     stcol = curcol, FullUpdate++; 
  135.     if (currow < strow) 
  136.     strow = currow, FullUpdate++; 
  137.     while (1) { 
  138.     register    i; 
  139.     for (i = stcol, cols = 0, col = RESCOL; 
  140.          (col + fwidth[i]) < COLS-1 && i < MAXCOLS; i++) { 
  141.         cols++; 
  142.         if (hidden_col[i]) 
  143.         continue; 
  144.         col += fwidth[i]; 
  145.     } 
  146.     if (curcol >= stcol + cols) 
  147.         stcol++, FullUpdate++; 
  148.     else 
  149.         break; 
  150.     } 
  151.     while (1) { 
  152.     register    i; 
  153.     for (i = strow, rows = 0, row = RESROW; 
  154.          row < ROWS && i < MAXROWS; i++) { 
  155.         rows++; 
  156.         if (hidden_row[i]) 
  157.         continue; 
  158.         row++; 
  159.     } 
  160.     if (currow >= strow + rows) 
  161.         strow++, FullUpdate++; 
  162.     else 
  163.         break; 
  164.     } 
  165.     maxcol = stcol + cols - 1; 
  166.     maxrow = strow + rows - 1; 
  167.     if (FullUpdate) { 
  168.     register int i; 
  169.     move (2, 0); 
  170.     clrtobot (); 
  171.     standout(); 
  172.     for (row=RESROW, i=strow; i <= maxrow; i++) { 
  173.         if (hidden_row[i]) 
  174.         continue; 
  175.         move(row,0); 
  176. #ifdef TOS 
  177.         { 
  178.             char format[10]; 
  179.             sprintf(format,"%%-%dd",RESCOL); 
  180.             printw(format,i); 
  181.         } 
  182. #else 
  183.         printw("%-*d", RESCOL, i); 
  184. #endif 
  185.         row++; 
  186.     } 
  187.     move (2,0); 
  188. #ifdef TOS 
  189.     { 
  190.         char format[10]; 
  191.         sprintf(format,"%%%ds",RESCOL); 
  192.         printw(format," "); 
  193.     } 
  194. #else 
  195.     printw("%*s", RESCOL, " "); 
  196. #endif 
  197.     for (col=RESCOL, i = stcol; i <= maxcol; i++) { 
  198.         if (hidden_col[i]) 
  199.         continue; 
  200.         move(2, col); 
  201. #ifdef TOS 
  202.     { 
  203.         char format[10]; 
  204.         sprintf(format,"%%%ds",fwidth[i]); 
  205.         printw(format,coltoa(i)); 
  206.     } 
  207. #else 
  208.         printw("%*s", fwidth[i], coltoa(i)); 
  209. #endif 
  210.         col += fwidth[i]; 
  211.     } 
  212.     standend(); 
  213.     } 
  214.     for (row = strow, r = RESROW; row <= maxrow; row++) { 
  215.     register    c = RESCOL; 
  216.     if (hidden_row[row]) 
  217.         continue; 
  218.     for (p = &tbl[row][col = stcol]; col <= maxcol; col++, p++) { 
  219.         if (hidden_col[col]) 
  220.         continue; 
  221.         if (*p && ((*p) -> flags & is_changed || FullUpdate)) { 
  222.         char   *s; 
  223.         move (r, c); 
  224.         (*p) -> flags &= ~is_changed; 
  225.         if ((*p) -> flags & is_valid) 
  226. #ifdef TOS 
  227.             { 
  228.                 char format[16]; 
  229.                 sprintf(format,"%%%d.%df",fwidth[col],precision[col]); 
  230.                 printw(format,(*p)->v); 
  231.             } 
  232. #else 
  233.             printw ("%*.*f", fwidth[col], precision[col], (*p) -> v); 
  234. #endif 
  235.         if (s = (*p) -> label) { 
  236.             char field[1024]; 
  237.  
  238.             strncpy(field,s,fwidth[col]); 
  239.             field[fwidth[col]] = 0; 
  240.             move (r,(*p) -> flags & is_leftflush 
  241.                 ? c : c - strlen (field) + fwidth[col]); 
  242.             addstr(field); 
  243.         } 
  244.         } 
  245.         c += fwidth[col]; 
  246.     } 
  247.     r++; 
  248.     } 
  249.     
  250.     move(lastmy, lastmx); 
  251.     if (inch() == '<') 
  252.         addstr (under_cursor); 
  253.     lastmy =  RESROW; 
  254.     for (row = strow; row < currow; row++) 
  255.     if (!hidden_row[row]) 
  256.         lastmy += 1; 
  257.     lastmx = RESCOL; 
  258.     for (col = stcol; col <= curcol; col++) 
  259.     if (!hidden_col[col]) 
  260.         lastmx += fwidth[col]; 
  261.     move(lastmy, lastmx); 
  262.     *under_cursor = inch(); 
  263.     addstr ("<"); 
  264.     move (0, 0); 
  265.     clrtoeol (); 
  266.     if (linelim >= 0) { 
  267.     addstr (">> "); 
  268.     addstr (line); 
  269.     } else { 
  270.     if (showme) { 
  271.         register struct ent *p; 
  272.         p = tbl[currow][curcol]; 
  273.         if (p && ((p->flags & is_valid) || p->label)) { 
  274.         if (p->expr || !p->label) { 
  275.             linelim = 0; 
  276.             editexp(currow, curcol); 
  277.         } else { 
  278.             sprintf(line, "%s", p->label); 
  279.         } 
  280.         addstr("["); 
  281.         addstr (line); 
  282.         addstr("]"); 
  283.         linelim = -1; 
  284.         } else { 
  285.         addstr("[]"); 
  286.         } 
  287.     } 
  288.     move (lastmy, lastmx); 
  289.     } 
  290.     FullUpdate = 0; 
  291. } 
  292.  
  293. void 
  294. quit() 
  295. { 
  296.     endwin (); 
  297.     exit(); 
  298. } 
  299.  
  300. main (argc, argv) 
  301. char  **argv; { 
  302.     int     inloop = 1; 
  303.     register int   c; 
  304.     int     edistate = -1; 
  305.     int     arg = 1; 
  306.     int     narg; 
  307.     int     nedistate = -1; 
  308.     int        running = 1; 
  309.     { 
  310.     register    i; 
  311.     for (i = 0; i < MAXCOLS; i++) { 
  312.         fwidth[i] = DEFWIDTH; 
  313.         precision[i] = DEFPREC; 
  314.     } 
  315.     } 
  316.     linelim = -1; 
  317.     curfile[0]=0; 
  318.     running = 1; 
  319.  
  320.     if (argc > 1 && (! strcmp(argv[1],"-b"))) { 
  321.     argc--, argv++; 
  322.     batch = 1; 
  323.     } 
  324.  
  325.     if (! batch) { 
  326.     initscr (); 
  327.     } 
  328.     initkbd(); 
  329.     if (argc > 1) { 
  330.     strcpy(curfile,argv[1]); 
  331.     readfile (argv[1],0); 
  332.     } 
  333.     modflg = 0; 
  334.     if (batch) exit(0); 
  335.     error ("VC 2.1  Type '?' for help."); 
  336.     FullUpdate++; 
  337.     while (inloop) { running = 1; 
  338.     while (running) { 
  339.     nedistate = -1; 
  340.     narg = 1; 
  341.     if (edistate < 0 && linelim < 0 && (changed || FullUpdate)) 
  342.         EvalAll (), changed = 0; 
  343.     update (); 
  344.     refresh (); 
  345.     move (1, 0); 
  346.     clrtoeol (); 
  347.     fflush (stdout); 
  348.     seenerr = 0; 
  349.     if (((c = nmgetch ()) < ' ') || ( c == 0177 )) 
  350.         switch (c) { 
  351.         case ctl (z): 
  352.             quit(); 
  353.             break; 
  354.         case ctl (r): 
  355.             FullUpdate++; 
  356.             touchwin(); 
  357.             clear(); 
  358.             break; 
  359.         default: 
  360.             error ("No such command  (^%c)", c + 0100); 
  361.             break; 
  362.         case ctl (b): 
  363.             while (--arg>=0) { 
  364.             if (curcol) 
  365.                 curcol--; 
  366.             else 
  367.                 error ("At column A"); 
  368.             while(hidden_col[curcol] && curcol) 
  369.                 curcol--; 
  370.             } 
  371.             break; 
  372.         case ctl (c): 
  373.             running = 0; 
  374.             break; 
  375.         case ctl (f): 
  376.             while (--arg>=0) { 
  377.             if (curcol < MAXCOLS - 1) 
  378.                 curcol++; 
  379.             else 
  380.                 error ("The table can't be any wider"); 
  381.             while(hidden_col[curcol]&&(curcol<MAXCOLS-1)) 
  382.                 curcol++; 
  383.             } 
  384.             break; 
  385.         case ctl (g): 
  386.         case ctl ([): 
  387.             linelim = -1; 
  388.             move (1, 0); 
  389.             clrtoeol (); 
  390.             break; 
  391.         case 0177: 
  392.         case ctl (h): 
  393.             while (--arg>=0) if (linelim > 0) 
  394.             line[--linelim] = 0; 
  395.             break; 
  396.         case ctl (l): 
  397.             FullUpdate++; 
  398.             break; 
  399.         case ctl (m): 
  400.             if (linelim < 0) 
  401.             line[linelim = 0] = 0; 
  402.             else { 
  403.             linelim = 0; 
  404.             yyparse (); 
  405.             linelim = -1; 
  406.             } 
  407.             break; 
  408.         case ctl (n): 
  409.             while (--arg>=0) { 
  410.             if (currow < MAXROWS - 1) 
  411.                 currow++; 
  412.             else 
  413.                 error ("The table can't be any longer"); 
  414.             while (hidden_row[currow] && (currow < MAXROWS - 1)) 
  415.                 currow++; 
  416.             } 
  417.             break; 
  418.         case ctl (p): 
  419.             while (--arg>=0) { 
  420.             if (currow) 
  421.                 currow--; 
  422.             else 
  423.                 error ("At row zero"); 
  424.             while (hidden_row[currow] && currow) 
  425.                 currow--; 
  426.             } 
  427.             break; 
  428.         case ctl (q): 
  429.             break;    /* ignore flow control */ 
  430.         case ctl (s): 
  431.             break;    /* ignore flow control */ 
  432.         case ctl (t): 
  433.             showme ^= 1; 
  434.             break; 
  435.         case ctl (u): 
  436.             narg = arg * 4; 
  437.             nedistate = 1; 
  438.             break; 
  439.         case ctl (v):    /* insert variable name */ 
  440.             if (linelim > 0) { 
  441.             sprintf (line+linelim,"%s%d", coltoa(curcol), currow); 
  442.             linelim = strlen (line); 
  443.             } 
  444.             break; 
  445.         case ctl (e):    /* insert variable expression */ 
  446.             if (linelim > 0) editexp(currow,curcol); 
  447.             break; 
  448.         case ctl (a):    /* insert variable value */ 
  449.             if (linelim > 0) { 
  450.             struct ent *p = tbl[currow][curcol]; 
  451.  
  452.             if (p && p -> flags & is_valid) { 
  453.                 sprintf (line + linelim, "%.*f", 
  454.                     precision[curcol],p -> v); 
  455.                 linelim = strlen (line); 
  456.             } 
  457.             } 
  458.             break; 
  459.         } 
  460.     else 
  461.         if ('0' <= c && c <= '9' && (linelim < 0 || edistate >= 0)) { 
  462.         if (edistate != 0) { 
  463.             if (c == '0')      /* just a '0' goes to left col */ 
  464.             curcol = 0; 
  465.             else { 
  466.                 nedistate = 0; 
  467.                 narg = c - '0'; 
  468.             } 
  469.         } else { 
  470.             nedistate = 0; 
  471.             narg = arg * 10 + (c - '0'); 
  472.         } 
  473.         } 
  474.         else 
  475.         if (linelim >= 0) { 
  476.             line[linelim++] = c; 
  477.             line[linelim] = 0; 
  478.         } 
  479.         else 
  480.             switch (c) { 
  481.             case '.': 
  482.                 nedistate = 1; 
  483.                 break; 
  484.             case ':': 
  485.                 break;    /* Be nice to vi users */ 
  486.             case '=': 
  487.                 sprintf(line,"let %s%d = ",coltoa(curcol),currow); 
  488.                 linelim = strlen (line); 
  489.                 break; 
  490.             case '/': 
  491.                 sprintf(line,"copy [to] %s%d [from] ", 
  492.                       coltoa(curcol), currow); 
  493.                 linelim = strlen (line); 
  494.                 break; 
  495.             case '$': 
  496.                 curcol = MAXCOLS - 1; 
  497.                 while (!tbl[currow][curcol] && curcol > 0) 
  498.                 curcol--; 
  499.                 break; 
  500.             case '?': 
  501.                 help (); 
  502.                 break; 
  503.             case '"': 
  504.                 sprintf (line, "label %s%d = \"", 
  505.                         coltoa(curcol), currow); 
  506.                 linelim = strlen (line); 
  507.                 break; 
  508.             case '<': 
  509.                 sprintf (line, "leftstring %s%d = \"", 
  510.                     coltoa(curcol), currow); 
  511.                 linelim = strlen (line); 
  512.                 break; 
  513.             case '>': 
  514.                 sprintf (line, "rightstring %s%d = \"", 
  515.                     coltoa(curcol), currow); 
  516.                 linelim = strlen (line); 
  517.                 break; 
  518.             case 'e': 
  519.                 editv (currow, curcol); 
  520.                 break; 
  521.             case 'E': 
  522.                 edits (currow, curcol); 
  523.                 break; 
  524.             case 'f': 
  525.                 sprintf (line, "format [for column] %s [is] ", 
  526.                     coltoa(curcol)); 
  527.                 error("Current format is %d %d", 
  528.                     fwidth[curcol],precision[curcol]); 
  529.                 linelim = strlen (line); 
  530.                 break; 
  531.             case 'P': 
  532.                 sprintf (line, "put [database into] \""); 
  533.                 if (*curfile) 
  534.                 error("default file is '%s'",curfile); 
  535.                 linelim = strlen (line); 
  536.                 break; 
  537.             case 'M': 
  538.                 sprintf (line, "merge [database from] \""); 
  539.                 linelim = strlen (line); 
  540.                 break; 
  541.             case 'G': 
  542.                 sprintf (line, "get [database from] \""); 
  543.                 if (*curfile) 
  544.                 error("default file is '%s'",curfile); 
  545.                 linelim = strlen (line); 
  546.                 break; 
  547.             case 'W': 
  548.                 sprintf (line, "write [listing to] \""); 
  549.                 linelim = strlen (line); 
  550.                 break; 
  551.             case 'T':    /* tbl output */ 
  552.                 sprintf (line, "tbl [listing to] \""); 
  553.                 linelim = strlen (line); 
  554.                 break; 
  555.             case 'i': 
  556.                 switch (get_qual()) { 
  557.                 case 'r': 
  558.                 insertrow(arg); 
  559.                 break; 
  560.                 case 'c': 
  561.                 insertcol(arg); 
  562.                 break; 
  563.                 default: 
  564.                 break; 
  565.                 } 
  566.                 break; 
  567.             case 'd': 
  568.                 switch (get_qual()) { 
  569.                 case 'r': 
  570.                 deleterow(arg); 
  571.                 break; 
  572.                 case 'c': 
  573.                 deletecol(arg); 
  574.                 break; 
  575.                 default: 
  576.                 break; 
  577.                 } 
  578.                 break; 
  579.             case 'v': 
  580.                 switch (get_qual()) { 
  581.                 case 'r': 
  582.                 valueizerow(arg); 
  583.                 break; 
  584.                 case 'c': 
  585.                 valueizecol(arg); 
  586.                 break; 
  587.                 default: 
  588.                 break; 
  589.                 } 
  590.                 break; 
  591.             case 'p': 
  592.                 { 
  593.                 register qual; 
  594.                 qual = get_qual(); 
  595.                 while (arg--) 
  596.                     pullcells(qual); 
  597.                 break; 
  598.                 } 
  599.             case 'x': 
  600.                 { 
  601.                 register struct ent **p; 
  602.                 register int c; 
  603.                 flush_saved(); 
  604.                 for (c = curcol; arg-- && c < MAXCOLS; c++) { 
  605.                 p = &tbl[currow][c]; 
  606.                 if (*p) { 
  607.                         free_ent(*p); 
  608.                         *p = 0; 
  609.                 } 
  610.                 } 
  611.                 sync_refs(); 
  612.                 FullUpdate++; 
  613.                 } 
  614.                 break; 
  615.             case 'Q': 
  616.             case 'q': 
  617.                 running = 0; 
  618.                 break; 
  619.             case 'h': 
  620.                 while (--arg>=0) { 
  621.                 if (curcol) 
  622.                     curcol--; 
  623.                 else 
  624.                     error ("At column A"); 
  625.                 while(hidden_col[curcol] && curcol) 
  626.                     curcol--; 
  627.                 } 
  628.                 break; 
  629.             case 'j': 
  630.                 while (--arg>=0) { 
  631.                 if (currow < MAXROWS - 1) 
  632.                     currow++; 
  633.                 else 
  634.                     error ("The table can't be any longer"); 
  635.                 while (hidden_row[currow]&&(currow<MAXROWS-1)) 
  636.                     currow++; 
  637.                 } 
  638.                 break; 
  639.             case 'k': 
  640.                 while (--arg>=0) { 
  641.                 if (currow) 
  642.                     currow--; 
  643.                 else 
  644.                     error ("At row zero"); 
  645.                 while (hidden_row[currow] && currow) 
  646.                     currow--; 
  647.                 } 
  648.                 break; 
  649.             case 'l': 
  650.                 while (--arg>=0) { 
  651.                 if (curcol < MAXCOLS - 1) 
  652.                     curcol++; 
  653.                 else 
  654.                     error ("The table can't be any wider"); 
  655.                 while(hidden_col[curcol]&&(curcol<MAXCOLS-1)) 
  656.                     curcol++; 
  657.                 } 
  658.                 break; 
  659.             case 'm': 
  660.                 savedrow = currow; 
  661.                 savedcol = curcol; 
  662.                 break; 
  663.             case 'c': { 
  664.                 register struct ent *p = tbl[savedrow][savedcol]; 
  665.                 register c; 
  666.                 register struct ent *n; 
  667.                 if (!p) 
  668.                 break; 
  669.                 FullUpdate++; 
  670.                 modflg++; 
  671.                 for (c = curcol; arg-- && c < MAXCOLS; c++) { 
  672.                 n = lookat (currow, c); 
  673.                 clearent(n); 
  674.                 n -> flags = p -> flags; 
  675.                 n -> v = p -> v; 
  676.                 n -> expr = copye(p->expr, 
  677.                         currow - savedrow, 
  678.                         c - savedcol); 
  679.                 n -> label = 0; 
  680.                 if (p -> label) { 
  681.                     n -> label = (char *) 
  682.                          malloc(strlen(p->label)+1); 
  683.                 strcpy (n -> label, p -> label); 
  684.                 } 
  685.                 } 
  686.                 break; 
  687.             } 
  688.             case 'z': 
  689.                 switch (get_qual()) { 
  690.                 case 'r': 
  691.                 hiderow(arg); 
  692.                 break; 
  693.                 case 'c': 
  694.                 hidecol(arg); 
  695.                 break; 
  696.                 default: 
  697.                 break; 
  698.                 } 
  699.                 break; 
  700.             case 's': 
  701.                 switch (get_qual()) { 
  702.                 case 'r': 
  703.                 showrow_op(); 
  704.                 break; 
  705.                 case 'c': 
  706.                 showcol_op(); 
  707.                 break; 
  708.                 default: 
  709.                 break; 
  710.                 } 
  711.                 break; 
  712.             case 'a': 
  713.                 switch (get_qual()) { 
  714.                 case 'r': 
  715.                 while (arg--) 
  716.                     duprow(); 
  717.                 break; 
  718.                 case 'c': 
  719.                 while (arg--) 
  720.                     dupcol(); 
  721.                 break; 
  722.                 default: 
  723.                 break; 
  724.                 } 
  725.                 break; 
  726.             default: 
  727.                 if ((c & 0177) != c) 
  728.                 error("Weird character, decimal '%d'.\n", 
  729.                     (int) c); 
  730.                 else error ("No such command  (%c)", c); 
  731.                 break; 
  732.             } 
  733.     edistate = nedistate; 
  734.     arg = narg; 
  735.     }                /* while (running) */ 
  736.     inloop = modcheck(" before exiting"); 
  737.     }                /*  while (inloop) */ 
  738.     endwin (); 
  739. } 
  740.  
  741. modcheck(endstr) char *endstr; { 
  742.     if (modflg && curfile[0]) { 
  743.     char ch, lin[100]; 
  744.  
  745.     move (0, 0); 
  746.     clrtoeol (); 
  747.     sprintf (lin,"File '%s' is modified, save%s? ",curfile,endstr); 
  748.     addstr (lin); 
  749.     refresh(); 
  750.     ch = nmgetch(); 
  751.     if (ch == 'y' || ch == 'Y') writefile(curfile); 
  752.     else if (ch == ctl (g)) return(1); 
  753.     } 
  754.     return(0); 
  755. } 
  756.     
  757. writefile (fname) 
  758. char *fname; { 
  759.     register FILE *f; 
  760.     register struct ent **p; 
  761.     register r, c; 
  762.     char save[1024]; 
  763.  
  764.     if (*fname == 0) fname = &curfile[0]; 
  765.  
  766.     strcpy(save,fname); 
  767.  
  768.     f = fopen (fname, "w"); 
  769.     if (f==0) { 
  770.     error ("Can't create %s", fname); 
  771.     return; 
  772.     } 
  773.  
  774.     fprintf (f, "# This data file was generated by the Spreadsheet "); 
  775.     fprintf (f, "Calculator.\n"); 
  776.     fprintf (f, "# You almost certainly shouldn't edit it.\n\n"); 
  777.     for (c=0; c<MAXCOLS; c++) 
  778.     if (fwidth[c] != DEFWIDTH || precision[c] != DEFPREC) 
  779.         fprintf (f, "format %s %d %d\n",coltoa(c),fwidth[c],precision[c]); 
  780.     for (r=0; r<=maxrow; r++) { 
  781.     p = &tbl[r][0]; 
  782.     for (c=0; c<=maxcol; c++, p++) 
  783.         if (*p) { 
  784.         if ((*p)->label) 
  785.             fprintf (f, "%sstring %s%d = \"%s\"\n", 
  786.                 (*p)->flags&is_leftflush ? "left" : "right", 
  787.                 coltoa(c),r,(*p)->label); 
  788.         if ((*p)->flags&is_valid) { 
  789.             editv (r, c); 
  790.             fprintf (f, "%s\n",line); 
  791.         } 
  792.         } 
  793.     } 
  794.     fclose (f); 
  795.     strcpy(curfile,save); 
  796.  
  797.     modflg = 0; 
  798.     error("File '%s' written.",curfile); 
  799. } 
  800.  
  801. readfile (fname,eraseflg) 
  802. char *fname; int eraseflg; { 
  803.     register FILE *f; 
  804.     char save[1024]; 
  805.  
  806.     if (*fname == 0) fname = &curfile[0]; 
  807.     strcpy(save,fname); 
  808.  
  809.     if (eraseflg && strcmp(fname,curfile) && modcheck(" first")) return; 
  810.  
  811.     f = fopen (save, "r"); 
  812.     if (f==0) { 
  813.     error ("Can't read %s", save); 
  814.     return; 
  815.     } 
  816.  
  817.     if (eraseflg) erasedb (); 
  818.  
  819.     while (fgets(line,sizeof line,f)) { 
  820.     linelim = 0; 
  821.     if (line[0] != '#') yyparse (); 
  822.     } 
  823.     fclose (f); 
  824.     linelim = -1; 
  825.     modflg++; 
  826.     if (eraseflg) { 
  827.     strcpy(curfile,save); 
  828.     modflg = 0; 
  829.     } 
  830.     EvalAll(); 
  831. } 
  832.  
  833. erasedb () { 
  834.     register r, c; 
  835.     for (c = 0; c<=maxcol; c++) { 
  836.     fwidth[c] = DEFWIDTH; 
  837.     precision[c] = DEFPREC; 
  838.     } 
  839.  
  840.     for (r = 0; r<=maxrow; r++) { 
  841.     register struct ent **p = &tbl[r][0]; 
  842.     for (c=0; c++<=maxcol; p++) 
  843.         if (*p) { 
  844.         if ((*p)->expr) efree ((*p) -> expr); 
  845.         if ((*p)->label) free ((*p) -> label); 
  846.         free (*p); 
  847.         *p = 0; 
  848.         } 
  849.     } 
  850.     maxrow = 0; 
  851.     maxcol = 0; 
  852.     FullUpdate++; 
  853. } 
  854.