includes/Parser.php

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