| blob | c5d69685e488e51415b7cd91d88a800be0c38fba |
1 <?php
3 /**
4 * Differences from DOM schema:
5 * * attribute nodes are children
6 * * <h> nodes that aren't at the top are replaced with <possible-h>
7 * @ingroup Parser
8 */
16 }
20 }
24 }
26 /**
27 * Preprocess some wikitext and return the document tree.
28 * This is the ghost of Parser::replace_variables().
29 *
30 * @param string $text The text to parse
31 * @param integer flags Bitwise combination of:
32 * Parser::PTD_FOR_INCLUSION Handle <noinclude>/<includeonly> as if the text is being
33 * included. Default is to assume a direct page view.
34 *
35 * The generated DOM tree must depend only on the input text and the flags.
36 * The DOM tree must be the same in OT_HTML and OT_WIKI mode, to avoid a regression of bug 4899.
37 *
38 * Any flag added to the $flags parameter here, or any other parameter liable to cause a
39 * change in the DOM tree for a given text, must be passed through the section identifier
40 * in the section edit link and thus back to extractSections().
41 *
42 * The output of this function is currently only cached in process memory, but a persistent
43 * cache may be implemented at a later date which takes further advantage of these strict
44 * dependency requirements.
45 *
46 * @private
47 */
52 // Check cache.
65 // From the cache
71 }
72 }
74 }
82 ),
85 ),
91 )
92 );
102 if ( strpos( $text, '<onlyinclude>' ) !== false && strpos( $text, '</onlyinclude>' ) !== false ) {
104 }
109 }
112 // Use "A" modifier (anchored) instead of "^", because ^ doesn't work with an offset
131 //$this->memCheck();
134 // Ignore all input up to the next <onlyinclude>
137 // Ignored section runs to the end
140 }
145 }
151 # Find next opening brace, closing brace or pipe
158 }
161 }
163 // First equals will be for the template
165 }
167 # Output literal section, advance input counter
172 }
175 // Do a past-the-end run to finish off the heading
179 # All done
181 }
195 }
202 # Some versions of PHP have a strcspn which stops on null characters
203 # Ignore and continue
206 }
207 }
208 }
212 // Handle </onlyinclude>
213 if ( $enableOnlyinclude && substr( $text, $i, strlen( '</onlyinclude>' ) ) == '</onlyinclude>' ) {
216 }
218 // Determine element name
220 // Element name missing or not listed
224 }
225 // Handle comments
227 // To avoid leaving blank lines, when a comment is both preceded
228 // and followed by a newline (ignoring spaces), trim leading and
229 // trailing spaces and one of the newlines.
231 // Find the end
234 // Unclosed comment in input, runs to end
239 // Search backwards for leading whitespace
241 // Search forwards for trailing whitespace
242 // $wsEnd will be the position of the last space
244 // Eat the line if possible
245 // TODO: This could theoretically be done if $wsStart == 0, i.e. for comments at
246 // the overall start. That's not how Sanitizer::removeHTMLcomments() did it, but
247 // it's a possible beneficial b/c break.
250 {
253 // Remove leading whitespace from the end of the accumulator
254 // Sanity check first though
259 {
261 }
262 // Do a line-start run next time to look for headings after the comment
265 // No line to eat, just take the comment itself
268 }
273 // Comments abutting, no change in visual end
278 }
279 }
283 }
285 }
290 // Find end of tag
293 // Infinite backtrack
294 // Disable tag search to prevent worst-case O(N^2) performance
299 }
301 // Handle ignored tags
306 }
310 // Short end tag
317 // Find closing tag
320 {
325 // No end tag -- let it run out to the end of the text.
329 }
330 }
331 // <includeonly> and <noinclude> just become <ignore> tags
335 }
340 // Note that the attr element contains the whitespace between name and attribute,
341 // this is necessary for precise reconstruction during pre-save transform.
343 }
350 }
353 }
355 }
358 // Is this the start of a heading?
359 // Line break belongs before the heading element in any case
365 }
369 // DWIM: This looks kind of like a name/value separator
370 // Let's let the equals handler have it and break the potential heading
371 // This is heuristic, but AFAICT the methods for completely correct disambiguation are very complex.
383 }
384 }
388 // A heading must be open, otherwise \n wouldn't have been in the search list
391 // Search back through the input to see if it has a proper close
392 // Do this using the reversed string since the other solutions (end anchor, etc.) are inefficient
396 // Comment found at line end
397 // Search for equals signs before the comment
400 }
405 // This is just a single string of equals signs on its own line
406 // Replicate the doHeadings behaviour /={count}(.+)={count}/
407 // First find out how many equals signs there really are (don't stop at 6)
413 }
416 }
418 // Normal match, output <h>
425 // Single equals sign on its own line, count=0
427 }
429 // No match, no <h>, just pass down the inner text
431 }
432 // Unwind the stack
437 // Append the result to the enclosing accumulator
442 }
443 // Note that we do NOT increment the input pointer.
444 // This is because the closing linebreak could be the opening linebreak of
445 // another heading. Infinite loops are avoided because the next iteration MUST
446 // hit the heading open case above, which unconditionally increments the
447 // input pointer.
448 }
451 # count opening brace characters
454 # we need to add to stack only if opening brace count is enough for one of the rules
456 # Add it to the stack
462 );
468 # Add literal brace(s)
470 }
472 }
476 # lets check if there are enough characters for closing brace
480 # check for maximum matching characters (if there are 5 closing
481 # characters, we will probably need only 3 - depending on the rules)
485 # The specified maximum exists in the callback array, unless the caller
486 # has made an error
489 # Count is less than the maximum
490 # Skip any gaps in the callback array to find the true largest match
491 # Need to use array_key_exists not isset because the callback can be null
495 }
496 }
499 # No matching element found in callback array
500 # Output a literal closing brace and continue
504 }
507 // No element, just literal text
511 # Create XML element
512 # Note: $parts is already XML, does not need to be encoded further
519 # The invocation is at the start of the line if lineStart is set in
520 # the stack, and all opening brackets are used up.
523 }
531 // Find equals
536 }
538 }
541 }
544 }
547 // Construct name node
553 }
555 // Construct value node
560 }
576 }
577 }
578 }
580 # Advance input pointer
583 # Unwind the stack
587 # Re-add the old stack element if it still has unmatched opening characters remaining
591 # do we still qualify for any callback with remaining count?
600 }
603 }
605 }
609 # Add XML element to the enclosing accumulator
614 }
615 }
622 }
629 }
630 }
632 # Output any remaining unclosed brackets
635 }
637 # Enable top-level headings
641 }
642 }
648 // Cache
655 }
659 }
660 }
662 /**
663 * Stack class to help Preprocessor::preprocessToObj()
664 * @ingroup Parser
665 */
671 }
672 }
674 /**
675 * @ingroup Parser
676 */
681 }
683 /**
684 * Get the accumulator that would result if the close is not found.
685 */
692 }
701 }
703 }
704 }
706 }
707 }
709 /**
710 * @ingroup Parser
711 */
717 }
719 }
720 }
722 /**
723 * @ingroup Parser
724 */
730 }
732 /**
733 * Append a string literal
734 */
743 }
744 }
746 /**
747 * Append a PPNode
748 */
755 }
756 }
758 /**
759 * Append a tree node with text contents
760 */
764 }
766 /**
767 * Append a PPAccum_Hash
768 * Takes over ownership of the nodes in the source argument. These nodes may
769 * subsequently be modified, especially nextSibling.
770 */
773 // nothing to add
780 }
781 }
782 }
784 /**
785 * An expansion frame, used as a context to expand the result of preprocessToObj()
786 * @ingroup Parser
787 */
792 /**
793 * Hashtable listing templates which are disallowed for expansion in this frame,
794 * having been encountered previously in parent frames.
795 */
798 /**
799 * Recursion depth of this frame, top = 0
800 * Note that this is NOT the same as expansion depth in expand()
801 */
805 /**
806 * Construct a new preprocessor frame.
807 * @param Preprocessor $preprocessor The parent preprocessor
808 */
816 }
818 /**
819 * Create a new child frame
820 * $args is optionally a multi-root PPNode or array containing the template arguments
821 */
827 }
834 }
838 // Numbered parameter
842 // Named parameter
846 }
847 }
848 }
849 return new PPTemplateFrame_Hash( $this->preprocessor, $this, $numberedArgs, $namedArgs, $title );
850 }
856 }
859 {
861 }
864 }
879 // All done with this iterator
885 }
888 // All done with this iterator
894 }
896 // Copy to $contextNode and then delete from iterator stack,
897 // because this is not an iterator but we do have to execute it once
900 }
905 // nothing to do
911 // No output
916 # Double-brace expansion
919 $newIterator = $this->virtualBracketedImplode( '{{', '|', '}}', $bits['title'], $bits['parts'] );
926 }
927 }
929 # Triple-brace expansion
932 $newIterator = $this->virtualBracketedImplode( '{{{', '|', '}}}', $bits['title'], $bits['parts'] );
939 }
940 }
942 # HTML-style comment
943 # Remove it in HTML, pre+remove and STRIP_COMMENTS modes
947 {
949 }
950 # Add a strip marker in PST mode so that pstPass2() can run some old-fashioned regexes on the result
951 # Not in RECOVER_COMMENTS mode (extractSections) though
954 }
955 # Recover the literal comment in RECOVER_COMMENTS and pre+no-remove
958 }
960 # Output suppression used by <includeonly> etc.
961 # OT_WIKI will only respect <ignore> in substed templates.
962 # The other output types respect it unless NO_IGNORE is set.
963 # extractSections() sets NO_IGNORE and so never respects it.
964 if ( ( !isset( $this->parent ) && $this->parser->ot['wiki'] ) || ( $flags & self::NO_IGNORE ) ) {
967 //$out .= '';
968 }
970 # Extension tag
974 # Heading
976 # Expand immediately and insert heading index marker
980 }
991 # Expand in virtual stack
993 }
995 # Generic recursive expansion
997 }
1000 }
1007 // Return accumulated value to parent
1008 // With tail recursion
1015 }
1016 }
1017 }
1020 }
1030 }
1033 }
1039 }
1041 }
1042 }
1044 }
1046 /**
1047 * Implode with no flags specified
1048 * This previously called implodeWithFlags but has now been inlined to reduce stack depth
1049 */
1058 }
1061 }
1067 }
1069 }
1070 }
1072 }
1074 /**
1075 * Makes an object that, when expand()ed, will be the same as one obtained
1076 * with implode()
1077 */
1086 }
1089 }
1095 }
1097 }
1098 }
1100 }
1102 /**
1103 * Virtual implode with brackets
1104 */
1113 }
1116 }
1122 }
1124 }
1125 }
1128 }
1132 }
1139 }
1140 }
1144 }
1148 }
1152 }
1154 /**
1155 * Returns true if there are no arguments in this frame
1156 */
1159 }
1163 }
1165 /**
1166 * Returns true if the infinite loop check is OK, false if a loop is detected
1167 */
1170 }
1172 /**
1173 * Return true if the frame is a template frame
1174 */
1177 }
1178 }
1180 /**
1181 * Expansion frame with template arguments
1182 * @ingroup Parser
1183 */
1188 function __construct( $preprocessor, $parent = false, $numberedArgs = array(), $namedArgs = array(), $title = false ) {
1200 }
1203 }
1214 }
1217 }
1220 }
1221 /**
1222 * Returns true if there are no arguments in this frame
1223 */
1226 }
1234 }
1236 }
1242 }
1244 }
1250 }
1252 }
1257 }
1259 # No trimming for unnamed arguments
1260 $this->numberedExpansionCache[$index] = $this->parent->expand( $this->numberedArgs[$index], self::STRIP_COMMENTS );
1261 }
1263 }
1268 }
1270 # Trim named arguments post-expand, for backwards compatibility
1273 }
1275 }
1281 }
1283 }
1285 /**
1286 * Return true if the frame is a template frame
1287 */
1290 }
1291 }
1293 /**
1294 * Expansion frame with custom arguments
1295 * @ingroup Parser
1296 */
1303 }
1313 }
1316 }
1319 }
1323 }
1328 }
1330 }
1331 }
1333 /**
1334 * @ingroup Parser
1335 */
1342 }
1352 }
1353 }
1358 }
1359 }
1365 }
1373 }
1374 }
1380 }
1382 }
1386 }
1390 }
1397 }
1398 }
1400 }
1407 }
1409 /**
1410 * Split a <part> node into an associative array containing:
1411 * name PPNode name
1412 * index String index
1413 * value PPNode value
1414 */
1420 }
1425 {
1427 }
1430 }
1431 }
1435 }
1438 }
1440 }
1442 /**
1443 * Split an <ext> node into an associative array containing name, attr, inner and close
1444 * All values in the resulting array are PPNodes. Inner and close are optional.
1445 */
1451 }
1460 }
1461 }
1464 }
1466 }
1468 /**
1469 * Split an <h> node
1470 */
1474 }
1479 }
1484 }
1485 }
1488 }
1490 }
1492 /**
1493 * Split a <template> or <tplarg> node
1494 */
1501 }
1504 }
1507 }
1510 }
1511 }
1514 }
1517 }
1518 }
1520 /**
1521 * @ingroup Parser
1522 */
1529 }
1531 }
1535 }
1539 }
1550 }
1552 /**
1553 * @ingroup Parser
1554 */
1560 }
1564 }
1568 }
1572 }
1578 }
1586 }
1588 /**
1589 * @ingroup Parser
1590 */
1597 }
1601 }
1605 }
1609 }
1619 }