1 //! Global initialization and retrieval of command line arguments.
3 //! On some platforms these are stored during runtime startup,
4 //! and on some they are retrieved from the system on demand.
6 #![allow(dead_code)] // runtime init functions not used during testing
8 use crate::ffi::OsString;
12 /// One-time global initialization.
13 pub unsafe fn init(argc: isize, argv: *const *const u8) {
17 /// Returns the command line arguments
18 pub fn args() -> Args {
23 iter: vec::IntoIter<OsString>,
26 impl !Send for Args {}
27 impl !Sync for Args {}
29 impl fmt::Debug for Args {
30 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
31 self.iter.as_slice().fmt(f)
35 impl Iterator for Args {
37 fn next(&mut self) -> Option<OsString> {
40 fn size_hint(&self) -> (usize, Option<usize>) {
45 impl ExactSizeIterator for Args {
46 fn len(&self) -> usize {
51 impl DoubleEndedIterator for Args {
52 fn next_back(&mut self) -> Option<OsString> {
59 target_os = "android",
60 target_os = "freebsd",
61 target_os = "dragonfly",
63 target_os = "openbsd",
64 target_os = "solaris",
65 target_os = "illumos",
66 target_os = "emscripten",
69 target_os = "fuchsia",
71 target_os = "vxworks",
76 use crate::ffi::{CStr, OsString};
77 use crate::os::unix::prelude::*;
79 use crate::sync::atomic::{AtomicIsize, AtomicPtr, Ordering};
81 // The system-provided argc and argv, which we store in static memory
82 // here so that we can defer the work of parsing them until its actually
85 // Note that we never mutate argv/argc, the argv array, or the argv
86 // strings, which allows the code in this file to be very simple.
87 static ARGC: AtomicIsize = AtomicIsize::new(0);
88 static ARGV: AtomicPtr<*const u8> = AtomicPtr::new(ptr::null_mut());
90 unsafe fn really_init(argc: isize, argv: *const *const u8) {
91 // These don't need to be ordered with each other or other stores,
92 // because they only hold the unmodified system-provide argv/argc.
93 ARGC.store(argc, Ordering::Relaxed);
94 ARGV.store(argv as *mut _, Ordering::Relaxed);
98 pub unsafe fn init(_argc: isize, _argv: *const *const u8) {
99 // On Linux-GNU, we rely on `ARGV_INIT_ARRAY` below to initialize
100 // `ARGC` and `ARGV`. But in Miri that does not actually happen so we
101 // still initialize here.
102 #[cfg(any(miri, not(all(target_os = "linux", target_env = "gnu"))))]
103 really_init(_argc, _argv);
106 /// glibc passes argc, argv, and envp to functions in .init_array, as a non-standard extension.
107 /// This allows `std::env::args` to work even in a `cdylib`, as it does on macOS and Windows.
108 #[cfg(all(target_os = "linux", target_env = "gnu"))]
110 #[link_section = ".init_array.00099"]
111 static ARGV_INIT_ARRAY: extern "C" fn(
112 crate::os::raw::c_int,
116 extern "C" fn init_wrapper(
117 argc: crate::os::raw::c_int,
118 argv: *const *const u8,
119 _envp: *const *const u8,
122 really_init(argc as isize, argv);
128 pub fn args() -> Args {
129 Args { iter: clone().into_iter() }
132 fn clone() -> Vec<OsString> {
134 // Load ARGC and ARGV, which hold the unmodified system-provided
135 // argc/argv, so we can read the pointed-to memory without atomics
136 // or synchronization.
138 // If either ARGC or ARGV is still zero or null, then either there
139 // really are no arguments, or someone is asking for `args()`
140 // before initialization has completed, and we return an empty
142 let argv = ARGV.load(Ordering::Relaxed);
143 let argc = if argv.is_null() { 0 } else { ARGC.load(Ordering::Relaxed) };
146 let cstr = CStr::from_ptr(*argv.offset(i) as *const libc::c_char);
147 OsStringExt::from_vec(cstr.to_bytes().to_vec())
154 #[cfg(any(target_os = "macos", target_os = "ios", target_os = "watchos"))]
157 use crate::ffi::CStr;
159 pub unsafe fn init(_argc: isize, _argv: *const *const u8) {}
161 #[cfg(target_os = "macos")]
162 pub fn args() -> Args {
163 use crate::os::unix::prelude::*;
165 // These functions are in crt_externs.h.
166 fn _NSGetArgc() -> *mut libc::c_int;
167 fn _NSGetArgv() -> *mut *mut *mut libc::c_char;
172 (*_NSGetArgc() as isize, *_NSGetArgv() as *const *const libc::c_char);
175 let bytes = CStr::from_ptr(*argv.offset(i)).to_bytes().to_vec();
176 OsStringExt::from_vec(bytes)
180 Args { iter: vec.into_iter() }
183 // As _NSGetArgc and _NSGetArgv aren't mentioned in iOS docs
184 // and use underscores in their names - they're most probably
185 // are considered private and therefore should be avoided
186 // Here is another way to get arguments using Objective C
189 // In general it looks like:
191 // let args = [[NSProcessInfo processInfo] arguments]
192 // for i in (0..[args count])
193 // res.push([args objectAtIndex:i])
195 #[cfg(any(target_os = "ios", target_os = "watchos"))]
196 pub fn args() -> Args {
197 use crate::ffi::OsString;
202 fn sel_registerName(name: *const libc::c_uchar) -> Sel;
203 fn objc_getClass(class_name: *const libc::c_uchar) -> NsId;
206 #[cfg(target_arch = "aarch64")]
208 fn objc_msgSend(obj: NsId, sel: Sel) -> NsId;
209 #[allow(clashing_extern_declarations)]
210 #[link_name = "objc_msgSend"]
211 fn objc_msgSend_ul(obj: NsId, sel: Sel, i: libc::c_ulong) -> NsId;
214 #[cfg(not(target_arch = "aarch64"))]
216 fn objc_msgSend(obj: NsId, sel: Sel, ...) -> NsId;
217 #[allow(clashing_extern_declarations)]
218 #[link_name = "objc_msgSend"]
219 fn objc_msgSend_ul(obj: NsId, sel: Sel, ...) -> NsId;
222 type Sel = *const libc::c_void;
223 type NsId = *const libc::c_void;
225 let mut res = Vec::new();
228 let process_info_sel = sel_registerName("processInfo\0".as_ptr());
229 let arguments_sel = sel_registerName("arguments\0".as_ptr());
230 let utf8_sel = sel_registerName("UTF8String\0".as_ptr());
231 let count_sel = sel_registerName("count\0".as_ptr());
232 let object_at_sel = sel_registerName("objectAtIndex:\0".as_ptr());
234 let klass = objc_getClass("NSProcessInfo\0".as_ptr());
235 let info = objc_msgSend(klass, process_info_sel);
236 let args = objc_msgSend(info, arguments_sel);
238 let cnt: usize = mem::transmute(objc_msgSend(args, count_sel));
240 let tmp = objc_msgSend_ul(args, object_at_sel, i as libc::c_ulong);
241 let utf_c_str: *const libc::c_char = mem::transmute(objc_msgSend(tmp, utf8_sel));
242 let bytes = CStr::from_ptr(utf_c_str).to_bytes();
243 res.push(OsString::from(str::from_utf8(bytes).unwrap()))
247 Args { iter: res.into_iter() }
251 #[cfg(target_os = "espidf")]
256 pub unsafe fn init(_argc: isize, _argv: *const *const u8) {}
258 pub fn args() -> Args {
259 Args { iter: Vec::new().into_iter() }