AML: implement support for native methods in the AML namespace

Author: IsaacWoods

src/aml/mod.rs

@@ -136,12 +136,13 @@ where
         trace!("Invoking AML method: {}", path);
 
         let object = self.namespace.lock().get(path.clone())?.clone();
-        match object.typ() {
-            ObjectType::Method => {
+        match &*object {
+            Object::Method { .. } => {
                 self.namespace.lock().add_level(path.clone(), NamespaceLevelKind::MethodLocals)?;
                 let context = MethodContext::new_from_method(object, args, path)?;
                 self.do_execute_method(context)
             }
+            Object::NativeMethod(f) => f(&args),
             _ => Ok(object),
         }
     }
@@ -644,13 +645,22 @@ where
                             })
                             .collect();
 
-                        self.namespace.lock().add_level(method_scope.clone(), NamespaceLevelKind::MethodLocals)?;
+                        if let Object::Method { .. } = **method {
+                            self.namespace
+                                .lock()
+                                .add_level(method_scope.clone(), NamespaceLevelKind::MethodLocals)?;
 
-                        let new_context =
-                            MethodContext::new_from_method(method.clone(), args, method_scope.clone())?;
-                        let old_context = mem::replace(&mut context, new_context);
-                        self.context_stack.lock().push(old_context);
-                        context.retire_op(op);
+                            let new_context =
+                                MethodContext::new_from_method(method.clone(), args, method_scope.clone())?;
+                            let old_context = mem::replace(&mut context, new_context);
+                            self.context_stack.lock().push(old_context);
+                            context.retire_op(op);
+                        } else if let Object::NativeMethod { ref f, .. } = **method {
+                            let result = f(&args)?;
+                            context.contribute_arg(Argument::Object(result));
+                        } else {
+                            panic!();
+                        }
                     }
                     Opcode::Return => {
                         let [Argument::Object(object)] = &op.arguments[..] else { panic!() };
@@ -1207,7 +1217,8 @@ where
                         let object = self.namespace.lock().search(&name, &context.current_scope);
                         match object {
                             Ok((resolved_name, object)) => {
-                                if let Object::Method { flags, .. } = *object {
+                                if let Object::Method { flags, .. } | Object::NativeMethod { flags, .. } = *object
+                                {
                                     context.start_in_flight_op(OpInFlight::new_with(
                                         Opcode::InternalMethodCall,
                                         vec![Argument::Object(object), Argument::Namestring(resolved_name)],
@@ -1762,7 +1773,7 @@ where
                 Object::Event => "[Event]".to_string(),
                 Object::FieldUnit(_) => "[Field]".to_string(),
                 Object::Integer(value) => value.to_string(),
-                Object::Method { .. } => "[Control Method]".to_string(),
+                Object::Method { .. } | Object::NativeMethod(_) => "[Control Method]".to_string(),
                 Object::Mutex { .. } => "[Mutex]".to_string(),
                 Object::Reference { inner, .. } => resolve_as_string(&*(inner.clone().unwrap_reference())),
                 Object::OpRegion(_) => "[Operation Region]".to_string(),

src/aml/namespace.rs

@@ -1,8 +1,11 @@
-use super::object::WrappedObject;
-use crate::aml::AmlError;
+use super::{
+    AmlError,
+    object::{MethodFlags, Object, WrappedObject},
+};
 use alloc::{
     collections::btree_map::BTreeMap,
     string::{String, ToString},
+    sync::Arc,
     vec,
     vec::Vec,
 };
@@ -26,6 +29,12 @@ impl Namespace {
         namespace.add_level(AmlName::from_str("\\_PR").unwrap(), NamespaceLevelKind::Scope).unwrap();
         namespace.add_level(AmlName::from_str("\\_TZ").unwrap(), NamespaceLevelKind::Scope).unwrap();
 
+        // TODO: this is just testing the native methods atm - actually implement it
+        namespace.insert(
+            AmlName::from_str("\\_OSI").unwrap(),
+            Object::NativeMethod { f: Arc::new(|args| todo!()), flags: MethodFlags(0) }.wrap(),
+        );
+
         // TODO: add pre-defined objects as well - \GL, \OSI, etc.
 
         namespace

src/aml/object.rs

@@ -3,7 +3,9 @@ use alloc::{borrow::Cow, string::String, sync::Arc, vec::Vec};
 use bit_field::BitField;
 use core::{cell::UnsafeCell, fmt, ops};
 
-#[derive(Clone, Debug)]
+type NativeMethod = dyn Fn(&[WrappedObject]) -> Result<WrappedObject, AmlError>;
+
+#[derive(Clone)]
 pub enum Object {
     Uninitialized,
     Buffer(Vec<u8>),
@@ -13,6 +15,7 @@ pub enum Object {
     FieldUnit(FieldUnit),
     Integer(u64),
     Method { code: Vec<u8>, flags: MethodFlags },
+    NativeMethod { f: Arc<NativeMethod>, flags: MethodFlags },
     Mutex { mutex: Handle, sync_level: u8 },
     Reference { kind: ReferenceKind, inner: WrappedObject },
     OpRegion(OpRegion),
@@ -39,6 +42,7 @@ impl fmt::Display for Object {
             Object::Integer(value) => write!(f, "Integer({})", value),
             // TODO: decode flags here
             Object::Method { code, flags } => write!(f, "Method"),
+            Object::NativeMethod { .. } => write!(f, "NativeMethod"),
             Object::Mutex { mutex, sync_level } => write!(f, "Mutex"),
             Object::Reference { kind, inner } => write!(f, "Reference({:?} -> {})", kind, **inner),
             Object::OpRegion(region) => write!(f, "{:?}", region),
@@ -248,6 +252,7 @@ impl Object {
             Object::FieldUnit(_) => ObjectType::FieldUnit,
             Object::Integer(_) => ObjectType::Integer,
             Object::Method { .. } => ObjectType::Method,
+            Object::NativeMethod { .. } => ObjectType::Method,
             Object::Mutex { .. } => ObjectType::Mutex,
             Object::Reference { inner, .. } => inner.typ(),
             Object::OpRegion(_) => ObjectType::OpRegion,