Rollup merge of #75530 - nixphix:docs/os-raw, r=jyn514

tmandry · web-flow · commit 6d09e29f5e97 · 2020-08-14T14:47:03.000-07:00
Switch to intra-doc links in os/raw/*.md Partial fix for #75080 @rustbot modify labels: T-doc, A-intra-doc-links, T-rustdoc r? @jyn514
diff --git a/library/std/src/os/raw/char.md b/library/std/src/os/raw/char.md
@@ -5,7 +5,5 @@ 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's `char` type]: https://en.wikipedia.org/wiki/C_data_types#Basic_types
-[Rust's `char` type]: ../../primitive.char.html
-[`CStr`]: ../../ffi/struct.CStr.html
-[`i8`]: ../../primitive.i8.html
-[`u8`]: ../../primitive.u8.html
+[Rust's `char` type]: char
+[`CStr`]: crate::ffi::CStr
diff --git a/library/std/src/os/raw/double.md b/library/std/src/os/raw/double.md
@@ -3,5 +3,4 @@ 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.
 
 [IEEE-754 double-precision float]: https://en.wikipedia.org/wiki/IEEE_754
-[`float`]: type.c_float.html
-[`f64`]: ../../primitive.f64.html
+[`float`]: c_float
diff --git a/library/std/src/os/raw/float.md b/library/std/src/os/raw/float.md
@@ -3,4 +3,3 @@ 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.
 
 [IEEE-754 single-precision float]: https://en.wikipedia.org/wiki/IEEE_754
-[`f32`]: ../../primitive.f32.html
diff --git a/library/std/src/os/raw/int.md b/library/std/src/os/raw/int.md
@@ -2,6 +2,4 @@ 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.
 
-[`short`]: type.c_short.html
-[`i32`]: ../../primitive.i32.html
-[`i16`]: ../../primitive.i16.html
+[`short`]: c_short
diff --git a/library/std/src/os/raw/long.md b/library/std/src/os/raw/long.md
@@ -2,6 +2,4 @@ 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`.
 
-[`int`]: type.c_int.html
-[`i32`]: ../../primitive.i32.html
-[`i64`]: ../../primitive.i64.html
+[`int`]: c_int
diff --git a/library/std/src/os/raw/longlong.md b/library/std/src/os/raw/longlong.md
@@ -2,6 +2,4 @@ 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.
 
-[`long`]: type.c_int.html
-[`i64`]: ../../primitive.i64.html
-[`i128`]: ../../primitive.i128.html
+[`long`]: c_int
diff --git a/library/std/src/os/raw/schar.md b/library/std/src/os/raw/schar.md
@@ -2,5 +2,4 @@ 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`].
 
-[`char`]: type.c_char.html
-[`i8`]: ../../primitive.i8.html
+[`char`]: c_char
diff --git a/library/std/src/os/raw/short.md b/library/std/src/os/raw/short.md
@@ -2,5 +2,4 @@ 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.
 
-[`char`]: type.c_char.html
-[`i16`]: ../../primitive.i16.html
+[`char`]: c_char
diff --git a/library/std/src/os/raw/uchar.md b/library/std/src/os/raw/uchar.md
@@ -2,5 +2,4 @@ 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`].
 
-[`char`]: type.c_char.html
-[`u8`]: ../../primitive.u8.html
+[`char`]: c_char
diff --git a/library/std/src/os/raw/uint.md b/library/std/src/os/raw/uint.md
@@ -2,6 +2,4 @@ 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.
 
-[`int`]: type.c_int.html
-[`u32`]: ../../primitive.u32.html
-[`u16`]: ../../primitive.u16.html
+[`int`]: c_int
diff --git a/library/std/src/os/raw/ulong.md b/library/std/src/os/raw/ulong.md
@@ -2,6 +2,4 @@ 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`.
 
-[`long`]: type.c_long.html
-[`u32`]: ../../primitive.u32.html
-[`u64`]: ../../primitive.u64.html
+[`long`]: c_long
diff --git a/library/std/src/os/raw/ulonglong.md b/library/std/src/os/raw/ulonglong.md
@@ -2,6 +2,4 @@ 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.
 
-[`long long`]: type.c_longlong.html
-[`u64`]: ../../primitive.u64.html
-[`u128`]: ../../primitive.u128.html
+[`long long`]: c_longlong
diff --git a/library/std/src/os/raw/ushort.md b/library/std/src/os/raw/ushort.md
@@ -2,5 +2,4 @@ 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`].
 
-[`short`]: type.c_short.html
-[`u16`]: ../../primitive.u16.html
+[`short`]: c_short

Original file line number	Diff line number	Diff line change
@@ -3,4 +3,3 @@ Equivalent to C's `float` type.
`3`	`3`	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.
`4`	`4`
`5`	`5`	`[IEEE-754 single-precision float]: https://en.wikipedia.org/wiki/IEEE_754`
`6`		-[`f32`]: ../../primitive.f32.html