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: 727 942 77.2 %
Date: 2014-08-17 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         289 : PHP_METHOD(domdocument, __construct)
    1452             : {
    1453             : 
    1454             :         zval *id;
    1455         289 :         xmlDoc *docp = NULL, *olddoc;
    1456             :         dom_object *intern;
    1457         289 :         char *encoding, *version = NULL;
    1458         289 :         int encoding_len = 0, version_len = 0, refcount;
    1459             :         zend_error_handling error_handling;
    1460             : 
    1461         289 :         zend_replace_error_handling(EH_THROW, dom_domexception_class_entry, &error_handling TSRMLS_CC);
    1462         289 :         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         289 :         zend_restore_error_handling(&error_handling TSRMLS_CC);
    1468         289 :         docp = xmlNewDoc(version);
    1469             : 
    1470         289 :         if (!docp) {
    1471           0 :                 php_dom_throw_error(INVALID_STATE_ERR, 1 TSRMLS_CC);
    1472           0 :                 RETURN_FALSE;
    1473             :         }
    1474             : 
    1475         289 :         if (encoding_len > 0) {
    1476           6 :                 docp->encoding = (const xmlChar*)xmlStrdup(encoding);
    1477             :         }
    1478             : 
    1479         289 :         intern = (dom_object *)zend_object_store_get_object(id TSRMLS_CC);
    1480         289 :         if (intern != NULL) {
    1481         289 :                 olddoc = (xmlDocPtr) dom_object_get_node(intern);
    1482         289 :                 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         289 :                 intern->document = NULL;
    1490         289 :                 if (php_libxml_increment_doc_ref((php_libxml_node_object *)intern, docp TSRMLS_CC) == -1) {
    1491           0 :                         RETURN_FALSE;
    1492             :                 }
    1493         289 :                 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         127 :                 char *file_dest = _dom_get_valid_file_path(source, resolved_path, MAXPATHLEN  TSRMLS_CC);
    1584         127 :                 if (file_dest) {
    1585         127 :                         ctxt = xmlCreateFileParserCtxt(file_dest);
    1586             :                 }
    1587             :                 
    1588             :         } else {
    1589          80 :                 ctxt = xmlCreateMemoryParserCtxt(source, source_len);
    1590             :         }
    1591             : 
    1592         207 :         if (ctxt == NULL) {
    1593           0 :                 return(NULL);
    1594             :         }
    1595             : 
    1596             :         /* If loading from memory, we need to set the base directory for the document */
    1597         207 :         if (mode != DOM_LOAD_FILE) {
    1598             : #if HAVE_GETCWD
    1599          80 :                 directory = VCWD_GETCWD(resolved_path, MAXPATHLEN);
    1600             : #elif HAVE_GETWD
    1601             :                 directory = VCWD_GETWD(resolved_path);
    1602             : #endif
    1603          80 :                 if (directory) {
    1604          80 :                         if(ctxt->directory != NULL) {
    1605           0 :                                 xmlFree((char *) ctxt->directory);
    1606             :                         }
    1607          80 :                         resolved_path_len = strlen(resolved_path);
    1608          80 :                         if (resolved_path[resolved_path_len - 1] != DEFAULT_SLASH) {
    1609          80 :                                 resolved_path[resolved_path_len] = DEFAULT_SLASH;
    1610          80 :                                 resolved_path[++resolved_path_len] = '\0';
    1611             :                         }
    1612          80 :                         ctxt->directory = (char *) xmlCanonicPath((const xmlChar *) resolved_path);
    1613             :                 }
    1614             :         }
    1615             : 
    1616         207 :         ctxt->vctxt.error = php_libxml_ctx_error;
    1617         207 :         ctxt->vctxt.warning = php_libxml_ctx_warning;
    1618             : 
    1619         207 :         if (ctxt->sax != NULL) {
    1620         207 :                 ctxt->sax->error = php_libxml_ctx_error;
    1621         207 :                 ctxt->sax->warning = php_libxml_ctx_warning;
    1622             :         }
    1623             : 
    1624         207 :         if (validate && ! (options & XML_PARSE_DTDVALID)) {
    1625           1 :                 options |= XML_PARSE_DTDVALID;
    1626             :         }
    1627         207 :         if (resolve_externals && ! (options & XML_PARSE_DTDATTR)) {
    1628           5 :                 options |= XML_PARSE_DTDATTR;
    1629             :         }
    1630         207 :         if (substitute_ent && ! (options & XML_PARSE_NOENT)) {
    1631           7 :                 options |= XML_PARSE_NOENT;
    1632             :         }
    1633         207 :         if (keep_blanks == 0 && ! (options & XML_PARSE_NOBLANKS)) {
    1634           2 :                 options |= XML_PARSE_NOBLANKS;
    1635             :         }
    1636             : 
    1637         207 :         xmlCtxtUseOptions(ctxt, options);
    1638             : 
    1639         207 :         ctxt->recovery = recover;
    1640         207 :         if (recover) {
    1641           0 :                 old_error_reporting = EG(error_reporting);
    1642           0 :                 EG(error_reporting) = old_error_reporting | E_WARNING;
    1643             :         }
    1644             : 
    1645         207 :         xmlParseDocument(ctxt);
    1646             : 
    1647         413 :         if (ctxt->wellFormed || recover) {
    1648         206 :                 ret = ctxt->myDoc;
    1649         206 :                 if (ctxt->recovery) {
    1650           0 :                         EG(error_reporting) = old_error_reporting;
    1651             :                 }
    1652             :                 /* If loading from memory, set the base reference uri for the document */
    1653         206 :                 if (ret && ret->URL == NULL && ctxt->directory != NULL) {
    1654          79 :                         ret->URL = xmlStrdup(ctxt->directory);
    1655             :                 }
    1656             :         } else {
    1657           1 :                 ret = NULL;
    1658           1 :                 xmlFreeDoc(ctxt->myDoc);
    1659           1 :                 ctxt->myDoc = NULL;
    1660             :         }
    1661             : 
    1662         207 :         xmlFreeParserCtxt(ctxt);
    1663             : 
    1664         207 :         return(ret);
    1665             : }
    1666             : /* }}} */
    1667             : 
    1668             : /* {{{ static void dom_parse_document(INTERNAL_FUNCTION_PARAMETERS, int mode) */
    1669         207 : static void dom_parse_document(INTERNAL_FUNCTION_PARAMETERS, int mode) {
    1670             :         zval *id;
    1671         207 :         xmlDoc *docp = NULL, *newdoc;
    1672             :         dom_doc_propsptr doc_prop;
    1673             :         dom_object *intern;
    1674             :         char *source;
    1675             :         int source_len, refcount, ret;
    1676         207 :         long options = 0;
    1677             : 
    1678         207 :         id = getThis();
    1679         207 :         if (id != NULL && ! instanceof_function(Z_OBJCE_P(id), dom_document_class_entry TSRMLS_CC)) {
    1680           0 :                 id = NULL;
    1681             :         }
    1682             : 
    1683         207 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &source, &source_len, &options) == FAILURE) {
    1684           0 :                 return;
    1685             :         }
    1686             : 
    1687         207 :         if (!source_len) {
    1688           0 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Empty string supplied as input");
    1689           0 :                 RETURN_FALSE;
    1690             :         }
    1691             : 
    1692         207 :         newdoc = dom_document_parser(id, mode, source, source_len, options TSRMLS_CC);
    1693             : 
    1694         207 :         if (!newdoc)
    1695           1 :                 RETURN_FALSE;
    1696             : 
    1697         206 :         if (id != NULL) {
    1698         206 :                 intern = (dom_object *)zend_object_store_get_object(id TSRMLS_CC);
    1699         206 :                 if (intern != NULL) {
    1700         206 :                         docp = (xmlDocPtr) dom_object_get_node(intern);
    1701         206 :                         doc_prop = NULL;
    1702         206 :                         if (docp != NULL) {
    1703         206 :                                 php_libxml_decrement_node_ptr((php_libxml_node_object *) intern TSRMLS_CC);
    1704         206 :                                 doc_prop = intern->document->doc_props;
    1705         206 :                                 intern->document->doc_props = NULL;
    1706         206 :                                 refcount = php_libxml_decrement_doc_ref((php_libxml_node_object *)intern TSRMLS_CC);
    1707         206 :                                 if (refcount != 0) {
    1708           3 :                                         docp->_private = NULL;
    1709             :                                 }
    1710             :                         }
    1711         206 :                         intern->document = NULL;
    1712         206 :                         if (php_libxml_increment_doc_ref((php_libxml_node_object *)intern, newdoc TSRMLS_CC) == -1) {
    1713           0 :                                 RETURN_FALSE;
    1714             :                         }
    1715         206 :                         intern->document->doc_props = doc_prop;
    1716             :                 }
    1717             : 
    1718         206 :                 php_libxml_increment_node_ptr((php_libxml_node_object *)intern, (xmlNodePtr)newdoc, (void *)intern TSRMLS_CC);
    1719             : 
    1720         206 :                 RETURN_TRUE;
    1721             :         } else {
    1722           0 :                 DOM_RET_OBJ((xmlNodePtr) newdoc, &ret, NULL);
    1723             :         }
    1724             : }
    1725             : /* }}} end dom_parser_document */
    1726             : 
    1727             : /* {{{ proto DOMNode dom_document_load(string source [, int options]);
    1728             : URL: http://www.w3.org/TR/DOM-Level-3-LS/load-save.html#LS-DocumentLS-load
    1729             : Since: DOM Level 3
    1730             : */
    1731         127 : PHP_METHOD(domdocument, load)
    1732             : {
    1733         127 :         dom_parse_document(INTERNAL_FUNCTION_PARAM_PASSTHRU, DOM_LOAD_FILE);
    1734         127 : }
    1735             : /* }}} end dom_document_load */
    1736             : 
    1737             : /* {{{ proto DOMNode dom_document_loadxml(string source [, int options]);
    1738             : URL: http://www.w3.org/TR/DOM-Level-3-LS/load-save.html#LS-DocumentLS-loadXML
    1739             : Since: DOM Level 3
    1740             : */
    1741          80 : PHP_METHOD(domdocument, loadXML)
    1742             : {
    1743          80 :         dom_parse_document(INTERNAL_FUNCTION_PARAM_PASSTHRU, DOM_LOAD_STRING);
    1744          80 : }
    1745             : /* }}} end dom_document_loadxml */
    1746             : 
    1747             : /* {{{ proto int dom_document_save(string file);
    1748             : Convenience method to save to file
    1749             : */
    1750           3 : PHP_FUNCTION(dom_document_save)
    1751             : {
    1752             :         zval *id;
    1753             :         xmlDoc *docp;
    1754           3 :         int file_len = 0, bytes, format, saveempty = 0;
    1755             :         dom_object *intern;
    1756             :         dom_doc_propsptr doc_props;
    1757             :         char *file;
    1758           3 :         long options = 0;
    1759             : 
    1760           3 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Os|l", &id, dom_document_class_entry, &file, &file_len, &options) == FAILURE) {
    1761           0 :                 return;
    1762             :         }
    1763             : 
    1764           3 :         if (file_len == 0) {
    1765           0 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid Filename");
    1766           0 :                 RETURN_FALSE;
    1767             :         }
    1768             : 
    1769           3 :         DOM_GET_OBJ(docp, id, xmlDocPtr, intern);
    1770             : 
    1771             :         /* encoding handled by property on doc */
    1772             : 
    1773           3 :         doc_props = dom_get_doc_props(intern->document);
    1774           3 :         format = doc_props->formatoutput;
    1775           3 :         if (options & LIBXML_SAVE_NOEMPTYTAG) {
    1776           0 :                 saveempty = xmlSaveNoEmptyTags;
    1777           0 :                 xmlSaveNoEmptyTags = 1;
    1778             :         }
    1779           3 :         bytes = xmlSaveFormatFileEnc(file, docp, NULL, format);
    1780           3 :         if (options & LIBXML_SAVE_NOEMPTYTAG) {
    1781           0 :                 xmlSaveNoEmptyTags = saveempty;
    1782             :         }
    1783           3 :         if (bytes == -1) {
    1784           1 :                 RETURN_FALSE;
    1785             :         }
    1786           2 :         RETURN_LONG(bytes);
    1787             : }
    1788             : /* }}} end dom_document_save */
    1789             : 
    1790             : /* {{{ proto string dom_document_savexml([node n]);
    1791             : URL: http://www.w3.org/TR/DOM-Level-3-LS/load-save.html#LS-DocumentLS-saveXML
    1792             : Since: DOM Level 3
    1793             : */
    1794          52 : PHP_FUNCTION(dom_document_savexml)
    1795             : {
    1796          52 :         zval *id, *nodep = NULL;
    1797             :         xmlDoc *docp;
    1798             :         xmlNode *node;
    1799             :         xmlBufferPtr buf;
    1800             :         xmlChar *mem;
    1801             :         dom_object *intern, *nodeobj;
    1802             :         dom_doc_propsptr doc_props;
    1803          52 :         int size, format, saveempty = 0;
    1804          52 :         long options = 0;
    1805             : 
    1806          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) {
    1807           0 :                 return;
    1808             :         }
    1809             : 
    1810          52 :         DOM_GET_OBJ(docp, id, xmlDocPtr, intern);
    1811             : 
    1812          52 :         doc_props = dom_get_doc_props(intern->document);
    1813          52 :         format = doc_props->formatoutput;
    1814             : 
    1815          52 :         if (nodep != NULL) {
    1816             :                 /* Dump contents of Node */
    1817           3 :                 DOM_GET_OBJ(node, nodep, xmlNodePtr, nodeobj);
    1818           3 :                 if (node->doc != docp) {
    1819           0 :                         php_dom_throw_error(WRONG_DOCUMENT_ERR, dom_get_strict_error(intern->document) TSRMLS_CC);
    1820           0 :                         RETURN_FALSE;
    1821             :                 }
    1822           3 :                 buf = xmlBufferCreate();
    1823           3 :                 if (!buf) {
    1824           0 :                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not fetch buffer");
    1825           0 :                         RETURN_FALSE;
    1826             :                 }
    1827           3 :                 if (options & LIBXML_SAVE_NOEMPTYTAG) {
    1828           0 :                         saveempty = xmlSaveNoEmptyTags;
    1829           0 :                         xmlSaveNoEmptyTags = 1;
    1830             :                 }
    1831           3 :                 xmlNodeDump(buf, docp, node, 0, format);
    1832           3 :                 if (options & LIBXML_SAVE_NOEMPTYTAG) {
    1833           0 :                         xmlSaveNoEmptyTags = saveempty;
    1834             :                 }
    1835           3 :                 mem = (xmlChar*) xmlBufferContent(buf);
    1836           3 :                 if (!mem) {
    1837           0 :                         xmlBufferFree(buf);
    1838           0 :                         RETURN_FALSE;
    1839             :                 }
    1840           3 :                 RETVAL_STRING(mem, 1);
    1841           3 :                 xmlBufferFree(buf);
    1842             :         } else {
    1843          49 :                 if (options & LIBXML_SAVE_NOEMPTYTAG) {
    1844           0 :                         saveempty = xmlSaveNoEmptyTags;
    1845           0 :                         xmlSaveNoEmptyTags = 1;
    1846             :                 }
    1847             :                 /* Encoding is handled from the encoding property set on the document */
    1848          49 :                 xmlDocDumpFormatMemory(docp, &mem, &size, format);
    1849          49 :                 if (options & LIBXML_SAVE_NOEMPTYTAG) {
    1850           0 :                         xmlSaveNoEmptyTags = saveempty;
    1851             :                 }
    1852          49 :                 if (!size) {
    1853           0 :                         RETURN_FALSE;
    1854             :                 }
    1855          49 :                 RETVAL_STRINGL(mem, size, 1);
    1856          49 :                 xmlFree(mem);
    1857             :         }
    1858             : }
    1859             : /* }}} end dom_document_savexml */
    1860             : 
    1861           8 : static xmlNodePtr php_dom_free_xinclude_node(xmlNodePtr cur TSRMLS_DC) /* {{{ */
    1862             : {
    1863             :         xmlNodePtr xincnode;
    1864             : 
    1865           8 :         xincnode = cur;
    1866           8 :         cur = cur->next;
    1867           8 :         xmlUnlinkNode(xincnode);
    1868           8 :         php_libxml_node_free_resource(xincnode TSRMLS_CC);
    1869             : 
    1870           8 :         return cur;
    1871             : }
    1872             : /* }}} */
    1873             : 
    1874          22 : static void php_dom_remove_xinclude_nodes(xmlNodePtr cur TSRMLS_DC) /* {{{ */
    1875             : {
    1876          94 :         while(cur) {
    1877          50 :                 if (cur->type == XML_XINCLUDE_START) {
    1878           4 :                         cur = php_dom_free_xinclude_node(cur TSRMLS_CC);
    1879             : 
    1880             :                         /* XML_XINCLUDE_END node will be a sibling of XML_XINCLUDE_START */
    1881          13 :                         while(cur && cur->type != XML_XINCLUDE_END) {
    1882             :                                 /* remove xinclude processing nodes from recursive xincludes */
    1883           5 :                                 if (cur->type == XML_ELEMENT_NODE) {
    1884           5 :                                            php_dom_remove_xinclude_nodes(cur->children TSRMLS_CC);
    1885             :                                 }
    1886           5 :                                 cur = cur->next;
    1887             :                         }
    1888             : 
    1889           4 :                         if (cur && cur->type == XML_XINCLUDE_END) {
    1890           4 :                                 cur = php_dom_free_xinclude_node(cur TSRMLS_CC);
    1891             :                         }
    1892             :                 } else {
    1893          46 :                         if (cur->type == XML_ELEMENT_NODE) {
    1894          15 :                                 php_dom_remove_xinclude_nodes(cur->children TSRMLS_CC);
    1895             :                         }
    1896          46 :                         cur = cur->next;
    1897             :                 }
    1898             :         }
    1899          22 : }
    1900             : /* }}} */
    1901             : 
    1902             : /* {{{ proto int dom_document_xinclude([int options])
    1903             :    Substitutues xincludes in a DomDocument */
    1904           2 : PHP_FUNCTION(dom_document_xinclude)
    1905             : {
    1906             :         zval *id;
    1907             :         xmlDoc *docp;
    1908             :         xmlNodePtr root;
    1909           2 :         long flags = 0; 
    1910             :         int err;
    1911             :         dom_object *intern;
    1912             : 
    1913           2 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O|l", &id, dom_document_class_entry, &flags) == FAILURE) {
    1914           0 :                 return;
    1915             :         }
    1916             : 
    1917           2 :         DOM_GET_OBJ(docp, id, xmlDocPtr, intern);
    1918             : 
    1919           2 :         err = xmlXIncludeProcessFlags(docp, flags);
    1920             : 
    1921             :         /* XML_XINCLUDE_START and XML_XINCLUDE_END nodes need to be removed as these
    1922             :         are added via xmlXIncludeProcess to mark beginning and ending of xincluded document 
    1923             :         but are not wanted in resulting document - must be done even if err as it could fail after
    1924             :         having processed some xincludes */
    1925           2 :         root = (xmlNodePtr) docp->children;
    1926           4 :         while(root && root->type != XML_ELEMENT_NODE && root->type != XML_XINCLUDE_START) {
    1927           0 :                 root = root->next;
    1928             :         }
    1929           2 :         if (root) {
    1930           2 :                 php_dom_remove_xinclude_nodes(root TSRMLS_CC);
    1931             :         }
    1932             : 
    1933           2 :         if (err) {
    1934           2 :                 RETVAL_LONG(err);
    1935             :         } else {
    1936           0 :                 RETVAL_FALSE;
    1937             :         }
    1938             :     
    1939             : }
    1940             : /* }}} */
    1941             : 
    1942             : /* {{{ proto boolean dom_document_validate();
    1943             : Since: DOM extended
    1944             : */
    1945           8 : PHP_FUNCTION(dom_document_validate)
    1946             : {
    1947             :         zval *id;
    1948             :         xmlDoc *docp;
    1949             :         dom_object *intern;
    1950             :         xmlValidCtxt *cvp;
    1951             : 
    1952           8 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &id, dom_document_class_entry) == FAILURE) {
    1953           1 :                 return;
    1954             :         }
    1955             : 
    1956           7 :         DOM_GET_OBJ(docp, id, xmlDocPtr, intern);
    1957             : 
    1958           7 :         cvp = xmlNewValidCtxt();
    1959             :         
    1960           7 :         cvp->userData = NULL;
    1961           7 :         cvp->error    = (xmlValidityErrorFunc) php_libxml_error_handler;
    1962           7 :         cvp->warning  = (xmlValidityErrorFunc) php_libxml_error_handler;
    1963             :         
    1964           7 :         if (xmlValidateDocument(cvp, docp)) {
    1965           5 :                 RETVAL_TRUE;
    1966             :         } else {
    1967           2 :                 RETVAL_FALSE;
    1968             :         }
    1969             :         
    1970           7 :         xmlFreeValidCtxt(cvp);
    1971             :         
    1972             : }
    1973             : /* }}} */
    1974             : 
    1975             : #if defined(LIBXML_SCHEMAS_ENABLED)
    1976          11 : static void _dom_document_schema_validate(INTERNAL_FUNCTION_PARAMETERS, int type) /* {{{ */
    1977             : {
    1978             :         zval *id;
    1979             :         xmlDoc *docp;
    1980             :         dom_object *intern;
    1981          11 :         char *source = NULL, *valid_file = NULL;
    1982          11 :         int source_len = 0;
    1983             :         xmlSchemaParserCtxtPtr  parser;
    1984             :         xmlSchemaPtr            sptr;
    1985             :         xmlSchemaValidCtxtPtr   vptr;
    1986             :         int                     is_valid;
    1987             :         char resolved_path[MAXPATHLEN + 1];
    1988             : 
    1989          11 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Op", &id, dom_document_class_entry, &source, &source_len) == FAILURE) {
    1990           2 :                 return;
    1991             :         }
    1992             : 
    1993           9 :         if (source_len == 0) {
    1994           2 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid Schema source");
    1995           2 :                 RETURN_FALSE;
    1996             :         }
    1997             : 
    1998           7 :         DOM_GET_OBJ(docp, id, xmlDocPtr, intern);
    1999             : 
    2000           7 :         switch (type) {
    2001             :         case DOM_LOAD_FILE:
    2002           4 :                 valid_file = _dom_get_valid_file_path(source, resolved_path, MAXPATHLEN  TSRMLS_CC);
    2003           4 :                 if (!valid_file) {
    2004           0 :                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid Schema file source");
    2005           0 :                         RETURN_FALSE;
    2006             :                 }
    2007           4 :                 parser = xmlSchemaNewParserCtxt(valid_file);
    2008           4 :                 break;
    2009             :         case DOM_LOAD_STRING:
    2010           3 :                 parser = xmlSchemaNewMemParserCtxt(source, source_len);
    2011             :                 /* If loading from memory, we need to set the base directory for the document 
    2012             :                    but it is not apparent how to do that for schema's */
    2013           3 :                 break;
    2014             :         default:
    2015           0 :                 return;
    2016             :         }
    2017             : 
    2018           7 :         xmlSchemaSetParserErrors(parser,
    2019             :                 (xmlSchemaValidityErrorFunc) php_libxml_error_handler,
    2020             :                 (xmlSchemaValidityWarningFunc) php_libxml_error_handler,
    2021             :                 parser);
    2022           7 :         sptr = xmlSchemaParse(parser);
    2023           7 :         xmlSchemaFreeParserCtxt(parser);
    2024           7 :         if (!sptr) {
    2025           3 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid Schema");
    2026           3 :                 RETURN_FALSE;
    2027             :         }
    2028             : 
    2029           4 :         docp = (xmlDocPtr) dom_object_get_node(intern);
    2030             : 
    2031           4 :         vptr = xmlSchemaNewValidCtxt(sptr);
    2032           4 :         if (!vptr) {
    2033           0 :                 xmlSchemaFree(sptr);
    2034           0 :                 php_error(E_ERROR, "Invalid Schema Validation Context");
    2035           0 :                 RETURN_FALSE;
    2036             :         }
    2037             : 
    2038           4 :         xmlSchemaSetValidErrors(vptr, php_libxml_error_handler, php_libxml_error_handler, vptr);
    2039           4 :         is_valid = xmlSchemaValidateDoc(vptr, docp);
    2040           4 :         xmlSchemaFree(sptr);
    2041           4 :         xmlSchemaFreeValidCtxt(vptr);
    2042             : 
    2043           4 :         if (is_valid == 0) {
    2044           2 :                 RETURN_TRUE;
    2045             :         } else {
    2046           2 :                 RETURN_FALSE;
    2047             :         }
    2048             : }
    2049             : /* }}} */
    2050             : 
    2051             : /* {{{ proto boolean dom_document_schema_validate_file(string filename); */
    2052           6 : PHP_FUNCTION(dom_document_schema_validate_file)
    2053             : {
    2054           6 :         _dom_document_schema_validate(INTERNAL_FUNCTION_PARAM_PASSTHRU, DOM_LOAD_FILE);
    2055           6 : }
    2056             : /* }}} end dom_document_schema_validate_file */
    2057             : 
    2058             : /* {{{ proto boolean dom_document_schema_validate(string source); */
    2059           5 : PHP_FUNCTION(dom_document_schema_validate_xml)
    2060             : {
    2061           5 :         _dom_document_schema_validate(INTERNAL_FUNCTION_PARAM_PASSTHRU, DOM_LOAD_STRING);
    2062           5 : }
    2063             : /* }}} end dom_document_schema_validate */
    2064             : 
    2065           6 : static void _dom_document_relaxNG_validate(INTERNAL_FUNCTION_PARAMETERS, int type) /* {{{ */
    2066             : {
    2067             :         zval *id;
    2068             :         xmlDoc *docp;
    2069             :         dom_object *intern;
    2070           6 :         char *source = NULL, *valid_file = NULL;
    2071           6 :         int source_len = 0;
    2072             :         xmlRelaxNGParserCtxtPtr parser;
    2073             :         xmlRelaxNGPtr           sptr;
    2074             :         xmlRelaxNGValidCtxtPtr  vptr;
    2075             :         int                     is_valid;
    2076             :         char resolved_path[MAXPATHLEN + 1];
    2077             : 
    2078           6 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Op", &id, dom_document_class_entry, &source, &source_len) == FAILURE) {
    2079           0 :                 return;
    2080             :         }
    2081             : 
    2082           6 :         if (source_len == 0) {
    2083           0 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid Schema source");
    2084           0 :                 RETURN_FALSE;
    2085             :         }
    2086             : 
    2087           6 :         DOM_GET_OBJ(docp, id, xmlDocPtr, intern);
    2088             : 
    2089           6 :         switch (type) {
    2090             :         case DOM_LOAD_FILE:
    2091           3 :                 valid_file = _dom_get_valid_file_path(source, resolved_path, MAXPATHLEN  TSRMLS_CC);
    2092           3 :                 if (!valid_file) {
    2093           0 :                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid RelaxNG file source");
    2094           0 :                         RETURN_FALSE;
    2095             :                 }
    2096           3 :                 parser = xmlRelaxNGNewParserCtxt(valid_file);
    2097           3 :                 break;
    2098             :         case DOM_LOAD_STRING:
    2099           3 :                 parser = xmlRelaxNGNewMemParserCtxt(source, source_len);
    2100             :                 /* If loading from memory, we need to set the base directory for the document 
    2101             :                    but it is not apparent how to do that for schema's */
    2102           3 :                 break;
    2103             :         default:
    2104           0 :                 return;
    2105             :         }
    2106             : 
    2107           6 :         xmlRelaxNGSetParserErrors(parser,
    2108             :                 (xmlRelaxNGValidityErrorFunc) php_libxml_error_handler,
    2109             :                 (xmlRelaxNGValidityWarningFunc) php_libxml_error_handler,
    2110             :                 parser);
    2111           6 :         sptr = xmlRelaxNGParse(parser);
    2112           6 :         xmlRelaxNGFreeParserCtxt(parser);
    2113           6 :         if (!sptr) {
    2114           2 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid RelaxNG");
    2115           2 :                 RETURN_FALSE;
    2116             :         }
    2117             : 
    2118           4 :         docp = (xmlDocPtr) dom_object_get_node(intern);
    2119             : 
    2120           4 :         vptr = xmlRelaxNGNewValidCtxt(sptr);
    2121           4 :         if (!vptr) {
    2122           0 :                 xmlRelaxNGFree(sptr);
    2123           0 :                 php_error(E_ERROR, "Invalid RelaxNG Validation Context");
    2124           0 :                 RETURN_FALSE;
    2125             :         }
    2126             : 
    2127           4 :         xmlRelaxNGSetValidErrors(vptr, php_libxml_error_handler, php_libxml_error_handler, vptr);
    2128           4 :         is_valid = xmlRelaxNGValidateDoc(vptr, docp);
    2129           4 :         xmlRelaxNGFree(sptr);
    2130           4 :         xmlRelaxNGFreeValidCtxt(vptr);
    2131             : 
    2132           4 :         if (is_valid == 0) {
    2133           2 :                 RETURN_TRUE;
    2134             :         } else {
    2135           2 :                 RETURN_FALSE;
    2136             :         }
    2137             : }
    2138             : /* }}} */
    2139             : 
    2140             : /* {{{ proto boolean dom_document_relaxNG_validate_file(string filename); */
    2141           3 : PHP_FUNCTION(dom_document_relaxNG_validate_file)
    2142             : {
    2143           3 :         _dom_document_relaxNG_validate(INTERNAL_FUNCTION_PARAM_PASSTHRU, DOM_LOAD_FILE);
    2144           3 : }
    2145             : /* }}} end dom_document_relaxNG_validate_file */
    2146             : 
    2147             : /* {{{ proto boolean dom_document_relaxNG_validate_xml(string source); */
    2148           3 : PHP_FUNCTION(dom_document_relaxNG_validate_xml)
    2149             : {
    2150           3 :         _dom_document_relaxNG_validate(INTERNAL_FUNCTION_PARAM_PASSTHRU, DOM_LOAD_STRING);
    2151           3 : }
    2152             : /* }}} end dom_document_relaxNG_validate_xml */
    2153             : 
    2154             : #endif
    2155             : 
    2156             : #if defined(LIBXML_HTML_ENABLED)
    2157             : 
    2158          12 : static void dom_load_html(INTERNAL_FUNCTION_PARAMETERS, int mode) /* {{{ */
    2159             : {
    2160             :         zval *id;
    2161          12 :         xmlDoc *docp = NULL, *newdoc;
    2162             :         dom_object *intern;
    2163             :         dom_doc_propsptr doc_prop;
    2164             :         char *source;
    2165             :         int source_len, refcount, ret;
    2166          12 :         long options = 0;
    2167             :         htmlParserCtxtPtr ctxt;
    2168             :         
    2169          12 :         id = getThis();
    2170             : 
    2171          12 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &source, &source_len, &options) == FAILURE) {
    2172           1 :                 return;
    2173             :         }
    2174             : 
    2175          11 :         if (!source_len) {
    2176           2 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Empty string supplied as input");
    2177           2 :                 RETURN_FALSE;
    2178             :         }
    2179             : 
    2180           9 :         if (mode == DOM_LOAD_FILE) {
    2181           5 :                 ctxt = htmlCreateFileParserCtxt(source, NULL);
    2182             :         } else {
    2183           4 :                 source_len = xmlStrlen(source);
    2184           4 :                 ctxt = htmlCreateMemoryParserCtxt(source, source_len);
    2185             :         }
    2186             : 
    2187           9 :         if (!ctxt) {
    2188           1 :                 RETURN_FALSE;
    2189             :         }
    2190             : 
    2191           8 :         if (options) {
    2192           0 :                 htmlCtxtUseOptions(ctxt, options);
    2193             :         }
    2194             : 
    2195           8 :         ctxt->vctxt.error = php_libxml_ctx_error;
    2196           8 :         ctxt->vctxt.warning = php_libxml_ctx_warning;
    2197           8 :         if (ctxt->sax != NULL) {
    2198           8 :                 ctxt->sax->error = php_libxml_ctx_error;
    2199           8 :                 ctxt->sax->warning = php_libxml_ctx_warning;
    2200             :         }
    2201           8 :         htmlParseDocument(ctxt);
    2202           8 :         newdoc = ctxt->myDoc;
    2203           8 :         htmlFreeParserCtxt(ctxt);
    2204             :         
    2205           8 :         if (!newdoc)
    2206           0 :                 RETURN_FALSE;
    2207             : 
    2208           8 :         if (id != NULL && instanceof_function(Z_OBJCE_P(id), dom_document_class_entry TSRMLS_CC)) {
    2209           8 :                 intern = (dom_object *)zend_object_store_get_object(id TSRMLS_CC);
    2210           8 :                 if (intern != NULL) {
    2211           8 :                         docp = (xmlDocPtr) dom_object_get_node(intern);
    2212           8 :                         doc_prop = NULL;
    2213           8 :                         if (docp != NULL) {
    2214           8 :                                 php_libxml_decrement_node_ptr((php_libxml_node_object *) intern TSRMLS_CC);
    2215           8 :                                 doc_prop = intern->document->doc_props;
    2216           8 :                                 intern->document->doc_props = NULL;
    2217           8 :                                 refcount = php_libxml_decrement_doc_ref((php_libxml_node_object *)intern TSRMLS_CC);
    2218           8 :                                 if (refcount != 0) {
    2219           0 :                                         docp->_private = NULL;
    2220             :                                 }
    2221             :                         }
    2222           8 :                         intern->document = NULL;
    2223           8 :                         if (php_libxml_increment_doc_ref((php_libxml_node_object *)intern, newdoc TSRMLS_CC) == -1) {
    2224           0 :                                 RETURN_FALSE;
    2225             :                         }
    2226           8 :                         intern->document->doc_props = doc_prop;
    2227             :                 }
    2228             : 
    2229           8 :                 php_libxml_increment_node_ptr((php_libxml_node_object *)intern, (xmlNodePtr)newdoc, (void *)intern TSRMLS_CC);
    2230             : 
    2231           8 :                 RETURN_TRUE;
    2232             :         } else {
    2233           0 :                 DOM_RET_OBJ((xmlNodePtr) newdoc, &ret, NULL);
    2234             :         }
    2235             : }
    2236             : /* }}} */
    2237             : 
    2238             : /* {{{ proto DOMNode dom_document_load_html_file(string source);
    2239             : Since: DOM extended
    2240             : */
    2241           6 : PHP_METHOD(domdocument, loadHTMLFile)
    2242             : {
    2243           6 :         dom_load_html(INTERNAL_FUNCTION_PARAM_PASSTHRU, DOM_LOAD_FILE);
    2244           6 : }
    2245             : /* }}} end dom_document_load_html_file */
    2246             : 
    2247             : /* {{{ proto DOMNode dom_document_load_html(string source);
    2248             : Since: DOM extended
    2249             : */
    2250           6 : PHP_METHOD(domdocument, loadHTML)
    2251             : {
    2252           6 :         dom_load_html(INTERNAL_FUNCTION_PARAM_PASSTHRU, DOM_LOAD_STRING);
    2253           6 : }
    2254             : /* }}} end dom_document_load_html */
    2255             : 
    2256             : /* {{{ proto int dom_document_save_html_file(string file);
    2257             : Convenience method to save to file as html
    2258             : */
    2259           4 : PHP_FUNCTION(dom_document_save_html_file)
    2260             : {
    2261             :         zval *id;
    2262             :         xmlDoc *docp;
    2263             :         int file_len, bytes, format;
    2264             :         dom_object *intern;
    2265             :         dom_doc_propsptr doc_props;
    2266             :         char *file;
    2267             :         const char *encoding;
    2268             : 
    2269           4 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Os", &id, dom_document_class_entry, &file, &file_len) == FAILURE) {
    2270           1 :                 return;
    2271             :         }
    2272             : 
    2273           3 :         if (file_len == 0) {
    2274           1 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid Filename");
    2275           1 :                 RETURN_FALSE;
    2276             :         }
    2277             : 
    2278           2 :         DOM_GET_OBJ(docp, id, xmlDocPtr, intern);
    2279             : 
    2280             : 
    2281           2 :         encoding = (const char *) htmlGetMetaEncoding(docp);
    2282             : 
    2283           2 :         doc_props = dom_get_doc_props(intern->document);
    2284           2 :         format = doc_props->formatoutput;
    2285           2 :         bytes = htmlSaveFileFormat(file, docp, encoding, format);
    2286             : 
    2287           2 :         if (bytes == -1) {
    2288           0 :                 RETURN_FALSE;
    2289             :         }
    2290           2 :         RETURN_LONG(bytes);
    2291             : }
    2292             : /* }}} end dom_document_save_html_file */
    2293             : 
    2294             : /* {{{ proto string dom_document_save_html();
    2295             : Convenience method to output as html
    2296             : */
    2297          11 : PHP_FUNCTION(dom_document_save_html)
    2298             : {
    2299          11 :         zval *id, *nodep = NULL;
    2300             :         xmlDoc *docp;
    2301             :         xmlNode *node;
    2302             :         xmlBufferPtr buf;
    2303             :         dom_object *intern, *nodeobj;
    2304          11 :         xmlChar *mem = NULL;
    2305          11 :         int size = 0, format;
    2306             :         dom_doc_propsptr doc_props;
    2307             : 
    2308          11 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(),
    2309             :                 "O|O!", &id, dom_document_class_entry, &nodep, dom_node_class_entry)
    2310             :                 == FAILURE) {
    2311           0 :                 return;
    2312             :         }
    2313             : 
    2314          11 :         DOM_GET_OBJ(docp, id, xmlDocPtr, intern);
    2315             : 
    2316          11 :         doc_props = dom_get_doc_props(intern->document);
    2317          11 :         format = doc_props->formatoutput;
    2318             : 
    2319          11 :         if (nodep != NULL) {
    2320             :                 /* Dump contents of Node */
    2321           4 :                 DOM_GET_OBJ(node, nodep, xmlNodePtr, nodeobj);
    2322           4 :                 if (node->doc != docp) {
    2323           0 :                         php_dom_throw_error(WRONG_DOCUMENT_ERR, dom_get_strict_error(intern->document) TSRMLS_CC);
    2324           0 :                         RETURN_FALSE;
    2325             :                 }
    2326             :                 
    2327           4 :                 buf = xmlBufferCreate();
    2328           4 :                 if (!buf) {
    2329           0 :                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not fetch buffer");
    2330           0 :                         RETURN_FALSE;
    2331             :                 }
    2332             :                 
    2333           4 :                 if (node->type == XML_DOCUMENT_FRAG_NODE) {
    2334             :                         int one_size;
    2335             : 
    2336          10 :                         for (node = node->children; node; node = node->next) {
    2337           3 :                                 one_size = htmlNodeDump(buf, docp, node);
    2338             : 
    2339           3 :                                 if (one_size >= 0) {
    2340           3 :                                         size += one_size;
    2341             :                                 } else {
    2342           0 :                                         size = -1;
    2343           0 :                                         break;
    2344             :                                 }
    2345             :                         }
    2346             :                 } else {
    2347           2 :                         size = htmlNodeDump(buf, docp, node);
    2348             :                 }
    2349           4 :                 if (size >= 0) {
    2350           4 :                         mem = (xmlChar*) xmlBufferContent(buf);
    2351           4 :                         if (!mem) {
    2352           0 :                                 RETVAL_FALSE;
    2353             :                         } else {
    2354           4 :                                 RETVAL_STRINGL((const char*) mem, size, 1);
    2355             :                         }
    2356             :                 } else {
    2357           0 :                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "Error dumping HTML node");
    2358           0 :                         RETVAL_FALSE;
    2359             :                 }
    2360           4 :                 xmlBufferFree(buf);
    2361             :         } else {
    2362             : #if LIBXML_VERSION >= 20623
    2363           7 :                 htmlDocDumpMemoryFormat(docp, &mem, &size, format);
    2364             : #else
    2365             :                 htmlDocDumpMemory(docp, &mem, &size);
    2366             : #endif
    2367           7 :                 if (!size) {
    2368           0 :                         RETVAL_FALSE;
    2369             :                 } else {
    2370           7 :                         RETVAL_STRINGL((const char*) mem, size, 1);
    2371             :                 }
    2372           7 :                 if (mem)
    2373           7 :                         xmlFree(mem);
    2374             :         }
    2375             : 
    2376             : }
    2377             : /* }}} end dom_document_save_html */
    2378             : 
    2379             : #endif  /* defined(LIBXML_HTML_ENABLED) */
    2380             : 
    2381             : /* {{{ proto boolean DOMDocument::registerNodeClass(string baseclass, string extendedclass);
    2382             :    Register extended class used to create base node type */
    2383           3 : PHP_METHOD(domdocument, registerNodeClass)
    2384             : {
    2385             :         zval *id;
    2386             :         xmlDoc *docp;
    2387           3 :         char *baseclass = NULL, *extendedclass = NULL;
    2388           3 :         int baseclass_len = 0, extendedclass_len = 0;
    2389           3 :         zend_class_entry *basece = NULL, *ce = NULL;
    2390             :         dom_object *intern;
    2391             : 
    2392           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) {
    2393           0 :                 return;
    2394             :         }
    2395             : 
    2396           3 :         if (baseclass_len) {
    2397             :                 zend_class_entry **pce;
    2398           3 :                 if (zend_lookup_class(baseclass, baseclass_len, &pce TSRMLS_CC) == FAILURE) {
    2399           0 :                         php_error_docref(NULL TSRMLS_CC, E_ERROR, "Class %s does not exist", baseclass);
    2400           0 :                         return;
    2401             :                 }
    2402           3 :                 basece = *pce;
    2403             :         }
    2404             : 
    2405           3 :         if (basece == NULL || ! instanceof_function(basece, dom_node_class_entry TSRMLS_CC)) {
    2406           0 :                 php_error_docref(NULL TSRMLS_CC, E_ERROR, "Class %s is not derived from DOMNode.", baseclass);
    2407           0 :                 return;
    2408             :         }
    2409             : 
    2410           3 :         if (extendedclass_len) {
    2411             :                 zend_class_entry **pce;
    2412           2 :                 if (zend_lookup_class(extendedclass, extendedclass_len, &pce TSRMLS_CC) == FAILURE) {
    2413           0 :                         php_error_docref(NULL TSRMLS_CC, E_ERROR, "Class %s does not exist", extendedclass);
    2414             :                 }
    2415           2 :                 ce = *pce;
    2416             :         }
    2417             : 
    2418           3 :         if (ce == NULL || instanceof_function(ce, basece TSRMLS_CC)) {
    2419             : 
    2420           3 :                 DOM_GET_OBJ(docp, id, xmlDocPtr, intern);
    2421             : 
    2422           3 :                 if (dom_set_doc_classmap(intern->document, basece, ce TSRMLS_CC) == FAILURE) {
    2423           0 :                         php_error_docref(NULL TSRMLS_CC, E_ERROR, "Class %s could not be registered.", extendedclass);
    2424             :                 }
    2425           3 :                 RETURN_TRUE;
    2426             :         } else {
    2427           0 :                 php_error_docref(NULL TSRMLS_CC, E_ERROR, "Class %s is not derived from %s.", extendedclass, baseclass);
    2428             :         }
    2429             : 
    2430           0 :         RETURN_FALSE;
    2431             : }
    2432             : /* }}} */
    2433             : 
    2434             : #endif  /* HAVE_LIBXML && HAVE_DOM */
    2435             : 
    2436             : /*
    2437             :  * Local variables:
    2438             :  * tab-width: 4
    2439             :  * c-basic-offset: 4
    2440             :  * End:
    2441             :  * vim600: noet sw=4 ts=4 fdm=marker
    2442             :  * vim<600: noet sw=4 ts=4
    2443             :  */

Generated by: LCOV version 1.10

Generated at Sun, 17 Aug 2014 15:21:50 +0000 (5 days ago)

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