fivedev/harbour-core
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
35ca6dae3337cd3abb6b8a69ae00d428cd34cbde
harbour-core/harbour/source/common/hbstr.c
Ryszard Glab 49d728084c 2006-03-09 16:30 UTC+0100 Ryszard Glab <rglab//imid.med.pl> 
* include/hbapi.h
  * include/hbexpra.c
  * include/hbexprb.c
  * include/hbexprop.h
    * modified to support strings with embeded LF/CR characters

  * source/common/hbstr.c
  * source/rtl/strings.c
    * added hb_strRemEscSeq() function that removes C-like Esc
      sequences (\n \t \r \b currently)

  * source/compiler/cmdcheck.c
    * added new command line switch
      -r=<max_recursive_preprocessor_passes>
      with defaults equal to -r=1024

  * include/hbpp.h
  * source/compiler/harbour.l
  * source/compiler/harbour.y
  * source/macro/macro.y
  * source/pp/ppcomp.c
  * source/pp/ppcore.c
  * source/pp/pplib.c
  * source/pp/pptable.c
  * source/pp/pragma.c
    * fixed compilation of #command ( => (,7
      (loops in #define or #command are trapped now)
    * fixed compilation of \[ and \] in command/translate
    * modified TEXT/ENDTEXT to use '#pragma __text'
    + added #pragma __stream and #pragma __cstream
      (examples later)
2006-03-09 15:22:16 +00:00

978 lines
24 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;
}
/*
Simple routine to extract uncommented part of (read) buffer
*/
HB_EXPORT char *hb_stripOutComments( char* buffer )
{
if( buffer && *buffer )
{
USHORT ui = strlen( buffer );
char *szOut = (char*) hb_xgrab( ui + 1 );
int i;
int uu = 0;
char *last;
hb_xmemset( szOut, 0, ui + 1 );
for ( i = 0; i < ui; i ++ )
{
if ( buffer[ i ] == '/' )
{
if( buffer [ i + 1 ] == '*' )
{
i ++;
while ( ++ i < ui )
{
if ( buffer [ i ] == '*' && buffer [ i + 1 ] == '/' )
{
i += 2;
break;
}
}
}
else if ( buffer[ i + 1 ] == '/' )
{
while ( ++ i < ui )
{
if ( buffer [ i ] == '\n' || buffer [ i ] == '\r' )
{
break;
}
}
}
}
szOut[ uu ++ ] = buffer[ i ];
}
/* trim left */
while ( HB_ISSPACE( *szOut ) )
{
strcpy( szOut, szOut + 1 );
}
/* trim right */
last = szOut + strlen ( szOut );
while ( last > szOut )
{
if ( !HB_ISSPACE( *( last - 1 ) ) )
{
break;
}
last--;
}
*last = 0;
return( szOut );
}
else
{
return ( NULL );
}
}
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