PHP  
 PHP: Test and Code Coverage Analysis
downloads | QA | documentation | faq | getting help | mailing lists | reporting bugs | php.net sites | links | my php.net 
 

LCOV - code coverage report
Current view: top level - ext/dom - node.c (source / functions) Hit Total Coverage
Test: PHP Code Coverage Lines: 577 822 70.2 %
Date: 2019-05-06 Functions: 37 44 84.1 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :    +----------------------------------------------------------------------+
       3             :    | PHP Version 7                                                        |
       4             :    +----------------------------------------------------------------------+
       5             :    | Copyright (c) The PHP Group                                          |
       6             :    +----------------------------------------------------------------------+
       7             :    | This source file is subject to version 3.01 of the PHP license,      |
       8             :    | that is bundled with this package in the file LICENSE, and is        |
       9             :    | available through the world-wide-web at the following url:           |
      10             :    | http://www.php.net/license/3_01.txt                                  |
      11             :    | If you did not receive a copy of the PHP license and are unable to   |
      12             :    | obtain it through the world-wide-web, please send a note to          |
      13             :    | license@php.net so we can mail you a copy immediately.               |
      14             :    +----------------------------------------------------------------------+
      15             :    | Authors: Christian Stocker <chregu@php.net>                          |
      16             :    |          Rob Richards <rrichards@php.net>                            |
      17             :    +----------------------------------------------------------------------+
      18             : */
      19             : 
      20             : #ifdef HAVE_CONFIG_H
      21             : #include "config.h"
      22             : #endif
      23             : 
      24             : #include "php.h"
      25             : #if HAVE_LIBXML && HAVE_DOM
      26             : #include "php_dom.h"
      27             : 
      28             : /* {{{ arginfo */
      29             : ZEND_BEGIN_ARG_INFO_EX(arginfo_dom_node_insert_before, 0, 0, 1)
      30             :         ZEND_ARG_OBJ_INFO(0, newChild, DOMNode, 0)
      31             :         ZEND_ARG_OBJ_INFO(0, refChild, DOMNode, 1)
      32             : ZEND_END_ARG_INFO();
      33             : 
      34             : ZEND_BEGIN_ARG_INFO_EX(arginfo_dom_node_replace_child, 0, 0, 2)
      35             :         ZEND_ARG_OBJ_INFO(0, newChild, DOMNode, 0)
      36             :         ZEND_ARG_OBJ_INFO(0, oldChild, DOMNode, 0)
      37             : ZEND_END_ARG_INFO();
      38             : 
      39             : ZEND_BEGIN_ARG_INFO_EX(arginfo_dom_node_remove_child, 0, 0, 1)
      40             :         ZEND_ARG_OBJ_INFO(0, oldChild, DOMNode, 0)
      41             : ZEND_END_ARG_INFO();
      42             : 
      43             : ZEND_BEGIN_ARG_INFO_EX(arginfo_dom_node_append_child, 0, 0, 1)
      44             :         ZEND_ARG_OBJ_INFO(0, newChild, DOMNode, 0)
      45             : ZEND_END_ARG_INFO();
      46             : 
      47             : ZEND_BEGIN_ARG_INFO_EX(arginfo_dom_node_has_child_nodes, 0, 0, 0)
      48             : ZEND_END_ARG_INFO();
      49             : 
      50             : ZEND_BEGIN_ARG_INFO_EX(arginfo_dom_node_clone_node, 0, 0, 0)
      51             :         ZEND_ARG_INFO(0, deep)
      52             : ZEND_END_ARG_INFO();
      53             : 
      54             : ZEND_BEGIN_ARG_INFO_EX(arginfo_dom_node_normalize, 0, 0, 0)
      55             : ZEND_END_ARG_INFO();
      56             : 
      57             : ZEND_BEGIN_ARG_INFO_EX(arginfo_dom_node_is_supported, 0, 0, 2)
      58             :         ZEND_ARG_INFO(0, feature)
      59             :         ZEND_ARG_INFO(0, version)
      60             : ZEND_END_ARG_INFO();
      61             : 
      62             : ZEND_BEGIN_ARG_INFO_EX(arginfo_dom_node_has_attributes, 0, 0, 0)
      63             : ZEND_END_ARG_INFO();
      64             : 
      65             : ZEND_BEGIN_ARG_INFO_EX(arginfo_dom_node_compare_document_position, 0, 0, 1)
      66             :         ZEND_ARG_OBJ_INFO(0, other, DOMNode, 0)
      67             : ZEND_END_ARG_INFO();
      68             : 
      69             : ZEND_BEGIN_ARG_INFO_EX(arginfo_dom_node_is_same_node, 0, 0, 1)
      70             :         ZEND_ARG_OBJ_INFO(0, other, DOMNode, 0)
      71             : ZEND_END_ARG_INFO();
      72             : 
      73             : ZEND_BEGIN_ARG_INFO_EX(arginfo_dom_node_lookup_prefix, 0, 0, 1)
      74             :         ZEND_ARG_INFO(0, namespaceURI)
      75             : ZEND_END_ARG_INFO();
      76             : 
      77             : ZEND_BEGIN_ARG_INFO_EX(arginfo_dom_node_is_default_namespace, 0, 0, 1)
      78             :         ZEND_ARG_INFO(0, namespaceURI)
      79             : ZEND_END_ARG_INFO();
      80             : 
      81             : ZEND_BEGIN_ARG_INFO_EX(arginfo_dom_node_lookup_namespace_uri, 0, 0, 1)
      82             :         ZEND_ARG_INFO(0, prefix)
      83             : ZEND_END_ARG_INFO();
      84             : 
      85             : ZEND_BEGIN_ARG_INFO_EX(arginfo_dom_node_is_equal_node, 0, 0, 1)
      86             :         ZEND_ARG_OBJ_INFO(0, arg, DOMNode, 0)
      87             : ZEND_END_ARG_INFO();
      88             : 
      89             : ZEND_BEGIN_ARG_INFO_EX(arginfo_dom_node_get_feature, 0, 0, 2)
      90             :         ZEND_ARG_INFO(0, feature)
      91             :         ZEND_ARG_INFO(0, version)
      92             : ZEND_END_ARG_INFO();
      93             : 
      94             : ZEND_BEGIN_ARG_INFO_EX(arginfo_dom_node_set_user_data, 0, 0, 3)
      95             :         ZEND_ARG_INFO(0, key)
      96             :         ZEND_ARG_INFO(0, data)
      97             :         ZEND_ARG_INFO(0, handler)
      98             : ZEND_END_ARG_INFO();
      99             : 
     100             : ZEND_BEGIN_ARG_INFO_EX(arginfo_dom_node_get_user_data, 0, 0, 1)
     101             :         ZEND_ARG_INFO(0, key)
     102             : ZEND_END_ARG_INFO();
     103             : 
     104             : ZEND_BEGIN_ARG_INFO_EX(arginfo_dom_node_getNodePath, 0, 0, 0)
     105             : ZEND_END_ARG_INFO();
     106             : 
     107             : ZEND_BEGIN_ARG_INFO_EX(arginfo_dom_node_getLineNo, 0, 0, 0)
     108             : ZEND_END_ARG_INFO();
     109             : 
     110             : ZEND_BEGIN_ARG_INFO_EX(arginfo_dom_node_C14N, 0, 0, 0)
     111             :         ZEND_ARG_INFO(0, exclusive)
     112             :         ZEND_ARG_INFO(0, with_comments)
     113             :         ZEND_ARG_ARRAY_INFO(0, xpath, 1)
     114             :         ZEND_ARG_ARRAY_INFO(0, ns_prefixes, 1)
     115             : ZEND_END_ARG_INFO();
     116             : 
     117             : ZEND_BEGIN_ARG_INFO_EX(arginfo_dom_node_C14NFile, 0, 0, 1)
     118             :         ZEND_ARG_INFO(0, uri)
     119             :         ZEND_ARG_INFO(0, exclusive)
     120             :         ZEND_ARG_INFO(0, with_comments)
     121             :         ZEND_ARG_ARRAY_INFO(0, xpath, 1)
     122             :         ZEND_ARG_ARRAY_INFO(0, ns_prefixes, 1)
     123             : ZEND_END_ARG_INFO();
     124             : /* }}} */
     125             : 
     126             : /*
     127             : * class DOMNode
     128             : *
     129             : * URL: https://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-1950641247
     130             : * Since:
     131             : */
     132             : 
     133             : const zend_function_entry php_dom_node_class_functions[] = { /* {{{ */
     134             :         PHP_FALIAS(insertBefore, dom_node_insert_before, arginfo_dom_node_insert_before)
     135             :         PHP_FALIAS(replaceChild, dom_node_replace_child, arginfo_dom_node_replace_child)
     136             :         PHP_FALIAS(removeChild, dom_node_remove_child, arginfo_dom_node_remove_child)
     137             :         PHP_FALIAS(appendChild, dom_node_append_child, arginfo_dom_node_append_child)
     138             :         PHP_FALIAS(hasChildNodes, dom_node_has_child_nodes, arginfo_dom_node_has_child_nodes)
     139             :         PHP_FALIAS(cloneNode, dom_node_clone_node, arginfo_dom_node_clone_node)
     140             :         PHP_FALIAS(normalize, dom_node_normalize, arginfo_dom_node_normalize)
     141             :         PHP_FALIAS(isSupported, dom_node_is_supported, arginfo_dom_node_is_supported)
     142             :         PHP_FALIAS(hasAttributes, dom_node_has_attributes, arginfo_dom_node_has_attributes)
     143             :         PHP_FALIAS(compareDocumentPosition, dom_node_compare_document_position, arginfo_dom_node_compare_document_position)
     144             :         PHP_FALIAS(isSameNode, dom_node_is_same_node, arginfo_dom_node_is_same_node)
     145             :         PHP_FALIAS(lookupPrefix, dom_node_lookup_prefix, arginfo_dom_node_lookup_prefix)
     146             :         PHP_FALIAS(isDefaultNamespace, dom_node_is_default_namespace, arginfo_dom_node_is_default_namespace)
     147             :         PHP_FALIAS(lookupNamespaceUri, dom_node_lookup_namespace_uri, arginfo_dom_node_lookup_namespace_uri)
     148             :         PHP_FALIAS(isEqualNode, dom_node_is_equal_node, arginfo_dom_node_is_equal_node)
     149             :         PHP_FALIAS(getFeature, dom_node_get_feature, arginfo_dom_node_get_feature)
     150             :         PHP_FALIAS(setUserData, dom_node_set_user_data, arginfo_dom_node_set_user_data)
     151             :         PHP_FALIAS(getUserData, dom_node_get_user_data, arginfo_dom_node_get_user_data)
     152             :         PHP_ME(domnode, getNodePath, arginfo_dom_node_getNodePath, ZEND_ACC_PUBLIC)
     153             :         PHP_ME(domnode, getLineNo, arginfo_dom_node_getLineNo, ZEND_ACC_PUBLIC)
     154             :         PHP_ME(domnode, C14N, arginfo_dom_node_C14N, ZEND_ACC_PUBLIC)
     155             :         PHP_ME(domnode, C14NFile, arginfo_dom_node_C14NFile, ZEND_ACC_PUBLIC)
     156             :         PHP_FE_END
     157             : };
     158             : /* }}} */
     159             : 
     160         172 : static void dom_reconcile_ns(xmlDocPtr doc, xmlNodePtr nodep) /* {{{ */
     161             : {
     162         172 :         xmlNsPtr nsptr, nsdftptr, curns, prevns = NULL;
     163             : 
     164         172 :         if (nodep->type == XML_ELEMENT_NODE) {
     165             :                 /* Following if block primarily used for inserting nodes created via createElementNS */
     166         123 :                 if (nodep->nsDef != NULL) {
     167          11 :                         curns = nodep->nsDef;
     168          34 :                         while (curns) {
     169          12 :                                 nsdftptr = curns->next;
     170          12 :                                 if (curns->href != NULL) {
     171          17 :                                         if((nsptr = xmlSearchNsByHref(doc, nodep->parent, curns->href)) &&
     172           6 :                                                 (curns->prefix == NULL || xmlStrEqual(nsptr->prefix, curns->prefix))) {
     173           5 :                                                 curns->next = NULL;
     174           5 :                                                 if (prevns == NULL) {
     175           5 :                                                         nodep->nsDef = nsdftptr;
     176             :                                                 } else {
     177           0 :                                                         prevns->next = nsdftptr;
     178             :                                                 }
     179           5 :                                                 dom_set_old_ns(doc, curns);
     180           5 :                                                 curns = prevns;
     181             :                                         }
     182             :                                 }
     183          12 :                                 prevns = curns;
     184          12 :                                 curns = nsdftptr;
     185             :                         }
     186             :                 }
     187         123 :                 xmlReconciliateNs(doc, nodep);
     188             :         }
     189         172 : }
     190             : /* }}} */
     191             : 
     192             : /* {{{ nodeName string
     193             : readonly=yes
     194             : URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-F68D095
     195             : Since:
     196             : */
     197         271 : int dom_node_node_name_read(dom_object *obj, zval *retval)
     198             : {
     199             :         xmlNode *nodep;
     200             :         xmlNsPtr ns;
     201         271 :         char *str = NULL;
     202         271 :         xmlChar *qname = NULL;
     203             : 
     204         271 :         nodep = dom_object_get_node(obj);
     205             : 
     206         271 :         if (nodep == NULL) {
     207           0 :                 php_dom_throw_error(INVALID_STATE_ERR, 0);
     208           0 :                 return FAILURE;
     209             :         }
     210             : 
     211         271 :         switch (nodep->type) {
     212         151 :                 case XML_ATTRIBUTE_NODE:
     213             :                 case XML_ELEMENT_NODE:
     214         151 :                         ns = nodep->ns;
     215         151 :                         if (ns != NULL && ns->prefix) {
     216           9 :                                 qname = xmlStrdup(ns->prefix);
     217           9 :                                 qname = xmlStrcat(qname, (xmlChar *) ":");
     218           9 :                                 qname = xmlStrcat(qname, nodep->name);
     219           9 :                                 str = (char *) qname;
     220             :                         } else {
     221         142 :                                 str = (char *) nodep->name;
     222             :                         }
     223         151 :                         break;
     224           0 :                 case XML_NAMESPACE_DECL:
     225           0 :                         ns = nodep->ns;
     226           0 :                         if (ns != NULL && ns->prefix) {
     227           0 :                                 qname = xmlStrdup((xmlChar *) "xmlns");
     228           0 :                                 qname = xmlStrcat(qname, (xmlChar *) ":");
     229           0 :                                 qname = xmlStrcat(qname, nodep->name);
     230           0 :                                 str = (char *) qname;
     231             :                         } else {
     232           0 :                                 str = (char *) nodep->name;
     233             :                         }
     234           0 :                         break;
     235          11 :                 case XML_DOCUMENT_TYPE_NODE:
     236             :                 case XML_DTD_NODE:
     237             :                 case XML_PI_NODE:
     238             :                 case XML_ENTITY_DECL:
     239             :                 case XML_ENTITY_REF_NODE:
     240             :                 case XML_NOTATION_NODE:
     241          11 :                         str = (char *) nodep->name;
     242          11 :                         break;
     243           0 :                 case XML_CDATA_SECTION_NODE:
     244           0 :                         str = "#cdata-section";
     245           0 :                         break;
     246           0 :                 case XML_COMMENT_NODE:
     247           0 :                         str = "#comment";
     248           0 :                         break;
     249           1 :                 case XML_HTML_DOCUMENT_NODE:
     250             :                 case XML_DOCUMENT_NODE:
     251           1 :                         str = "#document";
     252           1 :                         break;
     253           5 :                 case XML_DOCUMENT_FRAG_NODE:
     254           5 :                         str = "#document-fragment";
     255           5 :                         break;
     256         103 :                 case XML_TEXT_NODE:
     257         103 :                         str = "#text";
     258         103 :                         break;
     259           0 :                 default:
     260           0 :                         php_error_docref(NULL, E_WARNING, "Invalid Node Type");
     261             :         }
     262             : 
     263         271 :         if (str != NULL) {
     264         542 :                 ZVAL_STRING(retval, str);
     265             :         } else {
     266           0 :                 ZVAL_EMPTY_STRING(retval);
     267             :         }
     268             : 
     269         271 :         if (qname != NULL) {
     270           9 :                 xmlFree(qname);
     271             :         }
     272             : 
     273         271 :         return SUCCESS;
     274             : 
     275             : }
     276             : 
     277             : /* }}} */
     278             : 
     279             : /* {{{ nodeValue        string
     280             : readonly=no
     281             : URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-F68D080
     282             : Since:
     283             : */
     284         225 : int dom_node_node_value_read(dom_object *obj, zval *retval)
     285             : {
     286         225 :         xmlNode *nodep = dom_object_get_node(obj);
     287         225 :         char *str = NULL;
     288             : 
     289         225 :         if (nodep == NULL) {
     290           0 :                 php_dom_throw_error(INVALID_STATE_ERR, 0);
     291           0 :                 return FAILURE;
     292             :         }
     293             : 
     294             :         /* Access to Element node is implemented as a convenience method */
     295         225 :         switch (nodep->type) {
     296         219 :                 case XML_ATTRIBUTE_NODE:
     297             :                 case XML_TEXT_NODE:
     298             :                 case XML_ELEMENT_NODE:
     299             :                 case XML_COMMENT_NODE:
     300             :                 case XML_CDATA_SECTION_NODE:
     301             :                 case XML_PI_NODE:
     302         219 :                         str = (char *) xmlNodeGetContent(nodep);
     303         219 :                         break;
     304           0 :                 case XML_NAMESPACE_DECL:
     305           0 :                         str = (char *) xmlNodeGetContent(nodep->children);
     306           0 :                         break;
     307           6 :                 default:
     308           6 :                         str = NULL;
     309           6 :                         break;
     310             :         }
     311             : 
     312         225 :         if(str != NULL) {
     313         438 :                 ZVAL_STRING(retval, str);
     314         219 :                 xmlFree(str);
     315             :         } else {
     316           6 :                 ZVAL_NULL(retval);
     317             :         }
     318             : 
     319         225 :         return SUCCESS;
     320             : 
     321             : }
     322             : 
     323          22 : int dom_node_node_value_write(dom_object *obj, zval *newval)
     324             : {
     325          22 :         xmlNode *nodep = dom_object_get_node(obj);
     326             : 
     327          22 :         if (nodep == NULL) {
     328           0 :                 php_dom_throw_error(INVALID_STATE_ERR, 0);
     329           0 :                 return FAILURE;
     330             :         }
     331             : 
     332             :         /* Access to Element node is implemented as a convenience method */
     333          22 :         switch (nodep->type) {
     334          22 :                 case XML_ELEMENT_NODE:
     335             :                 case XML_ATTRIBUTE_NODE:
     336          22 :                         if (nodep->children) {
     337          21 :                                 node_list_unlink(nodep->children);
     338          21 :                                 php_libxml_node_free_list((xmlNodePtr) nodep->children);
     339          21 :                                 nodep->children = NULL;
     340             :                         }
     341             :                 case XML_TEXT_NODE:
     342             :                 case XML_COMMENT_NODE:
     343             :                 case XML_CDATA_SECTION_NODE:
     344             :                 case XML_PI_NODE:
     345             :                         {
     346          22 :                                 zend_string *str = zval_get_string(newval);
     347          22 :                                 xmlNodeSetContentLen(nodep, (xmlChar *) ZSTR_VAL(str), ZSTR_LEN(str) + 1);
     348             :                                 zend_string_release_ex(str, 0);
     349          22 :                                 break;
     350             :                         }
     351           0 :                 default:
     352           0 :                         break;
     353             :         }
     354             : 
     355          22 :         return SUCCESS;
     356             : }
     357             : 
     358             : /* }}} */
     359             : 
     360             : /* {{{ nodeType int
     361             : readonly=yes
     362             : URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-111237558
     363             : Since:
     364             : */
     365          78 : int dom_node_node_type_read(dom_object *obj, zval *retval)
     366             : {
     367             :         xmlNode *nodep;
     368             : 
     369          78 :         nodep = dom_object_get_node(obj);
     370             : 
     371          78 :         if (nodep == NULL) {
     372           0 :                 php_dom_throw_error(INVALID_STATE_ERR, 0);
     373           0 :                 return FAILURE;
     374             :         }
     375             : 
     376             :         /* Specs dictate that they are both type XML_DOCUMENT_TYPE_NODE */
     377          78 :         if (nodep->type == XML_DTD_NODE) {
     378           0 :                 ZVAL_LONG(retval, XML_DOCUMENT_TYPE_NODE);
     379             :         } else {
     380          78 :                 ZVAL_LONG(retval, nodep->type);
     381             :         }
     382             : 
     383          78 :         return SUCCESS;
     384             : }
     385             : 
     386             : /* }}} */
     387             : 
     388             : /* {{{ parentNode       DomNode
     389             : readonly=yes
     390             : URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-1060184317
     391             : Since:
     392             : */
     393         139 : int dom_node_parent_node_read(dom_object *obj, zval *retval)
     394             : {
     395             :         xmlNode *nodep, *nodeparent;
     396             : 
     397         139 :         nodep = dom_object_get_node(obj);
     398             : 
     399         139 :         if (nodep == NULL) {
     400           0 :                 php_dom_throw_error(INVALID_STATE_ERR, 0);
     401           0 :                 return FAILURE;
     402             :         }
     403             : 
     404         139 :         nodeparent = nodep->parent;
     405         139 :         if (!nodeparent) {
     406          15 :                 ZVAL_NULL(retval);
     407          15 :                 return SUCCESS;
     408             :         }
     409             : 
     410         124 :         php_dom_create_object(nodeparent, retval, obj);
     411         124 :         return SUCCESS;
     412             : }
     413             : 
     414             : /* }}} */
     415             : 
     416             : /* {{{ childNodes       DomNodeList
     417             : readonly=yes
     418             : URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-1451460987
     419             : Since:
     420             : */
     421         116 : int dom_node_child_nodes_read(dom_object *obj, zval *retval)
     422             : {
     423         116 :         xmlNode *nodep = dom_object_get_node(obj);
     424             :         dom_object *intern;
     425             : 
     426         116 :         if (nodep == NULL) {
     427           0 :                 php_dom_throw_error(INVALID_STATE_ERR, 0);
     428           0 :                 return FAILURE;
     429             :         }
     430             : 
     431         116 :         if (dom_node_children_valid(nodep) == FAILURE) {
     432           2 :                 ZVAL_NULL(retval);
     433             :         } else {
     434         114 :                 php_dom_create_interator(retval, DOM_NODELIST);
     435         114 :                 intern = Z_DOMOBJ_P(retval);
     436         114 :                 dom_namednode_iter(obj, XML_ELEMENT_NODE, intern, NULL, NULL, NULL);
     437             :         }
     438             : 
     439         116 :         return SUCCESS;
     440             : }
     441             : 
     442             : /* }}} */
     443             : 
     444             : /* {{{ firstChild DomNode
     445             : readonly=yes
     446             : URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-169727388
     447             : Since:
     448             : */
     449          77 : int dom_node_first_child_read(dom_object *obj, zval *retval)
     450             : {
     451          77 :         xmlNode *nodep, *first = NULL;
     452             : 
     453          77 :         nodep = dom_object_get_node(obj);
     454             : 
     455          77 :         if (nodep == NULL) {
     456           0 :                 php_dom_throw_error(INVALID_STATE_ERR, 0);
     457           0 :                 return FAILURE;
     458             :         }
     459             : 
     460          77 :         if (dom_node_children_valid(nodep) == SUCCESS) {
     461          75 :                 first = nodep->children;
     462             :         }
     463             : 
     464          77 :         if (!first) {
     465           3 :                 ZVAL_NULL(retval);
     466           3 :                 return SUCCESS;
     467             :         }
     468             : 
     469          74 :         php_dom_create_object(first, retval, obj);
     470          74 :         return SUCCESS;
     471             : }
     472             : 
     473             : /* }}} */
     474             : 
     475             : /* {{{ lastChild        DomNode
     476             : readonly=yes
     477             : URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-61AD09FB
     478             : Since:
     479             : */
     480          12 : int dom_node_last_child_read(dom_object *obj, zval *retval)
     481             : {
     482          12 :         xmlNode *nodep, *last = NULL;
     483             : 
     484          12 :         nodep = dom_object_get_node(obj);
     485             : 
     486          12 :         if (nodep == NULL) {
     487           0 :                 php_dom_throw_error(INVALID_STATE_ERR, 0);
     488           0 :                 return FAILURE;
     489             :         }
     490             : 
     491          12 :         if (dom_node_children_valid(nodep) == SUCCESS) {
     492          10 :                 last = nodep->last;
     493             :         }
     494             : 
     495          12 :         if (!last) {
     496           2 :                 ZVAL_NULL(retval);
     497           2 :                 return SUCCESS;
     498             :         }
     499             : 
     500          10 :         php_dom_create_object(last, retval, obj);
     501          10 :         return SUCCESS;
     502             : }
     503             : 
     504             : /* }}} */
     505             : 
     506             : /* {{{ previousSibling  DomNode
     507             : readonly=yes
     508             : URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-640FB3C8
     509             : Since:
     510             : */
     511         114 : int dom_node_previous_sibling_read(dom_object *obj, zval *retval)
     512             : {
     513             :         xmlNode *nodep, *prevsib;
     514             : 
     515         114 :         nodep = dom_object_get_node(obj);
     516             : 
     517         114 :         if (nodep == NULL) {
     518           0 :                 php_dom_throw_error(INVALID_STATE_ERR, 0);
     519           0 :                 return FAILURE;
     520             :         }
     521             : 
     522         114 :         prevsib = nodep->prev;
     523         114 :         if (!prevsib) {
     524          44 :                 ZVAL_NULL(retval);
     525          44 :                 return SUCCESS;
     526             :         }
     527             : 
     528          70 :         php_dom_create_object(prevsib, retval, obj);
     529          70 :         return SUCCESS;
     530             : }
     531             : 
     532             : /* }}} */
     533             : 
     534             : /* {{{ nextSibling      DomNode
     535             : readonly=yes
     536             : URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-6AC54C2F
     537             : Since:
     538             : */
     539         118 : int dom_node_next_sibling_read(dom_object *obj, zval *retval)
     540             : {
     541             :         xmlNode *nodep, *nextsib;
     542             : 
     543         118 :         nodep = dom_object_get_node(obj);
     544             : 
     545         118 :         if (nodep == NULL) {
     546           0 :                 php_dom_throw_error(INVALID_STATE_ERR, 0);
     547           0 :                 return FAILURE;
     548             :         }
     549             : 
     550         118 :         nextsib = nodep->next;
     551         118 :         if (!nextsib) {
     552          42 :                 ZVAL_NULL(retval);
     553          42 :                 return SUCCESS;
     554             :         }
     555             : 
     556          76 :         php_dom_create_object(nextsib, retval, obj);
     557          76 :         return SUCCESS;
     558             : }
     559             : 
     560             : /* }}} */
     561             : 
     562             : /* {{{ attributes       DomNamedNodeMap
     563             : readonly=yes
     564             : URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-84CF096
     565             : Since:
     566             : */
     567          16 : int dom_node_attributes_read(dom_object *obj, zval *retval)
     568             : {
     569          16 :         xmlNode *nodep = dom_object_get_node(obj);
     570             :         dom_object *intern;
     571             : 
     572          16 :         if (nodep == NULL) {
     573           0 :                 php_dom_throw_error(INVALID_STATE_ERR, 0);
     574           0 :                 return FAILURE;
     575             :         }
     576             : 
     577          16 :         if (nodep->type == XML_ELEMENT_NODE) {
     578          10 :                 php_dom_create_interator(retval, DOM_NAMEDNODEMAP);
     579          10 :                 intern = Z_DOMOBJ_P(retval);
     580          10 :                 dom_namednode_iter(obj, XML_ATTRIBUTE_NODE, intern, NULL, NULL, NULL);
     581             :         } else {
     582           6 :                 ZVAL_NULL(retval);
     583             :         }
     584             : 
     585          16 :         return SUCCESS;
     586             : }
     587             : 
     588             : /* }}} */
     589             : 
     590             : /* {{{ ownerDocument    DomDocument
     591             : readonly=yes
     592             : URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-node-ownerDoc
     593             : Since:
     594             : */
     595          12 : int dom_node_owner_document_read(dom_object *obj, zval *retval)
     596             : {
     597          12 :         xmlNode *nodep = dom_object_get_node(obj);
     598             :         xmlDocPtr docp;
     599             : 
     600          12 :         if (nodep == NULL) {
     601           0 :                 php_dom_throw_error(INVALID_STATE_ERR, 0);
     602           0 :                 return FAILURE;
     603             :         }
     604             : 
     605          12 :         if (nodep->type == XML_DOCUMENT_NODE || nodep->type == XML_HTML_DOCUMENT_NODE) {
     606           1 :                 ZVAL_NULL(retval);
     607           1 :                 return SUCCESS;
     608             :         }
     609             : 
     610          11 :         docp = nodep->doc;
     611          11 :         if (!docp) {
     612           0 :                 return FAILURE;
     613             :         }
     614             : 
     615          11 :         php_dom_create_object((xmlNodePtr) docp, retval, obj);
     616          11 :         return SUCCESS;
     617             : }
     618             : 
     619             : /* }}} */
     620             : 
     621             : /* {{{ namespaceUri     string
     622             : readonly=yes
     623             : URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-NodeNSname
     624             : Since: DOM Level 2
     625             : */
     626          10 : int dom_node_namespace_uri_read(dom_object *obj, zval *retval)
     627             : {
     628          10 :         xmlNode *nodep = dom_object_get_node(obj);
     629          10 :         char *str = NULL;
     630             : 
     631          10 :         if (nodep == NULL) {
     632           0 :                 php_dom_throw_error(INVALID_STATE_ERR, 0);
     633           0 :                 return FAILURE;
     634             :         }
     635             : 
     636          10 :         switch (nodep->type) {
     637           7 :                 case XML_ELEMENT_NODE:
     638             :                 case XML_ATTRIBUTE_NODE:
     639             :                 case XML_NAMESPACE_DECL:
     640           7 :                         if (nodep->ns != NULL) {
     641           1 :                                 str = (char *) nodep->ns->href;
     642             :                         }
     643           7 :                         break;
     644           3 :                 default:
     645           3 :                         str = NULL;
     646           3 :                         break;
     647             :         }
     648             : 
     649          10 :         if (str != NULL) {
     650           2 :                 ZVAL_STRING(retval, str);
     651             :         } else {
     652           9 :                 ZVAL_NULL(retval);
     653             :         }
     654             : 
     655          10 :         return SUCCESS;
     656             : }
     657             : 
     658             : /* }}} */
     659             : 
     660             : /* {{{ prefix   string
     661             : readonly=no
     662             : URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-NodeNSPrefix
     663             : Since: DOM Level 2
     664             : */
     665          10 : int dom_node_prefix_read(dom_object *obj, zval *retval)
     666             : {
     667          10 :         xmlNode *nodep = dom_object_get_node(obj);
     668             :         xmlNsPtr ns;
     669          10 :         char *str = NULL;
     670             : 
     671          10 :         if (nodep == NULL) {
     672           0 :                 php_dom_throw_error(INVALID_STATE_ERR, 0);
     673           0 :                 return FAILURE;
     674             :         }
     675             : 
     676          10 :         switch (nodep->type) {
     677           7 :                 case XML_ELEMENT_NODE:
     678             :                 case XML_ATTRIBUTE_NODE:
     679             :                 case XML_NAMESPACE_DECL:
     680           7 :                         ns = nodep->ns;
     681           7 :                         if (ns != NULL && ns->prefix) {
     682           1 :                                 str = (char *) ns->prefix;
     683             :                         }
     684           7 :                         break;
     685           3 :                 default:
     686           3 :                         str = NULL;
     687           3 :                         break;
     688             :         }
     689             : 
     690          10 :         if (str == NULL) {
     691           9 :                 ZVAL_EMPTY_STRING(retval);
     692             :         } else {
     693           2 :                 ZVAL_STRING(retval, str);
     694             :         }
     695          10 :         return SUCCESS;
     696             : 
     697             : }
     698             : 
     699           0 : int dom_node_prefix_write(dom_object *obj, zval *newval)
     700             : {
     701             :         zend_string *str;
     702           0 :         xmlNode *nodep, *nsnode = NULL;
     703           0 :         xmlNsPtr ns = NULL, curns;
     704             :         char *strURI;
     705             :         char *prefix;
     706             : 
     707           0 :         nodep = dom_object_get_node(obj);
     708             : 
     709           0 :         if (nodep == NULL) {
     710           0 :                 php_dom_throw_error(INVALID_STATE_ERR, 0);
     711           0 :                 return FAILURE;
     712             :         }
     713             : 
     714           0 :         switch (nodep->type) {
     715           0 :                 case XML_ELEMENT_NODE:
     716           0 :                         nsnode = nodep;
     717           0 :                 case XML_ATTRIBUTE_NODE:
     718           0 :                         if (nsnode == NULL) {
     719           0 :                                 nsnode = nodep->parent;
     720           0 :                                 if (nsnode == NULL) {
     721           0 :                                         nsnode = xmlDocGetRootElement(nodep->doc);
     722             :                                 }
     723             :                         }
     724           0 :                         str = zval_get_string(newval);
     725           0 :                         prefix = ZSTR_VAL(str);
     726           0 :                         if (nsnode && nodep->ns != NULL && !xmlStrEqual(nodep->ns->prefix, (xmlChar *)prefix)) {
     727           0 :                                 strURI = (char *) nodep->ns->href;
     728           0 :                                 if (strURI == NULL ||
     729           0 :                                         (!strcmp(prefix, "xml") && strcmp(strURI, (char *) XML_XML_NAMESPACE)) ||
     730           0 :                                         (nodep->type == XML_ATTRIBUTE_NODE && !strcmp(prefix, "xmlns") &&
     731           0 :                                          strcmp(strURI, (char *) DOM_XMLNS_NAMESPACE)) ||
     732           0 :                                         (nodep->type == XML_ATTRIBUTE_NODE && !strcmp((char *) nodep->name, "xmlns"))) {
     733           0 :                                         ns = NULL;
     734             :                                 } else {
     735           0 :                                         curns = nsnode->nsDef;
     736           0 :                                         while (curns != NULL) {
     737           0 :                                                 if (xmlStrEqual((xmlChar *)prefix, curns->prefix) && xmlStrEqual(nodep->ns->href, curns->href)) {
     738           0 :                                                         ns = curns;
     739           0 :                                                         break;
     740             :                                                 }
     741           0 :                                                 curns = curns->next;
     742             :                                         }
     743           0 :                                         if (ns == NULL) {
     744           0 :                                                 ns = xmlNewNs(nsnode, nodep->ns->href, (xmlChar *)prefix);
     745             :                                         }
     746             :                                 }
     747             : 
     748           0 :                                 if (ns == NULL) {
     749             :                                         zend_string_release_ex(str, 0);
     750           0 :                                         php_dom_throw_error(NAMESPACE_ERR, dom_get_strict_error(obj->document));
     751           0 :                                         return FAILURE;
     752             :                                 }
     753             : 
     754           0 :                                 xmlSetNs(nodep, ns);
     755             :                         }
     756             :                         zend_string_release_ex(str, 0);
     757           0 :                         break;
     758           0 :                 default:
     759           0 :                         break;
     760             :         }
     761             : 
     762           0 :         return SUCCESS;
     763             : }
     764             : 
     765             : /* }}} */
     766             : 
     767             : /* {{{ localName        string
     768             : readonly=yes
     769             : URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-NodeNSLocalN
     770             : Since: DOM Level 2
     771             : */
     772          11 : int dom_node_local_name_read(dom_object *obj, zval *retval)
     773             : {
     774          11 :         xmlNode *nodep = dom_object_get_node(obj);
     775             : 
     776          11 :         if (nodep == NULL) {
     777           0 :                 php_dom_throw_error(INVALID_STATE_ERR, 0);
     778           0 :                 return FAILURE;
     779             :         }
     780             : 
     781          11 :         if (nodep->type == XML_ELEMENT_NODE || nodep->type == XML_ATTRIBUTE_NODE || nodep->type == XML_NAMESPACE_DECL) {
     782          16 :                 ZVAL_STRING(retval, (char *) (nodep->name));
     783             :         } else {
     784           3 :                 ZVAL_NULL(retval);
     785             :         }
     786             : 
     787          11 :         return SUCCESS;
     788             : }
     789             : 
     790             : /* }}} */
     791             : 
     792             : /* {{{ baseURI  string
     793             : readonly=yes
     794             : URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#Node3-baseURI
     795             : Since: DOM Level 3
     796             : */
     797           9 : int dom_node_base_uri_read(dom_object *obj, zval *retval)
     798             : {
     799           9 :         xmlNode *nodep = dom_object_get_node(obj);
     800             :         xmlChar *baseuri;
     801             : 
     802           9 :         if (nodep == NULL) {
     803           0 :                 php_dom_throw_error(INVALID_STATE_ERR, 0);
     804           0 :                 return FAILURE;
     805             :         }
     806             : 
     807           9 :         baseuri = xmlNodeGetBase(nodep->doc, nodep);
     808           9 :         if (baseuri) {
     809          12 :                 ZVAL_STRING(retval, (char *) (baseuri));
     810           6 :                 xmlFree(baseuri);
     811             :         } else {
     812           3 :                 ZVAL_NULL(retval);
     813             :         }
     814             : 
     815           9 :         return SUCCESS;
     816             : }
     817             : 
     818             : /* }}} */
     819             : 
     820             : /* {{{ textContent      string
     821             : readonly=no
     822             : URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#Node3-textContent
     823             : Since: DOM Level 3
     824             : */
     825          41 : int dom_node_text_content_read(dom_object *obj, zval *retval)
     826             : {
     827          41 :         xmlNode *nodep = dom_object_get_node(obj);
     828          41 :         char *str = NULL;
     829             : 
     830          41 :         if (nodep == NULL) {
     831           0 :                 php_dom_throw_error(INVALID_STATE_ERR, 0);
     832           0 :                 return FAILURE;
     833             :         }
     834             : 
     835          41 :         str = (char *) xmlNodeGetContent(nodep);
     836             : 
     837          41 :         if (str != NULL) {
     838          82 :                 ZVAL_STRING(retval, str);
     839          41 :                 xmlFree(str);
     840             :         } else {
     841           0 :                 ZVAL_EMPTY_STRING(retval);
     842             :         }
     843             : 
     844          41 :         return SUCCESS;
     845             : }
     846             : 
     847           1 : int dom_node_text_content_write(dom_object *obj, zval *newval)
     848             : {
     849           1 :         xmlNode *nodep = dom_object_get_node(obj);
     850             :         zend_string *str;
     851             : 
     852           1 :         if (nodep == NULL) {
     853           0 :                 php_dom_throw_error(INVALID_STATE_ERR, 0);
     854           0 :                 return FAILURE;
     855             :         }
     856             : 
     857           1 :         if (nodep->type == XML_ELEMENT_NODE || nodep->type == XML_ATTRIBUTE_NODE) {
     858           0 :                 if (nodep->children) {
     859           0 :                         node_list_unlink(nodep->children);
     860           0 :                         php_libxml_node_free_list((xmlNodePtr) nodep->children);
     861           0 :                         nodep->children = NULL;
     862             :                 }
     863             :         }
     864             : 
     865           1 :         str = zval_get_string(newval);
     866             :         /* we have to use xmlNodeAddContent() to get the same behavior as with xmlNewText() */
     867           1 :         xmlNodeSetContent(nodep, (xmlChar *) "");
     868           1 :         xmlNodeAddContent(nodep, (xmlChar *) ZSTR_VAL(str));
     869             :         zend_string_release_ex(str, 0);
     870             : 
     871           1 :         return SUCCESS;
     872             : }
     873             : 
     874             : /* }}} */
     875             : 
     876          17 : static xmlNodePtr _php_dom_insert_fragment(xmlNodePtr nodep, xmlNodePtr prevsib, xmlNodePtr nextsib, xmlNodePtr fragment, dom_object *intern, dom_object *childobj) /* {{{ */
     877             : {
     878             :         xmlNodePtr newchild, node;
     879             : 
     880          17 :         newchild = fragment->children;
     881             : 
     882          17 :         if (newchild) {
     883          16 :                 if (prevsib == NULL) {
     884           6 :                         nodep->children = newchild;
     885             :                 } else {
     886          10 :                         prevsib->next = newchild;
     887             :                 }
     888          16 :                 newchild->prev = prevsib;
     889          16 :                 if (nextsib == NULL) {
     890          10 :                         nodep->last = fragment->last;
     891             :                 } else {
     892           6 :                         fragment->last->next = nextsib;
     893           6 :                         nextsib->prev = fragment->last;
     894             :                 }
     895             : 
     896          16 :                 node = newchild;
     897          35 :                 while (node != NULL) {
     898          19 :                         node->parent = nodep;
     899          19 :                         if (node->doc != nodep->doc) {
     900           0 :                                 xmlSetTreeDoc(node, nodep->doc);
     901           0 :                                 if (node->_private != NULL) {
     902           0 :                                         childobj = node->_private;
     903           0 :                                         childobj->document = intern->document;
     904           0 :                                         php_libxml_increment_doc_ref((php_libxml_node_object *)childobj, NULL);
     905             :                                 }
     906             :                         }
     907          19 :                         if (node == fragment->last) {
     908          16 :                                 break;
     909             :                         }
     910           3 :                         node = node->next;
     911             :                 }
     912             : 
     913          16 :                 fragment->children = NULL;
     914          16 :                 fragment->last = NULL;
     915             :         }
     916             : 
     917          17 :         return newchild;
     918             : }
     919             : /* }}} */
     920             : 
     921             : /* {{{ proto domnode dom_node_insert_before(DomNode newChild, DomNode refChild);
     922             : URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-952280727
     923             : Since:
     924             : */
     925          16 : PHP_FUNCTION(dom_node_insert_before)
     926             : {
     927          16 :         zval *id, *node, *ref = NULL;
     928             :         xmlNodePtr child, new_child, parentp, refp;
     929             :         dom_object *intern, *childobj, *refpobj;
     930             :         int ret, stricterror;
     931             : 
     932          16 :         id = ZEND_THIS;
     933          16 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "O|O!", &node, dom_node_class_entry, &ref, dom_node_class_entry) == FAILURE) {
     934           7 :                 return;
     935             :         }
     936             : 
     937          16 :         DOM_GET_OBJ(parentp, id, xmlNodePtr, intern);
     938             : 
     939          16 :         if (dom_node_children_valid(parentp) == FAILURE) {
     940           0 :                 RETURN_FALSE;
     941             :         }
     942             : 
     943          16 :         DOM_GET_OBJ(child, node, xmlNodePtr, childobj);
     944             : 
     945          16 :         new_child = NULL;
     946             : 
     947          16 :         stricterror = dom_get_strict_error(intern->document);
     948             : 
     949          32 :         if (dom_node_is_read_only(parentp) == SUCCESS ||
     950          18 :                 (child->parent != NULL && dom_node_is_read_only(child->parent) == SUCCESS)) {
     951           0 :                 php_dom_throw_error(NO_MODIFICATION_ALLOWED_ERR, stricterror);
     952           0 :                 RETURN_FALSE;
     953             :         }
     954             : 
     955          16 :         if (dom_hierarchy(parentp, child) == FAILURE) {
     956           0 :                 php_dom_throw_error(HIERARCHY_REQUEST_ERR, stricterror);
     957           0 :                 RETURN_FALSE;
     958             :         }
     959             : 
     960          16 :         if (child->doc != parentp->doc && child->doc != NULL) {
     961           1 :                 php_dom_throw_error(WRONG_DOCUMENT_ERR, stricterror);
     962           1 :                 RETURN_FALSE;
     963             :         }
     964             : 
     965          15 :         if (child->type == XML_DOCUMENT_FRAG_NODE && child->children == NULL) {
     966           1 :                 php_error_docref(NULL, E_WARNING, "Document Fragment is empty");
     967           1 :                 RETURN_FALSE;
     968             :         }
     969             : 
     970          14 :         if (child->doc == NULL && parentp->doc != NULL) {
     971           0 :                 childobj->document = intern->document;
     972           0 :                 php_libxml_increment_doc_ref((php_libxml_node_object *)childobj, NULL);
     973             :         }
     974             : 
     975          14 :         if (ref != NULL) {
     976          11 :                 DOM_GET_OBJ(refp, ref, xmlNodePtr, refpobj);
     977          11 :                 if (refp->parent != parentp) {
     978           5 :                         php_dom_throw_error(NOT_FOUND_ERR, stricterror);
     979           5 :                         RETURN_FALSE;
     980             :                 }
     981             : 
     982           6 :                 if (child->parent != NULL) {
     983           1 :                         xmlUnlinkNode(child);
     984             :                 }
     985             : 
     986           7 :                 if (child->type == XML_TEXT_NODE && (refp->type == XML_TEXT_NODE ||
     987           2 :                         (refp->prev != NULL && refp->prev->type == XML_TEXT_NODE))) {
     988           2 :                         if (child->doc == NULL) {
     989           0 :                                 xmlSetTreeDoc(child, parentp->doc);
     990             :                         }
     991           2 :                         new_child = child;
     992           2 :                         new_child->parent = refp->parent;
     993           2 :                         new_child->next = refp;
     994           2 :                         new_child->prev = refp->prev;
     995           2 :                         refp->prev = new_child;
     996           2 :                         if (new_child->prev != NULL) {
     997           1 :                                 new_child->prev->next = new_child;
     998             :                         }
     999           4 :                         if (new_child->parent != NULL) {
    1000           2 :                                 if (new_child->parent->children == refp) {
    1001           1 :                                         new_child->parent->children = new_child;
    1002             :                                 }
    1003             :                         }
    1004             : 
    1005           4 :                 } else if (child->type == XML_ATTRIBUTE_NODE) {
    1006             :                         xmlAttrPtr lastattr;
    1007             : 
    1008           0 :                         if (child->ns == NULL)
    1009           0 :                                 lastattr = xmlHasProp(refp->parent, child->name);
    1010             :                         else
    1011           0 :                                 lastattr = xmlHasNsProp(refp->parent, child->name, child->ns->href);
    1012           0 :                         if (lastattr != NULL && lastattr->type != XML_ATTRIBUTE_DECL) {
    1013           0 :                                 if (lastattr != (xmlAttrPtr) child) {
    1014           0 :                                         xmlUnlinkNode((xmlNodePtr) lastattr);
    1015           0 :                                         php_libxml_node_free_resource((xmlNodePtr) lastattr);
    1016             :                                 } else {
    1017           0 :                                         DOM_RET_OBJ(child, &ret, intern);
    1018           0 :                                         return;
    1019             :                                 }
    1020             :                         }
    1021           4 :                 } else if (child->type == XML_DOCUMENT_FRAG_NODE) {
    1022           3 :                         new_child = _php_dom_insert_fragment(parentp, refp->prev, refp, child, intern, childobj);
    1023             :                 }
    1024             : 
    1025           6 :                 if (new_child == NULL) {
    1026           1 :                         new_child = xmlAddPrevSibling(refp, child);
    1027             :                 }
    1028             :         } else {
    1029           3 :                 if (child->parent != NULL){
    1030           1 :                         xmlUnlinkNode(child);
    1031             :                 }
    1032           3 :                 if (child->type == XML_TEXT_NODE && parentp->last != NULL && parentp->last->type == XML_TEXT_NODE) {
    1033           1 :                         child->parent = parentp;
    1034           1 :                         if (child->doc == NULL) {
    1035           0 :                                 xmlSetTreeDoc(child, parentp->doc);
    1036             :                         }
    1037           1 :                         new_child = child;
    1038           2 :                         if (parentp->children == NULL) {
    1039           0 :                                 parentp->children = child;
    1040           0 :                                 parentp->last = child;
    1041             :                         } else {
    1042           1 :                                 child = parentp->last;
    1043           1 :                                 child->next = new_child;
    1044           1 :                                 new_child->prev = child;
    1045           1 :                                 parentp->last = new_child;
    1046             :                         }
    1047           2 :                 } else  if (child->type == XML_ATTRIBUTE_NODE) {
    1048             :                         xmlAttrPtr lastattr;
    1049             : 
    1050           0 :                         if (child->ns == NULL)
    1051           0 :                                 lastattr = xmlHasProp(parentp, child->name);
    1052             :                         else
    1053           0 :                                 lastattr = xmlHasNsProp(parentp, child->name, child->ns->href);
    1054           0 :                         if (lastattr != NULL && lastattr->type != XML_ATTRIBUTE_DECL) {
    1055           0 :                                 if (lastattr != (xmlAttrPtr) child) {
    1056           0 :                                         xmlUnlinkNode((xmlNodePtr) lastattr);
    1057           0 :                                         php_libxml_node_free_resource((xmlNodePtr) lastattr);
    1058             :                                 } else {
    1059           0 :                                         DOM_RET_OBJ(child, &ret, intern);
    1060           0 :                                         return;
    1061             :                                 }
    1062             :                         }
    1063           2 :                 } else if (child->type == XML_DOCUMENT_FRAG_NODE) {
    1064           2 :                         new_child = _php_dom_insert_fragment(parentp, parentp->last, NULL, child, intern, childobj);
    1065             :                 }
    1066           3 :                 if (new_child == NULL) {
    1067           0 :                         new_child = xmlAddChild(parentp, child);
    1068             :                 }
    1069             :         }
    1070             : 
    1071           9 :         if (NULL == new_child) {
    1072           0 :                 php_error_docref(NULL, E_WARNING, "Couldn't add newnode as the previous sibling of refnode");
    1073           0 :                 RETURN_FALSE;
    1074             :         }
    1075             : 
    1076           9 :         dom_reconcile_ns(parentp->doc, new_child);
    1077             : 
    1078           9 :         DOM_RET_OBJ(new_child, &ret, intern);
    1079             : 
    1080             : }
    1081             : /* }}} end dom_node_insert_before */
    1082             : 
    1083             : /* {{{ proto DomNode dom_node_replace_child(DomNode newChild, DomNode oldChild);
    1084             : URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-785887307
    1085             : Since:
    1086             : */
    1087           9 : PHP_FUNCTION(dom_node_replace_child)
    1088             : {
    1089             :         zval *id, *newnode, *oldnode;
    1090             :         xmlNodePtr children, newchild, oldchild, nodep;
    1091             :         dom_object *intern, *newchildobj, *oldchildobj;
    1092           9 :         int foundoldchild = 0, stricterror;
    1093             : 
    1094             :         int ret;
    1095             : 
    1096           9 :         id = ZEND_THIS;
    1097           9 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "OO", &newnode, dom_node_class_entry, &oldnode, dom_node_class_entry) == FAILURE) {
    1098           0 :                 return;
    1099             :         }
    1100             : 
    1101           9 :         DOM_GET_OBJ(nodep, id, xmlNodePtr, intern);
    1102             : 
    1103           9 :         if (dom_node_children_valid(nodep) == FAILURE) {
    1104           0 :                 RETURN_FALSE;
    1105             :         }
    1106             : 
    1107           9 :         DOM_GET_OBJ(newchild, newnode, xmlNodePtr, newchildobj);
    1108           9 :         DOM_GET_OBJ(oldchild, oldnode, xmlNodePtr, oldchildobj);
    1109             : 
    1110           9 :         children = nodep->children;
    1111           9 :         if (!children) {
    1112           0 :                 RETURN_FALSE;
    1113             :         }
    1114             : 
    1115           9 :         stricterror = dom_get_strict_error(intern->document);
    1116             : 
    1117          18 :         if (dom_node_is_read_only(nodep) == SUCCESS ||
    1118          11 :                 (newchild->parent != NULL && dom_node_is_read_only(newchild->parent) == SUCCESS)) {
    1119           0 :                 php_dom_throw_error(NO_MODIFICATION_ALLOWED_ERR, stricterror);
    1120           0 :                 RETURN_FALSE;
    1121             :         }
    1122             : 
    1123           9 :         if (newchild->doc != nodep->doc && newchild->doc != NULL) {
    1124           0 :                 php_dom_throw_error(WRONG_DOCUMENT_ERR, stricterror);
    1125           0 :                 RETURN_FALSE;
    1126             :         }
    1127             : 
    1128           9 :         if (dom_hierarchy(nodep, newchild) == FAILURE) {
    1129           0 :                 php_dom_throw_error(HIERARCHY_REQUEST_ERR, stricterror);
    1130           0 :                 RETURN_FALSE;
    1131             :         }
    1132             : 
    1133             :         /* check for the old child and whether the new child is already a child */
    1134          27 :         while (children) {
    1135          18 :                 if (children == oldchild) {
    1136           9 :                         foundoldchild = 1;
    1137           9 :                         break;
    1138             :                 }
    1139           9 :                 children = children->next;
    1140             :         }
    1141             : 
    1142           9 :         if (foundoldchild) {
    1143           9 :                 if (newchild->type == XML_DOCUMENT_FRAG_NODE) {
    1144             :                         xmlNodePtr prevsib, nextsib;
    1145           6 :                         prevsib = oldchild->prev;
    1146           6 :                         nextsib = oldchild->next;
    1147             : 
    1148           6 :                         xmlUnlinkNode(oldchild);
    1149             : 
    1150           6 :                         newchild = _php_dom_insert_fragment(nodep, prevsib, nextsib, newchild, intern, newchildobj);
    1151           6 :                         if (newchild) {
    1152           5 :                                 dom_reconcile_ns(nodep->doc, newchild);
    1153             :                         }
    1154           3 :                 } else if (oldchild != newchild) {
    1155           3 :                         if (newchild->doc == NULL && nodep->doc != NULL) {
    1156           0 :                                 xmlSetTreeDoc(newchild, nodep->doc);
    1157           0 :                                 newchildobj->document = intern->document;
    1158           0 :                                 php_libxml_increment_doc_ref((php_libxml_node_object *)newchildobj, NULL);
    1159             :                         }
    1160           3 :                         xmlReplaceNode(oldchild, newchild);
    1161           3 :                         dom_reconcile_ns(nodep->doc, newchild);
    1162             :                 }
    1163           9 :                 DOM_RET_OBJ(oldchild, &ret, intern);
    1164           9 :                 return;
    1165             :         } else {
    1166           0 :                 php_dom_throw_error(NOT_FOUND_ERR, dom_get_strict_error(intern->document));
    1167           0 :                 RETURN_FALSE;
    1168             :         }
    1169             : }
    1170             : /* }}} end dom_node_replace_child */
    1171             : 
    1172             : /* {{{ proto DomNode dom_node_remove_child(DomNode oldChild);
    1173             : URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-1734834066
    1174             : Since:
    1175             : */
    1176          18 : PHP_FUNCTION(dom_node_remove_child)
    1177             : {
    1178             :         zval *id, *node;
    1179             :         xmlNodePtr children, child, nodep;
    1180             :         dom_object *intern, *childobj;
    1181             :         int ret, stricterror;
    1182             : 
    1183          18 :         id = ZEND_THIS;
    1184          18 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "O", &node, dom_node_class_entry) == FAILURE) {
    1185           0 :                 return;
    1186             :         }
    1187             : 
    1188          18 :         DOM_GET_OBJ(nodep, id, xmlNodePtr, intern);
    1189             : 
    1190          18 :         if (dom_node_children_valid(nodep) == FAILURE) {
    1191           0 :                 RETURN_FALSE;
    1192             :         }
    1193             : 
    1194          18 :         DOM_GET_OBJ(child, node, xmlNodePtr, childobj);
    1195             : 
    1196          18 :         stricterror = dom_get_strict_error(intern->document);
    1197             : 
    1198          36 :         if (dom_node_is_read_only(nodep) == SUCCESS ||
    1199          36 :                 (child->parent != NULL && dom_node_is_read_only(child->parent) == SUCCESS)) {
    1200           0 :                 php_dom_throw_error(NO_MODIFICATION_ALLOWED_ERR, stricterror);
    1201           0 :                 RETURN_FALSE;
    1202             :         }
    1203             : 
    1204          18 :         children = nodep->children;
    1205          18 :         if (!children) {
    1206           0 :                 php_dom_throw_error(NOT_FOUND_ERR, stricterror);
    1207           0 :                 RETURN_FALSE;
    1208             :         }
    1209             : 
    1210          52 :         while (children) {
    1211          34 :                 if (children == child) {
    1212          18 :                         xmlUnlinkNode(child);
    1213          18 :                         DOM_RET_OBJ(child, &ret, intern);
    1214          18 :                         return;
    1215             :                 }
    1216          16 :                 children = children->next;
    1217             :         }
    1218             : 
    1219           0 :         php_dom_throw_error(NOT_FOUND_ERR, stricterror);
    1220           0 :         RETURN_FALSE
    1221             : }
    1222             : /* }}} end dom_node_remove_child */
    1223             : 
    1224             : /* {{{ proto DomNode dom_node_append_child(DomNode newChild);
    1225             : URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-184E7107
    1226             : Since:
    1227             : */
    1228         158 : PHP_FUNCTION(dom_node_append_child)
    1229             : {
    1230             :         zval *id, *node;
    1231         158 :         xmlNodePtr child, nodep, new_child = NULL;
    1232             :         dom_object *intern, *childobj;
    1233             :         int ret, stricterror;
    1234             : 
    1235         158 :         id = ZEND_THIS;
    1236         158 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "O", &node, dom_node_class_entry) == FAILURE) {
    1237           3 :                 return;
    1238             :         }
    1239             : 
    1240         158 :         DOM_GET_OBJ(nodep, id, xmlNodePtr, intern);
    1241             : 
    1242         158 :         if (dom_node_children_valid(nodep) == FAILURE) {
    1243           0 :                 RETURN_FALSE;
    1244             :         }
    1245             : 
    1246         158 :         DOM_GET_OBJ(child, node, xmlNodePtr, childobj);
    1247             : 
    1248         158 :         stricterror = dom_get_strict_error(intern->document);
    1249             : 
    1250         316 :         if (dom_node_is_read_only(nodep) == SUCCESS ||
    1251         161 :                 (child->parent != NULL && dom_node_is_read_only(child->parent) == SUCCESS)) {
    1252           0 :                 php_dom_throw_error(NO_MODIFICATION_ALLOWED_ERR, stricterror);
    1253           0 :                 RETURN_FALSE;
    1254             :         }
    1255             : 
    1256         158 :         if (dom_hierarchy(nodep, child) == FAILURE) {
    1257           2 :                 php_dom_throw_error(HIERARCHY_REQUEST_ERR, stricterror);
    1258           2 :                 RETURN_FALSE;
    1259             :         }
    1260             : 
    1261         156 :         if (!(child->doc == NULL || child->doc == nodep->doc)) {
    1262           0 :                 php_dom_throw_error(WRONG_DOCUMENT_ERR, stricterror);
    1263           0 :                 RETURN_FALSE;
    1264             :         }
    1265             : 
    1266         156 :         if (child->type == XML_DOCUMENT_FRAG_NODE && child->children == NULL) {
    1267           1 :                 php_error_docref(NULL, E_WARNING, "Document Fragment is empty");
    1268           1 :                 RETURN_FALSE;
    1269             :         }
    1270             : 
    1271         155 :         if (child->doc == NULL && nodep->doc != NULL) {
    1272          24 :                 childobj->document = intern->document;
    1273          24 :                 php_libxml_increment_doc_ref((php_libxml_node_object *)childobj, NULL);
    1274             :         }
    1275             : 
    1276         155 :         if (child->parent != NULL){
    1277           1 :                 xmlUnlinkNode(child);
    1278             :         }
    1279             : 
    1280         155 :         if (child->type == XML_TEXT_NODE && nodep->last != NULL && nodep->last->type == XML_TEXT_NODE) {
    1281           5 :                 child->parent = nodep;
    1282           5 :                 if (child->doc == NULL) {
    1283           0 :                         xmlSetTreeDoc(child, nodep->doc);
    1284             :                 }
    1285           5 :                 new_child = child;
    1286          10 :                 if (nodep->children == NULL) {
    1287           0 :                         nodep->children = child;
    1288           0 :                         nodep->last = child;
    1289             :                 } else {
    1290           5 :                         child = nodep->last;
    1291           5 :                         child->next = new_child;
    1292           5 :                         new_child->prev = child;
    1293           5 :                         nodep->last = new_child;
    1294             :                 }
    1295         150 :         } else  if (child->type == XML_ATTRIBUTE_NODE) {
    1296             :                 xmlAttrPtr lastattr;
    1297             : 
    1298           2 :                 if (child->ns == NULL)
    1299           1 :                         lastattr = xmlHasProp(nodep, child->name);
    1300             :                 else
    1301           1 :                         lastattr = xmlHasNsProp(nodep, child->name, child->ns->href);
    1302           2 :                 if (lastattr != NULL && lastattr->type != XML_ATTRIBUTE_DECL) {
    1303           0 :                         if (lastattr != (xmlAttrPtr) child) {
    1304           0 :                                 xmlUnlinkNode((xmlNodePtr) lastattr);
    1305           0 :                                 php_libxml_node_free_resource((xmlNodePtr) lastattr);
    1306             :                         }
    1307             :                 }
    1308         148 :         } else if (child->type == XML_DOCUMENT_FRAG_NODE) {
    1309           6 :                 new_child = _php_dom_insert_fragment(nodep, nodep->last, NULL, child, intern, childobj);
    1310             :         }
    1311             : 
    1312         155 :         if (new_child == NULL) {
    1313         144 :                 new_child = xmlAddChild(nodep, child);
    1314         144 :                 if (new_child == NULL) {
    1315           0 :                         php_error_docref(NULL, E_WARNING, "Couldn't append node");
    1316           0 :                         RETURN_FALSE;
    1317             :                 }
    1318             :         }
    1319             : 
    1320         155 :         dom_reconcile_ns(nodep->doc, new_child);
    1321             : 
    1322         155 :         DOM_RET_OBJ(new_child, &ret, intern);
    1323             : }
    1324             : /* }}} end dom_node_append_child */
    1325             : 
    1326             : /* {{{ proto bool dom_node_has_child_nodes();
    1327             : URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-810594187
    1328             : Since:
    1329             : */
    1330          84 : PHP_FUNCTION(dom_node_has_child_nodes)
    1331             : {
    1332             :         zval *id;
    1333             :         xmlNode *nodep;
    1334             :         dom_object *intern;
    1335             : 
    1336          84 :         id = ZEND_THIS;
    1337          84 :         if (zend_parse_parameters_none() == FAILURE) {
    1338           0 :                 return;
    1339             :         }
    1340             : 
    1341          84 :         DOM_GET_OBJ(nodep, id, xmlNodePtr, intern);
    1342             : 
    1343          84 :         if (dom_node_children_valid(nodep) == FAILURE) {
    1344          42 :                 RETURN_FALSE;
    1345             :         }
    1346             : 
    1347          42 :         if (nodep->children) {
    1348          33 :                 RETURN_TRUE;
    1349             :         } else {
    1350           9 :                 RETURN_FALSE;
    1351             :         }
    1352             : }
    1353             : /* }}} end dom_node_has_child_nodes */
    1354             : 
    1355             : /* {{{ proto DomNode dom_node_clone_node(bool deep);
    1356             : URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-3A0ED0A4
    1357             : Since:
    1358             : */
    1359           5 : PHP_FUNCTION(dom_node_clone_node)
    1360             : {
    1361             :         zval *id;
    1362             :         xmlNode *n, *node;
    1363             :         int ret;
    1364             :         dom_object *intern;
    1365           5 :         zend_bool recursive = 0;
    1366             : 
    1367           5 :         id = ZEND_THIS;
    1368           5 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "|b", &recursive) == FAILURE) {
    1369           0 :                 return;
    1370             :         }
    1371             : 
    1372           5 :         DOM_GET_OBJ(n, id, xmlNodePtr, intern);
    1373             : 
    1374           5 :         node = xmlDocCopyNode(n, n->doc, recursive);
    1375             : 
    1376           5 :         if (!node) {
    1377           0 :                 RETURN_FALSE;
    1378             :         }
    1379             : 
    1380             :         /* When deep is false Element nodes still require the attributes
    1381             :         Following taken from libxml as xmlDocCopyNode doesn't do this */
    1382           5 :         if (n->type == XML_ELEMENT_NODE && recursive == 0) {
    1383           3 :                 if (n->nsDef != NULL) {
    1384           0 :                         node->nsDef = xmlCopyNamespaceList(n->nsDef);
    1385             :                 }
    1386           3 :                 if (n->ns != NULL) {
    1387             :                         xmlNsPtr ns;
    1388           0 :                         ns = xmlSearchNs(n->doc, node, n->ns->prefix);
    1389           0 :                         if (ns == NULL) {
    1390           0 :                                 ns = xmlSearchNs(n->doc, n, n->ns->prefix);
    1391           0 :                                 if (ns != NULL) {
    1392           0 :                                         xmlNodePtr root = node;
    1393             : 
    1394           0 :                                         while (root->parent != NULL) {
    1395           0 :                                                 root = root->parent;
    1396             :                                         }
    1397           0 :                                         node->ns = xmlNewNs(root, ns->href, ns->prefix);
    1398             :                                 }
    1399             :                         } else {
    1400           0 :                                 node->ns = ns;
    1401             :                         }
    1402             :                 }
    1403           3 :                 if (n->properties != NULL) {
    1404           3 :                         node->properties = xmlCopyPropList(node, n->properties);
    1405             :                 }
    1406             :         }
    1407             : 
    1408             :         /* If document cloned we want a new document proxy */
    1409           5 :         if (node->doc != n->doc) {
    1410           0 :                 intern = NULL;
    1411             :         }
    1412             : 
    1413           5 :         DOM_RET_OBJ(node, &ret, intern);
    1414             : }
    1415             : /* }}} end dom_node_clone_node */
    1416             : 
    1417             : /* {{{ proto void dom_node_normalize();
    1418             : URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-normalize
    1419             : Since:
    1420             : */
    1421           2 : PHP_FUNCTION(dom_node_normalize)
    1422             : {
    1423             :         zval *id;
    1424             :         xmlNode *nodep;
    1425             :         dom_object *intern;
    1426             : 
    1427           2 :         id = ZEND_THIS;
    1428           2 :         if (zend_parse_parameters_none() == FAILURE) {
    1429           0 :                 return;
    1430             :         }
    1431             : 
    1432           2 :         DOM_GET_OBJ(nodep, id, xmlNodePtr, intern);
    1433             : 
    1434           2 :         dom_normalize(nodep);
    1435             : 
    1436             : }
    1437             : /* }}} end dom_node_normalize */
    1438             : 
    1439             : /* {{{ proto bool dom_node_is_supported(string feature, string version);
    1440             : URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-Level-2-Core-Node-supports
    1441             : Since: DOM Level 2
    1442             : */
    1443           0 : PHP_FUNCTION(dom_node_is_supported)
    1444             : {
    1445             :         size_t feature_len, version_len;
    1446             :         char *feature, *version;
    1447             : 
    1448           0 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss", &feature, &feature_len, &version, &version_len) == FAILURE) {
    1449           0 :                 return;
    1450             :         }
    1451             : 
    1452           0 :         if (dom_has_feature(feature, version)) {
    1453           0 :                 RETURN_TRUE;
    1454             :         } else {
    1455           0 :                 RETURN_FALSE;
    1456             :         }
    1457             : }
    1458             : /* }}} end dom_node_is_supported */
    1459             : 
    1460             : /* {{{ proto bool dom_node_has_attributes();
    1461             : URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-NodeHasAttrs
    1462             : Since: DOM Level 2
    1463             : */
    1464           2 : PHP_FUNCTION(dom_node_has_attributes)
    1465             : {
    1466             :         zval *id;
    1467             :         xmlNode *nodep;
    1468             :         dom_object *intern;
    1469             : 
    1470           2 :         id = ZEND_THIS;
    1471           2 :         if (zend_parse_parameters_none() == FAILURE) {
    1472           0 :                 return;
    1473             :         }
    1474             : 
    1475           2 :         DOM_GET_OBJ(nodep, id, xmlNodePtr, intern);
    1476             : 
    1477           2 :         if (nodep->type != XML_ELEMENT_NODE)
    1478           0 :                 RETURN_FALSE;
    1479             : 
    1480           2 :         if (nodep->properties) {
    1481           1 :                 RETURN_TRUE;
    1482             :         } else {
    1483           1 :                 RETURN_FALSE;
    1484             :         }
    1485             : }
    1486             : /* }}} end dom_node_has_attributes */
    1487             : 
    1488             : /* {{{ proto short dom_node_compare_document_position(DomNode other);
    1489             : URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#Node3-compareDocumentPosition
    1490             : Since: DOM Level 3
    1491             : */
    1492           0 : PHP_FUNCTION(dom_node_compare_document_position)
    1493             : {
    1494           0 :  DOM_NOT_IMPLEMENTED();
    1495             : }
    1496             : /* }}} end dom_node_compare_document_position */
    1497             : 
    1498             : /* {{{ proto bool dom_node_is_same_node(DomNode other);
    1499             : URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#Node3-isSameNode
    1500             : Since: DOM Level 3
    1501             : */
    1502           2 : PHP_FUNCTION(dom_node_is_same_node)
    1503             : {
    1504             :         zval *id, *node;
    1505             :         xmlNodePtr nodeotherp, nodep;
    1506             :         dom_object *intern, *nodeotherobj;
    1507             : 
    1508           2 :         id = ZEND_THIS;
    1509           2 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "O", &node, dom_node_class_entry) == FAILURE) {
    1510           0 :                 return;
    1511             :         }
    1512             : 
    1513           2 :         DOM_GET_OBJ(nodep, id, xmlNodePtr, intern);
    1514             : 
    1515           2 :         DOM_GET_OBJ(nodeotherp, node, xmlNodePtr, nodeotherobj);
    1516             : 
    1517           2 :         if (nodep == nodeotherp) {
    1518           1 :                 RETURN_TRUE;
    1519             :         } else {
    1520           1 :                 RETURN_FALSE;
    1521             :         }
    1522             : }
    1523             : /* }}} end dom_node_is_same_node */
    1524             : 
    1525             : /* {{{ proto string dom_node_lookup_prefix(string namespaceURI);
    1526             : URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#Node3-lookupNamespacePrefix
    1527             : Since: DOM Level 3
    1528             : */
    1529           2 : PHP_FUNCTION(dom_node_lookup_prefix)
    1530             : {
    1531             :         zval *id;
    1532           2 :         xmlNodePtr nodep, lookupp = NULL;
    1533             :         dom_object *intern;
    1534             :         xmlNsPtr nsptr;
    1535           2 :         size_t uri_len = 0;
    1536             :         char *uri;
    1537             : 
    1538           2 :         id = ZEND_THIS;
    1539           2 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &uri, &uri_len) == FAILURE) {
    1540           0 :                 return;
    1541             :         }
    1542             : 
    1543           2 :         DOM_GET_OBJ(nodep, id, xmlNodePtr, intern);
    1544             : 
    1545           2 :         if (uri_len > 0) {
    1546           2 :                 switch (nodep->type) {
    1547           1 :                         case XML_ELEMENT_NODE:
    1548           1 :                                 lookupp = nodep;
    1549           1 :                                 break;
    1550           1 :                         case XML_DOCUMENT_NODE:
    1551             :                         case XML_HTML_DOCUMENT_NODE:
    1552           1 :                                 lookupp = xmlDocGetRootElement((xmlDocPtr) nodep);
    1553           1 :                                 break;
    1554           0 :                         case XML_ENTITY_NODE :
    1555             :                         case XML_NOTATION_NODE:
    1556             :                         case XML_DOCUMENT_FRAG_NODE:
    1557             :                         case XML_DOCUMENT_TYPE_NODE:
    1558             :                         case XML_DTD_NODE:
    1559           0 :                                 RETURN_NULL();
    1560             :                                 break;
    1561           0 :                         default:
    1562           0 :                                 lookupp =  nodep->parent;
    1563             :                 }
    1564             : 
    1565           2 :                 if (lookupp != NULL) {
    1566           2 :                         nsptr = xmlSearchNsByHref(lookupp->doc, lookupp, (xmlChar *) uri);
    1567           2 :                         if (nsptr && nsptr->prefix != NULL) {
    1568           4 :                                 RETURN_STRING((char *) nsptr->prefix);
    1569             :                         }
    1570             :                 }
    1571             :         }
    1572             : 
    1573           0 :         RETURN_NULL();
    1574             : }
    1575             : /* }}} end dom_node_lookup_prefix */
    1576             : 
    1577             : /* {{{ proto bool dom_node_is_default_namespace(string namespaceURI);
    1578             : URL: http://www.w3.org/TR/DOM-Level-3-Core/core.html#Node3-isDefaultNamespace
    1579             : Since: DOM Level 3
    1580             : */
    1581           2 : PHP_FUNCTION(dom_node_is_default_namespace)
    1582             : {
    1583             :         zval *id;
    1584             :         xmlNodePtr nodep;
    1585             :         dom_object *intern;
    1586             :         xmlNsPtr nsptr;
    1587           2 :         size_t uri_len = 0;
    1588             :         char *uri;
    1589             : 
    1590           2 :         id = ZEND_THIS;
    1591           2 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &uri, &uri_len) == FAILURE) {
    1592           0 :                 return;
    1593             :         }
    1594             : 
    1595           2 :         DOM_GET_OBJ(nodep, id, xmlNodePtr, intern);
    1596           2 :         if (nodep->type == XML_DOCUMENT_NODE || nodep->type == XML_HTML_DOCUMENT_NODE) {
    1597           1 :                 nodep = xmlDocGetRootElement((xmlDocPtr) nodep);
    1598             :         }
    1599             : 
    1600           2 :         if (nodep && uri_len > 0) {
    1601           2 :                 nsptr = xmlSearchNs(nodep->doc, nodep, NULL);
    1602           2 :                 if (nsptr && xmlStrEqual(nsptr->href, (xmlChar *) uri)) {
    1603           2 :                         RETURN_TRUE;
    1604             :                 }
    1605             :         }
    1606             : 
    1607           0 :         RETURN_FALSE;
    1608             : }
    1609             : /* }}} end dom_node_is_default_namespace */
    1610             : 
    1611             : /* {{{ proto string dom_node_lookup_namespace_uri(string prefix);
    1612             : URL: http://www.w3.org/TR/DOM-Level-3-Core/core.html#Node3-lookupNamespaceURI
    1613             : Since: DOM Level 3
    1614             : */
    1615           3 : PHP_FUNCTION(dom_node_lookup_namespace_uri)
    1616             : {
    1617             :         zval *id;
    1618             :         xmlNodePtr nodep;
    1619             :         dom_object *intern;
    1620             :         xmlNsPtr nsptr;
    1621             :         size_t prefix_len;
    1622             :         char *prefix;
    1623             : 
    1624           3 :         id = ZEND_THIS;
    1625           3 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "s!", &prefix, &prefix_len) == FAILURE) {
    1626           0 :                 return;
    1627             :         }
    1628             : 
    1629           3 :         DOM_GET_OBJ(nodep, id, xmlNodePtr, intern);
    1630           3 :         if (nodep->type == XML_DOCUMENT_NODE || nodep->type == XML_HTML_DOCUMENT_NODE) {
    1631           1 :                 nodep = xmlDocGetRootElement((xmlDocPtr) nodep);
    1632           1 :                 if (nodep == NULL) {
    1633           0 :                         RETURN_NULL();
    1634             :                 }
    1635             :         }
    1636             : 
    1637           3 :         nsptr = xmlSearchNs(nodep->doc, nodep, (xmlChar *) prefix);
    1638           3 :         if (nsptr && nsptr->href != NULL) {
    1639           6 :                 RETURN_STRING((char *) nsptr->href);
    1640             :         }
    1641             : 
    1642           0 :         RETURN_NULL();
    1643             : }
    1644             : /* }}} end dom_node_lookup_namespace_uri */
    1645             : 
    1646             : /* {{{ proto bool dom_node_is_equal_node(DomNode arg);
    1647             : URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#Node3-isEqualNode
    1648             : Since: DOM Level 3
    1649             : */
    1650           0 : PHP_FUNCTION(dom_node_is_equal_node)
    1651             : {
    1652           0 :  DOM_NOT_IMPLEMENTED();
    1653             : }
    1654             : /* }}} end dom_node_is_equal_node */
    1655             : 
    1656             : /* {{{ proto DomNode dom_node_get_feature(string feature, string version);
    1657             : URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#Node3-getFeature
    1658             : Since: DOM Level 3
    1659             : */
    1660           0 : PHP_FUNCTION(dom_node_get_feature)
    1661             : {
    1662           0 :  DOM_NOT_IMPLEMENTED();
    1663             : }
    1664             : /* }}} end dom_node_get_feature */
    1665             : 
    1666             : /* {{{ proto mixed dom_node_set_user_data(string key, mixed data, userdatahandler handler);
    1667             : URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#Node3-setUserData
    1668             : Since: DOM Level 3
    1669             : */
    1670           0 : PHP_FUNCTION(dom_node_set_user_data)
    1671             : {
    1672           0 :  DOM_NOT_IMPLEMENTED();
    1673             : }
    1674             : /* }}} end dom_node_set_user_data */
    1675             : 
    1676             : /* {{{ proto mixed dom_node_get_user_data(string key);
    1677             : URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#Node3-getUserData
    1678             : Since: DOM Level 3
    1679             : */
    1680           0 : PHP_FUNCTION(dom_node_get_user_data)
    1681             : {
    1682           0 :  DOM_NOT_IMPLEMENTED();
    1683             : }
    1684             : /* }}} end dom_node_get_user_data */
    1685             : 
    1686           9 : static void dom_canonicalization(INTERNAL_FUNCTION_PARAMETERS, int mode) /* {{{ */
    1687             : {
    1688             :         zval *id;
    1689           9 :         zval *xpath_array=NULL, *ns_prefixes=NULL;
    1690             :         xmlNodePtr nodep;
    1691             :         xmlDocPtr docp;
    1692           9 :         xmlNodeSetPtr nodeset = NULL;
    1693             :         dom_object *intern;
    1694           9 :         zend_bool exclusive=0, with_comments=0;
    1695           9 :         xmlChar **inclusive_ns_prefixes = NULL;
    1696           9 :         char *file = NULL;
    1697           9 :         int ret = -1;
    1698           9 :         size_t file_len = 0;
    1699             :         xmlOutputBufferPtr buf;
    1700           9 :         xmlXPathContextPtr ctxp=NULL;
    1701           9 :         xmlXPathObjectPtr xpathobjp=NULL;
    1702             : 
    1703           9 :         id = ZEND_THIS;
    1704           9 :         if (mode == 0) {
    1705           8 :                 if (zend_parse_parameters(ZEND_NUM_ARGS(),
    1706             :                         "|bba!a!", &exclusive, &with_comments,
    1707             :                         &xpath_array, &ns_prefixes) == FAILURE) {
    1708           1 :                         return;
    1709             :                 }
    1710             :         } else {
    1711           1 :                 if (zend_parse_parameters(ZEND_NUM_ARGS(),
    1712             :                         "s|bba!a!", &file, &file_len, &exclusive,
    1713             :                         &with_comments, &xpath_array, &ns_prefixes) == FAILURE) {
    1714           0 :                         return;
    1715             :                 }
    1716             :         }
    1717             : 
    1718           9 :         DOM_GET_OBJ(nodep, id, xmlNodePtr, intern);
    1719             : 
    1720           9 :         docp = nodep->doc;
    1721             : 
    1722           9 :         if (! docp) {
    1723           0 :                 php_error_docref(NULL, E_WARNING, "Node must be associated with a document");
    1724           0 :                 RETURN_FALSE;
    1725             :         }
    1726             : 
    1727           9 :         if (xpath_array == NULL) {
    1728           7 :                 if (nodep->type != XML_DOCUMENT_NODE) {
    1729           7 :                         ctxp = xmlXPathNewContext(docp);
    1730           7 :                         ctxp->node = nodep;
    1731           7 :                         xpathobjp = xmlXPathEvalExpression((xmlChar *) "(.//. | .//@* | .//namespace::*)", ctxp);
    1732           7 :                         ctxp->node = NULL;
    1733           7 :                         if (xpathobjp && xpathobjp->type == XPATH_NODESET) {
    1734           7 :                                 nodeset = xpathobjp->nodesetval;
    1735             :                         } else {
    1736           0 :                                 if (xpathobjp) {
    1737           0 :                                         xmlXPathFreeObject(xpathobjp);
    1738             :                                 }
    1739           0 :                                 xmlXPathFreeContext(ctxp);
    1740           0 :                                 php_error_docref(NULL, E_WARNING, "XPath query did not return a nodeset.");
    1741           0 :                                 RETURN_FALSE;
    1742             :                         }
    1743             :                 }
    1744             :         } else {
    1745             :                 /*xpath query from xpath_array */
    1746           2 :                 HashTable *ht = Z_ARRVAL_P(xpath_array);
    1747             :                 zval *tmp;
    1748             :                 char *xquery;
    1749             : 
    1750           2 :                 tmp = zend_hash_str_find(ht, "query", sizeof("query")-1);
    1751           4 :                 if (tmp && Z_TYPE_P(tmp) == IS_STRING) {
    1752           2 :                         xquery = Z_STRVAL_P(tmp);
    1753             :                 } else {
    1754           0 :                         php_error_docref(NULL, E_WARNING, "'query' missing from xpath array or is not a string");
    1755           0 :                         RETURN_FALSE;
    1756             :                 }
    1757             : 
    1758           2 :                 ctxp = xmlXPathNewContext(docp);
    1759           2 :                 ctxp->node = nodep;
    1760             : 
    1761           2 :                 tmp = zend_hash_str_find(ht, "namespaces", sizeof("namespaces")-1);
    1762           3 :                 if (tmp && Z_TYPE_P(tmp) == IS_ARRAY) {
    1763             :                         zval *tmpns;
    1764             :                         zend_string *prefix;
    1765             : 
    1766           3 :                         ZEND_HASH_FOREACH_STR_KEY_VAL(Z_ARRVAL_P(tmp), prefix, tmpns) {
    1767           1 :                                 if (Z_TYPE_P(tmpns) == IS_STRING) {
    1768           1 :                                         if (prefix) {
    1769           1 :                                                 xmlXPathRegisterNs(ctxp, (xmlChar *) ZSTR_VAL(prefix), (xmlChar *) Z_STRVAL_P(tmpns));
    1770             :                                         }
    1771             :                                 }
    1772             :                         } ZEND_HASH_FOREACH_END();
    1773             :                 }
    1774             : 
    1775           2 :                 xpathobjp = xmlXPathEvalExpression((xmlChar *) xquery, ctxp);
    1776           2 :                 ctxp->node = NULL;
    1777           2 :                 if (xpathobjp && xpathobjp->type == XPATH_NODESET) {
    1778           2 :                         nodeset = xpathobjp->nodesetval;
    1779             :                 } else {
    1780           0 :                         if (xpathobjp) {
    1781           0 :                                 xmlXPathFreeObject(xpathobjp);
    1782             :                         }
    1783           0 :                         xmlXPathFreeContext(ctxp);
    1784           0 :                         php_error_docref(NULL, E_WARNING, "XPath query did not return a nodeset.");
    1785           0 :                         RETURN_FALSE;
    1786             :                 }
    1787             :         }
    1788             : 
    1789           9 :         if (ns_prefixes != NULL) {
    1790           2 :                 if (exclusive) {
    1791             :                         zval *tmpns;
    1792           2 :                         int nscount = 0;
    1793             : 
    1794           2 :                         inclusive_ns_prefixes = safe_emalloc(zend_hash_num_elements(Z_ARRVAL_P(ns_prefixes)) + 1,
    1795             :                                 sizeof(xmlChar *), 0);
    1796           6 :                         ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(ns_prefixes), tmpns) {
    1797           2 :                                 if (Z_TYPE_P(tmpns) == IS_STRING) {
    1798           2 :                                         inclusive_ns_prefixes[nscount++] = (xmlChar *) Z_STRVAL_P(tmpns);
    1799             :                                 }
    1800             :                         } ZEND_HASH_FOREACH_END();
    1801           2 :                         inclusive_ns_prefixes[nscount] = NULL;
    1802             :                 } else {
    1803           0 :                         php_error_docref(NULL, E_NOTICE,
    1804             :                                 "Inclusive namespace prefixes only allowed in exclusive mode.");
    1805             :                 }
    1806             :         }
    1807             : 
    1808           9 :         if (mode == 1) {
    1809           1 :                 buf = xmlOutputBufferCreateFilename(file, NULL, 0);
    1810             :         } else {
    1811           8 :                 buf = xmlAllocOutputBuffer(NULL);
    1812             :         }
    1813             : 
    1814           9 :     if (buf != NULL) {
    1815           9 :                 ret = xmlC14NDocSaveTo(docp, nodeset, exclusive, inclusive_ns_prefixes,
    1816             :                         with_comments, buf);
    1817             :         }
    1818             : 
    1819           9 :         if (inclusive_ns_prefixes != NULL) {
    1820           2 :                 efree(inclusive_ns_prefixes);
    1821             :         }
    1822           9 :         if (xpathobjp != NULL) {
    1823           9 :                 xmlXPathFreeObject(xpathobjp);
    1824             :         }
    1825           9 :         if (ctxp != NULL) {
    1826           9 :                 xmlXPathFreeContext(ctxp);
    1827             :         }
    1828             : 
    1829           9 :     if (buf == NULL || ret < 0) {
    1830           0 :         RETVAL_FALSE;
    1831             :     } else {
    1832           9 :                 if (mode == 0) {
    1833             : #ifdef LIBXML2_NEW_BUFFER
    1834             :                         ret = xmlOutputBufferGetSize(buf);
    1835             : #else
    1836           8 :                         ret = buf->buffer->use;
    1837             : #endif
    1838           8 :                         if (ret > 0) {
    1839             : #ifdef LIBXML2_NEW_BUFFER
    1840             :                                 RETVAL_STRINGL((char *) xmlOutputBufferGetContent(buf), ret);
    1841             : #else
    1842          16 :                                 RETVAL_STRINGL((char *) buf->buffer->content, ret);
    1843             : #endif
    1844             :                         } else {
    1845           0 :                                 RETVAL_EMPTY_STRING();
    1846             :                         }
    1847             :                 }
    1848             :     }
    1849             : 
    1850           9 :         if (buf) {
    1851             :                 int bytes;
    1852             : 
    1853           9 :                 bytes = xmlOutputBufferClose(buf);
    1854           9 :                 if (mode == 1 && (ret >= 0)) {
    1855           1 :                         RETURN_LONG(bytes);
    1856             :                 }
    1857             :         }
    1858             : }
    1859             : /* }}} */
    1860             : 
    1861             : /* {{{ proto string DOMNode::C14N([bool exclusive [, bool with_comments [, array xpath [, array ns_prefixes]]]])
    1862             :    Canonicalize nodes to a string */
    1863           8 : PHP_METHOD(domnode, C14N)
    1864             : {
    1865           8 :         dom_canonicalization(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
    1866           8 : }
    1867             : /* }}} */
    1868             : 
    1869             : /* {{{ proto int DOMNode::C14NFile(string uri [, bool exclusive [, bool with_comments [, array xpath [, array ns_prefixes]]]])
    1870             :    Canonicalize nodes to a file */
    1871           1 : PHP_METHOD(domnode, C14NFile)
    1872             : {
    1873           1 :         dom_canonicalization(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
    1874           1 : }
    1875             : /* }}} */
    1876             : 
    1877             : /* {{{ proto int DOMNode::getNodePath()
    1878             :    Gets an xpath for a node */
    1879           2 : PHP_METHOD(domnode, getNodePath)
    1880             : {
    1881             :         zval *id;
    1882             :         xmlNode *nodep;
    1883             :         dom_object *intern;
    1884             :         char *value;
    1885             : 
    1886           2 :         DOM_GET_THIS_OBJ(nodep, id, xmlNodePtr, intern);
    1887             : 
    1888           2 :         value = (char *) xmlGetNodePath(nodep);
    1889           2 :         if (value == NULL) {
    1890           0 :                 RETURN_NULL();
    1891             :         } else {
    1892           4 :                 RETVAL_STRING(value);
    1893           2 :                 xmlFree(value);
    1894             :         }
    1895             : }
    1896             : /* }}} */
    1897             : 
    1898             : /* {{{ proto int DOMNode::getLineNo()
    1899             :    Gets line number for a node */
    1900           3 : PHP_METHOD(domnode, getLineNo)
    1901             : {
    1902             :         zval *id;
    1903             :         xmlNode *nodep;
    1904             :         dom_object *intern;
    1905             : 
    1906           3 :         if (zend_parse_parameters_none() == FAILURE) {
    1907           0 :                 return;
    1908             :         }
    1909             : 
    1910           3 :         DOM_GET_THIS_OBJ(nodep, id, xmlNodePtr, intern);
    1911             : 
    1912           3 :         RETURN_LONG(xmlGetLineNo(nodep));
    1913             : }
    1914             : /* }}} */
    1915             : 
    1916             : #endif

Generated by: LCOV version 1.10

Generated at Mon, 06 May 2019 17:58:13 +0000 (998 days ago)

Copyright © 2005-2022 The PHP Group
All rights reserved.