Fixed number of bugs

src/acpi/aml/dataobj.rs

@@ -125,11 +125,11 @@ fn parse_computational_data(data: &[u8],
         },
         0x00 => Ok(AmlParseType {
             val: AmlValue::IntegerConstant(0 as u64),
-            len: 9 as usize
+            len: 1 as usize
         }),
         0x01 => Ok(AmlParseType {
             val: AmlValue::IntegerConstant(1 as u64),
-            len: 9 as usize
+            len: 1 as usize
         }),
         0x5B => if data[1] == 0x30 {
             Ok(AmlParseType {
@@ -141,7 +141,7 @@ fn parse_computational_data(data: &[u8],
         },
         0xFF => Ok(AmlParseType {
             val: AmlValue::IntegerConstant(0xFFFFFFFFFFFFFFFF),
-            len: 9 as usize
+            len: 1 as usize
         }),
         _ => parse_def_buffer(data, ctx)
     }

src/acpi/aml/mod.rs

@@ -41,7 +41,7 @@ pub fn parse_aml_table(sdt: &'static Sdt) -> Result<BTreeMap<String, AmlValue>,
     let data = sdt.data();
     let mut ctx = AmlExecutionContext::new(String::from_str("\\").unwrap());
     
-    let term_list = parse_term_list(data, &mut ctx)?;
+    parse_term_list(data, &mut ctx)?;
 
     Ok(ctx.namespace.clone())
 }

src/acpi/aml/namedobj.rs

@@ -474,10 +474,13 @@ fn parse_field_list(data: &[u8],
                     selector: FieldSelector,
                     flags: &mut FieldFlags) -> ParseResult {
     let mut current_offset: usize = 0;
+    let mut field_offset: usize = 0;
     let mut connection = AmlValue::Uninitialized;
 
     while current_offset < data.len() {
-        parse_field_element(&data[current_offset..], ctx, selector.clone(), &mut connection, flags, &mut current_offset)?;
+        let res = parse_field_element(&data[current_offset..], ctx, selector.clone(), &mut connection, flags, &mut field_offset)?;
+
+        current_offset += res.len;
     }
 
     Ok(AmlParseType {
@@ -503,6 +506,7 @@ fn parse_field_element(data: &[u8],
             length: field.val.length
         });
 
+        *offset += field.val.length;
         field.len
     } else if let Ok(field) = parse_reserved_field(data, ctx) {
         *offset += field.val;

src/acpi/aml/namespace.rs

@@ -129,6 +129,10 @@ pub fn get_namespace_string(current: String, modifier_v: AmlValue) -> String {
     }
 
     let mut namespace = current.clone();
-    namespace.push('.');
+
+    if !namespace.ends_with("\\") {
+        namespace.push('.');
+    }
+    
     namespace + &modifier
 }

src/acpi/aml/namespacemodifier.rs

@@ -66,13 +66,13 @@ fn parse_scope_op(data: &[u8],
     let (pkg_length, pkg_length_len) = parse_pkg_length(&data[1..])?;
     let name = parse_name_string(&data[1 + pkg_length_len..], ctx)?;
     
-    let local_scope_string = get_namespace_string(ctx.scope.clone(), name.val);
+    let local_scope_string = get_namespace_string(ctx.scope.clone(), name.val.clone());
     let containing_scope_string = ctx.scope.clone();
     
     ctx.scope = local_scope_string;
-    parse_term_list(&data[1 + pkg_length_len + name.len..], ctx)?;
+    parse_term_list(&data[1 + pkg_length_len + name.len .. 1 + pkg_length], ctx)?;
     ctx.scope = containing_scope_string;
-    
+
     Ok(AmlParseType {
         val: AmlValue::None,
         len: 1 + pkg_length

src/acpi/aml/parsermacros.rs

@@ -4,7 +4,10 @@ macro_rules! parser_selector {
         match $func($data, $ctx) {
             Ok(res) => return Ok(res),
             Err(AmlError::AmlInvalidOpCode) => (),
-            Err(e) => return Err(e)
+            Err(e) => {
+//                println!("This doesn't work for some reason");
+                return Err(e);
+            }
         }
     };
     {$data:expr, $ctx:expr, $func:expr, $($funcs:expr),+} => {
@@ -13,6 +16,7 @@ macro_rules! parser_selector {
     };
 }
 
+#[macro_export]
 macro_rules! parser_selector_simple {
     {$data:expr, $func:expr} => {
         match $func($data) {
@@ -27,21 +31,6 @@ macro_rules! parser_selector_simple {
     };
 }
 
-#[macro_export]
-macro_rules! parser_wrap {
-    ($wrap:expr, $func:expr) => {
-        |data, namespace, scope| { 
-            match $func(data) {
-                Ok(res) => Ok(AmlParseTypeGeneric {
-                    val: $wrap(res.val),
-                    len: res.len
-                }),
-                Err(e) => Err(e)
-            }
-        }
-    };
-}
-
 #[macro_export]
 macro_rules! parser_opcode {
     ($data:expr, $opcode:expr) => {
@@ -64,14 +53,3 @@ macro_rules! parser_opcode_extended {
         }
     };
 }
-
-#[macro_export]
-macro_rules! parser_verify_value {
-    ($val:expr) => {
-        match $val.val {
-            Some(s) => s,
-            None => return Err(AmlError::AmlValueError)
-        }
-    };
-}
-

src/acpi/aml/termlist.rs

@@ -73,6 +73,7 @@ pub fn parse_method_invocation(data: &[u8],
     // 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)
 }
 

src/acpi/aml/type2opcode.rs

@@ -149,7 +149,11 @@ fn parse_package_elements_list(data: &[u8],
         let dro = if let Ok(e) = parse_data_ref_obj(&data[current_offset..], ctx) {
             e
         } else {
-            parse_name_string(&data[current_offset..], ctx)?
+            let d = parse_name_string(&data[current_offset..], ctx)?;
+            AmlParseType {
+                val: AmlValue::ObjectReference(ObjectReference::NamedObj(d.val.get_as_string()?)),
+                len: d.len
+            }
         };
 
         elements.push(dro.val);

src/stop.rs

@@ -14,6 +14,7 @@ pub unsafe extern fn kstop() -> ! {
             if let Some(ref namespace) = acpi.namespace {
                 if let Some(s) = namespace.get("\\_S5") {
                     if let Ok(p) = s.get_as_package() {
+                        println!("{:?}", p);
                         let slp_typa = p[0].get_as_integer().expect("SLP_TYPa is not an integer");
                         let slp_typb = p[1].get_as_integer().expect("SLP_TYPb is not an integer");