a628dc315e
* Shuffle around the wiggle crates This commit reorganizes the wiggle crates slightly by performing the following transforms: * The `crates/wiggle` crate, previously named `wiggle`, was moved to `crates/wiggle/crates/macro` and is renamed to `wiggle-macro`. * The `crates/wiggle/crates/runtime` crate, previously named `wiggle-runtime`, was moved to `crates/wiggle` and is renamed to `wiggle`. * The new `wiggle` crate depends on `wiggle-macro` and reexports the macro. The goal here is that consumers only deal with the `wiggle` crate itself. No more crates depend on `wiggle-runtime` and all dependencies are entirely on just the `wiggle` crate. * Remove the `crates/wiggle/crates` directory Move everything into `crates/wiggle` directly, like `wasi-common` * Add wiggle-macro to test-all script * Fixup a test
118 lines
3.0 KiB
Rust
118 lines
3.0 KiB
Rust
use std::path::{Path, PathBuf};
|
|
|
|
use proc_macro2::Span;
|
|
use syn::{
|
|
braced, bracketed,
|
|
parse::{Parse, ParseStream},
|
|
punctuated::Punctuated,
|
|
Error, Ident, LitStr, Result, Token,
|
|
};
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub struct Config {
|
|
pub witx: WitxConf,
|
|
pub ctx: CtxConf,
|
|
pub emit_metadata: bool,
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub enum ConfigField {
|
|
Witx(WitxConf),
|
|
Ctx(CtxConf),
|
|
}
|
|
|
|
impl ConfigField {
|
|
pub fn parse_pair(ident: &str, value: ParseStream, err_loc: Span) -> Result<Self> {
|
|
match ident {
|
|
"witx" => Ok(ConfigField::Witx(value.parse()?)),
|
|
"ctx" => Ok(ConfigField::Ctx(value.parse()?)),
|
|
_ => Err(Error::new(err_loc, "expected `witx` or `ctx`")),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Parse for ConfigField {
|
|
fn parse(input: ParseStream) -> Result<Self> {
|
|
let id: Ident = input.parse()?;
|
|
let _colon: Token![:] = input.parse()?;
|
|
Self::parse_pair(id.to_string().as_ref(), input, id.span())
|
|
}
|
|
}
|
|
|
|
impl Config {
|
|
pub fn build(fields: impl Iterator<Item = ConfigField>, err_loc: Span) -> Result<Self> {
|
|
let mut witx = None;
|
|
let mut ctx = None;
|
|
for f in fields {
|
|
match f {
|
|
ConfigField::Witx(c) => {
|
|
witx = Some(c);
|
|
}
|
|
ConfigField::Ctx(c) => {
|
|
ctx = Some(c);
|
|
}
|
|
}
|
|
}
|
|
Ok(Config {
|
|
witx: witx
|
|
.take()
|
|
.ok_or_else(|| Error::new(err_loc, "`witx` field required"))?,
|
|
ctx: ctx
|
|
.take()
|
|
.ok_or_else(|| Error::new(err_loc, "`ctx` field required"))?,
|
|
emit_metadata: false,
|
|
})
|
|
}
|
|
}
|
|
|
|
impl Parse for Config {
|
|
fn parse(input: ParseStream) -> Result<Self> {
|
|
let contents;
|
|
let _lbrace = braced!(contents in input);
|
|
let fields: Punctuated<ConfigField, Token![,]> =
|
|
contents.parse_terminated(ConfigField::parse)?;
|
|
Ok(Config::build(fields.into_iter(), input.span())?)
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub struct WitxConf {
|
|
pub paths: Vec<PathBuf>,
|
|
}
|
|
|
|
impl WitxConf {
|
|
pub fn make_paths_relative_to<P: AsRef<Path>>(&mut self, root: P) {
|
|
self.paths.iter_mut().for_each(|p| {
|
|
if !p.is_absolute() {
|
|
*p = PathBuf::from(root.as_ref()).join(p.clone());
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
impl Parse for WitxConf {
|
|
fn parse(input: ParseStream) -> Result<Self> {
|
|
let content;
|
|
let _ = bracketed!(content in input);
|
|
let path_lits: Punctuated<LitStr, Token![,]> = content.parse_terminated(Parse::parse)?;
|
|
let paths = path_lits
|
|
.iter()
|
|
.map(|lit| PathBuf::from(lit.value()))
|
|
.collect();
|
|
Ok(WitxConf { paths })
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub struct CtxConf {
|
|
pub name: Ident,
|
|
}
|
|
|
|
impl Parse for CtxConf {
|
|
fn parse(input: ParseStream) -> Result<Self> {
|
|
Ok(CtxConf {
|
|
name: input.parse()?,
|
|
})
|
|
}
|
|
}
|