strop 0.3.0

stochastically generates machine code
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

use crate::Callable;
use crate::Disassemble;
use crate::IterationResult;
use crate::RunResult;
use crate::Step;

/// A wrapper which writes to stdout
#[derive(Debug, Clone)]
pub struct Trace<T: Disassemble + Clone>(T);

/// Wraps an object up in a `Trace`, so that each mutation is printed to stdout.
pub trait ToTrace {
    /// Wraps an object up in a `Trace`, so that each mutation is printed to stdout.
    fn trace(self) -> Trace<Self>
    where
        Self: Sized + Clone + Disassemble,
    {
        Trace::<Self>(self)
    }
}

impl<T> ToTrace for T {}

impl<T: Disassemble + Clone> Disassemble for Trace<T> {
    fn dasm(&self) {
        self.0.dasm();
    }
}

impl<Insn, S: crate::BruteforceSearch<Insn> + Clone + Disassemble> crate::BruteforceSearch<Insn>
    for Trace<S>
{
    fn analyze_this(&self) -> Result<(), crate::StaticAnalysis<Insn>> {
        Ok(())
    }
    fn inner(&mut self) -> &mut dyn crate::BruteforceSearch<Insn> {
        &mut self.0
    }
    fn step(&mut self) {
        self.inner().step();
        println!("stepped:");
        self.dasm();
    }
}

impl<T: Step + Clone + Disassemble> Step for Trace<T> {
    fn next(&mut self) -> IterationResult {
        self.0.next()?;
        println!("trace:");
        self.0.dasm();
        Ok(())
    }

    fn first() -> Self {
        Self(T::first())
    }
}

impl<
        InputParameters,
        ReturnType,
        T: Callable<InputParameters, ReturnType> + Clone + Disassemble,
    > Callable<InputParameters, ReturnType> for Trace<T>
{
    fn call(&self, parameters: InputParameters) -> RunResult<ReturnType> {
        self.0.call(parameters)
    }
}