Switch to new opcode names: statement, expression, and reference type

Newer versions of the spec have moved to a new naming scheme for what were
known as Type 1, Type 2, and Type 6 opcodes, which were tbf objectively
terrible names. This moves to those new names, both to match the spec, and
to make our code clearer.

aml/src/type2.rs → aml/src/expression.rs

@@ -26,25 +26,24 @@ use alloc::{
 };
 use core::{cmp::Ordering, convert::TryInto, mem, ops::Deref};
 
-/// Type 2 opcodes return a value and so can be used in expressions.
-pub fn type2_opcode<'a, 'c>() -> impl Parser<'a, 'c, AmlValue>
+pub fn expression_opcode<'a, 'c>() -> impl Parser<'a, 'c, AmlValue>
 where
     'c: 'a,
 {
     /*
-     * Type2Opcode := DefAquire | DefAdd | DefAnd | DefBuffer | DefConcat | DefConcatRes |
-     *                DefCondRefOf | DefCopyObject | DefDecrement | DefDerefOf | DefDivide |
-     *                DefFindSetLeftBit | DefFindSetRightBit | DefFromBCD | DefIncrement | DefIndex |
-     *                DefLAnd | DefLEqual | DefLGreater | DefLGreaterEqual | DefLLess | DefLLessEqual |
-     *                DefMid | DefLNot | DefLNotEqual | DefLoad | 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
+     * ExpressionOpcode := DefAquire | DefAdd | DefAnd | DefBuffer | DefConcat | DefConcatRes |
+     *                     DefCondRefOf | DefCopyObject | DefDecrement | DefDerefOf | DefDivide |
+     *                     DefFindSetLeftBit | DefFindSetRightBit | DefFromBCD | DefIncrement | DefIndex |
+     *                     DefLAnd | DefLEqual | DefLGreater | DefLGreaterEqual | DefLLess | DefLLessEqual |
+     *                     DefMid | DefLNot | DefLNotEqual | DefLoad | 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
      */
-    make_parser_concrete!(comment_scope(
+    comment_scope(
         DebugVerbosity::AllScopes,
-        "Type2Opcode",
+        "ExpressionOpcode",
         choice!(
             def_add(),
             def_and(),
@@ -68,7 +67,7 @@ where
             def_to_integer(),
             method_invocation() // XXX: this must always appear last. See how we have to parse it to see why.
         ),
-    ))
+    )
 }
 
 pub fn def_add<'a, 'c>() -> impl Parser<'a, 'c, AmlValue>

aml/src/lib.rs

@@ -43,6 +43,7 @@ extern crate std;
 #[cfg(test)]
 mod test_utils;
 
+pub(crate) mod expression;
 pub(crate) mod misc;
 pub(crate) mod name_object;
 pub(crate) mod namespace;
@@ -51,9 +52,8 @@ pub(crate) mod parser;
 pub mod pci_routing;
 pub(crate) mod pkg_length;
 pub mod resource;
+pub(crate) mod statement;
 pub(crate) mod term_object;
-pub(crate) mod type1;
-pub(crate) mod type2;
 pub mod value;
 
 pub use crate::{namespace::*, value::AmlValue};

aml/src/name_object.rs

@@ -40,8 +40,8 @@ where
     'c: 'a,
 {
     /*
-     * SuperName := SimpleName | DebugObj | Type6Opcode
-     * TODO: this doesn't cover Type6Opcode yet
+     * SuperName := SimpleName | DebugObj | ReferenceTypeOpcode
+     * TODO: this doesn't cover ReferenceTypeOpcode yet
      */
     comment_scope(
         DebugVerbosity::AllScopes,

aml/src/type1.rs → aml/src/statement.rs

@@ -20,19 +20,17 @@ use crate::{
     DebugVerbosity,
 };
 
-/// Type 1 opcodes do not return a value and so can't be used in expressions.
-pub fn type1_opcode<'a, 'c>() -> impl Parser<'a, 'c, ()>
+pub fn statement_opcode<'a, 'c>() -> impl Parser<'a, 'c, ()>
 where
     'c: 'a,
 {
     /*
-     * Type1Opcode := DefBreak | DefBreakPoint | DefContinue | DefFatal | DefIfElse | DefLoad | DefNoop |
-     *                DefNotify | DefRelease | DefReset | DefReturn | DefSignal | DefSleep | DefStall |
-     *                DefWhile
+     * StatementOpcode := DefBreak | DefBreakPoint | DefContinue | DefFatal | DefIfElse | DefLoad | DefNoop |
+     *                    DefNotify | DefRelease | DefReset | DefReturn | DefSignal | DefSleep | DefStall | DefWhile
      */
     comment_scope(
         DebugVerbosity::AllScopes,
-        "Type1Opcode",
+        "StatementOpcode",
         choice!(
             def_break(),
             def_breakpoint(),

aml/src/term_object.rs

@@ -1,4 +1,5 @@
 use crate::{
+    expression::{def_buffer, def_package, expression_opcode},
     misc::{arg_obj, local_obj},
     name_object::{name_seg, name_string},
     namespace::{AmlName, LevelType},
@@ -18,8 +19,7 @@ use crate::{
         Propagate,
     },
     pkg_length::{pkg_length, PkgLength},
-    type1::type1_opcode,
-    type2::{def_buffer, def_package, type2_opcode},
+    statement::statement_opcode,
     value::{AmlValue, FieldFlags, MethodCode, MethodFlags, RegionSpace},
     AmlContext,
     AmlError,
@@ -57,7 +57,7 @@ where
     'c: 'a,
 {
     /*
-     * TermObj := NamespaceModifierObj | NamedObj | Type1Opcode | Type2Opcode
+     * TermObj := NamespaceModifierObj | NamedObj | StatementOpcode | ExpressionOpcode
      */
     comment_scope(
         DebugVerbosity::AllScopes,
@@ -65,8 +65,8 @@ where
         choice!(
             namespace_modifier().map(|()| Ok(None)),
             named_obj().map(|()| Ok(None)),
-            type1_opcode().map(|()| Ok(None)),
-            type2_opcode().map(|value| Ok(Some(value)))
+            statement_opcode().map(|()| Ok(None)),
+            expression_opcode().map(|value| Ok(Some(value)))
         ),
     )
 }
@@ -834,7 +834,7 @@ where
     'c: 'a,
 {
     /*
-     * TermArg := Type2Opcode | DataObject | ArgObj | LocalObj
+     * TermArg := ExpressionOpcode | DataObject | ArgObj | LocalObj
      */
     comment_scope(
         DebugVerbosity::AllScopes,
@@ -847,7 +847,7 @@ where
             local_obj().map_with_context(|local_num, context| {
                 (Ok(try_with_context!(context, context.local(local_num)).clone()), context)
             }),
-            make_parser_concrete!(type2_opcode())
+            make_parser_concrete!(expression_opcode())
         ),
     )
 }