Implemented some of the basic scheduler functions such as yield(), dormant(),
etc. Added a small thread switching test. Works.
* Sched:
  * Implemented yield(), block(), and cleaned up wake() and dormant().
  * Added support for spawning threads that are dormant at first.
Fixed a bug with x86-32's saveContextAndCallPull(), which caused subtle
trashing until an eventual deadlock occured.

Also added support for up to 16 deadlocked CPUs in the waitLockC bypass
buffers for deadlock debugging.
* Sched: Fixed a bug in taskContextC's constructor where only CS, DS and SS
  were being initialized and the other segment regs were left unset.
* Added an x86-32 General protection fault handler that just prints the
  error code the CPU pushed, then halts the CPU.
* Began working on the Timer Tributary's main thread.
* Implemented taskTribC::unblock().
* Implemented kernel class singleWaiterQueueC, a simple waitQueue.
* Added #defines for each prio class.
* Added the skeletal outline of the Timer Trib's event processing thread.
* Fixed up a debug message in memoryReservoirC.
* IBM-PC:
  * i8254:
    * Now holds an object cache for allocating IRQ event objects quickly.
    * Now queues IRQ events on its internal queue.

* ZKCM:
  * Timer Devices now have an internal IRQ event queue.

* Timer Tributary:
  * Event Dequeuer thread is now mostly defined.
  * Redefined the message types for the control queue after redesign.
* SingleWaiterQueueC: Added support for non-blocking pop().
* TimerTrib: The de-Qer thread now checks all queues without blocking,
  calling block() at the end if no messages were found.
* ZKCM:
  * Timer Device API: Moved the object cache into the base timerDevice API
    class, and the corresponding allocate/free methods.

* Timer Tributary:
  * Event de-queuer thread now dispatches the messages by calling
    timerQueueC::tick() (new method).
  * The event de-queuer thread now free()s the IRQ event objects to the
    driver object's cache when it's done processing them.

* Process/Thread:
  * Moved the "pending events" bitmap out of taskC and into processStreamC.
* Fixed a minor implementation oversight where new threads were being spawned
  with EFLAGS=0 in their initial pre-set task context. This obviously caused
  them to spawn with local interrupts disabled, and that is not desirable.
* Added a note doc file about my current take on the CPU Stream state machine.
* Removed the "postcall" functionality in the IPI handler. Postcall may
  be deprecated completely soon.
* Revamped the way CPU Messager works to a small degree -- now it can
  be set to reject all incoming messages, and its state machine is more
  up to date with the CPU Stream state machine.
* Fixed up some negligence within processStreamC's __kprocessAllocateBmps().
* BSP CPU Stream now enables local IRQs during the call to
  cpuTribC::initializeBspCpuStream().
* i8254:
  * ISR routine will free event objects if they couldn't be used.
  * disable()'s state machine will update such that re-enabling the IRQ
    works.

* SingleWaiterQueueC: Separated the constructor/initialize() methods from
  the function of setting a waiting thread. Now a separate function
  setWaitingThread() handles this.

* InterruptTrib: Silenced some IRQ context messages that filled up too much
  of the debug log.
* IBM-PC: i8254:
  * Implemented zkcmTimerDeviceC::disable().
  * Fixed state machine, and provided a uniform method of "disabling" the
    i8254 IRQ on all real hardware.
* Removed some superfluous headers from various files.
* Timer Tributary:
  * Spawn the dequeueing thread as DORMANT from now on, and explicitly wake
    it when done initializing it.
  * Implemented timerTribC::initializeAllQueues()
  * Implemented timerTribC::newTimerDeviceNotification().
  * Fleshed out timerTribC::enableQueue().
  * Rectified a nomenclature mistake where I was calling microseconds
    nanoseconds.

* i8254:
  * Renamed the ambit definition macros to better reflect what they define.
  * Updated the conversion logic to properly convert the nanosecond API
    into the internal microsecond granular chip's CLK pulses.
  * Updated documentation to match changes.

* IBM-PC Timer Control mod: Fixed bugs in the Timer Filter API's filters.
* panic(): Fixed the call sequence for CLI and HLT.
TimerTrib: No longer enable()s timer queues explicitly.
* Timer Trib:
  * Timer Queues:
    * Implemented enable(), disable(), initialize(), latch() and unlatch().
    * Fleshed out the basic functional form for "tick()".
  * Kernel Time types:
    * Added constructors to timestampS for easy initialization.

* SingleWaiterQueueC: Small changes toward eliminating lost wakeups.
* Replaced date_t with struct dateS, and updated the kernel source to match.
* RTC/CMOS: Will no longer repeatedly check FADT for offset. Caches it the
  first time instead.
* Re-structured Timer Tributary, grouping related data together.
* Rewrote timerTrib's processing thread.
* Separated logic sensibly.
* Removed excess, obsolete code.
* Fixed an annoying bug which occured because of stack trampling due to
  the way I had written saveContextAndCallPull().
  * There is still some bug which manifests only in Bochs and Sun Virtual
    Box, where the active thread stops being pulled. It doesn't occur
    on real hardware, and is most likely data-structure related.

* Implemented support code for the x86 debug register debugger features.
  Can now use read and write breakpoints, and code-execution breakpoints in
  the kernel.
  * Implemented exception handlers for x86-32 exceptions 1 and 3 (debug
    and breakpoint exceptions).
* Began basic support for Clang++ in the build system.
  * Also began adding support for Clang in the compiler libs.
  * Corrected one or two miscellaneous bugs that Clang detected.
* Fixed yet another bug in saveContextAndCallPull():
  * This one was about it not preserving the previous task's EAX
    register when saving context.
* Made modifications to prioQueueC to make it less race susceptible.

* Implemented a large chunk of the Timer subsystem.
  * Timer Stream:
    * Implemented createOneshotEvent().
    * Implemented createPeriodicEvent().
    * Implemented pullEvent().
    ^ These three together form the core of the kernel's timer events API.
  * Timer Queues:
    * The dequeueing thread now coherently handles tick events.
    * Supports a process setting a thread in a foreign process to be the
      wakeup target for a timeout event.

* Interrupt Trib:
  * Trimmed down some of the log messages that the IRQ path was generating.

* Task Stream:
  * No longer prints a message when the CPU enters C1.
* Added the rest of the queues to Timer Trib.
* Timer Trib now has a "latchedPeriodsMask" member to indicate which of the
  constituent queues is actually latched to a timer device.
* Dynamicized the Timer Trib's handling of Timer Queues.