<?php 
$file = "http://www.informatik-forum.at/external.php?type=XML";
$stack = array();


// start_element_handler ( resource parser, string name, array attribs )
function startElement($parser, $name, $attribs)
{
   global $stack;
   $tag=array("name"=>$name,"attrs"=>$attrs);
   array_push($stack,$tag);
}


// end_element_handler ( resource parser, string name )
function endElement($parser, $name)
{
   global $stack;
   $stack[count($stack)-2]['children'][] = $stack[count($stack)-1];
   array_pop($stack);
}


// handler ( resource parser, string data )
function characterData($parser, $data)
{
   global $stack,$i;


   if(trim($data))
   { 
             $stack[count($stack)-1]['data'] .= $data; 
   }
}


// handler ( resource parser, string target, string data )
function PIHandler($parser, $target, $data)
{
global $stack,$i;
//PHP EVALUATION
   if ((strtolower($target)) == "php") {
           global $parser_file;
         //eval($data);  gust doesn't work if you want the
         //string added to the array
         $text .= '<?php '.$data.' ?>'; 
         ob_start();
           eval ('?>' . $text);
           $text = ob_get_clean();
           $stack[count($stack)-1]['data'] .= $text;

   }

}


function defaultHandler($parser, $data)
{

}


function externalEntityRefHandler($parser, $openEntityNames, $base, $systemId,
                                 $publicId) {
   if ($systemId) {
       if (!list($parser, $fp) = new_xml_parser($systemId)) {
           printf("Could not open entity %s at %s\n", $openEntityNames,
                   $systemId);
           return false;
       }
       while ($data = fread($fp, 4096)) {
           if (!xml_parse($parser, $data, feof($fp))) {
               printf("XML error: %s at line %d while parsing entity %s\n",
                       xml_error_string(xml_get_error_code($parser)),
                       xml_get_current_line_number($parser), $openEntityNames);
               xml_parser_free($parser);
               return false;
           }
       }
       xml_parser_free($parser);
       return true;
   }
   return false;
}


function new_xml_parser($file)
{
   global $parser_file;
   $xml_parser = xml_parser_create();

   xml_parser_set_option($xml_parser, XML_OPTION_CASE_FOLDING, 0);

   xml_set_processing_instruction_handler($xml_parser, "PIHandler");

   xml_set_element_handler($xml_parser, "startElement", "endElement");

   xml_set_character_data_handler($xml_parser, "characterData");

   xml_set_default_handler($xml_parser, "defaultHandler");

   xml_set_external_entity_ref_handler($xml_parser, "externalEntityRefHandler");
 
   if (!($fp = @fopen($file, "r"))) {
       return false;
   }
   if (!is_array($parser_file)) {
       settype($parser_file, "array");
   }
   $parser_file[$xml_parser] = $file;
   return array($xml_parser, $fp);
}


if (!(list($xml_parser, $fp) = new_xml_parser($file))) {
   die("could not open XML input");
}


//ERROR
while ($data = fread($fp, 4096)) {
   if (!xml_parse($xml_parser, $data, feof($fp))) {
       die(sprintf("XML error: %s at line %d\n",
                   xml_error_string(xml_get_error_code($xml_parser)),
                   xml_get_current_line_number($xml_parser)));
   }
}
//END
xml_parser_free($xml_parser);
print_r($stack); 
?>

<?php
require_once 'XML/Parser.php';


class myParser extends XML_Parser
{
  function myParser()
  {
    parent::XML_Parser();
  }


 /**
  * handle start element
  *
  * @access private
  * @param  resource  xml parser resource
  * @param  string    name of the element
  * @param  array     attributes
  */
  function startHandler($xp, $name, $attribs)
  {
    printf('handle start tag: %s<br />', $name);
  }


 /**
  * handle start element
  *
  * @access private
  * @param  resource  xml parser resource
  * @param  string    name of the element
  */
  function endHandler($xp, $name)
  {
    printf('handle end tag: %s<br />', $name);
  }


 /**
  * handle character data
  *
  * @access private
  * @param  resource  xml parser resource
  * @param  string    character data
  */
  function cdataHandler($xp, $cdata)
  {
    // does nothing here, but might e.g. print $cdata
  }
}


$p = &new myParser();


$result = $p->setInputFile('xml_parser_file.xml');
$result = $p->parse();
?>

<?php


class XMLParser {
   var $filename;
   var $xml;
   var $data;

   function XMLParser($xml_file)
   {
       $this->filename = $xml_file;
       $this->xml = xml_parser_create();
       xml_set_object($this->xml, $this);
       xml_set_element_handler($this->xml, 'startHandler', 'endHandler');
       xml_set_character_data_handler($this->xml, 'dataHandler');
       $this->parse($xml_file);
   }

   function parse($xml_file)
   {
       if (!($fp = fopen($xml_file, 'r'))) {
             die('Cannot open XML data file: '.$xml_file);
               return false;
       }


       $bytes_to_parse = 512;


       while ($data = fread($fp, $bytes_to_parse)) {
           $parse = xml_parse($this->xml, $data, feof($fp));

           if (!$parse) {
               die(sprintf("XML error: %s at line %d",
                   xml_error_string(xml_get_error_code($this->xml)),
                       xml_get_current_line_number($this->xml)));
                       xml_parser_free($this->xml
                     );
           }
       }


       return true;
   }

   function startHandler($parser, $name, $attributes)
   {
       $data['name'] = $name;
       if ($attributes) { $data['attributes'] = $attributes; }
       $this->data[] = $data;
   }


   function dataHandler($parser, $data)
   {
       if ($data = trim($data)) {
           $index = count($this->data) - 1;
           // begin multi-line bug fix (use the .= operator)
           $this->data[$index]['content'] .= $data;
           // end multi-line bug fix
       }
   }


   function endHandler($parser, $name)
   {
       if (count($this->data) > 1) {
           $data = array_pop($this->data);
           $index = count($this->data) - 1;
           $this->data[$index]['child'][] = $data;
       }
   }
}


?>