| /external/clang/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/ |
| p6.cpp | 16 struct Literal {
17 constexpr Literal() {}
51 template<typename T> struct T1 : virtual Literal { // expected-note {{here}}
60 constexpr T2<Literal> g2() { return {}; }
62 template<typename T> class T3 : public T { // expected-note {{class with virtual base class is not a literal type}}
66 constexpr T3<Literal> g3() { return {}; } // ok
67 constexpr T3<VirtBase> g4() { return {}; } // expected-error {{not a literal type}}
|
| p4.cpp | 16 struct Literal {
17 constexpr Literal() {}
18 explicit Literal(int); // expected-note 2 {{here}}
23 // shall be a literal type.
26 constexpr S(int, NonLiteral, N::C) {} // expected-error {{constexpr constructor's 2nd parameter type 'NonLiteral' is not a literal type}}
27 constexpr S(int, NonLiteral = 42) {} // expected-error {{constexpr constructor's 2nd parameter type 'NonLiteral' is not a literal type}}
31 constexpr S(Literal) = delete;
194 Literal l;
195 Literal m;
196 Literal n[3]
[all...] |
| p3.cpp | 16 struct Literal {
17 constexpr Literal() {}
30 struct T : SS, NonLiteral { // expected-note {{base class 'NonLiteral' of non-literal type}}
32 constexpr int f() const; // expected-error {{non-literal type 'T' cannot have constexpr members}}
39 // - its return type shall be a literal type;
40 constexpr NonLiteral NonLiteralReturn() const { return {}; } // expected-error {{constexpr function's return type 'NonLiteral' is not a literal type}}
43 // expected-error@-2 {{constexpr function's return type 'void' is not a literal type}}
49 // - each of its parameter types shall be a literal type;
50 constexpr int NonLiteralParam(NonLiteral) const { return 0; } // expected-error {{constexpr function's 1st parameter type 'NonLiteral' is not a literal type}}
60 // don't have a literal return type. Defaulted assignment operators can't b
[all...] |
| /external/clang/lib/Sema/ |
| SemaStmtAsm.cpp | 91 // The parser verifies that there is a string literal here.
97 StringLiteral *Literal = Constraints[i];
98 if (!Literal->isAscii())
99 return StmtError(Diag(Literal->getLocStart(),diag::err_asm_wide_character)
100 << Literal->getSourceRange());
106 TargetInfo::ConstraintInfo Info(Literal->getString(), OutputName);
108 return StmtError(Diag(Literal->getLocStart(),
129 StringLiteral *Literal = Constraints[i];
130 if (!Literal->isAscii())
131 return StmtError(Diag(Literal->getLocStart(),diag::err_asm_wide_character
[all...] |
| /external/chromium_org/third_party/sqlite/src/test/ |
| fuzz_common.tcl | 24 # Literal
33 # Returns a string representing an SQL literal.
35 proc Literal {} {
71 set TemplateList [concat $c $c $c {[Literal]}]
94 {[Literal]} {[Literal]} {[Literal]} \
95 {[Literal]} {[Literal]} {[Literal]} \
[all...] |
| /external/chromium_org/third_party/icu/source/test/intltest/ |
| wbnf.cpp | 411 } else { //if (isAlphabet(c) || isDigit(c) || TRUE){ // treat others as literal
425 char * operator()(const char * literal /*c-string*/){
427 for(;*literal != 0; literal++){
428 append(*literal);
506 class Literal : public Pick {
511 Literal(const char * s /*c-string*/){
919 default: token.append(c); // unknown escaping, treat it as literal
[all...] |
| /external/icu4c/test/intltest/ |
| wbnf.cpp | 411 } else { //if (isAlphabet(c) || isDigit(c) || TRUE){ // treat others as literal
425 char * operator()(const char * literal /*c-string*/){
427 for(;*literal != 0; literal++){
428 append(*literal);
506 class Literal : public Pick {
511 Literal(const char * s /*c-string*/){
919 default: token.append(c); // unknown escaping, treat it as literal
[all...] |
| /external/clang/lib/Lex/ |
| PPExpressions.cpp | 221 NumericLiteralParser Literal(Spelling, PeekTok.getLocation(), PP);
222 if (Literal.hadError)
225 if (Literal.isFloatingLiteral() || Literal.isImaginary) {
229 assert(Literal.isIntegerLiteral() && "Unknown ppnumber");
232 if (Literal.hasUDSuffix())
236 if (!PP.getLangOpts().C99 && Literal.isLongLong) {
245 // Parse the integer literal into Result.
246 if (Literal.GetIntegerValue(Result.Val)) {
247 // Overflow parsing integer literal
[all...] |
| Preprocessor.cpp | 437 // If this is a raw identifier or a literal token, set the pointer data.
750 // We need at least one string literal.
757 // Lex string literal tokens, optionally with macro expansion.
772 StringLiteralParser Literal(&StrToks[0], StrToks.size(), *this);
773 assert(Literal.isAscii() && "Didn't allow wide strings in");
775 if (Literal.hadError)
778 if (Literal.Pascal) {
784 String = Literal.GetString();
|
| /external/chromium_org/third_party/mesa/src/src/gallium/tools/trace/ |
| parse.py | 259 return Literal(None)
265 return Literal(value)
271 return Literal(value)
277 return Literal(value)
283 return Literal(value)
295 return Literal(value)
301 return Literal(value)
|
| /external/mesa3d/src/gallium/tools/trace/ |
| parse.py | 259 return Literal(None)
265 return Literal(value)
271 return Literal(value)
277 return Literal(value)
283 return Literal(value)
295 return Literal(value)
301 return Literal(value)
|
| /external/clang/test/CXX/expr/expr.const/ |
| p2-0x.cpp | 21 // literal class or a constexpr function [ Note: Overload resolution (13.3)
287 // with a constant expression [Note: a string literal (2.14.5 [lex.string])
296 // - a non-volatile glvalue of literal type that refers to a non-volatile
301 volatile int v; // expected-note {{not literal because}}
303 constexpr V v; // expected-error {{non-literal type}}
320 // - a non-volatile glvalue of literal type that refers to a non-volatile
543 struct Literal {
544 constexpr Literal(const char *name) : name(name) {}
548 constexpr Expr(Literal l) : IsLiteral(true), l(l) {}
551 Literal l
[all...] |
| /bootable/recovery/edify/ |
| expr.h | 80 // Glue to make an Expr out of a literal.
81 Value* Literal(const char* name, State* state, int argc, Expr* argv[]);
|
| parser.y | 70 $$->fn = Literal;
|
| /external/v8/src/ |
| ast.cc | 174 ObjectLiteral::Property::Property(Literal* key,
246 ZoneHashMap table(Literal::Match);
249 Literal* literal = property->key(); local
250 if (literal->handle()->IsNull()) continue;
251 uint32_t hash = literal->Hash();
255 table.Lookup(literal, hash, false) != NULL) {
259 table.Lookup(literal, hash, true);
317 // Check for the pattern: typeof <expression> equals <string literal>.
347 // Check for the pattern: void <literal> equals <expression
[all...] |
| full-codegen.h | 383 // Try to perform a comparison as a fast inlined literal compare if
389 // a given literal string.
629 // location, as a literal, or on top of the stack) into the result
810 class AccessorTable: public TemplateHashMap<Literal,
815 TemplateHashMap<Literal,
817 ZoneListAllocationPolicy>(Literal::Match),
820 Iterator lookup(Literal* literal) {
821 Iterator it = find(literal, true);
|
| ast.h | 99 V(Literal) \
332 // True iff the expression is a literal represented as a smi.
335 // True iff the expression is a string literal.
338 // True iff the expression is the null literal.
785 // True if there is a function literal subexpression in the condition.
843 // True if there is a function literal subexpression in the condition.
1210 class Literal: public Expression {
1212 DECLARE_NODE_TYPE(Literal)
[all...] |
| /external/chromium_org/third_party/re2/re2/ |
| prefilter.cc | 215 static Info* Literal(Rune r);
405 // Constructs Info for literal rune.
406 Prefilter::Info* Prefilter::Info::Literal(Rune r) {
413 // Constructs Info for literal rune for Latin1 encoded string.
562 info = Literal(re->rune());
577 info = Literal(re->runes()[0]);
579 info = Concat(info, Literal(re->runes()[i]));
|
| /external/regex-re2/re2/ |
| prefilter.cc | 215 static Info* Literal(Rune r);
405 // Constructs Info for literal rune.
406 Prefilter::Info* Prefilter::Info::Literal(Rune r) {
413 // Constructs Info for literal rune for Latin1 encoded string.
562 info = Literal(re->rune());
577 info = Literal(re->runes()[0]);
579 info = Concat(info, Literal(re->runes()[i]));
|
| /external/chromium_org/v8/src/ |
| full-codegen.h | 479 // Try to perform a comparison as a fast inlined literal compare if
485 // a given literal string.
736 // location, as a literal, or on top of the stack) into the result
922 class AccessorTable: public TemplateHashMap<Literal
[all...] |
| ast.cc | 192 ObjectLiteralProperty::ObjectLiteralProperty(Literal* key,
267 ZoneHashMap table(Literal::Match, ZoneHashMap::kDefaultHashMapCapacity,
271 Literal* literal = property->key(); local
272 if (literal->value()->IsNull()) continue;
273 uint32_t hash = literal->Hash();
278 table.Lookup(literal, hash, false, allocator) != NULL) {
282 table.Lookup(literal, hash, true, allocator);
349 // Check for the pattern: typeof <expression> equals <string literal>.
379 // Check for the pattern: void <literal> equals <expression> o
[all...] |
| ast.h | 103 V(Literal) \
347 // True iff the expression is a literal represented as a smi.
350 // True iff the expression is a string literal.
353 // True iff the expression is the null literal.
356 // True if we can prove that the expression is the undefined literal.
819 // True if there is a function literal subexpression in the condition.
876 // True if there is a function literal subexpression in the condition.
[all...] |
| /external/chromium_org/third_party/re2/re2/testing/ |
| parse_test.cc | 257 // Test that parsing with Literal works.
258 TEST(TestParse, Literal) {
259 TestParse(literal_tests, arraysize(literal_tests), Regexp::Literal, "literal");
397 // ToString produces "\\{" for a literal brace,
|
| /external/regex-re2/re2/testing/ |
| parse_test.cc | 257 // Test that parsing with Literal works.
258 TEST(TestParse, Literal) {
259 TestParse(literal_tests, arraysize(literal_tests), Regexp::Literal, "literal");
397 // ToString produces "\\{" for a literal brace,
|
| /external/chromium_org/third_party/jinja2/ |
| nodes.py | 421 class Literal(Expr):
426 class Const(Literal):
449 class TemplateData(Literal):
462 class Tuple(Literal):
480 class List(Literal):
481 """Any list literal such as ``[1, 2, 3]``"""
489 class Dict(Literal):
490 """Any dict literal such as ``{1: 2, 3: 4}``. The items must be a list of
|
