From 75279150275972e41dcb9c0c7803e4861dfaa715 Mon Sep 17 00:00:00 2001 From: Connor Wood Date: Mon, 3 Jul 2017 10:31:01 +0100 Subject: [PATCH] Added a context manager --- src/acpi/aml/dataobj.rs | 27 +-- src/acpi/aml/mod.rs | 15 +- src/acpi/aml/namedobj.rs | 294 +++++++++++----------- src/acpi/aml/namespace.rs | 1 + src/acpi/aml/namespacemodifier.rs | 44 ++-- src/acpi/aml/namestring.rs | 23 +- src/acpi/aml/parser.rs | 8 + src/acpi/aml/parsermacros.rs | 10 +- src/acpi/aml/termlist.rs | 35 ++- src/acpi/aml/type1opcode.rs | 91 +++---- src/acpi/aml/type2opcode.rs | 389 +++++++++++++----------------- 11 files changed, 425 insertions(+), 512 deletions(-) diff --git a/src/acpi/aml/dataobj.rs b/src/acpi/aml/dataobj.rs index 77f7d2f..4025f7f 100644 --- a/src/acpi/aml/dataobj.rs +++ b/src/acpi/aml/dataobj.rs @@ -3,18 +3,17 @@ use collections::string::String; use collections::btree_map::BTreeMap; use super::AmlError; -use super::parser::{AmlParseType, ParseResult}; -use super::namespace::{AmlValue, ObjectReference}; +use super::parser::{ AmlParseType, ParseResult, AmlExecutionContext }; +use super::namespace::{ AmlValue, ObjectReference }; use super::type2opcode::{parse_def_buffer, parse_def_package, parse_def_var_package}; use super::termlist::parse_term_arg; use super::namestring::parse_super_name; pub fn parse_data_obj(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { parser_selector! { - data, namespace, scope.clone(), + data, ctx, parse_computational_data, parse_def_package, parse_def_var_package @@ -24,15 +23,14 @@ pub fn parse_data_obj(data: &[u8], } pub fn parse_data_ref_obj(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { parser_selector! { - data, namespace, scope.clone(), + data, ctx, parse_data_obj, parse_term_arg }; - match parse_super_name(data, namespace, scope.clone()) { + match parse_super_name(data, ctx) { Ok(res) => match res.val { AmlValue::String(s) => Ok(AmlParseType { val: AmlValue::ObjectReference(ObjectReference::NamedObj(s)), @@ -45,8 +43,7 @@ pub fn parse_data_ref_obj(data: &[u8], } pub fn parse_arg_obj(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { match data[0] { 0x68 ... 0x6E => Ok(AmlParseType { val: AmlValue::ObjectReference(ObjectReference::ArgObj(data[0] - 0x68)), @@ -57,8 +54,7 @@ pub fn parse_arg_obj(data: &[u8], } pub fn parse_local_obj(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { match data[0] { 0x68 ... 0x6E => Ok(AmlParseType { val: AmlValue::ObjectReference(ObjectReference::LocalObj(data[0] - 0x60)), @@ -69,8 +65,7 @@ pub fn parse_local_obj(data: &[u8], } fn parse_computational_data(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { match data[0] { 0x0A => Ok(AmlParseType { val: AmlValue::Integer(data[1] as u64), @@ -148,6 +143,6 @@ fn parse_computational_data(data: &[u8], val: AmlValue::IntegerConstant(0xFFFFFFFFFFFFFFFF), len: 9 as usize }), - _ => parse_def_buffer(data, namespace, scope.clone()) + _ => parse_def_buffer(data, ctx) } } diff --git a/src/acpi/aml/mod.rs b/src/acpi/aml/mod.rs index a113c0b..d20ce4c 100644 --- a/src/acpi/aml/mod.rs +++ b/src/acpi/aml/mod.rs @@ -24,7 +24,7 @@ mod type1opcode; mod type2opcode; mod parser; -use self::parser::ParseResult; +use self::parser::{ ParseResult, AmlExecutionContext }; use self::termlist::parse_term_list; pub use self::namespace::AmlValue; @@ -39,13 +39,14 @@ pub enum AmlError { pub fn parse_aml_table(sdt: &'static Sdt) -> Result, AmlError> { let data = sdt.data(); + let mut ctx = AmlExecutionContext { + namespace: &mut BTreeMap::new(), + scope: String::from_str("\\").unwrap() + }; + + let term_list = parse_term_list(data, &mut ctx)?; - let global_namespace_specifier = String::from_str("\\").unwrap(); - let mut global_namespace = BTreeMap::new(); - - let term_list = parse_term_list(data, &mut global_namespace, global_namespace_specifier.clone())?; - - Ok(global_namespace) + Ok(ctx.namespace.clone()) } pub fn is_aml_table(sdt: &'static Sdt) -> bool { diff --git a/src/acpi/aml/namedobj.rs b/src/acpi/aml/namedobj.rs index c521893..3c4605b 100644 --- a/src/acpi/aml/namedobj.rs +++ b/src/acpi/aml/namedobj.rs @@ -6,8 +6,8 @@ use core::str::FromStr; use collections::btree_map::BTreeMap; use super::AmlError; -use super::parser::{AmlParseType, ParseResult, AmlParseTypeGeneric}; -use super::namespace::{AmlValue, ObjectReference, FieldSelector, get_namespace_string}; +use super::parser::{ AmlParseType, ParseResult, AmlParseTypeGeneric, AmlExecutionContext }; +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}; use super::pkglength::parse_pkg_length; @@ -87,10 +87,9 @@ pub enum AccessAttrib { } pub fn parse_named_obj(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { parser_selector! { - data, namespace, scope.clone(), + data, ctx, parse_def_bank_field, parse_def_create_bit_field, parse_def_create_byte_field, @@ -115,19 +114,17 @@ pub fn parse_named_obj(data: &[u8], } fn parse_def_bank_field(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { // TODO: Why isn't bank name used? parser_opcode_extended!(data, 0x87); let (pkg_length, pkg_length_len) = parse_pkg_length(&data[2..])?; let data = &data[2 + pkg_length_len .. 2 + pkg_length]; - let region_name = parse_name_string(data, namespace, scope.clone())?; - let bank_name = parse_name_string(&data[2 + pkg_length_len + region_name.len .. 2 + pkg_length], namespace, scope.clone())?; + let region_name = parse_name_string(data, ctx)?; + let bank_name = parse_name_string(&data[2 + pkg_length_len + region_name.len .. 2 + pkg_length], ctx)?; - let bank_value = parse_term_arg( - &data[2 + pkg_length_len + region_name.len .. 2 + pkg_length], namespace, scope.clone())?; + let bank_value = parse_term_arg(&data[2 + pkg_length_len + region_name.len .. 2 + pkg_length], ctx)?; let flags_raw = data[2 + pkg_length_len + region_name.len + bank_name.len + bank_value.len]; let mut flags = FieldFlags { @@ -156,7 +153,7 @@ fn parse_def_bank_field(data: &[u8], let field_list = parse_field_list( &data[3 + pkg_length_len + region_name.len + bank_name.len + bank_value.len .. - 2 + pkg_length], namespace, scope, selector, &mut flags)?; + 2 + pkg_length], ctx, selector, &mut flags)?; Ok(AmlParseType { val: AmlValue::None, @@ -165,17 +162,16 @@ fn parse_def_bank_field(data: &[u8], } fn parse_def_create_bit_field(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { parser_opcode!(data, 0x8D); - let source_buf = parse_term_arg(&data[2..], namespace, scope.clone())?; - let bit_index = parse_term_arg(&data[2 + source_buf.len..], namespace, scope.clone())?; - let name = parse_name_string(&data[1 + source_buf.len + bit_index.len..], namespace, scope.clone())?; + let source_buf = parse_term_arg(&data[2..], ctx)?; + let bit_index = parse_term_arg(&data[2 + source_buf.len..], ctx)?; + let name = parse_name_string(&data[1 + source_buf.len + bit_index.len..], ctx)?; - let local_scope_string = get_namespace_string(scope.clone(), name.val); + let local_scope_string = get_namespace_string(ctx.scope.clone(), name.val); - namespace.insert(local_scope_string, AmlValue::BufferField { + ctx.namespace.insert(local_scope_string, AmlValue::BufferField { source_buf: Box::new(source_buf.val), index: Box::new(bit_index.val), length: Box::new(AmlValue::IntegerConstant(1)) @@ -188,17 +184,16 @@ fn parse_def_create_bit_field(data: &[u8], } fn parse_def_create_byte_field(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { parser_opcode!(data, 0x8C); - let source_buf = parse_term_arg(&data[2..], namespace, scope.clone())?; - let bit_index = parse_term_arg(&data[2 + source_buf.len..], namespace, scope.clone())?; - let name = parse_name_string(&data[1 + source_buf.len + bit_index.len..], namespace, scope.clone())?; + let source_buf = parse_term_arg(&data[2..], ctx)?; + let bit_index = parse_term_arg(&data[2 + source_buf.len..], ctx)?; + let name = parse_name_string(&data[1 + source_buf.len + bit_index.len..], ctx)?; - let local_scope_string = get_namespace_string(scope.clone(), name.val); + let local_scope_string = get_namespace_string(ctx.scope.clone(), name.val); - namespace.insert(local_scope_string, AmlValue::BufferField { + ctx.namespace.insert(local_scope_string, AmlValue::BufferField { source_buf: Box::new(source_buf.val), index: Box::new(bit_index.val), length: Box::new(AmlValue::IntegerConstant(8)) @@ -211,17 +206,16 @@ fn parse_def_create_byte_field(data: &[u8], } fn parse_def_create_word_field(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { parser_opcode!(data, 0x8B); - let source_buf = parse_term_arg(&data[2..], namespace, scope.clone())?; - let bit_index = parse_term_arg(&data[2 + source_buf.len..], namespace, scope.clone())?; - let name = parse_name_string(&data[1 + source_buf.len + bit_index.len..], namespace, scope.clone())?; + let source_buf = parse_term_arg(&data[2..], ctx)?; + let bit_index = parse_term_arg(&data[2 + source_buf.len..], ctx)?; + let name = parse_name_string(&data[1 + source_buf.len + bit_index.len..], ctx)?; - let local_scope_string = get_namespace_string(scope.clone(), name.val); + let local_scope_string = get_namespace_string(ctx.scope.clone(), name.val); - namespace.insert(local_scope_string, AmlValue::BufferField { + ctx.namespace.insert(local_scope_string, AmlValue::BufferField { source_buf: Box::new(source_buf.val), index: Box::new(bit_index.val), length: Box::new(AmlValue::IntegerConstant(16)) @@ -234,17 +228,16 @@ fn parse_def_create_word_field(data: &[u8], } fn parse_def_create_dword_field(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { parser_opcode!(data, 0x8A); - let source_buf = parse_term_arg(&data[2..], namespace, scope.clone())?; - let bit_index = parse_term_arg(&data[2 + source_buf.len..], namespace, scope.clone())?; - let name = parse_name_string(&data[1 + source_buf.len + bit_index.len..], namespace, scope.clone())?; + let source_buf = parse_term_arg(&data[2..], ctx)?; + let bit_index = parse_term_arg(&data[2 + source_buf.len..], ctx)?; + let name = parse_name_string(&data[1 + source_buf.len + bit_index.len..], ctx)?; - let local_scope_string = get_namespace_string(scope.clone(), name.val); + let local_scope_string = get_namespace_string(ctx.scope.clone(), name.val); - namespace.insert(local_scope_string, AmlValue::BufferField { + ctx.namespace.insert(local_scope_string, AmlValue::BufferField { source_buf: Box::new(source_buf.val), index: Box::new(bit_index.val), length: Box::new(AmlValue::IntegerConstant(32)) @@ -257,17 +250,16 @@ fn parse_def_create_dword_field(data: &[u8], } fn parse_def_create_qword_field(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { parser_opcode!(data, 0x8F); - let source_buf = parse_term_arg(&data[2..], namespace, scope.clone())?; - let bit_index = parse_term_arg(&data[2 + source_buf.len..], namespace, scope.clone())?; - let name = parse_name_string(&data[1 + source_buf.len + bit_index.len..], namespace, scope.clone())?; + let source_buf = parse_term_arg(&data[2..], ctx)?; + let bit_index = parse_term_arg(&data[2 + source_buf.len..], ctx)?; + let name = parse_name_string(&data[1 + source_buf.len + bit_index.len..], ctx)?; - let local_scope_string = get_namespace_string(scope.clone(), name.val); + let local_scope_string = get_namespace_string(ctx.scope.clone(), name.val); - namespace.insert(local_scope_string, AmlValue::BufferField { + ctx.namespace.insert(local_scope_string, AmlValue::BufferField { source_buf: Box::new(source_buf.val), index: Box::new(bit_index.val), length: Box::new(AmlValue::IntegerConstant(64)) @@ -280,18 +272,17 @@ fn parse_def_create_qword_field(data: &[u8], } fn parse_def_create_field(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { parser_opcode_extended!(data, 0x13); - let source_buf = parse_term_arg(&data[2..], namespace, scope.clone())?; - let bit_index = parse_term_arg(&data[2 + source_buf.len..], namespace, scope.clone())?; - let num_bits = parse_term_arg(&data[2 + source_buf.len + bit_index.len..], namespace, scope.clone())?; - let name = parse_name_string(&data[2 + source_buf.len + bit_index.len + num_bits.len..], namespace, scope.clone())?; + let source_buf = parse_term_arg(&data[2..], ctx)?; + let bit_index = parse_term_arg(&data[2 + source_buf.len..], ctx)?; + let num_bits = parse_term_arg(&data[2 + source_buf.len + bit_index.len..], ctx)?; + let name = parse_name_string(&data[2 + source_buf.len + bit_index.len + num_bits.len..], ctx)?; - let local_scope_string = get_namespace_string(scope.clone(), name.val); + let local_scope_string = get_namespace_string(ctx.scope.clone(), name.val); - namespace.insert(local_scope_string, AmlValue::BufferField { + ctx.namespace.insert(local_scope_string, AmlValue::BufferField { source_buf: Box::new(source_buf.val), index: Box::new(bit_index.val), length: Box::new(num_bits.val) @@ -304,19 +295,18 @@ fn parse_def_create_field(data: &[u8], } fn parse_def_data_region(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { // TODO: Find the actual offset and length, once table mapping is implemented parser_opcode_extended!(data, 0x88); - let name = parse_name_string(&data[2..], namespace, scope.clone())?; - let signature = parse_term_arg(&data[2 + name.len..], namespace, scope.clone())?; - let oem_id = parse_term_arg(&data[2 + name.len + signature.len..], namespace, scope.clone())?; - let oem_table_id = parse_term_arg(&data[2 + name.len + signature.len + oem_id.len..], namespace, scope.clone())?; - - let local_scope_string = get_namespace_string(scope.clone(), name.val); + let name = parse_name_string(&data[2..], ctx)?; + let signature = parse_term_arg(&data[2 + name.len..], ctx)?; + let oem_id = parse_term_arg(&data[2 + name.len + signature.len..], ctx)?; + let oem_table_id = parse_term_arg(&data[2 + name.len + signature.len + oem_id.len..], ctx)?; - namespace.insert(local_scope_string, AmlValue::OperationRegion { + let local_scope_string = get_namespace_string(ctx.scope.clone(), name.val); + + ctx.namespace.insert(local_scope_string, AmlValue::OperationRegion { region: RegionSpace::SystemMemory, offset: Box::new(AmlValue::IntegerConstant(0)), len: Box::new(AmlValue::IntegerConstant(0)) @@ -329,14 +319,13 @@ fn parse_def_data_region(data: &[u8], } fn parse_def_event(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { parser_opcode_extended!(data, 0x02); - let name = parse_name_string(&data[2..], namespace, scope.clone())?; + let name = parse_name_string(&data[2..], ctx)?; - let local_scope_string = get_namespace_string(scope, name.val); - namespace.insert(local_scope_string, AmlValue::Event); + let local_scope_string = get_namespace_string(ctx.scope.clone(), name.val); + ctx.namespace.insert(local_scope_string, AmlValue::Event); Ok(AmlParseType { val: AmlValue::None, @@ -345,18 +334,23 @@ fn parse_def_event(data: &[u8], } fn parse_def_device(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { + // TODO: How to handle local context deferreds + // TODO: How to also handle local context reference to calling context parser_opcode_extended!(data, 0x82); let (pkg_length, pkg_length_len) = parse_pkg_length(&data[2..])?; - let name = parse_name_string(&data[2 + pkg_length_len .. 2 + pkg_length], namespace, scope.clone())?; - - let mut local_namespace = BTreeMap::new(); - let obj_list = parse_object_list(&data[2 + pkg_length_len + name.len .. 2 + pkg_length], &mut local_namespace, String::new())?; + let name = parse_name_string(&data[2 + pkg_length_len .. 2 + pkg_length], ctx)?; - let local_scope_string = get_namespace_string(scope, name.val); - namespace.insert(local_scope_string, AmlValue::Device(local_namespace)); + let mut local_ctx = AmlExecutionContext { + namespace: &mut BTreeMap::new(), + scope: String::new() + }; + + let obj_list = parse_object_list(&data[2 + pkg_length_len + name.len .. 2 + pkg_length], &mut local_ctx)?; + + let local_scope_string = get_namespace_string(ctx.scope.clone(), name.val); + ctx.namespace.insert(local_scope_string, AmlValue::Device(local_ctx.namespace.clone())); Ok(AmlParseType { val: AmlValue::None, @@ -365,11 +359,10 @@ fn parse_def_device(data: &[u8], } fn parse_def_op_region(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { parser_opcode_extended!(data, 0x80); - let name = parse_name_string(&data[2..], namespace, scope.clone())?; + let name = parse_name_string(&data[2..], ctx)?; let region = match data[2 + name.len] { 0x00 => RegionSpace::SystemMemory, 0x01 => RegionSpace::SystemIO, @@ -385,11 +378,11 @@ fn parse_def_op_region(data: &[u8], _ => return Err(AmlError::AmlParseError("OpRegion - invalid region")) }; - let offset = parse_term_arg(&data[3 + name.len..], namespace, scope.clone())?; - let len = parse_term_arg(&data[3 + name.len + offset.len..], namespace, scope.clone())?; + let offset = parse_term_arg(&data[3 + name.len..], ctx)?; + let len = parse_term_arg(&data[3 + name.len + offset.len..], ctx)?; - let local_scope_string = get_namespace_string(scope.clone(), name.val); - namespace.insert(local_scope_string, AmlValue::OperationRegion { + let local_scope_string = get_namespace_string(ctx.scope.clone(), name.val); + ctx.namespace.insert(local_scope_string, AmlValue::OperationRegion { region: region, offset: Box::new(offset.val), len: Box::new(len.val) @@ -402,12 +395,11 @@ fn parse_def_op_region(data: &[u8], } fn parse_def_field(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { parser_opcode_extended!(data, 0x81); let (pkg_length, pkg_length_len) = parse_pkg_length(&data[2..])?; - let name = parse_name_string(&data[2 + pkg_length_len .. 2 + pkg_length], namespace, scope.clone())?; + let name = parse_name_string(&data[2 + pkg_length_len .. 2 + pkg_length], ctx)?; let flags_raw = data[2 + pkg_length_len + name.len]; let mut flags = FieldFlags { @@ -431,7 +423,7 @@ fn parse_def_field(data: &[u8], let selector = FieldSelector::Region(name.val.get_as_string()?); - let field_list = parse_field_list(&data[3 + pkg_length_len + name.len .. 2 + pkg_length], namespace, scope, selector, &mut flags)?; + let field_list = parse_field_list(&data[3 + pkg_length_len + name.len .. 2 + pkg_length], ctx, selector, &mut flags)?; Ok(AmlParseType { val: AmlValue::None, @@ -440,13 +432,12 @@ fn parse_def_field(data: &[u8], } fn parse_def_index_field(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { parser_opcode_extended!(data, 0x86); let (pkg_length, pkg_length_len) = parse_pkg_length(&data[2..])?; - let idx_name = parse_name_string( &data[2 + pkg_length_len .. 2 + pkg_length], namespace, scope.clone())?; - let data_name = parse_name_string(&data[2 + pkg_length_len + idx_name.len .. 2 + pkg_length], namespace, scope.clone())?; + let idx_name = parse_name_string(&data[2 + pkg_length_len .. 2 + pkg_length], ctx)?; + let data_name = parse_name_string(&data[2 + pkg_length_len + idx_name.len .. 2 + pkg_length], ctx)?; let flags_raw = data[2 + pkg_length_len + idx_name.len + data_name.len]; let mut flags = FieldFlags { @@ -474,7 +465,7 @@ fn parse_def_index_field(data: &[u8], }; let field_list = parse_field_list( - &data[3 + pkg_length_len + idx_name.len + data_name.len .. 2 + pkg_length], namespace, scope, selector, &mut flags)?; + &data[3 + pkg_length_len + idx_name.len + data_name.len .. 2 + pkg_length], ctx, selector, &mut flags)?; Ok(AmlParseType { val: AmlValue::None, @@ -483,21 +474,14 @@ fn parse_def_index_field(data: &[u8], } fn parse_field_list(data: &[u8], - namespace: &mut BTreeMap, - scope: String, + ctx: &mut AmlExecutionContext, selector: FieldSelector, flags: &mut FieldFlags) -> ParseResult { let mut current_offset: usize = 0; let mut connection = AmlValue::Uninitialized; while current_offset < data.len() { - match parse_field_element(&data[current_offset..], namespace, scope.clone(), selector.clone(), - &mut connection, flags, &mut current_offset) { - Ok(_) => (), - Err(AmlError::AmlInvalidOpCode) => - return Err(AmlError::AmlParseError("FieldList - no valid field")), - Err(e) => return Err(e) - } + parse_field_element(&data[current_offset..], ctx, selector.clone(), &mut connection, flags, &mut current_offset)?; } Ok(AmlParseType { @@ -507,16 +491,15 @@ fn parse_field_list(data: &[u8], } fn parse_field_element(data: &[u8], - namespace: &mut BTreeMap, - scope: String, + ctx: &mut AmlExecutionContext, selector: FieldSelector, connection: &mut AmlValue, flags: &mut FieldFlags, offset: &mut usize) -> ParseResult { - let length = if let Ok(field) = parse_named_field(data, namespace, scope.clone()) { - let local_scope_string = get_namespace_string(scope.clone(), AmlValue::String(field.val.name.clone())); + 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())); - namespace.insert(local_scope_string, AmlValue::FieldUnit { + ctx.namespace.insert(local_scope_string, AmlValue::FieldUnit { selector: selector.clone(), connection: Box::new(connection.clone()), flags: flags.clone(), @@ -525,10 +508,10 @@ fn parse_field_element(data: &[u8], }); field.len - } else if let Ok(field) = parse_reserved_field(data, namespace, scope.clone()) { + } else if let Ok(field) = parse_reserved_field(data, ctx) { *offset += field.val; field.len - } else if let Ok(field) = parse_access_field(data, namespace, scope.clone()) { + } else if let Ok(field) = parse_access_field(data, ctx) { match field.val.access_type { AccessType::BufferAcc(_) => flags.access_type = AccessType::BufferAcc(field.val.access_attrib.clone()), @@ -536,7 +519,7 @@ fn parse_field_element(data: &[u8], } field.len - } else if let Ok(field) = parse_connect_field(data, namespace, scope.clone()) { + } else if let Ok(field) = parse_connect_field(data, ctx) { *connection = field.val.clone(); field.len } else { @@ -550,8 +533,7 @@ fn parse_field_element(data: &[u8], } fn parse_named_field(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> Result, AmlError> { + ctx: &mut AmlExecutionContext) -> Result, AmlError> { let (name_seg, name_seg_len) = parse_name_seg(&data[0..4])?; let name = match String::from_utf8(name_seg) { Ok(s) => s, @@ -566,8 +548,7 @@ fn parse_named_field(data: &[u8], } fn parse_reserved_field(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> Result, AmlError> { + ctx: &mut AmlExecutionContext) -> Result, AmlError> { parser_opcode!(data, 0x00); let (length, length_len) = parse_pkg_length(&data[1..])?; @@ -578,8 +559,7 @@ fn parse_reserved_field(data: &[u8], } fn parse_access_field(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> Result, AmlError> { + ctx: &mut AmlExecutionContext) -> Result, AmlError> { parser_opcode!(data, 0x01, 0x03); let flags_raw = data[1]; @@ -625,17 +605,16 @@ fn parse_access_field(data: &[u8], } fn parse_connect_field(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { parser_opcode!(data, 0x02); - if let Ok(e) = parse_def_buffer(&data[1..], namespace, scope.clone()) { + if let Ok(e) = parse_def_buffer(&data[1..], ctx) { Ok(AmlParseType { val: e.val, len: e.len + 1 }) } else { - let name = parse_name_string(&data[1..], namespace, scope.clone())?; + let name = parse_name_string(&data[1..], ctx)?; Ok(AmlParseType { val: AmlValue::ObjectReference(ObjectReference::NamedObj(name.val.get_as_string()?)), len: name.len + 1 @@ -644,12 +623,11 @@ fn parse_connect_field(data: &[u8], } fn parse_def_method(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { parser_opcode!(data, 0x14); let (pkg_len, pkg_len_len) = parse_pkg_length(&data[1..])?; - let name = parse_name_string(&data[1 + pkg_len_len..], namespace, scope.clone())?; + let name = parse_name_string(&data[1 + pkg_len_len..], ctx)?; let flags = data[1 + pkg_len_len + name.len]; let arg_count = flags & 0x07; @@ -658,8 +636,8 @@ fn parse_def_method(data: &[u8], let term_list = &data[2 + pkg_len_len + name.len .. 1 + pkg_len]; - let local_scope_string = get_namespace_string(scope.clone(), name.val); - namespace.insert(local_scope_string, AmlValue::Method(Method { + let local_scope_string = get_namespace_string(ctx.scope.clone(), name.val); + ctx.namespace.insert(local_scope_string, AmlValue::Method(Method { arg_count, serialized, sync_level, @@ -673,16 +651,15 @@ fn parse_def_method(data: &[u8], } fn parse_def_mutex(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { parser_opcode_extended!(data, 0x01); - let name = parse_name_string(&data[2 ..], namespace, scope.clone())?; + let name = parse_name_string(&data[2 ..], ctx)?; let flags = data[2 + name.len]; let sync_level = flags & 0x0F; - let local_scope_string = get_namespace_string(scope, name.val); - namespace.insert(local_scope_string, AmlValue::Mutex(sync_level)); + let local_scope_string = get_namespace_string(ctx.scope.clone(), name.val); + ctx.namespace.insert(local_scope_string, AmlValue::Mutex(sync_level)); Ok(AmlParseType { val: AmlValue::None, @@ -691,26 +668,31 @@ fn parse_def_mutex(data: &[u8], } fn parse_def_power_res(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { + // TODO: How to handle local context deferreds + // TODO: How to also handle local context reference to calling context parser_opcode_extended!(data, 0x84); let (pkg_len, pkg_len_len) = parse_pkg_length(&data[2..])?; - let name = parse_name_string(&data[2 + pkg_len_len..], namespace, scope.clone())?; + let name = parse_name_string(&data[2 + pkg_len_len..], ctx)?; - let local_scope_string = get_namespace_string(scope, name.val); - let mut local_namespace = BTreeMap::new(); + let local_scope_string = get_namespace_string(ctx.scope.clone(), name.val); let system_level = data[2 + pkg_len_len + name.len]; let resource_order: u16 = (data[3 + pkg_len_len + name.len] as u16) + ((data[4 + pkg_len_len + name.len] as u16) << 8); - parse_object_list(&data[5 + pkg_len_len + name.len .. 2 + pkg_len], &mut local_namespace, String::new())?; + let mut local_ctx = AmlExecutionContext { + namespace: &mut BTreeMap::new(), + scope: String::new() + }; + + parse_object_list(&data[5 + pkg_len_len + name.len .. 2 + pkg_len], &mut local_ctx)?; - namespace.insert(local_scope_string, AmlValue::PowerResource { + ctx.namespace.insert(local_scope_string, AmlValue::PowerResource { system_level, resource_order, - obj_list: local_namespace + obj_list: local_ctx.namespace.clone() }); Ok(AmlParseType { @@ -720,15 +702,13 @@ fn parse_def_power_res(data: &[u8], } fn parse_def_processor(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { parser_opcode_extended!(data, 0x83); let (pkg_len, pkg_len_len) = parse_pkg_length(&data[2..])?; - let name = parse_name_string(&data[2 + pkg_len_len..], namespace, scope.clone())?; + let name = parse_name_string(&data[2 + pkg_len_len..], ctx)?; - let local_scope_string = get_namespace_string(scope, name.val); - let mut local_namespace = BTreeMap::new(); + let local_scope_string = get_namespace_string(ctx.scope.clone(), name.val); let proc_id = data[2 + pkg_len_len + name.len]; let p_blk_addr: u32 = (data[3 + pkg_len_len + name.len] as u32) + @@ -737,12 +717,17 @@ fn parse_def_processor(data: &[u8], ((data[6 + pkg_len_len + name.len] as u32) << 24); let p_blk_len = data[7 + pkg_len_len + name.len]; - parse_object_list(&data[8 + pkg_len_len + name.len .. 2 + pkg_len], &mut local_namespace, String::new())?; + let mut local_ctx = AmlExecutionContext { + namespace: &mut BTreeMap::new(), + scope: String::new() + }; - namespace.insert(local_scope_string, AmlValue::Processor { + parse_object_list(&data[8 + pkg_len_len + name.len .. 2 + pkg_len], &mut local_ctx)?; + + ctx.namespace.insert(local_scope_string, AmlValue::Processor { proc_id: proc_id, p_blk: if p_blk_len > 0 { Some(p_blk_addr) } else { None }, - obj_list: local_namespace + obj_list: local_ctx.namespace.clone() }); Ok(AmlParseType { @@ -752,19 +737,22 @@ fn parse_def_processor(data: &[u8], } fn parse_def_thermal_zone(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { parser_opcode_extended!(data, 0x85); let (pkg_len, pkg_len_len) = parse_pkg_length(&data[2..])?; - let name = parse_name_string(&data[2 + pkg_len_len .. 2 + pkg_len], namespace, scope.clone())?; + let name = parse_name_string(&data[2 + pkg_len_len .. 2 + pkg_len], ctx)?; - let local_scope_string = get_namespace_string(scope, name.val); - let mut local_namespace = BTreeMap::new(); + let local_scope_string = get_namespace_string(ctx.scope.clone(), name.val); + + let mut local_ctx = AmlExecutionContext { + namespace: &mut BTreeMap::new(), + scope: String::new() + }; - parse_object_list(&data[2 + pkg_len_len + name.len .. 2 + pkg_len], &mut local_namespace, String::new())?; + parse_object_list(&data[2 + pkg_len_len + name.len .. 2 + pkg_len], &mut local_ctx)?; - namespace.insert(local_scope_string, AmlValue::ThermalZone(local_namespace)); + ctx.namespace.insert(local_scope_string, AmlValue::ThermalZone(local_ctx.namespace.clone())); Ok(AmlParseType { val: AmlValue::None, diff --git a/src/acpi/aml/namespace.rs b/src/acpi/aml/namespace.rs index d2ac417..54cef02 100644 --- a/src/acpi/aml/namespace.rs +++ b/src/acpi/aml/namespace.rs @@ -6,6 +6,7 @@ use collections::btree_map::BTreeMap; use core::str::FromStr; use super::namedobj::{ RegionSpace, FieldFlags, Method }; +use super::parser::AmlExecutionContext; use super::AmlError; #[derive(Debug, Clone)] diff --git a/src/acpi/aml/namespacemodifier.rs b/src/acpi/aml/namespacemodifier.rs index b04d405..35cd1a3 100644 --- a/src/acpi/aml/namespacemodifier.rs +++ b/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}; +use super::parser::{AmlParseType, ParseResult, AmlParseTypeGeneric, AmlExecutionContext}; use super::namespace::{AmlValue, ObjectReference, FieldSelector, get_namespace_string}; use super::pkglength::parse_pkg_length; use super::namestring::parse_name_string; @@ -12,10 +12,9 @@ use super::termlist::parse_term_list; use super::dataobj::parse_data_ref_obj; pub fn parse_namespace_modifier(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { parser_selector! { - data, namespace, scope.clone(), + data, ctx, parse_alias_op, parse_scope_op, parse_name_op @@ -25,17 +24,16 @@ pub fn parse_namespace_modifier(data: &[u8], } fn parse_alias_op(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { parser_opcode!(data, 0x06); - let source_name = parse_name_string(&data[1..], namespace, scope.clone())?; - let alias_name = parse_name_string(&data[1 + source_name.len..], namespace, scope.clone())?; + let source_name = parse_name_string(&data[1..], ctx)?; + let alias_name = parse_name_string(&data[1 + source_name.len..], ctx)?; - let local_scope_string = get_namespace_string(scope.clone(), source_name.val); - let local_alias_string = get_namespace_string(scope.clone(), alias_name.val); + let local_scope_string = get_namespace_string(ctx.scope.clone(), source_name.val); + let local_alias_string = get_namespace_string(ctx.scope.clone(), alias_name.val); - namespace.insert(local_scope_string, AmlValue::ObjectReference( + ctx.namespace.insert(local_scope_string, AmlValue::ObjectReference( ObjectReference::NamedObj(local_alias_string))); Ok(AmlParseType { @@ -45,16 +43,15 @@ fn parse_alias_op(data: &[u8], } fn parse_name_op(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { parser_opcode!(data, 0x08); - let name = parse_name_string(&data[1..], namespace, scope.clone())?; - let data_ref_obj = parse_data_ref_obj(&data[1 + name.len..], namespace, scope.clone())?; + let name = parse_name_string(&data[1..], ctx)?; + let data_ref_obj = parse_data_ref_obj(&data[1 + name.len..], ctx)?; - let local_scope_string = get_namespace_string(scope.clone(), name.val); + let local_scope_string = get_namespace_string(ctx.scope.clone(), name.val); - namespace.insert(local_scope_string, data_ref_obj.val); + ctx.namespace.insert(local_scope_string, data_ref_obj.val); Ok(AmlParseType { val: AmlValue::None, @@ -63,15 +60,18 @@ fn parse_name_op(data: &[u8], } fn parse_scope_op(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { parser_opcode!(data, 0x10); let (pkg_length, pkg_length_len) = parse_pkg_length(&data[1..])?; - let name = parse_name_string(&data[1 + pkg_length_len..], namespace, scope.clone())?; + let name = parse_name_string(&data[1 + pkg_length_len..], ctx)?; - let local_scope_string = get_namespace_string(scope, name.val); - parse_term_list(&data[1 + pkg_length_len + name.len..], namespace, local_scope_string)?; + let local_scope_string = get_namespace_string(ctx.scope.clone(), name.val); + let containing_scope_string = ctx.scope.clone(); + + ctx.scope = local_scope_string; + parse_term_list(&data[1 + pkg_length_len + name.len..], ctx)?; + ctx.scope = containing_scope_string; Ok(AmlParseType { val: AmlValue::None, diff --git a/src/acpi/aml/namestring.rs b/src/acpi/aml/namestring.rs index ccbdcce..e63a9b0 100644 --- a/src/acpi/aml/namestring.rs +++ b/src/acpi/aml/namestring.rs @@ -3,14 +3,13 @@ use collections::string::String; use collections::btree_map::BTreeMap; use super::AmlError; -use super::parser::{AmlParseType, ParseResult, AmlParseTypeGeneric}; +use super::parser::{AmlParseType, ParseResult, AmlParseTypeGeneric, AmlExecutionContext}; 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], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { let mut characters: Vec = vec!(); let mut starting_index: usize = 0; @@ -142,10 +141,9 @@ fn parse_multi_name_path(data: &[u8]) -> Result<(Vec, usize), AmlError> { } pub fn parse_super_name(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { parser_selector! { - data, namespace, scope.clone(), + data, ctx, parse_simple_name, parse_type6_opcode, parse_debug_obj @@ -155,8 +153,7 @@ pub fn parse_super_name(data: &[u8], } fn parse_debug_obj(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { parser_opcode_extended!(data, 0x31); Ok(AmlParseType { @@ -166,10 +163,9 @@ fn parse_debug_obj(data: &[u8], } pub fn parse_simple_name(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { parser_selector! { - data, namespace, scope.clone(), + data, ctx, parse_name_string, parse_arg_obj, parse_local_obj @@ -179,14 +175,13 @@ pub fn parse_simple_name(data: &[u8], } pub fn parse_target(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { if data[0] == 0x00 { Ok(AmlParseType { val: AmlValue::None, len: 1 as usize }) } else { - parse_super_name(data, namespace, scope.clone()) + parse_super_name(data, ctx) } } diff --git a/src/acpi/aml/parser.rs b/src/acpi/aml/parser.rs index 080a1ae..b316319 100644 --- a/src/acpi/aml/parser.rs +++ b/src/acpi/aml/parser.rs @@ -1,3 +1,6 @@ +use collections::string::String; +use collections::btree_map::BTreeMap; + use super::namespace::AmlValue; use super::AmlError; @@ -8,3 +11,8 @@ pub struct AmlParseTypeGeneric { pub val: T, pub len: usize } + +pub struct AmlExecutionContext<'a> { + pub namespace: &'a mut BTreeMap, + pub scope: String +} diff --git a/src/acpi/aml/parsermacros.rs b/src/acpi/aml/parsermacros.rs index 6b9555a..3f8cf61 100644 --- a/src/acpi/aml/parsermacros.rs +++ b/src/acpi/aml/parsermacros.rs @@ -1,15 +1,15 @@ #[macro_export] macro_rules! parser_selector { - {$data:expr, $namespace:expr, $scope:expr, $func:expr} => { - match $func($data, $namespace, $scope) { + {$data:expr, $ctx:expr, $func:expr} => { + match $func($data, $ctx) { Ok(res) => return Ok(res), Err(AmlError::AmlInvalidOpCode) => (), Err(e) => return Err(e) } }; - {$data:expr, $namespace:expr, $scope:expr, $func:expr, $($funcs:expr),+} => { - parser_selector! {$data, $namespace, $scope, $func}; - parser_selector! {$data, $namespace, $scope, $($funcs),*}; + {$data:expr, $ctx:expr, $func:expr, $($funcs:expr),+} => { + parser_selector! {$data, $ctx, $func}; + parser_selector! {$data, $ctx, $($funcs),*}; }; } diff --git a/src/acpi/aml/termlist.rs b/src/acpi/aml/termlist.rs index bc2a747..bbce0e4 100644 --- a/src/acpi/aml/termlist.rs +++ b/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}; +use super::parser::{ AmlParseType, ParseResult, AmlParseTypeGeneric, AmlExecutionContext }; use super::namespace::{AmlValue, ObjectReference, FieldSelector, get_namespace_string}; use super::namespacemodifier::parse_namespace_modifier; use super::namedobj::parse_named_obj; @@ -14,12 +14,11 @@ use super::type2opcode::parse_type2_opcode; use super::namestring::parse_name_string; pub fn parse_term_list(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { let mut current_offset: usize = 0; while current_offset < data.len() { - let res = parse_term_obj(&data[current_offset..], namespace, scope.clone())?; + let res = parse_term_obj(&data[current_offset..], ctx)?; current_offset += res.len; } @@ -30,10 +29,9 @@ pub fn parse_term_list(data: &[u8], } pub fn parse_term_arg(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { parser_selector! { - data, namespace, scope.clone(), + data, ctx, parse_local_obj, parse_data_obj, parse_arg_obj, @@ -44,12 +42,11 @@ pub fn parse_term_arg(data: &[u8], } pub fn parse_object_list(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { let mut current_offset: usize = 0; while current_offset < data.len() { - let res = parse_object(&data[current_offset..], namespace, scope.clone())?; + let res = parse_object(&data[current_offset..], ctx)?; current_offset += res.len; } @@ -60,10 +57,9 @@ pub fn parse_object_list(data: &[u8], } fn parse_object(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { parser_selector! { - data, namespace, scope.clone(), + data, ctx, parse_namespace_modifier, parse_named_obj }; @@ -72,17 +68,18 @@ fn parse_object(data: &[u8], } pub fn parse_method_invocation(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { - let name = parse_name_string(data, namespace, scope)?; + ctx: &mut AmlExecutionContext) -> ParseResult { + // TODO: Check if method exists in namespace + // TODO: If so, parse appropriate number of parameters + // TODO: If not, add deferred load to ctx + let name = parse_name_string(data, ctx)?; Err(AmlError::AmlDeferredLoad) } fn parse_term_obj(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { parser_selector! { - data, namespace, scope.clone(), + data, ctx, parse_namespace_modifier, parse_named_obj, parse_type1_opcode, diff --git a/src/acpi/aml/type1opcode.rs b/src/acpi/aml/type1opcode.rs index b32acf8..7bc9546 100644 --- a/src/acpi/aml/type1opcode.rs +++ b/src/acpi/aml/type1opcode.rs @@ -4,17 +4,16 @@ use collections::vec::Vec; use collections::btree_map::BTreeMap; use super::AmlError; -use super::parser::{AmlParseType, ParseResult}; +use super::parser::{AmlParseType, ParseResult, AmlExecutionContext}; use super::namespace::{AmlValue, ObjectReference}; use super::pkglength::parse_pkg_length; use super::termlist::{parse_term_arg, parse_term_list}; use super::namestring::{parse_name_string, parse_super_name}; pub fn parse_type1_opcode(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { parser_selector! { - data, namespace, scope.clone(), + data, ctx, parse_def_break, parse_def_breakpoint, parse_def_continue, @@ -37,8 +36,7 @@ pub fn parse_type1_opcode(data: &[u8], } fn parse_def_break(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { // TODO: Implement parser_opcode!(data, 0xA5); @@ -49,8 +47,7 @@ fn parse_def_break(data: &[u8], } fn parse_def_breakpoint(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { // TODO: Implement parser_opcode!(data, 0xCC); @@ -61,8 +58,7 @@ fn parse_def_breakpoint(data: &[u8], } fn parse_def_continue(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { // TODO: Implement parser_opcode!(data, 0x9F); @@ -73,8 +69,7 @@ fn parse_def_continue(data: &[u8], } fn parse_def_noop(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { parser_opcode!(data, 0xA3); Ok(AmlParseType { @@ -84,27 +79,25 @@ fn parse_def_noop(data: &[u8], } fn parse_def_fatal(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { parser_opcode_extended!(data, 0x32); let fatal_type = data[2]; let fatal_code: u16 = (data[3] as u16) + ((data[4] as u16) << 8); - let fatal_arg = parse_term_arg(&data[5..], namespace, scope.clone())?; + let fatal_arg = parse_term_arg(&data[5..], ctx)?; Err(AmlError::AmlFatalError(fatal_type, fatal_code, fatal_arg.val)) } fn parse_def_load(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { // 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 parser_opcode_extended!(data, 0x20); - let name = parse_name_string(&data[2..], namespace, scope.clone())?; - let ddb_handle_object = parse_super_name(&data[2 + name.len..], namespace, scope.clone())?; + let name = parse_name_string(&data[2..], ctx)?; + let ddb_handle_object = parse_super_name(&data[2 + name.len..], ctx)?; Ok(AmlParseType { val: AmlValue::None, @@ -113,13 +106,12 @@ fn parse_def_load(data: &[u8], } fn parse_def_notify(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { // TODO: This requires significantly more infrastructure from the OS itself, see 5.6.6 parser_opcode!(data, 0x86); - let object = parse_super_name(&data[1..], namespace, scope.clone())?; - let value = parse_term_arg(&data[1 + object.len..], namespace, scope.clone())?; + let object = parse_super_name(&data[1..], ctx)?; + let value = parse_term_arg(&data[1 + object.len..], ctx)?; Ok(AmlParseType { val: AmlValue::None, @@ -128,14 +120,13 @@ fn parse_def_notify(data: &[u8], } fn parse_def_release(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { // TODO: Check ownership of the mutex pointed to // TODO: FATAL if not owned // TODO: Release if it is parser_opcode_extended!(data, 0x27); - let object = parse_super_name(&data[2..], namespace, scope.clone())?; + let object = parse_super_name(&data[2..], ctx)?; Ok(AmlParseType { val: AmlValue::None, @@ -144,12 +135,11 @@ fn parse_def_release(data: &[u8], } fn parse_def_reset(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { // TODO: object (of type Event) is a semaphore. Reset the resource count to 0 parser_opcode_extended!(data, 0x26); - let object = parse_super_name(&data[2..], namespace, scope.clone())?; + let object = parse_super_name(&data[2..], ctx)?; Ok(AmlParseType { val: AmlValue::None, @@ -158,12 +148,11 @@ fn parse_def_reset(data: &[u8], } fn parse_def_signal(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { // TODO: Increment the resource count of the semaphore parser_opcode_extended!(data, 0x24); - let object = parse_super_name(&data[2..], namespace, scope.clone())?; + let object = parse_super_name(&data[2..], ctx)?; Ok(AmlParseType { val: AmlValue::None, @@ -172,12 +161,11 @@ fn parse_def_signal(data: &[u8], } fn parse_def_sleep(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { // TODO: Sleep the processor for the specified number of milliseconds (minimum) parser_opcode_extended!(data, 0x22); - let time = parse_term_arg(&data[2..], namespace, scope.clone())?; + let time = parse_term_arg(&data[2..], ctx)?; Ok(AmlParseType { val: AmlValue::None, @@ -186,12 +174,11 @@ fn parse_def_sleep(data: &[u8], } fn parse_def_stall(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { // TODO: Sleep the processor for the specified number of microseconds (minimum) parser_opcode_extended!(data, 0x21); - let time = parse_term_arg(&data[2..], namespace, scope.clone())?; + let time = parse_term_arg(&data[2..], ctx)?; Ok(AmlParseType { val: AmlValue::None, @@ -200,13 +187,12 @@ fn parse_def_stall(data: &[u8], } fn parse_def_unload(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { // TODO: remove from namespace all values added when `object` was loaded // TODO: globally synchronous (how?) parser_opcode_extended!(data, 0x2A); - let object = parse_super_name(&data[2..], namespace, scope.clone())?; + let object = parse_super_name(&data[2..], ctx)?; Ok(AmlParseType { val: AmlValue::None, @@ -215,12 +201,11 @@ fn parse_def_unload(data: &[u8], } fn parse_def_if_else(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { parser_opcode!(data, 0xA0); let (pkg_length, pkg_length_len) = parse_pkg_length(&data[1..])?; - let if_condition = parse_term_arg(&data[1 + pkg_length_len .. 1 + pkg_length], namespace, scope.clone())?; + let if_condition = parse_term_arg(&data[1 + pkg_length_len .. 1 + pkg_length], ctx)?; let (else_length, else_length_len) = if data.len() > 1 + pkg_length && data[1 + pkg_length] == 0xA1 { parse_pkg_length(&data[2 + pkg_length..])? @@ -229,11 +214,9 @@ fn parse_def_if_else(data: &[u8], }; if if_condition.val.get_as_integer()? > 0 { - parse_term_list(&data[1 + pkg_length_len + if_condition.len .. 1 + pkg_length], - namespace, scope.clone())?; + parse_term_list(&data[1 + pkg_length_len + if_condition.len .. 1 + pkg_length], ctx)?; } else if else_length > 0 { - parse_term_list(&data[2 + pkg_length + else_length_len .. 2 + pkg_length + else_length], - namespace, scope.clone())?; + parse_term_list(&data[2 + pkg_length + else_length_len .. 2 + pkg_length + else_length], ctx)?; } Ok(AmlParseType { @@ -243,19 +226,18 @@ fn parse_def_if_else(data: &[u8], } fn parse_def_while(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { parser_opcode!(data, 0xA2); let (pkg_length, pkg_length_len) = parse_pkg_length(&data[1..])?; loop { - let predicate = parse_term_arg(&data[1 + pkg_length_len..], namespace, scope.clone())?; + 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], namespace, scope.clone())?; + parse_term_list(&data[1 + pkg_length_len + predicate.len .. 1 + pkg_length], ctx)?; } Ok(AmlParseType { @@ -265,13 +247,12 @@ fn parse_def_while(data: &[u8], } fn parse_def_return(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { // TODO: Return to the calling context // TODO: We need contexts for that parser_opcode!(data, 0xA4); - let arg_object = parse_term_arg(&data[1..], namespace, scope.clone())?; + let arg_object = parse_term_arg(&data[1..], ctx)?; Ok(AmlParseType { val: AmlValue::None, diff --git a/src/acpi/aml/type2opcode.rs b/src/acpi/aml/type2opcode.rs index eef85e1..0685251 100644 --- a/src/acpi/aml/type2opcode.rs +++ b/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}; +use super::parser::{AmlParseType, ParseResult, AmlExecutionContext}; use super::namespace::{AmlValue, ObjectReference}; use super::pkglength::parse_pkg_length; use super::termlist::{parse_term_arg, parse_method_invocation}; @@ -22,10 +22,9 @@ pub enum MatchOpcode { } pub fn parse_type2_opcode(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { parser_selector! { - data, namespace, scope.clone(), + data, ctx, parse_def_increment, parse_def_acquire, parse_def_wait, @@ -82,10 +81,9 @@ pub fn parse_type2_opcode(data: &[u8], } pub fn parse_type6_opcode(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { parser_selector! { - data, namespace, scope.clone(), + data, ctx, parse_def_deref_of, parse_def_ref_of, parse_def_index, @@ -96,11 +94,10 @@ pub fn parse_type6_opcode(data: &[u8], } pub fn parse_def_object_type(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { parser_opcode!(data, 0x8E); parser_selector! { - data, namespace, scope.clone(), + data, ctx, parse_super_name, parse_def_ref_of, parse_def_deref_of, @@ -111,16 +108,14 @@ pub fn parse_def_object_type(data: &[u8], } pub fn parse_def_package(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { // TODO: Handle deferred loads in here // TODO: Truncate/extend array if necessary parser_opcode!(data, 0x12); let (pkg_length, pkg_length_len) = parse_pkg_length(&data[1..])?; let num_elements = data[1 + pkg_length_len]; - let elements = parse_package_elements_list(&data[2 + pkg_length_len .. 1 + pkg_length], - namespace, scope.clone())?; + let elements = parse_package_elements_list(&data[2 + pkg_length_len .. 1 + pkg_length], ctx)?; Ok(AmlParseType { val: elements.val, @@ -129,16 +124,15 @@ pub fn parse_def_package(data: &[u8], } pub fn parse_def_var_package(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { // TODO: Handle deferred loads in here // TODO: Truncate/extend array if necessary parser_opcode!(data, 0x13); let (pkg_length, pkg_length_len) = parse_pkg_length(&data[1..])?; - let num_elements = parse_term_arg(&data[1 + pkg_length_len .. 1 + pkg_length], namespace, scope.clone())?; + let num_elements = parse_term_arg(&data[1 + pkg_length_len .. 1 + pkg_length], ctx)?; let elements = parse_package_elements_list(&data[1 + pkg_length_len + num_elements.len .. - 1 + pkg_length], namespace, scope.clone())?; + 1 + pkg_length], ctx)?; Ok(AmlParseType { val: elements.val, @@ -147,16 +141,15 @@ pub fn parse_def_var_package(data: &[u8], } fn parse_package_elements_list(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { let mut current_offset: usize = 0; let mut elements: Vec = vec!(); while current_offset < data.len() { - let dro = if let Ok(e) = parse_data_ref_obj(&data[current_offset..], namespace, scope.clone()) { + let dro = if let Ok(e) = parse_data_ref_obj(&data[current_offset..], ctx) { e } else { - parse_name_string(&data[current_offset..], namespace, scope.clone())? + parse_name_string(&data[current_offset..], ctx)? }; elements.push(dro.val); @@ -170,13 +163,12 @@ fn parse_package_elements_list(data: &[u8], } pub fn parse_def_buffer(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { // TODO: Perform computation parser_opcode!(data, 0x11); let (pkg_length, pkg_length_len) = parse_pkg_length(&data[1..])?; - let buffer_size = parse_term_arg(&data[1 + pkg_length_len..], namespace, scope.clone())?; + let buffer_size = parse_term_arg(&data[1 + pkg_length_len..], ctx)?; let byte_list = data[1 + pkg_length_len + buffer_size.len .. 1 + pkg_length].to_vec(); Ok(AmlParseType { @@ -186,12 +178,11 @@ pub fn parse_def_buffer(data: &[u8], } fn parse_def_ref_of(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { // TODO: Perform computation parser_opcode!(data, 0x71); - let obj = parse_super_name(&data[1..], namespace, scope.clone())?; + let obj = parse_super_name(&data[1..], ctx)?; Ok(AmlParseType { val: AmlValue::Uninitialized, @@ -200,12 +191,11 @@ fn parse_def_ref_of(data: &[u8], } fn parse_def_deref_of(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { // TODO: Perform computation parser_opcode!(data, 0x83); - let obj = parse_term_arg(&data[1..], namespace, scope.clone())?; + let obj = parse_term_arg(&data[1..], ctx)?; Ok(AmlParseType { val: AmlValue::Uninitialized, @@ -214,13 +204,12 @@ fn parse_def_deref_of(data: &[u8], } fn parse_def_acquire(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { // TODO: Store the result // TODO: Perform computation parser_opcode_extended!(data, 0x23); - let obj = parse_super_name(&data[1..], namespace, scope.clone())?; + let obj = parse_super_name(&data[1..], ctx)?; let timeout = (data[2 + obj.len] as u16) + ((data[3 + obj.len] as u16) << 8); Ok(AmlParseType { @@ -230,13 +219,12 @@ fn parse_def_acquire(data: &[u8], } fn parse_def_increment(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { // TODO: Store the result // TODO: Perform computation parser_opcode!(data, 0x75); - let obj = parse_super_name(&data[1..], namespace, scope.clone())?; + let obj = parse_super_name(&data[1..], ctx)?; Ok(AmlParseType { val: AmlValue::Uninitialized, @@ -245,15 +233,14 @@ fn parse_def_increment(data: &[u8], } fn parse_def_index(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { // TODO: Store the result, if appropriate // TODO: Perform computation parser_opcode!(data, 0x88); - let obj = parse_term_arg(&data[1..], namespace, scope.clone())?; - let idx = parse_term_arg(&data[1 + obj.len..], namespace, scope.clone())?; - let target = parse_target(&data[1 + obj.len + idx.len..], namespace, scope.clone())?; + let obj = parse_term_arg(&data[1..], ctx)?; + let idx = parse_term_arg(&data[1 + obj.len..], ctx)?; + let target = parse_target(&data[1 + obj.len + idx.len..], ctx)?; Ok(AmlParseType { val: AmlValue::Uninitialized, @@ -262,12 +249,11 @@ fn parse_def_index(data: &[u8], } fn parse_def_land(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { parser_opcode!(data, 0x90); - let lhs = parse_term_arg(&data[1..], namespace, scope.clone())?; - let rhs = parse_term_arg(&data[1 + lhs.len..], namespace, scope.clone())?; + let lhs = parse_term_arg(&data[1..], ctx)?; + let rhs = parse_term_arg(&data[1 + lhs.len..], ctx)?; let result = if lhs.val.get_as_integer()? > 0 && rhs.val.get_as_integer()? > 0 { 1 } else { 0 }; @@ -278,12 +264,11 @@ fn parse_def_land(data: &[u8], } fn parse_def_lequal(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { parser_opcode!(data, 0x93); - let lhs = parse_term_arg(&data[1..], namespace, scope.clone())?; - let rhs = parse_term_arg(&data[1 + lhs.len..], namespace, scope.clone())?; + let lhs = parse_term_arg(&data[1..], ctx)?; + let rhs = parse_term_arg(&data[1 + lhs.len..], ctx)?; let result = if lhs.val.get_as_integer()? == rhs.val.get_as_integer()? { 1 } else { 0 }; @@ -294,12 +279,11 @@ fn parse_def_lequal(data: &[u8], } fn parse_def_lgreater(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { parser_opcode!(data, 0x94); - let lhs = parse_term_arg(&data[1..], namespace, scope.clone())?; - let rhs = parse_term_arg(&data[1 + lhs.len..], namespace, scope.clone())?; + let lhs = parse_term_arg(&data[1..], ctx)?; + let rhs = parse_term_arg(&data[1 + lhs.len..], ctx)?; let result = if lhs.val.get_as_integer()? > rhs.val.get_as_integer()? { 1 } else { 0 }; @@ -310,12 +294,11 @@ fn parse_def_lgreater(data: &[u8], } fn parse_def_lless(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { parser_opcode!(data, 0x95); - let lhs = parse_term_arg(&data[1..], namespace, scope.clone())?; - let rhs = parse_term_arg(&data[1 + lhs.len..], namespace, scope.clone())?; + let lhs = parse_term_arg(&data[1..], ctx)?; + let rhs = parse_term_arg(&data[1 + lhs.len..], ctx)?; let result = if lhs.val.get_as_integer()? < rhs.val.get_as_integer()? { 1 } else { 0 }; @@ -326,11 +309,10 @@ fn parse_def_lless(data: &[u8], } fn parse_def_lnot(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { parser_opcode!(data, 0x92); - let operand = parse_term_arg(&data[1..], namespace, scope.clone())?; + let operand = parse_term_arg(&data[1..], ctx)?; let result = if operand.val.get_as_integer()? == 0 { 1 } else { 0 }; Ok(AmlParseType { @@ -340,12 +322,11 @@ fn parse_def_lnot(data: &[u8], } fn parse_def_lor(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { parser_opcode!(data, 0x91); - let lhs = parse_term_arg(&data[1..], namespace, scope.clone())?; - let rhs = parse_term_arg(&data[1 + lhs.len..], namespace, scope.clone())?; + let lhs = parse_term_arg(&data[1..], ctx)?; + let rhs = parse_term_arg(&data[1 + lhs.len..], ctx)?; let result = if lhs.val.get_as_integer()? > 0 || rhs.val.get_as_integer()? > 0 { 1 } else { 0 }; @@ -356,14 +337,13 @@ fn parse_def_lor(data: &[u8], } fn parse_def_to_hex_string(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { // TODO: Compute the result // TODO: Store the result, if appropriate parser_opcode!(data, 0x98); - let operand = parse_term_arg(&data[2..], namespace, scope.clone())?; - let target = parse_target(&data[2 + operand.len..], namespace, scope.clone())?; + let operand = parse_term_arg(&data[2..], ctx)?; + let target = parse_target(&data[2 + operand.len..], ctx)?; Ok(AmlParseType { val: AmlValue::Uninitialized, @@ -372,14 +352,13 @@ fn parse_def_to_hex_string(data: &[u8], } fn parse_def_to_buffer(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { // TODO: Compute the result // TODO: Store the result, if appropriate parser_opcode!(data, 0x96); - let operand = parse_term_arg(&data[2..], namespace, scope.clone())?; - let target = parse_target(&data[2 + operand.len..], namespace, scope.clone())?; + let operand = parse_term_arg(&data[2..], ctx)?; + let target = parse_target(&data[2 + operand.len..], ctx)?; Ok(AmlParseType { val: AmlValue::Uninitialized, @@ -388,14 +367,13 @@ fn parse_def_to_buffer(data: &[u8], } fn parse_def_to_bcd(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { // TODO: Compute the result // TODO: Store the result, if appropriate parser_opcode_extended!(data, 0x29); - let operand = parse_term_arg(&data[2..], namespace, scope.clone())?; - let target = parse_target(&data[2 + operand.len..], namespace, scope.clone())?; + let operand = parse_term_arg(&data[2..], ctx)?; + let target = parse_target(&data[2 + operand.len..], ctx)?; Ok(AmlParseType { val: AmlValue::Uninitialized, @@ -404,14 +382,13 @@ fn parse_def_to_bcd(data: &[u8], } fn parse_def_to_decimal_string(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { // TODO: Compute the result // TODO: Store the result, if appropriate parser_opcode!(data, 0x97); - let operand = parse_term_arg(&data[2..], namespace, scope.clone())?; - let target = parse_target(&data[2 + operand.len..], namespace, scope.clone())?; + let operand = parse_term_arg(&data[2..], ctx)?; + let target = parse_target(&data[2 + operand.len..], ctx)?; Ok(AmlParseType { val: AmlValue::Uninitialized, @@ -420,14 +397,13 @@ fn parse_def_to_decimal_string(data: &[u8], } fn parse_def_to_integer(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { // TODO: Compute the result // TODO: Store the result, if appropriate parser_opcode!(data, 0x99); - let operand = parse_term_arg(&data[2..], namespace, scope.clone())?; - let target = parse_target(&data[2 + operand.len..], namespace, scope.clone())?; + let operand = parse_term_arg(&data[2..], ctx)?; + let target = parse_target(&data[2 + operand.len..], ctx)?; Ok(AmlParseType { val: AmlValue::Uninitialized, @@ -436,15 +412,14 @@ fn parse_def_to_integer(data: &[u8], } fn parse_def_to_string(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { // TODO: Compute the result // TODO: Store the result, if appropriate parser_opcode!(data, 0x9C); - let operand = parse_term_arg(&data[1..], namespace, scope.clone())?; - let length = parse_term_arg(&data[1 + operand.len..], namespace, scope.clone())?; - let target = parse_target(&data[1 + operand.len + length.len..], namespace, scope.clone())?; + let operand = parse_term_arg(&data[1..], ctx)?; + let length = parse_term_arg(&data[1 + operand.len..], ctx)?; + let target = parse_target(&data[1 + operand.len + length.len..], ctx)?; Ok(AmlParseType { val: AmlValue::Uninitialized, @@ -453,14 +428,13 @@ fn parse_def_to_string(data: &[u8], } fn parse_def_subtract(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { // TODO: Store the result, if appropriate parser_opcode!(data, 0x74); - let lhs = parse_term_arg(&data[1..], namespace, scope.clone())?; - let rhs = parse_term_arg(&data[1 + lhs.len..], namespace, scope.clone())?; - let target = parse_target(&data[1 + lhs.len + rhs.len..], namespace, scope.clone())?; + let lhs = parse_term_arg(&data[1..], ctx)?; + let rhs = parse_term_arg(&data[1 + lhs.len..], ctx)?; + let target = parse_target(&data[1 + lhs.len + rhs.len..], ctx)?; let result = lhs.val.get_as_integer()? - rhs.val.get_as_integer()?; @@ -471,12 +445,11 @@ fn parse_def_subtract(data: &[u8], } fn parse_def_size_of(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { // TODO: Perform the computation parser_opcode!(data, 0x87); - let name = parse_super_name(&data[1..], namespace, scope.clone())?; + let name = parse_super_name(&data[1..], ctx)?; Ok(AmlParseType { val: AmlValue::Uninitialized, @@ -485,13 +458,12 @@ fn parse_def_size_of(data: &[u8], } fn parse_def_store(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { // TODO: Perform the store parser_opcode!(data, 0x70); - let operand = parse_term_arg(&data[1..], namespace, scope.clone())?; - let target = parse_super_name(&data[1 + operand.len..], namespace, scope.clone())?; + let operand = parse_term_arg(&data[1..], ctx)?; + let target = parse_super_name(&data[1 + operand.len..], ctx)?; Ok(AmlParseType { val: AmlValue::Uninitialized, @@ -500,14 +472,13 @@ fn parse_def_store(data: &[u8], } fn parse_def_or(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { // TODO: Store the result, if appropriate parser_opcode!(data, 0x7D); - let lhs = parse_term_arg(&data[1..], namespace, scope.clone())?; - let rhs = parse_term_arg(&data[1 + lhs.len..], namespace, scope.clone())?; - let target = parse_target(&data[1 + lhs.len + rhs.len..], namespace, scope.clone())?; + let lhs = parse_term_arg(&data[1..], ctx)?; + let rhs = parse_term_arg(&data[1 + lhs.len..], ctx)?; + let target = parse_target(&data[1 + lhs.len + rhs.len..], ctx)?; let result = lhs.val.get_as_integer()? | rhs.val.get_as_integer()?; @@ -518,14 +489,13 @@ fn parse_def_or(data: &[u8], } fn parse_def_shift_left(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { // TODO: Store the result, if appropriate parser_opcode!(data, 0x79); - let lhs = parse_term_arg(&data[1..], namespace, scope.clone())?; - let rhs = parse_term_arg(&data[1 + lhs.len..], namespace, scope.clone())?; - let target = parse_target(&data[1 + lhs.len + rhs.len..], namespace, scope.clone())?; + let lhs = parse_term_arg(&data[1..], ctx)?; + let rhs = parse_term_arg(&data[1 + lhs.len..], ctx)?; + let target = parse_target(&data[1 + lhs.len + rhs.len..], ctx)?; let result = lhs.val.get_as_integer()? >> rhs.val.get_as_integer()?; @@ -536,14 +506,13 @@ fn parse_def_shift_left(data: &[u8], } fn parse_def_shift_right(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { // TODO: Store the result, if appropriate parser_opcode!(data, 0x7A); - let lhs = parse_term_arg(&data[1..], namespace, scope.clone())?; - let rhs = parse_term_arg(&data[1 + lhs.len..], namespace, scope.clone())?; - let target = parse_target(&data[1 + lhs.len + rhs.len..], namespace, scope.clone())?; + let lhs = parse_term_arg(&data[1..], ctx)?; + let rhs = parse_term_arg(&data[1 + lhs.len..], ctx)?; + let target = parse_target(&data[1 + lhs.len + rhs.len..], ctx)?; let result = lhs.val.get_as_integer()? << rhs.val.get_as_integer()?; @@ -554,14 +523,13 @@ fn parse_def_shift_right(data: &[u8], } fn parse_def_add(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { // TODO: Store the result, if appropriate parser_opcode!(data, 0x72); - let lhs = parse_term_arg(&data[1..], namespace, scope.clone())?; - let rhs = parse_term_arg(&data[1 + lhs.len..], namespace, scope.clone())?; - let target = parse_target(&data[1 + lhs.len + rhs.len..], namespace, scope.clone())?; + let lhs = parse_term_arg(&data[1..], ctx)?; + let rhs = parse_term_arg(&data[1 + lhs.len..], ctx)?; + let target = parse_target(&data[1 + lhs.len + rhs.len..], ctx)?; let result = lhs.val.get_as_integer()? + rhs.val.get_as_integer()?; @@ -572,14 +540,13 @@ fn parse_def_add(data: &[u8], } fn parse_def_and(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { // TODO: Store the result, if appropriate parser_opcode!(data, 0x7B); - let lhs = parse_term_arg(&data[1..], namespace, scope.clone())?; - let rhs = parse_term_arg(&data[1 + lhs.len..], namespace, scope.clone())?; - let target = parse_target(&data[1 + lhs.len + rhs.len..], namespace, scope.clone())?; + let lhs = parse_term_arg(&data[1..], ctx)?; + let rhs = parse_term_arg(&data[1 + lhs.len..], ctx)?; + let target = parse_target(&data[1 + lhs.len + rhs.len..], ctx)?; let result = lhs.val.get_as_integer()? & rhs.val.get_as_integer()?; @@ -590,14 +557,13 @@ fn parse_def_and(data: &[u8], } fn parse_def_xor(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { // TODO: Store the result, if appropriate parser_opcode!(data, 0x7F); - let lhs = parse_term_arg(&data[1..], namespace, scope.clone())?; - let rhs = parse_term_arg(&data[1 + lhs.len..], namespace, scope.clone())?; - let target = parse_target(&data[1 + lhs.len + rhs.len..], namespace, scope.clone())?; + let lhs = parse_term_arg(&data[1..], ctx)?; + let rhs = parse_term_arg(&data[1 + lhs.len..], ctx)?; + let target = parse_target(&data[1 + lhs.len + rhs.len..], ctx)?; let result = lhs.val.get_as_integer()? ^ rhs.val.get_as_integer()?; @@ -608,15 +574,14 @@ fn parse_def_xor(data: &[u8], } fn parse_def_concat_res(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { // TODO: Compute the result // TODO: Store the result, if appropriate parser_opcode!(data, 0x84); - let lhs = parse_term_arg(&data[1..], namespace, scope.clone())?; - let rhs = parse_term_arg(&data[1 + lhs.len..], namespace, scope.clone())?; - let target = parse_target(&data[1 + lhs.len + rhs.len..], namespace, scope.clone())?; + let lhs = parse_term_arg(&data[1..], ctx)?; + let rhs = parse_term_arg(&data[1 + lhs.len..], ctx)?; + let target = parse_target(&data[1 + lhs.len + rhs.len..], ctx)?; Ok(AmlParseType { val: AmlValue::Uninitialized, @@ -625,13 +590,12 @@ fn parse_def_concat_res(data: &[u8], } fn parse_def_wait(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { // TODO: Compute the result parser_opcode_extended!(data, 0x25); - let event_object = parse_super_name(&data[2..], namespace, scope.clone())?; - let operand = parse_term_arg(&data[2 + event_object.len..], namespace, scope.clone())?; + let event_object = parse_super_name(&data[2..], ctx)?; + let operand = parse_term_arg(&data[2 + event_object.len..], ctx)?; Ok(AmlParseType { val: AmlValue::Uninitialized, @@ -640,14 +604,13 @@ fn parse_def_wait(data: &[u8], } fn parse_def_cond_ref_of(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { // TODO: Compute the result // TODO: Store the result parser_opcode_extended!(data, 0x12); - let operand = parse_super_name(&data[2..], namespace, scope.clone())?; - let target = parse_target(&data[2 + operand.len..], namespace, scope.clone())?; + let operand = parse_super_name(&data[2..], ctx)?; + let target = parse_target(&data[2 + operand.len..], ctx)?; Ok(AmlParseType { val: AmlValue::Uninitialized, @@ -656,14 +619,13 @@ fn parse_def_cond_ref_of(data: &[u8], } fn parse_def_copy_object(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { // TODO: Compute the result // TODO: Store the result parser_opcode!(data, 0x9D); - let source = parse_term_arg(&data[1..], namespace, scope.clone())?; - let destination = parse_simple_name(&data[1 + source.len..], namespace, scope.clone())?; + let source = parse_term_arg(&data[1..], ctx)?; + let destination = parse_simple_name(&data[1 + source.len..], ctx)?; Ok(AmlParseType { val: AmlValue::Uninitialized, @@ -672,15 +634,14 @@ fn parse_def_copy_object(data: &[u8], } fn parse_def_concat(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { // TODO: Compute the result // TODO: Store the result parser_opcode!(data, 0x73); - let lhs = parse_term_arg(&data[1..], namespace, scope.clone())?; - let rhs = parse_term_arg(&data[1 + lhs.len..], namespace, scope.clone())?; - let target = parse_target(&data[1 + lhs.len + rhs.len..], namespace, scope.clone())?; + let lhs = parse_term_arg(&data[1..], ctx)?; + let rhs = parse_term_arg(&data[1 + lhs.len..], ctx)?; + let target = parse_target(&data[1 + lhs.len + rhs.len..], ctx)?; Ok(AmlParseType { val: AmlValue::Uninitialized, @@ -689,13 +650,12 @@ fn parse_def_concat(data: &[u8], } fn parse_def_decrement(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { // TODO: Compute the result // TODO: Store the result parser_opcode!(data, 0x76); - let target = parse_super_name(&data[1..], namespace, scope.clone())?; + let target = parse_super_name(&data[1..], ctx)?; Ok(AmlParseType { val: AmlValue::Uninitialized, @@ -704,16 +664,15 @@ fn parse_def_decrement(data: &[u8], } fn parse_def_divide(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { // TODO: Compute the result // TODO: Store the result, if appropriate parser_opcode!(data, 0x78); - let lhs = parse_term_arg(&data[1..], namespace, scope.clone())?; - let rhs = parse_term_arg(&data[1 + lhs.len..], namespace, scope.clone())?; - let target_remainder = parse_target(&data[1 + lhs.len + rhs.len..], namespace, scope.clone())?; - let target_quotient = parse_target(&data[1 + lhs.len + rhs.len + target_remainder.len..], namespace, scope.clone())?; + let lhs = parse_term_arg(&data[1..], ctx)?; + let rhs = parse_term_arg(&data[1 + lhs.len..], ctx)?; + let target_remainder = parse_target(&data[1 + lhs.len + rhs.len..], ctx)?; + let target_quotient = parse_target(&data[1 + lhs.len + rhs.len + target_remainder.len..], ctx)?; Ok(AmlParseType { val: AmlValue::Uninitialized, @@ -722,14 +681,13 @@ fn parse_def_divide(data: &[u8], } fn parse_def_find_set_left_bit(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { // TODO: Compute the result // TODO: Store the result, if appropriate parser_opcode!(data, 0x81); - let operand = parse_term_arg(&data[2..], namespace, scope.clone())?; - let target = parse_target(&data[2 + operand.len..], namespace, scope.clone())?; + let operand = parse_term_arg(&data[2..], ctx)?; + let target = parse_target(&data[2 + operand.len..], ctx)?; Ok(AmlParseType { val: AmlValue::Uninitialized, @@ -738,14 +696,13 @@ fn parse_def_find_set_left_bit(data: &[u8], } fn parse_def_find_set_right_bit(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { // TODO: Compute the result // TODO: Store the result, if appropriate parser_opcode!(data, 0x82); - let operand = parse_term_arg(&data[2..], namespace, scope.clone())?; - let target = parse_target(&data[2 + operand.len..], namespace, scope.clone())?; + let operand = parse_term_arg(&data[2..], ctx)?; + let target = parse_target(&data[2 + operand.len..], ctx)?; Ok(AmlParseType { val: AmlValue::Uninitialized, @@ -754,19 +711,18 @@ fn parse_def_find_set_right_bit(data: &[u8], } fn parse_def_load_table(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { // TODO: Compute the result // TODO: Store the result, if appropriate // TODO: Clean up parser_opcode_extended!(data, 0x1F); - let signature = parse_term_arg(&data[2..], namespace, scope.clone())?; - let oem_id = parse_term_arg(&data[2 + signature.len..], namespace, scope.clone())?; - let oem_table_id = parse_term_arg(&data[2 + signature.len + oem_id.len..], namespace, scope.clone())?; - let root_path = parse_term_arg(&data[2 + signature.len + oem_id.len + oem_table_id.len..], namespace, scope.clone())?; - let parameter_path = parse_term_arg(&data[2 + signature.len + oem_id.len + oem_table_id.len + root_path.len..], namespace, scope.clone())?; - let parameter_data = parse_term_arg(&data[2 + signature.len + oem_id.len + oem_table_id.len + root_path.len + parameter_path.len..], namespace, scope.clone())?; + let signature = parse_term_arg(&data[2..], ctx)?; + let oem_id = parse_term_arg(&data[2 + signature.len..], ctx)?; + let oem_table_id = parse_term_arg(&data[2 + signature.len + oem_id.len..], ctx)?; + let root_path = parse_term_arg(&data[2 + signature.len + oem_id.len + oem_table_id.len..], ctx)?; + let parameter_path = parse_term_arg(&data[2 + signature.len + oem_id.len + oem_table_id.len + root_path.len..], ctx)?; + let parameter_data = parse_term_arg(&data[2 + signature.len + oem_id.len + oem_table_id.len + root_path.len + parameter_path.len..], ctx)?; Ok(AmlParseType { val: AmlValue::Uninitialized, @@ -775,14 +731,13 @@ fn parse_def_load_table(data: &[u8], } fn parse_def_match(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { // TODO: Compute the result // TODO: Store the result, if appropriate // TODO: Clean up match blocks parser_opcode!(data, 0x28); - let search_pkg = parse_term_arg(&data[1..], namespace, scope.clone())?; + let search_pkg = parse_term_arg(&data[1..], ctx)?; let first_operation = match data[1 + search_pkg.len] { 0 => MatchOpcode::MTR, @@ -793,7 +748,7 @@ fn parse_def_match(data: &[u8], 5 => MatchOpcode::MGT, _ => return Err(AmlError::AmlParseError("DefMatch - Invalid Opcode")) }; - let first_operand = parse_term_arg(&data[2 + search_pkg.len..], namespace, scope.clone())?; + let first_operand = parse_term_arg(&data[2 + search_pkg.len..], ctx)?; let second_operation = match data[2 + search_pkg.len + first_operand.len] { 0 => MatchOpcode::MTR, @@ -804,9 +759,9 @@ fn parse_def_match(data: &[u8], 5 => MatchOpcode::MGT, _ => return Err(AmlError::AmlParseError("DefMatch - Invalid Opcode")) }; - let second_operand = parse_term_arg(&data[3 + search_pkg.len + first_operand.len..], namespace, scope.clone())?; + let second_operand = parse_term_arg(&data[3 + search_pkg.len + first_operand.len..], ctx)?; - let start_index = parse_term_arg(&data[3 + search_pkg.len + first_operand.len + second_operand.len..], namespace, scope.clone())?; + let start_index = parse_term_arg(&data[3 + search_pkg.len + first_operand.len + second_operand.len..], ctx)?; Ok(AmlParseType { val: AmlValue::Uninitialized, @@ -815,14 +770,13 @@ fn parse_def_match(data: &[u8], } fn parse_def_from_bcd(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { // TODO: Store the result, if appropriate // TODO: Clean up match block parser_opcode_extended!(data, 0x28); - let operand = parse_term_arg(&data[2..], namespace, scope.clone())?; - let target = parse_target(&data[2 + operand.len..], namespace, scope.clone())?; + let operand = parse_term_arg(&data[2..], ctx)?; + let target = parse_target(&data[2 + operand.len..], ctx)?; let result = match target.val.get_as_integer() { Ok(i) => { @@ -851,16 +805,15 @@ fn parse_def_from_bcd(data: &[u8], } fn parse_def_mid(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { // TODO: Compute the result // TODO: Store the result, if appropriate parser_opcode!(data, 0x9E); - let source = parse_term_arg(&data[1..], namespace, scope.clone())?; - let index = parse_term_arg(&data[1 + source.len..], namespace, scope.clone())?; - let length = parse_term_arg(&data[1 + source.len + index.len..], namespace, scope.clone())?; - let target = parse_target(&data[1 + source.len + index.len + length.len..], namespace, scope.clone())?; + let source = parse_term_arg(&data[1..], ctx)?; + let index = parse_term_arg(&data[1 + source.len..], ctx)?; + let length = parse_term_arg(&data[1 + source.len + index.len..], ctx)?; + let target = parse_target(&data[1 + source.len + index.len + length.len..], ctx)?; Ok(AmlParseType { val: AmlValue::Uninitialized, @@ -869,15 +822,14 @@ fn parse_def_mid(data: &[u8], } fn parse_def_mod(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { // TODO: Store the result, if appropriate // TODO: Fatal exception on rhs == 0 parser_opcode!(data, 0x85); - let lhs = parse_term_arg(&data[1..], namespace, scope.clone())?; - let rhs = parse_term_arg(&data[1 + lhs.len..], namespace, scope.clone())?; - let target = parse_target(&data[1 + lhs.len + rhs.len..], namespace, scope.clone())?; + let lhs = parse_term_arg(&data[1..], ctx)?; + let rhs = parse_term_arg(&data[1 + lhs.len..], ctx)?; + let target = parse_target(&data[1 + lhs.len + rhs.len..], ctx)?; let result = lhs.val.get_as_integer()? % rhs.val.get_as_integer()?; @@ -888,15 +840,14 @@ fn parse_def_mod(data: &[u8], } fn parse_def_multiply(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { // TODO: Store the result, if appropriate // TODO: Handle overflow parser_opcode!(data, 0x77); - let lhs = parse_term_arg(&data[1..], namespace, scope.clone())?; - let rhs = parse_term_arg(&data[1 + lhs.len..], namespace, scope.clone())?; - let target = parse_target(&data[1 + lhs.len + rhs.len..], namespace, scope.clone())?; + let lhs = parse_term_arg(&data[1..], ctx)?; + let rhs = parse_term_arg(&data[1 + lhs.len..], ctx)?; + let target = parse_target(&data[1 + lhs.len + rhs.len..], ctx)?; let result = lhs.val.get_as_integer()? * rhs.val.get_as_integer()?; @@ -907,14 +858,13 @@ fn parse_def_multiply(data: &[u8], } fn parse_def_nand(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { // TODO: Store the result, if appropriate parser_opcode!(data, 0x7C); - let lhs = parse_term_arg(&data[1..], namespace, scope.clone())?; - let rhs = parse_term_arg(&data[1 + lhs.len..], namespace, scope.clone())?; - let target = parse_target(&data[1 + lhs.len + rhs.len..], namespace, scope.clone())?; + let lhs = parse_term_arg(&data[1..], ctx)?; + let rhs = parse_term_arg(&data[1 + lhs.len..], ctx)?; + let target = parse_target(&data[1 + lhs.len + rhs.len..], ctx)?; let result = !(lhs.val.get_as_integer()? & rhs.val.get_as_integer()?); @@ -925,14 +875,13 @@ fn parse_def_nand(data: &[u8], } fn parse_def_nor(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { // TODO: Store the result, if appropriate parser_opcode!(data, 0x7E); - let lhs = parse_term_arg(&data[1..], namespace, scope.clone())?; - let rhs = parse_term_arg(&data[1 + lhs.len..], namespace, scope.clone())?; - let target = parse_target(&data[1 + lhs.len + rhs.len..], namespace, scope.clone())?; + let lhs = parse_term_arg(&data[1..], ctx)?; + let rhs = parse_term_arg(&data[1 + lhs.len..], ctx)?; + let target = parse_target(&data[1 + lhs.len + rhs.len..], ctx)?; let result = !(lhs.val.get_as_integer()? | rhs.val.get_as_integer()?); @@ -943,13 +892,12 @@ fn parse_def_nor(data: &[u8], } fn parse_def_not(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { // TODO: Store the result, if appropriate parser_opcode!(data, 0x80); - let operand = parse_term_arg(&data[1..], namespace, scope.clone())?; - let target = parse_target(&data[1 + operand.len..], namespace, scope.clone())?; + let operand = parse_term_arg(&data[1..], ctx)?; + let target = parse_target(&data[1 + operand.len..], ctx)?; let result = !operand.val.get_as_integer()?; @@ -960,8 +908,7 @@ fn parse_def_not(data: &[u8], } fn parse_def_timer(data: &[u8], - namespace: &mut BTreeMap, - scope: String) -> ParseResult { + ctx: &mut AmlExecutionContext) -> ParseResult { // TODO: Read from the hardware timer, and split into 100ns intervals parser_opcode_extended!(data, 0x33);