diff options
Diffstat (limited to 'test')
56 files changed, 2859 insertions, 132 deletions
diff --git a/test/Analysis/array-struct.c b/test/Analysis/array-struct.c index c0e1d8b7e39f..0ad7ae7e8283 100644 --- a/test/Analysis/array-struct.c +++ b/test/Analysis/array-struct.c @@ -148,3 +148,13 @@ void f15() { if (a[1]) // no-warning 1; } + +struct s3 p[1]; + +// Code from postgresql. +// Current cast logic of region store mistakenly leaves the final result region +// an ElementRegion of type 'char'. Then load a nonloc::SymbolVal from it and +// assigns to 'a'. +void f16(struct s3 *p) { + struct s3 a = *((struct s3*) ((char*) &p[0])); +} diff --git a/test/CXX/dcl.dcl/dcl.spec/dcl.fct.spec/p3.cpp b/test/CXX/dcl.dcl/dcl.spec/dcl.fct.spec/p3.cpp new file mode 100644 index 000000000000..3b0e345f0172 --- /dev/null +++ b/test/CXX/dcl.dcl/dcl.spec/dcl.fct.spec/p3.cpp @@ -0,0 +1,11 @@ +// RUN: clang-cc -verify %s +// XFAIL + +void f0(void) { + inline void f1(); // expected-error {{'inline' is not allowed on block scope function declaration}} +} + +// FIXME: Add test for "If the inline specifier is used in a friend declaration, +// that declaration shall be a definition or the function shall have previously +// been declared inline. + diff --git a/test/CXX/dcl.dcl/dcl.spec/dcl.fct.spec/p4.cpp b/test/CXX/dcl.dcl/dcl.spec/dcl.fct.spec/p4.cpp new file mode 100644 index 000000000000..0142dcbb055c --- /dev/null +++ b/test/CXX/dcl.dcl/dcl.spec/dcl.fct.spec/p4.cpp @@ -0,0 +1,7 @@ +// RUN: clang-cc -verify %s +// XFAIL + +void f0() { +} + +inline void f0(); // expected-error {{function definition cannot preceed inline declaration}} diff --git a/test/CXX/dcl.dcl/dcl.spec/dcl.fct.spec/p6.cpp b/test/CXX/dcl.dcl/dcl.spec/dcl.fct.spec/p6.cpp new file mode 100644 index 000000000000..c5f0a51b22e5 --- /dev/null +++ b/test/CXX/dcl.dcl/dcl.spec/dcl.fct.spec/p6.cpp @@ -0,0 +1,13 @@ +// RUN: clang-cc -verify %s +// XFAIL + +class A { +public: + explicit A(); + + explicit operator int(); // expected-warning {{explicit conversion functions are a C++0x extension}} + + explicit void f0(); // expected-error {{'explicit' cannot only be applied to constructor or conversion function}} +}; + +explicit A::A() { } // expected-error {{'explicit' cannot be specified outside class definition}} diff --git a/test/CXX/dcl.dcl/dcl.spec/dcl.stc/p10.cpp b/test/CXX/dcl.dcl/dcl.spec/dcl.stc/p10.cpp new file mode 100644 index 000000000000..62ae7bfded14 --- /dev/null +++ b/test/CXX/dcl.dcl/dcl.spec/dcl.stc/p10.cpp @@ -0,0 +1,14 @@ +// RUN: clang-cc -verify %s +// XFAIL + +typedef const int T0; +typedef int& T1; + +struct s0 { + mutable const int f0; // expected-error{{'mutable' and 'const' cannot be mixed}} + mutable T0 f1; // expected-error{{'mutable' and 'const' cannot be mixed}} + mutable int &f2; // expected-error{{'mutable' cannot be applied to references}} + mutable T1 f3; // expected-error{{'mutable' cannot be applied to references}} + mutable struct s1 {}; // expected-error{{'mutable' cannot be applied to non-data members}} + mutable void im0(); // expected-error{{'mutable' cannot be applied to functions}} +}; diff --git a/test/CXX/dcl.dcl/dcl.spec/dcl.stc/p9.cpp b/test/CXX/dcl.dcl/dcl.spec/dcl.stc/p9.cpp new file mode 100644 index 000000000000..5d9f9e7a51c5 --- /dev/null +++ b/test/CXX/dcl.dcl/dcl.spec/dcl.stc/p9.cpp @@ -0,0 +1,12 @@ +// RUN: clang-cc -verify %s + +struct S; // expected-note {{forward declaration of 'struct S'}} +extern S a; +extern S f(); +extern void g(S a); // expected-note {{candidate function}} + +void h() { + // FIXME: This diagnostic could be better. + g(a); // expected-error {{no matching function for call to 'g'}} + f(); // expected-error {{return type of called function ('struct S') is incomplete}} +} diff --git a/test/CXX/dcl.dcl/dcl.spec/dcl.typedef/p3.cpp b/test/CXX/dcl.dcl/dcl.spec/dcl.typedef/p3.cpp new file mode 100644 index 000000000000..867b4f03d41f --- /dev/null +++ b/test/CXX/dcl.dcl/dcl.spec/dcl.typedef/p3.cpp @@ -0,0 +1,8 @@ +// RUN: clang-cc -verify %s + +typedef struct s { int x; } s; +typedef int I; +typedef int I2; +typedef I2 I; // expected-note {{previous definition is here}} + +typedef char I; // expected-error {{typedef redefinition with different types}} diff --git a/test/CXX/dcl.dcl/dcl.spec/dcl.typedef/p4.cpp b/test/CXX/dcl.dcl/dcl.spec/dcl.typedef/p4.cpp new file mode 100644 index 000000000000..f1413f9b41b8 --- /dev/null +++ b/test/CXX/dcl.dcl/dcl.spec/dcl.typedef/p4.cpp @@ -0,0 +1,9 @@ +// RUN: clang-cc -verify %s +// XFAIL + +struct S { + typedef struct A {} A; // expected-note {{previous definition is here}} + typedef struct B B; + typedef A A; // expected-error {{redefinition of 'A'}} +}; + diff --git a/test/CXX/temp/temp.param/p1.cpp b/test/CXX/temp/temp.param/p1.cpp new file mode 100644 index 000000000000..488c3a07429a --- /dev/null +++ b/test/CXX/temp/temp.param/p1.cpp @@ -0,0 +1 @@ +// Paragraph 1 is descriptive, and therefore requires no tests. diff --git a/test/CXX/temp/temp.param/p10.cpp b/test/CXX/temp/temp.param/p10.cpp new file mode 100644 index 000000000000..56e7f3281eb6 --- /dev/null +++ b/test/CXX/temp/temp.param/p10.cpp @@ -0,0 +1,12 @@ +// RUN: clang-cc -fsyntax-only -verify %s +template<typename> struct Y1; +template<typename, int> struct Y2; + +template<class T1, class T2 = int> class B2; +template<class T1 = int, class T2> class B2; + +template<template<class, int> class, template<class> class = Y1> class B2t; +template<template<class, int> class = Y2, template<class> class> class B2t; + +template<int N, int M = 5> class B2n; +template<int N = 5, int M> class B2n; diff --git a/test/CXX/temp/temp.param/p11.cpp b/test/CXX/temp/temp.param/p11.cpp new file mode 100644 index 000000000000..9e7fd39c0a46 --- /dev/null +++ b/test/CXX/temp/temp.param/p11.cpp @@ -0,0 +1,15 @@ +// RUN: clang-cc -fsyntax-only -verify %s +template<typename> struct Y1; +template<typename, int> struct Y2; + +template<class T1 = int, // expected-note{{previous default template argument defined here}} + class T2> // expected-error{{template parameter missing a default argument}} + class B1; + +template<template<class> class = Y1, // expected-note{{previous default template argument defined here}} + template<class> class> // expected-error{{template parameter missing a default argument}} + class B1t; + +template<int N = 5, // expected-note{{previous default template argument defined here}} + int M> // expected-error{{template parameter missing a default argument}} + class B1n; diff --git a/test/CXX/temp/temp.param/p12.cpp b/test/CXX/temp/temp.param/p12.cpp new file mode 100644 index 000000000000..5511224ebe94 --- /dev/null +++ b/test/CXX/temp/temp.param/p12.cpp @@ -0,0 +1,37 @@ +// RUN: clang-cc -fsyntax-only -verify %s +template<typename> struct Y1; // expected-note{{too few template parameters in template template argument}} +template<typename, int> struct Y2; + +// C++ [temp.param]p12: +template<class T1, + class T2 = int> // expected-note{{previous default template argument defined here}} + class B3; +template<class T1, typename T2> class B3; +template<class T1, + typename T2 = float> // expected-error{{template parameter redefines default argument}} + class B3; + +template<template<class, int> class, + template<class> class = Y1> // expected-note{{previous default template argument defined here}} + class B3t; + +template<template<class, int> class, template<class> class> class B3t; + +template<template<class, int> class, + template<class> class = Y1> // expected-error{{template parameter redefines default argument}} + class B3t; + +template<int N, + int M = 5> // expected-note{{previous default template argument defined here}} + class B3n; + +template<int N, int M> class B3n; + +template<int N, + int M = 7> // expected-error{{template parameter redefines default argument}} + class B3n; + +// Check validity of default arguments +template<template<class, int> class // expected-note{{previous template template parameter is here}} + = Y1> // expected-error{{template template argument has different template parameters than its corresponding template template parameter}} + class C1; diff --git a/test/CXX/temp/temp.param/p13.cpp b/test/CXX/temp/temp.param/p13.cpp new file mode 100644 index 000000000000..559b892d0fd2 --- /dev/null +++ b/test/CXX/temp/temp.param/p13.cpp @@ -0,0 +1,14 @@ +// RUN: clang-cc -fsyntax-only -verify %s + +// The scope of atemplate-parameterextends from its point of +// declaration until the end of its template. In particular, a +// template-parameter can be used in the declaration of subsequent +// template-parameters and their default arguments. + +template<class T, T* p, class U = T> class X { /* ... */ }; +// FIXME: template<class T> void f(T* p = new T); + +// Check for bogus template parameter shadow warning. +template<template<class T> class, + template<class T> class> + class B1noshadow; diff --git a/test/CXX/temp/temp.param/p14.cpp b/test/CXX/temp/temp.param/p14.cpp new file mode 100644 index 000000000000..07e6bfe40983 --- /dev/null +++ b/test/CXX/temp/temp.param/p14.cpp @@ -0,0 +1,5 @@ +// RUN: clang-cc -fsyntax-only -verify %s +// XFAIL + +// A template-parameter shall not be used in its own default argument. +template<typename T = typename T::type> struct X; // expected-error{{default}} diff --git a/test/SemaTemplate/right-angle-brackets-0x.cpp b/test/CXX/temp/temp.param/p15-cxx0x.cpp index 57b6ee22410c..57b6ee22410c 100644 --- a/test/SemaTemplate/right-angle-brackets-0x.cpp +++ b/test/CXX/temp/temp.param/p15-cxx0x.cpp diff --git a/test/SemaTemplate/right-angle-brackets-98.cpp b/test/CXX/temp/temp.param/p15.cpp index 764bb7bae073..764bb7bae073 100644 --- a/test/SemaTemplate/right-angle-brackets-98.cpp +++ b/test/CXX/temp/temp.param/p15.cpp diff --git a/test/CXX/temp/temp.param/p2.cpp b/test/CXX/temp/temp.param/p2.cpp new file mode 100644 index 000000000000..a402cf6f888d --- /dev/null +++ b/test/CXX/temp/temp.param/p2.cpp @@ -0,0 +1,16 @@ +// RUN: clang-cc -fsyntax-only -verify %s + +// There is no semantic difference between class and typename in a +// template-parameter. typename followed by an unqualified-id names a +// template type parameter. +template<class T> struct X; +template<typename T> struct X; + +// typename followed by aqualified-id denotes the type in a non-type +// parameter-declaration. +// FIXME: template<typename T, typename T::type Value> struct Y; + +// A storage class shall not be specified in a template-parameter declaration. +template<static int Value> struct Z; // FIXME: expect an error + +// FIXME: add the example from p2 diff --git a/test/CXX/temp/temp.param/p3.cpp b/test/CXX/temp/temp.param/p3.cpp new file mode 100644 index 000000000000..6a76fe20b81a --- /dev/null +++ b/test/CXX/temp/temp.param/p3.cpp @@ -0,0 +1,28 @@ +// RUN: clang-cc -fsyntax-only -verify %s + +// A type-parameter defines its identifier to be a type-name (if +// declared with class or typename) or template-name (if declared with +// template) in the scope of the template declaration. +template<typename T> struct X0 { + T* value; +}; + +template<template<class T> class Y> struct X1 { + Y<int> value; +}; + +// [Note: because of the name lookup rules, a template-parameter that +// could be interpreted as either a non-type template-parameter or a +// type-parameter (because its identifier is the name of an already +// existing class) is taken as a type-parameter. For example, +class T { /* ... */ }; +int i; + +template<class T, T i> struct X2 { + void f(T t) + { + T t1 = i; //template-parameters T and i + ::T t2 = ::i; // global namespace members T and i \ + // expected-error{{cannot initialize}} + } +}; diff --git a/test/CXX/temp/temp.param/p4.cpp b/test/CXX/temp/temp.param/p4.cpp new file mode 100644 index 000000000000..3efff1243600 --- /dev/null +++ b/test/CXX/temp/temp.param/p4.cpp @@ -0,0 +1,20 @@ +// RUN: clang-cc -fsyntax-only -verify %s +class X; + +// C++ [temp.param]p4 +typedef int INT; +enum E { enum1, enum2 }; +template<int N> struct A1; +template<INT N, INT M> struct A2; +template<enum E x, E y> struct A3; +template<int &X> struct A4; +template<int *Ptr> struct A5; +template<int (&f)(int, int)> struct A6; +template<int (*fp)(float, double)> struct A7; +template<int X::*pm> struct A8; +template<float (X::*pmf)(float, int)> struct A9; +template<typename T, T x> struct A10; + +template<float f> struct A11; // expected-error{{a non-type template parameter cannot have type 'float'}} + +template<void *Ptr> struct A12; // expected-error{{a non-type template parameter cannot have type 'void *'}} diff --git a/test/CXX/temp/temp.param/p7.cpp b/test/CXX/temp/temp.param/p7.cpp new file mode 100644 index 000000000000..ccc869ae0fbe --- /dev/null +++ b/test/CXX/temp/temp.param/p7.cpp @@ -0,0 +1,15 @@ +// RUN: clang-cc -fsyntax-only -verify %s + +// A non-type template-parameter shall not be declared to have +// floating point, class, or void type. +struct A; + +template<double d> class X; // expected-error{{cannot have type}} +template<double* pd> class Y; //OK +template<double& rd> class Z; //OK + +template<A a> class X0; // expected-error{{cannot have type}} + +typedef void VOID; +template<VOID a> class X01; // expected-error{{cannot have type}} + diff --git a/test/CXX/temp/temp.param/p8.cpp b/test/CXX/temp/temp.param/p8.cpp new file mode 100644 index 000000000000..dd4af17d79fa --- /dev/null +++ b/test/CXX/temp/temp.param/p8.cpp @@ -0,0 +1,6 @@ +// RUN: clang-cc -fsyntax-only -verify %s +template<int X[10]> struct A; +template<int *X> struct A; +template<int f(float, double)> struct B; +typedef float FLOAT; +template<int (*f)(FLOAT, double)> struct B; diff --git a/test/CodeGen/always_inline.c b/test/CodeGen/always_inline.c index cb32e3b62181..c12b45404d2d 100644 --- a/test/CodeGen/always_inline.c +++ b/test/CodeGen/always_inline.c @@ -1,5 +1,6 @@ // RUN: clang -emit-llvm -S -o %t %s && -// RUN: grep '@f0' %t | count 0 && +// RUN: not grep '@f0' %t && +// RUN: not grep 'call ' %t && // RUN: clang -mllvm -disable-llvm-optzns -emit-llvm -S -o %t %s && // RUN: grep '@f0' %t | count 2 @@ -11,3 +12,9 @@ static int __attribute__((always_inline)) f0() { int f1() { return f0(); } + +// PR4372 +inline int f2() __attribute__((always_inline)); +int f2() { return 7; } +int f3(void) { return f2(); } + diff --git a/test/CodeGen/lineno-dbginfo.c b/test/CodeGen/lineno-dbginfo.c index fe9e59ac2d70..12c32ce9dd4b 100644 --- a/test/CodeGen/lineno-dbginfo.c +++ b/test/CodeGen/lineno-dbginfo.c @@ -1,5 +1,6 @@ -// RUN: echo "#include <stdio.h>" > %t.h -// RUN: clang -S -save-temps -g -include %t.h %s -emit-llvm -o %t.ll -// RUN: grep "i32 5" %t.ll +// RUN: echo "#include <stdio.h>" > %t.h && +// RUN: clang -S -save-temps -g -include %t.h %s -emit-llvm -o %t.ll && +// RUN: grep "i32 5" %t.ll && +// RUN: rm -f lineno-dbginfo.i // outer is at line number 5. int outer = 42; diff --git a/test/CodeGen/target-data.c b/test/CodeGen/target-data.c new file mode 100644 index 000000000000..9d73d5c6300d --- /dev/null +++ b/test/CodeGen/target-data.c @@ -0,0 +1,7 @@ +// RUN: clang-cc -triple i686-unknown-unknown -emit-llvm -o %t %s && +// RUN: grep 'target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:32:32"' %t && +// RUN: clang-cc -triple i686-apple-darwin9 -emit-llvm -o %t %s && +// RUN: grep 'target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"' %t && +// RUN: clang-cc -triple x86_64-unknown-unknown -emit-llvm -o %t %s && +// RUN: grep 'target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128"' %t && +// RUN: true diff --git a/test/CodeGen/x86_32-arguments.c b/test/CodeGen/x86_32-arguments.c index 8980c66b2072..43a3ab246c71 100644 --- a/test/CodeGen/x86_32-arguments.c +++ b/test/CodeGen/x86_32-arguments.c @@ -154,4 +154,9 @@ struct s37 { float c[1][1]; } f37(void) {} // RUN: grep 'define void @f38(.struct.s38. noalias sret .agg.result)' %t && struct s38 { char a[3]; short b; } f38(void) {} +// RUN: grep 'define void @f39(.struct.s39. byval align 16 .x)' %t && +typedef int v39 __attribute((vector_size(16))); +struct s39 { v39 x; }; +void f39(struct s39 x) {} + // RUN: true diff --git a/test/CodeGenCXX/static-assert.cpp b/test/CodeGenCXX/static-assert.cpp new file mode 100644 index 000000000000..7757acd83887 --- /dev/null +++ b/test/CodeGenCXX/static-assert.cpp @@ -0,0 +1,3 @@ +// RUN: clang-cc %s -emit-llvm -o - -std=c++0x + +static_assert(true, ""); diff --git a/test/CodeGenObjC/property-complex.m b/test/CodeGenObjC/property-complex.m new file mode 100644 index 000000000000..2e23ca410559 --- /dev/null +++ b/test/CodeGenObjC/property-complex.m @@ -0,0 +1,61 @@ +// RUN: clang-cc -triple i386-apple-darwin9 -emit-llvm -S -o - %s && +// RUN: clang-cc -triple x86_64-apple-darwin9 -emit-llvm -S -o - %s + +@interface I0 { +@public + _Complex float iv0; +} + +@property(assign) _Complex float p0; + +-(_Complex float) im0; +-(void) setIm0: (_Complex float) a0; +@end + +@implementation I0 +@dynamic p0; + +-(id) init { + self->iv0 = 5.0 + 2.0i; + return self; +} + +-(_Complex float) im0 { + printf("im0: %.2f + %.2fi\n", __real iv0, __imag iv0); + return iv0 + (.1 + .2i); +} +-(void) setIm0: (_Complex float) a0 { + printf("setIm0: %.2f + %.2fi\n", __real a0, __imag a0); + iv0 = a0 + (.3 + .4i); +} + +-(_Complex float) p0 { + printf("p0: %.2f + %.2fi\n", __real iv0, __imag iv0); + return iv0 + (.5 + .6i); +} +-(void) setP0: (_Complex float) a0 { + printf("setP0: %.2f + %.2fi\n", __real a0, __imag a0); + iv0 = a0 + (.7 + .8i); +} +@end + +void f0(I0 *a0) { + float l0 = __real a0.im0; + float l1 = __imag a0->iv0; + _Complex float l2 = (a0.im0 = a0.im0); + _Complex float l3 = a0->iv0; + _Complex float l4 = (a0->iv0 = a0->iv0); + _Complex float l5 = a0->iv0; + _Complex float l6 = (a0.p0 = a0.p0); + _Complex float l7 = a0->iv0; + _Complex float l8 = [a0 im0]; + printf("l0: %.2f + %.2fi\n", __real l0, __imag l0); + printf("l1: %.2f + %.2fi\n", __real l1, __imag l1); + printf("l2: %.2f + %.2fi\n", __real l2, __imag l2); + printf("l3: %.2f + %.2fi\n", __real l3, __imag l3); + printf("l4: %.2f + %.2fi\n", __real l4, __imag l4); + printf("l5: %.2f + %.2fi\n", __real l5, __imag l5); + printf("l6: %.2f + %.2fi\n", __real l6, __imag l6); + printf("l7: %.2f + %.2fi\n", __real l7, __imag l7); + printf("l8: %.2f + %.2fi\n", __real l8, __imag l8); +} diff --git a/test/Driver/clang_f_opts.c b/test/Driver/clang_f_opts.c index 9dc8f63db8de..8266f7762398 100644 --- a/test/Driver/clang_f_opts.c +++ b/test/Driver/clang_f_opts.c @@ -2,9 +2,10 @@ // RUN: grep -F '"-fblocks"' %t && // RUN: grep -F '"--fmath-errno=1"' %t && // RUN: grep -F '"-fpascal-strings"' %t && -// RUN: clang -### -S -x c /dev/null -fblocks -fbuiltin -fmath-errno -fcommon -fpascal-strings -fno-blocks -fno-builtin -fno-math-errno -fno-common -fno-pascal-strings %s 2> %t && +// RUN: clang -### -S -x c /dev/null -fblocks -fbuiltin -fmath-errno -fcommon -fpascal-strings -fno-blocks -fno-builtin -fno-math-errno -fno-common -fno-pascal-strings -fno-show-source-location %s 2> %t && // RUN: grep -F '"-fblocks=0"' %t && // RUN: grep -F '"-fbuiltin=0"' %t && // RUN: grep -F '"-fno-common"' %t && // RUN: grep -F '"--fmath-errno=0"' %t && +// RUN: grep -F '"-fno-show-source-location"' %t && // RUN: true diff --git a/test/Frontend/cpp-output.c b/test/Frontend/cpp-output.c new file mode 100644 index 000000000000..ee37f4cd6853 --- /dev/null +++ b/test/Frontend/cpp-output.c @@ -0,0 +1,15 @@ +// RUN: clang -E -o %t -C %s && +// RUN: grep '^int x; // comment' %t && +// RUN: grep '^x x' %t && +// RUN: clang -E -o %t -CC %s && +// RUN: grep '^int x; // comment' %t && +// RUN: grep '^x /\* comment \*/ x /\* comment \*/' %t && +// RUN: true + +int x; // comment + +#define A(foo, bar) foo bar +#define B x // comment + +A(B, B) + diff --git a/test/Lexer/char-escapes.c b/test/Lexer/char-escapes.c new file mode 100644 index 000000000000..ef665fe84a5b --- /dev/null +++ b/test/Lexer/char-escapes.c @@ -0,0 +1,21 @@ +// RUN: clang-cc -fsyntax-only -pedantic -verify %s + +int test['\\' == 92 ? 1 : -1]; +int test['\"' == 34 ? 1 : -1]; +int test['\'' == 39 ? 1 : -1]; +int test['\?' == 63 ? 1 : -1]; +int test['\a' == 7 ? 1 : -1]; +int test['\b' == 8 ? 1 : -1]; +int test['\e' == 27 ? 1 : -1]; // expected-warning {{non-standard escape}} +int test['\E' == 27 ? 1 : -1]; // expected-warning {{non-standard escape}} +int test['\f' == 12 ? 1 : -1]; +int test['\n' == 10 ? 1 : -1]; +int test['\r' == 13 ? 1 : -1]; +int test['\t' == 9 ? 1 : -1]; +int test['\v' == 11 ? 1 : -1]; +int test['\xa' == 10 ? 1 : -1]; +int test['\1' == 1 ? 1 : -1]; +int test['\(' == 40 ? 1 : -1]; // expected-warning {{non-standard escape}} +int test['\{' == 123 ? 1 : -1]; // expected-warning {{non-standard escape}} +int test['\[' == 91 ? 1 : -1]; // expected-warning {{non-standard escape}} +int test['\%' == 37 ? 1 : -1]; // expected-warning {{non-standard escape}} diff --git a/test/Makefile b/test/Makefile index 1ebaedd6b7da..271f46fdd6dc 100644 --- a/test/Makefile +++ b/test/Makefile @@ -4,42 +4,17 @@ include $(LEVEL)/Makefile.common # Test in all immediate subdirectories if unset. TESTDIRS ?= $(shell echo $(PROJ_SRC_DIR)/*/) -# Only run rewriter tests on darwin. -ifeq ($(OS),Darwin) -TESTDIRS += -endif - +ifndef TESTARGS ifdef VERBOSE -ifeq ($(VERBOSE),0) -PROGRESS = : -REPORTFAIL = echo 'FAIL: clang' $(TARGET_TRIPLE) $(subst $(LLVM_SRC_ROOT)/tools/clang/,,$<) -DONE = $(LLVMToolDir)/clang -v +TESTARGS = -v else -PROGRESS = echo $< -REPORTFAIL = cat $@ -DONE = true +TESTARGS = -s endif -else -PROGRESS = printf '.' -REPORTFAIL = (echo; echo '----' $< 'failed ----') -DONE = echo endif -TESTS := $(addprefix Output/, $(addsuffix .testresults, $(shell find $(TESTDIRS) \( -name '*.c' -or -name '*.cpp' -or -name '*.m' -or -name '*.mm' -or -name '*.S' \) | grep -v "Output/"))) -Output/%.testresults: % - @ $(PROGRESS) - @ PATH=$(ToolDir):$(LLVM_SRC_ROOT)/test/Scripts:$$PATH VG=$(VG) $(PROJ_SRC_DIR)/TestRunner.sh $< > $@ || $(REPORTFAIL) - all:: - @ mkdir -p $(addprefix Output/, $(TESTDIRS)) - @ rm -f $(TESTS) @ echo '--- Running clang tests for $(TARGET_TRIPLE) ---' - @ $(MAKE) $(TESTS) - @ $(DONE) - @ !(cat $(TESTS) | grep -q " FAILED! ") - -report: $(TESTS) - @ cat $^ + @ PATH=$(ToolDir):$(LLVM_SRC_ROOT)/test/Scripts:$$PATH VG=$(VG) ../utils/test/MultiTestRunner.py $(TESTARGS) $(TESTDIRS) clean:: @ rm -rf Output/ diff --git a/test/Parser/statements.c b/test/Parser/statements.c index c5923bc0641b..b95c23fb28b0 100644 --- a/test/Parser/statements.c +++ b/test/Parser/statements.c @@ -54,3 +54,6 @@ void test6(void) { while (0); } +int test7() { + return 4 // expected-error {{expected ';' after return statement}} +} diff --git a/test/Preprocessor/feature_tests.c b/test/Preprocessor/feature_tests.c new file mode 100644 index 000000000000..9a29ab96c93e --- /dev/null +++ b/test/Preprocessor/feature_tests.c @@ -0,0 +1,31 @@ +// RUN: clang-cc %s --triple=i686-apple-darwin9 && +// RUN: clang-cc %s -E --triple=i686-apple-darwin9 +#ifndef __has_feature +#error Should have __has_feature +#endif + + +#if __has_feature(something_we_dont_have) +#error Bad +#endif + +#if !__has_builtin(__builtin_huge_val) || \ + !__has_builtin(__builtin_shufflevector) || \ + !__has_builtin(__builtin_trap) || \ + !__has_feature(attribute_analyzer_noreturn) || \ + !__has_feature(attribute_overloadable) +#error Clang should have these +#endif + +#if __has_builtin(__builtin_insanity) +#error Clang should not have this +#endif + + + +// Make sure we have x86 builtins only (forced with target triple). + +#if !__has_builtin(__builtin_ia32_emms) || \ + __has_builtin(__builtin_altivec_abs_v4sf) +#error Broken handling of target-specific builtins +#endif diff --git a/test/Sema/const-eval.c b/test/Sema/const-eval.c index 971986b2d3af..72db14c82053 100644 --- a/test/Sema/const-eval.c +++ b/test/Sema/const-eval.c @@ -66,3 +66,5 @@ EVAL_EXPR(30, (int)(_Complex float)((1<<30)-1) == (1<<30) ? 1 : -1) EVAL_EXPR(31, (int*)0 == (int*)0 ? 1 : -1) EVAL_EXPR(32, (int*)0 != (int*)0 ? -1 : 1) EVAL_EXPR(33, (void*)0 - (void*)0 == 0 ? 1 : -1) +void foo(void) {} +EVAL_EXPR(34, (foo == (void *)0) ? -1 : 1) diff --git a/test/Sema/init-vector.c b/test/Sema/init-vector.c new file mode 100644 index 000000000000..691ea97268fd --- /dev/null +++ b/test/Sema/init-vector.c @@ -0,0 +1,17 @@ +// RUN: clang-cc -fsyntax-only -verify %s + +typedef float __attribute__((vector_size (16))) v4f_t; + +typedef union { + struct { + float x, y, z, w; + }s; + v4f_t v; +} vector_t; + + +vector_t foo(v4f_t p) +{ + vector_t v = {.v = p}; + return v; +} diff --git a/test/SemaCXX/default2.cpp b/test/SemaCXX/default2.cpp index f99e45415dc4..edbd6b3e206a 100644 --- a/test/SemaCXX/default2.cpp +++ b/test/SemaCXX/default2.cpp @@ -115,9 +115,15 @@ void test_Z(const Z& z) { } struct ZZ { - void f(ZZ z = g()); // expected-error{{no matching constructor for initialization}} - static ZZ g(int = 17); + void f(ZZ z = g()); // expected-error{{no matching constructor for initialization}} + ZZ(ZZ&, int = 17); // expected-note{{candidate function}} }; + +// http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#325 +class C2 { + static void g(int = f()); // expected-error{{use of default argument to function 'f' that is declared later in class 'C2'}} + static int f(int = 10); // expected-note{{default argument declared here}} +}; diff --git a/test/SemaCXX/member-pointer.cpp b/test/SemaCXX/member-pointer.cpp index cfe4f75dd17d..d2df5eb317a0 100644 --- a/test/SemaCXX/member-pointer.cpp +++ b/test/SemaCXX/member-pointer.cpp @@ -12,7 +12,8 @@ int A::*pdi1; int (::A::*pdi2); int (A::*pfi)(int); -int B::*pbi; // expected-error {{expected a class or namespace}} +int B::*pbi; // expected-error {{expected a class or namespace}} \ + // expected-error{{does not point into a class}} int C::*pci; // expected-error {{'pci' does not point into a class}} void A::*pdv; // expected-error {{'pdv' declared as a member pointer to void}} int& A::*pdr; // expected-error {{'pdr' declared as a pointer to a reference}} diff --git a/test/SemaTemplate/default-arguments.cpp b/test/SemaTemplate/default-arguments.cpp index 5b6ab7d1552c..f9bb44ecb9c0 100644 --- a/test/SemaTemplate/default-arguments.cpp +++ b/test/SemaTemplate/default-arguments.cpp @@ -13,3 +13,12 @@ X<> *x4; template<typename T = int> struct Z { }; template struct Z<>; + +// PR4362 +template<class T> struct a { }; +template<> struct a<int> { static const bool v = true; }; + +template<class T, bool = a<T>::v> struct p { }; // expected-error {{no member named 'v'}} + +template struct p<bool>; // expected-note {{in instantiation of default argument for 'p<bool>' required here}} +template struct p<int>; diff --git a/test/SemaTemplate/dependent-names.cpp b/test/SemaTemplate/dependent-names.cpp new file mode 100644 index 000000000000..95ee2d2b9d1f --- /dev/null +++ b/test/SemaTemplate/dependent-names.cpp @@ -0,0 +1,16 @@ +// RUN: clang-cc -fsyntax-only -verify %s + +typedef double A; +template<typename T> class B { + typedef int A; +}; + +template<typename T> struct X : B<T> { + static A a; +}; + +int a0[sizeof(X<int>::a) == sizeof(double) ? 1 : -1]; + +// PR4365. +template<class T> class Q; +template<class T> class R : Q<T> {T current;}; diff --git a/test/SemaTemplate/example-typelist.cpp b/test/SemaTemplate/example-typelist.cpp new file mode 100644 index 000000000000..4a2aeb20e730 --- /dev/null +++ b/test/SemaTemplate/example-typelist.cpp @@ -0,0 +1,98 @@ +// RUN: clang-cc -fsyntax-only -verify %s + +// A simple cons-style typelist +struct nil { }; + +template<typename Head, typename Tail = nil> +struct cons { + typedef Head head; + typedef Tail tail; +}; + +// is_same trait, for testing +template<typename T, typename U> +struct is_same { + static const bool value = false; +}; + +template<typename T> +struct is_same<T, T> { + static const bool value = true; +}; + +// metaprogram that computes the length of a list +template<typename T> struct length; + +template<typename Head, typename Tail> +struct length<cons<Head, Tail> > { + static const unsigned value = length<Tail>::value + 1; +}; + +template<> +struct length<nil> { + static const unsigned value = 0; +}; + +typedef cons<unsigned char, + cons<unsigned short, + cons<unsigned int, + cons<unsigned long> > > > unsigned_inttypes; +int length0[length<unsigned_inttypes>::value == 4? 1 : -1]; + +// metaprogram that reverses a list + +// FIXME: I would prefer that this be a partial specialization, but +// that requires partial ordering of class template partial +// specializations. +template<typename T> +class reverse { + typedef typename reverse<typename T::tail>::type reversed_tail; + + typedef typename reverse<typename reversed_tail::tail>::type most_of_tail; + +public: + typedef cons<typename reversed_tail::head, + typename reverse<cons<typename T::head, most_of_tail> >::type> type; +}; + +template<typename Head> +class reverse<cons<Head> > { +public: + typedef cons<Head> type; +}; + +template<> +class reverse<nil> { +public: + typedef nil type; +}; + +int reverse0[is_same<reverse<unsigned_inttypes>::type, + cons<unsigned long, + cons<unsigned int, + cons<unsigned short, + cons<unsigned char> > > > >::value? 1 : -1]; + +// metaprogram that finds a type within a list + +// FIXME: I would prefer that this be a partial specialization, but +// that requires partial ordering of class template partial +// specializations. +template<typename List, typename T> +struct find : find<typename List::tail, T> { }; + +template<typename Tail, typename T> +struct find<cons<T, Tail>, T> { + typedef cons<T, Tail> type; +}; + +template<typename T> +struct find<nil, T> { + typedef nil type; +}; + +int find0[is_same<find<unsigned_inttypes, unsigned int>::type, + cons<unsigned int, cons<unsigned long> > >::value? + 1 : -1]; +int find1[is_same<find<unsigned_inttypes, int>::type, nil>::value? 1 : -1]; + diff --git a/test/SemaTemplate/instantiate-declref-ice.cpp b/test/SemaTemplate/instantiate-declref-ice.cpp new file mode 100644 index 000000000000..21ee87202797 --- /dev/null +++ b/test/SemaTemplate/instantiate-declref-ice.cpp @@ -0,0 +1,7 @@ +// RUN: clang-cc -fsyntax-only -verify %s + +template<int i> struct x { + static const int j = i; + x<j>* y; +}; + diff --git a/test/SemaTemplate/instantiate-dependent-nested-name.cpp b/test/SemaTemplate/instantiate-dependent-nested-name.cpp new file mode 100644 index 000000000000..2b1d29878a54 --- /dev/null +++ b/test/SemaTemplate/instantiate-dependent-nested-name.cpp @@ -0,0 +1,7 @@ +// RUN: clang-cc -fsyntax-only -verify %s +// PR4382 +template<typename T> struct X { static const T A = 1; }; +template<typename T, bool = X<T>::A> struct Y { typedef T A; }; +template<typename T> struct Z { typedef typename Y<T>::A A; }; +extern int x; +extern Z<int>::A x; diff --git a/test/SemaTemplate/instantiate-function-1.cpp b/test/SemaTemplate/instantiate-function-1.cpp index 5b3a6d998404..023cc5437f69 100644 --- a/test/SemaTemplate/instantiate-function-1.cpp +++ b/test/SemaTemplate/instantiate-function-1.cpp @@ -140,7 +140,7 @@ template<typename T> struct Member0 { tp->f; this->f; - this.f; // expected-error{{member reference base type 'struct Member0 *const' is not a structure or union}} + this.f; // expected-error{{member reference base type 'Member0<T> *const' is not a structure or union}} } }; @@ -209,3 +209,9 @@ struct Abstract { template struct TryCatch0<int>; // okay template struct TryCatch0<Incomplete*>; // expected-note{{instantiation}} template struct TryCatch0<Abstract>; // expected-note{{instantiation}} + +// PR4383 +template<typename T> struct X; +template<typename T> struct Y : public X<T> { + Y& x() { return *this; } +}; diff --git a/test/SemaTemplate/instantiate-member-pointers.cpp b/test/SemaTemplate/instantiate-member-pointers.cpp new file mode 100644 index 000000000000..b3ddb3fafa31 --- /dev/null +++ b/test/SemaTemplate/instantiate-member-pointers.cpp @@ -0,0 +1,27 @@ +// RUN: clang-cc -fsyntax-only -verify %s + +struct Y { + int x; +}; + +template<typename T> +struct X1 { + int f(T* ptr, int T::*pm) { // expected-error{{member pointer}} + return ptr->*pm; + } +}; + +template struct X1<Y>; +template struct X1<int>; // expected-note{{instantiation}} + +template<typename T, typename Class> +struct X2 { + T f(Class &obj, T Class::*pm) { // expected-error{{to a reference}} \ + // expected-error{{member pointer to void}} + return obj.*pm; + } +}; + +template struct X2<int, Y>; +template struct X2<int&, Y>; // expected-note{{instantiation}} +template struct X2<const void, Y>; // expected-note{{instantiation}} diff --git a/test/SemaTemplate/metafun-apply.cpp b/test/SemaTemplate/metafun-apply.cpp index 7bc971f24b59..9261ed6a6c96 100644 --- a/test/SemaTemplate/metafun-apply.cpp +++ b/test/SemaTemplate/metafun-apply.cpp @@ -23,8 +23,7 @@ struct bogus { template<typename MetaFun, typename T> struct apply1 { typedef typename MetaFun::template apply<T>::type type; // expected-note{{in instantiation of template class 'struct add_reference::apply<void>' requested here}} \ - // expected-error{{'apply' following the 'template' keyword does not refer to a template}} \ - // FIXME: expected-error{{type 'MetaFun::template apply<int>' cannot be used prior to '::' because it has no members}} + // expected-error{{'apply' following the 'template' keyword does not refer to a template}} }; int i; @@ -36,8 +35,7 @@ void test() { apply1<add_reference, void>::type t; // expected-note{{in instantiation of template class 'struct apply1<struct add_reference, void>' requested here}} \ // FIXME: expected-error{{unexpected type name 'type': expected expression}} - apply1<bogus, int>::type t2; // expected-note{{in instantiation of template class 'struct apply1<struct bogus, int>' requested here}} \ - // FIXME: expected-error{{unexpected type name 'type': expected expression}} + apply1<bogus, int>::type t2; // expected-note{{in instantiation of template class 'struct apply1<struct bogus, int>' requested here}} } diff --git a/test/SemaTemplate/temp_class_spec.cpp b/test/SemaTemplate/temp_class_spec.cpp index 4e4f5560aef3..1a534236c8eb 100644 --- a/test/SemaTemplate/temp_class_spec.cpp +++ b/test/SemaTemplate/temp_class_spec.cpp @@ -134,3 +134,130 @@ int is_unary_function6[is_unary_function_with_same_return_type_as_argument_type< int is_unary_function7[is_unary_function_with_same_return_type_as_argument_type<int (*)(int, bool)>::value ? -1 : 1]; int is_unary_function8[is_unary_function_with_same_return_type_as_argument_type<int (*)(bool)>::value ? -1 : 1]; int is_unary_function9[is_unary_function_with_same_return_type_as_argument_type<int (*)(int)>::value ? 1 : -1]; +int is_unary_function10[is_unary_function_with_same_return_type_as_argument_type<int (*)(int, ...)>::value ? -1 : 1]; +int is_unary_function11[is_unary_function_with_same_return_type_as_argument_type<int (* const)(int)>::value ? -1 : 1]; + +template<typename T> +struct is_binary_function { + static const bool value = false; +}; + +template<typename R, typename T1, typename T2> +struct is_binary_function<R(T1, T2)> { + static const bool value = true; +}; + +int is_binary_function0[is_binary_function<int(float, double)>::value? 1 : -1]; + +template<typename T> +struct is_member_pointer { + static const bool value = false; +}; + +template<typename T, typename Class> +struct is_member_pointer<T Class::*> { + static const bool value = true; +}; + +struct X { }; + +int is_member_pointer0[is_member_pointer<int X::*>::value? 1 : -1]; +int is_member_pointer1[is_member_pointer<const int X::*>::value? 1 : -1]; +int is_member_pointer2[is_member_pointer<int (X::*)()>::value? 1 : -1]; +int is_member_pointer3[is_member_pointer<int (X::*)(int) const>::value? 1 : -1]; +int is_member_pointer4[is_member_pointer<int (X::**)(int) const>::value? -1 : 1]; +int is_member_pointer5[is_member_pointer<int>::value? -1 : 1]; + +template<typename T> +struct is_member_function_pointer { + static const bool value = false; +}; + +template<typename T, typename Class> +struct is_member_function_pointer<T (Class::*)()> { + static const bool value = true; +}; + +template<typename T, typename Class> +struct is_member_function_pointer<T (Class::*)() const> { + static const bool value = true; +}; + +template<typename T, typename Class> +struct is_member_function_pointer<T (Class::*)() volatile> { + static const bool value = true; +}; + +template<typename T, typename Class> +struct is_member_function_pointer<T (Class::*)() const volatile> { + static const bool value = true; +}; + +template<typename T, typename Class, typename A1> +struct is_member_function_pointer<T (Class::*)(A1)> { + static const bool value = true; +}; + +template<typename T, typename Class, typename A1> +struct is_member_function_pointer<T (Class::*)(A1) const> { + static const bool value = true; +}; + +template<typename T, typename Class, typename A1> +struct is_member_function_pointer<T (Class::*)(A1) volatile> { + static const bool value = true; +}; + +template<typename T, typename Class, typename A1> +struct is_member_function_pointer<T (Class::*)(A1) const volatile> { + static const bool value = true; +}; + +int is_member_function_pointer0[ + is_member_function_pointer<int X::*>::value? -1 : 1]; +int is_member_function_pointer1[ + is_member_function_pointer<int (X::*)()>::value? 1 : -1]; +int is_member_function_pointer2[ + is_member_function_pointer<X (X::*)(X&)>::value? 1 : -1]; +int is_member_function_pointer3[ + is_member_function_pointer<int (X::*)() const>::value? 1 : -1]; +int is_member_function_pointer4[ + is_member_function_pointer<int (X::*)(float) const>::value? 1 : -1]; + +// Test substitution of non-dependent arguments back into the template +// argument list of the class template partial specialization. +template<typename T, typename ValueType = T> +struct is_nested_value_type_identity { + static const bool value = false; +}; + +template<typename T> +struct is_nested_value_type_identity<T, typename T::value_type> { + static const bool value = true; +}; + +template<typename T> +struct HasValueType { + typedef T value_type; +}; + +struct HasIdentityValueType { + typedef HasIdentityValueType value_type; +}; + +struct NoValueType { }; + +int is_nested_value_type_identity0[ + is_nested_value_type_identity<HasValueType<int> >::value? -1 : 1]; +int is_nested_value_type_identity1[ + is_nested_value_type_identity<HasIdentityValueType>::value? 1 : -1]; +int is_nested_value_type_identity2[ + is_nested_value_type_identity<NoValueType>::value? -1 : 1]; + + +// C++ [temp.class.spec]p4: +template<class T1, class T2, int I> class A { }; //#1 +template<class T, int I> class A<T, T*, I> { }; //#2 +template<class T1, class T2, int I> class A<T1*, T2, I> { }; //#3 +template<class T> class A<int, T*, 5> { }; //#4 +template<class T1, class T2, int I> class A<T1, T2*, I> { }; //#5 diff --git a/test/SemaTemplate/temp_class_spec_blocks.cpp b/test/SemaTemplate/temp_class_spec_blocks.cpp new file mode 100644 index 000000000000..920d9c8b0cbd --- /dev/null +++ b/test/SemaTemplate/temp_class_spec_blocks.cpp @@ -0,0 +1,34 @@ +// RUN: clang-cc -fsyntax-only -verify %s -fblocks +template<typename T> +struct is_unary_block { + static const bool value = false; +}; + +template<typename T, typename U> +struct is_unary_block<T (^)(U)> { + static const bool value = true; +}; + +int is_unary_block0[is_unary_block<int>::value ? -1 : 1]; +int is_unary_block1[is_unary_block<int (^)()>::value ? -1 : 1]; +int is_unary_block2[is_unary_block<int (^)(int, bool)>::value ? -1 : 1]; +int is_unary_block3[is_unary_block<int (^)(bool)>::value ? 1 : -1]; +int is_unary_block4[is_unary_block<int (^)(int)>::value ? 1 : -1]; + +template<typename T> +struct is_unary_block_with_same_return_type_as_argument_type { + static const bool value = false; +}; + +template<typename T> +struct is_unary_block_with_same_return_type_as_argument_type<T (^)(T)> { + static const bool value = true; +}; + +int is_unary_block5[is_unary_block_with_same_return_type_as_argument_type<int>::value ? -1 : 1]; +int is_unary_block6[is_unary_block_with_same_return_type_as_argument_type<int (^)()>::value ? -1 : 1]; +int is_unary_block7[is_unary_block_with_same_return_type_as_argument_type<int (^)(int, bool)>::value ? -1 : 1]; +int is_unary_block8[is_unary_block_with_same_return_type_as_argument_type<int (^)(bool)>::value ? -1 : 1]; +int is_unary_block9[is_unary_block_with_same_return_type_as_argument_type<int (^)(int)>::value ? 1 : -1]; +int is_unary_block10[is_unary_block_with_same_return_type_as_argument_type<int (^)(int, ...)>::value ? -1 : 1]; +int is_unary_block11[is_unary_block_with_same_return_type_as_argument_type<int (^ const)(int)>::value ? -1 : 1]; diff --git a/test/SemaTemplate/temp_class_spec_neg.cpp b/test/SemaTemplate/temp_class_spec_neg.cpp new file mode 100644 index 000000000000..b50bd8f634aa --- /dev/null +++ b/test/SemaTemplate/temp_class_spec_neg.cpp @@ -0,0 +1,45 @@ +// RUN: clang-cc -fsyntax-only -verify %s +template<typename T> struct vector; + +// C++ [temp.class.spec]p6: +namespace N { + namespace M { + template<typename T> struct A; // expected-note{{here}} + } +} + +template<typename T> +struct N::M::A<T*> { }; // expected-error{{not in namespace}} + +// C++ [temp.class.spec]p9 +// bullet 1 +template <int I, int J> struct A {}; +template <int I> struct A<I+5, I*2> {}; // expected-error{{depends on}} +template <int I, int J> struct B {}; +template <int I> struct B<I, I> {}; //OK + +// bullet 2 +template <class T, T t> struct C {}; // expected-note{{declared here}} +template <class T> struct C<T, 1>; // expected-error{{specializes}} +template <class T, T* t> struct C<T*, t>; // okay + +template< int X, int (*array_ptr)[X] > class A2 {}; // expected-note{{here}} +int array[5]; +template< int X > class A2<X,&array> { }; // expected-error{{specializes}} + +template<typename T, int N, template<typename X> class TT> +struct Test0; + +// bullet 3 +template<typename T, int N, template<typename X> class TT> +struct Test0<T, N, TT>; // expected-error{{does not specialize}} + +// C++ [temp.class.spec]p10 +template<typename T = int, // expected-error{{default template argument}} + int N = 17, // expected-error{{default template argument}} + template<typename X> class TT = ::vector> // expected-error{{default template argument}} + struct Test0<T*, N, TT> { }; + +template<typename T> struct Test1; +template<typename T, typename U> // expected-note{{non-deducible}} + struct Test1<T*> { }; // expected-warning{{never be used}} diff --git a/test/SemaTemplate/temp_param.cpp b/test/SemaTemplate/temp_param.cpp deleted file mode 100644 index c042f0849a04..000000000000 --- a/test/SemaTemplate/temp_param.cpp +++ /dev/null @@ -1,90 +0,0 @@ -// RUN: clang-cc -fsyntax-only -verify %s - -class X; - -// C++ [temp.param]p4 -typedef int INT; -enum E { enum1, enum2 }; -template<int N> struct A1; -template<INT N, INT M> struct A2; -template<enum E x, E y> struct A3; -template<int &X> struct A4; -template<int *Ptr> struct A5; -template<int (&f)(int, int)> struct A6; -template<int (*fp)(float, double)> struct A7; -template<int X::*pm> struct A8; -template<float (X::*pmf)(float, int)> struct A9; -template<typename T, T x> struct A10; - -template<float f> struct A11; // expected-error{{a non-type template parameter cannot have type 'float'}} - -template<void *Ptr> struct A12; // expected-error{{a non-type template parameter cannot have type 'void *'}} - -// C++ [temp.param]p8 -template<int X[10]> struct A5; -template<int f(float, double)> struct A7; - -// C++ [temp.param]p11: -template<typename> struct Y1; // expected-note{{too few template parameters in template template argument}} -template<typename, int> struct Y2; - -template<class T1 = int, // expected-note{{previous default template argument defined here}} - class T2> // expected-error{{template parameter missing a default argument}} - class B1; - -template<template<class> class = Y1, // expected-note{{previous default template argument defined here}} - template<class> class> // expected-error{{template parameter missing a default argument}} - class B1t; - -template<int N = 5, // expected-note{{previous default template argument defined here}} - int M> // expected-error{{template parameter missing a default argument}} - class B1n; - -// Check for bogus template parameter shadow warning. -template<template<class T> class, - template<class T> class> - class B1noshadow; - -// C++ [temp.param]p10: -template<class T1, class T2 = int> class B2; -template<class T1 = int, class T2> class B2; - -template<template<class, int> class, template<class> class = Y1> class B2t; -template<template<class, int> class = Y2, template<class> class> class B2t; - -template<int N, int M = 5> class B2n; -template<int N = 5, int M> class B2n; - -// C++ [temp.param]p12: -template<class T1, - class T2 = int> // expected-note{{previous default template argument defined here}} - class B3; -template<class T1, typename T2> class B3; -template<class T1, - typename T2 = float> // expected-error{{template parameter redefines default argument}} - class B3; - -template<template<class, int> class, - template<class> class = Y1> // expected-note{{previous default template argument defined here}} - class B3t; - -template<template<class, int> class, template<class> class> class B3t; - -template<template<class, int> class, - template<class> class = Y1> // expected-error{{template parameter redefines default argument}} - class B3t; - -template<int N, - int M = 5> // expected-note{{previous default template argument defined here}} - class B3n; - -template<int N, int M> class B3n; - -template<int N, - int M = 7> // expected-error{{template parameter redefines default argument}} - class B3n; - -// Check validity of default arguments -template<template<class, int> class // expected-note{{previous template template parameter is here}} - = Y1> // expected-error{{template template argument has different template parameters than its corresponding template template parameter}} - class C1; diff --git a/test/SemaTemplate/typename-specifier-3.cpp b/test/SemaTemplate/typename-specifier-3.cpp new file mode 100644 index 000000000000..8dde6095e533 --- /dev/null +++ b/test/SemaTemplate/typename-specifier-3.cpp @@ -0,0 +1,19 @@ +// RUN: clang-cc -fsyntax-only -verify %s + +// PR4364 +template<class T> struct a { + T b() { + return typename T::x(); + } +}; +struct B { + typedef B x; +}; +B c() { + a<B> x; + return x.b(); +} + +// Some extra tests for invalid cases +template<class T> struct test2 { T b() { return typename T::a; } }; // expected-error{{expected '(' for function-style cast or type construction}} +template<class T> struct test3 { T b() { return typename a; } }; // expected-error{{expected a qualified name after 'typename'}} diff --git a/test/SemaTemplate/variadic-class-template-1.cpp b/test/SemaTemplate/variadic-class-template-1.cpp new file mode 100644 index 000000000000..6df905006692 --- /dev/null +++ b/test/SemaTemplate/variadic-class-template-1.cpp @@ -0,0 +1,4 @@ +// RUN: clang-cc -fsyntax-only -verify %s -std=c++0x + +template<typename ... Args = int> struct S1 { }; // expected-error{{template parameter pack cannot have a default argument}} +template<typename ... Args, typename T> struct S2 { }; // expected-error{{template parameter pack must be the last template parameter}} diff --git a/test/SemaTemplate/variadic-class-template-2.cpp b/test/SemaTemplate/variadic-class-template-2.cpp new file mode 100644 index 000000000000..eadea901c7fe --- /dev/null +++ b/test/SemaTemplate/variadic-class-template-2.cpp @@ -0,0 +1,19 @@ +// RUN: clang-cc -fsyntax-only -verify %s -std=c++0x + +// Type parameters packs +template <typename ...> struct TS1 {}; // expected-note{{template parameter is declared here}} +template struct TS1<>; +template struct TS1<int>; +template struct TS1<int, int>; +template struct TS1<int, 10>; // expected-error{{template argument for template type parameter must be a type}} + +template <typename, typename ...> struct TS2 {}; // expected-note{{template is declared here}} +template struct TS2<>; // expected-error{{too few template arguments for class template 'TS2'}} +template struct TS2<int>; +template struct TS2<int, int>; + +template <typename = int, typename ...> struct TS3 {}; // expected-note{{template parameter is declared here}} +template struct TS3<>; // expected-note{{previous explicit instantiation is here}} +template struct TS3<int>; // expected-error{{duplicate explicit instantiation of 'TS3<>'}} +template struct TS3<int, int>; +template struct TS3<10>; // expected-error{{template argument for template type parameter must be a type}} diff --git a/test/SemaTemplate/variadic-parse.cpp b/test/SemaTemplate/variadic-parse.cpp new file mode 100644 index 000000000000..e1d1b1f98db2 --- /dev/null +++ b/test/SemaTemplate/variadic-parse.cpp @@ -0,0 +1,6 @@ +// RUN: clang-cc -fsyntax-only -verify %s -std=c++0x + +// Parsing type parameter packs. +template <typename ... Args> struct T1 {}; +template <typename ... > struct T2 {}; + diff --git a/test/SemaTemplate/variadic-unsupported.cpp b/test/SemaTemplate/variadic-unsupported.cpp new file mode 100644 index 000000000000..98f217c76891 --- /dev/null +++ b/test/SemaTemplate/variadic-unsupported.cpp @@ -0,0 +1,5 @@ +// RUN: clang-cc -fsyntax-only -verify %s + +// Type parameter packs. +template <typename ... > struct T1 {}; // expected-error{{variadic templates are only allowed in C++0x}} + diff --git a/test/cxx-sections.data b/test/cxx-sections.data new file mode 100644 index 000000000000..b4501ea286ca --- /dev/null +++ b/test/cxx-sections.data @@ -0,0 +1,1954 @@ +1 [intro] + 1.1 [intro.scope] + 1.2 [intro.refs] + 1.3 [intro.defs] + 1.3.1 [defns.argument] + 1.3.2 [defns.cond.supp] + 1.3.3 [defns.diagnostic] + 1.3.4 [defns.dynamic.type] + 1.3.5 [defns.ill.formed] + 1.3.6 [defns.impl.defined] + 1.3.7 [defns.impl.limits] + 1.3.8 [defns.locale.specific] + 1.3.9 [defns.multibyte] + 1.3.10 [defns.parameter] + 1.3.11 [defns.signature] + 1.3.12 [defns.static.type] + 1.3.13 [defns.undefined] + 1.3.14 [defns.unspecified] + 1.3.15 [defns.well.formed] + 1.4 [intro.compliance] + 1.5 [intro.structure] + 1.6 [syntax] + 1.7 [intro.memory] + 1.8 [intro.object] + 1.9 [intro.execution] + 1.10 [intro.multithread] + 1.11 [intro.ack] +2 [lex] + 2.1 [lex.phases] + 2.2 [lex.charset] + 2.3 [lex.trigraph] + 2.4 [lex.pptoken] + 2.5 [lex.digraph] + 2.6 [lex.token] + 2.7 [lex.comment] + 2.8 [lex.header] + 2.9 [lex.ppnumber] + 2.10 [lex.name] + 2.11 [lex.key] + 2.12 [lex.operators] + 2.13 [lex.literal] + 2.13.1 [lex.icon] + 2.13.2 [lex.ccon] + 2.13.3 [lex.fcon] + 2.13.4 [lex.string] + 2.13.5 [lex.bool] + 2.13.6 [lex.nullptr] + 2.13.7 [lex.ext] +3 [basic] + 3.1 [basic.def] + 3.2 [basic.def.odr] + 3.3 [basic.scope] + 3.3.1 [basic.scope.pdecl] + 3.3.2 [basic.scope.local] + 3.3.3 [basic.scope.proto] + 3.3.4 [basic.funscope] + 3.3.5 [basic.scope.namespace] + 3.3.6 [basic.scope.class] + 3.3.7 [basic.scope.concept] + 3.3.8 [basic.scope.req] + 3.3.9 [basic.scope.enum] + 3.3.10 [basic.scope.hiding] + 3.4 [basic.lookup] + 3.4.1 [basic.lookup.unqual] + 3.4.2 [basic.lookup.argdep] + 3.4.3 [basic.lookup.qual] + 3.4.3.1 [class.qual] + 3.4.3.2 [namespace.qual] + 3.4.3.3 [concept.qual] + 3.4.4 [basic.lookup.elab] + 3.4.5 [basic.lookup.classref] + 3.4.6 [basic.lookup.udir] + 3.5 [basic.link] + 3.6 [basic.start] + 3.6.1 [basic.start.main] + 3.6.2 [basic.start.init] + 3.6.3 [basic.start.term] + 3.7 [basic.stc] + 3.7.1 [basic.stc.static] + 3.7.2 [basic.stc.thread] + 3.7.3 [basic.stc.auto] + 3.7.4 [basic.stc.dynamic] + 3.7.4.1 [basic.stc.dynamic.allocation] + 3.7.4.2 [basic.stc.dynamic.deallocation] + 3.7.4.3 [basic.stc.dynamic.safety] + 3.7.5 [basic.stc.inherit] + 3.8 [basic.life] + 3.9 [basic.types] + 3.9.1 [basic.fundamental] + 3.9.2 [basic.compound] + 3.9.3 [basic.type.qualifier] + 3.10 [basic.lval] + 3.11 [basic.align] +4 [conv] + 4.1 [conv.lval] + 4.2 [conv.array] + 4.3 [conv.func] + 4.4 [conv.qual] + 4.5 [conv.prom] + 4.6 [conv.fpprom] + 4.7 [conv.integral] + 4.8 [conv.double] + 4.9 [conv.fpint] + 4.10 [conv.ptr] + 4.11 [conv.mem] + 4.12 [conv.bool] + 4.13 [conv.rank] +5 [expr] + 5.1 [expr.prim] + 5.1.1 [expr.prim.lambda] + 5.2 [expr.post] + 5.2.1 [expr.sub] + 5.2.2 [expr.call] + 5.2.3 [expr.type.conv] + 5.2.4 [expr.pseudo] + 5.2.5 [expr.ref] + 5.2.6 [expr.post.incr] + 5.2.7 [expr.dynamic.cast] + 5.2.8 [expr.typeid] + 5.2.9 [expr.static.cast] + 5.2.10 [expr.reinterpret.cast] + 5.2.11 [expr.const.cast] + 5.3 [expr.unary] + 5.3.1 [expr.unary.op] + 5.3.2 [expr.pre.incr] + 5.3.3 [expr.sizeof] + 5.3.4 [expr.new] + 5.3.5 [expr.delete] + 5.3.6 [expr.alignof] + 5.4 [expr.cast] + 5.5 [expr.mptr.oper] + 5.6 [expr.mul] + 5.7 [expr.add] + 5.8 [expr.shift] + 5.9 [expr.rel] + 5.10 [expr.eq] + 5.11 [expr.bit.and] + 5.12 [expr.xor] + 5.13 [expr.or] + 5.14 [expr.log.and] + 5.15 [expr.log.or] + 5.16 [expr.cond] + 5.17 [expr.ass] + 5.18 [expr.comma] + 5.19 [expr.const] +6 [stmt.stmt] + 6.1 [stmt.label] + 6.2 [stmt.expr] + 6.3 [stmt.block] + 6.4 [stmt.select] + 6.4.1 [stmt.if] + 6.4.2 [stmt.switch] + 6.5 [stmt.iter] + 6.5.1 [stmt.while] + 6.5.2 [stmt.do] + 6.5.3 [stmt.for] + 6.5.4 [stmt.ranged] + 6.6 [stmt.jump] + 6.6.1 [stmt.break] + 6.6.2 [stmt.cont] + 6.6.3 [stmt.return] + 6.6.4 [stmt.goto] + 6.7 [stmt.dcl] + 6.8 [stmt.ambig] + 6.9 [stmt.late] +7 [dcl.dcl] + 7.1 [dcl.spec] + 7.1.1 [dcl.stc] + 7.1.2 [dcl.fct.spec] + 7.1.3 [dcl.typedef] + 7.1.4 [dcl.friend] + 7.1.5 [dcl.constexpr] + 7.1.6 [dcl.type] + 7.1.6.1 [dcl.type.cv] + 7.1.6.2 [dcl.type.simple] + 7.1.6.3 [dcl.type.elab] + 7.1.6.4 [dcl.spec.auto] + 7.2 [dcl.enum] + 7.3 [basic.namespace] + 7.3.1 [namespace.def] + 7.3.1.1 [namespace.unnamed] + 7.3.1.2 [namespace.memdef] + 7.3.2 [namespace.alias] + 7.3.3 [namespace.udecl] + 7.3.4 [namespace.udir] + 7.4 [dcl.asm] + 7.5 [dcl.link] + 7.6 [dcl.attr] + 7.6.1 [dcl.attr.grammar] + 7.6.2 [dcl.align] + 7.6.3 [dcl.attr.noreturn] + 7.6.4 [dcl.attr.final] + 7.6.5 [dcl.attr.depend] +8 [dcl.decl] + 8.1 [dcl.name] + 8.2 [dcl.ambig.res] + 8.3 [dcl.meaning] + 8.3.1 [dcl.ptr] + 8.3.2 [dcl.ref] + 8.3.3 [dcl.mptr] + 8.3.4 [dcl.array] + 8.3.5 [dcl.fct] + 8.3.6 [dcl.fct.default] + 8.4 [dcl.fct.def] + 8.5 [dcl.init] + 8.5.1 [dcl.init.aggr] + 8.5.2 [dcl.init.string] + 8.5.3 [dcl.init.ref] + 8.5.4 [dcl.init.list] +9 [class] + 9.1 [class.name] + 9.2 [class.mem] + 9.3 [class.mfct] + 9.3.1 [class.mfct.non-static] + 9.3.2 [class.this] + 9.4 [class.static] + 9.4.1 [class.static.mfct] + 9.4.2 [class.static.data] + 9.5 [class.union] + 9.6 [class.bit] + 9.7 [class.nest] + 9.8 [class.local] + 9.9 [class.nested.type] +10 [class.derived] + 10.1 [class.mi] + 10.2 [class.member.lookup] + 10.3 [class.virtual] + 10.4 [class.abstract] +11 [class.access] + 11.1 [class.access.spec] + 11.2 [class.access.base] + 11.3 [class.access.dcl] + 11.4 [class.friend] + 11.5 [class.protected] + 11.6 [class.access.virt] + 11.7 [class.paths] + 11.8 [class.access.nest] +12 [special] + 12.1 [class.ctor] + 12.2 [class.temporary] + 12.3 [class.conv] + 12.3.1 [class.conv.ctor] + 12.3.2 [class.conv.fct] + 12.4 [class.dtor] + 12.5 [class.free] + 12.6 [class.init] + 12.6.1 [class.expl.init] + 12.6.2 [class.base.init] + 12.7 [class.cdtor] + 12.8 [class.copy] + 12.9 [class.inhctor] +13 [over] + 13.1 [over.load] + 13.2 [over.dcl] + 13.3 [over.match] + 13.3.1 [over.match.funcs] + 13.3.1.1 [over.match.call] + 13.3.1.1.1 [over.call.func] + 13.3.1.1.2 [over.call.object] + 13.3.1.2 [over.match.oper] + 13.3.1.3 [over.match.ctor] + 13.3.1.4 [over.match.copy] + 13.3.1.5 [over.match.conv] + 13.3.1.6 [over.match.ref] + 13.3.1.7 [over.match.list] + 13.3.2 [over.match.viable] + 13.3.3 [over.match.best] + 13.3.3.1 [over.best.ics] + 13.3.3.1.1 [over.ics.scs] + 13.3.3.1.2 [over.ics.user] + 13.3.3.1.3 [over.ics.ellipsis] + 13.3.3.1.4 [over.ics.ref] + 13.3.3.1.5 [over.ics.list] + 13.3.3.2 [over.ics.rank] + 13.4 [over.over] + 13.5 [over.oper] + 13.5.1 [over.unary] + 13.5.2 [over.binary] + 13.5.3 [over.ass] + 13.5.4 [over.call] + 13.5.5 [over.sub] + 13.5.6 [over.ref] + 13.5.7 [over.inc] + 13.5.8 [over.literal] + 13.6 [over.built] +14 [temp] + 14.1 [temp.param] + 14.2 [temp.names] + 14.3 [temp.arg] + 14.3.1 [temp.arg.type] + 14.3.2 [temp.arg.nontype] + 14.3.3 [temp.arg.template] + 14.4 [temp.type] + 14.5 [temp.decls] + 14.5.1 [temp.class] + 14.5.1.1 [temp.mem.func] + 14.5.1.2 [temp.mem.class] + 14.5.1.3 [temp.static] + 14.5.2 [temp.mem] + 14.5.3 [temp.variadic] + 14.5.4 [temp.friend] + 14.5.5 [temp.class.spec] + 14.5.5.1 [temp.class.spec.match] + 14.5.5.2 [temp.class.order] + 14.5.5.3 [temp.class.spec.mfunc] + 14.5.6 [temp.fct] + 14.5.6.1 [temp.over.link] + 14.5.6.2 [temp.func.order] + 14.5.7 [temp.alias] + 14.5.8 [temp.concept.map] + 14.6 [temp.res] + 14.6.1 [temp.local] + 14.6.2 [temp.dep] + 14.6.2.1 [temp.dep.type] + 14.6.2.2 [temp.dep.expr] + 14.6.2.3 [temp.dep.constexpr] + 14.6.2.4 [temp.dep.temp] + 14.6.3 [temp.nondep] + 14.6.4 [temp.dep.res] + 14.6.4.1 [temp.point] + 14.6.4.2 [temp.dep.candidate] + 14.6.5 [temp.inject] + 14.7 [temp.spec] + 14.7.1 [temp.inst] + 14.7.2 [temp.explicit] + 14.7.3 [temp.expl.spec] + 14.8 [temp.fct.spec] + 14.8.1 [temp.arg.explicit] + 14.8.2 [temp.deduct] + 14.8.2.1 [temp.deduct.call] + 14.8.2.2 [temp.deduct.funcaddr] + 14.8.2.3 [temp.deduct.conv] + 14.8.2.4 [temp.deduct.partial] + 14.8.2.5 [temp.deduct.type] + 14.8.3 [temp.over] + 14.9 [concept] + 14.9.1 [concept.def] + 14.9.1.1 [concept.fct] + 14.9.1.2 [concept.assoc] + 14.9.1.3 [concept.req] + 14.9.1.4 [concept.axiom] + 14.9.2 [concept.map] + 14.9.2.1 [concept.map.fct] + 14.9.2.2 [concept.map.assoc] + 14.9.3 [concept.refine] + 14.9.3.1 [concept.member.lookup] + 14.9.3.2 [concept.refine.maps] + 14.9.4 [concept.support] + 14.10 [temp.constrained] + 14.10.1 [temp.req] + 14.10.1.1 [temp.req.sat] + 14.10.1.2 [temp.req.impl] + 14.10.2 [temp.archetype] + 14.10.2.1 [temp.archetype.assemble] + 14.10.3 [temp.constrained.set] + 14.10.4 [temp.constrained.inst] +15 [except] + 15.1 [except.throw] + 15.2 [except.ctor] + 15.3 [except.handle] + 15.4 [except.spec] + 15.5 [except.special] + 15.5.1 [except.terminate] + 15.5.2 [except.unexpected] + 15.5.3 [except.uncaught] + 15.6 [except.access] +16 [cpp] + 16.1 [cpp.cond] + 16.2 [cpp.include] + 16.3 [cpp.replace] + 16.3.1 [cpp.subst] + 16.3.2 [cpp.stringize] + 16.3.3 [cpp.concat] + 16.3.4 [cpp.rescan] + 16.3.5 [cpp.scope] + 16.4 [cpp.line] + 16.5 [cpp.error] + 16.6 [cpp.pragma] + 16.7 [cpp.null] + 16.8 [cpp.predefined] + 16.9 [cpp.pragma.op] +17 [library] + 17.1 [library.general] + 17.2 [library.overview] + 17.3 [definitions] + 17.3.1 [defns.arbitrary.stream] + 17.3.2 [defns.blocked] + 17.3.3 [defns.character] + 17.3.4 [defns.character.container] + 17.3.5 [defns.comparison] + 17.3.6 [defns.component] + 17.3.7 [defns.deadlock] + 17.3.8 [defns.default.behavior] + 17.3.9 [defns.handler] + 17.3.10 [defns.iostream.templates] + 17.3.11 [defns.modifier] + 17.3.12 [defns.obj.state] + 17.3.13 [defns.ntcts] + 17.3.14 [defns.narrow.iostream] + 17.3.15 [defns.observer] + 17.3.16 [defns.replacement] + 17.3.17 [defns.repositional.stream] + 17.3.18 [defns.required.behavior] + 17.3.19 [defns.reserved.function] + 17.3.20 [defns.stable] + 17.3.21 [defns.traits] + 17.3.22 [defns.wide.iostream] + 17.4 [defns.additional] + 17.5 [description] + 17.5.1 [description.general] + 17.5.2 [structure] + 17.5.2.1 [structure.elements] + 17.5.2.2 [structure.summary] + 17.5.2.3 [structure.requirements] + 17.5.2.4 [structure.specifications] + 17.5.2.5 [structure.see.also] + 17.5.3 [conventions] + 17.5.3.1 [conventions.general] + 17.5.3.2 [type.descriptions] + 17.5.3.2.1 [type.descriptions.general] + 17.5.3.2.2 [enumerated.types] + 17.5.3.2.3 [bitmask.types] + 17.5.3.2.4 [character.seq] + 17.5.3.2.4.1 [character.seq.general] + 17.5.3.2.4.2 [byte.strings] + 17.5.3.2.4.3 [multibyte.strings] + 17.5.3.2.4.4 [char16_t.seq] + 17.5.3.2.4.5 [char32_t.seq] + 17.5.3.2.4.6 [wide.characters] + 17.5.3.3 [functions.within.classes] + 17.5.3.4 [objects.within.classes] + 17.6 [requirements] + 17.6.1 [requirements.general] + 17.6.2 [organization] + 17.6.2.1 [organization.general] + 17.6.2.2 [contents] + 17.6.2.3 [headers] + 17.6.2.4 [compliance] + 17.6.3 [using] + 17.6.3.1 [using.overview] + 17.6.3.2 [using.headers] + 17.6.3.3 [using.linkage] + 17.6.4 [constraints] + 17.6.4.1 [constraints.overview] + 17.6.4.2 [namespace.constraints] + 17.6.4.2.1 [namespace.std] + 17.6.4.2.2 [namespace.posix] + 17.6.4.3 [reserved.names] + 17.6.4.3.1 [reserved.names.general] + 17.6.4.3.2 [macro.names] + 17.6.4.3.3 [global.names] + 17.6.4.3.4 [extern.names] + 17.6.4.3.5 [extern.types] + 17.6.4.3.6 [usrlit.suffix] + 17.6.4.4 [alt.headers] + 17.6.4.5 [derived.classes] + 17.6.4.6 [replacement.functions] + 17.6.4.7 [handler.functions] + 17.6.4.8 [res.on.functions] + 17.6.4.9 [res.on.arguments] + 17.6.4.10 [res.on.objects] + 17.6.4.11 [res.on.required] + 17.6.5 [conforming] + 17.6.5.1 [conforming.overview] + 17.6.5.2 [res.on.headers] + 17.6.5.3 [res.on.macro.definitions] + 17.6.5.4 [global.functions] + 17.6.5.5 [member.functions] + 17.6.5.6 [reentrancy] + 17.6.5.7 [res.on.data.races] + 17.6.5.8 [protection.within.classes] + 17.6.5.9 [derivation] + 17.6.5.10 [res.on.exception.handling] + 17.6.5.11 [res.on.pointer.storage] + 17.6.5.12 [value.error.codes] +18 [language.support] + 18.1 [support.types] + 18.2 [support.limits] + 18.2.1 [limits] + 18.2.1.1 [numeric.limits] + 18.2.1.2 [numeric.limits.members] + 18.2.1.3 [round.style] + 18.2.1.4 [denorm.style] + 18.2.1.5 [numeric.special] + 18.2.2 [c.limits] + 18.3 [cstdint] + 18.3.1 [cstdint.syn] + 18.3.2 [stdinth] + 18.4 [support.start.term] + 18.5 [support.dynamic] + 18.5.1 [new.delete] + 18.5.1.1 [new.delete.single] + 18.5.1.2 [new.delete.array] + 18.5.1.3 [new.delete.placement] + 18.5.1.4 [new.delete.dataraces] + 18.5.2 [alloc.errors] + 18.5.2.1 [bad.alloc] + 18.5.2.2 [new.handler] + 18.5.2.3 [set.new.handler] + 18.6 [support.rtti] + 18.6.1 [type.info] + 18.6.2 [type.index] + 18.6.2.1 [type.index.overview] + 18.6.2.2 [type.index.members] + 18.6.2.3 [type.index.templ] + 18.6.3 [bad.cast] + 18.6.4 [bad.typeid] + 18.7 [support.exception] + 18.7.1 [exception] + 18.7.2 [exception.unexpected] + 18.7.2.1 [bad.exception] + 18.7.2.2 [unexpected.handler] + 18.7.2.3 [set.unexpected] + 18.7.2.4 [unexpected] + 18.7.3 [exception.terminate] + 18.7.3.1 [terminate.handler] + 18.7.3.2 [set.terminate] + 18.7.3.3 [terminate] + 18.7.4 [uncaught] + 18.7.5 [propagation] + 18.7.6 [except.nested] + 18.8 [support.initlist] + 18.8.1 [support.initlist.cons] + 18.8.2 [support.initlist.access] + 18.8.3 [support.initlist.concept] + 18.9 [support.runtime] +19 [diagnostics] + 19.1 [std.exceptions] + 19.1.1 [logic.error] + 19.1.2 [domain.error] + 19.1.3 [invalid.argument] + 19.1.4 [length.error] + 19.1.5 [out.of.range] + 19.1.6 [runtime.error] + 19.1.7 [range.error] + 19.1.8 [overflow.error] + 19.1.9 [underflow.error] + 19.2 [assertions] + 19.3 [errno] + 19.4 [syserr] + 19.4.1 [syserr.errcat] + 19.4.1.1 [syserr.errcat.overview] + 19.4.1.2 [syserr.errcat.virtuals] + 19.4.1.3 [syserr.errcat.nonvirtuals] + 19.4.1.4 [syserr.errcat.derived] + 19.4.1.5 [syserr.errcat.objects] + 19.4.2 [syserr.errcode] + 19.4.2.1 [syserr.errcodeenum] + 19.4.2.2 [syserr.errcode.overview] + 19.4.2.3 [syserr.errcode.constructors] + 19.4.2.4 [syserr.errcode.modifiers] + 19.4.2.5 [syserr.errcode.observers] + 19.4.2.6 [syserr.errcode.nonmembers] + 19.4.3 [syserr.errcondition] + 19.4.3.1 [syserr.errcondenum] + 19.4.3.2 [syserr.errcondition.overview] + 19.4.3.3 [syserr.errcondition.constructors] + 19.4.3.4 [syserr.errcondition.modifiers] + 19.4.3.5 [syserr.errcondition.observers] + 19.4.3.6 [syserr.errcondition.nonmembers] + 19.4.4 [syserr.compare] + 19.4.5 [syserr.syserr] + 19.4.5.1 [syserr.syserr.overview] + 19.4.5.2 [syserr.syserr.members] +20 [utilities] + 20.1 [utility.requirements] + 20.1.1 [utility.arg.requirements] + 20.1.2 [allocator.requirements] + 20.2 [utility.concepts] + 20.2.1 [concept.transform] + 20.2.2 [concept.true] + 20.2.3 [concept.operator] + 20.2.4 [concept.predicate] + 20.2.5 [concept.comparison] + 20.2.6 [concept.construct] + 20.2.7 [concept.destruct] + 20.2.8 [concept.copymove] + 20.2.9 [concept.memory] + 20.2.10 [concept.regular] + 20.2.11 [concept.convertible] + 20.2.12 [concept.arithmetic] + 20.3 [utility] + 20.3.1 [operators] + 20.3.2 [forward] + 20.3.3 [pairs] + 20.3.4 [pair.astuple] + 20.3.5 [pair.concepts] + 20.3.6 [template.bitset] + 20.3.6.1 [bitset.cons] + 20.3.6.2 [bitset.members] + 20.3.6.3 [bitset.operators] + 20.4 [ratio] + 20.4.1 [ratio.ratio] + 20.4.2 [ratio.arithmetic] + 20.4.3 [ratio.comparison] + 20.4.4 [ratio.si] + 20.5 [tuple] + 20.5.1 [tuple.general] + 20.5.2 [tuple.tuple] + 20.5.2.1 [tuple.traits] + 20.5.2.2 [tuple.cnstr] + 20.5.2.3 [tuple.creation] + 20.5.2.4 [tuple.helper] + 20.5.2.5 [tuple.elem] + 20.5.2.6 [tuple.rel] + 20.5.2.7 [tuple.swap] + 20.5.2.8 [tuple.special] + 20.5.2.9 [tuple.concepts] + 20.6 [meta] + 20.6.1 [meta.rqmts] + 20.6.2 [meta.type.synop] + 20.6.3 [meta.help] + 20.6.4 [meta.unary] + 20.6.4.1 [meta.unary.cat] + 20.6.4.2 [meta.unary.comp] + 20.6.4.3 [meta.unary.prop] + 20.6.5 [meta.rel] + 20.6.6 [meta.trans] + 20.6.6.1 [meta.trans.cv] + 20.6.6.2 [meta.trans.ref] + 20.6.6.3 [meta.trans.sign] + 20.6.6.4 [meta.trans.arr] + 20.6.6.5 [meta.trans.ptr] + 20.6.7 [meta.trans.other] + 20.7 [function.objects] + 20.7.1 [func.def] + 20.7.2 [func.require] + 20.7.3 [base] + 20.7.4 [func.ret] + 20.7.5 [refwrap] + 20.7.5.1 [refwrap.const] + 20.7.5.2 [refwrap.assign] + 20.7.5.3 [refwrap.access] + 20.7.5.4 [refwrap.invoke] + 20.7.5.5 [refwrap.helpers] + 20.7.6 [identity.operation] + 20.7.7 [arithmetic.operations] + 20.7.8 [comparisons] + 20.7.9 [logical.operations] + 20.7.10 [bitwise.operations] + 20.7.11 [negators] + 20.7.12 [bind] + 20.7.12.1 [func.bind] + 20.7.12.1.1 [func.bind.isbind] + 20.7.12.1.2 [func.bind.isplace] + 20.7.12.1.3 [func.bind.bind] + 20.7.12.1.4 [func.bind.place] + 20.7.13 [function.pointer.adaptors] + 20.7.14 [member.pointer.adaptors] + 20.7.15 [func.memfn] + 20.7.16 [func.wrap] + 20.7.16.1 [func.wrap.badcall] + 20.7.16.1.1 [func.wrap.badcall.const] + 20.7.16.2 [func.wrap.func] + 20.7.16.2.1 [func.wrap.func.con] + 20.7.16.2.2 [func.wrap.func.mod] + 20.7.16.2.3 [func.wrap.func.cap] + 20.7.16.2.4 [func.wrap.func.inv] + 20.7.16.2.5 [func.wrap.func.targ] + 20.7.16.2.6 [func.wrap.func.nullptr] + 20.7.16.2.7 [func.wrap.func.alg] + 20.7.17 [unord.hash] + 20.7.18 [func.referenceclosure] + 20.7.18.1 [func.referenceclosure.cons] + 20.7.18.2 [func.referenceclosure.obs] + 20.7.18.3 [func.referenceclosure.invoke] + 20.7.18.4 [func.referenceclosure.compare] + 20.8 [memory] + 20.8.1 [allocator.tag] + 20.8.2 [allocator] + 20.8.2.1 [allocator.general] + 20.8.2.2 [allocator.concepts] + 20.8.3 [allocator.element.concepts] + 20.8.4 [allocator.propagation] + 20.8.5 [allocator.propagation.map] + 20.8.6 [default.allocator] + 20.8.6.1 [allocator.members] + 20.8.6.2 [allocator.globals] + 20.8.7 [allocator.adaptor] + 20.8.7.1 [allocator.adaptor.cntr] + 20.8.7.2 [allocator.adaptor.members] + 20.8.7.3 [allocator.adaptor.globals] + 20.8.8 [storage.iterator] + 20.8.9 [temporary.buffer] + 20.8.10 [construct.element] + 20.8.11 [specialized.algorithms] + 20.8.11.1 [object.addressof] + 20.8.11.2 [uninitialized.copy] + 20.8.11.3 [uninitialized.fill] + 20.8.11.4 [uninitialized.fill.n] + 20.8.12 [unique.ptr] + 20.8.12.1 [unique.ptr.dltr] + 20.8.12.1.1 [unique.ptr.dltr.dflt] + 20.8.12.1.2 [unique.ptr.dltr.dflt1] + 20.8.12.1.3 [unique.ptr.dltr.dflt2] + 20.8.12.2 [unique.ptr.single] + 20.8.12.2.1 [unique.ptr.single.ctor] + 20.8.12.2.2 [unique.ptr.single.dtor] + 20.8.12.2.3 [unique.ptr.single.asgn] + 20.8.12.2.4 [unique.ptr.single.observers] + 20.8.12.2.5 [unique.ptr.single.modifiers] + 20.8.12.3 [unique.ptr.runtime] + 20.8.12.3.1 [unique.ptr.runtime.ctor] + 20.8.12.3.2 [unique.ptr.runtime.observers] + 20.8.12.3.3 [unique.ptr.runtime.modifiers] + X [unique.ptr.compiletime] + 20.8.12.4 [unique.ptr.special] + 20.8.13 [util.smartptr] + 20.8.13.1 [util.smartptr.weakptr] + 20.8.13.2 [util.smartptr.shared] + 20.8.13.2.1 [util.smartptr.shared.const] + 20.8.13.2.2 [util.smartptr.shared.dest] + 20.8.13.2.3 [util.smartptr.shared.assign] + 20.8.13.2.4 [util.smartptr.shared.mod] + 20.8.13.2.5 [util.smartptr.shared.obs] + 20.8.13.2.6 [util.smartptr.shared.create] + 20.8.13.2.7 [util.smartptr.shared.cmp] + 20.8.13.2.8 [util.smartptr.shared.io] + 20.8.13.2.9 [util.smartptr.shared.spec] + 20.8.13.2.10 [util.smartptr.shared.cast] + 20.8.13.2.11 [util.smartptr.getdeleter] + 20.8.13.3 [util.smartptr.weak] + 20.8.13.3.1 [util.smartptr.weak.const] + 20.8.13.3.2 [util.smartptr.weak.dest] + 20.8.13.3.3 [util.smartptr.weak.assign] + 20.8.13.3.4 [util.smartptr.weak.mod] + 20.8.13.3.5 [util.smartptr.weak.obs] + 20.8.13.3.6 [util.smartptr.weak.cmp] + 20.8.13.3.7 [util.smartptr.weak.spec] + 20.8.13.4 [util.smartptr.ownerless] + 20.8.13.5 [util.smartptr.enab] + 20.8.13.6 [util.smartptr.shared.atomic] + 20.8.13.7 [util.dynamic.safety] + 20.8.14 [ptr.align] + 20.8.15 [c.malloc] + 20.9 [time] + 20.9.1 [time.clock.req] + 20.9.2 [time.traits] + 20.9.2.1 [time.traits.is_fp] + 20.9.2.2 [time.traits.duration_values] + 20.9.2.3 [time.traits.specializations] + 20.9.3 [time.duration] + 20.9.3.1 [time.duration.cons] + 20.9.3.2 [time.duration.observer] + 20.9.3.3 [time.duration.arithmetic] + 20.9.3.4 [time.duration.special] + 20.9.3.5 [time.duration.nonmember] + 20.9.3.6 [time.duration.comparisons] + 20.9.3.7 [time.duration.cast] + 20.9.4 [time.point] + 20.9.4.1 [time.point.cons] + 20.9.4.2 [time.point.observer] + 20.9.4.3 [time.point.arithmetic] + 20.9.4.4 [time.point.special] + 20.9.4.5 [time.point.nonmember] + 20.9.4.6 [time.point.comparisons] + 20.9.4.7 [time.point.cast] + 20.9.5 [time.clock] + 20.9.5.1 [time.clock.system] + 20.9.5.2 [time.clock.monotonic] + 20.9.5.3 [time.clock.hires] + 20.10 [date.time] +21 [strings] + 21.1 [char.traits] + 21.1.1 [char.traits.require] + 21.1.2 [char.traits.typedefs] + 21.1.3 [char.traits.specializations] + 21.1.3.1 [char.traits.specializations.char] + 21.1.3.2 [char.traits.specializations.char16_t] + 21.1.3.3 [char.traits.specializations.char32_t] + 21.1.3.4 [char.traits.specializations.wchar.t] + 21.2 [string.classes] + 21.3 [basic.string] + 21.3.1 [string.require] + 21.3.2 [string.cons] + 21.3.3 [string.iterators] + 21.3.4 [string.capacity] + 21.3.5 [string.access] + 21.3.6 [string.modifiers] + 21.3.6.1 [string::op+=] + 21.3.6.2 [string::append] + 21.3.6.3 [string::assign] + 21.3.6.4 [string::insert] + 21.3.6.5 [string::erase] + 21.3.6.6 [string::replace] + 21.3.6.7 [string::copy] + 21.3.6.8 [string::swap] + 21.3.7 [string.ops] + 21.3.7.1 [string.accessors] + 21.3.7.2 [string::find] + 21.3.7.3 [string::rfind] + 21.3.7.4 [string::find.first.of] + 21.3.7.5 [string::find.last.of] + 21.3.7.6 [string::find.first.not.of] + 21.3.7.7 [string::find.last.not.of] + 21.3.7.8 [string::substr] + 21.3.7.9 [string::compare] + 21.3.8 [string.nonmembers] + 21.3.8.1 [string::op+] + 21.3.8.2 [string::operator==] + 21.3.8.3 [string::op!=] + 21.3.8.4 [string::op<] + 21.3.8.5 [string::op>] + 21.3.8.6 [string::op<=] + 21.3.8.7 [string::op>=] + 21.3.8.8 [string.special] + 21.3.8.9 [string.io] + 21.4 [string.conversions] + 21.5 [c.strings] +22 [localization] + 22.1 [locales] + 22.1.1 [locale] + 22.1.1.1 [locale.types] + 22.1.1.1.1 [locale.category] + 22.1.1.1.2 [locale.facet] + 22.1.1.1.3 [locale.id] + 22.1.1.2 [locale.cons] + 22.1.1.3 [locale.members] + 22.1.1.4 [locale.operators] + 22.1.1.5 [locale.statics] + 22.1.2 [locale.global.templates] + 22.1.3 [locale.convenience] + 22.1.3.1 [classification] + 22.1.3.2 [conversions] + 22.1.3.2.1 [conversions.character] + 22.1.3.2.2 [conversions.string] + 22.1.3.2.3 [conversions.buffer] + 22.2 [locale.categories] + 22.2.1 [category.ctype] + 22.2.1.1 [locale.ctype] + 22.2.1.1.1 [locale.ctype.members] + 22.2.1.1.2 [locale.ctype.virtuals] + 22.2.1.2 [locale.ctype.byname] + 22.2.1.3 [facet.ctype.special] + 22.2.1.3.1 [facet.ctype.char.dtor] + 22.2.1.3.2 [facet.ctype.char.members] + 22.2.1.3.3 [facet.ctype.char.statics] + 22.2.1.3.4 [facet.ctype.char.virtuals] + 22.2.1.4 [locale.codecvt] + 22.2.1.4.1 [locale.codecvt.members] + 22.2.1.4.2 [locale.codecvt.virtuals] + 22.2.1.5 [locale.codecvt.byname] + 22.2.2 [category.numeric] + 22.2.2.1 [locale.num.get] + 22.2.2.1.1 [facet.num.get.members] + 22.2.2.1.2 [facet.num.get.virtuals] + 22.2.2.2 [locale.nm.put] + 22.2.2.2.1 [facet.num.put.members] + 22.2.2.2.2 [facet.num.put.virtuals] + 22.2.3 [facet.numpunct] + 22.2.3.1 [locale.numpunct] + 22.2.3.1.1 [facet.numpunct.members] + 22.2.3.1.2 [facet.numpunct.virtuals] + 22.2.3.2 [locale.numpunct.byname] + 22.2.4 [category.collate] + 22.2.4.1 [locale.collate] + 22.2.4.1.1 [locale.collate.members] + 22.2.4.1.2 [locale.collate.virtuals] + 22.2.4.2 [locale.collate.byname] + 22.2.5 [category.time] + 22.2.5.1 [locale.time.get] + 22.2.5.1.1 [locale.time.get.members] + 22.2.5.1.2 [locale.time.get.virtuals] + 22.2.5.2 [locale.time.get.byname] + 22.2.5.3 [locale.time.put] + 22.2.5.3.1 [locale.time.put.members] + 22.2.5.3.2 [locale.time.put.virtuals] + 22.2.5.4 [locale.time.put.byname] + 22.2.6 [category.monetary] + 22.2.6.1 [locale.money.get] + 22.2.6.1.1 [locale.money.get.members] + 22.2.6.1.2 [locale.money.get.virtuals] + 22.2.6.2 [locale.money.put] + 22.2.6.2.1 [locale.money.put.members] + 22.2.6.2.2 [locale.money.put.virtuals] + 22.2.6.3 [locale.moneypunct] + 22.2.6.3.1 [locale.moneypunct.members] + 22.2.6.3.2 [locale.moneypunct.virtuals] + 22.2.6.4 [locale.moneypunct.byname] + 22.2.7 [category.messages] + 22.2.7.1 [locale.messages] + 22.2.7.1.1 [locale.messages.members] + 22.2.7.1.2 [locale.messages.virtuals] + 22.2.7.2 [locale.messages.byname] + 22.2.8 [facets.examples] + 22.3 [locale.stdcvt] + 22.4 [c.locales] +23 [containers] + 23.1 [container.requirements] + 23.1.1 [container.requirements.general] + 23.1.2 [container.requirements.dataraces] + 23.1.3 [sequence.reqmts] + 23.1.4 [associative.reqmts] + 23.1.4.1 [associative.reqmts.except] + 23.1.5 [unord.req] + 23.1.5.1 [unord.req.except] + 23.1.6 [container.concepts] + 23.1.6.1 [container.concepts.free] + 23.1.6.2 [container.concepts.member] + 23.1.6.3 [container.concepts.maps] + 23.2 [sequences] + 23.2.1 [array] + 23.2.1.1 [array.cons] + 23.2.1.2 [array.special] + 23.2.1.3 [array.size] + 23.2.1.4 [array.data] + 23.2.1.5 [array.fill] + 23.2.1.6 [array.zero] + 23.2.1.7 [array.tuple] + 23.2.2 [deque] + 23.2.2.1 [deque.cons] + 23.2.2.2 [deque.capacity] + 23.2.2.3 [deque.modifiers] + 23.2.2.4 [deque.special] + 23.2.3 [forwardlist] + 23.2.3.1 [forwardlist.cons] + 23.2.3.2 [forwardlist.iter] + 23.2.3.3 [forwardlist.access] + 23.2.3.4 [forwardlist.modifiers] + 23.2.3.5 [forwardlist.ops] + 23.2.3.6 [forwardlist.spec] + 23.2.4 [list] + 23.2.4.1 [list.cons] + 23.2.4.2 [list.capacity] + 23.2.4.3 [list.modifiers] + 23.2.4.4 [list.ops] + 23.2.4.5 [list.special] + 23.2.5 [container.adaptors] + 23.2.5.1 [queue] + 23.2.5.1.1 [queue.defn] + 23.2.5.1.2 [queue.ops] + 23.2.5.1.3 [queue.special] + 23.2.5.2 [priority.queue] + 23.2.5.2.1 [priqueue.cons] + 23.2.5.2.2 [priqueue.members] + 23.2.5.2.3 [priqueue.special] + 23.2.5.3 [stack] + 23.2.5.3.1 [stack.defn] + 23.2.5.3.2 [stack.ops] + 23.2.5.3.3 [stack.special] + 23.2.6 [vector] + 23.2.6.1 [vector.cons] + 23.2.6.2 [vector.capacity] + 23.2.6.3 [vector.data] + 23.2.6.4 [vector.modifiers] + 23.2.6.5 [vector.special] + 23.2.7 [vector.bool] + 23.3 [associative] + 23.3.1 [map] + 23.3.1.1 [map.cons] + 23.3.1.2 [map.access] + 23.3.1.3 [map.modifiers] + 23.3.1.4 [map.ops] + 23.3.1.5 [map.special] + 23.3.2 [multimap] + 23.3.2.1 [multimap.cons] + 23.3.2.2 [multimap.modifiers] + 23.3.2.3 [multimap.ops] + 23.3.2.4 [multimap.special] + 23.3.3 [set] + 23.3.3.1 [set.cons] + 23.3.3.2 [set.special] + 23.3.4 [multiset] + 23.3.4.1 [multiset.cons] + 23.3.4.2 [multiset.special] + 23.4 [unord] + 23.4.1 [unord.map] + 23.4.1.1 [unord.map.cnstr] + 23.4.1.2 [unord.map.elem] + 23.4.1.3 [unord.map.swap] + 23.4.2 [unord.multimap] + 23.4.2.1 [unord.multimap.cnstr] + 23.4.2.2 [unord.multimap.swap] + 23.4.3 [unord.set] + 23.4.3.1 [unord.set.cnstr] + 23.4.3.2 [unord.set.swap] + 23.4.4 [unord.multiset] + 23.4.4.1 [unord.multiset.cnstr] + 23.4.4.2 [unord.multiset.swap] +24 [iterators] + 24.1 [iterator.concepts] + 24.1.1 [iterator.iterators] + 24.1.2 [input.iterators] + 24.1.3 [output.iterators] + 24.1.4 [forward.iterators] + 24.1.5 [bidirectional.iterators] + 24.1.6 [random.access.iterators] + 24.1.7 [shuffle.iterators] + 24.1.8 [iterator.concepts.range] + 24.2 [iterator.synopsis] + 24.3 [iterator.operations] + 24.4 [predef.iterators] + 24.4.1 [reverse.iterators] + 24.4.1.1 [reverse.iterator] + 24.4.1.2 [reverse.iter.requirements] + 24.4.1.3 [reverse.iter.ops] + 24.4.1.3.1 [reverse.iter.cons] + 24.4.1.3.2 [reverse.iter.op=] + 24.4.1.3.3 [reverse.iter.conv] + 24.4.1.3.4 [reverse.iter.op.star] + 24.4.1.3.5 [reverse.iter.opref] + 24.4.1.3.6 [reverse.iter.op++] + 24.4.1.3.7 [reverse.iter.op--] + 24.4.1.3.8 [reverse.iter.op+] + 24.4.1.3.9 [reverse.iter.op+=] + 24.4.1.3.10 [reverse.iter.op-] + 24.4.1.3.11 [reverse.iter.op-=] + 24.4.1.3.12 [reverse.iter.opindex] + 24.4.1.3.13 [reverse.iter.op==] + 24.4.1.3.14 [reverse.iter.op<] + 24.4.1.3.15 [reverse.iter.op!=] + 24.4.1.3.16 [reverse.iter.op>] + 24.4.1.3.17 [reverse.iter.op>=] + 24.4.1.3.18 [reverse.iter.op<=] + 24.4.1.3.19 [reverse.iter.opdiff] + 24.4.1.3.20 [reverse.iter.opsum] + 24.4.1.4 [reverse.iter.maps] + 24.4.2 [insert.iterators] + 24.4.2.1 [back.insert.iterator] + 24.4.2.2 [back.insert.iter.ops] + 24.4.2.2.1 [back.insert.iter.cons] + 24.4.2.2.2 [back.insert.iter.op=] + 24.4.2.2.3 [back.insert.iter.op*] + 24.4.2.2.4 [back.insert.iter.op++] + 24.4.2.2.5 [back.inserter] + 24.4.2.2.6 [back.insert.iter.maps] + 24.4.2.3 [front.insert.iterator] + 24.4.2.4 [front.insert.iter.ops] + 24.4.2.4.1 [front.insert.iter.cons] + 24.4.2.4.2 [front.insert.iter.op=] + 24.4.2.4.3 [front.insert.iter.op*] + 24.4.2.4.4 [front.insert.iter.op++] + 24.4.2.4.5 [front.inserter] + 24.4.2.4.6 [front.insert.iter.maps] + 24.4.2.5 [insert.iterator] + 24.4.2.6 [insert.iter.ops] + 24.4.2.6.1 [insert.iter.cons] + 24.4.2.6.2 [insert.iter.op=] + 24.4.2.6.3 [insert.iter.op*] + 24.4.2.6.4 [insert.iter.op++] + 24.4.2.6.5 [inserter] + 24.4.2.6.6 [insert.iter.maps] + 24.4.3 [move.iterators] + 24.4.3.1 [move.iterator] + 24.4.3.2 [move.iter.requirements] + 24.4.3.3 [move.iter.ops] + 24.4.3.3.1 [move.iter.op.const] + 24.4.3.3.2 [move.iter.op=] + 24.4.3.3.3 [move.iter.op.conv] + 24.4.3.3.4 [move.iter.op.star] + 24.4.3.3.5 [move.iter.op.ref] + 24.4.3.3.6 [move.iter.op.incr] + 24.4.3.3.7 [move.iter.op.decr] + 24.4.3.3.8 [move.iter.op.+] + 24.4.3.3.9 [move.iter.op.+=] + 24.4.3.3.10 [move.iter.op.-] + 24.4.3.3.11 [move.iter.op.-=] + 24.4.3.3.12 [move.iter.op.index] + 24.4.3.3.13 [move.iter.op.comp] + 24.4.3.3.14 [move.iter.nonmember] + 24.4.3.3.15 [move.iter.maps] + 24.5 [stream.iterators] + 24.5.1 [istream.iterator] + 24.5.1.1 [istream.iterator.cons] + 24.5.1.2 [istream.iterator.ops] + 24.5.2 [ostream.iterator] + 24.5.2.1 [ostream.iterator.cons.des] + 24.5.2.2 [ostream.iterator.ops] + 24.5.3 [istreambuf.iterator] + 24.5.3.1 [istreambuf.iterator::proxy] + 24.5.3.2 [istreambuf.iterator.cons] + 24.5.3.3 [istreambuf.iterator::op*] + 24.5.3.4 [istreambuf.iterator::op++] + 24.5.3.5 [istreambuf.iterator::equal] + 24.5.3.6 [istreambuf.iterator::op==] + 24.5.3.7 [istreambuf.iterator::op!=] + 24.5.4 [ostreambuf.iterator] + 24.5.4.1 [ostreambuf.iter.cons] + 24.5.4.2 [ostreambuf.iter.ops] +25 [algorithms] + 25.1 [alg.nonmodifying] + 25.1.1 [alg.all_of] + 25.1.2 [alg.any_of] + 25.1.3 [alg.none_of] + 25.1.4 [alg.foreach] + 25.1.5 [alg.find] + 25.1.6 [alg.find.end] + 25.1.7 [alg.find.first.of] + 25.1.8 [alg.adjacent.find] + 25.1.9 [alg.count] + 25.1.10 [mismatch] + 25.1.11 [alg.equal] + 25.1.12 [alg.search] + 25.2 [alg.modifying.operations] + 25.2.1 [alg.copy] + 25.2.2 [alg.move] + 25.2.3 [alg.swap] + 25.2.4 [alg.transform] + 25.2.5 [alg.replace] + 25.2.6 [alg.fill] + 25.2.7 [alg.generate] + 25.2.8 [alg.remove] + 25.2.9 [alg.unique] + 25.2.10 [alg.reverse] + 25.2.11 [alg.rotate] + 25.2.12 [alg.random.shuffle] + 25.2.13 [alg.partitions] + 25.3 [alg.sorting] + 25.3.1 [alg.sort] + 25.3.1.1 [sort] + 25.3.1.2 [stable.sort] + 25.3.1.3 [partial.sort] + 25.3.1.4 [partial.sort.copy] + 25.3.1.5 [is.sorted] + 25.3.2 [alg.nth.element] + 25.3.3 [alg.binary.search] + 25.3.3.1 [lower.bound] + 25.3.3.2 [upper.bound] + 25.3.3.3 [equal.range] + 25.3.3.4 [binary.search] + 25.3.4 [alg.merge] + 25.3.5 [alg.set.operations] + 25.3.5.1 [includes] + 25.3.5.2 [set.union] + 25.3.5.3 [set.intersection] + 25.3.5.4 [set.difference] + 25.3.5.5 [set.symmetric.difference] + 25.3.6 [alg.heap.operations] + 25.3.6.1 [push.heap] + 25.3.6.2 [pop.heap] + 25.3.6.3 [make.heap] + 25.3.6.4 [sort.heap] + 25.3.6.5 [is.heap] + 25.3.7 [alg.min.max] + 25.3.8 [alg.lex.comparison] + 25.3.9 [alg.permutation.generators] + 25.4 [alg.c.library] +26 [numerics] + 26.1 [numeric.requirements] + 26.2 [cfenv] + 26.2.1 [cfenv.syn] + 26.2.2 [fenv] + 26.3 [complex.numbers] + 26.3.1 [complex.synopsis] + 26.3.2 [complex] + 26.3.3 [complex.special] + 26.3.4 [complex.members] + 26.3.5 [complex.member.ops] + 26.3.6 [complex.ops] + 26.3.7 [complex.value.ops] + 26.3.8 [complex.transcendentals] + 26.3.9 [cmplx.over] + 26.3.10 [ccmplx] + 26.3.11 [cmplxh] + 26.4 [rand] + 26.4.1 [rand.req] + 26.4.1.1 [rand.req.genl] + 26.4.1.2 [rand.req.urng] + 26.4.1.3 [rand.req.eng] + 26.4.1.4 [rand.req.adapt] + 26.4.1.5 [rand.req.dist] + 26.4.2 [rand.synopsis] + 26.4.3 [rand.eng] + 26.4.3.1 [rand.eng.lcong] + 26.4.3.2 [rand.eng.mers] + 26.4.3.3 [rand.eng.sub] + 26.4.4 [rand.adapt] + 26.4.4.1 [rand.adapt.disc] + 26.4.4.2 [rand.adapt.ibits] + 26.4.4.3 [rand.adapt.shuf] + X [rand.adapt.xor] + 26.4.5 [rand.predef] + 26.4.6 [rand.device] + 26.4.7 [rand.util] + 26.4.7.1 [rand.util.seedseq] + 26.4.7.2 [rand.util.canonical] + 26.4.8 [rand.dist] + 26.4.8.1 [rand.dist.uni] + 26.4.8.1.1 [rand.dist.uni.int] + 26.4.8.1.2 [rand.dist.uni.real] + 26.4.8.2 [rand.dist.bern] + 26.4.8.2.1 [rand.dist.bern.bernoulli] + 26.4.8.2.2 [rand.dist.bern.bin] + 26.4.8.2.3 [rand.dist.bern.geo] + 26.4.8.2.4 [rand.dist.bern.negbin] + 26.4.8.3 [rand.dist.pois] + 26.4.8.3.1 [rand.dist.pois.poisson] + 26.4.8.3.2 [rand.dist.pois.exp] + 26.4.8.3.3 [rand.dist.pois.gamma] + 26.4.8.3.4 [rand.dist.pois.weibull] + 26.4.8.3.5 [rand.dist.pois.extreme] + 26.4.8.4 [rand.dist.norm] + 26.4.8.4.1 [rand.dist.norm.normal] + 26.4.8.4.2 [rand.dist.norm.lognormal] + 26.4.8.4.3 [rand.dist.norm.chisq] + 26.4.8.4.4 [rand.dist.norm.cauchy] + 26.4.8.4.5 [rand.dist.norm.f] + 26.4.8.4.6 [rand.dist.norm.t] + 26.4.8.5 [rand.dist.samp] + 26.4.8.5.1 [rand.dist.samp.discrete] + 26.4.8.5.2 [rand.dist.samp.pconst] + 26.4.8.5.3 [rand.dist.samp.genpdf] + 26.5 [numarray] + 26.5.1 [valarray.synopsis] + 26.5.2 [template.valarray] + 26.5.2.1 [valarray.cons] + 26.5.2.2 [valarray.assign] + 26.5.2.3 [valarray.access] + 26.5.2.4 [valarray.sub] + 26.5.2.5 [valarray.unary] + 26.5.2.6 [valarray.cassign] + 26.5.2.7 [valarray.members] + 26.5.3 [valarray.nonmembers] + 26.5.3.1 [valarray.binary] + 26.5.3.2 [valarray.comparison] + 26.5.3.3 [valarray.transcend] + 26.5.3.4 [valarray.special] + 26.5.4 [class.slice] + 26.5.4.1 [cons.slice] + 26.5.4.2 [slice.access] + 26.5.5 [template.slice.array] + 26.5.5.1 [slice.arr.assign] + 26.5.5.2 [slice.arr.comp.assign] + 26.5.5.3 [slice.arr.fill] + 26.5.6 [class.gslice] + 26.5.6.1 [gslice.cons] + 26.5.6.2 [gslice.access] + 26.5.7 [template.gslice.array] + 26.5.7.1 [gslice.array.assign] + 26.5.7.2 [gslice.array.comp.assign] + 26.5.7.3 [gslice.array.fill] + 26.5.8 [template.mask.array] + 26.5.8.1 [mask.array.assign] + 26.5.8.2 [mask.array.comp.assign] + 26.5.8.3 [mask.array.fill] + 26.5.9 [template.indirect.array] + 26.5.9.1 [indirect.array.assign] + 26.5.9.2 [indirect.array.comp.assign] + 26.5.9.3 [indirect.array.fill] + 26.5.9.4 [valarray.concepts] + 26.6 [numeric.ops] + 26.6.1 [accumulate] + 26.6.2 [inner.product] + 26.6.3 [partial.sum] + 26.6.4 [adjacent.difference] + 26.6.5 [numeric.iota] + 26.7 [c.math] +27 [input.output] + 27.1 [iostreams.requirements] + 27.1.1 [iostream.limits.imbue] + 27.1.2 [iostreams.limits.pos] + 27.1.3 [iostreams.threadsafety] + 27.2 [iostream.forward] + 27.3 [iostream.objects] + 27.3.1 [narrow.stream.objects] + 27.3.2 [wide.stream.objects] + 27.4 [iostreams.base] + 27.4.1 [stream.types] + 27.4.2 [ios.base] + 27.4.2.1 [ios.types] + 27.4.2.1.1 [ios::failure] + 27.4.2.1.2 [ios::fmtflags] + 27.4.2.1.3 [ios::iostate] + 27.4.2.1.4 [ios::openmode] + 27.4.2.1.5 [ios::seekdir] + 27.4.2.1.6 [ios::Init] + 27.4.2.2 [fmtflags.state] + 27.4.2.3 [ios.base.locales] + 27.4.2.4 [ios.members.static] + 27.4.2.5 [ios.base.storage] + 27.4.2.6 [ios.base.callback] + 27.4.2.7 [ios.base.cons] + 27.4.3 [fpos] + 27.4.3.1 [fpos.members] + 27.4.3.2 [fpos.operations] + 27.4.4 [ios] + 27.4.4.1 [basic.ios.cons] + 27.4.4.2 [basic.ios.members] + 27.4.4.3 [iostate.flags] + 27.4.5 [std.ios.manip] + 27.4.5.1 [fmtflags.manip] + 27.4.5.2 [adjustfield.manip] + 27.4.5.3 [basefield.manip] + 27.4.5.4 [floatfield.manip] + 27.4.5.5 [error.reporting] + 27.5 [stream.buffers] + 27.5.1 [streambuf.reqts] + 27.5.2 [streambuf] + 27.5.2.1 [streambuf.cons] + 27.5.2.2 [streambuf.members] + 27.5.2.2.1 [streambuf.locales] + 27.5.2.2.2 [streambuf.buffer] + 27.5.2.2.3 [streambuf.pub.get] + 27.5.2.2.4 [streambuf.pub.pback] + 27.5.2.2.5 [streambuf.pub.put] + 27.5.2.3 [streambuf.protected] + 27.5.2.3.1 [streambuf.assign] + 27.5.2.3.2 [streambuf.get.area] + 27.5.2.3.3 [streambuf.put.area] + 27.5.2.4 [streambuf.virtuals] + 27.5.2.4.1 [streambuf.virt.locales] + 27.5.2.4.2 [streambuf.virt.buffer] + 27.5.2.4.3 [streambuf.virt.get] + 27.5.2.4.4 [streambuf.virt.pback] + 27.5.2.4.5 [streambuf.virt.put] + 27.6 [iostream.format] + 27.6.1 [input.streams] + 27.6.1.1 [istream] + 27.6.1.1.1 [istream.cons] + 27.6.1.1.2 [istream.assign] + 27.6.1.1.3 [istream::sentry] + 27.6.1.2 [istream.formatted] + 27.6.1.2.1 [istream.formatted.reqmts] + 27.6.1.2.2 [istream.formatted.arithmetic] + 27.6.1.2.3 [istream::extractors] + 27.6.1.3 [istream.unformatted] + 27.6.1.4 [istream.manip] + 27.6.1.5 [iostreamclass] + 27.6.1.5.1 [iostream.cons] + 27.6.1.5.2 [iostream.dest] + 27.6.1.5.3 [iostream.assign] + 27.6.2 [output.streams] + 27.6.2.1 [ostream] + 27.6.2.2 [ostream.cons] + 27.6.2.3 [ostream.assign] + 27.6.2.4 [ostream::sentry] + 27.6.2.5 [ostream.seeks] + 27.6.2.6 [ostream.formatted] + 27.6.2.6.1 [ostream.formatted.reqmts] + 27.6.2.6.2 [ostream.inserters.arithmetic] + 27.6.2.6.3 [ostream.inserters] + 27.6.2.6.4 [ostream.inserters.character] + 27.6.2.7 [ostream.unformatted] + 27.6.2.8 [ostream.manip] + 27.6.3 [std.manip] + 27.6.4 [ext.manip] + 27.7 [string.streams] + 27.7.1 [stringbuf] + 27.7.1.1 [stringbuf.cons] + 27.7.1.2 [stringbuf.assign] + 27.7.1.3 [stringbuf.members] + 27.7.1.4 [stringbuf.virtuals] + 27.7.2 [istringstream] + 27.7.2.1 [istringstream.cons] + 27.7.2.2 [istringstream.assign] + 27.7.2.3 [istringstream.members] + 27.7.3 [ostringstream] + 27.7.3.1 [ostringstream.cons] + 27.7.3.2 [ostringstream.assign] + 27.7.3.3 [ostringstream.members] + 27.7.4 [stringstream] + 27.7.5 [stringstream.cons] + 27.7.5.1 [stringstream.assign] + 27.7.6 [stringstream.members] + 27.8 [file.streams] + 27.8.1 [fstreams] + 27.8.1.1 [filebuf] + 27.8.1.2 [filebuf.cons] + 27.8.1.3 [filebuf.assign] + 27.8.1.4 [filebuf.members] + 27.8.1.5 [filebuf.virtuals] + 27.8.1.6 [ifstream] + 27.8.1.7 [ifstream.cons] + 27.8.1.8 [ifstream.assign] + 27.8.1.9 [ifstream.members] + 27.8.1.10 [ofstream] + 27.8.1.11 [ofstream.cons] + 27.8.1.12 [ofstream.assign] + 27.8.1.13 [ofstream.members] + 27.8.1.14 [fstream] + 27.8.1.15 [fstream.cons] + 27.8.1.16 [fstream.assign] + 27.8.1.17 [fstream.members] + 27.8.2 [c.files] +28 [re] + 28.1 [re.def] + 28.1.1 [defns.regex.collating.element] + 28.1.2 [defns.regex.finite.state.machine] + 28.1.3 [defns.regex.format.specifier] + 28.1.4 [defns.regex.matched] + 28.1.5 [defns.regex.primary.equivalence.class] + 28.1.6 [defns.regex.regular.expression] + 28.1.7 [defns.regex.subexpression] + 28.2 [re.req] + 28.3 [re.sum] + 28.4 [re.syn] + 28.5 [re.const] + 28.5.1 [re.synopt] + 28.5.2 [re.matchflag] + 28.5.3 [re.err] + 28.6 [re.badexp] + 28.7 [re.traits] + 28.8 [re.regex] + 28.8.1 [re.regex.const] + 28.8.2 [re.regex.construct] + 28.8.3 [re.regex.assign] + 28.8.4 [re.regex.operations] + 28.8.5 [re.regex.locale] + 28.8.6 [re.regex.swap] + 28.8.7 [re.regex.nonmemb] + 28.8.7.1 [re.regex.nmswap] + 28.9 [re.submatch] + 28.9.1 [re.submatch.members] + 28.9.2 [re.submatch.op] + 28.9.3 [re.submatch.concepts] + 28.10 [re.results] + 28.10.1 [re.results.const] + 28.10.2 [re.results.size] + 28.10.3 [re.results.acc] + 28.10.4 [re.results.form] + 28.10.5 [re.results.all] + 28.10.6 [re.results.swap] + 28.10.7 [re.results.nonmember] + 28.11 [re.alg] + 28.11.1 [re.except] + 28.11.2 [re.alg.match] + 28.11.3 [re.alg.search] + 28.11.4 [re.alg.replace] + 28.12 [re.iter] + 28.12.1 [re.regiter] + 28.12.1.1 [re.regiter.cnstr] + 28.12.1.2 [re.regiter.comp] + 28.12.1.3 [re.regiter.deref] + 28.12.1.4 [re.regiter.incr] + 28.12.2 [re.tokiter] + 28.12.2.1 [re.tokiter.cnstr] + 28.12.2.2 [re.tokiter.comp] + 28.12.2.3 [re.tokiter.deref] + 28.12.2.4 [re.tokiter.incr] + 28.13 [re.grammar] +29 [atomics] + 29.1 [atomics.order] + 29.2 [atomics.lockfree] + 29.3 [atomics.types] + 29.3.1 [atomics.types.integral] + 29.3.2 [atomics.types.address] + 29.3.3 [atomics.types.generic] + 29.4 [atomics.types.operations] + 29.5 [atomics.flag] + 29.6 [atomics.fences] +30 [thread] + 30.1 [thread.req] + 30.1.1 [thread.req.paramname] + 30.1.2 [thread.req.exception] + 30.1.3 [thread.req.native] + 30.1.4 [thread.req.timing] + 30.2 [thread.threads] + 30.2.1 [thread.thread.class] + 30.2.1.1 [thread.thread.id] + 30.2.1.2 [thread.thread.constr] + 30.2.1.3 [thread.thread.destr] + 30.2.1.4 [thread.thread.assign] + 30.2.1.5 [thread.thread.member] + 30.2.1.6 [thread.thread.static] + 30.2.1.7 [thread.thread.algorithm] + 30.2.2 [thread.thread.this] + 30.3 [thread.mutex] + 30.3.1 [thread.mutex.requirements] + 30.3.1.1 [thread.mutex.class] + 30.3.1.2 [thread.mutex.recursive] + 30.3.2 [thread.timedmutex.requirements] + 30.3.2.1 [thread.timedmutex.class] + 30.3.2.2 [thread.timedmutex.recursive] + 30.3.3 [thread.lock] + 30.3.3.1 [thread.lock.guard] + 30.3.3.2 [thread.lock.unique] + 30.3.3.2.1 [thread.lock.unique.cons] + 30.3.3.2.2 [thread.lock.unique.locking] + 30.3.3.2.3 [thread.lock.unique.mod] + 30.3.3.2.4 [thread.lock.unique.obs] + 30.3.4 [thread.lock.algorithm] + 30.3.5 [thread.once] + 30.3.5.1 [thread.once.onceflag] + 30.3.5.2 [thread.once.callonce] + 30.4 [thread.condition] + 30.4.1 [thread.condition.condvar] + 30.4.2 [thread.condition.condvarany] + 30.5 [futures] + 30.5.1 [futures.overview] + 30.5.2 [futures.errors] + 30.5.3 [futures.future_error] + 30.5.4 [futures.unique_future] + 30.5.5 [future.shared_future] + 30.5.6 [futures.promise] + 30.5.7 [futures.allocators] + 30.5.8 [futures.task] +X [datetime] + X [datetime.req] + X [datetime.syn] + X [datetime.duration] + X [datetime.nanoseconds] + X [datetime.microseconds] + X [datetime.milliseconds] + X [datetime.seconds] + X [datetime.minutes] + X [datetime.hours] + X [datetime.system] + X [datetime.nonmembers] +A [gram] + A.1 [gram.key] + A.2 [gram.lex] + A.3 [gram.basic] + A.4 [gram.expr] + A.5 [gram.stmt] + A.6 [gram.dcl] + A.7 [gram.decl] + A.8 [gram.class] + A.9 [gram.derived] + A.10 [gram.special] + A.11 [gram.over] + A.12 [gram.temp] + A.13 [gram.except] + A.14 [gram.cpp] +B [implimits] +C [diff] + C.1 [diff.iso] + C.1.1 [diff.lex] + C.1.2 [diff.basic] + C.1.3 [diff.expr] + C.1.4 [diff.stat] + C.1.5 [diff.dcl] + C.1.6 [diff.decl] + C.1.7 [diff.class] + C.1.8 [diff.special] + C.1.9 [diff.cpp] + C.2 [diff.library] + C.2.1 [diff.mods.to.headers] + C.2.2 [diff.mods.to.definitions] + C.2.2.1 [diff.char16] + C.2.2.2 [diff.wchar.t] + C.2.2.3 [diff.header.iso646.h] + C.2.2.4 [diff.null] + C.2.3 [diff.mods.to.declarations] + C.2.4 [diff.mods.to.behavior] + C.2.4.1 [diff.offsetof] + C.2.4.2 [diff.malloc] +D [depr] + D.1 [depr.incr.bool] + D.2 [depr.static] + D.3 [depr.access.dcl] + D.4 [depr.string] + D.5 [depr.c.headers] + D.6 [depr.ios.members] + D.7 [depr.str.strstreams] + D.7.1 [depr.strstreambuf] + D.7.1.1 [depr.strstreambuf.cons] + D.7.1.2 [depr.strstreambuf.members] + D.7.1.3 [depr.strstreambuf.virtuals] + D.7.2 [depr.istrstream] + D.7.2.1 [depr.istrstream.cons] + D.7.2.2 [depr.istrstream.members] + D.7.3 [depr.ostrstream] + D.7.3.1 [depr.ostrstream.cons] + D.7.3.2 [depr.ostrstream.members] + D.7.4 [depr.strstream] + D.7.4.1 [depr.strstream.cons] + D.7.4.2 [depr.strstream.dest] + D.7.4.3 [depr.strstream.oper] + D.8 [depr.lib.binders] + D.8.1 [depr.lib.binder.1st] + D.8.2 [depr.lib.bind.1st] + D.8.3 [depr.lib.binder.2nd] + D.8.4 [depr.lib.bind.2nd] + D.9 [depr.auto.ptr] + D.9.1 [auto.ptr] + D.9.1.1 [auto.ptr.cons] + D.9.1.2 [auto.ptr.members] + D.9.1.3 [auto.ptr.conv] + D.10 [depr.lib.iterator.primitives] + D.10.1 [iterator.traits] + D.10.2 [iterator.basic] + D.10.3 [std.iterator.tags] + D.10.4 [iterator.backward] +E [xref] +X [garbage.collection] + +TR1 1 [tr.intro] + TR1 1.1 [tr.description] + TR1 1.2 [tr.intro.ext] + TR1 1.3 [tr.intro.namespaces] +TR1 2 [tr.util] + TR1 2.1 [tr.util.refwrap] + TR1 2.1.1 [tr.util.refwrp.synopsis] + TR1 2.1.2 [tr.util.refwrp.refwrp] + TR1 2.1.2.1 [tr.util.refwrp.const] + TR1 2.1.2.2 [tr.util.refwrp.assign] + TR1 2.1.2.3 [tr.util.refwrp.access] + TR1 2.1.2.4 [tr.util.refwrp.invoke] + TR1 2.1.2.5 [tr.util.refwrp.helpers] + TR1 2.2 [tr.util.smartptr] + TR1 2.2.1 [tr.util.smartptr.synopsis] + TR1 2.2.2 [tr.util.smartptr.weakptr] + TR1 2.2.3 [tr.util.smartptr.shared] + TR1 2.2.3.1 [tr.util.smartptr.shared.const] + TR1 2.2.3.2 [tr.util.smartptr.shared.dest] + TR1 2.2.3.3 [tr.util.smartptr.shared.assign] + TR1 2.2.3.4 [tr.util.smartptr.shared.mod] + TR1 2.2.3.5 [tr.util.smartptr.shared.obs] + TR1 2.2.3.6 [tr.util.smartptr.shared.cmp] + TR1 2.2.3.7 [tr.util.smartptr.shared.io] + TR1 2.2.3.8 [tr.util.smartptr.shared.spec] + TR1 2.2.3.9 [tr.util.smartptr.shared.cast] + TR1 2.2.3.10 [tr.util.smartptr.getdeleter] + TR1 2.2.4 [tr.util.smartptr.weak] + TR1 2.2.4.1 [tr.util.smartptr.weak.const] + TR1 2.2.4.2 [tr.util.smartptr.weak.dest] + TR1 2.2.4.3 [tr.util.smartptr.weak.assign] + TR1 2.2.4.4 [tr.util.smartptr.weak.mod] + TR1 2.2.4.5 [tr.util.smartptr.weak.obs] + TR1 2.2.4.6 [tr.util.smartptr.weak.cmp] + TR1 2.2.4.7 [tr.util.smartptr.weak.spec] + TR1 2.2.5 [tr.util.smartptr.enab] +TR1 3 [tr.func] + TR1 3.1 [tr.func.def] + TR1 3.2 [tr.func.syn] + TR1 3.3 [tr.func.require] + TR1 3.4 [tr.func.ret] + TR1 3.5 [tr.func.memfn] + TR1 3.6 [tr.func.bind] + TR1 3.6.1 [tr.func.bind.isbind] + TR1 3.6.2 [tr.func.bind.isplace] + TR1 3.6.3 [tr.func.bind.bind] + TR1 3.6.4 [tr.func.bind.place] + TR1 3.7 [tr.func.wrap] + TR1 3.7.1 [tr.func.wrap.badcall] + TR1 3.7.1.1 [tr.func.wrap.badcall.const] + TR1 3.7.2 [tr.func.wrap.func] + TR1 3.7.2.1 [tr.func.wrap.func.con] + TR1 3.7.2.2 [tr.func.wrap.func.mod] + TR1 3.7.2.3 [tr.func.wrap.func.cap] + TR1 3.7.2.4 [tr.func.wrap.func.inv] + TR1 3.7.2.5 [tr.func.wrap.func.targ] + TR1 3.7.2.6 [tr.func.wrap.func.undef] + TR1 3.7.2.7 [tr.func.wrap.func.nullptr] + TR1 3.7.2.8 [tr.func.wrap.func.alg] +TR1 4 [tr.meta] + TR1 4.1 [tr.meta.rqmts] + TR1 4.2 [tr.meta.type.synop] + TR1 4.3 [tr.meta.help] + TR1 4.4 [tr.meta.requirements] + TR1 4.5 [tr.meta.unary] + TR1 4.5.1 [tr.meta.unary.cat] + TR1 4.5.2 [tr.meta.unary.comp] + TR1 4.5.3 [tr.meta.unary.prop] + TR1 4.6 [tr.meta.rel] + TR1 4.7 [tr.meta.trans] + TR1 4.7.1 [tr.meta.trans.cv] + TR1 4.7.2 [tr.meta.trans.ref] + TR1 4.7.3 [tr.meta.trans.arr] + TR1 4.7.4 [tr.meta.trans.ptr] + TR1 4.8 [tr.meta.trans.other] + TR1 4.9 [tr.meta.req] +TR1 5 [tr.num] + TR1 5.1 [tr.rand] + TR1 5.1.1 [tr.rand.req] + TR1 5.1.2 [tr.rand.synopsis] + TR1 5.1.3 [tr.rand.var] + TR1 5.1.4 [tr.rand.eng] + TR1 5.1.4.1 [tr.rand.eng.lcong] + TR1 5.1.4.2 [tr.rand.eng.mers] + TR1 5.1.4.3 [tr.rand.eng.sub] + TR1 5.1.4.4 [tr.rand.eng.sub1] + TR1 5.1.4.5 [tr.rand.eng.disc] + TR1 5.1.4.6 [tr.rand.eng.xor] + TR1 5.1.5 [tr.rand.predef] + TR1 5.1.6 [tr.rand.device] + TR1 5.1.7 [tr.rand.dist] + TR1 5.1.7.1 [tr.rand.dist.iunif] + TR1 5.1.7.2 [tr.rand.dist.bern] + TR1 5.1.7.3 [tr.rand.dist.geom] + TR1 5.1.7.4 [tr.rand.dist.pois] + TR1 5.1.7.5 [tr.rand.dist.bin] + TR1 5.1.7.6 [tr.rand.dist.runif] + TR1 5.1.7.7 [tr.rand.dist.exp] + TR1 5.1.7.8 [tr.rand.dist.norm] + TR1 5.1.7.9 [tr.rand.dist.gamma] + TR1 5.2 [tr.num.sf] + TR1 5.2.1 [tr.num.sf.cmath] + TR1 5.2.1.1 [tr.num.sf.Lnm] + TR1 5.2.1.2 [tr.num.sf.Plm] + TR1 5.2.1.3 [tr.num.sf.beta] + TR1 5.2.1.4 [tr.num.sf.ellK] + TR1 5.2.1.5 [tr.num.sf.ellEx] + TR1 5.2.1.6 [tr.num.sf.ellPx] + TR1 5.2.1.7 [tr.num.sf.conhyp] + TR1 5.2.1.8 [tr.num.sf.I] + TR1 5.2.1.9 [tr.num.sf.J] + TR1 5.2.1.10 [tr.num.sf.K] + TR1 5.2.1.11 [tr.num.sf.N] + TR1 5.2.1.12 [tr.num.sf.ellF] + TR1 5.2.1.13 [tr.num.sf.ellE] + TR1 5.2.1.14 [tr.num.sf.ellP] + TR1 5.2.1.15 [tr.num.sf.ei] + TR1 5.2.1.16 [tr.num.sf.Hn] + TR1 5.2.1.17 [tr.num.sf.hyper] + TR1 5.2.1.18 [tr.num.sf.Ln] + TR1 5.2.1.19 [tr.num.sf.Pl] + TR1 5.2.1.20 [tr.num.sf.riemannzeta] + TR1 5.2.1.21 [tr.num.sf.j] + TR1 5.2.1.22 [tr.num.sf.Ylm] + TR1 5.2.1.23 [tr.num.sf.n] + TR1 5.2.2 [tr.num.sf.mathh] +TR1 6 [tr.cont] + TR1 6.1 [tr.tuple] + TR1 6.1.1 [tr.tuple.synopsis] + TR1 6.1.2 [tr.tuple.synopsis.pair] + TR1 6.1.3 [tr.tuple.tuple] + TR1 6.1.3.1 [tr.tuple.cnstr] + TR1 6.1.3.2 [tr.tuple.creation] + TR1 6.1.3.3 [tr.tuple.helper] + TR1 6.1.3.4 [tr.tuple.elem] + TR1 6.1.3.5 [tr.tuple.rel] + TR1 6.1.4 [tr.tuple.pairs] + TR1 6.2 [tr.array] + TR1 6.2.1 [tr.array.syn] + TR1 6.2.2 [tr.array.array] + TR1 6.2.2.1 [tr.array.cons] + TR1 6.2.2.2 [tr.array.special] + TR1 6.2.2.3 [tr.array.size] + TR1 6.2.2.4 [tr.array.zero] + TR1 6.2.2.5 [tr.array.tuple] + TR1 6.3 [tr.hash] + TR1 6.3.1 [tr.unord.req] + TR1 6.3.1.1 [tr.unord.req.except] + TR1 6.3.2 [tr.unord.fun.syn] + TR1 6.3.3 [tr.unord.hash] + TR1 6.3.4 [tr.unord.unord] + TR1 6.3.4.1 [tr.unord.syn.set] + TR1 6.3.4.2 [tr.unord.syn.map] + TR1 6.3.4.3 [tr.unord.set] + TR1 6.3.4.3.1 [tr.unord.set.cnstr] + TR1 6.3.4.3.2 [tr.unord.set.swap] + TR1 6.3.4.4 [tr.unord.map] + TR1 6.3.4.4.1 [tr.unord.map.cnstr] + TR1 6.3.4.4.2 [tr.unord.map.elem] + TR1 6.3.4.4.3 [tr.unord.map.swap] + TR1 6.3.4.5 [tr.unord.multiset] + TR1 6.3.4.5.1 [tr.unord.multiset.cnstr] + TR1 6.3.4.5.2 [tr.unord.multiset.swap] + TR1 6.3.4.6 [tr.unord.multimap] + TR1 6.3.4.6.1 [tr.unord.multimap.cnstr] + TR1 6.3.4.6.2 [tr.unord.multimap.swap] +TR1 7 [tr.re] + TR1 7.1 [tr.re.def] + TR1 7.2 [tr.re.req] + TR1 7.3 [tr.re.sum] + TR1 7.4 [tr.re.syn] + TR1 7.5 [tr.re.const] + TR1 7.5.1 [tr.re.synopt] + TR1 7.5.2 [tr.re.matchflag] + TR1 7.5.3 [tr.re.err] + TR1 7.6 [tr.re.badexp] + TR1 7.7 [tr.re.traits] + TR1 7.8 [tr.re.regex] + TR1 7.8.1 [tr.re.regex.const] + TR1 7.8.2 [tr.re.regex.construct] + TR1 7.8.3 [tr.re.regex.assign] + TR1 7.8.4 [tr.re.regex.operations] + TR1 7.8.5 [tr.re.regex.locale] + TR1 7.8.6 [tr.re.regex.swap] + TR1 7.8.7 [tr.re.regex.nonmemb] + TR1 7.8.7.1 [tr.re.regex.nmswap.] + TR1 7.9 [tr.re.submatch] + TR1 7.9.1 [tr.re.submatch.members] + TR1 7.9.2 [tr.re.submatch.op] + TR1 7.10 [tr.re.results] + TR1 7.10.1 [tr.re.results.const] + TR1 7.10.2 [tr.re.results.size] + TR1 7.10.3 [tr.re.results.acc] + TR1 7.10.4 [tr.re.results.form] + TR1 7.10.5 [tr.re.results.all] + TR1 7.10.1 [tr.re.results.swap] + TR1 7.11 [tr.re.alg] + TR1 7.11.1 [tr.re.except] + TR1 7.11.2 [tr.re.alg.match] + TR1 7.11.3 [tr.re.alg.search] + TR1 7.11.4 [tr.re.alg.replace] + TR1 7.12 [tr.re.iter] + TR1 7.12.1 [tr.re.regiter] + TR1 7.12.1.1 [tr.re.regiter.cnstr] + TR1 7.12.1.2 [tr.re.regiter.comp] + TR1 7.12.1.3 [tr.re.regiter.deref] + TR1 7.12.1.4 [tr.re.regiter.incr] + TR1 7.12.2 [tr.re.tokiter] + TR1 7.12.2.1 [tr.re.tokiter.cnstr] + TR1 7.12.2.2 [tr.re.tokiter.comp] + TR1 7.12.2.3 [tr.re.tokiter.deref] + TR1 7.12.2.4 [tr.re.tokiter.incr] + TR1 7.13 [tr.re.grammar] +TR1 8 [tr.c99] + TR1 8.1 [tr.c99.cmplx] + TR1 8.1.1 [tr.c99.cmplx.syn] + TR1 8.1.2 [tr.c99.cmplx.acos] + TR1 8.1.3 [tr.c99.cmplx.asin] + TR1 8.1.4 [tr.c99.cmplx.atan] + TR1 8.1.5 [tr.c99.cmplx.acosh] + TR1 8.1.6 [tr.c99.cmplx.asinh] + TR1 8.1.7 [tr.c99.cmplx.atanh] + TR1 8.1.8 [tr.c99.cmplx.fabs] + TR1 8.1.9 [tr.c99.cmplx.over] + TR1 8.2 [tr.c99.ccmplx] + TR1 8.3 [tr.c99.cmplxh] + TR1 8.4 [tr.c99.cctype] + TR1 8.4.1 [tr.c99.cctype.syn] + TR1 8.4.2 [tr.c99.cctype.blank] + TR1 8.5 [tr.c99.ctypeh] + TR1 8.6 [tr.c99.cfenv] + TR1 8.6.1 [tr.c99.cfenv.syn] + TR1 8.6.2 [tr.c99.cfenv.def] + TR1 8.7 [tr.c99.fenv] + TR1 8.8 [tr.c99.cfloat] + TR1 8.9 [tr.c99.floath] + TR1 8.10 [tr.c99.ios] + TR1 8.10.1 [tr.c99.ios.syn] + TR1 8.10.2 [tr.c99.ios.hex] + TR1 8.11 [tr.c99.cinttypes] + TR1 8.11.1 [tr.c99.cinttypes.syn] + TR1 8.11.2 [tr.c99.cinttypes.def] + TR1 8.12 [tr.c99.inttypesh] + TR1 8.13 [tr.c99.climits] + TR1 8.14 [tr.c99.limitsh] + TR1 8.15 [tr.c99.locale] + TR1 8.16 [tr.c99.cmath] + TR1 8.16.1 [tr.c99.cmath.syn] + TR1 8.16.2 [tr.c99.cmath.def] + TR1 8.16.3 [tr.c99.cmath.tmpl] + TR1 8.16.4 [tr.c99.cmath.over] + TR1 8.17 [tr.c99.mathh] + TR1 8.18 [tr.c99.cstdarg] + TR1 8.19 [tr.c99.stdargh] + TR1 8.20 [tr.c99.cbool] + TR1 8.21 [tr.c99.boolh] + TR1 8.22 [tr.c99.cstdint] + TR1 8.22.1 [tr.c99.cstdint.syn] + TR1 8.22.2 [tr.c99.cstdint.def] + TR1 8.23 [tr.c99.stdinth] + TR1 8.24 [tr.c99.cstdio] + TR1 8.24.1 [tr.c99.cstdio.syn] + TR1 8.24.2 [tr.c99.cstdio.def] + TR1 8.24.3 [tr.c99.cstdio.spec] + TR1 8.24.4 [tr.c99.stdioh] + TR1 8.25 [tr.c99.cstdlib] + TR1 8.25.1 [tr.c99.cstdlib.syn] + TR1 8.25.2 [tr.c99.cstdlib.def] + TR1 8.25.3 [tr.c99.cstdlib.abs] + TR1 8.25.4 [tr.c99.cstdlib.div] + TR1 8.26 [tr.c99.stdlibh] + TR1 8.27 [tr.c99.ctgmath] + TR1 8.28 [tr.c99.tgmathh] + TR1 8.29 [tr.c99.ctime] + TR1 8.30 [tr.c99.cwchar] + TR1 8.30.1 [tr.c99.cwchar.syn] + TR1 8.30.2 [tr.c99.cwchar.def] + TR1 8.30.3 [tr.c99.cwchar.spec] + TR1 8.31 [tr.c99.wcharh] + TR1 8.32 [tr.c99.cwctype] + TR1 8.32.1 [tr.c99.cwctype.syn] + TR1 8.32.2 [tr.c99.cwctype.iswblank] + TR1 8.33 [tr.c99.wctypeh] +TR1 A [tr.limits] + +TRDecimal 1 [trdec.intro] + TRDecimal 1.1 [trdec.model] + TRDecimal 1.2 [trdec.encodings] + TRDecimal 1.3 [trdec.refs] +TRDecimal 2 [trdec.conventions] + TRDecimal 2.1 [trdec.relation.intro] + TRDecimal 2.2 [trdec.relation.tr1] + TRDecimal 2.3 [trdec.categories] + TRDecimal 2.4 [trdec.namespace] +TRDecimal 3 [trdec.types] + TRDecimal 3.1 [trdec.types.encodings] + TRDecimal 3.2 [trdec.types.types] + TRDecimal 3.2.1 [trdec.types.types.synopsis] + TRDecimal 3.2.2 [trdec.types.types.decimal32] + TRDecimal 3.2.2.1 [trdec.types.types.decimal32.cons] + TRDecimal 3.2.2.2 [trdec.types.types.decimal32.conv.float] + TRDecimal 3.2.2.3 [trdec.types.types.decimal32.conv.from.int] + TRDecimal 3.2.2.4 [trdec.types.types.decimal32.conv.to.int] + TRDecimal 3.2.2.5 [trdec.types.types.decimal32.incr] + TRDecimal 3.2.2.6 [trdec.types.types.decimal32.comp.ass] + TRDecimal 3.2.3 [trdec.types.types.decimal64] + TRDecimal 3.2.3.1 [trdec.types.types.decimal64.cons] + TRDecimal 3.2.3.2 [trdec.types.types.decimal64.float] + TRDecimal 3.2.3.3 [trdec.types.types.decimal64.from.int] + TRDecimal 3.2.3.4 [trdec.types.types.decimal64.to.int] + TRDecimal 3.2.3.5 [trdec.types.types.decimal64.incr] + TRDecimal 3.2.3.6 [trdec.types.types.decimal64.comp.ass] + TRDecimal 3.2.4 [trdec.types.types.decimal128] + TRDecimal 3.2.4.1 [trdec.types.types.decimal128.cons] + TRDecimal 3.2.4.2 [trdec.types.types.decimal128.float] + TRDecimal 3.2.4.3 [trdec.types.types.decimal128.from.int] + TRDecimal 3.2.4.4 [trdec.types.types.decimal128.to.int] + TRDecimal 3.2.4.5 [trdec.types.types.decimal128.incr] + TRDecimal 3.2.4.6 [trdec.types.types.decimal128.comp.ass] + TRDecimal 3.2.5 [trdec.types.types.init] + TRDecimal 3.2.6 [trdec.types.types.conv.float] + TRDecimal 3.2.7 [trdec.types.types.unary] + TRDecimal 3.2.8 [trdec.types.types.binary] + TRDecimal 3.2.9 [trdec.types.types.comp] + TRDecimal 3.2.10 [trdec.types.types.input] + TRDecimal 3.2.11 [trdec.types.types.output] + TRDecimal 3.3 [trdec.types.limits] + TRDecimal 3.4 [trdec.types.cdecfloat] + TRDecimal 3.4.1 [trdec.types.cdecfloat.synopsis] + TRDecimal 3.4.2 [trdec.types.decfloat.h.synopsis] + TRDecimal 3.4.3 [trdec.types.cdecfloat.max.value] + TRDecimal 3.4.4 [trdec.types.cdecfloat.epsilon] + TRDecimal 3.4.5 [trdec.types.cdecfloat.min.normal.value] + TRDecimal 3.4.6 [trdec.types.cdecfloat.min.subnormal.value] + TRDecimal 3.4.7 [trdec.types.cdecfloat.eval.format] + TRDecimal 3.5 [trdec.types.cfenv] + TRDecimal 3.5.1 [trdec.types.cfenv.synopsis] + TRDecimal 3.5.2 [trdec.types.cfenv.round] + TRDecimal 3.5.3 [trdec.types.cfenv.fe_dec_getround] + TRDecimal 3.5.4 [trdec.types.cfenv.fe_dec_setround] + TRDecimal 3.5.5 [trdec.types.cfenv.fenv.h] + TRDecimal 3.6 [trdec.types.cmath] + TRDecimal 3.6.1 [trdec.types.cmath.synopsis] + TRDecimal 3.6.2 [trdec.types.cmath.macros] + TRDecimal 3.6.3 [trdec.types.cmath.eval.format] + TRDecimal 3.6.4 [trdec.types.cmath.samequantum] + TRDecimal 3.6.5 [trdec.types.cmath.quantize] + TRDecimal 3.6.6 [trdec.types.cmath.elementary] + TRDecimal 3.6.6.1 [trdec.types.cmath.elementary.abs] + TRDecimal 3.6.7 [trdec.types.cmath.math.h] + TRDecimal 3.6.7.1 [trdec.types.cmath.math.h.synopsis] + TRDecimal 3.7 [trdec.types.cstdio] + TRDecimal 3.8 [trdec.types.cstdlib] + TRDecimal 3.8.1 [trdec.types.cstdlib.synopsis] + TRDecimal 3.8.2 [trdec.types.cstdlib.strtod] + TRDecimal 3.8.3 [trdec.types.cstdlib.stdlib.h] + TRDecimal 3.9 [trdec.types.cwchar] + TRDecimal 3.9.1 [trdec.types.cwchar.synopsis] + TRDecimal 3.9.2 [trdec.types.cwchar.wcstod] + TRDecimal 3.9.3 [trdec.types.cwchar.wchar.h] + TRDecimal 3.10 [trdec.types.facets] + TRDecimal 3.10.1 [trdec.types.facets.locale] + TRDecimal 3.10.2 [trdec.types.facets.extended_num_get] + TRDecimal 3.10.2.1 [trdec.types.facets.extended_num_get.mem] + TRDecimal 3.10.2.2 [trdec.types.facets.extended_num_get.virt] + TRDecimal 3.10.3 [trdec.types.facets.extended_num_put] + TRDecimal 3.10.3.1 [trdec.types.facets.extended_num_put.mem] + TRDecimal 3.10.3.2 [trdec.types.facets.extended_num_put.virt] + TRDecimal 3.11 [trdec.types.traits] + TRDecimal 3.11.1 [trdec.types.traits.synopsis] + TRDecimal 3.11.2 [trdec.types.traits.is_decimal_floating_point] + TRDecimal 3.12 [trdec.types.hash] + TRDecimal 3.12.1 [trdec.types.hash.synopsis] + TRDecimal 3.12.2 [trdec.types.hash.spec] +TRDecimal 4 [trdec.compat] + TRDecimal 4.1 [trdec.compat.decfloat.h] + TRDecimal 4.2 [trdec.compat.literals] + TRDecimal 4.3 [trdec.compat.conv] diff --git a/test/make_test_dirs.pl b/test/make_test_dirs.pl new file mode 100755 index 000000000000..3a524d2adb1b --- /dev/null +++ b/test/make_test_dirs.pl @@ -0,0 +1,27 @@ +#!/usr/bin/perl -w +# +# Simple little Perl script that takes the cxx-sections.data file as +# input and generates a directory structure that mimics the standard's +# structure. +use English; + +$current_indent_level = -4; +while ($line = <STDIN>) { + $line =~ /^\s*/; + $next_indent_level = length($MATCH); + if ($line =~ /\[([^\]]*)\]/) { + my $section = $1; + while ($next_indent_level < $current_indent_level) { + chdir(".."); + $current_indent_level -= 4; + } + + if ($next_indent_level == $current_indent_level) { + chdir(".."); + } else { + $current_indent_level = $next_indent_level; + } + mkdir($section); + chdir($section); + } +} |