home *** CD-ROM | disk | FTP | other *** search
/ Crawly Crypt Collection 1 / crawlyvol1.bin / program / compiler / sozobon / scsrc20 / ld / utls.c < prev   
C/C++ Source or Header  |  1991-02-22  |  3KB  |  200 lines
  1.  
  2. /*
  3.  * Copyright (c) 1991 by Sozobon, Limited.  Author: Johann Ruegg
  4.  *
  5.  * Permission is granted to anyone to use this software for any purpose
  6.  * on any computer system, and to redistribute it freely, with the
  7.  * following restrictions:
  8.  * 1) No charge may be made other than reasonable charges for reproduction.
  9.  * 2) Modified versions must be clearly marked as such.
  10.  * 3) The authors are not responsible for any harmful consequences
  11.  *    of using this software, even if they result from defects in it.
  12.  */
  13.  
  14. extern int vflag;
  15. #define FBSIZE    1000
  16.  
  17. fbcopy(fr, to, cnt)
  18. long cnt;
  19. {
  20.     char buf[FBSIZE];
  21.     int k;
  22.  
  23.     while (cnt > 0) {
  24.         if (cnt > FBSIZE)
  25.             k = FBSIZE;
  26.         else
  27.             k = cnt;
  28.         rread(fr, buf, k);
  29.         t_write(to, buf, k);
  30.         cnt -= k;
  31.     }
  32. }
  33.  
  34. bfcopy(fr, to, cnt)
  35. long cnt;
  36. {
  37.     char buf[FBSIZE];
  38.     int k;
  39.  
  40.     while (cnt > 0) {
  41.         if (cnt > FBSIZE)
  42.             k = FBSIZE;
  43.         else
  44.             k = cnt;
  45.         t_read(fr, buf, k);
  46.         wwrite(to, buf, k);
  47.         cnt -= k;
  48.     }
  49. }
  50.  
  51. char *
  52. mmalloc(size)
  53. {
  54.     char *rv, *malloc();
  55.  
  56. again:
  57.     rv = malloc(size);
  58.     if (rv == 0) {
  59.         if (t_frees())
  60.             goto again;
  61.         fatal("out of memory");
  62.     }
  63.     if (vflag > 2)
  64.         printf("M %x rets %lx ", size, rv);
  65.     return rv;
  66. }
  67.  
  68. char *
  69. mlmalloc(size)
  70. long size;
  71. {
  72.     char *rv, *malloc();
  73.  
  74.     if (size > 65000L)
  75.         fatal("malloc chunk too big");
  76. again:
  77.     rv = malloc((unsigned)size);
  78.     if (rv == 0) {
  79.         if (t_frees())
  80.             goto again;
  81.         fatal("out of memory");
  82.     }
  83.     if (vflag > 2)
  84.         printf("M %lx rets %lx ", size, rv);
  85.     return rv;
  86. }
  87.  
  88. rread(fd, buf, cnt)
  89. char *buf;
  90. {
  91.     if (read(fd, buf, cnt) != cnt)
  92.         fatal("read error");
  93.     if (vflag > 2)
  94.         printf("R %d %lx %d ", fd, buf, cnt);
  95.     return cnt;
  96. }
  97.  
  98. wwrite(fd, buf, cnt)
  99. char *buf;
  100. {
  101.     if (write(fd, buf, cnt) != cnt)
  102.         fatal("write error");
  103.     if (vflag > 2)
  104.         printf("W %d %lx %d ", fd, buf, cnt);
  105.     return cnt;
  106. }
  107.  
  108. long
  109. llseek(fd, ofs, how)
  110. long ofs;
  111. {
  112.     long rv, lseek();
  113.  
  114.     rv = lseek(fd, ofs, how);
  115.     if (rv < 0)
  116.         fatal("lseek error");
  117.     if (vflag > 2)
  118.         printf("S %d %lx %d ", fd, ofs, how);
  119.     return rv;
  120. }
  121.  
  122. #ifdef UNIXHOST
  123. #define lread read
  124. #else
  125. long lread();
  126. #endif
  127.  
  128. long
  129. rlread(fd, buf, lcnt)
  130. char *buf;
  131. long lcnt;
  132. {
  133.     if (lread(fd, buf, lcnt) != lcnt)
  134.         fatal("read error");
  135.     if (vflag > 2)
  136.         printf("R %d %lx %ld ", fd, buf, lcnt);
  137.     return lcnt;
  138. }
  139.  
  140. strnlen(s, max)
  141. char *s;
  142. {
  143.     int i;
  144.  
  145.     for (i=0; i<max; i++)
  146.         if (*s++ == 0)
  147.             return i;
  148.     return max;
  149. }
  150.  
  151. struct generic {
  152.     struct generic *next;
  153. };
  154.  
  155. listins(hpp, np)
  156. struct generic **hpp, *np;
  157. {
  158.     np->next = *hpp;
  159.     *hpp = np;
  160. }
  161.  
  162. listadd(hpp, np)
  163. struct generic **hpp, *np;
  164. {
  165.     struct generic *tp;
  166.  
  167.     np->next = 0;
  168.  
  169.     if (*hpp == 0) {
  170.         *hpp = np;
  171.     } else {
  172.         tp = *hpp;
  173.         while (tp->next)
  174.             tp = tp->next;
  175.         tp->next = np;
  176.     }
  177. }
  178.  
  179. listdel(hpp, np)
  180. struct generic **hpp, *np;
  181. {
  182.     struct generic *tp;
  183.  
  184.     if (*hpp == np) {
  185.         *hpp = np->next;
  186.         np->next = 0;
  187.     } else {
  188.         tp = *hpp;
  189.         while (tp->next) {
  190.             if (tp->next == np) {
  191.                 tp->next = np->next;
  192.                 np->next = 0;
  193.                 return;
  194.             }
  195.             tp = tp->next;
  196.         }
  197.         fatal("listdel error");
  198.     }
  199. }
  200.