xtoa.cpp

Go to the documentation of this file.

// $Header: /tmp/svngaudi/tmp.jEpFh25751/Gaudi/GaudiKernel/src/Lib/xtoa.cpp,v 1.3 2003/11/27 10:20:59 mato Exp $
#if !defined(_WIN32)
#include <stdlib.h>
#include <limits.h>
#include "GaudiKernel/xtoa.h"

/***
*xtoa.c - convert integers/longs to ASCII string
*
*   Copyright (c) 1989-1997, Microsoft Corporation. All rights reserved.
*
*Purpose:
*   The module has code to convert integers/longs to ASCII strings.  See
*
*******************************************************************************/

/***
*char *_itoa, *_ltoa, *_ultoa(val, buf, radix) - convert binary int to ASCII
*   string
*
*Purpose:
*   Converts an int to a character string.
*
*Entry:
*   val - number to be converted (int, long or unsigned long)
*   int radix - base to convert into
*   char *buf - ptr to buffer to place result
*
*Exit:
*   fills in space pointed to by buf with string result
*   returns a pointer to this buffer
*
*Exceptions:
*
*******************************************************************************/

/* helper routine that does the main job. */

static void __cdecl xtoa (unsigned long val,char *buf,unsigned radix,int is_neg)  {
  char *p;    /* pointer to traverse string */
  char *firstdig;   /* pointer to first digit */
  char temp;    /* temp char */
  unsigned digval;  /* value of digit */

  p = buf;

  if (is_neg) {
    /* negative, so output '-' and negate */
    *p++ = '-';
    val = (unsigned long)(-(long)val);
  }

  firstdig = p;     /* save pointer to first digit */

  do {
    digval = (unsigned) (val % radix);
    val /= radix;   /* get next digit */

    /* convert to ascii and store */
    if (digval > 9)
      *p++ = (char) (digval - 10 + 'a');  /* a letter */
    else
      *p++ = (char) (digval + '0');       /* a digit */
  } while (val > 0);

  /* We now have the digit of the number in the buffer, but in reverse
     order.  Thus we reverse them now. */

  *p-- = '\0';    /* terminate string; p points to last digit */

  do {
    temp = *p;
    *p = *firstdig;
    *firstdig = temp;   /* swap *p and *firstdig */
    --p;
    ++firstdig;   /* advance to next two digits */
  } while (firstdig < p); /* repeat until halfway */
}

/* Actual functions just call conversion helper with neg flag set correctly,
   and return pointer to buffer. */

extern "C" char * __cdecl _itoa (int val,char *buf,int radix)    {
  if (radix == 10 && val < 0)
    xtoa((unsigned long)val, buf, radix, 1);
  else
    xtoa((unsigned long)(unsigned int)val, buf, radix, 0);
  return buf;
}

extern "C" char * __cdecl _ltoa (long val,char *buf,int radix)   {
  xtoa((unsigned long)val, buf, radix, (radix == 10 && val < 0));
  return buf;
}

extern "C" char * __cdecl _ultoa (unsigned long val,char *buf,int radix)    {
  xtoa(val, buf, radix, 0);
  return buf;
}

#if 0 // ndef _NO_INT64

static void __stdcall x64toa (  /* stdcall is faster and smaller... Might as well use it for the helper. */
  unsigned __int64 val,
  char *buf,
  unsigned radix,
  int is_neg
  )
{
  char *p;  /* pointer to traverse string */
  char *firstdig;   /* pointer to first digit */
  char temp;  /* temp char */
  unsigned digval;  /* value of digit */

  p = buf;

  if ( is_neg )  {
    *p++ = '-';   /* negative, so output '-' and negate */
  }

  firstdig = p;   /* save pointer to first digit */

  do {
    digval = (unsigned) (val % radix);
    val /= radix;   /* get next digit */

    /* convert to ascii and store */
    if (digval > 9)
      *p++ = (char) (digval - 10 + 'a');  /* a letter */
    else
      *p++ = (char) (digval + '0'); /* a digit */
  } while (val > 0);

  /* We now have the digit of the number in the buffer, but in reverse
   order.  Thus we reverse them now. */

  *p-- = '\0';  /* terminate string; p points to last digit */

  do {
    temp = *p;
    *p = *firstdig;
    *firstdig = temp;   /* swap *p and *firstdig */
    --p;
    ++firstdig;   /* advance to next two digits */
  } while (firstdig < p); /* repeat until halfway */
}

/* Actual functions just call conversion helper with neg flag set correctly,
   and return pointer to buffer. */

extern "C" char * __cdecl _i64toa (__int64 val,char *buf,int radix )   {
  x64toa((unsigned __int64)val, buf, radix, (radix == 10 && val < 0));
  return buf;
}

extern "C" char * __cdecl i64toa (__int64 val,char *buf,int radix )   {
  x64toa((unsigned __int64)val, buf, radix, (radix == 10 && val < 0));
  return buf;
}

extern "C" char * __cdecl _ui64toa (unsigned __int64 val,char *buf,int radix)    {
  x64toa(val, buf, radix, 0);
  return buf;
}

extern "C" char * __cdecl ui64toa (unsigned __int64 val,char *buf,int radix)    {
  x64toa(val, buf, radix, 0);
  return buf;
}

#endif  /* _NO_INT64 */

#endif /* WIN32   */