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/Zend/
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_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)) {
436 uint32_t i, children = zend_ast_get_num_children(ast); local
485 uint32_t i, children = zend_ast_get_num_children(ast); local
512 uint32_t i, children = zend_ast_get_num_children(ast); local
[all...]
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_compile.c2407 for (i = 0; i < list->children; ++i) {
2477 for (i = 0; i < list->children; i++) {
2672 for (i = 0; i < args->children; ++i) {
2887 for (i = 0; i < args->children; ++i) {
2901 || args->children != 1 || args->child[0]->kind == ZEND_AST_UNPACK
2923 if (args->children != 1 || args->child[0]->kind == ZEND_AST_UNPACK) {
2939 if (args->children != 1 || args->child[0]->kind != ZEND_AST_ZVAL) {
3021 if (args->children != 2 || zend_args_contain_unpack(args)) {
3039 if (args->children < 1 || zend_args_contain_unpack(args)) {
3043 zend_compile_init_user_func(args->child[0], args->children
3078 int children = zend_ast_is_list(ast) ? zend_ast_get_list(ast)->children : zend_ast_get_num_children(ast); local
4906 uint32_t i, children = list->children; local
[all...]
/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/opcache/
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++) {
839 for (i = 0; i < list->children; i++) {
845 uint32_t children = zend_ast_get_num_children(ast); local
846 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_persist.c244 sizeof(zend_ast_list) - sizeof(zend_ast *) + sizeof(zend_ast *) * list->children);
245 for (i = 0; i < list->children; i++) {
252 uint32_t children = zend_ast_get_num_children(ast); local
253 node = zend_accel_memdup(ast, sizeof(zend_ast) - sizeof(zend_ast *) + sizeof(zend_ast *) * children);
254 for (i = 0; i < children; i++) {
H A Dzend_persist_calc.c100 ADD_SIZE(sizeof(zend_ast_list) - sizeof(zend_ast *) + sizeof(zend_ast *) * list->children);
101 for (i = 0; i < list->children; i++) {
107 uint32_t children = zend_ast_get_num_children(ast); local
108 ADD_SIZE(sizeof(zend_ast) - sizeof(zend_ast *) + sizeof(zend_ast *) * children);
109 for (i = 0; i < children; i++) {
/PHP_TRUNK/ext/tidy/
H A Dtidy.c842 zval attribute, children, temp; local
894 array_init(&children);
904 add_next_index_zval(&children, &temp);
909 ZVAL_NULL(&children);
912 zend_hash_str_update(obj->std.properties, "child", sizeof("child") - 1, &children);
1713 Returns true if this node has children */
/PHP_TRUNK/sapi/cgi/
H A Dcgi_main.c107 /* these globals used for forking children on unix systems */
111 static int children = 0; variable
122 /* Is Parent waiting for children to exit */
1987 children = atoi(children_str);
1988 if (children < 0) {
2000 if (children) {
2004 /* Create a process group for ourself & children */
2011 /* Set up handler to kill children upon exit */
2034 /* One of the children.
2054 } while (parent && (running < children));
[all...]

Completed in 101 milliseconds