Fix parsers to use new Propagate type

aml/src/name_object.rs

@@ -2,7 +2,7 @@ use crate::{
     misc::{arg_obj, debug_obj, local_obj, ArgNum, LocalNum},
     namespace::{AmlName, NameComponent},
     opcode::{opcode, DUAL_NAME_PREFIX, MULTI_NAME_PREFIX, NULL_NAME, PREFIX_CHAR, ROOT_CHAR},
-    parser::{choice, comment_scope, consume, n_of, take, take_while, Parser},
+    parser::{choice, comment_scope, consume, n_of, take, take_while, Parser, Propagate},
     AmlContext,
     AmlError,
     DebugVerbosity,
@@ -93,7 +93,7 @@ where
     comment_scope(DebugVerbosity::AllScopes, "NameString", move |input: &'a [u8], context| {
         let first_char = match input.first() {
             Some(&c) => c,
-            None => return Err((input, context, AmlError::UnexpectedEndOfStream)),
+            None => return Err((input, context, Propagate::Err(AmlError::UnexpectedEndOfStream))),
         };
 
         match first_char {
@@ -102,7 +102,7 @@ where
             _ => name_path()
                 .map(|path| {
                     if path.len() == 0 {
-                        return Err(AmlError::EmptyNamesAreInvalid);
+                        return Err(Propagate::Err(AmlError::EmptyNamesAreInvalid));
                     }
 
                     Ok(AmlName::from_components(path))

aml/src/opcode.rs

@@ -82,9 +82,9 @@ where
     'c: 'a,
 {
     move |input: &'a [u8], context: &'c mut AmlContext| match input.first() {
-        None => Err((input, context, AmlError::UnexpectedEndOfStream)),
+        None => Err((input, context, Propagate::Err(AmlError::UnexpectedEndOfStream))),
         Some(&byte) if byte == opcode => Ok((&input[1..], context, ())),
-        Some(_) => Err((input, context, AmlError::WrongParser)),
+        Some(_) => Err((input, context, Propagate::Err(AmlError::WrongParser))),
     }
 }
 

aml/src/pkg_length.rs

@@ -1,5 +1,5 @@
 use crate::{
-    parser::{take, take_n, Parser},
+    parser::{take, take_n, Parser, Propagate},
     AmlContext,
     AmlError,
 };
@@ -42,7 +42,7 @@ where
          */
         match PkgLength::from_raw_length(input, raw_length) {
             Ok(pkg_length) => Ok((new_input, context, pkg_length)),
-            Err(err) => Err((input, context, err)),
+            Err(err) => Err((input, context, Propagate::Err(err))),
         }
     }
 }
@@ -70,26 +70,27 @@ where
             return Ok((new_input, context, length));
         }
 
-        let (new_input, context, length): (&[u8], &mut AmlContext, u32) =
-            match take_n(byte_count as u32).parse(new_input, context) {
-                Ok((new_input, context, bytes)) => {
-                    let initial_length = u32::from(lead_byte.get_bits(0..4));
-                    (
-                        new_input,
-                        context,
-                        bytes
-                            .iter()
-                            .enumerate()
-                            .fold(initial_length, |length, (i, &byte)| length + (u32::from(byte) << (4 + i * 8))),
-                    )
-                }
-
-                /*
-                 * The stream was too short. We return an error, making sure to return the
-                 * *original* stream (that we haven't consumed any of).
-                 */
-                Err((_, context, _)) => return Err((input, context, AmlError::UnexpectedEndOfStream)),
-            };
+        let (new_input, context, length): (&[u8], &mut AmlContext, u32) = match take_n(byte_count as u32)
+            .parse(new_input, context)
+        {
+            Ok((new_input, context, bytes)) => {
+                let initial_length = u32::from(lead_byte.get_bits(0..4));
+                (
+                    new_input,
+                    context,
+                    bytes
+                        .iter()
+                        .enumerate()
+                        .fold(initial_length, |length, (i, &byte)| length + (u32::from(byte) << (4 + i * 8))),
+                )
+            }
+
+            /*
+             * The stream was too short. We return an error, making sure to return the
+             * *original* stream (that we haven't consumed any of).
+             */
+            Err((_, context, _)) => return Err((input, context, Propagate::Err(AmlError::UnexpectedEndOfStream))),
+        };
 
         Ok((new_input, context, length))
     }

aml/src/term_object.rs

@@ -15,6 +15,7 @@ use crate::{
         try_with_context,
         ParseResult,
         Parser,
+        Propagate,
     },
     pkg_length::{pkg_length, PkgLength},
     type1::type1_opcode,
@@ -114,7 +115,7 @@ where
             name_string().then(data_ref_object()).map_with_context(|(name, data_ref_object), context| {
                 try_with_context!(
                     context,
-                    context.namespace.add_value_at_resolved_path(name, &context.current_scope, data_ref_object,)
+                    context.namespace.add_value_at_resolved_path(name, &context.current_scope, data_ref_object)
                 );
                 (Ok(()), context)
             }),
@@ -201,15 +202,15 @@ where
                         0x08 => RegionSpace::GeneralPurposeIo,
                         0x09 => RegionSpace::GenericSerialBus,
                         space @ 0x80..=0xff => RegionSpace::OemDefined(space),
-                        byte => return (Err(AmlError::InvalidRegionSpace(byte)), context),
+                        byte => return (Err(Propagate::Err(AmlError::InvalidRegionSpace(byte))), context),
                     };
                     let offset = match offset.as_integer(context) {
                         Ok(offset) => offset,
-                        Err(err) => return (Err(err), context),
+                        Err(err) => return (Err(Propagate::Err(err)), context),
                     };
                     let length = match length.as_integer(context) {
                         Ok(length) => length,
-                        Err(err) => return (Err(err), context),
+                        Err(err) => return (Err(Propagate::Err(err)), context),
                     };
                     let parent_device = match region {
                         RegionSpace::PciConfig | RegionSpace::IPMI | RegionSpace::GenericSerialBus => {
@@ -560,12 +561,12 @@ where
              */
             let nul_position = match input.iter().position(|&c| c == b'\0') {
                 Some(position) => position,
-                None => return Err((input, context, AmlError::UnterminatedStringConstant)),
+                None => return Err((input, context, Propagate::Err(AmlError::UnterminatedStringConstant))),
             };
 
             let string = String::from(match str::from_utf8(&input[0..nul_position]) {
                 Ok(string) => string,
-                Err(_) => return Err((input, context, AmlError::InvalidStringConstant)),
+                Err(_) => return Err((input, context, Propagate::Err(AmlError::InvalidStringConstant))),
             });
 
             Ok((&input[(nul_position + 1)..], context, AmlValue::String(string)))
@@ -588,7 +589,7 @@ where
             opcode::ONE_OP => Ok((new_input, context, AmlValue::Integer(1))),
             opcode::ONES_OP => Ok((new_input, context, AmlValue::Integer(u64::max_value()))),
 
-            _ => Err((input, context, AmlError::WrongParser)),
+            _ => Err((input, context, Propagate::Err(AmlError::WrongParser))),
         }
     };
 

aml/src/type2.rs

@@ -10,6 +10,7 @@ use crate::{
         take_to_end_of_pkglength,
         try_with_context,
         Parser,
+        Propagate,
     },
     pkg_length::pkg_length,
     term_object::{data_ref_object, term_arg},
@@ -134,7 +135,7 @@ where
                     let buffer_size = try_with_context!(context, buffer_size.as_integer(context)) as usize;
 
                     if buffer_size < bytes.len() {
-                        return (Err(AmlError::MalformedBuffer), context);
+                        return (Err(Propagate::Err(AmlError::MalformedBuffer)), context);
                     }
 
                     let mut buffer = vec![0; buffer_size];
@@ -312,7 +313,7 @@ where
                     }
 
                     if package_contents.len() != num_elements as usize {
-                        return Err((input, context, AmlError::MalformedPackage));
+                        return Err((input, context, Propagate::Err(AmlError::MalformedPackage)));
                     }
 
                     Ok((input, context, AmlValue::Package(package_contents)))