devela 0.27.0

A development layer of coherence.
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
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

// devela::sys::env::arg::os_ref
//
//! Defines [`IterArgsOsRef`] and [`args_os_ref_iter()`].
//
// WAIT: [macos build fails](https://github.com/dtolnay/argv/issues/1)

use crate::OsStr;

/// Returns an iterator over command line arguments.
pub(crate) fn args_os_ref_iter() -> IterArgsOsRef {
    IterArgsOsRef { platform_specific: r#impl::args_os_ref_iter() }
}

#[doc = crate::_tags!(iterator lifetime)]
#[doc = crate::_doc_miri_warn!(tag)]
/// Iterator over references of command line arguments.
#[doc = crate::_doc_location!("sys/env")]
///
/// See [`Env::args_os_ref()`][crate::Env#method.args_os_ref].
#[doc = crate::_doc!(vendor: "argv")]
#[derive(Debug)]
pub struct IterArgsOsRef {
    platform_specific: r#impl::IterArgsOsRef,
}

impl Iterator for IterArgsOsRef {
    type Item = &'static OsStr;

    fn next(&mut self) -> Option<Self::Item> {
        self.platform_specific.next()
    }
    fn size_hint(&self) -> (usize, Option<usize>) {
        self.platform_specific.size_hint()
    }
}

impl ExactSizeIterator for IterArgsOsRef {
    fn len(&self) -> usize {
        self.platform_specific.len()
    }
}

// NOTE: miri https://github.com/dtolnay/argv/issues/17#issuecomment-3201054937
#[cfg(all(target_os = "linux", not(target_env = "musl"), not(miri)))]
mod r#impl {
    use crate::{CStr, OsStr, c_char, c_int};
    use std::os::unix::ffi::OsStrExt;
    use std::{mem, ptr};

    static mut ARGC: c_int = 0;
    static mut ARGV: *const *const c_char = ptr::null();

    #[cfg(target_os = "linux")]
    #[unsafe(link_section = ".init_array")]
    #[used]
    static CAPTURE: unsafe extern "C" fn(c_int, *const *const c_char) = capture;

    // Disabled for now until we investigate https://github.com/dtolnay/argv/issues/1
    #[cfg_attr(target_os = "macos", link_section = "__DATA,__mod_init_func")]
    #[allow(dead_code)]
    unsafe extern "C" fn capture(argc: c_int, argv: *const *const c_char) {
        unsafe {
            ARGC = argc;
            ARGV = argv;
        }
    }

    pub(crate) fn args_os_ref_iter() -> IterArgsOsRef {
        // These are only mutated before main so they are safe to read once main
        // has begun.
        let argc = unsafe { ARGC };
        let argv = unsafe { ARGV };

        // We count on the OS to provide argv for which argv + argc does not
        // overflow.
        let end = unsafe { argv.offset(argc as isize) };

        IterArgsOsRef { next: argv, end }
    }

    #[derive(Debug)]
    pub(crate) struct IterArgsOsRef {
        next: *const *const c_char,
        end: *const *const c_char,
    }

    impl Iterator for IterArgsOsRef {
        type Item = &'static OsStr;

        fn next(&mut self) -> Option<Self::Item> {
            if ptr::eq(self.next, self.end) {
                None
            } else {
                let ptr = unsafe { *self.next };
                let c_str = unsafe { CStr::from_ptr(ptr) };
                self.next = unsafe { self.next.offset(1) };
                Some(OsStr::from_bytes(c_str.to_bytes()))
            }
        }

        fn size_hint(&self) -> (usize, Option<usize>) {
            let len = self.len();
            (len, Some(len))
        }
    }

    impl ExactSizeIterator for IterArgsOsRef {
        fn len(&self) -> usize {
            (self.end as usize - self.next as usize) / mem::size_of::<*const c_char>()
        }
    }

    // Thread safe despite the raw pointers.
    unsafe impl Send for IterArgsOsRef {}
    unsafe impl Sync for IterArgsOsRef {}
}

#[cfg(any(not(target_os = "linux"), target_env = "musl", miri))]
mod r#impl {
    use crate::{Once, OsStr};
    use std::{env, iter, ptr, slice};

    static ONCE: Once = Once::new();
    static mut ARGV: Vec<&'static OsStr> = Vec::new();

    pub(crate) fn args_os_ref_iter() -> IterArgsOsRef {
        ONCE.call_once(|| {
            let argv = env::args_os()
                .map(|arg| -> &OsStr { Box::leak(arg.into_boxed_os_str()) })
                .collect();
            unsafe { ARGV = argv }
        });
        let argv = unsafe { &*ptr::addr_of!(ARGV) };
        argv.iter().copied()
    }

    pub(crate) type IterArgsOsRef = iter::Copied<slice::Iter<'static, &'static OsStr>>;
}

const _AUTO_TRAITS: () = {
    fn assert_send<T: Send>() {}
    fn assert_sync<T: Sync>() {}

    let _ = assert_send::<IterArgsOsRef>;
    let _ = assert_sync::<IterArgsOsRef>;
};