79 foreach ( $values
as $k => $val ) {
81 $store = [ [
'part', [
82 [
'name', [ [
'@index', [ $k ] ] ] ],
83 [
'value', [ strval( $val ) ] ],
86 $store = [ [
'part', [
87 [
'name', [ strval( $k ) ] ],
89 [
'value', [ strval( $val ) ] ],
122 if ( $tree !==
false ) {
123 $store = json_decode( $tree );
124 if ( is_array( $store ) ) {
129 $forInclusion = $flags & Parser::PTD_FOR_INCLUSION;
131 $xmlishElements = $this->
parser->getStripList();
132 $xmlishAllowMissingEndTag = [
'includeonly',
'noinclude',
'onlyinclude' ];
133 $enableOnlyinclude =
false;
134 if ( $forInclusion ) {
135 $ignoredTags = [
'includeonly',
'/includeonly' ];
136 $ignoredElements = [
'noinclude' ];
137 $xmlishElements[] =
'noinclude';
138 if ( strpos( $text,
'<onlyinclude>' ) !==
false
139 && strpos( $text,
'</onlyinclude>' ) !==
false
141 $enableOnlyinclude =
true;
144 $ignoredTags = [
'noinclude',
'/noinclude',
'onlyinclude',
'/onlyinclude' ];
145 $ignoredElements = [
'includeonly' ];
146 $xmlishElements[] =
'includeonly';
148 $xmlishRegex = implode(
'|', array_merge( $xmlishElements, $ignoredTags ) );
151 $elementsRegex =
"~($xmlishRegex)(?:\s|\/>|>)|(!--)~iA";
155 $searchBase =
"[{<\n";
161 $revText = strrev( $text );
162 $lengthText = strlen( $text );
167 $accum =& $stack->getAccum();
178 $noMoreClosingTag = [];
180 $findOnlyinclude = $enableOnlyinclude;
182 $fakeLineStart =
true;
187 if ( $findOnlyinclude ) {
189 $startPos = strpos( $text,
'<onlyinclude>', $i );
190 if ( $startPos ===
false ) {
192 $accum[] = [
'ignore', [ substr( $text, $i ) ] ];
195 $tagEndPos = $startPos + strlen(
'<onlyinclude>' );
196 $accum[] = [
'ignore', [ substr( $text, $i, $tagEndPos - $i ) ] ];
198 $findOnlyinclude =
false;
201 if ( $fakeLineStart ) {
202 $found =
'line-start';
205 # Find next opening brace, closing brace or pipe
206 $search = $searchBase;
207 if ( $stack->top ===
false ) {
208 $currentClosing =
'';
210 $currentClosing = $stack->top->close;
211 $search .= $currentClosing;
221 # Output literal section, advance input counter
222 $literalLength = strcspn( $text, $search, $i );
223 if ( $literalLength > 0 ) {
225 $i += $literalLength;
227 if ( $i >= $lengthText ) {
228 if ( $currentClosing ==
"\n" ) {
237 $curChar = $curTwoChar = $text[$i];
238 if ( ( $i + 1 ) < $lengthText ) {
239 $curTwoChar .= $text[$i + 1];
241 if ( $curChar ==
'|' ) {
243 } elseif ( $curChar ==
'=' ) {
245 } elseif ( $curChar ==
'<' ) {
247 } elseif ( $curChar ==
"\n" ) {
251 $found =
'line-start';
253 } elseif ( $curTwoChar == $currentClosing ) {
255 $curChar = $curTwoChar;
256 } elseif ( $curChar == $currentClosing ) {
258 } elseif ( isset( $this->rules[$curTwoChar] ) ) {
259 $curChar = $curTwoChar;
261 $rule = $this->rules[$curChar];
262 } elseif ( isset( $this->rules[$curChar] ) ) {
264 $rule = $this->rules[$curChar];
266 # Some versions of PHP have a strcspn which stops on
267 # null characters; ignore these and continue.
268 # We also may get '-' and '}' characters here which
269 # don't match -{ or $currentClosing. Add these to
270 # output and continue.
271 if ( $curChar ==
'-' || $curChar ==
'}' ) {
280 if ( $found ==
'angle' ) {
283 if ( $enableOnlyinclude
284 && substr( $text, $i, strlen(
'</onlyinclude>' ) ) ==
'</onlyinclude>'
286 $findOnlyinclude =
true;
291 if ( !preg_match( $elementsRegex, $text,
$matches, 0, $i + 1 ) ) {
305 $endPos = strpos( $text,
'-->', $i + 4 );
306 if ( $endPos ===
false ) {
308 $inner = substr( $text, $i );
309 $accum[] = [
'comment', [ $inner ] ];
313 $wsStart = $i ? ( $i - strspn( $revText,
" \t", $lengthText - $i ) ) : 0;
317 $wsEnd = $endPos + 2 + strspn( $text,
" \t", $endPos + 3 );
321 $comments = [ [ $wsStart, $wsEnd ] ];
322 while ( substr( $text, $wsEnd + 1, 4 ) ==
'<!--' ) {
323 $c = strpos( $text,
'-->', $wsEnd + 4 );
324 if ( $c ===
false ) {
327 $c = $c + 2 + strspn( $text,
" \t", $c + 3 );
328 $comments[] = [ $wsEnd + 1, $c ];
336 if ( $wsStart > 0 && substr( $text, $wsStart - 1, 1 ) ==
"\n"
337 && substr( $text, $wsEnd + 1, 1 ) ==
"\n"
340 $wsLength = $i - $wsStart;
341 $endIndex =
count( $accum ) - 1;
346 && is_string( $accum[$endIndex] )
347 && strspn( $accum[$endIndex],
" \t", -$wsLength ) === $wsLength
349 $accum[$endIndex] = substr( $accum[$endIndex], 0, -$wsLength );
353 foreach ( $comments
as $j => $com ) {
355 $endPos = $com[1] + 1;
356 if ( $j == (
count( $comments ) - 1 ) ) {
359 $inner = substr( $text, $startPos, $endPos - $startPos );
360 $accum[] = [
'comment', [ $inner ] ];
364 $fakeLineStart =
true;
372 $part = $stack->top->getCurrentPart();
373 if ( !( isset( $part->commentEnd ) && $part->commentEnd == $wsStart - 1 ) ) {
374 $part->visualEnd = $wsStart;
377 $part->commentEnd = $endPos;
380 $inner = substr( $text, $startPos, $endPos - $startPos + 1 );
381 $accum[] = [
'comment', [ $inner ] ];
386 $lowerName = strtolower(
$name );
387 $attrStart = $i + strlen(
$name ) + 1;
390 $tagEndPos = $noMoreGT ?
false : strpos( $text,
'>', $attrStart );
391 if ( $tagEndPos ===
false ) {
401 if ( in_array( $lowerName, $ignoredTags ) ) {
402 $accum[] = [
'ignore', [ substr( $text, $i, $tagEndPos - $i + 1 ) ] ];
408 if ( $text[$tagEndPos - 1] ==
'/' ) {
410 $attrEnd = $tagEndPos - 1;
415 $attrEnd = $tagEndPos;
418 !isset( $noMoreClosingTag[
$name] ) &&
419 preg_match(
"/<\/" . preg_quote(
$name,
'/' ) .
"\s*>/i",
420 $text,
$matches, PREG_OFFSET_CAPTURE, $tagEndPos + 1 )
422 $inner = substr( $text, $tagEndPos + 1,
$matches[0][1] - $tagEndPos - 1 );
427 if ( in_array(
$name, $xmlishAllowMissingEndTag ) ) {
429 $inner = substr( $text, $tagEndPos + 1 );
436 substr( $text, $tagStartPos, $tagEndPos + 1 - $tagStartPos ) );
438 $noMoreClosingTag[
$name] =
true;
444 if ( in_array( $lowerName, $ignoredElements ) ) {
445 $accum[] = [
'ignore', [ substr( $text, $tagStartPos, $i - $tagStartPos ) ] ];
449 if ( $attrEnd <= $attrStart ) {
454 $attr = substr( $text, $attrStart, $attrEnd - $attrStart );
458 [
'name', [
$name ] ],
459 [
'attr', [ $attr ] ] ];
460 if ( $inner !==
null ) {
461 $children[] = [
'inner', [ $inner ] ];
463 if ( $close !==
null ) {
464 $children[] = [
'close', [ $close ] ];
466 $accum[] = [
'ext', $children ];
467 } elseif ( $found ==
'line-start' ) {
470 if ( $fakeLineStart ) {
471 $fakeLineStart =
false;
477 $count = strspn( $text,
'=', $i, 6 );
478 if ( $count == 1 && $findEquals ) {
483 } elseif ( $count > 0 ) {
487 'parts' => [
new PPDPart_Hash( str_repeat(
'=', $count ) ) ],
490 $stack->push( $piece );
491 $accum =& $stack->getAccum();
492 $stackFlags = $stack->getFlags();
493 if ( isset( $stackFlags[
'findEquals'] ) ) {
494 $findEquals = $stackFlags[
'findEquals'];
496 if ( isset( $stackFlags[
'findPipe'] ) ) {
497 $findPipe = $stackFlags[
'findPipe'];
499 if ( isset( $stackFlags[
'inHeading'] ) ) {
500 $inHeading = $stackFlags[
'inHeading'];
504 } elseif ( $found ==
'line-end' ) {
505 $piece = $stack->top;
509 assert( $piece->open ===
"\n" );
510 $part = $piece->getCurrentPart();
514 $wsLength = strspn( $revText,
" \t", $lengthText - $i );
515 $searchStart = $i - $wsLength;
516 if ( isset( $part->commentEnd ) && $searchStart - 1 == $part->commentEnd ) {
519 $searchStart = $part->visualEnd;
520 $searchStart -= strspn( $revText,
" \t", $lengthText - $searchStart );
522 $count = $piece->count;
523 $equalsLength = strspn( $revText,
'=', $lengthText - $searchStart );
524 if ( $equalsLength > 0 ) {
525 if ( $searchStart - $equalsLength == $piece->startPos ) {
529 $count = $equalsLength;
533 $count = min( 6, intval( ( $count - 1 ) / 2 ) );
536 $count = min( $equalsLength, $count );
540 $element = [ [
'possible-h',
543 [
'@level', [ $count ] ],
544 [
'@i', [ $headingIndex++ ] ]
559 $accum =& $stack->getAccum();
560 $stackFlags = $stack->getFlags();
561 if ( isset( $stackFlags[
'findEquals'] ) ) {
562 $findEquals = $stackFlags[
'findEquals'];
564 if ( isset( $stackFlags[
'findPipe'] ) ) {
565 $findPipe = $stackFlags[
'findPipe'];
567 if ( isset( $stackFlags[
'inHeading'] ) ) {
568 $inHeading = $stackFlags[
'inHeading'];
572 array_splice( $accum,
count( $accum ), 0, $element );
579 } elseif ( $found ==
'open' ) {
580 # count opening brace characters
581 $curLen = strlen( $curChar );
582 $count = ( $curLen > 1 ) ?
583 # allow the
final character to repeat
584 strspn( $text, $curChar[$curLen - 1], $i + 1 ) + 1 :
585 strspn( $text, $curChar, $i );
588 $lineStart = ( $i > 0 && $text[$i - 1] ==
"\n" );
590 if ( $curChar ===
"-{" && $count > $curLen ) {
596 $rule = $this->rules[$curChar];
599 # we need to add to stack only if opening brace count is enough for one of the rules
600 if ( $count >= $rule[
'min'] ) {
601 # Add it to the stack
604 'close' => $rule[
'end'],
605 'savedPrefix' => $savedPrefix,
607 'lineStart' => $lineStart,
610 $stack->push( $piece );
611 $accum =& $stack->getAccum();
612 $stackFlags = $stack->getFlags();
613 if ( isset( $stackFlags[
'findEquals'] ) ) {
614 $findEquals = $stackFlags[
'findEquals'];
616 if ( isset( $stackFlags[
'findPipe'] ) ) {
617 $findPipe = $stackFlags[
'findPipe'];
619 if ( isset( $stackFlags[
'inHeading'] ) ) {
620 $inHeading = $stackFlags[
'inHeading'];
623 # Add literal brace(s)
627 } elseif ( $found ==
'close' ) {
628 $piece = $stack->top;
629 # lets check if there are enough characters for closing brace
630 $maxCount = $piece->count;
631 if ( $piece->close ===
'}-' && $curChar ===
'}' ) {
632 $maxCount--; # don
't try to match closing '-
' as a '}
'
634 $curLen = strlen( $curChar );
635 $count = ( $curLen > 1 ) ? $curLen :
636 strspn( $text, $curChar, $i, $maxCount );
638 # check for maximum matching characters (if there are 5 closing
639 # characters, we will probably need only 3 - depending on the rules)
640 $rule = $this->rules[$piece->open];
641 if ( $count > $rule['max
'] ) {
642 # The specified maximum exists in the callback array, unless the caller
644 $matchingCount = $rule['max
'];
646 # Count is less than the maximum
647 # Skip any gaps in the callback array to find the true largest match
648 # Need to use array_key_exists not isset because the callback can be null
649 $matchingCount = $count;
650 while ( $matchingCount > 0 && !array_key_exists( $matchingCount, $rule['names'] ) ) {
655 if ( $matchingCount <= 0 ) {
656 # No matching element found in callback array
657 # Output a literal closing brace and continue
658 $endText = substr( $text, $i, $count );
659 self::addLiteral( $accum, $endText );
663 $name = $rule['names'][$matchingCount];
664 if ( $name === null ) {
665 // No element, just literal text
666 $endText = substr( $text, $i, $matchingCount );
667 $element = $piece->breakSyntax( $matchingCount );
668 self::addLiteral( $element, $endText );
671 $parts = $piece->parts;
672 $titleAccum = $parts[0]->out;
677 # The invocation is at the start of the line if lineStart is set in
678 # the stack, and all opening brackets are used up.
679 if ( $maxCount == $matchingCount &&
680 !empty( $piece->lineStart ) &&
681 strlen( $piece->savedPrefix ) == 0 ) {
682 $children[] = [ '@lineStart
', [ 1 ] ];
684 $titleNode = [ 'title', $titleAccum ];
685 $children[] = $titleNode;
687 foreach ( $parts as $part ) {
688 if ( isset( $part->eqpos ) ) {
689 $equalsNode = $part->out[$part->eqpos];
690 $nameNode = [ 'name', array_slice( $part->out, 0, $part->eqpos ) ];
691 $valueNode = [ 'value', array_slice( $part->out, $part->eqpos + 1 ) ];
692 $partNode = [ 'part', [ $nameNode, $equalsNode, $valueNode ] ];
693 $children[] = $partNode;
695 $nameNode = [ 'name', [ [ '@index
', [ $argIndex++ ] ] ] ];
696 $valueNode = [ 'value', $part->out ];
697 $partNode = [ 'part', [ $nameNode, $valueNode ] ];
698 $children[] = $partNode;
701 $element = [ [ $name, $children ] ];
704 # Advance input pointer
705 $i += $matchingCount;
709 $accum =& $stack->getAccum();
711 # Re-add the old stack element if it still has unmatched opening characters remaining
712 if ( $matchingCount < $piece->count ) {
713 $piece->parts = [ new PPDPart_Hash ];
714 $piece->count -= $matchingCount;
715 # do we still qualify for any callback with remaining count?
716 $min = $this->rules[$piece->open]['min
'];
717 if ( $piece->count >= $min ) {
718 $stack->push( $piece );
719 $accum =& $stack->getAccum();
720 } elseif ( $piece->count == 1 && $piece->open === '{
' && $piece->savedPrefix === '-
' ) {
721 $piece->savedPrefix = '';
724 $piece->close = $this->rules[$piece->open]['end
'];
725 $stack->push( $piece );
726 $accum =& $stack->getAccum();
728 $s = substr( $piece->open, 0, -1 );
730 substr( $piece->open, -1 ),
731 $piece->count - strlen( $s )
733 self::addLiteral( $accum, $piece->savedPrefix . $s );
735 } elseif ( $piece->savedPrefix !== '' ) {
736 self::addLiteral( $accum, $piece->savedPrefix );
739 $stackFlags = $stack->getFlags();
740 if ( isset( $stackFlags['findEquals
'] ) ) {
741 $findEquals = $stackFlags['findEquals
'];
743 if ( isset( $stackFlags['findPipe
'] ) ) {
744 $findPipe = $stackFlags['findPipe
'];
746 if ( isset( $stackFlags['inHeading
'] ) ) {
747 $inHeading = $stackFlags['inHeading
'];
750 # Add XML element to the enclosing accumulator
751 array_splice( $accum, count( $accum ), 0, $element );
752 } elseif ( $found == 'pipe
' ) {
753 $findEquals = true; // shortcut for getFlags()
755 $accum =& $stack->getAccum();
757 } elseif ( $found == 'equals
' ) {
758 $findEquals = false; // shortcut for getFlags()
759 $accum[] = [ 'equals
', [ '=
' ] ];
760 $stack->getCurrentPart()->eqpos = count( $accum ) - 1;
765 # Output any remaining unclosed brackets
766 foreach ( $stack->stack as $piece ) {
767 array_splice( $stack->rootAccum, count( $stack->rootAccum ), 0, $piece->breakSyntax() );
770 # Enable top-level headings
771 foreach ( $stack->rootAccum as &$node ) {
772 if ( is_array( $node ) && $node[PPNode_Hash_Tree::NAME] === 'possible-h
' ) {
773 $node[PPNode_Hash_Tree::NAME] = 'h
';
777 $rootStore = [ [ 'root', $stack->rootAccum ] ];
778 $rootNode = new PPNode_Hash_Tree( $rootStore, 0 );
781 $tree = json_encode( $rootStore, JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE );
782 if ( $tree !== false ) {
783 $this->cacheSetTree( $text, $flags, $tree );
789 private static function addLiteral( array &$accum, $text ) {
790 $n = count( $accum );
791 if ( $n && is_string( $accum[$n - 1] ) ) {
792 $accum[$n - 1] .= $text;
803 // phpcs:ignore Squiz.Classes.ValidClassName.NotCamelCaps
804 class PPDStack_Hash extends PPDStack {
806 public function __construct() {
807 $this->elementClass = PPDStackElement_Hash::class;
808 parent::__construct();
809 $this->rootAccum = [];
816 // phpcs:ignore Squiz.Classes.ValidClassName.NotCamelCaps
817 class PPDStackElement_Hash extends PPDStackElement {
819 public function __construct( $data = [] ) {
820 $this->partClass = PPDPart_Hash::class;
821 parent::__construct( $data );
830 public function breakSyntax( $openingCount = false ) {
831 if ( $this->open == "\n" ) {
832 $accum = array_merge( [ $this->savedPrefix ], $this->parts[0]->out );
834 if ( $openingCount === false ) {
835 $openingCount = $this->count;
837 $s = substr( $this->open, 0, -1 );
839 substr( $this->open, -1 ),
840 $openingCount - strlen( $s )
842 $accum = [ $this->savedPrefix . $s ];
845 foreach ( $this->parts as $part ) {
848 } elseif ( is_string( $accum[$lastIndex] ) ) {
849 $accum[$lastIndex] .= '|
';
851 $accum[++$lastIndex] = '|
';
853 foreach ( $part->out as $node ) {
854 if ( is_string( $node ) && is_string( $accum[$lastIndex] ) ) {
855 $accum[$lastIndex] .= $node;
857 $accum[++$lastIndex] = $node;
869 // phpcs:ignore Squiz.Classes.ValidClassName.NotCamelCaps
870 class PPDPart_Hash extends PPDPart {
872 public function __construct( $out = '' ) {
878 parent::__construct( $accum );
886 // phpcs:ignore Squiz.Classes.ValidClassName.NotCamelCaps
887 class PPFrame_Hash implements PPFrame {
897 public $preprocessor;
909 public $loopCheckHash;
917 private $volatile = false;
923 protected $childExpansionCache;
929 public function __construct( $preprocessor ) {
930 $this->preprocessor = $preprocessor;
931 $this->parser = $preprocessor->parser;
932 $this->title = $this->parser->mTitle;
933 $this->titleCache = [ $this->title ? $this->title->getPrefixedDBkey() : false ];
934 $this->loopCheckHash = [];
936 $this->childExpansionCache = [];
949 public function newChild( $args = false, $title = false, $indexOffset = 0 ) {
952 if ( $title === false ) {
953 $title = $this->title;
955 if ( $args !== false ) {
956 if ( $args instanceof PPNode_Hash_Array ) {
957 $args = $args->value;
958 } elseif ( !is_array( $args ) ) {
961 foreach ( $args as $arg ) {
962 $bits = $arg->splitArg();
963 if ( $bits['index
'] !== '' ) {
964 // Numbered parameter
965 $index = $bits['index
'] - $indexOffset;
966 if ( isset( $namedArgs[$index] ) || isset( $numberedArgs[$index] ) ) {
967 $this->parser->getOutput()->addWarning( wfMessage( 'duplicate-
args-warning
',
968 wfEscapeWikiText( $this->title ),
969 wfEscapeWikiText( $title ),
970 wfEscapeWikiText( $index ) )->text() );
971 $this->parser->addTrackingCategory( 'duplicate-
args-category
' );
973 $numberedArgs[$index] = $bits['value'];
974 unset( $namedArgs[$index] );
977 $name = trim( $this->expand( $bits['name'], PPFrame::STRIP_COMMENTS ) );
978 if ( isset( $namedArgs[$name] ) || isset( $numberedArgs[$name] ) ) {
979 $this->parser->getOutput()->addWarning( wfMessage( 'duplicate-
args-warning
',
980 wfEscapeWikiText( $this->title ),
981 wfEscapeWikiText( $title ),
982 wfEscapeWikiText( $name ) )->text() );
983 $this->parser->addTrackingCategory( 'duplicate-
args-category
' );
985 $namedArgs[$name] = $bits['value'];
986 unset( $numberedArgs[$name] );
990 return new PPTemplateFrame_Hash( $this->preprocessor, $this, $numberedArgs, $namedArgs, $title );
1000 public function cachedExpand( $key, $root, $flags = 0 ) {
1001 // we don't have
a parent,
so we don
't have a cache
1002 return $this->expand( $root, $flags );
1011 public function expand( $root, $flags = 0 ) {
1012 static $expansionDepth = 0;
1013 if ( is_string( $root ) ) {
1017 if ( ++$this->parser->mPPNodeCount > $this->parser->mOptions->getMaxPPNodeCount() ) {
1018 $this->parser->limitationWarn( 'node-
count-exceeded
',
1019 $this->parser->mPPNodeCount,
1020 $this->parser->mOptions->getMaxPPNodeCount()
1022 return '<span
class=
"error">Node-
count limit exceeded</span>
';
1024 if ( $expansionDepth > $this->parser->mOptions->getMaxPPExpandDepth() ) {
1025 $this->parser->limitationWarn( 'expansion-depth-exceeded
',
1027 $this->parser->mOptions->getMaxPPExpandDepth()
1029 return '<span
class=
"error">Expansion depth limit exceeded</span>
';
1032 if ( $expansionDepth > $this->parser->mHighestExpansionDepth ) {
1033 $this->parser->mHighestExpansionDepth = $expansionDepth;
1036 $outStack = [ '', '' ];
1037 $iteratorStack = [ false, $root ];
1038 $indexStack = [ 0, 0 ];
1040 while ( count( $iteratorStack ) > 1 ) {
1041 $level = count( $outStack ) - 1;
1042 $iteratorNode =& $iteratorStack[$level];
1043 $out =& $outStack[$level];
1044 $index =& $indexStack[$level];
1046 if ( is_array( $iteratorNode ) ) {
1047 if ( $index >= count( $iteratorNode ) ) {
1048 // All done with this iterator
1049 $iteratorStack[$level] = false;
1050 $contextNode = false;
1052 $contextNode = $iteratorNode[$index];
1055 } elseif ( $iteratorNode instanceof PPNode_Hash_Array ) {
1056 if ( $index >= $iteratorNode->getLength() ) {
1057 // All done with this iterator
1058 $iteratorStack[$level] = false;
1059 $contextNode = false;
1061 $contextNode = $iteratorNode->item( $index );
1065 // Copy to $contextNode and then delete from iterator stack,
1066 // because this is not an iterator but we do have to execute it once
1067 $contextNode = $iteratorStack[$level];
1068 $iteratorStack[$level] = false;
1071 $newIterator = false;
1072 $contextName = false;
1073 $contextChildren = false;
1075 if ( $contextNode === false ) {
1077 } elseif ( is_string( $contextNode ) ) {
1078 $out .= $contextNode;
1079 } elseif ( $contextNode instanceof PPNode_Hash_Array ) {
1080 $newIterator = $contextNode;
1081 } elseif ( $contextNode instanceof PPNode_Hash_Attr ) {
1083 } elseif ( $contextNode instanceof PPNode_Hash_Text ) {
1084 $out .= $contextNode->value;
1085 } elseif ( $contextNode instanceof PPNode_Hash_Tree ) {
1086 $contextName = $contextNode->name;
1087 $contextChildren = $contextNode->getRawChildren();
1088 } elseif ( is_array( $contextNode ) ) {
1089 // Node descriptor array
1090 if ( count( $contextNode ) !== 2 ) {
1091 throw new MWException( __METHOD__ .
1092 ': found an
array where
a node descriptor should be
' );
1094 list( $contextName, $contextChildren ) = $contextNode;
1096 throw new MWException( __METHOD__ . ': Invalid parameter
type' );
1099 // Handle node descriptor array or tree object
1100 if ( $contextName === false ) {
1101 // Not a node, already handled above
1102 } elseif ( $contextName[0] === '@
' ) {
1103 // Attribute: no output
1104 } elseif ( $contextName === 'template' ) {
1105 # Double-brace expansion
1106 $bits = PPNode_Hash_Tree::splitRawTemplate( $contextChildren );
1107 if ( $flags & PPFrame::NO_TEMPLATES ) {
1108 $newIterator = $this->virtualBracketedImplode(
1114 $ret = $this->parser->braceSubstitution( $bits, $this );
1115 if ( isset( $ret['object'] ) ) {
1116 $newIterator = $ret['object'];
1118 $out .= $ret['text'];
1121 } elseif ( $contextName === 'tplarg
' ) {
1122 # Triple-brace expansion
1123 $bits = PPNode_Hash_Tree::splitRawTemplate( $contextChildren );
1124 if ( $flags & PPFrame::NO_ARGS ) {
1125 $newIterator = $this->virtualBracketedImplode(
1131 $ret = $this->parser->argSubstitution( $bits, $this );
1132 if ( isset( $ret['object'] ) ) {
1133 $newIterator = $ret['object'];
1135 $out .= $ret['text'];
1138 } elseif ( $contextName === 'comment
' ) {
1139 # HTML-style comment
1140 # Remove it in HTML, pre+remove and STRIP_COMMENTS modes
1141 # Not in RECOVER_COMMENTS mode (msgnw) though.
1142 if ( ( $this->parser->ot['html
']
1143 || ( $this->parser->ot['pre
'] && $this->parser->mOptions->getRemoveComments() )
1144 || ( $flags & PPFrame::STRIP_COMMENTS )
1145 ) && !( $flags & PPFrame::RECOVER_COMMENTS )
1148 } elseif ( $this->parser->ot['wiki'] && !( $flags & PPFrame::RECOVER_COMMENTS ) ) {
1149 # Add a strip marker in PST mode so that pstPass2() can
1150 # run some old-fashioned regexes on the result.
1151 # Not in RECOVER_COMMENTS mode (extractSections) though.
1152 $out .= $this->parser->insertStripItem( $contextChildren[0] );
1154 # Recover the literal comment in RECOVER_COMMENTS and pre+no-remove
1155 $out .= $contextChildren[0];
1157 } elseif ( $contextName === 'ignore
' ) {
1158 # Output suppression used by <includeonly> etc.
1159 # OT_WIKI will only respect <ignore> in substed templates.
1160 # The other output types respect it unless NO_IGNORE is set.
1161 # extractSections() sets NO_IGNORE and so never respects it.
1162 if ( ( !isset( $this->parent ) && $this->parser->ot['wiki'] )
1163 || ( $flags & PPFrame::NO_IGNORE )
1165 $out .= $contextChildren[0];
1169 } elseif ( $contextName === 'ext
' ) {
1171 $bits = PPNode_Hash_Tree::splitRawExt( $contextChildren ) +
1172 [ 'attr
' => null, 'inner
' => null, 'close
' => null ];
1173 if ( $flags & PPFrame::NO_TAGS ) {
1174 $s = '<
' . $bits['name']->getFirstChild()->value;
1175 if ( $bits['attr
'] ) {
1176 $s .= $bits['attr
']->getFirstChild()->value;
1178 if ( $bits['inner
'] ) {
1179 $s .= '>
' . $bits['inner
']->getFirstChild()->value;
1180 if ( $bits['close
'] ) {
1181 $s .= $bits['close
']->getFirstChild()->value;
1188 $out .= $this->parser->extensionSubstitution( $bits, $this );
1190 } elseif ( $contextName === 'h
' ) {
1192 if ( $this->parser->ot['html
'] ) {
1193 # Expand immediately and insert heading index marker
1194 $s = $this->expand( $contextChildren, $flags );
1195 $bits = PPNode_Hash_Tree::splitRawHeading( $contextChildren );
1196 $titleText = $this->title->getPrefixedDBkey();
1197 $this->parser->mHeadings[] = [ $titleText, $bits['i
'] ];
1198 $serial = count( $this->parser->mHeadings ) - 1;
1199 $marker = Parser::MARKER_PREFIX . "-h-$serial-" . Parser::MARKER_SUFFIX;
1200 $s = substr( $s, 0, $bits['level
'] ) . $marker . substr( $s, $bits['level
'] );
1201 $this->parser->mStripState->addGeneral( $marker, '' );
1204 # Expand in virtual stack
1205 $newIterator = $contextChildren;
1208 # Generic recursive expansion
1209 $newIterator = $contextChildren;
1212 if ( $newIterator !== false ) {
1214 $iteratorStack[] = $newIterator;
1216 } elseif ( $iteratorStack[$level] === false ) {
1217 // Return accumulated value to parent
1218 // With tail recursion
1219 while ( $iteratorStack[$level] === false && $level > 0 ) {
1220 $outStack[$level - 1] .= $out;
1221 array_pop( $outStack );
1222 array_pop( $iteratorStack );
1223 array_pop( $indexStack );
1229 return $outStack[0];
1238 public function implodeWithFlags( $sep, $flags /*, ... */ ) {
1239 $args = array_slice( func_get_args(), 2 );
1243 foreach ( $args as $root ) {
1244 if ( $root instanceof PPNode_Hash_Array ) {
1245 $root = $root->value;
1247 if ( !is_array( $root ) ) {
1250 foreach ( $root as $node ) {
1256 $s .= $this->expand( $node, $flags );
1269 public function implode( $sep /*, ... */ ) {
1270 $args = array_slice( func_get_args(), 1 );
1274 foreach ( $args as $root ) {
1275 if ( $root instanceof PPNode_Hash_Array ) {
1276 $root = $root->value;
1278 if ( !is_array( $root ) ) {
1281 foreach ( $root as $node ) {
1287 $s .= $this->expand( $node );
1301 public function virtualImplode( $sep /*, ... */ ) {
1302 $args = array_slice( func_get_args(), 1 );
1306 foreach ( $args as $root ) {
1307 if ( $root instanceof PPNode_Hash_Array ) {
1308 $root = $root->value;
1310 if ( !is_array( $root ) ) {
1313 foreach ( $root as $node ) {
1322 return new PPNode_Hash_Array( $out );
1334 public function virtualBracketedImplode( $start, $sep, $end /*, ... */ ) {
1335 $args = array_slice( func_get_args(), 3 );
1339 foreach ( $args as $root ) {
1340 if ( $root instanceof PPNode_Hash_Array ) {
1341 $root = $root->value;
1343 if ( !is_array( $root ) ) {
1346 foreach ( $root as $node ) {
1356 return new PPNode_Hash_Array( $out );
1359 public function __toString() {
1367 public function getPDBK( $level = false ) {
1368 if ( $level === false ) {
1369 return $this->title->getPrefixedDBkey();
1371 return $this->titleCache[$level] ?? false;
1378 public function getArguments() {
1385 public function getNumberedArguments() {
1392 public function getNamedArguments() {
1401 public function isEmpty() {
1409 public function getArgument( $name ) {
1420 public function loopCheck( $title ) {
1421 return !isset( $this->loopCheckHash[$title->getPrefixedDBkey()] );
1429 public function isTemplate() {
1438 public function getTitle() {
1439 return $this->title;
1447 public function setVolatile( $flag = true ) {
1448 $this->volatile = $flag;
1456 public function isVolatile() {
1457 return $this->volatile;
1465 public function setTTL( $ttl ) {
1466 if ( $ttl !== null && ( $this->ttl === null || $ttl < $this->ttl ) ) {
1476 public function getTTL() {
1485 // phpcs:ignore Squiz.Classes.ValidClassName.NotCamelCaps
1486 class PPTemplateFrame_Hash extends PPFrame_Hash {
1488 public $numberedArgs, $namedArgs, $parent;
1489 public $numberedExpansionCache, $namedExpansionCache;
1498 public function __construct( $preprocessor, $parent = false, $numberedArgs = [],
1499 $namedArgs = [], $title = false
1501 parent::__construct( $preprocessor );
1503 $this->parent = $parent;
1504 $this->numberedArgs = $numberedArgs;
1505 $this->namedArgs = $namedArgs;
1506 $this->title = $title;
1507 $pdbk = $title ? $title->getPrefixedDBkey() : false;
1508 $this->titleCache = $parent->titleCache;
1509 $this->titleCache[] = $pdbk;
1510 $this->loopCheckHash = /*clone*/ $parent->loopCheckHash;
1511 if ( $pdbk !== false ) {
1512 $this->loopCheckHash[$pdbk] = true;
1514 $this->depth = $parent->depth + 1;
1515 $this->numberedExpansionCache = $this->namedExpansionCache = [];
1518 public function __toString() {
1521 $args = $this->numberedArgs + $this->namedArgs;
1522 foreach ( $args as $name => $value ) {
1528 $s .= "\"$name\":\"" .
1529 str_replace( '"', '\\"', $value->__toString() ) . '"';
1542 public function cachedExpand( $key, $root, $flags = 0 ) {
1543 if ( isset( $this->parent->childExpansionCache[$key] ) ) {
1544 return $this->parent->childExpansionCache[$key];
1546 $retval = $this->expand( $root, $flags );
1547 if ( !$this->isVolatile() ) {
1548 $this->parent->childExpansionCache[$key] = $retval;
1558 public function isEmpty() {
1559 return !count( $this->numberedArgs ) && !count( $this->namedArgs );
1565 public function getArguments() {
1567 foreach ( array_merge(
1568 array_keys( $this->numberedArgs ),
1569 array_keys( $this->namedArgs ) ) as $key ) {
1570 $arguments[$key] = $this->getArgument( $key );
1578 public function getNumberedArguments() {
1580 foreach ( array_keys( $this->numberedArgs ) as $key ) {
1581 $arguments[$key] = $this->getArgument( $key );
1589 public function getNamedArguments() {
1591 foreach ( array_keys( $this->namedArgs ) as $key ) {
1592 $arguments[$key] = $this->getArgument( $key );
1601 public function getNumberedArgument( $index ) {
1602 if ( !isset( $this->numberedArgs[$index] ) ) {
1605 if ( !isset( $this->numberedExpansionCache[$index] ) ) {
1606 # No trimming for unnamed arguments
1607 $this->numberedExpansionCache[$index] = $this->parent->expand(
1608 $this->numberedArgs[$index],
1609 PPFrame::STRIP_COMMENTS
1612 return $this->numberedExpansionCache[$index];
1619 public function getNamedArgument( $name ) {
1620 if ( !isset( $this->namedArgs[$name] ) ) {
1623 if ( !isset( $this->namedExpansionCache[$name] ) ) {
1624 # Trim named arguments post-expand, for backwards compatibility
1625 $this->namedExpansionCache[$name] = trim(
1626 $this->parent->expand( $this->namedArgs[$name], PPFrame::STRIP_COMMENTS ) );
1628 return $this->namedExpansionCache[$name];
1635 public function getArgument( $name ) {
1636 $text = $this->getNumberedArgument( $name );
1637 if ( $text === false ) {
1638 $text = $this->getNamedArgument( $name );
1648 public function isTemplate() {
1652 public function setVolatile( $flag = true ) {
1653 parent::setVolatile( $flag );
1654 $this->parent->setVolatile( $flag );
1657 public function setTTL( $ttl ) {
1658 parent::setTTL( $ttl );
1659 $this->parent->setTTL( $ttl );
1667 // phpcs:ignore Squiz.Classes.ValidClassName.NotCamelCaps
1668 class PPCustomFrame_Hash extends PPFrame_Hash {
1672 public function __construct( $preprocessor, $args ) {
1673 parent::__construct( $preprocessor );
1674 $this->args = $args;
1677 public function __toString() {
1680 foreach ( $this->args as $name => $value ) {
1686 $s .= "\
"$name\":\"" .
1687 str_replace(
'"',
'\\"',
$value->__toString() ) .
'"';
1705 return $this->
args[$index] ??
false;
1758 $this->store = $store;
1759 $this->index = $index;
1760 list( $this->
name, $this->rawChildren ) = $this->store[$index];
1772 if ( !isset( $store[$index] ) ) {
1776 $descriptor = $store[$index];
1777 if ( is_string( $descriptor ) ) {
1779 } elseif ( is_array( $descriptor ) ) {
1780 if ( $descriptor[self::NAME][0] ===
'@' ) {
1786 throw new MWException( __METHOD__ .
': invalid node descriptor' );
1788 return new $class( $store, $index );
1797 for ( $node = $this->getFirstChild(); $node; $node = $node->getNextSibling() ) {
1799 $attribs .=
' ' . $node->name .
'="' . htmlspecialchars( $node->value ) .
'"';
1801 $inner .= $node->__toString();
1804 if ( $inner ===
'' ) {
1805 return "<{$this->name}$attribs/>";
1807 return "<{$this->name}$attribs>$inner</{$this->name}>";
1816 foreach ( $this->rawChildren
as $i => $child ) {
1817 $children[] = self::factory( $this->rawChildren, $i );
1830 if ( !isset( $this->rawChildren[0] ) ) {
1833 return self::factory( $this->rawChildren, 0 );
1845 return self::factory( $this->store, $this->index + 1 );
1856 foreach ( $this->rawChildren
as $i => $child ) {
1857 if ( is_array( $child ) && $child[self::NAME] ===
$name ) {
1858 $children[] = self::factory( $this->rawChildren, $i );
1869 return $this->rawChildren;
1904 return self::splitRawArg( $this->rawChildren );
1914 foreach ( $children
as $i => $child ) {
1915 if ( !is_array( $child ) ) {
1918 if ( $child[self::NAME] ===
'name' ) {
1919 $bits[
'name'] =
new self( $children, $i );
1920 if ( isset( $child[self::CHILDREN][0][self::NAME] )
1921 && $child[self::CHILDREN][0][self::NAME] ===
'@index'
1923 $bits[
'index'] = $child[self::CHILDREN][0][self::CHILDREN][0];
1925 } elseif ( $child[self::NAME] ===
'value' ) {
1926 $bits[
'value'] =
new self( $children, $i );
1930 if ( !isset( $bits[
'name'] ) ) {
1931 throw new MWException(
'Invalid brace node passed to ' . __METHOD__ );
1933 if ( !isset( $bits[
'index'] ) ) {
1934 $bits[
'index'] =
'';
1947 return self::splitRawExt( $this->rawChildren );
1957 foreach ( $children
as $i => $child ) {
1958 if ( !is_array( $child ) ) {
1961 switch ( $child[self::NAME] ) {
1963 $bits[
'name'] =
new self( $children, $i );
1966 $bits[
'attr'] =
new self( $children, $i );
1969 $bits[
'inner'] =
new self( $children, $i );
1972 $bits[
'close'] =
new self( $children, $i );
1976 if ( !isset( $bits[
'name'] ) ) {
1977 throw new MWException(
'Invalid ext node passed to ' . __METHOD__ );
1989 if ( $this->
name !==
'h' ) {
1990 throw new MWException(
'Invalid h node passed to ' . __METHOD__ );
1992 return self::splitRawHeading( $this->rawChildren );
2002 foreach ( $children
as $i => $child ) {
2003 if ( !is_array( $child ) ) {
2006 if ( $child[self::NAME] ===
'@i' ) {
2007 $bits[
'i'] = $child[self::CHILDREN][0];
2008 } elseif ( $child[self::NAME] ===
'@level' ) {
2009 $bits[
'level'] = $child[self::CHILDREN][0];
2012 if ( !isset( $bits[
'i'] ) ) {
2013 throw new MWException(
'Invalid h node passed to ' . __METHOD__ );
2025 return self::splitRawTemplate( $this->rawChildren );
2035 $bits = [
'lineStart' =>
'' ];
2036 foreach ( $children
as $i => $child ) {
2037 if ( !is_array( $child ) ) {
2040 switch ( $child[self::NAME] ) {
2042 $bits[
'title'] =
new self( $children, $i );
2045 $parts[] =
new self( $children, $i );
2048 $bits[
'lineStart'] =
'1';
2052 if ( !isset( $bits[
'title'] ) ) {
2053 throw new MWException(
'Invalid node passed to ' . __METHOD__ );
2077 $this->
value = $store[$index];
2078 if ( !is_scalar( $this->
value ) ) {
2079 throw new MWException( __CLASS__ .
' given object instead of string' );
2081 $this->store = $store;
2082 $this->index = $index;
2086 return htmlspecialchars( $this->
value );
2118 throw new MWException( __METHOD__ .
': not supported' );
2122 throw new MWException( __METHOD__ .
': not supported' );
2126 throw new MWException( __METHOD__ .
': not supported' );
2143 return var_export( $this,
true );
2151 return $this->
value[$i];
2175 throw new MWException( __METHOD__ .
': not supported' );
2179 throw new MWException( __METHOD__ .
': not supported' );
2183 throw new MWException( __METHOD__ .
': not supported' );
2204 $descriptor = $store[$index];
2206 throw new MWException( __METHOD__ .
': invalid name in attribute descriptor' );
2210 $this->store = $store;
2211 $this->index = $index;
2215 return "<@{$this->name}>" . htmlspecialchars( $this->
value ) .
"</@{$this->name}>";
2247 throw new MWException( __METHOD__ .
': not supported' );
2251 throw new MWException( __METHOD__ .
': not supported' );
2255 throw new MWException( __METHOD__ .
': not supported' );