69 lines
1.9 KiB
Rust
69 lines
1.9 KiB
Rust
pub mod types;
|
|
pub mod names;
|
|
pub mod context;
|
|
pub mod parsers;
|
|
|
|
use std::path::PathBuf;
|
|
use preserves::value::Map;
|
|
|
|
use crate::syntax::block::constructors::*;
|
|
use crate::metaschema::*;
|
|
|
|
pub type ModulePath = Vec<String>;
|
|
|
|
#[derive(Debug)]
|
|
pub struct CompilerConfig {
|
|
pub bundle: Map<ModulePath, Schema>,
|
|
pub output_dir: PathBuf,
|
|
}
|
|
|
|
impl CompilerConfig {
|
|
pub fn new(output_dir: PathBuf) -> Self {
|
|
CompilerConfig {
|
|
bundle: Map::new(),
|
|
output_dir: output_dir,
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn compile(config: &CompilerConfig) -> Result<(), std::io::Error> {
|
|
for (k, v) in config.bundle.iter() {
|
|
let mut output_path = config.output_dir.clone();
|
|
output_path.extend(k);
|
|
output_path.set_extension("rs");
|
|
let mut m = context::ModuleContext::new();
|
|
|
|
// println!("\n{:?}", &output_path);
|
|
|
|
// TODO: embedded type
|
|
|
|
for (n, d) in &v.definitions.0 {
|
|
m.define_type(item(types::render_definition_type(n, &types::definition_type(d))));
|
|
parsers::gen_definition_parser(&mut m, n, d);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
println!("#![allow(unused_parens)]");
|
|
println!();
|
|
println!("use std::convert::TryFrom;");
|
|
println!("use preserves::value::NestedValue;");
|
|
println!("use lazy_static::lazy_static;");
|
|
println!();
|
|
|
|
println!("lazy_static! {{");
|
|
for (value, name) in m.literals {
|
|
let bs = preserves::value::PackedWriter::encode(&value).unwrap();
|
|
println!(" pub static ref {}: preserves::value::IOValue = /* {:?} */ preserves::value::packed::from_bytes(&vec!{:?}).unwrap();",
|
|
name,
|
|
value,
|
|
bs);
|
|
}
|
|
println!("}}\n");
|
|
|
|
for i in m.typedefs { println!("{:?}\n", i); }
|
|
for i in m.functiondefs { println!("{:?}\n", i); }
|
|
}
|
|
Ok(())
|
|
}
|