use cxxrtl::{CxxrtlHandle, CxxrtlObject};
use std::env;

use std::fs::File;
use cxxrtl::{CxxrtlHandle, CxxrtlObject, Vcd};

    handle: CxxrtlHandle,

    pub handle: CxxrtlHandle,

    fn new(lib: &str) -> Self {
        let handle = unsafe { CxxrtlHandle::new(lib) };

    fn new() -> Self {
        extern "C" {
            fn cxxrtl_design_create() -> *mut cxxrtl::_cxxrtl_toplevel;
        }
        let handle = unsafe { CxxrtlHandle::new(cxxrtl_design_create()) };

    let lib = concat!(env!("OUT_DIR"), "/design.so");
    let mut blink = Blink::new(lib);

    let mut blink = Blink::new();
    let mut vcd = Vcd::new();
    vcd.timescale(cxxrtl::Timescale::Us(1));
    vcd.add_without_memories(&blink.handle);

    let mut vcd_file = File::create("wave.vcd").unwrap();
    vcd.sample(0);

        vcd.sample(cycle * 2);

        vcd.sample(cycle * 2 + 1);

        vcd.write(&mut vcd_file).unwrap();

    let capi = Path::new(include).join("backends/cxxrtl/cxxrtl_capi.cc");

    let dest = out_path.join("design.so");

    Command::new("clang++")
        .args(&["-g", "-O3", "-fPIC", "-shared", "-std=c++14"])
        .arg(format!("-I{}", include))
        .arg(capi)
        .arg(design_cc)
        .arg("-o")
        .arg(dest)
        .status()
        .expect("failed generate cxxrtl code");

    cc::Build::new()
        .include(include)
        .cpp(true)
        .flag_if_supported("-std=c++14")
        .file(design_cc)
        .compile("design");

[build-dependencies]
cc = "1.0"