xc2bit: Miscellaneous refactoring

ArcaneNibble · ArcaneNibble · commit 02d2aaae19c0 · 2017-06-24T00:53:06.000-07:00
diff --git a/src/xc2bit/src/bitstream.rs b/src/xc2bit/src/bitstream.rs
@@ -1327,7 +1327,7 @@ impl XC2BitstreamBits {
 }
 
 /// Common logic for reading bitstreams on "small" devices
-pub fn read_bitstream_logical_common_small(fuses: &[bool], device: XC2Device,
+fn read_bitstream_logical_common_small(fuses: &[bool], device: XC2Device,
     fb: &mut [XC2BitstreamFB], iobs: &mut [XC2MCSmallIOB]) -> Result<(), XC2BitError> {
 
     for i in 0..fb.len() {
@@ -1352,7 +1352,7 @@ pub fn read_bitstream_logical_common_small(fuses: &[bool], device: XC2Device,
 }
 
 /// Common logic for reading bitstreams on "large" devices
-pub fn read_bitstream_logical_common_large(fuses: &[bool], device: XC2Device,
+fn read_bitstream_logical_common_large(fuses: &[bool], device: XC2Device,
     fb: &mut [XC2BitstreamFB], iobs: &mut [XC2MCLargeIOB]) -> Result<(), XC2BitError> {
 
     for i in 0..fb.len() {
@@ -1382,7 +1382,7 @@ pub fn read_bitstream_logical_common_large(fuses: &[bool], device: XC2Device,
     Ok(())
 }
 /// Internal function for parsing an XC2C32 bitstream
-pub fn read_32_bitstream_logical(fuses: &[bool]) -> Result<XC2BitstreamBits, XC2BitError> {
+fn read_32_bitstream_logical(fuses: &[bool]) -> Result<XC2BitstreamBits, XC2BitError> {
     let mut fb = [XC2BitstreamFB::default(); 2];
     let mut iobs = [XC2MCSmallIOB::default(); 32];
     
@@ -1403,7 +1403,7 @@ pub fn read_32_bitstream_logical(fuses: &[bool]) -> Result<XC2BitstreamBits, XC2
 }
 
 /// Internal function for parsing an XC2C32A bitstream
-pub fn read_32a_bitstream_logical(fuses: &[bool]) -> Result<XC2BitstreamBits, XC2BitError> {
+fn read_32a_bitstream_logical(fuses: &[bool]) -> Result<XC2BitstreamBits, XC2BitError> {
     let mut fb = [XC2BitstreamFB::default(); 2];
     let mut iobs = [XC2MCSmallIOB::default(); 32];
     
@@ -1432,7 +1432,7 @@ pub fn read_32a_bitstream_logical(fuses: &[bool]) -> Result<XC2BitstreamBits, XC
 }
 
 /// Internal function for parsing an XC2C64 bitstream
-pub fn read_64_bitstream_logical(fuses: &[bool]) -> Result<XC2BitstreamBits, XC2BitError> {
+fn read_64_bitstream_logical(fuses: &[bool]) -> Result<XC2BitstreamBits, XC2BitError> {
     let mut fb = [XC2BitstreamFB::default(); 4];
     let mut iobs = [XC2MCSmallIOB::default(); 64];
     
@@ -1450,7 +1450,7 @@ pub fn read_64_bitstream_logical(fuses: &[bool]) -> Result<XC2BitstreamBits, XC2
 }
 
 /// Internal function for parsing an XC2C64A bitstream
-pub fn read_64a_bitstream_logical(fuses: &[bool]) -> Result<XC2BitstreamBits, XC2BitError> {
+fn read_64a_bitstream_logical(fuses: &[bool]) -> Result<XC2BitstreamBits, XC2BitError> {
     let mut fb = [XC2BitstreamFB::default(); 4];
     let mut iobs = [XC2MCSmallIOB::default(); 64];
     
@@ -1476,7 +1476,7 @@ pub fn read_64a_bitstream_logical(fuses: &[bool]) -> Result<XC2BitstreamBits, XC
 }
 
 /// Internal function for parsing an XC2C128 bitstream
-pub fn read_128_bitstream_logical(fuses: &[bool]) -> Result<XC2BitstreamBits, XC2BitError> {
+fn read_128_bitstream_logical(fuses: &[bool]) -> Result<XC2BitstreamBits, XC2BitError> {
     let mut fb = [XC2BitstreamFB::default(); 8];
     let mut iobs = [XC2MCLargeIOB::default(); 100];
     
@@ -1503,7 +1503,7 @@ pub fn read_128_bitstream_logical(fuses: &[bool]) -> Result<XC2BitstreamBits, XC
 }
 
 /// Internal function for parsing an XC2C256 bitstream
-pub fn read_256_bitstream_logical(fuses: &[bool]) -> Result<XC2BitstreamBits, XC2BitError> {
+fn read_256_bitstream_logical(fuses: &[bool]) -> Result<XC2BitstreamBits, XC2BitError> {
     let mut fb = [XC2BitstreamFB::default(); 16];
     let mut iobs = [XC2MCLargeIOB::default(); 184];
     
@@ -1530,7 +1530,7 @@ pub fn read_256_bitstream_logical(fuses: &[bool]) -> Result<XC2BitstreamBits, XC
 }
 
 /// Internal function for parsing an XC2C384 bitstream
-pub fn read_384_bitstream_logical(fuses: &[bool]) -> Result<XC2BitstreamBits, XC2BitError> {
+fn read_384_bitstream_logical(fuses: &[bool]) -> Result<XC2BitstreamBits, XC2BitError> {
     let mut fb = [XC2BitstreamFB::default(); 24];
     let mut iobs = [XC2MCLargeIOB::default(); 240];
     
@@ -1561,7 +1561,7 @@ pub fn read_384_bitstream_logical(fuses: &[bool]) -> Result<XC2BitstreamBits, XC
 }
 
 /// Internal function for parsing an XC2C512 bitstream
-pub fn read_512_bitstream_logical(fuses: &[bool]) -> Result<XC2BitstreamBits, XC2BitError> {
+fn read_512_bitstream_logical(fuses: &[bool]) -> Result<XC2BitstreamBits, XC2BitError> {
     let mut fb = [XC2BitstreamFB::default(); 32];
     let mut iobs = [XC2MCLargeIOB::default(); 270];
     
@@ -1592,7 +1592,7 @@ pub fn read_512_bitstream_logical(fuses: &[bool]) -> Result<XC2BitstreamBits, XC
 }
 
 /// Common logic for reading bitstreams on "small" devices
-pub fn read_bitstream_physical_common_small(fuse_array: &FuseArray, device: XC2Device,
+fn read_bitstream_physical_common_small(fuse_array: &FuseArray, device: XC2Device,
     fb: &mut [XC2BitstreamFB], iobs: &mut [XC2MCSmallIOB]) -> Result<(), XC2BitError> {
 
     for i in 0..fb.len() {
@@ -1607,7 +1607,7 @@ pub fn read_bitstream_physical_common_small(fuse_array: &FuseArray, device: XC2D
 }
 
 /// Common logic for reading bitstreams on "large" devices
-pub fn read_bitstream_physical_common_large(fuse_array: &FuseArray, device: XC2Device,
+fn read_bitstream_physical_common_large(fuse_array: &FuseArray, device: XC2Device,
     fb: &mut [XC2BitstreamFB], iobs: &mut [XC2MCLargeIOB]) -> Result<(), XC2BitError> {
 
     for i in 0..fb.len() {
@@ -1622,7 +1622,7 @@ pub fn read_bitstream_physical_common_large(fuse_array: &FuseArray, device: XC2D
 }
 
 /// Internal function for parsing an XC2C32 bitstream
-pub fn read_32_bitstream_physical(fuse_array: &FuseArray) -> Result<XC2BitstreamBits, XC2BitError> {
+fn read_32_bitstream_physical(fuse_array: &FuseArray) -> Result<XC2BitstreamBits, XC2BitError> {
     let mut fb = [XC2BitstreamFB::default(); 2];
     let mut iobs = [XC2MCSmallIOB::default(); 32];
     
@@ -1643,7 +1643,7 @@ pub fn read_32_bitstream_physical(fuse_array: &FuseArray) -> Result<XC2Bitstream
 }
 
 /// Internal function for parsing an XC2C32A bitstream
-pub fn read_32a_bitstream_physical(fuse_array: &FuseArray) -> Result<XC2BitstreamBits, XC2BitError> {
+fn read_32a_bitstream_physical(fuse_array: &FuseArray) -> Result<XC2BitstreamBits, XC2BitError> {
     let mut fb = [XC2BitstreamFB::default(); 2];
     let mut iobs = [XC2MCSmallIOB::default(); 32];
     
@@ -1672,7 +1672,7 @@ pub fn read_32a_bitstream_physical(fuse_array: &FuseArray) -> Result<XC2Bitstrea
 }
 
 /// Internal function for parsing an XC2C64 bitstream
-pub fn read_64_bitstream_physical(fuse_array: &FuseArray) -> Result<XC2BitstreamBits, XC2BitError> {
+fn read_64_bitstream_physical(fuse_array: &FuseArray) -> Result<XC2BitstreamBits, XC2BitError> {
     let mut fb = [XC2BitstreamFB::default(); 4];
     let mut iobs = [XC2MCSmallIOB::default(); 64];
     
@@ -1690,7 +1690,7 @@ pub fn read_64_bitstream_physical(fuse_array: &FuseArray) -> Result<XC2Bitstream
 }
 
 /// Internal function for parsing an XC2C64A bitstream
-pub fn read_64a_bitstream_physical(fuse_array: &FuseArray) -> Result<XC2BitstreamBits, XC2BitError> {
+fn read_64a_bitstream_physical(fuse_array: &FuseArray) -> Result<XC2BitstreamBits, XC2BitError> {
     let mut fb = [XC2BitstreamFB::default(); 4];
     let mut iobs = [XC2MCSmallIOB::default(); 64];
     
@@ -1716,7 +1716,7 @@ pub fn read_64a_bitstream_physical(fuse_array: &FuseArray) -> Result<XC2Bitstrea
 }
 
 /// Internal function for parsing an XC2C128 bitstream
-pub fn read_128_bitstream_physical(fuse_array: &FuseArray) -> Result<XC2BitstreamBits, XC2BitError> {
+fn read_128_bitstream_physical(fuse_array: &FuseArray) -> Result<XC2BitstreamBits, XC2BitError> {
     let mut fb = [XC2BitstreamFB::default(); 8];
     let mut iobs = [XC2MCLargeIOB::default(); 100];
     
@@ -1743,7 +1743,7 @@ pub fn read_128_bitstream_physical(fuse_array: &FuseArray) -> Result<XC2Bitstrea
 }
 
 /// Internal function for parsing an XC2C256 bitstream
-pub fn read_256_bitstream_physical(fuse_array: &FuseArray) -> Result<XC2BitstreamBits, XC2BitError> {
+fn read_256_bitstream_physical(fuse_array: &FuseArray) -> Result<XC2BitstreamBits, XC2BitError> {
     let mut fb = [XC2BitstreamFB::default(); 16];
     let mut iobs = [XC2MCLargeIOB::default(); 184];
     
@@ -1770,7 +1770,7 @@ pub fn read_256_bitstream_physical(fuse_array: &FuseArray) -> Result<XC2Bitstrea
 }
 
 /// Internal function for parsing an XC2C384 bitstream
-pub fn read_384_bitstream_physical(fuse_array: &FuseArray) -> Result<XC2BitstreamBits, XC2BitError> {
+fn read_384_bitstream_physical(fuse_array: &FuseArray) -> Result<XC2BitstreamBits, XC2BitError> {
     let mut fb = [XC2BitstreamFB::default(); 24];
     let mut iobs = [XC2MCLargeIOB::default(); 240];
     
@@ -1801,7 +1801,7 @@ pub fn read_384_bitstream_physical(fuse_array: &FuseArray) -> Result<XC2Bitstrea
 }
 
 /// Internal function for parsing an XC2C512 bitstream
-pub fn read_512_bitstream_physical(fuse_array: &FuseArray) -> Result<XC2BitstreamBits, XC2BitError> {
+fn read_512_bitstream_physical(fuse_array: &FuseArray) -> Result<XC2BitstreamBits, XC2BitError> {
     let mut fb = [XC2BitstreamFB::default(); 32];
     let mut iobs = [XC2MCLargeIOB::default(); 270];
     
diff --git a/src/xc2bit/src/errors.rs b/src/xc2bit/src/errors.rs
@@ -31,18 +31,30 @@ use std::fmt;
 use std::num;
 use std::str;
 
+/// Errors that can occur when parsing a .jed file
 #[derive(Debug, PartialEq, Eq)]
 pub enum JedParserError {
+    /// No STX byte found
     MissingSTX,
+    /// No ETX byte found
     MissingETX,
+    /// An invalid UTF-8 sequence occurred
     InvalidUtf8(str::Utf8Error),
+    /// A field contains a character not appropriate for that field (e.g. non-hex digit in a hex field)
     InvalidCharacter,
+    /// An unexpected end of file was encountered in the file checksum
     UnexpectedEnd,
+    /// The file checksum was nonzero and incorrect
     BadFileChecksum,
+    /// The fuse checksum (`C` command) was incorrect
     BadFuseChecksum,
+    /// A `L` field index was out of range
     InvalidFuseIndex,
+    /// There was no `QF` field
     MissingQF,
+    /// There was no `F` field, but not all fuses had a value specified
     MissingF,
+    /// There was a field that this program does not recognize
     UnrecognizedField,
 }
 
@@ -102,12 +114,18 @@ impl From<num::ParseIntError> for JedParserError {
     }
 }
 
+/// Errors that can occur when parsing a bitstream
 #[derive(Debug, PartialEq, Eq)]
 pub enum XC2BitError {
+    /// The .jed file could not be parsed
     JedParseError(JedParserError),
+    /// The device name is invalid
     BadDeviceName(String),
+    /// The number of fuses was incorrect for the device
     WrongFuseCount,
+    /// An unknown value was used in the `Oe` field
     UnsupportedOeConfiguration((bool, bool, bool, bool)),
+    /// An unknown value was used in the ZIA selection bits
     UnsupportedZIAConfiguration(Vec<bool>),
 }
 
diff --git a/src/xc2bit/src/fb.rs b/src/xc2bit/src/fb.rs
@@ -625,13 +625,13 @@ impl XC2BitstreamFB {
             _ => true,
         };
 
-        let zia_row_read_function = match device {
-            XC2Device::XC2C32 | XC2Device::XC2C32A => XC2ZIARowPiece::read_32_zia_fb_row_logical,
-            XC2Device::XC2C64 | XC2Device::XC2C64A => XC2ZIARowPiece::read_64_zia_fb_row_logical,
-            XC2Device::XC2C128 => XC2ZIARowPiece::read_128_zia_fb_row_logical,
-            XC2Device::XC2C256 => XC2ZIARowPiece::read_256_zia_fb_row_logical,
-            XC2Device::XC2C384 => XC2ZIARowPiece::read_384_zia_fb_row_logical,
-            XC2Device::XC2C512 => XC2ZIARowPiece::read_512_zia_fb_row_logical,
+        let zia_row_decode_function = match device {
+            XC2Device::XC2C32 | XC2Device::XC2C32A => XC2ZIARowPiece::decode_32_zia_choice,
+            XC2Device::XC2C64 | XC2Device::XC2C64A => XC2ZIARowPiece::decode_64_zia_choice,
+            XC2Device::XC2C128 => XC2ZIARowPiece::decode_128_zia_choice,
+            XC2Device::XC2C256 => XC2ZIARowPiece::decode_256_zia_choice,
+            XC2Device::XC2C384 => XC2ZIARowPiece::decode_384_zia_choice,
+            XC2Device::XC2C512 => XC2ZIARowPiece::decode_512_zia_choice,
         };
 
         let mut and_terms = [XC2PLAAndTerm::default(); ANDTERMS_PER_FB];
@@ -649,7 +649,8 @@ impl XC2BitstreamFB {
         let mut zia_bits = [XC2ZIARowPiece::default(); INPUTS_PER_ANDTERM];
         let zia_block_idx = fuse_base;
         for i in 0..zia_bits.len() {
-            let result = zia_row_read_function(fuses, zia_block_idx, i)?;
+            let zia_row_fuses = &fuses[zia_block_idx + i * zia_row_width..zia_block_idx + (i + 1) * zia_row_width];
+            let result = zia_row_decode_function(i, zia_row_fuses)?;
             zia_bits[i] = result;
         }
 
diff --git a/src/xc2bit/src/zia.rs b/src/xc2bit/src/zia.rs
@@ -9158,15 +9158,6 @@ const T: bool = true;
 const F: bool = false;
 
 impl XC2ZIARowPiece {
-    /// Internal function that reads a piece of the ZIA corresponding to one FB and one row
-    pub fn read_32_zia_fb_row_logical(fuses: &[bool], block_idx: usize, row_idx: usize)
-        -> Result<Self, XC2BitError> {
-
-        let zia_row_fuses = &fuses[block_idx + row_idx * 8..block_idx + (row_idx + 1) * 8];
-
-        XC2ZIARowPiece::decode_32_zia_choice(row_idx, zia_row_fuses)
-    }
-
     /// Internal function that takes a ZIA row and decodes the bit encoding for it
     pub fn decode_32_zia_choice(row: usize, row_bits: &[bool]) -> Result<Self, XC2BitError> {
         // This is an ugly workaround for the lack of stable slice patterns
@@ -9227,15 +9218,6 @@ impl XC2ZIARowPiece {
         }
     }
 
-    /// Internal function that reads a piece of the ZIA corresponding to one FB and one row
-    pub fn read_64_zia_fb_row_logical(fuses: &[bool], block_idx: usize, row_idx: usize)
-        -> Result<Self, XC2BitError> {
-
-        let zia_row_fuses = &fuses[block_idx + row_idx * 16..block_idx + (row_idx + 1) * 16];
-
-        XC2ZIARowPiece::decode_64_zia_choice(row_idx, zia_row_fuses)
-    }
-
     /// Internal function that takes a ZIA row and decodes the bit encoding for it
     pub fn decode_64_zia_choice(row: usize, row_bits: &[bool]) -> Result<Self, XC2BitError> {
         // This is an ugly workaround for the lack of stable slice patterns
@@ -9319,15 +9301,6 @@ impl XC2ZIARowPiece {
         }
     }
 
-    /// Internal function that reads a piece of the ZIA corresponding to one FB and one row
-    pub fn read_128_zia_fb_row_logical(fuses: &[bool], block_idx: usize, row_idx: usize)
-        -> Result<Self, XC2BitError> {
-
-        let zia_row_fuses = &fuses[block_idx + row_idx * 28..block_idx + (row_idx + 1) * 28];
-
-        XC2ZIARowPiece::decode_128_zia_choice(row_idx, zia_row_fuses)
-    }
-
     /// Internal function that takes a ZIA row and decodes the bit encoding for it
     pub fn decode_128_zia_choice(row: usize, row_bits: &[bool]) -> Result<Self, XC2BitError> {
         // This is an ugly workaround for the lack of stable slice patterns
@@ -9443,15 +9416,6 @@ impl XC2ZIARowPiece {
         }
     }
 
-    /// Internal function that reads a piece of the ZIA corresponding to one FB and one row
-    pub fn read_256_zia_fb_row_logical(fuses: &[bool], block_idx: usize, row_idx: usize)
-        -> Result<Self, XC2BitError> {
-
-        let zia_row_fuses = &fuses[block_idx + row_idx * 48..block_idx + (row_idx + 1) * 48];
-
-        XC2ZIARowPiece::decode_256_zia_choice(row_idx, zia_row_fuses)
-    }
-
     /// Internal function that takes a ZIA row and decodes the bit encoding for it
     pub fn decode_256_zia_choice(row: usize, row_bits: &[bool]) -> Result<Self, XC2BitError> {
         // This is an ugly workaround for the lack of stable slice patterns
@@ -9623,15 +9587,6 @@ impl XC2ZIARowPiece {
         }
     }
 
-    /// Internal function that reads a piece of the ZIA corresponding to one FB and one row
-    pub fn read_384_zia_fb_row_logical(fuses: &[bool], block_idx: usize, row_idx: usize)
-        -> Result<Self, XC2BitError> {
-
-        let zia_row_fuses = &fuses[block_idx + row_idx * 74..block_idx + (row_idx + 1) * 74];
-
-        XC2ZIARowPiece::decode_384_zia_choice(row_idx, zia_row_fuses)
-    }
-
     /// Internal function that takes a ZIA row and decodes the bit encoding for it
     pub fn decode_384_zia_choice(row: usize, row_bits: &[bool]) -> Result<Self, XC2BitError> {
         // This is an ugly workaround for the lack of stable slice patterns
@@ -9873,15 +9828,6 @@ impl XC2ZIARowPiece {
         }
     }
 
-    /// Internal function that reads a piece of the ZIA corresponding to one FB and one row
-    pub fn read_512_zia_fb_row_logical(fuses: &[bool], block_idx: usize, row_idx: usize)
-        -> Result<Self, XC2BitError> {
-
-        let zia_row_fuses = &fuses[block_idx + row_idx * 88..block_idx + (row_idx + 1) * 88];
-
-        XC2ZIARowPiece::decode_512_zia_choice(row_idx, zia_row_fuses)
-    }
-
     /// Internal function that takes a ZIA row and decodes the bit encoding for it
     pub fn decode_512_zia_choice(row: usize, row_bits: &[bool]) -> Result<Self, XC2BitError> {
         // This is an ugly workaround for the lack of stable slice patterns
