drone-micropython-core 0.1.1

MicroPython for Drone.
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 alloc::alloc;
use cmd::{Cmd, CmdKind, CmdRes};
use core::alloc::Layout;
use core::ptr;
use core::sync::atomic::AtomicBool;
use drone_core::drv::{Driver, Resource};
use drone_core::ffi::c_void;
#[cfg(feature = "io")]
use drone_core::ffi::CStr;
use drone_core::stack_adapter::{Adapter, Context, Stack};
#[cfg(feature = "io")]
use exec::exec_path;
use exec::{exec_source, UncaughtException};
use futures::prelude::*;
use rt::{gc_init, mp_deinit, mp_init};

static CREATED: AtomicBool = AtomicBool::new(false);
static mut HEAP: *mut u8 = ptr::null_mut();

/// MicroPython session core driver.
#[derive(Driver)]
#[driver(forward)]
pub struct MpSessCore<T: MpSessResCore>(T);

/// MicroPython session core resource.
pub trait MpSessResCore: Resource<Source = Self> + Driver {
  /// Stack storage.
  type Stack: Stack<Cmd, CmdRes, Self::Req, Self::ReqRes>;

  /// Context handler.
  type Context: Context<Self::Req, Self::ReqRes>;

  /// Possible requests.
  type Req: Send + 'static;

  /// Possible request results.
  type ReqRes: Send + 'static;

  /// Possible errors.
  type Error: From<UncaughtException>;

  /// Stack size.
  const STACK_SIZE: usize;

  /// Heap size.
  const HEAP_SIZE: usize;

  /// Returns a mutable reference to the stack object.
  fn stack(&mut self) -> &mut Self::Stack;

  /// Runs a request `req` asynchronously.
  fn run_req<'sess>(
    &'sess mut self,
    req: Self::Req,
  ) -> Box<Future<Item = Self::ReqRes, Error = Self::Error> + 'sess>;

  /// Runs at the first entrance into command loop.
  fn init();
}

impl<T: MpSessResCore> Adapter for MpSessCore<T> {
  type Stack = T::Stack;
  type Context = T::Context;
  type Cmd = Cmd;
  type CmdRes = CmdRes;
  type Req = T::Req;
  type ReqRes = T::ReqRes;
  type Error = T::Error;

  const STACK_SIZE: usize = T::STACK_SIZE;

  fn singleton() -> Option<&'static AtomicBool> {
    Some(&CREATED)
  }

  fn init() {
    T::init();
    unsafe {
      HEAP = alloc::alloc(heap_layout(T::HEAP_SIZE));
      gc_init(HEAP as *mut c_void, HEAP.add(T::HEAP_SIZE) as *mut c_void);
      mp_init();
    }
  }

  fn deinit() {
    unsafe {
      mp_deinit();
      alloc::dealloc(HEAP, heap_layout(T::HEAP_SIZE));
    }
  }

  fn stack(&mut self) -> &mut Self::Stack {
    self.0.stack()
  }

  fn run_cmd(cmd: Cmd, _context: Self::Context) -> CmdRes {
    match cmd {
      Cmd(CmdKind::ExecSource { source }) => CmdRes {
        exec_source: unsafe { exec_source(&*source) },
      },
      #[cfg(feature = "io")]
      Cmd(CmdKind::ExecPath { path }) => CmdRes {
        exec_path: unsafe { exec_path(&*path) },
      },
    }
  }

  fn run_req<'sess>(
    &'sess mut self,
    req: Self::Req,
  ) -> Box<Future<Item = Self::ReqRes, Error = Self::Error> + 'sess> {
    self.0.run_req(req)
  }
}

impl<T: MpSessResCore> MpSessCore<T> {
  /// Executes a script contained in `source`.
  pub fn exec_source<'sess>(
    &'sess mut self,
    source: &'sess str,
  ) -> impl Future<Item = (), Error = T::Error> + 'sess {
    async(static move || unsafe {
      await!(self.cmd(Cmd(CmdKind::ExecSource { source })))?.exec_source?;
      Ok(())
    })
  }

  /// Executes a script located at `path`.
  #[cfg(feature = "io")]
  pub fn exec_path<'sess>(
    &'sess mut self,
    path: &'sess CStr,
  ) -> impl Future<Item = (), Error = T::Error> + 'sess {
    async(static move || unsafe {
      await!(self.cmd(Cmd(CmdKind::ExecPath { path })))?.exec_path?;
      Ok(())
    })
  }
}

fn heap_layout(size: usize) -> Layout {
  unsafe { Layout::from_size_align_unchecked(size, 1) }
}