From 1d7ee5470b34869a1bb6ef0abe429e854da4e951 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Przemys=C5=82aw=20Czerpak?= Date: Sun, 6 Sep 2015 15:44:49 +0200 Subject: [PATCH] 2015-09-06 15:44 UTC+0200 Przemyslaw Czerpak (druzus/at/poczta.onet.pl) * src/rtl/disksphb.c * src/rtl/filesys.c * use native system functions for disk and file IO operations in OS2 builds. + added support for long files (> 2GB) in OS2 builds ! fixed file IO error setting in OS2 builds ; For above modifications I had to change nearly all file IO functions in OS2 build. I would like to OS2 users to make tests. In next step I'll update hb_process*() functions. --- ChangeLog.txt | 11 + src/rtl/disksphb.c | 8 +- src/rtl/filesys.c | 861 ++++++++++++++++++++++++++++++++++----------- 3 files changed, 672 insertions(+), 208 deletions(-) diff --git a/ChangeLog.txt b/ChangeLog.txt index b3bf53cb0f..f04b0ea771 100644 --- a/ChangeLog.txt +++ b/ChangeLog.txt @@ -10,6 +10,17 @@ * Change, ! Fix, % Optimization, + Addition, - Removal, ; Comment */ +2015-09-06 15:44 UTC+0200 Przemyslaw Czerpak (druzus/at/poczta.onet.pl) + * src/rtl/disksphb.c + * src/rtl/filesys.c + * use native system functions for disk and file IO operations in OS2 + builds. + + added support for long files (> 2GB) in OS2 builds + ! fixed file IO error setting in OS2 builds + ; For above modifications I had to change nearly all file IO functions + in OS2 build. I would like to OS2 users to make tests. + In next step I'll update hb_process*() functions. + 2015-09-03 14:02 UTC+0200 Przemyslaw Czerpak (druzus/at/poczta.onet.pl) * win-make.exe * updated GNU make for MS-Windows to version 4.1 diff --git a/src/rtl/disksphb.c b/src/rtl/disksphb.c index 58d1b7a338..34d1f9f51a 100644 --- a/src/rtl/disksphb.c +++ b/src/rtl/disksphb.c @@ -277,17 +277,17 @@ double hb_fsDiskSpace( const char * pszPath, HB_USHORT uiType ) #else /* HB_OS_OS2 */ { struct _FSALLOCATE fsa; - USHORT rc; + APIRET rc; /* Query level 1 info from filesystem */ - while( ( rc = DosQueryFSInfo( uiDrive, 1, &fsa, sizeof( fsa ) ) ) != 0 ) + 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_fsSetIOError( rc == 0, 0 ); + hb_fsSetError( ( HB_ERRCODE ) rc ); - if( rc == 0 ) + if( rc == NO_ERROR ) { switch( uiType ) { diff --git a/src/rtl/filesys.c b/src/rtl/filesys.c index 384e1895fe..62df598ff0 100644 --- a/src/rtl/filesys.c +++ b/src/rtl/filesys.c @@ -176,6 +176,7 @@ #define INCL_DOSFILEMGR #define INCL_DOSERRORS #define INCL_DOSDATETIME + #define INCL_LONGLONG #include #include #include @@ -420,7 +421,7 @@ static HANDLE DosToWinHandle( HB_FHANDLE fHandle ) return ( HANDLE ) fHandle; } -static void convert_open_flags( HB_BOOL fCreate, HB_FATTR ulAttr, HB_USHORT uiFlags, +static void convert_open_flags( HB_BOOL fCreate, HB_FATTR nAttr, HB_USHORT uiFlags, DWORD * dwMode, DWORD * dwShare, DWORD * dwCreat, DWORD * dwAttr ) { @@ -478,43 +479,116 @@ static void convert_open_flags( HB_BOOL fCreate, HB_FATTR ulAttr, HB_USHORT uiFl } /* file attributes flags */ - if( ulAttr == FC_NORMAL ) - { + if( nAttr == FC_NORMAL ) *dwAttr = FILE_ATTRIBUTE_NORMAL; - } else { *dwAttr = FILE_ATTRIBUTE_ARCHIVE; - if( ulAttr & FC_READONLY ) + if( nAttr & FC_READONLY ) *dwAttr |= FILE_ATTRIBUTE_READONLY; - if( ulAttr & FC_HIDDEN ) + if( nAttr & FC_HIDDEN ) *dwAttr |= FILE_ATTRIBUTE_HIDDEN; - if( ulAttr & FC_SYSTEM ) + if( nAttr & FC_SYSTEM ) *dwAttr |= FILE_ATTRIBUTE_SYSTEM; } } +#elif defined( HB_OS_OS2 ) + +static void convert_open_flags( HB_BOOL fCreate, HB_FATTR nAttr, HB_USHORT uiFlags, + PULONG fsOpenMode, PULONG fsOpenFlag, PULONG pulAttr ) +{ + if( fCreate ) + { + *fsOpenMode = OPEN_ACTION_CREATE_IF_NEW | + ( uiFlags & FO_EXCL ? OPEN_ACTION_FAIL_IF_EXISTS : + OPEN_ACTION_REPLACE_IF_EXISTS ); + *fsOpenFlag = OPEN_ACCESS_READWRITE; + } + else + { + if( uiFlags & FO_CREAT ) + { + if( uiFlags & FO_EXCL ) + *fsOpenMode = OPEN_ACTION_CREATE_IF_NEW | OPEN_ACTION_FAIL_IF_EXISTS; + else if( uiFlags & FO_TRUNC ) + *fsOpenMode = OPEN_ACTION_CREATE_IF_NEW | OPEN_ACTION_REPLACE_IF_EXISTS; + else + *fsOpenMode = OPEN_ACTION_CREATE_IF_NEW | OPEN_ACTION_OPEN_IF_EXISTS; + } + else if( uiFlags & FO_TRUNC ) + *fsOpenMode = OPEN_ACTION_FAIL_IF_NEW | OPEN_ACTION_REPLACE_IF_EXISTS; + else + *fsOpenMode = OPEN_ACTION_FAIL_IF_NEW | OPEN_ACTION_OPEN_IF_EXISTS; + + *fsOpenFlag = 0; + switch( uiFlags & ( FO_READ | FO_WRITE | FO_READWRITE ) ) + { + case FO_READWRITE: + *fsOpenFlag |= OPEN_ACCESS_READWRITE; + break; + case FO_WRITE: + *fsOpenFlag |= OPEN_ACCESS_WRITEONLY; + break; + case FO_READ: + *fsOpenFlag |= OPEN_ACCESS_READONLY; + break; + } + } + + /* shared flags */ + switch( uiFlags & ( FO_DENYREAD | FO_DENYWRITE | FO_EXCLUSIVE | FO_DENYNONE ) ) + { + case FO_DENYREAD: + *fsOpenFlag = OPEN_SHARE_DENYREAD; + break; + case FO_DENYWRITE: + *fsOpenFlag = OPEN_SHARE_DENYWRITE; + break; + case FO_EXCLUSIVE: + *fsOpenFlag = OPEN_SHARE_DENYREADWRITE; + break; + default: + *fsOpenFlag = OPEN_SHARE_DENYNONE; + break; + } + + /* file attributes flags */ + if( nAttr == FC_NORMAL ) + *pulAttr = FILE_NORMAL; + else + { + *pulAttr = FILE_ARCHIVED; + if( nAttr & FC_READONLY ) + *pulAttr |= FILE_READONLY; + if( nAttr & FC_HIDDEN ) + *pulAttr |= FILE_HIDDEN; + if( nAttr & FC_SYSTEM ) + *pulAttr |= FILE_SYSTEM; + } +} + #else -static void convert_open_flags( HB_BOOL fCreate, HB_FATTR ulAttr, HB_USHORT uiFlags, +static void convert_open_flags( HB_BOOL fCreate, HB_FATTR nAttr, HB_USHORT uiFlags, int * flags, unsigned * mode, int * share, int * attr ) { - HB_TRACE( HB_TR_DEBUG, ( "convert_open_flags(%d, %u, %hu, %p, %p, %p, %p)", fCreate, ulAttr, uiFlags, flags, mode, share, attr ) ); + HB_TRACE( HB_TR_DEBUG, ( "convert_open_flags(%d, %u, %hu, %p, %p, %p, %p)", fCreate, nAttr, uiFlags, flags, mode, share, attr ) ); /* file access mode */ #if defined( HB_OS_UNIX ) - *mode = HB_FA_POSIX_ATTR( ulAttr ); + *mode = HB_FA_POSIX_ATTR( nAttr ); if( *mode == 0 ) { - *mode = ( ulAttr & FC_HIDDEN ) ? S_IRUSR : ( S_IRUSR | S_IRGRP | S_IROTH ); - if( ! ( ulAttr & FC_READONLY ) ) + *mode = ( nAttr & FC_HIDDEN ) ? S_IRUSR : ( S_IRUSR | S_IRGRP | S_IROTH ); + if( ! ( nAttr & FC_READONLY ) ) { if( *mode & S_IRUSR ) *mode |= S_IWUSR; if( *mode & S_IRGRP ) *mode |= S_IWGRP; if( *mode & S_IROTH ) *mode |= S_IWOTH; } - if( ulAttr & FC_SYSTEM ) + if( nAttr & FC_SYSTEM ) { if( *mode & S_IRUSR ) *mode |= S_IXUSR; if( *mode & S_IRGRP ) *mode |= S_IXGRP; @@ -523,24 +597,24 @@ static void convert_open_flags( HB_BOOL fCreate, HB_FATTR ulAttr, HB_USHORT uiFl } #else *mode = S_IREAD | - ( ( ulAttr & FC_READONLY ) ? 0 : S_IWRITE ) | - ( ( ulAttr & FC_SYSTEM ) ? S_IEXEC : 0 ); + ( ( nAttr & FC_READONLY ) ? 0 : S_IWRITE ) | + ( ( nAttr & FC_SYSTEM ) ? S_IEXEC : 0 ); #endif /* dos file attributes */ #if defined( HB_FS_DOSATTR ) - if( ulAttr == FC_NORMAL ) + if( nAttr == FC_NORMAL ) { *attr = _A_NORMAL; } else { *attr = _A_ARCH; - if( ulAttr & FC_READONLY ) + if( nAttr & FC_READONLY ) *attr |= _A_READONLY; - if( ulAttr & FC_HIDDEN ) + if( nAttr & FC_HIDDEN ) *attr |= _A_HIDDEN; - if( ulAttr & FC_SYSTEM ) + if( nAttr & FC_SYSTEM ) *attr |= _A_SYSTEM; } #else @@ -791,21 +865,17 @@ HB_BOOL hb_fsPipeCreate( HB_FHANDLE hPipe[ 2 ] ) } #elif defined( HB_OS_OS2 ) { -# if defined( __GNUC__ ) - fResult = pipe( hPipe ) == 0; - if( fResult ) - { - setmode( hPipe[ 0 ], O_BINARY ); - setmode( hPipe[ 1 ], O_BINARY ); - } - else - hPipe[ 0 ] = hPipe[ 1 ] = FS_ERROR; -# else - fResult = _pipe( hPipe, 4096, _O_BINARY ) == 0; - if( ! fResult ) - hPipe[ 0 ] = hPipe[ 1 ] = FS_ERROR; -# endif - hb_fsSetIOError( fResult, 0 ); + HFILE hPipeRd, hPipeWr; + APIRET ret = DosCreatePipe( &hPipeRd, &hPipeWr, 4096 ); + hb_fsSetError( ( HB_ERRCODE ) ret ); + fResult = ret == NO_ERROR; + if( fResult ) + { + hPipe[ 0 ] = ( HB_FHANDLE ) hPipeRd; + hPipe[ 1 ] = ( HB_FHANDLE ) hPipeWr; + } + else + hPipe[ 0 ] = hPipe[ 1 ] = FS_ERROR; } #elif defined( HB_OS_UNIX ) && ! defined( HB_OS_VXWORKS ) && ! defined( HB_OS_SYMBIAN ) { @@ -856,7 +926,7 @@ int hb_fsIsPipeOrSock( HB_FHANDLE hPipeHandle ) { ULONG type = 0, attr = 0; APIRET ret = DosQueryHType( ( HFILE ) hPipeHandle, &type, &attr ); - hb_fsSetIOError( ret == NO_ERROR, 0 ); + hb_fsSetError( ( HB_ERRCODE ) ret ); return ret == NO_ERROR && ( type & 0xFF ) == FHT_PIPE ? 1 : 0; } #else @@ -886,7 +956,7 @@ HB_BOOL hb_fsPipeUnblock( HB_FHANDLE hPipeHandle ) #elif defined( HB_OS_OS2 ) { APIRET ret = DosSetNPHState( ( HPIPE ) hPipeHandle, NP_NOWAIT ); - hb_fsSetIOError( ret == NO_ERROR, 0 ); + hb_fsSetError( ( HB_ERRCODE ) ret ); return ret == NO_ERROR; } #elif defined( HB_OS_UNIX ) && ! defined( HB_OS_MINIX ) @@ -963,8 +1033,8 @@ HB_SIZE hb_fsPipeIsData( HB_FHANDLE hPipeHandle, HB_SIZE nBufferSize, avail.cbmessage = 0; ret = DosPeekNPipe( ( HPIPE ) hPipeHandle, NULL, 0, NULL, &avail, NULL ); + hb_fsSetError( ( HB_ERRCODE ) ret ); fResult = ret == NO_ERROR || ret == ERROR_PIPE_BUSY; - hb_fsSetIOError( fResult, 0 ); } while( fResult && avail.cbpipe == 0 && ( nTimeOut < 0 || ( end_timer > 0 && @@ -1090,18 +1160,28 @@ HB_SIZE hb_fsPipeWrite( HB_FHANDLE hPipeHandle, const void * buffer, HB_SIZE nSi SetNamedPipeHandleState( hPipe, &dwNewMode, NULL, NULL ); } + nWritten = 0; do { - DWORD dwWritten; + DWORD dwWritten, dwToWrite; if( fResult ) hb_releaseCPU(); - fResult = WriteFile( hPipe, buffer, ( DWORD ) nSize, &dwWritten, NULL ) != 0; - nWritten = fResult ? ( HB_SIZE ) dwWritten : ( HB_SIZE ) FS_ERROR; + dwToWrite = ( DWORD ) ( nSize - nWritten ); + /* real life tests show that MSDN is wrong and MS-Windows + refuse to accept even single byte if data is longer then + size of PIPE buffer in unblocking mode [druzus] */ + if( dwToWrite > 4096 ) + dwToWrite = 4096; + fResult = WriteFile( hPipe, ( const HB_BYTE * ) buffer + nWritten, dwToWrite, &dwWritten, NULL ) != 0; + if( fResult ) + nWritten += ( HB_SIZE ) dwWritten; + else if( nWritten == 0 ) + nWritten = ( HB_SIZE ) FS_ERROR; hb_fsSetIOError( fResult, 0 ); } - while( fResult && nWritten == 0 && + while( fResult && nWritten < nSize && ( nTimeOut < 0 || ( end_timer > 0 && end_timer > hb_dateMilliSeconds() ) ) && hb_vmRequestQuery() == 0 ); @@ -1118,8 +1198,10 @@ HB_SIZE hb_fsPipeWrite( HB_FHANDLE hPipeHandle, const void * buffer, HB_SIZE nSi #elif defined( HB_OS_OS2 ) { ULONG state = 0; + APIRET ret; - if( DosQueryNPHState( ( HPIPE ) hPipeHandle, &state ) == NO_ERROR ) + ret = DosQueryNPHState( ( HPIPE ) hPipeHandle, &state ); + if( ret == NO_ERROR ) { HB_MAXUINT end_timer = nTimeOut > 0 ? hb_dateMilliSeconds() + nTimeOut : 0; HB_BOOL fResult = HB_FALSE; @@ -1134,10 +1216,11 @@ HB_SIZE hb_fsPipeWrite( HB_FHANDLE hPipeHandle, const void * buffer, HB_SIZE nSi if( fResult ) hb_releaseCPU(); - fResult = DosWrite( ( HPIPE ) hPipeHandle, ( PVOID ) buffer, - ( ULONG ) nSize, &cbActual ) == NO_ERROR; + ret = DosWrite( ( HPIPE ) hPipeHandle, ( PVOID ) buffer, + ( ULONG ) nSize, &cbActual ); + hb_fsSetError( ( HB_ERRCODE ) ret ); + fResult = ret == NO_ERROR; nWritten = fResult ? ( HB_SIZE ) cbActual : ( HB_SIZE ) FS_ERROR; - hb_fsSetIOError( fResult, 0 ); } while( fResult && nWritten == 0 && ( nTimeOut < 0 || ( end_timer > 0 && @@ -1149,7 +1232,7 @@ HB_SIZE hb_fsPipeWrite( HB_FHANDLE hPipeHandle, const void * buffer, HB_SIZE nSi } else { - hb_fsSetIOError( HB_FALSE, 0 ); + hb_fsSetError( ( HB_ERRCODE ) ret ); nWritten = ( HB_SIZE ) FS_ERROR; } } @@ -1268,6 +1351,30 @@ HB_FHANDLE hb_fsOpen( const char * pszFileName, HB_USHORT uiFlags ) hFileHandle = ( HB_FHANDLE ) hFile; } +#elif defined( HB_OS_OS2 ) + { + char * pszFree; + HFILE hFile; + ULONG ulAction = 0, ulAttribute, fsOpenFlag, fsOpenMode; + APIRET ret; + + pszFileName = hb_fsNameConv( pszFileName, &pszFree ); + convert_open_flags( HB_FALSE, FC_NORMAL, uiFlags, + &fsOpenMode, &fsOpenFlag, &ulAttribute ); + + hb_vmUnlock(); + + ret = DosOpen( ( PSZ ) pszFileName, &hFile, &ulAction, 0, + ulAttribute, fsOpenFlag, fsOpenMode, NULL ); + + hFileHandle = ret == NO_ERROR ? ( HB_FHANDLE ) hFile : FS_ERROR; + hb_fsSetError( ( HB_ERRCODE ) ret ); + + hb_vmLock(); + + if( pszFree ) + hb_xfree( pszFree ); + } #else { char * pszFree; @@ -1304,11 +1411,11 @@ HB_FHANDLE hb_fsOpen( const char * pszFileName, HB_USHORT uiFlags ) return hFileHandle; } -HB_FHANDLE hb_fsCreate( const char * pszFileName, HB_FATTR ulAttr ) +HB_FHANDLE hb_fsCreate( const char * pszFileName, HB_FATTR nAttr ) { HB_FHANDLE hFileHandle; - HB_TRACE( HB_TR_DEBUG, ( "hb_fsCreate(%s, %u)", pszFileName, ulAttr ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_fsCreate(%s, %u)", pszFileName, nAttr ) ); #if defined( HB_OS_WIN ) { @@ -1319,7 +1426,7 @@ HB_FHANDLE hb_fsCreate( const char * pszFileName, HB_FATTR ulAttr ) lpFileName = HB_FSNAMECONV( pszFileName, &lpFree ); - convert_open_flags( HB_TRUE, ulAttr, FO_EXCLUSIVE, &dwMode, &dwShare, &dwCreat, &dwAttr ); + convert_open_flags( HB_TRUE, nAttr, FO_EXCLUSIVE, &dwMode, &dwShare, &dwCreat, &dwAttr ); hb_vmUnlock(); hFile = CreateFile( lpFileName, dwMode, dwShare, NULL, dwCreat, dwAttr, NULL ); @@ -1331,6 +1438,30 @@ HB_FHANDLE hb_fsCreate( const char * pszFileName, HB_FATTR ulAttr ) hFileHandle = ( HB_FHANDLE ) hFile; } +#elif defined( HB_OS_OS2 ) + { + char * pszFree; + HFILE hFile; + ULONG ulAction = 0, ulAttribute, fsOpenFlag, fsOpenMode; + APIRET ret; + + pszFileName = hb_fsNameConv( pszFileName, &pszFree ); + convert_open_flags( HB_TRUE, nAttr, FO_EXCLUSIVE, + &fsOpenMode, &fsOpenFlag, &ulAttribute ); + + hb_vmUnlock(); + + ret = DosOpen( ( PSZ ) pszFileName, &hFile, &ulAction, 0, + ulAttribute, fsOpenFlag, fsOpenMode, NULL ); + + hFileHandle = ret == NO_ERROR ? ( HB_FHANDLE ) hFile : FS_ERROR; + hb_fsSetError( ( HB_ERRCODE ) ret ); + + hb_vmLock(); + + if( pszFree ) + hb_xfree( pszFree ); + } #else { char * pszFree; @@ -1339,7 +1470,7 @@ HB_FHANDLE hb_fsCreate( const char * pszFileName, HB_FATTR ulAttr ) pszFileName = hb_fsNameConv( pszFileName, &pszFree ); - convert_open_flags( HB_TRUE, ulAttr, FO_EXCLUSIVE, &flags, &mode, &share, &attr ); + convert_open_flags( HB_TRUE, nAttr, FO_EXCLUSIVE, &flags, &mode, &share, &attr ); hb_vmUnlock(); #if defined( HB_FS_DOSCREAT ) @@ -1367,11 +1498,11 @@ HB_FHANDLE hb_fsCreate( const char * pszFileName, HB_FATTR ulAttr ) [vszakats] */ -HB_FHANDLE hb_fsCreateEx( const char * pszFileName, HB_FATTR ulAttr, HB_USHORT uiFlags ) +HB_FHANDLE hb_fsCreateEx( const char * pszFileName, HB_FATTR nAttr, HB_USHORT uiFlags ) { HB_FHANDLE hFileHandle; - HB_TRACE( HB_TR_DEBUG, ( "hb_fsCreateEx(%s, %u, %hu)", pszFileName, ulAttr, uiFlags ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_fsCreateEx(%s, %u, %hu)", pszFileName, nAttr, uiFlags ) ); #if defined( HB_OS_WIN ) { @@ -1382,7 +1513,7 @@ HB_FHANDLE hb_fsCreateEx( const char * pszFileName, HB_FATTR ulAttr, HB_USHORT u lpFileName = HB_FSNAMECONV( pszFileName, &lpFree ); - convert_open_flags( HB_TRUE, ulAttr, uiFlags, &dwMode, &dwShare, &dwCreat, &dwAttr ); + convert_open_flags( HB_TRUE, nAttr, uiFlags, &dwMode, &dwShare, &dwCreat, &dwAttr ); hb_vmUnlock(); hFile = CreateFile( lpFileName, dwMode, dwShare, NULL, dwCreat, dwAttr, NULL ); @@ -1394,6 +1525,30 @@ HB_FHANDLE hb_fsCreateEx( const char * pszFileName, HB_FATTR ulAttr, HB_USHORT u hFileHandle = ( HB_FHANDLE ) hFile; } +#elif defined( HB_OS_OS2 ) + { + char * pszFree; + HFILE hFile; + ULONG ulAction = 0, ulAttribute, fsOpenFlag, fsOpenMode; + APIRET ret; + + pszFileName = hb_fsNameConv( pszFileName, &pszFree ); + convert_open_flags( HB_TRUE, nAttr, uiFlags, + &fsOpenMode, &fsOpenFlag, &ulAttribute ); + + hb_vmUnlock(); + + ret = DosOpen( ( PSZ ) pszFileName, &hFile, &ulAction, 0, + ulAttribute, fsOpenFlag, fsOpenMode, NULL ); + + hFileHandle = ret == NO_ERROR ? ( HB_FHANDLE ) hFile : FS_ERROR; + hb_fsSetError( ( HB_ERRCODE ) ret ); + + hb_vmLock(); + + if( pszFree ) + hb_xfree( pszFree ); + } #else { char * pszFree; @@ -1402,7 +1557,7 @@ HB_FHANDLE hb_fsCreateEx( const char * pszFileName, HB_FATTR ulAttr, HB_USHORT u pszFileName = hb_fsNameConv( pszFileName, &pszFree ); - convert_open_flags( HB_TRUE, ulAttr, uiFlags, &flags, &mode, &share, &attr ); + convert_open_flags( HB_TRUE, nAttr, uiFlags, &flags, &mode, &share, &attr ); hb_vmUnlock(); #if defined( HB_FS_SOPEN ) @@ -1428,6 +1583,12 @@ void hb_fsClose( HB_FHANDLE hFileHandle ) hb_vmUnlock(); #if defined( HB_OS_WIN ) hb_fsSetIOError( CloseHandle( DosToWinHandle( hFileHandle ) ) != 0, 0 ); +#elif defined( HB_OS_OS2 ) + { + APIRET ret = DosClose( hFileHandle ); + + hb_fsSetError( ( HB_ERRCODE ) ret ); + } #else { int ret; @@ -1636,7 +1797,27 @@ HB_BOOL hb_fsGetFileTime( const char * pszFileName, long * plJulian, long * plMi } } } -#elif defined( HB_OS_UNIX ) || defined( HB_OS_OS2 ) || defined( HB_OS_DOS ) || defined( __GNUC__ ) +#elif defined( HB_OS_OS2 ) + { + FILESTATUS3 fs3; + APIRET ret; + char * pszFree; + + ret = DosQueryPathInfo( ( PCSZ ) hb_fsNameConv( pszFileName, &pszFree ), + FIL_STANDARD, &fs3, sizeof( fs3 ) ); + if( ret == NO_ERROR ) + { + *plJulian = hb_dateEncode( fs3.fdateLastWrite.year + 1980, + fs3.fdateLastWrite.month, + fs3.fdateLastWrite.day ); + *plMillisec = hb_timeEncode( fs3.ftimeLastWrite.hours, + fs3.ftimeLastWrite.minutes, + fs3.ftimeLastWrite.twosecs * 2, 0 ); + } + if( pszFree ) + hb_xfree( pszFree ); + } +#elif defined( HB_OS_UNIX ) || defined( HB_OS_DOS ) || defined( __GNUC__ ) { char * pszFree; # if defined( HB_USE_LARGEFILE64 ) @@ -1685,15 +1866,15 @@ HB_BOOL hb_fsGetFileTime( const char * pszFileName, long * plJulian, long * plMi return fResult; } -HB_BOOL hb_fsGetAttr( const char * pszFileName, HB_FATTR * pulAttr ) +HB_BOOL hb_fsGetAttr( const char * pszFileName, HB_FATTR * pnAttr ) { HB_BOOL fResult; - HB_TRACE( HB_TR_DEBUG, ( "hb_fsGetAttr(%s, %p)", pszFileName, pulAttr ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_fsGetAttr(%s, %p)", pszFileName, pnAttr ) ); hb_vmUnlock(); - *pulAttr = 0; + *pnAttr = 0; fResult = HB_FALSE; #if defined( HB_OS_WIN ) { @@ -1707,7 +1888,7 @@ HB_BOOL hb_fsGetAttr( const char * pszFileName, HB_FATTR * pulAttr ) if( dwAttr != INVALID_FILE_ATTRIBUTES ) { - *pulAttr = hb_fsAttrFromRaw( dwAttr ); + *pnAttr = hb_fsAttrFromRaw( dwAttr ); fResult = HB_TRUE; } hb_fsSetIOError( fResult, 0 ); @@ -1730,7 +1911,7 @@ HB_BOOL hb_fsGetAttr( const char * pszFileName, HB_FATTR * pulAttr ) if( _dos_getfileattr( pszFileName, &attr ) == 0 ) # endif { - *pulAttr = hb_fsAttrFromRaw( attr ); + *pnAttr = hb_fsAttrFromRaw( attr ); fResult = HB_TRUE; } hb_fsSetIOError( fResult, 0 ); @@ -1738,15 +1919,15 @@ HB_BOOL hb_fsGetAttr( const char * pszFileName, HB_FATTR * pulAttr ) # elif defined( HB_OS_OS2 ) { FILESTATUS3 fs3; - APIRET ulrc; + APIRET ret; - ulrc = DosQueryPathInfo( ( PCSZ ) pszFileName, FIL_STANDARD, &fs3, sizeof( fs3 ) ); - if( ulrc == NO_ERROR ) + ret = DosQueryPathInfo( ( PCSZ ) pszFileName, FIL_STANDARD, &fs3, sizeof( fs3 ) ); + if( ret == NO_ERROR ) { - *pulAttr = hb_fsAttrFromRaw( fs3.attrFile ); + *pnAttr = hb_fsAttrFromRaw( fs3.attrFile ); fResult = HB_TRUE; } - hb_fsSetIOError( fResult, 0 ); + hb_fsSetError( ( HB_ERRCODE ) ret ); } # elif defined( HB_OS_UNIX ) { @@ -1758,7 +1939,7 @@ HB_BOOL hb_fsGetAttr( const char * pszFileName, HB_FATTR * pulAttr ) if( stat( pszFileName, &statbuf ) == 0 ) # endif { - *pulAttr = hb_fsAttrFromRaw( statbuf.st_mode ); + *pnAttr = hb_fsAttrFromRaw( statbuf.st_mode ); fResult = HB_TRUE; } hb_fsSetIOError( fResult, 0 ); @@ -1838,13 +2019,13 @@ HB_BOOL hb_fsSetFileTime( const char * pszFileName, long lJulian, long lMillisec #elif defined( HB_OS_OS2 ) { FILESTATUS3 fs3; - APIRET ulrc; + APIRET ret; char * pszFree; pszFileName = hb_fsNameConv( pszFileName, &pszFree ); - ulrc = DosQueryPathInfo( ( PCSZ ) pszFileName, FIL_STANDARD, &fs3, sizeof( fs3 ) ); - if( ulrc == NO_ERROR ) + ret = DosQueryPathInfo( ( PCSZ ) pszFileName, FIL_STANDARD, &fs3, sizeof( fs3 ) ); + if( ret == NO_ERROR ) { FDATE fdate; FTIME ftime; @@ -1878,11 +2059,11 @@ HB_BOOL hb_fsSetFileTime( const char * pszFileName, long lJulian, long lMillisec fs3.fdateCreation = fs3.fdateLastAccess = fs3.fdateLastWrite = fdate; fs3.ftimeCreation = fs3.ftimeLastAccess = fs3.ftimeLastWrite = ftime; - ulrc = DosSetPathInfo( ( PCSZ ) pszFileName, FIL_STANDARD, - &fs3, sizeof( fs3 ), DSPI_WRTTHRU ); + ret = DosSetPathInfo( ( PCSZ ) pszFileName, FIL_STANDARD, + &fs3, sizeof( fs3 ), DSPI_WRTTHRU ); } - fResult = ulrc == NO_ERROR; - hb_fsSetIOError( fResult, 0 ); + hb_fsSetError( ( HB_ERRCODE ) ret ); + fResult = ret == NO_ERROR; if( pszFree ) hb_xfree( pszFree ); } @@ -1965,11 +2146,11 @@ HB_BOOL hb_fsSetFileTime( const char * pszFileName, long lJulian, long lMillisec return fResult; } -HB_BOOL hb_fsSetAttr( const char * pszFileName, HB_FATTR ulAttr ) +HB_BOOL hb_fsSetAttr( const char * pszFileName, HB_FATTR nAttr ) { HB_BOOL fResult; - HB_TRACE( HB_TR_DEBUG, ( "hb_fsSetAttr(%s, %u)", pszFileName, ulAttr ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_fsSetAttr(%s, %u)", pszFileName, nAttr ) ); hb_vmUnlock(); @@ -1981,13 +2162,13 @@ HB_BOOL hb_fsSetAttr( const char * pszFileName, HB_FATTR ulAttr ) lpFileName = HB_FSNAMECONV( pszFileName, &lpFree ); - if( ulAttr & HB_FA_READONLY ) + if( nAttr & HB_FA_READONLY ) dwFlags |= FILE_ATTRIBUTE_READONLY; - if( ulAttr & HB_FA_HIDDEN ) + if( nAttr & HB_FA_HIDDEN ) dwFlags |= FILE_ATTRIBUTE_HIDDEN; - if( ulAttr & HB_FA_SYSTEM ) + if( nAttr & HB_FA_SYSTEM ) dwFlags |= FILE_ATTRIBUTE_SYSTEM; - if( ulAttr & HB_FA_ARCHIVE ) + if( nAttr & HB_FA_ARCHIVE ) dwFlags |= FILE_ATTRIBUTE_ARCHIVE; if( dwFlags == 0 ) dwFlags = FILE_ATTRIBUTE_NORMAL; @@ -2006,51 +2187,51 @@ HB_BOOL hb_fsSetAttr( const char * pszFileName, HB_FATTR ulAttr ) # if defined( HB_OS_OS2 ) { FILESTATUS3 fs3; - APIRET ulrc; + APIRET ret; ULONG ulOsAttr = FILE_NORMAL; - if( ulAttr & HB_FA_READONLY ) + if( nAttr & HB_FA_READONLY ) ulOsAttr |= FILE_READONLY; - if( ulAttr & HB_FA_HIDDEN ) + if( nAttr & HB_FA_HIDDEN ) ulOsAttr |= FILE_HIDDEN; - if( ulAttr & HB_FA_SYSTEM ) + if( nAttr & HB_FA_SYSTEM ) ulOsAttr |= FILE_SYSTEM; - if( ulAttr & HB_FA_ARCHIVE ) + if( nAttr & HB_FA_ARCHIVE ) ulOsAttr |= FILE_ARCHIVED; - ulrc = DosQueryPathInfo( ( PCSZ ) pszFileName, FIL_STANDARD, &fs3, sizeof( fs3 ) ); - if( ulrc == NO_ERROR ) + ret = DosQueryPathInfo( ( PCSZ ) pszFileName, FIL_STANDARD, &fs3, sizeof( fs3 ) ); + if( ret == NO_ERROR ) { fs3.attrFile = ulOsAttr; - ulrc = DosSetPathInfo( ( PCSZ ) pszFileName, FIL_STANDARD, - &fs3, sizeof( fs3 ), DSPI_WRTTHRU ); + ret = DosSetPathInfo( ( PCSZ ) pszFileName, FIL_STANDARD, + &fs3, sizeof( fs3 ), DSPI_WRTTHRU ); } - fResult = ulrc == NO_ERROR; - hb_fsSetIOError( fResult, 0 ); + hb_fsSetError( ( HB_ERRCODE ) ret ); + fResult = ret == NO_ERROR; } # elif defined( HB_OS_DOS ) - ulAttr &= ~( HB_FA_ARCHIVE | HB_FA_HIDDEN | HB_FA_READONLY | HB_FA_SYSTEM ); + nAttr &= ~( HB_FA_ARCHIVE | HB_FA_HIDDEN | HB_FA_READONLY | HB_FA_SYSTEM ); # if defined( __DJGPP__ ) || defined( __BORLANDC__ ) - fResult = _chmod( pszFileName, 1, ulAttr ) != -1; + fResult = _chmod( pszFileName, 1, nAttr ) != -1; # else - fResult = _dos_setfileattr( pszFileName, ulAttr ) != -1; + fResult = _dos_setfileattr( pszFileName, nAttr ) != -1; # endif hb_fsSetIOError( fResult, 0 ); # elif defined( HB_OS_UNIX ) { - int iAttr = HB_FA_POSIX_ATTR( ulAttr ), iResult; + int iAttr = HB_FA_POSIX_ATTR( nAttr ), iResult; if( iAttr == 0 ) { - iAttr = ( ulAttr & HB_FA_HIDDEN ) ? S_IRUSR : ( S_IRUSR | S_IRGRP | S_IROTH ); - if( ! ( ulAttr & HB_FA_READONLY ) ) + iAttr = ( nAttr & HB_FA_HIDDEN ) ? S_IRUSR : ( S_IRUSR | S_IRGRP | S_IROTH ); + if( ! ( nAttr & HB_FA_READONLY ) ) { if( iAttr & S_IRUSR ) iAttr |= S_IWUSR; if( iAttr & S_IRGRP ) iAttr |= S_IWGRP; if( iAttr & S_IROTH ) iAttr |= S_IWOTH; } - if( ulAttr & HB_FA_SYSTEM ) + if( nAttr & HB_FA_SYSTEM ) { if( iAttr & S_IRUSR ) iAttr |= S_IXUSR; if( iAttr & S_IRGRP ) iAttr |= S_IXGRP; @@ -2096,6 +2277,15 @@ HB_USHORT hb_fsRead( HB_FHANDLE hFileHandle, void * pBuff, HB_USHORT uiCount ) uiRead = bResult ? ( HB_USHORT ) dwRead : 0; } +#elif defined( HB_OS_OS2 ) + { + ULONG ulRead = 0; + APIRET ret; + + ret = DosRead( hFileHandle, pBuff, uiCount, &ulRead ); + hb_fsSetError( ( HB_ERRCODE ) ret ); + uiRead = ret == NO_ERROR ? ( HB_USHORT ) ulRead : 0; + } #else { long lRead; @@ -2111,7 +2301,7 @@ HB_USHORT hb_fsRead( HB_FHANDLE hFileHandle, void * pBuff, HB_USHORT uiCount ) HB_USHORT hb_fsWrite( HB_FHANDLE hFileHandle, const void * pBuff, HB_USHORT uiCount ) { - HB_USHORT uiWritten; + HB_USHORT uiWritten = 0; HB_TRACE( HB_TR_DEBUG, ( "hb_fsWrite(%p, %p, %hu)", ( void * ) ( HB_PTRDIFF ) hFileHandle, pBuff, uiCount ) ); @@ -2119,21 +2309,37 @@ HB_USHORT hb_fsWrite( HB_FHANDLE hFileHandle, const void * pBuff, HB_USHORT uiCo #if defined( HB_OS_WIN ) { - DWORD dwWritten = 0; BOOL bResult; if( uiCount ) { - bResult = WriteFile( DosToWinHandle( hFileHandle ), pBuff, uiCount, &dwWritten, NULL ); + DWORD dwWritten = 0; + bResult = WriteFile( DosToWinHandle( hFileHandle ), pBuff, uiCount, &dwWritten, NULL ); + uiWritten = bResult ? ( HB_USHORT ) dwWritten : 0; + } + else + bResult = SetEndOfFile( DosToWinHandle( hFileHandle ) ); + hb_fsSetIOError( bResult != 0, 0 ); + + } +#elif defined( HB_OS_OS2 ) + { + APIRET ret; + + if( uiCount ) + { + ULONG ulWritten = 0; + ret = DosWrite( hFileHandle, ( void * ) pBuff, uiCount, &ulWritten ); + uiWritten = ret == NO_ERROR ? ( HB_USHORT ) ulWritten : 0; } else { - dwWritten = 0; - bResult = SetEndOfFile( DosToWinHandle( hFileHandle ) ); + LONGLONG llPos; + ret = DosSetFilePtrL( hFileHandle, 0, SEEK_CUR, &llPos ); + if( ret == NO_ERROR ) + ret = DosSetFileSizeL( hFileHandle, llPos ); } - hb_fsSetIOError( bResult != 0, 0 ); - - uiWritten = bResult ? ( HB_USHORT ) dwWritten : 0; + hb_fsSetError( ( HB_ERRCODE ) ret ); } #else if( uiCount ) @@ -2150,7 +2356,6 @@ HB_USHORT hb_fsWrite( HB_FHANDLE hFileHandle, const void * pBuff, HB_USHORT uiCo # else HB_FAILURE_RETRY( iResult, ftruncate( hFileHandle, lseek( hFileHandle, 0L, SEEK_CUR ) ) ); # endif - uiWritten = 0; } #endif @@ -2211,6 +2416,15 @@ HB_SIZE hb_fsReadLarge( HB_FHANDLE hFileHandle, void * pBuff, HB_SIZE nCount ) # endif hb_fsSetIOError( bResult != 0, 0 ); } +#elif defined( HB_OS_OS2 ) + { + ULONG ulRead = 0; + APIRET ret; + + ret = DosRead( hFileHandle, pBuff, nCount, &ulRead ); + hb_fsSetError( ( HB_ERRCODE ) ret ); + nRead = ret == NO_ERROR ? ( HB_SIZE ) ulRead : 0; + } #elif defined( HB_FS_IO_16BIT ) { nRead = 0; @@ -2312,6 +2526,25 @@ HB_SIZE hb_fsWriteLarge( HB_FHANDLE hFileHandle, const void * pBuff, HB_SIZE nCo else hb_fsSetIOError( SetEndOfFile( DosToWinHandle( hFileHandle ) ) != 0, 0 ); +#elif defined( HB_OS_OS2 ) + { + APIRET ret; + + if( nCount ) + { + ULONG ulWritten = 0; + ret = DosWrite( hFileHandle, ( void * ) pBuff, nCount, &ulWritten ); + nWritten = ret == NO_ERROR ? ( HB_SIZE ) ulWritten : 0; + } + else + { + LONGLONG llPos; + ret = DosSetFilePtrL( hFileHandle, 0, SEEK_CUR, &llPos ); + if( ret == NO_ERROR ) + ret = DosSetFileSizeL( hFileHandle, llPos ); + } + hb_fsSetError( ( HB_ERRCODE ) ret ); + } #else if( nCount ) @@ -2386,10 +2619,8 @@ HB_SIZE hb_fsReadAt( HB_FHANDLE hFileHandle, void * pBuff, HB_SIZE nCount, HB_FO # endif nRead = lRead == -1 ? 0 : lRead; } -#else - nRead = 0; -# if defined( HB_OS_WIN ) -# if defined( HB_WIN_IOREAD_LIMIT ) +#elif defined( HB_OS_WIN ) +# if defined( HB_WIN_IOREAD_LIMIT ) { HANDLE hWFileHandle = DosToWinHandle( hFileHandle ); OVERLAPPED Overlapped; @@ -2399,6 +2630,7 @@ HB_SIZE hb_fsReadAt( HB_FHANDLE hFileHandle, void * pBuff, HB_SIZE nCount, HB_FO Overlapped.Offset = ( DWORD ) ( nOffset & 0xFFFFFFFF ); Overlapped.OffsetHigh = ( DWORD ) ( nOffset >> 32 ); + nRead = 0; while( nCount ) { DWORD dwToRead; @@ -2428,7 +2660,7 @@ HB_SIZE hb_fsReadAt( HB_FHANDLE hFileHandle, void * pBuff, HB_SIZE nCount, HB_FO } hb_fsSetIOError( bResult != 0, 0 ); } -# else +# else if( hb_iswinnt() ) { DWORD dwRead = 0; @@ -2450,7 +2682,10 @@ HB_SIZE hb_fsReadAt( HB_FHANDLE hFileHandle, void * pBuff, HB_SIZE nCount, HB_FO SEEK_SET ); nPos = ( ( HB_FOFFSET ) ulOffsetHigh << 32 ) | ulOffsetLow; if( nPos == ( HB_FOFFSET ) INVALID_SET_FILE_POINTER ) + { hb_fsSetIOError( HB_FALSE, 0 ); + nRead = 0; + } else { DWORD dwRead = 0; @@ -2459,31 +2694,40 @@ HB_SIZE hb_fsReadAt( HB_FHANDLE hFileHandle, void * pBuff, HB_SIZE nCount, HB_FO nRead = dwRead; } } -# endif +# endif /* HB_WIN_IOREAD_LIMIT */ - /* TOFIX: this is not atom operation. It has to be fixed for RDD - * file access with shared file handles in aliased work areas - */ +/* TOFIX: below are not atom operations. It has to be fixed for RDD + * file access with shared file handles in aliased work areas + */ +#elif defined( HB_OS_OS2 ) + { + ULONG ulRead = 0; + LONGLONG llPos; + APIRET ret; -# elif defined( HB_FS_IO_16BIT ) + ret = DosSetFilePtrL( hFileHandle, nOffset, SEEK_SET, &llPos ); + if( ret == NO_ERROR ) + ret = DosRead( hFileHandle, pBuff, nCount, &ulRead ); + hb_fsSetError( ( HB_ERRCODE ) ret ); + nRead = ret == NO_ERROR ? ulRead : 0; + } +#elif defined( HB_FS_IO_16BIT ) if( hb_fsSeekLarge( hFileHandle, nOffset, FS_SET ) == nOffset ) nRead = hb_fsReadLarge( hFileHandle, pBuff, nCount ); -# else + else + nRead = 0; +#else { - HB_FOFFSET nPos; -# if defined( HB_USE_LARGEFILE64 ) - nPos = lseek64( hFileHandle, nOffset, SEEK_SET ); -# elif defined( HB_OS_OS2 ) - ULONG ulPos; - if( DosSetFilePtr( hFileHandle, nOffset, SEEK_SET, &ulPos ) == 0 ) - nPos = ( HB_FOFFSET ) ulPos; - else - nPos = ( HB_FOFFSET ) -1; -# else - nPos = lseek( hFileHandle, nOffset, SEEK_SET ); -# endif +# if defined( HB_USE_LARGEFILE64 ) + HB_FOFFSET nPos = lseek64( hFileHandle, nOffset, SEEK_SET ); +# else + HB_FOFFSET nPos = lseek( hFileHandle, nOffset, SEEK_SET ); +# endif if( nPos == ( HB_FOFFSET ) -1 ) + { hb_fsSetIOError( HB_FALSE, 0 ); + nRead = 0; + } else { long lRead; @@ -2491,7 +2735,6 @@ HB_SIZE hb_fsReadAt( HB_FHANDLE hFileHandle, void * pBuff, HB_SIZE nCount, HB_FO nRead = lRead == -1 ? 0 : lRead; } } -# endif #endif hb_vmLock(); @@ -2517,10 +2760,8 @@ HB_SIZE hb_fsWriteAt( HB_FHANDLE hFileHandle, const void * pBuff, HB_SIZE nCount # endif nWritten = lWritten == -1 ? 0 : lWritten; } -#else - nWritten = 0; -# if defined( HB_OS_WIN ) -# if defined( HB_WIN_IOWRITE_LIMIT ) +#elif defined( HB_OS_WIN ) +# if defined( HB_WIN_IOWRITE_LIMIT ) { HANDLE hWFileHandle = DosToWinHandle( hFileHandle ); OVERLAPPED Overlapped; @@ -2530,6 +2771,7 @@ HB_SIZE hb_fsWriteAt( HB_FHANDLE hFileHandle, const void * pBuff, HB_SIZE nCount Overlapped.Offset = ( DWORD ) ( nOffset & 0xFFFFFFFF ); Overlapped.OffsetHigh = ( DWORD ) ( nOffset >> 32 ); + nWritten = 0; while( nCount ) { DWORD dwToWrite; @@ -2559,7 +2801,7 @@ HB_SIZE hb_fsWriteAt( HB_FHANDLE hFileHandle, const void * pBuff, HB_SIZE nCount } hb_fsSetIOError( bResult != 0, 0 ); } -# else +# else if( hb_iswinnt() ) { DWORD dwWritten = 0; @@ -2581,7 +2823,10 @@ HB_SIZE hb_fsWriteAt( HB_FHANDLE hFileHandle, const void * pBuff, HB_SIZE nCount SEEK_SET ); nPos = ( ( HB_FOFFSET ) ulOffsetHigh << 32 ) | ulOffsetLow; if( nPos == ( HB_FOFFSET ) INVALID_SET_FILE_POINTER ) + { hb_fsSetIOError( HB_FALSE, 0 ); + nWritten = 0; + } else { DWORD dwWritten = 0; @@ -2590,31 +2835,40 @@ HB_SIZE hb_fsWriteAt( HB_FHANDLE hFileHandle, const void * pBuff, HB_SIZE nCount nWritten = dwWritten; } } -# endif +# endif /* HB_WIN_IOWRITE_LIMIT */ - /* TOFIX: this is not atom operation. It has to be fixed for RDD - * file access with shared file handles in aliased work areas - */ +/* TOFIX: below are not atom operations. It has to be fixed for RDD + * file access with shared file handles in aliased work areas + */ +#elif defined( HB_OS_OS2 ) + { + ULONG ulWritten = 0; + LONGLONG llPos; + APIRET ret; -# elif defined( HB_FS_IO_16BIT ) + ret = DosSetFilePtrL( hFileHandle, nOffset, SEEK_SET, &llPos ); + if( ret == NO_ERROR ) + ret = DosWrite( hFileHandle, ( void * ) pBuff, nCount, &ulWritten ); + hb_fsSetError( ( HB_ERRCODE ) ret ); + nWritten = ret == NO_ERROR ? ulWritten : 0; + } +#elif defined( HB_FS_IO_16BIT ) if( hb_fsSeekLarge( hFileHandle, nOffset, FS_SET ) == nOffset ) nWritten = hb_fsWriteLarge( hFileHandle, pBuff, nCount ); -# else + else + nWritten = 0; +#else { - HB_FOFFSET nPos; -# if defined( HB_USE_LARGEFILE64 ) - nPos = lseek64( hFileHandle, nOffset, SEEK_SET ); -# elif defined( HB_OS_OS2 ) - ULONG ulPos; - if( DosSetFilePtr( hFileHandle, nOffset, SEEK_SET, &ulPos ) == 0 ) - nPos = ( HB_FOFFSET ) ulPos; - else - nPos = ( HB_FOFFSET ) -1; -# else - nPos = lseek( hFileHandle, nOffset, SEEK_SET ); -# endif +# if defined( HB_USE_LARGEFILE64 ) + HB_FOFFSET nPos = lseek64( hFileHandle, nOffset, SEEK_SET ); +# else + HB_FOFFSET nPos = lseek( hFileHandle, nOffset, SEEK_SET ); +# endif if( nPos == ( HB_FOFFSET ) -1 ) + { hb_fsSetIOError( HB_FALSE, 0 ); + nWritten = 0; + } else { long lWritten; @@ -2622,7 +2876,6 @@ HB_SIZE hb_fsWriteAt( HB_FHANDLE hFileHandle, const void * pBuff, HB_SIZE nCount nWritten = lWritten == -1 ? 0 : lWritten; } } -# endif #endif hb_vmLock(); @@ -2658,6 +2911,14 @@ HB_BOOL hb_fsTruncAt( HB_FHANDLE hFileHandle, HB_FOFFSET nOffset ) hb_fsSetIOError( fResult, 0 ); } +#elif defined( HB_OS_OS2 ) + { + APIRET ret; + + ret = DosSetFileSizeL( hFileHandle, nOffset ); + hb_fsSetError( ( HB_ERRCODE ) ret ); + fResult = ret == NO_ERROR; + } #else { int iResult; @@ -2687,7 +2948,7 @@ void hb_fsCommit( HB_FHANDLE hFileHandle ) #elif defined( HB_OS_OS2 ) - hb_fsSetIOError( DosResetBuffer( hFileHandle ) == 0, 0 ); + hb_fsSetError( ( HB_ERRCODE ) DosResetBuffer( hFileHandle ) ); #elif defined( HB_OS_UNIX ) { @@ -2798,6 +3059,7 @@ HB_BOOL hb_fsLock( HB_FHANDLE hFileHandle, HB_ULONG ulStart, #elif defined( HB_OS_OS2 ) { struct _FILELOCK fl, ful; + APIRET ret; switch( uiMode & FL_MASK ) { @@ -2809,7 +3071,7 @@ HB_BOOL hb_fsLock( HB_FHANDLE hFileHandle, HB_ULONG ulStart, ful.lRange = 0; /* lock region, 2 seconds timeout, exclusive access - no atomic */ - fResult = ( DosSetFileLocks( hFileHandle, &ful, &fl, 2000L, 0L ) == 0 ); + ret = DosSetFileLocks( hFileHandle, &ful, &fl, 2000L, 0L ); break; case FL_UNLOCK: @@ -2820,13 +3082,14 @@ HB_BOOL hb_fsLock( HB_FHANDLE hFileHandle, HB_ULONG ulStart, ful.lRange = ulLength; /* unlock region, 2 seconds timeout, exclusive access - no atomic */ - fResult = ( DosSetFileLocks( hFileHandle, &ful, &fl, 2000L, 0L ) == 0 ); + ret = DosSetFileLocks( hFileHandle, &ful, &fl, 2000L, 0L ); break; default: - fResult = HB_FALSE; + ret = ERROR_INVALID_DATA; } - hb_fsSetIOError( fResult, 0 ); + hb_fsSetError( ( HB_ERRCODE ) ret ); + fResult = ret == NO_ERROR; } #elif defined( _MSC_VER ) || defined( __DMC__ ) { @@ -3004,6 +3267,41 @@ HB_BOOL hb_fsLockLarge( HB_FHANDLE hFileHandle, HB_FOFFSET nStart, hb_fsSetIOError( fResult, 0 ); hb_vmLock(); } +#elif defined( HB_OS_OS2 ) + { + struct _FILELOCKL fl, ful; + APIRET ret; + + switch( uiMode & FL_MASK ) + { + case FL_LOCK: + + fl.lOffset = nStart; + fl.lRange = nLength; + ful.lOffset = 0; + ful.lRange = 0; + + /* lock region, 2 seconds timeout, exclusive access - no atomic */ + ret = DosSetFileLocksL( hFileHandle, &ful, &fl, 2000L, 0L ); + break; + + case FL_UNLOCK: + + fl.lOffset = 0; + fl.lRange = 0; + ful.lOffset = nStart; + ful.lRange = nLength; + + /* unlock region, 2 seconds timeout, exclusive access - no atomic */ + ret = DosSetFileLocksL( hFileHandle, &ful, &fl, 2000L, 0L ); + break; + + default: + ret = ERROR_INVALID_DATA; + } + hb_fsSetError( ( HB_ERRCODE ) ret ); + fResult = ret == NO_ERROR; + } #elif defined( HB_USE_LARGEFILE64 ) { struct flock64 lock_info; @@ -3107,33 +3405,7 @@ HB_ULONG hb_fsSeek( HB_FHANDLE hFileHandle, HB_LONG lOffset, HB_USHORT uiFlags ) nFlags = convert_seek_flags( uiFlags ); hb_vmUnlock(); -#if defined( HB_OS_OS2 ) - { - APIRET ret; - - /* This DOS hack creates 2GB file size limit, Druzus */ - if( lOffset < 0 && nFlags == SEEK_SET ) - { - ret = 1; - hb_fsSetError( 25 ); /* 'Seek Error' */ - } - else - { - ret = DosSetFilePtr( hFileHandle, lOffset, nFlags, &ulPos ); - /* TODO: what we should do with this error code? Is it DOS compatible? */ - hb_fsSetError( ( HB_ERRCODE ) ret ); - } - - if( ret != 0 ) - { - /* FIXME: it should work if DosSetFilePtr is lseek compatible - but maybe OS2 has DosGetFilePtr too, if not then remove this - comment, Druzus */ - if( DosSetFilePtr( hFileHandle, 0, SEEK_CUR, &ulPos ) != 0 ) - ulPos = 0; - } - } -#elif defined( HB_OS_WIN ) +#if defined( HB_OS_WIN ) /* This DOS hack creates 2GB file size limit, Druzus */ if( lOffset < 0 && nFlags == SEEK_SET ) { @@ -3152,7 +3424,23 @@ HB_ULONG hb_fsSeek( HB_FHANDLE hFileHandle, HB_LONG lOffset, HB_USHORT uiFlags ) if( ulPos == ( ULONG ) INVALID_SET_FILE_POINTER ) ulPos = 0; } +#elif defined( HB_OS_OS2 ) + { + APIRET ret; + /* This DOS hack creates 2GB file size limit, Druzus */ + if( lOffset < 0 && nFlags == SEEK_SET ) + ret = 25; /* 'Seek Error' */ + else + ret = DosSetFilePtr( hFileHandle, lOffset, nFlags, &ulPos ); + hb_fsSetError( ( HB_ERRCODE ) ret ); + + if( ret != NO_ERROR ) + { + if( DosSetFilePtr( hFileHandle, 0, SEEK_CUR, &ulPos ) != NO_ERROR ) + ulPos = 0; + } + } #else /* This DOS hack creates 2GB file size limit, Druzus */ if( lOffset < 0 && nFlags == SEEK_SET ) @@ -3228,6 +3516,27 @@ HB_FOFFSET hb_fsSeekLarge( HB_FHANDLE hFileHandle, HB_FOFFSET nOffset, HB_USHORT } hb_vmLock(); } +#elif defined( HB_OS_OS2 ) + { + HB_USHORT nFlags = convert_seek_flags( uiFlags ); + LONGLONG llPos = 0; + APIRET ret; + + hb_vmUnlock(); + if( nOffset < 0 && nFlags == SEEK_SET ) + ret = 25; /* 'Seek Error' */ + else + ret = DosSetFilePtrL( hFileHandle, nOffset, nFlags, &llPos ); + hb_fsSetError( ( HB_ERRCODE ) ret ); + + if( ret != NO_ERROR ) + { + if( DosSetFilePtrL( hFileHandle, 0, SEEK_CUR, &llPos ) != NO_ERROR ) + llPos = 0; + } + nPos = ( HB_FOFFSET ) llPos; + hb_vmLock(); + } #elif defined( HB_USE_LARGEFILE64 ) { HB_USHORT nFlags = convert_seek_flags( uiFlags ); @@ -3299,6 +3608,24 @@ HB_BOOL hb_fsDelete( const char * pszFileName ) if( lpFree ) hb_xfree( lpFree ); } +#elif defined( HB_OS_OS2 ) + { + char * pszFree; + APIRET ret; + + pszFileName = hb_fsNameConv( pszFileName, &pszFree ); + + hb_vmUnlock(); + + ret = DosDelete( ( PCSZ ) pszFileName ); + fResult = ret == NO_ERROR; + hb_fsSetError( ( HB_ERRCODE ) ret ); + + hb_vmLock(); + + if( pszFree ) + hb_xfree( pszFree ); + } #else { char * pszFree; @@ -3346,6 +3673,28 @@ HB_BOOL hb_fsRename( const char * pOldName, const char * pNewName ) if( lpNewFree ) hb_xfree( lpNewFree ); } +#elif defined( HB_OS_OS2 ) + { + char * pszFreeOld, * pszFreeNew; + APIRET ret; + + + pOldName = hb_fsNameConv( pOldName, &pszFreeOld ); + pNewName = hb_fsNameConv( pNewName, &pszFreeNew ); + + hb_vmUnlock(); + + ret = DosMove( ( PCSZ ) pOldName, ( PCSZ ) pNewName ); + fResult = ret == NO_ERROR; + hb_fsSetError( ( HB_ERRCODE ) ret ); + + hb_vmLock(); + + if( pszFreeOld ) + hb_xfree( pszFreeOld ); + if( pszFreeNew ) + hb_xfree( pszFreeNew ); + } #else { char * pszFreeOld, * pszFreeNew; @@ -3393,6 +3742,24 @@ HB_BOOL hb_fsMkDir( const char * pszDirName ) if( lpFree ) hb_xfree( lpFree ); } +#elif defined( HB_OS_OS2 ) + { + char * pszFree; + APIRET ret; + + pszDirName = hb_fsNameConv( pszDirName, &pszFree ); + + hb_vmUnlock(); + + ret = DosCreateDir( ( PCSZ ) pszDirName, NULL ); + fResult = ret == NO_ERROR; + hb_fsSetError( ( HB_ERRCODE ) ret ); + + hb_vmLock(); + + if( pszFree ) + hb_xfree( pszFree ); + } #else { char * pszFree; @@ -3446,6 +3813,24 @@ HB_BOOL hb_fsChDir( const char * pszDirName ) if( lpFree ) hb_xfree( lpFree ); } +#elif defined( HB_OS_OS2 ) + { + char * pszFree; + APIRET ret; + + pszDirName = hb_fsNameConv( pszDirName, &pszFree ); + + hb_vmUnlock(); + + ret = DosSetCurrentDir( ( PCSZ ) pszDirName ); + fResult = ret == NO_ERROR; + hb_fsSetError( ( HB_ERRCODE ) ret ); + + hb_vmLock(); + + if( pszFree ) + hb_xfree( pszFree ); + } #else { char * pszFree; @@ -3490,6 +3875,24 @@ HB_BOOL hb_fsRmDir( const char * pszDirName ) if( lpFree ) hb_xfree( lpFree ); } +#elif defined( HB_OS_OS2 ) + { + char * pszFree; + APIRET ret; + + pszDirName = hb_fsNameConv( pszDirName, &pszFree ); + + hb_vmUnlock(); + + ret = DosDeleteDir( ( PCSZ ) pszDirName ); + fResult = ret == NO_ERROR; + hb_fsSetError( ( HB_ERRCODE ) ret ); + + hb_vmLock(); + + if( pszFree ) + hb_xfree( pszFree ); + } #else { char * pszFree; @@ -3569,9 +3972,7 @@ HB_ERRCODE hb_fsCurDirBuff( int iDrive, char * pszBuffer, HB_SIZE nSize ) if( iDrive >= 0 ) { ULONG ulLen = ( ULONG ) nSize; - - hb_fsSetIOError( DosQueryCurrentDir( iDrive, ( PBYTE ) pszBuffer, - &ulLen ) == NO_ERROR, 0 ); + hb_fsSetError( ( HB_ERRCODE ) DosQueryCurrentDir( iDrive, ( PBYTE ) pszBuffer, &ulLen ) ); } else hb_fsSetError( ( HB_ERRCODE ) FS_ERROR ); @@ -3689,14 +4090,22 @@ HB_BOOL hb_fsGetCWD( char * pszBuffer, HB_SIZE nSize ) } #elif defined( HB_OS_OS2 ) { - ULONG ulLen = ( ULONG ) nSize - 3, ulDrive, ulLogical; + ULONG ulDrive = 0, ulLogical; + APIRET ret; - DosQueryCurrentDisk( &ulDrive, &ulLogical ); - pszBuffer[ 0 ] = ( char ) ( ulDrive + ( 'A' - 1 ) ); - pszBuffer[ 1 ] = HB_OS_DRIVE_DELIM_CHR; - pszBuffer[ 2 ] = HB_OS_PATH_DELIM_CHR; - fResult = DosQueryCurrentDir( 0, ( PBYTE ) pszBuffer + 3, &ulLen ) == NO_ERROR; - hb_fsSetIOError( fResult, 0 ); + ret = DosQueryCurrentDisk( &ulDrive, &ulLogical ); + if( ret == NO_ERROR ) + { + ULONG ulLen = ( ULONG ) nSize - 3; + pszBuffer[ 0 ] = ( char ) ( ulDrive + ( 'A' - 1 ) ); + pszBuffer[ 1 ] = HB_OS_DRIVE_DELIM_CHR; + pszBuffer[ 2 ] = HB_OS_PATH_DELIM_CHR; + ret = DosQueryCurrentDir( 0, ( PBYTE ) pszBuffer + 3, &ulLen ); + } + hb_fsSetError( ( HB_ERRCODE ) ret ); + fResult = ret == NO_ERROR; + if( ! fResult ) + pszBuffer[ 0 ] = '\0'; } #else @@ -3712,7 +4121,7 @@ HB_BOOL hb_fsGetCWD( char * pszBuffer, HB_SIZE nSize ) if( fResult && pszBuffer[ 0 ] ) { HB_SIZE nLen; -#if defined( __DJGPP__ ) || defined( HB_OS_OS2 ) +#if defined( __DJGPP__ ) /* convert '/' to '\' */ nLen = 0; while( pszBuffer[ nLen ] != 0 ) @@ -3779,6 +4188,39 @@ HB_BOOL hb_fsSetCWD( const char * pszDirName ) if( lpFree ) hb_xfree( lpFree ); } +#elif defined( HB_OS_OS2 ) + { + char * pszFree; + APIRET ret; + + pszDirName = hb_fsNameConv( pszDirName, &pszFree ); + + hb_vmUnlock(); + + ret = DosSetCurrentDir( ( PCSZ ) pszDirName ); + if( ret == NO_ERROR && pszDirName[ 0 ] != 0 && + pszDirName[ 1 ] == HB_OS_DRIVE_DELIM_CHR ) + { + int iDrive = pszDirName[ 0 ]; + + if( iDrive >= 'A' && iDrive <= 'Z' ) + iDrive -= 'A'; + else if( iDrive >= 'a' && iDrive <= 'z' ) + iDrive -= 'a'; + else + iDrive = 0; + + if( iDrive ) + ret = DosSetDefaultDisk( iDrive ); + } + fResult = ret == NO_ERROR; + hb_fsSetError( ( HB_ERRCODE ) ret ); + + hb_vmLock(); + + if( pszFree ) + hb_xfree( pszFree ); + } #else { char * pszFree; @@ -3905,9 +4347,13 @@ HB_ERRCODE hb_fsIsDrv( int iDrive ) #elif defined( HB_OS_OS2 ) { ULONG ulDrive, ulLogical; + APIRET ret; - DosQueryCurrentDisk( &ulDrive, &ulLogical ); - nResult = ( ( ulLogical >> iDrive ) & 1 ) ? 0 : ( HB_ERRCODE ) F_ERROR; + hb_vmUnlock(); + ret = DosQueryCurrentDisk( &ulDrive, &ulLogical ); + hb_vmLock(); + nResult = ret == NO_ERROR && ( ( ulLogical >> iDrive ) & 1 ) ? 0 : ( HB_ERRCODE ) F_ERROR; + hb_fsSetError( 0 ); } #elif defined( HB_OS_HAS_DRIVE_LETTER ) { @@ -3953,13 +4399,20 @@ HB_BOOL hb_fsIsDevice( HB_FHANDLE hFileHandle ) fResult = GetFileType( DosToWinHandle( hFileHandle ) ) == FILE_TYPE_CHAR; hb_fsSetIOError( fResult, 0 ); +#elif defined( HB_OS_OS2 ) +{ + ULONG type = 0, attr = 0; + APIRET ret = DosQueryHType( ( HFILE ) hFileHandle, &type, &attr ); + hb_fsSetError( ( HB_ERRCODE ) ret ); + fResult = ret == NO_ERROR && ( type & 0xFF ) == FHT_CHRDEV; +} #else -#if defined( _MSC_VER ) || defined( __MINGW32__ ) - fResult = _isatty( hFileHandle ) != 0; -#else - fResult = isatty( hFileHandle ) != 0; -#endif +# if defined( _MSC_VER ) || defined( __MINGW32__ ) + fResult = _isatty( hFileHandle ) != 0; +# else + fResult = isatty( hFileHandle ) != 0; +# endif hb_fsSetIOError( fResult, 0 ); #endif