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