XMLParser.inc.php

<?php
 
// The default character encodings
define('XML_PARSER_SOURCE_ENCODING', Config::getVar('i18n', 'client_charset'));
define('XML_PARSER_TARGET_ENCODING', Config::getVar('i18n', 'client_charset'));
 
import('lib.pkp.classes.xml.XMLParserDOMHandler');
 
class XMLParser {
   var $handler;
 
   var $errors;
 
   function __construct() {
      $this->errors = array();
   }
 
   function parseText($text) {
      $parser = $this->createParser();
 
      if (!isset($this->handler)) {
         // Use default handler for parsing
         $handler = new XMLParserDOMHandler();
         $this->setHandler($handler);
      }
 
      xml_set_object($parser, $this->handler);
      xml_set_element_handler($parser, "startElement", "endElement");
      xml_set_character_data_handler($parser, "characterData");
 
      if (!xml_parse($parser, $text, true)) {
         $this->addError(xml_error_string(xml_get_error_code($parser)));
      }
 
      $result = $this->handler->getResult();
      $this->destroyParser($parser);
      if (isset($handler)) {
         $handler->destroy();
      }
      return $result;
   }
 
   function parse($file) {
      $parser = $this->createParser();
 
      if (!isset($this->handler)) {
         // Use default handler for parsing
         $handler = new XMLParserDOMHandler();
         $this->setHandler($handler);
      }
 
      xml_set_object($parser, $this->handler);
      xml_set_element_handler($parser, "startElement", "endElement");
      xml_set_character_data_handler($parser, "characterData");
 
      if (!$stream = $this->_getStream($file)) return false;
 
      while (($data = $stream->read(16384)) !== '') {
         if (!xml_parse($parser, $data, $stream->eof())) {
            $this->addError(xml_error_string(xml_get_error_code($parser)));
         }
      }
 
      $stream->close();
      $result = $this->handler->getResult();
      $this->destroyParser($parser);
      if (isset($handler)) {
         $handler->destroy();
      }
      return $result;
   }
 
   protected function _getStream($filenameOrUrl) {
      $urlPieces = parse_url($filenameOrUrl);
      if ($urlPieces && isset($urlPieces['scheme'])) {
         // Remote URL.
         $client = Application::get()->getHttpClient();
         $response = $client->request('GET', $filenameOrUrl);
         return GuzzleHttp\Psr7\stream_for($response->getBody());
      } elseif (file_exists($filenameOrUrl) && is_readable($filenameOrUrl)) {
         $resource = fopen($filenameOrUrl, 'r');
         return GuzzleHttp\Psr7\stream_for($resource);
      }
      return null;
   }
 
   function addError($error) {
      array_push($this->errors, $error);
   }
 
   function getErrors() {
      return $this->errors;
   }
 
   function getStatus() {
      return empty($this->errors);
   }
 
   function setHandler($handler) {
      $this->handler = $handler;
   }
 
   function parseTextStruct($text, $tagsToMatch = array()) {
      $parser = $this->createParser();
      $result = xml_parse_into_struct($parser, $text, $values, $tags);
      $this->destroyParser($parser);
      if (!$result) return null;
 
      // Clean up data struct, removing undesired tags if necessary
      $data = array();
      foreach ($tags as $key => $indices) {
         if (!empty($tagsToMatch) && !in_array($key, $tagsToMatch)) {
            continue;
         }
 
         $data[$key] = array();
 
         foreach ($indices as $index) {
            if (!isset($values[$index]['type']) || ($values[$index]['type'] != 'open' && $values[$index]['type'] != 'complete')) {
               continue;
            }
 
            $data[$key][] = array(
               'attributes' => isset($values[$index]['attributes']) ? $values[$index]['attributes'] : array(),
               'value' => isset($values[$index]['value']) ? $values[$index]['value'] : ''
            );
         }
      }
 
      return $data;
   }
 
   function parseStruct($file, $tagsToMatch = array()) {
      $stream = $this->_getStream($file);
      $fileContents = $stream->getContents();
      if (!$fileContents) {
         return false;
      }
      return $this->parseTextStruct($fileContents, $tagsToMatch);
   }
 
   function createParser() {
      $parser = xml_parser_create(XML_PARSER_SOURCE_ENCODING);
      xml_parser_set_option($parser, XML_OPTION_TARGET_ENCODING, XML_PARSER_TARGET_ENCODING);
      xml_parser_set_option($parser, XML_OPTION_CASE_FOLDING, false);
      return $parser;
   }
 
   function destroyParser($parser) {
      xml_parser_free($parser);
   }
}
 
class XMLParserHandler {
 
   function startElement($parser, $tag, $attributes) {
   }
 
   function endElement($parser, $tag) {
   }
 
   function characterData($parser, $data) {
   }
 
   function getResult() {
      return null;
   }
 
   function destroy() {
   }
}