static void s_getPathName( _HB_GETPATHNAME getPathName ) { void * hLongPath; DWORD length = 0; LPCTSTR lpszLongPath = HB_PARSTR( 1, &hLongPath, NULL ); if( lpszLongPath ) { if( HB_ISBYREF( 2 ) ) { TCHAR buffer[ HB_PATH_MAX ]; DWORD cchBuffer = ( DWORD ) HB_SIZEOFARRAY( buffer ); LPTSTR lpszShortPath = buffer; HB_BOOL fSize = HB_ISNUM( 3 ); if( fSize ) /* the size of buffer is limited by user */ { cchBuffer = ( DWORD ) hb_parnl( 3 ); if( cchBuffer == 0 ) lpszShortPath = NULL; else if( cchBuffer > ( DWORD ) HB_SIZEOFARRAY( buffer ) ) lpszShortPath = ( LPTSTR ) hb_xgrab( cchBuffer * sizeof( TCHAR ) ); } length = getPathName( lpszLongPath, lpszShortPath, cchBuffer ); if( ! fSize && length > cchBuffer ) /* default buffer size was too small */ { cchBuffer = length; lpszShortPath = ( LPTSTR ) hb_xgrab( cchBuffer * sizeof( TCHAR ) ); length = getPathName( lpszLongPath, lpszShortPath, cchBuffer ); } hbwapi_SetLastError( GetLastError() ); HB_STORSTRLEN( lpszShortPath, length > cchBuffer ? 0 : length, 2 ); if( lpszShortPath && lpszShortPath != buffer ) hb_xfree( lpszShortPath ); } else if( getPathName ) { length = getPathName( lpszLongPath, NULL, 0 ); hbwapi_SetLastError( GetLastError() ); } } hb_retnl( length ); hb_strfree( hLongPath ); }
/* 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 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 ); } } }