/PHP_TRUNK/ext/dom/examples/ 
H A D  dom1.php  12 // 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 D  fpm_worker_pool.h  31 struct fpm_child_s *children; member in struct:fpm_worker_pool_s

/PHP_TRUNK/ext/xmlrpc/libxmlrpc/ 
H A D  xml_element.h  155 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 D  node.c  307 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 D  tidy.c  837 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 D  zend_generators.h  34 * The solution to this problem is a doublylinked 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 multichildren 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 multichildren node and copy all the leaf node pointers from there). In case there was no multichildren 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 D  zend_ast.c  41 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 D  zend_ast.h  158 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 D  zend_compile.c  2433 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 D  zend_persist_calc.c  97 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 D  zend_accelerator_util_funcs.c  201 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 D  zend_file_cache.c  279 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 D  zend_persist.c  220 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 D  cgi_main.c  103 /* 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...] 