]>
Commit | Line | Data |
---|---|---|
92a42be0 SL |
1 | // Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT |
2 | // file at the top-level directory of this distribution and at | |
3 | // http://rust-lang.org/COPYRIGHT. | |
4 | // | |
5 | // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or | |
6 | // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license | |
7 | // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your | |
8 | // option. This file may not be copied, modified, or distributed | |
9 | // except according to those terms. | |
10 | ||
11 | //! Crate docs | |
12 | ||
13 | #![allow(bad_style, overflowing_literals, improper_ctypes)] | |
14 | #![crate_type = "rlib"] | |
15 | #![crate_name = "libc"] | |
16 | #![cfg_attr(dox, feature(no_core, lang_items))] | |
17 | #![cfg_attr(dox, no_core)] | |
18 | #![doc(html_logo_url = "https://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png", | |
19 | html_favicon_url = "https://doc.rust-lang.org/favicon.ico")] | |
20 | ||
21 | #![cfg_attr(all(target_os = "linux", target_arch = "x86_64"), doc( | |
22 | html_root_url = "https://doc.rust-lang.org/libc/x86_64-unknown-linux-gnu" | |
23 | ))] | |
24 | #![cfg_attr(all(target_os = "linux", target_arch = "x86"), doc( | |
25 | html_root_url = "https://doc.rust-lang.org/libc/i686-unknown-linux-gnu" | |
26 | ))] | |
27 | #![cfg_attr(all(target_os = "linux", target_arch = "arm"), doc( | |
28 | html_root_url = "https://doc.rust-lang.org/libc/arm-unknown-linux-gnueabihf" | |
29 | ))] | |
30 | #![cfg_attr(all(target_os = "linux", target_arch = "mips"), doc( | |
31 | html_root_url = "https://doc.rust-lang.org/libc/mips-unknown-linux-gnu" | |
32 | ))] | |
33 | #![cfg_attr(all(target_os = "linux", target_arch = "aarch64"), doc( | |
34 | html_root_url = "https://doc.rust-lang.org/libc/aarch64-unknown-linux-gnu" | |
35 | ))] | |
36 | #![cfg_attr(all(target_os = "linux", target_env = "musl"), doc( | |
37 | html_root_url = "https://doc.rust-lang.org/libc/x86_64-unknown-linux-musl" | |
38 | ))] | |
39 | #![cfg_attr(all(target_os = "macos", target_arch = "x86_64"), doc( | |
40 | html_root_url = "https://doc.rust-lang.org/libc/x86_64-apple-darwin" | |
41 | ))] | |
42 | #![cfg_attr(all(target_os = "macos", target_arch = "x86"), doc( | |
43 | html_root_url = "https://doc.rust-lang.org/libc/i686-apple-darwin" | |
44 | ))] | |
45 | #![cfg_attr(all(windows, target_arch = "x86_64", target_env = "gnu"), doc( | |
46 | html_root_url = "https://doc.rust-lang.org/libc/x86_64-pc-windows-gnu" | |
47 | ))] | |
48 | #![cfg_attr(all(windows, target_arch = "x86", target_env = "gnu"), doc( | |
49 | html_root_url = "https://doc.rust-lang.org/libc/i686-pc-windows-gnu" | |
50 | ))] | |
51 | #![cfg_attr(all(windows, target_arch = "x86_64", target_env = "msvc"), doc( | |
52 | html_root_url = "https://doc.rust-lang.org/libc/x86_64-pc-windows-msvc" | |
53 | ))] | |
54 | #![cfg_attr(all(windows, target_arch = "x86", target_env = "msvc"), doc( | |
55 | html_root_url = "https://doc.rust-lang.org/libc/i686-pc-windows-msvc" | |
56 | ))] | |
9cc50fc6 | 57 | #![cfg_attr(target_os = "android", doc( |
92a42be0 SL |
58 | html_root_url = "https://doc.rust-lang.org/libc/arm-linux-androideabi" |
59 | ))] | |
9cc50fc6 SL |
60 | #![cfg_attr(target_os = "freebsd", doc( |
61 | html_root_url = "https://doc.rust-lang.org/libc/x86_64-unknown-freebsd" | |
62 | ))] | |
63 | #![cfg_attr(target_os = "openbsd", doc( | |
64 | html_root_url = "https://doc.rust-lang.org/libc/x86_64-unknown-openbsd" | |
65 | ))] | |
66 | #![cfg_attr(target_os = "bitrig", doc( | |
67 | html_root_url = "https://doc.rust-lang.org/libc/x86_64-unknown-bitrig" | |
68 | ))] | |
69 | #![cfg_attr(target_os = "netbsd", doc( | |
70 | html_root_url = "https://doc.rust-lang.org/libc/x86_64-unknown-netbsd" | |
71 | ))] | |
72 | #![cfg_attr(target_os = "dragonfly", doc( | |
73 | html_root_url = "https://doc.rust-lang.org/libc/x86_64-unknown-dragonfly" | |
74 | ))] | |
92a42be0 SL |
75 | |
76 | // Attributes needed when building as part of the standard library | |
54a0048b | 77 | #![cfg_attr(stdbuild, feature(no_std, core, core_slice_ext, staged_api, custom_attribute, cfg_target_vendor))] |
92a42be0 SL |
78 | #![cfg_attr(stdbuild, no_std)] |
79 | #![cfg_attr(stdbuild, staged_api)] | |
80 | #![cfg_attr(stdbuild, allow(warnings))] | |
81 | #![cfg_attr(stdbuild, unstable(feature = "libc", | |
82 | reason = "use `libc` from crates.io", | |
83 | issue = "27783"))] | |
84 | ||
7453a54e SL |
85 | #![cfg_attr(not(feature = "use_std"), no_std)] |
86 | ||
87 | #[cfg(all(not(stdbuild), not(dox), feature = "use_std"))] | |
92a42be0 SL |
88 | extern crate std as core; |
89 | ||
90 | #[macro_use] mod macros; | |
91 | mod dox; | |
92 | ||
93 | // Use repr(u8) as LLVM expects `void*` to be the same as `i8*` to help enable | |
94 | // more optimization opportunities around it recognizing things like | |
95 | // malloc/free. | |
96 | #[repr(u8)] | |
97 | pub enum c_void { | |
98 | // Two dummy variants so the #[repr] attribute can be used. | |
99 | #[doc(hidden)] | |
100 | __variant1, | |
101 | #[doc(hidden)] | |
102 | __variant2, | |
103 | } | |
104 | ||
105 | pub type int8_t = i8; | |
106 | pub type int16_t = i16; | |
107 | pub type int32_t = i32; | |
108 | pub type int64_t = i64; | |
109 | pub type uint8_t = u8; | |
110 | pub type uint16_t = u16; | |
111 | pub type uint32_t = u32; | |
112 | pub type uint64_t = u64; | |
113 | ||
114 | pub type c_schar = i8; | |
115 | pub type c_uchar = u8; | |
116 | pub type c_short = i16; | |
117 | pub type c_ushort = u16; | |
118 | pub type c_int = i32; | |
119 | pub type c_uint = u32; | |
120 | pub type c_float = f32; | |
121 | pub type c_double = f64; | |
122 | pub type c_longlong = i64; | |
123 | pub type c_ulonglong = u64; | |
124 | pub type intmax_t = i64; | |
125 | pub type uintmax_t = u64; | |
126 | ||
127 | pub type size_t = usize; | |
128 | pub type ptrdiff_t = isize; | |
129 | pub type intptr_t = isize; | |
130 | pub type uintptr_t = usize; | |
131 | pub type ssize_t = isize; | |
132 | ||
133 | pub enum FILE {} | |
134 | pub enum fpos_t {} // TODO: fill this out with a struct | |
135 | ||
136 | extern { | |
137 | pub fn isalnum(c: c_int) -> c_int; | |
138 | pub fn isalpha(c: c_int) -> c_int; | |
139 | pub fn iscntrl(c: c_int) -> c_int; | |
140 | pub fn isdigit(c: c_int) -> c_int; | |
141 | pub fn isgraph(c: c_int) -> c_int; | |
142 | pub fn islower(c: c_int) -> c_int; | |
143 | pub fn isprint(c: c_int) -> c_int; | |
144 | pub fn ispunct(c: c_int) -> c_int; | |
145 | pub fn isspace(c: c_int) -> c_int; | |
146 | pub fn isupper(c: c_int) -> c_int; | |
147 | pub fn isxdigit(c: c_int) -> c_int; | |
148 | pub fn tolower(c: c_int) -> c_int; | |
149 | pub fn toupper(c: c_int) -> c_int; | |
150 | ||
151 | #[cfg_attr(all(target_os = "macos", target_arch = "x86"), | |
152 | link_name = "fopen$UNIX2003")] | |
153 | pub fn fopen(filename: *const c_char, | |
154 | mode: *const c_char) -> *mut FILE; | |
155 | #[cfg_attr(all(target_os = "macos", target_arch = "x86"), | |
156 | link_name = "freopen$UNIX2003")] | |
157 | pub fn freopen(filename: *const c_char, mode: *const c_char, | |
158 | file: *mut FILE) -> *mut FILE; | |
159 | pub fn fflush(file: *mut FILE) -> c_int; | |
160 | pub fn fclose(file: *mut FILE) -> c_int; | |
161 | pub fn remove(filename: *const c_char) -> c_int; | |
162 | pub fn rename(oldname: *const c_char, newname: *const c_char) -> c_int; | |
163 | pub fn tmpfile() -> *mut FILE; | |
164 | pub fn setvbuf(stream: *mut FILE, | |
165 | buffer: *mut c_char, | |
166 | mode: c_int, | |
167 | size: size_t) -> c_int; | |
168 | pub fn setbuf(stream: *mut FILE, buf: *mut c_char); | |
169 | pub fn fgetc(stream: *mut FILE) -> c_int; | |
170 | pub fn fgets(buf: *mut c_char, n: c_int, stream: *mut FILE) -> *mut c_char; | |
171 | pub fn fputc(c: c_int, stream: *mut FILE) -> c_int; | |
172 | #[cfg_attr(all(target_os = "macos", target_arch = "x86"), | |
173 | link_name = "fputs$UNIX2003")] | |
174 | pub fn fputs(s: *const c_char, stream: *mut FILE)-> c_int; | |
175 | pub fn puts(s: *const c_char) -> c_int; | |
176 | pub fn ungetc(c: c_int, stream: *mut FILE) -> c_int; | |
177 | pub fn fread(ptr: *mut c_void, | |
178 | size: size_t, | |
179 | nobj: size_t, | |
180 | stream: *mut FILE) | |
181 | -> size_t; | |
182 | #[cfg_attr(all(target_os = "macos", target_arch = "x86"), | |
183 | link_name = "fwrite$UNIX2003")] | |
184 | pub fn fwrite(ptr: *const c_void, | |
185 | size: size_t, | |
186 | nobj: size_t, | |
187 | stream: *mut FILE) | |
188 | -> size_t; | |
189 | pub fn fseek(stream: *mut FILE, offset: c_long, whence: c_int) -> c_int; | |
190 | pub fn ftell(stream: *mut FILE) -> c_long; | |
191 | pub fn rewind(stream: *mut FILE); | |
9cc50fc6 | 192 | #[cfg_attr(target_os = "netbsd", link_name = "__fgetpos50")] |
92a42be0 | 193 | pub fn fgetpos(stream: *mut FILE, ptr: *mut fpos_t) -> c_int; |
9cc50fc6 | 194 | #[cfg_attr(target_os = "netbsd", link_name = "__fsetpos50")] |
92a42be0 SL |
195 | pub fn fsetpos(stream: *mut FILE, ptr: *const fpos_t) -> c_int; |
196 | pub fn feof(stream: *mut FILE) -> c_int; | |
197 | pub fn ferror(stream: *mut FILE) -> c_int; | |
198 | pub fn perror(s: *const c_char); | |
199 | pub fn atoi(s: *const c_char) -> c_int; | |
200 | #[cfg_attr(all(target_os = "macos", target_arch = "x86"), | |
201 | link_name = "strtod$UNIX2003")] | |
202 | pub fn strtod(s: *const c_char, endp: *mut *mut c_char) -> c_double; | |
203 | pub fn strtol(s: *const c_char, | |
204 | endp: *mut *mut c_char, base: c_int) -> c_long; | |
205 | pub fn strtoul(s: *const c_char, endp: *mut *mut c_char, | |
206 | base: c_int) -> c_ulong; | |
207 | pub fn calloc(nobj: size_t, size: size_t) -> *mut c_void; | |
208 | pub fn malloc(size: size_t) -> *mut c_void; | |
209 | pub fn realloc(p: *mut c_void, size: size_t) -> *mut c_void; | |
210 | pub fn free(p: *mut c_void); | |
7453a54e | 211 | pub fn abort() -> !; |
92a42be0 SL |
212 | pub fn exit(status: c_int) -> !; |
213 | pub fn _exit(status: c_int) -> !; | |
214 | pub fn atexit(cb: extern fn()) -> c_int; | |
215 | #[cfg_attr(all(target_os = "macos", target_arch = "x86"), | |
216 | link_name = "system$UNIX2003")] | |
217 | pub fn system(s: *const c_char) -> c_int; | |
218 | pub fn getenv(s: *const c_char) -> *mut c_char; | |
219 | ||
220 | pub fn strcpy(dst: *mut c_char, src: *const c_char) -> *mut c_char; | |
221 | pub fn strncpy(dst: *mut c_char, src: *const c_char, n: size_t) | |
222 | -> *mut c_char; | |
223 | pub fn strcat(s: *mut c_char, ct: *const c_char) -> *mut c_char; | |
224 | pub fn strncat(s: *mut c_char, ct: *const c_char, n: size_t) -> *mut c_char; | |
225 | pub fn strcmp(cs: *const c_char, ct: *const c_char) -> c_int; | |
226 | pub fn strncmp(cs: *const c_char, ct: *const c_char, n: size_t) -> c_int; | |
227 | pub fn strcoll(cs: *const c_char, ct: *const c_char) -> c_int; | |
228 | pub fn strchr(cs: *const c_char, c: c_int) -> *mut c_char; | |
229 | pub fn strrchr(cs: *const c_char, c: c_int) -> *mut c_char; | |
230 | pub fn strspn(cs: *const c_char, ct: *const c_char) -> size_t; | |
231 | pub fn strcspn(cs: *const c_char, ct: *const c_char) -> size_t; | |
232 | pub fn strpbrk(cs: *const c_char, ct: *const c_char) -> *mut c_char; | |
233 | pub fn strstr(cs: *const c_char, ct: *const c_char) -> *mut c_char; | |
234 | pub fn strlen(cs: *const c_char) -> size_t; | |
235 | #[cfg_attr(all(target_os = "macos", target_arch = "x86"), | |
236 | link_name = "strerror$UNIX2003")] | |
237 | pub fn strerror(n: c_int) -> *mut c_char; | |
238 | pub fn strtok(s: *mut c_char, t: *const c_char) -> *mut c_char; | |
239 | pub fn strxfrm(s: *mut c_char, ct: *const c_char, n: size_t) -> size_t; | |
240 | pub fn wcslen(buf: *const wchar_t) -> size_t; | |
241 | ||
242 | pub fn memcmp(cx: *const c_void, ct: *const c_void, n: size_t) -> c_int; | |
243 | pub fn memchr(cx: *const c_void, c: c_int, n: size_t) -> *mut c_void; | |
244 | } | |
245 | ||
246 | // These are all inline functions on android, so they end up just being entirely | |
247 | // missing on that platform. | |
248 | #[cfg(not(target_os = "android"))] | |
249 | extern { | |
250 | pub fn abs(i: c_int) -> c_int; | |
251 | pub fn atof(s: *const c_char) -> c_double; | |
252 | pub fn labs(i: c_long) -> c_long; | |
253 | pub fn rand() -> c_int; | |
254 | pub fn srand(seed: c_uint); | |
255 | } | |
256 | ||
257 | cfg_if! { | |
258 | if #[cfg(windows)] { | |
259 | mod windows; | |
260 | pub use windows::*; | |
54a0048b | 261 | } else if #[cfg(unix)] { |
92a42be0 SL |
262 | mod unix; |
263 | pub use unix::*; | |
54a0048b SL |
264 | } else { |
265 | // Unknown target_family | |
92a42be0 SL |
266 | } |
267 | } |