Large-scale renaming of all Win32 functions and types to use the
standard Windows names.
diff --git a/files/file.c b/files/file.c
index c596564..8e18adb 100644
--- a/files/file.c
+++ b/files/file.c
@@ -66,7 +66,7 @@
*
* Convert OF_* mode into flags for CreateFile.
*/
-static void FILE_ConvertOFMode( INT32 mode, DWORD *access, DWORD *sharing )
+static void FILE_ConvertOFMode( INT mode, DWORD *access, DWORD *sharing )
{
switch(mode & 0x03)
{
@@ -141,7 +141,7 @@
For all other cases we barf,set the DOS_ERROR and return TRUE
*/
-static BOOL32 FILE_ShareDeny( int mode, int oldmode)
+static BOOL FILE_ShareDeny( int mode, int oldmode)
{
int oldsharemode = oldmode & 0x70;
int sharemode = mode & 0x70;
@@ -307,7 +307,7 @@
*
* Duplicate a Unix handle into a task handle.
*/
-HFILE32 FILE_DupUnixHandle( int fd, DWORD access )
+HFILE FILE_DupUnixHandle( int fd, DWORD access )
{
FILE_OBJECT *file;
int unix_handle;
@@ -317,7 +317,7 @@
if ((unix_handle = dup(fd)) == -1)
{
FILE_SetDosError();
- return INVALID_HANDLE_VALUE32;
+ return INVALID_HANDLE_VALUE;
}
req.access = access;
req.inherit = 1;
@@ -328,13 +328,13 @@
CLIENT_SendRequest( REQ_CREATE_FILE, unix_handle, 1,
&req, sizeof(req) );
CLIENT_WaitSimpleReply( &reply, sizeof(reply), NULL );
- if (reply.handle == -1) return INVALID_HANDLE_VALUE32;
+ if (reply.handle == -1) return INVALID_HANDLE_VALUE;
if (!(file = HeapAlloc( SystemHeap, 0, sizeof(FILE_OBJECT) )))
{
CLIENT_CloseHandle( reply.handle );
SetLastError( ERROR_TOO_MANY_OPEN_FILES );
- return (HFILE32)NULL;
+ return (HFILE)NULL;
}
file->header.type = K32OBJ_FILE;
file->header.refcount = 0;
@@ -348,9 +348,9 @@
*
* Implementation of CreateFile. Takes a Unix path name.
*/
-HFILE32 FILE_CreateFile( LPCSTR filename, DWORD access, DWORD sharing,
+HFILE FILE_CreateFile( LPCSTR filename, DWORD access, DWORD sharing,
LPSECURITY_ATTRIBUTES sa, DWORD creation,
- DWORD attributes, HANDLE32 template )
+ DWORD attributes, HANDLE template )
{
FILE_OBJECT *file;
struct create_file_request req;
@@ -382,7 +382,7 @@
CLIENT_WaitSimpleReply( &reply, sizeof(reply), NULL );
}
}
- if (reply.handle == -1) return INVALID_HANDLE_VALUE32;
+ if (reply.handle == -1) return INVALID_HANDLE_VALUE;
/* Now build the FILE_OBJECT */
@@ -390,7 +390,7 @@
{
SetLastError( ERROR_OUTOFMEMORY );
CLIENT_CloseHandle( reply.handle );
- return (HFILE32)INVALID_HANDLE_VALUE32;
+ return (HFILE)INVALID_HANDLE_VALUE;
}
file->header.type = K32OBJ_FILE;
file->header.refcount = 0;
@@ -404,7 +404,7 @@
*
* Same as FILE_CreateFile but for a device
*/
-HFILE32 FILE_CreateDevice( int client_id, DWORD access, LPSECURITY_ATTRIBUTES sa )
+HFILE FILE_CreateDevice( int client_id, DWORD access, LPSECURITY_ATTRIBUTES sa )
{
FILE_OBJECT *file;
struct create_device_request req;
@@ -415,7 +415,7 @@
req.id = client_id;
CLIENT_SendRequest( REQ_CREATE_DEVICE, -1, 1, &req, sizeof(req) );
CLIENT_WaitSimpleReply( &reply, sizeof(reply), NULL );
- if (reply.handle == -1) return INVALID_HANDLE_VALUE32;
+ if (reply.handle == -1) return INVALID_HANDLE_VALUE;
/* Now build the FILE_OBJECT */
@@ -423,7 +423,7 @@
{
SetLastError( ERROR_OUTOFMEMORY );
CLIENT_CloseHandle( reply.handle );
- return (HFILE32)INVALID_HANDLE_VALUE32;
+ return (HFILE)INVALID_HANDLE_VALUE;
}
file->header.type = K32OBJ_FILE;
file->header.refcount = 0;
@@ -460,16 +460,16 @@
* Doesn't support character devices, pipes, template files, or a
* lot of the 'attributes' flags yet.
*/
-HFILE32 WINAPI CreateFile32A( LPCSTR filename, DWORD access, DWORD sharing,
+HFILE WINAPI CreateFileA( LPCSTR filename, DWORD access, DWORD sharing,
LPSECURITY_ATTRIBUTES sa, DWORD creation,
- DWORD attributes, HANDLE32 template )
+ DWORD attributes, HANDLE template )
{
DOS_FULL_NAME full_name;
if (!filename)
{
SetLastError( ERROR_INVALID_PARAMETER );
- return HFILE_ERROR32;
+ return HFILE_ERROR;
}
/* If the name starts with '\\?\', ignore the first 4 chars. */
@@ -480,7 +480,7 @@
{
FIXME( file, "UNC name (%s) not supported.\n", filename );
SetLastError( ERROR_PATH_NOT_FOUND );
- return HFILE_ERROR32;
+ return HFILE_ERROR;
}
}
@@ -492,32 +492,32 @@
{
FIXME( file, "UNC name (%s) not supported.\n", filename );
SetLastError( ERROR_PATH_NOT_FOUND );
- return HFILE_ERROR32;
+ return HFILE_ERROR;
}
/* Open a console for CONIN$ or CONOUT$ */
- if (!lstrcmpi32A(filename, "CONIN$")) return CONSOLE_OpenHandle( FALSE, access, sa );
- if (!lstrcmpi32A(filename, "CONOUT$")) return CONSOLE_OpenHandle( TRUE, access, sa );
+ if (!lstrcmpiA(filename, "CONIN$")) return CONSOLE_OpenHandle( FALSE, access, sa );
+ if (!lstrcmpiA(filename, "CONOUT$")) return CONSOLE_OpenHandle( TRUE, access, sa );
if (DOSFS_GetDevice( filename ))
{
- HFILE32 ret;
+ HFILE ret;
TRACE(file, "opening device '%s'\n", filename );
- if (HFILE_ERROR32!=(ret=DOSFS_OpenDevice( filename, access )))
+ if (HFILE_ERROR!=(ret=DOSFS_OpenDevice( filename, access )))
return ret;
/* Do not silence this please. It is a critical error. -MM */
ERR(file, "Couldn't open device '%s'!\n",filename);
SetLastError( ERROR_FILE_NOT_FOUND );
- return HFILE_ERROR32;
+ return HFILE_ERROR;
}
/* check for filename, don't check for last entry if creating */
if (!DOSFS_GetFullName( filename,
(creation == OPEN_EXISTING) || (creation == TRUNCATE_EXISTING), &full_name ))
- return HFILE_ERROR32;
+ return HFILE_ERROR;
return FILE_CreateFile( full_name.long_name, access, sharing,
sa, creation, attributes, template );
@@ -528,12 +528,12 @@
/*************************************************************************
* CreateFile32W (KERNEL32.48)
*/
-HFILE32 WINAPI CreateFile32W( LPCWSTR filename, DWORD access, DWORD sharing,
+HFILE WINAPI CreateFileW( LPCWSTR filename, DWORD access, DWORD sharing,
LPSECURITY_ATTRIBUTES sa, DWORD creation,
- DWORD attributes, HANDLE32 template)
+ DWORD attributes, HANDLE template)
{
LPSTR afn = HEAP_strdupWtoA( GetProcessHeap(), 0, filename );
- HFILE32 res = CreateFile32A( afn, access, sharing, sa, creation, attributes, template );
+ HFILE res = CreateFileA( afn, access, sharing, sa, creation, attributes, template );
HeapFree( GetProcessHeap(), 0, afn );
return res;
}
@@ -571,7 +571,7 @@
*
* Stat a Unix path name. Return TRUE if OK.
*/
-BOOL32 FILE_Stat( LPCSTR unixName, BY_HANDLE_FILE_INFORMATION *info )
+BOOL FILE_Stat( LPCSTR unixName, BY_HANDLE_FILE_INFORMATION *info )
{
struct stat st;
@@ -590,7 +590,7 @@
/***********************************************************************
* GetFileInformationByHandle (KERNEL32.219)
*/
-DWORD WINAPI GetFileInformationByHandle( HFILE32 hFile,
+DWORD WINAPI GetFileInformationByHandle( HFILE hFile,
BY_HANDLE_FILE_INFORMATION *info )
{
struct get_file_info_request req;
@@ -622,14 +622,14 @@
*/
DWORD WINAPI GetFileAttributes16( LPCSTR name )
{
- return GetFileAttributes32A( name );
+ return GetFileAttributesA( name );
}
/**************************************************************************
* GetFileAttributes32A (KERNEL32.217)
*/
-DWORD WINAPI GetFileAttributes32A( LPCSTR name )
+DWORD WINAPI GetFileAttributesA( LPCSTR name )
{
DOS_FULL_NAME full_name;
BY_HANDLE_FILE_INFORMATION info;
@@ -645,10 +645,10 @@
/**************************************************************************
* GetFileAttributes32W (KERNEL32.218)
*/
-DWORD WINAPI GetFileAttributes32W( LPCWSTR name )
+DWORD WINAPI GetFileAttributesW( LPCWSTR name )
{
LPSTR nameA = HEAP_strdupWtoA( GetProcessHeap(), 0, name );
- DWORD res = GetFileAttributes32A( nameA );
+ DWORD res = GetFileAttributesA( nameA );
HeapFree( GetProcessHeap(), 0, nameA );
return res;
}
@@ -657,7 +657,7 @@
/***********************************************************************
* GetFileSize (KERNEL32.220)
*/
-DWORD WINAPI GetFileSize( HFILE32 hFile, LPDWORD filesizehigh )
+DWORD WINAPI GetFileSize( HFILE hFile, LPDWORD filesizehigh )
{
BY_HANDLE_FILE_INFORMATION info;
if (!GetFileInformationByHandle( hFile, &info )) return 0;
@@ -669,7 +669,7 @@
/***********************************************************************
* GetFileTime (KERNEL32.221)
*/
-BOOL32 WINAPI GetFileTime( HFILE32 hFile, FILETIME *lpCreationTime,
+BOOL WINAPI GetFileTime( HFILE hFile, FILETIME *lpCreationTime,
FILETIME *lpLastAccessTime,
FILETIME *lpLastWriteTime )
{
@@ -684,7 +684,7 @@
/***********************************************************************
* CompareFileTime (KERNEL32.28)
*/
-INT32 WINAPI CompareFileTime( LPFILETIME x, LPFILETIME y )
+INT WINAPI CompareFileTime( LPFILETIME x, LPFILETIME y )
{
if (!x || !y) return -1;
@@ -721,22 +721,22 @@
if (drive & TF_FORCEDRIVE)
sprintf(temppath,"%c:", drive & ~TF_FORCEDRIVE );
else
- GetTempPath32A( 132, temppath );
- return (UINT16)GetTempFileName32A( temppath, prefix, unique, buffer );
+ GetTempPathA( 132, temppath );
+ return (UINT16)GetTempFileNameA( temppath, prefix, unique, buffer );
}
/***********************************************************************
* GetTempFileName32A (KERNEL32.290)
*/
-UINT32 WINAPI GetTempFileName32A( LPCSTR path, LPCSTR prefix, UINT32 unique,
+UINT WINAPI GetTempFileNameA( LPCSTR path, LPCSTR prefix, UINT unique,
LPSTR buffer)
{
- static UINT32 unique_temp;
+ static UINT unique_temp;
DOS_FULL_NAME full_name;
int i;
LPSTR p;
- UINT32 num;
+ UINT num;
if ( !path || !prefix || !buffer ) return 0;
@@ -760,9 +760,9 @@
{
do
{
- HFILE32 handle = CreateFile32A( buffer, GENERIC_WRITE, 0, NULL,
+ HFILE handle = CreateFileA( buffer, GENERIC_WRITE, 0, NULL,
CREATE_NEW, FILE_ATTRIBUTE_NORMAL, -1 );
- if (handle != INVALID_HANDLE_VALUE32)
+ if (handle != INVALID_HANDLE_VALUE)
{ /* We created it */
TRACE(file, "created %s\n",
buffer);
@@ -794,17 +794,17 @@
/***********************************************************************
* GetTempFileName32W (KERNEL32.291)
*/
-UINT32 WINAPI GetTempFileName32W( LPCWSTR path, LPCWSTR prefix, UINT32 unique,
+UINT WINAPI GetTempFileNameW( LPCWSTR path, LPCWSTR prefix, UINT unique,
LPWSTR buffer )
{
LPSTR patha,prefixa;
char buffera[144];
- UINT32 ret;
+ UINT ret;
if (!path) return 0;
patha = HEAP_strdupWtoA( GetProcessHeap(), 0, path );
prefixa = HEAP_strdupWtoA( GetProcessHeap(), 0, prefix );
- ret = GetTempFileName32A( patha, prefixa, unique, buffera );
+ ret = GetTempFileNameA( patha, prefixa, unique, buffera );
lstrcpyAtoW( buffer, buffera );
HeapFree( GetProcessHeap(), 0, patha );
HeapFree( GetProcessHeap(), 0, prefixa );
@@ -817,17 +817,17 @@
*
* Implementation of OpenFile16() and OpenFile32().
*/
-static HFILE32 FILE_DoOpenFile( LPCSTR name, OFSTRUCT *ofs, UINT32 mode,
- BOOL32 win32 )
+static HFILE FILE_DoOpenFile( LPCSTR name, OFSTRUCT *ofs, UINT mode,
+ BOOL win32 )
{
- HFILE32 hFileRet;
+ HFILE hFileRet;
FILETIME filetime;
WORD filedatetime[2];
DOS_FULL_NAME full_name;
DWORD access, sharing;
char *p;
- if (!ofs) return HFILE_ERROR32;
+ if (!ofs) return HFILE_ERROR;
ofs->cBytes = sizeof(OFSTRUCT);
ofs->nErrCode = 0;
@@ -835,7 +835,7 @@
if (!name) {
ERR(file, "called with `name' set to NULL ! Please debug.\n");
- return HFILE_ERROR32;
+ return HFILE_ERROR;
}
TRACE(file, "%s %04x\n", name, mode );
@@ -843,7 +843,7 @@
/* the watcom 10.6 IDE relies on a valid path returned in ofs->szPathName
Are there any cases where getting the path here is wrong?
Uwe Bonnes 1997 Apr 2 */
- if (!GetFullPathName32A( name, sizeof(ofs->szPathName),
+ if (!GetFullPathNameA( name, sizeof(ofs->szPathName),
ofs->szPathName, NULL )) goto error;
FILE_ConvertOFMode( mode, &access, &sharing );
@@ -863,9 +863,9 @@
if (mode & OF_CREATE)
{
- if ((hFileRet = CreateFile32A( name, GENERIC_READ | GENERIC_WRITE,
+ if ((hFileRet = CreateFileA( name, GENERIC_READ | GENERIC_WRITE,
sharing, NULL, CREATE_ALWAYS,
- FILE_ATTRIBUTE_NORMAL, -1 ))== INVALID_HANDLE_VALUE32)
+ FILE_ATTRIBUTE_NORMAL, -1 ))== INVALID_HANDLE_VALUE)
goto error;
goto success;
}
@@ -890,7 +890,7 @@
found:
TRACE(file, "found %s = %s\n",
full_name.long_name, full_name.short_name );
- lstrcpyn32A( ofs->szPathName, full_name.short_name,
+ lstrcpynA( ofs->szPathName, full_name.short_name,
sizeof(ofs->szPathName) );
if (mode & OF_SHARE_EXCLUSIVE)
@@ -911,7 +911,7 @@
if (GetModuleHandle16(last+1))
{
TRACE(file,"Denying shared open for %s\n",full_name.long_name);
- return HFILE_ERROR32;
+ return HFILE_ERROR;
}
}
@@ -924,7 +924,7 @@
hFileRet = FILE_CreateFile( full_name.long_name, access, sharing,
NULL, OPEN_EXISTING, 0, -1 );
- if (hFileRet == HFILE_ERROR32) goto not_found;
+ if (hFileRet == HFILE_ERROR) goto not_found;
GetFileTime( hFileRet, NULL, NULL, &filetime );
FileTimeToDosDateTime( &filetime, &filedatetime[0], &filedatetime[1] );
@@ -966,7 +966,7 @@
ofs->nErrCode = GetLastError();
WARN(file, "(%s): return = HFILE_ERROR error= %d\n",
name,ofs->nErrCode );
- return HFILE_ERROR32;
+ return HFILE_ERROR;
}
@@ -982,7 +982,7 @@
/***********************************************************************
* OpenFile32 (KERNEL32.396)
*/
-HFILE32 WINAPI OpenFile32( LPCSTR name, OFSTRUCT *ofs, UINT32 mode )
+HFILE WINAPI OpenFile( LPCSTR name, OFSTRUCT *ofs, UINT mode )
{
return FILE_DoOpenFile( name, ofs, mode, TRUE );
}
@@ -994,8 +994,8 @@
* Allocates the default DOS handles for a process. Called either by
* AllocDosHandle below or by the DOSVM stuff.
*/
-BOOL32 FILE_InitProcessDosHandles( void ) {
- HANDLE32 *ptr;
+BOOL FILE_InitProcessDosHandles( void ) {
+ HANDLE *ptr;
if (!(ptr = HeapAlloc( SystemHeap, HEAP_ZERO_MEMORY,
sizeof(*ptr) * DOS_TABLE_SIZE )))
@@ -1015,12 +1015,12 @@
* Allocate a DOS handle for a Win32 handle. The Win32 handle is no
* longer valid after this function (even on failure).
*/
-HFILE16 FILE_AllocDosHandle( HANDLE32 handle )
+HFILE16 FILE_AllocDosHandle( HANDLE handle )
{
int i;
- HANDLE32 *ptr = PROCESS_Current()->dos_handles;
+ HANDLE *ptr = PROCESS_Current()->dos_handles;
- if (!handle || (handle == INVALID_HANDLE_VALUE32))
+ if (!handle || (handle == INVALID_HANDLE_VALUE))
return INVALID_HANDLE_VALUE16;
if (!ptr) {
@@ -1048,13 +1048,13 @@
*
* Return the Win32 handle for a DOS handle.
*/
-HANDLE32 FILE_GetHandle32( HFILE16 hfile )
+HANDLE FILE_GetHandle( HFILE16 hfile )
{
- HANDLE32 *table = PROCESS_Current()->dos_handles;
+ HANDLE *table = PROCESS_Current()->dos_handles;
if ((hfile >= DOS_TABLE_SIZE) || !table || !table[hfile])
{
SetLastError( ERROR_INVALID_HANDLE );
- return INVALID_HANDLE_VALUE32;
+ return INVALID_HANDLE_VALUE;
}
return table[hfile];
}
@@ -1067,8 +1067,8 @@
*/
HFILE16 FILE_Dup2( HFILE16 hFile1, HFILE16 hFile2 )
{
- HANDLE32 *table = PROCESS_Current()->dos_handles;
- HANDLE32 new_handle;
+ HANDLE *table = PROCESS_Current()->dos_handles;
+ HANDLE new_handle;
if ((hFile1 >= DOS_TABLE_SIZE) || (hFile2 >= DOS_TABLE_SIZE) ||
!table || !table[hFile1])
@@ -1097,7 +1097,7 @@
*/
HFILE16 WINAPI _lclose16( HFILE16 hFile )
{
- HANDLE32 *table = PROCESS_Current()->dos_handles;
+ HANDLE *table = PROCESS_Current()->dos_handles;
if (hFile < 5)
{
@@ -1120,17 +1120,17 @@
/***********************************************************************
* _lclose32 (KERNEL32.592)
*/
-HFILE32 WINAPI _lclose32( HFILE32 hFile )
+HFILE WINAPI _lclose( HFILE hFile )
{
TRACE(file, "handle %d\n", hFile );
- return CloseHandle( hFile ) ? 0 : HFILE_ERROR32;
+ return CloseHandle( hFile ) ? 0 : HFILE_ERROR;
}
/***********************************************************************
* ReadFile (KERNEL32.428)
*/
-BOOL32 WINAPI ReadFile( HANDLE32 hFile, LPVOID buffer, DWORD bytesToRead,
+BOOL WINAPI ReadFile( HANDLE hFile, LPVOID buffer, DWORD bytesToRead,
LPDWORD bytesRead, LPOVERLAPPED overlapped )
{
struct get_read_fd_request req;
@@ -1164,7 +1164,7 @@
/***********************************************************************
* WriteFile (KERNEL32.578)
*/
-BOOL32 WINAPI WriteFile( HANDLE32 hFile, LPCVOID buffer, DWORD bytesToWrite,
+BOOL WINAPI WriteFile( HANDLE hFile, LPCVOID buffer, DWORD bytesToWrite,
LPDWORD bytesWritten, LPOVERLAPPED overlapped )
{
struct get_write_fd_request req;
@@ -1206,9 +1206,9 @@
hFile, (DWORD)buffer, count );
/* Some programs pass a count larger than the allocated buffer */
- maxlen = GetSelectorLimit( SELECTOROF(buffer) ) - OFFSETOF(buffer) + 1;
+ maxlen = GetSelectorLimit16( SELECTOROF(buffer) ) - OFFSETOF(buffer) + 1;
if (count > maxlen) count = maxlen;
- return _lread32(FILE_GetHandle32(hFile), PTR_SEG_TO_LIN(buffer), count );
+ return _lread(FILE_GetHandle(hFile), PTR_SEG_TO_LIN(buffer), count );
}
@@ -1224,7 +1224,7 @@
/***********************************************************************
* _lread32 (KERNEL32.596)
*/
-UINT32 WINAPI _lread32( HFILE32 handle, LPVOID buffer, UINT32 count )
+UINT WINAPI _lread( HFILE handle, LPVOID buffer, UINT count )
{
DWORD result;
if (!ReadFile( handle, buffer, count, &result, NULL )) return -1;
@@ -1237,7 +1237,7 @@
*/
UINT16 WINAPI _lread16( HFILE16 hFile, LPVOID buffer, UINT16 count )
{
- return (UINT16)_lread32(FILE_GetHandle32(hFile), buffer, (LONG)count );
+ return (UINT16)_lread(FILE_GetHandle(hFile), buffer, (LONG)count );
}
@@ -1247,17 +1247,17 @@
HFILE16 WINAPI _lcreat16( LPCSTR path, INT16 attr )
{
TRACE(file, "%s %02x\n", path, attr );
- return FILE_AllocDosHandle( _lcreat32( path, attr ) );
+ return FILE_AllocDosHandle( _lcreat( path, attr ) );
}
/***********************************************************************
* _lcreat32 (KERNEL32.593)
*/
-HFILE32 WINAPI _lcreat32( LPCSTR path, INT32 attr )
+HFILE WINAPI _lcreat( LPCSTR path, INT attr )
{
TRACE(file, "%s %02x\n", path, attr );
- return CreateFile32A( path, GENERIC_READ | GENERIC_WRITE,
+ return CreateFileA( path, GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
CREATE_ALWAYS, attr, -1 );
}
@@ -1266,10 +1266,10 @@
/***********************************************************************
* _lcreat16_uniq (Not a Windows API)
*/
-HFILE16 _lcreat16_uniq( LPCSTR path, INT32 attr )
+HFILE16 _lcreat16_uniq( LPCSTR path, INT attr )
{
TRACE(file, "%s %02x\n", path, attr );
- return FILE_AllocDosHandle( CreateFile32A( path, GENERIC_READ | GENERIC_WRITE,
+ return FILE_AllocDosHandle( CreateFileA( path, GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
CREATE_NEW, attr, -1 ));
}
@@ -1278,7 +1278,7 @@
/***********************************************************************
* SetFilePointer (KERNEL32.492)
*/
-DWORD WINAPI SetFilePointer( HFILE32 hFile, LONG distance, LONG *highword,
+DWORD WINAPI SetFilePointer( HFILE hFile, LONG distance, LONG *highword,
DWORD method )
{
struct set_file_pointer_request req;
@@ -1318,14 +1318,14 @@
*/
LONG WINAPI _llseek16( HFILE16 hFile, LONG lOffset, INT16 nOrigin )
{
- return SetFilePointer( FILE_GetHandle32(hFile), lOffset, NULL, nOrigin );
+ return SetFilePointer( FILE_GetHandle(hFile), lOffset, NULL, nOrigin );
}
/***********************************************************************
* _llseek32 (KERNEL32.594)
*/
-LONG WINAPI _llseek32( HFILE32 hFile, LONG lOffset, INT32 nOrigin )
+LONG WINAPI _llseek( HFILE hFile, LONG lOffset, INT nOrigin )
{
return SetFilePointer( hFile, lOffset, NULL, nOrigin );
}
@@ -1336,20 +1336,20 @@
*/
HFILE16 WINAPI _lopen16( LPCSTR path, INT16 mode )
{
- return FILE_AllocDosHandle( _lopen32( path, mode ) );
+ return FILE_AllocDosHandle( _lopen( path, mode ) );
}
/***********************************************************************
* _lopen32 (KERNEL32.595)
*/
-HFILE32 WINAPI _lopen32( LPCSTR path, INT32 mode )
+HFILE WINAPI _lopen( LPCSTR path, INT mode )
{
DWORD access, sharing;
TRACE(file, "('%s',%04x)\n", path, mode );
FILE_ConvertOFMode( mode, &access, &sharing );
- return CreateFile32A( path, access, sharing, NULL, OPEN_EXISTING, 0, -1 );
+ return CreateFileA( path, access, sharing, NULL, OPEN_EXISTING, 0, -1 );
}
@@ -1358,15 +1358,15 @@
*/
UINT16 WINAPI _lwrite16( HFILE16 hFile, LPCSTR buffer, UINT16 count )
{
- return (UINT16)_hwrite32( FILE_GetHandle32(hFile), buffer, (LONG)count );
+ return (UINT16)_hwrite( FILE_GetHandle(hFile), buffer, (LONG)count );
}
/***********************************************************************
* _lwrite32 (KERNEL32.761)
*/
-UINT32 WINAPI _lwrite32( HFILE32 hFile, LPCSTR buffer, UINT32 count )
+UINT WINAPI _lwrite( HFILE hFile, LPCSTR buffer, UINT count )
{
- return (UINT32)_hwrite32( hFile, buffer, (LONG)count );
+ return (UINT)_hwrite( hFile, buffer, (LONG)count );
}
@@ -1375,16 +1375,16 @@
*/
LONG WINAPI _hread16( HFILE16 hFile, LPVOID buffer, LONG count)
{
- return _lread32( FILE_GetHandle32(hFile), buffer, count );
+ return _lread( FILE_GetHandle(hFile), buffer, count );
}
/***********************************************************************
* _hread32 (KERNEL32.590)
*/
-LONG WINAPI _hread32( HFILE32 hFile, LPVOID buffer, LONG count)
+LONG WINAPI _hread( HFILE hFile, LPVOID buffer, LONG count)
{
- return _lread32( hFile, buffer, count );
+ return _lread( hFile, buffer, count );
}
@@ -1393,7 +1393,7 @@
*/
LONG WINAPI _hwrite16( HFILE16 hFile, LPCSTR buffer, LONG count )
{
- return _hwrite32( FILE_GetHandle32(hFile), buffer, count );
+ return _hwrite( FILE_GetHandle(hFile), buffer, count );
}
@@ -1407,7 +1407,7 @@
* o works with console handles
*
*/
-LONG WINAPI _hwrite32( HFILE32 handle, LPCSTR buffer, LONG count )
+LONG WINAPI _hwrite( HFILE handle, LPCSTR buffer, LONG count )
{
DWORD result;
@@ -1416,11 +1416,11 @@
if (!count)
{
/* Expand or truncate at current position */
- if (!SetEndOfFile( handle )) return HFILE_ERROR32;
+ if (!SetEndOfFile( handle )) return HFILE_ERROR;
return 0;
}
if (!WriteFile( handle, buffer, count, &result, NULL ))
- return HFILE_ERROR32;
+ return HFILE_ERROR;
return result;
}
@@ -1430,8 +1430,8 @@
*/
UINT16 WINAPI SetHandleCount16( UINT16 count )
{
- HGLOBAL16 hPDB = GetCurrentPDB();
- PDB *pdb = (PDB *)GlobalLock16( hPDB );
+ HGLOBAL16 hPDB = GetCurrentPDB16();
+ PDB16 *pdb = (PDB16 *)GlobalLock16( hPDB );
BYTE *files = PTR_SEG_TO_LIN( pdb->fileHandlesPtr );
TRACE(file, "(%d)\n", count );
@@ -1446,7 +1446,7 @@
memcpy( pdb->fileHandles, files, 20 );
GlobalFree16( pdb->hFileHandles );
pdb->fileHandlesPtr = (SEGPTR)MAKELONG( 0x18,
- GlobalHandleToSel( hPDB ) );
+ GlobalHandleToSel16( hPDB ) );
pdb->hFileHandles = 0;
pdb->nbFiles = 20;
}
@@ -1480,7 +1480,7 @@
/*************************************************************************
* SetHandleCount32 (KERNEL32.494)
*/
-UINT32 WINAPI SetHandleCount32( UINT32 count )
+UINT WINAPI SetHandleCount( UINT count )
{
return MIN( 256, count );
}
@@ -1489,7 +1489,7 @@
/***********************************************************************
* FlushFileBuffers (KERNEL32.133)
*/
-BOOL32 WINAPI FlushFileBuffers( HFILE32 hFile )
+BOOL WINAPI FlushFileBuffers( HFILE hFile )
{
struct flush_file_request req;
@@ -1504,7 +1504,7 @@
/**************************************************************************
* SetEndOfFile (KERNEL32.483)
*/
-BOOL32 WINAPI SetEndOfFile( HFILE32 hFile )
+BOOL WINAPI SetEndOfFile( HFILE hFile )
{
struct truncate_file_request req;
@@ -1521,14 +1521,14 @@
*/
BOOL16 WINAPI DeleteFile16( LPCSTR path )
{
- return DeleteFile32A( path );
+ return DeleteFileA( path );
}
/***********************************************************************
* DeleteFile32A (KERNEL32.71)
*/
-BOOL32 WINAPI DeleteFile32A( LPCSTR path )
+BOOL WINAPI DeleteFileA( LPCSTR path )
{
DOS_FULL_NAME full_name;
@@ -1559,10 +1559,10 @@
/***********************************************************************
* DeleteFile32W (KERNEL32.72)
*/
-BOOL32 WINAPI DeleteFile32W( LPCWSTR path )
+BOOL WINAPI DeleteFileW( LPCWSTR path )
{
LPSTR xpath = HEAP_strdupWtoA( GetProcessHeap(), 0, path );
- BOOL32 ret = DeleteFile32A( xpath );
+ BOOL ret = DeleteFileA( xpath );
HeapFree( GetProcessHeap(), 0, xpath );
return ret;
}
@@ -1662,7 +1662,7 @@
/***********************************************************************
* GetFileType (KERNEL32.222)
*/
-DWORD WINAPI GetFileType( HFILE32 hFile )
+DWORD WINAPI GetFileType( HFILE hFile )
{
struct get_file_info_request req;
struct get_file_info_reply reply;
@@ -1680,7 +1680,7 @@
/**************************************************************************
* MoveFileEx32A (KERNEL32.???)
*/
-BOOL32 WINAPI MoveFileEx32A( LPCSTR fn1, LPCSTR fn2, DWORD flag )
+BOOL WINAPI MoveFileExA( LPCSTR fn1, LPCSTR fn2, DWORD flag )
{
DOS_FULL_NAME full_name1, full_name2;
int mode=0; /* mode == 1: use copy */
@@ -1750,18 +1750,18 @@
}
else return TRUE;
else /* copy File */
- return CopyFile32A(fn1, fn2, (!(flag & MOVEFILE_REPLACE_EXISTING)));
+ return CopyFileA(fn1, fn2, (!(flag & MOVEFILE_REPLACE_EXISTING)));
}
/**************************************************************************
* MoveFileEx32W (KERNEL32.???)
*/
-BOOL32 WINAPI MoveFileEx32W( LPCWSTR fn1, LPCWSTR fn2, DWORD flag )
+BOOL WINAPI MoveFileExW( LPCWSTR fn1, LPCWSTR fn2, DWORD flag )
{
LPSTR afn1 = HEAP_strdupWtoA( GetProcessHeap(), 0, fn1 );
LPSTR afn2 = HEAP_strdupWtoA( GetProcessHeap(), 0, fn2 );
- BOOL32 res = MoveFileEx32A( afn1, afn2, flag );
+ BOOL res = MoveFileExA( afn1, afn2, flag );
HeapFree( GetProcessHeap(), 0, afn1 );
HeapFree( GetProcessHeap(), 0, afn2 );
return res;
@@ -1773,7 +1773,7 @@
*
* Move file or directory
*/
-BOOL32 WINAPI MoveFile32A( LPCSTR fn1, LPCSTR fn2 )
+BOOL WINAPI MoveFileA( LPCSTR fn1, LPCSTR fn2 )
{
DOS_FULL_NAME full_name1, full_name2;
struct stat fstat;
@@ -1808,7 +1808,7 @@
return FALSE;
}
else
- return CopyFile32A(fn1, fn2, TRUE); /*fail, if exist */
+ return CopyFileA(fn1, fn2, TRUE); /*fail, if exist */
}
}
@@ -1816,11 +1816,11 @@
/**************************************************************************
* MoveFile32W (KERNEL32.390)
*/
-BOOL32 WINAPI MoveFile32W( LPCWSTR fn1, LPCWSTR fn2 )
+BOOL WINAPI MoveFileW( LPCWSTR fn1, LPCWSTR fn2 )
{
LPSTR afn1 = HEAP_strdupWtoA( GetProcessHeap(), 0, fn1 );
LPSTR afn2 = HEAP_strdupWtoA( GetProcessHeap(), 0, fn2 );
- BOOL32 res = MoveFile32A( afn1, afn2 );
+ BOOL res = MoveFileA( afn1, afn2 );
HeapFree( GetProcessHeap(), 0, afn1 );
HeapFree( GetProcessHeap(), 0, afn2 );
return res;
@@ -1830,35 +1830,35 @@
/**************************************************************************
* CopyFile32A (KERNEL32.36)
*/
-BOOL32 WINAPI CopyFile32A( LPCSTR source, LPCSTR dest, BOOL32 fail_if_exists )
+BOOL WINAPI CopyFileA( LPCSTR source, LPCSTR dest, BOOL fail_if_exists )
{
- HFILE32 h1, h2;
+ HFILE h1, h2;
BY_HANDLE_FILE_INFORMATION info;
- UINT32 count;
- BOOL32 ret = FALSE;
+ UINT count;
+ BOOL ret = FALSE;
int mode;
char buffer[2048];
- if ((h1 = _lopen32( source, OF_READ )) == HFILE_ERROR32) return FALSE;
+ if ((h1 = _lopen( source, OF_READ )) == HFILE_ERROR) return FALSE;
if (!GetFileInformationByHandle( h1, &info ))
{
CloseHandle( h1 );
return FALSE;
}
mode = (info.dwFileAttributes & FILE_ATTRIBUTE_READONLY) ? 0444 : 0666;
- if ((h2 = CreateFile32A( dest, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
+ if ((h2 = CreateFileA( dest, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
fail_if_exists ? CREATE_NEW : CREATE_ALWAYS,
- info.dwFileAttributes, h1 )) == HFILE_ERROR32)
+ info.dwFileAttributes, h1 )) == HFILE_ERROR)
{
CloseHandle( h1 );
return FALSE;
}
- while ((count = _lread32( h1, buffer, sizeof(buffer) )) > 0)
+ while ((count = _lread( h1, buffer, sizeof(buffer) )) > 0)
{
char *p = buffer;
while (count > 0)
{
- INT32 res = _lwrite32( h2, p, count );
+ INT res = _lwrite( h2, p, count );
if (res <= 0) goto done;
p += res;
count -= res;
@@ -1875,11 +1875,11 @@
/**************************************************************************
* CopyFile32W (KERNEL32.37)
*/
-BOOL32 WINAPI CopyFile32W( LPCWSTR source, LPCWSTR dest, BOOL32 fail_if_exists)
+BOOL WINAPI CopyFileW( LPCWSTR source, LPCWSTR dest, BOOL fail_if_exists)
{
LPSTR sourceA = HEAP_strdupWtoA( GetProcessHeap(), 0, source );
LPSTR destA = HEAP_strdupWtoA( GetProcessHeap(), 0, dest );
- BOOL32 ret = CopyFile32A( sourceA, destA, fail_if_exists );
+ BOOL ret = CopyFileA( sourceA, destA, fail_if_exists );
HeapFree( GetProcessHeap(), 0, sourceA );
HeapFree( GetProcessHeap(), 0, destA );
return ret;
@@ -1893,14 +1893,14 @@
* the "ex" version of the method and calls the CopyFile method.
* It will have to be fixed eventually.
*/
-BOOL32 WINAPI CopyFileEx32A(LPCSTR sourceFilename,
+BOOL WINAPI CopyFileExA(LPCSTR sourceFilename,
LPCSTR destFilename,
LPPROGRESS_ROUTINE progressRoutine,
LPVOID appData,
- LPBOOL32 cancelFlagPointer,
+ LPBOOL cancelFlagPointer,
DWORD copyFlags)
{
- BOOL32 failIfExists = FALSE;
+ BOOL failIfExists = FALSE;
/*
* Interpret the only flag that CopyFile can interpret.
@@ -1910,23 +1910,23 @@
failIfExists = TRUE;
}
- return CopyFile32A(sourceFilename, destFilename, failIfExists);
+ return CopyFileA(sourceFilename, destFilename, failIfExists);
}
/**************************************************************************
* CopyFileEx32W (KERNEL32.859)
*/
-BOOL32 WINAPI CopyFileEx32W(LPCWSTR sourceFilename,
+BOOL WINAPI CopyFileExW(LPCWSTR sourceFilename,
LPCWSTR destFilename,
LPPROGRESS_ROUTINE progressRoutine,
LPVOID appData,
- LPBOOL32 cancelFlagPointer,
+ LPBOOL cancelFlagPointer,
DWORD copyFlags)
{
LPSTR sourceA = HEAP_strdupWtoA( GetProcessHeap(), 0, sourceFilename );
LPSTR destA = HEAP_strdupWtoA( GetProcessHeap(), 0, destFilename );
- BOOL32 ret = CopyFileEx32A(sourceA,
+ BOOL ret = CopyFileExA(sourceA,
destA,
progressRoutine,
appData,
@@ -1943,7 +1943,7 @@
/***********************************************************************
* SetFileTime (KERNEL32.650)
*/
-BOOL32 WINAPI SetFileTime( HFILE32 hFile,
+BOOL WINAPI SetFileTime( HFILE hFile,
const FILETIME *lpCreationTime,
const FILETIME *lpLastAccessTime,
const FILETIME *lpLastWriteTime )
@@ -1970,7 +1970,7 @@
/**************************************************************************
* LockFile (KERNEL32.511)
*/
-BOOL32 WINAPI LockFile( HFILE32 hFile, DWORD dwFileOffsetLow, DWORD dwFileOffsetHigh,
+BOOL WINAPI LockFile( HFILE hFile, DWORD dwFileOffsetLow, DWORD dwFileOffsetHigh,
DWORD nNumberOfBytesToLockLow, DWORD nNumberOfBytesToLockHigh )
{
struct lock_file_request req;
@@ -1990,7 +1990,7 @@
/**************************************************************************
* UnlockFile (KERNEL32.703)
*/
-BOOL32 WINAPI UnlockFile( HFILE32 hFile, DWORD dwFileOffsetLow, DWORD dwFileOffsetHigh,
+BOOL WINAPI UnlockFile( HFILE hFile, DWORD dwFileOffsetLow, DWORD dwFileOffsetHigh,
DWORD nNumberOfBytesToUnlockLow, DWORD nNumberOfBytesToUnlockHigh )
{
struct unlock_file_request req;
@@ -2031,7 +2031,7 @@
* how critical that is at this point (FIXME).
*/
-static BOOL32 DOS_AddLock(FILE_OBJECT *file, struct flock *f)
+static BOOL DOS_AddLock(FILE_OBJECT *file, struct flock *f)
{
DOS_FILE_LOCK *curr;
DWORD processId;
@@ -2084,7 +2084,7 @@
}
}
-static BOOL32 DOS_RemoveLock(FILE_OBJECT *file, struct flock *f)
+static BOOL DOS_RemoveLock(FILE_OBJECT *file, struct flock *f)
{
DWORD processId;
DOS_FILE_LOCK **curr;
@@ -2112,8 +2112,8 @@
/**************************************************************************
* LockFile (KERNEL32.511)
*/
-BOOL32 WINAPI LockFile(
- HFILE32 hFile,DWORD dwFileOffsetLow,DWORD dwFileOffsetHigh,
+BOOL WINAPI LockFile(
+ HFILE hFile,DWORD dwFileOffsetLow,DWORD dwFileOffsetHigh,
DWORD nNumberOfBytesToLockLow,DWORD nNumberOfBytesToLockHigh )
{
struct flock f;
@@ -2163,8 +2163,8 @@
/**************************************************************************
* UnlockFile (KERNEL32.703)
*/
-BOOL32 WINAPI UnlockFile(
- HFILE32 hFile,DWORD dwFileOffsetLow,DWORD dwFileOffsetHigh,
+BOOL WINAPI UnlockFile(
+ HFILE hFile,DWORD dwFileOffsetLow,DWORD dwFileOffsetHigh,
DWORD nNumberOfBytesToUnlockLow,DWORD nNumberOfBytesToUnlockHigh )
{
FILE_OBJECT *file;
@@ -2203,7 +2203,7 @@
/**************************************************************************
* GetFileAttributesEx32A [KERNEL32.874]
*/
-BOOL32 WINAPI GetFileAttributesEx32A(
+BOOL WINAPI GetFileAttributesExA(
LPCSTR lpFileName, GET_FILEEX_INFO_LEVELS fInfoLevelId,
LPVOID lpFileInformation)
{
@@ -2238,13 +2238,13 @@
/**************************************************************************
* GetFileAttributesEx32W [KERNEL32.875]
*/
-BOOL32 WINAPI GetFileAttributesEx32W(
+BOOL WINAPI GetFileAttributesExW(
LPCWSTR lpFileName, GET_FILEEX_INFO_LEVELS fInfoLevelId,
LPVOID lpFileInformation)
{
LPSTR nameA = HEAP_strdupWtoA( GetProcessHeap(), 0, lpFileName );
- BOOL32 res =
- GetFileAttributesEx32A( nameA, fInfoLevelId, lpFileInformation);
+ BOOL res =
+ GetFileAttributesExA( nameA, fInfoLevelId, lpFileInformation);
HeapFree( GetProcessHeap(), 0, nameA );
return res;
}
