2018-03-20 19:16:32 +00:00
|
|
|
// Copyright 2018 Mozilla
|
|
|
|
//
|
|
|
|
// Licensed under the Apache License, Version 2.0 (the "License"); you may not use
|
|
|
|
// this file except in compliance with the License. You may obtain a copy of the
|
|
|
|
// License at http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
// Unless required by applicable law or agreed to in writing, software distributed
|
|
|
|
// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
|
|
|
|
// CONDITIONS OF ANY KIND, either express or implied. See the License for the
|
|
|
|
// specific language governing permissions and limitations under the License.
|
|
|
|
|
|
|
|
pub mod strings {
|
2020-01-14 15:46:21 +00:00
|
|
|
use std::ffi::{CStr, CString};
|
2018-04-05 10:21:48 +00:00
|
|
|
use std::os::raw::c_char;
|
|
|
|
|
2020-01-14 15:46:21 +00:00
|
|
|
use mentat::Keyword;
|
2018-03-20 19:16:32 +00:00
|
|
|
|
2020-08-06 03:03:58 +00:00
|
|
|
/// # Safety
|
|
|
|
///
|
|
|
|
/// This function TODO
|
|
|
|
pub unsafe fn c_char_to_string(cchar: *const c_char) -> &'static str {
|
2018-06-25 19:10:11 +00:00
|
|
|
assert!(!cchar.is_null());
|
2020-08-06 03:03:58 +00:00
|
|
|
let c_str = CStr::from_ptr(cchar);
|
2018-05-14 15:20:36 +00:00
|
|
|
c_str.to_str().unwrap_or("")
|
2018-03-20 19:16:32 +00:00
|
|
|
}
|
|
|
|
|
2020-01-14 15:46:21 +00:00
|
|
|
pub fn string_to_c_char<T>(r_string: T) -> *mut c_char
|
|
|
|
where
|
|
|
|
T: Into<String>,
|
|
|
|
{
|
2018-04-05 10:21:48 +00:00
|
|
|
CString::new(r_string.into()).unwrap().into_raw()
|
|
|
|
}
|
|
|
|
|
2018-05-14 15:20:36 +00:00
|
|
|
pub fn kw_from_string(keyword_string: &'static str) -> Keyword {
|
2018-04-26 16:26:12 +00:00
|
|
|
// TODO: validate. The input might not be a keyword!
|
2020-08-06 03:03:58 +00:00
|
|
|
let attr_name = keyword_string.trim_start_matches(':');
|
|
|
|
let parts: Vec<&str> = attr_name.split('/').collect();
|
2018-05-11 16:52:17 +00:00
|
|
|
Keyword::namespaced(parts[0], parts[1])
|
2018-03-20 19:16:32 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub mod log {
|
2020-01-14 15:46:21 +00:00
|
|
|
#[cfg(all(target_os = "android", not(test)))]
|
2018-03-20 19:16:32 +00:00
|
|
|
use std::ffi::CString;
|
|
|
|
|
2020-01-14 15:46:21 +00:00
|
|
|
#[cfg(all(target_os = "android", not(test)))]
|
2018-03-20 19:16:32 +00:00
|
|
|
use android;
|
|
|
|
|
|
|
|
// TODO far from ideal. And, we might actually want to println in tests.
|
2020-01-14 15:46:21 +00:00
|
|
|
#[cfg(all(not(target_os = "android"), not(target_os = "ios")))]
|
2018-03-20 19:16:32 +00:00
|
|
|
pub fn d(_: &str) {}
|
|
|
|
|
2020-01-14 15:46:21 +00:00
|
|
|
#[cfg(all(target_os = "ios", not(test)))]
|
2018-03-20 19:16:32 +00:00
|
|
|
pub fn d(message: &str) {
|
|
|
|
eprintln!("{}", message);
|
|
|
|
}
|
|
|
|
|
2020-01-14 15:46:21 +00:00
|
|
|
#[cfg(all(target_os = "android", not(test)))]
|
2018-03-20 19:16:32 +00:00
|
|
|
pub fn d(message: &str) {
|
|
|
|
let message = CString::new(message).unwrap();
|
|
|
|
let message = message.as_ptr();
|
|
|
|
let tag = CString::new("Mentat").unwrap();
|
|
|
|
let tag = tag.as_ptr();
|
2018-04-05 10:21:48 +00:00
|
|
|
unsafe { android::__android_log_write(android::LogLevel::Debug as i32, tag, message) };
|
2018-03-20 19:16:32 +00:00
|
|
|
}
|
|
|
|
}
|
2018-06-25 19:10:11 +00:00
|
|
|
|
|
|
|
pub mod error {
|
|
|
|
use super::strings::string_to_c_char;
|
|
|
|
use std::boxed::Box;
|
|
|
|
use std::fmt::Display;
|
2020-01-14 15:46:21 +00:00
|
|
|
use std::os::raw::c_char;
|
2018-06-25 19:10:11 +00:00
|
|
|
use std::ptr;
|
|
|
|
|
|
|
|
/// Represents an error that occurred on the mentat side. Many mentat FFI functions take a
|
|
|
|
/// `*mut ExternError` as the last argument. This is an out parameter that indicates an
|
|
|
|
/// error that occurred during that function's execution (if any).
|
|
|
|
///
|
|
|
|
/// For functions that use this pattern, if the ExternError's message property is null, then no
|
|
|
|
/// error occurred. If the message is non-null then it contains a string description of the
|
|
|
|
/// error that occurred.
|
|
|
|
///
|
|
|
|
/// Important: This message is allocated on the heap and it is the consumer's responsibility to
|
|
|
|
/// free it using `destroy_mentat_string`!
|
|
|
|
///
|
|
|
|
/// While this pattern is not ergonomic in Rust, it offers two main benefits:
|
|
|
|
///
|
|
|
|
/// 1. It avoids defining a large number of `Result`-shaped types in the FFI consumer, as would
|
|
|
|
/// be required with something like an `struct ExternResult<T> { ok: *mut T, err:... }`
|
|
|
|
/// 2. It offers additional type safety over `struct ExternResult { ok: *mut c_void, err:... }`,
|
|
|
|
/// which helps avoid memory safety errors.
|
|
|
|
#[repr(C)]
|
|
|
|
#[derive(Debug)]
|
|
|
|
pub struct ExternError {
|
|
|
|
pub message: *mut c_char,
|
|
|
|
// TODO: Include an error code here.
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Default for ExternError {
|
|
|
|
fn default() -> ExternError {
|
2020-01-14 15:46:21 +00:00
|
|
|
ExternError {
|
|
|
|
message: ptr::null_mut(),
|
|
|
|
}
|
2018-06-25 19:10:11 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Translate Result<T, E>, into something C can understand, when T is not `#[repr(C)]`
|
|
|
|
///
|
|
|
|
/// - If `result` is `Ok(v)`, moves `v` to the heap and returns a pointer to it, and sets
|
|
|
|
/// `error` to a state indicating that no error occurred (`message` is null).
|
|
|
|
/// - If `result` is `Err(e)`, returns a null pointer and stores a string representing the error
|
|
|
|
/// message (which was allocated on the heap and should eventually be freed) into
|
|
|
|
/// `error.message`
|
2020-08-06 03:03:58 +00:00
|
|
|
/// # Safety
|
|
|
|
/// Be afraid... TODO
|
2018-06-25 19:10:11 +00:00
|
|
|
pub unsafe fn translate_result<T, E>(result: Result<T, E>, error: *mut ExternError) -> *mut T
|
2020-01-14 15:46:21 +00:00
|
|
|
where
|
|
|
|
E: Display,
|
|
|
|
{
|
2018-06-25 19:10:11 +00:00
|
|
|
// TODO: can't unwind across FFI...
|
|
|
|
assert!(!error.is_null(), "Error output parameter is not optional");
|
|
|
|
let error = &mut *error;
|
|
|
|
error.message = ptr::null_mut();
|
|
|
|
match result {
|
|
|
|
Ok(val) => Box::into_raw(Box::new(val)),
|
|
|
|
Err(e) => {
|
|
|
|
error.message = string_to_c_char(e.to_string());
|
|
|
|
ptr::null_mut()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Translate Result<Option<T>, E> into something C can understand, when T is not `#[repr(C)]`.
|
|
|
|
///
|
|
|
|
/// - If `result` is `Ok(Some(v))`, moves `v` to the heap and returns a pointer to it, and
|
|
|
|
/// sets `error` to a state indicating that no error occurred (`message` is null).
|
|
|
|
/// - If `result` is `Ok(None)` returns a null pointer, but sets `error` to a state indicating
|
|
|
|
/// that no error occurred (`message` is null).
|
|
|
|
/// - If `result` is `Err(e)`, returns a null pointer and stores a string representing the error
|
|
|
|
/// message (which was allocated on the heap and should eventually be freed) into
|
|
|
|
/// `error.message`
|
2020-08-06 03:03:58 +00:00
|
|
|
/// # Safety
|
|
|
|
/// Be afraid... TODO
|
2020-01-14 15:46:21 +00:00
|
|
|
pub unsafe fn translate_opt_result<T, E>(
|
|
|
|
result: Result<Option<T>, E>,
|
|
|
|
error: *mut ExternError,
|
|
|
|
) -> *mut T
|
|
|
|
where
|
|
|
|
E: Display,
|
|
|
|
{
|
2018-06-25 19:10:11 +00:00
|
|
|
assert!(!error.is_null(), "Error output parameter is not optional");
|
|
|
|
let error = &mut *error;
|
|
|
|
error.message = ptr::null_mut();
|
|
|
|
match result {
|
|
|
|
Ok(Some(val)) => Box::into_raw(Box::new(val)),
|
|
|
|
Ok(None) => ptr::null_mut(),
|
|
|
|
Err(e) => {
|
|
|
|
error.message = string_to_c_char(e.to_string());
|
|
|
|
ptr::null_mut()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Identical to `translate_result`, but with additional type checking for the case that we have
|
|
|
|
/// a `Result<(), E>` (which we're about to drop on the floor).
|
2020-08-06 03:03:58 +00:00
|
|
|
/// # Safety
|
|
|
|
/// Be afraid... TODO
|
2020-01-14 15:46:21 +00:00
|
|
|
pub unsafe fn translate_void_result<E>(result: Result<(), E>, error: *mut ExternError)
|
|
|
|
where
|
|
|
|
E: Display,
|
|
|
|
{
|
2018-06-25 19:10:11 +00:00
|
|
|
// Note that Box<T> guarantees that if T is zero sized, it's not heap allocated. So not
|
|
|
|
// only do we never need to free the return value of this, it would be a problem if someone did.
|
|
|
|
translate_result(result, error);
|
|
|
|
}
|
|
|
|
}
|