static void * hb_pcre2_grab( PCRE2_SIZE size, void * data )
{
HB_SYMBOL_UNUSED( data );
return size > 0 ? hb_xgrab( size ) : NULL;
}
static void hb_mlGetEOLs( PHB_MLC_INFO pMLC, int iParam )
{
int iEOLs = 0;
HB_SIZE nLen;
pMLC->pEOLs = pMLC->EOL_buffer;
/* NOTE: This is a parameter extension (HB_EXTENSION) which breaks
our effort to keep strict parameter compatibility with
Clipper 5.x. In this case we've resorted to a compromise
because there was no other idea which seemed natural enough.
Clipper will ignore these parameters and use CRLF EOL hard
coded. [vszakats] */
#ifndef HB_CLP_STRICT /* HB_EXTENSION */
nLen = hb_parclen( iParam );
if( nLen )
{
pMLC->pEOLs[ 0 ].szEOL = hb_parc( iParam );
pMLC->pEOLs[ 0 ].nLen = nLen;
iEOLs = 1;
}
else if( HB_ISARRAY( iParam ) )
{
PHB_ITEM pArray = hb_param( iParam, HB_IT_ARRAY );
HB_SIZE nSize = hb_arrayLen( pArray ), n;
for( n = 1; n <= nSize; ++n )
{
if( hb_arrayGetCLen( pArray, n ) > 0 )
++iEOLs;
}
if( iEOLs )
{
if( iEOLs > HB_EOL_BUFFER_SIZE )
pMLC->pEOLs = ( PHB_EOL_INFO ) hb_xgrab( sizeof( HB_EOL_INFO ) * iEOLs );
iEOLs = 0;
for( n = 1; n <= nSize; ++n )
{
nLen = hb_arrayGetCLen( pArray, n );
if( nLen > 0 )
{
pMLC->pEOLs[ iEOLs ].szEOL = hb_arrayGetCPtr( pArray, n );
pMLC->pEOLs[ iEOLs ].nLen = nLen;
++iEOLs;
}
}
}
}
#else
HB_SYMBOL_UNUSED( iParam );
HB_SYMBOL_UNUSED( nLen );
#endif
if( iEOLs == 0 )
{
pMLC->pEOLs[ 0 ].szEOL = hb_setGetEOL();
if( ! pMLC->pEOLs[ 0 ].szEOL || ! pMLC->pEOLs[ 0 ].szEOL[ 0 ] )
pMLC->pEOLs[ 0 ].szEOL = hb_conNewLine();
pMLC->pEOLs[ 0 ].nLen = strlen( pMLC->pEOLs[ 0 ].szEOL );
iEOLs = pMLC->pEOLs[ 0 ].nLen ? 1 : 0;
}
pMLC->iEOLs = iEOLs;
}
static void hbqt_lib_exit( void * cargo )
{
HB_SYMBOL_UNUSED( cargo );
}
HB_FATTR hb_fsAttrToRaw( HB_FATTR nAttr )
{
HB_FATTR raw_attr;
HB_TRACE( HB_TR_DEBUG, ( "hb_fsAttrToRaw(%u)", nAttr ) );
#if defined( HB_OS_DOS )
raw_attr = 0;
if( nAttr & HB_FA_ARCHIVE ) raw_attr |= FA_ARCH;
if( nAttr & HB_FA_DIRECTORY ) raw_attr |= FA_DIREC;
if( nAttr & HB_FA_HIDDEN ) raw_attr |= FA_HIDDEN;
if( nAttr & HB_FA_READONLY ) raw_attr |= FA_RDONLY;
if( nAttr & HB_FA_LABEL ) raw_attr |= FA_LABEL;
if( nAttr & HB_FA_SYSTEM ) raw_attr |= FA_SYSTEM;
#elif defined( HB_OS_OS2 )
raw_attr = 0;
if( nAttr & HB_FA_ARCHIVE ) raw_attr |= FILE_ARCHIVED;
if( nAttr & HB_FA_DIRECTORY ) raw_attr |= FILE_DIRECTORY;
if( nAttr & HB_FA_HIDDEN ) raw_attr |= FILE_HIDDEN;
if( nAttr & HB_FA_READONLY ) raw_attr |= FILE_READONLY;
if( nAttr & HB_FA_SYSTEM ) raw_attr |= FILE_SYSTEM;
#elif defined( HB_OS_WIN )
raw_attr = 0;
if( nAttr & HB_FA_ARCHIVE ) raw_attr |= FILE_ATTRIBUTE_ARCHIVE;
if( nAttr & HB_FA_DIRECTORY ) raw_attr |= FILE_ATTRIBUTE_DIRECTORY;
if( nAttr & HB_FA_HIDDEN ) raw_attr |= FILE_ATTRIBUTE_HIDDEN;
if( nAttr & HB_FA_READONLY ) raw_attr |= FILE_ATTRIBUTE_READONLY;
if( nAttr & HB_FA_SYSTEM ) raw_attr |= FILE_ATTRIBUTE_SYSTEM;
if( nAttr & HB_FA_NORMAL ) raw_attr |= FILE_ATTRIBUTE_NORMAL;
/* Note that FILE_ATTRIBUTE_NORMAL is not needed
HB_FA_DEVICE not supported
HB_FA_VOLCOMP needs to be checked */
if( nAttr & HB_FA_ENCRYPTED ) raw_attr |= FILE_ATTRIBUTE_ENCRYPTED;
if( nAttr & HB_FA_TEMPORARY ) raw_attr |= FILE_ATTRIBUTE_TEMPORARY;
if( nAttr & HB_FA_SPARSE ) raw_attr |= FILE_ATTRIBUTE_SPARSE_FILE;
if( nAttr & HB_FA_REPARSE ) raw_attr |= FILE_ATTRIBUTE_REPARSE_POINT;
if( nAttr & HB_FA_COMPRESSED ) raw_attr |= FILE_ATTRIBUTE_COMPRESSED;
if( nAttr & HB_FA_OFFLINE ) raw_attr |= FILE_ATTRIBUTE_OFFLINE;
if( nAttr & HB_FA_NOTINDEXED ) raw_attr |= 0x00002000; /* FILE_ATTRIBUTE_NOT_CONTENT_INDEXED not defined in some older winnt.h */
if( nAttr & HB_FA_VOLCOMP ) raw_attr |= 0x00008000;
#elif defined( HB_OS_UNIX )
raw_attr = HB_FA_POSIX_ATTR( nAttr );
if( nAttr & HB_FA_FILE ) raw_attr |= S_IFREG;
if( nAttr & HB_FA_DIRECTORY ) raw_attr |= S_IFDIR;
if( nAttr & HB_FA_LINK ) raw_attr |= S_IFLNK;
if( nAttr & HB_FA_CHRDEVICE ) raw_attr |= S_IFCHR;
if( nAttr & HB_FA_BLKDEVICE ) raw_attr |= S_IFBLK;
if( nAttr & HB_FA_FIFO ) raw_attr |= S_IFIFO;
if( nAttr & HB_FA_SOCKET ) raw_attr |= S_IFSOCK;
#else
HB_SYMBOL_UNUSED( nAttr );
raw_attr = 0;
#endif
return raw_attr;
}
static void hb_regfree( PHB_REGEX pRegEx )
{
HB_SYMBOL_UNUSED( pRegEx );
}
static HB_BOOL s_fileAccept( const char * pszFileName )
{
HB_SYMBOL_UNUSED( pszFileName );
return HB_FALSE;
}
static PHB_FILE s_fileOpen( PHB_FILE_FUNCS pFuncs, const char * pszName,
const char * pszDefExt, HB_USHORT uiExFlags,
const char * pPaths, PHB_ITEM pError )
{
const char * pszHost = pszName + FILE_PREFIX_LEN, * ptr;
PHB_FILE pFile = NULL;
HB_ERRCODE errcode = 0;
HB_SIZE nLen = 0;
int iPort = 0;
int timeout = -1;
HB_SYMBOL_UNUSED( pFuncs );
HB_SYMBOL_UNUSED( pszDefExt );
HB_SYMBOL_UNUSED( pPaths );
if( ( ptr = strchr( pszHost, ':' ) ) != NULL && ptr != pszHost )
{
nLen = ptr - pszHost;
++ptr;
while( HB_ISDIGIT( * ptr ) )
iPort = iPort * 10 + ( * ptr++ - '0' );
if( * ptr == ':' )
{
++ptr;
while( HB_ISDIGIT( * ptr ) )
timeout = HB_MAX( timeout, 0 ) * 10 + ( * ptr++ - '0' );
}
if( * ptr != 0 && * ptr != ':' )
iPort = 0;
}
if( iPort > 0 )
{
char * pszAddr, * pszIpAddr;
pszAddr = hb_strndup( pszHost, nLen );
pszIpAddr = hb_socketResolveAddr( pszAddr, HB_SOCKET_AF_INET );
hb_xfree( pszAddr );
if( pszIpAddr )
{
HB_SOCKET sd = hb_socketOpen( HB_SOCKET_PF_INET, HB_SOCKET_PT_STREAM, 0 );
if( sd != HB_NO_SOCKET )
{
void * pSockAddr;
unsigned uiLen;
if( hb_socketInetAddr( &pSockAddr, &uiLen, pszIpAddr, iPort ) )
{
hb_socketSetKeepAlive( sd, HB_TRUE );
if( hb_socketConnect( sd, pSockAddr, uiLen, timeout ) == 0 )
{
switch( uiExFlags & ( FO_READ | FO_WRITE | FO_READWRITE ) )
{
case FO_READ:
hb_socketShutdown( sd, HB_SOCKET_SHUT_WR );
break;
case FO_WRITE:
hb_socketShutdown( sd, HB_SOCKET_SHUT_RD );
break;
}
pFile = s_fileNew( sd, timeout );
sd = HB_NO_SOCKET;
}
hb_xfree( pSockAddr );
}
if( sd != HB_NO_SOCKET )
{
errcode = hb_socketGetError();
hb_socketClose( sd );
}
}
hb_xfree( pszIpAddr );
}
if( errcode == 0 && pFile == NULL )
errcode = hb_socketGetError();
}
else
errcode = HB_SOCKET_ERR_WRONGADDR;
hb_fsSetError( errcode );
if( pError )
{
hb_errPutFileName( pError, pszName );
if( pFile == NULL )
{
hb_errPutOsCode( pError, errcode );
hb_errPutGenCode( pError, ( HB_ERRCODE ) EG_OPEN );
}
}
return pFile;
}
BOOL WINAPI SetCurrentDirectoryW( LPCWSTR dirname )
{
HB_SYMBOL_UNUSED( dirname );
return FALSE;
}
UINT WINAPI SetErrorMode( UINT mode )
{
HB_SYMBOL_UNUSED( mode );
return 0;
}
HB_ERRCODE hb_rddSelectWorkAreaNumber( int iArea )
{
HB_SYMBOL_UNUSED( iArea );
return HB_FAILURE;
}
HB_ERRCODE hb_rddSelectWorkAreaSymbol( PHB_SYMB pSymAlias )
{
HB_SYMBOL_UNUSED( pSymAlias );
return HB_FAILURE;
}
HB_ERRCODE hb_rddSelectWorkAreaAlias( const char * szName )
{
HB_SYMBOL_UNUSED( szName );
return HB_FAILURE;
}
void hb_rddWaShutDown( PHB_STACKRDD pRddInfo )
{
HB_SYMBOL_UNUSED( pRddInfo );
}
static void hb_pcre2_free( void * ptr, void * data )
{
HB_SYMBOL_UNUSED( data );
if( ptr )
hb_xfree( ptr );
}
static void s_fileFlush( PHB_FILE pFile, HB_BOOL fDirty )
{
HB_SYMBOL_UNUSED( pFile );
HB_SYMBOL_UNUSED( fDirty );
}
HANDLE WINAPI GetStdHandle( DWORD nStdHandle )
{
HB_SYMBOL_UNUSED( nStdHandle );
return NULL;
}
static void s_fileCommit( PHB_FILE pFile )
{
HB_SYMBOL_UNUSED( pFile );
hb_fsSetError( HB_FILE_ERR_UNSUPPORTED );
}
DWORD WINAPI GetFileType( HANDLE handle )
{
HB_SYMBOL_UNUSED( handle );
return 0;
}
static HB_BOOL s_fileAccept( PHB_FILE_FUNCS pFuncs, const char * pszFileName )
{
HB_SYMBOL_UNUSED( pFuncs );
return hb_strnicmp( pszFileName, FILE_PREFIX, FILE_PREFIX_LEN ) == 0;
}
BOOL WINAPI SetKeyboardState( PBYTE p )
{
HB_SYMBOL_UNUSED( p );
return FALSE;
}
HB_FATTR hb_fsAttrFromRaw( HB_FATTR raw_attr )
{
HB_FATTR nAttr;
HB_TRACE( HB_TR_DEBUG, ( "hb_fsAttrFromRaw(%u)", raw_attr ) );
#if defined( HB_OS_DOS )
nAttr = 0;
if( raw_attr & FA_ARCH ) nAttr |= HB_FA_ARCHIVE;
if( raw_attr & FA_DIREC ) nAttr |= HB_FA_DIRECTORY;
if( raw_attr & FA_HIDDEN ) nAttr |= HB_FA_HIDDEN;
if( raw_attr & FA_RDONLY ) nAttr |= HB_FA_READONLY;
if( raw_attr & FA_LABEL ) nAttr |= HB_FA_LABEL;
if( raw_attr & FA_SYSTEM ) nAttr |= HB_FA_SYSTEM;
#elif defined( HB_OS_OS2 )
nAttr = 0;
if( raw_attr & FILE_ARCHIVED ) nAttr |= HB_FA_ARCHIVE;
if( raw_attr & FILE_DIRECTORY ) nAttr |= HB_FA_DIRECTORY;
if( raw_attr & FILE_HIDDEN ) nAttr |= HB_FA_HIDDEN;
if( raw_attr & FILE_READONLY ) nAttr |= HB_FA_READONLY;
if( raw_attr & FILE_SYSTEM ) nAttr |= HB_FA_SYSTEM;
#elif defined( HB_OS_WIN )
nAttr = 0;
if( raw_attr & FILE_ATTRIBUTE_ARCHIVE ) nAttr |= HB_FA_ARCHIVE;
if( raw_attr & FILE_ATTRIBUTE_DIRECTORY ) nAttr |= HB_FA_DIRECTORY;
if( raw_attr & FILE_ATTRIBUTE_HIDDEN ) nAttr |= HB_FA_HIDDEN;
if( raw_attr & FILE_ATTRIBUTE_READONLY ) nAttr |= HB_FA_READONLY;
if( raw_attr & FILE_ATTRIBUTE_SYSTEM ) nAttr |= HB_FA_SYSTEM;
if( raw_attr & FILE_ATTRIBUTE_NORMAL ) nAttr |= HB_FA_NORMAL;
/* Note that FILE_ATTRIBUTE_NORMAL is not needed
HB_FA_DEVICE not supported
HB_FA_VOLCOMP needs to be checked */
if( raw_attr & FILE_ATTRIBUTE_ENCRYPTED ) nAttr |= HB_FA_ENCRYPTED;
if( raw_attr & FILE_ATTRIBUTE_TEMPORARY ) nAttr |= HB_FA_TEMPORARY;
if( raw_attr & FILE_ATTRIBUTE_SPARSE_FILE ) nAttr |= HB_FA_SPARSE;
if( raw_attr & FILE_ATTRIBUTE_REPARSE_POINT ) nAttr |= HB_FA_REPARSE;
if( raw_attr & FILE_ATTRIBUTE_COMPRESSED ) nAttr |= HB_FA_COMPRESSED;
if( raw_attr & FILE_ATTRIBUTE_OFFLINE ) nAttr |= HB_FA_OFFLINE;
/* FILE_ATTRIBUTE_NOT_CONTENT_INDEXED */
/* not defined in some older winnt.h */
if( raw_attr & 0x00002000 ) nAttr |= HB_FA_NOTINDEXED;
if( raw_attr & 0x00008000 ) nAttr |= HB_FA_VOLCOMP;
#elif defined( HB_OS_UNIX )
nAttr = ( ( raw_attr & S_IXOTH ) ? HB_FA_XOTH : 0 ) |
( ( raw_attr & S_IWOTH ) ? HB_FA_WOTH : 0 ) |
( ( raw_attr & S_IROTH ) ? HB_FA_ROTH : 0 ) |
( ( raw_attr & S_IXGRP ) ? HB_FA_XGRP : 0 ) |
( ( raw_attr & S_IWGRP ) ? HB_FA_WGRP : 0 ) |
( ( raw_attr & S_IRGRP ) ? HB_FA_RGRP : 0 ) |
( ( raw_attr & S_IXUSR ) ? HB_FA_XUSR : 0 ) |
( ( raw_attr & S_IWUSR ) ? HB_FA_WUSR : 0 ) |
( ( raw_attr & S_IRUSR ) ? HB_FA_RUSR : 0 ) |
( ( raw_attr & S_ISVTX ) ? HB_FA_SVTX : 0 ) |
( ( raw_attr & S_ISGID ) ? HB_FA_SGID : 0 ) |
( ( raw_attr & S_ISUID ) ? HB_FA_SUID : 0 );
if( S_ISREG( raw_attr ) ) nAttr |= HB_FA_FILE;
if( S_ISDIR( raw_attr ) ) nAttr |= HB_FA_DIRECTORY;
if( S_ISLNK( raw_attr ) ) nAttr |= HB_FA_LINK;
if( S_ISCHR( raw_attr ) ) nAttr |= HB_FA_CHRDEVICE;
if( S_ISBLK( raw_attr ) ) nAttr |= HB_FA_BLKDEVICE;
if( S_ISFIFO( raw_attr ) ) nAttr |= HB_FA_FIFO;
#if ! defined( HB_OS_VXWORKS )
if( S_ISSOCK( raw_attr ) ) nAttr |= HB_FA_SOCKET;
#endif
#else
nAttr = 0;
HB_SYMBOL_UNUSED( raw_attr );
#endif
return nAttr;
}
static HB_ERRCODE sddDisconnect( SQLDDCONNECTION * pConnection )
{
HB_SYMBOL_UNUSED( pConnection );
hb_errRT_SQLBASE( EG_UNSUPPORTED, ESQLDD_NULLSDD, NULL, NULL );
return HB_FAILURE;
}
static HB_BOOL hb_fsFindNextLow( PHB_FFIND ffind )
{
HB_BOOL bFound;
int iYear = 0;
int iMonth = 0;
int iDay = 0;
int iHour = 0;
int iMin = 0;
int iSec = 0;
int iMSec = 0;
HB_FATTR raw_attr = 0, nAttr = 0;
/* Set the default values in case some platforms don't
support some of these, or they may fail on them. */
ffind->szName[ 0 ] = '\0';
ffind->size = 0;
/* Do platform dependant first/next search */
hb_vmUnlock();
#if defined( HB_OS_DOS )
{
PHB_FFIND_INFO info = ( PHB_FFIND_INFO ) ffind->info;
/* Handling HB_FA_LABEL doesn't need any special tricks
under the MS-DOS platform. */
if( ffind->bFirst )
{
ffind->bFirst = HB_FALSE;
/* tzset(); */
#if defined( __WATCOMC__ )
bFound = ( _dos_findfirst( ffind->pszFileMask, ( HB_USHORT ) hb_fsAttrToRaw( ffind->attrmask ), &info->entry ) == 0 );
#else
bFound = ( findfirst( ffind->pszFileMask, &info->entry, ( HB_USHORT ) hb_fsAttrToRaw( ffind->attrmask ) ) == 0 );
#endif
}
else
{
#if defined( __WATCOMC__ )
bFound = ( _dos_findnext( &info->entry ) == 0 );
#else
bFound = ( findnext( &info->entry ) == 0 );
#endif
}
/* Fill Harbour found file info */
if( bFound )
{
hb_strncpy( ffind->szName, info->entry.ff_name, sizeof( ffind->szName ) - 1 );
ffind->size = info->entry.ff_fsize;
raw_attr = info->entry.ff_attrib;
{
time_t ftime;
struct tm * ft;
struct stat sStat;
stat( info->entry.ff_name, &sStat );
ftime = sStat.st_mtime;
ft = localtime( &ftime );
iYear = ft->tm_year + 1900;
iMonth = ft->tm_mon + 1;
iDay = ft->tm_mday;
iHour = ft->tm_hour;
iMin = ft->tm_min;
iSec = ft->tm_sec;
}
}
hb_fsSetIOError( bFound, 0 );
}
#elif defined( HB_OS_OS2 )
{
#define HB_OS2_DIRCNT 16
PHB_FFIND_INFO info = ( PHB_FFIND_INFO ) ffind->info;
APIRET ret = NO_ERROR;
/* TODO: HB_FA_LABEL handling */
if( ffind->bFirst )
{
ffind->bFirst = HB_FALSE;
info->isWSeB = hb_isWSeB();
info->findSize = sizeof( FILEFINDBUF3L );
if( info->findSize & 0x07 )
info->findSize += 0x08 - ( info->findSize & 0x07 );
info->findSize *= HB_OS2_DIRCNT;
if( info->findSize > 0xF000 )
info->findSize = 0xF000;
info->findInitCnt = ! info->isWSeB ? info->findSize / 32 : HB_OS2_DIRCNT;
info->hFindFile = HDIR_CREATE;
info->findCount = info->findInitCnt;
ret = DosAllocMem( &info->entry, info->findSize, OBJ_TILE | PAG_COMMIT | PAG_WRITE );
if( ret == NO_ERROR )
{
ret = DosFindFirst( ( PCSZ ) ffind->pszFileMask,
&info->hFindFile,
( ULONG ) hb_fsAttrToRaw( ffind->attrmask ),
info->entry,
info->findSize,
&info->findCount,
FIL_STANDARDL );
bFound = ret == NO_ERROR && info->findCount > 0;
if( bFound )
info->next = info->entry;
}
else
{
info->entry = NULL;
bFound = HB_FALSE;
}
}
else if( info->findCount == 0 )
{
info->findCount = info->findInitCnt;
ret = DosFindNext( info->hFindFile,
info->entry,
info->findSize,
&info->findCount );
bFound = ret == NO_ERROR && info->findCount > 0;
if( bFound )
info->next = info->entry;
}
else
bFound = HB_TRUE;
if( bFound )
{
ULONG oNextEntryOffset;
if( info->isWSeB )
{
PFILEFINDBUF3L pFFB = ( PFILEFINDBUF3L ) info->next;
hb_strncpy( ffind->szName, pFFB->achName, sizeof( ffind->szName ) - 1 );
ffind->size = ( HB_FOFFSET ) pFFB->cbFile;
raw_attr = pFFB->attrFile;
iYear = pFFB->fdateLastWrite.year + 1980;
iMonth = pFFB->fdateLastWrite.month;
iDay = pFFB->fdateLastWrite.day;
iHour = pFFB->ftimeLastWrite.hours;
iMin = pFFB->ftimeLastWrite.minutes;
iSec = pFFB->ftimeLastWrite.twosecs * 2;
oNextEntryOffset = pFFB->oNextEntryOffset;
}
else
{
PFILEFINDBUF3 pFFB = ( PFILEFINDBUF3 ) info->next;
hb_strncpy( ffind->szName, pFFB->achName, sizeof( ffind->szName ) - 1 );
ffind->size = ( HB_FOFFSET ) pFFB->cbFile;
raw_attr = pFFB->attrFile;
iYear = pFFB->fdateLastWrite.year + 1980;
iMonth = pFFB->fdateLastWrite.month;
iDay = pFFB->fdateLastWrite.day;
iHour = pFFB->ftimeLastWrite.hours;
iMin = pFFB->ftimeLastWrite.minutes;
iSec = pFFB->ftimeLastWrite.twosecs * 2;
oNextEntryOffset = pFFB->oNextEntryOffset;
}
if( oNextEntryOffset > 0 )
{
info->next = ( char * ) info->next + oNextEntryOffset;
info->findCount--;
}
else
info->findCount = 0;
}
hb_fsSetError( ( HB_ERRCODE ) ret );
}
#elif defined( HB_OS_WIN )
{
PHB_FFIND_INFO info = ( PHB_FFIND_INFO ) ffind->info;
bFound = HB_FALSE;
#if ! defined( HB_OS_WIN_CE )
if( ( ffind->attrmask & HB_FA_LABEL ) != 0 && ! info->fLabelDone )
{
TCHAR lpVolName[ HB_PATH_MAX ];
LPTSTR lpFileMask = NULL;
char * mask = NULL;
info->fLabelDone = HB_TRUE;
if( ffind->pszFileMask && *ffind->pszFileMask )
{
PHB_FNAME pFileName = hb_fsFNameSplit( ffind->pszFileMask );
if( pFileName->szName && pFileName->szName[ 0 ] )
mask = hb_strdup( pFileName->szName );
if( pFileName->szPath && pFileName->szPath[ 0 ] &&
( pFileName->szPath[ 1 ] ||
pFileName->szPath[ 0 ] != HB_OS_PATH_DELIM_CHR ) )
lpFileMask = HB_CHARDUP( pFileName->szPath );
hb_xfree( pFileName );
}
bFound = GetVolumeInformation( lpFileMask, lpVolName,
HB_SIZEOFARRAY( lpVolName ),
NULL, NULL, NULL, NULL, 0 ) != 0;
if( bFound )
{
HB_OSSTRDUP2( lpVolName, ffind->szName, sizeof( ffind->szName ) - 1 );
if( mask && *mask && ! hb_strMatchFile( ffind->szName, mask ) )
{
ffind->szName[ 0 ] = '\0';
bFound = HB_FALSE;
}
}
if( lpFileMask )
hb_xfree( lpFileMask );
if( mask )
hb_xfree( mask );
}
#endif
if( ! bFound &&
( ffind->attrmask & ( HB_FA_LABEL | HB_FA_HIDDEN | HB_FA_SYSTEM |
HB_FA_DIRECTORY ) ) != HB_FA_LABEL )
{
if( ffind->bFirst )
{
LPTSTR lpFileMask = HB_CHARDUP( ffind->pszFileMask );
ffind->bFirst = HB_FALSE;
info->dwAttr = ( DWORD ) hb_fsAttrToRaw( ffind->attrmask );
info->hFindFile = FindFirstFile( lpFileMask, &info->pFindFileData );
hb_xfree( lpFileMask );
if( ( info->hFindFile != INVALID_HANDLE_VALUE ) && _HB_WIN_MATCH() )
bFound = HB_TRUE;
}
if( ! bFound && info->hFindFile != INVALID_HANDLE_VALUE )
{
while( FindNextFile( info->hFindFile, &info->pFindFileData ) )
{
if( _HB_WIN_MATCH() )
{
bFound = HB_TRUE;
break;
}
}
}
/* Fill Harbour found file info */
if( bFound )
{
HB_OSSTRDUP2( info->pFindFileData.cFileName, ffind->szName, sizeof( ffind->szName ) - 1 );
if( info->pFindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY )
ffind->size = 0;
else
{
#if defined( __XCC__ ) || ( defined( __POCC__ ) && __POCC__ >= 500 )
/* NOTE: PellesC 5.00.1 will go into an infinite loop if we don't
split this into two operations. [vszakats] */
ffind->size = ( HB_FOFFSET ) info->pFindFileData.nFileSizeLow;
ffind->size += ( HB_FOFFSET ) info->pFindFileData.nFileSizeHigh << 32;
#else
ffind->size = ( HB_FOFFSET ) info->pFindFileData.nFileSizeLow +
( ( HB_FOFFSET ) info->pFindFileData.nFileSizeHigh << 32 );
#endif
}
raw_attr = ( HB_FATTR ) info->pFindFileData.dwFileAttributes;
/* NOTE: One of these may fail when searching on an UNC path, I
don't know yet what's the reason. [vszakats] */
{
FILETIME ft;
SYSTEMTIME time;
if( FileTimeToLocalFileTime( &info->pFindFileData.ftLastWriteTime, &ft ) &&
FileTimeToSystemTime( &ft, &time ) )
{
iYear = time.wYear;
iMonth = time.wMonth;
iDay = time.wDay;
iHour = time.wHour;
iMin = time.wMinute;
iSec = time.wSecond;
iMSec = time.wMilliseconds;
}
}
}
}
hb_fsSetIOError( bFound, 0 );
}
#elif defined( HB_OS_UNIX )
{
PHB_FFIND_INFO info = ( PHB_FFIND_INFO ) ffind->info;
char dirname[ HB_PATH_MAX ];
bFound = HB_FALSE;
/* TODO: HB_FA_LABEL handling */
if( ffind->bFirst )
{
char * pos;
ffind->bFirst = HB_FALSE;
hb_strncpy( dirname, ffind->pszFileMask, sizeof( dirname ) - 1 );
pos = strrchr( dirname, HB_OS_PATH_DELIM_CHR );
if( pos )
{
hb_strncpy( info->pattern, pos + 1, sizeof( info->pattern ) - 1 );
*( pos + 1 ) = '\0';
}
else
{
hb_strncpy( info->pattern, dirname, sizeof( info->pattern ) - 1 );
dirname[ 0 ] = '.';
dirname[ 1 ] = HB_OS_PATH_DELIM_CHR;
dirname[ 2 ] = '\0';
}
/* tzset(); */
info->dir = opendir( dirname );
hb_strncpy( info->path, dirname, sizeof( info->path ) - 1 );
}
if( info->dir && info->pattern[ 0 ] != '\0' )
{
while( ( info->entry = readdir( info->dir ) ) != NULL )
{
if( hb_strMatchFile( info->entry->d_name, info->pattern ) )
{
bFound = HB_TRUE;
break;
}
}
}
/* Fill Harbour found file info */
if( bFound )
{
hb_strncpy( dirname, info->path, sizeof( dirname ) - 1 );
hb_strncat( dirname, info->entry->d_name, sizeof( dirname ) - 1 );
{
time_t ftime;
struct tm lt;
#if defined( HB_USE_LARGEFILE64 )
struct stat64 sStat, sStatL;
if( lstat64( dirname, &sStat ) == 0 )
{
if( S_ISLNK( sStat.st_mode ) && ( ffind->attrmask & HB_FA_LINK ) == 0 )
{
if( stat64( dirname, &sStatL ) == 0 )
memcpy( &sStat, &sStatL, sizeof( sStat ) );
nAttr |= HB_FA_LINK;
}
#else
struct stat sStat, sStatL;
if( lstat( dirname, &sStat ) == 0 )
{
if( S_ISLNK( sStat.st_mode ) && ( ffind->attrmask & HB_FA_LINK ) == 0 )
{
if( stat( dirname, &sStatL ) == 0 )
memcpy( &sStat, &sStatL, sizeof( sStat ) );
nAttr |= HB_FA_LINK;
}
#endif
hb_strncpy( ffind->szName, info->entry->d_name, sizeof( ffind->szName ) - 1 );
ffind->size = sStat.st_size;
raw_attr = sStat.st_mode;
ftime = sStat.st_mtime;
# if defined( HB_HAS_LOCALTIME_R )
localtime_r( &ftime, < );
# else
lt = *localtime( &ftime );
# endif
iYear = lt.tm_year + 1900;
iMonth = lt.tm_mon + 1;
iDay = lt.tm_mday;
iHour = lt.tm_hour;
iMin = lt.tm_min;
iSec = lt.tm_sec;
# if defined( HB_OS_LINUX ) && \
defined( __GLIBC__ ) && defined( __GLIBC_MINOR__ ) && \
( __GLIBC__ > 2 || ( __GLIBC__ == 2 && __GLIBC_MINOR__ >= 6 ) )
# if defined( _BSD_SOURCE ) || defined( _SVID_SOURCE ) || \
( __GLIBC_MINOR__ >= 12 && \
( ( defined( _POSIX_C_SOURCE ) || _POSIX_C_SOURCE >= 200809L ) || \
( defined( _XOPEN_SOURCE ) || _XOPEN_SOURCE >= 700 ) ) )
iMSec = sStat.st_mtim.tv_nsec / 1000000;
# else
iMSec = sStat.st_mtimensec / 1000000;
# endif
# endif
}
else
bFound = HB_FALSE;
}
}
hb_fsSetIOError( bFound, 0 );
}
#else
{
int iTODO; /* TODO: for given platform */
/* HB_SYMBOL_UNUSED( ffind ); */
HB_SYMBOL_UNUSED( iYear );
HB_SYMBOL_UNUSED( iMonth );
HB_SYMBOL_UNUSED( iDay );
HB_SYMBOL_UNUSED( iHour );
HB_SYMBOL_UNUSED( iMin );
HB_SYMBOL_UNUSED( iSec );
HB_SYMBOL_UNUSED( iMSec );
HB_SYMBOL_UNUSED( raw_attr );
bFound = HB_FALSE;
hb_fsSetIOError( bFound, 0 );
}
#endif
/* Fill common Harbour found file info */
if( bFound )
{
/* Do the conversions common for all platforms */
ffind->szName[ sizeof( ffind->szName ) - 1 ] = '\0';
#if ! defined( HB_OS_WIN )
/* Convert from OS codepage */
{
char * pszFree = NULL;
HB_SIZE nSize = sizeof( ffind->szName );
const char * pszResult = hb_osDecodeCP( ffind->szName, &pszFree, &nSize );
if( pszFree )
{
hb_strncpy( ffind->szName, pszResult, sizeof( ffind->szName ) - 1 );
hb_xfree( pszFree );
}
}
#endif
ffind->attr = hb_fsAttrFromRaw( raw_attr ) | nAttr;
ffind->lDate = hb_dateEncode( iYear, iMonth, iDay );
ffind->lTime = hb_timeEncode( iHour, iMin, iSec, iMSec );
hb_dateStrPut( ffind->szDate, iYear, iMonth, iDay );
ffind->szDate[ 8 ] = '\0';
hb_snprintf( ffind->szTime, sizeof( ffind->szTime ), "%02d:%02d:%02d", iHour, iMin, iSec );
}
hb_vmLock();
return bFound;
}
PHB_FFIND hb_fsFindFirst( const char * pszFileMask, HB_FATTR attrmask )
{
PHB_FFIND ffind = ( PHB_FFIND ) hb_xgrabz( sizeof( HB_FFIND ) );
/* Allocate platform dependent file find info storage */
ffind->info = ( void * ) hb_xgrabz( sizeof( HB_FFIND_INFO ) );
/* Store search parameters */
#if defined( HB_OS_WIN )
ffind->pszFileMask = pszFileMask;
#else
/* Convert to OS codepage */
ffind->pszFileMask = hb_fsNameConv( pszFileMask, &ffind->pszFree );
#endif
ffind->attrmask = attrmask;
ffind->bFirst = HB_TRUE;
/* Find first/next matching file */
if( hb_fsFindNext( ffind ) )
return ffind;
/* If no file found at all, free stuff allocated so far and return NULL. */
hb_fsFindClose( ffind );
return NULL;
}
static HB_ERRCODE sddOpen( SQLBASEAREAP pArea )
{
HB_SYMBOL_UNUSED( pArea );
hb_errRT_SQLBASE( EG_UNSUPPORTED, ESQLDD_NULLSDD, NULL, NULL );
return HB_FAILURE;
}
static int hb_regcomp( PHB_REGEX pRegEx, const char * szRegEx )
{
HB_SYMBOL_UNUSED( pRegEx );
HB_SYMBOL_UNUSED( szRegEx );
return -1;
}
static HB_ERRCODE sddClose( SQLBASEAREAP pArea )
{
HB_SYMBOL_UNUSED( pArea );
return HB_SUCCESS;
}
static void hbqt_lib_init( void * cargo )
{
HB_SYMBOL_UNUSED( cargo );
hbqt_registerCallbacks();
}
static HB_ERRCODE sqlbaseRddInfo( LPRDDNODE pRDD, HB_USHORT uiIndex, HB_ULONG ulConnect, PHB_ITEM pItem )
{
HB_ULONG ulConn;
SQLDDCONNECTION * pConn;
HB_SYMBOL_UNUSED( pRDD );
ulConn = ulConnect ? ulConnect : s_ulConnectionCurrent;
if( ulConn > 0 && ulConn <= s_ulConnectionCount )
pConn = s_pConnection[ ulConn - 1 ];
else
pConn = NULL;
switch( uiIndex )
{
case RDDI_REMOTE:
hb_itemPutL( pItem, HB_TRUE );
break;
case RDDI_CONNECTION:
{
HB_ULONG ulNewConnection = 0;
if( hb_itemType( pItem ) & HB_IT_NUMERIC )
ulNewConnection = hb_itemGetNL( pItem );
hb_itemPutNL( pItem, ulConnect ? ulConnect : s_ulConnectionCurrent );
if( ulNewConnection )
s_ulConnectionCurrent = ulNewConnection;
break;
}
case RDDI_ISDBF:
hb_itemPutL( pItem, HB_FALSE );
break;
case RDDI_CANPUTREC:
hb_itemPutL( pItem, HB_TRUE );
break;
case RDDI_CONNECT:
{
PSDDNODE pNode = NULL;
HB_ULONG ul;
const char * pStr;
pStr = hb_arrayGetCPtr( pItem, 1 );
if( pStr )
{
pNode = s_pSdd;
while( pNode )
{
if( ! hb_stricmp( pNode->Name, pStr ) )
break;
pNode = pNode->pNext;
}
}
hb_rddsqlSetError( 0, NULL, NULL, NULL, 0 );
pConn = ( SQLDDCONNECTION * ) hb_xgrab( sizeof( SQLDDCONNECTION ) );
memset( pConn, 0, sizeof( SQLDDCONNECTION ) );
if( pNode && pNode->Connect( pConn, pItem ) == HB_SUCCESS )
{
pConn->pSDD = pNode;
/* Find free connection handle */
for( ul = 0; ul < s_ulConnectionCount; ul++ )
{
if( ! s_pConnection[ ul ] )
break;
}
if( ul >= s_ulConnectionCount )
{
/* Realloc connection table */
if( s_pConnection )
s_pConnection = ( SQLDDCONNECTION ** ) hb_xrealloc( s_pConnection, sizeof( SQLDDCONNECTION * ) * ( s_ulConnectionCount + CONNECTION_LIST_EXPAND ) );
else
s_pConnection = ( SQLDDCONNECTION ** ) hb_xgrab( sizeof( SQLDDCONNECTION * ) * CONNECTION_LIST_EXPAND );
memset( s_pConnection + s_ulConnectionCount, 0, sizeof( SQLDDCONNECTION * ) * CONNECTION_LIST_EXPAND );
ul = s_ulConnectionCount;
s_ulConnectionCount += CONNECTION_LIST_EXPAND;
}
s_pConnection[ ul ] = pConn;
ul++;
s_ulConnectionCurrent = ul;
}
else
{
hb_xfree( pConn );
ul = 0;
}
hb_itemPutNI( pItem, ul );
break;
}
case RDDI_DISCONNECT:
hb_rddsqlSetError( 0, NULL, NULL, NULL, 0 );
if( pConn && ! pConn->uiAreaCount && pConn->pSDD->Disconnect( pConn ) == HB_SUCCESS )
{
hb_xfree( pConn );
s_pConnection[ ulConn - 1 ] = NULL;
if( s_ulConnectionCurrent == ulConn )
s_ulConnectionCurrent = 0;
hb_itemPutL( pItem, HB_TRUE );
return HB_SUCCESS;
}
hb_itemPutL( pItem, HB_FALSE );
return HB_SUCCESS;
case RDDI_EXECUTE:
hb_rddsqlSetError( 0, NULL, NULL, NULL, 0 );
if( pConn )
hb_itemPutL( pItem, pConn->pSDD->Execute( pConn, pItem ) == HB_SUCCESS );
else
hb_itemPutL( pItem, HB_FALSE );
return HB_SUCCESS;
case RDDI_ERROR:
hb_itemPutC( pItem, s_szError );
return HB_SUCCESS;
case RDDI_ERRORNO:
hb_itemPutNI( pItem, s_errCode );
return HB_SUCCESS;
case RDDI_QUERY:
hb_itemPutC( pItem, s_szQuery );
return HB_SUCCESS;
case RDDI_NEWID:
hb_itemCopy( pItem, s_pItemNewID );
return HB_SUCCESS;
case RDDI_AFFECTEDROWS:
hb_itemPutNInt( pItem, s_ulAffectedRows );
return HB_SUCCESS;
#if 0
default:
return SUPER_RDDINFO( pRDD, uiIndex, ulConnect, pItem );
#endif
}
return HB_SUCCESS;
}
static HB_ERRCODE odbcGoTo( SQLBASEAREAP pArea, HB_ULONG ulRecNo )
{
SQLHSTMT hStmt;
SQLRETURN res;
SQLLEN iLen;
PHB_ITEM pArray, pItem;
LPFIELD pField;
HB_USHORT ui;
/* No pArea->pSDDData for DBCreate() area...
* though pArea->fFetched == HB_TRUE for them
*/
hStmt = pArea->pSDDData ? ( ( SDDDATA * ) pArea->pSDDData )->hStmt : NULL;
while( ulRecNo > pArea->ulRecCount && ! pArea->fFetched )
{
if( ! SQL_SUCCEEDED( SQLFetch( hStmt ) ) )
{
pArea->fFetched = HB_TRUE;
break;
}
pArray = hb_itemArrayNew( pArea->area.uiFieldCount );
pItem = NULL;
for( ui = 1; ui <= pArea->area.uiFieldCount; ui++ )
{
iLen = SQL_NULL_DATA;
res = 0;
pField = pArea->area.lpFields + ui - 1;
switch( pField->uiType )
{
case HB_FT_STRING:
if( pField->uiType & HB_FF_BINARY )
{
char buffer[ 1 ];
iLen = 0;
if( SQL_SUCCEEDED( res = SQLGetData( hStmt, ui, SQL_C_BINARY, buffer, 0, &iLen ) ) )
{
if( iLen >= 0 )
{
char * val = ( char * ) hb_xgrab( iLen + 1 );
if( SQL_SUCCEEDED( res = SQLGetData( hStmt, ui, SQL_C_BINARY, val, iLen + 1, &iLen ) ) )
pItem = hb_itemPutCLPtr( pItem, val, ( HB_SIZE ) iLen );
else
hb_xfree( val );
}
}
}
else
{
O_HB_CHAR buffer[ 1 ];
#if defined( UNICODE )
SQLSMALLINT iTargetType = SQL_C_WCHAR;
#else
SQLSMALLINT iTargetType = SQL_C_CHAR;
#endif
iLen = 0;
if( SQL_SUCCEEDED( res = SQLGetData( hStmt, ui, iTargetType, buffer, 0, &iLen ) ) )
{
if( iLen >= 0 )
{
O_HB_CHAR * val = ( O_HB_CHAR * ) hb_xgrab( iLen + sizeof( O_HB_CHAR ) );
if( SQL_SUCCEEDED( res = SQLGetData( hStmt, ui, iTargetType, val, iLen + sizeof( O_HB_CHAR ), &iLen ) ) )
{
#if defined( UNICODE )
iLen >>= 1;
#endif
pItem = O_HB_ITEMPUTSTRLEN( pItem, val, ( HB_SIZE ) iLen );
}
hb_xfree( val );
}
}
}
break;
case HB_FT_INTEGER:
#if ODBCVER >= 0x0300
if( pField->uiTypeExtended == ( HB_USHORT ) SQL_BIGINT )
{
HB_I64 val = 0;
/* NOTE: SQL_C_SBIGINT not available before ODBC 3.0 */
if( SQL_SUCCEEDED( res = SQLGetData( hStmt, ui, SQL_C_SBIGINT, &val, sizeof( val ), &iLen ) ) )
pItem = hb_itemPutNIntLen( pItem, val, pField->uiLen );
}
else
#endif
{
SQLINTEGER val = 0;
if( SQL_SUCCEEDED( res = SQLGetData( hStmt, ui, SQL_C_LONG, &val, sizeof( val ), &iLen ) ) )
pItem = hb_itemPutNLLen( pItem, val, pField->uiLen );
}
break;
case HB_FT_LONG:
if( pField->uiDec == 0 && pField->uiLen < 10 )
{
SQLINTEGER val = 0;
if( SQL_SUCCEEDED( res = SQLGetData( hStmt, ui, SQL_C_LONG, &val, sizeof( val ), &iLen ) ) )
pItem = hb_itemPutNLLen( pItem, val, pField->uiLen );
}
else
{
double val = 0.0;
if( SQL_SUCCEEDED( res = SQLGetData( hStmt, ui, SQL_C_DOUBLE, &val, sizeof( val ), &iLen ) ) )
pItem = hb_itemPutNDLen( pItem, val, pField->uiLen, pField->uiDec );
}
break;
case HB_FT_DOUBLE:
{
double val = 0.0;
if( SQL_SUCCEEDED( res = SQLGetData( hStmt, ui, SQL_C_DOUBLE, &val, sizeof( val ), &iLen ) ) )
pItem = hb_itemPutNDLen( pItem, val, pField->uiLen, pField->uiDec );
break;
}
case HB_FT_LOGICAL:
{
unsigned char val = 0;
if( SQL_SUCCEEDED( res = SQLGetData( hStmt, ui, SQL_C_BIT, &val, sizeof( val ), &iLen ) ) )
pItem = hb_itemPutL( pItem, val != 0 );
break;
}
case HB_FT_DATE:
{
DATE_STRUCT val = { 0, 0, 0 };
if( SQL_SUCCEEDED( res = SQLGetData( hStmt, ui, SQL_C_DATE, &val, sizeof( val ), &iLen ) ) )
pItem = hb_itemPutD( pItem, val.year, val.month, val.day );
break;
}
case HB_FT_TIME:
{
TIME_STRUCT val = { 0, 0, 0 };
if( SQL_SUCCEEDED( res = SQLGetData( hStmt, ui, SQL_C_TIME, &val, sizeof( val ), &iLen ) ) )
pItem = hb_itemPutTDT( pItem, 0, hb_timeEncode( val.hour, val.minute, val.second, 0 ) );
break;
}
case HB_FT_TIMESTAMP:
{
TIMESTAMP_STRUCT val = { 0, 0, 0, 0, 0, 0, 0 };
if( SQL_SUCCEEDED( res = SQLGetData( hStmt, ui, SQL_C_TIMESTAMP, &val, sizeof( val ), &iLen ) ) )
pItem = hb_itemPutTDT( pItem, hb_dateEncode( val.year, val.month, val.day ),
hb_timeEncode( val.hour, val.minute, val.second, val.fraction / 1000000 ) );
break;
}
}
/* TODO: check SQL_SUCCEEDED( res ) */
/* TODO: check for SQL_NO_TOTAL. What does this mean? */
HB_SYMBOL_UNUSED( res );
if( pItem )
{
/* NULL -> NIL */
if( iLen == SQL_NULL_DATA )
hb_itemClear( pItem );
else
hb_arraySetForward( pArray, ui, pItem );
}
}
if( pItem )
hb_itemRelease( pItem );
if( pArea->ulRecCount + 1 >= pArea->ulRecMax )
{
pArea->pRow = ( void ** ) hb_xrealloc( pArea->pRow, ( pArea->ulRecMax + SQLDD_ROWSET_RESIZE ) * sizeof( void * ) );
pArea->pRowFlags = ( HB_BYTE * ) hb_xrealloc( pArea->pRowFlags, ( pArea->ulRecMax + SQLDD_ROWSET_RESIZE ) * sizeof( HB_BYTE ) );
pArea->ulRecMax += SQLDD_ROWSET_RESIZE;
}
pArea->ulRecCount++;
pArea->pRow[ pArea->ulRecCount ] = pArray;
pArea->pRowFlags[ pArea->ulRecCount ] = SQLDD_FLAG_CACHED;
}
static int hb_regexec( PHB_REGEX pRegEx, const char * szString, HB_SIZE nLen,
int iMatches, HB_REGMATCH * aMatches )
{
#if defined( HB_HAS_PCRE2 )
PCRE2_SIZE iResult = pcre2_match( pRegEx->re_pcre,
( PCRE2_SPTR ) szString,
( PCRE2_SIZE ) nLen,
( PCRE2_SIZE ) 0 /* startoffset */,
( uint32_t ) pRegEx->iEFlags,
aMatches, s_re_ctxm );
if( iResult == 0 )
{
PCRE2_SIZE i;
for( i = 0; i < ( PCRE2_SIZE ) iMatches; i++ )
{
if( HB_REGMATCH_EO( aMatches, i ) != HB_REGMATCH_UNSET )
iResult = i + 1;
}
}
return ( int ) iResult;
#elif defined( HB_HAS_PCRE )
int iResult = pcre_exec( pRegEx->re_pcre, NULL /* pcre_extra */,
szString, ( int ) nLen, 0 /* startoffset */,
pRegEx->iEFlags, aMatches, HB_REGMATCH_SIZE( iMatches ) );
if( iResult == 0 )
{
int i;
for( i = 0; i < iMatches; i++ )
{
if( HB_REGMATCH_EO( aMatches, i ) != HB_REGMATCH_UNSET )
iResult = i + 1;
}
}
return iResult;
#elif defined( HB_POSIX_REGEX )
char * szBuffer = NULL;
int iResult, i;
if( szString[ nLen ] != 0 )
{
szBuffer = hb_strndup( szString, nLen );
szString = szBuffer;
}
for( i = 0; i < iMatches; i++ )
HB_REGMATCH_EO( aMatches, i ) = HB_REGMATCH_UNSET;
iResult = regexec( &pRegEx->reg, szString, iMatches, aMatches, pRegEx->iEFlags );
if( iResult == 0 )
{
for( i = 0; i < iMatches; i++ )
{
if( HB_REGMATCH_EO( aMatches, i ) != HB_REGMATCH_UNSET )
iResult = i + 1;
}
}
else
iResult = -1;
if( szBuffer )
hb_xfree( szBuffer );
return iResult;
#else
HB_SYMBOL_UNUSED( pRegEx );
HB_SYMBOL_UNUSED( szString );
HB_SYMBOL_UNUSED( nLen );
HB_SYMBOL_UNUSED( iMatches );
HB_SYMBOL_UNUSED( aMatches );
return -1;
#endif
}
