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