Adding support for references to another peripheral

Handling "<PERIPHERAL>.<REGISTER>.<FIELD>.<ENUMERATEDVALUES>" format
for the "derivedFrom" attribute in <enumeratedValues>.

Author: idubrov

src/generate.rs

@@ -69,7 +69,7 @@ pub fn device(d: &Device, items: &mut Vec<Tokens>) -> Result<()> {
             continue;
         }
 
-        ::generate::peripheral(p, items, &d.defaults)?;
+        ::generate::peripheral(p, &d.peripherals, items, &d.defaults)?;
     }
 
     Ok(())
@@ -235,6 +235,7 @@ pub fn interrupt(peripherals: &[Peripheral], items: &mut Vec<Tokens>) {
 
 pub fn peripheral(
     p: &Peripheral,
+    all_peripherals: &[Peripheral],
     items: &mut Vec<Tokens>,
     defaults: &Defaults,
 ) -> Result<()> {
@@ -290,7 +291,7 @@ pub fn peripheral(
     mod_items.push(::generate::register_block(registers, defaults)?);
 
     for register in registers {
-        ::generate::register(register, registers, p, defaults, &mut mod_items)?;
+        ::generate::register(register, registers, p, all_peripherals, defaults, &mut mod_items)?;
     }
 
     let name_sc = Ident::new(&*p.name.to_sanitized_snake_case());
@@ -416,6 +417,7 @@ pub fn register(
     register: &Register,
     all_registers: &[Register],
     peripheral: &Peripheral,
+    all_peripherals: &[Peripheral],
     defs: &Defaults,
     items: &mut Vec<Tokens>,
 ) -> Result<()> {
@@ -572,6 +574,7 @@ pub fn register(
                 register,
                 all_registers,
                 peripheral,
+                all_peripherals,
                 &rty,
                 access,
                 &mut mod_items,
@@ -623,6 +626,7 @@ pub fn fields(
     parent: &Register,
     all_registers: &[Register],
     peripheral: &Peripheral,
+    all_peripherals: &[Peripheral],
     rty: &Ident,
     access: Access,
     mod_items: &mut Vec<Tokens>,
@@ -724,6 +728,7 @@ pub fn fields(
                     parent,
                     all_registers,
                     peripheral,
+                    all_peripherals,
                     Usage::Read,
                 )? {
                 struct Variant<'a> {
@@ -767,7 +772,19 @@ pub fn fields(
                     let description =
                         format!("Possible values of the field `{}`", f.name);
 
-                    if let Some(ref register) = base.register {
+                    if let (Some(ref peripheral), Some(ref register)) = (base.peripheral, base.register) {
+                        let pmod_ = peripheral.to_sanitized_snake_case();
+                        let rmod_ = register.to_sanitized_snake_case();
+                        let pmod_ = Ident::new(&*pmod_);
+                        let rmod_ = Ident::new(&*rmod_);
+
+                        mod_items.push(
+                            quote! {
+                                #[doc = #description]
+                                pub type #pc_r = ::#pmod_::#rmod_::#base_pc_r;
+                            },
+                        );
+                    } else if let Some(ref register) = base.register {
                         let mod_ = register.to_sanitized_snake_case();
                         let mod_ = Ident::new(&*mod_);
 
@@ -1037,6 +1054,7 @@ pub fn fields(
                     parent,
                     all_registers,
                     peripheral,
+                    all_peripherals,
                     Usage::Write,
                 )? {
                 struct Variant {
@@ -1058,7 +1076,24 @@ pub fn fields(
                             let pc = base.field.to_sanitized_pascal_case();
                             let base_pc_w = Ident::new(&*format!("{}W", pc));
 
-                            if let Some(ref register) = base.register {
+                            if let (Some(ref peripheral), Some(ref register)) = (base.peripheral, base.register) {
+                                let pmod_ = peripheral.to_sanitized_snake_case();
+                                let rmod_ = register.to_sanitized_snake_case();
+                                let pmod_ = Ident::new(&*pmod_);
+                                let rmod_ = Ident::new(&*rmod_);
+
+                                mod_items.push(
+                                    quote! {
+                                        #[doc = #pc_w_doc]
+                                        pub type #pc_w =
+                                            ::#pmod_::#rmod_::#base_pc_w;
+                                    },
+                                );
+
+                                quote! {
+                                    ::#pmod_::#rmod_::#base_pc_w
+                                }
+                            } else if let Some(ref register) = base.register {
                                 let mod_ = register.to_sanitized_snake_case();
                                 let mod_ = Ident::new(&*mod_);
 

src/util.rs

@@ -249,6 +249,7 @@ pub fn unsuffixed_or_bool(n: u64, width: u32) -> Lit {
 
 #[derive(Clone, Debug)]
 pub struct Base<'a> {
+    pub peripheral: Option<&'a str>,
     pub register: Option<&'a str>,
     pub field: &'a str,
 }
@@ -260,27 +261,38 @@ pub fn lookup<'a>
     register: &'a Register,
     all_registers: &'a [Register],
     peripheral: &'a Peripheral,
+    all_peripherals: &'a [Peripheral],
     usage: Usage,
 ) -> Result<Option<(&'a EnumeratedValues, Option<Base<'a>>)>> {
     let evs = evs.iter()
         .map(
             |evs| if let Some(ref base) = evs.derived_from {
                 let mut parts = base.split('.');
 
-                match (parts.next(), parts.next(), parts.next()) {
-                    (Some(base_register), Some(base_field), Some(base_evs)) => {
+                match (parts.next(), parts.next(), parts.next(), parts.next()) {
+                    (Some(base_peripheral), Some(base_register), Some(base_field), Some(base_evs)) => {
+                        lookup_in_peripherals(
+                            base_peripheral,
+                            base_register,
+                            base_field,
+                            base_evs,
+                            all_peripherals,
+                        )
+                    }
+                    (Some(base_register), Some(base_field), Some(base_evs), None) => {
                         lookup_in_peripheral(
+                            None,
                             base_register,
                             base_field,
                             base_evs,
                             all_registers,
                             peripheral,
                         )
                     }
-                    (Some(base_field), Some(base_evs), None) => {
+                    (Some(base_field), Some(base_evs), None, None) => {
                         lookup_in_fields(base_evs, base_field, fields, register)
                     }
-                    (Some(base_evs), None, None) => {
+                    (Some(base_evs), None, None, None) => {
                         lookup_in_register(base_evs, register)
                     }
                     _ => unreachable!(),
@@ -307,7 +319,7 @@ fn lookup_in_fields<'f>(
     register: &Register,
 ) -> Result<(&'f EnumeratedValues, Option<Base<'f>>)> {
     if let Some(base_field) = fields.iter().find(|f| f.name == base_field) {
-        return lookup_in_field(base_evs, None, base_field);
+        return lookup_in_field(base_evs, None, None, base_field);
     } else {
         Err(
             format!(
@@ -321,6 +333,7 @@ fn lookup_in_fields<'f>(
 
 fn lookup_in_peripheral<'p>
     (
+    base_peripheral: Option<&'p str>,
     base_register: &'p str,
     base_field: &str,
     base_evs: &str,
@@ -339,7 +352,7 @@ fn lookup_in_peripheral<'p>
                .unwrap_or(&[])
                .iter()
                .find(|f| f.name == base_field) {
-            lookup_in_field(base_evs, Some(base_register), field)
+            lookup_in_field(base_evs, Some(base_register), base_peripheral, field)
         } else {
             Err(
                 format!(
@@ -363,6 +376,7 @@ fn lookup_in_peripheral<'p>
 fn lookup_in_field<'f>(
     base_evs: &str,
     base_register: Option<&'f str>,
+    base_peripheral: Option<&'f str>,
     field: &'f Field,
 ) -> Result<(&'f EnumeratedValues, Option<Base<'f>>)> {
     for evs in &field.enumerated_values {
@@ -373,6 +387,7 @@ fn lookup_in_field<'f>(
                     Base {
                         field: &field.name,
                         register: base_register,
+                        peripheral: base_peripheral,
                     },
                 ))),
             );
@@ -416,6 +431,7 @@ fn lookup_in_register<'r>
                         Base {
                             field: field,
                             register: None,
+                            peripheral: None
                         },
                     )),
                 );
@@ -437,6 +453,40 @@ fn lookup_in_register<'r>
     }
 }
 
+fn lookup_in_peripherals<'p>
+(
+    base_peripheral: &'p str,
+    base_register: &'p str,
+    base_field: &str,
+    base_evs: &str,
+    all_peripherals: &'p [Peripheral],
+) -> Result<(&'p EnumeratedValues, Option<Base<'p>>)> {
+    if let Some(peripheral) = all_peripherals
+        .iter()
+        .find(|p| { p.name == base_peripheral }) {
+        let all_registers = peripheral.registers
+            .as_ref()
+            .map(|x| x.as_ref())
+            .unwrap_or(&[][..]);
+        lookup_in_peripheral(
+            Some(base_peripheral),
+            base_register,
+            base_field,
+            base_evs,
+            all_registers,
+            peripheral
+        )
+    } else {
+        Err(
+            format!(
+                "No peripheral {}",
+                base_peripheral
+            ),
+        )?
+    }
+}
+
+
 pub trait U32Ext {
     fn to_ty(&self) -> Result<Ident>;
     fn to_ty_width(&self) -> Result<u32>;