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->doMagicLinks( $text );
 662                 $text = $this->replaceInternalLinks ( $text );
 663                 # Another call to replace links and images inside captions of images
 664                 $text = $this->replaceInternalLinks ( $text );
 665                 $text = $this->replaceExternalLinks( $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                 # Look at the first character
1238                 if( $target{0} == '/' ) {
1239                         # / at end means we don't want the slash to be shown
1240                         if(substr($target,-1,1)=='/') {
1241                                 $target=substr($target,1,-1);
1242                                 $noslash=$target;
1243                         } else {
1244                                 $noslash=substr($target,1);
1245                         }
1246
1247                         # Some namespaces don't allow subpages
1248                         if(!empty($wgNamespacesWithSubpages[$this->mTitle->getNamespace()])) {
1249                                 # subpages allowed here
1250                                 $ret = $this->mTitle->getPrefixedText(). '/' . trim($noslash);
1251                                 if( '' === $text ) {
1252                                         $text = $target;
1253                                 } # this might be changed for ugliness reasons
1254                         } else {
1255                                 # no subpage allowed, use standard link
1256                                 $ret = $target;
1257                         }
1258                 } else {
1259                         # no subpage
1260                         $ret = $target;
1261                 }
1262
1263                 return $ret;
1264         }
1265
1266         /**#@+
1267          * Used by doBlockLevels()
1268          * @access private
1269          */
1270         /* private */ function closeParagraph() {
1271                 $result = '';
1272                 if ( '' != $this->mLastSection ) {
1273                         $result = '</' . $this->mLastSection  . ">\n";
1274                 }
1275                 $this->mInPre = false;
1276                 $this->mLastSection = '';
1277                 return $result;
1278         }
1279         # getCommon() returns the length of the longest common substring
1280         # of both arguments, starting at the beginning of both.
1281         #
1282         /* private */ function getCommon( $st1, $st2 ) {
1283                 $fl = strlen( $st1 );
1284                 $shorter = strlen( $st2 );
1285                 if ( $fl < $shorter ) { $shorter = $fl; }
1286
1287                 for ( $i = 0; $i < $shorter; ++$i ) {
1288                         if ( $st1{$i} != $st2{$i} ) { break; }
1289                 }
1290                 return $i;
1291         }
1292         # These next three functions open, continue, and close the list
1293         # element appropriate to the prefix character passed into them.
1294         #
1295         /* private */ function openList( $char ) {
1296                 $result = $this->closeParagraph();
1297
1298                 if ( '*' == $char ) { $result .= '<ul><li>'; }
1299                 else if ( '#' == $char ) { $result .= '<ol><li>'; }
1300                 else if ( ':' == $char ) { $result .= '<dl><dd>'; }
1301                 else if ( ';' == $char ) {
1302                         $result .= '<dl><dt>';
1303                         $this->mDTopen = true;
1304                 }
1305                 else { $result = '<!-- ERR 1 -->'; }
1306
1307                 return $result;
1308         }
1309
1310         /* private */ function nextItem( $char ) {
1311                 if ( '*' == $char || '#' == $char ) { return '</li><li>'; }
1312                 else if ( ':' == $char || ';' == $char ) {
1313                         $close = '</dd>';
1314                         if ( $this->mDTopen ) { $close = '</dt>'; }
1315                         if ( ';' == $char ) {
1316                                 $this->mDTopen = true;
1317                                 return $close . '<dt>';
1318                         } else {
1319                                 $this->mDTopen = false;
1320                                 return $close . '<dd>';
1321                         }
1322                 }
1323                 return '<!-- ERR 2 -->';
1324         }
1325
1326         /* private */ function closeList( $char ) {
1327                 if ( '*' == $char ) { $text = '</li></ul>'; }
1328                 else if ( '#' == $char ) { $text = '</li></ol>'; }
1329                 else if ( ':' == $char ) {
1330                         if ( $this->mDTopen ) {
1331                                 $this->mDTopen = false;
1332                                 $text = '</dt></dl>';
1333                         } else {
1334                                 $text = '</dd></dl>';
1335                         }
1336                 }
1337                 else {  return '<!-- ERR 3 -->'; }
1338                 return $text."\n";
1339         }
1340         /**#@-*/
1341
1342         /**
1343          * Make lists from lines starting with ':', '*', '#', etc.
1344          *
1345          * @access private
1346          * @return string the lists rendered as HTML
1347          */
1348         function doBlockLevels( $text, $linestart ) {
1349                 $fname = 'Parser::doBlockLevels';
1350                 wfProfileIn( $fname );
1351
1352                 # Parsing through the text line by line.  The main thing
1353                 # happening here is handling of block-level elements p, pre,
1354                 # and making lists from lines starting with * # : etc.
1355                 #
1356                 $textLines = explode( "\n", $text );
1357
1358                 $lastPrefix = $output = $lastLine = '';
1359                 $this->mDTopen = $inBlockElem = false;
1360                 $prefixLength = 0;
1361                 $paragraphStack = false;
1362
1363                 if ( !$linestart ) {
1364                         $output .= array_shift( $textLines );
1365                 }
1366                 foreach ( $textLines as $oLine ) {
1367                         $lastPrefixLength = strlen( $lastPrefix );
1368                         $preCloseMatch = preg_match('/<\\/pre/i', $oLine );
1369                         $preOpenMatch = preg_match('/<pre/i', $oLine );
1370                         if ( !$this->mInPre ) {
1371                                 # Multiple prefixes may abut each other for nested lists.
1372                                 $prefixLength = strspn( $oLine, '*#:;' );
1373                                 $pref = substr( $oLine, 0, $prefixLength );
1374
1375                                 # eh?
1376                                 $pref2 = str_replace( ';', ':', $pref );
1377                                 $t = substr( $oLine, $prefixLength );
1378                                 $this->mInPre = !empty($preOpenMatch);
1379                         } else {
1380                                 # Don't interpret any other prefixes in preformatted text
1381                                 $prefixLength = 0;
1382                                 $pref = $pref2 = '';
1383                                 $t = $oLine;
1384                         }
1385
1386                         # List generation
1387                         if( $prefixLength && 0 == strcmp( $lastPrefix, $pref2 ) ) {
1388                                 # Same as the last item, so no need to deal with nesting or opening stuff
1389                                 $output .= $this->nextItem( substr( $pref, -1 ) );
1390                                 $paragraphStack = false;
1391
1392                                 if ( substr( $pref, -1 ) == ';') {
1393                                         # The one nasty exception: definition lists work like this:
1394                                         # ; title : definition text
1395                                         # So we check for : in the remainder text to split up the
1396                                         # title and definition, without b0rking links.
1397                                         # FIXME: This is not foolproof. Something better in Tokenizer might help.
1398                                         if( preg_match( '/^(.*?(?:\s|&nbsp;)):(.*)$/', $t, $match ) ) {
1399                                                 $term = $match[1];
1400                                                 $output .= $term . $this->nextItem( ':' );
1401                                                 $t = $match[2];
1402                                         }
1403                                 }
1404                         } elseif( $prefixLength || $lastPrefixLength ) {
1405                                 # Either open or close a level...
1406                                 $commonPrefixLength = $this->getCommon( $pref, $lastPrefix );
1407                                 $paragraphStack = false;
1408
1409                                 while( $commonPrefixLength < $lastPrefixLength ) {
1410                                         $output .= $this->closeList( $lastPrefix{$lastPrefixLength-1} );
1411                                         --$lastPrefixLength;
1412                                 }
1413                                 if ( $prefixLength <= $commonPrefixLength && $commonPrefixLength > 0 ) {
1414                                         $output .= $this->nextItem( $pref{$commonPrefixLength-1} );
1415                                 }
1416                                 while ( $prefixLength > $commonPrefixLength ) {
1417                                         $char = substr( $pref, $commonPrefixLength, 1 );
1418                                         $output .= $this->openList( $char );
1419
1420                                         if ( ';' == $char ) {
1421                                                 # FIXME: This is dupe of code above
1422                                                 if( preg_match( '/^(.*?(?:\s|&nbsp;)):(.*)$/', $t, $match ) ) {
1423                                                         $term = $match[1];
1424                                                         $output .= $term . $this->nextItem( ':' );
1425                                                         $t = $match[2];
1426                                                 }
1427                                         }
1428                                         ++$commonPrefixLength;
1429                                 }
1430                                 $lastPrefix = $pref2;
1431                         }
1432                         if( 0 == $prefixLength ) {
1433                                 # No prefix (not in list)--go to paragraph mode
1434                                 $uniq_prefix = UNIQ_PREFIX;
1435                                 // XXX: use a stack for nestable elements like span, table and div
1436                                 $openmatch = preg_match('/(<table|<blockquote|<h1|<h2|<h3|<h4|<h5|<h6|<pre|<tr|<p|<ul|<li|<\\/tr|<\\/td|<\\/th)/i', $t );
1437                                 $closematch = preg_match(
1438                                         '/(<\\/table|<\\/blockquote|<\\/h1|<\\/h2|<\\/h3|<\\/h4|<\\/h5|<\\/h6|'.
1439                                         '<td|<th|<div|<\\/div|<hr|<\\/pre|<\\/p|'.$uniq_prefix.'-pre|<\\/li|<\\/ul)/i', $t );
1440                                 if ( $openmatch or $closematch ) {
1441                                         $paragraphStack = false;
1442                                         $output .= $this->closeParagraph();
1443                                         if($preOpenMatch and !$preCloseMatch) {
1444                                                 $this->mInPre = true;
1445                                         }
1446                                         if ( $closematch ) {
1447                                                 $inBlockElem = false;
1448                                         } else {
1449                                                 $inBlockElem = true;
1450                                         }
1451                                 } else if ( !$inBlockElem && !$this->mInPre ) {
1452                                         if ( ' ' == $t{0} and ( $this->mLastSection == 'pre' or trim($t) != '' ) ) {
1453                                                 // pre
1454                                                 if ($this->mLastSection != 'pre') {
1455                                                         $paragraphStack = false;
1456                                                         $output .= $this->closeParagraph().'<pre>';
1457                                                         $this->mLastSection = 'pre';
1458                                                 }
1459                                                 $t = substr( $t, 1 );
1460                                         } else {
1461                                                 // paragraph
1462                                                 if ( '' == trim($t) ) {
1463                                                         if ( $paragraphStack ) {
1464                                                                 $output .= $paragraphStack.'<br />';
1465                                                                 $paragraphStack = false;
1466                                                                 $this->mLastSection = 'p';
1467                                                         } else {
1468                                                                 if ($this->mLastSection != 'p' ) {
1469                                                                         $output .= $this->closeParagraph();
1470                                                                         $this->mLastSection = '';
1471                                                                         $paragraphStack = '<p>';
1472                                                                 } else {
1473                                                                         $paragraphStack = '</p><p>';
1474                                                                 }
1475                                                         }
1476                                                 } else {
1477                                                         if ( $paragraphStack ) {
1478                                                                 $output .= $paragraphStack;
1479                                                                 $paragraphStack = false;
1480                                                                 $this->mLastSection = 'p';
1481                                                         } else if ($this->mLastSection != 'p') {
1482                                                                 $output .= $this->closeParagraph().'<p>';
1483                                                                 $this->mLastSection = 'p';
1484                                                         }
1485                                                 }
1486                                         }
1487                                 }
1488                         }
1489                         if ($paragraphStack === false) {
1490                                 $output .= $t."\n";
1491                         }
1492                 }
1493                 while ( $prefixLength ) {
1494                         $output .= $this->closeList( $pref2{$prefixLength-1} );
1495                         --$prefixLength;
1496                 }
1497                 if ( '' != $this->mLastSection ) {
1498                         $output .= '</' . $this->mLastSection . '>';
1499                         $this->mLastSection = '';
1500                 }
1501
1502                 wfProfileOut( $fname );
1503                 return $output;
1504         }
1505
1506         /**
1507          * Return value of a magic variable (like PAGENAME)
1508          *
1509          * @access private
1510          */
1511         function getVariableValue( $index ) {
1512                 global $wgContLang, $wgSitename, $wgServer;
1513
1514                 switch ( $index ) {
1515                         case MAG_CURRENTMONTH:
1516                                 return $wgContLang->formatNum( date( 'm' ) );
1517                         case MAG_CURRENTMONTHNAME:
1518                                 return $wgContLang->getMonthName( date('n') );
1519                         case MAG_CURRENTMONTHNAMEGEN:
1520                                 return $wgContLang->getMonthNameGen( date('n') );
1521                         case MAG_CURRENTDAY:
1522                                 return $wgContLang->formatNum( date('j') );
1523                         case MAG_PAGENAME:
1524                                 return $this->mTitle->getText();
1525                         case MAG_PAGENAMEE:
1526                                 return $this->mTitle->getPartialURL();
1527                         case MAG_NAMESPACE:
1528                                 # return Namespace::getCanonicalName($this->mTitle->getNamespace());
1529                                 return $wgContLang->getNsText($this->mTitle->getNamespace()); # Patch by Dori
1530                         case MAG_CURRENTDAYNAME:
1531                                 return $wgContLang->getWeekdayName( date('w')+1 );
1532                         case MAG_CURRENTYEAR:
1533                                 return $wgContLang->formatNum( date( 'Y' ) );
1534                         case MAG_CURRENTTIME:
1535                                 return $wgContLang->time( wfTimestampNow(), false );
1536                         case MAG_NUMBEROFARTICLES:
1537                                 return $wgContLang->formatNum( wfNumberOfArticles() );
1538                         case MAG_SITENAME:
1539                                 return $wgSitename;
1540                         case MAG_SERVER:
1541                                 return $wgServer;
1542                         default:
1543                                 return NULL;
1544                 }
1545         }
1546
1547         /**
1548          * initialise the magic variables (like CURRENTMONTHNAME)
1549          *
1550          * @access private
1551          */
1552         function initialiseVariables() {
1553                 global $wgVariableIDs;
1554                 $this->mVariables = array();
1555                 foreach ( $wgVariableIDs as $id ) {
1556                         $mw =& MagicWord::get( $id );
1557                         $mw->addToArray( $this->mVariables, $this->getVariableValue( $id ) );
1558                 }
1559         }
1560
1561         /**
1562          * Replace magic variables, templates, and template arguments
1563          * with the appropriate text. Templates are substituted recursively,
1564          * taking care to avoid infinite loops.
1565          *
1566          * Note that the substitution depends on value of $mOutputType:
1567          *  OT_WIKI: only {{subst:}} templates
1568          *  OT_MSG: only magic variables
1569          *  OT_HTML: all templates and magic variables
1570          *
1571          * @param string $tex The text to transform
1572          * @param array $args Key-value pairs representing template parameters to substitute
1573          * @access private
1574          */
1575         function replaceVariables( $text, $args = array() ) {
1576                 global $wgLang, $wgScript, $wgArticlePath;
1577
1578                 # Prevent too big inclusions
1579                 if(strlen($text)> MAX_INCLUDE_SIZE)
1580                 return $text;
1581
1582                 $fname = 'Parser::replaceVariables';
1583                 wfProfileIn( $fname );
1584
1585                 $titleChars = Title::legalChars();
1586
1587                 # This function is called recursively. To keep track of arguments we need a stack:
1588                 array_push( $this->mArgStack, $args );
1589
1590                 # PHP global rebinding syntax is a bit weird, need to use the GLOBALS array
1591                 $GLOBALS['wgCurParser'] =& $this;
1592
1593                 # Variable substitution
1594                 $text = preg_replace_callback( "/{{([$titleChars]*?)}}/", 'wfVariableSubstitution', $text );
1595
1596                 if ( $this->mOutputType == OT_HTML || $this->mOutputType == OT_WIKI ) {
1597                         # Argument substitution
1598                         $text = preg_replace_callback( "/{{{([$titleChars]*?)}}}/", 'wfArgSubstitution', $text );
1599                 }
1600                 # Template substitution
1601                 $regex = '/(\\n|{)?{{(['.$titleChars.']*)(\\|.*?|)}}/s';
1602                 $text = preg_replace_callback( $regex, 'wfBraceSubstitution', $text );
1603
1604                 array_pop( $this->mArgStack );
1605
1606                 wfProfileOut( $fname );
1607                 return $text;
1608         }
1609
1610         /**
1611          * Replace magic variables
1612          * @access private
1613          */
1614         function variableSubstitution( $matches ) {
1615                 if ( !$this->mVariables ) {
1616                         $this->initialiseVariables();
1617                 }
1618                 $skip = false;
1619                 if ( $this->mOutputType == OT_WIKI ) {
1620                         # Do only magic variables prefixed by SUBST
1621                         $mwSubst =& MagicWord::get( MAG_SUBST );
1622                         if (!$mwSubst->matchStartAndRemove( $matches[1] ))
1623                                 $skip = true;
1624                         # Note that if we don't substitute the variable below,
1625                         # we don't remove the {{subst:}} magic word, in case
1626                         # it is a template rather than a magic variable.
1627                 }
1628                 if ( !$skip && array_key_exists( $matches[1], $this->mVariables ) ) {
1629                         $text = $this->mVariables[$matches[1]];
1630                         $this->mOutput->mContainsOldMagic = true;
1631                 } else {
1632                         $text = $matches[0];
1633                 }
1634                 return $text;
1635         }
1636
1637         # Split template arguments
1638         function getTemplateArgs( $argsString ) {
1639                 if ( $argsString === '' ) {
1640                         return array();
1641                 }
1642
1643                 $args = explode( '|', substr( $argsString, 1 ) );
1644
1645                 # If any of the arguments contains a '[[' but no ']]', it needs to be
1646                 # merged with the next arg because the '|' character between belongs
1647                 # to the link syntax and not the template parameter syntax.
1648                 $argc = count($args);
1649                 $i = 0;
1650                 for ( $i = 0; $i < $argc-1; $i++ ) {
1651                         if ( substr_count ( $args[$i], '[[' ) != substr_count ( $args[$i], ']]' ) ) {
1652                                 $args[$i] .= '|'.$args[$i+1];
1653                                 array_splice($args, $i+1, 1);
1654                                 $i--;
1655                                 $argc--;
1656                         }
1657                 }
1658
1659                 return $args;
1660         }
1661
1662         /**
1663          * Return the text of a template, after recursively
1664          * replacing any variables or templates within the template.
1665          *
1666          * @param array $matches The parts of the template
1667          *  $matches[1]: the title, i.e. the part before the |
1668          *  $matches[2]: the parameters (including a leading |), if  any
1669          * @return string the text of the template
1670          * @access private
1671          */
1672         function braceSubstitution( $matches ) {
1673                 global $wgLinkCache, $wgContLang;
1674                 $fname = 'Parser::braceSubstitution';
1675                 $found = false;
1676                 $nowiki = false;
1677                 $noparse = false;
1678
1679                 $title = NULL;
1680
1681                 # Need to know if the template comes at the start of a line,
1682                 # to treat the beginning of the template like the beginning
1683                 # of a line for tables and block-level elements.
1684                 $linestart = $matches[1];
1685
1686                 # $part1 is the bit before the first |, and must contain only title characters
1687                 # $args is a list of arguments, starting from index 0, not including $part1
1688
1689                 $part1 = $matches[2];
1690                 # If the third subpattern matched anything, it will start with |
1691
1692                 $args = $this->getTemplateArgs($matches[3]);
1693                 $argc = count( $args );
1694
1695                 # Don't parse {{{}}} because that's only for template arguments
1696                 if ( $linestart === '{' ) {
1697                         $text = $matches[0];
1698                         $found = true;
1699                         $noparse = true;
1700                 }
1701
1702                 # SUBST
1703                 if ( !$found ) {
1704                         $mwSubst =& MagicWord::get( MAG_SUBST );
1705                         if ( $mwSubst->matchStartAndRemove( $part1 ) xor ($this->mOutputType == OT_WIKI) ) {
1706                                 # One of two possibilities is true:
1707                                 # 1) Found SUBST but not in the PST phase
1708                                 # 2) Didn't find SUBST and in the PST phase
1709                                 # In either case, return without further processing
1710                                 $text = $matches[0];
1711                                 $found = true;
1712                                 $noparse = true;
1713                         }
1714                 }
1715
1716                 # MSG, MSGNW and INT
1717                 if ( !$found ) {
1718                         # Check for MSGNW:
1719                         $mwMsgnw =& MagicWord::get( MAG_MSGNW );
1720                         if ( $mwMsgnw->matchStartAndRemove( $part1 ) ) {
1721                                 $nowiki = true;
1722                         } else {
1723                                 # Remove obsolete MSG:
1724                                 $mwMsg =& MagicWord::get( MAG_MSG );
1725                                 $mwMsg->matchStartAndRemove( $part1 );
1726                         }
1727
1728                         # Check if it is an internal message
1729                         $mwInt =& MagicWord::get( MAG_INT );
1730                         if ( $mwInt->matchStartAndRemove( $part1 ) ) {
1731                                 if ( $this->incrementIncludeCount( 'int:'.$part1 ) ) {
1732                                         $text = $linestart . wfMsgReal( $part1, $args, true );
1733                                         $found = true;
1734                                 }
1735                         }
1736                 }
1737
1738                 # NS
1739                 if ( !$found ) {
1740                         # Check for NS: (namespace expansion)
1741                         $mwNs = MagicWord::get( MAG_NS );
1742                         if ( $mwNs->matchStartAndRemove( $part1 ) ) {
1743                                 if ( intval( $part1 ) ) {
1744                                         $text = $linestart . $wgContLang->getNsText( intval( $part1 ) );
1745                                         $found = true;
1746                                 } else {
1747                                         $index = Namespace::getCanonicalIndex( strtolower( $part1 ) );
1748                                         if ( !is_null( $index ) ) {
1749                                                 $text = $linestart . $wgContLang->getNsText( $index );
1750                                                 $found = true;
1751                                         }
1752                                 }
1753                         }
1754                 }
1755
1756                 # LOCALURL and LOCALURLE
1757                 if ( !$found ) {
1758                         $mwLocal = MagicWord::get( MAG_LOCALURL );
1759                         $mwLocalE = MagicWord::get( MAG_LOCALURLE );
1760
1761                         if ( $mwLocal->matchStartAndRemove( $part1 ) ) {
1762                                 $func = 'getLocalURL';
1763                         } elseif ( $mwLocalE->matchStartAndRemove( $part1 ) ) {
1764                                 $func = 'escapeLocalURL';
1765                         } else {
1766                                 $func = '';
1767                         }
1768
1769                         if ( $func !== '' ) {
1770                                 $title = Title::newFromText( $part1 );
1771                                 if ( !is_null( $title ) ) {
1772                                         if ( $argc > 0 ) {
1773                                                 $text = $linestart . $title->$func( $args[0] );
1774                                         } else {
1775                                                 $text = $linestart . $title->$func();
1776                                         }
1777                                         $found = true;
1778                                 }
1779                         }
1780                 }
1781
1782                 # GRAMMAR
1783                 if ( !$found && $argc == 1 ) {
1784                         $mwGrammar =& MagicWord::get( MAG_GRAMMAR );
1785                         if ( $mwGrammar->matchStartAndRemove( $part1 ) ) {
1786                                 $text = $linestart . $wgContLang->convertGrammar( $args[0], $part1 );
1787                                 $found = true;
1788                         }
1789                 }
1790
1791                 # Template table test
1792
1793                 # Did we encounter this template already? If yes, it is in the cache
1794                 # and we need to check for loops.
1795                 if ( !$found && isset( $this->mTemplates[$part1] ) ) {
1796                         # set $text to cached message.
1797                         $text = $linestart . $this->mTemplates[$part1];
1798                         $found = true;
1799
1800                         # Infinite loop test
1801                         if ( isset( $this->mTemplatePath[$part1] ) ) {
1802                                 $noparse = true;
1803                                 $found = true;
1804                                 $text .= '<!-- WARNING: template loop detected -->';
1805                         }
1806                 }
1807
1808                 # Load from database
1809                 $itcamefromthedatabase = false;
1810                 if ( !$found ) {
1811                         $ns = NS_TEMPLATE;
1812                         $part1 = $this->maybeDoSubpageLink( $part1, $subpage='' );
1813                         if ($subpage !== '') {
1814                                 $ns = $this->mTitle->getNamespace();
1815                         }
1816                         $title = Title::newFromText( $part1, $ns );
1817                         if ( !is_null( $title ) && !$title->isExternal() ) {
1818                                 # Check for excessive inclusion
1819                                 $dbk = $title->getPrefixedDBkey();
1820                                 if ( $this->incrementIncludeCount( $dbk ) ) {
1821                                         # This should never be reached.
1822                                         $article = new Article( $title );
1823                                         $articleContent = $article->getContentWithoutUsingSoManyDamnGlobals();
1824                                         if ( $articleContent !== false ) {
1825                                                 $found = true;
1826                                                 $text = $linestart . $articleContent;
1827                                                 $itcamefromthedatabase = true;
1828                                         }
1829                                 }
1830
1831                                 # If the title is valid but undisplayable, make a link to it
1832                                 if ( $this->mOutputType == OT_HTML && !$found ) {
1833                                         $text = $linestart . '[['.$title->getPrefixedText().']]';
1834                                         $found = true;
1835                                 }
1836
1837                                 # Template cache array insertion
1838                                 $this->mTemplates[$part1] = $text;
1839                         }
1840                 }
1841
1842                 # Recursive parsing, escaping and link table handling
1843                 # Only for HTML output
1844                 if ( $nowiki && $found && $this->mOutputType == OT_HTML ) {
1845                         $text = wfEscapeWikiText( $text );
1846                 } elseif ( ($this->mOutputType == OT_HTML || $this->mOutputType == OT_WIKI) && $found && !$noparse) {
1847                         # Clean up argument array
1848                         $assocArgs = array();
1849                         $index = 1;
1850                         foreach( $args as $arg ) {
1851                                 $eqpos = strpos( $arg, '=' );
1852                                 if ( $eqpos === false ) {
1853                                         $assocArgs[$index++] = $arg;
1854                                 } else {
1855                                         $name = trim( substr( $arg, 0, $eqpos ) );
1856                                         $value = trim( substr( $arg, $eqpos+1 ) );
1857                                         if ( $value === false ) {
1858                                                 $value = '';
1859                                         }
1860                                         if ( $name !== false ) {
1861                                                 $assocArgs[$name] = $value;
1862                                         }
1863                                 }
1864                         }
1865
1866                         # Add a new element to the templace recursion path
1867                         $this->mTemplatePath[$part1] = 1;
1868
1869                         $text = $this->strip( $text, $this->mStripState );
1870                         $text = $this->removeHTMLtags( $text );
1871                         $text = $this->replaceVariables( $text, $assocArgs );
1872
1873                         # Resume the link cache and register the inclusion as a link
1874                         if ( $this->mOutputType == OT_HTML && !is_null( $title ) ) {
1875                                 $wgLinkCache->addLinkObj( $title );
1876                         }
1877
1878                         # If the template begins with a table or block-level
1879                         # element, it should be treated as beginning a new line.
1880                         if ($linestart !== '\n' && preg_match('/^({\\||:|;|#|\*)/', $text)) {
1881                                 $text = "\n" . $text;
1882                         }
1883                 }
1884
1885                 # Empties the template path
1886                 $this->mTemplatePath = array();
1887                 if ( !$found ) {
1888                         return $matches[0];
1889                 } else {
1890                         # replace ==section headers==
1891                         # XXX this needs to go away once we have a better parser.
1892                         if ( $this->mOutputType != OT_WIKI && $itcamefromthedatabase ) {
1893                                 if( !is_null( $title ) )
1894                                         $encodedname = base64_encode($title->getPrefixedDBkey());
1895                                 else
1896                                         $encodedname = base64_encode("");
1897                                 $m = preg_split('/(^={1,6}.*?={1,6}\s*?$)/m', $text, -1,
1898                                         PREG_SPLIT_DELIM_CAPTURE);
1899                                 $text = '';
1900                                 $nsec = 0;
1901                                 for( $i = 0; $i < count($m); $i += 2 ) {
1902                                         $text .= $m[$i];
1903                                         if (!isset($m[$i + 1]) || $m[$i + 1] == "") continue;
1904                                         $hl = $m[$i + 1];
1905                                         if( strstr($hl, "<!--MWTEMPLATESECTION") ) {
1906                                                 $text .= $hl;
1907                                                 continue;
1908                                         }
1909                                         preg_match('/^(={1,6})(.*?)(={1,6})\s*?$/m', $hl, $m2);
1910                                         $text .= $m2[1] . $m2[2] . "<!--MWTEMPLATESECTION="
1911                                                 . $encodedname . "&" . base64_encode("$nsec") . "-->" . $m2[3];
1912
1913                                         $nsec++;
1914                                 }
1915                         }
1916                 }
1917
1918                 # Empties the template path
1919                 $this->mTemplatePath = array();
1920                 if ( !$found ) {
1921                         return $matches[0];
1922                 } else {
1923                         return $text;
1924                 }
1925         }
1926
1927         /**
1928          * Triple brace replacement -- used for template arguments
1929          * @access private
1930          */
1931         function argSubstitution( $matches ) {
1932                 $arg = trim( $matches[1] );
1933                 $text = $matches[0];
1934                 $inputArgs = end( $this->mArgStack );
1935
1936                 if ( array_key_exists( $arg, $inputArgs ) ) {
1937                         $text = $inputArgs[$arg];
1938                 }
1939
1940                 return $text;
1941         }
1942
1943         /**
1944          * Returns true if the function is allowed to include this entity
1945          * @access private
1946          */
1947         function incrementIncludeCount( $dbk ) {
1948                 if ( !array_key_exists( $dbk, $this->mIncludeCount ) ) {
1949                         $this->mIncludeCount[$dbk] = 0;
1950                 }
1951                 if ( ++$this->mIncludeCount[$dbk] <= MAX_INCLUDE_REPEAT ) {
1952                         return true;
1953                 } else {
1954                         return false;
1955                 }
1956         }
1957
1958
1959         /**
1960          * Cleans up HTML, removes dangerous tags and attributes, and
1961          * removes HTML comments
1962          * @access private
1963          */
1964         function removeHTMLtags( $text ) {
1965                 global $wgUseTidy, $wgUserHtml;
1966                 $fname = 'Parser::removeHTMLtags';
1967                 wfProfileIn( $fname );
1968
1969                 if( $wgUserHtml ) {
1970                         $htmlpairs = array( # Tags that must be closed
1971                                 'b', 'del', 'i', 'ins', 'u', 'font', 'big', 'small', 'sub', 'sup', 'h1',
1972                                 'h2', 'h3', 'h4', 'h5', 'h6', 'cite', 'code', 'em', 's',
1973                                 'strike', 'strong', 'tt', 'var', 'div', 'center',
1974                                 'blockquote', 'ol', 'ul', 'dl', 'table', 'caption', 'pre',
1975                                 'ruby', 'rt' , 'rb' , 'rp', 'p'
1976                         );
1977                         $htmlsingle = array(
1978                                 'br', 'hr', 'li', 'dt', 'dd'
1979                         );
1980                         $htmlnest = array( # Tags that can be nested--??
1981                                 'table', 'tr', 'td', 'th', 'div', 'blockquote', 'ol', 'ul',
1982                                 'dl', 'font', 'big', 'small', 'sub', 'sup'
1983                         );
1984                         $tabletags = array( # Can only appear inside table
1985                                 'td', 'th', 'tr'
1986                         );
1987                 } else {
1988                         $htmlpairs = array();
1989                         $htmlsingle = array();
1990                         $htmlnest = array();
1991                         $tabletags = array();
1992                 }
1993
1994                 $htmlsingle = array_merge( $tabletags, $htmlsingle );
1995                 $htmlelements = array_merge( $htmlsingle, $htmlpairs );
1996
1997                 $htmlattrs = $this->getHTMLattrs () ;
1998
1999                 # Remove HTML comments
2000                 $text = $this->removeHTMLcomments( $text );
2001
2002                 $bits = explode( '<', $text );
2003                 $text = array_shift( $bits );
2004                 if(!$wgUseTidy) {
2005                         $tagstack = array(); $tablestack = array();
2006                         foreach ( $bits as $x ) {
2007                                 $prev = error_reporting( E_ALL & ~( E_NOTICE | E_WARNING ) );
2008                                 preg_match( '/^(\\/?)(\\w+)([^>]*)(\\/{0,1}>)([^<]*)$/',
2009                                 $x, $regs );
2010                                 list( $qbar, $slash, $t, $params, $brace, $rest ) = $regs;
2011                                 error_reporting( $prev );
2012
2013                                 $badtag = 0 ;
2014                                 if ( in_array( $t = strtolower( $t ), $htmlelements ) ) {
2015                                         # Check our stack
2016                                         if ( $slash ) {
2017                                                 # Closing a tag...
2018                                                 if ( ! in_array( $t, $htmlsingle ) &&
2019                                                 ( $ot = @array_pop( $tagstack ) ) != $t ) {
2020                                                         @array_push( $tagstack, $ot );
2021                                                         $badtag = 1;
2022                                                 } else {
2023                                                         if ( $t == 'table' ) {
2024                                                                 $tagstack = array_pop( $tablestack );
2025                                                         }
2026                                                         $newparams = '';
2027                                                 }
2028                                         } else {
2029                                                 # Keep track for later
2030                                                 if ( in_array( $t, $tabletags ) &&
2031                                                 ! in_array( 'table', $tagstack ) ) {
2032                                                         $badtag = 1;
2033                                                 } else if ( in_array( $t, $tagstack ) &&
2034                                                 ! in_array ( $t , $htmlnest ) ) {
2035                                                         $badtag = 1 ;
2036                                                 } else if ( ! in_array( $t, $htmlsingle ) ) {
2037                                                         if ( $t == 'table' ) {
2038                                                                 array_push( $tablestack, $tagstack );
2039                                                                 $tagstack = array();
2040                                                         }
2041                                                         array_push( $tagstack, $t );
2042                                                 }
2043                                                 # Strip non-approved attributes from the tag
2044                                                 $newparams = $this->fixTagAttributes($params);
2045
2046                                         }
2047                                         if ( ! $badtag ) {
2048                                                 $rest = str_replace( '>', '&gt;', $rest );
2049                                                 $text .= "<$slash$t $newparams$brace$rest";
2050                                                 continue;
2051                                         }
2052                                 }
2053                                 $text .= '&lt;' . str_replace( '>', '&gt;', $x);
2054                         }
2055                         # Close off any remaining tags
2056                         while ( is_array( $tagstack ) && ($t = array_pop( $tagstack )) ) {
2057                                 $text .= "</$t>\n";
2058                                 if ( $t == 'table' ) { $tagstack = array_pop( $tablestack ); }
2059                         }
2060                 } else {
2061                         # this might be possible using tidy itself
2062                         foreach ( $bits as $x ) {
2063                                 preg_match( '/^(\\/?)(\\w+)([^>]*)(\\/{0,1}>)([^<]*)$/',
2064                                 $x, $regs );
2065                                 @list( $qbar, $slash, $t, $params, $brace, $rest ) = $regs;
2066                                 if ( in_array( $t = strtolower( $t ), $htmlelements ) ) {
2067                                         $newparams = $this->fixTagAttributes($params);
2068                                         $rest = str_replace( '>', '&gt;', $rest );
2069                                         $text .= "<$slash$t $newparams$brace$rest";
2070                                 } else {
2071                                         $text .= '&lt;' . str_replace( '>', '&gt;', $x);
2072                                 }
2073                         }
2074                 }
2075                 wfProfileOut( $fname );
2076                 return $text;
2077         }
2078
2079         /**
2080          * Remove '<!--', '-->', and everything between.
2081          * To avoid leaving blank lines, when a comment is both preceded
2082          * and followed by a newline (ignoring spaces), trim leading and
2083          * trailing spaces and one of the newlines.
2084          *
2085          * @access private
2086          */
2087         function removeHTMLcomments( $text ) {
2088                 $fname='Parser::removeHTMLcomments';
2089                 wfProfileIn( $fname );
2090                 while (($start = strpos($text, '<!--')) !== false) {
2091                         $end = strpos($text, '-->', $start + 4);
2092                         if ($end === false) {
2093                                 # Unterminated comment; bail out
2094                                 break;
2095                         }
2096
2097                         $end += 3;
2098
2099                         # Trim space and newline if the comment is both
2100                         # preceded and followed by a newline
2101                         $spaceStart = max($start - 1, 0);
2102                         $spaceLen = $end - $spaceStart;
2103                         while (substr($text, $spaceStart, 1) === ' ' && $spaceStart > 0) {
2104                                 $spaceStart--;
2105                                 $spaceLen++;
2106                         }
2107                         while (substr($text, $spaceStart + $spaceLen, 1) === ' ')
2108                                 $spaceLen++;
2109                         if (substr($text, $spaceStart, 1) === "\n" and substr($text, $spaceStart + $spaceLen, 1) === "\n") {
2110                                 # Remove the comment, leading and trailing
2111                                 # spaces, and leave only one newline.
2112                                 $text = substr_replace($text, "\n", $spaceStart, $spaceLen + 1);
2113                         }
2114                         else {
2115                                 # Remove just the comment.
2116                                 $text = substr_replace($text, '', $start, $end - $start);
2117                         }
2118                 }
2119                 wfProfileOut( $fname );
2120                 return $text;
2121         }
2122
2123         /**
2124          * This function accomplishes several tasks:
2125          * 1) Auto-number headings if that option is enabled
2126          * 2) Add an [edit] link to sections for logged in users who have enabled the option
2127          * 3) Add a Table of contents on the top for users who have enabled the option
2128          * 4) Auto-anchor headings
2129          *
2130          * It loops through all headlines, collects the necessary data, then splits up the
2131          * string and re-inserts the newly formatted headlines.
2132          * @access private
2133          */
2134         /* private */ function formatHeadings( $text, $isMain=true ) {
2135                 global $wgInputEncoding, $wgMaxTocLevel, $wgContLang, $wgLinkHolders;
2136
2137                 $doNumberHeadings = $this->mOptions->getNumberHeadings();
2138                 $doShowToc = $this->mOptions->getShowToc();
2139                 $forceTocHere = false;
2140                 if( !$this->mTitle->userCanEdit() ) {
2141                         $showEditLink = 0;
2142                         $rightClickHack = 0;
2143                 } else {
2144                         $showEditLink = $this->mOptions->getEditSection();
2145                         $rightClickHack = $this->mOptions->getEditSectionOnRightClick();
2146                 }
2147
2148                 # Inhibit editsection links if requested in the page
2149                 $esw =& MagicWord::get( MAG_NOEDITSECTION );
2150                 if( $esw->matchAndRemove( $text ) ) {
2151                         $showEditLink = 0;
2152                 }
2153                 # if the string __NOTOC__ (not case-sensitive) occurs in the HTML,
2154                 # do not add TOC
2155                 $mw =& MagicWord::get( MAG_NOTOC );
2156                 if( $mw->matchAndRemove( $text ) ) {
2157                         $doShowToc = 0;
2158                 }
2159
2160                 # never add the TOC to the Main Page. This is an entry page that should not
2161                 # be more than 1-2 screens large anyway
2162                 if( $this->mTitle->getPrefixedText() == wfMsg('mainpage') ) {
2163                         $doShowToc = 0;
2164                 }
2165
2166                 # Get all headlines for numbering them and adding funky stuff like [edit]
2167                 # links - this is for later, but we need the number of headlines right now
2168                 $numMatches = preg_match_all( '/<H([1-6])(.*?' . '>)(.*?)<\/H[1-6]>/i', $text, $matches );
2169
2170                 # if there are fewer than 4 headlines in the article, do not show TOC
2171                 if( $numMatches < 4 ) {
2172                         $doShowToc = 0;
2173                 }
2174
2175                 # if the string __TOC__ (not case-sensitive) occurs in the HTML,
2176                 # override above conditions and always show TOC at that place
2177                 $mw =& MagicWord::get( MAG_TOC );
2178                 if ($mw->match( $text ) ) {
2179                         $doShowToc = 1;
2180                         $forceTocHere = true;
2181                 } else {
2182                         # if the string __FORCETOC__ (not case-sensitive) occurs in the HTML,
2183                         # override above conditions and always show TOC above first header
2184                         $mw =& MagicWord::get( MAG_FORCETOC );
2185                         if ($mw->matchAndRemove( $text ) ) {
2186                                 $doShowToc = 1;
2187                         }
2188                 }
2189
2190
2191
2192                 # We need this to perform operations on the HTML
2193                 $sk =& $this->mOptions->getSkin();
2194
2195                 # headline counter
2196                 $headlineCount = 0;
2197                 $sectionCount = 0; # headlineCount excluding template sections
2198
2199                 # Ugh .. the TOC should have neat indentation levels which can be
2200                 # passed to the skin functions. These are determined here
2201                 $toclevel = 0;
2202                 $toc = '';
2203                 $full = '';
2204                 $head = array();
2205                 $sublevelCount = array();
2206                 $level = 0;
2207                 $prevlevel = 0;
2208                 foreach( $matches[3] as $headline ) {
2209                         $istemplate = 0;
2210                         $templatetitle = "";
2211                         $templatesection = 0;
2212
2213                         if (preg_match("/<!--MWTEMPLATESECTION=([^&]+)&([^_]+)-->/", $headline, $mat)) {
2214                                 $istemplate = 1;
2215                                 $templatetitle = base64_decode($mat[1]);
2216                                 $templatesection = 1 + (int)base64_decode($mat[2]);
2217                                 $headline = preg_replace("/<!--MWTEMPLATESECTION=([^&]+)&([^_]+)-->/", "", $headline);
2218                         }
2219
2220                         $numbering = '';
2221                         if( $level ) {
2222                                 $prevlevel = $level;
2223                         }
2224                         $level = $matches[1][$headlineCount];
2225                         if( ( $doNumberHeadings || $doShowToc ) && $prevlevel && $level > $prevlevel ) {
2226                                 # reset when we enter a new level
2227                                 $sublevelCount[$level] = 0;
2228                                 $toc .= $sk->tocIndent( $level - $prevlevel );
2229                                 $toclevel += $level - $prevlevel;
2230                         }
2231                         if( ( $doNumberHeadings || $doShowToc ) && $level < $prevlevel ) {
2232                                 # reset when we step back a level
2233                                 $sublevelCount[$level+1]=0;
2234                                 $toc .= $sk->tocUnindent( $prevlevel - $level );
2235                                 $toclevel -= $prevlevel - $level;
2236                         }
2237                         # count number of headlines for each level
2238                         @$sublevelCount[$level]++;
2239                         if( $doNumberHeadings || $doShowToc ) {
2240                                 $dot = 0;
2241                                 for( $i = 1; $i <= $level; $i++ ) {
2242                                         if( !empty( $sublevelCount[$i] ) ) {
2243                                                 if( $dot ) {
2244                                                         $numbering .= '.';
2245                                                 }
2246                                                 $numbering .= $wgContLang->formatNum( $sublevelCount[$i] );
2247                                                 $dot = 1;
2248                                         }
2249                                 }
2250                         }
2251
2252                         # The canonized header is a version of the header text safe to use for links
2253                         # Avoid insertion of weird stuff like <math> by expanding the relevant sections
2254                         $canonized_headline = $this->unstrip( $headline, $this->mStripState );
2255                         $canonized_headline = $this->unstripNoWiki( $headline, $this->mStripState );
2256
2257                         # Remove link placeholders by the link text.
2258                         #     <!--LINK number-->
2259                         # turns into
2260                         #     link text with suffix
2261                         $canonized_headline = preg_replace( '/<!--LINK ([0-9]*)-->/e',
2262                                                             "\$wgLinkHolders['texts'][\$1]",
2263                                                             $canonized_headline );
2264
2265                         # strip out HTML
2266                         $canonized_headline = preg_replace( '/<.*?' . '>/','',$canonized_headline );
2267                         $tocline = trim( $canonized_headline );
2268                         $canonized_headline = urlencode( do_html_entity_decode( str_replace(' ', '_', $tocline), ENT_COMPAT, $wgInputEncoding ) );
2269                         $replacearray = array(
2270                                 '%3A' => ':',
2271                                 '%' => '.'
2272                         );
2273                         $canonized_headline = str_replace(array_keys($replacearray),array_values($replacearray),$canonized_headline);
2274                         $refer[$headlineCount] = $canonized_headline;
2275
2276                         # count how many in assoc. array so we can track dupes in anchors
2277                         @$refers[$canonized_headline]++;
2278                         $refcount[$headlineCount]=$refers[$canonized_headline];
2279
2280                         # Prepend the number to the heading text
2281
2282                         if( $doNumberHeadings || $doShowToc ) {
2283                                 $tocline = $numbering . ' ' . $tocline;
2284
2285                                 # Don't number the heading if it is the only one (looks silly)
2286                                 if( $doNumberHeadings && count( $matches[3] ) > 1) {
2287                                         # the two are different if the line contains a link
2288                                         $headline=$numbering . ' ' . $headline;
2289                                 }
2290                         }
2291
2292                         # Create the anchor for linking from the TOC to the section
2293                         $anchor = $canonized_headline;
2294                         if($refcount[$headlineCount] > 1 ) {
2295                                 $anchor .= '_' . $refcount[$headlineCount];
2296                         }
2297                         if( $doShowToc && ( !isset($wgMaxTocLevel) || $toclevel<$wgMaxTocLevel ) ) {
2298                                 $toc .= $sk->tocLine($anchor,$tocline,$toclevel);
2299                         }
2300                         if( $showEditLink && ( !$istemplate || $templatetitle !== "" ) ) {
2301                                 if ( empty( $head[$headlineCount] ) ) {
2302                                         $head[$headlineCount] = '';
2303                                 }
2304                                 if( $istemplate )
2305                                         $head[$headlineCount] .= $sk->editSectionLinkForOther($templatetitle, $templatesection);
2306                                 else
2307                                         $head[$headlineCount] .= $sk->editSectionLink($sectionCount+1);
2308                         }
2309
2310                         # Add the edit section span
2311                         if( $rightClickHack ) {
2312                                 if( $istemplate )
2313                                         $headline = $sk->editSectionScriptForOther($templatetitle, $templatesection, $headline);
2314                                 else
2315                                         $headline = $sk->editSectionScript($sectionCount+1,$headline);
2316                         }
2317
2318                         # give headline the correct <h#> tag
2319                         @$head[$headlineCount] .= "<a name=\"$anchor\"></a><h".$level.$matches[2][$headlineCount] .$headline.'</h'.$level.'>';
2320
2321                         $headlineCount++;
2322                         if( !$istemplate )
2323                                 $sectionCount++;
2324                 }
2325
2326                 if( $doShowToc ) {
2327                         $toclines = $headlineCount;
2328                         $toc .= $sk->tocUnindent( $toclevel );
2329                         $toc = $sk->tocTable( $toc );
2330                 }
2331
2332                 # split up and insert constructed headlines
2333
2334                 $blocks = preg_split( '/<H[1-6].*?' . '>.*?<\/H[1-6]>/i', $text );
2335                 $i = 0;
2336
2337                 foreach( $blocks as $block ) {
2338                         if( $showEditLink && $headlineCount > 0 && $i == 0 && $block != "\n" ) {
2339                                 # This is the [edit] link that appears for the top block of text when
2340                                 # section editing is enabled
2341
2342                                 # Disabled because it broke block formatting
2343                                 # For example, a bullet point in the top line
2344                                 # $full .= $sk->editSectionLink(0);
2345                         }
2346                         $full .= $block;
2347                         if( $doShowToc && !$i && $isMain && !$forceTocHere) {
2348                         # Top anchor now in skin
2349                                 $full = $full.$toc;
2350                         }
2351
2352                         if( !empty( $head[$i] ) ) {
2353                                 $full .= $head[$i];
2354                         }
2355                         $i++;
2356                 }
2357                 if($forceTocHere) {
2358                         $mw =& MagicWord::get( MAG_TOC );
2359                         return $mw->replace( $toc, $full );
2360                 } else {
2361                         return $full;
2362                 }
2363         }
2364
2365         /**
2366          * Return an HTML link for the "ISBN 123456" text
2367          * @access private
2368          */
2369         function magicISBN( $text ) {
2370                 global $wgLang;
2371                 $fname = 'Parser::magicISBN';
2372                 wfProfileIn( $fname );
2373
2374                 $a = split( 'ISBN ', ' '.$text );
2375                 if ( count ( $a ) < 2 ) {
2376                         wfProfileOut( $fname );
2377                         return $text;
2378                 }
2379                 $text = substr( array_shift( $a ), 1);
2380                 $valid = '0123456789-ABCDEFGHIJKLMNOPQRSTUVWXYZ';
2381
2382                 foreach ( $a as $x ) {
2383                         $isbn = $blank = '' ;
2384                         while ( ' ' == $x{0} ) {
2385                                 $blank .= ' ';
2386                                 $x = substr( $x, 1 );
2387                         }
2388                         if ( $x == '' ) { # blank isbn
2389                                 $text .= "ISBN $blank";
2390                                 continue;
2391                         }
2392                         while ( strstr( $valid, $x{0} ) != false ) {
2393                                 $isbn .= $x{0};
2394                                 $x = substr( $x, 1 );
2395                         }
2396                         $num = str_replace( '-', '', $isbn );
2397                         $num = str_replace( ' ', '', $num );
2398
2399                         if ( '' == $num ) {
2400                                 $text .= "ISBN $blank$x";
2401                         } else {
2402                                 $titleObj = Title::makeTitle( NS_SPECIAL, 'Booksources' );
2403                                 $text .= '<a href="' .
2404                                 $titleObj->escapeLocalUrl( 'isbn='.$num ) .
2405                                         "\" class=\"internal\">ISBN $isbn</a>";
2406                                 $text .= $x;
2407                         }
2408                 }
2409                 wfProfileOut( $fname );
2410                 return $text;
2411         }
2412
2413         /**
2414          * Return an HTML link for the "GEO ..." text
2415          * @access private
2416          */
2417         function magicGEO( $text ) {
2418                 global $wgLang, $wgUseGeoMode;
2419                 $fname = 'Parser::magicGEO';
2420                 wfProfileIn( $fname );
2421
2422                 # These next five lines are only for the ~35000 U.S. Census Rambot pages...
2423                 $directions = array ( 'N' => 'North' , 'S' => 'South' , 'E' => 'East' , 'W' => 'West' ) ;
2424                 $text = preg_replace ( "/(\d+)&deg;(\d+)'(\d+)\" {$directions['N']}, (\d+)&deg;(\d+)'(\d+)\" {$directions['W']}/" , "(GEO +\$1.\$2.\$3:-\$4.\$5.\$6)" , $text ) ;
2425                 $text = preg_replace ( "/(\d+)&deg;(\d+)'(\d+)\" {$directions['N']}, (\d+)&deg;(\d+)'(\d+)\" {$directions['E']}/" , "(GEO +\$1.\$2.\$3:+\$4.\$5.\$6)" , $text ) ;
2426                 $text = preg_replace ( "/(\d+)&deg;(\d+)'(\d+)\" {$directions['S']}, (\d+)&deg;(\d+)'(\d+)\" {$directions['W']}/" , "(GEO +\$1.\$2.\$3:-\$4.\$5.\$6)" , $text ) ;
2427                 $text = preg_replace ( "/(\d+)&deg;(\d+)'(\d+)\" {$directions['S']}, (\d+)&deg;(\d+)'(\d+)\" {$directions['E']}/" , "(GEO +\$1.\$2.\$3:+\$4.\$5.\$6)" , $text ) ;
2428
2429                 $a = split( 'GEO ', ' '.$text );
2430                 if ( count ( $a ) < 2 ) {
2431                         wfProfileOut( $fname );
2432                         return $text;
2433                 }
2434                 $text = substr( array_shift( $a ), 1);
2435                 $valid = '0123456789.+-:';
2436
2437                 foreach ( $a as $x ) {
2438                         $geo = $blank = '' ;
2439                         while ( ' ' == $x{0} ) {
2440                                 $blank .= ' ';
2441                                 $x = substr( $x, 1 );
2442                         }
2443                         while ( strstr( $valid, $x{0} ) != false ) {
2444                                 $geo .= $x{0};
2445                                 $x = substr( $x, 1 );
2446                         }
2447                         $num = str_replace( '+', '', $geo );
2448                         $num = str_replace( ' ', '', $num );
2449
2450                         if ( '' == $num || count ( explode ( ':' , $num , 3 ) ) < 2 ) {
2451                                 $text .= "GEO $blank$x";
2452                         } else {
2453                                 $titleObj = Title::makeTitle( NS_SPECIAL, 'Geo' );
2454                                 $text .= '<a href="' .
2455                                 $titleObj->escapeLocalUrl( 'coordinates='.$num ) .
2456                                         "\" class=\"internal\">GEO $geo</a>";
2457                                 $text .= $x;
2458                         }
2459                 }
2460                 wfProfileOut( $fname );
2461                 return $text;
2462         }
2463
2464         /**
2465          * Return an HTML link for the "RFC 1234" text
2466          * @access private
2467          * @param string $text text to be processed
2468          */
2469         function magicRFC( $text ) {
2470                 global $wgLang;
2471
2472                 $valid = '0123456789';
2473                 $internal = false;
2474
2475                 $a = split( 'RFC ', ' '.$text );
2476                 if ( count ( $a ) < 2 ) return $text;
2477                 $text = substr( array_shift( $a ), 1);
2478
2479                 /* Check if RFC keyword is preceed by [[.
2480                  * This test is made here cause of the array_shift above
2481                  * that prevent the test to be done in the foreach.
2482                  */
2483                 if(substr($text, -2) == '[[') { $internal = true; }
2484
2485                 foreach ( $a as $x ) {
2486                         /* token might be empty if we have RFC RFC 1234 */
2487                         if($x=='') {
2488                                 $text.='RFC ';
2489                                 continue;
2490                                 }
2491
2492                         $rfc = $blank = '' ;
2493
2494                         /** remove and save whitespaces in $blank */
2495                         while ( $x{0} == ' ' ) {
2496                                 $blank .= ' ';
2497                                 $x = substr( $x, 1 );
2498                         }
2499
2500                         /** remove and save the rfc number in $rfc */
2501                         while ( strstr( $valid, $x{0} ) != false ) {
2502                                 $rfc .= $x{0};
2503                                 $x = substr( $x, 1 );
2504                         }
2505
2506                         if ( $rfc == '') {
2507                                 /* call back stripped spaces*/
2508                                 $text .= "RFC $blank$x";
2509                         } elseif( $internal) {
2510                                 /* normal link */
2511                                 $text .= "RFC $rfc$x";
2512                         } else {
2513                                 /* build the external link*/
2514                                 $url = wfmsg( 'rfcurl' );
2515                                 $url = str_replace( '$1', $rfc, $url);
2516                                 $sk =& $this->mOptions->getSkin();
2517                                 $la = $sk->getExternalLinkAttributes( $url, 'RFC '.$rfc );
2518                                 $text .= "<a href='{$url}'{$la}>RFC {$rfc}</a>{$x}";
2519                         }
2520
2521                         /* Check if the next RFC keyword is preceed by [[ */
2522                         $internal = (substr($x,-2) == '[[');
2523                 }
2524                 return $text;
2525         }
2526
2527         /**
2528          * Transform wiki markup when saving a page by doing \r\n -> \n
2529          * conversion, substitting signatures, {{subst:}} templates, etc.
2530          *
2531          * @param string $text the text to transform
2532          * @param Title &$title the Title object for the current article
2533          * @param User &$user the User object describing the current user
2534          * @param ParserOptions $options parsing options
2535          * @param bool $clearState whether to clear the parser state first
2536          * @return string the altered wiki markup
2537          * @access public
2538          */
2539         function preSaveTransform( $text, &$title, &$user, $options, $clearState = true ) {
2540                 $this->mOptions = $options;
2541                 $this->mTitle =& $title;
2542                 $this->mOutputType = OT_WIKI;
2543
2544                 if ( $clearState ) {
2545                         $this->clearState();
2546                 }
2547
2548                 $stripState = false;
2549                 $pairs = array(
2550                         "\r\n" => "\n",
2551                         );
2552                 $text = str_replace(array_keys($pairs), array_values($pairs), $text);
2553                 // now with regexes
2554                 /*
2555                 $pairs = array(
2556                         "/<br.+(clear|break)=[\"']?(all|both)[\"']?\\/?>/i" => '<br style="clear:both;"/>',
2557                         "/<br *?>/i" => "<br />",
2558                 );
2559                 $text = preg_replace(array_keys($pairs), array_values($pairs), $text);
2560                 */
2561                 $text = $this->strip( $text, $stripState, false );
2562                 $text = $this->pstPass2( $text, $user );
2563                 $text = $this->unstrip( $text, $stripState );
2564                 $text = $this->unstripNoWiki( $text, $stripState );
2565                 return $text;
2566         }
2567
2568         /**
2569          * Pre-save transform helper function
2570          * @access private
2571          */
2572         function pstPass2( $text, &$user ) {
2573                 global $wgLang, $wgContLang, $wgLocaltimezone, $wgCurParser;
2574
2575                 # Variable replacement
2576                 # Because mOutputType is OT_WIKI, this will only process {{subst:xxx}} type tags
2577                 $text = $this->replaceVariables( $text );
2578
2579                 # Signatures
2580                 #
2581                 $n = $user->getName();
2582                 $k = $user->getOption( 'nickname' );
2583                 if ( '' == $k ) { $k = $n; }
2584                 if(isset($wgLocaltimezone)) {
2585                         $oldtz = getenv('TZ'); putenv('TZ='.$wgLocaltimezone);
2586                 }
2587                 /* Note: this is an ugly timezone hack for the European wikis */
2588                 $d = $wgContLang->timeanddate( date( 'YmdHis' ), false ) .
2589                   ' (' . date( 'T' ) . ')';
2590                 if(isset($wgLocaltimezone)) putenv('TZ='.$oldtzs);
2591
2592                 $text = preg_replace( '/~~~~~/', $d, $text );
2593                 $text = preg_replace( '/~~~~/', '[[' . $wgContLang->getNsText( NS_USER ) . ":$n|$k]] $d", $text );
2594                 $text = preg_replace( '/~~~/', '[[' . $wgContLang->getNsText( NS_USER ) . ":$n|$k]]", $text );
2595
2596                 # Context links: [[|name]] and [[name (context)|]]
2597                 #
2598                 $tc = "[&;%\\-,.\\(\\)' _0-9A-Za-z\\/:\\x80-\\xff]";
2599                 $np = "[&;%\\-,.' _0-9A-Za-z\\/:\\x80-\\xff]"; # No parens
2600                 $namespacechar = '[ _0-9A-Za-z\x80-\xff]'; # Namespaces can use non-ascii!
2601                 $conpat = "/^({$np}+) \\(({$tc}+)\\)$/";
2602
2603                 $p1 = "/\[\[({$np}+) \\(({$np}+)\\)\\|]]/";             # [[page (context)|]]
2604                 $p2 = "/\[\[\\|({$tc}+)]]/";                                    # [[|page]]
2605                 $p3 = "/\[\[(:*$namespacechar+):({$np}+)\\|]]/";                # [[namespace:page|]] and [[:namespace:page|]]
2606                 $p4 = "/\[\[(:*$namespacechar+):({$np}+) \\(({$np}+)\\)\\|]]/"; # [[ns:page (cont)|]] and [[:ns:page (cont)|]]
2607                 $context = '';
2608                 $t = $this->mTitle->getText();
2609                 if ( preg_match( $conpat, $t, $m ) ) {
2610                         $context = $m[2];
2611                 }
2612                 $text = preg_replace( $p4, '[[\\1:\\2 (\\3)|\\2]]', $text );
2613                 $text = preg_replace( $p1, '[[\\1 (\\2)|\\1]]', $text );
2614                 $text = preg_replace( $p3, '[[\\1:\\2|\\2]]', $text );
2615
2616                 if ( '' == $context ) {
2617                         $text = preg_replace( $p2, '[[\\1]]', $text );
2618                 } else {
2619                         $text = preg_replace( $p2, "[[\\1 ({$context})|\\1]]", $text );
2620                 }
2621
2622                 # Trim trailing whitespace
2623                 # MAG_END (__END__) tag allows for trailing
2624                 # whitespace to be deliberately included
2625                 $text = rtrim( $text );
2626                 $mw =& MagicWord::get( MAG_END );
2627                 $mw->matchAndRemove( $text );
2628
2629                 return $text;
2630         }
2631
2632         /**
2633          * Set up some variables which are usually set up in parse()
2634          * so that an external function can call some class members with confidence
2635          * @access public
2636          */
2637         function startExternalParse( &$title, $options, $outputType, $clearState = true ) {
2638                 $this->mTitle =& $title;
2639                 $this->mOptions = $options;
2640                 $this->mOutputType = $outputType;
2641                 if ( $clearState ) {
2642                         $this->clearState();
2643                 }
2644         }
2645
2646         /**
2647          * Transform a MediaWiki message by replacing magic variables.
2648          *
2649          * @param string $text the text to transform
2650          * @param ParserOptions $options  options
2651          * @return string the text with variables substituted
2652          * @access public
2653          */
2654         function transformMsg( $text, $options ) {
2655                 global $wgTitle;
2656                 static $executing = false;
2657
2658                 # Guard against infinite recursion
2659                 if ( $executing ) {
2660                         return $text;
2661                 }
2662                 $executing = true;
2663
2664                 $this->mTitle = $wgTitle;
2665                 $this->mOptions = $options;
2666                 $this->mOutputType = OT_MSG;
2667                 $this->clearState();
2668                 $text = $this->replaceVariables( $text );
2669
2670                 $executing = false;
2671                 return $text;
2672         }
2673
2674         /**
2675          * Create an HTML-style tag, e.g. <yourtag>special text</yourtag>
2676          * Callback will be called with the text within
2677          * Transform and return the text within
2678          * @access public
2679          */
2680         function setHook( $tag, $callback ) {
2681                 $oldVal = @$this->mTagHooks[$tag];
2682                 $this->mTagHooks[$tag] = $callback;
2683                 return $oldVal;
2684         }
2685 }
2686
2687 /**
2688  * @todo document
2689  * @package MediaWiki
2690  */
2691 class ParserOutput
2692 {
2693         var $mText, $mLanguageLinks, $mCategoryLinks, $mContainsOldMagic;
2694         var $mCacheTime; # Used in ParserCache
2695
2696         function ParserOutput( $text = '', $languageLinks = array(), $categoryLinks = array(),
2697                 $containsOldMagic = false )
2698         {
2699                 $this->mText = $text;
2700                 $this->mLanguageLinks = $languageLinks;
2701                 $this->mCategoryLinks = $categoryLinks;
2702                 $this->mContainsOldMagic = $containsOldMagic;
2703                 $this->mCacheTime = '';
2704         }
2705
2706         function getText() { return $this->mText; }
2707         function getLanguageLinks() { return $this->mLanguageLinks; }
2708         function getCategoryLinks() { return $this->mCategoryLinks; }
2709         function getCacheTime() { return $this->mCacheTime; }
2710         function containsOldMagic() { return $this->mContainsOldMagic; }
2711         function setText( $text ) { return wfSetVar( $this->mText, $text ); }
2712         function setLanguageLinks( $ll ) { return wfSetVar( $this->mLanguageLinks, $ll ); }
2713         function setCategoryLinks( $cl ) { return wfSetVar( $this->mCategoryLinks, $cl ); }
2714         function setContainsOldMagic( $com ) { return wfSetVar( $this->mContainsOldMagic, $com ); }
2715         function setCacheTime( $t ) { return wfSetVar( $this->mCacheTime, $t ); }
2716
2717         function merge( $other ) {
2718                 $this->mLanguageLinks = array_merge( $this->mLanguageLinks, $other->mLanguageLinks );
2719                 $this->mCategoryLinks = array_merge( $this->mCategoryLinks, $this->mLanguageLinks );
2720                 $this->mContainsOldMagic = $this->mContainsOldMagic || $other->mContainsOldMagic;
2721         }
2722
2723 }
2724
2725 /**
2726  * Set options of the Parser
2727  * @todo document
2728  * @package MediaWiki
2729  */
2730 class ParserOptions
2731 {
2732         # All variables are private
2733         var $mUseTeX;                    # Use texvc to expand <math> tags
2734         var $mUseDynamicDates;           # Use $wgDateFormatter to format dates
2735         var $mInterwikiMagic;            # Interlanguage links are removed and returned in an array
2736         var $mAllowExternalImages;       # Allow external images inline
2737         var $mSkin;                      # Reference to the preferred skin
2738         var $mDateFormat;                # Date format index
2739         var $mEditSection;               # Create "edit section" links
2740         var $mEditSectionOnRightClick;   # Generate JavaScript to edit section on right click
2741         var $mNumberHeadings;            # Automatically number headings
2742         var $mShowToc;                   # Show table of contents
2743
2744         function getUseTeX()                        { return $this->mUseTeX; }
2745         function getUseDynamicDates()               { return $this->mUseDynamicDates; }
2746         function getInterwikiMagic()                { return $this->mInterwikiMagic; }
2747         function getAllowExternalImages()           { return $this->mAllowExternalImages; }
2748         function getSkin()                          { return $this->mSkin; }
2749         function getDateFormat()                    { return $this->mDateFormat; }
2750         function getEditSection()                   { return $this->mEditSection; }
2751         function getEditSectionOnRightClick()       { return $this->mEditSectionOnRightClick; }
2752         function getNumberHeadings()                { return $this->mNumberHeadings; }
2753         function getShowToc()                       { return $this->mShowToc; }
2754
2755         function setUseTeX( $x )                    { return wfSetVar( $this->mUseTeX, $x ); }
2756         function setUseDynamicDates( $x )           { return wfSetVar( $this->mUseDynamicDates, $x ); }
2757         function setInterwikiMagic( $x )            { return wfSetVar( $this->mInterwikiMagic, $x ); }
2758         function setAllowExternalImages( $x )       { return wfSetVar( $this->mAllowExternalImages, $x ); }
2759         function setDateFormat( $x )                { return wfSetVar( $this->mDateFormat, $x ); }
2760         function setEditSection( $x )               { return wfSetVar( $this->mEditSection, $x ); }
2761         function setEditSectionOnRightClick( $x )   { return wfSetVar( $this->mEditSectionOnRightClick, $x ); }
2762         function setNumberHeadings( $x )            { return wfSetVar( $this->mNumberHeadings, $x ); }
2763         function setShowToc( $x )                   { return wfSetVar( $this->mShowToc, $x ); }
2764
2765         function setSkin( &$x ) { $this->mSkin =& $x; }
2766
2767         # Get parser options
2768         /* static */ function newFromUser( &$user ) {
2769                 $popts = new ParserOptions;
2770                 $popts->initialiseFromUser( $user );
2771                 return $popts;
2772         }
2773
2774         # Get user options
2775         function initialiseFromUser( &$userInput ) {
2776                 global $wgUseTeX, $wgUseDynamicDates, $wgInterwikiMagic, $wgAllowExternalImages;
2777
2778                 $fname = 'ParserOptions::initialiseFromUser';
2779                 wfProfileIn( $fname );
2780                 if ( !$userInput ) {
2781                         $user = new User;
2782                         $user->setLoaded( true );
2783                 } else {
2784                         $user =& $userInput;
2785                 }
2786
2787                 $this->mUseTeX = $wgUseTeX;
2788                 $this->mUseDynamicDates = $wgUseDynamicDates;
2789                 $this->mInterwikiMagic = $wgInterwikiMagic;
2790                 $this->mAllowExternalImages = $wgAllowExternalImages;
2791                 wfProfileIn( $fname.'-skin' );
2792                 $this->mSkin =& $user->getSkin();
2793                 wfProfileOut( $fname.'-skin' );
2794                 $this->mDateFormat = $user->getOption( 'date' );
2795                 $this->mEditSection = $user->getOption( 'editsection' );
2796                 $this->mEditSectionOnRightClick = $user->getOption( 'editsectiononrightclick' );
2797                 $this->mNumberHeadings = $user->getOption( 'numberheadings' );
2798                 $this->mShowToc = $user->getOption( 'showtoc' );
2799                 wfProfileOut( $fname );
2800         }
2801
2802
2803 }
2804
2805 # Regex callbacks, used in Parser::replaceVariables
2806 function wfBraceSubstitution( $matches ) {
2807         global $wgCurParser;
2808         return $wgCurParser->braceSubstitution( $matches );
2809 }
2810
2811 function wfArgSubstitution( $matches ) {
2812         global $wgCurParser;
2813         return $wgCurParser->argSubstitution( $matches );
2814 }
2815
2816 function wfVariableSubstitution( $matches ) {
2817         global $wgCurParser;
2818         return $wgCurParser->variableSubstitution( $matches );
2819 }
2820
2821 /**
2822  * Return the total number of articles
2823  */
2824 function wfNumberOfArticles() {
2825         global $wgNumberOfArticles;
2826
2827         wfLoadSiteStats();
2828         return $wgNumberOfArticles;
2829 }
2830
2831 /**
2832  * Get various statistics from the database
2833  * @private
2834  */
2835 function wfLoadSiteStats() {
2836         global $wgNumberOfArticles, $wgTotalViews, $wgTotalEdits;
2837         $fname = 'wfLoadSiteStats';
2838
2839         if ( -1 != $wgNumberOfArticles ) return;
2840         $dbr =& wfGetDB( DB_SLAVE );
2841         $s = $dbr->getArray( 'site_stats',
2842                 array( 'ss_total_views', 'ss_total_edits', 'ss_good_articles' ),
2843                 array( 'ss_row_id' => 1 ), $fname
2844         );
2845
2846         if ( $s === false ) {
2847                 return;
2848         } else {
2849                 $wgTotalViews = $s->ss_total_views;
2850                 $wgTotalEdits = $s->ss_total_edits;
2851                 $wgNumberOfArticles = $s->ss_good_articles;
2852         }
2853 }
2854
2855 function wfEscapeHTMLTagsOnly( $in ) {
2856         return str_replace(
2857                 array( '"', '>', '<' ),
2858                 array( '&quot;', '&gt;', '&lt;' ),
2859                 $in );
2860 }
2861
2862 ?>