From c01a04148b2d2b27331a4c20be7903cf64e8189f Mon Sep 17 00:00:00 2001
From: Connor Wood <connorwood71@gmail.com>
Date: Mon, 17 Jul 2017 12:20:04 +0100
Subject: [PATCH] Implemented method return values

---
 src/acpi/aml/dataobj.rs           |  35 +--
 src/acpi/aml/namedobj.rs          | 161 +++++++------
 src/acpi/aml/namespace.rs         |   7 +-
 src/acpi/aml/namespacemodifier.rs |  28 ++-
 src/acpi/aml/namestring.rs        |  35 +--
 src/acpi/aml/parser.rs            |   3 +-
 src/acpi/aml/termlist.rs          |  60 ++---
 src/acpi/aml/type1opcode.rs       | 145 ++++++------
 src/acpi/aml/type2opcode.rs       | 371 +++++++++++++++++-------------
 9 files changed, 483 insertions(+), 362 deletions(-)

diff --git a/src/acpi/aml/dataobj.rs b/src/acpi/aml/dataobj.rs
index 411c3ff..7bb50d3 100644
--- a/src/acpi/aml/dataobj.rs
+++ b/src/acpi/aml/dataobj.rs
@@ -12,11 +12,12 @@ use super::namestring::parse_super_name;
 
 pub fn parse_data_obj(data: &[u8],
                       ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_selector! {
@@ -31,11 +32,12 @@ pub fn parse_data_obj(data: &[u8],
 
 pub fn parse_data_ref_obj(data: &[u8],
                           ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_selector! {
@@ -58,11 +60,12 @@ pub fn parse_data_ref_obj(data: &[u8],
 
 pub fn parse_arg_obj(data: &[u8],
                      ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     match data[0] {
@@ -76,11 +79,12 @@ pub fn parse_arg_obj(data: &[u8],
 
 pub fn parse_local_obj(data: &[u8],
                        ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     match data[0] {
@@ -94,11 +98,12 @@ pub fn parse_local_obj(data: &[u8],
 
 fn parse_computational_data(data: &[u8],
                             ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     match data[0] {
diff --git a/src/acpi/aml/namedobj.rs b/src/acpi/aml/namedobj.rs
index 27695bb..f9a308d 100644
--- a/src/acpi/aml/namedobj.rs
+++ b/src/acpi/aml/namedobj.rs
@@ -80,11 +80,12 @@ pub enum AccessAttrib {
 
 pub fn parse_named_obj(data: &[u8],
                        ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_selector! {
@@ -114,11 +115,12 @@ pub fn parse_named_obj(data: &[u8],
 
 fn parse_def_bank_field(data: &[u8],
                         ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     // TODO: Why isn't bank name used?
@@ -169,11 +171,12 @@ fn parse_def_bank_field(data: &[u8],
 
 fn parse_def_create_bit_field(data: &[u8],
                               ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_opcode!(data, 0x8D);
@@ -198,11 +201,12 @@ fn parse_def_create_bit_field(data: &[u8],
 
 fn parse_def_create_byte_field(data: &[u8],
                                ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_opcode!(data, 0x8C);
@@ -227,11 +231,12 @@ fn parse_def_create_byte_field(data: &[u8],
 
 fn parse_def_create_word_field(data: &[u8],
                                ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_opcode!(data, 0x8B);
@@ -256,11 +261,12 @@ fn parse_def_create_word_field(data: &[u8],
 
 fn parse_def_create_dword_field(data: &[u8],
                                 ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_opcode!(data, 0x8A);
@@ -285,11 +291,12 @@ fn parse_def_create_dword_field(data: &[u8],
 
 fn parse_def_create_qword_field(data: &[u8],
                                 ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_opcode!(data, 0x8F);
@@ -314,11 +321,12 @@ fn parse_def_create_qword_field(data: &[u8],
 
 fn parse_def_create_field(data: &[u8],
                           ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_opcode_extended!(data, 0x13);
@@ -344,11 +352,12 @@ fn parse_def_create_field(data: &[u8],
 
 fn parse_def_data_region(data: &[u8],
                          ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     // TODO: Find the actual offset and length, once table mapping is implemented
@@ -375,11 +384,12 @@ fn parse_def_data_region(data: &[u8],
 
 fn parse_def_event(data: &[u8],
                    ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_opcode_extended!(data, 0x02);
@@ -397,11 +407,12 @@ fn parse_def_event(data: &[u8],
 
 fn parse_def_device(data: &[u8],
                     ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     // TODO: How to handle local context deferreds
@@ -425,11 +436,12 @@ fn parse_def_device(data: &[u8],
 
 fn parse_def_op_region(data: &[u8],
                        ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_opcode_extended!(data, 0x80);
@@ -468,11 +480,12 @@ fn parse_def_op_region(data: &[u8],
 
 fn parse_def_field(data: &[u8],
                    ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_opcode_extended!(data, 0x81);
@@ -512,11 +525,12 @@ fn parse_def_field(data: &[u8],
 
 fn parse_def_index_field(data: &[u8],
                          ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_opcode_extended!(data, 0x86);
@@ -563,11 +577,12 @@ fn parse_field_list(data: &[u8],
                     ctx: &mut AmlExecutionContext,
                     selector: FieldSelector,
                     flags: &mut FieldFlags) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     let mut current_offset: usize = 0;
@@ -577,11 +592,12 @@ fn parse_field_list(data: &[u8],
     while current_offset < data.len() {
         let res = parse_field_element(&data[current_offset..], ctx, selector.clone(), &mut connection, flags, &mut field_offset)?;
         
-        if ctx.state != ExecutionState::EXECUTING {
-            return Ok(AmlParseType {
+        match ctx.state {
+            ExecutionState::EXECUTING => (),
+            _ => return Ok(AmlParseType {
                 val: AmlValue::None,
                 len: 0 as usize
-            });
+            })
         }
     
         current_offset += res.len;
@@ -599,11 +615,12 @@ fn parse_field_element(data: &[u8],
                        connection: &mut AmlValue,
                        flags: &mut FieldFlags,
                        offset: &mut usize) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     let length = if let Ok(field) = parse_named_field(data, ctx) {
@@ -717,11 +734,12 @@ fn parse_access_field(data: &[u8],
 
 fn parse_connect_field(data: &[u8],
                        ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_opcode!(data, 0x02);
@@ -742,11 +760,12 @@ fn parse_connect_field(data: &[u8],
 
 fn parse_def_method(data: &[u8],
                     ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_opcode!(data, 0x14);
@@ -777,11 +796,12 @@ fn parse_def_method(data: &[u8],
 
 fn parse_def_mutex(data: &[u8],
                    ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_opcode_extended!(data, 0x01);
@@ -801,11 +821,12 @@ fn parse_def_mutex(data: &[u8],
 
 fn parse_def_power_res(data: &[u8],
                        ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     // TODO: How to handle local context deferreds
@@ -838,11 +859,12 @@ fn parse_def_power_res(data: &[u8],
 
 fn parse_def_processor(data: &[u8],
                        ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_opcode_extended!(data, 0x83);
@@ -876,11 +898,12 @@ fn parse_def_processor(data: &[u8],
 
 fn parse_def_thermal_zone(data: &[u8],
                           ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_opcode_extended!(data, 0x85);    
diff --git a/src/acpi/aml/namespace.rs b/src/acpi/aml/namespace.rs
index 8aed913..0332b03 100644
--- a/src/acpi/aml/namespace.rs
+++ b/src/acpi/aml/namespace.rs
@@ -7,7 +7,7 @@ use core::str::FromStr;
 
 use super::termlist::parse_term_list;
 use super::namedobj::{ RegionSpace, FieldFlags };
-use super::parser::AmlExecutionContext;
+use super::parser::{AmlExecutionContext, ExecutionState};
 use super::AmlError;
 
 #[derive(Debug, Clone)]
@@ -130,7 +130,10 @@ impl Method {
 
         parse_term_list(&self.term_list[..], &mut ctx);
 
-        AmlValue::None
+        match ctx.state {
+            ExecutionState::RETURN(v) => v,
+            _ => AmlValue::IntegerConstant(0)
+        }
     }
 }
 
diff --git a/src/acpi/aml/namespacemodifier.rs b/src/acpi/aml/namespacemodifier.rs
index 8ca0c9e..1c72e0a 100644
--- a/src/acpi/aml/namespacemodifier.rs
+++ b/src/acpi/aml/namespacemodifier.rs
@@ -13,11 +13,12 @@ use super::dataobj::parse_data_ref_obj;
 
 pub fn parse_namespace_modifier(data: &[u8],
                                 ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_selector! {
@@ -32,11 +33,12 @@ pub fn parse_namespace_modifier(data: &[u8],
 
 fn parse_alias_op(data: &[u8],
                   ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_opcode!(data, 0x06);
@@ -58,11 +60,12 @@ fn parse_alias_op(data: &[u8],
 
 fn parse_name_op(data: &[u8],
                  ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_opcode!(data, 0x08);
@@ -82,11 +85,12 @@ fn parse_name_op(data: &[u8],
 
 fn parse_scope_op(data: &[u8],
                   ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_opcode!(data, 0x10);
diff --git a/src/acpi/aml/namestring.rs b/src/acpi/aml/namestring.rs
index b1c2301..389e650 100644
--- a/src/acpi/aml/namestring.rs
+++ b/src/acpi/aml/namestring.rs
@@ -10,11 +10,12 @@ use super::type2opcode::parse_type6_opcode;
 
 pub fn parse_name_string(data: &[u8],
                          ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     let mut characters: Vec<u8> = vec!();
@@ -149,11 +150,12 @@ fn parse_multi_name_path(data: &[u8]) -> Result<(Vec<u8>, usize), AmlError> {
 
 pub fn parse_super_name(data: &[u8],
                         ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_selector! {
@@ -168,11 +170,12 @@ pub fn parse_super_name(data: &[u8],
 
 fn parse_debug_obj(data: &[u8],
                    ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_opcode_extended!(data, 0x31);
@@ -185,11 +188,12 @@ fn parse_debug_obj(data: &[u8],
 
 pub fn parse_simple_name(data: &[u8],
                          ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_selector! {
@@ -204,11 +208,12 @@ pub fn parse_simple_name(data: &[u8],
 
 pub fn parse_target(data: &[u8],
                     ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     if data[0] == 0x00 {
diff --git a/src/acpi/aml/parser.rs b/src/acpi/aml/parser.rs
index a358328..269bd6a 100644
--- a/src/acpi/aml/parser.rs
+++ b/src/acpi/aml/parser.rs
@@ -13,12 +13,11 @@ pub struct AmlParseTypeGeneric<T> {
     pub len: usize
 }
 
-#[derive(PartialEq)]
 pub enum ExecutionState {
     EXECUTING,
     CONTINUE,
     BREAK,
-    RETURN
+    RETURN(AmlValue)
 }
 
 pub struct AmlExecutionContext {
diff --git a/src/acpi/aml/termlist.rs b/src/acpi/aml/termlist.rs
index e8a59fc..9152f56 100644
--- a/src/acpi/aml/termlist.rs
+++ b/src/acpi/aml/termlist.rs
@@ -15,11 +15,12 @@ use super::namestring::parse_name_string;
 
 pub fn parse_term_list(data: &[u8],
                        ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
-            len: data.len()
-        });
+            len: 0 as usize
+        })
     }
     
     let mut current_offset: usize = 0;
@@ -27,11 +28,12 @@ pub fn parse_term_list(data: &[u8],
     while current_offset < data.len() {
         let res = parse_term_obj(&data[current_offset..], ctx)?;
         
-        if ctx.state != ExecutionState::EXECUTING {
-            return Ok(AmlParseType {
+        match ctx.state {
+            ExecutionState::EXECUTING => (),
+            _ => return Ok(AmlParseType {
                 val: AmlValue::None,
                 len: data.len()
-            });
+            })
         }
     
         current_offset += res.len;
@@ -45,11 +47,12 @@ pub fn parse_term_list(data: &[u8],
 
 pub fn parse_term_arg(data: &[u8],
                       ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_selector! {
@@ -65,11 +68,12 @@ pub fn parse_term_arg(data: &[u8],
 
 pub fn parse_object_list(data: &[u8],
                          ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
-            len: data.len()
-        });
+            len: 0 as usize
+        })
     }
     
     let mut current_offset: usize = 0;
@@ -77,11 +81,12 @@ pub fn parse_object_list(data: &[u8],
     while current_offset < data.len() {
         let res = parse_object(&data[current_offset..], ctx)?;
         
-        if ctx.state != ExecutionState::EXECUTING {
-            return Ok(AmlParseType {
+        match ctx.state {
+            ExecutionState::EXECUTING => (),
+            _ => return Ok(AmlParseType {
                 val: AmlValue::None,
                 len: data.len()
-            });
+            })
         }
     
         current_offset += res.len;
@@ -95,11 +100,12 @@ pub fn parse_object_list(data: &[u8],
 
 fn parse_object(data: &[u8],
                 ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_selector! {
@@ -113,11 +119,12 @@ fn parse_object(data: &[u8],
 
 pub fn parse_method_invocation(data: &[u8],
                                ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     let name = parse_name_string(data, ctx)?;
@@ -150,11 +157,12 @@ pub fn parse_method_invocation(data: &[u8],
 
 fn parse_term_obj(data: &[u8],
                   ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_selector! {
diff --git a/src/acpi/aml/type1opcode.rs b/src/acpi/aml/type1opcode.rs
index 35c7e0c..b09b868 100644
--- a/src/acpi/aml/type1opcode.rs
+++ b/src/acpi/aml/type1opcode.rs
@@ -12,11 +12,12 @@ use super::namestring::{parse_name_string, parse_super_name};
 
 pub fn parse_type1_opcode(data: &[u8],
                           ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_selector! {
@@ -44,11 +45,12 @@ pub fn parse_type1_opcode(data: &[u8],
 
 fn parse_def_break(data: &[u8],
                    ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_opcode!(data, 0xA5);
@@ -62,11 +64,12 @@ fn parse_def_break(data: &[u8],
 
 fn parse_def_breakpoint(data: &[u8],
                         ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_opcode!(data, 0xCC);
@@ -79,11 +82,12 @@ fn parse_def_breakpoint(data: &[u8],
 
 fn parse_def_continue(data: &[u8],
                       ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_opcode!(data, 0x9F);
@@ -97,11 +101,12 @@ fn parse_def_continue(data: &[u8],
 
 fn parse_def_noop(data: &[u8],
                   ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_opcode!(data, 0xA3);
@@ -114,11 +119,12 @@ fn parse_def_noop(data: &[u8],
 
 fn parse_def_fatal(data: &[u8],
                    ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_opcode_extended!(data, 0x32);
@@ -132,11 +138,12 @@ fn parse_def_fatal(data: &[u8],
 
 fn parse_def_load(data: &[u8],
                   ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     // TODO: Load in the table pointed to by `name`
@@ -155,11 +162,12 @@ fn parse_def_load(data: &[u8],
 
 fn parse_def_notify(data: &[u8],
                     ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     // TODO: This requires significantly more infrastructure from the OS itself, see 5.6.6
@@ -176,11 +184,12 @@ fn parse_def_notify(data: &[u8],
 
 fn parse_def_release(data: &[u8],
                      ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     // TODO: Check ownership of the mutex pointed to
@@ -198,11 +207,12 @@ fn parse_def_release(data: &[u8],
 
 fn parse_def_reset(data: &[u8],
                    ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     // TODO: object (of type Event) is a semaphore. Reset the resource count to 0
@@ -218,11 +228,12 @@ fn parse_def_reset(data: &[u8],
 
 fn parse_def_signal(data: &[u8],
                     ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     // TODO: Increment the resource count of the semaphore
@@ -238,11 +249,12 @@ fn parse_def_signal(data: &[u8],
 
 fn parse_def_sleep(data: &[u8],
                    ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     // TODO: Sleep the processor for the specified number of milliseconds (minimum)
@@ -258,11 +270,12 @@ fn parse_def_sleep(data: &[u8],
 
 fn parse_def_stall(data: &[u8],
                    ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     // TODO: Sleep the processor for the specified number of microseconds (minimum)
@@ -278,11 +291,12 @@ fn parse_def_stall(data: &[u8],
 
 fn parse_def_unload(data: &[u8],
                     ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     // TODO: remove from namespace all values added when `object` was loaded
@@ -299,11 +313,12 @@ fn parse_def_unload(data: &[u8],
 
 fn parse_def_if_else(data: &[u8],
                      ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_opcode!(data, 0xA0);
@@ -331,11 +346,12 @@ fn parse_def_if_else(data: &[u8],
 
 fn parse_def_while(data: &[u8],
                    ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_opcode!(data, 0xA2);
@@ -343,13 +359,6 @@ fn parse_def_while(data: &[u8],
     let (pkg_length, pkg_length_len) = parse_pkg_length(&data[1..])?;
 
     loop {
-        if ctx.state != ExecutionState::EXECUTING {
-            return Ok(AmlParseType {
-                val: AmlValue::None,
-                len: 0 as usize
-            });
-        }
-        
         let predicate = parse_term_arg(&data[1 + pkg_length_len..], ctx)?;
         if predicate.val.get_as_integer()? == 0 {
             break;
@@ -357,11 +366,17 @@ fn parse_def_while(data: &[u8],
         
         parse_term_list(&data[1 + pkg_length_len + predicate.len .. 1 + pkg_length], ctx)?;
 
-        if ctx.state == ExecutionState::BREAK {
-            ctx.state = ExecutionState::EXECUTING;
-            break;
-        } else if ctx.state == ExecutionState::CONTINUE {
-            ctx.state = ExecutionState::EXECUTING;
+        match ctx.state {
+            ExecutionState::EXECUTING => (),
+            ExecutionState::BREAK => {
+                ctx.state = ExecutionState::EXECUTING;
+                break;
+            },
+            ExecutionState::CONTINUE => ctx.state = ExecutionState::EXECUTING,
+            _ => return Ok(AmlParseType {
+                val: AmlValue::None,
+                len: 0 as usize
+            })
         }
     }
     
@@ -373,18 +388,18 @@ fn parse_def_while(data: &[u8],
 
 fn parse_def_return(data: &[u8],
                     ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
-    // TODO: Return to the calling context
-    // TODO: We need contexts for that
     parser_opcode!(data, 0xA4);
 
     let arg_object = parse_term_arg(&data[1..], ctx)?;
+    ctx.state = ExecutionState::RETURN(arg_object.val);
 
     Ok(AmlParseType {
         val: AmlValue::None,
diff --git a/src/acpi/aml/type2opcode.rs b/src/acpi/aml/type2opcode.rs
index 2ef678e..52dcae0 100644
--- a/src/acpi/aml/type2opcode.rs
+++ b/src/acpi/aml/type2opcode.rs
@@ -25,11 +25,12 @@ pub enum MatchOpcode {
 
 pub fn parse_type2_opcode(data: &[u8],
                           ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_selector! {
@@ -91,11 +92,12 @@ pub fn parse_type2_opcode(data: &[u8],
 
 pub fn parse_type6_opcode(data: &[u8],
                           ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_selector! {
@@ -111,11 +113,12 @@ pub fn parse_type6_opcode(data: &[u8],
 
 pub fn parse_def_object_type(data: &[u8],
                              ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_opcode!(data, 0x8E);
@@ -132,11 +135,12 @@ pub fn parse_def_object_type(data: &[u8],
 
 pub fn parse_def_package(data: &[u8],
                          ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     // TODO: Handle deferred loads in here
@@ -162,11 +166,12 @@ pub fn parse_def_package(data: &[u8],
 
 pub fn parse_def_var_package(data: &[u8],
                              ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     // TODO: Handle deferred loads in here
@@ -195,11 +200,12 @@ pub fn parse_def_var_package(data: &[u8],
 
 fn parse_package_elements_list(data: &[u8],
                                ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     let mut current_offset: usize = 0;
@@ -228,11 +234,12 @@ fn parse_package_elements_list(data: &[u8],
 
 pub fn parse_def_buffer(data: &[u8],
                         ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     // TODO: Perform computation
@@ -250,11 +257,12 @@ pub fn parse_def_buffer(data: &[u8],
 
 fn parse_def_ref_of(data: &[u8],
                     ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     // TODO: Perform computation
@@ -270,11 +278,12 @@ fn parse_def_ref_of(data: &[u8],
 
 fn parse_def_deref_of(data: &[u8],
                       ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     // TODO: Perform computation
@@ -290,11 +299,12 @@ fn parse_def_deref_of(data: &[u8],
 
 fn parse_def_acquire(data: &[u8],
                      ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     // TODO: Store the result
@@ -312,11 +322,12 @@ fn parse_def_acquire(data: &[u8],
 
 fn parse_def_increment(data: &[u8],
                        ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_opcode!(data, 0x75);
@@ -334,11 +345,12 @@ fn parse_def_increment(data: &[u8],
 
 fn parse_def_index(data: &[u8],
                    ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     // TODO: Store the result, if appropriate
@@ -357,11 +369,12 @@ fn parse_def_index(data: &[u8],
 
 fn parse_def_land(data: &[u8],
                   ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_opcode!(data, 0x90);
@@ -379,11 +392,12 @@ fn parse_def_land(data: &[u8],
 
 fn parse_def_lequal(data: &[u8],
                     ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_opcode!(data, 0x93);
@@ -401,11 +415,12 @@ fn parse_def_lequal(data: &[u8],
 
 fn parse_def_lgreater(data: &[u8],
                       ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_opcode!(data, 0x94);
@@ -423,11 +438,12 @@ fn parse_def_lgreater(data: &[u8],
 
 fn parse_def_lless(data: &[u8],
                    ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_opcode!(data, 0x95);
@@ -445,11 +461,12 @@ fn parse_def_lless(data: &[u8],
 
 fn parse_def_lnot(data: &[u8],
                   ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_opcode!(data, 0x92);
@@ -465,11 +482,12 @@ fn parse_def_lnot(data: &[u8],
 
 fn parse_def_lor(data: &[u8],
                  ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_opcode!(data, 0x91);
@@ -487,11 +505,12 @@ fn parse_def_lor(data: &[u8],
 
 fn parse_def_to_hex_string(data: &[u8],
                            ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     // TODO: Compute the result
@@ -509,11 +528,12 @@ fn parse_def_to_hex_string(data: &[u8],
 
 fn parse_def_to_buffer(data: &[u8],
                        ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     // TODO: Compute the result
@@ -531,11 +551,12 @@ fn parse_def_to_buffer(data: &[u8],
 
 fn parse_def_to_bcd(data: &[u8],
                     ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     // TODO: Compute the result
@@ -553,11 +574,12 @@ fn parse_def_to_bcd(data: &[u8],
 
 fn parse_def_to_decimal_string(data: &[u8],
                                ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     // TODO: Compute the result
@@ -575,11 +597,12 @@ fn parse_def_to_decimal_string(data: &[u8],
 
 fn parse_def_to_integer(data: &[u8],
                         ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     // TODO: Compute the result
@@ -597,11 +620,12 @@ fn parse_def_to_integer(data: &[u8],
 
 fn parse_def_to_string(data: &[u8],
                        ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     // TODO: Compute the result
@@ -620,11 +644,12 @@ fn parse_def_to_string(data: &[u8],
 
 fn parse_def_subtract(data: &[u8],
                       ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_opcode!(data, 0x74);
@@ -645,11 +670,12 @@ fn parse_def_subtract(data: &[u8],
 
 fn parse_def_size_of(data: &[u8],
                      ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     // TODO: Perform the computation
@@ -665,11 +691,12 @@ fn parse_def_size_of(data: &[u8],
 
 fn parse_def_store(data: &[u8],
                    ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_opcode!(data, 0x70);
@@ -687,11 +714,12 @@ fn parse_def_store(data: &[u8],
 
 fn parse_def_or(data: &[u8],
                 ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_opcode!(data, 0x7D);
@@ -712,11 +740,12 @@ fn parse_def_or(data: &[u8],
 
 fn parse_def_shift_left(data: &[u8],
                         ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_opcode!(data, 0x79);
@@ -737,11 +766,12 @@ fn parse_def_shift_left(data: &[u8],
 
 fn parse_def_shift_right(data: &[u8],
                          ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_opcode!(data, 0x7A);
@@ -762,11 +792,12 @@ fn parse_def_shift_right(data: &[u8],
 
 fn parse_def_add(data: &[u8],
                  ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_opcode!(data, 0x72);
@@ -787,11 +818,12 @@ fn parse_def_add(data: &[u8],
 
 fn parse_def_and(data: &[u8],
                  ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_opcode!(data, 0x7B);
@@ -812,11 +844,12 @@ fn parse_def_and(data: &[u8],
 
 fn parse_def_xor(data: &[u8],
                  ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_opcode!(data, 0x7F);
@@ -837,11 +870,12 @@ fn parse_def_xor(data: &[u8],
 
 fn parse_def_concat_res(data: &[u8],
                         ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     // TODO: Compute the result
@@ -860,11 +894,12 @@ fn parse_def_concat_res(data: &[u8],
 
 fn parse_def_wait(data: &[u8],
                   ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     // TODO: Compute the result
@@ -881,11 +916,12 @@ fn parse_def_wait(data: &[u8],
 
 fn parse_def_cond_ref_of(data: &[u8],
                          ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     // TODO: Compute the result
@@ -903,11 +939,12 @@ fn parse_def_cond_ref_of(data: &[u8],
 
 fn parse_def_copy_object(data: &[u8],
                          ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     // TODO: Compute the result
@@ -925,11 +962,12 @@ fn parse_def_copy_object(data: &[u8],
 
 fn parse_def_concat(data: &[u8],
                     ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     // TODO: Compute the result
@@ -948,11 +986,12 @@ fn parse_def_concat(data: &[u8],
 
 fn parse_def_decrement(data: &[u8],
                        ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_opcode!(data, 0x76);
@@ -970,11 +1009,12 @@ fn parse_def_decrement(data: &[u8],
 
 fn parse_def_divide(data: &[u8],
                     ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_opcode!(data, 0x78);
@@ -1001,11 +1041,12 @@ fn parse_def_divide(data: &[u8],
 
 fn parse_def_find_set_left_bit(data: &[u8],
                                ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_opcode!(data, 0x81);
@@ -1036,11 +1077,12 @@ fn parse_def_find_set_left_bit(data: &[u8],
 
 fn parse_def_find_set_right_bit(data: &[u8],
                                 ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_opcode!(data, 0x82);
@@ -1075,11 +1117,12 @@ fn parse_def_find_set_right_bit(data: &[u8],
 
 fn parse_def_load_table(data: &[u8],
                         ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     // TODO: Compute the result
@@ -1102,6 +1145,14 @@ fn parse_def_load_table(data: &[u8],
 
 fn parse_def_match(data: &[u8],
                    ctx: &mut AmlExecutionContext) -> ParseResult {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
+            val: AmlValue::None,
+            len: 0 as usize
+        })
+    }
+    
     // TODO: Clean up
     parser_opcode!(data, 0x28);
     
@@ -1163,7 +1214,7 @@ fn parse_def_match(data: &[u8],
                 return Ok(AmlParseType {
                     val: AmlValue::Integer(idx as u64),
                     len: 3 + search_pkg.len + first_operand.len + second_operand.len + start_index.len
-                });
+                })
             }
         },
         AmlValue::String(i) => {
@@ -1194,7 +1245,7 @@ fn parse_def_match(data: &[u8],
                 return Ok(AmlParseType {
                     val: AmlValue::Integer(idx as u64),
                     len: 3 + search_pkg.len + first_operand.len + second_operand.len + start_index.len
-                });
+                })
             }
         },
         _ => {
@@ -1226,7 +1277,7 @@ fn parse_def_match(data: &[u8],
                 return Ok(AmlParseType {
                     val: AmlValue::Integer(idx as u64),
                     len: 3 + search_pkg.len + first_operand.len + second_operand.len + start_index.len
-                });
+                })
             }
         }
     }
@@ -1239,11 +1290,12 @@ fn parse_def_match(data: &[u8],
 
 fn parse_def_from_bcd(data: &[u8],
                       ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_opcode_extended!(data, 0x28);
@@ -1276,11 +1328,12 @@ fn parse_def_from_bcd(data: &[u8],
 
 fn parse_def_mid(data: &[u8],
                  ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_opcode!(data, 0x9E);
@@ -1337,11 +1390,12 @@ fn parse_def_mid(data: &[u8],
 
 fn parse_def_mod(data: &[u8],
                  ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_opcode!(data, 0x85);
@@ -1366,11 +1420,12 @@ fn parse_def_mod(data: &[u8],
 
 fn parse_def_multiply(data: &[u8],
                       ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     // TODO: Handle overflow
@@ -1392,11 +1447,12 @@ fn parse_def_multiply(data: &[u8],
 
 fn parse_def_nand(data: &[u8],
                   ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_opcode!(data, 0x7C);
@@ -1417,11 +1473,12 @@ fn parse_def_nand(data: &[u8],
 
 fn parse_def_nor(data: &[u8],
                  ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_opcode!(data, 0x7E);
@@ -1442,11 +1499,12 @@ fn parse_def_nor(data: &[u8],
 
 fn parse_def_not(data: &[u8],
                  ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_opcode!(data, 0x80);
@@ -1466,11 +1524,12 @@ fn parse_def_not(data: &[u8],
 
 fn parse_def_timer(data: &[u8],
                    ctx: &mut AmlExecutionContext) -> ParseResult {
-    if ctx.state != ExecutionState::EXECUTING {
-        return Ok(AmlParseType {
+    match ctx.state {
+        ExecutionState::EXECUTING => (),
+        _ => return Ok(AmlParseType {
             val: AmlValue::None,
             len: 0 as usize
-        });
+        })
     }
     
     parser_opcode_extended!(data, 0x33);