static HB_BOOL hb_tokenParam( int iParam, HB_SIZE nSkip,
const char ** pszLine, HB_SIZE * pnLen,
const char ** pszDelim, HB_SIZE * pnDelim,
int * piFlags )
{
const char * szLine = hb_parc( 1 ), * szDelim = NULL;
HB_SIZE nLen = hb_parclen( 1 ), nDelim = 0;
int iFlags = 0;
if( nLen )
{
if( nSkip )
{
szLine += nSkip;
if( nLen <= nSkip )
nLen = 0;
else
nLen -= nSkip;
}
nDelim = hb_parclen( iParam );
if( nDelim )
{
szDelim = hb_parc( iParam );
iFlags |= _HB_TOK_ISDELIM;
}
else
{
szDelim = " ";
nDelim = 1;
}
if( ( iFlags & _HB_TOK_ISDELIM ) == 0 )
{
while( nLen && *szLine == szDelim[ 0 ] )
{
++szLine;
--nLen;
}
while( nLen && szLine[ nLen - 1 ] == szDelim[ 0 ] )
--nLen;
}
if( hb_parl( iParam + 1 ) )
{
iFlags |= _HB_TOK_RESPECT_DQUOTE | _HB_TOK_RESPECT_SQUOTE;
if( hb_parl( iParam + 2 ) )
iFlags &= ~_HB_TOK_RESPECT_SQUOTE;
}
else
iFlags |= hb_parni( iParam + 1 );
}
*pnLen = nLen;
*pnDelim = nDelim;
*pszLine = szLine;
*pszDelim = szDelim;
*piFlags = iFlags;
return szLine != NULL;
}
static HB_BOOL s_fileTimeGet( PHB_FILE_FUNCS pFuncs, const char * pszFileName, long * plJulian, long * plMillisec )
{
PHB_IOUSR pIO = ( PHB_IOUSR ) pFuncs;
HB_BOOL fResult;
int iOffset;
iOffset = ( int ) ( hb_stackTopOffset() - hb_stackBaseOffset() );
hb_vmPushNil();
hb_vmPushNil();
s_pushMethod( pIO, IOUSR_TIMEGET );
hb_vmPushString( pszFileName, strlen( pszFileName ) );
hb_xvmPushLocalByRef( ( HB_SHORT ) iOffset );
hb_xvmPushLocalByRef( ( HB_SHORT ) ( iOffset + 1 ) );
hb_vmDo( 3 );
fResult = hb_parl( -1 );
if( fResult )
{
*plJulian = hb_itemGetNL( hb_stackItemFromBase( iOffset ) );
*plMillisec = hb_itemGetNL( hb_stackItemFromBase( iOffset + 1 ) );
}
hb_stackPop();
hb_stackPop();
return fResult;
}
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 void SetGet( int iFlag )
{
int iState = 0;
HB_GT_INFO gtInfo;
memset( >Info, 0, sizeof( gtInfo ) );
hb_gtInfo( HB_GTI_KBDSHIFTS, >Info );
if( gtInfo.pResult )
{
iState = hb_itemGetNI( gtInfo.pResult );
gtInfo.pNewVal = gtInfo.pResult;
gtInfo.pResult = NULL;
}
if( HB_ISLOG( 1 ) )
{
gtInfo.pNewVal = hb_itemPutNI( gtInfo.pNewVal,
hb_parl( 1 ) ? ( iState | iFlag ) : ( iState & ~iFlag ) );
hb_gtInfo( HB_GTI_KBDSHIFTS, >Info );
}
if( gtInfo.pNewVal )
hb_itemRelease( gtInfo.pNewVal );
if( gtInfo.pResult )
hb_itemRelease( gtInfo.pResult );
hb_retl( ( iState & iFlag ) != 0 );
}
static HB_BOOL s_fileDelete( PHB_FILE_FUNCS pFuncs, const char * pszFileName )
{
PHB_IOUSR pIO = ( PHB_IOUSR ) pFuncs;
s_pushMethod( pIO, IOUSR_DELETE );
hb_vmPushString( pszFileName, strlen( pszFileName ) );
hb_vmDo( 1 );
return hb_parl( -1 );
}
static HB_BOOL s_fileEof( PHB_FILE pFile )
{
PHB_IOUSR pIO = ( PHB_IOUSR ) pFile->pFuncs;
s_pushMethod( pIO, IOUSR_EOF );
hb_vmPush( pFile->pFileItm );
hb_vmDo( 1 );
return hb_parl( -1 );
}
static HB_BOOL s_fileDirRemove( PHB_FILE_FUNCS pFuncs, const char * pszDirName )
{
PHB_IOUSR pIO = ( PHB_IOUSR ) pFuncs;
s_pushMethod( pIO, IOUSR_DIRREMOVE );
hb_vmPushString( pszDirName, strlen( pszDirName ) );
hb_vmDo( 1 );
return hb_parl( -1 );
}
static HB_BOOL s_fileRename( PHB_FILE_FUNCS pFuncs, const char * pszName, const char * pszNewName )
{
PHB_IOUSR pIO = ( PHB_IOUSR ) pFuncs;
s_pushMethod( pIO, IOUSR_RENAME );
hb_vmPushString( pszName, strlen( pszName ) );
hb_vmPushString( pszNewName, strlen( pszNewName ) );
hb_vmDo( 2 );
return hb_parl( -1 );
}
static HB_BOOL s_fileTruncAt( PHB_FILE pFile, HB_FOFFSET nOffset )
{
PHB_IOUSR pIO = ( PHB_IOUSR ) pFile->pFuncs;
s_pushMethod( pIO, IOUSR_TRUNCAT );
hb_vmPush( pFile->pFileItm );
hb_vmPushNumInt( ( HB_MAXINT ) nOffset );
hb_vmDo( 2 );
return hb_parl( -1 );
}
static HB_BOOL s_fileAttrSet( PHB_FILE_FUNCS pFuncs, const char * pszFileName, HB_FATTR nAttr )
{
PHB_IOUSR pIO = ( PHB_IOUSR ) pFuncs;
s_pushMethod( pIO, IOUSR_ATTRSET );
hb_vmPushString( pszFileName, strlen( pszFileName ) );
hb_vmPushLong( nAttr );
hb_vmDo( 2 );
return hb_parl( -1 );
}
static HB_BOOL s_fileCopy( PHB_FILE_FUNCS pFuncs, const char * pSrcFile, const char * pszDstFile )
{
PHB_IOUSR pIO = ( PHB_IOUSR ) pFuncs;
s_pushMethod( pIO, IOUSR_COPY );
hb_vmPushString( pSrcFile, strlen( pSrcFile ) );
hb_vmPushString( pszDstFile, strlen( pszDstFile ) );
hb_vmDo( 2 );
return hb_parl( -1 );
}
static HB_BOOL s_fileLinkSym( PHB_FILE_FUNCS pFuncs, const char * pszTarget, const char * pszNewName )
{
PHB_IOUSR pIO = ( PHB_IOUSR ) pFuncs;
s_pushMethod( pIO, IOUSR_LINKSYM );
hb_vmPushString( pszTarget, strlen( pszTarget ) );
hb_vmPushString( pszNewName, strlen( pszNewName ) );
hb_vmDo( 2 );
return hb_parl( -1 );
}
static HB_BOOL s_fileTimeSet( PHB_FILE_FUNCS pFuncs, const char * pszFileName, long lJulian, long lMillisec )
{
PHB_IOUSR pIO = ( PHB_IOUSR ) pFuncs;
s_pushMethod( pIO, IOUSR_TIMESET );
hb_vmPushString( pszFileName, strlen( pszFileName ) );
hb_vmPushLong( lJulian );
hb_vmPushLong( lMillisec );
hb_vmDo( 3 );
return hb_parl( -1 );
}
static HB_BOOL s_fileExists( PHB_FILE_FUNCS pFuncs, const char * pszFileName, char * pRetPath )
{
PHB_IOUSR pIO = ( PHB_IOUSR ) pFuncs;
HB_SYMBOL_UNUSED( pRetPath );
s_pushMethod( pIO, IOUSR_EXISTS );
hb_vmPushString( pszFileName, strlen( pszFileName ) );
hb_vmDo( 1 );
return hb_parl( -1 );
}
static HB_BOOL s_fileConfigure( PHB_FILE pFile, int iIndex, PHB_ITEM pValue )
{
PHB_IOUSR pIO = ( PHB_IOUSR ) pFile->pFuncs;
s_pushMethod( pIO, IOUSR_CONFIGURE );
hb_vmPush( pFile->pFileItm );
hb_vmPushInteger( iIndex );
if( pValue != NULL )
hb_vmPush( pValue );
hb_vmDo( pValue != NULL ? 3 : 2 );
return hb_parl( -1 );
}
static HB_BOOL s_fileLock( PHB_FILE pFile, HB_FOFFSET nStart,
HB_FOFFSET nLen, int iType )
{
PHB_IOUSR pIO = ( PHB_IOUSR ) pFile->pFuncs;
s_pushMethod( pIO, IOUSR_LOCK );
hb_vmPush( pFile->pFileItm );
hb_vmPushNumInt( ( HB_MAXINT ) nStart );
hb_vmPushNumInt( ( HB_MAXINT ) nLen );
hb_vmPushInteger( iType );
hb_vmDo( 4 );
return hb_parl( -1 );
}
static PHB_FFIND _hb_fileStart( HB_BOOL fNext, HB_BOOL fAny )
{
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 )
{
HB_FATTR ulAttr;
ulAttr = ( HB_FATTR ) hb_parnldef( 2, fAny ? HB_FA_ANY : HB_FA_ALL );
pFFData->ulAttr = hb_parl( 3 ) ? ulAttr : 0;
pFFData->ffind = hb_fsFindFirst( szFile, ulAttr );
while( pFFData->ffind && pFFData->ulAttr &&
HB_FF_ATTR( pFFData->ffind ) != 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 && HB_FF_ATTR( pFFData->ffind ) != pFFData->ulAttr );
}
return pFFData->ffind;
}
static HB_BOOL s_fileAccept( PHB_FILE_FUNCS pFuncs, const char * pszFileName )
{
PHB_IOUSR pIO = ( PHB_IOUSR ) pFuncs;
HB_BOOL fResult = HB_FALSE;
if( hb_strnicmp( pszFileName, pIO->prefix, pIO->prefix_len ) == 0 )
{
if( s_hasMethod( pIO, IOUSR_ACCEPT ) )
{
s_pushMethod( pIO, IOUSR_ACCEPT );
hb_vmPushString( pszFileName, strlen( pszFileName ) );
hb_vmDo( 1 );
fResult = hb_parl( -1 );
}
else if( pIO->prefix_len > 0 )
fResult = HB_TRUE;
}
return fResult;
}
static HB_BOOL s_fileAttrGet( PHB_FILE_FUNCS pFuncs, const char * pszFileName, HB_FATTR * pnAttr )
{
PHB_IOUSR pIO = ( PHB_IOUSR ) pFuncs;
HB_BOOL fResult;
int iOffset;
iOffset = ( int ) ( hb_stackTopOffset() - hb_stackBaseOffset() );
hb_vmPushNil();
s_pushMethod( pIO, IOUSR_ATTRGET );
hb_vmPushString( pszFileName, strlen( pszFileName ) );
hb_xvmPushLocalByRef( ( HB_SHORT ) iOffset );
hb_vmDo( 2 );
fResult = hb_parl( -1 );
if( fResult )
*pnAttr = ( HB_FATTR ) hb_itemGetNL( hb_stackItemFromBase( iOffset ) );
hb_stackPop();
return fResult;
}
/* helper function for the charswap and wordswap functions */
static void do_charswap( int iSwitch )
{
/* suppress return value ? */
int iNoRet = ct_getref() && HB_ISBYREF( 1 );
/* param check */
if( HB_ISCHAR( 1 ) )
{
const char * pcString = hb_parc( 1 );
HB_SIZE sStrLen = hb_parclen( 1 );
char * pcRet;
HB_SIZE sRetIndex = 0;
int iShift, iMod;
const char * pcSub;
if( sStrLen == 0 )
{
if( iNoRet )
hb_ret();
else
hb_retc_null();
return;
}
if( iSwitch == DO_CHARSWAP_WORDSWAP )
{
iShift = 4;
if( hb_parl( 2 ) )
iSwitch = DO_CHARSWAP_WORDSWAP_CHARSWAP;
}
else
iShift = 2;
pcRet = ( char * ) hb_xgrab( sStrLen );
for( pcSub = pcString; pcSub < pcString + sStrLen + 1 - iShift; pcSub += iShift )
{
switch( iSwitch )
{
case DO_CHARSWAP_WORDSWAP:
pcRet[ sRetIndex++ ] = pcSub[ 2 ];
pcRet[ sRetIndex++ ] = pcSub[ 3 ];
pcRet[ sRetIndex++ ] = pcSub[ 0 ];
pcRet[ sRetIndex++ ] = pcSub[ 1 ];
break;
case DO_CHARSWAP_WORDSWAP_CHARSWAP:
pcRet[ sRetIndex++ ] = pcSub[ 3 ];
pcRet[ sRetIndex++ ] = pcSub[ 2 ];
/* no 'break' here !! */
case DO_CHARSWAP_CHARSWAP:
pcRet[ sRetIndex++ ] = pcSub[ 1 ];
pcRet[ sRetIndex++ ] = pcSub[ 0 ];
}
}
/* copy rest of string */
if( iSwitch == DO_CHARSWAP_WORDSWAP || iSwitch == DO_CHARSWAP_WORDSWAP_CHARSWAP )
iMod = sStrLen % 4;
else
iMod = sStrLen % 2;
for( pcSub = pcString + sStrLen - iMod; pcSub < pcString + sStrLen; pcSub++ )
pcRet[ sRetIndex++ ] = *pcSub;
/* return string */
hb_storclen( pcRet, sRetIndex, 1 );
if( iNoRet )
hb_retl( HB_FALSE );
else
hb_retclen( pcRet, sRetIndex );
hb_xfree( pcRet );
}
else
{
PHB_ITEM pSubst = NULL;
int iArgErrorMode = ct_getargerrormode();
if( iArgErrorMode != CT_ARGERR_IGNORE )
{
if( iSwitch == DO_CHARSWAP_CHARSWAP )
pSubst = ct_error_subst( ( HB_USHORT ) iArgErrorMode, EG_ARG,
CT_ERROR_CHARSWAP,
NULL, HB_ERR_FUNCNAME, 0, EF_CANSUBSTITUTE,
HB_ERR_ARGS_BASEPARAMS );
else
pSubst = ct_error_subst( ( HB_USHORT ) iArgErrorMode, EG_ARG,
CT_ERROR_WORDSWAP,
NULL, HB_ERR_FUNCNAME, 0, EF_CANSUBSTITUTE,
HB_ERR_ARGS_BASEPARAMS );
}
if( pSubst != NULL )
hb_itemReturnRelease( pSubst );
else if( iNoRet )
hb_retl( HB_FALSE );
else
hb_retc_null();
}
}
static void hb_compGenArgList( int iFirst, int iLast,
int * pArgC, const char *** pArgV,
PHB_ITEM * pIncItem,
PHB_PP_OPEN_FUNC * pOpenFunc,
PHB_PP_MSG_FUNC * pMsgFunc )
{
PHB_ITEM pParam;
HB_SIZE ul, nLen;
int argc = 1, i;
const char ** argv;
if( pMsgFunc )
{
*pMsgFunc = NULL;
if( HB_ISLOG( iFirst ) )
{
if( hb_parl( iFirst ) )
*pMsgFunc = s_pp_msg;
++iFirst;
}
}
if( pIncItem && pOpenFunc )
{
*pOpenFunc = NULL;
*pIncItem = hb_param( iFirst, HB_IT_HASH );
if( *pIncItem )
{
++iFirst;
*pOpenFunc = s_pp_openFile;
}
}
for( i = iFirst; i <= iLast; ++i )
{
pParam = hb_param( i, HB_IT_ARRAY | HB_IT_STRING );
if( pParam )
{
if( HB_IS_ARRAY( pParam ) )
{
ul = hb_arrayLen( pParam );
if( ul )
{
do
{
if( hb_arrayGetType( pParam, ul ) & HB_IT_STRING )
++argc;
}
while( --ul );
}
}
else if( HB_IS_STRING( pParam ) )
++argc;
}
}
argv = ( const char ** ) hb_xgrab( sizeof( char * ) * ( argc + 1 ) );
argc = 0;
for( i = iFirst; i <= iLast; ++i )
{
pParam = hb_param( i, HB_IT_ARRAY | HB_IT_STRING );
if( pParam )
{
if( HB_IS_ARRAY( pParam ) )
{
nLen = hb_arrayLen( pParam );
for( ul = 1; ul <= nLen; ++ul )
{
if( hb_arrayGetType( pParam, ul ) & HB_IT_STRING )
argv[ argc++ ] = hb_arrayGetCPtr( pParam, ul );
}
}
else if( HB_IS_STRING( pParam ) )
argv[ argc++ ] = hb_itemGetCPtr( pParam );
}
}
argv[ argc ] = NULL;
*pArgC = argc;
*pArgV = argv;
}
static void s_inetRecvPattern( const char * const * patterns, int * patternsizes,
int iPatternsCount, int iParam )
{
PHB_SOCKET_STRUCT socket = HB_PARSOCKET( 1 );
PHB_ITEM pResult = hb_param( iParam, HB_IT_BYREF );
PHB_ITEM pMaxSize = hb_param( iParam + 1, HB_IT_NUMERIC );
PHB_ITEM pBufferSize = hb_param( iParam + 2, HB_IT_NUMERIC );
char cChar = '\0';
char * buffer;
int iPaternFound = 0;
int iTimeElapsed = 0;
int iPos = 0;
int iLen;
int iAllocated, iBufferSize, iMax;
int i;
if( socket == NULL )
{
hb_inetErrRT();
return;
}
else if( ! hb_inetIsOpen( socket ) )
{
if( pResult )
hb_itemPutNI( pResult, -1 );
hb_retc_null();
return;
}
iBufferSize = pBufferSize ? hb_itemGetNI( pBufferSize ) : 80;
iMax = pMaxSize ? hb_itemGetNI( pMaxSize ) : 0;
socket->iError = HB_INET_ERR_OK;
buffer = ( char * ) hb_xgrab( iBufferSize );
iAllocated = iBufferSize;
do
{
if( iPos == iAllocated - 1 )
{
iAllocated += iBufferSize;
buffer = ( char * ) hb_xrealloc( buffer, iAllocated );
}
iLen = s_inetRecv( socket, &cChar, 1, HB_TRUE, socket->iTimeout );
if( iLen == -1 && s_inetIsTimeout( socket ) )
{
iLen = -2; /* this signals timeout */
if( socket->pPeriodicBlock )
{
HB_BOOL fResult;
iTimeElapsed += socket->iTimeout;
hb_execFromArray( socket->pPeriodicBlock );
fResult = hb_parl( -1 ) && hb_vmRequestQuery() == 0;
if( fResult &&
( socket->iTimeLimit == -1 || iTimeElapsed < socket->iTimeLimit ) )
iLen = 1;
}
}
else if( iLen > 0 )
{
buffer[ iPos++ ] = cChar;
for( i = 0; i < iPatternsCount; ++i )
{
if( patternsizes[ i ] <= iPos &&
cChar == patterns[ i ][ patternsizes[ i ] - 1 ] )
{
if( memcmp( buffer + iPos - patternsizes[ i ],
patterns[ i ], patternsizes[ i ] ) == 0 )
{
iPaternFound = i + 1;
break;
}
}
}
}
}
while( iLen > 0 && iPaternFound == 0 && ( iMax == 0 || iPos < iMax ) );
if( iPaternFound )
{
socket->iCount = iPos;
if( pResult )
hb_itemPutNI( pResult, iPos );
hb_retclen_buffer( buffer, iPos - patternsizes[ iPaternFound - 1 ] );
}
else
{
if( iLen == 0 )
socket->iError = HB_INET_ERR_CLOSEDCONN;
else if( iLen < 0 )
hb_inetGetError( socket );
else
{
socket->iError = HB_INET_ERR_BUFFOVERRUN;
iLen = -1;
}
if( pResult )
hb_itemPutNI( pResult, iLen );
hb_xfree( buffer );
hb_retc_null();
}
}
static void s_inetRecvInternal( int iMode )
{
PHB_SOCKET_STRUCT socket = HB_PARSOCKET( 1 );
PHB_ITEM pBuffer = hb_param( 2, HB_IT_STRING );
if( socket == NULL || pBuffer == NULL || ! HB_ISBYREF( 2 ) )
hb_inetErrRT();
else if( ! hb_inetIsOpen( socket ) )
hb_retni( -1 );
else
{
int iLen, iMaxLen, iReceived, iTimeElapsed;
char * buffer;
HB_SIZE nLen;
if( hb_itemGetWriteCL( pBuffer, &buffer, &nLen ) )
iLen = ( int ) nLen;
else
{
iLen = 0;
buffer = NULL;
}
if( HB_ISNUM( 3 ) )
{
iMaxLen = hb_parni( 3 );
if( iMaxLen < 0 )
iMaxLen = 0;
else if( iLen < iMaxLen )
iMaxLen = iLen;
}
else
iMaxLen = iLen;
iReceived = iTimeElapsed = 0;
socket->iError = HB_INET_ERR_OK;
do
{
iLen = s_inetRecv( socket, buffer + iReceived, iMaxLen - iReceived,
HB_FALSE, socket->iTimeout );
if( iLen >= 0 )
{
iReceived += iLen;
if( iMode == 0 ) /* Called from hb_inetRecv()? */
break;
}
else if( iLen == -1 && s_inetIsTimeout( socket ) )
{
/* if we have a pPeriodicBlock, timeLimit is our REAL timeout */
if( socket->pPeriodicBlock )
{
/* timed out; let's see if we have to run a cb routine */
iTimeElapsed += socket->iTimeout;
hb_execFromArray( socket->pPeriodicBlock );
/* do we continue? */
if( hb_parl( -1 ) && hb_vmRequestQuery() == 0 &&
( socket->iTimeLimit == -1 || iTimeElapsed < socket->iTimeLimit ) )
iLen = 1; /* Declare success to continue loop */
}
}
}
while( iReceived < iMaxLen && iLen > 0 );
socket->iCount = iReceived;
if( iLen == 0 )
socket->iError = HB_INET_ERR_CLOSEDCONN;
else if( iLen < 0 )
hb_inetGetError( socket );
hb_retni( iReceived > 0 ? iReceived : iLen );
}
}
/* helper function for the Pos*() functions */
static void do_pos1( int iSwitch )
{
if( HB_ISCHAR( 1 ) && /* all functions need string as 1st param */
( iSwitch != DO_POS1_POSRANGE || /* that's the only condition for all functions _except_ PosRange() */
( iSwitch == DO_POS1_POSRANGE && /* In addition, PosRange() needs .. */
HB_ISCHAR( 2 ) && /* .. string as 2nd .. */
HB_ISCHAR( 3 ) ) ) ) /* .. and 3rd param */
{
const unsigned char * pcString, * puc;
HB_SIZE sStrLen;
unsigned char ucChar1 = ' ', ucChar2 = ' ';
int iMode;
HB_SIZE sIgnore;
int iParamShift = 0;
if( iSwitch == DO_POS1_POSRANGE )
{
if( hb_parclen( 1 ) == 0 )
{
hb_retns( 0 );
return;
}
else
ucChar1 = *( hb_parc( 1 ) );
if( hb_parclen( 2 ) == 0 )
{
hb_retns( 0 );
return;
}
else
ucChar2 = *( hb_parc( 2 ) );
iParamShift += 2;
}
pcString = ( const unsigned char * ) hb_parc( iParamShift + 1 );
sStrLen = hb_parclen( iParamShift + 1 );
iMode = hb_parl( iParamShift + 2 );
sIgnore = hb_parnsdef( iParamShift + 3, 0 );
for( puc = pcString + sIgnore; puc < pcString + sStrLen; puc++ )
{
int iDoRet = 0;
switch( iSwitch )
{
case DO_POS1_POSALPHA:
iDoRet = hb_charIsAlpha( ( HB_UCHAR ) *puc );
break;
case DO_POS1_POSLOWER:
iDoRet = hb_charIsLower( ( HB_UCHAR ) *puc );
break;
case DO_POS1_POSRANGE:
iDoRet = ( ucChar1 <= *puc && ucChar2 >= *puc );
break;
case DO_POS1_POSUPPER:
iDoRet = hb_charIsUpper( ( HB_UCHAR ) *puc );
break;
}
if( ( iMode && ! iDoRet ) || ( ! iMode && iDoRet ) )
{
hb_retns( puc - pcString + 1 );
return;
}
}
hb_retns( 0 );
}
else
{
PHB_ITEM pSubst = NULL;
int iArgErrorMode = ct_getargerrormode();
if( iArgErrorMode != CT_ARGERR_IGNORE )
{
HB_ERRCODE iError = 0;
switch( iSwitch )
{
case DO_POS1_POSALPHA:
iError = CT_ERROR_POSALPHA;
break;
case DO_POS1_POSLOWER:
iError = CT_ERROR_POSLOWER;
break;
case DO_POS1_POSRANGE:
iError = CT_ERROR_POSRANGE;
break;
case DO_POS1_POSUPPER:
iError = CT_ERROR_POSUPPER;
break;
}
pSubst = ct_error_subst( ( HB_USHORT ) iArgErrorMode, EG_ARG, iError,
NULL, HB_ERR_FUNCNAME, 0,
EF_CANSUBSTITUTE, HB_ERR_ARGS_BASEPARAMS );
}
if( pSubst != NULL )
hb_itemReturnRelease( pSubst );
else
hb_retns( 0 );
}
}
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 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 );
}
}
}
