path: root/paste/include/class.geshi.php

<?php
/**
 * GeSHi - Generic Syntax Highlighter
 * 
 * For information on how to use GeSHi, please consult the documentation
 * found in the docs/ directory, or online at http://geshi.org/docs/
 * 
 *  This file is part of GeSHi.
 *
 *  GeSHi is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  GeSHi is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with GeSHi; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 * You can view a copy of the GNU GPL in the COPYING file that comes
 * with GeSHi, in the docs/ directory.
 *
 * @package   core
 * @author    Nigel McNie <nigel@geshi.org>
 * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL
 * @copyright (C) 2004, 2005 Nigel McNie
 * @version   1.1.0
 * 
 */

/**
 * MAJOR TODOs:
 * 
 * @todo [blocking 1.1.1] (bug 5) Support balanced context endings
 * @todo [blocking 1.1.1] (bug 14) OCCs should be able to modify their parent context
 * @todo [blocking 1.1.1] (bug 16, 17) Better Delphi and Codeworker support
 */

/** GeSHi Version */
define('GESHI_VERSION', '1.1.0');

/** Set the correct directory separator */
define('GESHI_DIR_SEPARATOR', ('WIN' != substr(PHP_OS, 0, 3)) ? '/' : '\\');

// Define the root directory for the GeSHi code tree
if (!defined('GESHI_ROOT')) {
    /** The root directory for GeSHi (where class.geshi.php is located) */
    define('GESHI_ROOT', dirname(__FILE__) . GESHI_DIR_SEPARATOR);
}

/**#@+
 * @access private
 */
/** The data directory for GeSHi */
define('GESHI_DATA_ROOT', GESHI_ROOT . 'geshi' . GESHI_DIR_SEPARATOR);
/** The classes directory for GeSHi */
define('GESHI_CLASSES_ROOT', GESHI_DATA_ROOT . 'classes' . GESHI_DIR_SEPARATOR);
/** The languages directory for GeSHi */
define('GESHI_LANGUAGES_ROOT', GESHI_DATA_ROOT . 'languages' . GESHI_DIR_SEPARATOR);
/** The context files directory for GeSHi */
define('GESHI_CONTEXTS_ROOT', GESHI_DATA_ROOT . 'contexts' . GESHI_DIR_SEPARATOR);
/** The theme files directory for GeSHi */
define('GESHI_THEMES_ROOT', GESHI_DATA_ROOT . 'themes' . GESHI_DIR_SEPARATOR);
/**#@-*/

/** Get required functions */
require GESHI_DATA_ROOT . 'functions.geshi.php';

/** Get styler class */
require GESHI_CLASSES_ROOT . 'class.geshistyler.php';

/** Get context class */
require GESHI_CLASSES_ROOT . 'class.geshicontext.php';


//
// Constants
//

// Debugging constants. These will disappear in stable builds. Specify
// as a bitfield, e.g. GESHI_DBG_API | GESHI_DBG_PARSE, by defining the
// GESHI_DBG context before including this file
/** No debugging */
define('GESHI_DBG_NONE', 0);
/** Debug the API */
define('GESHI_DBG_API', 1);
/** Debug actual parsing */
define('GESHI_DBG_PARSE', 2);
/** Debug error handling */
define('GESHI_DBG_ERR', 4);
/** Maximum debug level */
define('GESHI_DBG_ALL', GESHI_DBG_API | GESHI_DBG_PARSE | GESHI_DBG_ERR);

// Set efault debug level
if (!defined('GESHI_DBG')) {
    /** Default debug level */
    define('GESHI_DBG', GESHI_DBG_NONE);
}

// These provide BACKWARD COMPATIBILITY ONLY
// Use New Method setStyles(mixed identifiers, string styles);
// e.g. setStyles('html/tag', 'styles');
//      setStyles(array('html/tag', 'html/css-delimiters'), 'style');
/** Used to mark a context as having no equivalence in 1.0.X */
define('GESHI_STYLE_NONE', 0);
/** Used to mark a context as being like a number in 1.0.X */
define('GESHI_STYLE_NUMBERS', 1);
/** Used to mark a context as being like a comment in 1.0.X */
define('GESHI_STYLE_COMMENTS', 2);
/** Used to mark a context as being like a string in 1.0.X */
define('GESHI_STYLE_STRINGS', 3);
/** Used to mark a context as being like a symbol in 1.0.X */
define('GESHI_STYLE_SYMBOLS', 4);
/** Used to mark a context as being like a method in 1.0.X */
define('GESHI_STYLE_METHODS', 5);

/**#@+
 * @access private
 */

// Error related constants, not needed by users of GeSHi
/** No error has occured */
define('GESHI_ERROR_NONE', 0);
/** There is no source code to highlight */
define('GESHI_ERROR_NO_INPUT', 1);
/** You don't have a language file for the specified language */
define('GESHI_ERROR_NO_SUCH_LANG', 2);
/** The language name contained illegal characters */
define('GESHI_ERROR_LANG_NAME_ILLEGAL_CHARS', 4);
/** The path specified is not readable */
//define('GESHI_ERROR_ILLEGAL_PATH', 5);
/** The theme specified does not exist */
//define('GESHI_ERROR_NO_SUCH_THEME', 6);
/** Parsing is in strict mode, but the root context does not have a specific opener */
//define('GESHI_ERROR_STRICT_MODE_NO_OPENER', 7);
/** getTime($type) was called with an invalid type */
define('GESHI_ERROR_INVALID_TIME_TYPE', 8);
/** A file that was requested for loading data is not available */
define('GESHI_ERROR_FILE_UNAVAILABLE', 9);

// Constants for specifying who (out of the parent or child) highlights the delimiter
// between the parent and the child. Note that if you view the numbers as two bit binary,
// a 1 indicates where the child parses and a 0 indicates where the parent should parse.
// The default is GESHI_CHILD_PARSE_BOTH
/** The child should parse neither delimiter (parent parses both) */
define('GESHI_CHILD_PARSE_NONE', 0);
/** The child should parse the right (end) delimiter, the parent should parse the left delimiter */
define('GESHI_CHILD_PARSE_RIGHT', 1);
/** The child should parse the left (beginning) delimiter, the parent should parse the right delimiter */
define('GESHI_CHILD_PARSE_LEFT', 2);
/** The child should parse both delimiters (default) */
define('GESHI_CHILD_PARSE_BOTH', 3);

// The name of integer/double number contexts
define('GESHI_NUM_INT', 'num/int');
define('GESHI_NUM_DBL', 'num/dbl');

/** Default file extension */
define('GESHI_DEFAULT_FILE_EXTENSION', '.php');

/**#@-*/


/**
 * The GeSHi class
 *
 * @package core 
 * @author  Nigel McNie <nigel@geshi.org>
 * @version   1.1.0
 * @since   1.0.0
 */
class GeSHi
{
    /**#@+
     * @access private
     * @var string
     */

    /**
     * The source code to parse
     */
    var $_source;

    /**
     * The name of the language to use when parsing the source
     */
    var $language;

    /**
     * The humanised version of the language name
     */
    var $humanLanguageName;

    /**
     * The error code of any error that has occured
     */
    var $_error;

    /**#@-*/
    /**#@+
     * @access private
     */

    /**
     * The root context to use for parsing the source
     * 
     * @var GeSHiContext
     */
    var $_rootContext;
    
    /**
     * Whether this object should be prepared as if it will be used
     * many times
     * 
     * @var boolean
     */
    var $_cacheRootContext;
    
    /**
     * The cached root context, if caching of context trees is enabled
     * 
     * @var GeSHiContext
     */
    var $_cachedRootContext;
    
    /**
     * The GeSHiStyler object used by this class and all contexts for
     * assisting parsing.
     * 
     * @var GeSHiStyler
     */

    /**#@-*/
    
    /**
     * Sets the source and language name of the source to parse
     *
     * Also sets up other defaults, such as the default encoding
     * 
     * <b>USAGE:</b>
     * 
     * <pre>$geshi =& new GeSHi($source, $language);
     * if (false !== ($msg = $geshi->error())) {
     *     // Handle error here: error message in $msg
     * }
     * $code = $geshi->parseCode();</pre>
     *
     * @param string The source code to highlight
     * @param string The language to highlight the source with
     * @param string The path to the GeSHi data files. <b>This is no longer used!</b> The path is detected
     *               automatically by GeSHi, this paramters is only included for backward compatibility. If
     *               you want to set the path to the GeSHi data directories yourself, you should define the
     *               GESHI_ROOT constant before including class.geshi.php.
     * @since 1.0.0
     */
    function GeSHi ($source, $language_name, $path = '')
    {
        geshi_dbg('GeSHi::GeSHi (language='.$language_name.')', GESHI_DBG_API);

        // Initialise timing
        $initial_times = array(0 => '0 0', 1 => '0 0');
        $this->_times = array(
            'pre'   => $initial_times,
            'parse' => $initial_times,
            'post'  => $initial_times
        );
        
        $this->_styler =& new GeSHiStyler;

        // @todo [blocking 1.1.5] Make third parameter an option array thing        
        
        $this->setFileExtension(GESHI_DEFAULT_FILE_EXTENSION);
        //$this->setOutputFormat(GESHI_OUTPUT_HTML);
        //$this->setEncoding(GESHI_DEFAULT_ENCODING);

        // Set the initial source/language
        $this->setSource($source);
        $this->setLanguage($language_name);
    }

    /**
     * Returns an error message if there has been an error. Useful for debugging,
     * but not recommended for use on a live site.
     * 
     * The last error that occured is returned by this method
     * @todo [blocking 1.1.9] Documentation: has this changed from 1.0.X?
     *
     * @return false|string A message if there is an error, else false
     * @since  1.0.0
     */
    function error ()
    {
        geshi_dbg('GeSHi::error()', GESHI_DBG_ERR | GESHI_DBG_API);
        if ($this->_error) {
            $msg = $this->_getErrorMessage();
            geshi_dbg('  ERR: ' . $this->_error . ': ' . $msg, GESHI_DBG_API | GESHI_DBG_ERR);
            return sprintf('<br /><strong>GeSHi Error:</strong> %s (code %s)<br />',
                    $msg,
                    '<a href="http://geshi.org/developers/error-codes/#' . $this->_error
                    . '">#' . $this->_error . '</a>'
            );
        }
        geshi_dbg('  No error', GESHI_DBG_ERR | GESHI_DBG_API);
        return false;
    }

    /**
     * Sets the source code to highlight
     *
     * @param string The source code to highlight
     * @since 1.0.0
     */
    function setSource ($source)
    {
        geshi_dbg('GeSHi::setSource(' . substr($source, 0, 15) . '...)', GESHI_DBG_API);
        $this->_source = $source;
        if (!$this->_sourceValid()) {
            geshi_dbg('@e  Source code is not valid!', GESHI_DBG_API | GESHI_DBG_ERR);
        }
    }

    /**
     * Sets the source code to highlight. This method is deprecated, and will be
     * removed in 1.4/2.0.
     *
     * @param string The source code to highlight
     * @since 1.0.0
     * @deprecated In favour of {@link setSource()}
     */
    function set_source ($source)
    {
        $this->setSource($source);
    }

    /**
     * Sets the language to use for highlighting
     *
     * @param string The language to use for highlighting
     * @since 1.0.0
     */
    function setLanguage ($language_name)
    {
        $this->_times['pre'][0] = microtime();
        geshi_dbg('GeSHi::setLanguage('.$language_name.')', GESHI_DBG_API);
        $this->_language = strtolower($language_name);
        
        // Make a legal language name
        if (false === strpos($this->_language, '/')) {
            $this->_language .= '/'.$this->_language;
            geshi_dbg('  Language name converted to '.$this->_language, GESHI_DBG_API);
        }

        if ($this->_languageNameValid()) {
            // load language now
            geshi_dbg('@o  Language name fine, loading data', GESHI_DBG_API);
            $this->_parsePreProcess();
        } else {
            geshi_dbg('@e  Language name not OK! (code '.$this->_error.')', GESHI_DBG_API | GESHI_DBG_ERR);
        }

        $this->_times['pre'][1] = microtime();
        geshi_dbg('  Language data loaded in ' . number_format($this->getTime('pre'), 3) . ' seconds', GESHI_DBG_API);
    }

    /**
     * Sets the language to use for highlighting. This method is deprecated, and
     * will be removed in 1.4/2.0.
     *
     * @param string The language to use for highlighting
     * @since 1.0.0
     * @deprecated In favour of {@link setLanguage()}
     */
    function set_language($language_name)
    {
        $this->setLanguage($language_name);
    }
    
    /**
     * Sets whether this object should cache the root context as loaded. Use
     * this if you're going to use the same language in this object to parse
     * multiple source codes.
     *
     * @param boolean true if caching of context data should be used 
     */
    function cacheRootContext ($flag = true)
    {
        geshi_dbg('GeSHi::cacheRootContext(' . $flag . ')', GESHI_DBG_API);
        $this->_cacheRootContext = ($flag) ? true : false;
        $this->_cachedRootContext = ($this->_cacheRootContext) ? $this->_rootContext : null;
        geshi_dbg('  Set caching to ' . $flag . ', cached root context size = ' . count($this->_cachedRootContext), GESHI_DBG_API);
    }
    
    /**
     * Sets the file extension to use when getting external php files
     * 
     * @param string The file extension for PHP files. Can be specified with or without the leading "."
     */
    function setFileExtension ($extension)
    {
        $this->_styler->fileExtension = ('.' == substr($extension, 0, 1)) ? $extension : '.' . $extension;
        geshi_dbg('GeSHi::setFileExtension(' . $this->_styler->fileExtension . ')', GESHI_DBG_API);
    }

    /**
     * Returns various timings related to this object.
     *
     * For example, how long it took to load a specific context,
     * or parse the source code.
     *
     * You can pass a string to this method, it will return various timings based
     * on what string you pass:
     * 
     * <ul>
     *   <li>If you pass <b>'total'</b> (default), you will get the time it took to
     *   load, parse and post-process the last call to {@link GeSHi::parseCode()}.</li>
     *   <li>If you pass <b>'pre'</b>, you will get the time it took to load the last
     *   language. If caching of the root context is enabled, then this time will likely
     *   be close to zero if you are calling this method after second and subsequent calls
     *   to {@link GeSHi::parseCode()}.</li>
     *   <li>If youpass <b>'parse'</b>, you will get the time it took to parse the last
     *   time {@link GeSHi::parseCode()} was called.
     *
     * @param string What time you want to access
     * @return false|double The time if there is a time, else false if there was an error
     */
    function getTime ($type = 'total')
    {
        geshi_dbg('GeSHi::getTime(' . $type . ')', GESHI_DBG_API);
        if (isset($this->_times[$type])) {
            geshi_dbg('@o  Valid type', GESHI_DBG_API);
            $start = explode(' ', $this->_times[$type][0]);
            $end   = explode(' ', $this->_times[$type][1]);
            return $end[0] + $end[1] - $start[0] - $start[1];
        } elseif ('total' == $type) {
            return $this->getTime('pre') + $this->getTime('parse') + $this->getTime('post');
        }
        geshi_dbg('@w  Type passed to getTime is invalid', GESHI_DBG_API | GESHI_DBG_ERR);
        $this->_error = GESHI_ERROR_INVALID_TIME_TYPE;
        return false;
    }
    
    /**
     * Sets styles of contexts in the source code
     * 
     * @param string The selector to use, this is the style name of a context. Example: php/php
     * @param string The CSS styles to apply to the context
     */
     function setStyles ($selector, $styles)
     {
        geshi_dbg('GeSHi::setStyles(' . $selector . ', ' . $styles . ')', GESHI_DBG_API);
        $this->_styler->setStyle($selector, $styles);
     }
     
     /**
      * Returns the version of this GeSHi
      * 
      * @return string The version of this GeSHi
      * @static
      */
     function getVersion ()
     {
     	geshi_dbg('GeSHi::getVersion()', GESHI_DBG_API);
     	return GESHI_VERSION;
     }
     
     /**
      * Returns the version of this GeSHi
      * 
      * @return string The version of this GeSHi
      * @deprecated in favour of {@link GeSHi::getVersion()}
      */
     function get_version ()
     {
     	return GeSHi::getVersion();
     }

    /**
     * Syntax-highlights the source code
     * 
     * @return string The source code, highlighted
     */
    function parseCode ()
    {
        $this->_times['parse'][0] = microtime();
        geshi_dbg('GeSHi::parseCode()', GESHI_DBG_API | GESHI_DBG_PARSE);

        if ($this->_error) {
            // Bail out
            geshi_dbg('@e  Error occured!!', GESHI_DBG_PARSE);
            $this->_times['parse'][1] = $this->_times['post'][0] = microtime();
            $result = $this->_parsePostProcess();
            $this->_times['post'][1] = microtime(); 
            return $result;
        }

        // Kill the cached root context, replacing with
        // the new root context if needed
        if ($this->_cacheRootContext) {
            $this->_rootContext = $this->_cachedRootContext;
        }
        
        //@todo [blocking 1.1.5] does this space still need to be added?
        $code = ' ' . $this->_source;
        // Runtime setup of context tree/styler info
        // Reset the parse data to nothing 
        $this->_styler->resetParseData();
        // Remove contexts from the parse tree that aren't interesting
        $this->_rootContext->trimUselessChildren($code);
        // The important bit - parse the code
        $this->_rootContext->parseCode($code);


        $this->_times['parse'][1] = $this->_times['post'][0] = microtime();
        $result = $this->_parsePostProcess();
        $this->_times['post'][1] = microtime();
        
        return $result;
    }

    //
    // Private Methods
    //

    /**#@+
     * @access private
     */
    /**
     * Get the error message relating to the current error code
     * 
     * @return string The error message relating to the current error code
     */
    function _getErrorMessage ()
    {
        if ($this->_error) {
            $messages = array (
                // @todo [blocking 1.1.5] Move out of here
                GESHI_ERROR_NO_SUCH_LANG => 'GeSHi could not find the language {LANGUAGE} (using path {LANGPATH})',
                GESHI_ERROR_NO_INPUT => 'No source code passed to GeSHi to highlight',
                GESHI_ERROR_LANG_NAME_ILLEGAL_CHARS => 'The language name {LANGUAGE} contains illegal characters',
            //GESHI_ERROR_ILLEGAL_PATH => 'The path {PATH} is not a readable directory',
            //GESHI_ERROR_NO_SUCH_THEME => 'GeSHi could not find the theme {THEME} (using path {THEMEPATH})',
            //GESHI_ERROR_STRICT_MODE_NO_OPENER => 'Strict mode is enabled but there is no opener for the root context',
                GESHI_ERROR_INVALID_TIME_TYPE => 'Call getTime with the only parameter set to one of "pre", "parse", "post" or "total"',
                GESHI_ERROR_FILE_UNAVAILABLE => 'A file that GeSHi requires to parse using the language ' . $this->_language . ' is unavailable'
            );

            $variable_substitutes = array (
                '{LANGUAGE}' => $this->_language,
                '{PATH}' => GESHI_ROOT,
                '{LANGPATH}' => GESHI_LANGUAGES_ROOT,
                //'{THEMEPATH}' => GESHI_THEMES_ROOT,
                //'{THEME}'     => $this->_styler->themeName
            );

            $message = $messages[$this->_error];
            foreach ($variable_substitutes as $string => $replacement) {
                $message = str_replace($string, $replacement, $message);
            }
            $message = htmlspecialchars($message, ENT_COMPAT, $this->_styler->charset);
            return $message;
        }
        return '';
    }

    /**
     * Check that the language name to be used is valid
     * 
     * @return boolean true if the language name is valid, else false
     */
    function _languageNameValid ()
    {
        geshi_dbg('GeSHi::_languageNameValid('.$this->_language.')', GESHI_DBG_API);

        // Check if the language contains illegal characters. If language names do
        // not match this regular expression, they are not valid. This is a useful
        // security check as well, if people blindly use a post/get variable as the
        // language name... 
        if (!preg_match('#[a-z][a-z0-9]*(/[a-z][a-z0-9]*)+#', $this->_language)) {
            geshi_dbg('@e  Language name contains illegal characters', GESHI_DBG_API | GESHI_DBG_ERR);
            $this->_error = GESHI_ERROR_LANG_NAME_ILLEGAL_CHARS;
            return false;
        }

        // Check that the language file for this language exists
        $language_file = $this->_getLanguageDataFile();
        geshi_dbg('  Language file to use: ' . $language_file, GESHI_DBG_API);
        
        if (!geshi_can_include($language_file)) {
            geshi_dbg('@e  Language does not exist on filesystem', GESHI_DBG_API | GESHI_DBG_ERR);
            $this->_error = GESHI_ERROR_NO_SUCH_LANG;
            return false;
        }

        geshi_dbg('@o  Language name is fine', GESHI_DBG_API);
        return true;
    }

    /**
     * Checks to make sure that the source code inputted is valid
     * 
     * The source is valid when:
     * 
     * <ul>
     *   <li>it is not empty</li>
     * </ul>
     * 
     * @return true if the source code is valid, else false
     */
    function _sourceValid ()
    {
        geshi_dbg('GeSHi::_sourceValid()', GESHI_DBG_API);
        // Is source empty?
        if ('' == trim($this->_source)) {
            geshi_dbg('@e  No source code inputted', GESHI_DBG_API | GESHI_DBG_ERR);
            $this->_error = GESHI_ERROR_NO_INPUT;
            return false;
        }
        geshi_dbg('@o  Source code OK', GESHI_DBG_API);
        return true;
        // @todo [blocking 1.1.9] Other things can go in here - checks against max and min length etc
    }

    /**
     * Prepare the source code for parsing
     */
    function _parsePreProcess ()
    {
        geshi_dbg('GeSHi::parsePreProcess()', GESHI_DBG_API);

        // Strip newlines to common form
        $this->_source = str_replace("\r\n", "\n", $this->_source);
        $this->_source = str_replace("\r", "\n", $this->_source);

        // Load all the data needed for parsing this language
        $language_file = $this->_getLanguageDataFile();
        geshi_dbg('  Loading language data from ' . GESHI_LANGUAGES_ROOT . $language_file, GESHI_DBG_API);
        require $language_file;

        if ($error_data = $this->_rootContext->load($this->_styler)) {
            geshi_dbg('@e  Could not load the context data tree: code(' . $error_data['code'] . ') in context ' . $error_data['name'], GESHI_DBG_API | GESHI_DBG_ERR);
            $this->_error = $error_data['code'];
        }

        // Inform the context tree that all contexts have been loaded, so it is OK to search through
        // the tree for default styles as needed.        
        $this->_rootContext->loadStyleData(); 
        
        // Save a copy of the root context if we are caching 
        $this->_cachedRootContext = ($this->_cacheRootContext) ? $this->_rootContext : null;
        
        geshi_dbg('Finished preprocessing', GESHI_DBG_API);       
    }

    /**
     * Builds the result string to return, by looking at the context data array
     * 
     * This is to be moved into a new class: GeSHi_Highlighter, which will extend GeSHi to
     * do this job. The GeSHi class will still be able to highlight source code, but this
     * behaviour is deprecated and will be removed in the next major release.
     * 
     * @return The code, post-processed.
     */
    function _parsePostProcess ()
    {
        if ($this->_error) {
            // If there was an error, the source will be in string form
            return '<pre style="background-color:#fcc;border:1px solid #c99;">' . htmlspecialchars($this->_source) .'</pre>';
        }
        
        // $this->_data should hold an array(
        //   0 => array(0=>string of code, 1=> context name identifier
        $result = '';
        $data = $this->_styler->getParseData();
        // TO BE REMOVED from stable release
        if (GESHI_DBG & GESHI_DBG_PARSE) {
            $result .= '<pre style="background-color:#ffc;border:1px solid #cc9;">';
	        foreach ($data as $token) {
	        	if (!isset($check)) {
	        		$token[0] = substr($token[0], 1); // remove padding
	        		$check = 0;
	        	}
	            $result .= '[' . $token[1] . ']: ' . htmlspecialchars($token[0]) . "\n";
	        }
	        unset($check);
	        $result .= '</pre>';
        }

        $result .= '<pre style="background-color:#ffc;border:1px solid #cc9;">';
        foreach ($data as $token) {
        	if (!isset($check)) {
        		$token[0] = substr($token[0], 1); // remove padding (slow?)
        		$check = 0;
        	}
            if ($token[2]) {
                $result .= '<a href="' . $token[2] . '">';
            }
            $result .= '<span style="' . $this->_styler->getStyle($token[1]) . '" ';
//            $result .= 'class="' . str_replace(array('/', '_'), '-', $token[1]) . '" ';
            $result .= 'title="' . $token[1] . '">' . htmlspecialchars($token[0]) . '</span>';
            if ($token[2]) {
                // there's a URL associated with this token
                $result .= '</a>';
            }
        }
        $result .= '</pre>';
        
        // @todo [blocking 1.1.1] (bug 12) Evaluate feasability and get working if possible the functionality below...
        //$result = preg_replace('#([^"])(((https?)|(ftp))://[a-z0-9\-]+\.([a-z0-9\-\.]+)+/?([a-zA-Z0-9\.\-_%]+/?)*\??([a-zA-Z0-9=&\[\];%]+)?(\#[a-zA-Z0-9\-_]+)?)#', '\\1<a href="\\2">\\2</a>', $result);
        //$result = preg_replace('#([a-z0-9\._\-]+@[[a-z0-9\-\.]+[a-z]+)#si', '<a href="mailto:\\1">\\1</a>', $result);
                
        return $result;        
    }
    
    
    /**
     * Helper function to convert a language name to the file name where its data will reside
     * 
     * @return The absolute path of the language file where the current language data will be sourced
     */
    function _getLanguageDataFile ()
    {
        geshi_dbg('GeSHi::_getLanguageDataFile()', GESHI_DBG_API);
        if ('/' == GESHI_DIR_SEPARATOR) {
            $language_file = $this->_language . $this->_styler->fileExtension;
        } else {
            $language_file = explode('/', $this->_language);
            $language_file = implode(GESHI_DIR_SEPARATOR, $language_file) . $this->_styler->fileExtension;
        }
        geshi_dbg('Language file is ' . $language_file, GESHI_DBG_API);
        return GESHI_LANGUAGES_ROOT . $language_file;
    }
    /**#@-*/    
}
?>