cr 0.1.1

Rust safe bindings for cr.h: A Simple C Hot Reload Header-only Library
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

#[macro_use]
extern crate cr;

use std::thread;
use std::time::Duration;

mod basic_state;

use basic_state::*;

use cr::cr_op::*;

cr_main!(plugin_main);

pub fn plugin_main(ctx: &mut BasicPlugin, cr_op: cr::cr_op) -> i32 {
    // Test "guest" feature.
    #[cfg(not(feature = "guest"))]
    {
        println!("Guest compiled with host-side code.");
        // This code will only run if the "guest" feature is not used.
        let plugin = BasicPlugin::new(BasicState { counter: 0 }, "test");
        println!("- plugin = {:?}", plugin);
    }

    println!("test recompile. test1");
    //panic!("test");
    // Test crash.
    // Rollback to the previous version seems to work once.
    // Then on the next reload it gets stuck in a setjmp/longjmp loop?
    /*
    unsafe {
        let ptr
            = std::ptr::null_mut() as *mut std::os::raw::c_int;
        // invalid read.
        println!("Read from null pointer: {:?}", *ptr);
        // invalid write.
        *ptr = 0x1234;
    }
    // */
    match cr_op {
        CR_LOAD => {
            println!("Plugin load. version = {}", ctx.get_version());
        }
        CR_STEP => {
            let version = ctx.get_version();
            let state = ctx.state_mut();
            state.counter += 1;
            println!(
                "Plugin step. count = {}. version = {}",
                state.counter, version
            );

            // slow down the printing.
            thread::sleep(Duration::from_millis(200));
        }
        CR_UNLOAD => {
            println!("Plugin unload. version = {}", ctx.get_version());
        }
        CR_CLOSE => {
            println!("Plugin close. version = {}", ctx.get_version());
        }
    }

    return 0;
}