aml: introduce 'transparent' reference types + handle undefined package elements

Author: IsaacWoods

aml/src/lib.rs

@@ -707,11 +707,17 @@ impl Interpreter {
                 Opcode::DataRegion => todo!(),
                 Opcode::Local(local) => {
                     let local = context.locals[local as usize].clone();
-                    context.last_op()?.arguments.push(Argument::Object(Arc::new(Object::Reference(local))));
+                    context.last_op()?.arguments.push(Argument::Object(Arc::new(Object::Reference {
+                        kind: ReferenceKind::LocalOrArg,
+                        inner: local,
+                    })));
                 }
                 Opcode::Arg(arg) => {
                     let arg = context.args[arg as usize].clone();
-                    context.last_op()?.arguments.push(Argument::Object(Arc::new(Object::Reference(arg))));
+                    context.last_op()?.arguments.push(Argument::Object(Arc::new(Object::Reference {
+                        kind: ReferenceKind::LocalOrArg,
+                        inner: arg,
+                    })));
                 }
                 Opcode::Store => context.start_in_flight_op(OpInFlight::new(Opcode::Store, 2)),
                 Opcode::RefOf => todo!(),
@@ -725,15 +731,28 @@ impl Interpreter {
                     context.current_block.pc -= 1;
                     let name = context.namestring()?;
 
-                    let (_, object) = self.namespace.lock().search(&name, &context.current_scope)?;
-                    if let Object::Method { flags, .. } = *object {
-                        context.start_in_flight_op(OpInFlight::new_with(
-                            Opcode::InternalMethodCall,
-                            flags.arg_count(),
-                        ))
-                    } else {
-                        context.last_op()?.arguments.push(Argument::Object(object));
+                    match self.namespace.lock().search(&name, &context.current_scope) {
+                        Ok((resolved_name, object)) => {
+                            if let Object::Method { flags, .. } = *object {
+                                context.start_in_flight_op(OpInFlight::new_with(
+                                    Opcode::InternalMethodCall,
                                     vec![Argument::Object(object), Argument::Namestring(resolved_name)],
+                                    flags.arg_count(),
+                                ))
+                            } else {
+                                context.last_op()?.arguments.push(Argument::Object(object));
+                            }
+                        }
+                        Err(AmlError::ObjectDoesNotExist(_)) => {
+                            if context.current_block.kind == BlockKind::Package {
+                                let reference = Object::Reference {
+                                    kind: ReferenceKind::Unresolved,
+                                    inner: Arc::new(Object::String(name.to_string())),
+                                };
+                                context.last_op()?.arguments.push(Argument::Object(Arc::new(reference)));
+                            }
+                        }
+                        Err(other) => Err(other)?,
                     }
                 }
 
@@ -946,6 +965,7 @@ impl Interpreter {
         // TODO: convert object to be of the type of destination, in line with 19.3.5 of the spec
         // TODO: write the object to the destination, including e.g. field writes that then lead to
         // literally god knows what.
+        let object = object.unwrap_transparent_reference();
         match target {
             Argument::Object(target) => match target.gain_mut() {
                 Object::Integer(target) => match object.gain_mut() {

aml/src/object.rs

@@ -13,7 +13,7 @@ pub enum Object {
     Integer(u64),
     Method { code: Vec<u8>, flags: MethodFlags },
     Mutex { sync_level: u8 },
-    Reference(Arc<Object>),
+    Reference { kind: ReferenceKind, inner: Arc<Object> },
     OpRegion(OpRegion),
     Package(Vec<Arc<Object>>),
     PowerResource { system_level: u8, resource_order: u16 },
@@ -77,7 +77,7 @@ impl Object {
             Object::Integer(_) => ObjectType::Integer,
             Object::Method { .. } => ObjectType::Method,
             Object::Mutex { .. } => ObjectType::Mutex,
-            Object::Reference(object) => object.typ(),
+            Object::Reference { inner, .. } => inner.typ(),
             Object::OpRegion(_) => ObjectType::OpRegion,
             Object::Package(_) => ObjectType::Package,
             Object::PowerResource { .. } => ObjectType::PowerResource,
@@ -87,6 +87,35 @@ impl Object {
             Object::ThermalZone => ObjectType::ThermalZone,
         }
     }
+
+    pub fn unwrap_reference(self: Arc<Object>) -> Arc<Object> {
+        let mut object = self;
+        loop {
+            if let Object::Reference { ref inner, .. } = *object {
+                object = inner.clone();
+            } else {
+                return object.clone();
+            }
+        }
+    }
+
+    /// Unwraps 'transparent' references (e.g. locals, arguments, and internal usage of reference-type objects), but maintain 'real'
+    /// references deliberately created by AML.
+    pub fn unwrap_transparent_reference(self: Arc<Self>) -> Arc<Object> {
+        let mut object = self;
+        loop {
+            // TODO: what should this do with unresolved namestrings? It would need namespace
+            // access to resolve them (and then this would probs have to move to a method on
+            // `Interpreter`)?
+            if let Object::Reference { kind, ref inner } = *object
+                && kind == ReferenceKind::LocalOrArg
+            {
+                object = inner.clone();
+            } else {
+                return object.clone();
+            }
+        }
+    }
 }
 
 #[derive(Debug)]
@@ -113,6 +142,12 @@ impl MethodFlags {
     }
 }
 
+#[derive(Clone, Copy, PartialEq, Debug)]
+pub enum ReferenceKind {
+    LocalOrArg,
+    Unresolved,
+}
+
 #[derive(Clone, Copy, PartialEq, Debug)]
 pub enum ObjectType {
     Uninitialized,