Parse `DefPowerResources`

Just parse them and stick them in the namespace. This was actually way less
work than I thought was required for these objects.

aml/src/lib.rs

@@ -296,8 +296,9 @@ impl AmlContext {
 
             LevelType::Scope => Ok(true),
 
-            // TODO: can either of these contain devices?
+            // TODO: can any of these contain devices?
             LevelType::Processor => Ok(false),
+            LevelType::PowerResource => Ok(false),
             LevelType::MethodLocals => Ok(false),
         })?;
 

aml/src/namespace.rs

@@ -30,6 +30,8 @@ pub enum LevelType {
     /// A legacy `Processor` object's sub-objects are stored in a level of this type. Modern tables define
     /// processors as `Device`s.
     Processor,
+    /// A `PowerResource` object's sub-objects are stored in a level of this type.
+    PowerResource,
     /// A level of this type is created at the same path as the name of a method when it is invoked. It can be
     /// used by the method to store local variables.
     MethodLocals,

aml/src/opcode.rs

@@ -31,6 +31,7 @@ pub const EXT_DEF_OP_REGION_OP: u8 = 0x80;
 pub const EXT_DEF_FIELD_OP: u8 = 0x81;
 pub const EXT_DEF_DEVICE_OP: u8 = 0x82;
 pub const EXT_DEF_PROCESSOR_OP: u8 = 0x83;
+pub const EXT_DEF_POWER_RES_OP: u8 = 0x84;
 
 /*
  * Type 1 opcodes

aml/src/term_object.rs

@@ -97,7 +97,15 @@ where
     comment_scope(
         DebugVerbosity::AllScopes,
         "NamedObj",
-        choice!(def_op_region(), def_field(), def_method(), def_device(), def_processor(), def_mutex()),
+        choice!(
+            def_op_region(),
+            def_field(),
+            def_method(),
+            def_device(),
+            def_processor(),
+            def_power_res(),
+            def_mutex()
+        ),
     )
 }
 
@@ -235,6 +243,56 @@ where
         .discard_result()
 }
 
+pub fn def_power_res<'a, 'c>() -> impl Parser<'a, 'c, ()>
+where
+    'c: 'a,
+{
+    /*
+     * DefPowerRes := ExtOpPrefix 0x84 PkgLength NameString SystemLevel ResourceOrder TermList
+     * SystemLevel := ByteData
+     * ResourceOrder := WordData
+     */
+    ext_opcode(opcode::EXT_DEF_POWER_RES_OP)
+        .then(comment_scope(
+            DebugVerbosity::Scopes,
+            "DefPowerRes",
+            pkg_length()
+                .then(name_string())
+                .then(take())
+                .then(take_u16())
+                .map_with_context(|(((pkg_length, name), system_level), resource_order), context| {
+                    /*
+                     * `PowerResource` objects contain data within themselves, and can also have sub-objects,
+                     * so we add both a level for the sub-objects, and a value for the data.
+                     */
+                    let resolved_name = try_with_context!(context, name.resolve(&context.current_scope));
+                    try_with_context!(
+                        context,
+                        context.namespace.add_level(resolved_name.clone(), LevelType::PowerResource)
+                    );
+                    try_with_context!(
+                        context,
+                        context.namespace.add_value(
+                            resolved_name.clone(),
+                            AmlValue::PowerResource { system_level, resource_order }
+                        )
+                    );
+                    let previous_scope = context.current_scope.clone();
+                    context.current_scope = resolved_name;
+
+                    (Ok((previous_scope, pkg_length)), context)
+                })
+                .feed(move |(previous_scope, pkg_length)| {
+                    term_list(pkg_length).map(move |_| Ok(previous_scope.clone()))
+                })
+                .map_with_context(|previous_scope, context| {
+                    context.current_scope = previous_scope;
+                    (Ok(()), context)
+                }),
+        ))
+        .discard_result()
+}
+
 pub fn def_field<'a, 'c>() -> impl Parser<'a, 'c, ()>
 where
     'c: 'a,

aml/src/value.rs

@@ -201,6 +201,10 @@ pub enum AmlValue {
         sync_level: u8,
     },
     Package(Vec<AmlValue>),
+    PowerResource {
+        system_level: u8,
+        resource_order: u16,
+    },
 }
 
 impl AmlValue {
@@ -236,6 +240,7 @@ impl AmlValue {
             AmlValue::Processor { .. } => AmlType::Processor,
             AmlValue::Mutex { .. } => AmlType::Mutex,
             AmlValue::Package(_) => AmlType::Package,
+            AmlValue::PowerResource { .. } => AmlType::PowerResource,
         }
     }