includes/Parser.php

   1 <?php
   2
   3 /**
   4  * File for Parser and related classes
   5  *
   6  * @package MediaWiki
   7  * @version $Id$
   8  */
   9
  10 /**
  11  * Update this version number when the ParserOutput format
  12  * changes in an incompatible way, so the parser cache
  13  * can automatically discard old data.
  14  */
  15 define( 'MW_PARSER_VERSION', '1.4.0' );
  16
  17 /**
  18  * Variable substitution O(N^2) attack
  19  *
  20  * Without countermeasures, it would be possible to attack the parser by saving
  21  * a page filled with a large number of inclusions of large pages. The size of
  22  * the generated page would be proportional to the square of the input size.
  23  * Hence, we limit the number of inclusions of any given page, thus bringing any
  24  * attack back to O(N).
  25  */
  26
  27 define( 'MAX_INCLUDE_REPEAT', 100 );
  28 define( 'MAX_INCLUDE_SIZE', 1000000 ); // 1 Million
  29
  30 define( 'RLH_FOR_UPDATE', 1 );
  31
  32 # Allowed values for $mOutputType
  33 define( 'OT_HTML', 1 );
  34 define( 'OT_WIKI', 2 );
  35 define( 'OT_MSG' , 3 );
  36
  37 # string parameter for extractTags which will cause it
  38 # to strip HTML comments in addition to regular
  39 # <XML>-style tags. This should not be anything we
  40 # may want to use in wikisyntax
  41 define( 'STRIP_COMMENTS', 'HTMLCommentStrip' );
  42
  43 # prefix for escaping, used in two functions at least
  44 define( 'UNIQ_PREFIX', 'NaodW29');
  45
  46 # Constants needed for external link processing
  47 define( 'URL_PROTOCOLS', 'http|https|ftp|irc|gopher|news|mailto' );
  48 define( 'HTTP_PROTOCOLS', 'http|https' );
  49 # Everything except bracket, space, or control characters
  50 define( 'EXT_LINK_URL_CLASS', '[^]<>"\\x00-\\x20\\x7F]' );
  51 # Including space
  52 define( 'EXT_LINK_TEXT_CLASS', '[^\]\\x00-\\x1F\\x7F]' );
  53 define( 'EXT_IMAGE_FNAME_CLASS', '[A-Za-z0-9_.,~%\\-+&;#*?!=()@\\x80-\\xFF]' );
  54 define( 'EXT_IMAGE_EXTENSIONS', 'gif|png|jpg|jpeg' );
  55 define( 'EXT_LINK_BRACKETED',  '/\[(('.URL_PROTOCOLS.'):'.EXT_LINK_URL_CLASS.'+) *('.EXT_LINK_TEXT_CLASS.'*?)\]/S' );
  56 define( 'EXT_IMAGE_REGEX',
  57         '/^('.HTTP_PROTOCOLS.':)'.  # Protocol
  58         '('.EXT_LINK_URL_CLASS.'+)\\/'.  # Hostname and path
  59         '('.EXT_IMAGE_FNAME_CLASS.'+)\\.((?i)'.EXT_IMAGE_EXTENSIONS.')$/S' # Filename
  60 );
  61
  62 /**
  63  * PHP Parser
  64  *
  65  * Processes wiki markup
  66  *
  67  * <pre>
  68  * There are three main entry points into the Parser class:
  69  * parse()
  70  *   produces HTML output
  71  * preSaveTransform().
  72  *   produces altered wiki markup.
  73  * transformMsg()
  74  *   performs brace substitution on MediaWiki messages
  75  *
  76  * Globals used:
  77  *    objects:   $wgLang, $wgDateFormatter, $wgLinkCache
  78  *
  79  * NOT $wgArticle, $wgUser or $wgTitle. Keep them away!
  80  *
  81  * settings:
  82  *  $wgUseTex*, $wgUseDynamicDates*, $wgInterwikiMagic*,
  83  *  $wgNamespacesWithSubpages, $wgAllowExternalImages*,
  84  *  $wgLocaltimezone
  85  *
  86  *  * only within ParserOptions
  87  * </pre>
  88  *
  89  * @package MediaWiki
  90  */
  91 class Parser
  92 {
  93         /**#@+
  94          * @access private
  95          */
  96         # Persistent:
  97         var $mTagHooks;
  98
  99         # Cleared with clearState():
 100         var $mOutput, $mAutonumber, $mDTopen, $mStripState = array();
 101         var $mVariables, $mIncludeCount, $mArgStack, $mLastSection, $mInPre;
 102
 103         # Temporary:
 104         var $mOptions, $mTitle, $mOutputType,
 105             $mTemplates,        // cache of already loaded templates, avoids
 106                                 // multiple SQL queries for the same string
 107             $mTemplatePath;     // stores an unsorted hash of all the templates already loaded
 108                                 // in this path. Used for loop detection.
 109
 110         /**#@-*/
 111
 112         /**
 113          * Constructor
 114          *
 115          * @access public
 116          */
 117         function Parser() {
 118                 $this->mTemplates = array();
 119                 $this->mTemplatePath = array();
 120                 $this->mTagHooks = array();
 121                 $this->clearState();
 122         }
 123
 124         /**
 125          * Clear Parser state
 126          *
 127          * @access private
 128          */
 129         function clearState() {
 130                 $this->mOutput = new ParserOutput;
 131                 $this->mAutonumber = 0;
 132                 $this->mLastSection = "";
 133                 $this->mDTopen = false;
 134                 $this->mVariables = false;
 135                 $this->mIncludeCount = array();
 136                 $this->mStripState = array();
 137                 $this->mArgStack = array();
 138                 $this->mInPre = false;
 139         }
 140
 141         /**
 142          * First pass--just handle <nowiki> sections, pass the rest off
 143          * to internalParse() which does all the real work.
 144          *
 145          * @access private
 146          * @return ParserOutput a ParserOutput
 147          */
 148         function parse( $text, &$title, $options, $linestart = true, $clearState = true ) {
 149                 global $wgUseTidy, $wgContLang;
 150                 $fname = 'Parser::parse';
 151                 wfProfileIn( $fname );
 152
 153                 if ( $clearState ) {
 154                         $this->clearState();
 155                 }
 156
 157                 $this->mOptions = $options;
 158                 $this->mTitle =& $title;
 159                 $this->mOutputType = OT_HTML;
 160
 161                 $stripState = NULL;
 162                 $text = $this->strip( $text, $this->mStripState );
 163
 164                 $text = $this->internalParse( $text, $linestart );
 165                 $text = $this->unstrip( $text, $this->mStripState );
 166                 # Clean up special characters, only run once, next-to-last before doBlockLevels
 167                 if(!$wgUseTidy) {
 168                         $fixtags = array(
 169                                 # french spaces, last one Guillemet-left
 170                                 # only if there is something before the space
 171                                 '/(.) (?=\\?|:|;|!|\\302\\273)/i' => '\\1&nbsp;\\2',
 172                                 # french spaces, Guillemet-right
 173                                 "/(\\302\\253) /i"=>"\\1&nbsp;",
 174                                 '/<hr *>/i' => '<hr />',
 175                                 '/<br *>/i' => '<br />',
 176                                 '/<center *>/i' => '<div class="center">',
 177                                 '/<\\/center *>/i' => '</div>',
 178                                 # Clean up spare ampersands; note that we probably ought to be
 179                                 # more careful about named entities.
 180                                 '/&(?!:amp;|#[Xx][0-9A-fa-f]+;|#[0-9]+;|[a-zA-Z0-9]+;)/' => '&amp;'
 181                         );
 182                         $text = preg_replace( array_keys($fixtags), array_values($fixtags), $text );
 183                 } else {
 184                         $fixtags = array(
 185                                 # french spaces, last one Guillemet-left
 186                                 '/ (\\?|:|;|!|\\302\\273)/i' => '&nbsp;\\1',
 187                                 # french spaces, Guillemet-right
 188                                 '/(\\302\\253) /i' => '\\1&nbsp;',
 189                                 '/<center *>/i' => '<div class="center">',
 190                                 '/<\\/center *>/i' => '</div>'
 191                         );
 192                         $text = preg_replace( array_keys($fixtags), array_values($fixtags), $text );
 193                 }
 194                 # only once and last
 195                 $text = $this->doBlockLevels( $text, $linestart );
 196
 197                 $this->replaceLinkHolders( $text );
 198                 $text = $wgContLang->convert($text);
 199
 200                 $text = $this->unstripNoWiki( $text, $this->mStripState );
 201                 global $wgUseTidy;
 202                 if ($wgUseTidy) {
 203                         $text = Parser::tidy($text);
 204                 }
 205
 206                 $this->mOutput->setText( $text );
 207                 wfProfileOut( $fname );
 208                 return $this->mOutput;
 209         }
 210
 211         /**
 212          * Get a random string
 213          *
 214          * @access private
 215          * @static
 216          */
 217         function getRandomString() {
 218                 return dechex(mt_rand(0, 0x7fffffff)) . dechex(mt_rand(0, 0x7fffffff));
 219         }
 220
 221         /**
 222          * Replaces all occurrences of <$tag>content</$tag> in the text
 223          * with a random marker and returns the new text. the output parameter
 224          * $content will be an associative array filled with data on the form
 225          * $unique_marker => content.
 226          *
 227          * If $content is already set, the additional entries will be appended
 228          * If $tag is set to STRIP_COMMENTS, the function will extract
 229          * <!-- HTML comments -->
 230          *
 231          * @access private
 232          * @static
 233          */
 234         function extractTags($tag, $text, &$content, $uniq_prefix = ''){
 235                 $rnd = $uniq_prefix . '-' . $tag . Parser::getRandomString();
 236                 if ( !$content ) {
 237                         $content = array( );
 238                 }
 239                 $n = 1;
 240                 $stripped = '';
 241
 242                 while ( '' != $text ) {
 243                         if($tag==STRIP_COMMENTS) {
 244                                 $p = preg_split( '/<!--/i', $text, 2 );
 245                         } else {
 246                                 $p = preg_split( "/<\\s*$tag\\s*>/i", $text, 2 );
 247                         }
 248                         $stripped .= $p[0];
 249                         if ( ( count( $p ) < 2 ) || ( '' == $p[1] ) ) {
 250                                 $text = '';
 251                         } else {
 252                                 if($tag==STRIP_COMMENTS) {
 253                                         $q = preg_split( '/-->/i', $p[1], 2 );
 254                                 } else {
 255                                         $q = preg_split( "/<\\/\\s*$tag\\s*>/i", $p[1], 2 );
 256                                 }
 257                                 $marker = $rnd . sprintf('%08X', $n++);
 258                                 $content[$marker] = $q[0];
 259                                 $stripped .= $marker;
 260                                 $text = $q[1];
 261                         }
 262                 }
 263                 return $stripped;
 264         }
 265
 266         /**
 267          * Strips and renders nowiki, pre, math, hiero
 268          * If $render is set, performs necessary rendering operations on plugins
 269          * Returns the text, and fills an array with data needed in unstrip()
 270          * If the $state is already a valid strip state, it adds to the state
 271          *
 272          * @param bool $stripcomments when set, HTML comments <!-- like this -->
 273          *  will be stripped in addition to other tags. This is important
 274          *  for section editing, where these comments cause confusion when
 275          *  counting the sections in the wikisource
 276          *
 277          * @access private
 278          */
 279         function strip( $text, &$state, $stripcomments = false ) {
 280                 $render = ($this->mOutputType == OT_HTML);
 281                 $html_content = array();
 282                 $nowiki_content = array();
 283                 $math_content = array();
 284                 $pre_content = array();
 285                 $comment_content = array();
 286                 $ext_content = array();
 287                 $gallery_content = array();
 288
 289                 # Replace any instances of the placeholders
 290                 $uniq_prefix = UNIQ_PREFIX;
 291                 #$text = str_replace( $uniq_prefix, wfHtmlEscapeFirst( $uniq_prefix ), $text );
 292
 293                 # html
 294                 global $wgRawHtml, $wgWhitelistEdit;
 295                 if( $wgRawHtml && $wgWhitelistEdit ) {
 296                         $text = Parser::extractTags('html', $text, $html_content, $uniq_prefix);
 297                         foreach( $html_content as $marker => $content ) {
 298                                 if ($render ) {
 299                                         # Raw and unchecked for validity.
 300                                         $html_content[$marker] = $content;
 301                                 } else {
 302                                         $html_content[$marker] = '<html>'.$content.'</html>';
 303                                 }
 304                         }
 305                 }
 306
 307                 # nowiki
 308                 $text = Parser::extractTags('nowiki', $text, $nowiki_content, $uniq_prefix);
 309                 foreach( $nowiki_content as $marker => $content ) {
 310                         if( $render ){
 311                                 $nowiki_content[$marker] = wfEscapeHTMLTagsOnly( $content );
 312                         } else {
 313                                 $nowiki_content[$marker] = '<nowiki>'.$content.'</nowiki>';
 314                         }
 315                 }
 316
 317                 # math
 318                 $text = Parser::extractTags('math', $text, $math_content, $uniq_prefix);
 319                 foreach( $math_content as $marker => $content ){
 320                         if( $render ) {
 321                                 if( $this->mOptions->getUseTeX() ) {
 322                                         $math_content[$marker] = renderMath( $content );
 323                                 } else {
 324                                         $math_content[$marker] = '&lt;math&gt;'.$content.'&lt;math&gt;';
 325                                 }
 326                         } else {
 327                                 $math_content[$marker] = '<math>'.$content.'</math>';
 328                         }
 329                 }
 330
 331                 # pre
 332                 $text = Parser::extractTags('pre', $text, $pre_content, $uniq_prefix);
 333                 foreach( $pre_content as $marker => $content ){
 334                         if( $render ){
 335                                 $pre_content[$marker] = '<pre>' . wfEscapeHTMLTagsOnly( $content ) . '</pre>';
 336                         } else {
 337                                 $pre_content[$marker] = '<pre>'.$content.'</pre>';
 338                         }
 339                 }
 340
 341                 # gallery
 342                 $text = Parser::extractTags('gallery', $text, $gallery_content, $uniq_prefix);
 343                 foreach( $gallery_content as $marker => $content ) {
 344                         require_once( 'ImageGallery.php' );
 345                         if ( $render ) {
 346                                 $gallery_content[$marker] = Parser::renderImageGallery( $content );
 347                         } else {
 348                                 $gallery_content[$marker] = '<gallery>'.$content.'</gallery>';
 349                         }
 350                 }
 351
 352                 # Comments
 353                 if($stripcomments) {
 354                         $text = Parser::extractTags(STRIP_COMMENTS, $text, $comment_content, $uniq_prefix);
 355                         foreach( $comment_content as $marker => $content ){
 356                                 $comment_content[$marker] = '<!--'.$content.'-->';
 357                         }
 358                 }
 359
 360                 # Extensions
 361                 foreach ( $this->mTagHooks as $tag => $callback ) {
 362                         $ext_contents[$tag] = array();
 363                         $text = Parser::extractTags( $tag, $text, $ext_content[$tag], $uniq_prefix );
 364                         foreach( $ext_content[$tag] as $marker => $content ) {
 365                                 if ( $render ) {
 366                                         $ext_content[$tag][$marker] = $callback( $content );
 367                                 } else {
 368                                         $ext_content[$tag][$marker] = "<$tag>$content</$tag>";
 369                                 }
 370                         }
 371                 }
 372
 373                 # Merge state with the pre-existing state, if there is one
 374                 if ( $state ) {
 375                         $state['html'] = $state['html'] + $html_content;
 376                         $state['nowiki'] = $state['nowiki'] + $nowiki_content;
 377                         $state['math'] = $state['math'] + $math_content;
 378                         $state['pre'] = $state['pre'] + $pre_content;
 379                         $state['comment'] = $state['comment'] + $comment_content;
 380                         $state['gallery'] = $state['gallery'] + $gallery_content;
 381
 382                         foreach( $ext_content as $tag => $array ) {
 383                                 if ( array_key_exists( $tag, $state ) ) {
 384                                         $state[$tag] = $state[$tag] + $array;
 385                                 }
 386                         }
 387                 } else {
 388                         $state = array(
 389                           'html' => $html_content,
 390                           'nowiki' => $nowiki_content,
 391                           'math' => $math_content,
 392                           'pre' => $pre_content,
 393                           'comment' => $comment_content,
 394                           'gallery' => $gallery_content,
 395                         ) + $ext_content;
 396                 }
 397                 return $text;
 398         }
 399
 400         /**
 401          * restores pre, math, and hiero removed by strip()
 402          *
 403          * always call unstripNoWiki() after this one
 404          * @access private
 405          */
 406         function unstrip( $text, &$state ) {
 407                 # Must expand in reverse order, otherwise nested tags will be corrupted
 408                 $contentDict = end( $state );
 409                 for ( $contentDict = end( $state ); $contentDict !== false; $contentDict = prev( $state ) ) {
 410                         if( key($state) != 'nowiki' && key($state) != 'html') {
 411                                 for ( $content = end( $contentDict ); $content !== false; $content = prev( $contentDict ) ) {
 412                                         $text = str_replace( key( $contentDict ), $content, $text );
 413                                 }
 414                         }
 415                 }
 416
 417                 return $text;
 418         }
 419
 420         /**
 421          * always call this after unstrip() to preserve the order
 422          *
 423          * @access private
 424          */
 425         function unstripNoWiki( $text, &$state ) {
 426                 # Must expand in reverse order, otherwise nested tags will be corrupted
 427                 for ( $content = end($state['nowiki']); $content !== false; $content = prev( $state['nowiki'] ) ) {
 428                         $text = str_replace( key( $state['nowiki'] ), $content, $text );
 429                 }
 430
 431                 global $wgRawHtml;
 432                 if ($wgRawHtml) {
 433                         for ( $content = end($state['html']); $content !== false; $content = prev( $state['html'] ) ) {
 434                                 $text = str_replace( key( $state['html'] ), $content, $text );
 435                         }
 436                 }
 437
 438                 return $text;
 439         }
 440
 441         /**
 442          * Add an item to the strip state
 443          * Returns the unique tag which must be inserted into the stripped text
 444          * The tag will be replaced with the original text in unstrip()
 445          *
 446          * @access private
 447          */
 448         function insertStripItem( $text, &$state ) {
 449                 $rnd = UNIQ_PREFIX . '-item' . Parser::getRandomString();
 450                 if ( !$state ) {
 451                         $state = array(
 452                           'html' => array(),
 453                           'nowiki' => array(),
 454                           'math' => array(),
 455                           'pre' => array()
 456                         );
 457                 }
 458                 $state['item'][$rnd] = $text;
 459                 return $rnd;
 460         }
 461
 462         /**
 463          * Return allowed HTML attributes
 464          *
 465          * @access private
 466          */
 467         function getHTMLattrs () {
 468                 $htmlattrs = array( # Allowed attributes--no scripting, etc.
 469                                 'title', 'align', 'lang', 'dir', 'width', 'height',
 470                                 'bgcolor', 'clear', /* BR */ 'noshade', /* HR */
 471                                 'cite', /* BLOCKQUOTE, Q */ 'size', 'face', 'color',
 472                                 /* FONT */ 'type', 'start', 'value', 'compact',
 473                                 /* For various lists, mostly deprecated but safe */
 474                                 'summary', 'width', 'border', 'frame', 'rules',
 475                                 'cellspacing', 'cellpadding', 'valign', 'char',
 476                                 'charoff', 'colgroup', 'col', 'span', 'abbr', 'axis',
 477                                 'headers', 'scope', 'rowspan', 'colspan', /* Tables */
 478                                 'id', 'class', 'name', 'style' /* For CSS */
 479                                 );
 480                 return $htmlattrs ;
 481         }
 482
 483         /**
 484          * Remove non approved attributes and javascript in css
 485          *
 486          * @access private
 487          */
 488         function fixTagAttributes ( $t ) {
 489                 if ( trim ( $t ) == '' ) return '' ; # Saves runtime ;-)
 490                 $htmlattrs = $this->getHTMLattrs() ;
 491
 492                 # Strip non-approved attributes from the tag
 493                 $t = preg_replace(
 494                         '/(\\w+)(\\s*=\\s*([^\\s\">]+|\"[^\">]*\"))?/e',
 495                         "(in_array(strtolower(\"\$1\"),\$htmlattrs)?(\"\$1\".((\"x\$3\" != \"x\")?\"=\$3\":'')):'')",
 496                         $t);
 497
 498                 $t = str_replace ( '<></>' , '' , $t ) ; # This should fix bug 980557
 499
 500                 # Strip javascript "expression" from stylesheets. Brute force approach:
 501                 # If anythin offensive is found, all attributes of the HTML tag are dropped
 502
 503                 if( preg_match(
 504                         '/style\\s*=.*(expression|tps*:\/\/|url\\s*\().*/is',
 505                         wfMungeToUtf8( $t ) ) )
 506                 {
 507                         $t='';
 508                 }
 509
 510                 return trim ( $t ) ;
 511         }
 512
 513         /**
 514          * interface with html tidy, used if $wgUseTidy = true
 515          *
 516          * @access public
 517          * @static
 518          */
 519         function tidy ( $text ) {
 520                 global $wgTidyConf, $wgTidyBin, $wgTidyOpts;
 521                 global $wgInputEncoding, $wgOutputEncoding;
 522                 $fname = 'Parser::tidy';
 523                 wfProfileIn( $fname );
 524
 525                 $cleansource = '';
 526                 $opts = '';
 527                 switch(strtoupper($wgOutputEncoding)) {
 528                         case 'ISO-8859-1':
 529                                 $opts .= ($wgInputEncoding == $wgOutputEncoding)? ' -latin1':' -raw';
 530                                 break;
 531                         case 'UTF-8':
 532                                 $opts .= ($wgInputEncoding == $wgOutputEncoding)? ' -utf8':' -raw';
 533                                 break;
 534                         default:
 535                                 $opts .= ' -raw';
 536                         }
 537
 538                 $wrappedtext = '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"'.
 539 ' "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html>'.
 540 '<head><title>test</title></head><body>'.$text.'</body></html>';
 541                 $descriptorspec = array(
 542                         0 => array('pipe', 'r'),
 543                         1 => array('pipe', 'w'),
 544                         2 => array('file', '/dev/null', 'a')
 545                 );
 546                 $process = proc_open("$wgTidyBin -config $wgTidyConf $wgTidyOpts$opts", $descriptorspec, $pipes);
 547                 if (is_resource($process)) {
 548                         fwrite($pipes[0], $wrappedtext);
 549                         fclose($pipes[0]);
 550                         while (!feof($pipes[1])) {
 551                                 $cleansource .= fgets($pipes[1], 1024);
 552                         }
 553                         fclose($pipes[1]);
 554                         $return_value = proc_close($process);
 555                 }
 556
 557                 wfProfileOut( $fname );
 558
 559                 if( $cleansource == '' && $text != '') {
 560                         wfDebug( "Tidy error detected!\n" );
 561                         return $text . "\n<!-- Tidy found serious XHTML errors -->\n";
 562                 } else {
 563                         return $cleansource;
 564                 }
 565         }
 566
 567         /**
 568          * parse the wiki syntax used to render tables
 569          *
 570          * @access private
 571          */
 572         function doTableStuff ( $t ) {
 573                 $fname = 'Parser::doTableStuff';
 574                 wfProfileIn( $fname );
 575
 576                 $t = explode ( "\n" , $t ) ;
 577                 $td = array () ; # Is currently a td tag open?
 578                 $ltd = array () ; # Was it TD or TH?
 579                 $tr = array () ; # Is currently a tr tag open?
 580                 $ltr = array () ; # tr attributes
 581                 $indent_level = 0; # indent level of the table
 582                 foreach ( $t AS $k => $x )
 583                 {
 584                         $x = trim ( $x ) ;
 585                         $fc = substr ( $x , 0 , 1 ) ;
 586                         if ( preg_match( '/^(:*)\{\|(.*)$/', $x, $matches ) ) {
 587                                 $indent_level = strlen( $matches[1] );
 588                                 $t[$k] = "\n" .
 589                                         str_repeat( '<dl><dd>', $indent_level ) .
 590                                         '<table ' . $this->fixTagAttributes ( $matches[2] ) . '>' ;
 591                                 array_push ( $td , false ) ;
 592                                 array_push ( $ltd , '' ) ;
 593                                 array_push ( $tr , false ) ;
 594                                 array_push ( $ltr , '' ) ;
 595                         }
 596                         else if ( count ( $td ) == 0 ) { } # Don't do any of the following
 597                         else if ( '|}' == substr ( $x , 0 , 2 ) ) {
 598                                 $z = "</table>\n" ;
 599                                 $l = array_pop ( $ltd ) ;
 600                                 if ( array_pop ( $tr ) ) $z = '</tr>' . $z ;
 601                                 if ( array_pop ( $td ) ) $z = '</'.$l.'>' . $z ;
 602                                 array_pop ( $ltr ) ;
 603                                 $t[$k] = $z . str_repeat( '</dd></dl>', $indent_level );
 604                         }
 605                         else if ( '|-' == substr ( $x , 0 , 2 ) ) { # Allows for |---------------
 606                                 $x = substr ( $x , 1 ) ;
 607                                 while ( $x != '' && substr ( $x , 0 , 1 ) == '-' ) $x = substr ( $x , 1 ) ;
 608                                 $z = '' ;
 609                                 $l = array_pop ( $ltd ) ;
 610                                 if ( array_pop ( $tr ) ) $z = '</tr>' . $z ;
 611                                 if ( array_pop ( $td ) ) $z = '</'.$l.'>' . $z ;
 612                                 array_pop ( $ltr ) ;
 613                                 $t[$k] = $z ;
 614                                 array_push ( $tr , false ) ;
 615                                 array_push ( $td , false ) ;
 616                                 array_push ( $ltd , '' ) ;
 617                                 array_push ( $ltr , $this->fixTagAttributes ( $x ) ) ;
 618                         }
 619                         else if ( '|' == $fc || '!' == $fc || '|+' == substr ( $x , 0 , 2 ) ) { # Caption
 620                                 # $x is a table row
 621                                 if ( '|+' == substr ( $x , 0 , 2 ) ) {
 622                                         $fc = '+' ;
 623                                         $x = substr ( $x , 1 ) ;
 624                                 }
 625                                 $after = substr ( $x , 1 ) ;
 626                                 if ( $fc == '!' ) $after = str_replace ( '!!' , '||' , $after ) ;
 627                                 $after = explode ( '||' , $after ) ;
 628                                 $t[$k] = '' ;
 629
 630                                 # Loop through each table cell
 631                                 foreach ( $after AS $theline )
 632                                 {
 633                                         $z = '' ;
 634                                         if ( $fc != '+' )
 635                                         {
 636                                                 $tra = array_pop ( $ltr ) ;
 637                                                 if ( !array_pop ( $tr ) ) $z = '<tr '.$tra.">\n" ;
 638                                                 array_push ( $tr , true ) ;
 639                                                 array_push ( $ltr , '' ) ;
 640                                         }
 641
 642                                         $l = array_pop ( $ltd ) ;
 643                                         if ( array_pop ( $td ) ) $z = '</'.$l.'>' . $z ;
 644                                         if ( $fc == '|' ) $l = 'td' ;
 645                                         else if ( $fc == '!' ) $l = 'th' ;
 646                                         else if ( $fc == '+' ) $l = 'caption' ;
 647                                         else $l = '' ;
 648                                         array_push ( $ltd , $l ) ;
 649
 650                                         # Cell parameters
 651                                         $y = explode ( '|' , $theline , 2 ) ;
 652                                         # Note that a '|' inside an invalid link should not
 653                                         # be mistaken as delimiting cell parameters
 654                                         if ( strpos( $y[0], '[[' ) !== false ) {
 655                                                 $y = array ($theline);
 656                                         }
 657                                         if ( count ( $y ) == 1 )
 658                                                 $y = "{$z}<{$l}>{$y[0]}" ;
 659                                         else $y = $y = "{$z}<{$l} ".$this->fixTagAttributes($y[0]).">{$y[1]}" ;
 660                                         $t[$k] .= $y ;
 661                                         array_push ( $td , true ) ;
 662                                 }
 663                         }
 664                 }
 665
 666                 # Closing open td, tr && table
 667                 while ( count ( $td ) > 0 )
 668                 {
 669                         if ( array_pop ( $td ) ) $t[] = '</td>' ;
 670                         if ( array_pop ( $tr ) ) $t[] = '</tr>' ;
 671                         $t[] = '</table>' ;
 672                 }
 673
 674                 $t = implode ( "\n" , $t ) ;
 675                 #               $t = $this->removeHTMLtags( $t );
 676                 wfProfileOut( $fname );
 677                 return $t ;
 678         }
 679
 680         /**
 681          * Helper function for parse() that transforms wiki markup into
 682          * HTML. Only called for $mOutputType == OT_HTML.
 683          *
 684          * @access private
 685          */
 686         function internalParse( $text, $linestart, $args = array(), $isMain=true ) {
 687                 global $wgContLang;
 688
 689                 $fname = 'Parser::internalParse';
 690                 wfProfileIn( $fname );
 691
 692                 $text = $this->removeHTMLtags( $text );
 693                 $text = $this->replaceVariables( $text, $args );
 694
 695                 $text = preg_replace( '/(^|\n)-----*/', '\\1<hr />', $text );
 696
 697                 $text = $this->doHeadings( $text );
 698                 if($this->mOptions->getUseDynamicDates()) {
 699                         global $wgDateFormatter;
 700                         $text = $wgDateFormatter->reformat( $this->mOptions->getDateFormat(), $text );
 701                 }
 702                 $text = $this->doAllQuotes( $text );
 703                 $text = $this->replaceInternalLinks ( $text );
 704                 $text = $this->replaceExternalLinks( $text );
 705
 706                 # replaceInternalLinks may sometimes leave behind
 707                 # absolute URLs, which have to be masked to hide them from replaceExternalLinks
 708                 $text = str_replace("http-noparse://","http://",$text);
 709
 710                 $text = $this->doMagicLinks( $text );
 711                 $text = $this->doTableStuff( $text );
 712                 $text = $this->formatHeadings( $text, $isMain );
 713                 $sk =& $this->mOptions->getSkin();
 714                 $text = $sk->transformContent( $text );
 715
 716                 wfProfileOut( $fname );
 717                 return $text;
 718         }
 719
 720         /**
 721          * Replace special strings like "ISBN xxx" and "RFC xxx" with
 722          * magic external links.
 723          *
 724          * @access private
 725          */
 726         function &doMagicLinks( &$text ) {
 727                 global $wgUseGeoMode;
 728                 $text = $this->magicISBN( $text );
 729                 if ( isset( $wgUseGeoMode ) && $wgUseGeoMode ) {
 730                         $text = $this->magicGEO( $text );
 731                 }
 732                 $text = $this->magicRFC( $text, 'RFC ', 'rfcurl' );
 733                 $text = $this->magicRFC( $text, 'PMID ', 'pubmedurl' );
 734                 return $text;
 735         }
 736
 737         /**
 738          * Parse ^^ tokens and return html
 739          *
 740          * @access private
 741          */
 742         function doExponent( $text ) {
 743                 $fname = 'Parser::doExponent';
 744                 wfProfileIn( $fname );
 745                 $text = preg_replace('/\^\^(.*)\^\^/','<small><sup>\\1</sup></small>', $text);
 746                 wfProfileOut( $fname );
 747                 return $text;
 748         }
 749
 750         /**
 751          * Parse headers and return html
 752          *
 753          * @access private
 754          */
 755         function doHeadings( $text ) {
 756                 $fname = 'Parser::doHeadings';
 757                 wfProfileIn( $fname );
 758                 for ( $i = 6; $i >= 1; --$i ) {
 759                         $h = substr( '======', 0, $i );
 760                         $text = preg_replace( "/^{$h}(.+){$h}(\\s|$)/m",
 761                           "<h{$i}>\\1</h{$i}>\\2", $text );
 762                 }
 763                 wfProfileOut( $fname );
 764                 return $text;
 765         }
 766
 767         /**
 768          * Replace single quotes with HTML markup
 769          * @access private
 770          * @return string the altered text
 771          */
 772         function doAllQuotes( $text ) {
 773                 $fname = 'Parser::doAllQuotes';
 774                 wfProfileIn( $fname );
 775                 $outtext = '';
 776                 $lines = explode( "\n", $text );
 777                 foreach ( $lines as $line ) {
 778                         $outtext .= $this->doQuotes ( $line ) . "\n";
 779                 }
 780                 $outtext = substr($outtext, 0,-1);
 781                 wfProfileOut( $fname );
 782                 return $outtext;
 783         }
 784
 785         /**
 786          * Helper function for doAllQuotes()
 787          * @access private
 788          */
 789         function doQuotes( $text ) {
 790                 $arr = preg_split( "/(''+)/", $text, -1, PREG_SPLIT_DELIM_CAPTURE );
 791                 if ( count( $arr ) == 1 )
 792                         return $text;
 793                 else
 794                 {
 795                         # First, do some preliminary work. This may shift some apostrophes from
 796                         # being mark-up to being text. It also counts the number of occurrences
 797                         # of bold and italics mark-ups.
 798                         $i = 0;
 799                         $numbold = 0;
 800                         $numitalics = 0;
 801                         foreach ( $arr as $r )
 802                         {
 803                                 if ( ( $i % 2 ) == 1 )
 804                                 {
 805                                         # If there are ever four apostrophes, assume the first is supposed to
 806                                         # be text, and the remaining three constitute mark-up for bold text.
 807                                         if ( strlen( $arr[$i] ) == 4 )
 808                                         {
 809                                                 $arr[$i-1] .= "'";
 810                                                 $arr[$i] = "'''";
 811                                         }
 812                                         # If there are more than 5 apostrophes in a row, assume they're all
 813                                         # text except for the last 5.
 814                                         else if ( strlen( $arr[$i] ) > 5 )
 815                                         {
 816                                                 $arr[$i-1] .= str_repeat( "'", strlen( $arr[$i] ) - 5 );
 817                                                 $arr[$i] = "'''''";
 818                                         }
 819                                         # Count the number of occurrences of bold and italics mark-ups.
 820                                         # We are not counting sequences of five apostrophes.
 821                                         if ( strlen( $arr[$i] ) == 2 ) $numitalics++;  else
 822                                         if ( strlen( $arr[$i] ) == 3 ) $numbold++;     else
 823                                         if ( strlen( $arr[$i] ) == 5 ) { $numitalics++; $numbold++; }
 824                                 }
 825                                 $i++;
 826                         }
 827
 828                         # If there is an odd number of both bold and italics, it is likely
 829                         # that one of the bold ones was meant to be an apostrophe followed
 830                         # by italics. Which one we cannot know for certain, but it is more
 831                         # likely to be one that has a single-letter word before it.
 832                         if ( ( $numbold % 2 == 1 ) && ( $numitalics % 2 == 1 ) )
 833                         {
 834                                 $i = 0;
 835                                 $firstsingleletterword = -1;
 836                                 $firstmultiletterword = -1;
 837                                 $firstspace = -1;
 838                                 foreach ( $arr as $r )
 839                                 {
 840                                         if ( ( $i % 2 == 1 ) and ( strlen( $r ) == 3 ) )
 841                                         {
 842                                                 $x1 = substr ($arr[$i-1], -1);
 843                                                 $x2 = substr ($arr[$i-1], -2, 1);
 844                                                 if ($x1 == ' ') {
 845                                                         if ($firstspace == -1) $firstspace = $i;
 846                                                 } else if ($x2 == ' ') {
 847                                                         if ($firstsingleletterword == -1) $firstsingleletterword = $i;
 848                                                 } else {
 849                                                         if ($firstmultiletterword == -1) $firstmultiletterword = $i;
 850                                                 }
 851                                         }
 852                                         $i++;
 853                                 }
 854
 855                                 # If there is a single-letter word, use it!
 856                                 if ($firstsingleletterword > -1)
 857                                 {
 858                                         $arr [ $firstsingleletterword ] = "''";
 859                                         $arr [ $firstsingleletterword-1 ] .= "'";
 860                                 }
 861                                 # If not, but there's a multi-letter word, use that one.
 862                                 else if ($firstmultiletterword > -1)
 863                                 {
 864                                         $arr [ $firstmultiletterword ] = "''";
 865                                         $arr [ $firstmultiletterword-1 ] .= "'";
 866                                 }
 867                                 # ... otherwise use the first one that has neither.
 868                                 # (notice that it is possible for all three to be -1 if, for example,
 869                                 # there is only one pentuple-apostrophe in the line)
 870                                 else if ($firstspace > -1)
 871                                 {
 872                                         $arr [ $firstspace ] = "''";
 873                                         $arr [ $firstspace-1 ] .= "'";
 874                                 }
 875                         }
 876
 877                         # Now let's actually convert our apostrophic mush to HTML!
 878                         $output = '';
 879                         $buffer = '';
 880                         $state = '';
 881                         $i = 0;
 882                         foreach ($arr as $r)
 883                         {
 884                                 if (($i % 2) == 0)
 885                                 {
 886                                         if ($state == 'both')
 887                                                 $buffer .= $r;
 888                                         else
 889                                                 $output .= $r;
 890                                 }
 891                                 else
 892                                 {
 893                                         if (strlen ($r) == 2)
 894                                         {
 895                                                 if ($state == 'i')
 896                                                 { $output .= '</i>'; $state = ''; }
 897                                                 else if ($state == 'bi')
 898                                                 { $output .= '</i>'; $state = 'b'; }
 899                                                 else if ($state == 'ib')
 900                                                 { $output .= '</b></i><b>'; $state = 'b'; }
 901                                                 else if ($state == 'both')
 902                                                 { $output .= '<b><i>'.$buffer.'</i>'; $state = 'b'; }
 903                                                 else # $state can be 'b' or ''
 904                                                 { $output .= '<i>'; $state .= 'i'; }
 905                                         }
 906                                         else if (strlen ($r) == 3)
 907                                         {
 908                                                 if ($state == 'b')
 909                                                 { $output .= '</b>'; $state = ''; }
 910                                                 else if ($state == 'bi')
 911                                                 { $output .= '</i></b><i>'; $state = 'i'; }
 912                                                 else if ($state == 'ib')
 913                                                 { $output .= '</b>'; $state = 'i'; }
 914                                                 else if ($state == 'both')
 915                                                 { $output .= '<i><b>'.$buffer.'</b>'; $state = 'i'; }
 916                                                 else # $state can be 'i' or ''
 917                                                 { $output .= '<b>'; $state .= 'b'; }
 918                                         }
 919                                         else if (strlen ($r) == 5)
 920                                         {
 921                                                 if ($state == 'b')
 922                                                 { $output .= '</b><i>'; $state = 'i'; }
 923                                                 else if ($state == 'i')
 924                                                 { $output .= '</i><b>'; $state = 'b'; }
 925                                                 else if ($state == 'bi')
 926                                                 { $output .= '</i></b>'; $state = ''; }
 927                                                 else if ($state == 'ib')
 928                                                 { $output .= '</b></i>'; $state = ''; }
 929                                                 else if ($state == 'both')
 930                                                 { $output .= '<i><b>'.$buffer.'</b></i>'; $state = ''; }
 931                                                 else # ($state == '')
 932                                                 { $buffer = ''; $state = 'both'; }
 933                                         }
 934                                 }
 935                                 $i++;
 936                         }
 937                         # Now close all remaining tags.  Notice that the order is important.
 938                         if ($state == 'b' || $state == 'ib')
 939                                 $output .= '</b>';
 940                         if ($state == 'i' || $state == 'bi' || $state == 'ib')
 941                                 $output .= '</i>';
 942                         if ($state == 'bi')
 943                                 $output .= '</b>';
 944                         if ($state == 'both')
 945                                 $output .= '<b><i>'.$buffer.'</i></b>';
 946                         return $output;
 947                 }
 948         }
 949
 950         /**
 951          * Replace external links
 952          *
 953          * Note: this is all very hackish and the order of execution matters a lot.
 954          * Make sure to run maintenance/parserTests.php if you change this code.
 955          *
 956          * @access private
 957          */
 958         function replaceExternalLinks( $text ) {
 959                 $fname = 'Parser::replaceExternalLinks';
 960                 wfProfileIn( $fname );
 961
 962                 $sk =& $this->mOptions->getSkin();
 963                 $linktrail = wfMsgForContent('linktrail');
 964                 $bits = preg_split( EXT_LINK_BRACKETED, $text, -1, PREG_SPLIT_DELIM_CAPTURE );
 965
 966                 $s = $this->replaceFreeExternalLinks( array_shift( $bits ) );
 967
 968                 $i = 0;
 969                 while ( $i<count( $bits ) ) {
 970                         $url = $bits[$i++];
 971                         $protocol = $bits[$i++];
 972                         $text = $bits[$i++];
 973                         $trail = $bits[$i++];
 974
 975                         # The characters '<' and '>' (which were escaped by
 976                         # removeHTMLtags()) should not be included in
 977                         # URLs, per RFC 2396.
 978                         if (preg_match('/&(lt|gt);/', $url, $m2, PREG_OFFSET_CAPTURE)) {
 979                                 $text = substr($url, $m2[0][1]) . ' ' . $text;
 980                                 $url = substr($url, 0, $m2[0][1]);
 981                         }
 982
 983                         # If the link text is an image URL, replace it with an <img> tag
 984                         # This happened by accident in the original parser, but some people used it extensively
 985                         $img = $this->maybeMakeImageLink( $text );
 986                         if ( $img !== false ) {
 987                                 $text = $img;
 988                         }
 989
 990                         $dtrail = '';
 991
 992                         # No link text, e.g. [http://domain.tld/some.link]
 993                         if ( $text == '' ) {
 994                                 # Autonumber if allowed
 995                                 if ( strpos( HTTP_PROTOCOLS, $protocol ) !== false ) {
 996                                         $text = '[' . ++$this->mAutonumber . ']';
 997                                 } else {
 998                                         # Otherwise just use the URL
 999                                         $text = htmlspecialchars( $url );
1000                                 }
1001                         } else {
1002                                 # Have link text, e.g. [http://domain.tld/some.link text]s
1003                                 # Check for trail
1004                                 if ( preg_match( $linktrail, $trail, $m2 ) ) {
1005                                         $dtrail = $m2[1];
1006                                         $trail = $m2[2];
1007                                 }
1008                         }
1009
1010                         $encUrl = htmlspecialchars( $url );
1011                         # Bit in parentheses showing the URL for the printable version
1012                         if( $url == $text || preg_match( "!$protocol://" . preg_quote( $text, '/' ) . "/?$!", $url ) ) {
1013                                 $paren = '';
1014                         } else {
1015                                 # Expand the URL for printable version
1016                                 if ( ! $sk->suppressUrlExpansion() ) {
1017                                         $paren = "<span class='urlexpansion'> (<i>" . htmlspecialchars ( $encUrl ) . "</i>)</span>";
1018                                 } else {
1019                                         $paren = '';
1020                                 }
1021                         }
1022
1023                         # Process the trail (i.e. everything after this link up until start of the next link),
1024                         # replacing any non-bracketed links
1025                         $trail = $this->replaceFreeExternalLinks( $trail );
1026
1027                         # Use the encoded URL
1028                         # This means that users can paste URLs directly into the text
1029                         # Funny characters like &ouml; aren't valid in URLs anyway
1030                         # This was changed in August 2004
1031                         $s .= $sk->makeExternalLink( $url, $text, false ) . $dtrail. $paren . $trail;
1032                 }
1033
1034                 wfProfileOut( $fname );
1035                 return $s;
1036         }
1037
1038         /**
1039          * Replace anything that looks like a URL with a link
1040          * @access private
1041          */
1042         function replaceFreeExternalLinks( $text ) {
1043                 $fname = 'Parser::replaceFreeExternalLinks';
1044                 wfProfileIn( $fname );
1045
1046                 $bits = preg_split( '/((?:'.URL_PROTOCOLS.'):)/S', $text, -1, PREG_SPLIT_DELIM_CAPTURE );
1047                 $s = array_shift( $bits );
1048                 $i = 0;
1049
1050                 $sk =& $this->mOptions->getSkin();
1051
1052                 while ( $i < count( $bits ) ){
1053                         $protocol = $bits[$i++];
1054                         $remainder = $bits[$i++];
1055
1056                         if ( preg_match( '/^('.EXT_LINK_URL_CLASS.'+)(.*)$/s', $remainder, $m ) ) {
1057                                 # Found some characters after the protocol that look promising
1058                                 $url = $protocol . $m[1];
1059                                 $trail = $m[2];
1060
1061                                 # The characters '<' and '>' (which were escaped by
1062                                 # removeHTMLtags()) should not be included in
1063                                 # URLs, per RFC 2396.
1064                                 if (preg_match('/&(lt|gt);/', $url, $m2, PREG_OFFSET_CAPTURE)) {
1065                                         $trail = substr($url, $m2[0][1]) . $trail;
1066                                         $url = substr($url, 0, $m2[0][1]);
1067                                 }
1068
1069                                 # Move trailing punctuation to $trail
1070                                 $sep = ',;\.:!?';
1071                                 # If there is no left bracket, then consider right brackets fair game too
1072                                 if ( strpos( $url, '(' ) === false ) {
1073                                         $sep .= ')';
1074                                 }
1075
1076                                 $numSepChars = strspn( strrev( $url ), $sep );
1077                                 if ( $numSepChars ) {
1078                                         $trail = substr( $url, -$numSepChars ) . $trail;
1079                                         $url = substr( $url, 0, -$numSepChars );
1080                                 }
1081
1082                                 # Replace &amp; from obsolete syntax with &.
1083                                 # All HTML entities will be escaped by makeExternalLink()
1084                                 # or maybeMakeImageLink()
1085                                 $url = str_replace( '&amp;', '&', $url );
1086
1087                                 # Is this an external image?
1088                                 $text = $this->maybeMakeImageLink( $url );
1089                                 if ( $text === false ) {
1090                                         # Not an image, make a link
1091                                         $text = $sk->makeExternalLink( $url, $url );
1092                                 }
1093                                 $s .= $text . $trail;
1094                         } else {
1095                                 $s .= $protocol . $remainder;
1096                         }
1097                 }
1098                 wfProfileOut();
1099                 return $s;
1100         }
1101
1102         /**
1103          * make an image if it's allowed
1104          * @access private
1105          */
1106         function maybeMakeImageLink( $url ) {
1107                 $sk =& $this->mOptions->getSkin();
1108                 $text = false;
1109                 if ( $this->mOptions->getAllowExternalImages() ) {
1110                         if ( preg_match( EXT_IMAGE_REGEX, $url ) ) {
1111                                 # Image found
1112                                 $text = $sk->makeImage( htmlspecialchars( $url ) );
1113                         }
1114                 }
1115                 return $text;
1116         }
1117
1118         /**
1119          * Process [[ ]] wikilinks
1120          *
1121          * @access private
1122          */
1123
1124         function replaceInternalLinks( $s ) {
1125                 global $wgLang, $wgContLang, $wgLinkCache;
1126                 global $wgDisableLangConversion;
1127                 static $fname = 'Parser::replaceInternalLinks' ;
1128
1129                 wfProfileIn( $fname );
1130
1131                 wfProfileIn( $fname.'-setup' );
1132                 static $tc = FALSE;
1133                 # the % is needed to support urlencoded titles as well
1134                 if ( !$tc ) { $tc = Title::legalChars() . '#%'; }
1135
1136                 $sk =& $this->mOptions->getSkin();
1137                 global $wgUseOldExistenceCheck;
1138                 # "Post-parse link colour check" works only on wiki text since it's now
1139                 # in Parser. Enable it, then disable it when we're done.
1140                 $saveParseColour = $sk->postParseLinkColour( !$wgUseOldExistenceCheck );
1141
1142                 $redirect = MagicWord::get ( MAG_REDIRECT ) ;
1143
1144                 #split the entire text string on occurences of [[
1145                 $a = explode( '[[', ' ' . $s );
1146                 #get the first element (all text up to first [[), and remove the space we added
1147                 $s = array_shift( $a );
1148                 $s = substr( $s, 1 );
1149
1150                 # Match a link having the form [[namespace:link|alternate]]trail
1151                 static $e1 = FALSE;
1152                 if ( !$e1 ) { $e1 = "/^([{$tc}]+)(?:\\|([^]]+))?]](.*)\$/sD"; }
1153                 # Match cases where there is no "]]", which might still be images
1154                 static $e1_img = FALSE;
1155                 if ( !$e1_img ) { $e1_img = "/^([{$tc}]+)\\|(.*)\$/sD"; }
1156                 # Match the end of a line for a word that's not followed by whitespace,
1157                 # e.g. in the case of 'The Arab al[[Razi]]', 'al' will be matched
1158                 static $e2 = '/^(.*?)([a-zA-Z\x80-\xff]+)$/sD';
1159
1160                 $useLinkPrefixExtension = $wgContLang->linkPrefixExtension();
1161
1162                 $nottalk = !Namespace::isTalk( $this->mTitle->getNamespace() );
1163
1164                 if ( $useLinkPrefixExtension ) {
1165                         if ( preg_match( $e2, $s, $m ) ) {
1166                                 $first_prefix = $m[2];
1167                                 $s = $m[1];
1168                         } else {
1169                                 $first_prefix = false;
1170                         }
1171                 } else {
1172                         $prefix = '';
1173                 }
1174
1175                 $selflink = $this->mTitle->getPrefixedText();
1176                 wfProfileOut( $fname.'-setup' );
1177
1178                 $checkVariantLink = sizeof($wgContLang->getVariants())>1;
1179                 # Loop for each link
1180                 for ($k = 0; isset( $a[$k] ); $k++) {
1181                         $line = $a[$k];
1182                         if ( $useLinkPrefixExtension ) {
1183                                 wfProfileIn( $fname.'-prefixhandling' );
1184                                 if ( preg_match( $e2, $s, $m ) ) {
1185                                         $prefix = $m[2];
1186                                         $s = $m[1];
1187                                 } else {
1188                                         $prefix='';
1189                                 }
1190                                 # first link
1191                                 if($first_prefix) {
1192                                         $prefix = $first_prefix;
1193                                         $first_prefix = false;
1194                                 }
1195                                 wfProfileOut( $fname.'-prefixhandling' );
1196                         }
1197
1198                         $might_be_img = false;
1199
1200                         if ( preg_match( $e1, $line, $m ) ) { # page with normal text or alt
1201                                 $text = $m[2];
1202                                 # fix up urlencoded title texts
1203                                 if(preg_match('/%/', $m[1] )) $m[1] = urldecode($m[1]);
1204                                 $trail = $m[3];
1205                         } elseif( preg_match($e1_img, $line, $m) ) { # Invalid, but might be an image with a link in its caption
1206                                 $might_be_img = true;
1207                                 $text = $m[2];
1208                                 if(preg_match('/%/', $m[1] )) $m[1] = urldecode($m[1]);
1209                                 $trail = "";
1210                         } else { # Invalid form; output directly
1211                                 $s .= $prefix . '[[' . $line ;
1212                                 continue;
1213                         }
1214
1215                         # Don't allow internal links to pages containing
1216                         # PROTO: where PROTO is a valid URL protocol; these
1217                         # should be external links.
1218                         if (preg_match('/^((?:'.URL_PROTOCOLS.'):)/', $m[1])) {
1219                                 $s .= $prefix . '[[' . $line ;
1220                                 continue;
1221                         }
1222
1223                         # Make subpage if necessary
1224                         $link = $this->maybeDoSubpageLink( $m[1], $text );
1225
1226                         $noforce = (substr($m[1], 0, 1) != ':');
1227                         if (!$noforce) {
1228                                 # Strip off leading ':'
1229                                 $link = substr($link, 1);
1230                         }
1231
1232                         $nt =& Title::newFromText( $this->unstripNoWiki($link, $this->mStripState) );
1233                         if( !$nt ) {
1234                                 $s .= $prefix . '[[' . $line;
1235                                 continue;
1236                         }
1237
1238                         #check other language variants of the link
1239                         #if the article does not exist
1240                         if( $checkVariantLink
1241                             && $nt->getArticleID() == 0 ) {
1242                                 $wgContLang->findVariantLink($link, $nt);
1243                         }
1244
1245                         $ns = $nt->getNamespace();
1246                         $iw = $nt->getInterWiki();
1247
1248                         if ($might_be_img) { # if this is actually an invalid link
1249                                 if ($ns == NS_IMAGE && $noforce) { #but might be an image
1250                                         $found = false;
1251                                         while (isset ($a[$k+1]) ) {
1252                                                 #look at the next 'line' to see if we can close it there
1253                                                 $next_line =  array_shift(array_splice( $a, $k + 1, 1) );
1254                                                 if( preg_match("/^(.*?]].*?)]](.*)$/sD", $next_line, $m) ) {
1255                                                 # the first ]] closes the inner link, the second the image
1256                                                         $found = true;
1257                                                         $text .= '[[' . $m[1];
1258                                                         $trail = $m[2];
1259                                                         break;
1260                                                 } elseif( preg_match("/^.*?]].*$/sD", $next_line, $m) ) {
1261                                                         #if there's exactly one ]] that's fine, we'll keep looking
1262                                                         $text .= '[[' . $m[0];
1263                                                 } else {
1264                                                         #if $next_line is invalid too, we need look no further
1265                                                         $text .= '[[' . $next_line;
1266                                                         break;
1267                                                 }
1268                                         }
1269                                         if ( !$found ) {
1270                                                 # we couldn't find the end of this imageLink, so output it raw
1271                                                 #but don't ignore what might be perfectly normal links in the text we've examined
1272                                                 $text = $this->replaceInternalLinks($text);
1273                                                 $s .= $prefix . '[[' . $link . '|' . $text;
1274                                                 # note: no $trail, because without an end, there *is* no trail
1275                                                 continue;
1276                                         }
1277                                 } else { #it's not an image, so output it raw
1278                                         $s .= $prefix . '[[' . $link . '|' . $text;
1279                                         # note: no $trail, because without an end, there *is* no trail
1280                                         continue;
1281                                 }
1282                         }
1283
1284                         $wasblank = ( '' == $text );
1285                         if( $wasblank ) $text = $link;
1286
1287
1288                         # Link not escaped by : , create the various objects
1289                         if( $noforce ) {
1290
1291                                 # Interwikis
1292                                 if( $iw && $this->mOptions->getInterwikiMagic() && $nottalk && $wgContLang->getLanguageName( $iw ) ) {
1293                                         array_push( $this->mOutput->mLanguageLinks, $nt->getFullText() );
1294                                         $tmp = $prefix . $trail ;
1295                                         $s .= (trim($tmp) == '')? '': $tmp;
1296                                         continue;
1297                                 }
1298
1299                                 if ( $ns == NS_IMAGE ) {
1300                                         wfProfileIn( "$fname-image" );
1301
1302                                         # recursively parse links inside the image caption
1303                                         # actually, this will parse them in any other parameters, too,
1304                                         # but it might be hard to fix that, and it doesn't matter ATM
1305                                         $text = $this->replaceExternalLinks($text);
1306                                         $text = $this->replaceInternalLinks($text);
1307
1308                                         # replace the image with a link-holder so that replaceExternalLinks() can't mess with it
1309                                         $s .= $prefix . $this->insertStripItem( $sk->makeImageLinkObj( $nt, $text ), $this->mStripState ) . $trail;
1310                                         $wgLinkCache->addImageLinkObj( $nt );
1311
1312                                         wfProfileOut( "$fname-image" );
1313                                         continue;
1314                                 }
1315
1316                                 if ( $ns == NS_CATEGORY ) {
1317                                         wfProfileIn( "$fname-category" );
1318                                         $t = $nt->getText();
1319
1320                                         $wgLinkCache->suspend(); # Don't save in links/brokenlinks
1321                                         $pPLC=$sk->postParseLinkColour();
1322                                         $sk->postParseLinkColour( false );
1323                                         $t = $sk->makeLinkObj( $nt, $t, '', '' , $prefix );
1324                                         $sk->postParseLinkColour( $pPLC );
1325                                         $wgLinkCache->resume();
1326
1327                                         if ( $wasblank ) {
1328                                                 if ( $this->mTitle->getNamespace() == NS_CATEGORY ) {
1329                                                         $sortkey = $this->mTitle->getText();
1330                                                 } else {
1331                                                         $sortkey = $this->mTitle->getPrefixedText();
1332                                                 }
1333                                         } else {
1334                                                 $sortkey = $text;
1335                                         }
1336                                         $wgLinkCache->addCategoryLinkObj( $nt, $sortkey );
1337                                         $this->mOutput->addCategoryLink( $t );
1338                                         $s .= $prefix . $trail ;
1339
1340                                         wfProfileOut( "$fname-category" );
1341                                         continue;
1342                                 }
1343                         }
1344
1345                         if( ( $nt->getPrefixedText() === $selflink ) &&
1346                             ( $nt->getFragment() === '' ) ) {
1347                                 # Self-links are handled specially; generally de-link and change to bold.
1348                                 $s .= $prefix . $sk->makeSelfLinkObj( $nt, $text, '', $trail );
1349                                 continue;
1350                         }
1351
1352                         # Special and Media are pseudo-namespaces; no pages actually exist in them
1353                         if( $ns == NS_MEDIA ) {
1354                                 $s .= $prefix . $sk->makeMediaLinkObj( $nt, $text, true ) . $trail;
1355                                 $wgLinkCache->addImageLinkObj( $nt );
1356                                 continue;
1357                         } elseif( $ns == NS_SPECIAL ) {
1358                                 $s .= $prefix . $sk->makeKnownLinkObj( $nt, $text, '', $trail );
1359                                 continue;
1360                         }
1361                         $s .= $sk->makeLinkObj( $nt, $text, '', $trail, $prefix );
1362                 }
1363                 $sk->postParseLinkColour( $saveParseColour );
1364                 wfProfileOut( $fname );
1365                 return $s;
1366         }
1367
1368         /**
1369          * Handle link to subpage if necessary
1370          * @param string $target the source of the link
1371          * @param string &$text the link text, modified as necessary
1372          * @return string the full name of the link
1373          * @access private
1374          */
1375         function maybeDoSubpageLink($target, &$text) {
1376                 # Valid link forms:
1377                 # Foobar -- normal
1378                 # :Foobar -- override special treatment of prefix (images, language links)
1379                 # /Foobar -- convert to CurrentPage/Foobar
1380                 # /Foobar/ -- convert to CurrentPage/Foobar, strip the initial / from text
1381                 global $wgNamespacesWithSubpages;
1382
1383                 $fname = 'Parser::maybeDoSubpageLink';
1384                 wfProfileIn( $fname );
1385                 # Look at the first character
1386                 if( $target{0} == '/' ) {
1387                         # / at end means we don't want the slash to be shown
1388                         if(substr($target,-1,1)=='/') {
1389                                 $target=substr($target,1,-1);
1390                                 $noslash=$target;
1391                         } else {
1392                                 $noslash=substr($target,1);
1393                         }
1394
1395                         # Some namespaces don't allow subpages
1396                         if(!empty($wgNamespacesWithSubpages[$this->mTitle->getNamespace()])) {
1397                                 # subpages allowed here
1398                                 $ret = $this->mTitle->getPrefixedText(). '/' . trim($noslash);
1399                                 if( '' === $text ) {
1400                                         $text = $target;
1401                                 } # this might be changed for ugliness reasons
1402                         } else {
1403                                 # no subpage allowed, use standard link
1404                                 $ret = $target;
1405                         }
1406                 } else {
1407                         # no subpage
1408                         $ret = $target;
1409                 }
1410
1411                 wfProfileOut( $fname );
1412                 return $ret;
1413         }
1414
1415         /**#@+
1416          * Used by doBlockLevels()
1417          * @access private
1418          */
1419         /* private */ function closeParagraph() {
1420                 $result = '';
1421                 if ( '' != $this->mLastSection ) {
1422                         $result = '</' . $this->mLastSection  . ">\n";
1423                 }
1424                 $this->mInPre = false;
1425                 $this->mLastSection = '';
1426                 return $result;
1427         }
1428         # getCommon() returns the length of the longest common substring
1429         # of both arguments, starting at the beginning of both.
1430         #
1431         /* private */ function getCommon( $st1, $st2 ) {
1432                 $fl = strlen( $st1 );
1433                 $shorter = strlen( $st2 );
1434                 if ( $fl < $shorter ) { $shorter = $fl; }
1435
1436                 for ( $i = 0; $i < $shorter; ++$i ) {
1437                         if ( $st1{$i} != $st2{$i} ) { break; }
1438                 }
1439                 return $i;
1440         }
1441         # These next three functions open, continue, and close the list
1442         # element appropriate to the prefix character passed into them.
1443         #
1444         /* private */ function openList( $char ) {
1445                 $result = $this->closeParagraph();
1446
1447                 if ( '*' == $char ) { $result .= '<ul><li>'; }
1448                 else if ( '#' == $char ) { $result .= '<ol><li>'; }
1449                 else if ( ':' == $char ) { $result .= '<dl><dd>'; }
1450                 else if ( ';' == $char ) {
1451                         $result .= '<dl><dt>';
1452                         $this->mDTopen = true;
1453                 }
1454                 else { $result = '<!-- ERR 1 -->'; }
1455
1456                 return $result;
1457         }
1458
1459         /* private */ function nextItem( $char ) {
1460                 if ( '*' == $char || '#' == $char ) { return '</li><li>'; }
1461                 else if ( ':' == $char || ';' == $char ) {
1462                         $close = '</dd>';
1463                         if ( $this->mDTopen ) { $close = '</dt>'; }
1464                         if ( ';' == $char ) {
1465                                 $this->mDTopen = true;
1466                                 return $close . '<dt>';
1467                         } else {
1468                                 $this->mDTopen = false;
1469                                 return $close . '<dd>';
1470                         }
1471                 }
1472                 return '<!-- ERR 2 -->';
1473         }
1474
1475         /* private */ function closeList( $char ) {
1476                 if ( '*' == $char ) { $text = '</li></ul>'; }
1477                 else if ( '#' == $char ) { $text = '</li></ol>'; }
1478                 else if ( ':' == $char ) {
1479                         if ( $this->mDTopen ) {
1480                                 $this->mDTopen = false;
1481                                 $text = '</dt></dl>';
1482                         } else {
1483                                 $text = '</dd></dl>';
1484                         }
1485                 }
1486                 else {  return '<!-- ERR 3 -->'; }
1487                 return $text."\n";
1488         }
1489         /**#@-*/
1490
1491         /**
1492          * Make lists from lines starting with ':', '*', '#', etc.
1493          *
1494          * @access private
1495          * @return string the lists rendered as HTML
1496          */
1497         function doBlockLevels( $text, $linestart ) {
1498                 $fname = 'Parser::doBlockLevels';
1499                 wfProfileIn( $fname );
1500
1501                 # Parsing through the text line by line.  The main thing
1502                 # happening here is handling of block-level elements p, pre,
1503                 # and making lists from lines starting with * # : etc.
1504                 #
1505                 $textLines = explode( "\n", $text );
1506
1507                 $lastPrefix = $output = $lastLine = '';
1508                 $this->mDTopen = $inBlockElem = false;
1509                 $prefixLength = 0;
1510                 $paragraphStack = false;
1511
1512                 if ( !$linestart ) {
1513                         $output .= array_shift( $textLines );
1514                 }
1515                 foreach ( $textLines as $oLine ) {
1516                         $lastPrefixLength = strlen( $lastPrefix );
1517                         $preCloseMatch = preg_match('/<\\/pre/i', $oLine );
1518                         $preOpenMatch = preg_match('/<pre/i', $oLine );
1519                         if ( !$this->mInPre ) {
1520                                 # Multiple prefixes may abut each other for nested lists.
1521                                 $prefixLength = strspn( $oLine, '*#:;' );
1522                                 $pref = substr( $oLine, 0, $prefixLength );
1523
1524                                 # eh?
1525                                 $pref2 = str_replace( ';', ':', $pref );
1526                                 $t = substr( $oLine, $prefixLength );
1527                                 $this->mInPre = !empty($preOpenMatch);
1528                         } else {
1529                                 # Don't interpret any other prefixes in preformatted text
1530                                 $prefixLength = 0;
1531                                 $pref = $pref2 = '';
1532                                 $t = $oLine;
1533                         }
1534
1535                         # List generation
1536                         if( $prefixLength && 0 == strcmp( $lastPrefix, $pref2 ) ) {
1537                                 # Same as the last item, so no need to deal with nesting or opening stuff
1538                                 $output .= $this->nextItem( substr( $pref, -1 ) );
1539                                 $paragraphStack = false;
1540
1541                                 if ( substr( $pref, -1 ) == ';') {
1542                                         # The one nasty exception: definition lists work like this:
1543                                         # ; title : definition text
1544                                         # So we check for : in the remainder text to split up the
1545                                         # title and definition, without b0rking links.
1546                                         if ($this->findColonNoLinks($t, $term, $t2) !== false) {
1547                                                 $t = $t2;
1548                                                 $output .= $term . $this->nextItem( ':' );
1549                                         }
1550                                 }
1551                         } elseif( $prefixLength || $lastPrefixLength ) {
1552                                 # Either open or close a level...
1553                                 $commonPrefixLength = $this->getCommon( $pref, $lastPrefix );
1554                                 $paragraphStack = false;
1555
1556                                 while( $commonPrefixLength < $lastPrefixLength ) {
1557                                         $output .= $this->closeList( $lastPrefix{$lastPrefixLength-1} );
1558                                         --$lastPrefixLength;
1559                                 }
1560                                 if ( $prefixLength <= $commonPrefixLength && $commonPrefixLength > 0 ) {
1561                                         $output .= $this->nextItem( $pref{$commonPrefixLength-1} );
1562                                 }
1563                                 while ( $prefixLength > $commonPrefixLength ) {
1564                                         $char = substr( $pref, $commonPrefixLength, 1 );
1565                                         $output .= $this->openList( $char );
1566
1567                                         if ( ';' == $char ) {
1568                                                 # FIXME: This is dupe of code above
1569                                                 if ($this->findColonNoLinks($t, $term, $t2) !== false) {
1570                                                         $t = $t2;
1571                                                         $output .= $term . $this->nextItem( ':' );
1572                                                 }
1573                                         }
1574                                         ++$commonPrefixLength;
1575                                 }
1576                                 $lastPrefix = $pref2;
1577                         }
1578                         if( 0 == $prefixLength ) {
1579                                 wfProfileIn( "$fname-paragraph" );
1580                                 # No prefix (not in list)--go to paragraph mode
1581                                 $uniq_prefix = UNIQ_PREFIX;
1582                                 // XXX: use a stack for nestable elements like span, table and div
1583                                 $openmatch = preg_match('/(<table|<blockquote|<h1|<h2|<h3|<h4|<h5|<h6|<pre|<tr|<p|<ul|<li|<\\/tr|<\\/td|<\\/th)/iS', $t );
1584                                 $closematch = preg_match(
1585                                         '/(<\\/table|<\\/blockquote|<\\/h1|<\\/h2|<\\/h3|<\\/h4|<\\/h5|<\\/h6|'.
1586                                         '<td|<th|<div|<\\/div|<hr|<\\/pre|<\\/p|'.$uniq_prefix.'-pre|<\\/li|<\\/ul)/iS', $t );
1587                                 if ( $openmatch or $closematch ) {
1588                                         $paragraphStack = false;
1589                                         $output .= $this->closeParagraph();
1590                                         if($preOpenMatch and !$preCloseMatch) {
1591                                                 $this->mInPre = true;
1592                                         }
1593                                         if ( $closematch ) {
1594                                                 $inBlockElem = false;
1595                                         } else {
1596                                                 $inBlockElem = true;
1597                                         }
1598                                 } else if ( !$inBlockElem && !$this->mInPre ) {
1599                                         if ( ' ' == $t{0} and ( $this->mLastSection == 'pre' or trim($t) != '' ) ) {
1600                                                 // pre
1601                                                 if ($this->mLastSection != 'pre') {
1602                                                         $paragraphStack = false;
1603                                                         $output .= $this->closeParagraph().'<pre>';
1604                                                         $this->mLastSection = 'pre';
1605                                                 }
1606                                                 $t = substr( $t, 1 );
1607                                         } else {
1608                                                 // paragraph
1609                                                 if ( '' == trim($t) ) {
1610                                                         if ( $paragraphStack ) {
1611                                                                 $output .= $paragraphStack.'<br />';
1612                                                                 $paragraphStack = false;
1613                                                                 $this->mLastSection = 'p';
1614                                                         } else {
1615                                                                 if ($this->mLastSection != 'p' ) {
1616                                                                         $output .= $this->closeParagraph();
1617                                                                         $this->mLastSection = '';
1618                                                                         $paragraphStack = '<p>';
1619                                                                 } else {
1620                                                                         $paragraphStack = '</p><p>';
1621                                                                 }
1622                                                         }
1623                                                 } else {
1624                                                         if ( $paragraphStack ) {
1625                                                                 $output .= $paragraphStack;
1626                                                                 $paragraphStack = false;
1627                                                                 $this->mLastSection = 'p';
1628                                                         } else if ($this->mLastSection != 'p') {
1629                                                                 $output .= $this->closeParagraph().'<p>';
1630                                                                 $this->mLastSection = 'p';
1631                                                         }
1632                                                 }
1633                                         }
1634                                 }
1635                                 wfProfileOut( "$fname-paragraph" );
1636                         }
1637                         if ($paragraphStack === false) {
1638                                 $output .= $t."\n";
1639                         }
1640                 }
1641                 while ( $prefixLength ) {
1642                         $output .= $this->closeList( $pref2{$prefixLength-1} );
1643                         --$prefixLength;
1644                 }
1645                 if ( '' != $this->mLastSection ) {
1646                         $output .= '</' . $this->mLastSection . '>';
1647                         $this->mLastSection = '';
1648                 }
1649
1650                 wfProfileOut( $fname );
1651                 return $output;
1652         }
1653
1654         /**
1655          * Split up a string on ':', ignoring any occurences inside
1656          * <a>..</a> or <span>...</span>
1657          * @param string $str the string to split
1658          * @param string &$before set to everything before the ':'
1659          * @param string &$after set to everything after the ':'
1660          * return string the position of the ':', or false if none found
1661          */
1662         function findColonNoLinks($str, &$before, &$after) {
1663                 # I wonder if we should make this count all tags, not just <a>
1664                 # and <span>. That would prevent us from matching a ':' that
1665                 # comes in the middle of italics other such formatting....
1666                 # -- Wil
1667                 $fname = 'Parser::findColonNoLinks';
1668                 wfProfileIn( $fname );
1669                 $pos = 0;
1670                 do {
1671                         $colon = strpos($str, ':', $pos);
1672
1673                         if ($colon !== false) {
1674                                 $before = substr($str, 0, $colon);
1675                                 $after = substr($str, $colon + 1);
1676
1677                                 # Skip any ':' within <a> or <span> pairs
1678                                 $a = substr_count($before, '<a');
1679                                 $s = substr_count($before, '<span');
1680                                 $ca = substr_count($before, '</a>');
1681                                 $cs = substr_count($before, '</span>');
1682
1683                                 if ($a <= $ca and $s <= $cs) {
1684                                         # Tags are balanced before ':'; ok
1685                                         break;
1686                                 }
1687                                 $pos = $colon + 1;
1688                         }
1689                 } while ($colon !== false);
1690                 wfProfileOut( $fname );
1691                 return $colon;
1692         }
1693
1694         /**
1695          * Return value of a magic variable (like PAGENAME)
1696          *
1697          * @access private
1698          */
1699         function getVariableValue( $index ) {
1700                 global $wgContLang, $wgSitename, $wgServer;
1701
1702                 /**
1703                  * Some of these require message or data lookups and can be
1704                  * expensive to check many times.
1705                  */
1706                 static $varCache = array();
1707                 if( isset( $varCache[$index] ) ) return $varCache[$index];
1708
1709                 switch ( $index ) {
1710                         case MAG_CURRENTMONTH:
1711                                 return $varCache[$index] = $wgContLang->formatNum( date( 'm' ) );
1712                         case MAG_CURRENTMONTHNAME:
1713                                 return $varCache[$index] = $wgContLang->getMonthName( date('n') );
1714                         case MAG_CURRENTMONTHNAMEGEN:
1715                                 return $varCache[$index] = $wgContLang->getMonthNameGen( date('n') );
1716                         case MAG_CURRENTDAY:
1717                                 return $varCache[$index] = $wgContLang->formatNum( date('j') );
1718                         case MAG_PAGENAME:
1719                                 return $this->mTitle->getText();
1720                         case MAG_PAGENAMEE:
1721                                 return $this->mTitle->getPartialURL();
1722                         case MAG_NAMESPACE:
1723                                 # return Namespace::getCanonicalName($this->mTitle->getNamespace());
1724                                 return $wgContLang->getNsText($this->mTitle->getNamespace()); # Patch by Dori
1725                         case MAG_CURRENTDAYNAME:
1726                                 return $varCache[$index] = $wgContLang->getWeekdayName( date('w')+1 );
1727                         case MAG_CURRENTYEAR:
1728                                 return $varCache[$index] = $wgContLang->formatNum( date( 'Y' ) );
1729                         case MAG_CURRENTTIME:
1730                                 return $varCache[$index] = $wgContLang->time( wfTimestampNow(), false );
1731                         case MAG_NUMBEROFARTICLES:
1732                                 return $varCache[$index] = $wgContLang->formatNum( wfNumberOfArticles() );
1733                         case MAG_SITENAME:
1734                                 return $wgSitename;
1735                         case MAG_SERVER:
1736                                 return $wgServer;
1737                         default:
1738                                 return NULL;
1739                 }
1740         }
1741
1742         /**
1743          * initialise the magic variables (like CURRENTMONTHNAME)
1744          *
1745          * @access private
1746          */
1747         function initialiseVariables() {
1748                 $fname = 'Parser::initialiseVariables';
1749                 wfProfileIn( $fname );
1750                 global $wgVariableIDs;
1751                 $this->mVariables = array();
1752                 foreach ( $wgVariableIDs as $id ) {
1753                         $mw =& MagicWord::get( $id );
1754                         $mw->addToArray( $this->mVariables, $this->getVariableValue( $id ) );
1755                 }
1756                 wfProfileOut( $fname );
1757         }
1758
1759         /**
1760          * Replace magic variables, templates, and template arguments
1761          * with the appropriate text. Templates are substituted recursively,
1762          * taking care to avoid infinite loops.
1763          *
1764          * Note that the substitution depends on value of $mOutputType:
1765          *  OT_WIKI: only {{subst:}} templates
1766          *  OT_MSG: only magic variables
1767          *  OT_HTML: all templates and magic variables
1768          *
1769          * @param string $tex The text to transform
1770          * @param array $args Key-value pairs representing template parameters to substitute
1771          * @access private
1772          */
1773         function replaceVariables( $text, $args = array() ) {
1774                 global $wgLang, $wgScript, $wgArticlePath;
1775
1776                 # Prevent too big inclusions
1777                 if( strlen( $text ) > MAX_INCLUDE_SIZE ) {
1778                         return $text;
1779                 }
1780
1781                 $fname = 'Parser::replaceVariables';
1782                 wfProfileIn( $fname );
1783
1784                 $titleChars = Title::legalChars();
1785
1786                 # This function is called recursively. To keep track of arguments we need a stack:
1787                 array_push( $this->mArgStack, $args );
1788
1789                 # Variable substitution
1790                 $text = preg_replace_callback( "/{{([$titleChars]*?)}}/", array( &$this, 'variableSubstitution' ), $text );
1791
1792                 if ( $this->mOutputType == OT_HTML || $this->mOutputType == OT_WIKI ) {
1793                         # Argument substitution
1794                         $text = preg_replace_callback( "/{{{([$titleChars]*?)}}}/", array( &$this, 'argSubstitution' ), $text );
1795                 }
1796                 # Template substitution
1797                 $regex = '/(\\n|{)?{{(['.$titleChars.']*)(\\|.*?|)}}/s';
1798                 $text = preg_replace_callback( $regex, array( &$this, 'braceSubstitution' ), $text );
1799
1800                 array_pop( $this->mArgStack );
1801
1802                 wfProfileOut( $fname );
1803                 return $text;
1804         }
1805
1806         /**
1807          * Replace magic variables
1808          * @access private
1809          */
1810         function variableSubstitution( $matches ) {
1811                 if ( !$this->mVariables ) {
1812                         $this->initialiseVariables();
1813                 }
1814                 $skip = false;
1815                 if ( $this->mOutputType == OT_WIKI ) {
1816                         # Do only magic variables prefixed by SUBST
1817                         $mwSubst =& MagicWord::get( MAG_SUBST );
1818                         if (!$mwSubst->matchStartAndRemove( $matches[1] ))
1819                                 $skip = true;
1820                         # Note that if we don't substitute the variable below,
1821                         # we don't remove the {{subst:}} magic word, in case
1822                         # it is a template rather than a magic variable.
1823                 }
1824                 if ( !$skip && array_key_exists( $matches[1], $this->mVariables ) ) {
1825                         $text = $this->mVariables[$matches[1]];
1826                         $this->mOutput->mContainsOldMagic = true;
1827                 } else {
1828                         $text = $matches[0];
1829                 }
1830                 return $text;
1831         }
1832
1833         # Split template arguments
1834         function getTemplateArgs( $argsString ) {
1835                 if ( $argsString === '' ) {
1836                         return array();
1837                 }
1838
1839                 $args = explode( '|', substr( $argsString, 1 ) );
1840
1841                 # If any of the arguments contains a '[[' but no ']]', it needs to be
1842                 # merged with the next arg because the '|' character between belongs
1843                 # to the link syntax and not the template parameter syntax.
1844                 $argc = count($args);
1845                 $i = 0;
1846                 for ( $i = 0; $i < $argc-1; $i++ ) {
1847                         if ( substr_count ( $args[$i], '[[' ) != substr_count ( $args[$i], ']]' ) ) {
1848                                 $args[$i] .= '|'.$args[$i+1];
1849                                 array_splice($args, $i+1, 1);
1850                                 $i--;
1851                                 $argc--;
1852                         }
1853                 }
1854
1855                 return $args;
1856         }
1857
1858         /**
1859          * Return the text of a template, after recursively
1860          * replacing any variables or templates within the template.
1861          *
1862          * @param array $matches The parts of the template
1863          *  $matches[1]: the title, i.e. the part before the |
1864          *  $matches[2]: the parameters (including a leading |), if  any
1865          * @return string the text of the template
1866          * @access private
1867          */
1868         function braceSubstitution( $matches ) {
1869                 global $wgLinkCache, $wgContLang;
1870                 $fname = 'Parser::braceSubstitution';
1871                 $found = false;
1872                 $nowiki = false;
1873                 $noparse = false;
1874
1875                 $title = NULL;
1876
1877                 # Need to know if the template comes at the start of a line,
1878                 # to treat the beginning of the template like the beginning
1879                 # of a line for tables and block-level elements.
1880                 $linestart = $matches[1];
1881
1882                 # $part1 is the bit before the first |, and must contain only title characters
1883                 # $args is a list of arguments, starting from index 0, not including $part1
1884
1885                 $part1 = $matches[2];
1886                 # If the third subpattern matched anything, it will start with |
1887
1888                 $args = $this->getTemplateArgs($matches[3]);
1889                 $argc = count( $args );
1890
1891                 # Don't parse {{{}}} because that's only for template arguments
1892                 if ( $linestart === '{' ) {
1893                         $text = $matches[0];
1894                         $found = true;
1895                         $noparse = true;
1896                 }
1897
1898                 # SUBST
1899                 if ( !$found ) {
1900                         $mwSubst =& MagicWord::get( MAG_SUBST );
1901                         if ( $mwSubst->matchStartAndRemove( $part1 ) xor ($this->mOutputType == OT_WIKI) ) {
1902                                 # One of two possibilities is true:
1903                                 # 1) Found SUBST but not in the PST phase
1904                                 # 2) Didn't find SUBST and in the PST phase
1905                                 # In either case, return without further processing
1906                                 $text = $matches[0];
1907                                 $found = true;
1908                                 $noparse = true;
1909                         }
1910                 }
1911
1912                 # MSG, MSGNW and INT
1913                 if ( !$found ) {
1914                         # Check for MSGNW:
1915                         $mwMsgnw =& MagicWord::get( MAG_MSGNW );
1916                         if ( $mwMsgnw->matchStartAndRemove( $part1 ) ) {
1917                                 $nowiki = true;
1918                         } else {
1919                                 # Remove obsolete MSG:
1920                                 $mwMsg =& MagicWord::get( MAG_MSG );
1921                                 $mwMsg->matchStartAndRemove( $part1 );
1922                         }
1923
1924                         # Check if it is an internal message
1925                         $mwInt =& MagicWord::get( MAG_INT );
1926                         if ( $mwInt->matchStartAndRemove( $part1 ) ) {
1927                                 if ( $this->incrementIncludeCount( 'int:'.$part1 ) ) {
1928                                         $text = $linestart . wfMsgReal( $part1, $args, true );
1929                                         $found = true;
1930                                 }
1931                         }
1932                 }
1933
1934                 # NS
1935                 if ( !$found ) {
1936                         # Check for NS: (namespace expansion)
1937                         $mwNs = MagicWord::get( MAG_NS );
1938                         if ( $mwNs->matchStartAndRemove( $part1 ) ) {
1939                                 if ( intval( $part1 ) ) {
1940                                         $text = $linestart . $wgContLang->getNsText( intval( $part1 ) );
1941                                         $found = true;
1942                                 } else {
1943                                         $index = Namespace::getCanonicalIndex( strtolower( $part1 ) );
1944                                         if ( !is_null( $index ) ) {
1945                                                 $text = $linestart . $wgContLang->getNsText( $index );
1946                                                 $found = true;
1947                                         }
1948                                 }
1949                         }
1950                 }
1951
1952                 # LOCALURL and LOCALURLE
1953                 if ( !$found ) {
1954                         $mwLocal = MagicWord::get( MAG_LOCALURL );
1955                         $mwLocalE = MagicWord::get( MAG_LOCALURLE );
1956
1957                         if ( $mwLocal->matchStartAndRemove( $part1 ) ) {
1958                                 $func = 'getLocalURL';
1959                         } elseif ( $mwLocalE->matchStartAndRemove( $part1 ) ) {
1960                                 $func = 'escapeLocalURL';
1961                         } else {
1962                                 $func = '';
1963                         }
1964
1965                         if ( $func !== '' ) {
1966                                 $title = Title::newFromText( $part1 );
1967                                 if ( !is_null( $title ) ) {
1968                                         if ( $argc > 0 ) {
1969                                                 $text = $linestart . $title->$func( $args[0] );
1970                                         } else {
1971                                                 $text = $linestart . $title->$func();
1972                                         }
1973                                         $found = true;
1974                                 }
1975                         }
1976                 }
1977
1978                 # GRAMMAR
1979                 if ( !$found && $argc == 1 ) {
1980                         $mwGrammar =& MagicWord::get( MAG_GRAMMAR );
1981                         if ( $mwGrammar->matchStartAndRemove( $part1 ) ) {
1982                                 $text = $linestart . $wgContLang->convertGrammar( $args[0], $part1 );
1983                                 $found = true;
1984                         }
1985                 }
1986
1987                 # Template table test
1988
1989                 # Did we encounter this template already? If yes, it is in the cache
1990                 # and we need to check for loops.
1991                 if ( !$found && isset( $this->mTemplates[$part1] ) ) {
1992                         # set $text to cached message.
1993                         $text = $linestart . $this->mTemplates[$part1];
1994                         $found = true;
1995
1996                         # Infinite loop test
1997                         if ( isset( $this->mTemplatePath[$part1] ) ) {
1998                                 $noparse = true;
1999                                 $found = true;
2000                                 $text .= '<!-- WARNING: template loop detected -->';
2001                         }
2002                 }
2003
2004                 # Load from database
2005                 $itcamefromthedatabase = false;
2006                 if ( !$found ) {
2007                         $ns = NS_TEMPLATE;
2008                         $part1 = $this->maybeDoSubpageLink( $part1, $subpage='' );
2009                         if ($subpage !== '') {
2010                                 $ns = $this->mTitle->getNamespace();
2011                         }
2012                         $title = Title::newFromText( $part1, $ns );
2013                         if ( !is_null( $title ) && !$title->isExternal() ) {
2014                                 # Check for excessive inclusion
2015                                 $dbk = $title->getPrefixedDBkey();
2016                                 if ( $this->incrementIncludeCount( $dbk ) ) {
2017                                         # This should never be reached.
2018                                         $article = new Article( $title );
2019                                         $articleContent = $article->getContentWithoutUsingSoManyDamnGlobals();
2020                                         if ( $articleContent !== false ) {
2021                                                 $found = true;
2022                                                 $text = $linestart . $articleContent;
2023                                                 $itcamefromthedatabase = true;
2024                                         }
2025                                 }
2026
2027                                 # If the title is valid but undisplayable, make a link to it
2028                                 if ( $this->mOutputType == OT_HTML && !$found ) {
2029                                         $text = $linestart . '[['.$title->getPrefixedText().']]';
2030                                         $found = true;
2031                                 }
2032
2033                                 # Template cache array insertion
2034                                 $this->mTemplates[$part1] = $text;
2035                         }
2036                 }
2037
2038                 # Recursive parsing, escaping and link table handling
2039                 # Only for HTML output
2040                 if ( $nowiki && $found && $this->mOutputType == OT_HTML ) {
2041                         $text = wfEscapeWikiText( $text );
2042                 } elseif ( ($this->mOutputType == OT_HTML || $this->mOutputType == OT_WIKI) && $found && !$noparse) {
2043                         # Clean up argument array
2044                         $assocArgs = array();
2045                         $index = 1;
2046                         foreach( $args as $arg ) {
2047                                 $eqpos = strpos( $arg, '=' );
2048                                 if ( $eqpos === false ) {
2049                                         $assocArgs[$index++] = $arg;
2050                                 } else {
2051                                         $name = trim( substr( $arg, 0, $eqpos ) );
2052                                         $value = trim( substr( $arg, $eqpos+1 ) );
2053                                         if ( $value === false ) {
2054                                                 $value = '';
2055                                         }
2056                                         if ( $name !== false ) {
2057                                                 $assocArgs[$name] = $value;
2058                                         }
2059                                 }
2060                         }
2061
2062                         # Add a new element to the templace recursion path
2063                         $this->mTemplatePath[$part1] = 1;
2064
2065                         $text = $this->strip( $text, $this->mStripState );
2066                         $text = $this->removeHTMLtags( $text );
2067                         $text = $this->replaceVariables( $text, $assocArgs );
2068
2069                         # Resume the link cache and register the inclusion as a link
2070                         if ( $this->mOutputType == OT_HTML && !is_null( $title ) ) {
2071                                 $wgLinkCache->addLinkObj( $title );
2072                         }
2073
2074                         # If the template begins with a table or block-level
2075                         # element, it should be treated as beginning a new line.
2076                         if ($linestart !== '\n' && preg_match('/^({\\||:|;|#|\*)/', $text)) {
2077                                 $text = "\n" . $text;
2078                         }
2079                 }
2080
2081                 # Empties the template path
2082                 $this->mTemplatePath = array();
2083                 if ( !$found ) {
2084                         return $matches[0];
2085                 } else {
2086                         # replace ==section headers==
2087                         # XXX this needs to go away once we have a better parser.
2088                         if ( $this->mOutputType != OT_WIKI && $itcamefromthedatabase ) {
2089                                 if( !is_null( $title ) )
2090                                         $encodedname = base64_encode($title->getPrefixedDBkey());
2091                                 else
2092                                         $encodedname = base64_encode("");
2093                                 $m = preg_split('/(^={1,6}.*?={1,6}\s*?$)/m', $text, -1,
2094                                         PREG_SPLIT_DELIM_CAPTURE);
2095                                 $text = '';
2096                                 $nsec = 0;
2097                                 for( $i = 0; $i < count($m); $i += 2 ) {
2098                                         $text .= $m[$i];
2099                                         if (!isset($m[$i + 1]) || $m[$i + 1] == "") continue;
2100                                         $hl = $m[$i + 1];
2101                                         if( strstr($hl, "<!--MWTEMPLATESECTION") ) {
2102                                                 $text .= $hl;
2103                                                 continue;
2104                                         }
2105                                         preg_match('/^(={1,6})(.*?)(={1,6})\s*?$/m', $hl, $m2);
2106                                         $text .= $m2[1] . $m2[2] . "<!--MWTEMPLATESECTION="
2107                                                 . $encodedname . "&" . base64_encode("$nsec") . "-->" . $m2[3];
2108
2109                                         $nsec++;
2110                                 }
2111                         }
2112                 }
2113
2114                 # Empties the template path
2115                 $this->mTemplatePath = array();
2116
2117                 if ( !$found ) {
2118                         return $matches[0];
2119                 } else {
2120                         return $text;
2121                 }
2122         }
2123
2124         /**
2125          * Triple brace replacement -- used for template arguments
2126          * @access private
2127          */
2128         function argSubstitution( $matches ) {
2129                 $arg = trim( $matches[1] );
2130                 $text = $matches[0];
2131                 $inputArgs = end( $this->mArgStack );
2132
2133                 if ( array_key_exists( $arg, $inputArgs ) ) {
2134                         $text = $inputArgs[$arg];
2135                 }
2136
2137                 return $text;
2138         }
2139
2140         /**
2141          * Returns true if the function is allowed to include this entity
2142          * @access private
2143          */
2144         function incrementIncludeCount( $dbk ) {
2145                 if ( !array_key_exists( $dbk, $this->mIncludeCount ) ) {
2146                         $this->mIncludeCount[$dbk] = 0;
2147                 }
2148                 if ( ++$this->mIncludeCount[$dbk] <= MAX_INCLUDE_REPEAT ) {
2149                         return true;
2150                 } else {
2151                         return false;
2152                 }
2153         }
2154
2155
2156         /**
2157          * Cleans up HTML, removes dangerous tags and attributes, and
2158          * removes HTML comments
2159          * @access private
2160          */
2161         function removeHTMLtags( $text ) {
2162                 global $wgUseTidy, $wgUserHtml;
2163                 $fname = 'Parser::removeHTMLtags';
2164                 wfProfileIn( $fname );
2165
2166                 if( $wgUserHtml ) {
2167                         $htmlpairs = array( # Tags that must be closed
2168                                 'b', 'del', 'i', 'ins', 'u', 'font', 'big', 'small', 'sub', 'sup', 'h1',
2169                                 'h2', 'h3', 'h4', 'h5', 'h6', 'cite', 'code', 'em', 's',
2170                                 'strike', 'strong', 'tt', 'var', 'div', 'center',
2171                                 'blockquote', 'ol', 'ul', 'dl', 'table', 'caption', 'pre',
2172                                 'ruby', 'rt' , 'rb' , 'rp', 'p'
2173                         );
2174                         $htmlsingle = array(
2175                                 'br', 'hr', 'li', 'dt', 'dd'
2176                         );
2177                         $htmlnest = array( # Tags that can be nested--??
2178                                 'table', 'tr', 'td', 'th', 'div', 'blockquote', 'ol', 'ul',
2179                                 'dl', 'font', 'big', 'small', 'sub', 'sup'
2180                         );
2181                         $tabletags = array( # Can only appear inside table
2182                                 'td', 'th', 'tr'
2183                         );
2184                 } else {
2185                         $htmlpairs = array();
2186                         $htmlsingle = array();
2187                         $htmlnest = array();
2188                         $tabletags = array();
2189                 }
2190
2191                 $htmlsingle = array_merge( $tabletags, $htmlsingle );
2192                 $htmlelements = array_merge( $htmlsingle, $htmlpairs );
2193
2194                 $htmlattrs = $this->getHTMLattrs () ;
2195
2196                 # Remove HTML comments
2197                 $text = $this->removeHTMLcomments( $text );
2198
2199                 $bits = explode( '<', $text );
2200                 $text = array_shift( $bits );
2201                 if(!$wgUseTidy) {
2202                         $tagstack = array(); $tablestack = array();
2203                         foreach ( $bits as $x ) {
2204                                 $prev = error_reporting( E_ALL & ~( E_NOTICE | E_WARNING ) );
2205                                 preg_match( '/^(\\/?)(\\w+)([^>]*)(\\/{0,1}>)([^<]*)$/',
2206                                 $x, $regs );
2207                                 list( $qbar, $slash, $t, $params, $brace, $rest ) = $regs;
2208                                 error_reporting( $prev );
2209
2210                                 $badtag = 0 ;
2211                                 if ( in_array( $t = strtolower( $t ), $htmlelements ) ) {
2212                                         # Check our stack
2213                                         if ( $slash ) {
2214                                                 # Closing a tag...
2215                                                 if ( ! in_array( $t, $htmlsingle ) &&
2216                                                 ( $ot = @array_pop( $tagstack ) ) != $t ) {
2217                                                         @array_push( $tagstack, $ot );
2218                                                         $badtag = 1;
2219                                                 } else {
2220                                                         if ( $t == 'table' ) {
2221                                                                 $tagstack = array_pop( $tablestack );
2222                                                         }
2223                                                         $newparams = '';
2224                                                 }
2225                                         } else {
2226                                                 # Keep track for later
2227                                                 if ( in_array( $t, $tabletags ) &&
2228                                                 ! in_array( 'table', $tagstack ) ) {
2229                                                         $badtag = 1;
2230                                                 } else if ( in_array( $t, $tagstack ) &&
2231                                                 ! in_array ( $t , $htmlnest ) ) {
2232                                                         $badtag = 1 ;
2233                                                 } else if ( ! in_array( $t, $htmlsingle ) ) {
2234                                                         if ( $t == 'table' ) {
2235                                                                 array_push( $tablestack, $tagstack );
2236                                                                 $tagstack = array();
2237                                                         }
2238                                                         array_push( $tagstack, $t );
2239                                                 }
2240                                                 # Strip non-approved attributes from the tag
2241                                                 $newparams = $this->fixTagAttributes($params);
2242
2243                                         }
2244                                         if ( ! $badtag ) {
2245                                                 $rest = str_replace( '>', '&gt;', $rest );
2246                                                 $text .= "<$slash$t $newparams$brace$rest";
2247                                                 continue;
2248                                         }
2249                                 }
2250                                 $text .= '&lt;' . str_replace( '>', '&gt;', $x);
2251                         }
2252                         # Close off any remaining tags
2253                         while ( is_array( $tagstack ) && ($t = array_pop( $tagstack )) ) {
2254                                 $text .= "</$t>\n";
2255                                 if ( $t == 'table' ) { $tagstack = array_pop( $tablestack ); }
2256                         }
2257                 } else {
2258                         # this might be possible using tidy itself
2259                         foreach ( $bits as $x ) {
2260                                 preg_match( '/^(\\/?)(\\w+)([^>]*)(\\/{0,1}>)([^<]*)$/',
2261                                 $x, $regs );
2262                                 @list( $qbar, $slash, $t, $params, $brace, $rest ) = $regs;
2263                                 if ( in_array( $t = strtolower( $t ), $htmlelements ) ) {
2264                                         $newparams = $this->fixTagAttributes($params);
2265                                         $rest = str_replace( '>', '&gt;', $rest );
2266                                         $text .= "<$slash$t $newparams$brace$rest";
2267                                 } else {
2268                                         $text .= '&lt;' . str_replace( '>', '&gt;', $x);
2269                                 }
2270                         }
2271                 }
2272                 wfProfileOut( $fname );
2273                 return $text;
2274         }
2275
2276         /**
2277          * Remove '<!--', '-->', and everything between.
2278          * To avoid leaving blank lines, when a comment is both preceded
2279          * and followed by a newline (ignoring spaces), trim leading and
2280          * trailing spaces and one of the newlines.
2281          *
2282          * @access private
2283          */
2284         function removeHTMLcomments( $text ) {
2285                 $fname='Parser::removeHTMLcomments';
2286                 wfProfileIn( $fname );
2287                 while (($start = strpos($text, '<!--')) !== false) {
2288                         $end = strpos($text, '-->', $start + 4);
2289                         if ($end === false) {
2290                                 # Unterminated comment; bail out
2291                                 break;
2292                         }
2293
2294                         $end += 3;
2295
2296                         # Trim space and newline if the comment is both
2297                         # preceded and followed by a newline
2298                         $spaceStart = max($start - 1, 0);
2299                         $spaceLen = $end - $spaceStart;
2300                         while (substr($text, $spaceStart, 1) === ' ' && $spaceStart > 0) {
2301                                 $spaceStart--;
2302                                 $spaceLen++;
2303                         }
2304                         while (substr($text, $spaceStart + $spaceLen, 1) === ' ')
2305                                 $spaceLen++;
2306                         if (substr($text, $spaceStart, 1) === "\n" and substr($text, $spaceStart + $spaceLen, 1) === "\n") {
2307                                 # Remove the comment, leading and trailing
2308                                 # spaces, and leave only one newline.
2309                                 $text = substr_replace($text, "\n", $spaceStart, $spaceLen + 1);
2310                         }
2311                         else {
2312                                 # Remove just the comment.
2313                                 $text = substr_replace($text, '', $start, $end - $start);
2314                         }
2315                 }
2316                 wfProfileOut( $fname );
2317                 return $text;
2318         }
2319
2320         /**
2321          * This function accomplishes several tasks:
2322          * 1) Auto-number headings if that option is enabled
2323          * 2) Add an [edit] link to sections for logged in users who have enabled the option
2324          * 3) Add a Table of contents on the top for users who have enabled the option
2325          * 4) Auto-anchor headings
2326          *
2327          * It loops through all headlines, collects the necessary data, then splits up the
2328          * string and re-inserts the newly formatted headlines.
2329          * @access private
2330          */
2331         /* private */ function formatHeadings( $text, $isMain=true ) {
2332                 global $wgInputEncoding, $wgMaxTocLevel, $wgContLang, $wgLinkHolders;
2333
2334                 $doNumberHeadings = $this->mOptions->getNumberHeadings();
2335                 $doShowToc = $this->mOptions->getShowToc();
2336                 $forceTocHere = false;
2337                 if( !$this->mTitle->userCanEdit() ) {
2338                         $showEditLink = 0;
2339                         $rightClickHack = 0;
2340                 } else {
2341                         $showEditLink = $this->mOptions->getEditSection();
2342                         $rightClickHack = $this->mOptions->getEditSectionOnRightClick();
2343                 }
2344
2345                 # Inhibit editsection links if requested in the page
2346                 $esw =& MagicWord::get( MAG_NOEDITSECTION );
2347                 if( $esw->matchAndRemove( $text ) ) {
2348                         $showEditLink = 0;
2349                 }
2350                 # if the string __NOTOC__ (not case-sensitive) occurs in the HTML,
2351                 # do not add TOC
2352                 $mw =& MagicWord::get( MAG_NOTOC );
2353                 if( $mw->matchAndRemove( $text ) ) {
2354                         $doShowToc = 0;
2355                 }
2356
2357                 # never add the TOC to the Main Page. This is an entry page that should not
2358                 # be more than 1-2 screens large anyway
2359                 if( $this->mTitle->getPrefixedText() == wfMsg('mainpage') ) {
2360                         $doShowToc = 0;
2361                 }
2362
2363                 # Get all headlines for numbering them and adding funky stuff like [edit]
2364                 # links - this is for later, but we need the number of headlines right now
2365                 $numMatches = preg_match_all( '/<H([1-6])(.*?' . '>)(.*?)<\/H[1-6]>/i', $text, $matches );
2366
2367                 # if there are fewer than 4 headlines in the article, do not show TOC
2368                 if( $numMatches < 4 ) {
2369                         $doShowToc = 0;
2370                 }
2371
2372                 # if the string __TOC__ (not case-sensitive) occurs in the HTML,
2373                 # override above conditions and always show TOC at that place
2374                 $mw =& MagicWord::get( MAG_TOC );
2375                 if ($mw->match( $text ) ) {
2376                         $doShowToc = 1;
2377                         $forceTocHere = true;
2378                 } else {
2379                         # if the string __FORCETOC__ (not case-sensitive) occurs in the HTML,
2380                         # override above conditions and always show TOC above first header
2381                         $mw =& MagicWord::get( MAG_FORCETOC );
2382                         if ($mw->matchAndRemove( $text ) ) {
2383                                 $doShowToc = 1;
2384                         }
2385                 }
2386
2387
2388
2389                 # We need this to perform operations on the HTML
2390                 $sk =& $this->mOptions->getSkin();
2391
2392                 # headline counter
2393                 $headlineCount = 0;
2394                 $sectionCount = 0; # headlineCount excluding template sections
2395
2396                 # Ugh .. the TOC should have neat indentation levels which can be
2397                 # passed to the skin functions. These are determined here
2398                 $toclevel = 0;
2399                 $toc = '';
2400                 $full = '';
2401                 $head = array();
2402                 $sublevelCount = array();
2403                 $level = 0;
2404                 $prevlevel = 0;
2405                 foreach( $matches[3] as $headline ) {
2406                         $istemplate = 0;
2407                         $templatetitle = "";
2408                         $templatesection = 0;
2409
2410                         if (preg_match("/<!--MWTEMPLATESECTION=([^&]+)&([^_]+)-->/", $headline, $mat)) {
2411                                 $istemplate = 1;
2412                                 $templatetitle = base64_decode($mat[1]);
2413                                 $templatesection = 1 + (int)base64_decode($mat[2]);
2414                                 $headline = preg_replace("/<!--MWTEMPLATESECTION=([^&]+)&([^_]+)-->/", "", $headline);
2415                         }
2416
2417                         $numbering = '';
2418                         if( $level ) {
2419                                 $prevlevel = $level;
2420                         }
2421                         $level = $matches[1][$headlineCount];
2422                         if( ( $doNumberHeadings || $doShowToc ) && $prevlevel && $level > $prevlevel ) {
2423                                 # reset when we enter a new level
2424                                 $sublevelCount[$level] = 0;
2425                                 $toc .= $sk->tocIndent( $level - $prevlevel );
2426                                 $toclevel += $level - $prevlevel;
2427                         }
2428                         if( ( $doNumberHeadings || $doShowToc ) && $level < $prevlevel ) {
2429                                 # reset when we step back a level
2430                                 $sublevelCount[$level+1]=0;
2431                                 $toc .= $sk->tocUnindent( $prevlevel - $level );
2432                                 $toclevel -= $prevlevel - $level;
2433                         }
2434                         # count number of headlines for each level
2435                         @$sublevelCount[$level]++;
2436                         if( $doNumberHeadings || $doShowToc ) {
2437                                 $dot = 0;
2438                                 for( $i = 1; $i <= $level; $i++ ) {
2439                                         if( !empty( $sublevelCount[$i] ) ) {
2440                                                 if( $dot ) {
2441                                                         $numbering .= '.';
2442                                                 }
2443                                                 $numbering .= $wgContLang->formatNum( $sublevelCount[$i] );
2444                                                 $dot = 1;
2445                                         }
2446                                 }
2447                         }
2448
2449                         # The canonized header is a version of the header text safe to use for links
2450                         # Avoid insertion of weird stuff like <math> by expanding the relevant sections
2451                         $canonized_headline = $this->unstrip( $headline, $this->mStripState );
2452                         $canonized_headline = $this->unstripNoWiki( $headline, $this->mStripState );
2453
2454                         # Remove link placeholders by the link text.
2455                         #     <!--LINK number-->
2456                         # turns into
2457                         #     link text with suffix
2458                         $canonized_headline = preg_replace( '/<!--LINK ([0-9]*)-->/e',
2459                                                             "\$wgLinkHolders['texts'][\$1]",
2460                                                             $canonized_headline );
2461
2462                         # strip out HTML
2463                         $canonized_headline = preg_replace( '/<.*?' . '>/','',$canonized_headline );
2464                         $tocline = trim( $canonized_headline );
2465                         $canonized_headline = urlencode( do_html_entity_decode( str_replace(' ', '_', $tocline), ENT_COMPAT, $wgInputEncoding ) );
2466                         $replacearray = array(
2467                                 '%3A' => ':',
2468                                 '%' => '.'
2469                         );
2470                         $canonized_headline = str_replace(array_keys($replacearray),array_values($replacearray),$canonized_headline);
2471                         $refer[$headlineCount] = $canonized_headline;
2472
2473                         # count how many in assoc. array so we can track dupes in anchors
2474                         @$refers[$canonized_headline]++;
2475                         $refcount[$headlineCount]=$refers[$canonized_headline];
2476
2477                         # Prepend the number to the heading text
2478
2479                         if( $doNumberHeadings || $doShowToc ) {
2480                                 $tocline = $numbering . ' ' . $tocline;
2481
2482                                 # Don't number the heading if it is the only one (looks silly)
2483                                 if( $doNumberHeadings && count( $matches[3] ) > 1) {
2484                                         # the two are different if the line contains a link
2485                                         $headline=$numbering . ' ' . $headline;
2486                                 }
2487                         }
2488
2489                         # Create the anchor for linking from the TOC to the section
2490                         $anchor = $canonized_headline;
2491                         if($refcount[$headlineCount] > 1 ) {
2492                                 $anchor .= '_' . $refcount[$headlineCount];
2493                         }
2494                         if( $doShowToc && ( !isset($wgMaxTocLevel) || $toclevel<$wgMaxTocLevel ) ) {
2495                                 $toc .= $sk->tocLine($anchor,$tocline,$toclevel);
2496                         }
2497                         if( $showEditLink && ( !$istemplate || $templatetitle !== "" ) ) {
2498                                 if ( empty( $head[$headlineCount] ) ) {
2499                                         $head[$headlineCount] = '';
2500                                 }
2501                                 if( $istemplate )
2502                                         $head[$headlineCount] .= $sk->editSectionLinkForOther($templatetitle, $templatesection);
2503                                 else
2504                                         $head[$headlineCount] .= $sk->editSectionLink($this->mTitle, $sectionCount+1);
2505                         }
2506
2507                         # Add the edit section span
2508                         if( $rightClickHack ) {
2509                                 if( $istemplate )
2510                                         $headline = $sk->editSectionScriptForOther($templatetitle, $templatesection, $headline);
2511                                 else
2512                                         $headline = $sk->editSectionScript($this->mTitle, $sectionCount+1,$headline);
2513                         }
2514
2515                         # give headline the correct <h#> tag
2516                         @$head[$headlineCount] .= "<a name=\"$anchor\"></a><h".$level.$matches[2][$headlineCount] .$headline.'</h'.$level.'>';
2517
2518                         $headlineCount++;
2519                         if( !$istemplate )
2520                                 $sectionCount++;
2521                 }
2522
2523                 if( $doShowToc ) {
2524                         $toclines = $headlineCount;
2525                         $toc .= $sk->tocUnindent( $toclevel );
2526                         $toc = $sk->tocTable( $toc );
2527                 }
2528
2529                 # split up and insert constructed headlines
2530
2531                 $blocks = preg_split( '/<H[1-6].*?' . '>.*?<\/H[1-6]>/i', $text );
2532                 $i = 0;
2533
2534                 foreach( $blocks as $block ) {
2535                         if( $showEditLink && $headlineCount > 0 && $i == 0 && $block != "\n" ) {
2536                                 # This is the [edit] link that appears for the top block of text when
2537                                 # section editing is enabled
2538
2539                                 # Disabled because it broke block formatting
2540                                 # For example, a bullet point in the top line
2541                                 # $full .= $sk->editSectionLink(0);
2542                         }
2543                         $full .= $block;
2544                         if( $doShowToc && !$i && $isMain && !$forceTocHere) {
2545                         # Top anchor now in skin
2546                                 $full = $full.$toc;
2547                         }
2548
2549                         if( !empty( $head[$i] ) ) {
2550                                 $full .= $head[$i];
2551                         }
2552                         $i++;
2553                 }
2554                 if($forceTocHere) {
2555                         $mw =& MagicWord::get( MAG_TOC );
2556                         return $mw->replace( $toc, $full );
2557                 } else {
2558                         return $full;
2559                 }
2560         }
2561
2562         /**
2563          * Return an HTML link for the "ISBN 123456" text
2564          * @access private
2565          */
2566         function magicISBN( $text ) {
2567                 global $wgLang;
2568                 $fname = 'Parser::magicISBN';
2569                 wfProfileIn( $fname );
2570
2571                 $a = split( 'ISBN ', ' '.$text );
2572                 if ( count ( $a ) < 2 ) {
2573                         wfProfileOut( $fname );
2574                         return $text;
2575                 }
2576                 $text = substr( array_shift( $a ), 1);
2577                 $valid = '0123456789-ABCDEFGHIJKLMNOPQRSTUVWXYZ';
2578
2579                 foreach ( $a as $x ) {
2580                         $isbn = $blank = '' ;
2581                         while ( ' ' == $x{0} ) {
2582                                 $blank .= ' ';
2583                                 $x = substr( $x, 1 );
2584                         }
2585                         if ( $x == '' ) { # blank isbn
2586                                 $text .= "ISBN $blank";
2587                                 continue;
2588                         }
2589                         while ( strstr( $valid, $x{0} ) != false ) {
2590                                 $isbn .= $x{0};
2591                                 $x = substr( $x, 1 );
2592                         }
2593                         $num = str_replace( '-', '', $isbn );
2594                         $num = str_replace( ' ', '', $num );
2595
2596                         if ( '' == $num ) {
2597                                 $text .= "ISBN $blank$x";
2598                         } else {
2599                                 $titleObj = Title::makeTitle( NS_SPECIAL, 'Booksources' );
2600                                 $text .= '<a href="' .
2601                                 $titleObj->escapeLocalUrl( 'isbn='.$num ) .
2602                                         "\" class=\"internal\">ISBN $isbn</a>";
2603                                 $text .= $x;
2604                         }
2605                 }
2606                 wfProfileOut( $fname );
2607                 return $text;
2608         }
2609
2610         /**
2611          * Return an HTML link for the "GEO ..." text
2612          * @access private
2613          */
2614         function magicGEO( $text ) {
2615                 global $wgLang, $wgUseGeoMode;
2616                 $fname = 'Parser::magicGEO';
2617                 wfProfileIn( $fname );
2618
2619                 # These next five lines are only for the ~35000 U.S. Census Rambot pages...
2620                 $directions = array ( 'N' => 'North' , 'S' => 'South' , 'E' => 'East' , 'W' => 'West' ) ;
2621                 $text = preg_replace ( "/(\d+)&deg;(\d+)'(\d+)\" {$directions['N']}, (\d+)&deg;(\d+)'(\d+)\" {$directions['W']}/" , "(GEO +\$1.\$2.\$3:-\$4.\$5.\$6)" , $text ) ;
2622                 $text = preg_replace ( "/(\d+)&deg;(\d+)'(\d+)\" {$directions['N']}, (\d+)&deg;(\d+)'(\d+)\" {$directions['E']}/" , "(GEO +\$1.\$2.\$3:+\$4.\$5.\$6)" , $text ) ;
2623                 $text = preg_replace ( "/(\d+)&deg;(\d+)'(\d+)\" {$directions['S']}, (\d+)&deg;(\d+)'(\d+)\" {$directions['W']}/" , "(GEO +\$1.\$2.\$3:-\$4.\$5.\$6)" , $text ) ;
2624                 $text = preg_replace ( "/(\d+)&deg;(\d+)'(\d+)\" {$directions['S']}, (\d+)&deg;(\d+)'(\d+)\" {$directions['E']}/" , "(GEO +\$1.\$2.\$3:+\$4.\$5.\$6)" , $text ) ;
2625
2626                 $a = split( 'GEO ', ' '.$text );
2627                 if ( count ( $a ) < 2 ) {
2628                         wfProfileOut( $fname );
2629                         return $text;
2630                 }
2631                 $text = substr( array_shift( $a ), 1);
2632                 $valid = '0123456789.+-:';
2633
2634                 foreach ( $a as $x ) {
2635                         $geo = $blank = '' ;
2636                         while ( ' ' == $x{0} ) {
2637                                 $blank .= ' ';
2638                                 $x = substr( $x, 1 );
2639                         }
2640                         while ( strstr( $valid, $x{0} ) != false ) {
2641                                 $geo .= $x{0};
2642                                 $x = substr( $x, 1 );
2643                         }
2644                         $num = str_replace( '+', '', $geo );
2645                         $num = str_replace( ' ', '', $num );
2646
2647                         if ( '' == $num || count ( explode ( ':' , $num , 3 ) ) < 2 ) {
2648                                 $text .= "GEO $blank$x";
2649                         } else {
2650                                 $titleObj = Title::makeTitle( NS_SPECIAL, 'Geo' );
2651                                 $text .= '<a href="' .
2652                                 $titleObj->escapeLocalUrl( 'coordinates='.$num ) .
2653                                         "\" class=\"internal\">GEO $geo</a>";
2654                                 $text .= $x;
2655                         }
2656                 }
2657                 wfProfileOut( $fname );
2658                 return $text;
2659         }
2660
2661         /**
2662          * Return an HTML link for the "RFC 1234" text
2663          * @access private
2664          * @param string $text text to be processed
2665          */
2666         function magicRFC( $text, $keyword='RFC ', $urlmsg='rfcurl'  ) {
2667                 global $wgLang;
2668
2669                 $valid = '0123456789';
2670                 $internal = false;
2671
2672                 $a = split( $keyword, ' '.$text );
2673                 if ( count ( $a ) < 2 ) {
2674                         return $text;
2675                 }
2676                 $text = substr( array_shift( $a ), 1);
2677
2678                 /* Check if keyword is preceed by [[.
2679                  * This test is made here cause of the array_shift above
2680                  * that prevent the test to be done in the foreach.
2681                  */
2682                 if ( substr( $text, -2 ) == '[[' ) {
2683                         $internal = true;
2684                 }
2685
2686                 foreach ( $a as $x ) {
2687                         /* token might be empty if we have RFC RFC 1234 */
2688                         if ( $x=='' ) {
2689                                 $text.=$keyword;
2690                                 continue;
2691                                 }
2692
2693                         $id = $blank = '' ;
2694
2695                         /** remove and save whitespaces in $blank */
2696                         while ( $x{0} == ' ' ) {
2697                                 $blank .= ' ';
2698                                 $x = substr( $x, 1 );
2699                         }
2700
2701                         /** remove and save the rfc number in $id */
2702                         while ( strstr( $valid, $x{0} ) != false ) {
2703                                 $id .= $x{0};
2704                                 $x = substr( $x, 1 );
2705                         }
2706
2707                         if ( $id == '' ) {
2708                                 /* call back stripped spaces*/
2709                                 $text .= $keyword.$blank.$x;
2710                         } elseif( $internal ) {
2711                                 /* normal link */
2712                                 $text .= $keyword.$id.$x;
2713                         } else {
2714                                 /* build the external link*/
2715                                 $url = wfmsg( $urlmsg );
2716                                 $url = str_replace( '$1', $id, $url);
2717                                 $sk =& $this->mOptions->getSkin();
2718                                 $la = $sk->getExternalLinkAttributes( $url, $keyword.$id );
2719                                 $text .= "<a href='{$url}'{$la}>{$keyword}{$id}</a>{$x}";
2720                         }
2721
2722                         /* Check if the next RFC keyword is preceed by [[ */
2723                         $internal = ( substr($x,-2) == '[[' );
2724                 }
2725                 return $text;
2726         }
2727
2728         /**
2729          * Transform wiki markup when saving a page by doing \r\n -> \n
2730          * conversion, substitting signatures, {{subst:}} templates, etc.
2731          *
2732          * @param string $text the text to transform
2733          * @param Title &$title the Title object for the current article
2734          * @param User &$user the User object describing the current user
2735          * @param ParserOptions $options parsing options
2736          * @param bool $clearState whether to clear the parser state first
2737          * @return string the altered wiki markup
2738          * @access public
2739          */
2740         function preSaveTransform( $text, &$title, &$user, $options, $clearState = true ) {
2741                 $this->mOptions = $options;
2742                 $this->mTitle =& $title;
2743                 $this->mOutputType = OT_WIKI;
2744
2745                 if ( $clearState ) {
2746                         $this->clearState();
2747                 }
2748
2749                 $stripState = false;
2750                 $pairs = array(
2751                         "\r\n" => "\n",
2752                         );
2753                 $text = str_replace( array_keys( $pairs ), array_values( $pairs ), $text );
2754                 $text = $this->strip( $text, $stripState, false );
2755                 $text = $this->pstPass2( $text, $user );
2756                 $text = $this->unstrip( $text, $stripState );
2757                 $text = $this->unstripNoWiki( $text, $stripState );
2758                 return $text;
2759         }
2760
2761         /**
2762          * Pre-save transform helper function
2763          * @access private
2764          */
2765         function pstPass2( $text, &$user ) {
2766                 global $wgLang, $wgContLang, $wgLocaltimezone;
2767
2768                 # Variable replacement
2769                 # Because mOutputType is OT_WIKI, this will only process {{subst:xxx}} type tags
2770                 $text = $this->replaceVariables( $text );
2771
2772                 # Signatures
2773                 #
2774                 $n = $user->getName();
2775                 $k = $user->getOption( 'nickname' );
2776                 if ( '' == $k ) { $k = $n; }
2777                 if ( isset( $wgLocaltimezone ) ) {
2778                         $oldtz = getenv( 'TZ' );
2779                         putenv( 'TZ='.$wgLocaltimezone );
2780                 }
2781                 /* Note: this is an ugly timezone hack for the European wikis */
2782                 $d = $wgContLang->timeanddate( date( 'YmdHis' ), false ) .
2783                   ' (' . date( 'T' ) . ')';
2784                 if ( isset( $wgLocaltimezone ) ) {
2785                         putenv( 'TZ='.$oldtzs );
2786                 }
2787
2788                 $text = preg_replace( '/~~~~~~/', $d, $text );
2789                 $text = preg_replace( '/~~~~/', '[[' . $wgContLang->getNsText( NS_USER ) . ":$n|$k]] $d", $text );
2790                 $text = preg_replace( '/~~~/', '[[' . $wgContLang->getNsText( NS_USER ) . ":$n|$k]]", $text );
2791
2792                 # Context links: [[|name]] and [[name (context)|]]
2793                 #
2794                 $tc = "[&;%\\-,.\\(\\)' _0-9A-Za-z\\/:\\x80-\\xff]";
2795                 $np = "[&;%\\-,.' _0-9A-Za-z\\/:\\x80-\\xff]"; # No parens
2796                 $namespacechar = '[ _0-9A-Za-z\x80-\xff]'; # Namespaces can use non-ascii!
2797                 $conpat = "/^({$np}+) \\(({$tc}+)\\)$/";
2798
2799                 $p1 = "/\[\[({$np}+) \\(({$np}+)\\)\\|]]/";             # [[page (context)|]]
2800                 $p2 = "/\[\[\\|({$tc}+)]]/";                                    # [[|page]]
2801                 $p3 = "/\[\[(:*$namespacechar+):({$np}+)\\|]]/";                # [[namespace:page|]] and [[:namespace:page|]]
2802                 $p4 = "/\[\[(:*$namespacechar+):({$np}+) \\(({$np}+)\\)\\|]]/"; # [[ns:page (cont)|]] and [[:ns:page (cont)|]]
2803                 $context = '';
2804                 $t = $this->mTitle->getText();
2805                 if ( preg_match( $conpat, $t, $m ) ) {
2806                         $context = $m[2];
2807                 }
2808                 $text = preg_replace( $p4, '[[\\1:\\2 (\\3)|\\2]]', $text );
2809                 $text = preg_replace( $p1, '[[\\1 (\\2)|\\1]]', $text );
2810                 $text = preg_replace( $p3, '[[\\1:\\2|\\2]]', $text );
2811
2812                 if ( '' == $context ) {
2813                         $text = preg_replace( $p2, '[[\\1]]', $text );
2814                 } else {
2815                         $text = preg_replace( $p2, "[[\\1 ({$context})|\\1]]", $text );
2816                 }
2817
2818                 # Trim trailing whitespace
2819                 # MAG_END (__END__) tag allows for trailing
2820                 # whitespace to be deliberately included
2821                 $text = rtrim( $text );
2822                 $mw =& MagicWord::get( MAG_END );
2823                 $mw->matchAndRemove( $text );
2824
2825                 return $text;
2826         }
2827
2828         /**
2829          * Set up some variables which are usually set up in parse()
2830          * so that an external function can call some class members with confidence
2831          * @access public
2832          */
2833         function startExternalParse( &$title, $options, $outputType, $clearState = true ) {
2834                 $this->mTitle =& $title;
2835                 $this->mOptions = $options;
2836                 $this->mOutputType = $outputType;
2837                 if ( $clearState ) {
2838                         $this->clearState();
2839                 }
2840         }
2841
2842         /**
2843          * Transform a MediaWiki message by replacing magic variables.
2844          *
2845          * @param string $text the text to transform
2846          * @param ParserOptions $options  options
2847          * @return string the text with variables substituted
2848          * @access public
2849          */
2850         function transformMsg( $text, $options ) {
2851                 global $wgTitle;
2852                 static $executing = false;
2853
2854                 # Guard against infinite recursion
2855                 if ( $executing ) {
2856                         return $text;
2857                 }
2858                 $executing = true;
2859
2860                 $this->mTitle = $wgTitle;
2861                 $this->mOptions = $options;
2862                 $this->mOutputType = OT_MSG;
2863                 $this->clearState();
2864                 $text = $this->replaceVariables( $text );
2865
2866                 $executing = false;
2867                 return $text;
2868         }
2869
2870         /**
2871          * Create an HTML-style tag, e.g. <yourtag>special text</yourtag>
2872          * Callback will be called with the text within
2873          * Transform and return the text within
2874          * @access public
2875          */
2876         function setHook( $tag, $callback ) {
2877                 $oldVal = @$this->mTagHooks[$tag];
2878                 $this->mTagHooks[$tag] = $callback;
2879                 return $oldVal;
2880         }
2881
2882         /**
2883          * Replace <!--LINK--> link placeholders with actual links, in the buffer
2884          * Placeholders created in Skin::makeLinkObj()
2885          * Returns an array of links found, indexed by PDBK:
2886          *  0 - broken
2887          *  1 - normal link
2888          *  2 - stub
2889          * $options is a bit field, RLH_FOR_UPDATE to select for update
2890          */
2891         function replaceLinkHolders( &$text, $options = 0 ) {
2892                 global $wgUser, $wgLinkCache, $wgUseOldExistenceCheck, $wgLinkHolders;
2893                 global $wgInterwikiLinkHolders;
2894                 global $outputReplace;
2895
2896                 if ( $wgUseOldExistenceCheck ) {
2897                         return array();
2898                 }
2899
2900                 $fname = 'Parser::replaceLinkHolders';
2901                 wfProfileIn( $fname );
2902
2903                 $pdbks = array();
2904                 $colours = array();
2905
2906                 #if ( !empty( $tmpLinks[0] ) ) { #TODO
2907                 if ( !empty( $wgLinkHolders['namespaces'] ) ) {
2908                         wfProfileIn( $fname.'-check' );
2909                         $dbr =& wfGetDB( DB_SLAVE );
2910                         $cur = $dbr->tableName( 'cur' );
2911                         $sk = $wgUser->getSkin();
2912                         $threshold = $wgUser->getOption('stubthreshold');
2913
2914                         # Sort by namespace
2915                         asort( $wgLinkHolders['namespaces'] );
2916
2917                         # Generate query
2918                         $query = false;
2919                         foreach ( $wgLinkHolders['namespaces'] as $key => $val ) {
2920                                 # Make title object
2921                                 $title = $wgLinkHolders['titles'][$key];
2922
2923                                 # Skip invalid entries.
2924                                 # Result will be ugly, but prevents crash.
2925                                 if ( is_null( $title ) ) {
2926                                         continue;
2927                                 }
2928                                 $pdbk = $pdbks[$key] = $title->getPrefixedDBkey();
2929
2930                                 # Check if it's in the link cache already
2931                                 if ( $wgLinkCache->getGoodLinkID( $pdbk ) ) {
2932                                         $colours[$pdbk] = 1;
2933                                 } elseif ( $wgLinkCache->isBadLink( $pdbk ) ) {
2934                                         $colours[$pdbk] = 0;
2935                                 } else {
2936                                         # Not in the link cache, add it to the query
2937                                         if ( !isset( $current ) ) {
2938                                                 $current = $val;
2939                                                 $query =  "SELECT cur_id, cur_namespace, cur_title";
2940                                                 if ( $threshold > 0 ) {
2941                                                         $query .= ", LENGTH(cur_text) AS cur_len, cur_is_redirect";
2942                                                 }
2943                                                 $query .= " FROM $cur WHERE (cur_namespace=$val AND cur_title IN(";
2944                                         } elseif ( $current != $val ) {
2945                                                 $current = $val;
2946                                                 $query .= ")) OR (cur_namespace=$val AND cur_title IN(";
2947                                         } else {
2948                                                 $query .= ', ';
2949                                         }
2950
2951                                         $query .= $dbr->addQuotes( $wgLinkHolders['dbkeys'][$key] );
2952                                 }
2953                         }
2954                         if ( $query ) {
2955                                 $query .= '))';
2956                                 if ( $options & RLH_FOR_UPDATE ) {
2957                                         $query .= ' FOR UPDATE';
2958                                 }
2959
2960                                 $res = $dbr->query( $query, $fname );
2961
2962                                 # Fetch data and form into an associative array
2963                                 # non-existent = broken
2964                                 # 1 = known
2965                                 # 2 = stub
2966                                 while ( $s = $dbr->fetchObject($res) ) {
2967                                         $title = Title::makeTitle( $s->cur_namespace, $s->cur_title );
2968                                         $pdbk = $title->getPrefixedDBkey();
2969                                         $wgLinkCache->addGoodLink( $s->cur_id, $pdbk );
2970
2971                                         if ( $threshold >  0 ) {
2972                                                 $size = $s->cur_len;
2973                                                 if ( $s->cur_is_redirect || $s->cur_namespace != 0 || $length < $threshold ) {
2974                                                         $colours[$pdbk] = 1;
2975                                                 } else {
2976                                                         $colours[$pdbk] = 2;
2977                                                 }
2978                                         } else {
2979                                                 $colours[$pdbk] = 1;
2980                                         }
2981                                 }
2982                         }
2983                         wfProfileOut( $fname.'-check' );
2984
2985                         # Construct search and replace arrays
2986                         wfProfileIn( $fname.'-construct' );
2987                         $outputReplace = array();
2988                         foreach ( $wgLinkHolders['namespaces'] as $key => $ns ) {
2989                                 $pdbk = $pdbks[$key];
2990                                 $searchkey = '<!--LINK '.$key.'-->';
2991                                 $title = $wgLinkHolders['titles'][$key];
2992                                 if ( empty( $colours[$pdbk] ) ) {
2993                                         $wgLinkCache->addBadLink( $pdbk );
2994                                         $colours[$pdbk] = 0;
2995                                         $outputReplace[$searchkey] = $sk->makeBrokenLinkObj( $title,
2996                                                                         $wgLinkHolders['texts'][$key],
2997                                                                         $wgLinkHolders['queries'][$key] );
2998                                 } elseif ( $colours[$pdbk] == 1 ) {
2999                                         $outputReplace[$searchkey] = $sk->makeKnownLinkObj( $title,
3000                                                                         $wgLinkHolders['texts'][$key],
3001                                                                         $wgLinkHolders['queries'][$key] );
3002                                 } elseif ( $colours[$pdbk] == 2 ) {
3003                                         $outputReplace[$searchkey] = $sk->makeStubLinkObj( $title,
3004                                                                         $wgLinkHolders['texts'][$key],
3005                                                                         $wgLinkHolders['queries'][$key] );
3006                                 }
3007                         }
3008                         wfProfileOut( $fname.'-construct' );
3009
3010                         # Do the thing
3011                         wfProfileIn( $fname.'-replace' );
3012
3013                         $text = preg_replace_callback(
3014                                 '/(<!--LINK .*?-->)/',
3015                                 "outputReplaceMatches",
3016                                 $text);
3017                         wfProfileOut( $fname.'-replace' );
3018                 }
3019
3020                 if ( !empty( $wgInterwikiLinkHolders ) ) {
3021                         wfProfileIn( $fname.'-interwiki' );
3022                         $outputReplace = $wgInterwikiLinkHolders;
3023                         $text = preg_replace_callback(
3024                                 '/<!--IWLINK (.*?)-->/',
3025                                 "outputReplaceMatches",
3026                                 $text );
3027                         wfProfileOut( $fname.'-interwiki' );
3028                 }
3029
3030                 wfProfileOut( $fname );
3031                 return $colours;
3032         }
3033
3034         /**
3035          * Renders an image gallery from a text with one line per image.
3036          * text labels may be given by using |-style alternative text. E.g.
3037          *   Image:one.jpg|The number "1"
3038          *   Image:tree.jpg|A tree
3039          * given as text will return the HTML of a gallery with two images,
3040          * labeled 'The number "1"' and
3041          * 'A tree'.
3042          */
3043         function renderImageGallery( $text ) {
3044                 global $wgLinkCache;
3045                 $ig = new ImageGallery();
3046                 $ig->setShowBytes( false );
3047                 $ig->setShowFilename( false );
3048                 $lines = explode( "\n", $text );
3049
3050                 foreach ( $lines as $line ) {
3051                         # match lines like these:
3052                         # Image:someimage.jpg|This is some image
3053                         preg_match( "/^([^|]+)(\\|(.*))?$/", $line, $matches );
3054                         # Skip empty lines
3055                         if ( count( $matches ) == 0 ) {
3056                                 continue;
3057                         }
3058                         $nt = Title::newFromURL( $matches[1] );
3059                         if ( isset( $matches[3] ) ) {
3060                                 $label = $matches[3];
3061                         } else {
3062                                 $label = '';
3063                         }
3064                         $ig->add( Image::newFromTitle( $nt ), $label );
3065                         $wgLinkCache->addImageLinkObj( $nt );
3066                 }
3067                 return $ig->toHTML();
3068         }
3069 }
3070
3071 /**
3072  * @todo document
3073  * @package MediaWiki
3074  */
3075 class ParserOutput
3076 {
3077         var $mText, $mLanguageLinks, $mCategoryLinks, $mContainsOldMagic;
3078         var $mCacheTime; # Used in ParserCache
3079         var $mVersion;   # Compatibility check
3080
3081         function ParserOutput( $text = '', $languageLinks = array(), $categoryLinks = array(),
3082                 $containsOldMagic = false )
3083         {
3084                 $this->mText = $text;
3085                 $this->mLanguageLinks = $languageLinks;
3086                 $this->mCategoryLinks = $categoryLinks;
3087                 $this->mContainsOldMagic = $containsOldMagic;
3088                 $this->mCacheTime = '';
3089                 $this->mVersion = MW_PARSER_VERSION;
3090         }
3091
3092         function getText()                   { return $this->mText; }
3093         function getLanguageLinks()          { return $this->mLanguageLinks; }
3094         function getCategoryLinks()          { return array_keys( $this->mCategoryLinks ); }
3095         function getCacheTime()              { return $this->mCacheTime; }
3096         function containsOldMagic()          { return $this->mContainsOldMagic; }
3097         function setText( $text )            { return wfSetVar( $this->mText, $text ); }
3098         function setLanguageLinks( $ll )     { return wfSetVar( $this->mLanguageLinks, $ll ); }
3099         function setCategoryLinks( $cl )     { return wfSetVar( $this->mCategoryLinks, $cl ); }
3100         function setContainsOldMagic( $com ) { return wfSetVar( $this->mContainsOldMagic, $com ); }
3101         function setCacheTime( $t )          { return wfSetVar( $this->mCacheTime, $t ); }
3102         function addCategoryLink( $c )       { $this->mCategoryLinks[$c] = 1; }
3103
3104         function merge( $other ) {
3105                 $this->mLanguageLinks = array_merge( $this->mLanguageLinks, $other->mLanguageLinks );
3106                 $this->mCategoryLinks = array_merge( $this->mCategoryLinks, $this->mLanguageLinks );
3107                 $this->mContainsOldMagic = $this->mContainsOldMagic || $other->mContainsOldMagic;
3108         }
3109
3110         /**
3111          * Return true if this cached output object predates the global or
3112          * per-article cache invalidation timestamps, or if it comes from
3113          * an incompatible older version.
3114          *
3115          * @param string $touched the affected article's last touched timestamp
3116          * @return bool
3117          * @access public
3118          */
3119         function expired( $touched ) {
3120                 global $wgCacheEpoch;
3121                 return $this->getCacheTime() <= $touched ||
3122                        $this->getCacheTime() <= $wgCacheEpoch ||
3123                        !isset( $this->mVersion ) ||
3124                        version_compare( $this->mVersion, MW_PARSER_VERSION, "lt" );
3125         }
3126 }
3127
3128 /**
3129  * Set options of the Parser
3130  * @todo document
3131  * @package MediaWiki
3132  */
3133 class ParserOptions
3134 {
3135         # All variables are private
3136         var $mUseTeX;                    # Use texvc to expand <math> tags
3137         var $mUseDynamicDates;           # Use $wgDateFormatter to format dates
3138         var $mInterwikiMagic;            # Interlanguage links are removed and returned in an array
3139         var $mAllowExternalImages;       # Allow external images inline
3140         var $mSkin;                      # Reference to the preferred skin
3141         var $mDateFormat;                # Date format index
3142         var $mEditSection;               # Create "edit section" links
3143         var $mEditSectionOnRightClick;   # Generate JavaScript to edit section on right click
3144         var $mNumberHeadings;            # Automatically number headings
3145         var $mShowToc;                   # Show table of contents
3146
3147         function getUseTeX()                        { return $this->mUseTeX; }
3148         function getUseDynamicDates()               { return $this->mUseDynamicDates; }
3149         function getInterwikiMagic()                { return $this->mInterwikiMagic; }
3150         function getAllowExternalImages()           { return $this->mAllowExternalImages; }
3151         function getSkin()                          { return $this->mSkin; }
3152         function getDateFormat()                    { return $this->mDateFormat; }
3153         function getEditSection()                   { return $this->mEditSection; }
3154         function getEditSectionOnRightClick()       { return $this->mEditSectionOnRightClick; }
3155         function getNumberHeadings()                { return $this->mNumberHeadings; }
3156         function getShowToc()                       { return $this->mShowToc; }
3157
3158         function setUseTeX( $x )                    { return wfSetVar( $this->mUseTeX, $x ); }
3159         function setUseDynamicDates( $x )           { return wfSetVar( $this->mUseDynamicDates, $x ); }
3160         function setInterwikiMagic( $x )            { return wfSetVar( $this->mInterwikiMagic, $x ); }
3161         function setAllowExternalImages( $x )       { return wfSetVar( $this->mAllowExternalImages, $x ); }
3162         function setDateFormat( $x )                { return wfSetVar( $this->mDateFormat, $x ); }
3163         function setEditSection( $x )               { return wfSetVar( $this->mEditSection, $x ); }
3164         function setEditSectionOnRightClick( $x )   { return wfSetVar( $this->mEditSectionOnRightClick, $x ); }
3165         function setNumberHeadings( $x )            { return wfSetVar( $this->mNumberHeadings, $x ); }
3166         function setShowToc( $x )                   { return wfSetVar( $this->mShowToc, $x ); }
3167
3168         function setSkin( &$x ) { $this->mSkin =& $x; }
3169
3170         # Get parser options
3171         /* static */ function newFromUser( &$user ) {
3172                 $popts = new ParserOptions;
3173                 $popts->initialiseFromUser( $user );
3174                 return $popts;
3175         }
3176
3177         # Get user options
3178         function initialiseFromUser( &$userInput ) {
3179                 global $wgUseTeX, $wgUseDynamicDates, $wgInterwikiMagic, $wgAllowExternalImages;
3180                 $fname = 'ParserOptions::initialiseFromUser';
3181                 wfProfileIn( $fname );
3182                 if ( !$userInput ) {
3183                         $user = new User;
3184                         $user->setLoaded( true );
3185                 } else {
3186                         $user =& $userInput;
3187                 }
3188
3189                 $this->mUseTeX = $wgUseTeX;
3190                 $this->mUseDynamicDates = $wgUseDynamicDates;
3191                 $this->mInterwikiMagic = $wgInterwikiMagic;
3192                 $this->mAllowExternalImages = $wgAllowExternalImages;
3193                 wfProfileIn( $fname.'-skin' );
3194                 $this->mSkin =& $user->getSkin();
3195                 wfProfileOut( $fname.'-skin' );
3196                 $this->mDateFormat = $user->getOption( 'date' );
3197                 $this->mEditSection = $user->getOption( 'editsection' );
3198                 $this->mEditSectionOnRightClick = $user->getOption( 'editsectiononrightclick' );
3199                 $this->mNumberHeadings = $user->getOption( 'numberheadings' );
3200                 $this->mShowToc = $user->getOption( 'showtoc' );
3201                 wfProfileOut( $fname );
3202         }
3203
3204
3205 }
3206
3207 /**
3208  * Callback function used by Parser::replaceLinkHolders()
3209  * to substitute link placeholders.
3210  */
3211 function &outputReplaceMatches( $matches ) {
3212         global $outputReplace;
3213         return $outputReplace[$matches[1]];
3214 }
3215
3216 /**
3217  * Return the total number of articles
3218  */
3219 function wfNumberOfArticles() {
3220         global $wgNumberOfArticles;
3221
3222         wfLoadSiteStats();
3223         return $wgNumberOfArticles;
3224 }
3225
3226 /**
3227  * Get various statistics from the database
3228  * @private
3229  */
3230 function wfLoadSiteStats() {
3231         global $wgNumberOfArticles, $wgTotalViews, $wgTotalEdits;
3232         $fname = 'wfLoadSiteStats';
3233
3234         if ( -1 != $wgNumberOfArticles ) return;
3235         $dbr =& wfGetDB( DB_SLAVE );
3236         $s = $dbr->selectRow( 'site_stats',
3237                 array( 'ss_total_views', 'ss_total_edits', 'ss_good_articles' ),
3238                 array( 'ss_row_id' => 1 ), $fname
3239         );
3240
3241         if ( $s === false ) {
3242                 return;
3243         } else {
3244                 $wgTotalViews = $s->ss_total_views;
3245                 $wgTotalEdits = $s->ss_total_edits;
3246                 $wgNumberOfArticles = $s->ss_good_articles;
3247         }
3248 }
3249
3250 function wfEscapeHTMLTagsOnly( $in ) {
3251         return str_replace(
3252                 array( '"', '>', '<' ),
3253                 array( '&quot;', '&gt;', '&lt;' ),
3254                 $in );
3255 }
3256
3257 ?>