diff options
53 files changed, 380 insertions, 405 deletions
diff --git a/Private/Builtins/ACPI/ACPIFactoryInterface.hxx b/Private/Builtins/ACPI/ACPIFactoryInterface.hxx index 6d2325fe..1f75ad2f 100644 --- a/Private/Builtins/ACPI/ACPIFactoryInterface.hxx +++ b/Private/Builtins/ACPI/ACPIFactoryInterface.hxx @@ -43,8 +43,8 @@ class ACPIFactoryInterface final { } private: - VoidPtr m_Rsdp; // pointer to root descriptor. - SSizeT m_Entries; // number of entries, -1 tells that no invalid entries were + VoidPtr fRsdp; // pointer to root descriptor. + SSizeT fEntries; // number of entries, -1 tells that no invalid entries were // found. }; } // namespace NewOS diff --git a/Private/Builtins/AHCI/Defines.hxx b/Private/Builtins/AHCI/Defines.hxx index 44a19f38..afec2778 100644 --- a/Private/Builtins/AHCI/Defines.hxx +++ b/Private/Builtins/AHCI/Defines.hxx @@ -315,7 +315,7 @@ typedef struct HbaCmdTbl final { /* EOF */ -#ifdef __KERNEL__ +#if defined(__AHCI__) /// @brief Initializes an AHCI disk. /// @param PortsImplemented the amount of port that have been detected. @@ -324,10 +324,22 @@ NewOS::Boolean drv_std_init(NewOS::UInt16& PortsImplemented); NewOS::Boolean drv_std_detected(NewOS::Void); -NewOS::Void drv_std_read(NewOS::UInt64 Lba, NewOS::UInt16 IO, NewOS::UInt8 Master, NewOS::Char* Buf, +/// @brief Read from disk. +/// @param Lba +/// @param Buf +/// @param SectorSz +/// @param Size +/// @return +NewOS::Void drv_std_read(NewOS::UInt64 Lba, NewOS::Char* Buf, NewOS::SizeT SectorSz, NewOS::SizeT Size); -NewOS::Void drv_std_write(NewOS::UInt64 Lba, NewOS::UInt16 IO, NewOS::UInt8 Master, NewOS::Char* Buf, +/// @brief Write to disk. +/// @param Lba +/// @param Buf +/// @param SectorSz +/// @param Size +/// @return +NewOS::Void drv_std_write(NewOS::UInt64 Lba, NewOS::Char* Buf, NewOS::SizeT SectorSz, NewOS::SizeT Size); #endif // ifdef __KERNEL__ diff --git a/Private/Builtins/ATA/Defines.hxx b/Private/Builtins/ATA/Defines.hxx index c8a87384..9eed6039 100644 --- a/Private/Builtins/ATA/Defines.hxx +++ b/Private/Builtins/ATA/Defines.hxx @@ -118,7 +118,7 @@ ///! ATA command register. #define ATA_COMMAND(x) (x + 7) -#define kATASectorSize 512 +#define kATASectorSize (512U) enum { kATADevicePATA, @@ -128,7 +128,7 @@ enum { kATADeviceCount, }; -#ifdef __KERNEL__ +#if defined(__ATA_PIO__) || defined(__ATA_DMA__) NewOS::Boolean drv_std_init(NewOS::UInt16 Bus, NewOS::UInt8 Drive, NewOS::UInt16& OutBus, NewOS::UInt8& OutMaster); diff --git a/Private/CFKit/GUIDWrapper.hpp b/Private/CFKit/GUIDWrapper.hpp index 8a71c614..62bc6d73 100644 --- a/Private/CFKit/GUIDWrapper.hpp +++ b/Private/CFKit/GUIDWrapper.hpp @@ -23,10 +23,10 @@ union GUIDSequence { alignas(8) ULong u64[2]; struct { - alignas(8) UInt m_Ms1; - UShort m_Ms2; - UShort m_Ms3; - UChar m_Ms4[8]; + alignas(8) UInt fMs1; + UShort fMs2; + UShort fMs3; + UChar fMs4[8]; }; }; @@ -40,10 +40,10 @@ class GUID final { GUID(const GUID &) = default; public: - GUIDSequence &operator->() noexcept { return m_UUID; } - GUIDSequence &Leak() noexcept { return m_UUID; } + GUIDSequence &operator->() noexcept { return fUUID; } + GUIDSequence &Leak() noexcept { return fUUID; } private: - GUIDSequence m_UUID; + GUIDSequence fUUID; }; } // namespace NewOS::XRN diff --git a/Private/CFKit/Property.hpp b/Private/CFKit/Property.hpp index 84b4ed64..243580fc 100644 --- a/Private/CFKit/Property.hpp +++ b/Private/CFKit/Property.hpp @@ -17,7 +17,7 @@ using PropertyId = Int; class Property { public: - explicit Property(const StringView &sw) : m_sName(sw) {} + explicit Property(const StringView &sw) : fsName(sw) {} virtual ~Property() = default; @@ -29,8 +29,8 @@ class Property { const PropertyId &GetPropertyById(); private: - Ref<StringView> m_sName; - PropertyId m_Action; + Ref<StringView> fsName; + PropertyId fAction; }; template <SSizeT N> diff --git a/Private/CFKit/URL.hpp b/Private/CFKit/URL.hpp index 4131247c..748b3cf0 100644 --- a/Private/CFKit/URL.hpp +++ b/Private/CFKit/URL.hpp @@ -21,7 +21,7 @@ class Url final { Ref<ErrorOr<StringView>> Protocol() noexcept; private: - Ref<StringView> m_urlView; + Ref<StringView> fUrlView; }; ErrorOr<StringView> url_extract_location(const char *url); diff --git a/Private/HALKit/AMD64/HalACPIFactoryInterface.cxx b/Private/HALKit/AMD64/HalACPIFactoryInterface.cxx index 4d1844d9..983c7219 100644 --- a/Private/HALKit/AMD64/HalACPIFactoryInterface.cxx +++ b/Private/HALKit/AMD64/HalACPIFactoryInterface.cxx @@ -21,8 +21,8 @@ void rt_shutdown_acpi_virtualbox(void) { HAL::Out16(0x4004, 0x3400); } /// You have to parse the MADT! ACPIFactoryInterface::ACPIFactoryInterface(voidPtr rsdPtr) - : m_Rsdp(rsdPtr), m_Entries(0) { - volatile RSDP *_rsdPtr = reinterpret_cast<volatile RSDP *>(this->m_Rsdp); + : fRsdp(rsdPtr), fEntries(0) { + volatile RSDP *_rsdPtr = reinterpret_cast<volatile RSDP *>(this->fRsdp); MUST_PASS(_rsdPtr); MUST_PASS(_rsdPtr->Revision >= 2); @@ -48,13 +48,13 @@ Void ACPIFactoryInterface::Reboot() { /// @brief Finds a descriptor table inside ACPI XSDT. ErrorOr<voidPtr> ACPIFactoryInterface::Find(const char *signature) { - MUST_PASS(m_Rsdp); + MUST_PASS(fRsdp); if (!signature) return ErrorOr<voidPtr>{-2}; if (*signature == 0) return ErrorOr<voidPtr>{-3}; - RSDP *rsdPtr = reinterpret_cast<RSDP *>(this->m_Rsdp); + RSDP *rsdPtr = reinterpret_cast<RSDP *>(this->fRsdp); if (rsdPtr->Revision <= 1) { return ErrorOr<voidPtr>{-4}; diff --git a/Private/HALKit/AMD64/PCI/Device.cxx b/Private/HALKit/AMD64/PCI/Device.cxx index f5f1d602..f6bf75da 100644 --- a/Private/HALKit/AMD64/PCI/Device.cxx +++ b/Private/HALKit/AMD64/PCI/Device.cxx @@ -31,59 +31,59 @@ void NewOSPCISetCfgTarget(NewOS::UInt bar, NewOS::UShort bus, NewOS::UShort dev, namespace NewOS::PCI { Device::Device(UShort bus, UShort device, UShort func, UShort bar) - : m_Bus(bus), m_Device(device), m_Function(func), m_Bar(bar) {} + : fBus(bus), fDevice(device), fFunction(func), fBar(bar) {} Device::~Device() {} UInt Device::Read(UInt bar, Size sz) { - NewOSPCISetCfgTarget(bar, m_Bus, m_Device, m_Function); + NewOSPCISetCfgTarget(bar, fBus, fDevice, fFunction); if (sz == 4) - return HAL::In32((UShort)PciConfigKind::ConfigData + (m_Bar & 3)); + return HAL::In32((UShort)PciConfigKind::ConfigData + (fBar & 3)); if (sz == 2) - return HAL::In16((UShort)PciConfigKind::ConfigData + (m_Bar & 3)); - if (sz == 1) return HAL::In8((UShort)PciConfigKind::ConfigData + (m_Bar & 3)); + return HAL::In16((UShort)PciConfigKind::ConfigData + (fBar & 3)); + if (sz == 1) return HAL::In8((UShort)PciConfigKind::ConfigData + (fBar & 3)); return 0xFFFF; } void Device::Write(UInt bar, UIntPtr data, Size sz) { - NewOSPCISetCfgTarget(bar, m_Bus, m_Device, m_Function); + NewOSPCISetCfgTarget(bar, fBus, fDevice, fFunction); if (sz == 4) - HAL::Out32((UShort)PciConfigKind::ConfigData + (m_Bar & 3), (UInt)data); + HAL::Out32((UShort)PciConfigKind::ConfigData + (fBar & 3), (UInt)data); if (sz == 2) - HAL::Out16((UShort)PciConfigKind::ConfigData + (m_Bar & 3), (UShort)data); + HAL::Out16((UShort)PciConfigKind::ConfigData + (fBar & 3), (UShort)data); if (sz == 1) - HAL::Out8((UShort)PciConfigKind::ConfigData + (m_Bar & 3), (UChar)data); + HAL::Out8((UShort)PciConfigKind::ConfigData + (fBar & 3), (UChar)data); } UShort Device::DeviceId() { - return (UShort)(NewOSPCIReadRaw(0x0 >> 16, m_Bus, m_Device, m_Function)); + return (UShort)(NewOSPCIReadRaw(0x0 >> 16, fBus, fDevice, fFunction)); } UShort Device::VendorId() { - return (UShort)(NewOSPCIReadRaw(0x0, m_Bus, m_Device, m_Function) >> 16); + return (UShort)(NewOSPCIReadRaw(0x0, fBus, fDevice, fFunction) >> 16); } UShort Device::InterfaceId() { - return (UShort)(NewOSPCIReadRaw(0x0, m_Bus, m_Device, m_Function) >> 16); + return (UShort)(NewOSPCIReadRaw(0x0, fBus, fDevice, fFunction) >> 16); } UChar Device::Class() { - return (UChar)(NewOSPCIReadRaw(0x08, m_Bus, m_Device, m_Function) >> 24); + return (UChar)(NewOSPCIReadRaw(0x08, fBus, fDevice, fFunction) >> 24); } UChar Device::Subclass() { - return (UChar)(NewOSPCIReadRaw(0x08, m_Bus, m_Device, m_Function) >> 16); + return (UChar)(NewOSPCIReadRaw(0x08, fBus, fDevice, fFunction) >> 16); } UChar Device::ProgIf() { - return (UChar)(NewOSPCIReadRaw(0x08, m_Bus, m_Device, m_Function) >> 8); + return (UChar)(NewOSPCIReadRaw(0x08, fBus, fDevice, fFunction) >> 8); } UChar Device::HeaderType() { - return (UChar)(NewOSPCIReadRaw(0xC, m_Bus, m_Device, m_Function) >> 16); + return (UChar)(NewOSPCIReadRaw(0xC, fBus, fDevice, fFunction) >> 16); } void Device::EnableMmio() { @@ -100,9 +100,9 @@ UShort Device::Vendor() { UShort vendor = VendorId(); if (vendor != (UShort)PciConfigKind::Invalid) - m_Device = (UShort)Read(0x0, sizeof(UShort)); + fDevice = (UShort)Read(0x0, sizeof(UShort)); - return m_Device; + return fDevice; } Device::operator bool() { return VendorId() != (UShort)PciConfigKind::Invalid; } diff --git a/Private/HALKit/AMD64/PCI/Dma.cxx b/Private/HALKit/AMD64/PCI/Dma.cxx index 1efef53b..f0a10eb9 100644 --- a/Private/HALKit/AMD64/PCI/Dma.cxx +++ b/Private/HALKit/AMD64/PCI/Dma.cxx @@ -7,36 +7,36 @@ #include <KernelKit/PCI/Dma.hpp> namespace NewOS { -DMAWrapper::operator bool() { return m_Address; } +DMAWrapper::operator bool() { return fAddress; } -bool DMAWrapper::operator!() { return !m_Address; } +bool DMAWrapper::operator!() { return !fAddress; } Boolean DMAWrapper::Check(UIntPtr offset) const { - if (!m_Address) return false; + if (!fAddress) return false; if (offset == 0) return true; kcout << "[DMAWrapper::IsIn] Checking offset..\n"; - return reinterpret_cast<UIntPtr>(m_Address) >= offset; + return reinterpret_cast<UIntPtr>(fAddress) >= offset; } bool DMAWrapper::Write(const UIntPtr &bit, const UIntPtr &offset) { - if (!m_Address) return false; + if (!fAddress) return false; kcout << "[DMAWrapper::Write] Writing at address..\n"; auto addr = - (volatile UIntPtr *)(reinterpret_cast<UIntPtr>(m_Address) + offset); + (volatile UIntPtr *)(reinterpret_cast<UIntPtr>(fAddress) + offset); *addr = bit; return true; } UIntPtr DMAWrapper::Read(const UIntPtr &offset) { - kcout << "[DMAWrapper::Read] checking m_Address..\n"; - if (!m_Address) return 0; + kcout << "[DMAWrapper::Read] checking fAddress..\n"; + if (!fAddress) return 0; - kcout << "[DMAWrapper::Read] Reading m_Address..\n"; - return *(volatile UIntPtr *)(reinterpret_cast<UIntPtr>(m_Address) + offset); + kcout << "[DMAWrapper::Read] Reading fAddress..\n"; + return *(volatile UIntPtr *)(reinterpret_cast<UIntPtr>(fAddress) + offset); ; } @@ -48,7 +48,7 @@ OwnPtr<IOBuf<Char *>> DMAFactory::Construct(OwnPtr<DMAWrapper> &dma) { if (!dma) return {}; OwnPtr<IOBuf<Char *>> dmaOwnPtr = - make_ptr<IOBuf<Char *>, char *>(reinterpret_cast<char *>(dma->m_Address)); + make_ptr<IOBuf<Char *>, char *>(reinterpret_cast<char *>(dma->fAddress)); if (!dmaOwnPtr) return {}; @@ -57,7 +57,7 @@ OwnPtr<IOBuf<Char *>> DMAFactory::Construct(OwnPtr<DMAWrapper> &dma) { } DMAWrapper &DMAWrapper::operator=(voidPtr Ptr) { - m_Address = Ptr; + fAddress = Ptr; return *this; } } // namespace NewOS diff --git a/Private/HALKit/AMD64/PCI/Iterator.cxx b/Private/HALKit/AMD64/PCI/Iterator.cxx index 151d8780..25e83ada 100644 --- a/Private/HALKit/AMD64/PCI/Iterator.cxx +++ b/Private/HALKit/AMD64/PCI/Iterator.cxx @@ -18,7 +18,7 @@ Iterator::Iterator(const Types::PciDeviceKind &type) { Device dev(bus, device, function, 0); if (dev.Class() == (UChar)type) { - m_Devices[bus].Leak().Leak() = dev; + fDevices[bus].Leak().Leak() = dev; } } } @@ -28,7 +28,7 @@ Iterator::Iterator(const Types::PciDeviceKind &type) { Iterator::~Iterator() {} Ref<PCI::Device> Iterator::operator[](const Size &sz) { - PCI_ITERATOR_FIND_AND_UNWRAP(m_Devices[sz], sz); + PCI_ITERATOR_FIND_AND_UNWRAP(fDevices[sz], sz); return {}; } } // namespace NewOS::PCI diff --git a/Private/HALKit/AMD64/Processor.hpp b/Private/HALKit/AMD64/Processor.hpp index 472fd6df..a2aaf8f7 100644 --- a/Private/HALKit/AMD64/Processor.hpp +++ b/Private/HALKit/AMD64/Processor.hpp @@ -172,7 +172,6 @@ struct PACKED ALIGN(0x1000) NewOSGDT final { } // namespace Detail } // namespace NewOS::HAL -EXTERN_C void idt_handle_system_call(NewOS::UIntPtr rsp); EXTERN_C void idt_handle_generic(NewOS::UIntPtr rsp); EXTERN_C void idt_handle_gpf(NewOS::UIntPtr rsp); EXTERN_C void idt_handle_math(NewOS::UIntPtr rsp); diff --git a/Private/HALKit/AMD64/Storage/AHCI.cxx b/Private/HALKit/AMD64/Storage/AHCI.cxx index 35308582..2b58b744 100644 --- a/Private/HALKit/AMD64/Storage/AHCI.cxx +++ b/Private/HALKit/AMD64/Storage/AHCI.cxx @@ -49,11 +49,9 @@ NewOS::Boolean drv_std_detected(NewOS::Void) { return kAhciDevice.DeviceId() != 0xFFFF; } -NewOS::Void drv_std_read(NewOS::UInt64 Lba, NewOS::UInt16 IO, - NewOS::UInt8 Master, NewOS::Char* Buf, +NewOS::Void drv_std_read(NewOS::UInt64 Lba, NewOS::Char* Buf, NewOS::SizeT SectorSz, NewOS::SizeT Size) {} -NewOS::Void drv_std_write(NewOS::UInt64 Lba, NewOS::UInt16 IO, - NewOS::UInt8 Master, NewOS::Char* Buf, +NewOS::Void drv_std_write(NewOS::UInt64 Lba, NewOS::Char* Buf, NewOS::SizeT SectorSz, NewOS::SizeT Size) {} #endif // __AHCI__
\ No newline at end of file diff --git a/Private/HALKit/AMD64/Storage/ATA-DMA.cxx b/Private/HALKit/AMD64/Storage/ATA-DMA.cxx index d3e90f67..523c7e17 100644 --- a/Private/HALKit/AMD64/Storage/ATA-DMA.cxx +++ b/Private/HALKit/AMD64/Storage/ATA-DMA.cxx @@ -23,6 +23,7 @@ using namespace NewOS; EXTERN_C Int32 kPRDTTransferStatus; +STATIC PRDT kPRDT; #ifdef __ATA_DMA__ diff --git a/Private/KernelKit/DeviceManager.hpp b/Private/KernelKit/DeviceManager.hpp index 0935c5b3..490ebc71 100644 --- a/Private/KernelKit/DeviceManager.hpp +++ b/Private/KernelKit/DeviceManager.hpp @@ -34,7 +34,7 @@ template <typename T> class DeviceInterface { public: explicit DeviceInterface(void (*Out)(T), void (*In)(T)) - : m_Out(Out), m_In(In) {} + : fOut(Out), fIn(In) {} virtual ~DeviceInterface() = default; @@ -44,23 +44,23 @@ class DeviceInterface { public: virtual DeviceInterface<T> &operator<<(T Data) { - m_Out(Data); + fOut(Data); return *this; } virtual DeviceInterface<T> &operator>>(T Data) { - m_In(Data); + fIn(Data); return *this; } virtual const char *Name() const { return "DeviceInterface"; } - operator bool() { return m_Out && m_In; } - bool operator!() { return !m_Out && !m_In; } + operator bool() { return fOut && fIn; } + bool operator!() { return !fOut && !fIn; } private: - void (*m_Out)(T Data); - void (*m_In)(T Data); + void (*fOut)(T Data); + void (*fIn)(T Data); }; /// @@ -70,7 +70,7 @@ class DeviceInterface { template <typename T> class IOBuf final { public: - explicit IOBuf(T Dat) : m_Data(Dat) { + explicit IOBuf(T Dat) : fData(Dat) { // at least pass something valid when instancating this struct. MUST_PASS(Dat); } @@ -83,16 +83,16 @@ class IOBuf final { public: template <typename R> R operator->() const { - return m_Data; + return fData; } template <typename R> R &operator[](Size index) const { - return m_Data[index]; + return fData[index]; } private: - T m_Data; + T fData; }; ///! @brief Device enum types. diff --git a/Private/KernelKit/Framebuffer.hpp b/Private/KernelKit/Framebuffer.hpp index 91b4e8fd..39b1eb5e 100644 --- a/Private/KernelKit/Framebuffer.hpp +++ b/Private/KernelKit/Framebuffer.hpp @@ -20,16 +20,16 @@ enum class FramebufferColorKind : UChar { class FramebufferContext final { public: - UIntPtr m_Base; - UIntPtr m_Bpp; - UInt m_Width; - UInt m_Height; + UIntPtr fBase; + UIntPtr fBpp; + UInt fWidth; + UInt fHeight; }; class Framebuffer final { public: explicit Framebuffer(Ref<FramebufferContext *> &addr) - : m_FrameBufferAddr(addr) {} + : fFrameBufferAddr(addr) {} ~Framebuffer() {} Framebuffer &operator=(const Framebuffer &) = delete; @@ -62,8 +62,8 @@ class Framebuffer final { Framebuffer &PutPixel(SizeT x, SizeT y, UInt32 color); private: - Ref<FramebufferContext *> m_FrameBufferAddr; - FramebufferColorKind m_Colour; + Ref<FramebufferContext *> fFrameBufferAddr; + FramebufferColorKind fColour; }; /***********************************************************************************/ diff --git a/Private/KernelKit/LockDelegate.hpp b/Private/KernelKit/LockDelegate.hpp index 07f492a8..3b4889c9 100644 --- a/Private/KernelKit/LockDelegate.hpp +++ b/Private/KernelKit/LockDelegate.hpp @@ -34,13 +34,13 @@ class LockDelegate final { if (*expr) { - m_LockStatus | kLockDone; + fLockStatus | kLockDone; break; } } if (spin == N) - m_LockStatus | kLockTimedOut; + fLockStatus | kLockTimedOut; } ~LockDelegate() = default; @@ -50,15 +50,15 @@ class LockDelegate final bool Done() { - return m_LockStatus[kLockDone] == kLockDone; + return fLockStatus[kLockDone] == kLockDone; } bool HasTimedOut() { - return m_LockStatus[kLockTimedOut] != kLockTimedOut; + return fLockStatus[kLockTimedOut] != kLockTimedOut; } private: - Atom<UInt> m_LockStatus; + Atom<UInt> fLockStatus; }; } // namespace NewOS diff --git a/Private/KernelKit/PCI/Device.hpp b/Private/KernelKit/PCI/Device.hpp index 9bb22cb2..ea11e327 100644 --- a/Private/KernelKit/PCI/Device.hpp +++ b/Private/KernelKit/PCI/Device.hpp @@ -68,10 +68,10 @@ namespace NewOS::PCI UShort Vendor(); private: - UShort m_Bus; - UShort m_Device; - UShort m_Function; - UShort m_Bar; + UShort fBus; + UShort fDevice; + UShort fFunction; + UShort fBar; }; } // namespace NewOS::PCI diff --git a/Private/KernelKit/PCI/Dma.hpp b/Private/KernelKit/PCI/Dma.hpp index 1e1b5036..392aeee3 100644 --- a/Private/KernelKit/PCI/Dma.hpp +++ b/Private/KernelKit/PCI/Dma.hpp @@ -28,7 +28,7 @@ class DMAWrapper final { public: explicit DMAWrapper(nullPtr) = delete; explicit DMAWrapper(voidPtr Ptr, DmaKind Kind = DmaKind::PCI) - : m_Address(Ptr), m_Kind(Kind) {} + : fAddress(Ptr), fKind(Kind) {} public: DMAWrapper &operator=(voidPtr Ptr); @@ -59,8 +59,8 @@ class DMAWrapper final { UIntPtr operator[](const UIntPtr &offset); private: - voidPtr m_Address{nullptr}; - DmaKind m_Kind{DmaKind::Invalid}; + voidPtr fAddress{nullptr}; + DmaKind fKind{DmaKind::Invalid}; private: friend class DMAFactory; diff --git a/Private/KernelKit/PCI/Dma.inl b/Private/KernelKit/PCI/Dma.inl index 5f7e1379..846785a1 100644 --- a/Private/KernelKit/PCI/Dma.inl +++ b/Private/KernelKit/PCI/Dma.inl @@ -9,12 +9,12 @@ namespace NewOS template<class T> T* DMAWrapper::operator->() { - return m_Address; + return fAddress; } template<class T> T* DMAWrapper::Get(const UIntPtr offset) { - return reinterpret_cast<T*>((UIntPtr) m_Address + offset); + return reinterpret_cast<T*>((UIntPtr) fAddress + offset); } } diff --git a/Private/KernelKit/PCI/IO-Impl-AMD64.inl b/Private/KernelKit/PCI/IO-Impl-AMD64.inl index 195ebca1..bf7b98d4 100644 --- a/Private/KernelKit/PCI/IO-Impl-AMD64.inl +++ b/Private/KernelKit/PCI/IO-Impl-AMD64.inl @@ -18,11 +18,11 @@ template <typename T> T IOArray<Sz>::In(SizeT index) { switch (sizeof(T)) { case 4: - return HAL::In32(m_Ports[index].Leak()); + return HAL::In32(fPorts[index].Leak()); case 2: - return HAL::In16(m_Ports[index].Leak()); + return HAL::In16(fPorts[index].Leak()); case 1: - return HAL::In8(m_Ports[index].Leak()); + return HAL::In8(fPorts[index].Leak()); default: return 0xFFFF; } @@ -34,11 +34,11 @@ void IOArray<Sz>::Out(SizeT index, T value) { switch (sizeof(T)) { #ifdef __x86_64__ case 4: - HAL::Out32(m_Ports[index].Leak(), value); + HAL::Out32(fPorts[index].Leak(), value); case 2: - HAL::Out16(m_Ports[index].Leak(), value); + HAL::Out16(fPorts[index].Leak(), value); case 1: - HAL::Out8(m_Ports[index].Leak(), value); + HAL::Out8(fPorts[index].Leak(), value); #endif default: break; diff --git a/Private/KernelKit/PCI/IO.hpp b/Private/KernelKit/PCI/IO.hpp index 87a29b78..a0ee51dc 100644 --- a/Private/KernelKit/PCI/IO.hpp +++ b/Private/KernelKit/PCI/IO.hpp @@ -19,14 +19,14 @@ class IOArray final { IOArray(nullPtr) = delete; - explicit IOArray(Array<UShort, Sz> &ports) : m_Ports(ports) {} + explicit IOArray(Array<UShort, Sz> &ports) : fPorts(ports) {} ~IOArray() {} IOArray &operator=(const IOArray &) = default; IOArray(const IOArray &) = default; - operator bool() { return !m_Ports.Empty(); } + operator bool() { return !fPorts.Empty(); } public: template <typename T> @@ -36,7 +36,7 @@ class IOArray final { void Out(SizeT index, T value); private: - Array<UShort, Sz> m_Ports; + Array<UShort, Sz> fPorts; }; using IOArray16 = IOArray<16>; diff --git a/Private/KernelKit/PCI/Iterator.hpp b/Private/KernelKit/PCI/Iterator.hpp index 7f17263d..b81aae74 100644 --- a/Private/KernelKit/PCI/Iterator.hpp +++ b/Private/KernelKit/PCI/Iterator.hpp @@ -29,7 +29,7 @@ namespace NewOS::PCI { Ref<PCI::Device> operator[](const Size &sz); private: - Array<PCI::Device, NEWOS_BUS_COUNT> m_Devices; + Array<PCI::Device, NEWOS_BUS_COUNT> fDevices; }; } // namespace NewOS::PCI diff --git a/Private/KernelKit/SMPManager.hpp b/Private/KernelKit/SMPManager.hpp index 42cd572e..631b29ea 100644 --- a/Private/KernelKit/SMPManager.hpp +++ b/Private/KernelKit/SMPManager.hpp @@ -60,12 +60,12 @@ class HardwareThread final { const ThreadID& ID() noexcept; private: - HAL::StackFrame* m_Stack; - ThreadKind m_Kind; - ThreadID m_ID; - bool m_Wakeup; - bool m_Busy; - Int64 m_PID; + HAL::StackFrame* fStack; + ThreadKind fKind; + ThreadID fID; + bool fWakeup; + bool fBusy; + Int64 fPID; private: friend class SMPManager; @@ -106,8 +106,8 @@ class SMPManager final { SizeT Count() noexcept; private: - Array<HardwareThread, kMaxHarts> m_ThreadList; - ThreadID m_CurrentThread{0}; + Array<HardwareThread, kMaxHarts> fThreadList; + ThreadID fCurrentThread{0}; }; /// @brief wakes up thread. diff --git a/Private/NetworkKit/IP.hpp b/Private/NetworkKit/IP.hpp index 3d7119da..b8876aaa 100644 --- a/Private/NetworkKit/IP.hpp +++ b/Private/NetworkKit/IP.hpp @@ -33,7 +33,7 @@ class RawIPAddress final { bool operator!=(const RawIPAddress &ipv6); private: - char m_Addr[4]; + char fAddr[4]; friend IPFactory; // it is the one creating these addresses, thus this // is why the constructors are private. @@ -51,7 +51,7 @@ class RawIPAddress6 final { RawIPAddress6(const RawIPAddress6 &) = default; public: - char *Address() { return m_Addr; } + char *Address() { return fAddr; } char &operator[](const Size &index); @@ -59,7 +59,7 @@ class RawIPAddress6 final { bool operator!=(const RawIPAddress6 &ipv6); private: - char m_Addr[8]; + char fAddr[8]; friend IPFactory; }; diff --git a/Private/NewBoot/Source/HEL/AMD64/BootEPM.cxx b/Private/NewBoot/Source/HEL/AMD64/BootEPM.cxx index 133429c5..0d678dc1 100644 --- a/Private/NewBoot/Source/HEL/AMD64/BootEPM.cxx +++ b/Private/NewBoot/Source/HEL/AMD64/BootEPM.cxx @@ -7,8 +7,9 @@ #include <BootKit/BootKit.hxx> #include <FSKit/NewFS.hxx> +#define kEPMSectorSize kATASectorSize #define kEPMSwapSize MIB(16) -#define kEPMGPTStartLba 30 +#define kEPMGPTStartLba (30) // {310E1FC7-2060-425D-BE7B-75A37CC679BC} STATIC const BlockGUID kEPMGuid = { @@ -28,19 +29,19 @@ EXTERN_C Boolean boot_write_epm_partition(const Char* namePart, SizeT namePartLe if (!bootDev) return No; bootDev->Leak().mBase = kEPMGPTStartLba; - bootDev->Leak().mSize = kATASectorSize; + bootDev->Leak().mSize = kEPMSectorSize; - Char buf[kATASectorSize] = {0}; + Char buf[kEPMSectorSize] = {0}; bootDev->Read(buf, 1); BTextWriter writer; - writer.Write(L"NewOS: Checking for a NewFS partition...\r\n"); + writer.Write(L"NewOS: Checking for a EPM partition...\r\n"); for (SizeT index = 0; index < kEPMMagicLength; ++index) { if (buf[index] != kEPMMagic[index]) { - writer.Write(L"NewOS: Writing a NewFS partition...\r\n"); + writer.Write(L"NewOS: Writing a EPM partition...\r\n"); BootBlockType* bootBlock = (BootBlockType*)buf; @@ -58,7 +59,7 @@ EXTERN_C Boolean boot_write_epm_partition(const Char* namePart, SizeT namePartLe bootBlock->LbaStart = sizeof(BootBlockType) + (sizeof(PartitionBlockType) * kEPMMaxBlks); - bootBlock->SectorSz = kATASectorSize; + bootBlock->SectorSz = kEPMSectorSize; bootBlock->Uuid = kEPMGuid; @@ -80,7 +81,7 @@ EXTERN_C Boolean boot_write_epm_partition(const Char* namePart, SizeT namePartLe partBlock->Name[i] = partNameSystem[i]; } - partBlock->SectorSz = kATASectorSize; + partBlock->SectorSz = kEPMSectorSize; partBlock->LbaStart = kEPMStartPartitionBlk + kEPMSwapSize; partBlock->Version = kNewFSVersionInteger; partBlock->Kind = kNewFSPartitionTypeStandard; @@ -101,7 +102,7 @@ EXTERN_C Boolean boot_write_epm_partition(const Char* namePart, SizeT namePartLe swapBlock->Name[i] = partNameSwap[i]; } - swapBlock->SectorSz = kATASectorSize; + swapBlock->SectorSz = kEPMSectorSize; swapBlock->LbaStart = kEPMStartPartitionBlk; swapBlock->Version = kNewFSVersionInteger; swapBlock->Kind = kNewFSPartitionTypePage; diff --git a/Private/NewBoot/Source/HEL/PowerPC/BootEPM.cxx b/Private/NewBoot/Source/HEL/PowerPC/BootEPM.cxx index 2e35b0dc..f088d73c 100644 --- a/Private/NewBoot/Source/HEL/PowerPC/BootEPM.cxx +++ b/Private/NewBoot/Source/HEL/PowerPC/BootEPM.cxx @@ -7,8 +7,7 @@ #include <BootKit/BootKit.hxx> #include <FSKit/NewFS.hxx> -#define kEPMSectorSize 1024 - +#define kEPMSectorSize (1024U) #define kEPMSwapSize MIB(16) // {310E1FC7-2060-425D-BE7B-75A37CC679BC} @@ -37,11 +36,11 @@ EXTERN_C Boolean boot_write_epm_partition(const Char* namePart, SizeT namePartLe BTextWriter writer; - writer.Write(L"NewOS: Checking for a NewFS partition...\r\n"); + writer.Write(L"NewOS: Checking for a EPM partition...\r\n"); for (SizeT index = 0; index < kEPMMagicLength; ++index) { if (buf[index] != kEPMMagic[index]) { - writer.Write(L"NewOS: Writing a NewFS partition...\r\n"); + writer.Write(L"NewOS: Writing a EPM partition...\r\n"); BootBlockType* bootBlock = (BootBlockType*)buf; diff --git a/Private/NewKit/Array.hpp b/Private/NewKit/Array.hpp index a892f1a7..6724d8a9 100644 --- a/Private/NewKit/Array.hpp +++ b/Private/NewKit/Array.hpp @@ -27,12 +27,12 @@ public: return {}; kcout << "Returning element\r\n"; - return ErrorOr<T>(m_Array[At]); + return ErrorOr<T>(fArray[At]); } Boolean Empty() const { - for (auto Val : m_Array) + for (auto Val : fArray) { if (Val) return false; @@ -44,7 +44,7 @@ public: SizeT Count() const { SizeT cntElems = 0UL; - for (auto Val : m_Array) + for (auto Val : fArray) { if (Val) ++cntElems; @@ -55,7 +55,7 @@ public: const T *CData() { - return m_Array; + return fArray; } operator bool() @@ -64,7 +64,7 @@ public: } private: - T m_Array[N]; + T fArray[N]; }; } // namespace NewOS diff --git a/Private/NewKit/ArrayList.hpp b/Private/NewKit/ArrayList.hpp index ef6889ea..b7ab50cf 100644 --- a/Private/NewKit/ArrayList.hpp +++ b/Private/NewKit/ArrayList.hpp @@ -15,7 +15,7 @@ namespace NewOS { public: explicit ArrayList(T *list) - : m_List(reinterpret_cast<T>(list)) + : fList(reinterpret_cast<T>(list)) {} ~ArrayList() = default; @@ -25,26 +25,26 @@ namespace NewOS T *Data() { - return m_List; + return fList; } const T *CData() { - return m_List; + return fList; } T &operator[](int index) const { - return m_List[index]; + return fList[index]; } operator bool() { - return m_List; + return fList; } private: - T *m_List; + T *fList; friend class InitHelpers; diff --git a/Private/NewKit/Atom.hpp b/Private/NewKit/Atom.hpp index 34cbea51..648302fc 100644 --- a/Private/NewKit/Atom.hpp +++ b/Private/NewKit/Atom.hpp @@ -22,11 +22,11 @@ template <typename T> class Atom final public: T operator[](Size sz) { - return (m_ArrayOfAtoms & sz); + return (fArrayOfAtoms & sz); } void operator|(Size sz) { - m_ArrayOfAtoms |= sz; + fArrayOfAtoms |= sz; } friend Boolean operator==(Atom<T> &atomic, const T &idx) @@ -40,6 +40,6 @@ template <typename T> class Atom final } private: - T m_ArrayOfAtoms; + T fArrayOfAtoms; }; } // namespace NewOS diff --git a/Private/NewKit/Function.hpp b/Private/NewKit/Function.hpp index 63bc31dc..79d33a3b 100644 --- a/Private/NewKit/Function.hpp +++ b/Private/NewKit/Function.hpp @@ -10,7 +10,7 @@ class Function final { Function() = default; public: - explicit Function(T (*Fn)(Args... args)) : m_Fn(Fn) {} + explicit Function(T (*Fn)(Args... args)) : fFn(Fn) {} ~Function() = default; @@ -19,20 +19,20 @@ class Function final { template <typename... XArgs> T operator()(Args... args) { - return m_Fn(args...); + return fFn(args...); } template <typename... XArgs> T Call(Args... args) { - return m_Fn(args...); + return fFn(args...); } - operator bool() { return m_Fn; } + operator bool() { return fFn; } - bool operator!() { return !m_Fn; } + bool operator!() { return !fFn; } private: - T (*m_Fn)(Args... args); + T (*fFn)(Args... args); }; } // namespace NewOS diff --git a/Private/NewKit/MutableArray.hpp b/Private/NewKit/MutableArray.hpp index bdedb97f..b46f1bc7 100644 --- a/Private/NewKit/MutableArray.hpp +++ b/Private/NewKit/MutableArray.hpp @@ -13,9 +13,9 @@ auto *NAME = NODE; \ while (NAME) \ { \ - if (NAME->m_Index == Index) \ - return NAME->m_Val; \ - NAME = NAME->m_Next; \ + if (NAME->fIndex == Index) \ + return NAME->fVal; \ + NAME = NAME->fNext; \ } @@ -24,18 +24,18 @@ auto *NAME = NODE; \ while (NAME) \ { \ - if (NAME->m_Index == Index) \ - return Ref<T>{NAME->m_Val}; \ - NAME = NAME->m_Next; \ + if (NAME->fIndex == Index) \ + return Ref<T>{NAME->fVal}; \ + NAME = NAME->fNext; \ } #define TRY_REMOVE_NODE(NODE) \ - if (NODE && NODE->m_Index == Index) \ + if (NODE && NODE->fIndex == Index) \ { \ - NODE->m_Used = false; \ - NODE->m_Index = 0; \ + NODE->fUsed = false; \ + NODE->fIndex = 0; \ \ return true; \ } @@ -53,19 +53,19 @@ template <typename T, T _PlaceHolderValue> class NullableMutableArray; template <typename T> class MutableLinkedList { public: - T m_Val; - SizeT m_Index{0}; - Boolean m_Used{false}; + T fVal; + SizeT fIndex{0}; + Boolean fUsed{false}; - MutableLinkedList *m_Prev{nullptr}; - MutableLinkedList *m_Next{nullptr}; + MutableLinkedList *fPrev{nullptr}; + MutableLinkedList *fNext{nullptr}; }; template <typename T, T _PlaceHolderValue> class NullableMutableArray { public: // explicit this. - explicit NullableMutableArray() : m_FirstNode(new MutableLinkedList<T>()) {} + explicit NullableMutableArray() : fFirstNode(new MutableLinkedList<T>()) {} /* * We free all the nodes allocated by the array @@ -74,12 +74,12 @@ template <typename T, T _PlaceHolderValue> class NullableMutableArray virtual ~NullableMutableArray() { - auto *It = m_FirstNode; + auto *It = fFirstNode; MutableLinkedList<T> *NextIt = nullptr; while (It) { - NextIt = It->m_Next; + NextIt = It->fNext; delete It; It = NextIt; @@ -94,43 +94,43 @@ template <typename T, T _PlaceHolderValue> class NullableMutableArray public: T operator[](const SizeT &Index) const { - TRY_FIND_NODE(first, m_FirstNode); - TRY_FIND_NODE(last, m_LastNode); + TRY_FIND_NODE(first, fFirstNode); + TRY_FIND_NODE(last, fLastNode); return _PlaceHolderValue; } - SizeT Count() const { return m_NodeCount; } + SizeT Count() const { return fNodeCount; } public: Boolean Remove(const SizeT &Index) { - TRY_REMOVE_NODE(m_FirstNode); - TRY_REMOVE_NODE(m_LastNode); + TRY_REMOVE_NODE(fFirstNode); + TRY_REMOVE_NODE(fLastNode); return false; } Boolean Add(const T val) { - auto *iterationNode = m_FirstNode; + auto *iterationNode = fFirstNode; MUST_PASS(iterationNode); while (iterationNode) { - if (!iterationNode->m_Used) + if (!iterationNode->fUsed) { - iterationNode->m_Val = val; - iterationNode->m_Index = 0; + iterationNode->fVal = val; + iterationNode->fIndex = 0; - iterationNode->m_Used = true; + iterationNode->fUsed = true; - ++m_NodeCount; + ++fNodeCount; return true; } - iterationNode = iterationNode->m_Next; + iterationNode = iterationNode->fNext; } return false; @@ -138,11 +138,11 @@ template <typename T, T _PlaceHolderValue> class NullableMutableArray private: /* Avoid useless lookups */ - MutableLinkedList<T> *m_LastNode{nullptr}; - MutableLinkedList<T> *m_FirstNode{nullptr}; + MutableLinkedList<T> *fLastNode{nullptr}; + MutableLinkedList<T> *fFirstNode{nullptr}; /* Number of nodes inside of this dynamic array. */ - NewOS::SizeT m_NodeCount{0}; + NewOS::SizeT fNodeCount{0}; private: // don't remove that @@ -162,24 +162,24 @@ class MutableArray : public NullableMutableArray<voidPtr, nullptr> public: Boolean Add(const T val) { - auto *iterationNode = m_FirstNode; + auto *iterationNode = fFirstNode; MUST_PASS(iterationNode); while (iterationNode) { - if (!iterationNode->m_Used) + if (!iterationNode->fUsed) { - iterationNode->m_Val = val; - iterationNode->m_Index = 0; + iterationNode->fVal = val; + iterationNode->fIndex = 0; - iterationNode->m_Used = true; + iterationNode->fUsed = true; - ++m_NodeCount; + ++fNodeCount; return true; } - iterationNode = iterationNode->m_Next; + iterationNode = iterationNode->fNext; } return false; @@ -188,24 +188,24 @@ class MutableArray : public NullableMutableArray<voidPtr, nullptr> public: Ref<T> operator[](const SizeT &Index) const { - TRY_FIND_NODE2(first, m_FirstNode); - TRY_FIND_NODE2(last, m_LastNode); + TRY_FIND_NODE2(first, fFirstNode); + TRY_FIND_NODE2(last, fLastNode); return {}; } - SizeT Count() const { return m_NodeCount; } + SizeT Count() const { return fNodeCount; } bool Contains(T &value) noexcept { - MutableLinkedList<T> *first = m_FirstNode; + MutableLinkedList<T> *first = fFirstNode; while (first) { - if (first->m_Val == value && first->m_Used) + if (first->fVal == value && first->fUsed) return true; - first = first->m_Next; + first = first->fNext; } return false; @@ -213,10 +213,10 @@ class MutableArray : public NullableMutableArray<voidPtr, nullptr> private: /* Avoid useless lookups */ - MutableLinkedList<T> *m_LastNode{nullptr}; - MutableLinkedList<T> *m_FirstNode{nullptr}; + MutableLinkedList<T> *fLastNode{nullptr}; + MutableLinkedList<T> *fFirstNode{nullptr}; /* Number of nodes inside of this dynamic array. */ - NewOS::SizeT m_NodeCount{0}; + NewOS::SizeT fNodeCount{0}; }; } // namespace NewOS diff --git a/Private/NewKit/OwnPtr.hpp b/Private/NewKit/OwnPtr.hpp index e6d006ed..ff2b59e1 100644 --- a/Private/NewKit/OwnPtr.hpp +++ b/Private/NewKit/OwnPtr.hpp @@ -30,30 +30,30 @@ class OwnPtr final { public: template <typename... Args> bool New(Args &&...arg) { - if (m_Cls) { + if (fCls) { return false; } - m_Cls = new T(arg...); - return m_Cls; + fCls = new T(arg...); + return fCls; } void Delete() { - if (m_Cls) delete m_Cls; + if (fCls) delete fCls; - m_Cls = nullptr; + fCls = nullptr; } - T *operator->() const { return m_Cls; }; - T *Raw() { return m_Cls; } + T *operator->() const { return fCls; }; + T *Raw() { return fCls; } - Ref<T> AsRef() { return Ref<T>(m_Cls); } + Ref<T> AsRef() { return Ref<T>(fCls); } - operator bool() { return m_Cls; } - bool operator!() { return !m_Cls; } + operator bool() { return fCls; } + bool operator!() { return !fCls; } private: - T *m_Cls; + T *fCls; }; template <typename T, typename... Args> diff --git a/Private/NewKit/PageManager.hpp b/Private/NewKit/PageManager.hpp index 9aba5a6c..c8806c90 100644 --- a/Private/NewKit/PageManager.hpp +++ b/Private/NewKit/PageManager.hpp @@ -42,15 +42,15 @@ class PTEWrapper final { bool Access(); private: - Boolean m_Rw; - Boolean m_User; - Boolean m_ExecDisable; - UIntPtr m_VirtAddr; - Boolean m_Cache; - Boolean m_Shareable; - Boolean m_Wt; - Boolean m_Present; - Boolean m_Accessed; + Boolean fRw; + Boolean fUser; + Boolean fExecDisable; + UIntPtr fVirtAddr; + Boolean fCache; + Boolean fShareable; + Boolean fWt; + Boolean fPresent; + Boolean fAccessed; private: friend class PageManager; diff --git a/Private/NewKit/Pmm.hpp b/Private/NewKit/Pmm.hpp index ed43a03c..2ed8b753 100644 --- a/Private/NewKit/Pmm.hpp +++ b/Private/NewKit/Pmm.hpp @@ -31,9 +31,9 @@ class Pmm final { Boolean ToggleShare(Ref<PTEWrapper> refPage, Boolean enable = true); /// @brief Get the page manager of this. - Ref<PageManager> &Leak() { return m_PageManager; } + Ref<PageManager> &Leak() { return fPageManager; } private: - Ref<PageManager> m_PageManager; + Ref<PageManager> fPageManager; }; } // namespace NewOS diff --git a/Private/NewKit/Ref.hpp b/Private/NewKit/Ref.hpp index 4327081b..30e65e2f 100644 --- a/Private/NewKit/Ref.hpp +++ b/Private/NewKit/Ref.hpp @@ -18,27 +18,27 @@ class Ref final { ~Ref() = default; public: - Ref(T cls, const bool &strong = false) : m_Class(cls), m_Strong(strong) {} + Ref(T cls, const bool &strong = false) : fClass(cls), fStrong(strong) {} Ref &operator=(T ref) { - m_Class = ref; + fClass = ref; return *this; } public: - T operator->() const { return m_Class; } + T operator->() const { return fClass; } - T &Leak() { return m_Class; } + T &Leak() { return fClass; } - T operator*() { return m_Class; } + T operator*() { return fClass; } - bool IsStrong() const { return m_Strong; } + bool IsStrong() const { return fStrong; } - operator bool() { return m_Strong; } + operator bool() { return fStrong; } private: - T m_Class; - bool m_Strong{false}; + T fClass; + bool fStrong{false}; }; template <typename T> @@ -47,17 +47,17 @@ class NonNullRef final { NonNullRef() = delete; NonNullRef(nullPtr) = delete; - NonNullRef(T *ref) : m_Ref(ref, true) {} + NonNullRef(T *ref) : fRef(ref, true) {} Ref<T> &operator->() { - MUST_PASS(m_Ref); - return m_Ref; + MUST_PASS(fRef); + return fRef; } NonNullRef &operator=(const NonNullRef<T> &ref) = delete; NonNullRef(const NonNullRef<T> &ref) = default; private: - Ref<T> m_Ref{nullptr}; + Ref<T> fRef{nullptr}; }; } // namespace NewOS diff --git a/Private/NewKit/Stream.hpp b/Private/NewKit/Stream.hpp index 30e60939..67288191 100644 --- a/Private/NewKit/Stream.hpp +++ b/Private/NewKit/Stream.hpp @@ -17,7 +17,7 @@ namespace NewOS { public: explicit Stream(Ref<Stream> ref) - : m_Stream(ref) + : fStream(ref) {} ~Stream() = default; @@ -28,31 +28,31 @@ namespace NewOS template <typename Data> friend Stream<StreamTrait, Kind> &operator>>(Stream<StreamTrait, Kind> &Ks, Ref<Data>& Buf) { - Ks.m_Kind = Ks.m_Stream->In(Buf); + Ks.fKind = Ks.fStream->In(Buf); return *Ks; } template <typename Data> friend Stream<StreamTrait, Kind> &operator<<(Stream<StreamTrait, Kind> &Ks, Ref<Data>& Buf) { - Ks.m_Kind = Buf; - Ks.m_Stream->Out(Buf.Leak()); + Ks.fKind = Buf; + Ks.fStream->Out(Buf.Leak()); return *Ks; } Ref<StreamTrait> &AsStreamTrait() { - return m_Stream; + return fStream; } Ref<Kind>& AsType() { - return m_Kind; + return fKind; } private: - Ref<StreamTrait> m_Stream; - Ref<Kind> m_Kind; + Ref<StreamTrait> fStream; + Ref<Kind> fKind; }; } // namespace NewOS diff --git a/Private/NewKit/String.hpp b/Private/NewKit/String.hpp index 1806c32a..93dfc584 100644 --- a/Private/NewKit/String.hpp +++ b/Private/NewKit/String.hpp @@ -15,14 +15,14 @@ class StringView final { public: explicit StringView() = default; - explicit StringView(Size Sz) : m_Sz(Sz) { + explicit StringView(Size Sz) : fSz(Sz) { MUST_PASS(Sz > 1); - m_Data = new Char[Sz]; - MUST_PASS(m_Data); + fData = new Char[Sz]; + MUST_PASS(fData); } ~StringView() { - if (m_Data) delete[] m_Data; + if (fData) delete[] fData; } StringView &operator=(const StringView &) = default; @@ -41,14 +41,14 @@ class StringView final { StringView &operator+=(const Char *rhs); StringView &operator+=(const StringView &rhs); - operator bool() { return m_Data; } + operator bool() { return fData; } - bool operator!() { return m_Data; } + bool operator!() { return fData; } private: - Char *m_Data{nullptr}; - Size m_Sz{0}; - Size m_Cur{0}; + Char *fData{nullptr}; + Size fSz{0}; + Size fCur{0}; friend class StringBuilder; }; diff --git a/Private/NewKit/Utils.hpp b/Private/NewKit/Utils.hpp index 67ecaf22..749e15ba 100644 --- a/Private/NewKit/Utils.hpp +++ b/Private/NewKit/Utils.hpp @@ -24,5 +24,5 @@ Boolean is_space(Char chr); Int rt_to_uppercase(Int c); Int rt_to_lower(Int c); voidPtr rt_string_in_string(const char *in, const char *needle); -char *rt_string_from_char(char *str, const char chr); +char *rt_string_frofchar(char *str, const char chr); } // namespace NewOS diff --git a/Private/NewKit/Variant.hpp b/Private/NewKit/Variant.hpp index 109acbbe..c0738de2 100644 --- a/Private/NewKit/Variant.hpp +++ b/Private/NewKit/Variant.hpp @@ -25,15 +25,15 @@ class Variant final { public: explicit Variant(StringView *stringView) - : m_Ptr((voidPtr)stringView), m_Kind(VariantKind::kString) {} - explicit Variant(nullPtr) : m_Ptr(nullptr), m_Kind(VariantKind::kUndefined) {} - explicit Variant(voidPtr ptr) : m_Ptr(ptr), m_Kind(VariantKind::kPointer) {} + : fPtr((voidPtr)stringView), fKind(VariantKind::kString) {} + explicit Variant(nullPtr) : fPtr(nullptr), fKind(VariantKind::kUndefined) {} + explicit Variant(voidPtr ptr) : fPtr(ptr), fKind(VariantKind::kPointer) {} public: const Char *ToString(); private: - voidPtr m_Ptr{nullptr}; - VariantKind m_Kind{VariantKind::kUndefined}; + voidPtr fPtr{nullptr}; + VariantKind fKind{VariantKind::kUndefined}; }; } // namespace NewOS diff --git a/Private/Source/DriveManager.cxx b/Private/Source/DriveManager.cxx index d04faa68..b468ebae 100644 --- a/Private/Source/DriveManager.cxx +++ b/Private/Source/DriveManager.cxx @@ -25,7 +25,12 @@ Void ke_drv_input(DriveTrait::DrivePacket* pckt) { pckt->fPacketGood = false; +#ifndef __AHCI__ drv_std_read(pckt->fLba, kATAIO, kATAMaster, (Char*)pckt->fPacketContent, 1, pckt->fPacketSize); +#else + drv_std_read(pckt->fLba, (Char*)pckt->fPacketContent, 1, pckt->fPacketSize); +#endif + pckt->fPacketGood = true; } @@ -40,7 +45,11 @@ Void ke_drv_output(DriveTrait::DrivePacket* pckt) { pckt->fPacketGood = false; +#ifndef __AHCI__ drv_std_write(pckt->fLba, kATAIO, kATAMaster, (Char*)pckt->fPacketContent, 1, pckt->fPacketSize); +#else + drv_std_write(pckt->fLba,(Char*)pckt->fPacketContent, 1, pckt->fPacketSize); +#endif pckt->fPacketGood = true; } @@ -68,7 +77,7 @@ const Char* ke_drive_kind(Void) { return "ATA-DMA"; } #endif #ifdef __AHCI__ -const Char* ke_drive_kind(Void) { return "AHCO"; } +const Char* ke_drive_kind(Void) { return "AHCI"; } #endif /// @brief Unimplemented drive. diff --git a/Private/Source/Framebuffer.cxx b/Private/Source/Framebuffer.cxx index d0be2a13..5dc54c81 100644 --- a/Private/Source/Framebuffer.cxx +++ b/Private/Source/Framebuffer.cxx @@ -36,14 +36,14 @@ const UInt32 kRgbWhite = 0xFFFFFFFF; * @return volatile* */ volatile UIntPtr *Framebuffer::operator[](const UIntPtr &pos) { - return (UIntPtr *)(m_FrameBufferAddr->m_Base * pos); + return (UIntPtr *)(fFrameBufferAddr->fBase * pos); } /// @brief Boolean operator. Framebuffer::operator bool() { - return m_FrameBufferAddr.Leak()->m_Base != 0 && - m_Colour != FramebufferColorKind::INVALID && - m_FrameBufferAddr.Leak()->m_Base != kBadPtr; + return fFrameBufferAddr.Leak()->fBase != 0 && + fColour != FramebufferColorKind::INVALID && + fFrameBufferAddr.Leak()->fBase != kBadPtr; } /// @brief Set color kind of framebuffer. @@ -51,26 +51,26 @@ Framebuffer::operator bool() { /// @return const FramebufferColorKind &Framebuffer::Color( const FramebufferColorKind &colour) { - if (m_Colour != FramebufferColorKind::INVALID && + if (fColour != FramebufferColorKind::INVALID && colour != FramebufferColorKind::INVALID) { - m_Colour = colour; + fColour = colour; } - return m_Colour; + return fColour; } /// @brief Leak framebuffer context. /// @return The reference of the framebuffer context. Ref<FramebufferContext *> &Framebuffer::Leak() { - return this->m_FrameBufferAddr; + return this->fFrameBufferAddr; } Framebuffer &Framebuffer::DrawRect(SizeT width, SizeT height, SizeT x, SizeT y, UInt32 color) { for (NewOS::SizeT i = x; i < width + x; ++i) { for (NewOS::SizeT u = y; u < height + y; ++u) { - *(((volatile NewOS::UInt32 *)(m_FrameBufferAddr.Leak()->m_Base + - 4 * m_FrameBufferAddr.Leak()->m_Bpp * i + + *(((volatile NewOS::UInt32 *)(fFrameBufferAddr.Leak()->fBase + + 4 * fFrameBufferAddr.Leak()->fBpp * i + 4 * u))) = color; } } @@ -79,8 +79,8 @@ Framebuffer &Framebuffer::DrawRect(SizeT width, SizeT height, SizeT x, SizeT y, } Framebuffer &Framebuffer::PutPixel(SizeT x, SizeT y, UInt32 color) { - *(((volatile NewOS::UInt32 *)(m_FrameBufferAddr.Leak()->m_Base + - 4 * m_FrameBufferAddr.Leak()->m_Bpp * x + + *(((volatile NewOS::UInt32 *)(fFrameBufferAddr.Leak()->fBase + + 4 * fFrameBufferAddr.Leak()->fBpp * x + 4 * y))) = color; return *this; diff --git a/Private/Source/GUIDWizard.cxx b/Private/Source/GUIDWizard.cxx index 90903979..9d0d4f35 100644 --- a/Private/Source/GUIDWizard.cxx +++ b/Private/Source/GUIDWizard.cxx @@ -24,10 +24,10 @@ auto make_sequence(const ArrayList<UShort>& uuidSeq) -> Ref<GUIDSequence*> { Ref<GUIDSequence*> sequenceReference{seq, true}; - sequenceReference->m_Ms1 |= uuidSeq[0]; - sequenceReference->m_Ms2 |= uuidSeq[1]; - sequenceReference->m_Ms3 |= uuidSeq[2]; - sequenceReference->m_Ms3 |= uuidSeq[3]; + sequenceReference->fMs1 |= uuidSeq[0]; + sequenceReference->fMs2 |= uuidSeq[1]; + sequenceReference->fMs3 |= uuidSeq[2]; + sequenceReference->fMs3 |= uuidSeq[3]; return sequenceReference; } diff --git a/Private/Source/Network/IP.cxx b/Private/Source/Network/IP.cxx index 04e5247d..06421c21 100644 --- a/Private/Source/Network/IP.cxx +++ b/Private/Source/Network/IP.cxx @@ -8,13 +8,13 @@ #include <NewKit/Utils.hpp> namespace NewOS { -char* RawIPAddress::Address() { return m_Addr; } +char* RawIPAddress::Address() { return fAddr; } -RawIPAddress::RawIPAddress(char bytes[4]) { rt_copy_memory(bytes, m_Addr, 4); } +RawIPAddress::RawIPAddress(char bytes[4]) { rt_copy_memory(bytes, fAddr, 4); } bool RawIPAddress::operator==(const RawIPAddress& ipv4) { for (Size index = 0; index < 4; ++index) { - if (ipv4.m_Addr[index] != m_Addr[index]) return false; + if (ipv4.fAddr[index] != fAddr[index]) return false; } return true; @@ -22,7 +22,7 @@ bool RawIPAddress::operator==(const RawIPAddress& ipv4) { bool RawIPAddress::operator!=(const RawIPAddress& ipv4) { for (Size index = 0; index < 4; ++index) { - if (ipv4.m_Addr[index] == m_Addr[index]) return false; + if (ipv4.fAddr[index] == fAddr[index]) return false; } return true; @@ -34,11 +34,11 @@ char& RawIPAddress::operator[](const Size& index) { static char IP_PLACEHOLDER = '0'; if (index > 4) return IP_PLACEHOLDER; - return m_Addr[index]; + return fAddr[index]; } RawIPAddress6::RawIPAddress6(char bytes[8]) { - rt_copy_memory(bytes, m_Addr, 8); + rt_copy_memory(bytes, fAddr, 8); } char& RawIPAddress6::operator[](const Size& index) { @@ -47,12 +47,12 @@ char& RawIPAddress6::operator[](const Size& index) { static char IP_PLACEHOLDER = '0'; if (index > 8) return IP_PLACEHOLDER; - return m_Addr[index]; + return fAddr[index]; } bool RawIPAddress6::operator==(const RawIPAddress6& ipv6) { for (SizeT index = 0; index < 8; ++index) { - if (ipv6.m_Addr[index] != m_Addr[index]) return false; + if (ipv6.fAddr[index] != fAddr[index]) return false; } return true; @@ -60,7 +60,7 @@ bool RawIPAddress6::operator==(const RawIPAddress6& ipv6) { bool RawIPAddress6::operator!=(const RawIPAddress6& ipv6) { for (SizeT index = 0; index < 8; ++index) { - if (ipv6.m_Addr[index] == m_Addr[index]) return false; + if (ipv6.fAddr[index] == fAddr[index]) return false; } return true; diff --git a/Private/Source/PRDT.cxx b/Private/Source/PRDT.cxx index f999dfd6..42808a43 100644 --- a/Private/Source/PRDT.cxx +++ b/Private/Source/PRDT.cxx @@ -8,25 +8,4 @@ #include <NewKit/String.hpp> #include <StorageKit/PRDT.hpp> -namespace NewOS { -PRDT::PRDT(const UIntPtr& physAddr) : m_PrdtAddr(physAddr) { - MUST_PASS(physAddr); - kcout << "PRDT::PRDT() {}\r\n"; -} - -PRDT::~PRDT() { - kcout << "PRDT::~PRDT() {}\r\n"; - m_PrdtAddr = 0; -} - -const UInt& PRDT::Low() { return m_Low; } - -const UShort& PRDT::High() { return m_High; } - -const UIntPtr& PRDT::PhysicalAddress() { return m_PrdtAddr; } - -PRDT& PRDT::operator=(const UIntPtr& prdtAddress) { - m_PrdtAddr = prdtAddress; - return *this; -} -} // namespace NewOS +namespace NewOS {} // namespace NewOS diff --git a/Private/Source/PageManager.cxx b/Private/Source/PageManager.cxx index 4c4524cd..0704734c 100644 --- a/Private/Source/PageManager.cxx +++ b/Private/Source/PageManager.cxx @@ -17,15 +17,15 @@ namespace NewOS { PTEWrapper::PTEWrapper(Boolean Rw, Boolean User, Boolean ExecDisable, UIntPtr VirtAddr) - : m_Rw(Rw), - m_User(User), - m_ExecDisable(ExecDisable), - m_VirtAddr(VirtAddr), - m_Cache(false), - m_Shareable(false), - m_Wt(false), - m_Present(true), - m_Accessed(false) {} + : fRw(Rw), + fUser(User), + fExecDisable(ExecDisable), + fVirtAddr(VirtAddr), + fCache(false), + fShareable(false), + fWt(false), + fPresent(true), + fAccessed(false) {} PTEWrapper::~PTEWrapper() {} @@ -36,8 +36,8 @@ void PageManager::FlushTLB(UIntPtr VirtAddr) { } bool PTEWrapper::Reclaim() { - if (!this->m_Present) { - this->m_Present = true; + if (!this->fPresent) { + this->fPresent = true; return true; } @@ -61,16 +61,16 @@ bool PageManager::Free(Ref<PTEWrapper *> &wrapper) { } const UIntPtr PTEWrapper::VirtualAddress() { - return (m_VirtAddr + sizeof(PTE) + sizeof(PTEWrapper)); + return (fVirtAddr + sizeof(PTE) + sizeof(PTEWrapper)); } -bool PTEWrapper::Shareable() { return m_Shareable; } +bool PTEWrapper::Shareable() { return fShareable; } -bool PTEWrapper::Present() { return m_Present; } +bool PTEWrapper::Present() { return fPresent; } -bool PTEWrapper::Access() { return m_Accessed; } +bool PTEWrapper::Access() { return fAccessed; } -void PTEWrapper::NoExecute(const bool enable) { this->m_ExecDisable = enable; } +void PTEWrapper::NoExecute(const bool enable) { this->fExecDisable = enable; } -const bool &PTEWrapper::NoExecute() { return this->m_ExecDisable; } +const bool &PTEWrapper::NoExecute() { return this->fExecDisable; } } // namespace NewOS diff --git a/Private/Source/Pmm.cxx b/Private/Source/Pmm.cxx index ba5f62e8..7c331c65 100644 --- a/Private/Source/Pmm.cxx +++ b/Private/Source/Pmm.cxx @@ -8,15 +8,15 @@ #include <NewKit/Pmm.hpp> namespace NewOS { -Pmm::Pmm() : m_PageManager() { kcout << "[PMM] Allocate PageMemoryManager"; } +Pmm::Pmm() : fPageManager() { kcout << "[PMM] Allocate PageMemoryManager"; } Pmm::~Pmm() = default; /* If this returns Null pointer, enter emergency mode */ Ref<PTEWrapper> Pmm::RequestPage(Boolean user, Boolean readWrite) { - PTEWrapper pt = m_PageManager.Leak().Request(user, readWrite, false); + PTEWrapper pt = fPageManager.Leak().Request(user, readWrite, false); - if (pt.m_Present) { + if (pt.fPresent) { kcout << "[PMM]: Allocation was successful."; return Ref<PTEWrapper>(pt); } @@ -29,7 +29,7 @@ Ref<PTEWrapper> Pmm::RequestPage(Boolean user, Boolean readWrite) { Boolean Pmm::FreePage(Ref<PTEWrapper> PageRef) { if (!PageRef) return false; - PageRef.Leak().m_Present = false; + PageRef.Leak().fPresent = false; return true; } @@ -37,7 +37,7 @@ Boolean Pmm::FreePage(Ref<PTEWrapper> PageRef) { Boolean Pmm::TogglePresent(Ref<PTEWrapper> PageRef, Boolean Enable) { if (!PageRef) return false; - PageRef.Leak().m_Present = Enable; + PageRef.Leak().fPresent = Enable; return true; } @@ -45,7 +45,7 @@ Boolean Pmm::TogglePresent(Ref<PTEWrapper> PageRef, Boolean Enable) { Boolean Pmm::ToggleUser(Ref<PTEWrapper> PageRef, Boolean Enable) { if (!PageRef) return false; - PageRef.Leak().m_Rw = Enable; + PageRef.Leak().fRw = Enable; return true; } @@ -53,7 +53,7 @@ Boolean Pmm::ToggleUser(Ref<PTEWrapper> PageRef, Boolean Enable) { Boolean Pmm::ToggleRw(Ref<PTEWrapper> PageRef, Boolean Enable) { if (!PageRef) return false; - PageRef.Leak().m_Rw = Enable; + PageRef.Leak().fRw = Enable; return true; } @@ -61,7 +61,7 @@ Boolean Pmm::ToggleRw(Ref<PTEWrapper> PageRef, Boolean Enable) { Boolean Pmm::ToggleShare(Ref<PTEWrapper> PageRef, Boolean Enable) { if (!PageRef) return false; - PageRef.Leak().m_Shareable = Enable; + PageRef.Leak().fShareable = Enable; return true; } diff --git a/Private/Source/Property.cxx b/Private/Source/Property.cxx index 81cf430a..c9e20df8 100644 --- a/Private/Source/Property.cxx +++ b/Private/Source/Property.cxx @@ -8,8 +8,8 @@ namespace NewOS { bool Property::StringEquals(StringView& name) { - return m_sName && this->m_sName == name; + return fsName && this->fsName == name; } -const PropertyId& Property::GetPropertyById() { return m_Action; } +const PropertyId& Property::GetPropertyById() { return fAction; } } // namespace NewOS diff --git a/Private/Source/SMPManager.cxx b/Private/Source/SMPManager.cxx index 18625cc5..3c342e16 100644 --- a/Private/Source/SMPManager.cxx +++ b/Private/Source/SMPManager.cxx @@ -26,36 +26,36 @@ HardwareThread::~HardwareThread() = default; //! @brief returns the id -const ThreadID& HardwareThread::ID() noexcept { return m_ID; } +const ThreadID& HardwareThread::ID() noexcept { return fID; } //! @brief returns the kind -const ThreadKind& HardwareThread::Kind() noexcept { return m_Kind; } +const ThreadKind& HardwareThread::Kind() noexcept { return fKind; } //! @brief is the core busy? -bool HardwareThread::IsBusy() noexcept { return m_Busy; } +bool HardwareThread::IsBusy() noexcept { return fBusy; } /// @brief Get processor stack frame. HAL::StackFramePtr HardwareThread::StackFrame() noexcept { - MUST_PASS(m_Stack); - return m_Stack; + MUST_PASS(fStack); + return fStack; } -void HardwareThread::Busy(const bool busy) noexcept { m_Busy = busy; } +void HardwareThread::Busy(const bool busy) noexcept { fBusy = busy; } -HardwareThread::operator bool() { return m_Stack; } +HardwareThread::operator bool() { return fStack; } /// @brief Wakeup the processor. void HardwareThread::Wake(const bool wakeup) noexcept { - m_Wakeup = wakeup; + fWakeup = wakeup; - if (!m_Wakeup) - rt_hang_thread(m_Stack); + if (!fWakeup) + rt_hang_thread(fStack); else - rt_wakeup_thread(m_Stack); + rt_wakeup_thread(fStack); } extern bool rt_check_stack(HAL::StackFramePtr stackPtr); @@ -63,14 +63,14 @@ extern bool rt_check_stack(HAL::StackFramePtr stackPtr); bool HardwareThread::Switch(HAL::StackFramePtr stack) { if (!rt_check_stack(stack)) return false; - m_Stack = stack; + fStack = stack; - rt_do_context_switch(m_Stack); + rt_do_context_switch(fStack); return true; } ///! @brief Tells if processor is waked up. -bool HardwareThread::IsWakeup() noexcept { return m_Wakeup; } +bool HardwareThread::IsWakeup() noexcept { return fWakeup; } //! @brief Constructor and destructor @@ -88,10 +88,10 @@ Ref<SMPManager> SMPManager::Shared() { /// @brief Get Stack Frame of Core HAL::StackFramePtr SMPManager::GetStackFrame() noexcept { - if (m_ThreadList[m_CurrentThread].Leak() && + if (fThreadList[fCurrentThread].Leak() && ProcessHelper::GetCurrentPID() == - m_ThreadList[m_CurrentThread].Leak().Leak().m_PID) - return m_ThreadList[m_CurrentThread].Leak().Leak().m_Stack; + fThreadList[fCurrentThread].Leak().Leak().fPID) + return fThreadList[fCurrentThread].Leak().Leak().fStack; return nullptr; } @@ -102,31 +102,31 @@ bool SMPManager::Switch(HAL::StackFramePtr stack) { for (SizeT idx = 0; idx < kMaxHarts; ++idx) { // stack != nullptr -> if core is used, then continue. - if (!m_ThreadList[idx].Leak() || - !m_ThreadList[idx].Leak().Leak().IsWakeup() || - m_ThreadList[idx].Leak().Leak().IsBusy()) + if (!fThreadList[idx].Leak() || + !fThreadList[idx].Leak().Leak().IsWakeup() || + fThreadList[idx].Leak().Leak().IsBusy()) continue; // to avoid any null deref. - if (!m_ThreadList[idx].Leak().Leak().m_Stack) continue; - if (m_ThreadList[idx].Leak().Leak().m_Stack->Rsp == 0) continue; - if (m_ThreadList[idx].Leak().Leak().m_Stack->Rbp == 0) continue; + if (!fThreadList[idx].Leak().Leak().fStack) continue; + if (fThreadList[idx].Leak().Leak().fStack->Rsp == 0) continue; + if (fThreadList[idx].Leak().Leak().fStack->Rbp == 0) continue; - m_ThreadList[idx].Leak().Leak().Busy(true); + fThreadList[idx].Leak().Leak().Busy(true); - m_ThreadList[idx].Leak().Leak().m_ID = idx; + fThreadList[idx].Leak().Leak().fID = idx; /// I figured out this: /// Allocate stack /// Set APIC base to stack /// Do stuff and relocate stack based on this code. /// - Amlel - rt_copy_memory(stack, m_ThreadList[idx].Leak().Leak().m_Stack, + rt_copy_memory(stack, fThreadList[idx].Leak().Leak().fStack, sizeof(HAL::StackFrame)); - m_ThreadList[idx].Leak().Leak().m_PID = ProcessHelper::GetCurrentPID(); + fThreadList[idx].Leak().Leak().fPID = ProcessHelper::GetCurrentPID(); - m_ThreadList[idx].Leak().Leak().Busy(false); + fThreadList[idx].Leak().Leak().Busy(false); return true; } @@ -141,32 +141,32 @@ bool SMPManager::Switch(HAL::StackFramePtr stack) { */ Ref<HardwareThread> SMPManager::operator[](const SizeT& idx) { if (idx == 0) { - if (m_ThreadList[idx].Leak().Leak().Kind() != kHartSystemReserved) { - m_ThreadList[idx].Leak().Leak().m_Kind = kHartBoot; + if (fThreadList[idx].Leak().Leak().Kind() != kHartSystemReserved) { + fThreadList[idx].Leak().Leak().fKind = kHartBoot; } } else if (idx >= kMaxHarts) { HardwareThread fakeThread; - fakeThread.m_Kind = kInvalidHart; + fakeThread.fKind = kInvalidHart; return {fakeThread}; } - return m_ThreadList[idx].Leak(); + return fThreadList[idx].Leak(); } /** * Check if thread pool isn't empty. * @return */ -SMPManager::operator bool() noexcept { return !m_ThreadList.Empty(); } +SMPManager::operator bool() noexcept { return !fThreadList.Empty(); } /** * Reverse operator bool * @return */ -bool SMPManager::operator!() noexcept { return m_ThreadList.Empty(); } +bool SMPManager::operator!() noexcept { return fThreadList.Empty(); } /// @brief Returns the amount of core present. /// @return the number of cores. -SizeT SMPManager::Count() noexcept { return m_ThreadList.Count(); } +SizeT SMPManager::Count() noexcept { return fThreadList.Count(); } } // namespace NewOS diff --git a/Private/Source/String.cxx b/Private/Source/String.cxx index a204777d..8f571f34 100644 --- a/Private/Source/String.cxx +++ b/Private/Source/String.cxx @@ -9,17 +9,17 @@ #include <KernelKit/DebugOutput.hpp> namespace NewOS { -Char *StringView::Data() { return m_Data; } +Char *StringView::Data() { return fData; } -const Char *StringView::CData() { return m_Data; } +const Char *StringView::CData() { return fData; } -Size StringView::Length() const { return rt_string_len(m_Data); } +Size StringView::Length() const { return rt_string_len(fData); } bool StringView::operator==(const StringView &rhs) const { if (rhs.Length() != this->Length()) return false; for (Size index = 0; index < this->Length(); ++index) { - if (rhs.m_Data[index] != m_Data[index]) return false; + if (rhs.fData[index] != fData[index]) return false; } return true; @@ -29,7 +29,7 @@ bool StringView::operator==(const Char *rhs) const { if (rt_string_len(rhs) != this->Length()) return false; for (Size index = 0; index < rt_string_len(rhs); ++index) { - if (rhs[index] != m_Data[index]) return false; + if (rhs[index] != fData[index]) return false; } return true; @@ -39,7 +39,7 @@ bool StringView::operator!=(const StringView &rhs) const { if (rhs.Length() != this->Length()) return false; for (Size index = 0; index < rhs.Length(); ++index) { - if (rhs.m_Data[index] == m_Data[index]) return false; + if (rhs.fData[index] == fData[index]) return false; } return true; @@ -49,7 +49,7 @@ bool StringView::operator!=(const Char *rhs) const { if (rt_string_len(rhs) != this->Length()) return false; for (Size index = 0; index < rt_string_len(rhs); ++index) { - if (rhs[index] == m_Data[index]) return false; + if (rhs[index] == fData[index]) return false; } return true; @@ -174,17 +174,17 @@ static void string_append(char *lhs, char *rhs, int cur) { } StringView &StringView::operator+=(const Char *rhs) { - string_append(this->m_Data, const_cast<char *>(rhs), this->m_Cur); - this->m_Cur += rt_string_len(rhs); + string_append(this->fData, const_cast<char *>(rhs), this->fCur); + this->fCur += rt_string_len(rhs); return *this; } StringView &StringView::operator+=(const StringView &rhs) { - if (rt_string_len(rhs.m_Data) > rt_string_len(this->m_Data)) return *this; + if (rt_string_len(rhs.fData) > rt_string_len(this->fData)) return *this; - string_append(this->m_Data, const_cast<char *>(rhs.m_Data), this->m_Cur); - this->m_Cur += rt_string_len(const_cast<char *>(rhs.m_Data)); + string_append(this->fData, const_cast<char *>(rhs.fData), this->fCur); + this->fCur += rt_string_len(const_cast<char *>(rhs.fData)); return *this; } diff --git a/Private/Source/URL.cxx b/Private/Source/URL.cxx index c384c378..ebb325c1 100644 --- a/Private/Source/URL.cxx +++ b/Private/Source/URL.cxx @@ -11,7 +11,7 @@ /// BUGS: 0 namespace NewOS { -Url::Url(StringView &strUrl) : m_urlView(strUrl, false) {} +Url::Url(StringView &strUrl) : fUrlView(strUrl, false) {} Url::~Url() = default; @@ -63,7 +63,7 @@ ErrorOr<StringView> url_extract_protocol(const char *url) { } Ref<ErrorOr<StringView>> Url::Location() noexcept { - const char *src = m_urlView.Leak().CData(); + const char *src = fUrlView.Leak().CData(); auto loc = url_extract_location(src); if (!loc) return {}; @@ -72,7 +72,7 @@ Ref<ErrorOr<StringView>> Url::Location() noexcept { } Ref<ErrorOr<StringView>> Url::Protocol() noexcept { - const char *src = m_urlView.Leak().CData(); + const char *src = fUrlView.Leak().CData(); auto loc = url_extract_protocol(src); if (!loc) return {}; diff --git a/Private/Source/Utils.cxx b/Private/Source/Utils.cxx index 9072ead9..75e158a0 100644 --- a/Private/Source/Utils.cxx +++ b/Private/Source/Utils.cxx @@ -157,7 +157,7 @@ voidPtr rt_string_in_string(const char *in, const char *needle) { // @brief Checks for a string start at the character. -char *rt_string_from_char(char *str, const char chr) { +char *rt_string_frofchar(char *str, const char chr) { while (*str != chr) { ++str; diff --git a/Private/Source/Variant.cxx b/Private/Source/Variant.cxx index 065d562e..fbea1768 100644 --- a/Private/Source/Variant.cxx +++ b/Private/Source/Variant.cxx @@ -8,11 +8,11 @@ namespace NewOS { const Char* Variant::ToString() { - if (m_Ptr == nullptr) { + if (fPtr == nullptr) { return ("Memory:{Nullptr}"); } - switch (m_Kind) { + switch (fKind) { case VariantKind::kString: return ("Class:{String}"); case VariantKind::kPointer: diff --git a/Private/StorageKit/PRDT.hpp b/Private/StorageKit/PRDT.hpp index 9163a8bf..d83f2a56 100644 --- a/Private/StorageKit/PRDT.hpp +++ b/Private/StorageKit/PRDT.hpp @@ -19,33 +19,10 @@ enum kPRDTTransfer { kPRDTTransferCount, }; -class PRDT final { - public: - explicit PRDT() = delete; - explicit PRDT(const UIntPtr &physAddr); - ~PRDT(); - - PRDT &operator=(const PRDT &) = default; - PRDT(const PRDT &) = default; - - public: - const UInt &Low(); - const UShort &High(); - const UIntPtr &PhysicalAddress(); - - public: - PRDT &operator=(const UIntPtr &prdtAddress); - - public: - operator bool() { return m_PrdtAddr != 0; } - - private: - union { - UInt m_Low; - UShort m_High; - }; - - UIntPtr m_PrdtAddr; +struct PRDT { + UInt32 fPhysAddress; + UInt32 fSectorCount; + UInt8 fEndBit; }; EXTERN_C Int32 kPRDTTransferStatus; |