home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / unix / volume20 / xxalloc / nx.c < prev    next >
Encoding:
C/C++ Source or Header  |  1989-10-16  |  6.2 KB  |  321 lines
  1. /*xxalloc.c**************************************************************/     
  2. /*                                    */
  3. /*                xxalloc                 */
  4. /*                                    */
  5. /*            Placed in the public domain            */
  6. /*             by Harold G. Walters 1988            */
  7. /*                                    */
  8. /*    Bug fixes, ect to walters@ce.okstate.edu until May 1989        */
  9. /*                                    */
  10. /*    This software is provided as is.  No claims are made for    */
  11. /*    this software regarding its fitness and/or correctness for    */
  12. /*     any purpose.  Use of this software is at the user's own risk.    */
  13. /*                                    */
  14. /************************************************************************/
  15.  
  16. #include <stdio.h>
  17.  
  18. extern char *calloc();
  19. extern void free();
  20.  
  21. #define STRLEN 132
  22. static char msg[STRLEN];
  23. static long amount = 0L;
  24.  
  25. extern void xx_error();
  26.  
  27. char *xx_alloc(n)
  28. unsigned n;
  29. {
  30.     char *m;
  31.     amount += n;
  32.     if ((m = calloc(1, n)) == (char *) NULL)
  33.     {
  34.         sprintf(msg, "xx_alloc: memory allocation error at %ld bytes\n",
  35.             amount);
  36.         xx_error(msg);
  37.         return((char *) NULL);
  38.     }
  39.     return((char *) m);
  40. }
  41.  
  42. void xx_free(p, n)
  43. char *p;
  44. unsigned n;
  45. {
  46.     free(p);
  47.     amount -= n;
  48.     return;
  49. }
  50.  
  51. long xx_amount()
  52. {
  53.     return(amount);
  54. }
  55.  
  56. /* end index >= begin index */
  57. static void index_test(b, e)
  58. int b, e;
  59. {
  60.     if (e < b)
  61.     {
  62.         sprintf(msg, "index_test: end index %d < begin index %d\n",
  63.             e, b);
  64.         xx_error(msg);
  65.         /* exit here even if xx_error() returns */
  66.         /* this is a programming error if this ever happens */
  67.         exit(2);
  68.     }
  69.     return;
  70. }
  71.  
  72. char *n1_alloc(ib, ie, n)
  73. int ib, ie, n;
  74. {
  75.     char *m;
  76.     index_test(ib, ie);
  77.     m = (char *) xx_alloc((unsigned) (ie - ib + 1) * n);
  78.     if (m == (char *) NULL) return((char *) NULL);
  79.     m -= ib * n;
  80.     return((char *) m);
  81. }
  82.  
  83. char *n1_renum(m, ib, ie, nib, nie, n)
  84. char *m;
  85. int ib, ie, nib, nie, n;
  86. {
  87.     index_test(ib, ie);
  88.     index_test(nib, nie);
  89.     m += (ib - nib) * n;
  90.     return((char *) m);
  91. }
  92.  
  93. void n1_free(m, ib, ie, n)
  94. char *m;
  95. int ib, ie, n;
  96. {
  97.     index_test(ib, ie);
  98.     xx_free((char*) (m + ib * n), (unsigned) ((ie - ib + 1) * n));
  99.     return;
  100. }
  101.  
  102. void n1_init(m, ib, ie, n, nini)
  103. char *m;
  104. int ib, ie, n;
  105. void (*nini)();
  106. {
  107.     int i;
  108.     index_test(ib, ie);
  109.     if (nini == (void (*)()) NULL)
  110.         return;
  111.     for (i = ib; i <= ie; i++)
  112.         (*nini)(&m[i*n]);
  113.     return;
  114. }
  115.  
  116. void n1_prnt(fp, nprn, m, ib, ie, n)
  117. FILE *fp;
  118. void (*nprn)();
  119. char *m;
  120. int ib, ie, n;
  121. {
  122.     int i;
  123.     index_test(ib, ie);
  124.     if (nprn == (void (*)()) NULL)
  125.         return;
  126.     for (i = ib; i <= ie; i++)
  127.         (*nprn)(fp, &m[i*n]);
  128.     return;
  129. }
  130.  
  131. char **n2_alloc(ib, ie, jb, je, n)
  132. int ib, ie, jb, je, n;
  133. {
  134.     int i;
  135.     char **m;
  136.     index_test(ib, ie);
  137.     index_test(jb, je);
  138.     m = (char **) xx_alloc((unsigned) (ie - ib + 1) * sizeof(char *));
  139.     if (m == (char **) NULL) return((char **) NULL);
  140.     m -= ib;
  141.     for(i = ib; i <= ie; i++)
  142.     {
  143.         m[i] = (char *) xx_alloc((unsigned) (je - jb + 1) * n);
  144.         if (m[i] == (char *) NULL) return((char **) NULL);
  145.         m[i] -= jb * n;
  146.     }
  147.     return((char **) m);
  148. }
  149.  
  150. char **n2_renum(m, ib, ie, jb, je, nib, nie, njb, nje, n)
  151. char **m;
  152. int ib, ie, jb, je, nib, nie, njb, nje, n;
  153. {
  154.     int i;
  155.     index_test(ib, ie);
  156.     index_test(jb, je);
  157.     index_test(nib, nie);
  158.     index_test(njb, nje);
  159.     for(i = ie; i >= ib; i--)
  160.         m[i] += (jb - njb) * n;
  161.     m += (ib - nib);
  162.     return((char **) m);
  163. }
  164.  
  165. void n2_free(m, ib, ie, jb, je, n)
  166. char **m;
  167. int ib, ie, jb, je, n;
  168. {
  169.     int i;
  170.     index_test(ib, ie);
  171.     index_test(jb, je);
  172.     for(i = ie; i >= ib; i--)
  173.         xx_free((char*) (m[i] + jb * n), 
  174.             (unsigned) ((je - jb + 1) * n));
  175.     xx_free((char*) (m + ib), (unsigned) ((ie - ib + 1) * sizeof(char *)));
  176.     return;
  177. }
  178.  
  179. void n2_init(m, ib, ie, jb, je, n, nini)
  180. char **m;
  181. int ib, ie, jb, je, n;
  182. void (*nini)();
  183. {
  184.     int i, j;
  185.     index_test(ib, ie);
  186.     index_test(jb, je);
  187.     if (nini == (void (*)()) NULL)
  188.         return;
  189.     for (i = ib; i <= ie; i++)
  190.         for (j = jb; j <= je; j++)
  191.             (*nini)(&m[i][j*n]);
  192.     return;
  193. }
  194.  
  195. void n2_prnt(fp, nprn, m, ib, ie, jb, je, n)
  196. FILE *fp;
  197. void (*nprn)();
  198. char **m;
  199. int ib, ie, jb, je, n;
  200. {
  201.     int i, j;
  202.     index_test(ib, ie);
  203.     index_test(jb, je);
  204.     if (nprn == (void (*)()) NULL)
  205.         return;
  206.     for (i = ib; i <= ie; i++)
  207.         for (j = jb; j <= je; j++)
  208.             (*nprn)(fp, &m[i][j*n]);
  209.     return;
  210. }
  211.  
  212. char ***n3_alloc(ib, ie, jb, je, kb, ke, n)
  213. int ib, ie, jb, je, kb, ke, n;
  214. {
  215.     int i, j;
  216.     char ***m;
  217.     index_test(ib, ie);
  218.     index_test(jb, je);
  219.     index_test(kb, ke);
  220.     m = (char ***) xx_alloc((unsigned) (ie - ib + 1) * sizeof(char **));
  221.     if (m == (char ***) NULL) return((char ***) NULL);
  222.     m -= ib;
  223.     for(i = ib; i <= ie; i++)
  224.     {
  225.         m[i] = (char **) xx_alloc((unsigned) (je - jb + 1) * 
  226.             sizeof(char *));
  227.         if (m[i] == (char **) NULL) return((char ***) NULL);
  228.         m[i] -= jb;
  229.         for(j = jb; j <= je; j++)
  230.         {
  231.             m[i][j] = (char *) xx_alloc((unsigned) (ke - kb + 1)
  232.                 * n);
  233.             if (m[i][j] == (char *) NULL) return((char ***) NULL);
  234.             m[i][j] -= kb * n;
  235.         }
  236.     }
  237.     return((char ***) m);
  238. }
  239.  
  240. char ***n3_renum(m, ib, ie, jb, je, kb, ke, nib, nie, njb, nje, nkb, nke, n)
  241. char ***m;
  242. int ib, ie, jb, je, kb, ke, nib, nie, njb, nje, nkb, nke, n;
  243. {
  244.     int i, j;
  245.     index_test(ib, ie);
  246.     index_test(jb, je);
  247.     index_test(kb, ke);
  248.     index_test(nib, nie);
  249.     index_test(njb, nje);
  250.     index_test(nkb, nke);
  251.     for(i = ie; i >= ib; i--)
  252.         for (j = je; j >= jb; j--)
  253.             m[i][j] += (kb - nkb) * n;
  254.     for(i = ie; i >= ib; i--)
  255.         m[i] += (jb - njb);
  256.     m += (ib - nib);
  257.     return((char ***) m);
  258. }
  259.  
  260. void n3_free(m, ib, ie, jb, je, kb, ke, n)
  261. char ***m;
  262. int ib, ie, jb, je, kb, ke, n;
  263. {
  264.     int i, j;
  265.     index_test(ib, ie);
  266.     index_test(jb, je);
  267.     index_test(kb, ke);
  268.     for(i = ie; i >= ib; i--)
  269.         for (j = je; j >= jb; j--)
  270.             xx_free((char*) (m[i][j] + kb * n),
  271.                 (unsigned) (ke - kb + 1) * n);
  272.     for(i = ie; i >= ib; i--)
  273.         xx_free((char*) (m[i] + jb), 
  274.             (unsigned) ((je - jb + 1) * sizeof(char *)));
  275.     xx_free((char*) (m + ib),
  276.         (unsigned) ((ie - ib + 1) * sizeof(char **)));
  277.     return;
  278. }
  279.  
  280. void n3_init(m, ib, ie, jb, je, kb, ke, n, nini)
  281. char ***m;
  282. int ib, ie, jb, je, kb, ke, n;
  283. void (*nini)();
  284. {
  285.     int i, j, k;
  286.     index_test(ib, ie);
  287.     index_test(jb, je);
  288.     index_test(kb, ke);
  289.     if (nini == (void (*)()) NULL)
  290.         return;
  291.     for (i = ib; i <= ie; i++)
  292.         for (j = jb; j <= je; j++)
  293.             for (k = kb; k <= ke; k++)
  294.                 (*nini)(&m[i][j][k*n]);
  295.     return;
  296. }
  297.  
  298. void n3_prnt(fp, nprn, m, ib, ie, jb, je, kb, ke, n)
  299. FILE *fp;
  300. void (*nprn)();
  301. char ***m;
  302. int ib, ie, jb, je, kb, ke, n;
  303. {
  304.     int i, j, k;
  305.     index_test(ib, ie);
  306.     index_test(jb, je);
  307.     index_test(kb, ke);
  308.     if (nprn == (void (*)()) NULL)
  309.         return;
  310.     for (i = ib; i <= ie; i++)
  311.     {
  312.         fprintf(fp, "%d\n", i);
  313.         for (j = jb; j <= je; j++)
  314.             for (k = kb; k <= ke; k++)
  315.                 (*nprn)(fp, &m[i][j][k*n]);
  316.     }
  317.     return;
  318. }
  319.  
  320.  
  321.