home *** CD-ROM | disk | FTP | other *** search
/ Network PC / Network PC.iso / amiga utilities / communication / internet / amitcp3.0b / src.lha / src / amitcp / kern / amiga_subr.h < prev    next >
Encoding:
C/C++ Source or Header  |  1996-09-08  |  6.9 KB  |  362 lines
  1. /*
  2.  * $Id: amiga_subr.h,v 1.13 1994/01/23 22:06:26 jraja Exp $
  3.  * 
  4.  * Copyright (c) 1993 AmiTCP/IP Group, <amitcp-group@hut.fi>
  5.  *                    Helsinki University of Technology, Finland.
  6.  *                    All rights reserved.
  7.  *
  8.  * HISTORY
  9.  * $Log: amiga_subr.h,v $
  10.  * Revision 1.13  1994/01/23  22:06:26  jraja
  11.  * Fixed bcopy argument cast.
  12.  *
  13.  * Revision 1.12  1994/01/18  02:28:27  jraja
  14.  * Changed some arguments to const.
  15.  *
  16.  * Revision 1.11  1993/06/04  11:16:15  jraja
  17.  * Fixes for first public release.
  18.  *
  19.  * Revision 1.10  1993/05/17  01:02:04  ppessi
  20.  * Changed RCS version
  21.  *
  22.  * Revision 1.9  1993/04/24  23:19:22  jraja
  23.  * Changed define NO_NOALIGN to USE_ALIGNED_COPIES.
  24.  *
  25.  * Revision 1.8  93/04/13  22:30:20  22:30:20  jraja (Jarno Tapio Rajahalme)
  26.  * Changed NOALIGNED to NOALIGN.
  27.  * 
  28.  * Revision 1.7  93/03/22  17:04:11  17:04:11  jraja (Jarno Tapio Rajahalme)
  29.  * Added definitions for aligned_bzero() aligned_bzero_const(),
  30.  * aligned_bcopy() aligned_bcopy_const(). These are optimized versions of
  31.  * bzero() and bcopy(). _const ones are to be used with constant size argument.
  32.  * 
  33.  * Revision 1.6  93/03/19  14:14:44  14:14:44  too (Tomi Ollila)
  34.  * Code changes at night 17-18 March 1993
  35.  * 
  36.  * Revision 1.5  93/03/04  09:43:32  09:43:32  jraja (Jarno Tapio Rajahalme)
  37.  * Fixed includes.
  38.  * 
  39.  * Revision 1.4  93/02/27  12:44:25  12:44:25  jraja (Jarno Tapio Rajahalme)
  40.  * added strncpy() for gcc.
  41.  * 
  42.  * Revision 1.3  93/02/24  12:52:22  12:52:22  jraja (Jarno Tapio Rajahalme)
  43.  * Changed uxkern to kern.
  44.  * 
  45.  * Revision 1.2  93/02/04  18:57:47  18:57:47  jraja (Jarno Tapio Rajahalme)
  46.  * Added SASC definitions and ovbcopy().
  47.  * 
  48.  * Revision 1.1  93/01/06  19:05:36  19:05:36  jraja (Jarno Tapio Rajahalme)
  49.  * Initial revision
  50.  * 
  51.  */
  52. #ifndef AMIGA_SUBR_H
  53. #define AMIGA_SUBR_H
  54.  
  55. #if __SASC
  56. /*
  57.  * Using builtin functions (string.h included in kern/amiga_includes.h)
  58.  */
  59. #ifndef AMIGA_INCLUDES_H
  60. #include <kern/amiga_includes.h>
  61. #endif
  62.  
  63. #define imin(a,b) min(a,b)
  64. #define MIN(a,b) min(a,b)
  65. #define lmin(a,b) min(a,b)
  66. #define ulmin(a,b) min(a,b)
  67.  
  68. #define imax(a,b) max(a,b)
  69. #define MAX(a,b) max(a,b)
  70. #define lmax(a,b) max(a,b)
  71. #define ulmax(a,b) max(a,b)
  72.  
  73. /*
  74.  * bcopy(), bcmp() and bzero() are defined in string.h
  75.  *
  76.  * NOTE: bcopy is infact ovbcopy(). Optimize this when all other works!
  77.  */
  78.  
  79. #undef bcopy 
  80. #define bcopy(a,b,c) CopyMem((APTR)(a),b,c)
  81. #define ovbcopy(a,b,c) memmove(b,a,c)
  82.  
  83. #else
  84.  
  85. #ifndef SYS_CDEFS_H
  86. #include <sys/cdefs.h>
  87. #endif
  88.  
  89. static inline int 
  90. imin(int a, int b)
  91. {
  92.   return (a < b ? a : b);
  93. }
  94.  
  95. #define MIN(a,b) imin(a,b)
  96.  
  97. static inline int 
  98. imax(int a, int b)
  99. {
  100.   return (a > b ? a : b);
  101. }
  102.  
  103. static inline unsigned int
  104. min(unsigned int a, unsigned int b)
  105. {
  106.   return (a < b ? a : b);
  107. }
  108.  
  109. static inline unsigned int
  110. max(unsigned int a, unsigned int b)
  111. {
  112.   return (a > b ? a : b);
  113. }
  114.  
  115. static inline long
  116. lmin(long a, long b)
  117. {
  118.   return (a < b ? a : b);
  119. }
  120.  
  121. static inline long
  122. lmax(long a, long b)
  123. {
  124.   return (a > b ? a : b);
  125. }
  126.  
  127. static inline unsigned long
  128. ulmin(unsigned long a, unsigned long b)
  129. {
  130.   return (a < b ? a : b);
  131. }
  132.  
  133. static inline unsigned long
  134. ulmax(unsigned long a, unsigned long b)
  135. {
  136.   return (a > b ? a : b);
  137. }
  138.  
  139. static inline int 
  140. bcmp(const void *v1, const void *v2, register unsigned len)
  141. {
  142.   const register u_char *s1 = v1, *s2 = v2;
  143.   
  144.   while (len--)
  145.     if (*s1++ != *s2++)
  146.       return (1);
  147.   return (0);
  148. }
  149.  
  150. static inline void
  151. bzero(void *buf, register unsigned len)
  152. {
  153.   register char *s = buf;
  154.  
  155.   while(len--)
  156.     *s++ = '\0';
  157. }
  158.  
  159. static inline void
  160. ovbcopy(const void *v1, void *v2, register unsigned len)
  161. {
  162.   const register u_char *s1 = v1;
  163.   register u_char *s2 = v2;
  164.   
  165.   if (s1 < s2) {
  166.     /*
  167.      * copy possibly destroying s1 (if overlap), copy backwards
  168.      */
  169.     s1 += len;
  170.     s2 += len;
  171.     while (len--)
  172.       *(--s2) = *(--s1); 
  173.   }
  174.   else
  175.     while (len--)
  176.       *s2++ = *s1++;
  177. }
  178.  
  179. static inline void
  180. bcopy(const void *v1, void *v2, register unsigned len)
  181. {
  182.   const register u_char *s1 = v1;
  183.   register u_char *s2 = v2;
  184.   
  185.   while (len--)
  186.     *s2++ = *s1++;
  187. }
  188.  
  189. static inline int
  190. strlen(register const char *s1)
  191. {
  192.   register int len;
  193.   
  194.   for (len = 0; *s1++ != '\0'; len++)
  195.     ;
  196.   return (len);
  197. }
  198.  
  199. static inline char *
  200. strcpy(register char *s1, register const char *s2)
  201. {
  202.   register char *s = s1;
  203.   while(*s++ = *s2++)
  204.     ;
  205.   return (s1);
  206. }
  207.  
  208. static inline char *
  209. strncpy(register char *s1, register const char *s2, register unsigned int len)
  210. {
  211.   register char *s = s1;
  212.   while(len-- && (*s++ = *s2++))
  213.     ;
  214.   return (s1);
  215. }
  216. #endif /* __SASC */
  217.  
  218. /* 
  219.  * These are for both environments
  220.  */
  221.  
  222. #ifndef USE_ALIGNED_COPIES
  223. #define aligned_bcopy_const bcopy
  224. #define aligned_bcopy bcopy
  225. #define aligned_bzero_const bzero
  226. #define aligned_bzero bzero
  227. #else
  228. /*
  229.  * clear an aligned memory area of constant length to zero
  230.  */ 
  231. static inline void
  232. aligned_bzero_const(void *buf, long size) 
  233. {
  234.   short lcount;
  235.   long *lbuf = (long *)buf;
  236.   short *sbuf;
  237.  
  238.   lcount = (size >> 2);
  239.   if (lcount--) {
  240.     /*
  241.      * unroll the loop if short enough
  242.      */
  243.     if (lcount < 6) {
  244.       *lbuf++ = 0;
  245.       if (--lcount >= 0)
  246.     *lbuf++ = 0;
  247.       if (--lcount >= 0)
  248.     *lbuf++ = 0;
  249.       if (--lcount >= 0)
  250.     *lbuf++ = 0;
  251.       if (--lcount >= 0)
  252.     *lbuf++ = 0;
  253.       if (--lcount >= 0)
  254.     *lbuf++ = 0;
  255.     }
  256.     else {
  257.       do {
  258.     *lbuf++ = 0;
  259.       } while (--lcount >= 0);
  260.     }
  261.   }
  262.  
  263.   sbuf = (short *)lbuf;
  264.   if (size & 0x2)
  265.     *sbuf++ = 0;
  266.  
  267.   if (size & 0x1)
  268.     *(char *)sbuf = 0;
  269. }
  270.  
  271. static inline void
  272. aligned_bzero(void *buf, long size) 
  273. {
  274.   short lcount;
  275.   long *lbuf = (long *)buf;
  276.   short *sbuf;
  277.  
  278.   lcount = (size >> 2);
  279.   if (lcount--) {
  280.     do {
  281.       *lbuf++ = 0;
  282.     } while (--lcount >= 0);
  283.   }
  284.  
  285.   sbuf = (short *)lbuf;
  286.   if (size & 0x2)
  287.     *sbuf++ = 0;
  288.  
  289.   if (size & 0x1)
  290.     *(char *)sbuf = 0;
  291. }
  292.  
  293. static inline void
  294. aligned_bcopy_const(const void *src, void *dst, long size) 
  295. {
  296.   short lcount;
  297.   long *ldst = (long *)dst;
  298.   short *sdst;
  299.   long *lsrc = (long *)src;
  300.   short *ssrc;
  301.  
  302.   lcount = (size >> 2);
  303.   if (lcount--) {
  304.     /*
  305.      * unroll the loop if short enough
  306.      */
  307.     if (lcount < 6) {
  308.       *ldst++ = *lsrc++;
  309.       if (--lcount >= 0)
  310.     *ldst++ = *lsrc++;
  311.       if (--lcount >= 0)
  312.     *ldst++ = *lsrc++;
  313.       if (--lcount >= 0)
  314.     *ldst++ = *lsrc++;
  315.       if (--lcount >= 0)
  316.     *ldst++ = *lsrc++;
  317.       if (--lcount >= 0)
  318.     *ldst++ = *lsrc++;
  319.     }
  320.     else {
  321.       do {
  322.     *ldst++ = *lsrc++;
  323.       } while (--lcount >= 0);
  324.     }
  325.   }
  326.  
  327.   sdst = (short *)ldst;
  328.   ssrc = (short *)lsrc;
  329.   if (size & 0x2)
  330.     *sdst++ = *ssrc++;
  331.  
  332.   if (size & 0x1)
  333.     *(char *)sdst = *(char *)ssrc;
  334. }
  335.  
  336. static inline void
  337. aligned_bcopy(const void *src, void *dst, long size) 
  338. {
  339.   short lcount;
  340.   long *ldst = (long *)dst;
  341.   short *sdst;
  342.   long *lsrc = (long *)src;
  343.   short *ssrc;
  344.  
  345.   lcount = (size >> 2);
  346.   if (lcount--) {
  347.     do {
  348.       *ldst++ = *lsrc++;
  349.     } while (--lcount >= 0);
  350.   }
  351.  
  352.   sdst = (short *)ldst;
  353.   ssrc = (short *)lsrc;
  354.   if (size & 0x2)
  355.     *sdst++ = *ssrc++;
  356.  
  357.   if (size & 0x1)
  358.     *(char *)sdst = *(char *)ssrc;
  359. }
  360. #endif /* USE_ALIGNED_COPIES */
  361. #endif /* AMIGA_SUBR_H */
  362.