function PageArchive(&$title)
 {
     if (is_null($title)) {
         wfDebugDieBacktrace('Archiver() given a null title.');
     }
     $this->title =& $title;
 }

/**
 * @return string
 */
function oaiDatestamp($timestamp, $granularity = 'YYYY-MM-DDThh:mm:ssZ')
{
    $formats = array('YYYY-MM-DD' => '$1-$2-$3', 'YYYY-MM-DDThh:mm:ssZ' => '$1-$2-$3T$4:$5:$6Z');
    if (!isset($formats[$granularity])) {
        wfDebugDieBacktrace('oaiFormatDate given illegal output format');
    }
    return preg_replace('/^(....)(..)(..)(..)(..)(..)$/', $formats[$granularity], wfTimestamp(TS_MW, $timestamp));
}

 /**
 * Initialization of ... everything
 @return Article either the object to become $wgArticle, or NULL
 */
 function initialize(&$title, &$output, &$user, $request)
 {
     wfProfileIn('MediaWiki::initialize');
     $this->preliminaryChecks($title, $output, $request);
     $article = NULL;
     if (!$this->initializeSpecialCases($title, $output, $request)) {
         $article = $this->initializeArticle($title, $request);
         if (is_object($article)) {
             $this->performAction($output, $article, $title, $user, $request);
         } elseif (is_string($article)) {
             $output->redirect($article);
         } else {
             wfDebugDieBacktrace("Shouldn't happen: MediaWiki::initializeArticle() returned neither an object nor a URL");
         }
     }
     wfProfileOut('MediaWiki::initialize');
     return $article;
 }

 function processLoginRequest($user, $pass)
 {
     global $wgUser, $wgRequest;
     $userlogin = new LoginForm($wgRequest);
     $userlogin->mName = $user;
     $userlogin->mPassword = $pass;
     //$auth = $userlogin->authenticateUserData();
     //$r= new AjaxResponse($auth);
     //return $r;
     $msg = '';
     switch ($userlogin->authenticateUserData()) {
         case LoginForm::SUCCESS:
             $wgUser->setCookies();
             $msg = wfMsgWikiHtml('loginsuccess', $wgUser->getName());
             break;
         case LoginForm::NO_NAME:
         case LoginForm::ILLEGAL:
             $msg = wfMsgWikiHtml('noname');
             break;
         case LoginForm::WRONG_PLUGIN_PASS:
             $msg = wfMsgWikiHtml('wrongpassword');
             break;
         case LoginForm::NOT_EXISTS:
             $msg = wfMsgWikiHtml('nosuchuser', htmlspecialchars($user));
             break;
         case LoginForm::WRONG_PASS:
             $msg = wfMsgWikiHtml('wrongpassword');
             break;
         case LoginForm::EMPTY_PASS:
             $msg = wfMsgWikiHtml('wrongpasswordempty');
             break;
         case LoginForm::RESET_PASS:
             $msg = wfMsgWikiHtml('resetpass_announce');
             break;
         default:
             wfDebugDieBacktrace("Unhandled case value");
     }
     return new AjaxResponse('<div class="pBody">' . $msg . '</div>');
 }

 /**
  * Equivalent of wfCreateObject
  */
 function extCreateObject($name, $p)
 {
     $p = array_values($p);
     switch (count($p)) {
         case 0:
             return new $name();
         case 1:
             return new $name($p[0]);
         case 2:
             return new $name($p[0], $p[1]);
         case 3:
             return new $name($p[0], $p[1], $p[2]);
         case 4:
             return new $name($p[0], $p[1], $p[2], $p[3]);
         case 5:
             return new $name($p[0], $p[1], $p[2], $p[3], $p[4]);
         case 6:
             return new $name($p[0], $p[1], $p[2], $p[3], $p[4], $p[5]);
         default:
             wfDebugDieBacktrace("Too many arguments to constructor in extCreateObject");
     }
 }

 function error()
 {
     wfDebugDieBacktrace("Attempt to call member function of FakeTitle\n");
 }

 static function HTCPPurge($urlArr)
 {
     global $wgHTCPMulticastAddress, $wgHTCPMulticastTTL, $wgHTCPPort;
     $fname = 'SquidUpdate::HTCPPurge';
     wfProfileIn($fname);
     $htcpOpCLR = 4;
     // HTCP CLR
     // FIXME PHP doesn't support these socket constants (include/linux/in.h)
     if (!defined("IPPROTO_IP")) {
         define("IPPROTO_IP", 0);
         define("IP_MULTICAST_LOOP", 34);
         define("IP_MULTICAST_TTL", 33);
     }
     // pfsockopen doesn't work because we need set_sock_opt
     $conn = socket_create(AF_INET, SOCK_DGRAM, SOL_UDP);
     if ($conn) {
         // Set socket options
         socket_set_option($conn, IPPROTO_IP, IP_MULTICAST_LOOP, 0);
         if ($wgHTCPMulticastTTL != 1) {
             socket_set_option($conn, IPPROTO_IP, IP_MULTICAST_TTL, $wgHTCPMulticastTTL);
         }
         foreach ($urlArr as $url) {
             if (!is_string($url)) {
                 wfDebugDieBacktrace('Bad purge URL');
             }
             $url = SquidUpdate::expand($url);
             // Construct a minimal HTCP request diagram
             // as per RFC 2756
             // Opcode 'CLR', no response desired, no auth
             $htcpTransID = rand();
             $htcpSpecifier = pack('na4na*na8n', 4, 'HEAD', strlen($url), $url, 8, 'HTTP/1.0', 0);
             $htcpDataLen = 8 + 2 + strlen($htcpSpecifier);
             $htcpLen = 4 + $htcpDataLen + 2;
             // Note! Squid gets the bit order of the first
             // word wrong, wrt the RFC. Apparently no other
             // implementation exists, so adapt to Squid
             $htcpPacket = pack('nxxnCxNxxa*n', $htcpLen, $htcpDataLen, $htcpOpCLR, $htcpTransID, $htcpSpecifier, 2);
             // Send out
             wfDebug("Purging URL {$url} via HTCP\n");
             socket_sendto($conn, $htcpPacket, $htcpLen, 0, $wgHTCPMulticastAddress, $wgHTCPPort);
         }
     } else {
         $errstr = socket_strerror(socket_last_error());
         wfDebug("SquidUpdate::HTCPPurge(): Error opening UDP socket: {$errstr}\n");
     }
     wfProfileOut($fname);
 }

 /**
  * DELETE query wrapper
  *
  * Use $conds == "*" to delete all rows
  */
 function delete($table, $conds, $fname = 'Database::delete')
 {
     if (!$conds) {
         wfDebugDieBacktrace('Database::delete() called with no conditions');
     }
     $table = $this->tableName($table);
     $sql = "DELETE FROM {$table}";
     if ($conds != '*') {
         $sql .= ' WHERE ' . $this->makeList($conds, LIST_AND);
     }
     return $this->query($sql, $fname);
 }

 /**
  * @param $s string
  * @return string
  */
 function checkTitleEncoding($s)
 {
     if (is_array($s)) {
         wfDebugDieBacktrace('Given array to checkTitleEncoding.');
     }
     # Check for non-UTF-8 URLs
     $ishigh = preg_match('/[\\x80-\\xff]/', $s);
     if (!$ishigh) {
         return $s;
     }
     $isutf8 = preg_match('/^([\\x00-\\x7f]|[\\xc0-\\xdf][\\x80-\\xbf]|' . '[\\xe0-\\xef][\\x80-\\xbf]{2}|[\\xf0-\\xf7][\\x80-\\xbf]{3})+$/', $s);
     if ($isutf8) {
         return $s;
     }
     return $this->iconv($this->fallback8bitEncoding(), 'utf-8', $s);
 }

 /**
  * @param $s string
  * @return string
  */
 function checkTitleEncoding($s)
 {
     if (is_array($s)) {
         wfDebugDieBacktrace('Given array to checkTitleEncoding.');
     }
     if (StringUtils::isUtf8($s)) {
         return $s;
     }
     return $this->iconv($this->fallback8bitEncoding(), 'utf-8', $s);
 }

 function checkDBSchema(&$db)
 {
     # img_name must be unique
     if (!$db->indexUnique('image', 'img_name') && !$db->indexExists('image', 'PRIMARY')) {
         wfDebugDieBacktrace('Database schema not up to date, please run maintenance/archives/patch-image_name_unique.sql');
     }
     #new fields must exist
     if (!$db->fieldExists('image', 'img_media_type') || !$db->fieldExists('image', 'img_metadata') || !$db->fieldExists('image', 'img_width')) {
         wfDebugDieBacktrace('Database schema not up to date, please run maintenance/update.php');
     }
 }

 function processLogin()
 {
     global $wgUser, $wgAuth;
     switch ($this->authenticateUserData()) {
         case self::SUCCESS:
             # We've verified now, update the real record
             if ((bool) $this->mRemember != (bool) $wgUser->getOption('rememberpassword')) {
                 $wgUser->setOption('rememberpassword', $this->mRemember ? 1 : 0);
                 $wgUser->saveSettings();
             } else {
                 $wgUser->invalidateCache();
             }
             $wgUser->setCookies();
             if ($this->hasSessionCookie()) {
                 if ($this->mAutoRedirect != "") {
                     $title = Title::newFromText(urldecode($this->mAutoRedirect));
                     if ($title && is_object($title) && ($this->mFromSite || $this->shouldFollow($title))) {
                         return $this->successfulLogin($title->getLocalURL(), true, true);
                     }
                 }
                 return $this->successfulLogin(wfMsg('loginsuccess_owl', $wgUser->getName()));
             } else {
                 return $this->cookieRedirectCheck('login');
             }
             break;
         case self::NO_NAME:
         case self::ILLEGAL:
             $this->mainLoginForm(wfMsg('noname'), 'error_username');
             break;
         case self::WRONG_PLUGIN_PASS:
             $this->mainLoginForm(wfMsg('wrongpassword'), 'error_password');
             break;
         case self::NOT_EXISTS:
             if ($wgUser->isAllowed('createaccount')) {
                 $this->mainLoginForm(wfMsg('nosuchuser', htmlspecialchars($this->mName)), 'error_username');
             } else {
                 $this->mainLoginForm(wfMsg('nosuchusershort', htmlspecialchars($this->mName)), 'error_username');
             }
             break;
             // XXADDED
         // XXADDED
         case self::NO_EMAIL:
             $this->mainLoginForm(wfMsg('noemail_login'), 'error_username');
             break;
         case self::MULTIPLE_EMAILS:
             $this->mainLoginForm(wfMsg('multipleemails_login'), 'error_username');
             break;
         case self::WRONG_PASS:
             $this->mainLoginForm(wfMsg('wrongpassword'), 'error_password');
             break;
         case self::EMPTY_PASS:
             $this->mainLoginForm(wfMsg('wrongpasswordempty'), 'error_password');
             break;
         case self::RESET_PASS:
             $this->resetLoginForm(wfMsg('resetpass_announce'), 'error_password');
             break;
         default:
             wfDebugDieBacktrace("Unhandled case value");
     }
 }

 /**
  * Pick the appropriate attribute value from a match set from the
  * MW_ATTRIBS_REGEX matches.
  *
  * @param array $set
  * @return string
  * @access private
  */
 function getTagAttributeCallback($set)
 {
     if (isset($set[6])) {
         # Illegal #XXXXXX color with no quotes.
         return $set[6];
     } elseif (isset($set[5])) {
         # No quotes.
         return $set[5];
     } elseif (isset($set[4])) {
         # Single-quoted
         return $set[4];
     } elseif (isset($set[3])) {
         # Double-quoted
         return $set[3];
     } elseif (!isset($set[2])) {
         # In XHTML, attributes must have a value.
         # For 'reduced' form, return explicitly the attribute name here.
         return $set[1];
     } else {
         wfDebugDieBacktrace("Tag conditions not met. This should never happen and is a bug.");
     }
 }

 /** Delete a group */
 function delete()
 {
     global $wgMemc;
     if (Group::getStaticGroups()) {
         wfDebugDieBacktrace("Can't modify groups in static mode");
     }
     if ($this->id == 0) {
         return;
     }
     $fname = 'Group::delete';
     $dbw =& wfGetDB(DB_MASTER);
     // First remove all users from the group
     $dbw->delete('user_group', array('ug_group' => $this->id), $fname);
     // Now delete the group
     $dbw->delete('groups', array('gr_id' => $this->id), $fname);
     $wgMemc->delete(Group::getCacheKey($this->id));
 }

 function MwRdfGetModel($article, $modelnames = null)
 {
     global $wgRdfModelFunctions, $wgRdfDefaultModels;
     if ($modelnames == null) {
         $modelnames = $wgRdfDefaultModels;
     }
     $fullModel = ModelFactory::getDefaultModel();
     $title = $article->mTitle;
     $uri = $title->getFullURL();
     $fullModel->setBaseURI($uri);
     foreach ($modelnames as $modelname) {
         $modelfunc = $wgRdfModelFunctions[$modelname];
         if (!$modelfunc) {
             wfDebugDieBacktrace("MwRdf: No RDF model named '{$modelname}'.");
         } elseif (!function_exists($modelfunc)) {
             wfDebugDieBacktrace("MwRdf: No function named '{$modelfunc}' " . " for model '{$modelname}'.");
         }
         # Check the cache...
         $model = MwRdfGetCache($title, $modelname);
         # If it's not there, regenerate.
         if (!isset($model) || !$model) {
             $model = $modelfunc($article);
             MwRdfSetCache($title, $modelname, $model);
         }
         if (isset($model)) {
             $fullModel->addModel($model);
         }
     }
     return $fullModel;
 }

 protected static function load()
 {
     global $wgFlaggedRevsTags, $wgFlaggedRevTags;
     if (self::$loaded) {
         return true;
     }
     if (!FlaggedRevsSetup::isReady()) {
         // sanity
         wfDebugDieBacktrace('FlaggedRevs config loaded too soon! Possibly before LocalSettings.php!');
     }
     self::$loaded = true;
     $flaggedRevsTags = null;
     if (isset($wgFlaggedRevTags)) {
         $flaggedRevsTags = $wgFlaggedRevTags;
         // b/c
         wfWarn('Please use $wgFlaggedRevsTags instead of $wgFlaggedRevTags in config.');
     } elseif (isset($wgFlaggedRevsTags)) {
         $flaggedRevsTags = $wgFlaggedRevsTags;
     }
     # Assume true, then set to false if needed
     if (!empty($flaggedRevsTags)) {
         self::$qualityVersions = true;
         self::$pristineVersions = true;
         self::$binaryFlagging = count($flaggedRevsTags) <= 1;
     }
     foreach ($flaggedRevsTags as $tag => $levels) {
         # Sanity checks
         $safeTag = htmlspecialchars($tag);
         if (!preg_match('/^[a-zA-Z]{1,20}$/', $tag) || $safeTag !== $tag) {
             die('FlaggedRevs given invalid tag name!');
         }
         # Define "quality" and "pristine" reqs
         if (is_array($levels)) {
             $minQL = $levels['quality'];
             $minPL = $levels['pristine'];
             $ratingLevels = $levels['levels'];
             # B/C, $levels is just an integer (minQL)
         } else {
             global $wgFlaggedRevPristine, $wgFlaggedRevValues;
             $ratingLevels = isset($wgFlaggedRevValues) ? $wgFlaggedRevValues : 1;
             $minQL = $levels;
             // an integer
             $minPL = isset($wgFlaggedRevPristine) ? $wgFlaggedRevPristine : $ratingLevels + 1;
             wfWarn('Please update the format of $wgFlaggedRevsTags in config.');
         }
         # Set FlaggedRevs tags
         self::$dimensions[$tag] = array();
         for ($i = 0; $i <= $ratingLevels; $i++) {
             self::$dimensions[$tag][$i] = "{$tag}-{$i}";
         }
         if ($ratingLevels > 1) {
             self::$binaryFlagging = false;
             // more than one level
         }
         # Sanity checks
         if (!is_integer($minQL) || !is_integer($minPL)) {
             die('FlaggedRevs given invalid tag value!');
         }
         if ($minQL > $ratingLevels) {
             self::$qualityVersions = false;
             self::$pristineVersions = false;
         }
         if ($minPL > $ratingLevels) {
             self::$pristineVersions = false;
         }
         self::$minQL[$tag] = max($minQL, 1);
         self::$minPL[$tag] = max($minPL, 1);
         self::$minSL[$tag] = 1;
     }
     global $wgFlaggedRevsTagsRestrictions, $wgFlagRestrictions;
     if (isset($wgFlagRestrictions)) {
         self::$tagRestrictions = $wgFlagRestrictions;
         // b/c
         wfWarn('Please use $wgFlaggedRevsTagsRestrictions instead of $wgFlagRestrictions in config.');
     } else {
         self::$tagRestrictions = $wgFlaggedRevsTagsRestrictions;
     }
     # Make sure that the restriction levels are unique
     global $wgFlaggedRevsRestrictionLevels;
     self::$restrictionLevels = array_unique($wgFlaggedRevsRestrictionLevels);
     self::$restrictionLevels = array_filter(self::$restrictionLevels, 'strlen');
     # Make sure no talk namespaces are in review namespace
     global $wgFlaggedRevsNamespaces;
     foreach ($wgFlaggedRevsNamespaces as $ns) {
         if (MWNamespace::isTalk($ns)) {
             die('FlaggedRevs given talk namespace in $wgFlaggedRevsNamespaces!');
         } elseif ($ns == NS_MEDIAWIKI) {
             die('FlaggedRevs given NS_MEDIAWIKI in $wgFlaggedRevsNamespaces!');
         }
     }
     self::$reviewNamespaces = $wgFlaggedRevsNamespaces;
     # Handle $wgFlaggedRevsAutoReview settings
     global $wgFlaggedRevsAutoReview, $wgFlaggedRevsAutoReviewNew;
     if (is_int($wgFlaggedRevsAutoReview)) {
         self::$autoReviewConfig = $wgFlaggedRevsAutoReview;
     } else {
         // b/c
         if ($wgFlaggedRevsAutoReview) {
             self::$autoReviewConfig = FR_AUTOREVIEW_CHANGES;
         }
//.........这里部分代码省略.........

 /**
  * @param object $row
  * @access private
  */
 function Revision($row)
 {
     if (is_object($row)) {
         $this->mId = IntVal($row->rev_id);
         $this->mPage = IntVal($row->rev_page);
         $this->mTextId = IntVal($row->rev_text_id);
         $this->mComment = $row->rev_comment;
         $this->mUserText = $row->rev_user_text;
         $this->mUser = IntVal($row->rev_user);
         $this->mMinorEdit = IntVal($row->rev_minor_edit);
         $this->mTimestamp = $row->rev_timestamp;
         $this->mDeleted = IntVal($row->rev_deleted);
         $this->mCurrent = $row->rev_id == $row->page_latest;
         $this->mTitle = Title::makeTitle($row->page_namespace, $row->page_title);
         if (isset($row->old_text)) {
             $this->mText = $this->getRevisionText($row);
         } else {
             $this->mText = null;
         }
     } elseif (is_array($row)) {
         // Build a new revision to be saved...
         global $wgUser;
         $this->mId = isset($row['id']) ? IntVal($row['id']) : null;
         $this->mPage = isset($row['page']) ? IntVal($row['page']) : null;
         $this->mTextId = isset($row['text_id']) ? IntVal($row['text_id']) : null;
         $this->mUserText = isset($row['user_text']) ? StrVal($row['user_text']) : $wgUser->getName();
         $this->mUser = isset($row['user']) ? IntVal($row['user']) : $wgUser->getId();
         $this->mMinorEdit = isset($row['minor_edit']) ? IntVal($row['minor_edit']) : 0;
         $this->mTimestamp = isset($row['timestamp']) ? StrVal($row['timestamp']) : wfTimestamp(TS_MW);
         $this->mDeleted = isset($row['deleted']) ? IntVal($row['deleted']) : 0;
         // Enforce spacing trimming on supplied text
         $this->mComment = isset($row['comment']) ? trim(StrVal($row['comment'])) : null;
         $this->mText = isset($row['text']) ? rtrim(StrVal($row['text'])) : null;
         $this->mTitle = null;
         # Load on demand if needed
         $this->mCurrent = false;
     } else {
         wfDebugDieBacktrace('Revision constructor passed invalid row format.');
     }
 }

 function reportQueryError($error, $errno, $sql, $fname, $tempIgnore = false)
 {
     $message = "A database error has occurred\n" . "Query: {$sql}\n" . "Function: {$fname}\n" . "Error: {$errno} {$error}\n";
     wfDebugDieBacktrace($message);
 }

 /**
  * Factory: creates an object representing an ID
  * @static
  */
 function &get($id)
 {
     global $wgMagicWords;
     if (!is_array($wgMagicWords)) {
         wfDebugDieBacktrace("Incorrect initialisation order, \$wgMagicWords does not exist\n");
     }
     if (!array_key_exists($id, $wgMagicWords)) {
         $mw = new MagicWord();
         $mw->load($id);
         $wgMagicWords[$id] = $mw;
     }
     return $wgMagicWords[$id];
 }

 /**
  * gzwrite() / fwrite() wrapper
  */
 function write(&$handle, $str)
 {
     if ($handle === true || $handle === false) {
         wfDebugDieBacktrace(__METHOD__ . " was passed a boolean as a file handle.\n");
     }
     if ($this->compress) {
         gzwrite($handle, $str);
     } else {
         fwrite($handle, $str);
     }
 }