| blob | e778ca8a1456026e1d969aa07e93630ec7fe6d44 |
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 */
24 /**
25 * @defgroup Parser Parser
26 */
28 /**
29 * PHP Parser - Processes wiki markup (which uses a more user-friendly
30 * syntax, such as "[[link]]" for making links), and provides a one-way
31 * transformation of that wiki markup it into XHTML output / markup
32 * (which in turn the browser understands, and can display).
33 *
34 * There are seven main entry points into the Parser class:
35 *
36 * - Parser::parse()
37 * produces HTML output
38 * - Parser::preSaveTransform().
39 * produces altered wiki markup.
40 * - Parser::preprocess()
41 * removes HTML comments and expands templates
42 * - Parser::cleanSig() and Parser::cleanSigInSig()
43 * Cleans a signature before saving it to preferences
44 * - Parser::getSection()
45 * Return the content of a section from an article for section editing
46 * - Parser::replaceSection()
47 * Replaces a section by number inside an article
48 * - Parser::getPreloadText()
49 * Removes <noinclude> sections, and <includeonly> tags.
50 *
51 * Globals used:
52 * object: $wgContLang
53 *
54 * @warning $wgUser or $wgTitle or $wgRequest or $wgLang. Keep them away!
55 *
56 * @par Settings:
57 * $wgLocaltimezone
58 * $wgNamespacesWithSubpages
59 *
60 * @par Settings only within ParserOptions:
61 * $wgAllowExternalImages
62 * $wgAllowSpecialInclusion
63 * $wgInterwikiMagic
64 * $wgMaxArticleSize
65 * $wgUseDynamicDates
66 *
67 * @ingroup Parser
68 */
70 /**
71 * Update this version number when the ParserOutput format
72 * changes in an incompatible way, so the parser cache
73 * can automatically discard old data.
74 */
77 /**
78 * Update this version number when the output of serialiseHalfParsedText()
79 * changes in an incompatible way
80 */
83 # Flags for Parser::setFunctionHook
84 # Also available as global constants from Defines.php
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 bug 19052
96 # State constants for the definition list colon extraction
106 # Flags for preprocessToDom
109 # Allowed values for $this->mOutputType
110 # Parameter to startExternalParse().
117 # Marker Suffix needs to be accessible staticly.
120 # Persistent:
134 # Initialised by initialiseVariables()
136 /**
137 * @var MagicWordArray
138 */
141 /**
142 * @var MagicWordArray
143 */
145 var $mConf, $mPreprocessor, $mExtLinkBracketedRegex, $mUrlProtocols; # Initialised in constructor
147 # Cleared with clearState():
148 /**
149 * @var ParserOutput
150 */
154 /**
155 * @var StripState
156 */
160 /**
161 * @var LinkHolderArray
162 */
173 /**
174 * @var User
175 */
178 # Temporary
179 # These are variables reset at least once per parse regardless of $clearState
181 /**
182 * @var ParserOptions
183 */
186 /**
187 * @var Title
188 */
198 /**
199 * @var string
200 */
203 /**
204 * Constructor
205 *
206 * @param $conf array
207 */
216 # Preprocessor_Hash is much faster than Preprocessor_DOM in compiled mode
219 # PECL extension that conflicts with the core DOM extension (bug 13770)
226 }
228 }
230 /**
231 * Reduce memory usage to reduce the impact of circular references
232 */
236 }
239 }
240 }
242 /**
243 * Do various kinds of initialisation on the first call of the parser
244 */
248 }
259 }
261 /**
262 * Clear Parser state
263 *
264 * @private
265 */
270 }
286 /**
287 * Prefix for temporary replacement strings for the multipass parser.
288 * \x07 should never appear in input as it's disallowed in XML.
289 * Using it at the front also gives us a little extra robustness
290 * since it shouldn't match when butted up against identifier-like
291 * string constructs.
292 *
293 * Must not consist of all title characters, or else it will change
294 * the behaviour of <nowiki> in a link.
295 */
300 # Clear these on every parse, bug 4549
308 );
317 # Fix cloning
320 }
324 }
326 /**
327 * Convert wikitext to HTML
328 * Do not call this function recursively.
329 *
330 * @param $text String: text we want to parse
331 * @param $title Title object
332 * @param $options ParserOptions
333 * @param $linestart boolean
334 * @param $clearState boolean
335 * @param $revid Int: number to pass in {{REVISIONID}}
336 * @return ParserOutput a ParserOutput
337 */
338 public function parse( $text, Title $title, ParserOptions $options, $linestart = true, $clearState = true, $revid = null ) {
339 /**
340 * First pass--just handle <nowiki> sections, pass the rest off
341 * to internalParse() which does all the real work.
342 */
351 # Remove the strip marker tag prefix from the input, if present.
354 }
365 }
368 # No more strip!
375 # Clean up special characters, only run once, next-to-last before doBlockLevels
377 # french spaces, last one Guillemet-left
378 # only if there is something before the space
380 # french spaces, Guillemet-right
383 );
390 /**
391 * The input doesn't get language converted if
392 * a) It's disabled
393 * b) Content isn't converted
394 * c) It's a conversion table
395 * d) it is an interface message (which is in the user language)
396 */
399 {
400 # Run convert unconditionally in 1.18-compatible mode
403 # The position of the convert() call should not be changed. it
404 # assumes that the links are all replaced and the only thing left
405 # is the <nowiki> mark.
407 }
408 }
410 /**
411 * A converted title will be provided in the output object if title and
412 * content conversion are enabled, the article text does not contain
413 * a conversion-suppressing double-underscore tag, and no
414 * {{DISPLAYTITLE:...}} is present. DISPLAYTITLE takes precedence over
415 * automatic link conversion.
416 */
421 {
428 }
429 }
443 # attempt to sanitize at least some nesting problems
444 # (bug #2702 and quite a few others)
446 # ''Something [http://www.cool.com cool''] -->
447 # <i>Something</i><a href="http://www.cool.com"..><i>cool></i></a>
450 # fix up an anchor inside another anchor, only
451 # at least for a single single nested link (bug 3695)
454 # fix div inside inline elements- doBlockLevels won't wrap a line which
455 # contains a div, so fix it up here; replace
456 # div with escaped text
459 # remove empty italic or bold tag pairs, some
460 # introduced by rules above
462 );
468 }
474 );
475 }
479 # Information on include size limits, for the benefit of users who try to skirt them
482 $PFreport = "Expensive parser function count: {$this->mExpensiveFunctionCount}/{$this->mOptions->getExpensiveParserFunctionLimit()}\n";
485 "Preprocessor visited node count: {$this->mPPNodeCount}/{$this->mOptions->getMaxPPNodeCount()}\n" .
490 "Highest expansion depth: {$this->mHighestExpansionDepth}/{$this->mOptions->getMaxPPExpandDepth()}\n".
498 }
499 }
510 }
512 /**
513 * Recursive parser entry point that can be called from an extension tag
514 * hook.
515 *
516 * If $frame is not provided, then template variables (e.g., {{{1}}}) within $text are not expanded
517 *
518 * @param $text String: text extension wants to have parsed
519 * @param $frame PPFrame: The frame to use for expanding any template variables
520 *
521 * @return string
522 */
530 }
532 /**
533 * Expand templates and variables in the text, producing valid, static wikitext.
534 * Also removes comments.
535 * @return mixed|string
536 */
542 }
549 }
551 /**
552 * Recursive parser entry point that can be called from an extension tag
553 * hook.
554 *
555 * @param $text String: text to be expanded
556 * @param $frame PPFrame: The frame to use for expanding any template variables
557 * @return String
558 * @since 1.19
559 */
566 }
568 /**
569 * Process the wikitext for the "?preload=" feature. (bug 5210)
570 *
571 * "<noinclude>", "<includeonly>" etc. are parsed as for template
572 * transclusion, comments, templates, arguments, tags hooks and parser
573 * functions are untouched.
574 *
575 * @param $text String
576 * @param $title Title
577 * @param $options ParserOptions
578 * @return String
579 */
581 # Parser (re)initialisation
589 }
591 /**
592 * Get a random string
593 *
594 * @return string
595 */
598 }
600 /**
601 * Set the current user.
602 * Should only be used when doing pre-save transform.
603 *
604 * @param $user Mixed: User object or null (to reset)
605 */
608 }
610 /**
611 * Accessor for mUniqPrefix.
612 *
613 * @return String
614 */
617 # @todo FIXME: This is probably *horribly wrong*
618 # LanguageConverter seems to want $wgParser's uniqPrefix, however
619 # if this is called for a parser cache hit, the parser may not
620 # have ever been initialized in the first place.
621 # Not really sure what the heck is supposed to be going on here.
623 # throw new MWException( "Accessing uninitialized mUniqPrefix" );
624 }
626 }
628 /**
629 * Set the context title
630 *
631 * @param $t Title
632 */
636 }
639 # Strip the fragment to avoid various odd effects
644 }
645 }
647 /**
648 * Accessor for the Title object
649 *
650 * @return Title object
651 */
654 }
656 /**
657 * Accessor/mutator for the Title object
658 *
659 * @param $x Title object or null to just get the current one
660 * @return Title object
661 */
664 }
666 /**
667 * Set the output type
668 *
669 * @param $ot Integer: new value
670 */
673 # Shortcut alias
679 );
680 }
682 /**
683 * Accessor/mutator for the output type
684 *
685 * @param $x int|null New value or null to just get the current one
686 * @return Integer
687 */
690 }
692 /**
693 * Get the ParserOutput object
694 *
695 * @return ParserOutput object
696 */
699 }
701 /**
702 * Get the ParserOptions object
703 *
704 * @return ParserOptions object
705 */
708 }
710 /**
711 * Accessor/mutator for the ParserOptions object
712 *
713 * @param $x ParserOptions New value or null to just get the current one
714 * @return ParserOptions Current ParserOptions object
715 */
718 }
720 /**
721 * @return int
722 */
725 }
727 /**
728 * @param $id int
729 */
732 }
734 /**
735 * Get a language object for use in parser functions such as {{FORMATNUM:}}
736 * @return Language
737 */
740 }
742 /**
743 * Get the target language for the content being parsed. This is usually the
744 * language that the content is in.
745 *
746 * @since 1.19
747 *
748 * @return Language|null
749 */
759 }
762 }
764 /**
765 * Get the language object for language conversion
766 */
773 }
774 }
776 /**
777 * Get a User object either from $this->mUser, if set, or from the
778 * ParserOptions object otherwise
779 *
780 * @return User object
781 */
785 }
787 }
789 /**
790 * Get a preprocessor object
791 *
792 * @return Preprocessor instance
793 */
798 }
800 }
802 /**
803 * Replaces all occurrences of HTML-style comments and the given tags
804 * in the text with a random marker and returns the next text. The output
805 * parameter $matches will be an associative array filled with data in
806 * the form:
807 *
808 * @code
809 * 'UNIQ-xxxxx' => array(
810 * 'element',
811 * 'tag content',
812 * array( 'param' => 'x' ),
813 * '<element param="x">tag content</element>' ) )
814 * @endcode
815 *
816 * @param $elements array list of element names. Comments are always extracted.
817 * @param $text string Source text string.
818 * @param $matches array Out parameter, Array: extracted tags
819 * @param $uniq_prefix string
820 * @return String: stripped text
821 */
835 }
837 # comment
843 # tag
848 }
854 # Empty element tag, <tag />
863 }
867 # No end tag -- let it run out to the end of the text.
873 }
874 }
880 }
882 }
884 /**
885 * Get a list of strippable XML-like elements
886 *
887 * @return array
888 */
891 }
893 /**
894 * Add an item to the strip state
895 * Returns the unique tag which must be inserted into the stripped text
896 * The tag will be replaced with the original text in unstrip()
897 *
898 * @param $text string
899 *
900 * @return string
901 */
907 }
909 /**
910 * parse the wiki syntax used to render tables
911 *
912 * @private
913 * @return string
914 */
933 }
939 # First check if we are starting a new table
952 # Don't do any of the following
956 # We are ending a table
962 }
966 }
970 }
974 # Now we have a table row
977 # Whats after the tag is now only attributes
990 }
994 }
1000 } elseif ( $first_character === '|' || $first_character === '!' || substr( $line , 0 , 2 ) === '|+' ) {
1001 # This might be cell elements, td, th or captions
1005 }
1011 }
1013 # Split up multiple cells on the same line.
1014 # FIXME : This can result in improper nesting of tags processed
1015 # by earlier parser steps, but should avoid splitting up eg
1016 # attribute values containing literal "||".
1021 # Loop through each table cell
1028 }
1033 }
1039 }
1049 }
1053 # A cell could contain both parameters and data
1056 # Bug 553: Note that a '|' inside an invalid link should not
1057 # be mistaken as delimiting cell parameters
1066 }
1070 }
1071 }
1073 }
1075 # Closing open td, tr && table
1079 }
1082 }
1085 }
1088 }
1090 # Remove trailing line-ending (b/c)
1093 }
1095 # special case: don't return empty table
1098 }
1103 }
1105 /**
1106 * Helper function for parse() that transforms wiki markup into
1107 * HTML. Only called for $mOutputType == self::OT_HTML.
1108 *
1109 * @private
1110 *
1111 * @param $text string
1112 * @param $isMain bool
1113 * @param $frame bool
1114 *
1115 * @return string
1116 */
1122 # Hook to suspend the parser in this state
1123 if ( !wfRunHooks( 'ParserBeforeInternalParse', array( &$this, &$text, &$this->mStripState ) ) ) {
1126 }
1128 # if $frame is provided, then use $frame for replacing any variables
1130 # use frame depth to infer how include/noinclude tags should be handled
1131 # depth=0 means this is the top-level document; otherwise it's an included document
1136 }
1140 # if $frame is not provided, then use old-style replaceVariables
1142 }
1145 $text = Sanitizer::removeHTMLtags( $text, array( &$this, 'attributeStripCallback' ), false, array_keys( $this->mTransparentTagHooks ) );
1148 # Tables need to come after variable replacement for things to work
1149 # properly; putting them before other transformations should keep
1150 # exciting things like link expansions from showing up in surprising
1151 # places.
1162 }
1167 # replaceInternalLinks may sometimes leave behind
1168 # absolute URLs, which have to be masked to hide them from replaceExternalLinks
1176 }
1178 /**
1179 * Replace special strings like "ISBN xxx" and "RFC xxx" with
1180 * magic external links.
1181 *
1182 * DML
1183 * @private
1184 *
1185 * @param $text string
1186 *
1187 * @return string
1188 */
1194 '!(?: # Start cases
1198 (?:RFC|PMID)\s+([0-9]+) | # m[4]: RFC or PMID, capture number
1200 (?: 97[89] [\ \-]? )? # optional 13-digit ISBN prefix
1201 (?: [0-9] [\ \-]? ){9} # 9 digits with opt. delimiters
1202 [0-9Xx] # check digit
1207 }
1209 /**
1210 * @throws MWException
1211 * @param $m array
1212 * @return HTML|string
1213 */
1216 # Skip anchor
1219 # Skip HTML element
1222 # Free external link
1225 # RFC or PMID
1239 }
1243 # ISBN
1249 ));
1256 }
1257 }
1259 /**
1260 * Make a free external link, given a user-supplied URL
1261 *
1262 * @param $url string
1263 *
1264 * @return string HTML
1265 * @private
1266 */
1272 # The characters '<' and '>' (which were escaped by
1273 # removeHTMLtags()) should not be included in
1274 # URLs, per RFC 2396.
1279 }
1281 # Move trailing punctuation to $trail
1283 # If there is no left bracket, then consider right brackets fair game too
1286 }
1292 }
1296 # Is this an external image?
1299 # Not an image, make a link
1303 # Register it in the output object...
1304 # Replace unnecessary URL escape codes with their equivalent characters
1307 }
1310 }
1313 /**
1314 * Parse headers and return html
1315 *
1316 * @private
1317 *
1318 * @param $text string
1319 *
1320 * @return string
1321 */
1328 }
1331 }
1333 /**
1334 * Replace single quotes with HTML markup
1335 * @private
1336 *
1337 * @param $text string
1338 *
1339 * @return string the altered text
1340 */
1347 }
1351 }
1353 /**
1354 * Helper function for doAllQuotes()
1355 *
1356 * @param $text string
1357 *
1358 * @return string
1359 */
1365 # First, do some preliminary work. This may shift some apostrophes from
1366 # being mark-up to being text. It also counts the number of occurrences
1367 # of bold and italics mark-ups.
1372 # If there are ever four apostrophes, assume the first is supposed to
1373 # be text, and the remaining three constitute mark-up for bold text.
1378 # If there are more than 5 apostrophes in a row, assume they're all
1379 # text except for the last 5.
1382 }
1383 # Count the number of occurrences of bold and italics mark-ups.
1384 # We are not counting sequences of five apostrophes.
1392 }
1393 }
1394 }
1396 # If there is an odd number of both bold and italics, it is likely
1397 # that one of the bold ones was meant to be an apostrophe followed
1398 # by italics. Which one we cannot know for certain, but it is more
1399 # likely to be one that has a single-letter word before it.
1412 }
1416 }
1420 }
1421 }
1422 }
1424 }
1426 # If there is a single-letter word, use it!
1431 # If not, but there's a multi-letter word, use that one.
1435 # ... otherwise use the first one that has neither.
1436 # (notice that it is possible for all three to be -1 if, for example,
1437 # there is only one pentuple-apostrophe in the line)
1440 }
1441 }
1443 # Now let's actually convert our apostrophic mush to HTML!
1454 }
1467 }
1479 }
1493 }
1494 }
1495 }
1497 }
1498 # Now close all remaining tags. Notice that the order is important.
1501 }
1504 }
1507 }
1508 # There might be lonely ''''', so make sure we have a buffer
1511 }
1513 }
1514 }
1516 /**
1517 * Replace external links (REL)
1518 *
1519 * Note: this is all very hackish and the order of execution matters a lot.
1520 * Make sure to run maintenance/parserTests.php if you change this code.
1521 *
1522 * @private
1523 *
1524 * @param $text string
1525 *
1526 * @return string
1527 */
1533 throw new MWException( "PCRE needs to be compiled with --enable-unicode-properties in order for MediaWiki to function" );
1534 }
1544 # The characters '<' and '>' (which were escaped by
1545 # removeHTMLtags()) should not be included in
1546 # URLs, per RFC 2396.
1551 }
1553 # If the link text is an image URL, replace it with an <img> tag
1554 # This happened by accident in the original parser, but some people used it extensively
1558 }
1562 # Set linktype for CSS - if URL==text, link is essentially free
1565 # No link text, e.g. [http://domain.tld/some.link]
1567 # Autonumber
1572 # Have link text, e.g. [http://domain.tld/some.link text]s
1573 # Check for trail
1575 }
1581 # Use the encoded URL
1582 # This means that users can paste URLs directly into the text
1583 # Funny characters like ö aren't valid in URLs anyway
1584 # This was changed in August 2004
1588 # Register link in the output object.
1589 # Replace unnecessary URL escape codes with the referenced character
1590 # This prevents spammers from hiding links from the filters
1593 }
1597 }
1599 /**
1600 * Get an associative array of additional HTML attributes appropriate for a
1601 * particular external link. This currently may include rel => nofollow
1602 * (depending on configuration, namespace, and the URL's domain) and/or a
1603 * target attribute (depending on configuration).
1604 *
1605 * @param $url String|bool optional URL, to extract the domain from for rel =>
1606 * nofollow if appropriate
1607 * @return Array associative array of HTML attributes
1608 */
1615 {
1617 }
1620 }
1622 }
1624 /**
1625 * Replace unusual URL escape codes with their equivalent characters
1626 *
1627 * @param $url String
1628 * @return String
1629 *
1630 * @todo This can merge genuinely required bits in the path or query string,
1631 * breaking legit URLs. A proper fix would treat the various parts of
1632 * the URL differently; as a workaround, just use the output for
1633 * statistical records, not for actual linking/output.
1634 */
1638 }
1640 /**
1641 * Callback function used in replaceUnusualEscapes().
1642 * Replaces unusual URL escape codes with their equivalent character
1643 *
1644 * @param $matches array
1645 *
1646 * @return string
1647 */
1651 # Is it an unsafe or HTTP reserved character according to RFC 1738?
1653 # No, shouldn't be escaped
1656 # Yes, leave it escaped
1658 }
1659 }
1661 /**
1662 * make an image if it's allowed, either through the global
1663 * option, through the exception, or through the on-wiki whitelist
1664 * @private
1665 *
1666 * $param $url string
1667 *
1668 * @return string
1669 */
1674 # $imagesfrom could be either a single string or an array of strings, parse out the latter
1681 }
1682 }
1687 }
1691 # Image found
1693 }
1694 }
1697 $whitelist = explode( "\n", wfMessage( 'external_image_whitelist' )->inContentLanguage()->text() );
1699 # Sanitize the regex fragment, make it case-insensitive, ignore blank entries/comments
1702 }
1704 # Image matches a whitelist entry
1707 }
1708 }
1709 }
1711 }
1713 /**
1714 * Process [[ ]] wikilinks
1715 *
1716 * @param $s string
1717 *
1718 * @return String: processed text
1719 *
1720 * @private
1721 */
1725 }
1727 /**
1728 * Process [[ ]] wikilinks (RIL)
1729 * @return LinkHolderArray
1730 *
1731 * @private
1732 */
1738 # the % is needed to support urlencoded titles as well
1741 # Match a link having the form [[namespace:link|alternate]]trail
1743 # Match cases where there is no "]]", which might still be images
1745 }
1749 # split the entire text string on occurrences of [[
1751 # get the first element (all text up to first [[), and remove the space we added
1760 # Match the end of a line for a word that's not followed by whitespace,
1761 # e.g. in the case of 'The Arab al[[Razi]]', 'al' will be matched
1763 }
1769 }
1778 }
1781 }
1788 }
1792 # Loop for each link
1794 # Check for excessive memory usage
1796 # Too big
1797 # Do the existence check, replace the link holders and clear the array
1800 }
1809 }
1810 # first link
1814 }
1816 }
1823 # If we get a ] at the beginning of $m[3] that means we have a link that's something like:
1824 # [[Image:Foo.jpg|[http://example.com desc]]] <- having three ] in a row fucks up,
1825 # the real problem is with the $e1 regex
1826 # See bug 1300.
1827 #
1828 # Still some problems for cases where the ] is meant to be outside punctuation,
1829 # and no image is in sight. See bug 2095.
1830 #
1834 )
1835 {
1838 }
1839 # fix up urlencoded title texts
1841 # Should anchors '#' also be rejected?
1843 }
1845 } elseif ( preg_match( $e1_img, $line, $m ) ) { # Invalid, but might be an image with a link in its caption
1850 }
1856 }
1860 # Don't allow internal links to pages containing
1861 # PROTO: where PROTO is a valid URL protocol; these
1862 # should be external links.
1867 }
1869 # Make subpage if necessary
1874 }
1878 # Strip off leading ':'
1880 }
1889 }
1900 # look at the next 'line' to see if we can close it there
1905 }
1908 # the first ]] closes the inner link, the second the image
1914 # if there's exactly one ]] that's fine, we'll keep looking
1917 # if $next_line is invalid too, we need look no further
1920 }
1921 }
1923 # we couldn't find the end of this imageLink, so output it raw
1924 # but don't ignore what might be perfectly normal links in the text we've examined
1927 # note: no $trail, because without an end, there *is* no trail
1930 }
1933 # note: no $trail, because without an end, there *is* no trail
1936 }
1938 }
1944 # Bug 4598 madness. Handle the quotes only if they come from the alternate part
1945 # [[Lista d''e paise d''o munno]] -> <a href="...">Lista d''e paise d''o munno</a>
1946 # [[Criticism of Harry Potter|Criticism of ''Harry Potter'']]
1947 # -> <a href="Criticism of Harry Potter">Criticism of <i>Harry Potter</i></a>
1949 }
1951 # Link not escaped by : , create the various objects
1953 # Interwikis
1955 if ( $iw && $this->mOptions->getInterwikiMagic() && $nottalk && Language::fetchLanguageName( $iw, null, 'mw' ) ) {
1961 }
1968 # if no parameters were passed, $text
1969 # becomes something like "File:Foo.png",
1970 # which we don't want to pass on to the
1971 # image generator
1974 # recursively parse links inside the image caption
1975 # actually, this will parse them in any other parameters, too,
1976 # but it might be hard to fix that, and it doesn't matter ATM
1979 }
1980 # cloak any absolute URLs inside the image markup, so replaceExternalLinks() won't touch them
1985 }
1988 }
1998 }
2004 /**
2005 * Strip the whitespace Category links produce, see bug 87
2006 * @todo We might want to use trim($tmp, "\n") here.
2007 */
2012 }
2013 }
2015 # Self-link checking
2020 }
2021 }
2023 # NS_MEDIA is a pseudo-namespace for linking directly to a file
2024 # @todo FIXME: Should do batch file existence checks, see comment below
2027 # Give extensions a chance to select the file revision for us
2032 # Fetch and register the file (file title may be different via hooks)
2034 # Cloak with NOPARSE to avoid replacement in replaceExternalLinks
2039 }
2042 # Some titles, such as valid special pages or files in foreign repos, should
2043 # be shown as bluelinks even though they're not included in the page table
2044 #
2045 # @todo FIXME: isAlwaysKnown() can be expensive for file links; we should really do
2046 # batch file existence checks for NS_FILE and NS_MEDIA
2051 # Links will be added to the output link list after checking
2053 }
2055 }
2058 }
2060 /**
2061 * Render a forced-blue link inline; protect against double expansion of
2062 * URLs if we're in a mode that prepends full URL prefixes to internal links.
2063 * Since this little disaster has to split off the trail text to avoid
2064 * breaking URLs in the following text without breaking trails on the
2065 * wiki links, it's been made into a horrible function.
2066 *
2067 * @param $nt Title
2068 * @param $text String
2069 * @param $query Array or String
2070 * @param $trail String
2071 * @param $prefix String
2072 * @return String: HTML-wikitext mix oh yuck
2073 */
2079 }
2082 }
2087 }
2089 /**
2090 * Insert a NOPARSE hacky thing into any inline links in a chunk that's
2091 * going to go through further parsing steps before inline URL expansion.
2092 *
2093 * Not needed quite as much as it used to be since free links are a bit
2094 * more sensible these days. But bracketed links are still an issue.
2095 *
2096 * @param $text String: more-or-less HTML
2097 * @return String: less-or-more HTML with NOPARSE bits
2098 */
2102 }
2104 /**
2105 * Return true if subpage links should be expanded on this page.
2106 * @return Boolean
2107 */
2109 # Some namespaces don't allow subpages
2111 }
2113 /**
2114 * Handle link to subpage if necessary
2115 *
2116 * @param $target String: the source of the link
2117 * @param &$text String: the link text, modified as necessary
2118 * @return string the full name of the link
2119 * @private
2120 */
2123 }
2125 /**#@+
2126 * Used by doBlockLevels()
2127 * @private
2128 *
2129 * @return string
2130 */
2135 }
2139 }
2141 /**
2142 * getCommon() returns the length of the longest common substring
2143 * of both arguments, starting at the beginning of both.
2144 * @private
2145 *
2146 * @param $st1 string
2147 * @param $st2 string
2148 *
2149 * @return int
2150 */
2156 }
2161 }
2162 }
2164 }
2166 /**
2167 * These next three functions open, continue, and close the list
2168 * element appropriate to the prefix character passed into them.
2169 * @private
2170 *
2171 * @param $char string
2172 *
2173 * @return string
2174 */
2189 }
2192 }
2194 /**
2195 * TODO: document
2196 * @param $char String
2197 * @private
2198 *
2199 * @return string
2200 */
2208 }
2215 }
2216 }
2218 }
2220 /**
2221 * TODO: document
2222 * @param $char String
2223 * @private
2224 *
2225 * @return string
2226 */
2238 }
2241 }
2243 }
2244 /**#@-*/
2246 /**
2247 * Make lists from lines starting with ':', '*', '#', etc. (DBL)
2248 *
2249 * @param $text String
2250 * @param $linestart Boolean: whether or not this is at the start of a line.
2251 * @private
2252 * @return string the lists rendered as HTML
2253 */
2257 # Parsing through the text line by line. The main thing
2258 # happening here is handling of block-level elements p, pre,
2259 # and making lists from lines starting with * # : etc.
2260 #
2269 # Fix up $linestart
2274 }
2275 # * = ul
2276 # # = ol
2277 # ; = dt
2278 # : = dd
2283 # If not in a <pre> element, scan for and figure out what prefixes are there.
2285 # Multiple prefixes may abut each other for nested lists.
2289 # eh?
2290 # ; and : are both from definition-lists, so they're equivalent
2291 # for the purposes of determining whether or not we need to open/close
2292 # elements.
2297 # Don't interpret any other prefixes in preformatted text
2301 }
2303 # List generation
2305 # Same as the last item, so no need to deal with nesting or opening stuff
2310 # The one nasty exception: definition lists work like this:
2311 # ; title : definition text
2312 # So we check for : in the remainder text to split up the
2313 # title and definition, without b0rking links.
2318 }
2319 }
2321 # We need to open or close prefixes, or both.
2323 # Either open or close a level...
2327 # Close all the prefixes which aren't shared.
2331 }
2333 # Continue the current prefix if appropriate.
2336 }
2338 # Open prefixes where appropriate.
2344 # @todo FIXME: This is dupe of code above
2348 }
2349 }
2351 }
2353 }
2355 # If we have no prefixes, go to paragraph mode.
2358 # No prefix (not in list)--go to paragraph mode
2359 # XXX: use a stack for nestable elements like span, table and div
2360 $openmatch = preg_match('/(?:<table|<blockquote|<h1|<h2|<h3|<h4|<h5|<h6|<pre|<tr|<p|<ul|<ol|<li|<\\/tr|<\\/td|<\\/th)/iS', $t );
2363 '<td|<th|<\\/?div|<hr|<\\/pre|<\\/p|'.$this->mUniqPrefix.'-pre|<\\/li|<\\/ul|<\\/ol|<\\/?center)/iS', $t );
2366 # TODO bug 5718: paragraph closed
2370 }
2374 # pre
2379 }
2382 # paragraph
2395 }
2396 }
2405 }
2406 }
2407 }
2408 }
2410 }
2411 # somewhere above we forget to get out of pre block (bug 785)
2414 }
2417 }
2418 }
2422 }
2426 }
2430 }
2432 /**
2433 * Split up a string on ':', ignoring any occurrences inside tags
2434 * to prevent illegal overlapping.
2435 *
2436 * @param $str String the string to split
2437 * @param &$before String set to everything before the ':'
2438 * @param &$after String set to everything after the ':'
2439 * @return String the position of the ':', or false if none found
2440 */
2446 # Nothing to find!
2449 }
2453 # Easy; no tag nesting to worry about
2458 }
2460 # Ugly state machine to walk through avoiding tags.
2468 # (Using the number is a performance hack for common cases)
2472 # Could be either a <start> tag or an </end> tag
2477 # We found it!
2482 }
2483 # Embedded in a tag; don't break it.
2486 # Skip ahead looking for something interesting
2489 # Nothing else interesting
2492 }
2496 # We found it!
2501 }
2502 }
2504 # Nothing else interesting to find; abort!
2505 # We're nested, but there's no close tags left. Abort!
2507 }
2508 # Skip ahead to next tag start
2511 }
2514 # In a <tag>
2521 # Slash may be followed by >?
2525 # ignore
2526 }
2537 # Illegal early close? This shouldn't happen D:
2542 }
2545 # In a </tag>
2552 }
2554 }
2558 # Yes, a self-closed tag <blah/>
2561 # Probably we're jumping the gun, and this is an attribute
2563 }
2568 }
2575 }
2582 }
2586 }
2587 }
2592 }
2595 }
2597 /**
2598 * Return value of a magic variable (like PAGENAME)
2599 *
2600 * @private
2601 *
2602 * @param $index integer
2603 * @param $frame PPFrame
2604 *
2605 * @return string
2606 */
2612 // If no title set, bad things are going to happen
2613 // later. Title should always be set since this
2614 // should only be called in the middle of a parse
2615 // operation (but the unit-tests do funky stuff)
2618 }
2620 /**
2621 * Some of these require message or data lookups and can be
2622 * expensive to check many times.
2623 */
2627 }
2628 }
2633 # Use the time zone
2638 }
2652 }
2721 $value = wfEscapeWikiText( wfUrlEncode( str_replace( ' ', '_', $this->mTitle->getBaseText() ) ) );
2729 }
2737 }
2750 # 0 means the page doesn't exist in the database,
2751 # which means the user is previewing a new page.
2752 # The vary-revision flag must be set, because the magic word
2753 # will have a different value once the page is saved.
2756 }
2760 # Let the edit saving system know we should parse the page
2761 # *after* a revision ID has been assigned.
2767 # Let the edit saving system know we should parse the page
2768 # *after* a revision ID has been assigned. This is for null edits.
2774 # Let the edit saving system know we should parse the page
2775 # *after* a revision ID has been assigned. This is for null edits.
2781 # Let the edit saving system know we should parse the page
2782 # *after* a revision ID has been assigned. This is for null edits.
2788 # Let the edit saving system know we should parse the page
2789 # *after* a revision ID has been assigned. This is for null edits.
2795 # Let the edit saving system know we should parse the page
2796 # *after* a revision ID has been assigned. This is for null edits.
2802 # Let the edit saving system know we should parse the page
2803 # *after* a revision ID has been assigned. This is for null edits.
2809 # Let the edit saving system know we should parse the page
2810 # *after* a revision ID has been assigned. This is for null edits.
2825 $value = $this->mTitle->canTalk() ? str_replace( '_',' ',$this->mTitle->getTalkNsText() ) : '';
2849 # @bug 4594 PHP5 has it zero padded, PHP4 does not, cast to
2850 # int to remove the padding
2869 # @bug 4594 PHP5 has it zero padded, PHP4 does not, cast to
2870 # int to remove the padding
2930 if ( wfRunHooks( 'ParserGetVariableValueSwitch', array( &$this, &$this->mVarCache, &$index, &$ret, &$frame ) ) ) {
2934 }
2935 }
2939 }
2942 }
2944 /**
2945 * initialise the magic variables (like CURRENTMONTHNAME) and substitution modifiers
2946 *
2947 * @private
2948 */
2957 }
2959 /**
2960 * Preprocess some wikitext and return the document tree.
2961 * This is the ghost of replace_variables().
2962 *
2963 * @param $text String: The text to parse
2964 * @param $flags Integer: bitwise combination of:
2965 * self::PTD_FOR_INCLUSION Handle "<noinclude>" and "<includeonly>" as if the text is being
2966 * included. Default is to assume a direct page view.
2967 *
2968 * The generated DOM tree must depend only on the input text and the flags.
2969 * The DOM tree must be the same in OT_HTML and OT_WIKI mode, to avoid a regression of bug 4899.
2970 *
2971 * Any flag added to the $flags parameter here, or any other parameter liable to cause a
2972 * change in the DOM tree for a given text, must be passed through the section identifier
2973 * in the section edit link and thus back to extractSections().
2974 *
2975 * The output of this function is currently only cached in process memory, but a persistent
2976 * cache may be implemented at a later date which takes further advantage of these strict
2977 * dependency requirements.
2978 *
2979 * @private
2980 *
2981 * @return PPNode
2982 */
2986 }
2988 /**
2989 * Return a three-element array: leading whitespace, string contents, trailing whitespace
2990 *
2991 * @param $s string
2992 *
2993 * @return array
2994 */
3004 }
3006 }
3008 /**
3009 * Replace magic variables, templates, and template arguments
3010 * with the appropriate text. Templates are substituted recursively,
3011 * taking care to avoid infinite loops.
3012 *
3013 * Note that the substitution depends on value of $mOutputType:
3014 * self::OT_WIKI: only {{subst:}} templates
3015 * self::OT_PREPROCESS: templates but not extension tags
3016 * self::OT_HTML: all templates and extension tags
3017 *
3018 * @param $text String the text to transform
3019 * @param $frame PPFrame Object describing the arguments passed to the template.
3020 * Arguments may also be provided as an associative array, as was the usual case before MW1.12.
3021 * Providing arguments this way may be useful for extensions wishing to perform variable replacement explicitly.
3022 * @param $argsOnly Boolean only do argument (triple-brace) expansion, not double-brace expansion
3023 * @private
3024 *
3025 * @return string
3026 */
3028 # Is there any text? Also, Prevent too big inclusions!
3031 }
3037 wfDebug( __METHOD__." called using plain parameters instead of a PPFrame instance. Creating custom frame.\n" );
3039 }
3047 }
3049 /**
3050 * Clean up argument array - refactored in 1.9 so parserfunctions can use it, too.
3051 *
3052 * @param $args array
3053 *
3054 * @return array
3055 */
3068 }
3071 }
3072 }
3073 }
3076 }
3078 /**
3079 * Warn the user when a parser limitation is reached
3080 * Will warn at most once the user per limitation type
3081 *
3082 * @param $limitationType String: should be one of:
3083 * 'expensive-parserfunction' (corresponding messages:
3084 * 'expensive-parserfunction-warning',
3085 * 'expensive-parserfunction-category')
3086 * 'post-expand-template-argument' (corresponding messages:
3087 * 'post-expand-template-argument-warning',
3088 * 'post-expand-template-argument-category')
3089 * 'post-expand-template-inclusion' (corresponding messages:
3090 * 'post-expand-template-inclusion-warning',
3091 * 'post-expand-template-inclusion-category')
3092 * @param $current int|null Current value
3093 * @param $max int|null Maximum allowed, when an explicit limit has been
3094 * exceeded, provide the values (optional)
3095 */
3097 # does no harm if $current and $max are present but are unnecessary for the message
3102 }
3104 /**
3105 * Return the text of a template, after recursively
3106 * replacing any variables or templates within the template.
3107 *
3108 * @param $piece Array: the parts of the template
3109 * $piece['title']: the title, i.e. the part before the |
3110 * $piece['parts']: the parameter array
3111 * $piece['lineStart']: whether the brace was at the start of a line
3112 * @param $frame PPFrame The current frame, contains template arguments
3113 * @return String: the text of the template
3114 * @private
3115 */
3121 # Flags
3129 # Title object, where $text came from
3132 # $part1 is the bit before the first |, and must contain only title characters.
3133 # Various prefixes will be stripped from it later.
3138 # Original title text preserved for various purposes
3141 # $args is a list of argument nodes, starting from index 0, not including $part1
3142 # @todo FIXME: If piece['parts'] is null then the call to getLength() below won't work b/c this $args isn't an object
3148 # SUBST
3154 # Possibilities for substMatch: "subst", "safesubst" or FALSE
3155 # Decide whether to expand template or keep wikitext as-is.
3161 }
3167 }
3168 }
3173 }
3174 }
3176 # Variables
3183 }
3185 }
3186 }
3188 # MSG, MSGNW and RAW
3190 # Check for MSGNW:
3195 # Remove obsolete MSG:
3198 }
3200 # Check for RAW:
3204 }
3205 }
3208 # Parser functions
3214 # Case sensitive functions
3219 # Case insensitive functions
3225 }
3226 }
3233 # Add a frame parameter, and pass the arguments as an array
3238 }
3241 # Convert arguments to plain text
3244 }
3246 }
3248 # Workaround for PHP bug 35229 and similar
3254 }
3264 }
3266 # Extract flags into the local scope
3267 # This allows callers to set flags such as nowiki, found, etc.
3271 }
3275 }
3277 }
3278 }
3280 }
3282 # Finish mangling title and then check for loops.
3283 # Set $title to a Title object and $titleText to the PDBK
3286 # Split the title into page and subpage
3291 }
3295 # Check for language variants if the template is not found
3298 }
3299 # Do recursion depth check
3307 }
3308 }
3309 }
3311 # Load from database
3314 # Too many unique items can kill profiling DBs/collectors
3317 }
3323 {
3324 // Pass the template arguments as URL parameters.
3325 // "uselang" will have no effect since the Language object
3326 // is forced to the one defined in ParserOptions.
3334 }
3335 }
3337 // Create a new context to execute the special page
3350 }
3359 }
3360 }
3362 # If the title is valid but undisplayable, make a link to it
3366 }
3368 # Interwiki transclusion
3374 # Preprocess it like a template
3377 }
3379 }
3381 # Do infinite loop check
3382 # This has to be done after redirect resolution to avoid infinite loops via redirects
3389 }
3391 }
3393 # If we haven't found text to substitute by now, we're done
3394 # Recover the source wikitext and return it
3399 }
3402 }
3404 # Expand DOM-style return values in a child frame
3406 # Clean up argument array
3412 # Expansion is eligible for the empty-frame cache
3418 }
3420 # Uncached expansion
3422 }
3423 }
3427 }
3431 }
3433 # Replace raw HTML by a placeholder
3437 # Escape nowiki-style return values
3442 {
3443 # Bug 529: if the template begins with a table or block-level
3444 # element, it should be treated as beginning a new line.
3445 # This behaviour is somewhat controversial.
3447 }
3450 # Error, oversize inclusion
3452 # Make a working, properly escaped link if possible (bug 23588)
3455 # This will probably not be a working link, but at least it may
3456 # provide some hint of where the problem is
3459 }
3460 $text .= $this->insertStripItem( '<!-- WARNING: template omitted, post-expand include size too large -->' );
3462 }
3468 }
3472 }
3474 /**
3475 * Get the semi-parsed DOM representation of a template with a given title,
3476 * and its redirect destination title. Cached.
3477 *
3478 * @param $title Title
3479 *
3480 * @return array
3481 */
3490 }
3493 }
3495 # Cache miss, go to the database
3501 }
3509 }
3512 }
3514 /**
3515 * Fetch the unparsed text of a template and register a reference to it.
3516 * @param Title $title
3517 * @return Array ( string or false, Title )
3518 */
3520 $templateCb = $this->mOptions->getTemplateCallback(); # Defaults to Parser::statelessFetchTemplate()
3527 }
3528 }
3530 }
3532 /**
3533 * Fetch the unparsed text of a template and register a reference to it.
3534 * @param Title $title
3535 * @return mixed string or false
3536 */
3540 }
3542 /**
3543 * Static function to get a template
3544 * Can be overridden via ParserOptions::setTemplateCallback().
3545 *
3546 * @param $title Title
3547 * @param $parser Parser
3548 *
3549 * @return array
3550 */
3556 # Loop to fetch the article, with up to 1 redirect
3558 # Give extensions a chance to select the revision instead
3569 );
3571 }
3572 # Get the revision
3577 # If there is no current revision, there is no page
3581 }
3588 # We fetched a rev from a different title; register it too...
3593 }
3603 }
3607 }
3610 }
3611 # Redirect?
3614 }
3619 }
3621 /**
3622 * Fetch a file and its title and register a reference to it.
3623 * If 'broken' is a key in $options then the file will appear as a broken thumbnail.
3624 * @param Title $title
3625 * @param Array $options Array of options to RepoGroup::findFile
3626 * @return File|bool
3627 */
3631 }
3633 /**
3634 * Fetch a file and its title and register a reference to it.
3635 * If 'broken' is a key in $options then the file will appear as a broken thumbnail.
3636 * @param Title $title
3637 * @param Array $options Array of options to RepoGroup::findFile
3638 * @return Array ( File or false, Title of file )
3639 */
3647 }
3650 # Register the file as a dependency...
3653 # Update fetched file title
3656 # This file was not a redirect, but the title does not match.
3657 # Register under the new name because otherwise the link will
3658 # get lost.
3660 }
3661 }
3663 }
3665 /**
3666 * Transclude an interwiki link.
3667 *
3668 * @param $title Title
3669 * @param $action
3670 *
3671 * @return string
3672 */
3678 }
3684 }
3686 }
3688 /**
3689 * @param $url string
3690 * @return Mixed|String
3691 */
3700 }
3705 }
3712 );
3714 }
3716 /**
3717 * Triple brace replacement -- used for template arguments
3718 * @private
3719 *
3720 * @param $piece array
3721 * @param $frame PPFrame
3722 *
3723 * @return array
3724 */
3735 && (
3739 )
3740 ) {
3741 # No match in frame, use the supplied default
3743 }
3747 }
3750 # No match anywhere
3752 }
3755 }
3760 }
3764 }
3766 /**
3767 * Return the text to be used for a given extension tag.
3768 * This is the ghost of strip().
3769 *
3770 * @param $params array Associative array of parameters:
3771 * name PPNode for the tag name
3772 * attr PPNode for unparsed text where tag attributes are thought to be
3773 * attributes Optional associative array of parsed attributes
3774 * inner Contents of extension element
3775 * noClose Original text did not have a close tag
3776 * @param $frame PPFrame
3777 *
3778 * @return string
3779 */
3784 $marker = "{$this->mUniqPrefix}-$name-" . sprintf( '%08X', $this->mMarkerIndex++ ) . self::MARKER_SUFFIX;
3792 }
3798 }
3801 # Workaround for PHP bug 35229 and similar
3804 }
3811 }
3817 }
3820 # Extract flags to local scope (to override $markerType)
3825 }
3829 }
3834 }
3835 }
3841 }
3842 }
3852 }
3854 }
3856 /**
3857 * Increment an include size counter
3858 *
3859 * @param $type String: the type of expansion
3860 * @param $size Integer: the size of the text
3861 * @return Boolean: false if this inclusion would take it over the maximum, true otherwise
3862 */
3869 }
3870 }
3872 /**
3873 * Increment the expensive function count
3874 *
3875 * @return Boolean: false if the limit has been exceeded
3876 */
3880 }
3882 /**
3883 * Strip double-underscore items like __NOGALLERY__ and __NOTOC__
3884 * Fills $this->mDoubleUnderscores, returns the modified text
3885 *
3886 * @param $text string
3887 *
3888 * @return string
3889 */
3893 # The position of __TOC__ needs to be recorded
3899 # Set a placeholder. At the end we'll fill it in with the TOC.
3902 # Only keep the first one.
3904 }
3906 # Now match and remove the rest of them
3912 }
3915 }
3916 if ( isset( $this->mDoubleUnderscores['hiddencat'] ) && $this->mTitle->getNamespace() == NS_CATEGORY ) {
3918 }
3919 # (bug 8068) Allow control over whether robots index a page.
3920 #
3921 # @todo FIXME: Bug 14899: __INDEX__ always overrides __NOINDEX__ here! This
3922 # is not desirable, the last one on the page should win.
3926 }
3930 }
3932 # Cache all double underscores in the database
3935 }
3939 }
3941 /**
3942 * Add a tracking category, getting the title from a system message,
3943 * or print a debug message if the title is invalid.
3944 *
3945 * @param $msg String: message key
3946 * @return Boolean: whether the addition was successful
3947 */
3952 }
3953 // Important to parse with correct title (bug 31469)
3959 # Allow tracking categories to be disabled by setting them to "-"
3962 }
3971 }
3972 }
3974 /**
3975 * This function accomplishes several tasks:
3976 * 1) Auto-number headings if that option is enabled
3977 * 2) Add an [edit] link to sections for users who have enabled the option and can edit the page
3978 * 3) Add a Table of contents on the top for users who have enabled the option
3979 * 4) Auto-anchor headings
3980 *
3981 * It loops through all headlines, collects the necessary data, then splits up the
3982 * string and re-inserts the newly formatted headlines.
3983 *
3984 * @param $text String
3985 * @param $origText String: original, untouched wikitext
3986 * @param $isMain Boolean
3987 * @return mixed|string
3988 * @private
3989 */
3993 # Inhibit editsection links if requested in the page
3999 }
4002 }
4004 # Get all headlines for numbering them and adding funky stuff like [edit]
4005 # links - this is for later, but we need the number of headlines right now
4007 $numMatches = preg_match_all( '/<H(?P<level>[1-6])(?P<attrib>.*?'.'>)(?P<header>.*?)<\/H[1-6] *>/i', $text, $matches );
4009 # if there are fewer than 4 headlines in the article, do not show TOC
4010 # unless it's been explicitly enabled.
4014 # Allow user to stipulate that a page should have a "new section"
4015 # link added via __NEWSECTIONLINK__
4018 }
4020 # Allow user to remove the "new section"
4021 # link via __NONEWSECTIONLINK__
4024 }
4026 # if the string __FORCETOC__ (not case-sensitive) occurs in the HTML,
4027 # override above conditions and always show TOC above first header
4031 }
4033 # headline counter
4037 # Ugh .. the TOC should have neat indentation levels which can be
4038 # passed to the skin functions. These are determined here
4070 }
4074 }
4078 # Increase TOC level
4085 }
4087 # Decrease TOC level, find level to jump to
4091 # Found last matching level
4095 # Found first matching level below current level
4098 }
4099 }
4102 }
4105 # Unindent only if the previous toc level was shown :p
4110 }
4111 }
4113 # No change in level, end TOC line
4116 }
4117 }
4121 # count number of headlines for each level
4128 }
4131 }
4132 }
4134 # The safe header is a version of the header text safe to use for links
4136 # Remove link placeholders by the link text.
4137 # <!--LINK number-->
4138 # turns into
4139 # link text with suffix
4140 # Do this before unstrip since link text can contain strip markers
4143 # Avoid insertion of weird stuff like <math> by expanding the relevant sections
4146 # Strip out HTML (first regex removes any tag not allowed)
4147 # Allowed tags are:
4148 # * <sup> and <sub> (bug 8393)
4149 # * <i> (bug 26375)
4150 # * <b> (r105284)
4151 # * <span dir="rtl"> and <span dir="ltr"> (bug 35167)
4152 #
4153 # We strip any parameter from accepted tags (second regex), except dir="rtl|ltr" from <span>,
4154 # to allow setting directionality in toc items.
4156 array( '#<(?!/?(span|sup|sub|i|b)(?: [^>]*)?>).*?'.'>#', '#<(/?(?:span(?: dir="(?:rtl|ltr)")?|sup|sub|i|b))(?: .*?)?'.'>#' ),
4158 $safeHeadline
4159 );
4162 # For the anchor, strip out HTML-y stuff period
4166 # Save headline for section edit hint before it's escaped
4170 # For reverse compatibility, provide an id that's
4171 # HTML4-compatible, like we used to.
4172 #
4173 # It may be worth noting, academically, that it's possible for
4174 # the legacy anchor to conflict with a non-legacy headline
4175 # anchor on the page. In this case likely the "correct" thing
4176 # would be to either drop the legacy anchors or make sure
4177 # they're numbered first. However, this would require people
4178 # to type in section names like "abc_.D7.93.D7.90.D7.A4"
4179 # manually, so let's not bother worrying about it.
4185 # No reason to have both (in fact, we can't)
4187 }
4192 }
4194 # HTML names must be case-insensitively unique (bug 10721).
4195 # This does not apply to Unicode characters per
4196 # http://dev.w3.org/html5/spec/infrastructure.html#case-sensitivity-and-string-comparison
4197 # @todo FIXME: We may be changing them depending on the current locale.
4203 }
4205 # count how many in assoc. array so we can track dupes in anchors
4210 }
4215 }
4217 # Don't number the heading if it is the only one (looks silly)
4219 # the two are different if the line contains a link
4220 $headline = Html::element( 'span', array( 'class' => 'mw-headline-number' ), $numbering ) . ' ' . $headline;
4221 }
4223 # Create the anchor for linking from the TOC to the section
4228 }
4231 }
4235 }
4237 # Add the section to the section tree
4238 # Find the DOM node for this header
4244 }
4245 }
4249 }
4259 );
4261 # give headline the correct <h#> tag
4263 // Output edit section links as markers with styles that can be customized by skins
4265 # Put a T flag in the section identifier, to indicate to extractSections()
4266 # that sections inside <includeonly> should be counted.
4270 }
4271 // We use a bit of pesudo-xml for editsection markers. The language converter is run later on
4272 // Using a UNIQ style marker leads to the converter screwing up the tokens when it converts stuff
4273 // And trying to insert strip tags fails too. At this point all real inputted tags have already been escaped
4274 // so we don't have to worry about a user trying to input one of these markers directly.
4275 // We use a page and section attribute to stop the language converter from converting these important bits
4276 // of data, but put the headline hint inside a content block because the language converter is supposed to
4277 // be able to convert that piece of data.
4284 }
4287 }
4293 }
4297 # Never ever show TOC if no headers
4300 }
4305 }
4308 }
4312 }
4314 # split up and insert constructed headlines
4318 // build an array of document sections
4321 // $head is zero-based, sections aren't.
4326 }
4328 /**
4329 * Send a hook, one per section.
4330 * The idea here is to be able to make section-level DIVs, but to do so in a
4331 * lower-impact, more correct way than r50769
4332 *
4333 * $this : caller
4334 * $section : the section number
4335 * &$sectionContent : ref to the content of the section
4336 * $showEditLinks : boolean describing whether this section has an edit link
4337 */
4341 }
4344 // append the TOC at the beginning
4345 // Top anchor now in skin
4347 }
4355 }
4356 }
4358 /**
4359 * Transform wiki markup when saving a page by doing "\r\n" -> "\n"
4360 * conversion, substitting signatures, {{subst:}} templates, etc.
4361 *
4362 * @param $text String: the text to transform
4363 * @param $title Title: the Title object for the current article
4364 * @param $user User: the User object describing the current user
4365 * @param $options ParserOptions: parsing options
4366 * @param $clearState Boolean: whether to clear the parser state first
4367 * @return String: the altered wiki markup
4368 */
4369 public function preSaveTransform( $text, Title $title, User $user, ParserOptions $options, $clearState = true ) {
4375 );
4379 }
4385 }
4387 /**
4388 * Pre-save transform helper function
4389 * @private
4390 *
4391 * @param $text string
4392 * @param $user User
4393 *
4394 * @return string
4395 */
4399 # Note: This is the timestamp saved as hardcoded wikitext to
4400 # the database, we use $wgContLang here in order to give
4401 # everyone the same signature and use the default one rather
4402 # than the one selected in each user's preferences.
4403 # (see also bug 12815)
4409 }
4417 # Allow translation of timezones through wiki. date() can return
4418 # whatever crap the system uses, localised or not, so we cannot
4419 # ship premade translations.
4424 }
4430 # Variable replacement
4431 # Because mOutputType is OT_WIKI, this will only process {{subst:xxx}} type tags
4434 # This works almost by chance, as the replaceVariables are done before the getUserSig(),
4435 # which may corrupt this parser instance via its wfMessage()->text() call-
4437 # Signatures
4443 ) );
4445 # Context links: [[|name]] and [[name (context)|]]
4451 $p3 = "/\[\[(:?$nc+:|:|)($tc+?)( ?\\($tc+\\)|)((?:, |，)$tc+|)\\|]]/"; # [[ns:page (context), context|]]
4454 # try $p1 first, to turn "[[A, B (C)|]]" into "[[A, B (C)|A, B]]"
4466 # if there's no context, don't bother duplicating the title
4468 }
4470 # Trim trailing whitespace
4474 }
4476 /**
4477 * Fetch the user's signature text, if any, and normalize to
4478 * validated, ready-to-insert wikitext.
4479 * If you have pre-fetched the nickname or the fancySig option, you can
4480 * specify them here to save a database query.
4481 * Do not reuse this parser instance after calling getUserSig(),
4482 * as it may have changed if it's the $wgParser.
4483 *
4484 * @param $user User
4485 * @param $nickname String|bool nickname to use or false to use user's default nickname
4486 * @param $fancySig Boolean|null whether the nicknname is the complete signature
4487 * or null to use default value
4488 * @return string
4489 */
4495 # If not given, retrieve from the user object.
4501 }
4509 # Sig. might contain markup; validate this
4511 # Validated; clean up (if needed) and return it
4514 # Failed to validate; fall back to the default
4517 }
4518 }
4520 # Make sure nickname doesnt get a sig in a sig
4523 # If we're still here, make it a link to the user page
4528 return wfMessage( $msgName, $userText, $nickText )->inContentLanguage()->title( $this->getTitle() )->text();
4529 }
4531 /**
4532 * Check that the user's signature contains no bad XML
4533 *
4534 * @param $text String
4535 * @return mixed An expanded string, or false if invalid.
4536 */
4539 }
4541 /**
4542 * Clean up signature text
4543 *
4544 * 1) Strip ~~~, ~~~~ and ~~~~~ out of signatures @see cleanSigInSig
4545 * 2) Substitute all transclusions
4546 *
4547 * @param $text String
4548 * @param $parsing bool Whether we're cleaning (preferences save) or parsing
4549 * @return String: signature text
4550 */
4555 }
4557 # Option to disable this feature
4560 }
4562 # @todo FIXME: Regex doesn't respect extension tags or nowiki
4563 # => Move this logic to braceSubstitution()
4565 $substRegex = '/\{\{(?!(?:' . $substWord->getBaseRegex() . '))/x' . $substWord->getRegexCase();
4576 }
4579 }
4581 /**
4582 * Strip ~~~, ~~~~ and ~~~~~ out of signatures
4583 *
4584 * @param $text String
4585 * @return String: signature text with /~{3,5}/ removed
4586 */
4590 }
4592 /**
4593 * Set up some variables which are usually set up in parse()
4594 * so that an external function can call some class members with confidence
4595 *
4596 * @param $title Title|null
4597 * @param $options ParserOptions
4598 * @param $outputType
4599 * @param $clearState bool
4600 */
4601 public function startExternalParse( Title $title = null, ParserOptions $options, $outputType, $clearState = true ) {
4603 }
4605 /**
4606 * @param $title Title|null
4607 * @param $options ParserOptions
4608 * @param $outputType
4609 * @param $clearState bool
4610 */
4611 private function startParse( Title $title = null, ParserOptions $options, $outputType, $clearState = true ) {
4617 }
4618 }
4620 /**
4621 * Wrapper for preprocess()
4622 *
4623 * @param $text String: the text to preprocess
4624 * @param $options ParserOptions: options
4625 * @param $title Title object or null to use $wgTitle
4626 * @return String
4627 */
4631 # Guard against infinite recursion
4634 }
4641 }
4643 # It's not uncommon having a null $wgTitle in scripts. See r80898
4644 # Create a ghost title in such case
4646 }
4652 }
4654 /**
4655 * Create an HTML-style tag, e.g. "<yourtag>special text</yourtag>"
4656 * The callback should have the following form:
4657 * function myParserHook( $text, $params, $parser, $frame ) { ... }
4658 *
4659 * Transform and return $text. Use $parser for any required context, e.g. use
4660 * $parser->getTitle() and $parser->getOptions() not $wgTitle or $wgOut->mParserOptions
4661 *
4662 * Hooks may return extended information by returning an array, of which the
4663 * first numbered element (index 0) must be the return string, and all other
4664 * entries are extracted into local variables within an internal function
4665 * in the Parser class.
4666 *
4667 * This interface (introduced r61913) appears to be undocumented, but
4668 * 'markerName' is used by some core tag hooks to override which strip
4669 * array their results are placed in. **Use great caution if attempting
4670 * this interface, as it is not documented and injudicious use could smash
4671 * private variables.**
4672 *
4673 * @param $tag Mixed: the tag to use, e.g. 'hook' for "<hook>"
4674 * @param $callback Mixed: the callback function (and object) to use for the tag
4675 * @return Mixed|null The old value of the mTagHooks array associated with the hook
4676 */
4681 }
4686 }
4689 }
4691 /**
4692 * As setHook(), but letting the contents be parsed.
4693 *
4694 * Transparent tag hooks are like regular XML-style tag hooks, except they
4695 * operate late in the transformation sequence, on HTML instead of wikitext.
4696 *
4697 * This is probably obsoleted by things dealing with parser frames?
4698 * The only extension currently using it is geoserver.
4699 *
4700 * @since 1.10
4701 * @todo better document or deprecate this
4702 *
4703 * @param $tag Mixed: the tag to use, e.g. 'hook' for "<hook>"
4704 * @param $callback Mixed: the callback function (and object) to use for the tag
4705 * @return Mixed|null The old value of the mTagHooks array associated with the hook
4706 */
4711 }
4712 $oldVal = isset( $this->mTransparentTagHooks[$tag] ) ? $this->mTransparentTagHooks[$tag] : null;
4716 }
4718 /**
4719 * Remove all tag hooks
4720 */
4725 }
4727 /**
4728 * Create a function, e.g. {{sum:1|2|3}}
4729 * The callback function should have the form:
4730 * function myParserFunction( &$parser, $arg1, $arg2, $arg3 ) { ... }
4731 *
4732 * Or with SFH_OBJECT_ARGS:
4733 * function myParserFunction( $parser, $frame, $args ) { ... }
4734 *
4735 * The callback may either return the text result of the function, or an array with the text
4736 * in element 0, and a number of flags in the other elements. The names of the flags are
4737 * specified in the keys. Valid flags are:
4738 * found The text returned is valid, stop processing the template. This
4739 * is on by default.
4740 * nowiki Wiki markup in the return value should be escaped
4741 * isHTML The returned text is HTML, armour it against wikitext transformation
4742 *
4743 * @param $id String: The magic word ID
4744 * @param $callback Mixed: the callback function (and object) to use
4745 * @param $flags Integer: a combination of the following flags:
4746 * SFH_NO_HASH No leading hash, i.e. {{plural:...}} instead of {{#if:...}}
4747 *
4748 * SFH_OBJECT_ARGS Pass the template arguments as PPNode objects instead of text. This
4749 * allows for conditional expansion of the parse tree, allowing you to eliminate dead
4750 * branches and thus speed up parsing. It is also possible to analyse the parse tree of
4751 * the arguments, and to control the way they are expanded.
4752 *
4753 * The $frame parameter is a PPFrame. This can be used to produce expanded text from the
4754 * arguments, for instance:
4755 * $text = isset( $args[0] ) ? $frame->expand( $args[0] ) : '';
4756 *
4757 * For technical reasons, $args[0] is pre-expanded and will be a string. This may change in
4758 * future versions. Please call $frame->expand() on it anyway so that your code keeps
4759 * working if/when this is changed.
4760 *
4761 * If you want whitespace to be trimmed from $args, you need to do it yourself, post-
4762 * expansion.
4763 *
4764 * Please read the documentation in includes/parser/Preprocessor.php for more information
4765 * about the methods available in PPFrame and PPNode.
4766 *
4767 * @return string|callback The old callback function for this name, if any
4768 */
4775 # Add to function cache
4784 # Case
4787 }
4788 # Add leading hash
4791 }
4792 # Remove trailing colon
4795 }
4797 }
4799 }
4801 /**
4802 * Get all registered function hook identifiers
4803 *
4804 * @return Array
4805 */
4808 }
4810 /**
4811 * Create a tag function, e.g. "<test>some stuff</test>".
4812 * Unlike tag hooks, tag functions are parsed at preprocessor level.
4813 * Unlike parser functions, their content is not preprocessed.
4814 * @return null
4815 */
4818 if ( preg_match( '/[<>\r\n]/', $tag, $m ) ) throw new MWException( "Invalid character {$m[0]} in setFunctionTagHook('$tag', ...) call" );
4825 }
4828 }
4830 /**
4831 * @todo FIXME: Update documentation. makeLinkObj() is deprecated.
4832 * Replace "<!--LINK-->" link placeholders with actual links, in the buffer
4833 * Placeholders created in Skin::makeLinkObj()
4834 *
4835 * @param $text string
4836 * @param $options int
4837 *
4838 * @return array of link CSS classes, indexed by PDBK.
4839 */
4842 }
4844 /**
4845 * Replace "<!--LINK-->" link placeholders with plain text of links
4846 * (not HTML-formatted).
4847 *
4848 * @param $text String
4849 * @return String
4850 */
4853 }
4855 /**
4856 * Renders an image gallery from a text with one line per image.
4857 * text labels may be given by using |-style alternative text. E.g.
4858 * Image:one.jpg|The number "1"
4859 * Image:tree.jpg|A tree
4860 * given as text will return the HTML of a gallery with two images,
4861 * labeled 'The number "1"' and
4862 * 'A tree'.
4863 *
4864 * @param string $text
4865 * @param array $params
4866 * @return string HTML
4867 */
4881 }
4887 }
4890 }
4893 }
4896 }
4902 # match lines like these:
4903 # Image:someimage.jpg|This is some image
4906 # Skip empty lines
4909 }
4913 }
4916 # Bogus title. Ignore these so we don't bomb out later.
4918 }
4924 // look for an |alt= definition while trying not to break existing
4925 // captions with multiple pipes (|) in it, until a more sensible grammar
4926 // is defined for images in galleries
4936 }
4941 //check to see if link matches an absolute url, if not then it must be a wiki link.
4945 }
4946 }
4948 // concatenate all other pipes
4950 }
4951 }
4952 // remove the first pipe
4954 }
4957 }
4959 }
4961 /**
4962 * @param $handler
4963 * @return array
4964 */
4970 }
4972 # Initialise static lists
4979 );
4987 }
4988 }
4989 }
4991 # Add handler params
4997 }
4998 }
5001 }
5002 return array( $this->mImageParams[$handlerClass], $this->mImageParamsMagicArray[$handlerClass] );
5003 }
5005 /**
5006 * Parse image options text and use it to make an image
5007 *
5008 * @param $title Title
5009 * @param $options String
5010 * @param $holders LinkHolderArray|bool
5011 * @return string HTML
5012 */
5014 # Check if the options text is of the form "options|alt text"
5015 # Options are:
5016 # * thumbnail make a thumbnail with enlarge-icon and caption, alignment depends on lang
5017 # * left no resizing, just left align. label is used for alt= only
5018 # * right same, but right aligned
5019 # * none same, but not aligned
5020 # * ___px scale to ___ pixels width, no aligning. e.g. use in taxobox
5021 # * center center the image
5022 # * frame Keep original image size, no magnify-button.
5023 # * framed Same as "frame"
5024 # * frameless like 'thumb' but without a frame. Keeps user preferences for width
5025 # * upright reduce width for upright images, rounded to full __0 px
5026 # * border draw a 1px border around the image
5027 # * alt Text for HTML alt attribute (defaults to empty)
5028 # * class Set a class for img node
5029 # * link Set the target of the image link. Can be external, interwiki, or local
5030 # vertical-align values (no % or length right now):
5031 # * baseline
5032 # * sub
5033 # * super
5034 # * top
5035 # * text-top
5036 # * middle
5037 # * bottom
5038 # * text-bottom
5042 # Give extensions a chance to select the file revision for us
5047 # Fetch and register the file (file title may be different via hooks)
5050 # Get parameter map
5057 }
5059 # Process the input parameters
5070 # Special case; width and height come in one variable together
5078 }
5079 }
5085 }
5086 }
5087 # else no validation -- bug 13436
5090 # Validate handler parameter
5093 # Validate internal parameters
5098 # @todo FIXME: Possibly check validity here for
5099 # manualthumb? downstream behavior seems odd with
5100 # missing manual thumbs.
5117 }
5119 }
5127 }
5128 }
5131 # Most other things appear to be empty or numeric...
5133 }
5134 }
5138 }
5139 }
5140 }
5143 }
5144 }
5146 # Process alignment parameters
5149 }
5152 }
5156 # Will the image be presented in a frame, with the caption below?
5162 # In the old days, [[Image:Foo|text...]] would set alt text. Later it
5163 # came to also set the caption, ordinary text after the image -- which
5164 # makes no sense, because that just repeats the text multiple times in
5165 # screen readers. It *also* came to set the title attribute.
5166 #
5167 # Now that we have an alt attribute, we should not set the alt text to
5168 # equal the caption: that's worse than useless, it just repeats the
5169 # text. This is the framed/thumbnail case. If there's no caption, we
5170 # use the unnamed parameter for alt text as well, just for the time be-
5171 # ing, if the unnamed param is set and the alt param is not.
5172 #
5173 # For the future, we need to figure out if we want to tweak this more,
5174 # e.g., introducing a title= parameter for the title; ignoring the un-
5175 # named parameter entirely for images without a caption; adding an ex-
5176 # plicit caption= parameter and preserving the old magic unnamed para-
5177 # meter for BC; ...
5180 # No caption or alt text, add the filename as the alt text so
5181 # that screen readers at least get some description of the image
5183 }
5184 # Do not set $params['frame']['title'] because tooltips don't make sense
5185 # for framed images
5188 # No alt text, use the "caption" for the alt text
5192 # No caption, fall back to using the filename for the
5193 # alt text
5195 }
5196 }
5197 # Use the "caption" for the tooltip text
5199 }
5203 # Linker does the rest
5208 # Give the handler a chance to modify the parser object
5211 }
5214 }
5216 /**
5217 * @param $caption
5218 * @param $holders LinkHolderArray
5219 * @return mixed|String
5220 */
5222 # Strip bad stuff out of the title (tooltip). We can't just use
5223 # replaceLinkHoldersText() here, because if this function is called
5224 # from replaceInternalLinks2(), mLinkHolders won't be up-to-date.
5229 }
5231 # make sure there are no placeholders in thumbnail attributes
5232 # that are later expanded to html- so expand them now and
5233 # remove the tags
5238 }
5240 /**
5241 * Set a flag in the output object indicating that the content is dynamic and
5242 * shouldn't be cached.
5243 */
5249 }
5252 }
5254 /**
5255 * Callback from the Sanitizer for expanding items found in HTML attribute
5256 * values, so they can be safely tested and escaped.
5257 *
5258 * @param $text String
5259 * @param $frame PPFrame
5260 * @return String
5261 */
5266 }
5268 /**
5269 * Accessor
5270 *
5271 * @return array
5272 */
5274 return array_merge( array_keys( $this->mTransparentTagHooks ), array_keys( $this->mTagHooks ), array_keys( $this->mFunctionTagHooks ) );
5275 }
5277 /**
5278 * Replace transparent tags in $text with the values given by the callbacks.
5279 *
5280 * Transparent tag hooks are like regular XML-style tag hooks, except they
5281 * operate late in the transformation sequence, on HTML instead of wikitext.
5282 *
5283 * @param $text string
5284 *
5285 * @return string
5286 */
5297 $output = call_user_func_array( $this->mTransparentTagHooks[$tagName], array( $content, $params, $this ) );
5300 }
5302 }
5304 }
5306 /**
5307 * Break wikitext input into sections, and either pull or replace
5308 * some particular section's text.
5309 *
5310 * External callers should use the getSection and replaceSection methods.
5311 *
5312 * @param $text String: Page wikitext
5313 * @param $section String: a section identifier string of the form:
5314 * "<flag1> - <flag2> - ... - <section number>"
5315 *
5316 * Currently the only recognised flag is "T", which means the target section number
5317 * was derived during a template inclusion parse, in other words this is a template
5318 * section edit link. If no flags are given, it was an ordinary section edit link.
5319 * This flag is required to avoid a section numbering mismatch when a section is
5320 * enclosed by "<includeonly>" (bug 6563).
5321 *
5322 * The section number 0 pulls the text before the first heading; other numbers will
5323 * pull the given section along with its lower-level subsections. If the section is
5324 * not found, $mode=get will return $newtext, and $mode=replace will return $text.
5325 *
5326 * Section 0 is always considered to exist, even if it only contains the empty
5327 * string. If $text is the empty string and section 0 is replaced, $newText is
5328 * returned.
5329 *
5330 * @param $mode String: one of "get" or "replace"
5331 * @param $newText String: replacement text for section data.
5332 * @return String: for "get", the extracted section text.
5333 * for "replace", the whole page with the section replaced.
5334 */
5341 # Process section extraction flags
5348 }
5349 }
5351 # Check for empty input
5353 # Only sections 0 and T-0 exist in an empty document
5359 }
5365 }
5366 }
5367 }
5369 # Preprocess the text
5372 # <h> nodes indicate section breaks
5373 # They can only occur at the top level, so we can find them by iterating the root's children
5376 # Find the target section
5378 # Section zero doesn't nest, level=big
5387 }
5388 }
5391 }
5393 }
5394 }
5397 # Not found
5402 }
5403 }
5405 # Find the end of the section, including nested sections
5412 }
5413 }
5416 }
5420 # Write out the remainder (in replace mode only)
5422 # Output the replacement text
5423 # Add two newlines on -- trailing whitespace in $newText is conventionally
5424 # stripped by the editor, so we need both newlines to restore the paragraph gap
5425 # Only add trailing whitespace if there is newText
5428 }
5433 }
5434 }
5437 # Re-insert stripped tags
5439 }
5442 }
5444 /**
5445 * This function returns the text of a section, specified by a number ($section).
5446 * A section is text under a heading like == Heading == or \<h1\>Heading\</h1\>, or
5447 * the first section before any such heading (section 0).
5448 *
5449 * If a section contains subsections, these are also returned.
5450 *
5451 * @param $text String: text to look in
5452 * @param $section String: section identifier
5453 * @param $deftext String: default to return if section is not found
5454 * @return string text of the requested section
5455 */
5458 }
5460 /**
5461 * This function returns $oldtext after the content of the section
5462 * specified by $section has been replaced with $text. If the target
5463 * section does not exist, $oldtext is returned unchanged.
5464 *
5465 * @param $oldtext String: former text of the article
5466 * @param $section int section identifier
5467 * @param $text String: replacing text
5468 * @return String: modified text
5469 */
5472 }
5474 /**
5475 * Get the ID of the revision we are parsing
5476 *
5477 * @return Mixed: integer or null
5478 */
5481 }
5483 /**
5484 * Get the revision object for $this->mRevisionId
5485 *
5486 * @return Revision|null either a Revision object or null
5487 */
5491 }
5494 }
5498 }
5500 /**
5501 * Get the timestamp associated with the current revision, adjusted for
5502 * the default server-local timestamp
5503 */
5513 # The cryptic '' timezone parameter tells to use the site-default
5514 # timezone offset instead of the user settings.
5515 #
5516 # Since this value will be saved into the parser cache, served
5517 # to other users, and potentially even used inside links and such,
5518 # it needs to be consistent for all visitors.
5522 }
5524 }
5526 /**
5527 * Get the name of the user that edited the last revision
5528 *
5529 * @return String: user name
5530 */
5535 # if this template is subst: the revision id will be blank,
5536 # so just use the current user's name
5541 }
5542 }
5544 }
5546 /**
5547 * Mutator for $mDefaultSort
5548 *
5549 * @param $sort string New value
5550 */
5554 }
5556 /**
5557 * Accessor for $mDefaultSort
5558 * Will use the empty string if none is set.
5559 *
5560 * This value is treated as a prefix, so the
5561 * empty string is equivalent to sorting by
5562 * page name.
5563 *
5564 * @return string
5565 */
5571 }
5572 }
5574 /**
5575 * Accessor for $mDefaultSort
5576 * Unlike getDefaultSort(), will return false if none is set
5577 *
5578 * @return string or false
5579 */
5582 }
5584 /**
5585 * Try to guess the section anchor name based on a wikitext fragment
5586 * presumably extracted from a heading, for example "Header" from
5587 * "== Header ==".
5588 *
5589 * @param $text string
5590 *
5591 * @return string
5592 */
5594 # Strip out wikitext links(they break the anchor)
5598 }
5600 /**
5601 * Same as guessSectionNameFromWikiText(), but produces legacy anchors
5602 * instead. For use in redirects, since IE6 interprets Redirect: headers
5603 * as something other than UTF-8 (apparently?), resulting in breakage.
5604 *
5605 * @param $text String: The section name
5606 * @return string An anchor
5607 */
5609 # Strip out wikitext links(they break the anchor)
5613 }
5615 /**
5616 * Strips a text string of wikitext for use in a section anchor
5617 *
5618 * Accepts a text string and then removes all wikitext from the
5619 * string and leaves only the resultant text (i.e. the result of
5620 * [[User:WikiSysop|Sysop]] would be "Sysop" and the result of
5621 * [[User:WikiSysop]] would be "User:WikiSysop") - this is intended
5622 * to create valid section anchors by mimicing the output of the
5623 * parser when headings are parsed.
5624 *
5625 * @param $text String: text string to be stripped of wikitext
5626 * for use in a Section anchor
5627 * @return string Filtered text string
5628 */
5630 # Strip internal link markup
5634 # Strip external link markup
5635 # @todo FIXME: Not tolerant to blank link text
5636 # I.E. [http://www.mediawiki.org] will render as [1] or something depending
5637 # on how many empty links there are on the page - need to figure that out.
5638 $text = preg_replace( '/\[(?i:' . $this->mUrlProtocols . ')([^ ]+?) ([^[]+)\]/', '$2', $text );
5640 # Parse wikitext quotes (italics & bold)
5643 # Strip HTML tags
5646 }
5648 /**
5649 * strip/replaceVariables/unstrip for preprocessor regression testing
5650 *
5651 * @param $text string
5652 * @param $title Title
5653 * @param $options ParserOptions
5654 * @param $outputType int
5655 *
5656 * @return string
5657 */
5658 function testSrvus( $text, Title $title, ParserOptions $options, $outputType = self::OT_HTML ) {
5665 }
5667 /**
5668 * @param $text string
5669 * @param $title Title
5670 * @param $options ParserOptions
5671 * @return string
5672 */
5675 }
5677 /**
5678 * @param $text
5679 * @param $title Title
5680 * @param $options ParserOptions
5681 * @return string
5682 */
5685 }
5687 /**
5688 * Call a callback function on all regions of the given text that are not
5689 * inside strip markers, and replace those regions with the return value
5690 * of the callback. For example, with input:
5691 *
5692 * aaa<MARKER>bbb
5693 *
5694 * This will call the callback function twice, with 'aaa' and 'bbb'. Those
5695 * two strings will be replaced with the value returned by the callback in
5696 * each case.
5697 *
5698 * @param $s string
5699 * @param $callback
5700 *
5701 * @return string
5702 */
5721 }
5722 }
5723 }
5725 }
5727 /**
5728 * Remove any strip markers found in the given text.
5729 *
5730 * @param $text Input string
5731 * @return string
5732 */
5735 }
5737 /**
5738 * Save the parser state required to convert the given half-parsed text to
5739 * HTML. "Half-parsed" in this context means the output of
5740 * recursiveTagParse() or internalParse(). This output has strip markers
5741 * from replaceVariables (extensionSubstitution() etc.), and link
5742 * placeholders from replaceLinkHolders().
5743 *
5744 * Returns an array which can be serialized and stored persistently. This
5745 * array can later be loaded into another parser instance with
5746 * unserializeHalfParsedText(). The text can then be safely incorporated into
5747 * the return value of a parser hook.
5748 *
5749 * @param $text string
5750 *
5751 * @return array
5752 */
5760 );
5763 }
5765 /**
5766 * Load the parser state given in the $data array, which is assumed to
5767 * have been generated by serializeHalfParsedText(). The text contents is
5768 * extracted from the array, and its markers are transformed into markers
5769 * appropriate for the current Parser instance. This transformed text is
5770 * returned, and can be safely included in the return value of a parser
5771 * hook.
5772 *
5773 * If the $data array has been stored persistently, the caller should first
5774 * check whether it is still valid, by calling isValidHalfParsedText().
5775 *
5776 * @param $data array Serialized data
5777 * @return String
5778 */
5782 }
5784 # First, extract the strip state.
5788 # Now renumber links
5791 # Should be good to go.
5793 }
5795 /**
5796 * Returns true if the given array, presumed to be generated by
5797 * serializeHalfParsedText(), is compatible with the current version of the
5798 * parser.
5799 *
5800 * @param $data Array
5801 *
5802 * @return bool
5803 */
5806 }
5808 /**
5809 * Parsed a width param of imagelink like 300px or 200x300px
5810 *
5811 * @param $value String
5812 *
5813 * @return array
5814 * @since 1.20
5815 */
5820 }
5822 # (bug 13500) In both cases (width/height and width only),
5823 # permit trailing "px" for backward compatibility.
5832 }
5834 }
5835 }