Ndtyjky

7.20.4.1 Macros for minimum-width integer constants

... The macro UINTN_C(value) shall expand to an integer constant expression corresponding to the type uint_leastN_t. For example, if uint_least64_t is a name for the type unsigned long long int, then UINT64_C(0x123) might expand to the integer constant 0x123ULL. C11dr §7.20.4.1 1

The type of UINTN_C() and friends are not as expected. See "Expected" comments in code output.

A) Is my compiler implementation wrong and the constant type should be uint_leastN_t?

or

B) Should the type of constant from UINTN_C(value) be the minimum of uint_leastN_t, int, unsigned and type needed to encode the value?

or

C) something else?

I had expected that the type of the constants to correspond to uint_leastN_t, but it appears to not be so under 2 conditions:

**1 If the macro corresponding type is below int/unsigned, the constant is int/unsigned

**2 If the value exceeds the range of the uint_leastN_t, then the type becomes a wider type constant.

§6.4.4.1 "The type of an integer constant is the first of the corresponding list in which its value can be represented ... (long list follows).

#include <limits.h>

#include <stdio.h>



#define type_of(X) _Generic((X), 

  unsigned long long: "unsigned long long", 

  unsigned long: "unsigned long", 

  unsigned: "unsigned", 

  int: "int", 

  unsigned short: "unsigned short", 

  default: "?" 

  )



int main() {

  uint_least16_t u16 = 0;

  uint_least32_t u32 = 0;

  uint_least64_t u64 = 0;

  printf("%zu %sn", sizeof(u16), type_of(u16));

  printf("%zu %sn", sizeof(u32), type_of(u32));

  printf("%zu %sn", sizeof(u64), type_of(u64));

  puts("");

  printf("%zu %sn", sizeof((uint_least16_t) UINT16_C(0)), type_of((uint_least16_t) UINT16_C(0)));

  printf("%zu %sn", sizeof UINT16_C(0), type_of(UINT16_C(0)));

  printf("%zu %sn", sizeof UINT16_C(0x1234), type_of(UINT16_C(0x1234)));

  printf("%zu %sn", sizeof UINT16_C(0x12345), type_of(UINT16_C(0x12345)));

  printf("%zu %sn", sizeof UINT32_C(0x12345678), type_of(UINT32_C(0x12345678)));

  printf("%zu %sn", sizeof UINT32_C(0x123456789), type_of(UINT32_C(0x123456789)));

  return 0;



  //round_frac_test(-2.05446162500000000e+06, 205);

  round_frac_test(fp_rand(), 6);

  round_frac_tests(10000);

  puts("Done");

  return 0;

}

Output

2 unsigned short

4 unsigned

8 unsigned long long



2 unsigned short

4 int       // Expected 2 unsigned short, see **1

4 int       // Expected 2 unsigned short, see **1

4 int       // Expected 2 unsigned short, see **2

4 unsigned

8 unsigned long long  // Expected 4 unsigned, see **2

I am using (GNU C11 (GCC) version 5.4.0)

In forming this post, I am leaning toward B, yet I am looking for your rational for confirmation -one way of the other. If B is so, a disappointing part is that UINTN_C() could result in a signed type.

I suppose that is what the "minimum-width" part is about.

This is covered in the parent subsection, 7.20.4.

In the portion you quoted:

The macro UINTN_C(value) shall expand to an integer constant expression corresponding to the type uint_leastN_t.

it says "corresponding to", not that the expansion is actually of that type. The meaning of "corresponding to" is explained in 7.20.4p3:

Each invocation of one of these macros shall expand to an integer
constant expression suitable for use in #if preprocessing directives.
The type of the expression shall have the same type as would an
expression of the corresponding type converted according to the
integer promotions. The value of the expression shall be that of the
argument.

Since the macros are intended to be used in an #if directive, they cannot use casts (the preprocessor doesn't understand casts or type names).

In practice, such a constant expression will almost always be implicitly converted to the appropriate type, so the fact that its actual type differs from what you might expect is not generally a problem.

As for a value outside the range of uint_leastN_t, that's also covered in the parent subsection, in 7.20.4p2:

The argument in any instance of these macros shall be an unsuffixed
integer constant (as defined in 6.4.4.1) with a value that does not
exceed the limits for the corresponding type.

This is a "shall" outside a constraint, so violating it causes undefined behavior. Don't do that.

(When reading the C standard, it's generally a good idea to check the parent subsections for wording that might clarify or override what you're reading. I've been bitten by this myself.)

On the host with 16 bit short and 32 bit integers unsigned short numbers are promoted to int. So the those macros are defined as:

#define INT16_C(x) (x)

#define UINT16_C(x) (x)

with no 'U' suffix for the unsigned short

If an int can represent all values of the original type (as restricted
by the width, for a bit-field), the value is converted to an int;

Those macros do only expand to the corresponding constants (or integer literals using more common language), and do not create any objects, and have to usable in the #if. So no casts are allowed. Macros do not perform any range checks as well.

int16_t x0 = 123;

uint16_t x1 = 123;    // no sign suffix needed

int32_t x2 = 2147483647;

uint32_t x3 = 2147583647U;  //sign suffix theoreticaly needed as int and unsigned int have the same rank

int64_t x4 = 9223372036854775807LL; 

uint64_t x5 = 9237372036854775807ULL; //same as above