Kernel: Rewrite whole AML parser

Now AML parsing is actually done while respecting namespaces and
scopes. I implemented the minimal functionality to parse qemu's AML.

Next step is to implement AML interpreting and then we can drop lai
as a dependency.

kernel/include/kernel/ACPI/ACPI.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <BAN/Vector.h>
+#include <kernel/ACPI/AML/Namespace.h>
 #include <kernel/ACPI/Headers.h>
 #include <kernel/Memory/Types.h>
 
@@ -32,6 +33,8 @@ namespace Kernel::ACPI
 			SDTHeader* as_header() { return (SDTHeader*)vaddr; }
 		};
 		BAN::Vector<MappedPage> m_mapped_headers;
+
+		BAN::RefPtr<AML::Namespace> m_namespace;
 	};
 
 }

kernel/include/kernel/ACPI/AML.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <kernel/ACPI/Headers.h>
+#include <kernel/ACPI/AML/Namespace.h>
 
 namespace Kernel::ACPI
 {
@@ -10,7 +11,7 @@ namespace Kernel::ACPI
 	public:
 		~AMLParser();
 
-		static AMLParser parse_table(const SDTHeader& header);
+		static BAN::RefPtr<AML::Namespace> parse_table(const SDTHeader& header);
 
 	private:
 		AMLParser();

kernel/include/kernel/ACPI/AML/Buffer.h

@@ -0,0 +1,60 @@
+#pragma once
+
+#include <kernel/ACPI/AML/Bytes.h>
+#include <kernel/ACPI/AML/Node.h>
+#include <kernel/ACPI/AML/ParseContext.h>
+#include <kernel/ACPI/AML/Pkg.h>
+
+namespace Kernel::ACPI::AML
+{
+
+	struct Buffer : public AML::Node
+	{
+		BAN::Vector<uint8_t> buffer;
+
+		Buffer() : AML::Node(Node::Type::Buffer) {}
+
+		static ParseResult parse(AML::ParseContext& context)
+		{
+			ASSERT(context.aml_data.size() >= 1);
+			ASSERT(static_cast<Byte>(context.aml_data[0]) == Byte::BufferOp);
+			context.aml_data = context.aml_data.slice(1);
+
+			auto buffer_pkg = AML::parse_pkg(context.aml_data);
+			if (!buffer_pkg.has_value())
+				return ParseResult::Failure;
+
+			auto buffer_context = context;
+			buffer_context.aml_data = buffer_pkg.value();
+
+			auto buffer_size_object = AML::parse_object(buffer_context);
+			if (!buffer_size_object.success())
+				return ParseResult::Failure;
+
+			auto buffer_size = buffer_size_object.node()->as_integer();
+			if (!buffer_size.has_value())
+				return ParseResult::Failure;
+
+			uint32_t actual_buffer_size = BAN::Math::max(buffer_size.value(), buffer_context.aml_data.size());
+
+			auto buffer = MUST(BAN::RefPtr<Buffer>::create());
+			MUST(buffer->buffer.resize(actual_buffer_size, 0));
+			for (uint32_t i = 0; i < buffer_context.aml_data.size(); i++)
+					buffer->buffer[i] = buffer_context.aml_data[i];
+
+#if AML_DEBUG_LEVEL >= 2
+			buffer->debug_print(0);
+			AML_DEBUG_PRINTLN("");
+#endif
+
+			return ParseResult(buffer);
+		}
+
+		virtual void debug_print(int indent) const override
+		{
+			AML_DEBUG_PRINT_INDENT(indent);
+			AML_DEBUG_PRINT("Buffer ({} bytes)", buffer.size());
+		}
+	};
+
+}

kernel/include/kernel/ACPI/AML/Bytes.h

@@ -1,265 +1,163 @@
 #pragma once
 
-#include <BAN/Formatter.h>
-#include <BAN/Vector.h>
-#include <BAN/StringView.h>
-#include <kernel/Debug.h>
-
-#define DUMP_AML 0
-
-#if DUMP_AML
-
-#define AML_DEBUG_CONCAT_IMPL(x, y) x##y
-#define AML_DEBUG_CONCAT(x, y) AML_DEBUG_CONCAT_IMPL(x, y)
-#define AML_DEBUG_INDENT_SCOPE() Kernel::ACPI::AML::Indenter AML_DEBUG_CONCAT(indenter, __COUNTER__)
-
-#define __AML_DEBUG_PRINT_INDENT()													\
-	do {																			\
-		BAN::Formatter::print(Debug::putchar, "{}:{3} ", __BASE_FILE__, __LINE__);	\
-		for (size_t i = 1; i < AML::g_depth; i++)									\
-			BAN::Formatter::print(Debug::putchar, "│ ");							\
-		if (AML::g_depth > 0)														\
-			BAN::Formatter::print(Debug::putchar, "├─");							\
-	} while (0)
-
-#define AML_DEBUG_PRINT_FN()													\
-	__AML_DEBUG_PRINT_INDENT();													\
-	AML_DEBUG_INDENT_SCOPE();													\
-	BAN::Formatter::println(Debug::putchar, "{}", AML::get_class_name(__PRETTY_FUNCTION__))
-
-#define AML_DEBUG_PRINT(...)									\
-	do {														\
-		__AML_DEBUG_PRINT_INDENT();								\
-		BAN::Formatter::println(Debug::putchar, __VA_ARGS__);	\
-	} while (0)
-
-#else
-
-#define AML_DEBUG_PRINT_FN()
-#define AML_DEBUG_PRINT(...)
-#define AML_DEBUG_INDENT_SCOPE()
-#define __AML_DEBUG_PRINT_INDENT()
-
-#endif
-
-#define AML_DEBUG_TODO(...)										\
-	do {														\
-		__AML_DEBUG_PRINT_INDENT();								\
-		BAN::Formatter::print(Debug::putchar, "\e[33mTODO: ");	\
-		BAN::Formatter::print(Debug::putchar, __VA_ARGS__);		\
-		BAN::Formatter::println(Debug::putchar, "\e[m");		\
-	} while (0)
-
-#define AML_DEBUG_ERROR(...)								\
-	do {													\
-		__AML_DEBUG_PRINT_INDENT();							\
-		BAN::Formatter::print(Debug::putchar, "\e[31m");	\
-		BAN::Formatter::print(Debug::putchar, __VA_ARGS__);	\
-		BAN::Formatter::println(Debug::putchar, "\e[m");	\
-	} while (0)
-
-#define AML_DEBUG_CANNOT_PARSE(TYPE, SPAN)																	\
-	do {																									\
-		__AML_DEBUG_PRINT_INDENT();																			\
-		BAN::Formatter::print(Debug::putchar, "\e[31mCannot parse " TYPE " (span {} bytes", SPAN.size());	\
-		if (SPAN.size() > 0)																				\
-			BAN::Formatter::print(Debug::putchar, ", {2H}", SPAN[0]);										\
-		if (SPAN.size() > 1)																				\
-			BAN::Formatter::print(Debug::putchar, " {2H}", SPAN[1]);										\
-		BAN::Formatter::println(Debug::putchar, ")\e[m");													\
-	} while (0)
+#include <stdint.h>
 
 namespace Kernel::ACPI::AML
 {
-	extern size_t g_depth;
-	struct Indenter
-	{
-		Indenter() { g_depth++; }
-		~Indenter() { g_depth--; }
-	};
-
-	static BAN::StringView get_class_name(BAN::StringView pretty_function)
-	{
-		return MUST(MUST(pretty_function.split(' '))[2].split(':'))[3];
-	}
-}
-
-#define GEN_PARSE_CASE_TODO(NAME)	\
-	case AML::Byte::NAME:			\
-		AML_DEBUG_TODO(#NAME);		\
-		return {};
-
-#define AML_TRY_PARSE_PACKAGE(NAME)							\
-	auto opt_##NAME = AML::PkgLength::parse_package(span);	\
-	if (!opt_##NAME.has_value())							\
-		return {};											\
-	auto NAME = opt_##NAME.release_value();
-
-#define AML_TRY_PARSE(NAME, TYPE, SPAN)			\
-	if (!TYPE::can_parse(SPAN))					\
-	{											\
-		AML_DEBUG_CANNOT_PARSE(#TYPE, SPAN);	\
-		return {};								\
-	}											\
-	auto NAME = TYPE::parse(SPAN);				\
-	if (!NAME.has_value())						\
-		return {}
-
-#define AML_TRY_PARSE_IF_CAN(TYPE)							\
-	if (TYPE::can_parse(span))								\
-	{														\
-		if (auto obj = TYPE::parse(span); obj.has_value())	\
-			return obj.release_value();						\
-		return {};											\
-	}
-
-
-
-namespace Kernel::ACPI::AML {
-
-	enum class Byte : uint8_t
+
+	enum class Byte
 	{
+		NullName = 0x00,
+		ZeroOp = 0x00,
+		OneOp = 0x01,
+		// 0x02 - 0x05
+		AliasOp = 0x06,
+		// 0x07
+		NameOp = 0x08,
+		// 0x09
+		BytePrefix = 0x0A,
+		WordPrefix = 0x0B,
+		DWordPrefix = 0x0C,
+		StringPrefix = 0x0D,
+		QWordPrefix = 0x0E,
+		// 0x0F
+		ScopeOp = 0x10,
+		BufferOp = 0x11,
+		PackageOp = 0x12,
+		VarPackageOp = 0x13,
+		MethodOp = 0x14,
+		ExternalOp = 0x15,
+		// 0x16 - 0x2D
+		DualNamePrefix = 0x2E,
+		MultiNamePrefix = 0x2F,
+		// 0x30 - 0x39 DigitChar
+		// 0x3A - 0x40
+		// 0x41 - 0x5A NameChar
 		ExtOpPrefix = 0x5B,
-
-		// NamePath
-		DualNamePrefix	= 0x2E,
-		MultiNamePrefix	= 0x2F,
-
-		// NameSpaceModifierObj
-		AliasOp	= 0x06,
-		NameOp	= 0x08,
-		ScopeOp	= 0x10,
-
-		// ConstObj
-		ZeroOp			= 0x00,
-		OneOp			= 0x01,
-		OnesOp			= 0xFF,
-
-		// ComputationalData
-		BytePrefix		= 0x0A,
-		WordPrefix		= 0x0B,
-		DWordPrefix		= 0x0C,
-		StringPrefix	= 0x0D,
-		QWordPrefix		= 0x0E,
-		BufferOp		= 0x11,
-		ExtRevisionOp	= 0x30,
-
-		// DataObject
-		PackageOp		= 0x12,
-		VarPackageOp	= 0x13,
-
-		// NamedObj
-		ExternalOp			= 0x15,
-		CreateDWordFieldOp	= 0x8A,
-		CreateWordFieldOp	= 0x8B,
-		CreateByteFieldOp	= 0x8C,
-		CreateBitFieldOp	= 0x8D,
-		CreateQWordFieldOp	= 0x8F,
-		ExtCreateFieldOp	= 0x13,
-		ExtOpRegionOp		= 0x80,
-		ExtProcessorOp		= 0x83, // deprecated
-		ExtPowerResOp		= 0x84,
-		ExtThermalZoneOp	= 0x85,
-		ExtBankFieldOp		= 0x87,
-		ExtDataRegionOp		= 0x88,
-		// ... not specified
-		MethodOp		= 0x14,
-		ExtMutexOp		= 0x01,
-		ExtEventOp		= 0x02,
-		ExtFieldOp		= 0x81,
-		ExtDeviceOp		= 0x82,
-		ExtIndexFieldOp	= 0x86,
-
-		// StatementOpcode
-		BreakOp			= 0xA5,
-		BreakPointOp	= 0xCC,
-		ContinueOp		= 0x9F,
-		ElseOp			= 0xA1,
-		IfOp			= 0xA0,
-		NoopOp			= 0xA3,
-		NotifyOp		= 0x86,
-		ReturnOp		= 0xA4,
-		WhileOp			= 0xA2,
-		ExtFatalOp		= 0x32,
-		ExtReleaseOp	= 0x27,
-		ExtResetOp		= 0x26,
-		ExtSignalOp		= 0x24,
-		ExtSleepOp		= 0x22,
-		ExtStallOp		= 0x21,
-
-		// ExpressionOpcode
-		//PackageOp			= 0x12,
-		//VarPackageOp		= 0x13,
-		//BufferOp			= 0x11,
-		StoreOp				= 0x70,
-		RefOfOp				= 0x71,
-		AddOp				= 0x72,
-		ConcatOp			= 0x73,
-		SubtractOp			= 0x74,
-		IncrementOp			= 0x75,
-		DecrementOp			= 0x76,
-		MultiplyOp			= 0x77,
-		DivideOp			= 0x78,
-		ShiftLeftOp			= 0x79,
-		ShiftRightOp		= 0x7A,
-		AndOp				= 0x7B,
-		NAndOp				= 0x7C,
-		OrOp				= 0x7D,
-		NOrOp				= 0x7E,
-		XOrOp				= 0x7F,
-		NotOp				= 0x80,
-		FindSetLeftBitOp	= 0x81,
-		FindSetRightBitOp	= 0x82,
-		DerefOfOp			= 0x83,
-		ConcatResOp			= 0x84,
-		ModOp				= 0x85,
-		SizeOfOp			= 0x87,
-		IndexOp				= 0x88,
-		MatchOp				= 0x89,
-		ObjectTypeOp		= 0x8E,
-		LAndOp				= 0x90,
-		LOrOp				= 0x91,
-		LNotOp				= 0x92,
-		LEqualOp			= 0x93,
-		LGreaterOp			= 0x94,
-		LLessOp				= 0x95,
-		ToBufferOp			= 0x96,
-		ToDecimalStringOp	= 0x97,
-		ToHexStringOp		= 0x98,
-		ToIntegerOp			= 0x99,
-		ToStringOp			= 0x9C,
-		CopyObjectOp		= 0x9D,
-		MidOp				= 0x9E,
-		ExtCondRefOfOp		= 0x12,
-		ExtLoadTableOp		= 0x1F,
-		ExtLoadOp			= 0x20,
-		ExtAcquireOp		= 0x23,
-		ExtWaitOp			= 0x25,
-		ExtFromBCDOp		= 0x28,
-		ExtToBCDOp			= 0x29,
-		ExtTimerOp			= 0x33,
-
-		// LocalObj
-		Local0Op	= 0x60,
-		Local1Op	= 0x61,
-		Local2Op	= 0x62,
-		Local3Op	= 0x63,
-		Local4Op	= 0x64,
-		Local5Op	= 0x65,
-		Local6Op	= 0x66,
-		Local7Op	= 0x67,
-
-		// ArgObj
-		Arg0Op	= 0x68,
-		Arg1Op	= 0x69,
-		Arg2Op	= 0x6A,
-		Arg3Op	= 0x6B,
-		Arg4Op	= 0x6C,
-		Arg5Op	= 0x6D,
-		Arg6Op	= 0x6E,
-
-		// DebugObj
-		ExtDebugOp	= 0x31,
+		RootChar = 0x5C,
+		// 0x5D
+		ParentPrefixChar = 0x5E,
+		// 0x5F NameChar
+		Local0 = 0x60,
+		Local1 = 0x61,
+		Local2 = 0x62,
+		Local3 = 0x63,
+		Local4 = 0x64,
+		Local5 = 0x65,
+		Local6 = 0x66,
+		Local7 = 0x67,
+		Arg0 = 0x68,
+		Arg1 = 0x69,
+		Arg2 = 0x6A,
+		Arg3 = 0x6B,
+		Arg4 = 0x6C,
+		Arg5 = 0x6D,
+		Arg6 = 0x6E,
+		// 0x6F
+		StoreOp = 0x70,
+		RefOfOp = 0x71,
+		AddOp = 0x72,
+		ConcatOp = 0x73,
+		SubtractOp = 0x74,
+		IncrementOp = 0x75,
+		DecrementOp = 0x76,
+		MultiplyOp = 0x77,
+		DivideOp = 0x78,
+		ShiftLeftOp = 0x79,
+		ShiftRightOp = 0x7A,
+		AndOp = 0x7B,
+		NandOp = 0x7C,
+		OrOp = 0x7D,
+		NorOp = 0x7E,
+		XorOp = 0x7F,
+		NotOp = 0x80,
+		FindSetLeftBitOp = 0x81,
+		FindSetRightBitOp = 0x82,
+		DerefOfOp = 0x83,
+		ConcatResOp = 0x84,
+		ModOp = 0x85,
+		NotifyOp = 0x86,
+		SizeOfOp = 0x87,
+		IndexOp = 0x88,
+		MatchOp = 0x89,
+		CreateDWordFieldOp = 0x8A,
+		CreateWordFieldOp = 0x8B,
+		CreateByteFieldOp = 0x8C,
+		CreateBitFieldOp = 0x8D,
+		ObjectTypeOp = 0x8E,
+		CreateQWordFieldOp = 0x8F,
+		LAndOp = 0x90,
+		LOrOp = 0x91,
+		LNotOp = 0x92,
+		LEqualOp = 0x93,
+		LGreaterOp = 0x94,
+		LLessOp = 0x95,
+		ToBufferOp = 0x96,
+		ToDecimalStringOp = 0x97,
+		ToHexStringOp = 0x98,
+		ToIntegerOp = 0x99,
+		// 0x9A - 0x9B
+		ToStringOp = 0x9C,
+		CopyObjectOp = 0x9D,
+		MidOp = 0x9E,
+		ContinueOp = 0x9F,
+		IfOp = 0xA0,
+		ElseOp = 0xA1,
+		WhileOp = 0xA2,
+		NoopOp = 0xA3,
+		ReturnOp = 0xA4,
+		BreakOp = 0xA5,
+		// 0xA6 - 0xCB
+		BreakPointOp = 0xCC,
+		// 0xCD - 0xFE
+		OnesOp = 0xFF,
 	};
 
+	enum class ExtOp
+	{
+		MutexOp = 0x01,
+		EventOp = 0x02,
+		CondRefOfOp = 0x12,
+		CreateFieldOp = 0x13,
+		LoadTableOp = 0x1F,
+		LoadOp = 0x20,
+		StallOp = 0x21,
+		SleepOp = 0x22,
+		AcquireOp = 0x23,
+		SignalOp = 0x24,
+		WaitOp = 0x25,
+		ResetOp = 0x26,
+		ReleaseOp = 0x27,
+		FromBCDOp = 0x28,
+		ToBCDOp = 0x29,
+		RevisionOp = 0x30,
+		DebugOp = 0x31,
+		FatalOp = 0x32,
+		TimerOp = 0x33,
+		OpRegionOp = 0x80,
+		FieldOp = 0x81,
+		DeviceOp = 0x82,
+		ProcessorOp = 0x83,
+		PowerResOp = 0x84,
+		ThermalZoneOp = 0x85,
+		IndexFieldOp = 0x86,
+		BankFieldOp = 0x87,
+		DataRegionOp = 0x88,
+	};
+
+	static constexpr bool is_digit_char(uint8_t ch)
+	{
+		return '0' <= ch && ch <= '9';
+	}
+
+	static constexpr bool is_lead_name_char(uint8_t ch)
+	{
+		return ('A' <= ch && ch <= 'Z') || ch == '_';
+	}
+
+	static constexpr bool is_name_char(uint8_t ch)
+	{
+		return is_lead_name_char(ch) || is_digit_char(ch);
+	}
+
 }

kernel/include/kernel/ACPI/AML/DataObject.h

@@ -1,102 +0,0 @@
-#pragma once
-
-#include <BAN/ByteSpan.h>
-#include <BAN/Optional.h>
-#include <BAN/String.h>
-#include <BAN/UniqPtr.h>
-#include <BAN/Variant.h>
-#include <BAN/Vector.h>
-#include <kernel/ACPI/AML/NameObject.h>
-
-namespace Kernel::ACPI::AML
-{
-	// ACPI Spec 6.4, Section 20.2.3
-
-	// Integer := ByteConst | WordConst | DWordConst | QWordConst
-	// Not actually defined in the spec...
-	struct Integer
-	{
-		uint64_t value;
-
-		static bool can_parse(BAN::ConstByteSpan span);
-		static BAN::Optional<Integer> parse(BAN::ConstByteSpan& span);
-	};
-
-	// Buffer := BufferOp PkgLength BufferSize ByteList
-	struct Buffer
-	{
-		Integer buffer_size;
-		BAN::Vector<uint8_t> data;
-
-		static bool can_parse(BAN::ConstByteSpan span);
-		static BAN::Optional<Buffer> parse(BAN::ConstByteSpan& span);
-	};
-
-	// ComputationalData := Integer | String | ConstObj | RevisionOp | DefBuffer
-	struct ComputationalData
-	{
-		struct String
-		{
-			BAN::String value;
-		};
-		struct ConstObj
-		{
-			enum class Type
-			{
-				Zero,
-				One,
-				Ones
-			};
-			Type type;
-		};
-		struct RevisionOp {};
-
-		BAN::Variant<Integer, String, ConstObj, RevisionOp, Buffer> data;
-
-		static bool can_parse(BAN::ConstByteSpan span);
-		static BAN::Optional<ComputationalData> parse(BAN::ConstByteSpan& span);
-	};
-
-	struct DataRefObject;
-	struct Uninitialized {};
-
-	// PackageElement := DataRefObject | NameString
-	using PackageElement = BAN::Variant<BAN::UniqPtr<DataRefObject>, NameString, Uninitialized>;
-
-	// DefPackage := PackageOp PkgLength NumElements PackageElementList
-	struct Package
-	{
-		BAN::Vector<PackageElement> elements;
-
-		static bool can_parse(BAN::ConstByteSpan span);
-		static BAN::Optional<Package> parse(BAN::ConstByteSpan& span);
-	};
-
-	// DefVarPackage := VarPackageOp PkgLength VarNumElements PackageElementList
-	struct VarPackage
-	{
-		BAN::Vector<PackageElement> elements;
-
-		static bool can_parse(BAN::ConstByteSpan span);
-		static BAN::Optional<VarPackage> parse(BAN::ConstByteSpan& span);
-	};
-
-	// DataObject := ComputationalData | DefPackage | DefVarPackage
-	struct DataObject
-	{
-		BAN::Variant<ComputationalData, Package, VarPackage> data;
-
-		static bool can_parse(BAN::ConstByteSpan span);
-		static BAN::Optional<DataObject> parse(BAN::ConstByteSpan& span);
-	};
-
-	// DataRefObject := DataObject | ObjectReference
-	struct DataRefObject
-	{
-		BAN::Variant<DataObject, Integer> object;
-
-		static bool can_parse(BAN::ConstByteSpan span);
-		static BAN::Optional<DataRefObject> parse(BAN::ConstByteSpan& span);
-	};
-
-}

kernel/include/kernel/ACPI/AML/Device.h

@@ -0,0 +1,52 @@
+#pragma once
+
+#include <kernel/ACPI/AML/ParseContext.h>
+#include <kernel/ACPI/AML/Pkg.h>
+#include <kernel/ACPI/AML/Scope.h>
+
+namespace Kernel::ACPI::AML
+{
+
+	struct Device : public AML::Scope
+	{
+		Device(NameSeg name) : Scope(name, Node::Type::Device) {}
+
+		static ParseResult parse(ParseContext& context)
+		{
+			ASSERT(context.aml_data.size() >= 2);
+			ASSERT(static_cast<AML::Byte>(context.aml_data[0]) == AML::Byte::ExtOpPrefix);
+			ASSERT(static_cast<AML::ExtOp>(context.aml_data[1]) == AML::ExtOp::DeviceOp);
+			context.aml_data = context.aml_data.slice(2);
+
+			auto device_pkg = AML::parse_pkg(context.aml_data);
+			if (!device_pkg.has_value())
+				return ParseResult::Failure;
+
+			auto name_string = AML::NameString::parse(device_pkg.value());
+			if (!name_string.has_value())
+				return ParseResult::Failure;
+
+			auto device = MUST(BAN::RefPtr<Device>::create(name_string->path.back()));
+			if (!context.root_namespace->add_named_object(context.scope.span(), name_string.value(), device))
+				return ParseResult::Failure;
+
+			return device->enter_context_and_parse_term_list(context, name_string.value(), device_pkg.value());
+		}
+
+		virtual void debug_print(int indent) const override
+		{
+			AML_DEBUG_PRINT_INDENT(indent);
+			AML_DEBUG_PRINT("Device ");
+			name.debug_print();
+			AML_DEBUG_PRINTLN(" {");
+			for (const auto& [name, object] : objects)
+			{
+				object->debug_print(indent + 1);
+				AML_DEBUG_PRINTLN("");
+			}
+			AML_DEBUG_PRINT_INDENT(indent);
+			AML_DEBUG_PRINT("}");
+		}
+	};
+
+}

kernel/include/kernel/ACPI/AML/Field.h

@@ -0,0 +1,89 @@
+#pragma once
+
+#include <kernel/ACPI/AML/NamedObject.h>
+#include <kernel/ACPI/AML/ParseContext.h>
+#include <kernel/ACPI/AML/Pkg.h>
+#include <kernel/ACPI/AML/Region.h>
+
+namespace Kernel::ACPI::AML
+{
+
+	struct FieldRules
+	{
+		enum class AccessType
+		{
+			Any = 0,
+			Byte = 1,
+			Word = 2,
+			DWord = 3,
+			QWord = 4,
+			Buffer = 5,
+		};
+		AccessType access_type;
+
+		enum class LockRule
+		{
+			NoLock = 0,
+			Lock = 1,
+		};
+		LockRule lock_rule;
+
+		enum class UpdateRule
+		{
+			Preserve = 0,
+			WriteAsOnes = 1,
+			WriteAsZeros = 2,
+		};
+		UpdateRule update_rule;
+	};
+
+	struct FieldElement : public NamedObject
+	{
+		uint64_t bit_offset;
+		uint32_t bit_count;
+
+		FieldRules access_rules;
+
+		OpRegion* op_region = nullptr;
+
+		FieldElement(NameSeg name, uint64_t bit_offset, uint32_t bit_count, FieldRules access_rules)
+			: NamedObject(Node::Type::FieldElement, name)
+			, bit_offset(bit_offset)
+			, bit_count(bit_count)
+			, access_rules(access_rules)
+		{}
+
+		void debug_print(int indent) const override;
+	};
+
+	struct Field
+	{
+		static ParseResult parse(ParseContext& context);
+	};
+
+	struct IndexFieldElement : public NamedObject
+	{
+		uint64_t bit_offset;
+		uint32_t bit_count;
+
+		FieldRules access_rules;
+
+		FieldElement* index_element = nullptr;
+		FieldElement* data_element = nullptr;
+
+		IndexFieldElement(NameSeg name, uint64_t bit_offset, uint32_t bit_count, FieldRules access_rules)
+			: NamedObject(Node::Type::IndexFieldElement, name)
+			, bit_offset(bit_offset)
+			, bit_count(bit_count)
+			, access_rules(access_rules)
+		{}
+
+		void debug_print(int indent) const override;
+	};
+
+	struct IndexField
+	{
+		static ParseResult parse(ParseContext& context);
+	};
+
+}

kernel/include/kernel/ACPI/AML/Integer.h

@@ -0,0 +1,92 @@
+#pragma once
+
+#include <BAN/Endianness.h>
+#include <BAN/Optional.h>
+#include <BAN/String.h>
+#include <BAN/Vector.h>
+#include <kernel/ACPI/AML/Bytes.h>
+#include <kernel/ACPI/AML/Node.h>
+#include <kernel/ACPI/AML/Utils.h>
+
+namespace Kernel::ACPI::AML
+{
+
+	struct Integer : public Node
+	{
+		static constexpr uint64_t Ones = -1;
+		uint64_t value;
+
+		Integer(uint64_t value) : Node(Node::Type::Integer), value(value) {}
+
+		BAN::Optional<uint64_t> as_integer() const override
+		{
+			return value;
+		}
+
+		static ParseResult parse(BAN::ConstByteSpan& aml_data)
+		{
+			switch (static_cast<AML::Byte>(aml_data[0]))
+			{
+				case AML::Byte::ZeroOp:
+					aml_data = aml_data.slice(1);
+					return ParseResult(MUST(BAN::RefPtr<Integer>::create(0)));
+				case AML::Byte::OneOp:
+					aml_data = aml_data.slice(1);
+					return ParseResult(MUST(BAN::RefPtr<Integer>::create(1)));
+				case AML::Byte::OnesOp:
+					aml_data = aml_data.slice(1);
+					return ParseResult(MUST(BAN::RefPtr<Integer>::create(Ones)));
+				case AML::Byte::BytePrefix:
+				{
+					if (aml_data.size() < 2)
+						return ParseResult::Failure;
+					uint8_t value = aml_data[1];
+					aml_data = aml_data.slice(2);
+					return ParseResult(MUST(BAN::RefPtr<Integer>::create(value)));
+				}
+				case AML::Byte::WordPrefix:
+				{
+					if (aml_data.size() < 3)
+						return ParseResult::Failure;
+					uint16_t value = BAN::little_endian_to_host<uint16_t>(
+						*reinterpret_cast<const uint16_t*>(&aml_data[1])
+					);
+					aml_data = aml_data.slice(3);
+					return ParseResult(MUST(BAN::RefPtr<Integer>::create(value)));
+				}
+				case AML::Byte::DWordPrefix:
+				{
+					if (aml_data.size() < 5)
+						return ParseResult::Failure;
+					uint32_t value = BAN::little_endian_to_host<uint32_t>(
+						*reinterpret_cast<const uint32_t*>(&aml_data[1])
+					);
+					aml_data = aml_data.slice(5);
+					return ParseResult(MUST(BAN::RefPtr<Integer>::create(value)));
+				}
+				case AML::Byte::QWordPrefix:
+				{
+					if (aml_data.size() < 9)
+						return ParseResult::Failure;
+					uint64_t value = BAN::little_endian_to_host<uint64_t>(
+						*reinterpret_cast<const uint64_t*>(&aml_data[1])
+					);
+					aml_data = aml_data.slice(9);
+					return ParseResult(MUST(BAN::RefPtr<Integer>::create(value)));
+				}
+				default:
+					ASSERT_NOT_REACHED();
+			}
+		}
+
+		void debug_print(int indent) const override
+		{
+			AML_DEBUG_PRINT_INDENT(indent);
+			if (value == Ones)
+				AML_DEBUG_PRINT("Ones");
+			else
+				AML_DEBUG_PRINT("0x{H}", value);
+		}
+	};
+
+}

kernel/include/kernel/ACPI/AML/Method.h

@@ -0,0 +1,78 @@
+#pragma once
+
+#include <kernel/ACPI/AML/Bytes.h>
+#include <kernel/ACPI/AML/NamedObject.h>
+#include <kernel/ACPI/AML/ParseContext.h>
+#include <kernel/ACPI/AML/Pkg.h>
+
+namespace Kernel::ACPI::AML
+{
+
+	struct Method : public AML::NamedObject
+	{
+		uint8_t arg_count;
+		bool serialized;
+		uint8_t sync_level;
+
+		BAN::ConstByteSpan term_list;
+
+		Method(AML::NameSeg name, uint8_t arg_count, bool serialized, uint8_t sync_level, BAN::ConstByteSpan term_list)
+			: AML::NamedObject(Node::Type::Method, name)
+			, arg_count(arg_count)
+			, serialized(serialized)
+			, sync_level(sync_level)
+			, term_list(term_list)
+		{}
+
+		static ParseResult parse(AML::ParseContext& context)
+		{
+			ASSERT(context.aml_data.size() >= 1);
+			ASSERT(static_cast<Byte>(context.aml_data[0]) == Byte::MethodOp);
+			context.aml_data = context.aml_data.slice(1);
+
+			auto method_pkg = AML::parse_pkg(context.aml_data);
+			if (!method_pkg.has_value())
+				return ParseResult::Failure;
+
+			auto name_string = AML::NameString::parse(method_pkg.value());
+			if (!name_string.has_value())
+				return ParseResult::Failure;
+
+			if (method_pkg->size() < 1)
+				return ParseResult::Failure;
+			auto method_flags = method_pkg.value()[0];
+			method_pkg = method_pkg.value().slice(1);
+
+			auto method = MUST(BAN::RefPtr<Method>::create(
+				name_string.value().path.back(),
+				method_flags & 0x07,
+				(method_flags >> 3) & 0x01,
+				method_flags >> 4,
+				method_pkg.value()
+			));
+
+			if (!context.root_namespace->add_named_object(context.scope.span(), name_string.value(), method))
+				return ParseResult::Failure;
+
+#if AML_DEBUG_LEVEL >= 2
+			method->debug_print(0);
+			AML_DEBUG_PRINTLN("");
+#endif
+
+			return ParseResult::Success;
+		}
+
+		virtual void debug_print(int indent) const override
+		{
+			AML_DEBUG_PRINT_INDENT(indent);
+			AML_DEBUG_PRINT("Method ");
+			name.debug_print();
+			AML_DEBUG_PRINTLN("({} args, {}Serialized, 0x{H}) {", arg_count, serialized ? "" : "Not", sync_level);
+			AML_DEBUG_PRINT_INDENT(indent + 1);
+			AML_DEBUG_PRINTLN("TermList: {} bytes", term_list.size());
+			AML_DEBUG_PRINT_INDENT(indent);
+			AML_DEBUG_PRINT("}");
+		}
+	};
+
+}

kernel/include/kernel/ACPI/AML/MiscObject.h

@@ -1,56 +0,0 @@
-#pragma once
-
-#include <BAN/ByteSpan.h>
-#include <BAN/Optional.h>
-
-namespace Kernel::ACPI::AML
-{
-	// ACPI Spec 6.4, Section 20.2.6
-
-	// ArgObj := Arg0Op | Arg1Op | Arg2Op | Arg3Op | Arg4Op | Arg5Op | Arg6Op
-	struct ArgObj
-	{
-		enum class Type
-		{
-			Arg0,
-			Arg1,
-			Arg2,
-			Arg3,
-			Arg4,
-			Arg5,
-			Arg6,
-		};
-		Type type;
-
-		static bool can_parse(BAN::ConstByteSpan span);
-		static BAN::Optional<ArgObj> parse(BAN::ConstByteSpan& span);
-	};
-
-	// LocalObj := Local0Op | Local1Op | Local2Op | Local3Op | Local4Op | Local5Op | Local6Op | Local7Op
-	struct LocalObj
-	{
-		enum class Type
-		{
-			Local0,
-			Local1,
-			Local2,
-			Local3,
-			Local4,
-			Local5,
-			Local6,
-			Local7,
-		};
-		Type type;
-
-		static bool can_parse(BAN::ConstByteSpan span);
-		static BAN::Optional<LocalObj> parse(BAN::ConstByteSpan& span);
-	};
-
-	// DebugObj := DebugOp
-	struct DebugObj
-	{
-		static bool can_parse(BAN::ConstByteSpan span);
-		static BAN::Optional<DebugObj> parse(BAN::ConstByteSpan& span);
-	};
-
-}

kernel/include/kernel/ACPI/AML/Mutex.h

@@ -0,0 +1,62 @@
+#pragma once
+
+#include <kernel/ACPI/AML/Bytes.h>
+#include <kernel/ACPI/AML/NamedObject.h>
+#include <kernel/ACPI/AML/ParseContext.h>
+
+namespace Kernel::ACPI::AML
+{
+
+	struct Mutex : public AML::NamedObject
+	{
+		uint8_t sync_level;
+
+		Mutex(NameSeg name, uint8_t sync_level)
+			: NamedObject(Node::Type::Mutex, name)
+			, sync_level(sync_level)
+		{}
+
+		static ParseResult parse(ParseContext& context)
+		{
+			ASSERT(context.aml_data.size() >= 2);
+			ASSERT(static_cast<AML::Byte>(context.aml_data[0]) == AML::Byte::ExtOpPrefix);
+			ASSERT(static_cast<AML::ExtOp>(context.aml_data[1]) == AML::ExtOp::MutexOp);
+			context.aml_data = context.aml_data.slice(2);
+
+			auto name = NameString::parse(context.aml_data);
+			if (!name.has_value())
+				return ParseResult::Failure;
+
+			if (context.aml_data.size() < 1)
+				return ParseResult::Failure;
+			auto sync_level = context.aml_data[0];
+			context.aml_data = context.aml_data.slice(1);
+
+			if (sync_level & 0xF0)
+			{
+				AML_ERROR("Invalid sync level {}", sync_level);
+				return ParseResult::Failure;
+			}
+
+			auto mutex = MUST(BAN::RefPtr<Mutex>::create(name->path.back(), sync_level));
+			if (!context.root_namespace->add_named_object(context.scope.span(), name.value(), mutex))
+				return ParseResult::Failure;
+
+#if AML_DEBUG_LEVEL >= 2
+			mutex->debug_print(0);
+			AML_DEBUG_PRINTLN("");
+#endif
+
+			return ParseResult::Success;
+		}
+
+		virtual void debug_print(int indent) const override
+		{
+			AML_DEBUG_PRINT_INDENT(indent);
+			AML_DEBUG_PRINT("Mutex ");
+			name.debug_print();
+			AML_DEBUG_PRINT(" (SyncLevel: {})", sync_level);
+		}
+	};
+
+}

kernel/include/kernel/ACPI/AML/NameObject.h

@@ -1,46 +0,0 @@
-#pragma once
-
-#include <BAN/ByteSpan.h>
-#include <BAN/Optional.h>
-#include <BAN/String.h>
-#include <BAN/UniqPtr.h>
-#include <BAN/Variant.h>
-#include <BAN/Vector.h>
-#include <kernel/ACPI/AML/MiscObject.h>
-
-namespace Kernel::ACPI::AML
-{
-	// ACPI Spec 6.4, Section 20.2.2
-
-	// NameSeg := LeadNameChar NameChar NameChar NameChar
-	// NameString := ('\' | {'^'}) (NameSeg | (DualNamePrefix NameSeg NameSeg) | (MultiNamePrefix SegCount NameSeg(SegCount)) | 0x00)
-	struct NameString
-	{
-		BAN::String prefix;
-		BAN::Vector<BAN::String> path;
-
-		static bool can_parse(BAN::ConstByteSpan span);
-		static BAN::Optional<NameString> parse(BAN::ConstByteSpan& span);
-	};
-
-	// SimpleName := NameString | ArgObj | LocalObj
-	struct SimpleName
-	{
-		BAN::Variant<NameString, ArgObj, LocalObj> name;
-
-		static bool can_parse(BAN::ConstByteSpan span);
-		static BAN::Optional<SimpleName> parse(BAN::ConstByteSpan& span);
-	};
-
-	struct ReferenceTypeOpcode;
-
-	// SuperName := SimpleName | DebugObj | ReferenceTypeOpcode
-	struct SuperName
-	{
-		BAN::Variant<SimpleName, DebugObj, BAN::UniqPtr<ReferenceTypeOpcode>> name;
-
-		static bool can_parse(BAN::ConstByteSpan span);
-		static BAN::Optional<SuperName> parse(BAN::ConstByteSpan& span);
-	};
-
-}

kernel/include/kernel/ACPI/AML/NamedObject.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <BAN/HashMap.h>
+#include <kernel/ACPI/AML/Names.h>
+
+namespace Kernel::ACPI::AML
+{
+
+	struct NamedObject : public Node
+	{
+		NameSeg name;
+
+		NamedObject(Node::Type type, NameSeg name) : Node(type), name(name) {}
+	};
+
+	struct Name : public NamedObject
+	{
+		BAN::RefPtr<AML::Node> object;
+
+		Name(NameSeg name, BAN::RefPtr<AML::Node> object)
+			: NamedObject(Node::Type::Name, name), object(BAN::move(object))
+		{}
+
+		static ParseResult parse(ParseContext& context);
+		virtual void debug_print(int indent) const override;
+	};
+
+}

kernel/include/kernel/ACPI/AML/Names.h

@@ -0,0 +1,157 @@
+#pragma once
+
+#include <BAN/Optional.h>
+#include <BAN/String.h>
+#include <BAN/Vector.h>
+#include <kernel/ACPI/AML/Bytes.h>
+#include <kernel/ACPI/AML/Node.h>
+#include <kernel/ACPI/AML/Utils.h>
+
+namespace Kernel::ACPI::AML
+{
+
+	struct NameSeg
+	{
+		union {
+			char chars[4];
+			uint32_t u32;
+		};
+
+		NameSeg() = default;
+
+		NameSeg(BAN::StringView name)
+		{
+			ASSERT(name.size() <= 4);
+			for (size_t i = 0; i < name.size(); i++)
+				chars[i] = static_cast<char>(name[i]);
+			for (size_t i = name.size(); i < 4; i++)
+				chars[i] = '_';
+		}
+
+		NameSeg(BAN::ConstByteSpan& aml_data)
+		{
+			ASSERT(aml_data.size() >= 4);
+			for (size_t i = 0; i < 4; i++)
+				chars[i] = static_cast<char>(aml_data[i]);
+			aml_data = aml_data.slice(4);
+		}
+
+		static BAN::Optional<NameSeg> parse(BAN::ConstByteSpan& aml_data)
+		{
+			if (aml_data.size() < 4)
+				return {};
+
+			if (!is_lead_name_char(aml_data[0])
+				|| !is_name_char(aml_data[1])
+				|| !is_name_char(aml_data[2])
+				|| !is_name_char(aml_data[3]))
+				return {};
+
+			return NameSeg(aml_data);
+		}
+
+		constexpr bool operator==(const NameSeg& other) const
+		{
+			return u32 == other.u32;
+		}
+
+		void debug_print() const
+		{
+			size_t len = 4;
+			while (len > 0 && chars[len - 1] == '_')
+				len--;
+			for (size_t i = 0; i < len; i++)
+				AML_DEBUG_PUTC(chars[i]);
+		}
+	};
+
+	struct NameString
+	{
+		BAN::String prefix;
+		BAN::Vector<NameSeg> path;
+
+		static BAN::Optional<NameString> parse(BAN::ConstByteSpan& aml_data)
+		{
+			if (aml_data.size() == 0)
+				return {};
+
+			NameString result;
+
+			if (static_cast<AML::Byte>(aml_data[0]) == AML::Byte::RootChar)
+			{
+				MUST(result.prefix.push_back('\\'));
+				aml_data = aml_data.slice(1);
+			}
+			else
+			{
+				while (aml_data.size() > 0 && static_cast<AML::Byte>(aml_data[0]) == AML::Byte::ParentPrefixChar)
+				{
+					MUST(result.prefix.push_back(aml_data[0]));
+					aml_data = aml_data.slice(1);
+				}
+			}
+
+			if (aml_data.size() == 0)
+				return {};
+
+			size_t name_count = 1;
+			switch (static_cast<AML::Byte>(aml_data[0]))
+			{
+				case AML::Byte::NullName:
+					name_count = 0;
+					aml_data = aml_data.slice(1);
+					break;
+				case AML::Byte::DualNamePrefix:
+					name_count = 2;
+					aml_data = aml_data.slice(1);
+					break;
+				case AML::Byte::MultiNamePrefix:
+					if (aml_data.size() < 2)
+						return {};
+					name_count = aml_data[1];
+					aml_data = aml_data.slice(2);
+					break;
+				default:
+					break;
+			}
+
+			for (size_t i = 0; i < name_count; i++)
+			{
+				auto name_seg = NameSeg::parse(aml_data);
+				if (!name_seg.has_value())
+					return {};
+				MUST(result.path.push_back(name_seg.release_value()));
+			}
+
+			return result;
+		}
+
+		void debug_print() const
+		{
+			for (size_t i = 0; i < prefix.size(); i++)
+				AML_DEBUG_PUTC(prefix[i]);
+			if (!path.empty())
+				path.front().debug_print();
+			for (size_t i = 1; i < path.size(); i++)
+			{
+				AML_DEBUG_PUTC('.');
+				path[i].debug_print();
+			}
+		}
+	};
+
+}
+
+namespace BAN
+{
+
+	template<>
+	struct hash<Kernel::ACPI::AML::NameSeg>
+	{
+		constexpr hash_t operator()(Kernel::ACPI::AML::NameSeg name) const
+		{
+			return hash<uint32_t>()(name.u32);
+		}
+	};
+
+}

kernel/include/kernel/ACPI/AML/Namespace.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include <kernel/ACPI/AML/Scope.h>
+
+namespace Kernel::ACPI::AML
+{
+
+	struct Namespace : public AML::Scope
+	{
+		Namespace() : AML::Scope(NameSeg("\\"sv)) {}
+
+		static BAN::RefPtr<Namespace> parse(BAN::ConstByteSpan aml);
+
+		BAN::Optional<BAN::Vector<AML::NameSeg>> resolve_path(BAN::Span<const AML::NameSeg> parsing_scope, const AML::NameString& relative_path);
+
+		// Find an object in the namespace. Returns nullptr if the object is not found.
+		BAN::RefPtr<NamedObject> find_object(BAN::Span<const AML::NameSeg> parsing_scope, const AML::NameString& relative_path);
+
+		// Add an object to the namespace. Returns false if the parent object could not be added.
+		bool add_named_object(BAN::Span<const AML::NameSeg> parsing_scope, const AML::NameString& object_path, BAN::RefPtr<NamedObject> object);
+	};
+
+}

kernel/include/kernel/ACPI/AML/Node.h

@@ -0,0 +1,69 @@
+#pragma once
+
+#include <BAN/ByteSpan.h>
+#include <BAN/Optional.h>
+#include <BAN/RefPtr.h>
+#include <BAN/Vector.h>
+
+namespace Kernel::ACPI::AML
+{
+
+	struct Node : public BAN::RefCounted<Node>
+	{
+		enum class Type
+		{
+			Buffer,
+			Device,
+			FieldElement,
+			IndexFieldElement,
+			Integer,
+			Method,
+			Mutex,
+			Name,
+			OpRegion,
+			Package,
+			Processor,
+			Scope,
+			String,
+		};
+		const Type type;
+
+		Node(Type type) : type(type) {}
+		virtual ~Node() = default;
+
+		virtual bool is_scope() const { return false; }
+		virtual BAN::Optional<uint64_t> as_integer() const { return {}; }
+
+		virtual void debug_print(int indent) const = 0;
+	};
+
+	struct ParseContext;
+	struct ParseResult
+	{
+		static ParseResult Failure;
+		static ParseResult Success;
+
+		enum class Result
+		{
+			Success,
+			Failure,
+		};
+
+		ParseResult(Result success) : m_result(success) {}
+		ParseResult(BAN::RefPtr<Node> node) : m_result(Result::Success), m_node(BAN::move(node)) { ASSERT(m_node); }
+
+		bool success() const { return m_result == Result::Success; }
+
+		BAN::RefPtr<Node> node()
+		{
+			ASSERT(m_node);
+			return m_node;
+		}
+
+	private:
+		Result m_result = Result::Failure;
+		BAN::RefPtr<Node> m_node;
+	};
+	ParseResult parse_object(ParseContext& context);
+
+}

kernel/include/kernel/ACPI/AML/Package.h

@@ -0,0 +1,66 @@
+#pragma once
+
+#include <kernel/ACPI/AML/Bytes.h>
+#include <kernel/ACPI/AML/Node.h>
+#include <kernel/ACPI/AML/ParseContext.h>
+#include <kernel/ACPI/AML/Pkg.h>
+
+namespace Kernel::ACPI::AML
+{
+
+	struct Package : public AML::Node
+	{
+		BAN::Vector<BAN::RefPtr<AML::Node>> elements;
+
+		Package() : Node(Node::Type::Package) {}
+
+		static ParseResult parse(AML::ParseContext& context)
+		{
+			ASSERT(context.aml_data.size() >= 1);
+			ASSERT(static_cast<Byte>(context.aml_data[0]) == Byte::PackageOp);
+			context.aml_data = context.aml_data.slice(1);
+
+			auto package_pkg = AML::parse_pkg(context.aml_data);
+			if (!package_pkg.has_value())
+				return ParseResult::Failure;
+
+			auto package_context = context;
+			package_context.aml_data = package_pkg.value();
+
+			if (package_pkg->size() < 1)
+				return ParseResult::Failure;
+			uint8_t num_elements = package_context.aml_data[0];
+			package_context.aml_data = package_context.aml_data.slice(1);
+
+			BAN::Vector<BAN::RefPtr<AML::Node>> elements;
+			while (elements.size() < num_elements && package_context.aml_data.size() > 0)
+			{
+				auto element_result = AML::parse_object(package_context);
+				if (!element_result.success())
+					return ParseResult::Failure;
+				MUST(elements.push_back(element_result.node()));
+			}
+			while (elements.size() < num_elements)
+				MUST(elements.push_back(BAN::RefPtr<AML::Node>()));
+
+			auto package = MUST(BAN::RefPtr<Package>::create());
+			package->elements = BAN::move(elements);
+			return ParseResult(package);
+		}
+
+		virtual void debug_print(int indent) const override
+		{
+			AML_DEBUG_PRINT_INDENT(indent);
+			AML_DEBUG_PRINT("Package {");
+			AML_DEBUG_PRINTLN("");
+			for (const auto& element : elements)
+			{
+				element->debug_print(indent + 1);
+				AML_DEBUG_PRINTLN("");
+			}
+			AML_DEBUG_PRINT_INDENT(indent);
+			AML_DEBUG_PRINT("}");
+		}
+	};
+
+}

kernel/include/kernel/ACPI/AML/PackageLength.h

@@ -1,36 +0,0 @@
-#pragma once
-
-#include <BAN/ByteSpan.h>
-#include <BAN/Optional.h>
-#include <kernel/ACPI/AML/Bytes.h>
-
-namespace Kernel::ACPI::AML
-{
-
-	struct PkgLength
-	{
-		static BAN::Optional<BAN::ConstByteSpan> parse_package(BAN::ConstByteSpan& span)
-		{
-			if (span.size() < 1)
-				return {};
-
-			uint8_t count = (span[0] >> 6) + 1;
-			if (span.size() < count)
-				return {};
-			if (count > 1 && (span[0] & 0x30))
-				return {};
-
-			uint32_t length = span[0] & 0x3F;
-			for (uint8_t i = 1; i < count; i++)
-				length |= static_cast<uint32_t>(span[i]) << (i * 8 - 4);
-
-			if (span.size() < length)
-				return {};
-
-			auto result = span.slice(count, length - count);
-			span = span.slice(length);
-			return result;
-		}
-	};
-
-}

kernel/include/kernel/ACPI/AML/ParseContext.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include <BAN/ByteSpan.h>
+#include <BAN/Vector.h>
+#include <kernel/ACPI/AML/NamedObject.h>
+#include <kernel/ACPI/AML/Namespace.h>
+
+namespace Kernel::ACPI::AML
+{
+
+	struct ParseContext
+	{
+		BAN::ConstByteSpan aml_data;
+		BAN::Vector<AML::NameSeg> scope;
+		struct Namespace* root_namespace;
+	};
+
+}

kernel/include/kernel/ACPI/AML/Pkg.h

@@ -0,0 +1,51 @@
+#pragma once
+
+#include <BAN/ByteSpan.h>
+#include <BAN/Optional.h>
+
+namespace Kernel::ACPI::AML
+{
+
+	static BAN::Optional<uint32_t> parse_pkg_length(BAN::ConstByteSpan aml_data)
+	{
+		if (aml_data.size() < 1)
+			return {};
+
+		uint8_t lead_byte = aml_data[0];
+		if ((lead_byte & 0xC0) && (lead_byte & 0x30))
+			return {};
+
+		uint32_t pkg_length = lead_byte & 0x3F;
+		uint8_t byte_count = (lead_byte >> 6) + 1;
+
+		if (aml_data.size() < byte_count)
+			return {};
+
+		for (uint8_t i = 1; i < byte_count; i++)
+			pkg_length |= aml_data[i] << (i * 8 - 4);
+
+		return pkg_length;
+	}
+
+	static void trim_pkg_length(BAN::ConstByteSpan& aml_data)
+	{
+		ASSERT(aml_data.size() >= 1);
+		uint8_t byte_count = (aml_data[0] >> 6) + 1;
+		aml_data = aml_data.slice(byte_count);
+	}
+
+	static BAN::Optional<BAN::ConstByteSpan> parse_pkg(BAN::ConstByteSpan& aml_data)
+	{
+		auto pkg_length = parse_pkg_length(aml_data);
+		if (!pkg_length.has_value())
+			return {};
+
+		auto result = aml_data.slice(0, pkg_length.value());
+		trim_pkg_length(result);
+
+		aml_data = aml_data.slice(pkg_length.value());
+
+		return result;
+	}
+
+}

kernel/include/kernel/ACPI/AML/Processor.h

@@ -0,0 +1,71 @@
+#pragma once
+
+#include <BAN/Endianness.h>
+#include <kernel/ACPI/AML/Bytes.h>
+#include <kernel/ACPI/AML/ParseContext.h>
+#include <kernel/ACPI/AML/Pkg.h>
+#include <kernel/ACPI/AML/Scope.h>
+
+namespace Kernel::ACPI::AML
+{
+
+	struct Processor : public AML::Scope
+	{
+		uint8_t id;
+		uint32_t pblk_addr;
+		uint8_t pblk_len;
+
+		Processor(NameSeg name, uint8_t id, uint32_t pblk_addr, uint8_t pblk_len)
+			: Scope(name, Node::Type::Processor)
+			, id(id)
+			, pblk_addr(pblk_addr)
+			, pblk_len(pblk_len)
+		{}
+
+		static ParseResult parse(ParseContext& context)
+		{
+			ASSERT(context.aml_data.size() >= 2);
+			ASSERT(static_cast<AML::Byte>(context.aml_data[0]) == AML::Byte::ExtOpPrefix);
+			ASSERT(static_cast<AML::ExtOp>(context.aml_data[1]) == AML::ExtOp::ProcessorOp);
+			context.aml_data = context.aml_data.slice(2);
+
+			auto processor_pkg = AML::parse_pkg(context.aml_data);
+			if (!processor_pkg.has_value())
+				return ParseResult::Failure;
+
+			auto name = NameString::parse(processor_pkg.value());
+			if (!name.has_value())
+				return ParseResult::Failure;
+
+			if (processor_pkg->size() < 1)
+				return ParseResult::Failure;
+			uint8_t id = processor_pkg.value()[0];
+			processor_pkg = processor_pkg->slice(1);
+
+			if (processor_pkg->size() < 4)
+				return ParseResult::Failure;
+			uint32_t pblk_addr = BAN::little_endian_to_host<uint32_t>(*reinterpret_cast<const uint32_t*>(processor_pkg->data()));
+			processor_pkg = processor_pkg->slice(4);
+
+			if (processor_pkg->size() < 1)
+				return ParseResult::Failure;
+			uint8_t pblk_len = processor_pkg.value()[0];
+			processor_pkg = processor_pkg->slice(1);
+
+			auto processor = MUST(BAN::RefPtr<Processor>::create(name->path.back(), id, pblk_addr, pblk_len));
+			if (!context.root_namespace->add_named_object(context.scope.span(), name.value(), processor))
+				return ParseResult::Failure;
+
+			return processor->enter_context_and_parse_term_list(context, name.value(), processor_pkg.value());
+		}
+
+		virtual void debug_print(int indent) const override
+		{
+			AML_DEBUG_PRINT_INDENT(indent);
+			AML_DEBUG_PRINT("Processor ");
+			name.debug_print();
+			AML_DEBUG_PRINT(" (ID: {}, PBlkAddr: 0x{H}, PBlkLen: {})", id, pblk_addr, pblk_len);
+		}
+	};
+
+}

kernel/include/kernel/ACPI/AML/Region.h

@@ -0,0 +1,114 @@
+#pragma once
+
+#include <kernel/ACPI/AML/NamedObject.h>
+#include <kernel/ACPI/AML/Namespace.h>
+#include <kernel/ACPI/AML/ParseContext.h>
+
+namespace Kernel::ACPI::AML
+{
+
+	struct OpRegion : public NamedObject
+	{
+		enum class RegionSpace
+		{
+			SystemMemory = 0,
+			SystemIO = 1,
+			PCIConfig = 2,
+			EmbeddedController = 3,
+			SMBus = 4,
+			SystemCMOS = 5,
+			PCIBarTarget = 6,
+			IPMI = 7,
+			GeneralPurposeIO = 8,
+			GenericSerialBus = 9,
+			PCC = 10,
+		};
+		RegionSpace space;
+		uint64_t offset;
+		uint64_t length;
+
+		OpRegion(NameSeg name, RegionSpace space, uint64_t offset, uint64_t length)
+			: NamedObject(Node::Type::OpRegion, name), space(space), offset(offset), length(length)
+		{}
+
+		static ParseResult parse(AML::ParseContext& context)
+		{
+			ASSERT(context.aml_data.size() > 2);
+			ASSERT(static_cast<Byte>(context.aml_data[0]) == Byte::ExtOpPrefix);
+			ASSERT(static_cast<ExtOp>(context.aml_data[1]) == ExtOp::OpRegionOp);
+			context.aml_data = context.aml_data.slice(2);
+
+			auto name = NameString::parse(context.aml_data);
+			if (!name.has_value())
+				return ParseResult::Failure;
+
+			if (context.aml_data.size() < 1)
+				return ParseResult::Failure;
+			auto region_space = static_cast<RegionSpace>(context.aml_data[0]);
+			context.aml_data = context.aml_data.slice(1);
+
+			auto offset_result = AML::parse_object(context);
+			if (!offset_result.success())
+				return ParseResult::Failure;
+			auto offset = offset_result.node()->as_integer();
+			if (!offset.has_value())
+			{
+				AML_ERROR("OpRegion offset must be an integer");
+				return ParseResult::Failure;
+			}
+
+			auto length_result = AML::parse_object(context);
+			if (!length_result.success())
+				return ParseResult::Failure;
+			auto length = length_result.node()->as_integer();
+			if (!length.has_value())
+			{
+				AML_ERROR("OpRegion length must be an integer");
+				return ParseResult::Failure;
+			}
+
+			auto op_region = MUST(BAN::RefPtr<OpRegion>::create(
+				name->path.back(),
+				region_space,
+				offset.value(),
+				length.value()
+			));
+
+			if (!context.root_namespace->add_named_object(context.scope.span(), name.value(), op_region))
+				return ParseResult::Failure;
+
+#if AML_DEBUG_LEVEL >= 2
+			op_region->debug_print(0);
+			AML_DEBUG_PRINTLN("");
+#endif
+
+			return ParseResult::Success;
+		}
+
+		virtual void debug_print(int indent) const override
+		{
+			BAN::StringView region_space_name;
+			switch (space)
+			{
+				case RegionSpace::SystemMemory:			region_space_name = "SystemMemory"sv; break;
+				case RegionSpace::SystemIO:				region_space_name = "SystemIO"sv; break;
+				case RegionSpace::PCIConfig:			region_space_name = "PCIConfig"sv; break;
+				case RegionSpace::EmbeddedController:	region_space_name = "EmbeddedController"sv; break;
+				case RegionSpace::SMBus:				region_space_name = "SMBus"sv; break;
+				case RegionSpace::SystemCMOS:			region_space_name = "SystemCMOS"sv; break;
+				case RegionSpace::PCIBarTarget:			region_space_name = "PCIBarTarget"sv; break;
+				case RegionSpace::IPMI:					region_space_name = "IPMI"sv; break;
+				case RegionSpace::GeneralPurposeIO:		region_space_name = "GeneralPurposeIO"sv; break;
+				case RegionSpace::GenericSerialBus:		region_space_name = "GenericSerialBus"sv; break;
+				case RegionSpace::PCC:					region_space_name = "PCC"sv; break;
+				default: region_space_name = "Unknown"sv; break;
+			}
+			AML_DEBUG_PRINT_INDENT(indent);
+			AML_DEBUG_PRINT("OperationRegion(");
+			name.debug_print();
+			AML_DEBUG_PRINT(", {}, 0x{H}, 0x{H})", region_space_name, offset, length);
+		}
+
+	};
+
+}

kernel/include/kernel/ACPI/AML/Scope.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <BAN/HashMap.h>
+#include <kernel/ACPI/AML/NamedObject.h>
+#include <kernel/ACPI/AML/Names.h>
+
+namespace Kernel::ACPI::AML
+{
+
+	struct Scope : public AML::NamedObject
+	{
+		BAN::HashMap<NameSeg, BAN::RefPtr<NamedObject>> objects;
+
+		Scope(NameSeg name, Node::Type type = Node::Type::Scope) : NamedObject(type, name) {}
+
+		virtual bool is_scope() const override { return true; }
+
+		static ParseResult parse(ParseContext& context);
+		virtual void debug_print(int indent) const override;
+
+	protected:
+		ParseResult enter_context_and_parse_term_list(ParseContext& outer_context, const AML::NameString& name, BAN::ConstByteSpan aml_data);
+	};
+
+}

kernel/include/kernel/ACPI/AML/String.h

@@ -0,0 +1,51 @@
+#pragma once
+
+#include <kernel/ACPI/AML/Bytes.h>
+#include <kernel/ACPI/AML/Node.h>
+#include <kernel/ACPI/AML/ParseContext.h>
+
+namespace Kernel::ACPI::AML
+{
+
+	struct String : public AML::Node
+	{
+		BAN::String string;
+
+		String() : Node(Node::Type::String) {}
+
+		static ParseResult parse(ParseContext& context)
+		{
+			ASSERT(context.aml_data.size() >= 1);
+			ASSERT(static_cast<AML::Byte>(context.aml_data[0]) == AML::Byte::StringPrefix);
+			context.aml_data = context.aml_data.slice(1);
+
+			BAN::String string;
+
+			while (context.aml_data.size() > 0)
+			{
+				if (context.aml_data[0] == 0x00)
+					break;
+				MUST(string.push_back(static_cast<char>(context.aml_data[0])));
+				context.aml_data = context.aml_data.slice(1);
+			}
+
+			if (context.aml_data.size() == 0)
+				return ParseResult::Failure;
+			if (context.aml_data[0] != 0x00)
+				return ParseResult::Failure;
+			context.aml_data = context.aml_data.slice(1);
+
+			auto string_node = MUST(BAN::RefPtr<String>::create());
+			string_node->string = BAN::move(string);
+
+			return ParseResult(string_node);
+		}
+
+		virtual void debug_print(int indent) const override
+		{
+			AML_DEBUG_PRINT_INDENT(indent);
+			AML_DEBUG_PRINT("String \"{}\"", string);
+		}
+	};
+
+}

kernel/include/kernel/ACPI/AML/TermObject.h

@@ -1,328 +0,0 @@
-#pragma once
-
-#include <BAN/ByteSpan.h>
-#include <BAN/Optional.h>
-#include <BAN/UniqPtr.h>
-#include <BAN/Variant.h>
-#include <BAN/Vector.h>
-#include <kernel/ACPI/AML/DataObject.h>
-#include <kernel/ACPI/AML/MiscObject.h>
-#include <kernel/ACPI/AML/NameObject.h>
-
-namespace Kernel::ACPI::AML
-{
-	// ACPI Spec 6.4, Section 20.2.5
-
-	struct TermObj;
-	struct TermArg;
-
-	// TermList := Nothing | TermObj TermList
-	struct TermList
-	{
-		BAN::Vector<TermObj> terms;
-
-		static bool can_parse(BAN::ConstByteSpan);
-		static BAN::Optional<TermList> parse(BAN::ConstByteSpan&);
-	};
-
-	// MethodInvocation := NameString TermArgList
-	struct MethodInvocation
-	{
-		NameString name;
-		BAN::Vector<TermArg> term_args;
-
-		static bool can_parse(BAN::ConstByteSpan);
-		static BAN::Optional<MethodInvocation> parse(BAN::ConstByteSpan&);
-	};
-
-	// ExpressionOpcode := DefAcquire | DefAdd | DefAnd | DefBuffer | DefConcat | DefConcatRes | DefCondRefOf
-	//                   | DefCopyObject | DefDecrement | DefDerefOf | DefDivide | DefFindSetLeftBit
-	//                   | DefFindSetRightBit | DefFromBCD | DefIncrement | DefIndex | DefLAnd | DefLEqual
-	//                   | DefLGreater | DefLGreaterEqual | DefLLess | DefLLessEqual | DefMid | DefLNot
-	//                   | DefLNotEqual | DefLoadTable | DefLOr | DefMatch | DefMod | DefMultiply | DefNAnd
-	//                   | DefNOr | DefNot | DefObjectType | DefOr | DefPackage | DefVarPackage | DefRefOf
-	//                   | DefShiftLeft | DefShiftRight | DefSizeOf | DefStore | DefSubtract | DefTimer
-	//                   | DefToBCD | DefToBuffer | DefToDecimalString | DefToHexString | DefToInteger
-	//                   | DefToString | DefWait | DefXOr | MethodInvocation
-	struct ExpressionOpcode
-	{
-		struct UnaryOp
-		{
-			enum class Type
-			{
-				Decrement,
-				Increment,
-				RefOf,
-				SizeOf,
-			};
-			Type type;
-			SuperName object;
-		};
-
-		struct BinaryOp
-		{
-			enum class Type
-			{
-				Add,
-				And,
-				Multiply,
-				NAnd,
-				NOr,
-				Or,
-				Subtract,
-				XOr,
-				ShiftLeft,
-				ShiftRight,
-			};
-			Type type;
-			BAN::UniqPtr<TermArg> source1;
-			BAN::UniqPtr<TermArg> source2;
-			SuperName target;
-		};
-
-		struct LogicalBinaryOp
-		{
-			enum class Type
-			{
-				And,
-				Equal,
-				Greater,
-				Less,
-				Or,
-				// GreaterEqual, LessEqual, NotEqual handled by Not + LogicalBinaryOp
-			};
-			Type type;
-			BAN::UniqPtr<TermArg> operand1;
-			BAN::UniqPtr<TermArg> operand2;
-		};
-
-#define GEN_OPCODE_STRUCT_OPERAND_TARGET(NAME) struct NAME { BAN::UniqPtr<TermArg> operand; SuperName target; }
-		GEN_OPCODE_STRUCT_OPERAND_TARGET(ToBuffer);
-		GEN_OPCODE_STRUCT_OPERAND_TARGET(ToDecimalString);
-		GEN_OPCODE_STRUCT_OPERAND_TARGET(ToHexString);
-		GEN_OPCODE_STRUCT_OPERAND_TARGET(ToInteger);
-#undef GEN_OPCODE_STRUCT_OPERAND_TARGET
-
-		struct Acquire
-		{
-			SuperName mutex;
-			uint16_t timeout;
-		};
-		struct Store
-		{
-			BAN::UniqPtr<TermArg> source;
-			SuperName target;
-		};
-
-		BAN::Variant<
-			UnaryOp, BinaryOp, LogicalBinaryOp,
-			ToBuffer, ToDecimalString, ToHexString, ToInteger,
-			Acquire, Buffer, Package, VarPackage, Store, MethodInvocation
-		> opcode;
-
-		static bool can_parse(BAN::ConstByteSpan);
-		static BAN::Optional<ExpressionOpcode> parse(BAN::ConstByteSpan&);
-	};
-
-	// TermArg := ExpressionOpcode | DataObject | ArgObj | LocalObj
-	struct TermArg
-	{
-		BAN::Variant<ExpressionOpcode, DataObject, ArgObj, LocalObj> arg;
-
-		static bool can_parse(BAN::ConstByteSpan);
-		static BAN::Optional<TermArg> parse(BAN::ConstByteSpan&);
-	};
-
-	// NameSpaceModifierObj := DefAlias | DefName | DefScope
-	struct NameSpaceModifierObj
-	{
-		struct Alias {};
-		struct Name
-		{
-			NameString name;
-			DataRefObject object;
-		};
-		struct Scope
-		{
-			NameString name;
-			TermList term_list;
-		};
-		BAN::Variant<Alias, Name, Scope> modifier;
-
-		static bool can_parse(BAN::ConstByteSpan);
-		static BAN::Optional<NameSpaceModifierObj> parse(BAN::ConstByteSpan&);
-	};
-
-	// NamedObj := DefBankField | DefCreateBitField | DefCreateByteField | DefCreateDWordField | DefCreateField
-	//           | DefCreateQWordField | DefCreateWordField | DefDataRegion | DefExternal | DefOpRegion
-	//           | DefProcessor(deprecated) | DefPowerRes | DefThermalZone
-	// Spec does not specify any of DefDevice, DefEvent, DefField, DefIndexField, DefMethod, DefMutex as options
-	struct NamedObj
-	{
-		struct CreateSizedField
-		{
-			enum class Type
-			{
-				Bit,
-				Byte,
-				Word,
-				DWord,
-				QWord,
-			};
-			Type type;
-			TermArg buffer;
-			TermArg index;
-			NameString name;
-		};
-
-		struct BankField {};
-		struct CreateField {};
-		struct DataRegion {};
-		struct External {};
-		struct OpRegion
-		{
-			enum class RegionSpace : uint8_t
-			{
-				SystemMemory = 0x00,
-				SystemIO = 0x01,
-				PCIConfigSpace = 0x02,
-				EmbeddedController = 0x03,
-				SMBus = 0x04,
-				SystemCMOS = 0x05,
-				PCIBarTarget = 0x06,
-				IPMI = 0x07,
-				GeneralPurposeIO = 0x08,
-				ResourceDescriptor = 0x09,
-				PCC = 0x0A,
-			};
-
-			NameString name;
-			RegionSpace region_space;
-			TermArg region_offset;
-			TermArg region_length;
-		};
-		struct Processor
-		{
-			NameString name;
-			uint8_t processor_id;
-			uint32_t p_blk_address;
-			uint8_t p_blk_length;
-			TermList term_list;
-		};
-		struct PowerRes {};
-		struct ThermalZone {};
-		struct Device
-		{
-			NameString name;
-			TermList term_list;
-		};
-		struct Event {};
-		struct Field
-		{
-			NameString name;
-			// field flags
-			// field list
-		};
-		struct IndexField {};
-		struct Method
-		{
-			NameString name;
-			uint8_t argument_count;
-			bool serialized;
-			uint8_t sync_level;
-			TermList term_list;
-		};
-		struct Mutex
-		{
-			NameString name;
-			uint8_t sync_level;
-		};
-
-		BAN::Variant<BankField, CreateSizedField, CreateField, DataRegion,
-			External, OpRegion, PowerRes, Processor, ThermalZone, Device,
-			Event, Field, IndexField, Method, Mutex
-		> object;
-
-		static bool can_parse(BAN::ConstByteSpan);
-		static BAN::Optional<NamedObj> parse(BAN::ConstByteSpan&);
-	};
-
-	// Object := NameSpaceModifierObj | NamedObj
-	struct Object
-	{
-		BAN::Variant<NameSpaceModifierObj, NamedObj> object;
-
-		static bool can_parse(BAN::ConstByteSpan);
-		static BAN::Optional<Object> parse(BAN::ConstByteSpan&);
-	};
-
-	// StatementOpcode := DefBreak | DefBreakPoint | DefContinue | DefFatal | DefIfElse | DefNoop | DefNotify
-	//                  | DefRelease | DefReset | DefReturn | DefSignal | DefSleep | DefStall | DefWhile
-	struct StatementOpcode
-	{
-		struct IfElse
-		{
-			TermArg predicate;
-			TermList true_list;
-			TermList false_list;
-		};
-		struct Notify
-		{
-			SuperName object;
-			TermArg value;
-		};
-		struct Release
-		{
-			SuperName mutex;
-		};
-		struct Return
-		{
-			// TODO: Is argument actually optional?
-			//       This is not specified in the spec but it seems like it should be
-			BAN::Optional<DataRefObject> arg;
-		};
-
-		BAN::Variant<IfElse, Notify, Release, Return> opcode;
-
-		static bool can_parse(BAN::ConstByteSpan);
-		static BAN::Optional<StatementOpcode> parse(BAN::ConstByteSpan&);
-	};
-
-	// TermObj := Object | StatementOpcode | ExpressionOpcode
-	struct TermObj
-	{
-		BAN::Variant<Object, StatementOpcode, ExpressionOpcode> term;
-
-		static bool can_parse(BAN::ConstByteSpan);
-		static BAN::Optional<TermObj> parse(BAN::ConstByteSpan&);
-	};
-
-	// ReferenceTypeOpcode := DefRefOf | DefDerefOf | DefIndex | UserTermObj
-	struct ReferenceTypeOpcode
-	{
-		struct RefOf
-		{
-			SuperName target;
-		};
-		struct DerefOf
-		{
-			TermArg source;
-		};
-		struct Index
-		{
-			TermArg source;
-			TermArg index;
-			SuperName destination;
-		};
-		struct UserTermObj
-		{
-			MethodInvocation method;
-		};
-
-		BAN::Variant<RefOf, DerefOf, Index, UserTermObj> opcode;
-
-		static bool can_parse(BAN::ConstByteSpan);
-		static BAN::Optional<ReferenceTypeOpcode> parse(BAN::ConstByteSpan&);
-	};
-
-}

kernel/include/kernel/ACPI/AML/Utils.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <BAN/Formatter.h>
+#include <kernel/Debug.h>
+
+// AML_DEBUG_LEVEL:
+//   0: No debug output
+//   1: Dump AML after parsing
+//   2: Dump AML while parsing
+#define AML_DEBUG_LEVEL 0
+
+#define AML_TODO(...) 											\
+	do {														\
+		BAN::Formatter::print(Debug::putchar, "\e[33mTODO: ");	\
+		BAN::Formatter::print(Debug::putchar, __VA_ARGS__);		\
+		BAN::Formatter::println(Debug::putchar, "\e[m");		\
+	} while (0)
+
+#define AML_ERROR(...) 											\
+	do {														\
+		BAN::Formatter::print(Debug::putchar, "\e[31mERROR: ");	\
+		BAN::Formatter::print(Debug::putchar, __VA_ARGS__);		\
+		BAN::Formatter::println(Debug::putchar, "\e[m");		\
+	} while (0)
+
+#define AML_PRINT(...) BAN::Formatter::println(Debug::putchar, __VA_ARGS__)
+
+#define AML_DEBUG_PRINT_INDENT(indent)			\
+	do {										\
+		for (int i = 0; i < (indent) * 2; i++)	\
+			AML_DEBUG_PUTC(' ');				\
+	} while (0)
+
+#define AML_DEBUG_PUTC(c) Debug::putchar(c)
+#define AML_DEBUG_PRINT(...) BAN::Formatter::print(Debug::putchar, __VA_ARGS__)
+#define AML_DEBUG_PRINTLN(...) BAN::Formatter::println(Debug::putchar, __VA_ARGS__)