includes/OutputPage.php

   1 <?php
   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                 $now = wfTime();
 405                 list( $usec, $sec ) = explode( " ", $wgRequestTime );
 406                 $start = (float)$sec + (float)$usec;
 407                 $elapsed = $now - $start;
 408                 $com = sprintf( "<!-- Time since request: %01.2f secs. -->",
 409                   $elapsed );
 410                 return $com;
 411         }
 412
 413         # Note: these arguments are keys into wfMsg(), not text!
 414         #
 415         function errorpage( $title, $msg )
 416         {
 417                 global $wgTitle;
 418
 419                 $this->mDebugtext .= "Original title: " .
 420                   $wgTitle->getPrefixedText() . "\n";
 421                 $this->setHTMLTitle( wfMsg( "errorpagetitle" ) );
 422                 $this->setPageTitle( wfMsg( $title ) );
 423                 $this->setRobotpolicy( "noindex,nofollow" );
 424                 $this->setArticleRelated( false );
 425
 426                 $this->mBodytext = "";
 427                 $this->addHTML( "<p>" . wfMsg( $msg ) . "\n" );
 428                 $this->returnToMain( false );
 429
 430                 $this->output();
 431                 wfAbruptExit();
 432         }
 433
 434         function sysopRequired()
 435         {
 436                 global $wgUser;
 437
 438                 $this->setHTMLTitle( wfMsg( "errorpagetitle" ) );
 439                 $this->setPageTitle( wfMsg( "sysoptitle" ) );
 440                 $this->setRobotpolicy( "noindex,nofollow" );
 441                 $this->setArticleRelated( false );
 442                 $this->mBodytext = "";
 443
 444                 $sk = $wgUser->getSkin();
 445                 $ap = $sk->makeKnownLink( wfMsg( "administrators" ), "" );
 446                 $this->addHTML( wfMsg( "sysoptext", $ap ) );
 447                 $this->returnToMain();
 448         }
 449
 450         function developerRequired()
 451         {
 452                 global $wgUser;
 453
 454                 $this->setHTMLTitle( wfMsg( "errorpagetitle" ) );
 455                 $this->setPageTitle( wfMsg( "developertitle" ) );
 456                 $this->setRobotpolicy( "noindex,nofollow" );
 457                 $this->setArticleRelated( false );
 458                 $this->mBodytext = "";
 459
 460                 $sk = $wgUser->getSkin();
 461                 $ap = $sk->makeKnownLink( wfMsg( "administrators" ), "" );
 462                 $this->addHTML( wfMsg( "developertext", $ap ) );
 463                 $this->returnToMain();
 464         }
 465
 466         function databaseError( $fname, &$conn )
 467         {
 468                 global $wgUser, $wgCommandLineMode;
 469
 470                 $this->setPageTitle( wfMsgNoDB( "databaseerror" ) );
 471                 $this->setRobotpolicy( "noindex,nofollow" );
 472                 $this->setArticleRelated( false );
 473
 474                 if ( $wgCommandLineMode ) {
 475                         $msg = wfMsgNoDB( "dberrortextcl" );
 476                 } else {
 477                         $msg = wfMsgNoDB( "dberrortext" );
 478                 }
 479
 480                 $msg = str_replace( "$1", htmlspecialchars( $conn->lastQuery() ), $msg );
 481                 $msg = str_replace( "$2", htmlspecialchars( $fname ), $msg );
 482                 $msg = str_replace( "$3", $conn->lastErrno(), $msg );
 483                 $msg = str_replace( "$4", htmlspecialchars( $conn->lastError() ), $msg );
 484
 485                 if ( $wgCommandLineMode || !is_object( $wgUser )) {
 486                         print "$msg\n";
 487                         wfAbruptExit();
 488                 }
 489                 $sk = $wgUser->getSkin();
 490                 $shlink = $sk->makeKnownLink( wfMsgNoDB( "searchhelppage" ),
 491                   wfMsgNoDB( "searchingwikipedia" ) );
 492                 $msg = str_replace( "$5", $shlink, $msg );
 493                 $this->mBodytext = $msg;
 494                 $this->output();
 495                 wfAbruptExit();
 496         }
 497
 498         function readOnlyPage( $source = "", $protected = false )
 499         {
 500                 global $wgUser, $wgReadOnlyFile;
 501
 502                 $this->setRobotpolicy( "noindex,nofollow" );
 503                 $this->setArticleRelated( false );
 504
 505                 if( $protected ) {
 506                         $this->setPageTitle( wfMsg( "viewsource" ) );
 507                         $this->addWikiText( wfMsg( "protectedtext" ) );
 508                 } else {
 509                         $this->setPageTitle( wfMsg( "readonly" ) );
 510                         $reason = file_get_contents( $wgReadOnlyFile );
 511                         $this->addHTML( wfMsg( "readonlytext", $reason ) );
 512                 }
 513
 514                 if($source) {
 515                         $rows = $wgUser->getOption( "rows" );
 516                         $cols = $wgUser->getOption( "cols" );
 517                         $text .= "</p>\n<textarea cols='$cols' rows='$rows' readonly>" .
 518                                 htmlspecialchars( $source ) . "\n</textarea>";
 519                         $this->addHTML( $text );
 520                 }
 521
 522                 $this->returnToMain( false );
 523         }
 524
 525         function fatalError( $message )
 526         {
 527                 $this->setPageTitle( wfMsg( "internalerror" ) );
 528                 $this->setRobotpolicy( "noindex,nofollow" );
 529                 $this->setArticleRelated( false );
 530
 531                 $this->mBodytext = $message;
 532                 $this->output();
 533                 wfAbruptExit();
 534         }
 535
 536         function unexpectedValueError( $name, $val )
 537         {
 538                 $this->fatalError( wfMsg( "unexpected", $name, $val ) );
 539         }
 540
 541         function fileCopyError( $old, $new )
 542         {
 543                 $this->fatalError( wfMsg( "filecopyerror", $old, $new ) );
 544         }
 545
 546         function fileRenameError( $old, $new )
 547         {
 548                 $this->fatalError( wfMsg( "filerenameerror", $old, $new ) );
 549         }
 550
 551         function fileDeleteError( $name )
 552         {
 553                 $this->fatalError( wfMsg( "filedeleteerror", $name ) );
 554         }
 555
 556         function fileNotFoundError( $name )
 557         {
 558                 $this->fatalError( wfMsg( "filenotfound", $name ) );
 559         }
 560
 561         function returnToMain( $auto = true )
 562         {
 563                 global $wgUser, $wgOut, $returnto;
 564
 565                 $sk = $wgUser->getSkin();
 566                 if ( "" == $returnto ) {
 567                         $returnto = wfMsg( "mainpage" );
 568                 }
 569                 $link = $sk->makeKnownLink( $returnto, "" );
 570
 571                 $r = wfMsg( "returnto", $link );
 572                 if ( $auto ) {
 573                         $wgOut->addMeta( "http:Refresh", "10;url=" .
 574                           wfLocalUrlE( wfUrlencode( $returnto ) ) );
 575                 }
 576                 $wgOut->addHTML( "\n<p>$r\n" );
 577         }
 578
 579
 580         function categoryMagic ()
 581         {
 582                 global $wgTitle , $wgUseCategoryMagic ;
 583                 if ( !isset ( $wgUseCategoryMagic ) || !$wgUseCategoryMagic ) return ;
 584                 $id = $wgTitle->getArticleID() ;
 585                 $cat = ucfirst ( wfMsg ( "category" ) ) ;
 586                 $ti = $wgTitle->getText() ;
 587                 $ti = explode ( ":" , $ti , 2 ) ;
 588                 if ( $cat != $ti[0] ) return "" ;
 589                 $r = "<br break=all>\n" ;
 590
 591                 $articles = array() ;
 592                 $parents = array () ;
 593                 $children = array() ;
 594
 595
 596                 global $wgUser ;
 597                 $sk = $wgUser->getSkin() ;
 598                 $sql = "SELECT l_from FROM links WHERE l_to={$id}" ;
 599                 $res = wfQuery ( $sql, DB_READ ) ;
 600                 while ( $x = wfFetchObject ( $res ) )
 601                 {
 602                 #  $t = new Title ;
 603                 #  $t->newFromDBkey ( $x->l_from ) ;
 604                 #  $t = $t->getText() ;
 605                         $t = $x->l_from ;
 606                         $y = explode ( ":" , $t , 2 ) ;
 607                         if ( count ( $y ) == 2 && $y[0] == $cat ) {
 608                                 array_push ( $children , $sk->makeLink ( $t , $y[1] ) ) ;
 609                         } else {
 610                                 array_push ( $articles , $sk->makeLink ( $t ) ) ;
 611                         }
 612                 }
 613                 wfFreeResult ( $res ) ;
 614
 615                 # Children
 616                 if ( count ( $children ) > 0 )
 617                 {
 618                         asort ( $children ) ;
 619                         $r .= "<h2>".wfMsg("subcategories")."</h2>\n" ;
 620                         $r .= implode ( ", " , $children ) ;
 621                 }
 622
 623                 # Articles
 624                 if ( count ( $articles ) > 0 )
 625                 {
 626                         asort ( $articles ) ;
 627                         $h =  wfMsg( "category_header", $ti[1] );
 628                         $r .= "<h2>{$h}</h2>\n" ;
 629                         $r .= implode ( ", " , $articles ) ;
 630                 }
 631
 632
 633                 return $r ;
 634         }
 635
 636 function getHTMLattrs ()
 637 {
 638                 $htmlattrs = array( # Allowed attributes--no scripting, etc.
 639                         "title", "align", "lang", "dir", "width", "height",
 640                         "bgcolor", "clear", /* BR */ "noshade", /* HR */
 641                         "cite", /* BLOCKQUOTE, Q */ "size", "face", "color",
 642                         /* FONT */ "type", "start", "value", "compact",
 643                         /* For various lists, mostly deprecated but safe */
 644                         "summary", "width", "border", "frame", "rules",
 645                         "cellspacing", "cellpadding", "valign", "char",
 646                         "charoff", "colgroup", "col", "span", "abbr", "axis",
 647                         "headers", "scope", "rowspan", "colspan", /* Tables */
 648                         "id", "class", "name", "style" /* For CSS */
 649                 );
 650 return $htmlattrs ;
 651 }
 652
 653 function fixTagAttributes ( $t )
 654 {
 655         if ( trim ( $t ) == "" ) return "" ; # Saves runtime ;-)
 656         $htmlattrs = $this->getHTMLattrs() ;
 657
 658         # Strip non-approved attributes from the tag
 659         $t = preg_replace(
 660                 "/(\\w+)(\\s*=\\s*([^\\s\">]+|\"[^\">]*\"))?/e",
 661                 "(in_array(strtolower(\"\$1\"),\$htmlattrs)?(\"\$1\".((\"x\$3\" != \"x\")?\"=\$3\":'')):'')",
 662                 $t);
 663         # Strip javascript "expression" from stylesheets. Brute force approach:
 664         # If anythin offensive is found, all attributes of the HTML tag are dropped
 665
 666         if( preg_match(
 667                 "/style\\s*=.*(expression|tps*:\/\/|url\\s*\().*/is",
 668                 wfMungeToUtf8( $t ) ) )
 669         {
 670                 $t="";
 671         }
 672
 673         return trim ( $t ) ;
 674 }
 675
 676 function doTableStuff ( $t )
 677 {
 678   $t = explode ( "\n" , $t ) ;
 679   $td = array () ; # Is currently a td tag open?
 680   $ltd = array () ; # Was it TD or TH?
 681   $tr = array () ; # Is currently a tr tag open?
 682   $ltr = array () ; # tr attributes
 683   foreach ( $t AS $k => $x )
 684     {
 685       $x = rtrim ( $x ) ;
 686       $fc = substr ( $x , 0 , 1 ) ;
 687       if ( "{|" == substr ( $x , 0 , 2 ) )
 688         {
 689           $t[$k] = "<table " . $this->fixTagAttributes ( substr ( $x , 3 ) ) . ">" ;
 690           array_push ( $td , false ) ;
 691           array_push ( $ltd , "" ) ;
 692           array_push ( $tr , false ) ;
 693           array_push ( $ltr , "" ) ;
 694         }
 695       else if ( count ( $td ) == 0 ) { } # Don't do any of the following
 696       else if ( "|}" == substr ( $x , 0 , 2 ) )
 697         {
 698           $z = "</table>\n" ;
 699           $l = array_pop ( $ltd ) ;
 700           if ( array_pop ( $tr ) ) $z = "</tr>" . $z ;
 701           if ( array_pop ( $td ) ) $z = "</{$l}>" . $z ;
 702           array_pop ( $ltr ) ;
 703           $t[$k] = $z ;
 704         }
 705 /*      else if ( "|_" == substr ( $x , 0 , 2 ) ) # Caption
 706         {
 707         $z = trim ( substr ( $x , 2 ) ) ;
 708         $t[$k] = "<caption>{$z}</caption>\n" ;
 709         }*/
 710       else if ( "|-" == substr ( $x , 0 , 2 ) ) # Allows for |---------------
 711         {
 712           $x = substr ( $x , 1 ) ;
 713           while ( $x != "" && substr ( $x , 0 , 1 ) == '-' ) $x = substr ( $x , 1 ) ;
 714           $z = "" ;
 715           $l = array_pop ( $ltd ) ;
 716           if ( array_pop ( $tr ) ) $z = "</tr>" . $z ;
 717           if ( array_pop ( $td ) ) $z = "</{$l}>" . $z ;
 718           array_pop ( $ltr ) ;
 719           $t[$k] = $z ;
 720           array_push ( $tr , false ) ;
 721           array_push ( $td , false ) ;
 722           array_push ( $ltd , "" ) ;
 723           array_push ( $ltr , $this->fixTagAttributes ( $x ) ) ;
 724         }
 725       else if ( "|" == $fc || "!" == $fc || "|+" == substr ( $x , 0 , 2 ) ) # Caption
 726         {
 727           if ( "|+" == substr ( $x , 0 , 2 ) )
 728               {
 729               $fc = "+" ;
 730               $x = substr ( $x , 1 ) ;
 731               }
 732           $after = substr ( $x , 1 ) ;
 733           if ( $fc == "!" ) $after = str_replace ( "!!" , "||" , $after ) ;
 734           $after = explode ( "||" , $after ) ;
 735           $t[$k] = "" ;
 736           foreach ( $after AS $theline )
 737              {
 738           $z = "" ;
 739           if ( $fc != "+" )
 740           {
 741             $tra = array_pop ( $ltr ) ;
 742             if ( !array_pop ( $tr ) ) $z = "<tr {$tra}>\n" ;
 743             array_push ( $tr , true ) ;
 744             array_push ( $ltr , "" ) ;
 745           }
 746
 747           $l = array_pop ( $ltd ) ;
 748           if ( array_pop ( $td ) ) $z = "</{$l}>" . $z ;
 749           if ( $fc == "|" ) $l = "TD" ;
 750           else if ( $fc == "!" ) $l = "TH" ;
 751           else if ( $fc == "+" ) $l = "CAPTION" ;
 752           else $l = "" ;
 753           array_push ( $ltd , $l ) ;
 754           $y = explode ( "|" , $theline , 2 ) ;
 755           if ( count ( $y ) == 1 ) $y = "{$z}<{$l}>{$y[0]}" ;
 756           else $y = $y = "{$z}<{$l} ".$this->fixTagAttributes($y[0]).">{$y[1]}" ;
 757           $t[$k] .= $y ;
 758           array_push ( $td , true ) ;
 759              }
 760         }
 761     }
 762
 763 # Closing open td, tr && table
 764 while ( count ( $td ) > 0 )
 765 {
 766 if ( array_pop ( $td ) ) $t[] = "</td>" ;
 767 if ( array_pop ( $tr ) ) $t[] = "</tr>" ;
 768 $t[] = "</table>" ;
 769 }
 770
 771   $t = implode ( "\n" , $t ) ;
 772 #               $t = $this->removeHTMLtags( $t );
 773   return $t ;
 774 }
 775
 776         # Well, OK, it's actually about 14 passes.  But since all the
 777         # hard lifting is done inside PHP's regex code, it probably
 778         # wouldn't speed things up much to add a real parser.
 779         #
 780         function doWikiPass2( $text, $linestart )
 781         {
 782                 global $wgUser, $wgLang, $wgUseDynamicDates;
 783                 $fname = "OutputPage::doWikiPass2";
 784                 wfProfileIn( $fname );
 785
 786                 $text = $this->removeHTMLtags( $text );
 787                 $text = $this->replaceVariables( $text );
 788
 789                 $text = preg_replace( "/(^|\n)-----*/", "\\1<hr>", $text );
 790                 $text = str_replace ( "<HR>", "<hr>", $text );
 791
 792                 $text = $this->doAllQuotes( $text );
 793                 $text = $this->doHeadings( $text );
 794                 $text = $this->doBlockLevels( $text, $linestart );
 795
 796                 if($wgUseDynamicDates) {
 797                         global $wgDateFormatter;
 798                         $text = $wgDateFormatter->reformat( $wgUser->getOption("date"), $text );
 799                 }
 800
 801                 $text = $this->replaceExternalLinks( $text );
 802                 $text = $this->replaceInternalLinks ( $text );
 803                 $text = $this->doTableStuff ( $text ) ;
 804
 805                 $text = $this->magicISBN( $text );
 806                 $text = $this->magicRFC( $text );
 807                 $text = $this->formatHeadings( $text );
 808
 809                 $sk = $wgUser->getSkin();
 810                 $text = $sk->transformContent( $text );
 811                 $text .= $this->categoryMagic () ;
 812
 813                 wfProfileOut( $fname );
 814                 return $text;
 815         }
 816
 817         /* private */ function doAllQuotes( $text )
 818         {
 819                 $outtext = "";
 820                 $lines = explode( "\r\n", $text );
 821                 foreach ( $lines as $line ) {
 822                         $outtext .= $this->doQuotes ( "", $line, "" ) . "\r\n";
 823                 }
 824                 return $outtext;
 825         }
 826
 827         /* private */ function doQuotes( $pre, $text, $mode )
 828         {
 829                 if ( preg_match( "/^(.*)''(.*)$/sU", $text, $m ) ) {
 830                         $m1_strong = ($m[1] == "") ? "" : "<strong>{$m[1]}</strong>";
 831                         $m1_em = ($m[1] == "") ? "" : "<em>{$m[1]}</em>";
 832                         if ( substr ($m[2], 0, 1) == "'" ) {
 833                                 $m[2] = substr ($m[2], 1);
 834                                 if ($mode == "em") {
 835                                         return $this->doQuotes ( $m[1], $m[2], ($m[1] == "") ? "both" : "emstrong" );
 836                                 } else if ($mode == "strong") {
 837                                         return $m1_strong . $this->doQuotes ( "", $m[2], "" );
 838                                 } else if (($mode == "emstrong") || ($mode == "both")) {
 839                                         return $this->doQuotes ( "", $pre.$m1_strong.$m[2], "em" );
 840                                 } else if ($mode == "strongem") {
 841                                         return "<strong>{$pre}{$m1_em}</strong>" . $this->doQuotes ( "", $m[2], "em" );
 842                                 } else {
 843                                         return $m[1] . $this->doQuotes ( "", $m[2], "strong" );
 844                                 }
 845                         } else {
 846                                 if ($mode == "strong") {
 847                                         return $this->doQuotes ( $m[1], $m[2], ($m[1] == "") ? "both" : "strongem" );
 848                                 } else if ($mode == "em") {
 849                                         return $m1_em . $this->doQuotes ( "", $m[2], "" );
 850                                 } else if ($mode == "emstrong") {
 851                                         return "<em>{$pre}{$m1_strong}</em>" . $this->doQuotes ( "", $m[2], "strong" );
 852                                 } else if (($mode == "strongem") || ($mode == "both")) {
 853                                         return $this->doQuotes ( "", $pre.$m1_em.$m[2], "strong" );
 854                                 } else {
 855                                         return $m[1] . $this->doQuotes ( "", $m[2], "em" );
 856                                 }
 857                         }
 858                 } else {
 859                         $text_strong = ($text == "") ? "" : "<strong>{$text}</strong>";
 860                         $text_em = ($text == "") ? "" : "<em>{$text}</em>";
 861                         if ($mode == "") {
 862                                 return $pre . $text;
 863                         } else if ($mode == "em") {
 864                                 return $pre . $text_em;
 865                         } else if ($mode == "strong") {
 866                                 return $pre . $text_strong;
 867                         } else if ($mode == "strongem") {
 868                                 return (($pre == "") && ($text == "")) ? "" : "<strong>{$pre}{$text_em}</strong>";
 869                         } else {
 870                                 return (($pre == "") && ($text == "")) ? "" : "<em>{$pre}{$text_strong}</em>";
 871                         }
 872                 }
 873         }
 874
 875         /* private */ function doHeadings( $text )
 876         {
 877                 for ( $i = 6; $i >= 1; --$i ) {
 878                         $h = substr( "======", 0, $i );
 879                         $text = preg_replace( "/^{$h}([^=]+){$h}(\\s|$)/m",
 880                           "<h{$i}>\\1</h{$i}>\\2", $text );
 881                 }
 882                 return $text;
 883         }
 884
 885         # Note: we have to do external links before the internal ones,
 886         # and otherwise take great care in the order of things here, so
 887         # that we don't end up interpreting some URLs twice.
 888
 889         /* private */ function replaceExternalLinks( $text )
 890         {
 891                 $fname = "OutputPage::replaceExternalLinks";
 892                 wfProfileIn( $fname );
 893                 $text = $this->subReplaceExternalLinks( $text, "http", true );
 894                 $text = $this->subReplaceExternalLinks( $text, "https", true );
 895                 $text = $this->subReplaceExternalLinks( $text, "ftp", false );
 896                 $text = $this->subReplaceExternalLinks( $text, "irc", false );
 897                 $text = $this->subReplaceExternalLinks( $text, "gopher", false );
 898                 $text = $this->subReplaceExternalLinks( $text, "news", false );
 899                 $text = $this->subReplaceExternalLinks( $text, "mailto", false );
 900                 wfProfileOut( $fname );
 901                 return $text;
 902         }
 903
 904         /* private */ function subReplaceExternalLinks( $s, $protocol, $autonumber )
 905         {
 906                 global $wgUser, $printable;
 907                 global $wgAllowExternalImages;
 908
 909
 910                 $unique = "4jzAfzB8hNvf4sqyO9Edd8pSmk9rE2in0Tgw3";
 911                 $uc = "A-Za-z0-9_\\/~%\\-+&*#?!=()@\\x80-\\xFF";
 912
 913                 # this is  the list of separators that should be ignored if they
 914                 # are the last character of an URL but that should be included
 915                 # if they occur within the URL, e.g. "go to www.foo.com, where .."
 916                 # in this case, the last comma should not become part of the URL,
 917                 # but in "www.foo.com/123,2342,32.htm" it should.
 918                 $sep = ",;\.:";
 919                 $fnc = "A-Za-z0-9_.,~%\\-+&;#*?!=()@\\x80-\\xFF";
 920                 $images = "gif|png|jpg|jpeg";
 921
 922                 # PLEASE NOTE: The curly braces { } are not part of the regex,
 923                 # they are interpreted as part of the string (used to tell PHP
 924                 # that the content of the string should be inserted there).
 925                 $e1 = "/(^|[^\\[])({$protocol}:)([{$uc}{$sep}]+)\\/([{$fnc}]+)\\." .
 926                   "((?i){$images})([^{$uc}]|$)/";
 927
 928                 $e2 = "/(^|[^\\[])({$protocol}:)(([".$uc."]|[".$sep."][".$uc."])+)([^". $uc . $sep. "]|[".$sep."]|$)/";
 929                 $sk = $wgUser->getSkin();
 930
 931                 if ( $autonumber and $wgAllowExternalImages) { # Use img tags only for HTTP urls
 932                         $s = preg_replace( $e1, "\\1" . $sk->makeImage( "{$unique}:\\3" .
 933                           "/\\4.\\5", "\\4.\\5" ) . "\\6", $s );
 934                 }
 935                 $s = preg_replace( $e2, "\\1" . "<a href=\"{$unique}:\\3\"" .
 936                   $sk->getExternalLinkAttributes( "{$unique}:\\3", wfEscapeHTML(
 937                   "{$unique}:\\3" ) ) . ">" . wfEscapeHTML( "{$unique}:\\3" ) .
 938                   "</a>\\5", $s );
 939                 $s = str_replace( $unique, $protocol, $s );
 940
 941                 $a = explode( "[{$protocol}:", " " . $s );
 942                 $s = array_shift( $a );
 943                 $s = substr( $s, 1 );
 944
 945                 $e1 = "/^([{$uc}"."{$sep}]+)](.*)\$/sD";
 946                 $e2 = "/^([{$uc}"."{$sep}]+)\\s+([^\\]]+)](.*)\$/sD";
 947
 948                 foreach ( $a as $line ) {
 949                         if ( preg_match( $e1, $line, $m ) ) {
 950                                 $link = "{$protocol}:{$m[1]}";
 951                                 $trail = $m[2];
 952                                 if ( $autonumber ) { $text = "[" . ++$this->mAutonumber . "]"; }
 953                                 else { $text = wfEscapeHTML( $link ); }
 954                         } else if ( preg_match( $e2, $line, $m ) ) {
 955                                 $link = "{$protocol}:{$m[1]}";
 956                                 $text = $m[2];
 957                                 $trail = $m[3];
 958                         } else {
 959                                 $s .= "[{$protocol}:" . $line;
 960                                 continue;
 961                         }
 962                         if ( $printable == "yes") $paren = " (<i>" . htmlspecialchars ( $link ) . "</i>)";
 963                         else $paren = "";
 964                         $la = $sk->getExternalLinkAttributes( $link, $text );
 965                         $s .= "<a href='{$link}'{$la}>{$text}</a>{$paren}{$trail}";
 966
 967                 }
 968                 return $s;
 969         }
 970
 971         /* private */ function replaceInternalLinks( $s )
 972         {
 973                 global $wgTitle, $wgUser, $wgLang;
 974                 global $wgLinkCache, $wgInterwikiMagic, $wgUseCategoryMagic;
 975                 global $wgNamespacesWithSubpages, $wgLanguageCode;
 976                 wfProfileIn( $fname = "OutputPage::replaceInternalLinks" );
 977
 978                 wfProfileIn( "$fname-setup" );
 979                 $tc = Title::legalChars() . "#";
 980                 $sk = $wgUser->getSkin();
 981
 982                 $a = explode( "[[", " " . $s );
 983                 $s = array_shift( $a );
 984                 $s = substr( $s, 1 );
 985
 986                 # Match a link having the form [[namespace:link|alternate]]trail
 987                 $e1 = "/^([{$tc}]+)(?:\\|([^]]+))?]](.*)\$/sD";
 988                 # Match the end of a line for a word that's not followed by whitespace,
 989                 # e.g. in the case of 'The Arab al[[Razi]]', 'al' will be matched
 990                 #$e2 = "/^(.*)\\b(\\w+)\$/suD";
 991                 #$e2 = "/^(.*\\s)(\\S+)\$/suD";
 992                 $e2 = '/^(.*\s)([a-zA-Z\x80-\xff]+)$/sD';
 993
 994
 995                 # Special and Media are pseudo-namespaces; no pages actually exist in them
 996                 $image = Namespace::getImage();
 997                 $special = Namespace::getSpecial();
 998                 $media = Namespace::getMedia();
 999                 $nottalk = !Namespace::isTalk( $wgTitle->getNamespace() );
1000
1001                 if ( $wgLang->linkPrefixExtension() && preg_match( $e2, $s, $m ) ) {
1002                         $new_prefix = $m[2];
1003                         $s = $m[1];
1004                 } else {
1005                         $new_prefix="";
1006                 }
1007
1008                 wfProfileOut( "$fname-setup" );
1009
1010                 foreach ( $a as $line ) {
1011                         $prefix = $new_prefix;
1012                         if ( $wgUseLinkPrefixCombination && preg_match( $e2, $line, $m ) ) {
1013                                 $new_prefix = $m[2];
1014                                 $line = $m[1];
1015                         } else {
1016                                 $new_prefix = "";
1017                         }
1018                         if ( preg_match( $e1, $line, $m ) ) { # page with normal text or alt
1019                                 $text = $m[2];
1020                                 $trail = $m[3];
1021                         } else { # Invalid form; output directly
1022                                 $s .= $prefix . "[[" . $line ;
1023                                 continue;
1024                         }
1025
1026                         /* Valid link forms:
1027                         Foobar -- normal
1028                         :Foobar -- override special treatment of prefix (images, language links)
1029                         /Foobar -- convert to CurrentPage/Foobar
1030                         /Foobar/ -- convert to CurrentPage/Foobar, strip the initial / from text
1031                         */
1032                         $c = substr($m[1],0,1);
1033                         $noforce = ($c != ":");
1034                         if( $c == "/" ) { # subpage
1035                                 if(substr($m[1],-1,1)=="/") {                 # / at end means we don't want the slash to be shown
1036                                         $m[1]=substr($m[1],1,strlen($m[1])-2);
1037                                         $noslash=$m[1];
1038                                 } else {
1039                                         $noslash=substr($m[1],1);
1040                                 }
1041                                 if($wgNamespacesWithSubpages[$wgTitle->getNamespace()]) { # subpages allowed here
1042                                         $link = $wgTitle->getPrefixedText(). "/" . trim($noslash);
1043                                         if( "" == $text ) {
1044                                                 $text= $m[1];
1045                                         } # this might be changed for ugliness reasons
1046                                 } else {
1047                                         $link = $noslash; # no subpage allowed, use standard link
1048                                 }
1049                         } elseif( $noforce ) { # no subpage
1050                                 $link = $m[1];
1051                         } else {
1052                                 $link = substr( $m[1], 1 );
1053                         }
1054                         if( "" == $text )
1055                                 $text = $link;
1056
1057                         $nt = Title::newFromText( $link );
1058                         if( !$nt ) {
1059                                 $s .= $prefix . "[[" . $line;
1060                                 continue;
1061                         }
1062                         $ns = $nt->getNamespace();
1063                         $iw = $nt->getInterWiki();
1064                         if( $noforce ) {
1065                                 if( $iw && $wgInterwikiMagic && $nottalk && $wgLang->getLanguageName( $iw ) ) {
1066                                         array_push( $this->mLanguageLinks, $nt->getPrefixedText() );
1067                                         $s .= $prefix . $trail;
1068                                         continue;
1069                                 }
1070                                 if( $ns == $image ) {
1071                                         $s .= $prefix . $sk->makeImageLinkObj( $nt, $text ) . $trail;
1072                                         $wgLinkCache->addImageLinkObj( $nt );
1073                                         continue;
1074                                 }
1075                         }
1076                         if( ( $nt->getPrefixedText() == $wgTitle->getPrefixedText() ) &&
1077                             ( strpos( $link, "#" ) == FALSE ) ) {
1078                                 $s .= $prefix . "<strong>" . $text . "</strong>" . $trail;
1079                                 continue;
1080                         }
1081                         if( $ns == $media ) {
1082                                 $s .= $prefix . $sk->makeMediaLinkObj( $nt, $text ) . $trail;
1083                                 $wgLinkCache->addImageLinkObj( $nt );
1084                                 continue;
1085                         } elseif( $ns == $special ) {
1086                                 $s .= $prefix . $sk->makeKnownLinkObj( $nt, $text, "", $trail );
1087                                 continue;
1088                         }
1089                         $s .= $sk->makeLinkObj( $nt, $text, "", $trail , $prefix );
1090                 }
1091                 wfProfileOut( $fname );
1092                 return $s;
1093         }
1094
1095         # Some functions here used by doBlockLevels()
1096         #
1097         /* private */ function closeParagraph()
1098         {
1099                 $result = "";
1100                 if ( 0 != strcmp( "p", $this->mLastSection ) &&
1101                   0 != strcmp( "", $this->mLastSection ) ) {
1102                         $result = "</" . $this->mLastSection  . ">";
1103                 }
1104                 $this->mLastSection = "";
1105                 return $result."\n";
1106         }
1107         # getCommon() returns the length of the longest common substring
1108         # of both arguments, starting at the beginning of both.
1109         #
1110         /* private */ function getCommon( $st1, $st2 )
1111         {
1112                 $fl = strlen( $st1 );
1113                 $shorter = strlen( $st2 );
1114                 if ( $fl < $shorter ) { $shorter = $fl; }
1115
1116                 for ( $i = 0; $i < $shorter; ++$i ) {
1117                         if ( $st1{$i} != $st2{$i} ) { break; }
1118                 }
1119                 return $i;
1120         }
1121         # These next three functions open, continue, and close the list
1122         # element appropriate to the prefix character passed into them.
1123         #
1124         /* private */ function openList( $char )
1125     {
1126                 $result = $this->closeParagraph();
1127
1128                 if ( "*" == $char ) { $result .= "<ul><li>"; }
1129                 else if ( "#" == $char ) { $result .= "<ol><li>"; }
1130                 else if ( ":" == $char ) { $result .= "<dl><dd>"; }
1131                 else if ( ";" == $char ) {
1132                         $result .= "<dl><dt>";
1133                         $this->mDTopen = true;
1134                 }
1135                 else { $result = "<!-- ERR 1 -->"; }
1136
1137                 return $result;
1138         }
1139
1140         /* private */ function nextItem( $char )
1141         {
1142                 if ( "*" == $char || "#" == $char ) { return "</li><li>"; }
1143                 else if ( ":" == $char || ";" == $char ) {
1144                         $close = "</dd>";
1145                         if ( $this->mDTopen ) { $close = "</dt>"; }
1146                         if ( ";" == $char ) {
1147                                 $this->mDTopen = true;
1148                                 return $close . "<dt>";
1149                         } else {
1150                                 $this->mDTopen = false;
1151                                 return $close . "<dd>";
1152                         }
1153                 }
1154                 return "<!-- ERR 2 -->";
1155         }
1156
1157         /* private */function closeList( $char )
1158         {
1159                 if ( "*" == $char ) { $text = "</li></ul>"; }
1160                 else if ( "#" == $char ) { $text = "</li></ol>"; }
1161                 else if ( ":" == $char ) {
1162                         if ( $this->mDTopen ) {
1163                                 $this->mDTopen = false;
1164                                 $text = "</dt></dl>";
1165                         } else {
1166                                 $text = "</dd></dl>";
1167                         }
1168                 }
1169                 else {  return "<!-- ERR 3 -->"; }
1170                 return $text."\n";
1171         }
1172
1173         /* private */ function doBlockLevels( $text, $linestart )
1174         {
1175                 $fname = "OutputPage::doBlockLevels";
1176                 wfProfileIn( $fname );
1177                 # Parsing through the text line by line.  The main thing
1178                 # happening here is handling of block-level elements p, pre,
1179                 # and making lists from lines starting with * # : etc.
1180                 #
1181                 $a = explode( "\n", $text );
1182                 $text = $lastPref = "";
1183                 $this->mDTopen = $inBlockElem = false;
1184
1185                 if ( ! $linestart ) { $text .= array_shift( $a ); }
1186                 foreach ( $a as $t ) {
1187                         if ( "" != $text ) { $text .= "\n"; }
1188
1189                         $oLine = $t;
1190                         $opl = strlen( $lastPref );
1191                         $npl = strspn( $t, "*#:;" );
1192                         $pref = substr( $t, 0, $npl );
1193                         $pref2 = str_replace( ";", ":", $pref );
1194                         $t = substr( $t, $npl );
1195
1196                         if ( 0 != $npl && 0 == strcmp( $lastPref, $pref2 ) ) {
1197                                 $text .= $this->nextItem( substr( $pref, -1 ) );
1198
1199                                 if ( ";" == substr( $pref, -1 ) ) {
1200                                         $cpos = strpos( $t, ":" );
1201                                         if ( ! ( false === $cpos ) ) {
1202                                                 $term = substr( $t, 0, $cpos );
1203                                                 $text .= $term . $this->nextItem( ":" );
1204                                                 $t = substr( $t, $cpos + 1 );
1205                                         }
1206                                 }
1207                         } else if (0 != $npl || 0 != $opl) {
1208                                 $cpl = $this->getCommon( $pref, $lastPref );
1209
1210                                 while ( $cpl < $opl ) {
1211                                         $text .= $this->closeList( $lastPref{$opl-1} );
1212                                         --$opl;
1213                                 }
1214                                 if ( $npl <= $cpl && $cpl > 0 ) {
1215                                         $text .= $this->nextItem( $pref{$cpl-1} );
1216                                 }
1217                                 while ( $npl > $cpl ) {
1218                                         $char = substr( $pref, $cpl, 1 );
1219                                         $text .= $this->openList( $char );
1220
1221                                         if ( ";" == $char ) {
1222                                                 $cpos = strpos( $t, ":" );
1223                                                 if ( ! ( false === $cpos ) ) {
1224                                                         $term = substr( $t, 0, $cpos );
1225                                                         $text .= $term . $this->nextItem( ":" );
1226                                                         $t = substr( $t, $cpos + 1 );
1227                                                 }
1228                                         }
1229                                         ++$cpl;
1230                                 }
1231                                 $lastPref = $pref2;
1232                         }
1233                         if ( 0 == $npl ) { # No prefix--go to paragraph mode
1234                                 if ( preg_match(
1235                                   "/(<table|<blockquote|<h1|<h2|<h3|<h4|<h5|<h6)/i", $t ) ) {
1236                                         $text .= $this->closeParagraph();
1237                                         $inBlockElem = true;
1238                                 }
1239                                 if ( ! $inBlockElem ) {
1240                                         if ( " " == $t{0} ) {
1241                                                 $newSection = "pre";
1242                                                 # $t = wfEscapeHTML( $t );
1243                                         }
1244                                         else { $newSection = "p"; }
1245
1246                                         if ( 0 == strcmp( "", trim( $oLine ) ) ) {
1247                                                 $text .= $this->closeParagraph();
1248                                                 $text .= "<" . $newSection . ">";
1249                                         } else if ( 0 != strcmp( $this->mLastSection,
1250                                           $newSection ) ) {
1251                                                 $text .= $this->closeParagraph();
1252                                                 if ( 0 != strcmp( "p", $newSection ) ) {
1253                                                         $text .= "<" . $newSection . ">";
1254                                                 }
1255                                         }
1256                                         $this->mLastSection = $newSection;
1257                                 }
1258                                 if ( $inBlockElem &&
1259                                   preg_match( "/(<\\/table|<\\/blockquote|<\\/h1|<\\/h2|<\\/h3|<\\/h4|<\\/h5|<\\/h6)/i", $t ) ) {
1260                                         $inBlockElem = false;
1261                                 }
1262                         }
1263                         $text .= $t;
1264                 }
1265                 while ( $npl ) {
1266                         $text .= $this->closeList( $pref2{$npl-1} );
1267                         --$npl;
1268                 }
1269                 if ( "" != $this->mLastSection ) {
1270                         if ( "p" != $this->mLastSection ) {
1271                                 $text .= "</" . $this->mLastSection . ">";
1272                         }
1273                         $this->mLastSection = "";
1274                 }
1275                 wfProfileOut( $fname );
1276                 return $text;
1277         }
1278
1279         /* private */ function replaceVariables( $text )
1280         {
1281                 global $wgLang, $wgCurOut;
1282                 $fname = "OutputPage::replaceVariables";
1283                 wfProfileIn( $fname );
1284
1285                 $magic = array();
1286
1287                 # Basic variables
1288                 # See Language.php for the definition of each magic word
1289                 # As with sigs, this uses the server's local time -- ensure
1290                 # this is appropriate for your audience!
1291
1292                 $magic[MAG_CURRENTMONTH] = date( "m" );
1293                 $magic[MAG_CURRENTMONTHNAME] = $wgLang->getMonthName( date("n") );
1294                 $magic[MAG_CURRENTMONTHNAMEGEN] = $wgLang->getMonthNameGen( date("n") );
1295                 $magic[MAG_CURRENTDAY] = date("j");
1296                 $magic[MAG_CURRENTDAYNAME] = $wgLang->getWeekdayName( date("w")+1 );
1297                 $magic[MAG_CURRENTYEAR] = date( "Y" );
1298                 $magic[MAG_CURRENTTIME] = $wgLang->time( wfTimestampNow(), false );
1299
1300                 $this->mContainsOldMagic += MagicWord::replaceMultiple($magic, $text, $text);
1301
1302                 $mw =& MagicWord::get( MAG_NUMBEROFARTICLES );
1303                 if ( $mw->match( $text ) ) {
1304                         $v = wfNumberOfArticles();
1305                         $text = $mw->replace( $v, $text );
1306                         if( $mw->getWasModified() ) { $this->mContainsOldMagic++; }
1307                 }
1308
1309                 # "Variables" with an additional parameter e.g. {{MSG:wikipedia}}
1310                 # The callbacks are at the bottom of this file
1311                 $wgCurOut = $this;
1312                 $mw =& MagicWord::get( MAG_MSG );
1313                 $text = $mw->substituteCallback( $text, "wfReplaceMsgVar" );
1314                 if( $mw->getWasModified() ) { $this->mContainsNewMagic++; }
1315
1316                 $mw =& MagicWord::get( MAG_MSGNW );
1317                 $text = $mw->substituteCallback( $text, "wfReplaceMsgnwVar" );
1318                 if( $mw->getWasModified() ) { $this->mContainsNewMagic++; }
1319
1320                 wfProfileOut( $fname );
1321                 return $text;
1322         }
1323
1324         # Cleans up HTML, removes dangerous tags and attributes
1325         /* private */ function removeHTMLtags( $text )
1326         {
1327                 $fname = "OutputPage::removeHTMLtags";
1328                 wfProfileIn( $fname );
1329                 $htmlpairs = array( # Tags that must be closed
1330                         "b", "i", "u", "font", "big", "small", "sub", "sup", "h1",
1331                         "h2", "h3", "h4", "h5", "h6", "cite", "code", "em", "s",
1332                         "strike", "strong", "tt", "var", "div", "center",
1333                         "blockquote", "ol", "ul", "dl", "table", "caption", "pre",
1334                         "ruby", "rt" , "rb" , "rp"
1335                 );
1336                 $htmlsingle = array(
1337                         "br", "p", "hr", "li", "dt", "dd"
1338                 );
1339                 $htmlnest = array( # Tags that can be nested--??
1340                         "table", "tr", "td", "th", "div", "blockquote", "ol", "ul",
1341                         "dl", "font", "big", "small", "sub", "sup"
1342                 );
1343                 $tabletags = array( # Can only appear inside table
1344                         "td", "th", "tr"
1345                 );
1346
1347                 $htmlsingle = array_merge( $tabletags, $htmlsingle );
1348                 $htmlelements = array_merge( $htmlsingle, $htmlpairs );
1349
1350                 $htmlattrs = $this->getHTMLattrs () ;
1351
1352                 # Remove HTML comments
1353                 $text = preg_replace( "/<!--.*-->/sU", "", $text );
1354
1355                 $bits = explode( "<", $text );
1356                 $text = array_shift( $bits );
1357                 $tagstack = array(); $tablestack = array();
1358
1359                 foreach ( $bits as $x ) {
1360                         $prev = error_reporting( E_ALL & ~( E_NOTICE | E_WARNING ) );
1361                         preg_match( "/^(\\/?)(\\w+)([^>]*)(\\/{0,1}>)([^<]*)$/",
1362                           $x, $regs );
1363                         list( $qbar, $slash, $t, $params, $brace, $rest ) = $regs;
1364                         error_reporting( $prev );
1365
1366                         $badtag = 0 ;
1367                         if ( in_array( $t = strtolower( $t ), $htmlelements ) ) {
1368                                 # Check our stack
1369                                 if ( $slash ) {
1370                                         # Closing a tag...
1371                                         if ( ! in_array( $t, $htmlsingle ) &&
1372                                           ( $ot = array_pop( $tagstack ) ) != $t ) {
1373                                                 array_push( $tagstack, $ot );
1374                                                 $badtag = 1;
1375                                         } else {
1376                                                 if ( $t == "table" ) {
1377                                                         $tagstack = array_pop( $tablestack );
1378                                                 }
1379                                                 $newparams = "";
1380                                         }
1381                                 } else {
1382                                         # Keep track for later
1383                                         if ( in_array( $t, $tabletags ) &&
1384                                           ! in_array( "table", $tagstack ) ) {
1385                                                 $badtag = 1;
1386                                         } else if ( in_array( $t, $tagstack ) &&
1387                                           ! in_array ( $t , $htmlnest ) ) {
1388                                                 $badtag = 1 ;
1389                                         } else if ( ! in_array( $t, $htmlsingle ) ) {
1390                                                 if ( $t == "table" ) {
1391                                                         array_push( $tablestack, $tagstack );
1392                                                         $tagstack = array();
1393                                                 }
1394                                                 array_push( $tagstack, $t );
1395                                         }
1396                                         # Strip non-approved attributes from the tag
1397                                         $newparams = $this->fixTagAttributes($params);
1398
1399                                 }
1400                                 if ( ! $badtag ) {
1401                                         $rest = str_replace( ">", "&gt;", $rest );
1402                                         $text .= "<$slash$t $newparams$brace$rest";
1403                                         continue;
1404                                 }
1405                         }
1406                         $text .= "&lt;" . str_replace( ">", "&gt;", $x);
1407                 }
1408                 # Close off any remaining tags
1409                 while ( $t = array_pop( $tagstack ) ) {
1410                         $text .= "</$t>\n";
1411                         if ( $t == "table" ) { $tagstack = array_pop( $tablestack ); }
1412                 }
1413                 wfProfileOut( $fname );
1414                 return $text;
1415         }
1416
1417 /*
1418  *
1419  * This function accomplishes several tasks:
1420  * 1) Auto-number headings if that option is enabled
1421  * 2) Add an [edit] link to sections for logged in users who have enabled the option
1422  * 3) Add a Table of contents on the top for users who have enabled the option
1423  * 4) Auto-anchor headings
1424  *
1425  * It loops through all headlines, collects the necessary data, then splits up the
1426  * string and re-inserts the newly formatted headlines.
1427  *
1428  * */
1429         /* private */ function formatHeadings( $text )
1430         {
1431                 global $wgUser,$wgArticle,$wgTitle,$wpPreview;
1432                 $nh=$wgUser->getOption( "numberheadings" );
1433                 $st=$wgUser->getOption( "showtoc" );
1434                 if(!$wgTitle->userCanEdit()) {
1435                         $es=0;
1436                         $esr=0;
1437                 } else {
1438                         $es=$wgUser->getID() && $wgUser->getOption( "editsection" );
1439                         $esr=$wgUser->getID() && $wgUser->getOption( "editsectiononrightclick" );
1440                 }
1441
1442                 # Inhibit editsection links if requested in the page
1443                 $esw =& MagicWord::get( MAG_NOEDITSECTION );
1444                 if ($esw->matchAndRemove( $text )) {
1445                         $es=0;
1446                 }
1447                 # if the string __NOTOC__ (not case-sensitive) occurs in the HTML,
1448                 # do not add TOC
1449                 $mw =& MagicWord::get( MAG_NOTOC );
1450                 if ($mw->matchAndRemove( $text ))
1451                 {
1452                         $st = 0;
1453                 }
1454
1455                 # never add the TOC to the Main Page. This is an entry page that should not
1456                 # be more than 1-2 screens large anyway
1457                 if($wgTitle->getPrefixedText()==wfMsg("mainpage")) {$st=0;}
1458
1459                 # We need this to perform operations on the HTML
1460                 $sk=$wgUser->getSkin();
1461
1462                 # Get all headlines for numbering them and adding funky stuff like [edit]
1463                 # links
1464                 preg_match_all("/<H([1-6])(.*?>)(.*?)<\/H[1-6]>/i",$text,$matches);
1465
1466                 # headline counter
1467                 $c=0;
1468
1469                 # Ugh .. the TOC should have neat indentation levels which can be
1470                 # passed to the skin functions. These are determined here
1471                 foreach($matches[3] as $headline) {
1472                         if($level) { $prevlevel=$level;}
1473                         $level=$matches[1][$c];
1474                         if(($nh||$st) && $prevlevel && $level>$prevlevel) {
1475
1476                                 $h[$level]=0; // reset when we enter a new level
1477                                 $toc.=$sk->tocIndent($level-$prevlevel);
1478                                 $toclevel+=$level-$prevlevel;
1479
1480                         }
1481                         if(($nh||$st) && $level<$prevlevel) {
1482                                 $h[$level+1]=0; // reset when we step back a level
1483                                 $toc.=$sk->tocUnindent($prevlevel-$level);
1484                                 $toclevel-=$prevlevel-$level;
1485
1486                         }
1487                         $h[$level]++; // count number of headlines for each level
1488
1489                         if($nh||$st) {
1490                                 for($i=1;$i<=$level;$i++) {
1491                                         if($h[$i]) {
1492                                                 if($dot) {$numbering.=".";}
1493                                                 $numbering.=$h[$i];
1494                                                 $dot=1;
1495                                         }
1496                                 }
1497                         }
1498
1499                         // The canonized header is a version of the header text safe to use for links
1500
1501                         $canonized_headline=preg_replace("/<.*?>/","",$headline); // strip out HTML
1502                         $tocline = trim( $canonized_headline );
1503                         $canonized_headline=str_replace('"',"",$canonized_headline);
1504                         $canonized_headline=str_replace(" ","_",trim($canonized_headline));
1505                         $refer[$c]=$canonized_headline;
1506                         $refers[$canonized_headline]++;  // count how many in assoc. array so we can track dupes in anchors
1507                         $refcount[$c]=$refers[$canonized_headline];
1508
1509             // Prepend the number to the heading text
1510
1511                         if($nh||$st) {
1512                                 $tocline=$numbering ." ". $tocline;
1513
1514                                 // Don't number the heading if it is the only one (looks silly)
1515                                 if($nh && count($matches[3]) > 1) {
1516                                         $headline=$numbering . " " . $headline; // the two are different if the line contains a link
1517                                 }
1518                         }
1519
1520                         // Create the anchor for linking from the TOC to the section
1521
1522                         $anchor=$canonized_headline;
1523                         if($refcount[$c]>1) {$anchor.="_".$refcount[$c];}
1524                         if($st) {
1525                                 $toc.=$sk->tocLine($anchor,$tocline,$toclevel);
1526                         }
1527                         if($es && !isset($wpPreview)) {
1528                                 $head[$c].=$sk->editSectionLink($c+1);
1529                         }
1530
1531                         // Put it all together
1532
1533                         $head[$c].="<h".$level.$matches[2][$c]
1534                          ."<a name=\"".$anchor."\">"
1535                          .$headline
1536                          ."</a>"
1537                          ."</h".$level.">";
1538
1539                         // Add the edit section link
1540
1541                         if($esr && !isset($wpPreview)) {
1542                                 $head[$c]=$sk->editSectionScript($c+1,$head[$c]);
1543                         }
1544
1545                         $numbering="";
1546                         $c++;
1547                         $dot=0;
1548                 }
1549
1550                 if($st) {
1551                         $toclines=$c;
1552                         $toc.=$sk->tocUnindent($toclevel);
1553                         $toc=$sk->tocTable($toc);
1554                 }
1555
1556                 // split up and insert constructed headlines
1557
1558                 $blocks=preg_split("/<H[1-6].*?>.*?<\/H[1-6]>/i",$text);
1559                 $i=0;
1560
1561                 foreach($blocks as $block) {
1562                         if(($es) && !isset($wpPreview) && $c>0 && $i==0) {
1563                             # This is the [edit] link that appears for the top block of text when
1564                                 # section editing is enabled
1565                                 $full.=$sk->editSectionLink(0);
1566                         }
1567                         $full.=$block;
1568                         if($st && $toclines>3 && !$i) {
1569                                 # Let's add a top anchor just in case we want to link to the top of the page
1570                                 $full="<a name=\"top\"></a>".$full.$toc;
1571                         }
1572
1573                         $full.=$head[$i];
1574                         $i++;
1575                 }
1576
1577                 return $full;
1578         }
1579
1580         /* private */ function magicISBN( $text )
1581         {
1582                 global $wgLang;
1583
1584                 $a = split( "ISBN ", " $text" );
1585                 if ( count ( $a ) < 2 ) return $text;
1586                 $text = substr( array_shift( $a ), 1);
1587                 $valid = "0123456789-ABCDEFGHIJKLMNOPQRSTUVWXYZ";
1588
1589                 foreach ( $a as $x ) {
1590                         $isbn = $blank = "" ;
1591                         while ( " " == $x{0} ) {
1592                                 $blank .= " ";
1593                                 $x = substr( $x, 1 );
1594                         }
1595                         while ( strstr( $valid, $x{0} ) != false ) {
1596                                 $isbn .= $x{0};
1597                                 $x = substr( $x, 1 );
1598                         }
1599                         $num = str_replace( "-", "", $isbn );
1600                         $num = str_replace( " ", "", $num );
1601
1602                         if ( "" == $num ) {
1603                                 $text .= "ISBN $blank$x";
1604                         } else {
1605                                 $text .= "<a href=\"" . wfLocalUrlE( $wgLang->specialPage(
1606                                   "Booksources"), "isbn={$num}" ) . "\" class=\"internal\">ISBN $isbn</a>";
1607                                 $text .= $x;
1608                         }
1609                 }
1610                 return $text;
1611         }
1612
1613         /* private */ function magicRFC( $text )
1614         {
1615                 return $text;
1616         }
1617
1618         /* private */ function headElement()
1619         {
1620                 global $wgDocType, $wgDTD, $wgUser, $wgLanguageCode, $wgOutputEncoding, $wgLang;
1621
1622                 $ret = "<!DOCTYPE HTML PUBLIC \"$wgDocType\"\n        \"$wgDTD\">\n";
1623
1624                 if ( "" == $this->mHTMLtitle ) {
1625                         $this->mHTMLtitle = $this->mPagetitle;
1626                 }
1627                 $rtl = $wgLang->isRTL() ? " dir='RTL'" : "";
1628                 $ret .= "<html lang=\"$wgLanguageCode\"$rtl><head><title>{$this->mHTMLtitle}</title>\n";
1629                 array_push( $this->mMetatags, array( "http:Content-type", "text/html; charset={$wgOutputEncoding}" ) );
1630                 foreach ( $this->mMetatags as $tag ) {
1631                         if ( 0 == strcasecmp( "http:", substr( $tag[0], 0, 5 ) ) ) {
1632                                 $a = "http-equiv";
1633                                 $tag[0] = substr( $tag[0], 5 );
1634                         } else {
1635                                 $a = "name";
1636                         }
1637                         $ret .= "<meta $a=\"{$tag[0]}\" content=\"{$tag[1]}\">\n";
1638                 }
1639                 $p = $this->mRobotpolicy;
1640                 if ( "" == $p ) { $p = "index,follow"; }
1641                 $ret .= "<meta name=\"robots\" content=\"$p\">\n";
1642
1643                 if ( count( $this->mKeywords ) > 0 ) {
1644                         $ret .= "<meta name=\"keywords\" content=\"" .
1645                           implode( ",", $this->mKeywords ) . "\">\n";
1646                 }
1647                 foreach ( $this->mLinktags as $tag ) {
1648                         $ret .= "<link ";
1649                         if ( "" != $tag[0] ) { $ret .= "rel=\"{$tag[0]}\" "; }
1650                         if ( "" != $tag[1] ) { $ret .= "rev=\"{$tag[1]}\" "; }
1651                         $ret .= "href=\"{$tag[2]}\">\n";
1652                 }
1653                 $sk = $wgUser->getSkin();
1654                 $ret .= $sk->getHeadScripts();
1655                 $ret .= $sk->getUserStyles();
1656
1657                 $ret .= "</head>\n";
1658                 return $ret;
1659         }
1660
1661         /* private */ function fillFromParserCache(){
1662                 global $wgUser, $wgArticle;
1663                 $hash = $wgUser->getPageRenderingHash();
1664                 $pageid = intval( $wgArticle->getID() );
1665                 $res = wfQuery("SELECT pc_data FROM parsercache WHERE pc_pageid = {$pageid} ".
1666                         " AND pc_prefhash = '{$hash}' AND pc_expire > NOW()", DB_WRITE);
1667                 $row = wfFetchObject ( $res );
1668                 if( $row ){
1669                         $data = unserialize( gzuncompress($row->pc_data) );
1670                         $this->addHTML( $data['html'] );
1671                         $this->mLanguageLinks = $data['mLanguageLinks'];
1672                         $this->mCategoryLinks = $data['mCategoryLinks'];
1673                         wfProfileOut( $fname );
1674                         return true;
1675                 } else {
1676                         return false;
1677                 }
1678         }
1679
1680         /* private */ function saveParserCache( $text ){
1681                 global $wgUser, $wgArticle;
1682                 $hash = $wgUser->getPageRenderingHash();
1683                 $pageid = intval( $wgArticle->getID() );
1684                 $title = wfStrencode( $wgArticle->mTitle->getPrefixedDBKey() );
1685                 $data = array();
1686                 $data['html'] = $text;
1687                 $data['mLanguageLinks'] = $this->mLanguageLinks;
1688                 $data['mCategoryLinks'] = $this->mCategoryLinks;
1689                 $ser = addslashes( gzcompress( serialize( $data ) ) );
1690                 if( $this->mContainsOldMagic ){
1691                         $expire = "1 HOUR";
1692                 } else {
1693                         $expire = "7 DAY";
1694                 }
1695
1696                 wfQuery("REPLACE INTO parsercache (pc_prefhash,pc_pageid,pc_title,pc_data, pc_expire) ".
1697                         "VALUES('{$hash}', {$pageid}, '{$title}', '{$ser}', ".
1698                                 "DATE_ADD(NOW(), INTERVAL {$expire}))", DB_WRITE);
1699
1700                 if( rand() % 50 == 0 ){ // more efficient to just do it sometimes
1701                         $this->purgeParserCache();
1702                 }
1703         }
1704
1705         /* static private */ function purgeParserCache(){
1706                 wfQuery("DELETE FROM parsercache WHERE pc_expire < NOW() LIMIT 250", DB_WRITE);
1707         }
1708
1709         /* static */ function parsercacheClearLinksTo( $pid ){
1710                 $pid = intval( $pid );
1711                 wfQuery("DELETE parsercache FROM parsercache,links ".
1712                         "WHERE pc_title=links.l_from AND l_to={$pid}", DB_WRITE);
1713                 wfQuery("DELETE FROM parsercache WHERE pc_pageid='{$pid}'", DB_WRITE);
1714         }
1715
1716         # $title is a prefixed db title, for example like Title->getPrefixedDBkey() returns.
1717         /* static */ function parsercacheClearBrokenLinksTo( $title ){
1718                 $title = wfStrencode( $title );
1719                 wfQuery("DELETE parsercache FROM parsercache,brokenlinks ".
1720                         "WHERE pc_pageid=bl_from AND bl_to='{$title}'", DB_WRITE);
1721         }
1722
1723         # $pid is a page id
1724         /* static */ function parsercacheClearPage( $pid, $namespace ){
1725                 $pid = intval( $pid );
1726                 if( $namespace == NS_MEDIAWIKI ){
1727                         OutputPage::parsercacheClearLinksTo( $pid );
1728                 } else {
1729                         wfQuery("DELETE FROM parsercache WHERE pc_pageid='{$pid}'", DB_WRITE);
1730                 }
1731         }
1732 }
1733
1734 # Regex callbacks, used in OutputPage::replaceVariables
1735
1736 # Just get rid of the dangerous stuff
1737 # Necessary because replaceVariables is called after removeHTMLtags,
1738 # and message text can come from any user
1739 function wfReplaceMsgVar( $matches ) {
1740         global $wgCurOut, $wgLinkCache;
1741         $text = $wgCurOut->removeHTMLtags( wfMsg( $matches[1] ) );
1742         $wgLinkCache->suspend();
1743         $text = $wgCurOut->replaceInternalLinks( $text );
1744         $wgLinkCache->resume();
1745         $wgLinkCache->addLinkObj( Title::makeTitle( NS_MEDIAWIKI, $matches[1] ) );
1746         return $text;
1747 }
1748
1749 # Effective <nowiki></nowiki>
1750 # Not real <nowiki> because this is called after nowiki sections are processed
1751 function wfReplaceMsgnwVar( $matches ) {
1752         global $wgCurOut, $wgLinkCache;
1753         $text = wfEscapeWikiText( wfMsg( $matches[1] ) );
1754         $wgLinkCache->addLinkObj( Title::makeTitle( NS_MEDIAWIKI, $matches[1] ) );
1755         return $text;
1756 }
1757
1758 ?>