| blob | 68ca150b2668c06546fdca9d5d8e25eb170cc8d9 |
1 <?php
2 /**
3 * @defgroup Parser Parser
4 *
5 * @file
6 * @ingroup Parser
7 * File for Parser and related classes
8 */
11 /**
12 * PHP Parser - Processes wiki markup (which uses a more user-friendly
13 * syntax, such as "[[link]]" for making links), and provides a one-way
14 * transformation of that wiki markup it into XHTML output / markup
15 * (which in turn the browser understands, and can display).
16 *
17 * <pre>
18 * There are five main entry points into the Parser class:
19 * parse()
20 * produces HTML output
21 * preSaveTransform().
22 * produces altered wiki markup.
23 * preprocess()
24 * removes HTML comments and expands templates
25 * cleanSig()
26 * Cleans a signature before saving it to preferences
27 * extractSections()
28 * Extracts sections from an article for section editing
29 *
30 * Globals used:
31 * objects: $wgLang, $wgContLang
32 *
33 * NOT $wgArticle, $wgUser or $wgTitle. Keep them away!
34 *
35 * settings:
36 * $wgUseTex*, $wgUseDynamicDates*, $wgInterwikiMagic*,
37 * $wgNamespacesWithSubpages, $wgAllowExternalImages*,
38 * $wgLocaltimezone, $wgAllowSpecialInclusion*,
39 * $wgMaxArticleSize*
40 *
41 * * only within ParserOptions
42 * </pre>
43 *
44 * @ingroup Parser
45 */
46 class Parser
47 {
48 /**
49 * Update this version number when the ParserOutput format
50 * changes in an incompatible way, so the parser cache
51 * can automatically discard old data.
52 */
55 # Flags for Parser::setFunctionHook
56 # Also available as global constants from Defines.php
60 # Constants needed for external link processing
61 # Everything except bracket, space, or control characters
66 // State constants for the definition list colon extraction
76 // Flags for preprocessToDom
79 // Allowed values for $this->mOutputType
80 // Parameter to startExternalParse().
86 // Marker Suffix needs to be accessible staticly.
89 /**#@+
90 * @private
91 */
92 # Persistent:
98 # Cleared with clearState():
108 # Temporary
109 # These are variables reset at least once per parse regardless of $clearState
118 /**#@-*/
120 /**
121 * Constructor
122 *
123 * @public
124 */
139 // PECL extension that conflicts with the core DOM extension (bug 13770)
146 }
149 }
151 /**
152 * Reduce memory usage to reduce the impact of circular references
153 */
157 }
160 }
161 }
163 /**
164 * Do various kinds of initialisation on the first call of the parser
165 */
169 }
180 }
182 /**
183 * Clear Parser state
184 *
185 * @private
186 */
191 }
204 /**
205 * Prefix for temporary replacement strings for the multipass parser.
206 * \x07 should never appear in input as it's disallowed in XML.
207 * Using it at the front also gives us a little extra robustness
208 * since it shouldn't match when butted up against identifier-like
209 * string constructs.
210 *
211 * Must not consist of all title characters, or else it will change
212 * the behaviour of <nowiki> in a link.
213 */
214 #$this->mUniqPrefix = "\x07UNIQ" . Parser::getRandomString();
215 # Changed to \x7f to allow XML double-parsing -- TS
219 # Clear these on every parse, bug 4549
227 );
235 # Fix cloning
238 }
242 }
246 // Shortcut alias
251 );
252 }
254 /**
255 * Set the context title
256 */
260 }
262 # Strip the fragment to avoid various odd effects
267 }
268 }
270 /**
271 * Accessor for mUniqPrefix.
272 *
273 * @public
274 */
277 // @fixme this is probably *horribly wrong*
278 // LanguageConverter seems to want $wgParser's uniqPrefix, however
279 // if this is called for a parser cache hit, the parser may not
280 // have ever been initialized in the first place.
281 // Not really sure what the heck is supposed to be going on here.
283 //throw new MWException( "Accessing uninitialized mUniqPrefix" );
284 }
286 }
288 /**
289 * Convert wikitext to HTML
290 * Do not call this function recursively.
291 *
292 * @param $text String: text we want to parse
293 * @param $title A title object
294 * @param $options ParserOptions
295 * @param $linestart boolean
296 * @param $clearState boolean
297 * @param $revid Int: number to pass in {{REVISIONID}}
298 * @return ParserOutput a ParserOutput
299 */
300 public function parse( $text, Title $title, ParserOptions $options, $linestart = true, $clearState = true, $revid = null ) {
301 /**
302 * First pass--just handle <nowiki> sections, pass the rest off
303 * to internalParse() which does all the real work.
304 */
313 }
322 }
325 # No more strip!
330 # Clean up special characters, only run once, next-to-last before doBlockLevels
332 # french spaces, last one Guillemet-left
333 # only if there is something before the space
335 # french spaces, Guillemet-right
338 );
345 # the position of the parserConvert() call should not be changed. it
346 # assumes that the links are all replaced and the only thing left
347 # is the <nowiki> mark.
348 # Side-effects: this calls $this->mOutput->setTitleText()
355 //!JF Move to its own function
370 }
372 }
380 # attempt to sanitize at least some nesting problems
381 # (bug #2702 and quite a few others)
383 # ''Something [http://www.cool.com cool''] -->
384 # <i>Something</i><a href="http://www.cool.com"..><i>cool></i></a>
387 # fix up an anchor inside another anchor, only
388 # at least for a single single nested link (bug 3695)
391 # fix div inside inline elements- doBlockLevels won't wrap a line which
392 # contains a div, so fix it up here; replace
393 # div with escaped text
396 # remove empty italic or bold tag pairs, some
397 # introduced by rules above
399 );
405 }
408 $this->limitationWarn( 'expensive-parserfunction', $this->mExpensiveFunctionCount, $wgExpensiveParserFunctionLimit );
409 }
413 # Information on include size limits, for the benefit of users who try to skirt them
417 $PFreport = "Expensive parser function count: {$this->mExpensiveFunctionCount}/$wgExpensiveParserFunctionLimit\n";
426 }
434 }
436 /**
437 * Recursive parser entry point that can be called from an extension tag
438 * hook.
439 */
447 }
449 /**
450 * Expand templates and variables in the text, producing valid, static wikitext.
451 * Also removes comments.
452 */
461 }
468 }
470 /**
471 * Get a random string
472 *
473 * @private
474 * @static
475 */
478 }
494 }
495 }
497 /**
498 * Get a preprocessor object
499 */
504 }
506 }
508 /**
509 * Replaces all occurrences of HTML-style comments and the given tags
510 * in the text with a random marker and returns the next text. The output
511 * parameter $matches will be an associative array filled with data in
512 * the form:
513 * 'UNIQ-xxxxx' => array(
514 * 'element',
515 * 'tag content',
516 * array( 'param' => 'x' ),
517 * '<element param="x">tag content</element>' ) )
518 *
519 * @param $elements list of element names. Comments are always extracted.
520 * @param $text Source text string.
521 * @param $uniq_prefix
522 *
523 * @public
524 * @static
525 */
539 }
541 // comment
547 // tag
552 }
558 // Empty element tag, <tag />
567 }
571 # No end tag -- let it run out to the end of the text.
577 }
578 }
584 }
586 }
588 /**
589 * Get a list of strippable XML-like elements
590 */
596 }
599 }
601 }
603 /**
604 * @deprecated use replaceVariables
605 */
608 }
610 /**
611 * Restores pre, math, and other extensions removed by strip()
612 *
613 * always call unstripNoWiki() after this one
614 * @private
615 * @deprecated use $this->mStripState->unstrip()
616 */
619 }
621 /**
622 * Always call this after unstrip() to preserve the order
623 *
624 * @private
625 * @deprecated use $this->mStripState->unstrip()
626 */
629 }
631 /**
632 * @deprecated use $this->mStripState->unstripBoth()
633 */
636 }
638 /**
639 * Add an item to the strip state
640 * Returns the unique tag which must be inserted into the stripped text
641 * The tag will be replaced with the original text in unstrip()
642 *
643 * @private
644 */
650 }
652 /**
653 * Interface with html tidy
654 * @deprecated Use MWTidy::tidy()
655 */
659 }
661 /**
662 * parse the wiki syntax used to render tables
663 *
664 * @private
665 */
684 }
689 // First check if we are starting a new table
702 // Don't do any of the following
706 // We are ending a table
712 }
716 }
720 }
724 // Now we have a table row
727 // Whats after the tag is now only attributes
740 }
744 }
750 }
751 else if ( $first_character === '|' || $first_character === '!' || substr ( $line , 0 , 2 ) === '|+' ) {
752 // This might be cell elements, td, th or captions
756 }
762 }
764 // Split up multiple cells on the same line.
765 // FIXME : This can result in improper nesting of tags processed
766 // by earlier parser steps, but should avoid splitting up eg
767 // attribute values containing literal "||".
772 // Loop through each table cell
774 {
777 {
781 }
786 }
792 }
802 }
806 // A cell could contain both parameters and data
809 // Bug 553: Note that a '|' inside an invalid link should not
810 // be mistaken as delimiting cell parameters
819 }
823 }
824 }
826 }
828 // Closing open td, tr && table
830 {
833 }
836 }
839 }
842 }
844 // Remove trailing line-ending (b/c)
847 }
849 // special case: don't return empty table
852 }
857 }
859 /**
860 * Helper function for parse() that transforms wiki markup into
861 * HTML. Only called for $mOutputType == self::OT_HTML.
862 *
863 * @private
864 */
870 # Hook to suspend the parser in this state
871 if ( !wfRunHooks( 'ParserBeforeInternalParse', array( &$this, &$text, &$this->mStripState ) ) ) {
874 }
877 $text = Sanitizer::removeHTMLtags( $text, array( &$this, 'attributeStripCallback' ), false, array_keys( $this->mTransparentTagHooks ) );
880 // Tables need to come after variable replacement for things to work
881 // properly; putting them before other transformations should keep
882 // exciting things like link expansions from showing up in surprising
883 // places.
893 }
898 # replaceInternalLinks may sometimes leave behind
899 # absolute URLs, which have to be masked to hide them from replaceExternalLinks
907 }
909 /**
910 * Replace special strings like "ISBN xxx" and "RFC xxx" with
911 * magic external links.
912 *
913 * DML
914 * @private
915 */
921 '!(?: # Start cases
922 (<a.*?</a>) | # m[1]: Skip link text
925 (?:RFC|PMID)\s+([0-9]+) | # m[4]: RFC or PMID, capture number
927 (?: 97[89] [\ \-]? )? # optional 13-digit ISBN prefix
928 (?: [0-9] [\ \-]? ){9} # 9 digits with opt. delimiters
929 [0-9Xx] # check digit
934 }
938 # Skip anchor
941 # Skip HTML element
944 # Free external link
947 # RFC or PMID
959 }
965 # ISBN
971 ));
978 }
979 }
981 /**
982 * Make a free external link, given a user-supplied URL
983 * @return HTML
984 * @private
985 */
993 # The characters '<' and '>' (which were escaped by
994 # removeHTMLtags()) should not be included in
995 # URLs, per RFC 2396.
1000 }
1002 # Move trailing punctuation to $trail
1004 # If there is no left bracket, then consider right brackets fair game too
1007 }
1013 }
1017 # Is this an external image?
1020 # Not an image, make a link
1023 # Register it in the output object...
1024 # Replace unnecessary URL escape codes with their equivalent characters
1027 }
1030 }
1033 /**
1034 * Parse headers and return html
1035 *
1036 * @private
1037 */
1044 }
1047 }
1049 /**
1050 * Replace single quotes with HTML markup
1051 * @private
1052 * @return string the altered text
1053 */
1060 }
1064 }
1066 /**
1067 * Helper function for doAllQuotes()
1068 */
1073 else
1074 {
1075 # First, do some preliminary work. This may shift some apostrophes from
1076 # being mark-up to being text. It also counts the number of occurrences
1077 # of bold and italics mark-ups.
1082 {
1084 {
1085 # If there are ever four apostrophes, assume the first is supposed to
1086 # be text, and the remaining three constitute mark-up for bold text.
1088 {
1091 }
1092 # If there are more than 5 apostrophes in a row, assume they're all
1093 # text except for the last 5.
1095 {
1098 }
1099 # Count the number of occurrences of bold and italics mark-ups.
1100 # We are not counting sequences of five apostrophes.
1104 }
1106 }
1108 # If there is an odd number of both bold and italics, it is likely
1109 # that one of the bold ones was meant to be an apostrophe followed
1110 # by italics. Which one we cannot know for certain, but it is more
1111 # likely to be one that has a single-letter word before it.
1113 {
1119 {
1121 {
1130 }
1131 }
1133 }
1135 # If there is a single-letter word, use it!
1137 {
1140 }
1141 # If not, but there's a multi-letter word, use that one.
1143 {
1146 }
1147 # ... otherwise use the first one that has neither.
1148 # (notice that it is possible for all three to be -1 if, for example,
1149 # there is only one pentuple-apostrophe in the line)
1151 {
1154 }
1155 }
1157 # Now let's actually convert our apostrophic mush to HTML!
1163 {
1165 {
1168 else
1170 }
1171 else
1172 {
1174 {
1185 }
1187 {
1198 }
1200 {
1213 }
1214 }
1216 }
1217 # Now close all remaining tags. Notice that the order is important.
1224 # There might be lonely ''''', so make sure we have a buffer
1228 }
1229 }
1231 /**
1232 * Replace external links (REL)
1233 *
1234 * Note: this is all very hackish and the order of execution matters a lot.
1235 * Make sure to run maintenance/parserTests.php if you change this code.
1236 *
1237 * @private
1238 */
1255 # The characters '<' and '>' (which were escaped by
1256 # removeHTMLtags()) should not be included in
1257 # URLs, per RFC 2396.
1262 }
1264 # If the link text is an image URL, replace it with an <img> tag
1265 # This happened by accident in the original parser, but some people used it extensively
1269 }
1273 # Set linktype for CSS - if URL==text, link is essentially free
1276 # No link text, e.g. [http://domain.tld/some.link]
1278 # Autonumber if allowed. See bug #5918
1284 # Otherwise just use the URL
1287 }
1289 # Have link text, e.g. [http://domain.tld/some.link text]s
1290 # Check for trail
1292 }
1298 # Use the encoded URL
1299 # This means that users can paste URLs directly into the text
1300 # Funny characters like ö aren't valid in URLs anyway
1301 # This was changed in August 2004
1305 # Register link in the output object.
1306 # Replace unnecessary URL escape codes with the referenced character
1307 # This prevents spammers from hiding links from the filters
1310 }
1314 }
1316 /**
1317 * Get an associative array of additional HTML attributes appropriate for a
1318 * particular external link. This currently may include rel => nofollow
1319 * (depending on configuration, namespace, and the URL's domain) and/or a
1320 * target attribute (depending on configuration).
1321 *
1322 * @param string $url Optional URL, to extract the domain from for rel =>
1323 * nofollow if appropriate
1324 * @return array Associative array of HTML attributes
1325 */
1342 }
1343 }
1344 }
1345 }
1346 }
1349 }
1351 }
1354 /**
1355 * Replace unusual URL escape codes with their equivalent characters
1356 * @param string
1357 * @return string
1358 * @static
1359 * @todo This can merge genuinely required bits in the path or query string,
1360 * breaking legit URLs. A proper fix would treat the various parts of
1361 * the URL differently; as a workaround, just use the output for
1362 * statistical records, not for actual linking/output.
1363 */
1367 }
1369 /**
1370 * Callback function used in replaceUnusualEscapes().
1371 * Replaces unusual URL escape codes with their equivalent character
1372 * @static
1373 * @private
1374 */
1378 // Is it an unsafe or HTTP reserved character according to RFC 1738?
1380 // No, shouldn't be escaped
1383 // Yes, leave it escaped
1385 }
1386 }
1388 /**
1389 * make an image if it's allowed, either through the global
1390 * option, through the exception, or through the on-wiki whitelist
1391 * @private
1392 */
1398 # $imagesfrom could be either a single string or an array of strings, parse out the latter
1405 }
1406 }
1411 }
1415 # Image found
1417 }
1418 }
1423 # Sanitize the regex fragment, make it case-insensitive, ignore blank entries/comments
1427 # Image matches a whitelist entry
1430 }
1431 }
1432 }
1434 }
1436 /**
1437 * Process [[ ]] wikilinks
1438 * @return processed text
1439 *
1440 * @private
1441 */
1445 }
1447 /**
1448 * Process [[ ]] wikilinks (RIL)
1449 * @return LinkHolderArray
1450 *
1451 * @private
1452 */
1460 # the % is needed to support urlencoded titles as well
1463 # Match a link having the form [[namespace:link|alternate]]trail
1465 # Match cases where there is no "]]", which might still be images
1467 }
1472 #split the entire text string on occurences of [[
1474 #get the first element (all text up to first [[), and remove the space we added
1483 # Match the end of a line for a word that's not followed by whitespace,
1484 # e.g. in the case of 'The Arab al[[Razi]]', 'al' will be matched
1486 }
1492 }
1501 }
1504 }
1510 }
1514 # Loop for each link
1516 # Check for excessive memory usage
1518 # Too big
1519 # Do the existence check, replace the link holders and clear the array
1522 }
1531 }
1532 # first link
1536 }
1538 }
1545 # If we get a ] at the beginning of $m[3] that means we have a link that's something like:
1546 # [[Image:Foo.jpg|[http://example.com desc]]] <- having three ] in a row fucks up,
1547 # the real problem is with the $e1 regex
1548 # See bug 1300.
1549 #
1550 # Still some problems for cases where the ] is meant to be outside punctuation,
1551 # and no image is in sight. See bug 2095.
1552 #
1556 )
1557 {
1560 }
1561 # fix up urlencoded title texts
1563 # Should anchors '#' also be rejected?
1565 }
1567 } elseif( preg_match($e1_img, $line, $m) ) { # Invalid, but might be an image with a link in its caption
1572 }
1578 }
1582 # Don't allow internal links to pages containing
1583 # PROTO: where PROTO is a valid URL protocol; these
1584 # should be external links.
1589 }
1591 # Make subpage if necessary
1596 }
1600 # Strip off leading ':'
1602 }
1611 }
1622 #look at the next 'line' to see if we can close it there
1627 }
1630 # the first ]] closes the inner link, the second the image
1636 #if there's exactly one ]] that's fine, we'll keep looking
1639 #if $next_line is invalid too, we need look no further
1642 }
1643 }
1645 # we couldn't find the end of this imageLink, so output it raw
1646 #but don't ignore what might be perfectly normal links in the text we've examined
1649 # note: no $trail, because without an end, there *is* no trail
1652 }
1655 # note: no $trail, because without an end, there *is* no trail
1658 }
1660 }
1665 # Link not escaped by : , create the various objects
1668 # Interwikis
1670 if( $iw && $this->mOptions->getInterwikiMagic() && $nottalk && $wgContLang->getLanguageName( $iw ) ) {
1676 }
1682 # recursively parse links inside the image caption
1683 # actually, this will parse them in any other parameters, too,
1684 # but it might be hard to fix that, and it doesn't matter ATM
1688 # cloak any absolute URLs inside the image markup, so replaceExternalLinks() won't touch them
1690 }
1695 }
1705 }
1711 /**
1712 * Strip the whitespace Category links produce, see bug 87
1713 * @todo We might want to use trim($tmp, "\n") here.
1714 */
1719 }
1720 }
1722 # Self-link checking
1727 }
1728 }
1730 # NS_MEDIA is a pseudo-namespace for linking directly to a file
1731 # FIXME: Should do batch file existence checks, see comment below
1734 # Give extensions a chance to select the file revision for us
1741 }
1742 # Cloak with NOPARSE to avoid replacement in replaceExternalLinks
1747 }
1750 # Some titles, such as valid special pages or files in foreign repos, should
1751 # be shown as bluelinks even though they're not included in the page table
1752 #
1753 # FIXME: isAlwaysKnown() can be expensive for file links; we should really do
1754 # batch file existence checks for NS_FILE and NS_MEDIA
1759 # Links will be added to the output link list after checking
1761 }
1763 }
1766 }
1768 /**
1769 * Make a link placeholder. The text returned can be later resolved to a real link with
1770 * replaceLinkHolders(). This is done for two reasons: firstly to avoid further
1771 * parsing of interwiki links, and secondly to allow all existence checks and
1772 * article length checks (for stub links) to be bundled into a single query.
1773 *
1774 * @deprecated
1775 */
1778 }
1780 /**
1781 * Render a forced-blue link inline; protect against double expansion of
1782 * URLs if we're in a mode that prepends full URL prefixes to internal links.
1783 * Since this little disaster has to split off the trail text to avoid
1784 * breaking URLs in the following text without breaking trails on the
1785 * wiki links, it's been made into a horrible function.
1786 *
1787 * @param Title $nt
1788 * @param string $text
1789 * @param string $query
1790 * @param string $trail
1791 * @param string $prefix
1792 * @return string HTML-wikitext mix oh yuck
1793 */
1797 // FIXME: use link() instead of deprecated makeKnownLinkObj()
1800 }
1802 /**
1803 * Insert a NOPARSE hacky thing into any inline links in a chunk that's
1804 * going to go through further parsing steps before inline URL expansion.
1805 *
1806 * Not needed quite as much as it used to be since free links are a bit
1807 * more sensible these days. But bracketed links are still an issue.
1808 *
1809 * @param string more-or-less HTML
1810 * @return string less-or-more HTML with NOPARSE bits
1811 */
1815 }
1817 /**
1818 * Return true if subpage links should be expanded on this page.
1819 * @return bool
1820 */
1822 # Some namespaces don't allow subpages
1824 }
1826 /**
1827 * Handle link to subpage if necessary
1828 * @param string $target the source of the link
1829 * @param string &$text the link text, modified as necessary
1830 * @return string the full name of the link
1831 * @private
1832 */
1834 # Valid link forms:
1835 # Foobar -- normal
1836 # :Foobar -- override special treatment of prefix (images, language links)
1837 # /Foobar -- convert to CurrentPage/Foobar
1838 # /Foobar/ -- convert to CurrentPage/Foobar, strip the initial / from text
1839 # ../ -- convert to CurrentPage, from CurrentPage/CurrentSubPage
1840 # ../Foobar -- convert to CurrentPage/Foobar, from CurrentPage/CurrentSubPage
1845 # Some namespaces don't allow subpages,
1846 # so only perform processing if subpages are allowed
1854 }
1855 # bug 7425
1857 # Look at the first character
1859 # / at end means we don't want the slash to be shown
1866 }
1873 # check for .. subpage backlinks
1879 }
1884 # / at the end means don't show full path
1889 }
1890 }
1894 }
1896 }
1897 }
1898 }
1899 }
1903 }
1905 /**#@+
1906 * Used by doBlockLevels()
1907 * @private
1908 */
1913 }
1917 }
1918 # getCommon() returns the length of the longest common substring
1919 # of both arguments, starting at the beginning of both.
1920 #
1928 }
1930 }
1931 # These next three functions open, continue, and close the list
1932 # element appropriate to the prefix character passed into them.
1933 #
1943 }
1947 }
1960 }
1961 }
1963 }
1974 }
1975 }
1978 }
1979 /**#@-*/
1981 /**
1982 * Make lists from lines starting with ':', '*', '#', etc. (DBL)
1983 *
1984 * @param $linestart bool whether or not this is at the start of a line.
1985 * @private
1986 * @return string the lists rendered as HTML
1987 */
1991 # Parsing through the text line by line. The main thing
1992 # happening here is handling of block-level elements p, pre,
1993 # and making lists from lines starting with * # : etc.
1994 #
2003 # Fix up $linestart
2008 }
2009 // * = ul
2010 // # = ol
2011 // ; = dt
2012 // : = dd
2017 // If not in a <pre> element, scan for and figure out what prefixes are there.
2019 # Multiple prefixes may abut each other for nested lists.
2023 # eh?
2024 // ; and : are both from definition-lists, so they're equivalent
2025 // for the purposes of determining whether or not we need to open/close
2026 // elements.
2031 # Don't interpret any other prefixes in preformatted text
2035 }
2037 # List generation
2039 # Same as the last item, so no need to deal with nesting or opening stuff
2044 # The one nasty exception: definition lists work like this:
2045 # ; title : definition text
2046 # So we check for : in the remainder text to split up the
2047 # title and definition, without b0rking links.
2052 }
2053 }
2055 // We need to open or close prefixes, or both.
2057 # Either open or close a level...
2061 // Close all the prefixes which aren't shared.
2065 }
2067 // Continue the current prefix if appropriate.
2070 }
2072 // Open prefixes where appropriate.
2078 # FIXME: This is dupe of code above
2082 }
2083 }
2085 }
2087 }
2089 // If we have no prefixes, go to paragraph mode.
2092 # No prefix (not in list)--go to paragraph mode
2093 // XXX: use a stack for nestable elements like span, table and div
2094 $openmatch = preg_match('/(?:<table|<blockquote|<h1|<h2|<h3|<h4|<h5|<h6|<pre|<tr|<p|<ul|<ol|<li|<\\/tr|<\\/td|<\\/th)/iS', $t );
2097 '<td|<th|<\\/?div|<hr|<\\/pre|<\\/p|'.$this->mUniqPrefix.'-pre|<\\/li|<\\/ul|<\\/ol|<\\/?center)/iS', $t );
2100 #Â TODO bug 5718: paragraph closed
2104 }
2109 }
2112 // pre
2117 }
2120 // paragraph
2133 }
2134 }
2143 }
2144 }
2145 }
2146 }
2148 }
2149 // somewhere above we forget to get out of pre block (bug 785)
2152 }
2155 }
2156 }
2160 }
2164 }
2168 }
2170 /**
2171 * Split up a string on ':', ignoring any occurences inside tags
2172 * to prevent illegal overlapping.
2173 * @param string $str the string to split
2174 * @param string &$before set to everything before the ':'
2175 * @param string &$after set to everything after the ':'
2176 * return string the position of the ':', or false if none found
2177 */
2183 // Nothing to find!
2186 }
2190 // Easy; no tag nesting to worry about
2195 }
2197 // Ugly state machine to walk through avoiding tags.
2205 // (Using the number is a performance hack for common cases)
2209 // Could be either a <start> tag or an </end> tag
2214 // We found it!
2219 }
2220 // Embedded in a tag; don't break it.
2223 // Skip ahead looking for something interesting
2226 // Nothing else interesting
2229 }
2233 // We found it!
2238 }
2239 }
2241 // Nothing else interesting to find; abort!
2242 // We're nested, but there's no close tags left. Abort!
2244 }
2245 // Skip ahead to next tag start
2248 }
2251 // In a <tag>
2258 // Slash may be followed by >?
2262 // ignore
2263 }
2274 // Illegal early close? This shouldn't happen D:
2279 }
2282 // In a </tag>
2289 }
2291 }
2295 // Yes, a self-closed tag <blah/>
2298 // Probably we're jumping the gun, and this is an attribute
2300 }
2305 }
2312 }
2319 }
2323 }
2324 }
2328 }
2331 }
2333 /**
2334 * Return value of a magic variable (like PAGENAME)
2335 *
2336 * @private
2337 */
2341 /**
2342 * Some of these require message or data lookups and can be
2343 * expensive to check many times.
2344 */
2348 }
2349 }
2354 # Use the time zone
2359 }
2374 }
2428 }
2435 }
2443 // Let the edit saving system know we should parse the page
2444 // *after* a revision ID has been assigned.
2449 // Let the edit saving system know we should parse the page
2450 // *after* a revision ID has been assigned. This is for null edits.
2455 // Let the edit saving system know we should parse the page
2456 // *after* a revision ID has been assigned. This is for null edits.
2461 // Let the edit saving system know we should parse the page
2462 // *after* a revision ID has been assigned. This is for null edits.
2467 // Let the edit saving system know we should parse the page
2468 // *after* a revision ID has been assigned. This is for null edits.
2473 // Let the edit saving system know we should parse the page
2474 // *after* a revision ID has been assigned. This is for null edits.
2479 // Let the edit saving system know we should parse the page
2480 // *after* a revision ID has been assigned. This is for null edits.
2501 return $this->mVarCache[$index] = $wgContLang->time( wfTimestamp( TS_MW, $ts ), false, false );
2505 // @bug 4594 PHP5 has it zero padded, PHP4 does not, cast to
2506 // int to remove the padding
2519 // @bug 4594 PHP5 has it zero padded, PHP4 does not, cast to
2520 // int to remove the padding
2561 if ( wfRunHooks( 'ParserGetVariableValueSwitch', array( &$this, &$this->mVarCache, &$index, &$ret ) ) )
2563 else
2565 }
2566 }
2568 /**
2569 * initialise the magic variables (like CURRENTMONTHNAME)
2570 *
2571 * @private
2572 */
2579 }
2581 /**
2582 * Preprocess some wikitext and return the document tree.
2583 * This is the ghost of replace_variables().
2584 *
2585 * @param string $text The text to parse
2586 * @param integer flags Bitwise combination of:
2587 * self::PTD_FOR_INCLUSION Handle <noinclude>/<includeonly> as if the text is being
2588 * included. Default is to assume a direct page view.
2589 *
2590 * The generated DOM tree must depend only on the input text and the flags.
2591 * The DOM tree must be the same in OT_HTML and OT_WIKI mode, to avoid a regression of bug 4899.
2592 *
2593 * Any flag added to the $flags parameter here, or any other parameter liable to cause a
2594 * change in the DOM tree for a given text, must be passed through the section identifier
2595 * in the section edit link and thus back to extractSections().
2596 *
2597 * The output of this function is currently only cached in process memory, but a persistent
2598 * cache may be implemented at a later date which takes further advantage of these strict
2599 * dependency requirements.
2600 *
2601 * @private
2602 */
2606 }
2608 /*
2609 * Return a three-element array: leading whitespace, string contents, trailing whitespace
2610 */
2620 }
2622 }
2624 /**
2625 * Replace magic variables, templates, and template arguments
2626 * with the appropriate text. Templates are substituted recursively,
2627 * taking care to avoid infinite loops.
2628 *
2629 * Note that the substitution depends on value of $mOutputType:
2630 * self::OT_WIKI: only {{subst:}} templates
2631 * self::OT_PREPROCESS: templates but not extension tags
2632 * self::OT_HTML: all templates and extension tags
2633 *
2634 * @param string $tex The text to transform
2635 * @param PPFrame $frame Object describing the arguments passed to the template.
2636 * Arguments may also be provided as an associative array, as was the usual case before MW1.12.
2637 * Providing arguments this way may be useful for extensions wishing to perform variable replacement explicitly.
2638 * @param bool $argsOnly Only do argument (triple-brace) expansion, not double-brace expansion
2639 * @private
2640 */
2642 # Is there any text? Also, Prevent too big inclusions!
2645 }
2651 wfDebug( __METHOD__." called using plain parameters instead of a PPFrame instance. Creating custom frame.\n" );
2653 }
2661 }
2663 /// Clean up argument array - refactored in 1.9 so parserfunctions can use it, too.
2676 }
2679 }
2680 }
2681 }
2684 }
2686 /**
2687 * Warn the user when a parser limitation is reached
2688 * Will warn at most once the user per limitation type
2689 *
2690 * @param string $limitationType, should be one of:
2691 * 'expensive-parserfunction' (corresponding messages: 'expensive-parserfunction-warning', 'expensive-parserfunction-category')
2692 * 'post-expand-template-argument' (corresponding messages: 'post-expand-template-argument-warning', 'post-expand-template-argument-category')
2693 * 'post-expand-template-inclusion' (corresponding messages: 'post-expand-template-inclusion-warning', 'post-expand-template-inclusion-category')
2694 * @params int $current, $max When an explicit limit has been
2695 * exceeded, provide the values (optional)
2696 */
2699 //does no harm if $current and $max are present but are unnecessary for the message
2705 }
2706 }
2708 /**
2709 * Return the text of a template, after recursively
2710 * replacing any variables or templates within the template.
2711 *
2712 * @param array $piece The parts of the template
2713 * $piece['title']: the title, i.e. the part before the |
2714 * $piece['parts']: the parameter array
2715 * $piece['lineStart']: whether the brace was at the start of a line
2716 * @param PPFrame The current frame, contains template arguments
2717 * @return string the text of the template
2718 * @private
2719 */
2725 # Flags
2733 # Title object, where $text came from
2736 # $part1 is the bit before the first |, and must contain only title characters.
2737 # Various prefixes will be stripped from it later.
2742 # Original title text preserved for various purposes
2745 # $args is a list of argument nodes, starting from index 0, not including $part1
2749 # SUBST
2754 # One of two possibilities is true:
2755 # 1) Found SUBST but not in the PST phase
2756 # 2) Didn't find SUBST and in the PST phase
2757 # In either case, return without further processing
2761 }
2762 }
2764 # Variables
2772 }
2773 }
2775 # MSG, MSGNW and RAW
2777 # Check for MSGNW:
2782 # Remove obsolete MSG:
2785 }
2787 # Check for RAW:
2791 }
2792 }
2795 # Parser functions
2801 # Case sensitive functions
2806 # Case insensitive functions
2812 }
2813 }
2819 # Add a frame parameter, and pass the arguments as an array
2824 }
2827 # Convert arguments to plain text
2830 }
2832 }
2834 # Workaround for PHP bug 35229 and similar
2839 }
2849 }
2851 // Extract flags into the local scope
2852 // This allows callers to set flags such as nowiki, found, etc.
2856 }
2860 }
2861 }
2862 }
2864 }
2866 # Finish mangling title and then check for loops.
2867 # Set $title to a Title object and $titleText to the PDBK
2870 # Split the title into page and subpage
2875 }
2879 # Check for language variants if the template is not found
2882 }
2883 # Do recursion depth check
2887 $text = '<span class="error">' . wfMsgForContent( 'parser-template-recursion-depth-warning', $limit ) . '</span>';
2888 }
2889 }
2890 }
2892 # Load from database
2896 if ( $title->getNamespace() == NS_SPECIAL && $this->mOptions->getAllowSpecialInclusion() && $this->ot['html'] ) {
2902 }
2903 } else if ( $wgNonincludableNamespaces && in_array( $title->getNamespace(), $wgNonincludableNamespaces ) ) {
2911 }
2912 }
2914 # If the title is valid but undisplayable, make a link to it
2918 }
2920 // Interwiki transclusion
2926 // Preprocess it like a template
2929 }
2931 }
2933 # Do infinite loop check
2934 # This has to be done after redirect resolution to avoid infinite loops via redirects
2937 $text = '<span class="error">' . wfMsgForContent( 'parser-template-loop-warning', $titleText ) . '</span>';
2939 }
2941 }
2943 # If we haven't found text to substitute by now, we're done
2944 # Recover the source wikitext and return it
2949 }
2951 # Expand DOM-style return values in a child frame
2953 # Clean up argument array
2959 # Expansion is eligible for the empty-frame cache
2965 }
2967 # Uncached expansion
2969 }
2970 }
2974 }
2976 # Replace raw HTML by a placeholder
2977 # Add a blank line preceding, to prevent it from mucking up
2978 # immediately preceding headings
2981 }
2982 # Escape nowiki-style return values
2985 }
2986 # Bug 529: if the template begins with a table or block-level
2987 # element, it should be treated as beginning a new line.
2988 # This behaviour is somewhat controversial.
2989 elseif ( is_string( $text ) && !$piece['lineStart'] && preg_match('/^(?:{\\||:|;|#|\*)/', $text)) /*}*/{
2991 }
2994 # Error, oversize inclusion
2996 $this->insertStripItem( '<!-- WARNING: template omitted, post-expand include size too large -->' );
2998 }
3004 }
3008 }
3010 /**
3011 * Get the semi-parsed DOM representation of a template with a given title,
3012 * and its redirect destination title. Cached.
3013 */
3022 }
3025 }
3027 // Cache miss, go to the database
3033 }
3041 }
3044 }
3046 /**
3047 * Fetch the unparsed text of a template and register a reference to it.
3048 */
3057 }
3058 }
3060 }
3065 }
3067 /**
3068 * Static function to get a template
3069 * Can be overridden via ParserOptions::setTemplateCallback().
3070 */
3076 // Loop to fetch the article, with up to 1 redirect
3078 # Give extensions a chance to select the revision instead
3089 }
3092 // If there is no current revision, there is no page
3096 }
3112 }
3115 }
3118 }
3119 // Redirect?
3122 }
3127 }
3129 /**
3130 * Transclude an interwiki link.
3131 */
3143 }
3155 }
3156 }
3168 }
3171 /**
3172 * Triple brace replacement -- used for template arguments
3173 * @private
3174 */
3185 && (
3189 )
3190 ) {
3191 # No match in frame, use the supplied default
3193 }
3197 }
3200 # No match anywhere
3202 }
3205 }
3210 }
3214 }
3216 /**
3217 * Return the text to be used for a given extension tag.
3218 * This is the ghost of strip().
3219 *
3220 * @param array $params Associative array of parameters:
3221 * name PPNode for the tag name
3222 * attr PPNode for unparsed text where tag attributes are thought to be
3223 * attributes Optional associative array of parsed attributes
3224 * inner Contents of extension element
3225 * noClose Original text did not have a close tag
3226 * @param PPFrame $frame
3227 */
3235 $marker = "{$this->mUniqPrefix}-$name-" . sprintf('%08X', $this->mMarkerIndex++) . self::MARKER_SUFFIX;
3243 }
3251 }
3265 # Workaround for PHP bug 35229 and similar
3268 }
3274 }
3275 }
3279 }
3284 }
3285 }
3291 }
3292 }
3298 }
3300 }
3302 /**
3303 * Increment an include size counter
3304 *
3305 * @param string $type The type of expansion
3306 * @param integer $size The size of the text
3307 * @return boolean False if this inclusion would take it over the maximum, true otherwise
3308 */
3315 }
3316 }
3318 /**
3319 * Increment the expensive function count
3320 *
3321 * @return boolean False if the limit has been exceeded
3322 */
3328 }
3330 }
3332 /**
3333 * Strip double-underscore items like __NOGALLERY__ and __NOTOC__
3334 * Fills $this->mDoubleUnderscores, returns the modified text
3335 */
3338 // The position of __TOC__ needs to be recorded
3344 // Set a placeholder. At the end we'll fill it in with the TOC.
3347 // Only keep the first one.
3349 }
3351 // Now match and remove the rest of them
3357 }
3360 }
3361 if ( isset( $this->mDoubleUnderscores['hiddencat'] ) && $this->mTitle->getNamespace() == NS_CATEGORY ) {
3364 $containerCategory = Title::makeTitleSafe( NS_CATEGORY, wfMsgForContent( 'hidden-category-category' ) );
3369 }
3370 }
3371 # (bug 8068) Allow control over whether robots index a page.
3372 #
3373 # FIXME (bug 14899): __INDEX__ always overrides __NOINDEX__ here! This
3374 # is not desirable, the last one on the page should win.
3379 }
3382 }
3384 /**
3385 * This function accomplishes several tasks:
3386 * 1) Auto-number headings if that option is enabled
3387 * 2) Add an [edit] link to sections for users who have enabled the option and can edit the page
3388 * 3) Add a Table of contents on the top for users who have enabled the option
3389 * 4) Auto-anchor headings
3390 *
3391 * It loops through all headlines, collects the necessary data, then splits up the
3392 * string and re-inserts the newly formatted headlines.
3393 *
3394 * @param string $text
3395 * @param string $origText Original, untouched wikitext
3396 * @param boolean $isMain
3397 * @private
3398 */
3405 // Do not call quickUserCan unless necessary
3408 }
3410 # Inhibit editsection links if requested in the page
3411 if ( isset( $this->mDoubleUnderscores['noeditsection'] ) || $this->mOptions->getIsPrintable() ) {
3413 }
3415 # Get all headlines for numbering them and adding funky stuff like [edit]
3416 # links - this is for later, but we need the number of headlines right now
3418 $numMatches = preg_match_all( '/<H(?P<level>[1-6])(?P<attrib>.*?'.'>)(?P<header>.*?)<\/H[1-6] *>/i', $text, $matches );
3420 # if there are fewer than 4 headlines in the article, do not show TOC
3421 # unless it's been explicitly enabled.
3425 # Allow user to stipulate that a page should have a "new section"
3426 # link added via __NEWSECTIONLINK__
3429 }
3431 # Allow user to remove the "new section"
3432 # link via __NONEWSECTIONLINK__
3435 }
3437 # if the string __FORCETOC__ (not case-sensitive) occurs in the HTML,
3438 # override above conditions and always show TOC above first header
3442 }
3444 # We need this to perform operations on the HTML
3447 # headline counter
3451 # Ugh .. the TOC should have neat indentation levels which can be
3452 # passed to the skin functions. These are determined here
3484 }
3489 }
3493 # Increase TOC level
3500 }
3501 }
3503 # Decrease TOC level, find level to jump to
3507 # Found last matching level
3510 }
3512 # Found first matching level below current level
3515 }
3516 }
3520 # Unindent only if the previous toc level was shown :p
3525 }
3526 }
3527 }
3529 # No change in level, end TOC line
3532 }
3533 }
3537 # count number of headlines for each level
3544 }
3547 }
3548 }
3550 # The safe header is a version of the header text safe to use for links
3551 # Avoid insertion of weird stuff like <math> by expanding the relevant sections
3554 # Remove link placeholders by the link text.
3555 # <!--LINK number-->
3556 # turns into
3557 # link text with suffix
3560 # Strip out HTML (other than plain <sup> and <sub>: bug 8393)
3564 $safeHeadline
3565 );
3568 # For the anchor, strip out HTML-y stuff period
3573 # Save headline for section edit hint before it's escaped
3581 # For reverse compatibility, provide an id that's
3582 # HTML4-compatible, like we used to.
3583 #
3584 # It may be worth noting, academically, that it's possible for
3585 # the legacy anchor to conflict with a non-legacy headline
3586 # anchor on the page. In this case likely the "correct" thing
3587 # would be to either drop the legacy anchors or make sure
3588 # they're numbered first. However, this would require people
3589 # to type in section names like "abc_.D7.93.D7.90.D7.A4"
3590 # manually, so let's not bother worrying about it.
3596 # No reason to have both (in fact, we can't)
3600 # The legacy id is invalid XML. We used to allow this, but
3601 # there's no reason to do so anymore. Backward
3602 # compatibility will fail slightly in this case, but it's
3603 # no big deal.
3605 }
3606 }
3608 # HTML names must be case-insensitively unique (bug 10721). FIXME:
3609 # Does this apply to Unicode characters? Because we aren't
3610 # handling those here.
3616 }
3618 # count how many in assoc. array so we can track dupes in anchors
3623 }
3628 }
3630 # Don't number the heading if it is the only one (looks silly)
3632 # the two are different if the line contains a link
3634 }
3636 # Create the anchor for linking from the TOC to the section
3641 }
3644 }
3648 }
3650 # Add the section to the section tree
3651 # Find the DOM node for this header
3657 }
3661 }
3671 );
3673 # give headline the correct <h#> tag
3676 # Put a T flag in the section identifier, to indicate to extractSections()
3677 # that sections inside <includeonly> should be counted.
3681 }
3684 }
3690 }
3694 # Never ever show TOC if no headers
3697 }
3702 }
3704 }
3709 }
3711 # split up and insert constructed headlines
3718 # This is the [edit] link that appears for the top block of text when
3719 # section editing is enabled
3721 # Disabled because it broke block formatting
3722 # For example, a bullet point in the top line
3723 # $full .= $sk->editSectionLink(0);
3724 }
3727 # Top anchor now in skin
3729 }
3733 }
3735 }
3740 }
3741 }
3743 /**
3744 * Merge $tree2 into $tree1 by replacing the section with index
3745 * $section in $tree1 and its descendants with the sections in $tree2.
3746 * Note that in the returned section tree, only the 'index' and
3747 * 'byteoffset' fields are guaranteed to be correct.
3748 * @param $tree1 array Section tree from ParserOutput::getSectons()
3749 * @param $tree2 array Section tree
3750 * @param $section int Section index
3751 * @param $title Title Title both section trees come from
3752 * @param $len2 int Length of the original wikitext for $tree2
3753 * @return array Merged section tree
3754 */
3767 // We've skipped enough
3769 else
3771 }
3777 // Rewrite index, byteoffset and number
3782 }
3789 // We're at $section
3790 // Insert sections from $tree2 here
3792 // Rewrite the fields in $s2
3793 // before inserting it
3806 }
3807 // Skip all descendants of $section in $tree1
3810 }
3811 }
3813 }
3815 /**
3816 * Increment a section number. Helper function for mergeSectionTrees()
3817 * @param $number array Array representing a section number
3818 * @param $level int Current TOC level (depth)
3819 * @param $lastLevel int Level of previous TOC entry
3820 */
3831 }
3833 /**
3834 * Transform wiki markup when saving a page by doing \r\n -> \n
3835 * conversion, substitting signatures, {{subst:}} templates, etc.
3836 *
3837 * @param string $text the text to transform
3838 * @param Title &$title the Title object for the current article
3839 * @param User $user the User object describing the current user
3840 * @param ParserOptions $options parsing options
3841 * @param bool $clearState whether to clear the parser state first
3842 * @return string the altered wiki markup
3843 * @public
3844 */
3852 }
3856 );
3861 }
3863 /**
3864 * Pre-save transform helper function
3865 * @private
3866 */
3870 /* Note: This is the timestamp saved as hardcoded wikitext to
3871 * the database, we use $wgContLang here in order to give
3872 * everyone the same signature and use the default one rather
3873 * than the one selected in each user's preferences.
3874 *
3875 * (see also bug 12815)
3876 */
3886 /* Allow translation of timezones trough wiki. date() can return
3887 * whatever crap the system uses, localised or not, so we cannot
3888 * ship premade translations.
3889 */
3895 }
3899 # Variable replacement
3900 # Because mOutputType is OT_WIKI, this will only process {{subst:xxx}} type tags
3903 # Signatures
3909 ) );
3911 # Context links: [[|name]] and [[name (context)|]]
3912 #
3919 $p3 = "/\[\[(:?$nc+:|:|)($tc+?)( \\($tc+\\)|)(, $tc+|)\\|]]/"; # [[ns:page (context), context|]]
3922 # try $p1 first, to turn "[[A, B (C)|]]" into "[[A, B (C)|A, B]]"
3934 # if there's no context, don't bother duplicating the title
3936 }
3938 # Trim trailing whitespace
3942 }
3944 /**
3945 * Fetch the user's signature text, if any, and normalize to
3946 * validated, ready-to-insert wikitext.
3947 *
3948 * @param User $user
3949 * @return string
3950 * @private
3951 */
3963 # Sig. might contain markup; validate this
3965 # Validated; clean up (if needed) and return it
3968 # Failed to validate; fall back to the default
3971 }
3972 }
3974 // Make sure nickname doesnt get a sig in a sig
3977 # If we're still here, make it a link to the user page
3984 }
3985 }
3987 /**
3988 * Check that the user's signature contains no bad XML
3989 *
3990 * @param string $text
3991 * @return mixed An expanded string, or false if invalid.
3992 */
3995 }
3997 /**
3998 * Clean up signature text
3999 *
4000 * 1) Strip ~~~, ~~~~ and ~~~~~ out of signatures @see cleanSigInSig
4001 * 2) Substitute all transclusions
4002 *
4003 * @param string $text
4004 * @param $parsing Whether we're cleaning (preferences save) or parsing
4005 * @return string Signature text
4006 */
4014 }
4016 # Option to disable this feature
4019 }
4021 # FIXME: regex doesn't respect extension tags or nowiki
4022 # => Move this logic to braceSubstitution()
4024 $substRegex = '/\{\{(?!(?:' . $substWord->getBaseRegex() . '))/x' . $substWord->getRegexCase();
4035 }
4038 }
4040 /**
4041 * Strip ~~~, ~~~~ and ~~~~~ out of signatures
4042 * @param string $text
4043 * @return string Signature text with /~{3,5}/ removed
4044 */
4048 }
4050 /**
4051 * Set up some variables which are usually set up in parse()
4052 * so that an external function can call some class members with confidence
4053 * @public
4054 */
4061 }
4062 }
4064 /**
4065 * Wrapper for preprocess()
4066 *
4067 * @param string $text the text to preprocess
4068 * @param ParserOptions $options options
4069 * @return string
4070 * @public
4071 */
4076 # Guard against infinite recursion
4079 }
4088 }
4090 /**
4091 * Create an HTML-style tag, e.g. <yourtag>special text</yourtag>
4092 * The callback should have the following form:
4093 * function myParserHook( $text, $params, &$parser ) { ... }
4094 *
4095 * Transform and return $text. Use $parser for any required context, e.g. use
4096 * $parser->getTitle() and $parser->getOptions() not $wgTitle or $wgOut->mParserOptions
4097 *
4098 * @public
4099 *
4100 * @param mixed $tag The tag to use, e.g. 'hook' for <hook>
4101 * @param mixed $callback The callback function (and object) to use for the tag
4102 *
4103 * @return The old value of the mTagHooks array associated with the hook
4104 */
4111 }
4114 }
4118 $oldVal = isset( $this->mTransparentTagHooks[$tag] ) ? $this->mTransparentTagHooks[$tag] : null;
4122 }
4124 /**
4125 * Remove all tag hooks
4126 */
4130 }
4132 /**
4133 * Create a function, e.g. {{sum:1|2|3}}
4134 * The callback function should have the form:
4135 * function myParserFunction( &$parser, $arg1, $arg2, $arg3 ) { ... }
4136 *
4137 * Or with SFH_OBJECT_ARGS:
4138 * function myParserFunction( $parser, $frame, $args ) { ... }
4139 *
4140 * The callback may either return the text result of the function, or an array with the text
4141 * in element 0, and a number of flags in the other elements. The names of the flags are
4142 * specified in the keys. Valid flags are:
4143 * found The text returned is valid, stop processing the template. This
4144 * is on by default.
4145 * nowiki Wiki markup in the return value should be escaped
4146 * isHTML The returned text is HTML, armour it against wikitext transformation
4147 *
4148 * @public
4149 *
4150 * @param string $id The magic word ID
4151 * @param mixed $callback The callback function (and object) to use
4152 * @param integer $flags a combination of the following flags:
4153 * SFH_NO_HASH No leading hash, i.e. {{plural:...}} instead of {{#if:...}}
4154 *
4155 * SFH_OBJECT_ARGS Pass the template arguments as PPNode objects instead of text. This
4156 * allows for conditional expansion of the parse tree, allowing you to eliminate dead
4157 * branches and thus speed up parsing. It is also possible to analyse the parse tree of
4158 * the arguments, and to control the way they are expanded.
4159 *
4160 * The $frame parameter is a PPFrame. This can be used to produce expanded text from the
4161 * arguments, for instance:
4162 * $text = isset( $args[0] ) ? $frame->expand( $args[0] ) : '';
4163 *
4164 * For technical reasons, $args[0] is pre-expanded and will be a string. This may change in
4165 * future versions. Please call $frame->expand() on it anyway so that your code keeps
4166 * working if/when this is changed.
4167 *
4168 * If you want whitespace to be trimmed from $args, you need to do it yourself, post-
4169 * expansion.
4170 *
4171 * Please read the documentation in includes/parser/Preprocessor.php for more information
4172 * about the methods available in PPFrame and PPNode.
4173 *
4174 * @return The old callback function for this name, if any
4175 */
4180 # Add to function cache
4189 # Case
4192 }
4193 # Add leading hash
4196 }
4197 # Remove trailing colon
4200 }
4202 }
4204 }
4206 /**
4207 * Get all registered function hook identifiers
4208 *
4209 * @return array
4210 */
4213 }
4215 /**
4216 * FIXME: update documentation. makeLinkObj() is deprecated.
4217 * Replace <!--LINK--> link placeholders with actual links, in the buffer
4218 * Placeholders created in Skin::makeLinkObj()
4219 * Returns an array of link CSS classes, indexed by PDBK.
4220 */
4223 }
4225 /**
4226 * Replace <!--LINK--> link placeholders with plain text of links
4227 * (not HTML-formatted).
4228 * @param string $text
4229 * @return string
4230 */
4233 }
4235 /**
4236 * Tag hook handler for 'pre'.
4237 */
4239 // Backwards-compatibility hack
4246 }
4248 /**
4249 * Renders an image gallery from a text with one line per image.
4250 * text labels may be given by using |-style alternative text. E.g.
4251 * Image:one.jpg|The number "1"
4252 * Image:tree.jpg|A tree
4253 * given as text will return the HTML of a gallery with two images,
4254 * labeled 'The number "1"' and
4255 * 'A tree'.
4256 */
4273 }
4276 }
4279 }
4282 }
4288 # match lines like these:
4289 # Image:someimage.jpg|This is some image
4292 # Skip empty lines
4295 }
4302 # Bogus title. Ignore these so we don't bomb out later.
4304 }
4309 }
4315 # Only add real images (bug #5586)
4318 }
4319 }
4321 }
4328 }
4330 // Initialise static lists
4337 );
4345 }
4346 }
4347 }
4349 // Add handler params
4355 }
4356 }
4359 }
4360 return array( $this->mImageParams[$handlerClass], $this->mImageParamsMagicArray[$handlerClass] );
4361 }
4363 /**
4364 * Parse image options text and use it to make an image
4365 * @param Title $title
4366 * @param string $options
4367 * @param LinkHolderArray $holders
4368 */
4370 # Check if the options text is of the form "options|alt text"
4371 # Options are:
4372 # * thumbnail make a thumbnail with enlarge-icon and caption, alignment depends on lang
4373 # * left no resizing, just left align. label is used for alt= only
4374 # * right same, but right aligned
4375 # * none same, but not aligned
4376 # * ___px scale to ___ pixels width, no aligning. e.g. use in taxobox
4377 # * center center the image
4378 # * framed Keep original image size, no magnify-button.
4379 # * frameless like 'thumb' but without a frame. Keeps user preferences for width
4380 # * upright reduce width for upright images, rounded to full __0 px
4381 # * border draw a 1px border around the image
4382 # * alt Text for HTML alt attribute (defaults to empty)
4383 # vertical-align values (no % or length right now):
4384 # * baseline
4385 # * sub
4386 # * super
4387 # * top
4388 # * text-top
4389 # * middle
4390 # * bottom
4391 # * text-bottom
4396 # Give extensions a chance to select the file revision for us
4398 wfRunHooks( 'BeforeParserMakeImageLinkObj', array( &$this, &$title, &$skip, &$time, &$descQuery ) );
4402 }
4404 # Get the file
4412 }
4414 }
4415 # Get parameter map
4420 # Process the input parameters
4431 // Special case; width and height come in one variable together
4434 # (bug 13500) In both cases (width/height and width only),
4435 # permit trailing "px" for backward compatibility.
4442 }
4446 }
4452 }
4456 # Validate handler parameter
4459 # Validate internal parameters
4463 // @fixme - possibly check validity here for
4464 // manualthumb? downstream behavior seems odd with
4465 // missing manual thumbs.
4481 }
4489 }
4490 }
4493 // Most other things appear to be empty or numeric...
4495 }
4496 }
4500 }
4501 }
4502 }
4505 }
4506 }
4508 # Process alignment parameters
4511 }
4514 }
4520 # In the old days, [[Image:Foo|text...]] would set alt text. Later it
4521 # came to also set the caption, ordinary text after the image -- which
4522 # makes no sense, because that just repeats the text multiple times in
4523 # screen readers. It *also* came to set the title attribute.
4524 #
4525 # Now that we have an alt attribute, we should not set the alt text to
4526 # equal the caption: that's worse than useless, it just repeats the
4527 # text. This is the framed/thumbnail case. If there's no caption, we
4528 # use the unnamed parameter for alt text as well, just for the time be-
4529 # ing, if the unnamed param is set and the alt param is not.
4530 #
4531 # For the future, we need to figure out if we want to tweak this more,
4532 # e.g., introducing a title= parameter for the title; ignoring the un-
4533 # named parameter entirely for images without a caption; adding an ex-
4534 # plicit caption= parameter and preserving the old magic unnamed para-
4535 # meter for BC; ...
4541 }
4545 # Linker does the rest
4546 $ret = $sk->makeImageLink2( $title, $file, $params['frame'], $params['handler'], $time, $descQuery );
4548 # Give the handler a chance to modify the parser object
4551 }
4554 }
4557 # Strip bad stuff out of the title (tooltip). We can't just use
4558 # replaceLinkHoldersText() here, because if this function is called
4559 # from replaceInternalLinks2(), mLinkHolders won't be up-to-date.
4564 }
4566 # make sure there are no placeholders in thumbnail attributes
4567 # that are later expanded to html- so expand them now and
4568 # remove the tags
4573 }
4575 /**
4576 * Set a flag in the output object indicating that the content is dynamic and
4577 * shouldn't be cached.
4578 */
4582 }
4584 /**#@+
4585 * Callback from the Sanitizer for expanding items found in HTML attribute
4586 * values, so they can be safely tested and escaped.
4587 * @param string $text
4588 * @param PPFrame $frame
4589 * @return string
4590 * @private
4591 */
4596 }
4598 /**#@-*/
4600 /**#@+
4601 * Accessor/mutator
4602 */
4606 /**#@-*/
4608 /**#@+
4609 * Accessor
4610 */
4611 function getTags() { return array_merge( array_keys($this->mTransparentTagHooks), array_keys( $this->mTagHooks ) ); }
4612 /**#@-*/
4615 /**
4616 * Break wikitext input into sections, and either pull or replace
4617 * some particular section's text.
4618 *
4619 * External callers should use the getSection and replaceSection methods.
4620 *
4621 * @param string $text Page wikitext
4622 * @param string $section A section identifier string of the form:
4623 * <flag1> - <flag2> - ... - <section number>
4624 *
4625 * Currently the only recognised flag is "T", which means the target section number
4626 * was derived during a template inclusion parse, in other words this is a template
4627 * section edit link. If no flags are given, it was an ordinary section edit link.
4628 * This flag is required to avoid a section numbering mismatch when a section is
4629 * enclosed by <includeonly> (bug 6563).
4630 *
4631 * The section number 0 pulls the text before the first heading; other numbers will
4632 * pull the given section along with its lower-level subsections. If the section is
4633 * not found, $mode=get will return $newtext, and $mode=replace will return $text.
4634 *
4635 * @param string $mode One of "get" or "replace"
4636 * @param string $newText Replacement text for section data.
4637 * @return string for "get", the extracted section text.
4638 * for "replace", the whole page with the section replaced.
4639 */
4649 // Process section extraction flags
4656 }
4657 }
4658 // Preprocess the text
4661 // <h> nodes indicate section breaks
4662 // They can only occur at the top level, so we can find them by iterating the root's children
4665 // Find the target section
4667 // Section zero doesn't nest, level=big
4676 }
4677 }
4680 }
4682 }
4683 }
4686 // Not found
4691 }
4692 }
4694 // Find the end of the section, including nested sections
4701 }
4702 }
4705 }
4709 // Write out the remainder (in replace mode only)
4711 // Output the replacement text
4712 // Add two newlines on -- trailing whitespace in $newText is conventionally
4713 // stripped by the editor, so we need both newlines to restore the paragraph gap
4714 // Only add trailing whitespace if there is newText
4717 }
4722 }
4723 }
4726 // Re-insert stripped tags
4728 }
4731 }
4733 /**
4734 * This function returns the text of a section, specified by a number ($section).
4735 * A section is text under a heading like == Heading == or \<h1\>Heading\</h1\>, or
4736 * the first section before any such heading (section 0).
4737 *
4738 * If a section contains subsections, these are also returned.
4739 *
4740 * @param string $text text to look in
4741 * @param string $section section identifier
4742 * @param string $deftext default to return if section is not found
4743 * @return string text of the requested section
4744 */
4747 }
4751 }
4753 /**
4754 * Get the timestamp associated with the current revision, adjusted for
4755 * the default server-local timestamp
4756 */
4765 // Normalize timestamp to internal MW format for timezone processing.
4766 // This has the added side-effect of replacing a null value with
4767 // the current time, which gives us more sensible behavior for
4768 // previews.
4771 // The cryptic '' timezone parameter tells to use the site-default
4772 // timezone offset instead of the user settings.
4773 //
4774 // Since this value will be saved into the parser cache, served
4775 // to other users, and potentially even used inside links and such,
4776 // it needs to be consistent for all visitors.
4780 }
4782 }
4784 /**
4785 * Get the name of the user that edited the last revision
4786 */
4788 // if this template is subst: the revision id will be blank,
4789 // so just use the current user's name
4796 }
4798 }
4800 /**
4801 * Mutator for $mDefaultSort
4802 *
4803 * @param $sort New value
4804 */
4807 }
4809 /**
4810 * Accessor for $mDefaultSort
4811 * Will use the title/prefixed title if none is set
4812 *
4813 * @return string
4814 */
4824 }
4825 }
4827 /**
4828 * Accessor for $mDefaultSort
4829 * Unlike getDefaultSort(), will return false if none is set
4830 *
4831 * @return string or false
4832 */
4835 }
4837 /**
4838 * Try to guess the section anchor name based on a wikitext fragment
4839 * presumably extracted from a heading, for example "Header" from
4840 * "== Header ==".
4841 */
4843 # Strip out wikitext links(they break the anchor)
4846 # strip out HTML
4853 );
4858 }
4860 /**
4861 * Strips a text string of wikitext for use in a section anchor
4862 *
4863 * Accepts a text string and then removes all wikitext from the
4864 * string and leaves only the resultant text (i.e. the result of
4865 * [[User:WikiSysop|Sysop]] would be "Sysop" and the result of
4866 * [[User:WikiSysop]] would be "User:WikiSysop") - this is intended
4867 * to create valid section anchors by mimicing the output of the
4868 * parser when headings are parsed.
4869 *
4870 * @param $text string Text string to be stripped of wikitext
4871 * for use in a Section anchor
4872 * @return Filtered text string
4873 */
4875 # Strip internal link markup
4879 # Strip external link markup (FIXME: Not Tolerant to blank link text
4880 # I.E. [http://www.mediawiki.org] will render as [1] or something depending
4881 # on how many empty links there are on the page - need to figure that out.
4884 # Parse wikitext quotes (italics & bold)
4887 # Strip HTML tags
4890 }
4894 }
4896 /**
4897 * strip/replaceVariables/unstrip for preprocessor regression testing
4898 */
4903 }
4911 }
4917 }
4919 }
4924 }
4926 }
4946 }
4947 }
4948 }
4950 }
4956 // First, find all strip markers, and store their
4957 // data in an array.
4960 while( ( $start_pos = strpos( $text, $this->mUniqPrefix, $pos ) ) && ( $end_pos = strpos( $text, self::MARKER_SUFFIX, $pos ) ) ) {
4972 }
4976 }
4979 // Now, find all of our links, and store THEIR
4980 // data in an array! :)
4984 // Internal links
4991 }
4996 }
5000 // Interwiki links
5006 }
5011 }
5013 function unserialiseHalfParsedText( $data, $intPrefix = null /* Unique identifying prefix */ ) {
5017 // First, extract the strip state.
5022 // Now, extract the text, and renumber links
5026 // Internal...
5033 }
5034 }
5036 // Interwiki...
5042 }
5044 // Should be good to go.
5046 }
5047 }
5049 /**
5050 * @todo document, briefly.
5051 * @ingroup Parser
5052 */
5059 }
5069 }
5079 }
5090 }
5091 }
5093 /**
5094 * @todo document, briefly.
5095 * @ingroup Parser
5096 */
5105 }
5106 }
5107 }