ring-lang-rs 0.1.17

Rust bindings for the Ring programming language
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

use crate::ffi_types::{CStr, CString, c_char, c_double, c_int, c_uint};

use crate::ffi;

#[inline]
pub fn ring_general_fexists(filename: &str) -> bool {
    if let Ok(cstr) = CString::new(filename) {
        unsafe { ffi::ring_general_fexists(cstr.as_ptr()) != 0 }
    } else {
        false
    }
}

#[inline]
pub fn ring_general_fexists_bytes(filename: &[u8]) -> bool {
    unsafe { ffi::ring_general_fexists(filename.as_ptr() as *const c_char) != 0 }
}

#[inline]
pub fn ring_general_currentdir() -> Option<String> {
    let mut buf = [0 as c_char; 4096];
    let result = unsafe { ffi::ring_general_currentdir(buf.as_mut_ptr()) };
    if result != 0 {
        unsafe {
            let cstr = CStr::from_ptr(buf.as_ptr());
            cstr.to_str().ok().map(|s| s.to_string())
        }
    } else {
        None
    }
}

#[inline]
pub fn ring_general_exefilename() -> Option<String> {
    let mut buf = [0 as c_char; 4096];
    let result = unsafe { ffi::ring_general_exefilename(buf.as_mut_ptr()) };
    if result != 0 {
        unsafe {
            let cstr = CStr::from_ptr(buf.as_ptr());
            cstr.to_str().ok().map(|s| s.to_string())
        }
    } else {
        None
    }
}

#[inline]
pub fn ring_general_exefolder() -> Option<String> {
    let mut buf = [0 as c_char; 4096];
    unsafe { ffi::ring_general_exefolder(buf.as_mut_ptr()) };
    unsafe {
        let cstr = CStr::from_ptr(buf.as_ptr());
        cstr.to_str().ok().map(|s| s.to_string())
    }
}

#[inline]
pub fn ring_general_chdir(dir: &str) -> bool {
    if let Ok(cstr) = CString::new(dir) {
        unsafe { ffi::ring_general_chdir(cstr.as_ptr()) != 0 }
    } else {
        false
    }
}

#[inline]
pub fn ring_general_chdir_bytes(dir: &[u8]) -> bool {
    unsafe { ffi::ring_general_chdir(dir.as_ptr() as *const c_char) != 0 }
}

#[inline]
pub fn ring_general_lower(s: &mut [u8]) {
    unsafe { ffi::ring_general_lower(s.as_mut_ptr() as *mut c_char) };
}

#[inline]
pub fn ring_general_upper(s: &mut [u8]) {
    unsafe { ffi::ring_general_upper(s.as_mut_ptr() as *mut c_char) };
}

#[inline]
pub fn ring_general_lower2(s: &mut [u8]) {
    unsafe { ffi::ring_general_lower2(s.as_mut_ptr() as *mut c_char, s.len() as c_uint) };
}

#[inline]
pub fn ring_general_upper2(s: &mut [u8]) {
    unsafe { ffi::ring_general_upper2(s.as_mut_ptr() as *mut c_char, s.len() as c_uint) };
}

#[inline]
pub fn ring_general_numtostring(num: c_double, decimals: c_int) -> Option<String> {
    let mut buf = [0 as c_char; 64];
    unsafe {
        ffi::ring_general_numtostring(num, buf.as_mut_ptr(), decimals);
        let cstr = CStr::from_ptr(buf.as_ptr());
        cstr.to_str().ok().map(|s| s.to_string())
    }
}

#[inline]
pub fn ring_general_find(haystack: &mut [u8], needle: &mut [u8]) -> Option<usize> {
    let result = unsafe {
        ffi::ring_general_find(
            haystack.as_mut_ptr() as *mut c_char,
            needle.as_mut_ptr() as *mut c_char,
        )
    };
    if result.is_null() {
        None
    } else {
        Some(result as usize - haystack.as_ptr() as usize)
    }
}

#[inline]
pub fn ring_general_find2(haystack: &mut [u8], needle: &mut [u8]) -> Option<usize> {
    let result = unsafe {
        ffi::ring_general_find2(
            haystack.as_mut_ptr() as *mut c_char,
            haystack.len() as c_uint,
            needle.as_mut_ptr() as *mut c_char,
            needle.len() as c_uint,
        )
    };
    if result.is_null() {
        None
    } else {
        Some(result as usize - haystack.as_ptr() as usize)
    }
}