Logo Search packages:      
Sourcecode: wireshark version File versions

g_ascii_strtoull.c

/* GLIB - Library of useful routines for C programming
 * Copyright (C) 1995-1997  Peter Mattis, Spencer Kimball and Josh MacDonald
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.      See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */

/*
 * Modified by the GLib Team and others 1997-2000.  See the AUTHORS
 * file for a list of people on the GLib Team.  See the ChangeLog
 * files for a list of changes.  These files are distributed with
 * GLib at ftp://ftp.gtk.org/pub/gtk/. 
 */

/*
 * $Id: g_ascii_strtoull.c 11889 2004-09-03 18:14:00Z guy $
 *
 * "g_ascii_strtoull()" extracted from GLib 2.4.5, for use with GLibs
 * that don't have it (e.g., GLib 1.2[.x]).
 */

/*
 * MT safe
 */

#include <errno.h>

#include <glib.h>

#include "g_ascii_strtoull.h"

#ifndef G_MAXUINT64
#define G_MAXUINT64     ((guint64)G_GINT64_CONSTANT(0xFFFFFFFFFFFFFFFFU))
#endif

/**
 * g_ascii_strtoull:
 * @nptr:    the string to convert to a numeric value.
 * @endptr:  if non-%NULL, it returns the character after
 *           the last character used in the conversion.
 * @base:    to be used for the conversion, 2..36 or 0
 *
 * Converts a string to a #guint64 value.
 * This function behaves like the standard strtoull() function
 * does in the C locale. It does this without actually
 * changing the current locale, since that would not be
 * thread-safe.
 *
 * This function is typically used when reading configuration
 * files or other non-user input that should be locale independent.
 * To handle input from the user you should normally use the
 * locale-sensitive system strtoull() function.
 *
 * If the correct value would cause overflow, %G_MAXUINT64
 * is returned, and %ERANGE is stored in %errno.
 *
 * Return value: the #guint64 value.
 *
 * Since: 2.2
 **/
guint64
g_ascii_strtoull (const gchar *nptr,
              gchar      **endptr,
              guint        base)
{
  /* this code is based on on the strtol(3) code from GNU libc released under
   * the GNU Lesser General Public License.
   *
   * Copyright (C) 1991,92,94,95,96,97,98,99,2000,01,02
   *        Free Software Foundation, Inc.
   */
#define ISSPACE(c)            ((c) == ' ' || (c) == '\f' || (c) == '\n' || \
                         (c) == '\r' || (c) == '\t' || (c) == '\v')
#define ISUPPER(c)            ((c) >= 'A' && (c) <= 'Z')
#define ISLOWER(c)            ((c) >= 'a' && (c) <= 'z')
#define ISALPHA(c)            (ISUPPER (c) || ISLOWER (c))
#define     TOUPPER(c)        (ISLOWER (c) ? (c) - 'a' + 'A' : (c))
#define     TOLOWER(c)        (ISUPPER (c) ? (c) - 'A' + 'a' : (c))
  gboolean negative, overflow;
  guint64 cutoff;
  guint64 cutlim;
  guint64 ui64;
  const gchar *s, *save;
  guchar c;
  
  if (base == 1 || base > 36)
    {
      errno = EINVAL;
      return 0;
    }
  
  save = s = nptr;
  
  /* Skip white space.  */
  while (ISSPACE (*s))
    ++s;
  if (!*s)
    goto noconv;
  
  /* Check for a sign.  */
  negative = FALSE;
  if (*s == '-')
    {
      negative = TRUE;
      ++s;
    }
  else if (*s == '+')
    ++s;
  
  /* Recognize number prefix and if BASE is zero, figure it out ourselves.  */
  if (*s == '0')
    {
      if ((base == 0 || base == 16) && TOUPPER (s[1]) == 'X')
      {
        s += 2;
        base = 16;
      }
      else if (base == 0)
      base = 8;
    }
  else if (base == 0)
    base = 10;
  
  /* Save the pointer so we can check later if anything happened.  */
  save = s;
  cutoff = G_MAXUINT64 / base;
  cutlim = G_MAXUINT64 % base;
  
  overflow = FALSE;
  ui64 = 0;
  c = *s;
  for (; c; c = *++s)
    {
      if (c >= '0' && c <= '9')
      c -= '0';
      else if (ISALPHA (c))
      c = TOUPPER (c) - 'A' + 10;
      else
      break;
      if (c >= base)
      break;
      /* Check for overflow.  */
      if (ui64 > cutoff || (ui64 == cutoff && c > cutlim))
      overflow = TRUE;
      else
      {
        ui64 *= base;
        ui64 += c;
      }
    }
  
  /* Check if anything actually happened.  */
  if (s == save)
    goto noconv;
  
  /* Store in ENDPTR the address of one character
     past the last character we converted.  */
  if (endptr)
    *endptr = (gchar*) s;
  
  if (overflow)
    {
      errno = ERANGE;
      return G_MAXUINT64;
    }
  
  /* Return the result of the appropriate sign.  */
  return negative ? -ui64 : ui64;
  
 noconv:
  /* We must handle a special case here: the base is 0 or 16 and the
     first two characters are '0' and 'x', but the rest are no
     hexadecimal digits.  This is no error case.  We return 0 and
     ENDPTR points to the `x`.  */
  if (endptr)
    {
      if (save - nptr >= 2 && TOUPPER (save[-1]) == 'X'
        && save[-2] == '0')
      *endptr = (gchar*) &save[-1];
      else
      /*  There was no number to convert.  */
      *endptr = (gchar*) nptr;
    }
  return 0;
}

Generated by  Doxygen 1.6.0   Back to index