WARNING! Access to this system is limited to authorised users only.
Unauthorised users may be subject to prosecution.
Unauthorised access to this system is a criminal offence under Australian law (Federal Crimes Act 1914 Part VIA)
It is a criminal offence to:
(1) Obtain access to data without authority. -Penalty 2 years imprisonment.
(2) Damage, delete, alter or insert data without authority. -Penalty 10 years imprisonment.
User activity is monitored and recorded. Anyone using this system expressly consents to such monitoring and recording.

Commit f092e7f3 authored by qinsoon's avatar qinsoon
Browse files

renaming APIMuValue to APIHandleKey

parent f3a7b9af
......@@ -37,13 +37,13 @@ impl MuBundle {
}
#[derive(Copy, Clone, Debug)]
pub struct APIMuValue {
pub struct APIHandleKey {
pub id: MuID,
pub v: APIMuValueKind
pub v: APIHandleKeyKind
}
#[derive(Copy, Clone, Debug)]
pub enum APIMuValueKind {
pub enum APIHandleKeyKind {
Int,
Float,
Double,
......@@ -88,9 +88,9 @@ pub enum APIMuValueKind {
macro_rules! handle_constructor {
($fn_name: ident, $kind: ident) => {
pub fn $fn_name(id: MuID) -> APIMuValue {
APIMuValue{
id: id, v: APIMuValueKind::$kind
pub fn $fn_name(id: MuID) -> APIHandleKey {
APIHandleKey{
id: id, v: APIHandleKeyKind::$kind
}
}
}
......
......@@ -19,7 +19,7 @@ mod deps {
pub type MuName = String;
pub type CName = MuName;
pub struct APIMuValue {
pub struct APIHandleKey {
// stub
}
......
......@@ -77,195 +77,195 @@ impl MuCtx {
panic!("Not implemented")
}
pub fn handle_from_sint8(&mut self, num: i8, len: c_int) -> *const APIMuValue {
pub fn handle_from_sint8(&mut self, num: i8, len: c_int) -> *const APIHandleKey {
panic!("Not implemented")
}
pub fn handle_from_uint8(&mut self, num: u8, len: c_int) -> *const APIMuValue {
pub fn handle_from_uint8(&mut self, num: u8, len: c_int) -> *const APIHandleKey {
panic!("Not implemented")
}
pub fn handle_from_sint16(&mut self, num: i16, len: c_int) -> *const APIMuValue {
pub fn handle_from_sint16(&mut self, num: i16, len: c_int) -> *const APIHandleKey {
panic!("Not implemented")
}
pub fn handle_from_uint16(&mut self, num: u16, len: c_int) -> *const APIMuValue {
pub fn handle_from_uint16(&mut self, num: u16, len: c_int) -> *const APIHandleKey {
panic!("Not implemented")
}
pub fn handle_from_sint32(&mut self, num: i32, len: c_int) -> *const APIMuValue {
pub fn handle_from_sint32(&mut self, num: i32, len: c_int) -> *const APIHandleKey {
panic!("Not implemented")
}
pub fn handle_from_uint32(&mut self, num: u32, len: c_int) -> *const APIMuValue {
pub fn handle_from_uint32(&mut self, num: u32, len: c_int) -> *const APIHandleKey {
panic!("Not implemented")
}
pub fn handle_from_sint64(&mut self, num: i64, len: c_int) -> *const APIMuValue {
pub fn handle_from_sint64(&mut self, num: i64, len: c_int) -> *const APIHandleKey {
panic!("Not implemented")
}
pub fn handle_from_uint64(&mut self, num: u64, len: c_int) -> *const APIMuValue {
pub fn handle_from_uint64(&mut self, num: u64, len: c_int) -> *const APIHandleKey {
panic!("Not implemented")
}
pub fn handle_from_uint64s(&mut self, nums: &[u64], len: c_int) -> *const APIMuValue {
pub fn handle_from_uint64s(&mut self, nums: &[u64], len: c_int) -> *const APIHandleKey {
panic!("Not implemented")
}
pub fn handle_from_float(&mut self, num: f32) -> *const APIMuValue {
pub fn handle_from_float(&mut self, num: f32) -> *const APIHandleKey {
panic!("Not implemented")
}
pub fn handle_from_double(&mut self, num: f64) -> *const APIMuValue {
pub fn handle_from_double(&mut self, num: f64) -> *const APIHandleKey {
panic!("Not implemented")
}
pub fn handle_from_ptr(&mut self, mu_type: MuID, ptr: CMuCPtr) -> *const APIMuValue {
pub fn handle_from_ptr(&mut self, mu_type: MuID, ptr: CMuCPtr) -> *const APIHandleKey {
panic!("Not implemented")
}
pub fn handle_from_fp(&mut self, mu_type: MuID, fp: CMuCFP) -> *const APIMuValue {
pub fn handle_from_fp(&mut self, mu_type: MuID, fp: CMuCFP) -> *const APIHandleKey {
panic!("Not implemented")
}
pub fn handle_to_sint8(&mut self, opnd: &APIMuValue) -> i8 {
pub fn handle_to_sint8(&mut self, opnd: &APIHandleKey) -> i8 {
panic!("Not implemented")
}
pub fn handle_to_uint8(&mut self, opnd: &APIMuValue) -> u8 {
pub fn handle_to_uint8(&mut self, opnd: &APIHandleKey) -> u8 {
panic!("Not implemented")
}
pub fn handle_to_sint16(&mut self, opnd: &APIMuValue) -> i16 {
pub fn handle_to_sint16(&mut self, opnd: &APIHandleKey) -> i16 {
panic!("Not implemented")
}
pub fn handle_to_uint16(&mut self, opnd: &APIMuValue) -> u16 {
pub fn handle_to_uint16(&mut self, opnd: &APIHandleKey) -> u16 {
panic!("Not implemented")
}
pub fn handle_to_sint32(&mut self, opnd: &APIMuValue) -> i32 {
pub fn handle_to_sint32(&mut self, opnd: &APIHandleKey) -> i32 {
panic!("Not implemented")
}
pub fn handle_to_uint32(&mut self, opnd: &APIMuValue) -> u32 {
pub fn handle_to_uint32(&mut self, opnd: &APIHandleKey) -> u32 {
panic!("Not implemented")
}
pub fn handle_to_sint64(&mut self, opnd: &APIMuValue) -> i64 {
pub fn handle_to_sint64(&mut self, opnd: &APIHandleKey) -> i64 {
panic!("Not implemented")
}
pub fn handle_to_uint64(&mut self, opnd: &APIMuValue) -> u64 {
pub fn handle_to_uint64(&mut self, opnd: &APIHandleKey) -> u64 {
panic!("Not implemented")
}
pub fn handle_to_float(&mut self, opnd: &APIMuValue) -> f32 {
pub fn handle_to_float(&mut self, opnd: &APIHandleKey) -> f32 {
panic!("Not implemented")
}
pub fn handle_to_double(&mut self, opnd: &APIMuValue) -> f64 {
pub fn handle_to_double(&mut self, opnd: &APIHandleKey) -> f64 {
panic!("Not implemented")
}
pub fn handle_to_ptr(&mut self, opnd: &APIMuValue) -> CMuCPtr {
pub fn handle_to_ptr(&mut self, opnd: &APIHandleKey) -> CMuCPtr {
panic!("Not implemented")
}
pub fn handle_to_fp(&mut self, opnd: &APIMuValue) -> CMuCFP {
pub fn handle_to_fp(&mut self, opnd: &APIHandleKey) -> CMuCFP {
panic!("Not implemented")
}
pub fn handle_from_const(&mut self, id: MuID) -> *const APIMuValue {
pub fn handle_from_const(&mut self, id: MuID) -> *const APIHandleKey {
panic!("Not implemented")
}
pub fn handle_from_global(&mut self, id: MuID) -> *const APIMuValue {
pub fn handle_from_global(&mut self, id: MuID) -> *const APIHandleKey {
panic!("Not implemented")
}
pub fn handle_from_func(&mut self, id: MuID) -> *const APIMuValue {
pub fn handle_from_func(&mut self, id: MuID) -> *const APIHandleKey {
panic!("Not implemented")
}
pub fn handle_from_expose(&mut self, id: MuID) -> *const APIMuValue {
pub fn handle_from_expose(&mut self, id: MuID) -> *const APIHandleKey {
panic!("Not implemented")
}
pub fn delete_value(&mut self, opnd: &APIMuValue) {
pub fn delete_value(&mut self, opnd: &APIHandleKey) {
panic!("Not implemented")
}
pub fn ref_eq(&mut self, lhs: &APIMuValue, rhs: &APIMuValue) -> bool {
pub fn ref_eq(&mut self, lhs: &APIHandleKey, rhs: &APIHandleKey) -> bool {
panic!("Not implemented")
}
pub fn ref_ult(&mut self, lhs: &APIMuValue, rhs: &APIMuValue) -> bool {
pub fn ref_ult(&mut self, lhs: &APIHandleKey, rhs: &APIHandleKey) -> bool {
panic!("Not implemented")
}
pub fn extract_value(&mut self, str: &APIMuValue, index: c_int) -> *const APIMuValue {
pub fn extract_value(&mut self, str: &APIHandleKey, index: c_int) -> *const APIHandleKey {
panic!("Not implemented")
}
pub fn insert_value(&mut self, str: &APIMuValue, index: c_int, newval: &APIMuValue) -> *const APIMuValue {
pub fn insert_value(&mut self, str: &APIHandleKey, index: c_int, newval: &APIHandleKey) -> *const APIHandleKey {
panic!("Not implemented")
}
pub fn extract_element(&mut self, str: &APIMuValue, index: &APIMuValue) -> *const APIMuValue {
pub fn extract_element(&mut self, str: &APIHandleKey, index: &APIHandleKey) -> *const APIHandleKey {
panic!("Not implemented")
}
pub fn insert_element(&mut self, str: &APIMuValue, index: &APIMuValue, newval: &APIMuValue) -> *const APIMuValue {
pub fn insert_element(&mut self, str: &APIHandleKey, index: &APIHandleKey, newval: &APIHandleKey) -> *const APIHandleKey {
panic!("Not implemented")
}
pub fn new_fixed(&mut self, mu_type: MuID) -> *const APIMuValue {
pub fn new_fixed(&mut self, mu_type: MuID) -> *const APIHandleKey {
panic!("Not implemented")
}
pub fn new_hybrid(&mut self, mu_type: MuID, length: &APIMuValue) -> *const APIMuValue {
pub fn new_hybrid(&mut self, mu_type: MuID, length: &APIHandleKey) -> *const APIHandleKey {
panic!("Not implemented")
}
pub fn refcast(&mut self, opnd: &APIMuValue, new_type: MuID) -> *const APIMuValue {
pub fn refcast(&mut self, opnd: &APIHandleKey, new_type: MuID) -> *const APIHandleKey {
panic!("Not implemented")
}
pub fn get_iref(&mut self, opnd: &APIMuValue) -> *const APIMuValue {
pub fn get_iref(&mut self, opnd: &APIHandleKey) -> *const APIHandleKey {
panic!("Not implemented")
}
pub fn get_field_iref(&mut self, opnd: &APIMuValue, field: c_int) -> *const APIMuValue {
pub fn get_field_iref(&mut self, opnd: &APIHandleKey, field: c_int) -> *const APIHandleKey {
panic!("Not implemented")
}
pub fn get_elem_iref(&mut self, opnd: &APIMuValue, index: &APIMuValue) -> *const APIMuValue {
pub fn get_elem_iref(&mut self, opnd: &APIHandleKey, index: &APIHandleKey) -> *const APIHandleKey {
panic!("Not implemented")
}
pub fn shift_iref(&mut self, opnd: &APIMuValue, offset: &APIMuValue) -> *const APIMuValue {
pub fn shift_iref(&mut self, opnd: &APIHandleKey, offset: &APIHandleKey) -> *const APIHandleKey {
panic!("Not implemented")
}
pub fn get_var_part_iref(&mut self, opnd: &APIMuValue) -> *const APIMuValue {
pub fn get_var_part_iref(&mut self, opnd: &APIHandleKey) -> *const APIHandleKey {
panic!("Not implemented")
}
pub fn load(&mut self, ord: CMuMemOrd, loc: &APIMuValue) -> *const APIMuValue {
pub fn load(&mut self, ord: CMuMemOrd, loc: &APIHandleKey) -> *const APIHandleKey {
panic!("Not implemented")
}
pub fn store(&mut self, ord: CMuMemOrd, loc: &APIMuValue, newval: &APIMuValue) {
pub fn store(&mut self, ord: CMuMemOrd, loc: &APIHandleKey, newval: &APIHandleKey) {
panic!("Not implemented")
}
pub fn cmpxchg(&mut self, ord_succ: CMuMemOrd, ord_fail: CMuMemOrd, weak: bool, loc: &APIMuValue, expected: &APIMuValue, desired: &APIMuValue, is_succ: *mut CMuBool) -> *const APIMuValue {
pub fn cmpxchg(&mut self, ord_succ: CMuMemOrd, ord_fail: CMuMemOrd, weak: bool, loc: &APIHandleKey, expected: &APIHandleKey, desired: &APIHandleKey, is_succ: *mut CMuBool) -> *const APIHandleKey {
panic!("Not implemented")
}
pub fn atomicrmw(&mut self, ord: CMuMemOrd, op: CMuAtomicRMWOptr, loc: &APIMuValue, opnd: &APIMuValue) -> *const APIMuValue {
pub fn atomicrmw(&mut self, ord: CMuMemOrd, op: CMuAtomicRMWOptr, loc: &APIHandleKey, opnd: &APIHandleKey) -> *const APIHandleKey {
panic!("Not implemented")
}
......@@ -273,107 +273,107 @@ impl MuCtx {
panic!("Not implemented")
}
pub fn new_stack(&mut self, func: &APIMuValue) -> *const APIMuValue {
pub fn new_stack(&mut self, func: &APIHandleKey) -> *const APIHandleKey {
panic!("Not implemented")
}
pub fn new_thread_nor(&mut self, stack: &APIMuValue, threadlocal: Option<&APIMuValue>, vals: Vec<&APIMuValue>) -> *const APIMuValue {
pub fn new_thread_nor(&mut self, stack: &APIHandleKey, threadlocal: Option<&APIHandleKey>, vals: Vec<&APIHandleKey>) -> *const APIHandleKey {
panic!("Not implemented")
}
pub fn new_thread_exc(&mut self, stack: &APIMuValue, threadlocal: Option<&APIMuValue>, exc: &APIMuValue) -> *const APIMuValue {
pub fn new_thread_exc(&mut self, stack: &APIHandleKey, threadlocal: Option<&APIHandleKey>, exc: &APIHandleKey) -> *const APIHandleKey {
panic!("Not implemented")
}
pub fn kill_stack(&mut self, stack: &APIMuValue) {
pub fn kill_stack(&mut self, stack: &APIHandleKey) {
panic!("Not implemented")
}
pub fn set_threadlocal(&mut self, thread: &APIMuValue, threadlocal: &APIMuValue) {
pub fn set_threadlocal(&mut self, thread: &APIHandleKey, threadlocal: &APIHandleKey) {
panic!("Not implemented")
}
pub fn get_threadlocal(&mut self, thread: &APIMuValue) -> *const APIMuValue {
pub fn get_threadlocal(&mut self, thread: &APIHandleKey) -> *const APIHandleKey {
panic!("Not implemented")
}
pub fn new_cursor(&mut self, stack: &APIMuValue) -> *const APIMuValue {
pub fn new_cursor(&mut self, stack: &APIHandleKey) -> *const APIHandleKey {
panic!("Not implemented")
}
pub fn next_frame(&mut self, cursor: &APIMuValue) {
pub fn next_frame(&mut self, cursor: &APIHandleKey) {
panic!("Not implemented")
}
pub fn copy_cursor(&mut self, cursor: &APIMuValue) -> *const APIMuValue {
pub fn copy_cursor(&mut self, cursor: &APIHandleKey) -> *const APIHandleKey {
panic!("Not implemented")
}
pub fn close_cursor(&mut self, cursor: &APIMuValue) {
pub fn close_cursor(&mut self, cursor: &APIHandleKey) {
panic!("Not implemented")
}
pub fn cur_func(&mut self, cursor: &APIMuValue) -> MuID {
pub fn cur_func(&mut self, cursor: &APIHandleKey) -> MuID {
panic!("Not implemented")
}
pub fn cur_func_ver(&mut self, cursor: &APIMuValue) -> MuID {
pub fn cur_func_ver(&mut self, cursor: &APIHandleKey) -> MuID {
panic!("Not implemented")
}
pub fn cur_inst(&mut self, cursor: &APIMuValue) -> MuID {
pub fn cur_inst(&mut self, cursor: &APIHandleKey) -> MuID {
panic!("Not implemented")
}
pub fn dump_keepalives(&mut self, cursor: &APIMuValue, results: *mut CMuValue) {
pub fn dump_keepalives(&mut self, cursor: &APIHandleKey, results: *mut CMuValue) {
panic!("Not implemented")
}
pub fn pop_frames_to(&mut self, cursor: &APIMuValue) {
pub fn pop_frames_to(&mut self, cursor: &APIHandleKey) {
panic!("Not implemented")
}
pub fn push_frame(&mut self, stack: &APIMuValue, func: &APIMuValue) {
pub fn push_frame(&mut self, stack: &APIHandleKey, func: &APIHandleKey) {
panic!("Not implemented")
}
pub fn tr64_is_fp(&mut self, value: &APIMuValue) -> bool {
pub fn tr64_is_fp(&mut self, value: &APIHandleKey) -> bool {
panic!("Not implemented")
}
pub fn tr64_is_int(&mut self, value: &APIMuValue) -> bool {
pub fn tr64_is_int(&mut self, value: &APIHandleKey) -> bool {
panic!("Not implemented")
}
pub fn tr64_is_ref(&mut self, value: &APIMuValue) -> bool {
pub fn tr64_is_ref(&mut self, value: &APIHandleKey) -> bool {
panic!("Not implemented")
}
pub fn tr64_to_fp(&mut self, value: &APIMuValue) -> *const APIMuValue {
pub fn tr64_to_fp(&mut self, value: &APIHandleKey) -> *const APIHandleKey {
panic!("Not implemented")
}
pub fn tr64_to_int(&mut self, value: &APIMuValue) -> *const APIMuValue {
pub fn tr64_to_int(&mut self, value: &APIHandleKey) -> *const APIHandleKey {
panic!("Not implemented")
}
pub fn tr64_to_ref(&mut self, value: &APIMuValue) -> *const APIMuValue {
pub fn tr64_to_ref(&mut self, value: &APIHandleKey) -> *const APIHandleKey {
panic!("Not implemented")
}
pub fn tr64_to_tag(&mut self, value: &APIMuValue) -> *const APIMuValue {
pub fn tr64_to_tag(&mut self, value: &APIHandleKey) -> *const APIHandleKey {
panic!("Not implemented")
}
pub fn tr64_from_fp(&mut self, value: &APIMuValue) -> *const APIMuValue {
pub fn tr64_from_fp(&mut self, value: &APIHandleKey) -> *const APIHandleKey {
panic!("Not implemented")
}
pub fn tr64_from_int(&mut self, value: &APIMuValue) -> *const APIMuValue {
pub fn tr64_from_int(&mut self, value: &APIHandleKey) -> *const APIHandleKey {
panic!("Not implemented")
}
pub fn tr64_from_ref(&mut self, reff: &APIMuValue, tag: &APIMuValue) -> *const APIMuValue {
pub fn tr64_from_ref(&mut self, reff: &APIHandleKey, tag: &APIHandleKey) -> *const APIHandleKey {
panic!("Not implemented")
}
......@@ -385,23 +385,23 @@ impl MuCtx {
panic!("Not implemented")
}
pub fn pin(&mut self, loc: &APIMuValue) -> *const APIMuValue {
pub fn pin(&mut self, loc: &APIHandleKey) -> *const APIHandleKey {
panic!("Not implemented")
}
pub fn unpin(&mut self, loc: &APIMuValue) {
pub fn unpin(&mut self, loc: &APIHandleKey) {
panic!("Not implemented")
}
pub fn get_addr(&mut self, loc: &APIMuValue) -> *const APIMuValue {
pub fn get_addr(&mut self, loc: &APIHandleKey) -> *const APIHandleKey {
panic!("Not implemented")
}
pub fn expose(&mut self, func: &APIMuValue, call_conv: CMuCallConv, cookie: &APIMuValue) -> *const APIMuValue {
pub fn expose(&mut self, func: &APIHandleKey, call_conv: CMuCallConv, cookie: &APIHandleKey) -> *const APIHandleKey {
panic!("Not implemented")
}
pub fn unexpose(&mut self, call_conv: CMuCallConv, value: &APIMuValue) {
pub fn unexpose(&mut self, call_conv: CMuCallConv, value: &APIHandleKey) {
panic!("Not implemented")
}
......@@ -409,7 +409,7 @@ impl MuCtx {
panic!("Not implemented")
}
pub fn make_boot_image(&mut self, whitelist: Vec<MuID>, primordial_func: Option<&APIMuValue>, primordial_stack: Option<&APIMuValue>, primordial_threadlocal: Option<&APIMuValue>, sym_fields: Vec<&APIMuValue>, sym_strings: Vec<String>, reloc_fields: Vec<&APIMuValue>, reloc_strings: Vec<String>, output_file: String) {
pub fn make_boot_image(&mut self, whitelist: Vec<MuID>, primordial_func: Option<&APIHandleKey>, primordial_stack: Option<&APIHandleKey>, primordial_threadlocal: Option<&APIHandleKey>, sym_fields: Vec<&APIHandleKey>, sym_strings: Vec<String>, reloc_fields: Vec<&APIHandleKey>, reloc_strings: Vec<String>, output_file: String) {
panic!("Not implemented")
}
......
......@@ -105,17 +105,17 @@ fn from_MuBool(cbool: CMuBool) -> bool {
cbool != 0
}
// APIMuValue is immutable when used.
// APIHandleKey is immutable when used.
#[inline(always)]
fn from_handle<'a>(cmuvalue: CMuValue) -> &'a APIMuValue {
fn from_handle<'a>(cmuvalue: CMuValue) -> &'a APIHandleKey {
debug_assert!(!cmuvalue.is_null());
unsafe {
&*(cmuvalue as *const APIMuValue)
&*(cmuvalue as *const APIHandleKey)
}
}
#[inline(always)]
fn from_handle_optional<'a>(cmuvalue: CMuValue) -> Option<&'a APIMuValue> {
fn from_handle_optional<'a>(cmuvalue: CMuValue) -> Option<&'a APIHandleKey> {
if cmuvalue.is_null() {
None
} else {
......@@ -157,11 +157,11 @@ fn from_MuFlag_array<'a>(ptr: *const CMuFlag, len: usize) -> &'a [CMuFlag] {
/// way as raw pointers. So this function will convert each element. This function is only called
/// by `new_thread_nor`. As always, thread creation dominates the time.
#[inline(always)]
fn from_handle_array<'a>(ptr: *const CMuValue, len: usize) -> Vec<&'a APIMuValue> {
fn from_handle_array<'a>(ptr: *const CMuValue, len: usize) -> Vec<&'a APIHandleKey> {
let slc = from_array_direct(ptr, len);
slc.iter().map(|&e| {
debug_assert!(!e.is_null());
unsafe { &*(e as *const APIMuValue) }
unsafe { &*(e as *const APIHandleKey) }
}).collect::<Vec<_>>()
}
......@@ -190,7 +190,7 @@ fn to_MuID(value: MuID) -> CMuID {
}
#[inline(always)]
fn to_handle(muvalue: *const APIMuValue) -> CMuValue {
fn to_handle(muvalue: *const APIHandleKey) -> CMuValue {
debug_assert!(!muvalue.is_null());
muvalue as CMuValue
}
......
......@@ -53,195 +53,195 @@ impl MuCtx {
panic!("The fast implementation does not support the text form.")
}
pub fn handle_from_sint8(&mut self, num: i8, len: c_int) -> *const APIMuValue {
pub fn handle_from_sint8(&mut self, num: i8, len: c_int) -> *const APIHandleKey {
panic!("Not implemented")
}
pub fn handle_from_uint8(&mut self, num: u8, len: c_int) -> *const APIMuValue {
pub fn handle_from_uint8(&mut self, num: u8, len: c_int) -> *const APIHandleKey {
panic!("Not implemented")
}
pub fn handle_from_sint16(&mut self, num: i16, len: c_int) -> *const APIMuValue {
pub fn handle_from_sint16(&mut self, num: i16, len: c_int) -> *const APIHandleKey {
panic!("Not implemented")
}
pub fn handle_from_uint16(&mut self, num: u16, len: c_int) -> *const APIMuValue {
pub fn handle_from_uint16(&mut self, num: u16, len: c_int) -> *const APIHandleKey {
panic!("Not implemented")
}
pub fn handle_from_sint32(&mut self, num: i32, len: c_int) -> *const APIMuValue {
pub fn handle_from_sint32(&mut self, num: i32, len: c_int) -> *const APIHandleKey {
panic!("Not implemented")
}
pub fn handle_from_uint32(&mut self, num: u32, len: c_int) -> *const APIMuValue {
pub fn handle_from_uint32(&mut self, num: u32, len: c_int) -> *const APIHandleKey {
panic!("Not implemented")
}
pub fn handle_from_sint64(&mut self, num: i64, len: c_int) -> *const APIMuValue {
pub fn handle_from_sint64(&mut self, num: i64, len: c_int) -> *const APIHandleKey {
panic!("Not implemented")
}
pub fn handle_from_uint64(&mut self, num: u64, len: c_int) -> *const APIMuValue {
pub fn handle_from_uint64(&mut self, num: u64, len: c_int) -> *const APIHandleKey {
panic!("Not implemented")
}
pub fn handle_from_uint64s(&mut self, nums: &[u64], len: c_int) -> *const APIMuValue {
pub fn handle_from_uint64s(&mut self, nums: &[u64], len: c_int) -> *const APIHandleKey {
panic!("Not implemented")
}
pub fn handle_from_float(&mut self, num: f32) -> *const APIMuValue {
pub fn handle_from_float(&mut self, num: f32) -> *const APIHandleKey {
panic!("Not implemented")
}
pub fn handle_from_double(&mut self, num: f64) -> *const APIMuValue {
pub fn handle_from_double(&mut self, num: f64) -> *const APIHandleKey {
panic!("Not implemented")
}
pub fn handle_from_ptr(&mut self, mu_type: MuID, ptr: CMuCPtr) -> *const APIMuValue {
pub fn handle_from_ptr(&mut self, mu_type: MuID, ptr: CMuCPtr) -> *const APIHandleKey {
panic!("Not implemented")
}
pub fn handle_from_fp(&mut self, mu_type: MuID, fp: CMuCFP) -> *const APIMuValue {
pub fn handle_from_fp(&mut self, mu_type: MuID, fp: CMuCFP) -> *const APIHandleKey {
panic!("Not implemented")
}
pub fn handle_to_sint8(&mut self, opnd: &APIMuValue) -> i8 {
pub fn handle_to_sint8(&mut self, opnd: &APIHandleKey) -> i8 {
panic!("Not implemented")
}