rustaveli 0.1.0

A library to generate random c programs
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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

use std::collections::HashSet;
use std::sync::Arc;

use dashmap::DashMap;
use lazy_static::lazy_static;
use rand::prelude::*;

use super::{cstruct::CStruct, ctype::CTypeable, random_string::RandomString};

lazy_static! {
    pub(crate) static ref PRIMITIVE_TYPES: HashSet<String> = HashSet::from([
        "bool".to_string(),
        "int".to_string(),
        "char*".to_string(),
        "float".to_string(),
        "double".to_string(),
        "size_t".to_string(),
    ]);
}

type InstructionCompletionFunction = fn(String, Option<String>, String) -> String;

#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct TypeInformation {
    pub(crate) size: String,
    pub(crate) default: String,
    pub(crate) random: fn(Option<Box<dyn CTypeable>>) -> String,
    pub(crate) compare: String,
    pub(crate) global_defenition: String,
    pub(crate) instructions: Vec<String>,
    pub(crate) instruction_function: Option<InstructionCompletionFunction>,
    pub(crate) self_: Option<CStruct>,
}

lazy_static! {
    pub(crate) static ref AVAILABLE_TYPES: Arc<DashMap<String, TypeInformation>> =
        Arc::new(DashMap::from_iter([
            (
                "bool".to_string(),
                TypeInformation {
                    size: "sizeof(bool)".into(),
                    default: "false".into(),
                    random: |_s| return random::<bool>().to_string(),
                    compare: "CMP_INT".into(),
                    global_defenition: "".into(),
                    instructions: vec!["&".into(), "|".into(), "^".into()],
                    instruction_function: None,
                    self_: None,
                },
            ),
            (
                "int".to_string(),
                TypeInformation {
                    size: "sizeof(int)".into(),
                    default: "0".into(),
                    random: |_s| {
                        return random::<i32>().to_string();
                    },
                    compare: "CMP_INT".into(),
                    global_defenition: "".into(),
                    instructions: vec![
                        "+".into(),
                        "-".into(),
                        "*".into(),
                        "/".into(),
                        "%".into(),
                        "&".into(),
                        "|".into(),
                        "^".into(),
                    ],
                    instruction_function: None,
                    self_: None,
                },
            ),
            (
                "size_t".to_string(),
                TypeInformation {
                    size: "sizeof(size_t)".into(),
                    default: "0".into(),
                    random: |_s| return random::<usize>().to_string(),
                    compare: "CMP_SIZE_T".into(),
                    global_defenition: "".into(),
                    instructions: vec![
                        "+".into(),
                        "-".into(),
                        "*".into(),
                        "/".into(),
                        "%".into(),
                        "&".into(),
                        "|".into(),
                        "^".into(),
                    ],
                    instruction_function: None,
                    self_: None,
                },
            ),
            (
                "float".to_string(),
                TypeInformation {
                    size: "sizeof(float)".into(),
                    default: "0.0".into(),
                    random: |_s| return random::<f32>().to_string(),
                    compare: "CMP_FLOAT".into(),
                    global_defenition: "".into(),
                    instructions: vec!["+".into(), "-".into(), "*".into(), "/".into()],
                    instruction_function: None,
                    self_: None,
                },
            ),
            (
                "double".to_string(),
                TypeInformation {
                    size: "sizeof(double)".into(),
                    default: "0.0".into(),
                    random: |_s| return random::<f64>().to_string(),
                    compare: "CMP_DOUBLE".into(),
                    global_defenition: "".into(),
                    instructions: vec!["+".into(), "-".into(), "*".into(), "/".into()],
                    instruction_function: None,
                    self_: None,
                },
            ),
            (
                "char*".to_string(),
                TypeInformation {
                    size: "sizeof(char*)".into(),
                    default: "0.0".into(),
                    random: |_s| return format!("\"{}\"", RandomString::new(None, None).value),
                    compare: "CMP_STRING".into(),
                    global_defenition: "".into(),
                    instructions: vec!["append".into(), "dup".into()],
                    instruction_function: Some(|a, b, i| {
                        if i == "append" {
                            format!("__strcat({a}, {})", b.unwrap())
                        } else {
                            format!("__strdup({a})")
                        }
                    }),
                    self_: None,
                },
            ),
        ]));
}