/* 
   ASCIIFunctions.h

   Declarations for all the Win32 ASCII Functions

   Copyright (C) 1996, 1997, 1998 Free Software Foundation, Inc.

   Author:  Scott Christley <scottc@net-community.com>

   This file is part of the Windows32 API Library.

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
   
   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.

   If you are interested in a warranty or support for this source code,
   contact Scott Christley <scottc@net-community.com> for more information.
   
   You should have received a copy of the GNU Library General Public
   License along with this library; see the file COPYING.LIB.
   If not, write to the Free Software Foundation, 
   59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/ 

#ifndef _GNU_H_WINDOWS32_ASCIIFUNCTIONS
#define _GNU_H_WINDOWS32_ASCIIFUNCTIONS

/* This keeps all this stuff from bugging the resource compiler. */
#ifndef	RC_INVOKED

#include <stdarg.h>
#include "Defines.h"
#include "Base.h"
#include "wstructs.h"

#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */

WINBOOL
STDCALL
GetBinaryTypeA(
	       LPCSTR lpApplicationName,
	       LPDWORD lpBinaryType
	       ) {}

DWORD
STDCALL
GetShortPathNameA(
		  LPCSTR lpszLongPath,
		  LPSTR  lpszShortPath,
		  DWORD    cchBuffer
		  ) {}

LPSTR
STDCALL
GetEnvironmentStringsA(
		       VOID
		       ) {}

WINBOOL
STDCALL
FreeEnvironmentStringsA(
			LPSTR str
			) {}

DWORD
STDCALL
FormatMessageA(
	       DWORD dwFlags,
	       LPCVOID lpSource,
	       DWORD dwMessageId,
	       DWORD dwLanguageId,
	       LPSTR lpBuffer,
	       DWORD nSize,
	       va_list *Arguments
	       ) {}

HANDLE
STDCALL
CreateMailslotA(
		LPCSTR lpName,
		DWORD nMaxMessageSize,
		DWORD lReadTimeout,
		LPSECURITY_ATTRIBUTES lpSecurityAttributes
		) {}

int
STDCALL
lstrcmpA(
	 LPCSTR lpString1,
	 LPCSTR lpString2
	 ) {}

int
STDCALL
lstrcmpiA(
	  LPCSTR lpString1,
	  LPCSTR lpString2
	  ) {}

LPSTR
STDCALL
lstrcpynA(
	  LPSTR lpString1,
	  LPCSTR lpString2,
	  int iMaxLength
	  ) {}

LPSTR
STDCALL
lstrcpyA(
	 LPSTR lpString1,
	 LPCSTR lpString2
	 ) {}

LPSTR
STDCALL
lstrcatA(
	 LPSTR lpString1,
	 LPCSTR lpString2
	 ) {}

int
STDCALL
lstrlenA(
	 LPCSTR lpString
	 ) {}

HANDLE
STDCALL
CreateMutexA(
	     LPSECURITY_ATTRIBUTES lpMutexAttributes,
	     WINBOOL bInitialOwner,
	     LPCSTR lpName
	     ) {}

HANDLE
STDCALL
OpenMutexA(
	   DWORD dwDesiredAccess,
	   WINBOOL bInheritHandle,
	   LPCSTR lpName
	   ) {}

HANDLE
STDCALL
CreateEventA(
	     LPSECURITY_ATTRIBUTES lpEventAttributes,
	     WINBOOL bManualReset,
	     WINBOOL bInitialState,
	     LPCSTR lpName
	     ) {}

HANDLE
STDCALL
OpenEventA(
	   DWORD dwDesiredAccess,
	   WINBOOL bInheritHandle,
	   LPCSTR lpName
	   ) {}

HANDLE
STDCALL
CreateSemaphoreA(
		 LPSECURITY_ATTRIBUTES lpSemaphoreAttributes,
		 LONG lInitialCount,
		 LONG lMaximumCount,
		 LPCSTR lpName
		 ) {}

HANDLE
STDCALL
OpenSemaphoreA(
	       DWORD dwDesiredAccess,
	       WINBOOL bInheritHandle,
	       LPCSTR lpName
	       ) {}

HANDLE
STDCALL
CreateFileMappingA(
		   HANDLE hFile,
		   LPSECURITY_ATTRIBUTES lpFileMappingAttributes,
		   DWORD flProtect,
		   DWORD dwMaximumSizeHigh,
		   DWORD dwMaximumSizeLow,
		   LPCSTR lpName
		   ) {}

HANDLE
STDCALL
OpenFileMappingA(
		 DWORD dwDesiredAccess,
		 WINBOOL bInheritHandle,
		 LPCSTR lpName
		 ) {}

DWORD
STDCALL
GetLogicalDriveStringsA(
			DWORD nBufferLength,
			LPSTR lpBuffer
			) {}

HINSTANCE
STDCALL
LoadLibraryA(
	     LPCSTR lpLibFileName
	     ) {}

HINSTANCE
STDCALL
LoadLibraryExA(
	       LPCSTR lpLibFileName,
	       HANDLE hFile,
	       DWORD dwFlags
	       ) {}

DWORD
STDCALL
GetModuleFileNameA(
		   HINSTANCE hModule,
		   LPSTR lpFilename,
		   DWORD nSize
		   ) {}

HMODULE
STDCALL
GetModuleHandleA(
		 LPCSTR lpModuleName
		 ) {}

VOID
STDCALL
FatalAppExitA(
	      UINT uAction,
	      LPCSTR lpMessageText
	      ) {}

LPSTR
STDCALL
GetCommandLineA(
		VOID
		) {}

DWORD
STDCALL
GetEnvironmentVariableA(
			LPCSTR lpName,
			LPSTR lpBuffer,
			DWORD nSize
			) {}

WINBOOL
STDCALL
SetEnvironmentVariableA(
			LPCSTR lpName,
			LPCSTR lpValue
			) {}

DWORD
STDCALL
ExpandEnvironmentStringsA(
			  LPCSTR lpSrc,
			  LPSTR lpDst,
			  DWORD nSize
			  ) {}

VOID
STDCALL
OutputDebugStringA(
		   LPCSTR lpOutputString
		   ) {}

HRSRC
STDCALL
FindResourceA(
	      HINSTANCE hModule,
	      LPCSTR lpName,
	      LPCSTR lpType
	      ) {}

HRSRC
STDCALL
FindResourceExA(
		HINSTANCE hModule,
		LPCSTR lpType,
		LPCSTR lpName,
		WORD    wLanguage
		) {}

WINBOOL
STDCALL
EnumResourceTypesA(
		   HINSTANCE hModule,
		   ENUMRESTYPEPROC lpEnumFunc,
		   LONG lParam
		   ) {}

WINBOOL
STDCALL
EnumResourceNamesA(
		   HINSTANCE hModule,
		   LPCSTR lpType,
		   ENUMRESNAMEPROC lpEnumFunc,
		   LONG lParam
		   ) {}

WINBOOL
STDCALL
EnumResourceLanguagesA(
		       HINSTANCE hModule,
		       LPCSTR lpType,
		       LPCSTR lpName,
		       ENUMRESLANGPROC lpEnumFunc,
		       LONG lParam
		       ) {}

HANDLE
STDCALL
BeginUpdateResourceA(
		     LPCSTR pFileName,
		     WINBOOL bDeleteExistingResources
		     ) {}

WINBOOL
STDCALL
UpdateResourceA(
		HANDLE      hUpdate,
		LPCSTR     lpType,
		LPCSTR     lpName,
		WORD        wLanguage,
		LPVOID      lpData,
		DWORD       cbData
		) {}

WINBOOL
STDCALL
EndUpdateResourceA(
		   HANDLE      hUpdate,
		   WINBOOL        fDiscard
		   ) {}

ATOM
STDCALL
GlobalAddAtomA(
	       LPCSTR lpString
	       ) {}

ATOM
STDCALL
GlobalFindAtomA(
		LPCSTR lpString
		) {}

UINT
STDCALL
GlobalGetAtomNameA(
		   ATOM nAtom,
		   LPSTR lpBuffer,
		   int nSize
		   ) {}

ATOM
STDCALL
AddAtomA(
	 LPCSTR lpString
	 ) {}

ATOM
STDCALL
FindAtomA(
	  LPCSTR lpString
	  ) {}

UINT
STDCALL
GetAtomNameA(
	     ATOM nAtom,
	     LPSTR lpBuffer,
	     int nSize
	     ) {}

UINT
STDCALL
GetProfileIntA(
	       LPCSTR lpAppName,
	       LPCSTR lpKeyName,
	       INT nDefault
	       ) {}

DWORD
STDCALL
GetProfileStringA(
		  LPCSTR lpAppName,
		  LPCSTR lpKeyName,
		  LPCSTR lpDefault,
		  LPSTR lpReturnedString,
		  DWORD nSize
		  ) {}

WINBOOL
STDCALL
WriteProfileStringA(
    LPCSTR lpAppName,
    LPCSTR lpKeyName,
    LPCSTR lpString
    ) {}

DWORD
STDCALL
GetProfileSectionA(
    LPCSTR lpAppName,
    LPSTR lpReturnedString,
    DWORD nSize
    ) {}

WINBOOL
STDCALL
WriteProfileSectionA(
    LPCSTR lpAppName,
    LPCSTR lpString
    ) {}

UINT
STDCALL
GetPrivateProfileIntA(
    LPCSTR lpAppName,
    LPCSTR lpKeyName,
    INT nDefault,
    LPCSTR lpFileName
    ) {}

DWORD
STDCALL
GetPrivateProfileStringA(
    LPCSTR lpAppName,
    LPCSTR lpKeyName,
    LPCSTR lpDefault,
    LPSTR lpReturnedString,
    DWORD nSize,
    LPCSTR lpFileName
    ) {}

WINBOOL
STDCALL
WritePrivateProfileStringA(
    LPCSTR lpAppName,
    LPCSTR lpKeyName,
    LPCSTR lpString,
    LPCSTR lpFileName
    ) {}

DWORD
STDCALL
GetPrivateProfileSectionA(
    LPCSTR lpAppName,
    LPSTR lpReturnedString,
    DWORD nSize,
    LPCSTR lpFileName
    ) {}

WINBOOL
STDCALL
WritePrivateProfileSectionA(
    LPCSTR lpAppName,
    LPCSTR lpString,
    LPCSTR lpFileName
    ) {}

UINT
STDCALL
GetDriveTypeA(
    LPCSTR lpRootPathName
    ) {}

UINT
STDCALL
GetSystemDirectoryA(
    LPSTR lpBuffer,
    UINT uSize
    ) {}

DWORD
STDCALL
GetTempPathA(
    DWORD nBufferLength,
    LPSTR lpBuffer
    ) {}

UINT
STDCALL
GetTempFileNameA(
    LPCSTR lpPathName,
    LPCSTR lpPrefixString,
    UINT uUnique,
    LPSTR lpTempFileName
    ) {}

UINT
STDCALL
GetWindowsDirectoryA(
    LPSTR lpBuffer,
    UINT uSize
    ) {}

WINBOOL
STDCALL
SetCurrentDirectoryA(
    LPCSTR lpPathName
    ) {}

DWORD
STDCALL
GetCurrentDirectoryA(
    DWORD nBufferLength,
    LPSTR lpBuffer
    ) {}

WINBOOL
STDCALL
GetDiskFreeSpaceA(
    LPCSTR lpRootPathName,
    LPDWORD lpSectorsPerCluster,
    LPDWORD lpBytesPerSector,
    LPDWORD lpNumberOfFreeClusters,
    LPDWORD lpTotalNumberOfClusters
    ) {}

WINBOOL
STDCALL
GetDiskFreeSpaceExA(
    LPCSTR lpDirectoryName,
    PULARGE_INTEGER lpFreeBytesAvailableToCaller,
    PULARGE_INTEGER lpTotalNumberOfBytes,
    PULARGE_INTEGER lpTotalNumberOfFreeBytes
    ) {}

WINBOOL
STDCALL
CreateDirectoryA(
    LPCSTR lpPathName,
    LPSECURITY_ATTRIBUTES lpSecurityAttributes
    ) {}

WINBOOL
STDCALL
CreateDirectoryExA(
    LPCSTR lpTemplateDirectory,
    LPCSTR lpNewDirectory,
    LPSECURITY_ATTRIBUTES lpSecurityAttributes
    ) {}

WINBOOL
STDCALL
RemoveDirectoryA(
    LPCSTR lpPathName
    ) {}

DWORD
STDCALL
GetFullPathNameA(
    LPCSTR lpFileName,
    DWORD nBufferLength,
    LPSTR lpBuffer,
    LPSTR *lpFilePart
    ) {}

WINBOOL
STDCALL
DefineDosDeviceA(
    DWORD dwFlags,
    LPCSTR lpDeviceName,
    LPCSTR lpTargetPath
    ) {}

DWORD
STDCALL
QueryDosDeviceA(
    LPCSTR lpDeviceName,
    LPSTR lpTargetPath,
    DWORD ucchMax
    ) {}

HANDLE
STDCALL
CreateFileA(
    LPCSTR lpFileName,
    DWORD dwDesiredAccess,
    DWORD dwShareMode,
    LPSECURITY_ATTRIBUTES lpSecurityAttributes,
    DWORD dwCreationDisposition,
    DWORD dwFlagsAndAttributes,
    HANDLE hTemplateFile
    ) {}

WINBOOL
STDCALL
SetFileAttributesA(
    LPCSTR lpFileName,
    DWORD dwFileAttributes
    ) {}

DWORD
STDCALL
GetFileAttributesA(
    LPCSTR lpFileName
    ) {}

DWORD
STDCALL
GetCompressedFileSizeA(
    LPCSTR lpFileName,
    LPDWORD lpFileSizeHigh
    ) {}

WINBOOL
STDCALL
DeleteFileA(
    LPCSTR lpFileName
    ) {}

DWORD
STDCALL
SearchPathA(
	    LPCSTR lpPath,
    LPCSTR lpFileName,
    LPCSTR lpExtension,
    DWORD nBufferLength,
    LPSTR lpBuffer,
    LPSTR *lpFilePart
    ) {}

WINBOOL
STDCALL
CopyFileA(
    LPCSTR lpExistingFileName,
    LPCSTR lpNewFileName,
    WINBOOL bFailIfExists
    ) {}

WINBOOL
STDCALL
MoveFileA(
    LPCSTR lpExistingFileName,
    LPCSTR lpNewFileName
    ) {}

WINBOOL
STDCALL
MoveFileExA(
    LPCSTR lpExistingFileName,
    LPCSTR lpNewFileName,
    DWORD dwFlags
    ) {}

HANDLE
STDCALL
CreateNamedPipeA(
    LPCSTR lpName,
    DWORD dwOpenMode,
    DWORD dwPipeMode,
    DWORD nMaxInstances,
    DWORD nOutBufferSize,
    DWORD nInBufferSize,
    DWORD nDefaultTimeOut,
    LPSECURITY_ATTRIBUTES lpSecurityAttributes
    ) {}

WINBOOL
STDCALL
GetNamedPipeHandleStateA(
    HANDLE hNamedPipe,
    LPDWORD lpState,
    LPDWORD lpCurInstances,
    LPDWORD lpMaxCollectionCount,
    LPDWORD lpCollectDataTimeout,
    LPSTR lpUserName,
    DWORD nMaxUserNameSize
    ) {}

WINBOOL
STDCALL
CallNamedPipeA(
    LPCSTR lpNamedPipeName,
    LPVOID lpInBuffer,
    DWORD nInBufferSize,
    LPVOID lpOutBuffer,
    DWORD nOutBufferSize,
    LPDWORD lpBytesRead,
    DWORD nTimeOut
    ) {}

WINBOOL
STDCALL
WaitNamedPipeA(
    LPCSTR lpNamedPipeName,
    DWORD nTimeOut
    ) {}

WINBOOL
STDCALL
SetVolumeLabelA(
    LPCSTR lpRootPathName,
    LPCSTR lpVolumeName
    ) {}

WINBOOL
STDCALL
GetVolumeInformationA(
    LPCSTR lpRootPathName,
    LPSTR lpVolumeNameBuffer,
    DWORD nVolumeNameSize,
    LPDWORD lpVolumeSerialNumber,
    LPDWORD lpMaximumComponentLength,
    LPDWORD lpFileSystemFlags,
    LPSTR lpFileSystemNameBuffer,
    DWORD nFileSystemNameSize
    ) {}

WINBOOL
STDCALL
ClearEventLogA (
    HANDLE hEventLog,
    LPCSTR lpBackupFileName
    ) {}

WINBOOL
STDCALL
BackupEventLogA (
    HANDLE hEventLog,
    LPCSTR lpBackupFileName
    ) {}

HANDLE
STDCALL
OpenEventLogA (
    LPCSTR lpUNCServerName,
    LPCSTR lpSourceName
    ) {}

HANDLE
STDCALL
RegisterEventSourceA (
    LPCSTR lpUNCServerName,
    LPCSTR lpSourceName
    ) {}

HANDLE
STDCALL
OpenBackupEventLogA (
    LPCSTR lpUNCServerName,
    LPCSTR lpFileName
    ) {}

WINBOOL
STDCALL
ReadEventLogA (
     HANDLE     hEventLog,
     DWORD      dwReadFlags,
     DWORD      dwRecordOffset,
     LPVOID     lpBuffer,
     DWORD      nNumberOfBytesToRead,
     DWORD      *pnBytesRead,
     DWORD      *pnMinNumberOfBytesNeeded
    ) {}

WINBOOL
STDCALL
ReportEventA (
     HANDLE     hEventLog,
     WORD       wType,
     WORD       wCategory,
     DWORD      dwEventID,
     PSID       lpUserSid,
     WORD       wNumStrings,
     DWORD      dwDataSize,
     LPCSTR   *lpStrings,
     LPVOID     lpRawData
    ) {}

WINBOOL
STDCALL
AccessCheckAndAuditAlarmA (
    LPCSTR SubsystemName,
    LPVOID HandleId,
    LPSTR ObjectTypeName,
    LPSTR ObjectName,
    PSECURITY_DESCRIPTOR SecurityDescriptor,
    DWORD DesiredAccess,
    PGENERIC_MAPPING GenericMapping,
    WINBOOL ObjectCreation,
    LPDWORD GrantedAccess,
    LPBOOL AccessStatus,
    LPBOOL pfGenerateOnClose
    ) {}

WINBOOL
STDCALL
ObjectOpenAuditAlarmA (
    LPCSTR SubsystemName,
    LPVOID HandleId,
    LPSTR ObjectTypeName,
    LPSTR ObjectName,
    PSECURITY_DESCRIPTOR pSecurityDescriptor,
    HANDLE ClientToken,
    DWORD DesiredAccess,
    DWORD GrantedAccess,
    PPRIVILEGE_SET Privileges,
    WINBOOL ObjectCreation,
    WINBOOL AccessGranted,
    LPBOOL GenerateOnClose
    ) {}

WINBOOL
STDCALL
ObjectPrivilegeAuditAlarmA (
    LPCSTR SubsystemName,
    LPVOID HandleId,
    HANDLE ClientToken,
    DWORD DesiredAccess,
    PPRIVILEGE_SET Privileges,
    WINBOOL AccessGranted
    ) {}

WINBOOL
STDCALL
ObjectCloseAuditAlarmA (
    LPCSTR SubsystemName,
    LPVOID HandleId,
    WINBOOL GenerateOnClose
    ) {}

WINBOOL
STDCALL
PrivilegedServiceAuditAlarmA (
    LPCSTR SubsystemName,
    LPCSTR ServiceName,
    HANDLE ClientToken,
    PPRIVILEGE_SET Privileges,
    WINBOOL AccessGranted
    ) {}

WINBOOL
STDCALL
SetFileSecurityA (
    LPCSTR lpFileName,
    SECURITY_INFORMATION SecurityInformation,
    PSECURITY_DESCRIPTOR pSecurityDescriptor
    ) {}

WINBOOL
STDCALL
GetFileSecurityA (
    LPCSTR lpFileName,
    SECURITY_INFORMATION RequestedInformation,
    PSECURITY_DESCRIPTOR pSecurityDescriptor,
    DWORD nLength,
    LPDWORD lpnLengthNeeded
    ) {}

HANDLE
STDCALL
FindFirstChangeNotificationA(
    LPCSTR lpPathName,
    WINBOOL bWatchSubtree,
    DWORD dwNotifyFilter
    ) {}

WINBOOL
STDCALL
IsBadStringPtrA(
    LPCSTR lpsz,
    UINT ucchMax
    ) {}

WINBOOL
STDCALL
LookupAccountSidA(
    LPCSTR lpSystemName,
    PSID Sid,
    LPSTR Name,
    LPDWORD cbName,
    LPSTR ReferencedDomainName,
    LPDWORD cbReferencedDomainName,
    PSID_NAME_USE peUse
    ) {}

WINBOOL
STDCALL
LookupAccountNameA(
    LPCSTR lpSystemName,
    LPCSTR lpAccountName,
    PSID Sid,
    LPDWORD cbSid,
    LPSTR ReferencedDomainName,
    LPDWORD cbReferencedDomainName,
    PSID_NAME_USE peUse
    ) {}

WINBOOL
STDCALL
LookupPrivilegeValueA(
    LPCSTR lpSystemName,
    LPCSTR lpName,
    PLUID   lpLuid
    ) {}

WINBOOL
STDCALL
LookupPrivilegeNameA(
    LPCSTR lpSystemName,
    PLUID   lpLuid,
    LPSTR lpName,
    LPDWORD cbName
    ) {}

WINBOOL
STDCALL
LookupPrivilegeDisplayNameA(
    LPCSTR lpSystemName,
    LPCSTR lpName,
    LPSTR lpDisplayName,
    LPDWORD cbDisplayName,
    LPDWORD lpLanguageId
    ) {}

WINBOOL
STDCALL
BuildCommDCBA(
    LPCSTR lpDef,
    LPDCB lpDCB
    ) {}

WINBOOL
STDCALL
BuildCommDCBAndTimeoutsA(
    LPCSTR lpDef,
    LPDCB lpDCB,
    LPCOMMTIMEOUTS lpCommTimeouts
    ) {}

WINBOOL
STDCALL
CommConfigDialogA(
    LPCSTR lpszName,
    HWND hWnd,
    LPCOMMCONFIG lpCC
    ) {}

WINBOOL
STDCALL
GetDefaultCommConfigA(
    LPCSTR lpszName,
    LPCOMMCONFIG lpCC,
    LPDWORD lpdwSize
    ) {}

WINBOOL
STDCALL
SetDefaultCommConfigA(
    LPCSTR lpszName,
    LPCOMMCONFIG lpCC,
    DWORD dwSize
    ) {}

WINBOOL
STDCALL
GetComputerNameA (
    LPSTR lpBuffer,
    LPDWORD nSize
    ) {}

WINBOOL
STDCALL
SetComputerNameA (
    LPCSTR lpComputerName
    ) {}

WINBOOL
STDCALL
GetUserNameA (
    LPSTR lpBuffer,
    LPDWORD nSize
    ) {}

int
STDCALL
wvsprintfA(
    LPSTR dst,
    LPCSTR fmt,
    va_list arglist) {}
 
int
CDECL
wsprintfA(LPSTR dst, LPCSTR fmt, ...) {}

HKL
STDCALL
LoadKeyboardLayoutA(
    LPCSTR pwszKLID,
    UINT Flags) {}
 
WINBOOL
STDCALL
GetKeyboardLayoutNameA(
    LPSTR pwszKLID) {}
 
HDESK
STDCALL
CreateDesktopA(
    LPSTR lpszDesktop,
    LPSTR lpszDevice,
    LPDEVMODE pDevmode,
    DWORD dwFlags,
    DWORD dwDesiredAccess,
    LPSECURITY_ATTRIBUTES lpsa) {}
 
HDESK
STDCALL
OpenDesktopA(
    LPSTR lpszDesktop,
    DWORD dwFlags,
    WINBOOL fInherit,
    DWORD dwDesiredAccess) {}
 
WINBOOL
STDCALL
EnumDesktopsA(
    HWINSTA hwinsta,
    DESKTOPENUMPROC lpEnumFunc,
    LPARAM lParam) {}
 
HWINSTA
STDCALL
CreateWindowStationA(
    LPSTR lpwinsta,
    DWORD dwReserved,
    DWORD dwDesiredAccess,
    LPSECURITY_ATTRIBUTES lpsa) {}
 
HWINSTA
STDCALL
OpenWindowStationA(
    LPSTR lpszWinSta,
    WINBOOL fInherit,
    DWORD dwDesiredAccess) {}
 
WINBOOL
STDCALL
EnumWindowStationsA(
    ENUMWINDOWSTATIONPROC lpEnumFunc,
    LPARAM lParam) {}
 
WINBOOL
STDCALL
GetUserObjectInformationA(
    HANDLE hObj,
    int nIndex,
    PVOID pvInfo,
    DWORD nLength,
    LPDWORD lpnLengthNeeded) {}
 
WINBOOL
STDCALL
SetUserObjectInformationA(
    HANDLE hObj,
    int nIndex,
    PVOID pvInfo,
    DWORD nLength) {}
 
UINT
STDCALL
RegisterWindowMessageA(
    LPCSTR lpString) {}
 
WINBOOL
STDCALL
GetMessageA(
    LPMSG lpMsg,
    HWND hWnd ,
    UINT wMsgFilterMin,
    UINT wMsgFilterMax) {}
 
LONG
STDCALL
DispatchMessageA(
    CONST MSG *lpMsg) {}
 
WINBOOL
STDCALL
PeekMessageA(
    LPMSG lpMsg,
    HWND hWnd ,
    UINT wMsgFilterMin,
    UINT wMsgFilterMax,
    UINT wRemoveMsg) {}
 
LRESULT
STDCALL
SendMessageA(
    HWND hWnd,
    UINT Msg,
    WPARAM wParam,
    LPARAM lParam) {}
 
LRESULT
STDCALL
SendMessageTimeoutA(
    HWND hWnd,
    UINT Msg,
    WPARAM wParam,
    LPARAM lParam,
    UINT fuFlags,
    UINT uTimeout,
    LPDWORD lpdwResult) {}
 
WINBOOL
STDCALL
SendNotifyMessageA(
    HWND hWnd,
    UINT Msg,
    WPARAM wParam,
    LPARAM lParam) {}
 
WINBOOL
STDCALL
SendMessageCallbackA(
    HWND hWnd,
    UINT Msg,
    WPARAM wParam,
    LPARAM lParam,
    SENDASYNCPROC lpResultCallBack,
    DWORD dwData) {}
 
WINBOOL
STDCALL
PostMessageA(
    HWND hWnd,
    UINT Msg,
    WPARAM wParam,
    LPARAM lParam) {}
 
WINBOOL
STDCALL
PostThreadMessageA(
    DWORD idThread,
    UINT Msg,
    WPARAM wParam,
    LPARAM lParam) {}
 
LRESULT
STDCALL
DefWindowProcA(
    HWND hWnd,
    UINT Msg,
    WPARAM wParam,
    LPARAM lParam) {}
 
LRESULT
STDCALL
CallWindowProcA(
    WNDPROC lpPrevWndFunc,
    HWND hWnd,
    UINT Msg,
    WPARAM wParam,
    LPARAM lParam) {}
 
ATOM
STDCALL
RegisterClassA(
    CONST WNDCLASS *lpWndClass) {}
 
WINBOOL
STDCALL
UnregisterClassA(
    LPCSTR lpClassName,
    HINSTANCE hInstance) {}
 
WINBOOL
STDCALL
GetClassInfoA(
    HINSTANCE hInstance ,
    LPCSTR lpClassName,
    LPWNDCLASS lpWndClass) {}
 
ATOM
STDCALL
RegisterClassExA(CONST WNDCLASSEX *wndClassEx) {}
 
WINBOOL
STDCALL
GetClassInfoExA(HINSTANCE hInstance, LPCSTR str, LPWNDCLASSEX wndClassEx) {}
 
HWND
STDCALL
CreateWindowExA(
    DWORD dwExStyle,
    LPCSTR lpClassName,
    LPCSTR lpWindowName,
    DWORD dwStyle,
    int X,
    int Y,
    int nWidth,
    int nHeight,
    HWND hWndParent ,
    HMENU hMenu,
    HINSTANCE hInstance,
    LPVOID lpParam) {}
 
HWND
STDCALL
CreateDialogParamA(
    HINSTANCE hInstance,
    LPCSTR lpTemplateName,
    HWND hWndParent ,
    DLGPROC lpDialogFunc,
    LPARAM dwInitParam) {}
 
HWND
STDCALL
CreateDialogIndirectParamA(
    HINSTANCE hInstance,
    LPCDLGTEMPLATE lpTemplate,
    HWND hWndParent,
    DLGPROC lpDialogFunc,
    LPARAM dwInitParam) {}
 
int
STDCALL
DialogBoxParamA(
    HINSTANCE hInstance,
    LPCSTR lpTemplateName,
    HWND hWndParent ,
    DLGPROC lpDialogFunc,
    LPARAM dwInitParam) {}
 
int
STDCALL
DialogBoxIndirectParamA(
    HINSTANCE hInstance,
    LPCDLGTEMPLATE hDialogTemplate,
    HWND hWndParent ,
    DLGPROC lpDialogFunc,
    LPARAM dwInitParam) {}
 
WINBOOL
STDCALL
SetDlgItemTextA(
    HWND hDlg,
    int nIDDlgItem,
    LPCSTR lpString) {}
 
UINT
STDCALL
GetDlgItemTextA(
    HWND hDlg,
    int nIDDlgItem,
    LPSTR lpString,
    int nMaxCount) {}
 
LONG
STDCALL
SendDlgItemMessageA(
    HWND hDlg,
    int nIDDlgItem,
    UINT Msg,
    WPARAM wParam,
    LPARAM lParam) {}
 
LRESULT
STDCALL
DefDlgProcA(
    HWND hDlg,
    UINT Msg,
    WPARAM wParam,
    LPARAM lParam) {}
 
WINBOOL
STDCALL
CallMsgFilterA(
    LPMSG lpMsg,
    int nCode) {}
 
UINT
STDCALL
RegisterClipboardFormatA(
    LPCSTR lpszFormat) {}
 
int
STDCALL
GetClipboardFormatNameA(
    UINT format,
    LPSTR lpszFormatName,
    int cchMaxCount) {}
 
WINBOOL
STDCALL
CharToOemA(
    LPCSTR lpszSrc,
    LPSTR lpszDst) {}
 
WINBOOL
STDCALL
OemToCharA(
    LPCSTR lpszSrc,
    LPSTR lpszDst) {}
 
WINBOOL
STDCALL
CharToOemBuffA(
    LPCSTR lpszSrc,
    LPSTR lpszDst,
    DWORD cchDstLength) {}
 
WINBOOL
STDCALL
OemToCharBuffA(
    LPCSTR lpszSrc,
    LPSTR lpszDst,
    DWORD cchDstLength) {}
 
LPSTR
STDCALL
CharUpperA(
    LPSTR lpsz) {}
 
DWORD
STDCALL
CharUpperBuffA(
    LPSTR lpsz,
    DWORD cchLength) {}
 
LPSTR
STDCALL
CharLowerA(
    LPSTR lpsz) {}
 
DWORD
STDCALL
CharLowerBuffA(
    LPSTR lpsz,
    DWORD cchLength) {}
 
LPSTR
STDCALL
CharNextA(
    LPCSTR lpsz) {}
 
LPSTR
STDCALL
CharPrevA(
    LPCSTR lpszStart,
    LPCSTR lpszCurrent) {}
 
WINBOOL
STDCALL
IsCharAlphaA(
    CHAR ch) {}
 
WINBOOL
STDCALL
IsCharAlphaNumericA(
    CHAR ch) {}
 
WINBOOL
STDCALL
IsCharUpperA(
    CHAR ch) {}
 
WINBOOL
STDCALL
IsCharLowerA(
    CHAR ch) {}
 
int
STDCALL
GetKeyNameTextA(
    LONG lParam,
    LPSTR lpString,
    int nSize
    ) {}
 
SHORT
STDCALL
VkKeyScanA(
    CHAR ch) {}
 
SHORT
STDCALL VkKeyScanExA(
    CHAR  ch,
    HKL   dwhkl) {}
 
UINT
STDCALL
MapVirtualKeyA(
    UINT uCode,
    UINT uMapType) {}
 
UINT
STDCALL
MapVirtualKeyExA(
    UINT uCode,
    UINT uMapType,
    HKL dwhkl) {}
 
HACCEL
STDCALL
LoadAcceleratorsA(
    HINSTANCE hInstance,
    LPCSTR lpTableName) {}
 
HACCEL
STDCALL
CreateAcceleratorTableA(
    LPACCEL accel, int v) {}
 
int
STDCALL
CopyAcceleratorTableA(
    HACCEL hAccelSrc,
    LPACCEL lpAccelDst,
    int cAccelEntries) {}
 
int
STDCALL
TranslateAcceleratorA(
    HWND hWnd,
    HACCEL hAccTable,
    LPMSG lpMsg) {}
 
HMENU
STDCALL
LoadMenuA(
    HINSTANCE hInstance,
    LPCSTR lpMenuName) {}
 
HMENU
STDCALL
LoadMenuIndirectA(
    CONST MENUTEMPLATE *lpMenuTemplate) {}
 
WINBOOL
STDCALL
ChangeMenuA(
    HMENU hMenu,
    UINT cmd,
    LPCSTR lpszNewItem,
    UINT cmdInsert,
    UINT flags) {}
 
int
STDCALL
GetMenuStringA(
    HMENU hMenu,
    UINT uIDItem,
    LPSTR lpString,
    int nMaxCount,
    UINT uFlag) {}
 
WINBOOL
STDCALL
InsertMenuA(
    HMENU hMenu,
    UINT uPosition,
    UINT uFlags,
    UINT uIDNewItem,
    LPCSTR lpNewItem
    ) {}
 
WINBOOL
STDCALL
AppendMenuA(
    HMENU hMenu,
    UINT uFlags,
    UINT uIDNewItem,
    LPCSTR lpNewItem
    ) {}
 
WINBOOL
STDCALL
ModifyMenuA(
    HMENU hMnu,
    UINT uPosition,
    UINT uFlags,
    UINT uIDNewItem,
    LPCSTR lpNewItem
    ) {}
 
WINBOOL
STDCALL
InsertMenuItemA(
    HMENU hMenu,
    UINT v1,
    WINBOOL b1,
    LPCMENUITEMINFO lpcMenuItemInfo
    ) {}
 
WINBOOL
STDCALL
GetMenuItemInfoA(
    HMENU hMenu,
    UINT v1,
    WINBOOL b1,
    LPMENUITEMINFO lpcMenuItemInfo
    ) {}
 
WINBOOL
STDCALL
SetMenuItemInfoA(
    HMENU hMenu,
    UINT v1,
    WINBOOL b1,
    LPCMENUITEMINFO lpcMenuItemInfo
    ) {}
 
int
STDCALL
DrawTextA(
    HDC hDC,
    LPCSTR lpString,
    int nCount,
    LPRECT lpRect,
    UINT uFormat) {}
 
int
STDCALL
DrawTextExA(HDC hDC, LPSTR str, int v1, LPRECT pRect, UINT v2,
	LPDRAWTEXTPARAMS lpDrawTextParams) {}
 
WINBOOL
STDCALL
GrayStringA(
    HDC hDC,
    HBRUSH hBrush,
    GRAYSTRINGPROC lpOutputFunc,
    LPARAM lpData,
    int nCount,
    int X,
    int Y,
    int nWidth,
    int nHeight) {}
 
WINBOOL
STDCALL
DrawStateA(HDC hDC, HBRUSH hBrush, DRAWSTATEPROC drawStateProc,
	LPARAM lParam, WPARAM wParam, int v1, int v2, int v3,
	int v4, UINT v5) {}

LONG
STDCALL
TabbedTextOutA(
    HDC hDC,
    int X,
    int Y,
    LPCSTR lpString,
    int nCount,
    int nTabPositions,
    LPINT lpnTabStopPositions,
    int nTabOrigin) {}
 
DWORD
STDCALL
GetTabbedTextExtentA(
    HDC hDC,
    LPCSTR lpString,
    int nCount,
    int nTabPositions,
    LPINT lpnTabStopPositions) {}
 
WINBOOL
STDCALL
SetPropA(
    HWND hWnd,
    LPCSTR lpString,
    HANDLE hData) {}
 
HANDLE
STDCALL
GetPropA(
    HWND hWnd,
    LPCSTR lpString) {}
 
HANDLE
STDCALL
RemovePropA(
    HWND hWnd,
    LPCSTR lpString) {}
 
int
STDCALL
EnumPropsExA(
    HWND hWnd,
    PROPENUMPROCEX lpEnumFunc,
    LPARAM lParam) {}
 
int
STDCALL
EnumPropsA(
    HWND hWnd,
    PROPENUMPROC lpEnumFunc) {}
 
WINBOOL
STDCALL
SetWindowTextA(
    HWND hWnd,
    LPCSTR lpString) {}
 
int
STDCALL
GetWindowTextA(
    HWND hWnd,
    LPSTR lpString,
    int nMaxCount) {}
 
int
STDCALL
GetWindowTextLengthA(
    HWND hWnd) {}
 
int
STDCALL
MessageBoxA(
    HWND hWnd ,
    LPCSTR lpText,
    LPCSTR lpCaption,
    UINT uType) {}
 
int
STDCALL
MessageBoxExA(
    HWND hWnd ,
    LPCSTR lpText,
    LPCSTR lpCaption,
    UINT uType,
    WORD wLanguageId) {}
 
int
STDCALL
MessageBoxIndirectA(LPMSGBOXPARAMS lpMsgBoxParams) {}

LONG
STDCALL
GetWindowLongA(
    HWND hWnd,
    int nIndex) {}
 
LONG
STDCALL
SetWindowLongA(
    HWND hWnd,
    int nIndex,
    LONG dwNewLong) {}
 
DWORD
STDCALL
GetClassLongA(
    HWND hWnd,
    int nIndex) {}
 
DWORD
STDCALL
SetClassLongA(
    HWND hWnd,
    int nIndex,
    LONG dwNewLong) {}
 
HWND
STDCALL
FindWindowA(
    LPCSTR lpClassName ,
    LPCSTR lpWindowName) {}
 
HWND
STDCALL
FindWindowExA(HWND hWnd, HWND hWind1, LPCSTR lpcStr, LPCSTR lpcStr1) {}

int
STDCALL
GetClassNameA(
    HWND hWnd,
    LPSTR lpClassName,
    int nMaxCount) {}
 
HHOOK
STDCALL
SetWindowsHookExA(
    int idHook,
    HOOKPROC lpfn,
    HINSTANCE hmod,
    DWORD dwThreadId) {}
 
HBITMAP
STDCALL
LoadBitmapA(
    HINSTANCE hInstance,
    LPCSTR lpBitmapName) {}
 
HCURSOR
STDCALL
LoadCursorA(
    HINSTANCE hInstance,
    LPCSTR lpCursorName) {}
 
HCURSOR
STDCALL
LoadCursorFromFileA(
    LPCSTR    lpFileName) {}
 
HICON
STDCALL
LoadIconA(
    HINSTANCE hInstance,
    LPCSTR lpIconName) {}
 
HANDLE
STDCALL
LoadImageA(
    HINSTANCE hInstance,
    LPCSTR str,
    UINT v1,
    int v2,
    int v3,
    UINT v4) {}
 
int
STDCALL
LoadStringA(
    HINSTANCE hInstance,
    UINT uID,
    LPSTR lpBuffer,
    int nBufferMax) {}
 
WINBOOL
STDCALL
IsDialogMessageA(
    HWND hDlg,
    LPMSG lpMsg) {}
 
int
STDCALL
DlgDirListA(
    HWND hDlg,
    LPSTR lpPathSpec,
    int nIDListBox,
    int nIDStaticPath,
    UINT uFileType) {}
 
WINBOOL
STDCALL
DlgDirSelectExA(
    HWND hDlg,
    LPSTR lpString,
    int nCount,
    int nIDListBox) {}
 
int
STDCALL
DlgDirListComboBoxA(
    HWND hDlg,
    LPSTR lpPathSpec,
    int nIDComboBox,
    int nIDStaticPath,
    UINT uFiletype) {}
 
WINBOOL
STDCALL
DlgDirSelectComboBoxExA(
    HWND hDlg,
    LPSTR lpString,
    int nCount,
    int nIDComboBox) {}
 
LRESULT
STDCALL
DefFrameProcA(
    HWND hWnd,
    HWND hWndMDIClient ,
    UINT uMsg,
    WPARAM wParam,
    LPARAM lParam) {}
 
LRESULT
STDCALL
DefMDIChildProcA(
    HWND hWnd,
    UINT uMsg,
    WPARAM wParam,
    LPARAM lParam) {}
 
HWND
STDCALL
CreateMDIWindowA(
    LPSTR lpClassName,
    LPSTR lpWindowName,
    DWORD dwStyle,
    int X,
    int Y,
    int nWidth,
    int nHeight,
    HWND hWndParent,
    HINSTANCE hInstance,
    LPARAM lParam
    ) {}
 
WINBOOL
STDCALL
WinHelpA(
    HWND hWndMain,
    LPCSTR lpszHelp,
    UINT uCommand,
    DWORD dwData
    ) {}
 
LONG
STDCALL
ChangeDisplaySettingsA(
    LPDEVMODE lpDevMode,
    DWORD dwFlags) {}
 
WINBOOL
STDCALL
EnumDisplaySettingsA(
    LPCSTR lpszDeviceName,
    DWORD iModeNum,
    LPDEVMODE lpDevMode) {}
 
WINBOOL
STDCALL
SystemParametersInfoA(
    UINT uiAction,
    UINT uiParam,
    PVOID pvParam,
    UINT fWinIni) {}
 
int
STDCALL
AddFontResourceA(LPCSTR str) {}

HMETAFILE
STDCALL
CopyMetaFileA(HMETAFILE hMetaFile, LPCSTR str) {}

HFONT
STDCALL
CreateFontIndirectA(CONST LOGFONT *logFont) {}

HDC
STDCALL
CreateICA(LPCSTR str1, LPCSTR str2, LPCSTR str3, CONST DEVMODE *devMode) {}

HDC
STDCALL
CreateMetaFileA(LPCSTR str) {}

WINBOOL
STDCALL
CreateScalableFontResourceA(DWORD v, LPCSTR str1, LPCSTR str2, LPCSTR str3) {}

int
STDCALL
DeviceCapabilitiesA(LPCSTR str1, LPCSTR str2, WORD w,
                                LPSTR str3, CONST DEVMODE * devMode) {}

int
STDCALL
EnumFontFamiliesExA(HDC hDC, LPLOGFONT logFont, FONTENUMEXPROC fontEnumProc,
				LPARAM lParam, DWORD dWord) {}

int
STDCALL
EnumFontFamiliesA(HDC hDC, LPCSTR str, FONTENUMPROC fontEnumproc,
				LPARAM lParam) {}

int
STDCALL
EnumFontsA(HDC hDC, LPCSTR str,  ENUMFONTSPROC enumFontProc, LPARAM lParam) {}

WINBOOL
STDCALL
GetCharWidthA(HDC hDC, UINT v1, UINT v2, LPINT pInt) {}

WINBOOL
STDCALL
GetCharWidth32A(HDC hDC, UINT v1, UINT v2, LPINT pInt) {}

WINBOOL
STDCALL
GetCharWidthFloatA(HDC hDC, UINT v1, UINT v2, PFLOAT pFloat) {}

WINBOOL
STDCALL
GetCharABCWidthsA(HDC hDC, UINT v1, UINT v2, LPABC pAbc) {}

WINBOOL
STDCALL
GetCharABCWidthsFloatA(HDC hDC, UINT v1, UINT v2, LPABCFLOAT pAbcFloat) {}
DWORD
STDCALL
GetGlyphOutlineA(HDC hDC, UINT v1, UINT v2, LPGLYPHMETRICS pGlyph, DWORD dWord,
				LPVOID ptr, CONST MAT2 *pMat2) {}

HMETAFILE
STDCALL
GetMetaFileA(LPCSTR str) {}

UINT
STDCALL
GetOutlineTextMetricsA(HDC hDC, UINT v, LPOUTLINETEXTMETRIC metric) {}

WINBOOL
STDCALL
GetTextExtentPointA(
                    HDC hDC,
                    LPCSTR str,
                    int v,
                    LPSIZE pSize
                    ) {}

WINBOOL
STDCALL
GetTextExtentPoint32A(
                    HDC hDC,
                    LPCSTR str,
                    int v,
                    LPSIZE pSize
                    ) {}

WINBOOL
STDCALL
GetTextExtentExPointA(
                    HDC hDC,
                    LPCSTR str,
                    int v1,
                    int v2,
                    LPINT p1,
                    LPINT p2,
                    LPSIZE psize
                    ) {}

DWORD
STDCALL
GetCharacterPlacementA(HDC hDC, LPCSTR s, int v1, int v2,
		LPGCP_RESULTS gcpResults, DWORD d) {}

HDC
STDCALL
ResetDCA(HDC hDC, CONST DEVMODE *devMode) {}

WINBOOL
STDCALL
RemoveFontResourceA(LPCSTR str) {}

HENHMETAFILE
STDCALL
CopyEnhMetaFileA(HENHMETAFILE hMetaFile, LPCSTR str) {}

HDC
STDCALL
CreateEnhMetaFileA(HDC hDC, LPCSTR str, CONST RECT *Rect, LPCSTR str1) {}

HENHMETAFILE
STDCALL
GetEnhMetaFileA(LPCSTR str) {}

UINT
STDCALL
GetEnhMetaFileDescriptionA(HENHMETAFILE hMetaFile, UINT v, LPSTR str) {}

WINBOOL
STDCALL
GetTextMetricsA(HDC hDC, LPTEXTMETRIC pTextMetric) {}

int
STDCALL
StartDocA(HDC hDC, CONST DOCINFO *docInfo) {}

int
STDCALL
GetObjectA(HGDIOBJ hGdiObj, int v, LPVOID ptr) {}

WINBOOL
STDCALL
TextOutA(HDC hDC, int v1, int v2, LPCSTR str, int v3) {}

WINBOOL
STDCALL
ExtTextOutA(HDC hDC, int v1, int v2, UINT v3, CONST RECT *pRect,
				LPCSTR str, UINT v4, CONST INT *pInt) {}

WINBOOL
STDCALL
PolyTextOutA(HDC hDC, CONST POLYTEXT *pPolyText, int v) {} 

int
STDCALL
GetTextFaceA(HDC hDC, int v, LPSTR str) {}

DWORD
STDCALL
GetKerningPairsA(HDC hDC, DWORD dWord, LPKERNINGPAIR pKerningPair) {}

HCOLORSPACE
STDCALL
CreateColorSpaceA(LPLOGCOLORSPACE pLogColorSpace) {}

WINBOOL
STDCALL
GetLogColorSpaceA(HCOLORSPACE hColorSpace,LPLOGCOLORSPACE pLogColorSpace,
					DWORD dWord) {}

WINBOOL
STDCALL
GetICMProfileA(HDC hDC,DWORD dWord,LPSTR str) {}

WINBOOL
STDCALL
SetICMProfileA(HDC hDC,LPSTR str) {}

WINBOOL
STDCALL
UpdateICMRegKeyA(DWORD d1, DWORD d2, LPSTR str, UINT v) {}

int
STDCALL
EnumICMProfilesA(HDC hDC,ICMENUMPROC icEnumProc,LPARAM lParam) {}

int
STDCALL
PropertySheetA(LPCPROPSHEETHEADER lppsph) {}

HIMAGELIST
STDCALL
ImageList_LoadImageA(HINSTANCE hi, LPCSTR lpbmp, int cx, int cGrow, COLORREF crMask, UINT uType, UINT uFlags) {}

HWND
STDCALL
CreateStatusWindowA(LONG style, LPCSTR lpszText, HWND hwndParent, UINT wID) {}

void
STDCALL
DrawStatusTextA(HDC hDC, LPRECT lprc, LPCSTR pszText, UINT uFlags) {}

WINBOOL
STDCALL
GetOpenFileNameA(LPOPENFILENAME lpOpenFileName) {}

WINBOOL
STDCALL
GetSaveFileNameA(LPOPENFILENAME lpOpenFileName) {}

short
STDCALL
GetFileTitleA(LPCSTR str, LPSTR s1, WORD v) {}

WINBOOL
STDCALL
ChooseColorA(LPCHOOSECOLOR chooseColor) {}

HWND
STDCALL
FindTextA(LPFINDREPLACE findReplace) {}

HWND
STDCALL
ReplaceTextA(LPFINDREPLACE findReplace) {}

WINBOOL
STDCALL
ChooseFontA(LPCHOOSEFONT chooseFont) {}

WINBOOL
STDCALL
PrintDlgA(LPPRINTDLG printDlg) {}

WINBOOL
STDCALL
PageSetupDlgA( LPPAGESETUPDLG pageSetupDlg) {}

WINBOOL
STDCALL
CreateProcessA(
    LPCSTR lpApplicationName,
    LPSTR lpCommandLine,
    LPSECURITY_ATTRIBUTES lpProcessAttributes,
    LPSECURITY_ATTRIBUTES lpThreadAttributes,
    WINBOOL bInheritHandles,
    DWORD dwCreationFlags,
    LPVOID lpEnvironment,
    LPCSTR lpCurrentDirectory,
    LPSTARTUPINFO lpStartupInfo,
    LPPROCESS_INFORMATION lpProcessInformation
    ) {}

VOID
STDCALL
GetStartupInfoA(
    LPSTARTUPINFO lpStartupInfo
    ) {}

HANDLE
STDCALL
FindFirstFileA(
    LPCSTR lpFileName,
    LPWIN32_FIND_DATA lpFindFileData
    ) {}

WINBOOL
STDCALL
FindNextFileA(
    HANDLE hFindFile,
    LPWIN32_FIND_DATA lpFindFileData
    ) {}

WINBOOL
STDCALL
GetVersionExA(
    LPOSVERSIONINFO lpVersionInformation
    ) {}

#define CreateWindowA(lpClassName, lpWindowName, dwStyle, x, y,\
nWidth, nHeight, hWndParent, hMenu, hInstance, lpParam)\
CreateWindowExA(0L, lpClassName, lpWindowName, dwStyle, x, y,\
nWidth, nHeight, hWndParent, hMenu, hInstance, lpParam)

#define CreateDialogA(hInstance, lpName, hWndParent, lpDialogFunc) \
CreateDialogParamA(hInstance, lpName, hWndParent, lpDialogFunc, 0L)

#define CreateDialogIndirectA(hInstance, lpTemplate, hWndParent, lpDialogFunc) \
CreateDialogIndirectParamA(hInstance, lpTemplate, hWndParent, lpDialogFunc, 0L)

#define DialogBoxA(hInstance, lpTemplate, hWndParent, lpDialogFunc) \
DialogBoxParamA(hInstance, lpTemplate, hWndParent, lpDialogFunc, 0L)

#define DialogBoxIndirectA(hInstance, lpTemplate, hWndParent, lpDialogFunc) \
DialogBoxIndirectParamA(hInstance, lpTemplate, hWndParent, lpDialogFunc, 0L)

HDC
STDCALL
CreateDCA(LPCSTR s1, LPCSTR s2, LPCSTR s3, CONST DEVMODE *devMode) {}

DWORD
STDCALL
VerInstallFileA(
        DWORD uFlags,
        LPSTR szSrcFileName,
        LPSTR szDestFileName,
        LPSTR szSrcDir,
        LPSTR szDestDir,
        LPSTR szCurDir,
        LPSTR szTmpFile,
        PUINT lpuTmpFileLen
        ) {}

DWORD
STDCALL
GetFileVersionInfoSizeA(
        LPSTR lptstrFilename,
        LPDWORD lpdwHandle
        ) {}

WINBOOL
STDCALL
GetFileVersionInfoA(
        LPSTR lptstrFilename,
        DWORD dwHandle,
        DWORD dwLen,
        LPVOID lpData
        ) {}

DWORD
STDCALL
VerLanguageNameA(
        DWORD wLang,
        LPSTR szLang,
        DWORD nSize
        ) {}

WINBOOL
STDCALL
VerQueryValueA(
        const LPVOID pBlock,
        LPSTR lpSubBlock,
        LPVOID * lplpBuffer,
        PUINT puLen
        ) {}

DWORD
STDCALL
VerFindFileA(
        DWORD uFlags,
        LPSTR szFileName,
        LPSTR szWinDir,
        LPSTR szAppDir,
        LPSTR szCurDir,
        PUINT lpuCurDirLen,
        LPSTR szDestDir,
        PUINT lpuDestDirLen
        ) {}

LONG
STDCALL
RegConnectRegistryA (
    LPSTR lpMachineName,
    HKEY hKey,
    PHKEY phkResult
    ) {}

LONG
STDCALL
RegCreateKeyA (
    HKEY hKey,
    LPCSTR lpSubKey,
    PHKEY phkResult
    ) {}

LONG
STDCALL
RegCreateKeyExA (
    HKEY hKey,
    LPCSTR lpSubKey,
    DWORD Reserved,
    LPSTR lpClass,
    DWORD dwOptions,
    REGSAM samDesired,
    LPSECURITY_ATTRIBUTES lpSecurityAttributes,
    PHKEY phkResult,
    LPDWORD lpdwDisposition
    ) {}

LONG
STDCALL
RegDeleteKeyA (
    HKEY hKey,
    LPCSTR lpSubKey
    ) {}

LONG
STDCALL
RegDeleteValueA (
    HKEY hKey,
    LPCSTR lpValueName
    ) {}

LONG
STDCALL
RegEnumKeyA (
    HKEY hKey,
    DWORD dwIndex,
    LPSTR lpName,
    DWORD cbName
    ) {}

LONG
STDCALL
RegEnumKeyExA (
    HKEY hKey,
    DWORD dwIndex,
    LPSTR lpName,
    LPDWORD lpcbName,
    LPDWORD lpReserved,
    LPSTR lpClass,
    LPDWORD lpcbClass,
    PFILETIME lpftLastWriteTime
    ) {}

LONG
STDCALL
RegEnumValueA (
    HKEY hKey,
    DWORD dwIndex,
    LPSTR lpValueName,
    LPDWORD lpcbValueName,
    LPDWORD lpReserved,
    LPDWORD lpType,
    LPBYTE lpData,
    LPDWORD lpcbData
    ) {}

LONG
STDCALL
RegLoadKeyA (
    HKEY    hKey,
    LPCSTR  lpSubKey,
    LPCSTR  lpFile
    ) {}

LONG
STDCALL
RegOpenKeyA (
    HKEY hKey,
    LPCSTR lpSubKey,
    PHKEY phkResult
    ) {}

LONG
STDCALL
RegOpenKeyExA (
    HKEY hKey,
    LPCSTR lpSubKey,
    DWORD ulOptions,
    REGSAM samDesired,
    PHKEY phkResult
    ) {}

LONG
STDCALL
RegQueryInfoKeyA (
    HKEY hKey,
    LPSTR lpClass,
    LPDWORD lpcbClass,
    LPDWORD lpReserved,
    LPDWORD lpcSubKeys,
    LPDWORD lpcbMaxSubKeyLen,
    LPDWORD lpcbMaxClassLen,
    LPDWORD lpcValues,
    LPDWORD lpcbMaxValueNameLen,
    LPDWORD lpcbMaxValueLen,
    LPDWORD lpcbSecurityDescriptor,
    PFILETIME lpftLastWriteTime
    ) {}

LONG
STDCALL
RegQueryValueA (
    HKEY hKey,
    LPCSTR lpSubKey,
    LPSTR lpValue,
    PLONG   lpcbValue
    ) {}

LONG
STDCALL
RegQueryMultipleValuesA (
    HKEY hKey,
    PVALENT val_list,
    DWORD num_vals,
    LPSTR lpValueBuf,
    LPDWORD ldwTotsize
    ) {}

LONG
STDCALL
RegQueryValueExA (
    HKEY hKey,
    LPCSTR lpValueName,
    LPDWORD lpReserved,
    LPDWORD lpType,
    LPBYTE lpData,
    LPDWORD lpcbData
    ) {}

LONG
STDCALL
RegReplaceKeyA (
    HKEY     hKey,
    LPCSTR  lpSubKey,
    LPCSTR  lpNewFile,
    LPCSTR  lpOldFile
    ) {}

LONG
STDCALL
RegRestoreKeyA (
    HKEY hKey,
    LPCSTR lpFile,
    DWORD   dwFlags
    ) {}

LONG
STDCALL
RegSaveKeyA (
    HKEY hKey,
    LPCSTR lpFile,
    LPSECURITY_ATTRIBUTES lpSecurityAttributes
    ) {}

LONG
STDCALL
RegSetValueA (
    HKEY hKey,
    LPCSTR lpSubKey,
    DWORD dwType,
    LPCSTR lpData,
    DWORD cbData
    ) {}

LONG
STDCALL
RegSetValueExA (
    HKEY hKey,
    LPCSTR lpValueName,
    DWORD Reserved,
    DWORD dwType,
    CONST BYTE* lpData,
    DWORD cbData
    ) {}

LONG
STDCALL
RegUnLoadKeyA (
    HKEY    hKey,
    LPCSTR lpSubKey
    ) {}

WINBOOL
STDCALL
InitiateSystemShutdownA(
    LPSTR lpMachineName,
    LPSTR lpMessage,
    DWORD dwTimeout,
    WINBOOL bForceAppsClosed,
    WINBOOL bRebootAfterShutdown
    ) {}

WINBOOL
STDCALL
AbortSystemShutdownA(
    LPSTR lpMachineName
    ) {}

int
STDCALL
CompareStringA(
    LCID     Locale,
    DWORD    dwCmpFlags,
    LPCSTR lpString1,
    int      cchCount1,
    LPCSTR lpString2,
    int      cchCount2) {}

int
STDCALL
LCMapStringA(
    LCID     Locale,
    DWORD    dwMapFlags,
    LPCSTR lpSrcStr,
    int      cchSrc,
    LPSTR  lpDestStr,
    int      cchDest) {}

int
STDCALL
GetLocaleInfoA(
    LCID     Locale,
    LCTYPE   LCType,
    LPSTR  lpLCData,
    int      cchData) {}

WINBOOL
STDCALL
SetLocaleInfoA(
    LCID     Locale,
    LCTYPE   LCType,
    LPCSTR lpLCData) {}

int
STDCALL
GetTimeFormatA(
    LCID     Locale,
    DWORD    dwFlags,
    CONST SYSTEMTIME *lpTime,
    LPCSTR lpFormat,
    LPSTR  lpTimeStr,
    int      cchTime) {}

int
STDCALL
GetDateFormatA(
    LCID     Locale,
    DWORD    dwFlags,
    CONST SYSTEMTIME *lpDate,
    LPCSTR lpFormat,
    LPSTR  lpDateStr,
    int      cchDate) {}

int
STDCALL
GetNumberFormatA(
    LCID     Locale,
    DWORD    dwFlags,
    LPCSTR lpValue,
    CONST NUMBERFMT *lpFormat,
    LPSTR  lpNumberStr,
    int      cchNumber) {}

int
STDCALL
GetCurrencyFormatA(
    LCID     Locale,
    DWORD    dwFlags,
    LPCSTR lpValue,
    CONST CURRENCYFMT *lpFormat,
    LPSTR  lpCurrencyStr,
    int      cchCurrency) {}

WINBOOL
STDCALL
EnumCalendarInfoA(
    CALINFO_ENUMPROC lpCalInfoEnumProc,
    LCID              Locale,
    CALID             Calendar,
    CALTYPE           CalType) {}

WINBOOL
STDCALL
EnumTimeFormatsA(
    TIMEFMT_ENUMPROC lpTimeFmtEnumProc,
    LCID              Locale,
    DWORD             dwFlags) {}

WINBOOL
STDCALL
EnumDateFormatsA(
    DATEFMT_ENUMPROC lpDateFmtEnumProc,
    LCID              Locale,
    DWORD             dwFlags) {}

WINBOOL
STDCALL
GetStringTypeExA(
    LCID     Locale,
    DWORD    dwInfoType,
    LPCSTR lpSrcStr,
    int      cchSrc,
    LPWORD   lpCharType) {}

WINBOOL
STDCALL
GetStringTypeA(
    LCID     Locale,
    DWORD    dwInfoType,
    LPCSTR   lpSrcStr,
    int      cchSrc,
    LPWORD   lpCharType) {}


int
STDCALL
FoldStringA(
    DWORD    dwMapFlags,
    LPCSTR lpSrcStr,
    int      cchSrc,
    LPSTR  lpDestStr,
    int      cchDest) {}

WINBOOL
STDCALL
EnumSystemLocalesA(
    LOCALE_ENUMPROC lpLocaleEnumProc,
    DWORD            dwFlags) {}

WINBOOL
STDCALL
EnumSystemCodePagesA(
    CODEPAGE_ENUMPROC lpCodePageEnumProc,
    DWORD              dwFlags) {}

WINBOOL
STDCALL
PeekConsoleInputA(
    HANDLE hConsoleInput,
    PINPUT_RECORD lpBuffer,
    DWORD nLength,
    LPDWORD lpNumberOfEventsRead
    ) {}

WINBOOL
STDCALL
ReadConsoleInputA(
    HANDLE hConsoleInput,
    PINPUT_RECORD lpBuffer,
    DWORD nLength,
    LPDWORD lpNumberOfEventsRead
    ) {}

WINBOOL
STDCALL
WriteConsoleInputA(
    HANDLE hConsoleInput,
    CONST INPUT_RECORD *lpBuffer,
    DWORD nLength,
    LPDWORD lpNumberOfEventsWritten
    ) {}

WINBOOL
STDCALL
ReadConsoleOutputA(
    HANDLE hConsoleOutput,
    PCHAR_INFO lpBuffer,
    COORD dwBufferSize,
    COORD dwBufferCoord,
    PSMALL_RECT lpReadRegion
    ) {}

WINBOOL
STDCALL
WriteConsoleOutputA(
    HANDLE hConsoleOutput,
    CONST CHAR_INFO *lpBuffer,
    COORD dwBufferSize,
    COORD dwBufferCoord,
    PSMALL_RECT lpWriteRegion
    ) {}

WINBOOL
STDCALL
ReadConsoleOutputCharacterA(
    HANDLE hConsoleOutput,
    LPSTR lpCharacter,
    DWORD nLength,
    COORD dwReadCoord,
    LPDWORD lpNumberOfCharsRead
    ) {}

WINBOOL
STDCALL
WriteConsoleOutputCharacterA(
    HANDLE hConsoleOutput,
    LPCSTR lpCharacter,
    DWORD nLength,
    COORD dwWriteCoord,
    LPDWORD lpNumberOfCharsWritten
    ) {}

WINBOOL
STDCALL
FillConsoleOutputCharacterA(
    HANDLE hConsoleOutput,
    CHAR  cCharacter,
    DWORD  nLength,
    COORD  dwWriteCoord,
    LPDWORD lpNumberOfCharsWritten
    ) {}

WINBOOL
STDCALL
ScrollConsoleScreenBufferA(
    HANDLE hConsoleOutput,
    CONST SMALL_RECT *lpScrollRectangle,
    CONST SMALL_RECT *lpClipRectangle,
    COORD dwDestinationOrigin,
    CONST CHAR_INFO *lpFill
    ) {}

DWORD
STDCALL
GetConsoleTitleA(
    LPSTR lpConsoleTitle,
    DWORD nSize
    ) {}

WINBOOL
STDCALL
SetConsoleTitleA(
    LPCSTR lpConsoleTitle
    ) {}

WINBOOL
STDCALL
ReadConsoleA(
    HANDLE hConsoleInput,
    LPVOID lpBuffer,
    DWORD nNumberOfCharsToRead,
    LPDWORD lpNumberOfCharsRead,
    LPVOID lpReserved
    ) {}

WINBOOL
STDCALL
WriteConsoleA(
    HANDLE hConsoleOutput,
    CONST VOID *lpBuffer,
    DWORD nNumberOfCharsToWrite,
    LPDWORD lpNumberOfCharsWritten,
    LPVOID lpReserved
    ) {}

DWORD STDCALL
WNetAddConnectionA(
     LPCSTR   lpRemoteName,
     LPCSTR   lpPassword,
     LPCSTR   lpLocalName
    ) {}

DWORD STDCALL
WNetAddConnection2A(
     LPNETRESOURCE lpNetResource,
     LPCSTR       lpPassword,
     LPCSTR       lpUserName,
     DWORD          dwFlags
    ) {}

DWORD STDCALL
WNetAddConnection3A(
     HWND           hwndOwner,
     LPNETRESOURCE lpNetResource,
     LPCSTR       lpPassword,
     LPCSTR       lpUserName,
     DWORD          dwFlags
    ) {}

DWORD STDCALL
WNetCancelConnectionA(
     LPCSTR lpName,
     WINBOOL     fForce
    ) {}

DWORD STDCALL
WNetCancelConnection2A(
     LPCSTR lpName,
     DWORD    dwFlags,
     WINBOOL     fForce
    ) {}

DWORD STDCALL
WNetGetConnectionA(
     LPCSTR lpLocalName,
     LPSTR  lpRemoteName,
     LPDWORD  lpnLength
    ) {}

DWORD STDCALL
WNetUseConnectionA(
    HWND            hwndOwner,
    LPNETRESOURCE  lpNetResource,
    LPCSTR        lpUserID,
    LPCSTR        lpPassword,
    DWORD           dwFlags,
    LPSTR         lpAccessName,
    LPDWORD         lpBufferSize,
    LPDWORD         lpResult
    ) {}

DWORD STDCALL
WNetSetConnectionA(
    LPCSTR    lpName,
    DWORD       dwProperties,
    LPVOID      pvValues
    ) {}

DWORD STDCALL
WNetConnectionDialog1A(
    LPCONNECTDLGSTRUCT lpConnDlgStruct
    ) {}

DWORD STDCALL
WNetDisconnectDialog1A(
    LPDISCDLGSTRUCT lpConnDlgStruct
    ) {}

DWORD STDCALL
WNetOpenEnumA(
     DWORD          dwScope,
     DWORD          dwType,
     DWORD          dwUsage,
     LPNETRESOURCE lpNetResource,
     LPHANDLE       lphEnum
    ) {}

DWORD STDCALL
WNetEnumResourceA(
     HANDLE  hEnum,
     LPDWORD lpcCount,
     LPVOID  lpBuffer,
     LPDWORD lpBufferSize
    ) {}

DWORD STDCALL
WNetGetUniversalNameA(
     LPCSTR lpLocalPath,
     DWORD    dwInfoLevel,
     LPVOID   lpBuffer,
     LPDWORD  lpBufferSize
     ) {}

DWORD STDCALL
WNetGetUserA(
     LPCSTR  lpName,
     LPSTR   lpUserName,
     LPDWORD   lpnLength
    ) {}

DWORD STDCALL
WNetGetProviderNameA(
    DWORD   dwNetType,
    LPSTR lpProviderName,
    LPDWORD lpBufferSize
    ) {}

DWORD STDCALL
WNetGetNetworkInformationA(
    LPCSTR          lpProvider,
    LPNETINFOSTRUCT   lpNetInfoStruct
    ) {}

DWORD STDCALL
WNetGetLastErrorA(
     LPDWORD    lpError,
     LPSTR    lpErrorBuf,
     DWORD      nErrorBufSize,
     LPSTR    lpNameBuf,
     DWORD      nNameBufSize
    ) {}

DWORD STDCALL
MultinetGetConnectionPerformanceA(
        LPNETRESOURCE lpNetResource,
        LPNETCONNECTINFOSTRUCT lpNetConnectInfoStruct
        ) {}

WINBOOL
STDCALL
ChangeServiceConfigA(
    SC_HANDLE    hService,
    DWORD        dwServiceType,
    DWORD        dwStartType,
    DWORD        dwErrorControl,
    LPCSTR     lpBinaryPathName,
    LPCSTR     lpLoadOrderGroup,
    LPDWORD      lpdwTagId,
    LPCSTR     lpDependencies,
    LPCSTR     lpServiceStartName,
    LPCSTR     lpPassword,
    LPCSTR     lpDisplayName
    ) {}

SC_HANDLE
STDCALL
CreateServiceA(
    SC_HANDLE    hSCManager,
    LPCSTR     lpServiceName,
    LPCSTR     lpDisplayName,
    DWORD        dwDesiredAccess,
    DWORD        dwServiceType,
    DWORD        dwStartType,
    DWORD        dwErrorControl,
    LPCSTR     lpBinaryPathName,
    LPCSTR     lpLoadOrderGroup,
    LPDWORD      lpdwTagId,
    LPCSTR     lpDependencies,
    LPCSTR     lpServiceStartName,
    LPCSTR     lpPassword
    ) {}

WINBOOL
STDCALL
EnumDependentServicesA(
    SC_HANDLE               hService,
    DWORD                   dwServiceState,
    LPENUM_SERVICE_STATUS  lpServices,
    DWORD                   cbBufSize,
    LPDWORD                 pcbBytesNeeded,
    LPDWORD                 lpServicesReturned
    ) {}

WINBOOL
STDCALL
EnumServicesStatusA(
    SC_HANDLE               hSCManager,
    DWORD                   dwServiceType,
    DWORD                   dwServiceState,
    LPENUM_SERVICE_STATUS  lpServices,
    DWORD                   cbBufSize,
    LPDWORD                 pcbBytesNeeded,
    LPDWORD                 lpServicesReturned,
    LPDWORD                 lpResumeHandle
    ) {}

WINBOOL
STDCALL
GetServiceKeyNameA(
    SC_HANDLE               hSCManager,
    LPCSTR                lpDisplayName,
    LPSTR                 lpServiceName,
    LPDWORD                 lpcchBuffer
    ) {}

WINBOOL
STDCALL
GetServiceDisplayNameA(
    SC_HANDLE               hSCManager,
    LPCSTR                lpServiceName,
    LPSTR                 lpDisplayName,
    LPDWORD                 lpcchBuffer
    ) {}

SC_HANDLE
STDCALL
OpenSCManagerA(
    LPCSTR lpMachineName,
    LPCSTR lpDatabaseName,
    DWORD   dwDesiredAccess
    ) {}

SC_HANDLE
STDCALL
OpenServiceA(
    SC_HANDLE   hSCManager,
    LPCSTR    lpServiceName,
    DWORD       dwDesiredAccess
    ) {}

WINBOOL
STDCALL
QueryServiceConfigA(
    SC_HANDLE               hService,
    LPQUERY_SERVICE_CONFIG lpServiceConfig,
    DWORD                   cbBufSize,
    LPDWORD                 pcbBytesNeeded
    ) {}

WINBOOL
STDCALL
QueryServiceLockStatusA(
    SC_HANDLE                       hSCManager,
    LPQUERY_SERVICE_LOCK_STATUS    lpLockStatus,
    DWORD                           cbBufSize,
    LPDWORD                         pcbBytesNeeded
    ) {}

SERVICE_STATUS_HANDLE
STDCALL
RegisterServiceCtrlHandlerA(
    LPCSTR             lpServiceName,
    LPHANDLER_FUNCTION   lpHandlerProc
    ) {}

WINBOOL
STDCALL
StartServiceCtrlDispatcherA(
			    LPSERVICE_TABLE_ENTRY    lpServiceStartTable
			    ) {}

WINBOOL
STDCALL
StartServiceA(
	      SC_HANDLE            hService,
	      DWORD                dwNumServiceArgs,
	      LPCSTR             *lpServiceArgVectors
	      ) {}

/* Extensions to OpenGL */

WINBOOL STDCALL
wglUseFontBitmapsA(HDC hDC, DWORD d1, DWORD d2, DWORD d3) {}

WINBOOL STDCALL
wglUseFontOutlinesA(HDC hDC, DWORD d1, DWORD d2, DWORD d3, FLOAT f1,
		    FLOAT f2, int v1, LPGLYPHMETRICSFLOAT gliphMetricsFloat) {}

/* ------------------------------------- */
/* From shellapi.h in old Cygnus headers */

unsigned int WINAPI
DragQueryFileA(HDROP hDrop, unsigned int v1, char *str, unsigned int v2) {}

HICON WINAPI
ExtractAssociatedIconA (HINSTANCE hInst, char *s1, WORD *v1) {}

HICON WINAPI
ExtractIconA (HINSTANCE hInst, const char *s1, unsigned int v1) {}

HINSTANCE WINAPI
FindExecutableA (const char *s1, const char *s2, char *s3) {}

int WINAPI
ShellAboutA (HWND hWnd, const char *s1, const char *s2, HICON hIcon) {}

HINSTANCE WINAPI
ShellExecuteA (HWND hWnd, const char *s1, const char *s2, char *s3,
		const char *s4, int v1) {}

/* end of stuff from shellapi.h in old Cygnus headers */
/* -------------------------------------------------- */
/* From ddeml.h in old Cygnus headers */

HSZ WINAPI
DdeCreateStringHandleA (DWORD d1, char *s1, int v1) {}

UINT WINAPI
DdeInitializeA (DWORD *d1, CALLB callB, DWORD d2, DWORD d3) {}

DWORD WINAPI
DdeQueryStringA (DWORD d1, HSZ hSz, char *p1, DWORD d2, int v1) {}

/* end of stuff from ddeml.h in old Cygnus headers */
/* ----------------------------------------------- */

WINBOOL STDCALL LogonUserA (LPSTR s1, LPSTR s2, LPSTR s3,
			DWORD d1, DWORD d2, HANDLE *handle) {}
WINBOOL STDCALL CreateProcessAsUserA (HANDLE handle, LPCTSTR s1, LPTSTR s2,
	SECURITY_ATTRIBUTES*securityAttributes1,
	SECURITY_ATTRIBUTES*securityAttributes2, WINBOOL b1, DWORD d1,
	LPVOID ptr,
	LPCTSTR s3, STARTUPINFO*startupInfo, PROCESS_INFORMATION*procInfo) {}

WINBOOL WINAPI PlaySoundA (LPCSTR pszSound, HMODULE hmod, DWORD fdwSound) {}

/*
   RES - Missing defines for print manager functions
*/
BOOL
WINAPI
OpenPrinterA(
   LPSTR    pPrinterName,
   LPHANDLE phPrinter,
   LPPRINTER_DEFAULTSA pDefault
) {}

LONG
WINAPI
DocumentPropertiesA(
    HWND      hWnd,
    HANDLE    hPrinter,
    LPSTR   pDeviceName,
    PDEVMODEA pDevModeOutput,
    PDEVMODEA pDevModeInput,
    DWORD     fMode
) {}

#ifdef __cplusplus
}
#endif /* __cplusplus */

#endif	/* RC_INVOKED */

#endif /* _GNU_H_WINDOWS32_ASCIIFUNCTIONS */
