Merge pull request #1194 from cryspen/jonas/hacl-rs-docs

Fix doc warnings in `libcrux-hacl-rs`

Author: jschneider-bensch

hacl-rs/src/bignum/bignum256.rs

@@ -13,7 +13,7 @@ Write `a + b mod 2^256` in `res`.
 
   This functions returns the carry.
 
-  The arguments a, b and res are meant to be 256-bit bignums, i.e. uint64_t[4]
+  The arguments a, b and res are meant to be 256-bit bignums, i.e. `uint64_t\[4\]`
 */
 pub fn add(a: &[u64], b: &[u64], res: &mut [u64]) -> u64 {
     let mut c: [u64; 1] = [0u64; 1usize];
@@ -45,7 +45,7 @@ Write `a - b mod 2^256` in `res`.
 
   This functions returns the carry.
 
-  The arguments a, b and res are meant to be 256-bit bignums, i.e. uint64_t[4]
+  The arguments a, b and res are meant to be 256-bit bignums, i.e. `uint64_t\[4\]`
 */
 pub fn sub(a: &[u64], b: &[u64], res: &mut [u64]) -> u64 {
     let mut c: [u64; 1] = [0u64; 1usize];
@@ -76,7 +76,7 @@ pub fn sub(a: &[u64], b: &[u64], res: &mut [u64]) -> u64 {
 /**
 Write `(a + b) mod n` in `res`.
 
-  The arguments a, b, n and the outparam res are meant to be 256-bit bignums, i.e. uint64_t[4].
+  The arguments a, b, n and the outparam res are meant to be 256-bit bignums, i.e. `uint64_t\[4\]`.
 
   Before calling this function, the caller will need to ensure that the following
   preconditions are observed.
@@ -142,7 +142,7 @@ pub fn add_mod(n: &[u64], a: &[u64], b: &[u64], res: &mut [u64]) {
 /**
 Write `(a - b) mod n` in `res`.
 
-  The arguments a, b, n and the outparam res are meant to be 256-bit bignums, i.e. uint64_t[4].
+  The arguments a, b, n and the outparam res are meant to be 256-bit bignums, i.e. `uint64_t\[4\]`.
 
   Before calling this function, the caller will need to ensure that the following
   preconditions are observed.
@@ -209,8 +209,8 @@ pub fn sub_mod(n: &[u64], a: &[u64], b: &[u64], res: &mut [u64]) {
 /**
 Write `a * b` in `res`.
 
-  The arguments a and b are meant to be 256-bit bignums, i.e. uint64_t[4].
-  The outparam res is meant to be a 512-bit bignum, i.e. uint64_t[8].
+  The arguments a and b are meant to be 256-bit bignums, i.e. `uint64_t\[4\]`.
+  The outparam res is meant to be a 512-bit bignum, i.e. `uint64_t\[8\]`.
 */
 pub fn mul(a: &[u64], b: &[u64], res: &mut [u64]) {
     (res[0usize..8usize]).copy_from_slice(&[0u64; 8usize]);
@@ -245,8 +245,8 @@ pub fn mul(a: &[u64], b: &[u64], res: &mut [u64]) {
 /**
 Write `a * a` in `res`.
 
-  The argument a is meant to be a 256-bit bignum, i.e. uint64_t[4].
-  The outparam res is meant to be a 512-bit bignum, i.e. uint64_t[8].
+  The argument a is meant to be a 256-bit bignum, i.e. `uint64_t\[4\]`.
+  The outparam res is meant to be a 512-bit bignum, i.e. `uint64_t\[8\]`.
 */
 pub fn sqr(a: &[u64], res: &mut [u64]) {
     (res[0usize..8usize]).copy_from_slice(&[0u64; 8usize]);
@@ -476,8 +476,8 @@ fn bn_slow_precomp(n: &[u64], mu: u64, r2: &[u64], a: &[u64], res: &mut [u64]) {
 /**
 Write `a mod n` in `res`.
 
-  The argument a is meant to be a 512-bit bignum, i.e. uint64_t[8].
-  The argument n and the outparam res are meant to be 256-bit bignums, i.e. uint64_t[4].
+  The argument a is meant to be a 512-bit bignum, i.e. `uint64_t\[8\]`.
+  The argument n and the outparam res are meant to be 256-bit bignums, i.e. `uint64_t\[4\]`.
 
   The function returns false if any of the following preconditions are violated,
   true otherwise.
@@ -863,7 +863,7 @@ fn exp_consttime(nBits: u32, n: &[u64], a: &[u64], bBits: u32, b: &[u64], res: &
 /**
 Write `a ^ b mod n` in `res`.
 
-  The arguments a, n and the outparam res are meant to be 256-bit bignums, i.e. uint64_t[4].
+  The arguments a, n and the outparam res are meant to be 256-bit bignums, i.e. `uint64_t\[4\]`.
 
   The argument b is a bignum of any size, and bBits is an upper bound on the
   number of significant bits of b. A tighter bound results in faster execution
@@ -894,7 +894,7 @@ pub fn mod_exp_vartime(n: &[u64], a: &[u64], bBits: u32, b: &[u64], res: &mut [u
 /**
 Write `a ^ b mod n` in `res`.
 
-  The arguments a, n and the outparam res are meant to be 256-bit bignums, i.e. uint64_t[4].
+  The arguments a, n and the outparam res are meant to be 256-bit bignums, i.e. `uint64_t\[4\]`.
 
   The argument b is a bignum of any size, and bBits is an upper bound on the
   number of significant bits of b. A tighter bound results in faster execution
@@ -925,7 +925,7 @@ pub fn mod_exp_consttime(n: &[u64], a: &[u64], bBits: u32, b: &[u64], res: &mut
 /**
 Write `a ^ (-1) mod n` in `res`.
 
-  The arguments a, n and the outparam res are meant to be 256-bit bignums, i.e. uint64_t[4].
+  The arguments a, n and the outparam res are meant to be 256-bit bignums, i.e. `uint64_t\[4\]`.
 
   Before calling this function, the caller will need to ensure that the following
   preconditions are observed.
@@ -999,7 +999,7 @@ pub fn mod_inv_prime_vartime(n: &[u64], a: &[u64], res: &mut [u64]) -> bool {
 /**
 Heap-allocate and initialize a montgomery context.
 
-  The argument n is meant to be a 256-bit bignum, i.e. uint64_t[4].
+  The argument n is meant to be a 256-bit bignum, i.e. `uint64_t\[4\]`.
 
   Before calling this function, the caller will need to ensure that the following
   preconditions are observed.
@@ -1031,8 +1031,8 @@ pub fn mont_ctx_init(n: &[u64]) -> Box<[super::base::bn_mont_ctx_u64]> {
 /**
 Write `a mod n` in `res`.
 
-  The argument a is meant to be a 512-bit bignum, i.e. uint64_t[8].
-  The outparam res is meant to be a 256-bit bignum, i.e. uint64_t[4].
+  The argument a is meant to be a 512-bit bignum, i.e. `uint64_t\[8\]`.
+  The outparam res is meant to be a 256-bit bignum, i.e. `uint64_t\[4\]`.
   The argument k is a montgomery context obtained through Hacl_Bignum256_mont_ctx_init.
 */
 pub fn mod_precomp(k: &[super::base::bn_mont_ctx_u64], a: &[u64], res: &mut [u64]) {
@@ -1045,7 +1045,7 @@ pub fn mod_precomp(k: &[super::base::bn_mont_ctx_u64], a: &[u64], res: &mut [u64
 /**
 Write `a ^ b mod n` in `res`.
 
-  The arguments a and the outparam res are meant to be 256-bit bignums, i.e. uint64_t[4].
+  The arguments a and the outparam res are meant to be 256-bit bignums, i.e. `uint64_t\[4\]`.
   The argument k is a montgomery context obtained through Hacl_Bignum256_mont_ctx_init.
 
   The argument b is a bignum of any size, and bBits is an upper bound on the
@@ -1077,7 +1077,7 @@ pub fn mod_exp_vartime_precomp(
 /**
 Write `a ^ b mod n` in `res`.
 
-  The arguments a and the outparam res are meant to be 256-bit bignums, i.e. uint64_t[4].
+  The arguments a and the outparam res are meant to be 256-bit bignums, i.e. `uint64_t\[4\]`.
   The argument k is a montgomery context obtained through Hacl_Bignum256_mont_ctx_init.
 
   The argument b is a bignum of any size, and bBits is an upper bound on the
@@ -1109,7 +1109,7 @@ pub fn mod_exp_consttime_precomp(
 /**
 Write `a ^ (-1) mod n` in `res`.
 
-  The argument a and the outparam res are meant to be 256-bit bignums, i.e. uint64_t[4].
+  The argument a and the outparam res are meant to be 256-bit bignums, i.e. `uint64_t\[4\]`.
   The argument k is a montgomery context obtained through Hacl_Bignum256_mont_ctx_init.
 
   Before calling this function, the caller will need to ensure that the following
@@ -1267,7 +1267,7 @@ pub fn bn_to_bytes_le(b: &[u64], res: &mut [u8]) {
 /**
 Returns 2^64 - 1 if a < b, otherwise returns 0.
 
- The arguments a and b are meant to be 256-bit bignums, i.e. uint64_t[4].
+ The arguments a and b are meant to be 256-bit bignums, i.e. `uint64_t\[4\]`.
 */
 pub fn lt_mask(a: &[u64], b: &[u64]) -> u64 {
     let mut acc: [u64; 1] = [0u64; 1usize];
@@ -1282,7 +1282,7 @@ pub fn lt_mask(a: &[u64], b: &[u64]) -> u64 {
 /**
 Returns 2^64 - 1 if a = b, otherwise returns 0.
 
- The arguments a and b are meant to be 256-bit bignums, i.e. uint64_t[4].
+ The arguments a and b are meant to be 256-bit bignums, i.e. `uint64_t\[4\]`.
 */
 pub fn eq_mask(a: &[u64], b: &[u64]) -> u64 {
     let mut mask: [u64; 1] = [0xFFFFFFFFFFFFFFFFu64; 1usize];

hacl-rs/src/bignum/bignum256_32.rs

@@ -13,7 +13,7 @@ Write `a + b mod 2^256` in `res`.
 
   This functions returns the carry.
 
-  The arguments a, b and res are meant to be 256-bit bignums, i.e. uint32_t[8]
+  The arguments a, b and res are meant to be 256-bit bignums, i.e. `uint32_t\[8\]`
 */
 pub fn add(a: &[u32], b: &[u32], res: &mut [u32]) -> u32 {
     let mut c: [u32; 1] = [0u32; 1usize];
@@ -45,7 +45,7 @@ Write `a - b mod 2^256` in `res`.
 
   This functions returns the carry.
 
-  The arguments a, b and res are meant to be 256-bit bignums, i.e. uint32_t[8]
+  The arguments a, b and res are meant to be 256-bit bignums, i.e. `uint32_t\[8\]`
 */
 pub fn sub(a: &[u32], b: &[u32], res: &mut [u32]) -> u32 {
     let mut c: [u32; 1] = [0u32; 1usize];
@@ -76,7 +76,7 @@ pub fn sub(a: &[u32], b: &[u32], res: &mut [u32]) -> u32 {
 /**
 Write `(a + b) mod n` in `res`.
 
-  The arguments a, b, n and the outparam res are meant to be 256-bit bignums, i.e. uint32_t[8].
+  The arguments a, b, n and the outparam res are meant to be 256-bit bignums, i.e. `uint32_t\[8\]`.
 
   Before calling this function, the caller will need to ensure that the following
   preconditions are observed.
@@ -142,7 +142,7 @@ pub fn add_mod(n: &[u32], a: &[u32], b: &[u32], res: &mut [u32]) {
 /**
 Write `(a - b) mod n` in `res`.
 
-  The arguments a, b, n and the outparam res are meant to be 256-bit bignums, i.e. uint32_t[8].
+  The arguments a, b, n and the outparam res are meant to be 256-bit bignums, i.e. `uint32_t\[8\]`.
 
   Before calling this function, the caller will need to ensure that the following
   preconditions are observed.
@@ -209,8 +209,8 @@ pub fn sub_mod(n: &[u32], a: &[u32], b: &[u32], res: &mut [u32]) {
 /**
 Write `a * b` in `res`.
 
-  The arguments a and b are meant to be 256-bit bignums, i.e. uint32_t[8].
-  The outparam res is meant to be a 512-bit bignum, i.e. uint32_t[16].
+  The arguments a and b are meant to be 256-bit bignums, i.e. `uint32_t\[8\]`.
+  The outparam res is meant to be a 512-bit bignum, i.e. `uint32_t\[16\]`.
 */
 pub fn mul(a: &[u32], b: &[u32], res: &mut [u32]) {
     (res[0usize..16usize]).copy_from_slice(&[0u32; 16usize]);
@@ -245,8 +245,8 @@ pub fn mul(a: &[u32], b: &[u32], res: &mut [u32]) {
 /**
 Write `a * a` in `res`.
 
-  The argument a is meant to be a 256-bit bignum, i.e. uint32_t[8].
-  The outparam res is meant to be a 512-bit bignum, i.e. uint32_t[16].
+  The argument a is meant to be a 256-bit bignum, i.e. `uint32_t\[8\]`.
+  The outparam res is meant to be a 512-bit bignum, i.e. `uint32_t\[16\]`.
 */
 pub fn sqr(a: &[u32], res: &mut [u32]) {
     (res[0usize..16usize]).copy_from_slice(&[0u32; 16usize]);
@@ -476,8 +476,8 @@ fn bn_slow_precomp(n: &[u32], mu: u32, r2: &[u32], a: &[u32], res: &mut [u32]) {
 /**
 Write `a mod n` in `res`.
 
-  The argument a is meant to be a 512-bit bignum, i.e. uint32_t[16].
-  The argument n and the outparam res are meant to be 256-bit bignums, i.e. uint32_t[8].
+  The argument a is meant to be a 512-bit bignum, i.e. `uint32_t\[16\]`.
+  The argument n and the outparam res are meant to be 256-bit bignums, i.e. `uint32_t\[8\]`.
 
   The function returns false if any of the following preconditions are violated,
   true otherwise.
@@ -863,7 +863,7 @@ fn exp_consttime(nBits: u32, n: &[u32], a: &[u32], bBits: u32, b: &[u32], res: &
 /**
 Write `a ^ b mod n` in `res`.
 
-  The arguments a, n and the outparam res are meant to be 256-bit bignums, i.e. uint32_t[8].
+  The arguments a, n and the outparam res are meant to be 256-bit bignums, i.e. `uint32_t\[8\]`.
 
   The argument b is a bignum of any size, and bBits is an upper bound on the
   number of significant bits of b. A tighter bound results in faster execution
@@ -894,7 +894,7 @@ pub fn mod_exp_vartime(n: &[u32], a: &[u32], bBits: u32, b: &[u32], res: &mut [u
 /**
 Write `a ^ b mod n` in `res`.
 
-  The arguments a, n and the outparam res are meant to be 256-bit bignums, i.e. uint32_t[8].
+  The arguments a, n and the outparam res are meant to be 256-bit bignums, i.e. `uint32_t\[8\]`.
 
   The argument b is a bignum of any size, and bBits is an upper bound on the
   number of significant bits of b. A tighter bound results in faster execution
@@ -925,7 +925,7 @@ pub fn mod_exp_consttime(n: &[u32], a: &[u32], bBits: u32, b: &[u32], res: &mut
 /**
 Write `a ^ (-1) mod n` in `res`.
 
-  The arguments a, n and the outparam res are meant to be 256-bit bignums, i.e. uint32_t[8].
+  The arguments a, n and the outparam res are meant to be 256-bit bignums, i.e. `uint32_t\[8\]`.
 
   Before calling this function, the caller will need to ensure that the following
   preconditions are observed.
@@ -1018,7 +1018,7 @@ pub fn mod_inv_prime_vartime(n: &[u32], a: &[u32], res: &mut [u32]) -> bool {
 /**
 Heap-allocate and initialize a montgomery context.
 
-  The argument n is meant to be a 256-bit bignum, i.e. uint32_t[8].
+  The argument n is meant to be a 256-bit bignum, i.e. `uint32_t\[8\]`.
 
   Before calling this function, the caller will need to ensure that the following
   preconditions are observed.
@@ -1050,8 +1050,8 @@ pub fn mont_ctx_init(n: &[u32]) -> Box<[super::base::bn_mont_ctx_u32]> {
 /**
 Write `a mod n` in `res`.
 
-  The argument a is meant to be a 512-bit bignum, i.e. uint32_t[16].
-  The outparam res is meant to be a 256-bit bignum, i.e. uint32_t[8].
+  The argument a is meant to be a 512-bit bignum, i.e. `uint32_t\[16\]`.
+  The outparam res is meant to be a 256-bit bignum, i.e. `uint32_t\[8\]`.
   The argument k is a montgomery context obtained through Hacl_Bignum256_mont_ctx_init.
 */
 pub fn mod_precomp(k: &[super::base::bn_mont_ctx_u32], a: &[u32], res: &mut [u32]) {
@@ -1064,7 +1064,7 @@ pub fn mod_precomp(k: &[super::base::bn_mont_ctx_u32], a: &[u32], res: &mut [u32
 /**
 Write `a ^ b mod n` in `res`.
 
-  The arguments a and the outparam res are meant to be 256-bit bignums, i.e. uint32_t[8].
+  The arguments a and the outparam res are meant to be 256-bit bignums, i.e. `uint32_t\[8\]`.
   The argument k is a montgomery context obtained through Hacl_Bignum256_mont_ctx_init.
 
   The argument b is a bignum of any size, and bBits is an upper bound on the
@@ -1096,7 +1096,7 @@ pub fn mod_exp_vartime_precomp(
 /**
 Write `a ^ b mod n` in `res`.
 
-  The arguments a and the outparam res are meant to be 256-bit bignums, i.e. uint32_t[8].
+  The arguments a and the outparam res are meant to be 256-bit bignums, i.e. `uint32_t\[8\]`.
   The argument k is a montgomery context obtained through Hacl_Bignum256_mont_ctx_init.
 
   The argument b is a bignum of any size, and bBits is an upper bound on the
@@ -1128,7 +1128,7 @@ pub fn mod_exp_consttime_precomp(
 /**
 Write `a ^ (-1) mod n` in `res`.
 
-  The argument a and the outparam res are meant to be 256-bit bignums, i.e. uint32_t[8].
+  The argument a and the outparam res are meant to be 256-bit bignums, i.e. `uint32_t\[8\]`.
   The argument k is a montgomery context obtained through Hacl_Bignum256_mont_ctx_init.
 
   Before calling this function, the caller will need to ensure that the following
@@ -1304,7 +1304,7 @@ pub fn bn_to_bytes_le(b: &[u32], res: &mut [u8]) {
 /**
 Returns 2^32 - 1 if a < b, otherwise returns 0.
 
- The arguments a and b are meant to be 256-bit bignums, i.e. uint32_t[8].
+ The arguments a and b are meant to be 256-bit bignums, i.e. `uint32_t\[8\]`.
 */
 pub fn lt_mask(a: &[u32], b: &[u32]) -> u32 {
     let mut acc: [u32; 1] = [0u32; 1usize];
@@ -1319,7 +1319,7 @@ pub fn lt_mask(a: &[u32], b: &[u32]) -> u32 {
 /**
 Returns 2^32 - 1 if a = b, otherwise returns 0.
 
- The arguments a and b are meant to be 256-bit bignums, i.e. uint32_t[8].
+ The arguments a and b are meant to be 256-bit bignums, i.e. `uint32_t\[8\]`.
 */
 pub fn eq_mask(a: &[u32], b: &[u32]) -> u32 {
     let mut mask: [u32; 1] = [0xFFFFFFFFu32; 1usize];