PHP xml_set_object函数代码示例

 function xmlParser()
 {
     $this->xml_obj = xml_parser_create();
     xml_set_object($this->xml_obj, $this);
     xml_set_character_data_handler($this->xml_obj, 'dataHandler');
     xml_set_element_handler($this->xml_obj, "startHandler", "endHandler");
 }

 /**
  * Constructs FormFilter
  * @access public
  */
 function __construct()
 {
     $this->parser = xml_parser_create();
     xml_set_object($this->parser, $this);
     xml_set_element_handler($this->parser, 'open', 'close');
     xml_set_character_data_handler($this->parser, 'data');
 }

 public function parse($xml_or_arr)
 {
     if (is_array($xml_or_arr)) {
         $output = array();
         foreach ($xml_or_arr as $val) {
             $to = $this->parse($val);
             $output = array_merge($output, $to);
         }
         return $output;
     }
     //		echo '<h1>xml in parser:</h1><pre>'; print_r($xml); echo '</pre>';
     // if we don't start with a processing instruction,
     // we add an outer node just to ensure it's a valid xml document
     // (i.e. only a single root node)
     if (substr($xml_or_arr, 0, 2) != '<?') {
         $xml_or_arr = "<{$this->insertedNode}>" . $xml_or_arr . "</{$this->insertedNode}>";
     }
     $this->parser = xml_parser_create();
     xml_set_object($this->parser, $this);
     xml_set_element_handler($this->parser, "tagOpen", "tagClosed");
     xml_parser_set_option($this->parser, XML_OPTION_CASE_FOLDING, 0);
     xml_parser_set_option($this->parser, XML_OPTION_SKIP_WHITE, 1);
     xml_set_character_data_handler($this->parser, "tagData");
     $this->xmldata = xml_parse($this->parser, $xml_or_arr);
     if (!$this->xmldata) {
         die(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);
     $this->parseCompleted();
     return $this->output;
 }

 function __construct($charset = 'UTF-8')
 {
     $this->conf = array();
     $this->conf['error'] = '<br /><strong>Error on line %s of ' . __FILE__ . '</strong>: %s<br />';
     $this->conf['cache_path'] = dirname(__FILE__);
     $this->conf['cache_time'] = 180;
     $this->conf['debug_mode'] = true;
     $this->conf['fetch_mode'] = ONYX_FETCH_ASSOC;
     if (!function_exists('xml_parser_create')) {
         $this->raiseError(__LINE__ - 2, ONYX_ERR_NO_PARSER);
         return false;
     }
     if ($charset == 'native') {
         $charset = LANG_CHARSET;
     }
     $this->parser = @xml_parser_create($charset);
     if (!is_resource($this->parser)) {
         $this->raiseError(__LINE__ - 3, ONYX_ERR_NO_PARSER);
         return false;
     }
     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, LANG_CHARSET);
     xml_set_element_handler($this->parser, 'tag_open', 'tag_close');
     xml_set_character_data_handler($this->parser, 'cdata');
 }

 /**
  * Run the loader, to load up field-restrictions from the XML file.
  *
  * @param  string			The default breadcrumbs
  * @param  string			The breadcrumb XML data
  */
 function go($current_breadcrumbs, $data)
 {
     $this->tag_stack = array();
     $this->attribute_stack = array();
     $this->substitution_current_match_key = NULL;
     $this->substitution_current_label = NULL;
     $this->links = array();
     $this->substitutions = array();
     $breadcrumb_tpl = do_template('BREADCRUMB_ESCAPED');
     $this->breadcrumb_tpl = $breadcrumb_tpl->evaluate();
     $this->current_breadcrumbs = $current_breadcrumbs;
     // Create and setup our parser
     $xml_parser = @xml_parser_create();
     if ($xml_parser === false) {
         return;
         // PHP5 default build on windows comes with this function disabled, so we need to be able to escape on error
     }
     xml_set_object($xml_parser, $this);
     @xml_parser_set_option($xml_parser, XML_OPTION_TARGET_ENCODING, get_charset());
     @xml_parser_set_option($xml_parser, XML_OPTION_CASE_FOLDING, 0);
     xml_set_element_handler($xml_parser, 'startElement', 'endElement');
     xml_set_character_data_handler($xml_parser, 'startText');
     // Run the parser
     if (@xml_parse($xml_parser, $data, true) == 0) {
         attach_message('breadcrumbs.xml: ' . xml_error_string(xml_get_error_code($xml_parser)), 'warn');
         return;
     }
     @xml_parser_free($xml_parser);
 }

 function parse($xml)
 {
     $this->result = array();
     $this->context = $xml;
     $this->currentTag = '';
     $this->currentState = array();
     $this->xmlParser = xml_parser_create();
     xml_parser_set_option($this->xmlParser, XML_OPTION_TARGET_ENCODING, "UTF-8") . xml_set_object($this->xmlParser, $this);
     xml_set_element_handler($this->xmlParser, 'startElement', 'endElement');
     xml_set_character_data_handler($this->xmlParser, 'content');
     $this->trigger('before:import');
     try {
         if (!xml_parse($this->xmlParser, $xml)) {
             $this->xmlParserError = 'Line ' . xml_get_current_line_number($this->xmlParser) . ': ' . (xml_get_error_code($this->xmlParser) ? xml_error_string(xml_get_error_code($this->xmlParser)) : 'Unknown error');
         }
     } catch (Exception $e) {
         $this->xmlParserError = $e->getMessage();
     }
     xml_parser_free($this->xmlParser);
     if ($this->xmlParserError) {
         $this->raiseError($this->xmlParserError);
     } else {
         if ($this->getCurrentState()) {
             $this->raiseError('Wrong ending state: ' . $this->getCurrentState());
         } else {
         }
     }
     $this->trigger('after:import');
     return $this->result;
 }

 public function fetch()
 {
     $this->query = $this->url . '?pid=' . $this->pid . '&noredirect=true&format=unixref&id=doi%3A' . $this->doi;
     $request_options = array('method' => 'POST');
     $result = drupal_http_request($this->query, $request_options);
     if ($result->code != 200) {
         drupal_set_message(t('HTTP error: !error when trying to contact crossref.org for XML input', array('!error' => $result->code)), 'error');
         return;
     }
     if (empty($result->data)) {
         drupal_set_message(t('Did not get any data from crossref.org'), 'error');
         return;
     }
     $sxml = @simplexml_load_string($result->data);
     if ($error = (string) $sxml->doi_record->crossref->error) {
         drupal_set_message($error, 'error');
         return;
     }
     $this->nodes = array();
     $this->parser = drupal_xml_parser_create($result->data);
     // use case-folding so we are sure to find the tag in
     xml_parser_set_option($this->parser, XML_OPTION_CASE_FOLDING, FALSE);
     xml_parser_set_option($this->parser, XML_OPTION_SKIP_WHITE, TRUE);
     xml_set_object($this->parser, $this);
     xml_set_element_handler($this->parser, 'unixref_startElement', 'unixref_endElement');
     xml_set_character_data_handler($this->parser, 'unixref_characterData');
     if (!xml_parse($this->parser, $result->data)) {
         drupal_set_message(sprintf("XML error: %s at line %d", xml_error_string(xml_get_error_code($this->parser)), xml_get_current_line_number($this->parser)), 'error');
     }
     xml_parser_free($this->parser);
     return $this->node;
 }

 public function xml() {
     $this->parser = xml_parser_create();    
     xml_parser_set_option($this->parser, XML_OPTION_CASE_FOLDING, false);    
     xml_set_object($this->parser, $this);    
     xml_set_element_handler($this->parser, 'open','close');    
     xml_set_character_data_handler($this->parser, 'data');    
 }

 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 replaceTranslation()
 {
     //write xml header
     fwrite($this->outputFP, '<?xml version="1.0" encoding="UTF-8"?>');
     //create parser
     $xml_parser = xml_parser_create('UTF-8');
     //configure parser
     //pass this object to parser to make its variables and functions visible inside callbacks
     xml_set_object($xml_parser, $this);
     //avoid uppercasing all tags name
     xml_parser_set_option($xml_parser, XML_OPTION_CASE_FOLDING, false);
     //define callbacks for tags
     xml_set_element_handler($xml_parser, "tagOpen", "tagClose");
     //define callback for data
     xml_set_character_data_handler($xml_parser, "characterData");
     //read a chunk of text
     while ($this->currentBuffer = fread($this->originalFP, 4096)) {
         /*
           preprocess file
         */
         // obfuscate entities because sax automatically does html_entity_decode
         $temporary_check_buffer = preg_replace("/&(.*?);/", '#%$1#%', $this->currentBuffer);
         $lastByte = $temporary_check_buffer[strlen($temporary_check_buffer) - 1];
         //avoid cutting entities in half:
         //the last fread could have truncated an entity (say, '&lt;' in '&l'), thus invalidating the escaping
         //***** and if there is an & that it is not an entity, this is an infinite loop !!!!!
         $escape_AMP = false;
         // 9 is the max length of an entity. So, suppose that the & is at the end of buffer,
         // add 9 Bytes and substitute the entities, if the & is present and it is not at the end
         //it can't be a entity, exit the loop
         while (true) {
             $_ampPos = strpos($temporary_check_buffer, '&');
             //check for real entity or escape it to safely exit from the loop!!!
             if ($_ampPos === false || strlen(substr($temporary_check_buffer, $_ampPos)) > 9) {
                 $escape_AMP = true;
                 break;
             }
             //if an entity is still present, fetch some more and repeat the escaping
             $this->currentBuffer .= fread($this->originalFP, 9);
             $temporary_check_buffer = preg_replace("/&(.*?);/", '#%$1#%', $this->currentBuffer);
         }
         //free stuff outside the loop
         unset($temporary_check_buffer);
         $this->currentBuffer = preg_replace("/&(.*?);/", '#%$1#%', $this->currentBuffer);
         if ($escape_AMP) {
             $this->currentBuffer = str_replace("&", '#%amp#%', $this->currentBuffer);
         }
         //get lenght of chunk
         $this->len = strlen($this->currentBuffer);
         //parse chunk of text
         if (!xml_parse($xml_parser, $this->currentBuffer, feof($this->originalFP))) {
             //if unable, die
             die(sprintf("XML error: %s at line %d", xml_error_string(xml_get_error_code($xml_parser)), xml_get_current_line_number($xml_parser)));
         }
         //get accumulated this->offset in document: as long as SAX pointer advances, we keep track of total bytes it has seen so far; this way, we can translate its global pointer in an address local to the current buffer of text to retrieve last char of tag
         $this->offset += $this->len;
     }
     //close parser
     xml_parser_free($xml_parser);
 }

 function XMLToArray($data, $ignore = array(), $replace = array(), $showattribs = false, $toupper = false)
 {
     $this->_showAttribs = $showattribs;
     $this->_parser = xml_parser_create();
     xml_set_object($this->_parser, $this);
     if ($toupper) {
         foreach ((array) $ignore as $key => $value) {
             $this->_ignore[strtoupper($key)] = strtoupper($value);
         }
         foreach ((array) $replace as $key => $value) {
             $this->_replace[strtoupper($key)] = strtoupper($value);
         }
         xml_parser_set_option($this->_parser, XML_OPTION_CASE_FOLDING, true);
     } else {
         $this->_ignore =& $ignore;
         $this->_replace =& $replace;
         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, '_cdata');
     $this->_data = array();
     $this->_level = 0;
     if (!xml_parse($this->_parser, $data, true)) {
         //new Error("XML Parse Error: ".xml_error_string(xml_get_error_code($this->_parser))."n on line: ".xml_get_current_line_number($this->_parser),true);
         return false;
     }
     xml_parser_free($this->_parser);
 }

 /**
  * Set handlers
  *
  * @access public
  * @param resource xml_parser instance
  * 
  */
 public function setHandlers($a_xml_parser)
 {
     xml_set_object($a_xml_parser, $this);
     xml_set_element_handler($a_xml_parser, 'handlerBeginTag', 'handlerEndTag');
     xml_set_character_data_handler($a_xml_parser, 'handlerCharacterData');
     return;
 }

    /**
     * Load translation data (XMLTM file reader)
     *
     * @param  string  $locale    Locale/Language to add data for, identical with locale identifier,
     *                            see Zend_Locale for more information
     * @param  string  $filename  XMLTM file to add, full path must be given for access
     * @param  array   $option    OPTIONAL Options to use
     * @throws Zend_Translation_Exception
     */
    protected function _loadTranslationData($filename, $locale, array $options = array())
    {
        $options = array_merge($this->_options, $options);
        $this->_lang = $locale;

        if ($options['clear']  ||  !isset($this->_translate[$locale])) {
            $this->_translate[$locale] = array();
        }

        if (!is_readable($filename)) {
            throw new Zend_Translate_Exception('Translation file \'' . $filename . '\' is not readable.');
        }

        $this->_file = xml_parser_create();
        xml_set_object($this->_file, $this);
        xml_parser_set_option($this->_file, XML_OPTION_CASE_FOLDING, 0);
        xml_set_element_handler($this->_file, "_startElement", "_endElement");
        xml_set_character_data_handler($this->_file, "_contentElement");

        if (!xml_parse($this->_file, file_get_contents($filename))) {
            throw new Zend_Translate_Exception(sprintf('XML error: %s at line %d',
                      xml_error_string(xml_get_error_code($this->_file)),
                      xml_get_current_line_number($this->_file)));
            xml_parser_free($this->_file);
        }
    }

 public function AkDBDesignerToAkelosDatabaseDesign()
 {
     $this->_parser = xml_parser_create();
     xml_set_object($this->_parser, &$this);
     xml_set_element_handler($this->_parser, 'tagOpen', 'tagClose');
     xml_parser_set_option($this->_parser, XML_OPTION_CASE_FOLDING, false);
 }

 function open($xml, $encoding = null)
 {
     if (!empty($encoding) && strtolower($encoding) != 'utf-8' && !Utils_Unicode::validate($xml)) {
         if (preg_match('/^<\\?xml[^<]*\\s+encoding=["\']?([\\w-]+)["\']?/', $xml, $matches)) {
             $encoding = $matches[1];
             $xml = preg_replace('/^(<\\?xml[^<]*\\s+encoding=)["\']?[\\w-]+["\']?/', '$1"utf-8"', $xml, 1);
         }
         if (strcasecmp($encoding, 'utf-8')) {
             $xml = Utils_Unicode::bring($xml, $encoding);
             if (is_null($xml)) {
                 $this->error = XML_ERROR_UNKNOWN_ENCODING;
                 return false;
             }
         }
     } else {
         if (substr($xml, 0, 3) == "") {
             $xml = substr($xml, 3);
         }
     }
     $p = xml_parser_create();
     xml_set_object($p, $this);
     xml_parser_set_option($p, XML_OPTION_CASE_FOLDING, 0);
     xml_set_element_handler($p, 'o', 'c');
     xml_set_character_data_handler($p, 'd');
     xml_set_default_handler($p, 'x');
     $this->tree = array('children' => array());
     $this->_cursor =& $this->tree;
     $this->_cdata = false;
     xml_parse($p, $xml);
     unset($this->_cursor);
     unset($this->_cdata);
     $this->error = xml_get_error_code($p);
     xml_parser_free($p);
     return $this->error == XML_ERROR_NONE;
 }