<?php
/**
- * File for magic words.
- *
* See docs/magicword.txt.
*
* This program is free software; you can redistribute it and/or modify
* @ingroup Parser
*/
-use MediaWiki\Logger\LoggerFactory;
-
/**
* This class encapsulates "magic words" such as "#redirect", __NOTOC__, etc.
*
/** @var bool */
private $mFound = false;
- static public $mVariableIDsInitialised = false;
- static public $mVariableIDs = array(
+ public static $mVariableIDsInitialised = false;
+ public static $mVariableIDs = [
'!',
'currentmonth',
'currentmonth1',
'contentlanguage',
'numberofadmins',
'cascadingsources',
- );
+ ];
/* Array of caching hints for ParserCache */
- static public $mCacheTTLs = array(
+ public static $mCacheTTLs = [
'currentmonth' => 86400,
'currentmonth1' => 86400,
'currentmonthname' => 86400,
'pagesinnamespace' => 3600,
'numberofadmins' => 3600,
'numberingroup' => 3600,
- );
+ ];
- static public $mDoubleUnderscoreIDs = array(
+ public static $mDoubleUnderscoreIDs = [
'notoc',
'nogallery',
'forcetoc',
'staticredirect',
'notitleconvert',
'nocontentconvert',
- );
+ ];
- static public $mSubstIDs = array(
+ public static $mSubstIDs = [
'subst',
'safesubst',
- );
+ ];
- static public $mObjects = array();
- static public $mDoubleUnderscoreArray = null;
+ public static $mObjects = [];
+ public static $mDoubleUnderscoreArray = null;
/**#@-*/
- function __construct( $id = 0, $syn = array(), $cs = false ) {
+ public function __construct( $id = 0, $syn = [], $cs = false ) {
$this->mId = $id;
$this->mSynonyms = (array)$syn;
$this->mCaseSensitive = $cs;
*
* @return MagicWord
*/
- static function &get( $id ) {
+ public static function &get( $id ) {
if ( !isset( self::$mObjects[$id] ) ) {
$mw = new MagicWord();
$mw->load( $id );
*
* @return array
*/
- static function getVariableIDs() {
+ public static function getVariableIDs() {
if ( !self::$mVariableIDsInitialised ) {
# Get variable IDs
- Hooks::run( 'MagicWordwgVariableIDs', array( &self::$mVariableIDs ) );
+ Hooks::run( 'MagicWordwgVariableIDs', [ &self::$mVariableIDs ] );
self::$mVariableIDsInitialised = true;
}
return self::$mVariableIDs;
* Get an array of parser substitution modifier IDs
* @return array
*/
- static function getSubstIDs() {
+ public static function getSubstIDs() {
return self::$mSubstIDs;
}
* @param int $id
* @return int
*/
- static function getCacheTTL( $id ) {
+ public static function getCacheTTL( $id ) {
if ( array_key_exists( $id, self::$mCacheTTLs ) ) {
return self::$mCacheTTLs[$id];
} else {
*
* @return MagicWordArray
*/
- static function getDoubleUnderscoreArray() {
+ public static function getDoubleUnderscoreArray() {
if ( is_null( self::$mDoubleUnderscoreArray ) ) {
- Hooks::run( 'GetDoubleUnderscoreIDs', array( &self::$mDoubleUnderscoreIDs ) );
+ Hooks::run( 'GetDoubleUnderscoreIDs', [ &self::$mDoubleUnderscoreIDs ] );
self::$mDoubleUnderscoreArray = new MagicWordArray( self::$mDoubleUnderscoreIDs );
}
return self::$mDoubleUnderscoreArray;
* For use in parser tests
*/
public static function clearCache() {
- self::$mObjects = array();
+ self::$mObjects = [];
}
/**
* @param int $id
* @throws MWException
*/
- function load( $id ) {
+ public function load( $id ) {
global $wgContLang;
$this->mId = $id;
$wgContLang->getMagic( $this );
if ( !$this->mSynonyms ) {
- $this->mSynonyms = array( 'brionmademeputthishere' );
+ $this->mSynonyms = [ 'brionmademeputthishere' ];
throw new MWException( "Error: invalid magic word '$id'" );
}
}
* Preliminary initialisation
* @private
*/
- function initRegex() {
+ 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, array( $this, 'compareStringLength' ) );
+ usort( $synonyms, [ $this, 'compareStringLength' ] );
- $escSyn = array();
+ $escSyn = [];
foreach ( $synonyms as $synonym ) {
// In case a magic word contains /, like that's going to happen;)
$escSyn[] = preg_quote( $synonym, '/' );
*
* @return int
*/
- function compareStringLength( $s1, $s2 ) {
+ public function compareStringLength( $s1, $s2 ) {
$l1 = strlen( $s1 );
$l2 = strlen( $s2 );
if ( $l1 < $l2 ) {
*
* @return string
*/
- function getRegex() {
+ public function getRegex() {
if ( $this->mRegex == '' ) {
$this->initRegex();
}
*
* @return string
*/
- function getRegexCase() {
+ public function getRegexCase() {
if ( $this->mRegex === '' ) {
$this->initRegex();
}
*
* @return string
*/
- function getRegexStart() {
+ public function getRegexStart() {
if ( $this->mRegex == '' ) {
$this->initRegex();
}
* @return string
* @since 1.23
*/
- function getRegexStartToEnd() {
+ public function getRegexStartToEnd() {
if ( $this->mRegexStartToEnd == '' ) {
$this->initRegex();
}
*
* @return string
*/
- function getBaseRegex() {
+ public function getBaseRegex() {
if ( $this->mRegex == '' ) {
$this->initRegex();
}
*
* @return bool
*/
- function match( $text ) {
+ public function match( $text ) {
return (bool)preg_match( $this->getRegex(), $text );
}
*
* @return bool
*/
- function matchStart( $text ) {
+ public function matchStart( $text ) {
return (bool)preg_match( $this->getRegexStart(), $text );
}
* @return bool
* @since 1.23
*/
- function matchStartToEnd( $text ) {
+ public function matchStartToEnd( $text ) {
return (bool)preg_match( $this->getRegexStartToEnd(), $text );
}
*
* @return string
*/
- function matchVariableStartToEnd( $text ) {
- $matches = array();
+ public function matchVariableStartToEnd( $text ) {
+ $matches = [];
$matchcount = preg_match( $this->getVariableStartToEndRegex(), $text, $matches );
if ( $matchcount == 0 ) {
return null;
*
* @return bool
*/
- function matchAndRemove( &$text ) {
+ public function matchAndRemove( &$text ) {
$this->mFound = false;
$text = preg_replace_callback(
$this->getRegex(),
- array( &$this, 'pregRemoveAndRecord' ),
+ [ &$this, 'pregRemoveAndRecord' ],
$text
);
* @param string $text
* @return bool
*/
- function matchStartAndRemove( &$text ) {
+ public function matchStartAndRemove( &$text ) {
$this->mFound = false;
$text = preg_replace_callback(
$this->getRegexStart(),
- array( &$this, 'pregRemoveAndRecord' ),
+ [ &$this, 'pregRemoveAndRecord' ],
$text
);
*
* @return string
*/
- function pregRemoveAndRecord() {
+ public function pregRemoveAndRecord() {
$this->mFound = true;
return '';
}
*
* @return string
*/
- function replace( $replacement, $subject, $limit = -1 ) {
+ public function replace( $replacement, $subject, $limit = -1 ) {
$res = preg_replace(
$this->getRegex(),
StringUtils::escapeRegexReplacement( $replacement ),
*
* @return string
*/
- function substituteCallback( $text, $callback ) {
+ public function substituteCallback( $text, $callback ) {
$res = preg_replace_callback( $this->getVariableRegex(), $callback, $text );
$this->mModified = $res !== $text;
return $res;
*
* @return string
*/
- function getVariableRegex() {
+ public function getVariableRegex() {
if ( $this->mVariableRegex == '' ) {
$this->initRegex();
}
*
* @return string
*/
- function getVariableStartToEndRegex() {
+ public function getVariableStartToEndRegex() {
if ( $this->mVariableStartToEndRegex == '' ) {
$this->initRegex();
}
*
* @return string
*/
- function getSynonym( $i ) {
+ public function getSynonym( $i ) {
return $this->mSynonyms[$i];
}
/**
* @return array
*/
- function getSynonyms() {
+ public function getSynonyms() {
return $this->mSynonyms;
}
*
* @return bool
*/
- function getWasModified() {
+ public function getWasModified() {
return $this->mModified;
}
*
* @return bool
*/
- function replaceMultiple( $magicarr, $subject, &$result ) {
+ public function replaceMultiple( $magicarr, $subject, &$result ) {
wfDeprecated( __METHOD__, '1.25' );
- $search = array();
- $replace = array();
+ $search = [];
+ $replace = [];
foreach ( $magicarr as $id => $replacement ) {
$mw = MagicWord::get( $id );
$search[] = $mw->getRegex();
* @param array $array
* @param string $value
*/
- function addToArray( &$array, $value ) {
+ public function addToArray( &$array, $value ) {
global $wgContLang;
foreach ( $this->mSynonyms as $syn ) {
$array[$wgContLang->lc( $syn )] = $value;
/**
* @return bool
*/
- function isCaseSensitive() {
+ public function isCaseSensitive() {
return $this->mCaseSensitive;
}
/**
* @return int
*/
- function getId() {
+ public function getId() {
return $this->mId;
}
}
-
-/**
- * Class for handling an array of magic words
- * @ingroup Parser
- */
-class MagicWordArray {
- /** @var array */
- public $names = array();
-
- /** @var array */
- private $hash;
-
- private $baseRegex;
-
- private $regex;
-
- /**
- * @param array $names
- */
- function __construct( $names = array() ) {
- $this->names = $names;
- }
-
- /**
- * Add a magic word by name
- *
- * @param string $name
- */
- public function add( $name ) {
- $this->names[] = $name;
- $this->hash = $this->baseRegex = $this->regex = null;
- }
-
- /**
- * Add a number of magic words by name
- *
- * @param array $names
- */
- public function addArray( $names ) {
- $this->names = array_merge( $this->names, array_values( $names ) );
- $this->hash = $this->baseRegex = $this->regex = null;
- }
-
- /**
- * Get a 2-d hashtable for this array
- * @return array
- */
- function getHash() {
- if ( is_null( $this->hash ) ) {
- global $wgContLang;
- $this->hash = array( 0 => array(), 1 => array() );
- foreach ( $this->names as $name ) {
- $magic = MagicWord::get( $name );
- $case = intval( $magic->isCaseSensitive() );
- foreach ( $magic->getSynonyms() as $syn ) {
- if ( !$case ) {
- $syn = $wgContLang->lc( $syn );
- }
- $this->hash[$case][$syn] = $name;
- }
- }
- }
- return $this->hash;
- }
-
- /**
- * Get the base regex
- * @return array
- */
- function getBaseRegex() {
- if ( is_null( $this->baseRegex ) ) {
- $this->baseRegex = array( 0 => '', 1 => '' );
- foreach ( $this->names as $name ) {
- $magic = MagicWord::get( $name );
- $case = intval( $magic->isCaseSensitive() );
- foreach ( $magic->getSynonyms() as $i => $syn ) {
- // Group name must start with a non-digit in PCRE 8.34+
- $it = strtr( $i, '0123456789', 'abcdefghij' );
- $group = "(?P<{$it}_{$name}>" . preg_quote( $syn, '/' ) . ')';
- if ( $this->baseRegex[$case] === '' ) {
- $this->baseRegex[$case] = $group;
- } else {
- $this->baseRegex[$case] .= '|' . $group;
- }
- }
- }
- }
- return $this->baseRegex;
- }
-
- /**
- * Get an unanchored regex that does not match parameters
- * @return array
- */
- function getRegex() {
- if ( is_null( $this->regex ) ) {
- $base = $this->getBaseRegex();
- $this->regex = array( '', '' );
- if ( $this->baseRegex[0] !== '' ) {
- $this->regex[0] = "/{$base[0]}/iuS";
- }
- if ( $this->baseRegex[1] !== '' ) {
- $this->regex[1] = "/{$base[1]}/S";
- }
- }
- return $this->regex;
- }
-
- /**
- * Get a regex for matching variables with parameters
- *
- * @return string
- */
- function getVariableRegex() {
- return str_replace( "\\$1", "(.*?)", $this->getRegex() );
- }
-
- /**
- * Get a regex anchored to the start of the string that does not match parameters
- *
- * @return array
- */
- function getRegexStart() {
- $base = $this->getBaseRegex();
- $newRegex = array( '', '' );
- if ( $base[0] !== '' ) {
- $newRegex[0] = "/^(?:{$base[0]})/iuS";
- }
- if ( $base[1] !== '' ) {
- $newRegex[1] = "/^(?:{$base[1]})/S";
- }
- return $newRegex;
- }
-
- /**
- * Get an anchored regex for matching variables with parameters
- *
- * @return array
- */
- function getVariableStartToEndRegex() {
- $base = $this->getBaseRegex();
- $newRegex = array( '', '' );
- if ( $base[0] !== '' ) {
- $newRegex[0] = str_replace( "\\$1", "(.*?)", "/^(?:{$base[0]})$/iuS" );
- }
- if ( $base[1] !== '' ) {
- $newRegex[1] = str_replace( "\\$1", "(.*?)", "/^(?:{$base[1]})$/S" );
- }
- return $newRegex;
- }
-
- /**
- * @since 1.20
- * @return array
- */
- public function getNames() {
- return $this->names;
- }
-
- /**
- * Parse a match array from preg_match
- * Returns array(magic word ID, parameter value)
- * If there is no parameter value, that element will be false.
- *
- * @param array $m
- *
- * @throws MWException
- * @return array
- */
- function parseMatch( $m ) {
- reset( $m );
- while ( list( $key, $value ) = each( $m ) ) {
- if ( $key === 0 || $value === '' ) {
- continue;
- }
- $parts = explode( '_', $key, 2 );
- if ( count( $parts ) != 2 ) {
- // This shouldn't happen
- // continue;
- throw new MWException( __METHOD__ . ': bad parameter name' );
- }
- list( /* $synIndex */, $magicName ) = $parts;
- $paramValue = next( $m );
- return array( $magicName, $paramValue );
- }
- // This shouldn't happen either
- throw new MWException( __METHOD__ . ': parameter not found' );
- }
-
- /**
- * Match some text, with parameter capture
- * Returns an array with the magic word name in the first element and the
- * parameter in the second element.
- * Both elements are false if there was no match.
- *
- * @param string $text
- *
- * @return array
- */
- public function matchVariableStartToEnd( $text ) {
- $regexes = $this->getVariableStartToEndRegex();
- foreach ( $regexes as $regex ) {
- if ( $regex !== '' ) {
- $m = array();
- if ( preg_match( $regex, $text, $m ) ) {
- return $this->parseMatch( $m );
- }
- }
- }
- return array( false, false );
- }
-
- /**
- * Match some text, without parameter capture
- * Returns the magic word name, or false if there was no capture
- *
- * @param string $text
- *
- * @return string|bool False on failure
- */
- public function matchStartToEnd( $text ) {
- $hash = $this->getHash();
- if ( isset( $hash[1][$text] ) ) {
- return $hash[1][$text];
- }
- global $wgContLang;
- $lc = $wgContLang->lc( $text );
- if ( isset( $hash[0][$lc] ) ) {
- return $hash[0][$lc];
- }
- return false;
- }
-
- /**
- * Returns an associative array, ID => param value, for all items that match
- * Removes the matched items from the input string (passed by reference)
- *
- * @param string $text
- *
- * @return array
- */
- public function matchAndRemove( &$text ) {
- $found = array();
- $regexes = $this->getRegex();
- foreach ( $regexes as $regex ) {
- if ( $regex === '' ) {
- continue;
- }
- $matches = array();
- $res = preg_match_all( $regex, $text, $matches, PREG_SET_ORDER );
- if ( $res === false ) {
- LoggerFactory::getInstance( 'parser' )->warning( 'preg_match_all returned false', array(
- 'code' => preg_last_error(),
- 'regex' => $regex,
- 'text' => $text,
- ) );
- } elseif ( $res ) {
- foreach ( $matches as $m ) {
- list( $name, $param ) = $this->parseMatch( $m );
- $found[$name] = $param;
- }
- }
- $res = preg_replace( $regex, '', $text );
- if ( $res === null ) {
- LoggerFactory::getInstance( 'parser' )->warning( 'preg_replace returned null', array(
- 'code' => preg_last_error(),
- 'regex' => $regex,
- 'text' => $text,
- ) );
- }
- $text = $res;
- }
- return $found;
- }
-
- /**
- * Return the ID of the magic word at the start of $text, and remove
- * the prefix from $text.
- * Return false if no match found and $text is not modified.
- * Does not match parameters.
- *
- * @param string $text
- *
- * @return int|bool False on failure
- */
- public function matchStartAndRemove( &$text ) {
- $regexes = $this->getRegexStart();
- foreach ( $regexes as $regex ) {
- if ( $regex === '' ) {
- continue;
- }
- if ( preg_match( $regex, $text, $m ) ) {
- list( $id, ) = $this->parseMatch( $m );
- if ( strlen( $m[0] ) >= strlen( $text ) ) {
- $text = '';
- } else {
- $text = substr( $text, strlen( $m[0] ) );
- }
- return $id;
- }
- }
- return false;
- }
-}
dépôts / lhc / web / wiklou.git / blobdiff