T0b1/wasmtime
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #668 from pchickey/pch/wig_latest_witx

Browse Source 
[wasi-common] wig: update to latest witx
This commit is contained in:
Pat Hickey
2019-12-05 17:24:38 -05:00
committed by GitHub
parent cc6e8e1af2 5793b14dd6
commit 7d415df209
2 changed files with 150 additions and 159 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
crates/wasi-common/WASI

Submodule crates/wasi-common/WASI updated: 9b298d7911...9150e66a34

307
crates/wasi-common/wig/src/raw_types.rs
View File

@@ -39,114 +39,114 @@ pub fn gen(args: TokenStream, mode: Mode) -> TokenStream {
} }
fn gen_datatypes(output: &mut TokenStream, doc: &witx::Document, mode: Mode) { fn gen_datatypes(output: &mut TokenStream, doc: &witx::Document, mode: Mode) {
for datatype in doc.datatypes() { for namedtype in doc.typenames() {
if mode.include_target_types() != type_has_target_size(doc, &datatype) { if mode.include_target_types() != namedtype_has_target_size(&namedtype) {
continue; continue;
} }
gen_datatype(output, doc, mode, &datatype); gen_datatype(output, mode, &namedtype);
} }
} }
fn gen_datatype( fn gen_datatype(output: &mut TokenStream, mode: Mode, namedtype: &witx::NamedType) {
output: &mut TokenStream, let wasi_name = format_ident!("__wasi_{}_t", namedtype.name.as_str());
doc: &witx::Document, match &namedtype.dt {
mode: Mode, witx::TypeRef::Name(alias_to) => {
datatype: &witx::Datatype, let to = tref_tokens(mode, &alias_to.dt);
) { output.extend(quote!(pub type #wasi_name = #to;));
match &datatype.variant { }
witx::DatatypeVariant::Alias(a) => { witx::TypeRef::Value(v) => match &**v {
if a.name.as_str() == "size" { witx::Type::Enum(e) => {
let wasi_name = format_ident!("__wasi_{}_t", a.name.as_str()); let repr = int_repr_tokens(e.repr);
match mode { output.extend(quote!(pub type #wasi_name = #repr;));
Mode::Host => output.extend(quote!(pub type #wasi_name = usize;)), for (index, variant) in e.variants.iter().enumerate() {
Mode::Wasi => panic!("size has target-specific size"), let value_name = format_ident!(
Mode::Wasi32 => output.extend(quote!(pub type #wasi_name = u32;)), "__WASI_{}_{}",
namedtype.name.as_str().to_shouty_snake_case(),
variant.name.as_str().to_shouty_snake_case()
);
let index_name = Literal::usize_unsuffixed(index);
output.extend(quote!(pub const #value_name: #wasi_name = #index_name;));
} }
} else {
let wasi_name = format_ident!("__wasi_{}_t", a.name.as_str());
let to = ident_tokens(mode, &a.to);
output.extend(quote!(pub type #wasi_name = #to;));
} }
} witx::Type::Flags(f) => {
witx::DatatypeVariant::Enum(e) => { let repr = int_repr_tokens(f.repr);
let wasi_name = format_ident!("__wasi_{}_t", e.name.as_str()); output.extend(quote!(pub type #wasi_name = #repr;));
let repr = int_repr_tokens(e.repr); for (index, flag) in f.flags.iter().enumerate() {
output.extend(quote!(pub type #wasi_name = #repr;)); let value_name = format_ident!(
for (index, variant) in e.variants.iter().enumerate() { "__WASI_{}_{}",
let value_name = format_ident!( namedtype.name.as_str().to_shouty_snake_case(),
"__WASI_{}_{}", flag.name.as_str().to_shouty_snake_case()
e.name.as_str().to_shouty_snake_case(), );
variant.name.as_str().to_shouty_snake_case() let flag_value = Literal::u128_unsuffixed(
); 1u128
let index_name = Literal::usize_unsuffixed(index); .checked_shl(u32::try_from(index).expect("flag value overflow"))
output.extend(quote!(pub const #value_name: #wasi_name = #index_name;)); .expect("flag value overflow"),
);
output.extend(quote!(pub const #value_name: #wasi_name = #flag_value;));
}
} }
} witx::Type::Struct(s) => {
witx::DatatypeVariant::Flags(f) => { output.extend(quote!(#[repr(C)]));
let wasi_name = format_ident!("__wasi_{}_t", f.name.as_str()); // Types which contain unions can't trivially implement Debug,
let repr = int_repr_tokens(f.repr); // Hash, or Eq, because the type itself doesn't record which
output.extend(quote!(pub type #wasi_name = #repr;)); // union member is active.
for (index, flag) in f.flags.iter().enumerate() { if struct_has_union(&s) {
let value_name = format_ident!( output.extend(quote!(#[derive(Copy, Clone)]));
"__WASI_{}_{}", output.extend(quote!(#[allow(missing_debug_implementations)]));
f.name.as_str().to_shouty_snake_case(), } else {
flag.name.as_str().to_shouty_snake_case() output.extend(quote!(#[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]));
); }
let flag_value = Literal::u128_unsuffixed(
1u128
.checked_shl(u32::try_from(index).expect("flag value overflow"))
.expect("flag value overflow"),
);
output.extend(quote!(pub const #value_name: #wasi_name = #flag_value;));
}
}
witx::DatatypeVariant::Struct(s) => {
output.extend(quote!(#[repr(C)]));
// Types which contain unions can't trivially implement Debug, output.extend(quote!(pub struct #wasi_name));
// Hash, or Eq, because the type itself doesn't record which
// union member is active. let mut inner = TokenStream::new();
if struct_has_union(&doc, s) { for member in &s.members {
let member_name = format_ident!("r#{}", member.name.as_str());
let member_type = tref_tokens(mode, &member.tref);
inner.extend(quote!(pub #member_name: #member_type,));
}
let braced = Group::new(Delimiter::Brace, inner);
output.extend(TokenStream::from(TokenTree::Group(braced)));
}
witx::Type::Union(u) => {
output.extend(quote!(#[repr(C)]));
output.extend(quote!(#[derive(Copy, Clone)])); output.extend(quote!(#[derive(Copy, Clone)]));
output.extend(quote!(#[allow(missing_debug_implementations)])); output.extend(quote!(#[allow(missing_debug_implementations)]));
} else {
output.extend(quote!(#[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)])); output.extend(quote!(pub union #wasi_name));
let mut inner = TokenStream::new();
for variant in &u.variants {
let variant_name = format_ident!("r#{}", variant.name.as_str());
let variant_type = tref_tokens(mode, &variant.tref);
inner.extend(quote!(pub #variant_name: #variant_type,));
}
let braced = Group::new(Delimiter::Brace, inner);
output.extend(TokenStream::from(TokenTree::Group(braced)));
} }
witx::Type::Handle(_h) => {
let wasi_name = format_ident!("__wasi_{}_t", s.name.as_str()); output.extend(quote!(pub type #wasi_name = u32;));
output.extend(quote!(pub struct #wasi_name));
let mut inner = TokenStream::new();
for member in &s.members {
let member_name = format_ident!("r#{}", member.name.as_str());
let member_type = ident_tokens(mode, &member.type_);
inner.extend(quote!(pub #member_name: #member_type,));
} }
let braced = Group::new(Delimiter::Brace, inner); witx::Type::Builtin(b) => {
output.extend(TokenStream::from(TokenTree::Group(braced))); if namedtype.name.as_str() == "size" {
} match mode {
witx::DatatypeVariant::Union(u) => { Mode::Host => output.extend(quote!(pub type #wasi_name = usize;)),
output.extend(quote!(#[repr(C)])); Mode::Wasi => panic!("size has target-specific size"),
output.extend(quote!(#[derive(Copy, Clone)])); Mode::Wasi32 => output.extend(quote!(pub type #wasi_name = u32;)),
output.extend(quote!(#[allow(missing_debug_implementations)])); }
} else {
let wasi_name = format_ident!("__wasi_{}_t", u.name.as_str()); let b_type = builtin_tokens(mode, *b);
output.extend(quote!(pub union #wasi_name)); output.extend(quote!(pub type #wasi_name = #b_type;));
}
let mut inner = TokenStream::new();
for variant in &u.variants {
let variant_name = format_ident!("r#{}", variant.name.as_str());
let variant_type = ident_tokens(mode, &variant.type_);
inner.extend(quote!(pub #variant_name: #variant_type,));
} }
let braced = Group::new(Delimiter::Brace, inner); witx::Type::Pointer { .. }
output.extend(TokenStream::from(TokenTree::Group(braced))); | witx::Type::ConstPointer { .. }
} | witx::Type::Array { .. } => {
witx::DatatypeVariant::Handle(a) => { let tref_tokens = tref_tokens(mode, &namedtype.dt);
let wasi_name = format_ident!("__wasi_{}_t", a.name.as_str()); output.extend(quote!(pub type #wasi_name = #tref_tokens;));
output.extend(quote!(pub type #wasi_name = u32;)); }
} },
} }
} }
@@ -179,86 +179,77 @@ fn builtin_tokens(mode: Mode, builtin: witx::BuiltinType) -> TokenStream {
} }
} }
fn ident_tokens(mode: Mode, ident: &witx::DatatypeIdent) -> TokenStream { fn tref_tokens(mode: Mode, tref: &witx::TypeRef) -> TokenStream {
match ident { match tref {
witx::DatatypeIdent::Builtin(builtin) => builtin_tokens(mode, *builtin), witx::TypeRef::Name(n) => TokenStream::from(TokenTree::Ident(format_ident!(
witx::DatatypeIdent::Ident(ident) => TokenStream::from(TokenTree::Ident(format_ident!(
"__wasi_{}_t", "__wasi_{}_t",
ident.name.as_str() n.name.as_str()
))), ))),
witx::DatatypeIdent::Pointer(pointee) => { witx::TypeRef::Value(v) => match &**v {
let pointee = ident_tokens(mode, pointee); witx::Type::Builtin(b) => builtin_tokens(mode, *b),
match mode { witx::Type::Pointer(pointee) => {
Mode::Host => quote!(*mut #pointee), let pointee = tref_tokens(mode, pointee);
Mode::Wasi => panic!("pointers have target-specific size"), match mode {
Mode::Wasi32 => quote!(u32), Mode::Host => quote!(*mut #pointee),
Mode::Wasi => panic!("pointers have target-specific size"),
Mode::Wasi32 => quote!(u32),
}
} }
} witx::Type::ConstPointer(pointee) => {
witx::DatatypeIdent::ConstPointer(pointee) => { let pointee = tref_tokens(mode, pointee);
let pointee = ident_tokens(mode, pointee); match mode {
match mode { Mode::Host => quote!(*const #pointee),
Mode::Host => quote!(*const #pointee), Mode::Wasi => panic!("pointers have target-specific size"),
Mode::Wasi => panic!("pointers have target-specific size"), Mode::Wasi32 => quote!(u32),
Mode::Wasi32 => quote!(u32), }
} }
} witx::Type::Array(element) => {
witx::DatatypeIdent::Array(element) => { let element_name = tref_tokens(mode, element);
let element_name = ident_tokens(mode, element); match mode {
match mode { Mode::Host => quote!((*const #element_name, usize)),
Mode::Host => quote!((*const #element_name, usize)), Mode::Wasi => panic!("arrays have target-specific size"),
Mode::Wasi => panic!("arrays have target-specific size"), Mode::Wasi32 => quote!((u32, u32)),
Mode::Wasi32 => quote!((u32, u32)), }
} }
} t => panic!("cannot give name to anonymous type {:?}", t),
},
} }
} }
/// Test whether the given struct contains any union members. /// Test whether the given struct contains any union members.
fn struct_has_union(doc: &witx::Document, s: &witx::StructDatatype) -> bool { fn struct_has_union(s: &witx::StructDatatype) -> bool {
s.members.iter().any(|member| match &member.type_ { s.members.iter().any(|member| match &*member.tref.type_() {
witx::DatatypeIdent::Ident(ident) => match &doc.datatype(&ident.name).unwrap().variant { witx::Type::Union { .. } => true,
witx::DatatypeVariant::Union(_) => true, witx::Type::Struct(s) => struct_has_union(&s),
witx::DatatypeVariant::Struct(s) => struct_has_union(doc, &s),
_ => false,
},
_ => false, _ => false,
}) })
} }
/// Test whether the given type has a target-specific size. /// Test whether the type referred to has a target-specific size.
fn type_has_target_size(doc: &witx::Document, type_: &witx::Datatype) -> bool { fn tref_has_target_size(tref: &witx::TypeRef) -> bool {
match &type_.variant { match tref {
witx::DatatypeVariant::Alias(a) => { witx::TypeRef::Name(nt) => namedtype_has_target_size(&nt),
a.name.as_str() == "size" || ident_has_target_size(doc, &a.to) witx::TypeRef::Value(t) => type_has_target_size(&t),
}
witx::DatatypeVariant::Enum(_) => false,
witx::DatatypeVariant::Flags(_) => false,
witx::DatatypeVariant::Struct(s) => s
.members
.iter()
.any(|m| ident_has_target_size(doc, &m.type_)),
witx::DatatypeVariant::Union(u) => u
.variants
.iter()
.any(|v| ident_has_target_size(doc, &v.type_)),
witx::DatatypeVariant::Handle(_) => false,
} }
} }
/// Test whether the given type ident has a target-specific size. /// Test whether the given named type has a target-specific size.
fn ident_has_target_size(doc: &witx::Document, ident: &witx::DatatypeIdent) -> bool { fn namedtype_has_target_size(nt: &witx::NamedType) -> bool {
match ident { if nt.name.as_str() == "size" {
witx::DatatypeIdent::Ident(ident) => { true
type_has_target_size(doc, &doc.datatype(&ident.name).unwrap()) } else {
} tref_has_target_size(&nt.dt)
witx::DatatypeIdent::Builtin(builtin) => { }
if let witx::BuiltinType::String = builtin { }
true
} else { /// Test whether the given type has a target-specific size.
false fn type_has_target_size(ty: &witx::Type) -> bool {
} match ty {
} witx::Type::Builtin(witx::BuiltinType::String) => true,
witx::DatatypeIdent::Pointer(_) | witx::DatatypeIdent::ConstPointer(_) => true, witx::Type::Pointer { .. } | witx::Type::ConstPointer { .. } => true,
witx::DatatypeIdent::Array(element) => ident_has_target_size(doc, element), witx::Type::Array(elem) => tref_has_target_size(elem),
witx::Type::Struct(s) => s.members.iter().any(|m| tref_has_target_size(&m.tref)),
witx::Type::Union(u) => u.variants.iter().any(|v| tref_has_target_size(&v.tref)),
_ => false,
} }
} }