| /external/v8/test/mjsunit/ |
| debug-evaluate-with-context.js | 103 in_top_frame: function(exec_state, expression, additional_context) {
104 return exec_state.frame(0).evaluate(expression, void 0, additional_context).value();
106 globally: function(exec_state, expression, additional_context) {
107 return exec_state.evaluateGlobal(expression, void 0, additional_context).value();
116 function evaluateViaProtocol(exec_state, expression, additional_context, frame_argument_adder) {
118 request_json = {"seq":17,"type":"request","command":"evaluate", arguments: { "expression": expression } };
137 in_top_frame: function(exec_state, expression, additional_context) {
138 return evaluateViaProtocol(exec_state, expression, additional_context, function(args) { args.frame = 0; });
140 globally: function(exec_state, expression, additional_context)
[all...] |
| /prebuilts/go/darwin-x86/src/go/types/ |
| universe.go | 133 _Append: {"append", 1, true, expression},
134 _Cap: {"cap", 1, false, expression},
136 _Complex: {"complex", 2, false, expression},
139 _Imag: {"imag", 1, false, expression},
140 _Len: {"len", 1, false, expression},
141 _Make: {"make", 1, true, expression},
142 _New: {"new", 1, false, expression},
146 _Real: {"real", 1, false, expression},
149 _Alignof: {"Alignof", 1, false, expression},
150 _Offsetof: {"Offsetof", 1, false, expression},
[all...] |
| /prebuilts/go/linux-x86/src/go/types/ |
| universe.go | 133 _Append: {"append", 1, true, expression},
134 _Cap: {"cap", 1, false, expression},
136 _Complex: {"complex", 2, false, expression},
139 _Imag: {"imag", 1, false, expression},
140 _Len: {"len", 1, false, expression},
141 _Make: {"make", 1, true, expression},
142 _New: {"new", 1, false, expression},
146 _Real: {"real", 1, false, expression},
149 _Alignof: {"Alignof", 1, false, expression},
150 _Offsetof: {"Offsetof", 1, false, expression},
[all...] |
| /external/clang/test/OpenMP/ |
| parallel_num_threads_messages.cpp | 17 #pragma omp parallel num_threads ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
18 #pragma omp parallel num_threads () // expected-error {{expected expression}}
21 #pragma omp parallel num_threads ((argc > 0) ? argv[1] : argv[2]) // expected-error 2 {{expression must have integral or unscoped enumeration type, not 'char *'}}
24 #pragma omp parallel num_threads (argv[1]=2) // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error 2 {{expression must have integral or unscoped enumeration type, not 'char *'}}
35 #pragma omp parallel num_threads ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
36 #pragma omp parallel num_threads () // expected-error {{expected expression}}
42 #pragma omp parallel num_threads (argv[1]=2) // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error {{expression must have integral or unscoped enumeration type, not 'char *'}}
|
| parallel_sections_num_threads_messages.cpp | 16 #pragma omp parallel sections num_threads ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
18 #pragma omp parallel sections num_threads () // expected-error {{expected expression}}
24 #pragma omp parallel sections num_threads ((argc > 0) ? argv[1] : argv[2]) // expected-error 2 {{expression must have integral or unscoped enumeration type, not 'char *'}}
30 #pragma omp parallel sections num_threads (argv[1]=2) // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error 2 {{expression must have integral or unscoped enumeration type, not 'char *'}}
43 #pragma omp parallel sections num_threads ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
45 #pragma omp parallel sections num_threads () // expected-error {{expected expression}}
57 #pragma omp parallel sections num_threads (argv[1]=2) // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error {{expression must have integral or unscoped enumeration type, not 'char *'}}
|
| for_simd_misc_messages.c | 91 // expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}}
95 // expected-error@+1 {{expected expression}}
99 // expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}}
103 // expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}}
148 // expected-error@+1 {{expression is not an integer constant expression}}
152 // expected-error@+1 {{expression is not an integer constant expression}}
176 // expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}}
180 // expected-error@+1 {{expected expression}}
[all...] |
| parallel_for_simd_misc_messages.c | 91 // expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}}
95 // expected-error@+1 {{expected expression}}
99 // expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}}
103 // expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}}
148 // expected-error@+1 {{expression is not an integer constant expression}}
152 // expected-error@+1 {{expression is not an integer constant expression}}
176 // expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}}
180 // expected-error@+1 {{expected expression}}
[all...] |
| critical_messages.cpp | 56 #pragma omp critical (name2) hint( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
58 #pragma omp critical (name2) hint(+ // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
60 #pragma omp critical (name2) hint(argc) // expected-error {{expression is not an integral constant expression}} expected-note {{read of non-const variable 'argc' is not allowed in a constant expression}}
119 #pragma omp critical (name2) hint( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
121 #pragma omp critical (name2) hint(+ // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
123 #pragma omp critical (name2) hint(argc) // expected-error {{expression is not an integral constant expression}} expected-note {{read of non-const variable 'argc' is not allowed in a constant expression}}
[all...] |
| /external/clang/test/Parser/ |
| cxx0x-lambda-expressions.cpp | 12 []; // expected-error {{expected body of lambda expression}}
43 int a4[1] = {[&b] = 1 }; // expected-error{{integral constant expression must have integral or unscoped enumeration type, not 'const int *'}}
45 int a6[1] = {[this] = 1 }; // expected-error{{integral constant expression must have integral or unscoped enumeration type, not 'C *'}}
48 int a9[1] = {[d = 0] = 1}; // expected-error{{is not an integral constant expression}}
56 delete [] { return new int; } (); // expected-error{{expected expression}}
80 mutable {}; // expected-error {{expected body of lambda expression}}
91 __attribute__((noreturn)) { while(1); }; // expected-error {{expected body of lambda expression}}
|
| /external/clang/test/SemaObjC/ |
| call-super-2.m | 44 i += [(id <Func>)super class_func0]; // expected-error {{cannot cast 'super' (it isn't an expression)}}
46 return i + [(Class <Func>)super class_func0]; // // expected-error {{cannot cast 'super' (it isn't an expression)}}
50 return [(Object <Func> *)super class_func0]; // expected-error {{cannot cast 'super' (it isn't an expression)}}
54 return [(Derived <Func> *)super class_func0]; // expected-error {{cannot cast 'super' (it isn't an expression)}}
76 return [(id <Func>)super instance_func0]; // expected-error {{cannot cast 'super' (it isn't an expression)}}
80 return [(Object <Func> *)super instance_func0]; // expected-error {{cannot cast 'super' (it isn't an expression)}}
84 return [(Derived <Func> *)super instance_func0]; // expected-error {{cannot cast 'super' (it isn't an expression)}}
|
| /external/proguard/src/proguard/util/ |
| ListParser.java | 54 // Does the regular expression contain a ',' list separator?
60 * Creates a StringMatcher for the given regular expression, which can
93 * Creates a StringMatcher for the given regular expression, which is a
94 * an optionally negated simple expression.
98 // Wrap the matcher if the regular expression starts with a '!' negator.
106 * Returns whether the given simple regular expression is negated.
122 System.out.println("Regular expression ["+args[0]+"]");
|
| /external/selinux/libsepol/include/sepol/policydb/ |
| conditional.h | 34 /* this is the max unique bools in a conditional expression
35 * for which we precompute all outcomes for the expression.
43 * A conditional expression is a list of operators and operands
62 * depending on the current value of the conditional expression. This
72 * contains a conditional expression, the current state of the expression,
74 * expression (the true list corresponds to if and the false list corresponds
|
| /external/v8/test/cctest/ |
| test-ast-expression-visitor.cc | 11 #include "src/ast/ast-expression-visitor.h"
16 #include "test/cctest/expression-type-collector.h"
17 #include "test/cctest/expression-type-collector-macros.h"
27 NodeTypeCounter(Isolate* isolate, Expression* expr, Counters* counts)
31 void VisitExpression(Expression* expr) override {
91 Expression* test_function_expr =
94 // Run NodeTypeCounter and sanity check counts for 3 expression types,
|
| /system/connectivity/shill/ |
| scope_logger.cc | 119 void ScopeLogger::EnableScopesByName(const string& expression) {
120 if (expression.empty()) {
126 // sequence specified by |expression| is not prefixed by a plus or
128 // enabled by |expression|.
129 if (expression[0] != '+' && expression[0] != '-')
133 StringTokenizer tokenizer(expression, "+-");
|
| scope_logger.h | 99 // Enables/disables scopes as specified by |expression|.
101 // |expression| is a string comprising a sequence of scope names, each
104 // is disabled for logging. Scopes that are not mentioned in |expression|
111 // |expression|.
113 // If |expression| is an empty string, all scopes are disabled. Any unknown
114 // scope name found in |expression| is ignored.
115 void EnableScopesByName(const std::string& expression);
|
| /external/apache-xml/src/main/java/org/apache/xpath/ |
| Expression.java | 19 * $Id: Expression.java 468655 2006-10-28 07:12:06Z minchau $
37 * This abstract class serves as the base for all expression objects. An
38 * Expression can be executed to return a {@link org.apache.xpath.objects.XObject},
45 public abstract class Expression implements java.io.Serializable, ExpressionNode, XPathVisitable
49 * The location where this expression was built from. Need for diagnostic
56 * Tell if this expression or it's subexpressions can traverse outside
67 // * Set the location where this expression was built from.
70 // * @param locator the location where this expression was built from, may be
79 * Execute an expression in the XPath runtime context, and return the
80 * result of the expression
[all...] |
| /external/icu/icu4c/source/i18n/unicode/ |
| uregex.h | 36 * Structure representing a compiled regular expression, plus the results
44 * Constants for Regular Expression Match Modes.
93 * traditional regular expression word boundaries. See
111 * Open (compile) an ICU regular expression. Compiles the regular expression in
113 * The resulting regular expression handle can then be used to perform various
117 * @param pattern The Regular Expression pattern to be compiled.
121 * the regular expression, UREGEX_CASE_INSENSITIVE, for
126 * error within the source regular expression string. If this
140 * Open (compile) an ICU regular expression. Compiles the regular expression i
[all...] |
| /external/skia/src/gpu/glsl/ |
| GrGLSL.h | 123 /** A generic base-class representing a GLSL expression.
124 * The instance can be a variable name, expression or vecN(0) or vecN(1). Does simple constant
151 /** Constructs an invalid expression.
156 // The only constructor that is allowed to build an empty expression.
160 /** Constructs an expression with all components as value v */
172 /** Constructs an expression from a string.
173 * Argument expr is a simple expression or a parenthesized expression. */
185 /** Constructs an expression from a string.
186 * Argument expr is a simple expression or a parenthesized expression. *
[all...] |
| /external/jsilver/src/com/google/clearsilver/jsilver/compiler/ |
| ExpressionTranslator.java | 60 * Translates a CS expression (from the AST) into an equivalent Java expression.
73 * appropriate types. The user of the expression is responsible for casting it and the producer of
74 * the expression is now free to produce optimized expressions.
81 * Translate a template AST expression into a Java String expression.
88 * Translate a template AST expression into a Java boolean expression.
95 * Translate a template AST expression into a Java integer expression
127 JavaExpression expression = translateUntyped(csExpression); local
209 PExpression expression = node.getExpression(); local
[all...] |
| /external/clang/test/SemaCXX/ |
| constant-expression-cxx11.cpp | 6 static_assert(++x, "test"); // expected-error {{not an integral constant expression}}
112 constexpr int &Recurse3 = Recurse2; // expected-error {{must be initialized by a constant expression}} expected-note {{initializer of 'Recurse2' is not a constant expression}}
117 constexpr int RecurseC = RecurseB; // expected-error {{must be initialized by a constant expression}} expected-note {{initializer of 'RecurseB' is not a constant expression}}
153 static_assert(F(4, k) == 3, ""); // expected-error {{constant expression}} expected-note {{read of non-const variable 'k'}}
205 constexpr int a = MaybeReturnJunk(true, 0); // expected-error {{constant expression}} expected-note {{read of variable whose lifetime has ended}}
216 constexpr int n3 = InternalReturnJunk(0); // expected-error {{must be initialized by a constant expression}} expected-note {{in call to 'InternalReturnJunk(0)'}}
256 constexpr int Invalid = Apply(Select(0), 0); // expected-error {{must be initialized by a constant expression}} expected-note {{in call to 'Apply(0, 0)'}}
267 constexpr bool g3 = &x <= &y; // expected-error {{must be initialized by a constant expression}}
[all...] |
| /external/apache-xml/src/main/java/org/apache/xpath/functions/ |
| FunctionDef1Arg.java | 40 * Execute the first argument expression that is expected to return a
49 * executing the argument expression.
60 * Tell if the expression is a nodeset expression.
61 * @return true if the expression can be represented as a nodeset.
69 * Execute the first argument expression that is expected to return a
79 * executing the argument expression.
101 * Execute the first argument expression that is expected to return a
111 * executing the argument expression.
158 * Tell if this expression or it's subexpressions can traverse outsid
[all...] |
| /external/eigen/doc/ |
| HiPerformance.dox | 19 Given an expression, the challenge is then to map it to a minimal set of routines.
36 For instance, the following expression:
47 <th>Not optimal expression</th>
70 returns a matrix product expression tracking the scalar scaling factor. <br>
83 <td>This is because the product expression has the EvalBeforeNesting bit which
84 enforces the evaluation of the product by the Tranpose expression.</td>
105 <td>First of all, here the .noalias() in the first expression is useless because
106 m2*m3 will be evaluated anyway. However, note how this expression can be rewritten
118 <td>This is because our expression analyzer is currently not able to extract trivial
119 expressions nested in a Block expression. Therefore the nested scala
[all...] |
| /external/libxml2/ |
| testXPath.c | 118 char expression[5000]; local
127 while (fgets(expression, 4500, input) != NULL) {
128 len = strlen(expression);
131 ((expression[len] == '\n') || (expression[len] == '\t') ||
132 (expression[len] == '\r') || (expression[len] == ' '))) len--;
133 expression[len + 1] = 0;
135 printf("\n========================\nExpression: %s\n", expression) ;
136 testXPath(expression);
[all...] |
| /prebuilts/gcc/linux-x86/host/x86_64-w64-mingw32-4.8/lib/gcc/x86_64-w64-mingw32/4.8.3/plugin/include/cp/ |
| cp-tree.def | 26 1. An expression of the form `A::m' where `A' is a class and `m' is
31 The expression is a pointer-to-member if its address is taken,
38 2. An expression of the form `x.*p'. In this case, operand 0 will
39 be an expression corresponding to `x' and operand 1 will be an
40 expression with pointer-to-member type. */
72 operator converts to. Operand is expression to be converted. */
78 operand 2 is the slot which was allocated for this expression, and
87 /* A throw expression. operand 0 is the expression, if there was one,
103 A BASELINK is an expression; the TREE_TYPE of the BASELINK give
[all...] |
| /toolchain/binutils/binutils-2.25/gas/ |
| expr.h | 22 * By popular demand, we define a struct to represent an expression.
32 * The type of an expression used to be stored as a segment. That got
37 /* This is the type of an expression. The operator types are also
38 used while parsing an expression.
43 /* An illegal expression. */
45 /* A nonexistent expression. */
47 /* X_add_number (a constant expression). */
123 /* The type of the expression. We can't assume that an arbitrary
158 #define expression(result) expr (0, result, expr_normal) macro
162 /* If an expression is O_big, look here for its value. These commo
[all...] |
