| /external/javaparser/javaparser-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/ |
| ForStatementContext.java | 21 import com.github.javaparser.ast.expr.Expression;
45 for (Expression expression : wrappedNode.getInitialization()) {
46 if (expression instanceof VariableDeclarationExpr) {
47 VariableDeclarationExpr variableDeclarationExpr = (VariableDeclarationExpr) expression;
53 } else if (!(expression instanceof AssignExpr || expression instanceof MethodCallExpr)) {
54 throw new UnsupportedOperationException(expression.getClass().getCanonicalName());
|
| /external/libcxx/test/std/utilities/utility/pairs/pairs.pair/ |
| not_constexpr_cxx11.fail.cpp | 38 constexpr P const_U_V(x, x); // expected-error {{must be initialized by a constant expression}}
39 constexpr P U_V(42, 101); // expected-error {{must be initialized by a constant expression}}
45 constexpr P const_U_V(e, e); // expected-error {{must be initialized by a constant expression}}
46 constexpr P U_V(42, 101); // expected-error {{must be initialized by a constant expression}}
47 constexpr P pair_U_V(other); // expected-error {{must be initialized by a constant expression}}
53 constexpr P const_U_V = {i, i}; // expected-error {{must be initialized by a constant expression}}
54 constexpr P U_V = {42, 101}; // expected-error {{must be initialized by a constant expression}}
55 constexpr P pair_U_V = other; // expected-error {{must be initialized by a constant expression}}
|
| /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/skia/src/sksl/ir/ |
| SkSLWhileStatement.h | 20 WhileStatement(int offset, std::unique_ptr<Expression> test,
30 std::unique_ptr<Expression> fTest;
|
| /external/skqp/src/sksl/ir/ |
| SkSLWhileStatement.h | 20 WhileStatement(int offset, std::unique_ptr<Expression> test,
30 std::unique_ptr<Expression> fTest;
|
| /external/tensorflow/tensorflow/compiler/xla/ |
| test_helpers.h | 62 #define EXPECT_IS_OK(expression) \
64 xla::testing::internal_status::GetStatus(expression))
65 #define EXPECT_IS_NOT_OK(expression) \
67 xla::testing::internal_status::GetStatus(expression))
69 #define ASSERT_IS_OK(expression) \
71 xla::testing::internal_status::GetStatus(expression))
73 #define ASSERT_IS_NOT_OK(expression) \
75 xla::testing::internal_status::GetStatus(expression))
|
| /external/v8/src/ast/ |
| ast-function-literal-id-reindexer.h | 14 // Changes the ID of all FunctionLiterals in the given Expression by adding the
22 void Reindex(Expression* pattern);
|
| /packages/apps/TV/common/src/com/android/tv/common/ |
| SoftPreconditions.java | 39 * Throws or logs if an expression involving the parameter of the calling method is not true.
41 * @param expression a boolean expression
51 * @return the evaluation result of the boolean expression
52 * @throws IllegalArgumentException if {@code expression} is true
55 final boolean expression,
59 if (!expression) {
63 return expression;
67 * Throws or logs if an expression involving the parameter of the calling method is not true.
69 * @param expression a boolean expressio
[all...] |
| /prebuilts/ndk/r16/sources/cxx-stl/llvm-libc++/test/std/utilities/utility/pairs/pairs.pair/ |
| not_constexpr_cxx11.fail.cpp | 38 constexpr P const_U_V(x, x); // expected-error {{must be initialized by a constant expression}}
39 constexpr P U_V(42, 101); // expected-error {{must be initialized by a constant expression}}
45 constexpr P const_U_V(e, e); // expected-error {{must be initialized by a constant expression}}
46 constexpr P U_V(42, 101); // expected-error {{must be initialized by a constant expression}}
47 constexpr P pair_U_V(other); // expected-error {{must be initialized by a constant expression}}
53 constexpr P const_U_V = {i, i}; // expected-error {{must be initialized by a constant expression}}
54 constexpr P U_V = {42, 101}; // expected-error {{must be initialized by a constant expression}}
55 constexpr P pair_U_V = other; // expected-error {{must be initialized by a constant expression}}
|
| /external/ply/ply/doc/ |
| ply.html | 146 collection of tokens specified by a collection of regular expression
223 The identification of tokens is typically done by writing a series of regular expression
236 # tokenizer for a simple expression evaluator for
252 # Regular expression rules for simple tokens
260 # A regular expression rule with some action code
390 Each token is specified by writing a regular expression rule compatible with Python's <tt>re</tt> module. Each of these rules
392 defines a token. For simple tokens, the regular expression can
394 most convenient way to write regular expression strings):
416 When a function is used, the regular expression rule is specified in the function documentation string.
434 When building the master regular expression,
[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...] |
| for_simd_safelen_messages.cpp | 21 #pragma omp for simd safelen ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
23 #pragma omp for simd safelen () // expected-error {{expected expression}}
26 // expected-error@+2 2 {{expression is not an integral constant expression}}
27 // expected-note@+1 2 {{read of non-const variable 'argc' is not allowed in a constant expression}}
39 // expected-error@+4 2 {{expression is not an integral constant expression}}
41 // expected-note@+2 2 {{non-constexpr function 'foobool' cannot be used in a constant expression}}
48 // expected-error@+4 2 {{expression is not an integral constant expression}}
[all...] |
| for_simd_simdlen_messages.cpp | 21 #pragma omp for simd simdlen ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
23 #pragma omp for simd simdlen () // expected-error {{expected expression}}
26 // expected-error@+2 2 {{expression is not an integral constant expression}}
27 // expected-note@+1 2 {{read of non-const variable 'argc' is not allowed in a constant expression}}
39 // expected-error@+4 2 {{expression is not an integral constant expression}}
41 // expected-note@+2 2 {{non-constexpr function 'foobool' cannot be used in a constant expression}}
48 // expected-error@+4 2 {{expression is not an integral constant expression}}
[all...] |
| simd_safelen_messages.cpp | 21 #pragma omp simd safelen ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
23 #pragma omp simd safelen () // expected-error {{expected expression}}
26 // expected-error@+2 2 {{expression is not an integral constant expression}}
27 // expected-note@+1 2 {{read of non-const variable 'argc' is not allowed in a constant expression}}
39 // expected-error@+4 2 {{expression is not an integral constant expression}}
41 // expected-note@+2 2 {{non-constexpr function 'foobool' cannot be used in a constant expression}}
48 // expected-error@+4 2 {{expression is not an integral constant expression}}
[all...] |
| simd_simdlen_messages.cpp | 21 #pragma omp simd simdlen ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
23 #pragma omp simd simdlen () // expected-error {{expected expression}}
26 // expected-error@+2 2 {{expression is not an integral constant expression}}
27 // expected-note@+1 2 {{read of non-const variable 'argc' is not allowed in a constant expression}}
39 // expected-error@+4 2 {{expression is not an integral constant expression}}
41 // expected-note@+2 2 {{non-constexpr function 'foobool' cannot be used in a constant expression}}
48 // expected-error@+4 2 {{expression is not an integral constant expression}}
[all...] |
| taskloop_simd_safelen_messages.cpp | 21 #pragma omp taskloop simd safelen ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
23 #pragma omp taskloop simd safelen () // expected-error {{expected expression}}
26 // expected-error@+2 2 {{expression is not an integral constant expression}}
27 // expected-note@+1 2 {{read of non-const variable 'argc' is not allowed in a constant expression}}
39 // expected-error@+4 2 {{expression is not an integral constant expression}}
41 // expected-note@+2 2 {{non-constexpr function 'foobool' cannot be used in a constant expression}}
48 // expected-error@+4 2 {{expression is not an integral constant expression}}
[all...] |
| taskloop_simd_simdlen_messages.cpp | 21 #pragma omp taskloop simd simdlen ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
23 #pragma omp taskloop simd simdlen () // expected-error {{expected expression}}
26 // expected-error@+2 2 {{expression is not an integral constant expression}}
27 // expected-note@+1 2 {{read of non-const variable 'argc' is not allowed in a constant expression}}
39 // expected-error@+4 2 {{expression is not an integral constant expression}}
41 // expected-note@+2 2 {{non-constexpr function 'foobool' cannot be used in a constant expression}}
48 // expected-error@+4 2 {{expression is not an integral constant expression}}
[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/clang/test/SemaCXX/ |
| 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/eigen/Eigen/src/Core/ |
| NoAlias.h | 18 * \brief Pseudo expression providing an operator = assuming no aliasing
22 * This class represents an expression with special assignment operators
23 * assuming no aliasing between the target expression and the source expression.
24 * More precisely it alloas to bypass the EvalBeforeAssignBit flag of the source expression.
36 explicit NoAlias(ExpressionType& expression) : m_expression(expression) {}
63 ExpressionType& expression() const function in class:Eigen::NoAlias
72 /** \returns a pseudo expression of \c *this with an operator= assuming
73 * no aliasing between \c *this and the source 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...] |
| /external/libxml2/result/XPath/expr/ |
| base | 3 Expression: 1
7 Expression: 1+2
11 Expression: 2*3
15 Expression: 1+2*3+4
19 Expression: (1+2)*(3+4)
23 Expression: 1*1+1*1+1*1+1*1+1*1+1*1+1*1+1*1+1*1+1*1+1*1+1*1+1*1+1*1+1*1+1*1+1*1+1*1+1*1+1*1+1*1
27 Expression: 0.000000000000000000000000000000000000000000000000001
31 Expression: -0.000000000000000000000000000000000000000000000000001
35 Expression: 1e2147483648
39 Expression: 1e429496729
[all...] |
| /prebuilts/go/darwin-x86/src/go/parser/ |
| short_test.go | 64 `package p; func f() { if _ /* ERROR "expected boolean expression" */ = range x; true {} };`,
65 `package p; func f() { switch _ /* ERROR "expected switch expression" */ = range x; true {} };`,
68 `package p; func f() { for ; _ /* ERROR "expected boolean or range expression" */ = range x ; {} };`,
70 `package p; func f() { switch t /* ERROR "expected switch expression" */ , t = t.(type) {} };`,
71 `package p; func f() { switch t /* ERROR "expected switch expression" */ = t.(type), t {} };`,
72 `package p; var a = [ /* ERROR "expected expression" */ 1]int;`,
73 `package p; var a = [ /* ERROR "expected expression" */ ...]int;`,
74 `package p; var a = struct /* ERROR "expected expression" */ {}`,
75 `package p; var a = func /* ERROR "expected expression" */ ();`,
76 `package p; var a = interface /* ERROR "expected expression" */ {}`,
[all...] |
