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