<?php
/**
- * File for magic words
- * @package MediaWiki
- * @subpackage Parser
- */
-
-/**
- * private
+ * See docs/magicword.txt.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ * http://www.gnu.org/copyleft/gpl.html
+ *
+ * @file
+ * @ingroup Parser
*/
-$wgMagicFound = false;
-
-/** Actual keyword to be used is set in Language.php */
-define('MAG_REDIRECT', 0);
-define('MAG_NOTOC', 1);
-define('MAG_START', 2);
-define('MAG_CURRENTMONTH', 3);
-define('MAG_CURRENTMONTHNAME', 4);
-define('MAG_CURRENTMONTHNAMEGEN', 5);
-define('MAG_CURRENTMONTHABBREV', 6);
-define('MAG_CURRENTDAY', 7);
-define('MAG_CURRENTDAYNAME', 8);
-define('MAG_CURRENTYEAR', 9);
-define('MAG_CURRENTTIME', 10);
-define('MAG_NUMBEROFARTICLES', 11);
-define('MAG_SUBST', 12);
-define('MAG_MSG', 13);
-define('MAG_MSGNW', 14);
-define('MAG_NOEDITSECTION', 15);
-define('MAG_END', 16);
-define('MAG_IMG_THUMBNAIL', 17);
-define('MAG_IMG_RIGHT', 18);
-define('MAG_IMG_LEFT', 19);
-define('MAG_IMG_NONE', 20);
-define('MAG_IMG_WIDTH', 21);
-define('MAG_IMG_CENTER', 22);
-define('MAG_INT', 23);
-define('MAG_FORCETOC', 24);
-define('MAG_SITENAME', 25);
-define('MAG_NS', 26);
-define('MAG_LOCALURL', 27);
-define('MAG_LOCALURLE', 28);
-define('MAG_SERVER', 29);
-define('MAG_IMG_FRAMED', 30);
-define('MAG_PAGENAME', 31);
-define('MAG_PAGENAMEE', 32);
-define('MAG_NAMESPACE', 33);
-define('MAG_TOC', 34);
-define('MAG_GRAMMAR', 35);
-define('MAG_NOTITLECONVERT', 36);
-define('MAG_NOCONTENTCONVERT', 37);
-define('MAG_CURRENTWEEK', 38);
-define('MAG_CURRENTDOW', 39);
-define('MAG_REVISIONID', 40);
-define('MAG_SCRIPTPATH', 41);
-define('MAG_SERVERNAME', 42);
-define('MAG_NUMBEROFFILES', 43);
-
-$wgVariableIDs = array(
- MAG_CURRENTMONTH,
- MAG_CURRENTMONTHNAME,
- MAG_CURRENTMONTHNAMEGEN,
- MAG_CURRENTMONTHABBREV,
- MAG_CURRENTDAY,
- MAG_CURRENTDAYNAME,
- MAG_CURRENTYEAR,
- MAG_CURRENTTIME,
- MAG_NUMBEROFARTICLES,
- MAG_NUMBEROFFILES,
- MAG_SITENAME,
- MAG_SERVER,
- MAG_SERVERNAME,
- MAG_SCRIPTPATH,
- MAG_PAGENAME,
- MAG_PAGENAMEE,
- MAG_NAMESPACE,
- MAG_CURRENTWEEK,
- MAG_CURRENTDOW,
- MAG_REVISIONID,
-);
/**
- * This class encapsulates "magic words" such as #redirect, __NOTOC__, etc.
- * Usage:
- * if (MagicWord::get( MAG_REDIRECT )->match( $text ) )
- *
- * Possible future improvements:
+ * This class encapsulates "magic words" such as "#redirect", __NOTOC__, etc.
+ *
+ * @par Usage:
+ * @code
+ * if (MagicWord::get( 'redirect' )->match( $text ) ) {
+ * // some code
+ * }
+ * @endcode
+ *
+ * Possible future improvements:
* * Simultaneous searching for a number of magic words
- * * $wgMagicWords in shared memory
+ * * MagicWord::$mObjects in shared memory
*
- * Please avoid reading the data out of one of these objects and then writing
+ * Please avoid reading the data out of one of these objects and then writing
* special case code. If possible, add another match()-like function here.
*
- * @package MediaWiki
+ * To add magic words in an extension, use $magicWords in a file listed in
+ * $wgExtensionMessagesFiles[].
+ *
+ * @par Example:
+ * @code
+ * $magicWords = [];
+ *
+ * $magicWords['en'] = [
+ * 'magicwordkey' => [ 0, 'case_insensitive_magic_word' ],
+ * 'magicwordkey2' => [ 1, 'CASE_sensitive_magic_word2' ],
+ * ];
+ * @endcode
+ *
+ * For magic words which are also Parser variables, add a MagicWordwgVariableIDs
+ * hook. Use string keys.
+ *
+ * @ingroup Parser
*/
class MagicWord {
- /**#@+
- * @access private
- */
- var $mId, $mSynonyms, $mCaseSensitive, $mRegex;
- var $mRegexStart, $mBaseRegex, $mVariableRegex;
- var $mModified;
/**#@-*/
- function MagicWord($id = 0, $syn = '', $cs = false) {
+ /** @var int */
+ public $mId;
+
+ /** @var array */
+ public $mSynonyms;
+
+ /** @var bool */
+ public $mCaseSensitive;
+
+ /** @var string */
+ private $mRegex = '';
+
+ /** @var string */
+ private $mRegexStart = '';
+
+ /** @var string */
+ private $mRegexStartToEnd = '';
+
+ /** @var string */
+ private $mBaseRegex = '';
+
+ /** @var string */
+ private $mVariableRegex = '';
+
+ /** @var string */
+ private $mVariableStartToEndRegex = '';
+
+ /** @var bool */
+ private $mModified = false;
+
+ /** @var bool */
+ private $mFound = false;
+
+ public static $mVariableIDsInitialised = false;
+ public static $mVariableIDs = [
+ '!',
+ 'currentmonth',
+ 'currentmonth1',
+ 'currentmonthname',
+ 'currentmonthnamegen',
+ 'currentmonthabbrev',
+ 'currentday',
+ 'currentday2',
+ 'currentdayname',
+ 'currentyear',
+ 'currenttime',
+ 'currenthour',
+ 'localmonth',
+ 'localmonth1',
+ 'localmonthname',
+ 'localmonthnamegen',
+ 'localmonthabbrev',
+ 'localday',
+ 'localday2',
+ 'localdayname',
+ 'localyear',
+ 'localtime',
+ 'localhour',
+ 'numberofarticles',
+ 'numberoffiles',
+ 'numberofedits',
+ 'articlepath',
+ 'pageid',
+ 'sitename',
+ 'server',
+ 'servername',
+ 'scriptpath',
+ 'stylepath',
+ 'pagename',
+ 'pagenamee',
+ 'fullpagename',
+ 'fullpagenamee',
+ 'namespace',
+ 'namespacee',
+ 'namespacenumber',
+ 'currentweek',
+ 'currentdow',
+ 'localweek',
+ 'localdow',
+ 'revisionid',
+ 'revisionday',
+ 'revisionday2',
+ 'revisionmonth',
+ 'revisionmonth1',
+ 'revisionyear',
+ 'revisiontimestamp',
+ 'revisionuser',
+ 'revisionsize',
+ 'subpagename',
+ 'subpagenamee',
+ 'talkspace',
+ 'talkspacee',
+ 'subjectspace',
+ 'subjectspacee',
+ 'talkpagename',
+ 'talkpagenamee',
+ 'subjectpagename',
+ 'subjectpagenamee',
+ 'numberofusers',
+ 'numberofactiveusers',
+ 'numberofpages',
+ 'currentversion',
+ 'rootpagename',
+ 'rootpagenamee',
+ 'basepagename',
+ 'basepagenamee',
+ 'currenttimestamp',
+ 'localtimestamp',
+ 'directionmark',
+ 'contentlanguage',
+ 'pagelanguage',
+ 'numberofadmins',
+ 'cascadingsources',
+ ];
+
+ /* Array of caching hints for ParserCache */
+ public static $mCacheTTLs = [
+ 'currentmonth' => 86400,
+ 'currentmonth1' => 86400,
+ 'currentmonthname' => 86400,
+ 'currentmonthnamegen' => 86400,
+ 'currentmonthabbrev' => 86400,
+ 'currentday' => 3600,
+ 'currentday2' => 3600,
+ 'currentdayname' => 3600,
+ 'currentyear' => 86400,
+ 'currenttime' => 3600,
+ 'currenthour' => 3600,
+ 'localmonth' => 86400,
+ 'localmonth1' => 86400,
+ 'localmonthname' => 86400,
+ 'localmonthnamegen' => 86400,
+ 'localmonthabbrev' => 86400,
+ 'localday' => 3600,
+ 'localday2' => 3600,
+ 'localdayname' => 3600,
+ 'localyear' => 86400,
+ 'localtime' => 3600,
+ 'localhour' => 3600,
+ 'numberofarticles' => 3600,
+ 'numberoffiles' => 3600,
+ 'numberofedits' => 3600,
+ 'currentweek' => 3600,
+ 'currentdow' => 3600,
+ 'localweek' => 3600,
+ 'localdow' => 3600,
+ 'numberofusers' => 3600,
+ 'numberofactiveusers' => 3600,
+ 'numberofpages' => 3600,
+ 'currentversion' => 86400,
+ 'currenttimestamp' => 3600,
+ 'localtimestamp' => 3600,
+ 'pagesinnamespace' => 3600,
+ 'numberofadmins' => 3600,
+ 'numberingroup' => 3600,
+ ];
+
+ public static $mDoubleUnderscoreIDs = [
+ 'notoc',
+ 'nogallery',
+ 'forcetoc',
+ 'toc',
+ 'noeditsection',
+ 'newsectionlink',
+ 'nonewsectionlink',
+ 'hiddencat',
+ 'index',
+ 'noindex',
+ 'staticredirect',
+ 'notitleconvert',
+ 'nocontentconvert',
+ ];
+
+ public static $mSubstIDs = [
+ 'subst',
+ 'safesubst',
+ ];
+
+ public static $mObjects = [];
+ public static $mDoubleUnderscoreArray = null;
+
+ /**#@-*/
+
+ public function __construct( $id = 0, $syn = [], $cs = false ) {
$this->mId = $id;
$this->mSynonyms = (array)$syn;
$this->mCaseSensitive = $cs;
- $this->mRegex = '';
- $this->mRegexStart = '';
- $this->mVariableRegex = '';
- $this->mVariableStartToEndRegex = '';
- $this->mModified = false;
}
/**
* Factory: creates an object representing an ID
- * @static
+ *
+ * @param int $id
+ *
+ * @return MagicWord
*/
- function &get( $id ) {
- global $wgMagicWords;
-
- if ( !is_array( $wgMagicWords ) ) {
- wfDebugDieBacktrace( "Incorrect initialisation order, \$wgMagicWords does not exist\n" );
- }
- if (!array_key_exists( $id, $wgMagicWords ) ) {
+ public static function &get( $id ) {
+ if ( !isset( self::$mObjects[$id] ) ) {
$mw = new MagicWord();
$mw->load( $id );
- $wgMagicWords[$id] = $mw;
+ self::$mObjects[$id] = $mw;
+ }
+ return self::$mObjects[$id];
+ }
+
+ /**
+ * Get an array of parser variable IDs
+ *
+ * @return array
+ */
+ public static function getVariableIDs() {
+ if ( !self::$mVariableIDsInitialised ) {
+ # Get variable IDs
+ Hooks::run( 'MagicWordwgVariableIDs', [ &self::$mVariableIDs ] );
+ self::$mVariableIDsInitialised = true;
+ }
+ return self::$mVariableIDs;
+ }
+
+ /**
+ * Get an array of parser substitution modifier IDs
+ * @return array
+ */
+ public static function getSubstIDs() {
+ return self::$mSubstIDs;
+ }
+
+ /**
+ * Allow external reads of TTL array
+ *
+ * @param int $id
+ * @return int
+ */
+ public static function getCacheTTL( $id ) {
+ if ( array_key_exists( $id, self::$mCacheTTLs ) ) {
+ return self::$mCacheTTLs[$id];
+ } else {
+ return -1;
}
- return $wgMagicWords[$id];
}
-
- # Initialises this object with an ID
- function load( $id ) {
- global $wgContLang;
+
+ /**
+ * Get a MagicWordArray of double-underscore entities
+ *
+ * @return MagicWordArray
+ */
+ public static function getDoubleUnderscoreArray() {
+ if ( is_null( self::$mDoubleUnderscoreArray ) ) {
+ Hooks::run( 'GetDoubleUnderscoreIDs', [ &self::$mDoubleUnderscoreIDs ] );
+ self::$mDoubleUnderscoreArray = new MagicWordArray( self::$mDoubleUnderscoreIDs );
+ }
+ return self::$mDoubleUnderscoreArray;
+ }
+
+ /**
+ * Clear the self::$mObjects variable
+ * For use in parser tests
+ */
+ public static function clearCache() {
+ self::$mObjects = [];
+ }
+
+ /**
+ * Initialises this object with an ID
+ *
+ * @param int $id
+ * @throws MWException
+ */
+ public function load( $id ) {
+ global $wgContLang;
$this->mId = $id;
$wgContLang->getMagic( $this );
+ if ( !$this->mSynonyms ) {
+ $this->mSynonyms = [ 'brionmademeputthishere' ];
+ throw new MWException( "Error: invalid magic word '$id'" );
+ }
}
-
+
/**
* Preliminary initialisation
* @private
*/
- function initRegex() {
- #$variableClass = Title::legalChars();
- # This was used for matching "$1" variables, but different uses of the feature will have
- # different restrictions, which should be checked *after* the MagicWord has been matched,
- # not here. - IMSoP
- $escSyn = array_map( 'preg_quote', $this->mSynonyms );
+ public function initRegex() {
+ // Sort the synonyms by length, descending, so that the longest synonym
+ // matches in precedence to the shortest
+ $synonyms = $this->mSynonyms;
+ usort( $synonyms, [ $this, 'compareStringLength' ] );
+
+ $escSyn = [];
+ foreach ( $synonyms as $synonym ) {
+ // In case a magic word contains /, like that's going to happen;)
+ $escSyn[] = preg_quote( $synonym, '/' );
+ }
$this->mBaseRegex = implode( '|', $escSyn );
- $case = $this->mCaseSensitive ? '' : 'i';
+
+ $case = $this->mCaseSensitive ? '' : 'iu';
$this->mRegex = "/{$this->mBaseRegex}/{$case}";
$this->mRegexStart = "/^(?:{$this->mBaseRegex})/{$case}";
+ $this->mRegexStartToEnd = "/^(?:{$this->mBaseRegex})$/{$case}";
$this->mVariableRegex = str_replace( "\\$1", "(.*?)", $this->mRegex );
- $this->mVariableStartToEndRegex = str_replace( "\\$1", "(.*?)",
+ $this->mVariableStartToEndRegex = str_replace( "\\$1", "(.*?)",
"/^(?:{$this->mBaseRegex})$/{$case}" );
}
-
+
+ /**
+ * A comparison function that returns -1, 0 or 1 depending on whether the
+ * first string is longer, the same length or shorter than the second
+ * string.
+ *
+ * @param string $s1
+ * @param string $s2
+ *
+ * @return int
+ */
+ public function compareStringLength( $s1, $s2 ) {
+ $l1 = strlen( $s1 );
+ $l2 = strlen( $s2 );
+ if ( $l1 < $l2 ) {
+ return 1;
+ } elseif ( $l1 > $l2 ) {
+ return -1;
+ } else {
+ return 0;
+ }
+ }
+
/**
* Gets a regex representing matching the word
+ *
+ * @return string
*/
- function getRegex() {
- if ($this->mRegex == '' ) {
+ public function getRegex() {
+ if ( $this->mRegex == '' ) {
$this->initRegex();
}
return $this->mRegex;
}
+ /**
+ * Gets the regexp case modifier to use, i.e. i or nothing, to be used if
+ * one is using MagicWord::getBaseRegex(), otherwise it'll be included in
+ * the complete expression
+ *
+ * @return string
+ */
+ public function getRegexCase() {
+ if ( $this->mRegex === '' ) {
+ $this->initRegex();
+ }
+
+ return $this->mCaseSensitive ? '' : 'iu';
+ }
+
/**
* Gets a regex matching the word, if it is at the string start
+ *
+ * @return string
*/
- function getRegexStart() {
- if ($this->mRegex == '' ) {
+ public function getRegexStart() {
+ if ( $this->mRegex == '' ) {
$this->initRegex();
}
return $this->mRegexStart;
}
+ /**
+ * Gets a regex matching the word from start to end of a string
+ *
+ * @return string
+ * @since 1.23
+ */
+ public function getRegexStartToEnd() {
+ if ( $this->mRegexStartToEnd == '' ) {
+ $this->initRegex();
+ }
+ return $this->mRegexStartToEnd;
+ }
+
/**
* regex without the slashes and what not
+ *
+ * @return string
*/
- function getBaseRegex() {
- if ($this->mRegex == '') {
+ public function getBaseRegex() {
+ if ( $this->mRegex == '' ) {
$this->initRegex();
}
return $this->mBaseRegex;
}
-
+
/**
* Returns true if the text contains the word
+ *
+ * @param string $text
+ *
* @return bool
*/
- function match( $text ) {
- return preg_match( $this->getRegex(), $text );
+ public function match( $text ) {
+ return (bool)preg_match( $this->getRegex(), $text );
}
/**
* Returns true if the text starts with the word
+ *
+ * @param string $text
+ *
* @return bool
*/
- function matchStart( $text ) {
- return preg_match( $this->getRegexStart(), $text );
+ public function matchStart( $text ) {
+ return (bool)preg_match( $this->getRegexStart(), $text );
+ }
+
+ /**
+ * Returns true if the text matched the word
+ *
+ * @param string $text
+ *
+ * @return bool
+ * @since 1.23
+ */
+ public function matchStartToEnd( $text ) {
+ return (bool)preg_match( $this->getRegexStartToEnd(), $text );
}
/**
* The return code is the matched string, if there's no variable
* part in the regex and the matched variable part ($1) if there
* is one.
+ *
+ * @param string $text
+ *
+ * @return string
*/
- function matchVariableStartToEnd( $text ) {
+ public function matchVariableStartToEnd( $text ) {
+ $matches = [];
$matchcount = preg_match( $this->getVariableStartToEndRegex(), $text, $matches );
if ( $matchcount == 0 ) {
- return NULL;
- } elseif ( count($matches) == 1 ) {
- return $matches[0];
+ return null;
} else {
- # multiple matched parts (variable match); some will be empty because of synonyms
- # the variable will be the second non-empty one so remove any blank elements and re-sort the indices
- $matches = array_values(array_filter($matches));
- return $matches[1];
+ # multiple matched parts (variable match); some will be empty because of
+ # synonyms. The variable will be the second non-empty one so remove any
+ # blank elements and re-sort the indices.
+ # See also T8526
+
+ $matches = array_values( array_filter( $matches ) );
+
+ if ( count( $matches ) == 1 ) {
+ return $matches[0];
+ } else {
+ return $matches[1];
+ }
}
}
-
/**
* Returns true if the text matches the word, and alters the
* input string, removing all instances of the word
+ *
+ * @param string &$text
+ *
+ * @return bool
*/
- function matchAndRemove( &$text ) {
- global $wgMagicFound;
- $wgMagicFound = false;
- $text = preg_replace_callback( $this->getRegex(), 'pregRemoveAndRecord', $text );
- return $wgMagicFound;
+ public function matchAndRemove( &$text ) {
+ $this->mFound = false;
+ $text = preg_replace_callback(
+ $this->getRegex(),
+ [ $this, 'pregRemoveAndRecord' ],
+ $text
+ );
+
+ return $this->mFound;
}
- function matchStartAndRemove( &$text ) {
- global $wgMagicFound;
- $wgMagicFound = false;
- $text = preg_replace_callback( $this->getRegexStart(), 'pregRemoveAndRecord', $text );
- return $wgMagicFound;
- }
+ /**
+ * @param string &$text
+ * @return bool
+ */
+ public function matchStartAndRemove( &$text ) {
+ $this->mFound = false;
+ $text = preg_replace_callback(
+ $this->getRegexStart(),
+ [ $this, 'pregRemoveAndRecord' ],
+ $text
+ );
+
+ return $this->mFound;
+ }
+ /**
+ * Used in matchAndRemove()
+ *
+ * @return string
+ */
+ public function pregRemoveAndRecord() {
+ $this->mFound = true;
+ return '';
+ }
/**
* Replaces the word with something else
+ *
+ * @param string $replacement
+ * @param string $subject
+ * @param int $limit
+ *
+ * @return string
*/
- function replace( $replacement, $subject ) {
- $res = preg_replace( $this->getRegex(), $replacement, $subject );
- $this->mModified = !($res === $subject);
+ public function replace( $replacement, $subject, $limit = -1 ) {
+ $res = preg_replace(
+ $this->getRegex(),
+ StringUtils::escapeRegexReplacement( $replacement ),
+ $subject,
+ $limit
+ );
+ $this->mModified = $res !== $subject;
return $res;
}
* Variable handling: {{SUBST:xxx}} style words
* Calls back a function to determine what to replace xxx with
* Input word must contain $1
+ *
+ * @param string $text
+ * @param callable $callback
+ *
+ * @return string
*/
- function substituteCallback( $text, $callback ) {
- $regex = $this->getVariableRegex();
+ public function substituteCallback( $text, $callback ) {
$res = preg_replace_callback( $this->getVariableRegex(), $callback, $text );
- $this->mModified = !($res === $text);
+ $this->mModified = $res !== $text;
return $res;
}
/**
* Matches the word, where $1 is a wildcard
+ *
+ * @return string
*/
- function getVariableRegex() {
+ public function getVariableRegex() {
if ( $this->mVariableRegex == '' ) {
$this->initRegex();
- }
+ }
return $this->mVariableRegex;
}
/**
* Matches the entire string, where $1 is a wildcard
+ *
+ * @return string
*/
- function getVariableStartToEndRegex() {
+ public function getVariableStartToEndRegex() {
if ( $this->mVariableStartToEndRegex == '' ) {
$this->initRegex();
- }
+ }
return $this->mVariableStartToEndRegex;
}
/**
* Accesses the synonym list directly
+ *
+ * @param int $i
+ *
+ * @return string
*/
- function getSynonym( $i ) {
+ public function getSynonym( $i ) {
return $this->mSynonyms[$i];
}
/**
- * Returns true if the last call to replace() or substituteCallback()
- * returned a modified text, otherwise false.
+ * @return array
*/
- function getWasModified(){
- return $this->mModified;
+ public function getSynonyms() {
+ return $this->mSynonyms;
}
/**
- * $magicarr is an associative array of (magic word ID => replacement)
- * This method uses the php feature to do several replacements at the same time,
- * thereby gaining some efficiency. The result is placed in the out variable
- * $result. The return value is true if something was replaced.
- * @static
- **/
- function replaceMultiple( $magicarr, $subject, &$result ){
- $search = array();
- $replace = array();
- foreach( $magicarr as $id => $replacement ){
- $mw = MagicWord::get( $id );
- $search[] = $mw->getRegex();
- $replace[] = $replacement;
- }
-
- $result = preg_replace( $search, $replace, $subject );
- return !($result === $subject);
+ * Returns true if the last call to replace() or substituteCallback()
+ * returned a modified text, otherwise false.
+ *
+ * @return bool
+ */
+ public function getWasModified() {
+ return $this->mModified;
}
/**
* Adds all the synonyms of this MagicWord to an array, to allow quick
* lookup in a list of magic words
+ *
+ * @param array &$array
+ * @param string $value
*/
- function addToArray( &$array, $value ) {
+ public function addToArray( &$array, $value ) {
+ global $wgContLang;
foreach ( $this->mSynonyms as $syn ) {
- $array[$syn] = $value;
+ $array[$wgContLang->lc( $syn )] = $value;
}
}
-}
-/**
- * Used in matchAndRemove()
- * @private
- **/
-function pregRemoveAndRecord( $match ) {
- global $wgMagicFound;
- $wgMagicFound = true;
- return '';
-}
+ /**
+ * @return bool
+ */
+ public function isCaseSensitive() {
+ return $this->mCaseSensitive;
+ }
-?>
+ /**
+ * @return int
+ */
+ public function getId() {
+ return $this->mId;
+ }
+}
scripts.mit.edu / autoinstallsdev / mediawiki.git / blobdiff