ULONG Size;
ULONG i;
LONG Error;
- BOOL Changed;
+ BOOLEAN Changed;
/* Count the number of visible drives */
DiskReportError(FALSE);
BOOLEAN AcpiPresent = FALSE;
-static BOOL
+static BOOLEAN
FindAcpiBios(VOID)
{
PUCHAR Ptr;
#define NDEBUG
#include <debug.h>
-static BOOL
+static BOOLEAN
FindApmBios(VOID)
{
REGS RegsIn;
ULONG edx = 0;
ULONG *Ptr;
LONG Error;
- BOOL SupportTSC = FALSE;
+ BOOLEAN SupportTSC = FALSE;
ULONG CpuSpeed;
}
-static BOOL
+static BOOLEAN
DetectMps(FRLDRHKEY CpuKey,
FRLDRHKEY FpuKey)
{
}
-static BOOL
+static BOOLEAN
FindPciBios(PCM_PCI_BUS_DATA BusData)
{
REGS RegsIn;
#ifdef __i386__
-BOOL DiskResetController(ULONG DriveNumber)
+BOOLEAN DiskResetController(ULONG DriveNumber)
{
REGS RegsIn;
REGS RegsOut;
return INT386_SUCCESS(RegsOut);
}
-BOOL DiskInt13ExtensionsSupported(ULONG DriveNumber)
+BOOLEAN DiskInt13ExtensionsSupported(ULONG DriveNumber)
{
REGS RegsIn;
REGS RegsOut;
WRITE_PORT_UCHAR((PUCHAR)0x3F2, 0);
}
-BOOL DiskGetExtendedDriveParameters(ULONG DriveNumber, PVOID Buffer, USHORT BufferSize)
+BOOLEAN DiskGetExtendedDriveParameters(ULONG DriveNumber, PVOID Buffer, USHORT BufferSize)
{
REGS RegsIn;
REGS RegsOut;
return TRUE;
}
-BOOL i386DiskGetBootVolume(PULONG DriveNumber, PULONGLONG StartSector, PULONGLONG SectorCount, int *FsType)
+BOOLEAN i386DiskGetBootVolume(PULONG DriveNumber, PULONGLONG StartSector, PULONGLONG SectorCount, int *FsType)
{
PARTITION_TABLE_ENTRY PartitionTableEntry;
UCHAR VolumeType;
((char *)BootDevice)[1] = (char)i386BootPartition;
}
-BOOL
+BOOLEAN
i386DiskBootingFromFloppy(VOID)
{
return i386BootDrive < 0x80;
((P) == PARTITION_EXTENDED || \
(P) == PARTITION_XINT13_EXTENDED)
-BOOL i386DiskGetSystemVolume(char *SystemPath,
+BOOLEAN i386DiskGetSystemVolume(char *SystemPath,
char *RemainingPath,
PULONG Device,
PULONG DriveNumber,
return FALSE;
}
-BOOL
+BOOLEAN
i386DiskGetBootPath(char *BootPath, unsigned Size)
{
static char Path[] = "multi(0)disk(0)";
return TRUE;
}
-BOOL
+BOOLEAN
i386DiskNormalizeSystemPath(char *SystemPath, unsigned Size)
{
CHAR BootPath[256];
*
*--*/
VOID
-STDCALL
+NTAPI
FrLdrStartup(ULONG Magic)
{
/* Disable Interrupts */
* None.
*
*--*/
-BOOL
-STDCALL
+BOOLEAN
+NTAPI
FrLdrMapKernel(FILE *KernelImage)
{
PIMAGE_DOS_HEADER ImageHeader;
}
ULONG_PTR
-STDCALL
+NTAPI
FrLdrLoadModule(FILE *ModuleImage,
LPCSTR ModuleName,
PULONG ModuleSize)
}
ULONG_PTR
-STDCALL
+NTAPI
FrLdrCreateModule(LPCSTR ModuleName)
{
PLOADER_MODULE ModuleData;
return(ModuleData->ModStart);
}
-BOOL
-STDCALL
+BOOLEAN
+NTAPI
FrLdrCloseModule(ULONG_PTR ModuleBase,
ULONG ModuleSize)
{
Int386(0x10, &Regs, &Regs);
}
-BOOL
+BOOLEAN
PcConsKbHit(VOID)
{
REGS Regs;
PcConsGetCh(void)
{
REGS Regs;
- static BOOL ExtendedKey = FALSE;
+ static BOOLEAN ExtendedKey = FALSE;
static char ExtendedScanCode = 0;
/* If the last time we were called an
// FUNCTIONS
/////////////////////////////////////////////////////////////////////////////////////////////
-static BOOL PcDiskResetController(ULONG DriveNumber)
+static BOOLEAN PcDiskResetController(ULONG DriveNumber)
{
REGS RegsIn;
REGS RegsOut;
return INT386_SUCCESS(RegsOut);
}
-static BOOL PcDiskReadLogicalSectorsLBA(ULONG DriveNumber, ULONGLONG SectorNumber, ULONG SectorCount, PVOID Buffer)
+static BOOLEAN PcDiskReadLogicalSectorsLBA(ULONG DriveNumber, ULONGLONG SectorNumber, ULONG SectorCount, PVOID Buffer)
{
REGS RegsIn;
REGS RegsOut;
return FALSE;
}
-static BOOL PcDiskReadLogicalSectorsCHS(ULONG DriveNumber, ULONGLONG SectorNumber, ULONG SectorCount, PVOID Buffer)
+static BOOLEAN PcDiskReadLogicalSectorsCHS(ULONG DriveNumber, ULONGLONG SectorNumber, ULONG SectorCount, PVOID Buffer)
{
ULONG PhysicalSector;
ULONG PhysicalHead;
return TRUE;
}
-static BOOL PcDiskInt13ExtensionsSupported(ULONG DriveNumber)
+static BOOLEAN PcDiskInt13ExtensionsSupported(ULONG DriveNumber)
{
static ULONG LastDriveNumber = 0xffffffff;
- static BOOL LastSupported;
+ static BOOLEAN LastSupported;
REGS RegsIn;
REGS RegsOut;
return TRUE;
}
-BOOL PcDiskReadLogicalSectors(ULONG DriveNumber, ULONGLONG SectorNumber, ULONG SectorCount, PVOID Buffer)
+BOOLEAN PcDiskReadLogicalSectors(ULONG DriveNumber, ULONGLONG SectorNumber, ULONG SectorCount, PVOID Buffer)
{
DbgPrint((DPRINT_DISK, "PcDiskReadLogicalSectors() DriveNumber: 0x%x SectorNumber: %I64d SectorCount: %d Buffer: 0x%x\n", DriveNumber, SectorNumber, SectorCount, Buffer));
return TRUE;
}
-BOOL
+BOOLEAN
PcDiskGetPartitionEntry(ULONG DriveNumber, ULONG PartitionNumber, PPARTITION_TABLE_ENTRY PartitionTableEntry)
{
/* Just use the standard routine */
return DiskGetPartitionEntry(DriveNumber, PartitionNumber, PartitionTableEntry);
}
-BOOL
+BOOLEAN
PcDiskGetDriveGeometry(ULONG DriveNumber, PGEOMETRY Geometry)
{
REGS RegsIn;
static ULONG ScreenHeight = 25; /* Screen Height in characters */
static ULONG BytesPerScanLine = 160; /* Number of bytes per scanline (delta) */
static VIDEODISPLAYMODE DisplayMode = VideoTextMode; /* Current display mode */
-static BOOL VesaVideoMode = FALSE; /* Are we using a VESA mode? */
+static BOOLEAN VesaVideoMode = FALSE; /* Are we using a VESA mode? */
static SVGA_MODE_INFORMATION VesaVideoModeInformation; /* Only valid when in VESA mode */
static ULONG CurrentMemoryBank = 0; /* Currently selected VESA bank */
WRITE_PORT_UCHAR((PUCHAR)CRTC+1, 0xDF);
}
-static BOOL
+static BOOLEAN
PcVideoVesaGetSVGAModeInformation(USHORT Mode, PSVGA_MODE_INFORMATION ModeInformation)
{
REGS Regs;
return TRUE;
}
-static BOOL
+static BOOLEAN
PcVideoSetBiosVesaMode(USHORT Mode)
{
REGS Regs;
return TRUE;
}
-static BOOL
+static BOOLEAN
PcVideoSetMode80x25(VOID)
{
PcVideoSetBiosMode(0x03);
return TRUE;
}
-static BOOL
+static BOOLEAN
PcVideoSetMode80x50_80x43(VOID)
{
if (VIDEOCARD_VGA == PcVideoDetectVideoCard())
return TRUE;
}
-static BOOL
+static BOOLEAN
PcVideoSetMode80x28(VOID)
{
/* FIXME: Is this VGA-only? */
return TRUE;
}
-static BOOL
+static BOOLEAN
PcVideoSetMode80x30(VOID)
{
/* FIXME: Is this VGA-only? */
return TRUE;
}
-static BOOL
+static BOOLEAN
PcVideoSetMode80x34(VOID)
{
/* FIXME: Is this VGA-only? */
return TRUE;
}
-static BOOL
+static BOOLEAN
PcVideoSetMode80x43(VOID)
{
/* FIXME: Is this VGA-only? */
return TRUE;
}
-static BOOL
+static BOOLEAN
PcVideoSetMode80x60(VOID)
{
/* FIXME: Is this VGA-only? */
return TRUE;
}
-static BOOL
+static BOOLEAN
PcVideoSetMode(ULONG NewMode)
{
CurrentMemoryBank = 0;
}
static VOID
-PcVideoSetBlinkBit(BOOL Enable)
+PcVideoSetBlinkBit(BOOLEAN Enable)
{
REGS Regs;
}
VIDEODISPLAYMODE
-PcVideoSetDisplayMode(char *DisplayModeName, BOOL Init)
+PcVideoSetDisplayMode(char *DisplayModeName, BOOLEAN Init)
{
ULONG VideoMode = VIDEOMODE_NORMAL_TEXT;
}
VOID
-PcVideoHideShowTextCursor(BOOL Show)
+PcVideoHideShowTextCursor(BOOLEAN Show)
{
if (Show)
{
*BufPtr = ((USHORT) Attr << 8) | (Ch & 0xff);
}
-BOOL
+BOOLEAN
PcVideoIsPaletteFixed(VOID)
{
return FALSE;
}
}
-BOOL
+BOOLEAN
XboxConsKbHit(VOID)
{
/* No keyboard support yet */
* PVOID Buffer Buffer for output data
*
* RETURNS:
- * BOOL: TRUE success, FALSE error
+ * BOOLEAN: TRUE success, FALSE error
*/
-static BOOL
+static BOOLEAN
XboxDiskPolledRead(ULONG CommandPort,
ULONG ControlPort,
UCHAR PreComp,
{
ULONG SectorCount = 0;
ULONG RetryCount;
- BOOL Junk = FALSE;
+ BOOLEAN Junk = FALSE;
UCHAR Status;
/* Wait for BUSY to clear */
}
}
-BOOL
+BOOLEAN
XboxDiskReadLogicalSectors(ULONG DriveNumber, ULONGLONG SectorNumber, ULONG SectorCount, PVOID Buffer)
{
ULONG StartSector;
return TRUE;
}
-BOOL
+BOOLEAN
XboxDiskGetPartitionEntry(ULONG DriveNumber, ULONG PartitionNumber, PPARTITION_TABLE_ENTRY PartitionTableEntry)
{
UCHAR SectorData[IDE_SECTOR_BUF_SZ];
return DiskGetPartitionEntry(DriveNumber, PartitionNumber, PartitionTableEntry);
}
-BOOL
+BOOLEAN
XboxDiskGetDriveGeometry(ULONG DriveNumber, PGEOMETRY Geometry)
{
IDE_DRIVE_IDENTIFY DrvParms;
ULONG i;
- BOOL Atapi;
+ BOOLEAN Atapi;
Atapi = FALSE; /* FIXME */
/* Get the Drive Identify block from drive or die */
#define I2C_IO_BASE 0xc000
-static BOOL
+static BOOLEAN
WriteToSMBus(UCHAR Address, UCHAR bRegister, UCHAR Size, ULONG Data_to_smbus)
{
int nRetriesToLive=50;
}
-static BOOL
+static BOOLEAN
ReadfromSMBus(UCHAR Address, UCHAR bRegister, UCHAR Size, ULONG *Data_to_smbus)
{
int nRetriesToLive=50;
return FALSE;
}
-BOOL
+BOOLEAN
I2CTransmitByteGetReturn(UCHAR bPicAddressI2cFormat, UCHAR bDataToWrite, ULONG *Return)
{
return ReadfromSMBus(bPicAddressI2cFormat, bDataToWrite, 1, Return);
}
// transmit a word, no returned data from I2C device
-static BOOL
+static BOOLEAN
I2CTransmitWord(UCHAR bPicAddressI2cFormat, USHORT wDataToWrite)
{
return WriteToSMBus(bPicAddressI2cFormat,(wDataToWrite>>8)&0xff,1,(wDataToWrite&0xff));
#define MAKE_COLOR(Red, Green, Blue) (0xff000000 | (((Red) & 0xff) << 16) | (((Green) & 0xff) << 8) | ((Blue) & 0xff))
-BOOL I2CTransmitByteGetReturn(UCHAR bPicAddressI2cFormat, UCHAR bDataToWrite, ULONG *Return);
+BOOLEAN I2CTransmitByteGetReturn(UCHAR bPicAddressI2cFormat, UCHAR bDataToWrite, ULONG *Return);
static VOID
XboxVideoOutputChar(UCHAR Char, unsigned X, unsigned Y, ULONG FgColor, ULONG BgColor)
}
static VOID
-XboxVideoClearScreenColor(ULONG Color, BOOL FullScreen)
+XboxVideoClearScreenColor(ULONG Color, BOOLEAN FullScreen)
{
ULONG Line, Col;
PULONG p;
}
VIDEODISPLAYMODE
-XboxVideoSetDisplayMode(char *DisplayMode, BOOL Init)
+XboxVideoSetDisplayMode(char *DisplayMode, BOOLEAN Init)
{
/* We only have one mode, semi-text */
return VideoTextMode;
}
VOID
-XboxVideoHideShowTextCursor(BOOL Show)
+XboxVideoHideShowTextCursor(BOOLEAN Show)
{
/* We don't have a cursor yet */
}
}
}
-BOOL
+BOOLEAN
XboxVideoIsPaletteFixed(VOID)
{
return FALSE;
return 0;
}
-BOOL PpcConsKbHit() {
+BOOLEAN PpcConsKbHit() {
return TRUE;
}
ofw_print_string("ClearScreen\n");
}
-VIDEODISPLAYMODE PpcVideoSetDisplayMode( char *DisplayMode, BOOL Init ) {
+VIDEODISPLAYMODE PpcVideoSetDisplayMode( char *DisplayMode, BOOLEAN Init ) {
printf( "DisplayMode: %s %s\n", DisplayMode, Init ? "true" : "false" );
return VideoGraphicsMode;
}
printf("SetTextCursorPosition(%d,%d)\n", X,Y);
}
-VOID PpcVideoHideShowTextCursor( BOOL Show ) {
+VOID PpcVideoHideShowTextCursor( BOOLEAN Show ) {
printf("HideShowTextCursor(%s)\n", Show ? "true" : "false");
}
printf( "CopyOffScreenBufferToVRAM(%x)\n", Buffer );
}
-BOOL PpcVideoIsPaletteFixed() {
+BOOLEAN PpcVideoIsPaletteFixed() {
return FALSE;
}
* away with grabbing a partition image by tftp in this scenario.
*/
-BOOL PpcDiskGetBootVolume( PULONG DriveNumber, PULONGLONG StartSector, PULONGLONG SectorCount, int *FsType ) {
+BOOLEAN PpcDiskGetBootVolume( PULONG DriveNumber, PULONGLONG StartSector, PULONGLONG SectorCount, int *FsType ) {
*DriveNumber = 0;
*StartSector = 0;
*SectorCount = 0;
return TRUE;
}
-BOOL PpcDiskGetSystemVolume( char *SystemPath,
+BOOLEAN PpcDiskGetSystemVolume( char *SystemPath,
char *RemainingPath,
PULONG Device,
PULONG DriveNumber,
return FALSE;
}
-BOOL PpcDiskGetBootPath( char *OutBootPath, unsigned Size ) {
+BOOLEAN PpcDiskGetBootPath( char *OutBootPath, unsigned Size ) {
strncpy( OutBootPath, BootPath, Size );
return TRUE;
}
BootDevice[0] = BootDevice[1] = 0;
}
-BOOL PpcDiskBootingFromFloppy(VOID) {
+BOOLEAN PpcDiskBootingFromFloppy(VOID) {
return FALSE;
}
-BOOL PpcDiskReadLogicalSectors( ULONG DriveNumber, ULONGLONG SectorNumber,
+BOOLEAN PpcDiskReadLogicalSectors( ULONG DriveNumber, ULONGLONG SectorNumber,
ULONG SectorCount, PVOID Buffer ) {
int rlen = 0;
return rlen > 0;
}
-BOOL PpcDiskGetPartitionEntry( ULONG DriveNumber, ULONG PartitionNumber,
+BOOLEAN PpcDiskGetPartitionEntry( ULONG DriveNumber, ULONG PartitionNumber,
PPARTITION_TABLE_ENTRY PartitionTableEntry ) {
printf("GetPartitionEntry(%d,%d)\n", DriveNumber, PartitionNumber);
return FALSE;
}
-BOOL PpcDiskGetDriveGeometry( ULONG DriveNumber, PGEOMETRY DriveGeometry ) {
+BOOLEAN PpcDiskGetDriveGeometry( ULONG DriveNumber, PGEOMETRY DriveGeometry ) {
printf("GetGeometry(%d)\n", DriveNumber);
DriveGeometry->BytesPerSector = 512;
DriveGeometry->Heads = 16;
void beep() {
}
-UCHAR STDCALL READ_PORT_UCHAR(PUCHAR Address) {
+UCHAR NTAPI READ_PORT_UCHAR(PUCHAR Address) {
return 0xff;
}
*
*--*/
VOID
-STDCALL
+NTAPI
FrLdrStartup(ULONG Magic)
{
#if 0
* None.
*
*--*/
-BOOL
-STDCALL
+BOOLEAN
+NTAPI
FrLdrMapKernel(FILE *KernelImage)
{
#if 0
}
ULONG_PTR
-STDCALL
+NTAPI
FrLdrLoadModule(FILE *ModuleImage,
LPCSTR ModuleName,
PULONG ModuleSize)
}
ULONG_PTR
-STDCALL
+NTAPI
FrLdrCreateModule(LPCSTR ModuleName)
{
#if 0
#endif
}
-BOOL
-STDCALL
+BOOLEAN
+NTAPI
FrLdrCloseModule(ULONG_PTR ModuleBase,
ULONG ModuleSize)
{
return TimeOut;
}
-BOOL MainBootMenuKeyPressFilter(ULONG KeyPress)
+BOOLEAN MainBootMenuKeyPressFilter(ULONG KeyPress)
{
if (KeyPress == KEY_F8)
{
return CacheBlock;
}
-BOOL CacheInternalFreeBlock(PCACHE_DRIVE CacheDrive)
+BOOLEAN CacheInternalFreeBlock(PCACHE_DRIVE CacheDrive)
{
PCACHE_BLOCK CacheBlockToFree;
//
///////////////////////////////////////////////////////////////////////////////////////
CACHE_DRIVE CacheManagerDrive;
-BOOL CacheManagerInitialized = FALSE;
-BOOL CacheManagerDataInvalid = FALSE;
+BOOLEAN CacheManagerInitialized = FALSE;
+BOOLEAN CacheManagerDataInvalid = FALSE;
ULONG CacheBlockCount = 0;
ULONG CacheSizeLimit = 0;
ULONG CacheSizeCurrent = 0;
-BOOL CacheInitializeDrive(ULONG DriveNumber)
+BOOLEAN CacheInitializeDrive(ULONG DriveNumber)
{
PCACHE_BLOCK NextCacheBlock;
GEOMETRY DriveGeometry;
CacheManagerDataInvalid = TRUE;
}
-BOOL CacheReadDiskSectors(ULONG DiskNumber, ULONG StartSector, ULONG SectorCount, PVOID Buffer)
+BOOLEAN CacheReadDiskSectors(ULONG DiskNumber, ULONG StartSector, ULONG SectorCount, PVOID Buffer)
{
PCACHE_BLOCK CacheBlock;
ULONG StartBlock;
return TRUE;
}
-BOOL CacheForceDiskSectorsIntoCache(ULONG DiskNumber, ULONG StartSector, ULONG SectorCount)
+BOOLEAN CacheForceDiskSectorsIntoCache(ULONG DiskNumber, ULONG StartSector, ULONG SectorCount)
{
PCACHE_BLOCK CacheBlock;
ULONG StartBlock;
return TRUE;
}
-BOOL CacheReleaseMemory(ULONG MinimumAmountToRelease)
+BOOLEAN CacheReleaseMemory(ULONG MinimumAmountToRelease)
{
ULONG AmountReleased;
/* STATIC FUNCTIONS *********************************************************/
-static BOOL Rs232DoesComPortExist(PUCHAR BaseAddress)
+static BOOLEAN Rs232DoesComPortExist(PUCHAR BaseAddress)
{
BOOLEAN found;
UCHAR mcr;
/* FUNCTIONS *********************************************************/
-BOOL Rs232PortInitialize(ULONG ComPort, ULONG BaudRate)
+BOOLEAN Rs232PortInitialize(ULONG ComPort, ULONG BaudRate)
{
ULONG BaseArray[5] = {0, 0x3F8, 0x2F8, 0x3E8, 0x2E8};
//char buffer[80];
return TRUE;
}
-BOOL Rs232PortGetByte(PUCHAR ByteRecieved)
+BOOLEAN Rs232PortGetByte(PUCHAR ByteRecieved)
{
if (PortInitialized == FALSE)
return FALSE;
return FALSE;
}
-BOOL Rs232PortPollByte(PUCHAR ByteRecieved)
+BOOLEAN Rs232PortPollByte(PUCHAR ByteRecieved)
{
if (PortInitialized == FALSE)
return FALSE;
#endif
-BOOL Rs232PortInUse(ULONG Base)
+BOOLEAN Rs232PortInUse(ULONG Base)
{
#ifdef DEBUG
return PortInitialized && Rs232PortBase == (PUCHAR)Base ? TRUE : FALSE;
//ULONG BaudRate = 19200;
ULONG BaudRate = 115200;
-BOOL DebugStartOfLine = TRUE;
+BOOLEAN DebugStartOfLine = TRUE;
VOID DebugInit(VOID)
{
#undef UNIMPLEMENTED
#define UNIMPLEMENTED BugCheck((DPRINT_WARNING, "Unimplemented\n"));
-static BOOL bReportError = TRUE;
+static BOOLEAN bReportError = TRUE;
/////////////////////////////////////////////////////////////////////////////////////////////
// FUNCTIONS
/////////////////////////////////////////////////////////////////////////////////////////////
-VOID DiskReportError (BOOL bError)
+VOID DiskReportError (BOOLEAN bError)
{
bReportError = bError;
}
}
// This function is in arch/i386/i386disk.c
-//BOOL DiskReadLogicalSectors(ULONG DriveNumber, U64 SectorNumber, ULONG SectorCount, PVOID Buffer)
+//BOOLEAN DiskReadLogicalSectors(ULONG DriveNumber, U64 SectorNumber, ULONG SectorCount, PVOID Buffer)
-BOOL DiskIsDriveRemovable(ULONG DriveNumber)
+BOOLEAN DiskIsDriveRemovable(ULONG DriveNumber)
{
// Hard disks use drive numbers >= 0x80
// So if the drive number indicates a hard disk
#define NDEBUG
#include <debug.h>
-BOOL DiskGetActivePartitionEntry(ULONG DriveNumber,
+BOOLEAN DiskGetActivePartitionEntry(ULONG DriveNumber,
PPARTITION_TABLE_ENTRY PartitionTableEntry,
ULONG *ActivePartition)
{
return TRUE;
}
-BOOL DiskGetPartitionEntry(ULONG DriveNumber, ULONG PartitionNumber, PPARTITION_TABLE_ENTRY PartitionTableEntry)
+BOOLEAN DiskGetPartitionEntry(ULONG DriveNumber, ULONG PartitionNumber, PPARTITION_TABLE_ENTRY PartitionTableEntry)
{
MASTER_BOOT_RECORD MasterBootRecord;
PARTITION_TABLE_ENTRY ExtendedPartitionTableEntry;
}
-BOOL DiskGetFirstPartitionEntry(PMASTER_BOOT_RECORD MasterBootRecord, PPARTITION_TABLE_ENTRY PartitionTableEntry)
+BOOLEAN DiskGetFirstPartitionEntry(PMASTER_BOOT_RECORD MasterBootRecord, PPARTITION_TABLE_ENTRY PartitionTableEntry)
{
ULONG Index;
return FALSE;
}
-BOOL DiskGetFirstExtendedPartitionEntry(PMASTER_BOOT_RECORD MasterBootRecord, PPARTITION_TABLE_ENTRY PartitionTableEntry)
+BOOLEAN DiskGetFirstExtendedPartitionEntry(PMASTER_BOOT_RECORD MasterBootRecord, PPARTITION_TABLE_ENTRY PartitionTableEntry)
{
ULONG Index;
return FALSE;
}
-BOOL DiskReadBootRecord(ULONG DriveNumber, ULONGLONG LogicalSectorNumber, PMASTER_BOOT_RECORD BootRecord)
+BOOLEAN DiskReadBootRecord(ULONG DriveNumber, ULONGLONG LogicalSectorNumber, PMASTER_BOOT_RECORD BootRecord)
{
char ErrMsg[64];
#ifdef DEBUG
#define NDEBUG
#include <debug.h>
-BOOL DriveMapInstalled = FALSE; // Tells us if we have already installed our drive map int 13h handler code
+BOOLEAN DriveMapInstalled = FALSE; // Tells us if we have already installed our drive map int 13h handler code
ULONG OldInt13HandlerAddress = 0; // Address of BIOS int 13h handler
ULONG DriveMapHandlerAddress = 0; // Linear address of our drive map handler
ULONG DriveMapHandlerSegOff = 0; // Segment:offset style address of our drive map handler
}
}
-BOOL DriveMapIsValidDriveString(PCSTR DriveString)
+BOOLEAN DriveMapIsValidDriveString(PCSTR DriveString)
{
ULONG Index;
ULONG Ext2InodesPerBlock = 0; // Number of inodes in one block
ULONG Ext2GroupDescPerBlock = 0; // Number of group descriptors in one block
-BOOL Ext2OpenVolume(UCHAR DriveNumber, ULONGLONG VolumeStartSector)
+BOOLEAN Ext2OpenVolume(UCHAR DriveNumber, ULONGLONG VolumeStartSector)
{
DbgPrint((DPRINT_FILESYSTEM, "Ext2OpenVolume() DriveNumber = 0x%x VolumeStartSector = %d\n", DriveNumber, VolumeStartSector));
* with info describing the file, etc. returns true
* if the file exists or false otherwise
*/
-BOOL Ext2LookupFile(PCSTR FileName, PEXT2_FILE_INFO Ext2FileInfoPointer)
+BOOLEAN Ext2LookupFile(PCSTR FileName, PEXT2_FILE_INFO Ext2FileInfoPointer)
{
UINT i;
ULONG NumberOfPathParts;
return TRUE;
}
-BOOL Ext2SearchDirectoryBufferForFile(PVOID DirectoryBuffer, ULONG DirectorySize, PCHAR FileName, PEXT2_DIR_ENTRY DirectoryEntry)
+BOOLEAN Ext2SearchDirectoryBufferForFile(PVOID DirectoryBuffer, ULONG DirectorySize, PCHAR FileName, PEXT2_DIR_ENTRY DirectoryEntry)
{
ULONG CurrentOffset;
PEXT2_DIR_ENTRY CurrentDirectoryEntry;
* Reads BytesToRead from open file and
* returns the number of bytes read in BytesRead
*/
-BOOL Ext2ReadFile(FILE *FileHandle, ULONGLONG BytesToRead, ULONGLONG* BytesRead, PVOID Buffer)
+BOOLEAN Ext2ReadFile(FILE *FileHandle, ULONGLONG BytesToRead, ULONGLONG* BytesRead, PVOID Buffer)
{
PEXT2_FILE_INFO Ext2FileInfo = (PEXT2_FILE_INFO)FileHandle;
ULONG BlockNumber;
return Ext2FileHandle->FilePointer;
}
-BOOL Ext2ReadVolumeSectors(UCHAR DriveNumber, ULONGLONG SectorNumber, ULONGLONG SectorCount, PVOID Buffer)
+BOOLEAN Ext2ReadVolumeSectors(UCHAR DriveNumber, ULONGLONG SectorNumber, ULONGLONG SectorCount, PVOID Buffer)
{
//GEOMETRY DiskGeometry;
- //BOOL ReturnValue;
+ //BOOLEAN ReturnValue;
//if (!DiskGetDriveGeometry(DriveNumber, &DiskGeometry))
//{
// return FALSE;
return CacheReadDiskSectors(DriveNumber, SectorNumber + Ext2VolumeStartSector, SectorCount, Buffer);
}
-BOOL Ext2ReadSuperBlock(VOID)
+BOOLEAN Ext2ReadSuperBlock(VOID)
{
DbgPrint((DPRINT_FILESYSTEM, "Ext2ReadSuperBlock()\n"));
return TRUE;
}
-BOOL Ext2ReadGroupDescriptors(VOID)
+BOOLEAN Ext2ReadGroupDescriptors(VOID)
{
ULONG GroupDescBlockCount;
ULONG CurrentGroupDescBlock;
return TRUE;
}
-BOOL Ext2ReadDirectory(ULONG Inode, PVOID* DirectoryBuffer, PEXT2_INODE InodePointer)
+BOOLEAN Ext2ReadDirectory(ULONG Inode, PVOID* DirectoryBuffer, PEXT2_INODE InodePointer)
{
EXT2_FILE_INFO DirectoryFileInfo;
return TRUE;
}
-BOOL Ext2ReadBlock(ULONG BlockNumber, PVOID Buffer)
+BOOLEAN Ext2ReadBlock(ULONG BlockNumber, PVOID Buffer)
{
CHAR ErrorString[80];
* Ext2ReadPartialBlock()
* Reads part of a block into memory
*/
-BOOL Ext2ReadPartialBlock(ULONG BlockNumber, ULONG StartingOffset, ULONG Length, PVOID Buffer)
+BOOLEAN Ext2ReadPartialBlock(ULONG BlockNumber, ULONG StartingOffset, ULONG Length, PVOID Buffer)
{
DbgPrint((DPRINT_FILESYSTEM, "Ext2ReadPartialBlock() BlockNumber = %d StartingOffset = %d Length = %d Buffer = 0x%x\n", BlockNumber, StartingOffset, Length, Buffer));
return (((Inode - 1) % Ext2SuperBlock->s_inodes_per_group) % Ext2InodesPerBlock);
}
-BOOL Ext2ReadInode(ULONG Inode, PEXT2_INODE InodeBuffer)
+BOOLEAN Ext2ReadInode(ULONG Inode, PEXT2_INODE InodeBuffer)
{
ULONG InodeGroupNumber;
ULONG InodeBlockNumber;
return TRUE;
}
-BOOL Ext2ReadGroupDescriptor(ULONG Group, PEXT2_GROUP_DESC GroupBuffer)
+BOOLEAN Ext2ReadGroupDescriptor(ULONG Group, PEXT2_GROUP_DESC GroupBuffer)
{
DbgPrint((DPRINT_FILESYSTEM, "Ext2ReadGroupDescriptor()\n"));
}
}
-BOOL Ext2CopyIndirectBlockPointers(ULONG* BlockList, ULONG* CurrentBlockInList, ULONG BlockCount, ULONG IndirectBlock)
+BOOLEAN Ext2CopyIndirectBlockPointers(ULONG* BlockList, ULONG* CurrentBlockInList, ULONG BlockCount, ULONG IndirectBlock)
{
ULONG* BlockBuffer = (ULONG*)FILESYSBUFFER;
ULONG CurrentBlock;
return TRUE;
}
-BOOL Ext2CopyDoubleIndirectBlockPointers(ULONG* BlockList, ULONG* CurrentBlockInList, ULONG BlockCount, ULONG DoubleIndirectBlock)
+BOOLEAN Ext2CopyDoubleIndirectBlockPointers(ULONG* BlockList, ULONG* CurrentBlockInList, ULONG BlockCount, ULONG DoubleIndirectBlock)
{
ULONG* BlockBuffer;
ULONG CurrentBlock;
return TRUE;
}
-BOOL Ext2CopyTripleIndirectBlockPointers(ULONG* BlockList, ULONG* CurrentBlockInList, ULONG BlockCount, ULONG TripleIndirectBlock)
+BOOLEAN Ext2CopyTripleIndirectBlockPointers(ULONG* BlockList, ULONG* CurrentBlockInList, ULONG BlockCount, ULONG TripleIndirectBlock)
{
ULONG* BlockBuffer;
ULONG CurrentBlock;
ULONG FatType = 0; /* FAT12, FAT16, FAT32, FATX16 or FATX32 */
ULONG FatDriveNumber = 0;
-BOOL FatOpenVolume(ULONG DriveNumber, ULONG VolumeStartSector, ULONG PartitionSectorCount)
+BOOLEAN FatOpenVolume(ULONG DriveNumber, ULONG VolumeStartSector, ULONG PartitionSectorCount)
{
char ErrMsg[80];
ULONG FatSize;
}
}
-PVOID FatBufferDirectory(ULONG DirectoryStartCluster, ULONG *DirectorySize, BOOL RootDirectory)
+PVOID FatBufferDirectory(ULONG DirectoryStartCluster, ULONG *DirectorySize, BOOLEAN RootDirectory)
{
PVOID DirectoryBuffer;
return DirectoryBuffer;
}
-BOOL FatSearchDirectoryBufferForFile(PVOID DirectoryBuffer, ULONG DirectorySize, PCHAR FileName, PFAT_FILE_INFO FatFileInfoPointer)
+BOOLEAN FatSearchDirectoryBufferForFile(PVOID DirectoryBuffer, ULONG DirectorySize, PCHAR FileName, PFAT_FILE_INFO FatFileInfoPointer)
{
ULONG EntryCount;
ULONG CurrentEntry;
return FALSE;
}
-static BOOL FatXSearchDirectoryBufferForFile(PVOID DirectoryBuffer, ULONG DirectorySize, PCHAR FileName, PFAT_FILE_INFO FatFileInfoPointer)
+static BOOLEAN FatXSearchDirectoryBufferForFile(PVOID DirectoryBuffer, ULONG DirectorySize, PCHAR FileName, PFAT_FILE_INFO FatFileInfoPointer)
{
ULONG EntryCount;
ULONG CurrentEntry;
* with info describing the file, etc. returns true
* if the file exists or false otherwise
*/
-BOOL FatLookupFile(PCSTR FileName, PFAT_FILE_INFO FatFileInfoPointer)
+BOOLEAN FatLookupFile(PCSTR FileName, PFAT_FILE_INFO FatFileInfoPointer)
{
UINT i;
ULONG NumberOfPathParts;
* FatGetFatEntry()
* returns the Fat entry for a given cluster number
*/
-BOOL FatGetFatEntry(ULONG Cluster, ULONG* ClusterPointer)
+BOOLEAN FatGetFatEntry(ULONG Cluster, ULONG* ClusterPointer)
{
ULONG fat = 0;
UINT FatOffset;
* FatReadCluster()
* Reads the specified cluster into memory
*/
-BOOL FatReadCluster(ULONG ClusterNumber, PVOID Buffer)
+BOOLEAN FatReadCluster(ULONG ClusterNumber, PVOID Buffer)
{
ULONG ClusterStartSector;
* FatReadClusterChain()
* Reads the specified clusters into memory
*/
-BOOL FatReadClusterChain(ULONG StartClusterNumber, ULONG NumberOfClusters, PVOID Buffer)
+BOOLEAN FatReadClusterChain(ULONG StartClusterNumber, ULONG NumberOfClusters, PVOID Buffer)
{
ULONG ClusterStartSector;
* FatReadPartialCluster()
* Reads part of a cluster into memory
*/
-BOOL FatReadPartialCluster(ULONG ClusterNumber, ULONG StartingOffset, ULONG Length, PVOID Buffer)
+BOOLEAN FatReadPartialCluster(ULONG ClusterNumber, ULONG StartingOffset, ULONG Length, PVOID Buffer)
{
ULONG ClusterStartSector;
* Reads BytesToRead from open file and
* returns the number of bytes read in BytesRead
*/
-BOOL FatReadFile(FILE *FileHandle, ULONG BytesToRead, ULONG* BytesRead, PVOID Buffer)
+BOOLEAN FatReadFile(FILE *FileHandle, ULONG BytesToRead, ULONG* BytesRead, PVOID Buffer)
{
PFAT_FILE_INFO FatFileInfo = (PFAT_FILE_INFO)FileHandle;
ULONG ClusterNumber;
return FatFileHandle->FilePointer;
}
-BOOL FatReadVolumeSectors(ULONG DriveNumber, ULONG SectorNumber, ULONG SectorCount, PVOID Buffer)
+BOOLEAN FatReadVolumeSectors(ULONG DriveNumber, ULONG SectorNumber, ULONG SectorCount, PVOID Buffer)
{
return CacheReadDiskSectors(DriveNumber, SectorNumber + FatVolumeStartSector, SectorCount, Buffer);
}
/*
*
- * BOOL FsOpenVolume(ULONG DriveNumber, ULONGLONG StartSector, ULONGLONG SectorCount, int Type);
+ * BOOLEAN FsOpenVolume(ULONG DriveNumber, ULONGLONG StartSector, ULONGLONG SectorCount, int Type);
*
* This function is called to open a disk volume for file access.
* It must be called before any of the file functions will work.
*
*/
-static BOOL FsOpenVolume(ULONG DriveNumber, ULONGLONG StartSector, ULONGLONG SectorCount, int Type)
+static BOOLEAN FsOpenVolume(ULONG DriveNumber, ULONGLONG StartSector, ULONGLONG SectorCount, int Type)
{
CHAR ErrorText[80];
}
/*
*
- * BOOL FsOpenBootVolume()
+ * BOOLEAN FsOpenBootVolume()
*
* This function is called to open the boot disk volume for file access.
* It must be called before any of the file functions will work.
*/
-BOOL FsOpenBootVolume()
+BOOLEAN FsOpenBootVolume()
{
ULONG DriveNumber;
ULONGLONG StartSector;
return FsOpenVolume(DriveNumber, StartSector, SectorCount, Type);
}
-BOOL FsOpenSystemVolume(char *SystemPath, char *RemainingPath, PULONG Device)
+BOOLEAN FsOpenSystemVolume(char *SystemPath, char *RemainingPath, PULONG Device)
{
ULONG DriveNumber;
ULONGLONG StartSector;
* ReadFile()
* returns number of bytes read or EOF
*/
-BOOL FsReadFile(PFILE FileHandle, ULONG BytesToRead, ULONG* BytesRead, PVOID Buffer)
+BOOLEAN FsReadFile(PFILE FileHandle, ULONG BytesToRead, ULONG* BytesRead, PVOID Buffer)
{
ULONGLONG BytesReadBig;
- BOOL Success;
+ BOOLEAN Success;
//
// Set the number of bytes read equal to zero
return 0;
}
-BOOL FsIsEndOfFile(PFILE FileHandle)
+BOOLEAN FsIsEndOfFile(PFILE FileHandle)
{
if (FsGetFilePointer(FileHandle) >= FsGetFileSize(FileHandle))
{
/*
*
- * BOOL FsRecognizeVolume(ULONG DriveNumber, ULONG VolumeStartSector, UCHAR* VolumeType);
+ * BOOLEAN FsRecognizeVolume(ULONG DriveNumber, ULONG VolumeStartSector, UCHAR* VolumeType);
*
*/
-BOOL FsRecognizeVolume(ULONG DriveNumber, ULONG VolumeStartSector, UCHAR* VolumeType)
+BOOLEAN FsRecognizeVolume(ULONG DriveNumber, ULONG VolumeStartSector, UCHAR* VolumeType)
{
DbgPrint((DPRINT_FILESYSTEM, "FsRecognizeVolume() DriveNumber: 0x%x VolumeStartSector: %d\n", DriveNumber, VolumeStartSector));
return FALSE;
}
-BOOL FsRecIsIso9660(ULONG DriveNumber)
+BOOLEAN FsRecIsIso9660(ULONG DriveNumber)
{
PUCHAR Sector = (PUCHAR)DISKREADBUFFER;
Sector[5] == '1');
}
-BOOL FsRecIsExt2(ULONG DriveNumber, ULONG VolumeStartSector)
+BOOLEAN FsRecIsExt2(ULONG DriveNumber, ULONG VolumeStartSector)
{
PEXT2_SUPER_BLOCK SuperBlock = (PEXT2_SUPER_BLOCK)DISKREADBUFFER;
return FALSE;
}
-BOOL FsRecIsFat(ULONG DriveNumber, ULONG VolumeStartSector)
+BOOLEAN FsRecIsFat(ULONG DriveNumber, ULONG VolumeStartSector)
{
PFAT_BOOTSECTOR BootSector = (PFAT_BOOTSECTOR)DISKREADBUFFER;
PFAT32_BOOTSECTOR BootSector32 = (PFAT32_BOOTSECTOR)DISKREADBUFFER;
return FALSE;
}
-BOOL FsRecIsNtfs(ULONG DriveNumber, ULONG VolumeStartSector)
+BOOLEAN FsRecIsNtfs(ULONG DriveNumber, ULONG VolumeStartSector)
{
PNTFS_BOOTSECTOR BootSector = (PNTFS_BOOTSECTOR)DISKREADBUFFER;
if (!MachDiskReadLogicalSectors(DriveNumber, VolumeStartSector, 1, BootSector))
ULONG IsoDriveNumber = 0;
-BOOL IsoOpenVolume(ULONG DriveNumber)
+BOOLEAN IsoOpenVolume(ULONG DriveNumber)
{
PPVD Pvd = (PPVD)DISKREADBUFFER;
}
-static BOOL IsoSearchDirectoryBufferForFile(PVOID DirectoryBuffer, ULONG DirectoryLength, PCHAR FileName, PISO_FILE_INFO IsoFileInfoPointer)
+static BOOLEAN IsoSearchDirectoryBufferForFile(PVOID DirectoryBuffer, ULONG DirectoryLength, PCHAR FileName, PISO_FILE_INFO IsoFileInfoPointer)
{
PDIR_RECORD Record;
ULONG Offset;
* with info describing the file, etc. returns true
* if the file exists or false otherwise
*/
-static BOOL IsoLookupFile(PCSTR FileName, PISO_FILE_INFO IsoFileInfoPointer)
+static BOOLEAN IsoLookupFile(PCSTR FileName, PISO_FILE_INFO IsoFileInfoPointer)
{
UINT i;
ULONG NumberOfPathParts;
* Reads BytesToRead from open file and
* returns the number of bytes read in BytesRead
*/
-BOOL IsoReadFile(FILE *FileHandle, ULONG BytesToRead, ULONG* BytesRead, PVOID Buffer)
+BOOLEAN IsoReadFile(FILE *FileHandle, ULONG BytesToRead, ULONG* BytesRead, PVOID Buffer)
{
PISO_FILE_INFO IsoFileInfo = (PISO_FILE_INFO)FileHandle;
ULONG SectorNumber;
}
/* FIXME: Add support for attribute lists! */
-static BOOL NtfsFindAttribute(PNTFS_ATTR_CONTEXT Context, PNTFS_MFT_RECORD MftRecord, ULONG Type, const WCHAR *Name)
+static BOOLEAN NtfsFindAttribute(PNTFS_ATTR_CONTEXT Context, PNTFS_MFT_RECORD MftRecord, ULONG Type, const WCHAR *Name)
{
PNTFS_ATTR_RECORD AttrRecord;
PNTFS_ATTR_RECORD AttrRecordEnd;
}
/* FIXME: Optimize for multisector reads. */
-static BOOL NtfsDiskRead(ULONGLONG Offset, ULONGLONG Length, PCHAR Buffer)
+static BOOLEAN NtfsDiskRead(ULONGLONG Offset, ULONGLONG Length, PCHAR Buffer)
{
USHORT ReadLength;
return AlreadyRead;
}
-static BOOL NtfsFixupRecord(PNTFS_RECORD Record)
+static BOOLEAN NtfsFixupRecord(PNTFS_RECORD Record)
{
USHORT *USA;
USHORT USANumber;
return TRUE;
}
-static BOOL NtfsReadMftRecord(ULONG MFTIndex, PNTFS_MFT_RECORD Buffer)
+static BOOLEAN NtfsReadMftRecord(ULONG MFTIndex, PNTFS_MFT_RECORD Buffer)
{
ULONGLONG BytesRead;
}
#endif
-static BOOL NtfsCompareFileName(PCHAR FileName, PNTFS_INDEX_ENTRY IndexEntry)
+static BOOLEAN NtfsCompareFileName(PCHAR FileName, PNTFS_INDEX_ENTRY IndexEntry)
{
PWCHAR EntryFileName;
UCHAR EntryFileNameLength;
return TRUE;
}
-static BOOL NtfsFindMftRecord(ULONG MFTIndex, PCHAR FileName, ULONG *OutMFTIndex)
+static BOOLEAN NtfsFindMftRecord(ULONG MFTIndex, PCHAR FileName, ULONG *OutMFTIndex)
{
PNTFS_MFT_RECORD MftRecord;
ULONG Magic;
return FALSE;
}
-static BOOL NtfsLookupFile(PCSTR FileName, PNTFS_MFT_RECORD MftRecord, PNTFS_ATTR_CONTEXT DataContext)
+static BOOLEAN NtfsLookupFile(PCSTR FileName, PNTFS_MFT_RECORD MftRecord, PNTFS_ATTR_CONTEXT DataContext)
{
ULONG NumberOfPathParts;
CHAR PathPart[261];
return TRUE;
}
-BOOL NtfsOpenVolume(ULONG DriveNumber, ULONG VolumeStartSector)
+BOOLEAN NtfsOpenVolume(ULONG DriveNumber, ULONG VolumeStartSector)
{
NtfsBootSector = (PNTFS_BOOTSECTOR)DISKREADBUFFER;
return (FILE*)FileHandle;
}
-BOOL NtfsReadFile(FILE *File, ULONG BytesToRead, ULONG* BytesRead, PVOID Buffer)
+BOOLEAN NtfsReadFile(FILE *File, ULONG BytesToRead, ULONG* BytesRead, PVOID Buffer)
{
PNTFS_FILE_HANDLE FileHandle = (PNTFS_FILE_HANDLE)File;
ULONGLONG BytesRead64;
extern ULONG i386BootDrive;
extern ULONG i386BootPartition;
-extern BOOL i386DiskGetBootVolume(PULONG DriveNumber, PULONGLONG StartSector,
+extern BOOLEAN i386DiskGetBootVolume(PULONG DriveNumber, PULONGLONG StartSector,
PULONGLONG SectorCount, int *FsType);
-extern BOOL i386DiskGetSystemVolume(char *SystemPath, char *RemainingPath,
+extern BOOLEAN i386DiskGetSystemVolume(char *SystemPath, char *RemainingPath,
PULONG Device, PULONG DriveNumber,
PULONGLONG StartSector,
PULONGLONG SectorCount, int *FsType);
-extern BOOL i386DiskGetBootPath(char *BootPath, unsigned Size);
+extern BOOLEAN i386DiskGetBootPath(char *BootPath, unsigned Size);
extern VOID i386DiskGetBootDevice(PULONG BootDevice);
-extern BOOL i386DiskBootingFromFloppy(VOID);
-extern BOOL i386DiskNormalizeSystemPath(char *SystemPath, unsigned Size);
+extern BOOLEAN i386DiskBootingFromFloppy(VOID);
+extern BOOLEAN i386DiskNormalizeSystemPath(char *SystemPath, unsigned Size);
#endif /* __I386_I386_H_ */
VOID PcMachInit(const char *CmdLine);
VOID PcConsPutChar(int Ch);
-BOOL PcConsKbHit();
+BOOLEAN PcConsKbHit();
int PcConsGetCh();
VOID PcVideoClearScreen(UCHAR Attr);
-VIDEODISPLAYMODE PcVideoSetDisplayMode(char *DisplayMode, BOOL Init);
+VIDEODISPLAYMODE PcVideoSetDisplayMode(char *DisplayMode, BOOLEAN Init);
VOID PcVideoGetDisplaySize(PULONG Width, PULONG Height, PULONG Depth);
ULONG PcVideoGetBufferSize(VOID);
VOID PcVideoSetTextCursorPosition(ULONG X, ULONG Y);
-VOID PcVideoHideShowTextCursor(BOOL Show);
+VOID PcVideoHideShowTextCursor(BOOLEAN Show);
VOID PcVideoPutChar(int Ch, UCHAR Attr, unsigned X, unsigned Y);
VOID PcVideoCopyOffScreenBufferToVRAM(PVOID Buffer);
-BOOL PcVideoIsPaletteFixed(VOID);
+BOOLEAN PcVideoIsPaletteFixed(VOID);
VOID PcVideoSetPaletteColor(UCHAR Color, UCHAR Red, UCHAR Green, UCHAR Blue);
VOID PcVideoGetPaletteColor(UCHAR Color, UCHAR* Red, UCHAR* Green, UCHAR* Blue);
VOID PcVideoSync(VOID);
ULONG PcMemGetMemoryMap(PBIOS_MEMORY_MAP BiosMemoryMap, ULONG MaxMemoryMapSize);
-BOOL PcDiskReadLogicalSectors(ULONG DriveNumber, ULONGLONG SectorNumber, ULONG SectorCount, PVOID Buffer);
-BOOL PcDiskGetPartitionEntry(ULONG DriveNumber, ULONG PartitionNumber, PPARTITION_TABLE_ENTRY PartitionTableEntry);
-BOOL PcDiskGetDriveGeometry(ULONG DriveNumber, PGEOMETRY DriveGeometry);
+BOOLEAN PcDiskReadLogicalSectors(ULONG DriveNumber, ULONGLONG SectorNumber, ULONG SectorCount, PVOID Buffer);
+BOOLEAN PcDiskGetPartitionEntry(ULONG DriveNumber, ULONG PartitionNumber, PPARTITION_TABLE_ENTRY PartitionTableEntry);
+BOOLEAN PcDiskGetDriveGeometry(ULONG DriveNumber, PGEOMETRY DriveGeometry);
ULONG PcDiskGetCacheableBlockCount(ULONG DriveNumber);
VOID PcRTCGetCurrentDateTime(PULONG Year, PULONG Month, PULONG Day, PULONG Hour, PULONG Minute, PULONG Second);
VOID XboxMachInit(const char *CmdLine);
VOID XboxConsPutChar(int Ch);
-BOOL XboxConsKbHit();
+BOOLEAN XboxConsKbHit();
int XboxConsGetCh();
VOID XboxVideoInit(VOID);
VOID XboxVideoClearScreen(UCHAR Attr);
-VIDEODISPLAYMODE XboxVideoSetDisplayMode(char *DisplayModem, BOOL Init);
+VIDEODISPLAYMODE XboxVideoSetDisplayMode(char *DisplayModem, BOOLEAN Init);
VOID XboxVideoGetDisplaySize(PULONG Width, PULONG Height, PULONG Depth);
ULONG XboxVideoGetBufferSize(VOID);
VOID XboxVideoSetTextCursorPosition(ULONG X, ULONG Y);
-VOID XboxVideoHideShowTextCursor(BOOL Show);
+VOID XboxVideoHideShowTextCursor(BOOLEAN Show);
VOID XboxVideoPutChar(int Ch, UCHAR Attr, unsigned X, unsigned Y);
VOID XboxVideoCopyOffScreenBufferToVRAM(PVOID Buffer);
-BOOL XboxVideoIsPaletteFixed(VOID);
+BOOLEAN XboxVideoIsPaletteFixed(VOID);
VOID XboxVideoSetPaletteColor(UCHAR Color, UCHAR Red, UCHAR Green, UCHAR Blue);
VOID XboxVideoGetPaletteColor(UCHAR Color, UCHAR* Red, UCHAR* Green, UCHAR* Blue);
VOID XboxVideoSync(VOID);
PVOID XboxMemReserveMemory(ULONG MbToReserve);
ULONG XboxMemGetMemoryMap(PBIOS_MEMORY_MAP BiosMemoryMap, ULONG MaxMemoryMapSize);
-BOOL XboxDiskReadLogicalSectors(ULONG DriveNumber, ULONGLONG SectorNumber, ULONG SectorCount, PVOID Buffer);
-BOOL XboxDiskGetPartitionEntry(ULONG DriveNumber, ULONG PartitionNumber, PPARTITION_TABLE_ENTRY PartitionTableEntry);
-BOOL XboxDiskGetDriveGeometry(ULONG DriveNumber, PGEOMETRY DriveGeometry);
+BOOLEAN XboxDiskReadLogicalSectors(ULONG DriveNumber, ULONGLONG SectorNumber, ULONG SectorCount, PVOID Buffer);
+BOOLEAN XboxDiskGetPartitionEntry(ULONG DriveNumber, ULONG PartitionNumber, PPARTITION_TABLE_ENTRY PartitionTableEntry);
+BOOLEAN XboxDiskGetDriveGeometry(ULONG DriveNumber, PGEOMETRY DriveGeometry);
ULONG XboxDiskGetCacheableBlockCount(ULONG DriveNumber);
VOID XboxRTCGetCurrentDateTime(PULONG Year, PULONG Month, PULONG Day, PULONG Hour, PULONG Minute, PULONG Second);
ULONG GetDefaultOperatingSystem(PCSTR OperatingSystemList[], ULONG OperatingSystemCount);
LONG GetTimeOut(VOID);
-BOOL MainBootMenuKeyPressFilter(ULONG KeyPress);
+BOOLEAN MainBootMenuKeyPressFilter(ULONG KeyPress);
#endif // #defined __BOOTMGR_H
LIST_ITEM ListEntry; // Doubly linked list synchronization member
ULONG BlockNumber; // Track index for CHS, 64k block index for LBA
- BOOL LockedInCache; // Indicates that this block is locked in cache memory
+ BOOLEAN LockedInCache; // Indicates that this block is locked in cache memory
ULONG AccessCount; // Access count for this block
PVOID BlockData; // Pointer to block data
//
///////////////////////////////////////////////////////////////////////////////////////
extern CACHE_DRIVE CacheManagerDrive;
-extern BOOL CacheManagerInitialized;
+extern BOOLEAN CacheManagerInitialized;
extern ULONG CacheBlockCount;
extern ULONG CacheSizeLimit;
extern ULONG CacheSizeCurrent;
PCACHE_BLOCK CacheInternalGetBlockPointer(PCACHE_DRIVE CacheDrive, ULONG BlockNumber); // Returns a pointer to a CACHE_BLOCK structure given a block number
PCACHE_BLOCK CacheInternalFindBlock(PCACHE_DRIVE CacheDrive, ULONG BlockNumber); // Searches the block list for a particular block
PCACHE_BLOCK CacheInternalAddBlockToCache(PCACHE_DRIVE CacheDrive, ULONG BlockNumber); // Adds a block to the cache's block list
-BOOL CacheInternalFreeBlock(PCACHE_DRIVE CacheDrive); // Removes a block from the cache's block list & frees the memory
+BOOLEAN CacheInternalFreeBlock(PCACHE_DRIVE CacheDrive); // Removes a block from the cache's block list & frees the memory
VOID CacheInternalCheckCacheSizeLimits(PCACHE_DRIVE CacheDrive); // Checks the cache size limits to see if we can add a new block, if not calls CacheInternalFreeBlock()
VOID CacheInternalDumpBlockList(PCACHE_DRIVE CacheDrive); // Dumps the list of cached blocks to the debug output port
VOID CacheInternalOptimizeBlockList(PCACHE_DRIVE CacheDrive, PCACHE_BLOCK CacheBlock); // Moves the specified block to the head of the list
-BOOL CacheInitializeDrive(ULONG DriveNumber);
+BOOLEAN CacheInitializeDrive(ULONG DriveNumber);
VOID CacheInvalidateCacheData(VOID);
-BOOL CacheReadDiskSectors(ULONG DiskNumber, ULONG StartSector, ULONG SectorCount, PVOID Buffer);
-BOOL CacheForceDiskSectorsIntoCache(ULONG DiskNumber, ULONG StartSector, ULONG SectorCount);
-BOOL CacheReleaseMemory(ULONG MinimumAmountToRelease);
+BOOLEAN CacheReadDiskSectors(ULONG DiskNumber, ULONG StartSector, ULONG SectorCount, PVOID Buffer);
+BOOLEAN CacheForceDiskSectorsIntoCache(ULONG DiskNumber, ULONG StartSector, ULONG SectorCount);
+BOOLEAN CacheReleaseMemory(ULONG MinimumAmountToRelease);
#endif // defined __CACHE_H
#ifndef __RS232_H
#define __RS232_H
-BOOL Rs232PortInitialize(ULONG ComPort, ULONG BaudRate);
-BOOL Rs232PortGetByte(PUCHAR ByteRecieved);
-BOOL Rs232PortPollByte(PUCHAR ByteRecieved);
+BOOLEAN Rs232PortInitialize(ULONG ComPort, ULONG BaudRate);
+BOOLEAN Rs232PortGetByte(PUCHAR ByteRecieved);
+BOOLEAN Rs232PortPollByte(PUCHAR ByteRecieved);
VOID Rs232PortPutByte(UCHAR ByteToSend);
-BOOL Rs232PortInUse(ULONG Base);
+BOOLEAN Rs232PortInUse(ULONG Base);
#endif // defined __RS232_H
///////////////////////////////////////////////////////////////////////////////////////
#ifdef __i386__
-BOOL DiskResetController(ULONG DriveNumber);
-BOOL DiskInt13ExtensionsSupported(ULONG DriveNumber);
+BOOLEAN DiskResetController(ULONG DriveNumber);
+BOOLEAN DiskInt13ExtensionsSupported(ULONG DriveNumber);
//VOID DiskStopFloppyMotor(VOID);
-BOOL DiskGetExtendedDriveParameters(ULONG DriveNumber, PVOID Buffer, USHORT BufferSize);
+BOOLEAN DiskGetExtendedDriveParameters(ULONG DriveNumber, PVOID Buffer, USHORT BufferSize);
#endif // defined __i386__
// FreeLoader Disk Functions
//
///////////////////////////////////////////////////////////////////////////////////////
-VOID DiskReportError (BOOL bError);
+VOID DiskReportError (BOOLEAN bError);
VOID DiskError(PCSTR ErrorString, ULONG ErrorCode);
PCSTR DiskGetErrorCodeString(ULONG ErrorCode);
-BOOL DiskReadLogicalSectors(ULONG DriveNumber, ULONGLONG SectorNumber, ULONG SectorCount, PVOID Buffer); // Implemented in i386disk.c
-BOOL DiskIsDriveRemovable(ULONG DriveNumber);
+BOOLEAN DiskReadLogicalSectors(ULONG DriveNumber, ULONGLONG SectorNumber, ULONG SectorCount, PVOID Buffer); // Implemented in i386disk.c
+BOOLEAN DiskIsDriveRemovable(ULONG DriveNumber);
VOID DiskStopFloppyMotor(VOID); // Implemented in i386disk.c
///////////////////////////////////////////////////////////////////////////////////////
// Fixed Disk Partition Management Functions
//
///////////////////////////////////////////////////////////////////////////////////////
-BOOL DiskGetActivePartitionEntry(ULONG DriveNumber, PPARTITION_TABLE_ENTRY PartitionTableEntry, ULONG *ActivePartition);
-BOOL DiskGetPartitionEntry(ULONG DriveNumber, ULONG PartitionNumber, PPARTITION_TABLE_ENTRY PartitionTableEntry);
-BOOL DiskGetFirstPartitionEntry(PMASTER_BOOT_RECORD MasterBootRecord, PPARTITION_TABLE_ENTRY PartitionTableEntry);
-BOOL DiskGetFirstExtendedPartitionEntry(PMASTER_BOOT_RECORD MasterBootRecord, PPARTITION_TABLE_ENTRY PartitionTableEntry);
-BOOL DiskReadBootRecord(ULONG DriveNumber, ULONGLONG LogicalSectorNumber, PMASTER_BOOT_RECORD BootRecord);
+BOOLEAN DiskGetActivePartitionEntry(ULONG DriveNumber, PPARTITION_TABLE_ENTRY PartitionTableEntry, ULONG *ActivePartition);
+BOOLEAN DiskGetPartitionEntry(ULONG DriveNumber, ULONG PartitionNumber, PPARTITION_TABLE_ENTRY PartitionTableEntry);
+BOOLEAN DiskGetFirstPartitionEntry(PMASTER_BOOT_RECORD MasterBootRecord, PPARTITION_TABLE_ENTRY PartitionTableEntry);
+BOOLEAN DiskGetFirstExtendedPartitionEntry(PMASTER_BOOT_RECORD MasterBootRecord, PPARTITION_TABLE_ENTRY PartitionTableEntry);
+BOOLEAN DiskReadBootRecord(ULONG DriveNumber, ULONGLONG LogicalSectorNumber, PMASTER_BOOT_RECORD BootRecord);
#endif // defined __DISK_H
} PACKED DRIVE_MAP_LIST, *PDRIVE_MAP_LIST;
VOID DriveMapMapDrivesInSection(PCSTR SectionName);
-BOOL DriveMapIsValidDriveString(PCSTR DriveString); // Checks the drive string ("hd0") for validity
+BOOLEAN DriveMapIsValidDriveString(PCSTR DriveString); // Checks the drive string ("hd0") for validity
ULONG DriveMapGetBiosDriveNumber(PCSTR DeviceName); // Returns a BIOS drive number for any given device name (e.g. 0x80 for 'hd0')
VOID DriveMapInstallInt13Handler(PDRIVE_MAP_LIST DriveMap); // Installs the int 13h handler for the drive mapper
VOID DriveMapRemoveInt13Handler(VOID); // Removes a previously installed int 13h drive map handler
#define Ke386EraseFlags(x) __asm__ __volatile__("pushl $0 ; popfl\n")
-extern BOOL UserInterfaceUp; /* Tells us if the user interface is displayed */
+extern BOOLEAN UserInterfaceUp; /* Tells us if the user interface is displayed */
VOID BootMain(LPSTR CmdLine);
VOID RunLoader(VOID);
#define PFILE FILE *
VOID FileSystemError(PCSTR ErrorString);
-BOOL FsOpenBootVolume();
-BOOL FsOpenSystemVolume(PCHAR SystemPath, PCHAR RemainingPath, PULONG BootDevice);
+BOOLEAN FsOpenBootVolume();
+BOOLEAN FsOpenSystemVolume(PCHAR SystemPath, PCHAR RemainingPath, PULONG BootDevice);
PFILE FsOpenFile(PCSTR FileName);
VOID FsCloseFile(PFILE FileHandle);
-BOOL FsReadFile(PFILE FileHandle, ULONG BytesToRead, ULONG* BytesRead, PVOID Buffer);
+BOOLEAN FsReadFile(PFILE FileHandle, ULONG BytesToRead, ULONG* BytesRead, PVOID Buffer);
ULONG FsGetFileSize(PFILE FileHandle);
VOID FsSetFilePointer(PFILE FileHandle, ULONG NewFilePointer);
ULONG FsGetFilePointer(PFILE FileHandle);
-BOOL FsIsEndOfFile(PFILE FileHandle);
+BOOLEAN FsIsEndOfFile(PFILE FileHandle);
ULONG FsGetNumPathParts(PCSTR Path);
VOID FsGetFirstNameFromPath(PCHAR Buffer, PCSTR Path);
-BOOL Ext2OpenVolume(UCHAR DriveNumber, ULONGLONG VolumeStartSector);
+BOOLEAN Ext2OpenVolume(UCHAR DriveNumber, ULONGLONG VolumeStartSector);
FILE* Ext2OpenFile(PCSTR FileName);
-BOOL Ext2LookupFile(PCSTR FileName, PEXT2_FILE_INFO Ext2FileInfoPointer);
-BOOL Ext2SearchDirectoryBufferForFile(PVOID DirectoryBuffer, ULONG DirectorySize, PCHAR FileName, PEXT2_DIR_ENTRY DirectoryEntry);
-BOOL Ext2ReadFile(FILE *FileHandle, ULONGLONG BytesToRead, ULONGLONG* BytesRead, PVOID Buffer);
+BOOLEAN Ext2LookupFile(PCSTR FileName, PEXT2_FILE_INFO Ext2FileInfoPointer);
+BOOLEAN Ext2SearchDirectoryBufferForFile(PVOID DirectoryBuffer, ULONG DirectorySize, PCHAR FileName, PEXT2_DIR_ENTRY DirectoryEntry);
+BOOLEAN Ext2ReadFile(FILE *FileHandle, ULONGLONG BytesToRead, ULONGLONG* BytesRead, PVOID Buffer);
ULONGLONG Ext2GetFileSize(FILE *FileHandle);
VOID Ext2SetFilePointer(FILE *FileHandle, ULONGLONG NewFilePointer);
ULONGLONG Ext2GetFilePointer(FILE *FileHandle);
-BOOL Ext2ReadVolumeSectors(UCHAR DriveNumber, ULONGLONG SectorNumber, ULONGLONG SectorCount, PVOID Buffer);
+BOOLEAN Ext2ReadVolumeSectors(UCHAR DriveNumber, ULONGLONG SectorNumber, ULONGLONG SectorCount, PVOID Buffer);
-BOOL Ext2ReadSuperBlock(VOID);
-BOOL Ext2ReadGroupDescriptors(VOID);
-BOOL Ext2ReadDirectory(ULONG Inode, PVOID* DirectoryBuffer, PEXT2_INODE InodePointer);
-BOOL Ext2ReadBlock(ULONG BlockNumber, PVOID Buffer);
-BOOL Ext2ReadPartialBlock(ULONG BlockNumber, ULONG StartingOffset, ULONG Length, PVOID Buffer);
+BOOLEAN Ext2ReadSuperBlock(VOID);
+BOOLEAN Ext2ReadGroupDescriptors(VOID);
+BOOLEAN Ext2ReadDirectory(ULONG Inode, PVOID* DirectoryBuffer, PEXT2_INODE InodePointer);
+BOOLEAN Ext2ReadBlock(ULONG BlockNumber, PVOID Buffer);
+BOOLEAN Ext2ReadPartialBlock(ULONG BlockNumber, ULONG StartingOffset, ULONG Length, PVOID Buffer);
ULONG Ext2GetGroupDescBlockNumber(ULONG Group);
ULONG Ext2GetGroupDescOffsetInBlock(ULONG Group);
ULONG Ext2GetInodeGroupNumber(ULONG Inode);
ULONG Ext2GetInodeBlockNumber(ULONG Inode);
ULONG Ext2GetInodeOffsetInBlock(ULONG Inode);
-BOOL Ext2ReadInode(ULONG Inode, PEXT2_INODE InodeBuffer);
-BOOL Ext2ReadGroupDescriptor(ULONG Group, PEXT2_GROUP_DESC GroupBuffer);
+BOOLEAN Ext2ReadInode(ULONG Inode, PEXT2_INODE InodeBuffer);
+BOOLEAN Ext2ReadGroupDescriptor(ULONG Group, PEXT2_GROUP_DESC GroupBuffer);
ULONG* Ext2ReadBlockPointerList(PEXT2_INODE Inode);
ULONGLONG Ext2GetInodeFileSize(PEXT2_INODE Inode);
-BOOL Ext2CopyIndirectBlockPointers(ULONG* BlockList, ULONG* CurrentBlockInList, ULONG BlockCount, ULONG IndirectBlock);
-BOOL Ext2CopyDoubleIndirectBlockPointers(ULONG* BlockList, ULONG* CurrentBlockInList, ULONG BlockCount, ULONG DoubleIndirectBlock);
-BOOL Ext2CopyTripleIndirectBlockPointers(ULONG* BlockList, ULONG* CurrentBlockInList, ULONG BlockCount, ULONG TripleIndirectBlock);
+BOOLEAN Ext2CopyIndirectBlockPointers(ULONG* BlockList, ULONG* CurrentBlockInList, ULONG BlockCount, ULONG IndirectBlock);
+BOOLEAN Ext2CopyDoubleIndirectBlockPointers(ULONG* BlockList, ULONG* CurrentBlockInList, ULONG BlockCount, ULONG DoubleIndirectBlock);
+BOOLEAN Ext2CopyTripleIndirectBlockPointers(ULONG* BlockList, ULONG* CurrentBlockInList, ULONG BlockCount, ULONG TripleIndirectBlock);
#endif // #defined __EXT2_H
-BOOL FatOpenVolume(ULONG DriveNumber, ULONG VolumeStartSector, ULONG PartitionSectorCount);
+BOOLEAN FatOpenVolume(ULONG DriveNumber, ULONG VolumeStartSector, ULONG PartitionSectorCount);
ULONG FatDetermineFatType(PFAT_BOOTSECTOR FatBootSector, ULONG PartitionSectorCount);
-PVOID FatBufferDirectory(ULONG DirectoryStartCluster, ULONG* EntryCountPointer, BOOL RootDirectory);
-BOOL FatSearchDirectoryBufferForFile(PVOID DirectoryBuffer, ULONG EntryCount, PCHAR FileName, PFAT_FILE_INFO FatFileInfoPointer);
-BOOL FatLookupFile(PCSTR FileName, PFAT_FILE_INFO FatFileInfoPointer);
+PVOID FatBufferDirectory(ULONG DirectoryStartCluster, ULONG* EntryCountPointer, BOOLEAN RootDirectory);
+BOOLEAN FatSearchDirectoryBufferForFile(PVOID DirectoryBuffer, ULONG EntryCount, PCHAR FileName, PFAT_FILE_INFO FatFileInfoPointer);
+BOOLEAN FatLookupFile(PCSTR FileName, PFAT_FILE_INFO FatFileInfoPointer);
void FatParseShortFileName(PCHAR Buffer, PDIRENTRY DirEntry);
-BOOL FatGetFatEntry(ULONG Cluster, ULONG* ClusterPointer);
+BOOLEAN FatGetFatEntry(ULONG Cluster, ULONG* ClusterPointer);
FILE* FatOpenFile(PCSTR FileName);
ULONG FatCountClustersInChain(ULONG StartCluster);
ULONG* FatGetClusterChainArray(ULONG StartCluster);
-BOOL FatReadCluster(ULONG ClusterNumber, PVOID Buffer);
-BOOL FatReadClusterChain(ULONG StartClusterNumber, ULONG NumberOfClusters, PVOID Buffer);
-BOOL FatReadPartialCluster(ULONG ClusterNumber, ULONG StartingOffset, ULONG Length, PVOID Buffer);
-BOOL FatReadFile(FILE *FileHandle, ULONG BytesToRead, ULONG* BytesRead, PVOID Buffer);
+BOOLEAN FatReadCluster(ULONG ClusterNumber, PVOID Buffer);
+BOOLEAN FatReadClusterChain(ULONG StartClusterNumber, ULONG NumberOfClusters, PVOID Buffer);
+BOOLEAN FatReadPartialCluster(ULONG ClusterNumber, ULONG StartingOffset, ULONG Length, PVOID Buffer);
+BOOLEAN FatReadFile(FILE *FileHandle, ULONG BytesToRead, ULONG* BytesRead, PVOID Buffer);
ULONG FatGetFileSize(FILE *FileHandle);
VOID FatSetFilePointer(FILE *FileHandle, ULONG NewFilePointer);
ULONG FatGetFilePointer(FILE *FileHandle);
-BOOL FatReadVolumeSectors(ULONG DriveNumber, ULONG SectorNumber, ULONG SectorCount, PVOID Buffer);
+BOOLEAN FatReadVolumeSectors(ULONG DriveNumber, ULONG SectorNumber, ULONG SectorCount, PVOID Buffer);
#define ATTR_NORMAL 0x00
ULONG FileStart; // File start sector
ULONG FileSize; // File size
ULONG FilePointer; // File pointer
- BOOL Directory;
+ BOOLEAN Directory;
ULONG DriveNumber;
} ISO_FILE_INFO, * PISO_FILE_INFO;
-BOOL IsoOpenVolume(ULONG DriveNumber);
+BOOLEAN IsoOpenVolume(ULONG DriveNumber);
FILE* IsoOpenFile(PCSTR FileName);
-BOOL IsoReadFile(FILE *FileHandle, ULONG BytesToRead, ULONG* BytesRead, PVOID Buffer);
+BOOLEAN IsoReadFile(FILE *FileHandle, ULONG BytesToRead, ULONG* BytesRead, PVOID Buffer);
ULONG IsoGetFileSize(FILE *FileHandle);
VOID IsoSetFilePointer(FILE *FileHandle, ULONG NewFilePointer);
ULONG IsoGetFilePointer(FILE *FileHandle);
ULONGLONG Offset;
} PACKED NTFS_FILE_HANDLE, *PNTFS_FILE_HANDLE;
-BOOL NtfsOpenVolume(ULONG DriveNumber, ULONG VolumeStartSector);
+BOOLEAN NtfsOpenVolume(ULONG DriveNumber, ULONG VolumeStartSector);
FILE* NtfsOpenFile(PCSTR FileName);
-BOOL NtfsReadFile(FILE *FileHandle, ULONG BytesToRead, ULONG* BytesRead, PVOID Buffer);
+BOOLEAN NtfsReadFile(FILE *FileHandle, ULONG BytesToRead, ULONG* BytesRead, PVOID Buffer);
ULONG NtfsGetFileSize(FILE *FileHandle);
VOID NtfsSetFilePointer(FILE *FileHandle, ULONG NewFilePointer);
ULONG NtfsGetFilePointer(FILE *FileHandle);
#ifndef __FSREC_H
#define __FSREC_H
-BOOL FsRecognizeVolume(ULONG DriveNumber, ULONG VolumeStartSector, UCHAR* VolumeType);
-BOOL FsRecIsIso9660(ULONG DriveNumber);
-BOOL FsRecIsExt2(ULONG DriveNumber, ULONG VolumeStartSector);
-BOOL FsRecIsFat(ULONG DriveNumber, ULONG VolumeStartSector);
-BOOL FsRecIsNtfs(ULONG DriveNumber, ULONG VolumeStartSector);
+BOOLEAN FsRecognizeVolume(ULONG DriveNumber, ULONG VolumeStartSector, UCHAR* VolumeType);
+BOOLEAN FsRecIsIso9660(ULONG DriveNumber);
+BOOLEAN FsRecIsExt2(ULONG DriveNumber, ULONG VolumeStartSector);
+BOOLEAN FsRecIsFat(ULONG DriveNumber, ULONG VolumeStartSector);
+BOOLEAN FsRecIsNtfs(ULONG DriveNumber, ULONG VolumeStartSector);
#endif // #defined __FSREC_H
PFILE IniOpenIniFile();
-BOOL IniParseFile(PCHAR IniFileData, ULONG IniFileSize);
+BOOLEAN IniParseFile(PCHAR IniFileData, ULONG IniFileSize);
ULONG IniGetNextLineSize(PCHAR IniFileData, ULONG IniFileSize, ULONG CurrentOffset);
ULONG IniGetNextLine(PCHAR IniFileData, ULONG IniFileSize, PCHAR Buffer, ULONG BufferSize, ULONG CurrentOffset);
-BOOL IniIsLineEmpty(PCHAR LineOfText, ULONG TextLength);
-BOOL IniIsCommentLine(PCHAR LineOfText, ULONG TextLength);
-BOOL IniIsSectionName(PCHAR LineOfText, ULONG TextLength);
+BOOLEAN IniIsLineEmpty(PCHAR LineOfText, ULONG TextLength);
+BOOLEAN IniIsCommentLine(PCHAR LineOfText, ULONG TextLength);
+BOOLEAN IniIsSectionName(PCHAR LineOfText, ULONG TextLength);
ULONG IniGetSectionNameSize(PCHAR SectionNameLine, ULONG LineLength);
VOID IniExtractSectionName(PCHAR SectionName, PCHAR SectionNameLine, ULONG LineLength);
-BOOL IniIsSetting(PCHAR LineOfText, ULONG TextLength);
+BOOLEAN IniIsSetting(PCHAR LineOfText, ULONG TextLength);
ULONG IniGetSettingNameSize(PCHAR SettingNameLine, ULONG LineLength);
ULONG IniGetSettingValueSize(PCHAR SettingValueLine, ULONG LineLength);
VOID IniExtractSettingName(PCHAR SettingName, PCHAR SettingNameLine, ULONG LineLength);
VOID IniExtractSettingValue(PCHAR SettingValue, PCHAR SettingValueLine, ULONG LineLength);
-BOOL IniFileInitialize(VOID);
+BOOLEAN IniFileInitialize(VOID);
-BOOL IniOpenSection(PCSTR SectionName, ULONG* SectionId);
+BOOLEAN IniOpenSection(PCSTR SectionName, ULONG* SectionId);
ULONG IniGetNumSectionItems(ULONG SectionId);
ULONG IniGetSectionSettingNameSize(ULONG SectionId, ULONG SettingIndex);
ULONG IniGetSectionSettingValueSize(ULONG SectionId, ULONG SettingIndex);
-BOOL IniReadSettingByNumber(ULONG SectionId, ULONG SettingNumber, PCHAR SettingName, ULONG NameSize, PCHAR SettingValue, ULONG ValueSize);
-BOOL IniReadSettingByName(ULONG SectionId, PCSTR SettingName, PCHAR Buffer, ULONG BufferSize);
-BOOL IniAddSection(PCSTR SectionName, ULONG* SectionId);
-BOOL IniAddSettingValueToSection(ULONG SectionId, PCSTR SettingName, PCSTR SettingValue);
+BOOLEAN IniReadSettingByNumber(ULONG SectionId, ULONG SettingNumber, PCHAR SettingName, ULONG NameSize, PCHAR SettingValue, ULONG ValueSize);
+BOOLEAN IniReadSettingByName(ULONG SectionId, PCSTR SettingName, PCHAR Buffer, ULONG BufferSize);
+BOOLEAN IniAddSection(PCSTR SectionName, ULONG* SectionId);
+BOOLEAN IniAddSettingValueToSection(ULONG SectionId, PCSTR SettingName, PCSTR SettingValue);
#endif // defined __PARSEINI_H
VOID LoadAndBootLinux(PCSTR OperatingSystemName, PCSTR Description);
-BOOL LinuxParseIniSection(PCSTR OperatingSystemName);
-BOOL LinuxReadBootSector(PFILE LinuxKernelFile);
-BOOL LinuxReadSetupSector(PFILE LinuxKernelFile);
-BOOL LinuxReadKernel(PFILE LinuxKernelFile);
-BOOL LinuxCheckKernelVersion(VOID);
-BOOL LinuxReadInitrd(PFILE LinuxInitrdFile);
+BOOLEAN LinuxParseIniSection(PCSTR OperatingSystemName);
+BOOLEAN LinuxReadBootSector(PFILE LinuxKernelFile);
+BOOLEAN LinuxReadSetupSector(PFILE LinuxKernelFile);
+BOOLEAN LinuxReadKernel(PFILE LinuxKernelFile);
+BOOLEAN LinuxCheckKernelVersion(VOID);
+BOOLEAN LinuxReadInitrd(PFILE LinuxInitrdFile);
#endif // defined __LINUX_H
typedef struct tagMACHVTBL
{
VOID (*ConsPutChar)(int Ch);
- BOOL (*ConsKbHit)(VOID);
+ BOOLEAN (*ConsKbHit)(VOID);
int (*ConsGetCh)(VOID);
VOID (*VideoClearScreen)(UCHAR Attr);
- VIDEODISPLAYMODE (*VideoSetDisplayMode)(char *DisplayMode, BOOL Init);
+ VIDEODISPLAYMODE (*VideoSetDisplayMode)(char *DisplayMode, BOOLEAN Init);
VOID (*VideoGetDisplaySize)(PULONG Width, PULONG Height, PULONG Depth);
ULONG (*VideoGetBufferSize)(VOID);
VOID (*VideoSetTextCursorPosition)(ULONG X, ULONG Y);
- VOID (*VideoHideShowTextCursor)(BOOL Show);
+ VOID (*VideoHideShowTextCursor)(BOOLEAN Show);
VOID (*VideoPutChar)(int Ch, UCHAR Attr, unsigned X, unsigned Y);
VOID (*VideoCopyOffScreenBufferToVRAM)(PVOID Buffer);
- BOOL (*VideoIsPaletteFixed)(VOID);
+ BOOLEAN (*VideoIsPaletteFixed)(VOID);
VOID (*VideoSetPaletteColor)(UCHAR Color, UCHAR Red, UCHAR Green, UCHAR Blue);
VOID (*VideoGetPaletteColor)(UCHAR Color, UCHAR* Red, UCHAR* Green, UCHAR* Blue);
VOID (*VideoSync)(VOID);
ULONG (*GetMemoryMap)(PBIOS_MEMORY_MAP BiosMemoryMap, ULONG MaxMemoryMapSize);
- BOOL (*DiskGetBootVolume)(PULONG DriveNumber, PULONGLONG StartSector, PULONGLONG SectorCount, int *FsType);
- BOOL (*DiskGetSystemVolume)(char *SystemPath, char *RemainingPath, PULONG Device, PULONG DriveNumber, PULONGLONG StartSector, PULONGLONG SectorCount, int *FsType);
- BOOL (*DiskGetBootPath)(char *BootPath, unsigned Size);
+ BOOLEAN (*DiskGetBootVolume)(PULONG DriveNumber, PULONGLONG StartSector, PULONGLONG SectorCount, int *FsType);
+ BOOLEAN (*DiskGetSystemVolume)(char *SystemPath, char *RemainingPath, PULONG Device, PULONG DriveNumber, PULONGLONG StartSector, PULONGLONG SectorCount, int *FsType);
+ BOOLEAN (*DiskGetBootPath)(char *BootPath, unsigned Size);
VOID (*DiskGetBootDevice)(PULONG BootDevice);
- BOOL (*DiskBootingFromFloppy)(VOID);
- BOOL (*DiskNormalizeSystemPath)(char *SystemPath, unsigned Size);
- BOOL (*DiskReadLogicalSectors)(ULONG DriveNumber, ULONGLONG SectorNumber, ULONG SectorCount, PVOID Buffer);
- BOOL (*DiskGetPartitionEntry)(ULONG DriveNumber, ULONG PartitionNumber, PPARTITION_TABLE_ENTRY PartitionTableEntry);
- BOOL (*DiskGetDriveGeometry)(ULONG DriveNumber, PGEOMETRY DriveGeometry);
+ BOOLEAN (*DiskBootingFromFloppy)(VOID);
+ BOOLEAN (*DiskNormalizeSystemPath)(char *SystemPath, unsigned Size);
+ BOOLEAN (*DiskReadLogicalSectors)(ULONG DriveNumber, ULONGLONG SectorNumber, ULONG SectorCount, PVOID Buffer);
+ BOOLEAN (*DiskGetPartitionEntry)(ULONG DriveNumber, ULONG PartitionNumber, PPARTITION_TABLE_ENTRY PartitionTableEntry);
+ BOOLEAN (*DiskGetDriveGeometry)(ULONG DriveNumber, PGEOMETRY DriveGeometry);
ULONG (*DiskGetCacheableBlockCount)(ULONG DriveNumber);
VOID (*RTCGetCurrentDateTime)(PULONG Year, PULONG Month, PULONG Day, PULONG Hour, PULONG Minute, PULONG Second);
extern MACHVTBL MachVtbl;
VOID MachConsPutChar(int Ch);
-BOOL MachConsKbHit();
+BOOLEAN MachConsKbHit();
int MachConsGetCh();
VOID MachVideoClearScreen(UCHAR Attr);
-VIDEODISPLAYMODE MachVideoSetDisplayMode(char *DisplayMode, BOOL Init);
+VIDEODISPLAYMODE MachVideoSetDisplayMode(char *DisplayMode, BOOLEAN Init);
VOID MachVideoGetDisplaySize(PULONG Width, PULONG Height, PULONG Depth);
ULONG MachVideoGetBufferSize(VOID);
VOID MachVideoSetTextCursorPosition(ULONG X, ULONG Y);
-VOID MachVideoHideShowTextCursor(BOOL Show);
+VOID MachVideoHideShowTextCursor(BOOLEAN Show);
VOID MachVideoPutChar(int Ch, UCHAR Attr, unsigned X, unsigned Y);
VOID MachVideoCopyOffScreenBufferToVRAM(PVOID Buffer);
-BOOL MachVideoIsPaletteFixed(VOID);
+BOOLEAN MachVideoIsPaletteFixed(VOID);
VOID MachVideoSetPaletteColor(UCHAR Color, UCHAR Red, UCHAR Green, UCHAR Blue);
VOID MachVideoGetPaletteColor(UCHAR Color, UCHAR *Red, UCHAR *Green, UCHAR *Blue);
VOID MachVideoSync(VOID);
VOID MachVideoPrepareForReactOS(VOID);
ULONG MachGetMemoryMap(PBIOS_MEMORY_MAP BiosMemoryMap, ULONG MaxMemoryMapSize);
-BOOL MachDiskGetBootVolume(PULONG DriveNumber, PULONGLONG StartSector, PULONGLONG SectorCount, int *FsType);
-BOOL
+BOOLEAN MachDiskGetBootVolume(PULONG DriveNumber, PULONGLONG StartSector, PULONGLONG SectorCount, int *FsType);
+BOOLEAN
MachDiskGetSystemVolume(char *SystemPath,
char *RemainingPath,
PULONG Device,
PULONGLONG StartSector,
PULONGLONG SectorCount,
int *FsType);
-BOOL MachDiskGetBootPath(char *BootPath, unsigned Size);
+BOOLEAN MachDiskGetBootPath(char *BootPath, unsigned Size);
VOID MachDiskGetBootDevice(PULONG BootDevice);
-BOOL MachDiskBootingFromFloppy();
-BOOL MachDiskNormalizeSystemPath(char *SystemPath, unsigned Size);
-BOOL MachDiskReadLogicalSectors(ULONG DriveNumber, ULONGLONG SectorNumber, ULONG SectorCount, PVOID Buffer);
-BOOL MachDiskGetPartitionEntry(ULONG DriveNumber, ULONG PartitionNumber, PPARTITION_TABLE_ENTRY PartitionTableEntry);
-BOOL MachDiskGetDriveGeometry(ULONG DriveNumber, PGEOMETRY DriveGeometry);
+BOOLEAN MachDiskBootingFromFloppy();
+BOOLEAN MachDiskNormalizeSystemPath(char *SystemPath, unsigned Size);
+BOOLEAN MachDiskReadLogicalSectors(ULONG DriveNumber, ULONGLONG SectorNumber, ULONG SectorCount, PVOID Buffer);
+BOOLEAN MachDiskGetPartitionEntry(ULONG DriveNumber, ULONG PartitionNumber, PPARTITION_TABLE_ENTRY PartitionTableEntry);
+BOOLEAN MachDiskGetDriveGeometry(ULONG DriveNumber, PGEOMETRY DriveGeometry);
ULONG MachDiskGetCacheableBlockCount(ULONG DriveNumber);
VOID MachRTCGetCurrentDateTime(PULONG Year, PULONG Month, PULONG Day, PULONG Hour, PULONG Minute, PULONG Second);
VOID MachHwDetect(VOID);
ULONG MmFindAvailablePagesBeforePage(PVOID PageLookupTable, ULONG TotalPageCount, ULONG PagesNeeded, ULONG LastPage); // Returns the page number of the first available page range before the specified page
VOID MmFixupSystemMemoryMap(PBIOS_MEMORY_MAP BiosMemoryMap, ULONG* MapCount); // Removes entries in the memory map that describe memory above 4G
VOID MmUpdateLastFreePageHint(PVOID PageLookupTable, ULONG TotalPageCount); // Sets the LastFreePageHint to the last usable page of memory
-BOOL MmAreMemoryPagesAvailable(PVOID PageLookupTable, ULONG TotalPageCount, PVOID PageAddress, ULONG PageCount); // Returns TRUE if the specified pages of memory are available, otherwise FALSE
+BOOLEAN MmAreMemoryPagesAvailable(PVOID PageLookupTable, ULONG TotalPageCount, PVOID PageAddress, ULONG PageCount); // Returns TRUE if the specified pages of memory are available, otherwise FALSE
ULONG GetSystemMemorySize(VOID); // Returns the amount of total memory in the system
-//BOOL MmInitializeMemoryManager(ULONG LowMemoryStart, ULONG LowMemoryLength);
-BOOL MmInitializeMemoryManager(VOID);
+//BOOLEAN MmInitializeMemoryManager(ULONG LowMemoryStart, ULONG LowMemoryLength);
+BOOLEAN MmInitializeMemoryManager(VOID);
PVOID MmAllocateMemory(ULONG MemorySize);
VOID MmFreeMemory(PVOID MemoryPointer);
//PVOID MmAllocateLowMemory(ULONG MemorySize);
#ifndef __OSLIST_H
#define __OSLIST_H
-BOOL InitOperatingSystemList(PCSTR **SectionNamesPointer, PCSTR **DisplayNamesPointer, ULONG* OperatingSystemCountPointer);
+BOOLEAN InitOperatingSystemList(PCSTR **SectionNamesPointer, PCSTR **DisplayNamesPointer, ULONG* OperatingSystemCountPointer);
ULONG CountOperatingSystems(ULONG SectionId);
-BOOL AllocateListMemory(PCHAR **SectionNamesPointer, PCHAR **DisplayNamesPointer, ULONG OperatingSystemCount);
-BOOL RemoveQuotes(PCHAR QuotedString);
+BOOLEAN AllocateListMemory(PCHAR **SectionNamesPointer, PCHAR **DisplayNamesPointer, ULONG OperatingSystemCount);
+BOOLEAN RemoveQuotes(PCHAR QuotedString);
#endif // #defined __OSLIST_H
// ARC Path Functions
//
///////////////////////////////////////////////////////////////////////////////////////
-BOOL DissectArcPath(CHAR *ArcPath, CHAR *BootPath, ULONG* BootDrive, ULONG* BootPartition);
+BOOLEAN DissectArcPath(CHAR *ArcPath, CHAR *BootPath, ULONG* BootDrive, ULONG* BootPartition);
VOID ConstructArcPath(PCHAR ArcPath, PCHAR SystemFolder, ULONG Disk, ULONG Partition);
ULONG ConvertArcNameToBiosDriveNumber(PCHAR ArcPath);
VOID FASTCALL FrLdrSetupPae(ULONG Magic);
VOID FASTCALL FrLdrSetupPageDirectory(VOID);
VOID FASTCALL FrLdrGetPaeMode(VOID);
-BOOL STDCALL FrLdrMapKernel(FILE *KernelImage);
-ULONG_PTR STDCALL FrLdrCreateModule(LPCSTR ModuleName);
-ULONG_PTR STDCALL FrLdrLoadModule(FILE *ModuleImage, LPCSTR ModuleName, PULONG ModuleSize);
-BOOL STDCALL FrLdrCloseModule(ULONG_PTR ModuleBase, ULONG dwModuleSize);
-VOID STDCALL FrLdrStartup(ULONG Magic);
+BOOLEAN NTAPI FrLdrMapKernel(FILE *KernelImage);
+ULONG_PTR NTAPI FrLdrCreateModule(LPCSTR ModuleName);
+ULONG_PTR NTAPI FrLdrLoadModule(FILE *ModuleImage, LPCSTR ModuleName, PULONG ModuleSize);
+BOOLEAN NTAPI FrLdrCloseModule(ULONG_PTR ModuleBase, ULONG dwModuleSize);
+VOID NTAPI FrLdrStartup(ULONG Magic);
typedef VOID (FASTCALL *ASMCODE)(ULONG Magic, PROS_LOADER_PARAMETER_BLOCK LoaderBlock);
#endif // defined __REACTOS_H
RegInitializeRegistry(VOID);
LONG
-RegInitCurrentControlSet(BOOL LastKnownGood);
+RegInitCurrentControlSet(BOOLEAN LastKnownGood);
LONG
RegGetValueCount (FRLDRHKEY Key);
-BOOL
+BOOLEAN
RegImportBinaryHive (PCHAR ChunkBase,
ULONG ChunkSize);
-BOOL
+BOOLEAN
RegExportBinaryHive (PCWSTR KeyName,
PCHAR ChunkBase,
ULONG* ChunkSize);
PLIST_ITEM RtlListRemoveTail(PLIST_ITEM ListHead); // Removes the entry at the tail of the list
PLIST_ITEM RtlListGetHead(PLIST_ITEM ListHead); // Returns the entry at the head of the list
PLIST_ITEM RtlListGetTail(PLIST_ITEM ListHead); // Returns the entry at the tail of the list
-BOOL RtlListIsEmpty(PLIST_ITEM ListHead); // Indicates whether a doubly linked list is empty
+BOOLEAN RtlListIsEmpty(PLIST_ITEM ListHead); // Indicates whether a doubly linked list is empty
ULONG RtlListCountEntries(PLIST_ITEM ListHead); // Counts the entries in a doubly linked list
PLIST_ITEM RtlListGetPrevious(PLIST_ITEM ListEntry); // Returns the previous item in the list
PLIST_ITEM RtlListGetNext(PLIST_ITEM ListEntry); // Returns the next item in the list
extern CHAR UiTitleBoxTitleText[260]; // Title box's title text
-extern BOOL UserInterfaceUp; // Tells us if the user interface is displayed
+extern BOOLEAN UserInterfaceUp; // Tells us if the user interface is displayed
-extern BOOL UiUseSpecialEffects; // Tells us if we should use fade effects
-extern BOOL UiCenterMenu;
-extern BOOL UiMenuBox;
-extern BOOL UiMinimal;
+extern BOOLEAN UiUseSpecialEffects; // Tells us if we should use fade effects
+extern BOOLEAN UiCenterMenu;
+extern BOOLEAN UiMenuBox;
+extern BOOLEAN UiMinimal;
extern CHAR UiTimeText[];
extern const CHAR UiMonthNames[12][15];
// User Interface Functions
//
///////////////////////////////////////////////////////////////////////////////////////
-BOOL UiInitialize(BOOLEAN ShowGui); // Initialize User-Interface
-BOOL SetupUiInitialize(VOID); // Initialize User-Interface
+BOOLEAN UiInitialize(BOOLEAN ShowGui); // Initialize User-Interface
+BOOLEAN SetupUiInitialize(VOID); // Initialize User-Interface
VOID UiUnInitialize(PCSTR BootText); // Un-initialize User-Interface
VOID UiDrawBackdrop(VOID); // Fills the entire screen with a backdrop
VOID UiFillArea(ULONG Left, ULONG Top, ULONG Right, ULONG Bottom, CHAR FillChar, UCHAR Attr /* Color Attributes */); // Fills the area specified with FillChar and Attr
VOID UiDrawShadow(ULONG Left, ULONG Top, ULONG Right, ULONG Bottom); // Draws a shadow on the bottom and right sides of the area specified
-VOID UiDrawBox(ULONG Left, ULONG Top, ULONG Right, ULONG Bottom, UCHAR VertStyle, UCHAR HorzStyle, BOOL Fill, BOOL Shadow, UCHAR Attr); // Draws a box around the area specified
+VOID UiDrawBox(ULONG Left, ULONG Top, ULONG Right, ULONG Bottom, UCHAR VertStyle, UCHAR HorzStyle, BOOLEAN Fill, BOOLEAN Shadow, UCHAR Attr); // Draws a box around the area specified
VOID UiDrawText(ULONG X, ULONG Y, PCSTR Text, UCHAR Attr); // Draws text at coordinates specified
VOID UiDrawCenteredText(ULONG Left, ULONG Top, ULONG Right, ULONG Bottom, PCSTR TextString, UCHAR Attr); // Draws centered text at the coordinates specified and clips the edges
VOID UiDrawStatusText(PCSTR StatusText); // Draws text at the very bottom line on the screen
VOID UiDrawProgressBar(ULONG Left, ULONG Top, ULONG Right, ULONG Bottom, ULONG Position, ULONG Range, PCHAR ProgressText); // Draws the progress bar showing nPos percent filled
VOID UiShowMessageBoxesInSection(PCSTR SectionName); // Displays all the message boxes in a given section
VOID UiEscapeString(PCHAR String); // Processes a string and changes all occurances of "\n" to '\n'
-BOOL UiEditBox(PCSTR MessageText, PCHAR EditTextBuffer, ULONG Length);
+BOOLEAN UiEditBox(PCSTR MessageText, PCHAR EditTextBuffer, ULONG Length);
UCHAR UiTextToColor(PCSTR ColorText); // Converts the text color into it's equivalent color value
UCHAR UiTextToFillStyle(PCSTR FillStyleText); // Converts the text fill into it's equivalent fill value
// Menu Functions
//
///////////////////////////////////////////////////////////////////////////////////////
-typedef BOOL (*UiMenuKeyPressFilterCallback)(ULONG KeyPress);
+typedef BOOLEAN (*UiMenuKeyPressFilterCallback)(ULONG KeyPress);
-BOOL UiDisplayMenu(PCSTR MenuItemList[], ULONG MenuItemCount, ULONG DefaultMenuItem, LONG MenuTimeOut, ULONG* SelectedMenuItem, BOOL CanEscape, UiMenuKeyPressFilterCallback KeyPressFilter);
+BOOLEAN UiDisplayMenu(PCSTR MenuItemList[], ULONG MenuItemCount, ULONG DefaultMenuItem, LONG MenuTimeOut, ULONG* SelectedMenuItem, BOOLEAN CanEscape, UiMenuKeyPressFilterCallback KeyPressFilter);
VOID GuiDrawBackdrop(VOID); // Fills the entire screen with a backdrop\r
VOID GuiFillArea(ULONG Left, ULONG Top, ULONG Right, ULONG Bottom, UCHAR FillChar, UCHAR Attr /* Color Attributes */); // Fills the area specified with FillChar and Attr\r
VOID GuiDrawShadow(ULONG Left, ULONG Top, ULONG Right, ULONG Bottom); // Draws a shadow on the bottom and right sides of the area specified\r
-VOID GuiDrawBox(ULONG Left, ULONG Top, ULONG Right, ULONG Bottom, UCHAR VertStyle, UCHAR HorzStyle, BOOL Fill, BOOL Shadow, UCHAR Attr); // Draws a box around the area specified\r
+VOID GuiDrawBox(ULONG Left, ULONG Top, ULONG Right, ULONG Bottom, UCHAR VertStyle, UCHAR HorzStyle, BOOLEAN Fill, BOOLEAN Shadow, UCHAR Attr); // Draws a box around the area specified\r
VOID GuiDrawText(ULONG X, ULONG Y, PUCHAR Text, UCHAR Attr); // Draws text at coordinates specified\r
VOID GuiDrawStatusText(PCSTR StatusText); // Draws text at the very bottom line on the screen\r
VOID GuiUpdateDateTime(VOID); // Updates the date and time\r
// Menu Functions\r
//\r
///////////////////////////////////////////////////////////////////////////////////////\r
-BOOL GuiDisplayMenu(PCSTR MenuItemList[], ULONG MenuItemCount, ULONG DefaultMenuItem, LONG MenuTimeOut, ULONG* SelectedMenuItem);\r
+BOOLEAN GuiDisplayMenu(PCSTR MenuItemList[], ULONG MenuItemCount, ULONG DefaultMenuItem, LONG MenuTimeOut, ULONG* SelectedMenuItem);\r
\r
\r
\r
// Textual User Interface Functions\r
//\r
///////////////////////////////////////////////////////////////////////////////////////\r
-BOOL TuiInitialize(VOID); // Initialize User-Interface\r
+BOOLEAN TuiInitialize(VOID); // Initialize User-Interface\r
VOID TuiUnInitialize(VOID); // Un-initialize User-Interface\r
\r
VOID TuiDrawBackdrop(VOID); // Fills the entire screen with a backdrop\r
VOID TuiFillArea(ULONG Left, ULONG Top, ULONG Right, ULONG Bottom, CHAR FillChar, UCHAR Attr /* Color Attributes */); // Fills the area specified with FillChar and Attr\r
VOID TuiDrawShadow(ULONG Left, ULONG Top, ULONG Right, ULONG Bottom); // Draws a shadow on the bottom and right sides of the area specified\r
-VOID TuiDrawBox(ULONG Left, ULONG Top, ULONG Right, ULONG Bottom, UCHAR VertStyle, UCHAR HorzStyle, BOOL Fill, BOOL Shadow, UCHAR Attr); // Draws a box around the area specified\r
+VOID TuiDrawBox(ULONG Left, ULONG Top, ULONG Right, ULONG Bottom, UCHAR VertStyle, UCHAR HorzStyle, BOOLEAN Fill, BOOLEAN Shadow, UCHAR Attr); // Draws a box around the area specified\r
VOID TuiDrawText(ULONG X, ULONG Y, PCSTR Text, UCHAR Attr); // Draws text at coordinates specified\r
VOID TuiDrawCenteredText(ULONG Left, ULONG Top, ULONG Right, ULONG Bottom, PCSTR TextString, UCHAR Attr); // Draws centered text at the coordinates specified and clips the edges\r
VOID TuiDrawStatusText(PCSTR StatusText); // Draws text at the very bottom line on the screen\r
VOID TuiMessageBoxCritical(PCSTR MessageText); // Displays a message box on the screen with an ok button using no system resources\r
VOID TuiDrawProgressBarCenter(ULONG Position, ULONG Range, PCHAR ProgressText); // Draws the progress bar showing nPos percent filled\r
VOID TuiDrawProgressBar(ULONG Left, ULONG Top, ULONG Right, ULONG Bottom, ULONG Position, ULONG Range, PCHAR ProgressText); // Draws the progress bar showing nPos percent filled\r
-BOOL TuiEditBox(PCSTR MessageText, PCHAR EditTextBuffer, ULONG Length);\r
+BOOLEAN TuiEditBox(PCSTR MessageText, PCHAR EditTextBuffer, ULONG Length);\r
\r
UCHAR TuiTextToColor(PCSTR ColorText); // Converts the text color into it's equivalent color value\r
UCHAR TuiTextToFillStyle(PCSTR FillStyleText); // Converts the text fill into it's equivalent fill value\r
\r
} TUI_MENU_INFO, *PTUI_MENU_INFO;\r
\r
-VOID WINAPI TuiCalcMenuBoxSize(PTUI_MENU_INFO MenuInfo);\r
-VOID WINAPI TuiDrawMenu(PTUI_MENU_INFO MenuInfo);\r
-VOID WINAPI TuiDrawMenuBox(PTUI_MENU_INFO MenuInfo);\r
-VOID WINAPI TuiDrawMenuItem(PTUI_MENU_INFO MenuInfo, ULONG MenuItemNumber);\r
-ULONG WINAPI TuiProcessMenuKeyboardEvent(PTUI_MENU_INFO MenuInfo, UiMenuKeyPressFilterCallback KeyPressFilter);\r
-BOOL WINAPI TuiDisplayMenu(PCSTR MenuItemList[], ULONG MenuItemCount, ULONG DefaultMenuItem, LONG MenuTimeOut, ULONG* SelectedMenuItem, BOOL CanEscape, UiMenuKeyPressFilterCallback KeyPressFilter);\r
+VOID NTAPI TuiCalcMenuBoxSize(PTUI_MENU_INFO MenuInfo);\r
+VOID NTAPI TuiDrawMenu(PTUI_MENU_INFO MenuInfo);\r
+VOID NTAPI TuiDrawMenuBox(PTUI_MENU_INFO MenuInfo);\r
+VOID NTAPI TuiDrawMenuItem(PTUI_MENU_INFO MenuInfo, ULONG MenuItemNumber);\r
+ULONG NTAPI TuiProcessMenuKeyboardEvent(PTUI_MENU_INFO MenuInfo, UiMenuKeyPressFilterCallback KeyPressFilter);\r
+BOOLEAN NTAPI TuiDisplayMenu(PCSTR MenuItemList[], ULONG MenuItemCount, ULONG DefaultMenuItem, LONG MenuTimeOut, ULONG* SelectedMenuItem, BOOLEAN CanEscape, UiMenuKeyPressFilterCallback KeyPressFilter);\r
\r
\r
/*\r
#include <freeldr.h>
-BOOL IniFileInitialize(VOID)
+BOOLEAN IniFileInitialize(VOID)
{
PFILE Freeldr_Ini; // File handle for freeldr.ini
PCHAR FreeLoaderIniFileData;
ULONG FreeLoaderIniFileSize;
- BOOL Success;
+ BOOLEAN Success;
// Open freeldr.ini
Freeldr_Ini = IniOpenIniFile();
#define NDEBUG
#include <debug.h>
-BOOL IniOpenSection(PCSTR SectionName, ULONG* SectionId)
+BOOLEAN IniOpenSection(PCSTR SectionName, ULONG* SectionId)
{
PINI_SECTION Section;
return (strlen(Section->SectionItemList[SettingIndex].ItemValue) + 1);
}
-BOOL IniReadSettingByNumber(ULONG SectionId, ULONG SettingNumber, PCHAR SettingName, ULONG NameSize, PCHAR SettingValue, ULONG ValueSize)
+BOOLEAN IniReadSettingByNumber(ULONG SectionId, ULONG SettingNumber, PCHAR SettingName, ULONG NameSize, PCHAR SettingValue, ULONG ValueSize)
{
PINI_SECTION Section = (PINI_SECTION)SectionId;
PINI_SECTION_ITEM SectionItem;
return FALSE;
}
-BOOL IniReadSettingByName(ULONG SectionId, PCSTR SettingName, PCHAR Buffer, ULONG BufferSize)
+BOOLEAN IniReadSettingByName(ULONG SectionId, PCSTR SettingName, PCHAR Buffer, ULONG BufferSize)
{
PINI_SECTION Section = (PINI_SECTION)SectionId;
PINI_SECTION_ITEM SectionItem;
return FALSE;
}
-BOOL IniAddSection(PCSTR SectionName, ULONG* SectionId)
+BOOLEAN IniAddSection(PCSTR SectionName, ULONG* SectionId)
{
PINI_SECTION Section;
return TRUE;
}
-BOOL IniAddSettingValueToSection(ULONG SectionId, PCSTR SettingName, PCSTR SettingValue)
+BOOLEAN IniAddSettingValueToSection(ULONG SectionId, PCSTR SettingName, PCSTR SettingValue)
{
PINI_SECTION Section = (PINI_SECTION)SectionId;
PINI_SECTION_ITEM SectionItem;
ULONG IniFileSettingCount = 0;
-BOOL IniParseFile(PCHAR IniFileData, ULONG IniFileSize)
+BOOLEAN IniParseFile(PCHAR IniFileData, ULONG IniFileSize)
{
ULONG CurrentOffset;
ULONG CurrentLineNumber;
return CurrentOffset;
}
-BOOL IniIsLineEmpty(PCHAR LineOfText, ULONG TextLength)
+BOOLEAN IniIsLineEmpty(PCHAR LineOfText, ULONG TextLength)
{
ULONG Idx;
return TRUE;
}
-BOOL IniIsCommentLine(PCHAR LineOfText, ULONG TextLength)
+BOOLEAN IniIsCommentLine(PCHAR LineOfText, ULONG TextLength)
{
ULONG Idx;
return FALSE;
}
-BOOL IniIsSectionName(PCHAR LineOfText, ULONG TextLength)
+BOOLEAN IniIsSectionName(PCHAR LineOfText, ULONG TextLength)
{
ULONG Idx;
SectionName[DestIdx] = '\0';
}
-BOOL IniIsSetting(PCHAR LineOfText, ULONG TextLength)
+BOOLEAN IniIsSetting(PCHAR LineOfText, ULONG TextLength)
{
ULONG Idx;
PLINUX_BOOTSECTOR LinuxBootSector = NULL;
PLINUX_SETUPSECTOR LinuxSetupSector = NULL;
ULONG SetupSectorSize = 0;
-BOOL NewStyleLinuxKernel = FALSE;
+BOOLEAN NewStyleLinuxKernel = FALSE;
ULONG LinuxKernelSize = 0;
ULONG LinuxInitrdSize = 0;
CHAR LinuxKernelName[260];
CHAR LinuxInitrdName[260];
-BOOL LinuxHasInitrd = FALSE;
+BOOLEAN LinuxHasInitrd = FALSE;
CHAR LinuxCommandLine[260] = "";
ULONG LinuxCommandLineSize = 0;
PVOID LinuxKernelLoadAddress = NULL;
LinuxCommandLineSize = 0;
}
-BOOL LinuxParseIniSection(PCSTR OperatingSystemName)
+BOOLEAN LinuxParseIniSection(PCSTR OperatingSystemName)
{
CHAR SettingName[260];
ULONG SectionId;
return TRUE;
}
-BOOL LinuxReadBootSector(PFILE LinuxKernelFile)
+BOOLEAN LinuxReadBootSector(PFILE LinuxKernelFile)
{
// Allocate memory for boot sector
LinuxBootSector = (PLINUX_BOOTSECTOR)MmAllocateMemory(512);
return TRUE;
}
-BOOL LinuxReadSetupSector(PFILE LinuxKernelFile)
+BOOLEAN LinuxReadSetupSector(PFILE LinuxKernelFile)
{
UCHAR TempLinuxSetupSector[512];
return TRUE;
}
-BOOL LinuxReadKernel(PFILE LinuxKernelFile)
+BOOLEAN LinuxReadKernel(PFILE LinuxKernelFile)
{
ULONG BytesLoaded;
CHAR StatusText[260];
return TRUE;
}
-BOOL LinuxCheckKernelVersion(VOID)
+BOOLEAN LinuxCheckKernelVersion(VOID)
{
// Just assume old kernel until we find otherwise
NewStyleLinuxKernel = FALSE;
return TRUE;
}
-BOOL LinuxReadInitrd(PFILE LinuxInitrdFile)
+BOOLEAN LinuxReadInitrd(PFILE LinuxInitrdFile)
{
ULONG BytesLoaded;
CHAR StatusText[260];
MachVtbl.ConsPutChar(Ch);
}
-BOOL
+BOOLEAN
MachConsKbHit()
{
return MachVtbl.ConsKbHit();
}
VIDEODISPLAYMODE
-MachVideoSetDisplayMode(char *DisplayMode, BOOL Init)
+MachVideoSetDisplayMode(char *DisplayMode, BOOLEAN Init)
{
return MachVtbl.VideoSetDisplayMode(DisplayMode, Init);
}
}
VOID
-MachVideoHideShowTextCursor(BOOL Show)
+MachVideoHideShowTextCursor(BOOLEAN Show)
{
MachVtbl.VideoHideShowTextCursor(Show);
}
MachVtbl.VideoCopyOffScreenBufferToVRAM(Buffer);
}
-BOOL
+BOOLEAN
MachVideoIsPaletteFixed(VOID)
{
return MachVtbl.VideoIsPaletteFixed();
return MachVtbl.GetMemoryMap(BiosMemoryMap, MaxMemoryMapSize);
}
-BOOL
+BOOLEAN
MachDiskGetBootVolume(PULONG DriveNumber, PULONGLONG StartSector, PULONGLONG SectorCount, int *FsType)
{
return MachVtbl.DiskGetBootVolume(DriveNumber, StartSector, SectorCount, FsType);
}
-BOOL
+BOOLEAN
MachDiskGetSystemVolume(char *SystemPath,
char *RemainingPath,
PULONG Device,
FsType);
}
-BOOL
+BOOLEAN
MachDiskGetBootPath(char *BootPath, unsigned Size)
{
return MachVtbl.DiskGetBootPath(BootPath, Size);
MachVtbl.DiskGetBootDevice(BootDevice);
}
-BOOL
+BOOLEAN
MachDiskBootingFromFloppy()
{
return MachVtbl.DiskBootingFromFloppy();
}
-BOOL
+BOOLEAN
MachDiskNormalizeSystemPath(char *SystemPath, unsigned Size)
{
return MachVtbl.DiskNormalizeSystemPath(SystemPath, Size);
}
-BOOL
+BOOLEAN
MachDiskReadLogicalSectors(ULONG DriveNumber, ULONGLONG SectorNumber, ULONG SectorCount, PVOID Buffer)
{
return MachVtbl.DiskReadLogicalSectors(DriveNumber, SectorNumber, SectorCount, Buffer);
}
-BOOL
+BOOLEAN
MachDiskGetPartitionEntry(ULONG DriveNumber, ULONG PartitionNumber, PPARTITION_TABLE_ENTRY PartitionTableEntry)
{
return MachVtbl.DiskGetPartitionEntry(DriveNumber, PartitionNumber, PartitionTableEntry);
}
-BOOL
+BOOLEAN
MachDiskGetDriveGeometry(ULONG DriveNumber, PGEOMETRY DriveGeometry)
{
return MachVtbl.DiskGetDriveGeometry(DriveNumber, DriveGeometry);
standard Unix calling sequences. If the option is not selected,
the caller must always pop the args.
- The attribute stdcall is equivalent to RTD on a per module basis. */
+ The attribute NTAPI is equivalent to RTD on a per module basis. */
#define RETURN_POPS_ARGS(FUNDECL, FUNTYPE, SIZE) \
ix86_return_pops_args ((FUNDECL), (FUNTYPE), (SIZE))
}
#ifdef __i386__
-extern int VirtualProtect (char *, int, int, int *) __attribute__((stdcall));
+extern int VirtualProtect (char *, int, int, int *) __attribute__((NTAPI));
#endif
int
standard Unix calling sequences. If the option is not selected,
the caller must always pop the args.
- The attribute stdcall is equivalent to RTD on a per module basis. */
+ The attribute NTAPI is equivalent to RTD on a per module basis. */
#define RETURN_POPS_ARGS(FUNDECL, FUNTYPE, SIZE) \
ix86_return_pops_args ((FUNDECL), (FUNTYPE), (SIZE))
ULONG FreePagesInLookupTable = 0;
ULONG LastFreePageHint = 0;
-BOOL MmInitializeMemoryManager(VOID)
+BOOLEAN MmInitializeMemoryManager(VOID)
{
BIOS_MEMORY_MAP BiosMemoryMap[32];
ULONG BiosMemoryMapEntryCount;
}
}
-BOOL MmAreMemoryPagesAvailable(PVOID PageLookupTable, ULONG TotalPageCount, PVOID PageAddress, ULONG PageCount)
+BOOLEAN MmAreMemoryPagesAvailable(PVOID PageLookupTable, ULONG TotalPageCount, PVOID PageAddress, ULONG PageCount)
{
PPAGE_LOOKUP_TABLE_ITEM RealPageLookupTable = (PPAGE_LOOKUP_TABLE_ITEM)PageLookupTable;
ULONG StartPage;
#include <freeldr.h>
-BOOL InitOperatingSystemList(PCSTR **SectionNamesPointer, PCSTR **DisplayNamesPointer, ULONG* OperatingSystemCountPointer)
+BOOLEAN InitOperatingSystemList(PCSTR **SectionNamesPointer, PCSTR **DisplayNamesPointer, ULONG* OperatingSystemCountPointer)
{
ULONG Idx;
ULONG CurrentOperatingSystemIndex;
return OperatingSystemCount;
}
-BOOL AllocateListMemory(PCHAR **SectionNamesPointer, PCHAR **DisplayNamesPointer, ULONG OperatingSystemCount)
+BOOLEAN AllocateListMemory(PCHAR **SectionNamesPointer, PCHAR **DisplayNamesPointer, ULONG OperatingSystemCount)
{
ULONG Idx;
PCHAR *OperatingSystemSectionNames = NULL;
return FALSE;
}
-BOOL RemoveQuotes(PCHAR QuotedString)
+BOOLEAN RemoveQuotes(PCHAR QuotedString)
{
CHAR TempString[200];
#include <freeldr.h>
-BOOL DissectArcPath(CHAR *ArcPath, CHAR *BootPath, ULONG* BootDrive, ULONG* BootPartition)
+BOOLEAN DissectArcPath(CHAR *ArcPath, CHAR *BootPath, ULONG* BootDrive, ULONG* BootPartition)
{
char *p;
ULONG NameSize;
ULONG CellSize;
ULONG i;
- BOOL Packable = TRUE;
+ BOOLEAN Packable = TRUE;
assert (RootKeyCell);
static VOID
-CmiCleanupHive(PREGISTRY_HIVE Hive, BOOL Release)
+CmiCleanupHive(PREGISTRY_HIVE Hive, BOOLEAN Release)
{
MmFreeMemory (Hive->FreeListOffset);
MmFreeMemory (Hive->FreeList);
}
-static BOOL
+static BOOLEAN
CmiMergeFree(PREGISTRY_HIVE RegistryHive,
PCELL_HEADER FreeBlock,
BLOCK_OFFSET FreeOffset)
}
-static BOOL
+static BOOLEAN
CmiAddFree(PREGISTRY_HIVE RegistryHive,
PCELL_HEADER FreeBlock,
BLOCK_OFFSET FreeOffset,
- BOOL MergeFreeBlocks)
+ BOOLEAN MergeFreeBlocks)
{
PCELL_HEADER *tmpList;
BLOCK_OFFSET *tmpListOffset;
}
-static BOOL
+static BOOLEAN
CmiAddBin(PREGISTRY_HIVE RegistryHive,
ULONG BlockCount,
PVOID *NewBlock,
}
-static BOOL
+static BOOLEAN
CmiAllocateCell (PREGISTRY_HIVE RegistryHive,
LONG CellSize,
PVOID *Block,
}
-static BOOL
+static BOOLEAN
CmiAllocateHashTableCell (PREGISTRY_HIVE Hive,
PBLOCK_OFFSET HBOffset,
ULONG SubKeyCount)
{
PHASH_TABLE_CELL HashCell;
ULONG NewHashSize;
- BOOL Status;
+ BOOLEAN Status;
NewHashSize = sizeof(HASH_TABLE_CELL) +
(SubKeyCount * sizeof(HASH_RECORD));
}
-static BOOL
+static BOOLEAN
CmiAddKeyToParentHashTable (PREGISTRY_HIVE Hive,
BLOCK_OFFSET ParentKeyOffset,
PKEY_CELL NewKeyCell,
}
-static BOOL
+static BOOLEAN
CmiAllocateValueListCell (PREGISTRY_HIVE Hive,
PBLOCK_OFFSET ValueListOffset,
ULONG ValueCount)
{
PVALUE_LIST_CELL ValueListCell;
ULONG ValueListSize;
- BOOL Status;
+ BOOLEAN Status;
ValueListSize = sizeof(VALUE_LIST_CELL) +
(ValueCount * sizeof(BLOCK_OFFSET));
}
-static BOOL
+static BOOLEAN
CmiAllocateValueCell(PREGISTRY_HIVE Hive,
PVALUE_CELL *ValueCell,
BLOCK_OFFSET *ValueCellOffset,
{
PVALUE_CELL NewValueCell;
ULONG NameSize;
- BOOL Status;
+ BOOLEAN Status;
BOOLEAN Packable = TRUE;
ULONG i;
}
-static BOOL
+static BOOLEAN
CmiAddValueToKeyValueList(PREGISTRY_HIVE Hive,
BLOCK_OFFSET KeyCellOffset,
BLOCK_OFFSET ValueCellOffset)
return TRUE;
}
-static BOOL
+static BOOLEAN
CmiExportValue (PREGISTRY_HIVE Hive,
BLOCK_OFFSET KeyCellOffset,
FRLDRHKEY Key,
}
-static BOOL
+static BOOLEAN
CmiExportSubKey (PREGISTRY_HIVE Hive,
BLOCK_OFFSET ParentKeyOffset,
FRLDRHKEY ParentKey,
}
-static BOOL
+static BOOLEAN
CmiExportHive (PREGISTRY_HIVE Hive,
PCWSTR KeyName)
{
}
-static BOOL
+static BOOLEAN
RegImportValue (PHBIN RootBin,
PVALUE_CELL ValueCell,
FRLDRHKEY Key)
}
-static BOOL
+static BOOLEAN
RegImportSubKey(PHBIN RootBin,
PKEY_CELL KeyCell,
FRLDRHKEY ParentKey)
}
-BOOL
+BOOLEAN
RegImportBinaryHive(PCHAR ChunkBase,
ULONG ChunkSize)
{
}
-BOOL
+BOOLEAN
RegExportBinaryHive(PCWSTR KeyName,
PCHAR ChunkBase,
ULONG* ChunkSize)
static CHAR szLoadingMsg[] = "Loading ReactOS...";
-static BOOL
-STDCALL
+static BOOLEAN
+NTAPI
FrLdrLoadKernel(PCHAR szFileName,
INT nPos)
{
return TRUE;
}
-static BOOL
+static BOOLEAN
LoadKernelSymbols(PCHAR szKernelName, int nPos)
{
static ROSSYM_CALLBACKS FreeldrCallbacks =
return TRUE;
}
-static BOOL
+static BOOLEAN
FrLdrLoadNlsFile(PCSTR szFileName,
PCSTR szModuleName)
{
return(TRUE);
}
-static BOOL
+static BOOLEAN
FrLdrLoadNlsFiles(PCHAR szSystemRoot,
PCHAR szErrorOut)
{
return(TRUE);
}
-static BOOL
+static BOOLEAN
FrLdrLoadDriver(PCHAR szFileName,
INT nPos)
{
LONG
-RegInitCurrentControlSet(BOOL LastKnownGood)
+RegInitCurrentControlSet(BOOLEAN LastKnownGood)
{
WCHAR ControlSetKeyName[80];
FRLDRHKEY SelectKey;
return TRUE;
}
-static BOOL
+static BOOLEAN
LoadKernel(PCSTR szSourcePath, PCSTR szFileName)
{
CHAR szFullName[256];
return(TRUE);
}
-static BOOL
+static BOOLEAN
LoadKernelSymbols(PCSTR szSourcePath, PCSTR szFileName)
{
static ROSSYM_CALLBACKS FreeldrCallbacks =
return FALSE;
}
-static BOOL
+static BOOLEAN
LoadDriver(PCSTR szSourcePath, PCSTR szFileName)
{
CHAR szFullName[256];
}
-static BOOL
+static BOOLEAN
LoadNlsFile(PCSTR szSourcePath, PCSTR szFileName, PCSTR szModuleName)
{
CHAR szFullName[256];
return ListHead;
}
-BOOL RtlListIsEmpty(PLIST_ITEM ListHead)
+BOOLEAN RtlListIsEmpty(PLIST_ITEM ListHead)
{
if (ListHead == NULL)
{
{
}
-VOID GuiDrawBox(ULONG Left, ULONG Top, ULONG Right, ULONG Bottom, UCHAR VertStyle, UCHAR HorzStyle, BOOL Fill, BOOL Shadow, UCHAR Attr)
+VOID GuiDrawBox(ULONG Left, ULONG Top, ULONG Right, ULONG Bottom, UCHAR VertStyle, UCHAR HorzStyle, BOOLEAN Fill, BOOLEAN Shadow, UCHAR Attr)
{
}
#include <freeldr.h>
PVOID TextVideoBuffer = NULL;
-extern BOOL UiDrawTime;
-extern BOOL UiMinimal;
+extern BOOLEAN UiDrawTime;
+extern BOOLEAN UiMinimal;
/*
* printf() - prints formatted text to stdout
return 0;
}
-BOOL TuiInitialize(VOID)
+BOOLEAN TuiInitialize(VOID)
{
MachVideoClearScreen(ATTR(COLOR_WHITE, COLOR_BLACK));
MachVideoHideShowTextCursor(FALSE);
* DrawBox()
* This function assumes coordinates are zero-based
*/
-VOID TuiDrawBox(ULONG Left, ULONG Top, ULONG Right, ULONG Bottom, UCHAR VertStyle, UCHAR HorzStyle, BOOL Fill, BOOL Shadow, UCHAR Attr)
+VOID TuiDrawBox(ULONG Left, ULONG Top, ULONG Right, ULONG Bottom, UCHAR VertStyle, UCHAR HorzStyle, BOOLEAN Fill, BOOLEAN Shadow, UCHAR Attr)
{
UCHAR ULCorner, URCorner, LLCorner, LRCorner;
CHAR DateString[40];
CHAR TimeString[40];
CHAR TempString[20];
- BOOL PMHour = FALSE;
+ BOOLEAN PMHour = FALSE;
/* Don't draw the time if this has been disabled */
if (!UiDrawTime) return;
}
-BOOL TuiEditBox(PCSTR MessageText, PCHAR EditTextBuffer, ULONG Length)
+BOOLEAN TuiEditBox(PCSTR MessageText, PCHAR EditTextBuffer, ULONG Length)
{
int width = 8;
unsigned int height = 1;
int EditBoxCursorX;
unsigned int EditBoxTextCount;
int EditBoxTextDisplayIndex;
- BOOL ReturnCode;
+ BOOLEAN ReturnCode;
PVOID ScreenBuffer;
// Save the screen contents
/* FUNCTIONS *****************************************************************/
-BOOL
-WINAPI
+BOOLEAN
+NTAPI
TuiDisplayMenu(PCSTR MenuItemList[],
ULONG MenuItemCount,
ULONG DefaultMenuItem,
LONG MenuTimeOut,
ULONG* SelectedMenuItem,
- BOOL CanEscape,
+ BOOLEAN CanEscape,
UiMenuKeyPressFilterCallback KeyPressFilter)
{
TUI_MENU_INFO MenuInformation;
}
VOID
-WINAPI
+NTAPI
TuiCalcMenuBoxSize(PTUI_MENU_INFO MenuInfo)
{
ULONG i;
}
VOID
-WINAPI
+NTAPI
TuiDrawMenu(PTUI_MENU_INFO MenuInfo)
{
ULONG i;
}
VOID
-WINAPI
+NTAPI
TuiDrawMenuBox(PTUI_MENU_INFO MenuInfo)
{
CHAR MenuLineText[80];
}
VOID
-WINAPI
+NTAPI
TuiDrawMenuItem(PTUI_MENU_INFO MenuInfo,
ULONG MenuItemNumber)
{
}
ULONG
-WINAPI
+NTAPI
TuiProcessMenuKeyboardEvent(PTUI_MENU_INFO MenuInfo,
UiMenuKeyPressFilterCallback KeyPressFilter)
{
CHAR UiTitleBoxTitleText[260] = "Boot Menu"; // Title box's title text
-BOOL UserInterfaceUp = FALSE; // Tells us if the user interface is displayed
+BOOLEAN UserInterfaceUp = FALSE; // Tells us if the user interface is displayed
VIDEODISPLAYMODE UiDisplayMode = VideoTextMode; // Tells us if we are in text or graphics mode
-BOOL UiUseSpecialEffects = FALSE; // Tells us if we should use fade effects
-BOOL UiDrawTime = TRUE; // Tells us if we should draw the time
-BOOL UiMinimal = FALSE; // Tells us if we should use a minimal console-like UI
-BOOL UiCenterMenu = TRUE; // Tells us if we should use a centered or left-aligned menu
-BOOL UiMenuBox = TRUE; // Tells us if we shuld draw a box around the menu
+BOOLEAN UiUseSpecialEffects = FALSE; // Tells us if we should use fade effects
+BOOLEAN UiDrawTime = TRUE; // Tells us if we should draw the time
+BOOLEAN UiMinimal = FALSE; // Tells us if we should use a minimal console-like UI
+BOOLEAN UiCenterMenu = TRUE; // Tells us if we should use a centered or left-aligned menu
+BOOLEAN UiMenuBox = TRUE; // Tells us if we shuld draw a box around the menu
CHAR UiTimeText[260] = "[Time Remaining: ] ";
const CHAR UiMonthNames[12][15] = { "January ", "February ", "March ", "April ", "May ", "June ", "July ", "August ", "September ", "October ", "November ", "December " };
-BOOL UiInitialize(BOOLEAN ShowGui)
+BOOLEAN UiInitialize(BOOLEAN ShowGui)
{
ULONG SectionId;
CHAR DisplayModeText[260];
return TRUE;
}
-BOOL SetupUiInitialize(VOID)
+BOOLEAN SetupUiInitialize(VOID)
{
CHAR DisplayModeText[260];
}
}
-VOID UiDrawBox(ULONG Left, ULONG Top, ULONG Right, ULONG Bottom, UCHAR VertStyle, UCHAR HorzStyle, BOOL Fill, BOOL Shadow, UCHAR Attr)
+VOID UiDrawBox(ULONG Left, ULONG Top, ULONG Right, ULONG Bottom, UCHAR VertStyle, UCHAR HorzStyle, BOOLEAN Fill, BOOLEAN Shadow, UCHAR Attr)
{
if (VideoTextMode == UiDisplayMode)
{
}
}
-BOOL UiDisplayMenu(PCSTR MenuItemList[], ULONG MenuItemCount, ULONG DefaultMenuItem, LONG MenuTimeOut, ULONG* SelectedMenuItem, BOOL CanEscape, UiMenuKeyPressFilterCallback KeyPressFilter)
+BOOLEAN UiDisplayMenu(PCSTR MenuItemList[], ULONG MenuItemCount, ULONG DefaultMenuItem, LONG MenuTimeOut, ULONG* SelectedMenuItem, BOOLEAN CanEscape, UiMenuKeyPressFilterCallback KeyPressFilter)
{
if (VideoTextMode == UiDisplayMode)
{
}
}
-BOOL UiEditBox(PCSTR MessageText, PCHAR EditTextBuffer, ULONG Length)
+BOOLEAN UiEditBox(PCSTR MessageText, PCHAR EditTextBuffer, ULONG Length)
{
if (VideoTextMode == UiDisplayMode)
{
projects / reactos.git / commitdiff