bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Switch to intra-doc links in os/raw/*.md

Browse source
This commit is contained in:
Prabakaran Kumaresshan 2020-08-14 21:09:35 +05:30
parent 81dc88f88f
commit 232e3d04b3
13 changed files with 33 additions and 33 deletions
Download patch file Download diff file Expand all files Collapse all files

8
library/std/src/os/raw/char.md
View file

@ -5,7 +5,7 @@ Equivalent to C's `char` type.
C chars are most commonly used to make C strings. Unlike Rust, where the length of a string is included alongside the string, C strings mark the end of a string with the character `'\0'`. See [`CStr`] for more information. C chars are most commonly used to make C strings. Unlike Rust, where the length of a string is included alongside the string, C strings mark the end of a string with the character `'\0'`. See [`CStr`] for more information.
[C's `char` type]: https://en.wikipedia.org/wiki/C_data_types#Basic_types [C's `char` type]: https://en.wikipedia.org/wiki/C_data_types#Basic_types
[Rust's `char` type]: ../../primitive.char.html [Rust's `char` type]: char
[`CStr`]: ../../ffi/struct.CStr.html [`CStr`]: crate::ffi::CStr
[`i8`]: ../../primitive.i8.html [`i8`]: i8
[`u8`]: ../../primitive.u8.html [`u8`]: u8

4
library/std/src/os/raw/double.md
View file

@ -3,5 +3,5 @@ Equivalent to C's `double` type.
This type will almost always be [`f64`], which is guaranteed to be an [IEEE-754 double-precision float] in Rust. That said, the standard technically only guarantees that it be a floating-point number with at least the precision of a [`float`], and it may be `f32` or something entirely different from the IEEE-754 standard. This type will almost always be [`f64`], which is guaranteed to be an [IEEE-754 double-precision float] in Rust. That said, the standard technically only guarantees that it be a floating-point number with at least the precision of a [`float`], and it may be `f32` or something entirely different from the IEEE-754 standard.
[IEEE-754 double-precision float]: https://en.wikipedia.org/wiki/IEEE_754 [IEEE-754 double-precision float]: https://en.wikipedia.org/wiki/IEEE_754
[`float`]: type.c_float.html [`float`]: c_float
[`f64`]: ../../primitive.f64.html [`f64`]: f64

2
library/std/src/os/raw/float.md
View file

@ -3,4 +3,4 @@ Equivalent to C's `float` type.
This type will almost always be [`f32`], which is guaranteed to be an [IEEE-754 single-precision float] in Rust. That said, the standard technically only guarantees that it be a floating-point number, and it may have less precision than `f32` or not follow the IEEE-754 standard at all. This type will almost always be [`f32`], which is guaranteed to be an [IEEE-754 single-precision float] in Rust. That said, the standard technically only guarantees that it be a floating-point number, and it may have less precision than `f32` or not follow the IEEE-754 standard at all.
[IEEE-754 single-precision float]: https://en.wikipedia.org/wiki/IEEE_754 [IEEE-754 single-precision float]: https://en.wikipedia.org/wiki/IEEE_754
[`f32`]: ../../primitive.f32.html [`f32`]: f32

6
library/std/src/os/raw/int.md
View file

@ -2,6 +2,6 @@ Equivalent to C's `signed int` (`int`) type.
This type will almost always be [`i32`], but may differ on some esoteric systems. The C standard technically only requires that this type be a signed integer that is at least the size of a [`short`]; some systems define it as an [`i16`], for example. This type will almost always be [`i32`], but may differ on some esoteric systems. The C standard technically only requires that this type be a signed integer that is at least the size of a [`short`]; some systems define it as an [`i16`], for example.
[`short`]: type.c_short.html [`short`]: c_short
[`i32`]: ../../primitive.i32.html [`i32`]: i32
[`i16`]: ../../primitive.i16.html [`i16`]: i16

6
library/std/src/os/raw/long.md
View file

@ -2,6 +2,6 @@ Equivalent to C's `signed long` (`long`) type.
This type will always be [`i32`] or [`i64`]. Most notably, many Linux-based systems assume an `i64`, but Windows assumes `i32`. The C standard technically only requires that this type be a signed integer that is at least 32 bits and at least the size of an [`int`], although in practice, no system would have a `long` that is neither an `i32` nor `i64`. This type will always be [`i32`] or [`i64`]. Most notably, many Linux-based systems assume an `i64`, but Windows assumes `i32`. The C standard technically only requires that this type be a signed integer that is at least 32 bits and at least the size of an [`int`], although in practice, no system would have a `long` that is neither an `i32` nor `i64`.
[`int`]: type.c_int.html [`int`]: c_int
[`i32`]: ../../primitive.i32.html [`i32`]: i32
[`i64`]: ../../primitive.i64.html [`i64`]: i64

6
library/std/src/os/raw/longlong.md
View file

@ -2,6 +2,6 @@ Equivalent to C's `signed long long` (`long long`) type.
This type will almost always be [`i64`], but may differ on some systems. The C standard technically only requires that this type be a signed integer that is at least 64 bits and at least the size of a [`long`], although in practice, no system would have a `long long` that is not an `i64`, as most systems do not have a standardised [`i128`] type. This type will almost always be [`i64`], but may differ on some systems. The C standard technically only requires that this type be a signed integer that is at least 64 bits and at least the size of a [`long`], although in practice, no system would have a `long long` that is not an `i64`, as most systems do not have a standardised [`i128`] type.
[`long`]: type.c_int.html [`long`]: c_int
[`i64`]: ../../primitive.i64.html [`i64`]: i64
[`i128`]: ../../primitive.i128.html [`i128`]: i128

4
library/std/src/os/raw/schar.md
View file

@ -2,5 +2,5 @@ Equivalent to C's `signed char` type.
This type will always be [`i8`], but is included for completeness. It is defined as being a signed integer the same size as a C [`char`]. This type will always be [`i8`], but is included for completeness. It is defined as being a signed integer the same size as a C [`char`].
[`char`]: type.c_char.html [`char`]: c_char
[`i8`]: ../../primitive.i8.html [`i8`]: i8

4
library/std/src/os/raw/short.md
View file

@ -2,5 +2,5 @@ Equivalent to C's `signed short` (`short`) type.
This type will almost always be [`i16`], but may differ on some esoteric systems. The C standard technically only requires that this type be a signed integer with at least 16 bits; some systems may define it as `i32`, for example. This type will almost always be [`i16`], but may differ on some esoteric systems. The C standard technically only requires that this type be a signed integer with at least 16 bits; some systems may define it as `i32`, for example.
[`char`]: type.c_char.html [`char`]: c_char
[`i16`]: ../../primitive.i16.html [`i16`]: i16

4
library/std/src/os/raw/uchar.md
View file

@ -2,5 +2,5 @@ Equivalent to C's `unsigned char` type.
This type will always be [`u8`], but is included for completeness. It is defined as being an unsigned integer the same size as a C [`char`]. This type will always be [`u8`], but is included for completeness. It is defined as being an unsigned integer the same size as a C [`char`].
[`char`]: type.c_char.html [`char`]: c_char
[`u8`]: ../../primitive.u8.html [`u8`]: u8

6
library/std/src/os/raw/uint.md
View file

@ -2,6 +2,6 @@ Equivalent to C's `unsigned int` type.
This type will almost always be [`u32`], but may differ on some esoteric systems. The C standard technically only requires that this type be an unsigned integer with the same size as an [`int`]; some systems define it as a [`u16`], for example. This type will almost always be [`u32`], but may differ on some esoteric systems. The C standard technically only requires that this type be an unsigned integer with the same size as an [`int`]; some systems define it as a [`u16`], for example.
[`int`]: type.c_int.html [`int`]: c_int
[`u32`]: ../../primitive.u32.html [`u32`]: u32
[`u16`]: ../../primitive.u16.html [`u16`]: u16

6
library/std/src/os/raw/ulong.md
View file

@ -2,6 +2,6 @@ Equivalent to C's `unsigned long` type.
This type will always be [`u32`] or [`u64`]. Most notably, many Linux-based systems assume an `u64`, but Windows assumes `u32`. The C standard technically only requires that this type be an unsigned integer with the size of a [`long`], although in practice, no system would have a `ulong` that is neither a `u32` nor `u64`. This type will always be [`u32`] or [`u64`]. Most notably, many Linux-based systems assume an `u64`, but Windows assumes `u32`. The C standard technically only requires that this type be an unsigned integer with the size of a [`long`], although in practice, no system would have a `ulong` that is neither a `u32` nor `u64`.
[`long`]: type.c_long.html [`long`]: c_long
[`u32`]: ../../primitive.u32.html [`u32`]: u32
[`u64`]: ../../primitive.u64.html [`u64`]: u64

6
library/std/src/os/raw/ulonglong.md
View file

@ -2,6 +2,6 @@ Equivalent to C's `unsigned long long` type.
This type will almost always be [`u64`], but may differ on some systems. The C standard technically only requires that this type be an unsigned integer with the size of a [`long long`], although in practice, no system would have a `long long` that is not a `u64`, as most systems do not have a standardised [`u128`] type. This type will almost always be [`u64`], but may differ on some systems. The C standard technically only requires that this type be an unsigned integer with the size of a [`long long`], although in practice, no system would have a `long long` that is not a `u64`, as most systems do not have a standardised [`u128`] type.
[`long long`]: type.c_longlong.html [`long long`]: c_longlong
[`u64`]: ../../primitive.u64.html [`u64`]: u64
[`u128`]: ../../primitive.u128.html [`u128`]: u128

4
library/std/src/os/raw/ushort.md
View file

@ -2,5 +2,5 @@ Equivalent to C's `unsigned short` type.
This type will almost always be [`u16`], but may differ on some esoteric systems. The C standard technically only requires that this type be an unsigned integer with the same size as a [`short`]. This type will almost always be [`u16`], but may differ on some esoteric systems. The C standard technically only requires that this type be an unsigned integer with the same size as a [`short`].
[`short`]: type.c_short.html [`short`]: c_short
[`u16`]: ../../primitive.u16.html [`u16`]: u16