syntaxAlchemist/ldmc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

wip

Browse source
This commit is contained in:
Michael Sippel 2025-05-01 06:38:17 +02:00
parent ef819b4711
commit 6787e607a6
Signed by: senvas
GPG key ID: F96CF119C34B64A6
7 changed files with 240 additions and 421 deletions

61
morphisms/runtime/include/array/length-prefix.h
View file

@ -7,22 +7,22 @@
typedef struct { \
LEN_TYPE len; \
ITEM_TYPE items[]; \
} LengthPrefix_##LEN_TYPE##_Array_##ITEM_TYPE; \
} __Seq__LengthPrefix_##LEN_TYPE##___##ITEM_TYPE##_; \
\
static inline void length_prefix_##LEN_TYPE##_array_##ITEM_TYPE##_clear( \
LengthPrefix_##LEN_TYPE##_Array_##ITEM_TYPE *data) { \
__Seq__LengthPrefix_##LEN_TYPE##___##ITEM_TYPE##_ *data) { \
data->len = 0; \
} \
\
static inline void length_prefix_##LEN_TYPE##_array_##ITEM_TYPE##_push( \
LengthPrefix_##LEN_TYPE##_Array_##ITEM_TYPE *data, \
__Seq__LengthPrefix_##LEN_TYPE##___##ITEM_TYPE##_ *data, \
ITEM_TYPE value) { \
data->items[data->len++] = value; \
} \
\
static inline int length_prefix_##LEN_TYPE##_array_##ITEM_TYPE##_reverse( \
LengthPrefix_##LEN_TYPE##_Array_##ITEM_TYPE const * restrict src, \
LengthPrefix_##LEN_TYPE##_Array_##ITEM_TYPE *restrict dst) { \
__Seq__LengthPrefix_##LEN_TYPE##___##ITEM_TYPE##_ const * restrict src, \
__Seq__LengthPrefix_##LEN_TYPE##___##ITEM_TYPE##_ *restrict dst) { \
for (LEN_TYPE i = 0; i < src->len; i++) { \
dst->items[i] = src->items[src->len - 1 - i]; \
} \
@ -31,59 +31,10 @@
} \
\
static inline void length_prefix_##LEN_TYPE##_array_##ITEM_TYPE##_dump( \
LengthPrefix_##LEN_TYPE##_Array_##ITEM_TYPE const * data) { \
__Seq__LengthPrefix_##LEN_TYPE##___##ITEM_TYPE##_ const * data) { \
printf("Length: %llu\n", (unsigned long long) data->len); \
for (LEN_TYPE i = 0; i < data->len; i++) { \
printf("%llu ", (unsigned long long) data->items[i]); \
} \
printf("\n"); \
}
#define DEFINE_ALL_LENGTH_PREFIX_ARRAYS(LEN_TYPE) \
DEFINE_LENGTH_PREFIX_ARRAY(LEN_TYPE, uint8_t) \
DEFINE_LENGTH_PREFIX_ARRAY(LEN_TYPE, uint16_t) \
DEFINE_LENGTH_PREFIX_ARRAY(LEN_TYPE, uint32_t) \
DEFINE_LENGTH_PREFIX_ARRAY(LEN_TYPE, uint64_t)
DEFINE_ALL_LENGTH_PREFIX_ARRAYS(uint8_t)
DEFINE_ALL_LENGTH_PREFIX_ARRAYS(uint16_t)
DEFINE_ALL_LENGTH_PREFIX_ARRAYS(uint32_t)
DEFINE_ALL_LENGTH_PREFIX_ARRAYS(uint64_t)
#define DEFINE_LENGTH_PREFIX_ARRAY_MAP(LEN_TYPE, SRC_ITEM_TYPE, DST_ITEM_TYPE) \
static inline int length_prefix_##LEN_TYPE##_array_map_##SRC_ITEM_TYPE##_to_##DST_ITEM_TYPE( \
int (*f)(SRC_ITEM_TYPE const * restrict, DST_ITEM_TYPE * restrict), \
LengthPrefix_##LEN_TYPE##_Array_##SRC_ITEM_TYPE const * restrict src, \
LengthPrefix_##LEN_TYPE##_Array_##DST_ITEM_TYPE * restrict dst) \
{ \
if (dst->len < src->len) return -1; /* Ensure enough space */ \
for (LEN_TYPE i = 0; i < src->len; i++) { \
if (f(&src->items[i], &dst->items[i]) != 0) return -1; \
} \
dst->len = src->len; \
return 0; \
}
#define DEFINE_ALL_MAPS(LEN_TYPE) \
DEFINE_LENGTH_PREFIX_ARRAY_MAP(LEN_TYPE, uint8_t, uint8_t) \
DEFINE_LENGTH_PREFIX_ARRAY_MAP(LEN_TYPE, uint8_t, uint16_t) \
DEFINE_LENGTH_PREFIX_ARRAY_MAP(LEN_TYPE, uint8_t, uint32_t) \
DEFINE_LENGTH_PREFIX_ARRAY_MAP(LEN_TYPE, uint8_t, uint64_t) \
DEFINE_LENGTH_PREFIX_ARRAY_MAP(LEN_TYPE, uint16_t, uint8_t) \
DEFINE_LENGTH_PREFIX_ARRAY_MAP(LEN_TYPE, uint16_t, uint16_t) \
DEFINE_LENGTH_PREFIX_ARRAY_MAP(LEN_TYPE, uint16_t, uint32_t) \
DEFINE_LENGTH_PREFIX_ARRAY_MAP(LEN_TYPE, uint16_t, uint64_t) \
DEFINE_LENGTH_PREFIX_ARRAY_MAP(LEN_TYPE, uint32_t, uint8_t) \
DEFINE_LENGTH_PREFIX_ARRAY_MAP(LEN_TYPE, uint32_t, uint16_t) \
DEFINE_LENGTH_PREFIX_ARRAY_MAP(LEN_TYPE, uint32_t, uint32_t) \
DEFINE_LENGTH_PREFIX_ARRAY_MAP(LEN_TYPE, uint32_t, uint64_t) \
DEFINE_LENGTH_PREFIX_ARRAY_MAP(LEN_TYPE, uint64_t, uint8_t) \
DEFINE_LENGTH_PREFIX_ARRAY_MAP(LEN_TYPE, uint64_t, uint16_t) \
DEFINE_LENGTH_PREFIX_ARRAY_MAP(LEN_TYPE, uint64_t, uint32_t) \
DEFINE_LENGTH_PREFIX_ARRAY_MAP(LEN_TYPE, uint64_t, uint64_t)
DEFINE_ALL_MAPS(uint8_t)
DEFINE_ALL_MAPS(uint16_t)
DEFINE_ALL_MAPS(uint32_t)
DEFINE_ALL_MAPS(uint64_t)

223
src/c_gen.rs
View file

@ -1,9 +1,16 @@
use {
crate::{c_gen_types::{encode_morph_type_to_symbol, encode_type_to_arg_ty, encode_type_to_symbol, encode_type_to_value, get_c_repr_type}, morphism::LdmcPrimMorph, struct_layout::{get_type_size, LayoutType, ObjectSize, StructLayout}}, chumsky::{chain::Chain, primitive::Container}, laddertypes::{morphism::{Morphism, MorphismInstance}, morphism_sugared::{MorphismInstance2, SugaredMorphism, SugaredMorphismType}, parser::*, substitution_sugared::SugaredSubstitution, unparser::*, Substitution, SugaredEnumVariant, SugaredStructMember, SugaredTypeTerm, TypeDict, TypeTerm}, std::collections::HashMap
crate::{c_gen_types::{encode_morph_type_to_symbol, encode_type_to_value, get_c_repr_arg_type,
get_c_repr_definition, get_c_repr_type}, morphism::LdmcPrimMorph,
struct_layout::{get_type_size, LayoutType, ObjectSize, StructLayout}},
chumsky::{chain::Chain, primitive::Container},
laddertypes::{morphism::{MorphismInstance, Morphism, MorphismType},
parser::*, substitution::Substitution, unparser::*,
EnumVariant, StructMember, TypeTerm, TypeDict, DesugaredTypeTerm},
std::collections::HashMap
};
impl LdmcPrimMorph {
pub fn instantiated_symbol_name(&self, dict: &mut impl TypeDict, σ: &impl SugaredSubstitution) -> String {
pub fn instantiated_symbol_name(&self, dict: &mut impl TypeDict, σ: &impl Substitution) -> String {
let mut s = self.symbol.clone();
for (k_id,v) in self.type_args.iter() {
@ -14,7 +21,7 @@ impl LdmcPrimMorph {
//self.get_type().strip_halo().dst_type.contains_var(*var_id) {
let name = dict.get_varname(*var_id).unwrap();
let val_str = encode_type_to_symbol(dict, &val_trm);
let val_str = get_c_repr_type(dict, &val_trm);
s.push_str(&format!("_{}_{}", name, val_str));
//}
@ -31,20 +38,26 @@ impl LdmcPrimMorph {
}
pub fn expected_c_type_signature(&self, dict: &mut impl TypeDict,
σ: &std::collections::HashMap<laddertypes::TypeID, laddertypes::SugaredTypeTerm>
σ: &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.ty.src_type.clone(), true).expect("cant get c-repr type for src type"),
get_c_repr_type(dict, self.ty.dst_type.clone(), true).expect("cant get c-repr type for dst type"))
get_c_repr_definition(dict, self.ty.src_type.clone(), true).expect("cant get c-repr type for src type"),
get_c_repr_definition(dict, self.ty.dst_type.clone(), true).expect("cant get c-repr type for dst type"))
}
pub fn generate_instantiation(&self, dict: &mut impl TypeDict, σ: &impl SugaredSubstitution) -> Option<String> {
pub fn generate_instantiation(&self, dict: &mut impl TypeDict, σ: &impl Substitution) -> Option<String> {
let mut s = String::new();
let symbol = self.instantiated_symbol_name(dict, σ);
let src_c_symbol = encode_type_to_arg_ty(dict, &self.ty.strip_halo().src_type.clone().apply_subst(σ).get_floor_type().1);
let dst_c_symbol = encode_type_to_arg_ty(dict, &self.ty.strip_halo().dst_type.clone().apply_subst(σ).get_floor_type().1);
eprintln!("generate instantiation:");
let ty = self.ty.clone();
eprintln!("full type: {} ----> {}", ty.src_type.pretty(dict, 0), ty.dst_type.pretty(dict,0));
let ty = ty.strip_halo().apply_subst(σ);
eprintln!("stripped type: {} ----> {}", ty.src_type.pretty(dict, 0), ty.dst_type.pretty(dict,0));
let src_c_symbol = get_c_repr_arg_type(dict, &ty.src_type);
let dst_c_symbol = get_c_repr_arg_type(dict, &ty.dst_type);
s.push_str(&format!(r#"
int {} ( {} const * restrict src, {} * restrict dst ) {{
@ -66,8 +79,9 @@ int {} ( {} const * restrict src, {} * restrict dst ) {{
pub struct LdmcCTargetMorph {
includes: Vec< String >,
active_types: Vec< SugaredTypeTerm >,
active_types: Vec< TypeTerm >,
active_instantiations: Vec< LdmcPrimMorph >,
macro_calls: Vec< String >
}
impl LdmcCTargetMorph {
@ -75,18 +89,42 @@ impl LdmcCTargetMorph {
LdmcCTargetMorph {
includes: vec![
"#include <stdint.h>".into(),
"#include <array/length-prefix.h>".into(),
"#define FUSE(morph, src, dst) { int result = morph(src,dst); if(result) return result; }".into(),
],
active_instantiations: Vec::new(),
active_types: Vec::new(),
macro_calls: Vec::new()
}
}
pub fn add_type(&mut self, ty: SugaredTypeTerm) {
pub fn add_type(&mut self, dict: &mut impl TypeDict, ty: TypeTerm) {
let ty = ty.strip();
if ! self.active_types.contains(&ty) {
eprintln!("add type {:?}", ty);
match &ty {
SugaredTypeTerm::Seq { seq_repr, items } =>{
self.add_type(items.first().unwrap().clone());
TypeTerm::Seq { seq_repr, items } =>{
let item_type = items.first().unwrap().clone();
self.add_type(dict, item_type.clone());
if let Some(seq_repr) = seq_repr {
dict.add_varname("LengthType".into());
if let Ok(σ) =
laddertypes::constraint_system::unify(
seq_repr.as_ref(),
&dict.parse_desugared("<LengthPrefix LengthType>").expect("").sugar(dict)
)
{
let length_type = σ.get(&dict.get_typeid(&"LengthType".into()).expect("")).expect("cant get Length type");
self.add_type(dict, length_type.clone());
self.macro_calls.push(
format!("DEFINE_LENGTH_PREFIX_ARRAY({}, {})\n",
get_c_repr_type(dict, &length_type),
get_c_repr_type(dict, &item_type)
)
);
}
}
}
_=>{}
}
@ -97,7 +135,7 @@ impl LdmcCTargetMorph {
pub fn add_instantiation(
&mut self,
dict: &mut impl TypeDict,
morph: MorphismInstance2<LdmcPrimMorph>,
morph: MorphismInstance<LdmcPrimMorph>,
) -> Result<LdmcPrimMorph, ()> {
let new_inst = self.bake_morphism(dict, morph)?;
if ! self.active_instantiations.contains(&new_inst) {
@ -105,44 +143,58 @@ impl LdmcCTargetMorph {
}
let ty = new_inst.get_type().strip_halo();
self.add_type(ty.src_type.get_floor_type().1);
self.add_type(ty.dst_type.get_floor_type().1);
self.add_type(dict, ty.src_type);
self.add_type(dict, ty.dst_type);
Ok(new_inst)
}
pub fn into_c_source(self, dict: &mut impl TypeDict) -> String {
pub fn into_c_source(mut self, dict: &mut impl TypeDict) -> String {
let mut source = String::new();
self.includes.dedup();
self.macro_calls.dedup();
self.active_types.dedup();
for inc in self.includes {
source.push_str(&inc);
source.push('\n');
}
source.push('\n');
for ty in self.active_types {
source.push_str(&format!("
typedef {} {};
",
get_c_repr_type(dict, ty.clone(), false).expect(&format!("cant get c-repr type for type '{}'", ty.pretty(dict,0))),
encode_type_to_symbol(dict, &ty)));
if let Some(type_def) = get_c_repr_definition(dict, ty.clone(), false) {
let type_name = get_c_repr_type(dict, &ty);
source.push_str(&format!("typedef {} {};\n", type_def, type_name));
} else {
eprintln!("cant get c-repr type for type '{}'", ty.pretty(dict,0));
}
}
source.push('\n');
for m in self.macro_calls {
source.push_str(&m);
source.push('\n');
}
source.push('\n');
for m in self.active_instantiations {
source.push_str(&m.generate_instantiation(dict, &HashMap::new()).expect("cant create function"));
}
source
}
pub fn bake_morphism(
&mut self,
dict: &mut impl laddertypes::TypeDict,
morph_inst: MorphismInstance2<LdmcPrimMorph>,
morph_inst: MorphismInstance<LdmcPrimMorph>,
) -> Result<LdmcPrimMorph, ()> {
eprintln!("bake morphism: {}
------> {}", morph_inst.get_haloless_type().src_type.pretty(dict,0), morph_inst.get_haloless_type().dst_type.pretty(dict, 0));
let ty = morph_inst.get_type();
let symbol = encode_morph_type_to_symbol(dict, &ty);
match &morph_inst {
MorphismInstance2::Primitive { ψ, σ, morph } => {
MorphismInstance::Primitive { ψ, σ, morph } => {
let mut c_source = String::new();
for (ty_id, kind) in morph.type_args.iter() {
if let laddertypes::TypeID::Var(var_id) = ty_id {
@ -150,7 +202,7 @@ impl LdmcCTargetMorph {
//morph_inst.get_type().strip_halo().dst_type.contains_var(*var_id) {
if let Some(val) = σ.get(ty_id) {
let type_var_value =
if let Some(c_repr_type) = get_c_repr_type(dict, val.clone(), true) {
if let Some(c_repr_type) = get_c_repr_definition(dict, val.clone(), true) {
c_repr_type
} else {
encode_type_to_value(dict, &val)
@ -179,10 +231,7 @@ impl LdmcCTargetMorph {
c_source
})
},
MorphismInstance2::Chain { path } => {
let ty = morph_inst.get_type().strip_halo();
let symbol = encode_morph_type_to_symbol(dict, &ty);
MorphismInstance::Chain { path } => {
let mut c_source = String::new();
if path.len() > 1 {
@ -195,8 +244,8 @@ impl LdmcCTargetMorph {
for (i,morph) in path.iter().enumerate() {
if let Ok(inst) = self.add_instantiation(dict, morph.clone()) {
let morph_symbol = inst.instantiated_symbol_name(dict, &morph.get_subst());
let src_buf = if i == 0 { "src" } else if i%2 == 0 { "(void*)bufA" } else { "(void*)bufB" };
let dst_buf = if i+1 == path.len() { "dst" } else if i%2 == 0 { "(void*)bufB" } else { "(void*)bufA" };
let src_buf = if i == 0 { "(void*)src" } else if i%2 == 0 { "(void*)bufA" } else { "(void*)bufB" };
let dst_buf = if i+1 == path.len() { "(void*)dst" } else if i%2 == 0 { "(void*)bufB" } else { "(void*)bufA" };
c_source.push_str(&format!(r#"
FUSE( {}, {}, {} );"#,
@ -213,30 +262,28 @@ impl LdmcCTargetMorph {
c_source
})
}
MorphismInstance2::MapSeq { ψ, seq_repr, item_morph } => {
MorphismInstance::MapSeq { ψ, seq_repr, item_morph } => {
if let Ok(item_morph_inst) = self.add_instantiation(dict, item_morph.as_ref().clone()) {
if let Some(seq_repr) = seq_repr {
dict.add_varname("Length".into());
dict.add_varname("LengthType".into());
dict.add_varname("TerminatorValue".into());
if let Ok(γ) = laddertypes::unification_sugared::unify(
&dict.parse("<StaticLength Length>").expect("parse type template").sugar(dict),
if let Ok(γ) = laddertypes::constraint_system::unify(
&dict.parse_desugared("<StaticLength Length>").expect("parse type template").sugar(dict),
seq_repr.as_ref()
) {
let length = γ.get(&dict.get_typeid(&"Length".into()).expect("")).expect("cant get Length");
match length {
SugaredTypeTerm::Num(l) => {
let ty = morph_inst.get_type().strip_halo();
let symbol = encode_morph_type_to_symbol(dict, &morph_inst.get_type());
TypeTerm::Num(l) => {
let item_morph_symbol = item_morph_inst.instantiated_symbol_name(dict, &HashMap::new());
self.add_type( morph_inst.get_type().strip_halo().src_type );
self.add_type( morph_inst.get_type().strip_halo().dst_type );
self.add_type( dict, morph_inst.get_type().strip_halo().src_type );
self.add_type( dict, morph_inst.get_type().strip_halo().dst_type );
let c_source = format!(r#"
for( size_t i = 0; i < {}; ++i ) {{
FUSE( {}, &src[i], &dst[i] );
FUSE( {}, &src->items[i], &dst->items[i] );
}}
"#,
l,
@ -255,19 +302,16 @@ impl LdmcCTargetMorph {
}
}
else if let Ok(γ) = laddertypes::unification_sugared::unify(
&dict.parse("<LengthPrefix LengthType>").expect("parse type template").sugar(dict),
else if let Ok(γ) = laddertypes::constraint_system::unify(
&dict.parse_desugared("<LengthPrefix LengthType>").expect("parse type template").sugar(dict),
seq_repr.as_ref()
) {
// todo: assert that length type is native.UIntX
//let length_type = γ.get(&dict.get_typeid(&"LengthType".into()).expect("")).expect("cant get LengthType");
let ty = morph_inst.get_type().strip_halo();
let symbol = encode_morph_type_to_symbol(dict, &morph_inst.get_type());
let item_morph_symbol = item_morph_inst.instantiated_symbol_name(dict, &HashMap::new());
self.add_type( morph_inst.get_type().strip_halo().src_type );
self.add_type( morph_inst.get_type().strip_halo().dst_type );
self.add_type( dict, morph_inst.get_type().strip_halo().src_type );
self.add_type( dict, morph_inst.get_type().strip_halo().dst_type );
let c_source = format!(r#"
for( size_t i = 0; i < src->len; ++i ) {{
@ -284,13 +328,11 @@ impl LdmcCTargetMorph {
})
}
else if let Ok(γ) = laddertypes::unification_sugared::unify(
&dict.parse("<ValueTerminated TerminatorValue>").expect("parse type template").sugar(dict),
else if let Ok(γ) = laddertypes::constraint_system::unify(
&dict.parse_desugared("<ValueTerminated TerminatorValue>").expect("parse type template").sugar(dict),
seq_repr.as_ref()
) {
let terminator_value = γ.get(&dict.get_typeid(&"TerminatorValue".into()).expect("")).expect("cant get TerminatorValue");
let ty = morph_inst.get_type().strip_halo();
let symbol = encode_morph_type_to_symbol(dict, &morph_inst.get_haloless_type());
let item_morph_symbol = item_morph_inst.instantiated_symbol_name(dict, &HashMap::new());
let terminator = encode_type_to_value(dict, terminator_value);
@ -326,9 +368,7 @@ impl LdmcCTargetMorph {
Err(())
}
},
MorphismInstance2::MapStruct { ψ, struct_repr, member_morph } => {
let ty = morph_inst.get_type().strip_halo();
let symbol =encode_morph_type_to_symbol(dict, &morph_inst.get_haloless_type());
MorphismInstance::MapStruct { ψ, src_struct_repr, dst_struct_repr, member_morph } => {
let mut c_source = String::new();
@ -337,8 +377,7 @@ impl LdmcCTargetMorph {
let name = name.replace("-", "_").replace(".","_dot_");
c_source.push_str(
&format!("
FUSE( {}, &src->{}, &dst->{} );
",
FUSE( {}, &src->{}, &dst->{} );",
inst.symbol,
name, name
));
@ -354,49 +393,53 @@ impl LdmcCTargetMorph {
c_source
})
}
MorphismInstance2::MapEnum { ψ, enum_repr, variant_morph } => {
MorphismInstance::MapEnum { ψ, enum_repr, variant_morph } => {
todo!();
}
}
}
}
pub fn generate_main(dict: &mut impl TypeDict, morph: MorphismInstance2<LdmcPrimMorph>) -> Result<String, ()> {
pub fn generate_main(dict: &mut impl TypeDict, morph: MorphismInstance<LdmcPrimMorph>) -> Result<String, ()> {
let mut target = LdmcCTargetMorph::new();
let ty = morph.get_type();
if let Ok(inst) = target.add_instantiation(dict, morph) {
let mut c_source = target.into_c_source(dict);
match target.add_instantiation(dict, morph) {
Ok(inst) => {
let mut c_source = target.into_c_source(dict);
c_source.push_str(&format!(r#"
#include <unistd.h>
c_source.push_str(&format!(r#"
#include <unistd.h>
int main() {{
uint8_t bufIn[4096];
uint8_t bufOut[4096];"#));
int main() {{
uint8_t bufIn[4096];
uint8_t bufOut[4096];"#));
let (src_top, src_floor) = ty.src_type.get_floor_type();
if src_floor == dict.parse("<Seq~<ValueTerminated 0> native.UInt8>").expect("").sugar(dict) {
c_source.push_str("scanf(\"%s\", bufIn);");
} else {
c_source.push_str("read(0, bufIn, sizeof(bufIn));");
let (src_top, src_floor) = ty.src_type.get_floor_type();
if src_floor == dict.parse_desugared("<Seq~<ValueTerminated 0> native.UInt8>").expect("").sugar(dict) {
c_source.push_str("scanf(\"%s\", bufIn);");
} else {
c_source.push_str("read(0, bufIn, sizeof(bufIn));");
}
c_source.push_str(&format!(r#"FUSE( {}, (void const*)bufIn, (void*)bufOut );"#, inst.instantiated_symbol_name(dict, &HashMap::new())));
if let Ok(ψ) = laddertypes::constraint_system::subtype_unify(
&ty.src_type,
&dict.parse_desugared("<Seq~<ValueTerminated 0> native.UInt8>").expect("").sugar(dict)
) {
c_source.push_str("printf(\"%s\\n\", bufOut);");
} else {
c_source.push_str("write(1, bufOut, sizeof(bufOut));");
}
c_source.push_str("
return 0;
}");
Ok(c_source)
}
c_source.push_str(&format!(r#"FUSE( {}, (void const*)bufIn, (void*)bufOut );"#, inst.instantiated_symbol_name(dict, &HashMap::new())));
if let Ok(ψ) = laddertypes::unification_sugared::subtype_unify(
&ty.src_type,
&dict.parse("<Seq~<ValueTerminated 0> native.UInt8>").expect("").sugar(dict)
) {
c_source.push_str("printf(\"%s\\n\", bufOut);");
} else {
c_source.push_str("write(1, bufOut, sizeof(bufOut));");
Err(err) => {
eprintln!("failed to create morphism instatiation");
Err(())
}
c_source.push_str("
return 0;
}");
Ok(c_source)
} else {
Err(())
}
}

148
src/c_gen_types.rs
View file

@ -1,5 +1,9 @@
use {
crate::{morphism::LdmcPrimMorph, struct_layout::{get_type_size, LayoutType, ObjectSize, StructLayout}}, chumsky::chain::Chain, laddertypes::{morphism::{Morphism, MorphismInstance}, morphism_sugared::{MorphismInstance2, SugaredMorphismType}, parser::*, substitution_sugared::SugaredSubstitution, unparser::*, Substitution, SugaredEnumVariant, SugaredStructMember, SugaredTypeTerm, TypeDict, TypeTerm}
crate::{morphism::LdmcPrimMorph, struct_layout::{get_type_size, LayoutType, ObjectSize, StructLayout}},
chumsky::chain::Chain, laddertypes::{morphism::{MorphismInstance, MorphismType},
parser::*,
substitution::Substitution,
unparser::*, EnumVariant, StructMember, TypeTerm, TypeDict, DesugaredTypeTerm}, std::thread::yield_now
};
/*
@ -13,9 +17,9 @@ pub fn get_c_repr_kind(kind: String) -> Option<String> {
/* for a given ladder type `t`, get the corresponding C type
*/
pub fn get_c_repr_type(dict: &mut impl TypeDict, t: SugaredTypeTerm, skip_pointer: bool) -> Option<String> {
match t.get_floor_type().1.strip() {
SugaredTypeTerm::TypeID(tyid) => {
pub fn get_c_repr_definition(dict: &mut impl TypeDict, t: TypeTerm, skip_pointer: bool) -> Option<String> {
match t {
TypeTerm::TypeID(tyid) => {
if tyid == dict.get_typeid_creat("native.UInt8") {
Some("uint8_t".into())
} else if tyid == dict.get_typeid_creat("native.UInt16") {
@ -35,20 +39,18 @@ pub fn get_c_repr_type(dict: &mut impl TypeDict, t: SugaredTypeTerm, skip_pointe
}
}
SugaredTypeTerm::Seq{ seq_repr, items } => {
if let Some(sr_sugar) = seq_repr {
let sr = sr_sugar.desugar(dict);
TypeTerm::Seq{ seq_repr, items } => {
if let Some(seq_repr) = seq_repr {
let item_type = items.first().expect("no item type specified!").clone();
let item_c_type : String = get_c_repr_type(dict, item_type, false).expect("cant get item type representation");
let item_c_type : String = get_c_repr_type(dict, &item_type);
dict.add_varname("Length".into()); // Kind: Num
dict.add_varname("LengthType".into()); // Kind: Type
dict.add_varname("TermValue".into()); // Kind: Value of Type ItemType
if let Ok(σ) = laddertypes::unify(
&sr,
&dict.parse("<StaticLength Length>").expect("parse")
if let Ok((ψ, σ)) = laddertypes::constraint_system::subtype_unify(
seq_repr.as_ref(),
&dict.parse_desugared("<StaticLength Length>").expect("parse template type").sugar(dict)
) {
let length = match
σ.get(
@ -61,46 +63,23 @@ pub fn get_c_repr_type(dict: &mut impl TypeDict, t: SugaredTypeTerm, skip_pointe
return None;
}
};
Some(format!("{}[{}]", item_c_type, length))
Some(format!("struct {{ {} items[{}]; }} ", item_c_type, length))
}
else if let Ok(σ) = laddertypes::unify(
&sr,
&dict.parse("<LengthPrefix LengthType>").expect("parse")
else if let Ok((ψ, σ)) = laddertypes::constraint_system::subtype_unify(
seq_repr.as_ref(),
&dict.parse_desugared("<LengthPrefix LengthType>").expect("parse template type").sugar(dict)
) {
let length_type = σ.get(
&dict.get_typeid(&"LengthType".into()).expect("no LengthType ID")
).expect("no length type specified")
.clone()
.sugar(dict);
let length_c_type : String = get_c_repr_type(dict, length_type, false).expect("cant get length type representation");
).expect("no length type specified");
match length_c_type.as_str() {
"uint8_t" |
"uint16_t" |
"uint32_t" |
"uint64_t" => {}
s => {
eprintln!("invalid length type '{}' !", s);
return None;
}
}
match item_c_type.as_str() {
"uint8_t" |
"uint16_t" |
"uint32_t" |
"uint64_t" |
"void*" => {}
s => {
eprintln!("invalid item type '{}'!", s);
return None;
}
}
let length_c_type = get_c_repr_type(dict, &length_type);
Some(format!("LengthPrefix_{}_Array_{}", length_c_type, item_c_type))
Some(format!("struct {{ {} len; {} items[]; }} ", length_c_type, item_c_type))
}
else if let Ok(σ) = laddertypes::unify(
&sr,
&dict.parse("<ValueTerminated TermValue>").expect("")
else if let Ok((ψ, σ)) = laddertypes::constraint_system::subtype_unify(
seq_repr.as_ref(),
&dict.parse_desugared("<ValueTerminated TermValue>").expect("parse template type").sugar(dict)
) {
if skip_pointer {
Some(item_c_type)
@ -109,7 +88,7 @@ pub fn get_c_repr_type(dict: &mut impl TypeDict, t: SugaredTypeTerm, skip_pointe
}
}
else {
eprintln!("can't get C-repr for sequence type `{}`!", dict.unparse(&sr));
eprintln!("can't get C-repr for sequence type `{}`!", seq_repr.pretty(dict, 0));
None
}
} else {
@ -118,7 +97,7 @@ pub fn get_c_repr_type(dict: &mut impl TypeDict, t: SugaredTypeTerm, skip_pointe
}
}
SugaredTypeTerm::Struct{ struct_repr, members } => {
TypeTerm::Struct{ struct_repr, members } => {
let c_struct_attribute =
if let Some(sr) = struct_repr {
let sr = sr.desugar(dict);
@ -130,8 +109,8 @@ pub fn get_c_repr_type(dict: &mut impl TypeDict, t: SugaredTypeTerm, skip_pointe
let mut c_type = format!("struct {} {{\n", c_struct_attribute);
for SugaredStructMember{ symbol, ty } in members {
let field_c_type = get_c_repr_type(dict, ty, false).expect("");
for StructMember{ symbol, ty } in members {
let field_c_type = get_c_repr_definition(dict, ty, false).expect("");
c_type.push_str(&format!(" {} {};\n",
field_c_type,
symbol.replace("-", "_").replace(".","_dot_")
@ -142,13 +121,13 @@ pub fn get_c_repr_type(dict: &mut impl TypeDict, t: SugaredTypeTerm, skip_pointe
Some(c_type)
}
SugaredTypeTerm::Enum { enum_repr, variants } => {
TypeTerm::Enum { enum_repr, variants } => {
let mut c_type = format!("
struct {{
enum {{
");
for (i, SugaredEnumVariant{ symbol, ty }) in variants.iter().enumerate() {
for (i, EnumVariant{ symbol, ty }) in variants.iter().enumerate() {
c_type.push_str(&format!(
" {} = {}", symbol.replace("-", "_").replace(".","_dot_").to_uppercase(), i
));
@ -164,8 +143,8 @@ struct {{
union {
");
for SugaredEnumVariant{ symbol, ty } in variants {
let variant_c_type = get_c_repr_type(dict, ty, false).expect("cant get C-Repr type for variant");
for EnumVariant{ symbol, ty } in variants {
let variant_c_type = get_c_repr_definition(dict, ty, false).expect("cant get C-Repr type for variant");
c_type.push_str(&format!(
" {} {};\n", variant_c_type, symbol.replace("-", "_").replace(".","_dot_")
));
@ -178,9 +157,9 @@ struct {{
Some(c_type)
}
SugaredTypeTerm::Ladder(rungs) => {
TypeTerm::Ladder(rungs) => {
if let Some(t) = rungs.last() {
get_c_repr_type(dict, t.clone(), false)
get_c_repr_definition(dict, t.clone(), false)
} else {
None
}
@ -190,10 +169,11 @@ struct {{
}
}
pub fn encode_type_to_symbol(dict: &mut impl TypeDict, t: &laddertypes::SugaredTypeTerm)-> String {
let t = t.clone().desugar(dict);
match t {
laddertypes::TypeTerm::Char(c) => {
pub fn get_c_repr_type(dict: &mut impl TypeDict, t: &laddertypes::TypeTerm)-> String {
let t = t.clone().strip();
match t.desugar(dict) {
laddertypes::DesugaredTypeTerm::Char(c) => {
match c {
'.' => format!("_dot_"),
'-' => format!("_minus_"),
@ -201,57 +181,61 @@ pub fn encode_type_to_symbol(dict: &mut impl TypeDict, t: &laddertypes::SugaredT
format!("{}", (c as u64))
}
},
laddertypes::TypeTerm::Num(n) => {
laddertypes::DesugaredTypeTerm::Num(n) => {
format!("{}", n)
}
laddertypes::TypeTerm::TypeID(ty_id) => {
laddertypes::DesugaredTypeTerm::TypeID(ty_id) => {
if let Some(name) = dict.get_typename(&ty_id) {
name
.replace("-", "_")
.replace(".", "_dot_")
.replace(".", "")
} else {
format!("")
}
}
laddertypes::TypeTerm::Ladder(rs) |
laddertypes::TypeTerm::App(rs) => {
laddertypes::DesugaredTypeTerm::Ladder(rs) |
laddertypes::DesugaredTypeTerm::App(rs) => {
let mut s = String::new();
s.push('_');
for r in rs {
s.push('_');
let r = r.sugar(dict);
s.push_str(&encode_type_to_symbol(dict, &r));
s.push_str(&get_c_repr_type(dict, &r));
s.push('_');
}
s
}
}
}
pub fn encode_type_to_arg_ty(dict: &mut impl TypeDict, t: &laddertypes::SugaredTypeTerm) -> String {
match t.get_floor_type().1 {
SugaredTypeTerm::Seq { seq_repr, items } => {
if let Some(seq_repr) = seq_repr {
if seq_repr.as_ref() == &dict.parse("<ValueTerminated 0>").expect("").sugar(dict) {
return encode_type_to_symbol(dict, items.first().unwrap());
pub fn get_c_repr_arg_type(dict: &mut impl TypeDict, t: &laddertypes::TypeTerm)-> String {
let t = t.clone().strip().get_floor_type().1;
dict.add_varname("TerminatorValue".into());
match &t {
TypeTerm::Seq { seq_repr, items } => {
if let Some(seq_repr) = seq_repr.as_ref() {
if let Ok(ψ) = laddertypes::constraint_system::subtype_unify(
seq_repr,
&dict.parse_desugared("<ValueTerminated TerminatorValue>").expect("").sugar(dict)
) {
return get_c_repr_type(dict, &items[0].clone().strip().get_floor_type().1);
}
}
}
_=>{}
}
encode_type_to_symbol(dict, t)
_ => {}
}
get_c_repr_type(dict, &t)
}
pub fn encode_morph_type_to_symbol(dict: &mut impl TypeDict, t: &SugaredMorphismType) -> String {
pub fn encode_morph_type_to_symbol(dict: &mut impl TypeDict, t: &MorphismType) -> String {
format!(
"morph_{}__to_{}",
encode_type_to_symbol(dict, &t.src_type),
encode_type_to_symbol(dict, &t.dst_type)
"morph__{}___TO__{}",
get_c_repr_type(dict, &t.strip_halo().src_type),
get_c_repr_type(dict, &t.strip_halo().dst_type)
)
}
pub fn encode_type_to_value(dict: &mut impl TypeDict, t: &laddertypes::SugaredTypeTerm) -> String {
pub fn encode_type_to_value(dict: &mut impl TypeDict, t: &laddertypes::TypeTerm) -> String {
let t = t.clone().desugar(dict);
dict.unparse(&t)
}

7
src/main.rs
View file

@ -11,14 +11,15 @@ use {
morphism::LdmcPrimMorph,
parser::morphism_base_parser,
}, ariadne::{Color, Label, Report, ReportKind, Source}, c_gen::LdmcCTargetMorph, chumsky::prelude::*, laddertypes::{
morphism_path_sugared::SugaredShortestPathProblem, morphism_sugared::{MorphismInstance2, SugaredMorphism, SugaredMorphismType}, parser::ParseLadderType, unparser::*, BimapTypeDict, MorphismType, SugaredTypeTerm, TypeDict
morphism_path::ShortestPathProblem, morphism::{MorphismInstance, Morphism, MorphismType},
parser::ParseLadderType, unparser::*, BimapTypeDict, TypeTerm, TypeDict
}, std::{collections::HashMap, sync::{Arc, RwLock}}, tiny_ansi::TinyAnsi
};
fn main() {
let mut type_dict = Arc::new(RwLock::new(BimapTypeDict::new()));
let mut morphism_base = laddertypes::morphism_base_sugared::SugaredMorphismBase::<LdmcPrimMorph>::new();
let mut morphism_base = laddertypes::morphism_base::MorphismBase::<LdmcPrimMorph>::new();
let mut args = std::env::args().skip(1);
let src_type_arg = args.next().expect("src type expected");
@ -95,7 +96,7 @@ fn main() {
let src_type = type_dict.parse( src_type_arg.as_str() ).expect("");
let dst_type = type_dict.parse( dst_type_arg.as_str() ).expect("");
let ty = SugaredMorphismType{ src_type: src_type.sugar(&mut type_dict), dst_type: dst_type.sugar(&mut type_dict) };
let ty = MorphismType{ src_type: src_type, dst_type };
let m = morphism_base.get_morphism_instance( &ty ).expect("failed to find morphism");
println!("{}", crate::c_gen::generate_main(&mut type_dict, m).expect("failed to generate main function"));
}

170
src/morphism.rs
View file

@ -1,177 +1,17 @@
use laddertypes::{morphism::Morphism, morphism_base::MorphismBase, morphism_path::ShortestPathProblem, morphism_sugared::{SugaredMorphism, SugaredMorphismType}, SugaredStructMember};
use crate::{c_gen_types::encode_type_to_symbol, struct_layout::StructLayout};
use laddertypes::{morphism_path::ShortestPathProblem, morphism::{Morphism, MorphismType}, StructMember};
use crate::{c_gen_types::get_c_repr_type, struct_layout::StructLayout};
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct LdmcPrimMorph {
pub symbol: String,
pub type_args: Vec<(laddertypes::TypeID, String)>,
pub ty: SugaredMorphismType,
pub ty: MorphismType,
pub c_source: String
}
impl LdmcPrimMorph {
/*
pub fn into_prim_c_morphism(self, dict: &mut impl laddertypes::TypeDict, symbol: String) -> LdmcPrimCMorphism {
let src_c_type = ;
let dst_c_type = ;
let c_source =
format!("
int {} ( {} const * restrict src, {} * restrict dst ) {{
{}
return 0;
}}
",
symbol, src_c_type, dst_c_type,
self.generate_call(dict, &std::collections::HashMap::new(), 0)
);
LdmcPrimCMorphism {
symbol,
type_args: Vec::new(),
src_type,
dst_type,
c_source
}
}
*/
/*
pub fn new_struct_map(
dict: &mut impl laddertypes::TypeDict,
morph_base: &MorphismBase<LdmcPrimMorph>,
src: laddertypes::TypeTerm,
dst: laddertypes::TypeTerm,
) -> Self {
let src_struct = StructLayout::parse(dict, &src).expect("cant parse src struct layout");
let dst_struct = StructLayout::parse(dict, &dst).expect("cant parse dst struct layout");
let mut member_morphisms = Vec::new();
for SugaredStructMember{ symbol: field_name, ty: dst_type } in dst_struct.members.iter() {
let mut src_type = None;
for SugaredStructMember{ symbol: src_name, ty: st } in src_struct.members.iter() {
if src_name == field_name {
src_type = Some(st.clone());
}
}
let src_type = src_type.expect(&format!("cant find member {} in src struct", field_name));
if src_type == *dst_type {
member_morphisms.push(
StructFieldMorphism {
field_name: field_name.to_string(),
item_morph: None,
src_offset: src_struct.get_offset( field_name ),
dst_offset: dst_struct.get_offset( field_name ),
}
);
} else {
match ShortestPathProblem::new(
&morph_base,
laddertypes::MorphismType {
src_type: src_type.clone().desugar(dict),
dst_type: dst_type.clone().desugar(dict)
}
).solve()
{
Some(path) => {
let src_type = src_type.clone().desugar(dict);
let dst_type = dst_type.clone().desugar(dict);
let morph_symb = format!("morph_{}_to_{}",
encode_type_to_symbol(dict, &src_type),
encode_type_to_symbol(dict, &dst_type)
);
member_morphisms.push(
StructFieldMorphism {
field_name: field_name.to_string(),
item_morph: None,//Some(Box::new(item_morph.m.into_prim_c_morphism(dict, morph_symb, &item_morph.σ))),
src_offset: src_struct.get_offset( field_name ),
dst_offset: dst_struct.get_offset( field_name ),
}
);
},
None => {
eprintln!("cant map field {}", field_name);
}
}
}
}
LdmcPrimMorph::StructMap {
src_struct, dst_struct,
member_morphisms
}
}
*/
}
impl SugaredMorphism for LdmcPrimMorph {
fn get_type(&self) -> SugaredMorphismType {
impl Morphism for LdmcPrimMorph {
fn get_type(&self) -> MorphismType {
self.ty.clone()
}
}
/*
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() ]),
}
},
LdmcMorphism::StructMap { src_struct, dst_struct, member_morphisms } => {
laddertypes::MorphismType {
src_type: src_struct.get_type(),
dst_type: dst_struct.get_type()
}
}
}.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
}
}
}
*/

8
src/parser.rs
View file

@ -1,7 +1,7 @@
use {
crate::morphism::LdmcPrimMorph, chumsky::{
prelude::*, text::*
}, laddertypes::{morphism_sugared::SugaredMorphismType, parser::*, BimapTypeDict, TypeDict}, std::sync::{Arc, RwLock}
}, laddertypes::{morphism::MorphismType, parser::*, BimapTypeDict, TypeDict}, std::sync::{Arc, RwLock}
};
/* morphism-base text format:
@ -59,13 +59,13 @@ pub fn morphism_base_parser(
ty_args.push((var_id, kind));
}
let src_type = type_dict.parse(&src_type.iter().collect::<String>()).expect("couldnt parse src type").sugar(&mut *type_dict);
let dst_type = type_dict.parse(&dst_type.iter().collect::<String>()).expect("couldnt parse dst type").sugar(&mut *type_dict);
let src_type = type_dict.parse_desugared(&src_type.iter().collect::<String>()).expect("couldnt parse src type").sugar(&mut *type_dict);
let dst_type = type_dict.parse_desugared(&dst_type.iter().collect::<String>()).expect("couldnt parse dst type").sugar(&mut *type_dict);
LdmcPrimMorph {
symbol,
type_args: ty_args,
ty: SugaredMorphismType{
ty: MorphismType{
src_type,
dst_type
},

44
src/struct_layout.rs
View file

@ -1,7 +1,7 @@
use std::ops::Deref;
use laddertypes::{parser::*, unparser::*, SugaredStructMember, SugaredTypeTerm, TypeDict, TypeTerm};
use laddertypes::{parser::*, unparser::*, StructMember, TypeTerm, TypeDict, DesugaredTypeTerm};
#[derive(Clone, Copy, Debug)]
pub enum ObjectSize {
@ -46,9 +46,9 @@ impl std::ops::Mul for ObjectSize {
}
}
pub fn get_type_size( dict: &mut impl TypeDict, ty: SugaredTypeTerm ) -> ObjectSize {
pub fn get_type_size( dict: &mut impl TypeDict, ty: TypeTerm ) -> ObjectSize {
match &ty {
SugaredTypeTerm::TypeID(tyid) => {
TypeTerm::TypeID(tyid) => {
if tyid == &dict.get_typeid_creat("native.UInt8") { ObjectSize::Static(1) }
else if tyid == &dict.get_typeid_creat("native.UInt16") { ObjectSize::Static(2) }
else if tyid == &dict.get_typeid_creat("native.UInt32") { ObjectSize::Static(4) }
@ -61,23 +61,23 @@ pub fn get_type_size( dict: &mut impl TypeDict, ty: SugaredTypeTerm ) -> ObjectS
}
},
SugaredTypeTerm::Ladder(rungs) => {
TypeTerm::Ladder(rungs) => {
get_type_size(dict, rungs.last().unwrap().clone() )
}
SugaredTypeTerm::Struct { struct_repr, members } => {
TypeTerm::Struct { struct_repr, members } => {
let layout = StructLayout::parse_sugared(dict, ty).expect("invalid struct");
layout.get_size()
}
SugaredTypeTerm::Seq { seq_repr, items } => {
TypeTerm::Seq { seq_repr, items } => {
if let Some(seq_repr) = seq_repr {
dict.add_typename("Length".into());
dict.add_typename("LengthType".into());
dict.add_typename("TerminatorValue".into());
if let Ok(σ) = laddertypes::unify(
&seq_repr.clone().desugar(dict),
&seq_repr.clone(),
&dict.parse("<StaticLength Length>").expect("")
) {
if let Some(TypeTerm::Num(len)) = σ.get(&dict.get_typeid(&"Length".into()).expect("")) {
@ -87,13 +87,13 @@ pub fn get_type_size( dict: &mut impl TypeDict, ty: SugaredTypeTerm ) -> ObjectS
}
}
else if let Ok(σ) = laddertypes::unify(
&seq_repr.clone().desugar(dict),
&seq_repr.clone(),
&dict.parse("<LengthPrefix LengthType>").expect("")
) {
ObjectSize::Dynamic()
}
else if let Ok(σ) = laddertypes::unify(
&seq_repr.clone().desugar(dict),
&seq_repr.clone(),
&dict.parse("<ValueTerminated TerminatorValue>").expect("")
) {
ObjectSize::Dynamic()
@ -118,35 +118,35 @@ pub enum LayoutType {
}
impl LayoutType {
pub fn parse( dict: &mut impl TypeDict, ty: &TypeTerm ) -> Option< LayoutType > {
if ty == &dict.parse("Aligned").expect("parse") {
pub fn parse( dict: &mut impl TypeDict, ty: &DesugaredTypeTerm ) -> Option< LayoutType > {
if ty == &dict.parse_desugared("Aligned").expect("parse") {
Some(LayoutType::Aligned)
} else if ty == &dict.parse("Packed").expect("parse") {
} else if ty == &dict.parse_desugared("Packed").expect("parse") {
Some(LayoutType::Packed)
} else {
None
}
}
pub fn unparse(&self, dict: &mut impl TypeDict) -> TypeTerm {
pub fn unparse(&self, dict: &mut impl TypeDict) -> DesugaredTypeTerm {
match self {
LayoutType::Aligned => dict.parse("Aligned").unwrap(),
LayoutType::Packed => dict.parse("Packed").unwrap()
LayoutType::Aligned => dict.parse_desugared("Aligned").unwrap(),
LayoutType::Packed => dict.parse_desugared("Packed").unwrap()
}
}
}
#[derive(Clone)]
pub struct StructLayout {
pub ty: laddertypes::TypeTerm,
pub ty: laddertypes::DesugaredTypeTerm,
pub layout: LayoutType,
pub members: Vec< SugaredStructMember >,
pub members: Vec< StructMember >,
offsets: std::collections::HashMap< String, u64 >,
size: ObjectSize
}
impl StructLayout {
pub fn get_type(&self) -> TypeTerm {
pub fn get_type(&self) -> DesugaredTypeTerm {
self.ty.clone()
}
@ -161,7 +161,7 @@ impl StructLayout {
pub fn init_offsets(&mut self, dict: &mut impl TypeDict) {
let mut offset = 0;
for SugaredStructMember{symbol: field_name, ty: field_type} in self.members.iter() {
for StructMember{symbol: field_name, ty: field_type} in self.members.iter() {
//let field_c_type = crate::c_gen::get_c_repr_type(dict, field_type.clone(), true).expect("cant get c-repr for struct field");
match get_type_size( dict, field_type.clone() ) {
ObjectSize::Static(field_size) => {
@ -208,15 +208,15 @@ impl StructLayout {
}
}
pub fn parse(dict: &mut impl TypeDict, struct_type: &TypeTerm) -> Option <Self> {
pub fn parse(dict: &mut impl TypeDict, struct_type: &DesugaredTypeTerm) -> Option <Self> {
let st = struct_type.clone().strip().param_normalize().sugar(dict);
Self::parse_sugared(dict, st)
}
pub fn parse_sugared(dict: &mut impl TypeDict, st: SugaredTypeTerm) -> Option <Self> {
pub fn parse_sugared(dict: &mut impl TypeDict, st: TypeTerm) -> Option <Self> {
eprintln!("{}", st.pretty(dict, 0));
match st.clone() {
SugaredTypeTerm::Struct{ struct_repr, members } => {
TypeTerm::Struct{ struct_repr, members } => {
let mut sl = StructLayout {
ty: st.desugar(dict),
layout: if let Some(sr) = struct_repr {