static char * hb_mlGetParams( int iParAdd, ULONG * pulLen, ULONG * pulLineLength, ULONG * pulTabSize, BOOL * pfWordWrap, PHB_EOL_INFO * pEOLs, int * piEOLs ) { char * pszString = hb_parc( 1 ); if( pszString ) { if( ISNUM( 2 ) ) { if( hb_parnd( 2 ) <= 0 ) return NULL; * pulLineLength = hb_parnl( 2 ); } else * pulLineLength = 79; * pulLen = hb_parclen( 1 ); * pulTabSize = ISNUM( 3 + iParAdd ) ? hb_parnl( 3 + iParAdd ) : 4; * pfWordWrap = ISLOG( 4 + iParAdd ) ? hb_parl( 4 + iParAdd ) : TRUE; * pEOLs = hb_mlGetEOLs( 5 + iParAdd, piEOLs ); #ifdef HB_C52_STRICT if( * pulLineLength > 254 ) * pulLineLength = 79; #endif if( * pulTabSize >= * pulLineLength ) * pulTabSize = * pulLineLength - 1; else if( * pulTabSize == 0 ) * pulTabSize = 1; } return pszString; }
static PHB_FFIND _hb_fileStart( HB_BOOL fNext, HB_FATTR ulAttr ) { PHB_FFDATA pFFData = HB_GET_FFDATA(); if( hb_pcount() > 0 ) { const char * szFile = hb_parc( 1 ); if( pFFData->ffind ) { hb_fsFindClose( pFFData->ffind ); pFFData->ffind = NULL; } if( szFile ) { if( HB_ISNUM( 2 ) ) ulAttr = ( HB_FATTR ) hb_parnl( 2 ); pFFData->ulAttr = hb_parl( 3 ) ? ulAttr : HB_FA_ALL; pFFData->ffind = hb_fsFindFirst( szFile, ulAttr ); while( pFFData->ffind && pFFData->ulAttr && pFFData->ffind->attr != pFFData->ulAttr ) { if( ! hb_fsFindNext( pFFData->ffind ) ) { hb_fsFindClose( pFFData->ffind ); pFFData->ffind = NULL; } } } } else if( fNext && pFFData->ffind ) { do { if( ! hb_fsFindNext( pFFData->ffind ) ) { hb_fsFindClose( pFFData->ffind ); pFFData->ffind = NULL; break; } } while( pFFData->ulAttr && pFFData->ffind->attr != pFFData->ulAttr ); } return pFFData->ffind; }
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 ); }
/* wxSocketBase_ReadBase Teo. Mexico 2009 */ void wxSocketBase_ReadBase( HB_BYTE type ) { PHB_ITEM pSelf = hb_stackSelfItem(); wx_SocketBase* socketBase = (wx_SocketBase*) xho_itemListGet_XHO( pSelf ); PHB_ITEM pBuffer = hb_param( 1, HB_IT_STRING ); if( pBuffer == NULL || !HB_ISBYREF( 1 ) ) { hb_errRT_BASE_SubstR( EG_ARG, WXH_ERRBASE + 10, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS ); return; } if( socketBase ) { pBuffer = hb_itemUnShareString( pBuffer ); wxUint32 nbytes = HB_ISNIL( 2 ) ? hb_itemGetCLen( pBuffer ) : hb_parnl( 2 ); if( nbytes > 0 ) { if( nbytes > hb_itemGetCLen( pBuffer ) ) hb_itemReSizeString( pBuffer, nbytes ); if( type == '0' ) socketBase->Read( (char *) hb_itemGetCPtr( pBuffer ), nbytes ); else socketBase->ReadMsg( (char *) hb_itemGetCPtr( pBuffer ), nbytes ); wxUint32 uiLastCount = socketBase->LastCount(); if( uiLastCount < hb_itemGetCLen( pBuffer ) ) // hb_itemGetCLen( pBuffer ) = uiLastCount; hb_itemReSizeString( pBuffer, uiLastCount ); }else hb_errRT_BASE_SubstR( EG_ARG, WXH_ERRBASE + 10, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS ); hb_itemReturn( pSelf ); } }
BOOL CALLBACK WvgDialogProcChooseFont( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam ) { HB_BOOL bret = HB_FALSE; HB_BOOL binit = HB_FALSE; PHB_ITEM block; if( msg == WM_INITDIALOG ) { CHOOSEFONT * cf = ( CHOOSEFONT * ) lParam; PHB_ITEM pBlock = ( PHB_ITEM ) hb_itemNew( ( PHB_ITEM ) cf->lCustData ); SetProp( hwnd, TEXT( "DIALOGPROC" ), pBlock ); binit = HB_TRUE; } block = ( PHB_ITEM ) GetProp( hwnd, TEXT( "DIALOGPROC" ) ); if( block ) { hb_vmPushEvalSym(); hb_vmPush( block ); hb_vmPushNumInt( ( HB_PTRUINT ) hwnd ); hb_vmPushInteger( msg ); hb_vmPushNumInt( ( HB_PTRUINT ) wParam ); hb_vmPushNumInt( ( HB_PTRUINT ) lParam ); hb_vmDo( 4 ); bret = hb_parnl( -1 ); if( msg == WM_NCDESTROY ) { RemoveProp( hwnd, TEXT( "DIALOGPROC" ) ); hb_itemRelease( block ); } } if( binit ) return HB_TRUE; return bret; }
/* 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 remxxx functions */ static void do_remove( int iSwitch ) { /* param check */ if( HB_ISCHAR( 1 ) ) { const char * pcString = hb_parc( 1 ); HB_SIZE sStrLen = hb_parclen( 1 ); const char * pcRet; const char * pc; HB_SIZE sRetLen; char cSearch; if( hb_parclen( 2 ) > 0 ) cSearch = *( hb_parc( 2 ) ); else if( HB_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_null(); else hb_retclen( pcRet, sRetLen ); } else { PHB_ITEM pSubst = NULL; int iArgErrorMode = ct_getargerrormode(); if( iArgErrorMode != CT_ARGERR_IGNORE ) pSubst = ct_error_subst( ( HB_USHORT ) iArgErrorMode, EG_ARG, sulErrorSubcodes[ iSwitch ], NULL, HB_ERR_FUNCNAME, 0, EF_CANSUBSTITUTE, HB_ERR_ARGS_BASEPARAMS ); if( pSubst != NULL ) hb_itemReturnRelease( pSubst ); else hb_retc_null(); } }
/* helper function for the Count*() functions */ static void do_count( int iSwitch ) { /* param check */ if( HB_ISCHAR( 1 ) ) { const char * pcString = hb_parc( 1 ); HB_SIZE sStrLen = hb_parclen( 1 ); HB_SIZE sRetVal; const char * pc; char cSearch; if( hb_parclen( 2 ) > 0 ) cSearch = *( hb_parc( 2 ) ); else if( HB_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 { PHB_ITEM pSubst = NULL; int iArgErrorMode = ct_getargerrormode(); if( iArgErrorMode != CT_ARGERR_IGNORE ) pSubst = ct_error_subst( ( HB_USHORT ) iArgErrorMode, EG_ARG, iSwitch == DO_COUNT_COUNTLEFT ? CT_ERROR_COUNTLEFT : CT_ERROR_COUNTRIGHT, NULL, HB_ERR_FUNCNAME, 0, EF_CANSUBSTITUTE, HB_ERR_ARGS_BASEPARAMS ); if( pSubst != NULL ) hb_itemReturnRelease( pSubst ); else hb_retns( 0 ); } }
/* helper function for the replxxx functions */ static void do_replace( int iSwitch ) { /* suppressing return value ? */ int iNoRet = ct_getref() && HB_ISBYREF( 1 ); /* param check */ if( HB_ISCHAR( 1 ) && ( hb_parclen( 2 ) > 0 || HB_ISNUM( 2 ) ) ) { const char * pcString = hb_parc( 1 ); HB_SIZE sStrLen = hb_parclen( 1 ); char * pcRet, * pc; char cSearch, cReplace; if( sStrLen == 0 ) { if( iNoRet ) hb_ret(); else hb_retc_null(); return; } if( HB_ISNUM( 2 ) ) cReplace = ( char ) ( hb_parnl( 2 ) % 256 ); else cReplace = *( ( const char * ) hb_parc( 2 ) ); if( hb_parclen( 3 ) > 0 ) cSearch = *( ( const char * ) hb_parc( 3 ) ); else if( HB_ISNUM( 3 ) ) cSearch = ( char ) ( hb_parnl( 3 ) % 256 ); else cSearch = 0x20; pcRet = ( char * ) hb_xgrab( sStrLen + 1 ); hb_xmemcpy( pcRet, pcString, sStrLen ); if( iSwitch != DO_REPLACE_REPLRIGHT ) { pc = pcRet; while( *pc == cSearch && pc < pcRet + sStrLen ) { *pc = cReplace; pc++; } } if( iSwitch != DO_REPLACE_REPLLEFT ) { pc = pcRet + sStrLen - 1; while( *pc == cSearch && pc >= pcRet ) { *pc = cReplace; pc--; } } hb_storclen( pcRet, sStrLen, 1 ); if( iNoRet ) { hb_xfree( pcRet ); hb_ret(); } else hb_retclen_buffer( pcRet, sStrLen ); } else { PHB_ITEM pSubst = NULL; int iArgErrorMode = ct_getargerrormode(); if( iArgErrorMode != CT_ARGERR_IGNORE ) pSubst = ct_error_subst( ( HB_USHORT ) iArgErrorMode, EG_ARG, sulErrorSubcodes[ iSwitch ], NULL, HB_ERR_FUNCNAME, 0, EF_CANSUBSTITUTE, HB_ERR_ARGS_BASEPARAMS ); if( pSubst != NULL ) hb_itemReturnRelease( pSubst ); else if( iNoRet ) hb_ret(); else hb_retc_null(); } }
/* 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 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; }
PHB_ITEM hb_i18n_ngettext( PHB_ITEM pNum, PHB_ITEM pMsgID, PHB_ITEM pContext ) { PHB_I18N_TRANS pI18N = hb_i18n_table(); PHB_CODEPAGE cdpage = NULL; PHB_ITEM pMsgDst = pMsgID; PHB_ITEM pBlock = NULL; int iPluralForm = 0; if( pI18N ) { PHB_ITEM pTable = pContext && pI18N->context_table ? hb_hashGetItemPtr( pI18N->context_table, pContext, 0 ) : pI18N->default_context; cdpage = pI18N->base_cdpage; pBlock = pI18N->base_plural_block; iPluralForm = pI18N->base_plural_form; if( pTable ) { PHB_ITEM pMsg = HB_IS_ARRAY( pMsgID ) ? hb_arrayGetItemPtr( pMsgID, 1 ) : pMsgID; pTable = pMsg && HB_IS_STRING( pMsg ) ? hb_hashGetItemPtr( pTable, pMsg, 0 ) : NULL; if( pTable ) { if( HB_IS_STRING( pTable ) || ( HB_IS_ARRAY( pTable ) && ( hb_arrayGetType( pTable, 1 ) & HB_IT_STRING ) != 0 ) ) { pMsgID = pTable; cdpage = pI18N->cdpage; pBlock = pI18N->plural_block; iPluralForm = pI18N->plural_form; } } } } if( pMsgID && HB_IS_ARRAY( pMsgID ) ) { long lIndex; if( ! pNum ) lIndex = 1; else if( pBlock ) { hb_evalBlock1( pBlock, pNum ); lIndex = hb_parnl( -1 ); } else lIndex = hb_i18n_pluralindex( iPluralForm, pNum ); if( lIndex < 1 || ( lIndex != 1 && ( hb_arrayGetType( pMsgID, lIndex ) & HB_IT_STRING ) == 0 ) ) lIndex = 1; pMsgID = hb_arrayGetItemPtr( pMsgID, lIndex ); } if( pMsgID ) { if( HB_IS_STRING( pMsgID ) ) { if( cdpage ) { PHB_CODEPAGE cdp = hb_vmCDP(); if( cdp && cdp != cdpage ) { if( pMsgDst != pMsgID ) { hb_itemCopy( pMsgDst, pMsgID ); pMsgID = pMsgDst; } hb_i18n_transitm( pMsgID, cdpage, cdp ); } } } else pMsgID = NULL; } return pMsgID; }
/* 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 pad functions */ static void do_pad( int iSwitch ) { if( HB_ISCHAR( 1 ) && HB_ISNUM( 2 ) ) { const char * pcString = hb_parc( 1 ); HB_SIZE sStrLen = hb_parclen( 1 ); char * pcRet, * pc; HB_ISIZ nRetLen; HB_SIZE sRetLen; char cFill; nRetLen = hb_parns( 2 ); if( nRetLen <= 0 ) { int iArgErrorMode = ct_getargerrormode(); if( iArgErrorMode != CT_ARGERR_IGNORE ) ct_error( ( HB_USHORT ) iArgErrorMode, EG_ARG, iSwitch == DO_PAD_PADLEFT ? CT_ERROR_PADLEFT : CT_ERROR_PADRIGHT, NULL, HB_ERR_FUNCNAME, 0, EF_CANDEFAULT, HB_ERR_ARGS_BASEPARAMS ); hb_retc_null(); return; } sRetLen = ( HB_SIZE ) nRetLen; if( hb_parclen( 3 ) > 0 ) cFill = *( hb_parc( 3 ) ); else if( HB_ISNUM( 3 ) ) cFill = ( char ) ( hb_parnl( 3 ) % 256 ); else cFill = 0x20; pcRet = ( char * ) hb_xgrab( sRetLen + 1 ); 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_buffer( pcRet, sRetLen ); } else { PHB_ITEM pSubst = NULL; int iArgErrorMode = ct_getargerrormode(); if( iArgErrorMode != CT_ARGERR_IGNORE ) pSubst = ct_error_subst( ( HB_USHORT ) iArgErrorMode, EG_ARG, iSwitch == DO_PAD_PADLEFT ? CT_ERROR_PADLEFT : CT_ERROR_PADRIGHT, NULL, HB_ERR_FUNCNAME, 0, EF_CANSUBSTITUTE, HB_ERR_ARGS_BASEPARAMS ); if( pSubst != NULL ) hb_itemReturnRelease( pSubst ); else hb_retc_null(); } }
/* helper function for the justxxx() functions */ static void do_justify( int iSwitch ) { int iNoRet; iNoRet = ct_getref() && ISBYREF( 1 ); if( ISCHAR( 1 ) ) { const char * pcString = hb_parc( 1 ); HB_SIZE sStrLen = hb_parclen( 1 ); char cJustChar; const char * pc; char * pcRet, * pcw; HB_SIZE sJustOffset; if( sStrLen == 0 ) { if( iNoRet ) hb_ret(); else hb_retc_null(); 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 + 1 ); switch( iSwitch ) { case DO_JUSTIFY_JUSTLEFT: pc = pcString; sJustOffset = 0; while( ( *pc == cJustChar ) && ( pc < pcString + sStrLen ) ) { sJustOffset++; pc++; } hb_xmemcpy( pcRet, pcString + sJustOffset, (size_t) ( sStrLen - sJustOffset ) ); for( pcw = pcRet + sStrLen - sJustOffset; pcw < pcRet + sStrLen; pcw++ ) { *pcw = cJustChar; } break; case DO_JUSTIFY_JUSTRIGHT: pc = pcString + sStrLen - 1; sJustOffset = 0; while( ( *pc == cJustChar ) && ( pc >= pcString ) ) { sJustOffset++; pc--; } for( pcw = pcRet; pcw < pcRet + sJustOffset; pcw++ ) { *pcw = cJustChar; } hb_xmemcpy( pcRet + sJustOffset, pcString, (size_t) ( sStrLen - sJustOffset ) ); break; } if( ISBYREF( 1 ) ) hb_storclen( pcRet, sStrLen, 1 ); if( iNoRet ) { hb_ret(); hb_xfree( pcRet ); } else hb_retclen_buffer( pcRet, sStrLen ); } 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, HB_ERR_FUNCNAME, 0, EF_CANSUBSTITUTE, HB_ERR_ARGS_BASEPARAMS ); } if( pSubst != NULL ) hb_itemReturnRelease( pSubst ); else if( iNoRet ) hb_ret(); else hb_retc_null(); } }
/* 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 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 ); } } }