includes/Parser.php

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