split main.rs into separate files

src/c_gen.rs

@@ -0,0 +1,363 @@
+use {
+    laddertypes::{TypeDict, TypeTerm, parser::*, unparser::*, morphism::{Morphism, MorphismInstance}},
+    crate::morphism::{LdmcPrimCMorphism, LdmcMorphism}
+};
+
+/*
+*/
+pub fn get_c_repr_kind(kind: String) -> Option<String> {
+    match kind.as_str() {
+        "ℤ" => Some("uint64_t".into()),
+        _ => None
+    }
+}
+
+/* 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 _length_type = args[1].clone();
+                            let item_c_type : String = get_c_repr_type(dict, args[2].clone(), false)?;
+                            match item_c_type.as_str() {
+                                "uint8_t" => Some(format!("struct LengthPrefixUInt8Array")),
+                                "uint16_t" => Some(format!("struct LengthPrefixUInt16Array")),
+                                "uint32_t" => Some(format!("struct LengthPrefixUInt32Array")),
+                                "uint64_t" => Some(format!("struct LengthPrefixUInt64Array")),
+                                _ => None
+                            }
+                        }
+                        else if args[0] == laddertypes::TypeTerm::TypeID(dict.get_typeid(&"ValueTerminated".into()).unwrap())
+                        {
+                            let _delim_val = args[1].clone();
+                            let c_type = get_c_repr_type(dict, args[2].clone(), false)?;
+                            if skip_pointer {
+                                Some(c_type)
+                            } else {
+                                Some(format!("{} *", c_type))
+                            }
+                        }
+                        else if args[0] == laddertypes::TypeTerm::TypeID(dict.get_typeid(&"MsbCont".into()).unwrap())
+                        {
+                            let c_type = get_c_repr_type(dict, args[1].clone(), false)?;
+                            if skip_pointer {
+                                Some(c_type)
+                            } else {
+                                Some(format!("{} *", c_type))
+                            }
+                        }
+                        else {
+                            None
+                        }
+                    }
+
+                    _ => None
+                }
+            }
+        }
+        None => None
+    }
+}
+
+
+pub fn encode_type_to_symbol(dict: &mut impl TypeDict, t: &laddertypes::TypeTerm)-> String {
+    match t {
+        laddertypes::TypeTerm::Char(c) => {
+            match c {
+                '.' => format!("_dot_"),
+                _ =>
+                format!("{}", (*c as u64))
+            }
+        },
+        laddertypes::TypeTerm::Num(n) => {
+            format!("{}", n)
+        }
+        laddertypes::TypeTerm::TypeID(ty_id) => {
+            if let Some(name) = dict.get_typename(ty_id) {
+                format!("{}", name.replace(".", "_dot_"))
+            } else {
+                format!("")
+            }
+        }
+        laddertypes::TypeTerm::Ladder(rs) |
+        laddertypes::TypeTerm::App(rs) => {
+            let mut s = String::new();
+            for r in rs {
+                s.push('_');
+                s.push_str(&encode_type_to_symbol(dict, r));
+            }
+            s
+        }
+    }
+}
+
+pub fn encode_type_to_value(dict: &mut impl TypeDict, t: &laddertypes::TypeTerm) -> String {
+    dict.unparse(t)
+}
+
+
+pub fn generate_main(type_dict: &mut impl TypeDict, path: Vec<MorphismInstance<LdmcMorphism>>, src_type: TypeTerm, dst_type: TypeTerm) {
+    let mut i = 0;
+
+    /* todo: collect include files from morphism base */
+    println!(r#"
+#include <stdio.h>
+#include <unistd.h>
+#include <string.h>
+#include <stdint.h>
+#include <stdbool.h>
+"#);
+
+    let mut existing_instantiations = Vec::new();
+    for morph_inst in path.iter() {
+        match &morph_inst.m {
+            LdmcMorphism::Primitive( item_morph ) => {
+                let name = item_morph.instantiated_symbol_name(type_dict, &morph_inst.σ);
+                if ! existing_instantiations.contains(&name) {
+                    if let Some(s) = item_morph.generate_instantiation(type_dict, &morph_inst.σ) {
+                        println!("{}", s);
+                    } else {
+                        eprintln!("couldnt generate instance {}", name);
+                    }
+                    existing_instantiations.push( name );
+                }
+            }
+            LdmcMorphism::LengthPrefixMap { length_prefix_type, item_morph } => {
+                let name = item_morph.instantiated_symbol_name(type_dict, &morph_inst.σ);
+                if ! existing_instantiations.contains(&name) {
+                    if let Some(s) = item_morph.generate_instantiation(type_dict, &morph_inst.σ) {
+                        println!("{}", s);
+                    } else {
+                        eprintln!("couldnt generate instance {}", name);
+                    }
+
+                    existing_instantiations.push( name );
+                }
+            }
+            _ => {}
+        }
+    }
+
+    println!(r#"
+int main() {{
+uint8_t bufA[1024];
+uint8_t bufB[1024];
+
+char in_str[] = "read :: {} \n";
+char out_str[]= "write:: {} \n";
+write(2, in_str, strlen(in_str));
+write(2, out_str, strlen(out_str));
+
+int l = read(0, bufA, 1024);
+fprintf(stderr, "read  %d bytes\n", l);
+
+        "#,
+        type_dict.unparse(&src_type).replace("\\", "\\\\"),
+        type_dict.unparse(&dst_type).replace("\\", "\\\\") );
+
+    for morph_inst in path.iter() {
+        println!(r#"
+/* morph to {}
+
+...with
+morph {}
+---> {},
+subst σ = {:?},
+halo  Ψ = {}
+*/"#,
+            type_dict.unparse(&morph_inst.get_type().dst_type.param_normalize().decurry()),
+            type_dict.unparse(&morph_inst.m.get_type().src_type),
+            type_dict.unparse(&morph_inst.m.get_type().dst_type),
+            morph_inst.σ,
+            type_dict.unparse(&morph_inst.halo),
+        );
+        morph_inst.m.generate_call(type_dict, &morph_inst.σ, i);
+        i += 1;
+    }
+
+    let out_buf = if i%2==0 { "bufA" } else { "bufB" };
+
+    let is_string = false;
+    if let Ok((halo, σ)) = laddertypes::subtype_unify(
+        &dst_type,
+        &type_dict.parse("<Seq~<ValueTerminated 0> x86.UInt8>").unwrap()
+    ) {
+        println!(r#"
+printf("%s\n", {});"#, out_buf);
+    } else if let Ok((halo, σ)) = laddertypes::subtype_unify(
+        &dst_type,
+        &type_dict.parse("<Seq~<LengthPrefix x86.UInt64> x86.UInt8>").unwrap()
+    ) {
+        println!(r#"
+        /* write output
+         */
+        {{
+            struct LengthPrefixUInt8Array * buf = (void*){};
+            write(1, {}, sizeof(uint64_t) + buf->len);
+        }}"#, out_buf, out_buf);
+    } else {
+        println!(r#"
+write(1, {}, {});"#,
+            out_buf,
+            1024
+        );
+    }
+
+
+    println!(r#"
+return 0;
+}}
+    "#);
+
+    eprintln!("Success: generated C code");
+}
+
+impl LdmcPrimCMorphism {
+    pub fn instantiated_symbol_name(&self, dict: &mut impl TypeDict,
+        σ: &std::collections::HashMap<laddertypes::TypeID, laddertypes::TypeTerm>) -> String {
+        let mut s = self.symbol.clone();
+        for (k_id,v) in self.type_args.iter() {
+            if let Some(val_trm) = σ.get(k_id) {
+                if let laddertypes::TypeID::Var(var_id) = k_id {
+                    let name = dict.get_varname(*var_id).unwrap();
+                    let val_str = encode_type_to_symbol(dict, val_trm);
+                    s.push_str(&format!("_{}_{}", name, val_str));
+                }
+            } else {
+                if let laddertypes::TypeID::Var(var_id) = k_id {
+                    let k = dict.get_varname(*var_id).unwrap();
+                    s.push_str(&format!("_{:?}_MISSING", k));
+                    eprintln!("INCOMPLETE MORPHISM INSTANTIATION, missing {} ({})", k, var_id);
+                }
+            }
+        }
+        s
+    }
+
+    pub fn expected_c_type_signature(&self, dict: &mut impl TypeDict,
+        σ: &std::collections::HashMap<laddertypes::TypeID, laddertypes::TypeTerm>) -> String {
+        format!("int {} ({} const * restrict src, {} * restrict dst);",
+            self.instantiated_symbol_name(dict, σ),
+            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_instantiation(&self, dict: &mut impl TypeDict, σ: &std::collections::HashMap<laddertypes::TypeID, laddertypes::TypeTerm>) -> Option<String> {
+        let mut s = String::new();
+
+        s.push_str(&format!(r#"
+int {} ( {} const * restrict src, {} * restrict dst ) {{
+"#,
+            self.instantiated_symbol_name(dict, &σ),
+            get_c_repr_type(dict, self.src_type.clone().apply_substitution(&|k| σ.get(k).cloned()).clone(), true).expect("cant get c-repr-type"),
+            get_c_repr_type(dict, self.dst_type.clone().apply_substitution(&|k| σ.get(k).cloned()).clone(), true).expect("cant get c-repr-type"),
+        ));
+        for (ty_id, kind) in self.type_args.iter() {
+            if let Some(val) = σ.get(ty_id) {
+                s.push_str(&format!("    #define {} {}\n", dict.get_typename(&ty_id).unwrap(), encode_type_to_value(dict, val)));
+            }
+        }
+
+        s.push_str(&self.c_source);
+
+        for (ty_id, kind) in self.type_args.iter() {
+            s.push_str(&format!("\n    #undef {}", dict.get_typename(&ty_id).unwrap()));
+        }
+
+        s.push_str(&format!(r#"
+}}
+"#));
+        Some(s)
+    }
+}
+
+impl LdmcMorphism {
+    pub fn generate_call(&self, dict: &mut impl TypeDict, σ: &std::collections::HashMap<laddertypes::TypeID, laddertypes::TypeTerm>, i: u64) {
+        match self {
+            LdmcMorphism::Primitive(prim_morph) => {
+                let src_c_type = get_c_repr_type(dict, prim_morph.src_type.clone().apply_substitution(&|k| σ.get(k).cloned()).clone(), true).expect("cant get c-repr type for src type");
+                let dst_c_type = get_c_repr_type(dict, prim_morph.dst_type.clone().apply_substitution(&|k| σ.get(k).cloned()).clone(), true).expect("cant get c-repr type for dst type");
+
+                let src_buf = if i%2 == 0 { "bufA" } else { "bufB" };
+                let dst_buf = if i%2 == 0 { "bufB" } else { "bufA" };
+
+                println!(r#"
+    {}
+            {} const * restrict src = (void*) {};
+            {} * restrict dst = (void*) {};
+            {} ( src, dst );
+    {}"#,
+                    '{',
+                    src_c_type, src_buf,
+                    dst_c_type, dst_buf,
+                    prim_morph.instantiated_symbol_name(dict, σ),
+                    '}');
+            }
+            LdmcMorphism::LengthPrefixMap { length_prefix_type, item_morph } => {
+                let src_c_type = get_c_repr_type(dict, self.get_type().src_type.clone().apply_substitution(&|k| σ.get(k).cloned()).clone(), true).expect("cant get c-repr type for src type");
+                let dst_c_type = get_c_repr_type(dict, self.get_type().dst_type.clone().apply_substitution(&|k| σ.get(k).cloned()).clone(), true).expect("cant get c-repr type for dst type");
+
+                let map_fn = match (src_c_type.as_str(), dst_c_type.as_str()) {
+                    ("struct LengthPrefixUInt64Array", "struct LengthPrefixUInt64Array") => "length_prefix_array_map_64_to_64",
+                    ("struct LengthPrefixUInt8Array", "struct LengthPrefixUInt64Array") => "length_prefix_array_map_8_to_64",
+                    ("struct LengthPrefixUInt64Array", "struct LengthPrefixUInt8Array") => "length_prefix_array_map_64_to_8",
+                    ("struct LengthPrefixUInt8Array", "struct LengthPrefixUInt8Array") => "length_prefix_array_map_8_to_8",
+                    _ => {
+                        "{{ ERROR: no map function implemented }}"
+                    }
+                };
+
+                let src_buf = if i%2 == 0 { "bufA" } else { "bufB" };
+                let dst_buf = if i%2 == 0 { "bufB" } else { "bufA" };
+                println!(r#"
+    {}
+            {} const * restrict src = (void*) {};
+            {} * restrict dst = (void*) {};
+            {} ( {}, src, dst );
+    {}"#,
+            '{',
+                    src_c_type, src_buf,
+                    dst_c_type, dst_buf,
+                    map_fn,
+                    item_morph.instantiated_symbol_name(dict, σ),
+                    '}');
+            }
+            LdmcMorphism::ValueDelimMap { delim, item_morph } => {
+                let src_c_type = get_c_repr_type(dict, item_morph.src_type.clone(), false).expect("cant get c-repr type for src type");
+                let dst_c_type = get_c_repr_type(dict, item_morph.dst_type.clone(), false).expect("cant get c-repr type for dst type");
+
+                let src_buf = if i%2 == 0 { "bufA" } else { "bufB" };
+                let dst_buf = if i%2 == 0 { "bufB" } else { "bufA" };
+                println!(r#"
+    {}
+            {} const * restrict src = (void*) {};
+            {} * restrict dst = (void*) {};
+            value_delim_array_map_8_to_64( {}, src, dst );
+    {}"#,
+            '{',
+                    src_c_type, src_buf,
+                    dst_c_type, dst_buf,
+                    item_morph.instantiated_symbol_name(dict, σ),
+                    '}');
+            }
+        }
+    }
+}

src/main.rs

@@ -1,3 +1,8 @@
+
+mod morphism;
+mod parser;
+mod c_gen;
+
 use {
     ariadne::{Color, Label, Report, ReportKind, Source},
     chumsky::{
@@ -7,395 +12,15 @@ use {
         dict::TypeDict, parser::ParseLadderType, subtype_unify, unparser::UnparseLadderType, BimapTypeDict, Morphism, MorphismType
     },
     std::{any::Any, sync::{Arc, RwLock}},
-    tiny_ansi::TinyAnsi
+    tiny_ansi::TinyAnsi,
+
+
+    crate::{
+        morphism::LdmcMorphism,
+        parser::morphism_base_parser,
+    }
 };
 
-/*
-*/
-pub fn get_c_repr_kind(kind: String) -> Option<String> {
-    match kind.as_str() {
-        "ℤ" => Some("uint64_t".into()),
-        _ => None
-    }
-}
-
-/* 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 _length_type = args[1].clone();
-                            let item_c_type : String = get_c_repr_type(dict, args[2].clone(), false)?;
-                            match item_c_type.as_str() {
-                                "uint8_t" => Some(format!("struct LengthPrefixUInt8Array")),
-                                "uint16_t" => Some(format!("struct LengthPrefixUInt16Array")),
-                                "uint32_t" => Some(format!("struct LengthPrefixUInt32Array")),
-                                "uint64_t" => Some(format!("struct LengthPrefixUInt64Array")),
-                                _ => None
-                            }
-                        }
-                        else if args[0] == laddertypes::TypeTerm::TypeID(dict.get_typeid(&"ValueTerminated".into()).unwrap())
-                        {
-                            let _delim_val = args[1].clone();
-                            let c_type = get_c_repr_type(dict, args[2].clone(), false)?;
-                            if skip_pointer {
-                                Some(c_type)
-                            } else {
-                                Some(format!("{} *", c_type))
-                            }
-                        }
-                        else if args[0] == laddertypes::TypeTerm::TypeID(dict.get_typeid(&"MsbCont".into()).unwrap())
-                        {
-                            let c_type = get_c_repr_type(dict, args[1].clone(), false)?;
-                            if skip_pointer {
-                                Some(c_type)
-                            } else {
-                                Some(format!("{} *", c_type))
-                            }
-                        }
-                        else {
-                            None
-                        }
-                    }
-
-                    _ => None
-                }
-            }
-        }
-        None => None
-    }
-}
-
-#[derive(Clone, Debug)]
-struct LdmcPrimCMorphism {
-    symbol: String,
-    type_args: Vec<(laddertypes::TypeID, String)>,
-    src_type: laddertypes::TypeTerm,
-    dst_type: laddertypes::TypeTerm,
-    c_source: String
-}
-
-fn encode_type_to_symbol(dict: &mut impl TypeDict, t: &laddertypes::TypeTerm)-> String {
-    match t {
-        laddertypes::TypeTerm::Char(c) => {
-            match c {
-                '.' => format!("_dot_"),
-                _ =>
-                format!("{}", (*c as u64))
-            }
-        },
-        laddertypes::TypeTerm::Num(n) => {
-            format!("{}", n)
-        }
-        laddertypes::TypeTerm::TypeID(ty_id) => {
-            if let Some(name) = dict.get_typename(ty_id) {
-                format!("{}", name.replace(".", "_dot_"))
-            } else {
-                format!("")
-            }
-        }
-        laddertypes::TypeTerm::Ladder(rs) |
-        laddertypes::TypeTerm::App(rs) => {
-            let mut s = String::new();
-            for r in rs {
-                s.push('_');
-                s.push_str(&encode_type_to_symbol(dict, r));
-            }
-            s
-        }
-    }
-}
-
-fn encode_type_to_value(dict: &mut impl TypeDict, t: &laddertypes::TypeTerm) -> String {
-    dict.unparse(t)
-}
-
-impl LdmcPrimCMorphism {
-    pub fn instantiated_symbol_name(&self, dict: &mut impl TypeDict,
-        σ: &std::collections::HashMap<laddertypes::TypeID, laddertypes::TypeTerm>) -> String {
-        let mut s = self.symbol.clone();
-        for (k_id,v) in self.type_args.iter() {
-            if let Some(val_trm) = σ.get(k_id) {
-                if let laddertypes::TypeID::Var(var_id) = k_id {
-                    let name = dict.get_varname(*var_id).unwrap();
-                    let val_str = encode_type_to_symbol(dict, val_trm);
-                    s.push_str(&format!("_{}_{}", name, val_str));
-                }
-            } else {
-                if let laddertypes::TypeID::Var(var_id) = k_id {
-                    let k = dict.get_varname(*var_id).unwrap();
-                    s.push_str(&format!("_{:?}_MISSING", k));
-                    eprintln!("INCOMPLETE MORPHISM INSTANTIATION, missing {} ({})", k, var_id);
-                }
-            }
-        }
-        s
-    }
-
-    pub fn expected_c_type_signature(&self, dict: &mut impl TypeDict,
-        σ: &std::collections::HashMap<laddertypes::TypeID, laddertypes::TypeTerm>) -> String {
-        format!("int {} ({} const * restrict src, {} * restrict dst);",
-            self.instantiated_symbol_name(dict, σ),
-            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_instantiation(&self, dict: &mut impl TypeDict, σ: &std::collections::HashMap<laddertypes::TypeID, laddertypes::TypeTerm>) -> Option<String> {
-        let mut s = String::new();
-
-        s.push_str(&format!(r#"
-int {} ( {} const * restrict src, {} * restrict dst ) {{
-"#,
-            self.instantiated_symbol_name(dict, &σ),
-            get_c_repr_type(dict, self.src_type.clone().apply_substitution(&|k| σ.get(k).cloned()).clone(), true).expect("cant get c-repr-type"),
-            get_c_repr_type(dict, self.dst_type.clone().apply_substitution(&|k| σ.get(k).cloned()).clone(), true).expect("cant get c-repr-type"),
-        ));
-        for (ty_id, kind) in self.type_args.iter() {
-            if let Some(val) = σ.get(ty_id) {
-                s.push_str(&format!("    #define {} {}\n", dict.get_typename(&ty_id).unwrap(), encode_type_to_value(dict, val)));
-            }
-        }
-
-        s.push_str(&self.c_source);
-
-        for (ty_id, kind) in self.type_args.iter() {
-            s.push_str(&format!("\n    #undef {}", dict.get_typename(&ty_id).unwrap()));
-        }
-
-        s.push_str(&format!(r#"
-}}
-"#));
-        Some(s)
-    }
-}
-
-#[derive(Clone)]
-enum LdmcMorphism {
-    Primitive( LdmcPrimCMorphism ),
-    LengthPrefixMap{
-        length_prefix_type: laddertypes::TypeTerm,
-        item_morph: Box<LdmcPrimCMorphism>
-    },
-    ValueDelimMap{
-        delim: u64,
-        item_morph: Box<LdmcPrimCMorphism>
-    }
-}
-
-impl LdmcMorphism {
-    pub fn generate_call(&self, dict: &mut impl TypeDict, σ: &std::collections::HashMap<laddertypes::TypeID, laddertypes::TypeTerm>, i: u64) {
-        match self {
-            LdmcMorphism::Primitive(prim_morph) => {
-                let src_c_type = get_c_repr_type(dict, prim_morph.src_type.clone().apply_substitution(&|k| σ.get(k).cloned()).clone(), true).expect("cant get c-repr type for src type");
-                let dst_c_type = get_c_repr_type(dict, prim_morph.dst_type.clone().apply_substitution(&|k| σ.get(k).cloned()).clone(), true).expect("cant get c-repr type for dst type");
-
-                let src_buf = if i%2 == 0 { "bufA" } else { "bufB" };
-                let dst_buf = if i%2 == 0 { "bufB" } else { "bufA" };
-
-                println!(r#"
-    {}
-            {} const * restrict src = (void*) {};
-            {} * restrict dst = (void*) {};
-            {} ( src, dst );
-    {}"#,
-                    '{',
-                    src_c_type, src_buf,
-                    dst_c_type, dst_buf,
-                    prim_morph.instantiated_symbol_name(dict, σ),
-                    '}');
-            }
-            LdmcMorphism::LengthPrefixMap { length_prefix_type, item_morph } => {
-                let src_c_type = get_c_repr_type(dict, self.get_type().src_type.clone().apply_substitution(&|k| σ.get(k).cloned()).clone(), true).expect("cant get c-repr type for src type");
-                let dst_c_type = get_c_repr_type(dict, self.get_type().dst_type.clone().apply_substitution(&|k| σ.get(k).cloned()).clone(), true).expect("cant get c-repr type for dst type");
-
-                let map_fn = match (src_c_type.as_str(), dst_c_type.as_str()) {
-                    ("struct LengthPrefixUInt64Array", "struct LengthPrefixUInt64Array") => "length_prefix_array_map_64_to_64",
-                    ("struct LengthPrefixUInt8Array", "struct LengthPrefixUInt64Array") => "length_prefix_array_map_8_to_64",
-                    ("struct LengthPrefixUInt64Array", "struct LengthPrefixUInt8Array") => "length_prefix_array_map_64_to_8",
-                    ("struct LengthPrefixUInt8Array", "struct LengthPrefixUInt8Array") => "length_prefix_array_map_8_to_8",
-                    _ => {
-                        "{{ ERROR: no map function implemented }}"
-                    }
-                };
-
-                let src_buf = if i%2 == 0 { "bufA" } else { "bufB" };
-                let dst_buf = if i%2 == 0 { "bufB" } else { "bufA" };
-                println!(r#"
-    {}
-            {} const * restrict src = (void*) {};
-            {} * restrict dst = (void*) {};
-            {} ( {}, src, dst );
-    {}"#,
-            '{',
-                    src_c_type, src_buf,
-                    dst_c_type, dst_buf,
-                    map_fn,
-                    item_morph.instantiated_symbol_name(dict, σ),
-                    '}');
-            }
-            LdmcMorphism::ValueDelimMap { delim, item_morph } => {
-                let src_c_type = get_c_repr_type(dict, item_morph.src_type.clone(), false).expect("cant get c-repr type for src type");
-                let dst_c_type = get_c_repr_type(dict, item_morph.dst_type.clone(), false).expect("cant get c-repr type for dst type");
-
-                let src_buf = if i%2 == 0 { "bufA" } else { "bufB" };
-                let dst_buf = if i%2 == 0 { "bufB" } else { "bufA" };
-                println!(r#"
-    {}
-            {} const * restrict src = (void*) {};
-            {} * restrict dst = (void*) {};
-            value_delim_array_map_8_to_64( {}, src, dst );
-    {}"#,
-            '{',
-                    src_c_type, src_buf,
-                    dst_c_type, dst_buf,
-                    item_morph.instantiated_symbol_name(dict, σ),
-                    '}');
-            }
-        }
-    }
-}
-
-impl Morphism for LdmcMorphism {
-    fn weight(&self) -> u64 {
-        1
-    }
-
-    fn get_type(&self) -> laddertypes::MorphismType {
-        match self {
-            LdmcMorphism::Primitive(prim_morph) =>
-                laddertypes::MorphismType {
-                    src_type: prim_morph.src_type.clone().normalize(),
-                    dst_type: prim_morph.dst_type.clone().normalize()
-                },
-            LdmcMorphism::LengthPrefixMap{ length_prefix_type, item_morph } => {
-                laddertypes::MorphismType {
-                    src_type: laddertypes::TypeTerm::App(vec![ length_prefix_type.clone(), item_morph.src_type.clone() ]),
-                    dst_type: laddertypes::TypeTerm::App(vec![ length_prefix_type.clone(), item_morph.dst_type.clone() ]),
-                }
-            },
-            LdmcMorphism::ValueDelimMap{ delim, item_morph } => {
-                let value_delim_type = laddertypes::TypeTerm::App(vec![]);
-                laddertypes::MorphismType {
-                    src_type: laddertypes::TypeTerm::App(vec![ value_delim_type.clone(), item_morph.src_type.clone() ]),
-                    dst_type: laddertypes::TypeTerm::App(vec![ value_delim_type.clone(), item_morph.dst_type.clone() ]),
-                }
-            }
-        }.normalize()
-    }
-
-    fn map_morphism(&self, seq_type: laddertypes::TypeTerm) -> Option< Self > {
-        match self {
-            LdmcMorphism::Primitive(prim) => {
-                let item_morph = Box::new(prim.clone());
-/*
-                if seq_type == self.length_prefix_type {
-                */
-                    Some(LdmcMorphism::LengthPrefixMap{
-                        length_prefix_type: seq_type,
-                        item_morph,
-                    })
-                    /*
-                } else if seq_type == self.value_delim_type {
-                    Some(LdmcMorphism::ValueDelimMap { delim, item_morph })
-                } else {
-                    None
-                }
-                */
-            }
-            _ => None
-        }
-    }
-}
-
-/* morphism-base text format:
- *     NAME '(' [TYPE-ARG-NAME ':' KIND]  ')'
- *           SRC-TYPE
- *     '-->' DST-TYPE
- *     ```
- *          TEMPLATE-CODE
- *     ```
- */
-fn parser(
-    type_dict: Arc<RwLock< BimapTypeDict >>
-) -> impl Parser<char, (String, Vec<LdmcPrimCMorphism>), Error = Simple<char>> {
-
-    just("```")
-    .then(take_until(just("```")))
-    .map(
-        move |(a, (b, c))| {
-            b.iter().collect()
-        }
-    )
-
-    // morph name
-    .then(
-        ident().padded()
-
-    // type args
-    .then(
-        ident().padded()
-        .then_ignore(just(":").padded())
-        .then(none_of(",)").repeated().padded())
-        .separated_by(just(",").padded())
-        .delimited_by(just("("), just(")"))
-    )
-
-    // newline
-    .then_ignore(just('\n'))
-
-    // src type
-    .then(take_until(just("-->").ignored()))
-    // dst_type
-    .then(take_until(just("```")))
-
-    // c sourcecode template
-    .then(take_until(just("```")))
-
-    .map(
-        move |((((symbol, type_args), (src_type, _)), (dst_type, _)), (c_source, _))| {
-            let c_source = c_source.iter().collect();
-            let mut type_dict = type_dict.write().unwrap();
-            let type_args : Vec<_> = type_args.into_iter().map(|(v,k)| (v,k.into_iter().collect())).collect();
-            let mut ty_args = Vec::new();
-            for (var, kind) in type_args.into_iter() {
-                let var_id = type_dict.add_varname(var.clone());
-                ty_args.push((var_id, kind));
-            }
-
-            let mut src_type = type_dict.parse(&src_type.iter().collect::<String>()).expect("couldnt parse src type");
-            let mut dst_type = type_dict.parse(&dst_type.iter().collect::<String>()).expect("couldnt parse dst type");
-
-            LdmcPrimCMorphism {
-                symbol,
-                type_args: ty_args,
-                src_type,
-                dst_type,
-                c_source
-            }
-        })
-        .separated_by(text::newline())
-
-    )
-}
-
 fn main() {
     let mut type_dict = Arc::new(RwLock::new(BimapTypeDict::new()));
     let mut morphism_base = laddertypes::MorphismBase::<LdmcMorphism>::new(vec![
@@ -410,7 +35,7 @@ fn main() {
 
     for mb_path in args {
         let src = std::fs::read_to_string(mb_path.clone()).expect("read");
-        let result = parser(type_dict.clone()).parse(src.clone());
+        let result = morphism_base_parser(type_dict.clone()).parse(src.clone());
         match result {
             Ok((includes, morphisms)) => {
                 eprintln!("[{}] parse ok.", mb_path.bright_yellow());
@@ -447,118 +72,7 @@ fn main() {
 
     match path {
         Some(path) => {
-            let mut i = 0;
+            c_gen::generate_main(&mut type_dict, path, src_type, dst_type);
-
-            /* todo: collect include files from morphism base */
-            println!(r#"
-#include <stdio.h>
-#include <unistd.h>
-#include <string.h>
-#include <stdint.h>
-#include <stdbool.h>
-"#);
-
-            let mut existing_instantiations = Vec::new();
-            for morph_inst in path.iter() {
-                match &morph_inst.m {
-                    LdmcMorphism::Primitive( item_morph ) => {
-                        let name = item_morph.instantiated_symbol_name(&mut type_dict, &morph_inst.σ);
-                        if ! existing_instantiations.contains(&name) {
-                            if let Some(s) = item_morph.generate_instantiation(&mut type_dict, &morph_inst.σ) {
-                                println!("{}", s);
-                            } else {
-                                eprintln!("couldnt generate instance {}", name);
-                            }
-                            existing_instantiations.push( name );
-                        }
-                    }
-                    LdmcMorphism::LengthPrefixMap { length_prefix_type, item_morph } => {
-                        let name = item_morph.instantiated_symbol_name(&mut type_dict, &morph_inst.σ);
-                        if ! existing_instantiations.contains(&name) {
-                            if let Some(s) = item_morph.generate_instantiation(&mut type_dict, &morph_inst.σ) {
-                                println!("{}", s);
-                            } else {
-                                eprintln!("couldnt generate instance {}", name);
-                            }
-
-                            existing_instantiations.push( name );
-                        }
-                    }
-                    _ => {}
-                }
-            }
-
-            println!(r#"
-int main() {{
-    uint8_t bufA[1024];
-    uint8_t bufB[1024];
-
-    char in_str[] = "read :: {} \n";
-    char out_str[]= "write:: {} \n";
-    write(2, in_str, strlen(in_str));
-    write(2, out_str, strlen(out_str));
-
-    int l = read(0, bufA, 1024);
-    fprintf(stderr, "read  %d bytes\n", l);
-
-                "#,
-                type_dict.unparse(&src_type).replace("\\", "\\\\"),
-                type_dict.unparse(&dst_type).replace("\\", "\\\\") );
-            for morph_inst in path.iter() {
-                println!(r#"
-    /* morph to {}
-
-    ...with
-    morph {}
-     ---> {},
-    subst σ = {:?},
-    halo  Ψ = {}
-    */"#,
-                    type_dict.unparse(&morph_inst.get_type().dst_type.param_normalize().decurry()),
-                    type_dict.unparse(&morph_inst.m.get_type().src_type),
-                    type_dict.unparse(&morph_inst.m.get_type().dst_type),
-                    morph_inst.σ,
-                    type_dict.unparse(&morph_inst.halo),
-                );
-                morph_inst.m.generate_call(&mut type_dict, &morph_inst.σ, i);
-                i += 1;
-            }
-
-            let out_buf = if i%2==0 { "bufA" } else { "bufB" };
-
-            let is_string = false;
-            if let Ok((halo, σ)) = laddertypes::subtype_unify(
-                &dst_type,
-                &type_dict.parse("<Seq~<ValueTerminated 0> x86.UInt8>").unwrap()
-            ) {
-                println!(r#"
-    printf("%s\n", {});"#, out_buf);
-            } else if let Ok((halo, σ)) = laddertypes::subtype_unify(
-                &dst_type,
-                &type_dict.parse("<Seq~<LengthPrefix x86.UInt64> x86.UInt8>").unwrap()
-            ) {
-                println!(r#"
-                /* write output
-                 */
-                {{
-                    struct LengthPrefixUInt8Array * buf = (void*){};
-                    write(1, {}, sizeof(uint64_t) + buf->len);
-                }}"#, out_buf, out_buf);
-            } else {
-                println!(r#"
-    write(1, {}, {});"#,
-                    out_buf,
-                    1024
-                );
-            }
-
-
-            println!(r#"
-    return 0;
-}}
-            "#);
-
-            eprintln!("Success: generated C code");
         }
         None => {
             eprintln!("Error: could not find morphism path");

src/morphism.rs

@@ -0,0 +1,78 @@
+
+use {
+    laddertypes::{TypeDict, morphism::Morphism},
+};
+
+#[derive(Clone, Debug)]
+pub struct LdmcPrimCMorphism {
+    pub symbol: String,
+    pub type_args: Vec<(laddertypes::TypeID, String)>,
+    pub src_type: laddertypes::TypeTerm,
+    pub dst_type: laddertypes::TypeTerm,
+    pub c_source: String
+}
+
+#[derive(Clone)]
+pub enum LdmcMorphism {
+    Primitive( LdmcPrimCMorphism ),
+    LengthPrefixMap{
+        length_prefix_type: laddertypes::TypeTerm,
+        item_morph: Box<LdmcPrimCMorphism>
+    },
+    ValueDelimMap{
+        delim: u64,
+        item_morph: Box<LdmcPrimCMorphism>
+    }
+}
+
+impl Morphism for LdmcMorphism {
+    fn weight(&self) -> u64 {
+        1
+    }
+
+    fn get_type(&self) -> laddertypes::MorphismType {
+        match self {
+            LdmcMorphism::Primitive(prim_morph) =>
+                laddertypes::MorphismType {
+                    src_type: prim_morph.src_type.clone().normalize(),
+                    dst_type: prim_morph.dst_type.clone().normalize()
+                },
+            LdmcMorphism::LengthPrefixMap{ length_prefix_type, item_morph } => {
+                laddertypes::MorphismType {
+                    src_type: laddertypes::TypeTerm::App(vec![ length_prefix_type.clone(), item_morph.src_type.clone() ]),
+                    dst_type: laddertypes::TypeTerm::App(vec![ length_prefix_type.clone(), item_morph.dst_type.clone() ]),
+                }
+            },
+            LdmcMorphism::ValueDelimMap{ delim, item_morph } => {
+                let value_delim_type = laddertypes::TypeTerm::App(vec![]);
+                laddertypes::MorphismType {
+                    src_type: laddertypes::TypeTerm::App(vec![ value_delim_type.clone(), item_morph.src_type.clone() ]),
+                    dst_type: laddertypes::TypeTerm::App(vec![ value_delim_type.clone(), item_morph.dst_type.clone() ]),
+                }
+            }
+        }.normalize()
+    }
+
+    fn map_morphism(&self, seq_type: laddertypes::TypeTerm) -> Option< Self > {
+        match self {
+            LdmcMorphism::Primitive(prim) => {
+                let item_morph = Box::new(prim.clone());
+/*
+                if seq_type == self.length_prefix_type {
+                */
+                    Some(LdmcMorphism::LengthPrefixMap{
+                        length_prefix_type: seq_type,
+                        item_morph,
+                    })
+                    /*
+                } else if seq_type == self.value_delim_type {
+                    Some(LdmcMorphism::ValueDelimMap { delim, item_morph })
+                } else {
+                    None
+                }
+                */
+            }
+            _ => None
+        }
+    }
+}

src/parser.rs

@@ -0,0 +1,80 @@
+use {
+    chumsky::{
+        prelude::*, text::*
+    },
+    std::sync::{Arc, RwLock},
+
+    laddertypes::{TypeDict, BimapTypeDict, parser::*},
+    crate::morphism::LdmcPrimCMorphism
+};
+
+/* morphism-base text format:
+ *     NAME '(' [TYPE-ARG-NAME ':' KIND]  ')'
+ *           SRC-TYPE
+ *     '-->' DST-TYPE
+ *     ```
+ *          TEMPLATE-CODE
+ *     ```
+ */
+pub fn morphism_base_parser(
+    type_dict: Arc<RwLock< BimapTypeDict >>
+) -> impl Parser<char, (String, Vec<LdmcPrimCMorphism>), Error = Simple<char>> {
+
+    just("```")
+    .then(take_until(just("```")))
+    .map(
+        move |(a, (b, c))| {
+            b.iter().collect()
+        }
+    )
+
+    // morph name
+    .then(
+        ident().padded()
+
+    // type args
+    .then(
+        ident().padded()
+        .then_ignore(just(":").padded())
+        .then(none_of(",)").repeated().padded())
+        .separated_by(just(",").padded())
+        .delimited_by(just("("), just(")"))
+    )
+
+    // newline
+    .then_ignore(just('\n'))
+
+    // src type
+    .then(take_until(just("-->").ignored()))
+    // dst_type
+    .then(take_until(just("```")))
+
+    // c sourcecode template
+    .then(take_until(just("```")))
+
+    .map(
+        move |((((symbol, type_args), (src_type, _)), (dst_type, _)), (c_source, _))| {
+            let c_source = c_source.iter().collect();
+            let mut type_dict = type_dict.write().unwrap();
+            let type_args : Vec<_> = type_args.into_iter().map(|(v,k)| (v,k.into_iter().collect())).collect();
+            let mut ty_args = Vec::new();
+            for (var, kind) in type_args.into_iter() {
+                let var_id = type_dict.add_varname(var.clone());
+                ty_args.push((var_id, kind));
+            }
+
+            let mut src_type = type_dict.parse(&src_type.iter().collect::<String>()).expect("couldnt parse src type");
+            let mut dst_type = type_dict.parse(&dst_type.iter().collect::<String>()).expect("couldnt parse dst type");
+
+            LdmcPrimCMorphism {
+                symbol,
+                type_args: ty_args,
+                src_type,
+                dst_type,
+                c_source
+            }
+        })
+        .separated_by(text::newline())
+
+    )
+}