///////////////////////////////////////////////////////////////////////////////
// stdlibex.cpp                                                              //
// Extensions to stdlib(.h) Functions for converting 64 and 32 bits int's,   //
//                                                                           //
// Copyright (c) Smartsoft, LLC 1985-2002.  All Rights Reserved.             //
// Written by Jan Knepper                                                    //
//                                                                           //
// Redistribution and use in source and binary forms, with or without        //
// modification, are permitted provided that the following conditions        //
// are met:                                                                  //
// 1. Redistributions of source code must retain the above copyright         //
//    notice, this list of conditions and the following disclaimer.          //
// 2. Redistributions in binary form must reproduce the above copyright      //
//    notice, this list of conditions and the following disclaimer in the    //
//    documentation and/or other materials provided with the distribution.   //
// 3. The name of the author may not be used to endorse or promote products  //
//    derived from this software without specific prior written permission.  //
//                                                                           //
// THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND   //
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE     //
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR        //
// PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE //
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR       //
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF      //
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS  //
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN   //
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)   //
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF    //
// THE POSSIBILITY OF SUCH DAMAGE.                                           //
///////////////////////////////////////////////////////////////////////////////



#include <stdjak.h>

#include "RTL/stdlibex.h"



static const int        STRING   = 80;



static char *           x64toa  ( uint64, char *, unsigned, int );



char  *lltoa ( int64  value, char  *str, int  radix )
{
   return ( x64toa ( ( uint64 ) value, str, radix, ( ( radix == 10 ) && ( value < 0 ) ) ) );
}



char  *ulltoa ( uint64  value, char  *str, int  radix )
{
   return ( x64toa (            value, str, radix, ( ( radix == 10 ) && ( value < 0 ) ) ) );
}



#ifdef _UNICODE



wchar_t  *lltow ( int64  value, wchar_t  *str, int  radix )
{
   char     string   [ STRING ];

   MultiByteToWideChar ( CP_ACP, MB_PRECOMPOSED, lltoa ( value, string, radix ), -1, str, STRING );

   return ( str );
}



wchar_t  *ulltow ( uint64  value, wchar_t  *str, int  radix )
{
   char     string   [ STRING ];

   MultiByteToWideChar ( CP_ACP, MB_PRECOMPOSED, ulltoa ( value, string, radix ), -1, str, STRING );

   return ( str );
}



#endif



#ifdef __GNU_CPP__



static char *           x32toa  ( uint32, char *, unsigned, int );



char  *ltoa ( long  value, char  *str, int  radix )
{
   return ( x32toa ( ( uint32 ) value, str, radix, ( ( radix == 10 ) && ( value < 0 ) ) ) );
}



char  *ultoa ( ulong  value, char  *str, int  radix )
{
   return ( x32toa (            value, str, radix, ( ( radix == 10 ) && ( value < 0 ) ) ) );
}



#endif



static char *  x64toa ( uint64  value, char  *str, unsigned  radix, int  neg )
{
   char    *ptr   = str;

   // Deal with negativity. Don't be negative, be positive, cut of his ...!

   if ( neg )
   {
      *ptr++   = '-';
      value    = ( uint64 ) ( - ( int64 ) value );
   }

   char    *first = ptr;                  // Pointer to first digit.

   do
   {
      unsigned    digit = ( unsigned ) ( value % radix );

      value   /= radix;                   // Trick, repeatedly devide by 'radix'!

      // Convert to ASCII.

      if ( digit < 10 )
         *ptr++   = ( char ) ( digit      + '0' ); // A digit. '0'..'9'.
      else
         *ptr++   = ( char ) ( digit - 10 + 'A' ); // A letter. 'A'..'Z'.
   }
   while ( value > 0 );

   // Now 'ptr' points to the reverse string of digits that represents 'value'.
   // So, reverse the string. In Digital Mars C++ (Symantec C++, Zortech C++)
   // strrev would have done this, but hey... Not all compilers are as cool!

   *ptr--   = '\0';                       // ptr points to first, p points to last.

   do
   {
      // Swap em!

      char     help  = *ptr;

      *ptr     = *first;
      *first   = help;

      --ptr;                              // Move on forward and reverse!
      ++first;
   }
   while ( first < ptr );                 // Only go halfway!

   return ( str );
}



#ifdef __GNU_CPP__



static char *  x32toa ( uint32  value, char  *str, unsigned  radix, int  neg )
{
   char    *ptr   = str;

   // Deal with negativity. Don't be negative, be positive, cut of his ...!

   if ( neg )
   {
      *ptr++   = '-';
      value    = ( uint32 ) ( - ( int32 ) value );
   }

   char    *first = ptr;                  // Pointer to first digit.

   do
   {
      unsigned    digit = ( unsigned ) ( value % radix );

      value   /= radix;                   // Trick, repeatedly devide by 'radix'!

      // Convert to ASCII.

      if ( digit < 10 )
         *ptr++   = ( char ) ( digit      + '0' ); // A digit. '0'..'9'.
      else
         *ptr++   = ( char ) ( digit - 10 + 'A' ); // A letter. 'A'..'Z'.
   }
   while ( value > 0 );

   // Now 'ptr' points to the reverse string of digits that represents 'value'.
   // So, reverse the string. In Digital Mars C++ (Symantec C++, Zortech C++)
   // strrev would have done this, but hey... Not all compilers are as cool!

   *ptr--   = '\0';                       // ptr points to first, p points to last.

   do
   {
      // Swap em!

      char     help  = *ptr;

      *ptr     = *first;
      *first   = help;

      --ptr;                              // Move on, forward en reverse!
      ++first;
   }
   while ( first < ptr );                 // Only go halfway!

   return ( str );
}



#endif