binaries/src/clustalo/src/squid/types.c

   1 /*****************************************************************
   2  * SQUID - a library of functions for biological sequence analysis
   3  * Copyright (C) 1992-2002 Washington University School of Medicine
   4  *
   5  *     This source code is freely distributed under the terms of the
   6  *     GNU General Public License. See the files COPYRIGHT and LICENSE
   7  *     for details.
   8  *****************************************************************/
   9
  10 /* file: types.c
  11  *
  12  * Finicky type checkers for strings. Return 1 (TRUE) if ok, 0 elsewise.
  13  * Also, finicky type converters (sre_ntoh32() and friends)
  14  *
  15  * CVS $Id: types.c,v 1.5 2001/01/08 22:58:12 eddy Exp)
  16  */
  17
  18 #include <string.h>
  19 #include <ctype.h>
  20 #include "squid.h"
  21
  22 /* Function: IsInt()
  23  *
  24  * Returns TRUE if s points to something that atoi() will parse
  25  * completely and convert to an integer.
  26  */
  27 int
  28 IsInt(char *s)
  29 {
  30   int hex = 0;
  31
  32   if (s == NULL) {squid_errno = SQERR_PARAMETER; return 0; }
  33
  34                                 /* skip whitespace */
  35   while (isspace((int) (*s))) s++;
  36                                 /* skip leading sign */
  37   if (*s == '-' || *s == '+') s++;
  38                                 /* skip leading conversion signals */
  39   if ((strncmp(s, "0x", 2) == 0 && (int) strlen(s) > 2) ||
  40       (strncmp(s, "0X", 2) == 0 && (int) strlen(s) > 2))
  41     {
  42       s += 2;
  43       hex = 1;
  44     }
  45   else if (*s == '0' && (int) strlen(s) > 1)
  46     s++;
  47                                 /* examine remainder for garbage chars */
  48   if (!hex)
  49     while (*s != '\0')
  50       {
  51         if (!isdigit((int) (*s))) return 0;
  52         s++;
  53       }
  54   else
  55     while (*s != '\0')
  56       {
  57         if (!isxdigit((int) (*s))) return 0;
  58         s++;
  59       }
  60
  61   return 1;
  62 }
  63
  64
  65 /* Function: IsReal()
  66  *
  67  * Purpose:  Returns TRUE if s is a string representation
  68  *           of a valid floating point number.
  69  */
  70 int
  71 IsReal(char *s)
  72 {
  73   int gotdecimal = 0;
  74   int gotexp     = 0;
  75   int gotreal    = 0;
  76
  77   if (s == NULL) return 0;
  78
  79   while (isspace((int) (*s))) s++;         /* skip leading whitespace */
  80   if (*s == '-' || *s == '+') s++; /* skip leading sign */
  81
  82   /* Examine remainder for garbage. Allowed one '.' and
  83    * one 'e' or 'E'; if both '.' and e/E occur, '.'
  84    * must be first.
  85    */
  86   while (*s != '\0')
  87     {
  88       if (isdigit((int) (*s)))
  89         gotreal++;
  90       else if (*s == '.')
  91         {
  92           if (gotdecimal) return 0; /* can't have two */
  93           if (gotexp) return 0; /* e/E preceded . */
  94           else gotdecimal++;
  95         }
  96       else if (*s == 'e' || *s == 'E')
  97         {
  98           if (gotexp) return 0; /* can't have two */
  99           else gotexp++;
 100         }
 101       else if (isspace((int) (*s)))
 102         break;
 103
 104       s++;
 105     }
 106
 107   while (isspace((int) (*s))) s++;         /* skip trailing whitespace */
 108   if (*s == '\0' && gotreal) return 1;
 109   else return 0;
 110 }
 111
 112
 113 /* Function: Byteswap()
 114  *
 115  * Purpose:  Swap between big-endian and little-endian.
 116  *           For example:
 117  *               int foo = 0x12345678;
 118  *               byteswap((char *) &foo, sizeof(int));
 119  *               printf("%x\n", foo)
 120  *           gives 78563412.
 121  *
 122  *           I don't fully understand byte-swapping issues.
 123  *           However, I have tested this on chars through floats,
 124  *           on various machines:
 125  *               SGI IRIX 4.0.5, SunOS 4.1.3, DEC Alpha OSF/1, Alliant
 126  *
 127  * Date: Sun Feb 12 10:26:22 1995
 128  */
 129 void
 130 Byteswap(char *swap, int nbytes)
 131 {
 132   int  x;
 133   char byte;
 134
 135   for (x = 0; x < nbytes / 2; x++)
 136     {
 137       byte = swap[nbytes - x - 1];
 138       swap[nbytes - x - 1] = swap[x];
 139       swap[x] = byte;
 140     }
 141 }
 142
 143
 144
 145 /* Functions: sre_ntoh16(), etc.
 146  * Date:      SRE, Sun Dec 31 11:26:53 2000 [St. Louis]
 147  *
 148  * Purpose:   Provide functionality of ntohs(), etc; extended
 149  *            to 64-bit unsigned ints, and explicitly provided
 150  *            in case a machine doesn't have the ntohs()
 151  *            family.
 152  *
 153  *            If we're using the host functions,
 154  *            USE_HOST_BYTESWAP_FUNCTIONS was set to 1 in
 155  *            squidconf.h, and we #define'd sre_hton16(x)=hton(x), etc.
 156  *            in squid.h. In doing this, we assumed that the
 157  *            host functions work on 16- and 32-bit unsigned quantities.
 158  *            If for some reason that's not true, set
 159  *            USE_HOST_BYTESWAP_FUNCTIONS to 0.
 160  */
 161 #ifndef USE_HOST_BYTESWAP_FUNCTIONS
 162 sqd_uint16
 163 sre_ntoh16(sqd_uint16 netshort)
 164 {
 165 #ifdef WORDS_BIGENDIAN
 166   return netshort;
 167 #else
 168   Byteswap((char *) &netshort, 2);
 169   return netshort;
 170 #endif
 171 }
 172 sqd_uint32
 173 sre_ntoh32(sqd_uint32 netlong)
 174 {
 175 #ifdef WORDS_BIGENDIAN
 176   return netlong;
 177 #else
 178   Byteswap((char *) &netlong, 4);
 179   return netlong;
 180 #endif
 181 }
 182 sqd_uint16
 183 sre_hton16(sqd_uint16 hostshort)
 184 {
 185 #ifdef WORDS_BIGENDIAN
 186   return hostshort;
 187 #else
 188   Byteswap((char *) &hostshort, 2);
 189   return hostshort;
 190 #endif
 191 }
 192 sqd_uint32
 193 sre_hton32(sqd_uint32 hostlong)
 194 {
 195 #ifdef WORDS_BIGENDIAN
 196   return hostlong;
 197 #else
 198   Byteswap((char *) &hostlong, 4);
 199   return hostlong;
 200 #endif
 201 }
 202 #endif /*USE_HOST_BYTESWAP_FUNCTIONS*/
 203
 204 sqd_uint64
 205 sre_ntoh64(sqd_uint64 net_int64)
 206 {
 207 #ifdef WORDS_BIGENDIAN
 208   return net_int64;
 209 #else
 210   Byteswap((char *) &net_int64, 8);
 211   return net_int64;
 212 #endif
 213 }
 214 sqd_uint64
 215 sre_hton64(sqd_uint64 host_int64)
 216 {
 217 #ifdef WORDS_BIGENDIAN
 218   return host_int64;
 219 #else
 220   Byteswap((char *) &host_int64, 8);
 221   return host_int64;
 222 #endif
 223 }
 224
 225
 226
 227