Split (1)

train · 141k rows

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.

repo_id stringlengths 5 186	file_path stringlengths 15 223	content stringlengths 1 32.8M ⌀
repos/DirectXShaderCompiler/tools/clang/test	repos/DirectXShaderCompiler/tools/clang/test/Preprocessor/disabled-cond-diags2.c	// RUN: %clang_cc1 -Eonly -verify %s #if 0 #if 1 #endif junk // shouldn't produce diagnostics #endif #if 0 #endif junk // expected-warning{{extra tokens at end of #endif directive}} #if 1 junk // expected-error{{token is not a valid binary operator in a preprocessor subexpression}} #X // shouldn't produce diagnostics (block #if condition not valid, so skipped) #else #X // expected-error{{invalid preprocessing directive}} #endif #if 0 // diagnostics should not be produced until final #endif #X #include #if 1 junk #else junk #endif junk #line -2 #error #warning #endif junk // expected-warning{{extra tokens at end of #endif directive}}
repos/DirectXShaderCompiler/tools/clang/test	repos/DirectXShaderCompiler/tools/clang/test/Preprocessor/dump_macros.c	// RUN: %clang_cc1 -E -dM %s -o - \| FileCheck %s -strict-whitespace // Space at end even without expansion tokens // CHECK: #define A(x) #define A(x) // Space before expansion list. // CHECK: #define B(x,y) x y #define B(x,y)x y // No space in argument list. // CHECK: #define C(x,y) x y #define C(x, y) x y // No paste avoidance. // CHECK: #define D() .. #define D() .. // Simple test. // CHECK: #define E . // CHECK: #define F X()Y #define E . #define F X()Y // gcc prints macros at end of translation unit, so last one wins. // CHECK: #define G 2 #define G 1 #undef G #define G 2 // Variadic macros of various sorts. PR5699 // CHECK: H(x,...) __VA_ARGS__ #define H(x, ...) __VA_ARGS__ // CHECK: I(...) __VA_ARGS__ #define I(...) __VA_ARGS__ // CHECK: J(x...) __VA_ARGS__ #define J(x ...) __VA_ARGS__
repos/DirectXShaderCompiler/tools/clang/test	repos/DirectXShaderCompiler/tools/clang/test/Preprocessor/pr2086.c	// RUN: %clang_cc1 -E %s #define test #include "pr2086.h" #define test #include "pr2086.h" #ifdef test #error #endif
repos/DirectXShaderCompiler/tools/clang/test	repos/DirectXShaderCompiler/tools/clang/test/Preprocessor/macro_misc.c	// RUN: %clang_cc1 %s -Eonly -verify // This should not be rejected. #ifdef defined #endif // PR3764 // This should not produce a redefinition warning. #define FUNC_LIKE(a) (a) #define FUNC_LIKE(a)(a) // This either. #define FUNC_LIKE2(a)\ (a) #define FUNC_LIKE2(a) (a) // This should. #define FUNC_LIKE3(a) ( a) // expected-note {{previous definition is here}} #define FUNC_LIKE3(a) (a) // expected-warning {{'FUNC_LIKE3' macro redefined}} // RUN: %clang_cc1 -fms-extensions -DMS_EXT %s -Eonly -verify #ifndef MS_EXT // This should under C99. #define FUNC_LIKE4(a,b) (a+b) // expected-note {{previous definition is here}} #define FUNC_LIKE4(x,y) (x+y) // expected-warning {{'FUNC_LIKE4' macro redefined}} #else // This shouldn't under MS extensions. #define FUNC_LIKE4(a,b) (a+b) #define FUNC_LIKE4(x,y) (x+y) // This should. #define FUNC_LIKE5(a,b) (a+b) // expected-note {{previous definition is here}} #define FUNC_LIKE5(x,y) (y+x) // expected-warning {{'FUNC_LIKE5' macro redefined}} #endif
repos/DirectXShaderCompiler/tools/clang/test	repos/DirectXShaderCompiler/tools/clang/test/Preprocessor/microsoft-ext.c	// RUN: %clang_cc1 -E -fms-compatibility %s -o %t // RUN: FileCheck %s < %t # define M2(x, y) x + y # define P(x, y) {x, y} # define M(x, y) M2(x, P(x, y)) M(a, b) // CHECK: a + {a, b} // Regression test for PR13924 #define GTEST_CONCAT_TOKEN_(foo, bar) GTEST_CONCAT_TOKEN_IMPL_(foo, bar) #define GTEST_CONCAT_TOKEN_IMPL_(foo, bar) foo ## bar #define GMOCK_INTERNAL_COUNT_AND_2_VALUE_PARAMS(p0, p1) P2 #define GMOCK_ACTION_CLASS_(name, value_params)\ GTEST_CONCAT_TOKEN_(name##Action, GMOCK_INTERNAL_COUNT_##value_params) #define ACTION_TEMPLATE(name, template_params, value_params)\ class GMOCK_ACTION_CLASS_(name, value_params) {\ } ACTION_TEMPLATE(InvokeArgument, HAS_1_TEMPLATE_PARAMS(int, k), AND_2_VALUE_PARAMS(p0, p1)); // This tests compatibility with behaviour needed for type_traits in VS2012 // Test based on _VARIADIC_EXPAND_0X macros in xstddef of VS2012 #define _COMMA , #define MAKER(_arg1, _comma, _arg2) \ void func(_arg1 _comma _arg2) {} #define MAKE_FUNC(_makerP1, _makerP2, _arg1, _comma, _arg2) \ _makerP1##_makerP2(_arg1, _comma, _arg2) MAKE_FUNC(MAK, ER, int a, _COMMA, int b); // CHECK: void func(int a , int b) {}
repos/DirectXShaderCompiler/tools/clang/test	repos/DirectXShaderCompiler/tools/clang/test/Preprocessor/macro-reserved-ms.c	// RUN: %clang_cc1 -fsyntax-only -fms-extensions -verify %s // expected-no-diagnostics #define inline _inline #undef inline int x;
repos/DirectXShaderCompiler/tools/clang/test	repos/DirectXShaderCompiler/tools/clang/test/Preprocessor/header_lookup1.c	// RUN: %clang_cc1 %s -E \| grep 'stddef.h.*3' #include <stddef.h>
repos/DirectXShaderCompiler/tools/clang/test	repos/DirectXShaderCompiler/tools/clang/test/Preprocessor/cxx_oper_spelling.cpp	// RUN: %clang_cc1 -E %s \| FileCheck %s #define X(A) #A // C++'03 2.5p2: "In all respects of the language, each alternative // token behaves the same, respectively, as its primary token, // except for its spelling" // // This should be spelled as 'and', not '&&' a: X(and) // CHECK: a: "and"
repos/DirectXShaderCompiler/tools/clang/test	repos/DirectXShaderCompiler/tools/clang/test/Preprocessor/macro_fn_preexpand.c	// RUN: %clang_cc1 %s -E \| grep 'pre: 1 1 X' // RUN: %clang_cc1 %s -E \| grep 'nopre: 1A(X)' /* Preexpansion of argument. / #define A(X) 1 X pre: A(A(X)) / The ## operator disables preexpansion. */ #undef A #define A(X) 1 ## X nopre: A(A(X))
repos/DirectXShaderCompiler/tools/clang/test	repos/DirectXShaderCompiler/tools/clang/test/Preprocessor/pr13851.c	// Check that -E -M -MF does not cause an "argument unused" error, by adding // -Werror to the clang invocation. Also check the dependency output, if any. // RUN: %clang -Werror -E -M -MF %t-M.d %s // RUN: FileCheck --input-file=%t-M.d %s // CHECK: pr13851.o: // CHECK: pr13851.c // Check that -E -MM -MF does not cause an "argument unused" error, by adding // -Werror to the clang invocation. Also check the dependency output, if any. // RUN: %clang -Werror -E -MM -MF %t-MM.d %s // RUN: FileCheck --input-file=%t-MM.d %s
repos/DirectXShaderCompiler/tools/clang/test	repos/DirectXShaderCompiler/tools/clang/test/Preprocessor/macro_paste_msextensions.c	// RUN: not %clang_cc1 -P -E -fms-extensions %s \| FileCheck -strict-whitespace %s // This horrible stuff should preprocess into (other than whitespace): // int foo; // int bar; // int baz; int foo; // CHECK: int foo; #define comment /##/ dead tokens live here comment This is stupidity int bar; // CHECK: int bar; #define nested(x) int x comment cute little dead tokens... nested(baz) rise of the dead tokens ; // CHECK: int baz // CHECK: ; // rdar://8197149 - VC++ allows invalid token pastes: (##baz #define foo(x) abc(x) #define bar(y) foo(##baz(y)) bar(q) // CHECK: abc(baz(q)) #define str(x) #x #define collapse_spaces(a, b, c, d) str(a ## - ## b ## - ## c ## d) collapse_spaces(1a, b2, 3c, d4) // CHECK: "1a-b2-3cd4"
repos/DirectXShaderCompiler/tools/clang/test	repos/DirectXShaderCompiler/tools/clang/test/Preprocessor/macro_redefined.c	// RUN: %clang_cc1 %s -Eonly -verify -Wno-all -Wmacro-redefined -DCLI_MACRO=1 -DWMACRO_REDEFINED // RUN: %clang_cc1 %s -Eonly -verify -Wno-all -Wno-macro-redefined -DCLI_MACRO=1 #ifndef WMACRO_REDEFINED // expected-no-diagnostics #endif #ifdef WMACRO_REDEFINED // expected-note@1 {{previous definition is here}} // expected-warning@+2 {{macro redefined}} #endif #define CLI_MACRO #ifdef WMACRO_REDEFINED // expected-note@+3 {{previous definition is here}} // expected-warning@+3 {{macro redefined}} #endif #define REGULAR_MACRO #define REGULAR_MACRO 1
repos/DirectXShaderCompiler/tools/clang/test	repos/DirectXShaderCompiler/tools/clang/test/Preprocessor/macro_rparen_scan2.c	// RUN: %clang_cc1 -E %s \| FileCheck -strict-whitespace %s #define R_PAREN ) #define FUNC(a) a static int glob = (1 + FUNC(1 R_PAREN ); // CHECK: static int glob = (1 + 1 );
repos/DirectXShaderCompiler/tools/clang/test	repos/DirectXShaderCompiler/tools/clang/test/Preprocessor/pragma-captured.c	// RUN: %clang_cc1 -E %s \| FileCheck %s // Test pragma clang __debug captured, for Captured Statements void test1() { #pragma clang __debug captured { } // CHECK: void test1() // CHECK: { // CHECK: #pragma clang __debug captured }
repos/DirectXShaderCompiler/tools/clang/test	repos/DirectXShaderCompiler/tools/clang/test/Preprocessor/expr_define_expansion.c	// RUN: %clang_cc1 %s -E -CC -pedantic -verify // expected-no-diagnostics #define FOO && 1 #if defined FOO FOO #endif
repos/DirectXShaderCompiler/tools/clang/test	repos/DirectXShaderCompiler/tools/clang/test/Preprocessor/expr_liveness.c	/* RUN: %clang_cc1 -E %s -DNO_ERRORS -Werror -Wundef RUN: not %clang_cc1 -E %s / #ifdef NO_ERRORS / None of these divisions by zero are in live parts of the expression, do not emit any diagnostics. / #define MACRO_0 0 #define MACRO_1 1 #if MACRO_0 && 10 / MACRO_0 foo #endif #if MACRO_1 \|\| 10 / MACRO_0 bar #endif #if 0 ? 124/0 : 42 #endif // PR2279 #if 0 ? 1/0: 2 #else #error #endif // PR2279 #if 1 ? 2 ? 3 : 4 : 5 #endif // PR2284 #if 1 ? 0: 1 ? 1/0: 1/0 #endif #else / The 1/0 is live, it should error out. */ #if 0 && 1 ? 4 : 1 / 0 baz #endif #endif // rdar://6505352 // -Wundef should not warn about use of undefined identifier if not live. #if (!defined(XXX) \|\| XXX > 42) #endif
repos/DirectXShaderCompiler/tools/clang/test	repos/DirectXShaderCompiler/tools/clang/test/Preprocessor/macro_arg_slocentry_merge.c	// RUN: not %clang_cc1 -fsyntax-only %s 2>&1 \| FileCheck %s #include "macro_arg_slocentry_merge.h" // CHECK: macro_arg_slocentry_merge.h:7:19: error: unknown type name 'win' // CHECK: macro_arg_slocentry_merge.h:5:16: note: expanded from macro 'WINDOW' // CHECK: macro_arg_slocentry_merge.h:6:18: note: expanded from macro 'P_'
repos/DirectXShaderCompiler/tools/clang/test	repos/DirectXShaderCompiler/tools/clang/test/Preprocessor/microsoft-header-search.c	// RUN: %clang_cc1 -I%S/Inputs/microsoft-header-search %s -fms-compatibility -verify // expected-warning@Inputs/microsoft-header-search/a/findme.h:3 {{findme.h successfully included using MS search rules}} // expected-warning@Inputs/microsoft-header-search/a/b/include3.h:3 {{#include resolved using non-portable MSVC search rules as}} // expected-warning@Inputs/microsoft-header-search/falsepos.h:3 {{successfully resolved the falsepos.h header}} #include "Inputs/microsoft-header-search/include1.h"
repos/DirectXShaderCompiler/tools/clang/test	repos/DirectXShaderCompiler/tools/clang/test/Preprocessor/macro_fn_lparen_scan.c	// RUN: %clang_cc1 -E %s \| grep 'noexp: foo y' // RUN: %clang_cc1 -E %s \| grep 'expand: abc' // RUN: %clang_cc1 -E %s \| grep 'noexp2: foo nonexp' // RUN: %clang_cc1 -E %s \| grep 'expand2: abc' #define A foo #define foo() abc #define X A y // This should not expand to abc, because the foo macro isn't followed by (. noexp: X // This should expand to abc. #undef X #define X A () expand: X // This should be 'foo nonexp' noexp2: A nonexp // This should expand expand2: A ( )
repos/DirectXShaderCompiler/tools/clang/test	repos/DirectXShaderCompiler/tools/clang/test/Preprocessor/directive-invalid.c	// RUN: %clang_cc1 -E -verify %s // rdar://7683173 #define r_paren ) #if defined( x r_paren // expected-error {{missing ')' after 'defined'}} \ // expected-note {{to match this '('}} #endif
repos/DirectXShaderCompiler/tools/clang/test	repos/DirectXShaderCompiler/tools/clang/test/Preprocessor/assembler-with-cpp.c	// RUN: %clang_cc1 -x assembler-with-cpp -E %s -o - \| FileCheck -strict-whitespace -check-prefix=CHECK-Identifiers-False %s #ifndef __ASSEMBLER__ #error "__ASSEMBLER__ not defined" #endif // Invalid token pasting is ok. #define A X ## . 1: A // CHECK-Identifiers-False: 1: X . // Line markers are not linemarkers in .S files, they are passed through. # 321 // CHECK-Identifiers-False: # 321 // Unknown directives are passed through. # B C // CHECK-Identifiers-False: # B C // Unknown directives are expanded. #define D(x) BAR ## x # D(42) // CHECK-Identifiers-False: # BAR42 // Unmatched quotes are permitted. 2: ' 3: " // CHECK-Identifiers-False: 2: ' // CHECK-Identifiers-False: 3: " // (balance quotes to keep editors happy): "' // Empty char literals are ok. 4: '' // CHECK-Identifiers-False: 4: '' // Portions of invalid pasting should still expand as macros. // rdar://6709206 #define M4 expanded #define M5() M4 ## ( 5: M5() // CHECK-Identifiers-False: 5: expanded ( // rdar://6804322 #define FOO(name) name ## $foo 6: FOO(blarg) // CHECK-Identifiers-False: 6: blarg $foo // RUN: %clang_cc1 -x assembler-with-cpp -fdollars-in-identifiers -E %s -o - \| FileCheck -check-prefix=CHECK-Identifiers-True -strict-whitespace %s #define FOO(name) name ## $foo 7: FOO(blarg) // CHECK-Identifiers-True: 7: blarg$foo // #define T6() T6 #nostring #define T7(x) T7 #x 8: T6() 9: T7(foo) // CHECK-Identifiers-True: 8: T6 #nostring // CHECK-Identifiers-True: 9: T7 "foo" // Concatenation with period doesn't leave a space #define T8(A,B) A ## B 10: T8(.,T8) // CHECK-Identifiers-True: 10: .T8 // This should not crash. #define T11(a) #0 11: T11(b) // CHECK-Identifiers-True: 11: #0 // Universal character names can specify basic ascii and control characters 12: \u0020\u0030\u0080\u0000 // CHECK-Identifiers-False: 12: \u0020\u0030\u0080\u0000 // This should not crash // rdar://8823139 # ## // CHECK-Identifiers-False: # ## #define X(a) # # # 1 X(1) // CHECK-Identifiers-False: # # # 1
repos/DirectXShaderCompiler/tools/clang/test	repos/DirectXShaderCompiler/tools/clang/test/Preprocessor/invalid-__has_warning1.c	// RUN: %clang_cc1 -verify %s // These must be the last lines in this test. // expected-error@+1{{expected string literal}} expected-error@+1 2{{expected}} int i = __has_warning(
repos/DirectXShaderCompiler/tools/clang/test	repos/DirectXShaderCompiler/tools/clang/test/Preprocessor/include-macros.c	// RUN: %clang_cc1 -E -Dtest=FOO -imacros %S/pr2086.h %s \| grep 'HERE: test' // This should not be expanded into FOO because pr2086.h undefs 'test'. HERE: test
repos/DirectXShaderCompiler/tools/clang/test	repos/DirectXShaderCompiler/tools/clang/test/Preprocessor/traditional-cpp.c	/* Clang supports a very limited subset of -traditional-cpp, basically we only * intend to add support for things that people actually rely on when doing * things like using /usr/bin/cpp to preprocess non-source files. / / RUN: %clang_cc1 -traditional-cpp %s -E \| FileCheck -strict-whitespace %s RUN: %clang_cc1 -traditional-cpp %s -E -C \| FileCheck -check-prefix=CHECK-COMMENTS %s RUN: %clang_cc1 -traditional-cpp -x c++ %s -E \| FileCheck -check-prefix=CHECK-CXX %s / / -traditional-cpp should eliminate all C89 comments. / / CHECK-NOT: /* * CHECK-COMMENTS: {{^}}/* -traditional-cpp should eliminate all C89 comments. {{/$}} / /* -traditional-cpp should only eliminate "//" comments in C++ mode. / / CHECK: {{^}}foo // bar{{$}} * CHECK-CXX: {{^}}foo {{$}} / foo // bar / The lines in this file contain hard tab characters and trailing whitespace; * do not change them! / / CHECK: {{^}} indented!{{$}} * CHECK: {{^}}tab separated values{{$}} / indented! tab separated values #define bracket(x) >>>x<<< bracket(\| spaces \|) / CHECK: {{^}}>>>\| spaces \|<<<{{$}} / / This is still a preprocessing directive. / # define foo bar foo! - foo! foo! / CHECK: {{^}}bar!{{$}} * CHECK: {{^}} bar! bar! {{$}} / / Deliberately check a leading newline with spaces on that line. / # define foo bar foo! - foo! foo! / CHECK: {{^}}bar!{{$}} * CHECK: {{^}} bar! bar! {{$}} / / FIXME: -traditional-cpp should not consider this a preprocessing directive * because the # isn't in the first column. / #define foo2 bar foo2! / If this were working, both of these checks would be on. * CHECK-NOT: {{^}} #define foo2 bar{{$}} * CHECK-NOT: {{^}}foo2!{{$}} / / FIXME: -traditional-cpp should not homogenize whitespace in macros. / #define bracket2(x) >>> x <<< bracket2(spaces) / If this were working, this check would be on. * CHECK-NOT: {{^}}>>> spaces <<<{{$}} / / Check that #if 0 blocks work as expected / #if 0 #error "this is not an error" #if 1 a b c in skipped block #endif / Comments are whitespace too / #endif / CHECK-NOT: {{^}}a b c in skipped block{{$}} * CHECK-NOT: {{^}}/* Comments are whitespace too / Preserve URLs: http://clang.llvm.org / CHECK: {{^}}Preserve URLs: http://clang.llvm.org{{$}} / / The following tests ensure we ignore # and ## in macro bodies / #define FOO_NO_STRINGIFY(a) test(# a) FOO_NO_STRINGIFY(foobar) / CHECK: {{^}}test(# foobar){{$}} / #define FOO_NO_PASTE(a, b) test(b##a) FOO_NO_PASTE(foo,bar) / CHECK {{^}}test(bar##foo){{$}} / #define BAR_NO_STRINGIFY(a) test(#a) BAR_NO_STRINGIFY(foobar) / CHECK: {{^}}test(#foobar){{$}} */
repos/DirectXShaderCompiler/tools/clang/test	repos/DirectXShaderCompiler/tools/clang/test/Preprocessor/macro_fn.c	/* RUN: %clang_cc1 %s -Eonly -std=c89 -pedantic -verify / / PR3937 / #define zero() 0 / expected-note 2 {{defined here}} / #define one(x) 0 / expected-note 2 {{defined here}} / #define two(x, y) 0 / expected-note 4 {{defined here}} / #define zero_dot(...) 0 / expected-warning {{variadic macros are a C99 feature}} / #define one_dot(x, ...) 0 / expected-warning {{variadic macros are a C99 feature}} expected-note 2{{macro 'one_dot' defined here}} / zero() zero(1); / expected-error {{too many arguments provided to function-like macro invocation}} / zero(1, 2, 3); / expected-error {{too many arguments provided to function-like macro invocation}} / one() / ok / one(a) one(a,) / expected-error {{too many arguments provided to function-like macro invocation}} \ expected-warning {{empty macro arguments are a C99 feature}}/ one(a, b) / expected-error {{too many arguments provided to function-like macro invocation}} / two() / expected-error {{too few arguments provided to function-like macro invocation}} / two(a) / expected-error {{too few arguments provided to function-like macro invocation}} / two(a,b) two(a, ) / expected-warning {{empty macro arguments are a C99 feature}} / two(a,b,c) / expected-error {{too many arguments provided to function-like macro invocation}} / two( , / expected-warning {{empty macro arguments are a C99 feature}} / , / expected-warning {{empty macro arguments are a C99 feature}} \ expected-error {{too many arguments provided to function-like macro invocation}} / ) / expected-warning {{empty macro arguments are a C99 feature}} / two(,) / expected-warning 2 {{empty macro arguments are a C99 feature}} / / PR4006 & rdar://6807000 / #define e(...) __VA_ARGS__ / expected-warning {{variadic macros are a C99 feature}} / e(x) e() zero_dot() one_dot(x) / empty ... argument: expected-warning {{must specify at least one argument for '...' parameter of variadic macro}} / one_dot() / empty first argument, elided ...: expected-warning {{must specify at least one argument for '...' parameter of variadic macro}} / / rdar://6816766 - Crash with function-like macro test at end of directive. / #define E() (i == 0) #if E #endif / <rdar://problem/12292192> / #define NSAssert(condition, desc, ...) / expected-warning {{variadic macros are a C99 feature}} / \ SomeComplicatedStuff((desc), ##__VA_ARGS__) / expected-warning {{token pasting of ',' and __VA_ARGS__ is a GNU extension}} */ NSAssert(somecond, somedesc)
repos/DirectXShaderCompiler/tools/clang/test	repos/DirectXShaderCompiler/tools/clang/test/Preprocessor/c99-6_10_3_4_p5.c	// Example from C99 6.10.3.4p5 // RUN: %clang_cc1 -E %s \| FileCheck -strict-whitespace %s #define x 3 #define f(a) f(x * (a)) #undef x #define x 2 #define g f #define z z[0] #define h g(~ #define m(a) a(w) #define w 0,1 #define t(a) a #define p() int #define q(x) x #define r(x,y) x ## y #define str(x) # x f(y+1) + f(f(z)) % t(t(g)(0) + t)(1); g(x+(3,4)-w) \| h 5) & m (f)^m(m); p() i[q()] = { q(1), r(2,3), r(4,), r(,5), r(,) }; char c[2][6] = { str(hello), str() }; // CHECK: f(2 * (y+1)) + f(2 * (f(2 * (z[0])))) % f(2 * (0)) + t(1); // CHECK: f(2 * (2 +(3,4)-0,1)) \| f(2 * (~ 5)) & f(2 * (0,1))^m(0,1); // CHECK: int i[] = { 1, 23, 4, 5, }; // CHECK: char c[2][6] = { "hello", "" };
repos/DirectXShaderCompiler/tools/clang/test	repos/DirectXShaderCompiler/tools/clang/test/Preprocessor/cxx_true.cpp	/* RUN: %clang_cc1 -E %s -x c++ \| FileCheck -check-prefix CPP %s RUN: %clang_cc1 -E %s -x c \| FileCheck -check-prefix C %s RUN: %clang_cc1 -E %s -x c++ -verify -Wundef */ // expected-no-diagnostics #if true // CPP: test block_1 // C-NOT: test block_1 test block_1 #endif #if false // CPP-NOT: test block_2 // C-NOT: test block_2 test block_2 #endif
repos/DirectXShaderCompiler/tools/clang/test	repos/DirectXShaderCompiler/tools/clang/test/Preprocessor/comment_save_macro.c	// RUN: %clang_cc1 -E -C %s \| FileCheck -check-prefix=CHECK-C -strict-whitespace %s // CHECK-C: boo bork bar // zot // RUN: %clang_cc1 -E -CC %s \| FileCheck -check-prefix=CHECK-CC -strict-whitespace %s // CHECK-CC: boo bork /* blah*/ bar // zot // RUN: %clang_cc1 -E %s \| FileCheck -check-prefix=CHECK -strict-whitespace %s // CHECK: boo bork bar #define FOO bork // blah boo FOO bar // zot
repos/DirectXShaderCompiler/tools/clang/test	repos/DirectXShaderCompiler/tools/clang/test/Preprocessor/unterminated.c	// RUN: %clang_cc1 -E -verify %s // PR3096 #ifdef FOO // expected-error {{unterminated conditional directive}} /* /* */
repos/DirectXShaderCompiler/tools/clang/test	repos/DirectXShaderCompiler/tools/clang/test/Preprocessor/macro_backslash.c	// RUN: %clang_cc1 -E %s -Dfoo='bar\' \| FileCheck %s // CHECK: TTA bar\ TTB TTA foo TTB
repos/DirectXShaderCompiler/tools/clang/test	repos/DirectXShaderCompiler/tools/clang/test/Preprocessor/cxx_not.cpp	// RUN: %clang_cc1 -DA=1 -E %s \| grep 'int a = 927 == 927' // RUN: %clang_cc1 -E %s \| grep 'int a = 37 == 37' #if not defined(A) #define X 37 #else #define X 927 #endif #if ! defined(A) #define Y 37 #else #define Y 927 #endif int a = X == Y;
repos/DirectXShaderCompiler/tools/clang/test	repos/DirectXShaderCompiler/tools/clang/test/Preprocessor/skipping_unclean.c	// RUN: %clang_cc1 -E %s \| FileCheck --strict-whitespace %s #if 0 blah #\ else bark #endif // CHECK: {{^}}bark{{$}}
repos/DirectXShaderCompiler/tools/clang/test	repos/DirectXShaderCompiler/tools/clang/test/Preprocessor/macro_fn_comma_swallow2.c	// Test the __VA_ARGS__ comma swallowing extensions of various compiler dialects. // RUN: %clang_cc1 -E %s \| FileCheck -check-prefix=GCC -strict-whitespace %s // RUN: %clang_cc1 -E -std=c99 %s \| FileCheck -check-prefix=C99 -strict-whitespace %s // RUN: %clang_cc1 -E -std=c11 %s \| FileCheck -check-prefix=C99 -strict-whitespace %s // RUN: %clang_cc1 -E -x c++ %s \| FileCheck -check-prefix=GCC -strict-whitespace %s // RUN: %clang_cc1 -E -std=gnu99 %s \| FileCheck -check-prefix=GCC -strict-whitespace %s // RUN: %clang_cc1 -E -fms-compatibility %s \| FileCheck -check-prefix=MS -strict-whitespace %s // RUN: %clang_cc1 -E -DNAMED %s \| FileCheck -check-prefix=GCC -strict-whitespace %s // RUN: %clang_cc1 -E -std=c99 -DNAMED %s \| FileCheck -check-prefix=C99 -strict-whitespace %s #ifndef NAMED # define A(...) [ __VA_ARGS__ ] # define B(...) [ , __VA_ARGS__ ] # define C(...) [ , ## __VA_ARGS__ ] # define D(A,...) [ A , ## __VA_ARGS__ ] # define E(A,...) [ __VA_ARGS__ ## A ] #else // These are the GCC named argument versions of the C99-style variadic macros. // Note that __VA_ARGS__ may be used as the name, this is not prohibited! # define A(__VA_ARGS__...) [ __VA_ARGS__ ] # define B(__VA_ARGS__...) [ , __VA_ARGS__ ] # define C(__VA_ARGS__...) [ , ## __VA_ARGS__ ] # define D(A,__VA_ARGS__...) [ A , ## __VA_ARGS__ ] # define E(A,__VA_ARGS__...) [ __VA_ARGS__ ## A ] #endif 1: A() B() C() D() E() 2: A(a) B(a) C(a) D(a) E(a) 3: A(,) B(,) C(,) D(,) E(,) 4: A(a,b,c) B(a,b,c) C(a,b,c) D(a,b,c) E(a,b,c) 5: A(a,b,) B(a,b,) C(a,b,) D(a,b,) // The GCC ", ## __VA_ARGS__" extension swallows the comma when followed by // empty __VA_ARGS__. This extension does not apply in -std=c99 mode, but // does apply in C++. // // GCC: 1: [ ] [ , ] [ ] [ ] [ ] // GCC: 2: [ a ] [ , a ] [ ,a ] [ a ] [ a ] // GCC: 3: [ , ] [ , , ] [ ,, ] [ , ] [ ] // GCC: 4: [ a,b,c ] [ , a,b,c ] [ ,a,b,c ] [ a ,b,c ] [ b,ca ] // GCC: 5: [ a,b, ] [ , a,b, ] [ ,a,b, ] [ a ,b, ] // Under C99 standard mode, the GCC ", ## __VA_ARGS__" extension does not // swallow the comma when followed by empty __VA_ARGS__. // // C99: 1: [ ] [ , ] [ , ] [ ] [ ] // C99: 2: [ a ] [ , a ] [ ,a ] [ a ] [ a ] // C99: 3: [ , ] [ , , ] [ ,, ] [ , ] [ ] // C99: 4: [ a,b,c ] [ , a,b,c ] [ ,a,b,c ] [ a ,b,c ] [ b,ca ] // C99: 5: [ a,b, ] [ , a,b, ] [ ,a,b, ] [ a ,b, ] // Microsoft's extension is on ", __VA_ARGS__" (without explicit ##) where // the comma is swallowed when followed by empty __VA_ARGS__. // // MS: 1: [ ] [ ] [ ] [ ] [ ] // MS: 2: [ a ] [ , a ] [ ,a ] [ a ] [ a ] // MS: 3: [ , ] [ , , ] [ ,, ] [ , ] [ ] // MS: 4: [ a,b,c ] [ , a,b,c ] [ ,a,b,c ] [ a ,b,c ] [ b,ca ] // MS: 5: [ a,b, ] [ , a,b, ] [ ,a,b, ] [ a ,b, ] // FIXME: Item 3(d) in MS output should be [ ] not [ , ]
repos/DirectXShaderCompiler/tools/clang/test	repos/DirectXShaderCompiler/tools/clang/test/Preprocessor/print_line_include.c	// RUN: %clang_cc1 -E -P %s \| FileCheck %s // CHECK: int x; // CHECK-NEXT: int x; #include "print_line_include.h" #include "print_line_include.h"
repos/DirectXShaderCompiler/tools/clang/test	repos/DirectXShaderCompiler/tools/clang/test/Preprocessor/annotate_in_macro_arg.c	// RUN: %clang_cc1 -verify %s #define M1() // expected-note{{macro 'M1' defined here}} M1( // expected-error{{unterminated function-like macro invocation}} #if M1() // expected-error{{expected value in expression}} #endif #pragma pack()
repos/DirectXShaderCompiler/tools/clang/test	repos/DirectXShaderCompiler/tools/clang/test/Preprocessor/macro_paste_none.c	// RUN: %clang_cc1 -E %s \| grep '!!' #define A(B,C) B ## C !A(,)!
repos/DirectXShaderCompiler/tools/clang/test	repos/DirectXShaderCompiler/tools/clang/test/Preprocessor/pragma_ps4.c	// RUN: %clang_cc1 %s -triple x86_64-scei-ps4 -fsyntax-only -verify -fms-extensions // On PS4, issue a diagnostic that pragma comments are ignored except: // #pragma comment lib #pragma comment(lib) #pragma comment(lib,"foo") __pragma(comment(lib, "bar")) #pragma comment(linker) // expected-warning {{'#pragma comment linker' ignored}} #pragma comment(linker,"foo") // expected-warning {{'#pragma comment linker' ignored}} __pragma(comment(linker, " bar=" "2")) // expected-warning {{'#pragma comment linker' ignored}} #pragma comment(user) // expected-warning {{'#pragma comment user' ignored}} #pragma comment(user, "Compiled on " __DATE__ " at " __TIME__ ) // expected-warning {{'#pragma comment user' ignored}} __pragma(comment(user, "foo")) // expected-warning {{'#pragma comment user' ignored}} #pragma comment(compiler) // expected-warning {{'#pragma comment compiler' ignored}} #pragma comment(compiler, "foo") // expected-warning {{'#pragma comment compiler' ignored}} __pragma(comment(compiler, "foo")) // expected-warning {{'#pragma comment compiler' ignored}} #pragma comment(exestr) // expected-warning {{'#pragma comment exestr' ignored}} #pragma comment(exestr, "foo") // expected-warning {{'#pragma comment exestr' ignored}} __pragma(comment(exestr, "foo")) // expected-warning {{'#pragma comment exestr' ignored}} #pragma comment(foo) // expected-error {{unknown kind of pragma comment}} __pragma(comment(foo)) // expected-error {{unknown kind of pragma comment}}
repos/DirectXShaderCompiler/tools/clang/test	repos/DirectXShaderCompiler/tools/clang/test/Preprocessor/pp-modules.c	// RUN: rm -rf %t // RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -x objective-c %s -F %S/../Modules/Inputs -E -o - \| FileCheck %s // CHECK: int bar(); int bar(); // CHECK: @import Module; /* clang -E: implicit import for "{{.Headers[/\\]Module.h}}" / #include <Module/Module.h> // CHECK: int foo(); int foo(); // CHECK: @import Module; /* clang -E: implicit import for "{{.Headers[/\\]Module.h}}" / #include <Module/Module.h> #include "pp-modules.h" // CHECK: # 1 "{{.}}pp-modules.h" 1 // CHECK: @import Module; / clang -E: implicit import for "{{.}}Module.h" /{{$}} // CHECK: # 14 "{{.*}}pp-modules.c" 2
repos/DirectXShaderCompiler/tools/clang/test	repos/DirectXShaderCompiler/tools/clang/test/Preprocessor/pr19649-signed-wchar_t.c	// RUN: %clang_cc1 -triple powerpc64-unknown-linux-gnu -E -x c %s // RUN: %clang_cc1 -triple powerpc64-unknown-linux-gnu -E -fno-signed-char -x c %s #if (L'\0' - 1 > 0) # error "Unexpected expression evaluation result" #endif
repos/DirectXShaderCompiler/tools/clang/test	repos/DirectXShaderCompiler/tools/clang/test/Preprocessor/macro_fn_lparen_scan2.c	// RUN: %clang_cc1 -E %s \| grep 'FUNC (3 +1);' #define F(a) a #define FUNC(a) (a+1) F(FUNC) FUNC (3); /* final token sequence is FUNC(3+1) */