fruity 0.2.0

Rusty bindings for Apple libraries
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

/// Creates an [`NSString`](foundation/struct.NSString.html) from a static
/// string.
///
/// # Feature Flag
///
/// This macro is defined in [`foundation`](foundation/index.html),
/// which requires the **`foundation`**
/// [feature flag](index.html#feature-flags).
///
/// # Examples
///
/// This macro takes a `"string"` literal as the argument:
///
/// ```
/// let hello = fruity::nsstring!("hello");
///
/// assert_eq!(hello.to_string(), "hello");
/// ```
///
/// The result of this macro can even be used to create `static` values:
///
/// ```
/// # use fruity::foundation::NSString;
/// static WORLD: NSString = fruity::nsstring!("world");
///
/// assert_eq!(WORLD.to_string(), "world");
/// ```
///
/// Note that the result cannot be used in a `const` because it refers to
/// static data outside of this library.
///
/// # Validity Checking
///
/// Because the string data must be a valid C string, having null bytes inside
/// it causes a compile error:
///
/// ```compile_fail
/// let s = fruity::nsstring!("ab\0cd");
/// ```
///
/// # Runtime Cost
///
/// None.
///
/// The result is equivalent to `@"string"` syntax in Objective-C.
///
/// Because of that, this should be preferred over
/// [`NSString::from_str`](foundation/struct.NSString.html#method.from_str)
/// where possible.
///
/// # Compile-time Cost
///
/// Minimal.
///
/// This is implemented entirely with `const` evaluation. It is not a procedural
/// macro that requires dependencies for parsing.
#[macro_export]
macro_rules! nsstring {
    ($s:expr) => {{
        // Note that this always uses full paths to items from `$crate`. This
        // does not import any items because doing so could cause ambiguity if
        // the same names are exposed at the call site of this macro.
        //
        // The only names directly used are expressions, whose names shadow any
        // other names outside of this macro.

        // This can be in the `__cstring` link section, but it doesn't need to.
        const STR: &str = $crate::_priv::std::concat!($s, "\0");

        // Assert that `STR` is a valid C string:
        // 1. It ends with null.
        // 2. It has no interior nulls.
        const _: [(); 1] = [(); $crate::_priv::is_cstr(STR) as usize];

        #[link_section = "__DATA,__cfstring,regular"]
        static DATA: $crate::_priv::__CFString = $crate::_priv::__CFString {
            isa: unsafe {
                extern "C" {
                    static __CFConstantStringClassReference: $crate::_priv::std::ffi::c_void;
                }
                &__CFConstantStringClassReference
            },

            // This is a magic constant I came across when inspecting
            // Objective-C binaries. This is probably the CFTypeID?
            flags: 0x07c8,

            data: STR.as_ptr(),

            // The length does not include the null byte.
            len: STR.len() - 1,
        };

        #[allow(unused_unsafe)]
        let nsstring =
            unsafe { $crate::foundation::NSString::from_ptr(&DATA as *const _ as *mut _) };

        nsstring
    }};
}