main.rs

use core::fmt;

use rsim::*;

// fn main() {
//     let b: Signal = 12345u32.into();
//     let c: Signal = 1245u32.into();

//     let s: Signal = Signal::new_zeroed(5);

//     let b8: Signal = 0b0000_1010u8.into();

//     for i in 0..8 {
//         println!("b8[{}] {}", i, b8[i]);
//     }

//     println!("b8 {:b}", b8);

//     println!("s {:b}", s);

//     println!("{:?}", s);

//     if b == c {
//         println!("eq");
//     }

//     println!("b {:?}", b);

//     let i: u32 = b.into();
//     println!("i {:?}", i);

//     let a: Signal = 0b1001_0101u8.into();
//     let b: Signal = 0b1111_0000u8.into();
//     let c: Signal = &a & &b;

//     println!("{:?}", a);
//     println!("{:?}", b);
//     println!("{:?}", c);

//     let r: u8 = (&a & &b).into();
// }

// use petgraph::{
//     graph::{DiGraph, Node},
//     Directed,
// };

// use petgraph::dot::{Config, Dot};
// use std::fs::File;
// use std::io::prelude::*;

// fn main() {
//     let mut deps = DiGraph::<&str, &str>::new();
//     let pg = deps.add_node("petgraph");
//     let fb = deps.add_node("fixedbitset");
//     let qc = deps.add_node("quickcheck");
//     let rand = deps.add_node("rand");
//     let libc = deps.add_node("libc");
//     deps.extend_with_edges(&[(pg, fb), (pg, qc), (qc, rand), (rand, libc), (qc, libc)]);
//     println!("{:?}", Dot::with_config(&deps, &[Config::EdgeNoLabel]));

//     let out: String = Dot::with_config(&deps, &[Config::EdgeNoLabel]).to_string();

//     let mut file = File::create("foo.dot").unwrap();
//     file.write_all(out.as_bytes()).unwrap();
// }

use std::cell::Cell;

// two input mux
struct Mux<'a, const N: usize> {
    ins: (Signal<'a, N>, Signal<'a, N>),
    sel: &'a Signal<'a, 1>,
    out: &'a Signal<'a, N>,
}

impl<'a, const N: usize> Eval for Mux<'a, N> {
    fn eval(&self) -> () {
        let sel = self.sel[0].get();
        for (i, o) in self.out.iter().enumerate() {
            o.set(match sel {
                false => self.ins.0[i].get(),
                true => self.ins.1[i].get(),
            })
        }
    }
}

fn main() {
    let mut in1 = [false, true];
    let mut in2 = [true, false];
    let mut sel = [false];
    let sel = Signal::new(&mut sel);
    let mut out = [false, false];

    let out = &Signal::new(&mut out);
    // let s = &(&*out)[0..3]; // .to_slice(0, 1);
    let out0: Signal<1> = out.view(0, 1);
    let out1: Signal<1> = out.view(1, 2);
    // println!("s {:b}", &s);

    let m = Mux {
        ins: (Signal::new(&mut in1), Signal::new(&mut in2)),
        sel: &sel,
        out,
    };

    println!("m.out {:b}", m.out);
    m.eval();
    sel[0].set(true);
    m.eval();
    println!("m.out {:b}", m.out);
    // sel[0].set(false);
    sel.store([false]);
    sel.store_slice(&[false]);
    m.eval();
    println!("m.out {:b}", m.out);
    println!("out0 {:b}", &out0);
    println!("out1 {:b}", &out1);
    let p = &m.out[0..1];
    let m: Signal<1> = m.out[0..2].into();
}
// #[derive(Debug)]
// struct Mux<'a, const I: usize, const S: usize, const N: usize> {
//     inputs: [&'a Signal<N>; I],
//     sel: &'a Signal<S>,
//     output: Signal<N>,
// }

// impl<'a, const I: usize, const S: usize, const N: usize> Eval for Mux<'a, I, S, N> {
//     fn eval(&self) {
//         let s: u8 = self.sel.clone().into();
//         println!("s {}", s);

//         let o = self.inputs[s as usize];

//         self.output.store.set(o.store.get())
//     }
// }

// impl<'a, const I: usize, const S: usize, const N: usize> fmt::Binary for Mux<'a, I, S, N> {
//     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
//         fmt::Binary::fmt(&self.output, f)
//     }
// }

// fn main() {
//     let s1: Signal<8> = 0b10101u8.into();
//     // println!("s1 {:?}", s1);
//     println!("s1 {:b}", s1);

//     let s2: Signal<8> = 0b00110u8.into();
//     println!("s2 {:b}", s2);

//     let s3 = &s1 & &s2;

//     println!("s3 {:b}", s3);

//     let mut sel: Signal<1> = [true].into();

//     let m: Mux<2, 1, 8> = Mux {
//         inputs: [&s1, &s2],
//         sel: &sel,
//         output: 0u8.into(),
//     };

//     // println!("m {:?}", m);

//     println!("m {:b}", m);

//     m.eval();
//     println!("eval", m);
//     println!("m {:b}", m);

// }

// #[derive(Debug)]
// struct AndIn<'a> {
//     a: &'a Signal,
//     b: &'a Signal,
// }

// #[derive(Debug)]
// struct And<'a> {
//     inputs: AndIn<'a>,
//     output: Signal,
// }

// impl<'a> Eval for And<'a> {
//     fn eval(&mut self) {
//         self.output = (self.inputs.a & self.inputs.b).clone()
//     }
// }

// fn main() {
//     let a: Signal = 1u8.into();
//     let b: Signal = 2u8.into();

//     let mut and = And {
//         inputs: AndIn { a: &a, b: &b },
//         output: Signal::new(),
//     };

//     let mut m = Mux {
//         inputs: MuxIn {
//             a: &a,
//             b: &b,
//             sel: &and.output,
//         },
//         output: Signal::new(),
//     };

//     and.eval();
//     //println!("m {:?}", m);

//     m.eval();
//     // println!("m {:?}", m);
// }