includes/Parser.php

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