HomeSort by relevance Sort by last modified time
    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