Migrate RTL subsystem to C++

sdk/xtdk/hlfuncs.h

@@ -28,4 +28,37 @@ HlInitializeComPort(IN OUT PCPPORT Port,
                     IN PUCHAR PortAddress,
                     IN ULONG BaudRate);
 
+XTCLINK
+XTAPI
+UCHAR
+HlReadRegister8(IN PVOID Register);
+
+XTCLINK
+XTAPI
+USHORT
+HlReadRegister16(IN PVOID Register);
+
+XTCLINK
+XTAPI
+ULONG
+HlReadRegister32(IN PVOID Register);
+
+XTCLINK
+XTAPI
+VOID
+HlWriteRegister8(IN PVOID Register,
+                 IN UCHAR Value);
+
+XTCLINK
+XTAPI
+VOID
+HlWriteRegister16(IN PVOID Register,
+                  IN USHORT Value);
+
+XTCLINK
+XTAPI
+VOID
+HlWriteRegister32(IN PVOID Register,
+                  IN ULONG Value);
+
 #endif /* __XTDK_HLFUNCS_H */

sdk/xtdk/rtlfuncs.h

@@ -15,326 +15,363 @@
 #include <rtltypes.h>
 
 
-/* Routines used by XTLDR */
-XTCDECL
-VOID
-RtlInitializeListHead(IN PLIST_ENTRY ListHead);
-
-XTCDECL
-VOID
-RtlInsertHeadList(IN OUT PLIST_ENTRY ListHead,
-                  IN PLIST_ENTRY Entry);
-
-XTCDECL
-VOID
-RtlInsertTailList(IN OUT PLIST_ENTRY ListHead,
-                  IN PLIST_ENTRY Entry);
-
-XTAPI
-UCHAR
-RtlReadRegisterByte(IN VOLATILE PVOID Register);
-
-XTAPI
-ULONG
-RtlReadRegisterLong(IN VOLATILE PVOID Register);
-
-XTAPI
-USHORT
-RtlReadRegisterShort(IN VOLATILE PVOID Register);
-
-
-XTCDECL
-VOID
-RtlRemoveEntryList(IN PLIST_ENTRY Entry);
-
-
 /* Runtime Library routines forward references */
+XTCLINK
 XTAPI
 VOID
 RtlClearAllBits(IN PRTL_BITMAP BitMap);
 
+XTCLINK
 XTAPI
 VOID
 RtlClearBit(IN PRTL_BITMAP BitMap,
             IN ULONG_PTR Bit);
 
+XTCLINK
 XTAPI
 VOID
 RtlClearBits(IN PRTL_BITMAP BitMap,
              IN ULONG_PTR StartingIndex,
              IN ULONG_PTR Length);
 
+XTCLINK
 XTAPI
 ULONG
 RtlClearSetBits(IN PRTL_BITMAP BitMap,
                 IN ULONG_PTR Length,
                 IN ULONG_PTR Index);
 
+XTCLINK
 XTAPI
 BOOLEAN
 RtlCompareGuids(IN PGUID Guid1,
                 IN PGUID Guid2);
 
+XTCLINK
 XTAPI
 SIZE_T
 RtlCompareMemory(IN PCVOID LeftBuffer,
                  IN PCVOID RightBuffer,
                  IN SIZE_T Length);
 
+XTCLINK
 XTAPI
 SIZE_T
 RtlCompareString(IN PCSTR String1,
                  IN PCSTR String2,
                  IN SIZE_T Length);
 
+XTCLINK
 XTAPI
 SIZE_T
 RtlCompareStringInsensitive(IN PCSTR String1,
                             IN PCSTR String2,
                             IN SIZE_T Length);
 
+XTCLINK
 XTAPI
 SIZE_T
 RtlCompareWideString(IN PCWSTR String1,
                      IN PCWSTR String2,
                      IN SIZE_T Length);
 
+XTCLINK
 XTAPI
 SIZE_T
 RtlCompareWideStringInsensitive(IN PCWSTR String1,
                                 IN PCWSTR String2,
                                 IN SIZE_T Length);
 
+XTCLINK
 XTAPI
 PCHAR
 RtlConcatenateString(OUT PCHAR Destination,
                      IN PCHAR Source,
                      IN SIZE_T Count);
 
+XTCLINK
 XTAPI
 PWCHAR
 RtlConcatenateWideString(OUT PWCHAR Destination,
                          IN PWCHAR Source,
                          IN SIZE_T Count);
 
+XTCLINK
 XTAPI
 LARGE_INTEGER
 RtlConvertToLargeInteger32(IN LONG Value);
 
+XTCLINK
 XTAPI
 LARGE_INTEGER
 RtlConvertToLargeIntegerUnsigned32(IN ULONG Value);
 
+XTCLINK
 XTAPI
 VOID
 RtlCopyMemory(OUT PVOID Destination,
               IN PCVOID Source,
               IN SIZE_T Length);
 
+XTCLINK
 XTAPI
 VOID
 RtlCopyString(IN PCHAR Destination,
               IN PCSTR Source,
               IN ULONG Length);
 
+XTCLINK
 XTAPI
 VOID
 RtlCopyWideString(IN PWCHAR Destination,
                   IN PCWSTR Source,
                   IN ULONG Length);
 
+XTCLINK
 XTAPI
 LARGE_INTEGER
 RtlDivideLargeInteger(IN LARGE_INTEGER Dividend,
                       IN ULONG Divisor,
                       OUT PULONG Remainder);
 
+XTCLINK
 XTAPI
 ULONG_PTR
 RtlFindClearBits(IN PRTL_BITMAP BitMap,
                  IN ULONG_PTR Length,
                  IN ULONG_PTR Index);
 
+XTCLINK
 XTAPI
 ULONG_PTR
 RtlFindSetBits(IN PRTL_BITMAP BitMap,
                IN ULONG_PTR Length,
                IN ULONG_PTR Index);
 
+XTCLINK
 XTAPI
 PCSTR
 RtlFindString(IN PCSTR Source,
               IN PCSTR Search);
 
+XTCLINK
 XTAPI
 PCSTR
 RtlFindStringInsensitive(IN PCSTR Source,
                          IN PCSTR Search);
 
+XTCLINK
 XTAPI
 PCWSTR
 RtlFindWideString(IN PCWSTR Source,
                   IN PCWSTR Search);
 
+XTCLINK
 XTAPI
 PCWSTR
 RtlFindWideStringInsensitive(IN PCWSTR Source,
                              IN PCWSTR Search);
 
+XTCLINK
 XTAPI
 XTSTATUS
 RtlFormatWideString(IN PRTL_PRINT_CONTEXT Context,
                     IN PCWSTR Format,
                     IN VA_LIST ArgumentList);
 
+XTCLINK
 XTAPI
 VOID
 RtlInitializeBitMap(IN PRTL_BITMAP BitMap,
                     IN PULONG_PTR Buffer,
                     IN ULONG Size);
 
+XTCLINK
+XTCDECL
+VOID
+RtlInitializeListHead(IN PLIST_ENTRY ListHead);
+
+XTCLINK
+XTCDECL
+VOID
+RtlInsertHeadList(IN OUT PLIST_ENTRY ListHead,
+                  IN PLIST_ENTRY Entry);
+
+XTCLINK
+XTCDECL
+VOID
+RtlInsertTailList(IN OUT PLIST_ENTRY ListHead,
+                  IN PLIST_ENTRY Entry);
+
+XTCLINK
+XTCDECL
+BOOLEAN
+RtlListEmpty(IN PLIST_ENTRY ListHead);
+
+XTCLINK
+XTCDECL
+BOOLEAN
+RtlListLoop(IN PLIST_ENTRY ListHead);
+
+XTCLINK
 XTAPI
 VOID
 RtlMoveMemory(OUT PVOID Destination,
               IN PCVOID Source,
               IN SIZE_T Length);
 
+XTCLINK
 XTAPI
 LARGE_INTEGER
 RtlMultiplyLargeInteger(IN LARGE_INTEGER Multiplicand,
                         IN LONG Multiplier);
 
+XTCLINK
+XTCDECL
+VOID
+RtlRemoveEntryList(IN PLIST_ENTRY Entry);
+
+XTCLINK
 XTAPI
 VOID
 RtlReverseString(IN OUT PCHAR String,
                  IN ULONG Length);
 
+XTCLINK
 XTAPI
 VOID
 RtlReverseWideString(IN OUT PWCHAR String,
                      IN ULONG Length);
 
+XTCLINK
 XTAPI
 BOOLEAN
 RtlSameMemory(IN PCVOID LeftBuffer,
               IN PCVOID RightBuffer,
               IN SIZE_T Length);
 
+XTCLINK
 XTAPI
 VOID
 RtlSetAllBits(IN PRTL_BITMAP BitMap);
 
+XTCLINK
 XTAPI
 VOID
 RtlSetBit(IN PRTL_BITMAP BitMap,
           IN ULONG_PTR Bit);
 
+XTCLINK
 XTAPI
 VOID
 RtlSetBits(IN PRTL_BITMAP BitMap,
            IN ULONG_PTR StartingIndex,
            IN ULONG_PTR Length);
 
+XTCLINK
 XTAPI
 ULONG
 RtlSetClearBits(IN PRTL_BITMAP BitMap,
                 IN ULONG_PTR Length,
                 IN ULONG_PTR Index);
 
+XTCLINK
 XTAPI
 VOID
 RtlSetMemory(OUT PVOID Destination,
              IN UCHAR Byte,
              IN SIZE_T Length);
 
+XTCLINK
 XTAPI
 SIZE_T
 RtlStringLength(IN PCSTR String,
                 IN SIZE_T MaxLength);
 
+XTCLINK
 XTAPI
 SIZE_T
 RtlStringToWideString(OUT PWCHAR Destination,
                       IN PCSTR *Source,
                       IN SIZE_T Length);
 
+XTCLINK
 XTAPI
 BOOLEAN
 RtlTestBit(IN PRTL_BITMAP BitMap,
            IN ULONG_PTR Bit);
 
+XTCLINK
 XTAPI
 PCHAR
 RtlTokenizeString(IN PCHAR String,
                   IN PCSTR Delimiter,
                   IN OUT PCHAR *SavePtr);
 
+XTCLINK
 XTAPI
 PWCHAR
 RtlTokenizeWideString(IN PWCHAR String,
                       IN PCWSTR Delimiter,
                       IN OUT PWCHAR *SavePtr);
 
+XTCLINK
 XTAPI
 CHAR
 RtlToLowerCharacter(IN CHAR Character);
 
+XTCLINK
 XTAPI
 WCHAR
 RtlToLowerWideCharacter(IN WCHAR Character);
 
+XTCLINK
 XTAPI
 CHAR
 RtlToUpperCharacter(IN CHAR Character);
 
+XTCLINK
 XTAPI
 WCHAR
 RtlToUpperWideCharacter(IN WCHAR Character);
 
+XTCLINK
 XTAPI
 PCHAR
 RtlTrimLeftString(IN PCHAR String);
 
+XTCLINK
 XTAPI
 PWCHAR
 RtlTrimLeftWideString(IN PWCHAR String);
 
+XTCLINK
 XTAPI
 PCHAR
 RtlTrimRightString(IN PCHAR String);
 
+XTCLINK
 XTAPI
 PWCHAR
 RtlTrimRightWideString(IN PWCHAR String);
 
+XTCLINK
 XTAPI
 PCHAR
 RtlTrimString(IN PCHAR String);
 
+XTCLINK
 XTAPI
 PWCHAR
 RtlTrimWideString(IN PWCHAR String);
 
+XTCLINK
 XTAPI
 SIZE_T
 RtlWideStringLength(IN PCWSTR String,
                     IN SIZE_T MaxLength);
 
-XTAPI
+XTCLINK
-VOID
-RtlWriteRegisterByte(IN VOLATILE PVOID Register,
-                     IN UCHAR Value);
-
-XTAPI
-VOID
-RtlWriteRegisterLong(IN VOLATILE PVOID Register,
-                     IN ULONG Value);
-
-XTAPI
-VOID
-RtlWriteRegisterShort(IN VOLATILE PVOID Register,
-                      IN USHORT Value);
-
 XTAPI
 VOID
 RtlZeroMemory(OUT PVOID Destination,

sdk/xtdk/rtltypes.h

@@ -56,17 +56,17 @@ typedef XTSTATUS (*PWRITE_WIDE_CHARACTER)(IN WCHAR Character);
 /* Variable types enumeration list */
 typedef enum _RTL_VARIABLE_TYPE
 {
-    Unknown,
+    TypeUnknown,
-    AnsiString,
+    TypeAnsiString,
-    Boolean,
+    TypeBoolean,
-    Char,
+    TypeChar,
-    Float,
+    TypeFloat,
-    Guid,
+    TypeGuid,
-    Integer,
+    TypeInteger,
-    String,
+    TypeString,
-    UnicodeString,
+    TypeUnicodeString,
-    WideChar,
+    TypeWideChar,
-    WideString
+    TypeWideString
 } RTL_VARIABLE_TYPE, *PRTL_VARIABLE_TYPE;
 
 /* Bit Map structure definition */

xtoskrnl/CMakeLists.txt

@@ -33,9 +33,11 @@ list(APPEND XTOSKRNL_SOURCE
     ${XTOSKRNL_SOURCE_DIR}/ex/rundown.cc
     ${XTOSKRNL_SOURCE_DIR}/hl/acpi.c
     ${XTOSKRNL_SOURCE_DIR}/hl/cport.c
+    ${XTOSKRNL_SOURCE_DIR}/hl/exports.cc
     ${XTOSKRNL_SOURCE_DIR}/hl/fbdev.c
     ${XTOSKRNL_SOURCE_DIR}/hl/globals.c
     ${XTOSKRNL_SOURCE_DIR}/hl/init.c
+    ${XTOSKRNL_SOURCE_DIR}/hl/ioreg.cc
     ${XTOSKRNL_SOURCE_DIR}/hl/${ARCH}/cpu.c
     ${XTOSKRNL_SOURCE_DIR}/hl/${ARCH}/pic.c
     ${XTOSKRNL_SOURCE_DIR}/hl/${ARCH}/ioport.c
@@ -73,19 +75,19 @@ list(APPEND XTOSKRNL_SOURCE
     ${XTOSKRNL_SOURCE_DIR}/mm/${ARCH}/pages.c
     ${XTOSKRNL_SOURCE_DIR}/mm/${ARCH}/pmap.c
     ${XTOSKRNL_SOURCE_DIR}/po/idle.c
-    ${XTOSKRNL_SOURCE_DIR}/rtl/atomic.c
+    ${XTOSKRNL_SOURCE_DIR}/rtl/${ARCH}/dispatch.cc
-    ${XTOSKRNL_SOURCE_DIR}/rtl/bitmap.c
+    ${XTOSKRNL_SOURCE_DIR}/rtl/${ARCH}/exsup.cc
-    ${XTOSKRNL_SOURCE_DIR}/rtl/byteswap.c
+    ${XTOSKRNL_SOURCE_DIR}/rtl/atomic.cc
-    ${XTOSKRNL_SOURCE_DIR}/rtl/globals.c
+    ${XTOSKRNL_SOURCE_DIR}/rtl/bitmap.cc
-    ${XTOSKRNL_SOURCE_DIR}/rtl/guid.c
+    ${XTOSKRNL_SOURCE_DIR}/rtl/data.cc
-    ${XTOSKRNL_SOURCE_DIR}/rtl/ioreg.c
+    ${XTOSKRNL_SOURCE_DIR}/rtl/endian.cc
-    ${XTOSKRNL_SOURCE_DIR}/rtl/math.c
+    ${XTOSKRNL_SOURCE_DIR}/rtl/exports.cc
-    ${XTOSKRNL_SOURCE_DIR}/rtl/memory.c
+    ${XTOSKRNL_SOURCE_DIR}/rtl/guid.cc
-    ${XTOSKRNL_SOURCE_DIR}/rtl/plist.c
+    ${XTOSKRNL_SOURCE_DIR}/rtl/llist.cc
-    ${XTOSKRNL_SOURCE_DIR}/rtl/string.c
+    ${XTOSKRNL_SOURCE_DIR}/rtl/math.cc
-    ${XTOSKRNL_SOURCE_DIR}/rtl/widestr.c
+    ${XTOSKRNL_SOURCE_DIR}/rtl/memory.cc
-    ${XTOSKRNL_SOURCE_DIR}/rtl/${ARCH}/dispatch.c
+    ${XTOSKRNL_SOURCE_DIR}/rtl/string.cc
-    ${XTOSKRNL_SOURCE_DIR}/rtl/${ARCH}/exsup.c)
+    ${XTOSKRNL_SOURCE_DIR}/rtl/widestr.cc)
 
 # Set module definition SPEC file
 set_specfile(xtoskrnl.spec xtoskrnl.exe)

xtoskrnl/hl/exports.cc

@@ -0,0 +1,130 @@
+/**
+ * PROJECT:         ExectOS
+ * COPYRIGHT:       See COPYING.md in the top level directory
+ * FILE:            xtoskrnl/hl/exports.cc
+ * DESCRIPTION:     C-compatible API wrappers for exported kernel functions
+ * DEVELOPERS:      Aiken Harris <harraiken91@gmail.com>
+ */
+
+#include <xtos.hh>
+
+
+/**
+ * Reads an 8-bit data from a specified register address.
+ *
+ * @param Register
+ *        Supplies a pointer to register address holding data to read.
+ *
+ * @return This routine returns a value at the specified register.
+ *
+ * @since XT 1.0
+ */
+XTCLINK
+XTAPI
+UCHAR
+HlReadRegister8(IN PVOID Register)
+{
+    return HL::IoRegister::ReadRegister8(Register);
+}
+
+/**
+ * Reads a 16-bit data from a specified register address.
+ *
+ * @param Register
+ *        Supplies a pointer to register address holding data to read.
+ *
+ * @return This routine returns a value at the specified register.
+ *
+ * @since XT 1.0
+ */
+XTCLINK
+XTAPI
+USHORT
+HlReadRegister16(IN PVOID Register)
+{
+    return HL::IoRegister::ReadRegister16(Register);
+}
+
+/**
+ * Reads a 32-bit data from a specified register address.
+ *
+ * @param Register
+ *        Supplies a pointer to register address holding data to read.
+ *
+ * @return This routine returns a value at the specified register.
+ *
+ * @since XT 1.0
+ */
+XTCLINK
+XTAPI
+ULONG
+HlReadRegister32(IN PVOID Register)
+{
+    return HL::IoRegister::ReadRegister32(Register);
+}
+
+/**
+ * Writes an 8-bit value into a specified register address.
+ *
+ * @param Register
+ *        Supplies a pointer to register address where data will be written.
+ *
+ * @param Value
+ *        Supplies a new value that will be stored into a register.
+ *
+ * @return This routine does not return any value.
+ *
+ * @since XT 1.0
+ */
+XTCLINK
+XTAPI
+VOID
+HlWriteRegister8(IN PVOID Register,
+                 IN UCHAR Value)
+{
+    HL::IoRegister::WriteRegister8(Register, Value);
+}
+
+/**
+ * Writes a 16-bit value into a specified register address.
+ *
+ * @param Register
+ *        Supplies a pointer to register address where data will be written.
+ *
+ * @param Value
+ *        Supplies a new value that will be stored into a register.
+ *
+ * @return This routine does not return any value.
+ *
+ * @since XT 1.0
+ */
+XTCLINK
+XTAPI
+VOID
+HlWriteRegister16(IN PVOID Register,
+                  IN USHORT Value)
+{
+    HL::IoRegister::WriteRegister16(Register, Value);
+}
+
+/**
+ * Writes a 32-bit value into a specified register address.
+ *
+ * @param Register
+ *        Supplies a pointer to register address where data will be written.
+ *
+ * @param Value
+ *        Supplies a new value that will be stored into a register.
+ *
+ * @return This routine does not return any value.
+ *
+ * @since XT 1.0
+ */
+XTCLINK
+XTAPI
+VOID
+HlWriteRegister32(IN PVOID Register,
+                  IN ULONG Value)
+{
+    HL::IoRegister::WriteRegister32(Register, Value);
+}

xtoskrnl/hl/ioreg.cc

@@ -1,73 +1,73 @@
 /**
  * PROJECT:         ExectOS
  * COPYRIGHT:       See COPYING.md in the top level directory
- * FILE:            xtoskrnl/rtl/ioreg.c
+ * FILE:            xtoskrnl/hl/ioreg.cc
- * DESCRIPTION:     I/O registers related routines
+ * DESCRIPTION:     Basic I/O registers access functionality
  * DEVELOPERS:      Rafal Kupiec <belliash@codingworkshop.eu.org>
  */
 
-#include <xtos.h>
+#include <xtos.hh>
 
 
 /**
- * Reads a byte from a specified register address.
+ * Reads an 8-bit data from a specified register address.
  *
  * @param Register
  *        Supplies a pointer to register address holding data to read.
  *
- * @return This routine returns UCHAR byte read from the register.
+ * @return This routine returns a value at the specified register.
  *
  * @since XT 1.0
  */
 XTAPI
 UCHAR
-RtlReadRegisterByte(IN VOLATILE PVOID Register)
+HL::IoRegister::ReadRegister8(IN PVOID Register)
 {
     return *((VOLATILE PUCHAR)Register);
 }
 
 /**
- * Reads a byte from a specified register address.
+ * Reads a 16-bit data from a specified register address.
  *
  * @param Register
  *        Supplies a pointer to register address holding data to read.
  *
- * @return This routine returns ULONG byte read from the register.
+ * @return This routine returns a value at the specified register.
- *
- * @since XT 1.0
- */
-XTAPI
-ULONG
-RtlReadRegisterLong(IN VOLATILE PVOID Register)
-{
-    return *((VOLATILE PULONG)Register);
-}
-
-/**
- * Reads a byte from a specified register address.
- *
- * @param Register
- *        Supplies a pointer to register address holding data to read.
- *
- * @return This routine returns USHORT byte read from the register.
  *
  * @since XT 1.0
  */
 XTAPI
 USHORT
-RtlReadRegisterShort(IN VOLATILE PVOID Register)
+HL::IoRegister::ReadRegister16(IN PVOID Register)
 {
     return *((VOLATILE PUSHORT)Register);
 }
 
 /**
- * Writes a byte into a specified register address.
+ * Reads a 32-bit data from a specified register address.
+ *
+ * @param Register
+ *        Supplies a pointer to register address holding data to read.
+ *
+ * @return This routine returns a value at the specified register.
+ *
+ * @since XT 1.0
+ */
+XTAPI
+ULONG
+HL::IoRegister::ReadRegister32(IN PVOID Register)
+{
+    return *((VOLATILE PULONG)Register);
+}
+
+/**
+ * Writes an 8-bit value into a specified register address.
  *
  * @param Register
  *        Supplies a pointer to register address where data will be written.
  *
  * @param Value
- *        Supplies a new UCHAR value that will be stored into a register.
+ *        Supplies a new value that will be stored into a register.
  *
  * @return This routine does not return any value.
  *
@@ -75,20 +75,20 @@ RtlReadRegisterShort(IN VOLATILE PVOID Register)
  */
 XTAPI
 VOID
-RtlWriteRegisterByte(IN VOLATILE PVOID Register,
+HL::IoRegister::WriteRegister8(IN PVOID Register,
-                     IN UCHAR Value)
+                               IN UCHAR Value)
 {
     *((VOLATILE PUCHAR)Register) = Value;
 }
 
 /**
- * Writes a byte into a specified register address.
+ * Writes a 16-bit value into a specified register address.
  *
  * @param Register
  *        Supplies a pointer to register address where data will be written.
  *
  * @param Value
- *        Supplies a new ULONG value that will be stored into a register.
+ *        Supplies a new value that will be stored into a register.
  *
  * @return This routine does not return any value.
  *
@@ -96,29 +96,29 @@ RtlWriteRegisterByte(IN VOLATILE PVOID Register,
  */
 XTAPI
 VOID
-RtlWriteRegisterLong(IN VOLATILE PVOID Register,
+HL::IoRegister::WriteRegister16(IN PVOID Register,
-                     IN ULONG Value)
+                                IN USHORT Value)
-{
-    *((VOLATILE PULONG)Register) = Value;
-}
-
-/**
- * Writes a byte into a specified register address.
- *
- * @param Register
- *        Supplies a pointer to register address where data will be written.
- *
- * @param Value
- *        Supplies a new USHORT value that will be stored into a register.
- *
- * @return This routine does not return any value.
- *
- * @since XT 1.0
- */
-XTAPI
-VOID
-RtlWriteRegisterShort(IN VOLATILE PVOID Register,
-                      IN USHORT Value)
 {
     *((VOLATILE PUSHORT)Register) = Value;
 }
+
+/**
+ * Writes a 32-bit value into a specified register address.
+ *
+ * @param Register
+ *        Supplies a pointer to register address where data will be written.
+ *
+ * @param Value
+ *        Supplies a new value that will be stored into a register.
+ *
+ * @return This routine does not return any value.
+ *
+ * @since XT 1.0
+ */
+XTAPI
+VOID
+HL::IoRegister::WriteRegister32(IN PVOID Register,
+                                IN ULONG Value)
+{
+    *((VOLATILE PULONG)Register) = Value;
+}

xtoskrnl/includes/ar.hh

@@ -2,7 +2,7 @@
  * PROJECT:         ExectOS
  * COPYRIGHT:       See COPYING.md in the top level directory
  * FILE:            xtoskrnl/includes/ar.hh
- * DESCRIPTION:     
+ * DESCRIPTION:     Architecture Library
  * DEVELOPERS:      Aiken Harris <harraiken91@gmail.com>
  */
 

xtoskrnl/includes/ex.hh

@@ -2,7 +2,7 @@
  * PROJECT:         ExectOS
  * COPYRIGHT:       See COPYING.md in the top level directory
  * FILE:            xtoskrnl/includes/ex.hh
- * DESCRIPTION:     
+ * DESCRIPTION:     Kernel Executive
  * DEVELOPERS:      Aiken Harris <harraiken91@gmail.com>
  */
 

xtoskrnl/includes/rtl.hh

@@ -0,0 +1,25 @@
+/**
+ * PROJECT:         ExectOS
+ * COPYRIGHT:       See COPYING.md in the top level directory
+ * FILE:            xtoskrnl/includes/rtl.hh
+ * DESCRIPTION:     Runtime Library
+ * DEVELOPERS:      Aiken Harris <harraiken91@gmail.com>
+ */
+
+#ifndef __XTOSKRNL_RTL_HH
+#define __XTOSKRNL_RTL_HH
+
+#include <xtos.hh>
+
+#include <rtl/atomic.hh>
+#include <rtl/bitmap.hh>
+#include <rtl/dispatch.hh>
+#include <rtl/endian.hh>
+#include <rtl/guid.hh>
+#include <rtl/llist.hh>
+#include <rtl/math.hh>
+#include <rtl/memory.hh>
+#include <rtl/string.hh>
+#include <rtl/widestr.hh>
+
+#endif /* __XTOSKRNL_RTL_HH */

xtoskrnl/includes/rtl/atomic.hh

@@ -0,0 +1,97 @@
+/**
+ * PROJECT:         ExectOS
+ * COPYRIGHT:       See COPYING.md in the top level directory
+ * FILE:            xtoskrnl/includes/rtl/atomic.hh
+ * DESCRIPTION:     Atomic operations support
+ * DEVELOPERS:      Aiken Harris <harraiken91@gmail.com>
+ */
+
+#ifndef __XTOSKRNL_RTL_ATOMIC_HH
+#define __XTOSKRNL_RTL_ATOMIC_HH
+
+#include <xtos.hh>
+
+
+/* Runtime Library */
+namespace RTL
+{
+    class Atomic
+    {
+        public:
+            STATIC XTFASTCALL CHAR And8(IN PCHAR Address,
+                                        IN CHAR Mask);
+            STATIC XTFASTCALL SHORT And16(IN PSHORT Address,
+                                          IN SHORT Mask);
+            STATIC XTFASTCALL LONG And32(IN PLONG Address,
+                                         IN LONG Mask);
+            STATIC XTFASTCALL LONG_PTR And64(IN PLONG_PTR Address,
+                                             IN LONG_PTR Mask);
+            STATIC XTFASTCALL UCHAR BitTestAndSet(IN PLONG Base,
+                                                  IN LONG Offset);
+            STATIC XTFASTCALL UCHAR BitTestAndSet64(IN PLONGLONG Base,
+                                                    IN LONGLONG Offset);
+            STATIC XTFASTCALL CHAR CompareExchange8(IN PCHAR Address,
+                                                 IN CHAR Comperand,
+                                                 IN CHAR Exchange);
+            STATIC XTFASTCALL SHORT CompareExchange16(IN PSHORT Address,
+                                                   IN SHORT Comperand,
+                                                   IN SHORT Exchange);
+            STATIC XTFASTCALL LONG CompareExchange32(IN PLONG Address,
+                                                  IN LONG Comperand,
+                                                  IN LONG Exchange);
+            STATIC XTFASTCALL LONG_PTR CompareExchange64(IN PLONG_PTR Address,
+                                                      IN LONG_PTR Comperand,
+                                                      IN LONG_PTR Exchange);
+            STATIC XTFASTCALL PVOID CompareExchangePointer(IN PVOID *Address,
+                                                        IN PVOID Comperand,
+                                                        IN PVOID Exchange);
+            STATIC XTFASTCALL CHAR Decrement8(IN PCHAR Address);
+            STATIC XTFASTCALL SHORT Decrement16(IN PSHORT Address);
+            STATIC XTFASTCALL LONG Decrement32(IN PLONG Address);
+            STATIC XTFASTCALL LONG_PTR Decrement64(IN PLONG_PTR Address);
+            STATIC XTFASTCALL CHAR Exchange8(IN PCHAR Address,
+                                             IN CHAR Exchange);
+            STATIC XTFASTCALL SHORT Exchange16(IN PSHORT Address,
+                                               IN SHORT Exchange);
+            STATIC XTFASTCALL LONG Exchange32(IN PLONG Address,
+                                              IN LONG Exchange);
+            STATIC XTFASTCALL LONG_PTR Exchange64(IN PLONG_PTR Address,
+                                                  IN LONG_PTR Exchange);
+            STATIC XTFASTCALL CHAR ExchangeAdd8(IN PCHAR Address,
+                                                IN CHAR Value);
+            STATIC XTFASTCALL SHORT ExchangeAdd16(IN PSHORT Address,
+                                                  IN SHORT Value);
+            STATIC XTFASTCALL LONG ExchangeAdd32(IN PLONG Address,
+                                                 IN LONG Value);
+            STATIC XTFASTCALL LONG_PTR ExchangeAdd64(IN PLONG_PTR Address,
+                                                     IN LONG_PTR Value);
+            STATIC XTFASTCALL PVOID ExchangePointer(IN PVOID *Address,
+                                                    IN PVOID Exchange);
+            STATIC XTFASTCALL PSINGLE_LIST_ENTRY FlushSingleList(IN PSINGLE_LIST_HEADER Header);
+            STATIC XTFASTCALL CHAR Increment8(IN PCHAR Address);
+            STATIC XTFASTCALL SHORT Increment16(IN PSHORT Address);
+            STATIC XTFASTCALL LONG Increment32(IN PLONG Address);
+            STATIC XTFASTCALL LONG_PTR Increment64(IN PLONG_PTR Address);
+            STATIC XTFASTCALL CHAR Or8(IN PCHAR Address,
+                                       IN CHAR Mask);
+            STATIC XTFASTCALL SHORT Or16(IN PSHORT Address,
+                                         IN SHORT Mask);
+            STATIC XTFASTCALL LONG Or32(IN PLONG Address,
+                                        IN LONG Mask);
+            STATIC XTFASTCALL LONG_PTR Or64(IN PLONG_PTR Address,
+                                            IN LONG_PTR Mask);
+            STATIC XTFASTCALL XTFASTCALL PSINGLE_LIST_ENTRY PopEntrySingleList(IN PSINGLE_LIST_HEADER Header);
+            STATIC XTFASTCALL PSINGLE_LIST_ENTRY PushEntrySingleList(IN PSINGLE_LIST_HEADER Header,
+                                                                     IN PSINGLE_LIST_ENTRY Entry);
+            STATIC XTFASTCALL CHAR Xor8(IN PCHAR Address,
+                                        IN CHAR Mask);
+            STATIC XTFASTCALL SHORT Xor16(IN PSHORT Address,
+                                          IN SHORT Mask);
+            STATIC XTFASTCALL LONG Xor32(IN PLONG Address,
+                                         IN LONG Mask);
+            STATIC XTFASTCALL LONG_PTR Xor64(IN PLONG_PTR Address,
+                                             IN LONG_PTR Mask);
+    };
+}
+
+#endif /* __XTOSKRNL_RTL_ATOMIC_HH */

xtoskrnl/includes/rtl/bitmap.hh

@@ -0,0 +1,64 @@
+/**
+ * PROJECT:         ExectOS
+ * COPYRIGHT:       See COPYING.md in the top level directory
+ * FILE:            xtoskrnl/includes/rtl/bitmap.hh
+ * DESCRIPTION:     Bit maps support
+ * DEVELOPERS:      Aiken Harris <harraiken91@gmail.com>
+ */
+
+#ifndef __XTOSKRNL_RTL_BITMAP_HH
+#define __XTOSKRNL_RTL_BITMAP_HH
+
+#include <xtos.hh>
+
+
+/* Runtime Library */
+namespace RTL
+{
+    class BitMap
+    {
+        public:
+            STATIC XTAPI VOID ClearAllBits(IN PRTL_BITMAP BitMap);
+            STATIC XTAPI VOID ClearBit(IN PRTL_BITMAP BitMap,
+                                       IN ULONG_PTR Bit);
+            STATIC XTAPI VOID ClearBits(IN PRTL_BITMAP BitMap,
+                                        IN ULONG_PTR StartingIndex,
+                                        IN ULONG_PTR Length);
+            STATIC XTAPI ULONG ClearSetBits(IN PRTL_BITMAP BitMap,
+                                            IN ULONG_PTR Length,
+                                            IN ULONG_PTR Index);
+            STATIC XTAPI VOID DumpBitMap(IN PRTL_BITMAP BitMap);
+            STATIC XTAPI ULONG_PTR FindClearBits(IN PRTL_BITMAP BitMap,
+                                                 IN ULONG_PTR Length,
+                                                 IN ULONG_PTR Index);
+            STATIC XTAPI ULONG_PTR FindSetBits(IN PRTL_BITMAP BitMap,
+                                               IN ULONG_PTR Length,
+                                               IN ULONG_PTR Index);
+            STATIC XTAPI VOID InitializeBitMap(IN PRTL_BITMAP BitMap,
+                                               IN PULONG_PTR Buffer,
+                                               IN ULONG Size);
+            STATIC XTAPI VOID SetAllBits(IN PRTL_BITMAP BitMap);
+            STATIC XTAPI VOID SetBit(IN PRTL_BITMAP BitMap,
+                                     IN ULONG_PTR Bit);
+            STATIC XTAPI VOID SetBits(IN PRTL_BITMAP BitMap,
+                                      IN ULONG_PTR StartingIndex,
+                                      IN ULONG_PTR Length);
+            STATIC XTAPI ULONG SetClearBits(IN PRTL_BITMAP BitMap,
+                                            IN ULONG_PTR Length,
+                                            IN ULONG_PTR Index);
+            STATIC XTAPI BOOLEAN TestBit(IN PRTL_BITMAP BitMap,
+                                         IN ULONG_PTR Bit);
+
+        private:
+            STATIC XTAPI ULONG_PTR CountBits(IN PRTL_BITMAP BitMap,
+                                             IN ULONG_PTR Length,
+                                             IN ULONG_PTR StartingIndex,
+                                             IN BOOLEAN SetBits);
+            STATIC XTAPI ULONG_PTR FindBits(IN PRTL_BITMAP BitMap,
+                                            IN ULONG_PTR Length,
+                                            IN ULONG_PTR StartingIndex,
+                                            IN BOOLEAN SetBits);
+    };
+}
+
+#endif /* __XTOSKRNL_RTL_BITMAP_HH */

xtoskrnl/includes/rtl/dispatch.hh

@@ -0,0 +1,26 @@
+/**
+ * PROJECT:         ExectOS
+ * COPYRIGHT:       See COPYING.md in the top level directory
+ * FILE:            xtoskrnl/includes/rtl/dispatch.hh
+ * DESCRIPTION:     Dispatching support
+ * DEVELOPERS:      Aiken Harris <harraiken91@gmail.com>
+ */
+
+#ifndef __XTOSKRNL_RTL_DISPATCH_HH
+#define __XTOSKRNL_RTL_DISPATCH_HH
+
+#include <xtos.hh>
+
+
+/* Runtime Library */
+namespace RTL
+{
+    class Dispatcher
+    {
+        public:
+            STATIC XTAPI VOID GetStackLimits(OUT PULONG_PTR StackBase,
+                                             OUT PULONG_PTR StackLimit);
+    };
+}
+
+#endif /* __XTOSKRNL_RTL_DISPATCH_HH */

xtoskrnl/includes/rtl/endian.hh

@@ -0,0 +1,27 @@
+/**
+ * PROJECT:         ExectOS
+ * COPYRIGHT:       See COPYING.md in the top level directory
+ * FILE:            xtoskrnl/includes/rtl/endian.hh
+ * DESCRIPTION:     Endian conversion routines
+ * DEVELOPERS:      Aiken Harris <harraiken91@gmail.com>
+ */
+
+#ifndef __XTOSKRNL_RTL_ENDIAN_HH
+#define __XTOSKRNL_RTL_ENDIAN_HH
+
+#include <xtos.hh>
+
+
+/* Runtime Library */
+namespace RTL
+{
+    class Endianness
+    {
+        public:
+            STATIC XTAPI USHORT SwapByte16(IN USHORT Source);
+            STATIC XTAPI ULONG SwapByte32(IN ULONG Source);
+            STATIC XTAPI ULONGLONG SwapByte64(IN ULONGLONG Source);
+    };
+}
+
+#endif /* __XTOSKRNL_RTL_ENDIAN_HH */

xtoskrnl/includes/rtl/guid.hh

@@ -0,0 +1,26 @@
+/**
+ * PROJECT:         ExectOS
+ * COPYRIGHT:       See COPYING.md in the top level directory
+ * FILE:            xtoskrnl/includes/rtl/gui.hh
+ * DESCRIPTION:     Endian conversion routines
+ * DEVELOPERS:      Aiken Harris <harraiken91@gmail.com>
+ */
+
+#ifndef __XTOSKRNL_RTL_GUID_HH
+#define __XTOSKRNL_RTL_GUID_HH
+
+#include <xtos.hh>
+
+
+/* Runtime Library */
+namespace RTL
+{
+    class Guid
+    {
+        public:
+            STATIC XTAPI BOOLEAN CompareGuids(IN PGUID Guid1,
+                                              IN PGUID Guid2);
+    };
+}
+
+#endif /* __XTOSKRNL_RTL_GUID_HH */

xtoskrnl/includes/rtl/llist.hh

@@ -0,0 +1,33 @@
+/**
+ * PROJECT:         ExectOS
+ * COPYRIGHT:       See COPYING.md in the top level directory
+ * FILE:            xtoskrnl/includes/rtl/llist.hh
+ * DESCRIPTION:     Linked list manipulation routines
+ * DEVELOPERS:      Aiken Harris <harraiken91@gmail.com>
+ */
+
+#ifndef __XTOSKRNL_RTL_LLIST_HH
+#define __XTOSKRNL_RTL_LLIST_HH
+
+#include <xtos.hh>
+
+
+/* Runtime Library */
+namespace RTL
+{
+    class LinkedList
+    {
+        public:
+            STATIC XTCDECL VOID InitializeListHead(IN PLIST_ENTRY ListHead);
+            STATIC XTCDECL VOID InitializeListHead32(IN PLIST_ENTRY32 ListHead);
+            STATIC XTCDECL VOID InsertHeadList(IN OUT PLIST_ENTRY ListHead,
+                                               IN PLIST_ENTRY Entry);
+            STATIC XTCDECL VOID InsertTailList(IN OUT PLIST_ENTRY ListHead,
+                                               IN PLIST_ENTRY Entry);
+            STATIC XTCDECL BOOLEAN ListEmpty(IN PLIST_ENTRY ListHead);
+            STATIC XTCDECL BOOLEAN ListLoop(IN PLIST_ENTRY ListHead);
+            STATIC XTCDECL VOID RemoveEntryList(IN PLIST_ENTRY Entry);
+    };
+}
+
+#endif /* __XTOSKRNL_RTL_LLIST_HH */

xtoskrnl/includes/rtl/math.hh

@@ -0,0 +1,51 @@
+/**
+ * PROJECT:         ExectOS
+ * COPYRIGHT:       See COPYING.md in the top level directory
+ * FILE:            xtoskrnl/includes/rtl/math.hh
+ * DESCRIPTION:     Kernel math support
+ * DEVELOPERS:      Aiken Harris <harraiken91@gmail.com>
+ */
+
+#ifndef __XTOSKRNL_RTL_MATH_HH
+#define __XTOSKRNL_RTL_MATH_HH
+
+#include <xtos.hh>
+
+
+/* Runtime Library */
+namespace RTL
+{
+    class Math
+    {
+        public:
+            STATIC XTAPI LARGE_INTEGER ConvertToLargeInteger32(IN LONG Value);
+            STATIC XTAPI LARGE_INTEGER ConvertToLargeIntegerUnsigned32(IN ULONG Value);
+            STATIC XTAPI INT CountLeadingZeroes32(IN ULONG Value);
+            STATIC XTAPI INT CountLeadingZeroes64(IN ULONGLONG Value);
+            STATIC XTAPI INT CountTrailingZeroes32(IN ULONG Value);
+            STATIC XTAPI INT CountTrailingZeroes64(IN ULONGLONG Value);
+            STATIC XTAPI LONGLONG Divide32(IN LONG Dividend,
+                                           IN LONG Divisor,
+                                           OUT PLONG Remainder);
+            STATIC XTAPI LONGLONG Divide64(IN LONGLONG Dividend,
+                                           IN LONGLONG Divisor,
+                                           OUT PLONGLONG Remainder);
+            STATIC XTAPI ULONGLONG DivideUnsigned32(IN ULONG Dividend,
+                                                    IN ULONG Divisor,
+                                                    OUT PULONG Remainder);
+            STATIC XTAPI ULONGLONG DivideUnsigned64(IN ULONGLONG Dividend,
+                                                    IN ULONGLONG Divisor,
+                                                    OUT PULONGLONG Remainder);
+            STATIC XTAPI LARGE_INTEGER DivideLargeInteger(IN LARGE_INTEGER Dividend,
+                                                          IN ULONG Divisor,
+                                                          OUT PULONG Remainder);
+            STATIC XTAPI LONG GetBaseExponent(IN DOUBLE Value,
+                                               OUT PDOUBLE PowerOfTen);
+            STATIC XTAPI BOOLEAN InfiniteDouble(IN DOUBLE Value);
+            STATIC XTAPI LARGE_INTEGER MultiplyLargeInteger(IN LARGE_INTEGER Multiplicand,
+                                                            IN LONG Multiplier);
+            STATIC XTAPI BOOLEAN NanDouble(IN DOUBLE Value);
+    };
+}
+
+#endif /* __XTOSKRNL_RTL_MATH_HH */

xtoskrnl/includes/rtl/memory.hh

@@ -0,0 +1,41 @@
+/**
+ * PROJECT:         ExectOS
+ * COPYRIGHT:       See COPYING.md in the top level directory
+ * FILE:            xtoskrnl/includes/rtl/memory.hh
+ * DESCRIPTION:     Memory related routines
+ * DEVELOPERS:      Aiken Harris <harraiken91@gmail.com>
+ */
+
+#ifndef __XTOSKRNL_RTL_MEMORY_HH
+#define __XTOSKRNL_RTL_MEMORY_HH
+
+#include <xtos.hh>
+
+
+/* Runtime Library */
+namespace RTL
+{
+    class Memory
+    {
+        public:
+            STATIC XTAPI SIZE_T CompareMemory(IN PCVOID LeftBuffer,
+                                              IN PCVOID RightBuffer,
+                                              IN SIZE_T Length);
+            STATIC XTAPI VOID CopyMemory(OUT PVOID Destination,
+                                         IN PCVOID Source,
+                                         IN SIZE_T Length);
+            STATIC XTAPI VOID MoveMemory(OUT PVOID Destination,
+                                         IN PCVOID Source,
+                                         IN SIZE_T Length);
+            STATIC XTAPI BOOLEAN SameMemory(IN PCVOID LeftBuffer,
+                                            IN PCVOID RightBuffer,
+                                            IN SIZE_T Length);
+            STATIC XTAPI VOID SetMemory(OUT PVOID Destination,
+                                        IN UCHAR Byte,
+                                        IN SIZE_T Length);
+            STATIC XTAPI VOID ZeroMemory(OUT PVOID Destination,
+                                         IN SIZE_T Length);
+    };
+}
+
+#endif /* __XTOSKRNL_RTL_MEMORY_HH */

xtoskrnl/includes/rtl/string.hh

@@ -0,0 +1,55 @@
+/**
+ * PROJECT:         ExectOS
+ * COPYRIGHT:       See COPYING.md in the top level directory
+ * FILE:            xtoskrnl/includes/rtl/string.hh
+ * DESCRIPTION:     String support
+ * DEVELOPERS:      Aiken Harris <harraiken91@gmail.com>
+ */
+
+#ifndef __XTOSKRNL_RTL_STRING_HH
+#define __XTOSKRNL_RTL_STRING_HH
+
+#include <xtos.hh>
+
+
+/* Runtime Library */
+namespace RTL
+{
+    class String
+    {
+        public:
+            STATIC XTAPI SIZE_T CompareString(IN PCSTR String1,
+                                              IN PCSTR String2,
+                                              IN SIZE_T Length);
+            STATIC XTAPI SIZE_T CompareStringInsensitive(IN PCSTR String1,
+                                                         IN PCSTR String2,
+                                                         IN SIZE_T Length);
+            STATIC XTAPI PCHAR ConcatenateString(OUT PCHAR Destination,
+                                                 IN PCHAR Source,
+                                                 IN SIZE_T Count);
+            STATIC XTAPI VOID CopyString(IN PCHAR Destination,
+                                         IN PCSTR Source,
+                                         IN ULONG Length);
+            STATIC XTAPI PCSTR FindString(IN PCSTR Source,
+                                          IN PCSTR Search);
+            STATIC XTAPI PCSTR FindStringInsensitive(IN PCSTR Source,
+                                                     IN PCSTR Search);
+            STATIC XTAPI VOID ReverseString(IN OUT PCHAR String,
+                                            IN ULONG Length);
+            STATIC XTAPI SIZE_T StringLength(IN PCSTR String,
+                                             IN SIZE_T MaxLength);
+            STATIC XTAPI SIZE_T StringToWideString(OUT PWCHAR Destination,
+                                                   IN PCSTR *Source,
+                                                   IN SIZE_T Length);
+            STATIC XTAPI PCHAR TokenizeString(IN PCHAR String,
+                                              IN PCSTR Delimiter,
+                                              IN OUT PCHAR *SavePtr);
+            STATIC XTAPI CHAR ToLowerCharacter(IN CHAR Character);
+            STATIC XTAPI CHAR ToUpperCharacter(IN CHAR Character);
+            STATIC XTAPI PCHAR TrimLeftString(IN PCHAR String);
+            STATIC XTAPI PCHAR TrimRightString(IN PCHAR String);
+            STATIC XTAPI PCHAR TrimString(IN PCHAR String);
+    };
+}
+
+#endif /* __XTOSKRNL_RTL_STRING_HH */

xtoskrnl/includes/rtl/widestr.hh

@@ -0,0 +1,87 @@
+/**
+ * PROJECT:         ExectOS
+ * COPYRIGHT:       See COPYING.md in the top level directory
+ * FILE:            xtoskrnl/includes/rtl/widestr.hh
+ * DESCRIPTION:     Wide string support
+ * DEVELOPERS:      Aiken Harris <harraiken91@gmail.com>
+ */
+
+#ifndef __XTOSKRNL_RTL_WIDESTR_HH
+#define __XTOSKRNL_RTL_WIDESTR_HH
+
+#include <xtos.hh>
+
+
+/* Runtime Library */
+namespace RTL
+{
+    class WideString
+    {
+        public:
+            STATIC XTAPI SIZE_T CompareWideString(IN PCWSTR String1,
+                                                  IN PCWSTR String2,
+                                                  IN SIZE_T Length);
+            STATIC XTAPI SIZE_T CompareWideStringInsensitive(IN PCWSTR String1,
+                                                             IN PCWSTR String2,
+                                                             IN SIZE_T Length);
+            STATIC XTAPI PWCHAR ConcatenateWideString(OUT PWCHAR Destination,
+                                                      IN PWCHAR Source,
+                                                      IN SIZE_T Count);
+            STATIC XTAPI VOID CopyWideString(IN PWCHAR Destination,
+                                             IN PCWSTR Source,
+                                             IN ULONG Length);
+            STATIC XTAPI PCWSTR FindWideString(IN PCWSTR Source,
+                                               IN PCWSTR Search);
+            STATIC XTAPI PCWSTR FindWideStringInsensitive(IN PCWSTR Source,
+                                                          IN PCWSTR Search);
+            STATIC XTAPI XTSTATUS FormatWideString(IN PRTL_PRINT_CONTEXT Context,
+                                                   IN PCWSTR Format,
+                                                   IN VA_LIST ArgumentList);
+            STATIC XTAPI VOID ReverseWideString(IN OUT PWCHAR String,
+                                                IN ULONG Length);
+            STATIC XTAPI PWCHAR TokenizeWideString(IN PWCHAR String,
+                                                   IN PCWSTR Delimiter,
+                                                   IN OUT PWCHAR *SavePtr);
+            STATIC XTAPI WCHAR ToLowerWideCharacter(IN WCHAR Character);
+            STATIC XTAPI WCHAR ToUpperWideCharacter(IN WCHAR Character);
+            STATIC XTAPI PWCHAR TrimLeftWideString(IN PWCHAR String);
+            STATIC XTAPI PWCHAR TrimRightWideString(IN PWCHAR String);
+            STATIC XTAPI PWCHAR TrimWideString(IN PWCHAR String);
+            STATIC XTAPI SIZE_T WideStringLength(IN PCWSTR String,
+                                                 IN SIZE_T MaxLength);
+
+        private:
+            STATIC XTAPI XTSTATUS FormatArgumentSpecifier(IN PRTL_PRINT_CONTEXT Context,
+                                                          IN PCWSTR Format,
+                                                          IN PVA_LIST ArgumentList,
+                                                          IN OUT PULONG Index);
+            STATIC XTAPI ULONGLONG GetArgument(IN PVA_LIST ArgumentList,
+                                               IN ULONG ArgumentNumber,
+                                               IN LONG ArgumentSize);
+            STATIC XTAPI ULONGLONG GetSpecifierValue(IN PWCHAR *Format);
+            STATIC XTAPI XTSTATUS WriteWideCharacter(IN PRTL_PRINT_CONTEXT Context,
+                                                     IN WCHAR Character);
+            STATIC XTCDECL XTSTATUS WriteCustomValue(IN PRTL_PRINT_CONTEXT Context,
+                                                     IN PCWSTR Format,
+                                                     IN ...);
+            STATIC XTAPI XTSTATUS WriteDoubleValue(IN PRTL_PRINT_CONTEXT Context,
+                                                   IN PRTL_PRINT_FORMAT_PROPERTIES FormatProperties,
+                                                   IN DOUBLE Value);
+            STATIC XTAPI XTSTATUS WriteHexDoubleValue(IN PRTL_PRINT_CONTEXT Context,
+                                                      IN PRTL_PRINT_FORMAT_PROPERTIES FormatProperties,
+                                                      IN DOUBLE Double);
+            STATIC XTAPI XTSTATUS WriteIntegerValue(IN PRTL_PRINT_CONTEXT Context,
+                                                    IN PRTL_PRINT_FORMAT_PROPERTIES FormatProperties,
+                                                    IN ULONGLONG Integer);
+            STATIC XTAPI XTSTATUS WriteStringValue(PRTL_PRINT_CONTEXT Context,
+                                                   PRTL_PRINT_FORMAT_PROPERTIES FormatProperties,
+                                                   PCSTR String,
+                                                   SIZE_T StringLength);
+            STATIC XTAPI XTSTATUS WriteValue(PRTL_PRINT_CONTEXT Context,
+                                             PRTL_PRINT_FORMAT_PROPERTIES FormatProperties,
+                                             PCWSTR String,
+                                             SIZE_T StringLength);
+    };
+}
+
+#endif /* __XTOSKRNL_RTL_WIDESTR_HH */

xtoskrnl/includes/xtos.hh

@@ -28,4 +28,6 @@ extern "C" {
 
 #include <ar.hh>
 #include <ex.hh>
+#include <hl.hh>
 #include <ke.hh>
+#include <rtl.hh>

xtoskrnl/rtl/amd64/dispatch.cc

@@ -1,12 +1,12 @@
 /**
  * PROJECT:         ExectOS
  * COPYRIGHT:       See COPYING.md in the top level directory
- * FILE:            xtoskrnl/rtl/amd64/dispatch.c
+ * FILE:            xtoskrnl/rtl/amd64/dispatch.cc
  * DESCRIPTION:     Dispatching support for AMD64 architecture
  * DEVELOPERS:      Rafal Kupiec <belliash@codingworkshop.eu.org>
  */
 
-#include <xtos.h>
+#include <xtos.hh>
 
 
 /**
@@ -24,8 +24,8 @@
  */
 XTAPI
 VOID
-RtlGetStackLimits(OUT PULONG_PTR StackBase,
+RTL::Dispatcher::GetStackLimits(OUT PULONG_PTR StackBase,
-                  OUT PULONG_PTR StackLimit)
+                                OUT PULONG_PTR StackLimit)
 {
     PKTHREAD Thread = KeGetCurrentThread();
     *StackBase = (ULONG_PTR)Thread->StackBase;

xtoskrnl/rtl/amd64/exsup.cc

@@ -1,14 +1,15 @@
 /**
  * PROJECT:         ExectOS
  * COPYRIGHT:       See COPYING.md in the top level directory
- * FILE:            xtoskrnl/rtl/amd64/exsup.c
+ * FILE:            xtoskrnl/rtl/amd64/exsup.cc
  * DESCRIPTION:     Exception handling for AMD64 architecture
  * DEVELOPERS:      Rafal Kupiec <belliash@codingworkshop.eu.org>
  */
 
-#include <xtos.h>
+#include <xtos.hh>
 
 
+XTCLINK
 XTAPI
 EXCEPTION_DISPOSITION
 __C_specific_handler(IN PEXCEPTION_RECORD ExceptionRecord,
@@ -22,6 +23,7 @@ __C_specific_handler(IN PEXCEPTION_RECORD ExceptionRecord,
     return ExceptionContinueExecution;
 }
 
+XTCLINK
 XTCDECL
 INT
 _except_handler3(PEXCEPTION_RECORD ExceptionRecord,

xtoskrnl/rtl/atomic.cc

@@ -1,12 +1,12 @@
 /**
  * PROJECT:         ExectOS
  * COPYRIGHT:       See COPYING.md in the top level directory
- * FILE:            xtoskrnl/rtl/atomic.c
+ * FILE:            xtoskrnl/rtl/atomic.cc
  * DESCRIPTION:     Atomic operations support
  * DEVELOPERS:      Rafal Kupiec <belliash@codingworkshop.eu.org>
  */
 
-#include <xtos.h>
+#include <xtos.hh>
 
 
 /**
@@ -24,8 +24,8 @@
  */
 XTFASTCALL
 CHAR
-RtlAtomicAnd8(IN VOLATILE PCHAR Address,
+RTL::Atomic::And8(IN PCHAR Address,
-              IN CHAR Mask)
+                  IN CHAR Mask)
 {
     return __sync_fetch_and_and(Address, Mask);
 }
@@ -45,8 +45,8 @@ RtlAtomicAnd8(IN VOLATILE PCHAR Address,
  */
 XTFASTCALL
 SHORT
-RtlAtomicAnd16(IN VOLATILE PSHORT Address,
+RTL::Atomic::And16(IN PSHORT Address,
-               IN SHORT Mask)
+                   IN SHORT Mask)
 {
     return __sync_fetch_and_and(Address, Mask);
 }
@@ -66,8 +66,8 @@ RtlAtomicAnd16(IN VOLATILE PSHORT Address,
  */
 XTFASTCALL
 LONG
-RtlAtomicAnd32(IN VOLATILE PLONG Address,
+RTL::Atomic::And32(IN PLONG Address,
-               IN LONG Mask)
+                   IN LONG Mask)
 {
     return __sync_fetch_and_and(Address, Mask);
 }
@@ -87,8 +87,8 @@ RtlAtomicAnd32(IN VOLATILE PLONG Address,
  */
 XTFASTCALL
 LONG_PTR
-RtlAtomicAnd64(IN VOLATILE PLONG_PTR Address,
+RTL::Atomic::And64(IN PLONG_PTR Address,
-               IN LONG_PTR Mask)
+                   IN LONG_PTR Mask)
 {
     return __sync_fetch_and_and(Address, Mask);
 }
@@ -108,8 +108,8 @@ RtlAtomicAnd64(IN VOLATILE PLONG_PTR Address,
  */
 XTFASTCALL
 UCHAR
-RtlAtomicBitTestAndSet(IN VOLATILE PLONG Base,
+RTL::Atomic::BitTestAndSet(IN PLONG Base,
-                       IN LONG Offset)
+                           IN LONG Offset)
 {
     return (__atomic_fetch_or(Base, 1l << Offset, __ATOMIC_SEQ_CST) >> Offset) & 1;
 }
@@ -129,8 +129,8 @@ RtlAtomicBitTestAndSet(IN VOLATILE PLONG Base,
  */
 XTFASTCALL
 UCHAR
-RtlAtomicBitTestAndSet64(IN VOLATILE PLONGLONG Base,
+RTL::Atomic::BitTestAndSet64(IN PLONGLONG Base,
-                         IN LONGLONG Offset)
+                             IN LONGLONG Offset)
 {
     return (__atomic_fetch_or(Base, 1ll << Offset, __ATOMIC_SEQ_CST) >> Offset) & 1;
 }
@@ -153,9 +153,9 @@ RtlAtomicBitTestAndSet64(IN VOLATILE PLONGLONG Base,
  */
 XTFASTCALL
 CHAR
-RtlAtomicCompareExchange8(IN VOLATILE PCHAR Address,
+RTL::Atomic::CompareExchange8(IN PCHAR Address,
-                          IN CHAR Comperand,
+                              IN CHAR Comperand,
-                          IN CHAR Exchange)
+                              IN CHAR Exchange)
 {
     return __sync_val_compare_and_swap(Address, Comperand, Exchange);
 }
@@ -178,9 +178,9 @@ RtlAtomicCompareExchange8(IN VOLATILE PCHAR Address,
  */
 XTFASTCALL
 SHORT
-RtlAtomicCompareExchange16(IN VOLATILE PSHORT Address,
+RTL::Atomic::CompareExchange16(IN PSHORT Address,
-                           IN SHORT Comperand,
+                               IN SHORT Comperand,
-                           IN SHORT Exchange)
+                               IN SHORT Exchange)
 {
     return __sync_val_compare_and_swap(Address, Comperand, Exchange);
 }
@@ -203,9 +203,9 @@ RtlAtomicCompareExchange16(IN VOLATILE PSHORT Address,
  */
 XTFASTCALL
 LONG
-RtlAtomicCompareExchange32(IN VOLATILE PLONG Address,
+RTL::Atomic::CompareExchange32(IN PLONG Address,
-                           IN LONG Comperand,
+                               IN LONG Comperand,
-                           IN LONG Exchange)
+                               IN LONG Exchange)
 {
     return __sync_val_compare_and_swap(Address, Comperand, Exchange);
 }
@@ -228,9 +228,9 @@ RtlAtomicCompareExchange32(IN VOLATILE PLONG Address,
  */
 XTFASTCALL
 LONG_PTR
-RtlAtomicCompareExchange64(IN VOLATILE PLONG_PTR Address,
+RTL::Atomic::CompareExchange64(IN PLONG_PTR Address,
-                           IN LONG_PTR Comperand,
+                               IN LONG_PTR Comperand,
-                           IN LONG_PTR Exchange)
+                               IN LONG_PTR Exchange)
 {
     return __sync_val_compare_and_swap(Address, Comperand, Exchange);
 }
@@ -253,9 +253,9 @@ RtlAtomicCompareExchange64(IN VOLATILE PLONG_PTR Address,
  */
 XTFASTCALL
 PVOID
-RtlAtomicCompareExchangePointer(IN VOLATILE PVOID *Address,
+RTL::Atomic::CompareExchangePointer(IN PVOID *Address,
-                                IN PVOID Comperand,
+                                    IN PVOID Comperand,
-                                IN PVOID Exchange)
+                                    IN PVOID Exchange)
 {
     return (PVOID)__sync_val_compare_and_swap(Address, Comperand, Exchange);
 }
@@ -272,7 +272,7 @@ RtlAtomicCompareExchangePointer(IN VOLATILE PVOID *Address,
  */
 XTFASTCALL
 CHAR
-RtlAtomicDecrement8(IN VOLATILE PCHAR Address)
+RTL::Atomic::Decrement8(IN PCHAR Address)
 {
     return __sync_sub_and_fetch(Address, 1);
 }
@@ -289,7 +289,7 @@ RtlAtomicDecrement8(IN VOLATILE PCHAR Address)
  */
 XTFASTCALL
 SHORT
-RtlAtomicDecrement16(IN VOLATILE PSHORT Address)
+RTL::Atomic::Decrement16(IN PSHORT Address)
 {
     return __sync_sub_and_fetch(Address, 1);
 }
@@ -306,7 +306,7 @@ RtlAtomicDecrement16(IN VOLATILE PSHORT Address)
  */
 XTFASTCALL
 LONG
-RtlAtomicDecrement32(IN VOLATILE PLONG Address)
+RTL::Atomic::Decrement32(IN PLONG Address)
 {
     return __sync_sub_and_fetch(Address, 1);
 }
@@ -323,7 +323,7 @@ RtlAtomicDecrement32(IN VOLATILE PLONG Address)
  */
 XTFASTCALL
 LONG_PTR
-RtlAtomicDecrement64(IN VOLATILE PLONG_PTR Address)
+RTL::Atomic::Decrement64(IN PLONG_PTR Address)
 {
     return __sync_sub_and_fetch(Address, 1);
 }
@@ -343,8 +343,8 @@ RtlAtomicDecrement64(IN VOLATILE PLONG_PTR Address)
  */
 XTFASTCALL
 CHAR
-RtlAtomicExchange8(IN VOLATILE PCHAR Address,
+RTL::Atomic::Exchange8(IN PCHAR Address,
-                   IN CHAR Exchange)
+                       IN CHAR Exchange)
 {
     return __sync_lock_test_and_set(Address, Exchange);
 }
@@ -364,8 +364,8 @@ RtlAtomicExchange8(IN VOLATILE PCHAR Address,
  */
 XTFASTCALL
 SHORT
-RtlAtomicExchange16(IN VOLATILE PSHORT Address,
+RTL::Atomic::Exchange16(IN PSHORT Address,
-                    IN SHORT Exchange)
+                        IN SHORT Exchange)
 {
     return __sync_lock_test_and_set(Address, Exchange);
 }
@@ -385,8 +385,8 @@ RtlAtomicExchange16(IN VOLATILE PSHORT Address,
  */
 XTFASTCALL
 LONG
-RtlAtomicExchange32(IN VOLATILE PLONG Address,
+RTL::Atomic::Exchange32(IN PLONG Address,
-                    IN LONG Exchange)
+                        IN LONG Exchange)
 {
     return __sync_lock_test_and_set(Address, Exchange);
 }
@@ -406,8 +406,8 @@ RtlAtomicExchange32(IN VOLATILE PLONG Address,
  */
 XTFASTCALL
 LONG_PTR
-RtlAtomicExchange64(IN VOLATILE PLONG_PTR Address,
+RTL::Atomic::Exchange64(IN PLONG_PTR Address,
-                    IN LONG_PTR Exchange)
+                        IN LONG_PTR Exchange)
 {
     return __sync_lock_test_and_set(Address, Exchange);
 }
@@ -427,8 +427,8 @@ RtlAtomicExchange64(IN VOLATILE PLONG_PTR Address,
  */
 XTFASTCALL
 CHAR
-RtlAtomicExchangeAdd8(IN VOLATILE PCHAR Address,
+RTL::Atomic::ExchangeAdd8(IN PCHAR Address,
-                      IN CHAR Value)
+                          IN CHAR Value)
 {
     return __sync_fetch_and_add(Address, Value);
 }
@@ -448,8 +448,8 @@ RtlAtomicExchangeAdd8(IN VOLATILE PCHAR Address,
  */
 XTFASTCALL
 SHORT
-RtlAtomicExchangeAdd16(IN VOLATILE PSHORT Address,
+RTL::Atomic::ExchangeAdd16(IN PSHORT Address,
-                       IN SHORT Value)
+                           IN SHORT Value)
 {
     return __sync_fetch_and_add(Address, Value);
 }
@@ -469,8 +469,8 @@ RtlAtomicExchangeAdd16(IN VOLATILE PSHORT Address,
  */
 XTFASTCALL
 LONG
-RtlAtomicExchangeAdd32(IN VOLATILE PLONG Address,
+RTL::Atomic::ExchangeAdd32(IN PLONG Address,
-                       IN LONG Value)
+                           IN LONG Value)
 {
     return __sync_fetch_and_add(Address, Value);
 }
@@ -490,8 +490,8 @@ RtlAtomicExchangeAdd32(IN VOLATILE PLONG Address,
  */
 XTFASTCALL
 LONG_PTR
-RtlAtomicExchangeAdd64(IN VOLATILE PLONG_PTR Address,
+RTL::Atomic::ExchangeAdd64(IN PLONG_PTR Address,
-                       IN LONG_PTR Value)
+                           IN LONG_PTR Value)
 {
     return __sync_fetch_and_add(Address, Value);
 }
@@ -511,8 +511,8 @@ RtlAtomicExchangeAdd64(IN VOLATILE PLONG_PTR Address,
  */
 XTFASTCALL
 PVOID
-RtlAtomicExchangePointer(IN VOLATILE PVOID *Address,
+RTL::Atomic::ExchangePointer(IN PVOID *Address,
-                         IN PVOID Exchange)
+                             IN PVOID Exchange)
 {
     __sync_synchronize();
     return (PVOID)__sync_lock_test_and_set(Address, Exchange);
@@ -530,9 +530,9 @@ RtlAtomicExchangePointer(IN VOLATILE PVOID *Address,
  */
 XTFASTCALL
 PSINGLE_LIST_ENTRY
-RtlAtomicFlushSingleList(IN PSINGLE_LIST_HEADER Header)
+RTL::Atomic::FlushSingleList(IN PSINGLE_LIST_HEADER Header)
 {
-    return (PSINGLE_LIST_ENTRY)RtlAtomicExchange64((PLONG_PTR)&Header->Alignment, (LONGLONG)NULL);
+    return (PSINGLE_LIST_ENTRY)Exchange64((PLONG_PTR)&Header->Alignment, (LONGLONG)NULL);
 }
 
 /**
@@ -547,7 +547,7 @@ RtlAtomicFlushSingleList(IN PSINGLE_LIST_HEADER Header)
  */
 XTFASTCALL
 CHAR
-RtlAtomicIncrement8(IN VOLATILE PCHAR Address)
+RTL::Atomic::Increment8(IN PCHAR Address)
 {
     return __sync_add_and_fetch(Address, 1);
 }
@@ -564,7 +564,7 @@ RtlAtomicIncrement8(IN VOLATILE PCHAR Address)
  */
 XTFASTCALL
 SHORT
-RtlAtomicIncrement16(IN VOLATILE PSHORT Address)
+RTL::Atomic::Increment16(IN PSHORT Address)
 {
     return __sync_add_and_fetch(Address, 1);
 }
@@ -581,7 +581,7 @@ RtlAtomicIncrement16(IN VOLATILE PSHORT Address)
  */
 XTFASTCALL
 LONG
-RtlAtomicIncrement32(IN VOLATILE PLONG Address)
+RTL::Atomic::Increment32(IN PLONG Address)
 {
     return __sync_add_and_fetch(Address, 1);
 }
@@ -598,7 +598,7 @@ RtlAtomicIncrement32(IN VOLATILE PLONG Address)
  */
 XTFASTCALL
 LONG_PTR
-RtlAtomicIncrement64(IN VOLATILE PLONG_PTR Address)
+RTL::Atomic::Increment64(IN PLONG_PTR Address)
 {
     return __sync_add_and_fetch(Address, 1);
 }
@@ -618,8 +618,8 @@ RtlAtomicIncrement64(IN VOLATILE PLONG_PTR Address)
  */
 XTFASTCALL
 CHAR
-RtlAtomicOr8(IN VOLATILE PCHAR Address,
+RTL::Atomic::Or8(IN PCHAR Address,
-             IN CHAR Mask)
+                 IN CHAR Mask)
 {
     return __sync_fetch_and_or(Address, Mask);
 }
@@ -639,8 +639,8 @@ RtlAtomicOr8(IN VOLATILE PCHAR Address,
  */
 XTFASTCALL
 SHORT
-RtlAtomicOr16(IN VOLATILE PSHORT Address,
+RTL::Atomic::Or16(IN PSHORT Address,
-              IN SHORT Mask)
+                  IN SHORT Mask)
 {
     return __sync_fetch_and_or(Address, Mask);
 }
@@ -660,8 +660,8 @@ RtlAtomicOr16(IN VOLATILE PSHORT Address,
  */
 XTFASTCALL
 LONG
-RtlAtomicOr32(IN VOLATILE PLONG Address,
+RTL::Atomic::Or32(IN PLONG Address,
-              IN LONG Mask)
+                  IN LONG Mask)
 {
     return __sync_fetch_and_or(Address, Mask);
 }
@@ -681,8 +681,8 @@ RtlAtomicOr32(IN VOLATILE PLONG Address,
  */
 XTFASTCALL
 LONG_PTR
-RtlAtomicOr64(IN VOLATILE PLONG_PTR Address,
+RTL::Atomic::Or64(IN PLONG_PTR Address,
-              IN LONG_PTR Mask)
+                  IN LONG_PTR Mask)
 {
     return __sync_fetch_and_or(Address, Mask);
 }
@@ -699,12 +699,12 @@ RtlAtomicOr64(IN VOLATILE PLONG_PTR Address,
  */
 XTFASTCALL
 PSINGLE_LIST_ENTRY
-RtlAtomicPopEntrySingleList(IN PSINGLE_LIST_HEADER Header)
+RTL::Atomic::PopEntrySingleList(IN PSINGLE_LIST_HEADER Header)
 {
     PSINGLE_LIST_ENTRY ListHead, FirstEntry, NextEntry;
 
     /* Save header and first entry */
-    ListHead = (PVOID)Header;
+    ListHead = (PSINGLE_LIST_ENTRY)Header;
     FirstEntry = ListHead->Next;
     do
     {
@@ -712,16 +712,16 @@ RtlAtomicPopEntrySingleList(IN PSINGLE_LIST_HEADER Header)
         if(!FirstEntry)
         {
             /* Empty list */
-            return NULL;
+            return nullptr;
         }
 
         /* Update link */
         NextEntry = FirstEntry;
 
         /* Compare and exchange */
-        FirstEntry = (PVOID)RtlAtomicCompareExchange64((PLONG_PTR)ListHead,
+        FirstEntry = (PSINGLE_LIST_ENTRY)CompareExchange64((PLONG_PTR)ListHead,
-                                                       (LONG_PTR)FirstEntry->Next,
+                                                           (LONG_PTR)FirstEntry->Next,
-                                                       (LONG_PTR)FirstEntry);
+                                                           (LONG_PTR)FirstEntry);
     } while(FirstEntry != NextEntry);
 
     /* Return removed element */
@@ -743,14 +743,14 @@ RtlAtomicPopEntrySingleList(IN PSINGLE_LIST_HEADER Header)
  */
 XTFASTCALL
 PSINGLE_LIST_ENTRY
-RtlAtomicPushEntrySingleList(IN PSINGLE_LIST_HEADER Header,
+RTL::Atomic::PushEntrySingleList(IN PSINGLE_LIST_HEADER Header,
-                             IN PSINGLE_LIST_ENTRY Entry)
+                                 IN PSINGLE_LIST_ENTRY Entry)
 {
     PSINGLE_LIST_ENTRY ListHead, ListEntry, FirstEntry, NextEntry;
 
     /* Save header and new entry */
-    ListHead = (PVOID)Header;
+    ListHead = (PSINGLE_LIST_ENTRY)Header;
-    ListEntry = (PVOID)Entry;
+    ListEntry = Entry;
 
     /* Save next link in new first element */
     FirstEntry = ListHead->Next;
@@ -761,9 +761,9 @@ RtlAtomicPushEntrySingleList(IN PSINGLE_LIST_HEADER Header,
         NextEntry = FirstEntry;
 
         /* Compare and exchange */
-        FirstEntry = (PVOID)RtlAtomicCompareExchange64((PLONG_PTR)ListHead,
+        FirstEntry = (PSINGLE_LIST_ENTRY)CompareExchange64((PLONG_PTR)ListHead,
-                                                       (LONG_PTR)ListEntry,
+                                                           (LONG_PTR)ListEntry,
-                                                       (LONG_PTR)FirstEntry);
+                                                           (LONG_PTR)FirstEntry);
     } while(FirstEntry != NextEntry);
 
     /* Return original first element */
@@ -785,8 +785,8 @@ RtlAtomicPushEntrySingleList(IN PSINGLE_LIST_HEADER Header,
  */
 XTFASTCALL
 CHAR
-RtlAtomicXor8(IN VOLATILE PCHAR Address,
+RTL::Atomic::Xor8(IN PCHAR Address,
-              IN CHAR Mask)
+                  IN CHAR Mask)
 {
     return __sync_fetch_and_xor(Address, Mask);
 }
@@ -806,8 +806,8 @@ RtlAtomicXor8(IN VOLATILE PCHAR Address,
  */
 XTFASTCALL
 SHORT
-RtlAtomicXor16(IN VOLATILE PSHORT Address,
+RTL::Atomic::Xor16(IN PSHORT Address,
-               IN SHORT Mask)
+                   IN SHORT Mask)
 {
     return __sync_fetch_and_xor(Address, Mask);
 }
@@ -827,8 +827,8 @@ RtlAtomicXor16(IN VOLATILE PSHORT Address,
  */
 XTFASTCALL
 LONG
-RtlAtomicXor32(IN VOLATILE PLONG Address,
+RTL::Atomic::Xor32(IN PLONG Address,
-               IN LONG Mask)
+                   IN LONG Mask)
 {
     return __sync_fetch_and_xor(Address, Mask);
 }
@@ -848,8 +848,8 @@ RtlAtomicXor32(IN VOLATILE PLONG Address,
  */
 XTFASTCALL
 LONG_PTR
-RtlAtomicXor64(IN VOLATILE PLONG_PTR Address,
+RTL::Atomic::Xor64(IN PLONG_PTR Address,
-               IN LONG_PTR Mask)
+                   IN LONG_PTR Mask)
 {
     return __sync_fetch_and_xor(Address, Mask);
 }

xtoskrnl/rtl/bitmap.cc

@@ -1,12 +1,12 @@
 /**
  * PROJECT:         ExectOS
  * COPYRIGHT:       See COPYING.md in the top level directory
- * FILE:            xtoskrnl/rtl/bitmap.c
+ * FILE:            xtoskrnl/rtl/bitmap.cc
  * DESCRIPTION:     Bit maps support related routines
  * DEVELOPERS:      Rafal Kupiec <belliash@codingworkshop.eu.org>
  */
 
-#include <xtos.h>
+#include <xtos.hh>
 
 
 /**
@@ -21,10 +21,10 @@
  */
 XTAPI
 VOID
-RtlClearAllBits(IN PRTL_BITMAP BitMap)
+RTL::BitMap::ClearAllBits(IN PRTL_BITMAP BitMap)
 {
     /* Clear all bits */
-    RtlSetMemory(BitMap->Buffer, 0, ((BitMap->Size + BITS_PER_LONG - 1) / BITS_PER_LONG) * sizeof(ULONG_PTR));
+    RTL::Memory::SetMemory(BitMap->Buffer, 0, ((BitMap->Size + BITS_PER_LONG - 1) / BITS_PER_LONG) * sizeof(ULONG_PTR));
 }
 
 /**
@@ -42,8 +42,8 @@ RtlClearAllBits(IN PRTL_BITMAP BitMap)
  */
 XTAPI
 VOID
-RtlClearBit(IN PRTL_BITMAP BitMap,
+RTL::BitMap::ClearBit(IN PRTL_BITMAP BitMap,
-            IN ULONG_PTR Bit)
+                      IN ULONG_PTR Bit)
 {
     /* Check if bit is in range */
     if(Bit >= BitMap->Size)
@@ -74,9 +74,9 @@ RtlClearBit(IN PRTL_BITMAP BitMap,
  */
 XTAPI
 VOID
-RtlClearBits(IN PRTL_BITMAP BitMap,
+RTL::BitMap::ClearBits(IN PRTL_BITMAP BitMap,
-             IN ULONG_PTR StartingIndex,
+                       IN ULONG_PTR StartingIndex,
-             IN ULONG_PTR Length)
+                       IN ULONG_PTR Length)
 {
     ULONG_PTR BitOffset, Mask;
     PULONG_PTR Buffer;
@@ -118,7 +118,7 @@ RtlClearBits(IN PRTL_BITMAP BitMap,
     }
 
     /* Clear remaining bits */
-    RtlSetMemory(Buffer, 0, Length >> 3);
+    RTL::Memory::SetMemory(Buffer, 0, Length >> 3);
 
     /* Look for any remaining bits to clear */
     Buffer += Length / BITS_PER_LONG;
@@ -148,26 +148,85 @@ RtlClearBits(IN PRTL_BITMAP BitMap,
  */
 XTAPI
 ULONG
-RtlClearSetBits(IN PRTL_BITMAP BitMap,
+RTL::BitMap::ClearSetBits(IN PRTL_BITMAP BitMap,
-                IN ULONG_PTR Length,
+                          IN ULONG_PTR Length,
-                IN ULONG_PTR Index)
+                          IN ULONG_PTR Index)
 {
     ULONG_PTR StartingIndex;
 
     /* Find set bits */
-    StartingIndex = RtlFindSetBits(BitMap, Length, Index);
+    StartingIndex = FindSetBits(BitMap, Length, Index);
 
     /* Check if set bits were found */
     if(StartingIndex != MAXULONG_PTR)
     {
         /* Clear bits */
-        RtlClearBits(BitMap, StartingIndex, Length);
+        ClearBits(BitMap, StartingIndex, Length);
     }
 
     /* Return position of bits found */
     return StartingIndex;
 }
 
+/**
+ * Counts the number of either set or clear bits in the contiguous region of the bit map.
+ *
+ * @param BitMap
+ *        Supplies a pointer to the bit map.
+ *
+ * @param Length
+ *        Supplies the maximum length (number of bits) to count.
+ *
+ * @param StartingIndex
+ *        Supplies the starting index of the first bit to count.
+ *
+ * @param SetBits
+ *        Specifies whether count bits that are set or clear.
+ *
+ * @return This routine returns the number of equal bits found in the contiguous region.
+ *
+ * @since XT 1.0
+ */
+XTAPI
+ULONG_PTR
+RTL::BitMap::CountBits(IN PRTL_BITMAP BitMap,
+                       IN ULONG_PTR Length,
+                       IN ULONG_PTR StartingIndex,
+                       IN BOOLEAN SetBits)
+{
+    PULONG_PTR Buffer, BufferEnd;
+    ULONG_PTR BitOffset, Size;
+    ULONGLONG Value;
+
+    /* Get pointers to first and last bytes to check */
+    Buffer = &BitMap->Buffer[StartingIndex / BITS_PER_LONG];
+    BufferEnd = Buffer + ((Length + BITS_PER_LONG - 1) / BITS_PER_LONG);
+
+    /* Get offset and value */
+    BitOffset = StartingIndex & (BITS_PER_LONG - 1);
+    Value = (SetBits ? ~*Buffer : *Buffer) >> BitOffset << BitOffset;
+
+    /* Find first bit set until the end of the buffer */
+    while(!Value && Buffer + 1 < BufferEnd)
+    {
+        /* Advance buffer pointer and get value */
+        Value = SetBits ? ~*(++Buffer) : *(++Buffer);
+    }
+
+    /* Check if value found */
+    if(!Value)
+    {
+        /* No bits found, return length */
+        return Length;
+    }
+
+    /* Calculate size */
+    Size = ((Buffer - BitMap->Buffer) * BITS_PER_LONG) - StartingIndex + (ULONG_PTR)RTL::Math::CountTrailingZeroes64(Value);
+
+    /* Return whatever is smaller */
+    return Size > Length ? Length : Size;
+}
+
 /**
  * Dumps the contents of the bit map.
  *
@@ -180,7 +239,7 @@ RtlClearSetBits(IN PRTL_BITMAP BitMap,
  */
 XTAPI
 VOID
-RtlDumpBitMap(IN PRTL_BITMAP BitMap)
+RTL::BitMap::DumpBitMap(IN PRTL_BITMAP BitMap)
 {
     ULONG_PTR Index;
 
@@ -194,6 +253,99 @@ RtlDumpBitMap(IN PRTL_BITMAP BitMap)
     }
 }
 
+/**
+ * Searches the bit map for a contiguous region of either set or clear bits.
+ *
+ * @param BitMap
+ *        Supplies a pointer to the bit map.
+ *
+ * @param Length
+ *        Supplies the length (number of equal bits) to look for.
+ *
+ * @param StartingIndex
+ *        Supplies the starting index of the first bit to start the search at a given position.
+ *
+ * @param SetBits
+ *        Specifies whether count bits that are set or clear.
+ *
+ * @return This routine returns the bit map index position of the contiguous region found, or MAXULONG_PTR if not found.
+ *
+ * @since XT 1.0
+ */
+XTAPI
+ULONG_PTR
+RTL::BitMap::FindBits(IN PRTL_BITMAP BitMap,
+                      IN ULONG_PTR Length,
+                      IN ULONG_PTR StartingIndex,
+                      IN BOOLEAN SetBits)
+{
+    ULONG_PTR BitMapEnd, BitOffset, Size;
+    ULONG Tries;
+
+    /* Validate length */
+    if(Length > BitMap->Size)
+    {
+        /* Length exceeds bit map size, return MAXULONG_PTR */
+        return (ULONG_PTR)-1;
+    }
+    else if(!Length)
+    {
+        /* Length not specified, return starting index */
+        return StartingIndex;
+    }
+
+    /* Check if starting index is in range of bit map size */
+    if(StartingIndex >= BitMap->Size)
+    {
+        /* Starting index exceeds bit map size, start from the beginning */
+        StartingIndex = 0;
+    }
+
+    /* Try from starting index */
+    BitOffset = StartingIndex;
+    BitMapEnd = BitMap->Size;
+
+    /* At least two tries are required */
+    Tries = (StartingIndex != 0) + 2;
+    while(Tries)
+    {
+        /* Find until the end of the bit map */
+        while(BitOffset + Length < BitMapEnd)
+        {
+            /* Increment offset */
+            BitOffset += CountBits(BitMap, BitMap->Size - BitOffset, BitOffset, (BOOLEAN)!SetBits);
+            if(BitOffset + Length > BitMapEnd)
+            {
+                /* No match found, break loop execution */
+                break;
+            }
+
+            /* Count bits in the contiguous region and check if match found */
+            Size = CountBits(BitMap, Length, BitOffset, SetBits);
+            if(Size >= Length)
+            {
+                /* Match found, return offset */
+                return BitOffset;
+            }
+
+            /* Increment offset */
+            BitOffset += Size;
+        }
+
+        /* Try again if possible */
+        Tries--;
+        if(Tries)
+        {
+            /* Restart from the beginning up to the starting index */
+            BitOffset = 0;
+            BitMapEnd = StartingIndex;
+        }
+    }
+
+    /* No match found, return MAXULONG_PTR */
+    return (ULONG_PTR)-1;
+}
+
 /**
  * Searches the bit map for a contiguous region of clear bits.
  *
@@ -212,12 +364,12 @@ RtlDumpBitMap(IN PRTL_BITMAP BitMap)
  */
 XTAPI
 ULONG_PTR
-RtlFindClearBits(IN PRTL_BITMAP BitMap,
+RTL::BitMap::FindClearBits(IN PRTL_BITMAP BitMap,
-                 IN ULONG_PTR Length,
+                           IN ULONG_PTR Length,
-                 IN ULONG_PTR Index)
+                           IN ULONG_PTR Index)
 {
     /* Find clear bits */
-    return RtlpFindBits(BitMap, Length, Index, FALSE);
+    return FindBits(BitMap, Length, Index, FALSE);
 }
 
 /**
@@ -238,12 +390,12 @@ RtlFindClearBits(IN PRTL_BITMAP BitMap,
  */
 XTAPI
 ULONG_PTR
-RtlFindSetBits(IN PRTL_BITMAP BitMap,
+RTL::BitMap::FindSetBits(IN PRTL_BITMAP BitMap,
-               IN ULONG_PTR Length,
+                         IN ULONG_PTR Length,
-               IN ULONG_PTR Index)
+                         IN ULONG_PTR Index)
 {
     /* Find set bits */
-    return RtlpFindBits(BitMap, Length, Index, TRUE);
+    return FindBits(BitMap, Length, Index, TRUE);
 }
 
 /**
@@ -264,9 +416,9 @@ RtlFindSetBits(IN PRTL_BITMAP BitMap,
  */
 XTAPI
 VOID
-RtlInitializeBitMap(IN PRTL_BITMAP BitMap,
+RTL::BitMap::InitializeBitMap(IN PRTL_BITMAP BitMap,
-                    IN PULONG_PTR Buffer,
+                              IN PULONG_PTR Buffer,
-                    IN ULONG Size)
+                              IN ULONG Size)
 {
     /* Initialize bit map */
     BitMap->Buffer = Buffer;
@@ -285,10 +437,10 @@ RtlInitializeBitMap(IN PRTL_BITMAP BitMap,
  */
 XTAPI
 VOID
-RtlSetAllBits(IN PRTL_BITMAP BitMap)
+RTL::BitMap::SetAllBits(IN PRTL_BITMAP BitMap)
 {
     /* Set all bits */
-    RtlSetMemory(BitMap->Buffer, 0xFF, ((BitMap->Size + BITS_PER_LONG - 1) / BITS_PER_LONG) * sizeof(ULONG_PTR));
+    RTL::Memory::SetMemory(BitMap->Buffer, 0xFF, ((BitMap->Size + BITS_PER_LONG - 1) / BITS_PER_LONG) * sizeof(ULONG_PTR));
 }
 
 /**
@@ -306,8 +458,8 @@ RtlSetAllBits(IN PRTL_BITMAP BitMap)
  */
 XTAPI
 VOID
-RtlSetBit(IN PRTL_BITMAP BitMap,
+RTL::BitMap::SetBit(IN PRTL_BITMAP BitMap,
-          IN ULONG_PTR Bit)
+                    IN ULONG_PTR Bit)
 {
     /* Check if bit is in range */
     if(Bit >= BitMap->Size)
@@ -338,9 +490,9 @@ RtlSetBit(IN PRTL_BITMAP BitMap,
  */
 XTAPI
 VOID
-RtlSetBits(IN PRTL_BITMAP BitMap,
+RTL::BitMap::SetBits(IN PRTL_BITMAP BitMap,
-           IN ULONG_PTR StartingIndex,
+                     IN ULONG_PTR StartingIndex,
-           IN ULONG_PTR Length)
+                     IN ULONG_PTR Length)
 {
     ULONG_PTR BitOffset, Mask;
     PULONG_PTR Buffer;
@@ -382,7 +534,7 @@ RtlSetBits(IN PRTL_BITMAP BitMap,
     }
 
     /* Set remaining bits */
-    RtlSetMemory(Buffer, 0xFF, Length >> 3);
+    RTL::Memory::SetMemory(Buffer, 0xFF, Length >> 3);
 
     /* Look for any remaining bits to set */
     Buffer += Length / BITS_PER_LONG;
@@ -412,20 +564,20 @@ RtlSetBits(IN PRTL_BITMAP BitMap,
  */
 XTAPI
 ULONG
-RtlSetClearBits(IN PRTL_BITMAP BitMap,
+RTL::BitMap::SetClearBits(IN PRTL_BITMAP BitMap,
-                IN ULONG_PTR Length,
+                          IN ULONG_PTR Length,
-                IN ULONG_PTR Index)
+                          IN ULONG_PTR Index)
 {
     ULONG_PTR StartingIndex;
 
     /* Find clear bits */
-    StartingIndex = RtlFindClearBits(BitMap, Length, Index);
+    StartingIndex = FindClearBits(BitMap, Length, Index);
 
     /* Check if clear bits were found */
     if(StartingIndex != MAXULONG_PTR)
     {
         /* Set bits */
-        RtlSetBits(BitMap, StartingIndex, Length);
+        SetBits(BitMap, StartingIndex, Length);
     }
 
     /* Return position of bits found */
@@ -447,8 +599,8 @@ RtlSetClearBits(IN PRTL_BITMAP BitMap,
  */
 XTAPI
 BOOLEAN
-RtlTestBit(IN PRTL_BITMAP BitMap,
+RTL::BitMap::TestBit(IN PRTL_BITMAP BitMap,
-           IN ULONG_PTR Bit)
+                     IN ULONG_PTR Bit)
 {
     /* Check if bit is in range */
     if(Bit >= BitMap->Size)
@@ -460,155 +612,3 @@ RtlTestBit(IN PRTL_BITMAP BitMap,
     /* Test specified bit and return result */
     return ((BitMap->Buffer[Bit / BITS_PER_LONG] >> (Bit & (BITS_PER_LONG - 1))) & 1) ? TRUE : FALSE;
 }
-
-/**
- * Counts the number of either set or clear bits in the contiguous region of the bit map.
- *
- * @param BitMap
- *        Supplies a pointer to the bit map.
- *
- * @param Length
- *        Supplies the maximum length (number of bits) to count.
- *
- * @param StartingIndex
- *        Supplies the starting index of the first bit to count.
- *
- * @param SetBits
- *        Specifies whether count bits that are set or clear.
- *
- * @return This routine returns the number of equal bits found in the contiguous region.
- *
- * @since XT 1.0
- */
-XTAPI
-ULONG_PTR
-RtlpCountBits(IN PRTL_BITMAP BitMap,
-              IN ULONG_PTR Length,
-              IN ULONG_PTR StartingIndex,
-              IN BOOLEAN SetBits)
-{
-    PULONG_PTR Buffer, BufferEnd;
-    ULONG_PTR BitOffset, Size;
-    ULONGLONG Value;
-
-    /* Get pointers to first and last bytes to check */
-    Buffer = &BitMap->Buffer[StartingIndex / BITS_PER_LONG];
-    BufferEnd = Buffer + ((Length + BITS_PER_LONG - 1) / BITS_PER_LONG);
-
-    /* Get offset and value */
-    BitOffset = StartingIndex & (BITS_PER_LONG - 1);
-    Value = (SetBits ? ~*Buffer : *Buffer) >> BitOffset << BitOffset;
-
-    /* Find first bit set until the end of the buffer */
-    while(!Value && Buffer + 1 < BufferEnd)
-    {
-        /* Advance buffer pointer and get value */
-        Value = SetBits ? ~*(++Buffer) : *(++Buffer);
-    }
-
-    /* Check if value found */
-    if(!Value)
-    {
-        /* No bits found, return length */
-        return Length;
-    }
-
-    /* Calculate size */
-    Size = ((Buffer - BitMap->Buffer) * BITS_PER_LONG) - StartingIndex + (ULONG_PTR)RtlCountTrailingZeroes64(Value);
-
-    /* Return whatever is smaller */
-    return Size > Length ? Length : Size;
-}
-
-/**
- * Searches the bit map for a contiguous region of either set or clear bits.
- *
- * @param BitMap
- *        Supplies a pointer to the bit map.
- *
- * @param Length
- *        Supplies the length (number of equal bits) to look for.
- *
- * @param StartingIndex
- *        Supplies the starting index of the first bit to start the search at a given position.
- *
- * @param SetBits
- *        Specifies whether count bits that are set or clear.
- *
- * @return This routine returns the bit map index position of the contiguous region found, or MAXULONG_PTR if not found.
- *
- * @since XT 1.0
- */
-XTAPI
-ULONG_PTR
-RtlpFindBits(IN PRTL_BITMAP BitMap,
-             IN ULONG_PTR Length,
-             IN ULONG_PTR StartingIndex,
-             IN BOOLEAN SetBits)
-{
-    ULONG_PTR BitMapEnd, BitOffset, Size;
-    ULONG Tries;
-
-    /* Validate length */
-    if(Length > BitMap->Size)
-    {
-        /* Length exceeds bit map size, return MAXULONG_PTR */
-        return (ULONG_PTR)-1;
-    }
-    else if(!Length)
-    {
-        /* Length not specified, return starting index */
-        return StartingIndex;
-    }
-
-    /* Check if starting index is in range of bit map size */
-    if(StartingIndex >= BitMap->Size)
-    {
-        /* Starting index exceeds bit map size, start from the beginning */
-        StartingIndex = 0;
-    }
-
-    /* Try from starting index */
-    BitOffset = StartingIndex;
-    BitMapEnd = BitMap->Size;
-
-    /* At least two tries are required */
-    Tries = (StartingIndex != 0) + 2;
-    while(Tries)
-    {
-        /* Find until the end of the bit map */
-        while(BitOffset + Length < BitMapEnd)
-        {
-            /* Increment offset */
-            BitOffset += RtlpCountBits(BitMap, BitMap->Size - BitOffset, BitOffset, !SetBits);
-            if(BitOffset + Length > BitMapEnd)
-            {
-                /* No match found, break loop execution */
-                break;
-            }
-
-            /* Count bits in the contiguous region and check if match found */
-            Size = RtlpCountBits(BitMap, Length, BitOffset, SetBits);
-            if(Size >= Length)
-            {
-                /* Match found, return offset */
-                return BitOffset;
-            }
-
-            /* Increment offset */
-            BitOffset += Size;
-        }
-
-        /* Try again if possible */
-        Tries--;
-        if(Tries)
-        {
-            /* Restart from the beginning up to the starting index */
-            BitOffset = 0;
-            BitMapEnd = StartingIndex;
-        }
-    }
-
-    /* No match found, return MAXULONG_PTR */
-    return (ULONG_PTR)-1;
-}

xtoskrnl/rtl/data.cc

@@ -1,8 +1,8 @@
 /**
  * PROJECT:         ExectOS
  * COPYRIGHT:       See COPYING.md in the top level directory
- * FILE:            xtoskrnl/rtl/globals.c
+ * FILE:            xtoskrnl/rtl/data.cc
- * DESCRIPTION:     Kernel runtime library global variables
+ * DESCRIPTION:     Runtime Library global and static data
  * DEVELOPERS:      Rafal Kupiec <belliash@codingworkshop.eu.org>
  */
 
@@ -10,4 +10,4 @@
 
 
 /* This is required for floating numbers to keep LLVM happy */
-int _fltused = 0xFEEDBULL;
+XTCLINK INT _fltused = 0xFEEDBULL;

xtoskrnl/rtl/endian.cc

@@ -1,12 +1,12 @@
 /**
  * PROJECT:         ExectOS
  * COPYRIGHT:       See COPYING.md in the top level directory
- * FILE:            xtoskrnl/rtl/byteswap.c
+ * FILE:            xtoskrnl/rtl/endian.cc
  * DESCRIPTION:     Endian conversion routines
  * DEVELOPERS:      Rafal Kupiec <belliash@codingworkshop.eu.org>
  */
 
-#include <xtos.h>
+#include <xtos.hh>
 
 
 /**
@@ -21,7 +21,7 @@
  */
 XTFASTCALL
 USHORT
-RtlByteSwap16(IN USHORT Source)
+RTL::Endianness::SwapByte16(IN USHORT Source)
 {
     return (USHORT)(((Source >> 8) & 0x00FF) |
                     ((Source << 8) & 0xFF00));
@@ -39,7 +39,7 @@ RtlByteSwap16(IN USHORT Source)
  */
 XTFASTCALL
 ULONG
-RtlByteSwap32(IN ULONG Source)
+RTL::Endianness::SwapByte32(IN ULONG Source)
 {
     return (ULONG)(((Source >> 24) & 0x000000FF) |
                    ((Source >> 8)  & 0x0000FF00) |
@@ -59,7 +59,7 @@ RtlByteSwap32(IN ULONG Source)
  */
 XTFASTCALL
 ULONGLONG
-RtlByteSwap64(IN ULONGLONG Source)
+RTL::Endianness::SwapByte64(IN ULONGLONG Source)
 {
     return (ULONGLONG)(((Source >> 56) & 0x00000000000000FF) |
                        ((Source >> 40) & 0x000000000000FF00) |

xtoskrnl/rtl/guid.cc

@@ -1,12 +1,12 @@
 /**
  * PROJECT:         ExectOS
  * COPYRIGHT:       See COPYING.md in the top level directory
- * FILE:            xtoskrnl/rtl/guid.c
+ * FILE:            xtoskrnl/rtl/guid.cc
  * DESCRIPTION:     GUID manipulation routines
  * DEVELOPERS:      Rafal Kupiec <belliash@codingworkshop.eu.org>
  */
 
-#include <xtos.h>
+#include <xtos.hh>
 
 
 /**
@@ -24,8 +24,8 @@
  */
 XTAPI
 BOOLEAN
-RtlCompareGuids(IN PGUID Guid1,
+RTL::Guid::CompareGuids(IN PGUID Guid1,
-                IN PGUID Guid2)
+                        IN PGUID Guid2)
 {
     PUINT Guid1Ptr, Guid2Ptr;
 
@@ -34,6 +34,6 @@ RtlCompareGuids(IN PGUID Guid1,
     Guid2Ptr = (PUINT)Guid2;
 
     /* Compare GUIDs */
-    return(Guid1Ptr[0] == Guid2Ptr[0] && Guid1Ptr[1] == Guid2Ptr[1] &&
+    return (BOOLEAN)(Guid1Ptr[0] == Guid2Ptr[0] && Guid1Ptr[1] == Guid2Ptr[1] &&
-           Guid1Ptr[2] == Guid2Ptr[2] && Guid1Ptr[3] == Guid2Ptr[3]);
+                     Guid1Ptr[2] == Guid2Ptr[2] && Guid1Ptr[3] == Guid2Ptr[3]);
 }

xtoskrnl/rtl/i686/dispatch.cc

@@ -1,12 +1,12 @@
 /**
  * PROJECT:         ExectOS
  * COPYRIGHT:       See COPYING.md in the top level directory
- * FILE:            xtoskrnl/rtl/i686/dispatch.c
+ * FILE:            xtoskrnl/rtl/i686/dispatch.cc
  * DESCRIPTION:     Dispatching support for i686 architecture
  * DEVELOPERS:      Rafal Kupiec <belliash@codingworkshop.eu.org>
  */
 
-#include <xtos.h>
+#include <xtos.hh>
 
 
 /**
@@ -24,8 +24,8 @@
  */
 XTAPI
 VOID
-RtlGetStackLimits(OUT PULONG_PTR StackBase,
+RTL::Dispatcher::GetStackLimits(OUT PULONG_PTR StackBase,
-                  OUT PULONG_PTR StackLimit)
+                                OUT PULONG_PTR StackLimit)
 {
     PKTHREAD Thread = KeGetCurrentThread();
     *StackBase = (ULONG_PTR)Thread->StackBase - sizeof(FX_SAVE_AREA);

xtoskrnl/rtl/i686/exsup.cc

@@ -1,14 +1,15 @@
 /**
  * PROJECT:         ExectOS
  * COPYRIGHT:       See COPYING.md in the top level directory
- * FILE:            xtoskrnl/rtl/i686/exsup.c
+ * FILE:            xtoskrnl/rtl/i686/exsup.cc
  * DESCRIPTION:     Exception handling for i686 architecture
  * DEVELOPERS:      Rafal Kupiec <belliash@codingworkshop.eu.org>
  */
 
-#include <xtos.h>
+#include <xtos.hh>
 
 
+XTCLINK
 XTCDECL
 EXCEPTION_DISPOSITION
 __C_specific_handler(IN PEXCEPTION_RECORD ExceptionRecord,
@@ -22,6 +23,7 @@ __C_specific_handler(IN PEXCEPTION_RECORD ExceptionRecord,
     return ExceptionContinueExecution;
 }
 
+XTCLINK
 XTCDECL
 INT
 _except_handler3(PEXCEPTION_RECORD ExceptionRecord,

xtoskrnl/rtl/llist.cc

@@ -1,12 +1,12 @@
 /**
  * PROJECT:         ExectOS
  * COPYRIGHT:       See COPYING.md in the top level directory
- * FILE:            xtoskrnl/rtl/plist.c
+ * FILE:            xtoskrnl/rtl/llist.cc
  * DESCRIPTION:     Linked list manipulation routines
  * DEVELOPERS:      Rafal Kupiec <belliash@codingworkshop.eu.org>
  */
 
-#include <xtos.h>
+#include <xtos.hh>
 
 
 /**
@@ -21,7 +21,7 @@
  */
 XTCDECL
 VOID
-RtlInitializeListHead(IN PLIST_ENTRY ListHead)
+RTL::LinkedList::InitializeListHead(IN PLIST_ENTRY ListHead)
 {
     ListHead->Blink = ListHead;
     ListHead->Flink = ListHead;
@@ -39,7 +39,7 @@ RtlInitializeListHead(IN PLIST_ENTRY ListHead)
  */
 XTCDECL
 VOID
-RtlInitializeListHead32(IN PLIST_ENTRY32 ListHead)
+RTL::LinkedList::InitializeListHead32(IN PLIST_ENTRY32 ListHead)
 {
     ListHead->Blink = PtrToUlong(ListHead);
     ListHead->Flink = PtrToUlong(ListHead);
@@ -60,8 +60,8 @@ RtlInitializeListHead32(IN PLIST_ENTRY32 ListHead)
  */
 XTCDECL
 VOID
-RtlInsertHeadList(IN OUT PLIST_ENTRY ListHead,
+RTL::LinkedList::InsertHeadList(IN OUT PLIST_ENTRY ListHead,
-                  IN PLIST_ENTRY Entry)
+                                IN PLIST_ENTRY Entry)
 {
     Entry->Flink = ListHead->Flink;
     Entry->Blink = ListHead;
@@ -84,8 +84,8 @@ RtlInsertHeadList(IN OUT PLIST_ENTRY ListHead,
  */
 XTCDECL
 VOID
-RtlInsertTailList(IN OUT PLIST_ENTRY ListHead,
+RTL::LinkedList::InsertTailList(IN OUT PLIST_ENTRY ListHead,
-                  IN PLIST_ENTRY Entry)
+                                IN PLIST_ENTRY Entry)
 {
     Entry->Flink = ListHead;
     Entry->Blink = ListHead->Blink;
@@ -105,9 +105,9 @@ RtlInsertTailList(IN OUT PLIST_ENTRY ListHead,
  */
 XTCDECL
 BOOLEAN
-RtlListEmpty(IN PLIST_ENTRY ListHead)
+RTL::LinkedList::ListEmpty(IN PLIST_ENTRY ListHead)
 {
-    return (((ListHead->Flink == NULL) && (ListHead->Blink == NULL)) || (ListHead->Flink == ListHead));
+    return (BOOLEAN)(((ListHead->Flink == NULL) && (ListHead->Blink == NULL)) || (ListHead->Flink == ListHead));
 }
 
 /**
@@ -122,7 +122,7 @@ RtlListEmpty(IN PLIST_ENTRY ListHead)
  */
 XTCDECL
 BOOLEAN
-RtlListLoop(IN PLIST_ENTRY ListHead)
+RTL::LinkedList::ListLoop(IN PLIST_ENTRY ListHead)
 {
     PLIST_ENTRY SlowEntry, FastEntry;
 
@@ -168,7 +168,7 @@ RtlListLoop(IN PLIST_ENTRY ListHead)
  */
 XTCDECL
 VOID
-RtlRemoveEntryList(IN PLIST_ENTRY Entry)
+RTL::LinkedList::RemoveEntryList(IN PLIST_ENTRY Entry)
 {
     Entry->Flink->Blink = Entry->Blink;
     Entry->Blink->Flink = Entry->Flink;

xtoskrnl/rtl/math.cc

@@ -1,12 +1,12 @@
 /**
  * PROJECT:         ExectOS
  * COPYRIGHT:       See COPYING.md in the top level directory
- * FILE:            xtoskrnl/rtl/math.c
+ * FILE:            xtoskrnl/rtl/math.cc
  * DESCRIPTION:     Kernel math support
  * DEVELOPERS:      Rafal Kupiec <belliash@codingworkshop.eu.org>
  */
 
-#include <xtos.h>
+#include <xtos.hh>
 
 
 /**
@@ -21,7 +21,7 @@
  */
 XTAPI
 LARGE_INTEGER
-RtlConvertToLargeInteger32(IN LONG Value)
+RTL::Math::ConvertToLargeInteger32(IN LONG Value)
 {
     LARGE_INTEGER LargeInt;
 
@@ -42,7 +42,7 @@ RtlConvertToLargeInteger32(IN LONG Value)
  */
 XTAPI
 LARGE_INTEGER
-RtlConvertToLargeIntegerUnsigned32(IN ULONG Value)
+RTL::Math::ConvertToLargeIntegerUnsigned32(IN ULONG Value)
 {
     LARGE_INTEGER LargeInt;
 
@@ -63,7 +63,7 @@ RtlConvertToLargeIntegerUnsigned32(IN ULONG Value)
  */
 XTAPI
 INT
-RtlCountLeadingZeroes32(IN ULONG Value)
+RTL::Math::CountLeadingZeroes32(IN ULONG Value)
 {
     /* Return a number of leading zero bits */
     return __builtin_clzl(Value);
@@ -81,7 +81,7 @@ RtlCountLeadingZeroes32(IN ULONG Value)
  */
 XTAPI
 INT
-RtlCountLeadingZeroes64(IN ULONGLONG Value)
+RTL::Math::CountLeadingZeroes64(IN ULONGLONG Value)
 {
     /* Return a number of leading zero bits */
     return __builtin_clzll(Value);
@@ -99,7 +99,7 @@ RtlCountLeadingZeroes64(IN ULONGLONG Value)
  */
 XTAPI
 INT
-RtlCountTrailingZeroes32(IN ULONG Value)
+RTL::Math::CountTrailingZeroes32(IN ULONG Value)
 {
     /* Return a number of trailing zero bits */
     return __builtin_ctzl(Value);
@@ -117,7 +117,7 @@ RtlCountTrailingZeroes32(IN ULONG Value)
  */
 XTAPI
 INT
-RtlCountTrailingZeroes64(IN ULONGLONG Value)
+RTL::Math::CountTrailingZeroes64(IN ULONGLONG Value)
 {
     /* Return a number of trailing zero bits */
     return __builtin_ctzll(Value);
@@ -141,9 +141,9 @@ RtlCountTrailingZeroes64(IN ULONGLONG Value)
  */
 XTAPI
 LONGLONG
-RtlDivide32(IN LONG Dividend,
+RTL::Math::Divide32(IN LONG Dividend,
-            IN LONG Divisor,
+                    IN LONG Divisor,
-            OUT PLONG Remainder)
+                    OUT PLONG Remainder)
 {
     LONG Quotient;
 
@@ -179,9 +179,9 @@ RtlDivide32(IN LONG Dividend,
  */
 XTAPI
 LONGLONG
-RtlDivide64(IN LONGLONG Dividend,
+RTL::Math::Divide64(IN LONGLONG Dividend,
-            IN LONGLONG Divisor,
+                    IN LONGLONG Divisor,
-            OUT PLONGLONG Remainder)
+                    OUT PLONGLONG Remainder)
 {
     LONGLONG DividendSign, DivisorSign, Quotient, UDividend, UDivisor;
 
@@ -193,7 +193,7 @@ RtlDivide64(IN LONGLONG Dividend,
 
     /* Calculate the quotient */
     DividendSign ^= DivisorSign;
-    Quotient = (RtlDivideUnsigned64(UDividend, UDivisor, NULL) ^ DividendSign) - DividendSign;
+    Quotient = (DivideUnsigned64(UDividend, UDivisor, nullptr) ^ DividendSign) - DividendSign;
 
     /* Make sure a pointer to remainder provided */
     if(Remainder)
@@ -224,9 +224,9 @@ RtlDivide64(IN LONGLONG Dividend,
  */
 XTAPI
 ULONGLONG
-RtlDivideUnsigned32(IN ULONG Dividend,
+RTL::Math::DivideUnsigned32(IN ULONG Dividend,
-                    IN ULONG Divisor,
+                            IN ULONG Divisor,
-                    OUT PULONG Remainder)
+                            OUT PULONG Remainder)
 {
     /* Make sure a pointer to remainder provided */
     if(Remainder)
@@ -257,9 +257,9 @@ RtlDivideUnsigned32(IN ULONG Dividend,
  */
 XTAPI
 ULONGLONG
-RtlDivideUnsigned64(IN ULONGLONG Dividend,
+RTL::Math::DivideUnsigned64(IN ULONGLONG Dividend,
-                    IN ULONGLONG Divisor,
+                            IN ULONGLONG Divisor,
-                    OUT PULONGLONG Remainder)
+                            OUT PULONGLONG Remainder)
 {
     ULARGE_INTEGER DividendParts, DivisorParts, QuotientParts, RemainderParts;
     LONGLONG Difference;
@@ -312,7 +312,7 @@ RtlDivideUnsigned64(IN ULONGLONG Dividend,
         if(DivisorParts.u.HighPart != 0)
         {
             /* Divisor is 64-bit value, calculate the shift count */
-            Shift = RtlCountLeadingZeroes32(DivisorParts.u.HighPart) - RtlCountLeadingZeroes32(DividendParts.u.HighPart);
+            Shift = CountLeadingZeroes32(DivisorParts.u.HighPart) - CountLeadingZeroes32(DividendParts.u.HighPart);
 
             /* Check if shift count exceeds 32-bits */
             if(Shift > ((sizeof(ULONG) * BITS_PER_BYTE) - 1))
@@ -349,8 +349,8 @@ RtlDivideUnsigned64(IN ULONGLONG Dividend,
         {
             /* Divisor is 32-bit value, calculate the shift count */
             Shift = (sizeof(ULONG) * BITS_PER_BYTE) + 1 +
-                    RtlCountLeadingZeroes32(DivisorParts.u.LowPart) -
+                    CountLeadingZeroes32(DivisorParts.u.LowPart) -
-                    RtlCountLeadingZeroes32(DividendParts.u.HighPart);
+                    CountLeadingZeroes32(DividendParts.u.HighPart);
 
             /* Check if shift is 32-bit */
             if(Shift == (sizeof(ULONG) * BITS_PER_BYTE))
@@ -401,7 +401,7 @@ RtlDivideUnsigned64(IN ULONGLONG Dividend,
         }
 
         /* Calculate the shift count */
-        Shift = RtlCountLeadingZeroes32(DivisorParts.u.HighPart) - RtlCountLeadingZeroes32(DividendParts.u.HighPart);
+        Shift = CountLeadingZeroes32(DivisorParts.u.HighPart) - CountLeadingZeroes32(DividendParts.u.HighPart);
 
         /* Check if shift exceeds 32-bits */
         if(Shift > ((sizeof(ULONG) * BITS_PER_BYTE) - 2))
@@ -485,9 +485,9 @@ RtlDivideUnsigned64(IN ULONGLONG Dividend,
  */
 XTAPI
 LARGE_INTEGER
-RtlDivideLargeInteger(IN LARGE_INTEGER Dividend,
+RTL::Math::DivideLargeInteger(IN LARGE_INTEGER Dividend,
-                      IN ULONG Divisor,
+                              IN ULONG Divisor,
-                      OUT PULONG Remainder)
+                              OUT PULONG Remainder)
 {
     LONGLONG DividendSign, UDividend;
     LARGE_INTEGER LargeInt;
@@ -497,7 +497,7 @@ RtlDivideLargeInteger(IN LARGE_INTEGER Dividend,
     UDividend = (Dividend.QuadPart ^ DividendSign) - DividendSign;
 
     /* Calculate the quotient */
-    LargeInt.QuadPart = (RtlDivideUnsigned64(UDividend, Divisor, NULL) ^ DividendSign) - DividendSign;
+    LargeInt.QuadPart = (DivideUnsigned64(UDividend, Divisor, nullptr) ^ DividendSign) - DividendSign;
 
     /* Make sure a pointer to remainder provided */
     if(Remainder)
@@ -525,8 +525,8 @@ RtlDivideLargeInteger(IN LARGE_INTEGER Dividend,
  */
 XTAPI
 LONG
-RtlGetBaseExponent(IN DOUBLE Value,
+RTL::Math::GetBaseExponent(IN DOUBLE Value,
-                   OUT PDOUBLE PowerOfTen)
+                           OUT PDOUBLE PowerOfTen)
 {
     LONG BaseExponent, CurrentExponent, Exponent;
     ULONG ExponentShift, ExponentMask;
@@ -612,7 +612,7 @@ RtlGetBaseExponent(IN DOUBLE Value,
  */
 XTCDECL
 BOOLEAN
-RtlInfiniteDouble(IN DOUBLE Value)
+RTL::Math::InfiniteDouble(IN DOUBLE Value)
 {
     /* DOUBLE argument in IEEE 754 standard format */
     union
@@ -631,7 +631,7 @@ RtlInfiniteDouble(IN DOUBLE Value)
     Var.Double = &Value;
 
     /* Return TRUE if it is infinite, or FALSE otherwise */
-    return ((Var.DoubleS->Exponent & 0x7FF) == 0x7FF);
+    return (BOOLEAN)((Var.DoubleS->Exponent & 0x7FF) == 0x7FF);
 }
 
 /**
@@ -649,8 +649,8 @@ RtlInfiniteDouble(IN DOUBLE Value)
  */
 XTAPI
 LARGE_INTEGER
-RtlMultiplyLargeInteger(IN LARGE_INTEGER Multiplicand,
+RTL::Math::MultiplyLargeInteger(IN LARGE_INTEGER Multiplicand,
-                        IN LONG Multiplier)
+                                IN LONG Multiplier)
 {
     LARGE_INTEGER LargeInt;
 
@@ -671,7 +671,7 @@ RtlMultiplyLargeInteger(IN LARGE_INTEGER Multiplicand,
  */
 XTCDECL
 BOOLEAN
-RtlNanDouble(IN DOUBLE Value)
+RTL::Math::NanDouble(IN DOUBLE Value)
 {
     /* DOUBLE argument in IEEE 754 standard format */
     union
@@ -690,5 +690,5 @@ RtlNanDouble(IN DOUBLE Value)
     Var.Double = &Value;
 
     /* Return TRUE if it is NaN, or FALSE otherwise */
-    return (Var.DoubleS->Exponent == 0x7FF && (Var.DoubleS->MantissaHigh != 0 || Var.DoubleS->MantissaLow != 0));
+    return (BOOLEAN)(Var.DoubleS->Exponent == 0x7FF && (Var.DoubleS->MantissaHigh != 0 || Var.DoubleS->MantissaLow != 0));
 }

xtoskrnl/rtl/memory.cc

@@ -1,12 +1,12 @@
 /**
  * PROJECT:         ExectOS
  * COPYRIGHT:       See COPYING.md in the top level directory
- * FILE:            xtoskrnl/rtl/memory.c
+ * FILE:            xtoskrnl/rtl/memory.cc
  * DESCRIPTION:     Memory related routines
  * DEVELOPERS:      Rafal Kupiec <belliash@codingworkshop.eu.org>
  */
 
-#include <xtos.h>
+#include <xtos.hh>
 
 
 /**
@@ -27,9 +27,9 @@
  */
 XTAPI
 SIZE_T
-RtlCompareMemory(IN PCVOID LeftBuffer,
+RTL::Memory::CompareMemory(IN PCVOID LeftBuffer,
-                 IN PCVOID RightBuffer,
+                           IN PCVOID RightBuffer,
-                 IN SIZE_T Length)
+                           IN SIZE_T Length)
 {
     SIZE_T Bytes = 0;
 
@@ -73,9 +73,9 @@ RtlCompareMemory(IN PCVOID LeftBuffer,
  */
 XTAPI
 VOID
-RtlCopyMemory(OUT PVOID Destination,
+RTL::Memory::CopyMemory(OUT PVOID Destination,
-              IN PCVOID Source,
+                        IN PCVOID Source,
-              IN SIZE_T Length)
+                        IN SIZE_T Length)
 {
     PCHAR DestinationBytes = (PCHAR)Destination;
     PCCHAR SourceBytes = (PCHAR)Source;
@@ -106,9 +106,9 @@ RtlCopyMemory(OUT PVOID Destination,
  */
 XTAPI
 VOID
-RtlMoveMemory(OUT PVOID Destination,
+RTL::Memory::MoveMemory(OUT PVOID Destination,
-              IN PCVOID Source,
+                        IN PCVOID Source,
-              IN SIZE_T Length)
+                        IN SIZE_T Length)
 {
     PCHAR DestinationBytes = (PCHAR)Destination;
     PCHAR SourceBytes = (PCHAR)Source;
@@ -154,11 +154,11 @@ RtlMoveMemory(OUT PVOID Destination,
  */
 XTAPI
 BOOLEAN
-RtlSameMemory(IN PCVOID LeftBuffer,
+RTL::Memory::SameMemory(IN PCVOID LeftBuffer,
-              IN PCVOID RightBuffer,
+                        IN PCVOID RightBuffer,
-              IN SIZE_T Length)
+                        IN SIZE_T Length)
 {
-    return (RtlCompareMemory(LeftBuffer, RightBuffer, Length) == Length) ? TRUE : FALSE;
+    return (CompareMemory(LeftBuffer, RightBuffer, Length) == Length) ? TRUE : FALSE;
 }
 
 /**
@@ -179,9 +179,9 @@ RtlSameMemory(IN PCVOID LeftBuffer,
  */
 XTAPI
 VOID
-RtlSetMemory(OUT PVOID Destination,
+RTL::Memory::SetMemory(OUT PVOID Destination,
-             IN UCHAR Byte,
+                       IN UCHAR Byte,
-             IN SIZE_T Length)
+                       IN SIZE_T Length)
 {
     PCHAR DestinationBytes = (PCHAR)Destination;
 
@@ -207,9 +207,9 @@ RtlSetMemory(OUT PVOID Destination,
  */
 XTAPI
 VOID
-RtlZeroMemory(OUT PVOID Destination,
+RTL::Memory::ZeroMemory(OUT PVOID Destination,
-              IN SIZE_T Length)
+                        IN SIZE_T Length)
 {
     /* Fill the buffer with zeroes */
-    RtlSetMemory(Destination, 0, Length);
+    SetMemory(Destination, 0, Length);
 }

xtoskrnl/rtl/string.cc

@@ -1,12 +1,12 @@
 /**
  * PROJECT:         ExectOS
  * COPYRIGHT:       See COPYING.md in the top level directory
- * FILE:            xtoskrnl/rtl/string.c
+ * FILE:            xtoskrnl/rtl/string.cc
  * DESCRIPTION:     String support
  * DEVELOPERS:      Rafal Kupiec <belliash@codingworkshop.eu.org>
  */
 
-#include <xtos.h>
+#include <xtos.hh>
 
 
 /**
@@ -27,9 +27,9 @@
  */
 XTAPI
 SIZE_T
-RtlCompareString(IN PCSTR String1,
+RTL::String::CompareString(IN PCSTR String1,
-                 IN PCSTR String2,
+                           IN PCSTR String2,
-                 IN SIZE_T Length)
+                           IN SIZE_T Length)
 {
     SIZE_T Index;
 
@@ -79,9 +79,9 @@ RtlCompareString(IN PCSTR String1,
  */
 XTAPI
 SIZE_T
-RtlCompareStringInsensitive(IN PCSTR String1,
+RTL::String::CompareStringInsensitive(IN PCSTR String1,
-                            IN PCSTR String2,
+                                      IN PCSTR String2,
-                            IN SIZE_T Length)
+                                      IN SIZE_T Length)
 {
     CHAR Character1;
     CHAR Character2;
@@ -146,9 +146,9 @@ RtlCompareStringInsensitive(IN PCSTR String1,
  */
 XTAPI
 PCHAR
-RtlConcatenateString(OUT PCHAR Destination,
+RTL::String::ConcatenateString(OUT PCHAR Destination,
-                     IN PCHAR Source,
+                               IN PCHAR Source,
-                     IN SIZE_T Count)
+                               IN SIZE_T Count)
 {
     PCHAR DestString = Destination;
 
@@ -205,9 +205,9 @@ RtlConcatenateString(OUT PCHAR Destination,
  */
 XTAPI
 VOID
-RtlCopyString(IN PCHAR Destination,
+RTL::String::CopyString(IN PCHAR Destination,
-              IN PCSTR Source,
+                        IN PCSTR Source,
-              IN ULONG Length)
+                        IN ULONG Length)
 {
     ULONG Index;
 
@@ -244,8 +244,8 @@ RtlCopyString(IN PCHAR Destination,
  */
 XTAPI
 PCSTR
-RtlFindString(IN PCSTR Source,
+RTL::String::FindString(IN PCSTR Source,
-              IN PCSTR Search)
+                        IN PCSTR Search)
 {
     PCSTR CurrentSource;
     PCSTR CurrentSearch;
@@ -254,7 +254,7 @@ RtlFindString(IN PCSTR Source,
     if(!Source || !Search)
     {
         /* Invalid input parameters, return NULL */
-        return NULL;
+        return nullptr;
     }
 
     /* Check if search string is empty */
@@ -288,7 +288,7 @@ RtlFindString(IN PCSTR Source,
     }
 
     /* No match found, return NULL */
-    return NULL;
+    return nullptr;
 }
 
 /**
@@ -306,8 +306,8 @@ RtlFindString(IN PCSTR Source,
  */
 XTAPI
 PCSTR
-RtlFindStringInsensitive(IN PCSTR Source,
+RTL::String::FindStringInsensitive(IN PCSTR Source,
-                         IN PCSTR Search)
+                                   IN PCSTR Search)
 {
     PCSTR CurrentSource;
     PCSTR CurrentSearch;
@@ -316,7 +316,7 @@ RtlFindStringInsensitive(IN PCSTR Source,
     if(!Source || !Search)
     {
         /* Invalid input parameters, return NULL */
-        return NULL;
+        return nullptr;
     }
 
     /* Check if search string is empty */
@@ -335,7 +335,7 @@ RtlFindStringInsensitive(IN PCSTR Source,
 
         /* Check if the substring matches starting at the current position */
         while(*CurrentSource != '\0' && *CurrentSearch != '\0' &&
-              RtlToLowerCharacter(*CurrentSource) == RtlToLowerCharacter(*CurrentSearch))
+              ToLowerCharacter(*CurrentSource) == ToLowerCharacter(*CurrentSearch))
         {
             /* Go to the next character */
             CurrentSource++;
@@ -351,7 +351,7 @@ RtlFindStringInsensitive(IN PCSTR Source,
     }
 
     /* No match found, return NULL */
-    return NULL;
+    return nullptr;
 }
 
 /**
@@ -369,8 +369,8 @@ RtlFindStringInsensitive(IN PCSTR Source,
  */
 XTAPI
 VOID
-RtlReverseString(IN OUT PCHAR String,
+RTL::String::ReverseString(IN OUT PCHAR String,
-                 IN ULONG Length)
+                           IN ULONG Length)
 {
     UCHAR TempChar;
     ULONG Index;
@@ -400,8 +400,8 @@ RtlReverseString(IN OUT PCHAR String,
  */
 XTAPI
 SIZE_T
-RtlStringLength(IN PCSTR String,
+RTL::String::StringLength(IN PCSTR String,
-                IN SIZE_T MaxLength)
+                          IN SIZE_T MaxLength)
 {
     SIZE_T Length;
 
@@ -445,9 +445,9 @@ RtlStringLength(IN PCSTR String,
  */
 XTAPI
 SIZE_T
-RtlStringToWideString(OUT PWCHAR Destination,
+RTL::String::StringToWideString(OUT PWCHAR Destination,
-                      IN PCSTR *Source,
+                                IN PCSTR *Source,
-                      IN SIZE_T Length)
+                                IN SIZE_T Length)
 {
     PCSTR LocalSource = *Source;
     SIZE_T Count = Length;
@@ -466,7 +466,7 @@ RtlStringToWideString(OUT PWCHAR Destination,
         if((*Destination = *LocalSource) == 0)
         {
             /* End of string reached */
-            LocalSource = NULL;
+            LocalSource = nullptr;
             break;
         }
 
@@ -505,9 +505,9 @@ RtlStringToWideString(OUT PWCHAR Destination,
  */
 XTAPI
 PCHAR
-RtlTokenizeString(IN PCHAR String,
+RTL::String::TokenizeString(IN PCHAR String,
-                  IN PCSTR Delimiter,
+                            IN PCSTR Delimiter,
-                  IN OUT PCHAR *SavePtr)
+                            IN OUT PCHAR *SavePtr)
 {
     PCHAR Span, Token;
     CHAR Char, SpanChar;
@@ -516,15 +516,15 @@ RtlTokenizeString(IN PCHAR String,
     if(String == NULL && (String = *SavePtr) == NULL)
     {
         /* Empty string given */
-        return NULL;
+        return nullptr;
     }
 
     /* Check non-delimiter characters */
     Char = *String++;
     if(Char == '\0')
     {
-        *SavePtr = NULL;
+        *SavePtr = nullptr;
-        return NULL;
+        return nullptr;
     }
     Token = String - 1;
 
@@ -542,7 +542,7 @@ RtlTokenizeString(IN PCHAR String,
                 if(Char == '\0')
                 {
                     /* End of string reached, no more tokens */
-                    String = NULL;
+                    String = nullptr;
                 }
                 else
                 {
@@ -573,7 +573,7 @@ RtlTokenizeString(IN PCHAR String,
  */
 XTAPI
 CHAR
-RtlToLowerCharacter(IN CHAR Character)
+RTL::String::ToLowerCharacter(IN CHAR Character)
 {
     /* Check if character is uppercase */
     if(Character >= 'A' && Character <= 'Z')
@@ -598,7 +598,7 @@ RtlToLowerCharacter(IN CHAR Character)
  */
 XTAPI
 CHAR
-RtlToUpperCharacter(IN CHAR Character)
+RTL::String::ToUpperCharacter(IN CHAR Character)
 {
     /* Check if character is lowercase */
     if(Character >= 'a' && Character <= 'z')
@@ -623,7 +623,7 @@ RtlToUpperCharacter(IN CHAR Character)
  */
 XTAPI
 PCHAR
-RtlTrimLeftString(IN PCHAR String)
+RTL::String::TrimLeftString(IN PCHAR String)
 {
     PCHAR Start;
 
@@ -653,12 +653,12 @@ RtlTrimLeftString(IN PCHAR String)
  */
 XTAPI
 PCHAR
-RtlTrimRightString(IN PCHAR String)
+RTL::String::TrimRightString(IN PCHAR String)
 {
     PCHAR End;
 
     /* Find end of the string */
-    End = String + RtlStringLength(String, 0);
+    End = String + StringLength(String, 0);
 
     /* Skip all trailing whitespaces */
     while((End != String) && (*End == ' ' || *End == '\n' || *End == '\t' || *End == '\r' || *End == '\v' || *End == '\f'))
@@ -686,7 +686,7 @@ RtlTrimRightString(IN PCHAR String)
  */
 XTAPI
 PCHAR
-RtlTrimString(IN PCHAR String)
+RTL::String::TrimString(IN PCHAR String)
 {
-    return RtlTrimLeftString(RtlTrimRightString(String));
+    return TrimLeftString(TrimRightString(String));
 }