/* helper function for the *one functions */
static void do_charone( int iSwitch )
{
char *pcString;
size_t sStrLen;
char *pcDeleteSet;
size_t sDeleteSetLen;
/* param check */
if ( ISCHAR( 1 ) )
{
if ( ISCHAR( 2 ) )
{
pcString = hb_parc( 2 );
sStrLen = (size_t)hb_parclen( 2 );
pcDeleteSet = hb_parc( 1 );
sDeleteSetLen = (size_t)hb_parclen( 1 );
}
else
{
pcString = hb_parc( 1 );
sStrLen = (size_t)hb_parclen( 1 );
pcDeleteSet = NULL;
sDeleteSetLen = 0;
}
switch ( iSwitch )
{
case DO_CHARONE_CHARONE:
{
if (sStrLen > 1)
{
char *pcSub;
char *pcRet;
size_t sRetStrLen = 0;
char cCurrent = *pcString;
pcRet = (char *)hb_xgrab( sStrLen );
/* copy first char */
pcRet[ sRetStrLen++ ] = cCurrent;
for ( pcSub = pcString + 1; pcSub < pcString + sStrLen; pcSub++ )
{
if ( *pcSub != cCurrent )
{
cCurrent = *pcSub;
pcRet[ sRetStrLen++ ] = cCurrent;
}
else if ( pcDeleteSet != NULL
&& !ct_at_exact_forward( pcDeleteSet, sDeleteSetLen,
pcSub, 1, NULL ) )
{
pcRet[ sRetStrLen++ ] = cCurrent;
}
}
hb_retclen( pcRet, sRetStrLen );
hb_xfree( pcRet );
}
else /* if (sStrLen > 1) */
{
/* algorithm does nothing to 1-char-strings */
hb_retclen( pcString, sStrLen );
}
}
break;
case DO_CHARONE_WORDONE:
{
if ( sStrLen > 3 && sDeleteSetLen >= 2 )
{
char *pcSub;
char *pcRet;
size_t sRetStrLen = 0;
char cCurrent1 = pcString[0];
char cCurrent2 = pcString[1];
pcRet = (char *)hb_xgrab( sStrLen );
/* copy first double char */
pcRet[ sRetStrLen++ ] = cCurrent1;
pcRet[ sRetStrLen++ ] = cCurrent2;
for ( pcSub = pcString + 2; pcSub < pcString + sStrLen - 1; pcSub += 2 )
{
if ( !( pcSub[0] == cCurrent1 && pcSub[1] == cCurrent2 ) )
{
cCurrent1 = pcSub[0];
cCurrent2 = pcSub[1];
pcRet[ sRetStrLen++ ] = cCurrent1;
pcRet[ sRetStrLen++ ] = cCurrent2;
}
else if ( pcDeleteSet != NULL )
{
char *pc = NULL;
char *pStart = pcDeleteSet;
size_t sLen = sDeleteSetLen;
while ( sLen >= 2
&& ( pc = ct_at_exact_forward( pStart, sLen,
pcSub, 2, NULL ) ) != 0
&& ( pc - pcDeleteSet ) % 2 == 1 )
{
pStart = pc + 1;
sLen = sDeleteSetLen - ( pStart - pcDeleteSet );
}
if ( pc == NULL )
{
pcRet[ sRetStrLen++ ] = cCurrent1;
pcRet[ sRetStrLen++ ] = cCurrent2;
}
}
}
/* copy last character if string len is odd */
if ( sStrLen % 2 == 1 )
{
pcRet[ sRetStrLen++ ] = pcString[ sStrLen - 1 ];
}
hb_retclen( pcRet, sRetStrLen );
hb_xfree( pcRet );
}
else /* if (sStrLen > 3) */
{
/* algorithm does nothing to 3-char-strings */
hb_retclen( pcString, sStrLen );
}
}
break;
} /* switch (iSwitch) */
}
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_CHARONE_CHARONE ? CT_ERROR_CHARONE : CT_ERROR_WORDONE ),
NULL,
( iSwitch == DO_CHARONE_CHARONE ? "CHARONE" : "WORDONE" ),
0, EF_CANSUBSTITUTE, 2,
hb_paramError( 1 ), hb_paramError( 2 ) );
}
if ( pSubst != NULL )
{
hb_itemRelease( hb_itemReturnForward( pSubst ) );
}
else
{
hb_retc( "" );
}
}
}
static PHB_FILE s_fileExtOpen( PHB_FILE_FUNCS pFuncs, const char * pszFileName, const char * pDefExt,
HB_USHORT uiExFlags, const char * pPaths,
PHB_ITEM pError )
{
PHB_FILE pFile = NULL;
#if defined( HB_OS_UNIX )
HB_BOOL fResult, fSeek = HB_FALSE;
# if defined( HB_USE_LARGEFILE64 )
struct stat64 statbuf;
# else
struct stat statbuf;
# endif
#endif
HB_BOOL fShared, fReadonly;
HB_FHANDLE hFile;
char * pszFile;
HB_SYMBOL_UNUSED( pFuncs );
fShared = ( uiExFlags & ( FO_DENYREAD | FO_DENYWRITE | FO_EXCLUSIVE ) ) == 0;
fReadonly = ( uiExFlags & ( FO_READ | FO_WRITE | FO_READWRITE ) ) == FO_READ;
pszFile = hb_fsExtName( pszFileName, pDefExt, uiExFlags, pPaths );
hb_vmUnlock();
#if defined( HB_OS_UNIX )
# if defined( HB_USE_LARGEFILE64 )
fResult = stat64( ( char * ) pszFile, &statbuf ) == 0;
# else
fResult = stat( ( char * ) pszFile, &statbuf ) == 0;
# endif
hb_fsSetIOError( fResult, 0 );
if( fResult )
{
hb_threadEnterCriticalSection( &s_fileMtx );
pFile = hb_fileFind( statbuf.st_dev, statbuf.st_ino );
if( pFile )
{
if( ! fShared || ! pFile->shared || ( uiExFlags & FXO_TRUNCATE ) != 0 )
fResult = HB_FALSE;
else if( ! fReadonly && pFile->readonly )
pFile = NULL;
else
pFile->used++;
if( ( uiExFlags & FXO_NOSEEKPOS ) == 0 )
{
# if defined( HB_OS_VXWORKS )
fSeek = ! S_ISFIFO( statbuf.st_mode );
# else
fSeek = ! S_ISFIFO( statbuf.st_mode ) && ! S_ISSOCK( statbuf.st_mode );
# endif
}
}
hb_threadLeaveCriticalSection( &s_fileMtx );
}
if( pFile )
{
if( ! fResult )
{
hb_fsSetError( ( uiExFlags & FXO_TRUNCATE ) ? 5 : 32 );
pFile = NULL;
}
else if( uiExFlags & FXO_COPYNAME )
hb_strncpy( ( char * ) pszFileName, pszFile, HB_PATH_MAX - 1 );
if( pError )
{
hb_errPutFileName( pError, pszFile );
if( ! fResult )
{
hb_errPutOsCode( pError, hb_fsError() );
hb_errPutGenCode( pError, ( HB_ERRCODE ) ( ( uiExFlags & FXO_TRUNCATE ) ? EG_CREATE : EG_OPEN ) );
}
}
}
else
#endif
{
hFile = hb_fsExtOpen( pszFileName, pDefExt, uiExFlags, pPaths, pError );
if( hFile != FS_ERROR )
{
HB_ULONG device = 0, inode = 0;
#if defined( HB_OS_UNIX )
# if defined( HB_USE_LARGEFILE64 )
if( fstat64( hFile, &statbuf ) == 0 )
# else
if( fstat( hFile, &statbuf ) == 0 )
# endif
{
device = ( HB_ULONG ) statbuf.st_dev;
inode = ( HB_ULONG ) statbuf.st_ino;
if( ( uiExFlags & FXO_NOSEEKPOS ) == 0 )
{
# if defined( HB_OS_VXWORKS )
fSeek = ! S_ISFIFO( statbuf.st_mode );
# else
fSeek = ! S_ISFIFO( statbuf.st_mode ) && ! S_ISSOCK( statbuf.st_mode );
# endif
}
}
#endif
hb_threadEnterCriticalSection( &s_fileMtx );
pFile = hb_fileNew( hFile, fShared, fReadonly, device, inode, HB_TRUE );
if( pFile->hFile != hFile )
{
if( pFile->hFileRO == FS_ERROR && ! fReadonly && pFile->readonly )
{
pFile->hFileRO = pFile->hFile;
pFile->hFile = hFile;
pFile->readonly = HB_FALSE;
hFile = FS_ERROR;
}
if( pFile->uiLocks == 0 )
{
#if ! defined( HB_USE_SHARELOCKS ) || defined( HB_USE_BSDLOCKS )
if( pFile->hFileRO != FS_ERROR )
{
hb_fsClose( pFile->hFileRO );
pFile->hFileRO = FS_ERROR;
}
#endif
if( hFile != FS_ERROR )
{
hb_fsClose( hFile );
hFile = FS_ERROR;
#if defined( HB_USE_SHARELOCKS ) && ! defined( HB_USE_BSDLOCKS )
/* TOFIX: possible race condition */
hb_fsLockLarge( hFile, HB_SHARELOCK_POS, HB_SHARELOCK_SIZE,
FL_LOCK | FLX_SHARED );
#endif
}
}
}
else
hFile = FS_ERROR;
hb_threadLeaveCriticalSection( &s_fileMtx );
if( hFile != FS_ERROR )
{
/* TOFIX: possible race condition in MT mode,
* close() is not safe due to existing locks
* which are removed.
*/
hb_fsClose( hFile );
}
}
}
hb_xfree( pszFile );
#if defined( HB_OS_UNIX )
if( pFile && fSeek )
pFile = hb_fileposNew( pFile );
#endif
hb_vmLock();
return pFile;
}
HB_WCHAR * hb_fsNameConvU16( const char * szFileName )
{
char * pszBuffer = NULL;
HB_WCHAR * lpwFileName;
if( s_fFnTrim || s_cDirSep != HB_OS_PATH_DELIM_CHR ||
s_iFileCase != HB_SET_CASE_MIXED || s_iDirCase != HB_SET_CASE_MIXED )
{
PHB_FNAME pFileName;
HB_SIZE nLen;
szFileName = pszBuffer = hb_strncpy( ( char * ) hb_xgrab( HB_PATH_MAX ),
szFileName, HB_PATH_MAX - 1 );
if( s_cDirSep != HB_OS_PATH_DELIM_CHR )
{
char * p = ( char * ) szFileName;
while( *p )
{
if( *p == s_cDirSep )
*p = HB_OS_PATH_DELIM_CHR;
p++;
}
}
pFileName = hb_fsFNameSplit( szFileName );
/* strip trailing and leading spaces */
if( s_fFnTrim )
{
if( pFileName->szName )
{
nLen = strlen( pFileName->szName );
while( nLen && pFileName->szName[ nLen - 1 ] == ' ' )
--nLen;
while( nLen && pFileName->szName[ 0 ] == ' ' )
{
++pFileName->szName;
--nLen;
}
( ( char * ) pFileName->szName )[ nLen ] = '\0';
}
if( pFileName->szExtension )
{
nLen = strlen( pFileName->szExtension );
while( nLen && pFileName->szExtension[ nLen - 1 ] == ' ' )
--nLen;
while( nLen && pFileName->szExtension[ 0 ] == ' ' )
{
++pFileName->szExtension;
--nLen;
}
( ( char * ) pFileName->szExtension )[ nLen ] = '\0';
}
}
/* FILECASE */
if( s_iFileCase == HB_SET_CASE_LOWER )
{
if( pFileName->szName )
hb_strlow( ( char * ) pFileName->szName );
if( pFileName->szExtension )
hb_strlow( ( char * ) pFileName->szExtension );
}
else if( s_iFileCase == HB_SET_CASE_UPPER )
{
if( pFileName->szName )
hb_strupr( ( char * ) pFileName->szName );
if( pFileName->szExtension )
hb_strupr( ( char * ) pFileName->szExtension );
}
/* DIRCASE */
if( pFileName->szPath )
{
if( s_iDirCase == HB_SET_CASE_LOWER )
hb_strlow( ( char * ) pFileName->szPath );
else if( s_iDirCase == HB_SET_CASE_UPPER )
hb_strupr( ( char * ) pFileName->szPath );
}
hb_fsFNameMerge( ( char * ) szFileName, pFileName );
hb_xfree( pFileName );
}
lpwFileName = hb_mbtowc( szFileName );
if( pszBuffer )
hb_xfree( pszBuffer );
return lpwFileName;
}
HB_BOOL hb_lppRecv( PHB_LPP pSocket, void ** data, HB_SIZE * len, HB_MAXINT timeout )
{
HB_MAXINT nTime = 0;
long lRecv;
if( ! pSocket->pRecvBuffer )
{
pSocket->pRecvBuffer = ( char * ) hb_xgrab( 4 );
pSocket->nRecvLen = 0;
pSocket->fRecvHasSize = HB_FALSE;
}
if( timeout > 0 )
nTime = ( HB_MAXINT ) hb_dateMilliSeconds() + timeout;
for( ;; )
{
if( ! pSocket->fRecvHasSize )
{
lRecv = ( long ) ( 4 - pSocket->nRecvLen );
lRecv = hb_socketRecv( pSocket->sd, pSocket->pRecvBuffer + pSocket->nRecvLen, lRecv, 0, timeout );
if( lRecv == -1 )
{
pSocket->iError = hb_socketGetError();
return HB_FALSE;
}
else if( lRecv == 0 )
{
/* peer closed connection */
pSocket->iError = 0;
return HB_FALSE;
}
pSocket->nRecvLen += lRecv;
if( pSocket->nRecvLen < 4 )
{
pSocket->iError = HB_SOCKET_ERR_TIMEOUT;
return HB_FALSE;
}
pSocket->nRecvSize = HB_GET_UINT32( pSocket->pRecvBuffer );
if( pSocket->nLimit && pSocket->nRecvSize > pSocket->nLimit )
{
/* protection against remote memory exhaust attack */
pSocket->iError = HB_LPP_ERR_TOOLARGE;
hb_xfree( pSocket->pRecvBuffer );
pSocket->pRecvBuffer = NULL;
return HB_FALSE;
}
pSocket->nRecvLen = 0;
pSocket->fRecvHasSize = HB_TRUE;
if( pSocket->nRecvSize != 4 )
pSocket->pRecvBuffer = ( char * ) hb_xrealloc( pSocket->pRecvBuffer, pSocket->nRecvSize );
}
if( pSocket->nRecvSize - pSocket->nRecvLen < ( HB_SIZE ) LONG_MAX )
lRecv = ( long ) ( pSocket->nRecvSize - pSocket->nRecvLen );
else
lRecv = LONG_MAX;
lRecv = hb_socketRecv( pSocket->sd, pSocket->pRecvBuffer + pSocket->nRecvLen, lRecv, 0, timeout );
if( lRecv == -1 )
{
pSocket->iError = hb_socketGetError();
return HB_FALSE;
}
else if( lRecv == 0 )
{
/* peer closed connection */
pSocket->iError = 0;
return HB_FALSE;
}
pSocket->nRecvLen += lRecv;
if( pSocket->nRecvSize == pSocket->nRecvLen )
{
* data = pSocket->pRecvBuffer;
* len = pSocket->nRecvLen;
pSocket->pRecvBuffer = NULL;
pSocket->iError = 0;
return HB_TRUE;
}
if( timeout == 0 ||
( timeout > 0 && ( timeout = nTime - ( HB_MAXINT ) hb_dateMilliSeconds() ) <= 0 ) )
{
pSocket->iError = HB_SOCKET_ERR_TIMEOUT;
return HB_FALSE;
}
}
}
/* 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();
}
}
double hb_fsDiskSpace( const char * pszPath, HB_USHORT uiType )
{
char szPathBuf[ 2 ];
double dSpace = 0.0;
if( uiType > HB_DISK_TOTAL )
uiType = HB_DISK_AVAIL;
if( ! pszPath )
{
szPathBuf[ 0 ] = HB_OS_PATH_DELIM_CHR;
szPathBuf[ 1 ] = '\0';
pszPath = szPathBuf;
}
#if defined( HB_OS_WIN )
{
LPCTSTR lpPath;
LPTSTR lpFree;
lpPath = HB_FSNAMECONV( pszPath, &lpFree );
{
UINT uiErrMode = SetErrorMode( SEM_FAILCRITICALERRORS );
HB_BOOL fResult;
#if ! defined( HB_OS_WIN_CE ) && ! defined( HB_OS_WIN_64 )
/* NOTE: We need to call this function dynamically to maintain support
Win95 first edition. It was introduced in Win95B (aka OSR2) [vszakats] */
typedef BOOL ( WINAPI * P_GDFSE )( LPCTSTR, PULARGE_INTEGER,
PULARGE_INTEGER, PULARGE_INTEGER );
static P_GDFSE s_pGetDiskFreeSpaceEx = NULL;
static HB_BOOL s_fInit = HB_FALSE;
if( ! s_fInit )
{
HMODULE hModule = GetModuleHandle( HB_WINAPI_KERNEL32_DLL() );
if( hModule )
s_pGetDiskFreeSpaceEx = ( P_GDFSE )
HB_WINAPI_GETPROCADDRESST( hModule, "GetDiskFreeSpaceEx" );
s_fInit = HB_TRUE;
}
if( ! s_pGetDiskFreeSpaceEx )
{
DWORD dwSectorsPerCluster;
DWORD dwBytesPerSector;
DWORD dwNumberOfFreeClusters;
DWORD dwTotalNumberOfClusters;
fResult = GetDiskFreeSpace( lpPath,
&dwSectorsPerCluster,
&dwBytesPerSector,
&dwNumberOfFreeClusters,
&dwTotalNumberOfClusters ) ? HB_TRUE : HB_FALSE;
hb_fsSetIOError( fResult, 0 );
if( fResult )
{
switch( uiType )
{
case HB_DISK_AVAIL:
case HB_DISK_FREE:
dSpace = ( double ) dwNumberOfFreeClusters *
( double ) dwSectorsPerCluster *
( double ) dwBytesPerSector;
break;
case HB_DISK_USED:
case HB_DISK_TOTAL:
dSpace = ( double ) dwTotalNumberOfClusters *
( double ) dwSectorsPerCluster *
( double ) dwBytesPerSector;
if( uiType == HB_DISK_USED )
dSpace -= ( double ) dwNumberOfFreeClusters *
( double ) dwSectorsPerCluster *
( double ) dwBytesPerSector;
break;
}
}
}
else
#endif
{
#if defined( _MSC_VER ) || defined( __LCC__ ) || \
( defined( __GNUC__ ) && ! defined( __RSXNT__ ) )
# define HB_GET_LARGE_UINT( v ) ( ( double ) (v).LowPart + \
( double ) (v).HighPart * \
( ( ( double ) 0xFFFFFFFF ) + 1 ) )
#else
/* NOTE: Borland doesn't seem to deal with the un-named
struct that is part of ULARGE_INTEGER
[pt] */
# define HB_GET_LARGE_UINT( v ) ( ( double ) (v).u.LowPart + \
( double ) (v).u.HighPart * \
( ( ( double ) 0xFFFFFFFF ) + 1 ) )
#endif
ULARGE_INTEGER i64FreeBytesToCaller, i64TotalBytes, i64FreeBytes;
#if ! defined( HB_OS_WIN_CE ) && ! defined( HB_OS_WIN_64 )
fResult = s_pGetDiskFreeSpaceEx( lpPath,
( PULARGE_INTEGER ) &i64FreeBytesToCaller,
( PULARGE_INTEGER ) &i64TotalBytes,
( PULARGE_INTEGER ) &i64FreeBytes );
#else
fResult = GetDiskFreeSpaceEx( lpPath,
( PULARGE_INTEGER ) &i64FreeBytesToCaller,
( PULARGE_INTEGER ) &i64TotalBytes,
( PULARGE_INTEGER ) &i64FreeBytes );
#endif
hb_fsSetIOError( fResult, 0 );
if( fResult )
{
switch( uiType )
{
case HB_DISK_AVAIL:
dSpace = HB_GET_LARGE_UINT( i64FreeBytesToCaller );
break;
case HB_DISK_FREE:
dSpace = HB_GET_LARGE_UINT( i64FreeBytes );
break;
case HB_DISK_TOTAL:
dSpace = HB_GET_LARGE_UINT( i64TotalBytes );
break;
case HB_DISK_USED:
dSpace = HB_GET_LARGE_UINT( i64TotalBytes ) -
HB_GET_LARGE_UINT( i64FreeBytes );
break;
}
}
}
SetErrorMode( uiErrMode );
}
if( lpFree )
hb_xfree( lpFree );
}
#elif defined( HB_OS_DOS ) || defined( HB_OS_OS2 )
{
HB_USHORT uiDrive;
uiDrive = pszPath == NULL || pszPath[ 0 ] == 0 ||
pszPath[ 1 ] != HB_OS_DRIVE_DELIM_CHR ? 0 :
( pszPath[ 0 ] >= 'A' && pszPath[ 0 ] <= 'Z' ?
pszPath[ 0 ] - 'A' + 1 :
( pszPath[ 0 ] >= 'a' && pszPath[ 0 ] <= 'z' ?
pszPath[ 0 ] - 'a' + 1 : 0 ) );
#if defined( HB_OS_DOS )
for( ;; )
{
union REGS regs;
regs.HB_XREGS.dx = uiDrive;
regs.h.ah = 0x36;
HB_DOS_INT86( 0x21, ®s, ®s );
if( regs.HB_XREGS.ax != 0xFFFF )
{
HB_USHORT uiClusterTotal = regs.HB_XREGS.dx;
HB_USHORT uiClusterFree = regs.HB_XREGS.bx;
HB_USHORT uiSecPerCluster = regs.HB_XREGS.ax;
HB_USHORT uiSectorSize = regs.HB_XREGS.cx;
switch( uiType )
{
case HB_DISK_AVAIL:
case HB_DISK_FREE:
dSpace = ( double ) uiClusterFree *
( double ) uiSecPerCluster *
( double ) uiSectorSize;
break;
case HB_DISK_USED:
case HB_DISK_TOTAL:
dSpace = ( double ) uiClusterTotal *
( double ) uiSecPerCluster *
( double ) uiSectorSize;
if( uiType == HB_DISK_USED )
dSpace -= ( double ) uiClusterFree *
( double ) uiSecPerCluster *
( double ) uiSectorSize;
break;
}
}
else
{
if( hb_errRT_BASE_Ext1( EG_OPEN, 2018, NULL, NULL, 0, ( EF_CANDEFAULT | EF_CANRETRY ), HB_ERR_ARGS_BASEPARAMS ) == E_RETRY )
continue;
}
break;
}
#else /* HB_OS_OS2 */
{
struct _FSALLOCATE fsa;
APIRET rc;
/* Query level 1 info from filesystem */
while( ( rc = DosQueryFSInfo( uiDrive, 1, &fsa, sizeof( fsa ) ) ) != NO_ERROR )
{
if( hb_errRT_BASE_Ext1( EG_OPEN, 2018, NULL, NULL, 0, ( EF_CANDEFAULT | EF_CANRETRY ), HB_ERR_ARGS_BASEPARAMS ) != E_RETRY )
break;
}
hb_fsSetError( ( HB_ERRCODE ) rc );
if( rc == NO_ERROR )
{
switch( uiType )
{
case HB_DISK_AVAIL:
case HB_DISK_FREE:
dSpace = ( double ) fsa.cUnitAvail *
( double ) fsa.cSectorUnit *
( double ) fsa.cbSector;
break;
case HB_DISK_USED:
case HB_DISK_TOTAL:
dSpace = ( double ) fsa.cUnit *
( double ) fsa.cSectorUnit *
( double ) fsa.cbSector;
if( uiType == HB_DISK_USED )
dSpace -= ( double ) fsa.cUnitAvail *
( double ) fsa.cSectorUnit *
( double ) fsa.cbSector;
break;
}
}
}
#endif
}
#elif defined( HB_OS_UNIX ) && \
!( defined( __WATCOMC__ ) || defined( __CEGCC__ ) || defined( HB_OS_SYMBIAN ) )
{
#if defined( HB_OS_DARWIN ) || defined( HB_OS_ANDROID ) || \
defined( HB_OS_VXWORKS )
struct statfs sf;
#else
struct statvfs sf;
#endif
char * pszFree;
pszPath = hb_fsNameConv( pszPath, &pszFree );
#if defined( HB_OS_DARWIN ) || defined( HB_OS_ANDROID ) || \
defined( HB_OS_VXWORKS )
if( statfs( pszPath, &sf ) == 0 )
#else
if( statvfs( pszPath, &sf ) == 0 )
#endif
{
switch( uiType )
{
case HB_DISK_AVAIL:
dSpace = ( double ) sf.f_bavail * ( double ) sf.f_bsize;
break;
case HB_DISK_FREE:
dSpace = ( double ) sf.f_bfree * ( double ) sf.f_bsize;
break;
case HB_DISK_USED:
dSpace = ( double ) ( sf.f_blocks - sf.f_bfree ) *
( double ) sf.f_bsize;
break;
case HB_DISK_TOTAL:
dSpace = ( double ) sf.f_blocks * ( double ) sf.f_bsize;
break;
}
hb_fsSetIOError( HB_TRUE, 0 );
}
else
hb_fsSetIOError( HB_FALSE, 0 );
if( pszFree )
hb_xfree( pszFree );
}
#else
{
int iTODO;
HB_SYMBOL_UNUSED( uiType );
}
#endif
return dSpace;
}
static HB_ERRCODE pgsqlOpen( SQLBASEAREAP pArea )
{
PGconn * pConn = ( ( SDDCONN * ) pArea->pConnection->pSDDConn )->pConn;
SDDDATA * pSDDData;
PGresult * pResult;
ExecStatusType status;
PHB_ITEM pItemEof, pItem;
HB_USHORT uiFields, uiCount;
HB_BOOL bError;
DBFIELDINFO pFieldInfo;
pArea->pSDDData = memset( hb_xgrab( sizeof( SDDDATA ) ), 0, sizeof( SDDDATA ) );
pSDDData = ( SDDDATA * ) pArea->pSDDData;
pResult = PQexec( pConn, pArea->szQuery );
if( ! pResult )
{
hb_errRT_PostgreSQLDD( EG_OPEN, ESQLDD_LOWMEMORY, "Query failed", NULL, 0 ); /* Low memory, etc */
return HB_FAILURE;
}
status = PQresultStatus( pResult );
if( status != PGRES_TUPLES_OK && status != PGRES_COMMAND_OK )
{
hb_errRT_PostgreSQLDD( EG_OPEN, ESQLDD_INVALIDQUERY, PQresultErrorMessage( pResult ), pArea->szQuery, ( HB_ERRCODE ) status );
PQclear( pResult );
return HB_FAILURE;
}
pSDDData->pResult = pResult;
uiFields = ( HB_USHORT ) PQnfields( pResult );
SELF_SETFIELDEXTENT( ( AREAP ) pArea, uiFields );
pItemEof = hb_itemArrayNew( uiFields );
pItem = hb_itemNew( NULL );
bError = HB_FALSE;
for( uiCount = 0; uiCount < uiFields; uiCount++ )
{
pFieldInfo.atomName = PQfname( pResult, ( int ) uiCount );
pFieldInfo.uiDec = 0;
switch( PQftype( pResult, ( int ) uiCount ) )
{
case BPCHAROID:
case VARCHAROID:
pFieldInfo.uiType = HB_FT_STRING;
pFieldInfo.uiLen = ( HB_USHORT ) PQfmod( pResult, uiCount ) - 4;
break;
case TEXTOID:
pFieldInfo.uiType = HB_FT_MEMO;
pFieldInfo.uiLen = 10;
break;
case NUMERICOID:
pFieldInfo.uiType = HB_FT_DOUBLE;
pFieldInfo.uiLen = ( PQfmod( pResult, uiCount ) - 4 ) >> 16;
pFieldInfo.uiDec = ( PQfmod( pResult, uiCount ) - 4 ) & 0xFFFF;
break;
case INT2OID:
pFieldInfo.uiType = HB_FT_INTEGER;
pFieldInfo.uiLen = 6;
break;
case INT4OID:
pFieldInfo.uiType = HB_FT_INTEGER;
pFieldInfo.uiLen = 11;
break;
case INT8OID:
case OIDOID:
pFieldInfo.uiType = HB_FT_LONG;
pFieldInfo.uiLen = 20;
break;
case FLOAT4OID:
case FLOAT8OID:
case CASHOID: /* TODO: ??? */
pFieldInfo.uiType = HB_FT_DOUBLE;
pFieldInfo.uiLen = 16;
pFieldInfo.uiDec = 2; /* TODO: hb_set.SET_DECIMALS ??? */
break;
case BOOLOID:
pFieldInfo.uiType = HB_FT_LOGICAL;
pFieldInfo.uiLen = 1;
break;
case DATEOID:
pFieldInfo.uiType = HB_FT_DATE;
pFieldInfo.uiLen = 8;
break;
case INETOID:
pFieldInfo.uiType = HB_FT_STRING;
pFieldInfo.uiLen = 29;
break;
case CIDROID:
pFieldInfo.uiType = HB_FT_STRING;
pFieldInfo.uiLen = 32;
break;
case MACADDROID:
pFieldInfo.uiType = HB_FT_STRING;
pFieldInfo.uiLen = 17;
break;
case BITOID:
case VARBITOID:
pFieldInfo.uiType = HB_FT_STRING;
pFieldInfo.uiLen = ( HB_USHORT ) PQfsize( pResult, uiCount );
break;
case TIMEOID:
pFieldInfo.uiType = HB_FT_STRING;
pFieldInfo.uiLen = 12;
break;
case TIMESTAMPOID:
pFieldInfo.uiType = HB_FT_STRING;
pFieldInfo.uiLen = 23;
break;
case TIMETZOID:
pFieldInfo.uiType = HB_FT_STRING;
pFieldInfo.uiLen = 15;
break;
case TIMESTAMPTZOID:
pFieldInfo.uiType = HB_FT_STRING;
pFieldInfo.uiLen = 26;
break;
case NAMEOID:
pFieldInfo.uiType = HB_FT_STRING;
pFieldInfo.uiLen = 63;
break;
case BYTEAOID:
pFieldInfo.uiType = HB_FT_STRING;
pFieldInfo.uiLen = 0;
break;
default:
pFieldInfo.uiType = 0;
pFieldInfo.uiLen = 0;
bError = HB_TRUE;
break;
}
/* printf( "field:%s \ttype:%d \tsize:%d \tformat:%d \tmod:%d err=%d\n", pFieldInfo.atomName, PQftype( pResult, ( int ) uiCount ), PQfsize( pResult, uiCount ), PQfformat( pResult, uiCount ) , PQfmod( pResult, uiCount ), bError ); */
if( ! bError )
{
switch( pFieldInfo.uiType )
{
case HB_FT_STRING:
{
char * pStr;
pStr = ( char * ) hb_xgrab( pFieldInfo.uiLen + 1 );
memset( pStr, ' ', pFieldInfo.uiLen );
pStr[ pFieldInfo.uiLen ] = '\0';
hb_itemPutCL( pItem, pStr, pFieldInfo.uiLen );
hb_xfree( pStr );
break;
}
case HB_FT_MEMO:
hb_itemPutC( pItem, NULL );
hb_itemSetCMemo( pItem );
break;
case HB_FT_INTEGER:
hb_itemPutNI( pItem, 0 );
break;
case HB_FT_LONG:
hb_itemPutNL( pItem, 0 );
break;
case HB_FT_DOUBLE:
hb_itemPutND( pItem, 0.0 );
break;
case HB_FT_LOGICAL:
hb_itemPutL( pItem, HB_FALSE );
break;
case HB_FT_DATE:
hb_itemPutDS( pItem, NULL );
break;
default:
hb_itemClear( pItem );
bError = HB_TRUE;
break;
}
hb_arraySetForward( pItemEof, uiCount + 1, pItem );
/* if( pFieldInfo.uiType == HB_IT_DOUBLE || pFieldInfo.uiType == HB_IT_INTEGER )
pFieldInfo.uiType = HB_IT_LONG;
*/
if( ! bError )
bError = ( SELF_ADDFIELD( ( AREAP ) pArea, &pFieldInfo ) == HB_FAILURE );
}
if( bError )
break;
}
hb_itemRelease( pItem );
if( bError )
{
hb_itemClear( pItemEof );
hb_itemRelease( pItemEof );
hb_errRT_PostgreSQLDD( EG_CORRUPTION, ESQLDD_INVALIDFIELD, "Invalid field type", pArea->szQuery, 0 );
return HB_FAILURE;
}
pArea->ulRecCount = ( HB_ULONG ) PQntuples( pResult );
pArea->pRow = ( void ** ) hb_xgrab( ( pArea->ulRecCount + 1 ) * sizeof( void * ) );
pArea->pRowFlags = ( HB_BYTE * ) hb_xgrab( ( pArea->ulRecCount + 1 ) * sizeof( HB_BYTE ) );
memset( pArea->pRowFlags, 0, ( pArea->ulRecCount + 1 ) * sizeof( HB_BYTE ) );
*pArea->pRow = pItemEof;
pArea->pRowFlags[ 0 ] = SQLDD_FLAG_CACHED;
pArea->fFetched = HB_TRUE;
return HB_SUCCESS;
}
static void hb_pcre_free( void * ptr )
{
hb_xfree( ptr );
}
/* the contents of the inserted bytes are indeterminate, i.e. you'll have to
write to them before they mean anything */
static int _ins_buff( PFT_TEXT ft_text, HB_ISIZ iLen )
{
char * ReadBuff = ( char * ) hb_xgrab( BUFFSIZE );
char * WriteBuff = ( char * ) hb_xgrab( BUFFSIZE );
char * SaveBuff;
HB_FOFFSET fpRead, fpWrite;
HB_ISIZ WriteLen, ReadLen;
HB_ISIZ SaveLen;
HB_ISIZ iLenRemaining = iLen;
/* set target move distance, this allows iLen to be greater than BUFFSIZE */
iLen = HB_MIN( iLenRemaining, BUFFSIZE );
iLenRemaining -= iLen;
/* initialize file pointers */
fpRead = ft_text->offset[ ft_text->area ];
fpWrite = ft_text->offset[ ft_text->area ] + iLen;
/* do initial load of both buffers */
hb_fsSeekLarge( ft_text->handles[ ft_text->area ], fpRead, FS_SET );
WriteLen = hb_fsRead( ft_text->handles[ ft_text->area ], WriteBuff, BUFFSIZE );
fpRead += WriteLen;
ReadLen = hb_fsRead( ft_text->handles[ ft_text->area ], ReadBuff, BUFFSIZE );
fpRead += ReadLen;
ft_text->error[ ft_text->area ] = 0;
while( ! ft_text->error[ ft_text->area ] && iLen > 0 )
{
while( WriteLen > 0 )
{
/* position to beginning of write area */
if( hb_fsSeekLarge( ft_text->handles[ ft_text->area ], fpWrite, FS_SET ) != fpWrite )
{
ft_text->error[ ft_text->area ] = hb_fsError();
break;
}
SaveLen = hb_fsWriteLarge( ft_text->handles[ ft_text->area ], WriteBuff, WriteLen );
if( ! SaveLen )
{
ft_text->error[ ft_text->area ] = hb_fsError();
break;
}
/* move write pointer */
fpWrite += SaveLen;
if( SaveLen != WriteLen )
{
/* error, fetch errcode and quit */
ft_text->error[ ft_text->area ] = hb_fsError();
break;
}
#if 0
WriteLen = SaveLen;
#endif
/* swap buffers */
SaveBuff = WriteBuff;
WriteBuff = ReadBuff;
ReadBuff = SaveBuff;
WriteLen = ReadLen;
/* return to read area and read another buffer */
hb_fsSeekLarge( ft_text->handles[ ft_text->area ], fpRead, FS_SET );
ReadLen = hb_fsRead( ft_text->handles[ ft_text->area ], ReadBuff, BUFFSIZE );
fpRead += ReadLen;
}
iLen = HB_MIN( iLenRemaining, BUFFSIZE );
iLenRemaining -= iLen;
}
/* store length in bytes, set legacy EOF marker */
ft_text->lastbyte[ ft_text->area ] = hb_fsSeekLarge( ft_text->handles[ ft_text->area ], fpWrite, FS_SET );
hb_fsWrite( ft_text->handles[ ft_text->area ], WriteBuff, 0 );
/* clear last_rec so next gobot will recount the records */
ft_text->last_rec[ ft_text->area ] = 0;
hb_fsSeekLarge( ft_text->handles[ ft_text->area ], ft_text->offset[ ft_text->area ], FS_SET );
hb_xfree( ReadBuff );
hb_xfree( WriteBuff );
return ft_text->error[ ft_text->area ];
}
/*
* Implementação de printf() para Harbour/xHarbour.
*
* TODO: Creio que uma ótima melhoria seria somar o tamanho de todos os argumentos
* e criar um buffer já pre-determinado com um tamanho +/- necessário para evitar
* tantas realocações de memoria como ocorre nestes casos.
* 26/07/2008 - 08:17:42
*/
static
char *wx_printf( ULONG *Length )
{
PPrintInfo pInfo;
char c;
char *result;
ULONG request_len;
*Length = 0L;
// o primeiro argumento tem que ser uma string!
if ( !ISCHAR(1) )
return NULL;
/* Iniciamos a memoria */
pInfo = (PPrintInfo) hb_xgrab( sizeof(TPrintInfo) );
memset( pInfo, 0, sizeof(TPrintInfo) );
pInfo->Mask = hb_parcx(1);
pInfo->msk_len= hb_parclen(1);
pInfo->Result = (char *) hb_xgrab( pInfo->msk_len+1 );
pInfo->Buffer = pInfo->Result;
pInfo->cap_len= pInfo->msk_len;
pInfo->argp ++;
/* processamos a string como um todo */
while (pInfo->error == NONE &&
pInfo->msk_len &&
pInfo->Mask[0] )
{
c = pInfo->Mask[0];
switch (c)
{
case '%':
{
/*
* Se nao tem nenhum item de argumento, e o proximo caracter de escape nao for
* o "%", entao temos que abortar a rotina... indicando erro de argumento!
*/
if (pInfo->Mask[1] == '%')
{
printf_add_str( pInfo, "%", 1L );
pInfo->Mask += 2;
pInfo->msk_len -= 2;
continue;
}
pInfo->argp ++;
printf_add_conv( pInfo, hb_param( pInfo->argp, HB_IT_ANY ));
continue;
}
default:
{
// Precisa realocar memoria?
request_len = 1L;
if (pInfo->out_len+request_len > pInfo->cap_len)
{
pInfo->cap_len += request_len;
pInfo->Result = (char *) hb_xrealloc( pInfo->Result, pInfo->cap_len+1 );
pInfo->Buffer = pInfo->Result + (pInfo->out_len);
pInfo->out_len += request_len;
} else {
pInfo->out_len += request_len;
}
/*
* É um caracter simples ou é uma sequencia de escape a ser add?
* Links relacionados:
* http://docs.sun.com/app/docs/doc/816-0220/6m6nkorp8?a=view
* http://docs.sun.com/app/docs/doc/816-0213/6m6ne387j?a=view
*/
if (c == '\\')
{
pInfo->Mask ++;
pInfo->msk_len--;
if (!pInfo->msk_len)
continue;
c = pInfo->Mask[0];
switch(c)
{
case '\\':
c = '\\';
break;
case '\0':
c = '\0';
break;
case 'a':
c = '\a';
break;
case 'b':
c = '\b';
break;
case 'f':
c = '\f';
break;
case 'n':
c = '\n';
break;
case 'r':
c = '\r';
break;
case 't':
c = '\t';
break;
case 'v':
c = '\v';
break;
}
}
pInfo->Buffer[0] = c;
pInfo->Buffer ++;
pInfo->Mask ++;
pInfo->msk_len--;
break;
}
}
}
pInfo->Result[pInfo->out_len] = '\0';
result = pInfo->Result;
*Length = pInfo->out_len;
/* Liberamos a memoria alocada */
hb_xfree( pInfo );
return result;
}
// 26/07/2008 - 11:32:47
static
void printf_add_conv( PPrintInfo pInfo, PHB_ITEM pItem )
{
char flag = 0;
int width = 0;
int precision = 0;
char specifier = '\0';
char m = '\0';
char c;
char mask[20];
const char *t1;
const char *t2;
char * cValue;
double dValue;
ULONG Length;
/*
* Procura por uma string de conversao com o formato:
* 0 1 2 3 4
* %[flags][width][.precision][length]specifier
*
*/
t1 = pInfo->Mask;
mask[0] = '\0';
pInfo->Mask ++;
pInfo->msk_len--;
/*
* Se nao tem nenhum item de argumento, e o proximo caracter de escape nao for
* o "%", entao temos que abortar a rotina... indicando erro de argumento!
*/
if (pInfo->msk_len &&
// pInfo->Mask[0] != '%' &&
!pItem)
{
pInfo->error = FAILURE;
return;
}
/* processamos a string como um todo */
while (pInfo->error == NONE &&
pInfo->msk_len &&
pInfo->Mask[0] )
{
c = pInfo->Mask[0];
// setou o flag?
if (strchr( "-+ #0", c ))
{
flag = c;
c = 'A';
}
// setar o width?
if (strchr( "1234567890", c ))
{
char *t = (char *) hb_xgrab(15);
char *s = t;
do
{
*t = c;
t++;
pInfo->Mask ++;
pInfo->msk_len--;
c = pInfo->Mask[0];
} while (pInfo->msk_len && strchr( "1234567890", c ));
*t = '\0';
width = atoi( s );
hb_xfree(s);
}
// setar precision?
if (c == '.')
{
char *t = (char *) hb_xgrab(15);
char *s = t;
pInfo->Mask ++;
pInfo->msk_len--;
c = pInfo->Mask[0];
while (pInfo->msk_len && strchr( "1234567890", c ))
{
*t = c;
t++;
pInfo->Mask ++;
pInfo->msk_len--;
c = pInfo->Mask[0];
}
*t = '\0';
precision = atoi( s );
hb_xfree(s);
c = pInfo->Mask[0];
}
if (c == 'l' && strchr( "idouxX", pInfo->Mask[1] ))
m = c;
if (c == 'h' && strchr( "idouxX", pInfo->Mask[1] ))
m = c;
if (c == 'L' && strchr( "eEfgG", pInfo->Mask[1] ))
m = c;
// Chegou no tipo?
if (strchr( "cdieEfgGosuxXpn%", c ))
{
specifier = c;
pInfo->Mask ++;
pInfo->msk_len--;
t2 = pInfo->Mask;
switch( specifier )
{
case '%':
{
printf_add_str( pInfo, "%", 1L );
break;
}
case 'c':
// O argumento é tratado como um inteiro, e mostrado como o caractere ASCII correspondente.
{
char s[2];
memset( s, 0, 2 );
if (HB_IS_STRING( pItem ))
{
const char *t = hb_itemGetCPtr( pItem );
s[0] = ((t) ? t[0] : 0);
} else if( HB_IS_NUMERIC( pItem ) )
{
s[0] = (char) hb_itemGetNI( pItem );
}
printf_add_str( pInfo, s, 1L );
break;
}
case 's':
{
Length = t2-t1;
width = max( hb_itemGetCLen( pItem ), (ULONG) width );
cValue = (char *) hb_xgrab( width + 1 );
memmove( mask, t1, Length );
mask[Length] = '\0';
cValue[0] = '\0';
Length = sprintf( cValue, mask, hb_itemGetCPtr( pItem ) );
printf_add_str( pInfo, cValue, Length );
hb_xfree( cValue );
break;
}
case 'p':
{
char s[9];
s[0] = '\0';
sprintf( s, "%p", hb_itemGetPtr( pItem ) );
printf_add_str( pInfo, s, 8);
break;
}
/*
* Separamos aqui as operações sobre inteiros
*/
case 'i':
case 'd':
// O argumento é tratado como um INTEIRO, e mostrado como um número decimal com sinal.
case 'o':
// O argumento é tratado com um INTEIRO, e mostrado como un número octal.
case 'u':
// O argumento é tratado com um INTEIRO, e mostrado como um número decimal sem sinal.
case 'x':
// O argumento é tratado como um INTEIRO, e mostrado como um número hexadecimal (com as letras minúsculas).
case 'X':
// O argumento é tratado como um INTEIRO, e mostrado como um número hexadecimal (com as letras maiúsculas).
{
Length = t2-t1;
width = ((width) ? width : 32 );
cValue = (char *) hb_xgrab( width + 1 );
memmove( mask, t1, Length );
mask[Length] = '\0';
cValue[0] = '\0';
if (m == '\0')
Length = sprintf( cValue, mask, (int) hb_itemGetNI( pItem ));
if (m == 'l')
Length = sprintf( cValue, mask, (LONG) hb_itemGetNL( pItem )); // como LONG ???
if (m == 'h')
Length = sprintf( cValue, mask, (LONG) hb_itemGetNL( pItem )); // como LONG ???
printf_add_str( pInfo, cValue, Length );
hb_xfree( cValue );
break;
}
/*
* Separamos aqui as operações com numeros flutuantes
*/
case 'e' :
// O argumento é tratado como notação científica (e.g. 1.2e+2).
case 'E' :
// O argumento é tratado como notação científica (e.g. 1.2e+2).
case 'f' :
// O argumento é tratado como um float, e mostrado como um número de ponto flutuante.
case 'F' :
// O argumento é tratado como um float, e mostrado como um número de ponto flutuante.
{
Length = t2-t1;
width = ((width) ? width : 64 );
dValue = (double) hb_itemGetND( pItem ); // converting double --> float ???
cValue = (char *) hb_xgrab( width + 1 );
memmove( mask, t1, Length );
mask[Length] = '\0';
sprintf( cValue, mask, dValue );
printf_add_str( pInfo, cValue, strlen( cValue ) );
hb_xfree( cValue );
break;
}
default:
break;
}
break;
} else {
pInfo->Mask ++;
pInfo->msk_len--;
}
}
}
static HB_ERRCODE sqlbaseRddInfo( LPRDDNODE pRDD, HB_USHORT uiIndex, ULONG ulConnect, PHB_ITEM pItem )
{
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:
{
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;
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;
}
/*
default:
return SUPER_RDDINFO( pRDD, uiIndex, ulConnect, pItem );
*/
}
return HB_SUCCESS;
}
static HB_ERRCODE sqlbaseCreate( SQLBASEAREAP pArea, LPDBOPENINFO pOpenInfo )
{
PHB_ITEM pItemEof, pItem;
HB_USHORT uiCount;
HB_BOOL bError;
pArea->ulConnection = pOpenInfo->ulConnection ? pOpenInfo->ulConnection : s_ulConnectionCurrent;
if ( pArea->ulConnection > s_ulConnectionCount ||
( pArea->ulConnection && ! s_pConnection[ pArea->ulConnection - 1 ] ) )
{
hb_errRT_SQLBASE( EG_OPEN, ESQLDD_NOTCONNECTED, "Not connected", NULL );
return HB_FAILURE;
}
if ( pArea->ulConnection )
{
pArea->pConnection = s_pConnection[ pArea->ulConnection - 1 ];
pArea->pConnection->uiAreaCount++;
pArea->pSDD = pArea->pConnection->pSDD;
}
else
{
pArea->pSDD = &sddNull;
}
pItemEof = hb_itemArrayNew( pArea->area.uiFieldCount );
bError = HB_FALSE;
for ( uiCount = 0; uiCount < pArea->area.uiFieldCount; uiCount++ )
{
LPFIELD pField = pArea->area.lpFields + uiCount;
switch ( pField->uiType )
{
case HB_FT_STRING:
{
char* pStr;
pStr = ( char * ) hb_xgrab( pField->uiLen + 1 );
memset( pStr, ' ', pField->uiLen );
pStr[ pField->uiLen ] = '\0';
pItem = hb_itemPutCL( NULL, pStr, pField->uiLen );
hb_xfree( pStr );
break;
}
case HB_FT_MEMO:
pItem = hb_itemPutC( NULL, NULL );
break;
case HB_FT_INTEGER:
if ( pField->uiDec )
pItem = hb_itemPutND( NULL, 0.0 );
else
pItem = hb_itemPutNI( NULL, 0 );
break;
case HB_FT_LONG:
if ( pField->uiDec )
pItem = hb_itemPutND( NULL, 0.0 );
else
pItem = hb_itemPutNL( NULL, 0 );
break;
case HB_FT_FLOAT:
pItem = hb_itemPutND( NULL, 0.0 );
break;
case HB_FT_DOUBLE:
pItem = hb_itemPutND( NULL, 0.0 );
break;
case HB_FT_DATE:
pItem = hb_itemPutDS( NULL, NULL );
break;
case HB_FT_LOGICAL:
pItem = hb_itemPutL( NULL, HB_FALSE );
break;
default:
pItem = hb_itemNew( NULL );
bError = HB_TRUE;
break;
}
hb_arraySetForward( pItemEof, uiCount + 1, pItem );
hb_itemRelease( pItem );
if ( bError )
break;
}
if ( bError )
{
hb_itemClear( pItemEof );
hb_itemRelease( pItemEof );
hb_errRT_SQLBASE( EG_CORRUPTION, ESQLDD_INVALIDFIELD, "Invalid field type", NULL );
SELF_CLOSE( ( AREAP ) pArea );
return HB_FAILURE;
}
pArea->ulRecCount = 0;
pArea->pRow = ( void ** ) hb_xalloc( SQLDD_ROWSET_RESIZE * sizeof( void * ) );
pArea->pRowFlags = ( HB_BYTE * ) hb_xalloc( SQLDD_ROWSET_RESIZE * sizeof( HB_BYTE ) );
pArea->ulRecMax = SQLDD_ROWSET_RESIZE;
* (pArea->pRow) = pItemEof;
pArea->pRowFlags[ 0 ] = SQLDD_FLAG_CACHED;
pArea->fFetched = HB_TRUE;
if ( SUPER_CREATE( ( AREAP ) pArea, pOpenInfo ) != HB_SUCCESS )
{
SELF_CLOSE( ( AREAP ) pArea );
return HB_FAILURE;
}
return SELF_GOTOP( ( AREAP ) pArea );
}
static HB_ERRCODE sqlite3Open( SQLBASEAREAP pArea )
{
sqlite3 * pDb = ( ( SDDCONN * ) pArea->pConnection->pSDDConn )->pDb;
sqlite3_stmt * st = NULL;
SDDDATA * pSDDData;
const char * pszQuery;
HB_SIZE nQueryLen;
void * hQuery;
HB_USHORT uiFields, uiIndex;
PHB_ITEM pItemEof, pItem, pName = NULL;
HB_ERRCODE errCode;
char * szError;
HB_BOOL bError;
pArea->pSDDData = memset( hb_xgrab( sizeof( SDDDATA ) ), 0, sizeof( SDDDATA ) );
pSDDData = ( SDDDATA * ) pArea->pSDDData;
pItem = hb_itemPutC( NULL, pArea->szQuery );
pszQuery = S_HB_ITEMGETSTR( pItem, &hQuery, &nQueryLen );
if( sqlite3_prepare_v2( pDb, pszQuery, ( int ) nQueryLen, &st, NULL ) != SQLITE_OK )
{
hb_strfree( hQuery );
hb_itemRelease( pItem );
szError = sqlite3GetError( pDb, &errCode );
hb_errRT_SQLT3DD( EG_OPEN, ESQLDD_INVALIDQUERY, szError, pArea->szQuery, errCode );
sqlite3_finalize( st );
hb_xfree( szError );
return HB_FAILURE;
}
else
{
hb_strfree( hQuery );
hb_itemRelease( pItem );
}
if( sqlite3_step( st ) != SQLITE_ROW )
{
szError = sqlite3GetError( pDb, &errCode );
hb_errRT_SQLT3DD( EG_OPEN, ESQLDD_INVALIDQUERY, szError, pArea->szQuery, errCode );
sqlite3_finalize( st );
hb_xfree( szError );
return HB_FAILURE;
}
uiFields = ( HB_USHORT ) sqlite3_column_count( st );
SELF_SETFIELDEXTENT( &pArea->area, uiFields );
errCode = 0;
bError = HB_FALSE;
pItemEof = hb_itemArrayNew( uiFields );
for( uiIndex = 0; uiIndex < uiFields; ++uiIndex )
{
DBFIELDINFO dbFieldInfo;
memset( &dbFieldInfo, 0, sizeof( dbFieldInfo ) );
pName = S_HB_ITEMPUTSTR( pName, sqlite3_column_name( st, uiIndex ) );
dbFieldInfo.atomName = hb_itemGetCPtr( pName );
dbFieldInfo.uiType = sqlite3DeclType( st, uiIndex );
pItem = hb_arrayGetItemPtr( pItemEof, uiIndex + 1 );
switch( dbFieldInfo.uiType )
{
case HB_FT_STRING:
{
int iSize = sqlite3_column_bytes( st, uiIndex );
char * pStr;
dbFieldInfo.uiLen = ( HB_USHORT ) HB_MAX( iSize, 10 );
pStr = ( char * ) hb_xgrab( ( HB_SIZE ) dbFieldInfo.uiLen + 1 );
memset( pStr, ' ', dbFieldInfo.uiLen );
hb_itemPutCLPtr( pItem, pStr, dbFieldInfo.uiLen );
break;
}
case HB_FT_BLOB:
dbFieldInfo.uiLen = 4;
hb_itemPutC( pItem, NULL );
break;
case HB_FT_INTEGER:
dbFieldInfo.uiLen = 8;
hb_itemPutNInt( pItem, 0 );
break;
case HB_FT_LONG:
dbFieldInfo.uiLen = 20;
dbFieldInfo.uiDec = ( HB_USHORT ) hb_setGetDecimals();
hb_itemPutNDDec( pItem, 0.0, dbFieldInfo.uiDec );
break;
case HB_FT_ANY:
dbFieldInfo.uiLen = 6;
break;
default:
bError = HB_TRUE;
}
if( ! bError )
bError = ( SELF_ADDFIELD( &pArea->area, &dbFieldInfo ) == HB_FAILURE );
if( bError )
break;
}
hb_itemRelease( pName );
if( bError )
{
hb_itemRelease( pItemEof );
sqlite3_finalize( st );
hb_errRT_SQLT3DD( EG_CORRUPTION, ESQLDD_INVALIDFIELD, "Invalid field type", pArea->szQuery, errCode );
return HB_FAILURE;
}
pArea->ulRecCount = 0;
pArea->ulRecMax = SQLDD_ROWSET_INIT;
pArea->pRow = ( void ** ) hb_xgrab( SQLDD_ROWSET_INIT * sizeof( void * ) );
pArea->pRowFlags = ( HB_BYTE * ) hb_xgrab( SQLDD_ROWSET_INIT * sizeof( HB_BYTE ) );
pArea->pRow[ 0 ] = pItemEof;
pArea->pRowFlags[ 0 ] = SQLDD_FLAG_CACHED;
pSDDData->pStmt = st;
return HB_SUCCESS;
}
int main( int argc, char * argv[] )
{
char * szFile = NULL, * szRuleFile = NULL, * szWordFile = NULL, * szVerFile = NULL;
char * szLogFile = NULL;
BOOL fQuiet = FALSE, fWrite = FALSE, fChgLog = FALSE;
char * szChangeLogID = NULL, * szLastEntry = NULL;
int iResult = 0, i;
PHB_PP_STATE pState;
pState = hb_pp_new();
if( argc >= 2 )
{
szFile = argv[ 1 ];
for( i = 2; szFile && i < argc; i++ )
{
if( ! HB_ISOPTSEP( argv[ i ][ 0 ] ) )
szFile = NULL;
else
{
switch( argv[ i ][ 1 ] )
{
case 'q':
case 'Q':
if( argv[ i ][ 2 ] )
szFile = NULL;
else
fQuiet = TRUE;
break;
case 'w':
case 'W':
if( argv[ i ][ 2 ] )
szFile = NULL;
else
fWrite = TRUE;
break;
case 'c':
case 'C':
fChgLog = TRUE;
if( argv[ i ][ 2 ] )
szLogFile = argv[ i ] + 2;
break;
case 'i':
case 'I':
if( argv[ i ][ 2 ] )
hb_pp_addSearchPath( pState, argv[ i ] + 2, FALSE );
else
szFile = NULL;
break;
case 'o':
case 'O':
if( argv[ i ][ 2 ] )
szRuleFile = argv[ i ] + 2;
else
szFile = NULL;
break;
case 'x':
case 'X':
if( argv[ i ][ 2 ] )
szWordFile = argv[ i ] + 2;
else
szWordFile = NULL;
break;
case 'v':
case 'V':
if( argv[ i ][ 2 ] )
szVerFile = argv[ i ] + 2;
else
szFile = NULL;
break;
default:
szFile = NULL;
break;
}
}
}
}
if( szFile )
{
hb_pp_init( pState, fQuiet, 0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL );
if( hb_pp_inFile( pState, szFile, TRUE, NULL, TRUE ) )
{
char * szSVNID = ( char * ) hb_xgrab( 10 );
char * szSVNDateID = ( char * ) hb_xgrab( 10 );
if( fWrite )
{
char szFileName[ HB_PATH_MAX ];
PHB_FNAME pFileName;
pFileName = hb_fsFNameSplit( szFile );
pFileName->szExtension = ".ppo";
hb_fsFNameMerge( szFileName, pFileName );
hb_xfree( pFileName );
hb_pp_outFile( pState, szFileName, NULL );
}
if( fChgLog )
iResult = hb_pp_parseChangelog( pState, szLogFile, fQuiet,
szSVNID, szSVNDateID, &szChangeLogID, &szLastEntry );
if( iResult == 0 )
iResult = hb_pp_preprocesfile( pState, szRuleFile, szWordFile );
if( iResult == 0 && szVerFile )
iResult = hb_pp_generateVerInfo( szVerFile, szSVNID, szSVNDateID,
szChangeLogID, szLastEntry );
hb_xfree( szSVNID );
hb_xfree( szSVNDateID );
}
else
iResult = 1;
}
else
{
hb_pp_usage( argv[ 0 ] );
iResult = 1;
}
if( szChangeLogID )
hb_xfree( szChangeLogID );
if( szLastEntry )
hb_xfree( szLastEntry );
hb_pp_free( pState );
return iResult;
}
/* internal routine to do buffer skips. Passing a positive value performs
a downward skip, a negative number does an upward skip. Passing 0
skips to the end of file.
Returns a long indicating the number of records skipped */
static long _ft_skip( long iRecs )
{
PFT_TEXT ft_text = ( PFT_TEXT ) hb_stackGetTSD( &s_ft_text );
HB_ISIZ iByteCount;
HB_ISIZ iBytesRead, iBytesRemaining;
char * cPtr;
long iSkipped = 0;
char * cBuff = ( char * ) hb_xgrab( BUFFSIZE );
HB_FOFFSET fpOffset = ft_text->offset[ ft_text->area ];
ft_text->isBof[ ft_text->area ] = HB_FALSE;
ft_text->isEof[ ft_text->area ] = HB_FALSE;
ft_text->error[ ft_text->area ] = 0;
/* iRecs is zero if they want to find the EOF, start a top of file */
if( iRecs == 0 )
{
fpOffset = 0;
ft_text->recno[ ft_text->area ] = 1;
}
if( iRecs >= 0 )
{
do
{
cPtr = cBuff;
/* position file pointer to beginning of current record */
hb_fsSeekLarge( ft_text->handles[ ft_text->area ], fpOffset, FS_SET );
/* read a chunk */
iBytesRead = hb_fsRead( ft_text->handles[ ft_text->area ], cBuff, BUFFSIZE );
if( ! iBytesRead )
{
/* buffer is empty thus EOF, set vars and quit */
ft_text->isEof[ ft_text->area ] = HB_TRUE;
ft_text->last_rec[ ft_text->area ] = ft_text->recno[ ft_text->area ];
ft_text->last_off[ ft_text->area ] = ft_text->offset[ ft_text->area ];
ft_text->error[ ft_text->area ] = hb_fsError();
break;
}
iBytesRemaining = iBytesRead;
/* parse the buffer while there's still stuff in it */
do
{
/* get count of chars in this line */
iByteCount = _findeol( cPtr, iBytesRemaining, NULL );
if( iByteCount > 0 && iByteCount != iBytesRemaining )
{
/* found an EOL, iByteCount points to first char of next record */
iBytesRemaining -= iByteCount;
fpOffset += iByteCount;
cPtr += iByteCount;
ft_text->offset[ ft_text->area ] = fpOffset;
ft_text->recno[ ft_text->area ]++;
iSkipped++;
if( iRecs && ( iSkipped == iRecs ) )
iBytesRemaining = iBytesRead = 0;
}
else
{
/* no more EOLs in this buffer, or EOL is last chars in the buffer */
/* check for EOF */
if( iBytesRead != BUFFSIZE )
{
/* buffer was not full, thus EOF, set vars and quit */
iBytesRemaining = 0;
ft_text->last_rec[ ft_text->area ] = ft_text->recno[ ft_text->area ];
ft_text->last_off[ ft_text->area ] = ft_text->offset[ ft_text->area ];
if( iRecs )
ft_text->isEof[ ft_text->area ] = HB_TRUE;
}
else
{
/* buffer was full, so probably not EOF, but maybe EOL straddled end
of buffer, so back up pointer a bit before doing the next read */
fpOffset = hb_fsSeekLarge( ft_text->handles[ ft_text->area ], 0, FS_RELATIVE ) - 1;
iBytesRemaining = 0;
}
}
}
while( iBytesRemaining > 0 );
}
while( iBytesRead == BUFFSIZE );
}
else
{
/* skip backwards */
iRecs = -iRecs;
if( ft_text->recno[ ft_text->area ] > iRecs )
{
do
{
/* calc offset to read area of file ahead of current pointer */
fpOffset = HB_MAX( ft_text->offset[ ft_text->area ] - BUFFSIZE, 0 );
/* move file pointer */
hb_fsSeekLarge( ft_text->handles[ ft_text->area ], fpOffset, FS_SET );
/* read a chunk */
iBytesRead =
hb_fsRead( ft_text->handles[ ft_text->area ], cBuff, BUFFSIZE );
if( ! iBytesRead )
{
/* buffer is empty thus file is zero len, set vars and quit */
ft_text->isBof[ ft_text->area ] = HB_TRUE;
ft_text->isEof[ ft_text->area ] = HB_TRUE;
ft_text->recno[ ft_text->area ] = 0;
ft_text->offset[ ft_text->area ] = 0;
ft_text->last_rec[ ft_text->area ] = 0;
ft_text->error[ ft_text->area ] = hb_fsError();
break;
}
/* set pointer within buffer */
iBytesRemaining = ( int ) ( ft_text->offset[ ft_text->area ] - fpOffset );
cPtr = cBuff + iBytesRemaining;
/* parse the buffer while there's still stuff in it */
do
{
/* get count of chars in this line */
iByteCount = _findbol( cPtr, iBytesRemaining );
if( iByteCount > 0 )
{
/* found an EOL, iByteCount points to first char of next
record */
iBytesRemaining -= iByteCount;
ft_text->offset[ ft_text->area ] -= iByteCount;
cPtr -= iByteCount;
fpOffset = ft_text->offset[ ft_text->area ];
ft_text->recno[ ft_text->area ]--;
iSkipped++;
if( iSkipped == iRecs )
iBytesRemaining = iBytesRead = 0;
}
else
{
/* no more EOLs in this buffer so we're either at
BOF or record crosses buffer boundary */
/* check for BOF */
if( iBytesRead != BUFFSIZE )
{
/* buffer was not full, thus BOF, set vars and quit */
iBytesRemaining = 0;
ft_text->offset[ ft_text->area ] = 0;
ft_text->recno[ ft_text->area ] = 1;
ft_text->isBof[ ft_text->area ] = HB_TRUE;
}
else
{
/* buffer was full, so not BOF */
iBytesRemaining = 0;
}
}
}
while( iBytesRemaining > 0 );
}
while( fpOffset > 0 && iBytesRead == BUFFSIZE );
}
else
{
ft_text->offset[ ft_text->area ] = 0;
ft_text->recno[ ft_text->area ] = 1;
ft_text->isBof[ ft_text->area ] = HB_TRUE;
}
}
hb_xfree( cBuff );
return iSkipped;
}
static void hb_ParseLine( PHB_ITEM pReturn, const char * szText, int iDelimiter, int * iWord )
{
if( szText )
{
HB_ISIZ nLen = strlen( szText );
if( nLen > 0 )
{
PHB_ITEM pTemp = hb_itemNew( NULL );
HB_ISIZ i = 0;
int word_count = 0;
/* booked enough memory */
char * szResult = ( char * ) hb_xgrab( nLen + 1 );
#if 0
while( nLen )
{
if( szText[ nLen - 1 ] && ! HB_ISSPACE( szText[ nLen - 1 ] ) )
break;
nLen--;
}
szText[ nLen ] = 0;
nLen = strlen( szText );
#endif
while( i < nLen )
{
HB_ISIZ ui = 0;
hb_xmemset( szResult, ' ', nLen + 1 );
/* an '"' found, loop until the next one is found */
if( szText[ i ] == '"' )
{
/* an '"' after '"' ? */
if( szText[ i + 1 ] != '"' )
szResult[ ui ] = szText[ i + 1 ];
else
szResult[ ui ] = '\0';
++i;
while( ++i < nLen )
{
if( szText[ i - 1 ] == '"' )
{
szResult[ ui + 1 ] = '\0';
break;
}
else
{
if( szText[ i ] == '"' )
szResult[ ui + 1 ] = '\0';
else
szResult[ ++ui ] = szText[ i ];
}
}
word_count++;
hb_arrayAddForward( pReturn, hb_itemPutC( pTemp, szResult ) );
}
/* delimiter found */
else if( szText[ i ] == iDelimiter )
{
/* first delimiter found but no word yet */
if( word_count == 0 )
{
/* add an empty string */
szResult[ ui ] = '\0';
}
else
{
/* we have already have the first word */
/* check next character */
if( szText[ i - 1 ] == iDelimiter )
{
/* delimiter after delimiter */
/* just add an empty string */
szResult[ ui ] = '\0';
}
else
{
/* ",,0" */
/* it is not a delimiter */
/* move to next character */
++i;
szResult[ ui ] = szText[ i ];
while( ++i < nLen )
{
if( szText[ i ] == iDelimiter )
break;
else
szResult[ ++ui ] = szText[ i ];
}
}
}
word_count++;
szResult[ ui + 1 ] = '\0';
hb_arrayAddForward( pReturn, hb_itemPutC( pTemp, szResult ) );
}
else
{
szResult[ ui ] = szText[ i ];
while( ++i < nLen )
{
if( szText[ i ] == iDelimiter )
{
szResult[ ui + 1 ] = '\0';
break;
}
else if( szText[ i ] == '"' )
{
szResult[ ui ] = szText[ i + 1 ];
++i;
while( ++i < nLen )
{
if( szText[ i - 1 ] == '"' )
{
szResult[ ui + 1 ] = '\0';
break;
}
else
{
if( szText[ i ] == '"' )
{
szResult[ ui + 1 ] = '\0';
break;
}
else
szResult[ ++ui ] = szText[ i ];
}
}
}
else
szResult[ ++ui ] = szText[ i ];
}
word_count++;
szResult[ ui + 1 ] = '\0';
hb_arrayAddForward( pReturn, hb_itemPutC( pTemp, szResult ) );
}
i++;
}
/* last character in passed string is a delimiter */
/* just add an empty string */
if( szText[ nLen - 1 ] == iDelimiter )
{
word_count++;
hb_arrayAddForward( pReturn, hb_itemPutC( pTemp, NULL ) );
}
/* store number of words */
*iWord = word_count;
/* clean up */
hb_xfree( szResult );
hb_itemRelease( pTemp );
}
}
}
static PHRB_BODY hb_hrbLoad( const char * szHrbBody, HB_SIZE nBodySize, HB_USHORT usMode, const char * szFileName )
{
PHRB_BODY pHrbBody = NULL;
if( szHrbBody )
{
HB_SIZE nBodyOffset = 0;
HB_SIZE nSize; /* Size of function */
HB_SIZE nPos;
HB_ULONG ul;
char * buffer, ch;
HB_USHORT usBind = ( usMode & HB_HRB_BIND_MODEMASK );
PHB_SYMB pSymRead; /* Symbols read */
PHB_DYNF pDynFunc; /* Functions read */
PHB_DYNS pDynSym;
int iVersion = hb_hrbReadHead( szHrbBody, nBodySize, &nBodyOffset );
if( iVersion == 0 )
{
hb_errRT_BASE( EG_CORRUPTION, 9995, NULL, HB_ERR_FUNCNAME, 0 );
return NULL;
}
pHrbBody = ( PHRB_BODY ) hb_xgrab( sizeof( HRB_BODY ) );
pHrbBody->fInit = HB_FALSE;
pHrbBody->fExit = HB_FALSE;
pHrbBody->lSymStart = -1;
pHrbBody->ulFuncs = 0;
pHrbBody->pSymRead = NULL;
pHrbBody->pDynFunc = NULL;
pHrbBody->pModuleSymbols = NULL;
if( ! hb_hrbReadValue( szHrbBody, nBodySize, &nBodyOffset, &pHrbBody->ulSymbols ) ||
pHrbBody->ulSymbols == 0 )
{
hb_hrbUnLoad( pHrbBody );
hb_errRT_BASE( EG_CORRUPTION, 9996, NULL, HB_ERR_FUNCNAME, 0 );
return NULL;
}
/* calculate the size of dynamic symbol table */
nPos = nBodyOffset;
nSize = 0;
for( ul = 0; ul < pHrbBody->ulSymbols; ul++ ) /* Read symbols in .hrb */
{
while( nBodyOffset < nBodySize )
{
++nSize;
if( szHrbBody[ nBodyOffset++ ] == 0 )
break;
}
nBodyOffset += 2;
if( nBodyOffset >= nBodySize )
{
hb_hrbUnLoad( pHrbBody );
hb_errRT_BASE( EG_CORRUPTION, 9997, NULL, HB_ERR_FUNCNAME, 0 );
return NULL;
}
}
nBodyOffset = nPos;
ul = pHrbBody->ulSymbols * sizeof( HB_SYMB );
pSymRead = ( PHB_SYMB ) hb_xgrab( nSize + ul );
buffer = ( ( char * ) pSymRead ) + ul;
for( ul = 0; ul < pHrbBody->ulSymbols; ul++ ) /* Read symbols in .hrb */
{
pSymRead[ ul ].szName = buffer;
do
{
ch = *buffer++ = szHrbBody[ nBodyOffset++ ];
}
while( ch );
pSymRead[ ul ].scope.value = ( HB_BYTE ) szHrbBody[ nBodyOffset++ ];
pSymRead[ ul ].value.pCodeFunc = ( PHB_PCODEFUNC ) ( HB_PTRDIFF ) szHrbBody[ nBodyOffset++ ];
pSymRead[ ul ].pDynSym = NULL;
if( pHrbBody->lSymStart == -1 &&
( pSymRead[ ul ].scope.value & HB_FS_FIRST ) != 0 &&
( pSymRead[ ul ].scope.value & HB_FS_INITEXIT ) == 0 )
{
pHrbBody->lSymStart = ul;
}
}
/* Read number of functions */
if( ! hb_hrbReadValue( szHrbBody, nBodySize, &nBodyOffset, &pHrbBody->ulFuncs ) )
{
hb_xfree( pSymRead );
hb_hrbUnLoad( pHrbBody );
hb_errRT_BASE( EG_CORRUPTION, 9997, NULL, HB_ERR_FUNCNAME, 0 );
return NULL;
}
pHrbBody->pSymRead = pSymRead;
if( pHrbBody->ulFuncs )
{
pDynFunc = ( PHB_DYNF ) hb_xgrab( pHrbBody->ulFuncs * sizeof( HB_DYNF ) );
memset( pDynFunc, 0, pHrbBody->ulFuncs * sizeof( HB_DYNF ) );
pHrbBody->pDynFunc = pDynFunc;
for( ul = 0; ul < pHrbBody->ulFuncs; ul++ )
{
HB_ULONG ulValue;
/* Read name of function */
pDynFunc[ ul ].szName = hb_hrbReadId( szHrbBody, nBodySize, &nBodyOffset );
if( pDynFunc[ ul ].szName == NULL )
break;
/* Read size of function */
if( ! hb_hrbReadValue( szHrbBody, nBodySize, &nBodyOffset, &ulValue ) )
break;
nSize = ( HB_SIZE ) ulValue;
if( nBodyOffset + nSize > nBodySize )
break;
/* Copy function body */
pDynFunc[ ul ].pCode = ( HB_BYTE * ) hb_xgrab( nSize );
memcpy( ( char * ) pDynFunc[ ul ].pCode, szHrbBody + nBodyOffset, nSize );
nBodyOffset += nSize;
pDynFunc[ ul ].pCodeFunc = ( PHB_PCODEFUNC ) hb_xgrab( sizeof( HB_PCODEFUNC ) );
pDynFunc[ ul ].pCodeFunc->pCode = pDynFunc[ ul ].pCode;
pDynFunc[ ul ].pCodeFunc->pSymbols = pSymRead;
}
if( ul < pHrbBody->ulFuncs )
{
hb_xfree( pSymRead );
hb_hrbUnLoad( pHrbBody );
hb_errRT_BASE( EG_CORRUPTION, 9998, NULL, HB_ERR_FUNCNAME, 0 );
return NULL;
}
}
/* End of PCODE loading, now linking */
for( ul = 0; ul < pHrbBody->ulSymbols; ul++ )
{
if( pSymRead[ ul ].value.pCodeFunc == ( PHB_PCODEFUNC ) SYM_FUNC )
{
nPos = hb_hrbFindSymbol( pSymRead[ ul ].szName, pHrbBody->pDynFunc, pHrbBody->ulFuncs );
if( nPos == SYM_NOT_FOUND )
{
pSymRead[ ul ].value.pCodeFunc = ( PHB_PCODEFUNC ) SYM_EXTERN;
}
else
{
pSymRead[ ul ].value.pCodeFunc = ( PHB_PCODEFUNC ) pHrbBody->pDynFunc[ nPos ].pCodeFunc;
pSymRead[ ul ].scope.value |= HB_FS_PCODEFUNC | HB_FS_LOCAL |
( usBind == HB_HRB_BIND_FORCELOCAL ? HB_FS_STATIC : 0 );
}
}
else if( pSymRead[ ul ].value.pCodeFunc == ( PHB_PCODEFUNC ) SYM_DEFERRED )
{
pSymRead[ ul ].value.pCodeFunc = ( PHB_PCODEFUNC ) SYM_EXTERN;
pSymRead[ ul ].scope.value |= HB_FS_DEFERRED;
}
/* External function */
if( pSymRead[ ul ].value.pCodeFunc == ( PHB_PCODEFUNC ) SYM_EXTERN )
{
pSymRead[ ul ].value.pCodeFunc = NULL;
pDynSym = hb_dynsymFind( pSymRead[ ul ].szName );
if( pDynSym )
{
pSymRead[ ul ].value.pFunPtr = pDynSym->pSymbol->value.pFunPtr;
if( pDynSym->pSymbol->scope.value & HB_FS_PCODEFUNC )
{
pSymRead[ ul ].scope.value |= HB_FS_PCODEFUNC;
}
}
else if( ( pSymRead[ ul ].scope.value & HB_FS_DEFERRED ) == 0 )
{
if( ( usMode & HB_HRB_BIND_LAZY ) != 0 )
pSymRead[ ul ].scope.value |= HB_FS_DEFERRED;
else
{
char szName[ HB_SYMBOL_NAME_LEN + 1 ];
hb_strncpy( szName, pSymRead[ ul ].szName, sizeof( szName ) - 1 );
hb_xfree( pSymRead );
hb_hrbUnLoad( pHrbBody );
hb_errRT_BASE( EG_ARG, 6101, "Unknown or unregistered symbol", szName, 0 );
return NULL;
}
}
}
}
if( hb_vmLockModuleSymbols() )
{
if( usBind == HB_HRB_BIND_LOCAL )
{
for( ul = 0; ul < pHrbBody->ulSymbols; ul++ )
{
if( ( pSymRead[ ul ].scope.value &
( HB_FS_LOCAL | HB_FS_STATIC ) ) == HB_FS_LOCAL )
{
pDynSym = hb_dynsymFind( pSymRead[ ul ].szName );
if( pDynSym )
{
/* convert public function to static one */
pSymRead[ ul ].scope.value |= HB_FS_STATIC;
}
}
}
}
pHrbBody->pModuleSymbols = hb_vmRegisterSymbols( pHrbBody->pSymRead,
( HB_USHORT ) pHrbBody->ulSymbols,
szFileName ? szFileName : "pcode.hrb", 0,
HB_TRUE, HB_FALSE, usBind == HB_HRB_BIND_OVERLOAD );
if( pHrbBody->pModuleSymbols->pModuleSymbols != pSymRead )
{
/*
* Old unused symbol table has been recycled - free the one
* we allocated and disactivate static initialization [druzus]
*/
pHrbBody->pSymRead = pHrbBody->pModuleSymbols->pModuleSymbols;
hb_xfree( pSymRead );
pHrbBody->fInit = HB_TRUE;
}
else
{
/* mark symbol table as dynamically allocated so HVM will free it on exit */
pHrbBody->pModuleSymbols->fAllocated = HB_TRUE;
/* initialize static variables */
hb_hrbInitStatic( pHrbBody );
}
hb_vmUnlockModuleSymbols();
}
else
{
hb_xfree( pSymRead );
hb_hrbUnLoad( pHrbBody );
pHrbBody = NULL;
}
}
return pHrbBody;
}
static HB_ERRCODE pgsqlDisconnect( SQLDDCONNECTION * pConnection )
{
PQfinish( ( ( SDDCONN * ) pConnection->pSDDConn )->pConn );
hb_xfree( pConnection->pSDDConn );
return HB_SUCCESS;
}
PHB_ITEM hb_libLoad( PHB_ITEM pLibName, PHB_ITEM pArgs )
{
void * hDynLib = NULL;
if( hb_itemGetCLen( pLibName ) > 0 )
{
int argc = pArgs ? ( int ) hb_arrayLen( pArgs ) : 0, i;
const char ** argv = NULL;
if( argc > 0 )
{
argv = ( const char ** ) hb_xgrab( sizeof( char * ) * argc );
for( i = 0; i < argc; ++i )
argv[ i ] = hb_arrayGetCPtr( pArgs, i + 1 );
}
if( hb_vmLockModuleSymbols() )
{
/* use stack address as first level marker */
hb_vmBeginSymbolGroup( ( void * ) hb_stackId(), HB_TRUE );
#if defined( HB_OS_WIN )
{
void * hFileName;
hDynLib = ( void * ) LoadLibraryEx( HB_ITEMGETSTR( pLibName, &hFileName, NULL ), NULL, LOAD_WITH_ALTERED_SEARCH_PATH );
hb_strfree( hFileName );
}
#elif defined( HB_OS_OS2 )
{
HB_UCHAR LoadError[ 256 ] = ""; /* Area for load failure information */
HMODULE hDynModule;
if( DosLoadModule( ( PSZ ) LoadError, sizeof( LoadError ),
( PCSZ ) hb_itemGetCPtr( pLibName ), &hDynModule ) == NO_ERROR )
hDynLib = ( void * ) hDynModule;
}
#elif defined( HB_HAS_DLFCN )
hDynLib = ( void * ) dlopen( hb_itemGetCPtr( pLibName ), RTLD_LAZY | RTLD_GLOBAL );
if( ! hDynLib )
{
HB_TRACE( HB_TR_DEBUG, ( "hb_libLoad(): dlopen(): %s", dlerror() ) );
}
#elif defined( HB_CAUSEWAY_DLL )
hDynLib = LoadLibrary( hb_itemGetCPtr( pLibName ) );
#else
{
int iTODO;
}
#endif
/* set real marker */
hb_vmInitSymbolGroup( hDynLib, argc, argv );
hb_vmUnlockModuleSymbols();
}
if( argv )
hb_xfree( ( void * ) argv );
}
if( hDynLib )
{
void ** pLibPtr = ( void ** ) hb_gcAllocate( sizeof( void * ), &s_gcDynlibFuncs );
*pLibPtr = hDynLib;
return hb_itemPutPtrGC( NULL, pLibPtr );
}
return NULL;
}
PHB_ITEM hb_fsDirectory( const char * pszDirSpec, const char * pszAttributes, HB_BOOL fDateTime )
{
PHB_ITEM pDir = hb_itemArrayNew( 0 );
char * pszFree = NULL;
PHB_FFIND ffind;
HB_FATTR ulMask;
/* Get the passed attributes and convert them to Harbour Flags */
ulMask = HB_FA_ARCHIVE | HB_FA_READONLY;
if( pszAttributes && *pszAttributes )
ulMask |= hb_fsAttrEncode( pszAttributes );
if( pszDirSpec && *pszDirSpec )
{
if( ulMask != HB_FA_LABEL )
{
/* CA-Cl*pper compatible behavior - add all file mask when
* last character is directory or drive separator
*/
HB_SIZE nLen = strlen( pszDirSpec ) - 1;
#ifdef HB_OS_HAS_DRIVE_LETTER
if( pszDirSpec[ nLen ] == HB_OS_PATH_DELIM_CHR ||
pszDirSpec[ nLen ] == HB_OS_DRIVE_DELIM_CHR )
#else
if( pszDirSpec[ nLen ] == HB_OS_PATH_DELIM_CHR )
#endif
pszDirSpec = pszFree =
hb_xstrcpy( NULL, pszDirSpec, HB_OS_ALLFILE_MASK, NULL );
}
}
else
pszDirSpec = HB_OS_ALLFILE_MASK;
/* Get the file list */
if( ( ffind = hb_fsFindFirst( pszDirSpec, ulMask ) ) != NULL )
{
PHB_ITEM pSubarray = hb_itemNew( NULL );
do
{
char buffer[ 32 ];
hb_arrayNew ( pSubarray, F_LEN );
hb_arraySetC ( pSubarray, F_NAME, ffind->szName );
hb_arraySetNInt( pSubarray, F_SIZE, ffind->size );
hb_arraySetC ( pSubarray, F_TIME, ffind->szTime );
hb_arraySetC ( pSubarray, F_ATTR, hb_fsAttrDecode( ffind->attr, buffer ) );
if( fDateTime )
hb_arraySetTDT( pSubarray, F_DATE, ffind->lDate, ffind->lTime );
else
hb_arraySetDL ( pSubarray, F_DATE, ffind->lDate );
/* Don't exit when array limit is reached */
hb_arrayAddForward( pDir, pSubarray );
}
while( hb_fsFindNext( ffind ) );
hb_itemRelease( pSubarray );
hb_fsFindClose( ffind );
}
if( pszFree )
hb_xfree( pszFree );
return pDir;
}
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 HB_BOOL hb_SetDefaultPrinter( LPCTSTR lpPrinterName )
{
#if ! defined( HB_OS_WIN_CE )
BOOL bFlag;
DWORD dwNeeded = 0;
HANDLE hPrinter = NULL;
PRINTER_INFO_2 * ppi2 = NULL;
LPTSTR pBuffer = NULL;
/* If Windows 95 or 98, use SetPrinter. */
if( hb_iswin9x() )
{
/* Open this printer so you can get information about it. */
bFlag = OpenPrinter( ( LPTSTR ) lpPrinterName, &hPrinter, NULL );
if( ! bFlag || ! hPrinter )
return HB_FALSE;
/* The first GetPrinter() tells you how big our buffer must
be to hold ALL of PRINTER_INFO_2. Note that this will
typically return FALSE. This only means that the buffer (the 3rd
parameter) was not filled in. You do not want it filled in here. */
SetLastError( 0 );
bFlag = GetPrinter( hPrinter, 2, 0, 0, &dwNeeded );
if( ! bFlag )
{
if( ( GetLastError() != ERROR_INSUFFICIENT_BUFFER ) || ( dwNeeded == 0 ) )
{
ClosePrinter( hPrinter );
return HB_FALSE;
}
}
/* Allocate enough space for PRINTER_INFO_2. */
ppi2 = ( PRINTER_INFO_2 * ) hb_xgrab( dwNeeded );
/* The second GetPrinter() will fill in all the current information
so that all you have to do is modify what you are interested in. */
bFlag = GetPrinter( hPrinter, 2, ( LPBYTE ) ppi2, dwNeeded, &dwNeeded );
if( ! bFlag )
{
ClosePrinter( hPrinter );
hb_xfree( ppi2 );
return HB_FALSE;
}
/* Set default printer attribute for this printer. */
ppi2->Attributes |= PRINTER_ATTRIBUTE_DEFAULT;
bFlag = SetPrinter( hPrinter, 2, ( LPBYTE ) ppi2, 0 );
if( ! bFlag )
{
ClosePrinter( hPrinter );
hb_xfree( ppi2 );
return HB_FALSE;
}
/* Tell all open programs that this change occurred.
Allow each program 1 second to handle this message. */
SendMessageTimeout( HWND_BROADCAST, WM_SETTINGCHANGE, 0L, ( LPARAM ) ( LPCTSTR ) TEXT( "windows" ), SMTO_NORMAL, 1000, NULL );
}
/* If Windows NT, use the SetDefaultPrinter API for Windows 2000,
or WriteProfileString for version 4.0 and earlier. */
else if( hb_iswinnt() )
{
if( hb_iswin2k() ) /* Windows 2000 or later (use explicit call) */
{
HMODULE hWinSpool;
typedef BOOL ( WINAPI * DEFPRINTER )( LPCTSTR ); /* stops warnings */
DEFPRINTER fnSetDefaultPrinter;
hWinSpool = hbwapi_LoadLibrarySystem( TEXT( "winspool.drv" ) );
if( ! hWinSpool )
return HB_FALSE;
fnSetDefaultPrinter = ( DEFPRINTER ) HB_WINAPI_GETPROCADDRESST( hWinSpool,
"SetDefaultPrinter" );
if( ! fnSetDefaultPrinter )
{
FreeLibrary( hWinSpool );
return HB_FALSE;
}
bFlag = ( *fnSetDefaultPrinter )( lpPrinterName );
FreeLibrary( hWinSpool );
if( ! bFlag )
return HB_FALSE;
}
else /* NT4.0 or earlier */
{
HB_ISIZ nStrLen;
/* Open this printer so you can get information about it. */
bFlag = OpenPrinter( ( LPTSTR ) lpPrinterName, &hPrinter, NULL );
if( ! bFlag || ! hPrinter )
return HB_FALSE;
/* The first GetPrinter() tells you how big our buffer must
be to hold ALL of PRINTER_INFO_2. Note that this will
typically return FALSE. This only means that the buffer (the 3rd
parameter) was not filled in. You do not want it filled in here. */
SetLastError( 0 );
bFlag = GetPrinter( hPrinter, 2, 0, 0, &dwNeeded );
if( ! bFlag )
{
if( ( GetLastError() != ERROR_INSUFFICIENT_BUFFER ) || ( dwNeeded == 0 ) )
{
ClosePrinter( hPrinter );
return HB_FALSE;
}
}
/* Allocate enough space for PRINTER_INFO_2. */
ppi2 = ( PRINTER_INFO_2 * ) hb_xgrab( dwNeeded );
/* The second GetPrinter() fills in all the current
information. */
bFlag = GetPrinter( hPrinter, 2, ( LPBYTE ) ppi2, dwNeeded, &dwNeeded );
if( ( ! bFlag ) || ( ! ppi2->pDriverName ) || ( ! ppi2->pPortName ) )
{
ClosePrinter( hPrinter );
hb_xfree( ppi2 );
return HB_FALSE;
}
nStrLen = hbwapi_tstrlen( lpPrinterName ) +
hbwapi_tstrlen( ppi2->pDriverName ) +
hbwapi_tstrlen( ppi2->pPortName ) + 2;
/* Allocate buffer big enough for concatenated string.
String will be in form "printername,drivername,portname". */
pBuffer = ( LPTSTR ) hb_xgrab( ( nStrLen + 1 ) * sizeof( TCHAR ) );
pBuffer[ 0 ] = TEXT( '\0' );
/* Build string in form "printername,drivername,portname". */
hbwapi_tstrncat( pBuffer, lpPrinterName, nStrLen );
hbwapi_tstrncat( pBuffer, TEXT( "," ), nStrLen );
hbwapi_tstrncat( pBuffer, ppi2->pDriverName, nStrLen );
hbwapi_tstrncat( pBuffer, TEXT( "," ), nStrLen );
hbwapi_tstrncat( pBuffer, ppi2->pPortName, nStrLen );
/* Set the default printer in win.ini and registry. */
bFlag = WriteProfileString( TEXT( "windows" ), TEXT( "device" ), pBuffer );
if( ! bFlag )
{
ClosePrinter( hPrinter );
hb_xfree( ppi2 );
hb_xfree( pBuffer );
return HB_FALSE;
}
}
/* Tell all open programs that this change occurred.
Allow each app 1 second to handle this message. */
SendMessageTimeout( HWND_BROADCAST, WM_SETTINGCHANGE, 0L, 0L, SMTO_NORMAL, 1000, NULL );
}
/* Clean up. */
if( hPrinter )
ClosePrinter( hPrinter );
if( ppi2 )
hb_xfree( ppi2 );
if( pBuffer )
hb_xfree( pBuffer );
return HB_TRUE;
#else
HB_SYMBOL_UNUSED( lpPrinterName );
return HB_FALSE;
#endif
}
/* 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;
}
static void sk_add( PHB_SETKEY * sk_list_ptr, HB_BOOL bReturn,
int iKeyCode, PHB_ITEM pAction, PHB_ITEM pIsActive )
{
if( iKeyCode )
{
PHB_SETKEY sk_list_tmp, sk_list_end;
if( pIsActive && ! HB_IS_EVALITEM( pIsActive ) )
pIsActive = NULL;
if( pAction && ! HB_IS_EVALITEM( pAction ) )
pAction = NULL;
sk_list_tmp = sk_findkey( iKeyCode, *sk_list_ptr, &sk_list_end );
if( sk_list_tmp == NULL )
{
if( pAction )
{
sk_list_tmp = ( PHB_SETKEY ) hb_xgrab( sizeof( HB_SETKEY ) );
sk_list_tmp->next = NULL;
sk_list_tmp->iKeyCode = iKeyCode;
sk_list_tmp->pAction = hb_itemNew( pAction );
sk_list_tmp->pIsActive = pIsActive ? hb_itemNew( pIsActive ) : NULL;
if( sk_list_end == NULL )
*sk_list_ptr = sk_list_tmp;
else
sk_list_end->next = sk_list_tmp;
}
}
else
{
/* Return the previous value */
if( bReturn )
hb_itemReturn( sk_list_tmp->pAction );
/* Free the previous values */
hb_itemRelease( sk_list_tmp->pAction );
if( sk_list_tmp->pIsActive )
{
hb_itemRelease( sk_list_tmp->pIsActive );
}
/* Set the new values or free the entry */
if( pAction )
{
sk_list_tmp->pAction = hb_itemNew( pAction );
sk_list_tmp->pIsActive = pIsActive ? hb_itemNew( pIsActive ) : NULL;
}
else
{
/* if this is true, then the key found is the first key in the list */
if( sk_list_end == NULL )
{
sk_list_tmp = *sk_list_ptr;
*sk_list_ptr = sk_list_tmp->next;
hb_xfree( sk_list_tmp );
}
else
{
sk_list_end->next = sk_list_tmp->next;
hb_xfree( sk_list_tmp );
}
}
}
}
}
static void hb_pp_generateRules( FILE * fout, FILE * fword, PHB_PP_STATE pState )
{
PRESERVEDNAME pTemp;
int iDefs = 0, iTrans = 0, iCmds = 0;
UINT wNum = 0;
fprintf( fout, "/*\n * $Id: ppgen.c 9869 2012-12-08 18:25:43Z andijahja $\n */\n\n/*\n"
" * Harbour Project source code:\n"
" * Build in preprocessor rules.\n"
" *\n"
" * Copyright 2006 Przemyslaw Czerpak <druzus / at / priv.onet.pl>\n"
" * www - http://www.harbour-project.org\n"
" *\n"
" * This file is generated automatically by Harbour preprocessor\n"
" * and is covered by the same license as Harbour PP\n"
" */\n\n#define _HB_PP_INTERNAL\n#include \"hbpp.h\"\n\n" );
fprintf( fword, "/*\n * $Id: ppgen.c 9869 2012-12-08 18:25:43Z andijahja $\n */\n\n/*\n"
" * Harbour Project source code:\n"
" * Word list which should not be used as variable names.\n"
" *\n"
" * Copyright 2012 Andi Jahja <*****@*****.**>\n"
" * www - http://www.harbour-project.org\n"
" *\n"
" * This file is generated automatically by Harbour preprocessor\n"
" * and is covered by the same license as Harbour PP\n"
"*/\n\n#include \"hbapi.h\"\n"
"#include \"hbcomp.h\"\n"
"\nstatic const char * s_szReservedName[] = {\n" );
if( pState->pDefinitions )
iDefs = hb_pp_writeRules( fout, pState->pDefinitions, "def" );
if( pState->pTranslations )
iTrans = hb_pp_writeRules( fout, pState->pTranslations, "trs" );
if( pState->pCommands )
iCmds = hb_pp_writeRules( fout, pState->pCommands, "cmd" );
fprintf( fout, "\nvoid hb_pp_setStdRules( PHB_PP_STATE pState )\n{\n" );
hb_pp_generateInitFunc( fout, iDefs, "Definitions", "def" );
hb_pp_generateInitFunc( fout, iTrans, "Translations", "trs" );
hb_pp_generateInitFunc( fout, iCmds, "Commands", "cmd" );
fprintf( fout, "}\n" );
do
{
if ( ! hb_pp_NameFound( ( char * ) s_otherReservedName[ wNum ] ) )
fprintf( fword, " \"%s\",\n", ( char* ) s_otherReservedName[ wNum ] );
++ wNum;
} while( wNum < sizeof( s_otherReservedName ) / sizeof( char * ) );
pTemp = s_PPReservedName;
do
{
fprintf( fword, " \"%s\"", pTemp->szName );
hb_xfree( pTemp->szName );
pTemp = pTemp->pNext;
hb_xfree( ( void * ) s_PPReservedName );
s_PPReservedName = pTemp;
fprintf( fword, s_PPReservedName ? ",\n" : "\n" );
} while( pTemp );
fprintf( fword, "};\n\n"
"#define RESERVED_NAMES sizeof( s_szReservedName ) / sizeof( char * )\n\n"
"BOOL hb_compReservedPPName( char * szName )\n"
"{\n"
" UINT wNum = 0;\n"
" int iFound = 1;\n"
" int iLen = ( int ) strlen( szName );\n\n"
" while( wNum < RESERVED_NAMES && iFound )\n"
" {\n"
" int u = ( int ) strlen( s_szReservedName[ wNum ] ) ;\n\n"
" if ( iLen == u )\n"
" {\n"
" int i, j = 0;\n\n"
" for ( i = 0; i < u; i ++ )\n"
" {\n"
" if ( szName[ i ] == s_szReservedName[ wNum ] [ i ] )\n"
" j ++;\n"
" else\n"
" break;\n"
" }\n\n"
" if ( j == u )\n"
" iFound = 0;\n"
" }\n\n"
" ++wNum;\n"
" }\n\n"
" return ( iFound == 0 );\n"
"}\n" );
}
static void s_fileposClose( PHB_FILE pFilePos )
{
_PHB_FILE->pFuncs->Close( _PHB_FILE );
hb_xfree( pFilePos );
}
static int hb_pp_generateVerInfo( char * szVerFile, char * szCVSID, char * szCVSDateID, char * szChangeLogID, char * szLastEntry )
{
int iResult = 0;
char * pszEnv;
FILE * fout;
fout = hb_fopen( szVerFile, "w" );
if( ! fout )
{
#if ! defined( __MINGW32CE__ ) && ! defined( HB_OS_WIN_CE )
perror( szVerFile );
#endif
iResult = 1;
}
else
{
fprintf( fout, "/*\n * $Id: ppgen.c 9869 2012-12-08 18:25:43Z andijahja $\n */\n\n/*\n"
" * Harbour Project source code:\n"
" * Version information and build time switches.\n"
" *\n"
" * Copyright 2008 Przemyslaw Czerpak <druzus / at / priv.onet.pl>\n"
" * www - http://www.harbour-project.org\n"
" *\n"
" * This file is generated automatically by Harbour preprocessor\n"
" * and is covered by the same license as Harbour PP\n"
" */\n\n" );
fprintf( fout, "\n#ifndef __HBVERBLD_INCLUDED" );
fprintf( fout, "\n#define __HBVERBLD_INCLUDED\n" );
if( szCVSID )
fprintf( fout, "\n#define HB_VER_CVSID\t\t%s\n", szCVSID );
if( szCVSDateID )
{
fprintf( fout, "\n#if defined(HB_VER_BUILDDATE)" );
fprintf( fout, "\n#undef HB_VER_BUILDDATE" );
fprintf( fout, "\n#endif\n" );
fprintf( fout, "#define HB_VER_BUILDDATE\t%s\n", szCVSDateID );
}
if( szChangeLogID )
{
fprintf( fout, "\n#if defined(HB_VER_CHLCVS)" );
fprintf( fout, "\n#undef HB_VER_CHLCVS" );
fprintf( fout, "\n#endif\n" );
fprintf( fout, "\n#define HB_VER_CHLCVS\t\"%s\"\n", szChangeLogID );
}
if( szLastEntry )
{
fprintf( fout, "\n#if defined(HB_VER_LENTRY)" );
fprintf( fout, "\n#undef HB_VER_LENTRY" );
fprintf( fout, "\n#endif\n" );
fprintf( fout, "\n#define HB_VER_LENTRY\t\"%s\"\n", szLastEntry );
}
pszEnv = hb_getenv( "C_USR" );
if( pszEnv )
{
fprintf( fout, "\n#undef HB_VER_C_USR" );
fprintf( fout, "\n#define HB_VER_C_USR\t\"%s\"\n", pszEnv );
hb_xfree( pszEnv );
}
pszEnv = hb_getenv( "L_USR" );
if( pszEnv )
{
fprintf( fout, "\n#undef HB_VER_L_USR" );
fprintf( fout, "\n#define HB_VER_L_USR\t\"%s\"\n", pszEnv );
hb_xfree( pszEnv );
}
pszEnv = hb_getenv( "PRG_USR" );
if( pszEnv )
{
fprintf( fout, "\n#undef HB_VER_PRG_USR" );
fprintf( fout, "\n#define HB_VER_PRG_USR\t\"%s\"\n", pszEnv );
hb_xfree( pszEnv );
}
fprintf( fout, "\n#endif /* __HBVERBLD_INCLUDED */\n" );
fclose( fout );
}
return iResult;
}
/* helper function for the *one functions */
static void do_charonly( int iSwitch )
{
/* param check */
if( HB_ISCHAR( 1 ) && HB_ISCHAR( 2 ) )
{
const char * pcString = hb_parc( 2 );
HB_SIZE sStrLen = hb_parclen( 2 );
const char * pcOnlySet = hb_parc( 1 );
HB_SIZE sOnlySetLen = hb_parclen( 1 );
char * pcRet;
HB_SIZE sRetStrLen = 0;
int iShift, iBool;
const char * pcSub, * pc;
/* check for zero-length strings */
switch( iSwitch )
{
case DO_CHARONLY_CHARONLY:
case DO_CHARONLY_WORDONLY:
if( sStrLen == 0 || sOnlySetLen == 0 )
{
hb_retc_null();
return;
}
break;
case DO_CHARONLY_CHARREM:
case DO_CHARONLY_WORDREM:
if( sStrLen == 0 )
{
hb_retc_null();
return;
}
if( sOnlySetLen == 0 )
{
hb_retclen( pcString, sStrLen );
return;
}
break;
}
if( iSwitch == DO_CHARONLY_WORDONLY ||
iSwitch == DO_CHARONLY_WORDREM )
iShift = 2;
else
iShift = 1;
pcRet = ( char * ) hb_xgrab( sStrLen );
for( pcSub = pcString; pcSub < pcString + sStrLen + 1 - iShift; pcSub += iShift )
{
pc = ct_at_exact_forward( pcOnlySet, sOnlySetLen, pcSub, iShift, NULL );
iBool = ( ( pc != NULL ) && ( ( ( pc - pcOnlySet ) % iShift ) == 0 ) );
if( iBool ? ( iSwitch == DO_CHARONLY_CHARONLY ||
iSwitch == DO_CHARONLY_WORDONLY )
: ( iSwitch == DO_CHARONLY_CHARREM ||
iSwitch == DO_CHARONLY_WORDREM ) )
{
for( pc = pcSub; pc < pcSub + iShift; pc++ )
pcRet[ sRetStrLen++ ] = *pc;
}
}
/* copy last character if string len is odd */
if( iShift == 2 && sStrLen % 2 == 1 )
pcRet[ sRetStrLen++ ] = pcString[ sStrLen - 1 ];
hb_retclen( pcRet, sRetStrLen );
hb_xfree( pcRet );
}
else
{
PHB_ITEM pSubst = NULL;
int iArgErrorMode = ct_getargerrormode(), iError = 0;
if( iArgErrorMode != CT_ARGERR_IGNORE )
{
switch( iSwitch )
{
case DO_CHARONLY_CHARONLY:
iError = CT_ERROR_CHARONLY;
break;
case DO_CHARONLY_WORDONLY:
iError = CT_ERROR_WORDONLY;
break;
case DO_CHARONLY_CHARREM:
iError = CT_ERROR_CHARREM;
break;
case DO_CHARONLY_WORDREM:
iError = CT_ERROR_WORDREM;
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_retc_null();
}
}
HB_FHANDLE hb_fsProcessOpen( const char * pszFileName,
HB_FHANDLE * phStdin, HB_FHANDLE * phStdout,
HB_FHANDLE * phStderr,
HB_BOOL fDetach, HB_ULONG * pulPID )
{
HB_FHANDLE hPipeIn [ 2 ] = { FS_ERROR, FS_ERROR },
hPipeOut[ 2 ] = { FS_ERROR, FS_ERROR },
hPipeErr[ 2 ] = { FS_ERROR, FS_ERROR };
HB_FHANDLE hResult = FS_ERROR;
HB_ERRCODE errCode;
HB_BOOL fError = HB_FALSE;
HB_TRACE( HB_TR_DEBUG, ( "hb_fsProcessOpen(%s, %p, %p, %p, %d, %p)", pszFileName, phStdin, phStdout, phStderr, fDetach, pulPID ) );
if( phStdin != NULL )
fError = ! hb_fsPipeCreate( hPipeIn );
if( ! fError && phStdout != NULL )
fError = ! hb_fsPipeCreate( hPipeOut );
if( ! fError && phStderr != NULL )
{
if( phStdout == phStderr )
{
hPipeErr[ 0 ] = hPipeOut[ 0 ];
hPipeErr[ 1 ] = hPipeOut[ 1 ];
}
else
fError = ! hb_fsPipeCreate( hPipeErr );
}
if( ! fError )
{
#if defined( HB_OS_WIN )
PROCESS_INFORMATION pi;
STARTUPINFO si;
DWORD dwFlags = 0;
LPTSTR lpCommand = HB_CHARDUP( pszFileName );
# if ! defined( HB_OS_WIN_CE )
if( phStdin != NULL )
SetHandleInformation( ( HANDLE ) hb_fsGetOsHandle( hPipeIn [ 1 ] ), HANDLE_FLAG_INHERIT, 0 );
if( phStdout != NULL )
SetHandleInformation( ( HANDLE ) hb_fsGetOsHandle( hPipeOut[ 0 ] ), HANDLE_FLAG_INHERIT, 0 );
if( phStderr != NULL && phStdout != phStderr )
SetHandleInformation( ( HANDLE ) hb_fsGetOsHandle( hPipeErr[ 0 ] ), HANDLE_FLAG_INHERIT, 0 );
# endif
memset( &pi, 0, sizeof( pi ) );
memset( &si, 0, sizeof( si ) );
si.cb = sizeof( si );
# ifdef STARTF_USESTDHANDLES
si.dwFlags = STARTF_USESTDHANDLES;
# endif
if( fDetach )
{
# ifdef STARTF_USESHOWWINDOW
si.dwFlags |= STARTF_USESHOWWINDOW;
# endif
si.wShowWindow = SW_HIDE;
si.hStdInput = ( HANDLE ) hb_fsGetOsHandle( hPipeIn [ 0 ] );
si.hStdOutput = ( HANDLE ) hb_fsGetOsHandle( hPipeOut[ 1 ] );
si.hStdError = ( HANDLE ) hb_fsGetOsHandle( hPipeErr[ 1 ] );
# ifdef DETACHED_PROCESS
dwFlags |= DETACHED_PROCESS;
# endif
}
else
{
si.hStdInput = phStdin ? ( HANDLE ) hb_fsGetOsHandle( hPipeIn [ 0 ] ) : GetStdHandle( STD_INPUT_HANDLE );
si.hStdOutput = phStdout ? ( HANDLE ) hb_fsGetOsHandle( hPipeOut[ 1 ] ) : GetStdHandle( STD_OUTPUT_HANDLE );
si.hStdError = phStderr ? ( HANDLE ) hb_fsGetOsHandle( hPipeErr[ 1 ] ) : GetStdHandle( STD_ERROR_HANDLE );
}
fError = ! CreateProcess( NULL, /* lpAppName */
lpCommand,
NULL, /* lpProcessAttr */
NULL, /* lpThreadAttr */
TRUE, /* bInheritHandles */
dwFlags, /* dwCreationFlags */
NULL, /* lpEnvironment */
NULL, /* lpCurrentDirectory */
&si,
&pi );
hb_fsSetIOError( ! fError, 0 );
hb_xfree( lpCommand );
if( ! fError )
{
if( phStdin != NULL )
{
*phStdin = ( HB_FHANDLE ) hPipeIn[ 1 ];
hPipeIn[ 1 ] = FS_ERROR;
}
if( phStdout != NULL )
{
*phStdout = ( HB_FHANDLE ) hPipeOut[ 0 ];
hPipeOut[ 0 ] = FS_ERROR;
}
if( phStderr != NULL )
{
*phStderr = ( HB_FHANDLE ) hPipeErr[ 0 ];
hPipeErr[ 0 ] = FS_ERROR;
}
if( pulPID )
*pulPID = pi.dwProcessId;
CloseHandle( pi.hThread );
hResult = ( HB_FHANDLE ) pi.hProcess;
}
#elif defined( HB_OS_OS2 )
HFILE hNull = ( HFILE ) FS_ERROR;
ULONG ulState = 0;
APIRET ret = NO_ERROR;
PID pid = ( PID ) -1;
PHB_GT pGT;
if( fDetach && ( ! phStdin || ! phStdout || ! phStderr ) )
{
HB_FHANDLE hFile;
ret = hb_fsOS2DosOpen( "NUL:", &hFile, &ulState, 0,
FILE_NORMAL, OPEN_ACCESS_READWRITE,
OPEN_ACTION_OPEN_IF_EXISTS );
if( ret == NO_ERROR )
hNull = ( HFILE ) hFile;
}
if( ret == NO_ERROR && phStdin != NULL )
{
ret = DosQueryFHState( hPipeIn[ 1 ], &ulState );
if( ret == NO_ERROR && ( ulState & OPEN_FLAGS_NOINHERIT ) == 0 )
ret = DosSetFHState( hPipeIn[ 1 ], ( ulState & 0xFF00 ) | OPEN_FLAGS_NOINHERIT );
}
if( ret == NO_ERROR && phStdout != NULL )
{
ret = DosQueryFHState( hPipeOut[ 0 ], &ulState );
if( ret == NO_ERROR && ( ulState & OPEN_FLAGS_NOINHERIT ) == 0 )
ret = DosSetFHState( hPipeOut[ 0 ], ( ulState & 0xFF00 ) | OPEN_FLAGS_NOINHERIT );
}
if( ret == NO_ERROR && phStderr != NULL && phStdout != phStderr )
{
ret = DosQueryFHState( hPipeErr[ 0 ], &ulState );
if( ret == NO_ERROR && ( ulState & OPEN_FLAGS_NOINHERIT ) == 0 )
ret = DosSetFHState( hPipeErr[ 0 ], ( ulState & 0xFF00 ) | OPEN_FLAGS_NOINHERIT );
}
if( ret == NO_ERROR && ( pGT = hb_gt_Base() ) != NULL )
{
ULONG ulStateIn, ulStateOut, ulStateErr;
HFILE hStdIn, hStdErr, hStdOut, hDup;
ulStateIn = ulStateOut = ulStateErr = OPEN_FLAGS_NOINHERIT;
hStdIn = hStdErr = hStdOut = ( HFILE ) FS_ERROR;
if( ret == NO_ERROR && ( phStdin != NULL || fDetach ) )
{
hDup = 0;
ret = DosDupHandle( hDup, &hStdIn );
if( ret == NO_ERROR )
{
ret = DosQueryFHState( hStdIn, &ulStateIn );
if( ret == NO_ERROR && ( ulStateIn & OPEN_FLAGS_NOINHERIT ) == 0 )
ret = DosSetFHState( hStdIn, ( ulStateIn & 0xFF00 ) | OPEN_FLAGS_NOINHERIT );
if( ret == NO_ERROR )
ret = DosDupHandle( phStdin != NULL ? ( HFILE ) hPipeIn[ 0 ] : hNull, &hDup );
}
}
if( ret == NO_ERROR && ( phStdout != NULL || fDetach ) )
{
hDup = 1;
ret = DosDupHandle( hDup, &hStdOut );
if( ret == NO_ERROR )
{
ret = DosQueryFHState( hStdOut, &ulStateOut );
if( ret == NO_ERROR && ( ulStateOut & OPEN_FLAGS_NOINHERIT ) == 0 )
ret = DosSetFHState( hStdOut, ( ulStateOut & 0xFF00 ) | OPEN_FLAGS_NOINHERIT );
if( ret == NO_ERROR )
ret = DosDupHandle( phStdout != NULL ? ( HFILE ) hPipeOut[ 1 ] : hNull, &hDup );
}
}
if( ret == NO_ERROR && ( phStderr != NULL || fDetach ) )
{
hDup = 2;
ret = DosDupHandle( hDup, &hStdErr );
if( ret == NO_ERROR )
{
ret = DosQueryFHState( hStdErr, &ulStateErr );
if( ret == NO_ERROR && ( ulStateErr & OPEN_FLAGS_NOINHERIT ) == 0 )
ret = DosSetFHState( hStdErr, ( ulStateErr & 0xFF00 ) | OPEN_FLAGS_NOINHERIT );
if( ret == NO_ERROR )
ret = DosDupHandle( phStderr != NULL ? ( HFILE ) hPipeErr[ 1 ] : hNull, &hDup );
}
}
if( ret == NO_ERROR )
{
char * pArgs = hb_buildArgsOS2( pszFileName, &ret );
char uchLoadError[ CCHMAXPATH ] = { 0 };
RESULTCODES ChildRC = { 0, 0 };
if( pArgs )
{
ret = DosExecPgm( uchLoadError, sizeof( uchLoadError ),
fDetach ? EXEC_BACKGROUND : EXEC_ASYNCRESULT,
( PCSZ ) pArgs, NULL /* env */,
&ChildRC,
( PCSZ ) pArgs );
if( ret == NO_ERROR )
pid = ChildRC.codeTerminate;
hb_freeArgsOS2( pArgs );
}
}
if( hNull != ( HFILE ) FS_ERROR )
DosClose( hNull );
if( hStdIn != ( HFILE ) FS_ERROR )
{
hDup = 0;
DosDupHandle( hStdIn, &hDup );
DosClose( hStdIn );
if( ( ulStateIn & OPEN_FLAGS_NOINHERIT ) == 0 )
DosSetFHState( hDup, ulStateIn & 0xFF00 );
}
if( hStdOut != ( HFILE ) FS_ERROR )
{
hDup = 1;
DosDupHandle( hStdOut, &hDup );
DosClose( hStdOut );
if( ( ulStateOut & OPEN_FLAGS_NOINHERIT ) == 0 )
DosSetFHState( hDup, ulStateOut & 0xFF00 );
}
if( hStdErr != ( HFILE ) FS_ERROR )
{
hDup = 2;
DosDupHandle( hStdErr, &hDup );
DosClose( hStdErr );
if( ( ulStateErr & OPEN_FLAGS_NOINHERIT ) == 0 )
DosSetFHState( hDup, ulStateErr & 0xFF00 );
}
hb_gt_BaseFree( pGT );
}
else
{
if( hNull != ( HFILE ) FS_ERROR )
DosClose( hNull );
if( ret == NO_ERROR )
ret = ( APIRET ) FS_ERROR;
}
fError = ret != NO_ERROR;
if( ! fError )
{
if( phStdin != NULL )
{
*phStdin = ( HB_FHANDLE ) hPipeIn[ 1 ];
hPipeIn[ 1 ] = FS_ERROR;
}
if( phStdout != NULL )
{
*phStdout = ( HB_FHANDLE ) hPipeOut[ 0 ];
hPipeOut[ 0 ] = FS_ERROR;
}
if( phStderr != NULL )
{
*phStderr = ( HB_FHANDLE ) hPipeErr[ 0 ];
hPipeErr[ 0 ] = FS_ERROR;
}
if( pulPID )
*pulPID = pid;
hResult = ( HB_FHANDLE ) pid;
}
hb_fsSetError( ( HB_ERRCODE ) ret );
#elif defined( HB_OS_UNIX ) && \
! defined( HB_OS_VXWORKS ) && ! defined( HB_OS_SYMBIAN )
char ** argv = hb_buildArgs( pszFileName );
pid_t pid = fork();
if( pid == -1 )
fError = HB_TRUE;
else if( pid != 0 ) /* parent process */
{
if( phStdin != NULL )
{
*phStdin = ( HB_FHANDLE ) hPipeIn[ 1 ];
hPipeIn[ 1 ] = FS_ERROR;
}
if( phStdout != NULL )
{
*phStdout = ( HB_FHANDLE ) hPipeOut[ 0 ];
hPipeOut[ 0 ] = FS_ERROR;
}
if( phStderr != NULL )
{
*phStderr = ( HB_FHANDLE ) hPipeErr[ 0 ];
hPipeErr[ 0 ] = FS_ERROR;
}
if( pulPID )
*pulPID = pid;
hResult = ( HB_FHANDLE ) pid;
}
else /* child process */
{
if( fDetach && ( ! phStdin || ! phStdout || ! phStderr ) )
{
HB_FHANDLE hNull = open( "/dev/null", O_RDWR );
if( ! phStdin )
dup2( hNull, 0 );
if( ! phStdout )
dup2( hNull, 1 );
if( ! phStderr )
dup2( hNull, 2 );
if( hNull != FS_ERROR )
hb_fsClose( hNull );
}
if( phStdin != NULL )
{
dup2( hPipeIn[ 0 ], 0 );
hb_fsClose( hPipeIn[ 1 ] );
}
if( phStdout != NULL )
{
dup2( hPipeOut[ 1 ], 1 );
hb_fsClose( hPipeOut[ 0 ] );
}
if( phStderr != NULL )
{
dup2( hPipeErr[ 1 ], 2 );
if( phStdout != phStderr )
hb_fsClose( hPipeErr[ 0 ] );
}
/* close all non std* handles */
{
int iMaxFD, i;
iMaxFD = sysconf( _SC_OPEN_MAX );
if( iMaxFD < 3 )
iMaxFD = 1024;
for( i = 3; i < iMaxFD; ++i )
hb_fsClose( i );
}
/* reset extended process attributes */
if( setuid( getuid() ) == -1 ) {}
if( setgid( getgid() ) == -1 ) {}
/* execute command */
{
# if defined( __WATCOMC__ )
execvp( argv[ 0 ], ( const char ** ) argv );
# else
execvp( argv[ 0 ], argv );
# endif
exit( -1 );
}
}
hb_fsSetIOError( ! fError, 0 );
hb_freeArgs( argv );
#elif defined( HB_OS_OS2 ) || defined( HB_OS_WIN )
int hStdIn, hStdOut, hStdErr;
char ** argv;
int pid;
hStdIn = dup( 0 );
hStdOut = dup( 1 );
hStdErr = dup( 2 );
if( fDetach && ( ! phStdin || ! phStdout || ! phStderr ) )
{
HB_FHANDLE hNull = open( "NUL:", O_RDWR );
if( ! phStdin )
dup2( hNull, 0 );
if( ! phStdout )
dup2( hNull, 1 );
if( ! phStderr )
dup2( hNull, 2 );
if( hNull != FS_ERROR )
close( hNull );
}
if( phStdin != NULL )
dup2( hPipeIn[ 0 ], 0 );
if( phStdout != NULL )
dup2( hPipeOut[ 1 ], 1 );
if( phStderr != NULL )
dup2( hPipeErr[ 1 ], 2 );
argv = hb_buildArgs( pszFileName );
#if defined( _MSC_VER ) || defined( __LCC__ ) || \
defined( __XCC__ ) || defined( __POCC__ )
pid = _spawnvp( _P_NOWAIT, argv[ 0 ], argv );
#elif defined( __MINGW32__ ) || defined( __WATCOMC__ )
pid = spawnvp( P_NOWAIT, argv[ 0 ], ( const char * const * ) argv );
#else
pid = spawnvp( P_NOWAIT, argv[ 0 ], ( char * const * ) argv );
#endif
hb_freeArgs( argv );
dup2( hStdIn, 0 );
close( hStdIn );
dup2( hStdOut, 1 );
close( hStdOut );
dup2( hStdErr, 2 );
close( hStdErr );
if( pid < 0 )
fError = HB_TRUE;
else if( pid != 0 ) /* parent process */
{
if( phStdin != NULL )
{
*phStdin = ( HB_FHANDLE ) hPipeIn[ 1 ];
hPipeIn[ 1 ] = FS_ERROR;
}
if( phStdout != NULL )
{
*phStdout = ( HB_FHANDLE ) hPipeOut[ 0 ];
hPipeOut[ 0 ] = FS_ERROR;
}
if( phStderr != NULL )
{
*phStderr = ( HB_FHANDLE ) hPipeErr[ 0 ];
hPipeErr[ 0 ] = FS_ERROR;
}
if( pulPID )
*pulPID = pid;
hResult = ( HB_FHANDLE ) pid;
}
hb_fsSetIOError( ! fError, 0 );
#else
int iTODO; /* TODO: for given platform */
HB_SYMBOL_UNUSED( pszFileName );
HB_SYMBOL_UNUSED( fDetach );
HB_SYMBOL_UNUSED( pulPID );
hb_fsSetError( ( HB_ERRCODE ) FS_ERROR );
#endif
}
errCode = hb_fsError();
if( hPipeIn[ 0 ] != FS_ERROR )
hb_fsClose( hPipeIn[ 0 ] );
if( hPipeIn[ 1 ] != FS_ERROR )
hb_fsClose( hPipeIn[ 1 ] );
if( hPipeOut[ 0 ] != FS_ERROR )
hb_fsClose( hPipeOut[ 0 ] );
if( hPipeOut[ 1 ] != FS_ERROR )
hb_fsClose( hPipeOut[ 1 ] );
if( phStdout != phStderr )
{
if( hPipeErr[ 0 ] != FS_ERROR )
hb_fsClose( hPipeErr[ 0 ] );
if( hPipeErr[ 1 ] != FS_ERROR )
hb_fsClose( hPipeErr[ 1 ] );
}
hb_fsSetError( errCode );
return hResult;
}
