function AbstractSAXParser()
 {
     // create a parser
     $this->parserResource = xml_parser_create();
     if (isset($this->parserResource)) {
         // allowing object instance to use the xml parser
         xml_set_object($this->parserResource, $this);
         // set tag event handler
         xml_set_element_handler($this->parserResource, "startTagElement", "endTagElement");
         // set CDATA event handler
         xml_set_character_data_handler($this->parserResource, "cdataElement");
         // set processing instruction handler
         xml_set_processing_instruction_handler($this->parserResource, "instructionElement");
         // set undeclare entity
         xml_set_unparsed_entity_decl_handler($this->parserResource, "undeclaredEntityElement");
         // set notation delcaration handler
         xml_set_notation_decl_handler($this->parserResource, "notationDeclarationElement");
         // set external entity handler
         xml_set_external_entity_ref_handler($this->parserResource, "externalEntityElement");
         // seat default parser option
         xml_parser_set_option($this->parserResource, XML_OPTION_SKIP_WHITE, 1);
         xml_parser_set_option($this->parserResource, XML_OPTION_CASE_FOLDING, 0);
         xml_parser_set_option($this->parserResource, XML_OPTION_TARGET_ENCODING, 'UTF-8');
     }
 }

 public function __construct($input, $maxDepth = 20)
 {
     if (!is_string($input)) {
         throw new XmlToArrayException('No valid input.');
     }
     $this->_maxDepth = $maxDepth;
     $XMLParser = xml_parser_create();
     xml_parser_set_option($XMLParser, XML_OPTION_SKIP_WHITE, false);
     xml_parser_set_option($XMLParser, XML_OPTION_CASE_FOLDING, false);
     xml_parser_set_option($XMLParser, XML_OPTION_TARGET_ENCODING, 'UTF-8');
     xml_set_character_data_handler($XMLParser, array($this, '_contents'));
     xml_set_default_handler($XMLParser, array($this, '_default'));
     xml_set_element_handler($XMLParser, array($this, '_start'), array($this, '_end'));
     xml_set_external_entity_ref_handler($XMLParser, array($this, '_externalEntity'));
     xml_set_notation_decl_handler($XMLParser, array($this, '_notationDecl'));
     xml_set_processing_instruction_handler($XMLParser, array($this, '_processingInstruction'));
     xml_set_unparsed_entity_decl_handler($XMLParser, array($this, '_unparsedEntityDecl'));
     if (!xml_parse($XMLParser, $input, true)) {
         $errorCode = xml_get_error_code($XMLParser);
         $message = sprintf('%s. line: %d, char: %d' . ($this->_tagStack ? ', tag: %s' : ''), xml_error_string($errorCode), xml_get_current_line_number($XMLParser), xml_get_current_column_number($XMLParser) + 1, implode('->', $this->_tagStack));
         xml_parser_free($XMLParser);
         throw new XmlToArrayException($message, $errorCode);
     }
     xml_parser_free($XMLParser);
 }

 function SaxParser(&$input)
 {
     $this->level = 0;
     $this->parser = xml_parser_create('UTF-8');
     xml_set_object($this->parser, $this);
     $this->input =& $input;
     $this->setCaseFolding(false);
     $this->useUtfEncoding();
     xml_set_element_handler($this->parser, 'handleBeginElement', 'handleEndElement');
     xml_set_character_data_handler($this->parser, 'handleCharacterData');
     xml_set_processing_instruction_handler($this->parser, 'handleProcessingInstruction');
     xml_set_default_handler($this->parser, 'handleDefault');
     xml_set_unparsed_entity_decl_handler($this->parser, 'handleUnparsedEntityDecl');
     xml_set_notation_decl_handler($this->parser, 'handleNotationDecl');
     xml_set_external_entity_ref_handler($this->parser, 'handleExternalEntityRef');
 }

 /**
  * Take the input $xml and turn it into WBXML. This is _not_ the
  * intended way of using this class. It is derived from
  * Contenthandler and one should use it as a ContentHandler and
  * produce the XML-structure with startElement(), endElement(),
  * and characters().
  *
  * @throws Horde_Xml_Wbxml_Exception
  */
 public function encode($xml)
 {
     // Create the XML parser and set method references.
     $this->_parser = xml_parser_create_ns($this->_charset);
     xml_set_object($this->_parser, $this);
     xml_parser_set_option($this->_parser, XML_OPTION_CASE_FOLDING, false);
     xml_set_element_handler($this->_parser, '_startElement', '_endElement');
     xml_set_character_data_handler($this->_parser, '_characters');
     xml_set_processing_instruction_handler($this->_parser, '');
     xml_set_external_entity_ref_handler($this->_parser, '');
     if (!xml_parse($this->_parser, $xml)) {
         throw new Horde_Xml_Wbxml_Exception(sprintf('XML error: %s at line %d', xml_error_string(xml_get_error_code($this->_parser)), xml_get_current_line_number($this->_parser)));
     }
     xml_parser_free($this->_parser);
     return $this->_output;
 }

 protected final function init()
 {
     if ($this instanceof Features\IXmlNamespaceParser) {
         $this->parser = xml_parser_create_ns('UTF-8');
         // Set up start namespace declaration handler
         xml_set_start_namespace_decl_handler($this->parser, 'ns_start');
         // Set up end namespace declaration handler
         xml_set_end_namespace_decl_handler($this->parser, 'ns_end');
     } elseif ($this instanceof Features\IXmlBasicParser) {
         $this->parser = xml_parser_create('UTF-8');
     } else {
         throw new \BadMethodCallException('This class does not implements the XML Parser capabilities. Please implement either IXmlBasicParser or IXmlNamespaceParser.');
     }
     xml_set_object($this->parser, $this);
     foreach ($this->options as $option => $value) {
         xml_parser_set_option($this->parser, $option, $value);
     }
     if ($this instanceof Features\IXmlProcessorParser) {
         // Set up processing instruction (PI) handler
         xml_set_processing_instruction_handler($this->parser, 'pi_handler');
     }
     if ($this instanceof Features\IXmlEntityHandler) {
         // Set up external entity reference handler
         xml_set_external_entity_ref_handler($this->parser, 'entity_handler');
     }
     if ($this instanceof Features\IXmlNdataHandler) {
         // Set up notation declaration handler
         xml_set_notation_decl_handler($this->parser, 'notation_handler');
         // Set up unparsed entity declaration handler
         xml_set_unparsed_entity_decl_handler($this->parser, 'ndata_handler');
     }
     xml_set_element_handler($this->parser, "element_start", "element_end");
     xml_set_character_data_handler($this->parser, "cdata_handler");
     if ($this instanceof Features\IXmlDefaultHandler) {
         if (!defined('ACTIVATE_XML_PARSER_DEFAULT_HANDLER_I_KNOW_WHAT_AM_I_DOING')) {
             trigger_error('Active default handler interferes with many XML features like internal parsable entities.', E_USER_WARNING);
         }
         // Set up default (fallback) handler.
         // Warning: Interferes with INTERNAL ENTITY declarations like
         // <!ENTITY a 'b'>
         xml_set_default_handler($this->parser, "default_handler");
     }
 }

 function runtest($num, $i)
 {
     $this->readfile($num);
     echo "parsing xml data file {$this->currentFile} iteration {$i}\n";
     $xml_parser = xml_parser_create();
     xml_parser_set_option($xml_parser, XML_OPTION_CASE_FOLDING, 1);
     xml_set_object($xml_parser, $this);
     xml_set_element_handler($xml_parser, 'startElement', 'endElement');
     xml_set_character_data_handler($xml_parser, 'cDataHandler');
     xml_set_external_entity_ref_handler($xml_parser, 'externalEntityRefHandler');
     xml_set_processing_instruction_handler($xml_parser, 'piHandler');
     xml_set_unparsed_entity_decl_handler($xml_parser, 'unparsedEntityDeclHandler');
     xml_set_notation_decl_handler($xml_parser, 'entityDeclHandler');
     xml_set_default_handler($xml_parser, 'defaultHandler');
     if (!xml_parse($xml_parser, $this->contentBuffer, true)) {
         $this->currentFile != '' ? $inFile = "in file {$this->currentFile}" : ($inFile = '');
         $this->fatalErrorPage(sprintf(get_class($this) . ": XML error: %s at line %d {$inFile}", xml_error_string(xml_get_error_code($xml_parser)), xml_get_current_line_number($xml_parser)));
     }
     xml_parser_free($xml_parser);
 }

 function read_quizfile($filename = "")
 {
     if (strlen($filename)) {
         $this->file = $filename;
     } else {
         if (isset($this->file)) {
             $filename = $this->file;
         } else {
             return "No file specified!";
         }
     }
     $data = @implode("", @file($filename));
     if (!strlen($data)) {
         return "Can't read file {$filename}.";
     }
     $parser = xml_parser_create();
     xml_parser_set_option($parser, XML_OPTION_CASE_FOLDING, 0);
     xml_parser_set_option($parser, XML_OPTION_SKIP_WHITE, 1);
     xml_set_external_entity_ref_handler($parser, "");
     xml_parse_into_struct($parser, $data, $values, $tags);
     if (xml_get_error_code($parser) != XML_ERROR_NONE) {
         return xml_error_string(xml_get_error_code($parser));
     }
     xml_parser_free($parser);
     // loop through the structures
     $num = 0;
     foreach ($tags as $tag => $indizes) {
         if ($this->tags[$tag]) {
             // wenn questionset
             for ($x = 0; $x < count($indizes); $x += 2) {
                 // ID und Sprache setzen
                 $this->init_quizfile_data($values[$indizes[$x]]);
                 // Titel, Abstrakt und Editor setzen
                 $in = array($indizes[$x], $indizes[$x + 1]);
                 $this->get_quizfile_data($in, $values);
             }
         }
     }
     return "ok";
 }

 /**
  * create a parser
  *
  * @return	object	$parser
  */
 function createParser()
 {
     //	init XML Parser
     $parser = xml_parser_create($this->configObj->encoding);
     xml_set_object($parser, $this);
     if (version_compare(phpversion(), '5.0.0b') == -1) {
         xml_set_element_handler($parser, 'startElement', 'endElement');
         xml_set_character_data_handler($parser, 'characterData');
         xml_set_external_entity_ref_handler($parser, 'externalEntity');
     } else {
         xml_set_element_handler($parser, array($this, 'startElement'), array($this, 'endElement'));
         xml_set_character_data_handler($parser, array($this, 'characterData'));
         xml_set_external_entity_ref_handler($parser, array($this, 'externalEntity'));
     }
     xml_parser_set_option($parser, XML_OPTION_CASE_FOLDING, false);
     return $parser;
 }

    print "external: [{$names}] [{$sysid}] [{$pubid}]\n";
}
function notation($parser, $name, $base, $sysid, $pubid)
{
    print "notation: [{$names}] [{$sysid}] [{$pubid}]\n";
}
function pi_h($parser, $target, $data)
{
    print "pi: [{$target}] [{$data}]";
}
function unparsed($parser, $name, $base, $sysid, $pubid, $notation)
{
    print "unparsed: [{$names}] [{$sysid}] [{$pubid}] [{$notation}]\n";
}
$xml_parser = xml_parser_create();
xml_set_element_handler($xml_parser, 'startElement', 'endElement');
xml_set_character_data_handler($xml_parser, 'cdata');
xml_set_default_handler($xml_parser, 'default_h');
xml_set_external_entity_ref_handler($xml_parser, 'ext_ent');
xml_set_notation_decl_handler($xml_parser, 'notation');
xml_set_processing_instruction_handler($xml_parser, 'pi_h');
xml_set_unparsed_entity_decl_handler($xml_parser, 'unparsed');
if (!($fp = fopen($file, "r"))) {
    die("could not open XML input");
}
while ($data = fread($fp, 4096)) {
    if (!xml_parse($xml_parser, $data, feof($fp))) {
        die(sprintf("XML error: %s at line %d", xml_error_string(xml_get_error_code($xml_parser)), xml_get_current_line_number($xml_parser)));
    }
}
xml_parser_free($xml_parser);

 /**
  * Resets internal XML Parser instance
  */
 protected function resetParser()
 {
     if (is_resource($this->parser)) {
         xml_parser_free($this->parser);
         $this->parser = null;
     }
     $this->documentNode = null;
     $this->nodeStack = array(new $this->params['nodeClass'](VIVVO_XML_DOCUMENT_NODE));
     $this->parser = xml_parser_create($this->params['encoding']);
     xml_parser_set_option($this->parser, XML_OPTION_SKIP_WHITE, 1);
     xml_parser_set_option($this->parser, XML_OPTION_CASE_FOLDING, 0);
     xml_set_element_handler($this->parser, array(&$this, 'handlerNodeStart'), array(&$this, 'handlerNodeEnd'));
     xml_set_character_data_handler($this->parser, array(&$this, 'handlerTextNode'));
     xml_set_default_handler($this->parser, array(&$this, 'handlerDefault'));
     xml_set_end_namespace_decl_handler($this->parser, false);
     xml_set_external_entity_ref_handler($this->parser, false);
     xml_set_notation_decl_handler($this->parser, false);
     xml_set_processing_instruction_handler($this->parser, false);
     xml_set_start_namespace_decl_handler($this->parser, false);
     xml_set_unparsed_entity_decl_handler($this->parser, false);
     VivvoXMLNode::$counter = 0;
 }

 /**
  *  Register this class with a parser
  *
  *  @param string $namespace (optional)
  *  @param string $encoding (optional) default into to autodetect based on env
  *  @param string $separator (optional) the seperator to use for namespace
  *  @return resource the parser
  */
 public function register($encoding = '', $namespace = false, $separator = null)
 {
     if ($this->parser === null) {
         if ($namespace !== null) {
             $this->parser = xml_parser_create_ns($encoding, $separator);
         } else {
             $this->parser = xml_parser_create($encoding);
         }
         if (!$this->parser) {
             throw new RegisterParserFailure('call to xml_parser_create() failed');
         }
         # set element handler
         xml_set_element_handler($this->parser, array($this, "xmlStartTag"), array($this, "xmlEndTag"));
         # set CDATA hander
         xml_set_character_data_handler($this->parser, array($this, "xmlTagContent"));
         # set processing instructions handler
         xml_set_processing_instruction_handler($this->parser, array($this, "xmlPI"));
         # set the unparsed entity declaration handler
         xml_set_unparsed_entity_decl_handler($this->parser, array($this, "xmlUnparsedEntity"));
         # set the notation declaration handler function
         xml_set_notation_decl_handler($this->parser, array($this, "xmlNotation"));
         # set the external entity reference handler function
         xml_set_external_entity_ref_handler($this->parser, array($this, "xmlEentityRef"));
         # Sets the default handler function
         xml_set_default_handler($this->parser, array($this, "xmlDefault"));
         # Set a handler to be called when a namespace is declared.
         xml_set_start_namespace_decl_handler($this->parser, array($this, "xmlNSStart"));
         # Set a handler to be called when leaving the scope of a namespace declaration
         xml_set_end_namespace_decl_handler($this->parser, array($this, "xmlNSEnd"));
         # turn off case folding to stop element names from being uppercased;
         $this->setOption(XML_OPTION_CASE_FOLDING, false);
         //$this->setOption(XML_OPTION_SKIP_WHITE, true);
     } else {
         throw new ParserException('Parser already registered call XML::unregister() first');
     }
     return $this->parser;
 }

<?php

chdir(dirname(__FILE__));
$xml_parser = xml_parser_create();
xml_parser_set_option($xml_parser, XML_OPTION_CASE_FOLDING, 1);
xml_set_element_handler($xml_parser, "startElement", "endElement");
xml_set_character_data_handler($xml_parser, "characterData");
xml_set_processing_instruction_handler($xml_parser, "PIHandler");
xml_set_default_handler($xml_parser, "defaultHandler");
xml_set_external_entity_ref_handler($xml_parser, "externalEntityRefHandler");
if (!($fp = @fopen("xmltest.xml", "r"))) {
    die("could not open XML input");
}
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)));
    }
}
print "parse complete\n";
xml_parser_free($xml_parser);
function startElement($parser, $name, $attribs)
{
    print '{' . $name;
    if (sizeof($attribs)) {
        while (list($k, $v) = each($attribs)) {
            print " {$k}=\"{$v}\"";
        }
    }
    print '}';
}
function endElement($parser, $name)

 * Description: Set up external entity reference handler 
 * Source code: ext/xml/xml.c
 * Alias to functions: 
 */
echo "*** Testing xml_set_external_entity_ref_handler() : usage variations ***\n";
error_reporting(E_ALL & ~E_NOTICE);
class aClass
{
    function __toString()
    {
        return "Some Ascii Data";
    }
}
function validHandler(resource $parser, string $data)
{
}
// Initialise function arguments not being substituted (if any)
$hdl = 'validHandler';
//get an unset variable
$unset_var = 10;
unset($unset_var);
$fp = fopen(__FILE__, "r");
//array of values to iterate over
$values = array(0, 1, 12345, -2345, 10.5, -10.5, 101234567000.0, 1.07654321E-9, 0.5, array(), array(0), array(1), array(1, 2), array('color' => 'red', 'item' => 'pen'), NULL, null, true, false, TRUE, FALSE, "", '', "string", 'string', new aClass(), $fp, $undefined_var, $unset_var);
// loop through each element of the array for parser
foreach ($values as $value) {
    echo @"\nArg value {$value} \n";
    var_dump(xml_set_external_entity_ref_handler($value, $hdl));
}
fclose($fp);
echo "Done";

 /**
  * Create a new SAX parser and associate it with this XmlParser instance
  *
  * @void
  */
 private function newParser()
 {
     $parser = @xml_parser_create_ns(null, ' ');
     if (is_resource($parser)) {
         xml_parser_set_option($parser, XML_OPTION_CASE_FOLDING, false);
         xml_set_object($parser, $this);
         xml_set_element_handler($parser, 'startHandler', 'endHandler');
         xml_set_character_data_handler($parser, 'cDataHandler');
         xml_set_external_entity_ref_handler($parser, 'extEntityHandler');
         xml_set_processing_instruction_handler($parser, 'piHandler');
     }
     return $parser;
 }

function new_xml_parser($file)
{
    global $parser_file;
    $xml_parser = xml_parser_create();
    xml_parser_set_option($xml_parser, XML_OPTION_CASE_FOLDING, 1);
    xml_set_element_handler($xml_parser, "startElement", "endElement");
    xml_set_character_data_handler($xml_parser, "characterData");
    xml_set_processing_instruction_handler($xml_parser, "PIHandler");
    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);
}

 /**
  * @internal
  * Init the XML parser
  * @param $ns
  * @param $encoding
  * @param $separator
  * @private
  */
 function _initParser($ns = false, $encoding = 'UTF-8', $separator = null)
 {
     $this->_p = $ns ? xml_parser_create_ns($encoding, $separator) : xml_parser_create($encoding);
     xml_set_object($this->_p, $this);
     xml_set_default_handler($this->_p, '_default');
     xml_set_element_handler($this->_p, '_tagOpen', '_tagClose');
     xml_set_character_data_handler($this->_p, '_cdata');
     xml_set_start_namespace_decl_handler($this->_p, '_nsStart');
     xml_set_end_namespace_decl_handler($this->_p, '_nsEnd');
     xml_set_external_entity_ref_handler($this->_p, '_entityRef');
     xml_set_processing_instruction_handler($this->_p, '_pi');
     xml_set_notation_decl_handler($this->_p, '_notation');
     xml_set_unparsed_entity_decl_handler($this->_p, '_unparsedEntity');
     $this->setOption(XML_OPTION_CASE_FOLDING, false);
 }

function Aspis_xml_set_external_entity_ref_handler($parser, $handler)
{
    global $Aspis_xml_objects;
    if (!empty($Aspis_xml_objects)) {
        $c = count($Aspis_xml_objects);
        for ($i = $c - 1; $i >= 0; $i--) {
            $e = $Aspis_xml_objects[$i];
            if ($e[0] === $parser[0]) {
                $handler[0] = AspisInternalCallback(array(array(array($e[1], false), array($handler[0], false)), false));
                break;
            }
        }
    }
    return array(xml_set_external_entity_ref_handler($parser[0], $handler[0]), false);
}

 /**
  * Initialize the XML parser.
  */
 function init()
 {
     // Check that the charset is supported by the XML parser.
     $allowed_charsets = array('us-ascii', 'iso-8859-1', 'utf-8', 'utf-16');
     if (!in_array($this->charset, $allowed_charsets)) {
         $this->charset = 'utf-8';
     }
     // Create the XML parser.
     $this->parser = xml_parser_create($this->charset);
     xml_set_object($this->parser, $this);
     xml_parser_set_option($this->parser, XML_OPTION_CASE_FOLDING, false);
     xml_parser_set_option($this->parser, XML_OPTION_TARGET_ENCODING, 'UTF-8');
     xml_set_element_handler($this->parser, 'startElement', 'endElement');
     xml_set_character_data_handler($this->parser, 'characterData');
     xml_set_default_handler($this->parser, 'defaultHandler');
     // Disable processing instructions and external entities.
     xml_set_processing_instruction_handler($this->parser, '');
     xml_set_external_entity_ref_handler($this->parser, '');
 }

<?php

/* Prototype  : proto int xml_set_external_entity_ref_handler(resource parser, string hdl)
 * Description: Set up external entity reference handler 
 * Source code: ext/xml/xml.c
 * Alias to functions: 
 */
echo "*** Testing xml_set_external_entity_ref_handler() : error conditions ***\n";
//Test xml_set_external_entity_ref_handler with one more than the expected number of arguments
echo "\n-- Testing xml_set_external_entity_ref_handler() function with more than expected no. of arguments --\n";
$hdl = 'string_val';
$extra_arg = 10;
var_dump(xml_set_external_entity_ref_handler(null, $hdl, $extra_arg));
// Testing xml_set_external_entity_ref_handler with one less than the expected number of arguments
echo "\n-- Testing xml_set_external_entity_ref_handler() function with less than expected no. of arguments --\n";
var_dump(xml_set_external_entity_ref_handler(null));
echo "Done";

 /**
  *
  * @access protected
  */
 function register()
 {
     xml_set_character_data_handler($this->parser, 'character_data');
     xml_set_default_handler($this->parser, 'default_data');
     xml_set_element_handler($this->parser, 'tag_open', 'tag_close');
     xml_set_end_namespace_decl_handler($this->parser, 'end_namespace_decl');
     xml_set_external_entity_ref_handler($this->parser, 'external_entity_ref');
     xml_set_notation_decl_handler($this->parser, 'notation_decl');
     xml_set_processing_instruction_handler($this->parser, 'processing_instruction');
     xml_set_start_namespace_decl_handler($this->parser, 'start_namespace_decl');
     xml_set_unparsed_entity_decl_handler($this->parser, 'unparsed_entity');
     return $this->registered = 1;
 }