dokuwiki/inc/parserutils.php

810 lines
27 KiB
PHP

<?php
/**
* Utilities for accessing the parser
*
* @license GPL 2 (http://www.gnu.org/licenses/gpl.html)
* @author Harry Fuecks <hfuecks@gmail.com>
* @author Andreas Gohr <andi@splitbrain.org>
*/
use dokuwiki\Cache\CacheInstructions;
use dokuwiki\Cache\CacheRenderer;
use dokuwiki\ChangeLog\PageChangeLog;
use dokuwiki\Extension\PluginController;
use dokuwiki\Extension\Event;
use dokuwiki\Parsing\Parser;
/**
* How many pages shall be rendered for getting metadata during one request
* at maximum? Note that this limit isn't respected when METADATA_RENDER_UNLIMITED
* is passed as render parameter to p_get_metadata.
*/
if (!defined('P_GET_METADATA_RENDER_LIMIT')) define('P_GET_METADATA_RENDER_LIMIT', 5);
/** Don't render metadata even if it is outdated or doesn't exist */
define('METADATA_DONT_RENDER', 0);
/**
* Render metadata when the page is really newer or the metadata doesn't exist.
* Uses just a simple check, but should work pretty well for loading simple
* metadata values like the page title and avoids rendering a lot of pages in
* one request. The P_GET_METADATA_RENDER_LIMIT is used in this mode.
* Use this if it is unlikely that the metadata value you are requesting
* does depend e.g. on pages that are included in the current page using
* the include plugin (this is very likely the case for the page title, but
* not for relation references).
*/
define('METADATA_RENDER_USING_SIMPLE_CACHE', 1);
/**
* Render metadata using the metadata cache logic. The P_GET_METADATA_RENDER_LIMIT
* is used in this mode. Use this mode when you are requesting more complex
* metadata. Although this will cause rendering more often it might actually have
* the effect that less current metadata is returned as it is more likely than in
* the simple cache mode that metadata needs to be rendered for all pages at once
* which means that when the metadata for the page is requested that actually needs
* to be updated the limit might have been reached already.
*/
define('METADATA_RENDER_USING_CACHE', 2);
/**
* Render metadata without limiting the number of pages for which metadata is
* rendered. Use this mode with care, normally it should only be used in places
* like the indexer or in cli scripts where the execution time normally isn't
* limited. This can be combined with the simple cache using
* METADATA_RENDER_USING_CACHE | METADATA_RENDER_UNLIMITED.
*/
define('METADATA_RENDER_UNLIMITED', 4);
/**
* Returns the parsed Wikitext in XHTML for the given id and revision.
*
* If $excuse is true an explanation is returned if the file
* wasn't found
*
* @author Andreas Gohr <andi@splitbrain.org>
*
* @param string $id page id
* @param string|int $rev revision timestamp or empty string
* @param bool $excuse
* @param string $date_at
*
* @return null|string
*/
function p_wiki_xhtml($id, $rev='', $excuse=true,$date_at=''){
$file = wikiFN($id,$rev);
$ret = '';
//ensure $id is in global $ID (needed for parsing)
global $ID;
$keep = $ID;
$ID = $id;
if($rev || $date_at){
if(file_exists($file)){
//no caching on old revisions
$ret = p_render('xhtml',p_get_instructions(io_readWikiPage($file,$id,$rev)),$info,$date_at);
}elseif($excuse){
$ret = p_locale_xhtml('norev');
}
}else{
if(file_exists($file)){
$ret = p_cached_output($file,'xhtml',$id);
}elseif($excuse){
//check if the page once existed
$changelog = new PageChangeLog($id);
if($changelog->hasRevisions()) {
$ret = p_locale_xhtml('onceexisted');
} else {
$ret = p_locale_xhtml('newpage');
}
}
}
//restore ID (just in case)
$ID = $keep;
return $ret;
}
/**
* Returns the specified local text in parsed format
*
* @author Andreas Gohr <andi@splitbrain.org>
*
* @param string $id page id
* @return null|string
*/
function p_locale_xhtml($id){
//fetch parsed locale
$html = p_cached_output(localeFN($id));
return $html;
}
/**
* Returns the given file parsed into the requested output format
*
* @author Andreas Gohr <andi@splitbrain.org>
* @author Chris Smith <chris@jalakai.co.uk>
*
* @param string $file filename, path to file
* @param string $format
* @param string $id page id
* @return null|string
*/
function p_cached_output($file, $format='xhtml', $id='') {
global $conf;
$cache = new CacheRenderer($id, $file, $format);
if ($cache->useCache()) {
$parsed = $cache->retrieveCache(false);
if($conf['allowdebug'] && $format=='xhtml') {
$parsed .= "\n<!-- cachefile {$cache->cache} used -->\n";
}
} else {
$parsed = p_render($format, p_cached_instructions($file,false,$id), $info);
if ($info['cache'] && $cache->storeCache($parsed)) { // storeCache() attempts to save cachefile
if($conf['allowdebug'] && $format=='xhtml') {
$parsed .= "\n<!-- no cachefile used, but created {$cache->cache} -->\n";
}
}else{
$cache->removeCache(); //try to delete cachefile
if($conf['allowdebug'] && $format=='xhtml') {
$parsed .= "\n<!-- no cachefile used, caching forbidden -->\n";
}
}
}
return $parsed;
}
/**
* Returns the render instructions for a file
*
* Uses and creates a serialized cache file
*
* @author Andreas Gohr <andi@splitbrain.org>
*
* @param string $file filename, path to file
* @param bool $cacheonly
* @param string $id page id
* @return array|null
*/
function p_cached_instructions($file,$cacheonly=false,$id='') {
static $run = null;
if(is_null($run)) $run = array();
$cache = new CacheInstructions($id, $file);
if ($cacheonly || $cache->useCache() || (isset($run[$file]) && !defined('DOKU_UNITTEST'))) {
return $cache->retrieveCache();
} else if (file_exists($file)) {
// no cache - do some work
$ins = p_get_instructions(io_readWikiPage($file,$id));
if ($cache->storeCache($ins)) {
$run[$file] = true; // we won't rebuild these instructions in the same run again
} else {
msg('Unable to save cache file. Hint: disk full; file permissions; safe_mode setting.',-1);
}
return $ins;
}
return null;
}
/**
* turns a page into a list of instructions
*
* @author Harry Fuecks <hfuecks@gmail.com>
* @author Andreas Gohr <andi@splitbrain.org>
*
* @param string $text raw wiki syntax text
* @return array a list of instruction arrays
*/
function p_get_instructions($text){
$modes = p_get_parsermodes();
// Create the parser and handler
$Parser = new Parser(new Doku_Handler());
//add modes to parser
foreach($modes as $mode){
$Parser->addMode($mode['mode'],$mode['obj']);
}
// Do the parsing
Event::createAndTrigger('PARSER_WIKITEXT_PREPROCESS', $text);
$p = $Parser->parse($text);
// dbg($p);
return $p;
}
/**
* returns the metadata of a page
*
* @param string $id The id of the page the metadata should be returned from
* @param string $key The key of the metdata value that shall be read (by default everything)
* separate hierarchies by " " like "date created"
* @param int $render If the page should be rendererd - possible values:
* METADATA_DONT_RENDER, METADATA_RENDER_USING_SIMPLE_CACHE, METADATA_RENDER_USING_CACHE
* METADATA_RENDER_UNLIMITED (also combined with the previous two options),
* default: METADATA_RENDER_USING_CACHE
* @return mixed The requested metadata fields
*
* @author Esther Brunner <esther@kaffeehaus.ch>
* @author Michael Hamann <michael@content-space.de>
*/
function p_get_metadata($id, $key='', $render=METADATA_RENDER_USING_CACHE){
global $ID;
static $render_count = 0;
// track pages that have already been rendered in order to avoid rendering the same page
// again
static $rendered_pages = array();
// cache the current page
// Benchmarking shows the current page's metadata is generally the only page metadata
// accessed several times. This may catch a few other pages, but that shouldn't be an issue.
$cache = ($ID == $id);
$meta = p_read_metadata($id, $cache);
if (!is_numeric($render)) {
if ($render) {
$render = METADATA_RENDER_USING_SIMPLE_CACHE;
} else {
$render = METADATA_DONT_RENDER;
}
}
// prevent recursive calls in the cache
static $recursion = false;
if (!$recursion && $render != METADATA_DONT_RENDER && !isset($rendered_pages[$id])&& page_exists($id)){
$recursion = true;
$cachefile = new CacheRenderer($id, wikiFN($id), 'metadata');
$do_render = false;
if ($render & METADATA_RENDER_UNLIMITED || $render_count < P_GET_METADATA_RENDER_LIMIT) {
if ($render & METADATA_RENDER_USING_SIMPLE_CACHE) {
$pagefn = wikiFN($id);
$metafn = metaFN($id, '.meta');
if (!file_exists($metafn) || @filemtime($pagefn) > @filemtime($cachefile->cache)) {
$do_render = true;
}
} elseif (!$cachefile->useCache()){
$do_render = true;
}
}
if ($do_render) {
if (!defined('DOKU_UNITTEST')) {
++$render_count;
$rendered_pages[$id] = true;
}
$old_meta = $meta;
$meta = p_render_metadata($id, $meta);
// only update the file when the metadata has been changed
if ($meta == $old_meta || p_save_metadata($id, $meta)) {
// store a timestamp in order to make sure that the cachefile is touched
// this timestamp is also stored when the meta data is still the same
$cachefile->storeCache(time());
} else {
msg('Unable to save metadata file. Hint: disk full; file permissions; safe_mode setting.',-1);
}
}
$recursion = false;
}
$val = $meta['current'];
// filter by $key
foreach(preg_split('/\s+/', $key, 2, PREG_SPLIT_NO_EMPTY) as $cur_key) {
if (!isset($val[$cur_key])) {
return null;
}
$val = $val[$cur_key];
}
return $val;
}
/**
* sets metadata elements of a page
*
* @see http://www.dokuwiki.org/devel:metadata#functions_to_get_and_set_metadata
*
* @param string $id is the ID of a wiki page
* @param array $data is an array with key ⇒ value pairs to be set in the metadata
* @param boolean $render whether or not the page metadata should be generated with the renderer
* @param boolean $persistent indicates whether or not the particular metadata value will persist through
* the next metadata rendering.
* @return boolean true on success
*
* @author Esther Brunner <esther@kaffeehaus.ch>
* @author Michael Hamann <michael@content-space.de>
*/
function p_set_metadata($id, $data, $render=false, $persistent=true){
if (!is_array($data)) return false;
global $ID, $METADATA_RENDERERS;
// if there is currently a renderer change the data in the renderer instead
if (isset($METADATA_RENDERERS[$id])) {
$orig =& $METADATA_RENDERERS[$id];
$meta = $orig;
} else {
// cache the current page
$cache = ($ID == $id);
$orig = p_read_metadata($id, $cache);
// render metadata first?
$meta = $render ? p_render_metadata($id, $orig) : $orig;
}
// now add the passed metadata
$protected = array('description', 'date', 'contributor');
foreach ($data as $key => $value){
// be careful with sub-arrays of $meta['relation']
if ($key == 'relation'){
foreach ($value as $subkey => $subvalue){
if(isset($meta['current'][$key][$subkey]) && is_array($meta['current'][$key][$subkey])) {
$meta['current'][$key][$subkey] = array_replace($meta['current'][$key][$subkey], (array)$subvalue);
} else {
$meta['current'][$key][$subkey] = $subvalue;
}
if($persistent) {
if(isset($meta['persistent'][$key][$subkey]) && is_array($meta['persistent'][$key][$subkey])) {
$meta['persistent'][$key][$subkey] = array_replace(
$meta['persistent'][$key][$subkey],
(array) $subvalue
);
} else {
$meta['persistent'][$key][$subkey] = $subvalue;
}
}
}
// be careful with some senisitive arrays of $meta
} elseif (in_array($key, $protected)){
// these keys, must have subkeys - a legitimate value must be an array
if (is_array($value)) {
$meta['current'][$key] = !empty($meta['current'][$key]) ?
array_replace((array)$meta['current'][$key],$value) :
$value;
if ($persistent) {
$meta['persistent'][$key] = !empty($meta['persistent'][$key]) ?
array_replace((array)$meta['persistent'][$key],$value) :
$value;
}
}
// no special treatment for the rest
} else {
$meta['current'][$key] = $value;
if ($persistent) $meta['persistent'][$key] = $value;
}
}
// save only if metadata changed
if ($meta == $orig) return true;
if (isset($METADATA_RENDERERS[$id])) {
// set both keys individually as the renderer has references to the individual keys
$METADATA_RENDERERS[$id]['current'] = $meta['current'];
$METADATA_RENDERERS[$id]['persistent'] = $meta['persistent'];
return true;
} else {
return p_save_metadata($id, $meta);
}
}
/**
* Purges the non-persistant part of the meta data
* used on page deletion
*
* @author Michael Klier <chi@chimeric.de>
*
* @param string $id page id
* @return bool success / fail
*/
function p_purge_metadata($id) {
$meta = p_read_metadata($id);
foreach($meta['current'] as $key => $value) {
if(is_array($meta[$key])) {
$meta['current'][$key] = array();
} else {
$meta['current'][$key] = '';
}
}
return p_save_metadata($id, $meta);
}
/**
* read the metadata from source/cache for $id
* (internal use only - called by p_get_metadata & p_set_metadata)
*
* @author Christopher Smith <chris@jalakai.co.uk>
*
* @param string $id absolute wiki page id
* @param bool $cache whether or not to cache metadata in memory
* (only use for metadata likely to be accessed several times)
*
* @return array metadata
*/
function p_read_metadata($id,$cache=false) {
global $cache_metadata;
if (isset($cache_metadata[(string)$id])) return $cache_metadata[(string)$id];
$file = metaFN($id, '.meta');
$meta = file_exists($file) ?
unserialize(io_readFile($file, false)) :
array('current'=>array(),'persistent'=>array());
if ($cache) {
$cache_metadata[(string)$id] = $meta;
}
return $meta;
}
/**
* This is the backend function to save a metadata array to a file
*
* @param string $id absolute wiki page id
* @param array $meta metadata
*
* @return bool success / fail
*/
function p_save_metadata($id, $meta) {
// sync cached copies, including $INFO metadata
global $cache_metadata, $INFO;
if (isset($cache_metadata[$id])) $cache_metadata[$id] = $meta;
if (!empty($INFO) && ($id == $INFO['id'])) { $INFO['meta'] = $meta['current']; }
return io_saveFile(metaFN($id, '.meta'), serialize($meta));
}
/**
* renders the metadata of a page
*
* @author Esther Brunner <esther@kaffeehaus.ch>
*
* @param string $id page id
* @param array $orig the original metadata
* @return array|null array('current'=> array,'persistent'=> array);
*/
function p_render_metadata($id, $orig){
// make sure the correct ID is in global ID
global $ID, $METADATA_RENDERERS;
// avoid recursive rendering processes for the same id
if (isset($METADATA_RENDERERS[$id])) {
return $orig;
}
// store the original metadata in the global $METADATA_RENDERERS so p_set_metadata can use it
$METADATA_RENDERERS[$id] =& $orig;
$keep = $ID;
$ID = $id;
// add an extra key for the event - to tell event handlers the page whose metadata this is
$orig['page'] = $id;
$evt = new Event('PARSER_METADATA_RENDER', $orig);
if ($evt->advise_before()) {
// get instructions
$instructions = p_cached_instructions(wikiFN($id),false,$id);
if(is_null($instructions)){
$ID = $keep;
unset($METADATA_RENDERERS[$id]);
return null; // something went wrong with the instructions
}
// set up the renderer
$renderer = new Doku_Renderer_metadata();
$renderer->meta =& $orig['current'];
$renderer->persistent =& $orig['persistent'];
// loop through the instructions
foreach ($instructions as $instruction){
// execute the callback against the renderer
call_user_func_array(array(&$renderer, $instruction[0]), (array) $instruction[1]);
}
$evt->result = array('current'=>&$renderer->meta,'persistent'=>&$renderer->persistent);
}
$evt->advise_after();
// clean up
$ID = $keep;
unset($METADATA_RENDERERS[$id]);
return $evt->result;
}
/**
* returns all available parser syntax modes in correct order
*
* @author Andreas Gohr <andi@splitbrain.org>
*
* @return array[] with for each plugin the array('sort' => sortnumber, 'mode' => mode string, 'obj' => plugin object)
*/
function p_get_parsermodes(){
global $conf;
//reuse old data
static $modes = null;
if($modes != null && !defined('DOKU_UNITTEST')){
return $modes;
}
//import parser classes and mode definitions
require_once DOKU_INC . 'inc/parser/parser.php';
// we now collect all syntax modes and their objects, then they will
// be sorted and added to the parser in correct order
$modes = array();
// add syntax plugins
$pluginlist = plugin_list('syntax');
if(count($pluginlist)){
global $PARSER_MODES;
$obj = null;
foreach($pluginlist as $p){
/** @var \dokuwiki\Extension\SyntaxPlugin $obj */
if(!$obj = plugin_load('syntax',$p)) continue; //attempt to load plugin into $obj
$PARSER_MODES[$obj->getType()][] = "plugin_$p"; //register mode type
//add to modes
$modes[] = array(
'sort' => $obj->getSort(),
'mode' => "plugin_$p",
'obj' => $obj,
);
unset($obj); //remove the reference
}
}
// add default modes
$std_modes = array('listblock','preformatted','notoc','nocache',
'header','table','linebreak','footnote','hr',
'unformatted','php','html','code','file','quote',
'internallink','rss','media','externallink',
'emaillink','windowssharelink','eol');
if($conf['typography']){
$std_modes[] = 'quotes';
$std_modes[] = 'multiplyentity';
}
foreach($std_modes as $m){
$class = 'dokuwiki\\Parsing\\ParserMode\\'.ucfirst($m);
$obj = new $class();
$modes[] = array(
'sort' => $obj->getSort(),
'mode' => $m,
'obj' => $obj
);
}
// add formatting modes
$fmt_modes = array('strong','emphasis','underline','monospace',
'subscript','superscript','deleted');
foreach($fmt_modes as $m){
$obj = new \dokuwiki\Parsing\ParserMode\Formatting($m);
$modes[] = array(
'sort' => $obj->getSort(),
'mode' => $m,
'obj' => $obj
);
}
// add modes which need files
$obj = new \dokuwiki\Parsing\ParserMode\Smiley(array_keys(getSmileys()));
$modes[] = array('sort' => $obj->getSort(), 'mode' => 'smiley','obj' => $obj );
$obj = new \dokuwiki\Parsing\ParserMode\Acronym(array_keys(getAcronyms()));
$modes[] = array('sort' => $obj->getSort(), 'mode' => 'acronym','obj' => $obj );
$obj = new \dokuwiki\Parsing\ParserMode\Entity(array_keys(getEntities()));
$modes[] = array('sort' => $obj->getSort(), 'mode' => 'entity','obj' => $obj );
// add optional camelcase mode
if($conf['camelcase']){
$obj = new \dokuwiki\Parsing\ParserMode\Camelcaselink();
$modes[] = array('sort' => $obj->getSort(), 'mode' => 'camelcaselink','obj' => $obj );
}
//sort modes
usort($modes,'p_sort_modes');
return $modes;
}
/**
* Callback function for usort
*
* @author Andreas Gohr <andi@splitbrain.org>
*
* @param array $a
* @param array $b
* @return int $a is lower/equal/higher than $b
*/
function p_sort_modes($a, $b){
if($a['sort'] == $b['sort']) return 0;
return ($a['sort'] < $b['sort']) ? -1 : 1;
}
/**
* Renders a list of instruction to the specified output mode
*
* In the $info array is information from the renderer returned
*
* @author Harry Fuecks <hfuecks@gmail.com>
* @author Andreas Gohr <andi@splitbrain.org>
*
* @param string $mode
* @param array|null|false $instructions
* @param array $info returns render info like enabled toc and cache
* @param string $date_at
* @return null|string rendered output
*/
function p_render($mode,$instructions,&$info,$date_at=''){
if(is_null($instructions)) return '';
if($instructions === false) return '';
$Renderer = p_get_renderer($mode);
if (is_null($Renderer)) return null;
$Renderer->reset();
if($date_at) {
$Renderer->date_at = $date_at;
}
$Renderer->smileys = getSmileys();
$Renderer->entities = getEntities();
$Renderer->acronyms = getAcronyms();
$Renderer->interwiki = getInterwiki();
// Loop through the instructions
foreach ( $instructions as $instruction ) {
// Execute the callback against the Renderer
if(method_exists($Renderer, $instruction[0])){
call_user_func_array(array(&$Renderer, $instruction[0]), $instruction[1] ? $instruction[1] : array());
}
}
//set info array
$info = $Renderer->info;
// Post process and return the output
$data = array($mode,& $Renderer->doc);
Event::createAndTrigger('RENDERER_CONTENT_POSTPROCESS',$data);
return $Renderer->doc;
}
/**
* Figure out the correct renderer class to use for $mode,
* instantiate and return it
*
* @param string $mode Mode of the renderer to get
* @return null|Doku_Renderer The renderer
*
* @author Christopher Smith <chris@jalakai.co.uk>
*/
function p_get_renderer($mode) {
/** @var PluginController $plugin_controller */
global $conf, $plugin_controller;
$rname = !empty($conf['renderer_'.$mode]) ? $conf['renderer_'.$mode] : $mode;
$rclass = "Doku_Renderer_$rname";
// if requested earlier or a bundled renderer
if( class_exists($rclass) ) {
$Renderer = new $rclass();
return $Renderer;
}
// not bundled, see if its an enabled renderer plugin & when $mode is 'xhtml', the renderer can supply that format.
/** @var Doku_Renderer $Renderer */
$Renderer = $plugin_controller->load('renderer',$rname);
if ($Renderer && is_a($Renderer, 'Doku_Renderer') && ($mode != 'xhtml' || $mode == $Renderer->getFormat())) {
return $Renderer;
}
// there is a configuration error!
// not bundled, not a valid enabled plugin, use $mode to try to fallback to a bundled renderer
$rclass = "Doku_Renderer_$mode";
if ( class_exists($rclass) ) {
// viewers should see renderered output, so restrict the warning to admins only
$msg = "No renderer '$rname' found for mode '$mode', check your plugins";
if ($mode == 'xhtml') {
$msg .= " and the 'renderer_xhtml' config setting";
}
$msg .= ".<br/>Attempting to fallback to the bundled renderer.";
msg($msg,-1,'','',MSG_ADMINS_ONLY);
$Renderer = new $rclass;
$Renderer->nocache(); // fallback only (and may include admin alerts), don't cache
return $Renderer;
}
// fallback failed, alert the world
msg("No renderer '$rname' found for mode '$mode'",-1);
return null;
}
/**
* Gets the first heading from a file
*
* @param string $id dokuwiki page id
* @param int $render rerender if first heading not known
* default: METADATA_RENDER_USING_SIMPLE_CACHE
* Possible values: METADATA_DONT_RENDER,
* METADATA_RENDER_USING_SIMPLE_CACHE,
* METADATA_RENDER_USING_CACHE,
* METADATA_RENDER_UNLIMITED
* @return string|null The first heading
*
* @author Andreas Gohr <andi@splitbrain.org>
* @author Michael Hamann <michael@content-space.de>
*/
function p_get_first_heading($id, $render=METADATA_RENDER_USING_SIMPLE_CACHE){
return p_get_metadata(cleanID($id),'title',$render);
}
/**
* Wrapper for GeSHi Code Highlighter, provides caching of its output
*
* @param string $code source code to be highlighted
* @param string $language language to provide highlighting
* @param string $wrapper html element to wrap the returned highlighted text
* @return string xhtml code
*
* @author Christopher Smith <chris@jalakai.co.uk>
* @author Andreas Gohr <andi@splitbrain.org>
*/
function p_xhtml_cached_geshi($code, $language, $wrapper='pre', array $options=null) {
global $conf, $config_cascade, $INPUT;
$language = strtolower($language);
// remove any leading or trailing blank lines
$code = preg_replace('/^\s*?\n|\s*?\n$/','',$code);
$optionsmd5 = md5(serialize($options));
$cache = getCacheName($language.$code.$optionsmd5,".code");
$ctime = @filemtime($cache);
if($ctime && !$INPUT->bool('purge') &&
$ctime > filemtime(DOKU_INC.'vendor/composer/installed.json') && // libraries changed
$ctime > filemtime(reset($config_cascade['main']['default']))){ // dokuwiki changed
$highlighted_code = io_readFile($cache, false);
} else {
$geshi = new GeSHi($code, $language);
$geshi->set_encoding('utf-8');
$geshi->enable_classes();
$geshi->set_header_type(GESHI_HEADER_PRE);
$geshi->set_link_target($conf['target']['extern']);
if($options !== null) {
foreach ($options as $function => $params) {
if(is_callable(array($geshi, $function))) {
$geshi->$function($params);
}
}
}
// remove GeSHi's wrapper element (we'll replace it with our own later)
// we need to use a GeSHi wrapper to avoid <BR> throughout the highlighted text
$highlighted_code = trim(preg_replace('!^<pre[^>]*>|</pre>$!','',$geshi->parse_code()),"\n\r");
io_saveFile($cache,$highlighted_code);
}
// add a wrapper element if required
if ($wrapper) {
return "<$wrapper class=\"code $language\">$highlighted_code</$wrapper>";
} else {
return $highlighted_code;
}
}