HB_EXTERN_END HB_FUNC( HB_DBG_VMVARLGET ) { int iLevel = hb_parni( 1 ) + 1; int iLocal = hb_parni( 2 ); PHB_ITEM pLocal = hb_dbg_vmVarLGet( iLevel, iLocal ); if( pLocal ) { hb_itemReturn( pLocal ); } else { hb_errRT_BASE( EG_ARG, 9999, NULL, "HB_DBG_VMVARLGET", 2, hb_paramError( 1 ), hb_paramError( 2 ) ); } }
/* helper function */ static void do_atnum( int iSwitch ) { if( ( ISCHAR( 1 ) ) && ( ISCHAR( 2 ) ) ) { const char * pcStringToMatch = hb_parc( 1 ); HB_SIZE sStrToMatchLen = hb_parclen( 1 ); const char * pcString = hb_parc( 2 ); HB_SIZE sStrLen = hb_parclen( 2 ); int iMultiPass = ct_getatmupa(); int iAtLike = ct_getatlike(); char cAtLike = ct_getatlikechar(); HB_SIZE sIgnore, sMatchStrLen = 0; ULONG ulCounter; const char * pc = NULL; /* eventually ignore some characters */ if( ISNUM( 4 ) ) sIgnore = ( size_t ) hb_parnl( 4 ); else sIgnore = 0; if( sIgnore >= sStrLen ) { switch( iSwitch ) { case DO_ATNUM_AFTERATNUM: { /* AFTERATNUM */ int iArgErrorMode = ct_getargerrormode(); if( iArgErrorMode != CT_ARGERR_IGNORE ) { ct_error( ( USHORT ) iArgErrorMode, EG_ARG, CT_ERROR_AFTERATNUM, NULL, "AFTERATNUM", 0, EF_CANDEFAULT, 4, hb_paramError( 1 ), hb_paramError( 2 ), hb_paramError( 3 ), hb_paramError( 4 ) ); } ; hb_retc( "" ); }; break; case DO_ATNUM_BEFORATNUM: { /* BEFORATNUM */ int iArgErrorMode = ct_getargerrormode(); if( iArgErrorMode != CT_ARGERR_IGNORE ) { ct_error( ( USHORT ) iArgErrorMode, EG_ARG, CT_ERROR_BEFORATNUM, NULL, "BEFORATNUM", 0, EF_CANDEFAULT, 4, hb_paramError( 1 ), hb_paramError( 2 ), hb_paramError( 3 ), hb_paramError( 4 ) ); } ; hb_retc( "" ); }; break; case DO_ATNUM_ATNUM: { /* ATNUM */ int iArgErrorMode = ct_getargerrormode(); if( iArgErrorMode != CT_ARGERR_IGNORE ) { ct_error( ( USHORT ) iArgErrorMode, EG_ARG, CT_ERROR_ATNUM, NULL, "ATNUM", 0, EF_CANDEFAULT, 4, hb_paramError( 1 ), hb_paramError( 2 ), hb_paramError( 3 ), hb_paramError( 4 ) ); } ; hb_retnl( 0 ); }; break; } return; } else { pcString += sIgnore; sStrLen -= sIgnore; } /* nth match or last match ? */ if( ISNUM( 3 ) && ( ( ulCounter = hb_parnl( 3 ) ) != 0 ) ) { /* find the <ulCounter>th match */ const char * pcSubStr; HB_SIZE sSubStrLen; ULONG ulMatchCounter = 0; pcSubStr = pcString; sSubStrLen = sStrLen; while( ulMatchCounter < ulCounter ) { switch( iAtLike ) { case CT_SETATLIKE_EXACT: { pc = ct_at_exact_forward( pcSubStr, sSubStrLen, pcStringToMatch, sStrToMatchLen, &sMatchStrLen ); }; break; case CT_SETATLIKE_WILDCARD: { pc = ct_at_wildcard_forward( pcSubStr, sSubStrLen, pcStringToMatch, sStrToMatchLen, cAtLike, &sMatchStrLen ); }; break; default: { pc = NULL; }; } if( pc == NULL ) { /* no match found; if this happens at this point, there are no <ulCounter> matches, so return an empty string */ switch( iSwitch ) { case DO_ATNUM_AFTERATNUM: case DO_ATNUM_BEFORATNUM: { /* AFTERATNUM */ /* BEFORATNUM */ hb_retc( "" ); }; break; case DO_ATNUM_ATNUM: { /* ATNUM */ hb_retnl( 0 ); }; break; } return; } ulMatchCounter++; if( iMultiPass ) pcSubStr = pc + 1; else pcSubStr = pc + sMatchStrLen; sSubStrLen = sStrLen - ( pcSubStr - pcString ); } } else /* (ISNUM (3) && ((ulCounter = hb_parnl (3)) != 0) */ { /* we have to find the last match and return the string after that last match */ switch( iAtLike ) { case CT_SETATLIKE_EXACT: { pc = ct_at_exact_backward( pcString, sStrLen, pcStringToMatch, sStrToMatchLen, &sMatchStrLen ); }; break; case CT_SETATLIKE_WILDCARD: { pc = ct_at_wildcard_backward( pcString, sStrLen, pcStringToMatch, sStrToMatchLen, cAtLike, &sMatchStrLen ); }; break; default: { pc = NULL; }; } if( pc == NULL ) { /* no matches found */ switch( iSwitch ) { case DO_ATNUM_AFTERATNUM: case DO_ATNUM_BEFORATNUM: { /* AFTERATNUM */ /* BEFORATNUM */ hb_retc( "" ); }; break; case DO_ATNUM_ATNUM: { /* ATNUM */ hb_retnl( 0 ); }; break; } return; } } switch( iSwitch ) { case DO_ATNUM_AFTERATNUM: { /* AFTERATNUM */ if( pc + sMatchStrLen >= pcString + sStrLen ) hb_retc( "" ); else hb_retclen( pc + sMatchStrLen, sStrLen - ( pc + sMatchStrLen - pcString ) ); }; break; case DO_ATNUM_BEFORATNUM: { /* BEFORATNUM */ hb_retclen( pcString - sIgnore, pc - ( pcString - sIgnore ) ); }; break; case DO_ATNUM_ATNUM: { /* ATNUM */ hb_retns( pc - ( pcString - sIgnore ) + 1 ); }; break; } } else /* ((ISCHAR (1)) && (ISCHAR (2))) */ { switch( iSwitch ) { case DO_ATNUM_AFTERATNUM: case DO_ATNUM_BEFORATNUM: { /* AFTERATNUM */ PHB_ITEM pSubst = NULL; int iArgErrorMode = ct_getargerrormode(); if( iArgErrorMode != CT_ARGERR_IGNORE ) { pSubst = ct_error_subst( ( USHORT ) iArgErrorMode, EG_ARG, ( iSwitch == DO_ATNUM_AFTERATNUM ? CT_ERROR_AFTERATNUM : CT_ERROR_BEFORATNUM ), NULL, ( iSwitch == DO_ATNUM_AFTERATNUM ? "AFTERATNUM" : "BEFORATNUM" ), 0, EF_CANSUBSTITUTE, 4, hb_paramError( 1 ), hb_paramError( 2 ), hb_paramError( 3 ), hb_paramError( 4 ) ); } if( pSubst != NULL ) { hb_itemRelease( hb_itemReturnForward( pSubst ) ); } else { hb_retc( "" ); } }; break; case DO_ATNUM_ATNUM: { /* ATNUM */ PHB_ITEM pSubst = NULL; int iArgErrorMode = ct_getargerrormode(); if( iArgErrorMode != CT_ARGERR_IGNORE ) { pSubst = ct_error_subst( ( USHORT ) iArgErrorMode, EG_ARG, CT_ERROR_ATNUM, NULL, "ATNUM", 0, EF_CANSUBSTITUTE, 4, hb_paramError( 1 ), hb_paramError( 2 ), hb_paramError( 3 ), hb_paramError( 4 ) ); } if( pSubst != NULL ) { hb_itemRelease( hb_itemReturnForward( pSubst ) ); } else { hb_retnl( 0 ); } }; break; } } }
/* helper function for the justxxx() functions */ static void do_justify (int iSwitch) { int iNoRet; iNoRet = ct_getref() && ISBYREF( 1 ); if (ISCHAR (1)) { char *pcString = hb_parc (1); size_t sStrLen = hb_parclen (1); char cJustChar; char *pc, *pcRet; size_t sJustOffset; if ( sStrLen == 0 ) { if (iNoRet) { hb_ret(); } else { hb_retc( "" ); } return; } if (hb_parclen (2) > 0) cJustChar = *(hb_parc (2)); else if (ISNUM (2)) cJustChar = (char)( hb_parnl (2) % 256 ); else cJustChar = 0x20; pcRet = ( char *)hb_xgrab (sStrLen); switch (iSwitch) { case DO_JUSTIFY_JUSTLEFT: { pc = pcString; sJustOffset = 0; while ((*pc == cJustChar) && (pc < pcString+sStrLen)) { sJustOffset++; pc++; } hb_xmemcpy (pcRet, pcString+sJustOffset, sStrLen-sJustOffset); for (pc = pcRet+sStrLen-sJustOffset; pc < pcRet+sStrLen; pc++) { *pc = cJustChar; } }; break; case DO_JUSTIFY_JUSTRIGHT: { pc = pcString+sStrLen-1; sJustOffset = 0; while ((*pc == cJustChar) && (pc >= pcString)) { sJustOffset++; pc--; } for (pc = pcRet; pc < pcRet+sJustOffset; pc++) { *pc = cJustChar; } hb_xmemcpy (pcRet+sJustOffset, pcString, sStrLen-sJustOffset); }; break; } if (ISBYREF (1)) hb_storclen (pcRet, sStrLen, 1); if (iNoRet) hb_ret(); else hb_retclen (pcRet, sStrLen); hb_xfree (pcRet); } else /* ISCHAR (1) */ { PHB_ITEM pSubst = NULL; int iArgErrorMode = ct_getargerrormode(); if (iArgErrorMode != CT_ARGERR_IGNORE) { pSubst = ct_error_subst ((USHORT)iArgErrorMode, EG_ARG, (iSwitch == DO_JUSTIFY_JUSTLEFT ? CT_ERROR_JUSTLEFT : CT_ERROR_JUSTRIGHT), NULL, (iSwitch == DO_JUSTIFY_JUSTLEFT ? "JUSTLEFT" : "JUSTRIGHT"), 0, EF_CANSUBSTITUTE, 2, hb_paramError (1), hb_paramError (2)); } if (pSubst != NULL) { hb_itemRelease( hb_itemReturnForward( pSubst ) ); } else { if (iNoRet) hb_ret(); else hb_retc (""); } } return; }
/* helper function for the *one functions */ static void do_charone( int iSwitch ) { char *pcString; size_t sStrLen; char *pcDeleteSet; size_t sDeleteSetLen; /* param check */ if ( ISCHAR( 1 ) ) { if ( ISCHAR( 2 ) ) { pcString = hb_parc( 2 ); sStrLen = (size_t)hb_parclen( 2 ); pcDeleteSet = hb_parc( 1 ); sDeleteSetLen = (size_t)hb_parclen( 1 ); } else { pcString = hb_parc( 1 ); sStrLen = (size_t)hb_parclen( 1 ); pcDeleteSet = NULL; sDeleteSetLen = 0; } switch ( iSwitch ) { case DO_CHARONE_CHARONE: { if (sStrLen > 1) { char *pcSub; char *pcRet; size_t sRetStrLen = 0; char cCurrent = *pcString; pcRet = (char *)hb_xgrab( sStrLen ); /* copy first char */ pcRet[ sRetStrLen++ ] = cCurrent; for ( pcSub = pcString + 1; pcSub < pcString + sStrLen; pcSub++ ) { if ( *pcSub != cCurrent ) { cCurrent = *pcSub; pcRet[ sRetStrLen++ ] = cCurrent; } else if ( pcDeleteSet != NULL && !ct_at_exact_forward( pcDeleteSet, sDeleteSetLen, pcSub, 1, NULL ) ) { pcRet[ sRetStrLen++ ] = cCurrent; } } hb_retclen( pcRet, sRetStrLen ); hb_xfree( pcRet ); } else /* if (sStrLen > 1) */ { /* algorithm does nothing to 1-char-strings */ hb_retclen( pcString, sStrLen ); } } break; case DO_CHARONE_WORDONE: { if ( sStrLen > 3 && sDeleteSetLen >= 2 ) { char *pcSub; char *pcRet; size_t sRetStrLen = 0; char cCurrent1 = pcString[0]; char cCurrent2 = pcString[1]; pcRet = (char *)hb_xgrab( sStrLen ); /* copy first double char */ pcRet[ sRetStrLen++ ] = cCurrent1; pcRet[ sRetStrLen++ ] = cCurrent2; for ( pcSub = pcString + 2; pcSub < pcString + sStrLen - 1; pcSub += 2 ) { if ( !( pcSub[0] == cCurrent1 && pcSub[1] == cCurrent2 ) ) { cCurrent1 = pcSub[0]; cCurrent2 = pcSub[1]; pcRet[ sRetStrLen++ ] = cCurrent1; pcRet[ sRetStrLen++ ] = cCurrent2; } else if ( pcDeleteSet != NULL ) { char *pc = NULL; char *pStart = pcDeleteSet; size_t sLen = sDeleteSetLen; while ( sLen >= 2 && ( pc = ct_at_exact_forward( pStart, sLen, pcSub, 2, NULL ) ) != 0 && ( pc - pcDeleteSet ) % 2 == 1 ) { pStart = pc + 1; sLen = sDeleteSetLen - ( pStart - pcDeleteSet ); } if ( pc == NULL ) { pcRet[ sRetStrLen++ ] = cCurrent1; pcRet[ sRetStrLen++ ] = cCurrent2; } } } /* copy last character if string len is odd */ if ( sStrLen % 2 == 1 ) { pcRet[ sRetStrLen++ ] = pcString[ sStrLen - 1 ]; } hb_retclen( pcRet, sRetStrLen ); hb_xfree( pcRet ); } else /* if (sStrLen > 3) */ { /* algorithm does nothing to 3-char-strings */ hb_retclen( pcString, sStrLen ); } } break; } /* switch (iSwitch) */ } else /* if (ISCHAR (1)) */ { PHB_ITEM pSubst = NULL; int iArgErrorMode = ct_getargerrormode(); if ( iArgErrorMode != CT_ARGERR_IGNORE ) { pSubst = ct_error_subst( (USHORT)iArgErrorMode, EG_ARG, ( iSwitch == DO_CHARONE_CHARONE ? CT_ERROR_CHARONE : CT_ERROR_WORDONE ), NULL, ( iSwitch == DO_CHARONE_CHARONE ? "CHARONE" : "WORDONE" ), 0, EF_CANSUBSTITUTE, 2, hb_paramError( 1 ), hb_paramError( 2 ) ); } if ( pSubst != NULL ) { hb_itemRelease( hb_itemReturnForward( pSubst ) ); } else { hb_retc( "" ); } } }
/* helper function for the pad functions */ static void do_pad (int iSwitch) { if (ISCHAR (1) && ISNUM (2)) { char *pcString = (char *)hb_parc (1); size_t sStrLen = (size_t)hb_parclen (1); char *pcRet, *pc; LONG lRetLen; size_t sRetLen; char cFill; lRetLen = hb_parnl (2); if (lRetLen <= 0) { int iArgErrorMode = ct_getargerrormode(); if (iArgErrorMode != CT_ARGERR_IGNORE) { ct_error ((USHORT)iArgErrorMode, EG_ARG, (iSwitch == DO_PAD_PADLEFT ? CT_ERROR_PADLEFT : CT_ERROR_PADRIGHT), NULL, (iSwitch == DO_PAD_PADLEFT ? "PADLEFT" : "ROR_PADRIGHT"), 0, EF_CANDEFAULT, 3, hb_paramError (1), hb_paramError (2), hb_paramError (3)); } hb_retc (""); return; } sRetLen = (size_t)lRetLen; if (hb_parclen (3) > 0) cFill = *(hb_parc (3)); else if (ISNUM (3)) cFill = (char)( hb_parnl (3) % 256 ); else cFill = 0x20; pcRet = ( char * )hb_xgrab (sRetLen); if (iSwitch == DO_PAD_PADLEFT) { if (sRetLen > sStrLen) { /* fill with cFill */ for (pc = pcRet; pc < pcRet+(sRetLen-sStrLen); pc++) *pc = cFill; hb_xmemcpy (pcRet+(sRetLen-sStrLen), pcString, sStrLen); } else { hb_xmemcpy (pcRet, pcString+(sStrLen-sRetLen), sRetLen); } } else { hb_xmemcpy (pcRet, pcString, (sRetLen < sStrLen ? sRetLen : sStrLen)); if (sRetLen > sStrLen) { /* fill with cFill */ for (pc = pcRet+sStrLen; pc < pcRet+sRetLen; pc++) *pc = cFill; } } hb_retclen (pcRet, sRetLen); hb_xfree (pcRet); } else /* ISCHAR (1) && ISNUM (2) */ { PHB_ITEM pSubst = NULL; int iArgErrorMode = ct_getargerrormode(); if (iArgErrorMode != CT_ARGERR_IGNORE) { pSubst = ct_error_subst ((USHORT)iArgErrorMode, EG_ARG, (iSwitch == DO_PAD_PADLEFT ? CT_ERROR_PADLEFT : CT_ERROR_PADRIGHT), NULL, (iSwitch == DO_PAD_PADLEFT ? "PADLEFT" : "ROR_PADRIGHT"), 0, EF_CANSUBSTITUTE, 3, hb_paramError (1), hb_paramError (2), hb_paramError (3)); } if (pSubst != NULL) { hb_itemRelease( hb_itemReturnForward( pSubst ) ); } else { hb_retc (""); } return; } return; }
/* helper function for the remxxx functions */ static void do_remove( int iSwitch ) { /* param check */ if( ISCHAR( 1 ) ) { char * pcString = ( char * ) hb_parc( 1 ); size_t sStrLen = ( size_t ) hb_parclen( 1 ); char * pcRet, * pc; size_t sRetLen; char cSearch; if( hb_parclen( 2 ) > 0 ) cSearch = *( hb_parc( 2 ) ); else if( ISNUM( 2 ) ) cSearch = ( char ) ( hb_parnl( 2 ) % 256 ); else cSearch = 0x20; sRetLen = sStrLen; pcRet = pcString; if( iSwitch != DO_REMOVE_REMRIGHT ) { while( ( *pcRet == cSearch ) && ( pcRet < pcString + sStrLen ) ) { pcRet++; sRetLen--; } } if( iSwitch != DO_REMOVE_REMLEFT ) { pc = pcString + sStrLen - 1; while( ( *pc == cSearch ) && ( pc >= pcRet ) ) { pc--; sRetLen--; } } if( sRetLen == 0 ) hb_retc( "" ); else hb_retclen( pcRet, sRetLen ); } else /* if (ISCHAR (1)) */ { PHB_ITEM pSubst = NULL; int iArgErrorMode = ct_getargerrormode(); if( iArgErrorMode != CT_ARGERR_IGNORE ) { pSubst = ct_error_subst( ( USHORT ) iArgErrorMode, EG_ARG, sulErrorSubcodes[ iSwitch ], NULL, ( char * ) spcErrorOperation[ iSwitch ], 0, EF_CANSUBSTITUTE, 2, hb_paramError( 1 ), hb_paramError( 2 ) ); } if( pSubst != NULL ) { hb_itemRelease( hb_itemReturnForward( pSubst ) ); } else { hb_retc( "" ); } } }
/* helper function for the posxxx() functions */ static void do_pos1( int iSwitch ) { if( ( ISCHAR( 1 ) ) /* all functions need string as 1st param */ && ( ( iSwitch != DO_POS1_POSRANGE ) /* that's the only condition for all funcs _except_ POSRANGE */ || ( ( iSwitch == DO_POS1_POSRANGE ) /* In addition, POSRANGE needs .. */ && ( ISCHAR( 2 ) ) /* .. string as 2nd .. */ && ( ISCHAR( 3 ) ) /* .. and 3rd param */ ) ) ) { unsigned char * pcString; size_t sStrLen; unsigned char * puc, ucChar1 = ' ', ucChar2 = ' '; int iMode; size_t sIgnore; int iParamShift = 0; if( iSwitch == DO_POS1_POSRANGE ) { if( hb_parclen( 1 ) == 0 ) { hb_retnl( 0 ); return; } else { ucChar1 = *( hb_parc( 1 ) ); } if( hb_parclen( 2 ) == 0 ) { hb_retnl( 0 ); return; } else { ucChar2 = *( hb_parc( 2 ) ); } iParamShift += 2; } pcString = ( unsigned char * ) hb_parc( iParamShift + 1 ); sStrLen = ( size_t ) hb_parclen( iParamShift + 1 ); if( ISLOG( iParamShift + 2 ) ) iMode = hb_parl( iParamShift + 2 ); else iMode = 0; if( ISNUM( iParamShift + 3 ) ) sIgnore = ( size_t ) hb_parnl( iParamShift + 3 ); else sIgnore = 0; for( puc = pcString + sIgnore; puc < pcString + sStrLen; puc++ ) { int iDoRet = 0; switch( iSwitch ) { case DO_POS1_POSALPHA: { iDoRet = ISALPHA( *puc ); }; break; case DO_POS1_POSLOWER: { iDoRet = ISLOWER( *puc ); }; break; case DO_POS1_POSRANGE: { iDoRet = ( ( ucChar1 <= *puc ) && ( ucChar2 >= *puc ) ); }; break; case DO_POS1_POSUPPER: { iDoRet = ISUPPER( *puc ); }; break; } if( ( iMode && ! iDoRet ) || ( ! iMode && iDoRet ) ) { hb_retns( puc - pcString + 1 ); return; } } hb_retnl( 0 ); } else /* ISCHAR (1) etc. */ { PHB_ITEM pSubst = NULL; int iArgErrorMode = ct_getargerrormode(); if( iArgErrorMode != CT_ARGERR_IGNORE ) { switch( iSwitch ) { case DO_POS1_POSALPHA: { pSubst = ct_error_subst( ( USHORT ) iArgErrorMode, EG_ARG, CT_ERROR_POSALPHA, NULL, "POSALPHA", 0, EF_CANSUBSTITUTE, 3, hb_paramError( 1 ), hb_paramError( 2 ), hb_paramError( 3 ) ); }; break; case DO_POS1_POSLOWER: { pSubst = ct_error_subst( ( USHORT ) iArgErrorMode, EG_ARG, CT_ERROR_POSLOWER, NULL, "POSLOWER", 0, EF_CANSUBSTITUTE, 3, hb_paramError( 1 ), hb_paramError( 2 ), hb_paramError( 3 ) ); }; break; case DO_POS1_POSRANGE: { pSubst = ct_error_subst( ( USHORT ) iArgErrorMode, EG_ARG, CT_ERROR_POSRANGE, NULL, "POSRANGE", 0, EF_CANSUBSTITUTE, 5, hb_paramError( 1 ), hb_paramError( 2 ), hb_paramError( 3 ), hb_paramError( 4 ), hb_paramError( 5 ) ); }; break; case DO_POS1_POSUPPER: { pSubst = ct_error_subst( ( USHORT ) iArgErrorMode, EG_ARG, CT_ERROR_POSUPPER, NULL, "POSUPPER", 0, EF_CANSUBSTITUTE, 3, hb_paramError( 1 ), hb_paramError( 2 ), hb_paramError( 3 ) ); }; break; } } if( pSubst != NULL ) { hb_itemRelease( hb_itemReturnForward( pSubst ) ); } else { hb_retnl( 0 ); } } }
/* helper function for the countxxx functions */ static void do_count( int iSwitch ) { /* param check */ if( ISCHAR( 1 ) ) { const char * pcString = hb_parc( 1 ); size_t sStrLen = ( size_t ) hb_parclen( 1 ); size_t sRetVal; const char * pc; char cSearch; if( hb_parclen( 2 ) > 0 ) cSearch = *( hb_parc( 2 ) ); else if( ISNUM( 2 ) ) cSearch = ( char ) ( hb_parnl( 2 ) % 256 ); else cSearch = 0x20; sRetVal = 0; switch( iSwitch ) { case DO_COUNT_COUNTLEFT: { pc = pcString; while( ( *pc == cSearch ) && ( pc < pcString + sStrLen ) ) { sRetVal++; pc++; } }; break; case DO_COUNT_COUNTRIGHT: { pc = pcString + sStrLen - 1; while( ( *pc == cSearch ) && ( pc >= pcString ) ) { sRetVal++; pc--; } }; break; } hb_retns( sRetVal ); } else /* if (ISCHAR (1)) */ { PHB_ITEM pSubst = NULL; int iArgErrorMode = ct_getargerrormode(); if( iArgErrorMode != CT_ARGERR_IGNORE ) { pSubst = ct_error_subst( ( USHORT ) iArgErrorMode, EG_ARG, ( iSwitch == DO_COUNT_COUNTLEFT ? CT_ERROR_COUNTLEFT : CT_ERROR_COUNTRIGHT ), NULL, ( iSwitch == DO_COUNT_COUNTLEFT ? "COUNTLEFT" : "COUNTRIGHT" ), 0, EF_CANSUBSTITUTE, 2, hb_paramError( 1 ), hb_paramError( 2 ) ); } if( pSubst != NULL ) { hb_itemRelease( hb_itemReturnForward( pSubst ) ); } else { hb_retnl( 0 ); } } }