OpenGrok
Home
Sort by relevance
Sort by last modified time
Full Search
Definition
Symbol
File Path
History
|
|
Help
Searched
full:m_expr
(Results
1 - 8
of
8
) sorted by null
/external/apache-xml/src/main/java/org/apache/xpath/axes/
FilterExprWalker.java
76
m_expr
= compiler.compile(opPos);
77
m_expr
.exprSetParent(this);
78
//if((OpCodes.OP_FUNCTION == stepType) && (
m_expr
instanceof org.apache.xalan.templates.FuncKey))
79
if(
m_expr
instanceof org.apache.xpath.operations.Variable)
86
m_expr
= compiler.compile(opPos + 2);
87
m_expr
.exprSetParent(this);
89
// if(
m_expr
instanceof WalkingIterator)
91
// WalkingIterator wi = (WalkingIterator)
m_expr
;
97
//
m_expr
= fw.
m_expr
;
219
private Expression
m_expr
;
field in class:FilterExprWalker
[
all
...]
FilterExprIterator.java
34
private Expression
m_expr
;
field in class:FilterExprIterator
36
/** The result of executing
m_expr
. Needs to be deep cloned on clone op. */
58
m_expr
= expr;
74
getIsTopLevel(), m_stackFrame,
m_expr
);
119
m_expr
.fixupVariables(vars, globalsSize);
127
return
m_expr
;
136
m_expr
= expr;
145
if (null !=
m_expr
&&
m_expr
instanceof PathComponent)
147
return ((PathComponent)
m_expr
).getAnalysisBits()
[
all
...]
FilterExprIteratorSimple.java
42
private Expression
m_expr
;
field in class:FilterExprIteratorSimple
44
/** The result of executing
m_expr
. Needs to be deep cloned on clone op. */
66
m_expr
= expr;
80
getIsTopLevel(), m_stackFrame,
m_expr
);
109
// System.out.println("calling
m_expr
.execute(getXPathContext())");
204
m_expr
.fixupVariables(vars, globalsSize);
212
return
m_expr
;
221
m_expr
= expr;
230
if (null !=
m_expr
&&
m_expr
instanceof PathComponent
[
all
...]
/external/lldb/source/Expression/
ClangExpressionParser.cpp
187
m_expr
(expr),
360
ClangExpressionDeclMap *decl_map =
m_expr
.DeclMap();
392
MemoryBuffer *memory_buffer = MemoryBuffer::getMemBufferCopy(
m_expr
.Text(), __FUNCTION__);
397
ASTConsumer *ast_transformer =
m_expr
.ASTTransformer(m_code_generator.get());
432
if (
m_expr
.DeclMap() && !
m_expr
.DeclMap()->ResolveUnknownTypes())
489
if (!FindFunctionInModule(function_name, module_ap.get(),
m_expr
.FunctionName()))
492
err.SetErrorStringWithFormat("Couldn't find %s() in the module",
m_expr
.FunctionName());
498
log->Printf("Found function %s for %s", function_name.AsCString(),
m_expr
.FunctionName());
507
ClangExpressionDeclMap *decl_map =
m_expr
.DeclMap(); // result can be NUL
[
all
...]
/system/bt/btcore/test/
device_class_test.cpp
30
::testing::AssertionResult check_bitfield(const char *
m_expr
,
45
return ::testing::AssertionFailure() <<
m_expr
<< " and " << n_expr
/external/lldb/include/lldb/Expression/
ClangExpressionParser.h
138
ClangExpression &
m_expr
; ///< The expression to be parsed
member in class:lldb_private::ClangExpressionParser
/prebuilts/python/darwin-x86/2.7.5/lib/python2.7/pydoc_data/
topics.py
9
'binary': '\nBinary arithmetic operations\n****************************\n\nThe binary arithmetic operations have the conventional priority\nlevels. Note that some of these operations also apply to certain non-\nnumeric types. Apart from the power operator, there are only two\nlevels, one for multiplicative operators and one for additive\noperators:\n\n
m_expr
::= u_expr |
m_expr
"*" u_expr |
m_expr
"//" u_expr |
m_expr
"/" u_expr\n |
m_expr
"%" u_expr\n a_expr ::=
m_expr
| a_expr "+"
m_expr
| a_expr "-"
m_expr
\n\nThe ``*`` (multiplication) operator yields the product of its\narguments. The arguments must either both be numbers, or one argument\nmust be an integer (plain or long) and the other must be a sequence.\nIn the former case, the numbers are converted to a common type and\nthen multiplied together. In the latter case, sequence repetition is\nperformed; a negative repetition factor yields an empty sequence.\n\nThe ``/`` (division) and ``//`` (floor division) operators yield the\nquotient of their arguments. The numeric arguments are first\nconverted to a common type. Plain or long integer division yields an\ninteger of the same type; the result is that of mathematical division\nwith the \'floor\' function applied to the result. Division by zero\nraises the ``ZeroDivisionError`` exception.\n\nThe ``%`` (modulo) operator yields the remainder from the division of\nthe first argument by the second. The numeric arguments are first\nconverted to a common type. A zero right argument raises the\n``ZeroDivisionError`` exception. The arguments may be floating point\nnumbers, e.g., ``3.14%0.7`` equals ``0.34`` (since ``3.14`` equals\n``4*0.7 + 0.34``.) The modulo operator always yields a result with\nthe same sign as its second operand (or zero); the absolute value of\nthe result is strictly smaller than the absolute value of the second\noperand [2].\n\nThe integer division and modulo operators are connected by the\nfollowing identity: ``x == (x/y)*y + (x%y)``. Integer division and\nmodulo are also connected with the built-in function ``divmod()``:\n``divmod(x, y) == (x/y, x%y)``. These identities don\'t hold for\nfloating point numbers; there similar identities hold approximately\nwhere ``x/y`` is replaced by ``floor(x/y)`` or ``floor(x/y) - 1`` [3].\n\nIn addition to performing the modulo operation on numbers, the ``%``\noperator is also overloaded by string and unicode objects to perform\nstring formatting (also known as interpolation). The syntax for string\nformatting is described in the Python Library Reference, section\n*String Formatting Operations*.\n\nDeprecated since version 2.3: The floor division operator, the modulo\noperator, and the ``divmod()`` function are no longer defined for\ncomplex numbers. Instead, convert to a floating point number using\nthe ``abs()`` function if appropriate.\n\nThe ``+`` (addition) operator yields the sum of its arguments. The\narguments must either both be numbers or both sequences of the same\ntype. In the former case, the numbers are converted to a common type\nand then added together. In the latter case, the sequences are\nconcatenated.\n\nThe ``-`` (subtraction) operator yields the difference of its\narguments. The numeric arguments are first converted to a common\ntype.\n',
[
all
...]
/prebuilts/python/linux-x86/2.7.5/lib/python2.7/pydoc_data/
topics.py
9
'binary': '\nBinary arithmetic operations\n****************************\n\nThe binary arithmetic operations have the conventional priority\nlevels. Note that some of these operations also apply to certain non-\nnumeric types. Apart from the power operator, there are only two\nlevels, one for multiplicative operators and one for additive\noperators:\n\n
m_expr
::= u_expr |
m_expr
"*" u_expr |
m_expr
"//" u_expr |
m_expr
"/" u_expr\n |
m_expr
"%" u_expr\n a_expr ::=
m_expr
| a_expr "+"
m_expr
| a_expr "-"
m_expr
\n\nThe ``*`` (multiplication) operator yields the product of its\narguments. The arguments must either both be numbers, or one argument\nmust be an integer (plain or long) and the other must be a sequence.\nIn the former case, the numbers are converted to a common type and\nthen multiplied together. In the latter case, sequence repetition is\nperformed; a negative repetition factor yields an empty sequence.\n\nThe ``/`` (division) and ``//`` (floor division) operators yield the\nquotient of their arguments. The numeric arguments are first\nconverted to a common type. Plain or long integer division yields an\ninteger of the same type; the result is that of mathematical division\nwith the \'floor\' function applied to the result. Division by zero\nraises the ``ZeroDivisionError`` exception.\n\nThe ``%`` (modulo) operator yields the remainder from the division of\nthe first argument by the second. The numeric arguments are first\nconverted to a common type. A zero right argument raises the\n``ZeroDivisionError`` exception. The arguments may be floating point\nnumbers, e.g., ``3.14%0.7`` equals ``0.34`` (since ``3.14`` equals\n``4*0.7 + 0.34``.) The modulo operator always yields a result with\nthe same sign as its second operand (or zero); the absolute value of\nthe result is strictly smaller than the absolute value of the second\noperand [2].\n\nThe integer division and modulo operators are connected by the\nfollowing identity: ``x == (x/y)*y + (x%y)``. Integer division and\nmodulo are also connected with the built-in function ``divmod()``:\n``divmod(x, y) == (x/y, x%y)``. These identities don\'t hold for\nfloating point numbers; there similar identities hold approximately\nwhere ``x/y`` is replaced by ``floor(x/y)`` or ``floor(x/y) - 1`` [3].\n\nIn addition to performing the modulo operation on numbers, the ``%``\noperator is also overloaded by string and unicode objects to perform\nstring formatting (also known as interpolation). The syntax for string\nformatting is described in the Python Library Reference, section\n*String Formatting Operations*.\n\nDeprecated since version 2.3: The floor division operator, the modulo\noperator, and the ``divmod()`` function are no longer defined for\ncomplex numbers. Instead, convert to a floating point number using\nthe ``abs()`` function if appropriate.\n\nThe ``+`` (addition) operator yields the sum of its arguments. The\narguments must either both be numbers or both sequences of the same\ntype. In the former case, the numbers are converted to a common type\nand then added together. In the latter case, the sequences are\nconcatenated.\n\nThe ``-`` (subtraction) operator yields the difference of its\narguments. The numeric arguments are first converted to a common\ntype.\n',
[
all
...]
Completed in 625 milliseconds