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