includes/OutputPage.php

   1 <?
   2 # See design.doc
   3
   4 if($wgUseTeX) include_once( "Math.php" );
   5
   6 class OutputPage {
   7         var $mHeaders, $mCookies, $mMetatags, $mKeywords;
   8         var $mLinktags, $mPagetitle, $mBodytext, $mDebugtext;
   9         var $mHTMLtitle, $mRobotpolicy, $mIsarticle, $mPrintable;
  10         var $mSubtitle, $mRedirect, $mAutonumber, $mHeadtext;
  11         var $mLastModified, $mCategoryLinks;
  12
  13         var $mDTopen, $mLastSection; # Used for processing DL, PRE
  14         var $mLanguageLinks, $mSupressQuickbar;
  15         var $mOnloadHandler;
  16         var $mDoNothing;
  17         var $mContainsOldMagic, $mContainsNewMagic;
  18         var $mIsArticleRelated;
  19
  20         function OutputPage()
  21         {
  22                 $this->mHeaders = $this->mCookies = $this->mMetatags =
  23                 $this->mKeywords = $this->mLinktags = array();
  24                 $this->mHTMLtitle = $this->mPagetitle = $this->mBodytext =
  25                 $this->mLastSection = $this->mRedirect = $this->mLastModified =
  26                 $this->mSubtitle = $this->mDebugtext = $this->mRobotpolicy =
  27                 $this->mOnloadHandler = "";
  28                 $this->mIsArticleRelated = $this->mIsarticle = $this->mPrintable = true;
  29                 $this->mSupressQuickbar = $this->mDTopen = $this->mPrintable = false;
  30                 $this->mLanguageLinks = array();
  31                 $this->mCategoryLinks = array() ;
  32                 $this->mAutonumber = 0;
  33                 $this->mDoNothing = false;
  34                 $this->mContainsOldMagic = $this->mContainsNewMagic = 0;
  35         }
  36
  37         function addHeader( $name, $val ) { array_push( $this->mHeaders, "$name: $val" ) ; }
  38         function addCookie( $name, $val ) { array_push( $this->mCookies, array( $name, $val ) ); }
  39         function redirect( $url ) { $this->mRedirect = $url; }
  40
  41         # To add an http-equiv meta tag, precede the name with "http:"
  42         function addMeta( $name, $val ) { array_push( $this->mMetatags, array( $name, $val ) ); }
  43         function addKeyword( $text ) { array_push( $this->mKeywords, $text ); }
  44         function addLink( $rel, $rev, $target ) { array_push( $this->mLinktags, array( $rel, $rev, $target ) ); }
  45
  46         # checkLastModified tells the client to use the client-cached page if
  47         # possible. If sucessful, the OutputPage is disabled so that
  48         # any future call to OutputPage->output() have no effect. The method
  49         # returns true iff cache-ok headers was sent.
  50         function checkLastModified ( $timestamp )
  51         {
  52                 global $wgLang, $wgCachePages, $wgUser;
  53                 if( !$wgCachePages ) {
  54                         wfDebug( "CACHE DISABLED\n", false );
  55                         return;
  56                 }
  57                 if( preg_match( '/MSIE ([1-4]|5\.0)/', $_SERVER["HTTP_USER_AGENT"] ) ) {
  58                         # IE 5.0 has probs with our caching
  59                         wfDebug( "-- bad client, not caching\n", false );
  60                         return;
  61                 }
  62                 if( $wgUser->getOption( "nocache" ) ) {
  63                         wfDebug( "USER DISABLED CACHE\n", false );
  64                         return;
  65                 }
  66
  67                 $lastmod = gmdate( "D, j M Y H:i:s", wfTimestamp2Unix(
  68                         max( $timestamp, $wgUser->mTouched ) ) ) . " GMT";
  69
  70                 if( !empty( $_SERVER["HTTP_IF_MODIFIED_SINCE"] ) ) {
  71                         # IE sends sizes after the date like this:
  72                         # Wed, 20 Aug 2003 06:51:19 GMT; length=5202
  73                         # this breaks strtotime().
  74                         $modsince = preg_replace( '/;.*$/', '', $_SERVER["HTTP_IF_MODIFIED_SINCE"] );
  75                         $ismodsince = wfUnix2Timestamp( strtotime( $modsince ) );
  76                         wfDebug( "-- client send If-Modified-Since: " . $modsince . "\n", false );
  77                         wfDebug( "--  we might send Last-Modified : $lastmod\n", false );
  78
  79                         if( ($ismodsince >= $timestamp ) and $wgUser->validateCache( $ismodsince ) ) {
  80                                 # Make sure you're in a place you can leave when you call us!
  81                                 header( "HTTP/1.0 304 Not Modified" );
  82                                 $this->mLastModified = $lastmod;
  83                                 $this->sendCacheControl();
  84                                 wfDebug( "CACHED client: $ismodsince ; user: $wgUser->mTouched ; page: $timestamp\n", false );
  85                                 $this->disable();
  86                                 return true;
  87                         } else {
  88                                 wfDebug( "READY  client: $ismodsince ; user: $wgUser->mTouched ; page: $timestamp\n", false );
  89                                 $this->mLastModified = $lastmod;
  90                         }
  91                 } else {
  92                         wfDebug( "We're confused.\n", false );
  93                         $this->mLastModified = $lastmod;
  94                 }
  95         }
  96
  97         function setRobotpolicy( $str ) { $this->mRobotpolicy = $str; }
  98         function setHTMLtitle( $name ) { $this->mHTMLtitle = $name; }
  99         function setPageTitle( $name ) { $this->mPagetitle = $name; }
 100         function getPageTitle() { return $this->mPagetitle; }
 101         function setSubtitle( $str ) { $this->mSubtitle = $str; }
 102         function getSubtitle() { return $this->mSubtitle; }
 103         function isArticle() { return $this->mIsarticle; }
 104         function setPrintable() { $this->mPrintable = true; }
 105         function isPrintable() { return $this->mPrintable; }
 106         function setOnloadHandler( $js ) { $this->mOnloadHandler = $js; }
 107         function getOnloadHandler() { return $this->mOnloadHandler; }
 108         function disable() { $this->mDoNothing = true; }
 109
 110         function setArticleRelated( $v )
 111         {
 112                 $this->mIsArticleRelated = $v;
 113                 if ( !$v ) {
 114                         $this->mIsarticle = false;
 115                 }
 116         }
 117         function setArticleFlag( $v ) {
 118                 $this->mIsarticle = $v;
 119                 if ( $v ) {
 120                         $this->mIsArticleRelated = $v;
 121                 }
 122         }
 123
 124         function isArticleRelated()
 125         {
 126                 return $this->mIsArticleRelated;
 127         }
 128
 129         function getLanguageLinks() {
 130                 global $wgTitle, $wgLanguageCode;
 131                 global $wgDBconnection, $wgDBname;
 132                 return $this->mLanguageLinks;
 133         }
 134         function supressQuickbar() { $this->mSupressQuickbar = true; }
 135         function isQuickbarSupressed() { return $this->mSupressQuickbar; }
 136
 137         function addHTML( $text ) { $this->mBodytext .= $text; }
 138         function addHeadtext( $text ) { $this->mHeadtext .= $text; }
 139         function debug( $text ) { $this->mDebugtext .= $text; }
 140
 141         # First pass--just handle <nowiki> sections, pass the rest off
 142         # to doWikiPass2() which does all the real work.
 143         #
 144         function addWikiText( $text, $linestart = true )
 145         {
 146                 global $wgUseTeX, $wgArticle, $wgUser, $action;
 147                 $fname = "OutputPage::addWikiText";
 148                 wfProfileIn( $fname );
 149                 $unique  = "3iyZiyA7iMwg5rhxP0Dcc9oTnj8qD1jm1Sfv4";
 150                 $unique2 = "4LIQ9nXtiYFPCSfitVwDw7EYwQlL4GeeQ7qSO";
 151                 $unique3 = "fPaA8gDfdLBqzj68Yjg9Hil3qEF8JGO0uszIp";
 152                 $nwlist = array();
 153                 $nwsecs = 0;
 154                 $mathlist = array();
 155                 $mathsecs = 0;
 156                 $prelist = array ();
 157                 $presecs = 0;
 158                 $stripped = "";
 159                 $stripped2 = "";
 160                 $stripped3 = "";
 161
 162                 # Replace any instances of the placeholders
 163                 $text = str_replace( $unique, wfHtmlEscapeFirst( $unique ), $text );
 164                 $text = str_replace( $unique2, wfHtmlEscapeFirst( $unique2 ), $text );
 165                 $text = str_replace( $unique3, wfHtmlEscapeFirst( $unique3 ), $text );
 166
 167                 global $wgEnableParserCache;
 168                 $use_parser_cache =
 169                         $wgEnableParserCache && $action == "view" &&
 170                         intval($wgUser->getOption( "stubthreshold" )) == 0 &&
 171                         isset($wgArticle) && $wgArticle->getID() > 0;
 172
 173                 if( $use_parser_cache ){
 174                         if( $this->fillFromParserCache() ){
 175                                 wfProfileOut( $fname );
 176                                 return;
 177                         }
 178                 }
 179
 180                 while ( "" != $text ) {
 181                         $p = preg_split( "/<\\s*nowiki\\s*>/i", $text, 2 );
 182                         $stripped .= $p[0];
 183                         if ( ( count( $p ) < 2 ) || ( "" == $p[1] ) ) { $text = ""; }
 184                         else {
 185                                 $q = preg_split( "/<\\/\\s*nowiki\\s*>/i", $p[1], 2 );
 186                                 ++$nwsecs;
 187                                 $nwlist[$nwsecs] = wfEscapeHTMLTagsOnly($q[0]);
 188                                 $stripped .= $unique . $nwsecs . "s";
 189                                 $text = $q[1];
 190                         }
 191                 }
 192
 193                 if( $wgUseTeX ) {
 194                         while ( "" != $stripped ) {
 195                                 $p = preg_split( "/<\\s*math\\s*>/i", $stripped, 2 );
 196                                 $stripped2 .= $p[0];
 197                                 if ( ( count( $p ) < 2 ) || ( "" == $p[1] ) ) { $stripped = ""; }
 198                                 else {
 199                                         $q = preg_split( "/<\\/\\s*math\\s*>/i", $p[1], 2 );
 200                                         ++$mathsecs;
 201                                         $mathlist[$mathsecs] = renderMath($q[0]);
 202                                         $stripped2 .= $unique2 . $mathsecs . "s";
 203                                         $stripped = $q[1];
 204                                 }
 205                         }
 206                 } else {
 207                         $stripped2 = $stripped;
 208                 }
 209
 210                 while ( "" != $stripped2 ) {
 211                         $p = preg_split( "/<\\s*pre\\s*>/i", $stripped2, 2 );
 212                         $stripped3 .= $p[0];
 213                         if ( ( count( $p ) < 2 ) || ( "" == $p[1] ) ) { $stripped2 = ""; }
 214                         else {
 215                                 $q = preg_split( "/<\\/\\s*pre\\s*>/i", $p[1], 2 );
 216                                 ++$presecs;
 217                                 $prelist[$presecs] = "<pre>". wfEscapeHTMLTagsOnly($q[0]). "</pre>\n";
 218                                 $stripped3 .= $unique3 . $presecs . "s";
 219                                 $stripped2 = $q[1];
 220                         }
 221                 }
 222
 223                 $text = $this->doWikiPass2( $stripped3, $linestart );
 224
 225                 $specialChars = array("\\", "$");
 226                 $escapedChars = array("\\\\", "\\$");
 227                 for ( $i = 1; $i <= $presecs; ++$i ) {
 228                         $text = preg_replace( "/{$unique3}{$i}s/", str_replace( $specialChars,
 229                                 $escapedChars, $prelist[$i] ), $text );
 230                 }
 231
 232                 for ( $i = 1; $i <= $mathsecs; ++$i ) {
 233                         $text = preg_replace( "/{$unique2}{$i}s/", str_replace( $specialChars,
 234                                 $escapedChars, $mathlist[$i] ), $text );
 235                 }
 236
 237                 for ( $i = 1; $i <= $nwsecs; ++$i ) {
 238                         $text = preg_replace( "/{$unique}{$i}s/", str_replace( $specialChars,
 239                                 $escapedChars, $nwlist[$i] ), $text );
 240                 }
 241                 $this->addHTML( $text );
 242
 243                 if($use_parser_cache ){
 244                         $this->saveParserCache( $text );
 245                 }
 246                 wfProfileOut( $fname );
 247         }
 248
 249         # Set the maximum cache time on the Squid in seconds
 250         function setSquidMaxage( $maxage ) {
 251                 global $wgSquidMaxage;
 252                 $wgSquidMaxage = $maxage;
 253         }
 254
 255         function sendCacheControl() {
 256                 global $wgUseSquid, $wgUseESI, $wgSquidMaxage;
 257                 # FIXME: This header may cause trouble with some versions of Internet Explorer
 258                 header( "Vary: Accept-Encoding, Cookie" );
 259                 if( $this->mLastModified != "" ) {
 260                         if( $wgUseSquid && ! isset( $_COOKIE[ini_get( "session.name") ] ) &&
 261                           ! $this->isPrintable() )
 262                         {
 263                                 if ( $wgUseESI ) {
 264                                         # We'll purge the proxy cache explicitly, but require end user agents
 265                                         # to revalidate against the proxy on each visit.
 266                                         # Surrogate-Control controls our Squid, Cache-Control downstream caches
 267                                         wfDebug( "** proxy caching with ESI; {$this->mLastModified} **\n", false );
 268                                         # start with a shorter timeout for initial testing
 269                                         # header( 'Surrogate-Control: max-age=2678400+2678400, content="ESI/1.0"');
 270                                         header( 'Surrogate-Control: max-age='.$wgSquidMaxage.'+'.$wgSquidMaxage.', content="ESI/1.0"');
 271                                         header( 'Cache-Control: s-maxage=0, must-revalidate, max-age=0' );
 272                                 } else {
 273                                         # We'll purge the proxy cache for anons explicitly, but require end user agents
 274                                         # to revalidate against the proxy on each visit.
 275                                         # IMPORTANT! The Squid needs to replace the Cache-Control header with
 276                                         # Cache-Control: s-maxage=0, must-revalidate, max-age=0
 277                                         wfDebug( "** local proxy caching; {$this->mLastModified} **\n", false );
 278                                         # start with a shorter timeout for initial testing
 279                                         # header( "Cache-Control: s-maxage=2678400, must-revalidate, max-age=0" );
 280                                         header( 'Cache-Control: s-maxage='.$wgSquidMaxage.', must-revalidate, max-age=0' );
 281                                 }
 282                         } else {
 283                                 # We do want clients to cache if they can, but they *must* check for updates
 284                                 # on revisiting the page.
 285                                 wfDebug( "** private caching; {$this->mLastModified} **\n", false );
 286                                 header( "Expires: -1" );
 287                                 header( "Cache-Control: private, must-revalidate, max-age=0" );
 288                         }
 289                         header( "Last-modified: {$this->mLastModified}" );
 290                 } else {
 291                         wfDebug( "** no caching **\n", false );
 292                         header( "Expires: -1" );
 293                         header( "Cache-Control: no-cache" );
 294                         header( "Pragma: no-cache" );
 295                         header( "Last-modified: " . gmdate( "D, j M Y H:i:s" ) . " GMT" );
 296                 }
 297         }
 298
 299         # Finally, all the text has been munged and accumulated into
 300         # the object, let's actually output it:
 301         #
 302         function output()
 303         {
 304                 global $wgUser, $wgLang, $wgDebugComments, $wgCookieExpiration;
 305                 global $wgInputEncoding, $wgOutputEncoding, $wgLanguageCode;
 306                 if( $this->mDoNothing ){
 307                         return;
 308                 }
 309                 $fname = "OutputPage::output";
 310                 wfProfileIn( $fname );
 311
 312                 $sk = $wgUser->getSkin();
 313
 314                 $this->sendCacheControl();
 315
 316                 header( "Content-type: text/html; charset={$wgOutputEncoding}" );
 317                 header( "Content-language: {$wgLanguageCode}" );
 318
 319                 if ( "" != $this->mRedirect ) {
 320                         if( substr( $this->mRedirect, 0, 4 ) != "http" ) {
 321                                 # Standards require redirect URLs to be absolute
 322                                 global $wgServer;
 323                                 $this->mRedirect = $wgServer . $this->mRedirect;
 324                         }
 325                         header( "Location: {$this->mRedirect}" );
 326                         return;
 327                 }
 328
 329                 $exp = time() + $wgCookieExpiration;
 330                 foreach( $this->mCookies as $name => $val ) {
 331                         setcookie( $name, $val, $exp, "/" );
 332                 }
 333
 334                 $sk->outputPage( $this );
 335                 # flush();
 336         }
 337
 338         function out( $ins )
 339         {
 340                 global $wgInputEncoding, $wgOutputEncoding, $wgLang;
 341                 if ( 0 == strcmp( $wgInputEncoding, $wgOutputEncoding ) ) {
 342                         $outs = $ins;
 343                 } else {
 344                         $outs = $wgLang->iconv( $wgInputEncoding, $wgOutputEncoding, $ins );
 345                         if ( false === $outs ) { $outs = $ins; }
 346                 }
 347                 print $outs;
 348         }
 349
 350         function setEncodings()
 351         {
 352                 global $wgInputEncoding, $wgOutputEncoding;
 353                 global $wgUser, $wgLang;
 354
 355                 $wgInputEncoding = strtolower( $wgInputEncoding );
 356
 357                 if( $wgUser->getOption( 'altencoding' ) ) {
 358                         $wgLang->setAltEncoding();
 359                         return;
 360                 }
 361
 362                 if ( empty( $_SERVER['HTTP_ACCEPT_CHARSET'] ) ) {
 363                         $wgOutputEncoding = strtolower( $wgOutputEncoding );
 364                         return;
 365                 }
 366
 367                 /*
 368                 # This code is unused anyway!
 369                 # Commenting out. --bv 2003-11-15
 370
 371                 $a = explode( ",", $_SERVER['HTTP_ACCEPT_CHARSET'] );
 372                 $best = 0.0;
 373                 $bestset = "*";
 374
 375                 foreach ( $a as $s ) {
 376                         if ( preg_match( "/(.*);q=(.*)/", $s, $m ) ) {
 377                                 $set = $m[1];
 378                                 $q = (float)($m[2]);
 379                         } else {
 380                                 $set = $s;
 381                                 $q = 1.0;
 382                         }
 383                         if ( $q > $best ) {
 384                                 $bestset = $set;
 385                                 $best = $q;
 386                         }
 387                 }
 388                 #if ( "*" == $bestset ) { $bestset = "iso-8859-1"; }
 389                 if ( "*" == $bestset ) { $bestset = $wgOutputEncoding; }
 390                 $wgOutputEncoding = strtolower( $bestset );
 391
 392 # Disable for now
 393 #
 394                 */
 395                 $wgOutputEncoding = $wgInputEncoding;
 396         }
 397
 398         # Returns a HTML comment with the elapsed time since request.
 399         # This method has no side effects.
 400         function reportTime()
 401         {
 402                 global $wgRequestTime;
 403
 404                 list( $usec, $sec ) = explode( " ", microtime() );
 405                 $now = (float)$sec + (float)$usec;
 406
 407                 list( $usec, $sec ) = explode( " ", $wgRequestTime );
 408                 $start = (float)$sec + (float)$usec;
 409                 $elapsed = $now - $start;
 410                 $com = sprintf( "<!-- Time since request: %01.2f secs. -->",
 411                   $elapsed );
 412                 return $com;
 413         }
 414
 415         # Note: these arguments are keys into wfMsg(), not text!
 416         #
 417         function errorpage( $title, $msg )
 418         {
 419                 global $wgTitle;
 420
 421                 $this->mDebugtext .= "Original title: " .
 422                   $wgTitle->getPrefixedText() . "\n";
 423                 $this->setHTMLTitle( wfMsg( "errorpagetitle" ) );
 424                 $this->setPageTitle( wfMsg( $title ) );
 425                 $this->setRobotpolicy( "noindex,nofollow" );
 426                 $this->setArticleRelated( false );
 427
 428                 $this->mBodytext = "";
 429                 $this->addHTML( "<p>" . wfMsg( $msg ) . "\n" );
 430                 $this->returnToMain( false );
 431
 432                 $this->output();
 433                 wfAbruptExit();
 434         }
 435
 436         function sysopRequired()
 437         {
 438                 global $wgUser;
 439
 440                 $this->setHTMLTitle( wfMsg( "errorpagetitle" ) );
 441                 $this->setPageTitle( wfMsg( "sysoptitle" ) );
 442                 $this->setRobotpolicy( "noindex,nofollow" );
 443                 $this->setArticleRelated( false );
 444                 $this->mBodytext = "";
 445
 446                 $sk = $wgUser->getSkin();
 447                 $ap = $sk->makeKnownLink( wfMsg( "administrators" ), "" );
 448                 $this->addHTML( wfMsg( "sysoptext", $ap ) );
 449                 $this->returnToMain();
 450         }
 451
 452         function developerRequired()
 453         {
 454                 global $wgUser;
 455
 456                 $this->setHTMLTitle( wfMsg( "errorpagetitle" ) );
 457                 $this->setPageTitle( wfMsg( "developertitle" ) );
 458                 $this->setRobotpolicy( "noindex,nofollow" );
 459                 $this->setArticleRelated( false );
 460                 $this->mBodytext = "";
 461
 462                 $sk = $wgUser->getSkin();
 463                 $ap = $sk->makeKnownLink( wfMsg( "administrators" ), "" );
 464                 $this->addHTML( wfMsg( "developertext", $ap ) );
 465                 $this->returnToMain();
 466         }
 467
 468         function databaseError( $fname, &$conn )
 469         {
 470                 global $wgUser, $wgCommandLineMode;
 471
 472                 $this->setPageTitle( wfMsgNoDB( "databaseerror" ) );
 473                 $this->setRobotpolicy( "noindex,nofollow" );
 474                 $this->setArticleRelated( false );
 475
 476                 if ( $wgCommandLineMode ) {
 477                         $msg = wfMsgNoDB( "dberrortextcl" );
 478                 } else {
 479                         $msg = wfMsgNoDB( "dberrortext" );
 480                 }
 481
 482                 $msg = str_replace( "$1", htmlspecialchars( $conn->lastQuery() ), $msg );
 483                 $msg = str_replace( "$2", htmlspecialchars( $fname ), $msg );
 484                 $msg = str_replace( "$3", $conn->lastErrno(), $msg );
 485                 $msg = str_replace( "$4", htmlspecialchars( $conn->lastError() ), $msg );
 486
 487                 if ( $wgCommandLineMode || !is_object( $wgUser )) {
 488                         print "$msg\n";
 489                         wfAbruptExit();
 490                 }
 491                 $sk = $wgUser->getSkin();
 492                 $shlink = $sk->makeKnownLink( wfMsgNoDB( "searchhelppage" ),
 493                   wfMsgNoDB( "searchingwikipedia" ) );
 494                 $msg = str_replace( "$5", $shlink, $msg );
 495                 $this->mBodytext = $msg;
 496                 $this->output();
 497                 wfAbruptExit();
 498         }
 499
 500         function readOnlyPage( $source = "", $protected = false )
 501         {
 502                 global $wgUser, $wgReadOnlyFile;
 503
 504                 $this->setRobotpolicy( "noindex,nofollow" );
 505                 $this->setArticleRelated( false );
 506
 507                 if( $protected ) {
 508                         $this->setPageTitle( wfMsg( "viewsource" ) );
 509                         $this->addWikiText( wfMsg( "protectedtext" ) );
 510                 } else {
 511                         $this->setPageTitle( wfMsg( "readonly" ) );
 512                         $reason = file_get_contents( $wgReadOnlyFile );
 513                         $this->addHTML( wfMsg( "readonlytext", $reason ) );
 514                 }
 515
 516                 if($source) {
 517                         $rows = $wgUser->getOption( "rows" );
 518                         $cols = $wgUser->getOption( "cols" );
 519                         $text .= "</p>\n<textarea cols='$cols' rows='$rows' readonly>" .
 520                                 htmlspecialchars( $source ) . "\n</textarea>";
 521                         $this->addHTML( $text );
 522                 }
 523
 524                 $this->returnToMain( false );
 525         }
 526
 527         function fatalError( $message )
 528         {
 529                 $this->setPageTitle( wfMsg( "internalerror" ) );
 530                 $this->setRobotpolicy( "noindex,nofollow" );
 531                 $this->setArticleRelated( false );
 532
 533                 $this->mBodytext = $message;
 534                 $this->output();
 535                 wfAbruptExit();
 536         }
 537
 538         function unexpectedValueError( $name, $val )
 539         {
 540                 $this->fatalError( wfMsg( "unexpected", $name, $val ) );
 541         }
 542
 543         function fileCopyError( $old, $new )
 544         {
 545                 $this->fatalError( wfMsg( "filecopyerror", $old, $new ) );
 546         }
 547
 548         function fileRenameError( $old, $new )
 549         {
 550                 $this->fatalError( wfMsg( "filerenameerror", $old, $new ) );
 551         }
 552
 553         function fileDeleteError( $name )
 554         {
 555                 $this->fatalError( wfMsg( "filedeleteerror", $name ) );
 556         }
 557
 558         function fileNotFoundError( $name )
 559         {
 560                 $this->fatalError( wfMsg( "filenotfound", $name ) );
 561         }
 562
 563         function returnToMain( $auto = true )
 564         {
 565                 global $wgUser, $wgOut, $returnto;
 566
 567                 $sk = $wgUser->getSkin();
 568                 if ( "" == $returnto ) {
 569                         $returnto = wfMsg( "mainpage" );
 570                 }
 571                 $link = $sk->makeKnownLink( $returnto, "" );
 572
 573                 $r = wfMsg( "returnto", $link );
 574                 if ( $auto ) {
 575                         $wgOut->addMeta( "http:Refresh", "10;url=" .
 576                           wfLocalUrlE( wfUrlencode( $returnto ) ) );
 577                 }
 578                 $wgOut->addHTML( "\n<p>$r\n" );
 579         }
 580
 581
 582         function categoryMagic ()
 583         {
 584                 global $wgTitle , $wgUseCategoryMagic ;
 585                 if ( !isset ( $wgUseCategoryMagic ) || !$wgUseCategoryMagic ) return ;
 586                 $id = $wgTitle->getArticleID() ;
 587                 $cat = ucfirst ( wfMsg ( "category" ) ) ;
 588                 $ti = $wgTitle->getText() ;
 589                 $ti = explode ( ":" , $ti , 2 ) ;
 590                 if ( $cat != $ti[0] ) return "" ;
 591                 $r = "<br break=all>\n" ;
 592
 593                 $articles = array() ;
 594                 $parents = array () ;
 595                 $children = array() ;
 596
 597
 598                 global $wgUser ;
 599                 $sk = $wgUser->getSkin() ;
 600                 $sql = "SELECT l_from FROM links WHERE l_to={$id}" ;
 601                 $res = wfQuery ( $sql, DB_READ ) ;
 602                 while ( $x = wfFetchObject ( $res ) )
 603                 {
 604                 #  $t = new Title ;
 605                 #  $t->newFromDBkey ( $x->l_from ) ;
 606                 #  $t = $t->getText() ;
 607                         $t = $x->l_from ;
 608                         $y = explode ( ":" , $t , 2 ) ;
 609                         if ( count ( $y ) == 2 && $y[0] == $cat ) {
 610                                 array_push ( $children , $sk->makeLink ( $t , $y[1] ) ) ;
 611                         } else {
 612                                 array_push ( $articles , $sk->makeLink ( $t ) ) ;
 613                         }
 614                 }
 615                 wfFreeResult ( $res ) ;
 616
 617                 # Children
 618                 if ( count ( $children ) > 0 )
 619                 {
 620                         asort ( $children ) ;
 621                         $r .= "<h2>".wfMsg("subcategories")."</h2>\n" ;
 622                         $r .= implode ( ", " , $children ) ;
 623                 }
 624
 625                 # Articles
 626                 if ( count ( $articles ) > 0 )
 627                 {
 628                         asort ( $articles ) ;
 629                         $h =  wfMsg( "category_header", $ti[1] );
 630                         $r .= "<h2>{$h}</h2>\n" ;
 631                         $r .= implode ( ", " , $articles ) ;
 632                 }
 633
 634
 635                 return $r ;
 636         }
 637
 638 function getHTMLattrs ()
 639 {
 640                 $htmlattrs = array( # Allowed attributes--no scripting, etc.
 641                         "title", "align", "lang", "dir", "width", "height",
 642                         "bgcolor", "clear", /* BR */ "noshade", /* HR */
 643                         "cite", /* BLOCKQUOTE, Q */ "size", "face", "color",
 644                         /* FONT */ "type", "start", "value", "compact",
 645                         /* For various lists, mostly deprecated but safe */
 646                         "summary", "width", "border", "frame", "rules",
 647                         "cellspacing", "cellpadding", "valign", "char",
 648                         "charoff", "colgroup", "col", "span", "abbr", "axis",
 649                         "headers", "scope", "rowspan", "colspan", /* Tables */
 650                         "id", "class", "name", "style" /* For CSS */
 651                 );
 652 return $htmlattrs ;
 653 }
 654
 655 function fixTagAttributes ( $t )
 656 {
 657         if ( trim ( $t ) == "" ) return "" ; # Saves runtime ;-)
 658         $htmlattrs = $this->getHTMLattrs() ;
 659
 660         # Strip non-approved attributes from the tag
 661         $t = preg_replace(
 662                 "/(\\w+)(\\s*=\\s*([^\\s\">]+|\"[^\">]*\"))?/e",
 663                 "(in_array(strtolower(\"\$1\"),\$htmlattrs)?(\"\$1\".((\"x\$3\" != \"x\")?\"=\$3\":'')):'')",
 664                 $t);
 665         # Strip javascript "expression" from stylesheets. Brute force approach:
 666         # If anythin offensive is found, all attributes of the HTML tag are dropped
 667
 668         if( preg_match(
 669                 "/style\\s*=.*(expression|tps*:\/\/|url\\s*\().*/is",
 670                 wfMungeToUtf8( $t ) ) )
 671         {
 672                 $t="";
 673         }
 674
 675         return trim ( $t ) ;
 676 }
 677
 678 function doTableStuff ( $t )
 679 {
 680   $t = explode ( "\n" , $t ) ;
 681   $td = array () ; # Is currently a td tag open?
 682   $ltd = array () ; # Was it TD or TH?
 683   $tr = array () ; # Is currently a tr tag open?
 684   $ltr = array () ; # tr attributes
 685   foreach ( $t AS $k => $x )
 686     {
 687       $x = rtrim ( $x ) ;
 688       $fc = substr ( $x , 0 , 1 ) ;
 689       if ( "{|" == substr ( $x , 0 , 2 ) )
 690         {
 691           $t[$k] = "<table " . $this->fixTagAttributes ( substr ( $x , 3 ) ) . ">" ;
 692           array_push ( $td , false ) ;
 693           array_push ( $ltd , "" ) ;
 694           array_push ( $tr , false ) ;
 695           array_push ( $ltr , "" ) ;
 696         }
 697       else if ( count ( $td ) == 0 ) { } # Don't do any of the following
 698       else if ( "|}" == substr ( $x , 0 , 2 ) )
 699         {
 700           $z = "</table>\n" ;
 701           $l = array_pop ( $ltd ) ;
 702           if ( array_pop ( $tr ) ) $z = "</tr>" . $z ;
 703           if ( array_pop ( $td ) ) $z = "</{$l}>" . $z ;
 704           array_pop ( $ltr ) ;
 705           $t[$k] = $z ;
 706         }
 707 /*      else if ( "|_" == substr ( $x , 0 , 2 ) ) # Caption
 708         {
 709         $z = trim ( substr ( $x , 2 ) ) ;
 710         $t[$k] = "<caption>{$z}</caption>\n" ;
 711         }*/
 712       else if ( "|-" == substr ( $x , 0 , 2 ) ) # Allows for |---------------
 713         {
 714           $x = substr ( $x , 1 ) ;
 715           while ( $x != "" && substr ( $x , 0 , 1 ) == '-' ) $x = substr ( $x , 1 ) ;
 716           $z = "" ;
 717           $l = array_pop ( $ltd ) ;
 718           if ( array_pop ( $tr ) ) $z = "</tr>" . $z ;
 719           if ( array_pop ( $td ) ) $z = "</{$l}>" . $z ;
 720           array_pop ( $ltr ) ;
 721           $t[$k] = $z ;
 722           array_push ( $tr , false ) ;
 723           array_push ( $td , false ) ;
 724           array_push ( $ltd , "" ) ;
 725           array_push ( $ltr , $this->fixTagAttributes ( $x ) ) ;
 726         }
 727       else if ( "|" == $fc || "!" == $fc || "|+" == substr ( $x , 0 , 2 ) ) # Caption
 728         {
 729           if ( "|+" == substr ( $x , 0 , 2 ) )
 730               {
 731               $fc = "+" ;
 732               $x = substr ( $x , 1 ) ;
 733               }
 734           $after = substr ( $x , 1 ) ;
 735           if ( $fc == "!" ) $after = str_replace ( "!!" , "||" , $after ) ;
 736           $after = explode ( "||" , $after ) ;
 737           $t[$k] = "" ;
 738           foreach ( $after AS $theline )
 739              {
 740           $z = "" ;
 741           if ( $fc != "+" )
 742           {
 743             $tra = array_pop ( $ltr ) ;
 744             if ( !array_pop ( $tr ) ) $z = "<tr {$tra}>\n" ;
 745             array_push ( $tr , true ) ;
 746             array_push ( $ltr , "" ) ;
 747           }
 748
 749           $l = array_pop ( $ltd ) ;
 750           if ( array_pop ( $td ) ) $z = "</{$l}>" . $z ;
 751           if ( $fc == "|" ) $l = "TD" ;
 752           else if ( $fc == "!" ) $l = "TH" ;
 753           else if ( $fc == "+" ) $l = "CAPTION" ;
 754           else $l = "" ;
 755           array_push ( $ltd , $l ) ;
 756           $y = explode ( "|" , $theline , 2 ) ;
 757           if ( count ( $y ) == 1 ) $y = "{$z}<{$l}>{$y[0]}" ;
 758           else $y = $y = "{$z}<{$l} ".$this->fixTagAttributes($y[0]).">{$y[1]}" ;
 759           $t[$k] .= $y ;
 760           array_push ( $td , true ) ;
 761              }
 762         }
 763     }
 764
 765 # Closing open td, tr && table
 766 while ( count ( $td ) > 0 )
 767 {
 768 if ( array_pop ( $td ) ) $t[] = "</td>" ;
 769 if ( array_pop ( $tr ) ) $t[] = "</tr>" ;
 770 $t[] = "</table>" ;
 771 }
 772
 773   $t = implode ( "\n" , $t ) ;
 774 #               $t = $this->removeHTMLtags( $t );
 775   return $t ;
 776 }
 777
 778         # Well, OK, it's actually about 14 passes.  But since all the
 779         # hard lifting is done inside PHP's regex code, it probably
 780         # wouldn't speed things up much to add a real parser.
 781         #
 782         function doWikiPass2( $text, $linestart )
 783         {
 784                 global $wgUser, $wgLang, $wgUseDynamicDates;
 785                 $fname = "OutputPage::doWikiPass2";
 786                 wfProfileIn( $fname );
 787
 788                 $text = $this->removeHTMLtags( $text );
 789                 $text = $this->replaceVariables( $text );
 790
 791                 $text = preg_replace( "/(^|\n)-----*/", "\\1<hr>", $text );
 792                 $text = str_replace ( "<HR>", "<hr>", $text );
 793
 794                 $text = $this->doAllQuotes( $text );
 795                 $text = $this->doHeadings( $text );
 796                 $text = $this->doBlockLevels( $text, $linestart );
 797
 798                 if($wgUseDynamicDates) {
 799                         global $wgDateFormatter;
 800                         $text = $wgDateFormatter->reformat( $wgUser->getOption("date"), $text );
 801                 }
 802
 803                 $text = $this->replaceExternalLinks( $text );
 804                 $text = $this->replaceInternalLinks ( $text );
 805                 $text = $this->doTableStuff ( $text ) ;
 806
 807                 $text = $this->magicISBN( $text );
 808                 $text = $this->magicRFC( $text );
 809                 $text = $this->formatHeadings( $text );
 810
 811                 $sk = $wgUser->getSkin();
 812                 $text = $sk->transformContent( $text );
 813                 $text .= $this->categoryMagic () ;
 814
 815                 wfProfileOut( $fname );
 816                 return $text;
 817         }
 818
 819         /* private */ function doAllQuotes( $text )
 820         {
 821                 $outtext = "";
 822                 $lines = explode( "\r\n", $text );
 823                 foreach ( $lines as $line ) {
 824                         $outtext .= $this->doQuotes ( "", $line, "" ) . "\r\n";
 825                 }
 826                 return $outtext;
 827         }
 828
 829         /* private */ function doQuotes( $pre, $text, $mode )
 830         {
 831                 if ( preg_match( "/^(.*)''(.*)$/sU", $text, $m ) ) {
 832                         $m1_strong = ($m[1] == "") ? "" : "<strong>{$m[1]}</strong>";
 833                         $m1_em = ($m[1] == "") ? "" : "<em>{$m[1]}</em>";
 834                         if ( substr ($m[2], 0, 1) == "'" ) {
 835                                 $m[2] = substr ($m[2], 1);
 836                                 if ($mode == "em") {
 837                                         return $this->doQuotes ( $m[1], $m[2], ($m[1] == "") ? "both" : "emstrong" );
 838                                 } else if ($mode == "strong") {
 839                                         return $m1_strong . $this->doQuotes ( "", $m[2], "" );
 840                                 } else if (($mode == "emstrong") || ($mode == "both")) {
 841                                         return $this->doQuotes ( "", $pre.$m1_strong.$m[2], "em" );
 842                                 } else if ($mode == "strongem") {
 843                                         return "<strong>{$pre}{$m1_em}</strong>" . $this->doQuotes ( "", $m[2], "em" );
 844                                 } else {
 845                                         return $m[1] . $this->doQuotes ( "", $m[2], "strong" );
 846                                 }
 847                         } else {
 848                                 if ($mode == "strong") {
 849                                         return $this->doQuotes ( $m[1], $m[2], ($m[1] == "") ? "both" : "strongem" );
 850                                 } else if ($mode == "em") {
 851                                         return $m1_em . $this->doQuotes ( "", $m[2], "" );
 852                                 } else if ($mode == "emstrong") {
 853                                         return "<em>{$pre}{$m1_strong}</em>" . $this->doQuotes ( "", $m[2], "strong" );
 854                                 } else if (($mode == "strongem") || ($mode == "both")) {
 855                                         return $this->doQuotes ( "", $pre.$m1_em.$m[2], "strong" );
 856                                 } else {
 857                                         return $m[1] . $this->doQuotes ( "", $m[2], "em" );
 858                                 }
 859                         }
 860                 } else {
 861                         $text_strong = ($text == "") ? "" : "<strong>{$text}</strong>";
 862                         $text_em = ($text == "") ? "" : "<em>{$text}</em>";
 863                         if ($mode == "") {
 864                                 return $pre . $text;
 865                         } else if ($mode == "em") {
 866                                 return $pre . $text_em;
 867                         } else if ($mode == "strong") {
 868                                 return $pre . $text_strong;
 869                         } else if ($mode == "strongem") {
 870                                 return (($pre == "") && ($text == "")) ? "" : "<strong>{$pre}{$text_em}</strong>";
 871                         } else {
 872                                 return (($pre == "") && ($text == "")) ? "" : "<em>{$pre}{$text_strong}</em>";
 873                         }
 874                 }
 875         }
 876
 877         /* private */ function doHeadings( $text )
 878         {
 879                 for ( $i = 6; $i >= 1; --$i ) {
 880                         $h = substr( "======", 0, $i );
 881                         $text = preg_replace( "/^{$h}([^=]+){$h}(\\s|$)/m",
 882                           "<h{$i}>\\1</h{$i}>\\2", $text );
 883                 }
 884                 return $text;
 885         }
 886
 887         # Note: we have to do external links before the internal ones,
 888         # and otherwise take great care in the order of things here, so
 889         # that we don't end up interpreting some URLs twice.
 890
 891         /* private */ function replaceExternalLinks( $text )
 892         {
 893                 $fname = "OutputPage::replaceExternalLinks";
 894                 wfProfileIn( $fname );
 895                 $text = $this->subReplaceExternalLinks( $text, "http", true );
 896                 $text = $this->subReplaceExternalLinks( $text, "https", true );
 897                 $text = $this->subReplaceExternalLinks( $text, "ftp", false );
 898                 $text = $this->subReplaceExternalLinks( $text, "irc", false );
 899                 $text = $this->subReplaceExternalLinks( $text, "gopher", false );
 900                 $text = $this->subReplaceExternalLinks( $text, "news", false );
 901                 $text = $this->subReplaceExternalLinks( $text, "mailto", false );
 902                 wfProfileOut( $fname );
 903                 return $text;
 904         }
 905
 906         /* private */ function subReplaceExternalLinks( $s, $protocol, $autonumber )
 907         {
 908                 global $wgUser, $printable;
 909                 global $wgAllowExternalImages;
 910
 911
 912                 $unique = "4jzAfzB8hNvf4sqyO9Edd8pSmk9rE2in0Tgw3";
 913                 $uc = "A-Za-z0-9_\\/~%\\-+&*#?!=()@\\x80-\\xFF";
 914
 915                 # this is  the list of separators that should be ignored if they
 916                 # are the last character of an URL but that should be included
 917                 # if they occur within the URL, e.g. "go to www.foo.com, where .."
 918                 # in this case, the last comma should not become part of the URL,
 919                 # but in "www.foo.com/123,2342,32.htm" it should.
 920                 $sep = ",;\.:";
 921                 $fnc = "A-Za-z0-9_.,~%\\-+&;#*?!=()@\\x80-\\xFF";
 922                 $images = "gif|png|jpg|jpeg";
 923
 924                 # PLEASE NOTE: The curly braces { } are not part of the regex,
 925                 # they are interpreted as part of the string (used to tell PHP
 926                 # that the content of the string should be inserted there).
 927                 $e1 = "/(^|[^\\[])({$protocol}:)([{$uc}{$sep}]+)\\/([{$fnc}]+)\\." .
 928                   "((?i){$images})([^{$uc}]|$)/";
 929
 930                 $e2 = "/(^|[^\\[])({$protocol}:)(([".$uc."]|[".$sep."][".$uc."])+)([^". $uc . $sep. "]|[".$sep."]|$)/";
 931                 $sk = $wgUser->getSkin();
 932
 933                 if ( $autonumber and $wgAllowExternalImages) { # Use img tags only for HTTP urls
 934                         $s = preg_replace( $e1, "\\1" . $sk->makeImage( "{$unique}:\\3" .
 935                           "/\\4.\\5", "\\4.\\5" ) . "\\6", $s );
 936                 }
 937                 $s = preg_replace( $e2, "\\1" . "<a href=\"{$unique}:\\3\"" .
 938                   $sk->getExternalLinkAttributes( "{$unique}:\\3", wfEscapeHTML(
 939                   "{$unique}:\\3" ) ) . ">" . wfEscapeHTML( "{$unique}:\\3" ) .
 940                   "</a>\\5", $s );
 941                 $s = str_replace( $unique, $protocol, $s );
 942
 943                 $a = explode( "[{$protocol}:", " " . $s );
 944                 $s = array_shift( $a );
 945                 $s = substr( $s, 1 );
 946
 947                 $e1 = "/^([{$uc}"."{$sep}]+)](.*)\$/sD";
 948                 $e2 = "/^([{$uc}"."{$sep}]+)\\s+([^\\]]+)](.*)\$/sD";
 949
 950                 foreach ( $a as $line ) {
 951                         if ( preg_match( $e1, $line, $m ) ) {
 952                                 $link = "{$protocol}:{$m[1]}";
 953                                 $trail = $m[2];
 954                                 if ( $autonumber ) { $text = "[" . ++$this->mAutonumber . "]"; }
 955                                 else { $text = wfEscapeHTML( $link ); }
 956                         } else if ( preg_match( $e2, $line, $m ) ) {
 957                                 $link = "{$protocol}:{$m[1]}";
 958                                 $text = $m[2];
 959                                 $trail = $m[3];
 960                         } else {
 961                                 $s .= "[{$protocol}:" . $line;
 962                                 continue;
 963                         }
 964                         if ( $printable == "yes") $paren = " (<i>" . htmlspecialchars ( $link ) . "</i>)";
 965                         else $paren = "";
 966                         $la = $sk->getExternalLinkAttributes( $link, $text );
 967                         $s .= "<a href='{$link}'{$la}>{$text}</a>{$paren}{$trail}";
 968
 969                 }
 970                 return $s;
 971         }
 972
 973         /* private */ function replaceInternalLinks( $s )
 974         {
 975                 global $wgTitle, $wgUser, $wgLang;
 976                 global $wgLinkCache, $wgInterwikiMagic, $wgUseCategoryMagic;
 977                 global $wgNamespacesWithSubpages, $wgLanguageCode;
 978                 wfProfileIn( $fname = "OutputPage::replaceInternalLinks" );
 979
 980                 wfProfileIn( "$fname-setup" );
 981                 $tc = Title::legalChars() . "#";
 982                 $sk = $wgUser->getSkin();
 983
 984                 $a = explode( "[[", " " . $s );
 985                 $s = array_shift( $a );
 986                 $s = substr( $s, 1 );
 987
 988                 $e1 = "/^([{$tc}]+)(?:\\|([^]]+))?]](.*)\$/sD";
 989
 990                 # Special and Media are pseudo-namespaces; no pages actually exist in them
 991                 $image = Namespace::getImage();
 992                 $special = Namespace::getSpecial();
 993                 $media = Namespace::getMedia();
 994                 $nottalk = !Namespace::isTalk( $wgTitle->getNamespace() );
 995                 wfProfileOut( "$fname-setup" );
 996
 997                 foreach ( $a as $line ) {
 998                         if ( preg_match( $e1, $line, $m ) ) { # page with normal text or alt
 999                                 $text = $m[2];
1000                                 $trail = $m[3];
1001                         } else { # Invalid form; output directly
1002                                 $s .= "[[" . $line ;
1003                                 continue;
1004                         }
1005
1006                         /* Valid link forms:
1007                         Foobar -- normal
1008                         :Foobar -- override special treatment of prefix (images, language links)
1009                         /Foobar -- convert to CurrentPage/Foobar
1010                         /Foobar/ -- convert to CurrentPage/Foobar, strip the initial / from text
1011                         */
1012                         $c = substr($m[1],0,1);
1013                         $noforce = ($c != ":");
1014                         if( $c == "/" ) { # subpage
1015                                 if(substr($m[1],-1,1)=="/") {                 # / at end means we don't want the slash to be shown
1016                                         $m[1]=substr($m[1],1,strlen($m[1])-2);
1017                                         $noslash=$m[1];
1018                                 } else {
1019                                         $noslash=substr($m[1],1);
1020                                 }
1021                                 if($wgNamespacesWithSubpages[$wgTitle->getNamespace()]) { # subpages allowed here
1022                                         $link = $wgTitle->getPrefixedText(). "/" . trim($noslash);
1023                                         if( "" == $text ) {
1024                                                 $text= $m[1];
1025                                         } # this might be changed for ugliness reasons
1026                                 } else {
1027                                         $link = $noslash; # no subpage allowed, use standard link
1028                                 }
1029                         } elseif( $noforce ) { # no subpage
1030                                 $link = $m[1];
1031                         } else {
1032                                 $link = substr( $m[1], 1 );
1033                         }
1034                         if( "" == $text )
1035                                 $text = $link;
1036
1037                         $nt = Title::newFromText( $link );
1038                         if( !$nt ) {
1039                                 $s .= "[[" . $line;
1040                                 continue;
1041                         }
1042                         $ns = $nt->getNamespace();
1043                         $iw = $nt->getInterWiki();
1044                         if( $noforce ) {
1045                                 if( $iw && $wgInterwikiMagic && $nottalk && $wgLang->getLanguageName( $iw ) ) {
1046                                         array_push( $this->mLanguageLinks, $nt->getPrefixedText() );
1047                                         $s .= $trail;
1048                                         continue;
1049                                 }
1050                                 if( $ns == $image ) {
1051                                         $s .= $sk->makeImageLinkObj( $nt, $text ) . $trail;
1052                                         $wgLinkCache->addImageLinkObj( $nt );
1053                                         continue;
1054                                 }
1055                         }
1056                         if( ( $nt->getPrefixedText() == $wgTitle->getPrefixedText() ) &&
1057                             ( strpos( $link, "#" ) == FALSE ) ) {
1058                                 $s .= "<strong>" . $text . "</strong>" . $trail;
1059                                 continue;
1060                         }
1061                         if( $ns == $media ) {
1062                                 $s .= $sk->makeMediaLinkObj( $nt, $text ) . $trail;
1063                                 $wgLinkCache->addImageLinkObj( $nt );
1064                                 continue;
1065                         } elseif( $ns == $special ) {
1066                                 $s .= $sk->makeKnownLinkObj( $nt, $text, "", $trail );
1067                                 continue;
1068                         }
1069                         $s .= $sk->makeLinkObj( $nt, $text, "", $trail );
1070                 }
1071                 wfProfileOut( $fname );
1072                 return $s;
1073         }
1074
1075         # Some functions here used by doBlockLevels()
1076         #
1077         /* private */ function closeParagraph()
1078         {
1079                 $result = "";
1080                 if ( 0 != strcmp( "p", $this->mLastSection ) &&
1081                   0 != strcmp( "", $this->mLastSection ) ) {
1082                         $result = "</" . $this->mLastSection  . ">";
1083                 }
1084                 $this->mLastSection = "";
1085                 return $result."\n";
1086         }
1087         # getCommon() returns the length of the longest common substring
1088         # of both arguments, starting at the beginning of both.
1089         #
1090         /* private */ function getCommon( $st1, $st2 )
1091         {
1092                 $fl = strlen( $st1 );
1093                 $shorter = strlen( $st2 );
1094                 if ( $fl < $shorter ) { $shorter = $fl; }
1095
1096                 for ( $i = 0; $i < $shorter; ++$i ) {
1097                         if ( $st1{$i} != $st2{$i} ) { break; }
1098                 }
1099                 return $i;
1100         }
1101         # These next three functions open, continue, and close the list
1102         # element appropriate to the prefix character passed into them.
1103         #
1104         /* private */ function openList( $char )
1105     {
1106                 $result = $this->closeParagraph();
1107
1108                 if ( "*" == $char ) { $result .= "<ul><li>"; }
1109                 else if ( "#" == $char ) { $result .= "<ol><li>"; }
1110                 else if ( ":" == $char ) { $result .= "<dl><dd>"; }
1111                 else if ( ";" == $char ) {
1112                         $result .= "<dl><dt>";
1113                         $this->mDTopen = true;
1114                 }
1115                 else { $result = "<!-- ERR 1 -->"; }
1116
1117                 return $result;
1118         }
1119
1120         /* private */ function nextItem( $char )
1121         {
1122                 if ( "*" == $char || "#" == $char ) { return "</li><li>"; }
1123                 else if ( ":" == $char || ";" == $char ) {
1124                         $close = "</dd>";
1125                         if ( $this->mDTopen ) { $close = "</dt>"; }
1126                         if ( ";" == $char ) {
1127                                 $this->mDTopen = true;
1128                                 return $close . "<dt>";
1129                         } else {
1130                                 $this->mDTopen = false;
1131                                 return $close . "<dd>";
1132                         }
1133                 }
1134                 return "<!-- ERR 2 -->";
1135         }
1136
1137         /* private */function closeList( $char )
1138         {
1139                 if ( "*" == $char ) { $text = "</li></ul>"; }
1140                 else if ( "#" == $char ) { $text = "</li></ol>"; }
1141                 else if ( ":" == $char ) {
1142                         if ( $this->mDTopen ) {
1143                                 $this->mDTopen = false;
1144                                 $text = "</dt></dl>";
1145                         } else {
1146                                 $text = "</dd></dl>";
1147                         }
1148                 }
1149                 else {  return "<!-- ERR 3 -->"; }
1150                 return $text."\n";
1151         }
1152
1153         /* private */ function doBlockLevels( $text, $linestart )
1154         {
1155                 $fname = "OutputPage::doBlockLevels";
1156                 wfProfileIn( $fname );
1157                 # Parsing through the text line by line.  The main thing
1158                 # happening here is handling of block-level elements p, pre,
1159                 # and making lists from lines starting with * # : etc.
1160                 #
1161                 $a = explode( "\n", $text );
1162                 $text = $lastPref = "";
1163                 $this->mDTopen = $inBlockElem = false;
1164
1165                 if ( ! $linestart ) { $text .= array_shift( $a ); }
1166                 foreach ( $a as $t ) {
1167                         if ( "" != $text ) { $text .= "\n"; }
1168
1169                         $oLine = $t;
1170                         $opl = strlen( $lastPref );
1171                         $npl = strspn( $t, "*#:;" );
1172                         $pref = substr( $t, 0, $npl );
1173                         $pref2 = str_replace( ";", ":", $pref );
1174                         $t = substr( $t, $npl );
1175
1176                         if ( 0 != $npl && 0 == strcmp( $lastPref, $pref2 ) ) {
1177                                 $text .= $this->nextItem( substr( $pref, -1 ) );
1178
1179                                 if ( ";" == substr( $pref, -1 ) ) {
1180                                         $cpos = strpos( $t, ":" );
1181                                         if ( ! ( false === $cpos ) ) {
1182                                                 $term = substr( $t, 0, $cpos );
1183                                                 $text .= $term . $this->nextItem( ":" );
1184                                                 $t = substr( $t, $cpos + 1 );
1185                                         }
1186                                 }
1187                         } else if (0 != $npl || 0 != $opl) {
1188                                 $cpl = $this->getCommon( $pref, $lastPref );
1189
1190                                 while ( $cpl < $opl ) {
1191                                         $text .= $this->closeList( $lastPref{$opl-1} );
1192                                         --$opl;
1193                                 }
1194                                 if ( $npl <= $cpl && $cpl > 0 ) {
1195                                         $text .= $this->nextItem( $pref{$cpl-1} );
1196                                 }
1197                                 while ( $npl > $cpl ) {
1198                                         $char = substr( $pref, $cpl, 1 );
1199                                         $text .= $this->openList( $char );
1200
1201                                         if ( ";" == $char ) {
1202                                                 $cpos = strpos( $t, ":" );
1203                                                 if ( ! ( false === $cpos ) ) {
1204                                                         $term = substr( $t, 0, $cpos );
1205                                                         $text .= $term . $this->nextItem( ":" );
1206                                                         $t = substr( $t, $cpos + 1 );
1207                                                 }
1208                                         }
1209                                         ++$cpl;
1210                                 }
1211                                 $lastPref = $pref2;
1212                         }
1213                         if ( 0 == $npl ) { # No prefix--go to paragraph mode
1214                                 if ( preg_match(
1215                                   "/(<table|<blockquote|<h1|<h2|<h3|<h4|<h5|<h6)/i", $t ) ) {
1216                                         $text .= $this->closeParagraph();
1217                                         $inBlockElem = true;
1218                                 }
1219                                 if ( ! $inBlockElem ) {
1220                                         if ( " " == $t{0} ) {
1221                                                 $newSection = "pre";
1222                                                 # $t = wfEscapeHTML( $t );
1223                                         }
1224                                         else { $newSection = "p"; }
1225
1226                                         if ( 0 == strcmp( "", trim( $oLine ) ) ) {
1227                                                 $text .= $this->closeParagraph();
1228                                                 $text .= "<" . $newSection . ">";
1229                                         } else if ( 0 != strcmp( $this->mLastSection,
1230                                           $newSection ) ) {
1231                                                 $text .= $this->closeParagraph();
1232                                                 if ( 0 != strcmp( "p", $newSection ) ) {
1233                                                         $text .= "<" . $newSection . ">";
1234                                                 }
1235                                         }
1236                                         $this->mLastSection = $newSection;
1237                                 }
1238                                 if ( $inBlockElem &&
1239                                   preg_match( "/(<\\/table|<\\/blockquote|<\\/h1|<\\/h2|<\\/h3|<\\/h4|<\\/h5|<\\/h6)/i", $t ) ) {
1240                                         $inBlockElem = false;
1241                                 }
1242                         }
1243                         $text .= $t;
1244                 }
1245                 while ( $npl ) {
1246                         $text .= $this->closeList( $pref2{$npl-1} );
1247                         --$npl;
1248                 }
1249                 if ( "" != $this->mLastSection ) {
1250                         if ( "p" != $this->mLastSection ) {
1251                                 $text .= "</" . $this->mLastSection . ">";
1252                         }
1253                         $this->mLastSection = "";
1254                 }
1255                 wfProfileOut( $fname );
1256                 return $text;
1257         }
1258
1259         /* private */ function replaceVariables( $text )
1260         {
1261                 global $wgLang, $wgCurOut;
1262                 $fname = "OutputPage::replaceVariables";
1263                 wfProfileIn( $fname );
1264
1265                 $magic = array();
1266
1267                 # Basic variables
1268                 # See Language.php for the definition of each magic word
1269                 # As with sigs, this uses the server's local time -- ensure
1270                 # this is appropriate for your audience!
1271
1272                 $magic[MAG_CURRENTMONTH] = date( "m" );
1273                 $magic[MAG_CURRENTMONTHNAME] = $wgLang->getMonthName( date("n") );
1274                 $magic[MAG_CURRENTMONTHNAMEGEN] = $wgLang->getMonthNameGen( date("n") );
1275                 $magic[MAG_CURRENTDAY] = date("j");
1276                 $magic[MAG_CURRENTDAYNAME] = $wgLang->getWeekdayName( date("w")+1 );
1277                 $magic[MAG_CURRENTYEAR] = date( "Y" );
1278                 $magic[MAG_CURRENTTIME] = $wgLang->time( wfTimestampNow(), false );
1279
1280                 $this->mContainsOldMagic += MagicWord::replaceMultiple($magic, $text, $text);
1281
1282                 $mw =& MagicWord::get( MAG_NUMBEROFARTICLES );
1283                 if ( $mw->match( $text ) ) {
1284                         $v = wfNumberOfArticles();
1285                         $text = $mw->replace( $v, $text );
1286                         if( $mw->getWasModified() ) { $this->mContainsOldMagic++; }
1287                 }
1288
1289                 # "Variables" with an additional parameter e.g. {{MSG:wikipedia}}
1290                 # The callbacks are at the bottom of this file
1291                 $wgCurOut = $this;
1292                 $mw =& MagicWord::get( MAG_MSG );
1293                 $text = $mw->substituteCallback( $text, "wfReplaceMsgVar" );
1294                 if( $mw->getWasModified() ) { $this->mContainsNewMagic++; }
1295
1296                 $mw =& MagicWord::get( MAG_MSGNW );
1297                 $text = $mw->substituteCallback( $text, "wfReplaceMsgnwVar" );
1298                 if( $mw->getWasModified() ) { $this->mContainsNewMagic++; }
1299
1300                 wfProfileOut( $fname );
1301                 return $text;
1302         }
1303
1304         # Cleans up HTML, removes dangerous tags and attributes
1305         /* private */ function removeHTMLtags( $text )
1306         {
1307                 $fname = "OutputPage::removeHTMLtags";
1308                 wfProfileIn( $fname );
1309                 $htmlpairs = array( # Tags that must be closed
1310                         "b", "i", "u", "font", "big", "small", "sub", "sup", "h1",
1311                         "h2", "h3", "h4", "h5", "h6", "cite", "code", "em", "s",
1312                         "strike", "strong", "tt", "var", "div", "center",
1313                         "blockquote", "ol", "ul", "dl", "table", "caption", "pre",
1314                         "ruby", "rt" , "rb" , "rp"
1315                 );
1316                 $htmlsingle = array(
1317                         "br", "p", "hr", "li", "dt", "dd"
1318                 );
1319                 $htmlnest = array( # Tags that can be nested--??
1320                         "table", "tr", "td", "th", "div", "blockquote", "ol", "ul",
1321                         "dl", "font", "big", "small", "sub", "sup"
1322                 );
1323                 $tabletags = array( # Can only appear inside table
1324                         "td", "th", "tr"
1325                 );
1326
1327                 $htmlsingle = array_merge( $tabletags, $htmlsingle );
1328                 $htmlelements = array_merge( $htmlsingle, $htmlpairs );
1329
1330                 $htmlattrs = $this->getHTMLattrs () ;
1331
1332                 # Remove HTML comments
1333                 $text = preg_replace( "/<!--.*-->/sU", "", $text );
1334
1335                 $bits = explode( "<", $text );
1336                 $text = array_shift( $bits );
1337                 $tagstack = array(); $tablestack = array();
1338
1339                 foreach ( $bits as $x ) {
1340                         $prev = error_reporting( E_ALL & ~( E_NOTICE | E_WARNING ) );
1341                         preg_match( "/^(\\/?)(\\w+)([^>]*)(\\/{0,1}>)([^<]*)$/",
1342                           $x, $regs );
1343                         list( $qbar, $slash, $t, $params, $brace, $rest ) = $regs;
1344                         error_reporting( $prev );
1345
1346                         $badtag = 0 ;
1347                         if ( in_array( $t = strtolower( $t ), $htmlelements ) ) {
1348                                 # Check our stack
1349                                 if ( $slash ) {
1350                                         # Closing a tag...
1351                                         if ( ! in_array( $t, $htmlsingle ) &&
1352                                           ( $ot = array_pop( $tagstack ) ) != $t ) {
1353                                                 array_push( $tagstack, $ot );
1354                                                 $badtag = 1;
1355                                         } else {
1356                                                 if ( $t == "table" ) {
1357                                                         $tagstack = array_pop( $tablestack );
1358                                                 }
1359                                                 $newparams = "";
1360                                         }
1361                                 } else {
1362                                         # Keep track for later
1363                                         if ( in_array( $t, $tabletags ) &&
1364                                           ! in_array( "table", $tagstack ) ) {
1365                                                 $badtag = 1;
1366                                         } else if ( in_array( $t, $tagstack ) &&
1367                                           ! in_array ( $t , $htmlnest ) ) {
1368                                                 $badtag = 1 ;
1369                                         } else if ( ! in_array( $t, $htmlsingle ) ) {
1370                                                 if ( $t == "table" ) {
1371                                                         array_push( $tablestack, $tagstack );
1372                                                         $tagstack = array();
1373                                                 }
1374                                                 array_push( $tagstack, $t );
1375                                         }
1376                                         # Strip non-approved attributes from the tag
1377                                         $newparams = $this->fixTagAttributes($params);
1378
1379                                 }
1380                                 if ( ! $badtag ) {
1381                                         $rest = str_replace( ">", "&gt;", $rest );
1382                                         $text .= "<$slash$t $newparams$brace$rest";
1383                                         continue;
1384                                 }
1385                         }
1386                         $text .= "&lt;" . str_replace( ">", "&gt;", $x);
1387                 }
1388                 # Close off any remaining tags
1389                 while ( $t = array_pop( $tagstack ) ) {
1390                         $text .= "</$t>\n";
1391                         if ( $t == "table" ) { $tagstack = array_pop( $tablestack ); }
1392                 }
1393                 wfProfileOut( $fname );
1394                 return $text;
1395         }
1396
1397 /*
1398  *
1399  * This function accomplishes several tasks:
1400  * 1) Auto-number headings if that option is enabled
1401  * 2) Add an [edit] link to sections for logged in users who have enabled the option
1402  * 3) Add a Table of contents on the top for users who have enabled the option
1403  * 4) Auto-anchor headings
1404  *
1405  * It loops through all headlines, collects the necessary data, then splits up the
1406  * string and re-inserts the newly formatted headlines.
1407  *
1408  * */
1409         /* private */ function formatHeadings( $text )
1410         {
1411                 global $wgUser,$wgArticle,$wgTitle,$wpPreview;
1412                 $nh=$wgUser->getOption( "numberheadings" );
1413                 $st=$wgUser->getOption( "showtoc" );
1414                 if(!$wgTitle->userCanEdit()) {
1415                         $es=0;
1416                         $esr=0;
1417                 } else {
1418                         $es=$wgUser->getID() && $wgUser->getOption( "editsection" );
1419                         $esr=$wgUser->getID() && $wgUser->getOption( "editsectiononrightclick" );
1420                 }
1421
1422                 # Inhibit editsection links if requested in the page
1423                 $esw =& MagicWord::get( MAG_NOEDITSECTION );
1424                 if ($esw->matchAndRemove( $text )) {
1425                         $es=0;
1426                 }
1427                 # if the string __NOTOC__ (not case-sensitive) occurs in the HTML,
1428                 # do not add TOC
1429                 $mw =& MagicWord::get( MAG_NOTOC );
1430                 if ($mw->matchAndRemove( $text ))
1431                 {
1432                         $st = 0;
1433                 }
1434
1435                 # never add the TOC to the Main Page. This is an entry page that should not
1436                 # be more than 1-2 screens large anyway
1437                 if($wgTitle->getPrefixedText()==wfMsg("mainpage")) {$st=0;}
1438
1439                 # We need this to perform operations on the HTML
1440                 $sk=$wgUser->getSkin();
1441
1442                 # Get all headlines for numbering them and adding funky stuff like [edit]
1443                 # links
1444                 preg_match_all("/<H([1-6])(.*?>)(.*?)<\/H[1-6]>/i",$text,$matches);
1445
1446                 # headline counter
1447                 $c=0;
1448
1449                 # Ugh .. the TOC should have neat indentation levels which can be
1450                 # passed to the skin functions. These are determined here
1451                 foreach($matches[3] as $headline) {
1452                         if($level) { $prevlevel=$level;}
1453                         $level=$matches[1][$c];
1454                         if(($nh||$st) && $prevlevel && $level>$prevlevel) {
1455
1456                                 $h[$level]=0; // reset when we enter a new level
1457                                 $toc.=$sk->tocIndent($level-$prevlevel);
1458                                 $toclevel+=$level-$prevlevel;
1459
1460                         }
1461                         if(($nh||$st) && $level<$prevlevel) {
1462                                 $h[$level+1]=0; // reset when we step back a level
1463                                 $toc.=$sk->tocUnindent($prevlevel-$level);
1464                                 $toclevel-=$prevlevel-$level;
1465
1466                         }
1467                         $h[$level]++; // count number of headlines for each level
1468
1469                         if($nh||$st) {
1470                                 for($i=1;$i<=$level;$i++) {
1471                                         if($h[$i]) {
1472                                                 if($dot) {$numbering.=".";}
1473                                                 $numbering.=$h[$i];
1474                                                 $dot=1;
1475                                         }
1476                                 }
1477                         }
1478
1479                         // The canonized header is a version of the header text safe to use for links
1480
1481                         $canonized_headline=preg_replace("/<.*?>/","",$headline); // strip out HTML
1482                         $tocline = trim( $canonized_headline );
1483                         $canonized_headline=str_replace('"',"",$canonized_headline);
1484                         $canonized_headline=str_replace(" ","_",trim($canonized_headline));
1485                         $refer[$c]=$canonized_headline;
1486                         $refers[$canonized_headline]++;  // count how many in assoc. array so we can track dupes in anchors
1487                         $refcount[$c]=$refers[$canonized_headline];
1488
1489             // Prepend the number to the heading text
1490
1491                         if($nh||$st) {
1492                                 $tocline=$numbering ." ". $tocline;
1493
1494                                 // Don't number the heading if it is the only one (looks silly)
1495                                 if($nh && count($matches[3]) > 1) {
1496                                         $headline=$numbering . " " . $headline; // the two are different if the line contains a link
1497                                 }
1498                         }
1499
1500                         // Create the anchor for linking from the TOC to the section
1501
1502                         $anchor=$canonized_headline;
1503                         if($refcount[$c]>1) {$anchor.="_".$refcount[$c];}
1504                         if($st) {
1505                                 $toc.=$sk->tocLine($anchor,$tocline,$toclevel);
1506                         }
1507                         if($es && !isset($wpPreview)) {
1508                                 $head[$c].=$sk->editSectionLink($c+1);
1509                         }
1510
1511                         // Put it all together
1512
1513                         $head[$c].="<h".$level.$matches[2][$c]
1514                          ."<a name=\"".$anchor."\">"
1515                          .$headline
1516                          ."</a>"
1517                          ."</h".$level.">";
1518
1519                         // Add the edit section link
1520
1521                         if($esr && !isset($wpPreview)) {
1522                                 $head[$c]=$sk->editSectionScript($c+1,$head[$c]);
1523                         }
1524
1525                         $numbering="";
1526                         $c++;
1527                         $dot=0;
1528                 }
1529
1530                 if($st) {
1531                         $toclines=$c;
1532                         $toc.=$sk->tocUnindent($toclevel);
1533                         $toc=$sk->tocTable($toc);
1534                 }
1535
1536                 // split up and insert constructed headlines
1537
1538                 $blocks=preg_split("/<H[1-6].*?>.*?<\/H[1-6]>/i",$text);
1539                 $i=0;
1540
1541                 foreach($blocks as $block) {
1542                         if(($es) && !isset($wpPreview) && $c>0 && $i==0) {
1543                             # This is the [edit] link that appears for the top block of text when
1544                                 # section editing is enabled
1545                                 $full.=$sk->editSectionLink(0);
1546                         }
1547                         $full.=$block;
1548                         if($st && $toclines>3 && !$i) {
1549                                 # Let's add a top anchor just in case we want to link to the top of the page
1550                                 $full="<a name=\"top\"></a>".$full.$toc;
1551                         }
1552
1553                         $full.=$head[$i];
1554                         $i++;
1555                 }
1556
1557                 return $full;
1558         }
1559
1560         /* private */ function magicISBN( $text )
1561         {
1562                 global $wgLang;
1563
1564                 $a = split( "ISBN ", " $text" );
1565                 if ( count ( $a ) < 2 ) return $text;
1566                 $text = substr( array_shift( $a ), 1);
1567                 $valid = "0123456789-ABCDEFGHIJKLMNOPQRSTUVWXYZ";
1568
1569                 foreach ( $a as $x ) {
1570                         $isbn = $blank = "" ;
1571                         while ( " " == $x{0} ) {
1572                                 $blank .= " ";
1573                                 $x = substr( $x, 1 );
1574                         }
1575                         while ( strstr( $valid, $x{0} ) != false ) {
1576                                 $isbn .= $x{0};
1577                                 $x = substr( $x, 1 );
1578                         }
1579                         $num = str_replace( "-", "", $isbn );
1580                         $num = str_replace( " ", "", $num );
1581
1582                         if ( "" == $num ) {
1583                                 $text .= "ISBN $blank$x";
1584                         } else {
1585                                 $text .= "<a href=\"" . wfLocalUrlE( $wgLang->specialPage(
1586                                   "Booksources"), "isbn={$num}" ) . "\" class=\"internal\">ISBN $isbn</a>";
1587                                 $text .= $x;
1588                         }
1589                 }
1590                 return $text;
1591         }
1592
1593         /* private */ function magicRFC( $text )
1594         {
1595                 return $text;
1596         }
1597
1598         /* private */ function headElement()
1599         {
1600                 global $wgDocType, $wgDTD, $wgUser, $wgLanguageCode, $wgOutputEncoding, $wgLang;
1601
1602                 $ret = "<!DOCTYPE HTML PUBLIC \"$wgDocType\"\n        \"$wgDTD\">\n";
1603
1604                 if ( "" == $this->mHTMLtitle ) {
1605                         $this->mHTMLtitle = $this->mPagetitle;
1606                 }
1607                 $rtl = $wgLang->isRTL() ? " dir='RTL'" : "";
1608                 $ret .= "<html lang=\"$wgLanguageCode\"$rtl><head><title>{$this->mHTMLtitle}</title>\n";
1609                 array_push( $this->mMetatags, array( "http:Content-type", "text/html; charset={$wgOutputEncoding}" ) );
1610                 foreach ( $this->mMetatags as $tag ) {
1611                         if ( 0 == strcasecmp( "http:", substr( $tag[0], 0, 5 ) ) ) {
1612                                 $a = "http-equiv";
1613                                 $tag[0] = substr( $tag[0], 5 );
1614                         } else {
1615                                 $a = "name";
1616                         }
1617                         $ret .= "<meta $a=\"{$tag[0]}\" content=\"{$tag[1]}\">\n";
1618                 }
1619                 $p = $this->mRobotpolicy;
1620                 if ( "" == $p ) { $p = "index,follow"; }
1621                 $ret .= "<meta name=\"robots\" content=\"$p\">\n";
1622
1623                 if ( count( $this->mKeywords ) > 0 ) {
1624                         $ret .= "<meta name=\"keywords\" content=\"" .
1625                           implode( ",", $this->mKeywords ) . "\">\n";
1626                 }
1627                 foreach ( $this->mLinktags as $tag ) {
1628                         $ret .= "<link ";
1629                         if ( "" != $tag[0] ) { $ret .= "rel=\"{$tag[0]}\" "; }
1630                         if ( "" != $tag[1] ) { $ret .= "rev=\"{$tag[1]}\" "; }
1631                         $ret .= "href=\"{$tag[2]}\">\n";
1632                 }
1633                 $sk = $wgUser->getSkin();
1634                 $ret .= $sk->getHeadScripts();
1635                 $ret .= $sk->getUserStyles();
1636
1637                 $ret .= "</head>\n";
1638                 return $ret;
1639         }
1640
1641         /* private */ function fillFromParserCache(){
1642                 global $wgUser, $wgArticle;
1643                 $hash = $wgUser->getPageRenderingHash();
1644                 $pageid = intval( $wgArticle->getID() );
1645                 $res = wfQuery("SELECT pc_data FROM parsercache WHERE pc_pageid = {$pageid} ".
1646                         " AND pc_prefhash = '{$hash}' AND pc_expire > NOW()", DB_WRITE);
1647                 $row = wfFetchObject ( $res );
1648                 if( $row ){
1649                         $data = unserialize( gzuncompress($row->pc_data) );
1650                         $this->addHTML( $data['html'] );
1651                         $this->mLanguageLinks = $data['mLanguageLinks'];
1652                         $this->mCategoryLinks = $data['mCategoryLinks'];
1653                         wfProfileOut( $fname );
1654                         return true;
1655                 } else {
1656                         return false;
1657                 }
1658         }
1659
1660         /* private */ function saveParserCache( $text ){
1661                 global $wgUser, $wgArticle;
1662                 $hash = $wgUser->getPageRenderingHash();
1663                 $pageid = intval( $wgArticle->getID() );
1664                 $title = wfStrencode( $wgArticle->mTitle->getPrefixedDBKey() );
1665                 $data = array();
1666                 $data['html'] = $text;
1667                 $data['mLanguageLinks'] = $this->mLanguageLinks;
1668                 $data['mCategoryLinks'] = $this->mCategoryLinks;
1669                 $ser = addslashes( gzcompress( serialize( $data ) ) );
1670                 if( $this->mContainsOldMagic ){
1671                         $expire = "1 HOUR";
1672                 } else if( $this->mContainsNewMagic ){
1673                         $expire = "1 DAY";
1674                 } else {
1675                         $expire = "7 DAY";
1676                 }
1677
1678                 wfQuery("REPLACE INTO parsercache (pc_prefhash,pc_pageid,pc_title,pc_data, pc_expire) ".
1679                         "VALUES('{$hash}', {$pageid}, '{$title}', '{$ser}', ".
1680                                 "DATE_ADD(NOW(), INTERVAL {$expire}))", DB_WRITE);
1681
1682                 if( rand() % 50 == 0 ){ // more efficient to just do it sometimes
1683                         $this->purgeParserCache();
1684                 }
1685         }
1686
1687         /* static private */ function purgeParserCache(){
1688                 wfQuery("DELETE FROM parsercache WHERE pc_expire < NOW() LIMIT 250", DB_WRITE);
1689         }
1690
1691         /* static */ function parsercacheClearLinksTo( $pid ){
1692                 $pid = intval( $pid );
1693                 wfQuery("DELETE parsercache FROM parsercache,links ".
1694                         "WHERE pc_title=links.l_from AND l_to={$pid}", DB_WRITE);
1695                 wfQuery("DELETE FROM parsercache WHERE pc_pageid='{$pid}'", DB_WRITE);
1696         }
1697
1698         # $title is a prefixed db title, for example like Title->getPrefixedDBkey() returns.
1699         /* static */ function parsercacheClearBrokenLinksTo( $title ){
1700                 $title = wfStrencode( $title );
1701                 wfQuery("DELETE parsercache FROM parsercache,brokenlinks ".
1702                         "WHERE pc_pageid=bl_from AND bl_to='{$title}'", DB_WRITE);
1703         }
1704
1705         # $pid is a page id
1706         /* static */ function parsercacheClearPage( $pid ){
1707                 $pid = intval( $pid );
1708                 wfQuery("DELETE FROM parsercache WHERE pc_pageid='{$pid}'", DB_WRITE);
1709         }
1710 }
1711
1712 # Regex callbacks, used in OutputPage::replaceVariables
1713
1714 # Just get rid of the dangerous stuff
1715 # Necessary because replaceVariables is called after removeHTMLtags,
1716 # and message text can come from any user
1717 function wfReplaceMsgVar( $matches ) {
1718         global $wgCurOut, $wgLinkCache;
1719         $text = $wgCurOut->removeHTMLtags( wfMsg( $matches[1] ) );
1720         $wgLinkCache->suspend();
1721         $text = $wgCurOut->replaceInternalLinks( $text );
1722         $wgLinkCache->resume();
1723         $wgLinkCache->addLinkObj( Title::makeTitle( NS_MEDIAWIKI, $matches[1] ) );
1724         return $text;
1725 }
1726
1727 # Effective <nowiki></nowiki>
1728 # Not real <nowiki> because this is called after nowiki sections are processed
1729 function wfReplaceMsgnwVar( $matches ) {
1730         global $wgCurOut, $wgLinkCache;
1731         $text = wfEscapeWikiText( wfMsg( $matches[1] ) );
1732         $wgLinkCache->addLinkObj( Title::makeTitle( NS_MEDIAWIKI, $matches[1] ) );
1733         return $text;
1734 }
1735
1736 ?>