fivedev/harbour-core
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

2008-07-09 18:24 UTC+0200 Przemyslaw Czerpak (druzus/at/priv.onet.pl)

Browse Source 
* harbour/include/hbwince.h
  * harbour/source/common/hbwince.c
    + added SetFileAttributesA() for WinCE builds

  * harbour/source/rtl/filesys.c
    * replaced UNICODE translations for SetFileAttributes()
      with direct call to SetFileAttributesA()

  * harbour/include/hbapifs.h
  * harbour/source/rtl/spfiles.c
  * harbour/source/rtl/fstemp.c
  * harbour/source/rtl/hbffind.c
  * harbour/source/rtl/direct.c
  * harbour/source/rtl/filesys.c
    * changed internal representation for file attributes from USHORT
      to ULONG
    + added support for POSIX permission attributes in .c code
    ; added some comments about used attribute translations which
      should be cleand
This commit is contained in:
Przemyslaw Czerpak
2008-07-09 16:25:00 +00:00
parent 218d714555
commit d5ecd90c31
9 changed files with 227 additions and 179 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
harbour/ChangeLog
View File

@@ -8,6 +8,27 @@
2008-12-31 13:59 UTC+0100 Foo Bar <foo.bar@foobar.org>
*/
2008-07-09 18:24 UTC+0200 Przemyslaw Czerpak (druzus/at/priv.onet.pl)
* harbour/include/hbwince.h
* harbour/source/common/hbwince.c
+ added SetFileAttributesA() for WinCE builds
* harbour/source/rtl/filesys.c
* replaced UNICODE translations for SetFileAttributes()
with direct call to SetFileAttributesA()
* harbour/include/hbapifs.h
* harbour/source/rtl/spfiles.c
* harbour/source/rtl/fstemp.c
* harbour/source/rtl/hbffind.c
* harbour/source/rtl/direct.c
* harbour/source/rtl/filesys.c
* changed internal representation for file attributes from USHORT
to ULONG
+ added support for POSIX permission attributes in .c code
; added some comments about used attribute translations which
should be cleand
2008-07-09 13:57 UTC+0200 Przemyslaw Czerpak (druzus/at/priv.onet.pl)
* harbour/contrib/hbmzip/hbmzip.c
! added missing DJGPP header files

67
harbour/include/hbapifs.h
View File

@@ -88,24 +88,35 @@ HB_EXTERN_BEGIN
/* File attributes flags */
#define HB_FA_ALL 0x00000000
#define HB_FA_READONLY 0x00000001
#define HB_FA_HIDDEN 0x00000002
#define HB_FA_SYSTEM 0x00000004
#define HB_FA_LABEL 0x00000008
#define HB_FA_DIRECTORY 0x00000010
#define HB_FA_ARCHIVE 0x00000020
#define HB_FA_DEVICE 0x00000040
#define HB_FA_NORMAL 0x00000080
#define HB_FA_READONLY 0x00000001 /* R */
#define HB_FA_HIDDEN 0x00000002 /* H */
#define HB_FA_SYSTEM 0x00000004 /* S */
#define HB_FA_LABEL 0x00000008 /* V */
#define HB_FA_DIRECTORY 0x00000010 /* D | S_ISDIR() */
#define HB_FA_ARCHIVE 0x00000020 /* A | S_ISREG() */
#define HB_FA_DEVICE 0x00000040 /* I | S_ISBLK() */
#define HB_FA_NORMAL 0x00000080 /* */
#define HB_FA_TEMPORARY 0x00000100
#define HB_FA_SPARSE 0x00000200
#define HB_FA_REPARSE 0x00000400
#define HB_FA_COMPRESSED 0x00000800
#define HB_FA_OFFLINE 0x00001000
#define HB_FA_NOTINDEXED 0x00002000
#define HB_FA_ENCRYPTED 0x00004000
#define HB_FA_VOLCOMP 0x00008000 /* volume supports compression. */
#define HB_FA_TEMPORARY 0x00000100 /* T | S_ISFIFO()??? */
#define HB_FA_SPARSE 0x00000200 /* P | S_ISSOCK()??? */
#define HB_FA_REPARSE 0x00000400 /* L | S_ISLNK() */
#define HB_FA_COMPRESSED 0x00000800 /* C | S_ISCHR()??? */
#define HB_FA_OFFLINE 0x00001000 /* O */
#define HB_FA_NOTINDEXED 0x00002000 /* X */
#define HB_FA_ENCRYPTED 0x00004000 /* E */
#define HB_FA_VOLCOMP 0x00008000 /* M volume supports compression. */
/* these definitions should be cleared,
* now they only help to clean lower level code
*/
#define HB_FA_FIFO HB_FA_TEMPORARY /* S_ISFIFO() */
#define HB_FA_FILE HB_FA_ARCHIVE /* S_ISREG() */
#define HB_FA_BLKDEVICE HB_FA_DEVICE /* S_ISBLK() */
#define HB_FA_CHRDEVICE HB_FA_COMPRESSED /* S_ISCHR() */
#define HB_FA_SOCKET HB_FA_SPARSE /* S_ISSOCK() */
#define HB_FA_LINK HB_FA_REPARSE /* S_ISLNK() */
/* POSIX file permission */
#define HB_FA_SUID 0x08000000 /* set user ID on execution */
#define HB_FA_SGID 0x04000000 /* set group ID on execution */
#define HB_FA_SVTX 0x02000000 /* sticky bit */
@@ -140,9 +151,9 @@ extern HB_EXPORT BOOL hb_fsChDir ( BYTE * pszDirName ); /* change worki
extern HB_EXPORT USHORT hb_fsChDrv ( BYTE nDrive ); /* change working drive */
extern HB_EXPORT void hb_fsClose ( FHANDLE hFileHandle ); /* close a file */
extern HB_EXPORT void hb_fsCommit ( FHANDLE hFileHandle ); /* commit updates of a file */
extern HB_EXPORT FHANDLE hb_fsCreate ( BYTE * pszFileName, USHORT uiAttr ); /* create a file */
extern HB_EXPORT FHANDLE hb_fsCreateEx ( BYTE * pszFilename, USHORT uiAttr, USHORT uiFlags ); /* create a file, with specific open mode */
extern HB_EXPORT FHANDLE hb_fsCreateTemp ( const BYTE * pszDir, const BYTE * pszPrefix, USHORT uiAttr, BYTE * pszName ); /* create a temporary file from components */
extern HB_EXPORT FHANDLE hb_fsCreate ( BYTE * pszFileName, ULONG ulAttr ); /* create a file */
extern HB_EXPORT FHANDLE hb_fsCreateEx ( BYTE * pszFilename, ULONG ulAttr, USHORT uiFlags ); /* create a file, with specific open mode */
extern HB_EXPORT FHANDLE hb_fsCreateTemp ( const BYTE * pszDir, const BYTE * pszPrefix, ULONG ulAttr, BYTE * pszName ); /* create a temporary file from components */
extern HB_EXPORT BYTE * hb_fsCurDir ( USHORT uiDrive ); /* retrieve a static pointer containing current directory for specified drive */
extern HB_EXPORT USHORT hb_fsCurDirBuff ( USHORT uiDrive, BYTE * pbyBuffer, ULONG ulLen ); /* copy current directory for given drive into a buffer */
extern HB_EXPORT BYTE hb_fsCurDrv ( void ); /* retrieve current drive number */
@@ -234,8 +245,8 @@ extern HB_EXPORT void hb_fsFreeSearchPath( HB_PATHNAMES * pSearchList );
extern HB_EXPORT BOOL hb_spFile( BYTE * pFilename, BYTE * pRetPath );
extern HB_EXPORT FHANDLE hb_spOpen( BYTE * pFilename, USHORT uiFlags );
extern HB_EXPORT FHANDLE hb_spCreate( BYTE * pFilename, USHORT uiAttr );
extern HB_EXPORT FHANDLE hb_spCreateEx( BYTE * pFilename, USHORT uiAttr, USHORT uiFlags );
extern HB_EXPORT FHANDLE hb_spCreate( BYTE * pFilename, ULONG ulAttr );
extern HB_EXPORT FHANDLE hb_spCreateEx( BYTE * pFilename, ULONG ulAttr, USHORT uiFlags );
/* File Find API structure */
typedef struct
@@ -244,13 +255,13 @@ typedef struct
LONG lDate;
char szDate[ 9 ]; /* in YYYYMMDD format */
char szTime[ 9 ]; /* in HH:MM:SS format */
USHORT attr;
ULONG attr;
HB_FOFFSET size;
/* Private */
const char * pszFileMask;
USHORT attrmask;
ULONG attrmask;
BOOL bFirst;
void * info; /* Pointer to the platform specific find info */
@@ -258,15 +269,15 @@ typedef struct
} HB_FFIND, * PHB_FFIND;
/* File Find API functions */
extern HB_EXPORT PHB_FFIND hb_fsFindFirst( const char * pszFileName, USHORT uiAttr );
extern HB_EXPORT PHB_FFIND hb_fsFindFirst( const char * pszFileName, ULONG ulAttrMask );
extern HB_EXPORT BOOL hb_fsFindNext( PHB_FFIND ffind );
extern HB_EXPORT void hb_fsFindClose( PHB_FFIND ffind );
/* Misc helper functions */
extern USHORT hb_fsAttrFromRaw( ULONG raw_attr );
extern ULONG hb_fsAttrToRaw( USHORT uiAttr );
extern USHORT hb_fsAttrEncode( const char * szAttr );
extern char * hb_fsAttrDecode( USHORT uiAttr, char * szAttr );
extern ULONG hb_fsAttrFromRaw( ULONG raw_attr );
extern ULONG hb_fsAttrToRaw( ULONG ulAttr );
extern ULONG hb_fsAttrEncode( const char * szAttr );
extern char * hb_fsAttrDecode( ULONG ulAttr, char * szAttr );
extern HB_EXPORT BYTE * hb_fsNameConv( BYTE * szFileName, BOOL * pfFree );
extern HB_EXPORT BYTE * hb_fileNameConv( char *str );
extern HB_EXPORT BOOL hb_fsMaxFilesError( void );

1
harbour/include/hbwince.h
View File

@@ -124,6 +124,7 @@ extern char *strerror( int errnum );
BOOL WINAPI DeleteFileA( LPCSTR path );
BOOL WINAPI RemoveDirectoryA( LPCSTR path );
BOOL WINAPI CreateDirectoryA( LPCSTR path, LPSECURITY_ATTRIBUTES attr );
BOOL WINAPI SetFileAttributesA( LPCSTR filename, DWORD attr );
BOOL WINAPI CharToOemBuffA( LPCSTR src, LPSTR dst, DWORD len );
BOOL WINAPI OemToCharBuffA( LPCSTR src, LPSTR dst, DWORD len );
HANDLE WINAPI FindFirstFileA( LPCSTR path, WIN32_FIND_DATAA * data );

12
harbour/source/common/hbwince.c
View File

@@ -432,6 +432,18 @@ BOOL WINAPI CreateDirectoryA( LPCSTR path, LPSECURITY_ATTRIBUTES attr )
return b;
}
BOOL WINAPI SetFileAttributesA( LPCSTR filename, DWORD attr )
{
LPWSTR wfilename;
BOOL b;
wfilename = hb_mbtowc( filename );
b = SetFileAttributesW( wfilename, attr );
hb_xfree( wfilename );
return b;
}
BOOL WINAPI CharToOemBuffA( LPCSTR src, LPSTR dst, DWORD len )
{
if( len )

10
harbour/source/rtl/direct.c
View File

@@ -108,14 +108,14 @@ HB_FUNC( DIRECTORY )
char * szDirSpec = hb_parc( 1 );
char * szAttributes = hb_parc( 2 );
BOOL fFree = FALSE;
USHORT uiMask;
ULONG ulMask;
PHB_ITEM pDir = hb_itemArrayNew( 0 );
PHB_FFIND ffind;
/* Get the passed attributes and convert them to Harbour Flags */
uiMask = HB_FA_ARCHIVE
ulMask = HB_FA_ARCHIVE
| HB_FA_READONLY
| HB_FA_DEVICE
| HB_FA_TEMPORARY
@@ -129,10 +129,10 @@ HB_FUNC( DIRECTORY )
if( szAttributes && *szAttributes )
{
if( ( uiMask |= hb_fsAttrEncode( szAttributes ) ) & HB_FA_LABEL )
if( ( ulMask |= hb_fsAttrEncode( szAttributes ) ) & HB_FA_LABEL )
{
/* NOTE: This is Clipper Doc compatible. (not operationally) */
uiMask = HB_FA_LABEL;
ulMask = HB_FA_LABEL;
}
}
@@ -180,7 +180,7 @@ HB_FUNC( DIRECTORY )
/* Get the file list */
if( ( ffind = hb_fsFindFirst( szDirSpec, uiMask ) ) != NULL )
if( ( ffind = hb_fsFindFirst( szDirSpec, ulMask ) ) != NULL )
{
PHB_ITEM pSubarray = hb_itemNew( NULL );

30
harbour/source/rtl/filesys.c
View File

@@ -299,7 +299,7 @@ static HANDLE DosToWinHandle( FHANDLE fHandle )
return ( HANDLE ) fHandle;
}
static void convert_open_flags( BOOL fCreate, USHORT uiAttr, USHORT uiFlags,
static void convert_open_flags( BOOL fCreate, ULONG ulAttr, USHORT uiFlags,
DWORD *dwMode, DWORD *dwShare,
DWORD *dwCreat, DWORD *dwAttr )
{
@@ -361,18 +361,18 @@ static void convert_open_flags( BOOL fCreate, USHORT uiAttr, USHORT uiFlags,
}
/* file attributes flags */
if( uiAttr == FC_NORMAL )
if( ulAttr == FC_NORMAL )
{
*dwAttr = FILE_ATTRIBUTE_NORMAL;
}
else
{
*dwAttr = FILE_ATTRIBUTE_ARCHIVE;
if( uiAttr & FC_READONLY )
if( ulAttr & FC_READONLY )
*dwAttr |= FILE_ATTRIBUTE_READONLY;
if( uiAttr & FC_HIDDEN )
if( ulAttr & FC_HIDDEN )
*dwAttr |= FILE_ATTRIBUTE_HIDDEN;
if( uiAttr & FC_SYSTEM )
if( ulAttr & FC_SYSTEM )
*dwAttr |= FILE_ATTRIBUTE_SYSTEM;
}
}
@@ -688,12 +688,12 @@ HB_EXPORT FHANDLE hb_fsOpen( BYTE * pFilename, USHORT uiFlags )
return hFileHandle;
}
HB_EXPORT FHANDLE hb_fsCreate( BYTE * pFilename, USHORT uiAttr )
HB_EXPORT FHANDLE hb_fsCreate( BYTE * pFilename, ULONG ulAttr )
{
FHANDLE hFileHandle;
BOOL fFree;
HB_TRACE(HB_TR_DEBUG, ("hb_fsCreate(%p, %hu)", pFilename, uiAttr));
HB_TRACE(HB_TR_DEBUG, ("hb_fsCreate(%p, %lu)", pFilename, ulAttr));
pFilename = hb_fsNameConv( pFilename, &fFree );
@@ -702,7 +702,7 @@ HB_EXPORT FHANDLE hb_fsCreate( BYTE * pFilename, USHORT uiAttr )
DWORD dwMode, dwShare, dwCreat, dwAttr;
HANDLE hFile;
convert_open_flags( TRUE, uiAttr, FO_EXCLUSIVE, &dwMode, &dwShare, &dwCreat, &dwAttr );
convert_open_flags( TRUE, ulAttr, FO_EXCLUSIVE, &dwMode, &dwShare, &dwCreat, &dwAttr );
hFile = ( HANDLE ) CreateFileA( ( char * ) pFilename, dwMode, dwShare,
NULL, dwCreat, dwAttr, NULL );
@@ -715,7 +715,7 @@ HB_EXPORT FHANDLE hb_fsCreate( BYTE * pFilename, USHORT uiAttr )
{
int flags, share, attr;
unsigned mode;
convert_open_flags( TRUE, uiAttr, FO_EXCLUSIVE, &flags, &mode, &share, &attr );
convert_open_flags( TRUE, ulAttr, FO_EXCLUSIVE, &flags, &mode, &share, &attr );
#if defined(HB_FS_DOSCREAT)
hFileHandle = _creat( ( char * ) pFilename, attr );
@@ -745,12 +745,12 @@ HB_EXPORT FHANDLE hb_fsCreate( BYTE * pFilename, USHORT uiAttr )
[vszakats]
*/
HB_EXPORT FHANDLE hb_fsCreateEx( BYTE * pFilename, USHORT uiAttr, USHORT uiFlags )
HB_EXPORT FHANDLE hb_fsCreateEx( BYTE * pFilename, ULONG ulAttr, USHORT uiFlags )
{
FHANDLE hFileHandle;
BOOL fFree;
HB_TRACE(HB_TR_DEBUG, ("hb_fsCreateEx(%p, %hu, %hu)", pFilename, uiAttr, uiFlags));
HB_TRACE(HB_TR_DEBUG, ("hb_fsCreateEx(%p, %lu, %hu)", pFilename, ulAttr, uiFlags));
pFilename = hb_fsNameConv( pFilename, &fFree );
@@ -759,7 +759,7 @@ HB_EXPORT FHANDLE hb_fsCreateEx( BYTE * pFilename, USHORT uiAttr, USHORT uiFlags
DWORD dwMode, dwShare, dwCreat, dwAttr;
HANDLE hFile;
convert_open_flags( TRUE, uiAttr, uiFlags, &dwMode, &dwShare, &dwCreat, &dwAttr );
convert_open_flags( TRUE, ulAttr, uiFlags, &dwMode, &dwShare, &dwCreat, &dwAttr );
hFile = ( HANDLE ) CreateFileA( ( char * ) pFilename, dwMode, dwShare,
NULL, dwCreat, dwAttr, NULL );
@@ -772,7 +772,7 @@ HB_EXPORT FHANDLE hb_fsCreateEx( BYTE * pFilename, USHORT uiAttr, USHORT uiFlags
{
int flags, share, attr;
unsigned mode;
convert_open_flags( TRUE, uiAttr, uiFlags, &flags, &mode, &share, &attr );
convert_open_flags( TRUE, ulAttr, uiFlags, &flags, &mode, &share, &attr );
#if defined(HB_FS_SOPEN)
hFileHandle = open( ( char * ) pFilename, flags, mode );
@@ -1058,7 +1058,6 @@ HB_EXPORT BOOL hb_fsSetAttr( BYTE * pszFileName, ULONG ulAttr )
#if defined( HB_OS_WIN_32 )
{
DWORD dwFlags = FILE_ATTRIBUTE_ARCHIVE;
LPTSTR lpFile = HB_TCHAR_CONVTO( pszFileName );
if( ulAttr & HB_FA_READONLY )
dwFlags |= FILE_ATTRIBUTE_READONLY;
@@ -1068,9 +1067,8 @@ HB_EXPORT BOOL hb_fsSetAttr( BYTE * pszFileName, ULONG ulAttr )
dwFlags |= FILE_ATTRIBUTE_SYSTEM;
if( ulAttr & HB_FA_NORMAL )
dwFlags |= FILE_ATTRIBUTE_NORMAL;
fResult = SetFileAttributes( lpFile, dwFlags );
fResult = SetFileAttributesA( ( char * ) pszFileName, dwFlags );
hb_fsSetIOError( fResult, 0 );
HB_TCHAR_FREE( lpFile );
}
#elif defined( HB_OS_OS2 )
{

12
harbour/source/rtl/fstemp.c
View File

@@ -110,7 +110,7 @@ static BOOL hb_fsTempName( BYTE * pszBuffer, const BYTE * pszDir, const BYTE * p
/* NOTE: The buffer must be at least _POSIX_PATH_MAX chars long */
HB_EXPORT FHANDLE hb_fsCreateTemp( const BYTE * pszDir, const BYTE * pszPrefix, USHORT uiAttr, BYTE * pszName )
HB_EXPORT FHANDLE hb_fsCreateTemp( const BYTE * pszDir, const BYTE * pszPrefix, ULONG ulAttr, BYTE * pszName )
{
USHORT nAttemptLeft = 999;
@@ -118,7 +118,7 @@ HB_EXPORT FHANDLE hb_fsCreateTemp( const BYTE * pszDir, const BYTE * pszPrefix,
{
if( hb_fsTempName( pszName, pszDir, pszPrefix ) )
{
FHANDLE fhnd = hb_fsCreateEx( pszName, uiAttr, FO_EXCLUSIVE | FO_EXCL );
FHANDLE fhnd = hb_fsCreateEx( pszName, ulAttr, FO_EXCLUSIVE | FO_EXCL );
/* This function may fail, if the generated filename got
used between generation and the file creation. */
@@ -166,14 +166,12 @@ static BOOL fsGetTempDirByCase( BYTE *pszName, const char *pszTempDir )
return fOK;
}
HB_EXPORT FHANDLE hb_fsCreateTemp( const BYTE * pszDir, const BYTE * pszPrefix, USHORT uiAttr, BYTE * pszName )
HB_EXPORT FHANDLE hb_fsCreateTemp( const BYTE * pszDir, const BYTE * pszPrefix, ULONG ulAttr, BYTE * pszName )
{
/* less attemps */
int iAttemptLeft = 99, iLen;
FHANDLE fd;
HB_SYMBOL_UNUSED( uiAttr );
do
{
pszName[0] = '\0';
@@ -241,7 +239,7 @@ HB_EXPORT FHANDLE hb_fsCreateTemp( const BYTE * pszDir, const BYTE * pszPrefix,
pszName[ iLen++ ] = n + ( n > 9 ? 'a' - 10 : '0' );
}
hb_fsNameConv( pszName, NULL );
fd = hb_fsCreateEx( pszName, uiAttr, FO_EXCLUSIVE | FO_EXCL );
fd = hb_fsCreateEx( pszName, ulAttr, FO_EXCLUSIVE | FO_EXCL );
}
if( fd != (FHANDLE) FS_ERROR )
@@ -260,7 +258,7 @@ HB_FUNC( HB_FTEMPCREATE )
hb_retnint( ( HB_NHANDLE ) hb_fsCreateTemp( ( BYTE * ) hb_parc( 1 ),
( BYTE * ) hb_parc( 2 ),
( USHORT ) ( ISNUM( 3 ) ? ( USHORT ) hb_parni( 3 ) : FC_NORMAL ),
( ULONG ) ( ISNUM( 3 ) ? ( ULONG ) hb_parnl( 3 ) : FC_NORMAL ),
szName ) );
hb_storc( ( char *) szName, 4 );

235
harbour/source/rtl/hbffind.c
View File

@@ -179,142 +179,147 @@ HB_FILE_VER( "$Id$" )
/* ------------------------------------------------------------- */
USHORT hb_fsAttrFromRaw( ULONG raw_attr )
ULONG hb_fsAttrFromRaw( ULONG raw_attr )
{
USHORT uiAttr;
ULONG ulAttr;
HB_TRACE(HB_TR_DEBUG, ("hb_fsAttrFromRaw(%hu)", raw_attr));
HB_TRACE(HB_TR_DEBUG, ("hb_fsAttrFromRaw(%lu)", raw_attr));
#if defined(HB_OS_DOS)
uiAttr = 0;
if( raw_attr & FA_ARCH ) uiAttr |= HB_FA_ARCHIVE;
if( raw_attr & FA_DIREC ) uiAttr |= HB_FA_DIRECTORY;
if( raw_attr & FA_HIDDEN ) uiAttr |= HB_FA_HIDDEN;
if( raw_attr & FA_RDONLY ) uiAttr |= HB_FA_READONLY;
if( raw_attr & FA_LABEL ) uiAttr |= HB_FA_LABEL;
if( raw_attr & FA_SYSTEM ) uiAttr |= HB_FA_SYSTEM;
ulAttr = 0;
if( raw_attr & FA_ARCH ) ulAttr |= HB_FA_ARCHIVE;
if( raw_attr & FA_DIREC ) ulAttr |= HB_FA_DIRECTORY;
if( raw_attr & FA_HIDDEN ) ulAttr |= HB_FA_HIDDEN;
if( raw_attr & FA_RDONLY ) ulAttr |= HB_FA_READONLY;
if( raw_attr & FA_LABEL ) ulAttr |= HB_FA_LABEL;
if( raw_attr & FA_SYSTEM ) ulAttr |= HB_FA_SYSTEM;
#elif defined(HB_OS_OS2)
uiAttr = 0;
if( raw_attr & FILE_ARCHIVED ) uiAttr |= HB_FA_ARCHIVE;
if( raw_attr & FILE_DIRECTORY ) uiAttr |= HB_FA_DIRECTORY;
if( raw_attr & FILE_HIDDEN ) uiAttr |= HB_FA_HIDDEN;
if( raw_attr & FILE_READONLY ) uiAttr |= HB_FA_READONLY;
if( raw_attr & FILE_SYSTEM ) uiAttr |= HB_FA_SYSTEM;
ulAttr = 0;
if( raw_attr & FILE_ARCHIVED ) ulAttr |= HB_FA_ARCHIVE;
if( raw_attr & FILE_DIRECTORY ) ulAttr |= HB_FA_DIRECTORY;
if( raw_attr & FILE_HIDDEN ) ulAttr |= HB_FA_HIDDEN;
if( raw_attr & FILE_READONLY ) ulAttr |= HB_FA_READONLY;
if( raw_attr & FILE_SYSTEM ) ulAttr |= HB_FA_SYSTEM;
#elif defined(HB_OS_WIN_32)
uiAttr = 0;
if( raw_attr & FILE_ATTRIBUTE_ARCHIVE ) uiAttr |= HB_FA_ARCHIVE;
if( raw_attr & FILE_ATTRIBUTE_DIRECTORY ) uiAttr |= HB_FA_DIRECTORY;
if( raw_attr & FILE_ATTRIBUTE_HIDDEN ) uiAttr |= HB_FA_HIDDEN;
if( raw_attr & FILE_ATTRIBUTE_READONLY ) uiAttr |= HB_FA_READONLY;
if( raw_attr & FILE_ATTRIBUTE_SYSTEM ) uiAttr |= HB_FA_SYSTEM;
if( raw_attr & FILE_ATTRIBUTE_NORMAL ) uiAttr |= HB_FA_NORMAL;
ulAttr = 0;
if( raw_attr & FILE_ATTRIBUTE_ARCHIVE ) ulAttr |= HB_FA_ARCHIVE;
if( raw_attr & FILE_ATTRIBUTE_DIRECTORY ) ulAttr |= HB_FA_DIRECTORY;
if( raw_attr & FILE_ATTRIBUTE_HIDDEN ) ulAttr |= HB_FA_HIDDEN;
if( raw_attr & FILE_ATTRIBUTE_READONLY ) ulAttr |= HB_FA_READONLY;
if( raw_attr & FILE_ATTRIBUTE_SYSTEM ) ulAttr |= HB_FA_SYSTEM;
if( raw_attr & FILE_ATTRIBUTE_NORMAL ) ulAttr |= HB_FA_NORMAL;
#ifdef HB_EXTENSION
/* Note that FILE_ATTRIBUTE_NORMAL is not needed
HB_FA_DEVICE not supported
HB_FA_VOLCOMP needs to be checked */
if( raw_attr & FILE_ATTRIBUTE_ENCRYPTED ) uiAttr |= HB_FA_ENCRYPTED;
if( raw_attr & FILE_ATTRIBUTE_TEMPORARY ) uiAttr |= HB_FA_TEMPORARY;
if( raw_attr & FILE_ATTRIBUTE_SPARSE_FILE ) uiAttr |= HB_FA_SPARSE;
if( raw_attr & FILE_ATTRIBUTE_REPARSE_POINT ) uiAttr |= HB_FA_REPARSE;
if( raw_attr & FILE_ATTRIBUTE_COMPRESSED ) uiAttr |= HB_FA_COMPRESSED;
if( raw_attr & FILE_ATTRIBUTE_OFFLINE ) uiAttr |= HB_FA_OFFLINE;
if( raw_attr & FILE_ATTRIBUTE_ENCRYPTED ) ulAttr |= HB_FA_ENCRYPTED;
if( raw_attr & FILE_ATTRIBUTE_TEMPORARY ) ulAttr |= HB_FA_TEMPORARY;
if( raw_attr & FILE_ATTRIBUTE_SPARSE_FILE ) ulAttr |= HB_FA_SPARSE;
if( raw_attr & FILE_ATTRIBUTE_REPARSE_POINT ) ulAttr |= HB_FA_REPARSE;
if( raw_attr & FILE_ATTRIBUTE_COMPRESSED ) ulAttr |= HB_FA_COMPRESSED;
if( raw_attr & FILE_ATTRIBUTE_OFFLINE ) ulAttr |= HB_FA_OFFLINE;
/* FILE_ATTRIBUTE_NOT_CONTENT_INDEXED */
/* not defined in some older winnt.h */
if( raw_attr & 0x00002000 ) uiAttr |= HB_FA_NOTINDEXED;
if( raw_attr & 0x00008000 ) uiAttr |= HB_FA_VOLCOMP;
if( raw_attr & 0x00002000 ) ulAttr |= HB_FA_NOTINDEXED;
if( raw_attr & 0x00008000 ) ulAttr |= HB_FA_VOLCOMP;
#endif
#elif defined(HB_OS_UNIX)
uiAttr = 0;
if( S_ISREG( raw_attr ) ) uiAttr |= HB_FA_ARCHIVE;
if( S_ISDIR( raw_attr ) ) uiAttr |= HB_FA_DIRECTORY;
if( S_ISLNK( raw_attr ) ) uiAttr |= HB_FA_REPARSE;
if( S_ISCHR( raw_attr ) ) uiAttr |= HB_FA_COMPRESSED;
if( S_ISBLK( raw_attr ) ) uiAttr |= HB_FA_DEVICE;
if( S_ISFIFO( raw_attr ) ) uiAttr |= HB_FA_TEMPORARY;
if( S_ISSOCK( raw_attr ) ) uiAttr |= HB_FA_SPARSE;
ulAttr = ( ( raw_attr & S_IRWXO ) << 16 ) |
( ( raw_attr & S_IRWXG ) << 15 ) |
( ( raw_attr & S_IRWXU ) << 14 ) |
( ( raw_attr & ( S_ISUID | S_ISGID | S_ISVTX ) ) << 13 );
if( S_ISREG( raw_attr ) ) ulAttr |= HB_FA_FILE;
if( S_ISDIR( raw_attr ) ) ulAttr |= HB_FA_DIRECTORY;
if( S_ISLNK( raw_attr ) ) ulAttr |= HB_FA_LINK;
if( S_ISCHR( raw_attr ) ) ulAttr |= HB_FA_CHRDEVICE;
if( S_ISBLK( raw_attr ) ) ulAttr |= HB_FA_BLKDEVICE;
if( S_ISFIFO( raw_attr ) ) ulAttr |= HB_FA_FIFO;
if( S_ISSOCK( raw_attr ) ) ulAttr |= HB_FA_SOCKET;
#else
HB_SYMBOL_UNUSED( raw_attr );
uiAttr = 0;
ulAttr = 0;
#endif
return uiAttr;
return ulAttr;
}
ULONG hb_fsAttrToRaw( USHORT uiAttr )
ULONG hb_fsAttrToRaw( ULONG ulAttr )
{
ULONG raw_attr;
HB_TRACE(HB_TR_DEBUG, ("hb_fsAttrToRaw(%hu)", uiAttr));
HB_TRACE(HB_TR_DEBUG, ("hb_fsAttrToRaw(%lu)", ulAttr));
#if defined(HB_OS_DOS)
raw_attr = 0;
if( uiAttr & HB_FA_ARCHIVE ) raw_attr |= FA_ARCH;
if( uiAttr & HB_FA_DIRECTORY ) raw_attr |= FA_DIREC;
if( uiAttr & HB_FA_HIDDEN ) raw_attr |= FA_HIDDEN;
if( uiAttr & HB_FA_READONLY ) raw_attr |= FA_RDONLY;
if( uiAttr & HB_FA_LABEL ) raw_attr |= FA_LABEL;
if( uiAttr & HB_FA_SYSTEM ) raw_attr |= FA_SYSTEM;
if( ulAttr & HB_FA_ARCHIVE ) raw_attr |= FA_ARCH;
if( ulAttr & HB_FA_DIRECTORY ) raw_attr |= FA_DIREC;
if( ulAttr & HB_FA_HIDDEN ) raw_attr |= FA_HIDDEN;
if( ulAttr & HB_FA_READONLY ) raw_attr |= FA_RDONLY;
if( ulAttr & HB_FA_LABEL ) raw_attr |= FA_LABEL;
if( ulAttr & HB_FA_SYSTEM ) raw_attr |= FA_SYSTEM;
#elif defined(HB_OS_OS2)
raw_attr = 0;
if( uiAttr & HB_FA_ARCHIVE ) raw_attr |= FILE_ARCHIVED;
if( uiAttr & HB_FA_DIRECTORY ) raw_attr |= FILE_DIRECTORY;
if( uiAttr & HB_FA_HIDDEN ) raw_attr |= FILE_HIDDEN;
if( uiAttr & HB_FA_READONLY ) raw_attr |= FILE_READONLY;
if( uiAttr & HB_FA_SYSTEM ) raw_attr |= FILE_SYSTEM;
if( ulAttr & HB_FA_ARCHIVE ) raw_attr |= FILE_ARCHIVED;
if( ulAttr & HB_FA_DIRECTORY ) raw_attr |= FILE_DIRECTORY;
if( ulAttr & HB_FA_HIDDEN ) raw_attr |= FILE_HIDDEN;
if( ulAttr & HB_FA_READONLY ) raw_attr |= FILE_READONLY;
if( ulAttr & HB_FA_SYSTEM ) raw_attr |= FILE_SYSTEM;
#elif defined(HB_OS_WIN_32)
raw_attr = 0;
if( uiAttr & HB_FA_ARCHIVE ) raw_attr |= FILE_ATTRIBUTE_ARCHIVE;
if( uiAttr & HB_FA_DIRECTORY ) raw_attr |= FILE_ATTRIBUTE_DIRECTORY;
if( uiAttr & HB_FA_HIDDEN ) raw_attr |= FILE_ATTRIBUTE_HIDDEN;
if( uiAttr & HB_FA_READONLY ) raw_attr |= FILE_ATTRIBUTE_READONLY;
if( uiAttr & HB_FA_SYSTEM ) raw_attr |= FILE_ATTRIBUTE_SYSTEM;
if( uiAttr & HB_FA_NORMAL ) raw_attr |= FILE_ATTRIBUTE_NORMAL;
if( ulAttr & HB_FA_ARCHIVE ) raw_attr |= FILE_ATTRIBUTE_ARCHIVE;
if( ulAttr & HB_FA_DIRECTORY ) raw_attr |= FILE_ATTRIBUTE_DIRECTORY;
if( ulAttr & HB_FA_HIDDEN ) raw_attr |= FILE_ATTRIBUTE_HIDDEN;
if( ulAttr & HB_FA_READONLY ) raw_attr |= FILE_ATTRIBUTE_READONLY;
if( ulAttr & HB_FA_SYSTEM ) raw_attr |= FILE_ATTRIBUTE_SYSTEM;
if( ulAttr & HB_FA_NORMAL ) raw_attr |= FILE_ATTRIBUTE_NORMAL;
#ifdef HB_EXTENSION
/* Note that FILE_ATTRIBUTE_NORMAL is not needed
HB_FA_DEVICE not supported
HB_FA_VOLCOMP needs to be checked */
if( uiAttr & HB_FA_ENCRYPTED ) raw_attr |= FILE_ATTRIBUTE_ENCRYPTED;
if( uiAttr & HB_FA_TEMPORARY ) raw_attr |= FILE_ATTRIBUTE_TEMPORARY;
if( uiAttr & HB_FA_SPARSE ) raw_attr |= FILE_ATTRIBUTE_SPARSE_FILE;
if( uiAttr & HB_FA_REPARSE ) raw_attr |= FILE_ATTRIBUTE_REPARSE_POINT;
if( uiAttr & HB_FA_COMPRESSED ) raw_attr |= FILE_ATTRIBUTE_COMPRESSED;
if( uiAttr & HB_FA_OFFLINE ) raw_attr |= FILE_ATTRIBUTE_OFFLINE;
if( uiAttr & HB_FA_NOTINDEXED ) raw_attr |= 0x00002000; /* FILE_ATTRIBUTE_NOT_CONTENT_INDEXED not defined in some older winnt.h */
if( uiAttr & HB_FA_VOLCOMP ) raw_attr |= 0x00008000;
if( ulAttr & HB_FA_ENCRYPTED ) raw_attr |= FILE_ATTRIBUTE_ENCRYPTED;
if( ulAttr & HB_FA_TEMPORARY ) raw_attr |= FILE_ATTRIBUTE_TEMPORARY;
if( ulAttr & HB_FA_SPARSE ) raw_attr |= FILE_ATTRIBUTE_SPARSE_FILE;
if( ulAttr & HB_FA_REPARSE ) raw_attr |= FILE_ATTRIBUTE_REPARSE_POINT;
if( ulAttr & HB_FA_COMPRESSED ) raw_attr |= FILE_ATTRIBUTE_COMPRESSED;
if( ulAttr & HB_FA_OFFLINE ) raw_attr |= FILE_ATTRIBUTE_OFFLINE;
if( ulAttr & HB_FA_NOTINDEXED ) raw_attr |= 0x00002000; /* FILE_ATTRIBUTE_NOT_CONTENT_INDEXED not defined in some older winnt.h */
if( ulAttr & HB_FA_VOLCOMP ) raw_attr |= 0x00008000;
#endif
#elif defined(HB_OS_UNIX)
raw_attr = 0;
if( uiAttr & HB_FA_ARCHIVE ) raw_attr |= S_IFREG;
if( uiAttr & HB_FA_DIRECTORY ) raw_attr |= S_IFDIR;
if( uiAttr & HB_FA_REPARSE ) raw_attr |= S_IFLNK;
if( uiAttr & HB_FA_COMPRESSED ) raw_attr |= S_IFCHR;
if( uiAttr & HB_FA_DEVICE ) raw_attr |= S_IFBLK;
if( uiAttr & HB_FA_TEMPORARY ) raw_attr |= S_IFIFO;
if( uiAttr & HB_FA_SPARSE ) raw_attr |= S_IFSOCK;
raw_attr = HB_FA_POSIX_ATTR( ulAttr );
if( ulAttr & HB_FA_FILE ) raw_attr |= S_IFREG;
if( ulAttr & HB_FA_DIRECTORY ) raw_attr |= S_IFDIR;
if( ulAttr & HB_FA_LINK ) raw_attr |= S_IFLNK;
if( ulAttr & HB_FA_CHRDEVICE ) raw_attr |= S_IFCHR;
if( ulAttr & HB_FA_BLKDEVICE ) raw_attr |= S_IFBLK;
if( ulAttr & HB_FA_FIFO ) raw_attr |= S_IFIFO;
if( ulAttr & HB_FA_SOCKET ) raw_attr |= S_IFSOCK;
#else
HB_SYMBOL_UNUSED( uiAttr );
HB_SYMBOL_UNUSED( ulAttr );
raw_attr = 0;
#endif
@@ -325,11 +330,11 @@ ULONG hb_fsAttrToRaw( USHORT uiAttr )
/* Converts a CA-Cl*pper compatible file attribute string
to the internal reprensentation. */
USHORT hb_fsAttrEncode( const char * szAttr )
ULONG hb_fsAttrEncode( const char * szAttr )
{
const char * pos = szAttr;
char ch;
USHORT uiAttr = 0;
ULONG ulAttr = 0;
HB_TRACE(HB_TR_DEBUG, ("hb_fsAttrEncode(%p)", szAttr));
@@ -337,29 +342,29 @@ USHORT hb_fsAttrEncode( const char * szAttr )
{
switch( ch )
{
case 'R': uiAttr |= HB_FA_READONLY; break;
case 'H': uiAttr |= HB_FA_HIDDEN; break;
case 'S': uiAttr |= HB_FA_SYSTEM; break;
case 'V': uiAttr |= HB_FA_LABEL; break;
case 'D': uiAttr |= HB_FA_DIRECTORY; break;
case 'A': uiAttr |= HB_FA_ARCHIVE; break;
case 'R': ulAttr |= HB_FA_READONLY; break;
case 'H': ulAttr |= HB_FA_HIDDEN; break;
case 'S': ulAttr |= HB_FA_SYSTEM; break;
case 'V': ulAttr |= HB_FA_LABEL; break;
case 'D': ulAttr |= HB_FA_DIRECTORY; break;
case 'A': ulAttr |= HB_FA_ARCHIVE; break;
#ifdef HB_EXTENSION
case 'E': uiAttr |= HB_FA_ENCRYPTED; break;
case 'T': uiAttr |= HB_FA_TEMPORARY; break;
case 'P': uiAttr |= HB_FA_SPARSE; break;
case 'L': uiAttr |= HB_FA_REPARSE; break;
case 'C': uiAttr |= HB_FA_COMPRESSED; break;
case 'O': uiAttr |= HB_FA_OFFLINE; break;
case 'X': uiAttr |= HB_FA_NOTINDEXED; break;
case 'I': uiAttr |= HB_FA_DEVICE; break;
case 'M': uiAttr |= HB_FA_VOLCOMP; break;
case 'E': ulAttr |= HB_FA_ENCRYPTED; break;
case 'T': ulAttr |= HB_FA_TEMPORARY; break;
case 'P': ulAttr |= HB_FA_SPARSE; break;
case 'L': ulAttr |= HB_FA_REPARSE; break;
case 'C': ulAttr |= HB_FA_COMPRESSED; break;
case 'O': ulAttr |= HB_FA_OFFLINE; break;
case 'X': ulAttr |= HB_FA_NOTINDEXED; break;
case 'I': ulAttr |= HB_FA_DEVICE; break;
case 'M': ulAttr |= HB_FA_VOLCOMP; break;
#endif
}
pos++;
}
return uiAttr;
return ulAttr;
}
/* Converts a file attribute (ffind->attr) to the CA-Cl*pper
@@ -367,29 +372,29 @@ USHORT hb_fsAttrEncode( const char * szAttr )
/* NOTE: szAttr buffer must be at least 16 chars long */
char * hb_fsAttrDecode( USHORT uiAttr, char * szAttr )
char * hb_fsAttrDecode( ULONG ulAttr, char * szAttr )
{
char * ptr = szAttr;
HB_TRACE(HB_TR_DEBUG, ("hb_fsAttrDecode(%hu, %p)", uiAttr, szAttr));
HB_TRACE(HB_TR_DEBUG, ("hb_fsAttrDecode(%lu, %p)", ulAttr, szAttr));
/* Using the same order as CA-Cl*pper did: RHSVDA. */
if( uiAttr & HB_FA_READONLY ) *ptr++ = 'R';
if( uiAttr & HB_FA_HIDDEN ) *ptr++ = 'H';
if( uiAttr & HB_FA_SYSTEM ) *ptr++ = 'S';
if( uiAttr & HB_FA_LABEL ) *ptr++ = 'V';
if( uiAttr & HB_FA_DIRECTORY ) *ptr++ = 'D';
if( uiAttr & HB_FA_ARCHIVE ) *ptr++ = 'A';
if( ulAttr & HB_FA_READONLY ) *ptr++ = 'R';
if( ulAttr & HB_FA_HIDDEN ) *ptr++ = 'H';
if( ulAttr & HB_FA_SYSTEM ) *ptr++ = 'S';
if( ulAttr & HB_FA_LABEL ) *ptr++ = 'V';
if( ulAttr & HB_FA_DIRECTORY ) *ptr++ = 'D';
if( ulAttr & HB_FA_ARCHIVE ) *ptr++ = 'A';
#ifdef HB_EXTENSION
if( uiAttr & HB_FA_ENCRYPTED ) *ptr++ = 'E';
if( uiAttr & HB_FA_TEMPORARY ) *ptr++ = 'T';
if( uiAttr & HB_FA_SPARSE ) *ptr++ = 'P';
if( uiAttr & HB_FA_REPARSE ) *ptr++ = 'L';
if( uiAttr & HB_FA_COMPRESSED ) *ptr++ = 'C';
if( uiAttr & HB_FA_OFFLINE ) *ptr++ = 'O';
if( uiAttr & HB_FA_NOTINDEXED ) *ptr++ = 'X';
if( uiAttr & HB_FA_DEVICE ) *ptr++ = 'I';
if( uiAttr & HB_FA_VOLCOMP ) *ptr++ = 'M';
if( ulAttr & HB_FA_ENCRYPTED ) *ptr++ = 'E';
if( ulAttr & HB_FA_TEMPORARY ) *ptr++ = 'T';
if( ulAttr & HB_FA_SPARSE ) *ptr++ = 'P';
if( ulAttr & HB_FA_REPARSE ) *ptr++ = 'L';
if( ulAttr & HB_FA_COMPRESSED ) *ptr++ = 'C';
if( ulAttr & HB_FA_OFFLINE ) *ptr++ = 'O';
if( ulAttr & HB_FA_NOTINDEXED ) *ptr++ = 'X';
if( ulAttr & HB_FA_DEVICE ) *ptr++ = 'I';
if( ulAttr & HB_FA_VOLCOMP ) *ptr++ = 'M';
#endif
*ptr = '\0';
@@ -606,7 +611,7 @@ static BOOL hb_fsFindNextLow( PHB_FFIND ffind )
( ( HB_FOFFSET ) info->pFindFileData.nFileSizeHigh << 32 );
#endif
raw_attr = ( USHORT ) info->pFindFileData.dwFileAttributes;
raw_attr = ( ULONG ) info->pFindFileData.dwFileAttributes;
/* NOTE: One of these may fail when searching on an UNC path, I
don't know yet what's the reason. [vszakats] */
@@ -745,7 +750,7 @@ static BOOL hb_fsFindNextLow( PHB_FFIND ffind )
bFound = FALSE;
hb_fsSetError( (USHORT) FS_ERROR );
hb_fsSetError( ( USHORT ) FS_ERROR );
}
#endif
@@ -770,7 +775,7 @@ static BOOL hb_fsFindNextLow( PHB_FFIND ffind )
return bFound;
}
HB_EXPORT PHB_FFIND hb_fsFindFirst( const char * pszFileMask, USHORT attrmask )
HB_EXPORT PHB_FFIND hb_fsFindFirst( const char * pszFileMask, ULONG attrmask )
{
PHB_FFIND ffind;

18
harbour/source/rtl/spfiles.c
View File

@@ -134,34 +134,36 @@ FHANDLE hb_spOpen( BYTE * pFilename, USHORT uiFlags )
return hb_fsOpen( pFilename, uiFlags );
}
FHANDLE hb_spCreate( BYTE * pFilename, USHORT uiAttr )
FHANDLE hb_spCreate( BYTE * pFilename, ULONG ulAttr )
{
BYTE path[ _POSIX_PATH_MAX + 1 ];
PHB_FNAME pFilepath = hb_fsFNameSplit( (char*) pFilename );
PHB_FNAME pFilepath;
HB_TRACE(HB_TR_DEBUG, ("hb_spCreate(%p, %hu)", pFilename, uiAttr));
HB_TRACE(HB_TR_DEBUG, ("hb_spCreate(%p, %lu)", pFilename, ulAttr));
pFilepath = hb_fsFNameSplit( (char*) pFilename );
if( ! pFilepath->szPath && hb_set.HB_SET_DEFAULT )
pFilepath->szPath = hb_set.HB_SET_DEFAULT;
hb_fsFNameMerge( (char*) path, pFilepath );
hb_xfree( pFilepath );
return hb_fsCreate( path, uiAttr );
return hb_fsCreate( path, ulAttr );
}
FHANDLE hb_spCreateEx( BYTE * pFilename, USHORT uiAttr, USHORT uiFlags )
FHANDLE hb_spCreateEx( BYTE * pFilename, ULONG ulAttr, USHORT uiFlags )
{
BYTE path[ _POSIX_PATH_MAX + 1 ];
PHB_FNAME pFilepath = hb_fsFNameSplit( (char*) pFilename );
PHB_FNAME pFilepath;
HB_TRACE(HB_TR_DEBUG, ("hb_spCreateEx(%p, %hu, %hu)", pFilename, uiAttr, uiFlags));
HB_TRACE(HB_TR_DEBUG, ("hb_spCreateEx(%p, %lu, %hu)", pFilename, ulAttr, uiFlags));
pFilepath = hb_fsFNameSplit( (char*) pFilename );
if( ! pFilepath->szPath && hb_set.HB_SET_DEFAULT )
pFilepath->szPath = hb_set.HB_SET_DEFAULT;
hb_fsFNameMerge( (char*) path, pFilepath );
hb_xfree( pFilepath );
return hb_fsCreateEx( path, uiAttr, uiFlags );
return hb_fsCreateEx( path, ulAttr, uiFlags );
}