fivedev/harbour-core
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
9aaaadbc6f49d2abf2beb5b4de236f8043ec01bc
harbour-core/harbour/source/common/hbstr.c
Przemyslaw Czerpak 68cb7f510b 2006-08-17 12:40 UTC+0200 Przemyslaw Czerpak (druzus/at/priv.onet.pl) 
* harbour/contrib/rdd_ads/ads1.c
  * harbour/include/hbapi.h
  * harbour/include/hbapigt.h
  * harbour/include/hbapiitm.h
  * harbour/include/hbdefs.h
  * harbour/include/hbrdddbf.h
  * harbour/include/hbstack.h
  * harbour/include/hbsxfunc.h
  * harbour/source/common/expropt1.c
  * harbour/source/common/hbstr.c
  * harbour/source/compiler/harbour.c
  * harbour/source/compiler/hbident.c
  * harbour/source/pp/ppcore.c
  * harbour/source/rdd/hbdbsort.c
  * harbour/source/rdd/dbffpt/dbffpt1.c
  * harbour/source/rdd/hbsix/sxcompr.c
  * harbour/source/rtl/hardcr.c
  * harbour/source/rtl/inkey.c
  * harbour/source/rtl/isprint.c
  * harbour/source/rtl/math.c
  * harbour/source/rtl/mtran.c
  * harbour/source/rtl/natmsg.c
  * harbour/source/rtl/gtcrs/chrmap.c
  * harbour/source/rtl/gtcrs/gtcrs.c
  * harbour/source/rtl/gtsln/gtsln.c
  * harbour/source/rtl/gtsln/gtsln.h
  * harbour/source/rtl/gtsln/kbsln.c
  * harbour/source/rtl/gtsln/keytrans.c
  * harbour/source/rtl/gtsln/mousesln.c
  * harbour/source/vm/estack.c
  * harbour/source/vm/extend.c
  * harbour/source/vm/runner.c
  * harbour/utils/hbver/hbverfix.c
    * general code cleanup, public functions declared in header files,
      local changed to static, added mising void for functions without
      parameters, etc.
      We still have some public functions which are not used by core code
      and not declared in header files, like:
         hb_memvarValueBaseAddress(), hb_memvarGetVarHandle(),
         hb_memvarGetValueByHandle(), hb_clsCreate(), hb_clsAdd(),
         hb_clsAssociate(), hb_hashTableDel(), hb_hashTableSize(),
      I haven't touched them yet though we will have to keep in mind that
      we should make sth with them.
2006-08-17 11:05:09 +00:00

906 lines
22 KiB
C
Raw Blame History

/*
* $Id$
*/
/*
* Harbour Project source code:
* Harbour common string functions (accessed from standalone utilities and the RTL)
*
* Copyright 1999-2001 Viktor Szakats <viktor.szakats@syenar.hu>
* www - http://www.harbour-project.org
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2, or (at your option)
* any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this software; see the file COPYING. If not, write to
* the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
* Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/).
*
* As a special exception, the Harbour Project gives permission for
* additional uses of the text contained in its release of Harbour.
*
* The exception is that, if you link the Harbour libraries with other
* files to produce an executable, this does not by itself cause the
* resulting executable to be covered by the GNU General Public License.
* Your use of that executable is in no way restricted on account of
* linking the Harbour library code into it.
*
* This exception does not however invalidate any other reasons why
* the executable file might be covered by the GNU General Public License.
*
* This exception applies only to the code released by the Harbour
* Project under the name Harbour. If you copy code from other
* Harbour Project or Free Software Foundation releases into a copy of
* Harbour, as the General Public License permits, the exception does
* not apply to the code that you add in this way. To avoid misleading
* anyone as to the status of such modified files, you must delete
* this exception notice from them.
*
* If you write modifications of your own for Harbour, it is your choice
* whether to permit this exception to apply to your modifications.
* If you do not wish that, delete this exception notice.
*
*/
/*
* The following parts are Copyright of the individual authors.
* www - http://www.harbour-project.org
*
* Copyright 1999 David G. Holm <dholm@jsd-llc.com>
* hb_stricmp()
*
* See doc/license.txt for licensing terms.
*
*/
#include <ctype.h> /* Needed by hb_strupr() */
#include "hbapi.h"
#include "hbmath.h"
HB_EXPORT ULONG hb_strAt( const char * szSub, ULONG ulSubLen, const char * szText, ULONG ulLen )
{
HB_TRACE(HB_TR_DEBUG, ("hb_strAt(%s, %lu, %s, %lu)", szSub, ulSubLen, szText, ulLen));
if( ulSubLen > 0 && ulLen >= ulSubLen )
{
ULONG ulPos = 0;
ULONG ulSubPos = 0;
while( ulPos < ulLen && ulSubPos < ulSubLen )
{
if( szText[ ulPos ] == szSub[ ulSubPos ] )
{
ulSubPos++;
ulPos++;
}
else if( ulSubPos )
{
/* Go back to the first character after the first match,
or else tests like "22345" $ "012223456789" will fail. */
ulPos -= ( ulSubPos - 1 );
ulSubPos = 0;
}
else
ulPos++;
}
return ( ulSubPos < ulSubLen ) ? 0 : ( ulPos - ulSubLen + 1 );
}
else
return 0;
}
HB_EXPORT char * hb_strupr( char * pszText )
{
char * pszPos;
HB_TRACE(HB_TR_DEBUG, ("hb_strupr(%s)", pszText));
for( pszPos = pszText; *pszPos; pszPos++ )
*pszPos = toupper( *pszPos );
return pszText;
}
HB_EXPORT char * hb_strdup( const char * pszText )
{
char * pszDup;
ULONG ulLen = strlen( pszText ) + 1;
HB_TRACE(HB_TR_DEBUG, ("hb_strdup(%s, %ld)", pszText, ulLen));
pszDup = ( char * ) hb_xgrab( ulLen );
memcpy( pszDup, pszText, ulLen );
return pszDup;
}
HB_EXPORT char * hb_strndup( const char * pszText, ULONG ulLen )
{
char * pszDup;
ULONG ul;
HB_TRACE(HB_TR_DEBUG, ("hb_strndup(%s, %ld)", pszText, ulLen));
ul = 0;
pszDup = ( char * ) pszText;
while( ulLen-- && *pszDup++ )
{
++ul;
}
pszDup = ( char * ) hb_xgrab( ul + 1 );
memcpy( pszDup, pszText, ul );
pszDup[ ul ] = '\0';
return pszDup;
}
HB_EXPORT ULONG hb_strnlen( const char * pszText, ULONG ulLen )
{
ULONG ul = 0;
HB_TRACE(HB_TR_DEBUG, ("hb_strnlen(%s, %ld)", pszText, ulLen));
while( ulLen-- && *pszText++ )
{
++ul;
}
return ul;
}
HB_EXPORT int hb_stricmp( const char * s1, const char * s2 )
{
int rc = 0, c1, c2;
HB_TRACE(HB_TR_DEBUG, ("hb_stricmp(%s, %s)", s1, s2));
do
{
c1 = toupper( (unsigned char) *s1 );
c2 = toupper( (unsigned char) *s2 );
s1++;
s2++;
if( c1 != c2 )
{
rc = ( c1 < c2 ? -1 : 1 );
break;
}
}
while ( c1 );
return rc;
}
/* warning: It is not case sensitive */
HB_EXPORT int hb_strnicmp( const char * s1, const char * s2, ULONG count )
{
ULONG ulCount;
int rc = 0;
HB_TRACE(HB_TR_DEBUG, ("hb_strnicmp(%s, %s, %lu)", s1, s2, count));
for( ulCount = 0; ulCount < count; ulCount++ )
{
unsigned char c1 = toupper( (unsigned char) s1[ ulCount ] );
unsigned char c2 = toupper( (unsigned char) s2[ ulCount ] );
if( c1 != c2 )
{
rc = ( c1 < c2 ? -1 : 1 );
break;
}
else if ( !c1 )
break;
}
return rc;
}
/*
AJ: 2004-02-23
Concatenates multiple strings into a single result.
Eg. hb_xstrcat (buffer, "A", "B", NULL) stores "AB" in buffer.
*/
HB_EXPORT char * hb_xstrcat ( char *szDest, const char *szSrc, ... )
{
char *szResult = szDest;
va_list va;
HB_TRACE(HB_TR_DEBUG, ("hb_xstrcat(%p, %p, ...)", szDest, szSrc));
while( *szDest )
szDest++;
va_start(va, szSrc);
while( szSrc )
{
while ( *szSrc )
*szDest++ = *szSrc++;
szSrc = va_arg ( va, char* );
}
*szDest = '\0';
va_end ( va );
return ( szResult );
}
/*
AJ: 2004-02-23
Concatenates multiple strings into a single result.
Eg. hb_xstrcpy (buffer, "A", "B", NULL) stores "AB" in buffer.
Returns szDest.
Any existing contents of szDest are cleared. If the szDest buffer is NULL,
allocates a new buffer with the required length and returns that. The
buffer is allocated using hb_xgrab(), and should eventually be freed
using hb_xfree().
*/
HB_EXPORT char * hb_xstrcpy ( char *szDest, const char *szSrc, ...)
{
const char *szSrc_Ptr;
va_list va;
size_t dest_size;
HB_TRACE(HB_TR_DEBUG, ("hb_xstrcpy(%p, %p, ...)", szDest, szSrc));
if (szDest == NULL)
{
va_start (va, szSrc);
szSrc_Ptr = szSrc;
dest_size = 1;
while (szSrc_Ptr)
{
dest_size += strlen (szSrc_Ptr);
szSrc_Ptr = va_arg (va, char *);
}
va_end (va);
szDest = (char *) hb_xgrab( dest_size );
}
va_start (va, szSrc);
szSrc_Ptr = szSrc;
szDest [0] = '\0';
while (szSrc_Ptr)
{
hb_xstrcat (szDest, szSrc_Ptr, NULL );
szSrc_Ptr = va_arg (va, char *);
}
va_end (va);
return (szDest);
}
static double hb_numPow10( int nPrecision )
{
static double s_dPow10[16] = { 1.0, /* 0 */
10.0, /* 1 */
100.0, /* 2 */
1000.0, /* 3 */
10000.0, /* 4 */
100000.0, /* 5 */
1000000.0, /* 6 */
10000000.0, /* 7 */
100000000.0, /* 8 */
1000000000.0, /* 9 */
10000000000.0, /* 10 */
100000000000.0, /* 11 */
1000000000000.0, /* 12 */
10000000000000.0, /* 13 */
100000000000000.0, /* 14 */
1000000000000000.0 }; /* 15 */
if ( nPrecision < 16 )
{
if ( nPrecision >= 0 )
{
return s_dPow10[ nPrecision ];
}
else if ( nPrecision > -16 )
{
return 1.0 / s_dPow10[ -nPrecision ];
}
}
return pow(10.0, (double) nPrecision);
}
HB_EXPORT double hb_numRound( double dNum, int iDec )
{
static const double doBase = 10.0f;
double doComplete5, doComplete5i, dPow;
HB_TRACE(HB_TR_DEBUG, ("hb_numRound(%lf, %d)", dNum, iDec));
if( dNum == 0.0 )
return 0.0;
if ( iDec < 0 )
{
dPow = hb_numPow10( -iDec );
doComplete5 = dNum / dPow * doBase;
}
else
{
dPow = hb_numPow10( iDec );
doComplete5 = dNum * dPow * doBase;
}
/*
* double precision if 15 digit the 16th one is usually wrong but
* can give some information about number,
* Clipper display 16 digit only others are set to 0
* many people don't know/understand FL arithmetic. They expect
* that it will behaves in the same way as real numbers. It's not
* true but in business application we can try to hide this problem
* for them. Usually they not need such big precision in presented
* numbers so we can decrease the precision to 15 digits and use
* the cut part for proper rounding. It should resolve
* most of problems. But if someone totally not understand FL
* and will try to convert big matrix or sth like that it's quite
* possible that he chose one of the natural school algorithm which
* works nice with real numbers but can give very bad results in FL.
* In such case it could be good to decrease precision even more.
* It not fixes the used algorithm of course but will make many users
* happy because they can see nice (proper) result.
* So maybe it will be good to add SET PRECISION TO <n> for them and
* use the similar hack in ==, >=, <=, <, > operations if it's set.
*/
/* #define HB_NUM_PRECISION 16 */
#ifdef HB_NUM_PRECISION
/*
* this is a hack for people who cannot live without hacked FL values
* in rounding
*/
{
int iDecR, iPrec;
BOOL fNeg;
if ( dNum < 0 )
{
fNeg = TRUE;
dNum = -dNum;
}
else
{
fNeg = FALSE;
}
iDecR = (int) log10( dNum );
iPrec = iDecR + iDec;
if ( iPrec < -1 )
{
return 0.0;
}
else
{
if ( iPrec > HB_NUM_PRECISION )
{
iDec = HB_NUM_PRECISION - ( dNum < 1.0 ? 0 : 1 ) - iDecR;
iPrec = -1;
}
else
{
iPrec -= HB_NUM_PRECISION;
}
}
if ( iDec < 0 )
{
dPow = hb_numPow10( -iDec );
doComplete5 = dNum / dPow * doBase + 5.0 + hb_numPow10( iPrec );
}
else
{
dPow = hb_numPow10( iDec );
doComplete5 = dNum * dPow * doBase + 5.0 + hb_numPow10( iPrec );
}
if ( fNeg )
{
doComplete5 = -doComplete5;
}
}
#else
if( dNum < 0.0f )
doComplete5 -= 5.0f;
else
doComplete5 += 5.0f;
#endif
doComplete5 /= doBase;
#if defined( HB_DBLFL_PREC_FACTOR ) && !defined( HB_C52_STRICT )
/* similar operation is done by Cl5.3
it's a hack to force rounding FL values UP */
doComplete5 *= HB_DBLFL_PREC_FACTOR;
#endif
modf( doComplete5, &doComplete5i );
#if defined( __XCC__ ) || defined( __POCC__ )
if ( iDec < 16 )
{
if ( iDec >= 0 )
return doComplete5i / (LONGLONG) dPow;
else if ( iDec > -16 )
return doComplete5i * (LONGLONG) dPow;
}
#endif
if ( iDec < 0 )
return doComplete5i * dPow;
else
return doComplete5i / dPow;
}
HB_EXPORT double hb_numInt( double dNum )
{
double dInt;
#if defined( HB_DBLFL_PREC_FACTOR ) && !defined( HB_C52_STRICT )
/* Similar hack as in round to make this functions compatible */
dNum *= HB_DBLFL_PREC_FACTOR;
#endif
modf( dNum, &dInt );
return dInt;
}
static BOOL hb_str2number( BOOL fPCode, const char* szNum, ULONG ulLen, HB_LONG * lVal, double * dVal, int * piDec, int * piWidth )
{
BOOL fDbl = FALSE, fDec = FALSE, fNeg, fHex = FALSE;
ULONG ulPos = 0;
int c, iWidth, iDec = 0, iDecR = 0;
HB_TRACE(HB_TR_DEBUG, ("hb_str2number(%d, %p, %lu, %p, %p, %p, %p)", (int) fPCode, szNum, ulLen, lVal, dVal, piDec, piWidth ));
while ( ulPos < ulLen && isspace( (BYTE) szNum[ulPos] ) )
ulPos++;
if ( ulPos >= ulLen )
{
fNeg = FALSE;
}
else if ( szNum[ulPos] == '-' )
{
fNeg = TRUE;
ulPos++;
}
else
{
fNeg = FALSE;
if ( szNum[ulPos] == '+' )
ulPos++;
}
*lVal = 0;
/* Hex Number */
if( fPCode && ulPos + 1 < ulLen && szNum[ulPos] == '0' &&
( szNum[ulPos+1] == 'X' || szNum[ulPos+1] == 'x' ) )
{
ulPos += 2;
iWidth = HB_DEFAULT_WIDTH;
fHex = TRUE;
for ( ; ulPos < ulLen; ulPos++ )
{
c = szNum[ulPos];
if ( c >= '0' && c <= '9' )
c -= '0';
else if ( c >= 'A' && c <= 'F' )
c -= 'A' - 10;
else if ( c >= 'a' && c <= 'f' )
c -= 'a' - 10;
else
break;
*lVal = ( *lVal << 4 ) + c;
}
}
else
{
HB_LONG lLimV;
int iLimC;
lLimV = HB_LONG_MAX / 10;
iLimC = HB_LONG_MAX % 10;
iWidth = ulPos;
for ( ; ulPos < ulLen; ulPos++ )
{
c = szNum[ulPos];
if ( c >= '0' && c <= '9' )
{
if ( fDbl )
{
*dVal = *dVal * 10.0 + ( c - '0' );
}
else if ( *lVal < lLimV || ( *lVal <= lLimV && ( c - '0' ) <= iLimC ) )
{
*lVal = *lVal * 10 + ( c - '0' );
}
else
{
*dVal = (double) *lVal * 10.0 + ( c - '0' );
fDbl = TRUE;
}
if ( fDec )
iDec++;
else
iWidth++;
}
else if ( c == '.' && !fDec )
{
fDec = TRUE;
}
else
{
while ( !fDec && ulPos < ulLen )
{
if ( szNum[ulPos++] == '.' )
fDec = TRUE;
else
iWidth++;
}
if ( fDec )
iDecR = ulLen - ulPos;
break;
}
}
}
if ( fNeg )
{
if ( fDbl )
*dVal = -*dVal;
else
*lVal = -*lVal;
}
if ( !fDbl && (
#if defined( PCODE_LONG_LIM )
( fPCode && !fHex && !PCODE_LONG_LIM( *lVal ) ) ||
#endif
fDec ) )
{
*dVal = (double) *lVal;
fDbl = TRUE;
}
if ( iDec )
{
#if defined( __XCC__ ) || defined( __POCC__ )
if ( iDec < 16 )
*dVal /= ( LONGLONG ) hb_numPow10( iDec );
else
#endif
*dVal /= hb_numPow10( iDec );
}
if ( piDec )
*piDec = iDec + iDecR;
if ( piWidth )
{
if ( fHex )
*piWidth = iWidth;
else
{
int iSize = fDbl ? HB_DBL_LENGTH( *dVal ) : HB_LONG_LENGTH( *lVal );
if ( fPCode )
{
if ( iWidth < 10 || fNeg )
*piWidth = iSize;
else
*piWidth = iWidth + ( iDec == 0 ? 1 : 0 );
}
else
{
if ( iSize > 10 || iWidth > 10 )
*piWidth = iSize;
else if ( iDec + iDecR == 0 )
*piWidth = ( int ) ulLen;
else if ( iWidth == 0 )
*piWidth = 1;
else if ( fNeg && iWidth == 1 && *dVal != 0 )
*piWidth = 2;
else
*piWidth = iWidth;
}
}
}
return fDbl;
}
HB_EXPORT BOOL hb_compStrToNum( const char* szNum, HB_LONG * plVal, double * pdVal, int * piDec, int * piWidth )
{
HB_TRACE(HB_TR_DEBUG, ("hb_compStrToNum( %s, %p, %p, %p, %p)", szNum, plVal, pdVal, piDec, piWidth ));
return hb_str2number( TRUE, szNum, strlen( szNum ), plVal, pdVal, piDec, piWidth );
}
HB_EXPORT BOOL hb_valStrnToNum( const char* szNum, ULONG ulLen, HB_LONG * plVal, double * pdVal, int * piDec, int * piWidth )
{
HB_TRACE(HB_TR_DEBUG, ("hb_valStrToNum( %s, %lu, %p, %p, %p, %p)", szNum, ulLen, plVal, pdVal, piDec, piWidth ));
return hb_str2number( FALSE, szNum, ulLen, plVal, pdVal, piDec, piWidth );
}
HB_EXPORT BOOL hb_strToNum( const char* szNum, HB_LONG * plVal, double * pdVal )
{
HB_TRACE(HB_TR_DEBUG, ("hb_strToNum(%s, %p, %p)", szNum, plVal, pdVal ));
return hb_str2number( FALSE, szNum, strlen( szNum ), plVal, pdVal, NULL, NULL );
}
HB_EXPORT BOOL hb_strnToNum( const char* szNum, ULONG ulLen, HB_LONG * plVal, double * pdVal )
{
HB_TRACE(HB_TR_DEBUG, ("hb_strToNum(%s, %lu, %p, %p)", szNum, ulLen, plVal, pdVal ));
return hb_str2number( FALSE, szNum, ulLen, plVal, pdVal, NULL, NULL );
}
/* returns the numeric value of a character string representation of a number */
HB_EXPORT double hb_strVal( const char * szText, ULONG ulLen )
{
HB_LONG lVal;
double dVal;
HB_TRACE(HB_TR_DEBUG, ("hb_strVal(%s, %lu)", szText, ulLen));
if ( ! hb_str2number( FALSE, szText, ulLen, &lVal, &dVal, NULL, NULL ) )
dVal = ( double ) lVal;
return dVal;
}
HB_EXPORT HB_LONG hb_strValInt( const char * szText, int * iOverflow )
{
HB_LONG lVal;
double dVal;
HB_TRACE(HB_TR_DEBUG, ("hb_strValInt(%s)", szText));
if ( hb_str2number( FALSE, szText, strlen( szText ), &lVal, &dVal, NULL, NULL ) )
{
*iOverflow = 1;
return 0;
}
*iOverflow = 0;
return lVal;
}
/*
* This function copies szText to destination buffer.
* NOTE: Unlike the documentation for strncpy, this routine will always append
* a null
*/
HB_EXPORT char * hb_strncpy( char * pDest, const char * pSource, ULONG ulLen )
{
char *pBuf = pDest;
HB_TRACE(HB_TR_DEBUG, ("hb_strncpy(%p, %s, %lu)", pDest, pSource, ulLen));
pDest[ ulLen ] ='\0';
while( ulLen && ( *pDest++ = *pSource++ ) != '\0' )
{
ulLen--;
}
while (ulLen--)
{
*pDest++ = '\0';
}
return pBuf;
}
/*
* This function copies szText to destination buffer.
* NOTE: Unlike the documentation for strncat, this routine will always append
* a null and the ulLen param is pDest size not pSource limit
*/
HB_EXPORT char * hb_strncat( char * pDest, const char * pSource, ULONG ulLen )
{
char *pBuf = pDest;
HB_TRACE(HB_TR_DEBUG, ("hb_strncpy(%p, %s, %lu)", pDest, pSource, ulLen));
pDest[ ulLen ] ='\0';
while( ulLen && *pDest )
{
pDest++;
ulLen--;
}
while( ulLen && ( *pDest++ = *pSource++ ) != '\0' )
{
ulLen--;
}
/* if someone will need this then please uncomment the cleaning the rest of
buffer. */
/*
while (ulLen--)
{
*pDest++ = '\0';
}
*/
return pBuf;
}
/* This function copies and converts szText to upper case.
*/
/*
* NOTE: Unlike the documentation for strncpy, this routine will always append
* a null
* pt
*/
HB_EXPORT char * hb_strncpyUpper( char * pDest, const char * pSource, ULONG ulLen )
{
char *pBuf = pDest;
HB_TRACE(HB_TR_DEBUG, ("hb_strncpyUpper(%p, %s, %lu)", pDest, pSource, ulLen));
pDest[ ulLen ] ='\0';
/* some compilers impliment toupper as a macro, and this has side effects! */
/* *pDest++ = toupper( *pSource++ ); */
while( ulLen && (*pDest++ = toupper( *pSource )) != '\0' )
{
ulLen--;
pSource++;
}
while (ulLen--)
{
*pDest++ = '\0';
}
return pBuf;
}
/* This function copies and converts szText to upper case AND Trims it
*/
/*
* NOTE: Unlike the documentation for strncpy, this routine will always append
* a null
* pt
*/
HB_EXPORT char * hb_strncpyUpperTrim( char * pDest, const char * pSource, ULONG ulLen )
{
char *pBuf = pDest;
ULONG ulSLen;
HB_TRACE(HB_TR_DEBUG, ("hb_strncpyUpperTrim(%p, %s, %lu)", pDest, pSource, ulLen));
ulSLen = 0;
while ( ulSLen < ulLen && pSource[ ulSLen ] )
{
ulSLen++;
}
while( ulSLen && pSource[ ulSLen - 1 ] == ' ')
{
ulSLen--;
}
pDest[ ulLen ] = '\0';
/* some compilers impliment toupper as a macro, and this has side effects! */
/* *pDest++ = toupper( *pSource++ ); */
while( ulLen && ulSLen && (*pDest++ = toupper( *pSource )) != '\0' )
{
ulSLen--;
ulLen--;
pSource++;
}
while (ulLen--)
{
*pDest++ = '\0';
}
return pBuf;
}
/*
* This function copies trimed szText to destination buffer.
* NOTE: Unlike the documentation for strncpy, this routine will always append
* a null
*/
HB_EXPORT char * hb_strncpyTrim( char * pDest, const char * pSource, ULONG ulLen )
{
char *pBuf = pDest;
ULONG ulSLen;
HB_TRACE(HB_TR_DEBUG, ("hb_strncpyTrim(%p, %s, %lu)", pDest, pSource, ulLen));
ulSLen = 0;
while( ulSLen < ulLen && pSource[ ulSLen ] )
{
ulSLen++;
}
while( ulSLen && pSource[ ulSLen - 1 ] == ' ' )
{
ulSLen--;
}
pDest[ ulLen ] ='\0';
/* some compilers impliment toupper as a macro, and this has side effects! */
/* *pDest++ = toupper( *pSource++ ); */
while( ulLen && ulSLen && ( *pDest++ = *pSource++ ) != '\0' )
{
ulSLen--;
ulLen--;
}
while (ulLen--)
{
*pDest++ = '\0';
}
return pBuf;
}
char * hb_strRemEscSeq( char *str, ULONG *pLen )
{
char *ptr = str;
while( *ptr )
{
if( *ptr == '\\' )
{
switch( *(ptr+1) )
{
case '\\':
{
memmove( ptr, ptr+1, *pLen - (ptr - str) );
(*pLen)--;
break;
}
case 'r':
{
memmove( ptr, ptr+1, *pLen - (ptr - str) );
*ptr = '\r';
(*pLen)--;
break;
}
case 'n':
{
memmove( ptr, ptr+1, *pLen - (ptr - str) );
*ptr = '\n';
(*pLen)--;
break;
}
case 't':
{
memmove( ptr, ptr+1, *pLen - (ptr - str) );
*ptr = '\t';
(*pLen)--;
break;
}
case 'b':
{
memmove( ptr, ptr+1, *pLen - (ptr - str) );
*ptr = '\b';
(*pLen)--;
break;
}
default:
break;
}
}
ptr++;
}
return str;
}
Reference in New Issue View Git Blame Copy Permalink