From 1825d1162ea119ad2917054bd78c0a43f9e4fd99 Mon Sep 17 00:00:00 2001
From: Daniel Wyatt <dewyattmail@gmail.com>
Date: Sun, 13 Sep 2026 18:17:21 -0400
Subject: [PATCH 1/2] Add BufferField support for Increment/Decrement.

---
 src/aml/mod.rs | 31 ++++++++++++++++++++++---------
 1 file changed, 22 insertions(+), 9 deletions(-)

diff --git a/src/aml/mod.rs b/src/aml/mod.rs
index e9c23206..2deca602 100644
--- a/src/aml/mod.rs
+++ b/src/aml/mod.rs
@@ -517,24 +517,37 @@ where
                         self.do_unary_maths(&mut context, op)?;
                     }
                     Opcode::Increment | Opcode::Decrement => {
-                        let [Argument::Object(operand)] = &op.arguments[..] else { panic!() };
+                        extract_args!(op => [Argument::Object(operand)]);
                         let operand = operand.clone().unwrap_reference();
                         let token = self.object_token.lock();
 
-                        let Object::Integer(operand) = (unsafe { operand.gain_mut(&token) }) else {
-                            Err(AmlError::ObjectNotOfExpectedType {
-                                expected: ObjectType::Integer,
-                                got: operand.typ(),
-                            })?
+                        let operand = unsafe {operand.gain_mut(&token)};
+                        let value = match operand {
+                            Object::Integer(operand) => {
+                                *operand
+                            }
+                            Object::BufferField{..} => {
+                                operand.to_integer(self.integer_size)?
+                            }
+                            _ => Err(AmlError::ObjectNotOfExpectedType { expected: ObjectType::Integer, got: operand.typ() })?
                         };
 
                         let new_value = match op.op {
-                            Opcode::Increment => operand.wrapping_add(1),
-                            Opcode::Decrement => operand.wrapping_sub(1),
+                            Opcode::Increment => value.wrapping_add(1),
+                            Opcode::Decrement => value.wrapping_sub(1),
                             _ => unreachable!(),
                         };
 
-                        *operand = new_value;
+                        match operand {
+                            Object::Integer(operand) => {
+                                *operand = new_value;
+                            }
+                            Object::BufferField{..} => {
+                                operand.write_buffer_field(&new_value.to_le_bytes(), &token)?;
+                            }
+                            _ => unreachable!()
+                        }
+
                         context.contribute_arg(Argument::Object(Object::Integer(new_value).wrap()));
                         context.retire_op(op);
                     }

From 9c398ed33df82dfc8f59028afe631bf77a09208e Mon Sep 17 00:00:00 2001
From: Martin Hughes <martin-hughes@users.noreply.github.com>
Date: Sun, 25 Oct 2026 20:15:53 +0000
Subject: [PATCH 2/2] Very basic test

---
 tests/incdec.asl | 47 ++++++++++++++++++++++++++++++++++++++++-------
 1 file changed, 40 insertions(+), 7 deletions(-)

diff --git a/tests/incdec.asl b/tests/incdec.asl
index 4b584d51..9be43dea 100644
--- a/tests/incdec.asl
+++ b/tests/incdec.asl
@@ -1,9 +1,42 @@
 DefinitionBlock("incdec.aml", "DSDT", 1, "RSACPI", "INCDEC", 1) {
-    Name(X, 0)
-    X++
-    X++
-    X++
-    Name(Y, 0)
-    Y = X
-    X--
+    Name(FCNT, 0)
+
+    Method (CHEK, 2) {
+        If (Arg0 != Arg1) {
+            FCNT++
+            Printf("Wrong result, %o != %o", ToHexString(Arg0), ToHexString(Arg1))
+        }
+    }
+
+    // Plain integers
+    Method (T1) {
+        Name(X, 0)
+        X++
+        X++
+        X++
+
+
+        Name(Y, 0)
+        Y = X
+        X--
+
+        CHEK(Y, 3)
+        CHEK(X, 2)
+    }
+
+    // Basic buffer fields
+    Method (T2) {
+        Name(BUF, Buffer (2) { 0x00, 0x00 })
+        CreateWordField(BUF, 0, X)
+        X++
+
+        CHEK(ToInteger(X), 1)
+    }
+
+    Method (MAIN) {
+        T1()
+        T2()
+
+        Return (FCNT)
+    }
 }