VxDJmp(UniCharToOEM)
	}

UINT NAKED UniToUpper(string_t pUniUpStr, string_t pUniStr, UINT length)
	{
	VxDJmp(UniToUpper)
	}

UINT NAKED CreateBasis(string_t pBasisName, string_t pUniName, UINT length)
	{
	VxDJmp(CreateBasis)
	}

int NAKED MatchBasisName(string_t pBasisName, string_t pName)
	{
	VxDJmp(MatchBasisName)
	}

int NAKED AppendBasisTail(string_t pBasisName, int tail)
	{
	VxDJmp(AppendBasisTail)
	}

int NAKED FcbToShort(string_t p83name, string_t pFCBName, int trailDot)
	{
	VxDJmp(FcbToShort)
	}

int NAKED ShortToFcb(string_t pFCBName, string_t p83Name, UINT length)
	{
	VxDJmp(ShortToFcb)
	}

int NAKED ShortToLossyFcb(string_t pFCBName, string_t p83Name, UINT length)
	{
	VxDJmp(ShortToLossyFcb)
	}

typedef struct _CONVTABLES
	{
	DWORD	ct_length;
	PDWORD	ct_UniToWinAnsiTbl;
	PDWORD	ct_UniToOemTbl;
	PDWORD	ct_WinAnsiToUniTbl;
	PDWORD	ct_OemToUniTable;
	PDWORD	ct_UniToUpperDeltaTbl;
	PDWORD	ct_UniToUpperTbl;
	} _CONVTABLES, *_PCONVTABLES;

_PCONVTABLES NAKED IFSMgr_GetConversionTablePtrs()
	{
	VxDJmp(IFSMgr_GetConversionTablePtrs)
	}

int NAKED IFSMgr_ParsePath(pioreq pir)
	{
	VxDJmp(IFSMgr_ParsePath)
	}

int NAKED IFSMgr_FSDParsePath(pioreq pir)
	{
	VxDJmp(IFSMgr_FSDParsePath)
	}

int NAKED IFSMgr_ParseOneElement(USHORT* pe_unichars)
	{
	VxDJmp(IFSMgr_ParseOneElement)
	}

int NAKED IFSMgr_CheckAccessConflict(int fSortCompatibleDisable, fmode_t pfmode, int (*pfn)(fmode_t*, const void*), const void* FSDCookie)
	{
	VxDJmp(IFSMgr_CheckAccessConflict)
	}

int NAKED IFSMgr_LockFile(void** ppFSDLockListHead, DWORD LockOffset, DWORD LockLength, DWORD LockOwner, PVOID pOpenFileInstance, DWORD fLockSemantics)
	{
	VxDJmp(IFSMgr_LockFile)
	}

int NAKED IFSMgr_UnlockFile(void** ppFSDLockListHead, DWORD LockOffset, DWORD LockLength, DWORD LockOwner, PVOID pOpenFileInstance, DWORD fLockSemantics)
	{
	VxDJmp(IFSMgr_UnlockFile)
	}

VOID NAKED IFSMgr_RemoveLocks(void** ppFSDLockListHead, DWORD LockOwner, PVOID pOpenFileInstance)
	{
	VxDJmp(IFSMgr_RemoveLocks)
	}

int NAKED IFSMgr_CheckLocks(PVOID pFSDLockListHead, DWORD Offset, DWORD Length, DWORD Process, PVOID pOpenFileInstance, DWORD fOperation)
	{
	VxDJmp(IFSMgr_CheckLocks)
	}

int NAKED IFSMgr_CountLocks(PVOID pFSDLockListHead, PVOID pOpenFileInstance)
	{
	VxDJmp(IFSMgr_CountLocks)
	}

VOID NAKED IFSMgr_UnassignLockList(PVOID pFSDLockListHead)
	{
	VxDJmp(IFSMgr_UnassignLockList)
	}

VOID NAKED IFSMgr_ReassignLockFileInst(PVOID pFSDLockListhead, PVOID pOldOpenFileInstance, PVOID pNewOpenFileInstance)
	{
	VxDJmp(IFSMgr_ReassignLockFileInst)
	}

VOID NAKED NotifyVolumeArrival(UINT drive)
	{
	VxDJmp(NotifyVolumeArrival)
	}

int NAKED QueryVolumeRemoval(UINT drive, int fDialog)
	{
	VxDJmp(QueryVolumeRemoval)
	}

VOID NAKED NotifyVolumeRemoval(UINT drive)
	{
	VxDJmp(NotifyVolumeRemoval)
	}

int NAKED IFSMgr_PNPEvent(UINT Message, UINT Resource, UINT Flags)
	{
	VxDJmp(IFSMgr_PNPEvent)
	}

int NAKED _VolFlush(UINT Volume, int Flags)
	{
	VxDJmp(_VolFlush)
	}

VOID NAKED IFSMgr_CompleteAsync(pioreq pir)
	{
	VxDJmp(IFSMgr_CompleteAsync)
	}

int VXDINLINE R0_OpenCreateFile(BOOL incontext, WORD modeflags, WORD attrib, BYTE action, BYTE flags, char* pathname, PDWORD phandle, PDWORD paction)
	{
	DWORD opcode = incontext ? R0_OPENCREAT_IN_CONTEXT : R0_OPENCREATFILE;
	WORD result;
	_asm
		{
		mov	eax, opcode
		mov bx, modeflags
		mov cx, attrib
		mov dl, action
		mov dh, flags
		mov esi, pathname
		}
	VxDCall(IFSMgr_Ring0_FileIO)
	_asm
		{
		jc	error
		mov ebx, phandle
		mov [ebx], eax
		mov ebx, paction
		movzx ecx, cl
		mov [ebx], ecx
		xor eax, eax
		
	error:
		mov	result, ax
		}
	return result;
	}

int VXDINLINE R0_ReadFile(BOOL incontext, DWORD handle, DWORD count, DWORD pos, PBYTE buffer, PDWORD nread)
	{
	DWORD opcode = incontext ? R0_READFILE_IN_CONTEXT : R0_READFILE;
	WORD result;
	_asm
		{
		mov	eax, opcode
		mov	ebx, handle
		mov ecx, count
		mov edx, pos
		mov esi, buffer
		}
	VxDCall(IFSMgr_Ring0_FileIO)
	_asm
		{
		jc	error
		mov ebx, nread
		mov [ebx], ecx
		xor eax, eax
	error:
		mov	result, ax
		}
	return result;
	}

int VXDINLINE R0_WriteFile(BOOL incontext, DWORD handle, DWORD count, DWORD pos, const BYTE* buffer, PDWORD nwritten)
	{
	DWORD opcode = incontext ? R0_WRITEFILE_IN_CONTEXT : R0_WRITEFILE;
	WORD result;
	_asm
		{
		mov	eax, opcode
		mov	ebx, handle
		mov ecx, count
		mov edx, pos
		mov esi, buffer
		}
	VxDCall(IFSMgr_Ring0_FileIO)
	_asm
		{
		jc	error
		mov ebx, nwritten
		mov [ebx], ecx
		xor eax, eax
	error:
		mov result, ax
		}
	return result;
	}

int VXDINLINE R0_CloseFile(DWORD handle)
	{
	_asm
		{
		mov	eax, R0_CLOSEFILE
		mov ebx, handle
		}
	VxDCall(IFSMgr_Ring0_FileIO)
	_asm jc error
	_asm xor eax, eax
	_asm error:
	_asm movzx eax, ax
	}

int VXDINLINE R0_GetFileSize(DWORD handle, PDWORD psize)
	{
	_asm
		{
		mov	eax, R0_GETFILESIZE
		mov ebx, handle
		}
	VxDCall(IFSMgr_Ring0_FileIO)
	_asm
		{
		jc	error
		mov ebx, psize
		mov [ebx], eax
		xor	eax, eax
	error:
		movzx eax, ax
		}
	}

int VXDINLINE R0_FindFirstFile(WORD attrib, const char* pathname, _WIN32_FIND_DATA* fd, PDWORD phandle)
	{
	_asm
		{
		mov	eax, R0_FINDFIRSTFILE
		mov	esi, pathname
		mov edx, fd
		mov	cx, attrib
		}
	VxDCall(IFSMgr_Ring0_FileIO)
	_asm
		{
		jc	error
		mov ebx, phandle
		mov [ebx], eax
		xor eax, eax
	error:
		movzx eax, ax
		}
	}

int VXDINLINE R0_FindNextFile(DWORD handle, _WIN32_FIND_DATA* fd)
	{
	_asm
		{
		mov	eax, R0_FINDNEXTFILE
		mov ebx, handle
		mov edx, fd
		}
	VxDCall(IFSMgr_Ring0_FileIO)
	_asm jc error
	_asm xor eax, eax
	_asm error:
	_asm movzx eax, ax
	}

int VXDINLINE R0_FindClose(DWORD handle)
	{
	_asm
		{
		mov	eax, R0_FINDCLOSEFILE
		mov ebx, handle
		}
	VxDCall(IFSMgr_Ring0_FileIO)
	_asm jc error
	_asm xor eax, eax
	_asm error:
	_asm movzx eax, ax
	}

int VXDINLINE R0_GetFileAttributes(const char* pathname, PWORD pattrib)
	{
	_asm
		{
		mov	eax, R0_FILEATTRIBUTES or GET_ATTRIBUTES
		mov esi, pathname
		}
	VxDCall(IFSMgr_Ring0_FileIO)
	_asm
		{
		jc	error
		mov ebx, pattrib
		mov word ptr [ebx], cx
		xor eax, eax
	error:
		movzx eax, ax
		}
	}

int VXDINLINE R0_SetFileAttributes(const char* pathname, WORD attrib)
	{
	_asm
		{
		mov	eax, R0_FILEATTRIBUTES or SET_ATTRIBUTES
		mov cx, attrib
		mov esi, pathname
		}
	VxDCall(IFSMgr_Ring0_FileIO)
	_asm jc error
	_asm xor eax, eax
	_asm error:
	_asm movzx eax, ax
	}

int VXDINLINE R0_RenameFile(const char* oldname, const char* newname)
	{
	_asm
		{
		mov	eax, R0_RENAMEFILE
		mov esi, oldname
		mov edx, newname
		}
	VxDCall(IFSMgr_Ring0_FileIO)
	_asm jc error
	_asm xor eax, eax
	_asm error:
	_asm movzx eax, ax
	}

int VXDINLINE R0_DeleteFile(const char* pathname, WORD attrib)
	{
	_asm
		{
		mov eax, R0_DELETEFILE
		mov cx, attrib
		mov esi, pathname
		}
	VxDCall(IFSMgr_Ring0_FileIO)
	_asm jc error
	_asm xor eax, eax
	_asm error:
	_asm movzx eax, ax
	}

int VXDINLINE R0_LockFile(DWORD handle, DWORD pid, DWORD dwOffset, DWORD dwLength)
	{
	_asm
		{
		mov eax, R0_LOCKFILE or LOCK_REGION
		mov ebx, handle
		mov ecx, pid
		mov edx, dwOffset
		mov esi, dwLength
		}
	VxDCall(IFSMgr_Ring0_FileIO)
	_asm jc error
	_asm xor eax, eax
	_asm error:
	_asm movzx eax, ax
	}

int VXDINLINE R0_UnlockFile(DWORD handle, DWORD pid, DWORD dwOffset, DWORD dwLength)
	{
	_asm
		{
		mov eax, R0_LOCKFILE or UNLOCK_REGION
		mov ebx, handle
		mov ecx, pid
		mov edx, dwOffset
		mov esi, dwLength
		}
	VxDCall(IFSMgr_Ring0_FileIO)
	_asm jc error
	_asm xor eax, eax
	_asm error:
	_asm movzx eax, ax
	}

int VXDINLINE R0_GetDiskFreeSpace(BYTE drive, PWORD pspc, PWORD pavl, PWORD psecsize, PWORD ptot)
	{
	_asm
		{
		mov	eax, R0_GETDISKFREESPACE
		mov dl, drive
		}
	VxDCall(IFSMgr_Ring0_FileIO)
	_asm
		{
		jc	error
		mov esi, pspc
		mov word ptr [esi], ax		; sectors per cluster
		mov esi, pavl
		mov word ptr [esi], bx		; available clusters
		mov esi, psecsize
		mov word ptr [esi], cx		; bytes per sector
		mov esi, ptot
		mov word ptr [esi], dx		; total clusters on disk
		xor eax, eax
	error:
		movzx eax, ax
		}
	}

int VXDINLINE R0_ReadAbsoluteDisk(BYTE drive, UINT nsectors, DWORD sector, PBYTE buffer)
	{
	_asm
		{
		mov	al, drive
		mov ah, R0_READABSOLUTEDISK shr 8
		mov ecx, nsectors
		mov edx, sector
		mov esi, buffer
		}
	VxDCall(IFSMgr_Ring0_FileIO)
	_asm jc error
	_asm xor eax, eax
	_asm error:
	_asm movzx eax, ax
	}

int VXDINLINE R0_WriteAbsoluteDisk(BYTE drive, UINT nsectors, DWORD sector, const BYTE* buffer)
	{
	_asm
		{
		mov	al, drive
		mov ah, R0_WRITEABSOLUTEDISK shr 8
		mov ecx, nsectors
		mov edx, sector
		mov esi, buffer
		}
	VxDCall(IFSMgr_Ring0_FileIO)
	_asm jc error
	_asm xor eax, eax
	_asm error:
	_asm movzx eax, ax
	}

int VXDINLINE IFSMgr_Ring0GetDriveInfo(UINT drive)
	{
	_asm mov edx, drive
	VxDCall(IFSMgr_Ring0_FileIO)
	_asm
		{
		jnc	noerror
		mov eax, -1
	noerror:
		}
	}

ppIFSFileHookFunc NAKED IFSMgr_InstallFileSystemApiHook(pIFSFileHookFunc fcn)
	{
	VxDJmp(IFSMgr_InstallFileSystemApiHook)
	}

int NAKED IFSMgr_RemoveFileSystemApiHook(pIFSFileHookFunc fcn)
	{
	VxDJmp(IFSMgr_RemoveFileSystemApiHook)
	}

int NAKED IFSMgr_CDROM_Attach(DWORD drive, struct _VRP** pvrp, int fDoMount)
	{
	VxDJmp(IFSMgr_CDROM_Attach)
	}

int NAKED IFSMgr_CDROM_Detach(DWORD Drive, struct _VRP* vrp)
	{
	VxDJmp(IFSMgr_CDROM_Detach)
	}

int NAKED IFSMgr_FSDUnmountCFSD(DWORD rh)
	{
	VxDJmp(IFSMgr_FSDUnmountCFSD)
	}

int NAKED IFSMgr_MountChildVolume(struct _VRP* vrp, DWORD drive)
	{
	VxDJmp(IFSMgr_MountChildVolume)
	}

int NAKED IFSMgr_UnmountChildVolume(struct _VRP* vrp, DWORD drive)
	{
	VxDJmp(IFSMgr_UnmountChildVolume)
	}

int NAKED IFSMgr_SwapDrives(struct _VRP* vrp, DWORD drive1, DWORD drive2)
	{
	VxDJmp(IFSMgr_SwapDrives)
	}

int NAKED IFSMgr_FSDGetCurrentDrive(pioreq pir)
	{
	VxDJmp(IFSMgr_FSDGetCurrentDrive)
	}

int NAKED _GetMappedErr(UINT Function, UINT ExtErr)
	{
	VxDJmp(_GetMappedErr)
	}

int NAKED IFSMgr_GetLockState(DWORD drive, PDWORD pLockType, PDWORD pLockFlags, PDWORD pLockOwner)
	{
	VxDJmp(IFSMgr_GetLockState)
	}

BOOL VXDINLINE Query_PhysLock(DWORD unit)
	{
	_asm mov eax, unit
	VxDCall(Query_PhysLock)
	_asm sbb eax, eax			; CF set if process doesn't own volume lock, so return is -1 if unowned, 0 if owned
	}

VOID NAKED IFSMgr_printf(const char* pfstr, ...)
	{
	VxDJmp(IFSMgr_printf)
	}

#ifdef DEBUG
#define IFSASSERT(x) if (!(x)) IFSMgr_AssertFailed(#x, __FILE__, __LINE__)
VOID NAKED IFSMgr_AssertFailed(const char* msg, const char* pfname, DWORD line)
	{
	VxDJmp(IFSMgr_AssertFailed)
	}
VOID NAKED IFSMgr_LogEntry(const char* name, DWORD info1, DWORD info2, int sdepth, DWORD mask)
	{
	VxDJmp(IFSMgr_LogEntry)
	}
DWORD NAKED IFSMgr_DebugMenu(PVOID pm)
	{
	VxDJmp(IFSMgr_DebugMenu)
	}
DWORD NAKED IFSMgr_DebugVars()
	{
	VxDJmp(IFSMgr_DebugVars)
	}
int NAKED IFSMgr_GetDebugString(const char* prompt, char* buffer, UINT length)
	{
	VxDJmp(IFSMgr_GetDebugString)
	}
int NAKED IFSMgr_GetDebugHexNum(const char* prompt, PDWORD phexval)
	{
	VxDJmp(IFSMgr_GetDebugHexNum)
	}
DWORD NAKED IFSMgr_DbgSetFileHandleLimit(DWORD MaxHandles)
	{
	VxDJmp(IFSMgr_DbgSetFileHandleLimit)
	}
#else
#define IFSASSERT(x)
#define IFSMgr_Assert_Failed(a1, a2, a3)
#define IFSMgr_LogEntry(a1, a2, a3, a4, a5)
#define IFSMgr_DebugMenu(a1) NULL
#define IFSMgr_DebugVars() NULL
#define IFSMgr_GetDebugString(a1, a2, a3) 0
#define IFSMgr_GetDebugHexNum(a1, a2) 0
#define IFSMgr_DbgSetFileHandleLimit(a1) a1
#endif

//#pragma warning(default:4035)
#endif // Not_VxD

#endif // IFSMGR_SERVICES_ONLY

#ifdef __cplusplus
}
#endif

#endif // IFSMGR_H