Jika/redox-kernel
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Added a context manager

Browse Source
This commit is contained in:
Connor Wood
2017-07-03 10:31:01 +01:00
parent 6c74a02382
commit 7527915027
11 changed files with 425 additions and 512 deletions
Download Patch File Download Diff File Expand all files Collapse all files

27
src/acpi/aml/dataobj.rs
View File

@@ -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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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)
}
}

15
src/acpi/aml/mod.rs
View File

@@ -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<BTreeMap<String, AmlValue>, 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 {

294
src/acpi/aml/namedobj.rs
View File

@@ -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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
scope: String) -> Result<AmlParseTypeGeneric<NamedField>, AmlError> {
ctx: &mut AmlExecutionContext) -> Result<AmlParseTypeGeneric<NamedField>, 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<String, AmlValue>,
scope: String) -> Result<AmlParseTypeGeneric<usize>, AmlError> {
ctx: &mut AmlExecutionContext) -> Result<AmlParseTypeGeneric<usize>, 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<String, AmlValue>,
scope: String) -> Result<AmlParseTypeGeneric<AccessField>, AmlError> {
ctx: &mut AmlExecutionContext) -> Result<AmlParseTypeGeneric<AccessField>, 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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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,

1
src/acpi/aml/namespace.rs
View File

@@ -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)]

44
src/acpi/aml/namespacemodifier.rs
View File

@@ -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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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,

23
src/acpi/aml/namestring.rs
View File

@@ -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<String, AmlValue>,
scope: String) -> ParseResult {
ctx: &mut AmlExecutionContext) -> ParseResult {
let mut characters: Vec<u8> = vec!();
let mut starting_index: usize = 0;
@@ -142,10 +141,9 @@ fn parse_multi_name_path(data: &[u8]) -> Result<(Vec<u8>, usize), AmlError> {
}
pub fn parse_super_name(data: &[u8],
namespace: &mut BTreeMap<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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)
}
}

8
src/acpi/aml/parser.rs
View File

@@ -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<T> {
pub val: T,
pub len: usize
}
pub struct AmlExecutionContext<'a> {
pub namespace: &'a mut BTreeMap<String, AmlValue>,
pub scope: String
}

10
src/acpi/aml/parsermacros.rs
View File

@@ -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),*};
};
}

35
src/acpi/aml/termlist.rs
View File

@@ -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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
scope: String) -> ParseResult {
ctx: &mut AmlExecutionContext) -> ParseResult {
parser_selector! {
data, namespace, scope.clone(),
data, ctx,
parse_namespace_modifier,
parse_named_obj,
parse_type1_opcode,

91
src/acpi/aml/type1opcode.rs
View File

@@ -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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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,

389
src/acpi/aml/type2opcode.rs
View File

@@ -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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
scope: String) -> ParseResult {
ctx: &mut AmlExecutionContext) -> ParseResult {
let mut current_offset: usize = 0;
let mut elements: Vec<AmlValue> = 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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
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<String, AmlValue>,
scope: String) -> ParseResult {
ctx: &mut AmlExecutionContext) -> ParseResult {
// TODO: Read from the hardware timer, and split into 100ns intervals
parser_opcode_extended!(data, 0x33);