home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 498a.lha / SC_v6.7 / vmtbl.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-04-08  |  4.5 KB  |  198 lines
  1. #ifdef PSC
  2. # include <stdio.h>
  3. # include "sc.h"
  4. # ifndef FALSE
  5. #  define    FALSE    0
  6. #  define    TRUE    1
  7. # endif /* !FALSE */
  8. # undef    error
  9. # define error(msg)    fprintf(stderr, msg);
  10. #else /* PSC */
  11. # include <curses.h>
  12. # include "sc.h"
  13. #endif /* PSC */
  14.  
  15. extern    char    *malloc();
  16. extern    char    *realloc();
  17.  
  18. #if defined(BSD42) || defined(BSD43)
  19. #define    memcpy(dest, source, len)    bcopy(source, dest, (unsigned int)len);
  20. #define    memset(dest, zero, len)        bzero((dest), (unsigned int)(len));
  21. #endif
  22.  
  23. /*
  24.  * check to see if *rowp && *colp are currently allocated, if not expand the
  25.  * current size if we can.
  26.  */
  27. #ifndef PSC
  28. void
  29. checkbounds(rowp, colp)
  30. int    *rowp;
  31. int    *colp;
  32. {
  33.     if (*rowp < 0)
  34.         *rowp = 0;
  35.     else if (*rowp >= maxrows)
  36.     {    if (*colp >= maxcols)
  37.         {    if (!growtbl(GROWBOTH, *rowp, *colp))
  38.             {    *rowp = maxrows -1;
  39.                 *colp = maxcols -1;
  40.             }
  41.             return;
  42.         }
  43.         else
  44.         {    if (!growtbl(GROWROW, *rowp, 0))
  45.                 *rowp = maxrows-1;
  46.             return;
  47.         }
  48.     }
  49.     if (*colp < 0) 
  50.         *colp = 0;
  51.     else if (*colp >= maxcols)
  52.     {    if (!growtbl(GROWCOL, 0, *colp));
  53.             *colp = maxcols-1;
  54.     }
  55. }
  56. #endif /* !PSC */
  57.     
  58.  
  59. #define GROWALLOC(newptr, oldptr, nelem, type, msg) \
  60.     if (oldptr == (type *)NULL) \
  61.         newptr = (type *)malloc((unsigned)(nelem*sizeof(type))); \
  62.     else \
  63.         newptr = (type *)realloc((char *)oldptr, \
  64.                      (unsigned)(nelem*sizeof(type))); \
  65.     if (newptr == (type *)NULL) \
  66.     {   error(msg); \
  67.         return(FALSE); \
  68.     } \
  69.     oldptr = newptr /* wait incase we can't alloc */
  70.  
  71. static    char    nolonger[] = "The table can't be any longer";
  72. static    char    nowider[] = "The table can't be any wider";
  73.  
  74. /*
  75.  * grow the main && auxiliary tables (reset maxrows/maxcols as needed)
  76.  * toprow &&/|| topcol tell us a better guess of how big to become.
  77.  * we return TRUE if we could grow, FALSE if not....
  78.  */
  79. int
  80. growtbl(rowcol, toprow, topcol)
  81. int    rowcol;
  82. int    toprow, topcol;
  83. {
  84.     struct ent ***tbl2;
  85.     int    *fwidth2;
  86.     int    *precision2;
  87.     char    *col_hidden2;
  88.     char    *row_hidden2;
  89.     int    newrows, newcols;
  90.     int    i;
  91.  
  92. #ifndef PSC
  93.     newrows = maxrows;
  94. #endif /* !PSC */
  95.  
  96.     newcols = maxcols;
  97.     if (rowcol == GROWNEW)
  98.     {
  99. #ifndef PSC
  100.         maxrows = toprow = 0;
  101.         /* when we first start up, fill the screen w/ cells */
  102.         {    int startval;
  103.             startval = LINES - RESROW;
  104.             newrows = startval > MINROWS ? startval : MINROWS;
  105.             startval = ((COLS) - RESCOL) / DEFWIDTH;
  106.             newcols = startval > MINCOLS ? startval : MINCOLS;
  107.         }
  108. #else
  109.         newcols = MINCOLS;
  110. #endif /* !PSC */
  111.         maxcols = topcol = 0;
  112.     }
  113. #ifndef PSC
  114.     /* set how much to grow */
  115.     if ((rowcol == GROWROW) || (rowcol == GROWBOTH))
  116.     {    if (toprow > maxrows)
  117.             newrows = GROWAMT + toprow;
  118.         else
  119.             newrows += GROWAMT;
  120.     }
  121. #endif /* !PSC */
  122.     if ((rowcol == GROWCOL) || (rowcol == GROWBOTH))
  123.     {    if ((rowcol == GROWCOL) && ((maxcols == ABSMAXCOLS) ||
  124.                     (topcol >= ABSMAXCOLS)))
  125.         {    error(nowider);
  126.             return(FALSE);
  127.         }
  128.  
  129.         if (topcol > maxcols)
  130.             newcols = GROWAMT + topcol;
  131.         else
  132.             newcols += GROWAMT;
  133.  
  134.         if (newcols > ABSMAXCOLS)
  135.             newcols = ABSMAXCOLS;
  136.     }
  137.  
  138. #ifndef PSC
  139.     if ((rowcol == GROWROW) || (rowcol == GROWBOTH) || (rowcol == GROWNEW))
  140.     {
  141.         GROWALLOC(row_hidden2, row_hidden, newrows, char, nolonger);
  142.         memset(row_hidden+maxrows, 0, (newrows-maxrows)*sizeof(char));
  143.  
  144.         /* alloc tbl row pointers */
  145.         GROWALLOC(tbl2, tbl, newrows, struct ent **, nolonger);
  146.         memset(tbl+maxrows, 0, (newrows-maxrows)*(sizeof(struct ent **)));
  147.     }
  148. #endif /* !PSC */
  149.  
  150.     if ((rowcol == GROWCOL) || (rowcol == GROWBOTH) || (rowcol == GROWNEW))
  151.     {
  152.         GROWALLOC(fwidth2, fwidth, newcols, int, nowider);
  153.         GROWALLOC(precision2, precision, newcols, int, nowider);
  154. #ifdef PSC
  155.         memset(fwidth+maxcols, 0, (newcols-maxcols)*sizeof(int));
  156.         memset(precision+maxcols, 0, (newcols-maxcols)*sizeof(int));
  157.     }
  158. #else
  159.         GROWALLOC(col_hidden2, col_hidden, newcols, char, nowider);
  160.         memset(col_hidden+maxcols, 0, (newcols-maxcols)*sizeof(char));
  161.         for (i = maxcols; i < newcols; i++) {
  162.             fwidth[i] = DEFWIDTH;
  163.             precision[i] = DEFPREC;
  164.         }
  165.  
  166.         /* [re]alloc the space for each row */
  167.         for (i = 0; i < maxrows; i++)
  168.         {
  169.             if ((tbl[i] = (struct ent **)realloc((char *)tbl[i],
  170.             (unsigned)(newcols * sizeof(struct ent **)))) == (struct ent **)0)
  171.             {    error(nowider);
  172.                 return(FALSE);
  173.             }
  174.             memset((char *)ATBL(tbl,i, maxcols), 0,
  175.                (newcols-maxcols)*sizeof(struct ent **));
  176.         }
  177.     }
  178.     else
  179.         i = maxrows;
  180.  
  181.     /* fill in the bottom of the table */
  182.     for (; i < newrows; i++)
  183.     {    if ((tbl[i] = (struct ent **)malloc((unsigned)(newcols *
  184.                 sizeof(struct ent **)))) == (struct ent **)0)
  185.         {    error(nowider);
  186.             return(FALSE);
  187.         }
  188.         memset((char *)tbl[i], 0, newcols*sizeof(struct ent **));
  189.     }
  190.  
  191.     FullUpdate++;
  192.     maxrows = newrows;
  193. #endif /* PSC */
  194.  
  195.     maxcols = newcols;
  196.     return(TRUE);
  197. }
  198.