OpenGrok
Home
Sort by relevance
Sort by last modified time
Full Search
Definition
Symbol
File Path
History
|
|
Help
Searched
refs:overloaded
(Results
1 - 19
of
19
) sorted by null
/external/clang/test/Index/
code-completion.cpp
27
float&
overloaded
(int i, long second);
28
double&
overloaded
(float f, int second);
29
int&
overloaded
(Z z, int second);
33
overloaded
(Z(), 0);
61
// CHECK-OVERLOAD: NotImplemented:{ResultType int &}{Text
overloaded
}{LeftParen (}{Text Z z}{Comma , }{CurrentParameter int second}{RightParen )}
62
// CHECK-OVERLOAD: NotImplemented:{ResultType float &}{Text
overloaded
}{LeftParen (}{Text int i}{Comma , }{CurrentParameter long second}{RightParen )}
63
// CHECK-OVERLOAD: NotImplemented:{ResultType double &}{Text
overloaded
}{LeftParen (}{Text float f}{Comma , }{CurrentParameter int second}{RightParen )}
/external/clang/test/SemaCXX/
cxx0x-initializer-scalars.cpp
77
one
overloaded
(int);
78
two
overloaded
(double);
80
static_assert(sizeof(
overloaded
({0})) == sizeof(one), "bad overload");
81
static_assert(sizeof(
overloaded
({0.0})) == sizeof(two), "bad overload");
cxx0x-initializer-aggregates.cpp
63
one
overloaded
(A);
64
two
overloaded
(B);
66
static_assert(sizeof(
overloaded
({1, 2})) == sizeof(one), "bad overload");
67
static_assert(sizeof(
overloaded
({1, "two"})) == sizeof(two),
70
static_assert(sizeof(
overloaded
({1})) == sizeof(one), "bad overload");
cxx0x-initializer-stdinitializerlist.cpp
83
one
overloaded
(std::initializer_list<int>);
84
two
overloaded
(std::initializer_list<B>);
86
static_assert(sizeof(
overloaded
({1, 2, 3})) == sizeof(one), "bad overload");
87
static_assert(sizeof(
overloaded
({ {1, 2}, {2, 3}, {} })) == sizeof(two), "bad overload");
207
// expected-note@-1 {{candidate template ignored: couldn't resolve reference to
overloaded
function 'f'}}
/external/valgrind/main/massif/tests/
overloaded-new.post.exp
2
Command: ./
overloaded
-new
45
->33.24% (4,000B) 0x........: main (
overloaded
-new.cpp:49)
47
->33.24% (4,000B) 0x........: main (
overloaded
-new.cpp:50)
49
->16.62% (2,000B) 0x........: main (
overloaded
-new.cpp:51)
51
->16.62% (2,000B) 0x........: main (
overloaded
-new.cpp:52)
/frameworks/support/v8/renderscript/rs_support/
Android.mk
4
-Wno-
overloaded
-virtual -DRS_COMPATIBILITY_LIB
/external/chromium_org/third_party/WebKit/Source/devtools/front_end/
StylesSidebarPane.js
624
// Walk the style rules and update the sections with new
overloaded
and used properties.
[
all
...]
elementsPanel.css
399
.styles-section .properties .
overloaded
:not(.has-ignorable-error),
/external/chromium_org/third_party/openssl/openssl/crypto/
sparccpuid.S
183
! as libc provides a stub, which is
overloaded
the moment you link
/external/openssl/crypto/
sparccpuid.S
183
! as libc provides a stub, which is
overloaded
the moment you link
/external/clang/lib/AST/
StmtPrinter.cpp
[
all
...]
/external/chromium_org/third_party/JSON/JSON-2.59/blib/lib/
JSON.pm
[
all
...]
/external/chromium_org/third_party/JSON/JSON-2.59/lib/
JSON.pm
[
all
...]
/external/chromium_org/third_party/JSON/out/lib/perl5/
JSON.pm
[
all
...]
/external/chromium_org/third_party/JSON/JSON-2.59/blib/lib/JSON/
backportPP.pm
[
all
...]
/external/chromium_org/third_party/JSON/JSON-2.59/lib/JSON/
backportPP.pm
[
all
...]
/external/chromium_org/third_party/JSON/out/lib/perl5/JSON/
backportPP.pm
[
all
...]
/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 919 milliseconds