par Alexandre Alapetite le 2004-07-04 ; mise à jour 2011-11-19

Transition du XML de PHP4 `domxml` à PHP5 `dom`

Lors de l’évolution de PHP4 à PHP5, un certain nombre de modifications sont nécessaires dans les scripts. En PHP4, pour gérer du XML, il fallait utiliser l’extension domxml, qui était expérimentale. En PHP5, cette extension a été remplacée par l’extension dom.

La migration du code de PHP4 à PHP5 ne pose pas de difficultés, mais peut être longue si domxml a été largement utilisé. De plus, afin de faire une transition en douceur, il est souhaitable que les scripts soient le plus vite possible compatibles PHP5 alors même que le serveur tourne encore en PHP4. L’optimisation des scripts pour PHP5 pourra se faire plus tard.

Je propose sur cette page un module à inclure dans vos scripts PHP4/domxml, pour assurer la compatibilité vers PHP5/dom ou PHP6/dom.

Pour XSLT/XSL, regardez ma page PHP4/XSLT vers PHP5/XSL.

Sommaire

Introduction
Sommaire
Scripts PHP4 domxml compatibles PHP5 dom
- Historique
Licence
Remerciements
Commentaires

Quitter

Scripts PHP4 `domxml` compatibles PHP5 `dom`

Afin de faire marcher vos scripts PHP4 utilisant domxml sur un serveur migrant vers PHP5, il vous suffit d’inclure le fichier domxml-php4-to-php5.php dans vos sources PHP4 de cette manière :

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

Téléchargez domxml-php4-to-php5.php (1.23 2011-11-19)

Notez que cela ne modifie rien aux scripts lorsque le serveur est encore avec PHP4.
Les fonctionnalités les plus courantes de domxml sont supportées, mais pas son ensemble. Cela peut néanmoins facilement être étendu si nécessaire.
Ci-dessous, un exemple puis le code du fichier assurant la compatibilité.

exemple-php4.php

<?php
//Code PHP4 utilisant l’extension domxml
//On veut le faire marcher sous PHP5 avec dom
if (PHP_VERSION>='5')
 require_once('domxml-php4-to-php5.php'); //Charge le convertisseur si PHP5
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('un nouveau paragraphe'));
  $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
/*
 Pour être utilisé dans des scripts PHP4 utilisant l’extension DOMXML
 Permet aux scripts PHP4/DOMXML de fonctionner avec PHP5/DOM.
 Nécessite PHP5, utilise l’extension DOM (activée par défaut),
  utilise l’extension PHP5/XSL (inclue dans PHP5) pour les fonctions domxml_xslt,
  nécessite PHP>=5.1 pour le support complet des évaluations XPath,
  nécessite PHP>=5.1/libxml pour les rapports d’erreur DOMXML.
 https://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);} //Par Walter Ebert le 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 est l’encodage XML par défaut
  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; //Évite préfixe espace de nom pour 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;} //Évite préfixe espace de nom pour 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)
 {//Avec des contributions de Daniel Walker le 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))
    {//Supprime l’espace de nommage
     $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); //Ajoute les anciens espaces de nommage
   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);
  }
 }
 //Pour importer un DOMNode d’un autre DOMDocument
 protected function _importNode($newnode) {return $this->myOwnerDocument===$newnode->myOwnerDocument ? $newnode->myDOMNode : $this->myOwnerDocument->myDOMNode->importNode($newnode->myDOMNode,true);}
 static function _newDOMElement($aDOMNode,$aOwnerDocument)
 {//Pour vérifier le DOMNode PHP5 avant d’y associer une enveloppe DOMNode PHP4
  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'))
{//Voir aussi : https://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();}
 }
}

Historique

1.23 2011-11-19: correction : domxml_xslt_stylesheet(), domxml_xslt_stylesheet_file(), php4DomXsltStylesheet()
1.22 2011-07-04: correction : compatibilité isset(DomNode->*) sur les attributs; ajout : DomNode->parent() comme alias de DomNode->parent_node()
1.21.2 2010-10-04: correction : DomNode->add_child()
1.21.1 2009-03-13: modification : XPathContext->xpath_eval() vérifie mieux si le second paramètre est valide
1.21 2008-12-05: ajout : DomDocument->xinclude()
1.20a 2008-11-06: Licence GNU/LGPL
1.20 2008-07-25: correction : DomNode->attributes() retourne null quand il n’y a pas d’attributs; correction : DomNode->tagname retourne localName sans l’espace de nom; correction : XPathContext->xpath_eval() retourne false quand il n’y a pas de résultat
1.19 2007-09-30: ajout : DomProcessingInstruction, DomDocument->create_processing_instruction(); correction : DomElement->set_attribute(), DomNode->set_content(), meilleure similitude avec PHP4 pour les caractères spéciaux < & > " ' et des entités XML/HTML; correction : prise en compte du paramètre $mode pour les fonctions domxml_open_file(), domxml_open_mem()
1.18 2007-07-15: ajout : DomNode->replace_node(); ajout : DOMText->set_content(); ajout : XPATH_BOOLEAN, XPATH_NUMBER, XPATH_STRING; modification : XPathContext->xpath_eval() pour supporter les évaluations XPath (retourne XPATH_BOOLEAN, XPATH_NUMBER, XPATH_STRING). Nécessite PHP≥5.1.; correction : Désactive les paramètres $mode, $error non supportés par PHP<5.1/libxml pour les fonctions domxml_open_file(), domxml_open_mem(); correction : DomDocument->create_element_ns() dans le cas de documents vides
1.17 2007-06-05: correction : DomNode->replace_child()
1.16 2007-05-12: ajout : paramètres $mode, $error pour les fonctions domxml_open_file(), domxml_open_mem(). Nécessite PHP≥5.1/libxml pour les rapports d’erreurs.; ajout : constantes pour le paramètre $mode : DOMXML_LOAD_PARSING, DOMXML_LOAD_VALIDATING, DOMXML_LOAD_RECOVERING, DOMXML_LOAD_SUBSTITUTE_ENTITIES, DOMXML_LOAD_DONT_KEEP_BLANKS; correction : insert_before(); modification : quelques optimisations avec ===
1.15 2007-02-05: ajout : DomNode->unlink_node()
1.14 2007-01-23: ajout : DomDocument->create_entity_reference(); Merci à Walter Ebert
1.13 2007-01-18: modification : DomDocument->create_element_ns() pour éviter des préfixes superflus
1.12 2006-10-12: ajout : domxml_new_xmldoc(), xmldoc(), xmldocfile(); correction : xpath_new_context()
1.11 2006-09-16: ajout : support des espaces de nommage avec DomDocument->create_element_ns(), DomNode->set_namespace(), DomNode->add_namespace(); Merci à Daniel Walker
1.10.1 2006-08-20: correction : DOMNode->insert_before()
1.10 2006-08-05: ajout : DomNode->add_child(); correction : déclaration des attributs de classes selon la syntaxe objet PHP5; modification : DomNode->dump_node(), DomDocument->dump_node() pour être compatible E_STRICT
1.9 2006-04-24: ajout : DomElement->set_name()
1.8 2006-03-17: ajouts : html_doc(), html_doc_file(), XPATH_NODESET; modification : Meilleur support de DOMText, optimisations
1.7.2 2005-09-08: modification : DomNode->is_blank_node()
1.7.1 2005-08-25: ajout : DomDocument->free(), DomDocument->xpath_new_context(), XPathContext->xpath_eval(); supprimé : XPathContext->query() qui n’est pas dans PHP4/DOMXML. Remplacé par XPathContext->xpath_eval()
1.7 2005-08-09: ajout : DOMAttr->name, DOMAttr->value, xpath_register_ns(); modification : DomNode->new_child() pour accepter les entités XML entities; modification : DomNode->set_content() pour ajouter le texte, comme PHP4/DOMXML; correction : DomDocument->dump_mem() pour tolérer les documents sans encodage spécifié (utilise UTF-8); correction : DomNode->next_sibling(), DomNode->previous_sibling() pour fonctionner aussi avec DomAttribute; correction : xpath_eval() pour pouvoir retourner des DomAttribute; correction : DomDocument->get_element_by_id(), DomNode->first_child(), DomNode->last_child(), DomNode->next_sibling(), DomNode->previous_sibling() pour renvoyer null quand le noeud ciblé n’existe pas
1.6 2005-07-18: ajout : DomDocument->add_root()
1.5.10 2005-05-20: correction : DomNode->dump_file(), DomNode->dump_mem() pour utiliser les paramètres format, encoding optionnels
1.5.9 2005-04-18: correction : new DomDocument(), qui est invoqué par domxml_new_doc(), domxml_open_file(), domxml_open_mem(), DomXsltStylesheet->process()
1.5.8 2005-04-15: correction : DomNode->node_name(), bogue introduit version 1.5.5 pour les nœuds autres que DOMElement
1.5.7 2005-04-12: corrections : supporte l’import depuis des documents externes pour DomNode->append_child(), DomNode->append_sibling(), DomNode->replace_child()
1.5.6 2005-02-07: ajout : DomNode->dump_node(), DomDocument->dump_node()
1.5.5 2005-01-18: modification : DomNode->node_name() pour retourner le nom local localName sans l’espace de noms
1.5.4 2004-12-10: ajout : DomNode->prefix()
1.5.3 2004-11-23: licence Creative Commons version française "CC BY-SA (FR)"
1.5.2 2004-10-29: ajout : DomNode->new_child(), DomNode->owner_document()
1.5.1 2004-09-15: ajouts : 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: ajouts : DomDocument->get_element_by_id(), DomNode->children(), DomNode->type, DomNode->tagname, DomNode->content
1.4.2 2004-09-07: ajout : DomDocument->root()
1.4 2004-08-12: corrections : xpath_eval()
1.3.1 2004-08-10: corrections : DomNode->set_content()
1.3 2004-08-10: ajouts : domxml_new_doc(), domxml_open_mem(); modifications : DomDocument
1.2 2004-07-29: ajout : DomNode->is_blank_node()
1.1 2004-07-13: ajouts : DomNode->attributes(), DomNode->clone_node(), DomNode->node_name(), DomNode->set_content(); corrections : DomElement->tagname()
1.0 2004-07-04: distribution initiale

Licence

Cette librarie est publiée sous licence publique générale limitée GNU [GNU LGPL licence]

Si vous utilisez et aimez ce logiciel (surtout pour un usage professionnel), merci de considérer faire un don.

Remerciements

Je tiens à remercier les nombreuses personnes ayant fait des commentaires, suggestions et corrections.

Commentaires

Si vous souhaitez une réponse ou si c’est pour rapporter un problème avec cette librairie, merci de me contacter par courriel, en incluant si possible un exemple de script minimal qui fonctionne sous PHP4/domxml.

Postez vos commentaires. - (Multilingue français, danois, anglais) - (Puis rafraîchir si vous ne voyez pas votre message)

Voir uniquement les commentaires

https://alexandre.alapetite.fr

Retour

Transition du XML de PHP4 domxml à PHP5 dom