Handle missing dimIndex on registers

Per the SVD spec, dimIndex is not required:

> By default, <dimIndex> is a value starting with 0.
> Remark: Do not define <dimIndex> when using the placeholder [%s] in
<name> or <displayName>.

I interpret this as it being optional whether the name uses "%s" or
"[%s]". Atmel SAMD21 SVDs use "%s" with no dimIndex for 0-indexed
arrays.

This also tests that dimIndex is sequential and numeric in a single pass
without allocating temporary vectors, and fixes the typo
adresses -> addresses.

Author: kevinmehall

src/generate.rs

@@ -564,32 +564,17 @@ fn register_block(registers: &[Register], defs: &Defaults) -> Result<Tokens> {
                 size: register_size,
             }),
             Register::Array(ref info, ref array_info) => {
-                let sequential_adresses = register_size == array_info.dim_increment * BITS_PER_BYTE;
-
-                let numeral_indexes = array_info
-                    .dim_index
-                    .clone()
-                    .ok_or_else(|| {
-                        format!("Register {} has no `dim_index` field", register.name)
-                    })?
-                    .iter()
-                    .all(|element| element.parse::<usize>().is_ok());
+                let sequential_addresses = register_size == array_info.dim_increment * BITS_PER_BYTE;
 
-                let sequential_indexes = if numeral_indexes && sequential_adresses {
-                    array_info
-                        .dim_index
-                        .clone()
-                        .unwrap()
+                // if dimIndex exists, test if it is a sequence of numbers from 0 to dim
+                let sequential_indexes = array_info.dim_index.as_ref().map_or(true, |dim_index| {
+                    dim_index
                         .iter()
-                        .map(|element| element.parse::<u32>().unwrap())
-                        .collect::<Vec<u32>>()
-                        .eq(&(0..array_info.dim).collect::<Vec<u32>>())
-                } else {
-                    false
-                };
+                        .map(|element| element.parse::<u32>())
+                        .eq((0..array_info.dim).map(Ok))
+                });
 
-                let array_convertible =
-                    sequential_indexes && numeral_indexes && sequential_adresses;
+                let array_convertible = sequential_indexes && sequential_addresses;
 
                 if array_convertible {
                     registers_expanded.push(RegisterBlockField {