From afa326ed237dbd4a22371b61532b0b802bbde71a Mon Sep 17 00:00:00 2001 From: Michael Sippel <micha@fragmental.art> Date: Fri, 14 Feb 2025 14:07:18 +0100 Subject: [PATCH] more work on code generation --- src/main.rs | 154 ++++++++++++++++++++++++++-------------------------- 1 file changed, 77 insertions(+), 77 deletions(-) diff --git a/src/main.rs b/src/main.rs index a31db2b..34eedba 100644 --- a/src/main.rs +++ b/src/main.rs @@ -4,10 +4,7 @@ use { prelude::*, text::* }, laddertypes::{ - dict::TypeDict, - parser::ParseLadderType, - unparser::UnparseLadderType, BimapTypeDict, MorphismType, - Morphism + dict::TypeDict, parser::ParseLadderType, subtype_unify, unparser::UnparseLadderType, BimapTypeDict, Morphism, MorphismType }, std::sync::{Arc, RwLock} }; @@ -82,10 +79,6 @@ impl LdmcPrimCMorphism { 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, i: u64) { - - } } #[derive(Clone)] @@ -97,7 +90,7 @@ enum LdmcMorphism { }, ValueDelimMap{ delim: u64, - item_morph: Box<LdmcMorphism> + item_morph: Box<LdmcPrimCMorphism> } } @@ -123,6 +116,40 @@ impl LdmcMorphism { '}'); } LdmcMorphism::LengthPrefixMap { length_prefix_type, item_morph } => { + let src_c_type = get_c_repr_type(dict, self.get_type().src_type, true).expect("cant get c-repr type for src type"); + let dst_c_type = get_c_repr_type(dict, self.get_type().dst_type, 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" + }, + _ => { + "{{ 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.symbol, + '}'); + } + 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"); @@ -132,7 +159,7 @@ impl LdmcMorphism { {} {} const * restrict src = (void*) {}; {} * restrict dst = (void*) {}; - length_prefix_array_map_8_to_64( {}, src, dst ); + value_delim_array_map_8_to_64( {}, src, dst ); {}"#, '{', src_c_type, src_buf, @@ -140,9 +167,6 @@ impl LdmcMorphism { item_morph.symbol, '}'); } - LdmcMorphism::ValueDelimMap { delim, item_morph } => { - - } } } } @@ -167,20 +191,21 @@ impl Morphism for LdmcMorphism { }, LdmcMorphism::ValueDelimMap{ delim, item_morph } => { let value_delim_type = laddertypes::TypeTerm::App(vec![]); - let item_morph_type = item_morph.get_type(); laddertypes::MorphismType { - src_type: laddertypes::TypeTerm::App(vec![ value_delim_type.clone(), item_morph_type.src_type ]), - dst_type: laddertypes::TypeTerm::App(vec![ value_delim_type.clone(), item_morph_type.dst_type ]), + 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 { +/* + if seq_type == self.length_prefix_type { + */ Some(LdmcMorphism::LengthPrefixMap{ length_prefix_type: seq_type, item_morph, @@ -248,40 +273,22 @@ fn parser( fn main() { let mut type_dict = Arc::new(RwLock::new(BimapTypeDict::new())); - type_dict.add_varname("Delim".into()); let mut morphism_base = laddertypes::MorphismBase::<LdmcMorphism>::new(vec![ - type_dict.parse("Seq ~ <ValueDelim '\\0'>").expect(""), - type_dict.parse("Seq ~ <LengthPrefix x86.UInt64>").expect("") + type_dict.parse("Seq~<ValueDelim '\\0'>").expect(""), + type_dict.parse("Seq~<LengthPrefix x86.UInt64>").expect("") ]); -/* - let mut t = type_dict.parse("<Seq~<ValueDelim '\0'> Char>~<Seq~<ValueDelim '\0'> Ascii~Byte>").expect(""); - eprintln!("init :: {}\n", t.clone().sugar(&mut type_dict).pretty(&mut type_dict, 0)); - //t = t.normalize(); - //eprintln!("LNF :: {}\n", t.clone().sugar(&mut type_dict).pretty(&mut type_dict, 0)); - t = t.param_normalize(); - println!("PNF :: {}\n", t.sugar(&mut type_dict).pretty(&mut type_dict, 0)); - - return; -*/ - for mb_path in std::env::args().skip(1) { - let src = std::fs::read_to_string( - mb_path - ).expect("read"); + let mut args = std::env::args().skip(1); + let src_type_arg = args.next().expect("src type expected"); + let dst_type_arg = args.next().expect("dst type expected"); + for mb_path in args { + let src = std::fs::read_to_string(mb_path).expect("read"); let result = parser(type_dict.clone()).parse(src.clone()); match result { Ok(morphisms) => { eprintln!("parse ok."); - let mut dict = type_dict.write().unwrap(); - for m in morphisms { - /* - eprintln!("{}\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), - ); - */ morphism_base.add_morphism(LdmcMorphism::Primitive(m)); } } @@ -302,55 +309,48 @@ fn main() { } } - let path = morphism_base.find_morphism_path(MorphismType { - src_type: type_dict.parse("ℕ ~ <PosInt 10 BigEndian> ~ <Seq~<LengthPrefix x86.UInt64> <Digit 10>~x86.UInt64>").expect(""), - dst_type: type_dict.parse("ℕ ~ <PosInt 16 BigEndian> ~ <Seq~<LengthPrefix x86.UInt64> <Digit 16>~x86.UInt64>").expect(""), - }); + let path = morphism_base.find_morphism_path(MorphismType { + src_type: type_dict.parse( src_type_arg.as_str() ).expect(""), + dst_type: type_dict.parse( dst_type_arg.as_str() ).expect(""), + }, + &mut *type_dict.write().unwrap() + ); + match path { Some(path) => { - let mut path = path.into_iter(); - let mut src_type = path.next().unwrap(); - let mut i = 0; - println!(r#" #include <stdio.h> #include <stdint.h> #include <morphisms/length-prefix.h> #include <morphisms/posint.h> -int main() {} +int main() {{ uint8_t bufA[1024]; uint8_t bufB[1024]; scanf("%s", bufA); - "#, '{'); - for dst_type in path { - eprintln!("add morph from {}\nto {} - ", - src_type.clone().param_normalize().sugar(&mut type_dict).pretty(&mut type_dict, 1), - dst_type.clone().param_normalize().sugar(&mut type_dict).pretty(&mut type_dict, 1), - ); - let (m, typ, σ) = morphism_base.find_morphism_with_subtyping(&MorphismType { - src_type: src_type.param_normalize(), - dst_type: dst_type.clone().param_normalize() - }).expect("cant find morphism"); - - let dst_type = m.get_type().dst_type; - + "#); + for morph_inst in path { println!(r#" - /* morph to {} */"#, - dst_type.clone().param_normalize().decurry() - .sugar(&mut type_dict) - .pretty(&mut type_dict, 1) - ); - m.generate_call(&mut type_dict, i); - i += 1; + /* morph to {} - src_type = laddertypes::TypeTerm::Ladder(vec![ typ, dst_type ]); - src_type = src_type.normalize().apply_substitution(&|k| σ.get(k).cloned()).clone(); + ...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, i); + i += 1; } let out_buf = if i%2==0 { "bufA" } else { "bufB" }; @@ -358,8 +358,8 @@ int main() {} printf("%s\n", {}); return 0; -{} - "#, out_buf, '}'); +}} + "#, out_buf); } None => { eprintln!("Error: could not find morphism path");