includes/Parser.php

   1 <?php
   2
   3 include_once('Tokenizer.php');
   4
   5 if( $GLOBALS['wgUseWikiHiero'] ){
   6         include_once('wikihiero.php');
   7 }
   8
   9 # PHP Parser
  10 #
  11 # Processes wiki markup
  12 #
  13 # There are two main entry points into the Parser class: parse() and preSaveTransform().
  14 # The parse() function produces HTML output, preSaveTransform() produces altered wiki markup.
  15 #
  16 # Globals used:
  17 #    objects:   $wgLang, $wgDateFormatter, $wgLinkCache, $wgCurParser
  18 #
  19 # NOT $wgArticle, $wgUser or $wgTitle. Keep them away!
  20 #
  21 #    settings:  $wgUseTex*, $wgUseCategoryMagic*, $wgUseDynamicDates*, $wgInterwikiMagic*,
  22 #               $wgNamespacesWithSubpages, $wgLanguageCode, $wgAllowExternalImages*,
  23 #               $wgLocaltimezone
  24 #
  25 #      * only within ParserOptions
  26 #
  27 #
  28 #----------------------------------------
  29 #    Variable substitution O(N^2) attack
  30 #-----------------------------------------
  31 # Without countermeasures, it would be possible to attack the parser by saving a page
  32 # filled with a large number of inclusions of large pages. The size of the generated
  33 # page would be proportional to the square of the input size. Hence, we limit the number
  34 # of inclusions of any given page, thus bringing any attack back to O(N).
  35 #
  36 define( "MAX_INCLUDE_REPEAT", 5 );
  37
  38 # Recursion depth of variable/inclusion evaluation
  39 define( "MAX_INCLUDE_PASSES", 3 );
  40
  41 # Allowed values for $mOutputType
  42 define( "OT_HTML", 1 );
  43 define( "OT_WIKI", 2 );
  44 define( "OT_MSG", 3 );
  45
  46 # prefix for escaping, used in two functions at least
  47 define( "UNIQ_PREFIX", "NaodW29");
  48
  49 class Parser
  50 {
  51         # Cleared with clearState():
  52         var $mOutput, $mAutonumber, $mLastSection, $mDTopen, $mStripState = array();
  53         var $mVariables, $mIncludeCount;
  54
  55         # Temporary:
  56         var $mOptions, $mTitle, $mOutputType;
  57
  58         function Parser()
  59         {
  60                 $this->clearState();
  61         }
  62
  63         function clearState()
  64         {
  65                 $this->mOutput = new ParserOutput;
  66                 $this->mAutonumber = 0;
  67                 $this->mLastSection = "";
  68                 $this->mDTopen = false;
  69                 $this->mVariables = false;
  70                 $this->mIncludeCount = array();
  71                 $this->mStripState = array();
  72         }
  73
  74         # First pass--just handle <nowiki> sections, pass the rest off
  75         # to doWikiPass2() which does all the real work.
  76         #
  77         # Returns a ParserOutput
  78         #
  79         function parse( $text, &$title, $options, $linestart = true, $clearState = true )
  80         {
  81                 $fname = "Parser::parse";
  82                 wfProfileIn( $fname );
  83
  84                 if ( $clearState ) {
  85                         $this->clearState();
  86                 }
  87
  88                 $this->mOptions = $options;
  89                 $this->mTitle =& $title;
  90                 $this->mOutputType = OT_HTML;
  91
  92                 $stripState = NULL;
  93                 $text = $this->strip( $text, $this->mStripState );
  94                 $text = $this->doWikiPass2( $text, $linestart );
  95                 $text = $this->unstrip( $text, $this->mStripState );
  96
  97                 $this->mOutput->setText( $text );
  98                 wfProfileOut( $fname );
  99                 return $this->mOutput;
 100         }
 101
 102         /* static */ function getRandomString()
 103         {
 104                 return dechex(mt_rand(0, 0x7fffffff)) . dechex(mt_rand(0, 0x7fffffff));
 105         }
 106
 107         # Replaces all occurences of <$tag>content</$tag> in the text
 108         # with a random marker and returns the new text. the output parameter
 109         # $content will be an associative array filled with data on the form
 110         # $unique_marker => content.
 111
 112         /* static */ function extractTags($tag, $text, &$content, $uniq_prefix = ""){
 113                 $result = array();
 114                 $rnd = $uniq_prefix . '-' . $tag . Parser::getRandomString();
 115                 $content = array( );
 116                 $n = 1;
 117                 $stripped = "";
 118
 119                 while ( "" != $text ) {
 120                         $p = preg_split( "/<\\s*$tag\\s*>/i", $text, 2 );
 121                         $stripped .= $p[0];
 122                         if ( ( count( $p ) < 2 ) || ( "" == $p[1] ) ) {
 123                                 $text = "";
 124                         } else {
 125                                 $q = preg_split( "/<\\/\\s*$tag\\s*>/i", $p[1], 2 );
 126                                 $marker = $rnd . sprintf("%08X", $n++);
 127                                 $content[$marker] = $q[0];
 128                                 $stripped .= $marker;
 129                                 $text = $q[1];
 130                         }
 131                 }
 132                 return $stripped;
 133         }
 134
 135         # Strips <nowiki>, <pre> and <math>
 136         # Returns the text, and fills an array with data needed in unstrip()
 137         #
 138         function strip( $text, &$state )
 139         {
 140                 $render = ($this->mOutputType == OT_HTML);
 141                 $nowiki_content = array();
 142                 $hiero_content = array();
 143                 $math_content = array();
 144                 $pre_content = array();
 145
 146                 # Replace any instances of the placeholders
 147                 $uniq_prefix = UNIQ_PREFIX;
 148                 $text = str_replace( $uniq_prefix, wfHtmlEscapeFirst( $uniq_prefix ), $text );
 149
 150                 $text = Parser::extractTags("nowiki", $text, $nowiki_content, $uniq_prefix);
 151                 foreach( $nowiki_content as $marker => $content ){
 152                         if( $render ){
 153                                 $nowiki_content[$marker] = wfEscapeHTMLTagsOnly( $content );
 154                         } else {
 155                                 $nowiki_content[$marker] = "<nowiki>$content</nowiki>";
 156                         }
 157                 }
 158
 159                 if( $GLOBALS['wgUseWikiHiero'] ){
 160                         $text = Parser::extractTags("hiero", $text, $hiero_content, $uniq_prefix);
 161                         foreach( $hiero_content as $marker => $content ){
 162                                 if( $render ){
 163                                         $hiero_content[$marker] = WikiHiero( $content, WH_MODE_HTML);
 164                                 } else {
 165                                         $hiero_content[$marker] = "<hiero>$content</hiero>";
 166                                 }
 167                         }
 168                 }
 169
 170                 if( $this->mOptions->getUseTeX() ){
 171                         $text = Parser::extractTags("math", $text, $math_content, $uniq_prefix);
 172                         foreach( $math_content as $marker => $content ){
 173                                 if( $render ){
 174                                         $math_content[$marker] = renderMath( $content );
 175                                 } else {
 176                                         $math_content[$marker] = "<math>$content</math>";
 177                                 }
 178                         }
 179                 }
 180
 181                 $text = Parser::extractTags("pre", $text, $pre_content, $uniq_prefix);
 182                 foreach( $pre_content as $marker => $content ){
 183                         if( $render ){
 184                                 $pre_content[$marker] = "<pre>" . wfEscapeHTMLTagsOnly( $content ) . "</pre>";
 185                         } else {
 186                                 $pre_content[$marker] = "<pre>$content</pre>";
 187                         }
 188                 }
 189
 190                 # Must expand in reverse order, otherwise nested tags will be corrupted
 191                 $state = array( $pre_content, $math_content, $hiero_content, $nowiki_content );
 192                 return $text;
 193         }
 194
 195         function unstrip( $text, &$state )
 196         {
 197                 foreach( $state as $content_dict ){
 198                         foreach( $content_dict as $marker => $content ){
 199                                 $text = str_replace( $marker, $content, $text );
 200                         }
 201                 }
 202                 return $text;
 203         }
 204
 205         function categoryMagic ()
 206         {
 207                 global $wgLang , $wgUser ;
 208                 if ( !$this->mOptions->getUseCategoryMagic() ) return ;
 209                 $id = $this->mTitle->getArticleID() ;
 210                 $cat = $wgLang->ucfirst ( wfMsg ( "category" ) ) ;
 211                 $ti = $this->mTitle->getText() ;
 212                 $ti = explode ( ":" , $ti , 2 ) ;
 213                 if ( $cat != $ti[0] ) return "" ;
 214                 $r = "<br break='all' />\n" ;
 215
 216                 $articles = array() ;
 217                 $parents = array () ;
 218                 $children = array() ;
 219
 220
 221 #               $sk =& $this->mGetSkin();
 222                 $sk =& $wgUser->getSkin() ;
 223
 224                 $data = array () ;
 225                 $sql1 = "SELECT DISTINCT cur_title,cur_namespace FROM cur,links WHERE l_to={$id} AND l_from=cur_id";
 226                 $sql2 = "SELECT DISTINCT cur_title,cur_namespace FROM cur,brokenlinks WHERE bl_to={$id} AND bl_from=cur_id" ;
 227
 228                 $res = wfQuery ( $sql1, DB_READ ) ;
 229                 while ( $x = wfFetchObject ( $res ) ) $data[] = $x ;
 230
 231                 $res = wfQuery ( $sql2, DB_READ ) ;
 232                 while ( $x = wfFetchObject ( $res ) ) $data[] = $x ;
 233
 234
 235                 foreach ( $data AS $x )
 236                 {
 237                         $t = $wgLang->getNsText ( $x->cur_namespace ) ;
 238                         if ( $t != "" ) $t .= ":" ;
 239                         $t .= $x->cur_title ;
 240
 241                         $y = explode ( ":" , $t , 2 ) ;
 242                         if ( count ( $y ) == 2 && $y[0] == $cat ) {
 243                                 array_push ( $children , $sk->makeLink ( $t , $y[1] ) ) ;
 244                         } else {
 245                                 array_push ( $articles , $sk->makeLink ( $t ) ) ;
 246                         }
 247                 }
 248                 wfFreeResult ( $res ) ;
 249
 250                 # Children
 251                 if ( count ( $children ) > 0 )
 252                 {
 253                         asort ( $children ) ;
 254                         $r .= "<h2>".wfMsg("subcategories")."</h2>\n" ;
 255                         $r .= implode ( ", " , $children ) ;
 256                 }
 257
 258                 # Articles
 259                 if ( count ( $articles ) > 0 )
 260                 {
 261                         asort ( $articles ) ;
 262                         $h =  wfMsg( "category_header", $ti[1] );
 263                         $r .= "<h2>{$h}</h2>\n" ;
 264                         $r .= implode ( ", " , $articles ) ;
 265                 }
 266
 267
 268                 return $r ;
 269         }
 270
 271         function getHTMLattrs ()
 272         {
 273                 $htmlattrs = array( # Allowed attributes--no scripting, etc.
 274                                 "title", "align", "lang", "dir", "width", "height",
 275                                 "bgcolor", "clear", /* BR */ "noshade", /* HR */
 276                                 "cite", /* BLOCKQUOTE, Q */ "size", "face", "color",
 277                                 /* FONT */ "type", "start", "value", "compact",
 278                                 /* For various lists, mostly deprecated but safe */
 279                                 "summary", "width", "border", "frame", "rules",
 280                                 "cellspacing", "cellpadding", "valign", "char",
 281                                 "charoff", "colgroup", "col", "span", "abbr", "axis",
 282                                 "headers", "scope", "rowspan", "colspan", /* Tables */
 283                                 "id", "class", "name", "style" /* For CSS */
 284                                 );
 285                 return $htmlattrs ;
 286         }
 287
 288         function fixTagAttributes ( $t )
 289         {
 290                 if ( trim ( $t ) == "" ) return "" ; # Saves runtime ;-)
 291                 $htmlattrs = $this->getHTMLattrs() ;
 292
 293                 # Strip non-approved attributes from the tag
 294                 $t = preg_replace(
 295                         "/(\\w+)(\\s*=\\s*([^\\s\">]+|\"[^\">]*\"))?/e",
 296                         "(in_array(strtolower(\"\$1\"),\$htmlattrs)?(\"\$1\".((\"x\$3\" != \"x\")?\"=\$3\":'')):'')",
 297                         $t);
 298                 # Strip javascript "expression" from stylesheets. Brute force approach:
 299                 # If anythin offensive is found, all attributes of the HTML tag are dropped
 300
 301                 if( preg_match(
 302                         "/style\\s*=.*(expression|tps*:\/\/|url\\s*\().*/is",
 303                         wfMungeToUtf8( $t ) ) )
 304                 {
 305                         $t="";
 306                 }
 307
 308                 return trim ( $t ) ;
 309         }
 310
 311         function doTableStuff ( $t )
 312         {
 313                 $t = explode ( "\n" , $t ) ;
 314                 $td = array () ; # Is currently a td tag open?
 315                         $ltd = array () ; # Was it TD or TH?
 316                         $tr = array () ; # Is currently a tr tag open?
 317                         $ltr = array () ; # tr attributes
 318                         foreach ( $t AS $k => $x )
 319                         {
 320                                 $x = rtrim ( $x ) ;
 321                                 $fc = substr ( $x , 0 , 1 ) ;
 322                                 if ( "{|" == substr ( $x , 0 , 2 ) )
 323                                 {
 324                                         $t[$k] = "\n<table " . $this->fixTagAttributes ( substr ( $x , 3 ) ) . ">" ;
 325                                         array_push ( $td , false ) ;
 326                                         array_push ( $ltd , "" ) ;
 327                                         array_push ( $tr , false ) ;
 328                                         array_push ( $ltr , "" ) ;
 329                                 }
 330                                 else if ( count ( $td ) == 0 ) { } # Don't do any of the following
 331                                 else if ( "|}" == substr ( $x , 0 , 2 ) )
 332                                 {
 333                                         $z = "</table>\n" ;
 334                                         $l = array_pop ( $ltd ) ;
 335                                         if ( array_pop ( $tr ) ) $z = "</tr>" . $z ;
 336                                         if ( array_pop ( $td ) ) $z = "</{$l}>" . $z ;
 337                                         array_pop ( $ltr ) ;
 338                                         $t[$k] = $z ;
 339                                 }
 340                                 /*      else if ( "|_" == substr ( $x , 0 , 2 ) ) # Caption
 341                                                 {
 342                                                 $z = trim ( substr ( $x , 2 ) ) ;
 343                                                 $t[$k] = "<caption>{$z}</caption>\n" ;
 344                                                 }*/
 345                                 else if ( "|-" == substr ( $x , 0 , 2 ) ) # Allows for |---------------
 346                                 {
 347                                         $x = substr ( $x , 1 ) ;
 348                                         while ( $x != "" && substr ( $x , 0 , 1 ) == '-' ) $x = substr ( $x , 1 ) ;
 349                                         $z = "" ;
 350                                         $l = array_pop ( $ltd ) ;
 351                                         if ( array_pop ( $tr ) ) $z = "</tr>" . $z ;
 352                                         if ( array_pop ( $td ) ) $z = "</{$l}>" . $z ;
 353                                         array_pop ( $ltr ) ;
 354                                         $t[$k] = $z ;
 355                                         array_push ( $tr , false ) ;
 356                                         array_push ( $td , false ) ;
 357                                         array_push ( $ltd , "" ) ;
 358                                         array_push ( $ltr , $this->fixTagAttributes ( $x ) ) ;
 359                                 }
 360                                 else if ( "|" == $fc || "!" == $fc || "|+" == substr ( $x , 0 , 2 ) ) # Caption
 361                                 {
 362                                         if ( "|+" == substr ( $x , 0 , 2 ) )
 363                                         {
 364                                                 $fc = "+" ;
 365                                                 $x = substr ( $x , 1 ) ;
 366                                         }
 367                                         $after = substr ( $x , 1 ) ;
 368                                         if ( $fc == "!" ) $after = str_replace ( "!!" , "||" , $after ) ;
 369                                         $after = explode ( "||" , $after ) ;
 370                                         $t[$k] = "" ;
 371                                         foreach ( $after AS $theline )
 372                                         {
 373                                                 $z = "" ;
 374                                                 if ( $fc != "+" )
 375                                                 {
 376                                                         $tra = array_pop ( $ltr ) ;
 377                                                         if ( !array_pop ( $tr ) ) $z = "<tr {$tra}>\n" ;
 378                                                         array_push ( $tr , true ) ;
 379                                                         array_push ( $ltr , "" ) ;
 380                                                 }
 381
 382                                                 $l = array_pop ( $ltd ) ;
 383                                                 if ( array_pop ( $td ) ) $z = "</{$l}>" . $z ;
 384                                                 if ( $fc == "|" ) $l = "td" ;
 385                                                 else if ( $fc == "!" ) $l = "th" ;
 386                                                 else if ( $fc == "+" ) $l = "caption" ;
 387                                                 else $l = "" ;
 388                                                 array_push ( $ltd , $l ) ;
 389                                                 $y = explode ( "|" , $theline , 2 ) ;
 390                                                 if ( count ( $y ) == 1 ) $y = "{$z}<{$l}>{$y[0]}" ;
 391                                                 else $y = $y = "{$z}<{$l} ".$this->fixTagAttributes($y[0]).">{$y[1]}" ;
 392                                                 $t[$k] .= $y ;
 393                                                 array_push ( $td , true ) ;
 394                                         }
 395                                 }
 396                         }
 397
 398                 # Closing open td, tr && table
 399                 while ( count ( $td ) > 0 )
 400                 {
 401                         if ( array_pop ( $td ) ) $t[] = "</td>" ;
 402                         if ( array_pop ( $tr ) ) $t[] = "</tr>" ;
 403                         $t[] = "</table>" ;
 404                 }
 405
 406                 $t = implode ( "\n" , $t ) ;
 407                 #               $t = $this->removeHTMLtags( $t );
 408                 return $t ;
 409         }
 410
 411         # Well, OK, it's actually about 14 passes.  But since all the
 412         # hard lifting is done inside PHP's regex code, it probably
 413         # wouldn't speed things up much to add a real parser.
 414         #
 415         function doWikiPass2( $text, $linestart )
 416         {
 417                 $fname = "Parser::doWikiPass2";
 418                 wfProfileIn( $fname );
 419
 420                 $text = $this->removeHTMLtags( $text );
 421                 $text = $this->replaceVariables( $text );
 422
 423                 # $text = preg_replace( "/(^|\n)-----*/", "\\1<hr>", $text );
 424
 425                 $text = $this->doHeadings( $text );
 426
 427                 if($this->mOptions->getUseDynamicDates()) {
 428                         global $wgDateFormatter;
 429                         $text = $wgDateFormatter->reformat( $this->mOptions->getDateFormat(), $text );
 430                 }
 431
 432                 $text = $this->replaceExternalLinks( $text );
 433                 $text = $this->doBlockLevels( $text, $linestart );
 434                 $text = $this->doTokenizedParser ( $text );
 435                 $text = $this->doTableStuff ( $text ) ;
 436
 437                 $text = $this->formatHeadings( $text );
 438
 439                 $sk =& $this->mOptions->getSkin();
 440                 $text = $sk->transformContent( $text );
 441                 $fixtags = array(
 442                         "/<hr *>/i" => '<hr/>',
 443                         "/<br *>/i" => '<br/>',
 444                         "/<center *>/i"=>'<span style="text-align:center;">',
 445                         "/<\\/center *>/i" => '</span>'
 446                 );
 447                 $text = preg_replace( array_keys($fixtags), array_values($fixtags), $text );
 448
 449                 $text .= $this->categoryMagic () ;
 450
 451                 wfProfileOut( $fname );
 452                 return $text;
 453         }
 454
 455
 456         /* private */ function doHeadings( $text )
 457         {
 458                 for ( $i = 6; $i >= 1; --$i ) {
 459                         $h = substr( "======", 0, $i );
 460                         $text = preg_replace( "/^{$h}(.+){$h}(\\s|$)/m",
 461                           "<h{$i}>\\1</h{$i}>\\2", $text );
 462                 }
 463                 return $text;
 464         }
 465
 466         # Note: we have to do external links before the internal ones,
 467         # and otherwise take great care in the order of things here, so
 468         # that we don't end up interpreting some URLs twice.
 469
 470         /* private */ function replaceExternalLinks( $text )
 471         {
 472                 $fname = "Parser::replaceExternalLinks";
 473                 wfProfileIn( $fname );
 474                 $text = $this->subReplaceExternalLinks( $text, "http", true );
 475                 $text = $this->subReplaceExternalLinks( $text, "https", true );
 476                 $text = $this->subReplaceExternalLinks( $text, "ftp", false );
 477                 $text = $this->subReplaceExternalLinks( $text, "irc", false );
 478                 $text = $this->subReplaceExternalLinks( $text, "gopher", false );
 479                 $text = $this->subReplaceExternalLinks( $text, "news", false );
 480                 $text = $this->subReplaceExternalLinks( $text, "mailto", false );
 481                 wfProfileOut( $fname );
 482                 return $text;
 483         }
 484
 485         /* private */ function subReplaceExternalLinks( $s, $protocol, $autonumber )
 486         {
 487                 $unique = "4jzAfzB8hNvf4sqyO9Edd8pSmk9rE2in0Tgw3";
 488                 $uc = "A-Za-z0-9_\\/~%\\-+&*#?!=()@\\x80-\\xFF";
 489
 490                 # this is  the list of separators that should be ignored if they
 491                 # are the last character of an URL but that should be included
 492                 # if they occur within the URL, e.g. "go to www.foo.com, where .."
 493                 # in this case, the last comma should not become part of the URL,
 494                 # but in "www.foo.com/123,2342,32.htm" it should.
 495                 $sep = ",;\.:";
 496                 $fnc = "A-Za-z0-9_.,~%\\-+&;#*?!=()@\\x80-\\xFF";
 497                 $images = "gif|png|jpg|jpeg";
 498
 499                 # PLEASE NOTE: The curly braces { } are not part of the regex,
 500                 # they are interpreted as part of the string (used to tell PHP
 501                 # that the content of the string should be inserted there).
 502                 $e1 = "/(^|[^\\[])({$protocol}:)([{$uc}{$sep}]+)\\/([{$fnc}]+)\\." .
 503                   "((?i){$images})([^{$uc}]|$)/";
 504
 505                 $e2 = "/(^|[^\\[])({$protocol}:)(([".$uc."]|[".$sep."][".$uc."])+)([^". $uc . $sep. "]|[".$sep."]|$)/";
 506                 $sk =& $this->mOptions->getSkin();
 507
 508                 if ( $autonumber and $this->mOptions->getAllowExternalImages() ) { # Use img tags only for HTTP urls
 509                         $s = preg_replace( $e1, "\\1" . $sk->makeImage( "{$unique}:\\3" .
 510                           "/\\4.\\5", "\\4.\\5" ) . "\\6", $s );
 511                 }
 512                 $s = preg_replace( $e2, "\\1" . "<a href=\"{$unique}:\\3\"" .
 513                   $sk->getExternalLinkAttributes( "{$unique}:\\3", wfEscapeHTML(
 514                   "{$unique}:\\3" ) ) . ">" . wfEscapeHTML( "{$unique}:\\3" ) .
 515                   "</a>\\5", $s );
 516                 $s = str_replace( $unique, $protocol, $s );
 517
 518                 $a = explode( "[{$protocol}:", " " . $s );
 519                 $s = array_shift( $a );
 520                 $s = substr( $s, 1 );
 521
 522                 $e1 = "/^([{$uc}"."{$sep}]+)](.*)\$/sD";
 523                 $e2 = "/^([{$uc}"."{$sep}]+)\\s+([^\\]]+)](.*)\$/sD";
 524
 525                 foreach ( $a as $line ) {
 526                         if ( preg_match( $e1, $line, $m ) ) {
 527                                 $link = "{$protocol}:{$m[1]}";
 528                                 $trail = $m[2];
 529                                 if ( $autonumber ) { $text = "[" . ++$this->mAutonumber . "]"; }
 530                                 else { $text = wfEscapeHTML( $link ); }
 531                         } else if ( preg_match( $e2, $line, $m ) ) {
 532                                 $link = "{$protocol}:{$m[1]}";
 533                                 $text = $m[2];
 534                                 $trail = $m[3];
 535                         } else {
 536                                 $s .= "[{$protocol}:" . $line;
 537                                 continue;
 538                         }
 539                         if( $link == $text || preg_match( "!$protocol://" . preg_quote( $text, "/" ) . "/?$!", $link ) ) {
 540                                 $paren = "";
 541                         } else {
 542                                 # Expand the URL for printable version
 543                                 $paren = "<span class='urlexpansion'> (<i>" . htmlspecialchars ( $link ) . "</i>)</span>";
 544                         }
 545                         $la = $sk->getExternalLinkAttributes( $link, $text );
 546                         $s .= "<a href='{$link}'{$la}>{$text}</a>{$paren}{$trail}";
 547
 548                 }
 549                 return $s;
 550         }
 551
 552         /* private */ function handle3Quotes( &$state, $token )
 553         {
 554                 if ( $state["strong"] !== false ) {
 555                         if ( $state["em"] !== false && $state["em"] > $state["strong"] )
 556                         {
 557                                 # ''' lala ''lala '''
 558                                 $s = "</em></strong><em>";
 559                         } else {
 560                                 $s = "</strong>";
 561                         }
 562                         $state["strong"] = FALSE;
 563                 } else {
 564                         $s = "<strong>";
 565                         $state["strong"] = $token["pos"];
 566                 }
 567                 return $s;
 568         }
 569
 570         /* private */ function handle2Quotes( &$state, $token )
 571         {
 572                 if ( $state["em"] !== false ) {
 573                         if ( $state["strong"] !== false && $state["strong"] > $state["em"] )
 574                         {
 575                                 # ''lala'''lala'' ....'''
 576                                 $s = "</strong></em><strong>";
 577                         } else {
 578                                 $s = "</em>";
 579                         }
 580                         $state["em"] = FALSE;
 581                 } else {
 582                         $s = "<em>";
 583                         $state["em"] = $token["pos"];
 584                 }
 585                 return $s;
 586         }
 587
 588         /* private */ function handle5Quotes( &$state, $token )
 589         {
 590                 $s = "";
 591                 if ( $state["em"] !== false && $state["strong"] ) {
 592                         if ( $state["em"] < $state["strong"] ) {
 593                                 $s .= "</strong></em>";
 594                         } else {
 595                                 $s .= "</em></strong>";
 596                         }
 597                         $state["strong"] = $state["em"] = FALSE;
 598                 } elseif ( $state["em"] !== false ) {
 599                         $s .= "</em><strong>";
 600                         $state["em"] = FALSE;
 601                         $state["strong"] = $token["pos"];
 602                 } elseif ( $state["strong"] !== false ) {
 603                         $s .= "</strong><em>";
 604                         $state["strong"] = FALSE;
 605                         $state["em"] = $token["pos"];
 606                 } else { # not $em and not $strong
 607                         $s .= "<strong><em>";
 608                         $state["strong"] = $state["em"] = $token["pos"];
 609                 }
 610                 return $s;
 611         }
 612
 613         /* private */ function doTokenizedParser( $str )
 614         {
 615                 global $wgLang; # for language specific parser hook
 616
 617                 $tokenizer=Tokenizer::newFromString( $str );
 618                 $tokenStack = array();
 619
 620                 $s="";
 621                 $state["em"]      = FALSE;
 622                 $state["strong"]  = FALSE;
 623                 $tagIsOpen = FALSE;
 624                 $threeopen = false;
 625
 626                 # The tokenizer splits the text into tokens and returns them one by one.
 627                 # Every call to the tokenizer returns a new token.
 628                 while ( $token = $tokenizer->nextToken() )
 629                 {
 630                         switch ( $token["type"] )
 631                         {
 632                                 case "text":
 633                                         # simple text with no further markup
 634                                         $txt = $token["text"];
 635                                         break;
 636                                 case "[[[":
 637                                         # remember the tag opened with 3 [
 638                                         $threeopen = true;
 639                                 case "[[":
 640                                         # link opening tag.
 641                                         # FIXME : Treat orphaned open tags (stack not empty when text is over)
 642                                         $tagIsOpen = TRUE;
 643                                         array_push( $tokenStack, $token );
 644                                         $txt="";
 645                                         break;
 646
 647                                 case "]]]":
 648                                 case "]]":
 649                                         # link close tag.
 650                                         # get text from stack, glue it together, and call the code to handle a
 651                                         # link
 652
 653                                         if ( count( $tokenStack ) == 0 )
 654                                         {
 655                                                 # stack empty. Found a ]] without an opening [[
 656                                                 $txt = "]]";
 657                                         } else {
 658                                                 $linkText = "";
 659                                                 $lastToken = array_pop( $tokenStack );
 660                                                 while ( !(($lastToken["type"] == "[[[") or ($lastToken["type"] == "[[")) )
 661                                                 {
 662                                                         if( !empty( $lastToken["text"] ) ) {
 663                                                                 $linkText = $lastToken["text"] . $linkText;
 664                                                         }
 665                                                         $lastToken = array_pop( $tokenStack );
 666                                                 }
 667
 668                                                 $txt = $linkText ."]]";
 669
 670                                                 if( isset( $lastToken["text"] ) ) {
 671                                                         $prefix = $lastToken["text"];
 672                                                 } else {
 673                                                         $prefix = "";
 674                                                 }
 675                                                 $nextToken = $tokenizer->previewToken();
 676                                                 if ( $nextToken["type"] == "text" )
 677                                                 {
 678                                                         # Preview just looks at it. Now we have to fetch it.
 679                                                         $nextToken = $tokenizer->nextToken();
 680                                                         $txt .= $nextToken["text"];
 681                                                 }
 682                                                 $fakestate = $this->mStripState;
 683                                                 $txt = $this->handleInternalLink( $this->unstrip($txt,$fakestate), $prefix );
 684
 685                                                 # did the tag start with 3 [ ?
 686                                                 if($threeopen) {
 687                                                         # show the first as text
 688                                                         $txt = "[".$txt;
 689                                                         $threeopen=false;
 690                                                 }
 691
 692                                         }
 693                                         $tagIsOpen = (count( $tokenStack ) != 0);
 694                                         break;
 695                                 case "----":
 696                                         $txt = "\n<hr />\n";
 697                                         break;
 698                                 case "'''":
 699                                         # This and the three next ones handle quotes
 700                                         $txt = $this->handle3Quotes( $state, $token );
 701                                         break;
 702                                 case "''":
 703                                         $txt = $this->handle2Quotes( $state, $token );
 704                                         break;
 705                                 case "'''''":
 706                                         $txt = $this->handle5Quotes( $state, $token );
 707                                         break;
 708                                 case "":
 709                                         # empty token
 710                                         $txt="";
 711                                         break;
 712                                 case "RFC ":
 713                                         if ( $tagIsOpen ) {
 714                                                 $txt = "RFC ";
 715                                         } else {
 716                                                 $txt = $this->doMagicRFC( $tokenizer );
 717                                         }
 718                                         break;
 719                                 case "ISBN ":
 720                                         if ( $tagIsOpen ) {
 721                                                 $txt = "ISBN ";
 722                                         } else {
 723                                                 $txt = $this->doMagicISBN( $tokenizer );
 724                                         }
 725                                         break;
 726                                 default:
 727                                         # Call language specific Hook.
 728                                         $txt = $wgLang->processToken( $token, $tokenStack );
 729                                         if ( NULL == $txt ) {
 730                                                 # An unkown token. Highlight.
 731                                                 $txt = "<font color=\"#FF0000\"><b>".$token["type"]."</b></font>";
 732                                                 $txt .= "<font color=\"#FFFF00\"><b>".$token["text"]."</b></font>";
 733                                         }
 734                                         break;
 735                         }
 736                         # If we're parsing the interior of a link, don't append the interior to $s,
 737                         # but push it to the stack so it can be processed when a ]] token is found.
 738                         if ( $tagIsOpen  && $txt != "" ) {
 739                                 $token["type"] = "text";
 740                                 $token["text"] = $txt;
 741                                 array_push( $tokenStack, $token );
 742                         } else {
 743                                 $s .= $txt;
 744                         }
 745                 } #end while
 746                 if ( count( $tokenStack ) != 0 )
 747                 {
 748                         # still objects on stack. opened [[ tag without closing ]] tag.
 749                         $txt = "";
 750                         while ( $lastToken = array_pop( $tokenStack ) )
 751                         {
 752                                 if ( $lastToken["type"] == "text" )
 753                                 {
 754                                         $txt = $lastToken["text"] . $txt;
 755                                 } else {
 756                                         $txt = $lastToken["type"] . $txt;
 757                                 }
 758                         }
 759                         $s .= $txt;
 760                 }
 761                 return $s;
 762         }
 763
 764         /* private */ function handleInternalLink( $line, $prefix )
 765         {
 766                 global $wgLang, $wgLinkCache;
 767                 global $wgNamespacesWithSubpages, $wgLanguageCode;
 768                 static $fname = "Parser::handleInternalLink" ;
 769                 wfProfileIn( $fname );
 770
 771                 wfProfileIn( "$fname-setup" );
 772                 static $tc = FALSE;
 773                 if ( !$tc ) { $tc = Title::legalChars() . "#"; }
 774                 $sk =& $this->mOptions->getSkin();
 775
 776                 # Match a link having the form [[namespace:link|alternate]]trail
 777                 static $e1 = FALSE;
 778                 if ( !$e1 ) { $e1 = "/^([{$tc}]+)(?:\\|([^]]+))?]](.*)\$/sD"; }
 779                 # Match the end of a line for a word that's not followed by whitespace,
 780                 # e.g. in the case of 'The Arab al[[Razi]]', 'al' will be matched
 781                 #$e2 = "/^(.*)\\b(\\w+)\$/suD";
 782                 #$e2 = "/^(.*\\s)(\\S+)\$/suD";
 783                 static $e2 = '/^(.*\s)([a-zA-Z\x80-\xff]+)$/sD';
 784
 785
 786                 # Special and Media are pseudo-namespaces; no pages actually exist in them
 787                 static $image = FALSE;
 788                 static $special = FALSE;
 789                 static $media = FALSE;
 790                 static $category = FALSE;
 791                 if ( !$image ) { $image = Namespace::getImage(); }
 792                 if ( !$special ) { $special = Namespace::getSpecial(); }
 793                 if ( !$media ) { $media = Namespace::getMedia(); }
 794                 if ( !$category ) { $category = wfMsg ( "category" ) ; }
 795
 796                 $nottalk = !Namespace::isTalk( $this->mTitle->getNamespace() );
 797
 798                 wfProfileOut( "$fname-setup" );
 799                 $s = "";
 800
 801                 if ( preg_match( $e1, $line, $m ) ) { # page with normal text or alt
 802                         $text = $m[2];
 803                         $trail = $m[3];
 804                 } else { # Invalid form; output directly
 805                         $s .= $prefix . "[[" . $line ;
 806                         return $s;
 807                 }
 808
 809                 /* Valid link forms:
 810                 Foobar -- normal
 811                 :Foobar -- override special treatment of prefix (images, language links)
 812                 /Foobar -- convert to CurrentPage/Foobar
 813                 /Foobar/ -- convert to CurrentPage/Foobar, strip the initial / from text
 814                 */
 815                 $c = substr($m[1],0,1);
 816                 $noforce = ($c != ":");
 817                 if( $c == "/" ) { # subpage
 818                         if(substr($m[1],-1,1)=="/") {                 # / at end means we don't want the slash to be shown
 819                                 $m[1]=substr($m[1],1,strlen($m[1])-2);
 820                                 $noslash=$m[1];
 821                         } else {
 822                                 $noslash=substr($m[1],1);
 823                         }
 824                         if($wgNamespacesWithSubpages[$this->mTitle->getNamespace()]) { # subpages allowed here
 825                                 $link = $this->mTitle->getPrefixedText(). "/" . trim($noslash);
 826                                 if( "" == $text ) {
 827                                         $text= $m[1];
 828                                 } # this might be changed for ugliness reasons
 829                         } else {
 830                                 $link = $noslash; # no subpage allowed, use standard link
 831                         }
 832                 } elseif( $noforce ) { # no subpage
 833                         $link = $m[1];
 834                 } else {
 835                         $link = substr( $m[1], 1 );
 836                 }
 837                 if( "" == $text )
 838                         $text = $link;
 839
 840                 $nt = Title::newFromText( $link );
 841                 if( !$nt ) {
 842                         $s .= $prefix . "[[" . $line;
 843                         return $s;
 844                 }
 845                 $ns = $nt->getNamespace();
 846                 $iw = $nt->getInterWiki();
 847                 if( $noforce ) {
 848                         if( $iw && $this->mOptions->getInterwikiMagic() && $nottalk && $wgLang->getLanguageName( $iw ) ) {
 849                                 array_push( $this->mOutput->mLanguageLinks, $nt->getPrefixedText() );
 850                                 return (trim($s) == '')? '': $s;
 851                         }
 852                         if( $ns == $image ) {
 853                                 $s .= $prefix . $sk->makeImageLinkObj( $nt, $text ) . $trail;
 854                                 $wgLinkCache->addImageLinkObj( $nt );
 855                                 return $s;
 856                         }
 857                 }
 858                 if( ( $nt->getPrefixedText() == $this->mTitle->getPrefixedText() ) &&
 859                     ( strpos( $link, "#" ) == FALSE ) ) {
 860                         $s .= $prefix . "<strong>" . $text . "</strong>" . $trail;
 861                         return $s;
 862                 }
 863
 864                 # Category feature
 865                 $catns = strtoupper ( $nt->getDBkey () ) ;
 866                 $catns = explode ( ":" , $catns ) ;
 867                 if ( count ( $catns ) > 1 ) $catns = array_shift ( $catns ) ;
 868                 else $catns = "" ;
 869                 if ( $catns == strtoupper($category) && $this->mOptions->getUseCategoryMagic() ) {
 870                         $t = explode ( ":" , $nt->getText() ) ;
 871                         array_shift ( $t ) ;
 872                         $t = implode ( ":" , $t ) ;
 873                         $t = $wgLang->ucFirst ( $t ) ;
 874                         $nnt = Title::newFromText ( $category.":".$t ) ;
 875                         $t = $sk->makeLinkObj( $nnt, $t, "", $trail , $prefix );
 876                         $this->mOutput->mCategoryLinks[] = $t ;
 877                         $s .= $prefix . $trail ;
 878                         return $s ;
 879                 }
 880
 881                 if( $ns == $media ) {
 882                         $s .= $prefix . $sk->makeMediaLinkObj( $nt, $text ) . $trail;
 883                         $wgLinkCache->addImageLinkObj( $nt );
 884                         return $s;
 885                 } elseif( $ns == $special ) {
 886                         $s .= $prefix . $sk->makeKnownLinkObj( $nt, $text, "", $trail );
 887                         return $s;
 888                 }
 889                 $s .= $sk->makeLinkObj( $nt, $text, "", $trail , $prefix );
 890
 891                 wfProfileOut( $fname );
 892                 return $s;
 893         }
 894
 895         # Some functions here used by doBlockLevels()
 896         #
 897         /* private */ function closeParagraph()
 898         {
 899                 $result = "";
 900                 if ( '' != $this->mLastSection ) {
 901                         $result = "</" . $this->mLastSection  . ">";
 902                 }
 903                 $this->mLastSection = "";
 904                 return $result."\n";
 905         }
 906         # getCommon() returns the length of the longest common substring
 907         # of both arguments, starting at the beginning of both.
 908         #
 909         /* private */ function getCommon( $st1, $st2 )
 910         {
 911                 $fl = strlen( $st1 );
 912                 $shorter = strlen( $st2 );
 913                 if ( $fl < $shorter ) { $shorter = $fl; }
 914
 915                 for ( $i = 0; $i < $shorter; ++$i ) {
 916                         if ( $st1{$i} != $st2{$i} ) { break; }
 917                 }
 918                 return $i;
 919         }
 920         # These next three functions open, continue, and close the list
 921         # element appropriate to the prefix character passed into them.
 922         #
 923         /* private */ function openList( $char )
 924     {
 925                 $result = $this->closeParagraph();
 926
 927                 if ( "*" == $char ) { $result .= "<ul><li>"; }
 928                 else if ( "#" == $char ) { $result .= "<ol><li>"; }
 929                 else if ( ":" == $char ) { $result .= "<dl><dd>"; }
 930                 else if ( ";" == $char ) {
 931                         $result .= "<dl><dt>";
 932                         $this->mDTopen = true;
 933                 }
 934                 else { $result = "<!-- ERR 1 -->"; }
 935
 936                 return $result;
 937         }
 938
 939         /* private */ function nextItem( $char )
 940         {
 941                 if ( "*" == $char || "#" == $char ) { return "</li><li>"; }
 942                 else if ( ":" == $char || ";" == $char ) {
 943                         $close = "</dd>";
 944                         if ( $this->mDTopen ) { $close = "</dt>"; }
 945                         if ( ";" == $char ) {
 946                                 $this->mDTopen = true;
 947                                 return $close . "<dt>";
 948                         } else {
 949                                 $this->mDTopen = false;
 950                                 return $close . "<dd>";
 951                         }
 952                 }
 953                 return "<!-- ERR 2 -->";
 954         }
 955
 956         /* private */function closeList( $char )
 957         {
 958                 if ( "*" == $char ) { $text = "</li></ul>"; }
 959                 else if ( "#" == $char ) { $text = "</li></ol>"; }
 960                 else if ( ":" == $char ) {
 961                         if ( $this->mDTopen ) {
 962                                 $this->mDTopen = false;
 963                                 $text = "</dt></dl>";
 964                         } else {
 965                                 $text = "</dd></dl>";
 966                         }
 967                 }
 968                 else {  return "<!-- ERR 3 -->"; }
 969                 return $text."\n";
 970         }
 971
 972         /* private */ function doBlockLevels( $text, $linestart )
 973         {
 974                 $fname = "Parser::doBlockLevels";
 975                 wfProfileIn( $fname );
 976                 # Parsing through the text line by line.  The main thing
 977                 # happening here is handling of block-level elements p, pre,
 978                 # and making lists from lines starting with * # : etc.
 979                 #
 980                 $a = explode( "\n", $text );
 981                 $lastPref = $text = '';
 982                 $this->mDTopen = $inBlockElem = false;
 983
 984                 if ( ! $linestart ) { $text .= array_shift( $a ); }
 985                 foreach ( $a as $t ) {
 986                         if ( "" != $text ) { $text .= "\n"; }
 987
 988                         $oLine = $t;
 989                         $opl = strlen( $lastPref );
 990                         $npl = strspn( $t, "*#:;" );
 991                         $pref = substr( $t, 0, $npl );
 992                         $pref2 = str_replace( ";", ":", $pref );
 993                         $t = substr( $t, $npl );
 994
 995                         if ( 0 != $npl && 0 == strcmp( $lastPref, $pref2 ) ) {
 996                                 $text .= $this->nextItem( substr( $pref, -1 ) );
 997
 998                                 if ( ";" == substr( $pref, -1 ) ) {
 999                                         $cpos = strpos( $t, ":" );
1000                                         if ( ! ( false === $cpos ) ) {
1001                                                 $term = substr( $t, 0, $cpos );
1002                                                 $text .= $term . $this->nextItem( ":" );
1003                                                 $t = substr( $t, $cpos + 1 );
1004                                         }
1005                                 }
1006                         } else if (0 != $npl || 0 != $opl) {
1007                                 $cpl = $this->getCommon( $pref, $lastPref );
1008
1009                                 while ( $cpl < $opl ) {
1010                                         $text .= $this->closeList( $lastPref{$opl-1} );
1011                                         --$opl;
1012                                 }
1013                                 if ( $npl <= $cpl && $cpl > 0 ) {
1014                                         $text .= $this->nextItem( $pref{$cpl-1} );
1015                                 }
1016                                 while ( $npl > $cpl ) {
1017                                         $char = substr( $pref, $cpl, 1 );
1018                                         $text .= $this->openList( $char );
1019
1020                                         if ( ";" == $char ) {
1021                                                 $cpos = strpos( $t, ":" );
1022                                                 if ( ! ( false === $cpos ) ) {
1023                                                         $term = substr( $t, 0, $cpos );
1024                                                         $text .= $term . $this->nextItem( ":" );
1025                                                         $t = substr( $t, $cpos + 1 );
1026                                                 }
1027                                         }
1028                                         ++$cpl;
1029                                 }
1030                                 $lastPref = $pref2;
1031                         }
1032                         if ( 0 == $npl ) { # No prefix--go to paragraph mode
1033                                 $uniq_prefix = UNIQ_PREFIX;
1034                                 if ( preg_match(
1035                                   "/(<table|<blockquote|<h1|<h2|<h3|<h4|<h5|<h6|<div)/i", $t ) ) {
1036                                         $text .= $this->closeParagraph();
1037                                         $inBlockElem = true;
1038                                 } else if ( preg_match("/(<hr|<\\/td|".$uniq_prefix."-pre)/i", $t ) ) {
1039                                         $text .= $this->closeParagraph();
1040                                         $inBlockElem = false;
1041                                 }
1042                                 if ( ! $inBlockElem ) {
1043                                         if ( " " == $t{0} ) {
1044                                                 $newSection = "pre";
1045                                                 $text .= $this->closeParagraph();
1046                                                 # $t = wfEscapeHTML( $t );
1047                                         }
1048                                         else { $newSection = "p"; }
1049
1050                                         if ( ( '' == trim( $oLine ) ) ||  ( $this->mLastSection == $newSection and $newSection != 'p' )) {
1051                                                 $text .= $this->closeParagraph();
1052                                                 $text .= "<" . $newSection . ">";
1053                                                 $this->mLastSection = $newSection;
1054                                         }
1055                                 }
1056                                 if ( $inBlockElem &&
1057                                   preg_match( "/(<\\/table|<\\/blockquote|<\\/h1|<\\/h2|<\\/h3|<\\/h4|<\\/h5|<\\/h6|<\\/p<\\/div)/i", $t ) ) {
1058                                         $inBlockElem = false;
1059                                 }
1060                         }
1061                         $text .= $t;
1062                 }
1063                 while ( $npl ) {
1064                         $text .= $this->closeList( $pref2{$npl-1} );
1065                         --$npl;
1066                 }
1067                 if ( "" != $this->mLastSection ) {
1068                         $text .= "</" . $this->mLastSection . ">";
1069                         $this->mLastSection = "";
1070                 }
1071                 wfProfileOut( $fname );
1072                 return $text;
1073         }
1074
1075         function getVariableValue( $index ) {
1076                 global $wgLang, $wgSitename, $wgServer;
1077
1078                 switch ( $index ) {
1079                         case MAG_CURRENTMONTH:
1080                                 return date( "m" );
1081                         case MAG_CURRENTMONTHNAME:
1082                                 return $wgLang->getMonthName( date("n") );
1083                         case MAG_CURRENTMONTHNAMEGEN:
1084                                 return $wgLang->getMonthNameGen( date("n") );
1085                         case MAG_CURRENTDAY:
1086                                 return date("j");
1087                         case MAG_CURRENTDAYNAME:
1088                                 return $wgLang->getWeekdayName( date("w")+1 );
1089                         case MAG_CURRENTYEAR:
1090                                 return date( "Y" );
1091                         case MAG_CURRENTTIME:
1092                                 return $wgLang->time( wfTimestampNow(), false );
1093                         case MAG_NUMBEROFARTICLES:
1094                                 return wfNumberOfArticles();
1095                         case MAG_SITENAME:
1096                                 return $wgSitename;
1097                         case MAG_SERVER:
1098                                 return $wgServer;
1099                         default:
1100                                 return NULL;
1101                 }
1102         }
1103
1104         function initialiseVariables()
1105         {
1106                 global $wgVariableIDs;
1107                 $this->mVariables = array();
1108                 foreach ( $wgVariableIDs as $id ) {
1109                         $mw =& MagicWord::get( $id );
1110                         $mw->addToArray( $this->mVariables, $this->getVariableValue( $id ) );
1111                 }
1112         }
1113
1114         /* private */ function replaceVariables( $text )
1115         {
1116                 global $wgLang, $wgCurParser;
1117                 global $wgScript, $wgArticlePath;
1118
1119                 $fname = "Parser::replaceVariables";
1120                 wfProfileIn( $fname );
1121
1122                 $bail = false;
1123                 if ( !$this->mVariables ) {
1124                         $this->initialiseVariables();
1125                 }
1126                 $titleChars = Title::legalChars();
1127                 $regex = "/{{([$titleChars\\|]*?)}}/s";
1128
1129                 # "Recursive" variable expansion: run it through a couple of passes
1130                 for ( $i=0; $i<MAX_INCLUDE_REPEAT && !$bail; $i++ ) {
1131                         $oldText = $text;
1132
1133                         # It's impossible to rebind a global in PHP
1134                         # Instead, we run the substitution on a copy, then merge the changed fields back in
1135                         $wgCurParser = $this->fork();
1136
1137                         $text = preg_replace_callback( $regex, "wfBraceSubstitution", $text );
1138                         if ( $oldText == $text ) {
1139                                 $bail = true;
1140                         }
1141                         $this->merge( $wgCurParser );
1142                 }
1143
1144                 return $text;
1145         }
1146
1147         # Returns a copy of this object except with various variables cleared
1148         # This copy can be re-merged with the parent after operations on the copy
1149         function fork()
1150         {
1151                 $copy = $this;
1152                 $copy->mOutput = new ParserOutput;
1153                 return $copy;
1154         }
1155
1156         # Merges a copy split off with fork()
1157         function merge( &$copy )
1158         {
1159                 $this->mOutput->merge( $copy->mOutput );
1160
1161                 # Merge include throttling arrays
1162                 foreach( $copy->mIncludeCount as $dbk => $count ) {
1163                         if ( array_key_exists( $dbk, $this->mIncludeCount ) ) {
1164                                 $this->mIncludeCount[$dbk] += $count;
1165                         } else {
1166                                 $this->mIncludeCount[$dbk] = $count;
1167                         }
1168                 }
1169         }
1170
1171         function braceSubstitution( $matches )
1172         {
1173                 global $wgLinkCache, $wgLang;
1174                 $fname = "Parser::braceSubstitution";
1175                 $found = false;
1176                 $nowiki = false;
1177
1178                 $text = $matches[1];
1179
1180                 # SUBST
1181                 $mwSubst =& MagicWord::get( MAG_SUBST );
1182                 if ( $mwSubst->matchStartAndRemove( $text ) ) {
1183                         if ( $this->mOutputType != OT_WIKI ) {
1184                                 # Invalid SUBST not replaced at PST time
1185                                 # Return without further processing
1186                                 $text = $matches[0];
1187                                 $found = true;
1188                         }
1189                 } elseif ( $this->mOutputType == OT_WIKI ) {
1190                         # SUBST not found in PST pass, do nothing
1191                         $text = $matches[0];
1192                         $found = true;
1193                 }
1194
1195                 # MSG, MSGNW and INT
1196                 if ( !$found ) {
1197                         # Check for MSGNW:
1198                         $mwMsgnw =& MagicWord::get( MAG_MSGNW );
1199                         if ( $mwMsgnw->matchStartAndRemove( $text ) ) {
1200                                 $nowiki = true;
1201                         } else {
1202                                 # Remove obsolete MSG:
1203                                 $mwMsg =& MagicWord::get( MAG_MSG );
1204                                 $mwMsg->matchStartAndRemove( $text );
1205                         }
1206
1207                         # Check if it is an internal message
1208                         $mwInt =& MagicWord::get( MAG_INT );
1209                         if ( $mwInt->matchStartAndRemove( $text ) ) {
1210                                 $text = wfMsg( $text );
1211                                 $found = true;
1212                         }
1213                 }
1214
1215                 # NS
1216                 if ( !$found ) {
1217                         # Check for NS: (namespace expansion)
1218                         $mwNs = MagicWord::get( MAG_NS );
1219                         if ( $mwNs->matchStartAndRemove( $text ) ) {
1220                                 if ( intval( $text ) ) {
1221                                         $text = $wgLang->getNsText( intval( $text ) );
1222                                         $found = true;
1223                                 } else {
1224                                         $index = Namespace::getCanonicalIndex( strtolower( $text ) );
1225                                         if ( !is_null( $index ) ) {
1226                                                 $text = $wgLang->getNsText( $index );
1227                                                 $found = true;
1228                                         }
1229                                 }
1230                         }
1231                 }
1232
1233                 # LOCALURL and LOCALURLE
1234                 if ( !$found ) {
1235                         $mwLocal = MagicWord::get( MAG_LOCALURL );
1236                         $mwLocalE = MagicWord::get( MAG_LOCALURLE );
1237
1238                         if ( $mwLocal->matchStartAndRemove( $text ) ) {
1239                                 $func = 'getLocalURL';
1240                         } elseif ( $mwLocalE->matchStartAndRemove( $text ) ) {
1241                                 $func = 'escapeLocalURL';
1242                         } else {
1243                                 $func = '';
1244                         }
1245
1246                         if ( $func !== '' ) {
1247                                 $args = explode( "|", $text );
1248                                 $n = count( $args );
1249                                 if ( $n > 0 ) {
1250                                         $title = Title::newFromText( $args[0] );
1251                                         if ( !is_null( $title ) ) {
1252                                                 if ( $n > 1 ) {
1253                                                         $text = $title->$func( $args[1] );
1254                                                 } else {
1255                                                         $text = $title->$func();
1256                                                 }
1257                                                 $found = true;
1258                                         }
1259                                 }
1260                         }
1261                 }
1262
1263                 # Check for a match against internal variables
1264                 if ( !$found && array_key_exists( $text, $this->mVariables ) ) {
1265                         $text = $this->mVariables[$text];
1266                         $found = true;
1267                         $this->mOutput->mContainsOldMagic = true;
1268                 }
1269
1270                 # Load from database
1271                 if ( !$found ) {
1272                         $title = Title::newFromText( $text, NS_TEMPLATE );
1273                         if ( is_object( $title ) && !$title->isExternal() ) {
1274                                 # Check for excessive inclusion
1275                                 $dbk = $title->getPrefixedDBkey();
1276                                 if ( !array_key_exists( $dbk, $this->mIncludeCount ) ) {
1277                                         $this->mIncludeCount[$dbk] = 0;
1278                                 }
1279                                 if ( ++$this->mIncludeCount[$dbk] <= MAX_INCLUDE_REPEAT ) {
1280                                         $article = new Article( $title );
1281                                         $articleContent = $article->getContentWithoutUsingSoManyDamnGlobals();
1282                                         if ( $articleContent !== false ) {
1283                                                 $found = true;
1284                                                 $text = $articleContent;
1285
1286                                                 # Escaping and link table handling
1287                                                 # Not required for preSaveTransform()
1288                                                 if ( $this->mOutputType == OT_HTML ) {
1289                                                         if ( $nowiki ) {
1290                                                                 $text = wfEscapeWikiText( $text );
1291                                                         } else {
1292                                                                 $text = $this->removeHTMLtags( $text );
1293                                                         }
1294                                                         $wgLinkCache->suspend();
1295                                                         $text = $this->doTokenizedParser( $text );
1296                                                         $wgLinkCache->resume();
1297                                                         $wgLinkCache->addLinkObj( $title );
1298
1299                                                 }
1300                                         }
1301                                 }
1302
1303                                 # If the title is valid but undisplayable, make a link to it
1304                                 if ( $this->mOutputType == OT_HTML && !$found ) {
1305                                         $text = "[[" . $title->getPrefixedText() . "]]";
1306                                         $found = true;
1307                                 }
1308                         }
1309                 }
1310
1311                 if ( !$found ) {
1312                         return $matches[0];
1313                 } else {
1314                         return $text;
1315                 }
1316         }
1317
1318         # Cleans up HTML, removes dangerous tags and attributes
1319         /* private */ function removeHTMLtags( $text )
1320         {
1321                 $fname = "Parser::removeHTMLtags";
1322                 wfProfileIn( $fname );
1323                 $htmlpairs = array( # Tags that must be closed
1324                         "b", "i", "u", "font", "big", "small", "sub", "sup", "h1",
1325                         "h2", "h3", "h4", "h5", "h6", "cite", "code", "em", "s",
1326                         "strike", "strong", "tt", "var", "div", "center",
1327                         "blockquote", "ol", "ul", "dl", "table", "caption", "pre",
1328                         "ruby", "rt" , "rb" , "rp", "p"
1329                 );
1330                 $htmlsingle = array(
1331                         "br", "hr", "li", "dt", "dd"
1332                 );
1333                 $htmlnest = array( # Tags that can be nested--??
1334                         "table", "tr", "td", "th", "div", "blockquote", "ol", "ul",
1335                         "dl", "font", "big", "small", "sub", "sup"
1336                 );
1337                 $tabletags = array( # Can only appear inside table
1338                         "td", "th", "tr"
1339                 );
1340
1341                 $htmlsingle = array_merge( $tabletags, $htmlsingle );
1342                 $htmlelements = array_merge( $htmlsingle, $htmlpairs );
1343
1344                 $htmlattrs = $this->getHTMLattrs () ;
1345
1346                 # Remove HTML comments
1347                 $text = preg_replace( "/<!--.*-->/sU", "", $text );
1348
1349                 $bits = explode( "<", $text );
1350                 $text = array_shift( $bits );
1351                 $tagstack = array(); $tablestack = array();
1352
1353                 foreach ( $bits as $x ) {
1354                         $prev = error_reporting( E_ALL & ~( E_NOTICE | E_WARNING ) );
1355                         preg_match( "/^(\\/?)(\\w+)([^>]*)(\\/{0,1}>)([^<]*)$/",
1356                           $x, $regs );
1357                         list( $qbar, $slash, $t, $params, $brace, $rest ) = $regs;
1358                         error_reporting( $prev );
1359
1360                         $badtag = 0 ;
1361                         if ( in_array( $t = strtolower( $t ), $htmlelements ) ) {
1362                                 # Check our stack
1363                                 if ( $slash ) {
1364                                         # Closing a tag...
1365                                         if ( ! in_array( $t, $htmlsingle ) &&
1366                                           ( $ot = array_pop( $tagstack ) ) != $t ) {
1367                                                 array_push( $tagstack, $ot );
1368                                                 $badtag = 1;
1369                                         } else {
1370                                                 if ( $t == "table" ) {
1371                                                         $tagstack = array_pop( $tablestack );
1372                                                 }
1373                                                 $newparams = "";
1374                                         }
1375                                 } else {
1376                                         # Keep track for later
1377                                         if ( in_array( $t, $tabletags ) &&
1378                                           ! in_array( "table", $tagstack ) ) {
1379                                                 $badtag = 1;
1380                                         } else if ( in_array( $t, $tagstack ) &&
1381                                           ! in_array ( $t , $htmlnest ) ) {
1382                                                 $badtag = 1 ;
1383                                         } else if ( ! in_array( $t, $htmlsingle ) ) {
1384                                                 if ( $t == "table" ) {
1385                                                         array_push( $tablestack, $tagstack );
1386                                                         $tagstack = array();
1387                                                 }
1388                                                 array_push( $tagstack, $t );
1389                                         }
1390                                         # Strip non-approved attributes from the tag
1391                                         $newparams = $this->fixTagAttributes($params);
1392
1393                                 }
1394                                 if ( ! $badtag ) {
1395                                         $rest = str_replace( ">", "&gt;", $rest );
1396                                         $text .= "<$slash$t $newparams$brace$rest";
1397                                         continue;
1398                                 }
1399                         }
1400                         $text .= "&lt;" . str_replace( ">", "&gt;", $x);
1401                 }
1402                 # Close off any remaining tags
1403                 while ( $t = array_pop( $tagstack ) ) {
1404                         $text .= "</$t>\n";
1405                         if ( $t == "table" ) { $tagstack = array_pop( $tablestack ); }
1406                 }
1407                 wfProfileOut( $fname );
1408                 return $text;
1409         }
1410
1411 /*
1412  *
1413  * This function accomplishes several tasks:
1414  * 1) Auto-number headings if that option is enabled
1415  * 2) Add an [edit] link to sections for logged in users who have enabled the option
1416  * 3) Add a Table of contents on the top for users who have enabled the option
1417  * 4) Auto-anchor headings
1418  *
1419  * It loops through all headlines, collects the necessary data, then splits up the
1420  * string and re-inserts the newly formatted headlines.
1421  *
1422  */
1423
1424         /* private */ function formatHeadings( $text )
1425         {
1426                 $doNumberHeadings = $this->mOptions->getNumberHeadings();
1427                 $doShowToc = $this->mOptions->getShowToc();
1428                 if( !$this->mTitle->userCanEdit() ) {
1429                         $showEditLink = 0;
1430                         $rightClickHack = 0;
1431                 } else {
1432                         $showEditLink = $this->mOptions->getEditSection();
1433                         $rightClickHack = $this->mOptions->getEditSectionOnRightClick();
1434                 }
1435
1436                 # Inhibit editsection links if requested in the page
1437                 $esw =& MagicWord::get( MAG_NOEDITSECTION );
1438                 if( $esw->matchAndRemove( $text ) ) {
1439                         $showEditLink = 0;
1440                 }
1441                 # if the string __NOTOC__ (not case-sensitive) occurs in the HTML,
1442                 # do not add TOC
1443                 $mw =& MagicWord::get( MAG_NOTOC );
1444                 if( $mw->matchAndRemove( $text ) ) {
1445                         $doShowToc = 0;
1446                 }
1447
1448                 # never add the TOC to the Main Page. This is an entry page that should not
1449                 # be more than 1-2 screens large anyway
1450                 if( $this->mTitle->getPrefixedText() == wfMsg("mainpage") ) {
1451                         $doShowToc = 0;
1452                 }
1453
1454                 # Get all headlines for numbering them and adding funky stuff like [edit]
1455                 # links - this is for later, but we need the number of headlines right now
1456                 $numMatches = preg_match_all( "/<H([1-6])(.*?" . ">)(.*?)<\/H[1-6]>/i", $text, $matches );
1457
1458                 # if there are fewer than 4 headlines in the article, do not show TOC
1459                 if( $numMatches < 4 ) {
1460                         $doShowToc = 0;
1461                 }
1462
1463                 # if the string __FORCETOC__ (not case-sensitive) occurs in the HTML,
1464                 # override above conditions and always show TOC
1465                 $mw =& MagicWord::get( MAG_FORCETOC );
1466                 if ($mw->matchAndRemove( $text ) ) {
1467                         $doShowToc = 1;
1468                 }
1469
1470
1471                 # We need this to perform operations on the HTML
1472                 $sk =& $this->mOptions->getSkin();
1473
1474                 # headline counter
1475                 $headlineCount = 0;
1476
1477                 # Ugh .. the TOC should have neat indentation levels which can be
1478                 # passed to the skin functions. These are determined here
1479                 $toclevel = 0;
1480                 $toc = "";
1481                 $full = "";
1482                 $head = array();
1483                 $sublevelCount = array();
1484                 $level = 0;
1485                 $prevlevel = 0;
1486                 foreach( $matches[3] as $headline ) {
1487                         $numbering = "";
1488                         if( $level ) {
1489                                 $prevlevel = $level;
1490                         }
1491                         $level = $matches[1][$headlineCount];
1492                         if( ( $doNumberHeadings || $doShowToc ) && $prevlevel && $level > $prevlevel ) {
1493                                 # reset when we enter a new level
1494                                 $sublevelCount[$level] = 0;
1495                                 $toc .= $sk->tocIndent( $level - $prevlevel );
1496                                 $toclevel += $level - $prevlevel;
1497                         }
1498                         if( ( $doNumberHeadings || $doShowToc ) && $level < $prevlevel ) {
1499                                 # reset when we step back a level
1500                                 $sublevelCount[$level+1]=0;
1501                                 $toc .= $sk->tocUnindent( $prevlevel - $level );
1502                                 $toclevel -= $prevlevel - $level;
1503                         }
1504                         # count number of headlines for each level
1505                         @$sublevelCount[$level]++;
1506                         if( $doNumberHeadings || $doShowToc ) {
1507                                 $dot = 0;
1508                                 for( $i = 1; $i <= $level; $i++ ) {
1509                                         if( !empty( $sublevelCount[$i] ) ) {
1510                                                 if( $dot ) {
1511                                                         $numbering .= ".";
1512                                                 }
1513                                                 $numbering .= $sublevelCount[$i];
1514                                                 $dot = 1;
1515                                         }
1516                                 }
1517                         }
1518
1519                         # The canonized header is a version of the header text safe to use for links
1520                         # Avoid insertion of weird stuff like <math> by expanding the relevant sections
1521                         $canonized_headline = Parser::unstrip( $headline, $this->mStripState );
1522
1523                         # strip out HTML
1524                         $canonized_headline = preg_replace( "/<.*?" . ">/","",$canonized_headline );
1525                         $tocline = trim( $canonized_headline );
1526                         $canonized_headline = preg_replace("/[ &\\/<>\\(\\)\\[\\]=,+']+/", '_', html_entity_decode( $tocline));
1527                         $refer[$headlineCount] = $canonized_headline;
1528
1529                         # count how many in assoc. array so we can track dupes in anchors
1530                         @$refers[$canonized_headline]++;
1531                         $refcount[$headlineCount]=$refers[$canonized_headline];
1532
1533                         # Prepend the number to the heading text
1534
1535                         if( $doNumberHeadings || $doShowToc ) {
1536                                 $tocline = $numbering . " " . $tocline;
1537
1538                                 # Don't number the heading if it is the only one (looks silly)
1539                                 if( $doNumberHeadings && count( $matches[3] ) > 1) {
1540                                         # the two are different if the line contains a link
1541                                         $headline=$numbering . " " . $headline;
1542                                 }
1543                         }
1544
1545                         # Create the anchor for linking from the TOC to the section
1546                         $anchor = $canonized_headline;
1547                         if($refcount[$headlineCount] > 1 ) {
1548                                 $anchor .= "_" . $refcount[$headlineCount];
1549                         }
1550                         if( $doShowToc ) {
1551                                 $toc .= $sk->tocLine($anchor,$tocline,$toclevel);
1552                         }
1553                         if( $showEditLink ) {
1554                                 if ( empty( $head[$headlineCount] ) ) {
1555                                         $head[$headlineCount] = "";
1556                                 }
1557                                 $head[$headlineCount] .= $sk->editSectionLink($headlineCount+1);
1558                         }
1559
1560                         # Add the edit section span
1561                         if( $rightClickHack ) {
1562                                 $headline = $sk->editSectionScript($headlineCount+1,$headline);
1563                         }
1564
1565                         # give headline the correct <h#> tag
1566                         @$head[$headlineCount] .= "<a name=\"$anchor\"></a><h".$level.$matches[2][$headlineCount] .$headline."</h".$level.">";
1567
1568                         $headlineCount++;
1569                 }
1570
1571                 if( $doShowToc ) {
1572                         $toclines = $headlineCount;
1573                         $toc .= $sk->tocUnindent( $toclevel );
1574                         $toc = $sk->tocTable( $toc );
1575                 }
1576
1577                 # split up and insert constructed headlines
1578
1579                 $blocks = preg_split( "/<H[1-6].*?" . ">.*?<\/H[1-6]>/i", $text );
1580                 $i = 0;
1581
1582                 foreach( $blocks as $block ) {
1583                         if( $showEditLink && $headlineCount > 0 && $i == 0 && $block != "\n" ) {
1584                             # This is the [edit] link that appears for the top block of text when
1585                                 # section editing is enabled
1586                                 $full .= $sk->editSectionLink(0);
1587                         }
1588                         $full .= $block;
1589                         if( $doShowToc && !$i) {
1590                         # Top anchor now in skin
1591                                 $full = $full.$toc;
1592                         }
1593
1594                         if( !empty( $head[$i] ) ) {
1595                                 $full .= $head[$i];
1596                         }
1597                         $i++;
1598                 }
1599
1600                 return $full;
1601         }
1602
1603         /* private */ function doMagicISBN( &$tokenizer )
1604         {
1605                 global $wgLang;
1606
1607                 # Check whether next token is a text token
1608                 # If yes, fetch it and convert the text into a
1609                 # Special::BookSources link
1610                 $token = $tokenizer->previewToken();
1611                 while ( $token["type"] == "" )
1612                 {
1613                         $tokenizer->nextToken();
1614                         $token = $tokenizer->previewToken();
1615                 }
1616                 if ( $token["type"] == "text" )
1617                 {
1618                         $token = $tokenizer->nextToken();
1619                         $x = $token["text"];
1620                         $valid = "0123456789-ABCDEFGHIJKLMNOPQRSTUVWXYZ";
1621
1622                         $isbn = $blank = "" ;
1623                         while ( " " == $x{0} ) {
1624                                 $blank .= " ";
1625                                 $x = substr( $x, 1 );
1626                         }
1627                         while ( strstr( $valid, $x{0} ) != false ) {
1628                                 $isbn .= $x{0};
1629                                 $x = substr( $x, 1 );
1630                         }
1631                         $num = str_replace( "-", "", $isbn );
1632                         $num = str_replace( " ", "", $num );
1633
1634                         if ( "" == $num ) {
1635                                 $text = "ISBN $blank$x";
1636                         } else {
1637                                 $titleObj = Title::makeTitle( NS_SPECIAL, "Booksources" );
1638                                 $text = "<a href=\"" .
1639                                 $titleObj->escapeLocalUrl( "isbn={$num}" ) .
1640                                         "\" class=\"internal\">ISBN $isbn</a>";
1641                                 $text .= $x;
1642                         }
1643                 } else {
1644                         $text = "ISBN ";
1645                 }
1646                 return $text;
1647         }
1648         /* private */ function doMagicRFC( &$tokenizer )
1649         {
1650                 global $wgLang;
1651
1652                 # Check whether next token is a text token
1653                 # If yes, fetch it and convert the text into a
1654                 # link to an RFC source
1655                 $token = $tokenizer->previewToken();
1656                 while ( $token["type"] == "" )
1657                 {
1658                         $tokenizer->nextToken();
1659                         $token = $tokenizer->previewToken();
1660                 }
1661                 if ( $token["type"] == "text" )
1662                 {
1663                         $token = $tokenizer->nextToken();
1664                         $x = $token["text"];
1665                         $valid = "0123456789";
1666
1667                         $rfc = $blank = "" ;
1668                         while ( " " == $x{0} ) {
1669                                 $blank .= " ";
1670                                 $x = substr( $x, 1 );
1671                         }
1672                         while ( strstr( $valid, $x{0} ) != false ) {
1673                                 $rfc .= $x{0};
1674                                 $x = substr( $x, 1 );
1675                         }
1676
1677                         if ( "" == $rfc ) {
1678                                 $text .= "RFC $blank$x";
1679                         } else {
1680                                 $url = wfmsg( "rfcurl" );
1681                                 $url = str_replace( "$1", $rfc, $url);
1682                                 $sk =& $this->mOptions->getSkin();
1683                                 $la = $sk->getExternalLinkAttributes( $url, "RFC {$rfc}" );
1684                                 $text = "<a href='{$url}'{$la}>RFC {$rfc}</a>{$x}";
1685                         }
1686                 } else {
1687                         $text = "RFC ";
1688                 }
1689                 return $text;
1690         }
1691
1692         function preSaveTransform( $text, &$title, &$user, $options, $clearState = true )
1693         {
1694                 $this->mOptions = $options;
1695                 $this->mTitle =& $title;
1696                 $this->mOutputType = OT_WIKI;
1697
1698                 if ( $clearState ) {
1699                         $this->clearState();
1700                 }
1701
1702                 $stripState = false;
1703                 $text = str_replace("\r\n", "\n", $text);
1704                 $text = $this->strip( $text, $stripState, false );
1705                 $text = $this->pstPass2( $text, $user );
1706                 $text = $this->unstrip( $text, $stripState );
1707                 return $text;
1708         }
1709
1710         /* private */ function pstPass2( $text, &$user )
1711         {
1712                 global $wgLang, $wgLocaltimezone, $wgCurParser;
1713
1714                 # Variable replacement
1715                 # Because mOutputType is OT_WIKI, this will only process {{subst:xxx}} type tags
1716                 $text = $this->replaceVariables( $text );
1717
1718                 # Signatures
1719                 #
1720                 $n = $user->getName();
1721                 $k = $user->getOption( "nickname" );
1722                 if ( "" == $k ) { $k = $n; }
1723                 if(isset($wgLocaltimezone)) {
1724                         $oldtz = getenv("TZ"); putenv("TZ=$wgLocaltimezone");
1725                 }
1726                 /* Note: this is an ugly timezone hack for the European wikis */
1727                 $d = $wgLang->timeanddate( date( "YmdHis" ), false ) .
1728                   " (" . date( "T" ) . ")";
1729                 if(isset($wgLocaltimezone)) putenv("TZ=$oldtz");
1730
1731                 $text = preg_replace( "/~~~~~/", $d, $text );
1732                 $text = preg_replace( "/~~~~/", "[[" . $wgLang->getNsText(
1733                   Namespace::getUser() ) . ":$n|$k]] $d", $text );
1734                 $text = preg_replace( "/~~~/", "[[" . $wgLang->getNsText(
1735                   Namespace::getUser() ) . ":$n|$k]]", $text );
1736
1737                 # Context links: [[|name]] and [[name (context)|]]
1738                 #
1739                 $tc = "[&;%\\-,.\\(\\)' _0-9A-Za-z\\/:\\x80-\\xff]";
1740                 $np = "[&;%\\-,.' _0-9A-Za-z\\/:\\x80-\\xff]"; # No parens
1741                 $namespacechar = '[ _0-9A-Za-z\x80-\xff]'; # Namespaces can use non-ascii!
1742                 $conpat = "/^({$np}+) \\(({$tc}+)\\)$/";
1743
1744                 $p1 = "/\[\[({$np}+) \\(({$np}+)\\)\\|]]/";             # [[page (context)|]]
1745                 $p2 = "/\[\[\\|({$tc}+)]]/";                                    # [[|page]]
1746                 $p3 = "/\[\[($namespacechar+):({$np}+)\\|]]/";          # [[namespace:page|]]
1747                 $p4 = "/\[\[($namespacechar+):({$np}+) \\(({$np}+)\\)\\|]]/";
1748                                                                                                                 # [[ns:page (cont)|]]
1749                 $context = "";
1750                 $t = $this->mTitle->getText();
1751                 if ( preg_match( $conpat, $t, $m ) ) {
1752                         $context = $m[2];
1753                 }
1754                 $text = preg_replace( $p4, "[[\\1:\\2 (\\3)|\\2]]", $text );
1755                 $text = preg_replace( $p1, "[[\\1 (\\2)|\\1]]", $text );
1756                 $text = preg_replace( $p3, "[[\\1:\\2|\\2]]", $text );
1757
1758                 if ( "" == $context ) {
1759                         $text = preg_replace( $p2, "[[\\1]]", $text );
1760                 } else {
1761                         $text = preg_replace( $p2, "[[\\1 ({$context})|\\1]]", $text );
1762                 }
1763
1764                 /*
1765                 $mw =& MagicWord::get( MAG_SUBST );
1766                 $wgCurParser = $this->fork();
1767                 $text = $mw->substituteCallback( $text, "wfBraceSubstitution" );
1768                 $this->merge( $wgCurParser );
1769                 */
1770
1771                 # Trim trailing whitespace
1772                 # MAG_END (__END__) tag allows for trailing
1773                 # whitespace to be deliberately included
1774                 $text = rtrim( $text );
1775                 $mw =& MagicWord::get( MAG_END );
1776                 $mw->matchAndRemove( $text );
1777
1778                 return $text;
1779         }
1780
1781         # Set up some variables which are usually set up in parse()
1782         # so that an external function can call some class members with confidence
1783         function startExternalParse( &$title, $options, $outputType, $clearState = true )
1784         {
1785                 $this->mTitle =& $title;
1786                 $this->mOptions = $options;
1787                 $this->mOutputType = $outputType;
1788                 if ( $clearState ) {
1789                         $this->clearState();
1790                 }
1791         }
1792
1793         function transformMsg( $text, $options ) {
1794                 global $wgTitle;
1795                 static $executing = false;
1796
1797                 # Guard against infinite recursion
1798                 if ( $executing ) {
1799                         return $text;
1800                 }
1801                 $executing = true;
1802
1803                 $this->mTitle = $wgTitle;
1804                 $this->mOptions = $options;
1805                 $this->mOutputType = OT_MSG;
1806                 $this->clearState();
1807                 $text = $this->replaceVariables( $text );
1808
1809                 $executing = false;
1810                 return $text;
1811         }
1812 }
1813
1814 class ParserOutput
1815 {
1816         var $mText, $mLanguageLinks, $mCategoryLinks, $mContainsOldMagic;
1817
1818         function ParserOutput( $text = "", $languageLinks = array(), $categoryLinks = array(),
1819                 $containsOldMagic = false )
1820         {
1821                 $this->mText = $text;
1822                 $this->mLanguageLinks = $languageLinks;
1823                 $this->mCategoryLinks = $categoryLinks;
1824                 $this->mContainsOldMagic = $containsOldMagic;
1825         }
1826
1827         function getText() { return $this->mText; }
1828         function getLanguageLinks() { return $this->mLanguageLinks; }
1829         function getCategoryLinks() { return $this->mCategoryLinks; }
1830         function containsOldMagic() { return $this->mContainsOldMagic; }
1831         function setText( $text ) { return wfSetVar( $this->mText, $text ); }
1832         function setLanguageLinks( $ll ) { return wfSetVar( $this->mLanguageLinks, $ll ); }
1833         function setCategoryLinks( $cl ) { return wfSetVar( $this->mCategoryLinks, $cl ); }
1834         function setContainsOldMagic( $com ) { return wfSetVar( $this->mContainsOldMagic, $com ); }
1835
1836         function merge( $other ) {
1837                 $this->mLanguageLinks = array_merge( $this->mLanguageLinks, $other->mLanguageLinks );
1838                 $this->mCategoryLinks = array_merge( $this->mCategoryLinks, $this->mLanguageLinks );
1839                 $this->mContainsOldMagic = $this->mContainsOldMagic || $other->mContainsOldMagic;
1840         }
1841
1842 }
1843
1844 class ParserOptions
1845 {
1846         # All variables are private
1847         var $mUseTeX;                    # Use texvc to expand <math> tags
1848         var $mUseCategoryMagic;          # Treat [[Category:xxxx]] tags specially
1849         var $mUseDynamicDates;           # Use $wgDateFormatter to format dates
1850         var $mInterwikiMagic;            # Interlanguage links are removed and returned in an array
1851         var $mAllowExternalImages;       # Allow external images inline
1852         var $mSkin;                      # Reference to the preferred skin
1853         var $mDateFormat;                # Date format index
1854         var $mEditSection;               # Create "edit section" links
1855         var $mEditSectionOnRightClick;   # Generate JavaScript to edit section on right click
1856         var $mNumberHeadings;            # Automatically number headings
1857         var $mShowToc;                   # Show table of contents
1858
1859         function getUseTeX() { return $this->mUseTeX; }
1860         function getUseCategoryMagic() { return $this->mUseCategoryMagic; }
1861         function getUseDynamicDates() { return $this->mUseDynamicDates; }
1862         function getInterwikiMagic() { return $this->mInterwikiMagic; }
1863         function getAllowExternalImages() { return $this->mAllowExternalImages; }
1864         function getSkin() { return $this->mSkin; }
1865         function getDateFormat() { return $this->mDateFormat; }
1866         function getEditSection() { return $this->mEditSection; }
1867         function getEditSectionOnRightClick() { return $this->mEditSectionOnRightClick; }
1868         function getNumberHeadings() { return $this->mNumberHeadings; }
1869         function getShowToc() { return $this->mShowToc; }
1870
1871         function setUseTeX( $x ) { return wfSetVar( $this->mUseTeX, $x ); }
1872         function setUseCategoryMagic( $x ) { return wfSetVar( $this->mUseCategoryMagic, $x ); }
1873         function setUseDynamicDates( $x ) { return wfSetVar( $this->mUseDynamicDates, $x ); }
1874         function setInterwikiMagic( $x ) { return wfSetVar( $this->mInterwikiMagic, $x ); }
1875         function setAllowExternalImages( $x ) { return wfSetVar( $this->mAllowExternalImages, $x ); }
1876         function setSkin( $x ) { return wfSetRef( $this->mSkin, $x ); }
1877         function setDateFormat( $x ) { return wfSetVar( $this->mDateFormat, $x ); }
1878         function setEditSection( $x ) { return wfSetVar( $this->mEditSection, $x ); }
1879         function setEditSectionOnRightClick( $x ) { return wfSetVar( $this->mEditSectionOnRightClick, $x ); }
1880         function setNumberHeadings( $x ) { return wfSetVar( $this->mNumberHeadings, $x ); }
1881         function setShowToc( $x ) { return wfSetVar( $this->mShowToc, $x ); }
1882
1883         /* static */ function newFromUser( &$user )
1884         {
1885                 $popts = new ParserOptions;
1886                 $popts->initialiseFromUser( &$user );
1887                 return $popts;
1888         }
1889
1890         function initialiseFromUser( &$userInput )
1891         {
1892                 global $wgUseTeX, $wgUseCategoryMagic, $wgUseDynamicDates, $wgInterwikiMagic, $wgAllowExternalImages;
1893
1894                 if ( !$userInput ) {
1895                         $user = new User;
1896                         $user->setLoaded( true );
1897                 } else {
1898                         $user =& $userInput;
1899                 }
1900
1901                 $this->mUseTeX = $wgUseTeX;
1902                 $this->mUseCategoryMagic = $wgUseCategoryMagic;
1903                 $this->mUseDynamicDates = $wgUseDynamicDates;
1904                 $this->mInterwikiMagic = $wgInterwikiMagic;
1905                 $this->mAllowExternalImages = $wgAllowExternalImages;
1906                 $this->mSkin =& $user->getSkin();
1907                 $this->mDateFormat = $user->getOption( "date" );
1908                 $this->mEditSection = $user->getOption( "editsection" );
1909                 $this->mEditSectionOnRightClick = $user->getOption( "editsectiononrightclick" );
1910                 $this->mNumberHeadings = $user->getOption( "numberheadings" );
1911                 $this->mShowToc = $user->getOption( "showtoc" );
1912         }
1913
1914
1915 }
1916
1917 # Regex callbacks, used in Parser::replaceVariables
1918 function wfBraceSubstitution( $matches )
1919 {
1920         global $wgCurParser;
1921         return $wgCurParser->braceSubstitution( $matches );
1922 }
1923
1924 ?>