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

use crate::crunningfunction::*;
use crate::cstruct::*;
use crate::statics::*;

use rand::prelude::*;

#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct RandomCFile {
    number_of_functions: u8,
    generated_functions: Vec<String>,
    code: String,
}

static STARTING_C_CODE: &str = "// #include <math.h>
#include <assert.h>
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>

// #define FLT_EPSILON 0.0001
// #define MAX(a, b) a > b ? (a) : (b)
// #define CMP(a, b) ((a) == (b))
// #define CMP_INT(a, b) CMP(a, b)
// #define CMP_FLOAT(a, b) (fabs(CMP(a, b)) <= FPS_EPSILON * max(fabs((a)), fabs((b))))
// #define CMP_STR(a, b) (strcmp((a), (b)))
// #define CMP_BOOL(a, b) CMP(a, b)
// #define CMP_SIZE_T(a, b) CMP(a, b)
// #define CMP_STRUCT(a, b) (memcmp((a), (b), sizeof(a)))

volatile char* __strdup(char* a) {
    size_t l = strlen(a);
    char* r = (char*) malloc(sizeof(char) * l);
    assert(r != NULL);
    memcpy(r, a, sizeof(char) * l);
    return r;
}

volatile char* __strcat(char* a, char* b) {
    size_t al = strlen(a);
    size_t bl = strlen(b);
    char* r = (char*) malloc(sizeof(char) * (al + bl));
    assert(r != NULL);
    memcpy(r, a, sizeof(char) * al);
    memcpy(r + (sizeof(char) * al), b, sizeof(char) * bl);
    return r;
}

";

impl RandomCFile {
    pub fn new(number_of_functions: u8, number_of_structs_to_generate: u8) -> Self {
        let mut rt = Self::default();
        rt.number_of_functions = number_of_functions;
        rt.code = STARTING_C_CODE.to_string();

        let mut rng = thread_rng();

        for _ in 0..number_of_structs_to_generate {
            let a = CStruct::new(rng.gen_range(1..12) as u8, None, None);

            rt.code += &(a.generate_defenition() + "\n");
        }

        AVAILABLE_TYPES
            .iter()
            .map(|t| {
                AVAILABLE_TYPES
                    .get(t.pair().0)
                    .unwrap()
                    .global_defenition
                    .clone()
            })
            .filter(|x| x.is_empty())
            .collect::<Vec<_>>()
            .join("\n");

        rt.generate_functions();

        return rt;
    }

    fn generate_function(&mut self) {
        let f = CRunningFunction::new(None);
        self.code += f.finish();
        self.generated_functions.push(f.name);
    }

    fn generate_functions(&mut self) {
        for _ in 0..self.number_of_functions {
            self.generate_function();
        }

        self.code = self.code[0..self.code.len() - 2].to_string();
    }

    pub fn finish(&self) -> &str {
        return &self.code;
    }

    pub fn get_generated_function_names(&self) -> Vec<String> {
        return self.generated_functions.clone();
    }
}