* Code cleanup:

  - remove trailing white space, trailing empty lines, C++ comments, etc.
  - split cmd_boot.c (separate cmd_bdinfo.c and cmd_load.c)

* Patches by Kenneth Johansson, 25 Jun 2003:
  - major rework of command structure
    (work done mostly by Michal Cendrowski and Joakim Kristiansen)

5 files changed, 200 insertions, 200 deletions

diff --git a/board/MAI/bios_emulator/scitech/src/pm/beos/cpuinfo.c b/board/MAI/bios_emulator/scitech/src/pm/beos/cpuinfo.c
index c8f825e25b..cb3afe20c1 100644
--- a/board/MAI/bios_emulator/scitech/src/pm/beos/cpuinfo.c
+++ b/board/MAI/bios_emulator/scitech/src/pm/beos/cpuinfo.c
@@ -64,8 +64,8 @@ Initialise the counter and return the frequency of the counter.
 static void GetCounterFrequency(
     CPU_largeInteger *freq)
 {
-    // TODO: Return the frequency of the counter in here. You should try to
-    //       normalise this value to be around 100,000 ticks per second.
+    /* TODO: Return the frequency of the counter in here. You should try to */
+    /*       normalise this value to be around 100,000 ticks per second. */
     freq->low = 1000000;
     freq->high = 0;
 }
diff --git a/board/MAI/bios_emulator/scitech/src/pm/beos/event.c b/board/MAI/bios_emulator/scitech/src/pm/beos/event.c
index 4c32ce7434..93c6c0a8fc 100644
--- a/board/MAI/bios_emulator/scitech/src/pm/beos/event.c
+++ b/board/MAI/bios_emulator/scitech/src/pm/beos/event.c
@@ -59,7 +59,7 @@ events.
 ****************************************************************************/
 ulong _EVT_getTicks(void)
 {
-    // TODO: Implement this for your OS!
+    /* TODO: Implement this for your OS! */
 }
 
 /****************************************************************************
@@ -68,36 +68,36 @@ Pumps all messages in the application message queue into our event queue.
 ****************************************************************************/
 static void _EVT_pumpMessages(void)
 {
-    // TODO: The purpose of this function is to read all keyboard and mouse
-    //       events from the OS specific event queue, translate them and post
-    //       them into the SciTech event queue.
-    //
-    // NOTE: There are a couple of important things that this function must
-    //       take care of:
-    //
-    //  1. Support for KEYDOWN, KEYREPEAT and KEYUP is required.
-    //
-    //  2. Support for reading hardware scan code as well as ASCII
-    //     translated values is required. Games use the scan codes rather
-    //     than ASCII values. Scan codes go into the high order byte of the
-    //     keyboard message field.
-    //
-    //  3. Support for at least reading mouse motion data (mickeys) from the
-    //     mouse is required. Using the mickey values, we can then translate
-    //     to mouse cursor coordinates scaled to the range of the current
-    //     graphics display mode. Mouse values are scaled based on the
-    //     global 'rangeX' and 'rangeY'.
-    //
-    //  4. Support for a timestamp for the events is required, which is
-    //     defined as the number of milliseconds since some event (usually
-    //     system startup). This is the timestamp when the event occurred
-    //     (ie: at interrupt time) not when it was stuff into the SciTech
-    //     event queue.
-    //
-    //  5. Support for mouse double click events. If the OS has a native
-    //     mechanism to determine this, it should be used. Otherwise the
-    //     time stamp information will be used by the generic event code
-    //     to generate double click events.
+    /* TODO: The purpose of this function is to read all keyboard and mouse */
+    /*       events from the OS specific event queue, translate them and post */
+    /*       them into the SciTech event queue. */
+    /* */
+    /* NOTE: There are a couple of important things that this function must */
+    /*       take care of: */
+    /* */
+    /*  1. Support for KEYDOWN, KEYREPEAT and KEYUP is required. */
+    /* */
+    /*  2. Support for reading hardware scan code as well as ASCII */
+    /*     translated values is required. Games use the scan codes rather */
+    /*     than ASCII values. Scan codes go into the high order byte of the */
+    /*     keyboard message field. */
+    /* */
+    /*  3. Support for at least reading mouse motion data (mickeys) from the */
+    /*     mouse is required. Using the mickey values, we can then translate */
+    /*     to mouse cursor coordinates scaled to the range of the current */
+    /*     graphics display mode. Mouse values are scaled based on the */
+    /*     global 'rangeX' and 'rangeY'. */
+    /* */
+    /*  4. Support for a timestamp for the events is required, which is */
+    /*     defined as the number of milliseconds since some event (usually */
+    /*     system startup). This is the timestamp when the event occurred */
+    /*     (ie: at interrupt time) not when it was stuff into the SciTech */
+    /*     event queue. */
+    /* */
+    /*  5. Support for mouse double click events. If the OS has a native */
+    /*     mechanism to determine this, it should be used. Otherwise the */
+    /*     time stamp information will be used by the generic event code */
+    /*     to generate double click events. */
 }
 
 /****************************************************************************
@@ -141,7 +141,7 @@ void EVTAPI EVT_init(
     initEventQueue();
     memset(keyUpMsg,0,sizeof(keyUpMsg));
 
-    // TODO: Do any OS specific initialisation here
+    /* TODO: Do any OS specific initialisation here */
 
     /* Catch program termination signals so we can clean up properly */
     signal(SIGABRT, _EVT_abort);
@@ -171,7 +171,7 @@ and this function can be used to resume it again later.
 ****************************************************************************/
 void EVT_resume(void)
 {
-    // Do nothing for non DOS systems
+    /* Do nothing for non DOS systems */
 }
 
 /****************************************************************************
@@ -181,7 +181,7 @@ de-install the event handling code.
 ****************************************************************************/
 void EVT_suspend(void)
 {
-    // Do nothing for non DOS systems
+    /* Do nothing for non DOS systems */
 }
 
 /****************************************************************************
@@ -195,5 +195,5 @@ void EVT_exit(void)
     signal(SIGFPE, SIG_DFL);
     signal(SIGINT, SIG_DFL);
 
-    // TODO: Do any OS specific cleanup in here
+    /* TODO: Do any OS specific cleanup in here */
 }
diff --git a/board/MAI/bios_emulator/scitech/src/pm/beos/oshdr.h b/board/MAI/bios_emulator/scitech/src/pm/beos/oshdr.h
index ab423d4be6..043d73ecd1 100644
--- a/board/MAI/bios_emulator/scitech/src/pm/beos/oshdr.h
+++ b/board/MAI/bios_emulator/scitech/src/pm/beos/oshdr.h
@@ -28,5 +28,5 @@
 *
 ****************************************************************************/
 
-// This is where you include OS specific headers for the event handling
-// library.
+/* This is where you include OS specific headers for the event handling */
+/* library. */
diff --git a/board/MAI/bios_emulator/scitech/src/pm/beos/pm.c b/board/MAI/bios_emulator/scitech/src/pm/beos/pm.c
index c57d82ab68..2dcb1b81fb 100644
--- a/board/MAI/bios_emulator/scitech/src/pm/beos/pm.c
+++ b/board/MAI/bios_emulator/scitech/src/pm/beos/pm.c
@@ -38,7 +38,7 @@
 #include <stdlib.h>
 #include <string.h>
 
-// TODO: Include any BeOS specific headers here!
+/* TODO: Include any BeOS specific headers here! */
 
 /*--------------------------- Global variables ----------------------------*/
 
@@ -48,12 +48,12 @@ static void (PMAPIP fatalErrorCleanup)(void) = NULL;
 
 void PMAPI PM_init(void)
 {
-    // TODO: Do any initialisation in here. This includes getting IOPL
-    //       access for the process calling PM_init. This will get called
-    //       more than once.
+    /* TODO: Do any initialisation in here. This includes getting IOPL */
+    /*       access for the process calling PM_init. This will get called */
+    /*       more than once. */
 
-    // TODO: If you support the supplied MTRR register stuff (you need to
-    //       be at ring 0 for this!), you should initialise it in here.
+    /* TODO: If you support the supplied MTRR register stuff (you need to */
+    /*       be at ring 0 for this!), you should initialise it in here. */
 
 /* MTRR_init(); */
 }
@@ -68,9 +68,9 @@ void PMAPI PM_backslash(char *s)
 {
     uint pos = strlen(s);
     if (s[pos-1] != '/') {
-        s[pos] = '/';
-        s[pos+1] = '\0';
-        }
+	s[pos] = '/';
+	s[pos+1] = '\0';
+	}
 }
 
 void PMAPI PM_setFatalErrorCleanup(
@@ -81,112 +81,112 @@ void PMAPI PM_setFatalErrorCleanup(
 
 void PMAPI PM_fatalError(const char *msg)
 {
-    // TODO: If you are running in a GUI environment without a console,
-    //       this needs to be changed to bring up a fatal error message
-    //       box and terminate the program.
+    /* TODO: If you are running in a GUI environment without a console, */
+    /*       this needs to be changed to bring up a fatal error message */
+    /*       box and terminate the program. */
     if (fatalErrorCleanup)
-        fatalErrorCleanup();
+	fatalErrorCleanup();
     fprintf(stderr,"%s\n", msg);
     exit(1);
 }
 
 void * PMAPI PM_getVESABuf(uint *len,uint *rseg,uint *roff)
 {
-    // No BIOS access for the BeOS
+    /* No BIOS access for the BeOS */
     return NULL;
 }
 
 int PMAPI PM_kbhit(void)
 {
-    // TODO: This function checks if a key is available to be read. This
-    //       should be implemented, but is mostly used by the test programs
-    //       these days.
+    /* TODO: This function checks if a key is available to be read. This */
+    /*       should be implemented, but is mostly used by the test programs */
+    /*       these days. */
     return true;
 }
 
 int PMAPI PM_getch(void)
 {
-    // TODO: This returns the ASCII code of the key pressed. This
-    //       should be implemented, but is mostly used by the test programs
-    //       these days.
+    /* TODO: This returns the ASCII code of the key pressed. This */
+    /*       should be implemented, but is mostly used by the test programs */
+    /*       these days. */
     return 0xD;
 }
 
 int PMAPI PM_openConsole(void)
 {
-    // TODO: Opens up a fullscreen console for graphics output. If your
-    //       console does not have graphics/text modes, this can be left
-    //       empty. The main purpose of this is to disable console switching
-    //       when in graphics modes if you can switch away from fullscreen
-    //       consoles (if you want to allow switching, this can be done
-    //       elsewhere with a full save/restore state of the graphics mode).
+    /* TODO: Opens up a fullscreen console for graphics output. If your */
+    /*       console does not have graphics/text modes, this can be left */
+    /*       empty. The main purpose of this is to disable console switching */
+    /*       when in graphics modes if you can switch away from fullscreen */
+    /*       consoles (if you want to allow switching, this can be done */
+    /*       elsewhere with a full save/restore state of the graphics mode). */
     return 0;
 }
 
 int PMAPI PM_getConsoleStateSize(void)
 {
-    // TODO: Returns the size of the console state buffer used to save the
-    //       state of the console before going into graphics mode. This is
-    //       used to restore the console back to normal when we are done.
+    /* TODO: Returns the size of the console state buffer used to save the */
+    /*       state of the console before going into graphics mode. This is */
+    /*       used to restore the console back to normal when we are done. */
     return 1;
 }
 
 void PMAPI PM_saveConsoleState(void *stateBuf,int console_id)
 {
-    // TODO: Saves the state of the console into the state buffer. This is
-    //       used to restore the console back to normal when we are done.
-    //       We will always restore 80x25 text mode after being in graphics
-    //       mode, so if restoring text mode is all you need to do this can
-    //       be left empty.
+    /* TODO: Saves the state of the console into the state buffer. This is */
+    /*       used to restore the console back to normal when we are done. */
+    /*       We will always restore 80x25 text mode after being in graphics */
+    /*       mode, so if restoring text mode is all you need to do this can */
+    /*       be left empty. */
 }
 
 void PMAPI PM_restoreConsoleState(const void *stateBuf,int console_id)
 {
-    // TODO: Restore the state of the console from the state buffer. This is
-    //       used to restore the console back to normal when we are done.
-    //       We will always restore 80x25 text mode after being in graphics
-    //       mode, so if restoring text mode is all you need to do this can
-    //       be left empty.
+    /* TODO: Restore the state of the console from the state buffer. This is */
+    /*       used to restore the console back to normal when we are done. */
+    /*       We will always restore 80x25 text mode after being in graphics */
+    /*       mode, so if restoring text mode is all you need to do this can */
+    /*       be left empty. */
 }
 
 void PMAPI PM_closeConsole(int console_id)
 {
-    // TODO: Close the console when we are done, going back to text mode.
+    /* TODO: Close the console when we are done, going back to text mode. */
 }
 
 void PM_setOSCursorLocation(int x,int y)
 {
-    // TODO: Set the OS console cursor location to the new value. This is
-    //       generally used for new OS ports (used mostly for DOS).
+    /* TODO: Set the OS console cursor location to the new value. This is */
+    /*       generally used for new OS ports (used mostly for DOS). */
 }
 
 void PM_setOSScreenWidth(int width,int height)
 {
-    // TODO: Set the OS console screen width. This is generally unused for
-    //       new OS ports.
+    /* TODO: Set the OS console screen width. This is generally unused for */
+    /*       new OS ports. */
 }
 
 ibool PMAPI PM_setRealTimeClockHandler(PM_intHandler ih, int frequency)
 {
-    // TODO: Install a real time clock interrupt handler. Normally this
-    //       will not be supported from most OS'es in user land, so an
-    //       alternative mechanism is needed to enable software stereo.
-    //       Hence leave this unimplemented unless you have a high priority
-    //       mechanism to call the 32-bit callback when the real time clock
-    //       interrupt fires.
+    /* TODO: Install a real time clock interrupt handler. Normally this */
+    /*       will not be supported from most OS'es in user land, so an */
+    /*       alternative mechanism is needed to enable software stereo. */
+    /*       Hence leave this unimplemented unless you have a high priority */
+    /*       mechanism to call the 32-bit callback when the real time clock */
+    /*       interrupt fires. */
     return false;
 }
 
 void PMAPI PM_setRealTimeClockFrequency(int frequency)
 {
-    // TODO: Set the real time clock interrupt frequency. Used for stereo
-    //       LC shutter glasses when doing software stereo. Usually sets
-    //       the frequency to around 2048 Hz.
+    /* TODO: Set the real time clock interrupt frequency. Used for stereo */
+    /*       LC shutter glasses when doing software stereo. Usually sets */
+    /*       the frequency to around 2048 Hz. */
 }
 
 void PMAPI PM_restoreRealTimeClockHandler(void)
 {
-    // TODO: Restores the real time clock handler.
+    /* TODO: Restores the real time clock handler. */
 }
 
 char * PMAPI PM_getCurrentPath(
@@ -219,8 +219,8 @@ const char * PMAPI PM_getNucleusConfigPath(void)
 
 const char * PMAPI PM_getUniqueID(void)
 {
-    // TODO: Return a unique ID for the machine. If a unique ID is not
-    //       available, return the machine name.
+    /* TODO: Return a unique ID for the machine. If a unique ID is not */
+    /*       available, return the machine name. */
     static char buf[128];
     gethostname(buf, 128);
     return buf;
@@ -228,7 +228,7 @@ const char * PMAPI PM_getUniqueID(void)
 
 const char * PMAPI PM_getMachineName(void)
 {
-    // TODO: Return the network machine name for the machine.
+    /* TODO: Return the network machine name for the machine. */
     static char buf[128];
     gethostname(buf, 128);
     return buf;
@@ -236,7 +236,7 @@ const char * PMAPI PM_getMachineName(void)
 
 void * PMAPI PM_getBIOSPointer(void)
 {
-    // No BIOS access on the BeOS
+    /* No BIOS access on the BeOS */
     return NULL;
 }
 
@@ -244,212 +244,212 @@ void * PMAPI PM_getA0000Pointer(void)
 {
     static void *bankPtr;
     if (!bankPtr)
-        bankPtr = PM_mapPhysicalAddr(0xA0000,0xFFFF,true);
+	bankPtr = PM_mapPhysicalAddr(0xA0000,0xFFFF,true);
     return bankPtr;
 }
 
 void * PMAPI PM_mapPhysicalAddr(ulong base,ulong limit,ibool isCached)
 {
-    // TODO: This function maps a physical memory address to a linear
-    //       address in the address space of the calling process.
-
-    // NOTE: This function *must* be able to handle any phsyical base
-    //       address, and hence you will have to handle rounding of
-    //       the physical base address to a page boundary (ie: 4Kb on
-    //       x86 CPU's) to be able to properly map in the memory
-    //       region.
-
-    // NOTE: If possible the isCached bit should be used to ensure that
-    //       the PCD (Page Cache Disable) and PWT (Page Write Through)
-    //       bits are set to disable caching for a memory mapping used
-    //       for MMIO register access. We also disable caching using
-    //       the MTRR registers for Pentium Pro and later chipsets so if
-    //       MTRR support is enabled for your OS then you can safely ignore
-    //       the isCached flag and always enable caching in the page
-    //       tables.
+    /* TODO: This function maps a physical memory address to a linear */
+    /*       address in the address space of the calling process. */
+
+    /* NOTE: This function *must* be able to handle any phsyical base */
+    /*       address, and hence you will have to handle rounding of */
+    /*       the physical base address to a page boundary (ie: 4Kb on */
+    /*       x86 CPU's) to be able to properly map in the memory */
+    /*       region. */
+
+    /* NOTE: If possible the isCached bit should be used to ensure that */
+    /*       the PCD (Page Cache Disable) and PWT (Page Write Through) */
+    /*       bits are set to disable caching for a memory mapping used */
+    /*       for MMIO register access. We also disable caching using */
+    /*       the MTRR registers for Pentium Pro and later chipsets so if */
+    /*       MTRR support is enabled for your OS then you can safely ignore */
+    /*       the isCached flag and always enable caching in the page */
+    /*       tables. */
     return NULL;
 }
 
 void PMAPI PM_freePhysicalAddr(void *ptr,ulong limit)
 {
-    // TODO: This function will free a physical memory mapping previously
-    //       allocated with PM_mapPhysicalAddr() if at all possible. If
-    //       you can't free physical memory mappings, simply do nothing.
+    /* TODO: This function will free a physical memory mapping previously */
+    /*       allocated with PM_mapPhysicalAddr() if at all possible. If */
+    /*       you can't free physical memory mappings, simply do nothing. */
 }
 
 ulong PMAPI PM_getPhysicalAddr(void *p)
 {
-    // TODO: This function should find the physical address of a linear
-    //       address.
+    /* TODO: This function should find the physical address of a linear */
+    /*       address. */
     return 0xFFFFFFFFUL;
 }
 
 void PMAPI PM_sleep(ulong milliseconds)
 {
-    // TODO: Put the process to sleep for milliseconds
+    /* TODO: Put the process to sleep for milliseconds */
 }
 
 int PMAPI PM_getCOMPort(int port)
 {
-    // TODO: Re-code this to determine real values using the Plug and Play
-    //       manager for the OS.
+    /* TODO: Re-code this to determine real values using the Plug and Play */
+    /*       manager for the OS. */
     switch (port) {
-        case 0: return 0x3F8;
-        case 1: return 0x2F8;
-        }
+	case 0: return 0x3F8;
+	case 1: return 0x2F8;
+	}
     return 0;
 }
 
 int PMAPI PM_getLPTPort(int port)
 {
-    // TODO: Re-code this to determine real values using the Plug and Play
-    //       manager for the OS.
+    /* TODO: Re-code this to determine real values using the Plug and Play */
+    /*       manager for the OS. */
     switch (port) {
-        case 0: return 0x3BC;
-        case 1: return 0x378;
-        case 2: return 0x278;
-        }
+	case 0: return 0x3BC;
+	case 1: return 0x378;
+	case 2: return 0x278;
+	}
     return 0;
 }
 
 void * PMAPI PM_mallocShared(long size)
 {
-    // TODO: This is used to allocate memory that is shared between process
-    //       that all access the common Nucleus drivers via a common display
-    //       driver DLL. If your OS does not support shared memory (or if
-    //       the display driver does not need to allocate shared memory
-    //       for each process address space), this should just call PM_malloc.
+    /* TODO: This is used to allocate memory that is shared between process */
+    /*       that all access the common Nucleus drivers via a common display */
+    /*       driver DLL. If your OS does not support shared memory (or if */
+    /*       the display driver does not need to allocate shared memory */
+    /*       for each process address space), this should just call PM_malloc. */
     return PM_malloc(size);
 }
 
 void PMAPI PM_freeShared(void *ptr)
 {
-    // TODO: Free the shared memory block. This will be called in the context
-    //       of the original calling process that allocated the shared
-    //       memory with PM_mallocShared. Simply call free if you do not
-    //       need this.
+    /* TODO: Free the shared memory block. This will be called in the context */
+    /*       of the original calling process that allocated the shared */
+    /*       memory with PM_mallocShared. Simply call free if you do not */
+    /*       need this. */
     PM_free(ptr);
 }
 
 void * PMAPI PM_mapToProcess(void *base,ulong limit)
 {
-    // TODO: This function is used to map a physical memory mapping
-    //       previously allocated with PM_mapPhysicalAddr into the
-    //       address space of the calling process. If the memory mapping
-    //       allocated by PM_mapPhysicalAddr is global to all processes,
-    //       simply return the pointer.
+    /* TODO: This function is used to map a physical memory mapping */
+    /*       previously allocated with PM_mapPhysicalAddr into the */
+    /*       address space of the calling process. If the memory mapping */
+    /*       allocated by PM_mapPhysicalAddr is global to all processes, */
+    /*       simply return the pointer. */
     return base;
 }
 
 void * PMAPI PM_mapRealPointer(uint r_seg,uint r_off)
 {
-    // No BIOS access on the BeOS
+    /* No BIOS access on the BeOS */
     return NULL;
 }
 
 void * PMAPI PM_allocRealSeg(uint size,uint *r_seg,uint *r_off)
 {
-    // No BIOS access on the BeOS
+    /* No BIOS access on the BeOS */
     return NULL;
 }
 
 void PMAPI PM_freeRealSeg(void *mem)
 {
-    // No BIOS access on the BeOS
+    /* No BIOS access on the BeOS */
 }
 
 void PMAPI DPMI_int86(int intno, DPMI_regs *regs)
 {
-    // No BIOS access on the BeOS
+    /* No BIOS access on the BeOS */
 }
 
 int PMAPI PM_int86(int intno, RMREGS *in, RMREGS *out)
 {
-    // No BIOS access on the BeOS
+    /* No BIOS access on the BeOS */
     return 0;
 }
 
 int PMAPI PM_int86x(int intno, RMREGS *in, RMREGS *out,
     RMSREGS *sregs)
 {
-    // No BIOS access on the BeOS
+    /* No BIOS access on the BeOS */
     return 0;
 }
 
 void PMAPI PM_callRealMode(uint seg,uint off, RMREGS *in,
     RMSREGS *sregs)
 {
-    // No BIOS access on the BeOS
+    /* No BIOS access on the BeOS */
 }
 
 void PMAPI PM_availableMemory(ulong *physical,ulong *total)
 {
-    // TODO: Report the amount of available memory, both the amount of
-    //       physical memory left and the amount of virtual memory left.
-    //       If the OS does not provide these services, report 0's.
+    /* TODO: Report the amount of available memory, both the amount of */
+    /*       physical memory left and the amount of virtual memory left. */
+    /*       If the OS does not provide these services, report 0's. */
     *physical = *total = 0;
 }
 
 void * PMAPI PM_allocLockedMem(uint size,ulong *physAddr,ibool contiguous,ibool below16Meg)
 {
-    // TODO: Allocate a block of locked, physical memory of the specified
-    //       size. This is used for bus master operations. If this is not
-    //       supported by the OS, return NULL and bus mastering will not
-    //       be used.
+    /* TODO: Allocate a block of locked, physical memory of the specified */
+    /*       size. This is used for bus master operations. If this is not */
+    /*       supported by the OS, return NULL and bus mastering will not */
+    /*       be used. */
     return NULL;
 }
 
 void PMAPI PM_freeLockedMem(void *p,uint size,ibool contiguous)
 {
-    // TODO: Free a memory block allocated with PM_allocLockedMem.
+    /* TODO: Free a memory block allocated with PM_allocLockedMem. */
 }
 
 void PMAPI PM_setBankA(int bank)
 {
-    // No BIOS access on the BeOS
+    /* No BIOS access on the BeOS */
 }
 
 void PMAPI PM_setBankAB(int bank)
 {
-    // No BIOS access on the BeOS
+    /* No BIOS access on the BeOS */
 }
 
 void PMAPI PM_setCRTStart(int x,int y,int waitVRT)
 {
-    // No BIOS access on the BeOS
+    /* No BIOS access on the BeOS */
 }
 
 ibool PMAPI PM_enableWriteCombine(ulong base,ulong length,uint type)
 {
-    // TODO: This function should enable Pentium Pro and Pentium II MTRR
-    //       write combining for the passed in physical memory base address
-    //       and length. Normally this is done via calls to an OS specific
-    //       device driver as this can only be done at ring 0.
-    //
-    // NOTE: This is a *very* important function to implement! If you do
-    //       not implement, graphics performance on the latest Intel chips
-    //       will be severly impaired. For sample code that can be used
-    //       directly in a ring 0 device driver, see the MSDOS implementation
-    //       which includes assembler code to do this directly (if the
-    //       program is running at ring 0).
+    /* TODO: This function should enable Pentium Pro and Pentium II MTRR */
+    /*       write combining for the passed in physical memory base address */
+    /*       and length. Normally this is done via calls to an OS specific */
+    /*       device driver as this can only be done at ring 0. */
+    /* */
+    /* NOTE: This is a *very* important function to implement! If you do */
+    /*       not implement, graphics performance on the latest Intel chips */
+    /*       will be severly impaired. For sample code that can be used */
+    /*       directly in a ring 0 device driver, see the MSDOS implementation */
+    /*       which includes assembler code to do this directly (if the */
+    /*       program is running at ring 0). */
     return false;
 }
 
 ibool PMAPI PM_doBIOSPOST(ushort axVal,ulong BIOSPhysAddr,void *mappedBIOS)
 {
-    // TODO: This function is used to run the BIOS POST code on a secondary
-    //       controller to initialise it for use. This is not necessary
-    //       for multi-controller operation, but it will make it a lot
-    //       more convenicent for end users (otherwise they have to boot
-    //       the system once with the secondary controller as primary, and
-    //       then boot with both controllers installed).
-    //
-    //       Even if you don't support full BIOS access, it would be
-    //       adviseable to be able to POST the secondary controllers in the
-    //       system using this function as a minimum requirement. Some
-    //       graphics hardware has registers that contain values that only
-    //       the BIOS knows about, which makes bring up a card from cold
-    //       reset difficult if the BIOS has not POST'ed it.
+    /* TODO: This function is used to run the BIOS POST code on a secondary */
+    /*       controller to initialise it for use. This is not necessary */
+    /*       for multi-controller operation, but it will make it a lot */
+    /*       more convenicent for end users (otherwise they have to boot */
+    /*       the system once with the secondary controller as primary, and */
+    /*       then boot with both controllers installed). */
+    /* */
+    /*       Even if you don't support full BIOS access, it would be */
+    /*       adviseable to be able to POST the secondary controllers in the */
+    /*       system using this function as a minimum requirement. Some */
+    /*       graphics hardware has registers that contain values that only */
+    /*       the BIOS knows about, which makes bring up a card from cold */
+    /*       reset difficult if the BIOS has not POST'ed it. */
     return false;
 }
 
@@ -506,7 +506,7 @@ ibool PMAPI PM_driveValid(
     char drive)
 {
     if (drive == 3)
-        return true;
+	return true;
     return false;
 }
 
@@ -533,7 +533,7 @@ void PMAPI PM_setFileAttr(
     const char *filename,
     uint attrib)
 {
-    // TODO: Set the file attributes for a file
+    /* TODO: Set the file attributes for a file */
     (void)filename;
     (void)attrib;
 }
diff --git a/board/MAI/bios_emulator/scitech/src/pm/beos/ztimer.c b/board/MAI/bios_emulator/scitech/src/pm/beos/ztimer.c
index a5637a5ecf..a528b73177 100644
--- a/board/MAI/bios_emulator/scitech/src/pm/beos/ztimer.c
+++ b/board/MAI/bios_emulator/scitech/src/pm/beos/ztimer.c
@@ -36,7 +36,7 @@ Initialise the Zen Timer module internals.
 ****************************************************************************/
 void _ZTimerInit(void)
 {
-    // TODO: Do any specific internal initialisation in here
+    /* TODO: Do any specific internal initialisation in here */
 }
 
 /****************************************************************************
@@ -46,8 +46,8 @@ Start the Zen Timer counting.
 static void _LZTimerOn(
     LZTimerObject *tm)
 {
-    // TODO: Start the Zen Timer counting. This should be a macro if
-    //       possible.
+    /* TODO: Start the Zen Timer counting. This should be a macro if */
+    /*       possible. */
 }
 
 /****************************************************************************
@@ -57,8 +57,8 @@ Compute the lap time since the timer was started.
 static ulong _LZTimerLap(
     LZTimerObject *tm)
 {
-    // TODO: Compute the lap time between the current time and when the
-    //       timer was started.
+    /* TODO: Compute the lap time between the current time and when the */
+    /*       timer was started. */
     return 0;
 }
 
@@ -69,7 +69,7 @@ Stop the Zen Timer counting.
 static void _LZTimerOff(
     LZTimerObject *tm)
 {
-    // TODO: Stop the timer counting. Should be a macro if possible.
+    /* TODO: Stop the timer counting. Should be a macro if possible. */
 }
 
 /****************************************************************************
@@ -79,7 +79,7 @@ Compute the elapsed time in microseconds between start and end timings.
 static ulong _LZTimerCount(
     LZTimerObject *tm)
 {
-    // TODO: Compute the elapsed time and return it. Always microseconds.
+    /* TODO: Compute the elapsed time and return it. Always microseconds. */
     return 0;
 }
 
@@ -95,9 +95,9 @@ Read the Long Period timer from the OS
 ****************************************************************************/
 static ulong _ULZReadTime(void)
 {
-    // TODO: Read the long period timer from the OS. The resolution of this
-    //       timer should be around 1/20 of a second for timing long
-    //       periods if possible.
+    /* TODO: Read the long period timer from the OS. The resolution of this */
+    /*       timer should be around 1/20 of a second for timing long */
+    /*       periods if possible. */
 }
 
 /****************************************************************************