rcx 0.1.3

Communicate with LEGO RCX bricks
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

use askama::Template;
use serde::Deserialize;
use std::{
    io::{BufReader, Write},
    path::Path,
};

const OPCODES_FILE: &str = "opcodes.yaml";
const CODEGEN_FILE: &str = "opcodes.rs";

mod filters {
    pub fn hex(n: &u8) -> askama::Result<String> {
        Ok(format!("0x{n:02x}"))
    }
}

const fn true_() -> bool {
    true
}

#[derive(Deserialize)]
#[allow(dead_code)]
struct Opcode {
    name: String,
    description: String,
    #[serde(default)]
    context: Context,
    #[serde(default = "true_")]
    supports_alternate: bool,
    request: RequestResponse,
    response: Option<RequestResponse>,
}

#[derive(Deserialize)]
#[allow(dead_code)]
struct Context {
    #[serde(default)]
    request: bool,
    #[serde(default)]
    response: bool,
    #[serde(default)]
    instruction: bool,
}

impl Default for Context {
    fn default() -> Self {
        Self {
            request: true,
            response: true,
            instruction: true,
        }
    }
}

#[derive(Deserialize)]
struct RequestResponse {
    opcode: u8,
    #[serde(default)]
    params: Vec<Param>,
}

fn u8_() -> String {
    "u8".into()
}

#[derive(Deserialize)]
struct Param {
    name: String,
    #[serde(default = "u8_")]
    ty: String,
}

#[derive(Template)]
#[template(path = "opcodes.rs", escape = "none")]
struct OpcodesTemplate {
    opcodes: Vec<Opcode>,
}

fn main() {
    println!("cargo:rerun-if-changed={OPCODES_FILE}");
    println!("cargo:rerun-if-changed=templates/opcodes.rs");

    let opcodes_file = Path::new(env!("CARGO_MANIFEST_DIR")).join(OPCODES_FILE);
    let file = std::fs::File::open(opcodes_file).unwrap();
    let reader = BufReader::new(file);
    let opcodes: Vec<Opcode> = serde_yaml::from_reader(reader).unwrap();
    let templ = OpcodesTemplate { opcodes };

    let codegen = templ.render().unwrap();

    let codegen_file =
        Path::new(&std::env::var_os("OUT_DIR").unwrap()).join(CODEGEN_FILE);
    let mut codegen_file = std::fs::File::create(codegen_file).unwrap();
    codegen_file.write_all(codegen.as_bytes()).unwrap();
}