Implemented loop control

src/acpi/aml/dataobj.rs

@@ -3,7 +3,7 @@ use collections::string::String;
 use collections::btree_map::BTreeMap;
 
 use super::AmlError;
-use super::parser::{ AmlParseType, ParseResult, AmlExecutionContext };
+use super::parser::{ AmlParseType, ParseResult, AmlExecutionContext, ExecutionState };
 use super::namespace::{ AmlValue, ObjectReference };
 
 use super::type2opcode::{parse_def_buffer, parse_def_package, parse_def_var_package};
@@ -12,6 +12,13 @@ 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 {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_selector! {
         data, ctx,
         parse_computational_data,
@@ -24,6 +31,13 @@ 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 {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_selector! {
         data, ctx,
         parse_data_obj,
@@ -44,6 +58,13 @@ 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 {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     match data[0] {
         0x68 ... 0x6E => Ok(AmlParseType {
             val: AmlValue::ObjectReference(ObjectReference::ArgObj(data[0] - 0x68)),
@@ -55,6 +76,13 @@ 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 {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     match data[0] {
         0x68 ... 0x6E => Ok(AmlParseType {
             val: AmlValue::ObjectReference(ObjectReference::LocalObj(data[0] - 0x60)),
@@ -66,6 +94,13 @@ 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 {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     match data[0] {
         0x0A => Ok(AmlParseType {
             val: AmlValue::Integer(data[1] as u64),

src/acpi/aml/namedobj.rs

@@ -6,7 +6,7 @@ use core::str::FromStr;
 use collections::btree_map::BTreeMap;
 
 use super::AmlError;
-use super::parser::{ AmlParseType, ParseResult, AmlParseTypeGeneric, AmlExecutionContext };
+use super::parser::{ AmlParseType, ParseResult, AmlParseTypeGeneric, AmlExecutionContext, ExecutionState };
 use super::namespace::{ AmlValue, ObjectReference, FieldSelector, get_namespace_string };
 use super::namestring::{parse_name_string, parse_name_seg};
 use super::termlist::{parse_term_arg, parse_term_list, parse_object_list};
@@ -88,6 +88,13 @@ pub enum AccessAttrib {
 
 pub fn parse_named_obj(data: &[u8],
                        ctx: &mut AmlExecutionContext) -> ParseResult {
+    if ctx.state != ExecutionState::EXECUTING {
+        return Ok(AmlParseType {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_selector! {
         data, ctx,
         parse_def_bank_field,
@@ -115,6 +122,13 @@ 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 {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     // TODO: Why isn't bank name used?
     parser_opcode_extended!(data, 0x87);
 
@@ -163,6 +177,13 @@ 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 {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_opcode!(data, 0x8D);
 
     let source_buf = parse_term_arg(&data[2..], ctx)?;
@@ -185,6 +206,13 @@ 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 {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_opcode!(data, 0x8C);
 
     let source_buf = parse_term_arg(&data[2..], ctx)?;
@@ -207,6 +235,13 @@ 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 {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_opcode!(data, 0x8B);
 
     let source_buf = parse_term_arg(&data[2..], ctx)?;
@@ -229,6 +264,13 @@ 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 {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_opcode!(data, 0x8A);
 
     let source_buf = parse_term_arg(&data[2..], ctx)?;
@@ -251,6 +293,13 @@ 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 {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_opcode!(data, 0x8F);
 
     let source_buf = parse_term_arg(&data[2..], ctx)?;
@@ -273,6 +322,13 @@ 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 {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_opcode_extended!(data, 0x13);
 
     let source_buf = parse_term_arg(&data[2..], ctx)?;
@@ -296,6 +352,13 @@ 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 {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     // TODO: Find the actual offset and length, once table mapping is implemented
     parser_opcode_extended!(data, 0x88);
 
@@ -320,6 +383,13 @@ 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 {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_opcode_extended!(data, 0x02);
 
     let name = parse_name_string(&data[2..], ctx)?;
@@ -335,6 +405,13 @@ fn parse_def_event(data: &[u8],
 
 fn parse_def_device(data: &[u8],
                     ctx: &mut AmlExecutionContext) -> ParseResult {
+    if ctx.state != ExecutionState::EXECUTING {
+        return Ok(AmlParseType {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     // TODO: How to handle local context deferreds
     // TODO: How to also handle local context reference to calling context
     parser_opcode_extended!(data, 0x82);
@@ -356,6 +433,13 @@ 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 {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_opcode_extended!(data, 0x80);
 
     let name = parse_name_string(&data[2..], ctx)?;
@@ -392,6 +476,13 @@ 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 {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_opcode_extended!(data, 0x81);
 
     let (pkg_length, pkg_length_len) = parse_pkg_length(&data[2..])?;
@@ -429,6 +520,13 @@ 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 {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_opcode_extended!(data, 0x86);
 
     let (pkg_length, pkg_length_len) = parse_pkg_length(&data[2..])?;
@@ -473,13 +571,27 @@ fn parse_field_list(data: &[u8],
                     ctx: &mut AmlExecutionContext,
                     selector: FieldSelector,
                     flags: &mut FieldFlags) -> ParseResult {
+    if ctx.state != ExecutionState::EXECUTING {
+        return Ok(AmlParseType {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     let mut current_offset: usize = 0;
     let mut field_offset: usize = 0;
     let mut connection = AmlValue::Uninitialized;
 
     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 {
+                val: AmlValue::None,
+                len: 0 as usize
+            });
+        }
+    
         current_offset += res.len;
     }
 
@@ -495,6 +607,13 @@ fn parse_field_element(data: &[u8],
                        connection: &mut AmlValue,
                        flags: &mut FieldFlags,
                        offset: &mut usize) -> ParseResult {
+    if 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) {
         let local_scope_string = get_namespace_string(ctx.scope.clone(), AmlValue::String(field.val.name.clone()));
         
@@ -606,6 +725,13 @@ fn parse_access_field(data: &[u8],
 
 fn parse_connect_field(data: &[u8],
                        ctx: &mut AmlExecutionContext) -> ParseResult {
+    if ctx.state != ExecutionState::EXECUTING {
+        return Ok(AmlParseType {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_opcode!(data, 0x02);
 
     if let Ok(e) = parse_def_buffer(&data[1..], ctx) {
@@ -624,6 +750,13 @@ fn parse_connect_field(data: &[u8],
 
 fn parse_def_method(data: &[u8],
                     ctx: &mut AmlExecutionContext) -> ParseResult {
+    if ctx.state != ExecutionState::EXECUTING {
+        return Ok(AmlParseType {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_opcode!(data, 0x14);
 
     let (pkg_len, pkg_len_len) = parse_pkg_length(&data[1..])?;
@@ -652,6 +785,13 @@ fn parse_def_method(data: &[u8],
 
 fn parse_def_mutex(data: &[u8],
                    ctx: &mut AmlExecutionContext) -> ParseResult {
+    if ctx.state != ExecutionState::EXECUTING {
+        return Ok(AmlParseType {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_opcode_extended!(data, 0x01);
 
     let name = parse_name_string(&data[2 ..], ctx)?;
@@ -669,6 +809,13 @@ 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 {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     // TODO: How to handle local context deferreds
     // TODO: How to also handle local context reference to calling context
     parser_opcode_extended!(data, 0x84);
@@ -699,6 +846,13 @@ 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 {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_opcode_extended!(data, 0x83);
 
     let (pkg_len, pkg_len_len) = parse_pkg_length(&data[2..])?;
@@ -730,6 +884,13 @@ 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 {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_opcode_extended!(data, 0x85);    
     
     let (pkg_len, pkg_len_len) = parse_pkg_length(&data[2..])?;

src/acpi/aml/namespacemodifier.rs

@@ -4,7 +4,7 @@ use collections::vec::Vec;
 use collections::btree_map::BTreeMap;
 
 use super::AmlError;
-use super::parser::{AmlParseType, ParseResult, AmlParseTypeGeneric, AmlExecutionContext};
+use super::parser::{AmlParseType, ParseResult, AmlParseTypeGeneric, AmlExecutionContext, ExecutionState};
 use super::namespace::{AmlValue, ObjectReference, FieldSelector, get_namespace_string};
 use super::pkglength::parse_pkg_length;
 use super::namestring::parse_name_string;
@@ -13,6 +13,13 @@ 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 {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_selector! {
         data, ctx,
         parse_alias_op,
@@ -25,6 +32,13 @@ 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 {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_opcode!(data, 0x06);
 
     let source_name = parse_name_string(&data[1..], ctx)?;
@@ -44,6 +58,13 @@ fn parse_alias_op(data: &[u8],
 
 fn parse_name_op(data: &[u8],
                  ctx: &mut AmlExecutionContext) -> ParseResult {
+    if ctx.state != ExecutionState::EXECUTING {
+        return Ok(AmlParseType {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_opcode!(data, 0x08);
     
     let name = parse_name_string(&data[1..], ctx)?;
@@ -61,6 +82,13 @@ fn parse_name_op(data: &[u8],
 
 fn parse_scope_op(data: &[u8],
                   ctx: &mut AmlExecutionContext) -> ParseResult {
+    if ctx.state != ExecutionState::EXECUTING {
+        return Ok(AmlParseType {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_opcode!(data, 0x10);
 
     let (pkg_length, pkg_length_len) = parse_pkg_length(&data[1..])?;

src/acpi/aml/namestring.rs

@@ -3,13 +3,20 @@ use collections::string::String;
 use collections::btree_map::BTreeMap;
 
 use super::AmlError;
-use super::parser::{AmlParseType, ParseResult, AmlParseTypeGeneric, AmlExecutionContext};
+use super::parser::{AmlParseType, ParseResult, AmlParseTypeGeneric, AmlExecutionContext, ExecutionState};
 use super::namespace::{AmlValue, ObjectReference, FieldSelector, get_namespace_string};
 use super::dataobj::{parse_arg_obj, parse_local_obj};
 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 {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     let mut characters: Vec<u8> = vec!();
     let mut starting_index: usize = 0;
 
@@ -142,6 +149,13 @@ 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 {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_selector! {
         data, ctx,
         parse_simple_name,
@@ -154,6 +168,13 @@ 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 {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_opcode_extended!(data, 0x31);
 
     Ok(AmlParseType {
@@ -164,6 +185,13 @@ 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 {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_selector! {
         data, ctx,
         parse_name_string,
@@ -176,6 +204,13 @@ 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 {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     if data[0] == 0x00 {
         Ok(AmlParseType {
             val: AmlValue::None,

src/acpi/aml/parser.rs

@@ -12,11 +12,20 @@ pub struct AmlParseTypeGeneric<T> {
     pub len: usize
 }
 
+#[derive(PartialEq)]
+pub enum ExecutionState {
+    EXECUTING,
+    CONTINUE,
+    BREAK,
+    RETURN
+}
+
 pub struct AmlExecutionContext {
     pub namespace: BTreeMap<String, AmlValue>,
     pub scope: String,
     pub local_vars: [AmlValue; 8],
-    pub arg_vars: [AmlValue; 8]
+    pub arg_vars: [AmlValue; 8],
+    pub state: ExecutionState
 }
 
 impl AmlExecutionContext {
@@ -39,7 +48,8 @@ impl AmlExecutionContext {
                        AmlValue::Uninitialized,
                        AmlValue::Uninitialized,
                        AmlValue::Uninitialized,
-                       AmlValue::Uninitialized]
+                       AmlValue::Uninitialized],
+            state: ExecutionState::EXECUTING
         }
     }
 

src/acpi/aml/termlist.rs

@@ -4,7 +4,7 @@ use collections::vec::Vec;
 use collections::btree_map::BTreeMap;
 
 use super::AmlError;
-use super::parser::{ AmlParseType, ParseResult, AmlParseTypeGeneric, AmlExecutionContext };
+use super::parser::{ AmlParseType, ParseResult, AmlParseTypeGeneric, AmlExecutionContext, ExecutionState };
 use super::namespace::{AmlValue, ObjectReference, FieldSelector, get_namespace_string};
 use super::namespacemodifier::parse_namespace_modifier;
 use super::namedobj::parse_named_obj;
@@ -15,10 +15,25 @@ 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 {
+            val: AmlValue::None,
+            len: data.len()
+        });
+    }
+    
     let mut current_offset: usize = 0;
 
     while current_offset < data.len() {
         let res = parse_term_obj(&data[current_offset..], ctx)?;
+        
+        if ctx.state != ExecutionState::EXECUTING {
+            return Ok(AmlParseType {
+                val: AmlValue::None,
+                len: data.len()
+            });
+        }
+    
         current_offset += res.len;
     }
 
@@ -30,6 +45,13 @@ 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 {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_selector! {
         data, ctx,
         parse_local_obj,
@@ -43,10 +65,25 @@ 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 {
+            val: AmlValue::None,
+            len: data.len()
+        });
+    }
+    
     let mut current_offset: usize = 0;
 
     while current_offset < data.len() {
         let res = parse_object(&data[current_offset..], ctx)?;
+        
+        if ctx.state != ExecutionState::EXECUTING {
+            return Ok(AmlParseType {
+                val: AmlValue::None,
+                len: data.len()
+            });
+        }
+    
         current_offset += res.len;
     }
 
@@ -58,6 +95,13 @@ pub fn parse_object_list(data: &[u8],
 
 fn parse_object(data: &[u8],
                 ctx: &mut AmlExecutionContext) -> ParseResult {
+    if ctx.state != ExecutionState::EXECUTING {
+        return Ok(AmlParseType {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_selector! {
         data, ctx,
         parse_namespace_modifier,
@@ -69,6 +113,13 @@ fn parse_object(data: &[u8],
 
 pub fn parse_method_invocation(data: &[u8],
                                ctx: &mut AmlExecutionContext) -> ParseResult {
+    if ctx.state != ExecutionState::EXECUTING {
+        return Ok(AmlParseType {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     // TODO: Check if method exists in namespace
     // TODO: If so, parse appropriate number of parameters
     // TODO: If not, add deferred load to ctx
@@ -79,6 +130,13 @@ 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 {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_selector! {
         data, ctx,
         parse_namespace_modifier,

src/acpi/aml/type1opcode.rs

@@ -4,7 +4,7 @@ use collections::vec::Vec;
 use collections::btree_map::BTreeMap;
 
 use super::AmlError;
-use super::parser::{AmlParseType, ParseResult, AmlExecutionContext};
+use super::parser::{AmlParseType, ParseResult, AmlExecutionContext, ExecutionState};
 use super::namespace::{AmlValue, ObjectReference};
 use super::pkglength::parse_pkg_length;
 use super::termlist::{parse_term_arg, parse_term_list};
@@ -12,6 +12,13 @@ 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 {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_selector! {
         data, ctx,
         parse_def_break,
@@ -37,8 +44,15 @@ pub fn parse_type1_opcode(data: &[u8],
 
 fn parse_def_break(data: &[u8],
                    ctx: &mut AmlExecutionContext) -> ParseResult {
-    // TODO: Implement
+    if ctx.state != ExecutionState::EXECUTING {
+        return Ok(AmlParseType {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_opcode!(data, 0xA5);
+    ctx.state = ExecutionState::BREAK;
 
     Ok(AmlParseType {
         val: AmlValue::None,
@@ -48,6 +62,13 @@ fn parse_def_break(data: &[u8],
 
 fn parse_def_breakpoint(data: &[u8],
                         ctx: &mut AmlExecutionContext) -> ParseResult {
+    if ctx.state != ExecutionState::EXECUTING {
+        return Ok(AmlParseType {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_opcode!(data, 0xCC);
 
     Ok(AmlParseType {
@@ -58,8 +79,15 @@ fn parse_def_breakpoint(data: &[u8],
 
 fn parse_def_continue(data: &[u8],
                       ctx: &mut AmlExecutionContext) -> ParseResult {
-    // TODO: Implement
+    if ctx.state != ExecutionState::EXECUTING {
+        return Ok(AmlParseType {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_opcode!(data, 0x9F);
+    ctx.state = ExecutionState::CONTINUE;
 
     Ok(AmlParseType {
         val: AmlValue::None,
@@ -69,6 +97,13 @@ fn parse_def_continue(data: &[u8],
 
 fn parse_def_noop(data: &[u8],
                   ctx: &mut AmlExecutionContext) -> ParseResult {
+    if ctx.state != ExecutionState::EXECUTING {
+        return Ok(AmlParseType {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_opcode!(data, 0xA3);
 
     Ok(AmlParseType {
@@ -79,6 +114,13 @@ fn parse_def_noop(data: &[u8],
 
 fn parse_def_fatal(data: &[u8],
                    ctx: &mut AmlExecutionContext) -> ParseResult {
+    if ctx.state != ExecutionState::EXECUTING {
+        return Ok(AmlParseType {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_opcode_extended!(data, 0x32);
 
     let fatal_type = data[2];
@@ -90,6 +132,13 @@ fn parse_def_fatal(data: &[u8],
 
 fn parse_def_load(data: &[u8],
                   ctx: &mut AmlExecutionContext) -> ParseResult {
+    if ctx.state != ExecutionState::EXECUTING {
+        return Ok(AmlParseType {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     // TODO: Load in the table pointed to by `name`
     // TODO: Set DDB_Handle to the handle returned by loading in the table
     // TODO: Run the AML parser on the table, in a secondary namespace
@@ -106,6 +155,13 @@ fn parse_def_load(data: &[u8],
 
 fn parse_def_notify(data: &[u8],
                     ctx: &mut AmlExecutionContext) -> ParseResult {
+    if 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
     parser_opcode!(data, 0x86);
 
@@ -120,6 +176,13 @@ fn parse_def_notify(data: &[u8],
 
 fn parse_def_release(data: &[u8],
                      ctx: &mut AmlExecutionContext) -> ParseResult {
+    if ctx.state != ExecutionState::EXECUTING {
+        return Ok(AmlParseType {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     // TODO: Check ownership of the mutex pointed to
     // TODO: FATAL if not owned
     // TODO: Release if it is
@@ -135,6 +198,13 @@ fn parse_def_release(data: &[u8],
 
 fn parse_def_reset(data: &[u8],
                    ctx: &mut AmlExecutionContext) -> ParseResult {
+    if 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
     parser_opcode_extended!(data, 0x26);
 
@@ -148,6 +218,13 @@ fn parse_def_reset(data: &[u8],
 
 fn parse_def_signal(data: &[u8],
                     ctx: &mut AmlExecutionContext) -> ParseResult {
+    if ctx.state != ExecutionState::EXECUTING {
+        return Ok(AmlParseType {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     // TODO: Increment the resource count of the semaphore
     parser_opcode_extended!(data, 0x24);
 
@@ -161,6 +238,13 @@ fn parse_def_signal(data: &[u8],
 
 fn parse_def_sleep(data: &[u8],
                    ctx: &mut AmlExecutionContext) -> ParseResult {
+    if 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)
     parser_opcode_extended!(data, 0x22);
 
@@ -174,6 +258,13 @@ fn parse_def_sleep(data: &[u8],
 
 fn parse_def_stall(data: &[u8],
                    ctx: &mut AmlExecutionContext) -> ParseResult {
+    if 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)
     parser_opcode_extended!(data, 0x21);
 
@@ -187,6 +278,13 @@ fn parse_def_stall(data: &[u8],
 
 fn parse_def_unload(data: &[u8],
                     ctx: &mut AmlExecutionContext) -> ParseResult {
+    if 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
     // TODO: globally synchronous (how?)
     parser_opcode_extended!(data, 0x2A);
@@ -201,6 +299,13 @@ 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 {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_opcode!(data, 0xA0);
 
     let (pkg_length, pkg_length_len) = parse_pkg_length(&data[1..])?;
@@ -226,17 +331,38 @@ 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 {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_opcode!(data, 0xA2);
 
     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;
         }
         
         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;
+        }
     }
     
     Ok(AmlParseType {
@@ -247,6 +373,13 @@ fn parse_def_while(data: &[u8],
 
 fn parse_def_return(data: &[u8],
                     ctx: &mut AmlExecutionContext) -> ParseResult {
+    if 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);

src/acpi/aml/type2opcode.rs

@@ -4,7 +4,7 @@ use collections::vec::Vec;
 use collections::btree_map::BTreeMap;
 
 use super::AmlError;
-use super::parser::{AmlParseType, ParseResult, AmlExecutionContext};
+use super::parser::{AmlParseType, ParseResult, AmlExecutionContext, ExecutionState};
 use super::namespace::{AmlValue, ObjectReference};
 use super::pkglength::parse_pkg_length;
 use super::termlist::{parse_term_arg, parse_method_invocation};
@@ -25,6 +25,13 @@ pub enum MatchOpcode {
 
 pub fn parse_type2_opcode(data: &[u8],
                           ctx: &mut AmlExecutionContext) -> ParseResult {
+    if ctx.state != ExecutionState::EXECUTING {
+        return Ok(AmlParseType {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_selector! {
         data, ctx,
         parse_def_increment,
@@ -84,6 +91,13 @@ 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 {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_selector! {
         data, ctx,
         parse_def_deref_of,
@@ -97,6 +111,13 @@ 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 {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_opcode!(data, 0x8E);
     parser_selector! {
         data, ctx,
@@ -111,6 +132,13 @@ 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 {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     // TODO: Handle deferred loads in here
     parser_opcode!(data, 0x12);
 
@@ -134,6 +162,13 @@ 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 {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     // TODO: Handle deferred loads in here
     parser_opcode!(data, 0x13);
 
@@ -160,6 +195,13 @@ 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 {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     let mut current_offset: usize = 0;
     let mut elements: Vec<AmlValue> = vec!();
 
@@ -186,6 +228,13 @@ 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 {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     // TODO: Perform computation
     parser_opcode!(data, 0x11);
 
@@ -201,6 +250,13 @@ 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 {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     // TODO: Perform computation
     parser_opcode!(data, 0x71);
 
@@ -214,6 +270,13 @@ 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 {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     // TODO: Perform computation
     parser_opcode!(data, 0x83);
 
@@ -227,6 +290,13 @@ 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 {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     // TODO: Store the result
     // TODO: Perform computation
     parser_opcode_extended!(data, 0x23);
@@ -242,6 +312,13 @@ fn parse_def_acquire(data: &[u8],
 
 fn parse_def_increment(data: &[u8],
                        ctx: &mut AmlExecutionContext) -> ParseResult {
+    if ctx.state != ExecutionState::EXECUTING {
+        return Ok(AmlParseType {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_opcode!(data, 0x75);
 
     let obj = parse_super_name(&data[1..], ctx)?;
@@ -257,6 +334,13 @@ fn parse_def_increment(data: &[u8],
 
 fn parse_def_index(data: &[u8],
                    ctx: &mut AmlExecutionContext) -> ParseResult {
+    if ctx.state != ExecutionState::EXECUTING {
+        return Ok(AmlParseType {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     // TODO: Store the result, if appropriate
     // TODO: Perform computation
     parser_opcode!(data, 0x88);
@@ -273,6 +357,13 @@ fn parse_def_index(data: &[u8],
 
 fn parse_def_land(data: &[u8],
                   ctx: &mut AmlExecutionContext) -> ParseResult {
+    if ctx.state != ExecutionState::EXECUTING {
+        return Ok(AmlParseType {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_opcode!(data, 0x90);
 
     let lhs = parse_term_arg(&data[1..], ctx)?;
@@ -288,6 +379,13 @@ fn parse_def_land(data: &[u8],
 
 fn parse_def_lequal(data: &[u8],
                     ctx: &mut AmlExecutionContext) -> ParseResult {
+    if ctx.state != ExecutionState::EXECUTING {
+        return Ok(AmlParseType {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_opcode!(data, 0x93);
 
     let lhs = parse_term_arg(&data[1..], ctx)?;
@@ -303,6 +401,13 @@ fn parse_def_lequal(data: &[u8],
 
 fn parse_def_lgreater(data: &[u8],
                       ctx: &mut AmlExecutionContext) -> ParseResult {
+    if ctx.state != ExecutionState::EXECUTING {
+        return Ok(AmlParseType {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_opcode!(data, 0x94);
 
     let lhs = parse_term_arg(&data[1..], ctx)?;
@@ -318,6 +423,13 @@ fn parse_def_lgreater(data: &[u8],
 
 fn parse_def_lless(data: &[u8],
                    ctx: &mut AmlExecutionContext) -> ParseResult {
+    if ctx.state != ExecutionState::EXECUTING {
+        return Ok(AmlParseType {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_opcode!(data, 0x95);
 
     let lhs = parse_term_arg(&data[1..], ctx)?;
@@ -333,6 +445,13 @@ fn parse_def_lless(data: &[u8],
 
 fn parse_def_lnot(data: &[u8],
                   ctx: &mut AmlExecutionContext) -> ParseResult {
+    if ctx.state != ExecutionState::EXECUTING {
+        return Ok(AmlParseType {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_opcode!(data, 0x92);
 
     let operand = parse_term_arg(&data[1..], ctx)?;
@@ -346,6 +465,13 @@ fn parse_def_lnot(data: &[u8],
 
 fn parse_def_lor(data: &[u8],
                  ctx: &mut AmlExecutionContext) -> ParseResult {
+    if ctx.state != ExecutionState::EXECUTING {
+        return Ok(AmlParseType {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_opcode!(data, 0x91);
 
     let lhs = parse_term_arg(&data[1..], ctx)?;
@@ -361,6 +487,13 @@ 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 {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     // TODO: Compute the result
     // TODO: Store the result, if appropriate
     parser_opcode!(data, 0x98);
@@ -376,6 +509,13 @@ 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 {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     // TODO: Compute the result
     // TODO: Store the result, if appropriate
     parser_opcode!(data, 0x96);
@@ -391,6 +531,13 @@ 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 {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     // TODO: Compute the result
     // TODO: Store the result, if appropriate
     parser_opcode_extended!(data, 0x29);
@@ -406,6 +553,13 @@ 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 {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     // TODO: Compute the result
     // TODO: Store the result, if appropriate
     parser_opcode!(data, 0x97);
@@ -421,6 +575,13 @@ 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 {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     // TODO: Compute the result
     // TODO: Store the result, if appropriate
     parser_opcode!(data, 0x99);
@@ -436,6 +597,13 @@ 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 {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     // TODO: Compute the result
     // TODO: Store the result, if appropriate
     parser_opcode!(data, 0x9C);
@@ -452,6 +620,13 @@ 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 {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_opcode!(data, 0x74);
 
     let lhs = parse_term_arg(&data[1..], ctx)?;
@@ -470,6 +645,13 @@ 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 {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     // TODO: Perform the computation
     parser_opcode!(data, 0x87);
 
@@ -483,6 +665,13 @@ 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 {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_opcode!(data, 0x70);
 
     let operand = parse_term_arg(&data[1..], ctx)?;
@@ -498,6 +687,13 @@ fn parse_def_store(data: &[u8],
 
 fn parse_def_or(data: &[u8],
                 ctx: &mut AmlExecutionContext) -> ParseResult {
+    if ctx.state != ExecutionState::EXECUTING {
+        return Ok(AmlParseType {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_opcode!(data, 0x7D);
 
     let lhs = parse_term_arg(&data[1..], ctx)?;
@@ -516,6 +712,13 @@ 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 {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_opcode!(data, 0x79);
 
     let lhs = parse_term_arg(&data[1..], ctx)?;
@@ -534,6 +737,13 @@ 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 {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_opcode!(data, 0x7A);
 
     let lhs = parse_term_arg(&data[1..], ctx)?;
@@ -552,6 +762,13 @@ 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 {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_opcode!(data, 0x72);
 
     let lhs = parse_term_arg(&data[1..], ctx)?;
@@ -570,6 +787,13 @@ fn parse_def_add(data: &[u8],
 
 fn parse_def_and(data: &[u8],
                  ctx: &mut AmlExecutionContext) -> ParseResult {
+    if ctx.state != ExecutionState::EXECUTING {
+        return Ok(AmlParseType {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_opcode!(data, 0x7B);
 
     let lhs = parse_term_arg(&data[1..], ctx)?;
@@ -588,6 +812,13 @@ fn parse_def_and(data: &[u8],
 
 fn parse_def_xor(data: &[u8],
                  ctx: &mut AmlExecutionContext) -> ParseResult {
+    if ctx.state != ExecutionState::EXECUTING {
+        return Ok(AmlParseType {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_opcode!(data, 0x7F);
 
     let lhs = parse_term_arg(&data[1..], ctx)?;
@@ -606,6 +837,13 @@ 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 {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     // TODO: Compute the result
     // TODO: Store the result, if appropriate
     parser_opcode!(data, 0x84);
@@ -622,6 +860,13 @@ 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 {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     // TODO: Compute the result
     parser_opcode_extended!(data, 0x25);
 
@@ -636,6 +881,13 @@ 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 {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     // TODO: Compute the result
     // TODO: Store the result
     parser_opcode_extended!(data, 0x12);
@@ -651,6 +903,13 @@ 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 {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     // TODO: Compute the result
     // TODO: Store the result
     parser_opcode!(data, 0x9D);
@@ -666,6 +925,13 @@ 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 {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     // TODO: Compute the result
     // TODO: Store the result
     parser_opcode!(data, 0x73);
@@ -682,6 +948,13 @@ fn parse_def_concat(data: &[u8],
 
 fn parse_def_decrement(data: &[u8],
                        ctx: &mut AmlExecutionContext) -> ParseResult {
+    if ctx.state != ExecutionState::EXECUTING {
+        return Ok(AmlParseType {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_opcode!(data, 0x76);
 
     let obj = parse_super_name(&data[1..], ctx)?;
@@ -697,6 +970,13 @@ fn parse_def_decrement(data: &[u8],
 
 fn parse_def_divide(data: &[u8],
                     ctx: &mut AmlExecutionContext) -> ParseResult {
+    if ctx.state != ExecutionState::EXECUTING {
+        return Ok(AmlParseType {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_opcode!(data, 0x78);
 
     let lhs = parse_term_arg(&data[1..], ctx)?;
@@ -721,6 +1001,13 @@ 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 {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_opcode!(data, 0x81);
 
     let operand = parse_term_arg(&data[2..], ctx)?;
@@ -749,6 +1036,13 @@ 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 {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_opcode!(data, 0x82);
 
     let operand = parse_term_arg(&data[2..], ctx)?;
@@ -781,6 +1075,13 @@ 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 {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     // TODO: Compute the result
     // TODO: Store the result, if appropriate
     // TODO: Clean up
@@ -938,6 +1239,13 @@ 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 {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_opcode_extended!(data, 0x28);
 
     let operand = parse_term_arg(&data[2..], ctx)?;
@@ -968,6 +1276,13 @@ 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 {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_opcode!(data, 0x9E);
 
     let source = parse_term_arg(&data[1..], ctx)?;
@@ -1022,6 +1337,13 @@ fn parse_def_mid(data: &[u8],
 
 fn parse_def_mod(data: &[u8],
                  ctx: &mut AmlExecutionContext) -> ParseResult {
+    if ctx.state != ExecutionState::EXECUTING {
+        return Ok(AmlParseType {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_opcode!(data, 0x85);
 
     let lhs = parse_term_arg(&data[1..], ctx)?;
@@ -1044,6 +1366,13 @@ fn parse_def_mod(data: &[u8],
 
 fn parse_def_multiply(data: &[u8],
                       ctx: &mut AmlExecutionContext) -> ParseResult {
+    if ctx.state != ExecutionState::EXECUTING {
+        return Ok(AmlParseType {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     // TODO: Handle overflow
     parser_opcode!(data, 0x77);
 
@@ -1063,6 +1392,13 @@ fn parse_def_multiply(data: &[u8],
 
 fn parse_def_nand(data: &[u8],
                   ctx: &mut AmlExecutionContext) -> ParseResult {
+    if ctx.state != ExecutionState::EXECUTING {
+        return Ok(AmlParseType {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_opcode!(data, 0x7C);
 
     let lhs = parse_term_arg(&data[1..], ctx)?;
@@ -1081,6 +1417,13 @@ fn parse_def_nand(data: &[u8],
 
 fn parse_def_nor(data: &[u8],
                  ctx: &mut AmlExecutionContext) -> ParseResult {
+    if ctx.state != ExecutionState::EXECUTING {
+        return Ok(AmlParseType {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_opcode!(data, 0x7E);
 
     let lhs = parse_term_arg(&data[1..], ctx)?;
@@ -1099,6 +1442,13 @@ fn parse_def_nor(data: &[u8],
 
 fn parse_def_not(data: &[u8],
                  ctx: &mut AmlExecutionContext) -> ParseResult {
+    if ctx.state != ExecutionState::EXECUTING {
+        return Ok(AmlParseType {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_opcode!(data, 0x80);
 
     let operand = parse_term_arg(&data[1..], ctx)?;
@@ -1116,6 +1466,13 @@ fn parse_def_not(data: &[u8],
 
 fn parse_def_timer(data: &[u8],
                    ctx: &mut AmlExecutionContext) -> ParseResult {
+    if ctx.state != ExecutionState::EXECUTING {
+        return Ok(AmlParseType {
+            val: AmlValue::None,
+            len: 0 as usize
+        });
+    }
+    
     parser_opcode_extended!(data, 0x33);
 
     let (seconds, nanoseconds) = monotonic();