OpenGrok
Home
Sort by relevance
Sort by last modified time
Full Search
Definition
Symbol
File Path
History
|
|
Help
Searched
refs:For
(Results
476 - 500
of
1888
) sorted by null
<<
11
12
13
14
15
16
17
18
19
20
>>
/prebuilts/go/darwin-x86/src/go/doc/
example.go
49
for
_, file := range files {
53
for
_, decl := range file.Decls {
152
for
_, decl := range file.Decls {
157
for
_, spec := range d.Specs {
162
for
_, id := range s.Names {
175
//
For
selector expressions, only inspect the left hand side.
176
// (
For
an expression like fmt.Println, only add "fmt" to the
182
//
For
key value expressions, only inspect the value
205
for
n := range unresolved {
213
// paths
for
imports w/o renames (should be good enough most of the time)
[
all
...]
/prebuilts/go/darwin-x86/src/net/http/httputil/
reverseproxy.go
47
// ErrorLog specifies an optional logger
for
errors
54
// get byte slices
for
use by io.CopyBuffer when
64
// A BufferPool is an interface
for
getting and returning temporary
65
// byte slices
for
use by io.CopyBuffer.
85
// target's path is "/base" and the incoming request was
for
"/dir",
86
// the target request will be
for
/base/dir.
110
for
k, vv := range src {
111
for
_, v := range vv {
119
for
k, vv := range h {
164
outreq.Body = nil // Issue 16036: nil Body
for
http.Transport retrie
[
all
...]
/prebuilts/go/darwin-x86/src/testing/
testing.go
5
// Package testing provides support
for
automated testing of Go packages.
18
//
For
more detail, run ``go help test'' and ``go help testflag''.
36
//
For
a description of the testing flags, see
41
//
for
i := 0; i < b.N; i++ {
58
//
for
i := 0; i < b.N; i++ {
71
//
for
pb.Next() {
102
//
for
_, value := range Perm(4) {
114
// The naming convention to declare examples
for
the package, a function F, a type T and
122
// Multiple example functions
for
a package/type/function/method may be provided by
138
// without having to define separate functions
for
each. This enables use
[
all
...]
/prebuilts/go/darwin-x86/src/vendor/golang_org/x/net/http2/hpack/
tables.go
14
//
For
static tables, entries are never evicted.
16
//
For
dynamic tables, entries are evicted from ents[0] and added to the end.
17
// Each entry has a unique id that starts at one and increments
for
each
20
// are 1-based. The unique id
for
ents[k] is k + evictCount + 1.
28
// 2M years
for
evictCount to overflow.
33
// the same name. See above
for
a definition of "unique id".
37
// entry with the same name and value. See above
for
a definition of "unique id".
68
for
k := 0; k < n; k++ {
79
for
k := t.len() - n; k < t.len(); k++ {
94
// The returned index is a 1-based HPACK index.
For
dynamic tables, HPACK say
[
all
...]
/prebuilts/go/linux-x86/src/cmd/go/internal/list/
list.go
35
The -f flag specifies an alternate format
for
the list, using the
49
Stale bool // would 'go install' do anything
for
this package?
50
StaleReason string // explanation
for
Stale==true
63
FFiles []string // .f, .F, .
for
and .f90 Fortran source files
72
CgoCFLAGS []string // cgo: flags
for
C compiler
73
CgoCPPFLAGS []string // cgo: flags
for
C preprocessor
74
CgoCXXFLAGS []string // cgo: flags
for
C++ compiler
75
CgoFFLAGS []string // cgo: flags
for
Fortran compiler
76
CgoLDFLAGS []string // cgo: flags
for
linker
92
path to the vendor directory (
for
example, "d/vendor/p" instead of "p")
[
all
...]
/prebuilts/go/linux-x86/src/go/doc/
example.go
49
for
_, file := range files {
53
for
_, decl := range file.Decls {
152
for
_, decl := range file.Decls {
157
for
_, spec := range d.Specs {
162
for
_, id := range s.Names {
175
//
For
selector expressions, only inspect the left hand side.
176
// (
For
an expression like fmt.Println, only add "fmt" to the
182
//
For
key value expressions, only inspect the value
205
for
n := range unresolved {
213
// paths
for
imports w/o renames (should be good enough most of the time)
[
all
...]
/prebuilts/go/linux-x86/src/net/http/httputil/
reverseproxy.go
47
// ErrorLog specifies an optional logger
for
errors
54
// get byte slices
for
use by io.CopyBuffer when
64
// A BufferPool is an interface
for
getting and returning temporary
65
// byte slices
for
use by io.CopyBuffer.
85
// target's path is "/base" and the incoming request was
for
"/dir",
86
// the target request will be
for
/base/dir.
110
for
k, vv := range src {
111
for
_, v := range vv {
119
for
k, vv := range h {
164
outreq.Body = nil // Issue 16036: nil Body
for
http.Transport retrie
[
all
...]
/prebuilts/go/linux-x86/src/testing/
testing.go
5
// Package testing provides support
for
automated testing of Go packages.
18
//
For
more detail, run ``go help test'' and ``go help testflag''.
36
//
For
a description of the testing flags, see
41
//
for
i := 0; i < b.N; i++ {
58
//
for
i := 0; i < b.N; i++ {
71
//
for
pb.Next() {
102
//
for
_, value := range Perm(4) {
114
// The naming convention to declare examples
for
the package, a function F, a type T and
122
// Multiple example functions
for
a package/type/function/method may be provided by
138
// without having to define separate functions
for
each. This enables use
[
all
...]
/prebuilts/go/linux-x86/src/vendor/golang_org/x/net/http2/hpack/
tables.go
14
//
For
static tables, entries are never evicted.
16
//
For
dynamic tables, entries are evicted from ents[0] and added to the end.
17
// Each entry has a unique id that starts at one and increments
for
each
20
// are 1-based. The unique id
for
ents[k] is k + evictCount + 1.
28
// 2M years
for
evictCount to overflow.
33
// the same name. See above
for
a definition of "unique id".
37
// entry with the same name and value. See above
for
a definition of "unique id".
68
for
k := 0; k < n; k++ {
79
for
k := t.len() - n; k < t.len(); k++ {
94
// The returned index is a 1-based HPACK index.
For
dynamic tables, HPACK say
[
all
...]
/prebuilts/gdb/darwin-x86/lib/python2.7/pydoc_data/
topics.py
2
topics = {'assert': '\nThe ``assert`` statement\n************************\n\nAssert statements are a convenient way to insert debugging assertions\ninto a program:\n\n assert_stmt ::= "assert" expression ["," expression]\n\nThe simple form, ``assert expression``, is equivalent to\n\n if __debug__:\n if not expression: raise AssertionError\n\nThe extended form, ``assert expression1, expression2``, is equivalent\nto\n\n if __debug__:\n if not expression1: raise AssertionError(expression2)\n\nThese equivalences assume that ``__debug__`` and ``AssertionError``\nrefer to the built-in variables with those names. In the current\nimplementation, the built-in variable ``__debug__`` is ``True`` under\nnormal circumstances, ``False`` when optimization is requested\n(command line option -O). The current code generator emits no code\nfor an assert statement when optimization is requested at compile\ntime. Note that it is unnecessary to include the source code
for
the\nexpression that failed in the error message; it will be displayed as\npart of the stack trace.\n\nAssignments to ``__debug__`` are illegal. The value
for
the built-in\nvariable is determined when the interpreter starts.\n',
3
'assignment': '\nAssignment statements\n*********************\n\nAssignment statements are used to (re)bind names to values and to\nmodify attributes or items of mutable objects:\n\n assignment_stmt ::= (target_list "=")+ (expression_list | yield_expression)\n target_list ::= target ("," target)* [","]\n target ::= identifier\n | "(" target_list ")"\n | "[" target_list "]"\n | attributeref\n | subscription\n | slicing\n\n(See section *Primaries*
for
the syntax definitions
for
the last three\nsymbols.)\n\nAn assignment statement evaluates the expression list (remember that\nthis can be a single expression or a comma-separated list, the latter\nyielding a tuple) and assigns the single resulting object to each of\nthe target lists, from left to right.\n\nAssignment is defined recursively depending on the form of the target\n(list). When a target is part of a mutable object (an attribute\nreference, subscription or slicing), the mutable object must\nultimately perform the assignment and decide about its validity, and\nmay raise an exception if the assignment is unacceptable. The rules\nobserved by various types and the exceptions raised are given with the\ndefinition of the object types (see section *The standard type\nhierarchy*).\n\nAssignment of an object to a target list is recursively defined as\nfollows.\n\n* If the target list is a single target: The object is assigned to\n that target.\n\n* If the target list is a comma-separated list of targets: The object\n must be an iterable with the same number of items as there are\n targets in the target list, and the items are assigned, from left to\n right, to the corresponding targets.\n\nAssignment of an object to a single target is recursively defined as\nfollows.\n\n* If the target is an identifier (name):\n\n * If the name does not occur in a ``global`` statement in the\n current code block: the name is bound to the object in the current\n local namespace.\n\n * Otherwise: the name is bound to the object in the current global\n namespace.\n\n The name is rebound if it was already bound. This may cause the\n reference count
for
the object previously bound to the name to reach\n zero, causing the object to be deallocated and its destructor (if it\n has one) to be called.\n\n* If the target is a target list enclosed in parentheses or in square\n brackets: The object must be an iterable with the same number of\n items as there are targets in the target list, and its items are\n assigned, from left to right, to the corresponding targets.\n\n* If the target is an attribute reference: The primary expression in\n the reference is evaluated. It should yield an object with\n assignable attributes; if this is not the case, ``TypeError`` is\n raised. That object is then asked to assign the assigned object to\n the given attribute; if it cannot perform the assignment, it raises\n an exception (usually but not necessarily ``AttributeError``).\n\n Note: If the object is a class instance and the attribute reference\n occurs on both sides of the assignment operator, the RHS expression,\n ``a.x`` can access either an instance attribute or (if no instance\n attribute exists) a class attribute. The LHS target ``a.x`` is\n always set as an instance attribute, creating it if necessary.\n Thus, the two occurrences of ``a.x`` do not necessarily refer to the\n same attribute: if the RHS expression refers to a class attribute,\n the LHS creates a new instance attribute as the target of the\n assignment:\n\n class Cls:\n x = 3 # class variable\n inst = Cls()\n inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 3\n\n This description does not necessarily apply to descriptor\n attributes, such as properties created with ``property()``.\n\n* If the target is a subscription: The primary expression in the\n reference is evaluated. It should yield either a mutable sequence\n object (such as a list) or a mapping object (such as a dictionary).\n Next, the subscript expression is evaluated.\n\n If the primary is a mutable sequence object (such as a list), the\n subscript must yield a plain integer. If it is negative, the\n sequence\'s length is added to it. The resulting value must be a\n nonnegative integer less than the sequence\'s length, and the\n sequence is asked to assign the assigned object to its item with\n that index. If the index is out of range, ``IndexError`` is raised\n (assignment to a subscripted sequence cannot add new items to a\n list).\n\n If the primary is a mapping object (such as a dictionary), the\n subscript must have a type compatible with the mapping\'s key type,\n and the mapping is then asked to create a key/datum pair which maps\n the subscript to the assigned object. This can either replace an\n existing key/value pair with the same key value, or insert a new\n key/value pair (if no key with the same value existed).\n\n* If the target is a slicing: The primary expression in the reference\n is evaluated. It should yield a mutable sequence object (such as a\n list). The assigned object should be a sequence object of the same\n type. Next, the lower and upper bound expressions are evaluated,\n insofar they are present; defaults are zero and the sequence\'s\n length. The bounds should evaluate to (small) integers. If either\n bound is negative, the sequence\'s length is added to it. The\n resulting bounds are clipped to lie between zero and the sequence\'s\n length, inclusive. Finally, the sequence object is asked to replace\n the slice with the items of the assigned sequence. The length of\n the slice may be different from the length of the assigned sequence,\n thus changing the length of the target sequence, if the object\n allows it.\n\n**CPython implementation detail:** In the current implementation, the\nsyntax
for
targets is taken to be the same as
for
expressions, and\ninvalid syntax is rejected during the code generation phase, causing\nless detailed error messages.\n\nWARNING: Although the definition of assignment implies that overlaps\nbetween the left-hand side and the right-hand side are \'safe\' (
for
\nexample ``a, b = b, a`` swaps two variables), overlaps *within* the\ncollection of assigned-to variables are not safe!
For
instance, the\nfollowing program prints ``[0, 2]``:\n\n x = [0, 1]\n i = 0\n i, x[i] = 1, 2\n print x\n\n\nAugmented assignment statements\n===============================\n\nAugmented assignment is the combination, in a single statement, of a\nbinary operation and an assignment statement:\n\n augmented_assignment_stmt ::= augtarget augop (expression_list | yield_expression)\n augtarget ::= identifier | attributeref | subscription | slicing\n augop ::= "+=" | "-=" | "*=" | "/=" | "//=" | "%=" | "**="\n | ">>=" | "<<=" | "&=" | "^=" | "|="\n\n(See section *Primaries*
for
the syntax definitions for the last three\nsymbols.)\n\nAn augmented assignment evaluates the targ (…)
[
all
...]
/prebuilts/gdb/linux-x86/lib/python2.7/pydoc_data/
topics.py
2
topics = {'assert': '\nThe ``assert`` statement\n************************\n\nAssert statements are a convenient way to insert debugging assertions\ninto a program:\n\n assert_stmt ::= "assert" expression ["," expression]\n\nThe simple form, ``assert expression``, is equivalent to\n\n if __debug__:\n if not expression: raise AssertionError\n\nThe extended form, ``assert expression1, expression2``, is equivalent\nto\n\n if __debug__:\n if not expression1: raise AssertionError(expression2)\n\nThese equivalences assume that ``__debug__`` and ``AssertionError``\nrefer to the built-in variables with those names. In the current\nimplementation, the built-in variable ``__debug__`` is ``True`` under\nnormal circumstances, ``False`` when optimization is requested\n(command line option -O). The current code generator emits no code\nfor an assert statement when optimization is requested at compile\ntime. Note that it is unnecessary to include the source code
for
the\nexpression that failed in the error message; it will be displayed as\npart of the stack trace.\n\nAssignments to ``__debug__`` are illegal. The value
for
the built-in\nvariable is determined when the interpreter starts.\n',
3
'assignment': '\nAssignment statements\n*********************\n\nAssignment statements are used to (re)bind names to values and to\nmodify attributes or items of mutable objects:\n\n assignment_stmt ::= (target_list "=")+ (expression_list | yield_expression)\n target_list ::= target ("," target)* [","]\n target ::= identifier\n | "(" target_list ")"\n | "[" target_list "]"\n | attributeref\n | subscription\n | slicing\n\n(See section *Primaries*
for
the syntax definitions
for
the last three\nsymbols.)\n\nAn assignment statement evaluates the expression list (remember that\nthis can be a single expression or a comma-separated list, the latter\nyielding a tuple) and assigns the single resulting object to each of\nthe target lists, from left to right.\n\nAssignment is defined recursively depending on the form of the target\n(list). When a target is part of a mutable object (an attribute\nreference, subscription or slicing), the mutable object must\nultimately perform the assignment and decide about its validity, and\nmay raise an exception if the assignment is unacceptable. The rules\nobserved by various types and the exceptions raised are given with the\ndefinition of the object types (see section *The standard type\nhierarchy*).\n\nAssignment of an object to a target list is recursively defined as\nfollows.\n\n* If the target list is a single target: The object is assigned to\n that target.\n\n* If the target list is a comma-separated list of targets: The object\n must be an iterable with the same number of items as there are\n targets in the target list, and the items are assigned, from left to\n right, to the corresponding targets.\n\nAssignment of an object to a single target is recursively defined as\nfollows.\n\n* If the target is an identifier (name):\n\n * If the name does not occur in a ``global`` statement in the\n current code block: the name is bound to the object in the current\n local namespace.\n\n * Otherwise: the name is bound to the object in the current global\n namespace.\n\n The name is rebound if it was already bound. This may cause the\n reference count
for
the object previously bound to the name to reach\n zero, causing the object to be deallocated and its destructor (if it\n has one) to be called.\n\n* If the target is a target list enclosed in parentheses or in square\n brackets: The object must be an iterable with the same number of\n items as there are targets in the target list, and its items are\n assigned, from left to right, to the corresponding targets.\n\n* If the target is an attribute reference: The primary expression in\n the reference is evaluated. It should yield an object with\n assignable attributes; if this is not the case, ``TypeError`` is\n raised. That object is then asked to assign the assigned object to\n the given attribute; if it cannot perform the assignment, it raises\n an exception (usually but not necessarily ``AttributeError``).\n\n Note: If the object is a class instance and the attribute reference\n occurs on both sides of the assignment operator, the RHS expression,\n ``a.x`` can access either an instance attribute or (if no instance\n attribute exists) a class attribute. The LHS target ``a.x`` is\n always set as an instance attribute, creating it if necessary.\n Thus, the two occurrences of ``a.x`` do not necessarily refer to the\n same attribute: if the RHS expression refers to a class attribute,\n the LHS creates a new instance attribute as the target of the\n assignment:\n\n class Cls:\n x = 3 # class variable\n inst = Cls()\n inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 3\n\n This description does not necessarily apply to descriptor\n attributes, such as properties created with ``property()``.\n\n* If the target is a subscription: The primary expression in the\n reference is evaluated. It should yield either a mutable sequence\n object (such as a list) or a mapping object (such as a dictionary).\n Next, the subscript expression is evaluated.\n\n If the primary is a mutable sequence object (such as a list), the\n subscript must yield a plain integer. If it is negative, the\n sequence\'s length is added to it. The resulting value must be a\n nonnegative integer less than the sequence\'s length, and the\n sequence is asked to assign the assigned object to its item with\n that index. If the index is out of range, ``IndexError`` is raised\n (assignment to a subscripted sequence cannot add new items to a\n list).\n\n If the primary is a mapping object (such as a dictionary), the\n subscript must have a type compatible with the mapping\'s key type,\n and the mapping is then asked to create a key/datum pair which maps\n the subscript to the assigned object. This can either replace an\n existing key/value pair with the same key value, or insert a new\n key/value pair (if no key with the same value existed).\n\n* If the target is a slicing: The primary expression in the reference\n is evaluated. It should yield a mutable sequence object (such as a\n list). The assigned object should be a sequence object of the same\n type. Next, the lower and upper bound expressions are evaluated,\n insofar they are present; defaults are zero and the sequence\'s\n length. The bounds should evaluate to (small) integers. If either\n bound is negative, the sequence\'s length is added to it. The\n resulting bounds are clipped to lie between zero and the sequence\'s\n length, inclusive. Finally, the sequence object is asked to replace\n the slice with the items of the assigned sequence. The length of\n the slice may be different from the length of the assigned sequence,\n thus changing the length of the target sequence, if the object\n allows it.\n\n**CPython implementation detail:** In the current implementation, the\nsyntax
for
targets is taken to be the same as
for
expressions, and\ninvalid syntax is rejected during the code generation phase, causing\nless detailed error messages.\n\nWARNING: Although the definition of assignment implies that overlaps\nbetween the left-hand side and the right-hand side are \'safe\' (
for
\nexample ``a, b = b, a`` swaps two variables), overlaps *within* the\ncollection of assigned-to variables are not safe!
For
instance, the\nfollowing program prints ``[0, 2]``:\n\n x = [0, 1]\n i = 0\n i, x[i] = 1, 2\n print x\n\n\nAugmented assignment statements\n===============================\n\nAugmented assignment is the combination, in a single statement, of a\nbinary operation and an assignment statement:\n\n augmented_assignment_stmt ::= augtarget augop (expression_list | yield_expression)\n augtarget ::= identifier | attributeref | subscription | slicing\n augop ::= "+=" | "-=" | "*=" | "/=" | "//=" | "%=" | "**="\n | ">>=" | "<<=" | "&=" | "^=" | "|="\n\n(See section *Primaries*
for
the syntax definitions for the last three\nsymbols.)\n\nAn augmented assignment evaluates the targ (…)
[
all
...]
/prebuilts/python/darwin-x86/2.7.5/lib/python2.7/pydoc_data/
topics.py
2
topics = {'assert': '\nThe ``assert`` statement\n************************\n\nAssert statements are a convenient way to insert debugging assertions\ninto a program:\n\n assert_stmt ::= "assert" expression ["," expression]\n\nThe simple form, ``assert expression``, is equivalent to\n\n if __debug__:\n if not expression: raise AssertionError\n\nThe extended form, ``assert expression1, expression2``, is equivalent\nto\n\n if __debug__:\n if not expression1: raise AssertionError(expression2)\n\nThese equivalences assume that ``__debug__`` and ``AssertionError``\nrefer to the built-in variables with those names. In the current\nimplementation, the built-in variable ``__debug__`` is ``True`` under\nnormal circumstances, ``False`` when optimization is requested\n(command line option -O). The current code generator emits no code\nfor an assert statement when optimization is requested at compile\ntime. Note that it is unnecessary to include the source code
for
the\nexpression that failed in the error message; it will be displayed as\npart of the stack trace.\n\nAssignments to ``__debug__`` are illegal. The value
for
the built-in\nvariable is determined when the interpreter starts.\n',
3
'assignment': '\nAssignment statements\n*********************\n\nAssignment statements are used to (re)bind names to values and to\nmodify attributes or items of mutable objects:\n\n assignment_stmt ::= (target_list "=")+ (expression_list | yield_expression)\n target_list ::= target ("," target)* [","]\n target ::= identifier\n | "(" target_list ")"\n | "[" target_list "]"\n | attributeref\n | subscription\n | slicing\n\n(See section *Primaries*
for
the syntax definitions
for
the last three\nsymbols.)\n\nAn assignment statement evaluates the expression list (remember that\nthis can be a single expression or a comma-separated list, the latter\nyielding a tuple) and assigns the single resulting object to each of\nthe target lists, from left to right.\n\nAssignment is defined recursively depending on the form of the target\n(list). When a target is part of a mutable object (an attribute\nreference, subscription or slicing), the mutable object must\nultimately perform the assignment and decide about its validity, and\nmay raise an exception if the assignment is unacceptable. The rules\nobserved by various types and the exceptions raised are given with the\ndefinition of the object types (see section *The standard type\nhierarchy*).\n\nAssignment of an object to a target list is recursively defined as\nfollows.\n\n* If the target list is a single target: The object is assigned to\n that target.\n\n* If the target list is a comma-separated list of targets: The object\n must be an iterable with the same number of items as there are\n targets in the target list, and the items are assigned, from left to\n right, to the corresponding targets.\n\nAssignment of an object to a single target is recursively defined as\nfollows.\n\n* If the target is an identifier (name):\n\n * If the name does not occur in a ``global`` statement in the\n current code block: the name is bound to the object in the current\n local namespace.\n\n * Otherwise: the name is bound to the object in the current global\n namespace.\n\n The name is rebound if it was already bound. This may cause the\n reference count
for
the object previously bound to the name to reach\n zero, causing the object to be deallocated and its destructor (if it\n has one) to be called.\n\n* If the target is a target list enclosed in parentheses or in square\n brackets: The object must be an iterable with the same number of\n items as there are targets in the target list, and its items are\n assigned, from left to right, to the corresponding targets.\n\n* If the target is an attribute reference: The primary expression in\n the reference is evaluated. It should yield an object with\n assignable attributes; if this is not the case, ``TypeError`` is\n raised. That object is then asked to assign the assigned object to\n the given attribute; if it cannot perform the assignment, it raises\n an exception (usually but not necessarily ``AttributeError``).\n\n Note: If the object is a class instance and the attribute reference\n occurs on both sides of the assignment operator, the RHS expression,\n ``a.x`` can access either an instance attribute or (if no instance\n attribute exists) a class attribute. The LHS target ``a.x`` is\n always set as an instance attribute, creating it if necessary.\n Thus, the two occurrences of ``a.x`` do not necessarily refer to the\n same attribute: if the RHS expression refers to a class attribute,\n the LHS creates a new instance attribute as the target of the\n assignment:\n\n class Cls:\n x = 3 # class variable\n inst = Cls()\n inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 3\n\n This description does not necessarily apply to descriptor\n attributes, such as properties created with ``property()``.\n\n* If the target is a subscription: The primary expression in the\n reference is evaluated. It should yield either a mutable sequence\n object (such as a list) or a mapping object (such as a dictionary).\n Next, the subscript expression is evaluated.\n\n If the primary is a mutable sequence object (such as a list), the\n subscript must yield a plain integer. If it is negative, the\n sequence\'s length is added to it. The resulting value must be a\n nonnegative integer less than the sequence\'s length, and the\n sequence is asked to assign the assigned object to its item with\n that index. If the index is out of range, ``IndexError`` is raised\n (assignment to a subscripted sequence cannot add new items to a\n list).\n\n If the primary is a mapping object (such as a dictionary), the\n subscript must have a type compatible with the mapping\'s key type,\n and the mapping is then asked to create a key/datum pair which maps\n the subscript to the assigned object. This can either replace an\n existing key/value pair with the same key value, or insert a new\n key/value pair (if no key with the same value existed).\n\n* If the target is a slicing: The primary expression in the reference\n is evaluated. It should yield a mutable sequence object (such as a\n list). The assigned object should be a sequence object of the same\n type. Next, the lower and upper bound expressions are evaluated,\n insofar they are present; defaults are zero and the sequence\'s\n length. The bounds should evaluate to (small) integers. If either\n bound is negative, the sequence\'s length is added to it. The\n resulting bounds are clipped to lie between zero and the sequence\'s\n length, inclusive. Finally, the sequence object is asked to replace\n the slice with the items of the assigned sequence. The length of\n the slice may be different from the length of the assigned sequence,\n thus changing the length of the target sequence, if the object\n allows it.\n\n**CPython implementation detail:** In the current implementation, the\nsyntax
for
targets is taken to be the same as
for
expressions, and\ninvalid syntax is rejected during the code generation phase, causing\nless detailed error messages.\n\nWARNING: Although the definition of assignment implies that overlaps\nbetween the left-hand side and the right-hand side are \'safe\' (
for
\nexample ``a, b = b, a`` swaps two variables), overlaps *within* the\ncollection of assigned-to variables are not safe!
For
instance, the\nfollowing program prints ``[0, 2]``:\n\n x = [0, 1]\n i = 0\n i, x[i] = 1, 2\n print x\n\n\nAugmented assignment statements\n===============================\n\nAugmented assignment is the combination, in a single statement, of a\nbinary operation and an assignment statement:\n\n augmented_assignment_stmt ::= augtarget augop (expression_list | yield_expression)\n augtarget ::= identifier | attributeref | subscription | slicing\n augop ::= "+=" | "-=" | "*=" | "/=" | "//=" | "%=" | "**="\n | ">>=" | "<<=" | "&=" | "^=" | "|="\n\n(See section *Primaries*
for
the syntax definitions for the last three\nsymbols.)\n\nAn augmented assignment evaluates the targ (…)
[
all
...]
/prebuilts/python/linux-x86/2.7.5/lib/python2.7/pydoc_data/
topics.py
2
topics = {'assert': '\nThe ``assert`` statement\n************************\n\nAssert statements are a convenient way to insert debugging assertions\ninto a program:\n\n assert_stmt ::= "assert" expression ["," expression]\n\nThe simple form, ``assert expression``, is equivalent to\n\n if __debug__:\n if not expression: raise AssertionError\n\nThe extended form, ``assert expression1, expression2``, is equivalent\nto\n\n if __debug__:\n if not expression1: raise AssertionError(expression2)\n\nThese equivalences assume that ``__debug__`` and ``AssertionError``\nrefer to the built-in variables with those names. In the current\nimplementation, the built-in variable ``__debug__`` is ``True`` under\nnormal circumstances, ``False`` when optimization is requested\n(command line option -O). The current code generator emits no code\nfor an assert statement when optimization is requested at compile\ntime. Note that it is unnecessary to include the source code
for
the\nexpression that failed in the error message; it will be displayed as\npart of the stack trace.\n\nAssignments to ``__debug__`` are illegal. The value
for
the built-in\nvariable is determined when the interpreter starts.\n',
3
'assignment': '\nAssignment statements\n*********************\n\nAssignment statements are used to (re)bind names to values and to\nmodify attributes or items of mutable objects:\n\n assignment_stmt ::= (target_list "=")+ (expression_list | yield_expression)\n target_list ::= target ("," target)* [","]\n target ::= identifier\n | "(" target_list ")"\n | "[" target_list "]"\n | attributeref\n | subscription\n | slicing\n\n(See section *Primaries*
for
the syntax definitions
for
the last three\nsymbols.)\n\nAn assignment statement evaluates the expression list (remember that\nthis can be a single expression or a comma-separated list, the latter\nyielding a tuple) and assigns the single resulting object to each of\nthe target lists, from left to right.\n\nAssignment is defined recursively depending on the form of the target\n(list). When a target is part of a mutable object (an attribute\nreference, subscription or slicing), the mutable object must\nultimately perform the assignment and decide about its validity, and\nmay raise an exception if the assignment is unacceptable. The rules\nobserved by various types and the exceptions raised are given with the\ndefinition of the object types (see section *The standard type\nhierarchy*).\n\nAssignment of an object to a target list is recursively defined as\nfollows.\n\n* If the target list is a single target: The object is assigned to\n that target.\n\n* If the target list is a comma-separated list of targets: The object\n must be an iterable with the same number of items as there are\n targets in the target list, and the items are assigned, from left to\n right, to the corresponding targets.\n\nAssignment of an object to a single target is recursively defined as\nfollows.\n\n* If the target is an identifier (name):\n\n * If the name does not occur in a ``global`` statement in the\n current code block: the name is bound to the object in the current\n local namespace.\n\n * Otherwise: the name is bound to the object in the current global\n namespace.\n\n The name is rebound if it was already bound. This may cause the\n reference count
for
the object previously bound to the name to reach\n zero, causing the object to be deallocated and its destructor (if it\n has one) to be called.\n\n* If the target is a target list enclosed in parentheses or in square\n brackets: The object must be an iterable with the same number of\n items as there are targets in the target list, and its items are\n assigned, from left to right, to the corresponding targets.\n\n* If the target is an attribute reference: The primary expression in\n the reference is evaluated. It should yield an object with\n assignable attributes; if this is not the case, ``TypeError`` is\n raised. That object is then asked to assign the assigned object to\n the given attribute; if it cannot perform the assignment, it raises\n an exception (usually but not necessarily ``AttributeError``).\n\n Note: If the object is a class instance and the attribute reference\n occurs on both sides of the assignment operator, the RHS expression,\n ``a.x`` can access either an instance attribute or (if no instance\n attribute exists) a class attribute. The LHS target ``a.x`` is\n always set as an instance attribute, creating it if necessary.\n Thus, the two occurrences of ``a.x`` do not necessarily refer to the\n same attribute: if the RHS expression refers to a class attribute,\n the LHS creates a new instance attribute as the target of the\n assignment:\n\n class Cls:\n x = 3 # class variable\n inst = Cls()\n inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 3\n\n This description does not necessarily apply to descriptor\n attributes, such as properties created with ``property()``.\n\n* If the target is a subscription: The primary expression in the\n reference is evaluated. It should yield either a mutable sequence\n object (such as a list) or a mapping object (such as a dictionary).\n Next, the subscript expression is evaluated.\n\n If the primary is a mutable sequence object (such as a list), the\n subscript must yield a plain integer. If it is negative, the\n sequence\'s length is added to it. The resulting value must be a\n nonnegative integer less than the sequence\'s length, and the\n sequence is asked to assign the assigned object to its item with\n that index. If the index is out of range, ``IndexError`` is raised\n (assignment to a subscripted sequence cannot add new items to a\n list).\n\n If the primary is a mapping object (such as a dictionary), the\n subscript must have a type compatible with the mapping\'s key type,\n and the mapping is then asked to create a key/datum pair which maps\n the subscript to the assigned object. This can either replace an\n existing key/value pair with the same key value, or insert a new\n key/value pair (if no key with the same value existed).\n\n* If the target is a slicing: The primary expression in the reference\n is evaluated. It should yield a mutable sequence object (such as a\n list). The assigned object should be a sequence object of the same\n type. Next, the lower and upper bound expressions are evaluated,\n insofar they are present; defaults are zero and the sequence\'s\n length. The bounds should evaluate to (small) integers. If either\n bound is negative, the sequence\'s length is added to it. The\n resulting bounds are clipped to lie between zero and the sequence\'s\n length, inclusive. Finally, the sequence object is asked to replace\n the slice with the items of the assigned sequence. The length of\n the slice may be different from the length of the assigned sequence,\n thus changing the length of the target sequence, if the object\n allows it.\n\n**CPython implementation detail:** In the current implementation, the\nsyntax
for
targets is taken to be the same as
for
expressions, and\ninvalid syntax is rejected during the code generation phase, causing\nless detailed error messages.\n\nWARNING: Although the definition of assignment implies that overlaps\nbetween the left-hand side and the right-hand side are \'safe\' (
for
\nexample ``a, b = b, a`` swaps two variables), overlaps *within* the\ncollection of assigned-to variables are not safe!
For
instance, the\nfollowing program prints ``[0, 2]``:\n\n x = [0, 1]\n i = 0\n i, x[i] = 1, 2\n print x\n\n\nAugmented assignment statements\n===============================\n\nAugmented assignment is the combination, in a single statement, of a\nbinary operation and an assignment statement:\n\n augmented_assignment_stmt ::= augtarget augop (expression_list | yield_expression)\n augtarget ::= identifier | attributeref | subscription | slicing\n augop ::= "+=" | "-=" | "*=" | "/=" | "//=" | "%=" | "**="\n | ">>=" | "<<=" | "&=" | "^=" | "|="\n\n(See section *Primaries*
for
the syntax definitions for the last three\nsymbols.)\n\nAn augmented assignment evaluates the targ (…)
[
all
...]
/build/make/core/
allowed_ndk_types.mk
53
# Since nothing was actually linked
for
the static library, it is up to the
58
#
For
an app package, it's actually okay to depend on any set of STLs.
60
# already been checked
for
consistency, and if they don't they'll be
cleanspec.mk
12
# See the License
for
the specific language governing permissions and
56
#
For
example:
/build/soong/cmd/zipsync/
zipsync.go
12
// See the License
for
the specific language governing permissions and
70
//
For
now, just wipe the output directory and replace its contents with the zip files
80
for
_, input := range inputs {
87
for
_, f := range reader.File {
/build/soong/genrule/
filegroup.go
12
// See the License
for
the specific language governing permissions and
35
// of the path to use.
For
example, when a filegroup is used as data in a cc_test rule,
/compatibility/cdd/5_multimedia/
5_11_unprocessed-audio.md
1
## 5.11\. Capture
for
Unprocessed
3
Android includes support
for
recording of unprocessed audio via the
16
100 Hz to 7000 Hz
for
each and every microphone used to record the unprocessed
21
mid-frequency range
for
each and every microphone used to record the
26
mid-frequency range
for
each and every microphone used to record the
31
RMS of 520
for
16 bit-samples (or -36 dB Full Scale
for
floating point/double
32
precision samples)
for
each and every microphone used to record the unprocessed
35
* [C-1-6] MUST have a signal-to-noise ratio (SNR) at 60 dB or higher
for
41
1%
for
1 kHZ at 90 dB SPL input level at each and every microphone used t
[
all
...]
/compatibility/cdd/7_hardware-compatibility/
7_4_data-connectivity.md
8
they are
for
the purposes of Android considered independent of any data
11
calls and SMS.
For
instance, device implementations that cannot place calls or
13
whether they use a cellular network
for
data connectivity.
22
* [C-1-2] MUST implement full support
for
the API
for
that technology.
42
for
a blocked call.
45
for
a blocked message.
52
blocking related UI MUST be hidden
for
secondary users and the blocked list MUST
62
`KEYCODE_MEDIA_PLAY_PAUSE` and `KEYCODE_HEADSETHOOK` events
for
the
77
* SHOULD include support
for
one or more forms of 802.11\
[
all
...]
/development/build/
build_android_stubs.mk
9
# The source files
for
this library are _all_ generated, something we don't do
12
# building the docs. So
for
the dependency, we just use the
15
# resource files out of there
for
aapt.
26
framework_res_package := $(call intermediates-dir-
for
,APPS,framework-res,,COMMON)/package-export.apk
34
# Disable all warnings.
For
one, stubs are auto-generated and lack annotations currently. Second,
35
# any warnings should have been emitted
for
the stub sources.
88
$(hide) $(call commit-change-
for
-toc,$@)
/device/generic/goldfish-opengl/
Android.mk
1
# This is the top-level build file
for
the Android HW OpenGL ES emulation
12
# Top-level
for
all modules
64
#
For
the import/export feature to work properly, you must include
/device/linaro/bootloader/edk2/Vlv2TbltDevicePkg/FspSupport/Library/SecFspPlatformSecLibVlv2/Ia32/
PeiCoreEntry.asm
96
; We need to implement a long-term solution
for
BIST capture.
For
now, we just copy BSP BIST
97
;
for
all processor threads
/external/annotation-tools/annotation-file-utilities/
design.tex
15
The Annotation File Utilities (AFU) include programs
for
extracting
28
The use of source positions rather than tree paths
for
indicating
34
have inconsistent results
for
different representations of the same
41
path to the root, these tests can be repeated many times over
for
some
47
re-visitation of AST nodes. It reduces the chance
for
inconsistency
64
\item \texttt{annotator.scanner},\ containing support classes
for
89
and methods
for
generating the source text to be inserted.)
100
\item
For
each node in the AST in pre-order:
102
\item
For
each extracted \texttt{Insertion} that is relevant to the
103
immediately enclosing class (or package
for
compilation unit nodes)
[
all
...]
/external/antlr/antlr-3.4/runtime/ActionScript/project/src/org/antlr/runtime/
BaseRecognizer.as
13
// copies from Token object
for
convenience in actions
48
for
(var i:int = 0; state.ruleMemo!=null && i < state.ruleMemo.length; i++) { // wipe cache
95
// a single token and hope
for
the best
175
/** What error message should be generated
for
the various
180
* exception classes. This also makes it much easier
for
the exception
183
* the message
for
an exception type would be difficult because you
189
*
For
grammar debugging, you will want to override this to add
192
*
for
no viable alts, the decision description and state etc...
194
* Override this to change the message generated
for
one or more
249
//
for
development, can add "decision=<<"+nvae.grammarDecisionDescription+">>
[
all
...]
/external/golang-protobuf/ptypes/empty/
empty.pb.go
32
// or the response type of an API method.
For
instance:
38
// The JSON representation
for
`Empty` is empty JSON object `{}`.
Completed in 703 milliseconds
<<
11
12
13
14
15
16
17
18
19
20
>>