Searched defs:children (Results 1 - 14 of 14) sorted by relevance

/PHP_TRUNK/ext/dom/examples/
H A Ddom1.php12 // children() of of document would result in a memleak
13 //$children = $dom->children();
14 //print_node_list($children);
20 echo "--------- children of root\n";
21 $children = $rootnode->childNodes; variable
22 print_node_list($children);
24 // The last node should be identical with the last entry in the children array
34 // The children of this parent are the same children a
36 $children = $parent->childNodes; variable
63 $children = $attrs->item(0)->childNodes; variable
75 $children = $dom->getElementsByTagname("Silly"); variable
79 $children = $rootnode->getElementsByTagName("Silly"); variable
[all...]
/PHP_TRUNK/sapi/fpm/fpm/
H A Dfpm_worker_pool.h31 struct fpm_child_s *children; member in struct:fpm_worker_pool_s
/PHP_TRUNK/ext/xmlrpc/libxmlrpc/
H A Dxml_element.h155 queue children; /* child element list */ member in struct:_xml_element
185 #define xml_elem_next_element(el) ((el) ? (xml_element *)Q_Next(&el->children) : NULL)
186 #define xml_elem_head_element(el) ((el) ? (xml_element *)Q_Head(&el->children) : NULL)
/PHP_TRUNK/ext/dom/
H A Dnode.c307 str = (char *) xmlNodeGetContent(nodep->children);
338 if (nodep->children) {
339 node_list_unlink(nodep->children);
461 first = nodep->children;
872 newchild = fragment->children;
876 nodep->children = newchild;
905 fragment->children = NULL;
956 if (child->type == XML_DOCUMENT_FRAG_NODE && child->children == NULL) {
991 if (new_child->parent->children == refp) {
992 new_child->parent->children
1081 xmlNodePtr children, newchild, oldchild, nodep; local
1169 xmlNodePtr children, child, nodep; local
[all...]
/PHP_TRUNK/ext/tidy/
H A Dtidy.c837 zval attribute, children, temp; local
889 array_init(&children);
899 add_next_index_zval(&children, &temp);
904 ZVAL_NULL(&children);
907 zend_hash_str_update(obj->std.properties, "child", sizeof("child") - 1, &children);
1680 Returns true if this node has children */
/PHP_TRUNK/Zend/
H A Dzend_generators.h34 * The solution to this problem is a doubly-linked tree, which all Generators referenced in maintain a reference to. It should be impossible to avoid walking the tree in all cases. This way, we only need tree walks from leaf to root in case where some part of the `yield from` chain is passed to another `yield from`. (Update of leaf node pointer and list of multi-children nodes needed when leaf gets a child in direct path from leaf to root node.) But only in that case, which should be a fairly rare case (which is then possible, but not totally cheap).
35 * The root of the tree is then the currently executed Generator. The subnodes of the tree (all except the root node) are all Generators which do `yield from`. Each node of the tree knows a pointer to one leaf descendant node. Each node with multiple children needs a list of all leaf descendant nodes paired with pointers to their respective child node. (The stack is determined by leaf node pointers) Nodes with only one child just don't need a list, there it is enough to just have a pointer to the child node. Further, leaf nodes store a pointer to the root node.
36 * That way, when we advance any generator, we just need to look up a leaf node (which all have a reference to a root node). Then we can see at the root node whether current Generator is finished. If it isn't, all is fine and we can just continue. If the Generator finished, there will be two cases. Either it is a simple node with just one child, then go down to child node. Or it has multiple children and we now will remove the current leaf node from the list of nodes (unnecessary, is microoptimization) and go down to the child node whose reference was paired with current leaf node. Child node is then removed its parent reference and becomes new top node. Or the current node references the Generator we're currently executing, then we can continue from the YIELD_FROM opcode. When a node referenced as root node in a leaf node has a parent, then we go the way up until we find a root node without parent.
38 * When a Generator referenced by a node of the tree is added to `yield from`, that node now gets a list of children (we need to walk the descendants of that node and nodes of the tree of the other Generator down to the first multi-children node and copy all the leaf node pointers from there). In case there was no multi-children node (linear tree), we just add a pair (pointer to leaf node, pointer to child node), with the child node being in a direct path from leaf to this node.
43 uint32_t children; member in struct:_zend_generator_node
45 HashTable ht; /* if > 4 children */
49 } array[4]; /* if <= 4 children */
52 zend_generator *leaf; /* if > 0 children */
[all...]
H A Dzend_ast.c41 static inline size_t zend_ast_size(uint32_t children) { argument
42 return sizeof(zend_ast) - sizeof(zend_ast *) + sizeof(zend_ast *) * children;
45 static inline size_t zend_ast_list_size(uint32_t children) { argument
46 return sizeof(zend_ast_list) - sizeof(zend_ast *) + sizeof(zend_ast *) * children;
95 uint32_t i, children = kind >> ZEND_AST_NUM_CHILDREN_SHIFT; local
98 ast = zend_ast_alloc(zend_ast_size(children));
103 for (i = 0; i < children; ++i) {
151 list->children = 0;
172 if (list->children >= 4 && is_power_of_two(list->children)) {
431 uint32_t i, children = zend_ast_get_num_children(ast); local
480 uint32_t i, children = zend_ast_get_num_children(ast); local
507 uint32_t i, children = zend_ast_get_num_children(ast); local
[all...]
H A Dzend_ast.h158 zend_ast *child[1]; /* Array of children (using struct hack) */
161 /* Same as zend_ast, but with children count, which is updated dynamically */
166 uint32_t children; member in struct:_zend_ast_list
H A Dzend_compile.c2433 for (i = 0; i < list->children; ++i) {
2503 for (i = 0; i < list->children; i++) {
2698 for (i = 0; i < args->children; ++i) {
2898 for (i = 0; i < args->children; ++i) {
2912 || args->children != 1 || args->child[0]->kind == ZEND_AST_UNPACK
2928 if (args->children != 1 || args->child[0]->kind == ZEND_AST_UNPACK) {
2944 if (args->children != 1 || args->child[0]->kind != ZEND_AST_ZVAL) {
3025 if (args->children != 2 || zend_args_contain_unpack(args)) {
3043 if (args->children < 1 || zend_args_contain_unpack(args)) {
3047 zend_compile_init_user_func(args->child[0], args->children
4732 uint32_t i, children = list->children; local
[all...]
/PHP_TRUNK/ext/opcache/
H A Dzend_persist_calc.c97 ADD_SIZE(sizeof(zend_ast_list) - sizeof(zend_ast *) + sizeof(zend_ast *) * list->children);
98 for (i = 0; i < list->children; i++) {
104 uint32_t children = zend_ast_get_num_children(ast); local
105 ADD_SIZE(sizeof(zend_ast) - sizeof(zend_ast *) + sizeof(zend_ast *) * children);
106 for (i = 0; i < children; i++) {
H A Dzend_accelerator_util_funcs.c201 sizeof(zend_ast_list) - sizeof(zend_ast *) + sizeof(zend_ast *) * list->children);
204 copy->children = list->children;
205 for (i = 0; i < list->children; i++) {
214 uint32_t children = zend_ast_get_num_children(ast); local
215 zend_ast *copy = emalloc(sizeof(zend_ast) - sizeof(zend_ast *) + sizeof(zend_ast *) * children);
218 for (i = 0; i < children; i++) {
H A Dzend_file_cache.c279 for (i = 0; i < list->children; i++) {
285 uint32_t children = zend_ast_get_num_children(ast); local
286 for (i = 0; i < children; i++) {
815 for (i = 0; i < list->children; i++) {
821 uint32_t children = zend_ast_get_num_children(ast); local
822 for (i = 0; i < children; i++) {
H A Dzend_persist.c220 sizeof(zend_ast_list) - sizeof(zend_ast *) + sizeof(zend_ast *) * list->children);
221 for (i = 0; i < list->children; i++) {
228 uint32_t children = zend_ast_get_num_children(ast); local
229 node = zend_accel_memdup(ast, sizeof(zend_ast) - sizeof(zend_ast *) + sizeof(zend_ast *) * children);
230 for (i = 0; i < children; i++) {
/PHP_TRUNK/sapi/cgi/
H A Dcgi_main.c103 /* these globals used for forking children on unix systems */
107 static int children = 0; variable
118 /* Is Parent waiting for children to exit */
1981 children = atoi(children_str);
1982 if (children < 0) {
1994 if (children) {
1998 /* Create a process group for ourself & children */
2005 /* Set up handler to kill children upon exit */
2028 /* One of the children.
2048 } while (parent && (running < children));
[all...]

Completed in 39 milliseconds