From 49824860715c16f3f31c221a54d1ee210eef5595 Mon Sep 17 00:00:00 2001
From: Gabriel Smith <ga29smith@gmail.com>
Date: Sun, 7 May 2017 16:13:33 -0400
Subject: [PATCH] Fix two issues with bounds creation

The first issue came about when a DTS include was at the very start of a bound. Due to old logic that hadn't been thought through after the change to bounds this did not create a zero length bound before the include which is needed to be able to figure out the include tree later on.

The second issue was that new CPP bounds sometimes did not have the proper length at creation due to only knowing of the slice of input before a DTS include. The fix just passes in the length of the remaining section. This length will be trimmed by the following split from the DTS include, but ensures that the proper remainder is left after splitting.
---
 device_tree_source/src/include.rs | 33 +++++++++++++++----------------
 1 file changed, 16 insertions(+), 17 deletions(-)

diff --git a/device_tree_source/src/include.rs b/device_tree_source/src/include.rs
index 938e9ae..6950770 100644
--- a/device_tree_source/src/include.rs
+++ b/device_tree_source/src/include.rs
@@ -162,8 +162,8 @@ impl IncludeBounds {
         // println!("split s: {} e: {} off: {}", start, end, offset);
 
         for b in bounds.iter_mut() {
-            // println!("g_start: {} g_end: {}", b.global_start, b.global_end());
-            if b.start() < start && b.end() >= start {
+            // println!("b.start: {} b.end: {} b.len: {}", b.start(), b.end(), b.len());
+            if b.start() <= start && b.end() >= start {
                 // global_start -- start -- global_end
                 let remainder = b.end() - start;
 
@@ -178,15 +178,6 @@ impl IncludeBounds {
                 });
 
                 b.len = start - b.start();
-            } else if b.start() == start {
-                // split is at begining of the bound
-                // offset the start
-                {
-                    let offset = end - start;
-                    b.global_start += offset;
-                }
-                // shrink the len by the offset
-                b.len -= offset;
             }
         }
 
@@ -337,17 +328,22 @@ named!(find_linemarker<(&[u8], Linemarker)>, do_parse!(
     (pre, marker)
 ));
 
-fn parse_linemarkers(buf: &[u8], bounds: &mut Vec<IncludeBounds>, global_offset: usize)
+fn parse_linemarkers(buf: &[u8],
+                     bounds: &mut Vec<IncludeBounds>,
+                     global_offset: usize,
+                     post_len: usize)
                      -> Result<(), IncludeError> {
     let end_offset = global_offset + buf.len();
-    // println!("{}", str::from_utf8(buf).unwrap());
+    // println!("{}", String::from_utf8_lossy(buf));
     let mut buf = buf;
     // println!("parsing linemarkers");
     while let IResult::Done(rem, (pre, marker)) = find_linemarker(buf) {
-        // println!("{}", str::from_utf8(line).unwrap());
         // println!("{:?}", marker);
         // println!("pre.len() {}", pre.len());
+        // println!("rem.len() {}", rem.len());
+        // println!("post_len {}", post_len);
 
+        // println!("{:#?}", bounds);
         // double check that last bound was from a linemarker
         match bounds.last_mut() {
             Some(ref mut bound) if bound.method == IncludeMethod::CPP => { bound.len = pre.len() }
@@ -364,7 +360,7 @@ fn parse_linemarkers(buf: &[u8], bounds: &mut Vec<IncludeBounds>, global_offset:
                 Ok(f) => line_to_byte_offset(f.bytes().filter_map(|e| e.ok()), marker.child_line)?,
                 Err(_) => 0,
             },
-            len: rem.len(),
+            len: rem.len() + post_len,
             method: IncludeMethod::CPP,
         };
 
@@ -435,6 +431,9 @@ pub fn include_files<P: AsRef<Path>>(path: P) -> Result<(Vec<u8>, Vec<IncludeBou
         let mut string_buffer = String::new();
         file.read_to_string(&mut string_buffer)?;
 
+        // println!("{}", string_buffer);
+        // println!();
+
         let mut buf = string_buffer.as_bytes();
 
         named!(first_linemarker<(&[u8], Linemarker)>,
@@ -488,7 +487,7 @@ pub fn include_files<P: AsRef<Path>>(path: P) -> Result<(Vec<u8>, Vec<IncludeBou
         bounds.push(start_bound);
 
         while let Some((pre, included_path, rem)) = find_include(&buf[..]) {
-            parse_linemarkers(pre, &mut bounds, buffer.len())?;
+            parse_linemarkers(pre, &mut bounds, buffer.len(), buf.len() - pre.len())?;
             buffer.extend_from_slice(pre);
 
             let offset = pre.len();
@@ -522,7 +521,7 @@ pub fn include_files<P: AsRef<Path>>(path: P) -> Result<(Vec<u8>, Vec<IncludeBou
         }
 
         // no more includes, just add the rest and return
-        parse_linemarkers(buf, &mut bounds, buffer.len())?;
+        parse_linemarkers(buf, &mut bounds, buffer.len(), 0)?;
         buffer.extend(buf);
 
         Ok((buffer, bounds))