static HB_SIZE s_fileReadAt( PHB_FILE pFile, void * buffer,
HB_SIZE nSize, HB_FOFFSET nOffset )
{
PHB_IOUSR pIO = ( PHB_IOUSR ) pFile->pFuncs;
HB_SIZE nResult;
int iOffset;
iOffset = ( int ) ( hb_stackTopOffset() - hb_stackBaseOffset() );
memset( buffer, 0, nSize );
hb_vmPushString( ( const char * ) buffer, nSize );
s_pushMethod( pIO, IOUSR_READAT );
hb_vmPush( pFile->pFileItm );
hb_xvmPushLocalByRef( ( HB_SHORT ) iOffset );
hb_vmPushSize( nSize );
hb_vmPushNumInt( ( HB_MAXINT ) nOffset );
hb_vmDo( 4 );
nResult = hb_parns( -1 );
if( nResult > 0 )
{
nSize = hb_itemGetCLen( hb_stackItemFromBase( iOffset ) );
if( nResult > nSize )
nResult = nSize;
memcpy( buffer, hb_itemGetCPtr( hb_stackItemFromBase( iOffset ) ), nSize );
}
hb_stackPop();
return nResult;
}
static HB_FHANDLE s_fileHandle( PHB_FILE pFile )
{
PHB_IOUSR pIO = ( PHB_IOUSR ) pFile->pFuncs;
s_pushMethod( pIO, IOUSR_HANDLE );
hb_vmPush( pFile->pFileItm );
hb_vmDo( 1 );
return ( HB_FHANDLE ) hb_parns( -1 );
}
static HB_SIZE s_fileWriteAt( PHB_FILE pFile, const void * buffer,
HB_SIZE nSize, HB_FOFFSET nOffset )
{
PHB_IOUSR pIO = ( PHB_IOUSR ) pFile->pFuncs;
s_pushMethod( pIO, IOUSR_WRITEAT );
hb_vmPush( pFile->pFileItm );
hb_vmPushString( ( const char * ) buffer, nSize );
hb_vmPushSize( nSize );
hb_vmPushNumInt( ( HB_MAXINT ) nOffset );
hb_vmDo( 4 );
return hb_parns( -1 );
}
static HB_SIZE s_fileWrite( PHB_FILE pFile, const void * data,
HB_SIZE nSize, HB_MAXINT timeout )
{
PHB_IOUSR pIO = ( PHB_IOUSR ) pFile->pFuncs;
s_pushMethod( pIO, IOUSR_WRITE );
hb_vmPush( pFile->pFileItm );
hb_vmPushString( ( const char * ) data, nSize );
hb_vmPushSize( nSize );
hb_vmPushNumInt( timeout );
hb_vmDo( 4 );
return hb_parns( -1 );
}
/* This function creates an array item using 'iDimension' as an index
* to retrieve the number of elements from the parameter list.
*/
static void hb_arrayNewRagged( PHB_ITEM pArray, int iDimension )
{
HB_SIZE nElements;
HB_TRACE( HB_TR_DEBUG, ( "hb_arrayNewRagged(%p, %d)", pArray, iDimension ) );
nElements = hb_parns( iDimension );
/* create an array */
hb_arrayNew( pArray, nElements );
if( ++iDimension <= hb_pcount() )
{
/* call self recursively to create next dimensions
*/
while( nElements )
hb_arrayNewRagged( hb_arrayGetItemPtr( pArray, nElements-- ), iDimension );
}
}
/* helper function */
static void do_atnum( int iSwitch )
{
if( HB_ISCHAR( 1 ) && HB_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 = hb_parnsdef( 4, 0 ); /* eventually ignore some characters */
HB_SIZE sMatchStrLen = 0;
HB_SIZE nCounter;
const char * pc = NULL;
if( sIgnore >= sStrLen )
{
switch( iSwitch )
{
case DO_ATNUM_AFTERATNUM:
{
/* AFTERATNUM */
int iArgErrorMode = ct_getargerrormode();
if( iArgErrorMode != CT_ARGERR_IGNORE )
ct_error( ( HB_USHORT ) iArgErrorMode, EG_ARG, CT_ERROR_AFTERATNUM, NULL,
HB_ERR_FUNCNAME, 0, EF_CANDEFAULT, HB_ERR_ARGS_BASEPARAMS );
hb_retc_null();
break;
}
case DO_ATNUM_BEFORATNUM:
{
/* BEFORATNUM */
int iArgErrorMode = ct_getargerrormode();
if( iArgErrorMode != CT_ARGERR_IGNORE )
ct_error( ( HB_USHORT ) iArgErrorMode, EG_ARG, CT_ERROR_BEFORATNUM, NULL,
HB_ERR_FUNCNAME, 0, EF_CANDEFAULT, HB_ERR_ARGS_BASEPARAMS );
hb_retc_null();
break;
}
case DO_ATNUM_ATNUM:
{
/* ATNUM */
int iArgErrorMode = ct_getargerrormode();
if( iArgErrorMode != CT_ARGERR_IGNORE )
ct_error( ( HB_USHORT ) iArgErrorMode, EG_ARG, CT_ERROR_ATNUM, NULL, HB_ERR_FUNCNAME, 0,
EF_CANDEFAULT, HB_ERR_ARGS_BASEPARAMS );
hb_retns( 0 );
break;
}
}
return;
}
else
{
pcString += sIgnore;
sStrLen -= sIgnore;
}
/* nth match or last match ? */
if( HB_ISNUM( 3 ) && ( nCounter = hb_parns( 3 ) ) != 0 )
{
/* find the <nCounter>th match */
const char * pcSubStr;
HB_SIZE sSubStrLen;
HB_SIZE nMatchCounter = 0;
pcSubStr = pcString;
sSubStrLen = sStrLen;
while( nMatchCounter < nCounter )
{
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 <nCounter> matches, so return an empty string */
switch( iSwitch )
{
case DO_ATNUM_AFTERATNUM:
case DO_ATNUM_BEFORATNUM:
/* AFTERATNUM */
/* BEFORATNUM */
hb_retc_null();
break;
case DO_ATNUM_ATNUM:
/* ATNUM */
hb_retns( 0 );
break;
}
return;
}
nMatchCounter++;
if( iMultiPass )
pcSubStr = pc + 1;
else
pcSubStr = pc + sMatchStrLen;
sSubStrLen = sStrLen - ( pcSubStr - pcString );
}
}
else
{
/* 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_null();
break;
case DO_ATNUM_ATNUM:
/* ATNUM */
hb_retns( 0 );
break;
}
return;
}
}
switch( iSwitch )
{
case DO_ATNUM_AFTERATNUM:
/* AFTERATNUM */
if( pc + sMatchStrLen >= pcString + sStrLen )
hb_retc_null();
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 */
#if defined( __POCC__ ) && ( __POCC__ >= 500 ) && defined( HB_OS_WIN_64 )
/* NOTE: Workaround for Pelles C 5.00.13 AMD64 mode internal error:
'fatal error: Internal error: reduce_tree()' [vszakats]. */
hb_retns( pc - pcString + sIgnore + 1 );
#else
hb_retns( pc - ( pcString - sIgnore ) + 1 );
#endif
break;
}
}
else
{
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( ( HB_USHORT ) iArgErrorMode, EG_ARG,
iSwitch ==
DO_ATNUM_AFTERATNUM ? CT_ERROR_AFTERATNUM :
CT_ERROR_BEFORATNUM, NULL, HB_ERR_FUNCNAME, 0,
EF_CANSUBSTITUTE, HB_ERR_ARGS_BASEPARAMS );
if( pSubst != NULL )
hb_itemReturnRelease( pSubst );
else
hb_retc_null();
break;
}
case DO_ATNUM_ATNUM:
{
/* ATNUM */
PHB_ITEM pSubst = NULL;
int iArgErrorMode = ct_getargerrormode();
if( iArgErrorMode != CT_ARGERR_IGNORE )
pSubst = ct_error_subst( ( HB_USHORT ) iArgErrorMode, EG_ARG, CT_ERROR_ATNUM,
NULL, HB_ERR_FUNCNAME, 0, EF_CANSUBSTITUTE,
HB_ERR_ARGS_BASEPARAMS );
if( pSubst != NULL )
hb_itemReturnRelease( pSubst );
else
hb_retns( 0 );
break;
}
}
}
}
/* helper function for the token function group I */
static void do_token1( int iSwitch )
{
PCT_TOKEN ct_token = ( PCT_TOKEN ) hb_stackGetTSD( &s_ct_token );
int iParamCheck = 0;
int iNoRef = ct_getref() && HB_ISBYREF( 1 );
switch( iSwitch )
{
case DO_TOKEN1_TOKEN:
ct_token->iPreSeparator = ct_token->iPostSeparator = -1;
/* no "break" here !! */
case DO_TOKEN1_ATTOKEN:
case DO_TOKEN1_NUMTOKEN:
case DO_TOKEN1_TOKENLOWER:
case DO_TOKEN1_TOKENUPPER:
iParamCheck = HB_ISCHAR( 1 );
break;
}
if( iParamCheck )
{
const char * pcString = hb_parc( 1 );
HB_SIZE sStrLen = hb_parclen( 1 );
const char * pcSeparatorStr;
HB_SIZE sSeparatorStrLen;
HB_SIZE nTokenCounter;
HB_SIZE nSkip;
const char * pcSubStr;
char * pcRet = NULL;
HB_SIZE sSubStrLen;
HB_SIZE sRetStrLen = 0;
HB_SIZE nToken = 0;
HB_SIZE nSkipCnt;
const char * pc;
/* separator string */
sSeparatorStrLen = hb_parclen( 2 );
if( sSeparatorStrLen != 0 )
pcSeparatorStr = hb_parc( 2 );
else
{
pcSeparatorStr = sc_pcSeparatorStr;
sSeparatorStrLen = sc_sSeparatorStrLen;
}
if( iSwitch == DO_TOKEN1_NUMTOKEN )
{
/* token counter */
nTokenCounter = HB_SIZE_MAX;
/* skip width */
nSkip = hb_parns( 3 );
}
else
{
/* token counter */
nTokenCounter = hb_parns( 3 );
/* skip width */
nSkip = hb_parns( 4 ); /* HB_EXTENSION for AtToken()/TokenLower()/TokenUpper() */
}
if( nTokenCounter == 0 )
nTokenCounter = HB_SIZE_MAX;
if( nSkip == 0 )
nSkip = HB_SIZE_MAX;
/* prepare return value for TokenUpper()/TokenLower() */
if( iSwitch == DO_TOKEN1_TOKENLOWER || iSwitch == DO_TOKEN1_TOKENUPPER )
{
if( sStrLen == 0 )
{
if( iNoRef )
hb_retl( HB_FALSE );
else
hb_retc_null();
return;
}
sRetStrLen = sStrLen;
pcRet = ( char * ) hb_xgrab( sRetStrLen + 1 );
hb_xmemcpy( pcRet, pcString, sRetStrLen );
}
/* find the <nTokenCounter>th token */
pcSubStr = pcString;
sSubStrLen = sStrLen;
/* scan start condition */
pc = pcSubStr - 1;
while( nToken < nTokenCounter )
{
HB_SIZE sMatchedPos = sSeparatorStrLen;
/* Skip the left nSkip successive separators */
nSkipCnt = 0;
do
{
sSubStrLen -= ( pc - pcSubStr ) + 1;
pcSubStr = pc + 1;
pc = ct_at_charset_forward( pcSubStr, sSubStrLen,
pcSeparatorStr, sSeparatorStrLen, &sMatchedPos );
if( iSwitch == DO_TOKEN1_TOKEN )
{
ct_token->iPreSeparator = ct_token->iPostSeparator;
if( sMatchedPos < sSeparatorStrLen )
ct_token->iPostSeparator = pcSeparatorStr[ sMatchedPos ];
else
ct_token->iPostSeparator = -1;
}
nSkipCnt++;
}
while( nSkipCnt < nSkip && pc == pcSubStr );
if( sSubStrLen == 0 )
{
/* string ends with tokenizer (null string after tokenizer at
end of string is not a token) */
switch( iSwitch )
{
case DO_TOKEN1_TOKEN:
{
char cRet;
hb_retc_null();
if( HB_ISBYREF( 5 ) ) /* HB_EXTENSION */
{
cRet = ( char ) ct_token->iPreSeparator;
hb_storclen( &cRet, ( ct_token->iPreSeparator != -1 ? 1 : 0 ), 5 );
}
if( HB_ISBYREF( 6 ) ) /* HB_EXTENSION */
{
cRet = ( char ) ct_token->iPostSeparator;
hb_storclen( &cRet, ( ct_token->iPostSeparator != -1 ? 1 : 0 ), 6 );
}
break;
}
case DO_TOKEN1_NUMTOKEN:
hb_retns( nToken );
break;
case DO_TOKEN1_ATTOKEN:
hb_retns( 0 );
break;
case DO_TOKEN1_TOKENLOWER:
case DO_TOKEN1_TOKENUPPER:
hb_storclen( pcRet, sRetStrLen, 1 );
if( iNoRef )
{
hb_xfree( pcRet );
hb_retl( HB_FALSE );
}
else
hb_retclen_buffer( pcRet, sRetStrLen );
break;
}
return;
}
switch( iSwitch )
{
case DO_TOKEN1_TOKEN:
case DO_TOKEN1_NUMTOKEN:
case DO_TOKEN1_ATTOKEN:
break;
case DO_TOKEN1_TOKENLOWER:
if( pcSubStr != pc ) /* letters can be tokenizers, too,
but they should not be lowercase'd */
*( pcRet + ( pcSubStr - pcString ) ) = ( char ) hb_charLower( ( HB_UCHAR ) *pcSubStr );
break;
case DO_TOKEN1_TOKENUPPER:
if( pcSubStr != pc ) /* letters can be tokenizers, too,
but they should not be uppercase'd */
*( pcRet + ( pcSubStr - pcString ) ) = ( char ) hb_charUpper( ( HB_UCHAR ) *pcSubStr );
break;
default:
break;
}
nToken++;
if( pc == NULL )
{
/* little trick for return values */
pc = pcSubStr + sSubStrLen;
/* we must leave the while loop even if we have not
yet found the <nTokenCounter>th token */
break;
}
/* should we find the last token, but string ends with tokenizer, i.e.
pc points to the last character at the moment ?
-> break here ! */
if( nTokenCounter == HB_SIZE_MAX )
{
if( nSkip == HB_SIZE_MAX )
{
const char * t;
HB_BOOL bLast = HB_TRUE;
for( t = pc + 1; t < pcString + sStrLen; t++ )
{
if( ! memchr( pcSeparatorStr, *t, sSeparatorStrLen ) )
{
bLast = HB_FALSE;
break;
}
}
if( bLast )
break;
}
else if( pc + 1 == pcString + sStrLen )
break;
}
}
switch( iSwitch )
{
case DO_TOKEN1_TOKEN:
{
char cRet;
if( nTokenCounter == HB_SIZE_MAX ||
nToken == nTokenCounter )
hb_retclen( pcSubStr, pc - pcSubStr );
else
hb_retc_null();
if( HB_ISBYREF( 5 ) ) /* HB_EXTENSION */
{
cRet = ( char ) ct_token->iPreSeparator;
hb_storclen( &cRet, ( ct_token->iPreSeparator != -1 ? 1 : 0 ), 5 );
}
if( HB_ISBYREF( 6 ) ) /* HB_EXTENSION */
{
cRet = ( char ) ct_token->iPostSeparator;
hb_storclen( &cRet, ( ct_token->iPostSeparator != -1 ? 1 : 0 ), 6 );
}
break;
}
case DO_TOKEN1_NUMTOKEN:
hb_retns( nToken );
break;
case DO_TOKEN1_ATTOKEN:
if( nTokenCounter == HB_SIZE_MAX ||
nToken == nTokenCounter )
hb_retns( pcSubStr - pcString + 1 );
else
hb_retns( 0 );
break;
case DO_TOKEN1_TOKENLOWER:
case DO_TOKEN1_TOKENUPPER:
hb_storclen( pcRet, sRetStrLen, 1 );
if( iNoRef )
{
hb_xfree( pcRet );
hb_retl( HB_FALSE );
}
else
hb_retclen_buffer( pcRet, sRetStrLen );
break;
}
}
else
{
switch( iSwitch )
{
case DO_TOKEN1_TOKEN:
{
PHB_ITEM pSubst = NULL;
int iArgErrorMode = ct_getargerrormode();
char cRet;
if( HB_ISBYREF( 5 ) ) /* HB_EXTENSION */
{
cRet = ( char ) ct_token->iPreSeparator;
hb_storclen( &cRet, ( ct_token->iPreSeparator != -1 ? 1 : 0 ), 5 );
}
if( HB_ISBYREF( 6 ) ) /* HB_EXTENSION */
{
cRet = ( char ) ct_token->iPostSeparator;
hb_storclen( &cRet, ( ct_token->iPostSeparator != -1 ? 1 : 0 ), 6 );
}
if( iArgErrorMode != CT_ARGERR_IGNORE )
pSubst = ct_error_subst( ( HB_USHORT ) iArgErrorMode, EG_ARG,
CT_ERROR_TOKEN, NULL, HB_ERR_FUNCNAME, 0,
EF_CANSUBSTITUTE,
HB_ERR_ARGS_BASEPARAMS );
if( pSubst != NULL )
hb_itemReturnRelease( pSubst );
else if( ! iNoRef )
hb_retc_null();
else
hb_retl( HB_FALSE );
break;
}
case DO_TOKEN1_TOKENLOWER:
case DO_TOKEN1_TOKENUPPER:
{
PHB_ITEM pSubst = NULL;
int iArgErrorMode = ct_getargerrormode();
if( iArgErrorMode != CT_ARGERR_IGNORE )
pSubst = ct_error_subst( ( HB_USHORT ) iArgErrorMode, EG_ARG,
iSwitch == DO_TOKEN1_TOKENLOWER ?
CT_ERROR_TOKENLOWER : CT_ERROR_TOKENUPPER,
NULL, HB_ERR_FUNCNAME, 0,
EF_CANSUBSTITUTE,
HB_ERR_ARGS_BASEPARAMS );
if( pSubst != NULL )
hb_itemReturnRelease( pSubst );
else if( ! iNoRef )
hb_retc_null();
else
hb_retl( HB_FALSE );
break;
}
case DO_TOKEN1_NUMTOKEN:
case DO_TOKEN1_ATTOKEN:
{
PHB_ITEM pSubst = NULL;
int iArgErrorMode = ct_getargerrormode();
if( iArgErrorMode != CT_ARGERR_IGNORE )
pSubst = ct_error_subst( ( HB_USHORT ) iArgErrorMode, EG_ARG,
iSwitch == DO_TOKEN1_NUMTOKEN ?
CT_ERROR_NUMTOKEN : CT_ERROR_ATTOKEN,
NULL, HB_ERR_FUNCNAME, 0,
EF_CANSUBSTITUTE, HB_ERR_ARGS_BASEPARAMS );
if( pSubst != NULL )
hb_itemReturnRelease( pSubst );
else
hb_retns( 0 );
break;
}
}
}
}
/* 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();
}
}
