static int hb_pp_writeRules( FILE * fout, PHB_PP_RULE pFirst, const char * szName )
{
char szMatch[ 16 ], szResult[ 16 ];
HB_ULONG ulRepeatBits, ulBit;
PHB_PP_RULE pRule;
int iRule;
HB_USHORT u;
iRule = 0;
pRule = pFirst;
while( pRule )
{
++iRule;
if( pRule->pMatch )
{
hb_snprintf( szMatch, sizeof( szMatch ), "s_%cm%03d", szName[ 0 ], iRule );
hb_pp_writeTokenList( fout, pRule->pMatch, szMatch );
}
if( pRule->pResult )
{
hb_snprintf( szResult, sizeof( szResult ), "s_%cr%03d", szName[ 0 ], iRule );
hb_pp_writeTokenList( fout, pRule->pResult, szResult );
}
pRule = pRule->pPrev;
}
fprintf( fout, "static const HB_PP_DEFRULE s_%s[ %d ] = {\n",
szName, iRule );
iRule = 0;
pRule = pFirst;
while( pRule )
{
++iRule;
if( pRule->pMatch )
hb_snprintf( szMatch, sizeof( szMatch ), "s_%cm%03d", szName[ 0 ], iRule );
else
hb_strncpy( szMatch, "NULL ", sizeof( szMatch ) - 1 );
if( pRule->pResult )
hb_snprintf( szResult, sizeof( szResult ), "s_%cr%03d", szName[ 0 ], iRule );
else
hb_strncpy( szResult, "NULL ", sizeof( szResult ) - 1 );
ulRepeatBits = 0;
for( u = 0, ulBit = 1; u < pRule->markers; ++u, ulBit <<= 1 )
{
if( pRule->pMarkers[ u ].canrepeat )
ulRepeatBits |= ulBit;
}
fprintf( fout, " { %s, %s, %d,%2u, 0x%04lx }%s\n",
szMatch, szResult, HB_PP_CMP_MODE( pRule->mode ),
pRule->markers, ulRepeatBits, pRule->pPrev ? "," : "" );
pRule = pRule->pPrev;
}
fprintf( fout, "};\n\n" );
return iRule;
}
static int hb_gt_chrmapread( const char * pszFile, const char * pszTerm, int * nTransTbl )
{
int isTerm = -1;
FILE * fp = hb_fopen( pszFile, "r" );
if( fp != NULL )
{
char buf[ 256 ], * ptr, * pTerm;
hb_strncpy( buf, pszTerm, sizeof( buf ) - 1 );
isTerm = 0;
pTerm = buf;
while( pTerm )
{
if( ( ptr = strchr( pTerm, '/' ) ) != NULL )
*ptr++ = '\0';
if( *pTerm )
if( chrmap_parse( fp, pTerm, nTransTbl, pszFile ) > 0 )
isTerm = 1;
pTerm = ptr;
}
fclose( fp );
}
return isTerm;
}
static PHB_ITEM hb_i18n_serialize( PHB_I18N_TRANS pI18N )
{
if( pI18N )
{
HB_SIZE nSize;
HB_U32 ulCRC;
char * pBuffer = hb_itemSerialize( pI18N->table, 0, &nSize );
char * pI18Nbuffer;
PHB_ITEM pKey, pValue;
ulCRC = hb_crc32( 0, pBuffer, nSize );
pI18Nbuffer = ( char * ) memset( hb_xgrab( nSize + HB_I18N_HEADER_SIZE + 1 ),
0, HB_I18N_HEADER_SIZE );
memcpy( pI18Nbuffer + HB_I18N_HEADER_SIZE, pBuffer, nSize );
hb_xfree( pBuffer );
memcpy( pI18Nbuffer, s_signature, HB_I18N_SIG_SIZE );
HB_PUT_LE_UINT32( &pI18Nbuffer[ HB_I18N_SIZE_OFFSET ], nSize );
HB_PUT_LE_UINT32( &pI18Nbuffer[ HB_I18N_CRC_OFFSET ], ulCRC );
pKey = hb_itemPutCConst( NULL, "DESCRIPTION" );
pValue = hb_hashGetItemPtr( pI18N->table, pKey, 0 );
if( pValue )
hb_strncpy( &pI18Nbuffer[ HB_I18N_TXT_OFFSET ],
hb_itemGetCPtr( pValue ), HB_I18N_TXT_SIZE );
return hb_itemPutCLPtr( pKey, pI18Nbuffer, nSize + HB_I18N_HEADER_SIZE );
}
return NULL;
}
static void s_listenRet( HB_SOCKET sd, const char * szRootPath, HB_BOOL rpc )
{
if( sd != HB_NO_SOCKET )
{
PHB_LISTENSD lsd, * lsd_ptr;
int iLen;
lsd = ( PHB_LISTENSD ) memset( hb_xgrab( sizeof( HB_LISTENSD ) ),
0, sizeof( HB_LISTENSD ) );
lsd->sd = sd;
lsd->rpc = rpc;
if( szRootPath )
hb_strncpy( lsd->rootPath, szRootPath, sizeof( lsd->rootPath ) - 1 );
else
hb_fsBaseDirBuff( lsd->rootPath );
iLen = ( int ) strlen( lsd->rootPath );
if( iLen > 0 )
{
if( ! s_isDirSep( lsd->rootPath[ iLen - 1 ] ) )
{
if( iLen == sizeof( lsd->rootPath ) - 1 )
--iLen;
lsd->rootPath[ iLen ] = HB_OS_PATH_DELIM_CHR;
}
}
lsd_ptr = ( PHB_LISTENSD * ) hb_gcAllocate( sizeof( PHB_LISTENSD ),
&s_gcListensdFuncs );
*lsd_ptr = lsd;
hb_retptrGC( lsd_ptr );
}
else
hb_ret();
}
static void hb_pp_CollectReservedName( char * szName )
{
PRESERVEDNAME pTemp, pLast;
szName = hb_strupr( szName );
if( hb_pp_NameFound( szName ) )
return;
pTemp = ( PRESERVEDNAME ) hb_xgrab( sizeof( RESERVEDNAME ) );
pTemp->szName = ( char * ) hb_xgrab( strlen( szName ) + 1 );
hb_strncpy( pTemp->szName, szName, strlen( szName ) );
pTemp->pNext = NULL;
if( s_PPReservedName )
{
pLast = s_PPReservedName;
while( pLast->pNext )
pLast = pLast->pNext;
pLast->pNext = pTemp;
}
else
{
s_PPReservedName = pTemp;
}
}
static void hb_trace_message( char * buffer, HB_SIZE nSize, int iParam, int iCount )
{
int iFirst = iParam;
buffer[ 0 ] = '\0';
while( iParam <= iCount && nSize > 1 )
{
char * pszString;
HB_SIZE nLen;
HB_BOOL fFree;
if( iParam > iFirst )
{
*buffer++ = ' ';
--nSize;
}
pszString = hb_itemString( hb_param( iParam, HB_IT_ANY ), &nLen, &fFree );
hb_strncpy( buffer, pszString, nSize );
nLen = strlen( buffer );
nSize -= nLen;
buffer += nLen;
if( fFree )
hb_xfree( pszString );
iParam++;
}
}
static int _ft_nwsemopen( const char * szName, long nInitVal, HB_ULONG * pnHandle, int * pnOpenCnt )
{
#if defined( HB_OS_DOS )
{
HB_BYTE buffer[ 1 + 128 ];
union REGS regs;
struct SREGS sregs;
hb_strncpy( ( char * ) ( buffer + 1 ), szName, sizeof( buffer ) - 2 );
buffer[ 0 ] = ( HB_BYTE ) strlen( ( char * ) ( buffer + 1 ) );
regs.h.ah = 0xC5;
regs.h.al = SEM_OPEN;
regs.HB_XREGS.dx = FP_OFF( buffer );
sregs.ds = FP_SEG( buffer );
regs.HB_XREGS.cx = ( HB_U16 ) nInitVal;
HB_DOS_INT86X( 0x21, ®s, ®s, &sregs );
*pnHandle = ( ( ( HB_U32 ) regs.HB_XREGS.dx ) << 16 ) || ( HB_U32 ) regs.HB_XREGS.cx;
*pnOpenCnt = regs.h.bl;
return ( HB_BYTE ) regs.h.al;
}
#else /* TODO */
HB_SYMBOL_UNUSED( szName );
HB_SYMBOL_UNUSED( nInitVal );
*pnHandle = *pnOpenCnt = 0;
return 1;
#endif
}
CLIPPER HB_UNDOC2()
{
char szText[ 25 ];
_retc( "Hello word" );
hb_strncpy( szText, _parc( -1 ), sizeof( szText ) - 1 );
szText[ 5 ] = 0;
_retc( szText );
}
CLIPPER HB_UNDOC4()
{
char szText[ 25 ];
_retds( _pards( 1 ) );
hb_strncpy( szText, _pards( -1 ), sizeof( szText ) - 1 );
szText[ 3 ] = '1';
_retds( szText );
}
int hb_gt_chrmapinit( int * piTransTbl, const char * pszTerm, HB_BOOL fSetACSC )
{
char * pszFree = NULL;
int nRet = -1;
chrmap_init( piTransTbl );
if( pszTerm == NULL || *pszTerm == '\0' )
pszTerm = pszFree = hb_getenv( "HB_TERM" );
if( pszTerm == NULL || *pszTerm == '\0' )
{
if( pszFree )
hb_xfree( pszFree );
pszTerm = pszFree = hb_getenv( "TERM" );
}
if( pszTerm != NULL && *pszTerm != '\0' )
{
char * pszFile = hb_getenv( "HB_CHARMAP" );
if( pszFile != NULL && *pszFile != '\0' )
nRet = hb_gt_chrmapread( pszFile, pszTerm, piTransTbl );
if( nRet == -1 )
{
char szFile[ HB_PATH_MAX ];
if( pszFile )
hb_xfree( pszFile );
pszFile = hb_getenv( "HB_ROOT" );
if( pszFile != NULL && sizeof( szFile ) >
strlen( pszFile ) + strlen( s_szCharMapFileDefault ) )
{
hb_strncpy( szFile, pszFile, sizeof( szFile ) - 1 );
hb_strncat( szFile, s_szCharMapFileDefault, sizeof( szFile ) - 1 );
nRet = hb_gt_chrmapread( szFile, pszTerm, piTransTbl );
}
}
if( pszFile )
hb_xfree( pszFile );
if( nRet == -1 )
nRet = hb_gt_chrmapread( s_szCharMapFileDefault, pszTerm, piTransTbl );
}
if( pszFree )
hb_xfree( pszFree );
if( nRet == -1 )
{
chrmap_dotctrl( piTransTbl );
if( fSetACSC )
chrmap_acscbox( piTransTbl );
else
chrmap_ascictrl( piTransTbl );
}
return nRet;
}
static BOOL hb_gt_std_SetKeyCP( PHB_GT pGT, const char *pszTermCDP, const char *pszHostCDP )
{
HB_TRACE( HB_TR_DEBUG, ( "hb_gt_std_SetKeyCP(%p,%s,%s)", pGT, pszTermCDP, pszHostCDP ) );
HB_GTSUPER_SETKEYCP( pGT, pszTermCDP, pszHostCDP );
#ifndef HB_CDP_SUPPORT_OFF
if( !pszHostCDP )
pszHostCDP = hb_cdpID();
if( !pszTermCDP )
pszTermCDP = pszHostCDP;
if( pszTermCDP && pszHostCDP )
{
PHB_CODEPAGE cdpTerm = hb_cdpFind( pszTermCDP ),
cdpHost = hb_cdpFind( pszHostCDP );
if( cdpTerm && cdpHost && cdpTerm != cdpHost &&
cdpTerm->nChars && cdpTerm->nChars == cdpHost->nChars )
{
char *pszHostLetters = ( char * ) hb_xgrab( cdpHost->nChars * 2 + 1 );
char *pszTermLetters = ( char * ) hb_xgrab( cdpTerm->nChars * 2 + 1 );
hb_strncpy( pszHostLetters, cdpHost->CharsUpper, cdpHost->nChars * 2 );
hb_strncat( pszHostLetters, cdpHost->CharsLower, cdpHost->nChars * 2 );
hb_strncpy( pszTermLetters, cdpTerm->CharsUpper, cdpTerm->nChars * 2 );
hb_strncat( pszTermLetters, cdpTerm->CharsLower, cdpTerm->nChars * 2 );
hb_gt_std_setKeyTrans( HB_GTSTD_GET( pGT ), pszTermLetters, pszHostLetters );
hb_xfree( pszHostLetters );
hb_xfree( pszTermLetters );
}
else
hb_gt_std_setKeyTrans( HB_GTSTD_GET( pGT ), NULL, NULL );
return TRUE;
}
#endif
return FALSE;
}
static HB_ERRCODE adsxSysName( ADSXAREAP pArea, HB_BYTE * pBuffer )
{
UNSIGNED16 u16TableType;
UNSIGNED32 u32RetVal;
if( pArea->adsarea.hTable )
{
u32RetVal = AdsGetTableType( pArea->adsarea.hTable, &u16TableType );
if( u32RetVal != AE_SUCCESS )
{
HB_TRACE( HB_TR_DEBUG, ( "Error in adsxSysName: %lu pArea->adsarea.hTable %p", ( HB_ULONG ) u32RetVal, ( void * ) ( HB_PTRDIFF ) pArea->adsarea.hTable ) );
u16TableType = ( UNSIGNED16 ) pArea->adsarea.iFileType;
}
}
else
u16TableType = ( UNSIGNED16 ) pArea->adsarea.iFileType;
switch( u16TableType )
{
case ADS_NTX:
hb_strncpy( ( char * ) pBuffer, "ADSNTXX", HB_RDD_MAX_DRIVERNAME_LEN );
break;
case ADS_CDX:
hb_strncpy( ( char * ) pBuffer, "ADSCDXX", HB_RDD_MAX_DRIVERNAME_LEN );
break;
#if ADS_LIB_VERSION >= 900
case ADS_VFP:
hb_strncpy( ( char * ) pBuffer, "ADSVFPX", HB_RDD_MAX_DRIVERNAME_LEN );
break;
#endif
case ADS_ADT:
hb_strncpy( ( char * ) pBuffer, "ADSADTX", HB_RDD_MAX_DRIVERNAME_LEN );
break;
}
return HB_SUCCESS;
}
static PHB_CONSRV s_consrvNew( HB_SOCKET connsd, const char * szRootPath, HB_BOOL rpc )
{
PHB_CONSRV conn = ( PHB_CONSRV ) memset( hb_xgrab( sizeof( HB_CONSRV ) ),
0, sizeof( HB_CONSRV ) );
conn->sd = connsd;
conn->rpc = rpc;
conn->timeout = -1;
if( szRootPath )
{
hb_strncpy( conn->rootPath, szRootPath, sizeof( conn->rootPath ) - 1 );
conn->rootPathLen = ( int ) strlen( conn->rootPath );
}
return conn;
}
static HB_BOOL fsGetTempDirByCase( char * pszName, const char * pszTempDir, HB_BOOL fTrans )
{
HB_BOOL fOK = HB_FALSE;
if( pszTempDir && *pszTempDir != '\0' )
{
char * pTmp;
if( fTrans )
hb_osStrDecode2( pszTempDir, pszName, HB_PATH_MAX - 1 );
else
hb_strncpy( pszName, pszTempDir, HB_PATH_MAX - 1 );
switch( hb_setGetDirCase() )
{
case HB_SET_CASE_LOWER:
pTmp = hb_cdpnDupLower( hb_vmCDP(), pszName, NULL );
fOK = strcmp( pszName, pTmp ) == 0;
hb_xfree( pTmp );
break;
case HB_SET_CASE_UPPER:
pTmp = hb_cdpnDupUpper( hb_vmCDP(), pszName, NULL );
fOK = strcmp( pszName, pTmp ) == 0;
hb_xfree( pTmp );
break;
default:
fOK = HB_TRUE;
break;
}
}
if( fOK )
{
# if defined( __DJGPP__ ) || defined( HB_OS_OS2 )
/* convert '/' to '\' */
char * pszDelim = pszName;
while( ( pszDelim = strchr( pszDelim, '/' ) ) != NULL )
*pszDelim = '\\';
# endif
if( ! hb_fsDirExists( pszTempDir ) )
fOK = HB_FALSE;
}
return fOK;
}
static BOOL hb_fsTempName( BYTE * pszBuffer, const BYTE * pszDir, const BYTE * pszPrefix )
{
BOOL fResult;
#if defined(HB_WIN32_IO)
{
char cTempDir[ _POSIX_PATH_MAX + 1 ];
if( pszDir && pszDir[ 0 ] != '\0' )
hb_strncpy( ( char * ) cTempDir, ( const char * ) pszDir, sizeof( cTempDir ) - 1 );
else
{
if( ! GetTempPathA( ( DWORD ) _POSIX_PATH_MAX + 1, cTempDir ) )
{
hb_fsSetIOError( FALSE, 0 );
return FALSE;
}
}
cTempDir[ _POSIX_PATH_MAX ] = '\0';
fResult = GetTempFileNameA( ( LPCSTR ) cTempDir, pszPrefix ? ( LPCSTR ) pszPrefix : ( LPCSTR ) "xht", 0, ( LPSTR ) pszBuffer );
}
#else
/* TODO: Implement these: */
HB_SYMBOL_UNUSED( pszDir );
HB_SYMBOL_UNUSED( pszPrefix );
/* TOFIX: The spec says to reserve L_tmpnam number of characters for the
passed buffer. It will be needed to fix _POSIX_PATH_MAX to be
at least this large. */
pszBuffer[ 0 ] = '\0';
fResult = ( tmpnam( ( char * ) pszBuffer ) != NULL );
#endif
hb_fsSetIOError( fResult, 0 );
return fResult;
}
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;
}
char * hb_osStrDecode2( const char * pszName, char * pszBuffer, HB_SIZE nSize )
{
return hb_strncpy( pszBuffer, pszName, nSize );
}
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;
}
static int hb_pp_parseChangelog( PHB_PP_STATE pState, const char * pszFileName,
BOOL fQuiet, char * piSVNID, char * piSVNDateID,
char ** pszChangeLogID, char ** pszLastEntry )
{
int iResult = 0;
const char * pszFile;
FILE * file_in;
pszFile = pszFileName ? pszFileName : "../../../../ChangeLog";
do
{
if( hb_fsFileExists( pszFile ) )
break;
pszFile += 3;
}
while( ! pszFileName && ( *pszFile == '.' || *pszFile == 'C' ) );
file_in = hb_fopen( pszFile, "r" );
if( ! file_in )
{
if( ! fQuiet )
{
#if ! defined( __MINGW32CE__ ) && ! defined( HB_OS_WIN_CE )
perror( pszFile );
#else
fprintf( stderr, "Cannot open the %s file.\n", pszFile );
#endif
}
iResult = 1;
}
else
{
char szLine[ 256 ];
char szLine1[ 256 ];
char szId[ 128 ];
char szLog[ 128 ];
char * szFrom, * szTo;
int iLen;
*szId = *szLog = *szLine1 = '\0';
do
{
if( ! fgets( szLine, sizeof( szLine ), file_in ) )
break;
if( ! *szId )
{
szFrom = strstr( szLine, "$Id: " );
if( szFrom )
{
szFrom += 5;
szTo = strstr( szFrom, " $" );
if( szTo )
{
*szTo = 0;
}
hb_strncpy( szId, szFrom, sizeof( szId ) - 1 );
hb_strncpy( szLine1, szLine + 1, sizeof( szLine1 ) - 1 );
}
}
else if( ! *szLog )
{
if( szLine[ 4 ] == '-' && szLine[ 7 ] == '-' &&
szLine[ 10 ] == ' ' && szLine[ 13 ] == ':' )
{
int iLen;
hb_strncpy( szLog, szLine, sizeof( szLog ) - 1 );
iLen = strlen( szLog );
while( iLen-- && HB_ISSPACE( szLog[ iLen ] ) )
szLog[ iLen ] = '\0';
}
}
}
while( ! *szLog );
fclose( file_in );
if( ! *szLog )
{
if( ! fQuiet )
fprintf( stderr, "Cannot find valid $Id end log entry in the %s file.\n", pszFile );
iResult = 1;
}
else
{
char _szId[ 6 ];
int u = 0;
hb_xmemset( _szId, 0, 6 );
*szLine = '"';
hb_strncpy( szLine + 1, szLog, sizeof( szLine ) - 3 );
iLen = strlen( szLine );
szLine[ iLen ] = '"';
szLine[ ++iLen ] = '\0';
hb_pp_addDefine( pState, "HB_VER_LENTRY", szLine );
*pszLastEntry = hb_strdup( szLog );
hb_strncpy( szLine + 1, szId, sizeof( szLine ) - 3 );
iLen = strlen( szLine );
szLine[ iLen ] = '"';
szLine[ ++iLen ] = '\0';
hb_pp_addDefine( pState, "HB_VER_CHLCVS", szLine );
*pszChangeLogID = hb_strdup( szId );
szFrom = strchr( szLine, ' ' );
if( szFrom )
{
while( *szFrom == ' ' )
++szFrom;
iLen = 0;
while( ! HB_ISSPACE( szFrom[ iLen ] ) )
{
_szId[ u++ ] = szFrom[ iLen ];
++iLen;
}
/*
Latest CVS version before migration to SVN:
ChangeLog,v 1.6768 2011/01/25 18:50:35 guerra000
*/
if( iLen )
{
#if 0
int iCurrentVersion = atoi( _szId ) + 6768;
sprintf( _szId, "%i", iCurrentVersion );
hb_strncpy( piSVNID, _szId, strlen( _szId ) );
#else
hb_strncpy( piSVNID, _szId, u );
#endif
}
else
_szId[ 0 ] = 0;
}
if( _szId[ 0 ] )
{
char szSVNDateID[ 10 ];
int iLen = 0, u = 0, wLen = ( int ) strlen( szLine1 );
char *szDate = NULL;
*szSVNDateID ='\0';
do
{
if ( szLine1[ u ] == ' ' )
iLen ++;
if ( iLen == 4 )
{
iLen = u;
szDate = szLine1 + iLen + 1;
break;
}
++u;
} while ( u < wLen );
iLen = 0;
u = 0;
do
{
if (! ( szDate[ iLen ] == '-' ) )
szSVNDateID[ u++ ] = szDate[ iLen ];
if ( szDate[ iLen ] == ' ' )
break;
++iLen;
} while( szDate [ iLen ] );
szSVNDateID[ u ] = 0;
hb_strncpy( piSVNDateID, szSVNDateID, u );
hb_pp_addDefine( pState, "HB_VER_BUILDDATE", szSVNDateID );
hb_pp_addDefine( pState, "HB_VER_CVSID", _szId );
}
else
{
if( ! fQuiet )
fprintf( stderr, "Unrecognized Id entry in the %s file.\n", pszFile );
iResult = 1;
}
}
}
return iResult;
}
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;
}
char * hb_verCompiler( void )
{
char * pszCompiler;
char * pszName;
char szSub[ 32 ];
int iVerMajor;
int iVerMinor;
int iVerPatch;
HB_TRACE(HB_TR_DEBUG, ("hb_verCompiler()"));
pszCompiler = ( char * ) hb_xgrab( COMPILER_BUF_SIZE );
szSub[ 0 ] = '\0';
#if defined(__IBMC__) || defined(__IBMCPP__)
#if defined(__IBMC__)
iVerMajor = __IBMC__;
#else
iVerMajor = __IBMCPP__;
#endif
if( iVerMajor >= 300 )
pszName = "IBM Visual Age C++";
else
pszName = "IBM C++";
iVerMajor /= 100;
iVerMinor = iVerMajor % 100;
iVerPatch = 0;
#elif defined(__POCC__)
pszName = "Pelles ISO C Compiler";
iVerMajor = __POCC__ / 100;
iVerMinor = __POCC__ % 100;
iVerPatch = 0;
#elif defined(__XCC__)
pszName = "Pelles ISO C Compiler";
iVerMajor = __XCC__ / 100;
iVerMinor = __XCC__ % 100;
iVerPatch = 0;
#elif defined(__LCC__)
pszName = "Logiciels/Informatique lcc-win32";
iVerMajor = 0 /* __LCC__ / 100 */;
iVerMinor = 0 /* __LCC__ % 100 */;
iVerPatch = 0;
#elif defined(__DMC__)
pszName = __DMC_VERSION_STRING__;
iVerMajor = 0;
iVerMinor = 0;
iVerPatch = 0;
#elif defined(__ICL)
pszName = "Intel(R) C";
#if defined(__cplusplus)
hb_strncpy( szSub, "++", sizeof( szSub ) - 1 );
#endif
iVerMajor = __ICL / 100;
iVerMinor = __ICL % 100;
iVerPatch = 0;
#elif defined(_MSC_VER)
#if (_MSC_VER >= 800)
pszName = "Microsoft Visual C";
#else
pszName = "Microsoft C";
#endif
#if defined(__cplusplus)
hb_strncpy( szSub, "++", sizeof( szSub ) - 1 );
#endif
iVerMajor = _MSC_VER / 100;
iVerMinor = _MSC_VER % 100;
#if defined(_MSC_FULL_VER)
iVerPatch = _MSC_FULL_VER - ( _MSC_VER * 10000 );
#else
iVerPatch = 0;
#endif
#elif defined(__BORLANDC__)
#if (__BORLANDC__ == 1040) /* Version 3.1 */
iVerMajor = 3;
iVerMinor = 1;
iVerPatch = 0;
#elif (__BORLANDC__ >= 1280) /* Version 5.x */
iVerMajor = __BORLANDC__ >> 8;
iVerMinor = ( __BORLANDC__ & 0xFF ) >> 4;
iVerPatch = __BORLANDC__ & 0xF;
#else /* Version 4.x */
iVerMajor = __BORLANDC__ >> 8;
iVerMinor = ( __BORLANDC__ - 1 & 0xFF ) >> 4;
iVerPatch = 0;
#endif
#if (__BORLANDC__ >= 1424) /* Version 5.9 */
pszName = "CodeGear C++";
#else
pszName = "Borland C++";
#endif
#elif defined(__TURBOC__)
pszName = "Borland Turbo C";
iVerMajor = __TURBOC__ >> 8;
iVerMinor = __TURBOC__ & 0xFF;
iVerPatch = 0;
#elif defined(__MPW__)
pszName = "MPW C";
iVerMajor = __MPW__ / 100;
iVerMinor = __MPW__ % 100;
iVerPatch = 0;
#elif defined(__WATCOMC__)
#if __WATCOMC__ < 1200
pszName = "Watcom C";
#else
pszName = "Open Watcom C";
#endif
#if defined(__cplusplus)
hb_strncpy( szSub, "++", sizeof( szSub ) - 1 );
#endif
iVerMajor = __WATCOMC__ / 100;
iVerMinor = __WATCOMC__ % 100;
#if defined( __WATCOM_REVISION__ )
iVerPatch = __WATCOM_REVISION__;
#else
iVerPatch = 0;
#endif
#elif defined(__GNUC__)
#if defined(__DJGPP__)
pszName = "DJ Delorie's DJGPP";
#elif defined(__CYGWIN__)
pszName = "Cygwin GNU C";
#elif defined(__MINGW32__)
pszName = "MinGW GNU C";
#elif defined(__RSX32__)
pszName = "EMX/RSXNT/DOS GNU C";
#elif defined(__RSXNT__)
pszName = "EMX/RSXNT/Win32 GNU C";
#elif defined(__EMX__)
pszName = "EMX GNU C";
#else
pszName = "GNU C";
#endif
#if defined(__cplusplus)
hb_strncpy( szSub, "++", sizeof( szSub ) - 1 );
#endif
iVerMajor = __GNUC__;
iVerMinor = __GNUC_MINOR__;
#if defined(__GNUC_PATCHLEVEL__)
iVerPatch = __GNUC_PATCHLEVEL__;
#else
iVerPatch = 0;
#endif
#else
pszName = ( char * ) NULL;
iVerMajor = iVerMinor = iVerPatch = 0;
#endif
if( pszName )
{
#if defined( __ICL )
hb_snprintf( pszCompiler, COMPILER_BUF_SIZE, "%s%s %hd.%01d Build %u", pszName, szSub, iVerMajor, iVerMinor, __INTEL_COMPILER_BUILD_DATE );
#else
if( iVerPatch != 0 )
#if defined(_MSC_VER)
hb_snprintf( pszCompiler, COMPILER_BUF_SIZE, "%s%s %hd.%02d.%hd", pszName, szSub, iVerMajor, iVerMinor, iVerPatch );
#else
hb_snprintf( pszCompiler, COMPILER_BUF_SIZE, "%s%s %hd.%hd.%hd", pszName, szSub, iVerMajor, iVerMinor, iVerPatch );
#endif
else if( iVerMajor != 0 || iVerMinor != 0 )
hb_snprintf( pszCompiler, COMPILER_BUF_SIZE, "%s%s %hd.%hd", pszName, szSub, iVerMajor, iVerMinor );
else
hb_snprintf( pszCompiler, COMPILER_BUF_SIZE, "%s%s", pszName, szSub );
#endif
}
char * hb_verPlatform( void )
{
char * pszPlatform;
HB_TRACE(HB_TR_DEBUG, ("hb_verPlatform()"));
pszPlatform = ( char * ) hb_xgrab( PLATFORM_BUF_SIZE + 1 );
#if defined(HB_OS_DOS)
{
union REGS regs;
regs.h.ah = 0x30;
HB_DOS_INT86( 0x21, ®s, ®s );
hb_snprintf( pszPlatform, PLATFORM_BUF_SIZE + 1, "DOS %d.%02d", regs.h.al, regs.h.ah );
/* Host OS detection: Windows 2.x, 3.x, 95/98 */
{
regs.HB_XREGS.ax = 0x1600;
HB_DOS_INT86( 0x2F, ®s, ®s );
if( regs.h.al != 0x00 && regs.h.al != 0x80 )
{
char szHost[ 128 ];
if( regs.h.al == 0x01 || regs.h.al == 0xFF )
hb_snprintf( szHost, sizeof( szHost ), " (Windows 2.x)" );
else
hb_snprintf( szHost, sizeof( szHost ), " (Windows %d.%02d)", regs.h.al, regs.h.ah );
hb_strncat( pszPlatform, szHost, PLATFORM_BUF_SIZE );
}
}
/* Host OS detection: Windows NT/2000 */
{
regs.HB_XREGS.ax = 0x3306;
HB_DOS_INT86( 0x21, ®s, ®s );
if( regs.HB_XREGS.bx == 0x3205 )
hb_strncat( pszPlatform, " (Windows NT/2000)", PLATFORM_BUF_SIZE );
}
/* Host OS detection: OS/2 */
{
regs.h.ah = 0x30;
HB_DOS_INT86( 0x21, ®s, ®s );
if( regs.h.al >= 10 )
{
char szHost[ 128 ];
if( regs.h.al == 20 && regs.h.ah > 20 )
hb_snprintf( szHost, sizeof( szHost ), " (OS/2 %d.%02d)", regs.h.ah / 10, regs.h.ah % 10 );
else
hb_snprintf( szHost, sizeof( szHost ), " (OS/2 %d.%02d)", regs.h.al / 10, regs.h.ah );
hb_strncat( pszPlatform, szHost, PLATFORM_BUF_SIZE );
}
}
}
#elif defined(HB_OS_OS2)
{
unsigned long aulQSV[ QSV_MAX ] = { 0 };
APIRET rc;
rc = DosQuerySysInfo( 1L, QSV_MAX, ( void * ) aulQSV, sizeof( ULONG ) * QSV_MAX );
if( rc == 0 )
{
/* is this OS/2 2.x ? */
if( aulQSV[ QSV_VERSION_MINOR - 1 ] < 30 )
{
hb_snprintf( pszPlatform, PLATFORM_BUF_SIZE + 1, "OS/2 %ld.%02ld",
aulQSV[ QSV_VERSION_MAJOR - 1 ] / 10,
aulQSV[ QSV_VERSION_MINOR - 1 ] );
}
else
hb_snprintf( pszPlatform, PLATFORM_BUF_SIZE + 1, "OS/2 %2.2f",
( float ) aulQSV[ QSV_VERSION_MINOR - 1 ] / 10 );
}
else
hb_snprintf( pszPlatform, PLATFORM_BUF_SIZE + 1, "OS/2" );
}
#elif defined(HB_OS_WIN_32)
{
OSVERSIONINFOA osVer;
osVer.dwOSVersionInfoSize = sizeof( osVer );
if( GetVersionExA( &osVer ) )
{
const char *szName = NULL;
const char *szProduct = NULL;
switch( osVer.dwPlatformId )
{
case VER_PLATFORM_WIN32_WINDOWS:
if( osVer.dwMajorVersion == 4 && osVer.dwMinorVersion < 10 )
{
szName = " 95";
}
else if( osVer.dwMajorVersion == 4 && osVer.dwMinorVersion == 10 )
{
szName = " 98";
}
else
{
szName = " ME";
}
break;
case VER_PLATFORM_WIN32_NT:
if( osVer.dwMajorVersion == 6 )
{
szName = " Windows Vista";
}
else if( osVer.dwMajorVersion == 5 && osVer.dwMinorVersion == 2 )
{
szName = " Server 2003";
}
else if( osVer.dwMajorVersion == 5 && osVer.dwMinorVersion == 1 )
{
szName = " XP";
}
else if( osVer.dwMajorVersion == 5 )
{
szName = " 2000";
}
else
{
szName = " NT";
}
/* test for specific product on Windows NT 4.0 SP6 and later */
{
HBOSVERSIONINFOEX osVerEx; /* NOTE */
osVerEx.dwOSVersionInfoSize = sizeof( osVerEx );
/* Windows decl error? */
if( GetVersionEx( ( LPOSVERSIONINFOA ) &osVerEx ) )
{
/* workstation type */
if( osVerEx.wProductType == VER_NT_WORKSTATION )
{
if( osVerEx.dwMajorVersion == 4 )
{
szProduct = " Workstation 4.0";
}
else if( osVerEx.wSuiteMask & VER_SUITE_PERSONAL )
{
szProduct = " Home Edition";
}
else
{
szProduct = " Professional";
}
}
/* server type */
else if( osVerEx.wProductType == VER_NT_SERVER )
{
if( osVerEx.dwMajorVersion == 5 && osVerEx.dwMinorVersion == 2 )
{
if( osVerEx.wSuiteMask & VER_SUITE_DATACENTER )
{
szProduct = " Datacenter Edition";
}
else if( osVerEx.wSuiteMask & VER_SUITE_ENTERPRISE )
{
szProduct = " Enterprise Edition";
}
else if( osVerEx.wSuiteMask == VER_SUITE_BLADE )
{
szProduct = " Web Edition";
}
else
{
szProduct = " Standard Edition";
}
}
else if( osVerEx.dwMajorVersion == 5 && osVerEx.dwMinorVersion == 0 )
{
if( osVerEx.wSuiteMask & VER_SUITE_DATACENTER )
{
szProduct = " Datacenter Server";
}
else if( osVerEx.wSuiteMask & VER_SUITE_ENTERPRISE )
{
szProduct = " Advanced Server";
}
else
{
szProduct = " Server";
}
}
else
{
if( osVerEx.wSuiteMask & VER_SUITE_ENTERPRISE )
{
szProduct = " Server 4.0, Enterprise Edition";
}
else
{
szProduct = " Server 4.0";
}
}
}
}
}
break;
case VER_PLATFORM_WIN32s:
szName = " 32s";
break;
case VER_PLATFORM_WIN32_CE:
szName = " CE";
break;
}
hb_snprintf( pszPlatform, PLATFORM_BUF_SIZE + 1, "Windows %s%s %lu.%02lu.%04d",
szName ? szName : NULL, szProduct ? szProduct : "",
( ULONG ) osVer.dwMajorVersion,
( ULONG ) osVer.dwMinorVersion,
( USHORT ) LOWORD( osVer.dwBuildNumber ) );
/* Add service pack/other info */
if( osVer.szCSDVersion )
{
int i;
/* Skip the leading spaces (Win95B, Win98) */
for( i = 0; osVer.szCSDVersion[ i ] != '\0' && isspace( ( int ) osVer.szCSDVersion[ i ] ); i++ ) {};
if( osVer.szCSDVersion[ i ] != '\0' )
{
hb_strncat( pszPlatform, " ", PLATFORM_BUF_SIZE );
hb_strncat( pszPlatform, osVer.szCSDVersion + i, PLATFORM_BUF_SIZE );
}
}
}
else
hb_snprintf( pszPlatform, PLATFORM_BUF_SIZE + 1, "Windows" );
}
#elif defined(__CEGCC__)
{
hb_snprintf( pszPlatform, PLATFORM_BUF_SIZE + 1, "Windows CE" );
}
#elif defined(HB_OS_UNIX)
{
struct utsname un;
uname( &un );
hb_snprintf( pszPlatform, PLATFORM_BUF_SIZE + 1, "%s %s %s", un.sysname, un.release, un.machine );
}
#elif defined(HB_OS_MAC)
{
hb_strncpy( pszPlatform, "MacOS compatible", PLATFORM_BUF_SIZE );
}
#else
{
hb_strncpy( pszPlatform, "(unknown)", PLATFORM_BUF_SIZE );
}
#endif
return pszPlatform;
}
/* Split given filename into path, name and extension, plus determine drive */
PHB_FNAME hb_fsFNameSplit( const char * pszFileName )
{
PHB_FNAME pFileName;
HB_TRACE( HB_TR_DEBUG, ( "hb_fsFNameSplit(%s)", pszFileName ) );
HB_TRACE( HB_TR_INFO, ( "hb_fsFNameSplit: Filename: |%s|", pszFileName ) );
/* Grab memory, set defaults */
pFileName = ( PHB_FNAME ) hb_xgrab( sizeof( HB_FNAME ) );
pFileName->szPath =
pFileName->szName =
pFileName->szExtension =
pFileName->szDrive = NULL;
if( pszFileName )
{
char * pszPos, cDirSep;
HB_ISIZ iSize, iPos;
iPos = iSize = hb_strnlen( pszFileName, HB_PATH_MAX - 1 );
cDirSep = ( char ) hb_setGetDirSeparator();
pszPos = pFileName->szBuffer;
/* Find the end of the path part, and find out where the
name+ext starts */
while( --iPos >= 0 )
{
if( pszFileName[ iPos ] == cDirSep ||
strchr( HB_OS_PATH_DELIM_CHR_LIST, pszFileName[ iPos ] ) )
{
pFileName->szPath = pszPos;
hb_strncpy( pszPos, pszFileName, iPos + 1 );
pszPos += iPos + 2;
pszFileName += iPos + 1;
iSize -= iPos + 1;
break;
}
}
/* From this point pszFileName will point to the name+ext part of the path */
/* Split the filename part to name and extension */
iPos = iSize;
while( --iPos > 0 )
{
if( pszFileName[ iPos ] == '.' )
{
pFileName->szExtension = pszPos;
hb_strncpy( pszPos, pszFileName + iPos, iSize - iPos );
pszPos += iSize - iPos + 1;
iSize = iPos;
break;
}
}
if( iSize )
{
pFileName->szName = pszPos;
hb_strncpy( pszPos, pszFileName, iSize );
pszPos += iSize + 1;
}
/* Duplicate the drive letter from the path for easy access on
platforms where applicable. Note that the drive info is always
present also in the path itself. */
if( pFileName->szPath )
{
iPos = 0;
while( iPos < HB_MAX_DRIVE_LENGTH && pFileName->szPath[ iPos ] != '\0' )
{
if( pFileName->szPath[ iPos ] == ':' )
{
pFileName->szDrive = pszPos;
hb_strncpy( pszPos, pFileName->szPath, iPos );
break;
}
++iPos;
}
}
}
HB_TRACE( HB_TR_INFO, ( "hb_fsFNameSplit: szPath: |%s|", pFileName->szPath ) );
HB_TRACE( HB_TR_INFO, ( "hb_fsFNameSplit: szName: |%s|", pFileName->szName ) );
HB_TRACE( HB_TR_INFO, ( "hb_fsFNameSplit: szExt: |%s|", pFileName->szExtension ) );
HB_TRACE( HB_TR_INFO, ( "hb_fsFNameSplit: szDrive: |%s|", pFileName->szDrive ) );
return pFileName;
}
char * hb_verCompiler( void )
{
char * pszCompiler;
const char * pszName;
char szSub[ 64 ];
int iVerMajor;
int iVerMinor;
int iVerPatch;
int iVerMicro = 0;
int iElements = 0;
HB_TRACE( HB_TR_DEBUG, ( "hb_verCompiler()" ) );
pszCompiler = ( char * ) hb_xgrab( COMPILER_BUF_SIZE );
szSub[ 0 ] = '\0';
#if defined( __IBMC__ ) || defined( __IBMCPP__ )
#if defined( __IBMC__ )
iVerMajor = __IBMC__;
#else
iVerMajor = __IBMCPP__;
#endif
if( iVerMajor >= 300 )
pszName = "IBM Visual Age C++";
else
pszName = "IBM C++";
iVerMajor /= 100;
iVerMinor = iVerMajor % 100;
iVerPatch = 0;
#elif defined( __POCC__ )
pszName = "Pelles ISO C Compiler";
iVerMajor = __POCC__ / 100;
iVerMinor = __POCC__ % 100;
iVerPatch = 0;
#elif defined( __XCC__ )
pszName = "Pelles ISO C Compiler (XCC)";
iVerMajor = __XCC__ / 100;
iVerMinor = __XCC__ % 100;
iVerPatch = 0;
#elif defined( __LCC__ )
pszName = "Logiciels/Informatique lcc-win32";
iVerMajor = 0 /* __LCC__ / 100 */;
iVerMinor = 0 /* __LCC__ % 100 */;
iVerPatch = 0;
#elif defined( __DMC__ )
pszName = __DMC_VERSION_STRING__;
iVerMajor = 0;
iVerMinor = 0;
iVerPatch = 0;
#elif defined( __INTEL_COMPILER )
pszName = "Intel(R) C";
#if defined( __cplusplus )
hb_strncpy( szSub, "++", sizeof( szSub ) - 1 );
#endif
iVerMajor = __INTEL_COMPILER / 100;
iVerMinor = ( __INTEL_COMPILER % 100 ) / 10;
iVerPatch = 0;
#elif defined( __ICL )
pszName = "Intel(R) C";
#if defined( __cplusplus )
hb_strncpy( szSub, "++", sizeof( szSub ) - 1 );
#endif
iVerMajor = __ICL / 100;
iVerMinor = __ICL % 100;
iVerPatch = 0;
#elif defined( __ICC )
pszName = "Intel(R) (ICC) C";
#if defined( __cplusplus )
hb_strncpy( szSub, "++", sizeof( szSub ) - 1 );
#endif
iVerMajor = __ICC / 100;
iVerMinor = __ICC % 100;
iVerPatch = 0;
#elif defined( __OPENCC__ )
pszName = "Open64 C";
#if defined( __cplusplus )
hb_strncpy( szSub, "++", sizeof( szSub ) - 1 );
#endif
iVerMajor = __OPENCC__;
iVerMinor = __OPENCC_MINOR__;
#if __OPENCC_PATCHLEVEL__ - 0 <= 0
#undef __OPENCC_PATCHLEVEL__
#define __OPENCC_PATCHLEVEL__ 0
#endif
iVerPatch = __OPENCC_PATCHLEVEL__;
#elif defined( __clang__ ) && defined( __clang_major__ )
/* NOTE: keep clang detection before msvc detection. */
pszName = "LLVM/Clang C";
#if defined( __cplusplus )
hb_strncpy( szSub, "++", sizeof( szSub ) - 1 );
#endif
iVerMajor = __clang_major__;
iVerMinor = __clang_minor__;
iVerPatch = __clang_patchlevel__;
#elif defined( __clang__ )
pszName = "LLVM/Clang C";
#if defined( __cplusplus )
hb_strncpy( szSub, "++", sizeof( szSub ) - 1 );
#endif
hb_strncat( szSub, " 1.x", sizeof( szSub ) - 1 );
iVerMajor = iVerMinor = iVerPatch = 0;
#elif defined( __llvm__ ) && defined( __GNUC__ )
pszName = "LLVM/GNU C";
#if defined( __cplusplus )
hb_strncpy( szSub, "++", sizeof( szSub ) - 1 );
#endif
iVerMajor = __GNUC__;
iVerMinor = __GNUC_MINOR__;
#if defined( __GNUC_PATCHLEVEL__ )
iVerPatch = __GNUC_PATCHLEVEL__;
#else
iVerPatch = 0;
#endif
#elif defined( _MSC_VER )
#if _MSC_VER >= 800
pszName = "Microsoft Visual C";
#else
pszName = "Microsoft C";
#endif
#if defined( __cplusplus )
hb_strncpy( szSub, "++", sizeof( szSub ) - 1 );
#endif
iVerMajor = _MSC_VER / 100;
iVerMinor = _MSC_VER % 100;
#if defined( _MSC_FULL_VER )
#if _MSC_VER >= 1400
iVerPatch = _MSC_FULL_VER - ( _MSC_VER * 100000 );
#else
iVerPatch = _MSC_FULL_VER - ( _MSC_VER * 10000 );
#endif
#else
iVerPatch = 0;
#endif
#elif defined( __BORLANDC__ )
#if __BORLANDC__ >= 0x0590 /* Version 5.9 */
#if __BORLANDC__ >= 0x0620 /* Version 6.2 */
pszName = "Borland/Embarcadero C++";
#else
pszName = "Borland/CodeGear C++";
#endif
#else
pszName = "Borland C++";
#endif
#if __BORLANDC__ == 0x0400 /* Version 3.0 */
iVerMajor = 3;
iVerMinor = 0;
iVerPatch = 0;
#elif __BORLANDC__ == 0x0410 /* Version 3.1 */
iVerMajor = 3;
iVerMinor = 1;
iVerPatch = 0;
#elif __BORLANDC__ == 0x0452 /* Version 4.0 */
iVerMajor = 4;
iVerMinor = 0;
iVerPatch = 0;
#elif __BORLANDC__ == 0x0460 /* Version 4.5 */
iVerMajor = 4;
iVerMinor = 5;
iVerPatch = 0;
#elif __BORLANDC__ >= 0x0500 /* Version 5.x */
iVerMajor = __BORLANDC__ >> 8;
iVerMinor = ( __BORLANDC__ & 0xFF ) >> 4;
iVerPatch = __BORLANDC__ & 0xF;
#else /* Version 4.x */
iVerMajor = __BORLANDC__ >> 8;
iVerMinor = ( __BORLANDC__ - 1 & 0xFF ) >> 4;
iVerPatch = 0;
#endif
#elif defined( __TURBOC__ )
pszName = "Borland Turbo C";
iVerMajor = __TURBOC__ >> 8;
iVerMinor = __TURBOC__ & 0xFF;
iVerPatch = 0;
#elif defined( __MPW__ )
pszName = "MPW C";
iVerMajor = __MPW__ / 100;
iVerMinor = __MPW__ % 100;
iVerPatch = 0;
#elif defined( __WATCOMC__ )
#if __WATCOMC__ < 1200
pszName = "Watcom C";
#else
pszName = "Open Watcom C";
#endif
#if defined( __cplusplus )
hb_strncpy( szSub, "++", sizeof( szSub ) - 1 );
#endif
iVerMajor = __WATCOMC__ / 100;
iVerMinor = __WATCOMC__ % 100;
#if defined( __WATCOM_REVISION__ )
iVerPatch = __WATCOM_REVISION__;
#else
iVerPatch = 0;
#endif
#elif defined( __DCC__ )
pszName = "Wind River Compiler (diab)";
iVerMajor = ( __VERSION_NUMBER__ / 1000 ) % 10;
iVerMinor = ( __VERSION_NUMBER__ / 100 ) % 10;
iVerPatch = ( __VERSION_NUMBER__ / 10 ) % 10;
iVerMicro = __VERSION_NUMBER__ % 10;
iElements = 4;
#elif defined( __TINYC__ )
pszName = "Tiny C Compiler";
iVerMajor = __TINYC__ / 100;
iVerMinor = ( __TINYC__ % 100 ) / 10;
iVerPatch = ( __TINYC__ % 100 ) % 10;
#elif defined( __PCC__ )
pszName = "Portable C Compiler";
iVerMajor = __PCC__;
iVerMinor = __PCC_MINOR__;
iVerPatch = __PCC_MINORMINOR__;
#if defined( __GNUC__ )
hb_snprintf( szSub, sizeof( szSub ), " (GCC %d.%d.%d emul.)",
__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__ );
#endif
#elif defined( __GNUC__ )
#if defined( __DJGPP__ )
pszName = "Delorie GNU C";
#elif defined( __CYGWIN__ )
pszName = "Cygwin GNU C";
#elif defined( __MINGW32__ )
pszName = "MinGW GNU C";
#elif defined( __RSX32__ )
pszName = "EMX/RSXNT/DOS GNU C";
#elif defined( __RSXNT__ )
pszName = "EMX/RSXNT/Win32 GNU C";
#elif defined( __EMX__ )
pszName = "EMX GNU C";
#else
pszName = "GNU C";
#endif
#if defined( __cplusplus )
hb_strncpy( szSub, "++", sizeof( szSub ) - 1 );
#endif
iVerMajor = __GNUC__;
iVerMinor = __GNUC_MINOR__;
#if defined( __GNUC_PATCHLEVEL__ )
iVerPatch = __GNUC_PATCHLEVEL__;
#else
iVerPatch = 0;
#endif
#elif defined( __SUNPRO_C )
pszName = "Sun C";
#if __SUNPRO_C < 0x1000
iVerMajor = __SUNPRO_C / 0x100;
iVerMinor = ( __SUNPRO_C & 0xff ) / 0x10;
iVerPatch = __SUNPRO_C & 0xf;
#else
iVerMajor = __SUNPRO_C / 0x1000;
iVerMinor = __SUNPRO_C / 0x10 & 0xff;
iVerMinor = iVerMinor / 0x10 * 0xa + iVerMinor % 0x10;
iVerPatch = __SUNPRO_C & 0xf;
#endif
#elif defined( __SUNPRO_CC )
pszName = "Sun C++";
#if __SUNPRO_CC < 0x1000
iVerMajor = __SUNPRO_CC / 0x100;
iVerMinor = ( __SUNPRO_CC & 0xff ) / 0x10;
iVerPatch = __SUNPRO_CC & 0xf;
#else
iVerMajor = __SUNPRO_CC / 0x1000;
iVerMinor = __SUNPRO_CC / 0x10 & 0xff;
iVerMinor = iVerMinor / 0x10 * 0xa + iVerMinor % 0x10;
iVerPatch = __SUNPRO_CC & 0xf;
#endif
#else
pszName = NULL;
iVerMajor = iVerMinor = iVerPatch = 0;
#endif
if( pszName )
{
if( iElements == 4 )
hb_snprintf( pszCompiler, COMPILER_BUF_SIZE, "%s%s %d.%d.%d.%d", pszName, szSub, iVerMajor, iVerMinor, iVerPatch, iVerMicro );
else if( iVerPatch != 0 )
hb_snprintf( pszCompiler, COMPILER_BUF_SIZE, "%s%s %d.%d.%d", pszName, szSub, iVerMajor, iVerMinor, iVerPatch );
else if( iVerMajor != 0 || iVerMinor != 0 )
hb_snprintf( pszCompiler, COMPILER_BUF_SIZE, "%s%s %d.%d", pszName, szSub, iVerMajor, iVerMinor );
else
hb_snprintf( pszCompiler, COMPILER_BUF_SIZE, "%s%s", pszName, szSub );
}
else
hb_strncpy( pszCompiler, "(unrecognized)", COMPILER_BUF_SIZE - 1 );
#if defined( __clang_version__ )
if( strstr( __clang_version__, "(" ) )
/* "2.0 (trunk 103176)" -> "(trunk 103176)" */
hb_snprintf( szSub, sizeof( szSub ), " %s", strstr( __clang_version__, "(" ) );
else
hb_snprintf( szSub, sizeof( szSub ), " (%s)", __clang_version__ );
hb_strncat( pszCompiler, szSub, COMPILER_BUF_SIZE - 1 );
#endif
#if defined( __DJGPP__ )
hb_snprintf( szSub, sizeof( szSub ), " (DJGPP %i.%02i)", ( int ) __DJGPP__, ( int ) __DJGPP_MINOR__ );
hb_strncat( pszCompiler, szSub, COMPILER_BUF_SIZE - 1 );
#endif
#if defined( HB_ARCH_16BIT )
hb_strncat( pszCompiler, " (16-bit)", COMPILER_BUF_SIZE - 1 );
#elif defined( HB_ARCH_32BIT )
hb_strncat( pszCompiler, " (32-bit)", COMPILER_BUF_SIZE - 1 );
#elif defined( HB_ARCH_64BIT )
hb_strncat( pszCompiler, " (64-bit)", COMPILER_BUF_SIZE - 1 );
#endif
return pszCompiler;
}
/*
* Open a data store in the WorkArea.
*/
static HB_ERRCODE hb_sdfOpen( SDFAREAP pArea, LPDBOPENINFO pOpenInfo )
{
PHB_ITEM pError = NULL;
PHB_FNAME pFileName;
HB_ERRCODE errCode;
HB_USHORT uiFlags;
HB_BOOL fRetry;
char szFileName[ HB_PATH_MAX ];
char szAlias[ HB_RDD_MAX_ALIAS_LEN + 1 ];
HB_TRACE( HB_TR_DEBUG, ( "hb_sdfOpen(%p,%p)", pArea, pOpenInfo ) );
pArea->fShared = HB_TRUE; /* pOpenInfo->fShared; */
pArea->fReadonly = HB_TRUE; /* pOpenInfo->fReadonly; */
if( pOpenInfo->cdpId )
{
pArea->area.cdPage = hb_cdpFindExt( pOpenInfo->cdpId );
if( ! pArea->area.cdPage )
pArea->area.cdPage = hb_vmCDP();
}
else
pArea->area.cdPage = hb_vmCDP();
uiFlags = ( pArea->fReadonly ? FO_READ : FO_READWRITE ) |
( pArea->fShared ? FO_DENYNONE : FO_EXCLUSIVE );
pFileName = hb_fsFNameSplit( pOpenInfo->abName );
/* Add default file name extension if necessary */
if( hb_setGetDefExtension() && ! pFileName->szExtension )
{
PHB_ITEM pFileExt = hb_itemPutC( NULL, NULL );
SELF_INFO( &pArea->area, DBI_TABLEEXT, pFileExt );
pFileName->szExtension = hb_itemGetCPtr( pFileExt );
hb_fsFNameMerge( szFileName, pFileName );
hb_itemRelease( pFileExt );
}
else
{
hb_strncpy( szFileName, pOpenInfo->abName, sizeof( szFileName ) - 1 );
}
/* Create default alias if necessary */
if( ! pOpenInfo->atomAlias && pFileName->szName )
{
const char * szName = strrchr( pFileName->szName, ':' );
if( szName == NULL )
szName = pFileName->szName;
else
++szName;
hb_strncpyUpperTrim( szAlias, szName, sizeof( szAlias ) - 1 );
pOpenInfo->atomAlias = szAlias;
}
hb_xfree( pFileName );
/* Try open */
do
{
pArea->pFile = hb_fileExtOpen( szFileName, NULL, uiFlags |
FXO_DEFAULTS | FXO_SHARELOCK |
FXO_COPYNAME | FXO_NOSEEKPOS,
NULL, pError );
if( ! pArea->pFile )
{
if( ! pError )
{
pError = hb_errNew();
hb_errPutGenCode( pError, EG_OPEN );
hb_errPutSubCode( pError, EDBF_OPEN_DBF );
hb_errPutOsCode( pError, hb_fsError() );
hb_errPutDescription( pError, hb_langDGetErrorDesc( EG_OPEN ) );
hb_errPutFileName( pError, szFileName );
hb_errPutFlags( pError, EF_CANRETRY | EF_CANDEFAULT );
}
fRetry = ( SELF_ERROR( &pArea->area, pError ) == E_RETRY );
}
else
fRetry = HB_FALSE;
}
while( fRetry );
if( pError )
hb_itemRelease( pError );
if( ! pArea->pFile )
return HB_FAILURE;
errCode = SUPER_OPEN( &pArea->area, pOpenInfo );
if( errCode != HB_SUCCESS )
{
SELF_CLOSE( &pArea->area );
return HB_FAILURE;
}
hb_sdfInitArea( pArea, szFileName );
/* Position cursor at the first record */
return SELF_GOTOP( &pArea->area );
}
/*
* Create a data store in the specified WorkArea.
*/
static HB_ERRCODE hb_sdfCreate( SDFAREAP pArea, LPDBOPENINFO pCreateInfo )
{
HB_ERRCODE errCode;
PHB_FNAME pFileName;
PHB_ITEM pError = NULL;
HB_BOOL fRetry;
char szFileName[ HB_PATH_MAX ];
HB_TRACE( HB_TR_DEBUG, ( "hb_sdfCreate(%p,%p)", pArea, pCreateInfo ) );
pArea->fShared = HB_FALSE; /* pCreateInfo->fShared; */
pArea->fReadonly = HB_FALSE; /* pCreateInfo->fReadonly */
if( pCreateInfo->cdpId )
{
pArea->area.cdPage = hb_cdpFindExt( pCreateInfo->cdpId );
if( ! pArea->area.cdPage )
pArea->area.cdPage = hb_vmCDP();
}
else
pArea->area.cdPage = hb_vmCDP();
pFileName = hb_fsFNameSplit( pCreateInfo->abName );
if( hb_setGetDefExtension() && ! pFileName->szExtension )
{
PHB_ITEM pItem = hb_itemPutC( NULL, NULL );
SELF_INFO( &pArea->area, DBI_TABLEEXT, pItem );
pFileName->szExtension = hb_itemGetCPtr( pItem );
hb_fsFNameMerge( szFileName, pFileName );
hb_itemRelease( pItem );
}
else
{
hb_strncpy( szFileName, pCreateInfo->abName, sizeof( szFileName ) - 1 );
}
hb_xfree( pFileName );
/* Try create */
do
{
pArea->pFile = hb_fileExtOpen( szFileName, NULL,
FO_READWRITE | FO_EXCLUSIVE | FXO_TRUNCATE |
FXO_DEFAULTS | FXO_SHARELOCK | FXO_COPYNAME |
FXO_NOSEEKPOS,
NULL, pError );
if( ! pArea->pFile )
{
if( ! pError )
{
pError = hb_errNew();
hb_errPutGenCode( pError, EG_CREATE );
hb_errPutSubCode( pError, EDBF_CREATE_DBF );
hb_errPutOsCode( pError, hb_fsError() );
hb_errPutDescription( pError, hb_langDGetErrorDesc( EG_CREATE ) );
hb_errPutFileName( pError, szFileName );
hb_errPutFlags( pError, EF_CANRETRY | EF_CANDEFAULT );
}
fRetry = ( SELF_ERROR( &pArea->area, pError ) == E_RETRY );
}
else
fRetry = HB_FALSE;
}
while( fRetry );
if( pError )
hb_itemRelease( pError );
if( ! pArea->pFile )
return HB_FAILURE;
errCode = SUPER_CREATE( &pArea->area, pCreateInfo );
if( errCode != HB_SUCCESS )
{
SELF_CLOSE( &pArea->area );
return errCode;
}
hb_sdfInitArea( pArea, szFileName );
/* Position cursor at the first record */
return SELF_GOTOP( &pArea->area );
}
char * hb_verPlatform( void )
{
char * pszPlatform;
HB_TRACE( HB_TR_DEBUG, ( "hb_verPlatform()" ) );
pszPlatform = ( char * ) hb_xgrab( PLATFORM_BUF_SIZE + 1 );
#if defined( HB_OS_DOS )
{
union REGS regs;
regs.h.ah = 0x30;
HB_DOS_INT86( 0x21, ®s, ®s );
hb_snprintf( pszPlatform, PLATFORM_BUF_SIZE + 1, "DOS %d.%02d", regs.h.al, regs.h.ah );
/* Host OS detection: Windows 2.x, 3.x, 95/98 */
{
regs.HB_XREGS.ax = 0x1600;
HB_DOS_INT86( 0x2F, ®s, ®s );
if( regs.h.al != 0x00 && regs.h.al != 0x80 )
{
char szHost[ 128 ];
if( regs.h.al == 0x01 || regs.h.al == 0xFF )
hb_snprintf( szHost, sizeof( szHost ), " (Windows 2.x)" );
else
hb_snprintf( szHost, sizeof( szHost ), " (Windows %d.%02d)", regs.h.al, regs.h.ah );
hb_strncat( pszPlatform, szHost, PLATFORM_BUF_SIZE );
}
}
/* Host OS detection: Windows NT family */
{
regs.HB_XREGS.ax = 0x3306;
HB_DOS_INT86( 0x21, ®s, ®s );
if( regs.HB_XREGS.bx == 0x3205 )
hb_strncat( pszPlatform, " (Windows NT)", PLATFORM_BUF_SIZE );
}
/* Host OS detection: OS/2 */
{
regs.h.ah = 0x30;
HB_DOS_INT86( 0x21, ®s, ®s );
if( regs.h.al >= 10 )
{
char szHost[ 128 ];
if( regs.h.al == 20 && regs.h.ah > 20 )
hb_snprintf( szHost, sizeof( szHost ), " (OS/2 %d.%02d)", regs.h.ah / 10, regs.h.ah % 10 );
else
hb_snprintf( szHost, sizeof( szHost ), " (OS/2 %d.%02d)", regs.h.al / 10, regs.h.ah );
hb_strncat( pszPlatform, szHost, PLATFORM_BUF_SIZE );
}
}
}
#elif defined( HB_OS_OS2 )
{
unsigned long aulQSV[ QSV_MAX ] = { 0 };
APIRET rc = DosQuerySysInfo( 1L, QSV_MAX, ( void * ) aulQSV, sizeof( ULONG ) * QSV_MAX );
if( rc == 0 )
{
/* is this OS/2 2.x ? */
if( aulQSV[ QSV_VERSION_MINOR - 1 ] < 30 )
hb_snprintf( pszPlatform, PLATFORM_BUF_SIZE + 1, "OS/2 %ld.%02ld",
aulQSV[ QSV_VERSION_MAJOR - 1 ] / 10,
aulQSV[ QSV_VERSION_MINOR - 1 ] );
else
hb_snprintf( pszPlatform, PLATFORM_BUF_SIZE + 1, "OS/2 %2.2f",
( float ) aulQSV[ QSV_VERSION_MINOR - 1 ] / 10 );
}
else
hb_snprintf( pszPlatform, PLATFORM_BUF_SIZE + 1, "OS/2" );
}
#elif defined( HB_OS_WIN )
{
const char * pszName = "";
OSVERSIONINFO osvi;
memset( &osvi, 0, sizeof( osvi ) );
#if defined( HB_OS_WIN_CE )
pszName = " CE";
osvi.dwOSVersionInfoSize = sizeof( osvi );
GetVersionEx( &osvi );
#else
/* Detection of legacy Windows versions */
switch( hb_iswin9x() )
{
case 5:
osvi.dwMajorVersion = 4;
osvi.dwMinorVersion = 0;
pszName = " 95";
break;
case 8:
osvi.dwMajorVersion = 4;
osvi.dwMinorVersion = 10;
pszName = " 98";
break;
case 9:
osvi.dwMajorVersion = 4;
osvi.dwMinorVersion = 90;
pszName = " ME";
break;
}
#endif
if( pszName[ 0 ] == '\0' )
{
#if defined( HB_OS_WIN_CE )
pszName = " CE";
#else
if( hb_iswinver( 11, 0, 0, HB_TRUE ) )
{
osvi.dwMajorVersion = 11;
osvi.dwMinorVersion = 0;
pszName = " 11 or newer";
}
else if( hb_iswin10() )
{
osvi.dwMajorVersion = 10;
osvi.dwMinorVersion = 0;
if( hb_iswinver( 10, 0, VER_NT_WORKSTATION, HB_FALSE ) )
pszName = " 10";
else
pszName = " Server 2016";
}
else if( hb_iswin81() )
{
osvi.dwMajorVersion = 6;
osvi.dwMinorVersion = 3;
if( hb_iswinver( 6, 3, VER_NT_WORKSTATION, HB_FALSE ) )
pszName = " 8.1";
else
pszName = " Server 2012 R2";
}
else if( hb_iswinvista() )
{
if( hb_iswin8() )
{
osvi.dwMajorVersion = 6;
osvi.dwMinorVersion = 2;
if( hb_iswinver( 6, 2, VER_NT_WORKSTATION, HB_FALSE ) )
pszName = " 8";
else
pszName = " Server 2012";
}
else if( hb_iswinver( 6, 1, 0, HB_FALSE ) )
{
osvi.dwMajorVersion = 6;
osvi.dwMinorVersion = 1;
if( hb_iswinver( 6, 1, VER_NT_WORKSTATION, HB_FALSE ) )
pszName = " 7";
else
pszName = " Server 2008 R2";
}
else
{
osvi.dwMajorVersion = 6;
osvi.dwMinorVersion = 0;
if( hb_iswinver( 6, 0, VER_NT_WORKSTATION, HB_FALSE ) )
pszName = " Vista";
else
pszName = " Server 2008";
}
}
else if( hb_iswinver( 5, 2, 0, HB_FALSE ) )
{
osvi.dwMajorVersion = 5;
osvi.dwMinorVersion = 2;
if( hb_iswinver( 5, 2, VER_NT_WORKSTATION, HB_FALSE ) )
pszName = " XP x64";
else if( GetSystemMetrics( SM_SERVERR2 ) != 0 )
pszName = " Server 2003 R2";
else
pszName = " Server 2003";
}
else if( hb_iswinver( 5, 1, 0, HB_FALSE ) )
{
osvi.dwMajorVersion = 5;
osvi.dwMinorVersion = 1;
pszName = " XP";
}
else if( hb_iswin2k() )
{
osvi.dwMajorVersion = 5;
osvi.dwMinorVersion = 0;
pszName = " 2000";
}
else
pszName = " NT";
#endif
}
hb_snprintf( pszPlatform, PLATFORM_BUF_SIZE + 1, "Windows%s%s %lu.%lu",
pszName,
s_iWine ? " (Wine)" : "",
osvi.dwMajorVersion,
osvi.dwMinorVersion );
/* Add service pack/other info */
if( hb_iswin2k() )
{
int tmp;
for( tmp = 5; tmp > 0; --tmp )
{
if( hb_iswinsp( tmp, HB_TRUE ) )
{
char szServicePack[ 8 ];
hb_snprintf( szServicePack, sizeof( szServicePack ), " SP%u", tmp );
hb_strncat( pszPlatform, szServicePack, PLATFORM_BUF_SIZE );
break;
}
}
}
#if defined( HB_OS_WIN_CE )
else
{
/* Also for Win9x and NT, but GetVersionEx() is deprecated
so we avoid it. */
if( osvi.szCSDVersion[ 0 ] != TEXT( '\0' ) )
{
char * pszCSDVersion = HB_OSSTRDUP( osvi.szCSDVersion );
int i;
/* Skip the leading spaces (Win95B, Win98) */
for( i = 0; pszCSDVersion[ i ] != '\0' && HB_ISSPACE( ( int ) pszCSDVersion[ i ] ); i++ )
;
if( pszCSDVersion[ i ] != '\0' )
{
hb_strncat( pszPlatform, " ", PLATFORM_BUF_SIZE );
hb_strncat( pszPlatform, pszCSDVersion + i, PLATFORM_BUF_SIZE );
}
hb_xfree( pszCSDVersion );
}
}
#endif
}
#elif defined( __CEGCC__ )
{
hb_snprintf( pszPlatform, PLATFORM_BUF_SIZE + 1, "Windows CE" );
}
#elif defined( HB_OS_UNIX )
{
struct utsname un;
uname( &un );
#if defined( HB_OS_MINIX )
hb_snprintf( pszPlatform, PLATFORM_BUF_SIZE + 1, "%s Release %s Version %s %s",
un.sysname, un.release, un.version, un.machine );
#else
hb_snprintf( pszPlatform, PLATFORM_BUF_SIZE + 1, "%s %s %s", un.sysname, un.release, un.machine );
#endif
}
#else
{
hb_strncpy( pszPlatform, "(unrecognized)", PLATFORM_BUF_SIZE );
}
#endif
return pszPlatform;
}
HB_FHANDLE hb_fsCreateTempEx( char * pszName, const char * pszDir, const char * pszPrefix, const char * pszExt, HB_FATTR ulAttr )
{
/* less attemps */
int iAttemptLeft = 99, iLen;
HB_FHANDLE fd;
do
{
pszName[ 0 ] = '\0';
if( pszDir && pszDir[ 0 ] != '\0' )
{
hb_strncpy( pszName, pszDir, HB_PATH_MAX - 1 );
iLen = ( int ) strlen( pszName );
if( pszName[ iLen - 1 ] != HB_OS_PATH_DELIM_CHR &&
iLen < HB_PATH_MAX - 1 )
{
pszName[ iLen ] = HB_OS_PATH_DELIM_CHR;
pszName[ iLen + 1 ] = '\0';
}
}
else
hb_fsTempDir( pszName );
if( pszPrefix )
hb_strncat( pszName, pszPrefix, HB_PATH_MAX - 1 );
iLen = ( int ) strlen( pszName );
if( iLen > ( HB_PATH_MAX - 1 ) - 6 -
( pszExt ? ( int ) strlen( pszExt ) : 0 ) )
{
fd = FS_ERROR;
break;
}
#if defined( HB_HAS_MKSTEMP )
if( hb_setGetFileCase() != HB_SET_CASE_LOWER &&
hb_setGetFileCase() != HB_SET_CASE_UPPER &&
hb_setGetDirCase() != HB_SET_CASE_LOWER &&
hb_setGetDirCase() != HB_SET_CASE_UPPER
#if ! defined( HB_HAS_MKSTEMPS )
&& ( pszExt == NULL || *pszExt == 0 )
#endif
)
{
hb_vmUnlock();
hb_strncat( pszName, "XXXXXX", HB_PATH_MAX - 1 );
#if defined( HB_HAS_MKSTEMPS )
if( pszExt && *pszExt )
{
hb_strncat( pszName, pszExt, HB_PATH_MAX - 1 );
#if defined( HB_USE_LARGEFILE64 )
fd = ( HB_FHANDLE ) mkstemps64( pszName, ( int ) strlen( pszExt ) );
#else
fd = ( HB_FHANDLE ) mkstemps( pszName, ( int ) strlen( pszExt ) );
#endif
}
else
#endif
#if defined( HB_USE_LARGEFILE64 )
fd = ( HB_FHANDLE ) mkstemp64( pszName );
#else
fd = ( HB_FHANDLE ) mkstemp( pszName );
#endif
hb_fsSetIOError( fd != ( HB_FHANDLE ) -1, 0 );
hb_vmLock();
}
else
#endif /* HB_HAS_MKSTEMP */
{
int i, n;
double d = hb_random_num(), x;
for( i = 0; i < 6; i++ )
{
d = d * 36;
n = ( int ) d;
d = modf( d, &x );
pszName[ iLen++ ] = ( char ) ( n + ( n > 9 ? 'a' - 10 : '0' ) );
}
pszName[ iLen ] = '\0';
if( pszExt )
hb_strncat( pszName, pszExt, HB_PATH_MAX - 1 );
fd = hb_fsCreateEx( pszName, ulAttr, FO_EXCLUSIVE | FO_EXCL );
}
if( fd != ( HB_FHANDLE ) FS_ERROR )
break;
}
while( --iAttemptLeft );
return fd;
}
static HRESULT STDMETHODCALLTYPE Invoke( IDispatch * lpThis, DISPID dispid, REFIID riid,
LCID lcid, WORD wFlags, DISPPARAMS * pParams,
VARIANT * pVarResult, EXCEPINFO * pExcepInfo,
UINT * puArgErr )
{
PHB_DYNS pDynSym;
PHB_ITEM pAction;
HB_USHORT uiClass = 0;
HB_SYMBOL_UNUSED( lcid );
HB_SYMBOL_UNUSED( pExcepInfo );
HB_SYMBOL_UNUSED( puArgErr );
if( ! IsEqualIID( riid, HB_ID_REF( IID_NULL ) ) )
return DISP_E_UNKNOWNINTERFACE;
pAction = ( ( IHbOleServer * ) lpThis )->pAction;
if( ! pAction )
pAction = s_pAction;
if( pAction )
{
HB_BOOL fResult = HB_FALSE;
if( s_pMsgHash )
{
if( ( wFlags & DISPATCH_METHOD ) != 0 ||
( ( wFlags & DISPATCH_PROPERTYGET ) != 0 && pParams->cArgs == 0 ) ||
( ( wFlags & DISPATCH_PROPERTYPUT ) != 0 && pParams->cArgs == 1 ) )
{
fResult = hb_oleDispInvoke( NULL, pAction,
hb_hashGetKeyAt( s_pMsgHash, ( HB_SIZE ) dispid ),
pParams, pVarResult, s_objItemToVariant, uiClass );
}
}
else if( HB_IS_HASH( pAction ) )
{
PHB_ITEM pItem;
if( ( ( IHbOleServer * ) lpThis )->fGuids )
{
PHB_ITEM pKey = hb_itemPutNL( hb_stackAllocItem(), ( long ) dispid );
pItem = hb_hashGetItemPtr( pAction, pKey, 0 );
hb_stackPop();
}
else
pItem = hb_hashGetValueAt( pAction, ( HB_SIZE ) dispid );
if( pItem )
{
if( HB_IS_EVALITEM( pItem ) )
{
if( ( wFlags & DISPATCH_METHOD ) != 0 )
{
PHB_SYMB pSym = hb_itemGetSymbol( pItem );
fResult = hb_oleDispInvoke( pSym, pSym ? pAction : pItem, NULL,
pParams, pVarResult,
s_objItemToVariant, uiClass );
}
}
else if( ( wFlags & DISPATCH_PROPERTYGET ) != 0 &&
pParams->cArgs == 0 )
{
if( pVarResult )
hb_oleItemToVariantEx( pVarResult, pItem, s_objItemToVariant );
fResult = HB_TRUE;
}
else if( ( wFlags & DISPATCH_PROPERTYPUT ) != 0 &&
pParams->cArgs == 1 )
{
hb_oleVariantToItemEx( pItem, &pParams->rgvarg[ 0 ], uiClass );
fResult = HB_TRUE;
}
}
}
else if( HB_IS_OBJECT( pAction ) )
{
pDynSym = hb_dispIdToDynsym( dispid );
if( pDynSym && ( wFlags & DISPATCH_PROPERTYPUT ) != 0 )
{
if( pParams->cArgs == 1 )
{
char szName[ HB_SYMBOL_NAME_LEN + 1 ];
szName[ 0 ] = '_';
hb_strncpy( szName + 1, hb_dynsymName( pDynSym ), sizeof( szName ) - 2 );
pDynSym = hb_dynsymFindName( szName );
}
else
pDynSym = NULL;
}
if( pDynSym && hb_objHasMessage( pAction, pDynSym ) )
{
fResult = hb_oleDispInvoke( hb_dynsymSymbol( pDynSym ),
pAction, NULL, pParams, pVarResult,
s_objItemToVariant, uiClass );
}
}
if( ! fResult )
return DISP_E_MEMBERNOTFOUND;
}
else
{
pDynSym = hb_dispIdToDynsym( dispid );
if( ! pDynSym )
return DISP_E_MEMBERNOTFOUND;
if( wFlags & DISPATCH_PROPERTYPUT )
{
if( pParams->cArgs == 1 && hb_dynsymIsMemvar( pDynSym ) )
{
PHB_ITEM pItem = hb_stackAllocItem();
hb_oleVariantToItemEx( pItem, &pParams->rgvarg[ 0 ], uiClass );
hb_memvarSetValue( hb_dynsymSymbol( pDynSym ), pItem );
hb_stackPop();
return S_OK;
}
else
return DISP_E_MEMBERNOTFOUND;
}
else if( ( wFlags & DISPATCH_PROPERTYGET ) &&
pParams->cArgs == 0 && hb_dynsymIsMemvar( pDynSym ) )
{
if( pVarResult )
{
PHB_ITEM pItem = hb_stackAllocItem();
hb_memvarGet( pItem, hb_dynsymSymbol( pDynSym ) );
hb_oleItemToVariantEx( pVarResult, pItem, s_objItemToVariant );
hb_stackPop();
}
return S_OK;
}
else if( ( wFlags & DISPATCH_METHOD ) == 0 ||
! hb_dynsymIsFunction( pDynSym ) )
return DISP_E_MEMBERNOTFOUND;
else if( ! hb_oleDispInvoke( hb_dynsymSymbol( pDynSym ),
NULL, NULL, pParams, pVarResult,
s_objItemToVariant, uiClass ) )
return DISP_E_MEMBERNOTFOUND;
}
return S_OK;
}
static LONG WINAPI hb_winExceptionHandler( struct _EXCEPTION_POINTERS * pExceptionInfo )
{
char errmsg[ 8192 ];
int errmsglen = sizeof( errmsg ) - 1;
errmsg[ 0 ] = '\0';
#if defined( HB_OS_WIN_64 ) && defined( HB_CPU_X86_64 )
{
char buf[ 32 ];
PCONTEXT pCtx = pExceptionInfo->ContextRecord;
const char * szCode;
/* two most common codes */
switch( pExceptionInfo->ExceptionRecord->ExceptionCode )
{
case EXCEPTION_ACCESS_VIOLATION:
szCode = " " "ACCESS_VIOLATION";
break;
case EXCEPTION_IN_PAGE_ERROR:
szCode = " " "IN_PAGE_ERROR";
break;
default:
szCode = "";
}
hb_snprintf( errmsg, errmsglen,
"\n\n"
" Exception Code:%08X%s\n"
" Exception Address:%016" PFLL "X\n"
" RAX:%016" PFLL "X RBX:%016" PFLL "X RCX:%016" PFLL "X RDX:%016" PFLL "X\n"
" RSI:%016" PFLL "X RDI:%016" PFLL "X RBP:%016" PFLL "X\n"
" R8 :%016" PFLL "X R9 :%016" PFLL "X R10:%016" PFLL "X R11:%016" PFLL "X\n"
" R12:%016" PFLL "X R13:%016" PFLL "X R14:%016" PFLL "X R15:%016" PFLL "X\n"
" CS:RIP:%04X:%016" PFLL "X SS:RSP:%04X:%016" PFLL "X\n"
" DS:%04X ES:%04X FS:%04X GS:%04X\n"
" Flags:%08X\n",
( HB_U32 ) pExceptionInfo->ExceptionRecord->ExceptionCode, szCode,
( HB_PTRDIFF ) pExceptionInfo->ExceptionRecord->ExceptionAddress,
pCtx->Rax, pCtx->Rbx, pCtx->Rcx, pCtx->Rdx,
pCtx->Rsi, pCtx->Rdi, pCtx->Rbp,
pCtx->R8 , pCtx->R9 , pCtx->R10, pCtx->R11,
pCtx->R12, pCtx->R13, pCtx->R14, pCtx->R15,
( HB_U32 ) pCtx->SegCs, pCtx->Rip, ( HB_U32 ) pCtx->SegSs, pCtx->Rsp,
( HB_U32 ) pCtx->SegDs, ( HB_U32 ) pCtx->SegEs, ( HB_U32 ) pCtx->SegFs, ( HB_U32 ) pCtx->SegGs,
( HB_U32 ) pCtx->EFlags );
if( pExceptionInfo->ExceptionRecord->NumberParameters &&
pExceptionInfo->ExceptionRecord->NumberParameters < ( DWORD ) EXCEPTION_MAXIMUM_PARAMETERS )
{
DWORD arg;
hb_strncat( errmsg, " Exception Parameters:", errmsglen );
for( arg = 0; arg < pExceptionInfo->ExceptionRecord->NumberParameters; ++arg )
{
hb_snprintf( buf, sizeof( buf ), " %016" PFLL "X", ( HB_U64 ) pExceptionInfo->ExceptionRecord->ExceptionInformation[ arg ] );
hb_strncat( errmsg, buf, errmsglen );
}
hb_strncat( errmsg, "\n", errmsglen );
}
/* TODO: 64-bit stack trace.
See: - StackWalk64()
- https://www.codeproject.com/KB/threads/StackWalker.aspx?fid=202364 */
}
#elif defined( HB_OS_WIN_64 ) && defined( HB_CPU_IA_64 )
{
PCONTEXT pCtx = pExceptionInfo->ContextRecord;
hb_snprintf( errmsg, errmsglen,
"\n\n"
" Exception Code:%08X\n"
" Exception Address:%016" PFLL "X\n"
" IS0 :%016" PFLL "X IS1 :%016" PFLL "X IS2 :%016" PFLL "X IS3 :%016" PFLL "X\n"
" IT0 :%016" PFLL "X IT1 :%016" PFLL "X IT2 :%016" PFLL "X IT3 :%016" PFLL "X\n"
" IT4 :%016" PFLL "X IT5 :%016" PFLL "X IT6 :%016" PFLL "X IT7 :%016" PFLL "X\n"
" IT8 :%016" PFLL "X IT9 :%016" PFLL "X IT10:%016" PFLL "X IT11:%016" PFLL "X\n"
" IT12:%016" PFLL "X IT13:%016" PFLL "X IT14:%016" PFLL "X IT15:%016" PFLL "X\n"
" IT16:%016" PFLL "X IT17:%016" PFLL "X IT18:%016" PFLL "X IT19:%016" PFLL "X\n"
" IT20:%016" PFLL "X IT21:%016" PFLL "X IT22:%016" PFLL "X\n"
" IGp :%016" PFLL "X IV0 :%016" PFLL "X ISp :%016" PFLL "X ITeb:%016" PFLL "X\n"
" INat:%016" PFLL "X\n",
( HB_U32 ) pExceptionInfo->ExceptionRecord->ExceptionCode,
pExceptionInfo->ExceptionRecord->ExceptionAddress,
pCtx->IntS0 , pCtx->IntS1 , pCtx->IntS2 , pCtx->IntS3 ,
pCtx->IntT0 , pCtx->IntT1 , pCtx->IntT2 , pCtx->IntT3 ,
pCtx->IntT4 , pCtx->IntT5 , pCtx->IntT6 , pCtx->IntT7 ,
pCtx->IntT8 , pCtx->IntT9 , pCtx->IntT10, pCtx->IntT11,
pCtx->IntT12, pCtx->IntT13, pCtx->IntT14, pCtx->IntT15,
pCtx->IntT16, pCtx->IntT17, pCtx->IntT18, pCtx->IntT19,
pCtx->IntT20, pCtx->IntT21, pCtx->IntT22,
pCtx->IntGp , pCtx->IntV0 , pCtx->IntSp , pCtx->IntTeb,
pCtx->IntNats );
}
#elif defined( HB_OS_WIN_CE ) && defined( HB_CPU_ARM )
{
PCONTEXT pCtx = pExceptionInfo->ContextRecord;
hb_snprintf( errmsg, errmsglen,
"\n\n"
" Exception Code:%08X\n"
" Exception Address:%08X\n"
" R0 :%08X R1 :%08X R2 :%08X R3 :%08X\n"
" R4 :%08X R5 :%08X R6 :%08X R7 :%08X\n"
" R8 :%08X R9 :%08X R10:%08X R11:%08X\n"
" R12:%08X\n"
" SP :%08X LR :%08X PC :%08X\n"
" Flags:%08X\n",
( HB_U32 ) pExceptionInfo->ExceptionRecord->ExceptionCode,
( HB_U32 ) pExceptionInfo->ExceptionRecord->ExceptionAddress,
( HB_U32 ) pCtx->R0 , ( HB_U32 ) pCtx->R1 , ( HB_U32 ) pCtx->R2 , ( HB_U32 ) pCtx->R3 ,
( HB_U32 ) pCtx->R4 , ( HB_U32 ) pCtx->R5 , ( HB_U32 ) pCtx->R6 , ( HB_U32 ) pCtx->R7 ,
( HB_U32 ) pCtx->R8 , ( HB_U32 ) pCtx->R9 , ( HB_U32 ) pCtx->R10, ( HB_U32 ) pCtx->R11,
( HB_U32 ) pCtx->R12,
( HB_U32 ) pCtx->Sp , ( HB_U32 ) pCtx->Lr , ( HB_U32 ) pCtx->Pc,
( HB_U32 ) pCtx->Psr );
}
#elif defined( HB_OS_WIN_CE ) && defined( HB_CPU_MIPS ) && defined( HB_ARCH_32BIT )
{
PCONTEXT pCtx = pExceptionInfo->ContextRecord;
hb_snprintf( errmsg, errmsglen,
"\n\n"
" Exception Code:%08X\n"
" Exception Address:%08X\n"
" IZe:%08X IAt:%08X ILo:%08X IHi:%08X\n"
" IA0:%08X IA1:%08X IA2:%08X IA3:%08X\n"
" IT0:%08X IT1:%08X IT2:%08X IT3:%08X\n"
" IT4:%08X IT5:%08X IT6:%08X IT7:%08X\n"
" IT8:%08X IT9:%08X IV0:%08X IV1:%08X\n"
" IS0:%08X IS1:%08X IS2:%08X IS3:%08X\n"
" IS4:%08X IS5:%08X IS6:%08X IS7:%08X\n"
" IS8:%08X IK0:%08X IK1:%08X\n"
" IGp:%08X ISp:%08X IRa:%08X\n"
" Fsr:%08X Fir:%08X Psr:%08X\n",
( HB_U32 ) pExceptionInfo->ExceptionRecord->ExceptionCode,
( HB_U32 ) pExceptionInfo->ExceptionRecord->ExceptionAddress,
( HB_U32 ) pCtx->IntZero, ( HB_U32 ) pCtx->IntAt, ( HB_U32 ) pCtx->IntLo, ( HB_U32 ) pCtx->IntHi,
( HB_U32 ) pCtx->IntA0, ( HB_U32 ) pCtx->IntA1, ( HB_U32 ) pCtx->IntA2, ( HB_U32 ) pCtx->IntA3,
( HB_U32 ) pCtx->IntT0, ( HB_U32 ) pCtx->IntT1, ( HB_U32 ) pCtx->IntT2, ( HB_U32 ) pCtx->IntT3,
( HB_U32 ) pCtx->IntT4, ( HB_U32 ) pCtx->IntT5, ( HB_U32 ) pCtx->IntT6, ( HB_U32 ) pCtx->IntT7,
( HB_U32 ) pCtx->IntT8, ( HB_U32 ) pCtx->IntT9, ( HB_U32 ) pCtx->IntV0, ( HB_U32 ) pCtx->IntV1,
( HB_U32 ) pCtx->IntS0, ( HB_U32 ) pCtx->IntS1, ( HB_U32 ) pCtx->IntS2, ( HB_U32 ) pCtx->IntS3,
( HB_U32 ) pCtx->IntS4, ( HB_U32 ) pCtx->IntS5, ( HB_U32 ) pCtx->IntS6, ( HB_U32 ) pCtx->IntS7,
( HB_U32 ) pCtx->IntS8, ( HB_U32 ) pCtx->IntK0, ( HB_U32 ) pCtx->IntK1,
( HB_U32 ) pCtx->IntGp, ( HB_U32 ) pCtx->IntSp, ( HB_U32 ) pCtx->IntRa,
( HB_U32 ) pCtx->Fsr , ( HB_U32 ) pCtx->Fir , ( HB_U32 ) pCtx->Psr );
}
#elif defined( HB_OS_WIN_CE ) && defined( HB_CPU_MIPS ) && defined( HB_ARCH_64BIT ) /* Such platform doesn't currently exist [2010]. */
{
PCONTEXT pCtx = pExceptionInfo->ContextRecord;
hb_snprintf( errmsg, errmsglen,
"\n\n"
" Exception Code:%08X\n"
" Exception Address:%016" PFLL "X\n"
" IZe:%016" PFLL "X IAt:%016" PFLL "X ILo:%016" PFLL "X IHi:%016" PFLL "X\n"
" IA0:%016" PFLL "X IA1:%016" PFLL "X IA2:%016" PFLL "X IA3:%016" PFLL "X\n"
" IT0:%016" PFLL "X IT1:%016" PFLL "X IT2:%016" PFLL "X IT3:%016" PFLL "X\n"
" IT4:%016" PFLL "X IT5:%016" PFLL "X IT6:%016" PFLL "X IT7:%016" PFLL "X\n"
" IT8:%016" PFLL "X IT9:%016" PFLL "X IV0:%016" PFLL "X IV1:%016" PFLL "X\n"
" IS0:%016" PFLL "X IS1:%016" PFLL "X IS2:%016" PFLL "X IS3:%016" PFLL "X\n"
" IS4:%016" PFLL "X IS5:%016" PFLL "X IS6:%016" PFLL "X IS7:%016" PFLL "X\n"
" IS8:%016" PFLL "X IK0:%016" PFLL "X IK1:%016" PFLL "X\n"
" IGp:%016" PFLL "X ISp:%016" PFLL "X IRa:%016" PFLL "X\n"
" Fsr:%016" PFLL "X Fir:%016" PFLL "X Psr:%016" PFLL "X\n",
( HB_U32 ) pExceptionInfo->ExceptionRecord->ExceptionCode,
pExceptionInfo->ExceptionRecord->ExceptionAddress,
pCtx->IntZero, pCtx->IntAt, pCtx->IntLo, pCtx->IntHi,
pCtx->IntA0, pCtx->IntA1, pCtx->IntA2, pCtx->IntA3,
pCtx->IntT0, pCtx->IntT1, pCtx->IntT2, pCtx->IntT3,
pCtx->IntT4, pCtx->IntT5, pCtx->IntT6, pCtx->IntT7,
pCtx->IntT8, pCtx->IntT9, pCtx->IntV0, pCtx->IntV1,
pCtx->IntS0, pCtx->IntS1, pCtx->IntS2, pCtx->IntS3,
pCtx->IntS4, pCtx->IntS5, pCtx->IntS6, pCtx->IntS7,
pCtx->IntS8, pCtx->IntK0, pCtx->IntK1,
pCtx->IntGp, pCtx->IntSp, pCtx->IntRa,
pCtx->Fsr , pCtx->Fir , pCtx->Psr );
}
#elif defined( HB_OS_WIN_CE ) && defined( HB_CPU_SH )
{
PCONTEXT pCtx = pExceptionInfo->ContextRecord;
hb_snprintf( errmsg, errmsglen,
"\n\n"
" Exception Code:%08X\n"
" Exception Address:%08X\n"
" R0 :%08X R1 :%08X R2 :%08X R3 :%08X\n"
" R4 :%08X R5 :%08X R6 :%08X R7 :%08X\n"
" R8 :%08X R9 :%08X R10:%08X R11:%08X\n"
" R12:%08X R13:%08X R14:%08X R15:%08X\n"
" PR :%08X MACH:%08X MACL:%08X GBR:%08X\n",
( HB_U32 ) pExceptionInfo->ExceptionRecord->ExceptionCode,
( HB_U32 ) pExceptionInfo->ExceptionRecord->ExceptionAddress,
( HB_U32 ) pCtx->R0 , ( HB_U32 ) pCtx->R1 , ( HB_U32 ) pCtx->R2 , ( HB_U32 ) pCtx->R3 ,
( HB_U32 ) pCtx->R4 , ( HB_U32 ) pCtx->R5 , ( HB_U32 ) pCtx->R6 , ( HB_U32 ) pCtx->R7 ,
( HB_U32 ) pCtx->R8 , ( HB_U32 ) pCtx->R9 , ( HB_U32 ) pCtx->R10, ( HB_U32 ) pCtx->R11,
( HB_U32 ) pCtx->R12, ( HB_U32 ) pCtx->R13, ( HB_U32 ) pCtx->R14, ( HB_U32 ) pCtx->R15,
( HB_U32 ) pCtx->PR, ( HB_U32 ) pCtx->MACH, ( HB_U32 ) pCtx->MACL, ( HB_U32 ) pCtx->GBR );
}
#elif defined( HB_CPU_X86 )
{
char buf[ 64 + MAX_PATH ];
PCONTEXT pCtx = pExceptionInfo->ContextRecord;
const char * szCode;
/* two most common codes */
switch( pExceptionInfo->ExceptionRecord->ExceptionCode )
{
case EXCEPTION_ACCESS_VIOLATION:
szCode = " " "ACCESS_VIOLATION";
break;
case EXCEPTION_IN_PAGE_ERROR:
szCode = " " "IN_PAGE_ERROR";
break;
default:
szCode = "";
}
hb_snprintf( errmsg, errmsglen,
"\n\n"
" Exception Code:%08X%s\n"
" Exception Address:%08X\n"
" EAX:%08X EBX:%08X ECX:%08X EDX:%08X\n"
" ESI:%08X EDI:%08X EBP:%08X\n"
" CS:EIP:%04X:%08X SS:ESP:%04X:%08X\n"
" DS:%04X ES:%04X FS:%04X GS:%04X\n"
" Flags:%08X\n",
( HB_U32 ) pExceptionInfo->ExceptionRecord->ExceptionCode, szCode,
( HB_U32 ) pExceptionInfo->ExceptionRecord->ExceptionAddress,
( HB_U32 ) pCtx->Eax, ( HB_U32 ) pCtx->Ebx, ( HB_U32 ) pCtx->Ecx, ( HB_U32 ) pCtx->Edx,
( HB_U32 ) pCtx->Esi, ( HB_U32 ) pCtx->Edi, ( HB_U32 ) pCtx->Ebp,
( HB_U32 ) pCtx->SegCs, ( HB_U32 ) pCtx->Eip, ( HB_U32 ) pCtx->SegSs, ( HB_U32 ) pCtx->Esp,
( HB_U32 ) pCtx->SegDs, ( HB_U32 ) pCtx->SegEs, ( HB_U32 ) pCtx->SegFs, ( HB_U32 ) pCtx->SegGs,
( HB_U32 ) pCtx->EFlags );
if( pExceptionInfo->ExceptionRecord->NumberParameters &&
pExceptionInfo->ExceptionRecord->NumberParameters < ( DWORD ) EXCEPTION_MAXIMUM_PARAMETERS )
{
DWORD arg;
hb_strncat( errmsg, " Exception Parameters:", errmsglen );
for( arg = 0; arg < pExceptionInfo->ExceptionRecord->NumberParameters; ++arg )
{
hb_snprintf( buf, sizeof( buf ), " %08X", ( HB_U32 ) pExceptionInfo->ExceptionRecord->ExceptionInformation[ arg ] );
hb_strncat( errmsg, buf, errmsglen );
}
hb_strncat( errmsg, "\n", errmsglen );
}
{
unsigned char * pc;
unsigned int * sc;
unsigned int * ebp;
unsigned int eip;
unsigned int j;
int i;
hb_strncat( errmsg, " CS:EIP:", errmsglen );
pc = ( unsigned char * ) pCtx->Eip;
for( i = 0; i < 16; i++ )
{
/* TOFIX: Unsafe funcion. */
if( IsBadReadPtr( pc, 1 ) )
break;
hb_snprintf( buf, sizeof( buf ), " %02X", ( int ) pc[ i ] );
hb_strncat( errmsg, buf, errmsglen );
}
hb_strncat( errmsg, "\n SS:ESP:", errmsglen );
sc = ( unsigned int * ) pCtx->Esp;
for( i = 0; i < 16; i++ )
{
/* TOFIX: Unsafe funcion. */
if( IsBadReadPtr( sc, 4 ) )
break;
hb_snprintf( buf, sizeof( buf ), " %08X", sc[ i ] );
hb_strncat( errmsg, buf, errmsglen );
}
hb_strncat( errmsg, "\n\n", errmsglen );
hb_strncat( errmsg, " C stack:\n", errmsglen );
hb_strncat( errmsg, " EIP: EBP: Frame: OldEBP, RetAddr, Params...\n", errmsglen );
eip = pCtx->Eip;
ebp = ( unsigned int * ) pCtx->Ebp;
/* TOFIX: Unsafe funcion. */
if( ! IsBadWritePtr( ebp, 8 ) )
{
for( i = 0; i < 20; i++ )
{
/* TOFIX: Unsafe funcion. */
if( ( unsigned int ) ebp % 4 != 0 || IsBadWritePtr( ebp, 40 ) || ( unsigned int ) ebp >= ebp[ 0 ] )
break;
hb_snprintf( buf, sizeof( buf ), " %08X %08X ", ( int ) eip, ( int ) ebp );
hb_strncat( errmsg, buf, errmsglen );
for( j = 0; j < 10 && ( unsigned int ) ( ebp + j ) < ebp[ 0 ]; j++ )
{
hb_snprintf( buf, sizeof( buf ), " %08X", ebp[ j ] );
hb_strncat( errmsg, buf, errmsglen );
}
hb_strncat( errmsg, "\n", errmsglen );
eip = ebp[ 1 ];
ebp = ( unsigned int * ) ebp[ 0 ];
}
hb_strncat( errmsg, "\n", errmsglen );
}
}
}
#endif
{
#if defined( HB_OS_WIN_CE )
HMODULE hToolhelp = GetModuleHandle( TEXT( "toolhelp.dll" ) );
#else
/* NOTE: Several non-MS sources say that Win9x has these functions
in tlhelp32.dll. Testing shows though, that in Win95, Win95b
and Win98 they are in kernel32.dll, and tlhelp32.dll doesn't
exist. [vszakats] */
HMODULE hToolhelp = GetModuleHandle( TEXT( "kernel32.dll" ) );
#endif
if( hToolhelp )
{
/* NOTE: Hack to force the ASCII versions of these types. [vszakats] */
#if ! defined( HB_OS_WIN_CE ) && defined( UNICODE )
#undef MODULEENTRY32
#undef LPMODULEENTRY32
#endif
typedef HANDLE ( WINAPI * P_CTH32SSH )( DWORD, DWORD ); /* CreateToolhelp32Snapshot() */
typedef BOOL ( WINAPI * P_M32F )( HANDLE, LPMODULEENTRY32 ); /* Module32First() */
typedef BOOL ( WINAPI * P_M32N )( HANDLE, LPMODULEENTRY32 ); /* Module32Next() */
P_CTH32SSH pCreateToolhelp32Snapshot = ( P_CTH32SSH ) HB_WINAPI_GETPROCADDRESS( hToolhelp, "CreateToolhelp32Snapshot" );
P_M32F pModule32First = ( P_M32F ) HB_WINAPI_GETPROCADDRESS( hToolhelp, "Module32First" );
P_M32N pModule32Next = ( P_M32N ) HB_WINAPI_GETPROCADDRESS( hToolhelp, "Module32Next" );
if( pCreateToolhelp32Snapshot &&
pModule32First &&
pModule32Next )
{
/* Take a snapshot of all modules in the specified process. */
HANDLE hModuleSnap = pCreateToolhelp32Snapshot( TH32CS_SNAPMODULE | TH32CS_SNAPMODULE32, GetCurrentProcessId() );
if( hModuleSnap != INVALID_HANDLE_VALUE )
{
MODULEENTRY32 me32;
/* Set the size of the structure before using it. */
me32.dwSize = sizeof( MODULEENTRY32 );
/* Retrieve information about the first module, and exit if unsuccessful */
if( pModule32First( hModuleSnap, &me32 ) )
{
hb_strncat( errmsg, "\nModules:\n", errmsglen );
/* Now walk the module list of the process, and display information about each module */
do
{
char buf[ 256 ];
#if defined( HB_OS_WIN_64 )
/* TOFIX: me32.szExePath seemed trashed in some (standalone) tests. */
hb_snprintf( buf, sizeof( buf ), "%016" PFLL "X %016" PFLL "X %s\n", ( HB_PTRDIFF ) me32.modBaseAddr, ( HB_PTRDIFF ) me32.modBaseSize, me32.szExePath );
#else
char szBuffer[ MAX_PATH ];
#if defined( HB_OS_WIN_CE )
hb_wcntombcpy( szBuffer, me32.szExePath, HB_SIZEOFARRAY( szBuffer ) - 1 );
#else
hb_strncpy( szBuffer, me32.szExePath, HB_SIZEOFARRAY( szBuffer ) - 1 );
#endif
hb_snprintf( buf, sizeof( buf ), "%08lX %08lX %s\n", ( HB_PTRDIFF ) me32.modBaseAddr, ( HB_PTRDIFF ) me32.modBaseSize, szBuffer );
#endif
hb_strncat( errmsg, buf, errmsglen );
}
while( pModule32Next( hModuleSnap, &me32 ) );
}
/* Do not forget to clean up the snapshot object. */
CloseHandle( hModuleSnap );
}
}
}
}
hb_errInternalRaw( 6005, "Exception error:%s", errmsg, NULL );
return hb_cmdargCheck( "BATCH" ) ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH;
}
