fivedev/harbour-core
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

2012-07-18 18:15 UTC+0200 Viktor Szakats (harbour syenar.net)

Browse Source 
* contrib/hbgt/tests/test.prg
    * formatting (manual)

  * contrib/hbct/bitnum.c
  * contrib/hbct/charmirr.c
  * contrib/hbct/charonly.c
  * contrib/hbct/charsort.c
  * contrib/hbct/ctpad.c
  * contrib/hbct/ctstr.c
  * contrib/hbct/envparam.c
  * contrib/hbct/expand.c
  * contrib/hbct/files.c
  * contrib/hbct/justify.c
  * contrib/hbct/misc2.c
  * contrib/hbct/numat.c
  * contrib/hbct/pos1.c
  * contrib/hbct/posdiff.c
  * contrib/hbct/relation.c
  * contrib/hbct/replace.c
  * contrib/hbct/strswap.c
  * contrib/hbct/token1.c
  * contrib/hbct/token2.c
    * minor whitespace formatting

  * contrib/hbgt/ascposgt.c
  * contrib/hbgt/atdiff.c
  * contrib/hbgt/bitflags.c
  * contrib/hbgt/chareven.c
  * contrib/hbgt/charmixg.c
  * contrib/hbgt/charodd.c
  * contrib/hbgt/chrcount.c
  * contrib/hbgt/chrfirst.c
  * contrib/hbgt/chrtotal.c
  * contrib/hbgt/strasint.c
  * contrib/hbgt/strcount.c
  * contrib/hbgt/strcspn.c
  * contrib/hbgt/strdiffg.c
  * contrib/hbgt/strexpan.c
  * contrib/hbgt/strleft.c
  * contrib/hbgt/strpbrk.c
  * contrib/hbgt/strright.c
    * reformatted using uncrustify
This commit is contained in:
Viktor Szakats
2012-07-18 16:19:27 +00:00
parent 5428d17e70
commit 0407f7eccb
38 changed files with 597 additions and 494 deletions
Download Patch File Download Diff File Expand all files Collapse all files

44
harbour/ChangeLog
View File

@@ -16,6 +16,50 @@
The license applies to all entries newer than 2009-04-28.
*/
2012-07-18 18:15 UTC+0200 Viktor Szakats (harbour syenar.net)
* contrib/hbgt/tests/test.prg
* formatting (manual)
* contrib/hbct/bitnum.c
* contrib/hbct/charmirr.c
* contrib/hbct/charonly.c
* contrib/hbct/charsort.c
* contrib/hbct/ctpad.c
* contrib/hbct/ctstr.c
* contrib/hbct/envparam.c
* contrib/hbct/expand.c
* contrib/hbct/files.c
* contrib/hbct/justify.c
* contrib/hbct/misc2.c
* contrib/hbct/numat.c
* contrib/hbct/pos1.c
* contrib/hbct/posdiff.c
* contrib/hbct/relation.c
* contrib/hbct/replace.c
* contrib/hbct/strswap.c
* contrib/hbct/token1.c
* contrib/hbct/token2.c
* minor whitespace formatting
* contrib/hbgt/ascposgt.c
* contrib/hbgt/atdiff.c
* contrib/hbgt/bitflags.c
* contrib/hbgt/chareven.c
* contrib/hbgt/charmixg.c
* contrib/hbgt/charodd.c
* contrib/hbgt/chrcount.c
* contrib/hbgt/chrfirst.c
* contrib/hbgt/chrtotal.c
* contrib/hbgt/strasint.c
* contrib/hbgt/strcount.c
* contrib/hbgt/strcspn.c
* contrib/hbgt/strdiffg.c
* contrib/hbgt/strexpan.c
* contrib/hbgt/strleft.c
* contrib/hbgt/strpbrk.c
* contrib/hbgt/strright.c
* reformatted using uncrustify
2012-07-18 16:25 UTC+0200 Viktor Szakats (harbour syenar.net)
* tests/clsnv.prg
* tests/cursrtst.prg

2
harbour/contrib/hbct/bitnum.c
View File

@@ -58,7 +58,7 @@
HB_BOOL ct_numParam( int iParam, HB_MAXINT * plNum )
{
const char *szHex = hb_parc( iParam );
const char * szHex = hb_parc( iParam );
if( szHex )
{

4
harbour/contrib/hbct/charmirr.c
View File

@@ -65,9 +65,9 @@ HB_FUNC( CHARMIRR )
if( HB_ISCHAR( 1 ) )
{
const char * pcString = hb_parc( 1 ), *pc1;
const char * pcString = hb_parc( 1 ), * pc1;
HB_SIZE sStrLen = hb_parclen( 1 );
char * pcRet, *pc2;
char * pcRet, * pc2;
int iDontMirrorSpaces;
if( HB_ISLOG( 2 ) )

2
harbour/contrib/hbct/charonly.c
View File

@@ -77,7 +77,7 @@ static void do_charonly( int iSwitch )
char * pcRet;
HB_SIZE sRetStrLen = 0;
int iShift, iBool;
const char * pcSub, *pc;
const char * pcSub, * pc;
/* check for zero-length strings */
switch ( iSwitch )

4
harbour/contrib/hbct/charsort.c
View File

@@ -64,7 +64,7 @@ int extern _LNK_CONV
#else
static int
#endif
_hb_do_sortascend( const void *p1, const void *p2 )
_hb_do_sortascend( const void * p1, const void * p2 )
{
const char * pc1 = ( const char * ) p1;
const char * pc2 = ( const char * ) p2;
@@ -80,7 +80,7 @@ int extern _LNK_CONV
#else
static int
#endif
_hb_do_sortdescend( const void *p1, const void *p2 )
_hb_do_sortdescend( const void * p1, const void * p2 )
{
const char * pc1 = ( const char * ) p1;
const char * pc2 = ( const char * ) p2;

2
harbour/contrib/hbct/ctpad.c
View File

@@ -65,7 +65,7 @@ static void do_pad( int iSwitch )
{
const char * pcString = hb_parc( 1 );
HB_SIZE sStrLen = hb_parclen( 1 );
char * pcRet, *pc;
char * pcRet, * pc;
HB_ISIZ nRetLen;
HB_SIZE sRetLen;
char cFill;

28
harbour/contrib/hbct/ctstr.c
View File

@@ -72,8 +72,8 @@ int ct_str_exit( void )
/* -------------------------- */
/* search for exact substring */
/* -------------------------- */
const char *ct_at_exact_forward( const char * pcString, HB_SIZE sStrLen,
const char * pcMatch, HB_SIZE sMatchLen, HB_SIZE * psMatchStrLen )
const char * ct_at_exact_forward( const char * pcString, HB_SIZE sStrLen,
const char * pcMatch, HB_SIZE sMatchLen, HB_SIZE * psMatchStrLen )
{
HB_SIZE sPos;
@@ -101,8 +101,8 @@ const char *ct_at_exact_forward( const char * pcString, HB_SIZE sStrLen,
/* ------------------------------------------------ */
/* search for exact substring in backward direction */
/* ------------------------------------------------ */
const char *ct_at_exact_backward( const char * pcString, HB_SIZE sStrLen,
const char * pcMatch, HB_SIZE sMatchLen, HB_SIZE * psMatchStrLen )
const char * ct_at_exact_backward( const char * pcString, HB_SIZE sStrLen,
const char * pcMatch, HB_SIZE sMatchLen, HB_SIZE * psMatchStrLen )
{
HB_SIZE sIndex;
@@ -134,9 +134,9 @@ const char *ct_at_exact_backward( const char * pcString, HB_SIZE sStrLen,
/* ----------------------------------- */
/* search for substring using wildcard */
/* ----------------------------------- */
const char *ct_at_wildcard_forward( const char * pcString, HB_SIZE sStrLen,
const char * pcMatch, HB_SIZE sMatchLen,
char cWildCard, HB_SIZE * psMatchStrLen )
const char * ct_at_wildcard_forward( const char * pcString, HB_SIZE sStrLen,
const char * pcMatch, HB_SIZE sMatchLen,
char cWildCard, HB_SIZE * psMatchStrLen )
{
HB_SIZE sIndex;
@@ -172,9 +172,9 @@ const char *ct_at_wildcard_forward( const char * pcString, HB_SIZE sStrLen,
/* --------------------------------------------------------- */
/* search for substring using wildcard in backward direction */
/* --------------------------------------------------------- */
const char *ct_at_wildcard_backward( const char * pcString, HB_SIZE sStrLen,
const char * pcMatch, HB_SIZE sMatchLen,
char cWildCard, HB_SIZE * psMatchStrLen )
const char * ct_at_wildcard_backward( const char * pcString, HB_SIZE sStrLen,
const char * pcMatch, HB_SIZE sMatchLen,
char cWildCard, HB_SIZE * psMatchStrLen )
{
HB_SIZE sIndex;
@@ -210,8 +210,8 @@ const char *ct_at_wildcard_backward( const char * pcString, HB_SIZE sStrLen,
/* ------------------------------- */
/* search for character from a set */
/* ------------------------------- */
const char *ct_at_charset_forward( const char * pcString, HB_SIZE sStrLen,
const char * pcCharSet, HB_SIZE sCharSetLen, HB_SIZE * psMatchedCharPos )
const char * ct_at_charset_forward( const char * pcString, HB_SIZE sStrLen,
const char * pcCharSet, HB_SIZE sCharSetLen, HB_SIZE * psMatchedCharPos )
{
const char * pcRet, * pcSet, * pcStop1, * pcStop2;
@@ -243,8 +243,8 @@ const char *ct_at_charset_forward( const char * pcString, HB_SIZE sStrLen,
/* ----------------------------------------------------- */
/* search for character from a set in backward direction */
/* ----------------------------------------------------- */
const char *ct_at_charset_backward( const char * pcString, HB_SIZE sStrLen,
const char * pcCharSet, HB_SIZE sCharSetLen, HB_SIZE * psMatchedCharPos )
const char * ct_at_charset_backward( const char * pcString, HB_SIZE sStrLen,
const char * pcCharSet, HB_SIZE sCharSetLen, HB_SIZE * psMatchedCharPos )
{
const char * pcRet, * pcSet, * pcStop;

8
harbour/contrib/hbct/envparam.c
View File

@@ -59,18 +59,18 @@
# include <crt_externs.h>
# define environ (*_NSGetEnviron())
# elif !defined( __WATCOMC__ )
extern char **environ;
extern char ** environ;
# endif
#elif defined( HB_OS_DOS )
# if defined( __DJGPP__ )
extern char **environ;
extern char ** environ;
# elif !defined( __WATCOMC__ )
# define environ _environ
extern char **_environ;
extern char ** _environ;
# endif
#elif defined( HB_OS_OS2 )
# if !defined( __WATCOMC__ )
extern char **environ;
extern char ** environ;
# endif
#elif defined( HB_OS_WIN ) && ! defined( HB_OS_WIN_CE )
# include "hbwinuni.h"

2
harbour/contrib/hbct/expand.c
View File

@@ -64,7 +64,7 @@ HB_FUNC( EXPAND )
hb_retclen( szText, 1 );
else
{
char * szDest, *szPtr, cRepl;
char * szDest, * szPtr, cRepl;
int iRepl, i;
iRepl = hb_parni( 2 );

2
harbour/contrib/hbct/files.c
View File

@@ -199,7 +199,7 @@ HB_FUNC( SETFATTR )
HB_FUNC( SETFDATI )
{
const char *szFile = hb_parc( 1 );
const char * szFile = hb_parc( 1 );
HB_BOOL fResult = HB_FALSE;
if( szFile && *szFile )

3
harbour/contrib/hbct/justify.c
View File

@@ -68,12 +68,11 @@ static void do_justify( int iSwitch )
if( HB_ISCHAR( 1 ) )
{
const char * pcString = hb_parc( 1 );
HB_SIZE sStrLen = hb_parclen( 1 );
char cJustChar;
const char * pc;
char * pcRet, *pcw;
char * pcRet, * pcw;
HB_SIZE sJustOffset;
if( sStrLen == 0 )

4
harbour/contrib/hbct/misc2.c
View File

@@ -65,8 +65,8 @@ HB_FUNC( COMPLEMENT )
if( nLen > 0 )
{
const char *szSrc = hb_itemGetCPtr( pItem );
char *szBuffer = ( char * ) hb_xgrab( nLen + 1 );
const char * szSrc = hb_itemGetCPtr( pItem );
char * szBuffer = ( char * ) hb_xgrab( nLen + 1 );
for( ulPos = 0; ulPos < nLen; ulPos++ )
szBuffer[ ulPos ] = ~szSrc[ ulPos ];

2
harbour/contrib/hbct/numat.c
View File

@@ -67,7 +67,7 @@ HB_FUNC( NUMAT )
char cAtLike = ct_getatlikechar();
HB_SIZE sIgnore, sMatchStrLen = 0, sSubStrLen;
HB_SIZE nCounter;
const char * pc, *pcSubStr;
const char * pc, * pcSubStr;
/* eventually ignore some characters */
if( HB_ISNUM( 3 ) )

2
harbour/contrib/hbct/pos1.c
View File

@@ -72,7 +72,7 @@ static void do_pos1( int iSwitch )
HB_ISCHAR( 2 ) && /* .. string as 2nd .. */
HB_ISCHAR( 3 ) ) ) ) /* .. and 3rd param */
{
const unsigned char * pcString, *puc;
const unsigned char * pcString, * puc;
HB_SIZE sStrLen;
unsigned char ucChar1 = ' ', ucChar2 = ' ';
int iMode;

4
harbour/contrib/hbct/posdiff.c
View File

@@ -62,7 +62,7 @@ HB_FUNC( POSDIFF )
HB_SIZE sStrLen1 = hb_parclen( 1 );
const char * pcString2 = hb_parc( 2 );
HB_SIZE sStrLen2 = hb_parclen( 2 );
const char * pc1, *pc2;
const char * pc1, * pc2;
HB_SIZE sIgnore;
if( HB_ISNUM( 3 ) )
@@ -131,7 +131,7 @@ HB_FUNC( POSEQUAL )
HB_SIZE sStrLen1 = hb_parclen( 1 );
const char * pcString2 = hb_parc( 2 );
HB_SIZE sStrLen2 = hb_parclen( 2 );
const char * pc1, *pc2;
const char * pc1, * pc2;
HB_SIZE sIgnore, sCompare, sCompareCnt, sRet = 0;
if( HB_ISNUM( 4 ) )

4
harbour/contrib/hbct/relation.c
View File

@@ -67,7 +67,7 @@ HB_FUNC( CHARRELA )
const char * pcString2 = hb_parc( 4 );
HB_SIZE sStrLen2 = hb_parclen( 4 );
const char * pc1, *pc2;
const char * pc1, * pc2;
HB_SIZE sOffset1, sOffset2;
HB_SIZE sMatchStrLen;
@@ -153,7 +153,7 @@ HB_FUNC( CHARRELREP )
const char * pcReplace = hb_parc( 5 );
HB_SIZE sReplaceLen = hb_parclen( 5 );
char * pcRet;
const char * pc1, *pc2;
const char * pc1, * pc2;
HB_SIZE sOffset1, sOffset2;
HB_SIZE sMatchStrLen;

2
harbour/contrib/hbct/replace.c
View File

@@ -77,7 +77,7 @@ static void do_replace( int iSwitch )
{
const char * pcString = hb_parc( 1 );
HB_SIZE sStrLen = hb_parclen( 1 );
char * pcRet, *pc;
char * pcRet, * pc;
char cSearch, cReplace;
if( sStrLen == 0 )

2
harbour/contrib/hbct/strswap.c
View File

@@ -65,7 +65,7 @@ HB_FUNC( STRSWAP )
/* get parameters */
const char * pcString1 = hb_parc( 1 );
const char * pcString2 = hb_parc( 2 );
char * pcRet1 = NULL, *pcRet2 = NULL;
char * pcRet1 = NULL, * pcRet2 = NULL;
int iChange1, iChange2;
HB_SIZE sIndex, sCmpLen;

2
harbour/contrib/hbct/token1.c
View File

@@ -61,7 +61,7 @@
#include "ct.h"
/* static const data */
static const char *s_pcSeparatorStr =
static const char * s_pcSeparatorStr =
"\x00" "\x09" "\x0A" "\x0C" "\x1A" "\x20" "\x8A" "\x8C" ",.;:!\?/\\<>()#&%+-*";
static const HB_SIZE s_sSeparatorStrLen = 26;

12
harbour/contrib/hbct/token2.c
View File

@@ -75,7 +75,7 @@ typedef struct _TOKEN_POSITION
HB_SIZE sEndPos; /* relative 0-based index of first char BEHIND token,
so that length = sEndPos-sStartPos */
} TOKEN_POSITION;
typedef TOKEN_POSITION *TOKEN_ENVIRONMENT;
typedef TOKEN_POSITION * TOKEN_ENVIRONMENT;
/* -------------------------------------------------------------------- */
/* alloc new token environment */
@@ -147,7 +147,7 @@ static HB_SIZE sTokEnvGetSize( TOKEN_ENVIRONMENT env )
/* get position element pointed to by tokenizing pointer */
/* -------------------------------------------------------------------- */
static TOKEN_POSITION *sTokEnvGetPos( TOKEN_ENVIRONMENT env )
static TOKEN_POSITION * sTokEnvGetPos( TOKEN_ENVIRONMENT env )
{
if( env[ 1 ].sStartPos >= env[ 0 ].sStartPos )
return NULL;
@@ -159,7 +159,7 @@ static TOKEN_POSITION *sTokEnvGetPos( TOKEN_ENVIRONMENT env )
/* get position element pointed to by given 0-based index */
/* -------------------------------------------------------------------- */
static TOKEN_POSITION *sTokEnvGetPosIndex( TOKEN_ENVIRONMENT env, HB_SIZE index )
static TOKEN_POSITION * sTokEnvGetPosIndex( TOKEN_ENVIRONMENT env, HB_SIZE index )
{
if( index >= env[ 0 ].sStartPos )
return NULL;
@@ -245,7 +245,7 @@ static void sTokEnvDel( TOKEN_ENVIRONMENT env )
/* ==================================================================== */
/* static data */
static const char *spcSeparatorStr =
static const char * spcSeparatorStr =
"\x00" "\x09" "\x0A" "\x0C" "\x1A" "\x20" "\x8A" "\x8C" ",.;:!\?/\\<>()#&%+-*";
static const HB_SIZE ssSeparatorStrLen = 26;
@@ -287,7 +287,7 @@ HB_FUNC( TOKENINIT )
const char * pcSeparatorStr;
HB_SIZE sSeparatorStrLen;
HB_SIZE nSkipCnt, nSkip;
const char * pcSubStr, *pc;
const char * pcSubStr, * pc;
HB_SIZE sSubStrLen;
TOKEN_ENVIRONMENT sTokenEnvironment;
TOKEN_POSITION sTokenPosition;
@@ -433,7 +433,7 @@ HB_FUNC( TOKENNEXT )
HB_SIZE sStrLen = hb_parclen( 1 );
TOKEN_ENVIRONMENT sTokenEnvironment;
TOKEN_POSITION *psTokenPosition;
TOKEN_POSITION * psTokenPosition;
/* token environment by parameter ... */
if( HB_ISCHAR( 3 ) && HB_ISBYREF( 3 ) )

33
harbour/contrib/hbgt/ascposgt.c
View File

@@ -21,21 +21,24 @@
HB_FUNC( GT_ASCPOS )
{
const char *s;
HB_SIZE p;
const char * s;
HB_SIZE p;
if (HB_ISCHAR(1) && HB_ISNUM(2)) {
s = hb_parc(1);
p = hb_parns(2);
p--; /* decrement p to adjust for c strings */
/* starting at position 0 */
if( HB_ISCHAR( 1 ) && HB_ISNUM( 2 ) )
{
s = hb_parc( 1 );
p = hb_parns( 2 );
p--; /* decrement p to adjust for c strings */
/* starting at position 0 */
if (p > hb_parclen(1)) /* oh oh p > length of passed string */
hb_retni(-2); /* error -2 */
else
hb_retni((int) s[p]); /* return ascii code of appropriate */
/* character in string */
} else {
hb_retni(-1); /* parameter mismatch - error -1 */
}
if( p > hb_parclen( 1 ) ) /* oh oh p > length of passed string */
hb_retni( -2 ); /* error -2 */
else
hb_retni( ( int ) s[ p ] ); /* return ascii code of appropriate */
/* character in string */
}
else
{
hb_retni( -1 ); /* parameter mismatch - error -1 */
}
}

43
harbour/contrib/hbgt/atdiff.c
View File

@@ -21,29 +21,32 @@
HB_FUNC( GT_ATDIFF )
{
const char *s1, *s2;
HB_ISIZ pos, len;
const char * s1, * s2;
HB_ISIZ pos, len;
if (HB_ISCHAR(1) && HB_ISCHAR(2)) {
s1 = hb_parc(1);
s2 = hb_parc(2);
len = hb_parclen(2);
if( HB_ISCHAR( 1 ) && HB_ISCHAR( 2 ) )
{
s1 = hb_parc( 1 );
s2 = hb_parc( 2 );
len = hb_parclen( 2 );
/*
loop through comparing both strings
/*
loop through comparing both strings
NOTE: pos starts at 1, so as to return a string index
for CLIPPER
*/
NOTE: pos starts at 1, so as to return a string index
for CLIPPER
*/
for (pos = 1; (pos <= len) && (*s1 == *s2); s2++, s1++)
pos++;
for( pos = 1; ( pos <= len ) && ( *s1 == *s2 ); s2++, s1++ )
pos++;
if (pos > len) /* strings match exactly!!! */
hb_retns(0);
else
hb_retns(pos);
} else {
hb_retns(-1); /* parameter mismatch - error -1 */
}
if( pos > len ) /* strings match exactly!!! */
hb_retns( 0 );
else
hb_retns( pos );
}
else
{
hb_retns( -1 ); /* parameter mismatch - error -1 */
}
}

258
harbour/contrib/hbgt/bitflags.c
View File

@@ -28,153 +28,153 @@
#include "hbapi.h"
#define _GT_MAX(x,y) (x > y ? x : y)
#define _GT_MAX( x, y ) ( x > y ? x : y )
HB_FUNC( GT_NEWFLAG )
{
char *FlagString;
unsigned ByteCount;
unsigned FlagCount = 1;
unsigned Byte;
char * FlagString;
unsigned ByteCount;
unsigned FlagCount = 1;
unsigned Byte;
if (ISNUM(1))
{
FlagCount = (unsigned) hb_parni(1);
}
if (FlagCount > 0)
{
ByteCount = (unsigned)((FlagCount / 8) + 1);
if (!(FlagCount % 8))
{
--ByteCount;
}
FlagString = hb_xgrab(ByteCount);
for (Byte = 0; Byte < ByteCount; Byte++)
{
FlagString[Byte] = 0;
}
hb_retclen(FlagString, ByteCount);
hb_xfree(FlagString);
}
else
{
hb_retc_null();
}
if( ISNUM( 1 ) )
{
FlagCount = ( unsigned ) hb_parni( 1 );
}
if( FlagCount > 0 )
{
ByteCount = ( unsigned ) ( ( FlagCount / 8 ) + 1 );
if( ! ( FlagCount % 8 ) )
{
--ByteCount;
}
FlagString = hb_xgrab( ByteCount );
for( Byte = 0; Byte < ByteCount; Byte++ )
{
FlagString[ Byte ] = 0;
}
hb_retclen( FlagString, ByteCount );
hb_xfree( FlagString );
}
else
{
hb_retc_null();
}
}
HB_FUNC( GT_SETFLAG )
{
char *FlagString;
unsigned StartBit = 1;
unsigned EndBit = 1;
unsigned BitCount;
unsigned BitPointer;
unsigned BytePointer;
char * FlagString;
unsigned StartBit = 1;
unsigned EndBit = 1;
unsigned BitCount;
unsigned BitPointer;
unsigned BytePointer;
if ( HB_ISCHAR(1) )
{
FlagString = hb_parc(1);
if ( HB_ISNUM(2) )
{
StartBit = hb_parni(2);
}
if ( HB_ISNUM(3) )
{
EndBit = hb_parni(3);
}
EndBit = _GT_MAX(StartBit, EndBit);
if (StartBit > 0 && EndBit <= (hb_parclen(1) * 8))
{
for (BitCount = StartBit; BitCount <= EndBit; BitCount++)
{
BitPointer = BitCount % 8;
BytePointer = (unsigned) (BitCount / 8);
if (!BitPointer)
{
BitPointer = 8;
--BytePointer;
}
FlagString[BytePointer] |= 1 << (BitPointer - 1);
}
}
hb_retclen(FlagString, hb_parclen(1));
}
else
{
hb_retc_null();
}
if( HB_ISCHAR( 1 ) )
{
FlagString = hb_parc( 1 );
if( HB_ISNUM( 2 ) )
{
StartBit = hb_parni( 2 );
}
if( HB_ISNUM( 3 ) )
{
EndBit = hb_parni( 3 );
}
EndBit = _GT_MAX( StartBit, EndBit );
if( StartBit > 0 && EndBit <= ( hb_parclen( 1 ) * 8 ) )
{
for( BitCount = StartBit; BitCount <= EndBit; BitCount++ )
{
BitPointer = BitCount % 8;
BytePointer = ( unsigned ) ( BitCount / 8 );
if( ! BitPointer )
{
BitPointer = 8;
--BytePointer;
}
FlagString[ BytePointer ] |= 1 << ( BitPointer - 1 );
}
}
hb_retclen( FlagString, hb_parclen( 1 ) );
}
else
{
hb_retc_null();
}
}
HB_FUNC( GT_CLRFLAG )
{
char *FlagString;
unsigned StartBit = 1;
unsigned EndBit = 1;
unsigned BitCount;
unsigned BitPointer;
unsigned BytePointer;
char * FlagString;
unsigned StartBit = 1;
unsigned EndBit = 1;
unsigned BitCount;
unsigned BitPointer;
unsigned BytePointer;
if ( HB_ISCHAR(1) )
{
FlagString = hb_parc(1);
if ( HB_ISNUM(2) )
{
StartBit = hb_parni(2);
}
if ( HB_ISNUM(3) )
{
EndBit = hb_parni(3);
}
EndBit = _GT_MAX(StartBit, EndBit);
if (StartBit > 0 && EndBit <= (hb_parclen(1) * 8))
{
for (BitCount = StartBit; BitCount <= EndBit; BitCount++)
{
BitPointer = BitCount % 8;
BytePointer = (unsigned) (BitCount / 8);
if (!BitPointer)
{
BitPointer = 8;
--BytePointer;
}
FlagString[BytePointer] &= 0xff - (1 << (BitPointer - 1));
}
}
hb_retclen(FlagString, hb_parclen(1));
}
else
{
hb_retc_null();
}
if( HB_ISCHAR( 1 ) )
{
FlagString = hb_parc( 1 );
if( HB_ISNUM( 2 ) )
{
StartBit = hb_parni( 2 );
}
if( HB_ISNUM( 3 ) )
{
EndBit = hb_parni( 3 );
}
EndBit = _GT_MAX( StartBit, EndBit );
if( StartBit > 0 && EndBit <= ( hb_parclen( 1 ) * 8 ) )
{
for( BitCount = StartBit; BitCount <= EndBit; BitCount++ )
{
BitPointer = BitCount % 8;
BytePointer = ( unsigned ) ( BitCount / 8 );
if( ! BitPointer )
{
BitPointer = 8;
--BytePointer;
}
FlagString[ BytePointer ] &= 0xff - ( 1 << ( BitPointer - 1 ) );
}
}
hb_retclen( FlagString, hb_parclen( 1 ) );
}
else
{
hb_retc_null();
}
}
HB_FUNC( GT_ISFLAG )
{
HB_BOOL FlagStatus = HB_FALSE;
unsigned Bit = 1;
unsigned BitPointer;
unsigned BytePointer;
char *FlagString;
HB_BOOL FlagStatus = HB_FALSE;
unsigned Bit = 1;
unsigned BitPointer;
unsigned BytePointer;
char * FlagString;
if ( HB_ISCHAR(1) )
{
FlagString = hb_parc(1);
if ( HB_ISNUM(2) )
{
Bit = hb_parni(2);
}
if (Bit > 0 && Bit <= (hb_parclen(1) * 8))
{
BitPointer = Bit % 8;
BytePointer = (unsigned) (Bit / 8);
if (!BitPointer)
{
BitPointer = 8;
--BytePointer;
}
FlagStatus = FlagString[BytePointer] & (1 << (BitPointer - 1));
}
}
hb_retl(FlagStatus);
if( HB_ISCHAR( 1 ) )
{
FlagString = hb_parc( 1 );
if( HB_ISNUM( 2 ) )
{
Bit = hb_parni( 2 );
}
if( Bit > 0 && Bit <= ( hb_parclen( 1 ) * 8 ) )
{
BitPointer = Bit % 8;
BytePointer = ( unsigned ) ( Bit / 8 );
if( ! BitPointer )
{
BitPointer = 8;
--BytePointer;
}
FlagStatus = FlagString[ BytePointer ] & ( 1 << ( BitPointer - 1 ) );
}
}
hb_retl( FlagStatus );
}

29
harbour/contrib/hbgt/chareven.c
View File

@@ -21,21 +21,24 @@
HB_FUNC( GT_CHAREVEN )
{
const char *s1;
char *s2;
HB_ISIZ len, i;
const char * s1;
char * s2;
HB_ISIZ len, i;
if (HB_ISCHAR(1)) {
s1 = hb_parc(1);
len = hb_parclen(1);
if( HB_ISCHAR( 1 ) )
{
s1 = hb_parc( 1 );
len = hb_parclen( 1 );
s2 = (char *) hb_xgrab(len / 2 + 1); /* grab us some mem to work with */
s2 = ( char * ) hb_xgrab( len / 2 + 1 ); /* grab us some mem to work with */
for (i = 1; i <= len; i += 2)
s2[(i - 1)/2] = s1[i] & 0x7f;
for( i = 1; i <= len; i += 2 )
s2[ ( i - 1 ) / 2 ] = s1[ i ] & 0x7f;
hb_retclen_buffer(s2, len/2);
} else {
hb_retc_null(); /* parameter mismatch - error NullStr */
}
hb_retclen_buffer( s2, len / 2 );
}
else
{
hb_retc_null(); /* parameter mismatch - error NullStr */
}
}

52
harbour/contrib/hbgt/charmixg.c
View File

@@ -21,34 +21,38 @@
HB_FUNC( GT_CHARMIX )
{
const char *s1, *s2;
char *s3;
HB_ISIZ l1, l2, i, pos3;
const char * s1, * s2;
char * s3;
HB_ISIZ l1, l2, i, pos3;
if (HB_ISCHAR(1) && HB_ISCHAR(2)) {
s1 = hb_parc(1);
s2 = hb_parc(2);
l1 = hb_parclen(1);
l2 = hb_parclen(2);
pos3 = 0;
if( HB_ISCHAR( 1 ) && HB_ISCHAR( 2 ) )
{
s1 = hb_parc( 1 );
s2 = hb_parc( 2 );
l1 = hb_parclen( 1 );
l2 = hb_parclen( 2 );
pos3 = 0;
s3 = (char*)hb_xgrab(l1 + l2 + 1); /* grab us some mem to work with */
s3 = ( char * ) hb_xgrab( l1 + l2 + 1 ); /* grab us some mem to work with */
for (i = 0; i < l1; i++) {
s3[pos3++] = s1[i];
for( i = 0; i < l1; i++ )
{
s3[ pos3++ ] = s1[ i ];
if (i < l2)
s3[pos3++] = s2[i];
}
if( i < l2 )
s3[ pos3++ ] = s2[ i ];
}
if (l2 > l1)
for (; i < l2; i++)
s3[pos3++] = s2[i];
if( l2 > l1 )
for(; i < l2; i++ )
s3[ pos3++ ] = s2[ i ];
s3[pos3] = '\0';
hb_retclen(s3, l1 + l2);
hb_xfree(s3); /* free alloc'ed mem */
} else {
hb_retc_null(); /* parameter mismatch - error NullStr */
}
s3[ pos3 ] = '\0';
hb_retclen( s3, l1 + l2 );
hb_xfree( s3 ); /* free alloc'ed mem */
}
else
{
hb_retc_null(); /* parameter mismatch - error NullStr */
}
}

31
harbour/contrib/hbgt/charodd.c
View File

@@ -21,22 +21,25 @@
HB_FUNC( GT_CHARODD )
{
const char *s1;
char *s2;
HB_ISIZ len, i;
const char * s1;
char * s2;
HB_ISIZ len, i;
if (HB_ISCHAR(1)) {
s1 = hb_parc(1);
len = hb_parclen(1);
if( HB_ISCHAR( 1 ) )
{
s1 = hb_parc( 1 );
len = hb_parclen( 1 );
s2 = (char *)hb_xgrab(len / 2); /* grab us some mem to work with */
s2 = ( char * ) hb_xgrab( len / 2 ); /* grab us some mem to work with */
for (i = 0; i <= len; i += 2)
s2[i/2] = s1[i] & 0x7f;
for( i = 0; i <= len; i += 2 )
s2[ i / 2 ] = s1[ i ] & 0x7f;
hb_retclen(s2, len);
hb_xfree(s2); /* free alloc'ed mem */
} else {
hb_retc_null(); /* parameter mismatch - error NullStr */
}
hb_retclen( s2, len );
hb_xfree( s2 ); /* free alloc'ed mem */
}
else
{
hb_retc_null(); /* parameter mismatch - error NullStr */
}
}

34
harbour/contrib/hbgt/chrcount.c
View File

@@ -21,22 +21,26 @@
HB_FUNC( GT_CHRCOUNT )
{
const char *s1, *s2;
HB_ISIZ count, pos2, len;
const char * s1, * s2;
HB_ISIZ count, pos2, len;
if (HB_ISCHAR(1) && HB_ISCHAR(2)) {
s1 = hb_parc(1);
s2 = hb_parc(2);
len = hb_parclen(2);
if( HB_ISCHAR( 1 ) && HB_ISCHAR( 2 ) )
{
s1 = hb_parc( 1 );
s2 = hb_parc( 2 );
len = hb_parclen( 2 );
/* loop through s2 matching passed character (s1) with
each character of s1 */
for (count = 0, pos2 = 1; pos2 <= len; s2++, pos2++)
if (*s1 == *s2) /* character matches s1 */
count++; /* increment counter */
/* loop through s2 matching passed character (s1) with
each character of s1 */
for( count = 0, pos2 = 1; pos2 <= len; s2++, pos2++ )
if( *s1 == *s2 ) /* character matches s1 */
count++;
/* increment counter */
hb_retns(count); /* return result */
} else {
hb_retns(-1); /* parameter mismatch - error -1 */
}
hb_retns( count ); /* return result */
}
else
{
hb_retns( -1 ); /* parameter mismatch - error -1 */
}
}

50
harbour/contrib/hbgt/chrfirst.c
View File

@@ -21,31 +21,37 @@
HB_FUNC( GT_CHRFIRST )
{
const char *string;
const char *cset;
HB_ISIZ l1, l2;
HB_ISIZ p1, p2;
const char * string;
const char * cset;
HB_ISIZ l1, l2;
HB_ISIZ p1, p2;
if (HB_ISCHAR(1) && HB_ISCHAR(2)) {
string = hb_parc(2);
cset = hb_parc(1);
l1 = hb_parclen(2);
l2 = hb_parclen(1);
p1 = p2 = 0;
if( HB_ISCHAR( 1 ) && HB_ISCHAR( 2 ) )
{
string = hb_parc( 2 );
cset = hb_parc( 1 );
l1 = hb_parclen( 2 );
l2 = hb_parclen( 1 );
p1 = p2 = 0;
do {
for (p2 = 0; (p2 < l2) && (cset[p2] != string[p1]); ++p2)
;
if (p2 < l2) {
hb_retni(string[p1]);
break;
do
{
for( p2 = 0; ( p2 < l2 ) && ( cset[ p2 ] != string[ p1 ] ); ++p2 )
;
if( p2 < l2 )
{
hb_retni( string[ p1 ] );
break;
}
}
} while (p1++ < l1);
while( p1++ < l1 );
if (p2 >= l2)
hb_retni(0);
if( p2 >= l2 )
hb_retni( 0 );
} else {
hb_retni(-1); /* parameter mismatch - error NullStr */
}
}
else
{
hb_retni( -1 ); /* parameter mismatch - error NullStr */
}
}

34
harbour/contrib/hbgt/chrtotal.c
View File

@@ -21,22 +21,26 @@
HB_FUNC( GT_CHRTOTAL )
{
const char *s1, *s2;
HB_ISIZ count, p1, p2, l2, l1;
const char * s1, * s2;
HB_ISIZ count, p1, p2, l2, l1;
if (HB_ISCHAR(1) && HB_ISCHAR(2)) {
s1 = hb_parc(1);
s2 = hb_parc(2);
l2 = hb_parclen(2);
l1 = hb_parclen(1);
if( HB_ISCHAR( 1 ) && HB_ISCHAR( 2 ) )
{
s1 = hb_parc( 1 );
s2 = hb_parc( 2 );
l2 = hb_parclen( 2 );
l1 = hb_parclen( 1 );
for (count = 0, p2 = 0; p2 < l2; p2++)
for (p1 = 0; p1 < l1; p1++)
if (s1[p1] == s2[p2])
count++; /* increment counter */
for( count = 0, p2 = 0; p2 < l2; p2++ )
for( p1 = 0; p1 < l1; p1++ )
if( s1[ p1 ] == s2[ p2 ] )
count++;
/* increment counter */
hb_retns(count); /* return result */
} else {
hb_retns(-1); /* parameter mismatch - error -1 */
}
hb_retns( count ); /* return result */
}
else
{
hb_retns( -1 ); /* parameter mismatch - error -1 */
}
}

24
harbour/contrib/hbgt/strasint.c
View File

@@ -11,21 +11,21 @@
#include "hbapi.h"
int _GT_Internal_StringAsInt(char *String, HB_ISIZ Start, HB_ISIZ End)
int _GT_Internal_StringAsInt( char * String, HB_ISIZ Start, HB_ISIZ End )
{
int Decimal = 1;
int Value = 0;
HB_ISIZ Digit;
int Value = 0;
HB_ISIZ Digit;
HB_TRACE(HB_TR_DEBUG, ("_GT_Internal_StringAsInt(%s, %" HB_PFS "d, %" HB_PFS "d)", String, Start, End));
HB_TRACE( HB_TR_DEBUG, ( "_GT_Internal_StringAsInt(%s, %" HB_PFS "d, %" HB_PFS "d)", String, Start, End ) );
for (Digit = End; Digit >= Start; Digit--)
{
if (HB_ISDIGIT(String[Digit]))
{
Value += (String[Digit] - 0x30) * Decimal;
Decimal *= 0xA;
}
}
for( Digit = End; Digit >= Start; Digit-- )
{
if( HB_ISDIGIT( String[ Digit ] ) )
{
Value += ( String[ Digit ] - 0x30 ) * Decimal;
Decimal *= 0xA;
}
}
return Value;
}

53
harbour/contrib/hbgt/strcount.c
View File

@@ -21,35 +21,38 @@
HB_FUNC( GT_STRCOUNT )
{
const char *s1, *s2;
HB_ISIZ count, p1, p2, l1, l2;
int match;
const char * s1, * s2;
HB_ISIZ count, p1, p2, l1, l2;
int match;
if (HB_ISCHAR(1) && HB_ISCHAR(2)) {
s1 = hb_parc(1);
s2 = hb_parc(2);
l1 = hb_parclen(1);
l2 = hb_parclen(2);
if( HB_ISCHAR( 1 ) && HB_ISCHAR( 2 ) )
{
s1 = hb_parc( 1 );
s2 = hb_parc( 2 );
l1 = hb_parclen( 1 );
l2 = hb_parclen( 2 );
/* loop through s2 matching passed character (s1) with
each character of s1 */
/* loop through s2 matching passed character (s1) with
each character of s1 */
for (count = 0, p2 = 0; p2 <= (l2 - l1); p2++)
{
match = 1;
for (p1 = 0; p1 < l1; p1++)
for( count = 0, p2 = 0; p2 <= ( l2 - l1 ); p2++ )
{
if (s1[p1] != s2[p2 + p1])
match = 0;
match = 1;
for( p1 = 0; p1 < l1; p1++ )
{
if( s1[ p1 ] != s2[ p2 + p1 ] )
match = 0;
}
if( match )
count++;
}
if (match)
count++;
}
hb_retns(count); /* return result */
} else {
hb_retns(-1); /* parameter mismatch - error -1 */
}
hb_retns( count ); /* return result */
}
else
{
hb_retns( -1 ); /* parameter mismatch - error -1 */
}
}

42
harbour/contrib/hbgt/strcspn.c
View File

@@ -21,26 +21,30 @@
HB_FUNC( GT_STRCSPN )
{
const char *string;
const char *cset;
HB_ISIZ l1, l2;
HB_ISIZ p1, p2;
const char * string;
const char * cset;
HB_ISIZ l1, l2;
HB_ISIZ p1, p2;
if (HB_ISCHAR(1) && HB_ISCHAR(2)) {
string = hb_parc(1);
cset = hb_parc(2);
l1 = hb_parclen(1);
l2 = hb_parclen(2);
if( HB_ISCHAR( 1 ) && HB_ISCHAR( 2 ) )
{
string = hb_parc( 1 );
cset = hb_parc( 2 );
l1 = hb_parclen( 1 );
l2 = hb_parclen( 2 );
for (p1 = 0; p1 < l1; ++p1) {
for (p2 = 0; (p2 < l2) && (string[p1] != cset[p2]); ++p2)
;
for( p1 = 0; p1 < l1; ++p1 )
{
for( p2 = 0; ( p2 < l2 ) && ( string[ p1 ] != cset[ p2 ] ); ++p2 )
;
if (p2 < l2)
break;
}
hb_retns(p1);
} else {
hb_retns(-1); /* parameter mismatch - error -1 */
}
if( p2 < l2 )
break;
}
hb_retns( p1 );
}
else
{
hb_retns( -1 ); /* parameter mismatch - error -1 */
}
}

43
harbour/contrib/hbgt/strdiffg.c
View File

@@ -21,29 +21,32 @@
HB_FUNC( GT_STRDIFF )
{
const char *s1, *s2;
HB_ISIZ pos, len;
const char * s1, * s2;
HB_ISIZ pos, len;
if (HB_ISCHAR(1) && HB_ISCHAR(2)) {
s1 = hb_parc(1);
s2 = hb_parc(2);
len = hb_parclen(2);
if( HB_ISCHAR( 1 ) && HB_ISCHAR( 2 ) )
{
s1 = hb_parc( 1 );
s2 = hb_parc( 2 );
len = hb_parclen( 2 );
/*
loop through comparing both strings
/*
loop through comparing both strings
NOTE: pos starts at 1, so as to return a string index
for CLIPPER
*/
NOTE: pos starts at 1, so as to return a string index
for CLIPPER
*/
for (pos = 1; (pos <= len) && (*s1 == *s2); s2++, s1++)
pos++;
for( pos = 1; ( pos <= len ) && ( *s1 == *s2 ); s2++, s1++ )
pos++;
if (pos > len) /* strings match exactly!!! */
hb_retc_null();
else
hb_retc(s2);
} else {
hb_ret(); /* parameter mismatch - error return NIL */
}
if( pos > len ) /* strings match exactly!!! */
hb_retc_null();
else
hb_retc( s2 );
}
else
{
hb_ret(); /* parameter mismatch - error return NIL */
}
}

60
harbour/contrib/hbgt/strexpan.c
View File

@@ -21,40 +21,44 @@
HB_FUNC( GT_STREXPAND )
{
const char *in;
char *out;
int nIns = 1;
const char *insert = " ";
HB_ISIZ len;
HB_ISIZ i, p;
int j;
const char * in;
char * out;
int nIns = 1;
const char * insert = " ";
HB_ISIZ len;
HB_ISIZ i, p;
int j;
if (HB_ISCHAR(1) && (HB_ISNUM(2) || hb_pcount() < 2) && (HB_ISCHAR(3) || hb_pcount() < 3)) {
in = hb_parc(1);
len = hb_parclen(1);
if( HB_ISCHAR( 1 ) && ( HB_ISNUM( 2 ) || hb_pcount() < 2 ) && ( HB_ISCHAR( 3 ) || hb_pcount() < 3 ) )
{
in = hb_parc( 1 );
len = hb_parclen( 1 );
if (HB_ISNUM(2))
nIns = hb_parni(2);
if( HB_ISNUM( 2 ) )
nIns = hb_parni( 2 );
if (HB_ISCHAR(3))
insert = hb_parc(3);
if( HB_ISCHAR( 3 ) )
insert = hb_parc( 3 );
out = (char *)hb_xgrab(len * (nIns + 1)); /* alloc us some memory */
out = ( char * ) hb_xgrab( len * ( nIns + 1 ) ); /* alloc us some memory */
for (i = 0, p = 0; i < len; i++) { /* loop thru input */
out[p++] = in[i]; /* insert a character from input */
for( i = 0, p = 0; i < len; i++ ) /* loop thru input */
{
out[ p++ ] = in[ i ]; /* insert a character from input */
if (i < (len - 1)) { /* do not insert fill chars on last */
/* char of input */
for (j = 1; j <= nIns; j++) /* insert the fill characters */
out[p++] = insert[0];
if( i < ( len - 1 ) ) /* do not insert fill chars on last */
{ /* char of input */
for( j = 1; j <= nIns; j++ ) /* insert the fill characters */
out[ p++ ] = insert[ 0 ];
}
}
}
out[p] = '\0'; /* Add terminating NUL */
out[ p ] = '\0'; /* Add terminating NUL */
hb_retc(out);
hb_xfree(out); /* free alloc'ed mem */
} else {
hb_retc_null(); /* parameter mismatch - error NullStr */
}
hb_retc( out );
hb_xfree( out ); /* free alloc'ed mem */
}
else
{
hb_retc_null(); /* parameter mismatch - error NullStr */
}
}

42
harbour/contrib/hbgt/strleft.c
View File

@@ -21,27 +21,31 @@
HB_FUNC( GT_STRLEFT )
{
const char *string;
const char *cset;
HB_ISIZ l1, l2;
HB_ISIZ p1, p2;
const char * string;
const char * cset;
HB_ISIZ l1, l2;
HB_ISIZ p1, p2;
if (HB_ISCHAR(1) && HB_ISCHAR(2)) {
string = hb_parc(1);
cset = hb_parc(2);
l1 = hb_parclen(1);
l2 = hb_parclen(2);
if( HB_ISCHAR( 1 ) && HB_ISCHAR( 2 ) )
{
string = hb_parc( 1 );
cset = hb_parc( 2 );
l1 = hb_parclen( 1 );
l2 = hb_parclen( 2 );
for (p1 = 0; p1 < l1; p1++) {
for (p2 = 0; p2 < l2 && cset[p2] != string[p1]; p2++)
;
for( p1 = 0; p1 < l1; p1++ )
{
for( p2 = 0; p2 < l2 && cset[ p2 ] != string[ p1 ]; p2++ )
;
if (p2 == l2)
break;
}
hb_retns(p1);
if( p2 == l2 )
break;
}
hb_retns( p1 );
} else {
hb_retns(-1); /* parameter mismatch - error NullStr */
}
}
else
{
hb_retns( -1 ); /* parameter mismatch - error NullStr */
}
}

50
harbour/contrib/hbgt/strpbrk.c
View File

@@ -21,31 +21,37 @@
HB_FUNC( GT_STRPBRK )
{
const char *string;
const char *cset;
HB_ISIZ l1, l2;
HB_ISIZ p1, p2;
const char * string;
const char * cset;
HB_ISIZ l1, l2;
HB_ISIZ p1, p2;
if (HB_ISCHAR(1) && HB_ISCHAR(2)) {
string = hb_parc(1);
cset = hb_parc(2);
l1 = hb_parclen(1);
l2 = hb_parclen(2);
p1 = p2 = 0;
if( HB_ISCHAR( 1 ) && HB_ISCHAR( 2 ) )
{
string = hb_parc( 1 );
cset = hb_parc( 2 );
l1 = hb_parclen( 1 );
l2 = hb_parclen( 2 );
p1 = p2 = 0;
do {
for (p2 = 0; (p2 < l2) && (cset[p2] != string[p1]); ++p2)
;
if (p2 < l2) {
hb_retc(string + p1);
break;
do
{
for( p2 = 0; ( p2 < l2 ) && ( cset[ p2 ] != string[ p1 ] ); ++p2 )
;
if( p2 < l2 )
{
hb_retc( string + p1 );
break;
}
}
} while (p1++ < l1);
while( p1++ < l1 );
if (p2 >= l2)
hb_retc_null();
if( p2 >= l2 )
hb_retc_null();
} else {
hb_retc_null(); /* parameter mismatch - error NullStr */
}
}
else
{
hb_retc_null(); /* parameter mismatch - error NullStr */
}
}

42
harbour/contrib/hbgt/strright.c
View File

@@ -21,27 +21,31 @@
HB_FUNC( GT_STRRIGHT )
{
const char *string;
const char *cset;
HB_ISIZ l1, l2;
HB_ISIZ p1, p2;
const char * string;
const char * cset;
HB_ISIZ l1, l2;
HB_ISIZ p1, p2;
if (HB_ISCHAR(1) && HB_ISCHAR(2)) {
string = hb_parc(1);
cset = hb_parc(2);
l1 = hb_parclen(1);
l2 = hb_parclen(2);
if( HB_ISCHAR( 1 ) && HB_ISCHAR( 2 ) )
{
string = hb_parc( 1 );
cset = hb_parc( 2 );
l1 = hb_parclen( 1 );
l2 = hb_parclen( 2 );
for (p1 = l1 - 1; p1 >= 0; p1--) {
for (p2 = 0; p2 < l2 && cset[p2] != string[p1]; p2++)
;
for( p1 = l1 - 1; p1 >= 0; p1-- )
{
for( p2 = 0; p2 < l2 && cset[ p2 ] != string[ p1 ]; p2++ )
;
if (p2 == l2)
break;
}
hb_retns(l1 - p1 - 1);
if( p2 == l2 )
break;
}
hb_retns( l1 - p1 - 1 );
} else {
hb_retns(-1); /* parameter mismatch - error NullStr */
}
}
else
{
hb_retns( -1 ); /* parameter mismatch - error NullStr */
}
}

36
harbour/contrib/hbgt/tests/test.prg
View File

@@ -2,24 +2,26 @@
* $Id$
*/
#require "hbgt"
PROCEDURE Main()
QOut( 'gt_ascpos("Harbour",1) => ' + LTrim( Str(gt_ascpos("Harbour",1 ) ) ) )
QOut( 'gt_atdiff("This Is Harbour","This Is Clipper") => ' + LTrim( Str(gt_atdiff("This Is Harbour","This Is Clipper" ) ) ) )
QOut( 'gt_chareven("The_Power_Of_Harbour") => ' + gt_chareven( "The_Power_Of_Harbour" ) )
QOut( 'gt_charodd("The_Power_Of_Harbour") => ' + gt_charodd( "The_Power_Of_Harbour" ) )
QOut( 'gt_chrcount("s","she sells shells by the sea shore") => ' + LTrim( Str(gt_chrcount("s","she sells shells by the sea shore" ) ) ) )
QOut( 'gt_chrtotal("sl","she sells shells by the sea shore") => ' + LTrim( Str(gt_chrtotal("sl","she sells shells by the sea shore" ) ) ) )
QOut( 'gt_charmix("CLIPPER","harbour") => ' + gt_charmix( "CLIPPER","harbour" ) )
QOut( 'gt_asciisum("harbour") => ' + LTrim( Str(gt_asciisum("harbour" ) ) ) )
QOut( 'gt_chrfirst("Ho", "the power of Harbour") => ' + LTrim( Str(gt_chrfirst("Ho", "the power of Harbour" ) ) ) )
QOut( 'gt_strcount("the", "the cat sat on the mat") => ' + LTrim( Str(gt_strcount("the", "the cat sat on the mat" ) ) ) )
QOut( 'gt_strcspn("this is a test", "as ") => ' + LTrim( Str(gt_strcspn("this is a test", "as " ) ) ) )
QOut( 'gt_strcspn("this is a test", "elnjpq") => ' + LTrim( Str(gt_strcspn("this is a test", "elnjpq" ) ) ) )
QOut( 'gt_strDiff("the cat", "the rat") => ' + gt_strDiff( "the cat", "the rat" ) )
QOut( 'gt_strexpand("HARBOUR", 2,"-") => ' + gt_strexpand( "HARBOUR", 2,"-" ) )
QOut( 'gt_strleft("this is a test", "hsit ") => ' + LTrim( Str(gt_strleft("this is a test", "hsit " ) ) ) )
QOut( 'gt_strpbrk("this is a test", "sa ") => ' + gt_strpbrk( "this is a test", "sa " ) )
QOut( 'gt_strright("this is a test", "teas ") => ' + LTrim( Str(gt_strright("this is a test", "teas " ) ) ) )
QOut( 'gt_ascpos( "Harbour", 1 ) => ' + hb_ntos( gt_ascpos( "Harbour", 1 ) ) )
QOut( 'gt_atdiff( "This Is Harbour", "This Is Clipper" ) => ' + hb_ntos( gt_atdiff( "This Is Harbour", "This Is Clipper" ) ) )
QOut( 'gt_chareven( "The_Power_Of_Harbour" ) => ' + gt_chareven( "The_Power_Of_Harbour" ) )
QOut( 'gt_charodd( "The_Power_Of_Harbour" ) => ' + gt_charodd( "The_Power_Of_Harbour" ) )
QOut( 'gt_chrcount( "s", "she sells shells by the sea shore" ) => ' + hb_ntos( gt_chrcount( "s", "she sells shells by the sea shore" ) ) )
QOut( 'gt_chrtotal( "sl", "she sells shells by the sea shore" ) => ' + hb_ntos( gt_chrtotal( "sl", "she sells shells by the sea shore" ) ) )
QOut( 'gt_charmix( "CLIPPER", "harbour" ) => ' + gt_charmix( "CLIPPER", "harbour" ) )
QOut( 'gt_asciisum( "harbour" ) => ' + hb_ntos( gt_asciisum( "harbour" ) ) )
QOut( 'gt_chrfirst( "Ho", "the power of Harbour" ) => ' + hb_ntos( gt_chrfirst( "Ho", "the power of Harbour" ) ) )
QOut( 'gt_strcount( "the", "the cat sat on the mat" ) => ' + hb_ntos( gt_strcount( "the", "the cat sat on the mat" ) ) )
QOut( 'gt_strcspn( "this is a test", "as " ) => ' + hb_ntos( gt_strcspn( "this is a test", "as " ) ) )
QOut( 'gt_strcspn( "this is a test", "elnjpq" ) => ' + hb_ntos( gt_strcspn( "this is a test", "elnjpq" ) ) )
QOut( 'gt_strDiff( "the cat", "the rat" ) => ' + gt_strDiff( "the cat", "the rat" ) )
QOut( 'gt_strexpand( "HARBOUR", 2, "-" ) => ' + gt_strexpand( "HARBOUR", 2, "-" ) )
QOut( 'gt_strleft( "this is a test", "hsit " ) => ' + hb_ntos( gt_strleft( "this is a test", "hsit " ) ) )
QOut( 'gt_strpbrk( "this is a test", "sa " ) => ' + gt_strpbrk( "this is a test", "sa " ) )
QOut( 'gt_strright( "this is a test", "teas " ) => ' + hb_ntos( gt_strright( "this is a test", "teas " ) ) )
RETURN