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