function pullStats($set)
 {
     $xp = new XsltProcessor();
     // create a DOM document and load the XSL stylesheet
     $xsl = new DomDocument();
     $xsl->load('stats.xslt');
     // import the XSL styelsheet into the XSLT process
     $xp->importStylesheet($xsl);
     // create a DOM document and load the XML datat
     $xml_doc = new DomDocument();
     $xml_doc->load('xmlcache/' . $set . '.xml');
     // transform the XML into HTML using the XSL file
     if ($xml = $xp->transformToXML($xml_doc)) {
         $stats_xml = simplexml_load_string($xml);
         $temp_bottom = array();
         $temp_top = array();
         foreach ($stats_xml->top as $top) {
             array_push($temp_top, (string) $top);
         }
         foreach ($stats_xml->bottom as $bottom) {
             array_push($temp_bottom, (string) $bottom);
         }
         $temp_return = array('bottom' => $temp_bottom, 'top' => $temp_top, 'total' => (string) $stats_xml->total);
         return $temp_return;
     }
 }

/**
 * Metainformation catalogue
 * --------------------------------------------------
 *
 * Lib_XML for MicKa
 *
 * @link       http://www.bnhelp.cz
 * @package    Micka
 * @category   Metadata
 * @version    20121206
 *
 */
function applyTemplate($xmlSource, $xsltemplate)
{
    $rs = FALSE;
    if (File_Exists(CSW_XSL . '/' . $xsltemplate)) {
        if (!extension_loaded("xsl")) {
            if (substr(PHP_OS, 0, 3) == "WIN") {
                dl("php_xsl.dll");
            } else {
                dl("php_xsl.so");
            }
        }
        $xp = new XsltProcessor();
        $xml = new DomDocument();
        $xsl = new DomDocument();
        $xml->loadXML($xmlSource);
        $xsl->load(CSW_XSL . '/' . $xsltemplate);
        $xp->importStyleSheet($xsl);
        //$xp->setParameter("","lang",$lang);
        $xp->setParameter("", "user", $_SESSION['u']);
        $rs = $xp->transformToXml($xml);
    }
    if ($rs === FALSE) {
        setMickaLog('applyTemplate === FALSE', 'ERROR', 'micka_lib_xml.php');
    }
    return $rs;
}

function get_document($aNode)
{
    //get the directory in which the documents are contained from the config.php file
    global $xml_dir, $html_dir, $xslt, $html_xslt;
    //create the xslt
    $xp = new XsltProcessor();
    // create a DOM document and load the XSL stylesheet
    $xsl = new DomDocument();
    $xsl->load($xslt);
    // import the XSL styelsheet into the XSLT process
    $xp->importStylesheet($xsl);
    //open the xml document
    $xml = new DomDocument();
    $xml->loadXML($aNode);
    //transform
    if ($html = $xp->transformToXML($xml)) {
        $return = str_replace('<?xml version="1.0"?>' . "\n", "", $html);
        $return = str_replace('<!DOCTYPE div PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">' . "\n", "", $return);
        $return = str_replace("\n", "", $return);
        $return = str_replace("\n ", "", $return);
        return str_replace("\t", "", $return);
    } else {
        trigger_error('XSL transformation failed.', E_USER_ERROR);
    }
}

 /**
  * process xsl template with Flow xml
  *
  * @param   string      xsl source file
  * @return  string      xsl transformation output
  */
 public function process($xslfile)
 {
     $flow = Nexista_Flow::Singleton('Nexista_Flow');
     // The following can be used with the NYT xslt cache.
     $use_xslt_cache = "yes";
     if (!is_file($xslfile)) {
         Nexista_Error::init('XSL Handler - Error processing XSL file,
             it is unavailable: ' . $xslfile, NX_ERROR_FATAL);
     }
     if ($use_xslt_cache != "yes" || !class_exists('xsltCache')) {
         $xsl = new DomDocument('1.0', 'UTF-8');
         $xsl->substituteEntities = false;
         $xsl->resolveExternals = false;
         $xslfilecontents .= file_get_contents($xslfile);
         $xsl->loadXML($xslfilecontents);
         $xsl->documentURI = $xslfile;
         $xslHandler = new XsltProcessor();
         $xslHandler->importStyleSheet($xsl);
         if (4 == 3 && function_exists('setProfiling')) {
             $xslHandler->setProfiling("/tmp/xslt-profiling.txt");
         }
     } else {
         $xslHandler = new xsltCache();
         $xslHandler->importStyleSheet($xslfile);
     }
     $output = $xslHandler->transformToXML($flow->flowDocument);
     if ($output === false) {
         Nexista_Error::init('XSL Handler - Error processing XSL file: ' . $xslfile, NX_ERROR_FATAL);
     }
     return $output;
 }

 public function TeiDisplay($file, array $options = array())
 {
     if ($file->getExtension() != "xml") {
         return "";
     }
     //queue_css_file('tei_display_public', 'screen', false, "plugins/TeiDisplay/views/public/css");
     //echo "<h3>displaying ", $file->original_filename, "</h3><br/>";
     $files = $file->getItem()->Files;
     foreach ($files as $f) {
         if ($f->getExtension() == "xsl") {
             $xsl_file = $f;
         }
         if ($f->getExtension() == "css") {
             $css_file = $f;
         }
     }
     //queue_css_url($css_file->getWebPath());
     echo '<link rel="stylesheet" media="screen" href="' . $css_file->getWebPath() . '"/>';
     //echo "transforming with ", $xsl_file->original_filename, "<br/>";
     $xp = new XsltProcessor();
     $xsl = new DomDocument();
     //echo "loading ", "files/original/".$xsl_file->filename, "<br/>";
     $xsl->load("files/original/" . $xsl_file->filename);
     $xp->importStylesheet($xsl);
     $xml_doc = new DomDocument();
     //echo "loading ", "files/original/".$file->filename, "<br/>";
     $xml_doc->load("files/original/" . $file->filename);
     try {
         if ($doc = $xp->transformToXML($xml_doc)) {
             return $doc;
         }
     } catch (Exception $e) {
         $this->view->error = $e->getMessage();
     }
 }

 function handle($match, $state, $pos, Doku_Handler $handler)
 {
     switch ($state) {
         case DOKU_LEXER_SPECIAL:
             $matches = preg_split('/(&&XML&&\\n*|\\n*&&XSLT&&\\n*|\\n*&&END&&)/', $match, 5);
             $data = "XML: " . $matches[1] . "\nXSLT: " . $matches[2] . "(" . $match . ")";
             $xsltproc = new XsltProcessor();
             $xml = new DomDocument();
             $xsl = new DomDocument();
             $xml->loadXML($matches[1]);
             $xsl->loadXML($matches[2]);
             $xsltproc->registerPHPFunctions();
             $xsltproc->importStyleSheet($xsl);
             $data = $xsltproc->transformToXML($xml);
             if (!$data) {
                 $errors = libxml_get_errors();
                 foreach ($errors as $error) {
                     $data = display_xml_error($error, $xml);
                 }
                 libxml_clear_errors();
             }
             unset($xsltproc);
             return array($state, $data);
         case DOKU_LEXER_UNMATCHED:
             return array($state, $match);
         case DOKU_LEXER_EXIT:
             return array($state, '');
     }
     return array();
 }

function pubmed_metadata($pmid, &$item)
{
    global $debug;
    $ok = false;
    $url = 'http://eutils.ncbi.nlm.nih.gov/entrez/eutils/efetch.fcgi?' . 'retmode=xml' . '&db=pubmed' . '&id=' . $pmid;
    //echo $url;
    $xml = get($url);
    //echo $xml;
    if (preg_match('/<\\?xml /', $xml)) {
        $ok = true;
        if ($debug) {
            echo $xml;
        }
        $dom = new DOMDocument();
        $dom->loadXML($xml);
        $xpath = new DOMXPath($dom);
        /*		$nodeCollection = $xpath->query ("//crossref/error");
        		foreach($nodeCollection as $node)
        		{
        			$ok = false;
        		}
        		if ($ok)
        		{*/
        // Get JSON
        $xp = new XsltProcessor();
        $xsl = new DomDocument();
        $xsl->load('xsl/pubmed2JSON.xsl');
        $xp->importStylesheet($xsl);
        $xml_doc = new DOMDocument();
        $xml_doc->loadXML($xml);
        $json = $xp->transformToXML($xml_doc);
        //echo $json;
        $item = json_decode($json);
        // post process
        // Ensure metadata is OK (assumes a journal for now)
        if (!isset($item->issn)) {
            $issn = '';
            if (isset($item->title)) {
                $issn = issn_from_journal_title($item->title);
            }
            if ($issn == '') {
                if (isset($item->eissn)) {
                    $issn = $item->eissn;
                }
            }
            if ($issn != '') {
                $item->issn = $issn;
            }
        }
        if ($debug) {
            echo '<h3>Boo</h3>';
            print_r($item);
        }
    }
    return $ok;
}

 /**
  * @param $path
  * @param array $data
  * @return string
  */
 protected function evaluatePath($path, array $data = [])
 {
     $preferences = $this->XSLTSimple->addChild('Preferences');
     $url = $preferences->addChild('url');
     $url->addAttribute('isHttps', Request::secure());
     $url->addAttribute('currentUrl', Request::url());
     $url->addAttribute('baseUrl', URL::to(''));
     $url->addAttribute('previousUrl', URL::previous());
     $server = $preferences->addChild('server');
     $server->addAttribute('curretnYear', date('Y'));
     $server->addAttribute('curretnMonth', date('m'));
     $server->addAttribute('curretnDay', date('d'));
     $server->addAttribute('currentDateTime', date('Y-m-d H:i:s'));
     $language = $preferences->addChild('language');
     $language->addAttribute('current', App::getLocale());
     $default_language = \Config::get('app.default_language');
     if (isset($default_language)) {
         $language->addAttribute('default', $default_language);
     }
     $languages = \Config::get('app.available_languages');
     if (is_array($languages)) {
         foreach ($languages as $lang) {
             $language->addChild('item', $lang);
         }
     }
     // from form generator
     if (isset($data['form'])) {
         $this->XSLTSimple->addChild('Form', form($data['form']));
     }
     // adding form errors to xml
     if (isset($data['errors'])) {
         $this->XSLTSimple->addData($data['errors']->all(), 'FormErrors', false);
     }
     // "barryvdh/laravel-debugbar":
     // adding XML tab
     if (true === class_exists('Debugbar')) {
         $dom = dom_import_simplexml($this->XSLTSimple)->ownerDocument;
         $dom->preserveWhiteSpace = false;
         $dom->formatOutput = true;
         $prettyXml = $dom->saveXML();
         // add new tab and append xml to it
         if (false === \Debugbar::hasCollector('XML')) {
             \Debugbar::addCollector(new \DebugBar\DataCollector\MessagesCollector('XML'));
         }
         \Debugbar::getCollector('XML')->addMessage($prettyXml, 'info', false);
     }
     $xsl_processor = new \XsltProcessor();
     $xsl_processor->registerPHPFunctions();
     $xsl_processor->importStylesheet(simplexml_load_file($path));
     return $xsl_processor->transformToXML($this->XSLTSimple);
 }

 public function xhtmlAction()
 {
     $xml = DOCS_PATH . $this->view->docid . '.xml';
     $xsl = APPLICATION_PATH . 'modules/contingent/controllers/xml2html.xsl';
     $doc = new DOMDocument();
     $doc->substituteEntities = TRUE;
     $doc->load($xsl);
     $proc = new XsltProcessor();
     $proc->importStylesheet($doc);
     $doc->load($xml);
     $proc->setParameter('', 'contextPath', '/');
     $proc->setParameter('', 'nodeResPath', '/res/' . $this->view->docid . '/');
     echo $proc->transformToXml($doc);
 }

 /**
  * Execute render process
  * @param string $templatePath
  * @param \DOMDocument $source
  * @param array $parameters
  * @return string
  */
 public function execute($templatePath, \DOMDocument $source, array $parameters = array())
 {
     $xsl = new \DomDocument();
     $xsl->load($templatePath);
     $processor = new \XsltProcessor();
     $processor->importStylesheet($xsl);
     $outputDom = $processor->transformToDoc($source);
     if ($parameters['output.type'] && $parameters['output.type'] == 'xml') {
         $result = $outputDom->saveXML();
     } else {
         $result = $outputDom->saveHTML();
     }
     return $result;
 }

 /**
  * Register the service provider.
  *
  * @return void
  */
 public function register()
 {
     $this->app->singleton('view', function ($app) {
         $xsltProcessor = new XsltProcessor();
         $xsltProcessor->registerPHPFunctions();
         $extendedSimpleXMLElement = new ExtendedSimpleXMLElement('<App/>');
         $factory = new XSLTFactory($app['view.engine.resolver'], $app['view.finder'], $app['events'], $extendedSimpleXMLElement);
         $factory->setContainer($app);
         $factory->addExtension('xsl', 'xslt', function () use($xsltProcessor, $extendedSimpleXMLElement, $app) {
             return new XSLTEngine($xsltProcessor, $extendedSimpleXMLElement, $app['events']);
         });
         return $factory;
     });
 }

function getInterpretedXslt($xslPath, $xmlPath, $xsltProcessor = null)
{
    if ($xsltProcessor == null) {
        $xsltProcessor = new XsltProcessor();
        $xsltProcessor->registerPHPFunctions();
    }
    $xsl = new DOMDocument();
    $xsl->load($xslPath);
    $xsltProcessor->importStylesheet($xsl);
    $xml = new DOMDocument();
    $xml->load($xmlPath);
    $output = $xsltProcessor->transformToXML($xml) or die('Transformation error!');
    return $output;
}

 public function run($args)
 {
     // Get variables from args array passed into detached process.
     $filepath = $args['filepath'];
     $filename = !empty($args['csv_filename']) ? $args['csv_filename'] : pathinfo($filename, PATHINFO_BASENAME);
     $format = $args['format'];
     $itemTypeId = $args['item_type_id'];
     $collectionId = $args['collection_id'];
     $createCollections = $args['create_collections'];
     $recordsArePublic = $args['public'];
     $recordsAreFeatured = $args['featured'];
     $elementsAreHtml = $args['html_elements'];
     $containsExtraData = $args['extra_data'];
     $tagName = $args['tag_name'];
     $columnDelimiter = $args['column_delimiter'];
     $enclosure = $args['enclosure'];
     $elementDelimiter = $args['element_delimiter'];
     $tagDelimiter = $args['tag_delimiter'];
     $fileDelimiter = $args['file_delimiter'];
     // TODO Intermediate stylesheets are not managed currently.
     // $stylesheetIntermediate = $args['stylesheet_intermediate'];
     $stylesheetParameters = $args['stylesheet_parameters'];
     $stylesheet = !empty($args['stylesheet']) ? $args['stylesheet'] : get_option('xml_import_xsl_directory') . DIRECTORY_SEPARATOR . get_option('xml_import_stylesheet');
     $csvfilesdir = !empty($args['destination_dir']) ? $args['destination_dir'] : sys_get_temp_dir();
     // Create a DOM document and load the XML data.
     $xml_doc = new DomDocument();
     $xml_doc->load($filepath);
     // Create a DOM document and load the XSL stylesheet.
     $xsl = new DomDocument();
     $xsl->load($stylesheet);
     // Import the XSL styelsheet into the XSLT process.
     $xp = new XsltProcessor();
     $xp->setParameter('', 'node', $tagName);
     $xp->importStylesheet($xsl);
     // Write transformed xml file to the temp csv file.
     try {
         if ($doc = $xp->transformToXML($xml_doc)) {
             $csvFilename = $csvfilesdir . DIRECTORY_SEPARATOR . pathinfo($filename, PATHINFO_FILENAME) . '.csv';
             $documentFile = fopen($csvFilename, 'w');
             fwrite($documentFile, $doc);
             fclose($documentFile);
             //$this->_initializeCsvImport($basename, $recordsArePublic, $recordsAreFeatured, $collectionId);
             $this->_helper->flashMessenger(__('Successfully generated CSV File'));
         } else {
             $this->_helper->flashMessenger(__('Could not transform XML file.  Be sure your XML document is valid.'), 'error');
         }
     } catch (Exception $e) {
         $this->view->error = $e->getMessage();
     }
 }

 /**
  * translate xml
  *
  * @param string $xml_dom 
  * @param string $xsl_dom 
  * @param string $params 
  * @param string $php_functions 
  * @return void
  * @author Andy Bennett
  */
 private static function translate($xml_dom, $xsl_dom, $params = array(), $php_functions = array())
 {
     /* create the processor and import the stylesheet */
     $proc = new XsltProcessor();
     $proc->importStyleSheet($xsl_dom);
     foreach ($params as $name => $param) {
         $proc->setParameter('', $name, $param);
     }
     if (is_array($php_functions)) {
         $proc->registerPHPFunctions($php_functions);
     }
     /* transform and output the xml document */
     $newdom = $proc->transformToDoc($xml_dom);
     return $newdom->saveXML();
 }

 private function xsltTransform($xmlStr, $xslFile, $toDom = false)
 {
     $doc = new DOMDocument();
     $doc->substituteEntities = TRUE;
     //		$doc->resolveExternals = TRUE;
     $doc->load($xslFile);
     $proc = new XsltProcessor();
     $proc->importStylesheet($doc);
     $doc->loadXML($xmlStr);
     if ($toDom) {
         return $proc->transformToDoc($doc);
     } else {
         return $proc->transformToXml($doc);
     }
 }

 /**
  * Return a formatted html list of resources associated with a given
  * tag.
  *
  * The caller should check the $tr->status variable to see if the
  * query was successful. On anything but a 200 or 304, this method
  * returns nothing, but it would generally be useful to have a
  * warning for 204 (no resources yet for this tag) or 404 (tag not
  * found).
  * 
  * @return string html for a list of resources referenced by the
  * given tag.
  *
  * 
  */
 public function resList()
 {
     if (strlen($this->xml) == 0) {
         $this->getData();
         // args ?
     }
     if ($this->is_valid()) {
         $xsl = new DOMDocument();
         $xsl->load($this->loc->xsl_dir . "public_resourcelist.xsl");
         $proc = new XsltProcessor();
         $xsl = $proc->importStylesheet($xsl);
         // possibly cached DOM
         $taglist = $proc->transformToDoc($this->xml_DOM());
         $this->html = $taglist->saveXML();
         return $this->html;
     }
 }

 public function perform() {
     $action = $this->action;
     $xml_str = $action->perform();
     $xml_doc = simplexml_load_string($xml_str);
     if (!is_null($this->stylesheet)) {
         $xp = new XsltProcessor();
         $xsl = new DomDocument;
         $xsl->load($this->stylesheet);
         $xp->importStylesheet($xsl);
         if ($html = $xp->transformToXML($xml_doc)) {
             return $html;
         } else {
             throw new RtException('XSL transformation failed.');
         }
     } else {
         throw new RtException("Couldn't go on without xslt");
     }
 }

 function getReportDefinitionForm()
 {
     $fileName = "c:/web/afids_reports/trunk/writer/xsl_templates/reportDefinition.xsl";
     $xsl = new DomDocument();
     if (!$xsl->load($fileName)) {
         echo 'failed' . $fileName;
     }
     $stylesheet = new XsltProcessor();
     $stylesheet->importStylesheet($xsl);
     // pass the report name (id) to the xsl and the filtering is done there
     $stylesheet->setParameter(null, "reportName", $this->reportName);
     if (!($translatedResponse = $stylesheet->transformToXML($this->xml_report_definition))) {
         return "error";
     } else {
         return $translatedResponse;
         //echo $translatedResponse;
     }
 }

 function outputXML($projectList)
 {
     $dom = new DOMDocument('1.0');
     $dom->formatOutput = true;
     //header("Content-Type: text/plain");
     $root = $dom->createElement('SVNDump');
     $dom->appendChild($root);
     foreach ($projectList as &$project) {
         $this->addProjectNode($dom, $root, $project);
     }
     $xsl = new DOMDocument('1.0');
     $xsl->load("cs242_portfolio.xsl");
     $proc = new XsltProcessor();
     $xsl = $proc->importStylesheet($xsl);
     $newdom = $proc->transformToDoc($dom);
     echo $newdom->saveHTML();
     //echo $dom->saveXML();
 }

 public function transform($xsl_file = null, $xml_data = null)
 {
     CI()->benchmark->mark('xsl_transform (' . $xsl_file . ')_start');
     set_error_handler(array('XSL_Transform', 'handleError'));
     $xsl = new DOMDocument('1.0', 'UTF-8');
     $xsl->load($this->_getXSL($xsl_file));
     $inputdom = new DomDocument('1.0', 'UTF-8');
     $inputdom->loadXML($this->_getXML($xml_data));
     $proc = new XsltProcessor();
     $proc->importStylesheet($xsl);
     $proc->registerPhpFunctions($this->_allowedFunctions());
     $result = $proc->transformToXML($inputdom);
     // http://www.php.net/manual/en/xsltprocessor.transformtoxml.php#62081
     //$result = $proc->transformToDoc($inputdom);
     //$result = $result->saveHTML();
     restore_error_handler();
     // Strip out any <?xml stuff at top out output
     $result = preg_replace('/\\<\\?xml.+\\?\\>/', '', $result, 1);
     CI()->benchmark->mark('xsl_transform (' . $xsl_file . ')_end');
     return $result;
 }