text: /* Modifications copyright (c) 2015, Oracle and/or its affiliates
  */
  #include "config.h"
  #include <stdio.h>
  #include <assert.h>
  #include <ctype.h>
  #include <errno.h>
  #include <string.h>
  #include <stdlib.h>
  #include <stdarg.h>
  
  #include "memcached/util.h"
  
  /* Avoid warnings on solaris, where isspace() is an index into an array, and gcc uses signed chars */
  #define xisspace(c) isspace((unsigned char)c)
  
  bool safe_strtoull(const char *str, uint64_t *out) {
      assert(out != NULL);
      errno = 0;
      *out = 0;
      char *endptr;
      unsigned long long ull = strtoull(str, &endptr, 10);
      if (errno == ERANGE)
          return false;
      if (xisspace(*endptr) || (*endptr == '\0' && endptr != str)) {
          if ((long long) ull < 0) {
              /* only check for negative signs in the uncommon case when
               * the unsigned number is so big that it's negative as a
               * signed number. */
              if (strchr(str, '-') != NULL) {
                  return false;
              }
          }
          *out = ull;
          return true;
      }
      return false;
  }
  
  bool safe_strtoll(const char *str, int64_t *out) {
      assert(out != NULL);
      errno = 0;
      *out = 0;
      char *endptr;
      long long ll = strtoll(str, &endptr, 10);
      if (errno == ERANGE)
          return false;
      if (xisspace(*endptr) || (*endptr == '\0' && endptr != str)) {
          *out = ll;
          return true;
      }
      return false;
  }
  
  bool safe_strtoul(const char *str, uint32_t *out) {
      char *endptr = NULL;
      unsigned long l = 0;
      assert(out);
      assert(str);
      *out = 0;
      errno = 0;
  
      l = strtoul(str, &endptr, 10);
      if (errno == ERANGE) {
          return false;
      }
  
      if (xisspace(*endptr) || (*endptr == '\0' && endptr != str)) {
          if ((long) l < 0) {
              /* only check for negative signs in the uncommon case when
               * the unsigned number is so big that it's negative as a
               * signed number. */
              if (strchr(str, '-') != NULL) {
                  return false;
              }
          }
          *out = l;
          return true;
      }
  
      return false;
  }
  
  bool safe_strtol(const char *str, int32_t *out) {
      assert(out != NULL);
      errno = 0;
      *out = 0;
      char *endptr;
      long l = strtol(str, &endptr, 10);
      if (errno == ERANGE)
          return false;
      if (xisspace(*endptr) || (*endptr == '\0' && endptr != str)) {
          *out = l;
          return true;
      }
      return false;
  }
  
  bool safe_strtof(const char *str, float *out) {
      assert(out != NULL);
      errno = 0;
      *out = 0;
      char *endptr;
      float l = strtof(str, &endptr);
      if (errno == ERANGE)
          return false;
      if (isspace(*endptr) || (*endptr == '\0' && endptr != str)) {
          *out = l;
          return true;
      }
      return false;
  }
  
  void vperror(const char *fmt, ...) {
      int old_errno = errno;
      char buf[1024];
      va_list ap;
  
      va_start(ap, fmt);
      if (vsnprintf(buf, sizeof(buf), fmt, ap) == -1) {
          buf[sizeof(buf) - 1] = '\0';
      }
      va_end(ap);
  
      errno = old_errno;
  
      perror(buf);
  }
  
  uint64_t mc_swap64(uint64_t in) {
  #ifndef WORDS_BIGENDIAN
      /* Little endian, flip the bytes around until someone makes a faster/better
      * way to do this. */
      int64_t rv = 0;
      int i = 0;
       for(i = 0; i<8; i++) {
          rv = (rv << 8) | (in & 0xff);
          in >>= 8;
       }
      return rv;
  #else
      /* big-endian machines don't need byte swapping */
      return in;
  #endif
  }
  
  