daku 0.5.0

Interface to the Daku API
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
144

//! FFI bindings to the Daku API.

/// Portal IDs
#[repr(u32)]
#[derive(Debug, Copy, Clone)]
pub enum Portal {
    /// Logging API (stdout/printf)
    Log = 0,
    /// Developer command API (stdin/scanf)
    Prompt = 1,
    /// Set user information API (username, display name)
    Account = 2,
    /// Get user information API (username, display name)
    User = 3,
    /// Set system information API (system nickname, hostname)
    System = 4,
    /// Get system information API (system nickname, hostname)
    Host = 5,
    /// Set hardware features API (overclock, hardware time)
    Hardware = 6,
    /// Get hardware features API (cpu / gpu specs)
    Platform = 7,
    /// Task spawning API
    Spawn = 8,
    /// Blocking task spawning API
    SpawnBlocking = 9,
    /// MPMC Channel API
    Channel = 10,
    /// Account API (create / delete users)
    Admin = 11,
}

/// Channel Zero Command
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct Connect {
    /// The capacity of the ready list
    pub ready_capacity: usize,
    /// Reference to uninitialized ready list
    pub ready_data: *mut usize,
    /// The number of new portals
    pub portals_size: usize,
    /// in: List of new portal IDs - out: List of new portal channel IDs
    pub portals_data: *mut u32,
}

/// A queued command
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct Command {
    /// Ready index for when command completes
    pub ready: usize,
    /// Channel id to use
    pub channel: u32,
    /// Data buffer size
    pub size: usize,
    /// Data buffer reference
    pub data: *const (),
}

#[link(wasm_import_module = "daku")]
extern "C" {
    /// Unsafe asynchronous request FFI call
    pub fn ar(size: usize, data: *const Command) -> usize;
    /// Unstable debug call
    pub fn dbg(size: usize, text: *const u8);
}

/// Log level, pretty much copied from
/// [`log::Level`](https://docs.rs/log/0.4.17/log/enum.Level.html).
#[repr(usize)]
#[derive(Debug, Copy, Clone)]
pub enum Level {
    /// The “trace” level.
    ///
    /// Designates very low priority, often extremely verbose, information.
    Trace = 0b0000_0000_0000_0000_0000_0000_0000_0000,
    /// The “debug” level.
    ///
    /// Designates lower priority information.
    Debug = 0b0010_0000_0000_0000_0000_0000_0000_0000,
    /// The “info” level.
    ///
    /// Designates useful information.
    Info = 0b0100_0000_0000_0000_0000_0000_0000_0000,
    /// The “warn” level.
    ///
    /// Designates hazardous situations.
    Warn = 0b0110_0000_0000_0000_0000_0000_0000_0000,
    /// The “error” level.
    ///
    /// Designates very serious errors.
    Error = 0b1000_0000_0000_0000_0000_0000_0000_0000,
    /// The “trap” level.
    ///
    /// Trigger a trap without panicking.
    Trap = 0b1010_0000_0000_0000_0000_0000_0000_0000,
    /// Bit Mask.
    Mask = 0b1110_0000_0000_0000_0000_0000_0000_0000,
}

/// Spawn a task with state
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct Spawn {
    /// Task's asynchronous function (calls to `ar()` act as `.await` points)
    pub func: extern "C" fn(data: *mut ()),
    /// State to pass to asynchronous task function
    pub data: *mut (),
}

/// Portal Log Command
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct Log {
    /// Target size / log level
    pub target_size: usize,
    /// Target bytes
    pub target_data: *const u8,
    /// Message size
    pub message_size: usize,
    /// Message bytes
    pub message_data: *const u8,
}

/// UTF-8 text
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct Text {
    /// Length of string
    pub size: usize,
    /// UTF-8 String
    pub data: *mut u8,
}

/// Developer console prompt
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct Prompt {
    /// Text (in/out)
    pub text: *mut Text,
    /// Capacity (in/out)
    pub capacity: *mut usize,
}