| /sdk/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/gle2/ |
| LintOverlay.java | 64 Collection<Node> nodes = editor.getLintNodes(); local
65 if (nodes != null && !nodes.isEmpty()) {
68 nodes = Lists.newArrayList(nodes);
86 for (Node node : nodes) {
|
| /libcore/luni/src/main/java/javax/xml/transform/dom/ |
| DOMResult.java | 98 * <p>Use a DOM node to create a new output target specifying the child node where the result nodes should be inserted before.</p>
107 * where the result nodes should be inserted before.
114 * i.e. append the result nodes as the last child of the specified <code>node</code>.</p>
119 * @param nextSibling The child node where the result nodes should be inserted before.
147 * <p>Use a DOM node to create a new output target specifying the child node where the result nodes should be inserted before and
157 * where the result nodes should be inserted before.
164 * i.e. append the result nodes as the last child of the specified node and use the specified System ID.</p>
167 * @param nextSibling The child node where the result nodes should be inserted before.
252 * <p>Set the child node before which the result nodes will be inserted.</p>
255 * before which the result nodes should be inserted
[all...] |
| /external/antlr/antlr-3.4/runtime/Ruby/lib/antlr3/ |
| tree.rb | 89 Mainly, it customizes a few methods specifically to deal with tree nodes
95 assumptions about the class of the actual nodes it processes. One consequence of
98 construction and analysis of your tree nodes.
187 ############################################ Tree Nodes ############################################
200 tree nodes as well as the methods trees need to implement.
211 tree nodes
214 [siblings] all other nodes sharing the same parent as some node
453 value) and contains zero or more child tree nodes. Additionally, it tracks
677 * copying and creating tree nodes and tokens
678 * defining parent-child relationships between nodes
[all...] |
| /build/core/ |
| node_fns.mk | 121 # $(call get-inherited-nodes,PREFIX,A B)
128 define get-inherited-nodes
151 $(eval ### "Get the list of nodes that this variable inherits") \
198 $(call get-inherited-nodes,$(1).$(2),$(3)))
199 $(call _import-nodes-inner,$(1),$($(1).$(2).inherited),$(3))
216 # $(2): list of makefiles representing nodes to import
221 define _import-nodes-inner
238 # $(2): list of makefiles representing nodes to import
241 define import-nodes
248 $(call _import-nodes-inner,$(_node_import_context),$(_in),$(3))
[all...] |
| /external/chromium-trace/catapult/telemetry/third_party/altgraph/doc/ |
| dot.rst | 62 valid :command:`dot` parameters for the nodes and edges. For a list of all
103 weight = number (the larger the number the closer the nodes will be)
114 .. class:: Dot(graph[, nodes[, edgefn[, nodevisitor[, edgevisitor[, name[, dot[, dotty[, neato[, graphtype]]]]]]]]])
120 If the *nodes* argument is present it is the list of nodes to include
121 in the graph, otherwise all nodes in *graph* are included.
124 nodes connected to another node, this defaults to
127 are in *nodes*.
160 Replaces the current style for all nodes
167 and *tail* must both be valid nodes
[all...] |
| /external/clang/include/clang/ASTMatchers/ |
| ASTMatchFinder.h | 18 // AST nodes that the subexpressions matched on to output information about
26 // Result.Nodes.GetDeclAs<CXXRecordDecl>("id");
76 MatchResult(const BoundNodes &Nodes, clang::ASTContext *Context);
78 /// \brief Contains the nodes bound on the current match.
80 /// This allows user code to easily extract matched AST nodes.
81 const BoundNodes Nodes;
268 Nodes.push_back(Result.Nodes);
270 SmallVector<BoundNodes, 1> Nodes;
282 return std::move(Callback.Nodes);
[all...] |
| /external/google-breakpad/src/processor/ |
| map_serializers_unittest.cc | 82 // # of nodes
104 // # of nodes
154 // # of nodes
176 // # of nodes
229 // # of nodes
250 // # of nodes
311 1, // # of nodes
345 // root's map: # of nodes, offset1, offset2, key1, key2
349 // child1's map: # of nodes, offset1, offset2, key1, key2
357 // child2's map: # of nodes, offset1, key
[all...] |
| /external/llvm/include/llvm/Analysis/ |
| BlockFrequencyInfoImpl.h | 204 NodeList Nodes; ///< Header and the members of the loop.
210 : Parent(Parent), IsPackaged(false), NumHeaders(1), Nodes(1, Header),
215 : Parent(Parent), IsPackaged(false), Nodes(FirstHeader, LastHeader) {
216 NumHeaders = Nodes.size();
217 Nodes.insert(Nodes.end(), FirstOther, LastOther);
222 return std::binary_search(Nodes.begin(), Nodes.begin() + NumHeaders,
224 return Node == Nodes[0];
226 BlockNode getHeader() const { return Nodes[0];
[all...] |
| /external/v8/src/compiler/ |
| control-flow-optimizer.cc | 79 // a constant). Note that there may be more Phi nodes hanging off the Merge,
81 // EffectPhi nodes whose uses have either the IfTrue or IfFalse as control
103 // The resulting graph (modulo the Phi and EffectPhi nodes) looks like this:
133 // Check/collect other Phi/EffectPhi nodes hanging off the Merge.
137 // We cannot currently deal with non-Phi/EffectPhi nodes hanging off the
138 // Merge. Ideally, we would just clone the nodes (and everything that
143 // Right now we can only handle Phi/EffectPhi nodes whose uses are
146 // TODO(turbofan): Generalize this to all Phi/EffectPhi nodes using
147 // dominance/post-dominance on the sea of nodes.
194 // Fix up IfTrue and IfFalse and kill all dead nodes
[all...] |
| schedule.h | 26 // A basic block contains an ordered list of nodes and ends with a control
28 // first nodes in the block.
31 // Possible control nodes that can end a block.
77 // Nodes in the basic block.
163 NodeVector nodes_; // nodes of this block in forward order.
176 // A schedule represents the result of assigning nodes to basic blocks
193 // Check if nodes {a} and {b} are in the same block.
|
| state-values-utils.cc | 34 // If the nodes are already processed, they must be the same.
93 int StateValuesHashKey(Node** nodes, size_t count) {
96 hash = hash * 23 + nodes[i]->id();
104 Node* StateValuesCache::GetValuesNodeFromCache(Node** nodes, size_t count) {
105 StateValuesKey key(count, nodes);
106 int hash = StateValuesHashKey(nodes, count);
114 nodes);
|
| /libcore/luni/src/main/java/org/w3c/dom/ls/ |
| LSParserFilter.java | 20 * nodes as they are being constructed while parsing. As each node is
28 * <code>Entity</code>, and <code>Attr</code> nodes are never passed to the
29 * <code>acceptNode</code> method on the filter. The child nodes of an
33 * entities</a>", unexpanded entity reference nodes are never discarded and are always
73 * only element nodes are passed to the <code>startElement</code>
77 * children nodes. The Element may not yet be in place in the document
118 * been parsed. Attribute nodes are never passed to this function.
120 * children may be added or removed, text nodes modified, etc. The state
158 * Tells the <code>LSParser</code> what types of nodes to show to the
165 * <code>SHOW_DOCUMENT_FRAGMENT</code> are meaningless here. Those nodes
[all...] |
| /packages/apps/UnifiedEmail/src/com/google/android/mail/common/html/parser/ |
| HtmlTree.java | 41 * of the tree, we simply keeps a linear list of nodes (in-order).
43 * nodes:
101 /** Contains html nodes */
102 private final List<HtmlDocument.Node> nodes = new ArrayList<HtmlDocument.Node>(); field in class:HtmlTree
147 * @return the nodes of the tree
150 return Collections.unmodifiableList(nodes);
154 * @return number of nodes
157 return nodes.size();
165 X.assertTrue(endTagNodeNum >= 0 && endTagNodeNum < nodes.size());
174 X.assertTrue(openTagNodeNum >= 0 && openTagNodeNum < nodes.size())
[all...] |
| /external/clang/lib/ASTMatchers/ |
| ASTMatchFinder.cpp | 10 // Implements an algorithm to efficiently search for matches on AST nodes.
13 // The general idea is to visit all AST nodes with a RecursiveASTVisitor,
51 // bound nodes before the matcher was executed.
53 // We currently only memoize on nodes whose pointers identify the
54 // nodes (\c Stmt and \c Decl, but not \c QualType or \c TypeLoc).
57 // FIXME: Benchmark whether memoization of non-pointer typed nodes
70 // Used to store the result of a match and possibly bound nodes.
73 BoundNodesTreeBuilder Nodes;
131 // It's OK to always overwrite the bound nodes, as if there was
380 // For AST-nodes that don't have an identity, we can't memoize
[all...] |
| /external/opencv3/modules/core/include/opencv2/core/ |
| operations.hpp | 449 int (*nodes)[2] = (int(*)[2])&_nodes[0];
454 nodes[i][PARENT]=-1;
455 nodes[i][RANK] = 0;
464 while( nodes[root][PARENT] >= 0 )
465 root = nodes[root][PARENT];
473 while( nodes[root2][PARENT] >= 0 )
474 root2 = nodes[root2][PARENT];
479 int rank = nodes[root][RANK], rank2 = nodes[root2][RANK];
481 nodes[root2][PARENT] = root
[all...] |
| /external/apache-xml/src/main/java/org/apache/xalan/transformer/ |
| NodeSorter.java | 35 * This class can sort vectors of DOM nodes according to a select pattern.
65 * Given a vector of nodes, sort each node according to
67 * @param v an vector of Nodes.
87 // based on the input vector of nodes
88 Vector nodes = new Vector(); local
94 nodes.addElement(elem);
99 mergesort(nodes, scratchVector, 0, n - 1, support);
101 // return sorted vector of nodes
104 v.setItem(((NodeCompareElem) nodes.elementAt(i)).m_node, i);
114 * Return the results of a compare of two nodes
[all...] |
| /external/icu/icu4c/source/common/unicode/ |
| stringtriebuilder.h | 169 * registerNode() and registerFinalValue() take ownership of their input nodes,
170 * and only return owned nodes.
175 * NULL Node pointers can be safely passed into other Nodes because
183 // Hash set of nodes, maps from nodes to integer 1.
185 UHashtable *nodes; member in class:StringTrieBuilder
202 * Branch nodes in this trie data structure are not symmetric.
203 * Most branch edges "jump" to other nodes but the rightmost branch edges
211 * offset field which gets positive values when nodes are written.
218 * After root.markRightEdgesFirst(-1) the offsets of all nodes are negativ
[all...] |
| /external/icu/icu4c/source/i18n/ |
| collationbuilder.cpp | 210 rootPrimaryIndexes(errorCode), nodes(errorCode) {
322 int64_t node = nodes.elementAti(index);
324 // then skip backwards over this and further "weaker" nodes.
327 node = nodes.elementAti(index);
357 // Tailor after the last node between adjacent root nodes.
359 node = nodes.elementAti(index);
372 node = nodes.elementAti(index);
394 node = nodes.elementAti(i);
408 // Skip weaker nodes and same-level tailored nodes
[all...] |
| /external/v8/test/cctest/compiler/ |
| test-js-constant-cache.cc | 205 Node* nodes[] = {T.UndefinedConstant(), T.TheHoleConstant(), T.TrueConstant(), local
210 for (size_t i = 0; i < arraysize(nodes); i++) {
211 for (size_t j = 0; j < arraysize(nodes); j++) {
212 if (i != j) CHECK_NE(nodes[i], nodes[j]);
300 static bool Contains(NodeVector* nodes, Node* n) {
301 for (size_t i = 0; i < nodes->size(); i++) {
302 if (nodes->at(i) == n) return true;
309 NodeVector nodes(T->main_zone());
310 T->GetCachedNodes(&nodes);
[all...] |
| /external/fio/t/ |
| genzipf.c | 177 struct node *nodes; local
206 nodes = malloc(nranges * sizeof(struct node));
220 hash_insert(&nodes[j], offset);
227 qsort(nodes, j, sizeof(struct node), node_cmp);
234 printf("%lu, %lu\n", k, nodes[k].hits);
248 struct node *node = &nodes[k];
320 free(nodes);
|
| /external/opencv3/modules/objdetect/src/ |
| cascadedetect_convert.cpp | 104 std::vector<HaarClassifierNode> nodes; member in struct:cv::haar_cvt::HaarClassifier
192 weak.nodes.push_back(node);
229 int nnodes = (int)c.nodes.size(), nleaves = (int)c.leaves.size();
231 newfs << c.nodes[k].left << c.nodes[k].right
232 << c.nodes[k].f << c.nodes[k].threshold;
|
| /external/selinux/libsepol/cil/src/ |
| cil_symtab.c | 67 cil_list_init(&datum->nodes, CIL_LIST_ITEM);
72 cil_list_destroy(&datum->nodes, 0);
78 if (datum && datum->nodes != NULL) {
79 cil_list_remove(datum->nodes, CIL_NODE, node, 0);
80 if (datum->nodes->head == NULL) {
95 cil_list_append(datum->nodes, CIL_NODE, node);
97 cil_list_append(datum->nodes, CIL_NODE, node);
|
| /external/snakeyaml/src/main/java/org/yaml/snakeyaml/composer/ |
| Composer.java | 31 import org.yaml.snakeyaml.nodes.MappingNode;
32 import org.yaml.snakeyaml.nodes.Node;
33 import org.yaml.snakeyaml.nodes.NodeId;
34 import org.yaml.snakeyaml.nodes.NodeTuple;
35 import org.yaml.snakeyaml.nodes.ScalarNode;
36 import org.yaml.snakeyaml.nodes.SequenceNode;
37 import org.yaml.snakeyaml.nodes.Tag;
|
| /external/snakeyaml/src/main/java/org/yaml/snakeyaml/representer/ |
| Representer.java | 30 import org.yaml.snakeyaml.nodes.MappingNode;
31 import org.yaml.snakeyaml.nodes.Node;
32 import org.yaml.snakeyaml.nodes.NodeId;
33 import org.yaml.snakeyaml.nodes.NodeTuple;
34 import org.yaml.snakeyaml.nodes.ScalarNode;
35 import org.yaml.snakeyaml.nodes.SequenceNode;
36 import org.yaml.snakeyaml.nodes.Tag;
|
| /build/kati/ |
| serialize.go | 135 Nodes []*serializableDepNode
162 nodes []*serializableDepNode
190 func (ns *depNodesSerializer) serializeDepNodes(nodes []*DepNode) {
194 for _, n := range nodes {
243 ns.nodes = append(ns.nodes, &serializableDepNode{
277 ns.serializeDepNodes(g.nodes)
280 Nodes: ns.nodes,
512 nodes := g.Node
[all...] |
