PageRenderTime 57ms CodeModel.GetById 25ms RepoModel.GetById 0ms app.codeStats 1ms

/inc/app/sitellite/lib/geshi/contrib/langcheck.php

https://github.com/lux/sitellite
PHP | 673 lines | 594 code | 65 blank | 14 comment | 218 complexity | 7eba41a6135025ed4b6ba10ad252dd70 MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.1, Apache-2.0, GPL-3.0 
    

  1. <?php
    2. 

  2. /**
    3. 

  3.  * GeSHi example script
    4. 

  4.  *
    5. 

  5.  * Just point your browser at this script (with geshi.php in the parent directory,
    6. 

  6.  * and the language files in subdirectory "../geshi/")
    7. 

  7.  *
    8. 

  8.  * @author  Nigel McNie
    9. 

  9.  * @version $Id: langcheck.php 2091 2009-05-23 13:11:36Z benbe $
    10. 

  10.  */
    11. 

  11. header('Content-Type: text/html; charset=utf-8');
    12. 

  12. 

  13. set_time_limit(0);
    14. 

  14. error_reporting(E_ALL);
    15. 

  15. $time_start = explode(' ', microtime());
    16. 

  16. 

  17. define ('TYPE_NOTICE', 0);
    18. 

  18. define ('TYPE_WARNING', 1);
    19. 

  19. define ('TYPE_ERROR', 2);
    20. 

  20. 

  21. $error_abort = false;
    22. 

  22. $error_cache = array();
    23. 

  23. function output_error_cache(){
    24. 

  24.     global $error_cache, $error_abort;
    25. 

  25. 

  26.     if(count($error_cache)) {
    27. 

  27.         echo "<span style=\"color: #F00; font-weight: bold;\">Failed</span><br />";
    28. 

  28.         echo "<ol>\n";
    29. 

  29.         foreach($error_cache as $error_msg) {
    30. 

  30.             echo "<li>";
    31. 

  31.             switch($error_msg['t']) {
    32. 

  32.                 case TYPE_NOTICE:
    33. 

  33.                     echo "<span style=\"color: #080; font-weight: bold;\">NOTICE:</span>";
    34. 

  34.                     break;
    35. 

  35.                 case TYPE_WARNING:
    36. 

  36.                     echo "<span style=\"color: #CC0; font-weight: bold;\">WARNING:</span>";
    37. 

  37.                     break;
    38. 

  38.                 case TYPE_ERROR:
    39. 

  39.                     echo "<span style=\"color: #F00; font-weight: bold;\">ERROR:</span>";
    40. 

  40.                     break;
    41. 

  41.             }
    42. 

  42.             echo " " . $error_msg['m'] . "</li>";
    43. 

  43.         }
    44. 

  44.         echo "</ol>\n";
    45. 

  45.     } else {
    46. 

  46.         echo "<span style=\"color: #080; font-weight: bold;\">OK</span><br />";
    47. 

  47.     }
    48. 

  48.     echo "\n";
    49. 

  49. 

  50.     $error_cache = array();
    51. 

  51. }
    52. 

  52. 

  53. function report_error($type, $message) {
    54. 

  54.     global $error_cache, $error_abort;
    55. 

  55. 

  56.     $error_cache[] = array('t' => $type, 'm' => $message);
    57. 

  57.     if(TYPE_ERROR == $type) {
    58. 

  58.         $error_abort = true;
    59. 

  59.     }
    60. 

  60. }
    61. 

  61. 

  62. function dupfind_strtolower(&$value){
    63. 

  63.     $value = strtolower($value);
    64. 

  64. }
    65. 

  65. 

  66. ?>
    67. 

  67. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
    68. 

  68.      "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
    69. 

  69. <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
    70. 

  70. <head>
    71. 

  71.     <title>GeSHi Language File Validation Script</title>
    72. 

  72.     <style type="text/css">
    73. 

  73.     <!--
    74. 

  74.     html {
    75. 

  75.         background-color: #f0f0f0;
    76. 

  76.     }
    77. 

  77.     body {
    78. 

  78.         font-family: Verdana, Arial, sans-serif;
    79. 

  79.         margin: 10px;
    80. 

  80.         border: 2px solid #e0e0e0;
    81. 

  81.         background-color: #fcfcfc;
    82. 

  82.         padding: 5px;
    83. 

  83.         font-size: 10pt;
    84. 

  84.     }
    85. 

  85.     h2 {
    86. 

  86.         margin: .1em 0 .2em .5em;
    87. 

  87.         border-bottom: 1px solid #b0b0b0;
    88. 

  88.         color: #b0b0b0;
    89. 

  89.         font-weight: normal;
    90. 

  90.         font-size: 150%;
    91. 

  91.     }
    92. 

  92.     h3 {
    93. 

  93.         margin: .1em 0 .2em .5em;
    94. 

  94.         color: #b0b0b0;
    95. 

  95.         font-weight: normal;
    96. 

  96.         font-size: 120%;
    97. 

  97.     }
    98. 

  98.     #footer {
    99. 

  99.         text-align: center;
    100. 

  100.         font-size: 80%;
    101. 

  101.         color: #a9a9a9;
    102. 

  102.     }
    103. 

  103.     #footer a {
    104. 

  104.         color: #9999ff;
    105. 

  105.     }
    106. 

  106.     textarea {
    107. 

  107.         border: 1px solid #b0b0b0;
    108. 

  108.         font-size: 90%;
    109. 

  109.         color: #333;
    110. 

  110.         margin-left: 20px;
    111. 

  111.     }
    112. 

  112.     select, input {
    113. 

  113.         margin-left: 20px;
    114. 

  114.     }
    115. 

  115.     p {
    116. 

  116.         font-size: 90%;
    117. 

  117.         margin-left: .5em;
    118. 

  118.     }
    119. 

  119.     -->
    120. 

  120.     </style>
    121. 

  121. </head>
    122. 

  122. <body>
    123. 

  123. <h2>GeSHi Language File Validation Script</h2>
    124. 

  124. <p>To use this script, make sure that <strong>geshi.php</strong> is in the
    125. 

  125. parent directory or in your include_path, and that the language files are in a
    126. 

  126. subdirectory of GeSHi's directory called <strong>geshi/</strong>.</p>
    127. 

  127. <p>Everything else will be done by this script automatically. After the script
    128. 

  128. finished you should see messages of what could cause trouble with GeSHi or where
    129. 

  129. your language files can be improved. Please be patient, as this might take some time.</p>
    130. 

  130. 

  131. <ol>
    132. 

  132. <li>Checking where to find GeSHi installation ... <?php
    133. 

  133. // Rudimentary checking of where GeSHi is. In a default install it will be in ../, but
    134. 

  134. // it could be in the current directory if the include_path is set. There's nowhere else
    135. 

  135. // we can reasonably guess.
    136. 

  136. if (is_readable('../geshi.php')) {
    137. 

  137.     $path = '../';
    138. 

  138. } elseif (is_readable('geshi.php')) {
    139. 

  139.     $path = './';
    140. 

  140. } else {
    141. 

  141.     report_error(TYPE_ERROR, 'Could not find geshi.php - make sure it is in your include path!');
    142. 

  142. }
    143. 

  143. 

  144. if(!$error_abort) {
    145. 

  145.     require $path . 'geshi.php';
    146. 

  146. 

  147.     if(!class_exists('GeSHi')) {
    148. 

  148.         report_error(TYPE_ERROR, 'The GeSHi class was not found, although it seemed we loaded the correct file!');
    149. 

  149.     }
    150. 

  150. }
    151. 

  151. 

  152. if(!$error_abort) {
    153. 

  153.     if(!defined('GESHI_LANG_ROOT')) {
    154. 

  154.         report_error(TYPE_ERROR, 'There\'s no information present on where to find the language files!');
    155. 

  155.     } else if(!is_dir(GESHI_LANG_ROOT)) {
    156. 

  156.         report_error(TYPE_ERROR, 'The path "'.GESHI_LANG_ROOT.'" given, does not ressemble a directory!');
    157. 

  157.     } else if(!is_readable(GESHI_LANG_ROOT)) {
    158. 

  158.         report_error(TYPE_ERROR, 'The path "'.GESHI_LANG_ROOT.'" is not readable to this script!');
    159. 

  159.     }
    160. 

  160. }
    161. 

  161. 

  162. output_error_cache();
    163. 

  163. 

  164. if(!$error_abort) {
    165. 

  165.     echo "</li>\n<li>Listing available language files ... ";
    166. 

  166. 

  167.     if (!($dir = @opendir(GESHI_LANG_ROOT))) {
    168. 

  168.         report_error(TYPE_ERROR, 'Error requesting listing for available language files!');
    169. 

  169.     }
    170. 

  170. 

  171.     $languages = array();
    172. 

  172. 

  173.     if(!$error_abort) {
    174. 

  174.         while ($file = readdir($dir)) {
    175. 

  175.             if (!$file || $file[0] == '.' || strpos($file, '.') === false) {
    176. 

  176.                 continue;
    177. 

  177.             }
    178. 

  178.             $lang = substr($file, 0,  strpos($file, '.'));
    179. 

  179.             $languages[] = $lang;
    180. 

  180.         }
    181. 

  181.         closedir($dir);
    182. 

  182.     }
    183. 

  183. 

  184.     $languages = array_unique($languages);
    185. 

  185.     sort($languages);
    186. 

  186. 

  187.     if(!count($languages)) {
    188. 

  188.         report_error(TYPE_WARNING, 'Unable to locate any usable language files in "'.GESHI_LANG_ROOT.'"!');
    189. 

  189.     }
    190. 

  190. 

  191.     output_error_cache();
    192. 

  192. }
    193. 

  193. 

  194. if (isset($_REQUEST['show']) && in_array($_REQUEST['show'], $languages)) {
    195. 

  195.     $languages = array($_REQUEST['show']);
    196. 

  196. }
    197. 

  197. 

  198. if(!$error_abort) {
    199. 

  199.     foreach ($languages as $lang) {
    200. 

  200.         echo "</li>\n<li>Validating language file for '$lang' ... ";
    201. 

  201. 

  202.         $langfile = GESHI_LANG_ROOT . $lang . '.php';
    203. 

  203. 

  204.         unset($language_data);
    205. 

  205. 

  206.         if(!is_file($langfile)) {
    207. 

  207.             report_error(TYPE_ERROR, 'The path "' .$langfile. '" does not ressemble a regular file!');
    208. 

  208.         } else if(!is_readable($langfile)) {
    209. 

  209.             report_error(TYPE_ERROR, 'Cannot read file "' .$langfile. '"!');
    210. 

  210.         } else {
    211. 

  211.             $langfile_content = file_get_contents($langfile);
    212. 

  212.             if(preg_match("/\?>(?:\r?\n|\r(?!\n)){2,}\Z/", $langfile_content)) {
    213. 

  213.                 report_error(TYPE_ERROR, 'Language file contains trailing empty lines at EOF!');
    214. 

  214.             }
    215. 

  215.             if(!preg_match("/\?>(?:\r?\n|\r(?!\n))?\Z/", $langfile_content)) {
    216. 

  216.                 report_error(TYPE_ERROR, 'Language file contains no PHP end marker at EOF!');
    217. 

  217.             }
    218. 

  218.             if(preg_match("/\t/", $langfile_content)) {
    219. 

  219.                 report_error(TYPE_NOTICE, 'Language file contains unescaped tabulator chars (probably for indentation)!');
    220. 

  220.             }
    221. 

  221.             if(preg_match('/^(?:    )*(?!    )(?! \*) /m', $langfile_content)) {
    222. 

  222.                 report_error(TYPE_NOTICE, 'Language file contains irregular indentation (other than 4 spaces per indentation level)!');
    223. 

  223.             }
    224. 

  224. 

  225.             if(!preg_match("/\/\*\*((?!\*\/).)*?Author:((?!\*\/).)*?\*\//s", $langfile_content)) {
    226. 

  226.                 report_error(TYPE_WARNING, 'Language file does not contain a specification of an author!');
    227. 

  227.             }
    228. 

  228.             if(!preg_match("/\/\*\*((?!\*\/).)*?Copyright:((?!\*\/).)*?\*\//s", $langfile_content)) {
    229. 

  229.                 report_error(TYPE_WARNING, 'Language file does not contain a specification of the copyright!');
    230. 

  230.             }
    231. 

  231.             if(!preg_match("/\/\*\*((?!\*\/).)*?Release Version:((?!\*\/).)*?\*\//s", $langfile_content)) {
    232. 

  232.                 report_error(TYPE_WARNING, 'Language file does not contain a specification of the release version!');
    233. 

  233.             }
    234. 

  234.             if(!preg_match("/\/\*\*((?!\*\/).)*?Date Started:((?!\*\/).)*?\*\//s", $langfile_content)) {
    235. 

  235.                 report_error(TYPE_WARNING, 'Language file does not contain a specification of the date it was started!');
    236. 

  236.             }
    237. 

  237.             if(!preg_match("/\/\*\*((?!\*\/).)*?This file is part of GeSHi\.((?!\*\/).)*?\*\//s", $langfile_content)) {
    238. 

  238.                 report_error(TYPE_WARNING, 'Language file does not state that it belongs to GeSHi!');
    239. 

  239.             }
    240. 

  240.             if(!preg_match("/\/\*\*((?!\*\/).)*?language file for GeSHi\.((?!\*\/).)*?\*\//s", $langfile_content)) {
    241. 

  241.                 report_error(TYPE_WARNING, 'Language file does not state that it is a language file for GeSHi!');
    242. 

  242.             }
    243. 

  243.             if(!preg_match("/\/\*\*((?!\*\/).)*?GNU General Public License((?!\*\/).)*?\*\//s", $langfile_content)) {
    244. 

  244.                 report_error(TYPE_WARNING, 'Language file does not state that it is provided under the terms of the GNU GPL!');
    245. 

  245.             }
    246. 

  246. 

  247.             unset($langfile_content);
    248. 

  248. 

  249.             include $langfile;
    250. 

  250. 

  251.             if(!isset($language_data)) {
    252. 

  252.                 report_error(TYPE_ERROR, 'Language file does not contain a $language_data structure to check!');
    253. 

  253.             } else if (!is_array($language_data)) {
    254. 

  254.                 report_error(TYPE_ERROR, 'Language file contains a $language_data structure which is not an array!');
    255. 

  255.             }
    256. 

  256.         }
    257. 

  257. 

  258.         if(!$error_abort) {
    259. 

  259.             if(!isset($language_data['LANG_NAME'])) {
    260. 

  260.                 report_error(TYPE_ERROR, 'Language file contains no $language_data[\'LANG_NAME\'] specification!');
    261. 

  261.             } else if (!is_string($language_data['LANG_NAME'])) {
    262. 

  262.                 report_error(TYPE_ERROR, 'Language file contains a $language_data[\'LANG_NAME\'] specification which is not a string!');
    263. 

  263.             }
    264. 

  264. 

  265.             if(!isset($language_data['COMMENT_SINGLE'])) {
    266. 

  266.                 report_error(TYPE_ERROR, 'Language file contains no $language_data[\'COMMENT_SIGNLE\'] structure to check!');
    267. 

  267.             } else if (!is_array($language_data['COMMENT_SINGLE'])) {
    268. 

  268.                 report_error(TYPE_ERROR, 'Language file contains a $language_data[\'COMMENT_SINGLE\'] structure which is not an array!');
    269. 

  269.             }
    270. 

  270. 

  271.             if(!isset($language_data['COMMENT_MULTI'])) {
    272. 

  272.                 report_error(TYPE_ERROR, 'Language file contains no $language_data[\'COMMENT_MULTI\'] structure to check!');
    273. 

  273.             } else if (!is_array($language_data['COMMENT_MULTI'])) {
    274. 

  274.                 report_error(TYPE_ERROR, 'Language file contains a $language_data[\'COMMENT_MULTI\'] structure which is not an array!');
    275. 

  275.             }
    276. 

  276. 

  277.             if(isset($language_data['COMMENT_REGEXP'])) {
    278. 

  278.                 if (!is_array($language_data['COMMENT_REGEXP'])) {
    279. 

  279.                     report_error(TYPE_ERROR, 'Language file contains a $language_data[\'COMMENT_REGEXP\'] structure which is not an array!');
    280. 

  280.                 }
    281. 

  281.             }
    282. 

  282. 

  283.             if(!isset($language_data['QUOTEMARKS'])) {
    284. 

  284.                 report_error(TYPE_ERROR, 'Language file contains no $language_data[\'QUOTEMARKS\'] structure to check!');
    285. 

  285.             } else if (!is_array($language_data['QUOTEMARKS'])) {
    286. 

  286.                 report_error(TYPE_ERROR, 'Language file contains a $language_data[\'QUOTEMARKS\'] structure which is not an array!');
    287. 

  287.             }
    288. 

  288. 

  289.             if(isset($language_data['HARDQUOTE'])) {
    290. 

  290.                 if (!is_array($language_data['HARDQUOTE'])) {
    291. 

  291.                     report_error(TYPE_ERROR, 'Language file contains a $language_data[\'HARDQUOTE\'] structure which is not an array!');
    292. 

  292.                 }
    293. 

  293.             }
    294. 

  294. 

  295.             if(!isset($language_data['ESCAPE_CHAR'])) {
    296. 

  296.                 report_error(TYPE_ERROR, 'Language file contains no $language_data[\'ESCAPE_CHAR\'] specification to check!');
    297. 

  297.             } else if (!is_string($language_data['ESCAPE_CHAR'])) {
    298. 

  298.                 report_error(TYPE_ERROR, 'Language file contains a $language_data[\'ESCAPE_CHAR\'] specification which is not a string!');
    299. 

  299.             } else if (1 < strlen($language_data['ESCAPE_CHAR'])) {
    300. 

  300.                 report_error(TYPE_ERROR, 'Language file contains a $language_data[\'ESCAPE_CHAR\'] specification is not empty or exactly one char!');
    301. 

  301.             }
    302. 

  302. 

  303.             if(!isset($language_data['CASE_KEYWORDS'])) {
    304. 

  304.                 report_error(TYPE_ERROR, 'Language file contains no $language_data[\'CASE_KEYWORDS\'] specification!');
    305. 

  305.             } else if (!is_int($language_data['CASE_KEYWORDS'])) {
    306. 

  306.                 report_error(TYPE_ERROR, 'Language file contains a $language_data[\'CASE_KEYWORDS\'] specification which is not an integer!');
    307. 

  307.             } else if (GESHI_CAPS_NO_CHANGE != $language_data['CASE_KEYWORDS'] &&
    308. 

  308.                 GESHI_CAPS_LOWER != $language_data['CASE_KEYWORDS'] &&
    309. 

  309.                 GESHI_CAPS_UPPER != $language_data['CASE_KEYWORDS']) {
    310. 

  310.                 report_error(TYPE_ERROR, 'Language file contains a $language_data[\'CASE_KEYWORDS\'] specification which is neither of GESHI_CAPS_NO_CHANGE, GESHI_CAPS_LOWER nor GESHI_CAPS_UPPER!');
    311. 

  311.             }
    312. 

  312. 

  313.             if(!isset($language_data['KEYWORDS'])) {
    314. 

  314.                 report_error(TYPE_ERROR, 'Language file contains no $language_data[\'KEYWORDS\'] structure to check!');
    315. 

  315.             } else if (!is_array($language_data['KEYWORDS'])) {
    316. 

  316.                 report_error(TYPE_ERROR, 'Language file contains a $language_data[\'KEYWORDS\'] structure which is not an array!');
    317. 

  317.             } else {
    318. 

  318.                 foreach($language_data['KEYWORDS'] as $kw_key => $kw_value) {
    319. 

  319.                     if(!is_integer($kw_key)) {
    320. 

  320.                         report_error(TYPE_WARNING, "Language file contains an key '$kw_key' in \$language_data['KEYWORDS'] that is not integer!");
    321. 

  321.                     } else if (!is_array($kw_value)) {
    322. 

  322.                         report_error(TYPE_ERROR, "Language file contains a \$language_data['CASE_SENSITIVE']['$kw_value'] structure which is not an array!");
    323. 

  323.                     }
    324. 

  324.                 }
    325. 

  325.             }
    326. 

  326. 

  327.             if(!isset($language_data['SYMBOLS'])) {
    328. 

  328.                 report_error(TYPE_ERROR, 'Language file contains no $language_data[\'SYMBOLS\'] structure to check!');
    329. 

  329.             } else if (!is_array($language_data['SYMBOLS'])) {
    330. 

  330.                 report_error(TYPE_ERROR, 'Language file contains a $language_data[\'SYMBOLS\'] structure which is not an array!');
    331. 

  331.             }
    332. 

  332. 

  333.             if(!isset($language_data['CASE_SENSITIVE'])) {
    334. 

  334.                 report_error(TYPE_ERROR, 'Language file contains no $language_data[\'CASE_SENSITIVE\'] structure to check!');
    335. 

  335.             } else if (!is_array($language_data['CASE_SENSITIVE'])) {
    336. 

  336.                 report_error(TYPE_ERROR, 'Language file contains a $language_data[\'CASE_SENSITIVE\'] structure which is not an array!');
    337. 

  337.             } else {
    338. 

  338.                 foreach($language_data['CASE_SENSITIVE'] as $cs_key => $cs_value) {
    339. 

  339.                     if(!is_integer($cs_key)) {
    340. 

  340.                         report_error(TYPE_WARNING, "Language file contains an key '$cs_key' in \$language_data['CASE_SENSITIVE'] that is not integer!");
    341. 

  341.                     } else if (!is_bool($cs_value)) {
    342. 

  342.                         report_error(TYPE_ERROR, "Language file contains a Case Sensitivity specification for \$language_data['CASE_SENSITIVE']['$cs_value'] which is not a boolean!");
    343. 

  343.                     }
    344. 

  344.                 }
    345. 

  345.             }
    346. 

  346. 

  347.             if(!isset($language_data['URLS'])) {
    348. 

  348.                 report_error(TYPE_ERROR, 'Language file contains no $language_data[\'URLS\'] structure to check!');
    349. 

  349.             } else if (!is_array($language_data['URLS'])) {
    350. 

  350.                 report_error(TYPE_ERROR, 'Language file contains a $language_data[\'URLS\'] structure which is not an array!');
    351. 

  351.             } else {
    352. 

  352.                 foreach($language_data['URLS'] as $url_key => $url_value) {
    353. 

  353.                     if(!is_integer($url_key)) {
    354. 

  354.                         report_error(TYPE_WARNING, "Language file contains an key '$url_key' in \$language_data['URLS'] that is not integer!");
    355. 

  355.                     } else if (!is_string($url_value)) {
    356. 

  356.                         report_error(TYPE_ERROR, "Language file contains a Documentation URL specification for \$language_data['URLS']['$url_value'] which is not a string!");
    357. 

  357.                     } else if (preg_match('#&([^;]*(=|$))#U', $url_value)) {
    358. 

  358.                         report_error(TYPE_ERROR, "Language file contains unescaped ampersands (&amp;) in \$language_data['URLS']!");
    359. 

  359.                     }
    360. 

  360.                 }
    361. 

  361.             }
    362. 

  362. 

  363.             if(!isset($language_data['OOLANG'])) {
    364. 

  364.                 report_error(TYPE_ERROR, 'Language file contains no $language_data[\'OOLANG\'] specification!');
    365. 

  365.             } else if (!is_int($language_data['OOLANG']) && !is_bool($language_data['OOLANG'])) {
    366. 

  366.                 report_error(TYPE_ERROR, 'Language file contains a $language_data[\'OOLANG\'] specification which is neither boolean nor integer!');
    367. 

  367.             } else if (false !== $language_data['OOLANG'] &&
    368. 

  368.                 true !== $language_data['OOLANG'] &&
    369. 

  369.                 2 !== $language_data['OOLANG']) {
    370. 

  370.                 report_error(TYPE_ERROR, 'Language file contains a $language_data[\'OOLANG\'] specification which is neither of false, true or 2!');
    371. 

  371.             }
    372. 

  372. 

  373.             if(!isset($language_data['OBJECT_SPLITTERS'])) {
    374. 

  374.                 report_error(TYPE_ERROR, 'Language file contains no $language_data[\'OBJECT_SPLITTERS\'] structure to check!');
    375. 

  375.             } else if (!is_array($language_data['OBJECT_SPLITTERS'])) {
    376. 

  376.                 report_error(TYPE_ERROR, 'Language file contains a $language_data[\'OBJECT_SPLITTERS\'] structure which is not an array!');
    377. 

  377.             }
    378. 

  378. 

  379.             if(!isset($language_data['REGEXPS'])) {
    380. 

  380.                 report_error(TYPE_ERROR, 'Language file contains no $language_data[\'REGEXPS\'] structure to check!');
    381. 

  381.             } else if (!is_array($language_data['REGEXPS'])) {
    382. 

  382.                 report_error(TYPE_ERROR, 'Language file contains a $language_data[\'REGEXPS\'] structure which is not an array!');
    383. 

  383.             }
    384. 

  384. 

  385.             if(!isset($language_data['STRICT_MODE_APPLIES'])) {
    386. 

  386.                 report_error(TYPE_ERROR, 'Language file contains no $language_data[\'STRICT_MODE_APPLIES\'] specification!');
    387. 

  387.             } else if (!is_int($language_data['STRICT_MODE_APPLIES'])) {
    388. 

  388.                 report_error(TYPE_ERROR, 'Language file contains a $language_data[\'STRICT_MODE_APPLIES\'] specification which is not an integer!');
    389. 

  389.             } else if (GESHI_MAYBE != $language_data['STRICT_MODE_APPLIES'] &&
    390. 

  390.                 GESHI_ALWAYS != $language_data['STRICT_MODE_APPLIES'] &&
    391. 

  391.                 GESHI_NEVER != $language_data['STRICT_MODE_APPLIES']) {
    392. 

  392.                 report_error(TYPE_ERROR, 'Language file contains a $language_data[\'STRICT_MODE_APPLIES\'] specification which is neither of GESHI_MAYBE, GESHI_ALWAYS nor GESHI_NEVER!');
    393. 

  393.             }
    394. 

  394. 

  395.             if(!isset($language_data['SCRIPT_DELIMITERS'])) {
    396. 

  396.                 report_error(TYPE_ERROR, 'Language file contains no $language_data[\'SCRIPT_DELIMITERS\'] structure to check!');
    397. 

  397.             } else if (!is_array($language_data['SCRIPT_DELIMITERS'])) {
    398. 

  398.                 report_error(TYPE_ERROR, 'Language file contains a $language_data[\'SCRIPT_DELIMITERS\'] structure which is not an array!');
    399. 

  399.             }
    400. 

  400. 

  401.             if(!isset($language_data['HIGHLIGHT_STRICT_BLOCK'])) {
    402. 

  402.                 report_error(TYPE_ERROR, 'Language file contains no $language_data[\'HIGHLIGHT_STRICT_BLOCK\'] structure to check!');
    403. 

  403.             } else if (!is_array($language_data['HIGHLIGHT_STRICT_BLOCK'])) {
    404. 

  404.                 report_error(TYPE_ERROR, 'Language file contains a $language_data[\'HIGHLIGHT_STRICT_BLOCK\'] structure which is not an array!');
    405. 

  405.             }
    406. 

  406. 

  407.             if(isset($language_data['TAB_WIDTH'])) {
    408. 

  408.                 if (!is_int($language_data['TAB_WIDTH'])) {
    409. 

  409.                     report_error(TYPE_ERROR, 'Language file contains a $language_data[\'TAB_WIDTH\'] specification which is not an integer!');
    410. 

  410.                 } else if (1 > $language_data['TAB_WIDTH']) {
    411. 

  411.                     report_error(TYPE_ERROR, 'Language file contains a $language_data[\'TAB_WIDTH\'] specification which is less than 1!');
    412. 

  412.                 }
    413. 

  413.             }
    414. 

  414. 

  415.             if(isset($language_data['PARSER_CONTROL'])) {
    416. 

  416.                 if (!is_array($language_data['PARSER_CONTROL'])) {
    417. 

  417.                     report_error(TYPE_ERROR, 'Language file contains a $language_data[\'PARSER_CONTROL\'] structure which is not an array!');
    418. 

  418.                 }
    419. 

  419.             }
    420. 

  420. 

  421.             if(!isset($language_data['STYLES'])) {
    422. 

  422.                 report_error(TYPE_ERROR, 'Language file contains no $language_data[\'STYLES\'] structure to check!');
    423. 

  423.             } else if (!is_array($language_data['STYLES'])) {
    424. 

  424.                 report_error(TYPE_ERROR, 'Language file contains a $language_data[\'STYLES\'] structure which is not an array!');
    425. 

  425.             } else {
    426. 

  426.                 $style_arrays = array('KEYWORDS', 'COMMENTS', 'ESCAPE_CHAR',
    427. 

  427.                     'BRACKETS', 'STRINGS', 'NUMBERS', 'METHODS', 'SYMBOLS',
    428. 

  428.                     'REGEXPS', 'SCRIPT');
    429. 

  429.                 foreach($style_arrays as $style_kind) {
    430. 

  430.                     if(!isset($language_data['STYLES'][$style_kind])) {
    431. 

  431.                         report_error(TYPE_ERROR, "Language file contains no \$language_data['STYLES']['$style_kind'] structure to check!");
    432. 

  432.                     } else if (!is_array($language_data['STYLES'][$style_kind])) {
    433. 

  433.                         report_error(TYPE_ERROR, "Language file contains a \$language_data['STYLES\']['$style_kind'] structure which is not an array!");
    434. 

  434.                     } else {
    435. 

  435.                         foreach($language_data['STYLES'][$style_kind] as $sk_key => $sk_value) {
    436. 

  436.                             if(!is_int($sk_key) && ('COMMENTS' != $style_kind && 'MULTI' != $sk_key)
    437. 

  437.                                 && !(('STRINGS' == $style_kind || 'ESCAPE_CHAR' == $style_kind) && 'HARD' == $sk_key)) {
    438. 

  438.                                 report_error(TYPE_WARNING, "Language file contains an key '$sk_key' in \$language_data['STYLES']['$style_kind'] that is not integer!");
    439. 

  439.                             } else if (!is_string($sk_value)) {
    440. 

  440.                                 report_error(TYPE_WARNING, "Language file contains a CSS specification for \$language_data['STYLES']['$style_kind'][$key] which is not a string!");
    441. 

  441.                             }
    442. 

  442.                         }
    443. 

  443.                     }
    444. 

  444.                 }
    445. 

  445. 

  446.                 unset($style_arrays);
    447. 

  447.             }
    448. 

  448.         }
    449. 

  449. 

  450.         if(!$error_abort) {
    451. 

  451.             //Initial sanity checks survived? --> Let's dig deeper!
    452. 

  452.             foreach($language_data['KEYWORDS'] as $key => $keywords) {
    453. 

  453.                 if(!isset($language_data['CASE_SENSITIVE'][$key])) {
    454. 

  454.                     report_error(TYPE_ERROR, "Language file contains no \$language_data['CASE_SENSITIVE'] specification for keyword group $key!");
    455. 

  455.                 }
    456. 

  456.                 if(!isset($language_data['URLS'][$key])) {
    457. 

  457.                     report_error(TYPE_ERROR, "Language file contains no \$language_data['URLS'] specification for keyword group $key!");
    458. 

  458.                 }
    459. 

  459.                 if(empty($keywords)) {
    460. 

  460.                     report_error(TYPE_WARNING, "Language file contains an empty keyword list in \$language_data['KEYWORDS'] for group $key!");
    461. 

  461.                 }
    462. 

  462.                 foreach($keywords as $id => $kw) {
    463. 

  463.                     if(!is_string($kw)) {
    464. 

  464.                         report_error(TYPE_WARNING, "Language file contains an non-string entry at \$language_data['KEYWORDS'][$key][$id]!");
    465. 

  465.                     } else if (!strlen($kw)) {
    466. 

  466.                         report_error(TYPE_ERROR, "Language file contains an empty string entry at \$language_data['KEYWORDS'][$key][$id]!");
    467. 

  467.                     } else if (preg_match('/^([\(\)\{\}\[\]\^=.,:;\-+\*\/%\$\"\'\?]|&[\w#]\w*;)+$/i', $kw)) {
    468. 

  468.                         report_error(TYPE_NOTICE, "Language file contains an keyword ('$kw') at \$language_data['KEYWORDS'][$key][$id] which seems to be better suited for the symbols section!");
    469. 

  469.                     }
    470. 

  470.                 }
    471. 

  471.                 if(!$language_data['CASE_SENSITIVE'][$key]) {
    472. 

  472.                     array_walk($keywords, 'dupfind_strtolower');
    473. 

  473.                 }
    474. 

  474.                 if(count($keywords) != count(array_unique($keywords))) {
    475. 

  475.                     $kw_diffs = array_count_values($keywords);
    476. 

  476.                     foreach($kw_diffs as $kw => $kw_count) {
    477. 

  477.                         if($kw_count > 1) {
    478. 

  478.                             report_error(TYPE_WARNING, "Language file contains per-group duplicate keyword '$kw' in \$language_data['KEYWORDS'][$key]!");
    479. 

  479.                         }
    480. 

  480.                     }
    481. 

  481.                 }
    482. 

  482.             }
    483. 

  483. 

  484.             $disallowed_before = "(?<![a-zA-Z0-9\$_\|\#;>|^&";
    485. 

  485.             $disallowed_after = "(?![a-zA-Z0-9_\|%\\-&;";
    486. 

  486. 

  487.             foreach($language_data['KEYWORDS'] as $key => $keywords) {
    488. 

  488.                 foreach($language_data['KEYWORDS'] as $key2 => $keywords2) {
    489. 

  489.                     if($key2 <= $key) {
    490. 

  490.                         continue;
    491. 

  491.                     }
    492. 

  492.                     $kw_diffs = array_intersect($keywords, $keywords2);
    493. 

  493.                     foreach($kw_diffs as $kw) {
    494. 

  494.                         if(isset($language_data['PARSER_CONTROL']['KEYWORDS'])) {
    495. 

  495.                             //Check the precondition\post-cindition for the involved keyword groups
    496. 

  496.                             $g1_pre = $disallowed_before;
    497. 

  497.                             $g2_pre = $disallowed_before;
    498. 

  498.                             $g1_post = $disallowed_after;
    499. 

  499.                             $g2_post = $disallowed_after;
    500. 

  500.                             if(isset($language_data['PARSER_CONTROL']['KEYWORDS']['DISALLOWED_BEFORE'])) {
    501. 

  501.                                 $g1_pre = $language_data['PARSER_CONTROL']['KEYWORDS']['DISALLOWED_BEFORE'];
    502. 

  502.                                 $g2_pre = $language_data['PARSER_CONTROL']['KEYWORDS']['DISALLOWED_BEFORE'];
    503. 

  503.                             }
    504. 

  504.                             if(isset($language_data['PARSER_CONTROL']['KEYWORDS']['DISALLOWED_AFTER'])) {
    505. 

  505.                                 $g1_post = $language_data['PARSER_CONTROL']['KEYWORDS']['DISALLOWED_AFTER'];
    506. 

  506.                                 $g2_post = $language_data['PARSER_CONTROL']['KEYWORDS']['DISALLOWED_AFTER'];
    507. 

  507.                             }
    508. 

  508. 

  509.                             if(isset($language_data['PARSER_CONTROL']['KEYWORDS'][$key]['DISALLOWED_BEFORE'])) {
    510. 

  510.                                 $g1_pre = $language_data['PARSER_CONTROL']['KEYWORDS'][$key]['DISALLOWED_BEFORE'];
    511. 

  511.                             }
    512. 

  512.                             if(isset($language_data['PARSER_CONTROL']['KEYWORDS'][$key]['DISALLOWED_AFTER'])) {
    513. 

  513.                                 $g1_post = $language_data['PARSER_CONTROL']['KEYWORDS'][$key]['DISALLOWED_AFTER'];
    514. 

  514.                             }
    515. 

  515. 

  516.                             if(isset($language_data['PARSER_CONTROL']['KEYWORDS'][$key2]['DISALLOWED_BEFORE'])) {
    517. 

  517.                                 $g2_pre = $language_data['PARSER_CONTROL']['KEYWORDS'][$key2]['DISALLOWED_BEFORE'];
    518. 

  518.                             }
    519. 

  519.                             if(isset($language_data['PARSER_CONTROL']['KEYWORDS'][$key2]['DISALLOWED_AFTER'])) {
    520. 

  520.                                 $g2_post = $language_data['PARSER_CONTROL']['KEYWORDS'][$key2]['DISALLOWED_AFTER'];
    521. 

  521.                             }
    522. 

  522. 

  523.                             if($g1_pre != $g2_pre || $g1_post != $g2_post) {
    524. 

  524.                                 continue;
    525. 

  525.                             }
    526. 

  526.                         }
    527. 

  527.                         report_error(TYPE_WARNING, "Language file contains cross-group duplicate keyword '$kw' in \$language_data['KEYWORDS'][$key] and \$language_data['KEYWORDS'][$key2]!");
    528. 

  528.                     }
    529. 

  529.                 }
    530. 

  530.             }
    531. 

  531.             foreach($language_data['CASE_SENSITIVE'] as $key => $keywords) {
    532. 

  532.                 if(!isset($language_data['KEYWORDS'][$key]) && $key != GESHI_COMMENTS) {
    533. 

  533.                     report_error(TYPE_WARNING, "Language file contains an superfluous \$language_data['CASE_SENSITIVE'] specification for non-existing keyword group $key!");
    534. 

  534.                 }
    535. 

  535.             }
    536. 

  536.             foreach($language_data['URLS'] as $key => $keywords) {
    537. 

  537.                 if(!isset($language_data['KEYWORDS'][$key])) {
    538. 

  538.                     report_error(TYPE_WARNING, "Language file contains an superfluous \$language_data['URLS'] specification for non-existing keyword group $key!");
    539. 

  539.                 }
    540. 

  540.             }
    541. 

  541.             foreach($language_data['STYLES']['KEYWORDS'] as $key => $keywords) {
    542. 

  542.                 if(!isset($language_data['KEYWORDS'][$key])) {
    543. 

  543.                     report_error(TYPE_WARNING, "Language file contains an superfluous \$language_data['STYLES']['KEYWORDS'] specification for non-existing keyword group $key!");
    544. 

  544.                 }
    545. 

  545.             }
    546. 

  546. 

  547.             foreach($language_data['COMMENT_SINGLE'] as $ck => $cv) {
    548. 

  548.                 if(!is_int($ck)) {
    549. 

  549.                     report_error(TYPE_WARNING, "Language file contains an key '$ck' in \$language_data['COMMENT_SINGLE'] that is not integer!");
    550. 

  550.                 }
    551. 

  551.                 if(!is_string($cv)) {
    552. 

  552.                     report_error(TYPE_WARNING, "Language file contains an non-string entry at \$language_data['COMMENT_SINGLE'][$ck]!");
    553. 

  553.                 }
    554. 

  554.                 if(!isset($language_data['STYLES']['COMMENTS'][$ck])) {
    555. 

  555.                     report_error(TYPE_WARNING, "Language file contains no \$language_data['STYLES']['COMMENTS'] specification for comment group $ck!");
    556. 

  556.                 }
    557. 

  557.             }
    558. 

  558.             if(isset($language_data['COMMENT_REGEXP'])) {
    559. 

  559.                 foreach($language_data['COMMENT_REGEXP'] as $ck => $cv) {
    560. 

  560.                     if(!is_int($ck)) {
    561. 

  561.                         report_error(TYPE_WARNING, "Language file contains an key '$ck' in \$language_data['COMMENT_REGEXP'] that is not integer!");
    562. 

  562.                     }
    563. 

  563.                     if(!is_string($cv)) {
    564. 

  564.                         report_error(TYPE_WARNING, "Language file contains an non-string entry at \$language_data['COMMENT_REGEXP'][$ck]!");
    565. 

  565.                     }
    566. 

  566.                     if(!isset($language_data['STYLES']['COMMENTS'][$ck])) {
    567. 

  567.                         report_error(TYPE_WARNING, "Language file contains no \$language_data['STYLES']['COMMENTS'] specification for comment group $ck!");
    568. 

  568.                     }
    569. 

  569.                 }
    570. 

  570.             }
    571. 

  571.             foreach($language_data['STYLES']['COMMENTS'] as $ck => $cv) {
    572. 

  572.                 if($ck != 'MULTI' && !isset($language_data['COMMENT_SINGLE'][$ck]) &&
    573. 

  573.                     !isset($language_data['COMMENT_REGEXP'][$ck])) {
    574. 

  574.                     report_error(TYPE_NOTICE, "Language file contains an superfluous \$language_data['STYLES']['COMMENTS'] specification for Single Line or Regular-Expression Comment key $ck!");
    575. 

  575.                 }
    576. 

  576.             }
    577. 

  577.             if (isset($language_data['STYLES']['STRINGS']['HARD'])) {
    578. 

  578.                 if (empty($language_data['HARDQUOTE'])) {
    579. 

  579.                     report_error(TYPE_NOTICE, "Language file contains superfluous \$language_data['STYLES']['STRINGS'] specification for key 'HARD', but no 'HARDQUOTE's are defined!");
    580. 

  580.                 }
    581. 

  581.                 unset($language_data['STYLES']['STRINGS']['HARD']);
    582. 

  582.             }
    583. 

  583.             foreach($language_data['STYLES']['STRINGS'] as $sk => $sv) {
    584. 

  584.                 if($sk && !isset($language_data['QUOTEMARKS'][$sk])) {
    585. 

  585.                     report_error(TYPE_NOTICE, "Language file contains an superfluous \$language_data['STYLES']['STRINGS'] specification for non-existing quotemark key $sk!");
    586. 

  586.                 }
    587. 

  587.             }
    588. 

  588. 

  589.             foreach($language_data['REGEXPS'] as $rk => $rv) {
    590. 

  590.                 if(!is_int($rk)) {
    591. 

  591.                     report_error(TYPE_WARNING, "Language file contains an key '$rk' in \$language_data['REGEXPS'] that is not integer!");
    592. 

  592.                 }
    593. 

  593.                 if(is_string($rv)) {
    594. 

  594.                     //Check for unmasked / in regular expressions ...
    595. 

  595.                     if(empty($rv)) {
    596. 

  596.                         report_error(TYPE_WARNING, "Language file contains an empty regular expression at \$language_data['REGEXPS'][$rk]!");
    597. 

  597.                     } else {
    598. 

  598.                         if(preg_match("/(?<!\\\\)\//s", $rv)) {
    599. 

  599.                             report_error(TYPE_WARNING, "Language file contains a regular expression with an unmasked / character at \$language_data['REGEXPS'][$rk]!");
    600. 

  600.                         } elseif (preg_match("/(?<!<)(\\\\\\\\)*\\\\\|(?!>)/s", $rv)) {
    601. 

  601.                             report_error(TYPE_WARNING, "Language file contains a regular expression with an unescaped match for a pipe character '|' which needs escaping as '&lt;PIPE&gt;' instead at \$language_data['REGEXPS'][$rk]!");
    602. 

  602.                         }
    603. 

  603.                     }
    604. 

  604.                 } elseif(is_array($rv)) {
    605. 

  605.                     if(!isset($rv[GESHI_SEARCH])) {
    606. 

  606.                         report_error(TYPE_ERROR, "Language file contains no GESHI_SEARCH entry in extended regular expression at \$language_data['REGEXPS'][$rk]!");
    607. 

  607.                     } elseif(!is_string($rv[GESHI_SEARCH])) {
    608. 

  608.                         report_error(TYPE_ERROR, "Language file contains a GESHI_SEARCH entry in extended regular expression at \$language_data['REGEXPS'][$rk] which is not a string!");
    609. 

  609.                     } else {
    610. 

  610.                         if(preg_match("/(?<!\\\\)\//s", $rv[GESHI_SEARCH])) {
    611. 

  611.                             report_error(TYPE_WARNING, "Language file contains a regular expression with an unmasked / character at \$language_data['REGEXPS'][$rk]!");
    612. 

  612.                         } elseif (preg_match("/(?<!<)(\\\\\\\\)*\\\\\|(?!>)/s", $rv[GESHI_SEARCH])) {
    613. 

  613.                             report_error(TYPE_WARNING, "Language file contains a regular expression with an unescaped match for a pipe character '|' which needs escaping as '&lt;PIPE&gt;' instead at \$language_data['REGEXPS'][$rk]!");
    614. 

  614.                         }
    615. 

  615.                     }
    616. 

  616.                     if(!isset($rv[GESHI_REPLACE])) {
    617. 

  617.                         report_error(TYPE_WARNING, "Language file contains no GESHI_REPLACE entry in extended regular expression at \$language_data['REGEXPS'][$rk]!");
    618. 

  618.                     } elseif(!is_string($rv[GESHI_REPLACE])) {
    619. 

  619.                         report_error(TYPE_ERROR, "Language file contains a GESHI_REPLACE entry in extended regular expression at \$language_data['REGEXPS'][$rk] which is not a string!");
    620. 

  620.                     }
    621. 

  621.                     if(!isset($rv[GESHI_MODIFIERS])) {
    622. 

  622.                         report_error(TYPE_WARNING, "Language file contains no GESHI_MODIFIERS entry in extended regular expression at \$language_data['REGEXPS'][$rk]!");
    623. 

  623.                     } elseif(!is_string($rv[GESHI_MODIFIERS])) {
    624. 

  624.                         report_error(TYPE_ERROR, "Language file contains a GESHI_MODIFIERS entry in extended regular expression at \$language_data['REGEXPS'][$rk] which is not a string!");
    625. 

  625.                     }
    626. 

  626.                     if(!isset($rv[GESHI_BEFORE])) {
    627. 

  627.                         report_error(TYPE_WARNING, "Language file contains no GESHI_BEFORE entry in extended regular expression at \$language_data['REGEXPS'][$rk]!");
    628. 

  628.                     } elseif(!is_string($rv[GESHI_BEFORE])) {
    629. 

  629.                         report_error(TYPE_ERROR, "Language file contains a GESHI_BEFORE entry in extended regular expression at \$language_data['REGEXPS'][$rk] which is not a string!");
    630. 

  630.                     }
    631. 

  631.                     if(!isset($rv[GESHI_AFTER])) {
    632. 

  632.                         report_error(TYPE_WARNING, "Language file contains no GESHI_AFTER entry in extended regular expression at \$language_data['REGEXPS'][$rk]!");
    633. 

  633.                     } elseif(!is_string($rv[GESHI_AFTER])) {
    634. 

  634.                         report_error(TYPE_ERROR, "Language file contains a GESHI_AFTER entry in extended regular expression at \$language_data['REGEXPS'][$rk] which is not a string!");
    635. 

  635.                     }
    636. 

  636.                 } else {
    637. 

  637.                     report_error(TYPE_WARNING, "Language file contains an non-string and non-array entry at \$language_data['REGEXPS'][$rk]!");
    638. 

  638.                 }
    639. 

  639.                 if(!isset($language_data['STYLES']['REGEXPS'][$rk])) {
    640. 

  640.                     report_error(TYPE_WARNING, "Language file contains no \$language_data['STYLES']['REGEXPS'] specification for regexp group $rk!");
    641. 

  641.                 }
    642. 

  642.             }
    643. 

  643.             foreach($language_data['STYLES']['REGEXPS'] as $rk => $rv) {
    644. 

  644.                 if(!isset($language_data['REGEXPS'][$rk])) {
    645. 

  645.                     report_error(TYPE_NOTICE, "Language file contains an superfluous \$language_data['STYLES']['REGEXPS'] specification for regexp key $rk!");
    646. 

  646.                 }
    647. 

  647.             }
    648. 

  648. 

  649. 

  650.         }
    651. 

  651. 

  652.         output_error_cache();
    653. 

  653. 

  654.         flush();
    655. 

  655. 

  656.         if($error_abort) {
    657. 

  657.             break;
    658. 

  658.         }
    659. 

  659.     }
    660. 

  660. }
    661. 

  661. ?></li>
    662. 

  662. </ol>
    663. 

  663. 

  664. <p>Validation process completed in <?
    665. 

  665. $time_end = explode(' ', microtime());
    666. 

  666. $time_diff = $time_end[0] + $time_end[1] - $time_start[0] - $time_start[1];
    667. 

  667. 

  668. echo sprintf("%.2f", $time_diff);
    669. 

  669. ?> seconds.</p>
    670. 

  670. 

  671. <div id="footer">GeSHi &copy; 2004-2007 Nigel McNie, 2007-2008 Benny Baumann, released under the GNU GPL</div>
    672. 

  672. </body>
    673. 

  673. </html>
    674.