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 - document.c (source / functions) Hit Total Coverage
Test: PHP Code Coverage Lines: 728 944 77.1 %
Date: 2015-04-24 Functions: 62 67 92.5 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :    +----------------------------------------------------------------------+
       3             :    | PHP Version 5                                                        |
       4             :    +----------------------------------------------------------------------+
       5             :    | Copyright (c) 1997-2014 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             : /* $Id$ */
      21             : 
      22             : #ifdef HAVE_CONFIG_H
      23             : #include "config.h"
      24             : #endif
      25             : 
      26             : #include "php.h"
      27             : #if HAVE_LIBXML && HAVE_DOM
      28             : #include "php_dom.h"
      29             : #include <libxml/SAX.h>
      30             : #ifdef LIBXML_SCHEMAS_ENABLED
      31             : #include <libxml/relaxng.h>
      32             : #include <libxml/xmlschemas.h>
      33             : #endif
      34             : 
      35             : typedef struct _idsIterator idsIterator;
      36             : struct _idsIterator {
      37             :         xmlChar *elementId;
      38             :         xmlNode *element;
      39             : };
      40             : 
      41             : #define DOM_LOAD_STRING 0
      42             : #define DOM_LOAD_FILE 1
      43             : 
      44             : /* {{{ arginfo */
      45             : ZEND_BEGIN_ARG_INFO_EX(arginfo_dom_document_create_element, 0, 0, 1)
      46             :         ZEND_ARG_INFO(0, tagName)
      47             :         ZEND_ARG_INFO(0, value)
      48             : ZEND_END_ARG_INFO();
      49             : 
      50             : ZEND_BEGIN_ARG_INFO_EX(arginfo_dom_document_create_document_fragment, 0, 0, 0)
      51             : ZEND_END_ARG_INFO();
      52             : 
      53             : ZEND_BEGIN_ARG_INFO_EX(arginfo_dom_document_create_text_node, 0, 0, 1)
      54             :         ZEND_ARG_INFO(0, data)
      55             : ZEND_END_ARG_INFO();
      56             : 
      57             : ZEND_BEGIN_ARG_INFO_EX(arginfo_dom_document_create_comment, 0, 0, 1)
      58             :         ZEND_ARG_INFO(0, data)
      59             : ZEND_END_ARG_INFO();
      60             : 
      61             : ZEND_BEGIN_ARG_INFO_EX(arginfo_dom_document_create_cdatasection, 0, 0, 1)
      62             :         ZEND_ARG_INFO(0, data)
      63             : ZEND_END_ARG_INFO();
      64             : 
      65             : ZEND_BEGIN_ARG_INFO_EX(arginfo_dom_document_create_processing_instruction, 0, 0, 2)
      66             :         ZEND_ARG_INFO(0, target)
      67             :         ZEND_ARG_INFO(0, data)
      68             : ZEND_END_ARG_INFO();
      69             : 
      70             : ZEND_BEGIN_ARG_INFO_EX(arginfo_dom_document_create_attribute, 0, 0, 1)
      71             :         ZEND_ARG_INFO(0, name)
      72             : ZEND_END_ARG_INFO();
      73             : 
      74             : ZEND_BEGIN_ARG_INFO_EX(arginfo_dom_document_create_entity_reference, 0, 0, 1)
      75             :         ZEND_ARG_INFO(0, name)
      76             : ZEND_END_ARG_INFO();
      77             : 
      78             : ZEND_BEGIN_ARG_INFO_EX(arginfo_dom_document_get_elements_by_tag_name, 0, 0, 1)
      79             :         ZEND_ARG_INFO(0, tagName)
      80             : ZEND_END_ARG_INFO();
      81             : 
      82             : ZEND_BEGIN_ARG_INFO_EX(arginfo_dom_document_import_node, 0, 0, 2)
      83             :         ZEND_ARG_OBJ_INFO(0, importedNode, DOMNode, 0)
      84             :         ZEND_ARG_INFO(0, deep)
      85             : ZEND_END_ARG_INFO();
      86             : 
      87             : ZEND_BEGIN_ARG_INFO_EX(arginfo_dom_document_create_element_ns, 0, 0, 2)
      88             :         ZEND_ARG_INFO(0, namespaceURI)
      89             :         ZEND_ARG_INFO(0, qualifiedName)
      90             :         ZEND_ARG_INFO(0, value)
      91             : ZEND_END_ARG_INFO();
      92             : 
      93             : ZEND_BEGIN_ARG_INFO_EX(arginfo_dom_document_create_attribute_ns, 0, 0, 2)
      94             :         ZEND_ARG_INFO(0, namespaceURI)
      95             :         ZEND_ARG_INFO(0, qualifiedName)
      96             : ZEND_END_ARG_INFO();
      97             : 
      98             : ZEND_BEGIN_ARG_INFO_EX(arginfo_dom_document_get_elements_by_tag_name_ns, 0, 0, 2)
      99             :         ZEND_ARG_INFO(0, namespaceURI)
     100             :         ZEND_ARG_INFO(0, localName)
     101             : ZEND_END_ARG_INFO();
     102             : 
     103             : ZEND_BEGIN_ARG_INFO_EX(arginfo_dom_document_get_element_by_id, 0, 0, 1)
     104             :         ZEND_ARG_INFO(0, elementId)
     105             : ZEND_END_ARG_INFO();
     106             : 
     107             : ZEND_BEGIN_ARG_INFO_EX(arginfo_dom_document_adopt_node, 0, 0, 1)
     108             :         ZEND_ARG_OBJ_INFO(0, source, DOMNode, 0)
     109             : ZEND_END_ARG_INFO();
     110             : 
     111             : ZEND_BEGIN_ARG_INFO_EX(arginfo_dom_document_normalize_document, 0, 0, 0)
     112             : ZEND_END_ARG_INFO();
     113             : 
     114             : ZEND_BEGIN_ARG_INFO_EX(arginfo_dom_document_rename_node, 0, 0, 3)
     115             :         ZEND_ARG_OBJ_INFO(0, node, DOMNode, 0)
     116             :         ZEND_ARG_INFO(0, namespaceURI)
     117             :         ZEND_ARG_INFO(0, qualifiedName)
     118             : ZEND_END_ARG_INFO();
     119             : 
     120             : ZEND_BEGIN_ARG_INFO_EX(arginfo_dom_document_load, 0, 0, 1)
     121             :         ZEND_ARG_INFO(0, source)
     122             :         ZEND_ARG_INFO(0, options)
     123             : ZEND_END_ARG_INFO();
     124             : 
     125             : ZEND_BEGIN_ARG_INFO_EX(arginfo_dom_document_save, 0, 0, 1)
     126             :         ZEND_ARG_INFO(0, file)
     127             : ZEND_END_ARG_INFO();
     128             : 
     129             : ZEND_BEGIN_ARG_INFO_EX(arginfo_dom_document_loadxml, 0, 0, 1)
     130             :         ZEND_ARG_INFO(0, source)
     131             :         ZEND_ARG_INFO(0, options)
     132             : ZEND_END_ARG_INFO();
     133             : 
     134             : ZEND_BEGIN_ARG_INFO_EX(arginfo_dom_document_savexml, 0, 0, 0)
     135             :         ZEND_ARG_OBJ_INFO(0, node, DOMNode, 1)
     136             : ZEND_END_ARG_INFO();
     137             : 
     138             : ZEND_BEGIN_ARG_INFO_EX(arginfo_dom_document_construct, 0, 0, 0)
     139             :         ZEND_ARG_INFO(0, version)
     140             :         ZEND_ARG_INFO(0, encoding)
     141             : ZEND_END_ARG_INFO();
     142             : 
     143             : ZEND_BEGIN_ARG_INFO_EX(arginfo_dom_document_validate, 0, 0, 0)
     144             : ZEND_END_ARG_INFO();
     145             : 
     146             : ZEND_BEGIN_ARG_INFO_EX(arginfo_dom_document_xinclude, 0, 0, 0)
     147             :         ZEND_ARG_INFO(0, options)
     148             : ZEND_END_ARG_INFO();
     149             : 
     150             : ZEND_BEGIN_ARG_INFO_EX(arginfo_dom_document_loadhtml, 0, 0, 1)
     151             :         ZEND_ARG_INFO(0, source)
     152             :         ZEND_ARG_INFO(0, options)
     153             : ZEND_END_ARG_INFO();
     154             : 
     155             : ZEND_BEGIN_ARG_INFO_EX(arginfo_dom_document_loadhtmlfile, 0, 0, 1)
     156             :         ZEND_ARG_INFO(0, source)
     157             :         ZEND_ARG_INFO(0, options)
     158             : ZEND_END_ARG_INFO();
     159             : 
     160             : ZEND_BEGIN_ARG_INFO_EX(arginfo_dom_document_savehtml, 0, 0, 0)
     161             : ZEND_END_ARG_INFO();
     162             : 
     163             : ZEND_BEGIN_ARG_INFO_EX(arginfo_dom_document_savehtmlfile, 0, 0, 1)
     164             :         ZEND_ARG_INFO(0, file)
     165             : ZEND_END_ARG_INFO();
     166             : 
     167             : ZEND_BEGIN_ARG_INFO_EX(arginfo_dom_document_schema_validate_file, 0, 0, 1)
     168             :         ZEND_ARG_INFO(0, filename)
     169             : ZEND_END_ARG_INFO();
     170             : 
     171             : ZEND_BEGIN_ARG_INFO_EX(arginfo_dom_document_schema_validate_xml, 0, 0, 1)
     172             :         ZEND_ARG_INFO(0, source)
     173             : ZEND_END_ARG_INFO();
     174             : 
     175             : ZEND_BEGIN_ARG_INFO_EX(arginfo_dom_document_relaxNG_validate_file, 0, 0, 1)
     176             :         ZEND_ARG_INFO(0, filename)
     177             : ZEND_END_ARG_INFO();
     178             : 
     179             : ZEND_BEGIN_ARG_INFO_EX(arginfo_dom_document_relaxNG_validate_xml, 0, 0, 1)
     180             :         ZEND_ARG_INFO(0, source)
     181             : ZEND_END_ARG_INFO();
     182             : 
     183             : ZEND_BEGIN_ARG_INFO_EX(arginfo_dom_document_registernodeclass, 0, 0, 2)
     184             :         ZEND_ARG_INFO(0, baseClass)
     185             :         ZEND_ARG_INFO(0, extendedClass)
     186             : ZEND_END_ARG_INFO();
     187             : /* }}} */
     188             : 
     189             : /*
     190             : * class DOMDocument extends DOMNode
     191             : *
     192             : * URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-i-Document
     193             : * Since:
     194             : */
     195             : 
     196             : const zend_function_entry php_dom_document_class_functions[] = { /* {{{ */
     197             :         PHP_FALIAS(createElement, dom_document_create_element, arginfo_dom_document_create_element)
     198             :         PHP_FALIAS(createDocumentFragment, dom_document_create_document_fragment, arginfo_dom_document_create_document_fragment)
     199             :         PHP_FALIAS(createTextNode, dom_document_create_text_node, arginfo_dom_document_create_text_node)
     200             :         PHP_FALIAS(createComment, dom_document_create_comment, arginfo_dom_document_create_comment)
     201             :         PHP_FALIAS(createCDATASection, dom_document_create_cdatasection, arginfo_dom_document_create_cdatasection)
     202             :         PHP_FALIAS(createProcessingInstruction, dom_document_create_processing_instruction, arginfo_dom_document_create_processing_instruction)
     203             :         PHP_FALIAS(createAttribute, dom_document_create_attribute, arginfo_dom_document_create_attribute)
     204             :         PHP_FALIAS(createEntityReference, dom_document_create_entity_reference, arginfo_dom_document_create_entity_reference)
     205             :         PHP_FALIAS(getElementsByTagName, dom_document_get_elements_by_tag_name, arginfo_dom_document_get_elements_by_tag_name)
     206             :         PHP_FALIAS(importNode, dom_document_import_node, arginfo_dom_document_import_node)
     207             :         PHP_FALIAS(createElementNS, dom_document_create_element_ns, arginfo_dom_document_create_element_ns)
     208             :         PHP_FALIAS(createAttributeNS, dom_document_create_attribute_ns, arginfo_dom_document_create_attribute_ns)
     209             :         PHP_FALIAS(getElementsByTagNameNS, dom_document_get_elements_by_tag_name_ns, arginfo_dom_document_get_elements_by_tag_name_ns)
     210             :         PHP_FALIAS(getElementById, dom_document_get_element_by_id, arginfo_dom_document_get_element_by_id)
     211             :         PHP_FALIAS(adoptNode, dom_document_adopt_node, arginfo_dom_document_adopt_node)
     212             :         PHP_FALIAS(normalizeDocument, dom_document_normalize_document, arginfo_dom_document_normalize_document)
     213             :         PHP_FALIAS(renameNode, dom_document_rename_node, arginfo_dom_document_rename_node)
     214             :         PHP_ME(domdocument, load, arginfo_dom_document_load, ZEND_ACC_PUBLIC|ZEND_ACC_ALLOW_STATIC)
     215             :         PHP_FALIAS(save, dom_document_save, arginfo_dom_document_save)
     216             :         PHP_ME(domdocument, loadXML, arginfo_dom_document_loadxml, ZEND_ACC_PUBLIC|ZEND_ACC_ALLOW_STATIC)
     217             :         PHP_FALIAS(saveXML, dom_document_savexml, arginfo_dom_document_savexml)
     218             :         PHP_ME(domdocument, __construct, arginfo_dom_document_construct, ZEND_ACC_PUBLIC)
     219             :         PHP_FALIAS(validate, dom_document_validate, arginfo_dom_document_validate)
     220             :         PHP_FALIAS(xinclude, dom_document_xinclude, arginfo_dom_document_xinclude)
     221             : #if defined(LIBXML_HTML_ENABLED)
     222             :         PHP_ME(domdocument, loadHTML, arginfo_dom_document_loadhtml, ZEND_ACC_PUBLIC|ZEND_ACC_ALLOW_STATIC)
     223             :         PHP_ME(domdocument, loadHTMLFile, arginfo_dom_document_loadhtmlfile, ZEND_ACC_PUBLIC|ZEND_ACC_ALLOW_STATIC)
     224             :         PHP_FALIAS(saveHTML, dom_document_save_html, arginfo_dom_document_savehtml)
     225             :         PHP_FALIAS(saveHTMLFile, dom_document_save_html_file, arginfo_dom_document_savehtmlfile)
     226             : #endif  /* defined(LIBXML_HTML_ENABLED) */
     227             : #if defined(LIBXML_SCHEMAS_ENABLED)
     228             :         PHP_FALIAS(schemaValidate, dom_document_schema_validate_file, arginfo_dom_document_schema_validate_file)
     229             :         PHP_FALIAS(schemaValidateSource, dom_document_schema_validate_xml, arginfo_dom_document_schema_validate_xml)
     230             :         PHP_FALIAS(relaxNGValidate, dom_document_relaxNG_validate_file, arginfo_dom_document_relaxNG_validate_file)
     231             :         PHP_FALIAS(relaxNGValidateSource, dom_document_relaxNG_validate_xml, arginfo_dom_document_relaxNG_validate_xml)
     232             : #endif
     233             :         PHP_ME(domdocument, registerNodeClass, arginfo_dom_document_registernodeclass, ZEND_ACC_PUBLIC)
     234             :         PHP_FE_END
     235             : };
     236             : /* }}} */
     237             : 
     238             : /* {{{ docType  DOMDocumentType
     239             : readonly=yes
     240             : URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-B63ED1A31
     241             : Since:
     242             : */
     243          11 : int dom_document_doctype_read(dom_object *obj, zval **retval TSRMLS_DC)
     244             : {
     245             :         xmlDoc *docp;
     246             :         xmlDtdPtr dtdptr;
     247             :         int ret;
     248             : 
     249          11 :         docp = (xmlDocPtr) dom_object_get_node(obj);
     250             : 
     251          11 :         if (docp == NULL) {
     252           0 :                 php_dom_throw_error(INVALID_STATE_ERR, 0 TSRMLS_CC);
     253           0 :                 return FAILURE;
     254             :         }
     255             : 
     256          11 :         ALLOC_ZVAL(*retval);
     257             : 
     258          11 :         dtdptr = xmlGetIntSubset(docp);
     259          11 :         if (!dtdptr) {
     260           1 :                 ZVAL_NULL(*retval);
     261           1 :                 return SUCCESS;
     262             :         }
     263             : 
     264          10 :         if (NULL == (*retval = php_dom_create_object((xmlNodePtr) dtdptr, &ret, *retval, obj TSRMLS_CC))) {
     265           0 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot create required DOM object");
     266           0 :                 return FAILURE;
     267             :         }
     268          10 :         return SUCCESS;
     269             : 
     270             : }
     271             : 
     272             : /* }}} */
     273             : 
     274             : /* {{{ implementation   DOMImplementation
     275             : readonly=yes
     276             : URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-1B793EBA
     277             : Since:
     278             : */
     279           2 : int dom_document_implementation_read(dom_object *obj, zval **retval TSRMLS_DC)
     280             : {
     281           2 :         ALLOC_ZVAL(*retval);
     282           2 :         php_dom_create_implementation(retval TSRMLS_CC);
     283           2 :         return SUCCESS;
     284             : }
     285             : 
     286             : /* }}} */
     287             : 
     288             : /* {{{ documentElement  DOMElement
     289             : readonly=yes
     290             : URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-87CD092
     291             : Since:
     292             : */
     293          47 : int dom_document_document_element_read(dom_object *obj, zval **retval TSRMLS_DC)
     294             : {
     295             :         xmlDoc *docp;
     296             :         xmlNode *root;
     297             :         int ret;
     298             : 
     299          47 :         docp = (xmlDocPtr) dom_object_get_node(obj);
     300             : 
     301          47 :         if (docp == NULL) {
     302           0 :                 php_dom_throw_error(INVALID_STATE_ERR, 0 TSRMLS_CC);
     303           0 :                 return FAILURE;
     304             :         }
     305             : 
     306          47 :         ALLOC_ZVAL(*retval);
     307             : 
     308          47 :         root = xmlDocGetRootElement(docp);
     309          47 :         if (!root) {
     310           1 :                 ZVAL_NULL(*retval);
     311           1 :                 return SUCCESS;
     312             :         }
     313             : 
     314          46 :         if (NULL == (*retval = php_dom_create_object(root, &ret, *retval, obj TSRMLS_CC))) {
     315           0 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot create required DOM object");
     316           0 :                 return FAILURE;
     317             :         }
     318          46 :         return SUCCESS;
     319             : }
     320             : 
     321             : /* }}} */
     322             : 
     323             : /* {{{ encoding string
     324             : URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-Document3-encoding
     325             : Since: DOM Level 3
     326             : */
     327           7 : int dom_document_encoding_read(dom_object *obj, zval **retval TSRMLS_DC)
     328             : {
     329             :         xmlDoc *docp;
     330             :         char *encoding;
     331             : 
     332           7 :         docp = (xmlDocPtr) dom_object_get_node(obj);
     333             : 
     334           7 :         if (docp == NULL) {
     335           0 :                 php_dom_throw_error(INVALID_STATE_ERR, 0 TSRMLS_CC);
     336           0 :                 return FAILURE;
     337             :         }
     338             : 
     339           7 :         encoding = (char *) docp->encoding;
     340           7 :         ALLOC_ZVAL(*retval);
     341             : 
     342           7 :         if (encoding != NULL) {
     343           3 :                 ZVAL_STRING(*retval, encoding, 1);
     344             :         } else {
     345           4 :                 ZVAL_NULL(*retval);
     346             :         }
     347             : 
     348           7 :         return SUCCESS;
     349             : }
     350             : 
     351           4 : int dom_document_encoding_write(dom_object *obj, zval *newval TSRMLS_DC)
     352             : {
     353             :         zval value_copy;
     354             :         xmlDoc *docp;
     355             :         xmlCharEncodingHandlerPtr handler;
     356             : 
     357           4 :         docp = (xmlDocPtr) dom_object_get_node(obj);
     358             : 
     359           4 :         if (docp == NULL) {
     360           0 :                 php_dom_throw_error(INVALID_STATE_ERR, 0 TSRMLS_CC);
     361           0 :                 return FAILURE;
     362             :         }
     363             : 
     364           4 :         if (newval->type != IS_STRING) {
     365           0 :                 if(Z_REFCOUNT_P(newval) > 1) {
     366           0 :                         value_copy = *newval;
     367             :                         zval_copy_ctor(&value_copy);
     368           0 :                         newval = &value_copy;
     369             :                 }
     370           0 :                 convert_to_string(newval);
     371             :         }
     372             : 
     373           4 :         handler = xmlFindCharEncodingHandler(Z_STRVAL_P(newval));
     374             : 
     375           4 :     if (handler != NULL) {
     376           3 :                 xmlCharEncCloseFunc(handler);
     377           3 :                 if (docp->encoding != NULL) {
     378           2 :                         xmlFree((xmlChar *)docp->encoding);
     379             :                 }
     380           3 :                 docp->encoding = xmlStrdup((const xmlChar *) Z_STRVAL_P(newval));
     381             :     } else {
     382           1 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid Document Encoding");
     383             :     }
     384             : 
     385           4 :         if (newval == &value_copy) {
     386             :                 zval_dtor(newval);
     387             :         }
     388             : 
     389           4 :         return SUCCESS;
     390             : }
     391             : 
     392             : /* }}} */
     393             : 
     394             : /* {{{ standalone       boolean
     395             : readonly=no
     396             : URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-Document3-standalone
     397             : Since: DOM Level 3
     398             : */
     399           4 : int dom_document_standalone_read(dom_object *obj, zval **retval TSRMLS_DC)
     400             : {
     401             :         xmlDoc *docp;
     402             :         int standalone;
     403             : 
     404           4 :         docp = (xmlDocPtr) dom_object_get_node(obj);
     405             : 
     406           4 :         if (docp == NULL) {
     407           0 :                 php_dom_throw_error(INVALID_STATE_ERR, 0 TSRMLS_CC);
     408           0 :                 return FAILURE;
     409             :         }
     410             : 
     411           4 :         ALLOC_ZVAL(*retval);
     412           4 :         standalone = docp->standalone;
     413           4 :         ZVAL_BOOL(*retval, standalone);
     414             : 
     415           4 :         return SUCCESS;
     416             : }
     417             : 
     418           1 : int dom_document_standalone_write(dom_object *obj, zval *newval TSRMLS_DC)
     419             : {
     420             :         zval value_copy;
     421             :         xmlDoc *docp;
     422             :         int standalone;
     423             : 
     424           1 :         docp = (xmlDocPtr) dom_object_get_node(obj);
     425             : 
     426           1 :         if (docp == NULL) {
     427           0 :                 php_dom_throw_error(INVALID_STATE_ERR, 0 TSRMLS_CC);
     428           0 :                 return FAILURE;
     429             :         }
     430             : 
     431           1 :         if(Z_REFCOUNT_P(newval) > 1) {
     432           0 :                 value_copy = *newval;
     433             :                 zval_copy_ctor(&value_copy);
     434           0 :                 newval = &value_copy;
     435             :         }
     436           1 :         convert_to_long(newval);
     437             : 
     438           1 :         standalone = Z_LVAL_P(newval);
     439           1 :     if (standalone > 0) {
     440           0 :         docp->standalone = 1;
     441             :     }
     442           1 :     else if (standalone < 0) {
     443           0 :         docp->standalone = -1;
     444             :     }
     445             :     else {
     446           1 :         docp->standalone = 0;
     447             :     }
     448             : 
     449           1 :         if (newval == &value_copy) {
     450             :                 zval_dtor(newval);
     451             :         }
     452             : 
     453           1 :         return SUCCESS;
     454             : }
     455             : 
     456             : /* }}} */
     457             : 
     458             : /* {{{ version  string
     459             : readonly=no
     460             : URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-Document3-version
     461             : Since: DOM Level 3
     462             : */
     463           2 : int dom_document_version_read(dom_object *obj, zval **retval TSRMLS_DC)
     464             : {
     465             :         xmlDoc *docp;
     466             :         char *version;
     467             : 
     468           2 :         docp = (xmlDocPtr) dom_object_get_node(obj);
     469             : 
     470           2 :         if (docp == NULL) {
     471           0 :                 php_dom_throw_error(INVALID_STATE_ERR, 0 TSRMLS_CC);
     472           0 :                 return FAILURE;
     473             :         }
     474             : 
     475           2 :         version = (char *) docp->version;
     476           2 :         ALLOC_ZVAL(*retval);
     477             : 
     478           2 :         if (version != NULL) {
     479           2 :                 ZVAL_STRING(*retval, version, 1);
     480             :         } else {
     481           0 :                 ZVAL_NULL(*retval);
     482             :         }
     483             : 
     484           2 :         return SUCCESS;
     485             : }
     486             : 
     487           0 : int dom_document_version_write(dom_object *obj, zval *newval TSRMLS_DC)
     488             : {
     489             :         zval value_copy;
     490             :         xmlDoc *docp;
     491             : 
     492           0 :         docp = (xmlDocPtr) dom_object_get_node(obj);
     493             : 
     494           0 :         if (docp == NULL) {
     495           0 :                 php_dom_throw_error(INVALID_STATE_ERR, 0 TSRMLS_CC);
     496           0 :                 return FAILURE;
     497             :         }
     498             : 
     499           0 :         if (docp->version != NULL) {
     500           0 :                 xmlFree((xmlChar *) docp->version );
     501             :         }
     502             : 
     503           0 :         if (newval->type != IS_STRING) {
     504           0 :                 if(Z_REFCOUNT_P(newval) > 1) {
     505           0 :                         value_copy = *newval;
     506             :                         zval_copy_ctor(&value_copy);
     507           0 :                         newval = &value_copy;
     508             :                 }
     509           0 :                 convert_to_string(newval);
     510             :         }
     511             : 
     512           0 :         docp->version = xmlStrdup((const xmlChar *) Z_STRVAL_P(newval));
     513             : 
     514           0 :         if (newval == &value_copy) {
     515             :                 zval_dtor(newval);
     516             :         }
     517             : 
     518           0 :         return SUCCESS;
     519             : }
     520             : 
     521             : /* }}} */
     522             : 
     523             : /* {{{ strictErrorChecking      boolean
     524             : readonly=no
     525             : URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-Document3-strictErrorChecking
     526             : Since: DOM Level 3
     527             : */
     528           5 : int dom_document_strict_error_checking_read(dom_object *obj, zval **retval TSRMLS_DC)
     529             : {
     530             :         dom_doc_propsptr doc_prop;
     531             : 
     532           5 :         ALLOC_ZVAL(*retval);
     533           5 :         if (obj->document) {
     534           5 :                 doc_prop = dom_get_doc_props(obj->document);
     535           5 :                 ZVAL_BOOL(*retval, doc_prop->stricterror);
     536             :         } else {
     537           0 :                 ZVAL_FALSE(*retval);
     538             :         }
     539           5 :         return SUCCESS;
     540             : }
     541             : 
     542           2 : int dom_document_strict_error_checking_write(dom_object *obj, zval *newval TSRMLS_DC)
     543             : {
     544             :         zval value_copy;
     545             :         dom_doc_propsptr doc_prop;
     546             : 
     547           2 :         if(Z_REFCOUNT_P(newval) > 1) {
     548           0 :                 value_copy = *newval;
     549             :                 zval_copy_ctor(&value_copy);
     550           0 :                 newval = &value_copy;
     551             :         }
     552           2 :         convert_to_boolean(newval);
     553             : 
     554           2 :         if (obj->document) {
     555           2 :                 doc_prop = dom_get_doc_props(obj->document);
     556           2 :                 doc_prop->stricterror = Z_LVAL_P(newval);
     557             :         }
     558             : 
     559           2 :         if (newval == &value_copy) {
     560             :                 zval_dtor(newval);
     561             :         }
     562             : 
     563           2 :         return SUCCESS;
     564             : }
     565             : 
     566             : /* }}} */
     567             : 
     568             : /* {{{ formatOutput     boolean
     569             : readonly=no
     570             : */
     571           3 : int dom_document_format_output_read(dom_object *obj, zval **retval TSRMLS_DC)
     572             : {
     573             :         dom_doc_propsptr doc_prop;
     574             : 
     575           3 :         ALLOC_ZVAL(*retval);
     576           3 :         if (obj->document) {
     577           3 :                 doc_prop = dom_get_doc_props(obj->document);
     578           3 :                 ZVAL_BOOL(*retval, doc_prop->formatoutput);
     579             :         } else {
     580           0 :                 ZVAL_FALSE(*retval);
     581             :         }
     582           3 :         return SUCCESS;
     583             : }
     584             : 
     585           4 : int dom_document_format_output_write(dom_object *obj, zval *newval TSRMLS_DC)
     586             : {
     587             :         zval value_copy;
     588             :         dom_doc_propsptr doc_prop;
     589             : 
     590           4 :         if(Z_REFCOUNT_P(newval) > 1) {
     591           0 :                 value_copy = *newval;
     592             :                 zval_copy_ctor(&value_copy);
     593           0 :                 newval = &value_copy;
     594             :         }
     595           4 :         convert_to_boolean(newval);
     596             : 
     597           4 :         if (obj->document) {
     598           4 :                 doc_prop = dom_get_doc_props(obj->document);
     599           4 :                 doc_prop->formatoutput = Z_LVAL_P(newval);
     600             :         }
     601             : 
     602           4 :         if (newval == &value_copy) {
     603             :                 zval_dtor(newval);
     604             :         }
     605             : 
     606           4 :         return SUCCESS;
     607             : }
     608             : /* }}} */
     609             : 
     610             : /* {{{ validateOnParse  boolean
     611             : readonly=no
     612             : */
     613           4 : int     dom_document_validate_on_parse_read(dom_object *obj, zval **retval TSRMLS_DC)
     614             : {
     615             :         dom_doc_propsptr doc_prop;
     616             : 
     617           4 :         ALLOC_ZVAL(*retval);
     618           4 :         if (obj->document) {
     619           4 :                 doc_prop = dom_get_doc_props(obj->document);
     620           4 :                 ZVAL_BOOL(*retval, doc_prop->validateonparse);
     621             :         } else {
     622           0 :                 ZVAL_FALSE(*retval);
     623             :         }
     624           4 :         return SUCCESS;
     625             : }
     626             : 
     627           4 : int dom_document_validate_on_parse_write(dom_object *obj, zval *newval TSRMLS_DC)
     628             : {
     629             :         zval value_copy;
     630             :         dom_doc_propsptr doc_prop;
     631             : 
     632           4 :         if(Z_REFCOUNT_P(newval) > 1) {
     633           0 :                 value_copy = *newval;
     634             :                 zval_copy_ctor(&value_copy);
     635           0 :                 newval = &value_copy;
     636             :         }
     637           4 :         convert_to_boolean(newval);
     638             : 
     639           4 :         if (obj->document) {
     640           4 :                 doc_prop = dom_get_doc_props(obj->document);
     641           4 :                 doc_prop->validateonparse = Z_LVAL_P(newval);
     642             :         }
     643             : 
     644           4 :         if (newval == &value_copy) {
     645             :                 zval_dtor(newval);
     646             :         }
     647             : 
     648           4 :         return SUCCESS;
     649             : }
     650             : /* }}} */
     651             : 
     652             : /* {{{ resolveExternals boolean
     653             : readonly=no
     654             : */
     655           3 : int dom_document_resolve_externals_read(dom_object *obj, zval **retval TSRMLS_DC)
     656             : {
     657             :         dom_doc_propsptr doc_prop;
     658             : 
     659           3 :         ALLOC_ZVAL(*retval);
     660           3 :         if (obj->document) {
     661           3 :                 doc_prop = dom_get_doc_props(obj->document);
     662           3 :                 ZVAL_BOOL(*retval, doc_prop->resolveexternals);
     663             :         } else {
     664           0 :                 ZVAL_FALSE(*retval);
     665             :         }
     666           3 :         return SUCCESS;
     667             : }
     668             : 
     669           5 : int dom_document_resolve_externals_write(dom_object *obj, zval *newval TSRMLS_DC)
     670             : {
     671             :         zval value_copy;
     672             :         dom_doc_propsptr doc_prop;
     673             : 
     674           5 :         if(Z_REFCOUNT_P(newval) > 1) {
     675           0 :                 value_copy = *newval;
     676             :                 zval_copy_ctor(&value_copy);
     677           0 :                 newval = &value_copy;
     678             :         }
     679           5 :         convert_to_boolean(newval);
     680             : 
     681           5 :         if (obj->document) {
     682           5 :                 doc_prop = dom_get_doc_props(obj->document);
     683           5 :                 doc_prop->resolveexternals = Z_LVAL_P(newval);
     684             :         }
     685             : 
     686           5 :         if (newval == &value_copy) {
     687             :                 zval_dtor(newval);
     688             :         }
     689             : 
     690           5 :         return SUCCESS;
     691             : }
     692             : /* }}} */
     693             : 
     694             : /* {{{ preserveWhiteSpace       boolean
     695             : readonly=no
     696             : */
     697           3 : int dom_document_preserve_whitespace_read(dom_object *obj, zval **retval TSRMLS_DC)
     698             : {
     699             :         dom_doc_propsptr doc_prop;
     700             : 
     701           3 :         ALLOC_ZVAL(*retval);
     702           3 :         if (obj->document) {
     703           3 :                 doc_prop = dom_get_doc_props(obj->document);
     704           3 :                 ZVAL_BOOL(*retval, doc_prop->preservewhitespace);
     705             :         } else {
     706           0 :                 ZVAL_FALSE(*retval);
     707             :         }
     708           3 :         return SUCCESS;
     709             : }
     710             : 
     711           3 : int dom_document_preserve_whitespace_write(dom_object *obj, zval *newval TSRMLS_DC)
     712             : {
     713             :         zval value_copy;
     714             :         dom_doc_propsptr doc_prop;
     715             : 
     716           3 :         if(Z_REFCOUNT_P(newval) > 1) {
     717           0 :                 value_copy = *newval;
     718             :                 zval_copy_ctor(&value_copy);
     719           0 :                 newval = &value_copy;
     720             :         }
     721           3 :         convert_to_boolean(newval);
     722             : 
     723           3 :         if (obj->document) {
     724           3 :                 doc_prop = dom_get_doc_props(obj->document);
     725           3 :                 doc_prop->preservewhitespace = Z_LVAL_P(newval);
     726             :         }
     727             : 
     728           3 :         if (newval == &value_copy) {
     729             :                 zval_dtor(newval);
     730             :         }
     731             : 
     732           3 :         return SUCCESS;
     733             : }
     734             : /* }}} */
     735             : 
     736             : /* {{{ recover  boolean
     737             : readonly=no
     738             : */
     739           1 : int dom_document_recover_read(dom_object *obj, zval **retval TSRMLS_DC)
     740             : {
     741             :         dom_doc_propsptr doc_prop;
     742             : 
     743           1 :         ALLOC_ZVAL(*retval);
     744           1 :         if (obj->document) {
     745           1 :                 doc_prop = dom_get_doc_props(obj->document);
     746           1 :                 ZVAL_BOOL(*retval, doc_prop->recover);
     747             :         } else {
     748           0 :                 ZVAL_FALSE(*retval);
     749             :         }
     750           1 :         return SUCCESS;
     751             : }
     752             : 
     753           0 : int dom_document_recover_write(dom_object *obj, zval *newval TSRMLS_DC)
     754             : {
     755             :         zval value_copy;
     756             :         dom_doc_propsptr doc_prop;
     757             : 
     758           0 :         if(Z_REFCOUNT_P(newval) > 1) {
     759           0 :                 value_copy = *newval;
     760             :                 zval_copy_ctor(&value_copy);
     761           0 :                 newval = &value_copy;
     762             :         }
     763           0 :         convert_to_boolean(newval);
     764             : 
     765           0 :         if (obj->document) {
     766           0 :                 doc_prop = dom_get_doc_props(obj->document);
     767           0 :                 doc_prop->recover = Z_LVAL_P(newval);
     768             :         }
     769             : 
     770           0 :         if (newval == &value_copy) {
     771             :                 zval_dtor(newval);
     772             :         }
     773             : 
     774           0 :         return SUCCESS;
     775             : }
     776             : /* }}} */
     777             : 
     778             : /* {{{ substituteEntities       boolean
     779             : readonly=no
     780             : */
     781           1 : int dom_document_substitue_entities_read(dom_object *obj, zval **retval TSRMLS_DC)
     782             : {
     783             :         dom_doc_propsptr doc_prop;
     784             : 
     785           1 :         ALLOC_ZVAL(*retval);
     786           1 :         if (obj->document) {
     787           1 :                 doc_prop = dom_get_doc_props(obj->document);
     788           1 :                 ZVAL_BOOL(*retval, doc_prop->substituteentities);
     789             :         } else {
     790           0 :                 ZVAL_FALSE(*retval);
     791             :         }
     792           1 :         return SUCCESS;
     793             : }
     794             : 
     795           7 : int dom_document_substitue_entities_write(dom_object *obj, zval *newval TSRMLS_DC)
     796             : {
     797             :         zval value_copy;
     798             :         dom_doc_propsptr doc_prop;
     799             : 
     800           7 :         if(Z_REFCOUNT_P(newval) > 1) {
     801           0 :                 value_copy = *newval;
     802             :                 zval_copy_ctor(&value_copy);
     803           0 :                 newval = &value_copy;
     804             :         }
     805           7 :         convert_to_boolean(newval);
     806             : 
     807           7 :         if (obj->document) {
     808           7 :                 doc_prop = dom_get_doc_props(obj->document);
     809           7 :                 doc_prop->substituteentities = Z_LVAL_P(newval);
     810             :         }
     811             : 
     812           7 :         if (newval == &value_copy) {
     813             :                 zval_dtor(newval);
     814             :         }
     815             : 
     816           7 :         return SUCCESS;
     817             : }
     818             : /* }}} */
     819             : 
     820             : /* {{{ documentURI      string
     821             : readonly=no
     822             : URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-Document3-documentURI
     823             : Since: DOM Level 3
     824             : */
     825           3 : int dom_document_document_uri_read(dom_object *obj, zval **retval TSRMLS_DC)
     826             : {
     827             :         xmlDoc *docp;
     828             :         char *url;
     829             : 
     830           3 :         docp = (xmlDocPtr) dom_object_get_node(obj);
     831             : 
     832           3 :         if (docp == NULL) {
     833           0 :                 php_dom_throw_error(INVALID_STATE_ERR, 0 TSRMLS_CC);
     834           0 :                 return FAILURE;
     835             :         }
     836             : 
     837           3 :         ALLOC_ZVAL(*retval);
     838           3 :         url = (char *) docp->URL;
     839           3 :         if (url != NULL) {
     840           3 :                 ZVAL_STRING(*retval, url, 1);
     841             :         } else {
     842           0 :                 ZVAL_NULL(*retval);
     843             :         }
     844             : 
     845           3 :         return SUCCESS;
     846             : }
     847             : 
     848           1 : int dom_document_document_uri_write(dom_object *obj, zval *newval TSRMLS_DC)
     849             : {
     850             :         zval value_copy;
     851             :         xmlDoc *docp;
     852             : 
     853           1 :         docp = (xmlDocPtr) dom_object_get_node(obj);
     854             : 
     855           1 :         if (docp == NULL) {
     856           0 :                 php_dom_throw_error(INVALID_STATE_ERR, 0 TSRMLS_CC);
     857           0 :                 return FAILURE;
     858             :         }
     859             : 
     860           1 :         if (docp->URL != NULL) {
     861           1 :                 xmlFree((xmlChar *) docp->URL);
     862             :         }
     863             : 
     864           1 :         if (newval->type != IS_STRING) {
     865           0 :                 if(Z_REFCOUNT_P(newval) > 1) {
     866           0 :                         value_copy = *newval;
     867             :                         zval_copy_ctor(&value_copy);
     868           0 :                         newval = &value_copy;
     869             :                 }
     870           0 :                 convert_to_string(newval);
     871             :         }
     872             : 
     873           1 :         docp->URL = xmlStrdup((const xmlChar *) Z_STRVAL_P(newval));
     874             : 
     875           1 :         if (newval == &value_copy) {
     876             :                 zval_dtor(newval);
     877             :         }
     878             : 
     879           1 :         return SUCCESS;
     880             : }
     881             : 
     882             : /* }}} */
     883             : 
     884             : /* {{{ config   DOMConfiguration
     885             : readonly=yes
     886             : URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-Document3-config
     887             : Since: DOM Level 3
     888             : */
     889           2 : int dom_document_config_read(dom_object *obj, zval **retval TSRMLS_DC)
     890             : {
     891           2 :         ALLOC_ZVAL(*retval);
     892           2 :         ZVAL_NULL(*retval);
     893           2 :         return SUCCESS;
     894             : }
     895             : 
     896             : /* }}} */
     897             : 
     898             : /* {{{ proto DOMElement dom_document_create_element(string tagName [, string value]);
     899             : URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-2141741547
     900             : Since:
     901             : */
     902          79 : PHP_FUNCTION(dom_document_create_element)
     903             : {
     904             :         zval *id;
     905             :         xmlNode *node;
     906             :         xmlDocPtr docp;
     907             :         dom_object *intern;
     908             :         int ret, name_len, value_len;
     909          79 :         char *name, *value = NULL;
     910             : 
     911          79 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Os|s", &id, dom_document_class_entry, &name, &name_len, &value, &value_len) == FAILURE) {
     912           0 :                 return;
     913             :         }
     914             : 
     915          79 :         DOM_GET_OBJ(docp, id, xmlDocPtr, intern);
     916             : 
     917          79 :         if (xmlValidateName((xmlChar *) name, 0) != 0) {
     918           2 :                 php_dom_throw_error(INVALID_CHARACTER_ERR, dom_get_strict_error(intern->document) TSRMLS_CC);
     919           2 :                 RETURN_FALSE;
     920             :         }
     921             : 
     922          77 :         node = xmlNewDocNode(docp, NULL, name, value);
     923          77 :         if (!node) {
     924           0 :                 RETURN_FALSE;
     925             :         }
     926             : 
     927          77 :         DOM_RET_OBJ(node, &ret, intern);
     928             : }
     929             : /* }}} end dom_document_create_element */
     930             : 
     931             : /* {{{ proto DOMDocumentFragment dom_document_create_document_fragment();
     932             : URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-35CB04B5
     933             : Since:
     934             : */
     935           9 : PHP_FUNCTION(dom_document_create_document_fragment)
     936             : {
     937             :         zval *id;
     938             :         xmlNode *node;
     939             :         xmlDocPtr docp;
     940             :         dom_object *intern;
     941             :         int ret;
     942             : 
     943           9 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &id, dom_document_class_entry) == FAILURE) {
     944           0 :                 return;
     945             :         }
     946             : 
     947           9 :         DOM_GET_OBJ(docp, id, xmlDocPtr, intern);
     948             : 
     949           9 :         node =  xmlNewDocFragment(docp);
     950           9 :         if (!node) {
     951           0 :                 RETURN_FALSE;
     952             :         }
     953             : 
     954           9 :         DOM_RET_OBJ(node, &ret, intern);
     955             : }
     956             : /* }}} end dom_document_create_document_fragment */
     957             : 
     958             : /* {{{ proto DOMText dom_document_create_text_node(string data);
     959             : URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-1975348127
     960             : Since:
     961             : */
     962          27 : PHP_FUNCTION(dom_document_create_text_node)
     963             : {
     964             :         zval *id;
     965             :         xmlNode *node;
     966             :         xmlDocPtr docp;
     967             :         int ret, value_len;
     968             :         dom_object *intern;
     969             :         char *value;
     970             : 
     971          27 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Os", &id, dom_document_class_entry, &value, &value_len) == FAILURE) {
     972           0 :                 return;
     973             :         }
     974             : 
     975          27 :         DOM_GET_OBJ(docp, id, xmlDocPtr, intern);
     976             : 
     977          27 :         node = xmlNewDocText(docp, (xmlChar *) value);
     978          27 :         if (!node) {
     979           0 :                 RETURN_FALSE;
     980             :         }
     981             : 
     982          27 :         DOM_RET_OBJ(node, &ret, intern);
     983             : }
     984             : /* }}} end dom_document_create_text_node */
     985             : 
     986             : /* {{{ proto DOMComment dom_document_create_comment(string data);
     987             : URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-1334481328
     988             : Since:
     989             : */
     990          10 : PHP_FUNCTION(dom_document_create_comment)
     991             : {
     992             :         zval *id;
     993             :         xmlNode *node;
     994             :         xmlDocPtr docp;
     995             :         int ret, value_len;
     996             :         dom_object *intern;
     997             :         char *value;
     998             : 
     999          10 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Os", &id, dom_document_class_entry, &value, &value_len) == FAILURE) {
    1000           1 :                 return;
    1001             :         }
    1002             : 
    1003           9 :         DOM_GET_OBJ(docp, id, xmlDocPtr, intern);
    1004             : 
    1005           9 :         node = xmlNewDocComment(docp, (xmlChar *) value);
    1006           9 :         if (!node) {
    1007           0 :                 RETURN_FALSE;
    1008             :         }
    1009             : 
    1010           9 :         DOM_RET_OBJ(node, &ret, intern);
    1011             : }
    1012             : /* }}} end dom_document_create_comment */
    1013             : 
    1014             : /* {{{ proto DOMCdataSection dom_document_create_cdatasection(string data);
    1015             : URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-D26C0AF8
    1016             : Since:
    1017             : */
    1018           9 : PHP_FUNCTION(dom_document_create_cdatasection)
    1019             : {
    1020             :         zval *id;
    1021             :         xmlNode *node;
    1022             :         xmlDocPtr docp;
    1023             :         int ret, value_len;
    1024             :         dom_object *intern;
    1025             :         char *value;
    1026             : 
    1027           9 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Os", &id, dom_document_class_entry, &value, &value_len) == FAILURE) {
    1028           0 :                 return;
    1029             :         }
    1030             : 
    1031           9 :         DOM_GET_OBJ(docp, id, xmlDocPtr, intern);
    1032             : 
    1033           9 :         node = xmlNewCDataBlock(docp, (xmlChar *) value, value_len);
    1034           9 :         if (!node) {
    1035           0 :                 RETURN_FALSE;
    1036             :         }
    1037             : 
    1038           9 :         DOM_RET_OBJ(node, &ret, intern);
    1039             : }
    1040             : /* }}} end dom_document_create_cdatasection */
    1041             : 
    1042             : /* {{{ proto DOMProcessingInstruction dom_document_create_processing_instruction(string target, string data);
    1043             : URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-135944439
    1044             : Since:
    1045             : */
    1046           3 : PHP_FUNCTION(dom_document_create_processing_instruction)
    1047             : {
    1048             :         zval *id;
    1049             :         xmlNode *node;
    1050             :         xmlDocPtr docp;
    1051           3 :         int ret, value_len, name_len = 0;
    1052             :         dom_object *intern;
    1053           3 :         char *name, *value = NULL;
    1054             : 
    1055           3 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Os|s", &id, dom_document_class_entry, &name, &name_len, &value, &value_len) == FAILURE) {
    1056           0 :                 return;
    1057             :         }
    1058             : 
    1059           3 :         DOM_GET_OBJ(docp, id, xmlDocPtr, intern);
    1060             : 
    1061           3 :         if (xmlValidateName((xmlChar *) name, 0) != 0) {
    1062           1 :                 php_dom_throw_error(INVALID_CHARACTER_ERR, dom_get_strict_error(intern->document) TSRMLS_CC);
    1063           1 :                 RETURN_FALSE;
    1064             :         }
    1065             : 
    1066           2 :         node = xmlNewPI((xmlChar *) name, (xmlChar *) value);
    1067           2 :         if (!node) {
    1068           0 :                 RETURN_FALSE;
    1069             :         }
    1070             : 
    1071           2 :         node->doc = docp;
    1072             : 
    1073           2 :         DOM_RET_OBJ(node, &ret, intern);
    1074             : }
    1075             : /* }}} end dom_document_create_processing_instruction */
    1076             : 
    1077             : /* {{{ proto DOMAttr dom_document_create_attribute(string name);
    1078             : URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-1084891198
    1079             : Since:
    1080             : */
    1081           6 : PHP_FUNCTION(dom_document_create_attribute)
    1082             : {
    1083             :         zval *id;
    1084             :         xmlAttrPtr node;
    1085             :         xmlDocPtr docp;
    1086             :         int ret, name_len;
    1087             :         dom_object *intern;
    1088             :         char *name;
    1089             : 
    1090           6 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Os", &id, dom_document_class_entry, &name, &name_len) == FAILURE) {
    1091           0 :                 return;
    1092             :         }
    1093             : 
    1094           6 :         DOM_GET_OBJ(docp, id, xmlDocPtr, intern);
    1095             : 
    1096           6 :         if (xmlValidateName((xmlChar *) name, 0) != 0) {
    1097           4 :                 php_dom_throw_error(INVALID_CHARACTER_ERR, dom_get_strict_error(intern->document) TSRMLS_CC);
    1098           4 :                 RETURN_FALSE;
    1099             :         }
    1100             : 
    1101           2 :         node = xmlNewDocProp(docp, (xmlChar *) name, NULL);
    1102           2 :         if (!node) {
    1103           0 :                 RETURN_FALSE;
    1104             :         }
    1105             : 
    1106           2 :         DOM_RET_OBJ((xmlNodePtr) node, &ret, intern);
    1107             : 
    1108             : }
    1109             : /* }}} end dom_document_create_attribute */
    1110             : 
    1111             : /* {{{ proto DOMEntityReference dom_document_create_entity_reference(string name);
    1112             : URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-392B75AE
    1113             : Since:
    1114             : */
    1115           3 : PHP_FUNCTION(dom_document_create_entity_reference)
    1116             : {
    1117             :         zval *id;
    1118             :         xmlNode *node;
    1119           3 :         xmlDocPtr docp = NULL;
    1120             :         dom_object *intern;
    1121             :         int ret, name_len;
    1122             :         char *name;
    1123             : 
    1124           3 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Os", &id, dom_document_class_entry, &name, &name_len) == FAILURE) {
    1125           1 :                 return;
    1126             :         }
    1127             : 
    1128           2 :         DOM_GET_OBJ(docp, id, xmlDocPtr, intern);
    1129             : 
    1130           2 :         if (xmlValidateName((xmlChar *) name, 0) != 0) {
    1131           0 :                 php_dom_throw_error(INVALID_CHARACTER_ERR, dom_get_strict_error(intern->document) TSRMLS_CC);
    1132           0 :                 RETURN_FALSE;
    1133             :         }
    1134             : 
    1135           2 :         node = xmlNewReference(docp, name);
    1136           2 :         if (!node) {
    1137           0 :                 RETURN_FALSE;
    1138             :         }
    1139             : 
    1140           2 :         DOM_RET_OBJ((xmlNodePtr) node, &ret, intern);
    1141             : }
    1142             : /* }}} end dom_document_create_entity_reference */
    1143             : 
    1144             : /* {{{ proto DOMNodeList dom_document_get_elements_by_tag_name(string tagname);
    1145             : URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-A6C9094
    1146             : Since:
    1147             : */
    1148          24 : PHP_FUNCTION(dom_document_get_elements_by_tag_name)
    1149             : {
    1150             :         zval *id;
    1151             :         xmlDocPtr docp;
    1152             :         int name_len;
    1153             :         dom_object *intern, *namednode;
    1154             :         char *name;
    1155             :         xmlChar *local;
    1156             : 
    1157          24 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Os", &id, dom_document_class_entry, &name, &name_len) == FAILURE) {
    1158           0 :                 return;
    1159             :         }
    1160             : 
    1161          24 :         DOM_GET_OBJ(docp, id, xmlDocPtr, intern);
    1162             : 
    1163          24 :         php_dom_create_interator(return_value, DOM_NODELIST TSRMLS_CC);
    1164          24 :         namednode = (dom_object *)zend_objects_get_address(return_value TSRMLS_CC);
    1165          24 :         local = xmlCharStrndup(name, name_len);
    1166          24 :         dom_namednode_iter(intern, 0, namednode, NULL, local, NULL TSRMLS_CC);
    1167             : }
    1168             : /* }}} end dom_document_get_elements_by_tag_name */
    1169             : 
    1170             : /* {{{ proto DOMNode dom_document_import_node(DOMNode importedNode, boolean deep);
    1171             : URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#Core-Document-importNode
    1172             : Since: DOM Level 2
    1173             : */
    1174           5 : PHP_FUNCTION(dom_document_import_node)
    1175             : {
    1176             :         zval *id, *node;
    1177             :         xmlDocPtr docp;
    1178             :         xmlNodePtr nodep, retnodep;
    1179             :         dom_object *intern, *nodeobj;
    1180             :         int ret;
    1181           5 :         long recursive = 0;
    1182             : 
    1183           5 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "OO|l", &id, dom_document_class_entry, &node, dom_node_class_entry, &recursive) == FAILURE) {
    1184           0 :                 return;
    1185             :         }
    1186             : 
    1187           5 :         DOM_GET_OBJ(docp, id, xmlDocPtr, intern);
    1188             : 
    1189           5 :         DOM_GET_OBJ(nodep, node, xmlNodePtr, nodeobj);
    1190             : 
    1191          15 :         if (nodep->type == XML_HTML_DOCUMENT_NODE || nodep->type == XML_DOCUMENT_NODE
    1192          10 :                 || nodep->type == XML_DOCUMENT_TYPE_NODE) {
    1193           0 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot import: Node Type Not Supported");
    1194           0 :                 RETURN_FALSE;
    1195             :         }
    1196             : 
    1197           5 :         if (nodep->doc == docp) {
    1198           0 :                 retnodep = nodep;
    1199             :         } else {
    1200           5 :                 if ((recursive == 0) && (nodep->type == XML_ELEMENT_NODE)) {
    1201           1 :                         recursive = 2;
    1202             :                 }
    1203           5 :                 retnodep = xmlDocCopyNode(nodep, docp, recursive);
    1204           5 :                 if (!retnodep) {
    1205           0 :                         RETURN_FALSE;
    1206             :                 }
    1207             : 
    1208           5 :                 if ((retnodep->type == XML_ATTRIBUTE_NODE) && (nodep->ns != NULL)) {
    1209           2 :                         xmlNsPtr nsptr = NULL;
    1210           2 :                         xmlNodePtr root = xmlDocGetRootElement(docp);
    1211             : 
    1212           2 :                         nsptr = xmlSearchNsByHref (nodep->doc, root, nodep->ns->href);
    1213           2 :                         if (nsptr == NULL) {
    1214             :                                 int errorcode;
    1215           1 :                                 nsptr = dom_get_ns(root, (char *) nodep->ns->href, &errorcode, (char *) nodep->ns->prefix);
    1216             :                         }
    1217           2 :                         xmlSetNs(retnodep, nsptr);
    1218             :                 }
    1219             :         }
    1220             : 
    1221           5 :         DOM_RET_OBJ((xmlNodePtr) retnodep, &ret, intern);
    1222             : }
    1223             : /* }}} end dom_document_import_node */
    1224             : 
    1225             : /* {{{ proto DOMElement dom_document_create_element_ns(string namespaceURI, string qualifiedName [,string value]);
    1226             : URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-DocCrElNS
    1227             : Since: DOM Level 2
    1228             : */
    1229          21 : PHP_FUNCTION(dom_document_create_element_ns)
    1230             : {
    1231             :         zval *id;
    1232             :         xmlDocPtr docp;
    1233          21 :         xmlNodePtr nodep = NULL;
    1234          21 :         xmlNsPtr nsptr = NULL;
    1235          21 :         int ret, uri_len = 0, name_len = 0, value_len = 0;
    1236          21 :         char *uri, *name, *value = NULL;
    1237          21 :         char *localname = NULL, *prefix = NULL;
    1238             :         int errorcode;
    1239             :         dom_object *intern;
    1240             : 
    1241          21 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Os!s|s", &id, dom_document_class_entry, &uri, &uri_len, &name, &name_len, &value, &value_len) == FAILURE) {
    1242           0 :                 return;
    1243             :         }
    1244             : 
    1245          21 :         DOM_GET_OBJ(docp, id, xmlDocPtr, intern);
    1246             : 
    1247          21 :         errorcode = dom_check_qname(name, &localname, &prefix, uri_len, name_len);
    1248             : 
    1249          21 :         if (errorcode == 0) {
    1250          15 :                 if (xmlValidateName((xmlChar *) localname, 0) == 0) {
    1251          15 :                         nodep = xmlNewDocNode (docp, NULL, localname, value);
    1252          15 :                         if (nodep != NULL && uri != NULL) {
    1253          15 :                                 nsptr = xmlSearchNsByHref (nodep->doc, nodep, uri);
    1254          15 :                                 if (nsptr == NULL) {
    1255          14 :                                         nsptr = dom_get_ns(nodep, uri, &errorcode, prefix);
    1256             :                                 }
    1257          15 :                                 xmlSetNs(nodep, nsptr);
    1258             :                         }
    1259             :                 } else {
    1260           0 :                         errorcode = INVALID_CHARACTER_ERR;
    1261             :                 }
    1262             :         }
    1263             : 
    1264          21 :         xmlFree(localname);
    1265          21 :         if (prefix != NULL) {
    1266          15 :                 xmlFree(prefix);
    1267             :         }
    1268             : 
    1269          21 :         if (errorcode != 0) {
    1270           9 :                 if (nodep != NULL) {
    1271           3 :                         xmlFreeNode(nodep);
    1272             :                 }
    1273           9 :                 php_dom_throw_error(errorcode, dom_get_strict_error(intern->document) TSRMLS_CC);
    1274           9 :                 RETURN_FALSE;
    1275             :         }
    1276             : 
    1277          12 :         if (nodep == NULL) {
    1278           0 :                 RETURN_FALSE;
    1279             :         }
    1280             : 
    1281             : 
    1282          12 :         nodep->ns = nsptr;
    1283             : 
    1284          12 :         DOM_RET_OBJ(nodep, &ret, intern);
    1285             : }
    1286             : /* }}} end dom_document_create_element_ns */
    1287             : 
    1288             : /* {{{ proto DOMAttr dom_document_create_attribute_ns(string namespaceURI, string qualifiedName);
    1289             : URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-DocCrAttrNS
    1290             : Since: DOM Level 2
    1291             : */
    1292           1 : PHP_FUNCTION(dom_document_create_attribute_ns)
    1293             : {
    1294             :         zval *id;
    1295             :         xmlDocPtr docp;
    1296           1 :         xmlNodePtr nodep = NULL, root;
    1297             :         xmlNsPtr nsptr;
    1298           1 :         int ret, uri_len = 0, name_len = 0;
    1299             :         char *uri, *name;
    1300           1 :         char *localname = NULL, *prefix = NULL;
    1301             :         dom_object *intern;
    1302             :         int errorcode;
    1303             : 
    1304           1 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Os!s", &id, dom_document_class_entry, &uri, &uri_len, &name, &name_len) == FAILURE) {
    1305           0 :                 return;
    1306             :         }
    1307             : 
    1308           1 :         DOM_GET_OBJ(docp, id, xmlDocPtr, intern);
    1309             : 
    1310           1 :         root = xmlDocGetRootElement(docp);
    1311           1 :         if (root != NULL) {
    1312           1 :                 errorcode = dom_check_qname(name, &localname, &prefix, uri_len, name_len);
    1313           1 :                 if (errorcode == 0) {
    1314           1 :                         if (xmlValidateName((xmlChar *) localname, 0) == 0) {
    1315           1 :                                 nodep = (xmlNodePtr) xmlNewDocProp(docp, localname, NULL);
    1316           1 :                                 if (nodep != NULL && uri_len > 0) {
    1317           1 :                                         nsptr = xmlSearchNsByHref (nodep->doc, root, uri);
    1318           1 :                                         if (nsptr == NULL) {
    1319           0 :                                                 nsptr = dom_get_ns(root, uri, &errorcode, prefix);
    1320             :                                         }
    1321           1 :                                         xmlSetNs(nodep, nsptr);
    1322             :                                 }
    1323             :                         } else {
    1324           0 :                                 errorcode = INVALID_CHARACTER_ERR;
    1325             :                         }
    1326             :                 }
    1327             :         } else {
    1328           0 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Document Missing Root Element");
    1329           0 :                 RETURN_FALSE;
    1330             :         }
    1331             : 
    1332           1 :         xmlFree(localname);
    1333           1 :         if (prefix != NULL) {
    1334           1 :                 xmlFree(prefix);
    1335             :         }
    1336             : 
    1337           1 :         if (errorcode != 0) {
    1338           0 :                 if (nodep != NULL) {
    1339           0 :                         xmlFreeProp((xmlAttrPtr) nodep);
    1340             :                 }
    1341           0 :                 php_dom_throw_error(errorcode, dom_get_strict_error(intern->document) TSRMLS_CC);
    1342           0 :                 RETURN_FALSE;
    1343             :         }
    1344             : 
    1345           1 :         if (nodep == NULL) {
    1346           0 :                 RETURN_FALSE;
    1347             :         }
    1348             : 
    1349           1 :         DOM_RET_OBJ(nodep, &ret, intern);
    1350             : }
    1351             : /* }}} end dom_document_create_attribute_ns */
    1352             : 
    1353             : /* {{{ proto DOMNodeList dom_document_get_elements_by_tag_name_ns(string namespaceURI, string localName);
    1354             : URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-getElBTNNS
    1355             : Since: DOM Level 2
    1356             : */
    1357           2 : PHP_FUNCTION(dom_document_get_elements_by_tag_name_ns)
    1358             : {
    1359             :         zval *id;
    1360             :         xmlDocPtr docp;
    1361             :         int uri_len, name_len;
    1362             :         dom_object *intern, *namednode;
    1363             :         char *uri, *name;
    1364             :         xmlChar *local, *nsuri;
    1365             : 
    1366           2 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Oss", &id, dom_document_class_entry, &uri, &uri_len, &name, &name_len) == FAILURE) {
    1367           0 :                 return;
    1368             :         }
    1369             : 
    1370           2 :         DOM_GET_OBJ(docp, id, xmlDocPtr, intern);
    1371             : 
    1372           2 :         php_dom_create_interator(return_value, DOM_NODELIST TSRMLS_CC);
    1373           2 :         namednode = (dom_object *)zend_objects_get_address(return_value TSRMLS_CC);
    1374           2 :         local = xmlCharStrndup(name, name_len);
    1375           2 :         nsuri = xmlCharStrndup(uri, uri_len);
    1376           2 :         dom_namednode_iter(intern, 0, namednode, NULL, local, nsuri TSRMLS_CC);
    1377             : }
    1378             : /* }}} end dom_document_get_elements_by_tag_name_ns */
    1379             : 
    1380             : /* {{{ proto DOMElement dom_document_get_element_by_id(string elementId);
    1381             : URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-getElBId
    1382             : Since: DOM Level 2
    1383             : */
    1384           6 : PHP_FUNCTION(dom_document_get_element_by_id)
    1385             : {
    1386             :         zval *id;
    1387             :         xmlDocPtr docp;
    1388             :         xmlAttrPtr  attrp;
    1389             :         int ret, idname_len;
    1390             :         dom_object *intern;
    1391             :         char *idname;
    1392             : 
    1393           6 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Os", &id, dom_document_class_entry, &idname, &idname_len) == FAILURE) {
    1394           0 :                 return;
    1395             :         }
    1396             : 
    1397           6 :         DOM_GET_OBJ(docp, id, xmlDocPtr, intern);
    1398             : 
    1399           6 :         attrp = xmlGetID(docp, (xmlChar *) idname);
    1400             : 
    1401           9 :         if (attrp && attrp->parent) {
    1402           3 :                 DOM_RET_OBJ((xmlNodePtr) attrp->parent, &ret, intern);
    1403             :         } else {
    1404           3 :                 RETVAL_NULL();
    1405             :         }
    1406             : 
    1407             : }
    1408             : /* }}} end dom_document_get_element_by_id */
    1409             : 
    1410             : /* {{{ proto DOMNode dom_document_adopt_node(DOMNode source);
    1411             : URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-Document3-adoptNode
    1412             : Since: DOM Level 3
    1413             : */
    1414           0 : PHP_FUNCTION(dom_document_adopt_node)
    1415             : {
    1416           0 :  DOM_NOT_IMPLEMENTED();
    1417             : }
    1418             : /* }}} end dom_document_adopt_node */
    1419             : 
    1420             : /* {{{ proto void dom_document_normalize_document();
    1421             : URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-Document3-normalizeDocument
    1422             : Since: DOM Level 3
    1423             : */
    1424           0 : PHP_FUNCTION(dom_document_normalize_document)
    1425             : {
    1426             :         zval *id;
    1427             :         xmlDocPtr docp;
    1428             :         dom_object *intern;
    1429             : 
    1430           0 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &id, dom_document_class_entry) == FAILURE) {
    1431           0 :                 return;
    1432             :         }
    1433             : 
    1434           0 :         DOM_GET_OBJ(docp, id, xmlDocPtr, intern);
    1435             : 
    1436           0 :         dom_normalize((xmlNodePtr) docp TSRMLS_CC);
    1437             : }
    1438             : /* }}} end dom_document_normalize_document */
    1439             : 
    1440             : /* {{{ proto DOMNode dom_document_rename_node(node n, string namespaceURI, string qualifiedName);
    1441             : URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-Document3-renameNode
    1442             : Since: DOM Level 3
    1443             : */
    1444           0 : PHP_FUNCTION(dom_document_rename_node)
    1445             : {
    1446           0 :  DOM_NOT_IMPLEMENTED();
    1447             : }
    1448             : /* }}} end dom_document_rename_node */
    1449             : 
    1450             : /* {{{ proto void DOMDocument::__construct([string version], [string encoding]); */
    1451         290 : PHP_METHOD(domdocument, __construct)
    1452             : {
    1453             : 
    1454             :         zval *id;
    1455         290 :         xmlDoc *docp = NULL, *olddoc;
    1456             :         dom_object *intern;
    1457         290 :         char *encoding, *version = NULL;
    1458         290 :         int encoding_len = 0, version_len = 0, refcount;
    1459             :         zend_error_handling error_handling;
    1460             : 
    1461         290 :         zend_replace_error_handling(EH_THROW, dom_domexception_class_entry, &error_handling TSRMLS_CC);
    1462         290 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O|ss", &id, dom_document_class_entry, &version, &version_len, &encoding, &encoding_len) == FAILURE) {
    1463           0 :                 zend_restore_error_handling(&error_handling TSRMLS_CC);
    1464           0 :                 return;
    1465             :         }
    1466             : 
    1467         290 :         zend_restore_error_handling(&error_handling TSRMLS_CC);
    1468         290 :         docp = xmlNewDoc(version);
    1469             : 
    1470         290 :         if (!docp) {
    1471           0 :                 php_dom_throw_error(INVALID_STATE_ERR, 1 TSRMLS_CC);
    1472           0 :                 RETURN_FALSE;
    1473             :         }
    1474             : 
    1475         290 :         if (encoding_len > 0) {
    1476           6 :                 docp->encoding = (const xmlChar*)xmlStrdup(encoding);
    1477             :         }
    1478             : 
    1479         290 :         intern = (dom_object *)zend_object_store_get_object(id TSRMLS_CC);
    1480         290 :         if (intern != NULL) {
    1481         290 :                 olddoc = (xmlDocPtr) dom_object_get_node(intern);
    1482         290 :                 if (olddoc != NULL) {
    1483           0 :                         php_libxml_decrement_node_ptr((php_libxml_node_object *) intern TSRMLS_CC);
    1484           0 :                         refcount = php_libxml_decrement_doc_ref((php_libxml_node_object *)intern TSRMLS_CC);
    1485           0 :                         if (refcount != 0) {
    1486           0 :                                 olddoc->_private = NULL;
    1487             :                         }
    1488             :                 }
    1489         290 :                 intern->document = NULL;
    1490         290 :                 if (php_libxml_increment_doc_ref((php_libxml_node_object *)intern, docp TSRMLS_CC) == -1) {
    1491           0 :                         RETURN_FALSE;
    1492             :                 }
    1493         290 :                 php_libxml_increment_node_ptr((php_libxml_node_object *)intern, (xmlNodePtr)docp, (void *)intern TSRMLS_CC);
    1494             :         }
    1495             : }
    1496             : /* }}} end DOMDocument::__construct */
    1497             : 
    1498         134 : char *_dom_get_valid_file_path(char *source, char *resolved_path, int resolved_path_len  TSRMLS_DC) /* {{{ */
    1499             : {
    1500             :         xmlURI *uri;
    1501             :         xmlChar *escsource;
    1502             :         char *file_dest;
    1503         134 :         int isFileUri = 0;
    1504             : 
    1505         134 :         uri = xmlCreateURI();
    1506         134 :         escsource = xmlURIEscapeStr(source, ":");
    1507         134 :         xmlParseURIReference(uri, escsource);
    1508         134 :         xmlFree(escsource);
    1509             : 
    1510         134 :         if (uri->scheme != NULL) {
    1511             :                 /* absolute file uris - libxml only supports localhost or empty host */
    1512             : #ifdef PHP_WIN32
    1513             :                 if (strncasecmp(source, "file://",7) == 0 && ':' == source[8]) {
    1514             :                         isFileUri = 1;
    1515             :                         source += 7;
    1516             :                 } else
    1517             : #endif
    1518           4 :                 if (strncasecmp(source, "file:///",8) == 0) {
    1519           2 :                         isFileUri = 1;
    1520             : #ifdef PHP_WIN32
    1521             :                         source += 8;
    1522             : #else
    1523           2 :                         source += 7;
    1524             : #endif
    1525           2 :                 } else if (strncasecmp(source, "file://localhost/",17) == 0) {
    1526           0 :                         isFileUri = 1;
    1527             : #ifdef PHP_WIN32
    1528             :                         source += 17;
    1529             : #else
    1530           0 :                         source += 16;
    1531             : #endif
    1532             :                 }
    1533             :         }
    1534             : 
    1535         134 :         file_dest = source;
    1536             : 
    1537         134 :         if ((uri->scheme == NULL || isFileUri)) {
    1538             :                 /* XXX possible buffer overflow if VCWD_REALPATH does not know size of resolved_path */
    1539         132 :                 if (!VCWD_REALPATH(source, resolved_path) && !expand_filepath(source, resolved_path TSRMLS_CC)) {
    1540           0 :                         xmlFreeURI(uri);
    1541           0 :                         return NULL;
    1542             :                 }
    1543         132 :                 file_dest = resolved_path;
    1544             :         }
    1545             : 
    1546         134 :         xmlFreeURI(uri);
    1547             : 
    1548         134 :         return file_dest;
    1549             : }
    1550             : /* }}} */
    1551             : 
    1552         207 : static xmlDocPtr dom_document_parser(zval *id, int mode, char *source, int source_len, int options TSRMLS_DC) /* {{{ */
    1553             : {
    1554             :     xmlDocPtr ret;
    1555         207 :     xmlParserCtxtPtr ctxt = NULL;
    1556             :         dom_doc_propsptr doc_props;
    1557             :         dom_object *intern;
    1558         207 :         php_libxml_ref_obj *document = NULL;
    1559             :         int validate, recover, resolve_externals, keep_blanks, substitute_ent;
    1560             :         int resolved_path_len;
    1561         207 :         int old_error_reporting = 0;
    1562         207 :         char *directory=NULL, resolved_path[MAXPATHLEN];
    1563             : 
    1564         207 :         if (id != NULL) {
    1565         207 :                 intern = (dom_object *)zend_object_store_get_object(id TSRMLS_CC);
    1566         207 :                 document = intern->document;
    1567             :         }
    1568             : 
    1569         207 :         doc_props = dom_get_doc_props(document);
    1570         207 :         validate = doc_props->validateonparse;
    1571         207 :         resolve_externals = doc_props->resolveexternals;
    1572         207 :         keep_blanks = doc_props->preservewhitespace;
    1573         207 :         substitute_ent = doc_props->substituteentities;
    1574         207 :         recover = doc_props->recover;
    1575             : 
    1576         207 :         if (document == NULL) {
    1577           0 :                 efree(doc_props);
    1578             :         }
    1579             : 
    1580         207 :         xmlInitParser();
    1581             : 
    1582         207 :         if (mode == DOM_LOAD_FILE) {
    1583             :                 char *file_dest;
    1584         127 :                 if (CHECK_NULL_PATH(source, source_len)) {
    1585           0 :                         return NULL;
    1586             :                 }
    1587         127 :                 file_dest = _dom_get_valid_file_path(source, resolved_path, MAXPATHLEN  TSRMLS_CC);
    1588         127 :                 if (file_dest) {
    1589         127 :                         ctxt = xmlCreateFileParserCtxt(file_dest);
    1590             :                 }
    1591             : 
    1592             :         } else {
    1593          80 :                 ctxt = xmlCreateMemoryParserCtxt(source, source_len);
    1594             :         }
    1595             : 
    1596         207 :         if (ctxt == NULL) {
    1597           0 :                 return(NULL);
    1598             :         }
    1599             : 
    1600             :         /* If loading from memory, we need to set the base directory for the document */
    1601         207 :         if (mode != DOM_LOAD_FILE) {
    1602             : #if HAVE_GETCWD
    1603          80 :                 directory = VCWD_GETCWD(resolved_path, MAXPATHLEN);
    1604             : #elif HAVE_GETWD
    1605             :                 directory = VCWD_GETWD(resolved_path);
    1606             : #endif
    1607          80 :                 if (directory) {
    1608          80 :                         if(ctxt->directory != NULL) {
    1609           0 :                                 xmlFree((char *) ctxt->directory);
    1610             :                         }
    1611          80 :                         resolved_path_len = strlen(resolved_path);
    1612          80 :                         if (resolved_path[resolved_path_len - 1] != DEFAULT_SLASH) {
    1613          80 :                                 resolved_path[resolved_path_len] = DEFAULT_SLASH;
    1614          80 :                                 resolved_path[++resolved_path_len] = '\0';
    1615             :                         }
    1616          80 :                         ctxt->directory = (char *) xmlCanonicPath((const xmlChar *) resolved_path);
    1617             :                 }
    1618             :         }
    1619             : 
    1620         207 :         ctxt->vctxt.error = php_libxml_ctx_error;
    1621         207 :         ctxt->vctxt.warning = php_libxml_ctx_warning;
    1622             : 
    1623         207 :         if (ctxt->sax != NULL) {
    1624         207 :                 ctxt->sax->error = php_libxml_ctx_error;
    1625         207 :                 ctxt->sax->warning = php_libxml_ctx_warning;
    1626             :         }
    1627             : 
    1628         207 :         if (validate && ! (options & XML_PARSE_DTDVALID)) {
    1629           1 :                 options |= XML_PARSE_DTDVALID;
    1630             :         }
    1631         207 :         if (resolve_externals && ! (options & XML_PARSE_DTDATTR)) {
    1632           5 :                 options |= XML_PARSE_DTDATTR;
    1633             :         }
    1634         207 :         if (substitute_ent && ! (options & XML_PARSE_NOENT)) {
    1635           7 :                 options |= XML_PARSE_NOENT;
    1636             :         }
    1637         207 :         if (keep_blanks == 0 && ! (options & XML_PARSE_NOBLANKS)) {
    1638           2 :                 options |= XML_PARSE_NOBLANKS;
    1639             :         }
    1640             : 
    1641         207 :         xmlCtxtUseOptions(ctxt, options);
    1642             : 
    1643         207 :         ctxt->recovery = recover;
    1644         207 :         if (recover) {
    1645           0 :                 old_error_reporting = EG(error_reporting);
    1646           0 :                 EG(error_reporting) = old_error_reporting | E_WARNING;
    1647             :         }
    1648             : 
    1649         207 :         xmlParseDocument(ctxt);
    1650             : 
    1651         413 :         if (ctxt->wellFormed || recover) {
    1652         206 :                 ret = ctxt->myDoc;
    1653         206 :                 if (ctxt->recovery) {
    1654           0 :                         EG(error_reporting) = old_error_reporting;
    1655             :                 }
    1656             :                 /* If loading from memory, set the base reference uri for the document */
    1657         206 :                 if (ret && ret->URL == NULL && ctxt->directory != NULL) {
    1658          79 :                         ret->URL = xmlStrdup(ctxt->directory);
    1659             :                 }
    1660             :         } else {
    1661           1 :                 ret = NULL;
    1662           1 :                 xmlFreeDoc(ctxt->myDoc);
    1663           1 :                 ctxt->myDoc = NULL;
    1664             :         }
    1665             : 
    1666         207 :         xmlFreeParserCtxt(ctxt);
    1667             : 
    1668         207 :         return(ret);
    1669             : }
    1670             : /* }}} */
    1671             : 
    1672             : /* {{{ static void dom_parse_document(INTERNAL_FUNCTION_PARAMETERS, int mode) */
    1673         207 : static void dom_parse_document(INTERNAL_FUNCTION_PARAMETERS, int mode) {
    1674             :         zval *id;
    1675         207 :         xmlDoc *docp = NULL, *newdoc;
    1676             :         dom_doc_propsptr doc_prop;
    1677             :         dom_object *intern;
    1678             :         char *source;
    1679             :         int source_len, refcount, ret;
    1680         207 :         long options = 0;
    1681             : 
    1682         207 :         id = getThis();
    1683         207 :         if (id != NULL && ! instanceof_function(Z_OBJCE_P(id), dom_document_class_entry TSRMLS_CC)) {
    1684           0 :                 id = NULL;
    1685             :         }
    1686             : 
    1687         207 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &source, &source_len, &options) == FAILURE) {
    1688           0 :                 return;
    1689             :         }
    1690             : 
    1691         207 :         if (!source_len) {
    1692           0 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Empty string supplied as input");
    1693           0 :                 RETURN_FALSE;
    1694             :         }
    1695             : 
    1696         207 :         newdoc = dom_document_parser(id, mode, source, source_len, options TSRMLS_CC);
    1697             : 
    1698         207 :         if (!newdoc)
    1699           1 :                 RETURN_FALSE;
    1700             : 
    1701         206 :         if (id != NULL) {
    1702         206 :                 intern = (dom_object *)zend_object_store_get_object(id TSRMLS_CC);
    1703         206 :                 if (intern != NULL) {
    1704         206 :                         docp = (xmlDocPtr) dom_object_get_node(intern);
    1705         206 :                         doc_prop = NULL;
    1706         206 :                         if (docp != NULL) {
    1707         206 :                                 php_libxml_decrement_node_ptr((php_libxml_node_object *) intern TSRMLS_CC);
    1708         206 :                                 doc_prop = intern->document->doc_props;
    1709         206 :                                 intern->document->doc_props = NULL;
    1710         206 :                                 refcount = php_libxml_decrement_doc_ref((php_libxml_node_object *)intern TSRMLS_CC);
    1711         206 :                                 if (refcount != 0) {
    1712           3 :                                         docp->_private = NULL;
    1713             :                                 }
    1714             :                         }
    1715         206 :                         intern->document = NULL;
    1716         206 :                         if (php_libxml_increment_doc_ref((php_libxml_node_object *)intern, newdoc TSRMLS_CC) == -1) {
    1717           0 :                                 RETURN_FALSE;
    1718             :                         }
    1719         206 :                         intern->document->doc_props = doc_prop;
    1720             :                 }
    1721             : 
    1722         206 :                 php_libxml_increment_node_ptr((php_libxml_node_object *)intern, (xmlNodePtr)newdoc, (void *)intern TSRMLS_CC);
    1723             : 
    1724         206 :                 RETURN_TRUE;
    1725             :         } else {
    1726           0 :                 DOM_RET_OBJ((xmlNodePtr) newdoc, &ret, NULL);
    1727             :         }
    1728             : }
    1729             : /* }}} end dom_parser_document */
    1730             : 
    1731             : /* {{{ proto DOMNode dom_document_load(string source [, int options]);
    1732             : URL: http://www.w3.org/TR/DOM-Level-3-LS/load-save.html#LS-DocumentLS-load
    1733             : Since: DOM Level 3
    1734             : */
    1735         127 : PHP_METHOD(domdocument, load)
    1736             : {
    1737         127 :         dom_parse_document(INTERNAL_FUNCTION_PARAM_PASSTHRU, DOM_LOAD_FILE);
    1738         127 : }
    1739             : /* }}} end dom_document_load */
    1740             : 
    1741             : /* {{{ proto DOMNode dom_document_loadxml(string source [, int options]);
    1742             : URL: http://www.w3.org/TR/DOM-Level-3-LS/load-save.html#LS-DocumentLS-loadXML
    1743             : Since: DOM Level 3
    1744             : */
    1745          80 : PHP_METHOD(domdocument, loadXML)
    1746             : {
    1747          80 :         dom_parse_document(INTERNAL_FUNCTION_PARAM_PASSTHRU, DOM_LOAD_STRING);
    1748          80 : }
    1749             : /* }}} end dom_document_loadxml */
    1750             : 
    1751             : /* {{{ proto int dom_document_save(string file);
    1752             : Convenience method to save to file
    1753             : */
    1754           3 : PHP_FUNCTION(dom_document_save)
    1755             : {
    1756             :         zval *id;
    1757             :         xmlDoc *docp;
    1758           3 :         int file_len = 0, bytes, format, saveempty = 0;
    1759             :         dom_object *intern;
    1760             :         dom_doc_propsptr doc_props;
    1761             :         char *file;
    1762           3 :         long options = 0;
    1763             : 
    1764           3 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Os|l", &id, dom_document_class_entry, &file, &file_len, &options) == FAILURE) {
    1765           0 :                 return;
    1766             :         }
    1767             : 
    1768           3 :         if (file_len == 0) {
    1769           0 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid Filename");
    1770           0 :                 RETURN_FALSE;
    1771             :         }
    1772             : 
    1773           3 :         DOM_GET_OBJ(docp, id, xmlDocPtr, intern);
    1774             : 
    1775             :         /* encoding handled by property on doc */
    1776             : 
    1777           3 :         doc_props = dom_get_doc_props(intern->document);
    1778           3 :         format = doc_props->formatoutput;
    1779           3 :         if (options & LIBXML_SAVE_NOEMPTYTAG) {
    1780           0 :                 saveempty = xmlSaveNoEmptyTags;
    1781           0 :                 xmlSaveNoEmptyTags = 1;
    1782             :         }
    1783           3 :         bytes = xmlSaveFormatFileEnc(file, docp, NULL, format);
    1784           3 :         if (options & LIBXML_SAVE_NOEMPTYTAG) {
    1785           0 :                 xmlSaveNoEmptyTags = saveempty;
    1786             :         }
    1787           3 :         if (bytes == -1) {
    1788           1 :                 RETURN_FALSE;
    1789             :         }
    1790           2 :         RETURN_LONG(bytes);
    1791             : }
    1792             : /* }}} end dom_document_save */
    1793             : 
    1794             : /* {{{ proto string dom_document_savexml([node n]);
    1795             : URL: http://www.w3.org/TR/DOM-Level-3-LS/load-save.html#LS-DocumentLS-saveXML
    1796             : Since: DOM Level 3
    1797             : */
    1798          52 : PHP_FUNCTION(dom_document_savexml)
    1799             : {
    1800          52 :         zval *id, *nodep = NULL;
    1801             :         xmlDoc *docp;
    1802             :         xmlNode *node;
    1803             :         xmlBufferPtr buf;
    1804             :         xmlChar *mem;
    1805             :         dom_object *intern, *nodeobj;
    1806             :         dom_doc_propsptr doc_props;
    1807          52 :         int size, format, saveempty = 0;
    1808          52 :         long options = 0;
    1809             : 
    1810          52 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O|O!l", &id, dom_document_class_entry, &nodep, dom_node_class_entry, &options) == FAILURE) {
    1811           0 :                 return;
    1812             :         }
    1813             : 
    1814          52 :         DOM_GET_OBJ(docp, id, xmlDocPtr, intern);
    1815             : 
    1816          52 :         doc_props = dom_get_doc_props(intern->document);
    1817          52 :         format = doc_props->formatoutput;
    1818             : 
    1819          52 :         if (nodep != NULL) {
    1820             :                 /* Dump contents of Node */
    1821           3 :                 DOM_GET_OBJ(node, nodep, xmlNodePtr, nodeobj);
    1822           3 :                 if (node->doc != docp) {
    1823           0 :                         php_dom_throw_error(WRONG_DOCUMENT_ERR, dom_get_strict_error(intern->document) TSRMLS_CC);
    1824           0 :                         RETURN_FALSE;
    1825             :                 }
    1826           3 :                 buf = xmlBufferCreate();
    1827           3 :                 if (!buf) {
    1828           0 :                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not fetch buffer");
    1829           0 :                         RETURN_FALSE;
    1830             :                 }
    1831           3 :                 if (options & LIBXML_SAVE_NOEMPTYTAG) {
    1832           0 :                         saveempty = xmlSaveNoEmptyTags;
    1833           0 :                         xmlSaveNoEmptyTags = 1;
    1834             :                 }
    1835           3 :                 xmlNodeDump(buf, docp, node, 0, format);
    1836           3 :                 if (options & LIBXML_SAVE_NOEMPTYTAG) {
    1837           0 :                         xmlSaveNoEmptyTags = saveempty;
    1838             :                 }
    1839           3 :                 mem = (xmlChar*) xmlBufferContent(buf);
    1840           3 :                 if (!mem) {
    1841           0 :                         xmlBufferFree(buf);
    1842           0 :                         RETURN_FALSE;
    1843             :                 }
    1844           3 :                 RETVAL_STRING(mem, 1);
    1845           3 :                 xmlBufferFree(buf);
    1846             :         } else {
    1847          49 :                 if (options & LIBXML_SAVE_NOEMPTYTAG) {
    1848           0 :                         saveempty = xmlSaveNoEmptyTags;
    1849           0 :                         xmlSaveNoEmptyTags = 1;
    1850             :                 }
    1851             :                 /* Encoding is handled from the encoding property set on the document */
    1852          49 :                 xmlDocDumpFormatMemory(docp, &mem, &size, format);
    1853          49 :                 if (options & LIBXML_SAVE_NOEMPTYTAG) {
    1854           0 :                         xmlSaveNoEmptyTags = saveempty;
    1855             :                 }
    1856          49 :                 if (!size) {
    1857           0 :                         RETURN_FALSE;
    1858             :                 }
    1859          49 :                 RETVAL_STRINGL(mem, size, 1);
    1860          49 :                 xmlFree(mem);
    1861             :         }
    1862             : }
    1863             : /* }}} end dom_document_savexml */
    1864             : 
    1865           8 : static xmlNodePtr php_dom_free_xinclude_node(xmlNodePtr cur TSRMLS_DC) /* {{{ */
    1866             : {
    1867             :         xmlNodePtr xincnode;
    1868             : 
    1869           8 :         xincnode = cur;
    1870           8 :         cur = cur->next;
    1871           8 :         xmlUnlinkNode(xincnode);
    1872           8 :         php_libxml_node_free_resource(xincnode TSRMLS_CC);
    1873             : 
    1874           8 :         return cur;
    1875             : }
    1876             : /* }}} */
    1877             : 
    1878          22 : static void php_dom_remove_xinclude_nodes(xmlNodePtr cur TSRMLS_DC) /* {{{ */
    1879             : {
    1880          94 :         while(cur) {
    1881          50 :                 if (cur->type == XML_XINCLUDE_START) {
    1882           4 :                         cur = php_dom_free_xinclude_node(cur TSRMLS_CC);
    1883             : 
    1884             :                         /* XML_XINCLUDE_END node will be a sibling of XML_XINCLUDE_START */
    1885          13 :                         while(cur && cur->type != XML_XINCLUDE_END) {
    1886             :                                 /* remove xinclude processing nodes from recursive xincludes */
    1887           5 :                                 if (cur->type == XML_ELEMENT_NODE) {
    1888           5 :                                            php_dom_remove_xinclude_nodes(cur->children TSRMLS_CC);
    1889             :                                 }
    1890           5 :                                 cur = cur->next;
    1891             :                         }
    1892             : 
    1893           4 :                         if (cur && cur->type == XML_XINCLUDE_END) {
    1894           4 :                                 cur = php_dom_free_xinclude_node(cur TSRMLS_CC);
    1895             :                         }
    1896             :                 } else {
    1897          46 :                         if (cur->type == XML_ELEMENT_NODE) {
    1898          15 :                                 php_dom_remove_xinclude_nodes(cur->children TSRMLS_CC);
    1899             :                         }
    1900          46 :                         cur = cur->next;
    1901             :                 }
    1902             :         }
    1903          22 : }
    1904             : /* }}} */
    1905             : 
    1906             : /* {{{ proto int dom_document_xinclude([int options])
    1907             :    Substitutues xincludes in a DomDocument */
    1908           2 : PHP_FUNCTION(dom_document_xinclude)
    1909             : {
    1910             :         zval *id;
    1911             :         xmlDoc *docp;
    1912             :         xmlNodePtr root;
    1913           2 :         long flags = 0;
    1914             :         int err;
    1915             :         dom_object *intern;
    1916             : 
    1917           2 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O|l", &id, dom_document_class_entry, &flags) == FAILURE) {
    1918           0 :                 return;
    1919             :         }
    1920             : 
    1921           2 :         DOM_GET_OBJ(docp, id, xmlDocPtr, intern);
    1922             : 
    1923           2 :         err = xmlXIncludeProcessFlags(docp, flags);
    1924             : 
    1925             :         /* XML_XINCLUDE_START and XML_XINCLUDE_END nodes need to be removed as these
    1926             :         are added via xmlXIncludeProcess to mark beginning and ending of xincluded document
    1927             :         but are not wanted in resulting document - must be done even if err as it could fail after
    1928             :         having processed some xincludes */
    1929           2 :         root = (xmlNodePtr) docp->children;
    1930           4 :         while(root && root->type != XML_ELEMENT_NODE && root->type != XML_XINCLUDE_START) {
    1931           0 :                 root = root->next;
    1932             :         }
    1933           2 :         if (root) {
    1934           2 :                 php_dom_remove_xinclude_nodes(root TSRMLS_CC);
    1935             :         }
    1936             : 
    1937           2 :         if (err) {
    1938           2 :                 RETVAL_LONG(err);
    1939             :         } else {
    1940           0 :                 RETVAL_FALSE;
    1941             :         }
    1942             : 
    1943             : }
    1944             : /* }}} */
    1945             : 
    1946             : /* {{{ proto boolean dom_document_validate();
    1947             : Since: DOM extended
    1948             : */
    1949           8 : PHP_FUNCTION(dom_document_validate)
    1950             : {
    1951             :         zval *id;
    1952             :         xmlDoc *docp;
    1953             :         dom_object *intern;
    1954             :         xmlValidCtxt *cvp;
    1955             : 
    1956           8 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &id, dom_document_class_entry) == FAILURE) {
    1957           1 :                 return;
    1958             :         }
    1959             : 
    1960           7 :         DOM_GET_OBJ(docp, id, xmlDocPtr, intern);
    1961             : 
    1962           7 :         cvp = xmlNewValidCtxt();
    1963             : 
    1964           7 :         cvp->userData = NULL;
    1965           7 :         cvp->error    = (xmlValidityErrorFunc) php_libxml_error_handler;
    1966           7 :         cvp->warning  = (xmlValidityErrorFunc) php_libxml_error_handler;
    1967             : 
    1968           7 :         if (xmlValidateDocument(cvp, docp)) {
    1969           5 :                 RETVAL_TRUE;
    1970             :         } else {
    1971           2 :                 RETVAL_FALSE;
    1972             :         }
    1973             : 
    1974           7 :         xmlFreeValidCtxt(cvp);
    1975             : 
    1976             : }
    1977             : /* }}} */
    1978             : 
    1979             : #if defined(LIBXML_SCHEMAS_ENABLED)
    1980          11 : static void _dom_document_schema_validate(INTERNAL_FUNCTION_PARAMETERS, int type) /* {{{ */
    1981             : {
    1982             :         zval *id;
    1983             :         xmlDoc *docp;
    1984             :         dom_object *intern;
    1985          11 :         char *source = NULL, *valid_file = NULL;
    1986          11 :         int source_len = 0;
    1987             :         xmlSchemaParserCtxtPtr  parser;
    1988             :         xmlSchemaPtr            sptr;
    1989             :         xmlSchemaValidCtxtPtr   vptr;
    1990             :         int                     is_valid;
    1991             :         char resolved_path[MAXPATHLEN + 1];
    1992             : 
    1993          11 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Op", &id, dom_document_class_entry, &source, &source_len) == FAILURE) {
    1994           2 :                 return;
    1995             :         }
    1996             : 
    1997           9 :         if (source_len == 0) {
    1998           2 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid Schema source");
    1999           2 :                 RETURN_FALSE;
    2000             :         }
    2001             : 
    2002           7 :         DOM_GET_OBJ(docp, id, xmlDocPtr, intern);
    2003             : 
    2004           7 :         switch (type) {
    2005             :         case DOM_LOAD_FILE:
    2006           4 :                 valid_file = _dom_get_valid_file_path(source, resolved_path, MAXPATHLEN  TSRMLS_CC);
    2007           4 :                 if (!valid_file) {
    2008           0 :                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid Schema file source");
    2009           0 :                         RETURN_FALSE;
    2010             :                 }
    2011           4 :                 parser = xmlSchemaNewParserCtxt(valid_file);
    2012           4 :                 break;
    2013             :         case DOM_LOAD_STRING:
    2014           3 :                 parser = xmlSchemaNewMemParserCtxt(source, source_len);
    2015             :                 /* If loading from memory, we need to set the base directory for the document
    2016             :                    but it is not apparent how to do that for schema's */
    2017           3 :                 break;
    2018             :         default:
    2019           0 :                 return;
    2020             :         }
    2021             : 
    2022           7 :         xmlSchemaSetParserErrors(parser,
    2023             :                 (xmlSchemaValidityErrorFunc) php_libxml_error_handler,
    2024             :                 (xmlSchemaValidityWarningFunc) php_libxml_error_handler,
    2025             :                 parser);
    2026           7 :         sptr = xmlSchemaParse(parser);
    2027           7 :         xmlSchemaFreeParserCtxt(parser);
    2028           7 :         if (!sptr) {
    2029           3 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid Schema");
    2030           3 :                 RETURN_FALSE;
    2031             :         }
    2032             : 
    2033           4 :         docp = (xmlDocPtr) dom_object_get_node(intern);
    2034             : 
    2035           4 :         vptr = xmlSchemaNewValidCtxt(sptr);
    2036           4 :         if (!vptr) {
    2037           0 :                 xmlSchemaFree(sptr);
    2038           0 :                 php_error(E_ERROR, "Invalid Schema Validation Context");
    2039           0 :                 RETURN_FALSE;
    2040             :         }
    2041             : 
    2042           4 :         xmlSchemaSetValidErrors(vptr, php_libxml_error_handler, php_libxml_error_handler, vptr);
    2043           4 :         is_valid = xmlSchemaValidateDoc(vptr, docp);
    2044           4 :         xmlSchemaFree(sptr);
    2045           4 :         xmlSchemaFreeValidCtxt(vptr);
    2046             : 
    2047           4 :         if (is_valid == 0) {
    2048           2 :                 RETURN_TRUE;
    2049             :         } else {
    2050           2 :                 RETURN_FALSE;
    2051             :         }
    2052             : }
    2053             : /* }}} */
    2054             : 
    2055             : /* {{{ proto boolean dom_document_schema_validate_file(string filename); */
    2056           6 : PHP_FUNCTION(dom_document_schema_validate_file)
    2057             : {
    2058           6 :         _dom_document_schema_validate(INTERNAL_FUNCTION_PARAM_PASSTHRU, DOM_LOAD_FILE);
    2059           6 : }
    2060             : /* }}} end dom_document_schema_validate_file */
    2061             : 
    2062             : /* {{{ proto boolean dom_document_schema_validate(string source); */
    2063           5 : PHP_FUNCTION(dom_document_schema_validate_xml)
    2064             : {
    2065           5 :         _dom_document_schema_validate(INTERNAL_FUNCTION_PARAM_PASSTHRU, DOM_LOAD_STRING);
    2066           5 : }
    2067             : /* }}} end dom_document_schema_validate */
    2068             : 
    2069           6 : static void _dom_document_relaxNG_validate(INTERNAL_FUNCTION_PARAMETERS, int type) /* {{{ */
    2070             : {
    2071             :         zval *id;
    2072             :         xmlDoc *docp;
    2073             :         dom_object *intern;
    2074           6 :         char *source = NULL, *valid_file = NULL;
    2075           6 :         int source_len = 0;
    2076             :         xmlRelaxNGParserCtxtPtr parser;
    2077             :         xmlRelaxNGPtr           sptr;
    2078             :         xmlRelaxNGValidCtxtPtr  vptr;
    2079             :         int                     is_valid;
    2080             :         char resolved_path[MAXPATHLEN + 1];
    2081             : 
    2082           6 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Op", &id, dom_document_class_entry, &source, &source_len) == FAILURE) {
    2083           0 :                 return;
    2084             :         }
    2085             : 
    2086           6 :         if (source_len == 0) {
    2087           0 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid Schema source");
    2088           0 :                 RETURN_FALSE;
    2089             :         }
    2090             : 
    2091           6 :         DOM_GET_OBJ(docp, id, xmlDocPtr, intern);
    2092             : 
    2093           6 :         switch (type) {
    2094             :         case DOM_LOAD_FILE:
    2095           3 :                 valid_file = _dom_get_valid_file_path(source, resolved_path, MAXPATHLEN  TSRMLS_CC);
    2096           3 :                 if (!valid_file) {
    2097           0 :                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid RelaxNG file source");
    2098           0 :                         RETURN_FALSE;
    2099             :                 }
    2100           3 :                 parser = xmlRelaxNGNewParserCtxt(valid_file);
    2101           3 :                 break;
    2102             :         case DOM_LOAD_STRING:
    2103           3 :                 parser = xmlRelaxNGNewMemParserCtxt(source, source_len);
    2104             :                 /* If loading from memory, we need to set the base directory for the document
    2105             :                    but it is not apparent how to do that for schema's */
    2106           3 :                 break;
    2107             :         default:
    2108           0 :                 return;
    2109             :         }
    2110             : 
    2111           6 :         xmlRelaxNGSetParserErrors(parser,
    2112             :                 (xmlRelaxNGValidityErrorFunc) php_libxml_error_handler,
    2113             :                 (xmlRelaxNGValidityWarningFunc) php_libxml_error_handler,
    2114             :                 parser);
    2115           6 :         sptr = xmlRelaxNGParse(parser);
    2116           6 :         xmlRelaxNGFreeParserCtxt(parser);
    2117           6 :         if (!sptr) {
    2118           2 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid RelaxNG");
    2119           2 :                 RETURN_FALSE;
    2120             :         }
    2121             : 
    2122           4 :         docp = (xmlDocPtr) dom_object_get_node(intern);
    2123             : 
    2124           4 :         vptr = xmlRelaxNGNewValidCtxt(sptr);
    2125           4 :         if (!vptr) {
    2126           0 :                 xmlRelaxNGFree(sptr);
    2127           0 :                 php_error(E_ERROR, "Invalid RelaxNG Validation Context");
    2128           0 :                 RETURN_FALSE;
    2129             :         }
    2130             : 
    2131           4 :         xmlRelaxNGSetValidErrors(vptr, php_libxml_error_handler, php_libxml_error_handler, vptr);
    2132           4 :         is_valid = xmlRelaxNGValidateDoc(vptr, docp);
    2133           4 :         xmlRelaxNGFree(sptr);
    2134           4 :         xmlRelaxNGFreeValidCtxt(vptr);
    2135             : 
    2136           4 :         if (is_valid == 0) {
    2137           2 :                 RETURN_TRUE;
    2138             :         } else {
    2139           2 :                 RETURN_FALSE;
    2140             :         }
    2141             : }
    2142             : /* }}} */
    2143             : 
    2144             : /* {{{ proto boolean dom_document_relaxNG_validate_file(string filename); */
    2145           3 : PHP_FUNCTION(dom_document_relaxNG_validate_file)
    2146             : {
    2147           3 :         _dom_document_relaxNG_validate(INTERNAL_FUNCTION_PARAM_PASSTHRU, DOM_LOAD_FILE);
    2148           3 : }
    2149             : /* }}} end dom_document_relaxNG_validate_file */
    2150             : 
    2151             : /* {{{ proto boolean dom_document_relaxNG_validate_xml(string source); */
    2152           3 : PHP_FUNCTION(dom_document_relaxNG_validate_xml)
    2153             : {
    2154           3 :         _dom_document_relaxNG_validate(INTERNAL_FUNCTION_PARAM_PASSTHRU, DOM_LOAD_STRING);
    2155           3 : }
    2156             : /* }}} end dom_document_relaxNG_validate_xml */
    2157             : 
    2158             : #endif
    2159             : 
    2160             : #if defined(LIBXML_HTML_ENABLED)
    2161             : 
    2162          13 : static void dom_load_html(INTERNAL_FUNCTION_PARAMETERS, int mode) /* {{{ */
    2163             : {
    2164             :         zval *id;
    2165          13 :         xmlDoc *docp = NULL, *newdoc;
    2166             :         dom_object *intern;
    2167             :         dom_doc_propsptr doc_prop;
    2168             :         char *source;
    2169             :         int source_len, refcount, ret;
    2170          13 :         long options = 0;
    2171             :         htmlParserCtxtPtr ctxt;
    2172             : 
    2173          13 :         id = getThis();
    2174             : 
    2175          13 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "p|l", &source, &source_len, &options) == FAILURE) {
    2176           2 :                 return;
    2177             :         }
    2178             : 
    2179          11 :         if (!source_len) {
    2180           2 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Empty string supplied as input");
    2181           2 :                 RETURN_FALSE;
    2182             :         }
    2183             : 
    2184           9 :         if (mode == DOM_LOAD_FILE) {
    2185           5 :                 ctxt = htmlCreateFileParserCtxt(source, NULL);
    2186             :         } else {
    2187           4 :                 source_len = xmlStrlen(source);
    2188           4 :                 ctxt = htmlCreateMemoryParserCtxt(source, source_len);
    2189             :         }
    2190             : 
    2191           9 :         if (!ctxt) {
    2192           1 :                 RETURN_FALSE;
    2193             :         }
    2194             : 
    2195           8 :         if (options) {
    2196           0 :                 htmlCtxtUseOptions(ctxt, options);
    2197             :         }
    2198             : 
    2199           8 :         ctxt->vctxt.error = php_libxml_ctx_error;
    2200           8 :         ctxt->vctxt.warning = php_libxml_ctx_warning;
    2201           8 :         if (ctxt->sax != NULL) {
    2202           8 :                 ctxt->sax->error = php_libxml_ctx_error;
    2203           8 :                 ctxt->sax->warning = php_libxml_ctx_warning;
    2204             :         }
    2205           8 :         htmlParseDocument(ctxt);
    2206           8 :         newdoc = ctxt->myDoc;
    2207           8 :         htmlFreeParserCtxt(ctxt);
    2208             : 
    2209           8 :         if (!newdoc)
    2210           0 :                 RETURN_FALSE;
    2211             : 
    2212           8 :         if (id != NULL && instanceof_function(Z_OBJCE_P(id), dom_document_class_entry TSRMLS_CC)) {
    2213           8 :                 intern = (dom_object *)zend_object_store_get_object(id TSRMLS_CC);
    2214           8 :                 if (intern != NULL) {
    2215           8 :                         docp = (xmlDocPtr) dom_object_get_node(intern);
    2216           8 :                         doc_prop = NULL;
    2217           8 :                         if (docp != NULL) {
    2218           8 :                                 php_libxml_decrement_node_ptr((php_libxml_node_object *) intern TSRMLS_CC);
    2219           8 :                                 doc_prop = intern->document->doc_props;
    2220           8 :                                 intern->document->doc_props = NULL;
    2221           8 :                                 refcount = php_libxml_decrement_doc_ref((php_libxml_node_object *)intern TSRMLS_CC);
    2222           8 :                                 if (refcount != 0) {
    2223           0 :                                         docp->_private = NULL;
    2224             :                                 }
    2225             :                         }
    2226           8 :                         intern->document = NULL;
    2227           8 :                         if (php_libxml_increment_doc_ref((php_libxml_node_object *)intern, newdoc TSRMLS_CC) == -1) {
    2228           0 :                                 RETURN_FALSE;
    2229             :                         }
    2230           8 :                         intern->document->doc_props = doc_prop;
    2231             :                 }
    2232             : 
    2233           8 :                 php_libxml_increment_node_ptr((php_libxml_node_object *)intern, (xmlNodePtr)newdoc, (void *)intern TSRMLS_CC);
    2234             : 
    2235           8 :                 RETURN_TRUE;
    2236             :         } else {
    2237           0 :                 DOM_RET_OBJ((xmlNodePtr) newdoc, &ret, NULL);
    2238             :         }
    2239             : }
    2240             : /* }}} */
    2241             : 
    2242             : /* {{{ proto DOMNode dom_document_load_html_file(string source);
    2243             : Since: DOM extended
    2244             : */
    2245           7 : PHP_METHOD(domdocument, loadHTMLFile)
    2246             : {
    2247           7 :         dom_load_html(INTERNAL_FUNCTION_PARAM_PASSTHRU, DOM_LOAD_FILE);
    2248           7 : }
    2249             : /* }}} end dom_document_load_html_file */
    2250             : 
    2251             : /* {{{ proto DOMNode dom_document_load_html(string source);
    2252             : Since: DOM extended
    2253             : */
    2254           6 : PHP_METHOD(domdocument, loadHTML)
    2255             : {
    2256           6 :         dom_load_html(INTERNAL_FUNCTION_PARAM_PASSTHRU, DOM_LOAD_STRING);
    2257           6 : }
    2258             : /* }}} end dom_document_load_html */
    2259             : 
    2260             : /* {{{ proto int dom_document_save_html_file(string file);
    2261             : Convenience method to save to file as html
    2262             : */
    2263           4 : PHP_FUNCTION(dom_document_save_html_file)
    2264             : {
    2265             :         zval *id;
    2266             :         xmlDoc *docp;
    2267             :         int file_len, bytes, format;
    2268             :         dom_object *intern;
    2269             :         dom_doc_propsptr doc_props;
    2270             :         char *file;
    2271             :         const char *encoding;
    2272             : 
    2273           4 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Os", &id, dom_document_class_entry, &file, &file_len) == FAILURE) {
    2274           1 :                 return;
    2275             :         }
    2276             : 
    2277           3 :         if (file_len == 0) {
    2278           1 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid Filename");
    2279           1 :                 RETURN_FALSE;
    2280             :         }
    2281             : 
    2282           2 :         DOM_GET_OBJ(docp, id, xmlDocPtr, intern);
    2283             : 
    2284             : 
    2285           2 :         encoding = (const char *) htmlGetMetaEncoding(docp);
    2286             : 
    2287           2 :         doc_props = dom_get_doc_props(intern->document);
    2288           2 :         format = doc_props->formatoutput;
    2289           2 :         bytes = htmlSaveFileFormat(file, docp, encoding, format);
    2290             : 
    2291           2 :         if (bytes == -1) {
    2292           0 :                 RETURN_FALSE;
    2293             :         }
    2294           2 :         RETURN_LONG(bytes);
    2295             : }
    2296             : /* }}} end dom_document_save_html_file */
    2297             : 
    2298             : /* {{{ proto string dom_document_save_html();
    2299             : Convenience method to output as html
    2300             : */
    2301          11 : PHP_FUNCTION(dom_document_save_html)
    2302             : {
    2303          11 :         zval *id, *nodep = NULL;
    2304             :         xmlDoc *docp;
    2305             :         xmlNode *node;
    2306             :         xmlBufferPtr buf;
    2307             :         dom_object *intern, *nodeobj;
    2308          11 :         xmlChar *mem = NULL;
    2309          11 :         int size = 0, format;
    2310             :         dom_doc_propsptr doc_props;
    2311             : 
    2312          11 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(),
    2313             :                 "O|O!", &id, dom_document_class_entry, &nodep, dom_node_class_entry)
    2314             :                 == FAILURE) {
    2315           0 :                 return;
    2316             :         }
    2317             : 
    2318          11 :         DOM_GET_OBJ(docp, id, xmlDocPtr, intern);
    2319             : 
    2320          11 :         doc_props = dom_get_doc_props(intern->document);
    2321          11 :         format = doc_props->formatoutput;
    2322             : 
    2323          11 :         if (nodep != NULL) {
    2324             :                 /* Dump contents of Node */
    2325           4 :                 DOM_GET_OBJ(node, nodep, xmlNodePtr, nodeobj);
    2326           4 :                 if (node->doc != docp) {
    2327           0 :                         php_dom_throw_error(WRONG_DOCUMENT_ERR, dom_get_strict_error(intern->document) TSRMLS_CC);
    2328           0 :                         RETURN_FALSE;
    2329             :                 }
    2330             : 
    2331           4 :                 buf = xmlBufferCreate();
    2332           4 :                 if (!buf) {
    2333           0 :                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not fetch buffer");
    2334           0 :                         RETURN_FALSE;
    2335             :                 }
    2336             : 
    2337           4 :                 if (node->type == XML_DOCUMENT_FRAG_NODE) {
    2338             :                         int one_size;
    2339             : 
    2340          10 :                         for (node = node->children; node; node = node->next) {
    2341           3 :                                 one_size = htmlNodeDump(buf, docp, node);
    2342             : 
    2343           3 :                                 if (one_size >= 0) {
    2344           3 :                                         size += one_size;
    2345             :                                 } else {
    2346           0 :                                         size = -1;
    2347           0 :                                         break;
    2348             :                                 }
    2349             :                         }
    2350             :                 } else {
    2351           2 :                         size = htmlNodeDump(buf, docp, node);
    2352             :                 }
    2353           4 :                 if (size >= 0) {
    2354           4 :                         mem = (xmlChar*) xmlBufferContent(buf);
    2355           4 :                         if (!mem) {
    2356           0 :                                 RETVAL_FALSE;
    2357             :                         } else {
    2358           4 :                                 RETVAL_STRINGL((const char*) mem, size, 1);
    2359             :                         }
    2360             :                 } else {
    2361           0 :                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "Error dumping HTML node");
    2362           0 :                         RETVAL_FALSE;
    2363             :                 }
    2364           4 :                 xmlBufferFree(buf);
    2365             :         } else {
    2366             : #if LIBXML_VERSION >= 20623
    2367           7 :                 htmlDocDumpMemoryFormat(docp, &mem, &size, format);
    2368             : #else
    2369             :                 htmlDocDumpMemory(docp, &mem, &size);
    2370             : #endif
    2371           7 :                 if (!size) {
    2372           0 :                         RETVAL_FALSE;
    2373             :                 } else {
    2374           7 :                         RETVAL_STRINGL((const char*) mem, size, 1);
    2375             :                 }
    2376           7 :                 if (mem)
    2377           7 :                         xmlFree(mem);
    2378             :         }
    2379             : 
    2380             : }
    2381             : /* }}} end dom_document_save_html */
    2382             : 
    2383             : #endif  /* defined(LIBXML_HTML_ENABLED) */
    2384             : 
    2385             : /* {{{ proto boolean DOMDocument::registerNodeClass(string baseclass, string extendedclass);
    2386             :    Register extended class used to create base node type */
    2387           3 : PHP_METHOD(domdocument, registerNodeClass)
    2388             : {
    2389             :         zval *id;
    2390             :         xmlDoc *docp;
    2391           3 :         char *baseclass = NULL, *extendedclass = NULL;
    2392           3 :         int baseclass_len = 0, extendedclass_len = 0;
    2393           3 :         zend_class_entry *basece = NULL, *ce = NULL;
    2394             :         dom_object *intern;
    2395             : 
    2396           3 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Oss!", &id, dom_document_class_entry, &baseclass, &baseclass_len, &extendedclass, &extendedclass_len) == FAILURE) {
    2397           0 :                 return;
    2398             :         }
    2399             : 
    2400           3 :         if (baseclass_len) {
    2401             :                 zend_class_entry **pce;
    2402           3 :                 if (zend_lookup_class(baseclass, baseclass_len, &pce TSRMLS_CC) == FAILURE) {
    2403           0 :                         php_error_docref(NULL TSRMLS_CC, E_ERROR, "Class %s does not exist", baseclass);
    2404           0 :                         return;
    2405             :                 }
    2406           3 :                 basece = *pce;
    2407             :         }
    2408             : 
    2409           3 :         if (basece == NULL || ! instanceof_function(basece, dom_node_class_entry TSRMLS_CC)) {
    2410           0 :                 php_error_docref(NULL TSRMLS_CC, E_ERROR, "Class %s is not derived from DOMNode.", baseclass);
    2411           0 :                 return;
    2412             :         }
    2413             : 
    2414           3 :         if (extendedclass_len) {
    2415             :                 zend_class_entry **pce;
    2416           2 :                 if (zend_lookup_class(extendedclass, extendedclass_len, &pce TSRMLS_CC) == FAILURE) {
    2417           0 :                         php_error_docref(NULL TSRMLS_CC, E_ERROR, "Class %s does not exist", extendedclass);
    2418             :                 }
    2419           2 :                 ce = *pce;
    2420             :         }
    2421             : 
    2422           3 :         if (ce == NULL || instanceof_function(ce, basece TSRMLS_CC)) {
    2423             : 
    2424           3 :                 DOM_GET_OBJ(docp, id, xmlDocPtr, intern);
    2425             : 
    2426           3 :                 if (dom_set_doc_classmap(intern->document, basece, ce TSRMLS_CC) == FAILURE) {
    2427           0 :                         php_error_docref(NULL TSRMLS_CC, E_ERROR, "Class %s could not be registered.", extendedclass);
    2428             :                 }
    2429           3 :                 RETURN_TRUE;
    2430             :         } else {
    2431           0 :                 php_error_docref(NULL TSRMLS_CC, E_ERROR, "Class %s is not derived from %s.", extendedclass, baseclass);
    2432             :         }
    2433             : 
    2434           0 :         RETURN_FALSE;
    2435             : }
    2436             : /* }}} */
    2437             : 
    2438             : #endif  /* HAVE_LIBXML && HAVE_DOM */
    2439             : 
    2440             : /*
    2441             :  * Local variables:
    2442             :  * tab-width: 4
    2443             :  * c-basic-offset: 4
    2444             :  * End:
    2445             :  * vim600: noet sw=4 ts=4 fdm=marker
    2446             :  * vim<600: noet sw=4 ts=4
    2447             :  */

Generated by: LCOV version 1.10

Generated at Fri, 24 Apr 2015 17:26:43 +0000 (10 hours ago)

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