| /external/clang/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/ |
| p9.cpp | 19 // initializer and shall be initialized by a constant expression.
24 constexpr int nc1 = i; // expected-error {{constexpr variable 'nc1' must be initialized by a constant expression}} expected-note {{read of non-const variable 'i' is not allowed in a constant expression}}
27 constexpr int &nc3 = f(); // expected-error {{constexpr variable 'nc3' must be initialized by a constant expression}} expected-note {{non-constexpr function 'f' cannot be used in a constant expression}}
28 constexpr int nc4(i); // expected-error {{constexpr variable 'nc4' must be initialized by a constant expression}} expected-note {{read of non-const variable 'i' is not allowed in a constant expression}}
31 constexpr int &nc6(f()); // expected-error {{constexpr variable 'nc6' must be initialized by a constant expression}} expected-note {{non-constexpr function 'f'}}
|
| /external/clang/test/Preprocessor/ |
| expr_invalid_tok.c | 1 // RUN: not %clang_cc1 -E %s 2>&1 | grep 'invalid token at start of a preprocessor expression'
3 // RUN: not %clang_cc1 -E %s 2>&1 | grep ':14: error: expected end of line in preprocessor expression'
|
| /external/clang/test/Sema/ |
| typedef-variable-type.c | 4 typedef int (*a)[!.0]; // expected-warning{{size of static array must be an integer constant expression}}
8 typedef int (*a)[!.0]; // expected-warning{{size of static array must be an integer constant expression}}
|
| /external/clang/test/SemaCXX/ |
| PR19955.cpp | 5 constexpr int *varp = &var; // expected-error {{must be initialized by a constant expression}}
8 constexpr void (*funp)(void) = &fun; // expected-error {{must be initialized by a constant expression}}
|
| constexpr-strlen.cpp | 11 constexpr int m = strlen("hello"); // expected-error {{constant expression}} expected-note {{non-constexpr function 'strlen' cannot be used in a constant expression}}
|
| old-style-cast.cpp | 5 (long)x; // expected-warning {{use of old-style cast}} expected-warning {{expression result unused}}
6 (void**)x; // expected-warning {{use of old-style cast}} expected-warning {{expression result unused}}
|
| builtin-assume-aligned.cpp | 5 // expected-error@+1 {{must be initialized by a constant expression}}
10 // expected-error@+2 {{must be initialized by a constant expression}}
11 // expected-note@+1 {{cast from 'void *' is not allowed in a constant expression}}
14 // expected-error@+2 {{must be initialized by a constant expression}}
18 // expected-error@+2 {{must be initialized by a constant expression}}
21 // expected-error@+2 {{must be initialized by a constant expression}}
28 // expected-error@+2 {{must be initialized by a constant expression}}
33 // expected-error@+2 {{must be initialized by a constant expression}}
37 // expected-error@+2 {{must be initialized by a constant expression}}
42 // expected-error@+2 {{must be initialized by a constant expression}}
[all...] |
| /external/deqp/framework/randomshaders/ |
| rsgExpressionGenerator.cpp | 21 * \brief Expression generator.
38 Expression* ExpressionGenerator::generate (const ValueRange& valueRange, int initialDepth)
42 Expression* root = Expression::createRandom(m_state, valueRange);
46 // Generate full expression
59 void ExpressionGenerator::generate (Expression* root)
72 Expression* curExpr = m_expressionStack[m_expressionStack.size()-1];
73 Expression* child = curExpr->createNextChild(m_state);
|
| /external/libxml2/result/XPath/xptr/ |
| chapterschildseq | 3 Expression: /1/2/3
12 Expression: element(/1/2/3)
21 Expression: element(foo)element(/1/2/3)
30 Expression: element(/1/2/3)element(foo)
39 Expression: chapter1/3
44 Expression: element(chapter1/3)
48 Expression: element(foo)element(chapter1/3)
52 Expression: element(chapter1/3)element(foo)
|
| /external/lldb/test/lang/cpp/rdar12991846/ |
| TestRdar12991846.py | 3 Test that the expression parser returns proper Unicode strings.
13 # the expression parser does not deal correctly with Unicode expressions
33 """Test that the expression parser returns proper Unicode strings."""
40 """Test that the expression parser returns proper Unicode strings."""
52 """Test that the expression parser returns proper Unicode strings."""
71 self.expect('expression L"hello"',
74 self.expect('expression u"hello"',
77 self.expect('expression U"hello"',
|
| /external/lldb/test/lang/cpp/rvalue-references/ |
| TestRvalueReferences.py | 18 """Test that rvalues are supported in the C++ expression parser"""
23 @expectedFailureClang # pr16762: Expression evaluation of an rvalue-reference does not show the correct type.
28 """Test that rvalues are supported in the C++ expression parser"""
39 """Test that rvalues are supported in the C++ expression parser"""
53 self.expect("expression -- i",
61 self.expect("expression -- foo(2)")
63 self.expect("expression -- int &&j = 3; foo(j)",
66 self.expect("expression -- int &&k = 6; k",
|
| /external/lldb/test/lang/cpp/static_members/ |
| TestCPPStaticMembers.py | 41 self.expect("expression my_a.access()",
44 self.expect("expression my_a.m_a",
48 self.expect("expression my_a.s_d",
51 self.expect("expression my_a.s_b",
54 self.expect("expression A::s_b",
58 self.expect("expression s_d",
62 self.expect("expression m_c",
65 self.expect("expression s_b",
|
| /external/lldb/test/lang/objc/foundation/ |
| TestConstStrings.py | 2 Test that objective-c constant strings are generated correctly by the expression
20 """Test constant string generation amd comparison by the expression parser."""
27 """Test constant string generation amd comparison by the expression parser."""
40 """Test constant string generation amd comparison by the expression parser."""
51 self.expect('expression (int)[str compare:@"hello"]',
53 self.expect('expression (int)[str compare:@"world"]',
57 self.expect('expression (int)[@"" length]',
60 self.expect('expression (int)[@"123" length]',
|
| /external/mesa3d/src/glsl/tests/lower_jumps/ |
| lower_returns_3.opt_test.expected | 9 (if (expression bool > (var_ref a) (constant float (0.000000)))
10 ((if (expression bool > (var_ref b) (constant float (0.000000)))
|
| /external/eigen/Eigen/src/plugins/ |
| ArrayCwiseBinaryOps.h | 1 /** \returns an expression of the coefficient wise product of \c *this and \a other
12 /** \returns an expression of the coefficient wise quotient of \c *this and \a other
23 /** \returns an expression of the coefficient-wise min of \c *this and \a other
32 /** \returns an expression of the coefficient-wise min of \c *this and scalar \a other
48 /** \returns an expression of the coefficient-wise max of \c *this and \a other
57 /** \returns an expression of the coefficient-wise max of \c *this and scalar \a other
73 /** \returns an expression of the coefficient-wise \< operator of *this and \a other
82 /** \returns an expression of the coefficient-wise \<= operator of *this and \a other
91 /** \returns an expression of the coefficient-wise \> operator of *this and \a other
100 /** \returns an expression of the coefficient-wise \>= operator of *this and \a othe
[all...] |
| /external/clang/test/OpenMP/ |
| atomic_messages.c | 7 // expected-error@+2 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}}
8 // expected-note@+1 {{expected an expression statement}}
15 // expected-error@+2 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}}
16 // expected-note@+1 {{expected an expression statement}}
34 // expected-error@+2 {{the statement for 'atomic read' must be an expression statement of form 'v = x;', where v and x are both lvalue expressions with scalar type}}
35 // expected-note@+1 {{expected an expression statement}}
38 // expected-error@+2 {{the statement for 'atomic read' must be an expression statement of form 'v = x;', where v and x are both lvalue expressions with scalar type}}
42 // expected-error@+2 {{the statement for 'atomic read' must be an expression statement of form 'v = x;', where v and x are both lvalue expressions with scalar type}
[all...] |
| /external/apache-xml/src/main/java/org/apache/xpath/compiler/ |
| Compiler.java | 34 import org.apache.xpath.Expression;
67 * An instance of this class compiles an XPath string expression into
68 * a Expression object. This class compiles the string into a sequence
69 * of operation codes (op map) and then builds from that into an Expression
78 * SourceLocator where the expression is located.
82 * @param locator The location object where the expression lives, which
114 public Expression compile(int opPos) throws TransformerException
119 Expression expr = null;
209 private Expression compileOperation(Operation operation, int opPos)
231 private Expression compileUnary(UnaryOperation unary, int opPos
[all...] |
| /external/eigen/Eigen/src/Core/ |
| CwiseUnaryOp.h | 19 * \brief Generic expression where a coefficient-wise unary operator is applied to an expression
22 * \param XprType the type of the expression to which we are applying the unary operator
24 * This class represents an expression where a unary operator is applied to an expression.
25 * It is the return type of all operations taking exactly 1 input expression, regardless of the
26 * presence of other inputs such as scalars. For example, the operator* in the expression 3*matrix
27 * is considered unary, because only the right-hand side is an expression, and its
76 /** \returns the nested expression */
80 /** \returns the nested expression */
[all...] |
| /packages/apps/UnifiedEmail/src/org/apache/commons/io/filefilter/ |
| RegexFileFilter.java | 26 * Filters files using supplied regular expression(s).
48 /** The regular expression pattern that will be used to match filenames */
52 * Construct a new regular expression filter.
54 * @param pattern regular string expression to match
66 * Construct a new regular expression filter with the specified flags case sensitivity.
68 * @param pattern regular string expression to match
84 * Construct a new regular expression filter with the specified flags.
86 * @param pattern regular string expression to match
98 * Construct a new regular expression filter for a compiled regular expression
[all...] |
| /external/apache-xml/src/main/java/org/apache/xpath/functions/ |
| FunctionMultiArgs.java | 24 import org.apache.xpath.Expression;
40 Expression[] m_args;
43 * Return an expression array containing arguments at index 3 or greater.
47 public Expression[] getArgs()
53 * Set an argument expression for a function. This method is called by the
56 * @param arg non-null expression that represents the argument.
62 public void setArg(Expression arg, int argNum)
72 m_args = new Expression[1];
79 Expression[] args = new Expression[m_args.length + 1]
[all...] |
| FuncExtFunction.java | 26 import org.apache.xpath.Expression;
38 * An object of this class represents an extension call expression. When
39 * the expression executes, it calls ExtensionsTable#extFunction, and then
94 Expression arg = (Expression) m_argVec.elementAt(i);
135 * @return The Expression object at the given index.
137 public Expression getArg(int n) {
139 return (Expression) m_argVec.elementAt(n);
197 Expression arg = (Expression) m_argVec.elementAt(i)
[all...] |
| /frameworks/base/tools/aidl/ |
| AST.cpp | 37 WriteArgumentList(FILE* to, const vector<Expression*>& arguments)
95 Expression::~Expression()
177 FieldVariable::FieldVariable(Expression* o, const string& n)
238 StatementBlock::Add(Expression* expression)
240 this->statements.push_back(new ExpressionStatement(expression));
243 ExpressionStatement::ExpressionStatement(Expression* e)
244 :expression(e)
255 this->expression->Write(to)
350 Expression* expression = (Expression*)va_arg(args, void*); local
413 Expression* expression = (Expression*)va_arg(args, void*); local
[all...] |
| /external/v8/src/ |
| ast.h | 115 class Expression;
311 class Expression : public AstNode {
340 // True iff the expression is a literal represented as a smi.
343 // True iff the expression is a string literal.
346 // True iff the expression is the null literal.
349 // True if we can prove that the expression is the undefined literal.
352 // Expression type bounds
356 // Whether the expression is parenthesized
383 Expression(Zone* zone, int pos, IdGen* id_gen)
764 void Initialize(Expression* cond, Statement* body)
1031 Expression* expression() const { return expression_; } function in class:v8::internal::FINAL
1086 Expression* expression() const { return expression_; } function in class:v8::internal::FINAL
1102 Expression* expression() const { return expression_; } function in class:v8::internal::FINAL
1749 Expression* expression() const { return expression_; } function in class:v8::internal::FINAL
1847 Expression* expression() const { return expression_; } function in class:v8::internal::FINAL
1957 Expression* expression() const { return expression_; } function in class:v8::internal::FINAL
2049 Expression* expression() const { return expression_; } function in class:v8::internal::FINAL
2237 Expression* expression() const { return expression_; } function in class:v8::internal::FINAL
[all...] |
| parser.h | 184 // "Adds" an empty expression. Does nothing except consume a
289 // Parser state of containing expression, if any.
296 // Index in captures array of first capture in this sub-expression, if any.
297 // Also the capture index of this sub-expression itself, if group_type
363 typedef v8::internal::Expression* Expression;
369 typedef ZoneList<v8::internal::Expression*>* ExpressionList;
400 // Returns true if the expression is of type "this.foo".
401 static bool IsThisProperty(Expression* expression);
[all...] |
| /external/e2fsprogs/intl/ |
| plural.y | 2 /* Expression parsing for plural form selection.
52 struct expression *exp;
62 static struct expression *
63 new_exp (int nargs, enum operator op, struct expression * const *args)
66 struct expression *newp;
73 /* Allocate a new expression. */
74 newp = (struct expression *) malloc (sizeof (*newp));
91 static inline struct expression *
97 static inline struct expression *
98 new_exp_1 (enum operator op, struct expression *right
[all...] |
