static HB_BOOL hb_regex( int iRequest )
{
HB_REGMATCH aMatches[ HB_REGMATCH_SIZE( REGEX_MAX_GROUPS ) ];
PHB_ITEM pRetArray, pMatch, pString;
int i, iMatches, iMaxMatch;
HB_BOOL fResult = HB_FALSE;
PHB_REGEX pRegEx;
const char * pszString;
HB_SIZE nLen;
pString = hb_param( 2, HB_IT_STRING );
if( ! pString )
{
hb_errRT_BASE_SubstR( EG_ARG, 3014, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
return HB_FALSE;
}
pRegEx = hb_regexGet( hb_param( 1, HB_IT_ANY ),
( ! hb_parldef( 3, 1 ) ? HBREG_ICASE : 0 ) |
( hb_parl( 4 ) ? HBREG_NEWLINE : 0 ) );
if( ! pRegEx )
return HB_FALSE;
pszString = hb_itemGetCPtr( pString );
nLen = hb_itemGetCLen( pString );
iMaxMatch = iRequest == 0 || iRequest == 4 || iRequest == 5 ?
REGEX_MAX_GROUPS : 1;
iMatches = hb_regexec( pRegEx, pszString, nLen, iMaxMatch, aMatches );
if( iMatches > 0 )
{
switch( iRequest )
{
case 0:
pRetArray = hb_itemArrayNew( iMatches );
for( i = 0; i < iMatches; i++ )
{
if( HB_REGMATCH_EO( aMatches, i ) > -1 )
hb_arraySetCL( pRetArray, i + 1,
pszString + HB_REGMATCH_SO( aMatches, i ),
HB_REGMATCH_EO( aMatches, i ) -
HB_REGMATCH_SO( aMatches, i ) );
else
hb_arraySetCL( pRetArray, i + 1, NULL, 0 );
}
hb_itemReturnRelease( pRetArray );
fResult = HB_TRUE;
break;
case 1: /* LIKE */
fResult = HB_REGMATCH_SO( aMatches, 0 ) == 0 &&
( HB_SIZE ) HB_REGMATCH_EO( aMatches, 0 ) == nLen;
break;
case 2: /* MATCH ( HAS ) */
fResult = HB_TRUE;
break;
case 3: /* SPLIT */
iMaxMatch = hb_parni( 5 );
pRetArray = hb_itemArrayNew( 0 );
pMatch = hb_itemNew( NULL );
iMatches = 0;
do
{
hb_itemPutCL( pMatch, pszString, HB_REGMATCH_SO( aMatches, 0 ) );
hb_arrayAddForward( pRetArray, pMatch );
nLen -= HB_REGMATCH_EO( aMatches, 0 );
pszString += HB_REGMATCH_EO( aMatches, 0 );
iMatches++;
}
while( HB_REGMATCH_EO( aMatches, 0 ) > 0 && nLen &&
( iMaxMatch == 0 || iMatches < iMaxMatch ) &&
hb_regexec( pRegEx, pszString, nLen, 1, aMatches ) > 0 );
/* last match must be done also in case that pszString is empty;
this would mean an empty split field at the end of the string */
/* if( nLen ) */
{
hb_itemPutCL( pMatch, pszString, nLen );
hb_arrayAddForward( pRetArray, pMatch );
}
hb_itemRelease( pMatch );
hb_itemReturnRelease( pRetArray );
fResult = HB_TRUE;
break;
case 4: /* results AND positions */
pRetArray = hb_itemArrayNew( iMatches );
for( i = 0; i < iMatches; i++ )
{
int iSO = HB_REGMATCH_SO( aMatches, i ),
iEO = HB_REGMATCH_EO( aMatches, i );
pMatch = hb_arrayGetItemPtr( pRetArray, i + 1 );
hb_arrayNew( pMatch, 3 );
if( iEO != -1 )
{
/* matched string */
hb_arraySetCL( pMatch, 1, pszString + iSO, iEO - iSO );
/* begin of match */
hb_arraySetNS( pMatch, 2, iSO + 1 );
/* End of match */
hb_arraySetNS( pMatch, 3, iEO );
}
else
{
hb_arraySetCL( pMatch, 1, NULL, 0 );
hb_arraySetNS( pMatch, 2, 0 );
hb_arraySetNS( pMatch, 3, 0 );
}
}
hb_itemReturnRelease( pRetArray );
fResult = HB_TRUE;
break;
case 5: /* _ALL_ results AND positions */
{
PHB_ITEM pAtxArray;
int iMax = hb_parni( 5 ); /* max nuber of matches I want, 0 = unlimited */
int iGetMatch = hb_parni( 6 ); /* Gets if want only one single match or a sub-match */
HB_BOOL fOnlyMatch = hb_parldef( 7, 1 ); /* if HB_TRUE returns only matches and sub-matches, not positions */
HB_SIZE nOffset = 0;
int iCount = 0;
int iSO, iEO;
/* Set new array */
pRetArray = hb_itemArrayNew( 0 );
do
{
/* If I want all matches */
if( iGetMatch == 0 || /* Check boundaries */
( iGetMatch < 0 || iGetMatch > iMatches ) )
{
pAtxArray = hb_itemArrayNew( iMatches );
for( i = 0; i < iMatches; i++ )
{
iSO = HB_REGMATCH_SO( aMatches, i );
iEO = HB_REGMATCH_EO( aMatches, i );
pMatch = hb_arrayGetItemPtr( pAtxArray, i + 1 );
if( ! fOnlyMatch )
{
hb_arrayNew( pMatch, 3 );
if( iEO != -1 )
{
/* matched string */
hb_arraySetCL( pMatch, 1, pszString + iSO, iEO - iSO );
/* begin of match */
hb_arraySetNS( pMatch, 2, nOffset + iSO + 1 );
/* End of match */
hb_arraySetNS( pMatch, 3, nOffset + iEO );
}
else
{
hb_arraySetCL( pMatch, 1, NULL, 0 );
hb_arraySetNS( pMatch, 2, 0 );
hb_arraySetNS( pMatch, 3, 0 );
}
}
else
{
if( iEO != -1 )
/* matched string */
hb_itemPutCL( pMatch, pszString + iSO, iEO - iSO );
else
hb_itemPutC( pMatch, NULL );
}
}
hb_arrayAddForward( pRetArray, pAtxArray );
hb_itemRelease( pAtxArray );
}
else /* Here I get only single matches */
{
i = iGetMatch - 1;
iSO = HB_REGMATCH_SO( aMatches, i );
iEO = HB_REGMATCH_EO( aMatches, i );
pMatch = hb_itemNew( NULL );
if( ! fOnlyMatch )
{
hb_arrayNew( pMatch, 3 );
if( iEO != -1 )
{
/* matched string */
hb_arraySetCL( pMatch, 1, pszString + iSO, iEO - iSO );
/* begin of match */
hb_arraySetNS( pMatch, 2, nOffset + iSO + 1 );
/* End of match */
hb_arraySetNS( pMatch, 3, nOffset + iEO );
}
else
{
hb_arraySetCL( pMatch, 1, NULL, 0 );
hb_arraySetNS( pMatch, 2, 0 );
hb_arraySetNS( pMatch, 3, 0 );
}
}
else
{
if( iEO != -1 )
/* matched string */
hb_itemPutCL( pMatch, pszString + iSO, iEO - iSO );
else
hb_itemPutC( pMatch, NULL );
}
hb_arrayAddForward( pRetArray, pMatch );
hb_itemRelease( pMatch );
}
iEO = HB_REGMATCH_EO( aMatches, 0 );
if( iEO == -1 )
break;
nLen -= iEO;
pszString += iEO;
nOffset += iEO;
iCount++;
}
while( iEO && nLen && ( iMax == 0 || iCount < iMax ) &&
( iMatches = hb_regexec( pRegEx, pszString, nLen, iMaxMatch, aMatches ) ) > 0 );
hb_itemReturnRelease( pRetArray );
fResult = HB_TRUE;
break;
}
}
}
else if( iRequest == 3 )
{
pRetArray = hb_itemArrayNew( 1 );
hb_arraySet( pRetArray, 1, pString );
hb_itemReturnRelease( pRetArray );
fResult = HB_TRUE;
}
hb_regexFree( pRegEx );
return fResult;
}
/* helper function for the list function */
void ct_charlist( int iMode )
{
const char * pcString = hb_parc( 1 );
HB_SIZE sStrLen = hb_parclen( 1 );
HB_SIZE sCnt;
if( iMode == CT_CHARLIST_CHARHIST )
{
HB_SIZE asCharCnt[ UCHAR_MAX ];
PHB_ITEM pArray = hb_itemArrayNew( HB_SIZEOFARRAY( asCharCnt ) );
for( sCnt = 0; sCnt < HB_SIZEOFARRAY( asCharCnt ); ++sCnt )
asCharCnt[ sCnt ] = 0;
for( sCnt = 0; sCnt < sStrLen; ++sCnt )
asCharCnt[ ( HB_UCHAR ) pcString[ sCnt ] ]++;
for( sCnt = 0; sCnt < HB_SIZEOFARRAY( asCharCnt ); ++sCnt )
hb_arraySetNS( pArray, sCnt + 1, asCharCnt[ sCnt ] );
hb_itemReturnRelease( pArray );
}
else
{
char acCharCnt[ UCHAR_MAX ];
HB_SIZE sRetStrLen = 0;
if( iMode == CT_CHARLIST_CHARLIST )
{
char acMark[ UCHAR_MAX ];
memset( acMark, 0, sizeof( acMark ) );
for( sCnt = 0; sCnt < sStrLen; ++sCnt )
{
HB_UCHAR uc = ( HB_UCHAR ) pcString[ sCnt ];
if( acMark[ uc ] == 0 )
{
acCharCnt[ sRetStrLen++ ] = uc;
acMark[ uc ] = 1;
}
}
}
else if( iMode == CT_CHARLIST_CHARSLIST || iMode == CT_CHARLIST_CHARNOLIST )
{
char cScan = iMode == CT_CHARLIST_CHARSLIST ? 1 : 0;
for( sCnt = 0; sCnt < sStrLen; ++sCnt )
acCharCnt[ ( HB_UCHAR ) pcString[ sCnt ] ] = 1;
for( sCnt = 0; sCnt < HB_SIZEOFARRAY( acCharCnt ); ++sCnt )
{
if( acCharCnt[ sCnt ] == cScan )
acCharCnt[ sRetStrLen++ ] = ( HB_UCHAR ) sCnt;
}
}
hb_retclen( acCharCnt, sRetStrLen );
}
}
