includes/Parser.php

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