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