/* c4.c  Conversion Routines  (c)Copyright Sequiter Software Inc., 1988-1996.  All rights reserved. */

#include "d4all.h"

#ifdef __TURBOC__
   #pragma hdrstop
#endif  /* __TUROBC__ */

#ifdef S4VBASIC
int c4parm_check( void *ptr, int doCheck, const long message )
{
   char errMsg[512] ;

   if (!ptr)
      doCheck = - 1 ;

   else
   {
      switch (doCheck)
      {
         case 0:
            if ( ((INDEX4 *)ptr)->codeBase->debugInt != E4DEBUG_INT)
               doCheck = -1 ;
            break ;

         case 1:
            if ( ((CODE4 *)ptr)->debugInt != E4DEBUG_INT)
               doCheck = -1 ;
            break ;
         case 2:
            if ( ((DATA4 *)ptr)->debugInt != E4DEBUG_INT)
               doCheck = -1 ;
            break ;
         case 3:
            if ( ((FIELD4 *)ptr)->debugInt != E4DEBUG_INT)
               doCheck = -1 ;
            break ;
         case 4:
            if ( ((TAG4 *)ptr)->index->codeBase->debugInt != E4DEBUG_INT)
               doCheck = -1 ;
            break ;
         case 5:
            if ( ((RELATE4 *)ptr)->codeBase->debugInt != E4DEBUG_INT)
               doCheck = -1 ;
            break ;
         #ifndef S4OFF_REPORT
         case 6:
            if ( ((REPORT4 *)ptr)->codeBase->debugInt != E4DEBUG_INT)
               doCheck = -1 ;
            break ;
         #endif
      }
   }

   if (doCheck < 0 )
   {
      strcpy( errMsg, "Function was Passed an Invalid Structure Pointer" ) ;
      return error4describe( 0, e4info, message, errMsg, 0, 0 ) ;
   }
   else return 0 ;
}

#endif  /* S4VBASIC */

#ifdef S4NO_ATOF
double c4atof( const char *bufIn )
{
   double decLen = 1.0 ;
   int i, baseLen, decLenHold, offset, max ;
   const char *cPtr ;
   char *ptr, buf[40] ;
   double baseDoub, decDoub, doub ;

   max = strlen( bufIn ) ;
   for ( offset = 0 ; offset < max ; offset++ )
   {
      if ( bufIn[offset] != ' ' )
         break ;
   }

   u4ncpy( buf, bufIn + offset, sizeof( buf ) ) ;

   cPtr = strchr( buf, '.' ) ;
   if ( cPtr == 0 )
   {
      baseLen = strlen( buf ) ;
      ptr = 0 ;
   }
   else
   {
      baseLen = ( cPtr - buf ) ;
      ptr = buf + baseLen ;
      if ( ptr != cPtr )
         return -1 ;
   }

   if ( ptr )
   {
      *ptr++ = '\0' ;
      decLenHold = strlen( ptr ) ;
      for ( i = decLenHold ; i > 0 ; i-- )
         decLen = decLen * 10  ;

      if ( decLenHold > 9 )   /* too big for a long, so alternate conversion */
      {
         decDoub = 0.0 ;
         for ( i = 0 ; decLenHold > 9 ; decLenHold--, i++ )
            decDoub = decDoub * 10.0 + ptr[i] - '0' ;
         decDoub = decDoub * 1000000000 + (double)atol(ptr+i) ;
      }
      else
         decDoub = (double)atol(ptr) ;

      if ( baseLen > 9 )   /* too big for a long, so alternate conversion */
      {
         baseDoub = 0.0 ;
         for ( i = 0 ; baseLen > 9 ; baseLen--, i++ )
            baseDoub = baseDoub * 10.0 + buf[i] - '0' ;
         baseDoub = baseDoub * 1000000000 + (double)atol(buf+i) ;
      }
      else
         baseDoub = (double)atol(buf) ;
      doub = baseDoub + decDoub / decLen ;
      *(--ptr) = '.' ;
   }
   else
   {
      if ( baseLen > 9 )  /* greater than size of long */
      {
         doub = 0.0 ;
         for ( i = 0 ; baseLen > 9 ; baseLen--, i++ )
            doub = doub * 10.0 + buf[i] - '0' ;
         doub = doub * 1000000000 + (double)atol(buf+i) ;
      }
      else
         doub = (double)atol(buf) ;
   }
   return doub ;
}
#endif

/* c4atod    Converts a string to a double */
double S4FUNCTION c4atod( const char *str, const int lenStr )
{
   char buffer[50] ;
   int  len ;

   len = ( lenStr >= 50 ) ? 49 : lenStr ;
   memcpy( buffer, str, (size_t)len ) ;
   buffer[len] = '\0' ;
   #ifdef S4NO_ATOF
      return c4atof( buffer ) ;
   #else
      return atof( buffer ) ;
   #endif
}

void S4FUNCTION c4atod2( char *str, int lenStr, double *result )
{
   char buffer[50] ;
   int  len ;

   len = ( lenStr >= 50 ) ? 49 : lenStr ;
   memcpy( buffer, str, (size_t)len ) ;
   buffer[len] = '\0' ;
   #ifdef S4NO_ATOF
      *result = c4atof( buffer ) ;
   #else
      *result = atof( buffer ) ;
   #endif
   return;
}

int S4FUNCTION c4atoi( const char *str, const int l )
{
   char buf[128] ;
   int lenStr ;

   if ( l >= (int)sizeof( buf ) )
      lenStr = (int)sizeof( buf ) - 1 ;
   else
      lenStr = l ;
   memcpy( buf, str, (size_t)lenStr ) ;
   buf[lenStr] = '\0' ;
   return atoi( buf ) ;
}

long S4FUNCTION c4atol( const char *str, const int l )
{
   char buf[128] ;
   int lenStr ;

   if ( l >= (int)sizeof( buf ) )
      lenStr = (int)sizeof( buf ) - 1 ;
   else
      lenStr = l ;

   memcpy( buf, str, (size_t)lenStr) ;
   buf[lenStr] = '\0' ;
   return atol( buf ) ;
}

char *c4descend( char *to, const char *from, int len )
{
   for(; len-- > 0; )
      to[len] = -from[len] ;
   return to ;
}

#ifdef S4CLIPPER
/* S4CLIPPER */
void c4dtoaClipper( double val, char *result, int len, int decimals )
{
   int digLen, isNeg, zerosLen, decPos, decLen, resultLen, i ;
   char *str, *ptr ;

   resultLen = len ;

   #ifdef S4NO_FCVT
      str = f4fcvt( val, decimals, &digLen, &isNeg) ;
   #else
      str = fcvt( val, decimals, &digLen, &isNeg) ;
   #endif

   zerosLen = resultLen - digLen - decimals - (decimals > 0 ) ;
   if ( zerosLen > 0 )
      memset( result, '0', zerosLen ) ;

   if ( decimals > 0 )
   {
      decPos = resultLen - decimals - 1 ;
      result[decPos] = '.' ;
   }
   else
      decPos = resultLen ;

   if ( zerosLen > 0 )
      ptr = result + zerosLen ;
   else
      ptr = result ;

   if ( digLen >= 0 )
   {
      if ( (decPos - digLen) < 0 )
      {
         memset( ptr, (int) '*', (size_t)resultLen) ;
         return ;
      }
      memcpy( ptr, str, (size_t) digLen ) ;
      if ( zerosLen >= 0 && decimals > 0 )
      {
         ptr += digLen ;
         *ptr = '.' ;
         memcpy( ++ptr, str+digLen, (size_t)decimals ) ;
      }
   }
   else
   {
      decLen = decimals + digLen ;
      if ( decLen > 0 )
         memcpy( ptr - digLen, str, decLen ) ;
   }

   if ( isNeg )
   {
      for ( i=0; i< resultLen; i++ )
         result[i] = (char) 0x5c - result[i] ;
   }
}
#endif

/* Clipper, DESCEND() & ASCEND() */
/* Numeric Key Database Output is Converted to Numeric Key Index File format */
int c4clip( char *ptr, int len)
{
   int i, negative ;
   char *p ;

   for ( i= negative= 0, p= ptr; i< len; i++, p++ )
   {
      if ( *p == ' ' )
      {
         *p = '0' ;
      }
      else
      {
         if ( *p == '-' )
         {
            *p = '0' ;
            negative = 1 ;
         }
         else
            break ;
      }
   }

   if ( negative )
   {
      for ( i= 0, p= ptr; i< len; i++, p++ )
         *p = (char) 0x5c - *p ;
   }

   return 0 ;
}

/* c4dtoa45
   - formats a double to a string
   - if there is an overflow, '*' are returned
*/
int S4FUNCTION c4dtoa45( double doubVal, char *outBuffer, int len, int dec)
{
   int preLen, postLen, signPos, decVal, signVal ;
   char *result ;

   #ifdef E4PARM_LOW
      if ( len < 0 || len >128 || dec < 0 || dec >= len )
         return error4( 0, e4parm, E95106 ) ;
   #endif

   memset( outBuffer, (int) '0', (size_t) len) ;

   if (dec > 0)
   {
      postLen = dec ;
      if (postLen > 15)
         postLen = 15 ;
      if (postLen > len-1)
         postLen = len-1 ;
      preLen = len -postLen -1 ;

      outBuffer[ preLen] = '.' ;
   }
   else
   {
      preLen = len ;
      postLen = 0 ;
   }

   #ifdef S4NO_FCVT
      result = (char *)f4fcvt( doubVal, postLen, &decVal, &signVal) ;
   #else
      result = (char *)fcvt( doubVal, postLen, &decVal, &signVal) ;
   #endif

   if (decVal > 0)
      signPos = preLen-decVal -1 ;
   else
   {
      signPos = preLen - 2 ;
      if ( preLen == 1 )
         signPos = 0 ;
   }

   if ( (decVal > preLen) ||  (preLen<0)  ||  ((signPos< 0) && signVal) )
   {
      /* overflow */
      memset( outBuffer, (int)'*', (size_t)len) ;
      return e4overflow ;  /* don't generate an error, but return state */
   }

   if (decVal > 0)
   {
      memset( outBuffer, (int)' ', (size_t)(preLen - decVal) ) ;
      c4memmove( outBuffer + preLen - decVal, result, (size_t)decVal) ;
      if ( ( outBuffer[preLen-1] == '\0' ) && (preLen > 0) )
         outBuffer[preLen-1] = '0' ;
   }
   else
   {
      if ( preLen> 0 )
         memset( outBuffer, (int) ' ', (size_t) (preLen-1)) ;
   }
   if ( signVal )
      outBuffer[signPos] = '-' ;


   outBuffer += preLen+1 ;
   if (decVal >= 0)
      result+= decVal ;
   else
   {
      outBuffer    -= decVal ;
      postLen += decVal ;
   }

   if ( postLen > (int) strlen(result) )
      postLen = (int) strlen( result) ;

   /*  - outBuffer   points to where the digits go to
       - result       points to where the digits are to be copied from
       - postLen     is the number to be copied
   */

   if ( postLen > 0 )
      c4memmove( outBuffer, result, (size_t)postLen ) ;

   return 0 ;
}

/* c4encode

   - From CCYYMMDD to CCYY.MM.DD

   Ex.        c4encode( to, from, "CCYY.MM.DD", "CCYYMMDD" ) ;
*/

void S4FUNCTION c4encode( char *to, const char *f, char *tTo, const char *tF )
{
   int pos ;
   char chr ;
   char *chrPos ;
   char const * tFrom, * from ;

   tFrom = tF ;
   from = f ;

   strcpy( to, tTo ) ;

   while ( (chr = *tFrom++) != 0)
   {
      if ( ( chrPos= strchr( tTo, chr ) ) == 0 )
      {
         from++;
         continue ;
      }

      pos = (int)( chrPos - tTo ) ;
      to[pos++] = *from++ ;

      while (chr == *tFrom)
      {
         if (chr == tTo[pos] )
            to[pos++] = *from ;
         tFrom++ ;
         from++ ;
      }
   }
}

/*  c4ltoa45

    Converts a long to a string.  Fill with '0's rather than blanks if
    'num' is less than zero.
*/

void S4FUNCTION c4ltoa45( long lVal, char *ptr, int num)
{
   int   n, numPos ;
   long  iLong ;

   iLong = (lVal>0) ? lVal : -lVal ;
   numPos = n = (num > 0) ? num : -num ;

   while (n-- > 0)
   {
      ptr[n] = (char) ('0'+ iLong%10) ;
      iLong = iLong/10 ;
   }

   if ( iLong > 0 )
   {
     memset( ptr, (int) '*', (size_t) numPos ) ;
     return ;
   }

   num--;
   for (n=0; n<num; n++)
      if (ptr[n]=='0')
         ptr[n]= ' ';
      else
         break ;

   if (lVal < 0)
   {
      if ( ptr[0] != ' ' )
      {
         memset( ptr, (int) '*', (size_t) numPos ) ;
         return ;
      }
      for (n=num; n>=0; n--)
         if (ptr[n]==' ')
         {
            ptr[n]= '-' ;
            break ;
         }
   }
}

void S4FUNCTION c4trimN( char *str, int nCh )
{
   int len ;

   if ( nCh <= 0 )
      return ;

   /* Count the Length */
   len = 0 ;
   while ( len< nCh )
   {
      len++ ;
      if ( *str++ == '\0' )
         break ;
   }

   if ( len < nCh )
      nCh = len ;

   *(--str) = '\0' ;

   while( --nCh > 0 )
   {
      str-- ;
      if ( *str == '\0' ||  *str == ' ' )
         *str = '\0' ;
      else
         break ;
   }
}

#ifndef S4LANGUAGE

void S4FUNCTION c4lower( char *str )
{
#ifdef S4NO_STRLWR
   char *ptr ;

   ptr = str ;

   while ( *ptr != '\0' )
   {
      if ( *ptr >= 'A' && *ptr <= 'Z' )
       *ptr |= 0x20 ;
      ptr++ ;
   }
#else
   #ifdef S4ANSI
      AnsiLower( str ) ;
   #else
      (void)strlwr( str ) ;
   #endif
#endif
}

void S4FUNCTION c4upper( char *str )
{
#ifdef S4NO_STRUPR
   char *ptr ;

   ptr = str ;

   while ( *ptr != '\0' )
   {
      if ( *ptr >= 'a'  &&  *ptr <= 'z' )
       *ptr &= 0xDF ;
      ptr++ ;
   }
#else
   #ifdef S4ANSI
      AnsiUpper( str ) ;
   #else
      (void)strupr( str ) ;
   #endif
#endif
}

#else  /* ifdef S4LANGUAGE  */

#ifdef S4GERMAN
   void  S4FUNCTION c4upper( char *str )
   {
   #ifdef S4ANSI
      AnsiUpper(str) ;
   #else
      unsigned char *ptr ;

      ptr = (unsigned char *)str ;

      while ( *ptr != '\0' )
      {
         if ( *ptr >= 'a'  &&  *ptr <= 'z' )
            *ptr &= 0xDF ;

         if ( *ptr >= 0x81 )
         {
            switch( *ptr )
            {
                   case 0x84:
                      *ptr = 0x8E ;
                      break ;
                   case 0x94:
                      *ptr = 0x99 ;
                      break ;
                   case 0x81:
                      *ptr = 0x9A ;
                      break ;
            }
         }
         ptr++ ;
      }
   #endif
   }

   void S4FUNCTION c4lower( char *str )
   {
   #ifdef S4ANSI
      AnsiLower(str) ;
   #else
      unsigned char *ptr ;

      ptr = (unsigned char *)str ;

      while ( *ptr != '\0' )
      {
         if ( *ptr >= 'A' && *ptr <= 'Z' )
            *ptr |= 0x20 ;
         if ( *ptr >= 0x81 )
         {
            switch( *ptr )
            {
               case 0x8E:
                        *ptr = 0x84 ;
                        break ;
               case 0x99:
                        *ptr = 0x94 ;
                        break ;
               case 0x9A:
                        *ptr = 0x81 ;
                        break ;
            }
         }
         ptr++ ;
      }
   #endif
   }
#endif /* S4GERMAN */

#ifdef S4FRENCH
   void  S4FUNCTION c4upper( char *str )
   {
   #ifdef S4ANSI
      AnsiUpper(str) ;
   #else
      unsigned char *ptr ;

      ptr = (unsigned char *)str ;

      while ( *ptr != '\0' )
      {
         if ( *ptr >= 'a'  &&  *ptr <= 'z' )
            *ptr &= 0xDF ;

         /* Les accents sont laiss afin d'tre compatible avec toute priphrie */
         if ( *ptr >= E4C_CED )
         {
            switch( *ptr )
            {
               case E4A_TRE :
               case E4A_GRA :
                     case E4A_CIR :
                     case E4A_CI2 :
               case E4A_EGU :
                        *ptr = 'A' ;        /* A */
                        break ;
               case E4C_CED :
                  *ptr = 'C' ;        /* C */
                  break ;
                     case E4E_EGU :
               case E4E_GRA :
                     case E4E_CIR :
                     case E4E_TRE :
                  *ptr = 'E' ;        /* E */
                  break ;
                     case E4I_TRE :
               case E4I_EGU :
               case E4I_GRA :
                     case E4I_CIR :
                  *ptr = 'I' ;        /* I */
                  break ;
                     case E4U_CIR :
                     case E4U_TRE :
                     case E4U_GRA :
                     case E4U_EGU :
                  *ptr = 'O' ;        /* O */
                  break ;
                     case E4O_CIR :
                     case E4O_GRA :
                     case E4O_TRE :
                     case E4O_EGU :
                  *ptr = 'U' ;        /* U */
                  break ;
                     case E4Y_TRE :
                  *ptr = 'Y' ;        /* Y */
                  break ;
            }
         }
         ptr++ ;
      }
   #endif
   }

   void S4FUNCTION c4lower( char *str )
   {
   #ifdef S4ANSI
      AnsiLower(str) ;
   #else
      unsigned char *ptr ;

      ptr = (unsigned char *)str ;

      while ( *ptr != '\0' )
      {
         if ( *ptr >= 'A' && *ptr <= 'Z' )
            *ptr |= 0x20 ;

         /* Les accents sont laiss afin d'tre compatible avec toute priphrie */
         if ( *ptr >= E4C_CED )
         {
            switch( *ptr )
            {
               case E4CM_CED:
                  *ptr = 'c' ;       /* c */
                  break ;
               case E4AM_TRE:
               case E4AM_CIR:
                  *ptr = 'a' ;       /* a */
                  break ;
               case E4EM_EGU:
                  *ptr = 'e' ;       /* e */
                  break ;
               case E4OM_TRE:
                  *ptr = 'o' ;       /* o */
                  break ;
               case E4UM_TRE:
                  *ptr = 'u' ;       /* u */
                  break ;
            }
         }
         ptr++ ;
      }
   #endif
   }
#endif   /*  S4FRENCH  */

#ifdef S4SWEDISH
   void  S4FUNCTION c4upper( char *str )
   {
   #ifdef S4ANSI
      AnsiUpper(str) ;
   #else
      unsigned char *ptr ;

      ptr = (unsigned char *)str ;

      while ( *ptr != '\0' )
      {
         if ( *ptr >= 'a'  &&  *ptr <= 'z' )
            *ptr &= 0xDF ;

         if ( *ptr >= 0x81 )
         {
            switch( *ptr )
            {
                   case 0x81:
                      *ptr = 0x9A ;
                      break ;
                   case 0x82:
                      *ptr = 0x90 ;
                      break ;
                   case 0x84:
                      *ptr = 0x8E ;
                      break ;
                   case 0x86:
                      *ptr = 0x8F ;
                      break ;
                   case 0x91:
                      *ptr = 0x92 ;
                      break ;
                   case 0x94:
                      *ptr = 0x99 ;
                      break ;
            }
         }
         ptr++ ;
      }
   #endif
   }

   void S4FUNCTION c4lower( char *str )
   {
   #ifdef S4ANSI
      AnsiLower(str) ;
   #else
      unsigned char *ptr ;

      ptr = (unsigned char *)str ;

      while ( *ptr != '\0' )
      {
         if ( *ptr >= 'A' && *ptr <= 'Z' )
            *ptr |= 0x20 ;
         if ( *ptr >= 0x81 )
         {
            switch( *ptr )
            {
               case 0x8E:
                        *ptr = 0x84 ;
                        break ;
               case 0x8F:
                        *ptr = 0x86 ;
                        break ;
               case 0x90:
                        *ptr = 0x82 ;
                        break ;
               case 0x92:
                        *ptr = 0x91 ;
                        break ;
               case 0x99:
                        *ptr = 0x94 ;
                        break ;
               case 0x9A:
                        *ptr = 0x81 ;
                        break ;
            }
         }
         ptr++ ;
      }
   #endif
   }
#endif /* S4SWEDISH */

#ifdef S4FINNISH
   void  S4FUNCTION c4upper( char *str )
   {
   #ifdef S4ANSI
      AnsiUpper(str) ;
   #else
      unsigned char *ptr ;

      ptr = (unsigned char *)str ;

      while ( *ptr != '\0' )
      {
         if ( *ptr >= 'a'  &&  *ptr <= 'z' )
            *ptr &= 0xDF ;

         if ( *ptr >= 0x81 )
         {
            switch( *ptr )
            {
                   case 0x81:
                      *ptr = 0x9A ;
                      break ;
                   case 0x82:
                      *ptr = 0x90 ;
                      break ;
                   case 0x84:
                      *ptr = 0x8E ;
                      break ;
                   case 0x86:
                      *ptr = 0x8F ;
                      break ;
                   case 0x91:
                      *ptr = 0x92 ;
                      break ;
                   case 0x94:
                      *ptr = 0x99 ;
                      break ;
            }
         }
         ptr++ ;
      }
   #endif
   }

   void S4FUNCTION c4lower( char *str )
   {
   #ifdef S4ANSI
      AnsiLower(str) ;
   #else
      unsigned char *ptr ;

      ptr = (unsigned char *)str ;

      while ( *ptr != '\0' )
      {
         if ( *ptr >= 'A' && *ptr <= 'Z' )
            *ptr |= 0x20 ;
         if ( *ptr >= 0x81 )
         {
            switch( *ptr )
            {
               case 0x8E:
                        *ptr = 0x84 ;
                        break ;
               case 0x8F:
                        *ptr = 0x86 ;
                        break ;
               case 0x90:
                        *ptr = 0x82 ;
                        break ;
               case 0x92:
                        *ptr = 0x91 ;
                        break ;
               case 0x99:
                        *ptr = 0x94 ;
                        break ;
               case 0x9A:
                        *ptr = 0x81 ;
                        break ;
            }
         }
         ptr++ ;
      }
   #endif
   }
#endif /* S4FINNISH */

#ifdef S4NORWEGIAN
   void  S4FUNCTION c4upper( char *str )
   {
   #ifdef S4ANSI
      AnsiUpper(str) ;
   #else
      unsigned char *ptr ;

      ptr = (unsigned char *)str ;

      while ( *ptr != '\0' )
      {
         if ( *ptr >= 'a'  &&  *ptr <= 'z' )
            *ptr &= 0xDF ;

         if ( *ptr >= 0x81 )
         {
            switch( *ptr )
            {
                   case 0x81:
                      *ptr = 0x9A ;
                      break ;
                   case 0x82:
                      *ptr = 0x90 ;
                      break ;
                   case 0x84:
                      *ptr = 0x8E ;
                      break ;
                   case 0x86:
                      *ptr = 0x8F ;
                      break ;
                   case 0x91:
                      *ptr = 0x92 ;
                      break ;
                   case 0x94:
                      *ptr = 0x99 ;
                      break ;
            }
         }
         ptr++ ;
      }
   #endif
   }

   void S4FUNCTION c4lower( char *str )
   {
   #ifdef S4ANSI
      AnsiLower(str) ;
   #else
      unsigned char *ptr ;

      ptr = (unsigned char *)str ;

      while ( *ptr != '\0' )
      {
         if ( *ptr >= 'A' && *ptr <= 'Z' )
            *ptr |= 0x20 ;
         if ( *ptr >= 0x81 )
         {
            switch( *ptr )
            {
               case 0x8E:
                        *ptr = 0x84 ;
                        break ;
               case 0x8F:
                        *ptr = 0x86 ;
                        break ;
               case 0x90:
                        *ptr = 0x82 ;
                        break ;
               case 0x92:
                        *ptr = 0x91 ;
                        break ;
               case 0x99:
                        *ptr = 0x94 ;
                        break ;
               case 0x9A:
                        *ptr = 0x81 ;
                        break ;
            }
         }
         ptr++ ;
      }
   #endif
   }
#endif /* S4NORWEGIAN */

#endif   /*  S4LANGUAGE  */


#ifdef S4NO_MEMMOVE
void *c4memmove(void *dest, const void *src, size_t count )
{
   if ( dest < src )
   {
      if ( (char *)dest + count  <= (char *) src )
      {
         memcpy( dest, src, count ) ;
         return( dest ) ;
      }
      else
      {
         /* Start at beginning of 'src' */
         int  i ;
         for ( i=0; i< count; i++ )
            ((char *) dest)[i] = ((char *)src)[i] ;
         return( dest ) ;
      }
   }

   if ( src < dest )
   {
      if ( (char *) src + count  <= (char *) dest )
      {
         memcpy( dest, src, count ) ;
         return( dest ) ;
      }
      else
      {
         /* Start at end of 'src' */
         for(;count!=0;)
         {
            --count ;
            ((char *)dest)[count] = ((char *) src)[count] ;
         }
         return( dest ) ;
      }
   }
   return( dest ) ;
}
#endif  /* S4NO_MEMMOVE */

#ifdef S4MEMCMP
int c4memcmp(const void * __s1, const void * __s2, size_t __n)
{
   unsigned char *p1, *p2 ;
   int cnt ;

   p1 = (unsigned char *)__s1 ;
   p2 = (unsigned char *)__s2 ;

   for ( cnt = 0 ; cnt < __n ; cnt++ )
   {
      if ( p1[cnt] != p2[cnt] )
      {
         if ( p1[cnt] > p2[cnt] )
            return 1 ;
         return -1 ;
      }
   }
   return 0 ;
}
#endif   /* S4MEMCMP */

#ifdef S4NO_STRNICMP
int strnicmp(char *a, char *b, size_t n )
{
   unsigned char aChar, bChar ;

   for ( ; *a != '\0'  &&  *b != '\0' && n != 0; a++, b++, n-- )
   {
      aChar = (unsigned char) *a  & 0xDF ;
      bChar = (unsigned char) *b  & 0xDF ;

      if ( aChar < bChar )  return -1 ;
      if ( aChar > bChar )  return  1 ;
   }
   return 0 ;
}
#endif  /* S4NO_STRNICMP */

#ifndef S4OPTIMIZE_OFF
/* used by optimization */
int S4FUNCTION c4calcType( unsigned long l )
{
   int i ;

   for ( i = 0 ; l > 1 ; i++ )
      l >>= 1 ;
   return i ;
}

#endif