function to determine C-type to represent a ladder type, for morphism generate expected C-signatures & calls

src/main.rs

@@ -11,8 +11,60 @@ use {
     std::sync::{Arc, RwLock}
 };
 
+/* for a given ladder type `t`, get the corresponding C type
+ */
+pub fn get_c_repr_type(dict: &mut impl TypeDict, t: laddertypes::TypeTerm, skip_pointer: bool) -> Option<String> {
+    let lnf = t.normalize().decurry().get_lnf_vec();
+
+    match lnf.last() {
+        Some(t) => {
+            if t == &dict.parse("Byte").expect("parse")
+            || t == &dict.parse("x86.UInt8").expect("parse")
+            || t == &dict.parse("<StaticLength 8 Bit>").expect("parse")
+            {
+                Some("uint8_t".into())
+            } else if t == &dict.parse("x86.UInt16").expect("parse") {
+                Some("uint16_t".into())
+            } else if t == &dict.parse("x86.UInt32").expect("parse") {
+                Some("uint32_t".into())
+            } else if t == &dict.parse("x86.UInt64").expect("parse") {
+                Some("uint64_t".into())
+            } else {
+                match t {
+                    laddertypes::TypeTerm::App(args) => {
+                        if args[0] == laddertypes::TypeTerm::TypeID(dict.get_typeid(&"LengthPrefix".into()).unwrap())
+                        {
+                            let item_c_type : String = get_c_repr_type(dict, args[2].clone(), false)?;
+                            match item_c_type.as_str() {
+                                "uint8_t" => Some(format!("LengthPrefixUInt8Array")),
+                                "uint16_t" => Some(format!("LengthPrefixUInt16Array")),
+                                "uint32_t" => Some(format!("LengthPrefixUInt32Array")),
+                                "uint64_t" => Some(format!("LengthPrefixUInt64Array")),
+                                _ => None
+                            }
+                        }
+                        else if args[0] == laddertypes::TypeTerm::TypeID(dict.get_typeid(&"ValueDelim".into()).unwrap())
+                        {
+                            let c_type = get_c_repr_type(dict, args[2].clone(), false)?;
+                            if skip_pointer {
+                                Some(c_type)
+                            } else {
+                                Some(format!("{} *", c_type))
+                            }
+                        } else {
+                            None
+                        }
+                    }
+                    _ => None
+                }
+            }
+        }
+        None => None
+    }
+}
+
 #[derive(Debug)]
-struct Morphism {
+struct LdmcMorphism {
     symbol: String,
     type_args: Vec<(String, String)>,
     src_type: laddertypes::TypeTerm,
@@ -20,6 +72,34 @@ struct Morphism {
     locations: Vec<String>
 }
 
+impl LdmcMorphism {
+    pub fn expected_c_type_signature(&self, dict: &mut impl TypeDict) -> String {
+        format!("int {} ({} const * restrict src, {} * restrict dst);",
+            self.symbol,
+            get_c_repr_type(dict, self.src_type.clone(), true).expect("cant get c-repr type for src type"),
+            get_c_repr_type(dict, self.dst_type.clone(), true).expect("cant get c-repr type for dst type"))
+    }
+
+    pub fn generate_call(&self, dict: &mut impl TypeDict) {
+        let src_c_type = get_c_repr_type(dict, self.src_type.clone(), true).expect("cant get c-repr type for src type");
+        let dst_c_type = get_c_repr_type(dict, self.dst_type.clone(), true).expect("cant get c-repr type for dst type");
+
+        let src_buf = "bufA";
+        let dst_buf = "bufB";
+        println!(
+"{}
+    {} const * restrict src = {};
+    {} * restrict dst = {};
+    {} ( src, dst );
+{}",
+    '{',
+    src_c_type, src_buf,
+    dst_c_type, dst_buf,
+    self.symbol,
+    '}');
+    }
+}
+
 /* morphism-base text format:
  *     NAME '(' [TYPE-ARG-NAME ':' KIND]  ')'
  *           SRC-TYPE
@@ -28,7 +108,7 @@ struct Morphism {
  */
 fn parser(
     type_dict: Arc<RwLock< BimapTypeDict >>
-) -> impl Parser<char, Vec<Morphism>, Error = Simple<char>> {
+) -> impl Parser<char, Vec<LdmcMorphism>, Error = Simple<char>> {
 
     ident().padded()
     .then(
@@ -57,7 +137,7 @@ fn parser(
             let src_type = type_dict.parse(&src_type.iter().collect::<String>()).expect("couldnt parse src type");
             let dst_type = type_dict.parse(&dst_type.iter().collect::<String>()).expect("couldnt parse dst type");
 
-            Morphism {
+            LdmcMorphism {
                 symbol,
                 type_args,
                 src_type,
@@ -70,6 +150,7 @@ fn parser(
 
 fn main() {
     let type_dict = Arc::new(RwLock::new(BimapTypeDict::new()));
+
     let src = std::fs::read_to_string(
         std::env::args().nth(1).expect("expected file name")
     ).expect("read");
@@ -81,10 +162,14 @@ fn main() {
             let mut dict = type_dict.write().unwrap();
 
             for m in morphisms {
-                println!("{}\n    {}\n---> \n    {}\n", m.symbol,
-                    m.src_type.sugar(&mut *dict).pretty(&mut *dict, 1),
-                    m.dst_type.sugar(&mut *dict).pretty(&mut *dict, 1),
+                println!("{}\n    {}\n---> \n    {}\n{}\n\n", m.symbol,
+                    m.src_type.clone().sugar(&mut *dict).pretty(&mut *dict, 1),
+                    m.dst_type.clone().sugar(&mut *dict).pretty(&mut *dict, 1),
+
+                    m.expected_c_type_signature(&mut *dict),
                 );
+
+                m.generate_call(&mut *dict);
             }
         }
         Err(errs) => {