JTC1/SC22/WG21 N1568

WG21 N1568=04-0008

PROPOSED ADDITIONS TO TR-1 TO IMPROVE
COMPATIBILITY WITH C99

P.J. Plauger
Dinkumware, Ltd.
pjp@dinkumware.com


1. General

This clause describes additions designed to bring the Standard C++
library in closer agreement with the library described in
ISO/IEC 9899:1999 Standard C, as corrected through 2003 (hereafter
C99, for short).

To avoid the need for language changes:

1) Any use of the type *long long* in C99 is replaced in this
clause by the type *_Longlong*, which behaves like a signed integer
type that occupies at least 64 bits. Any header containing a declaration
that uses *_Longlong* shall provide an idempotent definition of
*_Longlong*.

2) Any use of the type *unsigned long long* in C99 is replaced in this
clause by the type *_ULonglong*, which behaves like an unsigned integer
type with the same number of bits as *_Longlong*. Any header containing
a declaration that uses *_ULonglong* shall provide an idempotent
definition of *_ULonglong*.

3) Any use of the type qualifier *restrict* in C99 shall be omitted
in this clause.

2. Additions to header *<complex>*

2.1 Synopsis

namespace std {
	namespace tr1 {
template<class T>
	complex<T> acos(complex<T>& x);
template<class T>
	complex<T> asin(complex<T>& x);
template<class T>
	complex<T> atan(complex<T>& x);

template<class T>
	complex<T> acosh(complex<T>& x);
template<class T>
	complex<T> asinh(complex<T>& x);
template<class T>
	complex<T> atanh(complex<T>& x);
template<class T>
	complex<T> fabs(complex<T>& x);
	}
}

2.2 Function acos

Effects: Behaves the same as C99 function *cacos*,
defined in subclause 7.3.5.1.

2.3 Function asin

Effects: Behaves the same as C99 function *casin*,
defined in subclause 7.3.5.2.

2.4 Function atan

Effects: Behaves the same as C99 function *catan*,
defined in subclause 7.3.5.3.

2.5 Function acosh

Effects: Behaves the same as C99 function *cacosh*,
defined in subclause 7.3.6.1.

2.6 Function asinh

Effects: Behaves the same as C99 function *casinh*,
defined in subclause 7.3.6.2.

2.7 Function atanh

Effects: Behaves the same as C99 function *catanh*,
defined in subclause 7.3.6.3.

2.8 Function fabs

Effects: Behaves the same as C99 function *cabs*,
defined in subclause 7.3.8.1.

2.8 Additional Overloads

The following template functions shall have additional overloads:

	arg
	conj
	imag
	norm
	polar
	real

The additional overloads shall be sufficient to ensure:

	1. If the argument has type *long double*, then it is effectively cast
	to *complex<long double>*.

	2. Otherwise, if the argument has type *double* or an integer type,
	then it is effectively cast to *complex<double>*.

	3. Otherwise, if the argument has type *float*, then it is effectively
	cast to *complex<float>*.

Template function *pow* shall have additional overloads sufficient to
ensure, for a call with at least one argument of type *complex<T>*:

	1. If either argument has type *complex<long double>* or type *long
	double*, then both arguments are effectively cast to
	*complex<long double>*.

	2. Otherwise, if either argument has type *complex<double>*, *double*,
	or an integer type, then both arguments are effectively cast to
	*complex<double>*.

	3. Otherwise, if either argument has type *complex<float>* or *float*,
	then both arguments are effectively cast to *complex<float>*.

3. Header *<ccomplex>*

The header behaves as if it simply includes the header *<complex>*.

4. Header *<complex.h>"

The header behaves as if it includes the header *<ccomplex>*, and provides
sufficient *using* declarations to declare in the global namespace all
function and type names declared or defined in the neader *<complex>*.

5. Additions to header *<cctype>*

5.1 Synopsis

namespace std {
	namespace tr1 {
int isblank(int ch);
	}
}

5.2 Function isblank

Function *isblank* behaves the same as C99 function *isblank*,
defined in subclause 7.4.1.3.

6. Additions to header *<ctype.h>*

The header behaves as if it includes the header *<cctype>*, and provides
sufficient additional *using* declarations to declare in the global
namespace the additional function name declared in the header *<cctype>*.

7. Header *<cfenv>*

7.1 Synopsis

namespace std {
	namespace tr1 {
	// types
typedef <object type> fenv_t;
typedef <integer type fexcept_t;

    // functions
int feclearexcept(int except);
int fegetexceptflag(fexcept_t *pflag, int except);
int feraiseexcept(int except);
int fesetexceptflag(const fexcept_t *pflag, int except);
int fetestexcept(int except);

int fegetround(void);
int fesetround(int mode);

int fegetenv(fenv_t *penv);
int feholdexcept(fenv_t *penv);
int fesetenv(const fenv_t *penv);
int feupdateenv(const fenv_t *penv);
	}
}

The header also defines the macros:

	FE_ALL_EXCEPT
	FE_DIVBYZERO
	FE_INEXACT
	FE_INVALID
	FE_OVERFLOW
	FE_UNDERFLOW

	FE_DOWNWARD
	FE_TONEAREST
	FE_TOWARDZERO
	FE_UPWARD

	FE_DFL_ENV

7.2 Definitions

The header defines all functions, types, and macros the same as
C99 subclause 7.6.

8. Header *<fenv.h>"

The header behaves as if it includes the header *<cfenv>*, and provides
sufficient *using* declarations to declare in the global namespace all
function and type names declared or defined in the header *<cfenv>*.

9. Additions to header *<cfloat>*

The header defines the macros:

	DECIMAL_DIG
	FLT_EVAL_METHOD

the same as C99 subclause 5.2.4.2.2.

10. Additions to header *<float.h>*

The header behaves as if it defines the additional macros defined in
*<cfloat>* by including the header *<cfloat>*.

11. Additions to header *<ios>*

11.1 Synopsis

namespace std {
	namespace tr1 {
ios_base& hexfloat(ios_base& str);
	}
}

11.2 Function *hexfloat*

ios_base& hexfloat(ios_base& str);

Effects: Calls *str.setf(ios_base::fixed | ios_base::scientific,
	ios_base::floatfield)*.

Returns: *str*.

[Note that adding the format flag hexfloat to class *ios_base*
cannot be done without invading namespace std, so only the named
manipulator is provided. Note also that the more obvious use of
ios_base::hex to specify hexadecimal floating-point format would
change the meaning of existing well defined programs. C++2003
gives no meaning to the combination of fixed and scientific.]

12. Header *<cinttypes>*

12.1 Synopsis

#include <cstdint>

namespace std {
	namespace tr1 {
	// types
typedef struct {
    intmax_t quot, rem;
    } imaxdiv_t;

    // functions
intmax_t imaxabs(intmax_t i);
intmax_t abs(intmax_t i);

imaxdiv_t imaxdiv(intmax_t numer, intmax_t denom);
imaxdiv_t div(intmax_t numer, intmax_t denom);

intmax_t strtoimax(const char * s, char **endptr, int base);
uintmax_t strtoumax(const char *s, char **endptr, int base);
intmax_t wcstoimax(const wchar_t *s, wchar_t **endptr, int base);
uintmax_t wcstoumax(const wchar_t *s, wchar_t **endptr, int base);
	}
}

The header also defines numerous macros of the form:

	PRI{d i o u x X}[FAST LEAST]{8 16 32 64}
	PRI{d i o u x X}{MAX PTR}
	SCN{d i o u x}[FAST LEAST]{8 16 32 64}
	SCN{d i o u x}{MAX PTR}

12.2 Definitions

The header defines all functions, types, and macros the same as
C99 subclause 7.8.

13. Header *<inttypes.h>"

The header behaves as if it includes the header *<cinttypes>*, and
provides sufficient *using* declarations to declare in the global
namespace all function and type names declared or defined in the
header *<cinttypes>*.

14. Additions to header *<climits>*

The header defines the macros:

	LLONG_MIN
	LLONG_MAX
	ULLONG_MAX

the same as C99 subclause 5.2.4.2.1.

15. Additions to header *<limits.h>*

The header behaves as if it defines the additional macros defined in
*<climits>* by including the header *<climits>*.

16. Additions to header *<locale>*

In subclause 22.2.2.2.2, Table 58 Floating-point conversions, after the line:

	floatfield == ios_base::scientific	%E

add the two lines:

	floatfield == ios_base::fixed | ios_base::scientific && !uppercase	%a
	floatfield == ios_base::fixed | ios_base::scientific	%A

[Note that the additional requirements on print and scan functions,
later in this clause, ensure that the print functions generate hexadecimal
floating-point fields with a *%a* or *%A* conversion specifier, and that the
scan functions match hexadecimal floating-point fields with a *%g* conversion
specifier.]

17. Additions to header *<cmath>*

17.1 Synopsis

namespace std {
	namespace tr1 {
	// types
typedef <floating-type> double_t;
typedef <floating-type> float_t;

	// functions
double acosh(double x);
float acoshf(float x);
long double acoshl(long double x);

double asinh(double x);
float asinhf(float x);
long double asinhl(long double x);

double atanh(double x);
float atanhf(float x);
long double atanhl(long double x);

double cbrt(double x);
float cbrtf(float x);
long double cbrtl(long double x);

double copysign(double x, double y);
float copysignf(float x, float y);
long double copysignl(long double x, long double y);

double erf(double x);
float erff(float x);
long double erfl(long double x);

double erfc(double x);
float erfcf(float x);
long double erfcl(long double x);

double exp2(double x);
float exp2f(float x);
long double exp2l(long double x);

double expm1(double x);
float expm1f(float x);
long double expm1l(long double x);

double fdim(double x, double y);
float fdimf(float x, float y);
long double fdiml(long double x, long double y);

double fma(double x, double y, double z);
float fmaf(float x, float y, float z);
long double fmal(long double x, long double y, long double z);

double fmax(double x, double y);
float fmaxf(float x, float y);
long double fmaxl(long double x, long double y);

double fmin(double x, double y);
float fminf(float x, float y);
long double fminl(long double x, long double y);

double hypot(double x, double y);
float hypotf(float x, float y);
long double hypotl(long double x, long double y);

int ilogb(double x);
int ilogbf(float x);
int ilogbl(long double x);

double lgamma(double x);
float lgammaf(float x);
long double lgammal(long double x);

long long llrint(double x);
long long llrintf(float x);
long long llrintl(long double x);

long long llround(double x);
long long llroundf(float x);
long long llroundl(long double x);

double log1p(double x);
float log1pf(float x);
long double log1pl(long double x);

double log2(double x);
float log2f(float x);
long double log2l(long double x);

double logb(double x);
float logbf(float x);
long double logbl(long double x);

long lrint(double x);
long lrintf(float x);
long lrintl(long double x);

long lround(double x);
long lroundf(float x);
long lroundl(long double x);

double nan(const char *str);
float nanf(const char *str);
long double nanl(const char *str);

double nearbyint(double x);
float nearbyintf(float x);
long double nearbyintl(long double x);

double nextafter(double x, double y);
float nextafterf(float x, float y);
long double nextafterl(long double x, long double y);

double nexttoward(double x, long double y);
float nexttowardf(float x, long double y);
long double nexttowardl(long double x, long double y);

double remainder(double x, double y);
float remainderf(float x, float y);
long double remainderl(long double x, long double y);

double remquo(double x, double y, int *pquo);
float remquof(float x, float y, int *pquo);
long double remquol(long double x, long double y, int *pquo);

double rint(double x);
float rintf(float x);
long double rintl(long double x);

double round(double x);
float roundf(float x);
long double roundl(long double x);

double scalbln(double x, long ex);
float scalblnf(float x, long ex);
long double scalblnl(long double x, long ex);

double scalbn(double x, int ex);
float scalbnf(float x, int ex);
long double scalbnl(long double x, int ex);

double tgamma(double x);
float tgammaf(float x);
long double tgammal(long double x);

double trunc(double x);
float truncf(float x);
long double truncl(long double x);

	// C99 macros defined as C++ templates
template<class T>
	bool signbit(T x);

template<class T>
	bool fpclassify(T x);
template<class T>
	bool isfinite(T x);
template<class T>
	bool isinf(T x);
template<class T>
	bool isnan(T x);
template<class T>
	bool isnormal(T x);

template<class T>
	bool isgreater(T x, T y);
template<class T>
	bool isgreaterequal(T x, T y);
template<class T>
	bool isless(T x, T y);
template<class T>
	bool islessequal(T x, T y);
template<class T>
	bool islessgreater(T x, T y);
template<class T>
	bool isunordered(T x, T y);
	}
}

The header also defines the macros:

	FP_FAST_FMA
	FP_FAST_FMAF
	FP_FAST_FMAL

	FP_ILOGB0
	FP_ILOGBNAN

	FP_INFINITE
	FP_NAN
	FP_NORMAL
	FP_SUBNORMAL
	FP_ZERO

	HUGE_VALF
	HUGE_VALL

	INFINITY
	NAN

	MATH_ERRNO
	MATH_ERREXCEPT
	math_errhandling

17.2 Definitions

The header defines all of the above (non-template) functions,
types, and macros the same as C99 subclause 7.12.

17.3 Template function definitions

The template functions:

template<class T>
	bool signbit(T x);

template<class T>
	bool fpclassify(T x);
template<class T>
	bool isfinite(T x);
template<class T>
	bool isinf(T x);
template<class T>
	bool isnan(T x);
template<class T>
	bool isnormal(T x);

template<class T>
	bool isgreater(T x);
template<class T>
	bool isgreaterequal(T x);
template<class T>
	bool isless(T x);
template<class T>
	bool islessequal(T x);
template<class T>
	bool islessgreater(T x);
template<class T>
	bool isunordered(T x);

behave the same as C99 macros with corresponding names defined in C99
subclause 7.12.3 Classification macros and C99 subclause 7.12.14
Comparison macros.

17.4 Additional overloads

The following functions shall have additional overloads:

	acos
	acosh
	asin
	asinh
	atan
	atan2
	atanh
	cbrt
	ceil
	copysign
	cos
	cosh
	erf
	erfc
	exp
	exp2
	expm1
	fabs
	fdim
	floor
	fma
	fmax
	fmin
	fmod
	frexp
	hypot
	log
	ilogb
	ldexp
	lgamma
	llrint
	llround
	log10
	log1p
	logb
	lrint
	lround
	nearbyint
	nextafter
	nexttoward
	pow
	remainder
	remquo
	rint
	round
	scalbln
	scalbn
	sin
	sinh
	sqrt
	tan
	tanh
	tgamma
	trunc

Each of the above functions shall have an overload with all parameters of
type *double* replaced with *long double*. If the return type of the
above function is type *double*, the return type of the overload shall
be *long double*.

Each of the above functions shall also have an overload with all parameters
of type *double* replaced with *float*. If the return type of the above
function is type *double*, the return type of the overload shall be *float*.

Moreover, there shall be additional overloads sufficient to ensure:

	1. If any argument corresponding to a *double* parameter has type
	*long double*, then all arguments corresponding to *double* parameters
	are effectively cast to *long double*.

	2. Otherwise, if any argument corresponding to a *double* parameter has
	type *double* or an integer type, then all arguments corresponding to
	*double* parameters are effectively cast to *double*.

	3. Otherwise, all arguments corresponding to *double* parameters are
	effectively cast to *float*.

18. Additions to header *<math.h>"

The header behaves as if it includes the header *<cmath>*, and provides
sufficient additional *using* declarations to declare in the global
namespace all the additional template function, function, and type names
declared or defined in the header *<cmath>*.

19. Additions to header *<cstdarg>*

Add the function macro:

	va_copy(va_list dest, va_list src)

as defined in C99 subclause 7.15.1.2.

20. Additions to header *<stdarg.h>*

The header behaves as if it defines the additional macro defined in
*<cstdarg>* by including the header *<cstdarg>*.

21. The header *<cstdbool>*

The header simply defines the macro:

	__bool_true_false_are_defined

as defined in C99 subclause 7.16.

22. The header *<stdbool.h>*

The header behaves as if it defines the additional macro defined in
*<cstbool>* by including the header *<cstdbool>*.

23. The header *<cstdint>*

23.1 Synopsis

namespace std {
	namespace tr1 {
	typedef <signed integer type> int8_t;	// optional
	typedef <signed integer type> int16_t;	// optional
	typedef <signed integer type> int32_t;	// optional
	typedef <signed integer type> int64_t;	// optional

	typedef <signed integer type> int_fast8_t;
	typedef <signed integer type> int_fast16_t;
	typedef <signed integer type> int_fast32_t;
	typedef <signed integer type> int_fast64_t;

	typedef <signed integer type> int_least8_t;
	typedef <signed integer type> int_least16_t;
	typedef <signed integer type> int_least32_t;
	typedef <signed integer type> int_least64_t;

	typedef <signed integer type> intmax_t;
	typedef <signed integer type> intptr_t;

	typedef <unsigned integer type> uint8_t;	// optional
	typedef <unsigned integer type> uint16_t;	// optional
	typedef <unsigned integer type> uint32_t;	// optional
	typedef <unsigned integer type> uint64_t;	// optional

	typedef <unsigned integer type> uint_fast8_t;
	typedef <unsigned integer type> uint_fast16_t;
	typedef <unsigned integer type> uint_fast32_t;
	typedef <unsigned integer type> uint_fast64_t;

	typedef <unsigned integer type> uint_least8_t;
	typedef <unsigned integer type> uint_least16_t;
	typedef <unsigned integer type> uint_least32_t;
	typedef <unsigned integer type> uint_least64_t;

	typedef <unsigned integer type> uintmax_t;
	typedef <unsigned integer type> uintptr_t;
	}
}

The header also defines numerous macros of the form:

	INT[FAST LEAST]{8 16 32 64}_MIN
	[U]INT[FAST LEAST]{8 16 32 64}_MAX
	INT{MAX PTR}_MIN
	[U]INT{MAX PTR}_MAX
	{PTRDIFF SIG_ATOMIC WCHAR WINT}{_MAX _MIN}
	SIZE_MAX

plus function macros of the form:

	[U]INT{8 16 32 64 MAX}_C

23.2 Definitions

The header defines all functions, types, and macros the same as
C99 subclause 7.18.

24. The header *<stdint.h>*

The header behaves as if it includes the header *<cstdint>*, and provides
sufficient *using* declarations to declare in the global namespace all
type names defined in the header *<cstdint>*.

25. Additions to header *<cstdio>*

25.1 Synopsis

namespace std {
	namespace tr1 {
int snprintf(char *s, size_t n, const char *format, ...);
int vsnprintf(char *s, size_t n, const char *format, va_list ap);

int vfscanf(FILE *stream, const char *format, va_list ap);
int vscanf(const char *format, va_list ap);
int vsscanf(const char *s, const char *format, va_list ap);
	}
}

25.2 Definitions

The header defines all added functions the same as C99 subclause 7.19.

25.3 Additional formatted input/output conversion specifications

The formatted output functions shall support the additional conversion
specifications specified in C99 subclause 7.19.6.1.

The formatted input functions shall support the additional conversion
specifications specified in C99 subclause 7.19.6.2.

[Note: These include the conversion specifiers a (for hexadecimal
floating-point) and F, and the conversion qualifiers hh, h, ll, t,
and z (for various integer types). They also include the ability
to match and generate various text forms of infinity and NaN values.]

26. Additions to header *<stdio.h>*

The header behaves as if it includes the header *<cstdio>*, and provides
sufficient additional *using* declarations to declare in the global
namespace all added function names defined in the header *<cstdio>*.

27. Additions to header *<cstdlib>*

27.1 Synopsis

namespace std {
	namespace tr1 {
	// types
typedef struct {
    _Longlong quot, rem;
    } lldiv_t;

	// functions
_Longlong llabs(long long i);
lldiv_t lldiv(_Longlong numer, _Longlong denom);

_Longlong atoll(const char *s);
_Longlong strtoll(const char *s, char **endptr, int base);
_ULonglong strtoull(const char *s, char **endptr, int base);

float strtof(const char *s, char **endptr);
long double strtold(const char *s, char **endptr);

	// overloads
_Longlong abs(_Longlong i);
lldiv_t div(_Longlong numer, _Longlong denom);
	}
}

27.2 Definitions

The header defines all added types and functions, other than the
overloads of *abs* and *div*, the same as C99 subclause 7.20.

27.3 Function abs

_Longlong abs(_Longlong i);

Effects: Behaves the same as C99 function *llabs*,
defined in subclause 7.20.6.1.

27.4 Function div

lldiv_t div(_Longlong numer, _Longlong denom);

Effects: Behaves the same as C99 function *lldiv*,
defined in subclause 7.20.6.2.

28. Additions to header *<stdlib.h>*

The header behaves as if it includes the header *<cstdlib>*, and provides
sufficient additional *using* declarations to declare in the global
namespace all added type and function names defined in the header *<cstdlib>*.

29. Header *<ctgmath>*

The header simply includes the headers *<ccomplex>* and *<cmath>*.

[Note that the overloads provided in C99 by magic macros are already
provided in *<ccomplex>* and *<cmath>* by "sufficient" additional overloads.]

30. Header *<tgmath.h>*

The header effectively includes the headers *<complex.h>* and *<math.h>*.

31. Additions to header *<ctime>*

The function *strftime* shall support the additional conversion
specifiers and modifiers specified in C99 subclause 7.23.3.4.

[Note: These include the conversion specifiers C, D, e, F, g, G, h,
r, R, t, T, u, V, and z, and the modifiers E and O.]

32. Additions to header *<cwchar>*

32.1 Synopsis

namespace std {
	namespace tr1 {
float wcstof(const wchar_t *nptr, wchar_t **endptr);
long double wcstold(const wchar_t *nptr, wchar_t **endptr);
_Longlong wcstoll(const wchar_t *nptr, wchar_t **endptr, int base);
_ULonglong wcstoull(const wchar_t *nptr, wchar_t **endptr, int base);

int vfwscanf(FILE *stream, const wchar_t *format, va_list arg);
int vswscanf(const wchar_t *s, const wchar_t *format, va_list arg);
int vwscanf(const wchar_t *format, va_list arg);
	}
}

Moreover, the function *wcsftime* shall support the additional conversion
specifiers and modifiers specified in C99 subclause 7.23.3.4.

32.2 Definitions

The header defines all added functions the same as C99 subclause 7.24.

32.3 Additional formatted wide input/output conversion specifications

The formatted wide output functions shall support the additional conversion
specifications specified in C99 subclause 7.24.2.1.

The formatted wide input functions shall support the additional conversion
specifications specified in C99 subclause 7.24.2.2.

[Note: These are essentially the same extensions as for the header
*<cstdio>*.]

33. Additions to header *<wchar.h>*

The header behaves as if it includes the header *<cwchar>*, and provides
sufficient additional *using* declarations to declare in the global
namespace all added function names defined in the header *<cwchar>*.

34. Additions to header *<cwctype>*

34.1 Synopsis

namespace std {
	namespace tr1 {
int isbwlank(wint_t ch);
	}
}

34.2 Function iswblank

Function *iswblank* behaves the same as C99 function *iswblank*,
defined in subclause 7.25.2.1.3.

35. Additions to header *<wctype.h>*

The header behaves as if it includes the header *<cwctype>*, and provides
sufficient additional *using* declarations to declare in the global
namespace the additional function name declared in the header *<cwctype>*.