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