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: 729 913 79.8 %
Date: 2019-05-06 Functions: 63 67 94.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10

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

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