| /external/chromium_org/third_party/mesa/src/src/glsl/tests/lower_jumps/ |
| lower_returns_main_true.opt_test | 12 ((if (expression bool > (var_ref a) (constant float (0.000000)))
13 ((if (expression bool > (var_ref b) (constant float (0.000000)))
|
| lower_returns_main_true.opt_test.expected | 8 (if (expression bool > (var_ref a) (constant float (0.000000)))
9 ((if (expression bool > (var_ref b) (constant float (0.000000)))
|
| lower_returns_sub_false.opt_test | 11 ((if (expression bool > (var_ref a) (constant float (0.000000)))
12 ((if (expression bool > (var_ref b) (constant float (0.000000)))
|
| lower_returns_sub_true.opt_test | 11 ((if (expression bool > (var_ref a) (constant float (0.000000)))
12 ((if (expression bool > (var_ref b) (constant float (0.000000)))
|
| lower_returns_sub_true.opt_test.expected | 8 (if (expression bool > (var_ref a) (constant float (0.000000)))
9 ((if (expression bool > (var_ref b) (constant float (0.000000)))
|
| /external/clang/test/Parser/ |
| cxx-throw.cpp | 13 __extension__ throw 1; // expected-error {{expected expression}}
14 (void)throw; // expected-error {{expected expression}}
|
| /external/clang/test/SemaObjC/ |
| selector-error.m | 16 a = (char*)@selector(bar); // expected-error {{cannot type cast @selector expression}}
17 return (char*)@selector(bar); // expected-error {{cannot type cast @selector expression}}
|
| /external/mesa3d/src/glsl/tests/lower_jumps/ |
| lower_returns_main_false.opt_test | 12 ((if (expression bool > (var_ref a) (constant float (0.000000)))
13 ((if (expression bool > (var_ref b) (constant float (0.000000)))
|
| lower_returns_main_true.opt_test | 12 ((if (expression bool > (var_ref a) (constant float (0.000000)))
13 ((if (expression bool > (var_ref b) (constant float (0.000000)))
|
| lower_returns_main_true.opt_test.expected | 8 (if (expression bool > (var_ref a) (constant float (0.000000)))
9 ((if (expression bool > (var_ref b) (constant float (0.000000)))
|
| lower_returns_sub_false.opt_test | 11 ((if (expression bool > (var_ref a) (constant float (0.000000)))
12 ((if (expression bool > (var_ref b) (constant float (0.000000)))
|
| lower_returns_sub_true.opt_test | 11 ((if (expression bool > (var_ref a) (constant float (0.000000)))
12 ((if (expression bool > (var_ref b) (constant float (0.000000)))
|
| lower_returns_sub_true.opt_test.expected | 8 (if (expression bool > (var_ref a) (constant float (0.000000)))
9 ((if (expression bool > (var_ref b) (constant float (0.000000)))
|
| /external/clang/test/CXX/expr/expr.const/ |
| p2-0x.cpp | 3 // A conditional-expression is a core constant expression unless it involves one
7 // expression, function invocation substitution (7.1.5 [dcl.constexpr])
25 int n : f(); // expected-error {{constant expression}} expected-note {{non-constexpr function 'f' cannot be used in a constant expression}}
33 int m : NonConstexpr2().n; // expected-error {{constant expression}} expected-note {{undefined constructor 'NonConstexpr2'}}
40 int n : NonConstexpr4().n; // expected-error {{constant expression}} expected-note {{non-constexpr constructor 'NonConstexpr4' cannot be used in a constant expression}}
48 int undefinedConstexpr2 : undefinedConstexpr1(); // expected-error {{constant expression}} expected-note {{undefined function 'undefinedConstexpr1' cannot be used in a constant expression}}
[all...] |
| /external/apache-xml/src/main/java/org/apache/xpath/operations/ |
| Operation.java | 23 import org.apache.xpath.Expression;
32 public class Operation extends Expression implements ExpressionOwner
36 /** The left operand expression.
38 protected Expression m_left;
40 /** The right operand expression.
42 protected Expression m_right;
62 * Tell if this expression or it's subexpressions can traverse outside
83 * @param l The left expression operand.
84 * @param r The right expression operand.
86 public void setLeftRight(Expression l, Expression r
[all...] |
| UnaryOperation.java | 23 import org.apache.xpath.Expression;
32 public abstract class UnaryOperation extends Expression implements ExpressionOwner
38 protected Expression m_right;
56 * Tell if this expression or it's subexpressions can traverse outside
71 * Set the expression operand for the operation.
74 * @param r The expression operand to which the unary operation will be
77 public void setRight(Expression r)
113 /** @return the operand of unary operation, as an Expression.
115 public Expression getOperand(){
134 public Expression getExpression(
[all...] |
| /external/clang/test/SemaCXX/ |
| warn-bool-conversion.cpp | 3 int* j = false; // expected-warning{{initialization of pointer of type 'int *' to null from a constant boolean expression}}
5 void foo(int* i, int *j=(false)) // expected-warning{{initialization of pointer of type 'int *' to null from a constant boolean expression}}
7 foo(false); // expected-warning{{initialization of pointer of type 'int *' to null from a constant boolean expression}}
11 foo(false == true); // expected-warning{{initialization of pointer of type 'int *' to null from a constant boolean expression}}
12 foo((42 + 24) < 32); // expected-warning{{initialization of pointer of type 'int *' to null from a constant boolean expression}}
15 foo(kFlag); // expected-warning{{initialization of pointer of type 'int *' to null from a constant boolean expression}}
|
| for-range-dereference.cpp | 40 for (auto i : pt) { } // expected-error{{invalid range expression of type 'T *'; did you mean to dereference it with '*'?}}
45 for (auto i : parr) { }// expected-error{{invalid range expression of type 'int (*)[10]'; did you mean to dereference it with '*'?}}
50 for (auto i : pNB) { }// expected-error{{invalid range expression of type 'NoBegin *'; no viable 'begin' function available}}
52 for (auto i : ppNB) { }// expected-error{{invalid range expression of type 'NoBegin **'; no viable 'begin' function available}}
54 for (auto i : pppppNB) { }// expected-error{{invalid range expression of type 'NoBegin *****'; no viable 'begin' function available}}
57 for (auto i : ANE) { } // expected-error{{invalid range expression of type 'ADLNoEnd'; no viable 'end' function available}}
59 for (auto i : pANE) { } // expected-error{{invalid range expression of type 'ADLNoEnd *'; no viable 'begin' function available}}
63 expected-note {{when looking up 'end' function for range expression of type 'DeletedEnd'}}
66 for (auto i : pDE) { } // expected-error {{invalid range expression of type 'DeletedEnd *'; no viable 'begin' function available}}
74 for (auto i : pPE) { }// expected-error {{invalid range expression of type 'PrivateEnd *'}
[all...] |
| /external/chromium_org/third_party/WebKit/Source/core/xml/ |
| XPathPredicate.h | 37 class Number : public Expression {
47 class StringExpression : public Expression {
57 class Negative : public Expression {
63 class NumericOp : public Expression {
68 NumericOp(Opcode, Expression* lhs, Expression* rhs);
76 class EqTestOp : public Expression {
79 EqTestOp(Opcode, Expression* lhs, Expression* rhs);
88 class LogicalOp : public Expression {
[all...] |
| /external/chromium_org/v8/src/ |
| ast.h | 137 class Expression;
313 class Expression: public AstNode {
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.
359 // Expression type bounds
391 explicit Expression(Isolate* isolate)
752 void Initialize(Expression* cond, Statement* body) {
757 Expression* cond() const { return cond_;
1016 Expression* expression() const { return expression_; } function in class:v8::internal::ExpressionStatement
1071 Expression* expression() const { return expression_; } function in class:v8::internal::ReturnStatement
1087 Expression* expression() const { return expression_; } function in class:v8::internal::WithStatement
1688 Expression* expression() const { return expression_; } function in class:v8::internal::Call
1771 Expression* expression() const { return expression_; } function in class:v8::internal::CallNew
1851 Expression* expression() const { return expression_; } function in class:v8::internal::UnaryOperation
1947 Expression* expression() const { return expression_; } function in class:v8::internal::CountOperation
2154 Expression* expression() const { return expression_; } function in class:v8::internal::Yield
[all...] |
| /external/clang/test/CXX/basic/basic.lookup/basic.lookup.classref/ |
| p1.cpp | 4 // In a class member access expression (5.2.5), if the . or -> token is
8 // looked up in the class of the object expression. If the identifier is not
9 // found, it is then looked up in the context of the entire postfix-expression
11 // the object expression finds a template, the name is also looked up in the
12 // context of the entire postfix-expression and
14 // expression is used, otherwise
15 // -- if the name is found in the context of the entire postfix-expression
17 // object expression is used, otherwise
19 // entity as the one found in the class of the object expression,
39 v.set<double>(3.2); // expected-warning{{lookup of 'set' in member access expression is ambiguous; using member of 'Value'}
[all...] |
| /external/apache-xml/src/main/java/org/apache/xpath/ |
| XPathVisitor.java | 39 * main intention is to provide a reasonable means to perform expression
45 * be used to reset the expression for rewriting. If a method returns
55 * @param owner The owner of the expression, to which the expression can
67 * @param owner The owner of the expression, to which the expression can
79 * @param owner The owner of the expression, to which the expression can
91 * proper unique component for predicates, and that the expression will
92 * be called also for whatever type Expression is
[all...] |
| /external/apache-xml/src/main/java/org/apache/xpath/compiler/ |
| OpCodes.java | 33 * (For instance, {boolean expression} means some expression
68 * {expression}
84 * {boolean expression}
85 * {boolean expression}
96 * {boolean expression}
97 * {boolean expression}
108 * {expression}
109 * {expression}
120 * {expression}
[all...] |
| /external/clang/lib/Parse/ |
| ParseExpr.cpp | 1 //===--- ParseExpr.cpp - Expression Parsing -------------------------------===//
11 /// \brief Provides the Expression parsing implementation.
17 /// as the 'cast-expression' production. Everything else is either a binary
37 /// Note: we diverge from the C99 grammar when parsing the assignment-expression
39 /// parsed as a unary-expression, but consistency dictates that it be a
42 /// unary-expression and conditional-expression don't produce. Because we want
43 /// consistency, we parse the LHS as a conditional-expression, then check for
47 /// pm-expression: [C++ 5.5]
48 /// cast-expression
[all...] |
| /external/chromium_org/v8/test/mjsunit/compiler/ |
| delete.js | 30 // In an effect context, expression is always true.
32 // In an effect context, expression is always false.
35 // In a pure test context, expression is always true.
37 // In a pure test context, expression is always false.
39 // In a negated test context, expression is always false.
42 // In a hybrid test/value context, expression is always true, value
45 // In a hybrid test/value context, expression is always false, value
48 // In a hybrid test/value context, expression is always true, value
51 // In a hybrid test/value context, expression is always false, value
55 // In a hybrid value/test context, expression is always true, valu
[all...] |
