From d5ecd90c317b563170375779c5a7b5afd33c67f7 Mon Sep 17 00:00:00 2001 From: Przemyslaw Czerpak Date: Wed, 9 Jul 2008 16:25:00 +0000 Subject: [PATCH] 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 --- harbour/ChangeLog | 21 +++ harbour/include/hbapifs.h | 67 +++++---- harbour/include/hbwince.h | 1 + harbour/source/common/hbwince.c | 12 ++ harbour/source/rtl/direct.c | 10 +- harbour/source/rtl/filesys.c | 30 ++-- harbour/source/rtl/fstemp.c | 12 +- harbour/source/rtl/hbffind.c | 235 ++++++++++++++++---------------- harbour/source/rtl/spfiles.c | 18 +-- 9 files changed, 227 insertions(+), 179 deletions(-) diff --git a/harbour/ChangeLog b/harbour/ChangeLog index 55b9ce2329..30aa6b216b 100644 --- a/harbour/ChangeLog +++ b/harbour/ChangeLog @@ -8,6 +8,27 @@ 2008-12-31 13:59 UTC+0100 Foo Bar */ +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 diff --git a/harbour/include/hbapifs.h b/harbour/include/hbapifs.h index 6ea802ae87..4dcae8c221 100644 --- a/harbour/include/hbapifs.h +++ b/harbour/include/hbapifs.h @@ -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 ); diff --git a/harbour/include/hbwince.h b/harbour/include/hbwince.h index e9760b7deb..0f3d29e29e 100644 --- a/harbour/include/hbwince.h +++ b/harbour/include/hbwince.h @@ -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 ); diff --git a/harbour/source/common/hbwince.c b/harbour/source/common/hbwince.c index ffc32b3e72..f8aacd91d8 100644 --- a/harbour/source/common/hbwince.c +++ b/harbour/source/common/hbwince.c @@ -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 ) diff --git a/harbour/source/rtl/direct.c b/harbour/source/rtl/direct.c index adabe9232d..bb66c6d353 100644 --- a/harbour/source/rtl/direct.c +++ b/harbour/source/rtl/direct.c @@ -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 ); diff --git a/harbour/source/rtl/filesys.c b/harbour/source/rtl/filesys.c index 92ed35030e..8e0e50eb43 100644 --- a/harbour/source/rtl/filesys.c +++ b/harbour/source/rtl/filesys.c @@ -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 ) { diff --git a/harbour/source/rtl/fstemp.c b/harbour/source/rtl/fstemp.c index 4fbfdafe15..d3183fe7b6 100644 --- a/harbour/source/rtl/fstemp.c +++ b/harbour/source/rtl/fstemp.c @@ -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 ); diff --git a/harbour/source/rtl/hbffind.c b/harbour/source/rtl/hbffind.c index d104e460b6..6e46072843 100644 --- a/harbour/source/rtl/hbffind.c +++ b/harbour/source/rtl/hbffind.c @@ -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; diff --git a/harbour/source/rtl/spfiles.c b/harbour/source/rtl/spfiles.c index 85dd0b3aed..3060fb348a 100644 --- a/harbour/source/rtl/spfiles.c +++ b/harbour/source/rtl/spfiles.c @@ -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 ); }