From 08aa4418c30cfc18ccc69a0f0f9cb9e17be6c196 Mon Sep 17 00:00:00 2001 From: Pierre Schmitz Date: Mon, 12 Aug 2013 09:28:15 +0200 Subject: Update to MediaWiki 1.21.1 --- .../__filesource/fsource_geshi_core_geshi.php.html | 4616 ++++++++++++++++++++ 1 file changed, 4616 insertions(+) create mode 100644 extensions/SyntaxHighlight_GeSHi/geshi/docs/api/__filesource/fsource_geshi_core_geshi.php.html (limited to 'extensions/SyntaxHighlight_GeSHi/geshi/docs/api/__filesource/fsource_geshi_core_geshi.php.html') diff --git a/extensions/SyntaxHighlight_GeSHi/geshi/docs/api/__filesource/fsource_geshi_core_geshi.php.html b/extensions/SyntaxHighlight_GeSHi/geshi/docs/api/__filesource/fsource_geshi_core_geshi.php.html new file mode 100644 index 00000000..3d799821 --- /dev/null +++ b/extensions/SyntaxHighlight_GeSHi/geshi/docs/api/__filesource/fsource_geshi_core_geshi.php.html @@ -0,0 +1,4616 @@ + + + + + + File Source for geshi.php + + + + +

Source for file geshi.php

+

Documentation is available at geshi.php

+
+
  1. <?php
    2. +
  2. /**
    3. +
  3.  * GeSHi - Generic Syntax Highlighter
    4. +
  4.  *
    5. +
  5.  * The GeSHi class for Generic Syntax Highlighting. Please refer to the
    6. +
  6.  * documentation at http://qbnz.com/highlighter/documentation.php for more
    7. +
  7.  * information about how to use this class.
    8. +
  8.  *
    9. +
  9.  * For changes, release notes, TODOs etc, see the relevant files in the docs/
    10. +
  10.  * directory.
    11. +
  11.  *
    12. +
  12.  *   This file is part of GeSHi.
    13. +
  13.  *
    14. +
  14.  *  GeSHi is free software; you can redistribute it and/or modify
    15. +
  15.  *  it under the terms of the GNU General Public License as published by
    16. +
  16.  *  the Free Software Foundation; either version 2 of the License, or
    17. +
  17.  *  (at your option) any later version.
    18. +
  18.  *
    19. +
  19.  *  GeSHi is distributed in the hope that it will be useful,
    20. +
  20.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
    21. +
  21.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    22. +
  22.  *  GNU General Public License for more details.
    23. +
  23.  *
    24. +
  24.  *  You should have received a copy of the GNU General Public License
    25. +
  25.  *  along with GeSHi; if not, write to the Free Software
    26. +
  26.  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
    27. +
  27.  *
    28. +
  28.  * @package    geshi
    29. +
  29.  * @subpackage core
    30. +
  30.  * @author     Nigel McNie <nigel@geshi.org>, Benny Baumann <BenBE@omorphia.de>
    31. +
  31.  * @copyright  (C) 2004 - 2007 Nigel McNie, (C) 2007 - 2008 Benny Baumann
    32. +
  32.  * @license    http://gnu.org/copyleft/gpl.html GNU GPL
    33. +
  33.  *
    34. +
  34.  */
    35. +
  35.  
    36. +
  36. //
    37. +
  37. // GeSHi Constants
    38. +
  38. // You should use these constant names in your programs instead of
    39. +
  39. // their values - you never know when a value may change in a future
    40. +
  40. // version
    41. +
  41. //
    42. +
  42.  
    43. +
  43. /** The version of this GeSHi file */
    44. +
  44. define('GESHI_VERSION', '1.0.8.2',);
    45. +
  45.  
    46. +
  46. // Define the root directory for the GeSHi code tree
    47. +
  47. if (!defined('GESHI_ROOT')) {
    48. +
  48.     /** The root directory for GeSHi */
    49. +
  49.     define('GESHI_ROOT', dirname(__FILE__) . DIRECTORY_SEPARATOR);
    50. +
  50. }
    51. +
  51. /** The language file directory for GeSHi
    52. +
  52.     @access private */
    53. +
  53. define('GESHI_LANG_ROOT', GESHI_ROOT . 'geshi' . DIRECTORY_SEPARATOR);
    54. +
  54.  
    55. +
  55. // Define if GeSHi should be paranoid about security
    56. +
  56. if (!defined('GESHI_SECURITY_PARANOID')) {
    57. +
  57.     /** Tells GeSHi to be paranoid about security settings */
    58. +
  58.     define('GESHI_SECURITY_PARANOID', false);
    59. +
  59. }
    60. +
  60.  
    61. +
  61. // Line numbers - use with enable_line_numbers()
    62. +
  62. /** Use no line numbers when building the result */
    63. +
  63. define('GESHI_NO_LINE_NUMBERS', 0);
    64. +
  64. /** Use normal line numbers when building the result */
    65. +
  65. define('GESHI_NORMAL_LINE_NUMBERS', 1);
    66. +
  66. /** Use fancy line numbers when building the result */
    67. +
  67. define('GESHI_FANCY_LINE_NUMBERS', 2);
    68. +
  68.  
    69. +
  69. // Container HTML type
    70. +
  70. /** Use nothing to surround the source */
    71. +
  71. define('GESHI_HEADER_NONE', 0);
    72. +
  72. /** Use a "div" to surround the source */
    73. +
  73. define('GESHI_HEADER_DIV', 1);
    74. +
  74. /** Use a "pre" to surround the source */
    75. +
  75. define('GESHI_HEADER_PRE', 2);
    76. +
  76. /** Use a pre to wrap lines when line numbers are enabled or to wrap the whole code. */
    77. +
  77. define('GESHI_HEADER_PRE_VALID', 3);
    78. +
  78. /**
    79. +
  79.  * Use a "table" to surround the source:
    80. +
  80.  *
    81. +
  81.  *  <table>
    82. +
  82.  *    <thead><tr><td colspan="2">$header</td></tr></thead>
    83. +
  83.  *    <tbody><tr><td><pre>$linenumbers</pre></td><td><pre>$code></pre></td></tr></tbody>
    84. +
  84.  *    <tfooter><tr><td colspan="2">$footer</td></tr></tfoot>
    85. +
  85.  *  </table>
    86. +
  86.  *
    87. +
  87.  * this is essentially only a workaround for Firefox, see sf#1651996 or take a look at
    88. +
  88.  * https://bugzilla.mozilla.org/show_bug.cgi?id=365805
    89. +
  89.  * @note when linenumbers are disabled this is essentially the same as GESHI_HEADER_PRE
    90. +
  90.  */
    91. +
  91. define('GESHI_HEADER_PRE_TABLE', 4);
    92. +
  92.  
    93. +
  93. // Capatalisation constants
    94. +
  94. /** Lowercase keywords found */
    95. +
  95. define('GESHI_CAPS_NO_CHANGE', 0);
    96. +
  96. /** Uppercase keywords found */
    97. +
  97. define('GESHI_CAPS_UPPER', 1);
    98. +
  98. /** Leave keywords found as the case that they are */
    99. +
  99. define('GESHI_CAPS_LOWER', 2);
    100. +
  100.  
    101. +
  101. // Link style constants
    102. +
  102. /** Links in the source in the :link state */
    103. +
  103. define('GESHI_LINK', 0);
    104. +
  104. /** Links in the source in the :hover state */
    105. +
  105. define('GESHI_HOVER', 1);
    106. +
  106. /** Links in the source in the :active state */
    107. +
  107. define('GESHI_ACTIVE', 2);
    108. +
  108. /** Links in the source in the :visited state */
    109. +
  109. define('GESHI_VISITED', 3);
    110. +
  110.  
    111. +
  111. // Important string starter/finisher
    112. +
  112. // Note that if you change these, they should be as-is: i.e., don't
    113. +
  113. // write them as if they had been run through htmlentities()
    114. +
  114. /** The starter for important parts of the source */
    115. +
  115. define('GESHI_START_IMPORTANT', '<BEGIN GeSHi>');
    116. +
  116. /** The ender for important parts of the source */
    117. +
  117. define('GESHI_END_IMPORTANT', '<END GeSHi>');
    118. +
  118.  
    119. +
  119. /**#@+
    120. +
  120.  *  @access private
    121. +
  121.  */
    122. +
  122. // When strict mode applies for a language
    123. +
  123. /** Strict mode never applies (this is the most common) */
    124. +
  124. define('GESHI_NEVER', 0);
    125. +
  125. /** Strict mode *might* apply, and can be enabled or
    126. +
  126.     disabled by {@link GeSHi->enable_strict_mode()} */
    127. +
  127. define('GESHI_MAYBE', 1);
    128. +
  128. /** Strict mode always applies */
    129. +
  129. define('GESHI_ALWAYS', 2);
    130. +
  130.  
    131. +
  131. // Advanced regexp handling constants, used in language files
    132. +
  132. /** The key of the regex array defining what to search for */
    133. +
  133. define('GESHI_SEARCH', 0);
    134. +
  134. /** The key of the regex array defining what bracket group in a
    135. +
  135.     matched search to use as a replacement */
    136. +
  136. define('GESHI_REPLACE', 1);
    137. +
  137. /** The key of the regex array defining any modifiers to the regular expression */
    138. +
  138. define('GESHI_MODIFIERS', 2);
    139. +
  139. /** The key of the regex array defining what bracket group in a
    140. +
  140.     matched search to put before the replacement */
    141. +
  141. define('GESHI_BEFORE', 3);
    142. +
  142. /** The key of the regex array defining what bracket group in a
    143. +
  143.     matched search to put after the replacement */
    144. +
  144. define('GESHI_AFTER', 4);
    145. +
  145. /** The key of the regex array defining a custom keyword to use
    146. +
  146.     for this regexp's html tag class */
    147. +
  147. define('GESHI_CLASS', 5);
    148. +
  148.  
    149. +
  149. /** Used in language files to mark comments */
    150. +
  150. define('GESHI_COMMENTS', 0);
    151. +
  151.  
    152. +
  152. /** Used to work around missing PHP features **/
    153. +
  153. define('GESHI_PHP_PRE_433', !(version_compare(PHP_VERSION, '4.3.3') === 1));
    154. +
  154.  
    155. +
  155. /** make sure we can call stripos **/
    156. +
  156. if (!function_exists('stripos')) {
    157. +
  157.     // the offset param of preg_match is not supported below PHP 4.3.3
    158. +
  158.     if (GESHI_PHP_PRE_433) {
    159. +
  159.         /**
    160. +
  160.          * @ignore
    161. +
  161.          */
    162. +
  162.         function stripos($haystack, $needle, $offset = null) {
    163. +
  163.             if (!is_null($offset)) {
    164. +
  164.                 $haystack = substr($haystack, $offset);
    165. +
  165.             }
    166. +
  166.             if (preg_match('/'. preg_quote($needle, '/') . '/', $haystack, $match, PREG_OFFSET_CAPTURE)) {
    167. +
  167.                 return $match[0][1];
    168. +
  168.             }
    169. +
  169.             return false;
    170. +
  170.         }
    171. +
  171.     }
    172. +
  172.     else {
    173. +
  173.         /**
    174. +
  174.          * @ignore
    175. +
  175.          */
    176. +
  176.         function stripos($haystack, $needle, $offset = null) {
    177. +
  177.             if (preg_match('/'. preg_quote($needle, '/') . '/', $haystack, $match, PREG_OFFSET_CAPTURE, $offset)) {
    178. +
  178.                 return $match[0][1];
    179. +
  179.             }
    180. +
  180.             return false;
    181. +
  181.         }
    182. +
  182.     }
    183. +
  183. }
    184. +
  184.  
    185. +
  185. /** some old PHP / PCRE subpatterns only support up to xxx subpatterns in
    186. +
  186.     regular expressions. Set this to false if your PCRE lib is up to date
    187. +
  187.     @see GeSHi->optimize_regexp_list()
    188. +
  188.     **/
    189. +
  189.  
    190. +
  190. define('GESHI_MAX_PCRE_SUBPATTERNS', 500);
    191. +
  191. /** it's also important not to generate too long regular expressions
    192. +
  192.     be generous here... but keep in mind, that when reaching this limit we
    193. +
  193.     still have to close open patterns. 12k should do just fine on a 16k limit.
    194. +
  194.     @see GeSHi->optimize_regexp_list()
    195. +
  195.     **/
    196. +
  196.  
    197. +
  197. define('GESHI_MAX_PCRE_LENGTH', 12288);
    198. +
  198.  
    199. +
  199. //Number format specification
    200. +
  200. /** Basic number format for integers */
    201. +
  201. define('GESHI_NUMBER_INT_BASIC', 1);        //Default integers \d+
    202. +
  202. /** Enhanced number format for integers like seen in C */
    203. +
  203. define('GESHI_NUMBER_INT_CSTYLE', 2);       //Default C-Style \d+[lL]?
    204. +
  204. /** Number format to highlight binary numbers with a suffix "b" */
    205. +
  205. define('GESHI_NUMBER_BIN_SUFFIX', 16);           //[01]+[bB]
    206. +
  206. /** Number format to highlight binary numbers with a prefix % */
    207. +
  207. define('GESHI_NUMBER_BIN_PREFIX_PERCENT', 32);   //%[01]+
    208. +
  208. /** Number format to highlight binary numbers with a prefix 0b (C) */
    209. +
  209. define('GESHI_NUMBER_BIN_PREFIX_0B', 64);        //0b[01]+
    210. +
  210. /** Number format to highlight octal numbers with a leading zero */
    211. +
  211. define('GESHI_NUMBER_OCT_PREFIX', 256);           //0[0-7]+
    212. +
  212. /** Number format to highlight octal numbers with a suffix of o */
    213. +
  213. define('GESHI_NUMBER_OCT_SUFFIX', 512);           //[0-7]+[oO]
    214. +
  214. /** Number format to highlight hex numbers with a prefix 0x */
    215. +
  215. define('GESHI_NUMBER_HEX_PREFIX', 4096);           //0x[0-9a-fA-F]+
    216. +
  216. /** Number format to highlight hex numbers with a suffix of h */
    217. +
  217. define('GESHI_NUMBER_HEX_SUFFIX', 8192);           //[0-9][0-9a-fA-F]*h
    218. +
  218. /** Number format to highlight floating-point numbers without support for scientific notation */
    219. +
  219. define('GESHI_NUMBER_FLT_NONSCI', 65536);          //\d+\.\d+
    220. +
  220. /** Number format to highlight floating-point numbers without support for scientific notation */
    221. +
  221. define('GESHI_NUMBER_FLT_NONSCI_F', 131072);       //\d+(\.\d+)?f
    222. +
  222. /** Number format to highlight floating-point numbers with support for scientific notation (E) and optional leading zero */
    223. +
  223. define('GESHI_NUMBER_FLT_SCI_SHORT', 262144);      //\.\d+e\d+
    224. +
  224. /** Number format to highlight floating-point numbers with support for scientific notation (E) and required leading digit */
    225. +
  225. define('GESHI_NUMBER_FLT_SCI_ZERO', 524288);       //\d+(\.\d+)?e\d+
    226. +
  226. //Custom formats are passed by RX array
    227. +
  227.  
    228. +
  228. // Error detection - use these to analyse faults
    229. +
  229. /** No sourcecode to highlight was specified
    230. +
  230.  * @deprecated
    231. +
  231.  */
    232. +
  232. define('GESHI_ERROR_NO_INPUT', 1);
    233. +
  233. /** The language specified does not exist */
    234. +
  234. define('GESHI_ERROR_NO_SUCH_LANG', 2);
    235. +
  235. /** GeSHi could not open a file for reading (generally a language file) */
    236. +
  236. define('GESHI_ERROR_FILE_NOT_READABLE', 3);
    237. +
  237. /** The header type passed to {@link GeSHi->set_header_type()} was invalid */
    238. +
  238. define('GESHI_ERROR_INVALID_HEADER_TYPE', 4);
    239. +
  239. /** The line number type passed to {@link GeSHi->enable_line_numbers()} was invalid */
    240. +
  240. define('GESHI_ERROR_INVALID_LINE_NUMBER_TYPE', 5);
    241. +
  241. /**#@-*/
    242. +
  242.  
    243. +
  243.  
    244. +
  244. /**
    245. +
  245.  * The GeSHi Class.
    246. +
  246.  *
    247. +
  247.  * Please refer to the documentation for GeSHi 1.0.X that is available
    248. +
  248.  * at http://qbnz.com/highlighter/documentation.php for more information
    249. +
  249.  * about how to use this class.
    250. +
  250.  *
    251. +
  251.  * @package   geshi
    252. +
  252.  * @author    Nigel McNie <nigel@geshi.org>, Benny Baumann <BenBE@omorphia.de>
    253. +
  253.  * @copyright (C) 2004 - 2007 Nigel McNie, (C) 2007 - 2008 Benny Baumann
    254. +
  254.  */
    255. +
  255. class GeSHi {
    256. +
  256.     /**#@+
    257. +
  257.      * @access private
    258. +
  258.      */
    259. +
  259.     /**
    260. +
  260.      * The source code to highlight
    261. +
  261.      * @var string 
    262. +
  262.      */
    263. +
  263.     var $source = '';
    264. +
  264.  
    265. +
  265.     /**
    266. +
  266.      * The language to use when highlighting
    267. +
  267.      * @var string 
    268. +
  268.      */
    269. +
  269.     var $language = '';
    270. +
  270.  
    271. +
  271.     /**
    272. +
  272.      * The data for the language used
    273. +
  273.      * @var array 
    274. +
  274.      */
    275. +
  275.     var $language_data = array();
    276. +
  276.  
    277. +
  277.     /**
    278. +
  278.      * The path to the language files
    279. +
  279.      * @var string 
    280. +
  280.      */
    281. +
  281.     var $language_path = GESHI_LANG_ROOT;
    282. +
  282.  
    283. +
  283.     /**
    284. +
  284.      * The error message associated with an error
    285. +
  285.      * @var string 
    286. +
  286.      * @todo check err reporting works
    287. +
  287.      */
    288. +
  288.     var $error = false;
    289. +
  289.  
    290. +
  290.     /**
    291. +
  291.      * Possible error messages
    292. +
  292.      * @var array 
    293. +
  293.      */
    294. +
  294.     var $error_messages = array(
    295. +
  295.         GESHI_ERROR_NO_SUCH_LANG => 'GeSHi could not find the language {LANGUAGE} (using path {PATH})',
    296. +
  296.         GESHI_ERROR_FILE_NOT_READABLE => 'The file specified for load_from_file was not readable',
    297. +
  297.         GESHI_ERROR_INVALID_HEADER_TYPE => 'The header type specified is invalid',
    298. +
  298.         GESHI_ERROR_INVALID_LINE_NUMBER_TYPE => 'The line number type specified is invalid'
    299. +
  299.     );
    300. +
  300.  
    301. +
  301.     /**
    302. +
  302.      * Whether highlighting is strict or not
    303. +
  303.      * @var boolean 
    304. +
  304.      */
    305. +
  305.     var $strict_mode = false;
    306. +
  306.  
    307. +
  307.     /**
    308. +
  308.      * Whether to use CSS classes in output
    309. +
  309.      * @var boolean 
    310. +
  310.      */
    311. +
  311.     var $use_classes = false;
    312. +
  312.  
    313. +
  313.     /**
    314. +
  314.      * The type of header to use. Can be one of the following
    315. +
  315.      * values:
    316. +
  316.      *
    317. +
  317.      * - GESHI_HEADER_PRE: Source is outputted in a "pre" HTML element.
    318. +
  318.      * - GESHI_HEADER_DIV: Source is outputted in a "div" HTML element.
    319. +
  319.      * - GESHI_HEADER_NONE: No header is outputted.
    320. +
  320.      *
    321. +
  321.      * @var int 
    322. +
  322.      */
    323. +
  323.     var $header_type = GESHI_HEADER_PRE;
    324. +
  324.  
    325. +
  325.     /**
    326. +
  326.      * Array of permissions for which lexics should be highlighted
    327. +
  327.      * @var array 
    328. +
  328.      */
    329. +
  329.     var $lexic_permissions = array(
    330. +
  330.         'KEYWORDS' =>    array(),
    331. +
  331.         'COMMENTS' =>    array('MULTI' => true),
    332. +
  332.         'REGEXPS' =>     array(),
    333. +
  333.         'ESCAPE_CHAR' => true,
    334. +
  334.         'BRACKETS' =>    true,
    335. +
  335.         'SYMBOLS' =>     false,
    336. +
  336.         'STRINGS' =>     true,
    337. +
  337.         'NUMBERS' =>     true,
    338. +
  338.         'METHODS' =>     true,
    339. +
  339.         'SCRIPT' =>      true
    340. +
  340.     );
    341. +
  341.  
    342. +
  342.     /**
    343. +
  343.      * The time it took to parse the code
    344. +
  344.      * @var double 
    345. +
  345.      */
    346. +
  346.     var $time = 0;
    347. +
  347.  
    348. +
  348.     /**
    349. +
  349.      * The content of the header block
    350. +
  350.      * @var string 
    351. +
  351.      */
    352. +
  352.     var $header_content = '';
    353. +
  353.  
    354. +
  354.     /**
    355. +
  355.      * The content of the footer block
    356. +
  356.      * @var string 
    357. +
  357.      */
    358. +
  358.     var $footer_content = '';
    359. +
  359.  
    360. +
  360.     /**
    361. +
  361.      * The style of the header block
    362. +
  362.      * @var string 
    363. +
  363.      */
    364. +
  364.     var $header_content_style = '';
    365. +
  365.  
    366. +
  366.     /**
    367. +
  367.      * The style of the footer block
    368. +
  368.      * @var string 
    369. +
  369.      */
    370. +
  370.     var $footer_content_style = '';
    371. +
  371.  
    372. +
  372.     /**
    373. +
  373.      * Tells if a block around the highlighted source should be forced
    374. +
  374.      * if not using line numbering
    375. +
  375.      * @var boolean 
    376. +
  376.      */
    377. +
  377.     var $force_code_block = false;
    378. +
  378.  
    379. +
  379.     /**
    380. +
  380.      * The styles for hyperlinks in the code
    381. +
  381.      * @var array 
    382. +
  382.      */
    383. +
  383.     var $link_styles = array();
    384. +
  384.  
    385. +
  385.     /**
    386. +
  386.      * Whether important blocks should be recognised or not
    387. +
  387.      * @var boolean 
    388. +
  388.      * @deprecated
    389. +
  389.      * @todo REMOVE THIS FUNCTIONALITY!
    390. +
  390.      */
    391. +
  391.     var $enable_important_blocks = false;
    392. +
  392.  
    393. +
  393.     /**
    394. +
  394.      * Styles for important parts of the code
    395. +
  395.      * @var string 
    396. +
  396.      * @deprecated
    397. +
  397.      * @todo As above - rethink the whole idea of important blocks as it is buggy and
    398. +
  398.      *  will be hard to implement in 1.2
    399. +
  399.      */
    400. +
  400.     var $important_styles = 'font-weight: bold; color: red;'; // Styles for important parts of the code
    401. +
  401.  
    402. +
  402.     /**
    403. +
  403.      * Whether CSS IDs should be added to the code
    404. +
  404.      * @var boolean 
    405. +
  405.      */
    406. +
  406.     var $add_ids = false;
    407. +
  407.  
    408. +
  408.     /**
    409. +
  409.      * Lines that should be highlighted extra
    410. +
  410.      * @var array 
    411. +
  411.      */
    412. +
  412.     var $highlight_extra_lines = array();
    413. +
  413.  
    414. +
  414.     /**
    415. +
  415.      * Styles of lines that should be highlighted extra
    416. +
  416.      * @var array 
    417. +
  417.      */
    418. +
  418.     var $highlight_extra_lines_styles = array();
    419. +
  419.  
    420. +
  420.     /**
    421. +
  421.      * Styles of extra-highlighted lines
    422. +
  422.      * @var string 
    423. +
  423.      */
    424. +
  424.     var $highlight_extra_lines_style = 'background-color: #ffc;';
    425. +
  425.  
    426. +
  426.     /**
    427. +
  427.      * The line ending
    428. +
  428.      * If null, nl2br() will be used on the result string.
    429. +
  429.      * Otherwise, all instances of \n will be replaced with $line_ending
    430. +
  430.      * @var string 
    431. +
  431.      */
    432. +
  432.     var $line_ending = null;
    433. +
  433.  
    434. +
  434.     /**
    435. +
  435.      * Number at which line numbers should start at
    436. +
  436.      * @var int 
    437. +
  437.      */
    438. +
  438.     var $line_numbers_start = 1;
    439. +
  439.  
    440. +
  440.     /**
    441. +
  441.      * The overall style for this code block
    442. +
  442.      * @var string 
    443. +
  443.      */
    444. +
  444.     var $overall_style = 'font-family:monospace;';
    445. +
  445.  
    446. +
  446.     /**
    447. +
  447.      *  The style for the actual code
    448. +
  448.      * @var string 
    449. +
  449.      */
    450. +
  450.     var $code_style = 'font: normal normal 1em/1.2em monospace; margin:0; padding:0; background:none; vertical-align:top;';
    451. +
  451.  
    452. +
  452.     /**
    453. +
  453.      * The overall class for this code block
    454. +
  454.      * @var string 
    455. +
  455.      */
    456. +
  456.     var $overall_class = '';
    457. +
  457.  
    458. +
  458.     /**
    459. +
  459.      * The overall ID for this code block
    460. +
  460.      * @var string 
    461. +
  461.      */
    462. +
  462.     var $overall_id = '';
    463. +
  463.  
    464. +
  464.     /**
    465. +
  465.      * Line number styles
    466. +
  466.      * @var string 
    467. +
  467.      */
    468. +
  468.     var $line_style1 = 'font-weight: normal; vertical-align:top;';
    469. +
  469.  
    470. +
  470.     /**
    471. +
  471.      * Line number styles for fancy lines
    472. +
  472.      * @var string 
    473. +
  473.      */
    474. +
  474.     var $line_style2 = 'font-weight: bold; vertical-align:top;';
    475. +
  475.  
    476. +
  476.     /**
    477. +
  477.      * Style for line numbers when GESHI_HEADER_PRE_TABLE is chosen
    478. +
  478.      * @var string 
    479. +
  479.      */
    480. +
  480.     var $table_linenumber_style = 'width:1px;text-align:right;margin:0;padding:0 2px;vertical-align:top;';
    481. +
  481.  
    482. +
  482.     /**
    483. +
  483.      * Flag for how line numbers are displayed
    484. +
  484.      * @var boolean 
    485. +
  485.      */
    486. +
  486.     var $line_numbers = GESHI_NO_LINE_NUMBERS;
    487. +
  487.  
    488. +
  488.     /**
    489. +
  489.      * Flag to decide if multi line spans are allowed. Set it to false to make sure
    490. +
  490.      * each tag is closed before and reopened after each linefeed.
    491. +
  491.      * @var boolean 
    492. +
  492.      */
    493. +
  493.     var $allow_multiline_span = true;
    494. +
  494.  
    495. +
  495.     /**
    496. +
  496.      * The "nth" value for fancy line highlighting
    497. +
  497.      * @var int 
    498. +
  498.      */
    499. +
  499.     var $line_nth_row = 0;
    500. +
  500.  
    501. +
  501.     /**
    502. +
  502.      * The size of tab stops
    503. +
  503.      * @var int 
    504. +
  504.      */
    505. +
  505.     var $tab_width = 8;
    506. +
  506.  
    507. +
  507.     /**
    508. +
  508.      * Should we use language-defined tab stop widths?
    509. +
  509.      * @var int 
    510. +
  510.      */
    511. +
  511.     var $use_language_tab_width = false;
    512. +
  512.  
    513. +
  513.     /**
    514. +
  514.      * Default target for keyword links
    515. +
  515.      * @var string 
    516. +
  516.      */
    517. +
  517.     var $link_target = '';
    518. +
  518.  
    519. +
  519.     /**
    520. +
  520.      * The encoding to use for entity encoding
    521. +
  521.      * NOTE: Used with Escape Char Sequences to fix UTF-8 handling (cf. SF#2037598)
    522. +
  522.      * @var string 
    523. +
  523.      */
    524. +
  524.     var $encoding = 'utf-8';
    525. +
  525.  
    526. +
  526.     /**
    527. +
  527.      * Should keywords be linked?
    528. +
  528.      * @var boolean 
    529. +
  529.      */
    530. +
  530.     var $keyword_links = true;
    531. +
  531.  
    532. +
  532.     /**
    533. +
  533.      * Currently loaded language file
    534. +
  534.      * @var string 
    535. +
  535.      * @since 1.0.7.22
    536. +
  536.      */
    537. +
  537.     var $loaded_language = '';
    538. +
  538.  
    539. +
  539.     /**
    540. +
  540.      * Wether the caches needed for parsing are built or not
    541. +
  541.      *
    542. +
  542.      * @var bool 
    543. +
  543.      * @since 1.0.8
    544. +
  544.      */
    545. +
  545.     var $parse_cache_built = false;
    546. +
  546.  
    547. +
  547.     /**
    548. +
  548.      * Work around for Suhosin Patch with disabled /e modifier
    549. +
  549.      *
    550. +
  550.      * Note from suhosins author in config file:
    551. +
  551.      * <blockquote>
    552. +
  552.      *   The /e modifier inside <code>preg_replace()</code> allows code execution.
    553. +
  553.      *   Often it is the cause for remote code execution exploits. It is wise to
    554. +
  554.      *   deactivate this feature and test where in the application it is used.
    555. +
  555.      *   The developer using the /e modifier should be made aware that he should
    556. +
  556.      *   use <code>preg_replace_callback()</code> instead
    557. +
  557.      * </blockquote>
    558. +
  558.      *
    559. +
  559.      * @var array 
    560. +
  560.      * @since 1.0.8
    561. +
  561.      */
    562. +
  562.     var $_kw_replace_group = 0;
    563. +
  563.     var $_rx_key = 0;
    564. +
  564.  
    565. +
  565.     /**
    566. +
  566.      * some "callback parameters" for handle_multiline_regexps
    567. +
  567.      *
    568. +
  568.      * @since 1.0.8
    569. +
  569.      * @access private
    570. +
  570.      * @var string 
    571. +
  571.      */
    572. +
  572.     var $_hmr_before = '';
    573. +
  573.     var $_hmr_replace = '';
    574. +
  574.     var $_hmr_after = '';
    575. +
  575.     var $_hmr_key = 0;
    576. +
  576.  
    577. +
  577.     /**#@-*/
    578. +
  578.  
    579. +
  579.     /**
    580. +
  580.      * Creates a new GeSHi object, with source and language
    581. +
  581.      *
    582. +
  582.      * @param string The source code to highlight
    583. +
  583.      * @param string The language to highlight the source with
    584. +
  584.      * @param string The path to the language file directory. <b>This
    585. +
  585.      *                is deprecated!</b> I've backported the auto path
    586. +
  586.      *                detection from the 1.1.X dev branch, so now it
    587. +
  587.      *                should be automatically set correctly. If you have
    588. +
  588.      *                renamed the language directory however, you will
    589. +
  589.      *                still need to set the path using this parameter or
    590. +
  590.      *                {@link GeSHi->set_language_path()}
    591. +
  591.      * @since 1.0.0
    592. +
  592.      */
    593. +
  593.     function GeSHi($source = '', $language = '', $path = '') {
    594. +
  594.         if (!empty($source)) {
    595. +
  595.             $this->set_source($source);
    596. +
  596.         }
    597. +
  597.         if (!empty($language)) {
    598. +
  598.             $this->set_language($language);
    599. +
  599.         }
    600. +
  600.         $this->set_language_path($path);
    601. +
  601.     }
    602. +
  602.  
    603. +
  603.     /**
    604. +
  604.      * Returns an error message associated with the last GeSHi operation,
    605. +
  605.      * or false if no error has occured
    606. +
  606.      *
    607. +
  607.      * @return string|falseAn error message if there has been an error, else false
    608. +
  608.      * @since  1.0.0
    609. +
  609.      */
    610. +
  610.     function error() {
    611. +
  611.         if ($this->error) {
    612. +
  612.             //Put some template variables for debugging here ...
    613. +
  613.             $debug_tpl_vars = array(
    614. +
  614.                 '{LANGUAGE}' => $this->language,
    615. +
  615.                 '{PATH}' => $this->language_path
    616. +
  616.             );
    617. +
  617.             $msg = str_replace(
    618. +
  618.                 array_keys($debug_tpl_vars),
    619. +
  619.                 array_values($debug_tpl_vars),
    620. +
  620.                 $this->error_messages[$this->error]);
    621. +
  621.  
    622. +
  622.             return "<br /><strong>GeSHi Error:</strong> $msg (code {$this->error})<br />";
    623. +
  623.         }
    624. +
  624.         return false;
    625. +
  625.     }
    626. +
  626.  
    627. +
  627.     /**
    628. +
  628.      * Gets a human-readable language name (thanks to Simon Patterson
    629. +
  629.      * for the idea :))
    630. +
  630.      *
    631. +
  631.      * @return string The name for the current language
    632. +
  632.      * @since  1.0.2
    633. +
  633.      */
    634. +
  634.     function get_language_name() {
    635. +
  635.         if (GESHI_ERROR_NO_SUCH_LANG == $this->error) {
    636. +
  636.             return $this->language_data['LANG_NAME'] . ' (Unknown Language)';
    637. +
  637.         }
    638. +
  638.         return $this->language_data['LANG_NAME'];
    639. +
  639.     }
    640. +
  640.  
    641. +
  641. /**    
    642. +
  642.      * Sets the source code for this object
    643. +
  643.      *
    644. +
  644.      * @param string The source code to highlight
    645. +
  645.      * @since 1.0.0
    646. +
  646.      */
    647. +
  647.     function set_source($source) {
    648. +
  648.         $this->source = $source;
    649. +
  649.         $this->highlight_extra_lines = array();
    650. +
  650.     }
    651. +
  651.  
    652. +
  652. /**    
    653. +
  653.      * Sets the language for this object
    654. +
  654.      *
    655. +
  655.      * @note since 1.0.8 this function won't reset language-settings by default anymore!
    656. +
  656.      *        if you need this set $force_reset = true
    657. +
  657.      *
    658. +
  658.      * @param string The name of the language to use
    659. +
  659.      * @since 1.0.0
    660. +
  660.      */
    661. +
  661.     function set_language($language, $force_reset = false) {
    662. +
  662.         if ($force_reset) {
    663. +
  663.             $this->loaded_language = false;
    664. +
  664.         }
    665. +
  665.  
    666. +
  666.         //Clean up the language name to prevent malicious code injection
    667. +
  667.         $language = preg_replace('#[^a-zA-Z0-9\-_]#', '', $language);
    668. +
  668.  
    669. +
  669.         $language = strtolower($language);
    670. +
  670.  
    671. +
  671.         //Retreive the full filename
    672. +
  672.         $file_name = $this->language_path . $language . '.php';
    673. +
  673.         if ($file_name == $this->loaded_language) {
    674. +
  674.             // this language is already loaded!
    675. +
  675.             return;
    676. +
  676.         }
    677. +
  677.  
    678. +
  678.         $this->language = $language;
    679. +
  679.  
    680. +
  680.         $this->error = false;
    681. +
  681.         $this->strict_mode = GESHI_NEVER;
    682. +
  682.  
    683. +
  683.         //Check if we can read the desired file
    684. +
  684.         if (!is_readable($file_name)) {
    685. +
  685.             $this->error = GESHI_ERROR_NO_SUCH_LANG;
    686. +
  686.             return;
    687. +
  687.         }
    688. +
  688.  
    689. +
  689.         // Load the language for parsing
    690. +
  690.         $this->load_language($file_name);
    691. +
  691.     }
    692. +
  692.  
    693. +
  693. /**    
    694. +
  694.      * Sets the path to the directory containing the language files. Note
    695. +
  695.      * that this path is relative to the directory of the script that included
    696. +
  696.      * geshi.php, NOT geshi.php itself.
    697. +
  697.      *
    698. +
  698.      * @param string The path to the language directory
    699. +
  699.      * @since 1.0.0
    700. +
  700.      * @deprecated The path to the language files should now be automatically
    701. +
  701.      *              detected, so this method should no longer be needed. The
    702. +
  702.      *              1.1.X branch handles manual setting of the path differently
    703. +
  703.      *              so this method will disappear in 1.2.0.
    704. +
  704.      */
    705. +
  705.     function set_language_path($path) {
    706. +
  706.         if(strpos($path,':')) {
    707. +
  707.             //Security Fix to prevent external directories using fopen wrappers.
    708. +
  708.             if(DIRECTORY_SEPARATOR == "\\") {
    709. +
  709.                 if(!preg_match('#^[a-zA-Z]:#', $path) || false !== strpos($path, ':', 2)) {
    710. +
  710.                     return;
    711. +
  711.                 }
    712. +
  712.             } else {
    713. +
  713.                 return;
    714. +
  714.             }
    715. +
  715.         }
    716. +
  716.         if(preg_match('#[^/a-zA-Z0-9_\.\-\\\s:]#', $path)) {
    717. +
  717.             //Security Fix to prevent external directories using fopen wrappers.
    718. +
  718.             return;
    719. +
  719.         }
    720. +
  720.         if(<a href="../geshi/core/_geshi.php.html#defineGESHI_SECURITY_PARANOID">GESHI_SECURITY_PARANOID</a> && false !== strpos($path, '/.')) {
    721. +
  721.             //Security Fix to prevent external directories using fopen wrappers.
    722. +
  722.             return;
    723. +
  723.         }
    724. +
  724.         if(<a href="../geshi/core/_geshi.php.html#defineGESHI_SECURITY_PARANOID">GESHI_SECURITY_PARANOID</a> && false !== strpos($path, '..')) {
    725. +
  725.             //Security Fix to prevent external directories using fopen wrappers.
    726. +
  726.             return;
    727. +
  727.         }
    728. +
  728.         if ($path) {
    729. +
  729.             $this->language_path = ('/' == $path[strlen($path) - 1]) ? $path : $path . '/';
    730. +
  730.             $this->set_language($this->language); // otherwise set_language_path has no effect
    731. +
  731.         }
    732. +
  732.     }
    733. +
  733.  
    734. +
  734. /**    
    735. +
  735.      * Sets the type of header to be used.
    736. +
  736.      *
    737. +
  737.      * If GESHI_HEADER_DIV is used, the code is surrounded in a "div".This
    738. +
  738.      * means more source code but more control over tab width and line-wrapping.
    739. +
  739.      * GESHI_HEADER_PRE means that a "pre" is used - less source, but less
    740. +
  740.      * control. Default is GESHI_HEADER_PRE.
    741. +
  741.      *
    742. +
  742.      * From 1.0.7.2, you can use GESHI_HEADER_NONE to specify that no header code
    743. +
  743.      * should be outputted.
    744. +
  744.      *
    745. +
  745.      * @param int The type of header to be used
    746. +
  746.      * @since 1.0.0
    747. +
  747.      */
    748. +
  748.     function set_header_type($type) {
    749. +
  749.         //Check if we got a valid header type
    750. +
  750.         if (!in_array($type, array(<a href="../geshi/core/_geshi.php.html#defineGESHI_HEADER_NONE">GESHI_HEADER_NONE</a>, <a href="../geshi/core/_geshi.php.html#defineGESHI_HEADER_DIV">GESHI_HEADER_DIV</a>,
    751. +
  751.             <a href="../geshi/core/_geshi.php.html#defineGESHI_HEADER_PRE">GESHI_HEADER_PRE</a>, <a href="../geshi/core/_geshi.php.html#defineGESHI_HEADER_PRE_VALID">GESHI_HEADER_PRE_VALID</a>, <a href="../geshi/core/_geshi.php.html#defineGESHI_HEADER_PRE_TABLE">GESHI_HEADER_PRE_TABLE</a>))) {
    752. +
  752.             $this->error = GESHI_ERROR_INVALID_HEADER_TYPE;
    753. +
  753.             return;
    754. +
  754.         }
    755. +
  755.  
    756. +
  756.         //Set that new header type
    757. +
  757.         $this->header_type = $type;
    758. +
  758.     }
    759. +
  759.  
    760. +
  760. /**    
    761. +
  761.      * Sets the styles for the code that will be outputted
    762. +
  762.      * when this object is parsed. The style should be a
    763. +
  763.      * string of valid stylesheet declarations
    764. +
  764.      *
    765. +
  765.      * @param string  The overall style for the outputted code block
    766. +
  766.      * @param boolean Whether to merge the styles with the current styles or not
    767. +
  767.      * @since 1.0.0
    768. +
  768.      */
    769. +
  769.     function set_overall_style($style, $preserve_defaults = false) {
    770. +
  770.         if (!$preserve_defaults) {
    771. +
  771.             $this->overall_style = $style;
    772. +
  772.         } else {
    773. +
  773.             $this->overall_style .= $style;
    774. +
  774.         }
    775. +
  775.     }
    776. +
  776.  
    777. +
  777. /**    
    778. +
  778.      * Sets the overall classname for this block of code. This
    779. +
  779.      * class can then be used in a stylesheet to style this object's
    780. +
  780.      * output
    781. +
  781.      *
    782. +
  782.      * @param string The class name to use for this block of code
    783. +
  783.      * @since 1.0.0
    784. +
  784.      */
    785. +
  785.     function set_overall_class($class) {
    786. +
  786.         $this->overall_class = $class;
    787. +
  787.     }
    788. +
  788.  
    789. +
  789. /**    
    790. +
  790.      * Sets the overall id for this block of code. This id can then
    791. +
  791.      * be used in a stylesheet to style this object's output
    792. +
  792.      *
    793. +
  793.      * @param string The ID to use for this block of code
    794. +
  794.      * @since 1.0.0
    795. +
  795.      */
    796. +
  796.     function set_overall_id($id) {
    797. +
  797.         $this->overall_id = $id;
    798. +
  798.     }
    799. +
  799.  
    800. +
  800. /**    
    801. +
  801.      * Sets whether CSS classes should be used to highlight the source. Default
    802. +
  802.      * is off, calling this method with no arguments will turn it on
    803. +
  803.      *
    804. +
  804.      * @param boolean Whether to turn classes on or not
    805. +
  805.      * @since 1.0.0
    806. +
  806.      */
    807. +
  807.     function enable_classes($flag = true) {
    808. +
  808.         $this->use_classes = ($flag) ? true : false;
    809. +
  809.     }
    810. +
  810.  
    811. +
  811. /**    
    812. +
  812.      * Sets the style for the actual code. This should be a string
    813. +
  813.      * containing valid stylesheet declarations. If $preserve_defaults is
    814. +
  814.      * true, then styles are merged with the default styles, with the
    815. +
  815.      * user defined styles having priority
    816. +
  816.      *
    817. +
  817.      * Note: Use this method to override any style changes you made to
    818. +
  818.      * the line numbers if you are using line numbers, else the line of
    819. +
  819.      * code will have the same style as the line number! Consult the
    820. +
  820.      * GeSHi documentation for more information about this.
    821. +
  821.      *
    822. +
  822.      * @param string  The style to use for actual code
    823. +
  823.      * @param boolean Whether to merge the current styles with the new styles
    824. +
  824.      * @since 1.0.2
    825. +
  825.      */
    826. +
  826.     function set_code_style($style, $preserve_defaults = false) {
    827. +
  827.         if (!$preserve_defaults) {
    828. +
  828.             $this->code_style = $style;
    829. +
  829.         } else {
    830. +
  830.             $this->code_style .= $style;
    831. +
  831.         }
    832. +
  832.     }
    833. +
  833.  
    834. +
  834. /**    
    835. +
  835.      * Sets the styles for the line numbers.
    836. +
  836.      *
    837. +
  837.      * @param string The style for the line numbers that are "normal"
    838. +
  838.      * @param string|booleanIf a string, this is the style of the line
    839. +
  839.      *         numbers that are "fancy", otherwise if boolean then this
    840. +
  840.      *         defines whether the normal styles should be merged with the
    841. +
  841.      *         new normal styles or not
    842. +
  842.      * @param boolean If set, is the flag for whether to merge the "fancy"
    843. +
  843.      *         styles with the current styles or not
    844. +
  844.      * @since 1.0.2
    845. +
  845.      */
    846. +
  846.     function set_line_style($style1, $style2 = '', $preserve_defaults = false) {
    847. +
  847.         //Check if we got 2 or three parameters
    848. +
  848.         if (is_bool($style2)) {
    849. +
  849.             $preserve_defaults = $style2;
    850. +
  850.             $style2 = '';
    851. +
  851.         }
    852. +
  852.  
    853. +
  853.         //Actually set the new styles
    854. +
  854.         if (!$preserve_defaults) {
    855. +
  855.             $this->line_style1 = $style1;
    856. +
  856.             $this->line_style2 = $style2;
    857. +
  857.         } else {
    858. +
  858.             $this->line_style1 .= $style1;
    859. +
  859.             $this->line_style2 .= $style2;
    860. +
  860.         }
    861. +
  861.     }
    862. +
  862.  
    863. +
  863. /**    
    864. +
  864.      * Sets whether line numbers should be displayed.
    865. +
  865.      *
    866. +
  866.      * Valid values for the first parameter are:
    867. +
  867.      *
    868. +
  868.      *  - GESHI_NO_LINE_NUMBERS: Line numbers will not be displayed
    869. +
  869.      *  - GESHI_NORMAL_LINE_NUMBERS: Line numbers will be displayed
    870. +
  870.      *  - GESHI_FANCY_LINE_NUMBERS: Fancy line numbers will be displayed
    871. +
  871.      *
    872. +
  872.      * For fancy line numbers, the second parameter is used to signal which lines
    873. +
  873.      * are to be fancy. For example, if the value of this parameter is 5 then every
    874. +
  874.      * 5th line will be fancy.
    875. +
  875.      *
    876. +
  876.      * @param int How line numbers should be displayed
    877. +
  877.      * @param int Defines which lines are fancy
    878. +
  878.      * @since 1.0.0
    879. +
  879.      */
    880. +
  880.     function enable_line_numbers($flag, $nth_row = 5) {
    881. +
  881.         if (<a href="../geshi/core/_geshi.php.html#defineGESHI_NO_LINE_NUMBERS">GESHI_NO_LINE_NUMBERS</a> != $flag && <a href="../geshi/core/_geshi.php.html#defineGESHI_NORMAL_LINE_NUMBERS">GESHI_NORMAL_LINE_NUMBERS</a> != $flag
    882. +
  882.             && <a href="../geshi/core/_geshi.php.html#defineGESHI_FANCY_LINE_NUMBERS">GESHI_FANCY_LINE_NUMBERS</a> != $flag) {
    883. +
  883.             $this->error = GESHI_ERROR_INVALID_LINE_NUMBER_TYPE;
    884. +
  884.         }
    885. +
  885.         $this->line_numbers = $flag;
    886. +
  886.         $this->line_nth_row = $nth_row;
    887. +
  887.     }
    888. +
  888.  
    889. +
  889. /**    
    890. +
  890.      * Sets wether spans and other HTML markup generated by GeSHi can
    891. +
  891.      * span over multiple lines or not. Defaults to true to reduce overhead.
    892. +
  892.      * Set it to false if you want to manipulate the output or manually display
    893. +
  893.      * the code in an ordered list.
    894. +
  894.      *
    895. +
  895.      * @param boolean Wether multiline spans are allowed or not
    896. +
  896.      * @since 1.0.7.22
    897. +
  897.      */
    898. +
  898.     function enable_multiline_span($flag) {
    899. +
  899.         $this->allow_multiline_span = (bool) $flag;
    900. +
  900.     }
    901. +
  901.  
    902. +
  902. /**    
    903. +
  903.      * Get current setting for multiline spans, see GeSHi->enable_multiline_span().
    904. +
  904.      *
    905. +
  905.      * @see enable_multiline_span
    906. +
  906.      * @return bool 
    907. +
  907.      */
    908. +
  908.     function get_multiline_span() {
    909. +
  909.         return $this->allow_multiline_span;
    910. +
  910.     }
    911. +
  911.  
    912. +
  912. /**    
    913. +
  913.      * Sets the style for a keyword group. If $preserve_defaults is
    914. +
  914.      * true, then styles are merged with the default styles, with the
    915. +
  915.      * user defined styles having priority
    916. +
  916.      *
    917. +
  917.      * @param int     The key of the keyword group to change the styles of
    918. +
  918.      * @param string  The style to make the keywords
    919. +
  919.      * @param boolean Whether to merge the new styles with the old or just
    920. +
  920.      *                 to overwrite them
    921. +
  921.      * @since 1.0.0
    922. +
  922.      */
    923. +
  923.     function set_keyword_group_style($key, $style, $preserve_defaults = false) {
    924. +
  924.         //Set the style for this keyword group
    925. +
  925.         if (!$preserve_defaults) {
    926. +
  926.             $this->language_data['STYLES']['KEYWORDS'][$key] = $style;
    927. +
  927.         } else {
    928. +
  928.             $this->language_data['STYLES']['KEYWORDS'][$key] .= $style;
    929. +
  929.         }
    930. +
  930.  
    931. +
  931.         //Update the lexic permissions
    932. +
  932.         if (!isset($this->lexic_permissions['KEYWORDS'][$key])) {
    933. +
  933.             $this->lexic_permissions['KEYWORDS'][$key] = true;
    934. +
  934.         }
    935. +
  935.     }
    936. +
  936.  
    937. +
  937. /**    
    938. +
  938.      * Turns highlighting on/off for a keyword group
    939. +
  939.      *
    940. +
  940.      * @param int     The key of the keyword group to turn on or off
    941. +
  941.      * @param boolean Whether to turn highlighting for that group on or off
    942. +
  942.      * @since 1.0.0
    943. +
  943.      */
    944. +
  944.     function set_keyword_group_highlighting($key, $flag = true) {
    945. +
  945.         $this->lexic_permissions['KEYWORDS'][$key] = ($flag) ? true : false;
    946. +
  946.     }
    947. +
  947.  
    948. +
  948. /**    
    949. +
  949.      * Sets the styles for comment groups.  If $preserve_defaults is
    950. +
  950.      * true, then styles are merged with the default styles, with the
    951. +
  951.      * user defined styles having priority
    952. +
  952.      *
    953. +
  953.      * @param int     The key of the comment group to change the styles of
    954. +
  954.      * @param string  The style to make the comments
    955. +
  955.      * @param boolean Whether to merge the new styles with the old or just
    956. +
  956.      *                 to overwrite them
    957. +
  957.      * @since 1.0.0
    958. +
  958.      */
    959. +
  959.     function set_comments_style($key, $style, $preserve_defaults = false) {
    960. +
  960.         if (!$preserve_defaults) {
    961. +
  961.             $this->language_data['STYLES']['COMMENTS'][$key] = $style;
    962. +
  962.         } else {
    963. +
  963.             $this->language_data['STYLES']['COMMENTS'][$key] .= $style;
    964. +
  964.         }
    965. +
  965.     }
    966. +
  966.  
    967. +
  967. /**    
    968. +
  968.      * Turns highlighting on/off for comment groups
    969. +
  969.      *
    970. +
  970.      * @param int     The key of the comment group to turn on or off
    971. +
  971.      * @param boolean Whether to turn highlighting for that group on or off
    972. +
  972.      * @since 1.0.0
    973. +
  973.      */
    974. +
  974.     function set_comments_highlighting($key, $flag = true) {
    975. +
  975.         $this->lexic_permissions['COMMENTS'][$key] = ($flag) ? true : false;
    976. +
  976.     }
    977. +
  977.  
    978. +
  978. /**    
    979. +
  979.      * Sets the styles for escaped characters. If $preserve_defaults is
    980. +
  980.      * true, then styles are merged with the default styles, with the
    981. +
  981.      * user defined styles having priority
    982. +
  982.      *
    983. +
  983.      * @param string  The style to make the escape characters
    984. +
  984.      * @param boolean Whether to merge the new styles with the old or just
    985. +
  985.      *                 to overwrite them
    986. +
  986.      * @since 1.0.0
    987. +
  987.      */
    988. +
  988.     function set_escape_characters_style($style, $preserve_defaults = false) {
    989. +
  989.         if (!$preserve_defaults) {
    990. +
  990.             $this->language_data['STYLES']['ESCAPE_CHAR'][0] = $style;
    991. +
  991.         } else {
    992. +
  992.             $this->language_data['STYLES']['ESCAPE_CHAR'][0] .= $style;
    993. +
  993.         }
    994. +
  994.     }
    995. +
  995.  
    996. +
  996. /**    
    997. +
  997.      * Turns highlighting on/off for escaped characters
    998. +
  998.      *
    999. +
  999.      * @param boolean Whether to turn highlighting for escape characters on or off
    1000. +
  1000.      * @since 1.0.0
    1001. +
  1001.      */
    1002. +
  1002.     function set_escape_characters_highlighting($flag = true) {
    1003. +
  1003.         $this->lexic_permissions['ESCAPE_CHAR'] = ($flag) ? true : false;
    1004. +
  1004.     }
    1005. +
  1005.  
    1006. +
  1006. /**    
    1007. +
  1007.      * Sets the styles for brackets. If $preserve_defaults is
    1008. +
  1008.      * true, then styles are merged with the default styles, with the
    1009. +
  1009.      * user defined styles having priority
    1010. +
  1010.      *
    1011. +
  1011.      * This method is DEPRECATED: use set_symbols_style instead.
    1012. +
  1012.      * This method will be removed in 1.2.X
    1013. +
  1013.      *
    1014. +
  1014.      * @param string  The style to make the brackets
    1015. +
  1015.      * @param boolean Whether to merge the new styles with the old or just
    1016. +
  1016.      *                 to overwrite them
    1017. +
  1017.      * @since 1.0.0
    1018. +
  1018.      * @deprecated In favour of set_symbols_style
    1019. +
  1019.      */
    1020. +
  1020.     function set_brackets_style($style, $preserve_defaults = false) {
    1021. +
  1021.         if (!$preserve_defaults) {
    1022. +
  1022.             $this->language_data['STYLES']['BRACKETS'][0] = $style;
    1023. +
  1023.         } else {
    1024. +
  1024.             $this->language_data['STYLES']['BRACKETS'][0] .= $style;
    1025. +
  1025.         }
    1026. +
  1026.     }
    1027. +
  1027.  
    1028. +
  1028. /**    
    1029. +
  1029.      * Turns highlighting on/off for brackets
    1030. +
  1030.      *
    1031. +
  1031.      * This method is DEPRECATED: use set_symbols_highlighting instead.
    1032. +
  1032.      * This method will be remove in 1.2.X
    1033. +
  1033.      *
    1034. +
  1034.      * @param boolean Whether to turn highlighting for brackets on or off
    1035. +
  1035.      * @since 1.0.0
    1036. +
  1036.      * @deprecated In favour of set_symbols_highlighting
    1037. +
  1037.      */
    1038. +
  1038.     function set_brackets_highlighting($flag) {
    1039. +
  1039.         $this->lexic_permissions['BRACKETS'] = ($flag) ? true : false;
    1040. +
  1040.     }
    1041. +
  1041.  
    1042. +
  1042. /**    
    1043. +
  1043.      * Sets the styles for symbols. If $preserve_defaults is
    1044. +
  1044.      * true, then styles are merged with the default styles, with the
    1045. +
  1045.      * user defined styles having priority
    1046. +
  1046.      *
    1047. +
  1047.      * @param string  The style to make the symbols
    1048. +
  1048.      * @param boolean Whether to merge the new styles with the old or just
    1049. +
  1049.      *                 to overwrite them
    1050. +
  1050.      * @param int     Tells the group of symbols for which style should be set.
    1051. +
  1051.      * @since 1.0.1
    1052. +
  1052.      */
    1053. +
  1053.     function set_symbols_style($style, $preserve_defaults = false, $group = 0) {
    1054. +
  1054.         // Update the style of symbols
    1055. +
  1055.         if (!$preserve_defaults) {
    1056. +
  1056.             $this->language_data['STYLES']['SYMBOLS'][$group] = $style;
    1057. +
  1057.         } else {
    1058. +
  1058.             $this->language_data['STYLES']['SYMBOLS'][$group] .= $style;
    1059. +
  1059.         }
    1060. +
  1060.  
    1061. +
  1061.         // For backward compatibility
    1062. +
  1062.         if (0 == $group) {
    1063. +
  1063.             $this->set_brackets_style ($style, $preserve_defaults);
    1064. +
  1064.         }
    1065. +
  1065.     }
    1066. +
  1066.  
    1067. +
  1067. /**    
    1068. +
  1068.      * Turns highlighting on/off for symbols
    1069. +
  1069.      *
    1070. +
  1070.      * @param boolean Whether to turn highlighting for symbols on or off
    1071. +
  1071.      * @since 1.0.0
    1072. +
  1072.      */
    1073. +
  1073.     function set_symbols_highlighting($flag) {
    1074. +
  1074.         // Update lexic permissions for this symbol group
    1075. +
  1075.         $this->lexic_permissions['SYMBOLS'] = ($flag) ? true : false;
    1076. +
  1076.  
    1077. +
  1077.         // For backward compatibility
    1078. +
  1078.         $this->set_brackets_highlighting ($flag);
    1079. +
  1079.     }
    1080. +
  1080.  
    1081. +
  1081. /**    
    1082. +
  1082.      * Sets the styles for strings. If $preserve_defaults is
    1083. +
  1083.      * true, then styles are merged with the default styles, with the
    1084. +
  1084.      * user defined styles having priority
    1085. +
  1085.      *
    1086. +
  1086.      * @param string  The style to make the escape characters
    1087. +
  1087.      * @param boolean Whether to merge the new styles with the old or just
    1088. +
  1088.      *                 to overwrite them
    1089. +
  1089.      * @since 1.0.0
    1090. +
  1090.      */
    1091. +
  1091.     function set_strings_style($style, $preserve_defaults = false) {
    1092. +
  1092.         if (!$preserve_defaults) {
    1093. +
  1093.             $this->language_data['STYLES']['STRINGS'][0] = $style;
    1094. +
  1094.         } else {
    1095. +
  1095.             $this->language_data['STYLES']['STRINGS'][0] .= $style;
    1096. +
  1096.         }
    1097. +
  1097.     }
    1098. +
  1098.  
    1099. +
  1099. /**    
    1100. +
  1100.      * Turns highlighting on/off for strings
    1101. +
  1101.      *
    1102. +
  1102.      * @param boolean Whether to turn highlighting for strings on or off
    1103. +
  1103.      * @since 1.0.0
    1104. +
  1104.      */
    1105. +
  1105.     function set_strings_highlighting($flag) {
    1106. +
  1106.         $this->lexic_permissions['STRINGS'] = ($flag) ? true : false;
    1107. +
  1107.     }
    1108. +
  1108.  
    1109. +
  1109. /**    
    1110. +
  1110.      * Sets the styles for numbers. If $preserve_defaults is
    1111. +
  1111.      * true, then styles are merged with the default styles, with the
    1112. +
  1112.      * user defined styles having priority
    1113. +
  1113.      *
    1114. +
  1114.      * @param string  The style to make the numbers
    1115. +
  1115.      * @param boolean Whether to merge the new styles with the old or just
    1116. +
  1116.      *                 to overwrite them
    1117. +
  1117.      * @since 1.0.0
    1118. +
  1118.      */
    1119. +
  1119.     function set_numbers_style($style, $preserve_defaults = false) {
    1120. +
  1120.         if (!$preserve_defaults) {
    1121. +
  1121.             $this->language_data['STYLES']['NUMBERS'][0] = $style;
    1122. +
  1122.         } else {
    1123. +
  1123.             $this->language_data['STYLES']['NUMBERS'][0] .= $style;
    1124. +
  1124.         }
    1125. +
  1125.     }
    1126. +
  1126.  
    1127. +
  1127. /**    
    1128. +
  1128.      * Turns highlighting on/off for numbers
    1129. +
  1129.      *
    1130. +
  1130.      * @param boolean Whether to turn highlighting for numbers on or off
    1131. +
  1131.      * @since 1.0.0
    1132. +
  1132.      */
    1133. +
  1133.     function set_numbers_highlighting($flag) {
    1134. +
  1134.         $this->lexic_permissions['NUMBERS'] = ($flag) ? true : false;
    1135. +
  1135.     }
    1136. +
  1136.  
    1137. +
  1137. /**    
    1138. +
  1138.      * Sets the styles for methods. $key is a number that references the
    1139. +
  1139.      * appropriate "object splitter" - see the language file for the language
    1140. +
  1140.      * you are highlighting to get this number. If $preserve_defaults is
    1141. +
  1141.      * true, then styles are merged with the default styles, with the
    1142. +
  1142.      * user defined styles having priority
    1143. +
  1143.      *
    1144. +
  1144.      * @param int     The key of the object splitter to change the styles of
    1145. +
  1145.      * @param string  The style to make the methods
    1146. +
  1146.      * @param boolean Whether to merge the new styles with the old or just
    1147. +
  1147.      *                 to overwrite them
    1148. +
  1148.      * @since 1.0.0
    1149. +
  1149.      */
    1150. +
  1150.     function set_methods_style($key, $style, $preserve_defaults = false) {
    1151. +
  1151.         if (!$preserve_defaults) {
    1152. +
  1152.             $this->language_data['STYLES']['METHODS'][$key] = $style;
    1153. +
  1153.         } else {
    1154. +
  1154.             $this->language_data['STYLES']['METHODS'][$key] .= $style;
    1155. +
  1155.         }
    1156. +
  1156.     }
    1157. +
  1157.  
    1158. +
  1158. /**    
    1159. +
  1159.      * Turns highlighting on/off for methods
    1160. +
  1160.      *
    1161. +
  1161.      * @param boolean Whether to turn highlighting for methods on or off
    1162. +
  1162.      * @since 1.0.0
    1163. +
  1163.      */
    1164. +
  1164.     function set_methods_highlighting($flag) {
    1165. +
  1165.         $this->lexic_permissions['METHODS'] = ($flag) ? true : false;
    1166. +
  1166.     }
    1167. +
  1167.  
    1168. +
  1168. /**    
    1169. +
  1169.      * Sets the styles for regexps. If $preserve_defaults is
    1170. +
  1170.      * true, then styles are merged with the default styles, with the
    1171. +
  1171.      * user defined styles having priority
    1172. +
  1172.      *
    1173. +
  1173.      * @param string  The style to make the regular expression matches
    1174. +
  1174.      * @param boolean Whether to merge the new styles with the old or just
    1175. +
  1175.      *                 to overwrite them
    1176. +
  1176.      * @since 1.0.0
    1177. +
  1177.      */
    1178. +
  1178.     function set_regexps_style($key, $style, $preserve_defaults = false) {
    1179. +
  1179.         if (!$preserve_defaults) {
    1180. +
  1180.             $this->language_data['STYLES']['REGEXPS'][$key] = $style;
    1181. +
  1181.         } else {
    1182. +
  1182.             $this->language_data['STYLES']['REGEXPS'][$key] .= $style;
    1183. +
  1183.         }
    1184. +
  1184.     }
    1185. +
  1185.  
    1186. +
  1186. /**    
    1187. +
  1187.      * Turns highlighting on/off for regexps
    1188. +
  1188.      *
    1189. +
  1189.      * @param int     The key of the regular expression group to turn on or off
    1190. +
  1190.      * @param boolean Whether to turn highlighting for the regular expression group on or off
    1191. +
  1191.      * @since 1.0.0
    1192. +
  1192.      */
    1193. +
  1193.     function set_regexps_highlighting($key, $flag) {
    1194. +
  1194.         $this->lexic_permissions['REGEXPS'][$key] = ($flag) ? true : false;
    1195. +
  1195.     }
    1196. +
  1196.  
    1197. +
  1197. /**    
    1198. +
  1198.      * Sets whether a set of keywords are checked for in a case sensitive manner
    1199. +
  1199.      *
    1200. +
  1200.      * @param int The key of the keyword group to change the case sensitivity of
    1201. +
  1201.      * @param boolean Whether to check in a case sensitive manner or not
    1202. +
  1202.      * @since 1.0.0
    1203. +
  1203.      */
    1204. +
  1204.     function set_case_sensitivity($key, $case) {
    1205. +
  1205.         $this->language_data['CASE_SENSITIVE'][$key] = ($case) ? true : false;
    1206. +
  1206.     }
    1207. +
  1207.  
    1208. +
  1208. /**    
    1209. +
  1209.      * Sets the case that keywords should use when found. Use the constants:
    1210. +
  1210.      *
    1211. +
  1211.      *  - GESHI_CAPS_NO_CHANGE: leave keywords as-is
    1212. +
  1212.      *  - GESHI_CAPS_UPPER: convert all keywords to uppercase where found
    1213. +
  1213.      *  - GESHI_CAPS_LOWER: convert all keywords to lowercase where found
    1214. +
  1214.      *
    1215. +
  1215.      * @param int A constant specifying what to do with matched keywords
    1216. +
  1216.      * @since 1.0.1
    1217. +
  1217.      */
    1218. +
  1218.     function set_case_keywords($case) {
    1219. +
  1219.         if (in_array($case, array(
    1220. +
  1220.             <a href="../geshi/core/_geshi.php.html#defineGESHI_CAPS_NO_CHANGE">GESHI_CAPS_NO_CHANGE</a>, <a href="../geshi/core/_geshi.php.html#defineGESHI_CAPS_UPPER">GESHI_CAPS_UPPER</a>, <a href="../geshi/core/_geshi.php.html#defineGESHI_CAPS_LOWER">GESHI_CAPS_LOWER</a>))) {
    1221. +
  1221.             $this->language_data['CASE_KEYWORDS'] = $case;
    1222. +
  1222.         }
    1223. +
  1223.     }
    1224. +
  1224.  
    1225. +
  1225. /**    
    1226. +
  1226.      * Sets how many spaces a tab is substituted for
    1227. +
  1227.      *
    1228. +
  1228.      * Widths below zero are ignored
    1229. +
  1229.      *
    1230. +
  1230.      * @param int The tab width
    1231. +
  1231.      * @since 1.0.0
    1232. +
  1232.      */
    1233. +
  1233.     function set_tab_width($width) {
    1234. +
  1234.         $this->tab_width = intval($width);
    1235. +
  1235.  
    1236. +
  1236.         //Check if it fit's the constraints:
    1237. +
  1237.         if ($this->tab_width < 1) {
    1238. +
  1238.             //Return it to the default
    1239. +
  1239.             $this->tab_width = 8;
    1240. +
  1240.         }
    1241. +
  1241.     }
    1242. +
  1242.  
    1243. +
  1243. /**    
    1244. +
  1244.      * Sets whether or not to use tab-stop width specifed by language
    1245. +
  1245.      *
    1246. +
  1246.      * @param boolean Whether to use language-specific tab-stop widths
    1247. +
  1247.      * @since 1.0.7.20
    1248. +
  1248.      */
    1249. +
  1249.     function set_use_language_tab_width($use) {
    1250. +
  1250.         $this->use_language_tab_width = (bool) $use;
    1251. +
  1251.     }
    1252. +
  1252.  
    1253. +
  1253. /**    
    1254. +
  1254.      * Returns the tab width to use, based on the current language and user
    1255. +
  1255.      * preference
    1256. +
  1256.      *
    1257. +
  1257.      * @return int Tab width
    1258. +
  1258.      * @since 1.0.7.20
    1259. +
  1259.      */
    1260. +
  1260.     function get_real_tab_width() {
    1261. +
  1261.         if (!$this->use_language_tab_width ||
    1262. +
  1262.             !isset($this->language_data['TAB_WIDTH'])) {
    1263. +
  1263.             return $this->tab_width;
    1264. +
  1264.         } else {
    1265. +
  1265.             return $this->language_data['TAB_WIDTH'];
    1266. +
  1266.         }
    1267. +
  1267.     }
    1268. +
  1268.  
    1269. +
  1269. /**    
    1270. +
  1270.      * Enables/disables strict highlighting. Default is off, calling this
    1271. +
  1271.      * method without parameters will turn it on. See documentation
    1272. +
  1272.      * for more details on strict mode and where to use it.
    1273. +
  1273.      *
    1274. +
  1274.      * @param boolean Whether to enable strict mode or not
    1275. +
  1275.      * @since 1.0.0
    1276. +
  1276.      */
    1277. +
  1277.     function enable_strict_mode($mode = true) {
    1278. +
  1278.         if (GESHI_MAYBE == $this->language_data['STRICT_MODE_APPLIES']) {
    1279. +
  1279.             $this->strict_mode = ($mode) ? GESHI_ALWAYS : GESHI_NEVER;
    1280. +
  1280.         }
    1281. +
  1281.     }
    1282. +
  1282.  
    1283. +
  1283. /**    
    1284. +
  1284.      * Disables all highlighting
    1285. +
  1285.      *
    1286. +
  1286.      * @since 1.0.0
    1287. +
  1287.      * @todo  Rewrite with array traversal
    1288. +
  1288.      * @deprecated In favour of enable_highlighting
    1289. +
  1289.      */
    1290. +
  1290.     function disable_highlighting() {
    1291. +
  1291.         $this->enable_highlighting(false);
    1292. +
  1292.     }
    1293. +
  1293.  
    1294. +
  1294. /**    
    1295. +
  1295.      * Enables all highlighting
    1296. +
  1296.      *
    1297. +
  1297.      * The optional flag parameter was added in version 1.0.7.21 and can be used
    1298. +
  1298.      * to enable (true) or disable (false) all highlighting.
    1299. +
  1299.      *
    1300. +
  1300.      * @since 1.0.0
    1301. +
  1301.      * @param boolean A flag specifying whether to enable or disable all highlighting
    1302. +
  1302.      * @todo  Rewrite with array traversal
    1303. +
  1303.      */
    1304. +
  1304.     function enable_highlighting($flag = true) {
    1305. +
  1305.         $flag = $flag ? true : false;
    1306. +
  1306.         foreach ($this->lexic_permissions as $key => $value) {
    1307. +
  1307.             if (is_array($value)) {
    1308. +
  1308.                 foreach ($value as $k => $v) {
    1309. +
  1309.                     $this->lexic_permissions[$key][$k] = $flag;
    1310. +
  1310.                 }
    1311. +
  1311.             } else {
    1312. +
  1312.                 $this->lexic_permissions[$key] = $flag;
    1313. +
  1313.             }
    1314. +
  1314.         }
    1315. +
  1315.  
    1316. +
  1316.         // Context blocks
    1317. +
  1317.         $this->enable_important_blocks = $flag;
    1318. +
  1318.     }
    1319. +
  1319.  
    1320. +
  1320. /**    
    1321. +
  1321.      * Given a file extension, this method returns either a valid geshi language
    1322. +
  1322.      * name, or the empty string if it couldn't be found
    1323. +
  1323.      *
    1324. +
  1324.      * @param string The extension to get a language name for
    1325. +
  1325.      * @param array  A lookup array to use instead of the default one
    1326. +
  1326.      * @since 1.0.5
    1327. +
  1327.      * @todo Re-think about how this method works (maybe make it private and/or make it
    1328. +
  1328.      *        a extension->lang lookup?)
    1329. +
  1329.      * @todo static?
    1330. +
  1330.      */
    1331. +
  1331.     function get_language_name_from_extension( $extension, $lookup = array() ) {
    1332. +
  1332.         if ( !is_array($lookup) || empty($lookup)) {
    1333. +
  1333.             $lookup = array(
    1334. +
  1334.                 'actionscript' => array('as'),
    1335. +
  1335.                 'ada' => array('a', 'ada', 'adb', 'ads'),
    1336. +
  1336.                 'apache' => array('conf'),
    1337. +
  1337.                 'asm' => array('ash', 'asm', 'inc'),
    1338. +
  1338.                 'asp' => array('asp'),
    1339. +
  1339.                 'bash' => array('sh'),
    1340. +
  1340.                 'bf' => array('bf'),
    1341. +
  1341.                 'c' => array('c', 'h'),
    1342. +
  1342.                 'c_mac' => array('c', 'h'),
    1343. +
  1343.                 'caddcl' => array(),
    1344. +
  1344.                 'cadlisp' => array(),
    1345. +
  1345.                 'cdfg' => array('cdfg'),
    1346. +
  1346.                 'cobol' => array('cbl'),
    1347. +
  1347.                 'cpp' => array('cpp', 'hpp', 'C', 'H', 'CPP', 'HPP'),
    1348. +
  1348.                 'csharp' => array('cs'),
    1349. +
  1349.                 'css' => array('css'),
    1350. +
  1350.                 'd' => array('d'),
    1351. +
  1351.                 'delphi' => array('dpk', 'dpr', 'pp', 'pas'),
    1352. +
  1352.                 'diff' => array('diff', 'patch'),
    1353. +
  1353.                 'dos' => array('bat', 'cmd'),
    1354. +
  1354.                 'gettext' => array('po', 'pot'),
    1355. +
  1355.                 'gml' => array('gml'),
    1356. +
  1356.                 'gnuplot' => array('plt'),
    1357. +
  1357.                 'groovy' => array('groovy'),
    1358. +
  1358.                 'haskell' => array('hs'),
    1359. +
  1359.                 'html4strict' => array('html', 'htm'),
    1360. +
  1360.                 'ini' => array('ini', 'desktop'),
    1361. +
  1361.                 'java' => array('java'),
    1362. +
  1362.                 'javascript' => array('js'),
    1363. +
  1363.                 'klonec' => array('kl1'),
    1364. +
  1364.                 'klonecpp' => array('klx'),
    1365. +
  1365.                 'latex' => array('tex'),
    1366. +
  1366.                 'lisp' => array('lisp'),
    1367. +
  1367.                 'lua' => array('lua'),
    1368. +
  1368.                 'matlab' => array('m'),
    1369. +
  1369.                 'mpasm' => array(),
    1370. +
  1370.                 'mysql' => array('sql'),
    1371. +
  1371.                 'nsis' => array(),
    1372. +
  1372.                 'objc' => array(),
    1373. +
  1373.                 'oobas' => array(),
    1374. +
  1374.                 'oracle8' => array(),
    1375. +
  1375.                 'oracle10' => array(),
    1376. +
  1376.                 'pascal' => array('pas'),
    1377. +
  1377.                 'perl' => array('pl', 'pm'),
    1378. +
  1378.                 'php' => array('php', 'php5', 'phtml', 'phps'),
    1379. +
  1379.                 'povray' => array('pov'),
    1380. +
  1380.                 'providex' => array('pvc', 'pvx'),
    1381. +
  1381.                 'prolog' => array('pl'),
    1382. +
  1382.                 'python' => array('py'),
    1383. +
  1383.                 'qbasic' => array('bi'),
    1384. +
  1384.                 'reg' => array('reg'),
    1385. +
  1385.                 'ruby' => array('rb'),
    1386. +
  1386.                 'sas' => array('sas'),
    1387. +
  1387.                 'scala' => array('scala'),
    1388. +
  1388.                 'scheme' => array('scm'),
    1389. +
  1389.                 'scilab' => array('sci'),
    1390. +
  1390.                 'smalltalk' => array('st'),
    1391. +
  1391.                 'smarty' => array(),
    1392. +
  1392.                 'tcl' => array('tcl'),
    1393. +
  1393.                 'vb' => array('bas'),
    1394. +
  1394.                 'vbnet' => array(),
    1395. +
  1395.                 'visualfoxpro' => array(),
    1396. +
  1396.                 'whitespace' => array('ws'),
    1397. +
  1397.                 'xml' => array('xml', 'svg'),
    1398. +
  1398.                 'z80' => array('z80', 'asm', 'inc')
    1399. +
  1399.             );
    1400. +
  1400.         }
    1401. +
  1401.  
    1402. +
  1402.         foreach ($lookup as $lang => $extensions) {
    1403. +
  1403.             if (in_array($extension, $extensions)) {
    1404. +
  1404.                 return $lang;
    1405. +
  1405.             }
    1406. +
  1406.         }
    1407. +
  1407.         return '';
    1408. +
  1408.     }
    1409. +
  1409.  
    1410. +
  1410. /**    
    1411. +
  1411.      * Given a file name, this method loads its contents in, and attempts
    1412. +
  1412.      * to set the language automatically. An optional lookup table can be
    1413. +
  1413.      * passed for looking up the language name. If not specified a default
    1414. +
  1414.      * table is used
    1415. +
  1415.      *
    1416. +
  1416.      * The language table is in the form
    1417. +
  1417.      * <pre>array(
    1418. +
  1418.      *   'lang_name' => array('extension', 'extension', ...),
    1419. +
  1419.      *   'lang_name' ...
    1420. +
  1420.      * );</pre>
    1421. +
  1421.      *
    1422. +
  1422.      * @param string The filename to load the source from
    1423. +
  1423.      * @param array  A lookup array to use instead of the default one
    1424. +
  1424.      * @todo Complete rethink of this and above method
    1425. +
  1425.      * @since 1.0.5
    1426. +
  1426.      */
    1427. +
  1427.     function load_from_file($file_name, $lookup = array()) {
    1428. +
  1428.         if (is_readable($file_name)) {
    1429. +
  1429.             $this->set_source(file_get_contents($file_name));
    1430. +
  1430.             $this->set_language($this->get_language_name_from_extension(substr(strrchr($file_name, '.'), 1), $lookup));
    1431. +
  1431.         } else {
    1432. +
  1432.             $this->error = GESHI_ERROR_FILE_NOT_READABLE;
    1433. +
  1433.         }
    1434. +
  1434.     }
    1435. +
  1435.  
    1436. +
  1436. /**    
    1437. +
  1437.      * Adds a keyword to a keyword group for highlighting
    1438. +
  1438.      *
    1439. +
  1439.      * @param int    The key of the keyword group to add the keyword to
    1440. +
  1440.      * @param string The word to add to the keyword group
    1441. +
  1441.      * @since 1.0.0
    1442. +
  1442.      */
    1443. +
  1443.     function add_keyword($key, $word) {
    1444. +
  1444.         if (!in_array($word, $this->language_data['KEYWORDS'][$key])) {
    1445. +
  1445.             $this->language_data['KEYWORDS'][$key][] = $word;
    1446. +
  1446.  
    1447. +
  1447.             //NEW in 1.0.8 don't recompile the whole optimized regexp, simply append it
    1448. +
  1448.             if ($this->parse_cache_built) {
    1449. +
  1449.                 $subkey = count($this->language_data['CACHED_KEYWORD_LISTS'][$key]) - 1;
    1450. +
  1450.                 $this->language_data['CACHED_KEYWORD_LISTS'][$key][$subkey] .= '|' . preg_quote($word, '/');
    1451. +
  1451.             }
    1452. +
  1452.         }
    1453. +
  1453.     }
    1454. +
  1454.  
    1455. +
  1455. /**    
    1456. +
  1456.      * Removes a keyword from a keyword group
    1457. +
  1457.      *
    1458. +
  1458.      * @param int    The key of the keyword group to remove the keyword from
    1459. +
  1459.      * @param string The word to remove from the keyword group
    1460. +
  1460.      * @param bool   Wether to automatically recompile the optimized regexp list or not.
    1461. +
  1461.      *                Note: if you set this to false and @see GeSHi->parse_code() was already called once,
    1462. +
  1462.      *                for the current language, you have to manually call @see GeSHi->optimize_keyword_group()
    1463. +
  1463.      *                or the removed keyword will stay in cache and still be highlighted! On the other hand
    1464. +
  1464.      *                it might be too expensive to recompile the regexp list for every removal if you want to
    1465. +
  1465.      *                remove a lot of keywords.
    1466. +
  1466.      * @since 1.0.0
    1467. +
  1467.      */
    1468. +
  1468.     function remove_keyword($key, $word, $recompile = true) {
    1469. +
  1469.         $key_to_remove = array_search($word, $this->language_data['KEYWORDS'][$key]);
    1470. +
  1470.         if ($key_to_remove !== false) {
    1471. +
  1471.             unset($this->language_data['KEYWORDS'][$key][$key_to_remove]);
    1472. +
  1472.  
    1473. +
  1473.             //NEW in 1.0.8, optionally recompile keyword group
    1474. +
  1474.             if ($recompile && $this->parse_cache_built) {
    1475. +
  1475.                 $this->optimize_keyword_group($key);
    1476. +
  1476.             }
    1477. +
  1477.         }
    1478. +
  1478.     }
    1479. +
  1479.  
    1480. +
  1480. /**    
    1481. +
  1481.      * Creates a new keyword group
    1482. +
  1482.      *
    1483. +
  1483.      * @param int    The key of the keyword group to create
    1484. +
  1484.      * @param string The styles for the keyword group
    1485. +
  1485.      * @param boolean Whether the keyword group is case sensitive ornot
    1486. +
  1486.      * @param array  The words to use for the keyword group
    1487. +
  1487.      * @since 1.0.0
    1488. +
  1488.      */
    1489. +
  1489.     function add_keyword_group($key, $styles, $case_sensitive = true, $words = array()) {
    1490. +
  1490.         $words = (array) $words;
    1491. +
  1491.         if  (empty($words)) {
    1492. +
  1492.             // empty word lists mess up highlighting
    1493. +
  1493.             return false;
    1494. +
  1494.         }
    1495. +
  1495.  
    1496. +
  1496.         //Add the new keyword group internally
    1497. +
  1497.         $this->language_data['KEYWORDS'][$key] = $words;
    1498. +
  1498.         $this->lexic_permissions['KEYWORDS'][$key] = true;
    1499. +
  1499.         $this->language_data['CASE_SENSITIVE'][$key] = $case_sensitive;
    1500. +
  1500.         $this->language_data['STYLES']['KEYWORDS'][$key] = $styles;
    1501. +
  1501.  
    1502. +
  1502.         //NEW in 1.0.8, cache keyword regexp
    1503. +
  1503.         if ($this->parse_cache_built) {
    1504. +
  1504.             $this->optimize_keyword_group($key);
    1505. +
  1505.         }
    1506. +
  1506.     }
    1507. +
  1507.  
    1508. +
  1508. /**    
    1509. +
  1509.      * Removes a keyword group
    1510. +
  1510.      *
    1511. +
  1511.      * @param int    The key of the keyword group to remove
    1512. +
  1512.      * @since 1.0.0
    1513. +
  1513.      */
    1514. +
  1514.     function remove_keyword_group ($key) {
    1515. +
  1515.         //Remove the keyword group internally
    1516. +
  1516.         unset($this->language_data['KEYWORDS'][$key]);
    1517. +
  1517.         unset($this->lexic_permissions['KEYWORDS'][$key]);
    1518. +
  1518.         unset($this->language_data['CASE_SENSITIVE'][$key]);
    1519. +
  1519.         unset($this->language_data['STYLES']['KEYWORDS'][$key]);
    1520. +
  1520.  
    1521. +
  1521.         //NEW in 1.0.8
    1522. +
  1522.         unset($this->language_data['CACHED_KEYWORD_LISTS'][$key]);
    1523. +
  1523.     }
    1524. +
  1524.  
    1525. +
  1525. /**    
    1526. +
  1526.      * compile optimized regexp list for keyword group
    1527. +
  1527.      *
    1528. +
  1528.      * @param int   The key of the keyword group to compile & optimize
    1529. +
  1529.      * @since 1.0.8
    1530. +
  1530.      */
    1531. +
  1531.     function optimize_keyword_group($key) {
    1532. +
  1532.         $this->language_data['CACHED_KEYWORD_LISTS'][$key] =
    1533. +
  1533.             $this->optimize_regexp_list($this->language_data['KEYWORDS'][$key]);
    1534. +
  1534.     }
    1535. +
  1535.  
    1536. +
  1536. /**    
    1537. +
  1537.      * Sets the content of the header block
    1538. +
  1538.      *
    1539. +
  1539.      * @param string The content of the header block
    1540. +
  1540.      * @since 1.0.2
    1541. +
  1541.      */
    1542. +
  1542.     function set_header_content($content) {
    1543. +
  1543.         $this->header_content = $content;
    1544. +
  1544.     }
    1545. +
  1545.  
    1546. +
  1546. /**    
    1547. +
  1547.      * Sets the content of the footer block
    1548. +
  1548.      *
    1549. +
  1549.      * @param string The content of the footer block
    1550. +
  1550.      * @since 1.0.2
    1551. +
  1551.      */
    1552. +
  1552.     function set_footer_content($content) {
    1553. +
  1553.         $this->footer_content = $content;
    1554. +
  1554.     }
    1555. +
  1555.  
    1556. +
  1556. /**    
    1557. +
  1557.      * Sets the style for the header content
    1558. +
  1558.      *
    1559. +
  1559.      * @param string The style for the header content
    1560. +
  1560.      * @since 1.0.2
    1561. +
  1561.      */
    1562. +
  1562.     function set_header_content_style($style) {
    1563. +
  1563.         $this->header_content_style = $style;
    1564. +
  1564.     }
    1565. +
  1565.  
    1566. +
  1566. /**    
    1567. +
  1567.      * Sets the style for the footer content
    1568. +
  1568.      *
    1569. +
  1569.      * @param string The style for the footer content
    1570. +
  1570.      * @since 1.0.2
    1571. +
  1571.      */
    1572. +
  1572.     function set_footer_content_style($style) {
    1573. +
  1573.         $this->footer_content_style = $style;
    1574. +
  1574.     }
    1575. +
  1575.  
    1576. +
  1576. /**    
    1577. +
  1577.      * Sets whether to force a surrounding block around
    1578. +
  1578.      * the highlighted code or not
    1579. +
  1579.      *
    1580. +
  1580.      * @param boolean Tells whether to enable or disable this feature
    1581. +
  1581.      * @since 1.0.7.20
    1582. +
  1582.      */
    1583. +
  1583.     function enable_inner_code_block($flag) {
    1584. +
  1584.         $this->force_code_block = (bool)$flag;
    1585. +
  1585.     }
    1586. +
  1586.  
    1587. +
  1587. /**    
    1588. +
  1588.      * Sets the base URL to be used for keywords
    1589. +
  1589.      *
    1590. +
  1590.      * @param int The key of the keyword group to set the URL for
    1591. +
  1591.      * @param string The URL to set for the group. If {FNAME} is in
    1592. +
  1592.      *                the url somewhere, it is replaced by the keyword
    1593. +
  1593.      *                that the URL is being made for
    1594. +
  1594.      * @since 1.0.2
    1595. +
  1595.      */
    1596. +
  1596.     function set_url_for_keyword_group($group, $url) {
    1597. +
  1597.         $this->language_data['URLS'][$group] = $url;
    1598. +
  1598.     }
    1599. +
  1599.  
    1600. +
  1600. /**    
    1601. +
  1601.      * Sets styles for links in code
    1602. +
  1602.      *
    1603. +
  1603.      * @param int A constant that specifies what state the style is being
    1604. +
  1604.      *             set for - e.g. :hover or :visited
    1605. +
  1605.      * @param string The styles to use for that state
    1606. +
  1606.      * @since 1.0.2
    1607. +
  1607.      */
    1608. +
  1608.     function set_link_styles($type, $styles) {
    1609. +
  1609.         $this->link_styles[$type] = $styles;
    1610. +
  1610.     }
    1611. +
  1611.  
    1612. +
  1612. /**    
    1613. +
  1613.      * Sets the target for links in code
    1614. +
  1614.      *
    1615. +
  1615.      * @param string The target for links in the code, e.g. _blank
    1616. +
  1616.      * @since 1.0.3
    1617. +
  1617.      */
    1618. +
  1618.     function set_link_target($target) {
    1619. +
  1619.         if (!$target) {
    1620. +
  1620.             $this->link_target = '';
    1621. +
  1621.         } else {
    1622. +
  1622.             $this->link_target = ' target="' . $target . '" ';
    1623. +
  1623.         }
    1624. +
  1624.     }
    1625. +
  1625.  
    1626. +
  1626. /**    
    1627. +
  1627.      * Sets styles for important parts of the code
    1628. +
  1628.      *
    1629. +
  1629.      * @param string The styles to use on important parts of the code
    1630. +
  1630.      * @since 1.0.2
    1631. +
  1631.      */
    1632. +
  1632.     function set_important_styles($styles) {
    1633. +
  1633.         $this->important_styles = $styles;
    1634. +
  1634.     }
    1635. +
  1635.  
    1636. +
  1636. /**    
    1637. +
  1637.      * Sets whether context-important blocks are highlighted
    1638. +
  1638.      *
    1639. +
  1639.      * @param boolean Tells whether to enable or disable highlighting of important blocks
    1640. +
  1640.      * @todo REMOVE THIS SHIZ FROM GESHI!
    1641. +
  1641.      * @deprecated
    1642. +
  1642.      * @since 1.0.2
    1643. +
  1643.      */
    1644. +
  1644.     function enable_important_blocks($flag) {
    1645. +
  1645.         $this->enable_important_blocks = ( $flag ) ? true : false;
    1646. +
  1646.     }
    1647. +
  1647.  
    1648. +
  1648. /**    
    1649. +
  1649.      * Whether CSS IDs should be added to each line
    1650. +
  1650.      *
    1651. +
  1651.      * @param boolean If true, IDs will be added to each line.
    1652. +
  1652.      * @since 1.0.2
    1653. +
  1653.      */
    1654. +
  1654.     function enable_ids($flag = true) {
    1655. +
  1655.         $this->add_ids = ($flag) ? true : false;
    1656. +
  1656.     }
    1657. +
  1657.  
    1658. +
  1658. /**    
    1659. +
  1659.      * Specifies which lines to highlight extra
    1660. +
  1660.      *
    1661. +
  1661.      * The extra style parameter was added in 1.0.7.21.
    1662. +
  1662.      *
    1663. +
  1663.      * @param mixed An array of line numbers to highlight, or just a line
    1664. +
  1664.      *               number on its own.
    1665. +
  1665.      * @param string A string specifying the style to use for this line.
    1666. +
  1666.      *               If null is specified, the default style is used.
    1667. +
  1667.      *               If false is specified, the line will be removed from
    1668. +
  1668.      *               special highlighting
    1669. +
  1669.      * @since 1.0.2
    1670. +
  1670.      * @todo  Some data replication here that could be cut down on
    1671. +
  1671.      */
    1672. +
  1672.     function highlight_lines_extra($lines, $style = null) {
    1673. +
  1673.         if (is_array($lines)) {
    1674. +
  1674.             //Split up the job using single lines at a time
    1675. +
  1675.             foreach ($lines as $line) {
    1676. +
  1676.                 $this->highlight_lines_extra($line, $style);
    1677. +
  1677.             }
    1678. +
  1678.         } else {
    1679. +
  1679.             //Mark the line as being highlighted specially
    1680. +
  1680.             $lines = intval($lines);
    1681. +
  1681.             $this->highlight_extra_lines[$lines] = $lines;
    1682. +
  1682.  
    1683. +
  1683.             //Decide on which style to use
    1684. +
  1684.             if ($style === null) { //Check if we should use default style
    1685. +
  1685.                 unset($this->highlight_extra_lines_styles[$lines]);
    1686. +
  1686.             } else if ($style === false) { //Check if to remove this line
    1687. +
  1687.                 unset($this->highlight_extra_lines[$lines]);
    1688. +
  1688.                 unset($this->highlight_extra_lines_styles[$lines]);
    1689. +
  1689.             } else {
    1690. +
  1690.                 $this->highlight_extra_lines_styles[$lines] = $style;
    1691. +
  1691.             }
    1692. +
  1692.         }
    1693. +
  1693.     }
    1694. +
  1694.  
    1695. +
  1695. /**    
    1696. +
  1696.      * Sets the style for extra-highlighted lines
    1697. +
  1697.      *
    1698. +
  1698.      * @param string The style for extra-highlighted lines
    1699. +
  1699.      * @since 1.0.2
    1700. +
  1700.      */
    1701. +
  1701.     function set_highlight_lines_extra_style($styles) {
    1702. +
  1702.         $this->highlight_extra_lines_style = $styles;
    1703. +
  1703.     }
    1704. +
  1704.  
    1705. +
  1705. /**    
    1706. +
  1706.      * Sets the line-ending
    1707. +
  1707.      *
    1708. +
  1708.      * @param string The new line-ending
    1709. +
  1709.      * @since 1.0.2
    1710. +
  1710.      */
    1711. +
  1711.     function set_line_ending($line_ending) {
    1712. +
  1712.         $this->line_ending = (string)$line_ending;
    1713. +
  1713.     }
    1714. +
  1714.  
    1715. +
  1715. /**    
    1716. +
  1716.      * Sets what number line numbers should start at. Should
    1717. +
  1717.      * be a positive integer, and will be converted to one.
    1718. +
  1718.      *
    1719. +
  1719.      * <b>Warning:</b> Using this method will add the "start"
    1720. +
  1720.      * attribute to the &lt;ol&gt; that is used for line numbering.
    1721. +
  1721.      * This is <b>not</b> valid XHTML strict, so if that's what you
    1722. +
  1722.      * care about then don't use this method. Firefox is getting
    1723. +
  1723.      * support for the CSS method of doing this in 1.1 and Opera
    1724. +
  1724.      * has support for the CSS method, but (of course) IE doesn't
    1725. +
  1725.      * so it's not worth doing it the CSS way yet.
    1726. +
  1726.      *
    1727. +
  1727.      * @param int The number to start line numbers at
    1728. +
  1728.      * @since 1.0.2
    1729. +
  1729.      */
    1730. +
  1730.     function start_line_numbers_at($number) {
    1731. +
  1731.         $this->line_numbers_start = abs(intval($number));
    1732. +
  1732.     }
    1733. +
  1733.  
    1734. +
  1734. /**    
    1735. +
  1735.      * Sets the encoding used for htmlspecialchars(), for international
    1736. +
  1736.      * support.
    1737. +
  1737.      *
    1738. +
  1738.      * NOTE: This is not needed for now because htmlspecialchars() is not
    1739. +
  1739.      * being used (it has a security hole in PHP4 that has not been patched).
    1740. +
  1740.      * Maybe in a future version it may make a return for speed reasons, but
    1741. +
  1741.      * I doubt it.
    1742. +
  1742.      *
    1743. +
  1743.      * @param string The encoding to use for the source
    1744. +
  1744.      * @since 1.0.3
    1745. +
  1745.      */
    1746. +
  1746.     function set_encoding($encoding) {
    1747. +
  1747.         if ($encoding) {
    1748. +
  1748.           $this->encoding = strtolower($encoding);
    1749. +
  1749.         }
    1750. +
  1750.     }
    1751. +
  1751.  
    1752. +
  1752. /**    
    1753. +
  1753.      * Turns linking of keywords on or off.
    1754. +
  1754.      *
    1755. +
  1755.      * @param boolean If true, links will be added to keywords
    1756. +
  1756.      * @since 1.0.2
    1757. +
  1757.      */
    1758. +
  1758.     function enable_keyword_links($enable = true) {
    1759. +
  1759.         $this->keyword_links = (bool) $enable;
    1760. +
  1760.     }
    1761. +
  1761.  
    1762. +
  1762. /**    
    1763. +
  1763.      * Setup caches needed for styling. This is automatically called in
    1764. +
  1764.      * parse_code() and get_stylesheet() when appropriate. This function helps
    1765. +
  1765.      * stylesheet generators as they rely on some style information being
    1766. +
  1766.      * preprocessed
    1767. +
  1767.      *
    1768. +
  1768.      * @since 1.0.8
    1769. +
  1769.      * @access private
    1770. +
  1770.      */
    1771. +
  1771.     function build_style_cache() {
    1772. +
  1772.         //Build the style cache needed to highlight numbers appropriate
    1773. +
  1773.         if($this->lexic_permissions['NUMBERS']) {
    1774. +
  1774.             //First check what way highlighting information for numbers are given
    1775. +
  1775.             if(!isset($this->language_data['NUMBERS'])) {
    1776. +
  1776.                 $this->language_data['NUMBERS'] = 0;
    1777. +
  1777.             }
    1778. +
  1778.  
    1779. +
  1779.             if(is_array($this->language_data['NUMBERS'])) {
    1780. +
  1780.                 $this->language_data['NUMBERS_CACHE'] = $this->language_data['NUMBERS'];
    1781. +
  1781.             } else {
    1782. +
  1782.                 $this->language_data['NUMBERS_CACHE'] = array();
    1783. +
  1783.                 if(!$this->language_data['NUMBERS']) {
    1784. +
  1784.                     $this->language_data['NUMBERS'] =
    1785. +
  1785.                         GESHI_NUMBER_INT_BASIC |
    1786. +
  1786.                         GESHI_NUMBER_FLT_NONSCI;
    1787. +
  1787.                 }
    1788. +
  1788.  
    1789. +
  1789.                 for($i = 0, $j = $this->language_data['NUMBERS']; $j > 0; ++$i, $j>>=1) {
    1790. +
  1790.                     //Rearrange style indices if required ...
    1791. +
  1791.                     if(isset($this->language_data['STYLES']['NUMBERS'][1<<$i])) {
    1792. +
  1792.                         $this->language_data['STYLES']['NUMBERS'][$i] =
    1793. +
  1793.                             $this->language_data['STYLES']['NUMBERS'][1<<$i];
    1794. +
  1794.                         unset($this->language_data['STYLES']['NUMBERS'][1<<$i]);
    1795. +
  1795.                     }
    1796. +
  1796.  
    1797. +
  1797.                     //Check if this bit is set for highlighting
    1798. +
  1798.                     if($j&1) {
    1799. +
  1799.                         //So this bit is set ...
    1800. +
  1800.                         //Check if it belongs to group 0 or the actual stylegroup
    1801. +
  1801.                         if(isset($this->language_data['STYLES']['NUMBERS'][$i])) {
    1802. +
  1802.                             $this->language_data['NUMBERS_CACHE'][$i] = 1 << $i;
    1803. +
  1803.                         } else {
    1804. +
  1804.                             if(!isset($this->language_data['NUMBERS_CACHE'][0])) {
    1805. +
  1805.                                 $this->language_data['NUMBERS_CACHE'][0] = 0;
    1806. +
  1806.                             }
    1807. +
  1807.                             $this->language_data['NUMBERS_CACHE'][0] |= 1 << $i;
    1808. +
  1808.                         }
    1809. +
  1809.                     }
    1810. +
  1810.                 }
    1811. +
  1811.             }
    1812. +
  1812.         }
    1813. +
  1813.     }
    1814. +
  1814.  
    1815. +
  1815. /**    
    1816. +
  1816.      * Setup caches needed for parsing. This is automatically called in parse_code() when appropriate.
    1817. +
  1817.      * This function makes stylesheet generators much faster as they do not need these caches.
    1818. +
  1818.      *
    1819. +
  1819.      * @since 1.0.8
    1820. +
  1820.      * @access private
    1821. +
  1821.      */
    1822. +
  1822.     function build_parse_cache() {
    1823. +
  1823.         // cache symbol regexp
    1824. +
  1824.         //As this is a costy operation, we avoid doing it for multiple groups ...
    1825. +
  1825.         //Instead we perform it for all symbols at once.
    1826. +
  1826.         //
    1827. +
  1827.         //For this to work, we need to reorganize the data arrays.
    1828. +
  1828.         if ($this->lexic_permissions['SYMBOLS'] && !empty($this->language_data['SYMBOLS'])) {
    1829. +
  1829.             $this->language_data['MULTIPLE_SYMBOL_GROUPS'] = count($this->language_data['STYLES']['SYMBOLS']) > 1;
    1830. +
  1830.  
    1831. +
  1831.             $this->language_data['SYMBOL_DATA'] = array();
    1832. +
  1832.             $symbol_preg_multi = array(); // multi char symbols
    1833. +
  1833.             $symbol_preg_single = array(); // single char symbols
    1834. +
  1834.             foreach ($this->language_data['SYMBOLS'] as $key => $symbols) {
    1835. +
  1835.                 if (is_array($symbols)) {
    1836. +
  1836.                     foreach ($symbols as $sym) {
    1837. +
  1837.                         $sym = $this->hsc($sym);
    1838. +
  1838.                         if (!isset($this->language_data['SYMBOL_DATA'][$sym])) {
    1839. +
  1839.                             $this->language_data['SYMBOL_DATA'][$sym] = $key;
    1840. +
  1840.                             if (isset($sym[1])) { // multiple chars
    1841. +
  1841.                                 $symbol_preg_multi[] = preg_quote($sym, '/');
    1842. +
  1842.                             } else { // single char
    1843. +
  1843.                                 if ($sym == '-') {
    1844. +
  1844.                                     // don't trigger range out of order error
    1845. +
  1845.                                     $symbol_preg_single[] = '\-';
    1846. +
  1846.                                 } else {
    1847. +
  1847.                                     $symbol_preg_single[] = preg_quote($sym, '/');
    1848. +
  1848.                                 }
    1849. +
  1849.                             }
    1850. +
  1850.                         }
    1851. +
  1851.                     }
    1852. +
  1852.                 } else {
    1853. +
  1853.                     $symbols = $this->hsc($symbols);
    1854. +
  1854.                     if (!isset($this->language_data['SYMBOL_DATA'][$symbols])) {
    1855. +
  1855.                         $this->language_data['SYMBOL_DATA'][$symbols] = 0;
    1856. +
  1856.                         if (isset($symbols[1])) { // multiple chars
    1857. +
  1857.                             $symbol_preg_multi[] = preg_quote($symbols, '/');
    1858. +
  1858.                         } else if ($symbols == '-') {
    1859. +
  1859.                             // don't trigger range out of order error
    1860. +
  1860.                             $symbol_preg_single[] = '\-';
    1861. +
  1861.                         } else { // single char
    1862. +
  1862.                             $symbol_preg_single[] = preg_quote($symbols, '/');
    1863. +
  1863.                         }
    1864. +
  1864.                     }
    1865. +
  1865.                 }
    1866. +
  1866.             }
    1867. +
  1867.  
    1868. +
  1868.             //Now we have an array with each possible symbol as the key and the style as the actual data.
    1869. +
  1869.             //This way we can set the correct style just the moment we highlight ...
    1870. +
  1870.             //
    1871. +
  1871.             //Now we need to rewrite our array to get a search string that
    1872. +
  1872.             $symbol_preg = array();
    1873. +
  1873.             if (!empty($symbol_preg_multi)) {
    1874. +
  1874.                 rsort($symbol_preg_multi);
    1875. +
  1875.                 $symbol_preg[] = implode('|', $symbol_preg_multi);
    1876. +
  1876.             }
    1877. +
  1877.             if (!empty($symbol_preg_single)) {
    1878. +
  1878.                 rsort($symbol_preg_single);
    1879. +
  1879.                 $symbol_preg[] = '[' . implode('', $symbol_preg_single) . ']';
    1880. +
  1880.             }
    1881. +
  1881.             $this->language_data['SYMBOL_SEARCH'] = implode("|", $symbol_preg);
    1882. +
  1882.         }
    1883. +
  1883.  
    1884. +
  1884.         // cache optimized regexp for keyword matching
    1885. +
  1885.         // remove old cache
    1886. +
  1886.         $this->language_data['CACHED_KEYWORD_LISTS'] = array();
    1887. +
  1887.         foreach (array_keys($this->language_data['KEYWORDS']) as $key) {
    1888. +
  1888.             if (!isset($this->lexic_permissions['KEYWORDS'][$key]) ||
    1889. +
  1889.                     $this->lexic_permissions['KEYWORDS'][$key]) {
    1890. +
  1890.                 $this->optimize_keyword_group($key);
    1891. +
  1891.             }
    1892. +
  1892.         }
    1893. +
  1893.  
    1894. +
  1894.         // brackets
    1895. +
  1895.         if ($this->lexic_permissions['BRACKETS']) {
    1896. +
  1896.             $this->language_data['CACHE_BRACKET_MATCH'] = array('[', ']', '(', ')', '{', '}');
    1897. +
  1897.             if (!$this->use_classes && isset($this->language_data['STYLES']['BRACKETS'][0])) {
    1898. +
  1898.                 $this->language_data['CACHE_BRACKET_REPLACE'] = array(
    1899. +
  1899.                     '<| style="' . $this->language_data['STYLES']['BRACKETS'][0] . '">&#91;|>',
    1900. +
  1900.                     '<| style="' . $this->language_data['STYLES']['BRACKETS'][0] . '">&#93;|>',
    1901. +
  1901.                     '<| style="' . $this->language_data['STYLES']['BRACKETS'][0] . '">&#40;|>',
    1902. +
  1902.                     '<| style="' . $this->language_data['STYLES']['BRACKETS'][0] . '">&#41;|>',
    1903. +
  1903.                     '<| style="' . $this->language_data['STYLES']['BRACKETS'][0] . '">&#123;|>',
    1904. +
  1904.                     '<| style="' . $this->language_data['STYLES']['BRACKETS'][0] . '">&#125;|>',
    1905. +
  1905.                 );
    1906. +
  1906.             }
    1907. +
  1907.             else {
    1908. +
  1908.                 $this->language_data['CACHE_BRACKET_REPLACE'] = array(
    1909. +
  1909.                     '<| class="br0">&#91;|>',
    1910. +
  1910.                     '<| class="br0">&#93;|>',
    1911. +
  1911.                     '<| class="br0">&#40;|>',
    1912. +
  1912.                     '<| class="br0">&#41;|>',
    1913. +
  1913.                     '<| class="br0">&#123;|>',
    1914. +
  1914.                     '<| class="br0">&#125;|>',
    1915. +
  1915.                 );
    1916. +
  1916.             }
    1917. +
  1917.         }
    1918. +
  1918.  
    1919. +
  1919.         //Build the parse cache needed to highlight numbers appropriate
    1920. +
  1920.         if($this->lexic_permissions['NUMBERS']) {
    1921. +
  1921.             //Check if the style rearrangements have been processed ...
    1922. +
  1922.             //This also does some preprocessing to check which style groups are useable ...
    1923. +
  1923.             if(!isset($this->language_data['NUMBERS_CACHE'])) {
    1924. +
  1924.                 $this->build_style_cache();
    1925. +
  1925.             }
    1926. +
  1926.  
    1927. +
  1927.             //Number format specification
    1928. +
  1928.             //All this formats are matched case-insensitively!
    1929. +
  1929.             static $numbers_format = array(
    1930. +
  1930.                 GESHI_NUMBER_INT_BASIC =>
    1931. +
  1931.                     '(?<![0-9a-z_\.%])(?<![\d\.]e[+\-])([1-9]\d*?|0)(?![0-9a-z\.])',
    1932. +
  1932.                 GESHI_NUMBER_INT_CSTYLE =>
    1933. +
  1933.                     '(?<![0-9a-z_\.%])(?<![\d\.]e[+\-])([1-9]\d*?|0)l(?![0-9a-z\.])',
    1934. +
  1934.                 GESHI_NUMBER_BIN_SUFFIX =>
    1935. +
  1935.                     '(?<![0-9a-z_\.])(?<![\d\.]e[+\-])[01]+?b(?![0-9a-z\.])',
    1936. +
  1936.                 GESHI_NUMBER_BIN_PREFIX_PERCENT =>
    1937. +
  1937.                     '(?<![0-9a-z_\.%])(?<![\d\.]e[+\-])%[01]+?(?![0-9a-z\.])',
    1938. +
  1938.                 GESHI_NUMBER_BIN_PREFIX_0B =>
    1939. +
  1939.                     '(?<![0-9a-z_\.%])(?<![\d\.]e[+\-])0b[01]+?(?![0-9a-z\.])',
    1940. +
  1940.                 GESHI_NUMBER_OCT_PREFIX =>
    1941. +
  1941.                     '(?<![0-9a-z_\.])(?<![\d\.]e[+\-])0[0-7]+?(?![0-9a-z\.])',
    1942. +
  1942.                 GESHI_NUMBER_OCT_SUFFIX =>
    1943. +
  1943.                     '(?<![0-9a-z_\.])(?<![\d\.]e[+\-])[0-7]+?o(?![0-9a-z\.])',
    1944. +
  1944.                 GESHI_NUMBER_HEX_PREFIX =>
    1945. +
  1945.                     '(?<![0-9a-z_\.])(?<![\d\.]e[+\-])0x[0-9a-f]+?(?![0-9a-z\.])',
    1946. +
  1946.                 GESHI_NUMBER_HEX_SUFFIX =>
    1947. +
  1947.                     '(?<![0-9a-z_\.])(?<![\d\.]e[+\-])\d[0-9a-f]*?h(?![0-9a-z\.])',
    1948. +
  1948.                 GESHI_NUMBER_FLT_NONSCI =>
    1949. +
  1949.                     '(?<![0-9a-z_\.])(?<![\d\.]e[+\-])\d+?\.\d+?(?![0-9a-z\.])',
    1950. +
  1950.                 GESHI_NUMBER_FLT_NONSCI_F =>
    1951. +
  1951.                     '(?<![0-9a-z_\.])(?<![\d\.]e[+\-])(?:\d+?(?:\.\d*?)?|\.\d+?)f(?![0-9a-z\.])',
    1952. +
  1952.                 GESHI_NUMBER_FLT_SCI_SHORT =>
    1953. +
  1953.                     '(?<![0-9a-z_\.])(?<![\d\.]e[+\-])\.\d+?(?:e[+\-]?\d+?)?(?![0-9a-z\.])',
    1954. +
  1954.                 GESHI_NUMBER_FLT_SCI_ZERO =>
    1955. +
  1955.                     '(?<![0-9a-z_\.])(?<![\d\.]e[+\-])(?:\d+?(?:\.\d*?)?|\.\d+?)(?:e[+\-]?\d+?)?(?![0-9a-z\.])'
    1956. +
  1956.                 );
    1957. +
  1957.  
    1958. +
  1958.             //At this step we have an associative array with flag groups for a
    1959. +
  1959.             //specific style or an string denoting a regexp given its index.
    1960. +
  1960.             $this->language_data['NUMBERS_RXCACHE'] = array();
    1961. +
  1961.             foreach($this->language_data['NUMBERS_CACHE'] as $key => $rxdata) {
    1962. +
  1962.                 if(is_string($rxdata)) {
    1963. +
  1963.                     $regexp = $rxdata;
    1964. +
  1964.                 } else {
    1965. +
  1965.                     //This is a bitfield of number flags to highlight:
    1966. +
  1966.                     //Build an array, implode them together and make this the actual RX
    1967. +
  1967.                     $rxuse = array();
    1968. +
  1968.                     for($i = 1; $i <= $rxdata; $i<<=1) {
    1969. +
  1969.                         if($rxdata & $i) {
    1970. +
  1970.                             $rxuse[] = $numbers_format[$i];
    1971. +
  1971.                         }
    1972. +
  1972.                     }
    1973. +
  1973.                     $regexp = implode("|", $rxuse);
    1974. +
  1974.                 }
    1975. +
  1975.  
    1976. +
  1976.                 $this->language_data['NUMBERS_RXCACHE'][$key] =
    1977. +
  1977.                     "/(?<!<\|\/NUM!)(?<!\d\/>)($regexp)(?!\|>)/i";
    1978. +
  1978.             }
    1979. +
  1979.         }
    1980. +
  1980.  
    1981. +
  1981.         $this->parse_cache_built = true;
    1982. +
  1982.     }
    1983. +
  1983.  
    1984. +
  1984.     /**
    1985. +
  1985.      * Returns the code in $this->source, highlighted and surrounded by the
    1986. +
  1986.      * nessecary HTML.
    1987. +
  1987.      *
    1988. +
  1988.      * This should only be called ONCE, cos it's SLOW! If you want to highlight
    1989. +
  1989.      * the same source multiple times, you're better off doing a whole lot of
    1990. +
  1990.      * str_replaces to replace the &lt;span&gt;s
    1991. +
  1991.      *
    1992. +
  1992.      * @since 1.0.0
    1993. +
  1993.      */
    1994. +
  1994.     function parse_code () {
    1995. +
  1995.         // Start the timer
    1996. +
  1996.         $start_time = microtime();
    1997. +
  1997.  
    1998. +
  1998.         // Firstly, if there is an error, we won't highlight
    1999. +
  1999.         if ($this->error) {
    2000. +
  2000.             //Escape the source for output
    2001. +
  2001.             $result = $this->hsc($this->source);
    2002. +
  2002.  
    2003. +
  2003.             //This fix is related to SF#1923020, but has to be applied regardless of
    2004. +
  2004.             //actually highlighting symbols.
    2005. +
  2005.             $result = str_replace(array('<SEMI>', '<PIPE>'), array(';', '|'), $result);
    2006. +
  2006.  
    2007. +
  2007.             // Timing is irrelevant
    2008. +
  2008.             $this->set_time($start_time, $start_time);
    2009. +
  2009.             $this->finalise($result);
    2010. +
  2010.             return $result;
    2011. +
  2011.         }
    2012. +
  2012.  
    2013. +
  2013.         // make sure the parse cache is up2date
    2014. +
  2014.         if (!$this->parse_cache_built) {
    2015. +
  2015.             $this->build_parse_cache();
    2016. +
  2016.         }
    2017. +
  2017.  
    2018. +
  2018.         // Replace all newlines to a common form.
    2019. +
  2019.         $code = str_replace("\r\n", "\n", $this->source);
    2020. +
  2020.         $code = str_replace("\r", "\n", $code);
    2021. +
  2021.  
    2022. +
  2022.         // Add spaces for regular expression matching and line numbers
    2023. +
  2023. //        $code = "\n" . $code . "\n";
    2024. +
    2025. +
  2025.         // Initialise various stuff
    2026. +
  2026.         $length           = strlen($code);
    2027. +
  2027.         $COMMENT_MATCHED  = false;
    2028. +
  2028.         $stuff_to_parse   = '';
    2029. +
  2029.         $endresult        = '';
    2030. +
  2030.  
    2031. +
  2031.         // "Important" selections are handled like multiline comments
    2032. +
  2032.         // @todo GET RID OF THIS SHIZ
    2033. +
  2033.         if ($this->enable_important_blocks) {
    2034. +
  2034.             $this->language_data['COMMENT_MULTI'][<a href="../geshi/core/_geshi.php.html#defineGESHI_START_IMPORTANT">GESHI_START_IMPORTANT</a>] = <a href="../geshi/core/_geshi.php.html#defineGESHI_END_IMPORTANT">GESHI_END_IMPORTANT</a>;
    2035. +
  2035.         }
    2036. +
  2036.  
    2037. +
  2037.         if ($this->strict_mode) {
    2038. +
  2038.             // Break the source into bits. Each bit will be a portion of the code
    2039. +
  2039.             // within script delimiters - for example, HTML between < and >
    2040. +
  2040.             $k = 0;
    2041. +
  2041.             $parts = array();
    2042. +
  2042.             $matches = array();
    2043. +
  2043.             $next_match_pointer = null;
    2044. +
  2044.             // we use a copy to unset delimiters on demand (when they are not found)
    2045. +
  2045.             $delim_copy = $this->language_data['SCRIPT_DELIMITERS'];
    2046. +
  2046.             $i = 0;
    2047. +
  2047.             while ($i < $length) {
    2048. +
  2048.                 $next_match_pos = $length + 1; // never true
    2049. +
  2049.                 foreach ($delim_copy as $dk => $delimiters) {
    2050. +
  2050.                     if(is_array($delimiters)) {
    2051. +
  2051.                         foreach ($delimiters as $open => $close) {
    2052. +
  2052.                             // make sure the cache is setup properly
    2053. +
  2053.                             if (!isset($matches[$dk][$open])) {
    2054. +
  2054.                                 $matches[$dk][$open] = array(
    2055. +
  2055.                                     'next_match' => -1,
    2056. +
  2056.                                     'dk' => $dk,
    2057. +
  2057.  
    2058. +
  2058.                                     'open' => $open, // needed for grouping of adjacent code blocks (see below)
    2059. +
  2059.                                     'open_strlen' => strlen($open),
    2060. +
  2060.  
    2061. +
  2061.                                     'close' => $close,
    2062. +
  2062.                                     'close_strlen' => strlen($close),
    2063. +
  2063.                                 );
    2064. +
  2064.                             }
    2065. +
  2065.                             // Get the next little bit for this opening string
    2066. +
  2066.                             if ($matches[$dk][$open]['next_match'] < $i) {
    2067. +
  2067.                                 // only find the next pos if it was not already cached
    2068. +
  2068.                                 $open_pos = strpos($code, $open, $i);
    2069. +
  2069.                                 if ($open_pos === false) {
    2070. +
  2070.                                     // no match for this delimiter ever
    2071. +
  2071.                                     unset($delim_copy[$dk][$open]);
    2072. +
  2072.                                     continue;
    2073. +
  2073.                                 }
    2074. +
  2074.                                 $matches[$dk][$open]['next_match'] = $open_pos;
    2075. +
  2075.                             }
    2076. +
  2076.                             if ($matches[$dk][$open]['next_match'] < $next_match_pos) {
    2077. +
  2077.                                 //So we got a new match, update the close_pos
    2078. +
  2078.                                 $matches[$dk][$open]['close_pos'] =
    2079. +
  2079.                                     strpos($code, $close, $matches[$dk][$open]['next_match']+1);
    2080. +
  2080.  
    2081. +
  2081.                                 $next_match_pointer =& $matches[$dk][$open];
    2082. +
  2082.                                 $next_match_pos = $matches[$dk][$open]['next_match'];
    2083. +
  2083.                             }
    2084. +
  2084.                         }
    2085. +
  2085.                     } else {
    2086. +
  2086.                         //So we should match an RegExp as Strict Block ...
    2087. +
  2087. /**                        
    2088. +
  2088.                          * The value in $delimiters is expected to be an RegExp
    2089. +
  2089.                          * containing exactly 2 matching groups:
    2090. +
  2090.                          *  - Group 1 is the opener
    2091. +
  2091.                          *  - Group 2 is the closer
    2092. +
  2092.                          */
    2093. +
  2093.                         if(!GESHI_PHP_PRE_433 && //Needs proper rewrite to work with PHP >=4.3.0; 4.3.3 is guaranteed to work.
    2094. +
  2094.                             preg_match($delimiters, $code, $matches_rx, PREG_OFFSET_CAPTURE, $i)) {
    2095. +
  2095.                             //We got a match ...
    2096. +
  2096.                             $matches[$dk] = array(
    2097. +
  2097.                                 'next_match' => $matches_rx[1][1],
    2098. +
  2098.                                 'dk' => $dk,
    2099. +
  2099.  
    2100. +
  2100.                                 'close_strlen' => strlen($matches_rx[2][0]),
    2101. +
  2101.                                 'close_pos' => $matches_rx[2][1],
    2102. +
  2102.                                 );
    2103. +
  2103.                         } else {
    2104. +
  2104.                             // no match for this delimiter ever
    2105. +
  2105.                             unset($delim_copy[$dk]);
    2106. +
  2106.                             continue;
    2107. +
  2107.                         }
    2108. +
  2108.  
    2109. +
  2109.                         if ($matches[$dk]['next_match'] <= $next_match_pos) {
    2110. +
  2110.                             $next_match_pointer =& $matches[$dk];
    2111. +
  2111.                             $next_match_pos = $matches[$dk]['next_match'];
    2112. +
  2112.                         }
    2113. +
  2113.                     }
    2114. +
  2114.                 }
    2115. +
  2115.                 // non-highlightable text
    2116. +
  2116.                 $parts[$k] = array(
    2117. +
  2117.                     1 => substr($code, $i, $next_match_pos - $i)
    2118. +
  2118.                 );
    2119. +
  2119.                 ++$k;
    2120. +
  2120.  
    2121. +
  2121.                 if ($next_match_pos > $length) {
    2122. +
  2122.                     // out of bounds means no next match was found
    2123. +
  2123.                     break;
    2124. +
  2124.                 }
    2125. +
  2125.  
    2126. +
  2126.                 // highlightable code
    2127. +
  2127.                 $parts[$k][0] = $next_match_pointer['dk'];
    2128. +
  2128.  
    2129. +
  2129.                 //Only combine for non-rx script blocks
    2130. +
  2130.                 if(is_array($delim_copy[$next_match_pointer['dk']])) {
    2131. +
  2131.                     // group adjacent script blocks, e.g. <foobar><asdf> should be one block, not three!
    2132. +
  2132.                     $i = $next_match_pos + $next_match_pointer['open_strlen'];
    2133. +
  2133.                     while (true) {
    2134. +
  2134.                         $close_pos = strpos($code, $next_match_pointer['close'], $i);
    2135. +
  2135.                         if ($close_pos == false) {
    2136. +
  2136.                             break;
    2137. +
  2137.                         }
    2138. +
  2138.                         $i = $close_pos + $next_match_pointer['close_strlen'];
    2139. +
  2139.                         if ($i == $length) {
    2140. +
  2140.                             break;
    2141. +
  2141.                         }
    2142. +
  2142.                         if ($code[$i] == $next_match_pointer['open'][0] && ($next_match_pointer['open_strlen'] == 1 ||
    2143. +
  2143.                             substr($code, $i, $next_match_pointer['open_strlen']) == $next_match_pointer['open'])) {
    2144. +
  2144.                             // merge adjacent but make sure we don't merge things like <tag><!-- comment -->
    2145. +
  2145.                             foreach ($matches as $submatches) {
    2146. +
  2146.                                 foreach ($submatches as $match) {
    2147. +
  2147.                                     if ($match['next_match'] == $i) {
    2148. +
  2148.                                         // a different block already matches here!
    2149. +
  2149.                                         break 3;
    2150. +
  2150.                                     }
    2151. +
  2151.                                 }
    2152. +
  2152.                             }
    2153. +
  2153.                         } else {
    2154. +
  2154.                             break;
    2155. +
  2155.                         }
    2156. +
  2156.                     }
    2157. +
  2157.                 } else {
    2158. +
  2158.                     $close_pos = $next_match_pointer['close_pos'] + $next_match_pointer['close_strlen'];
    2159. +
  2159.                     $i = $close_pos;
    2160. +
  2160.                 }
    2161. +
  2161.  
    2162. +
  2162.                 if ($close_pos === false) {
    2163. +
  2163.                     // no closing delimiter found!
    2164. +
  2164.                     $parts[$k][1] = substr($code, $next_match_pos);
    2165. +
  2165.                     ++$k;
    2166. +
  2166.                     break;
    2167. +
  2167.                 } else {
    2168. +
  2168.                     $parts[$k][1] = substr($code, $next_match_pos, $i - $next_match_pos);
    2169. +
  2169.                     ++$k;
    2170. +
  2170.                 }
    2171. +
  2171.             }
    2172. +
  2172.             unset($delim_copy, $next_match_pointer, $next_match_pos, $matches);
    2173. +
  2173.             $num_parts = $k;
    2174. +
  2174.  
    2175. +
  2175.             if ($num_parts == 1 && $this->strict_mode == GESHI_MAYBE) {
    2176. +
  2176.                 // when we have only one part, we don't have anything to highlight at all.
    2177. +
  2177.                 // if we have a "maybe" strict language, this should be handled as highlightable code
    2178. +
  2178.                 $parts = array(
    2179. +
  2179.                     0 => array(
    2180. +
  2180.                         0 => '',
    2181. +
  2181.                         1 => ''
    2182. +
  2182.                     ),
    2183. +
  2183.                     1 => array(
    2184. +
  2184.                         0 => null,
    2185. +
  2185.                         1 => $parts[0][1]
    2186. +
  2186.                     )
    2187. +
  2187.                 );
    2188. +
  2188.                 $num_parts = 2;
    2189. +
  2189.             }
    2190. +
  2190.  
    2191. +
  2191.         } else {
    2192. +
  2192.             // Not strict mode - simply dump the source into
    2193. +
  2193.             // the array at index 1 (the first highlightable block)
    2194. +
  2194.             $parts = array(
    2195. +
  2195.                 0 => array(
    2196. +
  2196.                     0 => '',
    2197. +
  2197.                     1 => ''
    2198. +
  2198.                 ),
    2199. +
  2199.                 1 => array(
    2200. +
  2200.                     0 => null,
    2201. +
  2201.                     1 => $code
    2202. +
  2202.                 )
    2203. +
  2203.             );
    2204. +
  2204.             $num_parts = 2;
    2205. +
  2205.         }
    2206. +
  2206.  
    2207. +
  2207.         //Unset variables we won't need any longer
    2208. +
  2208.         unset($code);
    2209. +
  2209.  
    2210. +
  2210.         //Preload some repeatedly used values regarding hardquotes ...
    2211. +
  2211.         $hq = isset($this->language_data['HARDQUOTE']) ? $this->language_data['HARDQUOTE'][0] : false;
    2212. +
  2212.         $hq_strlen = strlen($hq);
    2213. +
  2213.  
    2214. +
  2214.         //Preload if line numbers are to be generated afterwards
    2215. +
  2215.         //Added a check if line breaks should be forced even without line numbers, fixes SF#1727398
    2216. +
  2216.         $check_linenumbers = $this->line_numbers != <a href="../geshi/core/_geshi.php.html#defineGESHI_NO_LINE_NUMBERS">GESHI_NO_LINE_NUMBERS</a> ||
    2217. +
  2217.             !empty($this->highlight_extra_lines) || !$this->allow_multiline_span;
    2218. +
  2218.  
    2219. +
  2219.         //preload the escape char for faster checking ...
    2220. +
  2220.         $escaped_escape_char = $this->hsc($this->language_data['ESCAPE_CHAR']);
    2221. +
  2221.  
    2222. +
  2222.         // this is used for single-line comments
    2223. +
  2223.         $sc_disallowed_before = "";
    2224. +
  2224.         $sc_disallowed_after = "";
    2225. +
  2225.  
    2226. +
  2226.         if (isset($this->language_data['PARSER_CONTROL'])) {
    2227. +
  2227.             if (isset($this->language_data['PARSER_CONTROL']['COMMENTS'])) {
    2228. +
  2228.                 if (isset($this->language_data['PARSER_CONTROL']['COMMENTS']['DISALLOWED_BEFORE'])) {
    2229. +
  2229.                     $sc_disallowed_before = $this->language_data['PARSER_CONTROL']['COMMENTS']['DISALLOWED_BEFORE'];
    2230. +
  2230.                 }
    2231. +
  2231.                 if (isset($this->language_data['PARSER_CONTROL']['COMMENTS']['DISALLOWED_AFTER'])) {
    2232. +
  2232.                     $sc_disallowed_after = $this->language_data['PARSER_CONTROL']['COMMENTS']['DISALLOWED_AFTER'];
    2233. +
  2233.                 }
    2234. +
  2234.             }
    2235. +
  2235.         }
    2236. +
  2236.  
    2237. +
  2237.         //Fix for SF#1932083: Multichar Quotemarks unsupported
    2238. +
  2238.         $is_string_starter = array();
    2239. +
  2239.         if ($this->lexic_permissions['STRINGS']) {
    2240. +
  2240.             foreach ($this->language_data['QUOTEMARKS'] as $quotemark) {
    2241. +
  2241.                 if (!isset($is_string_starter[$quotemark[0]])) {
    2242. +
  2242.                     $is_string_starter[$quotemark[0]] = (string)$quotemark;
    2243. +
  2243.                 } else if (is_string($is_string_starter[$quotemark[0]])) {
    2244. +
  2244.                     $is_string_starter[$quotemark[0]] = array(
    2245. +
  2245.                         $is_string_starter[$quotemark[0]],
    2246. +
  2246.                         $quotemark);
    2247. +
  2247.                 } else {
    2248. +
  2248.                     $is_string_starter[$quotemark[0]][] = $quotemark;
    2249. +
  2249.                 }
    2250. +
  2250.             }
    2251. +
  2251.         }
    2252. +
  2252.  
    2253. +
  2253.         // Now we go through each part. We know that even-indexed parts are
    2254. +
  2254.         // code that shouldn't be highlighted, and odd-indexed parts should
    2255. +
  2255.         // be highlighted
    2256. +
  2256.         for ($key = 0; $key < $num_parts; ++$key) {
    2257. +
  2257.             $STRICTATTRS = '';
    2258. +
  2258.  
    2259. +
  2259.             // If this block should be highlighted...
    2260. +
  2260.             if (!($key & 1)) {
    2261. +
  2261.                 // Else not a block to highlight
    2262. +
  2262.                 $endresult .= $this->hsc($parts[$key][1]);
    2263. +
  2263.                 unset($parts[$key]);
    2264. +
  2264.                 continue;
    2265. +
  2265.             }
    2266. +
  2266.  
    2267. +
  2267.             $result = '';
    2268. +
  2268.             $part = $parts[$key][1];
    2269. +
  2269.  
    2270. +
  2270.             $highlight_part = true;
    2271. +
  2271.             if ($this->strict_mode && !is_null($parts[$key][0])) {
    2272. +
  2272.                 // get the class key for this block of code
    2273. +
  2273.                 $script_key = $parts[$key][0];
    2274. +
  2274.                 $highlight_part = $this->language_data['HIGHLIGHT_STRICT_BLOCK'][$script_key];
    2275. +
  2275.                 if ($this->language_data['STYLES']['SCRIPT'][$script_key] != '' &&
    2276. +
  2276.                     $this->lexic_permissions['SCRIPT']) {
    2277. +
  2277.                     // Add a span element around the source to
    2278. +
  2278.                     // highlight the overall source block
    2279. +
  2279.                     if (!$this->use_classes &&
    2280. +
  2280.                         $this->language_data['STYLES']['SCRIPT'][$script_key] != '') {
    2281. +
  2281.                         $attributes = ' style="' . $this->language_data['STYLES']['SCRIPT'][$script_key] . '"';
    2282. +
  2282.                     } else {
    2283. +
  2283.                         $attributes = ' class="sc' . $script_key . '"';
    2284. +
  2284.                     }
    2285. +
  2285.                     $result .= "<span$attributes>";
    2286. +
  2286.                     $STRICTATTRS = $attributes;
    2287. +
  2287.                 }
    2288. +
  2288.             }
    2289. +
  2289.  
    2290. +
  2290.             if ($highlight_part) {
    2291. +
  2291.                 // Now, highlight the code in this block. This code
    2292. +
  2292.                 // is really the engine of GeSHi (along with the method
    2293. +
  2293.                 // parse_non_string_part).
    2294. +
    2295. +
  2295.                 // cache comment regexps incrementally
    2296. +
  2296.                 $next_comment_regexp_key = '';
    2297. +
  2297.                 $next_comment_regexp_pos = -1;
    2298. +
  2298.                 $next_comment_multi_pos = -1;
    2299. +
  2299.                 $next_comment_single_pos = -1;
    2300. +
  2300.                 $comment_regexp_cache_per_key = array();
    2301. +
  2301.                 $comment_multi_cache_per_key = array();
    2302. +
  2302.                 $comment_single_cache_per_key = array();
    2303. +
  2303.                 $next_open_comment_multi = '';
    2304. +
  2304.                 $next_comment_single_key = '';
    2305. +
  2305.                 $escape_regexp_cache_per_key = array();
    2306. +
  2306.                 $next_escape_regexp_key = '';
    2307. +
  2307.                 $next_escape_regexp_pos = -1;
    2308. +
  2308.  
    2309. +
  2309.                 $length = strlen($part);
    2310. +
  2310.                 for ($i = 0; $i < $length; ++$i) {
    2311. +
  2311.                     // Get the next char
    2312. +
  2312.                     $char = $part[$i];
    2313. +
  2313.                     $char_len = 1;
    2314. +
  2314.  
    2315. +
  2315.                     // update regexp comment cache if needed
    2316. +
  2316.                     if (isset($this->language_data['COMMENT_REGEXP']) && $next_comment_regexp_pos < $i) {
    2317. +
  2317.                         $next_comment_regexp_pos = $length;
    2318. +
  2318.                         foreach ($this->language_data['COMMENT_REGEXP'] as $comment_key => $regexp) {
    2319. +
  2319.                             $match_i = false;
    2320. +
  2320.                             if (isset($comment_regexp_cache_per_key[$comment_key]) &&
    2321. +
  2321.                                 ($comment_regexp_cache_per_key[$comment_key]['pos'] >= $i ||
    2322. +
  2322.                                  $comment_regexp_cache_per_key[$comment_key]['pos'] === false)) {
    2323. +
  2323.                                 // we have already matched something
    2324. +
  2324.                                 if ($comment_regexp_cache_per_key[$comment_key]['pos'] === false) {
    2325. +
  2325.                                     // this comment is never matched
    2326. +
  2326.                                     continue;
    2327. +
  2327.                                 }
    2328. +
  2328.                                 $match_i = $comment_regexp_cache_per_key[$comment_key]['pos'];
    2329. +
  2329.                             } else if (
    2330. +
  2330.                                 //This is to allow use of the offset parameter in preg_match and stay as compatible with older PHP versions as possible
    2331. +
  2331.                                 (GESHI_PHP_PRE_433 && preg_match($regexp, substr($part, $i), $match, PREG_OFFSET_CAPTURE)) ||
    2332. +
  2332.                                 (!GESHI_PHP_PRE_433 && preg_match($regexp, $part, $match, PREG_OFFSET_CAPTURE, $i))
    2333. +
  2333.                                 ) {
    2334. +
  2334.                                 $match_i = $match[0][1];
    2335. +
  2335.                                 if (GESHI_PHP_PRE_433) {
    2336. +
  2336.                                     $match_i += $i;
    2337. +
  2337.                                 }
    2338. +
  2338.  
    2339. +
  2339.                                 $comment_regexp_cache_per_key[$comment_key] = array(
    2340. +
  2340.                                     'key' => $comment_key,
    2341. +
  2341.                                     'length' => strlen($match[0][0]),
    2342. +
  2342.                                     'pos' => $match_i
    2343. +
  2343.                                 );
    2344. +
  2344.                             } else {
    2345. +
  2345.                                 $comment_regexp_cache_per_key[$comment_key]['pos'] = false;
    2346. +
  2346.                                 continue;
    2347. +
  2347.                             }
    2348. +
  2348.  
    2349. +
  2349.                             if ($match_i !== false && $match_i < $next_comment_regexp_pos) {
    2350. +
  2350.                                 $next_comment_regexp_pos = $match_i;
    2351. +
  2351.                                 $next_comment_regexp_key = $comment_key;
    2352. +
  2352.                                 if ($match_i === $i) {
    2353. +
  2353.                                     break;
    2354. +
  2354.                                 }
    2355. +
  2355.                             }
    2356. +
  2356.                         }
    2357. +
  2357.                     }
    2358. +
  2358.  
    2359. +
  2359.                     $string_started = false;
    2360. +
  2360.  
    2361. +
  2361.                     if (isset($is_string_starter[$char])) {
    2362. +
  2362.                         // Possibly the start of a new string ...
    2363. +
    2364. +
  2364.                         //Check which starter it was ...
    2365. +
  2365.                         //Fix for SF#1932083: Multichar Quotemarks unsupported
    2366. +
  2366.                         if (is_array($is_string_starter[$char])) {
    2367. +
  2367.                             $char_new = '';
    2368. +
  2368.                             foreach ($is_string_starter[$char] as $testchar) {
    2369. +
  2369.                                 if ($testchar === substr($part, $i, strlen($testchar)) &&
    2370. +
  2370.                                     strlen($testchar) > strlen($char_new)) {
    2371. +
  2371.                                     $char_new = $testchar;
    2372. +
  2372.                                     $string_started = true;
    2373. +
  2373.                                 }
    2374. +
  2374.                             }
    2375. +
  2375.                             if ($string_started) {
    2376. +
  2376.                                 $char = $char_new;
    2377. +
  2377.                             }
    2378. +
  2378.                         } else {
    2379. +
  2379.                             $testchar = $is_string_starter[$char];
    2380. +
  2380.                             if ($testchar === substr($part, $i, strlen($testchar))) {
    2381. +
  2381.                                 $char = $testchar;
    2382. +
  2382.                                 $string_started = true;
    2383. +
  2383.                             }
    2384. +
  2384.                         }
    2385. +
  2385.                         $char_len = strlen($char);
    2386. +
  2386.                     }
    2387. +
  2387.  
    2388. +
  2388.                     if ($string_started && $i != $next_comment_regexp_pos) {
    2389. +
  2389.                         // Hand out the correct style information for this string
    2390. +
  2390.                         $string_key = array_search($char, $this->language_data['QUOTEMARKS']);
    2391. +
  2391.                         if (!isset($this->language_data['STYLES']['STRINGS'][$string_key]) ||
    2392. +
  2392.                             !isset($this->language_data['STYLES']['ESCAPE_CHAR'][$string_key])) {
    2393. +
  2393.                             $string_key = 0;
    2394. +
  2394.                         }
    2395. +
  2395.  
    2396. +
  2396.                         // parse the stuff before this
    2397. +
  2397.                         $result .= $this->parse_non_string_part($stuff_to_parse);
    2398. +
  2398.                         $stuff_to_parse = '';
    2399. +
  2399.  
    2400. +
  2400.                         if (!$this->use_classes) {
    2401. +
  2401.                             $string_attributes = ' style="' . $this->language_data['STYLES']['STRINGS'][$string_key] . '"';
    2402. +
  2402.                         } else {
    2403. +
  2403.                             $string_attributes = ' class="st'.$string_key.'"';
    2404. +
  2404.                         }
    2405. +
  2405.  
    2406. +
  2406.                         // now handle the string
    2407. +
  2407.                         $string = "<span$string_attributes>" . GeSHi::hsc($char);
    2408. +
  2408.                         $start = $i + $char_len;
    2409. +
  2409.                         $string_open = true;
    2410. +
  2410.  
    2411. +
  2411.                         if(empty($this->language_data['ESCAPE_REGEXP'])) {
    2412. +
  2412.                             $next_escape_regexp_pos = $length;
    2413. +
  2413.                         }
    2414. +
  2414.  
    2415. +
  2415.                         do {
    2416. +
  2416.                             //Get the regular ending pos ...
    2417. +
  2417.                             $close_pos = strpos($part, $char, $start);
    2418. +
  2418.                             if(false === $close_pos) {
    2419. +
  2419.                                 $close_pos = $length;
    2420. +
  2420.                             }
    2421. +
  2421.  
    2422. +
  2422.                             if($this->lexic_permissions['ESCAPE_CHAR']) {
    2423. +
  2423.                                 // update escape regexp cache if needed
    2424. +
  2424.                                 if (isset($this->language_data['ESCAPE_REGEXP']) && $next_escape_regexp_pos < $start) {
    2425. +
  2425.                                     $next_escape_regexp_pos = $length;
    2426. +
  2426.                                     foreach ($this->language_data['ESCAPE_REGEXP'] as $escape_key => $regexp) {
    2427. +
  2427.                                         $match_i = false;
    2428. +
  2428.                                         if (isset($escape_regexp_cache_per_key[$escape_key]) &&
    2429. +
  2429.                                             ($escape_regexp_cache_per_key[$escape_key]['pos'] >= $start ||
    2430. +
  2430.                                              $escape_regexp_cache_per_key[$escape_key]['pos'] === false)) {
    2431. +
  2431.                                             // we have already matched something
    2432. +
  2432.                                             if ($escape_regexp_cache_per_key[$escape_key]['pos'] === false) {
    2433. +
  2433.                                                 // this comment is never matched
    2434. +
  2434.                                                 continue;
    2435. +
  2435.                                             }
    2436. +
  2436.                                             $match_i = $escape_regexp_cache_per_key[$escape_key]['pos'];
    2437. +
  2437.                                         } else if (
    2438. +
  2438.                                             //This is to allow use of the offset parameter in preg_match and stay as compatible with older PHP versions as possible
    2439. +
  2439.                                             (GESHI_PHP_PRE_433 && preg_match($regexp, substr($part, $start), $match, PREG_OFFSET_CAPTURE)) ||
    2440. +
  2440.                                             (!GESHI_PHP_PRE_433 && preg_match($regexp, $part, $match, PREG_OFFSET_CAPTURE, $start))
    2441. +
  2441.                                             ) {
    2442. +
  2442.                                             $match_i = $match[0][1];
    2443. +
  2443.                                             if (GESHI_PHP_PRE_433) {
    2444. +
  2444.                                                 $match_i += $start;
    2445. +
  2445.                                             }
    2446. +
  2446.  
    2447. +
  2447.                                             $escape_regexp_cache_per_key[$escape_key] = array(
    2448. +
  2448.                                                 'key' => $escape_key,
    2449. +
  2449.                                                 'length' => strlen($match[0][0]),
    2450. +
  2450.                                                 'pos' => $match_i
    2451. +
  2451.                                             );
    2452. +
  2452.                                         } else {
    2453. +
  2453.                                             $escape_regexp_cache_per_key[$escape_key]['pos'] = false;
    2454. +
  2454.                                             continue;
    2455. +
  2455.                                         }
    2456. +
  2456.  
    2457. +
  2457.                                         if ($match_i !== false && $match_i < $next_escape_regexp_pos) {
    2458. +
  2458.                                             $next_escape_regexp_pos = $match_i;
    2459. +
  2459.                                             $next_escape_regexp_key = $escape_key;
    2460. +
  2460.                                             if ($match_i === $start) {
    2461. +
  2461.                                                 break;
    2462. +
  2462.                                             }
    2463. +
  2463.                                         }
    2464. +
  2464.                                     }
    2465. +
  2465.                                 }
    2466. +
  2466.  
    2467. +
  2467.                                 //Find the next simple escape position
    2468. +
  2468.                                 if('' != $this->language_data['ESCAPE_CHAR']) {
    2469. +
  2469.                                     $simple_escape = strpos($part, $this->language_data['ESCAPE_CHAR'], $start);
    2470. +
  2470.                                     if(false === $simple_escape) {
    2471. +
  2471.                                         $simple_escape = $length;
    2472. +
  2472.                                     }
    2473. +
  2473.                                 } else {
    2474. +
  2474.                                     $simple_escape = $length;
    2475. +
  2475.                                 }
    2476. +
  2476.                             } else {
    2477. +
  2477.                                 $next_escape_regexp_pos = $length;
    2478. +
  2478.                                 $simple_escape = $length;
    2479. +
  2479.                             }
    2480. +
  2480.  
    2481. +
  2481.                             if($simple_escape < $next_escape_regexp_pos &&
    2482. +
  2482.                                 $simple_escape < $length &&
    2483. +
  2483.                                 $simple_escape < $close_pos) {
    2484. +
  2484.                                 //The nexxt escape sequence is a simple one ...
    2485. +
  2485.                                 $es_pos = $simple_escape;
    2486. +
  2486.  
    2487. +
  2487.                                 //Add the stuff not in the string yet ...
    2488. +
  2488.                                 $string .= $this->hsc(substr($part, $start, $es_pos - $start));
    2489. +
  2489.  
    2490. +
  2490.                                 //Get the style for this escaped char ...
    2491. +
  2491.                                 if (!$this->use_classes) {
    2492. +
  2492.                                     $escape_char_attributes = ' style="' . $this->language_data['STYLES']['ESCAPE_CHAR'][0] . '"';
    2493. +
  2493.                                 } else {
    2494. +
  2494.                                     $escape_char_attributes = ' class="es0"';
    2495. +
  2495.                                 }
    2496. +
  2496.  
    2497. +
  2497.                                 //Add the style for the escape char ...
    2498. +
  2498.                                 $string .= "<span$escape_char_attributes>" .
    2499. +
  2499.                                     GeSHi::hsc($this->language_data['ESCAPE_CHAR']);
    2500. +
  2500.  
    2501. +
  2501.                                 //Get the byte AFTER the ESCAPE_CHAR we just found
    2502. +
  2502.                                 $es_char = $part[$es_pos + 1];
    2503. +
  2503.                                 if ($es_char == "\n") {
    2504. +
  2504.                                     // don't put a newline around newlines
    2505. +
  2505.                                     $string .= "</span>\n";
    2506. +
  2506.                                     $start = $es_pos + 2;
    2507. +
  2507.                                 } else if (ord($es_char) >= 128) {
    2508. +
  2508.                                     //This is an non-ASCII char (UTF8 or single byte)
    2509. +
  2509.                                     //This code tries to work around SF#2037598 ...
    2510. +
  2510.                                     if(function_exists('mb_substr')) {
    2511. +
  2511.                                         $es_char_m = mb_substr(substr($part, $es_pos+1, 16), 0, 1, $this->encoding);
    2512. +
  2512.                                         $string .= $es_char_m . '</span>';
    2513. +
  2513.                                     } else if (!GESHI_PHP_PRE_433 && 'utf-8' == $this->encoding) {
    2514. +
  2514.                                         if(preg_match("/[\xC2-\xDF][\x80-\xBF]".
    2515. +
  2515.                                             "|\xE0[\xA0-\xBF][\x80-\xBF]".
    2516. +
  2516.                                             "|[\xE1-\xEC\xEE\xEF][\x80-\xBF]{2}".
    2517. +
  2517.                                             "|\xED[\x80-\x9F][\x80-\xBF]".
    2518. +
  2518.                                             "|\xF0[\x90-\xBF][\x80-\xBF]{2}".
    2519. +
  2519.                                             "|[\xF1-\xF3][\x80-\xBF]{3}".
    2520. +
  2520.                                             "|\xF4[\x80-\x8F][\x80-\xBF]{2}/s",
    2521. +
  2521.                                             $part, $es_char_m, null, $es_pos + 1)) {
    2522. +
  2522.                                             $es_char_m = $es_char_m[0];
    2523. +
  2523.                                         } else {
    2524. +
  2524.                                             $es_char_m = $es_char;
    2525. +
  2525.                                         }
    2526. +
  2526.                                         $string .= $this->hsc($es_char_m) . '</span>';
    2527. +
  2527.                                     } else {
    2528. +
  2528.                                         $es_char_m = $this->hsc($es_char);
    2529. +
  2529.                                     }
    2530. +
  2530.                                     $start = $es_pos + strlen($es_char_m) + 1;
    2531. +
  2531.                                 } else {
    2532. +
  2532.                                     $string .= $this->hsc($es_char) . '</span>';
    2533. +
  2533.                                     $start = $es_pos + 2;
    2534. +
  2534.                                 }
    2535. +
  2535.                             } else if ($next_escape_regexp_pos < $length &&
    2536. +
  2536.                                 $next_escape_regexp_pos < $close_pos) {
    2537. +
  2537.                                 $es_pos = $next_escape_regexp_pos;
    2538. +
  2538.                                 //Add the stuff not in the string yet ...
    2539. +
  2539.                                 $string .= $this->hsc(substr($part, $start, $es_pos - $start));
    2540. +
  2540.  
    2541. +
  2541.                                 //Get the key and length of this match ...
    2542. +
  2542.                                 $escape = $escape_regexp_cache_per_key[$next_escape_regexp_key];
    2543. +
  2543.                                 $escape_str = substr($part, $es_pos, $escape['length']);
    2544. +
  2544.                                 $escape_key = $escape['key'];
    2545. +
  2545.  
    2546. +
  2546.                                 //Get the style for this escaped char ...
    2547. +
  2547.                                 if (!$this->use_classes) {
    2548. +
  2548.                                     $escape_char_attributes = ' style="' . $this->language_data['STYLES']['ESCAPE_CHAR'][$escape_key] . '"';
    2549. +
  2549.                                 } else {
    2550. +
  2550.                                     $escape_char_attributes = ' class="es' . $escape_key . '"';
    2551. +
  2551.                                 }
    2552. +
  2552.  
    2553. +
  2553.                                 //Add the style for the escape char ...
    2554. +
  2554.                                 $string .= "<span$escape_char_attributes>" .
    2555. +
  2555.                                     $this->hsc($escape_str) . '</span>';
    2556. +
  2556.  
    2557. +
  2557.                                 $start = $es_pos + $escape['length'];
    2558. +
  2558.                             } else {
    2559. +
  2559.                                 //Copy the remainder of the string ...
    2560. +
  2560.                                 $string .= $this->hsc(substr($part, $start, $close_pos - $start + $char_len)) . '</span>';
    2561. +
  2561.                                 $start = $close_pos + $char_len;
    2562. +
  2562.                                 $string_open = false;
    2563. +
  2563.                             }
    2564. +
  2564.                         } while($string_open);
    2565. +
  2565.  
    2566. +
  2566.                         if ($check_linenumbers) {
    2567. +
  2567.                             // Are line numbers used? If, we should end the string before
    2568. +
  2568.                             // the newline and begin it again (so when <li>s are put in the source
    2569. +
  2569.                             // remains XHTML compliant)
    2570. +
  2570.                             // note to self: This opens up possibility of config files specifying
    2571. +
  2571.                             // that languages can/cannot have multiline strings???
    2572. +
  2572.                             $string = str_replace("\n", "</span>\n<span$string_attributes>", $string);
    2573. +
  2573.                         }
    2574. +
  2574.  
    2575. +
  2575.                         $result .= $string;
    2576. +
  2576.                         $string = '';
    2577. +
  2577.                         $i = $start - 1;
    2578. +
  2578.                         continue;
    2579. +
  2579.                     } else if ($this->lexic_permissions['STRINGS'] && $hq && $hq[0] == $char &&
    2580. +
  2580.                         substr($part, $i, $hq_strlen) == $hq) {
    2581. +
  2581.                         // The start of a hard quoted string
    2582. +
  2582.                         if (!$this->use_classes) {
    2583. +
  2583.                             $string_attributes = ' style="' . $this->language_data['STYLES']['STRINGS']['HARD'] . '"';
    2584. +
  2584.                             $escape_char_attributes = ' style="' . $this->language_data['STYLES']['ESCAPE_CHAR']['HARD'] . '"';
    2585. +
  2585.                         } else {
    2586. +
  2586.                             $string_attributes = ' class="st_h"';
    2587. +
  2587.                             $escape_char_attributes = ' class="es_h"';
    2588. +
  2588.                         }
    2589. +
  2589.                         // parse the stuff before this
    2590. +
  2590.                         $result .= $this->parse_non_string_part($stuff_to_parse);
    2591. +
  2591.                         $stuff_to_parse = '';
    2592. +
  2592.  
    2593. +
  2593.                         // now handle the string
    2594. +
  2594.                         $string = '';
    2595. +
  2595.  
    2596. +
  2596.                         // look for closing quote
    2597. +
  2597.                         $start = $i + $hq_strlen;
    2598. +
  2598.                         while ($close_pos = strpos($part, $this->language_data['HARDQUOTE'][1], $start)) {
    2599. +
  2599.                             $start = $close_pos + 1;
    2600. +
  2600.                             if ($this->lexic_permissions['ESCAPE_CHAR'] && $part[$close_pos - 1] == $this->language_data['ESCAPE_CHAR']) {
    2601. +
  2601.                                 // make sure this quote is not escaped
    2602. +
  2602.                                 foreach ($this->language_data['HARDESCAPE'] as $hardescape) {
    2603. +
  2603.                                     if (substr($part, $close_pos - 1, strlen($hardescape)) == $hardescape) {
    2604. +
  2604.                                         // check wether this quote is escaped or if it is something like '\\'
    2605. +
  2605.                                         $escape_char_pos = $close_pos - 1;
    2606. +
  2606.                                         while ($escape_char_pos > 0
    2607. +
  2607.                                                 && $part[$escape_char_pos - 1] == $this->language_data['ESCAPE_CHAR']) {
    2608. +
  2608.                                             --$escape_char_pos;
    2609. +
  2609.                                         }
    2610. +
  2610.                                         if (($close_pos - $escape_char_pos) & 1) {
    2611. +
  2611.                                             // uneven number of escape chars => this quote is escaped
    2612. +
  2612.                                             continue 2;
    2613. +
  2613.                                         }
    2614. +
  2614.                                     }
    2615. +
  2615.                                 }
    2616. +
  2616.                             }
    2617. +
  2617.  
    2618. +
  2618.                             // found closing quote
    2619. +
  2619.                             break;
    2620. +
  2620.                         }
    2621. +
  2621.  
    2622. +
  2622.                         //Found the closing delimiter?
    2623. +
  2623.                         if (!$close_pos) {
    2624. +
  2624.                             // span till the end of this $part when no closing delimiter is found
    2625. +
  2625.                             $close_pos = $length;
    2626. +
  2626.                         }
    2627. +
  2627.  
    2628. +
  2628.                         //Get the actual string
    2629. +
  2629.                         $string = substr($part, $i, $close_pos - $i + 1);
    2630. +
  2630.                         $i = $close_pos;
    2631. +
  2631.  
    2632. +
  2632.                         // handle escape chars and encode html chars
    2633. +
  2633.                         // (special because when we have escape chars within our string they may not be escaped)
    2634. +
  2634.                         if ($this->lexic_permissions['ESCAPE_CHAR'] && $this->language_data['ESCAPE_CHAR']) {
    2635. +
  2635.                             $start = 0;
    2636. +
  2636.                             $new_string = '';
    2637. +
  2637.                             while ($es_pos = strpos($string, $this->language_data['ESCAPE_CHAR'], $start)) {
    2638. +
  2638.                                 // hmtl escape stuff before
    2639. +
  2639.                                 $new_string .= $this->hsc(substr($string, $start, $es_pos - $start));
    2640. +
  2640.                                 // check if this is a hard escape
    2641. +
  2641.                                 foreach ($this->language_data['HARDESCAPE'] as $hardescape) {
    2642. +
  2642.                                     if (substr($string, $es_pos, strlen($hardescape)) == $hardescape) {
    2643. +
  2643.                                         // indeed, this is a hardescape
    2644. +
  2644.                                         $new_string .= "<span$escape_char_attributes>" .
    2645. +
  2645.                                             $this->hsc($hardescape) . '</span>';
    2646. +
  2646.                                         $start = $es_pos + strlen($hardescape);
    2647. +
  2647.                                         continue 2;
    2648. +
  2648.                                     }
    2649. +
  2649.                                 }
    2650. +
  2650.                                 // not a hard escape, but a normal escape
    2651. +
  2651.                                 // they come in pairs of two
    2652. +
  2652.                                 $c = 0;
    2653. +
  2653.                                 while (isset($string[$es_pos + $c]) && isset($string[$es_pos + $c + 1])
    2654. +
  2654.                                     && $string[$es_pos + $c] == $this->language_data['ESCAPE_CHAR']
    2655. +
  2655.                                     && $string[$es_pos + $c + 1] == $this->language_data['ESCAPE_CHAR']) {
    2656. +
  2656.                                     $c += 2;
    2657. +
  2657.                                 }
    2658. +
  2658.                                 if ($c) {
    2659. +
  2659.                                     $new_string .= "<span$escape_char_attributes>" .
    2660. +
  2660.                                         str_repeat($escaped_escape_char, $c) .
    2661. +
  2661.                                         '</span>';
    2662. +
  2662.                                     $start = $es_pos + $c;
    2663. +
  2663.                                 } else {
    2664. +
  2664.                                     // this is just a single lonely escape char...
    2665. +
  2665.                                     $new_string .= $escaped_escape_char;
    2666. +
  2666.                                     $start = $es_pos + 1;
    2667. +
  2667.                                 }
    2668. +
  2668.                             }
    2669. +
  2669.                             $string = $new_string . $this->hsc(substr($string, $start));
    2670. +
  2670.                         } else {
    2671. +
  2671.                             $string = $this->hsc($string);
    2672. +
  2672.                         }
    2673. +
  2673.  
    2674. +
  2674.                         if ($check_linenumbers) {
    2675. +
  2675.                             // Are line numbers used? If, we should end the string before
    2676. +
  2676.                             // the newline and begin it again (so when <li>s are put in the source
    2677. +
  2677.                             // remains XHTML compliant)
    2678. +
  2678.                             // note to self: This opens up possibility of config files specifying
    2679. +
  2679.                             // that languages can/cannot have multiline strings???
    2680. +
  2680.                             $string = str_replace("\n", "</span>\n<span$string_attributes>", $string);
    2681. +
  2681.                         }
    2682. +
  2682.  
    2683. +
  2683.                         $result .= "<span$string_attributes>" . $string . '</span>';
    2684. +
  2684.                         $string = '';
    2685. +
  2685.                         continue;
    2686. +
  2686.                     } else {
    2687. +
  2687.                         //Have a look for regexp comments
    2688. +
  2688.                         if ($i == $next_comment_regexp_pos) {
    2689. +
  2689.                             $COMMENT_MATCHED = true;
    2690. +
  2690.                             $comment = $comment_regexp_cache_per_key[$next_comment_regexp_key];
    2691. +
  2691.                             $test_str = $this->hsc(substr($part, $i, $comment['length']));
    2692. +
  2692.  
    2693. +
  2693.                             //@todo If remove important do remove here
    2694. +
  2694.                             if ($this->lexic_permissions['COMMENTS']['MULTI']) {
    2695. +
  2695.                                 if (!$this->use_classes) {
    2696. +
  2696.                                     $attributes = ' style="' . $this->language_data['STYLES']['COMMENTS'][$comment['key']] . '"';
    2697. +
  2697.                                 } else {
    2698. +
  2698.                                     $attributes = ' class="co' . $comment['key'] . '"';
    2699. +
  2699.                                 }
    2700. +
  2700.  
    2701. +
  2701.                                 $test_str = "<span$attributes>" . $test_str . "</span>";
    2702. +
  2702.  
    2703. +
  2703.                                 // Short-cut through all the multiline code
    2704. +
  2704.                                 if ($check_linenumbers) {
    2705. +
  2705.                                     // strreplace to put close span and open span around multiline newlines
    2706. +
  2706.                                     $test_str = str_replace(
    2707. +
  2707.                                         "\n", "</span>\n<span$attributes>",
    2708. +
  2708.                                         str_replace("\n ", "\n&nbsp;", $test_str)
    2709. +
  2709.                                     );
    2710. +
  2710.                                 }
    2711. +
  2711.                             }
    2712. +
  2712.  
    2713. +
  2713.                             $i += $comment['length'] - 1;
    2714. +
  2714.  
    2715. +
  2715.                             // parse the rest
    2716. +
  2716.                             $result .= $this->parse_non_string_part($stuff_to_parse);
    2717. +
  2717.                             $stuff_to_parse = '';
    2718. +
  2718.                         }
    2719. +
  2719.  
    2720. +
  2720.                         // If we haven't matched a regexp comment, try multi-line comments
    2721. +
  2721.                         if (!$COMMENT_MATCHED) {
    2722. +
  2722.                             // Is this a multiline comment?
    2723. +
  2723.                             if (!empty($this->language_data['COMMENT_MULTI']) && $next_comment_multi_pos < $i) {
    2724. +
  2724.                                 $next_comment_multi_pos = $length;
    2725. +
  2725.                                 foreach ($this->language_data['COMMENT_MULTI'] as $open => $close) {
    2726. +
  2726.                                     $match_i = false;
    2727. +
  2727.                                     if (isset($comment_multi_cache_per_key[$open]) &&
    2728. +
  2728.                                         ($comment_multi_cache_per_key[$open] >= $i ||
    2729. +
  2729.                                          $comment_multi_cache_per_key[$open] === false)) {
    2730. +
  2730.                                         // we have already matched something
    2731. +
  2731.                                         if ($comment_multi_cache_per_key[$open] === false) {
    2732. +
  2732.                                             // this comment is never matched
    2733. +
  2733.                                             continue;
    2734. +
  2734.                                         }
    2735. +
  2735.                                         $match_i = $comment_multi_cache_per_key[$open];
    2736. +
  2736.                                     } else if (($match_i = stripos($part, $open, $i)) !== false) {
    2737. +
  2737.                                         $comment_multi_cache_per_key[$open] = $match_i;
    2738. +
  2738.                                     } else {
    2739. +
  2739.                                         $comment_multi_cache_per_key[$open] = false;
    2740. +
  2740.                                         continue;
    2741. +
  2741.                                     }
    2742. +
  2742.                                     if ($match_i !== false && $match_i < $next_comment_multi_pos) {
    2743. +
  2743.                                         $next_comment_multi_pos = $match_i;
    2744. +
  2744.                                         $next_open_comment_multi = $open;
    2745. +
  2745.                                         if ($match_i === $i) {
    2746. +
  2746.                                             break;
    2747. +
  2747.                                         }
    2748. +
  2748.                                     }
    2749. +
  2749.                                 }
    2750. +
  2750.                             }
    2751. +
  2751.                             if ($i == $next_comment_multi_pos) {
    2752. +
  2752.                                 $open = $next_open_comment_multi;
    2753. +
  2753.                                 $close = $this->language_data['COMMENT_MULTI'][$open];
    2754. +
  2754.                                 $open_strlen = strlen($open);
    2755. +
  2755.                                 $close_strlen = strlen($close);
    2756. +
  2756.                                 $COMMENT_MATCHED = true;
    2757. +
  2757.                                 $test_str_match = $open;
    2758. +
  2758.                                 //@todo If remove important do remove here
    2759. +
  2759.                                 if ($this->lexic_permissions['COMMENTS']['MULTI'] ||
    2760. +
  2760.                                     $open == <a href="../geshi/core/_geshi.php.html#defineGESHI_START_IMPORTANT">GESHI_START_IMPORTANT</a>) {
    2761. +
  2761.                                     if ($open != <a href="../geshi/core/_geshi.php.html#defineGESHI_START_IMPORTANT">GESHI_START_IMPORTANT</a>) {
    2762. +
  2762.                                         if (!$this->use_classes) {
    2763. +
  2763.                                             $attributes = ' style="' . $this->language_data['STYLES']['COMMENTS']['MULTI'] . '"';
    2764. +
  2764.                                         } else {
    2765. +
  2765.                                             $attributes = ' class="coMULTI"';
    2766. +
  2766.                                         }
    2767. +
  2767.                                         $test_str = "<span$attributes>" . $this->hsc($open);
    2768. +
  2768.                                     } else {
    2769. +
  2769.                                         if (!$this->use_classes) {
    2770. +
  2770.                                             $attributes = ' style="' . $this->important_styles . '"';
    2771. +
  2771.                                         } else {
    2772. +
  2772.                                             $attributes = ' class="imp"';
    2773. +
  2773.                                         }
    2774. +
  2774.  
    2775. +
  2775.                                         // We don't include the start of the comment if it's an
    2776. +
  2776.                                         // "important" part
    2777. +
  2777.                                         $test_str = "<span$attributes>";
    2778. +
  2778.                                     }
    2779. +
  2779.                                 } else {
    2780. +
  2780.                                     $test_str = $this->hsc($open);
    2781. +
  2781.                                 }
    2782. +
  2782.  
    2783. +
  2783.                                 $close_pos = strpos( $part, $close, $i + $open_strlen );
    2784. +
  2784.  
    2785. +
  2785.                                 if ($close_pos === false) {
    2786. +
  2786.                                     $close_pos = $length;
    2787. +
  2787.                                 }
    2788. +
  2788.  
    2789. +
  2789.                                 // Short-cut through all the multiline code
    2790. +
  2790.                                 $rest_of_comment = $this->hsc(substr($part, $i + $open_strlen, $close_pos - $i - $open_strlen + $close_strlen));
    2791. +
  2791.                                 if (($this->lexic_permissions['COMMENTS']['MULTI'] ||
    2792. +
  2792.                                     $test_str_match == <a href="../geshi/core/_geshi.php.html#defineGESHI_START_IMPORTANT">GESHI_START_IMPORTANT</a>) &&
    2793. +
  2793.                                     $check_linenumbers) {
    2794. +
  2794.  
    2795. +
  2795.                                     // strreplace to put close span and open span around multiline newlines
    2796. +
  2796.                                     $test_str .= str_replace(
    2797. +
  2797.                                         "\n", "</span>\n<span$attributes>",
    2798. +
  2798.                                         str_replace("\n ", "\n&nbsp;", $rest_of_comment)
    2799. +
  2799.                                     );
    2800. +
  2800.                                 } else {
    2801. +
  2801.                                     $test_str .= $rest_of_comment;
    2802. +
  2802.                                 }
    2803. +
  2803.  
    2804. +
  2804.                                 if ($this->lexic_permissions['COMMENTS']['MULTI'] ||
    2805. +
  2805.                                     $test_str_match == <a href="../geshi/core/_geshi.php.html#defineGESHI_START_IMPORTANT">GESHI_START_IMPORTANT</a>) {
    2806. +
  2806.                                     $test_str .= '</span>';
    2807. +
  2807.                                 }
    2808. +
  2808.  
    2809. +
  2809.                                 $i = $close_pos + $close_strlen - 1;
    2810. +
  2810.  
    2811. +
  2811.                                 // parse the rest
    2812. +
  2812.                                 $result .= $this->parse_non_string_part($stuff_to_parse);
    2813. +
  2813.                                 $stuff_to_parse = '';
    2814. +
  2814.                             }
    2815. +
  2815.                         }
    2816. +
  2816.  
    2817. +
  2817.                         // If we haven't matched a multiline comment, try single-line comments
    2818. +
  2818.                         if (!$COMMENT_MATCHED) {
    2819. +
  2819.                             // cache potential single line comment occurances
    2820. +
  2820.                             if (!empty($this->language_data['COMMENT_SINGLE']) && $next_comment_single_pos < $i) {
    2821. +
  2821.                                 $next_comment_single_pos = $length;
    2822. +
  2822.                                 foreach ($this->language_data['COMMENT_SINGLE'] as $comment_key => $comment_mark) {
    2823. +
  2823.                                     $match_i = false;
    2824. +
  2824.                                     if (isset($comment_single_cache_per_key[$comment_key]) &&
    2825. +
  2825.                                         ($comment_single_cache_per_key[$comment_key] >= $i ||
    2826. +
  2826.                                          $comment_single_cache_per_key[$comment_key] === false)) {
    2827. +
  2827.                                         // we have already matched something
    2828. +
  2828.                                         if ($comment_single_cache_per_key[$comment_key] === false) {
    2829. +
  2829.                                             // this comment is never matched
    2830. +
  2830.                                             continue;
    2831. +
  2831.                                         }
    2832. +
  2832.                                         $match_i = $comment_single_cache_per_key[$comment_key];
    2833. +
  2833.                                     } else if (
    2834. +
  2834.                                         // case sensitive comments
    2835. +
  2835.                                         ($this->language_data['CASE_SENSITIVE'][GESHI_COMMENTS] &&
    2836. +
  2836.                                         ($match_i = stripos($part, $comment_mark, $i)) !== false) ||
    2837. +
  2837.                                         // non case sensitive
    2838. +
  2838.                                         (!$this->language_data['CASE_SENSITIVE'][GESHI_COMMENTS] &&
    2839. +
  2839.                                           (($match_i = strpos($part, $comment_mark, $i)) !== false))) {
    2840. +
  2840.                                         $comment_single_cache_per_key[$comment_key] = $match_i;
    2841. +
  2841.                                     } else {
    2842. +
  2842.                                         $comment_single_cache_per_key[$comment_key] = false;
    2843. +
  2843.                                         continue;
    2844. +
  2844.                                     }
    2845. +
  2845.                                     if ($match_i !== false && $match_i < $next_comment_single_pos) {
    2846. +
  2846.                                         $next_comment_single_pos = $match_i;
    2847. +
  2847.                                         $next_comment_single_key = $comment_key;
    2848. +
  2848.                                         if ($match_i === $i) {
    2849. +
  2849.                                             break;
    2850. +
  2850.                                         }
    2851. +
  2851.                                     }
    2852. +
  2852.                                 }
    2853. +
  2853.                             }
    2854. +
  2854.                             if ($next_comment_single_pos == $i) {
    2855. +
  2855.                                 $comment_key = $next_comment_single_key;
    2856. +
  2856.                                 $comment_mark = $this->language_data['COMMENT_SINGLE'][$comment_key];
    2857. +
  2857.                                 $com_len = strlen($comment_mark);
    2858. +
  2858.  
    2859. +
  2859.                                 // This check will find special variables like $# in bash
    2860. +
  2860.                                 // or compiler directives of Delphi beginning {$
    2861. +
  2861.                                 if ((empty($sc_disallowed_before) || ($i == 0) ||
    2862. +
  2862.                                     (false === strpos($sc_disallowed_before, $part[$i-1]))) &&
    2863. +
  2863.                                     (empty($sc_disallowed_after) || ($length <= $i + $com_len) ||
    2864. +
  2864.                                     (false === strpos($sc_disallowed_after, $part[$i + $com_len]))))
    2865. +
  2865.                                 {
    2866. +
  2866.                                     // this is a valid comment
    2867. +
  2867.                                     $COMMENT_MATCHED = true;
    2868. +
  2868.                                     if ($this->lexic_permissions['COMMENTS'][$comment_key]) {
    2869. +
  2869.                                         if (!$this->use_classes) {
    2870. +
  2870.                                             $attributes = ' style="' . $this->language_data['STYLES']['COMMENTS'][$comment_key] . '"';
    2871. +
  2871.                                         } else {
    2872. +
  2872.                                             $attributes = ' class="co' . $comment_key . '"';
    2873. +
  2873.                                         }
    2874. +
  2874.                                         $test_str = "<span$attributes>" . $this->hsc($this->change_case($comment_mark));
    2875. +
  2875.                                     } else {
    2876. +
  2876.                                         $test_str = $this->hsc($comment_mark);
    2877. +
  2877.                                     }
    2878. +
  2878.  
    2879. +
  2879.                                     //Check if this comment is the last in the source
    2880. +
  2880.                                     $close_pos = strpos($part, "\n", $i);
    2881. +
  2881.                                     $oops = false;
    2882. +
  2882.                                     if ($close_pos === false) {
    2883. +
  2883.                                         $close_pos = $length;
    2884. +
  2884.                                         $oops = true;
    2885. +
  2885.                                     }
    2886. +
  2886.                                     $test_str .= $this->hsc(substr($part, $i + $com_len, $close_pos - $i - $com_len));
    2887. +
  2887.                                     if ($this->lexic_permissions['COMMENTS'][$comment_key]) {
    2888. +
  2888.                                         $test_str .= "</span>";
    2889. +
  2889.                                     }
    2890. +
  2890.  
    2891. +
  2891.                                     // Take into account that the comment might be the last in the source
    2892. +
  2892.                                     if (!$oops) {
    2893. +
  2893.                                       $test_str .= "\n";
    2894. +
  2894.                                     }
    2895. +
  2895.  
    2896. +
  2896.                                     $i = $close_pos;
    2897. +
  2897.  
    2898. +
  2898.                                     // parse the rest
    2899. +
  2899.                                     $result .= $this->parse_non_string_part($stuff_to_parse);
    2900. +
  2900.                                     $stuff_to_parse = '';
    2901. +
  2901.                                 }
    2902. +
  2902.                             }
    2903. +
  2903.                         }
    2904. +
  2904.                     }
    2905. +
  2905.  
    2906. +
  2906.                     // Where are we adding this char?
    2907. +
  2907.                     if (!$COMMENT_MATCHED) {
    2908. +
  2908.                         $stuff_to_parse .= $char;
    2909. +
  2909.                     } else {
    2910. +
  2910.                         $result .= $test_str;
    2911. +
  2911.                         unset($test_str);
    2912. +
  2912.                         $COMMENT_MATCHED = false;
    2913. +
  2913.                     }
    2914. +
  2914.                 }
    2915. +
  2915.                 // Parse the last bit
    2916. +
  2916.                 $result .= $this->parse_non_string_part($stuff_to_parse);
    2917. +
  2917.                 $stuff_to_parse = '';
    2918. +
  2918.             } else {
    2919. +
  2919.                 $result .= $this->hsc($part);
    2920. +
  2920.             }
    2921. +
  2921.             // Close the <span> that surrounds the block
    2922. +
  2922.             if ($STRICTATTRS != '') {
    2923. +
  2923.                 $result = str_replace("\n", "</span>\n<span$STRICTATTRS>", $result);
    2924. +
  2924.                 $result .= '</span>';
    2925. +
  2925.             }
    2926. +
  2926.  
    2927. +
  2927.             $endresult .= $result;
    2928. +
  2928.             unset($part, $parts[$key], $result);
    2929. +
  2929.         }
    2930. +
  2930.  
    2931. +
  2931.         //This fix is related to SF#1923020, but has to be applied regardless of
    2932. +
  2932.         //actually highlighting symbols.
    2933. +
  2933. /** NOTE: memorypeak #3 */        
    2934. +
  2934.         $endresult = str_replace(array('<SEMI>', '<PIPE>'), array(';', '|'), $endresult);
    2935. +
  2935.  
    2936. +
  2936. //        // Parse the last stuff (redundant?)
    2937. +
  2937. //        $result .= $this->parse_non_string_part($stuff_to_parse);
    2938. +
    2939. +
  2939.         // Lop off the very first and last spaces
    2940. +
  2940. //        $result = substr($result, 1, -1);
    2941. +
    2942. +
  2942.         // We're finished: stop timing
    2943. +
  2943.         $this->set_time($start_time, microtime());
    2944. +
  2944.  
    2945. +
  2945.         $this->finalise($endresult);
    2946. +
  2946.         return $endresult;
    2947. +
  2947.     }
    2948. +
  2948.  
    2949. +
  2949. /**    
    2950. +
  2950.      * Swaps out spaces and tabs for HTML indentation. Not needed if
    2951. +
  2951.      * the code is in a pre block...
    2952. +
  2952.      *
    2953. +
  2953.      * @param  string The source to indent (reference!)
    2954. +
  2954.      * @since  1.0.0
    2955. +
  2955.      * @access private
    2956. +
  2956.      */
    2957. +
  2957.     function indent(&$result) {
    2958. +
  2958.         /// Replace tabs with the correct number of spaces
    2959. +
  2959.         if (false !== strpos($result, "\t")) {
    2960. +
  2960.             $lines = explode("\n", $result);
    2961. +
  2961.             $result = null;//Save memory while we process the lines individually
    2962. +
  2962.             $tab_width = $this->get_real_tab_width();
    2963. +
  2963.             $tab_string = '&nbsp;' . str_repeat(' ', $tab_width);
    2964. +
  2964.  
    2965. +
  2965.             for ($key = 0, $n = count($lines); $key < $n; $key++) {
    2966. +
  2966.                 $line = $lines[$key];
    2967. +
  2967.                 if (false === strpos($line, "\t")) {
    2968. +
  2968.                     continue;
    2969. +
  2969.                 }
    2970. +
  2970.  
    2971. +
  2971.                 $pos = 0;
    2972. +
  2972.                 $length = strlen($line);
    2973. +
  2973.                 $lines[$key] = ''; // reduce memory
    2974. +
    2975. +
  2975.                 $IN_TAG = false;
    2976. +
  2976.                 for ($i = 0; $i < $length; ++$i) {
    2977. +
  2977.                     $char = $line[$i];
    2978. +
  2978.                     // Simple engine to work out whether we're in a tag.
    2979. +
  2979.                     // If we are we modify $pos. This is so we ignore HTML
    2980. +
  2980.                     // in the line and only workout the tab replacement
    2981. +
  2981.                     // via the actual content of the string
    2982. +
  2982.                     // This test could be improved to include strings in the
    2983. +
  2983.                     // html so that < or > would be allowed in user's styles
    2984. +
  2984.                     // (e.g. quotes: '<' '>'; or similar)
    2985. +
  2985.                     if ($IN_TAG) {
    2986. +
  2986.                         if ('>' == $char) {
    2987. +
  2987.                             $IN_TAG = false;
    2988. +
  2988.                         }
    2989. +
  2989.                         $lines[$key] .= $char;
    2990. +
  2990.                     } else if ('<' == $char) {
    2991. +
  2991.                         $IN_TAG = true;
    2992. +
  2992.                         $lines[$key] .= '<';
    2993. +
  2993.                     } else if ('&' == $char) {
    2994. +
  2994.                         $substr = substr($line, $i + 3, 5);
    2995. +
  2995.                         $posi = strpos($substr, ';');
    2996. +
  2996.                         if (false === $posi) {
    2997. +
  2997.                             ++$pos;
    2998. +
  2998.                         } else {
    2999. +
  2999.                             $pos -= $posi+2;
    3000. +
  3000.                         }
    3001. +
  3001.                         $lines[$key] .= $char;
    3002. +
  3002.                     } else if ("\t" == $char) {
    3003. +
  3003.                         $str = '';
    3004. +
  3004.                         // OPTIMISE - move $strs out. Make an array:
    3005. +
  3005.                         // $tabs = array(
    3006. +
  3006.                         //  1 => '&nbsp;',
    3007. +
  3007.                         //  2 => '&nbsp; ',
    3008. +
  3008.                         //  3 => '&nbsp; &nbsp;' etc etc
    3009. +
  3009.                         // to use instead of building a string every time
    3010. +
  3010.                         $tab_end_width = $tab_width - ($pos % $tab_width); //Moved out of the look as it doesn't change within the loop
    3011. +
  3011.                         if (($pos & 1) || 1 == $tab_end_width) {
    3012. +
  3012.                             $str .= substr($tab_string, 6, $tab_end_width);
    3013. +
  3013.                         } else {
    3014. +
  3014.                             $str .= substr($tab_string, 0, $tab_end_width+5);
    3015. +
  3015.                         }
    3016. +
  3016.                         $lines[$key] .= $str;
    3017. +
  3017.                         $pos += $tab_end_width;
    3018. +
  3018.  
    3019. +
  3019.                         if (false === strpos($line, "\t", $i + 1)) {
    3020. +
  3020.                             $lines[$key] .= substr($line, $i + 1);
    3021. +
  3021.                             break;
    3022. +
  3022.                         }
    3023. +
  3023.                     } else if (0 == $pos && ' ' == $char) {
    3024. +
  3024.                         $lines[$key] .= '&nbsp;';
    3025. +
  3025.                         ++$pos;
    3026. +
  3026.                     } else {
    3027. +
  3027.                         $lines[$key] .= $char;
    3028. +
  3028.                         ++$pos;
    3029. +
  3029.                     }
    3030. +
  3030.                 }
    3031. +
  3031.             }
    3032. +
  3032.             $result = implode("\n", $lines);
    3033. +
  3033.             unset($lines);//We don't need the lines separated beyond this --- free them!
    3034. +
  3034.         }
    3035. +
  3035.         // Other whitespace
    3036. +
  3036.         // BenBE: Fix to reduce the number of replacements to be done
    3037. +
  3037.         $result = preg_replace('/^ /m', '&nbsp;', $result);
    3038. +
  3038.         $result = str_replace('  ', ' &nbsp;', $result);
    3039. +
  3039.  
    3040. +
  3040.         if ($this->line_numbers == <a href="../geshi/core/_geshi.php.html#defineGESHI_NO_LINE_NUMBERS">GESHI_NO_LINE_NUMBERS</a>) {
    3041. +
  3041.             if ($this->line_ending === null) {
    3042. +
  3042.                 $result = nl2br($result);
    3043. +
  3043.             } else {
    3044. +
  3044.                 $result = str_replace("\n", $this->line_ending, $result);
    3045. +
  3045.             }
    3046. +
  3046.         }
    3047. +
  3047.     }
    3048. +
  3048.  
    3049. +
  3049. /**    
    3050. +
  3050.      * Changes the case of a keyword for those languages where a change is asked for
    3051. +
  3051.      *
    3052. +
  3052.      * @param  string The keyword to change the case of
    3053. +
  3053.      * @return string The keyword with its case changed
    3054. +
  3054.      * @since  1.0.0
    3055. +
  3055.      * @access private
    3056. +
  3056.      */
    3057. +
  3057.     function change_case($instr) {
    3058. +
  3058.         switch ($this->language_data['CASE_KEYWORDS']) {
    3059. +
  3059.             case <a href="../geshi/core/_geshi.php.html#defineGESHI_CAPS_UPPER">GESHI_CAPS_UPPER</a>:
    3060. +
  3060.                 return strtoupper($instr);
    3061. +
  3061.             case <a href="../geshi/core/_geshi.php.html#defineGESHI_CAPS_LOWER">GESHI_CAPS_LOWER</a>:
    3062. +
  3062.                 return strtolower($instr);
    3063. +
  3063.             default:
    3064. +
  3064.                 return $instr;
    3065. +
  3065.         }
    3066. +
  3066.     }
    3067. +
  3067.  
    3068. +
  3068. /**    
    3069. +
  3069.      * Handles replacements of keywords to include markup and links if requested
    3070. +
  3070.      *
    3071. +
  3071.      * @param  string The keyword to add the Markup to
    3072. +
  3072.      * @return The HTML for the match found
    3073. +
  3073.      * @since  1.0.8
    3074. +
  3074.      * @access private
    3075. +
  3075.      *
    3076. +
  3076.      * @todo   Get rid of ender in keyword links
    3077. +
  3077.      */
    3078. +
  3078.     function handle_keyword_replace($match) {
    3079. +
  3079.         $k = $this->_kw_replace_group;
    3080. +
  3080.         $keyword = $match[0];
    3081. +
  3081.  
    3082. +
  3082.         $before = '';
    3083. +
  3083.         $after = '';
    3084. +
  3084.  
    3085. +
  3085.         if ($this->keyword_links) {
    3086. +
  3086.             // Keyword links have been ebabled
    3087. +
    3088. +
  3088.             if (isset($this->language_data['URLS'][$k]) &&
    3089. +
  3089.                 $this->language_data['URLS'][$k] != '') {
    3090. +
  3090.                 // There is a base group for this keyword
    3091. +
    3092. +
  3092.                 // Old system: strtolower
    3093. +
  3093.                 //$keyword = ( $this->language_data['CASE_SENSITIVE'][$group] ) ? $keyword : strtolower($keyword);
    3094. +
  3094.                 // New system: get keyword from language file to get correct case
    3095. +
  3095.                 if (!$this->language_data['CASE_SENSITIVE'][$k] &&
    3096. +
  3096.                     strpos($this->language_data['URLS'][$k], '{FNAME}') !== false) {
    3097. +
  3097.                     foreach ($this->language_data['KEYWORDS'][$k] as $word) {
    3098. +
  3098.                         if (strcasecmp($word, $keyword) == 0) {
    3099. +
  3099.                             break;
    3100. +
  3100.                         }
    3101. +
  3101.                     }
    3102. +
  3102.                 } else {
    3103. +
  3103.                     $word = $keyword;
    3104. +
  3104.                 }
    3105. +
  3105.  
    3106. +
  3106.                 $before = '<|UR1|"' .
    3107. +
  3107.                     str_replace(
    3108. +
  3108.                         array(
    3109. +
  3109.                             '{FNAME}',
    3110. +
  3110.                             '{FNAMEL}',
    3111. +
  3111.                             '{FNAMEU}',
    3112. +
  3112.                             '.'),
    3113. +
  3113.                         array(
    3114. +
  3114.                             str_replace('+', '%20', urlencode($this->hsc($word))),
    3115. +
  3115.                             str_replace('+', '%20', urlencode($this->hsc(strtolower($word)))),
    3116. +
  3116.                             str_replace('+', '%20', urlencode($this->hsc(strtoupper($word)))),
    3117. +
  3117.                             '<DOT>'),
    3118. +
  3118.                         $this->language_data['URLS'][$k]
    3119. +
  3119.                     ) . '">';
    3120. +
  3120.                 $after = '</a>';
    3121. +
  3121.             }
    3122. +
  3122.         }
    3123. +
  3123.  
    3124. +
  3124.         return $before . '<|/'. $k .'/>' . $this->change_case($keyword) . '|>' . $after;
    3125. +
  3125.     }
    3126. +
  3126.  
    3127. +
  3127. /**    
    3128. +
  3128.      * handles regular expressions highlighting-definitions with callback functions
    3129. +
  3129.      *
    3130. +
  3130.      * @note this is a callback, don't use it directly
    3131. +
  3131.      *
    3132. +
  3132.      * @param array the matches array
    3133. +
  3133.      * @return The highlighted string
    3134. +
  3134.      * @since 1.0.8
    3135. +
  3135.      * @access private
    3136. +
  3136.      */
    3137. +
  3137.     function handle_regexps_callback($matches) {
    3138. +
  3138.         // before: "' style=\"' . call_user_func(\"$func\", '\\1') . '\"\\1|>'",
    3139. +
  3139.         return  ' style="' . call_user_func($this->language_data['STYLES']['REGEXPS'][$this->_rx_key], $matches[1]) . '"'. $matches[1] . '|>';
    3140. +
  3140.     }
    3141. +
  3141.  
    3142. +
  3142. /**    
    3143. +
  3143.      * handles newlines in REGEXPS matches. Set the _hmr_* vars before calling this
    3144. +
  3144.      *
    3145. +
  3145.      * @note this is a callback, don't use it directly
    3146. +
  3146.      *
    3147. +
  3147.      * @param array the matches array
    3148. +
  3148.      * @return string 
    3149. +
  3149.      * @since 1.0.8
    3150. +
  3150.      * @access private
    3151. +
  3151.      */
    3152. +
  3152.     function handle_multiline_regexps($matches) {
    3153. +
  3153.         $before = $this->_hmr_before;
    3154. +
  3154.         $after = $this->_hmr_after;
    3155. +
  3155.         if ($this->_hmr_replace) {
    3156. +
  3156.             $replace = $this->_hmr_replace;
    3157. +
  3157.             $search = array();
    3158. +
  3158.  
    3159. +
  3159.             foreach (array_keys($matches) as $k) {
    3160. +
  3160.                 $search[] = '\\' . $k;
    3161. +
  3161.             }
    3162. +
  3162.  
    3163. +
  3163.             $before = str_replace($search, $matches, $before);
    3164. +
  3164.             $after = str_replace($search, $matches, $after);
    3165. +
  3165.             $replace = str_replace($search, $matches, $replace);
    3166. +
  3166.         } else {
    3167. +
  3167.             $replace = $matches[0];
    3168. +
  3168.         }
    3169. +
  3169.         return $before
    3170. +
  3170.                     . '<|!REG3XP' . $this->_hmr_key .'!>'
    3171. +
  3171.                         . str_replace("\n", "|>\n<|!REG3XP" . $this->_hmr_key . '!>', $replace)
    3172. +
  3172.                     . '|>'
    3173. +
  3173.               . $after;
    3174. +
  3174.     }
    3175. +
  3175.  
    3176. +
  3176. /**    
    3177. +
  3177.      * Takes a string that has no strings or comments in it, and highlights
    3178. +
  3178.      * stuff like keywords, numbers and methods.
    3179. +
  3179.      *
    3180. +
  3180.      * @param string The string to parse for keyword, numbers etc.
    3181. +
  3181.      * @since 1.0.0
    3182. +
  3182.      * @access private
    3183. +
  3183.      * @todo BUGGY! Why? Why not build string and return?
    3184. +
  3184.      */
    3185. +
  3185.     function parse_non_string_part($stuff_to_parse) {
    3186. +
  3186.         $stuff_to_parse = ' ' . $this->hsc($stuff_to_parse);
    3187. +
  3187.  
    3188. +
  3188.         // Regular expressions
    3189. +
  3189.         foreach ($this->language_data['REGEXPS'] as $key => $regexp) {
    3190. +
  3190.             if ($this->lexic_permissions['REGEXPS'][$key]) {
    3191. +
  3191.                 if (is_array($regexp)) {
    3192. +
  3192.                     if ($this->line_numbers != <a href="../geshi/core/_geshi.php.html#defineGESHI_NO_LINE_NUMBERS">GESHI_NO_LINE_NUMBERS</a>) {
    3193. +
  3193.                         // produce valid HTML when we match multiple lines
    3194. +
  3194.                         $this->_hmr_replace = $regexp[GESHI_REPLACE];
    3195. +
  3195.                         $this->_hmr_before = $regexp[GESHI_BEFORE];
    3196. +
  3196.                         $this->_hmr_key = $key;
    3197. +
  3197.                         $this->_hmr_after = $regexp[GESHI_AFTER];
    3198. +
  3198.                         $stuff_to_parse = preg_replace_callback(
    3199. +
  3199.                             "/" . $regexp[GESHI_SEARCH] . "/{$regexp[GESHI_MODIFIERS]}",
    3200. +
  3200.                             array($this, 'handle_multiline_regexps'),
    3201. +
  3201.                             $stuff_to_parse);
    3202. +
  3202.                         $this->_hmr_replace = false;
    3203. +
  3203.                         $this->_hmr_before = '';
    3204. +
  3204.                         $this->_hmr_after = '';
    3205. +
  3205.                     } else {
    3206. +
  3206.                         $stuff_to_parse = preg_replace(
    3207. +
  3207.                             '/' . $regexp[GESHI_SEARCH] . '/' . $regexp[GESHI_MODIFIERS],
    3208. +
  3208.                             $regexp[GESHI_BEFORE] . '<|!REG3XP'. $key .'!>' . $regexp[GESHI_REPLACE] . '|>' . $regexp[GESHI_AFTER],
    3209. +
  3209.                             $stuff_to_parse);
    3210. +
  3210.                     }
    3211. +
  3211.                 } else {
    3212. +
  3212.                     if ($this->line_numbers != <a href="../geshi/core/_geshi.php.html#defineGESHI_NO_LINE_NUMBERS">GESHI_NO_LINE_NUMBERS</a>) {
    3213. +
  3213.                         // produce valid HTML when we match multiple lines
    3214. +
  3214.                         $this->_hmr_key = $key;
    3215. +
  3215.                         $stuff_to_parse = preg_replace_callback( "/(" . $regexp . ")/",
    3216. +
  3216.                                               array($this, 'handle_multiline_regexps'), $stuff_to_parse);
    3217. +
  3217.                         $this->_hmr_key = '';
    3218. +
  3218.                     } else {
    3219. +
  3219.                         $stuff_to_parse = preg_replace( "/(" . $regexp . ")/", "<|!REG3XP$key!>\\1|>", $stuff_to_parse);
    3220. +
  3220.                     }
    3221. +
  3221.                 }
    3222. +
  3222.             }
    3223. +
  3223.         }
    3224. +
  3224.  
    3225. +
  3225.         // Highlight numbers. As of 1.0.8 we support diffent types of numbers
    3226. +
  3226.         $numbers_found = false;
    3227. +
  3227.         if ($this->lexic_permissions['NUMBERS'] && preg_match('#\d#', $stuff_to_parse )) {
    3228. +
  3228.             $numbers_found = true;
    3229. +
  3229.  
    3230. +
  3230.             //For each of the formats ...
    3231. +
  3231.             foreach($this->language_data['NUMBERS_RXCACHE'] as $id => $regexp) {
    3232. +
  3232.                 //Check if it should be highlighted ...
    3233. +
  3233.                 $stuff_to_parse = preg_replace($regexp, "<|/NUM!$id/>\\1|>", $stuff_to_parse);
    3234. +
  3234.             }
    3235. +
  3235.         }
    3236. +
  3236.  
    3237. +
  3237.         // Highlight keywords
    3238. +
  3238.         $disallowed_before = "(?<![a-zA-Z0-9\$_\|\#;>|^&";
    3239. +
  3239.         $disallowed_after = "(?![a-zA-Z0-9_\|%\\-&;";
    3240. +
  3240.         if ($this->lexic_permissions['STRINGS']) {
    3241. +
  3241.             $quotemarks = preg_quote(implode($this->language_data['QUOTEMARKS']), '/');
    3242. +
  3242.             $disallowed_before .= $quotemarks;
    3243. +
  3243.             $disallowed_after .= $quotemarks;
    3244. +
  3244.         }
    3245. +
  3245.         $disallowed_before .= "])";
    3246. +
  3246.         $disallowed_after .= "])";
    3247. +
  3247.  
    3248. +
  3248.         $parser_control_pergroup = false;
    3249. +
  3249.         if (isset($this->language_data['PARSER_CONTROL'])) {
    3250. +
  3250.             if (isset($this->language_data['PARSER_CONTROL']['KEYWORDS'])) {
    3251. +
  3251.                 $x = 0; // check wether per-keyword-group parser_control is enabled
    3252. +
  3252.                 if (isset($this->language_data['PARSER_CONTROL']['KEYWORDS']['DISALLOWED_BEFORE'])) {
    3253. +
  3253.                     $disallowed_before = $this->language_data['PARSER_CONTROL']['KEYWORDS']['DISALLOWED_BEFORE'];
    3254. +
  3254.                     ++$x;
    3255. +
  3255.                 }
    3256. +
  3256.                 if (isset($this->language_data['PARSER_CONTROL']['KEYWORDS']['DISALLOWED_AFTER'])) {
    3257. +
  3257.                     $disallowed_after = $this->language_data['PARSER_CONTROL']['KEYWORDS']['DISALLOWED_AFTER'];
    3258. +
  3258.                     ++$x;
    3259. +
  3259.                 }
    3260. +
  3260.                 $parser_control_pergroup = (count($this->language_data['PARSER_CONTROL']['KEYWORDS']) - $x) > 0;
    3261. +
  3261.             }
    3262. +
  3262.         }
    3263. +
  3263.  
    3264. +
  3264.         // if this is changed, don't forget to change it below
    3265. +
  3265. //        if (!empty($disallowed_before)) {
    3266. +
  3266. //            $disallowed_before = "(?<![$disallowed_before])";
    3267. +
  3267. //        }
    3268. +
  3268. //        if (!empty($disallowed_after)) {
    3269. +
  3269. //            $disallowed_after = "(?![$disallowed_after])";
    3270. +
  3270. //        }
    3271. +
    3272. +
  3272.         foreach (array_keys($this->language_data['KEYWORDS']) as $k) {
    3273. +
  3273.             if (!isset($this->lexic_permissions['KEYWORDS'][$k]) ||
    3274. +
  3274.                 $this->lexic_permissions['KEYWORDS'][$k]) {
    3275. +
  3275.  
    3276. +
  3276.                 $case_sensitive = $this->language_data['CASE_SENSITIVE'][$k];
    3277. +
  3277.                 $modifiers = $case_sensitive ? '' : 'i';
    3278. +
  3278.  
    3279. +
  3279.                 // NEW in 1.0.8 - per-keyword-group parser control
    3280. +
  3280.                 $disallowed_before_local = $disallowed_before;
    3281. +
  3281.                 $disallowed_after_local = $disallowed_after;
    3282. +
  3282.                 if ($parser_control_pergroup && isset($this->language_data['PARSER_CONTROL']['KEYWORDS'][$k])) {
    3283. +
  3283.                     if (isset($this->language_data['PARSER_CONTROL']['KEYWORDS'][$k]['DISALLOWED_BEFORE'])) {
    3284. +
  3284.                         $disallowed_before_local =
    3285. +
  3285.                             $this->language_data['PARSER_CONTROL']['KEYWORDS'][$k]['DISALLOWED_BEFORE'];
    3286. +
  3286.                     }
    3287. +
  3287.  
    3288. +
  3288.                     if (isset($this->language_data['PARSER_CONTROL']['KEYWORDS'][$k]['DISALLOWED_AFTER'])) {
    3289. +
  3289.                         $disallowed_after_local =
    3290. +
  3290.                             $this->language_data['PARSER_CONTROL']['KEYWORDS'][$k]['DISALLOWED_AFTER'];
    3291. +
  3291.                     }
    3292. +
  3292.                 }
    3293. +
  3293.  
    3294. +
  3294.                 $this->_kw_replace_group = $k;
    3295. +
  3295.  
    3296. +
  3296.                 //NEW in 1.0.8, the cached regexp list
    3297. +
  3297.                 // since we don't want PHP / PCRE to crash due to too large patterns we split them into smaller chunks
    3298. +
  3298.                 for ($set = 0, $set_length = count($this->language_data['CACHED_KEYWORD_LISTS'][$k]); $set <  $set_length; ++$set) {
    3299. +
  3299.                     $keywordset =& $this->language_data['CACHED_KEYWORD_LISTS'][$k][$set];
    3300. +
  3300.                     // Might make a more unique string for putting the number in soon
    3301. +
  3301.                     // Basically, we don't put the styles in yet because then the styles themselves will
    3302. +
  3302.                     // get highlighted if the language has a CSS keyword in it (like CSS, for example ;))
    3303. +
  3303.                     $stuff_to_parse = preg_replace_callback(
    3304. +
  3304.                         "/$disallowed_before_local({$keywordset})(?!\<DOT\>(?:htm|php))$disallowed_after_local/$modifiers",
    3305. +
  3305.                         array($this, 'handle_keyword_replace'),
    3306. +
  3306.                         $stuff_to_parse
    3307. +
  3307.                         );
    3308. +
  3308.                 }
    3309. +
  3309.             }
    3310. +
  3310.         }
    3311. +
  3311.  
    3312. +
  3312.         //
    3313. +
  3313.         // Now that's all done, replace /[number]/ with the correct styles
    3314. +
  3314.         //
    3315. +
  3315.         foreach (array_keys($this->language_data['KEYWORDS']) as $k) {
    3316. +
  3316.             if (!$this->use_classes) {
    3317. +
  3317.                 $attributes = ' style="' .
    3318. +
  3318.                     (isset($this->language_data['STYLES']['KEYWORDS'][$k]) ?
    3319. +
  3319.                     $this->language_data['STYLES']['KEYWORDS'][$k] : "") . '"';
    3320. +
  3320.             } else {
    3321. +
  3321.                 $attributes = ' class="kw' . $k . '"';
    3322. +
  3322.             }
    3323. +
  3323.             $stuff_to_parse = str_replace("<|/$k/>", "<|$attributes>", $stuff_to_parse);
    3324. +
  3324.         }
    3325. +
  3325.  
    3326. +
  3326.         if ($numbers_found) {
    3327. +
  3327.             // Put number styles in
    3328. +
  3328.             foreach($this->language_data['NUMBERS_RXCACHE'] as $id => $regexp) {
    3329. +
  3329. //Commented out for now, as this needs some review ...
    3330. +
  3330. //                if ($numbers_permissions & $id) {
    3331. +
  3331.                     //Get the appropriate style ...
    3332. +
  3332.                         //Checking for unset styles is done by the style cache builder ...
    3333. +
  3333.                     if (!$this->use_classes) {
    3334. +
  3334.                         $attributes = ' style="' . $this->language_data['STYLES']['NUMBERS'][$id] . '"';
    3335. +
  3335.                     } else {
    3336. +
  3336.                         $attributes = ' class="nu'.$id.'"';
    3337. +
  3337.                     }
    3338. +
  3338.  
    3339. +
  3339.                     //Set in the correct styles ...
    3340. +
  3340.                     $stuff_to_parse = str_replace("/NUM!$id/", $attributes, $stuff_to_parse);
    3341. +
  3341. //                }
    3342. +
  3342.             }
    3343. +
  3343.         }
    3344. +
  3344.  
    3345. +
  3345.         // Highlight methods and fields in objects
    3346. +
  3346.         if ($this->lexic_permissions['METHODS'] && $this->language_data['OOLANG']) {
    3347. +
  3347.             $oolang_spaces = "[\s]*";
    3348. +
  3348.             $oolang_before = "";
    3349. +
  3349.             $oolang_after = "[a-zA-Z][a-zA-Z0-9_]*";
    3350. +
  3350.             if (isset($this->language_data['PARSER_CONTROL'])) {
    3351. +
  3351.                 if (isset($this->language_data['PARSER_CONTROL']['OOLANG'])) {
    3352. +
  3352.                     if (isset($this->language_data['PARSER_CONTROL']['OOLANG']['MATCH_BEFORE'])) {
    3353. +
  3353.                         $oolang_before = $this->language_data['PARSER_CONTROL']['OOLANG']['MATCH_BEFORE'];
    3354. +
  3354.                     }
    3355. +
  3355.                     if (isset($this->language_data['PARSER_CONTROL']['OOLANG']['MATCH_AFTER'])) {
    3356. +
  3356.                         $oolang_after = $this->language_data['PARSER_CONTROL']['OOLANG']['MATCH_AFTER'];
    3357. +
  3357.                     }
    3358. +
  3358.                     if (isset($this->language_data['PARSER_CONTROL']['OOLANG']['MATCH_SPACES'])) {
    3359. +
  3359.                         $oolang_spaces = $this->language_data['PARSER_CONTROL']['OOLANG']['MATCH_SPACES'];
    3360. +
  3360.                     }
    3361. +
  3361.                 }
    3362. +
  3362.             }
    3363. +
  3363.  
    3364. +
  3364.             foreach ($this->language_data['OBJECT_SPLITTERS'] as $key => $splitter) {
    3365. +
  3365.                 if (false !== strpos($stuff_to_parse, $splitter)) {
    3366. +
  3366.                     if (!$this->use_classes) {
    3367. +
  3367.                         $attributes = ' style="' . $this->language_data['STYLES']['METHODS'][$key] . '"';
    3368. +
  3368.                     } else {
    3369. +
  3369.                         $attributes = ' class="me' . $key . '"';
    3370. +
  3370.                     }
    3371. +
  3371.                     $stuff_to_parse = preg_replace("/($oolang_before)(" . preg_quote($this->language_data['OBJECT_SPLITTERS'][$key], '/') . ")($oolang_spaces)($oolang_after)/", "\\1\\2\\3<|$attributes>\\4|>", $stuff_to_parse);
    3372. +
  3372.                 }
    3373. +
  3373.             }
    3374. +
  3374.         }
    3375. +
  3375.  
    3376. +
  3376.         //
    3377. +
  3377.         // Highlight brackets. Yes, I've tried adding a semi-colon to this list.
    3378. +
  3378.         // You try it, and see what happens ;)
    3379. +
  3379.         // TODO: Fix lexic permissions not converting entities if shouldn't
    3380. +
  3380.         // be highlighting regardless
    3381. +
  3381.         //
    3382. +
  3382.         if ($this->lexic_permissions['BRACKETS']) {
    3383. +
  3383.             $stuff_to_parse = str_replace( $this->language_data['CACHE_BRACKET_MATCH'],
    3384. +
  3384.                               $this->language_data['CACHE_BRACKET_REPLACE'], $stuff_to_parse );
    3385. +
  3385.         }
    3386. +
  3386.  
    3387. +
  3387.  
    3388. +
  3388.         //FIX for symbol highlighting ...
    3389. +
  3389.         if ($this->lexic_permissions['SYMBOLS'] && !empty($this->language_data['SYMBOLS'])) {
    3390. +
  3390.             //Get all matches and throw away those witin a block that is already highlighted... (i.e. matched by a regexp)
    3391. +
  3391.             $n_symbols = preg_match_all("/<\|(?:<DOT>|[^>])+>(?:(?!\|>).*?)\|>|<\/a>|(?:" . $this->language_data['SYMBOL_SEARCH'] . ")+/", $stuff_to_parse, $pot_symbols, PREG_OFFSET_CAPTURE | PREG_SET_ORDER);
    3392. +
  3392.             $global_offset = 0;
    3393. +
  3393.             for ($s_id = 0; $s_id < $n_symbols; ++$s_id) {
    3394. +
  3394.                 $symbol_match = $pot_symbols[$s_id][0][0];
    3395. +
  3395.                 if (strpos($symbol_match, '<') !== false || strpos($symbol_match, '>') !== false) {
    3396. +
  3396.                     // already highlighted blocks _must_ include either < or >
    3397. +
  3397.                     // so if this conditional applies, we have to skip this match
    3398. +
  3398.                     // BenBE: UNLESS the block contains <SEMI> or <PIPE>
    3399. +
  3399.                     if(strpos($symbol_match, '<SEMI>') === false &&
    3400. +
  3400.                         strpos($symbol_match, '<PIPE>') === false) {
    3401. +
  3401.                         continue;
    3402. +
  3402.                     }
    3403. +
  3403.                 }
    3404. +
  3404.  
    3405. +
  3405.                 // if we reach this point, we have a valid match which needs to be highlighted
    3406. +
    3407. +
  3407.                 $symbol_length = strlen($symbol_match);
    3408. +
  3408.                 $symbol_offset = $pot_symbols[$s_id][0][1];
    3409. +
  3409.                 unset($pot_symbols[$s_id]);
    3410. +
  3410.                 $symbol_end = $symbol_length + $symbol_offset;
    3411. +
  3411.                 $symbol_hl = "";
    3412. +
  3412.  
    3413. +
  3413.                 // if we have multiple styles, we have to handle them properly
    3414. +
  3414.                 if ($this->language_data['MULTIPLE_SYMBOL_GROUPS']) {
    3415. +
  3415.                     $old_sym = -1;
    3416. +
  3416.                     // Split the current stuff to replace into its atomic symbols ...
    3417. +
  3417.                     preg_match_all("/" . $this->language_data['SYMBOL_SEARCH'] . "/", $symbol_match, $sym_match_syms, PREG_PATTERN_ORDER);
    3418. +
  3418.                     foreach ($sym_match_syms[0] as $sym_ms) {
    3419. +
  3419.                         //Check if consequtive symbols belong to the same group to save output ...
    3420. +
  3420.                         if (isset($this->language_data['SYMBOL_DATA'][$sym_ms])
    3421. +
  3421.                             && ($this->language_data['SYMBOL_DATA'][$sym_ms] != $old_sym)) {
    3422. +
  3422.                             if (-1 != $old_sym) {
    3423. +
  3423.                                 $symbol_hl .= "|>";
    3424. +
  3424.                             }
    3425. +
  3425.                             $old_sym = $this->language_data['SYMBOL_DATA'][$sym_ms];
    3426. +
  3426.                             if (!$this->use_classes) {
    3427. +
  3427.                                 $symbol_hl .= '<| style="' . $this->language_data['STYLES']['SYMBOLS'][$old_sym] . '">';
    3428. +
  3428.                             } else {
    3429. +
  3429.                                 $symbol_hl .= '<| class="sy' . $old_sym . '">';
    3430. +
  3430.                             }
    3431. +
  3431.                         }
    3432. +
  3432.                         $symbol_hl .= $sym_ms;
    3433. +
  3433.                     }
    3434. +
  3434.                     unset($sym_match_syms);
    3435. +
  3435.  
    3436. +
  3436.                     //Close remaining tags and insert the replacement at the right position ...
    3437. +
  3437.                     //Take caution if symbol_hl is empty to avoid doubled closing spans.
    3438. +
  3438.                     if (-1 != $old_sym) {
    3439. +
  3439.                         $symbol_hl .= "|>";
    3440. +
  3440.                     }
    3441. +
  3441.                 } else {
    3442. +
  3442.                     if (!$this->use_classes) {
    3443. +
  3443.                         $symbol_hl = '<| style="' . $this->language_data['STYLES']['SYMBOLS'][0] . '">';
    3444. +
  3444.                     } else {
    3445. +
  3445.                         $symbol_hl = '<| class="sy0">';
    3446. +
  3446.                     }
    3447. +
  3447.                     $symbol_hl .= $symbol_match . '|>';
    3448. +
  3448.                 }
    3449. +
  3449.  
    3450. +
  3450.                 $stuff_to_parse = substr_replace($stuff_to_parse, $symbol_hl, $symbol_offset + $global_offset, $symbol_length);
    3451. +
  3451.  
    3452. +
  3452.                 // since we replace old text with something of different size,
    3453. +
  3453.                 // we'll have to keep track of the differences
    3454. +
  3454.                 $global_offset += strlen($symbol_hl) - $symbol_length;
    3455. +
  3455.             }
    3456. +
  3456.         }
    3457. +
  3457.         //FIX for symbol highlighting ...
    3458. +
    3459. +
  3459.         // Add class/style for regexps
    3460. +
  3460.         foreach (array_keys($this->language_data['REGEXPS']) as $key) {
    3461. +
  3461.             if ($this->lexic_permissions['REGEXPS'][$key]) {
    3462. +
  3462.                 if (is_callable($this->language_data['STYLES']['REGEXPS'][$key])) {
    3463. +
  3463.                     $this->_rx_key = $key;
    3464. +
  3464.                     $stuff_to_parse = preg_replace_callback("/!REG3XP$key!(.*)\|>/U",
    3465. +
  3465.                         array($this, 'handle_regexps_callback'),
    3466. +
  3466.                         $stuff_to_parse);
    3467. +
  3467.                 } else {
    3468. +
  3468.                     if (!$this->use_classes) {
    3469. +
  3469.                         $attributes = ' style="' . $this->language_data['STYLES']['REGEXPS'][$key] . '"';
    3470. +
  3470.                     } else {
    3471. +
  3471.                         if (is_array($this->language_data['REGEXPS'][$key]) &&
    3472. +
  3472.                             array_key_exists(GESHI_CLASS, $this->language_data['REGEXPS'][$key])) {
    3473. +
  3473.                             $attributes = ' class="' .
    3474. +
  3474.                                 $this->language_data['REGEXPS'][$key][GESHI_CLASS] . '"';
    3475. +
  3475.                         } else {
    3476. +
  3476.                            $attributes = ' class="re' . $key . '"';
    3477. +
  3477.                         }
    3478. +
  3478.                     }
    3479. +
  3479.                     $stuff_to_parse = str_replace("!REG3XP$key!", "$attributes", $stuff_to_parse);
    3480. +
  3480.                 }
    3481. +
  3481.             }
    3482. +
  3482.         }
    3483. +
  3483.  
    3484. +
  3484.         // Replace <DOT> with . for urls
    3485. +
  3485.         $stuff_to_parse = str_replace('<DOT>', '.', $stuff_to_parse);
    3486. +
  3486.         // Replace <|UR1| with <a href= for urls also
    3487. +
  3487.         if (isset($this->link_styles[<a href="../geshi/core/_geshi.php.html#defineGESHI_LINK">GESHI_LINK</a>])) {
    3488. +
  3488.             if ($this->use_classes) {
    3489. +
  3489.                 $stuff_to_parse = str_replace('<|UR1|', '<a' . $this->link_target . ' href=', $stuff_to_parse);
    3490. +
  3490.             } else {
    3491. +
  3491.                 $stuff_to_parse = str_replace('<|UR1|', '<a' . $this->link_target . ' style="' . $this->link_styles[<a href="../geshi/core/_geshi.php.html#defineGESHI_LINK">GESHI_LINK</a>] . '" href=', $stuff_to_parse);
    3492. +
  3492.             }
    3493. +
  3493.         } else {
    3494. +
  3494.             $stuff_to_parse = str_replace('<|UR1|', '<a' . $this->link_target . ' href=', $stuff_to_parse);
    3495. +
  3495.         }
    3496. +
  3496.  
    3497. +
  3497.         //
    3498. +
  3498.         // NOW we add the span thingy ;)
    3499. +
  3499.         //
    3500. +
    3501. +
  3501.         $stuff_to_parse = str_replace('<|', '<span', $stuff_to_parse);
    3502. +
  3502.         $stuff_to_parse = str_replace ( '|>', '</span>', $stuff_to_parse );
    3503. +
  3503.         return substr($stuff_to_parse, 1);
    3504. +
  3504.     }
    3505. +
  3505.  
    3506. +
  3506.     /**
    3507. +
  3507.      * Sets the time taken to parse the code
    3508. +
  3508.      *
    3509. +
  3509.      * @param microtime The time when parsing started
    3510. +
  3510.      * @param microtime The time when parsing ended
    3511. +
  3511.      * @since 1.0.2
    3512. +
  3512.      * @access private
    3513. +
  3513.      */
    3514. +
  3514.     function set_time($start_time, $end_time) {
    3515. +
  3515.         $start = explode(' ', $start_time);
    3516. +
  3516.         $end = explode(' ', $end_time);
    3517. +
  3517.         $this->time = $end[0] + $end[1] - $start[0] - $start[1];
    3518. +
  3518.     }
    3519. +
  3519.  
    3520. +
  3520.     /**
    3521. +
  3521.      * Gets the time taken to parse the code
    3522. +
  3522.      *
    3523. +
  3523.      * @return double The time taken to parse the code
    3524. +
  3524.      * @since  1.0.2
    3525. +
  3525.      */
    3526. +
  3526.     function get_time() {
    3527. +
  3527.         return $this->time;
    3528. +
  3528.     }
    3529. +
  3529.  
    3530. +
  3530.     /**
    3531. +
  3531.      * Merges arrays recursively, overwriting values of the first array with values of later arrays
    3532. +
  3532.      *
    3533. +
  3533.      * @since 1.0.8
    3534. +
  3534.      * @access private
    3535. +
  3535.      */
    3536. +
  3536.     function merge_arrays() {
    3537. +
  3537.         $arrays = func_get_args();
    3538. +
  3538.         $narrays = count($arrays);
    3539. +
  3539.  
    3540. +
  3540.         // check arguments
    3541. +
  3541.         // comment out if more performance is necessary (in this case the foreach loop will trigger a warning if the argument is not an array)
    3542. +
  3542.         for ($i = 0; $i < $narrays; $i ++) {
    3543. +
  3543.             if (!is_array($arrays[$i])) {
    3544. +
  3544.                 // also array_merge_recursive returns nothing in this case
    3545. +
  3545.                 trigger_error('Argument #' . ($i+1) . ' is not an array - trying to merge array with scalar! Returning false!', E_USER_WARNING);
    3546. +
  3546.                 return false;
    3547. +
  3547.             }
    3548. +
  3548.         }
    3549. +
  3549.  
    3550. +
  3550.         // the first array is in the output set in every case
    3551. +
  3551.         $ret = $arrays[0];
    3552. +
  3552.  
    3553. +
  3553.         // merege $ret with the remaining arrays
    3554. +
  3554.         for ($i = 1; $i < $narrays; $i ++) {
    3555. +
  3555.             foreach ($arrays[$i] as $key => $value) {
    3556. +
  3556.                 if (is_array($value) && isset($ret[$key])) {
    3557. +
  3557.                     // if $ret[$key] is not an array you try to merge an scalar value with an array - the result is not defined (incompatible arrays)
    3558. +
  3558.                     // in this case the call will trigger an E_USER_WARNING and the $ret[$key] will be false.
    3559. +
  3559.                     $ret[$key] = $this->merge_arrays($ret[$key], $value);
    3560. +
  3560.                 } else {
    3561. +
  3561.                     $ret[$key] = $value;
    3562. +
  3562.                 }
    3563. +
  3563.             }
    3564. +
  3564.         }
    3565. +
  3565.  
    3566. +
  3566.         return $ret;
    3567. +
  3567.     }
    3568. +
  3568.  
    3569. +
  3569.     /**
    3570. +
  3570.      * Gets language information and stores it for later use
    3571. +
  3571.      *
    3572. +
  3572.      * @param string The filename of the language file you want to load
    3573. +
  3573.      * @since 1.0.0
    3574. +
  3574.      * @access private
    3575. +
  3575.      * @todo Needs to load keys for lexic permissions for keywords, regexps etc
    3576. +
  3576.      */
    3577. +
  3577.     function load_language($file_name) {
    3578. +
  3578.         if ($file_name == $this->loaded_language) {
    3579. +
  3579.             // this file is already loaded!
    3580. +
  3580.             return;
    3581. +
  3581.         }
    3582. +
  3582.  
    3583. +
  3583.         //Prepare some stuff before actually loading the language file
    3584. +
  3584.         $this->loaded_language = $file_name;
    3585. +
  3585.         $this->parse_cache_built = false;
    3586. +
  3586.         $this->enable_highlighting();
    3587. +
  3587.         $language_data = array();
    3588. +
  3588.  
    3589. +
  3589.         //Load the language file
    3590. +
  3590.         require $file_name;
    3591. +
  3591.  
    3592. +
  3592.         // Perhaps some checking might be added here later to check that
    3593. +
  3593.         // $language data is a valid thing but maybe not
    3594. +
  3594.         $this->language_data = $language_data;
    3595. +
  3595.  
    3596. +
  3596.         // Set strict mode if should be set
    3597. +
  3597.         $this->strict_mode = $this->language_data['STRICT_MODE_APPLIES'];
    3598. +
  3598.  
    3599. +
  3599.         // Set permissions for all lexics to true
    3600. +
  3600.         // so they'll be highlighted by default
    3601. +
  3601.         foreach (array_keys($this->language_data['KEYWORDS']) as $key) {
    3602. +
  3602.             if (!empty($this->language_data['KEYWORDS'][$key])) {
    3603. +
  3603.                 $this->lexic_permissions['KEYWORDS'][$key] = true;
    3604. +
  3604.             } else {
    3605. +
  3605.                 $this->lexic_permissions['KEYWORDS'][$key] = false;
    3606. +
  3606.             }
    3607. +
  3607.         }
    3608. +
  3608.  
    3609. +
  3609.         foreach (array_keys($this->language_data['COMMENT_SINGLE']) as $key) {
    3610. +
  3610.             $this->lexic_permissions['COMMENTS'][$key] = true;
    3611. +
  3611.         }
    3612. +
  3612.         foreach (array_keys($this->language_data['REGEXPS']) as $key) {
    3613. +
  3613.             $this->lexic_permissions['REGEXPS'][$key] = true;
    3614. +
  3614.         }
    3615. +
  3615.  
    3616. +
  3616.         // for BenBE and future code reviews:
    3617. +
  3617.         // we can use empty here since we only check for existance and emptiness of an array
    3618. +
  3618.         // if it is not an array at all but rather false or null this will work as intended as well
    3619. +
  3619.         // even if $this->language_data['PARSER_CONTROL'] is undefined this won't trigger a notice
    3620. +
  3620.         if (!empty($this->language_data['PARSER_CONTROL']['ENABLE_FLAGS'])) {
    3621. +
  3621.             foreach ($this->language_data['PARSER_CONTROL']['ENABLE_FLAGS'] as $flag => $value) {
    3622. +
  3622.                 // it's either true or false and maybe is true as well
    3623. +
  3623.                 $perm = $value !== GESHI_NEVER;
    3624. +
  3624.                 if ($flag == 'ALL') {
    3625. +
  3625.                     $this->enable_highlighting($perm);
    3626. +
  3626.                     continue;
    3627. +
  3627.                 }
    3628. +
  3628.                 if (!isset($this->lexic_permissions[$flag])) {
    3629. +
  3629.                     // unknown lexic permission
    3630. +
  3630.                     continue;
    3631. +
  3631.                 }
    3632. +
  3632.                 if (is_array($this->lexic_permissions[$flag])) {
    3633. +
  3633.                     foreach ($this->lexic_permissions[$flag] as $key => $val) {
    3634. +
  3634.                         $this->lexic_permissions[$flag][$key] = $perm;
    3635. +
  3635.                     }
    3636. +
  3636.                 } else {
    3637. +
  3637.                     $this->lexic_permissions[$flag] = $perm;
    3638. +
  3638.                 }
    3639. +
  3639.             }
    3640. +
  3640.             unset($this->language_data['PARSER_CONTROL']['ENABLE_FLAGS']);
    3641. +
  3641.         }
    3642. +
  3642.  
    3643. +
  3643.         //NEW in 1.0.8: Allow styles to be loaded from a separate file to override defaults
    3644. +
  3644.         $style_filename = substr($file_name, 0, -4) . '.style.php';
    3645. +
  3645.         if (is_readable($style_filename)) {
    3646. +
  3646.             //Clear any style_data that could have been set before ...
    3647. +
  3647.             if (isset($style_data)) {
    3648. +
  3648.                 unset($style_data);
    3649. +
  3649.             }
    3650. +
  3650.  
    3651. +
  3651.             //Read the Style Information from the style file
    3652. +
  3652.             include $style_filename;
    3653. +
  3653.  
    3654. +
  3654.             //Apply the new styles to our current language styles
    3655. +
  3655.             if (isset($style_data) && is_array($style_data)) {
    3656. +
  3656.                 $this->language_data['STYLES'] =
    3657. +
  3657.                     $this->merge_arrays($this->language_data['STYLES'], $style_data);
    3658. +
  3658.             }
    3659. +
  3659.         }
    3660. +
  3660.     }
    3661. +
  3661.  
    3662. +
  3662.     /**
    3663. +
  3663.      * Takes the parsed code and various options, and creates the HTML
    3664. +
  3664.      * surrounding it to make it look nice.
    3665. +
  3665.      *
    3666. +
  3666.      * @param  string The code already parsed (reference!)
    3667. +
  3667.      * @since  1.0.0
    3668. +
  3668.      * @access private
    3669. +
  3669.      */
    3670. +
  3670.     function finalise(&$parsed_code) {
    3671. +
  3671.         // Remove end parts of important declarations
    3672. +
  3672.         // This is BUGGY!! My fault for bad code: fix coming in 1.2
    3673. +
  3673.         // @todo Remove this crap
    3674. +
  3674.         if ($this->enable_important_blocks &&
    3675. +
  3675.             (strpos($parsed_code, $this->hsc(<a href="../geshi/core/_geshi.php.html#defineGESHI_START_IMPORTANT">GESHI_START_IMPORTANT</a>)) === false)) {
    3676. +
  3676.             $parsed_code = str_replace($this->hsc(<a href="../geshi/core/_geshi.php.html#defineGESHI_END_IMPORTANT">GESHI_END_IMPORTANT</a>), '', $parsed_code);
    3677. +
  3677.         }
    3678. +
  3678.  
    3679. +
  3679.         // Add HTML whitespace stuff if we're using the <div> header
    3680. +
  3680.         if ($this->header_type != <a href="../geshi/core/_geshi.php.html#defineGESHI_HEADER_PRE">GESHI_HEADER_PRE</a> && $this->header_type != <a href="../geshi/core/_geshi.php.html#defineGESHI_HEADER_PRE_VALID">GESHI_HEADER_PRE_VALID</a>) {
    3681. +
  3681.             $this->indent($parsed_code);
    3682. +
  3682.         }
    3683. +
  3683.  
    3684. +
  3684.         // purge some unnecessary stuff
    3685. +
  3685.         /** NOTE: memorypeak #1 */
    3686. +
  3686.         $parsed_code = preg_replace('#<span[^>]+>(\s*)</span>#', '\\1', $parsed_code);
    3687. +
  3687.  
    3688. +
  3688.         // If we are using IDs for line numbers, there needs to be an overall
    3689. +
  3689.         // ID set to prevent collisions.
    3690. +
  3690.         if ($this->add_ids && !$this->overall_id) {
    3691. +
  3691.             $this->overall_id = 'geshi-' . substr(md5(microtime()), 0, 4);
    3692. +
  3692.         }
    3693. +
  3693.  
    3694. +
  3694.         // Get code into lines
    3695. +
  3695.         /** NOTE: memorypeak #2 */
    3696. +
  3696.         $code = explode("\n", $parsed_code);
    3697. +
  3697.         $parsed_code = $this->header();
    3698. +
  3698.  
    3699. +
  3699.         // If we're using line numbers, we insert <li>s and appropriate
    3700. +
  3700.         // markup to style them (otherwise we don't need to do anything)
    3701. +
  3701.         if ($this->line_numbers != <a href="../geshi/core/_geshi.php.html#defineGESHI_NO_LINE_NUMBERS">GESHI_NO_LINE_NUMBERS</a> && $this->header_type != <a href="../geshi/core/_geshi.php.html#defineGESHI_HEADER_PRE_TABLE">GESHI_HEADER_PRE_TABLE</a>) {
    3702. +
  3702.             // If we're using the <pre> header, we shouldn't add newlines because
    3703. +
  3703.             // the <pre> will line-break them (and the <li>s already do this for us)
    3704. +
  3704.             $ls = ($this->header_type != <a href="../geshi/core/_geshi.php.html#defineGESHI_HEADER_PRE">GESHI_HEADER_PRE</a> && $this->header_type != <a href="../geshi/core/_geshi.php.html#defineGESHI_HEADER_PRE_VALID">GESHI_HEADER_PRE_VALID</a>) ? "\n" : '';
    3705. +
  3705.  
    3706. +
  3706.             // Set vars to defaults for following loop
    3707. +
  3707.             $i = 0;
    3708. +
  3708.  
    3709. +
  3709.             // Foreach line...
    3710. +
  3710.             for ($i = 0, $n = count($code); $i < $n;) {
    3711. +
  3711.                 //Reset the attributes for a new line ...
    3712. +
  3712.                 $attrs = array();
    3713. +
  3713.  
    3714. +
  3714.                 // Make lines have at least one space in them if they're empty
    3715. +
  3715.                 // BenBE: Checking emptiness using trim instead of relying on blanks
    3716. +
  3716.                 if ('' == trim($code[$i])) {
    3717. +
  3717.                     $code[$i] = '&nbsp;';
    3718. +
  3718.                 }
    3719. +
  3719.  
    3720. +
  3720.                 // If this is a "special line"...
    3721. +
  3721.                 if ($this->line_numbers == <a href="../geshi/core/_geshi.php.html#defineGESHI_FANCY_LINE_NUMBERS">GESHI_FANCY_LINE_NUMBERS</a> &&
    3722. +
  3722.                     $i % $this->line_nth_row == ($this->line_nth_row - 1)) {
    3723. +
  3723.                     // Set the attributes to style the line
    3724. +
  3724.                     if ($this->use_classes) {
    3725. +
  3725.                         //$attr = ' class="li2"';
    3726. +
  3726.                         $attrs['class'][] = 'li2';
    3727. +
  3727.                         $def_attr = ' class="de2"';
    3728. +
  3728.                     } else {
    3729. +
  3729.                         //$attr = ' style="' . $this->line_style2 . '"';
    3730. +
  3730.                         $attrs['style'][] = $this->line_style2;
    3731. +
  3731.                         // This style "covers up" the special styles set for special lines
    3732. +
  3732.                         // so that styles applied to special lines don't apply to the actual
    3733. +
  3733.                         // code on that line
    3734. +
  3734.                         $def_attr = ' style="' . $this->code_style . '"';
    3735. +
  3735.                     }
    3736. +
  3736.                 } else {
    3737. +
  3737.                     if ($this->use_classes) {
    3738. +
  3738.                         //$attr = ' class="li1"';
    3739. +
  3739.                         $attrs['class'][] = 'li1';
    3740. +
  3740.                         $def_attr = ' class="de1"';
    3741. +
  3741.                     } else {
    3742. +
  3742.                         //$attr = ' style="' . $this->line_style1 . '"';
    3743. +
  3743.                         $attrs['style'][] = $this->line_style1;
    3744. +
  3744.                         $def_attr = ' style="' . $this->code_style . '"';
    3745. +
  3745.                     }
    3746. +
  3746.                 }
    3747. +
  3747.  
    3748. +
  3748.                 //Check which type of tag to insert for this line
    3749. +
  3749.                 if ($this->header_type == <a href="../geshi/core/_geshi.php.html#defineGESHI_HEADER_PRE_VALID">GESHI_HEADER_PRE_VALID</a>) {
    3750. +
  3750.                     $start = "<pre$def_attr>";
    3751. +
  3751.                     $end = '</pre>';
    3752. +
  3752.                 } else {
    3753. +
  3753.                     // Span or div?
    3754. +
  3754.                     $start = "<div$def_attr>";
    3755. +
  3755.                     $end = '</div>';
    3756. +
  3756.                 }
    3757. +
  3757.  
    3758. +
  3758.                 ++$i;
    3759. +
  3759.  
    3760. +
  3760.                 // Are we supposed to use ids? If so, add them
    3761. +
  3761.                 if ($this->add_ids) {
    3762. +
  3762.                     $attrs['id'][] = "$this->overall_id-$i";
    3763. +
  3763.                 }
    3764. +
  3764.  
    3765. +
  3765.                 //Is this some line with extra styles???
    3766. +
  3766.                 if (in_array($i, $this->highlight_extra_lines)) {
    3767. +
  3767.                     if ($this->use_classes) {
    3768. +
  3768.                         if (isset($this->highlight_extra_lines_styles[$i])) {
    3769. +
  3769.                             $attrs['class'][] = "lx$i";
    3770. +
  3770.                         } else {
    3771. +
  3771.                             $attrs['class'][] = "ln-xtra";
    3772. +
  3772.                         }
    3773. +
  3773.                     } else {
    3774. +
  3774.                         array_push($attrs['style'], $this->get_line_style($i));
    3775. +
  3775.                     }
    3776. +
  3776.                 }
    3777. +
  3777.  
    3778. +
  3778.                 // Add in the line surrounded by appropriate list HTML
    3779. +
  3779.                 $attr_string = '';
    3780. +
  3780.                 foreach ($attrs as $key => $attr) {
    3781. +
  3781.                     $attr_string .= ' ' . $key . '="' . implode(' ', $attr) . '"';
    3782. +
  3782.                 }
    3783. +
  3783.  
    3784. +
  3784.                 $parsed_code .= "<li$attr_string>$start{$code[$i-1]}$end</li>$ls";
    3785. +
  3785.                 unset($code[$i - 1]);
    3786. +
  3786.             }
    3787. +
  3787.         } else {
    3788. +
  3788.             $n = count($code);
    3789. +
  3789.             if ($this->use_classes) {
    3790. +
  3790.                 $attributes = ' class="de1"';
    3791. +
  3791.             } else {
    3792. +
  3792.                 $attributes = ' style="'. $this->code_style .'"';
    3793. +
  3793.             }
    3794. +
  3794.             if ($this->header_type == <a href="../geshi/core/_geshi.php.html#defineGESHI_HEADER_PRE_VALID">GESHI_HEADER_PRE_VALID</a>) {
    3795. +
  3795.                 $parsed_code .= '<pre'. $attributes .'>';
    3796. +
  3796.             } elseif ($this->header_type == <a href="../geshi/core/_geshi.php.html#defineGESHI_HEADER_PRE_TABLE">GESHI_HEADER_PRE_TABLE</a>) {
    3797. +
  3797.                 if ($this->line_numbers != <a href="../geshi/core/_geshi.php.html#defineGESHI_NO_LINE_NUMBERS">GESHI_NO_LINE_NUMBERS</a>) {
    3798. +
  3798.                     if ($this->use_classes) {
    3799. +
  3799.                         $attrs = ' class="ln"';
    3800. +
  3800.                     } else {
    3801. +
  3801.                         $attrs = ' style="'. $this->table_linenumber_style .'"';
    3802. +
  3802.                     }
    3803. +
  3803.                     $parsed_code .= '<td'.$attrs.'><pre'.$attributes.'>';
    3804. +
  3804.                     // get linenumbers
    3805. +
  3805.                     // we don't merge it with the for below, since it should be better for
    3806. +
  3806.                     // memory consumption this way
    3807. +
  3807.                     // @todo: but... actually it would still be somewhat nice to merge the two loops
    3808. +
  3808.                     //        the mem peaks are at different positions
    3809. +
  3809.                     for ($i = 0; $i < $n; ++$i) {
    3810. +
  3810.                         $close = 0;
    3811. +
  3811.                         // fancy lines
    3812. +
  3812.                         if ($this->line_numbers == <a href="../geshi/core/_geshi.php.html#defineGESHI_FANCY_LINE_NUMBERS">GESHI_FANCY_LINE_NUMBERS</a> &&
    3813. +
  3813.                             $i % $this->line_nth_row == ($this->line_nth_row - 1)) {
    3814. +
  3814.                             // Set the attributes to style the line
    3815. +
  3815.                             if ($this->use_classes) {
    3816. +
  3816.                                 $parsed_code .= '<span class="xtra li2"><span class="de2">';
    3817. +
  3817.                             } else {
    3818. +
  3818.                                 // This style "covers up" the special styles set for special lines
    3819. +
  3819.                                 // so that styles applied to special lines don't apply to the actual
    3820. +
  3820.                                 // code on that line
    3821. +
  3821.                                 $parsed_code .= '<span style="display:block;' . $this->line_style2 . '">'
    3822. +
  3822.                                                   .'<span style="' . $this->code_style .'">';
    3823. +
  3823.                             }
    3824. +
  3824.                             $close += 2;
    3825. +
  3825.                         }
    3826. +
  3826.                         //Is this some line with extra styles???
    3827. +
  3827.                         if (in_array($i + 1, $this->highlight_extra_lines)) {
    3828. +
  3828.                             if ($this->use_classes) {
    3829. +
  3829.                                 if (isset($this->highlight_extra_lines_styles[$i])) {
    3830. +
  3830.                                     $parsed_code .= "<span class=\"xtra lx$i\">";
    3831. +
  3831.                                 } else {
    3832. +
  3832.                                     $parsed_code .= "<span class=\"xtra ln-xtra\">";
    3833. +
  3833.                                 }
    3834. +
  3834.                             } else {
    3835. +
  3835.                                 $parsed_code .= "<span style=\"display:block;" . $this->get_line_style($i) . "\">";
    3836. +
  3836.                             }
    3837. +
  3837.                             ++$close;
    3838. +
  3838.                         }
    3839. +
  3839.                         $parsed_code .= $this->line_numbers_start + $i;
    3840. +
  3840.                         if ($close) {
    3841. +
  3841.                             $parsed_code .= str_repeat('</span>', $close);
    3842. +
  3842.                         } else if ($i != $n) {
    3843. +
  3843.                             $parsed_code .= "\n";
    3844. +
  3844.                         }
    3845. +
  3845.                     }
    3846. +
  3846.                     $parsed_code .= '</pre></td><td'.$attributes.'>';
    3847. +
  3847.                 }
    3848. +
  3848.                 $parsed_code .= '<pre'. $attributes .'>';
    3849. +
  3849.             }
    3850. +
  3850.             // No line numbers, but still need to handle highlighting lines extra.
    3851. +
  3851.             // Have to use divs so the full width of the code is highlighted
    3852. +
  3852.             $close = 0;
    3853. +
  3853.             for ($i = 0; $i < $n; ++$i) {
    3854. +
  3854.                 // Make lines have at least one space in them if they're empty
    3855. +
  3855.                 // BenBE: Checking emptiness using trim instead of relying on blanks
    3856. +
  3856.                 if ('' == trim($code[$i])) {
    3857. +
  3857.                     $code[$i] = '&nbsp;';
    3858. +
  3858.                 }
    3859. +
  3859.                 // fancy lines
    3860. +
  3860.                 if ($this->line_numbers == <a href="../geshi/core/_geshi.php.html#defineGESHI_FANCY_LINE_NUMBERS">GESHI_FANCY_LINE_NUMBERS</a> &&
    3861. +
  3861.                     $i % $this->line_nth_row == ($this->line_nth_row - 1)) {
    3862. +
  3862.                     // Set the attributes to style the line
    3863. +
  3863.                     if ($this->use_classes) {
    3864. +
  3864.                         $parsed_code .= '<span class="xtra li2"><span class="de2">';
    3865. +
  3865.                     } else {
    3866. +
  3866.                         // This style "covers up" the special styles set for special lines
    3867. +
  3867.                         // so that styles applied to special lines don't apply to the actual
    3868. +
  3868.                         // code on that line
    3869. +
  3869.                         $parsed_code .= '<span style="display:block;' . $this->line_style2 . '">'
    3870. +
  3870.                                           .'<span style="' . $this->code_style .'">';
    3871. +
  3871.                     }
    3872. +
  3872.                     $close += 2;
    3873. +
  3873.                 }
    3874. +
  3874.                 //Is this some line with extra styles???
    3875. +
  3875.                 if (in_array($i + 1, $this->highlight_extra_lines)) {
    3876. +
  3876.                     if ($this->use_classes) {
    3877. +
  3877.                         if (isset($this->highlight_extra_lines_styles[$i])) {
    3878. +
  3878.                             $parsed_code .= "<span class=\"xtra lx$i\">";
    3879. +
  3879.                         } else {
    3880. +
  3880.                             $parsed_code .= "<span class=\"xtra ln-xtra\">";
    3881. +
  3881.                         }
    3882. +
  3882.                     } else {
    3883. +
  3883.                         $parsed_code .= "<span style=\"display:block;" . $this->get_line_style($i) . "\">";
    3884. +
  3884.                     }
    3885. +
  3885.                     ++$close;
    3886. +
  3886.                 }
    3887. +
  3887.  
    3888. +
  3888.                 $parsed_code .= $code[$i];
    3889. +
  3889.  
    3890. +
  3890.                 if ($close) {
    3891. +
  3891.                   $parsed_code .= str_repeat('</span>', $close);
    3892. +
  3892.                   $close = 0;
    3893. +
  3893.                 }
    3894. +
  3894.                 elseif ($i + 1 < $n) {
    3895. +
  3895.                     $parsed_code .= "\n";
    3896. +
  3896.                 }
    3897. +
  3897.                 unset($code[$i]);
    3898. +
  3898.             }
    3899. +
  3899.  
    3900. +
  3900.             if ($this->header_type == <a href="../geshi/core/_geshi.php.html#defineGESHI_HEADER_PRE_VALID">GESHI_HEADER_PRE_VALID</a> || $this->header_type == <a href="../geshi/core/_geshi.php.html#defineGESHI_HEADER_PRE_TABLE">GESHI_HEADER_PRE_TABLE</a>) {
    3901. +
  3901.                 $parsed_code .= '</pre>';
    3902. +
  3902.             }
    3903. +
  3903.             if ($this->header_type == <a href="../geshi/core/_geshi.php.html#defineGESHI_HEADER_PRE_TABLE">GESHI_HEADER_PRE_TABLE</a> && $this->line_numbers != <a href="../geshi/core/_geshi.php.html#defineGESHI_NO_LINE_NUMBERS">GESHI_NO_LINE_NUMBERS</a>) {
    3904. +
  3904.                 $parsed_code .= '</td>';
    3905. +
  3905.             }
    3906. +
  3906.         }
    3907. +
  3907.  
    3908. +
  3908.         $parsed_code .= $this->footer();
    3909. +
  3909.     }
    3910. +
  3910.  
    3911. +
  3911.     /**
    3912. +
  3912.      * Creates the header for the code block (with correct attributes)
    3913. +
  3913.      *
    3914. +
  3914.      * @return string The header for the code block
    3915. +
  3915.      * @since  1.0.0
    3916. +
  3916.      * @access private
    3917. +
  3917.      */
    3918. +
  3918.     function header() {
    3919. +
  3919.         // Get attributes needed
    3920. +
  3920.         /**
    3921. +
  3921.          * @todo   Document behaviour change - class is outputted regardless of whether
    3922. +
  3922.          *         we're using classes or not. Same with style
    3923. +
  3923.          */
    3924. +
  3924.         $attributes = ' class="' . $this->language;
    3925. +
  3925.         if ($this->overall_class != '') {
    3926. +
  3926.             $attributes .= " ".$this->overall_class;
    3927. +
  3927.         }
    3928. +
  3928.         $attributes .= '"';
    3929. +
  3929.  
    3930. +
  3930.         if ($this->overall_id != '') {
    3931. +
  3931.             $attributes .= " id=\"{$this->overall_id}\"";
    3932. +
  3932.         }
    3933. +
  3933.         if ($this->overall_style != '') {
    3934. +
  3934.             $attributes .= ' style="' . $this->overall_style . '"';
    3935. +
  3935.         }
    3936. +
  3936.  
    3937. +
  3937.         $ol_attributes = '';
    3938. +
  3938.  
    3939. +
  3939.         if ($this->line_numbers_start != 1) {
    3940. +
  3940.             $ol_attributes .= ' start="' . $this->line_numbers_start . '"';
    3941. +
  3941.         }
    3942. +
  3942.  
    3943. +
  3943.         // Get the header HTML
    3944. +
  3944.         $header = $this->header_content;
    3945. +
  3945.         if ($header) {
    3946. +
  3946.             if ($this->header_type == <a href="../geshi/core/_geshi.php.html#defineGESHI_HEADER_PRE">GESHI_HEADER_PRE</a> || $this->header_type == <a href="../geshi/core/_geshi.php.html#defineGESHI_HEADER_PRE_VALID">GESHI_HEADER_PRE_VALID</a>) {
    3947. +
  3947.                 $header = str_replace("\n", '', $header);
    3948. +
  3948.             }
    3949. +
  3949.             $header = $this->replace_keywords($header);
    3950. +
  3950.  
    3951. +
  3951.             if ($this->use_classes) {
    3952. +
  3952.                 $attr = ' class="head"';
    3953. +
  3953.             } else {
    3954. +
  3954.                 $attr = " style=\"{$this->header_content_style}\"";
    3955. +
  3955.             }
    3956. +
  3956.             if ($this->header_type == GESHI_HEADER_PRE_TABLE && $this->line_numbers != GESHI_NO_LINE_NUMBERS) {
    3957. +
  3957.                 $header = "<thead><tr><td colspan=\"2\" $attr>$header</td></tr></thead>";
    3958. +
  3958.             } else {
    3959. +
  3959.                 $header = "<div$attr>$header</div>";
    3960. +
  3960.             }
    3961. +
  3961.         }
    3962. +
  3962.  
    3963. +
  3963.         if (GESHI_HEADER_NONE == $this->header_type) {
    3964. +
  3964.             if ($this->line_numbers != GESHI_NO_LINE_NUMBERS) {
    3965. +
  3965.                 return "$header<ol$attributes$ol_attributes>";
    3966. +
  3966.             }
    3967. +
  3967.             return $header . ($this->force_code_block ? '<div>' : '');
    3968. +
  3968.         }
    3969. +
  3969.  
    3970. +
  3970.         // Work out what to return and do it
    3971. +
  3971.         if ($this->line_numbers != <a href="../geshi/core/_geshi.php.html#defineGESHI_NO_LINE_NUMBERS">GESHI_NO_LINE_NUMBERS</a>) {
    3972. +
  3972.             if ($this->header_type == <a href="../geshi/core/_geshi.php.html#defineGESHI_HEADER_PRE">GESHI_HEADER_PRE</a>) {
    3973. +
  3973.                 return "<pre$attributes>$header<ol$ol_attributes>";
    3974. +
  3974.             } else if ($this->header_type == GESHI_HEADER_DIV ||
    3975. +
  3975.                 $this->header_type == GESHI_HEADER_PRE_VALID) {
    3976. +
  3976.                 return "<div$attributes>$header<ol$ol_attributes>";
    3977. +
  3977.             } else if ($this->header_type == GESHI_HEADER_PRE_TABLE) {
    3978. +
  3978.                 return "<table$attributes>$header<tbody><tr class=\"li1\">";
    3979. +
  3979.             }
    3980. +
  3980.         } else {
    3981. +
  3981.             if ($this->header_type == GESHI_HEADER_PRE) {
    3982. +
  3982.                 return "<pre$attributes>$header"  .
    3983. +
  3983.                     ($this->force_code_block ? '<div>' : '');
    3984. +
  3984.             } else {
    3985. +
  3985.                 return "<div$attributes>$header" .
    3986. +
  3986.                     ($this->force_code_block ? '<div>' : '');
    3987. +
  3987.             }
    3988. +
  3988.         }
    3989. +
  3989.     }
    3990. +
  3990.  
    3991. +
  3991.     /**
    3992. +
  3992.      * Returns the footer for the code block.
    3993. +
  3993.      *
    3994. +
  3994.      * @return string The footer for the code block
    3995. +
  3995.      * @since  1.0.0
    3996. +
  3996.      * @access private
    3997. +
  3997.      */
    3998. +
  3998.     function footer() {
    3999. +
  3999.         $footer = $this->footer_content;
    4000. +
  4000.         if ($footer) {
    4001. +
  4001.             if ($this->header_type == <a href="../geshi/core/_geshi.php.html#defineGESHI_HEADER_PRE">GESHI_HEADER_PRE</a>) {
    4002. +
  4002.                 $footer = str_replace("\n", '', $footer);;
    4003. +
  4003.             }
    4004. +
  4004.             $footer = $this->replace_keywords($footer);
    4005. +
  4005.  
    4006. +
  4006.             if ($this->use_classes) {
    4007. +
  4007.                 $attr = ' class="foot"';
    4008. +
  4008.             } else {
    4009. +
  4009.                 $attr = " style=\"{$this->footer_content_style}\"";
    4010. +
  4010.             }
    4011. +
  4011.             if ($this->header_type == GESHI_HEADER_PRE_TABLE && $this->linenumbers != GESHI_NO_LINE_NUMBERS) {
    4012. +
  4012.                 $footer = "<tfoot><tr><td colspan=\"2\">$footer</td></tr></tfoot>";
    4013. +
  4013.             } else {
    4014. +
  4014.                 $footer = "<div$attr>$footer</div>";
    4015. +
  4015.             }
    4016. +
  4016.         }
    4017. +
  4017.  
    4018. +
  4018.         if (GESHI_HEADER_NONE == $this->header_type) {
    4019. +
  4019.             return ($this->line_numbers != GESHI_NO_LINE_NUMBERS) ? '</ol>' . $footer : $footer;
    4020. +
  4020.         }
    4021. +
  4021.  
    4022. +
  4022.         if ($this->header_type == <a href="../geshi/core/_geshi.php.html#defineGESHI_HEADER_DIV">GESHI_HEADER_DIV</a> || $this->header_type == <a href="../geshi/core/_geshi.php.html#defineGESHI_HEADER_PRE_VALID">GESHI_HEADER_PRE_VALID</a>) {
    4023. +
  4023.             if ($this->line_numbers != <a href="../geshi/core/_geshi.php.html#defineGESHI_NO_LINE_NUMBERS">GESHI_NO_LINE_NUMBERS</a>) {
    4024. +
  4024.                 return "</ol>$footer</div>";
    4025. +
  4025.             }
    4026. +
  4026.             return ($this->force_code_block ? '</div>' : '') .
    4027. +
  4027.                 "$footer</div>";
    4028. +
  4028.         }
    4029. +
  4029.         elseif ($this->header_type == GESHI_HEADER_PRE_TABLE) {
    4030. +
  4030.             if ($this->line_numbers != GESHI_NO_LINE_NUMBERS) {
    4031. +
  4031.                 return "</tr></tbody>$footer</table>";
    4032. +
  4032.             }
    4033. +
  4033.             return ($this->force_code_block ? '</div>' : '') .
    4034. +
  4034.                 "$footer</div>";
    4035. +
  4035.         }
    4036. +
  4036.         else {
    4037. +
  4037.             if ($this->line_numbers != GESHI_NO_LINE_NUMBERS) {
    4038. +
  4038.                 return "</ol>$footer</pre>";
    4039. +
  4039.             }
    4040. +
  4040.             return ($this->force_code_block ? '</div>' : '') .
    4041. +
  4041.                 "$footer</pre>";
    4042. +
  4042.         }
    4043. +
  4043.     }
    4044. +
  4044.  
    4045. +
  4045.     /**
    4046. +
  4046.      * Replaces certain keywords in the header and footer with
    4047. +
  4047.      * certain configuration values
    4048. +
  4048.      *
    4049. +
  4049.      * @param  string The header or footer content to do replacement on
    4050. +
  4050.      * @return string The header or footer with replaced keywords
    4051. +
  4051.      * @since  1.0.2
    4052. +
  4052.      * @access private
    4053. +
  4053.      */
    4054. +
  4054.     function replace_keywords($instr) {
    4055. +
  4055.         $keywords = $replacements = array();
    4056. +
  4056.  
    4057. +
  4057.         $keywords[] = '<TIME>';
    4058. +
  4058.         $keywords[] = '{TIME}';
    4059. +
  4059.         $replacements[] = $replacements[] = number_format($time = $this->get_time(), 3);
    4060. +
  4060.  
    4061. +
  4061.         $keywords[] = '<LANGUAGE>';
    4062. +
  4062.         $keywords[] = '{LANGUAGE}';
    4063. +
  4063.         $replacements[] = $replacements[] = $this->language_data['LANG_NAME'];
    4064. +
  4064.  
    4065. +
  4065.         $keywords[] = '<VERSION>';
    4066. +
  4066.         $keywords[] = '{VERSION}';
    4067. +
  4067.         $replacements[] = $replacements[] = <a href="../geshi/core/_geshi.php.html#defineGESHI_VERSION">GESHI_VERSION</a>;
    4068. +
  4068.  
    4069. +
  4069.         $keywords[] = '<SPEED>';
    4070. +
  4070.         $keywords[] = '{SPEED}';
    4071. +
  4071.         if ($time <= 0) {
    4072. +
  4072.             $speed = 'N/A';
    4073. +
  4073.         } else {
    4074. +
  4074.             $speed = strlen($this->source) / $time;
    4075. +
  4075.             if ($speed >= 1024) {
    4076. +
  4076.                 $speed = sprintf("%.2f KB/s", $speed / 1024.0);
    4077. +
  4077.             } else {
    4078. +
  4078.                 $speed = sprintf("%.0f B/s", $speed);
    4079. +
  4079.             }
    4080. +
  4080.         }
    4081. +
  4081.         $replacements[] = $replacements[] = $speed;
    4082. +
  4082.  
    4083. +
  4083.         return str_replace($keywords, $replacements, $instr);
    4084. +
  4084.     }
    4085. +
  4085.  
    4086. +
  4086.     /**
    4087. +
  4087.      * Secure replacement for PHP built-in function htmlspecialchars().
    4088. +
  4088.      *
    4089. +
  4089.      * See ticket #427 (http://wush.net/trac/wikka/ticket/427) for the rationale
    4090. +
  4090.      * for this replacement function.
    4091. +
  4091.      *
    4092. +
  4092.      * The INTERFACE for this function is almost the same as that for
    4093. +
  4093.      * htmlspecialchars(), with the same default for quote style; however, there
    4094. +
  4094.      * is no 'charset' parameter. The reason for this is as follows:
    4095. +
  4095.      *
    4096. +
  4096.      * The PHP docs say:
    4097. +
  4097.      *      "The third argument charset defines character set used in conversion."
    4098. +
  4098.      *
    4099. +
  4099.      * I suspect PHP's htmlspecialchars() is working at the byte-value level and
    4100. +
  4100.      * thus _needs_ to know (or asssume) a character set because the special
    4101. +
  4101.      * characters to be replaced could exist at different code points in
    4102. +
  4102.      * different character sets. (If indeed htmlspecialchars() works at
    4103. +
  4103.      * byte-value level that goes some  way towards explaining why the
    4104. +
  4104.      * vulnerability would exist in this function, too, and not only in
    4105. +
  4105.      * htmlentities() which certainly is working at byte-value level.)
    4106. +
  4106.      *
    4107. +
  4107.      * This replacement function however works at character level and should
    4108. +
  4108.      * therefore be "immune" to character set differences - so no charset
    4109. +
  4109.      * parameter is needed or provided. If a third parameter is passed, it will
    4110. +
  4110.      * be silently ignored.
    4111. +
  4111.      *
    4112. +
  4112.      * In the OUTPUT there is a minor difference in that we use '&#39;' instead
    4113. +
  4113.      * of PHP's '&#039;' for a single quote: this provides compatibility with
    4114. +
  4114.      *      get_html_translation_table(HTML_SPECIALCHARS, ENT_QUOTES)
    4115. +
  4115.      * (see comment by mikiwoz at yahoo dot co dot uk on
    4116. +
  4116.      * http://php.net/htmlspecialchars); it also matches the entity definition
    4117. +
  4117.      * for XML 1.0
    4118. +
  4118.      * (http://www.w3.org/TR/xhtml1/dtds.html#a_dtd_Special_characters).
    4119. +
  4119.      * Like PHP we use a numeric character reference instead of '&apos;' for the
    4120. +
  4120.      * single quote. For the other special characters we use the named entity
    4121. +
  4121.      * references, as PHP is doing.
    4122. +
  4122.      *
    4123. +
  4123.      * @author      {@link http://wikkawiki.org/JavaWoman Marjolein Katsma}
    4124. +
  4124.      *
    4125. +
  4125.      * @license     http://www.gnu.org/copyleft/lgpl.html
    4126. +
  4126.      *              GNU Lesser General Public License
    4127. +
  4127.      * @copyright   Copyright 2007, {@link http://wikkawiki.org/CreditsPage
    4128. +
  4128.      *              Wikka Development Team}
    4129. +
  4129.      *
    4130. +
  4130.      * @access      private
    4131. +
  4131.      * @param       string  $string string to be converted
    4132. +
  4132.      * @param       integer $quote_style
    4133. +
  4133.      *                      - ENT_COMPAT:   escapes &, <, > and double quote (default)
    4134. +
  4134.      *                      - ENT_NOQUOTES: escapes only &, < and >
    4135. +
  4135.      *                      - ENT_QUOTES:   escapes &, <, >, double and single quotes
    4136. +
  4136.      * @return      string  converted string
    4137. +
  4137.      * @since       1.0.7.18
    4138. +
  4138.      */
    4139. +
  4139.     function hsc($string, $quote_style = ENT_COMPAT) {
    4140. +
  4140.         // init
    4141. +
  4141.         static $aTransSpecchar = array(
    4142. +
  4142.             '&' => '&amp;',
    4143. +
  4143.             '"' => '&quot;',
    4144. +
  4144.             '<' => '&lt;',
    4145. +
  4145.             '>' => '&gt;',
    4146. +
  4146.  
    4147. +
  4147.             //This fix is related to SF#1923020, but has to be applied
    4148. +
  4148.             //regardless of actually highlighting symbols.
    4149. +
    4150. +
  4150.             //Circumvent a bug with symbol highlighting
    4151. +
  4151.             //This is required as ; would produce undesirable side-effects if it
    4152. +
  4152.             //was not to be processed as an entity.
    4153. +
  4153.             ';' => '<SEMI>', // Force ; to be processed as entity
    4154. +
  4154.             '|' => '<PIPE>' // Force | to be processed as entity
    4155. +
  4155.             );                      // ENT_COMPAT set
    4156. +
    4157. +
  4157.         switch ($quote_style) {
    4158. +
  4158.             case ENT_NOQUOTES: // don't convert double quotes
    4159. +
  4159.                 unset($aTransSpecchar['"']);
    4160. +
  4160.                 break;
    4161. +
  4161.             case ENT_QUOTES: // convert single quotes as well
    4162. +
  4162.                 $aTransSpecchar["'"] = '&#39;'; // (apos) htmlspecialchars() uses '&#039;'
    4163. +
  4163.                 break;
    4164. +
  4164.         }
    4165. +
  4165.  
    4166. +
  4166.         // return translated string
    4167. +
  4167.         return strtr($string, $aTransSpecchar);
    4168. +
  4168.     }
    4169. +
  4169.  
    4170. +
  4170.     /**
    4171. +
  4171.      * Returns a stylesheet for the highlighted code. If $economy mode
    4172. +
  4172.      * is true, we only return the stylesheet declarations that matter for
    4173. +
  4173.      * this code block instead of the whole thing
    4174. +
  4174.      *
    4175. +
  4175.      * @param  boolean Whether to use economy mode or not
    4176. +
  4176.      * @return string A stylesheet built on the data for the current language
    4177. +
  4177.      * @since  1.0.0
    4178. +
  4178.      */
    4179. +
  4179.     function get_stylesheet($economy_mode = true) {
    4180. +
  4180.         // If there's an error, chances are that the language file
    4181. +
  4181.         // won't have populated the language data file, so we can't
    4182. +
  4182.         // risk getting a stylesheet...
    4183. +
  4183.         if ($this->error) {
    4184. +
  4184.             return '';
    4185. +
  4185.         }
    4186. +
  4186.  
    4187. +
  4187.         //Check if the style rearrangements have been processed ...
    4188. +
  4188.         //This also does some preprocessing to check which style groups are useable ...
    4189. +
  4189.         if(!isset($this->language_data['NUMBERS_CACHE'])) {
    4190. +
  4190.             $this->build_style_cache();
    4191. +
  4191.         }
    4192. +
  4192.  
    4193. +
  4193.         // First, work out what the selector should be. If there's an ID,
    4194. +
  4194.         // that should be used, the same for a class. Otherwise, a selector
    4195. +
  4195.         // of '' means that these styles will be applied anywhere
    4196. +
  4196.         if ($this->overall_id) {
    4197. +
  4197.             $selector = '#' . $this->overall_id;
    4198. +
  4198.         } else {
    4199. +
  4199.             $selector = '.' . $this->language;
    4200. +
  4200.             if ($this->overall_class) {
    4201. +
  4201.                 $selector .= '.' . $this->overall_class;
    4202. +
  4202.             }
    4203. +
  4203.         }
    4204. +
  4204.         $selector .= ' ';
    4205. +
  4205.  
    4206. +
  4206.         // Header of the stylesheet
    4207. +
  4207.         if (!$economy_mode) {
    4208. +
  4208.             $stylesheet = "/**\n".
    4209. +
  4209.                 " * GeSHi Dynamically Generated Stylesheet\n".
    4210. +
  4210.                 " * --------------------------------------\n".
    4211. +
  4211.                 " * Dynamically generated stylesheet for {$this->language}\n".
    4212. +
  4212.                 " * CSS class: {$this->overall_class}, CSS id: {$this->overall_id}\n".
    4213. +
  4213.                 " * GeSHi (C) 2004 - 2007 Nigel McNie, 2007 - 2008 Benny Baumann\n" .
    4214. +
  4214.                 " * (http://qbnz.com/highlighter/ and http://geshi.org/)\n".
    4215. +
  4215.                 " * --------------------------------------\n".
    4216. +
  4216.                 " */\n";
    4217. +
  4217.         } else {
    4218. +
  4218.             $stylesheet = "/**\n".
    4219. +
  4219.                 " * GeSHi (C) 2004 - 2007 Nigel McNie, 2007 - 2008 Benny Baumann\n" .
    4220. +
  4220.                 " * (http://qbnz.com/highlighter/ and http://geshi.org/)\n".
    4221. +
  4221.                 " */\n";
    4222. +
  4222.         }
    4223. +
  4223.  
    4224. +
  4224.         // Set the <ol> to have no effect at all if there are line numbers
    4225. +
  4225.         // (<ol>s have margins that should be destroyed so all layout is
    4226. +
  4226.         // controlled by the set_overall_style method, which works on the
    4227. +
  4227.         // <pre> or <div> container). Additionally, set default styles for lines
    4228. +
  4228.         if (!$economy_mode || $this->line_numbers != <a href="../geshi/core/_geshi.php.html#defineGESHI_NO_LINE_NUMBERS">GESHI_NO_LINE_NUMBERS</a>) {
    4229. +
  4229.             //$stylesheet .= "$selector, {$selector}ol, {$selector}ol li {margin: 0;}\n";
    4230. +
  4230.             $stylesheet .= "$selector.de1, $selector.de2 {{$this->code_style}}\n";
    4231. +
  4231.         }
    4232. +
  4232.  
    4233. +
  4233.         // Add overall styles
    4234. +
  4234.         // note: neglect economy_mode, empty styles are meaningless
    4235. +
  4235.         if ($this->overall_style != '') {
    4236. +
  4236.             $stylesheet .= "$selector {{$this->overall_style}}\n";
    4237. +
  4237.         }
    4238. +
  4238.  
    4239. +
  4239.         // Add styles for links
    4240. +
  4240.         // note: economy mode does not make _any_ sense here
    4241. +
  4241.         //       either the style is empty and thus no selector is needed
    4242. +
  4242.         //       or the appropriate key is given.
    4243. +
  4243.         foreach ($this->link_styles as $key => $style) {
    4244. +
  4244.             if ($style != '') {
    4245. +
  4245.                 switch ($key) {
    4246. +
  4246.                     case <a href="../geshi/core/_geshi.php.html#defineGESHI_LINK">GESHI_LINK</a>:
    4247. +
  4247.                         $stylesheet .= "{$selector}a:link {{$style}}\n";
    4248. +
  4248.                         break;
    4249. +
  4249.                     case GESHI_HOVER:
    4250. +
  4250.                         $stylesheet .= "{$selector}a:hover {{$style}}\n";
    4251. +
  4251.                         break;
    4252. +
  4252.                     case GESHI_ACTIVE:
    4253. +
  4253.                         $stylesheet .= "{$selector}a:active {{$style}}\n";
    4254. +
  4254.                         break;
    4255. +
  4255.                     case GESHI_VISITED:
    4256. +
  4256.                         $stylesheet .= "{$selector}a:visited {{$style}}\n";
    4257. +
  4257.                         break;
    4258. +
  4258.                 }
    4259. +
  4259.             }
    4260. +
  4260.         }
    4261. +
  4261.  
    4262. +
  4262.         // Header and footer
    4263. +
  4263.         // note: neglect economy_mode, empty styles are meaningless
    4264. +
  4264.         if ($this->header_content_style != '') {
    4265. +
  4265.             $stylesheet .= "$selector.head {{$this->header_content_style}}\n";
    4266. +
  4266.         }
    4267. +
  4267.         if ($this->footer_content_style != '') {
    4268. +
  4268.             $stylesheet .= "$selector.foot {{$this->footer_content_style}}\n";
    4269. +
  4269.         }
    4270. +
  4270.  
    4271. +
  4271.         // Styles for important stuff
    4272. +
  4272.         // note: neglect economy_mode, empty styles are meaningless
    4273. +
  4273.         if ($this->important_styles != '') {
    4274. +
  4274.             $stylesheet .= "$selector.imp {{$this->important_styles}}\n";
    4275. +
  4275.         }
    4276. +
  4276.  
    4277. +
  4277.         // Simple line number styles
    4278. +
  4278.         if ((!$economy_mode || $this->line_numbers != GESHI_NO_LINE_NUMBERS) && $this->line_style1 != '') {
    4279. +
  4279.             $stylesheet .= "{$selector}li, {$selector}.li1 {{$this->line_style1}}\n";
    4280. +
  4280.         }
    4281. +
  4281.         if ((!$economy_mode || $this->line_numbers != GESHI_NO_LINE_NUMBERS) && $this->table_linenumber_style != '') {
    4282. +
  4282.             $stylesheet .= "{$selector}.ln {{$this->table_linenumber_style}}\n";
    4283. +
  4283.         }
    4284. +
  4284.         // If there is a style set for fancy line numbers, echo it out
    4285. +
  4285.         if ((!$economy_mode || $this->line_numbers == GESHI_FANCY_LINE_NUMBERS) && $this->line_style2 != '') {
    4286. +
  4286.             $stylesheet .= "{$selector}.li2 {{$this->line_style2}}\n";
    4287. +
  4287.         }
    4288. +
  4288.  
    4289. +
  4289.         // note: empty styles are meaningless
    4290. +
  4290.         foreach ($this->language_data['STYLES']['KEYWORDS'] as $group => $styles) {
    4291. +
  4291.             if ($styles != '' && (!$economy_mode ||
    4292. +
  4292.                 (isset($this->lexic_permissions['KEYWORDS'][$group]) &&
    4293. +
  4293.                 $this->lexic_permissions['KEYWORDS'][$group]))) {
    4294. +
  4294.                 $stylesheet .= "$selector.kw$group {{$styles}}\n";
    4295. +
  4295.             }
    4296. +
  4296.         }
    4297. +
  4297.         foreach ($this->language_data['STYLES']['COMMENTS'] as $group => $styles) {
    4298. +
  4298.             if ($styles != '' && (!$economy_mode ||
    4299. +
  4299.                 (isset($this->lexic_permissions['COMMENTS'][$group]) &&
    4300. +
  4300.                 $this->lexic_permissions['COMMENTS'][$group]) ||
    4301. +
  4301.                 (!empty($this->language_data['COMMENT_REGEXP']) &&
    4302. +
  4302.                 !empty($this->language_data['COMMENT_REGEXP'][$group])))) {
    4303. +
  4303.                 $stylesheet .= "$selector.co$group {{$styles}}\n";
    4304. +
  4304.             }
    4305. +
  4305.         }
    4306. +
  4306.         foreach ($this->language_data['STYLES']['ESCAPE_CHAR'] as $group => $styles) {
    4307. +
  4307.             if ($styles != '' && (!$economy_mode || $this->lexic_permissions['ESCAPE_CHAR'])) {
    4308. +
  4308.                 // NEW: since 1.0.8 we have to handle hardescapes
    4309. +
  4309.                 if ($group === 'HARD') {
    4310. +
  4310.                     $group = '_h';
    4311. +
  4311.                 }
    4312. +
  4312.                 $stylesheet .= "$selector.es$group {{$styles}}\n";
    4313. +
  4313.             }
    4314. +
  4314.         }
    4315. +
  4315.         foreach ($this->language_data['STYLES']['BRACKETS'] as $group => $styles) {
    4316. +
  4316.             if ($styles != '' && (!$economy_mode || $this->lexic_permissions['BRACKETS'])) {
    4317. +
  4317.                 $stylesheet .= "$selector.br$group {{$styles}}\n";
    4318. +
  4318.             }
    4319. +
  4319.         }
    4320. +
  4320.         foreach ($this->language_data['STYLES']['SYMBOLS'] as $group => $styles) {
    4321. +
  4321.             if ($styles != '' && (!$economy_mode || $this->lexic_permissions['SYMBOLS'])) {
    4322. +
  4322.                 $stylesheet .= "$selector.sy$group {{$styles}}\n";
    4323. +
  4323.             }
    4324. +
  4324.         }
    4325. +
  4325.         foreach ($this->language_data['STYLES']['STRINGS'] as $group => $styles) {
    4326. +
  4326.             if ($styles != '' && (!$economy_mode || $this->lexic_permissions['STRINGS'])) {
    4327. +
  4327.                 // NEW: since 1.0.8 we have to handle hardquotes
    4328. +
  4328.                 if ($group === 'HARD') {
    4329. +
  4329.                     $group = '_h';
    4330. +
  4330.                 }
    4331. +
  4331.                 $stylesheet .= "$selector.st$group {{$styles}}\n";
    4332. +
  4332.             }
    4333. +
  4333.         }
    4334. +
  4334.         foreach ($this->language_data['STYLES']['NUMBERS'] as $group => $styles) {
    4335. +
  4335.             if ($styles != '' && (!$economy_mode || $this->lexic_permissions['NUMBERS'])) {
    4336. +
  4336.                 $stylesheet .= "$selector.nu$group {{$styles}}\n";
    4337. +
  4337.             }
    4338. +
  4338.         }
    4339. +
  4339.         foreach ($this->language_data['STYLES']['METHODS'] as $group => $styles) {
    4340. +
  4340.             if ($styles != '' && (!$economy_mode || $this->lexic_permissions['METHODS'])) {
    4341. +
  4341.                 $stylesheet .= "$selector.me$group {{$styles}}\n";
    4342. +
  4342.             }
    4343. +
  4343.         }
    4344. +
  4344.         // note: neglect economy_mode, empty styles are meaningless
    4345. +
  4345.         foreach ($this->language_data['STYLES']['SCRIPT'] as $group => $styles) {
    4346. +
  4346.             if ($styles != '') {
    4347. +
  4347.                 $stylesheet .= "$selector.sc$group {{$styles}}\n";
    4348. +
  4348.             }
    4349. +
  4349.         }
    4350. +
  4350.         foreach ($this->language_data['STYLES']['REGEXPS'] as $group => $styles) {
    4351. +
  4351.             if ($styles != '' && (!$economy_mode ||
    4352. +
  4352.                 (isset($this->lexic_permissions['REGEXPS'][$group]) &&
    4353. +
  4353.                 $this->lexic_permissions['REGEXPS'][$group]))) {
    4354. +
  4354.                 if (is_array($this->language_data['REGEXPS'][$group]) &&
    4355. +
  4355.                     array_key_exists(GESHI_CLASS, $this->language_data['REGEXPS'][$group])) {
    4356. +
  4356.                     $stylesheet .= "$selector.";
    4357. +
  4357.                     $stylesheet .= $this->language_data['REGEXPS'][$group][GESHI_CLASS];
    4358. +
  4358.                     $stylesheet .= " {{$styles}}\n";
    4359. +
  4359.                 } else {
    4360. +
  4360.                     $stylesheet .= "$selector.re$group {{$styles}}\n";
    4361. +
  4361.                 }
    4362. +
  4362.             }
    4363. +
  4363.         }
    4364. +
  4364.         // Styles for lines being highlighted extra
    4365. +
  4365.         if (!$economy_mode || (count($this->highlight_extra_lines)!=count($this->highlight_extra_lines_styles))) {
    4366. +
  4366.             $stylesheet .= "{$selector}.ln-xtra, {$selector}li.ln-xtra, {$selector}div.ln-xtra {{$this->highlight_extra_lines_style}}\n";
    4367. +
  4367.         }
    4368. +
  4368.         $stylesheet .= "{$selector}span.xtra { display:block; }\n";
    4369. +
  4369.         foreach ($this->highlight_extra_lines_styles as $lineid => $linestyle) {
    4370. +
  4370.             $stylesheet .= "{$selector}.lx$lineid, {$selector}li.lx$lineid, {$selector}div.lx$lineid {{$linestyle}}\n";
    4371. +
  4371.         }
    4372. +
  4372.  
    4373. +
  4373.         return $stylesheet;
    4374. +
  4374.     }
    4375. +
  4375.  
    4376. +
  4376.     /**
    4377. +
  4377.      * Get's the style that is used for the specified line
    4378. +
  4378.      *
    4379. +
  4379.      * @param int The line number information is requested for
    4380. +
  4380.      * @access private
    4381. +
  4381.      * @since 1.0.7.21
    4382. +
  4382.      */
    4383. +
  4383.     function get_line_style($line) {
    4384. +
  4384.         //$style = null;
    4385. +
  4385.         $style = null;
    4386. +
  4386.         if (isset($this->highlight_extra_lines_styles[$line])) {
    4387. +
  4387.             $style = $this->highlight_extra_lines_styles[$line];
    4388. +
  4388.         } else { // if no "extra" style assigned
    4389. +
  4389.             $style = $this->highlight_extra_lines_style;
    4390. +
  4390.         }
    4391. +
  4391.  
    4392. +
  4392.         return $style;
    4393. +
  4393.     }
    4394. +
  4394.  
    4395. +
  4395.     /**
    4396. +
  4396.     * this functions creates an optimized regular expression list
    4397. +
  4397.     * of an array of strings.
    4398. +
  4398.     *
    4399. +
  4399.     * Example:
    4400. +
  4400.     * <code>$list = array('faa', 'foo', 'foobar');
    4401. +
  4401.     *          => string 'f(aa|oo(bar)?)'</code>
    4402. +
  4402.     *
    4403. +
  4403.     * @param $list array of (unquoted) strings
    4404. +
  4404.     * @param $regexp_delimiter your regular expression delimiter, @see preg_quote()
    4405. +
  4405.     * @return string for regular expression
    4406. +
  4406.     * @author Milian Wolff <mail@milianw.de>
    4407. +
  4407.     * @since 1.0.8
    4408. +
  4408.     * @access private
    4409. +
  4409.     */
    4410. +
  4410.     function optimize_regexp_list($list, $regexp_delimiter = '/') {
    4411. +
  4411.         $regex_chars = array('.', '\\', '+', '*', '?', '[', '^', ']', '$',
    4412. +
  4412.             '(', ')', '{', '}', '=', '!', '<', '>', '|', ':', $regexp_delimiter);
    4413. +
  4413.         sort($list);
    4414. +
  4414.         $regexp_list = array('');
    4415. +
  4415.         $num_subpatterns = 0;
    4416. +
  4416.         $list_key = 0;
    4417. +
  4417.  
    4418. +
  4418.         // the tokens which we will use to generate the regexp list
    4419. +
  4419.         $tokens = array();
    4420. +
  4420.         $prev_keys = array();
    4421. +
  4421.         // go through all entries of the list and generate the token list
    4422. +
  4422.         $cur_len = 0;
    4423. +
  4423.         for ($i = 0, $i_max = count($list); $i < $i_max; ++$i) {
    4424. +
  4424.             if ($cur_len > GESHI_MAX_PCRE_LENGTH) {
    4425. +
  4425.                 // seems like the length of this pcre is growing exorbitantly
    4426. +
  4426.                 $regexp_list[++$list_key] = $this->_optimize_regexp_list_tokens_to_string($tokens);
    4427. +
  4427.                 $num_subpatterns = substr_count($regexp_list[$list_key], '(?:');
    4428. +
  4428.                 $tokens = array();
    4429. +
  4429.                 $cur_len = 0;
    4430. +
  4430.             }
    4431. +
  4431.             $level = 0;
    4432. +
  4432.             $entry = preg_quote((string) $list[$i], $regexp_delimiter);
    4433. +
  4433.             $pointer = &$tokens;
    4434. +
  4434.             // properly assign the new entry to the correct position in the token array
    4435. +
  4435.             // possibly generate smaller common denominator keys
    4436. +
  4436.             while (true) {
    4437. +
  4437.                 // get the common denominator
    4438. +
  4438.                 if (isset($prev_keys[$level])) {
    4439. +
  4439.                     if ($prev_keys[$level] == $entry) {
    4440. +
  4440.                         // this is a duplicate entry, skip it
    4441. +
  4441.                         continue 2;
    4442. +
  4442.                     }
    4443. +
  4443.                     $char = 0;
    4444. +
  4444.                     while (isset($entry[$char]) && isset($prev_keys[$level][$char])
    4445. +
  4445.                             && $entry[$char] == $prev_keys[$level][$char]) {
    4446. +
  4446.                         ++$char;
    4447. +
  4447.                     }
    4448. +
  4448.                     if ($char > 0) {
    4449. +
  4449.                         // this entry has at least some chars in common with the current key
    4450. +
  4450.                         if ($char == strlen($prev_keys[$level])) {
    4451. +
  4451.                             // current key is totally matched, i.e. this entry has just some bits appended
    4452. +
  4452.                             $pointer = &$pointer[$prev_keys[$level]];
    4453. +
  4453.                         } else {
    4454. +
  4454.                             // only part of the keys match
    4455. +
  4455.                             $new_key_part1 = substr($prev_keys[$level], 0, $char);
    4456. +
  4456.                             $new_key_part2 = substr($prev_keys[$level], $char);
    4457. +
  4457.  
    4458. +
  4458.                             if (in_array($new_key_part1[0], $regex_chars)
    4459. +
  4459.                                 || in_array($new_key_part2[0], $regex_chars)) {
    4460. +
  4460.                                 // this is bad, a regex char as first character
    4461. +
  4461.                                 $pointer[$entry] = array('' => true);
    4462. +
  4462.                                 array_splice($prev_keys, $level, count($prev_keys), $entry);
    4463. +
  4463.                                 $cur_len += strlen($entry);
    4464. +
  4464.                                 continue;
    4465. +
  4465.                             } else {
    4466. +
  4466.                                 // relocate previous tokens
    4467. +
  4467.                                 $pointer[$new_key_part1] = array($new_key_part2 => $pointer[$prev_keys[$level]]);
    4468. +
  4468.                                 unset($pointer[$prev_keys[$level]]);
    4469. +
  4469.                                 $pointer = &$pointer[$new_key_part1];
    4470. +
  4470.                                 // recreate key index
    4471. +
  4471.                                 array_splice($prev_keys, $level, count($prev_keys), array($new_key_part1, $new_key_part2));
    4472. +
  4472.                                 $cur_len += strlen($new_key_part2);
    4473. +
  4473.                             }
    4474. +
  4474.                         }
    4475. +
  4475.                         ++$level;
    4476. +
  4476.                         $entry = substr($entry, $char);
    4477. +
  4477.                         continue;
    4478. +
  4478.                     }
    4479. +
  4479.                     // else: fall trough, i.e. no common denominator was found
    4480. +
  4480.                 }
    4481. +
  4481.                 if ($level == 0 && !empty($tokens)) {
    4482. +
  4482.                     // we can dump current tokens into the string and throw them away afterwards
    4483. +
  4483.                     $new_entry = $this->_optimize_regexp_list_tokens_to_string($tokens);
    4484. +
  4484.                     $new_subpatterns = substr_count($new_entry, '(?:');
    4485. +
  4485.                     if (GESHI_MAX_PCRE_SUBPATTERNS && $num_subpatterns + $new_subpatterns > GESHI_MAX_PCRE_SUBPATTERNS) {
    4486. +
  4486.                         $regexp_list[++$list_key] = $new_entry;
    4487. +
  4487.                         $num_subpatterns = $new_subpatterns;
    4488. +
  4488.                     } else {
    4489. +
  4489.                         if (!empty($regexp_list[$list_key])) {
    4490. +
  4490.                             $new_entry = '|' . $new_entry;
    4491. +
  4491.                         }
    4492. +
  4492.                         $regexp_list[$list_key] .= $new_entry;
    4493. +
  4493.                         $num_subpatterns += $new_subpatterns;
    4494. +
  4494.                     }
    4495. +
  4495.                     $tokens = array();
    4496. +
  4496.                     $cur_len = 0;
    4497. +
  4497.                 }
    4498. +
  4498.                 // no further common denominator found
    4499. +
  4499.                 $pointer[$entry] = array('' => true);
    4500. +
  4500.                 array_splice($prev_keys, $level, count($prev_keys), $entry);
    4501. +
  4501.  
    4502. +
  4502.                 $cur_len += strlen($entry);
    4503. +
  4503.                 break;
    4504. +
  4504.             }
    4505. +
  4505.             unset($list[$i]);
    4506. +
  4506.         }
    4507. +
  4507.         // make sure the last tokens get converted as well
    4508. +
  4508.         $new_entry = $this->_optimize_regexp_list_tokens_to_string($tokens);
    4509. +
  4509.         if (GESHI_MAX_PCRE_SUBPATTERNS && $num_subpatterns + substr_count($new_entry, '(?:') > GESHI_MAX_PCRE_SUBPATTERNS) {
    4510. +
  4510.             $regexp_list[++$list_key] = $new_entry;
    4511. +
  4511.         } else {
    4512. +
  4512.             if (!empty($regexp_list[$list_key])) {
    4513. +
  4513.                 $new_entry = '|' . $new_entry;
    4514. +
  4514.             }
    4515. +
  4515.             $regexp_list[$list_key] .= $new_entry;
    4516. +
  4516.         }
    4517. +
  4517.         return $regexp_list;
    4518. +
  4518.     }
    4519. +
  4519.     /**
    4520. +
  4520.     * this function creates the appropriate regexp string of an token array
    4521. +
  4521.     * you should not call this function directly, @see $this->optimize_regexp_list().
    4522. +
  4522.     *
    4523. +
  4523.     * @param &$tokens array of tokens
    4524. +
  4524.     * @param $recursed bool to know wether we recursed or not
    4525. +
  4525.     * @return string
    4526. +
  4526.     * @author Milian Wolff <mail@milianw.de>
    4527. +
  4527.     * @since 1.0.8
    4528. +
  4528.     * @access private
    4529. +
  4529.     */
    4530. +
  4530.     function _optimize_regexp_list_tokens_to_string(&$tokens, $recursed = false) {
    4531. +
  4531.         $list = '';
    4532. +
  4532.         foreach ($tokens as $token => $sub_tokens) {
    4533. +
  4533.             $list .= $token;
    4534. +
  4534.             $close_entry = isset($sub_tokens['']);
    4535. +
  4535.             unset($sub_tokens['']);
    4536. +
  4536.             if (!empty($sub_tokens)) {
    4537. +
  4537.                 $list .= '(?:' . $this->_optimize_regexp_list_tokens_to_string($sub_tokens, true) . ')';
    4538. +
  4538.                 if ($close_entry) {
    4539. +
  4539.                     // make sub_tokens optional
    4540. +
  4540.                     $list .= '?';
    4541. +
  4541.                 }
    4542. +
  4542.             }
    4543. +
  4543.             $list .= '|';
    4544. +
  4544.         }
    4545. +
  4545.         if (!$recursed) {
    4546. +
  4546.             // do some optimizations
    4547. +
  4547.             // common trailing strings
    4548. +
  4548.             // BUGGY!
    4549. +
  4549.             //$list = preg_replace_callback('#(?<=^|\:|\|)\w+?(\w+)(?:\|.+\1)+(?=\|)#', create_function(
    4550. +
  4550.             //    '$matches', 'return "(?:" . preg_replace("#" . preg_quote($matches[1], "#") . "(?=\||$)#", "", $matches[0]) . ")" . $matches[1];'), $list);
    4551. +
  4551.             // (?:p)? => p?
    4552. +
  4552.             $list = preg_replace('#\(\?\:(.)\)\?#', '\1?', $list);
    4553. +
  4553.             // (?:a|b|c|d|...)? => [abcd...]?
    4554. +
  4554.             // TODO: a|bb|c => [ac]|bb
    4555. +
  4555.             static $callback_2;
    4556. +
  4556.             if (!isset($callback_2)) {
    4557. +
  4557.                 $callback_2 = create_function('$matches', 'return "[" . str_replace("|", "", $matches[1]) . "]";');
    4558. +
  4558.             }
    4559. +
  4559.             $list = preg_replace_callback('#\(\?\:((?:.\|)+.)\)#', $callback_2, $list);
    4560. +
  4560.         }
    4561. +
  4561.         // return $list without trailing pipe
    4562. +
  4562.         return substr($list, 0, -1);
    4563. +
  4563.     }
    4564. +
  4564. } // End Class GeSHi
    4565. +
  4565.  
    4566. +
  4566.  
    4567. +
  4567. if (!function_exists('geshi_highlight')) {
    4568. +
  4568.     /**
    4569. +
  4569.      * Easy way to highlight stuff. Behaves just like highlight_string
    4570. +
  4570.      *
    4571. +
  4571.      * @param string The code to highlight
    4572. +
  4572.      * @param string The language to highlight the code in
    4573. +
  4573.      * @param string The path to the language files. You can leave this blank if you need
    4574. +
  4574.      *               as from version 1.0.7 the path should be automatically detected
    4575. +
  4575.      * @param boolean Whether to return the result or to echo
    4576. +
  4576.      * @return string The code highlighted (if $return is true)
    4577. +
  4577.      * @since 1.0.2
    4578. +
  4578.      */
    4579. +
  4579.     function geshi_highlight($string, $language, $path = null, $return = false) {
    4580. +
  4580.         $geshi = new GeSHi($string, $language, $path);
    4581. +
  4581.         $geshi->set_header_type(GESHI_HEADER_NONE);
    4582. +
  4582.  
    4583. +
  4583.         if ($return) {
    4584. +
  4584.             return '<code>' . $geshi->parse_code() . '</code>';
    4585. +
  4585.         }
    4586. +
  4586.  
    4587. +
  4587.         echo '<code>' . $geshi->parse_code() . '</code>';
    4588. +
  4588.  
    4589. +
  4589.         if ($geshi->error()) {
    4590. +
  4590.             return false;
    4591. +
  4591.         }
    4592. +
  4592.         return true;
    4593. +
  4593.     }
    4594. +
  4594. }
    4595. +
  4595.  
    4596. +
  4596. ?>
    4597. +
+
+

+ Documentation generated on Thu, 25 Dec 2008 14:34:52 +0100 by phpDocumentor 1.4.2 +

+ + \ No newline at end of file -- cgit v1.2.2