includes/parser/Parser.php

   1 <?php
   2 /**
   3  * PHP parser that converts wiki markup to HTML.
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  18  * http://www.gnu.org/copyleft/gpl.html
  19  *
  20  * @file
  21  * @ingroup Parser
  22  */
  23 use MediaWiki\Config\ServiceOptions;
  24 use MediaWiki\Linker\LinkRenderer;
  25 use MediaWiki\Linker\LinkRendererFactory;
  26 use MediaWiki\Linker\LinkTarget;
  27 use MediaWiki\MediaWikiServices;
  28 use MediaWiki\Special\SpecialPageFactory;
  29 use Psr\Log\NullLogger;
  30 use Wikimedia\ScopedCallback;
  31 use Psr\Log\LoggerInterface;
  32
  33 /**
  34  * @defgroup Parser Parser
  35  */
  36
  37 /**
  38  * PHP Parser - Processes wiki markup (which uses a more user-friendly
  39  * syntax, such as "[[link]]" for making links), and provides a one-way
  40  * transformation of that wiki markup it into (X)HTML output / markup
  41  * (which in turn the browser understands, and can display).
  42  *
  43  * There are seven main entry points into the Parser class:
  44  *
  45  * - Parser::parse()
  46  *     produces HTML output
  47  * - Parser::preSaveTransform()
  48  *     produces altered wiki markup
  49  * - Parser::preprocess()
  50  *     removes HTML comments and expands templates
  51  * - Parser::cleanSig() and Parser::cleanSigInSig()
  52  *     cleans a signature before saving it to preferences
  53  * - Parser::getSection()
  54  *     return the content of a section from an article for section editing
  55  * - Parser::replaceSection()
  56  *     replaces a section by number inside an article
  57  * - Parser::getPreloadText()
  58  *     removes <noinclude> sections and <includeonly> tags
  59  *
  60  * @warning $wgUser or $wgTitle or $wgRequest or $wgLang. Keep them away!
  61  *
  62  * @par Settings:
  63  * $wgNamespacesWithSubpages
  64  *
  65  * @par Settings only within ParserOptions:
  66  * $wgAllowExternalImages
  67  * $wgAllowSpecialInclusion
  68  * $wgInterwikiMagic
  69  * $wgMaxArticleSize
  70  *
  71  * @ingroup Parser
  72  */
  73 class Parser {
  74         /**
  75          * Update this version number when the ParserOutput format
  76          * changes in an incompatible way, so the parser cache
  77          * can automatically discard old data.
  78          */
  79         const VERSION = '1.6.4';
  80
  81         /**
  82          * Update this version number when the output of serialiseHalfParsedText()
  83          * changes in an incompatible way
  84          */
  85         const HALF_PARSED_VERSION = 2;
  86
  87         # Flags for Parser::setFunctionHook
  88         const SFH_NO_HASH = 1;
  89         const SFH_OBJECT_ARGS = 2;
  90
  91         # Constants needed for external link processing
  92         # Everything except bracket, space, or control characters
  93         # \p{Zs} is unicode 'separator, space' category. It covers the space 0x20
  94         # as well as U+3000 is IDEOGRAPHIC SPACE for T21052
  95         # \x{FFFD} is the Unicode replacement character, which Preprocessor_DOM
  96         # uses to replace invalid HTML characters.
  97         const EXT_LINK_URL_CLASS = '[^][<>"\\x00-\\x20\\x7F\p{Zs}\x{FFFD}]';
  98         # Simplified expression to match an IPv4 or IPv6 address, or
  99         # at least one character of a host name (embeds EXT_LINK_URL_CLASS)
 100         const EXT_LINK_ADDR = '(?:[0-9.]+|\\[(?i:[0-9a-f:.]+)\\]|[^][<>"\\x00-\\x20\\x7F\p{Zs}\x{FFFD}])';
 101         # RegExp to make image URLs (embeds IPv6 part of EXT_LINK_ADDR)
 102         // phpcs:ignore Generic.Files.LineLength
 103         const EXT_IMAGE_REGEX = '/^(http:\/\/|https:\/\/)((?:\\[(?i:[0-9a-f:.]+)\\])?[^][<>"\\x00-\\x20\\x7F\p{Zs}\x{FFFD}]+)
 104                 \\/([A-Za-z0-9_.,~%\\-+&;#*?!=()@\\x80-\\xFF]+)\\.((?i)gif|png|jpg|jpeg)$/Sxu';
 105
 106         # Regular expression for a non-newline space
 107         const SPACE_NOT_NL = '(?:\t|&nbsp;|&\#0*160;|&\#[Xx]0*[Aa]0;|\p{Zs})';
 108
 109         # Flags for preprocessToDom
 110         const PTD_FOR_INCLUSION = 1;
 111
 112         # Allowed values for $this->mOutputType
 113         # Parameter to startExternalParse().
 114         const OT_HTML = 1; # like parse()
 115         const OT_WIKI = 2; # like preSaveTransform()
 116         const OT_PREPROCESS = 3; # like preprocess()
 117         const OT_MSG = 3;
 118         const OT_PLAIN = 4; # like extractSections() - portions of the original are returned unchanged.
 119
 120         /**
 121          * @var string Prefix and suffix for temporary replacement strings
 122          * for the multipass parser.
 123          *
 124          * \x7f should never appear in input as it's disallowed in XML.
 125          * Using it at the front also gives us a little extra robustness
 126          * since it shouldn't match when butted up against identifier-like
 127          * string constructs.
 128          *
 129          * Must not consist of all title characters, or else it will change
 130          * the behavior of <nowiki> in a link.
 131          *
 132          * Must have a character that needs escaping in attributes, otherwise
 133          * someone could put a strip marker in an attribute, to get around
 134          * escaping quote marks, and break out of the attribute. Thus we add
 135          * `'".
 136          */
 137         const MARKER_SUFFIX = "-QINU`\"'\x7f";
 138         const MARKER_PREFIX = "\x7f'\"`UNIQ-";
 139
 140         # Markers used for wrapping the table of contents
 141         const TOC_START = '<mw:toc>';
 142         const TOC_END = '</mw:toc>';
 143
 144         /** @var int Assume that no output will later be saved this many seconds after parsing */
 145         const MAX_TTS = 900;
 146
 147         # Persistent:
 148         public $mTagHooks = [];
 149         public $mTransparentTagHooks = [];
 150         public $mFunctionHooks = [];
 151         public $mFunctionSynonyms = [ 0 => [], 1 => [] ];
 152         public $mFunctionTagHooks = [];
 153         public $mStripList = [];
 154         public $mDefaultStripList = [];
 155         public $mVarCache = [];
 156         public $mImageParams = [];
 157         public $mImageParamsMagicArray = [];
 158         public $mMarkerIndex = 0;
 159         /**
 160          * @var bool Whether firstCallInit still needs to be called
 161          */
 162         public $mFirstCall = true;
 163
 164         # Initialised by initialiseVariables()
 165
 166         /**
 167          * @var MagicWordArray
 168          */
 169         public $mVariables;
 170
 171         /**
 172          * @var MagicWordArray
 173          */
 174         public $mSubstWords;
 175
 176         /**
 177          * @deprecated since 1.34, there should be no need to use this
 178          * @var array
 179          */
 180         public $mConf;
 181
 182         # Initialised in constructor
 183         public $mExtLinkBracketedRegex, $mUrlProtocols;
 184
 185         # Initialized in getPreprocessor()
 186         /** @var Preprocessor */
 187         public $mPreprocessor;
 188
 189         # Cleared with clearState():
 190         /**
 191          * @var ParserOutput
 192          */
 193         public $mOutput;
 194         public $mAutonumber;
 195
 196         /**
 197          * @var StripState
 198          */
 199         public $mStripState;
 200
 201         public $mIncludeCount;
 202         /**
 203          * @var LinkHolderArray
 204          */
 205         public $mLinkHolders;
 206
 207         public $mLinkID;
 208         public $mIncludeSizes, $mPPNodeCount, $mGeneratedPPNodeCount, $mHighestExpansionDepth;
 209         public $mDefaultSort;
 210         public $mTplRedirCache, $mHeadings, $mDoubleUnderscores;
 211         public $mExpensiveFunctionCount; # number of expensive parser function calls
 212         public $mShowToc, $mForceTocPosition;
 213         /** @var array */
 214         public $mTplDomCache;
 215
 216         /**
 217          * @var User
 218          */
 219         public $mUser; # User object; only used when doing pre-save transform
 220
 221         # Temporary
 222         # These are variables reset at least once per parse regardless of $clearState
 223
 224         /**
 225          * @var ParserOptions
 226          */
 227         public $mOptions;
 228
 229         /**
 230          * @var Title
 231          */
 232         public $mTitle;        # Title context, used for self-link rendering and similar things
 233         public $mOutputType;   # Output type, one of the OT_xxx constants
 234         public $ot;            # Shortcut alias, see setOutputType()
 235         public $mRevisionObject; # The revision object of the specified revision ID
 236         public $mRevisionId;   # ID to display in {{REVISIONID}} tags
 237         public $mRevisionTimestamp; # The timestamp of the specified revision ID
 238         public $mRevisionUser; # User to display in {{REVISIONUSER}} tag
 239         public $mRevisionSize; # Size to display in {{REVISIONSIZE}} variable
 240         public $mRevIdForTs;   # The revision ID which was used to fetch the timestamp
 241         public $mInputSize = false; # For {{PAGESIZE}} on current page.
 242
 243         /**
 244          * @var array Array with the language name of each language link (i.e. the
 245          * interwiki prefix) in the key, value arbitrary. Used to avoid sending
 246          * duplicate language links to the ParserOutput.
 247          */
 248         public $mLangLinkLanguages;
 249
 250         /**
 251          * @var MapCacheLRU|null
 252          * @since 1.24
 253          *
 254          * A cache of the current revisions of titles. Keys are $title->getPrefixedDbKey()
 255          */
 256         public $currentRevisionCache;
 257
 258         /**
 259          * @var bool|string Recursive call protection.
 260          * This variable should be treated as if it were private.
 261          */
 262         public $mInParse = false;
 263
 264         /** @var SectionProfiler */
 265         protected $mProfiler;
 266
 267         /**
 268          * @var LinkRenderer
 269          */
 270         protected $mLinkRenderer;
 271
 272         /** @var MagicWordFactory */
 273         private $magicWordFactory;
 274
 275         /** @var Language */
 276         private $contLang;
 277
 278         /** @var ParserFactory */
 279         private $factory;
 280
 281         /** @var SpecialPageFactory */
 282         private $specialPageFactory;
 283
 284         /**
 285          * This is called $svcOptions instead of $options like elsewhere to avoid confusion with
 286          * $mOptions, which is public and widely used, and also with the local variable $options used
 287          * for ParserOptions throughout this file.
 288          *
 289          * @var ServiceOptions
 290          */
 291         private $svcOptions;
 292
 293         /** @var LinkRendererFactory */
 294         private $linkRendererFactory;
 295
 296         /** @var NamespaceInfo */
 297         private $nsInfo;
 298
 299         /** @var LoggerInterface */
 300         private $logger;
 301
 302         /**
 303          * TODO Make this a const when HHVM support is dropped (T192166)
 304          *
 305          * @var array
 306          * @since 1.33
 307          */
 308         public static $constructorOptions = [
 309                 // See $wgParserConf documentation
 310                 'class',
 311                 'preprocessorClass',
 312                 // See documentation for the corresponding config options
 313                 'ArticlePath',
 314                 'EnableScaryTranscluding',
 315                 'ExtraInterlanguageLinkPrefixes',
 316                 'FragmentMode',
 317                 'LanguageCode',
 318                 'MaxSigChars',
 319                 'MaxTocLevel',
 320                 'MiserMode',
 321                 'ScriptPath',
 322                 'Server',
 323                 'ServerName',
 324                 'ShowHostnames',
 325                 'Sitename',
 326                 'StylePath',
 327                 'TranscludeCacheExpiry',
 328         ];
 329
 330         /**
 331          * Constructing parsers directly is deprecated! Use a ParserFactory.
 332          *
 333          * @param ServiceOptions|null $svcOptions
 334          * @param MagicWordFactory|null $magicWordFactory
 335          * @param Language|null $contLang Content language
 336          * @param ParserFactory|null $factory
 337          * @param string|null $urlProtocols As returned from wfUrlProtocols()
 338          * @param SpecialPageFactory|null $spFactory
 339          * @param LinkRendererFactory|null $linkRendererFactory
 340          * @param NamespaceInfo|null $nsInfo
 341          * @param LoggerInterface|null $logger
 342          */
 343         public function __construct(
 344                 $svcOptions = null,
 345                 MagicWordFactory $magicWordFactory = null,
 346                 Language $contLang = null,
 347                 ParserFactory $factory = null,
 348                 $urlProtocols = null,
 349                 SpecialPageFactory $spFactory = null,
 350                 $linkRendererFactory = null,
 351                 $nsInfo = null,
 352                 $logger = null
 353         ) {
 354                 $services = MediaWikiServices::getInstance();
 355                 if ( !$svcOptions || is_array( $svcOptions ) ) {
 356                         // Pre-1.34 calling convention is the first parameter is just ParserConf, the seventh is
 357                         // Config, and the eighth is LinkRendererFactory.
 358                         $this->mConf = (array)$svcOptions;
 359                         if ( empty( $this->mConf['class'] ) ) {
 360                                 $this->mConf['class'] = self::class;
 361                         }
 362                         if ( empty( $this->mConf['preprocessorClass'] ) ) {
 363                                 $this->mConf['preprocessorClass'] = self::getDefaultPreprocessorClass();
 364                         }
 365                         $this->svcOptions = new ServiceOptions( self::$constructorOptions,
 366                                 $this->mConf,
 367                                 func_num_args() > 6 ? func_get_arg( 6 ) : $services->getMainConfig()
 368                         );
 369                         $linkRendererFactory = func_num_args() > 7 ? func_get_arg( 7 ) : null;
 370                         $nsInfo = func_num_args() > 8 ? func_get_arg( 8 ) : null;
 371                 } else {
 372                         // New calling convention
 373                         $svcOptions->assertRequiredOptions( self::$constructorOptions );
 374                         // $this->mConf is public, so we'll keep those two options there as well for
 375                         // compatibility until it's removed
 376                         $this->mConf = [
 377                                 'class' => $svcOptions->get( 'class' ),
 378                                 'preprocessorClass' => $svcOptions->get( 'preprocessorClass' ),
 379                         ];
 380                         $this->svcOptions = $svcOptions;
 381                 }
 382
 383                 $this->mUrlProtocols = $urlProtocols ?? wfUrlProtocols();
 384                 $this->mExtLinkBracketedRegex = '/\[(((?i)' . $this->mUrlProtocols . ')' .
 385                         self::EXT_LINK_ADDR .
 386                         self::EXT_LINK_URL_CLASS . '*)\p{Zs}*([^\]\\x00-\\x08\\x0a-\\x1F\\x{FFFD}]*?)\]/Su';
 387
 388                 $this->magicWordFactory = $magicWordFactory ??
 389                         $services->getMagicWordFactory();
 390
 391                 $this->contLang = $contLang ?? $services->getContentLanguage();
 392
 393                 $this->factory = $factory ?? $services->getParserFactory();
 394                 $this->specialPageFactory = $spFactory ?? $services->getSpecialPageFactory();
 395                 $this->linkRendererFactory = $linkRendererFactory ?? $services->getLinkRendererFactory();
 396                 $this->nsInfo = $nsInfo ?? $services->getNamespaceInfo();
 397                 $this->logger = $logger ?: new NullLogger();
 398         }
 399
 400         /**
 401          * Reduce memory usage to reduce the impact of circular references
 402          */
 403         public function __destruct() {
 404                 if ( isset( $this->mLinkHolders ) ) {
 405                         unset( $this->mLinkHolders );
 406                 }
 407                 foreach ( $this as $name => $value ) {
 408                         unset( $this->$name );
 409                 }
 410         }
 411
 412         /**
 413          * Allow extensions to clean up when the parser is cloned
 414          */
 415         public function __clone() {
 416                 $this->mInParse = false;
 417
 418                 // T58226: When you create a reference "to" an object field, that
 419                 // makes the object field itself be a reference too (until the other
 420                 // reference goes out of scope). When cloning, any field that's a
 421                 // reference is copied as a reference in the new object. Both of these
 422                 // are defined PHP5 behaviors, as inconvenient as it is for us when old
 423                 // hooks from PHP4 days are passing fields by reference.
 424                 foreach ( [ 'mStripState', 'mVarCache' ] as $k ) {
 425                         // Make a non-reference copy of the field, then rebind the field to
 426                         // reference the new copy.
 427                         $tmp = $this->$k;
 428                         $this->$k =& $tmp;
 429                         unset( $tmp );
 430                 }
 431
 432                 Hooks::run( 'ParserCloned', [ $this ] );
 433         }
 434
 435         /**
 436          * Which class should we use for the preprocessor if not otherwise specified?
 437          *
 438          * @since 1.34
 439          * @deprecated since 1.34, removing configurability of preprocessor
 440          * @return string
 441          */
 442         public static function getDefaultPreprocessorClass() {
 443                 return Preprocessor_Hash::class;
 444         }
 445
 446         /**
 447          * Do various kinds of initialisation on the first call of the parser
 448          */
 449         public function firstCallInit() {
 450                 if ( !$this->mFirstCall ) {
 451                         return;
 452                 }
 453                 $this->mFirstCall = false;
 454
 455                 CoreParserFunctions::register( $this );
 456                 CoreTagHooks::register( $this );
 457                 $this->initialiseVariables();
 458
 459                 // Avoid PHP 7.1 warning from passing $this by reference
 460                 $parser = $this;
 461                 Hooks::run( 'ParserFirstCallInit', [ &$parser ] );
 462         }
 463
 464         /**
 465          * Clear Parser state
 466          *
 467          * @private
 468          */
 469         public function clearState() {
 470                 $this->firstCallInit();
 471                 $this->mOutput = new ParserOutput;
 472                 $this->mOptions->registerWatcher( [ $this->mOutput, 'recordOption' ] );
 473                 $this->mAutonumber = 0;
 474                 $this->mIncludeCount = [];
 475                 $this->mLinkHolders = new LinkHolderArray( $this );
 476                 $this->mLinkID = 0;
 477                 $this->mRevisionObject = $this->mRevisionTimestamp =
 478                         $this->mRevisionId = $this->mRevisionUser = $this->mRevisionSize = null;
 479                 $this->mVarCache = [];
 480                 $this->mUser = null;
 481                 $this->mLangLinkLanguages = [];
 482                 $this->currentRevisionCache = null;
 483
 484                 $this->mStripState = new StripState( $this );
 485
 486                 # Clear these on every parse, T6549
 487                 $this->mTplRedirCache = $this->mTplDomCache = [];
 488
 489                 $this->mShowToc = true;
 490                 $this->mForceTocPosition = false;
 491                 $this->mIncludeSizes = [
 492                         'post-expand' => 0,
 493                         'arg' => 0,
 494                 ];
 495                 $this->mPPNodeCount = 0;
 496                 $this->mGeneratedPPNodeCount = 0;
 497                 $this->mHighestExpansionDepth = 0;
 498                 $this->mDefaultSort = false;
 499                 $this->mHeadings = [];
 500                 $this->mDoubleUnderscores = [];
 501                 $this->mExpensiveFunctionCount = 0;
 502
 503                 # Fix cloning
 504                 if ( isset( $this->mPreprocessor ) && $this->mPreprocessor->parser !== $this ) {
 505                         $this->mPreprocessor = null;
 506                 }
 507
 508                 $this->mProfiler = new SectionProfiler();
 509
 510                 // Avoid PHP 7.1 warning from passing $this by reference
 511                 $parser = $this;
 512                 Hooks::run( 'ParserClearState', [ &$parser ] );
 513         }
 514
 515         /**
 516          * Convert wikitext to HTML
 517          * Do not call this function recursively.
 518          *
 519          * @param string $text Text we want to parse
 520          * @param-taint $text escapes_htmlnoent
 521          * @param Title $title
 522          * @param ParserOptions $options
 523          * @param bool $linestart
 524          * @param bool $clearState
 525          * @param int|null $revid Number to pass in {{REVISIONID}}
 526          * @return ParserOutput A ParserOutput
 527          * @return-taint escaped
 528          */
 529         public function parse(
 530                 $text, Title $title, ParserOptions $options,
 531                 $linestart = true, $clearState = true, $revid = null
 532         ) {
 533                 if ( $clearState ) {
 534                         // We use U+007F DELETE to construct strip markers, so we have to make
 535                         // sure that this character does not occur in the input text.
 536                         $text = strtr( $text, "\x7f", "?" );
 537                         $magicScopeVariable = $this->lock();
 538                 }
 539                 // Strip U+0000 NULL (T159174)
 540                 $text = str_replace( "\000", '', $text );
 541
 542                 $this->startParse( $title, $options, self::OT_HTML, $clearState );
 543
 544                 $this->currentRevisionCache = null;
 545                 $this->mInputSize = strlen( $text );
 546                 if ( $this->mOptions->getEnableLimitReport() ) {
 547                         $this->mOutput->resetParseStartTime();
 548                 }
 549
 550                 $oldRevisionId = $this->mRevisionId;
 551                 $oldRevisionObject = $this->mRevisionObject;
 552                 $oldRevisionTimestamp = $this->mRevisionTimestamp;
 553                 $oldRevisionUser = $this->mRevisionUser;
 554                 $oldRevisionSize = $this->mRevisionSize;
 555                 if ( $revid !== null ) {
 556                         $this->mRevisionId = $revid;
 557                         $this->mRevisionObject = null;
 558                         $this->mRevisionTimestamp = null;
 559                         $this->mRevisionUser = null;
 560                         $this->mRevisionSize = null;
 561                 }
 562
 563                 // Avoid PHP 7.1 warning from passing $this by reference
 564                 $parser = $this;
 565                 Hooks::run( 'ParserBeforeStrip', [ &$parser, &$text, &$this->mStripState ] );
 566                 # No more strip!
 567                 Hooks::run( 'ParserAfterStrip', [ &$parser, &$text, &$this->mStripState ] );
 568                 $text = $this->internalParse( $text );
 569                 Hooks::run( 'ParserAfterParse', [ &$parser, &$text, &$this->mStripState ] );
 570
 571                 $text = $this->internalParseHalfParsed( $text, true, $linestart );
 572
 573                 /**
 574                  * A converted title will be provided in the output object if title and
 575                  * content conversion are enabled, the article text does not contain
 576                  * a conversion-suppressing double-underscore tag, and no
 577                  * {{DISPLAYTITLE:...}} is present. DISPLAYTITLE takes precedence over
 578                  * automatic link conversion.
 579                  */
 580                 if ( !( $options->getDisableTitleConversion()
 581                         || isset( $this->mDoubleUnderscores['nocontentconvert'] )
 582                         || isset( $this->mDoubleUnderscores['notitleconvert'] )
 583                         || $this->mOutput->getDisplayTitle() !== false )
 584                 ) {
 585                         $convruletitle = $this->getTargetLanguage()->getConvRuleTitle();
 586                         if ( $convruletitle ) {
 587                                 $this->mOutput->setTitleText( $convruletitle );
 588                         } else {
 589                                 $titleText = $this->getTargetLanguage()->convertTitle( $title );
 590                                 $this->mOutput->setTitleText( $titleText );
 591                         }
 592                 }
 593
 594                 # Compute runtime adaptive expiry if set
 595                 $this->mOutput->finalizeAdaptiveCacheExpiry();
 596
 597                 # Warn if too many heavyweight parser functions were used
 598                 if ( $this->mExpensiveFunctionCount > $this->mOptions->getExpensiveParserFunctionLimit() ) {
 599                         $this->limitationWarn( 'expensive-parserfunction',
 600                                 $this->mExpensiveFunctionCount,
 601                                 $this->mOptions->getExpensiveParserFunctionLimit()
 602                         );
 603                 }
 604
 605                 # Information on limits, for the benefit of users who try to skirt them
 606                 if ( $this->mOptions->getEnableLimitReport() ) {
 607                         $text .= $this->makeLimitReport();
 608                 }
 609
 610                 # Wrap non-interface parser output in a <div> so it can be targeted
 611                 # with CSS (T37247)
 612                 $class = $this->mOptions->getWrapOutputClass();
 613                 if ( $class !== false && !$this->mOptions->getInterfaceMessage() ) {
 614                         $this->mOutput->addWrapperDivClass( $class );
 615                 }
 616
 617                 $this->mOutput->setText( $text );
 618
 619                 $this->mRevisionId = $oldRevisionId;
 620                 $this->mRevisionObject = $oldRevisionObject;
 621                 $this->mRevisionTimestamp = $oldRevisionTimestamp;
 622                 $this->mRevisionUser = $oldRevisionUser;
 623                 $this->mRevisionSize = $oldRevisionSize;
 624                 $this->mInputSize = false;
 625                 $this->currentRevisionCache = null;
 626
 627                 return $this->mOutput;
 628         }
 629
 630         /**
 631          * Set the limit report data in the current ParserOutput, and return the
 632          * limit report HTML comment.
 633          *
 634          * @return string
 635          */
 636         protected function makeLimitReport() {
 637                 $maxIncludeSize = $this->mOptions->getMaxIncludeSize();
 638
 639                 $cpuTime = $this->mOutput->getTimeSinceStart( 'cpu' );
 640                 if ( $cpuTime !== null ) {
 641                         $this->mOutput->setLimitReportData( 'limitreport-cputime',
 642                                 sprintf( "%.3f", $cpuTime )
 643                         );
 644                 }
 645
 646                 $wallTime = $this->mOutput->getTimeSinceStart( 'wall' );
 647                 $this->mOutput->setLimitReportData( 'limitreport-walltime',
 648                         sprintf( "%.3f", $wallTime )
 649                 );
 650
 651                 $this->mOutput->setLimitReportData( 'limitreport-ppvisitednodes',
 652                         [ $this->mPPNodeCount, $this->mOptions->getMaxPPNodeCount() ]
 653                 );
 654                 $this->mOutput->setLimitReportData( 'limitreport-ppgeneratednodes',
 655                         [ $this->mGeneratedPPNodeCount, $this->mOptions->getMaxGeneratedPPNodeCount() ]
 656                 );
 657                 $this->mOutput->setLimitReportData( 'limitreport-postexpandincludesize',
 658                         [ $this->mIncludeSizes['post-expand'], $maxIncludeSize ]
 659                 );
 660                 $this->mOutput->setLimitReportData( 'limitreport-templateargumentsize',
 661                         [ $this->mIncludeSizes['arg'], $maxIncludeSize ]
 662                 );
 663                 $this->mOutput->setLimitReportData( 'limitreport-expansiondepth',
 664                         [ $this->mHighestExpansionDepth, $this->mOptions->getMaxPPExpandDepth() ]
 665                 );
 666                 $this->mOutput->setLimitReportData( 'limitreport-expensivefunctioncount',
 667                         [ $this->mExpensiveFunctionCount, $this->mOptions->getExpensiveParserFunctionLimit() ]
 668                 );
 669
 670                 foreach ( $this->mStripState->getLimitReport() as list( $key, $value ) ) {
 671                         $this->mOutput->setLimitReportData( $key, $value );
 672                 }
 673
 674                 Hooks::run( 'ParserLimitReportPrepare', [ $this, $this->mOutput ] );
 675
 676                 $limitReport = "NewPP limit report\n";
 677                 if ( $this->svcOptions->get( 'ShowHostnames' ) ) {
 678                         $limitReport .= 'Parsed by ' . wfHostname() . "\n";
 679                 }
 680                 $limitReport .= 'Cached time: ' . $this->mOutput->getCacheTime() . "\n";
 681                 $limitReport .= 'Cache expiry: ' . $this->mOutput->getCacheExpiry() . "\n";
 682                 $limitReport .= 'Dynamic content: ' .
 683                         ( $this->mOutput->hasDynamicContent() ? 'true' : 'false' ) .
 684                         "\n";
 685                 $limitReport .= 'Complications: [' . implode( ', ', $this->mOutput->getAllFlags() ) . "]\n";
 686
 687                 foreach ( $this->mOutput->getLimitReportData() as $key => $value ) {
 688                         if ( Hooks::run( 'ParserLimitReportFormat',
 689                                 [ $key, &$value, &$limitReport, false, false ]
 690                         ) ) {
 691                                 $keyMsg = wfMessage( $key )->inLanguage( 'en' )->useDatabase( false );
 692                                 $valueMsg = wfMessage( [ "$key-value-text", "$key-value" ] )
 693                                         ->inLanguage( 'en' )->useDatabase( false );
 694                                 if ( !$valueMsg->exists() ) {
 695                                         $valueMsg = new RawMessage( '$1' );
 696                                 }
 697                                 if ( !$keyMsg->isDisabled() && !$valueMsg->isDisabled() ) {
 698                                         $valueMsg->params( $value );
 699                                         $limitReport .= "{$keyMsg->text()}: {$valueMsg->text()}\n";
 700                                 }
 701                         }
 702                 }
 703                 // Since we're not really outputting HTML, decode the entities and
 704                 // then re-encode the things that need hiding inside HTML comments.
 705                 $limitReport = htmlspecialchars_decode( $limitReport );
 706
 707                 // Sanitize for comment. Note '‐' in the replacement is U+2010,
 708                 // which looks much like the problematic '-'.
 709                 $limitReport = str_replace( [ '-', '&' ], [ '‐', '&amp;' ], $limitReport );
 710                 $text = "\n<!-- \n$limitReport-->\n";
 711
 712                 // Add on template profiling data in human/machine readable way
 713                 $dataByFunc = $this->mProfiler->getFunctionStats();
 714                 uasort( $dataByFunc, function ( $a, $b ) {
 715                         return $b['real'] <=> $a['real']; // descending order
 716                 } );
 717                 $profileReport = [];
 718                 foreach ( array_slice( $dataByFunc, 0, 10 ) as $item ) {
 719                         $profileReport[] = sprintf( "%6.2f%% %8.3f %6d %s",
 720                                 $item['%real'], $item['real'], $item['calls'],
 721                                 htmlspecialchars( $item['name'] ) );
 722                 }
 723                 $text .= "<!--\nTransclusion expansion time report (%,ms,calls,template)\n";
 724                 $text .= implode( "\n", $profileReport ) . "\n-->\n";
 725
 726                 $this->mOutput->setLimitReportData( 'limitreport-timingprofile', $profileReport );
 727
 728                 // Add other cache related metadata
 729                 if ( $this->svcOptions->get( 'ShowHostnames' ) ) {
 730                         $this->mOutput->setLimitReportData( 'cachereport-origin', wfHostname() );
 731                 }
 732                 $this->mOutput->setLimitReportData( 'cachereport-timestamp',
 733                         $this->mOutput->getCacheTime() );
 734                 $this->mOutput->setLimitReportData( 'cachereport-ttl',
 735                         $this->mOutput->getCacheExpiry() );
 736                 $this->mOutput->setLimitReportData( 'cachereport-transientcontent',
 737                         $this->mOutput->hasDynamicContent() );
 738
 739                 if ( $this->mGeneratedPPNodeCount > $this->mOptions->getMaxGeneratedPPNodeCount() / 10 ) {
 740                         wfDebugLog( 'generated-pp-node-count', $this->mGeneratedPPNodeCount . ' ' .
 741                                 $this->mTitle->getPrefixedDBkey() );
 742                 }
 743                 return $text;
 744         }
 745
 746         /**
 747          * Half-parse wikitext to half-parsed HTML. This recursive parser entry point
 748          * can be called from an extension tag hook.
 749          *
 750          * The output of this function IS NOT SAFE PARSED HTML; it is "half-parsed"
 751          * instead, which means that lists and links have not been fully parsed yet,
 752          * and strip markers are still present.
 753          *
 754          * Use recursiveTagParseFully() to fully parse wikitext to output-safe HTML.
 755          *
 756          * Use this function if you're a parser tag hook and you want to parse
 757          * wikitext before or after applying additional transformations, and you
 758          * intend to *return the result as hook output*, which will cause it to go
 759          * through the rest of parsing process automatically.
 760          *
 761          * If $frame is not provided, then template variables (e.g., {{{1}}}) within
 762          * $text are not expanded
 763          *
 764          * @param string $text Text extension wants to have parsed
 765          * @param-taint $text escapes_htmlnoent
 766          * @param bool|PPFrame $frame The frame to use for expanding any template variables
 767          * @return string UNSAFE half-parsed HTML
 768          * @return-taint escaped
 769          */
 770         public function recursiveTagParse( $text, $frame = false ) {
 771                 // Avoid PHP 7.1 warning from passing $this by reference
 772                 $parser = $this;
 773                 Hooks::run( 'ParserBeforeStrip', [ &$parser, &$text, &$this->mStripState ] );
 774                 Hooks::run( 'ParserAfterStrip', [ &$parser, &$text, &$this->mStripState ] );
 775                 $text = $this->internalParse( $text, false, $frame );
 776                 return $text;
 777         }
 778
 779         /**
 780          * Fully parse wikitext to fully parsed HTML. This recursive parser entry
 781          * point can be called from an extension tag hook.
 782          *
 783          * The output of this function is fully-parsed HTML that is safe for output.
 784          * If you're a parser tag hook, you might want to use recursiveTagParse()
 785          * instead.
 786          *
 787          * If $frame is not provided, then template variables (e.g., {{{1}}}) within
 788          * $text are not expanded
 789          *
 790          * @since 1.25
 791          *
 792          * @param string $text Text extension wants to have parsed
 793          * @param-taint $text escapes_htmlnoent
 794          * @param bool|PPFrame $frame The frame to use for expanding any template variables
 795          * @return string Fully parsed HTML
 796          * @return-taint escaped
 797          */
 798         public function recursiveTagParseFully( $text, $frame = false ) {
 799                 $text = $this->recursiveTagParse( $text, $frame );
 800                 $text = $this->internalParseHalfParsed( $text, false );
 801                 return $text;
 802         }
 803
 804         /**
 805          * Expand templates and variables in the text, producing valid, static wikitext.
 806          * Also removes comments.
 807          * Do not call this function recursively.
 808          * @param string $text
 809          * @param Title|null $title
 810          * @param ParserOptions $options
 811          * @param int|null $revid
 812          * @param bool|PPFrame $frame
 813          * @return mixed|string
 814          */
 815         public function preprocess( $text, Title $title = null,
 816                 ParserOptions $options, $revid = null, $frame = false
 817         ) {
 818                 $magicScopeVariable = $this->lock();
 819                 $this->startParse( $title, $options, self::OT_PREPROCESS, true );
 820                 if ( $revid !== null ) {
 821                         $this->mRevisionId = $revid;
 822                 }
 823                 // Avoid PHP 7.1 warning from passing $this by reference
 824                 $parser = $this;
 825                 Hooks::run( 'ParserBeforeStrip', [ &$parser, &$text, &$this->mStripState ] );
 826                 Hooks::run( 'ParserAfterStrip', [ &$parser, &$text, &$this->mStripState ] );
 827                 $text = $this->replaceVariables( $text, $frame );
 828                 $text = $this->mStripState->unstripBoth( $text );
 829                 return $text;
 830         }
 831
 832         /**
 833          * Recursive parser entry point that can be called from an extension tag
 834          * hook.
 835          *
 836          * @param string $text Text to be expanded
 837          * @param bool|PPFrame $frame The frame to use for expanding any template variables
 838          * @return string
 839          * @since 1.19
 840          */
 841         public function recursivePreprocess( $text, $frame = false ) {
 842                 $text = $this->replaceVariables( $text, $frame );
 843                 $text = $this->mStripState->unstripBoth( $text );
 844                 return $text;
 845         }
 846
 847         /**
 848          * Process the wikitext for the "?preload=" feature. (T7210)
 849          *
 850          * "<noinclude>", "<includeonly>" etc. are parsed as for template
 851          * transclusion, comments, templates, arguments, tags hooks and parser
 852          * functions are untouched.
 853          *
 854          * @param string $text
 855          * @param Title $title
 856          * @param ParserOptions $options
 857          * @param array $params
 858          * @return string
 859          */
 860         public function getPreloadText( $text, Title $title, ParserOptions $options, $params = [] ) {
 861                 $msg = new RawMessage( $text );
 862                 $text = $msg->params( $params )->plain();
 863
 864                 # Parser (re)initialisation
 865                 $magicScopeVariable = $this->lock();
 866                 $this->startParse( $title, $options, self::OT_PLAIN, true );
 867
 868                 $flags = PPFrame::NO_ARGS | PPFrame::NO_TEMPLATES;
 869                 $dom = $this->preprocessToDom( $text, self::PTD_FOR_INCLUSION );
 870                 $text = $this->getPreprocessor()->newFrame()->expand( $dom, $flags );
 871                 $text = $this->mStripState->unstripBoth( $text );
 872                 return $text;
 873         }
 874
 875         /**
 876          * Set the current user.
 877          * Should only be used when doing pre-save transform.
 878          *
 879          * @param User|null $user User object or null (to reset)
 880          */
 881         public function setUser( $user ) {
 882                 $this->mUser = $user;
 883         }
 884
 885         /**
 886          * Set the context title
 887          *
 888          * @param Title $t
 889          */
 890         public function setTitle( $t ) {
 891                 if ( !$t ) {
 892                         $t = Title::newFromText( 'NO TITLE' );
 893                 }
 894
 895                 if ( $t->hasFragment() ) {
 896                         # Strip the fragment to avoid various odd effects
 897                         $this->mTitle = $t->createFragmentTarget( '' );
 898                 } else {
 899                         $this->mTitle = $t;
 900                 }
 901         }
 902
 903         /**
 904          * Accessor for the Title object
 905          *
 906          * @return Title|null
 907          */
 908         public function getTitle() {
 909                 return $this->mTitle;
 910         }
 911
 912         /**
 913          * Accessor/mutator for the Title object
 914          *
 915          * @param Title|null $x Title object or null to just get the current one
 916          * @return Title
 917          */
 918         public function Title( $x = null ) {
 919                 return wfSetVar( $this->mTitle, $x );
 920         }
 921
 922         /**
 923          * Set the output type
 924          *
 925          * @param int $ot New value
 926          */
 927         public function setOutputType( $ot ) {
 928                 $this->mOutputType = $ot;
 929                 # Shortcut alias
 930                 $this->ot = [
 931                         'html' => $ot == self::OT_HTML,
 932                         'wiki' => $ot == self::OT_WIKI,
 933                         'pre' => $ot == self::OT_PREPROCESS,
 934                         'plain' => $ot == self::OT_PLAIN,
 935                 ];
 936         }
 937
 938         /**
 939          * Accessor/mutator for the output type
 940          *
 941          * @param int|null $x New value or null to just get the current one
 942          * @return int
 943          */
 944         public function OutputType( $x = null ) {
 945                 return wfSetVar( $this->mOutputType, $x );
 946         }
 947
 948         /**
 949          * Get the ParserOutput object
 950          *
 951          * @return ParserOutput
 952          */
 953         public function getOutput() {
 954                 return $this->mOutput;
 955         }
 956
 957         /**
 958          * Get the ParserOptions object
 959          *
 960          * @return ParserOptions
 961          */
 962         public function getOptions() {
 963                 return $this->mOptions;
 964         }
 965
 966         /**
 967          * Accessor/mutator for the ParserOptions object
 968          *
 969          * @param ParserOptions|null $x New value or null to just get the current one
 970          * @return ParserOptions Current ParserOptions object
 971          */
 972         public function Options( $x = null ) {
 973                 return wfSetVar( $this->mOptions, $x );
 974         }
 975
 976         /**
 977          * @return int
 978          */
 979         public function nextLinkID() {
 980                 return $this->mLinkID++;
 981         }
 982
 983         /**
 984          * @param int $id
 985          */
 986         public function setLinkID( $id ) {
 987                 $this->mLinkID = $id;
 988         }
 989
 990         /**
 991          * Get a language object for use in parser functions such as {{FORMATNUM:}}
 992          * @return Language
 993          */
 994         public function getFunctionLang() {
 995                 return $this->getTargetLanguage();
 996         }
 997
 998         /**
 999          * Get the target language for the content being parsed. This is usually the
1000          * language that the content is in.
1001          *
1002          * @since 1.19
1003          *
1004          * @throws MWException
1005          * @return Language
1006          */
1007         public function getTargetLanguage() {
1008                 $target = $this->mOptions->getTargetLanguage();
1009
1010                 if ( $target !== null ) {
1011                         return $target;
1012                 } elseif ( $this->mOptions->getInterfaceMessage() ) {
1013                         return $this->mOptions->getUserLangObj();
1014                 } elseif ( is_null( $this->mTitle ) ) {
1015                         throw new MWException( __METHOD__ . ': $this->mTitle is null' );
1016                 }
1017
1018                 return $this->mTitle->getPageLanguage();
1019         }
1020
1021         /**
1022          * Get the language object for language conversion
1023          * @deprecated since 1.32, just use getTargetLanguage()
1024          * @return Language|null
1025          */
1026         public function getConverterLanguage() {
1027                 return $this->getTargetLanguage();
1028         }
1029
1030         /**
1031          * Get a User object either from $this->mUser, if set, or from the
1032          * ParserOptions object otherwise
1033          *
1034          * @return User
1035          */
1036         public function getUser() {
1037                 if ( !is_null( $this->mUser ) ) {
1038                         return $this->mUser;
1039                 }
1040                 return $this->mOptions->getUser();
1041         }
1042
1043         /**
1044          * Get a preprocessor object
1045          *
1046          * @return Preprocessor
1047          */
1048         public function getPreprocessor() {
1049                 if ( !isset( $this->mPreprocessor ) ) {
1050                         $class = $this->svcOptions->get( 'preprocessorClass' );
1051                         $this->mPreprocessor = new $class( $this );
1052                 }
1053                 return $this->mPreprocessor;
1054         }
1055
1056         /**
1057          * Get a LinkRenderer instance to make links with
1058          *
1059          * @since 1.28
1060          * @return LinkRenderer
1061          */
1062         public function getLinkRenderer() {
1063                 // XXX We make the LinkRenderer with current options and then cache it forever
1064                 if ( !$this->mLinkRenderer ) {
1065                         $this->mLinkRenderer = $this->linkRendererFactory->create();
1066                         $this->mLinkRenderer->setStubThreshold(
1067                                 $this->getOptions()->getStubThreshold()
1068                         );
1069                 }
1070
1071                 return $this->mLinkRenderer;
1072         }
1073
1074         /**
1075          * Get the MagicWordFactory that this Parser is using
1076          *
1077          * @since 1.32
1078          * @return MagicWordFactory
1079          */
1080         public function getMagicWordFactory() {
1081                 return $this->magicWordFactory;
1082         }
1083
1084         /**
1085          * Get the content language that this Parser is using
1086          *
1087          * @since 1.32
1088          * @return Language
1089          */
1090         public function getContentLanguage() {
1091                 return $this->contLang;
1092         }
1093
1094         /**
1095          * Replaces all occurrences of HTML-style comments and the given tags
1096          * in the text with a random marker and returns the next text. The output
1097          * parameter $matches will be an associative array filled with data in
1098          * the form:
1099          *
1100          * @code
1101          *   'UNIQ-xxxxx' => [
1102          *     'element',
1103          *     'tag content',
1104          *     [ 'param' => 'x' ],
1105          *     '<element param="x">tag content</element>' ]
1106          * @endcode
1107          *
1108          * @param array $elements List of element names. Comments are always extracted.
1109          * @param string $text Source text string.
1110          * @param array &$matches Out parameter, Array: extracted tags
1111          * @return string Stripped text
1112          */
1113         public static function extractTagsAndParams( $elements, $text, &$matches ) {
1114                 static $n = 1;
1115                 $stripped = '';
1116                 $matches = [];
1117
1118                 $taglist = implode( '|', $elements );
1119                 $start = "/<($taglist)(\\s+[^>]*?|\\s*?)(\/?>)|<(!--)/i";
1120
1121                 while ( $text != '' ) {
1122                         $p = preg_split( $start, $text, 2, PREG_SPLIT_DELIM_CAPTURE );
1123                         $stripped .= $p[0];
1124                         if ( count( $p ) < 5 ) {
1125                                 break;
1126                         }
1127                         if ( count( $p ) > 5 ) {
1128                                 # comment
1129                                 $element = $p[4];
1130                                 $attributes = '';
1131                                 $close = '';
1132                                 $inside = $p[5];
1133                         } else {
1134                                 # tag
1135                                 list( , $element, $attributes, $close, $inside ) = $p;
1136                         }
1137
1138                         $marker = self::MARKER_PREFIX . "-$element-" . sprintf( '%08X', $n++ ) . self::MARKER_SUFFIX;
1139                         $stripped .= $marker;
1140
1141                         if ( $close === '/>' ) {
1142                                 # Empty element tag, <tag />
1143                                 $content = null;
1144                                 $text = $inside;
1145                                 $tail = null;
1146                         } else {
1147                                 if ( $element === '!--' ) {
1148                                         $end = '/(-->)/';
1149                                 } else {
1150                                         $end = "/(<\\/$element\\s*>)/i";
1151                                 }
1152                                 $q = preg_split( $end, $inside, 2, PREG_SPLIT_DELIM_CAPTURE );
1153                                 $content = $q[0];
1154                                 if ( count( $q ) < 3 ) {
1155                                         # No end tag -- let it run out to the end of the text.
1156                                         $tail = '';
1157                                         $text = '';
1158                                 } else {
1159                                         list( , $tail, $text ) = $q;
1160                                 }
1161                         }
1162
1163                         $matches[$marker] = [ $element,
1164                                 $content,
1165                                 Sanitizer::decodeTagAttributes( $attributes ),
1166                                 "<$element$attributes$close$content$tail" ];
1167                 }
1168                 return $stripped;
1169         }
1170
1171         /**
1172          * Get a list of strippable XML-like elements
1173          *
1174          * @return array
1175          */
1176         public function getStripList() {
1177                 return $this->mStripList;
1178         }
1179
1180         /**
1181          * Add an item to the strip state
1182          * Returns the unique tag which must be inserted into the stripped text
1183          * The tag will be replaced with the original text in unstrip()
1184          *
1185          * @param string $text
1186          *
1187          * @return string
1188          */
1189         public function insertStripItem( $text ) {
1190                 $marker = self::MARKER_PREFIX . "-item-{$this->mMarkerIndex}-" . self::MARKER_SUFFIX;
1191                 $this->mMarkerIndex++;
1192                 $this->mStripState->addGeneral( $marker, $text );
1193                 return $marker;
1194         }
1195
1196         /**
1197          * parse the wiki syntax used to render tables
1198          *
1199          * @private
1200          * @param string $text
1201          * @return string
1202          */
1203         public function doTableStuff( $text ) {
1204                 $lines = StringUtils::explode( "\n", $text );
1205                 $out = '';
1206                 $td_history = []; # Is currently a td tag open?
1207                 $last_tag_history = []; # Save history of last lag activated (td, th or caption)
1208                 $tr_history = []; # Is currently a tr tag open?
1209                 $tr_attributes = []; # history of tr attributes
1210                 $has_opened_tr = []; # Did this table open a <tr> element?
1211                 $indent_level = 0; # indent level of the table
1212
1213                 foreach ( $lines as $outLine ) {
1214                         $line = trim( $outLine );
1215
1216                         if ( $line === '' ) { # empty line, go to next line
1217                                 $out .= $outLine . "\n";
1218                                 continue;
1219                         }
1220
1221                         $first_character = $line[0];
1222                         $first_two = substr( $line, 0, 2 );
1223                         $matches = [];
1224
1225                         if ( preg_match( '/^(:*)\s*\{\|(.*)$/', $line, $matches ) ) {
1226                                 # First check if we are starting a new table
1227                                 $indent_level = strlen( $matches[1] );
1228
1229                                 $attributes = $this->mStripState->unstripBoth( $matches[2] );
1230                                 $attributes = Sanitizer::fixTagAttributes( $attributes, 'table' );
1231
1232                                 $outLine = str_repeat( '<dl><dd>', $indent_level ) . "<table{$attributes}>";
1233                                 array_push( $td_history, false );
1234                                 array_push( $last_tag_history, '' );
1235                                 array_push( $tr_history, false );
1236                                 array_push( $tr_attributes, '' );
1237                                 array_push( $has_opened_tr, false );
1238                         } elseif ( count( $td_history ) == 0 ) {
1239                                 # Don't do any of the following
1240                                 $out .= $outLine . "\n";
1241                                 continue;
1242                         } elseif ( $first_two === '|}' ) {
1243                                 # We are ending a table
1244                                 $line = '</table>' . substr( $line, 2 );
1245                                 $last_tag = array_pop( $last_tag_history );
1246
1247                                 if ( !array_pop( $has_opened_tr ) ) {
1248                                         $line = "<tr><td></td></tr>{$line}";
1249                                 }
1250
1251                                 if ( array_pop( $tr_history ) ) {
1252                                         $line = "</tr>{$line}";
1253                                 }
1254
1255                                 if ( array_pop( $td_history ) ) {
1256                                         $line = "</{$last_tag}>{$line}";
1257                                 }
1258                                 array_pop( $tr_attributes );
1259                                 if ( $indent_level > 0 ) {
1260                                         $outLine = rtrim( $line ) . str_repeat( '</dd></dl>', $indent_level );
1261                                 } else {
1262                                         $outLine = $line;
1263                                 }
1264                         } elseif ( $first_two === '|-' ) {
1265                                 # Now we have a table row
1266                                 $line = preg_replace( '#^\|-+#', '', $line );
1267
1268                                 # Whats after the tag is now only attributes
1269                                 $attributes = $this->mStripState->unstripBoth( $line );
1270                                 $attributes = Sanitizer::fixTagAttributes( $attributes, 'tr' );
1271                                 array_pop( $tr_attributes );
1272                                 array_push( $tr_attributes, $attributes );
1273
1274                                 $line = '';
1275                                 $last_tag = array_pop( $last_tag_history );
1276                                 array_pop( $has_opened_tr );
1277                                 array_push( $has_opened_tr, true );
1278
1279                                 if ( array_pop( $tr_history ) ) {
1280                                         $line = '</tr>';
1281                                 }
1282
1283                                 if ( array_pop( $td_history ) ) {
1284                                         $line = "</{$last_tag}>{$line}";
1285                                 }
1286
1287                                 $outLine = $line;
1288                                 array_push( $tr_history, false );
1289                                 array_push( $td_history, false );
1290                                 array_push( $last_tag_history, '' );
1291                         } elseif ( $first_character === '|'
1292                                 || $first_character === '!'
1293                                 || $first_two === '|+'
1294                         ) {
1295                                 # This might be cell elements, td, th or captions
1296                                 if ( $first_two === '|+' ) {
1297                                         $first_character = '+';
1298                                         $line = substr( $line, 2 );
1299                                 } else {
1300                                         $line = substr( $line, 1 );
1301                                 }
1302
1303                                 // Implies both are valid for table headings.
1304                                 if ( $first_character === '!' ) {
1305                                         $line = StringUtils::replaceMarkup( '!!', '||', $line );
1306                                 }
1307
1308                                 # Split up multiple cells on the same line.
1309                                 # FIXME : This can result in improper nesting of tags processed
1310                                 # by earlier parser steps.
1311                                 $cells = explode( '||', $line );
1312
1313                                 $outLine = '';
1314
1315                                 # Loop through each table cell
1316                                 foreach ( $cells as $cell ) {
1317                                         $previous = '';
1318                                         if ( $first_character !== '+' ) {
1319                                                 $tr_after = array_pop( $tr_attributes );
1320                                                 if ( !array_pop( $tr_history ) ) {
1321                                                         $previous = "<tr{$tr_after}>\n";
1322                                                 }
1323                                                 array_push( $tr_history, true );
1324                                                 array_push( $tr_attributes, '' );
1325                                                 array_pop( $has_opened_tr );
1326                                                 array_push( $has_opened_tr, true );
1327                                         }
1328
1329                                         $last_tag = array_pop( $last_tag_history );
1330
1331                                         if ( array_pop( $td_history ) ) {
1332                                                 $previous = "</{$last_tag}>\n{$previous}";
1333                                         }
1334
1335                                         if ( $first_character === '|' ) {
1336                                                 $last_tag = 'td';
1337                                         } elseif ( $first_character === '!' ) {
1338                                                 $last_tag = 'th';
1339                                         } elseif ( $first_character === '+' ) {
1340                                                 $last_tag = 'caption';
1341                                         } else {
1342                                                 $last_tag = '';
1343                                         }
1344
1345                                         array_push( $last_tag_history, $last_tag );
1346
1347                                         # A cell could contain both parameters and data
1348                                         $cell_data = explode( '|', $cell, 2 );
1349
1350                                         # T2553: Note that a '|' inside an invalid link should not
1351                                         # be mistaken as delimiting cell parameters
1352                                         # Bug T153140: Neither should language converter markup.
1353                                         if ( preg_match( '/\[\[|-\{/', $cell_data[0] ) === 1 ) {
1354                                                 $cell = "{$previous}<{$last_tag}>" . trim( $cell );
1355                                         } elseif ( count( $cell_data ) == 1 ) {
1356                                                 // Whitespace in cells is trimmed
1357                                                 $cell = "{$previous}<{$last_tag}>" . trim( $cell_data[0] );
1358                                         } else {
1359                                                 $attributes = $this->mStripState->unstripBoth( $cell_data[0] );
1360                                                 $attributes = Sanitizer::fixTagAttributes( $attributes, $last_tag );
1361                                                 // Whitespace in cells is trimmed
1362                                                 $cell = "{$previous}<{$last_tag}{$attributes}>" . trim( $cell_data[1] );
1363                                         }
1364
1365                                         $outLine .= $cell;
1366                                         array_push( $td_history, true );
1367                                 }
1368                         }
1369                         $out .= $outLine . "\n";
1370                 }
1371
1372                 # Closing open td, tr && table
1373                 while ( count( $td_history ) > 0 ) {
1374                         if ( array_pop( $td_history ) ) {
1375                                 $out .= "</td>\n";
1376                         }
1377                         if ( array_pop( $tr_history ) ) {
1378                                 $out .= "</tr>\n";
1379                         }
1380                         if ( !array_pop( $has_opened_tr ) ) {
1381                                 $out .= "<tr><td></td></tr>\n";
1382                         }
1383
1384                         $out .= "</table>\n";
1385                 }
1386
1387                 # Remove trailing line-ending (b/c)
1388                 if ( substr( $out, -1 ) === "\n" ) {
1389                         $out = substr( $out, 0, -1 );
1390                 }
1391
1392                 # special case: don't return empty table
1393                 if ( $out === "<table>\n<tr><td></td></tr>\n</table>" ) {
1394                         $out = '';
1395                 }
1396
1397                 return $out;
1398         }
1399
1400         /**
1401          * Helper function for parse() that transforms wiki markup into half-parsed
1402          * HTML. Only called for $mOutputType == self::OT_HTML.
1403          *
1404          * @private
1405          *
1406          * @param string $text The text to parse
1407          * @param-taint $text escapes_html
1408          * @param bool $isMain Whether this is being called from the main parse() function
1409          * @param PPFrame|bool $frame A pre-processor frame
1410          *
1411          * @return string
1412          */
1413         public function internalParse( $text, $isMain = true, $frame = false ) {
1414                 $origText = $text;
1415
1416                 // Avoid PHP 7.1 warning from passing $this by reference
1417                 $parser = $this;
1418
1419                 # Hook to suspend the parser in this state
1420                 if ( !Hooks::run( 'ParserBeforeInternalParse', [ &$parser, &$text, &$this->mStripState ] ) ) {
1421                         return $text;
1422                 }
1423
1424                 # if $frame is provided, then use $frame for replacing any variables
1425                 if ( $frame ) {
1426                         # use frame depth to infer how include/noinclude tags should be handled
1427                         # depth=0 means this is the top-level document; otherwise it's an included document
1428                         if ( !$frame->depth ) {
1429                                 $flag = 0;
1430                         } else {
1431                                 $flag = self::PTD_FOR_INCLUSION;
1432                         }
1433                         $dom = $this->preprocessToDom( $text, $flag );
1434                         $text = $frame->expand( $dom );
1435                 } else {
1436                         # if $frame is not provided, then use old-style replaceVariables
1437                         $text = $this->replaceVariables( $text );
1438                 }
1439
1440                 Hooks::run( 'InternalParseBeforeSanitize', [ &$parser, &$text, &$this->mStripState ] );
1441                 $text = Sanitizer::removeHTMLtags(
1442                         $text,
1443                         [ $this, 'attributeStripCallback' ],
1444                         false,
1445                         array_keys( $this->mTransparentTagHooks ),
1446                         [],
1447                         [ $this, 'addTrackingCategory' ]
1448                 );
1449                 Hooks::run( 'InternalParseBeforeLinks', [ &$parser, &$text, &$this->mStripState ] );
1450
1451                 # Tables need to come after variable replacement for things to work
1452                 # properly; putting them before other transformations should keep
1453                 # exciting things like link expansions from showing up in surprising
1454                 # places.
1455                 $text = $this->doTableStuff( $text );
1456
1457                 $text = preg_replace( '/(^|\n)-----*/', '\\1<hr />', $text );
1458
1459                 $text = $this->doDoubleUnderscore( $text );
1460
1461                 $text = $this->doHeadings( $text );
1462                 $text = $this->replaceInternalLinks( $text );
1463                 $text = $this->doAllQuotes( $text );
1464                 $text = $this->replaceExternalLinks( $text );
1465
1466                 # replaceInternalLinks may sometimes leave behind
1467                 # absolute URLs, which have to be masked to hide them from replaceExternalLinks
1468                 $text = str_replace( self::MARKER_PREFIX . 'NOPARSE', '', $text );
1469
1470                 $text = $this->doMagicLinks( $text );
1471                 $text = $this->formatHeadings( $text, $origText, $isMain );
1472
1473                 return $text;
1474         }
1475
1476         /**
1477          * Helper function for parse() that transforms half-parsed HTML into fully
1478          * parsed HTML.
1479          *
1480          * @param string $text
1481          * @param bool $isMain
1482          * @param bool $linestart
1483          * @return string
1484          */
1485         private function internalParseHalfParsed( $text, $isMain = true, $linestart = true ) {
1486                 $text = $this->mStripState->unstripGeneral( $text );
1487
1488                 // Avoid PHP 7.1 warning from passing $this by reference
1489                 $parser = $this;
1490
1491                 if ( $isMain ) {
1492                         Hooks::run( 'ParserAfterUnstrip', [ &$parser, &$text ] );
1493                 }
1494
1495                 # Clean up special characters, only run once, next-to-last before doBlockLevels
1496                 $text = Sanitizer::armorFrenchSpaces( $text );
1497
1498                 $text = $this->doBlockLevels( $text, $linestart );
1499
1500                 $this->replaceLinkHolders( $text );
1501
1502                 /**
1503                  * The input doesn't get language converted if
1504                  * a) It's disabled
1505                  * b) Content isn't converted
1506                  * c) It's a conversion table
1507                  * d) it is an interface message (which is in the user language)
1508                  */
1509                 if ( !( $this->mOptions->getDisableContentConversion()
1510                         || isset( $this->mDoubleUnderscores['nocontentconvert'] ) )
1511                         && !$this->mOptions->getInterfaceMessage()
1512                 ) {
1513                         # The position of the convert() call should not be changed. it
1514                         # assumes that the links are all replaced and the only thing left
1515                         # is the <nowiki> mark.
1516                         $text = $this->getTargetLanguage()->convert( $text );
1517                 }
1518
1519                 $text = $this->mStripState->unstripNoWiki( $text );
1520
1521                 if ( $isMain ) {
1522                         Hooks::run( 'ParserBeforeTidy', [ &$parser, &$text ] );
1523                 }
1524
1525                 $text = $this->replaceTransparentTags( $text );
1526                 $text = $this->mStripState->unstripGeneral( $text );
1527
1528                 $text = Sanitizer::normalizeCharReferences( $text );
1529
1530                 if ( MWTidy::isEnabled() ) {
1531                         if ( $this->mOptions->getTidy() ) {
1532                                 $text = MWTidy::tidy( $text );
1533                         }
1534                 } else {
1535                         # attempt to sanitize at least some nesting problems
1536                         # (T4702 and quite a few others)
1537                         # This code path is buggy and deprecated!
1538                         wfDeprecated( 'disabling tidy', '1.33' );
1539                         $tidyregs = [
1540                                 # ''Something [http://www.cool.com cool''] -->
1541                                 # <i>Something</i><a href="http://www.cool.com"..><i>cool></i></a>
1542                                 '/(<([bi])>)(<([bi])>)?([^<]*)(<\/?a[^<]*>)([^<]*)(<\/\\4>)?(<\/\\2>)/' =>
1543                                 '\\1\\3\\5\\8\\9\\6\\1\\3\\7\\8\\9',
1544                                 # fix up an anchor inside another anchor, only
1545                                 # at least for a single single nested link (T5695)
1546                                 '/(<a[^>]+>)([^<]*)(<a[^>]+>[^<]*)<\/a>(.*)<\/a>/' =>
1547                                 '\\1\\2</a>\\3</a>\\1\\4</a>',
1548                                 # fix div inside inline elements- doBlockLevels won't wrap a line which
1549                                 # contains a div, so fix it up here; replace
1550                                 # div with escaped text
1551                                 '/(<([aib]) [^>]+>)([^<]*)(<div([^>]*)>)(.*)(<\/div>)([^<]*)(<\/\\2>)/' =>
1552                                 '\\1\\3&lt;div\\5&gt;\\6&lt;/div&gt;\\8\\9',
1553                                 # remove empty italic or bold tag pairs, some
1554                                 # introduced by rules above
1555                                 '/<([bi])><\/\\1>/' => '',
1556                         ];
1557
1558                         $text = preg_replace(
1559                                 array_keys( $tidyregs ),
1560                                 array_values( $tidyregs ),
1561                                 $text );
1562                 }
1563
1564                 if ( $isMain ) {
1565                         Hooks::run( 'ParserAfterTidy', [ &$parser, &$text ] );
1566                 }
1567
1568                 return $text;
1569         }
1570
1571         /**
1572          * Replace special strings like "ISBN xxx" and "RFC xxx" with
1573          * magic external links.
1574          *
1575          * DML
1576          * @private
1577          *
1578          * @param string $text
1579          *
1580          * @return string
1581          */
1582         public function doMagicLinks( $text ) {
1583                 $prots = wfUrlProtocolsWithoutProtRel();
1584                 $urlChar = self::EXT_LINK_URL_CLASS;
1585                 $addr = self::EXT_LINK_ADDR;
1586                 $space = self::SPACE_NOT_NL; #  non-newline space
1587                 $spdash = "(?:-|$space)"; # a dash or a non-newline space
1588                 $spaces = "$space++"; # possessive match of 1 or more spaces
1589                 $text = preg_replace_callback(
1590                         '!(?:                        # Start cases
1591                                 (<a[ \t\r\n>].*?</a>) |    # m[1]: Skip link text
1592                                 (<.*?>) |                  # m[2]: Skip stuff inside HTML elements' . "
1593                                 (\b                        # m[3]: Free external links
1594                                         (?i:$prots)
1595                                         ($addr$urlChar*)         # m[4]: Post-protocol path
1596                                 ) |
1597                                 \b(?:RFC|PMID) $spaces     # m[5]: RFC or PMID, capture number
1598                                         ([0-9]+)\b |
1599                                 \bISBN $spaces (           # m[6]: ISBN, capture number
1600                                         (?: 97[89] $spdash? )?   #  optional 13-digit ISBN prefix
1601                                         (?: [0-9]  $spdash? ){9} #  9 digits with opt. delimiters
1602                                         [0-9Xx]                  #  check digit
1603                                 )\b
1604                         )!xu", [ $this, 'magicLinkCallback' ], $text );
1605                 return $text;
1606         }
1607
1608         /**
1609          * @throws MWException
1610          * @param array $m
1611          * @return string HTML
1612          */
1613         public function magicLinkCallback( $m ) {
1614                 if ( isset( $m[1] ) && $m[1] !== '' ) {
1615                         # Skip anchor
1616                         return $m[0];
1617                 } elseif ( isset( $m[2] ) && $m[2] !== '' ) {
1618                         # Skip HTML element
1619                         return $m[0];
1620                 } elseif ( isset( $m[3] ) && $m[3] !== '' ) {
1621                         # Free external link
1622                         return $this->makeFreeExternalLink( $m[0], strlen( $m[4] ) );
1623                 } elseif ( isset( $m[5] ) && $m[5] !== '' ) {
1624                         # RFC or PMID
1625                         if ( substr( $m[0], 0, 3 ) === 'RFC' ) {
1626                                 if ( !$this->mOptions->getMagicRFCLinks() ) {
1627                                         return $m[0];
1628                                 }
1629                                 $keyword = 'RFC';
1630                                 $urlmsg = 'rfcurl';
1631                                 $cssClass = 'mw-magiclink-rfc';
1632                                 $trackingCat = 'magiclink-tracking-rfc';
1633                                 $id = $m[5];
1634                         } elseif ( substr( $m[0], 0, 4 ) === 'PMID' ) {
1635                                 if ( !$this->mOptions->getMagicPMIDLinks() ) {
1636                                         return $m[0];
1637                                 }
1638                                 $keyword = 'PMID';
1639                                 $urlmsg = 'pubmedurl';
1640                                 $cssClass = 'mw-magiclink-pmid';
1641                                 $trackingCat = 'magiclink-tracking-pmid';
1642                                 $id = $m[5];
1643                         } else {
1644                                 throw new MWException( __METHOD__ . ': unrecognised match type "' .
1645                                         substr( $m[0], 0, 20 ) . '"' );
1646                         }
1647                         $url = wfMessage( $urlmsg, $id )->inContentLanguage()->text();
1648                         $this->addTrackingCategory( $trackingCat );
1649                         return Linker::makeExternalLink( $url, "{$keyword} {$id}", true, $cssClass, [], $this->mTitle );
1650                 } elseif ( isset( $m[6] ) && $m[6] !== ''
1651                         && $this->mOptions->getMagicISBNLinks()
1652                 ) {
1653                         # ISBN
1654                         $isbn = $m[6];
1655                         $space = self::SPACE_NOT_NL; #  non-newline space
1656                         $isbn = preg_replace( "/$space/", ' ', $isbn );
1657                         $num = strtr( $isbn, [
1658                                 '-' => '',
1659                                 ' ' => '',
1660                                 'x' => 'X',
1661                         ] );
1662                         $this->addTrackingCategory( 'magiclink-tracking-isbn' );
1663                         return $this->getLinkRenderer()->makeKnownLink(
1664                                 SpecialPage::getTitleFor( 'Booksources', $num ),
1665                                 "ISBN $isbn",
1666                                 [
1667                                         'class' => 'internal mw-magiclink-isbn',
1668                                         'title' => false // suppress title attribute
1669                                 ]
1670                         );
1671                 } else {
1672                         return $m[0];
1673                 }
1674         }
1675
1676         /**
1677          * Make a free external link, given a user-supplied URL
1678          *
1679          * @param string $url
1680          * @param int $numPostProto
1681          *   The number of characters after the protocol.
1682          * @return string HTML
1683          * @private
1684          */
1685         public function makeFreeExternalLink( $url, $numPostProto ) {
1686                 $trail = '';
1687
1688                 # The characters '<' and '>' (which were escaped by
1689                 # removeHTMLtags()) should not be included in
1690                 # URLs, per RFC 2396.
1691                 # Make &nbsp; terminate a URL as well (bug T84937)
1692                 $m2 = [];
1693                 if ( preg_match(
1694                         '/&(lt|gt|nbsp|#x0*(3[CcEe]|[Aa]0)|#0*(60|62|160));/',
1695                         $url,
1696                         $m2,
1697                         PREG_OFFSET_CAPTURE
1698                 ) ) {
1699                         $trail = substr( $url, $m2[0][1] ) . $trail;
1700                         $url = substr( $url, 0, $m2[0][1] );
1701                 }
1702
1703                 # Move trailing punctuation to $trail
1704                 $sep = ',;\.:!?';
1705                 # If there is no left bracket, then consider right brackets fair game too
1706                 if ( strpos( $url, '(' ) === false ) {
1707                         $sep .= ')';
1708                 }
1709
1710                 $urlRev = strrev( $url );
1711                 $numSepChars = strspn( $urlRev, $sep );
1712                 # Don't break a trailing HTML entity by moving the ; into $trail
1713                 # This is in hot code, so use substr_compare to avoid having to
1714                 # create a new string object for the comparison
1715                 if ( $numSepChars && substr_compare( $url, ";", -$numSepChars, 1 ) === 0 ) {
1716                         # more optimization: instead of running preg_match with a $
1717                         # anchor, which can be slow, do the match on the reversed
1718                         # string starting at the desired offset.
1719                         # un-reversed regexp is: /&([a-z]+|#x[\da-f]+|#\d+)$/i
1720                         if ( preg_match( '/\G([a-z]+|[\da-f]+x#|\d+#)&/i', $urlRev, $m2, 0, $numSepChars ) ) {
1721                                 $numSepChars--;
1722                         }
1723                 }
1724                 if ( $numSepChars ) {
1725                         $trail = substr( $url, -$numSepChars ) . $trail;
1726                         $url = substr( $url, 0, -$numSepChars );
1727                 }
1728
1729                 # Verify that we still have a real URL after trail removal, and
1730                 # not just lone protocol
1731                 if ( strlen( $trail ) >= $numPostProto ) {
1732                         return $url . $trail;
1733                 }
1734
1735                 $url = Sanitizer::cleanUrl( $url );
1736
1737                 # Is this an external image?
1738                 $text = $this->maybeMakeExternalImage( $url );
1739                 if ( $text === false ) {
1740                         # Not an image, make a link
1741                         $text = Linker::makeExternalLink( $url,
1742                                 $this->getTargetLanguage()->getConverter()->markNoConversion( $url ),
1743                                 true, 'free',
1744                                 $this->getExternalLinkAttribs( $url ), $this->mTitle );
1745                         # Register it in the output object...
1746                         $this->mOutput->addExternalLink( $url );
1747                 }
1748                 return $text . $trail;
1749         }
1750
1751         /**
1752          * Parse headers and return html
1753          *
1754          * @private
1755          *
1756          * @param string $text
1757          *
1758          * @return string
1759          */
1760         public function doHeadings( $text ) {
1761                 for ( $i = 6; $i >= 1; --$i ) {
1762                         $h = str_repeat( '=', $i );
1763                         // Trim non-newline whitespace from headings
1764                         // Using \s* will break for: "==\n===\n" and parse as <h2>=</h2>
1765                         $text = preg_replace( "/^(?:$h)[ \\t]*(.+?)[ \\t]*(?:$h)\\s*$/m", "<h$i>\\1</h$i>", $text );
1766                 }
1767                 return $text;
1768         }
1769
1770         /**
1771          * Replace single quotes with HTML markup
1772          * @private
1773          *
1774          * @param string $text
1775          *
1776          * @return string The altered text
1777          */
1778         public function doAllQuotes( $text ) {
1779                 $outtext = '';
1780                 $lines = StringUtils::explode( "\n", $text );
1781                 foreach ( $lines as $line ) {
1782                         $outtext .= $this->doQuotes( $line ) . "\n";
1783                 }
1784                 $outtext = substr( $outtext, 0, -1 );
1785                 return $outtext;
1786         }
1787
1788         /**
1789          * Helper function for doAllQuotes()
1790          *
1791          * @param string $text
1792          *
1793          * @return string
1794          */
1795         public function doQuotes( $text ) {
1796                 $arr = preg_split( "/(''+)/", $text, -1, PREG_SPLIT_DELIM_CAPTURE );
1797                 $countarr = count( $arr );
1798                 if ( $countarr == 1 ) {
1799                         return $text;
1800                 }
1801
1802                 // First, do some preliminary work. This may shift some apostrophes from
1803                 // being mark-up to being text. It also counts the number of occurrences
1804                 // of bold and italics mark-ups.
1805                 $numbold = 0;
1806                 $numitalics = 0;
1807                 for ( $i = 1; $i < $countarr; $i += 2 ) {
1808                         $thislen = strlen( $arr[$i] );
1809                         // If there are ever four apostrophes, assume the first is supposed to
1810                         // be text, and the remaining three constitute mark-up for bold text.
1811                         // (T15227: ''''foo'''' turns into ' ''' foo ' ''')
1812                         if ( $thislen == 4 ) {
1813                                 $arr[$i - 1] .= "'";
1814                                 $arr[$i] = "'''";
1815                                 $thislen = 3;
1816                         } elseif ( $thislen > 5 ) {
1817                                 // If there are more than 5 apostrophes in a row, assume they're all
1818                                 // text except for the last 5.
1819                                 // (T15227: ''''''foo'''''' turns into ' ''''' foo ' ''''')
1820                                 $arr[$i - 1] .= str_repeat( "'", $thislen - 5 );
1821                                 $arr[$i] = "'''''";
1822                                 $thislen = 5;
1823                         }
1824                         // Count the number of occurrences of bold and italics mark-ups.
1825                         if ( $thislen == 2 ) {
1826                                 $numitalics++;
1827                         } elseif ( $thislen == 3 ) {
1828                                 $numbold++;
1829                         } elseif ( $thislen == 5 ) {
1830                                 $numitalics++;
1831                                 $numbold++;
1832                         }
1833                 }
1834
1835                 // If there is an odd number of both bold and italics, it is likely
1836                 // that one of the bold ones was meant to be an apostrophe followed
1837                 // by italics. Which one we cannot know for certain, but it is more
1838                 // likely to be one that has a single-letter word before it.
1839                 if ( ( $numbold % 2 == 1 ) && ( $numitalics % 2 == 1 ) ) {
1840                         $firstsingleletterword = -1;
1841                         $firstmultiletterword = -1;
1842                         $firstspace = -1;
1843                         for ( $i = 1; $i < $countarr; $i += 2 ) {
1844                                 if ( strlen( $arr[$i] ) == 3 ) {
1845                                         $x1 = substr( $arr[$i - 1], -1 );
1846                                         $x2 = substr( $arr[$i - 1], -2, 1 );
1847                                         if ( $x1 === ' ' ) {
1848                                                 if ( $firstspace == -1 ) {
1849                                                         $firstspace = $i;
1850                                                 }
1851                                         } elseif ( $x2 === ' ' ) {
1852                                                 $firstsingleletterword = $i;
1853                                                 // if $firstsingleletterword is set, we don't
1854                                                 // look at the other options, so we can bail early.
1855                                                 break;
1856                                         } elseif ( $firstmultiletterword == -1 ) {
1857                                                 $firstmultiletterword = $i;
1858                                         }
1859                                 }
1860                         }
1861
1862                         // If there is a single-letter word, use it!
1863                         if ( $firstsingleletterword > -1 ) {
1864                                 $arr[$firstsingleletterword] = "''";
1865                                 $arr[$firstsingleletterword - 1] .= "'";
1866                         } elseif ( $firstmultiletterword > -1 ) {
1867                                 // If not, but there's a multi-letter word, use that one.
1868                                 $arr[$firstmultiletterword] = "''";
1869                                 $arr[$firstmultiletterword - 1] .= "'";
1870                         } elseif ( $firstspace > -1 ) {
1871                                 // ... otherwise use the first one that has neither.
1872                                 // (notice that it is possible for all three to be -1 if, for example,
1873                                 // there is only one pentuple-apostrophe in the line)
1874                                 $arr[$firstspace] = "''";
1875                                 $arr[$firstspace - 1] .= "'";
1876                         }
1877                 }
1878
1879                 // Now let's actually convert our apostrophic mush to HTML!
1880                 $output = '';
1881                 $buffer = '';
1882                 $state = '';
1883                 $i = 0;
1884                 foreach ( $arr as $r ) {
1885                         if ( ( $i % 2 ) == 0 ) {
1886                                 if ( $state === 'both' ) {
1887                                         $buffer .= $r;
1888                                 } else {
1889                                         $output .= $r;
1890                                 }
1891                         } else {
1892                                 $thislen = strlen( $r );
1893                                 if ( $thislen == 2 ) {
1894                                         if ( $state === 'i' ) {
1895                                                 $output .= '</i>';
1896                                                 $state = '';
1897                                         } elseif ( $state === 'bi' ) {
1898                                                 $output .= '</i>';
1899                                                 $state = 'b';
1900                                         } elseif ( $state === 'ib' ) {
1901                                                 $output .= '</b></i><b>';
1902                                                 $state = 'b';
1903                                         } elseif ( $state === 'both' ) {
1904                                                 $output .= '<b><i>' . $buffer . '</i>';
1905                                                 $state = 'b';
1906                                         } else { // $state can be 'b' or ''
1907                                                 $output .= '<i>';
1908                                                 $state .= 'i';
1909                                         }
1910                                 } elseif ( $thislen == 3 ) {
1911                                         if ( $state === 'b' ) {
1912                                                 $output .= '</b>';
1913                                                 $state = '';
1914                                         } elseif ( $state === 'bi' ) {
1915                                                 $output .= '</i></b><i>';
1916                                                 $state = 'i';
1917                                         } elseif ( $state === 'ib' ) {
1918                                                 $output .= '</b>';
1919                                                 $state = 'i';
1920                                         } elseif ( $state === 'both' ) {
1921                                                 $output .= '<i><b>' . $buffer . '</b>';
1922                                                 $state = 'i';
1923                                         } else { // $state can be 'i' or ''
1924                                                 $output .= '<b>';
1925                                                 $state .= 'b';
1926                                         }
1927                                 } elseif ( $thislen == 5 ) {
1928                                         if ( $state === 'b' ) {
1929                                                 $output .= '</b><i>';
1930                                                 $state = 'i';
1931                                         } elseif ( $state === 'i' ) {
1932                                                 $output .= '</i><b>';
1933                                                 $state = 'b';
1934                                         } elseif ( $state === 'bi' ) {
1935                                                 $output .= '</i></b>';
1936                                                 $state = '';
1937                                         } elseif ( $state === 'ib' ) {
1938                                                 $output .= '</b></i>';
1939                                                 $state = '';
1940                                         } elseif ( $state === 'both' ) {
1941                                                 $output .= '<i><b>' . $buffer . '</b></i>';
1942                                                 $state = '';
1943                                         } else { // ($state == '')
1944                                                 $buffer = '';
1945                                                 $state = 'both';
1946                                         }
1947                                 }
1948                         }
1949                         $i++;
1950                 }
1951                 // Now close all remaining tags.  Notice that the order is important.
1952                 if ( $state === 'b' || $state === 'ib' ) {
1953                         $output .= '</b>';
1954                 }
1955                 if ( $state === 'i' || $state === 'bi' || $state === 'ib' ) {
1956                         $output .= '</i>';
1957                 }
1958                 if ( $state === 'bi' ) {
1959                         $output .= '</b>';
1960                 }
1961                 // There might be lonely ''''', so make sure we have a buffer
1962                 if ( $state === 'both' && $buffer ) {
1963                         $output .= '<b><i>' . $buffer . '</i></b>';
1964                 }
1965                 return $output;
1966         }
1967
1968         /**
1969          * Replace external links (REL)
1970          *
1971          * Note: this is all very hackish and the order of execution matters a lot.
1972          * Make sure to run tests/parser/parserTests.php if you change this code.
1973          *
1974          * @private
1975          *
1976          * @param string $text
1977          *
1978          * @throws MWException
1979          * @return string
1980          */
1981         public function replaceExternalLinks( $text ) {
1982                 $bits = preg_split( $this->mExtLinkBracketedRegex, $text, -1, PREG_SPLIT_DELIM_CAPTURE );
1983                 if ( $bits === false ) {
1984                         throw new MWException( "PCRE needs to be compiled with "
1985                                 . "--enable-unicode-properties in order for MediaWiki to function" );
1986                 }
1987                 $s = array_shift( $bits );
1988
1989                 $i = 0;
1990                 while ( $i < count( $bits ) ) {
1991                         $url = $bits[$i++];
1992                         $i++; // protocol
1993                         $text = $bits[$i++];
1994                         $trail = $bits[$i++];
1995
1996                         # The characters '<' and '>' (which were escaped by
1997                         # removeHTMLtags()) should not be included in
1998                         # URLs, per RFC 2396.
1999                         $m2 = [];
2000                         if ( preg_match( '/&(lt|gt);/', $url, $m2, PREG_OFFSET_CAPTURE ) ) {
2001                                 $text = substr( $url, $m2[0][1] ) . ' ' . $text;
2002                                 $url = substr( $url, 0, $m2[0][1] );
2003                         }
2004
2005                         # If the link text is an image URL, replace it with an <img> tag
2006                         # This happened by accident in the original parser, but some people used it extensively
2007                         $img = $this->maybeMakeExternalImage( $text );
2008                         if ( $img !== false ) {
2009                                 $text = $img;
2010                         }
2011
2012                         $dtrail = '';
2013
2014                         # Set linktype for CSS
2015                         $linktype = 'text';
2016
2017                         # No link text, e.g. [http://domain.tld/some.link]
2018                         if ( $text == '' ) {
2019                                 # Autonumber
2020                                 $langObj = $this->getTargetLanguage();
2021                                 $text = '[' . $langObj->formatNum( ++$this->mAutonumber ) . ']';
2022                                 $linktype = 'autonumber';
2023                         } else {
2024                                 # Have link text, e.g. [http://domain.tld/some.link text]s
2025                                 # Check for trail
2026                                 list( $dtrail, $trail ) = Linker::splitTrail( $trail );
2027                         }
2028
2029                         // Excluding protocol-relative URLs may avoid many false positives.
2030                         if ( preg_match( '/^(?:' . wfUrlProtocolsWithoutProtRel() . ')/', $text ) ) {
2031                                 $text = $this->getTargetLanguage()->getConverter()->markNoConversion( $text );
2032                         }
2033
2034                         $url = Sanitizer::cleanUrl( $url );
2035
2036                         # Use the encoded URL
2037                         # This means that users can paste URLs directly into the text
2038                         # Funny characters like ö aren't valid in URLs anyway
2039                         # This was changed in August 2004
2040                         $s .= Linker::makeExternalLink( $url, $text, false, $linktype,
2041                                 $this->getExternalLinkAttribs( $url ), $this->mTitle ) . $dtrail . $trail;
2042
2043                         # Register link in the output object.
2044                         $this->mOutput->addExternalLink( $url );
2045                 }
2046
2047                 return $s;
2048         }
2049
2050         /**
2051          * Get the rel attribute for a particular external link.
2052          *
2053          * @since 1.21
2054          * @param string|bool $url Optional URL, to extract the domain from for rel =>
2055          *   nofollow if appropriate
2056          * @param LinkTarget|null $title Optional LinkTarget, for wgNoFollowNsExceptions lookups
2057          * @return string|null Rel attribute for $url
2058          */
2059         public static function getExternalLinkRel( $url = false, $title = null ) {
2060                 global $wgNoFollowLinks, $wgNoFollowNsExceptions, $wgNoFollowDomainExceptions;
2061                 $ns = $title ? $title->getNamespace() : false;
2062                 if ( $wgNoFollowLinks && !in_array( $ns, $wgNoFollowNsExceptions )
2063                         && !wfMatchesDomainList( $url, $wgNoFollowDomainExceptions )
2064                 ) {
2065                         return 'nofollow';
2066                 }
2067                 return null;
2068         }
2069
2070         /**
2071          * Get an associative array of additional HTML attributes appropriate for a
2072          * particular external link.  This currently may include rel => nofollow
2073          * (depending on configuration, namespace, and the URL's domain) and/or a
2074          * target attribute (depending on configuration).
2075          *
2076          * @param string $url URL to extract the domain from for rel =>
2077          *   nofollow if appropriate
2078          * @return array Associative array of HTML attributes
2079          */
2080         public function getExternalLinkAttribs( $url ) {
2081                 $attribs = [];
2082                 $rel = self::getExternalLinkRel( $url, $this->mTitle );
2083
2084                 $target = $this->mOptions->getExternalLinkTarget();
2085                 if ( $target ) {
2086                         $attribs['target'] = $target;
2087                         if ( !in_array( $target, [ '_self', '_parent', '_top' ] ) ) {
2088                                 // T133507. New windows can navigate parent cross-origin.
2089                                 // Including noreferrer due to lacking browser
2090                                 // support of noopener. Eventually noreferrer should be removed.
2091                                 if ( $rel !== '' ) {
2092                                         $rel .= ' ';
2093                                 }
2094                                 $rel .= 'noreferrer noopener';
2095                         }
2096                 }
2097                 $attribs['rel'] = $rel;
2098                 return $attribs;
2099         }
2100
2101         /**
2102          * Replace unusual escape codes in a URL with their equivalent characters
2103          *
2104          * This generally follows the syntax defined in RFC 3986, with special
2105          * consideration for HTTP query strings.
2106          *
2107          * @param string $url
2108          * @return string
2109          */
2110         public static function normalizeLinkUrl( $url ) {
2111                 # Test for RFC 3986 IPv6 syntax
2112                 $scheme = '[a-z][a-z0-9+.-]*:';
2113                 $userinfo = '(?:[a-z0-9\-._~!$&\'()*+,;=:]|%[0-9a-f]{2})*';
2114                 $ipv6Host = '\\[((?:[0-9a-f:]|%3[0-A]|%[46][1-6])+)\\]';
2115                 if ( preg_match( "<^(?:{$scheme})?//(?:{$userinfo}@)?{$ipv6Host}(?:[:/?#].*|)$>i", $url, $m ) &&
2116                         IP::isValid( rawurldecode( $m[1] ) )
2117                 ) {
2118                         $isIPv6 = rawurldecode( $m[1] );
2119                 } else {
2120                         $isIPv6 = false;
2121                 }
2122
2123                 # Make sure unsafe characters are encoded
2124                 $url = preg_replace_callback( '/[\x00-\x20"<>\[\\\\\]^`{|}\x7F-\xFF]/',
2125                         function ( $m ) {
2126                                 return rawurlencode( $m[0] );
2127                         },
2128                         $url
2129                 );
2130
2131                 $ret = '';
2132                 $end = strlen( $url );
2133
2134                 # Fragment part - 'fragment'
2135                 $start = strpos( $url, '#' );
2136                 if ( $start !== false && $start < $end ) {
2137                         $ret = self::normalizeUrlComponent(
2138                                 substr( $url, $start, $end - $start ), '"#%<>[\]^`{|}' ) . $ret;
2139                         $end = $start;
2140                 }
2141
2142                 # Query part - 'query' minus &=+;
2143                 $start = strpos( $url, '?' );
2144                 if ( $start !== false && $start < $end ) {
2145                         $ret = self::normalizeUrlComponent(
2146                                 substr( $url, $start, $end - $start ), '"#%<>[\]^`{|}&=+;' ) . $ret;
2147                         $end = $start;
2148                 }
2149
2150                 # Scheme and path part - 'pchar'
2151                 # (we assume no userinfo or encoded colons in the host)
2152                 $ret = self::normalizeUrlComponent(
2153                         substr( $url, 0, $end ), '"#%<>[\]^`{|}/?' ) . $ret;
2154
2155                 # Fix IPv6 syntax
2156                 if ( $isIPv6 !== false ) {
2157                         $ipv6Host = "%5B({$isIPv6})%5D";
2158                         $ret = preg_replace(
2159                                 "<^((?:{$scheme})?//(?:{$userinfo}@)?){$ipv6Host}(?=[:/?#]|$)>i",
2160                                 "$1[$2]",
2161                                 $ret
2162                         );
2163                 }
2164
2165                 return $ret;
2166         }
2167
2168         private static function normalizeUrlComponent( $component, $unsafe ) {
2169                 $callback = function ( $matches ) use ( $unsafe ) {
2170                         $char = urldecode( $matches[0] );
2171                         $ord = ord( $char );
2172                         if ( $ord > 32 && $ord < 127 && strpos( $unsafe, $char ) === false ) {
2173                                 # Unescape it
2174                                 return $char;
2175                         } else {
2176                                 # Leave it escaped, but use uppercase for a-f
2177                                 return strtoupper( $matches[0] );
2178                         }
2179                 };
2180                 return preg_replace_callback( '/%[0-9A-Fa-f]{2}/', $callback, $component );
2181         }
2182
2183         /**
2184          * make an image if it's allowed, either through the global
2185          * option, through the exception, or through the on-wiki whitelist
2186          *
2187          * @param string $url
2188          *
2189          * @return string
2190          */
2191         private function maybeMakeExternalImage( $url ) {
2192                 $imagesfrom = $this->mOptions->getAllowExternalImagesFrom();
2193                 $imagesexception = !empty( $imagesfrom );
2194                 $text = false;
2195                 # $imagesfrom could be either a single string or an array of strings, parse out the latter
2196                 if ( $imagesexception && is_array( $imagesfrom ) ) {
2197                         $imagematch = false;
2198                         foreach ( $imagesfrom as $match ) {
2199                                 if ( strpos( $url, $match ) === 0 ) {
2200                                         $imagematch = true;
2201                                         break;
2202                                 }
2203                         }
2204                 } elseif ( $imagesexception ) {
2205                         $imagematch = ( strpos( $url, $imagesfrom ) === 0 );
2206                 } else {
2207                         $imagematch = false;
2208                 }
2209
2210                 if ( $this->mOptions->getAllowExternalImages()
2211                         || ( $imagesexception && $imagematch )
2212                 ) {
2213                         if ( preg_match( self::EXT_IMAGE_REGEX, $url ) ) {
2214                                 # Image found
2215                                 $text = Linker::makeExternalImage( $url );
2216                         }
2217                 }
2218                 if ( !$text && $this->mOptions->getEnableImageWhitelist()
2219                         && preg_match( self::EXT_IMAGE_REGEX, $url )
2220                 ) {
2221                         $whitelist = explode(
2222                                 "\n",
2223                                 wfMessage( 'external_image_whitelist' )->inContentLanguage()->text()
2224                         );
2225
2226                         foreach ( $whitelist as $entry ) {
2227                                 # Sanitize the regex fragment, make it case-insensitive, ignore blank entries/comments
2228                                 if ( strpos( $entry, '#' ) === 0 || $entry === '' ) {
2229                                         continue;
2230                                 }
2231                                 if ( preg_match( '/' . str_replace( '/', '\\/', $entry ) . '/i', $url ) ) {
2232                                         # Image matches a whitelist entry
2233                                         $text = Linker::makeExternalImage( $url );
2234                                         break;
2235                                 }
2236                         }
2237                 }
2238                 return $text;
2239         }
2240
2241         /**
2242          * Process [[ ]] wikilinks
2243          *
2244          * @param string $s
2245          *
2246          * @return string Processed text
2247          *
2248          * @private
2249          */
2250         public function replaceInternalLinks( $s ) {
2251                 $this->mLinkHolders->merge( $this->replaceInternalLinks2( $s ) );
2252                 return $s;
2253         }
2254
2255         /**
2256          * Process [[ ]] wikilinks (RIL)
2257          * @param string &$s
2258          * @throws MWException
2259          * @return LinkHolderArray
2260          *
2261          * @private
2262          */
2263         public function replaceInternalLinks2( &$s ) {
2264                 static $tc = false, $e1, $e1_img;
2265                 # the % is needed to support urlencoded titles as well
2266                 if ( !$tc ) {
2267                         $tc = Title::legalChars() . '#%';
2268                         # Match a link having the form [[namespace:link|alternate]]trail
2269                         $e1 = "/^([{$tc}]+)(?:\\|(.+?))?]](.*)\$/sD";
2270                         # Match cases where there is no "]]", which might still be images
2271                         $e1_img = "/^([{$tc}]+)\\|(.*)\$/sD";
2272                 }
2273
2274                 $holders = new LinkHolderArray( $this );
2275
2276                 # split the entire text string on occurrences of [[
2277                 $a = StringUtils::explode( '[[', ' ' . $s );
2278                 # get the first element (all text up to first [[), and remove the space we added
2279                 $s = $a->current();
2280                 $a->next();
2281                 $line = $a->current(); # Workaround for broken ArrayIterator::next() that returns "void"
2282                 $s = substr( $s, 1 );
2283
2284                 $useLinkPrefixExtension = $this->getTargetLanguage()->linkPrefixExtension();
2285                 $e2 = null;
2286                 if ( $useLinkPrefixExtension ) {
2287                         # Match the end of a line for a word that's not followed by whitespace,
2288                         # e.g. in the case of 'The Arab al[[Razi]]', 'al' will be matched
2289                         $charset = $this->contLang->linkPrefixCharset();
2290                         $e2 = "/^((?>.*[^$charset]|))(.+)$/sDu";
2291                 }
2292
2293                 if ( is_null( $this->mTitle ) ) {
2294                         throw new MWException( __METHOD__ . ": \$this->mTitle is null\n" );
2295                 }
2296                 $nottalk = !$this->mTitle->isTalkPage();
2297
2298                 if ( $useLinkPrefixExtension ) {
2299                         $m = [];
2300                         if ( preg_match( $e2, $s, $m ) ) {
2301                                 $first_prefix = $m[2];
2302                         } else {
2303                                 $first_prefix = false;
2304                         }
2305                 } else {
2306                         $prefix = '';
2307                 }
2308
2309                 $useSubpages = $this->areSubpagesAllowed();
2310
2311                 # Loop for each link
2312                 for ( ; $line !== false && $line !== null; $a->next(), $line = $a->current() ) {
2313                         # Check for excessive memory usage
2314                         if ( $holders->isBig() ) {
2315                                 # Too big
2316                                 # Do the existence check, replace the link holders and clear the array
2317                                 $holders->replace( $s );
2318                                 $holders->clear();
2319                         }
2320
2321                         if ( $useLinkPrefixExtension ) {
2322                                 if ( preg_match( $e2, $s, $m ) ) {
2323                                         list( , $s, $prefix ) = $m;
2324                                 } else {
2325                                         $prefix = '';
2326                                 }
2327                                 # first link
2328                                 if ( $first_prefix ) {
2329                                         $prefix = $first_prefix;
2330                                         $first_prefix = false;
2331                                 }
2332                         }
2333
2334                         $might_be_img = false;
2335
2336                         if ( preg_match( $e1, $line, $m ) ) { # page with normal text or alt
2337                                 $text = $m[2];
2338                                 # If we get a ] at the beginning of $m[3] that means we have a link that's something like:
2339                                 # [[Image:Foo.jpg|[http://example.com desc]]] <- having three ] in a row fucks up,
2340                                 # the real problem is with the $e1 regex
2341                                 # See T1500.
2342                                 # Still some problems for cases where the ] is meant to be outside punctuation,
2343                                 # and no image is in sight. See T4095.
2344                                 if ( $text !== ''
2345                                         && substr( $m[3], 0, 1 ) === ']'
2346                                         && strpos( $text, '[' ) !== false
2347                                 ) {
2348                                         $text .= ']'; # so that replaceExternalLinks($text) works later
2349                                         $m[3] = substr( $m[3], 1 );
2350                                 }
2351                                 # fix up urlencoded title texts
2352                                 if ( strpos( $m[1], '%' ) !== false ) {
2353                                         # Should anchors '#' also be rejected?
2354                                         $m[1] = str_replace( [ '<', '>' ], [ '&lt;', '&gt;' ], rawurldecode( $m[1] ) );
2355                                 }
2356                                 $trail = $m[3];
2357                         } elseif ( preg_match( $e1_img, $line, $m ) ) {
2358                                 # Invalid, but might be an image with a link in its caption
2359                                 $might_be_img = true;
2360                                 $text = $m[2];
2361                                 if ( strpos( $m[1], '%' ) !== false ) {
2362                                         $m[1] = str_replace( [ '<', '>' ], [ '&lt;', '&gt;' ], rawurldecode( $m[1] ) );
2363                                 }
2364                                 $trail = "";
2365                         } else { # Invalid form; output directly
2366                                 $s .= $prefix . '[[' . $line;
2367                                 continue;
2368                         }
2369
2370                         $origLink = ltrim( $m[1], ' ' );
2371
2372                         # Don't allow internal links to pages containing
2373                         # PROTO: where PROTO is a valid URL protocol; these
2374                         # should be external links.
2375                         if ( preg_match( '/^(?i:' . $this->mUrlProtocols . ')/', $origLink ) ) {
2376                                 $s .= $prefix . '[[' . $line;
2377                                 continue;
2378                         }
2379
2380                         # Make subpage if necessary
2381                         if ( $useSubpages ) {
2382                                 $link = $this->maybeDoSubpageLink( $origLink, $text );
2383                         } else {
2384                                 $link = $origLink;
2385                         }
2386
2387                         // \x7f isn't a default legal title char, so most likely strip
2388                         // markers will force us into the "invalid form" path above.  But,
2389                         // just in case, let's assert that xmlish tags aren't valid in
2390                         // the title position.
2391                         $unstrip = $this->mStripState->killMarkers( $link );
2392                         $noMarkers = ( $unstrip === $link );
2393
2394                         $nt = $noMarkers ? Title::newFromText( $link ) : null;
2395                         if ( $nt === null ) {
2396                                 $s .= $prefix . '[[' . $line;
2397                                 continue;
2398                         }
2399
2400                         $ns = $nt->getNamespace();
2401                         $iw = $nt->getInterwiki();
2402
2403                         $noforce = ( substr( $origLink, 0, 1 ) !== ':' );
2404
2405                         if ( $might_be_img ) { # if this is actually an invalid link
2406                                 if ( $ns == NS_FILE && $noforce ) { # but might be an image
2407                                         $found = false;
2408                                         while ( true ) {
2409                                                 # look at the next 'line' to see if we can close it there
2410                                                 $a->next();
2411                                                 $next_line = $a->current();
2412                                                 if ( $next_line === false || $next_line === null ) {
2413                                                         break;
2414                                                 }
2415                                                 $m = explode( ']]', $next_line, 3 );
2416                                                 if ( count( $m ) == 3 ) {
2417                                                         # the first ]] closes the inner link, the second the image
2418                                                         $found = true;
2419                                                         $text .= "[[{$m[0]}]]{$m[1]}";
2420                                                         $trail = $m[2];
2421                                                         break;
2422                                                 } elseif ( count( $m ) == 2 ) {
2423                                                         # if there's exactly one ]] that's fine, we'll keep looking
2424                                                         $text .= "[[{$m[0]}]]{$m[1]}";
2425                                                 } else {
2426                                                         # if $next_line is invalid too, we need look no further
2427                                                         $text .= '[[' . $next_line;
2428                                                         break;
2429                                                 }
2430                                         }
2431                                         if ( !$found ) {
2432                                                 # we couldn't find the end of this imageLink, so output it raw
2433                                                 # but don't ignore what might be perfectly normal links in the text we've examined
2434                                                 $holders->merge( $this->replaceInternalLinks2( $text ) );
2435                                                 $s .= "{$prefix}[[$link|$text";
2436                                                 # note: no $trail, because without an end, there *is* no trail
2437                                                 continue;
2438                                         }
2439                                 } else { # it's not an image, so output it raw
2440                                         $s .= "{$prefix}[[$link|$text";
2441                                         # note: no $trail, because without an end, there *is* no trail
2442                                         continue;
2443                                 }
2444                         }
2445
2446                         $wasblank = ( $text == '' );
2447                         if ( $wasblank ) {
2448                                 $text = $link;
2449                                 if ( !$noforce ) {
2450                                         # Strip off leading ':'
2451                                         $text = substr( $text, 1 );
2452                                 }
2453                         } else {
2454                                 # T6598 madness. Handle the quotes only if they come from the alternate part
2455                                 # [[Lista d''e paise d''o munno]] -> <a href="...">Lista d''e paise d''o munno</a>
2456                                 # [[Criticism of Harry Potter|Criticism of ''Harry Potter'']]
2457                                 #    -> <a href="Criticism of Harry Potter">Criticism of <i>Harry Potter</i></a>
2458                                 $text = $this->doQuotes( $text );
2459                         }
2460
2461                         # Link not escaped by : , create the various objects
2462                         if ( $noforce && !$nt->wasLocalInterwiki() ) {
2463                                 # Interwikis
2464                                 if (
2465                                         $iw && $this->mOptions->getInterwikiMagic() && $nottalk && (
2466                                                 Language::fetchLanguageName( $iw, null, 'mw' ) ||
2467                                                 in_array( $iw, $this->svcOptions->get( 'ExtraInterlanguageLinkPrefixes' ) )
2468                                         )
2469                                 ) {
2470                                         # T26502: filter duplicates
2471                                         if ( !isset( $this->mLangLinkLanguages[$iw] ) ) {
2472                                                 $this->mLangLinkLanguages[$iw] = true;
2473                                                 $this->mOutput->addLanguageLink( $nt->getFullText() );
2474                                         }
2475
2476                                         /**
2477                                          * Strip the whitespace interwiki links produce, see T10897
2478                                          */
2479                                         $s = rtrim( $s . $prefix ) . $trail; # T175416
2480                                         continue;
2481                                 }
2482
2483                                 if ( $ns == NS_FILE ) {
2484                                         if ( !wfIsBadImage( $nt->getDBkey(), $this->mTitle ) ) {
2485                                                 if ( $wasblank ) {
2486                                                         # if no parameters were passed, $text
2487                                                         # becomes something like "File:Foo.png",
2488                                                         # which we don't want to pass on to the
2489                                                         # image generator
2490                                                         $text = '';
2491                                                 } else {
2492                                                         # recursively parse links inside the image caption
2493                                                         # actually, this will parse them in any other parameters, too,
2494                                                         # but it might be hard to fix that, and it doesn't matter ATM
2495                                                         $text = $this->replaceExternalLinks( $text );
2496                                                         $holders->merge( $this->replaceInternalLinks2( $text ) );
2497                                                 }
2498                                                 # cloak any absolute URLs inside the image markup, so replaceExternalLinks() won't touch them
2499                                                 $s .= $prefix . $this->armorLinks(
2500                                                         $this->makeImage( $nt, $text, $holders ) ) . $trail;
2501                                                 continue;
2502                                         }
2503                                 } elseif ( $ns == NS_CATEGORY ) {
2504                                         /**
2505                                          * Strip the whitespace Category links produce, see T2087
2506                                          */
2507                                         $s = rtrim( $s . $prefix ) . $trail; # T2087, T87753
2508
2509                                         if ( $wasblank ) {
2510                                                 $sortkey = $this->getDefaultSort();
2511                                         } else {
2512                                                 $sortkey = $text;
2513                                         }
2514                                         $sortkey = Sanitizer::decodeCharReferences( $sortkey );
2515                                         $sortkey = str_replace( "\n", '', $sortkey );
2516                                         $sortkey = $this->getTargetLanguage()->convertCategoryKey( $sortkey );
2517                                         $this->mOutput->addCategory( $nt->getDBkey(), $sortkey );
2518
2519                                         continue;
2520                                 }
2521                         }
2522
2523                         # Self-link checking. For some languages, variants of the title are checked in
2524                         # LinkHolderArray::doVariants() to allow batching the existence checks necessary
2525                         # for linking to a different variant.
2526                         if ( $ns != NS_SPECIAL && $nt->equals( $this->mTitle ) && !$nt->hasFragment() ) {
2527                                 $s .= $prefix . Linker::makeSelfLinkObj( $nt, $text, '', $trail );
2528                                 continue;
2529                         }
2530
2531                         # NS_MEDIA is a pseudo-namespace for linking directly to a file
2532                         # @todo FIXME: Should do batch file existence checks, see comment below
2533                         if ( $ns == NS_MEDIA ) {
2534                                 # Give extensions a chance to select the file revision for us
2535                                 $options = [];
2536                                 $descQuery = false;
2537                                 Hooks::run( 'BeforeParserFetchFileAndTitle',
2538                                         [ $this, $nt, &$options, &$descQuery ] );
2539                                 # Fetch and register the file (file title may be different via hooks)
2540                                 list( $file, $nt ) = $this->fetchFileAndTitle( $nt, $options );
2541                                 # Cloak with NOPARSE to avoid replacement in replaceExternalLinks
2542                                 $s .= $prefix . $this->armorLinks(
2543                                         Linker::makeMediaLinkFile( $nt, $file, $text ) ) . $trail;
2544                                 continue;
2545                         }
2546
2547                         # Some titles, such as valid special pages or files in foreign repos, should
2548                         # be shown as bluelinks even though they're not included in the page table
2549                         # @todo FIXME: isAlwaysKnown() can be expensive for file links; we should really do
2550                         # batch file existence checks for NS_FILE and NS_MEDIA
2551                         if ( $iw == '' && $nt->isAlwaysKnown() ) {
2552                                 $this->mOutput->addLink( $nt );
2553                                 $s .= $this->makeKnownLinkHolder( $nt, $text, $trail, $prefix );
2554                         } else {
2555                                 # Links will be added to the output link list after checking
2556                                 $s .= $holders->makeHolder( $nt, $text, [], $trail, $prefix );
2557                         }
2558                 }
2559                 return $holders;
2560         }
2561
2562         /**
2563          * Render a forced-blue link inline; protect against double expansion of
2564          * URLs if we're in a mode that prepends full URL prefixes to internal links.
2565          * Since this little disaster has to split off the trail text to avoid
2566          * breaking URLs in the following text without breaking trails on the
2567          * wiki links, it's been made into a horrible function.
2568          *
2569          * @param Title $nt
2570          * @param string $text
2571          * @param string $trail
2572          * @param string $prefix
2573          * @return string HTML-wikitext mix oh yuck
2574          */
2575         protected function makeKnownLinkHolder( $nt, $text = '', $trail = '', $prefix = '' ) {
2576                 list( $inside, $trail ) = Linker::splitTrail( $trail );
2577
2578                 if ( $text == '' ) {
2579                         $text = htmlspecialchars( $nt->getPrefixedText() );
2580                 }
2581
2582                 $link = $this->getLinkRenderer()->makeKnownLink(
2583                         $nt, new HtmlArmor( "$prefix$text$inside" )
2584                 );
2585
2586                 return $this->armorLinks( $link ) . $trail;
2587         }
2588
2589         /**
2590          * Insert a NOPARSE hacky thing into any inline links in a chunk that's
2591          * going to go through further parsing steps before inline URL expansion.
2592          *
2593          * Not needed quite as much as it used to be since free links are a bit
2594          * more sensible these days. But bracketed links are still an issue.
2595          *
2596          * @param string $text More-or-less HTML
2597          * @return string Less-or-more HTML with NOPARSE bits
2598          */
2599         public function armorLinks( $text ) {
2600                 return preg_replace( '/\b((?i)' . $this->mUrlProtocols . ')/',
2601                         self::MARKER_PREFIX . "NOPARSE$1", $text );
2602         }
2603
2604         /**
2605          * Return true if subpage links should be expanded on this page.
2606          * @return bool
2607          */
2608         public function areSubpagesAllowed() {
2609                 # Some namespaces don't allow subpages
2610                 return $this->nsInfo->hasSubpages( $this->mTitle->getNamespace() );
2611         }
2612
2613         /**
2614          * Handle link to subpage if necessary
2615          *
2616          * @param string $target The source of the link
2617          * @param string &$text The link text, modified as necessary
2618          * @return string The full name of the link
2619          * @private
2620          */
2621         public function maybeDoSubpageLink( $target, &$text ) {
2622                 return Linker::normalizeSubpageLink( $this->mTitle, $target, $text );
2623         }
2624
2625         /**
2626          * Make lists from lines starting with ':', '*', '#', etc. (DBL)
2627          *
2628          * @param string $text
2629          * @param bool $linestart Whether or not this is at the start of a line.
2630          * @private
2631          * @return string The lists rendered as HTML
2632          */
2633         public function doBlockLevels( $text, $linestart ) {
2634                 return BlockLevelPass::doBlockLevels( $text, $linestart );
2635         }
2636
2637         /**
2638          * Return value of a magic variable (like PAGENAME)
2639          *
2640          * @private
2641          *
2642          * @param string $index Magic variable identifier as mapped in MagicWordFactory::$mVariableIDs
2643          * @param bool|PPFrame $frame
2644          *
2645          * @throws MWException
2646          * @return string
2647          */
2648         public function getVariableValue( $index, $frame = false ) {
2649                 if ( is_null( $this->mTitle ) ) {
2650                         // If no title set, bad things are going to happen
2651                         // later. Title should always be set since this
2652                         // should only be called in the middle of a parse
2653                         // operation (but the unit-tests do funky stuff)
2654                         throw new MWException( __METHOD__ . ' Should only be '
2655                                 . ' called while parsing (no title set)' );
2656                 }
2657
2658                 // Avoid PHP 7.1 warning from passing $this by reference
2659                 $parser = $this;
2660
2661                 /**
2662                  * Some of these require message or data lookups and can be
2663                  * expensive to check many times.
2664                  */
2665                 if (
2666                         Hooks::run( 'ParserGetVariableValueVarCache', [ &$parser, &$this->mVarCache ] ) &&
2667                         isset( $this->mVarCache[$index] )
2668                 ) {
2669                         return $this->mVarCache[$index];
2670                 }
2671
2672                 $ts = wfTimestamp( TS_UNIX, $this->mOptions->getTimestamp() );
2673                 Hooks::run( 'ParserGetVariableValueTs', [ &$parser, &$ts ] );
2674
2675                 $pageLang = $this->getFunctionLang();
2676
2677                 switch ( $index ) {
2678                         case '!':
2679                                 $value = '|';
2680                                 break;
2681                         case 'currentmonth':
2682                                 $value = $pageLang->formatNum( MWTimestamp::getInstance( $ts )->format( 'm' ), true );
2683                                 break;
2684                         case 'currentmonth1':
2685                                 $value = $pageLang->formatNum( MWTimestamp::getInstance( $ts )->format( 'n' ), true );
2686                                 break;
2687                         case 'currentmonthname':
2688                                 $value = $pageLang->getMonthName( MWTimestamp::getInstance( $ts )->format( 'n' ) );
2689                                 break;
2690                         case 'currentmonthnamegen':
2691                                 $value = $pageLang->getMonthNameGen( MWTimestamp::getInstance( $ts )->format( 'n' ) );
2692                                 break;
2693                         case 'currentmonthabbrev':
2694                                 $value = $pageLang->getMonthAbbreviation( MWTimestamp::getInstance( $ts )->format( 'n' ) );
2695                                 break;
2696                         case 'currentday':
2697                                 $value = $pageLang->formatNum( MWTimestamp::getInstance( $ts )->format( 'j' ), true );
2698                                 break;
2699                         case 'currentday2':
2700                                 $value = $pageLang->formatNum( MWTimestamp::getInstance( $ts )->format( 'd' ), true );
2701                                 break;
2702                         case 'localmonth':
2703                                 $value = $pageLang->formatNum( MWTimestamp::getLocalInstance( $ts )->format( 'm' ), true );
2704                                 break;
2705                         case 'localmonth1':
2706                                 $value = $pageLang->formatNum( MWTimestamp::getLocalInstance( $ts )->format( 'n' ), true );
2707                                 break;
2708                         case 'localmonthname':
2709                                 $value = $pageLang->getMonthName( MWTimestamp::getLocalInstance( $ts )->format( 'n' ) );
2710                                 break;
2711                         case 'localmonthnamegen':
2712                                 $value = $pageLang->getMonthNameGen( MWTimestamp::getLocalInstance( $ts )->format( 'n' ) );
2713                                 break;
2714                         case 'localmonthabbrev':
2715                                 $value = $pageLang->getMonthAbbreviation( MWTimestamp::getLocalInstance( $ts )->format( 'n' ) );
2716                                 break;
2717                         case 'localday':
2718                                 $value = $pageLang->formatNum( MWTimestamp::getLocalInstance( $ts )->format( 'j' ), true );
2719                                 break;
2720                         case 'localday2':
2721                                 $value = $pageLang->formatNum( MWTimestamp::getLocalInstance( $ts )->format( 'd' ), true );
2722                                 break;
2723                         case 'pagename':
2724                                 $value = wfEscapeWikiText( $this->mTitle->getText() );
2725                                 break;
2726                         case 'pagenamee':
2727                                 $value = wfEscapeWikiText( $this->mTitle->getPartialURL() );
2728                                 break;
2729                         case 'fullpagename':
2730                                 $value = wfEscapeWikiText( $this->mTitle->getPrefixedText() );
2731                                 break;
2732                         case 'fullpagenamee':
2733                                 $value = wfEscapeWikiText( $this->mTitle->getPrefixedURL() );
2734                                 break;
2735                         case 'subpagename':
2736                                 $value = wfEscapeWikiText( $this->mTitle->getSubpageText() );
2737                                 break;
2738                         case 'subpagenamee':
2739                                 $value = wfEscapeWikiText( $this->mTitle->getSubpageUrlForm() );
2740                                 break;
2741                         case 'rootpagename':
2742                                 $value = wfEscapeWikiText( $this->mTitle->getRootText() );
2743                                 break;
2744                         case 'rootpagenamee':
2745                                 $value = wfEscapeWikiText( wfUrlencode( str_replace(
2746                                         ' ',
2747                                         '_',
2748                                         $this->mTitle->getRootText()
2749                                 ) ) );
2750                                 break;
2751                         case 'basepagename':
2752                                 $value = wfEscapeWikiText( $this->mTitle->getBaseText() );
2753                                 break;
2754                         case 'basepagenamee':
2755                                 $value = wfEscapeWikiText( wfUrlencode( str_replace(
2756                                         ' ',
2757                                         '_',
2758                                         $this->mTitle->getBaseText()
2759                                 ) ) );
2760                                 break;
2761                         case 'talkpagename':
2762                                 if ( $this->mTitle->canHaveTalkPage() ) {
2763                                         $talkPage = $this->mTitle->getTalkPage();
2764                                         $value = wfEscapeWikiText( $talkPage->getPrefixedText() );
2765                                 } else {
2766                                         $value = '';
2767                                 }
2768                                 break;
2769                         case 'talkpagenamee':
2770                                 if ( $this->mTitle->canHaveTalkPage() ) {
2771                                         $talkPage = $this->mTitle->getTalkPage();
2772                                         $value = wfEscapeWikiText( $talkPage->getPrefixedURL() );
2773                                 } else {
2774                                         $value = '';
2775                                 }
2776                                 break;
2777                         case 'subjectpagename':
2778                                 $subjPage = $this->mTitle->getSubjectPage();
2779                                 $value = wfEscapeWikiText( $subjPage->getPrefixedText() );
2780                                 break;
2781                         case 'subjectpagenamee':
2782                                 $subjPage = $this->mTitle->getSubjectPage();
2783                                 $value = wfEscapeWikiText( $subjPage->getPrefixedURL() );
2784                                 break;
2785                         case 'pageid': // requested in T25427
2786                                 # Inform the edit saving system that getting the canonical output
2787                                 # after page insertion requires a parse that used that exact page ID
2788                                 $this->setOutputFlag( 'vary-page-id', '{{PAGEID}} used' );
2789                                 $value = $this->mTitle->getArticleID();
2790                                 if ( !$value ) {
2791                                         $value = $this->mOptions->getSpeculativePageId();
2792                                         if ( $value ) {
2793                                                 $this->mOutput->setSpeculativePageIdUsed( $value );
2794                                         }
2795                                 }
2796                                 break;
2797                         case 'revisionid':
2798                                 if (
2799                                         $this->svcOptions->get( 'MiserMode' ) &&
2800                                         !$this->mOptions->getInterfaceMessage() &&
2801                                         // @TODO: disallow this word on all namespaces
2802                                         $this->nsInfo->isContent( $this->mTitle->getNamespace() )
2803                                 ) {
2804                                         // Use a stub result instead of the actual revision ID in order to avoid
2805                                         // double parses on page save but still allow preview detection (T137900)
2806                                         if ( $this->getRevisionId() || $this->mOptions->getSpeculativeRevId() ) {
2807                                                 $value = '-';
2808                                         } else {
2809                                                 $this->setOutputFlag( 'vary-revision-exists', '{{REVISIONID}} used' );
2810                                                 $value = '';
2811                                         }
2812                                 } else {
2813                                         # Inform the edit saving system that getting the canonical output after
2814                                         # revision insertion requires a parse that used that exact revision ID
2815                                         $this->setOutputFlag( 'vary-revision-id', '{{REVISIONID}} used' );
2816                                         $value = $this->getRevisionId();
2817                                         if ( $value === 0 ) {
2818                                                 $rev = $this->getRevisionObject();
2819                                                 $value = $rev ? $rev->getId() : $value;
2820                                         }
2821                                         if ( !$value ) {
2822                                                 $value = $this->mOptions->getSpeculativeRevId();
2823                                                 if ( $value ) {
2824                                                         $this->mOutput->setSpeculativeRevIdUsed( $value );
2825                                                 }
2826                                         }
2827                                 }
2828                                 break;
2829                         case 'revisionday':
2830                                 $value = (int)$this->getRevisionTimestampSubstring( 6, 2, self::MAX_TTS, $index );
2831                                 break;
2832                         case 'revisionday2':
2833                                 $value = $this->getRevisionTimestampSubstring( 6, 2, self::MAX_TTS, $index );
2834                                 break;
2835                         case 'revisionmonth':
2836                                 $value = $this->getRevisionTimestampSubstring( 4, 2, self::MAX_TTS, $index );
2837                                 break;
2838                         case 'revisionmonth1':
2839                                 $value = (int)$this->getRevisionTimestampSubstring( 4, 2, self::MAX_TTS, $index );
2840                                 break;
2841                         case 'revisionyear':
2842                                 $value = $this->getRevisionTimestampSubstring( 0, 4, self::MAX_TTS, $index );
2843                                 break;
2844                         case 'revisiontimestamp':
2845                                 $value = $this->getRevisionTimestampSubstring( 0, 14, self::MAX_TTS, $index );
2846                                 break;
2847                         case 'revisionuser':
2848                                 # Inform the edit saving system that getting the canonical output after
2849                                 # revision insertion requires a parse that used the actual user ID
2850                                 $this->setOutputFlag( 'vary-user', '{{REVISIONUSER}} used' );
2851                                 $value = $this->getRevisionUser();
2852                                 break;
2853                         case 'revisionsize':
2854                                 $value = $this->getRevisionSize();
2855                                 break;
2856                         case 'namespace':
2857                                 $value = str_replace( '_', ' ',
2858                                         $this->contLang->getNsText( $this->mTitle->getNamespace() ) );
2859                                 break;
2860                         case 'namespacee':
2861                                 $value = wfUrlencode( $this->contLang->getNsText( $this->mTitle->getNamespace() ) );
2862                                 break;
2863                         case 'namespacenumber':
2864                                 $value = $this->mTitle->getNamespace();
2865                                 break;
2866                         case 'talkspace':
2867                                 $value = $this->mTitle->canHaveTalkPage()
2868                                         ? str_replace( '_', ' ', $this->mTitle->getTalkNsText() )
2869                                         : '';
2870                                 break;
2871                         case 'talkspacee':
2872                                 $value = $this->mTitle->canHaveTalkPage() ? wfUrlencode( $this->mTitle->getTalkNsText() ) : '';
2873                                 break;
2874                         case 'subjectspace':
2875                                 $value = str_replace( '_', ' ', $this->mTitle->getSubjectNsText() );
2876                                 break;
2877                         case 'subjectspacee':
2878                                 $value = ( wfUrlencode( $this->mTitle->getSubjectNsText() ) );
2879                                 break;
2880                         case 'currentdayname':
2881                                 $value = $pageLang->getWeekdayName( (int)MWTimestamp::getInstance( $ts )->format( 'w' ) + 1 );
2882                                 break;
2883                         case 'currentyear':
2884                                 $value = $pageLang->formatNum( MWTimestamp::getInstance( $ts )->format( 'Y' ), true );
2885                                 break;
2886                         case 'currenttime':
2887                                 $value = $pageLang->time( wfTimestamp( TS_MW, $ts ), false, false );
2888                                 break;
2889                         case 'currenthour':
2890                                 $value = $pageLang->formatNum( MWTimestamp::getInstance( $ts )->format( 'H' ), true );
2891                                 break;
2892                         case 'currentweek':
2893                                 # @bug T6594 PHP5 has it zero padded, PHP4 does not, cast to
2894                                 # int to remove the padding
2895                                 $value = $pageLang->formatNum( (int)MWTimestamp::getInstance( $ts )->format( 'W' ) );
2896                                 break;
2897                         case 'currentdow':
2898                                 $value = $pageLang->formatNum( MWTimestamp::getInstance( $ts )->format( 'w' ) );
2899                                 break;
2900                         case 'localdayname':
2901                                 $value = $pageLang->getWeekdayName(
2902                                         (int)MWTimestamp::getLocalInstance( $ts )->format( 'w' ) + 1
2903                                 );
2904                                 break;
2905                         case 'localyear':
2906                                 $value = $pageLang->formatNum( MWTimestamp::getLocalInstance( $ts )->format( 'Y' ), true );
2907                                 break;
2908                         case 'localtime':
2909                                 $value = $pageLang->time(
2910                                         MWTimestamp::getLocalInstance( $ts )->format( 'YmdHis' ),
2911                                         false,
2912                                         false
2913                                 );
2914                                 break;
2915                         case 'localhour':
2916                                 $value = $pageLang->formatNum( MWTimestamp::getLocalInstance( $ts )->format( 'H' ), true );
2917                                 break;
2918                         case 'localweek':
2919                                 # @bug T6594 PHP5 has it zero padded, PHP4 does not, cast to
2920                                 # int to remove the padding
2921                                 $value = $pageLang->formatNum( (int)MWTimestamp::getLocalInstance( $ts )->format( 'W' ) );
2922                                 break;
2923                         case 'localdow':
2924                                 $value = $pageLang->formatNum( MWTimestamp::getLocalInstance( $ts )->format( 'w' ) );
2925                                 break;
2926                         case 'numberofarticles':
2927                                 $value = $pageLang->formatNum( SiteStats::articles() );
2928                                 break;
2929                         case 'numberoffiles':
2930                                 $value = $pageLang->formatNum( SiteStats::images() );
2931                                 break;
2932                         case 'numberofusers':
2933                                 $value = $pageLang->formatNum( SiteStats::users() );
2934                                 break;
2935                         case 'numberofactiveusers':
2936                                 $value = $pageLang->formatNum( SiteStats::activeUsers() );
2937                                 break;
2938                         case 'numberofpages':
2939                                 $value = $pageLang->formatNum( SiteStats::pages() );
2940                                 break;
2941                         case 'numberofadmins':
2942                                 $value = $pageLang->formatNum( SiteStats::numberingroup( 'sysop' ) );
2943                                 break;
2944                         case 'numberofedits':
2945                                 $value = $pageLang->formatNum( SiteStats::edits() );
2946                                 break;
2947                         case 'currenttimestamp':
2948                                 $value = wfTimestamp( TS_MW, $ts );
2949                                 break;
2950                         case 'localtimestamp':
2951                                 $value = MWTimestamp::getLocalInstance( $ts )->format( 'YmdHis' );
2952                                 break;
2953                         case 'currentversion':
2954                                 $value = SpecialVersion::getVersion();
2955                                 break;
2956                         case 'articlepath':
2957                                 return $this->svcOptions->get( 'ArticlePath' );
2958                         case 'sitename':
2959                                 return $this->svcOptions->get( 'Sitename' );
2960                         case 'server':
2961                                 return $this->svcOptions->get( 'Server' );
2962                         case 'servername':
2963                                 return $this->svcOptions->get( 'ServerName' );
2964                         case 'scriptpath':
2965                                 return $this->svcOptions->get( 'ScriptPath' );
2966                         case 'stylepath':
2967                                 return $this->svcOptions->get( 'StylePath' );
2968                         case 'directionmark':
2969                                 return $pageLang->getDirMark();
2970                         case 'contentlanguage':
2971                                 return $this->svcOptions->get( 'LanguageCode' );
2972                         case 'pagelanguage':
2973                                 $value = $pageLang->getCode();
2974                                 break;
2975                         case 'cascadingsources':
2976                                 $value = CoreParserFunctions::cascadingsources( $this );
2977                                 break;
2978                         default:
2979                                 $ret = null;
2980                                 Hooks::run(
2981                                         'ParserGetVariableValueSwitch',
2982                                         [ &$parser, &$this->mVarCache, &$index, &$ret, &$frame ]
2983                                 );
2984
2985                                 return $ret;
2986                 }
2987
2988                 if ( $index ) {
2989                         $this->mVarCache[$index] = $value;
2990                 }
2991
2992                 return $value;
2993         }
2994
2995         /**
2996          * @param int $start
2997          * @param int $len
2998          * @param int $mtts Max time-till-save; sets vary-revision-timestamp if result changes by then
2999          * @param string $variable Parser variable name
3000          * @return string
3001          */
3002         private function getRevisionTimestampSubstring( $start, $len, $mtts, $variable ) {
3003                 # Get the timezone-adjusted timestamp to be used for this revision
3004                 $resNow = substr( $this->getRevisionTimestamp(), $start, $len );
3005                 # Possibly set vary-revision if there is not yet an associated revision
3006                 if ( !$this->getRevisionObject() ) {
3007                         # Get the timezone-adjusted timestamp $mtts seconds in the future.
3008                         # This future is relative to the current time and not that of the
3009                         # parser options. The rendered timestamp can be compared to that
3010                         # of the timestamp specified by the parser options.
3011                         $resThen = substr(
3012                                 $this->contLang->userAdjust( wfTimestamp( TS_MW, time() + $mtts ), '' ),
3013                                 $start,
3014                                 $len
3015                         );
3016
3017                         if ( $resNow !== $resThen ) {
3018                                 # Inform the edit saving system that getting the canonical output after
3019                                 # revision insertion requires a parse that used an actual revision timestamp
3020                                 $this->setOutputFlag( 'vary-revision-timestamp', "$variable used" );
3021                         }
3022                 }
3023
3024                 return $resNow;
3025         }
3026
3027         /**
3028          * initialise the magic variables (like CURRENTMONTHNAME) and substitution modifiers
3029          *
3030          * @private
3031          */
3032         public function initialiseVariables() {
3033                 $variableIDs = $this->magicWordFactory->getVariableIDs();
3034                 $substIDs = $this->magicWordFactory->getSubstIDs();
3035
3036                 $this->mVariables = $this->magicWordFactory->newArray( $variableIDs );
3037                 $this->mSubstWords = $this->magicWordFactory->newArray( $substIDs );
3038         }
3039
3040         /**
3041          * Preprocess some wikitext and return the document tree.
3042          * This is the ghost of replace_variables().
3043          *
3044          * @param string $text The text to parse
3045          * @param int $flags Bitwise combination of:
3046          *   - self::PTD_FOR_INCLUSION: Handle "<noinclude>" and "<includeonly>" as if the text is being
3047          *     included. Default is to assume a direct page view.
3048          *
3049          * The generated DOM tree must depend only on the input text and the flags.
3050          * The DOM tree must be the same in OT_HTML and OT_WIKI mode, to avoid a regression of T6899.
3051          *
3052          * Any flag added to the $flags parameter here, or any other parameter liable to cause a
3053          * change in the DOM tree for a given text, must be passed through the section identifier
3054          * in the section edit link and thus back to extractSections().
3055          *
3056          * The output of this function is currently only cached in process memory, but a persistent
3057          * cache may be implemented at a later date which takes further advantage of these strict
3058          * dependency requirements.
3059          *
3060          * @return PPNode
3061          */
3062         public function preprocessToDom( $text, $flags = 0 ) {
3063                 $dom = $this->getPreprocessor()->preprocessToObj( $text, $flags );
3064                 return $dom;
3065         }
3066
3067         /**
3068          * Return a three-element array: leading whitespace, string contents, trailing whitespace
3069          *
3070          * @param string $s
3071          *
3072          * @return array
3073          */
3074         public static function splitWhitespace( $s ) {
3075                 $ltrimmed = ltrim( $s );
3076                 $w1 = substr( $s, 0, strlen( $s ) - strlen( $ltrimmed ) );
3077                 $trimmed = rtrim( $ltrimmed );
3078                 $diff = strlen( $ltrimmed ) - strlen( $trimmed );
3079                 if ( $diff > 0 ) {
3080                         $w2 = substr( $ltrimmed, -$diff );
3081                 } else {
3082                         $w2 = '';
3083                 }
3084                 return [ $w1, $trimmed, $w2 ];
3085         }
3086
3087         /**
3088          * Replace magic variables, templates, and template arguments
3089          * with the appropriate text. Templates are substituted recursively,
3090          * taking care to avoid infinite loops.
3091          *
3092          * Note that the substitution depends on value of $mOutputType:
3093          *  self::OT_WIKI: only {{subst:}} templates
3094          *  self::OT_PREPROCESS: templates but not extension tags
3095          *  self::OT_HTML: all templates and extension tags
3096          *
3097          * @param string $text The text to transform
3098          * @param false|PPFrame|array $frame Object describing the arguments passed to the
3099          *   template. Arguments may also be provided as an associative array, as
3100          *   was the usual case before MW1.12. Providing arguments this way may be
3101          *   useful for extensions wishing to perform variable replacement
3102          *   explicitly.
3103          * @param bool $argsOnly Only do argument (triple-brace) expansion, not
3104          *   double-brace expansion.
3105          * @return string
3106          */
3107         public function replaceVariables( $text, $frame = false, $argsOnly = false ) {
3108                 # Is there any text? Also, Prevent too big inclusions!
3109                 $textSize = strlen( $text );
3110                 if ( $textSize < 1 || $textSize > $this->mOptions->getMaxIncludeSize() ) {
3111                         return $text;
3112                 }
3113
3114                 if ( $frame === false ) {
3115                         $frame = $this->getPreprocessor()->newFrame();
3116                 } elseif ( !( $frame instanceof PPFrame ) ) {
3117                         $this->logger->debug(
3118                                 __METHOD__ . " called using plain parameters instead of " .
3119                                 "a PPFrame instance. Creating custom frame."
3120                         );
3121                         $frame = $this->getPreprocessor()->newCustomFrame( $frame );
3122                 }
3123
3124                 $dom = $this->preprocessToDom( $text );
3125                 $flags = $argsOnly ? PPFrame::NO_TEMPLATES : 0;
3126                 $text = $frame->expand( $dom, $flags );
3127
3128                 return $text;
3129         }
3130
3131         /**
3132          * Clean up argument array - refactored in 1.9 so parserfunctions can use it, too.
3133          *
3134          * @param array $args
3135          *
3136          * @return array
3137          */
3138         public static function createAssocArgs( $args ) {
3139                 $assocArgs = [];
3140                 $index = 1;
3141                 foreach ( $args as $arg ) {
3142                         $eqpos = strpos( $arg, '=' );
3143                         if ( $eqpos === false ) {
3144                                 $assocArgs[$index++] = $arg;
3145                         } else {
3146                                 $name = trim( substr( $arg, 0, $eqpos ) );
3147                                 $value = trim( substr( $arg, $eqpos + 1 ) );
3148                                 if ( $value === false ) {
3149                                         $value = '';
3150                                 }
3151                                 if ( $name !== false ) {
3152                                         $assocArgs[$name] = $value;
3153                                 }
3154                         }
3155                 }
3156
3157                 return $assocArgs;
3158         }
3159
3160         /**
3161          * Warn the user when a parser limitation is reached
3162          * Will warn at most once the user per limitation type
3163          *
3164          * The results are shown during preview and run through the Parser (See EditPage.php)
3165          *
3166          * @param string $limitationType Should be one of:
3167          *   'expensive-parserfunction' (corresponding messages:
3168          *       'expensive-parserfunction-warning',
3169          *       'expensive-parserfunction-category')
3170          *   'post-expand-template-argument' (corresponding messages:
3171          *       'post-expand-template-argument-warning',
3172          *       'post-expand-template-argument-category')
3173          *   'post-expand-template-inclusion' (corresponding messages:
3174          *       'post-expand-template-inclusion-warning',
3175          *       'post-expand-template-inclusion-category')
3176          *   'node-count-exceeded' (corresponding messages:
3177          *       'node-count-exceeded-warning',
3178          *       'node-count-exceeded-category')
3179          *   'expansion-depth-exceeded' (corresponding messages:
3180          *       'expansion-depth-exceeded-warning',
3181          *       'expansion-depth-exceeded-category')
3182          * @param string|int|null $current Current value
3183          * @param string|int|null $max Maximum allowed, when an explicit limit has been
3184          *       exceeded, provide the values (optional)
3185          */
3186         public function limitationWarn( $limitationType, $current = '', $max = '' ) {
3187                 # does no harm if $current and $max are present but are unnecessary for the message
3188                 # Not doing ->inLanguage( $this->mOptions->getUserLangObj() ), since this is shown
3189                 # only during preview, and that would split the parser cache unnecessarily.
3190                 $warning = wfMessage( "$limitationType-warning" )->numParams( $current, $max )
3191                         ->text();
3192                 $this->mOutput->addWarning( $warning );
3193                 $this->addTrackingCategory( "$limitationType-category" );
3194         }
3195
3196         /**
3197          * Return the text of a template, after recursively
3198          * replacing any variables or templates within the template.
3199          *
3200          * @param array $piece The parts of the template
3201          *   $piece['title']: the title, i.e. the part before the |
3202          *   $piece['parts']: the parameter array
3203          *   $piece['lineStart']: whether the brace was at the start of a line
3204          * @param PPFrame $frame The current frame, contains template arguments
3205          * @throws Exception
3206          * @return string|array The text of the template
3207          */
3208         public function braceSubstitution( $piece, $frame ) {
3209                 // Flags
3210
3211                 // $text has been filled
3212                 $found = false;
3213                 // wiki markup in $text should be escaped
3214                 $nowiki = false;
3215                 // $text is HTML, armour it against wikitext transformation
3216                 $isHTML = false;
3217                 // Force interwiki transclusion to be done in raw mode not rendered
3218                 $forceRawInterwiki = false;
3219                 // $text is a DOM node needing expansion in a child frame
3220                 $isChildObj = false;
3221                 // $text is a DOM node needing expansion in the current frame
3222                 $isLocalObj = false;
3223
3224                 # Title object, where $text came from
3225                 $title = false;
3226
3227                 # $part1 is the bit before the first |, and must contain only title characters.
3228                 # Various prefixes will be stripped from it later.
3229                 $titleWithSpaces = $frame->expand( $piece['title'] );
3230                 $part1 = trim( $titleWithSpaces );
3231                 $titleText = false;
3232
3233                 # Original title text preserved for various purposes
3234                 $originalTitle = $part1;
3235
3236                 # $args is a list of argument nodes, starting from index 0, not including $part1
3237                 # @todo FIXME: If piece['parts'] is null then the call to getLength()
3238                 # below won't work b/c this $args isn't an object
3239                 $args = ( $piece['parts'] == null ) ? [] : $piece['parts'];
3240
3241                 $profileSection = null; // profile templates
3242
3243                 # SUBST
3244                 if ( !$found ) {
3245                         $substMatch = $this->mSubstWords->matchStartAndRemove( $part1 );
3246
3247                         # Possibilities for substMatch: "subst", "safesubst" or FALSE
3248                         # Decide whether to expand template or keep wikitext as-is.
3249                         if ( $this->ot['wiki'] ) {
3250                                 if ( $substMatch === false ) {
3251                                         $literal = true;  # literal when in PST with no prefix
3252                                 } else {
3253                                         $literal = false; # expand when in PST with subst: or safesubst:
3254                                 }
3255                         } else {
3256                                 if ( $substMatch == 'subst' ) {
3257                                         $literal = true;  # literal when not in PST with plain subst:
3258                                 } else {
3259                                         $literal = false; # expand when not in PST with safesubst: or no prefix
3260                                 }
3261                         }
3262                         if ( $literal ) {
3263                                 $text = $frame->virtualBracketedImplode( '{{', '|', '}}', $titleWithSpaces, $args );
3264                                 $isLocalObj = true;
3265                                 $found = true;
3266                         }
3267                 }
3268
3269                 # Variables
3270                 if ( !$found && $args->getLength() == 0 ) {
3271                         $id = $this->mVariables->matchStartToEnd( $part1 );
3272                         if ( $id !== false ) {
3273                                 $text = $this->getVariableValue( $id, $frame );
3274                                 if ( $this->magicWordFactory->getCacheTTL( $id ) > -1 ) {
3275                                         $this->mOutput->updateCacheExpiry(
3276                                                 $this->magicWordFactory->getCacheTTL( $id ) );
3277                                 }
3278                                 $found = true;
3279                         }
3280                 }
3281
3282                 # MSG, MSGNW and RAW
3283                 if ( !$found ) {
3284                         # Check for MSGNW:
3285                         $mwMsgnw = $this->magicWordFactory->get( 'msgnw' );
3286                         if ( $mwMsgnw->matchStartAndRemove( $part1 ) ) {
3287                                 $nowiki = true;
3288                         } else {
3289                                 # Remove obsolete MSG:
3290                                 $mwMsg = $this->magicWordFactory->get( 'msg' );
3291                                 $mwMsg->matchStartAndRemove( $part1 );
3292                         }
3293
3294                         # Check for RAW:
3295                         $mwRaw = $this->magicWordFactory->get( 'raw' );
3296                         if ( $mwRaw->matchStartAndRemove( $part1 ) ) {
3297                                 $forceRawInterwiki = true;
3298                         }
3299                 }
3300
3301                 # Parser functions
3302                 if ( !$found ) {
3303                         $colonPos = strpos( $part1, ':' );
3304                         if ( $colonPos !== false ) {
3305                                 $func = substr( $part1, 0, $colonPos );
3306                                 $funcArgs = [ trim( substr( $part1, $colonPos + 1 ) ) ];
3307                                 $argsLength = $args->getLength();
3308                                 for ( $i = 0; $i < $argsLength; $i++ ) {
3309                                         $funcArgs[] = $args->item( $i );
3310                                 }
3311
3312                                 $result = $this->callParserFunction( $frame, $func, $funcArgs );
3313
3314                                 // Extract any forwarded flags
3315                                 if ( isset( $result['title'] ) ) {
3316                                         $title = $result['title'];
3317                                 }
3318                                 if ( isset( $result['found'] ) ) {
3319                                         $found = $result['found'];
3320                                 }
3321                                 if ( array_key_exists( 'text', $result ) ) {
3322                                         // a string or null
3323                                         $text = $result['text'];
3324                                 }
3325                                 if ( isset( $result['nowiki'] ) ) {
3326                                         $nowiki = $result['nowiki'];
3327                                 }
3328                                 if ( isset( $result['isHTML'] ) ) {
3329                                         $isHTML = $result['isHTML'];
3330                                 }
3331                                 if ( isset( $result['forceRawInterwiki'] ) ) {
3332                                         $forceRawInterwiki = $result['forceRawInterwiki'];
3333                                 }
3334                                 if ( isset( $result['isChildObj'] ) ) {
3335                                         $isChildObj = $result['isChildObj'];
3336                                 }
3337                                 if ( isset( $result['isLocalObj'] ) ) {
3338                                         $isLocalObj = $result['isLocalObj'];
3339                                 }
3340                         }
3341                 }
3342
3343                 # Finish mangling title and then check for loops.
3344                 # Set $title to a Title object and $titleText to the PDBK
3345                 if ( !$found ) {
3346                         $ns = NS_TEMPLATE;
3347                         # Split the title into page and subpage
3348                         $subpage = '';
3349                         $relative = $this->maybeDoSubpageLink( $part1, $subpage );
3350                         if ( $part1 !== $relative ) {
3351                                 $part1 = $relative;
3352                                 $ns = $this->mTitle->getNamespace();
3353                         }
3354                         $title = Title::newFromText( $part1, $ns );
3355                         if ( $title ) {
3356                                 $titleText = $title->getPrefixedText();
3357                                 # Check for language variants if the template is not found
3358                                 if ( $this->getTargetLanguage()->hasVariants() && $title->getArticleID() == 0 ) {
3359                                         $this->getTargetLanguage()->findVariantLink( $part1, $title, true );
3360                                 }
3361                                 # Do recursion depth check
3362                                 $limit = $this->mOptions->getMaxTemplateDepth();
3363                                 if ( $frame->depth >= $limit ) {
3364                                         $found = true;
3365                                         $text = '<span class="error">'
3366                                                 . wfMessage( 'parser-template-recursion-depth-warning' )
3367                                                         ->numParams( $limit )->inContentLanguage()->text()
3368                                                 . '</span>';
3369                                 }
3370                         }
3371                 }
3372
3373                 # Load from database
3374                 if ( !$found && $title ) {
3375                         $profileSection = $this->mProfiler->scopedProfileIn( $title->getPrefixedDBkey() );
3376                         if ( !$title->isExternal() ) {
3377                                 if ( $title->isSpecialPage()
3378                                         && $this->mOptions->getAllowSpecialInclusion()
3379                                         && $this->ot['html']
3380                                 ) {
3381                                         $specialPage = $this->specialPageFactory->getPage( $title->getDBkey() );
3382                                         // Pass the template arguments as URL parameters.
3383                                         // "uselang" will have no effect since the Language object
3384                                         // is forced to the one defined in ParserOptions.
3385                                         $pageArgs = [];
3386                                         $argsLength = $args->getLength();
3387                                         for ( $i = 0; $i < $argsLength; $i++ ) {
3388                                                 $bits = $args->item( $i )->splitArg();
3389                                                 if ( strval( $bits['index'] ) === '' ) {
3390                                                         $name = trim( $frame->expand( $bits['name'], PPFrame::STRIP_COMMENTS ) );
3391                                                         $value = trim( $frame->expand( $bits['value'] ) );
3392                                                         $pageArgs[$name] = $value;
3393                                                 }
3394                                         }
3395
3396                                         // Create a new context to execute the special page
3397                                         $context = new RequestContext;
3398                                         $context->setTitle( $title );
3399                                         $context->setRequest( new FauxRequest( $pageArgs ) );
3400                                         if ( $specialPage && $specialPage->maxIncludeCacheTime() === 0 ) {
3401                                                 $context->setUser( $this->getUser() );
3402                                         } else {
3403                                                 // If this page is cached, then we better not be per user.
3404                                                 $context->setUser( User::newFromName( '127.0.0.1', false ) );
3405                                         }
3406                                         $context->setLanguage( $this->mOptions->getUserLangObj() );
3407                                         $ret = $this->specialPageFactory->capturePath( $title, $context, $this->getLinkRenderer() );
3408                                         if ( $ret ) {
3409                                                 $text = $context->getOutput()->getHTML();
3410                                                 $this->mOutput->addOutputPageMetadata( $context->getOutput() );
3411                                                 $found = true;
3412                                                 $isHTML = true;
3413                                                 if ( $specialPage && $specialPage->maxIncludeCacheTime() !== false ) {
3414                                                         $this->mOutput->updateRuntimeAdaptiveExpiry(
3415                                                                 $specialPage->maxIncludeCacheTime()
3416                                                         );
3417                                                 }
3418                                         }
3419                                 } elseif ( $this->nsInfo->isNonincludable( $title->getNamespace() ) ) {
3420                                         $found = false; # access denied
3421                                         $this->logger->debug(
3422                                                 __METHOD__ .
3423                                                 ": template inclusion denied for " . $title->getPrefixedDBkey()
3424                                         );
3425                                 } else {
3426                                         list( $text, $title ) = $this->getTemplateDom( $title );
3427                                         if ( $text !== false ) {
3428                                                 $found = true;
3429                                                 $isChildObj = true;
3430                                         }
3431                                 }
3432
3433                                 # If the title is valid but undisplayable, make a link to it
3434                                 if ( !$found && ( $this->ot['html'] || $this->ot['pre'] ) ) {
3435                                         $text = "[[:$titleText]]";
3436                                         $found = true;
3437                                 }
3438                         } elseif ( $title->isTrans() ) {
3439                                 # Interwiki transclusion
3440                                 if ( $this->ot['html'] && !$forceRawInterwiki ) {
3441                                         $text = $this->interwikiTransclude( $title, 'render' );
3442                                         $isHTML = true;
3443                                 } else {
3444                                         $text = $this->interwikiTransclude( $title, 'raw' );
3445                                         # Preprocess it like a template
3446                                         $text = $this->preprocessToDom( $text, self::PTD_FOR_INCLUSION );
3447                                         $isChildObj = true;
3448                                 }
3449                                 $found = true;
3450                         }
3451
3452                         # Do infinite loop check
3453                         # This has to be done after redirect resolution to avoid infinite loops via redirects
3454                         if ( !$frame->loopCheck( $title ) ) {
3455                                 $found = true;
3456                                 $text = '<span class="error">'
3457                                         . wfMessage( 'parser-template-loop-warning', $titleText )->inContentLanguage()->text()
3458                                         . '</span>';
3459                                 $this->addTrackingCategory( 'template-loop-category' );
3460                                 $this->mOutput->addWarning( wfMessage( 'template-loop-warning',
3461                                         wfEscapeWikiText( $titleText ) )->text() );
3462                                 $this->logger->debug( __METHOD__ . ": template loop broken at '$titleText'" );
3463                         }
3464                 }
3465
3466                 # If we haven't found text to substitute by now, we're done
3467                 # Recover the source wikitext and return it
3468                 if ( !$found ) {
3469                         $text = $frame->virtualBracketedImplode( '{{', '|', '}}', $titleWithSpaces, $args );
3470                         if ( $profileSection ) {
3471                                 $this->mProfiler->scopedProfileOut( $profileSection );
3472                         }
3473                         return [ 'object' => $text ];
3474                 }
3475
3476                 # Expand DOM-style return values in a child frame
3477                 if ( $isChildObj ) {
3478                         # Clean up argument array
3479                         $newFrame = $frame->newChild( $args, $title );
3480
3481                         if ( $nowiki ) {
3482                                 $text = $newFrame->expand( $text, PPFrame::RECOVER_ORIG );
3483                         } elseif ( $titleText !== false && $newFrame->isEmpty() ) {
3484                                 # Expansion is eligible for the empty-frame cache
3485                                 $text = $newFrame->cachedExpand( $titleText, $text );
3486                         } else {
3487                                 # Uncached expansion
3488                                 $text = $newFrame->expand( $text );
3489                         }
3490                 }
3491                 if ( $isLocalObj && $nowiki ) {
3492                         $text = $frame->expand( $text, PPFrame::RECOVER_ORIG );
3493                         $isLocalObj = false;
3494                 }
3495
3496                 if ( $profileSection ) {
3497                         $this->mProfiler->scopedProfileOut( $profileSection );
3498                 }
3499
3500                 # Replace raw HTML by a placeholder
3501                 if ( $isHTML ) {
3502                         $text = $this->insertStripItem( $text );
3503                 } elseif ( $nowiki && ( $this->ot['html'] || $this->ot['pre'] ) ) {
3504                         # Escape nowiki-style return values
3505                         $text = wfEscapeWikiText( $text );
3506                 } elseif ( is_string( $text )
3507                         && !$piece['lineStart']
3508                         && preg_match( '/^(?:{\\||:|;|#|\*)/', $text )
3509                 ) {
3510                         # T2529: if the template begins with a table or block-level
3511                         # element, it should be treated as beginning a new line.
3512                         # This behavior is somewhat controversial.
3513                         $text = "\n" . $text;
3514                 }
3515
3516                 if ( is_string( $text ) && !$this->incrementIncludeSize( 'post-expand', strlen( $text ) ) ) {
3517                         # Error, oversize inclusion
3518                         if ( $titleText !== false ) {
3519                                 # Make a working, properly escaped link if possible (T25588)
3520                                 $text = "[[:$titleText]]";
3521                         } else {
3522                                 # This will probably not be a working link, but at least it may
3523                                 # provide some hint of where the problem is
3524                                 preg_replace( '/^:/', '', $originalTitle );
3525                                 $text = "[[:$originalTitle]]";
3526                         }
3527                         $text .= $this->insertStripItem( '<!-- WARNING: template omitted, '
3528                                 . 'post-expand include size too large -->' );
3529                         $this->limitationWarn( 'post-expand-template-inclusion' );
3530                 }
3531
3532                 if ( $isLocalObj ) {
3533                         $ret = [ 'object' => $text ];
3534                 } else {
3535                         $ret = [ 'text' => $text ];
3536                 }
3537
3538                 return $ret;
3539         }
3540
3541         /**
3542          * Call a parser function and return an array with text and flags.
3543          *
3544          * The returned array will always contain a boolean 'found', indicating
3545          * whether the parser function was found or not. It may also contain the
3546          * following:
3547          *  text: string|object, resulting wikitext or PP DOM object
3548          *  isHTML: bool, $text is HTML, armour it against wikitext transformation
3549          *  isChildObj: bool, $text is a DOM node needing expansion in a child frame
3550          *  isLocalObj: bool, $text is a DOM node needing expansion in the current frame
3551          *  nowiki: bool, wiki markup in $text should be escaped
3552          *
3553          * @since 1.21
3554          * @param PPFrame $frame The current frame, contains template arguments
3555          * @param string $function Function name
3556          * @param array $args Arguments to the function
3557          * @throws MWException
3558          * @return array
3559          */
3560         public function callParserFunction( $frame, $function, array $args = [] ) {
3561                 # Case sensitive functions
3562                 if ( isset( $this->mFunctionSynonyms[1][$function] ) ) {
3563                         $function = $this->mFunctionSynonyms[1][$function];
3564                 } else {
3565                         # Case insensitive functions
3566                         $function = $this->contLang->lc( $function );
3567                         if ( isset( $this->mFunctionSynonyms[0][$function] ) ) {
3568                                 $function = $this->mFunctionSynonyms[0][$function];
3569                         } else {
3570                                 return [ 'found' => false ];
3571                         }
3572                 }
3573
3574                 list( $callback, $flags ) = $this->mFunctionHooks[$function];
3575
3576                 // Avoid PHP 7.1 warning from passing $this by reference
3577                 $parser = $this;
3578
3579                 $allArgs = [ &$parser ];
3580                 if ( $flags & self::SFH_OBJECT_ARGS ) {
3581                         # Convert arguments to PPNodes and collect for appending to $allArgs
3582                         $funcArgs = [];
3583                         foreach ( $args as $k => $v ) {
3584                                 if ( $v instanceof PPNode || $k === 0 ) {
3585                                         $funcArgs[] = $v;
3586                                 } else {
3587                                         $funcArgs[] = $this->mPreprocessor->newPartNodeArray( [ $k => $v ] )->item( 0 );
3588                                 }
3589                         }
3590
3591                         # Add a frame parameter, and pass the arguments as an array
3592                         $allArgs[] = $frame;
3593                         $allArgs[] = $funcArgs;
3594                 } else {
3595                         # Convert arguments to plain text and append to $allArgs
3596                         foreach ( $args as $k => $v ) {
3597                                 if ( $v instanceof PPNode ) {
3598                                         $allArgs[] = trim( $frame->expand( $v ) );
3599                                 } elseif ( is_int( $k ) && $k >= 0 ) {
3600                                         $allArgs[] = trim( $v );
3601                                 } else {
3602                                         $allArgs[] = trim( "$k=$v" );
3603                                 }
3604                         }
3605                 }
3606
3607                 $result = $callback( ...$allArgs );
3608
3609                 # The interface for function hooks allows them to return a wikitext
3610                 # string or an array containing the string and any flags. This mungs
3611                 # things around to match what this method should return.
3612                 if ( !is_array( $result ) ) {
3613                         $result = [
3614                                 'found' => true,
3615                                 'text' => $result,
3616                         ];
3617                 } else {
3618                         if ( isset( $result[0] ) && !isset( $result['text'] ) ) {
3619                                 $result['text'] = $result[0];
3620                         }
3621                         unset( $result[0] );
3622                         $result += [
3623                                 'found' => true,
3624                         ];
3625                 }
3626
3627                 $noparse = true;
3628                 $preprocessFlags = 0;
3629                 if ( isset( $result['noparse'] ) ) {
3630                         $noparse = $result['noparse'];
3631                 }
3632                 if ( isset( $result['preprocessFlags'] ) ) {
3633                         $preprocessFlags = $result['preprocessFlags'];
3634                 }
3635
3636                 if ( !$noparse ) {
3637                         $result['text'] = $this->preprocessToDom( $result['text'], $preprocessFlags );
3638                         $result['isChildObj'] = true;
3639                 }
3640
3641                 return $result;
3642         }
3643
3644         /**
3645          * Get the semi-parsed DOM representation of a template with a given title,
3646          * and its redirect destination title. Cached.
3647          *
3648          * @param Title $title
3649          *
3650          * @return array
3651          */
3652         public function getTemplateDom( $title ) {
3653                 $cacheTitle = $title;
3654                 $titleText = $title->getPrefixedDBkey();
3655
3656                 if ( isset( $this->mTplRedirCache[$titleText] ) ) {
3657                         list( $ns, $dbk ) = $this->mTplRedirCache[$titleText];
3658                         $title = Title::makeTitle( $ns, $dbk );
3659                         $titleText = $title->getPrefixedDBkey();
3660                 }
3661                 if ( isset( $this->mTplDomCache[$titleText] ) ) {
3662                         return [ $this->mTplDomCache[$titleText], $title ];
3663                 }
3664
3665                 # Cache miss, go to the database
3666                 list( $text, $title ) = $this->fetchTemplateAndTitle( $title );
3667
3668                 if ( $text === false ) {
3669                         $this->mTplDomCache[$titleText] = false;
3670                         return [ false, $title ];
3671                 }
3672
3673                 $dom = $this->preprocessToDom( $text, self::PTD_FOR_INCLUSION );
3674                 $this->mTplDomCache[$titleText] = $dom;
3675
3676                 if ( !$title->equals( $cacheTitle ) ) {
3677                         $this->mTplRedirCache[$cacheTitle->getPrefixedDBkey()] =
3678                                 [ $title->getNamespace(), $title->getDBkey() ];
3679                 }
3680
3681                 return [ $dom, $title ];
3682         }
3683
3684         /**
3685          * Fetch the current revision of a given title. Note that the revision
3686          * (and even the title) may not exist in the database, so everything
3687          * contributing to the output of the parser should use this method
3688          * where possible, rather than getting the revisions themselves. This
3689          * method also caches its results, so using it benefits performance.
3690          *
3691          * @since 1.24
3692          * @param Title $title
3693          * @return Revision
3694          */
3695         public function fetchCurrentRevisionOfTitle( $title ) {
3696                 $cacheKey = $title->getPrefixedDBkey();
3697                 if ( !$this->currentRevisionCache ) {
3698                         $this->currentRevisionCache = new MapCacheLRU( 100 );
3699                 }
3700                 if ( !$this->currentRevisionCache->has( $cacheKey ) ) {
3701                         $this->currentRevisionCache->set( $cacheKey,
3702                                 // Defaults to Parser::statelessFetchRevision()
3703                                 call_user_func( $this->mOptions->getCurrentRevisionCallback(), $title, $this )
3704                         );
3705                 }
3706                 return $this->currentRevisionCache->get( $cacheKey );
3707         }
3708
3709         /**
3710          * @param Title $title
3711          * @return bool
3712          * @since 1.34
3713          */
3714         public function isCurrentRevisionOfTitleCached( $title ) {
3715                 return (
3716                         $this->currentRevisionCache &&
3717                         $this->currentRevisionCache->has( $title->getPrefixedText() )
3718                 );
3719         }
3720
3721         /**
3722          * Wrapper around Revision::newFromTitle to allow passing additional parameters
3723          * without passing them on to it.
3724          *
3725          * @since 1.24
3726          * @param Title $title
3727          * @param Parser|bool $parser
3728          * @return Revision|bool False if missing
3729          */
3730         public static function statelessFetchRevision( Title $title, $parser = false ) {
3731                 $rev = Revision::newKnownCurrent( wfGetDB( DB_REPLICA ), $title );
3732
3733                 return $rev;
3734         }
3735
3736         /**
3737          * Fetch the unparsed text of a template and register a reference to it.
3738          * @param Title $title
3739          * @return array ( string or false, Title )
3740          */
3741         public function fetchTemplateAndTitle( $title ) {
3742                 // Defaults to Parser::statelessFetchTemplate()
3743                 $templateCb = $this->mOptions->getTemplateCallback();
3744                 $stuff = call_user_func( $templateCb, $title, $this );
3745                 // We use U+007F DELETE to distinguish strip markers from regular text.
3746                 $text = $stuff['text'];
3747                 if ( is_string( $stuff['text'] ) ) {
3748                         $text = strtr( $text, "\x7f", "?" );
3749                 }
3750                 $finalTitle = $stuff['finalTitle'] ?? $title;
3751                 if ( isset( $stuff['deps'] ) ) {
3752                         foreach ( $stuff['deps'] as $dep ) {
3753                                 $this->mOutput->addTemplate( $dep['title'], $dep['page_id'], $dep['rev_id'] );
3754                                 if ( $dep['title']->equals( $this->getTitle() ) ) {
3755                                         // Self-transclusion; final result may change based on the new page version
3756                                         $this->setOutputFlag( 'vary-revision', 'Self transclusion' );
3757                                 }
3758                         }
3759                 }
3760                 return [ $text, $finalTitle ];
3761         }
3762
3763         /**
3764          * Fetch the unparsed text of a template and register a reference to it.
3765          * @param Title $title
3766          * @return string|bool
3767          */
3768         public function fetchTemplate( $title ) {
3769                 return $this->fetchTemplateAndTitle( $title )[0];
3770         }
3771
3772         /**
3773          * Static function to get a template
3774          * Can be overridden via ParserOptions::setTemplateCallback().
3775          *
3776          * @param Title $title
3777          * @param bool|Parser $parser
3778          *
3779          * @return array
3780          */
3781         public static function statelessFetchTemplate( $title, $parser = false ) {
3782                 $text = $skip = false;
3783                 $finalTitle = $title;
3784                 $deps = [];
3785
3786                 # Loop to fetch the article, with up to 1 redirect
3787                 for ( $i = 0; $i < 2 && is_object( $title ); $i++ ) {
3788                         # Give extensions a chance to select the revision instead
3789                         $id = false; # Assume current
3790                         Hooks::run( 'BeforeParserFetchTemplateAndtitle',
3791                                 [ $parser, $title, &$skip, &$id ] );
3792
3793                         if ( $skip ) {
3794                                 $text = false;
3795                                 $deps[] = [
3796                                         'title' => $title,
3797                                         'page_id' => $title->getArticleID(),
3798                                         'rev_id' => null
3799                                 ];
3800                                 break;
3801                         }
3802                         # Get the revision
3803                         if ( $id ) {
3804                                 $rev = Revision::newFromId( $id );
3805                         } elseif ( $parser ) {
3806                                 $rev = $parser->fetchCurrentRevisionOfTitle( $title );
3807                         } else {
3808                                 $rev = Revision::newFromTitle( $title );
3809                         }
3810                         $rev_id = $rev ? $rev->getId() : 0;
3811                         # If there is no current revision, there is no page
3812                         if ( $id === false && !$rev ) {
3813                                 $linkCache = MediaWikiServices::getInstance()->getLinkCache();
3814                                 $linkCache->addBadLinkObj( $title );
3815                         }
3816
3817                         $deps[] = [
3818                                 'title' => $title,
3819                                 'page_id' => $title->getArticleID(),
3820                                 'rev_id' => $rev_id ];
3821                         if ( $rev && !$title->equals( $rev->getTitle() ) ) {
3822                                 # We fetched a rev from a different title; register it too...
3823                                 $deps[] = [
3824                                         'title' => $rev->getTitle(),
3825                                         'page_id' => $rev->getPage(),
3826                                         'rev_id' => $rev_id ];
3827                         }
3828
3829                         if ( $rev ) {
3830                                 $content = $rev->getContent();
3831                                 $text = $content ? $content->getWikitextForTransclusion() : null;
3832
3833                                 Hooks::run( 'ParserFetchTemplate',
3834                                         [ $parser, $title, $rev, &$text, &$deps ] );
3835
3836                                 if ( $text === false || $text === null ) {
3837                                         $text = false;
3838                                         break;
3839                                 }
3840                         } elseif ( $title->getNamespace() == NS_MEDIAWIKI ) {
3841                                 $message = wfMessage( MediaWikiServices::getInstance()->getContentLanguage()->
3842                                         lcfirst( $title->getText() ) )->inContentLanguage();
3843                                 if ( !$message->exists() ) {
3844                                         $text = false;
3845                                         break;
3846                                 }
3847                                 $content = $message->content();
3848                                 $text = $message->plain();
3849                         } else {
3850                                 break;
3851                         }
3852                         if ( !$content ) {
3853                                 break;
3854                         }
3855                         # Redirect?
3856                         $finalTitle = $title;
3857                         $title = $content->getRedirectTarget();
3858                 }
3859                 return [
3860                         'text' => $text,
3861                         'finalTitle' => $finalTitle,
3862                         'deps' => $deps ];
3863         }
3864
3865         /**
3866          * Fetch a file and its title and register a reference to it.
3867          * If 'broken' is a key in $options then the file will appear as a broken thumbnail.
3868          * @param Title $title
3869          * @param array $options Array of options to RepoGroup::findFile
3870          * @return array ( File or false, Title of file )
3871          */
3872         public function fetchFileAndTitle( $title, $options = [] ) {
3873                 $file = $this->fetchFileNoRegister( $title, $options );
3874
3875                 $time = $file ? $file->getTimestamp() : false;
3876                 $sha1 = $file ? $file->getSha1() : false;
3877                 # Register the file as a dependency...
3878                 $this->mOutput->addImage( $title->getDBkey(), $time, $sha1 );
3879                 if ( $file && !$title->equals( $file->getTitle() ) ) {
3880                         # Update fetched file title
3881                         $title = $file->getTitle();
3882                         $this->mOutput->addImage( $title->getDBkey(), $time, $sha1 );
3883                 }
3884                 return [ $file, $title ];
3885         }
3886
3887         /**
3888          * Helper function for fetchFileAndTitle.
3889          *
3890          * Also useful if you need to fetch a file but not use it yet,
3891          * for example to get the file's handler.
3892          *
3893          * @param Title $title
3894          * @param array $options Array of options to RepoGroup::findFile
3895          * @return File|bool
3896          */
3897         protected function fetchFileNoRegister( $title, $options = [] ) {
3898                 if ( isset( $options['broken'] ) ) {
3899                         $file = false; // broken thumbnail forced by hook
3900                 } elseif ( isset( $options['sha1'] ) ) { // get by (sha1,timestamp)
3901                         $file = RepoGroup::singleton()->findFileFromKey( $options['sha1'], $options );
3902                 } else { // get by (name,timestamp)
3903                         $file = MediaWikiServices::getInstance()->getRepoGroup()->findFile( $title, $options );
3904                 }
3905                 return $file;
3906         }
3907
3908         /**
3909          * Transclude an interwiki link.
3910          *
3911          * @param Title $title
3912          * @param string $action Usually one of (raw, render)
3913          *
3914          * @return string
3915          */
3916         public function interwikiTransclude( $title, $action ) {
3917                 if ( !$this->svcOptions->get( 'EnableScaryTranscluding' ) ) {
3918                         return wfMessage( 'scarytranscludedisabled' )->inContentLanguage()->text();
3919                 }
3920
3921                 $url = $title->getFullURL( [ 'action' => $action ] );
3922                 if ( strlen( $url ) > 1024 ) {
3923                         return wfMessage( 'scarytranscludetoolong' )->inContentLanguage()->text();
3924                 }
3925
3926                 $wikiId = $title->getTransWikiID(); // remote wiki ID or false
3927
3928                 $fname = __METHOD__;
3929                 $cache = MediaWikiServices::getInstance()->getMainWANObjectCache();
3930
3931                 $data = $cache->getWithSetCallback(
3932                         $cache->makeGlobalKey(
3933                                 'interwiki-transclude',
3934                                 ( $wikiId !== false ) ? $wikiId : 'external',
3935                                 sha1( $url )
3936                         ),
3937                         $this->svcOptions->get( 'TranscludeCacheExpiry' ),
3938                         function ( $oldValue, &$ttl ) use ( $url, $fname, $cache ) {
3939                                 $req = MWHttpRequest::factory( $url, [], $fname );
3940
3941                                 $status = $req->execute(); // Status object
3942                                 if ( !$status->isOK() ) {
3943                                         $ttl = $cache::TTL_UNCACHEABLE;
3944                                 } elseif ( $req->getResponseHeader( 'X-Database-Lagged' ) !== null ) {
3945                                         $ttl = min( $cache::TTL_LAGGED, $ttl );
3946                                 }
3947
3948                                 return [
3949                                         'text' => $status->isOK() ? $req->getContent() : null,
3950                                         'code' => $req->getStatus()
3951                                 ];
3952                         },
3953                         [
3954                                 'checkKeys' => ( $wikiId !== false )
3955                                         ? [ $cache->makeGlobalKey( 'interwiki-page', $wikiId, $title->getDBkey() ) ]
3956                                         : [],
3957                                 'pcGroup' => 'interwiki-transclude:5',
3958                                 'pcTTL' => $cache::TTL_PROC_LONG
3959                         ]
3960                 );
3961
3962                 if ( is_string( $data['text'] ) ) {
3963                         $text = $data['text'];
3964                 } elseif ( $data['code'] != 200 ) {
3965                         // Though we failed to fetch the content, this status is useless.
3966                         $text = wfMessage( 'scarytranscludefailed-httpstatus' )
3967                                 ->params( $url, $data['code'] )->inContentLanguage()->text();
3968                 } else {
3969                         $text = wfMessage( 'scarytranscludefailed', $url )->inContentLanguage()->text();
3970                 }
3971
3972                 return $text;
3973         }
3974
3975         /**
3976          * Triple brace replacement -- used for template arguments
3977          * @private
3978          *
3979          * @param array $piece
3980          * @param PPFrame $frame
3981          *
3982          * @return array
3983          */
3984         public function argSubstitution( $piece, $frame ) {
3985                 $error = false;
3986                 $parts = $piece['parts'];
3987                 $nameWithSpaces = $frame->expand( $piece['title'] );
3988                 $argName = trim( $nameWithSpaces );
3989                 $object = false;
3990                 $text = $frame->getArgument( $argName );
3991                 if ( $text === false && $parts->getLength() > 0
3992                         && ( $this->ot['html']
3993                                 || $this->ot['pre']
3994                                 || ( $this->ot['wiki'] && $frame->isTemplate() )
3995                         )
3996                 ) {
3997                         # No match in frame, use the supplied default
3998                         $object = $parts->item( 0 )->getChildren();
3999                 }
4000                 if ( !$this->incrementIncludeSize( 'arg', strlen( $text ) ) ) {
4001                         $error = '<!-- WARNING: argument omitted, expansion size too large -->';
4002                         $this->limitationWarn( 'post-expand-template-argument' );
4003                 }
4004
4005                 if ( $text === false && $object === false ) {
4006                         # No match anywhere
4007                         $object = $frame->virtualBracketedImplode( '{{{', '|', '}}}', $nameWithSpaces, $parts );
4008                 }
4009                 if ( $error !== false ) {
4010                         $text .= $error;
4011                 }
4012                 if ( $object !== false ) {
4013                         $ret = [ 'object' => $object ];
4014                 } else {
4015                         $ret = [ 'text' => $text ];
4016                 }
4017
4018                 return $ret;
4019         }
4020
4021         /**
4022          * Return the text to be used for a given extension tag.
4023          * This is the ghost of strip().
4024          *
4025          * @param array $params Associative array of parameters:
4026          *     name       PPNode for the tag name
4027          *     attr       PPNode for unparsed text where tag attributes are thought to be
4028          *     attributes Optional associative array of parsed attributes
4029          *     inner      Contents of extension element
4030          *     noClose    Original text did not have a close tag
4031          * @param PPFrame $frame
4032          *
4033          * @throws MWException
4034          * @return string
4035          */
4036         public function extensionSubstitution( $params, $frame ) {
4037                 static $errorStr = '<span class="error">';
4038                 static $errorLen = 20;
4039
4040                 $name = $frame->expand( $params['name'] );
4041                 if ( substr( $name, 0, $errorLen ) === $errorStr ) {
4042                         // Probably expansion depth or node count exceeded. Just punt the
4043                         // error up.
4044                         return $name;
4045                 }
4046
4047                 $attrText = !isset( $params['attr'] ) ? null : $frame->expand( $params['attr'] );
4048                 if ( substr( $attrText, 0, $errorLen ) === $errorStr ) {
4049                         // See above
4050                         return $attrText;
4051                 }
4052
4053                 // We can't safely check if the expansion for $content resulted in an
4054                 // error, because the content could happen to be the error string
4055                 // (T149622).
4056                 $content = !isset( $params['inner'] ) ? null : $frame->expand( $params['inner'] );
4057
4058                 $marker = self::MARKER_PREFIX . "-$name-"
4059                         . sprintf( '%08X', $this->mMarkerIndex++ ) . self::MARKER_SUFFIX;
4060
4061                 $isFunctionTag = isset( $this->mFunctionTagHooks[strtolower( $name )] ) &&
4062                         ( $this->ot['html'] || $this->ot['pre'] );
4063                 if ( $isFunctionTag ) {
4064                         $markerType = 'none';
4065                 } else {
4066                         $markerType = 'general';
4067                 }
4068                 if ( $this->ot['html'] || $isFunctionTag ) {
4069                         $name = strtolower( $name );
4070                         $attributes = Sanitizer::decodeTagAttributes( $attrText );
4071                         if ( isset( $params['attributes'] ) ) {
4072                                 $attributes += $params['attributes'];
4073                         }
4074
4075                         if ( isset( $this->mTagHooks[$name] ) ) {
4076                                 $output = call_user_func_array( $this->mTagHooks[$name],
4077                                         [ $content, $attributes, $this, $frame ] );
4078                         } elseif ( isset( $this->mFunctionTagHooks[$name] ) ) {
4079                                 list( $callback, ) = $this->mFunctionTagHooks[$name];
4080
4081                                 // Avoid PHP 7.1 warning from passing $this by reference
4082                                 $parser = $this;
4083                                 $output = call_user_func_array( $callback, [ &$parser, $frame, $content, $attributes ] );
4084                         } else {
4085                                 $output = '<span class="error">Invalid tag extension name: ' .
4086                                         htmlspecialchars( $name ) . '</span>';
4087                         }
4088
4089                         if ( is_array( $output ) ) {
4090                                 // Extract flags
4091                                 $flags = $output;
4092                                 $output = $flags[0];
4093                                 if ( isset( $flags['markerType'] ) ) {
4094                                         $markerType = $flags['markerType'];
4095                                 }
4096                         }
4097                 } else {
4098                         if ( is_null( $attrText ) ) {
4099                                 $attrText = '';
4100                         }
4101                         if ( isset( $params['attributes'] ) ) {
4102                                 foreach ( $params['attributes'] as $attrName => $attrValue ) {
4103                                         $attrText .= ' ' . htmlspecialchars( $attrName ) . '="' .
4104                                                 htmlspecialchars( $attrValue ) . '"';
4105                                 }
4106                         }
4107                         if ( $content === null ) {
4108                                 $output = "<$name$attrText/>";
4109                         } else {
4110                                 $close = is_null( $params['close'] ) ? '' : $frame->expand( $params['close'] );
4111                                 if ( substr( $close, 0, $errorLen ) === $errorStr ) {
4112                                         // See above
4113                                         return $close;
4114                                 }
4115                                 $output = "<$name$attrText>$content$close";
4116                         }
4117                 }
4118
4119                 if ( $markerType === 'none' ) {
4120                         return $output;
4121                 } elseif ( $markerType === 'nowiki' ) {
4122                         $this->mStripState->addNoWiki( $marker, $output );
4123                 } elseif ( $markerType === 'general' ) {
4124                         $this->mStripState->addGeneral( $marker, $output );
4125                 } else {
4126                         throw new MWException( __METHOD__ . ': invalid marker type' );
4127                 }
4128                 return $marker;
4129         }
4130
4131         /**
4132          * Increment an include size counter
4133          *
4134          * @param string $type The type of expansion
4135          * @param int $size The size of the text
4136          * @return bool False if this inclusion would take it over the maximum, true otherwise
4137          */
4138         public function incrementIncludeSize( $type, $size ) {
4139                 if ( $this->mIncludeSizes[$type] + $size > $this->mOptions->getMaxIncludeSize() ) {
4140                         return false;
4141                 } else {
4142                         $this->mIncludeSizes[$type] += $size;
4143                         return true;
4144                 }
4145         }
4146
4147         /**
4148          * Increment the expensive function count
4149          *
4150          * @return bool False if the limit has been exceeded
4151          */
4152         public function incrementExpensiveFunctionCount() {
4153                 $this->mExpensiveFunctionCount++;
4154                 return $this->mExpensiveFunctionCount <= $this->mOptions->getExpensiveParserFunctionLimit();
4155         }
4156
4157         /**
4158          * Strip double-underscore items like __NOGALLERY__ and __NOTOC__
4159          * Fills $this->mDoubleUnderscores, returns the modified text
4160          *
4161          * @param string $text
4162          *
4163          * @return string
4164          */
4165         public function doDoubleUnderscore( $text ) {
4166                 # The position of __TOC__ needs to be recorded
4167                 $mw = $this->magicWordFactory->get( 'toc' );
4168                 if ( $mw->match( $text ) ) {
4169                         $this->mShowToc = true;
4170                         $this->mForceTocPosition = true;
4171
4172                         # Set a placeholder. At the end we'll fill it in with the TOC.
4173                         $text = $mw->replace( '<!--MWTOC\'"-->', $text, 1 );
4174
4175                         # Only keep the first one.
4176                         $text = $mw->replace( '', $text );
4177                 }
4178
4179                 # Now match and remove the rest of them
4180                 $mwa = $this->magicWordFactory->getDoubleUnderscoreArray();
4181                 $this->mDoubleUnderscores = $mwa->matchAndRemove( $text );
4182
4183                 if ( isset( $this->mDoubleUnderscores['nogallery'] ) ) {
4184                         $this->mOutput->mNoGallery = true;
4185                 }
4186                 if ( isset( $this->mDoubleUnderscores['notoc'] ) && !$this->mForceTocPosition ) {
4187                         $this->mShowToc = false;
4188                 }
4189                 if ( isset( $this->mDoubleUnderscores['hiddencat'] )
4190                         && $this->mTitle->getNamespace() == NS_CATEGORY
4191                 ) {
4192                         $this->addTrackingCategory( 'hidden-category-category' );
4193                 }
4194                 # (T10068) Allow control over whether robots index a page.
4195                 # __INDEX__ always overrides __NOINDEX__, see T16899
4196                 if ( isset( $this->mDoubleUnderscores['noindex'] ) && $this->mTitle->canUseNoindex() ) {
4197                         $this->mOutput->setIndexPolicy( 'noindex' );
4198                         $this->addTrackingCategory( 'noindex-category' );
4199                 }
4200                 if ( isset( $this->mDoubleUnderscores['index'] ) && $this->mTitle->canUseNoindex() ) {
4201                         $this->mOutput->setIndexPolicy( 'index' );
4202                         $this->addTrackingCategory( 'index-category' );
4203                 }
4204
4205                 # Cache all double underscores in the database
4206                 foreach ( $this->mDoubleUnderscores as $key => $val ) {
4207                         $this->mOutput->setProperty( $key, '' );
4208                 }
4209
4210                 return $text;
4211         }
4212
4213         /**
4214          * @see ParserOutput::addTrackingCategory()
4215          * @param string $msg Message key
4216          * @return bool Whether the addition was successful
4217          */
4218         public function addTrackingCategory( $msg ) {
4219                 return $this->mOutput->addTrackingCategory( $msg, $this->mTitle );
4220         }
4221
4222         /**
4223          * This function accomplishes several tasks:
4224          * 1) Auto-number headings if that option is enabled
4225          * 2) Add an [edit] link to sections for users who have enabled the option and can edit the page
4226          * 3) Add a Table of contents on the top for users who have enabled the option
4227          * 4) Auto-anchor headings
4228          *
4229          * It loops through all headlines, collects the necessary data, then splits up the
4230          * string and re-inserts the newly formatted headlines.
4231          *
4232          * @param string $text
4233          * @param string $origText Original, untouched wikitext
4234          * @param bool $isMain
4235          * @return mixed|string
4236          * @private
4237          */
4238         public function formatHeadings( $text, $origText, $isMain = true ) {
4239                 # Inhibit editsection links if requested in the page
4240                 if ( isset( $this->mDoubleUnderscores['noeditsection'] ) ) {
4241                         $maybeShowEditLink = false;
4242                 } else {
4243                         $maybeShowEditLink = true; /* Actual presence will depend on post-cache transforms */
4244                 }
4245
4246                 # Get all headlines for numbering them and adding funky stuff like [edit]
4247                 # links - this is for later, but we need the number of headlines right now
4248                 # NOTE: white space in headings have been trimmed in doHeadings. They shouldn't
4249                 # be trimmed here since whitespace in HTML headings is significant.
4250                 $matches = [];
4251                 $numMatches = preg_match_all(
4252                         '/<H(?P<level>[1-6])(?P<attrib>.*?>)(?P<header>[\s\S]*?)<\/H[1-6] *>/i',
4253                         $text,
4254                         $matches
4255                 );
4256
4257                 # if there are fewer than 4 headlines in the article, do not show TOC
4258                 # unless it's been explicitly enabled.
4259                 $enoughToc = $this->mShowToc &&
4260                         ( ( $numMatches >= 4 ) || $this->mForceTocPosition );
4261
4262                 # Allow user to stipulate that a page should have a "new section"
4263                 # link added via __NEWSECTIONLINK__
4264                 if ( isset( $this->mDoubleUnderscores['newsectionlink'] ) ) {
4265                         $this->mOutput->setNewSection( true );
4266                 }
4267
4268                 # Allow user to remove the "new section"
4269                 # link via __NONEWSECTIONLINK__
4270                 if ( isset( $this->mDoubleUnderscores['nonewsectionlink'] ) ) {
4271                         $this->mOutput->hideNewSection( true );
4272                 }
4273
4274                 # if the string __FORCETOC__ (not case-sensitive) occurs in the HTML,
4275                 # override above conditions and always show TOC above first header
4276                 if ( isset( $this->mDoubleUnderscores['forcetoc'] ) ) {
4277                         $this->mShowToc = true;
4278                         $enoughToc = true;
4279                 }
4280
4281                 # headline counter
4282                 $headlineCount = 0;
4283                 $numVisible = 0;
4284
4285                 # Ugh .. the TOC should have neat indentation levels which can be
4286                 # passed to the skin functions. These are determined here
4287                 $toc = '';
4288                 $full = '';
4289                 $head = [];
4290                 $sublevelCount = [];
4291                 $levelCount = [];
4292                 $level = 0;
4293                 $prevlevel = 0;
4294                 $toclevel = 0;
4295                 $prevtoclevel = 0;
4296                 $markerRegex = self::MARKER_PREFIX . "-h-(\d+)-" . self::MARKER_SUFFIX;
4297                 $baseTitleText = $this->mTitle->getPrefixedDBkey();
4298                 $oldType = $this->mOutputType;
4299                 $this->setOutputType( self::OT_WIKI );
4300                 $frame = $this->getPreprocessor()->newFrame();
4301                 $root = $this->preprocessToDom( $origText );
4302                 $node = $root->getFirstChild();
4303                 $byteOffset = 0;
4304                 $tocraw = [];
4305                 $refers = [];
4306
4307                 $headlines = $numMatches !== false ? $matches[3] : [];
4308
4309                 $maxTocLevel = $this->svcOptions->get( 'MaxTocLevel' );
4310                 foreach ( $headlines as $headline ) {
4311                         $isTemplate = false;
4312                         $titleText = false;
4313                         $sectionIndex = false;
4314                         $numbering = '';
4315                         $markerMatches = [];
4316                         if ( preg_match( "/^$markerRegex/", $headline, $markerMatches ) ) {
4317                                 $serial = $markerMatches[1];
4318                                 list( $titleText, $sectionIndex ) = $this->mHeadings[$serial];
4319                                 $isTemplate = ( $titleText != $baseTitleText );
4320                                 $headline = preg_replace( "/^$markerRegex\\s*/", "", $headline );
4321                         }
4322
4323                         if ( $toclevel ) {
4324                                 $prevlevel = $level;
4325                         }
4326                         $level = $matches[1][$headlineCount];
4327
4328                         if ( $level > $prevlevel ) {
4329                                 # Increase TOC level
4330                                 $toclevel++;
4331                                 $sublevelCount[$toclevel] = 0;
4332                                 if ( $toclevel < $maxTocLevel ) {
4333                                         $prevtoclevel = $toclevel;
4334                                         $toc .= Linker::tocIndent();
4335                                         $numVisible++;
4336                                 }
4337                         } elseif ( $level < $prevlevel && $toclevel > 1 ) {
4338                                 # Decrease TOC level, find level to jump to
4339
4340                                 for ( $i = $toclevel; $i > 0; $i-- ) {
4341                                         if ( $levelCount[$i] == $level ) {
4342                                                 # Found last matching level
4343                                                 $toclevel = $i;
4344                                                 break;
4345                                         } elseif ( $levelCount[$i] < $level ) {
4346                                                 # Found first matching level below current level
4347                                                 $toclevel = $i + 1;
4348                                                 break;
4349                                         }
4350                                 }
4351                                 if ( $i == 0 ) {
4352                                         $toclevel = 1;
4353                                 }
4354                                 if ( $toclevel < $maxTocLevel ) {
4355                                         if ( $prevtoclevel < $maxTocLevel ) {
4356                                                 # Unindent only if the previous toc level was shown :p
4357                                                 $toc .= Linker::tocUnindent( $prevtoclevel - $toclevel );
4358                                                 $prevtoclevel = $toclevel;
4359                                         } else {
4360                                                 $toc .= Linker::tocLineEnd();
4361                                         }
4362                                 }
4363                         } else {
4364                                 # No change in level, end TOC line
4365                                 if ( $toclevel < $maxTocLevel ) {
4366                                         $toc .= Linker::tocLineEnd();
4367                                 }
4368                         }
4369
4370                         $levelCount[$toclevel] = $level;
4371
4372                         # count number of headlines for each level
4373                         $sublevelCount[$toclevel]++;
4374                         $dot = 0;
4375                         for ( $i = 1; $i <= $toclevel; $i++ ) {
4376                                 if ( !empty( $sublevelCount[$i] ) ) {
4377                                         if ( $dot ) {
4378                                                 $numbering .= '.';
4379                                         }
4380                                         $numbering .= $this->getTargetLanguage()->formatNum( $sublevelCount[$i] );
4381                                         $dot = 1;
4382                                 }
4383                         }
4384
4385                         # The safe header is a version of the header text safe to use for links
4386
4387                         # Remove link placeholders by the link text.
4388                         #     <!--LINK number-->
4389                         # turns into
4390                         #     link text with suffix
4391                         # Do this before unstrip since link text can contain strip markers
4392                         $safeHeadline = $this->replaceLinkHoldersText( $headline );
4393
4394                         # Avoid insertion of weird stuff like <math> by expanding the relevant sections
4395                         $safeHeadline = $this->mStripState->unstripBoth( $safeHeadline );
4396
4397                         # Remove any <style> or <script> tags (T198618)
4398                         $safeHeadline = preg_replace(
4399                                 '#<(style|script)(?: [^>]*[^>/])?>.*?</\1>#is',
4400                                 '',
4401                                 $safeHeadline
4402                         );
4403
4404                         # Strip out HTML (first regex removes any tag not allowed)
4405                         # Allowed tags are:
4406                         # * <sup> and <sub> (T10393)
4407                         # * <i> (T28375)
4408                         # * <b> (r105284)
4409                         # * <bdi> (T74884)
4410                         # * <span dir="rtl"> and <span dir="ltr"> (T37167)
4411                         # * <s> and <strike> (T35715)
4412                         # We strip any parameter from accepted tags (second regex), except dir="rtl|ltr" from <span>,
4413                         # to allow setting directionality in toc items.
4414                         $tocline = preg_replace(
4415                                 [
4416                                         '#<(?!/?(span|sup|sub|bdi|i|b|s|strike)(?: [^>]*)?>).*?>#',
4417                                         '#<(/?(?:span(?: dir="(?:rtl|ltr)")?|sup|sub|bdi|i|b|s|strike))(?: .*?)?>#'
4418                                 ],
4419                                 [ '', '<$1>' ],
4420                                 $safeHeadline
4421                         );
4422
4423                         # Strip '<span></span>', which is the result from the above if
4424                         # <span id="foo"></span> is used to produce an additional anchor
4425                         # for a section.
4426                         $tocline = str_replace( '<span></span>', '', $tocline );
4427
4428                         $tocline = trim( $tocline );
4429
4430                         # For the anchor, strip out HTML-y stuff period
4431                         $safeHeadline = preg_replace( '/<.*?>/', '', $safeHeadline );
4432                         $safeHeadline = Sanitizer::normalizeSectionNameWhitespace( $safeHeadline );
4433
4434                         # Save headline for section edit hint before it's escaped
4435                         $headlineHint = $safeHeadline;
4436
4437                         # Decode HTML entities
4438                         $safeHeadline = Sanitizer::decodeCharReferences( $safeHeadline );
4439
4440                         $safeHeadline = self::normalizeSectionName( $safeHeadline );
4441
4442                         $fallbackHeadline = Sanitizer::escapeIdForAttribute( $safeHeadline, Sanitizer::ID_FALLBACK );
4443                         $linkAnchor = Sanitizer::escapeIdForLink( $safeHeadline );
4444                         $safeHeadline = Sanitizer::escapeIdForAttribute( $safeHeadline, Sanitizer::ID_PRIMARY );
4445                         if ( $fallbackHeadline === $safeHeadline ) {
4446                                 # No reason to have both (in fact, we can't)
4447                                 $fallbackHeadline = false;
4448                         }
4449
4450                         # HTML IDs must be case-insensitively unique for IE compatibility (T12721).
4451                         # @todo FIXME: We may be changing them depending on the current locale.
4452                         $arrayKey = strtolower( $safeHeadline );
4453                         if ( $fallbackHeadline === false ) {
4454                                 $fallbackArrayKey = false;
4455                         } else {
4456                                 $fallbackArrayKey = strtolower( $fallbackHeadline );
4457                         }
4458
4459                         # Create the anchor for linking from the TOC to the section
4460                         $anchor = $safeHeadline;
4461                         $fallbackAnchor = $fallbackHeadline;
4462                         if ( isset( $refers[$arrayKey] ) ) {
4463                                 // phpcs:ignore Generic.Formatting.DisallowMultipleStatements
4464                                 for ( $i = 2; isset( $refers["${arrayKey}_$i"] ); ++$i );
4465                                 $anchor .= "_$i";
4466                                 $linkAnchor .= "_$i";
4467                                 $refers["${arrayKey}_$i"] = true;
4468                         } else {
4469                                 $refers[$arrayKey] = true;
4470                         }
4471                         if ( $fallbackHeadline !== false && isset( $refers[$fallbackArrayKey] ) ) {
4472                                 // phpcs:ignore Generic.Formatting.DisallowMultipleStatements
4473                                 for ( $i = 2; isset( $refers["${fallbackArrayKey}_$i"] ); ++$i );
4474                                 $fallbackAnchor .= "_$i";
4475                                 $refers["${fallbackArrayKey}_$i"] = true;
4476                         } else {
4477                                 $refers[$fallbackArrayKey] = true;
4478                         }
4479
4480                         # Don't number the heading if it is the only one (looks silly)
4481                         if ( count( $matches[3] ) > 1 && $this->mOptions->getNumberHeadings() ) {
4482                                 # the two are different if the line contains a link
4483                                 $headline = Html::element(
4484                                         'span',
4485                                         [ 'class' => 'mw-headline-number' ],
4486                                         $numbering
4487                                 ) . ' ' . $headline;
4488                         }
4489
4490                         if ( $enoughToc && ( !isset( $maxTocLevel ) || $toclevel < $maxTocLevel ) ) {
4491                                 $toc .= Linker::tocLine( $linkAnchor, $tocline,
4492                                         $numbering, $toclevel, ( $isTemplate ? false : $sectionIndex ) );
4493                         }
4494
4495                         # Add the section to the section tree
4496                         # Find the DOM node for this header
4497                         $noOffset = ( $isTemplate || $sectionIndex === false );
4498                         while ( $node && !$noOffset ) {
4499                                 if ( $node->getName() === 'h' ) {
4500                                         $bits = $node->splitHeading();
4501                                         if ( $bits['i'] == $sectionIndex ) {
4502                                                 break;
4503                                         }
4504                                 }
4505                                 $byteOffset += mb_strlen( $this->mStripState->unstripBoth(
4506                                         $frame->expand( $node, PPFrame::RECOVER_ORIG ) ) );
4507                                 $node = $node->getNextSibling();
4508                         }
4509                         $tocraw[] = [
4510                                 'toclevel' => $toclevel,
4511                                 'level' => $level,
4512                                 'line' => $tocline,
4513                                 'number' => $numbering,
4514                                 'index' => ( $isTemplate ? 'T-' : '' ) . $sectionIndex,
4515                                 'fromtitle' => $titleText,
4516                                 'byteoffset' => ( $noOffset ? null : $byteOffset ),
4517                                 'anchor' => $anchor,
4518                         ];
4519
4520                         # give headline the correct <h#> tag
4521                         if ( $maybeShowEditLink && $sectionIndex !== false ) {
4522                                 // Output edit section links as markers with styles that can be customized by skins
4523                                 if ( $isTemplate ) {
4524                                         # Put a T flag in the section identifier, to indicate to extractSections()
4525                                         # that sections inside <includeonly> should be counted.
4526                                         $editsectionPage = $titleText;
4527                                         $editsectionSection = "T-$sectionIndex";
4528                                         $editsectionContent = null;
4529                                 } else {
4530                                         $editsectionPage = $this->mTitle->getPrefixedText();
4531                                         $editsectionSection = $sectionIndex;
4532                                         $editsectionContent = $headlineHint;
4533                                 }
4534                                 // We use a bit of pesudo-xml for editsection markers. The
4535                                 // language converter is run later on. Using a UNIQ style marker
4536                                 // leads to the converter screwing up the tokens when it
4537                                 // converts stuff. And trying to insert strip tags fails too. At
4538                                 // this point all real inputted tags have already been escaped,
4539                                 // so we don't have to worry about a user trying to input one of
4540                                 // these markers directly. We use a page and section attribute
4541                                 // to stop the language converter from converting these
4542                                 // important bits of data, but put the headline hint inside a
4543                                 // content block because the language converter is supposed to
4544                                 // be able to convert that piece of data.
4545                                 // Gets replaced with html in ParserOutput::getText
4546                                 $editlink = '<mw:editsection page="' . htmlspecialchars( $editsectionPage );
4547                                 $editlink .= '" section="' . htmlspecialchars( $editsectionSection ) . '"';
4548                                 if ( $editsectionContent !== null ) {
4549                                         $editlink .= '>' . $editsectionContent . '</mw:editsection>';
4550                                 } else {
4551                                         $editlink .= '/>';
4552                                 }
4553                         } else {
4554                                 $editlink = '';
4555                         }
4556                         $head[$headlineCount] = Linker::makeHeadline( $level,
4557                                 $matches['attrib'][$headlineCount], $anchor, $headline,
4558                                 $editlink, $fallbackAnchor );
4559
4560                         $headlineCount++;
4561                 }
4562
4563                 $this->setOutputType( $oldType );
4564
4565                 # Never ever show TOC if no headers
4566                 if ( $numVisible < 1 ) {
4567                         $enoughToc = false;
4568                 }
4569
4570                 if ( $enoughToc ) {
4571                         if ( $prevtoclevel > 0 && $prevtoclevel < $maxTocLevel ) {
4572                                 $toc .= Linker::tocUnindent( $prevtoclevel - 1 );
4573                         }
4574                         $toc = Linker::tocList( $toc, $this->mOptions->getUserLangObj() );
4575                         $this->mOutput->setTOCHTML( $toc );
4576                         $toc = self::TOC_START . $toc . self::TOC_END;
4577                 }
4578
4579                 if ( $isMain ) {
4580                         $this->mOutput->setSections( $tocraw );
4581                 }
4582
4583                 # split up and insert constructed headlines
4584                 $blocks = preg_split( '/<H[1-6].*?>[\s\S]*?<\/H[1-6]>/i', $text );
4585                 $i = 0;
4586
4587                 // build an array of document sections
4588                 $sections = [];
4589                 foreach ( $blocks as $block ) {
4590                         // $head is zero-based, sections aren't.
4591                         if ( empty( $head[$i - 1] ) ) {
4592                                 $sections[$i] = $block;
4593                         } else {
4594                                 $sections[$i] = $head[$i - 1] . $block;
4595                         }
4596
4597                         /**
4598                          * Send a hook, one per section.
4599                          * The idea here is to be able to make section-level DIVs, but to do so in a
4600                          * lower-impact, more correct way than r50769
4601                          *
4602                          * $this : caller
4603                          * $section : the section number
4604                          * &$sectionContent : ref to the content of the section
4605                          * $maybeShowEditLinks : boolean describing whether this section has an edit link
4606                          */
4607                         Hooks::run( 'ParserSectionCreate', [ $this, $i, &$sections[$i], $maybeShowEditLink ] );
4608
4609                         $i++;
4610                 }
4611
4612                 if ( $enoughToc && $isMain && !$this->mForceTocPosition ) {
4613                         // append the TOC at the beginning
4614                         // Top anchor now in skin
4615                         $sections[0] .= $toc . "\n";
4616                 }
4617
4618                 $full .= implode( '', $sections );
4619
4620                 if ( $this->mForceTocPosition ) {
4621                         return str_replace( '<!--MWTOC\'"-->', $toc, $full );
4622                 } else {
4623                         return $full;
4624                 }
4625         }
4626
4627         /**
4628          * Transform wiki markup when saving a page by doing "\r\n" -> "\n"
4629          * conversion, substituting signatures, {{subst:}} templates, etc.
4630          *
4631          * @param string $text The text to transform
4632          * @param Title $title The Title object for the current article
4633          * @param User $user The User object describing the current user
4634          * @param ParserOptions $options Parsing options
4635          * @param bool $clearState Whether to clear the parser state first
4636          * @return string The altered wiki markup
4637          */
4638         public function preSaveTransform( $text, Title $title, User $user,
4639                 ParserOptions $options, $clearState = true
4640         ) {
4641                 if ( $clearState ) {
4642                         $magicScopeVariable = $this->lock();
4643                 }
4644                 $this->startParse( $title, $options, self::OT_WIKI, $clearState );
4645                 $this->setUser( $user );
4646
4647                 // Strip U+0000 NULL (T159174)
4648                 $text = str_replace( "\000", '', $text );
4649
4650                 // We still normalize line endings for backwards-compatibility
4651                 // with other code that just calls PST, but this should already
4652                 // be handled in TextContent subclasses
4653                 $text = TextContent::normalizeLineEndings( $text );
4654
4655                 if ( $options->getPreSaveTransform() ) {
4656                         $text = $this->pstPass2( $text, $user );
4657                 }
4658                 $text = $this->mStripState->unstripBoth( $text );
4659
4660                 $this->setUser( null ); # Reset
4661
4662                 return $text;
4663         }
4664
4665         /**
4666          * Pre-save transform helper function
4667          *
4668          * @param string $text
4669          * @param User $user
4670          *
4671          * @return string
4672          */
4673         private function pstPass2( $text, $user ) {
4674                 # Note: This is the timestamp saved as hardcoded wikitext to the database, we use
4675                 # $this->contLang here in order to give everyone the same signature and use the default one
4676                 # rather than the one selected in each user's preferences.  (see also T14815)
4677                 $ts = $this->mOptions->getTimestamp();
4678                 $timestamp = MWTimestamp::getLocalInstance( $ts );
4679                 $ts = $timestamp->format( 'YmdHis' );
4680                 $tzMsg = $timestamp->getTimezoneMessage()->inContentLanguage()->text();
4681
4682                 $d = $this->contLang->timeanddate( $ts, false, false ) . " ($tzMsg)";
4683
4684                 # Variable replacement
4685                 # Because mOutputType is OT_WIKI, this will only process {{subst:xxx}} type tags
4686                 $text = $this->replaceVariables( $text );
4687
4688                 # This works almost by chance, as the replaceVariables are done before the getUserSig(),
4689                 # which may corrupt this parser instance via its wfMessage()->text() call-
4690
4691                 # Signatures
4692                 if ( strpos( $text, '~~~' ) !== false ) {
4693                         $sigText = $this->getUserSig( $user );
4694                         $text = strtr( $text, [
4695                                 '~~~~~' => $d,
4696                                 '~~~~' => "$sigText $d",
4697                                 '~~~' => $sigText
4698                         ] );
4699                         # The main two signature forms used above are time-sensitive
4700                         $this->setOutputFlag( 'user-signature', 'User signature detected' );
4701                 }
4702
4703                 # Context links ("pipe tricks"): [[|name]] and [[name (context)|]]
4704                 $tc = '[' . Title::legalChars() . ']';
4705                 $nc = '[ _0-9A-Za-z\x80-\xff-]'; # Namespaces can use non-ascii!
4706
4707                 // [[ns:page (context)|]]
4708                 $p1 = "/\[\[(:?$nc+:|:|)($tc+?)( ?\\($tc+\\))\\|]]/";
4709                 // [[ns:page（context）|]] (double-width brackets, added in r40257)
4710                 $p4 = "/\[\[(:?$nc+:|:|)($tc+?)( ?（$tc+）)\\|]]/";
4711                 // [[ns:page (context), context|]] (using either single or double-width comma)
4712                 $p3 = "/\[\[(:?$nc+:|:|)($tc+?)( ?\\($tc+\\)|)((?:, |，)$tc+|)\\|]]/";
4713                 // [[|page]] (reverse pipe trick: add context from page title)
4714                 $p2 = "/\[\[\\|($tc+)]]/";
4715
4716                 # try $p1 first, to turn "[[A, B (C)|]]" into "[[A, B (C)|A, B]]"
4717                 $text = preg_replace( $p1, '[[\\1\\2\\3|\\2]]', $text );
4718                 $text = preg_replace( $p4, '[[\\1\\2\\3|\\2]]', $text );
4719                 $text = preg_replace( $p3, '[[\\1\\2\\3\\4|\\2]]', $text );
4720
4721                 $t = $this->mTitle->getText();
4722                 $m = [];
4723                 if ( preg_match( "/^($nc+:|)$tc+?( \\($tc+\\))$/", $t, $m ) ) {
4724                         $text = preg_replace( $p2, "[[$m[1]\\1$m[2]|\\1]]", $text );
4725                 } elseif ( preg_match( "/^($nc+:|)$tc+?(, $tc+|)$/", $t, $m ) && "$m[1]$m[2]" != '' ) {
4726                         $text = preg_replace( $p2, "[[$m[1]\\1$m[2]|\\1]]", $text );
4727                 } else {
4728                         # if there's no context, don't bother duplicating the title
4729                         $text = preg_replace( $p2, '[[\\1]]', $text );
4730                 }
4731
4732                 return $text;
4733         }
4734
4735         /**
4736          * Fetch the user's signature text, if any, and normalize to
4737          * validated, ready-to-insert wikitext.
4738          * If you have pre-fetched the nickname or the fancySig option, you can
4739          * specify them here to save a database query.
4740          * Do not reuse this parser instance after calling getUserSig(),
4741          * as it may have changed.
4742          *
4743          * @param User &$user
4744          * @param string|bool $nickname Nickname to use or false to use user's default nickname
4745          * @param bool|null $fancySig whether the nicknname is the complete signature
4746          *    or null to use default value
4747          * @return string
4748          */
4749         public function getUserSig( &$user, $nickname = false, $fancySig = null ) {
4750                 $username = $user->getName();
4751
4752                 # If not given, retrieve from the user object.
4753                 if ( $nickname === false ) {
4754                         $nickname = $user->getOption( 'nickname' );
4755                 }
4756
4757                 if ( is_null( $fancySig ) ) {
4758                         $fancySig = $user->getBoolOption( 'fancysig' );
4759                 }
4760
4761                 $nickname = $nickname == null ? $username : $nickname;
4762
4763                 if ( mb_strlen( $nickname ) > $this->svcOptions->get( 'MaxSigChars' ) ) {
4764                         $nickname = $username;
4765                         $this->logger->debug( __METHOD__ . ": $username has overlong signature." );
4766                 } elseif ( $fancySig !== false ) {
4767                         # Sig. might contain markup; validate this
4768                         if ( $this->validateSig( $nickname ) !== false ) {
4769                                 # Validated; clean up (if needed) and return it
4770                                 return $this->cleanSig( $nickname, true );
4771                         } else {
4772                                 # Failed to validate; fall back to the default
4773                                 $nickname = $username;
4774                                 $this->logger->debug( __METHOD__ . ": $username has bad XML tags in signature." );
4775                         }
4776                 }
4777
4778                 # Make sure nickname doesnt get a sig in a sig
4779                 $nickname = self::cleanSigInSig( $nickname );
4780
4781                 # If we're still here, make it a link to the user page
4782                 $userText = wfEscapeWikiText( $username );
4783                 $nickText = wfEscapeWikiText( $nickname );
4784                 $msgName = $user->isAnon() ? 'signature-anon' : 'signature';
4785
4786                 return wfMessage( $msgName, $userText, $nickText )->inContentLanguage()
4787                         ->title( $this->getTitle() )->text();
4788         }
4789
4790         /**
4791          * Check that the user's signature contains no bad XML
4792          *
4793          * @param string $text
4794          * @return string|bool An expanded string, or false if invalid.
4795          */
4796         public function validateSig( $text ) {
4797                 return Xml::isWellFormedXmlFragment( $text ) ? $text : false;
4798         }
4799
4800         /**
4801          * Clean up signature text
4802          *
4803          * 1) Strip 3, 4 or 5 tildes out of signatures @see cleanSigInSig
4804          * 2) Substitute all transclusions
4805          *
4806          * @param string $text
4807          * @param bool $parsing Whether we're cleaning (preferences save) or parsing
4808          * @return string Signature text
4809          */
4810         public function cleanSig( $text, $parsing = false ) {
4811                 if ( !$parsing ) {
4812                         global $wgTitle;
4813                         $magicScopeVariable = $this->lock();
4814                         $this->startParse( $wgTitle, new ParserOptions, self::OT_PREPROCESS, true );
4815                 }
4816
4817                 # Option to disable this feature
4818                 if ( !$this->mOptions->getCleanSignatures() ) {
4819                         return $text;
4820                 }
4821
4822                 # @todo FIXME: Regex doesn't respect extension tags or nowiki
4823                 #  => Move this logic to braceSubstitution()
4824                 $substWord = $this->magicWordFactory->get( 'subst' );
4825                 $substRegex = '/\{\{(?!(?:' . $substWord->getBaseRegex() . '))/x' . $substWord->getRegexCase();
4826                 $substText = '{{' . $substWord->getSynonym( 0 );
4827
4828                 $text = preg_replace( $substRegex, $substText, $text );
4829                 $text = self::cleanSigInSig( $text );
4830                 $dom = $this->preprocessToDom( $text );
4831                 $frame = $this->getPreprocessor()->newFrame();
4832                 $text = $frame->expand( $dom );
4833
4834                 if ( !$parsing ) {
4835                         $text = $this->mStripState->unstripBoth( $text );
4836                 }
4837
4838                 return $text;
4839         }
4840
4841         /**
4842          * Strip 3, 4 or 5 tildes out of signatures.
4843          *
4844          * @param string $text
4845          * @return string Signature text with /~{3,5}/ removed
4846          */
4847         public static function cleanSigInSig( $text ) {
4848                 $text = preg_replace( '/~{3,5}/', '', $text );
4849                 return $text;
4850         }
4851
4852         /**
4853          * Set up some variables which are usually set up in parse()
4854          * so that an external function can call some class members with confidence
4855          *
4856          * @param Title|null $title
4857          * @param ParserOptions $options
4858          * @param int $outputType
4859          * @param bool $clearState
4860          */
4861         public function startExternalParse( Title $title = null, ParserOptions $options,
4862                 $outputType, $clearState = true
4863         ) {
4864                 $this->startParse( $title, $options, $outputType, $clearState );
4865         }
4866
4867         /**
4868          * @param Title|null $title
4869          * @param ParserOptions $options
4870          * @param int $outputType
4871          * @param bool $clearState
4872          */
4873         private function startParse( Title $title = null, ParserOptions $options,
4874                 $outputType, $clearState = true
4875         ) {
4876                 $this->setTitle( $title );
4877                 $this->mOptions = $options;
4878                 $this->setOutputType( $outputType );
4879                 if ( $clearState ) {
4880                         $this->clearState();
4881                 }
4882         }
4883
4884         /**
4885          * Wrapper for preprocess()
4886          *
4887          * @param string $text The text to preprocess
4888          * @param ParserOptions $options
4889          * @param Title|null $title Title object or null to use $wgTitle
4890          * @return string
4891          */
4892         public function transformMsg( $text, $options, $title = null ) {
4893                 static $executing = false;
4894
4895                 # Guard against infinite recursion
4896                 if ( $executing ) {
4897                         return $text;
4898                 }
4899                 $executing = true;
4900
4901                 if ( !$title ) {
4902                         global $wgTitle;
4903                         $title = $wgTitle;
4904                 }
4905
4906                 $text = $this->preprocess( $text, $title, $options );
4907
4908                 $executing = false;
4909                 return $text;
4910         }
4911
4912         /**
4913          * Create an HTML-style tag, e.g. "<yourtag>special text</yourtag>"
4914          * The callback should have the following form:
4915          *    function myParserHook( $text, $params, $parser, $frame ) { ... }
4916          *
4917          * Transform and return $text. Use $parser for any required context, e.g. use
4918          * $parser->getTitle() and $parser->getOptions() not $wgTitle or $wgOut->mParserOptions
4919          *
4920          * Hooks may return extended information by returning an array, of which the
4921          * first numbered element (index 0) must be the return string, and all other
4922          * entries are extracted into local variables within an internal function
4923          * in the Parser class.
4924          *
4925          * This interface (introduced r61913) appears to be undocumented, but
4926          * 'markerType' is used by some core tag hooks to override which strip
4927          * array their results are placed in. **Use great caution if attempting
4928          * this interface, as it is not documented and injudicious use could smash
4929          * private variables.**
4930          *
4931          * @param string $tag The tag to use, e.g. 'hook' for "<hook>"
4932          * @param callable $callback The callback function (and object) to use for the tag
4933          * @throws MWException
4934          * @return callable|null The old value of the mTagHooks array associated with the hook
4935          */
4936         public function setHook( $tag, callable $callback ) {
4937                 $tag = strtolower( $tag );
4938                 if ( preg_match( '/[<>\r\n]/', $tag, $m ) ) {
4939                         throw new MWException( "Invalid character {$m[0]} in setHook('$tag', ...) call" );
4940                 }
4941                 $oldVal = $this->mTagHooks[$tag] ?? null;
4942                 $this->mTagHooks[$tag] = $callback;
4943                 if ( !in_array( $tag, $this->mStripList ) ) {
4944                         $this->mStripList[] = $tag;
4945                 }
4946
4947                 return $oldVal;
4948         }
4949
4950         /**
4951          * As setHook(), but letting the contents be parsed.
4952          *
4953          * Transparent tag hooks are like regular XML-style tag hooks, except they
4954          * operate late in the transformation sequence, on HTML instead of wikitext.
4955          *
4956          * This is probably obsoleted by things dealing with parser frames?
4957          * The only extension currently using it is geoserver.
4958          *
4959          * @since 1.10
4960          * @todo better document or deprecate this
4961          *
4962          * @param string $tag The tag to use, e.g. 'hook' for "<hook>"
4963          * @param callable $callback The callback function (and object) to use for the tag
4964          * @throws MWException
4965          * @return callable|null The old value of the mTagHooks array associated with the hook
4966          */
4967         public function setTransparentTagHook( $tag, callable $callback ) {
4968                 $tag = strtolower( $tag );
4969                 if ( preg_match( '/[<>\r\n]/', $tag, $m ) ) {
4970                         throw new MWException( "Invalid character {$m[0]} in setTransparentHook('$tag', ...) call" );
4971                 }
4972                 $oldVal = $this->mTransparentTagHooks[$tag] ?? null;
4973                 $this->mTransparentTagHooks[$tag] = $callback;
4974
4975                 return $oldVal;
4976         }
4977
4978         /**
4979          * Remove all tag hooks
4980          */
4981         public function clearTagHooks() {
4982                 $this->mTagHooks = [];
4983                 $this->mFunctionTagHooks = [];
4984                 $this->mStripList = $this->mDefaultStripList;
4985         }
4986
4987         /**
4988          * Create a function, e.g. {{sum:1|2|3}}
4989          * The callback function should have the form:
4990          *    function myParserFunction( &$parser, $arg1, $arg2, $arg3 ) { ... }
4991          *
4992          * Or with Parser::SFH_OBJECT_ARGS:
4993          *    function myParserFunction( $parser, $frame, $args ) { ... }
4994          *
4995          * The callback may either return the text result of the function, or an array with the text
4996          * in element 0, and a number of flags in the other elements. The names of the flags are
4997          * specified in the keys. Valid flags are:
4998          *   found                     The text returned is valid, stop processing the template. This
4999          *                             is on by default.
5000          *   nowiki                    Wiki markup in the return value should be escaped
5001          *   isHTML                    The returned text is HTML, armour it against wikitext transformation
5002          *
5003          * @param string $id The magic word ID
5004          * @param callable $callback The callback function (and object) to use
5005          * @param int $flags A combination of the following flags:
5006          *     Parser::SFH_NO_HASH      No leading hash, i.e. {{plural:...}} instead of {{#if:...}}
5007          *
5008          *     Parser::SFH_OBJECT_ARGS  Pass the template arguments as PPNode objects instead of text.
5009          *     This allows for conditional expansion of the parse tree, allowing you to eliminate dead
5010          *     branches and thus speed up parsing. It is also possible to analyse the parse tree of
5011          *     the arguments, and to control the way they are expanded.
5012          *
5013          *     The $frame parameter is a PPFrame. This can be used to produce expanded text from the
5014          *     arguments, for instance:
5015          *         $text = isset( $args[0] ) ? $frame->expand( $args[0] ) : '';
5016          *
5017          *     For technical reasons, $args[0] is pre-expanded and will be a string. This may change in
5018          *     future versions. Please call $frame->expand() on it anyway so that your code keeps
5019          *     working if/when this is changed.
5020          *
5021          *     If you want whitespace to be trimmed from $args, you need to do it yourself, post-
5022          *     expansion.
5023          *
5024          *     Please read the documentation in includes/parser/Preprocessor.php for more information
5025          *     about the methods available in PPFrame and PPNode.
5026          *
5027          * @throws MWException
5028          * @return string|callable The old callback function for this name, if any
5029          */
5030         public function setFunctionHook( $id, callable $callback, $flags = 0 ) {
5031                 $oldVal = isset( $this->mFunctionHooks[$id] ) ? $this->mFunctionHooks[$id][0] : null;
5032                 $this->mFunctionHooks[$id] = [ $callback, $flags ];
5033
5034                 # Add to function cache
5035                 $mw = $this->magicWordFactory->get( $id );
5036                 if ( !$mw ) {
5037                         throw new MWException( __METHOD__ . '() expecting a magic word identifier.' );
5038                 }
5039
5040                 $synonyms = $mw->getSynonyms();
5041                 $sensitive = intval( $mw->isCaseSensitive() );
5042
5043                 foreach ( $synonyms as $syn ) {
5044                         # Case
5045                         if ( !$sensitive ) {
5046                                 $syn = $this->contLang->lc( $syn );
5047                         }
5048                         # Add leading hash
5049                         if ( !( $flags & self::SFH_NO_HASH ) ) {
5050                                 $syn = '#' . $syn;
5051                         }
5052                         # Remove trailing colon
5053                         if ( substr( $syn, -1, 1 ) === ':' ) {
5054                                 $syn = substr( $syn, 0, -1 );
5055                         }
5056                         $this->mFunctionSynonyms[$sensitive][$syn] = $id;
5057                 }
5058                 return $oldVal;
5059         }
5060
5061         /**
5062          * Get all registered function hook identifiers
5063          *
5064          * @return array
5065          */
5066         public function getFunctionHooks() {
5067                 $this->firstCallInit();
5068                 return array_keys( $this->mFunctionHooks );
5069         }
5070
5071         /**
5072          * Create a tag function, e.g. "<test>some stuff</test>".
5073          * Unlike tag hooks, tag functions are parsed at preprocessor level.
5074          * Unlike parser functions, their content is not preprocessed.
5075          * @param string $tag
5076          * @param callable $callback
5077          * @param int $flags
5078          * @throws MWException
5079          * @return null
5080          */
5081         public function setFunctionTagHook( $tag, callable $callback, $flags ) {
5082                 $tag = strtolower( $tag );
5083                 if ( preg_match( '/[<>\r\n]/', $tag, $m ) ) {
5084                         throw new MWException( "Invalid character {$m[0]} in setFunctionTagHook('$tag', ...) call" );
5085                 }
5086                 $old = $this->mFunctionTagHooks[$tag] ?? null;
5087                 $this->mFunctionTagHooks[$tag] = [ $callback, $flags ];
5088
5089                 if ( !in_array( $tag, $this->mStripList ) ) {
5090                         $this->mStripList[] = $tag;
5091                 }
5092
5093                 return $old;
5094         }
5095
5096         /**
5097          * Replace "<!--LINK-->" link placeholders with actual links, in the buffer
5098          * Placeholders created in Linker::link()
5099          *
5100          * @param string &$text
5101          * @param int $options
5102          */
5103         public function replaceLinkHolders( &$text, $options = 0 ) {
5104                 $this->mLinkHolders->replace( $text );
5105         }
5106
5107         /**
5108          * Replace "<!--LINK-->" link placeholders with plain text of links
5109          * (not HTML-formatted).
5110          *
5111          * @param string $text
5112          * @return string
5113          */
5114         public function replaceLinkHoldersText( $text ) {
5115                 return $this->mLinkHolders->replaceText( $text );
5116         }
5117
5118         /**
5119          * Renders an image gallery from a text with one line per image.
5120          * text labels may be given by using |-style alternative text. E.g.
5121          *   Image:one.jpg|The number "1"
5122          *   Image:tree.jpg|A tree
5123          * given as text will return the HTML of a gallery with two images,
5124          * labeled 'The number "1"' and
5125          * 'A tree'.
5126          *
5127          * @param string $text
5128          * @param array $params
5129          * @return string HTML
5130          */
5131         public function renderImageGallery( $text, $params ) {
5132                 $mode = false;
5133                 if ( isset( $params['mode'] ) ) {
5134                         $mode = $params['mode'];
5135                 }
5136
5137                 try {
5138                         $ig = ImageGalleryBase::factory( $mode );
5139                 } catch ( Exception $e ) {
5140                         // If invalid type set, fallback to default.
5141                         $ig = ImageGalleryBase::factory( false );
5142                 }
5143
5144                 $ig->setContextTitle( $this->mTitle );
5145                 $ig->setShowBytes( false );
5146                 $ig->setShowDimensions( false );
5147                 $ig->setShowFilename( false );
5148                 $ig->setParser( $this );
5149                 $ig->setHideBadImages();
5150                 $ig->setAttributes( Sanitizer::validateTagAttributes( $params, 'ul' ) );
5151
5152                 if ( isset( $params['showfilename'] ) ) {
5153                         $ig->setShowFilename( true );
5154                 } else {
5155                         $ig->setShowFilename( false );
5156                 }
5157                 if ( isset( $params['caption'] ) ) {
5158                         // NOTE: We aren't passing a frame here or below.  Frame info
5159                         // is currently opaque to Parsoid, which acts on OT_PREPROCESS.
5160                         // See T107332#4030581
5161                         $caption = $this->recursiveTagParse( $params['caption'] );
5162                         $ig->setCaptionHtml( $caption );
5163                 }
5164                 if ( isset( $params['perrow'] ) ) {
5165                         $ig->setPerRow( $params['perrow'] );
5166                 }
5167                 if ( isset( $params['widths'] ) ) {
5168                         $ig->setWidths( $params['widths'] );
5169                 }
5170                 if ( isset( $params['heights'] ) ) {
5171                         $ig->setHeights( $params['heights'] );
5172                 }
5173                 $ig->setAdditionalOptions( $params );
5174
5175                 // Avoid PHP 7.1 warning from passing $this by reference
5176                 $parser = $this;
5177                 Hooks::run( 'BeforeParserrenderImageGallery', [ &$parser, &$ig ] );
5178
5179                 $lines = StringUtils::explode( "\n", $text );
5180                 foreach ( $lines as $line ) {
5181                         # match lines like these:
5182                         # Image:someimage.jpg|This is some image
5183                         $matches = [];
5184                         preg_match( "/^([^|]+)(\\|(.*))?$/", $line, $matches );
5185                         # Skip empty lines
5186                         if ( count( $matches ) == 0 ) {
5187                                 continue;
5188                         }
5189
5190                         if ( strpos( $matches[0], '%' ) !== false ) {
5191                                 $matches[1] = rawurldecode( $matches[1] );
5192                         }
5193                         $title = Title::newFromText( $matches[1], NS_FILE );
5194                         if ( is_null( $title ) ) {
5195                                 # Bogus title. Ignore these so we don't bomb out later.
5196                                 continue;
5197                         }
5198
5199                         # We need to get what handler the file uses, to figure out parameters.
5200                         # Note, a hook can overide the file name, and chose an entirely different
5201                         # file (which potentially could be of a different type and have different handler).
5202                         $options = [];
5203                         $descQuery = false;
5204                         Hooks::run( 'BeforeParserFetchFileAndTitle',
5205                                 [ $this, $title, &$options, &$descQuery ] );
5206                         # Don't register it now, as TraditionalImageGallery does that later.
5207                         $file = $this->fetchFileNoRegister( $title, $options );
5208                         $handler = $file ? $file->getHandler() : false;
5209
5210                         $paramMap = [
5211                                 'img_alt' => 'gallery-internal-alt',
5212                                 'img_link' => 'gallery-internal-link',
5213                         ];
5214                         if ( $handler ) {
5215                                 $paramMap += $handler->getParamMap();
5216                                 // We don't want people to specify per-image widths.
5217                                 // Additionally the width parameter would need special casing anyhow.
5218                                 unset( $paramMap['img_width'] );
5219                         }
5220
5221                         $mwArray = $this->magicWordFactory->newArray( array_keys( $paramMap ) );
5222
5223                         $label = '';
5224                         $alt = '';
5225                         $link = '';
5226                         $handlerOptions = [];
5227                         if ( isset( $matches[3] ) ) {
5228                                 // look for an |alt= definition while trying not to break existing
5229                                 // captions with multiple pipes (|) in it, until a more sensible grammar
5230                                 // is defined for images in galleries
5231
5232                                 // FIXME: Doing recursiveTagParse at this stage, and the trim before
5233                                 // splitting on '|' is a bit odd, and different from makeImage.
5234                                 $matches[3] = $this->recursiveTagParse( trim( $matches[3] ) );
5235                                 // Protect LanguageConverter markup
5236                                 $parameterMatches = StringUtils::delimiterExplode(
5237                                         '-{', '}-', '|', $matches[3], true /* nested */
5238                                 );
5239
5240                                 foreach ( $parameterMatches as $parameterMatch ) {
5241                                         list( $magicName, $match ) = $mwArray->matchVariableStartToEnd( $parameterMatch );
5242                                         if ( $magicName ) {
5243                                                 $paramName = $paramMap[$magicName];
5244
5245                                                 switch ( $paramName ) {
5246                                                         case 'gallery-internal-alt':
5247                                                                 $alt = $this->stripAltText( $match, false );
5248                                                                 break;
5249                                                         case 'gallery-internal-link':
5250                                                                 $linkValue = $this->stripAltText( $match, false );
5251                                                                 if ( preg_match( '/^-{R|(.*)}-$/', $linkValue ) ) {
5252                                                                         // Result of LanguageConverter::markNoConversion
5253                                                                         // invoked on an external link.
5254                                                                         $linkValue = substr( $linkValue, 4, -2 );
5255                                                                 }
5256                                                                 list( $type, $target ) = $this->parseLinkParameter( $linkValue );
5257                                                                 if ( $type === 'link-url' ) {
5258                                                                         $link = $target;
5259                                                                         $this->mOutput->addExternalLink( $target );
5260                                                                 } elseif ( $type === 'link-title' ) {
5261                                                                         $link = $target->getLinkURL();
5262                                                                         $this->mOutput->addLink( $target );
5263                                                                 }
5264                                                                 break;
5265                                                         default:
5266                                                                 // Must be a handler specific parameter.
5267                                                                 if ( $handler->validateParam( $paramName, $match ) ) {
5268                                                                         $handlerOptions[$paramName] = $match;
5269                                                                 } else {
5270                                                                         // Guess not, consider it as caption.
5271                                                                         $this->logger->debug(
5272                                                                                 "$parameterMatch failed parameter validation" );
5273                                                                         $label = $parameterMatch;
5274                                                                 }
5275                                                 }
5276
5277                                         } else {
5278                                                 // Last pipe wins.
5279                                                 $label = $parameterMatch;
5280                                         }
5281                                 }
5282                         }
5283
5284                         $ig->add( $title, $label, $alt, $link, $handlerOptions );
5285                 }
5286                 $html = $ig->toHTML();
5287                 Hooks::run( 'AfterParserFetchFileAndTitle', [ $this, $ig, &$html ] );
5288                 return $html;
5289         }
5290
5291         /**
5292          * @param MediaHandler $handler
5293          * @return array
5294          */
5295         public function getImageParams( $handler ) {
5296                 if ( $handler ) {
5297                         $handlerClass = get_class( $handler );
5298                 } else {
5299                         $handlerClass = '';
5300                 }
5301                 if ( !isset( $this->mImageParams[$handlerClass] ) ) {
5302                         # Initialise static lists
5303                         static $internalParamNames = [
5304                                 'horizAlign' => [ 'left', 'right', 'center', 'none' ],
5305                                 'vertAlign' => [ 'baseline', 'sub', 'super', 'top', 'text-top', 'middle',
5306                                         'bottom', 'text-bottom' ],
5307                                 'frame' => [ 'thumbnail', 'manualthumb', 'framed', 'frameless',
5308                                         'upright', 'border', 'link', 'alt', 'class' ],
5309                         ];
5310                         static $internalParamMap;
5311                         if ( !$internalParamMap ) {
5312                                 $internalParamMap = [];
5313                                 foreach ( $internalParamNames as $type => $names ) {
5314                                         foreach ( $names as $name ) {
5315                                                 // For grep: img_left, img_right, img_center, img_none,
5316                                                 // img_baseline, img_sub, img_super, img_top, img_text_top, img_middle,
5317                                                 // img_bottom, img_text_bottom,
5318                                                 // img_thumbnail, img_manualthumb, img_framed, img_frameless, img_upright,
5319                                                 // img_border, img_link, img_alt, img_class
5320                                                 $magicName = str_replace( '-', '_', "img_$name" );
5321                                                 $internalParamMap[$magicName] = [ $type, $name ];
5322                                         }
5323                                 }
5324                         }
5325
5326                         # Add handler params
5327                         $paramMap = $internalParamMap;
5328                         if ( $handler ) {
5329                                 $handlerParamMap = $handler->getParamMap();
5330                                 foreach ( $handlerParamMap as $magic => $paramName ) {
5331                                         $paramMap[$magic] = [ 'handler', $paramName ];
5332                                 }
5333                         }
5334                         $this->mImageParams[$handlerClass] = $paramMap;
5335                         $this->mImageParamsMagicArray[$handlerClass] =
5336                                 $this->magicWordFactory->newArray( array_keys( $paramMap ) );
5337                 }
5338                 return [ $this->mImageParams[$handlerClass], $this->mImageParamsMagicArray[$handlerClass] ];
5339         }
5340
5341         /**
5342          * Parse image options text and use it to make an image
5343          *
5344          * @param Title $title
5345          * @param string $options
5346          * @param LinkHolderArray|bool $holders
5347          * @return string HTML
5348          */
5349         public function makeImage( $title, $options, $holders = false ) {
5350                 # Check if the options text is of the form "options|alt text"
5351                 # Options are:
5352                 #  * thumbnail  make a thumbnail with enlarge-icon and caption, alignment depends on lang
5353                 #  * left       no resizing, just left align. label is used for alt= only
5354                 #  * right      same, but right aligned
5355                 #  * none       same, but not aligned
5356                 #  * ___px      scale to ___ pixels width, no aligning. e.g. use in taxobox
5357                 #  * center     center the image
5358                 #  * frame      Keep original image size, no magnify-button.
5359                 #  * framed     Same as "frame"
5360                 #  * frameless  like 'thumb' but without a frame. Keeps user preferences for width
5361                 #  * upright    reduce width for upright images, rounded to full __0 px
5362                 #  * border     draw a 1px border around the image
5363                 #  * alt        Text for HTML alt attribute (defaults to empty)
5364                 #  * class      Set a class for img node
5365                 #  * link       Set the target of the image link. Can be external, interwiki, or local
5366                 # vertical-align values (no % or length right now):
5367                 #  * baseline
5368                 #  * sub
5369                 #  * super
5370                 #  * top
5371                 #  * text-top
5372                 #  * middle
5373                 #  * bottom
5374                 #  * text-bottom
5375
5376                 # Protect LanguageConverter markup when splitting into parts
5377                 $parts = StringUtils::delimiterExplode(
5378                         '-{', '}-', '|', $options, true /* allow nesting */
5379                 );
5380
5381                 # Give extensions a chance to select the file revision for us
5382                 $options = [];
5383                 $descQuery = false;
5384                 Hooks::run( 'BeforeParserFetchFileAndTitle',
5385                         [ $this, $title, &$options, &$descQuery ] );
5386                 # Fetch and register the file (file title may be different via hooks)
5387                 list( $file, $title ) = $this->fetchFileAndTitle( $title, $options );
5388
5389                 # Get parameter map
5390                 $handler = $file ? $file->getHandler() : false;
5391
5392                 list( $paramMap, $mwArray ) = $this->getImageParams( $handler );
5393
5394                 if ( !$file ) {
5395                         $this->addTrackingCategory( 'broken-file-category' );
5396                 }
5397
5398                 # Process the input parameters
5399                 $caption = '';
5400                 $params = [ 'frame' => [], 'handler' => [],
5401                         'horizAlign' => [], 'vertAlign' => [] ];
5402                 $seenformat = false;
5403                 foreach ( $parts as $part ) {
5404                         $part = trim( $part );
5405                         list( $magicName, $value ) = $mwArray->matchVariableStartToEnd( $part );
5406                         $validated = false;
5407                         if ( isset( $paramMap[$magicName] ) ) {
5408                                 list( $type, $paramName ) = $paramMap[$magicName];
5409
5410                                 # Special case; width and height come in one variable together
5411                                 if ( $type === 'handler' && $paramName === 'width' ) {
5412                                         $parsedWidthParam = self::parseWidthParam( $value );
5413                                         if ( isset( $parsedWidthParam['width'] ) ) {
5414                                                 $width = $parsedWidthParam['width'];
5415                                                 if ( $handler->validateParam( 'width', $width ) ) {
5416                                                         $params[$type]['width'] = $width;
5417                                                         $validated = true;
5418                                                 }
5419                                         }
5420                                         if ( isset( $parsedWidthParam['height'] ) ) {
5421                                                 $height = $parsedWidthParam['height'];
5422                                                 if ( $handler->validateParam( 'height', $height ) ) {
5423                                                         $params[$type]['height'] = $height;
5424                                                         $validated = true;
5425                                                 }
5426                                         }
5427                                         # else no validation -- T15436
5428                                 } else {
5429                                         if ( $type === 'handler' ) {
5430                                                 # Validate handler parameter
5431                                                 $validated = $handler->validateParam( $paramName, $value );
5432                                         } else {
5433                                                 # Validate internal parameters
5434                                                 switch ( $paramName ) {
5435                                                         case 'manualthumb':
5436                                                         case 'alt':
5437                                                         case 'class':
5438                                                                 # @todo FIXME: Possibly check validity here for
5439                                                                 # manualthumb? downstream behavior seems odd with
5440                                                                 # missing manual thumbs.
5441                                                                 $validated = true;
5442                                                                 $value = $this->stripAltText( $value, $holders );
5443                                                                 break;
5444                                                         case 'link':
5445                                                                 list( $paramName, $value ) =
5446                                                                         $this->parseLinkParameter(
5447                                                                                 $this->stripAltText( $value, $holders )
5448                                                                         );
5449                                                                 if ( $paramName ) {
5450                                                                         $validated = true;
5451                                                                         if ( $paramName === 'no-link' ) {
5452                                                                                 $value = true;
5453                                                                         }
5454                                                                         if ( ( $paramName === 'link-url' ) && $this->mOptions->getExternalLinkTarget() ) {
5455                                                                                 $params[$type]['link-target'] = $this->mOptions->getExternalLinkTarget();
5456                                                                         }
5457                                                                 }
5458                                                                 break;
5459                                                         case 'frameless':
5460                                                         case 'framed':
5461                                                         case 'thumbnail':
5462                                                                 // use first appearing option, discard others.
5463                                                                 $validated = !$seenformat;
5464                                                                 $seenformat = true;
5465                                                                 break;
5466                                                         default:
5467                                                                 # Most other things appear to be empty or numeric...
5468                                                                 $validated = ( $value === false || is_numeric( trim( $value ) ) );
5469                                                 }
5470                                         }
5471
5472                                         if ( $validated ) {
5473                                                 $params[$type][$paramName] = $value;
5474                                         }
5475                                 }
5476                         }
5477                         if ( !$validated ) {
5478                                 $caption = $part;
5479                         }
5480                 }
5481
5482                 # Process alignment parameters
5483                 if ( $params['horizAlign'] ) {
5484                         $params['frame']['align'] = key( $params['horizAlign'] );
5485                 }
5486                 if ( $params['vertAlign'] ) {
5487                         $params['frame']['valign'] = key( $params['vertAlign'] );
5488                 }
5489
5490                 $params['frame']['caption'] = $caption;
5491
5492                 # Will the image be presented in a frame, with the caption below?
5493                 $imageIsFramed = isset( $params['frame']['frame'] )
5494                         || isset( $params['frame']['framed'] )
5495                         || isset( $params['frame']['thumbnail'] )
5496                         || isset( $params['frame']['manualthumb'] );
5497
5498                 # In the old days, [[Image:Foo|text...]] would set alt text.  Later it
5499                 # came to also set the caption, ordinary text after the image -- which
5500                 # makes no sense, because that just repeats the text multiple times in
5501                 # screen readers.  It *also* came to set the title attribute.
5502                 # Now that we have an alt attribute, we should not set the alt text to
5503                 # equal the caption: that's worse than useless, it just repeats the
5504                 # text.  This is the framed/thumbnail case.  If there's no caption, we
5505                 # use the unnamed parameter for alt text as well, just for the time be-
5506                 # ing, if the unnamed param is set and the alt param is not.
5507                 # For the future, we need to figure out if we want to tweak this more,
5508                 # e.g., introducing a title= parameter for the title; ignoring the un-
5509                 # named parameter entirely for images without a caption; adding an ex-
5510                 # plicit caption= parameter and preserving the old magic unnamed para-
5511                 # meter for BC; ...
5512                 if ( $imageIsFramed ) { # Framed image
5513                         if ( $caption === '' && !isset( $params['frame']['alt'] ) ) {
5514                                 # No caption or alt text, add the filename as the alt text so
5515                                 # that screen readers at least get some description of the image
5516                                 $params['frame']['alt'] = $title->getText();
5517                         }
5518                         # Do not set $params['frame']['title'] because tooltips don't make sense
5519                         # for framed images
5520                 } else { # Inline image
5521                         if ( !isset( $params['frame']['alt'] ) ) {
5522                                 # No alt text, use the "caption" for the alt text
5523                                 if ( $caption !== '' ) {
5524                                         $params['frame']['alt'] = $this->stripAltText( $caption, $holders );
5525                                 } else {
5526                                         # No caption, fall back to using the filename for the
5527                                         # alt text
5528                                         $params['frame']['alt'] = $title->getText();
5529                                 }
5530                         }
5531                         # Use the "caption" for the tooltip text
5532                         $params['frame']['title'] = $this->stripAltText( $caption, $holders );
5533                 }
5534                 $params['handler']['targetlang'] = $this->getTargetLanguage()->getCode();
5535
5536                 Hooks::run( 'ParserMakeImageParams', [ $title, $file, &$params, $this ] );
5537
5538                 # Linker does the rest
5539                 $time = $options['time'] ?? false;
5540                 $ret = Linker::makeImageLink( $this, $title, $file, $params['frame'], $params['handler'],
5541                         $time, $descQuery, $this->mOptions->getThumbSize() );
5542
5543                 # Give the handler a chance to modify the parser object
5544                 if ( $handler ) {
5545                         $handler->parserTransformHook( $this, $file );
5546                 }
5547
5548                 return $ret;
5549         }
5550
5551         /**
5552          * Parse the value of 'link' parameter in image syntax (`[[File:Foo.jpg|link=<value>]]`).
5553          *
5554          * Adds an entry to appropriate link tables.
5555          *
5556          * @since 1.32
5557          * @param string $value
5558          * @return array of `[ type, target ]`, where:
5559          *   - `type` is one of:
5560          *     - `null`: Given value is not a valid link target, use default
5561          *     - `'no-link'`: Given value is empty, do not generate a link
5562          *     - `'link-url'`: Given value is a valid external link
5563          *     - `'link-title'`: Given value is a valid internal link
5564          *   - `target` is:
5565          *     - When `type` is `null` or `'no-link'`: `false`
5566          *     - When `type` is `'link-url'`: URL string corresponding to given value
5567          *     - When `type` is `'link-title'`: Title object corresponding to given value
5568          */
5569         public function parseLinkParameter( $value ) {
5570                 $chars = self::EXT_LINK_URL_CLASS;
5571                 $addr = self::EXT_LINK_ADDR;
5572                 $prots = $this->mUrlProtocols;
5573                 $type = null;
5574                 $target = false;
5575                 if ( $value === '' ) {
5576                         $type = 'no-link';
5577                 } elseif ( preg_match( "/^((?i)$prots)/", $value ) ) {
5578                         if ( preg_match( "/^((?i)$prots)$addr$chars*$/u", $value, $m ) ) {
5579                                 $this->mOutput->addExternalLink( $value );
5580                                 $type = 'link-url';
5581                                 $target = $value;
5582                         }
5583                 } else {
5584                         $linkTitle = Title::newFromText( $value );
5585                         if ( $linkTitle ) {
5586                                 $this->mOutput->addLink( $linkTitle );
5587                                 $type = 'link-title';
5588                                 $target = $linkTitle;
5589                         }
5590                 }
5591                 return [ $type, $target ];
5592         }
5593
5594         /**
5595          * @param string $caption
5596          * @param LinkHolderArray|bool $holders
5597          * @return mixed|string
5598          */
5599         protected function stripAltText( $caption, $holders ) {
5600                 # Strip bad stuff out of the title (tooltip).  We can't just use
5601                 # replaceLinkHoldersText() here, because if this function is called
5602                 # from replaceInternalLinks2(), mLinkHolders won't be up-to-date.
5603                 if ( $holders ) {
5604                         $tooltip = $holders->replaceText( $caption );
5605                 } else {
5606                         $tooltip = $this->replaceLinkHoldersText( $caption );
5607                 }
5608
5609                 # make sure there are no placeholders in thumbnail attributes
5610                 # that are later expanded to html- so expand them now and
5611                 # remove the tags
5612                 $tooltip = $this->mStripState->unstripBoth( $tooltip );
5613                 # Compatibility hack!  In HTML certain entity references not terminated
5614                 # by a semicolon are decoded (but not if we're in an attribute; that's
5615                 # how link URLs get away without properly escaping & in queries).
5616                 # But wikitext has always required semicolon-termination of entities,
5617                 # so encode & where needed to avoid decode of semicolon-less entities.
5618                 # See T209236 and
5619                 # https://www.w3.org/TR/html5/syntax.html#named-character-references
5620                 # T210437 discusses moving this workaround to Sanitizer::stripAllTags.
5621                 $tooltip = preg_replace( "/
5622                         &                       # 1. entity prefix
5623                         (?=                     # 2. followed by:
5624                         (?:                     #  a. one of the legacy semicolon-less named entities
5625                                 A(?:Elig|MP|acute|circ|grave|ring|tilde|uml)|
5626                                 C(?:OPY|cedil)|E(?:TH|acute|circ|grave|uml)|
5627                                 GT|I(?:acute|circ|grave|uml)|LT|Ntilde|
5628                                 O(?:acute|circ|grave|slash|tilde|uml)|QUOT|REG|THORN|
5629                                 U(?:acute|circ|grave|uml)|Yacute|
5630                                 a(?:acute|c(?:irc|ute)|elig|grave|mp|ring|tilde|uml)|brvbar|
5631                                 c(?:cedil|edil|urren)|cent(?!erdot;)|copy(?!sr;)|deg|
5632                                 divide(?!ontimes;)|e(?:acute|circ|grave|th|uml)|
5633                                 frac(?:1(?:2|4)|34)|
5634                                 gt(?!c(?:c|ir)|dot|lPar|quest|r(?:a(?:pprox|rr)|dot|eq(?:less|qless)|less|sim);)|
5635                                 i(?:acute|circ|excl|grave|quest|uml)|laquo|
5636                                 lt(?!c(?:c|ir)|dot|hree|imes|larr|quest|r(?:Par|i(?:e|f|));)|
5637                                 m(?:acr|i(?:cro|ddot))|n(?:bsp|tilde)|
5638                                 not(?!in(?:E|dot|v(?:a|b|c)|)|ni(?:v(?:a|b|c)|);)|
5639                                 o(?:acute|circ|grave|rd(?:f|m)|slash|tilde|uml)|
5640                                 p(?:lusmn|ound)|para(?!llel;)|quot|r(?:aquo|eg)|
5641                                 s(?:ect|hy|up(?:1|2|3)|zlig)|thorn|times(?!b(?:ar|)|d;)|
5642                                 u(?:acute|circ|grave|ml|uml)|y(?:acute|en|uml)
5643                         )
5644                         (?:[^;]|$))     #  b. and not followed by a semicolon
5645                         # S = study, for efficiency
5646                         /Sx", '&amp;', $tooltip );
5647                 $tooltip = Sanitizer::stripAllTags( $tooltip );
5648
5649                 return $tooltip;
5650         }
5651
5652         /**
5653          * Set a flag in the output object indicating that the content is dynamic and
5654          * shouldn't be cached.
5655          * @deprecated since 1.28; use getOutput()->updateCacheExpiry()
5656          */
5657         public function disableCache() {
5658                 $this->logger->debug( "Parser output marked as uncacheable." );
5659                 if ( !$this->mOutput ) {
5660                         throw new MWException( __METHOD__ .
5661                                 " can only be called when actually parsing something" );
5662                 }
5663                 $this->mOutput->updateCacheExpiry( 0 ); // new style, for consistency
5664         }
5665
5666         /**
5667          * Callback from the Sanitizer for expanding items found in HTML attribute
5668          * values, so they can be safely tested and escaped.
5669          *
5670          * @param string &$text
5671          * @param bool|PPFrame $frame
5672          * @return string
5673          */
5674         public function attributeStripCallback( &$text, $frame = false ) {
5675                 $text = $this->replaceVariables( $text, $frame );
5676                 $text = $this->mStripState->unstripBoth( $text );
5677                 return $text;
5678         }
5679
5680         /**
5681          * Accessor
5682          *
5683          * @return array
5684          */
5685         public function getTags() {
5686                 $this->firstCallInit();
5687                 return array_merge(
5688                         array_keys( $this->mTransparentTagHooks ),
5689                         array_keys( $this->mTagHooks ),
5690                         array_keys( $this->mFunctionTagHooks )
5691                 );
5692         }
5693
5694         /**
5695          * @since 1.32
5696          * @return array
5697          */
5698         public function getFunctionSynonyms() {
5699                 $this->firstCallInit();
5700                 return $this->mFunctionSynonyms;
5701         }
5702
5703         /**
5704          * @since 1.32
5705          * @return string
5706          */
5707         public function getUrlProtocols() {
5708                 return $this->mUrlProtocols;
5709         }
5710
5711         /**
5712          * Replace transparent tags in $text with the values given by the callbacks.
5713          *
5714          * Transparent tag hooks are like regular XML-style tag hooks, except they
5715          * operate late in the transformation sequence, on HTML instead of wikitext.
5716          *
5717          * @param string $text
5718          *
5719          * @return string
5720          */
5721         public function replaceTransparentTags( $text ) {
5722                 $matches = [];
5723                 $elements = array_keys( $this->mTransparentTagHooks );
5724                 $text = self::extractTagsAndParams( $elements, $text, $matches );
5725                 $replacements = [];
5726
5727                 foreach ( $matches as $marker => $data ) {
5728                         list( $element, $content, $params, $tag ) = $data;
5729                         $tagName = strtolower( $element );
5730                         if ( isset( $this->mTransparentTagHooks[$tagName] ) ) {
5731                                 $output = call_user_func_array(
5732                                         $this->mTransparentTagHooks[$tagName],
5733                                         [ $content, $params, $this ]
5734                                 );
5735                         } else {
5736                                 $output = $tag;
5737                         }
5738                         $replacements[$marker] = $output;
5739                 }
5740                 return strtr( $text, $replacements );
5741         }
5742
5743         /**
5744          * Break wikitext input into sections, and either pull or replace
5745          * some particular section's text.
5746          *
5747          * External callers should use the getSection and replaceSection methods.
5748          *
5749          * @param string $text Page wikitext
5750          * @param string|int $sectionId A section identifier string of the form:
5751          *   "<flag1> - <flag2> - ... - <section number>"
5752          *
5753          * Currently the only recognised flag is "T", which means the target section number
5754          * was derived during a template inclusion parse, in other words this is a template
5755          * section edit link. If no flags are given, it was an ordinary section edit link.
5756          * This flag is required to avoid a section numbering mismatch when a section is
5757          * enclosed by "<includeonly>" (T8563).
5758          *
5759          * The section number 0 pulls the text before the first heading; other numbers will
5760          * pull the given section along with its lower-level subsections. If the section is
5761          * not found, $mode=get will return $newtext, and $mode=replace will return $text.
5762          *
5763          * Section 0 is always considered to exist, even if it only contains the empty
5764          * string. If $text is the empty string and section 0 is replaced, $newText is
5765          * returned.
5766          *
5767          * @param string $mode One of "get" or "replace"
5768          * @param string $newText Replacement text for section data.
5769          * @return string For "get", the extracted section text.
5770          *   for "replace", the whole page with the section replaced.
5771          */
5772         private function extractSections( $text, $sectionId, $mode, $newText = '' ) {
5773                 global $wgTitle; # not generally used but removes an ugly failure mode
5774
5775                 $magicScopeVariable = $this->lock();
5776                 $this->startParse( $wgTitle, new ParserOptions, self::OT_PLAIN, true );
5777                 $outText = '';
5778                 $frame = $this->getPreprocessor()->newFrame();
5779
5780                 # Process section extraction flags
5781                 $flags = 0;
5782                 $sectionParts = explode( '-', $sectionId );
5783                 $sectionIndex = array_pop( $sectionParts );
5784                 foreach ( $sectionParts as $part ) {
5785                         if ( $part === 'T' ) {
5786                                 $flags |= self::PTD_FOR_INCLUSION;
5787                         }
5788                 }
5789
5790                 # Check for empty input
5791                 if ( strval( $text ) === '' ) {
5792                         # Only sections 0 and T-0 exist in an empty document
5793                         if ( $sectionIndex == 0 ) {
5794                                 if ( $mode === 'get' ) {
5795                                         return '';
5796                                 }
5797
5798                                 return $newText;
5799                         } else {
5800                                 if ( $mode === 'get' ) {
5801                                         return $newText;
5802                                 }
5803
5804                                 return $text;
5805                         }
5806                 }
5807
5808                 # Preprocess the text
5809                 $root = $this->preprocessToDom( $text, $flags );
5810
5811                 # <h> nodes indicate section breaks
5812                 # They can only occur at the top level, so we can find them by iterating the root's children
5813                 $node = $root->getFirstChild();
5814
5815                 # Find the target section
5816                 if ( $sectionIndex == 0 ) {
5817                         # Section zero doesn't nest, level=big
5818                         $targetLevel = 1000;
5819                 } else {
5820                         while ( $node ) {
5821                                 if ( $node->getName() === 'h' ) {
5822                                         $bits = $node->splitHeading();
5823                                         if ( $bits['i'] == $sectionIndex ) {
5824                                                 $targetLevel = $bits['level'];
5825                                                 break;
5826                                         }
5827                                 }
5828                                 if ( $mode === 'replace' ) {
5829                                         $outText .= $frame->expand( $node, PPFrame::RECOVER_ORIG );
5830                                 }
5831                                 $node = $node->getNextSibling();
5832                         }
5833                 }
5834
5835                 if ( !$node ) {
5836                         # Not found
5837                         if ( $mode === 'get' ) {
5838                                 return $newText;
5839                         } else {
5840                                 return $text;
5841                         }
5842                 }
5843
5844                 # Find the end of the section, including nested sections
5845                 do {
5846                         if ( $node->getName() === 'h' ) {
5847                                 $bits = $node->splitHeading();
5848                                 $curLevel = $bits['level'];
5849                                 if ( $bits['i'] != $sectionIndex && $curLevel <= $targetLevel ) {
5850                                         break;
5851                                 }
5852                         }
5853                         if ( $mode === 'get' ) {
5854                                 $outText .= $frame->expand( $node, PPFrame::RECOVER_ORIG );
5855                         }
5856                         $node = $node->getNextSibling();
5857                 } while ( $node );
5858
5859                 # Write out the remainder (in replace mode only)
5860                 if ( $mode === 'replace' ) {
5861                         # Output the replacement text
5862                         # Add two newlines on -- trailing whitespace in $newText is conventionally
5863                         # stripped by the editor, so we need both newlines to restore the paragraph gap
5864                         # Only add trailing whitespace if there is newText
5865                         if ( $newText != "" ) {
5866                                 $outText .= $newText . "\n\n";
5867                         }
5868
5869                         while ( $node ) {
5870                                 $outText .= $frame->expand( $node, PPFrame::RECOVER_ORIG );
5871                                 $node = $node->getNextSibling();
5872                         }
5873                 }
5874
5875                 if ( is_string( $outText ) ) {
5876                         # Re-insert stripped tags
5877                         $outText = rtrim( $this->mStripState->unstripBoth( $outText ) );
5878                 }
5879
5880                 return $outText;
5881         }
5882
5883         /**
5884          * This function returns the text of a section, specified by a number ($section).
5885          * A section is text under a heading like == Heading == or \<h1\>Heading\</h1\>, or
5886          * the first section before any such heading (section 0).
5887          *
5888          * If a section contains subsections, these are also returned.
5889          *
5890          * @param string $text Text to look in
5891          * @param string|int $sectionId Section identifier as a number or string
5892          * (e.g. 0, 1 or 'T-1').
5893          * @param string $defaultText Default to return if section is not found
5894          *
5895          * @return string Text of the requested section
5896          */
5897         public function getSection( $text, $sectionId, $defaultText = '' ) {
5898                 return $this->extractSections( $text, $sectionId, 'get', $defaultText );
5899         }
5900
5901         /**
5902          * This function returns $oldtext after the content of the section
5903          * specified by $section has been replaced with $text. If the target
5904          * section does not exist, $oldtext is returned unchanged.
5905          *
5906          * @param string $oldText Former text of the article
5907          * @param string|int $sectionId Section identifier as a number or string
5908          * (e.g. 0, 1 or 'T-1').
5909          * @param string $newText Replacing text
5910          *
5911          * @return string Modified text
5912          */
5913         public function replaceSection( $oldText, $sectionId, $newText ) {
5914                 return $this->extractSections( $oldText, $sectionId, 'replace', $newText );
5915         }
5916
5917         /**
5918          * Get the ID of the revision we are parsing
5919          *
5920          * The return value will be either:
5921          *   - a) Positive, indicating a specific revision ID (current or old)
5922          *   - b) Zero, meaning the revision ID is specified by getCurrentRevisionCallback()
5923          *   - c) Null, meaning the parse is for preview mode and there is no revision
5924          *
5925          * @return int|null
5926          */
5927         public function getRevisionId() {
5928                 return $this->mRevisionId;
5929         }
5930
5931         /**
5932          * Get the revision object for $this->mRevisionId
5933          *
5934          * @return Revision|null Either a Revision object or null
5935          * @since 1.23 (public since 1.23)
5936          */
5937         public function getRevisionObject() {
5938                 if ( $this->mRevisionObject ) {
5939                         return $this->mRevisionObject;
5940                 }
5941
5942                 // NOTE: try to get the RevisionObject even if mRevisionId is null.
5943                 // This is useful when parsing a revision that has not yet been saved.
5944                 // However, if we get back a saved revision even though we are in
5945                 // preview mode, we'll have to ignore it, see below.
5946                 // NOTE: This callback may be used to inject an OLD revision that was
5947                 // already loaded, so "current" is a bit of a misnomer. We can't just
5948                 // skip it if mRevisionId is set.
5949                 $rev = call_user_func(
5950                         $this->mOptions->getCurrentRevisionCallback(),
5951                         $this->getTitle(),
5952                         $this
5953                 );
5954
5955                 if ( $this->mRevisionId === null && $rev && $rev->getId() ) {
5956                         // We are in preview mode (mRevisionId is null), and the current revision callback
5957                         // returned an existing revision. Ignore it and return null, it's probably the page's
5958                         // current revision, which is not what we want here. Note that we do want to call the
5959                         // callback to allow the unsaved revision to be injected here, e.g. for
5960                         // self-transclusion previews.
5961                         return null;
5962                 }
5963
5964                 // If the parse is for a new revision, then the callback should have
5965                 // already been set to force the object and should match mRevisionId.
5966                 // If not, try to fetch by mRevisionId for sanity.
5967                 if ( $this->mRevisionId && $rev && $rev->getId() != $this->mRevisionId ) {
5968                         $rev = Revision::newFromId( $this->mRevisionId );
5969                 }
5970
5971                 $this->mRevisionObject = $rev;
5972
5973                 return $this->mRevisionObject;
5974         }
5975
5976         /**
5977          * Get the timestamp associated with the current revision, adjusted for
5978          * the default server-local timestamp
5979          * @return string TS_MW timestamp
5980          */
5981         public function getRevisionTimestamp() {
5982                 if ( $this->mRevisionTimestamp !== null ) {
5983                         return $this->mRevisionTimestamp;
5984                 }
5985
5986                 # Use specified revision timestamp, falling back to the current timestamp
5987                 $revObject = $this->getRevisionObject();
5988                 $timestamp = $revObject ? $revObject->getTimestamp() : $this->mOptions->getTimestamp();
5989                 $this->mOutput->setRevisionTimestampUsed( $timestamp ); // unadjusted time zone
5990
5991                 # The cryptic '' timezone parameter tells to use the site-default
5992                 # timezone offset instead of the user settings.
5993                 # Since this value will be saved into the parser cache, served
5994                 # to other users, and potentially even used inside links and such,
5995                 # it needs to be consistent for all visitors.
5996                 $this->mRevisionTimestamp = $this->contLang->userAdjust( $timestamp, '' );
5997
5998                 return $this->mRevisionTimestamp;
5999         }
6000
6001         /**
6002          * Get the name of the user that edited the last revision
6003          *
6004          * @return string User name
6005          */
6006         public function getRevisionUser() {
6007                 if ( is_null( $this->mRevisionUser ) ) {
6008                         $revObject = $this->getRevisionObject();
6009
6010                         # if this template is subst: the revision id will be blank,
6011                         # so just use the current user's name
6012                         if ( $revObject ) {
6013                                 $this->mRevisionUser = $revObject->getUserText();
6014                         } elseif ( $this->ot['wiki'] || $this->mOptions->getIsPreview() ) {
6015                                 $this->mRevisionUser = $this->getUser()->getName();
6016                         }
6017                 }
6018                 return $this->mRevisionUser;
6019         }
6020
6021         /**
6022          * Get the size of the revision
6023          *
6024          * @return int|null Revision size
6025          */
6026         public function getRevisionSize() {
6027                 if ( is_null( $this->mRevisionSize ) ) {
6028                         $revObject = $this->getRevisionObject();
6029
6030                         # if this variable is subst: the revision id will be blank,
6031                         # so just use the parser input size, because the own substituation
6032                         # will change the size.
6033                         if ( $revObject ) {
6034                                 $this->mRevisionSize = $revObject->getSize();
6035                         } else {
6036                                 $this->mRevisionSize = $this->mInputSize;
6037                         }
6038                 }
6039                 return $this->mRevisionSize;
6040         }
6041
6042         /**
6043          * Mutator for $mDefaultSort
6044          *
6045          * @param string $sort New value
6046          */
6047         public function setDefaultSort( $sort ) {
6048                 $this->mDefaultSort = $sort;
6049                 $this->mOutput->setProperty( 'defaultsort', $sort );
6050         }
6051
6052         /**
6053          * Accessor for $mDefaultSort
6054          * Will use the empty string if none is set.
6055          *
6056          * This value is treated as a prefix, so the
6057          * empty string is equivalent to sorting by
6058          * page name.
6059          *
6060          * @return string
6061          */
6062         public function getDefaultSort() {
6063                 if ( $this->mDefaultSort !== false ) {
6064                         return $this->mDefaultSort;
6065                 } else {
6066                         return '';
6067                 }
6068         }
6069
6070         /**
6071          * Accessor for $mDefaultSort
6072          * Unlike getDefaultSort(), will return false if none is set
6073          *
6074          * @return string|bool
6075          */
6076         public function getCustomDefaultSort() {
6077                 return $this->mDefaultSort;
6078         }
6079
6080         private static function getSectionNameFromStrippedText( $text ) {
6081                 $text = Sanitizer::normalizeSectionNameWhitespace( $text );
6082                 $text = Sanitizer::decodeCharReferences( $text );
6083                 $text = self::normalizeSectionName( $text );
6084                 return $text;
6085         }
6086
6087         private static function makeAnchor( $sectionName ) {
6088                 return '#' . Sanitizer::escapeIdForLink( $sectionName );
6089         }
6090
6091         private function makeLegacyAnchor( $sectionName ) {
6092                 $fragmentMode = $this->svcOptions->get( 'FragmentMode' );
6093                 if ( isset( $fragmentMode[1] ) && $fragmentMode[1] === 'legacy' ) {
6094                         // ForAttribute() and ForLink() are the same for legacy encoding
6095                         $id = Sanitizer::escapeIdForAttribute( $sectionName, Sanitizer::ID_FALLBACK );
6096                 } else {
6097                         $id = Sanitizer::escapeIdForLink( $sectionName );
6098                 }
6099
6100                 return "#$id";
6101         }
6102
6103         /**
6104          * Try to guess the section anchor name based on a wikitext fragment
6105          * presumably extracted from a heading, for example "Header" from
6106          * "== Header ==".
6107          *
6108          * @param string $text
6109          * @return string Anchor (starting with '#')
6110          */
6111         public function guessSectionNameFromWikiText( $text ) {
6112                 # Strip out wikitext links(they break the anchor)
6113                 $text = $this->stripSectionName( $text );
6114                 $sectionName = self::getSectionNameFromStrippedText( $text );
6115                 return self::makeAnchor( $sectionName );
6116         }
6117
6118         /**
6119          * Same as guessSectionNameFromWikiText(), but produces legacy anchors
6120          * instead, if possible. For use in redirects, since various versions
6121          * of Microsoft browsers interpret Location: headers as something other
6122          * than UTF-8, resulting in breakage.
6123          *
6124          * @param string $text The section name
6125          * @return string Anchor (starting with '#')
6126          */
6127         public function guessLegacySectionNameFromWikiText( $text ) {
6128                 # Strip out wikitext links(they break the anchor)
6129                 $text = $this->stripSectionName( $text );
6130                 $sectionName = self::getSectionNameFromStrippedText( $text );
6131                 return $this->makeLegacyAnchor( $sectionName );
6132         }
6133
6134         /**
6135          * Like guessSectionNameFromWikiText(), but takes already-stripped text as input.
6136          * @param string $text Section name (plain text)
6137          * @return string Anchor (starting with '#')
6138          */
6139         public static function guessSectionNameFromStrippedText( $text ) {
6140                 $sectionName = self::getSectionNameFromStrippedText( $text );
6141                 return self::makeAnchor( $sectionName );
6142         }
6143
6144         /**
6145          * Apply the same normalization as code making links to this section would
6146          *
6147          * @param string $text
6148          * @return string
6149          */
6150         private static function normalizeSectionName( $text ) {
6151                 # T90902: ensure the same normalization is applied for IDs as to links
6152                 $titleParser = MediaWikiServices::getInstance()->getTitleParser();
6153                 try {
6154
6155                         $parts = $titleParser->splitTitleString( "#$text" );
6156                 } catch ( MalformedTitleException $ex ) {
6157                         return $text;
6158                 }
6159                 return $parts['fragment'];
6160         }
6161
6162         /**
6163          * Strips a text string of wikitext for use in a section anchor
6164          *
6165          * Accepts a text string and then removes all wikitext from the
6166          * string and leaves only the resultant text (i.e. the result of
6167          * [[User:WikiSysop|Sysop]] would be "Sysop" and the result of
6168          * [[User:WikiSysop]] would be "User:WikiSysop") - this is intended
6169          * to create valid section anchors by mimicing the output of the
6170          * parser when headings are parsed.
6171          *
6172          * @param string $text Text string to be stripped of wikitext
6173          * for use in a Section anchor
6174          * @return string Filtered text string
6175          */
6176         public function stripSectionName( $text ) {
6177                 # Strip internal link markup
6178                 $text = preg_replace( '/\[\[:?([^[|]+)\|([^[]+)\]\]/', '$2', $text );
6179                 $text = preg_replace( '/\[\[:?([^[]+)\|?\]\]/', '$1', $text );
6180
6181                 # Strip external link markup
6182                 # @todo FIXME: Not tolerant to blank link text
6183                 # I.E. [https://www.mediawiki.org] will render as [1] or something depending
6184                 # on how many empty links there are on the page - need to figure that out.
6185                 $text = preg_replace( '/\[(?i:' . $this->mUrlProtocols . ')([^ ]+?) ([^[]+)\]/', '$2', $text );
6186
6187                 # Parse wikitext quotes (italics & bold)
6188                 $text = $this->doQuotes( $text );
6189
6190                 # Strip HTML tags
6191                 $text = StringUtils::delimiterReplace( '<', '>', '', $text );
6192                 return $text;
6193         }
6194
6195         /**
6196          * strip/replaceVariables/unstrip for preprocessor regression testing
6197          *
6198          * @param string $text
6199          * @param Title $title
6200          * @param ParserOptions $options
6201          * @param int $outputType
6202          *
6203          * @return string
6204          */
6205         public function testSrvus( $text, Title $title, ParserOptions $options,
6206                 $outputType = self::OT_HTML
6207         ) {
6208                 $magicScopeVariable = $this->lock();
6209                 $this->startParse( $title, $options, $outputType, true );
6210
6211                 $text = $this->replaceVariables( $text );
6212                 $text = $this->mStripState->unstripBoth( $text );
6213                 $text = Sanitizer::removeHTMLtags( $text );
6214                 return $text;
6215         }
6216
6217         /**
6218          * @param string $text
6219          * @param Title $title
6220          * @param ParserOptions $options
6221          * @return string
6222          */
6223         public function testPst( $text, Title $title, ParserOptions $options ) {
6224                 return $this->preSaveTransform( $text, $title, $options->getUser(), $options );
6225         }
6226
6227         /**
6228          * @param string $text
6229          * @param Title $title
6230          * @param ParserOptions $options
6231          * @return string
6232          */
6233         public function testPreprocess( $text, Title $title, ParserOptions $options ) {
6234                 return $this->testSrvus( $text, $title, $options, self::OT_PREPROCESS );
6235         }
6236
6237         /**
6238          * Call a callback function on all regions of the given text that are not
6239          * inside strip markers, and replace those regions with the return value
6240          * of the callback. For example, with input:
6241          *
6242          *  aaa<MARKER>bbb
6243          *
6244          * This will call the callback function twice, with 'aaa' and 'bbb'. Those
6245          * two strings will be replaced with the value returned by the callback in
6246          * each case.
6247          *
6248          * @param string $s
6249          * @param callable $callback
6250          *
6251          * @return string
6252          */
6253         public function markerSkipCallback( $s, $callback ) {
6254                 $i = 0;
6255                 $out = '';
6256                 while ( $i < strlen( $s ) ) {
6257                         $markerStart = strpos( $s, self::MARKER_PREFIX, $i );
6258                         if ( $markerStart === false ) {
6259                                 $out .= call_user_func( $callback, substr( $s, $i ) );
6260                                 break;
6261                         } else {
6262                                 $out .= call_user_func( $callback, substr( $s, $i, $markerStart - $i ) );
6263                                 $markerEnd = strpos( $s, self::MARKER_SUFFIX, $markerStart );
6264                                 if ( $markerEnd === false ) {
6265                                         $out .= substr( $s, $markerStart );
6266                                         break;
6267                                 } else {
6268                                         $markerEnd += strlen( self::MARKER_SUFFIX );
6269                                         $out .= substr( $s, $markerStart, $markerEnd - $markerStart );
6270                                         $i = $markerEnd;
6271                                 }
6272                         }
6273                 }
6274                 return $out;
6275         }
6276
6277         /**
6278          * Remove any strip markers found in the given text.
6279          *
6280          * @param string $text
6281          * @return string
6282          */
6283         public function killMarkers( $text ) {
6284                 return $this->mStripState->killMarkers( $text );
6285         }
6286
6287         /**
6288          * Save the parser state required to convert the given half-parsed text to
6289          * HTML. "Half-parsed" in this context means the output of
6290          * recursiveTagParse() or internalParse(). This output has strip markers
6291          * from replaceVariables (extensionSubstitution() etc.), and link
6292          * placeholders from replaceLinkHolders().
6293          *
6294          * Returns an array which can be serialized and stored persistently. This
6295          * array can later be loaded into another parser instance with
6296          * unserializeHalfParsedText(). The text can then be safely incorporated into
6297          * the return value of a parser hook.
6298          *
6299          * @deprecated since 1.31
6300          * @param string $text
6301          *
6302          * @return array
6303          */
6304         public function serializeHalfParsedText( $text ) {
6305                 wfDeprecated( __METHOD__, '1.31' );
6306                 $data = [
6307                         'text' => $text,
6308                         'version' => self::HALF_PARSED_VERSION,
6309                         'stripState' => $this->mStripState->getSubState( $text ),
6310                         'linkHolders' => $this->mLinkHolders->getSubArray( $text )
6311                 ];
6312                 return $data;
6313         }
6314
6315         /**
6316          * Load the parser state given in the $data array, which is assumed to
6317          * have been generated by serializeHalfParsedText(). The text contents is
6318          * extracted from the array, and its markers are transformed into markers
6319          * appropriate for the current Parser instance. This transformed text is
6320          * returned, and can be safely included in the return value of a parser
6321          * hook.
6322          *
6323          * If the $data array has been stored persistently, the caller should first
6324          * check whether it is still valid, by calling isValidHalfParsedText().
6325          *
6326          * @deprecated since 1.31
6327          * @param array $data Serialized data
6328          * @throws MWException
6329          * @return string
6330          */
6331         public function unserializeHalfParsedText( $data ) {
6332                 wfDeprecated( __METHOD__, '1.31' );
6333                 if ( !isset( $data['version'] ) || $data['version'] != self::HALF_PARSED_VERSION ) {
6334                         throw new MWException( __METHOD__ . ': invalid version' );
6335                 }
6336
6337                 # First, extract the strip state.
6338                 $texts = [ $data['text'] ];
6339                 $texts = $this->mStripState->merge( $data['stripState'], $texts );
6340
6341                 # Now renumber links
6342                 $texts = $this->mLinkHolders->mergeForeign( $data['linkHolders'], $texts );
6343
6344                 # Should be good to go.
6345                 return $texts[0];
6346         }
6347
6348         /**
6349          * Returns true if the given array, presumed to be generated by
6350          * serializeHalfParsedText(), is compatible with the current version of the
6351          * parser.
6352          *
6353          * @deprecated since 1.31
6354          * @param array $data
6355          *
6356          * @return bool
6357          */
6358         public function isValidHalfParsedText( $data ) {
6359                 wfDeprecated( __METHOD__, '1.31' );
6360                 return isset( $data['version'] ) && $data['version'] == self::HALF_PARSED_VERSION;
6361         }
6362
6363         /**
6364          * Parsed a width param of imagelink like 300px or 200x300px
6365          *
6366          * @param string $value
6367          * @param bool $parseHeight
6368          *
6369          * @return array
6370          * @since 1.20
6371          */
6372         public static function parseWidthParam( $value, $parseHeight = true ) {
6373                 $parsedWidthParam = [];
6374                 if ( $value === '' ) {
6375                         return $parsedWidthParam;
6376                 }
6377                 $m = [];
6378                 # (T15500) In both cases (width/height and width only),
6379                 # permit trailing "px" for backward compatibility.
6380                 if ( $parseHeight && preg_match( '/^([0-9]*)x([0-9]*)\s*(?:px)?\s*$/', $value, $m ) ) {
6381                         $width = intval( $m[1] );
6382                         $height = intval( $m[2] );
6383                         $parsedWidthParam['width'] = $width;
6384                         $parsedWidthParam['height'] = $height;
6385                 } elseif ( preg_match( '/^[0-9]*\s*(?:px)?\s*$/', $value ) ) {
6386                         $width = intval( $value );
6387                         $parsedWidthParam['width'] = $width;
6388                 }
6389                 return $parsedWidthParam;
6390         }
6391
6392         /**
6393          * Lock the current instance of the parser.
6394          *
6395          * This is meant to stop someone from calling the parser
6396          * recursively and messing up all the strip state.
6397          *
6398          * @throws MWException If parser is in a parse
6399          * @return ScopedCallback The lock will be released once the return value goes out of scope.
6400          */
6401         protected function lock() {
6402                 if ( $this->mInParse ) {
6403                         throw new MWException( "Parser state cleared while parsing. "
6404                                 . "Did you call Parser::parse recursively? Lock is held by: " . $this->mInParse );
6405                 }
6406
6407                 // Save the backtrace when locking, so that if some code tries locking again,
6408                 // we can print the lock owner's backtrace for easier debugging
6409                 $e = new Exception;
6410                 $this->mInParse = $e->getTraceAsString();
6411
6412                 $recursiveCheck = new ScopedCallback( function () {
6413                         $this->mInParse = false;
6414                 } );
6415
6416                 return $recursiveCheck;
6417         }
6418
6419         /**
6420          * Strip outer <p></p> tag from the HTML source of a single paragraph.
6421          *
6422          * Returns original HTML if the <p/> tag has any attributes, if there's no wrapping <p/> tag,
6423          * or if there is more than one <p/> tag in the input HTML.
6424          *
6425          * @param string $html
6426          * @return string
6427          * @since 1.24
6428          */
6429         public static function stripOuterParagraph( $html ) {
6430                 $m = [];
6431                 if ( preg_match( '/^<p>(.*)\n?<\/p>\n?$/sU', $html, $m ) && strpos( $m[1], '</p>' ) === false ) {
6432                         $html = $m[1];
6433                 }
6434
6435                 return $html;
6436         }
6437
6438         /**
6439          * Return this parser if it is not doing anything, otherwise
6440          * get a fresh parser. You can use this method by doing
6441          * $newParser = $oldParser->getFreshParser(), or more simply
6442          * $oldParser->getFreshParser()->parse( ... );
6443          * if you're unsure if $oldParser is safe to use.
6444          *
6445          * @since 1.24
6446          * @return Parser A parser object that is not parsing anything
6447          */
6448         public function getFreshParser() {
6449                 if ( $this->mInParse ) {
6450                         return $this->factory->create();
6451                 } else {
6452                         return $this;
6453                 }
6454         }
6455
6456         /**
6457          * Set's up the PHP implementation of OOUI for use in this request
6458          * and instructs OutputPage to enable OOUI for itself.
6459          *
6460          * @since 1.26
6461          */
6462         public function enableOOUI() {
6463                 OutputPage::setupOOUI();
6464                 $this->mOutput->setEnableOOUI( true );
6465         }
6466
6467         /**
6468          * @param string $flag
6469          * @param string $reason
6470          */
6471         protected function setOutputFlag( $flag, $reason ) {
6472                 $this->mOutput->setFlag( $flag );
6473                 $name = $this->mTitle->getPrefixedText();
6474                 $this->logger->debug( __METHOD__ . ": set $flag flag on '$name'; $reason" );
6475         }
6476 }