home *** CD-ROM | disk | FTP | other *** search
/ Hacker Chronicles 2 / HACKER2.BIN / 640.BOARD.C < prev    next >
C/C++ Source or Header  |  1989-03-05  |  7KB  |  249 lines
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include "cell.h"
  4.  
  5. #define LIMIT    0x10000        /* 64k */
  6.  
  7. /* board dimensions */
  8. int Nrows = ILLEGAL;
  9. int Ncols = ILLEGAL;
  10.  
  11. int InitBoardDone = 0; /* sanity check */
  12.  
  13. /* memory usage */
  14. long Ltotal = 0; /* for board */
  15. long Itotal = 0; /* for dist */
  16. long Ctotal = 0; /* for dir */
  17.  
  18. /*
  19. ** memory is allocated in blocks of rows. as many rows as will fit in 64k are
  20. ** allocated in each block. blocks are linked together by pointers. the last
  21. ** block has a null 'next' pointer. if you want to route some *really* big
  22. ** boards (so big that 640k is not sufficient), you should change the
  23. ** algorithms below to test for Lotus-Intel-Microsoft expanded memory (LIM 3.2
  24. ** or 4.0) and use it if present. this would be a major enhancement, so if you
  25. ** do it i hope you will send it back to me so that it can be incorporated in
  26. ** future versions.
  27. */
  28.  
  29. struct lmem { /* a block of longs */
  30.     struct lmem far *next;     /* ptr to next block */
  31.     long         mem[1]; /* more than 1 is actually allocated */
  32.     };
  33.  
  34. struct imem { /* a block of ints */
  35.     struct imem far *next;     /* ptr to next block */
  36.     int         mem[1]; /* more than 1 is actually allocated */
  37.     };
  38.  
  39. struct cmem { /* a block of chars */
  40.     struct cmem far *next;     /* ptr to next block */
  41.     char         mem[1]; /* more than 1 is actually allocated */
  42.     };
  43.  
  44. struct lhead { /* header of blocks of longs */
  45.     int         numrows; /* number of rows per block */
  46.     struct lmem far *side[2]; /* ptr to first block of each chain */
  47.     };
  48.  
  49. struct ihead { /* header of blocks of ints */
  50.     int         numrows; /* number of rows per block */
  51.     struct imem far *side[2]; /* ptr to first block of each chain */
  52.     };
  53.  
  54. struct chead { /* header of blocks of chars */
  55.     int         numrows; /* number of rows per block */
  56.     struct cmem far *side[2]; /* ptr to first block of each chain */
  57.     };
  58.  
  59. static struct lhead Board = { 0, {NULL,NULL} }; /* 2-sided board */
  60. static struct ihead Dist = { 0, {NULL,NULL} }; /* path distance to cells */
  61. static struct chead Dir = { 0, {NULL,NULL} }; /* pointers back to source */
  62.  
  63. extern int justboard;
  64.  
  65. extern char far *Alloc( long );
  66.  
  67. void InitBoard( void );
  68. long GetCell( int, int, int );
  69. void SetCell( int, int, int, long );
  70. void OrCell( int, int, int, long );
  71. int GetDist( int, int, int );
  72. void SetDist( int, int, int, int );
  73. int GetDir( int, int, int );
  74. void SetDir( int, int, int, int );
  75.  
  76. void InitBoard () { /* initialize the data structures */
  77.     long lx, ly; /* for calculating block sizes */
  78.     struct lmem far * far *ltop;     /* for building board chain */
  79.     struct lmem far * far *lbottom;     /* for building board chain */
  80.     struct imem far * far *itop;     /* for building dist chain */
  81.     struct imem far * far *ibottom;     /* for building dist chain */
  82.     struct cmem far * far *ctop;     /* for building dir chain */
  83.     struct cmem far * far *cbottom;     /* for building dir chain */
  84.     int r, c, i, j, k; /* for calculating number of rows per block */
  85.  
  86.     InitBoardDone = 1; /* we have been called */
  87. /* allocate Board (longs) */
  88.     for (lx = (long)Ncols*sizeof(long), ly = 0, i = 0;
  89.         i < Nrows && ly <= LIMIT - sizeof(long far *); ly += lx, i++)
  90.         ; /* calculate maximum number of rows per block */
  91.     Board.numrows = --i;
  92.     ltop = &(Board.side[TOP]);
  93.     lbottom = &(Board.side[BOTTOM]);
  94.     for (j = Nrows; j > 0; j -= i) {
  95.         k = (j > i) ? i : j;
  96.         ly = ((long)k * lx) + sizeof(long far *);
  97.         *ltop = (struct lmem far *)Alloc( ly );
  98.         *lbottom = (struct lmem far *)Alloc( ly );
  99.         Ltotal += 2*ly;
  100.         ltop = (struct lmem far * far *)(*ltop);
  101.         lbottom = (struct lmem far * far *)(*lbottom);
  102.         }
  103.     *ltop = *lbottom = NULL;
  104.     if (!justboard) {
  105. /* allocate Dist (ints) */
  106.         for (lx = (long)Ncols*sizeof(int), ly = 0, i = 0;
  107.             i < Nrows && ly <= LIMIT - sizeof(int far *);
  108.             ly += lx, i++)
  109.             ; /* calculate maximum number of rows per block */
  110.         Dist.numrows = --i;
  111.         itop = &(Dist.side[TOP]);
  112.         ibottom = &(Dist.side[BOTTOM]);
  113.         for (j = Nrows; j > 0; j -= i) {
  114.             k = (j > i) ? i : j;
  115.             ly = ((long)k * lx) + sizeof(int far *);
  116.             *itop = (struct imem far *)Alloc( ly );
  117.             *ibottom = (struct imem far *)Alloc( ly );
  118.             Itotal += 2*ly;
  119.             itop = (struct imem far * far *)(*itop);
  120.             ibottom = (struct imem far * far *)(*ibottom);
  121.             }
  122.         *itop = *ibottom = NULL;
  123. /* allocate Dir (chars) */
  124.         for (lx = (long)Ncols*sizeof(char), ly = 0, i = 0;
  125.             i < Nrows && ly <= LIMIT - sizeof(char far *);
  126.             ly += lx, i++)
  127.             ; /* calculate maximum number of rows per block */
  128.         Dir.numrows = --i;
  129.         ctop = &(Dir.side[TOP]);
  130.         cbottom = &(Dir.side[BOTTOM]);
  131.         for (j = Nrows; j > 0; j -= i) {
  132.             k = (j > i) ? i : j;
  133.             ly = ((long)k * lx) + sizeof(char far *);
  134.             *ctop = (struct cmem far *)Alloc( ly );
  135.             *cbottom = (struct cmem far *)Alloc( ly );
  136.             Ctotal += 2*ly;
  137.             ctop = (struct cmem far * far *)(*ctop);
  138.             cbottom = (struct cmem far * far *)(*cbottom);
  139.             }
  140.         *ctop = *cbottom = NULL;
  141.         }
  142. /* initialize everything to empty */
  143.     for (r = 0; r < Nrows; r++) {
  144.         for (c = 0; c < Ncols; c++) {
  145.             SetCell( r, c, TOP, (long)EMPTY );
  146.             SetCell( r, c, BOTTOM, (long)EMPTY );
  147.             if (!justboard) {
  148.                 SetDist( r, c, TOP, EMPTY );
  149.                 SetDist( r, c, BOTTOM, EMPTY );
  150.                 SetDir( r, c, TOP, EMPTY );
  151.                 SetDir( r, c, BOTTOM, EMPTY );
  152.                 }
  153.             }
  154.         }
  155.     }
  156.  
  157. long GetCell( r, c, s ) /* fetch board cell */
  158.     int r, c, s;
  159.     {
  160.     struct lmem far *p;
  161.  
  162.     p = Board.side[s];
  163.     while (r >= Board.numrows) {
  164.         p = p->next;
  165.         r -= Board.numrows;
  166.         }
  167.     return( p->mem[r*Ncols+c] );
  168.     }
  169.  
  170. void SetCell( r, c, s, x ) /* store board cell */
  171.     int r, c, s;
  172.     long x;
  173.     {
  174.     struct lmem far *p;
  175.  
  176.     p = Board.side[s];
  177.     while (r >= Board.numrows) {
  178.         p = p->next;
  179.         r -= Board.numrows;
  180.         }
  181.     p->mem[r*Ncols+c] = x;
  182.     }
  183.  
  184. void OrCell( r, c, s, x ) /* augment board cell */
  185.     int r, c, s;
  186.     long x;
  187.     {
  188.     struct lmem far *p;
  189.  
  190.     p = Board.side[s];
  191.     while (r >= Board.numrows) {
  192.         p = p->next;
  193.         r -= Board.numrows;
  194.         }
  195.     p->mem[r*Ncols+c] |= x;
  196.     }
  197.  
  198. int GetDist( r, c, s ) /* fetch distance cell */
  199.     int r, c, s;
  200.     {
  201.     struct imem far *p;
  202.  
  203.     p = Dist.side[s];
  204.     while (r >= Dist.numrows) {
  205.         p = p->next;
  206.         r -= Dist.numrows;
  207.         }
  208.     return( p->mem[r*Ncols+c] );
  209.     }
  210.  
  211. void SetDist( r, c, s, x ) /* store distance cell */
  212.     int r, c, s, x;
  213.     {
  214.     struct imem far *p;
  215.  
  216.     p = Dist.side[s];
  217.     while (r >= Dist.numrows) {
  218.         p = p->next;
  219.         r -= Dist.numrows;
  220.         }
  221.     p->mem[r*Ncols+c] = x;
  222.     }
  223.  
  224. int GetDir( r, c, s ) /* fetch direction cell */
  225.     int r, c, s;
  226.     {
  227.     struct cmem far *p;
  228.  
  229.     p = Dir.side[s];
  230.     while (r >= Dir.numrows) {
  231.         p = p->next;
  232.         r -= Dir.numrows;
  233.         }
  234.     return( (int)(p->mem[r*Ncols+c]) );
  235.     }
  236.  
  237. void SetDir( r, c, s, x ) /* store direction cell */
  238.     int r, c, s, x;
  239.     {
  240.     struct cmem far *p;
  241.  
  242.     p = Dir.side[s];
  243.     while (r >= Dir.numrows) {
  244.         p = p->next;
  245.         r -= Dir.numrows;
  246.         }
  247.     p->mem[r*Ncols+c] = (char)x;
  248.     }
  249.