by Alexandre Alapetite on 2004-07-04; updated on 2011-11-19

XML transition from PHP4 domxml to PHP5 dom

When moving from PHP4 to PHP5, some modifications are required in the scripts. In PHP4, the experimental domxml extension was used to manage XML, but this has been replaced by the dom extension in PHP5.

Migration from PHP4 to PHP5 is easy, but might be long if domxml was broadly used. Moreover, in order to have a smooth transition, it is good for scripts to be compatible with PHP5 as soon as possible, even if the server is still running PHP4. The optimisation for PHP5 can be done later.

I propose on this page a module (wrapper) to include in your PHP4/domxml scripts, for them to be compatible with PHP5/dom or PHP6/dom.

For XSLT/XSL, have a look to my PHP4/XSLT to PHP5/XSL page.

français

Table of contents

Exit

Scripts for PHP4 domxml compatible with PHP5 dom

In order to run your PHP4 scripts that use domxml on a server moving to PHP5, you only need to include the file domxml-php4-to-php5.php in your PHP4 source code, this way:

if (PHP_VERSION>='5')
 require_once('domxml-php4-to-php5.php');

Note that it does not modify your scripts when the server is still running PHP4.
It is covering the main domxml functions, but not all of them. Nevertheless, it can easily be extended if needed.
Bellow, an example and the code for the compatibility file.

exemple-php4.php

<?php
//PHP4 script using domxml extension
//We want to make it run on PHP5 with dom
if (PHP_VERSION>='5')
 require_once('domxml-php4-to-php5.php'); //Load the PHP5 converter
if ($dom=domxml_open_file('test.xml'))
{
 $root=$dom->document_element();
 $bs=$root->get_elements_by_tagname('body');
 if (count($bs)==1)
 {
  $body=$bs[0];
  $p=$dom->create_element('p');
  $p->append_child($dom->create_text_node('a new paragraph'));
  $body->append_child($p);
  $body->append_child($dom->create_text_node("\n"));
 }
 $dom->dump_file('test.xml',false,false);
}
?>
domxml-php4-to-php5.php

<?php
/*
 To be used in PHP4 scripts using DOMXML extension.
 Allows PHP4/DOMXML scripts to run on PHP5/DOM.
 Requires PHP5, uses built-in DOM extension,
  needs XSL extension (included in PHP5) for domxml_xslt functions,
  needs PHP>=5.1 for full XPath evaluation support,
  needs PHP>=5.1/libxml for DOMXML error reports.
 http://alexandre.alapetite.fr/doc-alex/domxml-php4-php5/
*/

define('DOMXML_LOAD_PARSING',0);
define('DOMXML_LOAD_VALIDATING',1);
define('DOMXML_LOAD_RECOVERING',2);
define('DOMXML_LOAD_SUBSTITUTE_ENTITIES',4);
define('DOMXML_LOAD_DONT_KEEP_BLANKS',16);

function domxml_new_doc($version) {return new php4DOMDocument();}
function domxml_new_xmldoc($version) {return new php4DOMDocument();}
function domxml_open_file($filename,$mode=DOMXML_LOAD_PARSING,&$error=null)
{
 $dom=new php4DOMDocument($mode);
 $errorMode=(func_num_args()>2)&&defined('LIBXML_VERSION');
 if ($errorMode) libxml_use_internal_errors(true);
 if (!$dom->myDOMNode->load($filename)) $dom=null;
 if ($errorMode)
 {
  $error=array_map('_error_report',libxml_get_errors());
  libxml_clear_errors();
 }
 return $dom;
}
function domxml_open_mem($str,$mode=DOMXML_LOAD_PARSING,&$error=null)
{
 $dom=new php4DOMDocument($mode);
 $errorMode=(func_num_args()>2)&&defined('LIBXML_VERSION');
 if ($errorMode) libxml_use_internal_errors(true);
 if (!$dom->myDOMNode->loadXML($str)) $dom=null;
 if ($errorMode)
 {
  $error=array_map('_error_report',libxml_get_errors());
  libxml_clear_errors();
 }
 return $dom;
}
function html_doc($html_doc,$from_file=false)
{
 $dom=new php4DOMDocument();
 if ($from_file) $result=$dom->myDOMNode->loadHTMLFile($html_doc);
 else $result=$dom->myDOMNode->loadHTML($html_doc);
 return $result ? $dom : null;
}
function html_doc_file($filename) {return html_doc($filename,true);}
function xmldoc($str) {return domxml_open_mem($str);}
function xmldocfile($filename) {return domxml_open_file($filename);}
function xpath_eval($xpath_context,$eval_str,$contextnode=null) {return $xpath_context->xpath_eval($eval_str,$contextnode);}
function xpath_new_context($dom_document) {return new php4DOMXPath($dom_document);}
function xpath_register_ns($xpath_context,$prefix,$namespaceURI) {return $xpath_context->myDOMXPath->registerNamespace($prefix,$namespaceURI);}
function _entityDecode($text) {return html_entity_decode(strtr($text,array('&apos;'=>'\'')),ENT_QUOTES,'UTF-8');}
function _error_report($error) {return array('errormessage'=>$error->message,'nodename'=>'','line'=>$error->line,'col'=>$error->column)+($error->file==''?array():array('directory'=>dirname($error->file),'file'=>basename($error->file)));}

class php4DOMAttr extends php4DOMNode
{
 function __isset($name)
 {
  if ($name==='name') return true;
  else return parent::__isset($name);
 }
 function __get($name)
 {
  if ($name==='name') return $this->myDOMNode->name;
  else return parent::__get($name);
 }
 function name() {return $this->myDOMNode->name;}
 function set_content($text) {}
 function specified() {return $this->myDOMNode->specified;}
 function value() {return $this->myDOMNode->value;}
}

class php4DOMDocument extends php4DOMNode
{
 function php4DOMDocument($mode=DOMXML_LOAD_PARSING)
 {
  $this->myDOMNode=new DOMDocument();
  $this->myOwnerDocument=$this;
  if ($mode & DOMXML_LOAD_VALIDATING) $this->myDOMNode->validateOnParse=true;
  if ($mode & DOMXML_LOAD_RECOVERING) $this->myDOMNode->recover=true;
  if ($mode & DOMXML_LOAD_SUBSTITUTE_ENTITIES) $this->myDOMNode->substituteEntities=true;
  if ($mode & DOMXML_LOAD_DONT_KEEP_BLANKS) $this->myDOMNode->preserveWhiteSpace=false;
 }
 function add_root($name)
 {
  if ($this->myDOMNode->hasChildNodes()) $this->myDOMNode->removeChild($this->myDOMNode->firstChild);
  return new php4DOMElement($this->myDOMNode->appendChild($this->myDOMNode->createElement($name)),$this->myOwnerDocument);
 }
 function create_attribute($name,$value)
 {
  $myAttr=$this->myDOMNode->createAttribute($name);
  $myAttr->value=htmlspecialchars($value,ENT_QUOTES);
  return new php4DOMAttr($myAttr,$this);
 }
 function create_cdata_section($content) {return new php4DOMNode($this->myDOMNode->createCDATASection($content),$this);}
 function create_comment($data) {return new php4DOMNode($this->myDOMNode->createComment($data),$this);}
 function create_element($name) {return new php4DOMElement($this->myDOMNode->createElement($name),$this);}
 function create_element_ns($uri,$name,$prefix=null)
 {
  if ($prefix==null) $prefix=$this->myDOMNode->lookupPrefix($uri);
  if (($prefix==null)&&(($this->myDOMNode->documentElement==null)||(!$this->myDOMNode->documentElement->isDefaultNamespace($uri)))) $prefix='a'.sprintf('%u',crc32($uri));
  return new php4DOMElement($this->myDOMNode->createElementNS($uri,$prefix==null ? $name : $prefix.':'.$name),$this);
 }
 function create_entity_reference($content) {return new php4DOMNode($this->myDOMNode->createEntityReference($content),$this);} //By Walter Ebert 2007-01-22
 function create_processing_instruction($target,$data=''){return new php4DomProcessingInstruction($this->myDOMNode->createProcessingInstruction($target,$data),$this);}
 function create_text_node($content) {return new php4DOMText($this->myDOMNode->createTextNode($content),$this);}
 function document_element() {return parent::_newDOMElement($this->myDOMNode->documentElement,$this);}
 function dump_file($filename,$compressionmode=false,$format=false)
 {
  $format0=$this->myDOMNode->formatOutput;
  $this->myDOMNode->formatOutput=$format;
  $res=$this->myDOMNode->save($filename);
  $this->myDOMNode->formatOutput=$format0;
  return $res;
 }
 function dump_mem($format=false,$encoding=false)
 {
  $format0=$this->myDOMNode->formatOutput;
  $this->myDOMNode->formatOutput=$format;
  $encoding0=$this->myDOMNode->encoding;
  if ($encoding) $this->myDOMNode->encoding=$encoding;
  $dump=$this->myDOMNode->saveXML();
  $this->myDOMNode->formatOutput=$format0;
  if ($encoding) $this->myDOMNode->encoding= $encoding0=='' ? 'UTF-8' : $encoding0; //UTF-8 is XML default encoding
  return $dump;
 }
 function free()
 {
  if ($this->myDOMNode->hasChildNodes()) $this->myDOMNode->removeChild($this->myDOMNode->firstChild);
  $this->myDOMNode=null;
  $this->myOwnerDocument=null;
 }
 function get_element_by_id($id) {return parent::_newDOMElement($this->myDOMNode->getElementById($id),$this);}
 function get_elements_by_tagname($name)
 {
  $myDOMNodeList=$this->myDOMNode->getElementsByTagName($name);
  $nodeSet=array();
  $i=0;
  if (isset($myDOMNodeList))
   while ($node=$myDOMNodeList->item($i++)) $nodeSet[]=new php4DOMElement($node,$this);
  return $nodeSet;
 }
 function html_dump_mem() {return $this->myDOMNode->saveHTML();}
 function root() {return parent::_newDOMElement($this->myDOMNode->documentElement,$this);}
 function xinclude() {return $this->myDOMNode->xinclude();}
 function xpath_new_context() {return new php4DOMXPath($this);}
}

class php4DOMElement extends php4DOMNode
{
 function add_namespace($uri,$prefix)
 {
  if ($this->myDOMNode->hasAttributeNS('http://www.w3.org/2000/xmlns/',$prefix)) return false;
  else
  {
   $this->myDOMNode->setAttributeNS('http://www.w3.org/2000/xmlns/','xmlns:'.$prefix,$uri);
   return true;
  }
 }
 function get_attribute($name) {return $this->myDOMNode->getAttribute($name);}
 function get_attribute_node($name) {return parent::_newDOMElement($this->myDOMNode->getAttributeNode($name),$this->myOwnerDocument);}
 function get_elements_by_tagname($name)
 {
  $myDOMNodeList=$this->myDOMNode->getElementsByTagName($name);
  $nodeSet=array();
  $i=0;
  if (isset($myDOMNodeList))
   while ($node=$myDOMNodeList->item($i++)) $nodeSet[]=new php4DOMElement($node,$this->myOwnerDocument);
  return $nodeSet;
 }
 function has_attribute($name) {return $this->myDOMNode->hasAttribute($name);}
 function remove_attribute($name) {return $this->myDOMNode->removeAttribute($name);}
 function set_attribute($name,$value)
 {
  $myAttr=$this->myDOMNode->ownerDocument->createAttribute($name);
  $myAttr->value=htmlspecialchars($value,ENT_QUOTES);
  $this->myDOMNode->setAttributeNode($myAttr);
  return new php4DOMAttr($myAttr,$this->myOwnerDocument);
 }
 function set_name($name)
 {
  if ($this->myDOMNode->prefix=='') $newNode=$this->myDOMNode->ownerDocument->createElement($name);
  else $newNode=$this->myDOMNode->ownerDocument->createElementNS($this->myDOMNode->namespaceURI,$this->myDOMNode->prefix.':'.$name);
  $myDOMNodeList=$this->myDOMNode->attributes;
  $i=0;
  if (isset($myDOMNodeList))
   while ($node=$myDOMNodeList->item($i++))
    if ($node->namespaceURI=='') $newNode->setAttribute($node->name,$node->value);
    else $newNode->setAttributeNS($node->namespaceURI,$node->nodeName,$node->value);
  $myDOMNodeList=$this->myDOMNode->childNodes;
  if (isset($myDOMNodeList))
   while ($node=$myDOMNodeList->item(0)) $newNode->appendChild($node);
  $this->myDOMNode->parentNode->replaceChild($newNode,$this->myDOMNode);
  $this->myDOMNode=$newNode;
  return true;
 }
 function tagname() {return $this->tagname;}
}

class php4DOMNode
{
 public $myDOMNode;
 public $myOwnerDocument;
 function php4DOMNode($aDomNode,$aOwnerDocument)
 {
  $this->myDOMNode=$aDomNode;
  $this->myOwnerDocument=$aOwnerDocument;
 }
 function __isset($name)
 {
  switch ($name)
  {
   case 'type':
   case 'tagname':
   case 'content':
   case 'value':
    return true;
   default:
    return false;
  }
 }
 function __get($name)
 {
  switch ($name)
  {
   case 'type': return $this->myDOMNode->nodeType;
   case 'tagname': case 'tagname': return ($this->myDOMNode->nodeType===XML_ELEMENT_NODE) ? $this->myDOMNode->localName : $this->myDOMNode->tagName; //Avoid namespace prefix for DOMElement
   case 'content': return $this->myDOMNode->textContent;
   case 'value': return $this->myDOMNode->value;
   default:
    $myErrors=debug_backtrace();
    trigger_error('Undefined property: '.get_class($this).'::$'.$name.' ['.$myErrors[0]['file'].':'.$myErrors[0]['line'].']',E_USER_NOTICE);
    return false;
  }
 }
 function add_child($newnode) {return $this->append_child($newnode);}
 function add_namespace($uri,$prefix) {return false;}
 function append_child($newnode) {return self::_newDOMElement($this->myDOMNode->appendChild($this->_importNode($newnode)),$this->myOwnerDocument);}
 function append_sibling($newnode) {return self::_newDOMElement($this->myDOMNode->parentNode->appendChild($this->_importNode($newnode)),$this->myOwnerDocument);}
 function attributes()
 {
  $myDOMNodeList=$this->myDOMNode->attributes;
  if (!(isset($myDOMNodeList)&&$this->myDOMNode->hasAttributes())) return null;
  $nodeSet=array();
  $i=0;
  while ($node=$myDOMNodeList->item($i++)) $nodeSet[]=new php4DOMAttr($node,$this->myOwnerDocument);
  return $nodeSet;
 }
 function child_nodes()
 {
  $myDOMNodeList=$this->myDOMNode->childNodes;
  $nodeSet=array();
  $i=0;
  if (isset($myDOMNodeList))
   while ($node=$myDOMNodeList->item($i++)) $nodeSet[]=self::_newDOMElement($node,$this->myOwnerDocument);
  return $nodeSet;
 }
 function children() {return $this->child_nodes();}
 function clone_node($deep=false) {return self::_newDOMElement($this->myDOMNode->cloneNode($deep),$this->myOwnerDocument);}
 function dump_node($node=null) {return $node==null ? $this->myOwnerDocument->myDOMNode->saveXML($this->myDOMNode) : $this->myOwnerDocument->myDOMNode->saveXML($node->myDOMNode);}
 function first_child() {return self::_newDOMElement($this->myDOMNode->firstChild,$this->myOwnerDocument);}
 function get_content() {return $this->myDOMNode->textContent;}
 function has_attributes() {return $this->myDOMNode->hasAttributes();}
 function has_child_nodes() {return $this->myDOMNode->hasChildNodes();}
 function insert_before($newnode,$refnode) {return self::_newDOMElement($this->myDOMNode->insertBefore($this->_importNode($newnode),$refnode==null?null:$refnode->myDOMNode),$this->myOwnerDocument);}
 function is_blank_node() {return ($this->myDOMNode->nodeType===XML_TEXT_NODE)&&preg_match('%^\s*$%',$this->myDOMNode->nodeValue);}
 function last_child() {return self::_newDOMElement($this->myDOMNode->lastChild,$this->myOwnerDocument);}
 function new_child($name,$content)
 {
  $mySubNode=$this->myDOMNode->ownerDocument->createElement($name);
  $mySubNode->appendChild($this->myDOMNode->ownerDocument->createTextNode(_entityDecode($content)));
  $this->myDOMNode->appendChild($mySubNode);
  return new php4DOMElement($mySubNode,$this->myOwnerDocument);
 }
 function next_sibling() {return self::_newDOMElement($this->myDOMNode->nextSibling,$this->myOwnerDocument);}
 function node_name() {return ($this->myDOMNode->nodeType===XML_ELEMENT_NODE) ? $this->myDOMNode->localName : $this->myDOMNode->nodeName;} //Avoid namespace prefix for DOMElement
 function node_type() {return $this->myDOMNode->nodeType;}
 function node_value() {return $this->myDOMNode->nodeValue;}
 function owner_document() {return $this->myOwnerDocument;}
 function parent() {return self::_newDOMElement($this->myDOMNode->parentNode,$this->myOwnerDocument);}
 function parent_node() {return self::_newDOMElement($this->myDOMNode->parentNode,$this->myOwnerDocument);}
 function prefix() {return $this->myDOMNode->prefix;}
 function previous_sibling() {return self::_newDOMElement($this->myDOMNode->previousSibling,$this->myOwnerDocument);}
 function remove_child($oldchild) {return self::_newDOMElement($this->myDOMNode->removeChild($oldchild->myDOMNode),$this->myOwnerDocument);}
 function replace_child($newnode,$oldnode) {return self::_newDOMElement($this->myDOMNode->replaceChild($this->_importNode($newnode),$oldnode->myDOMNode),$this->myOwnerDocument);}
 function replace_node($newnode) {return self::_newDOMElement($this->myDOMNode->parentNode->replaceChild($this->_importNode($newnode),$this->myDOMNode),$this->myOwnerDocument);}
 function set_content($text) {return $this->myDOMNode->appendChild($this->myDOMNode->ownerDocument->createTextNode(_entityDecode($text)));}
 function set_namespace($uri,$prefix=null)
 {//Contributions by Daniel Walker 2006-09-08
  $nsprefix=$this->myDOMNode->lookupPrefix($uri);
  if ($nsprefix==null)
  {
   $nsprefix= $prefix==null ? $nsprefix='a'.sprintf('%u',crc32($uri)) : $prefix;
   if ($this->myDOMNode->nodeType===XML_ATTRIBUTE_NODE)
   {
    if (($prefix!=null)&&$this->myDOMNode->ownerElement->hasAttributeNS('http://www.w3.org/2000/xmlns/',$nsprefix)&&
        ($this->myDOMNode->ownerElement->getAttributeNS('http://www.w3.org/2000/xmlns/',$nsprefix)!=$uri))
    {//Remove namespace
     $parent=$this->myDOMNode->ownerElement;
     $parent->removeAttributeNode($this->myDOMNode);
     $parent->setAttribute($this->myDOMNode->localName,$this->myDOMNode->nodeValue);
     $this->myDOMNode=$parent->getAttributeNode($this->myDOMNode->localName);
     return;
    }
    $this->myDOMNode->ownerElement->setAttributeNS('http://www.w3.org/2000/xmlns/','xmlns:'.$nsprefix,$uri);
   }
  }
  if ($this->myDOMNode->nodeType===XML_ATTRIBUTE_NODE)
  {
   $parent=$this->myDOMNode->ownerElement;
   $parent->removeAttributeNode($this->myDOMNode);
   $parent->setAttributeNS($uri,$nsprefix.':'.$this->myDOMNode->localName,$this->myDOMNode->nodeValue);
   $this->myDOMNode=$parent->getAttributeNodeNS($uri,$this->myDOMNode->localName);
  }
  elseif ($this->myDOMNode->nodeType===XML_ELEMENT_NODE)
  {
   $NewNode=$this->myDOMNode->ownerDocument->createElementNS($uri,$nsprefix.':'.$this->myDOMNode->localName);
   foreach ($this->myDOMNode->attributes as $n) $NewNode->appendChild($n->cloneNode(true));
   foreach ($this->myDOMNode->childNodes as $n) $NewNode->appendChild($n->cloneNode(true));
   $xpath=new DOMXPath($this->myDOMNode->ownerDocument);
   $myDOMNodeList=$xpath->query('namespace::*[name()!="xml"]',$this->myDOMNode); //Add old namespaces
   foreach ($myDOMNodeList as $n) $NewNode->setAttributeNS('http://www.w3.org/2000/xmlns/',$n->nodeName,$n->nodeValue); 
   $this->myDOMNode->parentNode->replaceChild($NewNode,$this->myDOMNode);
   $this->myDOMNode=$NewNode;
  }
 }
 function unlink_node()
 {
  if ($this->myDOMNode->parentNode!=null)
  {
   if ($this->myDOMNode->nodeType===XML_ATTRIBUTE_NODE) $this->myDOMNode->parentNode->removeAttributeNode($this->myDOMNode);
   else $this->myDOMNode->parentNode->removeChild($this->myDOMNode);
  }
 }
 //To import DOMNode from another DOMDocument
 protected function _importNode($newnode) {return $this->myOwnerDocument===$newnode->myOwnerDocument ? $newnode->myDOMNode : $this->myOwnerDocument->myDOMNode->importNode($newnode->myDOMNode,true);}
 static function _newDOMElement($aDOMNode,$aOwnerDocument)
 {//Check the PHP5 DOMNode before creating a new associated PHP4 DOMNode wrapper
  if ($aDOMNode==null) return null;
  switch ($aDOMNode->nodeType)
  {
   case XML_ELEMENT_NODE: return new php4DOMElement($aDOMNode,$aOwnerDocument);
   case XML_TEXT_NODE: return new php4DOMText($aDOMNode,$aOwnerDocument);
   case XML_ATTRIBUTE_NODE: return new php4DOMAttr($aDOMNode,$aOwnerDocument);
   case XML_PI_NODE: return new php4DomProcessingInstruction($aDOMNode,$aOwnerDocument);
   default: return new php4DOMNode($aDOMNode,$aOwnerDocument);
  }
 }
}

class php4DomProcessingInstruction extends php4DOMNode
{
 function data() {return $this->myDOMNode->data;}
 function target() {return $this->myDOMNode->target;}
}

class php4DOMText extends php4DOMNode
{
 function __isset($name)
 {
  if ($name==='tagname') return true;
  else return parent::__isset($name);
 }
 function __get($name)
 {
  if ($name==='tagname') return '#text';
  else return parent::__get($name);
 }
 function tagname() {return '#text';}
 function set_content($text) {$this->myDOMNode->nodeValue=$text; return true;}
}

if (!defined('XPATH_NODESET'))
{
 define('XPATH_UNDEFINED',0);
 define('XPATH_NODESET',1);
 define('XPATH_BOOLEAN',2);
 define('XPATH_NUMBER',3);
 define('XPATH_STRING',4);
}

class php4DOMNodelist
{
 private $myDOMNodelist;
 public $nodeset;
 public $type=XPATH_UNDEFINED;
 public $value;
 function php4DOMNodelist($aDOMNodelist,$aOwnerDocument)
 {
  if (!isset($aDOMNodelist)) return; 
  elseif (is_object($aDOMNodelist)||is_array($aDOMNodelist))
  {
   if ($aDOMNodelist->length>0)
   {
    $this->myDOMNodelist=$aDOMNodelist;
    $this->nodeset=array();
    if (isset($this->myDOMNodelist))
    {
     $this->type=XPATH_NODESET;
     $i=0;
     while ($node=$this->myDOMNodelist->item($i++)) $this->nodeset[]=php4DOMNode::_newDOMElement($node,$aOwnerDocument);
    }
   }
  }
  elseif (is_int($aDOMNodelist)||is_float($aDOMNodelist))
  {
    $this->type=XPATH_NUMBER;
    $this->value=$aDOMNodelist;
  }
  elseif (is_bool($aDOMNodelist))
  {
    $this->type=XPATH_BOOLEAN;
    $this->value=$aDOMNodelist;
  }
  elseif (is_string($aDOMNodelist))
  {
    $this->type=XPATH_STRING;
    $this->value=$aDOMNodelist;
  }
 }
}

class php4DOMXPath
{
 public $myDOMXPath;
 private $myOwnerDocument;
 function php4DOMXPath($dom_document)
 {
  $this->myOwnerDocument=$dom_document->myOwnerDocument;
  $this->myDOMXPath=new DOMXPath($this->myOwnerDocument->myDOMNode);
 }
 function xpath_eval($eval_str,$contextnode=null)
 {
  if (method_exists($this->myDOMXPath,'evaluate')) $xp=isset($contextnode->myDOMNode) ? $this->myDOMXPath->evaluate($eval_str,$contextnode->myDOMNode) : $this->myDOMXPath->evaluate($eval_str);
  else $xp=isset($contextnode->myDOMNode) ? $this->myDOMXPath->query($eval_str,$contextnode->myDOMNode) : $this->myDOMXPath->query($eval_str);
  $xp=new php4DOMNodelist($xp,$this->myOwnerDocument);
  return ($xp->type===XPATH_UNDEFINED) ? false : $xp;
 }
 function xpath_register_ns($prefix,$namespaceURI) {return $this->myDOMXPath->registerNamespace($prefix,$namespaceURI);}
}

if (extension_loaded('xsl'))
{//See also: http://alexandre.alapetite.fr/doc-alex/xslt-php4-php5/
 function domxml_xslt_stylesheet($xslstring) {return new php4DomXsltStylesheet(domxml_open_mem($xslstring));}
 function domxml_xslt_stylesheet_doc($dom_document) {return new php4DomXsltStylesheet($dom_document);}
 function domxml_xslt_stylesheet_file($xslfile) {return new php4DomXsltStylesheet(domxml_open_file($xslfile));}
 class php4DomXsltStylesheet
 {
  private $myxsltProcessor;
  function php4DomXsltStylesheet($dom_document)
  {
   $this->myxsltProcessor=new xsltProcessor();
   $this->myxsltProcessor->importStyleSheet($dom_document->myDOMNode);
  }
  function process($dom_document,$xslt_parameters=array(),$param_is_xpath=false)
  {
   foreach ($xslt_parameters as $param=>$value) $this->myxsltProcessor->setParameter('',$param,$value);
   $myphp4DOMDocument=new php4DOMDocument();
   $myphp4DOMDocument->myDOMNode=$this->myxsltProcessor->transformToDoc($dom_document->myDOMNode);
   return $myphp4DOMDocument;
  }
  function result_dump_file($dom_document,$filename)
  {
   $html=$dom_document->myDOMNode->saveHTML();
   file_put_contents($filename,$html);
   return $html;
  }
  function result_dump_mem($dom_document) {return $dom_document->myDOMNode->saveHTML();}
 }
}

History

1.23 2011-11-19
corrected: domxml_xslt_stylesheet(), domxml_xslt_stylesheet_file(), php4DomXsltStylesheet()
1.22 2011-07-04
corrected: compatibility isset(DomNode->*) on attributes
added: DomNode->parent() as alias of DomNode->parent_node()
1.21.2 2010-10-04
corrected: DomNode->add_child()
1.21.1 2009-03-13
modification: XPathContext->xpath_eval() better checks if it second parameter is valid
1.21 2008-12-05
added: DomDocument->xinclude()
1.20a 2008-11-06
Licence GNU/LGPL
1.20 2008-07-25
corrected: DomNode->attributes() to return null when there are no attributes
corrected: DomNode->tagname to return the localName without the namespace
corrected: XPathContext->xpath_eval() to return false when there is no result
1.19 2007-09-30
added: DomProcessingInstruction, DomDocument->create_processing_instruction()
corrected: DomElement->set_attribute(), DomNode->set_content(), better similarity with PHP4 for special characters < & > " ' and XML/HTML entities
corrected: take into account $mode parameter for domxml_open_file(), domxml_open_mem() functions
1.18 2007-07-15
added: DomNode->replace_node()
added: DOMText->set_content()
added: XPATH_BOOLEAN, XPATH_NUMBER, XPATH_STRING
modified: XPathContext->xpath_eval() to support XPath evaluations (returns XPATH_BOOLEAN, XPATH_NUMBER, XPATH_STRING). Requires PHP≥5.1.
corrected: Disable parameters $mode, $error not supported by PHP<5.1/libxml for the functions domxml_open_file(), domxml_open_mem()
corrected: DomDocument->create_element_ns() in the case of empty documents
1.17 2007-06-05
corrected: DomNode->replace_child()
1.16 2007-05-12
added: parameters $mode, $error in functions domxml_open_file(), domxml_open_mem(). Requires PHP≥5.1/libxml for error reports.
added: constants for $mode parameter: DOMXML_LOAD_PARSING, DOMXML_LOAD_VALIDATING, DOMXML_LOAD_RECOVERING, DOMXML_LOAD_SUBSTITUTE_ENTITIES, DOMXML_LOAD_DONT_KEEP_BLANKS
corrected: insert_before()
modified: a few optimisations with ===
1.15 2007-02-05
added: DomNode->unlink_node()
1.14 2007-01-23
added: DomDocument->create_entity_reference()
Thanks to Walter Ebert
1.13 2007-01-18
modification: DomDocument->create_element_ns() to avoid superfluous prefixes
1.12 2006-10-12
added: domxml_new_xmldoc(), xmldoc(), xmldocfile()
corrected: xpath_new_context()
1.11 2006-09-16
added: support for namespaces with DomDocument->create_element_ns(), DomNode->set_namespace(), DomNode->add_namespace()
Thanks to Daniel Walker
1.10.1 2006-08-20
corrected: DOMNode->insert_before()
1.10 2006-08-05
added: DomNode->add_child()
corrected: class attribute declaration with PHP5 object syntax
modification: DomNode->dump_node(), DomDocument->dump_node() to be E_STRICT compliant
1.9 2006-04-24
added: DomElement->set_name()
1.8 2006-03-17
added: html_doc(), html_doc_file(), XPATH_NODESET
modification: better handling of DOMText, optimisations
1.7.2 2005-09-08
modification: DomNode->is_blank_node()
1.7.1 2005-08-25
added: DomDocument->free(), DomDocument->xpath_new_context(), XPathContext->xpath_eval()
removed: XPathContext->query() which is not in PHP4/DOMXML. Replace by XPathContext->xpath_eval()
1.7 2005-08-09
added: DOMAttr->name, DOMAttr->value, xpath_register_ns()
modification: DomNode->new_child() to accept XML entities
modification: DomNode->set_content() to append text like PHP4/DOMXML does
corrected: DomDocument->dump_mem() to handle documents with no encoding specified (fall back to UTF-8)
corrected: DomNode->next_sibling(), DomNode->previous_sibling() to work with DomAttribute
corrected: xpath_eval() to handle DomAttribute
corrected: DomDocument->get_element_by_id(), DomNode->first_child(), DomNode->last_child(), DomNode->next_sibling(), DomNode->previous_sibling() to return null when the targeted node does not exist
1.6 2005-07-18
added: DomDocument->add_root()
1.5.10 2005-05-20
corrected: DomNode->dump_file(), DomNode->dump_mem() to use the optionals format, encoding parameters
1.5.9 2005-04-18
corrected: new DomDocument(), which is called by domxml_new_doc(), domxml_open_file(), domxml_open_mem(), DomXsltStylesheet->process()
1.5.8 2005-04-15
corrected: DomNode->node_name(), bug introduced version 1.5.5 for nodes that are not DOMElement
1.5.7 2005-04-12
corrected: supports importing from external documents for DomNode->append_child(), DomNode->append_sibling(), DomNode->replace_child()
1.5.6 2005-02-07
added: DomNode->dump_node(), DomDocument->dump_node()
1.5.5 2005-01-18
corrected: DomNode->node_name() to return the localName without the namespace
1.5.4 2004-12-10
added: DomNode->prefix()
1.5.3 2004-11-23
Creative Commons Licence, French version "CC BY-SA (FR)"
1.5.2 2004-10-29
added: DomNode->new_child(), DomNode->owner_document()
1.5.1 2004-09-15
added: domxml_xslt_stylesheet(), domxml_xslt_stylesheet_doc(), domxml_xslt_stylesheet_file(), DomXsltStylesheet->process(), DomXsltStylesheet->result_dump_file(), DomXsltStylesheet->result_dump_mem()
1.5 2004-09-12
1.4.4 2004-09-08
added: DomDocument->get_element_by_id(), DomNode->children(), DomNode->type, DomNode->tagname, DomNode->content
1.4.2 2004-09-07
added: DomDocument->root()
1.4 2004-08-12
corrected: xpath_eval()
1.3.1 2004-08-10
corrected: DomNode->set_content()
1.3 2004-08-10
added: domxml_new_doc(), domxml_open_mem()
modified: DomDocument
1.2 2004-07-29
added: DomNode->is_blank_node()
1.1 2004-07-13
added: DomNode->attributes(), DomNode->clone_node(), DomNode->node_name(), DomNode->set_content()
corrected: DomElement->tagname()
1.0 2004-07-04
Initial release

Licence

This library is published under the terms of the GNU Lesser General Public License [GNU LGPL License]

If you use and like this library (especially for professional purposes), please consider making a donation.


Acknowledgements

I wish to thank the many people who gave feedback, suggestions and corrections.


Comments

If you expect an answer or if it is to report a problem, please contact me by e-mail, including when possible an example of a minimal script that works with PHP4/domxml.

object: View comments

http://alexandre.alapetite.fr

Back