home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: Science / Science.zip / OS2SCALC.ZIP / CMDS.C next >
C/C++ Source or Header  |  1990-07-19  |  9KB  |  556 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.  *   OS/2 Modifications by Brady Flowers, 7/19/90
  11.  *
  12.  */
  13.  
  14. #include "sc.h"
  15.  
  16. #ifdef OS2
  17. #include <stdlib.h>
  18. #include <string.h>
  19. #include "curs.h"
  20. #else
  21. extern char *malloc();
  22. #endif
  23.  
  24. VOID duprow()
  25. {
  26.  
  27.   if (currow >= MAXROWS - 1 || maxrow >= MAXROWS - 1)
  28.   {
  29.       error ("The table can't be any bigger");
  30.       return;
  31.   }
  32.   modflg++;
  33.   currow++;
  34.   openrow (currow);
  35.   for (curcol = 0; curcol <= maxcol; curcol++)
  36.   {
  37.       register struct ent *p = tbl[currow - 1][curcol];
  38.  
  39.       if (p)
  40.     {
  41.         register struct ent *n;
  42.  
  43.         n = lookat (currow, curcol);
  44.         n -> v = p -> v;
  45.         n -> flags = p -> flags;
  46.         n -> expr = copye (p -> expr, 1, 0);
  47.         n -> label = 0;
  48.         if (p -> label)
  49.       {
  50.             n -> label = (char *)malloc (strlen (p -> label) + 1);
  51.             strcpy (n -> label, p -> label);
  52.         }
  53.       }
  54.   }
  55.   for (curcol = 0; curcol <= maxcol; curcol++)
  56.   {
  57.       register struct ent *p = tbl[currow][curcol];
  58.  
  59.       if (p && (p -> flags & is_valid) && !p -> expr)
  60.         break;
  61.   }
  62.   if (curcol > maxcol)
  63.       curcol = 0;
  64. }
  65.  
  66.  
  67.  
  68. VOID dupcol()
  69. {
  70.  
  71.   if (curcol >= MAXCOLS - 1 || maxcol >= MAXCOLS - 1)
  72.   {
  73.       error ("The table can't be any wider");
  74.       return;
  75.   }
  76.   modflg++;
  77.   curcol++;
  78.   opencol (curcol);
  79.   for (currow = 0; currow <= maxrow; currow++)
  80.   {
  81.       register struct ent *p = tbl[currow][curcol - 1];
  82.  
  83.       if (p)
  84.     {
  85.         register struct ent *n;
  86.  
  87.         n = lookat (currow, curcol);
  88.         n -> v = p -> v;
  89.         n -> flags = p -> flags;
  90.         n -> expr = copye (p -> expr, 0, 1);
  91.         n -> label = 0;
  92.         if (p -> label)
  93.       {
  94.             n -> label = (char *)malloc (strlen (p -> label) + 1);
  95.             strcpy (n -> label, p -> label);
  96.         }
  97.       }
  98.   }
  99.   for (currow = 0; currow <= maxrow; currow++)
  100.   {
  101.       register struct ent *p = tbl[currow][curcol];
  102.  
  103.       if (p && (p -> flags & is_valid) && !p -> expr)
  104.         break;
  105.   }
  106.   if (currow > maxrow)
  107.       currow = 0;
  108. }
  109.  
  110.  
  111.  
  112. VOID insertrow(arg)
  113. {
  114.  
  115.   while (--arg>=0) openrow (currow);
  116. }
  117.  
  118.  
  119.  
  120. VOID deleterow(arg)
  121. {
  122.  
  123.   flush_saved();
  124.   erase_area(currow, 0, currow + arg - 1, maxcol);
  125.   currow += arg;
  126.   while (--arg>=0) closerow (--currow);
  127.     sync_refs();
  128. }
  129.  
  130.  
  131.  
  132.  
  133. VOID insertcol(arg)
  134. {
  135.  
  136.   while (--arg>=0) opencol(curcol);
  137. }
  138.  
  139.  
  140.  
  141. VOID deletecol(arg)
  142. {
  143.  
  144.   flush_saved();
  145.   erase_area(0, curcol, maxrow, curcol + arg - 1);
  146.   curcol += arg;
  147.   while (--arg>=0) closecol (--curcol);
  148.     sync_refs();
  149. }
  150.  
  151.  
  152.  
  153. VOID valueizerow(arg)
  154. {
  155.  
  156.   valueize_area(currow, 0, currow + arg - 1, maxcol);
  157. }
  158.  
  159.  
  160.  
  161. VOID valueizecol(arg)
  162. {
  163.  
  164.   valueize_area(0, curcol, maxrow, curcol + arg - 1);
  165. }
  166.  
  167.  
  168.  
  169. VOID erase_area(sr, sc, er, ec)
  170. int sr, sc, er, ec;
  171. {
  172.   register int r, c;
  173.   register struct ent **p;
  174.  
  175.   if (sr > er)
  176.   {
  177.       r = sr; sr = er; er= r;
  178.   }
  179.  
  180.   if (sc > ec)
  181.   {
  182.       c = sc; sc = ec; ec= c;
  183.   }
  184.  
  185.   if (sr < 0)
  186.       sr = 0;
  187.   if (sc < 0)
  188.       sc = 0;
  189.   if (er >= MAXROWS)
  190.       er = MAXROWS-1;
  191.   if (ec >= MAXCOLS)
  192.       ec = MAXCOLS-1;
  193.  
  194.   for (r = sr; r <= er; r++)
  195.   {
  196.       for (c = sc; c <= ec; c++)
  197.     {
  198.         p = &tbl[r][c];
  199.         if (*p)
  200.       {
  201.             free_ent(*p);
  202.             *p = 0;
  203.         }
  204.       }
  205.   }
  206. }
  207.  
  208.  
  209.  
  210. VOID valueize_area(sr, sc, er, ec)
  211. int sr, sc, er, ec;
  212. {
  213.   register int r, c;
  214.   register struct ent *p;
  215.  
  216.   if (sr > er)
  217.   {
  218.       r = sr; sr = er; er= r;
  219.   }
  220.  
  221.   if (sc > ec)
  222.   {
  223.       c = sc; sc = ec; ec= c;
  224.   }
  225.  
  226.   if (sr < 0)
  227.       sr = 0;
  228.   if (sc < 0)
  229.       sc = 0;
  230.   if (er >= MAXROWS)
  231.       er = MAXROWS-1;
  232.   if (ec >= MAXCOLS)
  233.       ec = MAXCOLS-1;
  234.  
  235.   for (r = sr; r <= er; r++)
  236.   {
  237.       for (c = sc; c <= ec; c++)
  238.     {
  239.         p = tbl[r][c];
  240.         if (p && p->expr)
  241.       {
  242.             efree(p->expr);
  243.             p->expr = 0;
  244.         }
  245.       }
  246.   }
  247. }
  248.  
  249.  
  250.  
  251. VOID pullcells(to_insert)
  252. {
  253.   register struct ent *p, *n;
  254.   register int deltar, deltac;
  255.   int minrow, mincol;
  256.   int maxrow, maxcol;
  257.   int numrows, numcols;
  258.  
  259.   if (!to_fix)
  260.       return;
  261.  
  262.   switch (to_insert)
  263.   {
  264.     case 'm':
  265.     case 'r':
  266.     case 'c':
  267.         break;
  268.     default:
  269.         return;
  270.   }
  271.  
  272.   minrow = MAXROWS;
  273.   mincol = MAXCOLS;
  274.   maxrow = 0;
  275.   maxcol = 0;
  276.  
  277.   for (p = to_fix; p; p = p->next)
  278.   {
  279.       if (p->row < minrow)
  280.         minrow = p->row;
  281.       if (p->row > maxrow)
  282.         maxrow = p->row;
  283.       if (p->col < mincol)
  284.         mincol = p->col;
  285.       if (p->col > maxcol)
  286.         maxcol = p->col;
  287.   }
  288.  
  289.   numrows = maxrow - minrow + 1;
  290.   numcols = maxcol - mincol + 1;
  291.   deltar = currow - minrow;
  292.   deltac = curcol - mincol;
  293.  
  294.   if (to_insert == 'r')
  295.   {
  296.       insertrow(numrows);
  297.       deltac = 0;
  298.   }
  299.   else if (to_insert == 'c')
  300.   {
  301.       insertcol(numcols);
  302.       deltar = 0;
  303.   }
  304.  
  305.   FullUpdate++;
  306.   modflg++;
  307.  
  308.   for (p = to_fix; p; p = p->next)
  309.   {
  310.       n = lookat (p->row + deltar, p->col + deltac);
  311.       clearent(n);
  312.       n -> flags = p -> flags & ~is_deleted;
  313.       n -> v = p -> v;
  314.       n -> expr = copye(p->expr, deltar, deltac);
  315.       n -> label = 0;
  316.       if (p -> label)
  317.     {
  318.         n -> label = (char *)malloc(strlen(p->label)+1);
  319.         strcpy (n -> label, p -> label);
  320.       }
  321.   }
  322. }
  323.  
  324.  
  325.  
  326. VOID showcol_op()
  327. {
  328.   register int i,j;
  329.  
  330.   for (i=0; i<MAXCOLS; i++)
  331.     if (hidden_col[i])
  332.     break;
  333.  
  334.   for(j=i; j<MAXCOLS; j++)
  335.       if (!hidden_col[j])
  336.         break;
  337.  
  338.   j--;
  339.   if (i<MAXCOLS)
  340.   {
  341.       sprintf(line,"show %s:", coltoa(i));
  342.       sprintf(line + strlen(line),"%s",coltoa(j));
  343.       linelim = strlen (line);
  344.   }
  345. }
  346.  
  347.  
  348.  
  349. VOID showrow_op()
  350. {
  351.   register int i,j;
  352.  
  353.   for (i=0; i<MAXROWS; i++)
  354.       if (hidden_row[i])
  355.         break;
  356.  
  357.   for(j=i; j<MAXROWS; j++)
  358.       if (!hidden_row[j])
  359.     {
  360.         break;
  361.       }
  362.  
  363.   j--;
  364.   if (i<MAXROWS)
  365.   {
  366.       sprintf(line,"show %d:%d", i, j);
  367.     linelim = strlen (line);
  368.   }
  369. }
  370.  
  371.  
  372.  
  373. int get_qual()
  374. {
  375.   register int c;
  376.  
  377.   c = nmgetch();
  378.   switch (c)
  379.   {
  380.     case 'c':
  381.     case 'j':
  382.     case 'k':
  383.     case ctl('p'):
  384.     case ctl('n'):
  385.         return('c');
  386.         break;
  387.     case 'r':
  388.     case 'l':
  389.     case 'h':
  390.     case ctl('f'):
  391.     case ctl('b'):
  392.         return('r');
  393.         break;
  394.     default:
  395.         return(c);
  396.         break;
  397.   }
  398. }
  399.  
  400.  
  401.  
  402. VOID openrow(rs)
  403. {
  404.   register    r;
  405.   register struct ent **p;
  406.   register    c;
  407.   register    i;
  408.  
  409.   if (rs > maxrow) maxrow = rs;
  410.   if (maxrow >= MAXROWS - 1 || rs > MAXROWS - 1)
  411.   {
  412.       error ("The table can't be any longer");
  413.       return;
  414.   }
  415.   for (i = maxrow+1; i > rs; i--)
  416.   {
  417.       hidden_row[i] = hidden_row[i-1];
  418.   }
  419.  
  420.   for (r = ++maxrow; r > rs; r--)
  421.       for (c = maxcol + 1, p = &tbl[r][0]; --c >= 0; p++)
  422.         if (p[0] = p[-MAXCOLS])
  423.             p[0] -> row++;
  424.  
  425.   p = &tbl[rs][0];
  426.   for (c = maxcol + 1; --c >= 0;)
  427.       *p++ = 0;
  428.   FullUpdate++;
  429.   modflg++;
  430. }
  431.  
  432.  
  433.  
  434. VOID closerow (r)
  435. register r;
  436. {
  437.   register struct ent **p;
  438.   register c;
  439.   register int i;
  440.  
  441.   if (r > maxrow) return;
  442.  
  443.   p = &tbl[r][0];
  444.   for (c=maxcol+1; --c>=0; )
  445.   {
  446.       if (*p)
  447.         free_ent(*p);
  448.       *p++ = 0;
  449.   }
  450.  
  451.   for (i = r; i < MAXROWS - 1; i++)
  452.   {
  453.       hidden_row[i] = hidden_row[i+1];
  454.   }
  455.  
  456.   while (r<maxrow)
  457.   {
  458.       for (c = maxcol+1, p = &tbl[r][0]; --c>=0; p++)
  459.         if (p[0] = p[MAXCOLS])
  460.             p[0]->row--;
  461.  
  462.       r++;
  463.   }
  464.  
  465.   p = &tbl[maxrow][0];
  466.   for (c=maxcol+1; --c>=0; ) *p++ = 0;
  467.     maxrow--;
  468.   FullUpdate++;
  469.   modflg++;
  470. }
  471.  
  472.  
  473.  
  474. VOID opencol (cs)
  475. {
  476.   register r;
  477.   register struct ent **p;
  478.   register c;
  479.   register lim = maxcol-cs+1;
  480.   int i;
  481.  
  482.   if (cs > maxcol) maxcol = cs;
  483.   if (maxcol >= MAXCOLS - 1 || cs > MAXCOLS - 1)
  484.   {
  485.       error ("The table can't be any wider");
  486.       return;
  487.   }
  488.   for (i = maxcol+1; i > cs; i--)
  489.   {
  490.       fwidth[i] = fwidth[i-1];
  491.       precision[i] = precision[i-1];
  492.       hidden_col[i] = hidden_col[i-1];
  493.   }
  494.   /* fwidth[cs] = DEFWIDTH;
  495.   precision[i] =  DEFPREC;  */
  496.  
  497.   for (r=0; r<=maxrow; r++)
  498.   {
  499.       p = &tbl[r][maxcol+1];
  500.  
  501.       for (c=lim; --c>=0; p--)
  502.         if (p[0] = p[-1])
  503.             p[0]->col++;
  504.  
  505.       p[0] = 0;
  506.   }
  507.   maxcol++;
  508.   FullUpdate++;
  509.   modflg++;
  510. }
  511.  
  512.  
  513.  
  514.  
  515. VOID closecol (cs)
  516. {
  517.   register r;
  518.   register struct ent **p;
  519.   register struct ent *q;
  520.   register c;
  521.   register lim = maxcol-cs;
  522.   int i;
  523.  
  524.   if (lim < 0) return;
  525.  
  526.   for (r=0; r<=maxrow; r++)
  527.       if (q = tbl[r][cs])
  528.     {
  529.         free_ent(q);
  530.       }
  531.  
  532.   for (r=0; r<=maxrow; r++)
  533.   {
  534.       p = &tbl[r][cs];
  535.  
  536.       for (c=lim; --c>=0; p++)
  537.         if (p[0] = p[1])
  538.             p[0]->col--;
  539.  
  540.       p[0] = 0;
  541.   }
  542.  
  543.   for (i = cs; i < MAXCOLS - 1; i++)
  544.   {
  545.       fwidth[i] = fwidth[i+1];
  546.       precision[i] = precision[i+1];
  547.       hidden_col[i] = hidden_col[i+1];
  548.   }
  549.  
  550.   maxcol--;
  551.   FullUpdate++;
  552.   modflg++;
  553. }
  554.  
  555.  
  556.