| Current File : /home/jvzmxxx/wiki/includes/parser/BlockLevelPass.php |
<?php
/**
* This is the part of the wikitext parser which handles automatic paragraphs
* and conversion of start-of-line prefixes to HTML lists.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
* http://www.gnu.org/copyleft/gpl.html
*
* @file
* @ingroup Parser
*/
class BlockLevelPass {
private $DTopen = false;
private $inPre = false;
private $lastSection = '';
private $linestart;
private $text;
# State constants for the definition list colon extraction
const COLON_STATE_TEXT = 0;
const COLON_STATE_TAG = 1;
const COLON_STATE_TAGSTART = 2;
const COLON_STATE_CLOSETAG = 3;
const COLON_STATE_TAGSLASH = 4;
const COLON_STATE_COMMENT = 5;
const COLON_STATE_COMMENTDASH = 6;
const COLON_STATE_COMMENTDASHDASH = 7;
/**
* Make lists from lines starting with ':', '*', '#', etc.
*
* @param string $text
* @param bool $lineStart Whether or not this is at the start of a line.
* @return string The lists rendered as HTML
*/
public static function doBlockLevels( $text, $lineStart ) {
$pass = new self( $text, $lineStart );
return $pass->execute();
}
/**
* Private constructor
*/
private function __construct( $text, $lineStart ) {
$this->text = $text;
$this->lineStart = $lineStart;
}
/**
* If a pre or p is open, return the corresponding close tag and update
* the state. If no tag is open, return an empty string.
* @return string
*/
private function closeParagraph() {
$result = '';
if ( $this->lastSection !== '' ) {
$result = '</' . $this->lastSection . ">\n";
}
$this->inPre = false;
$this->lastSection = '';
return $result;
}
/**
* getCommon() returns the length of the longest common substring
* of both arguments, starting at the beginning of both.
*
* @param string $st1
* @param string $st2
*
* @return int
*/
private function getCommon( $st1, $st2 ) {
$shorter = min( strlen( $st1 ), strlen( $st2 ) );
for ( $i = 0; $i < $shorter; ++$i ) {
if ( $st1[$i] !== $st2[$i] ) {
break;
}
}
return $i;
}
/**
* Open the list item element identified by the prefix character.
*
* @param string $char
*
* @return string
*/
private function openList( $char ) {
$result = $this->closeParagraph();
if ( '*' === $char ) {
$result .= "<ul><li>";
} elseif ( '#' === $char ) {
$result .= "<ol><li>";
} elseif ( ':' === $char ) {
$result .= "<dl><dd>";
} elseif ( ';' === $char ) {
$result .= "<dl><dt>";
$this->DTopen = true;
} else {
$result = '<!-- ERR 1 -->';
}
return $result;
}
/**
* Close the current list item and open the next one.
* @param string $char
*
* @return string
*/
private function nextItem( $char ) {
if ( '*' === $char || '#' === $char ) {
return "</li>\n<li>";
} elseif ( ':' === $char || ';' === $char ) {
$close = "</dd>\n";
if ( $this->DTopen ) {
$close = "</dt>\n";
}
if ( ';' === $char ) {
$this->DTopen = true;
return $close . '<dt>';
} else {
$this->DTopen = false;
return $close . '<dd>';
}
}
return '<!-- ERR 2 -->';
}
/**
* Close the current list item identified by the prefix character.
* @param string $char
*
* @return string
*/
private function closeList( $char ) {
if ( '*' === $char ) {
$text = "</li></ul>";
} elseif ( '#' === $char ) {
$text = "</li></ol>";
} elseif ( ':' === $char ) {
if ( $this->DTopen ) {
$this->DTopen = false;
$text = "</dt></dl>";
} else {
$text = "</dd></dl>";
}
} else {
return '<!-- ERR 3 -->';
}
return $text;
}
/**
* Execute the pass.
* @return string
*/
private function execute() {
$text = $this->text;
# Parsing through the text line by line. The main thing
# happening here is handling of block-level elements p, pre,
# and making lists from lines starting with * # : etc.
$textLines = StringUtils::explode( "\n", $text );
$lastPrefix = $output = '';
$this->DTopen = $inBlockElem = false;
$prefixLength = 0;
$pendingPTag = false;
$inBlockquote = false;
foreach ( $textLines as $inputLine ) {
# Fix up $lineStart
if ( !$this->lineStart ) {
$output .= $inputLine;
$this->lineStart = true;
continue;
}
# * = ul
# # = ol
# ; = dt
# : = dd
$lastPrefixLength = strlen( $lastPrefix );
$preCloseMatch = preg_match( '/<\\/pre/i', $inputLine );
$preOpenMatch = preg_match( '/<pre/i', $inputLine );
# If not in a <pre> element, scan for and figure out what prefixes are there.
if ( !$this->inPre ) {
# Multiple prefixes may abut each other for nested lists.
$prefixLength = strspn( $inputLine, '*#:;' );
$prefix = substr( $inputLine, 0, $prefixLength );
# eh?
# ; and : are both from definition-lists, so they're equivalent
# for the purposes of determining whether or not we need to open/close
# elements.
$prefix2 = str_replace( ';', ':', $prefix );
$t = substr( $inputLine, $prefixLength );
$this->inPre = (bool)$preOpenMatch;
} else {
# Don't interpret any other prefixes in preformatted text
$prefixLength = 0;
$prefix = $prefix2 = '';
$t = $inputLine;
}
# List generation
if ( $prefixLength && $lastPrefix === $prefix2 ) {
# Same as the last item, so no need to deal with nesting or opening stuff
$output .= $this->nextItem( substr( $prefix, -1 ) );
$pendingPTag = false;
if ( substr( $prefix, -1 ) === ';' ) {
# The one nasty exception: definition lists work like this:
# ; title : definition text
# So we check for : in the remainder text to split up the
# title and definition, without b0rking links.
$term = $t2 = '';
if ( $this->findColonNoLinks( $t, $term, $t2 ) !== false ) {
$t = $t2;
$output .= $term . $this->nextItem( ':' );
}
}
} elseif ( $prefixLength || $lastPrefixLength ) {
# We need to open or close prefixes, or both.
# Either open or close a level...
$commonPrefixLength = $this->getCommon( $prefix, $lastPrefix );
$pendingPTag = false;
# Close all the prefixes which aren't shared.
while ( $commonPrefixLength < $lastPrefixLength ) {
$output .= $this->closeList( $lastPrefix[$lastPrefixLength - 1] );
--$lastPrefixLength;
}
# Continue the current prefix if appropriate.
if ( $prefixLength <= $commonPrefixLength && $commonPrefixLength > 0 ) {
$output .= $this->nextItem( $prefix[$commonPrefixLength - 1] );
}
# Open prefixes where appropriate.
if ( $lastPrefix && $prefixLength > $commonPrefixLength ) {
$output .= "\n";
}
while ( $prefixLength > $commonPrefixLength ) {
$char = substr( $prefix, $commonPrefixLength, 1 );
$output .= $this->openList( $char );
if ( ';' === $char ) {
# @todo FIXME: This is dupe of code above
if ( $this->findColonNoLinks( $t, $term, $t2 ) !== false ) {
$t = $t2;
$output .= $term . $this->nextItem( ':' );
}
}
++$commonPrefixLength;
}
if ( !$prefixLength && $lastPrefix ) {
$output .= "\n";
}
$lastPrefix = $prefix2;
}
# If we have no prefixes, go to paragraph mode.
if ( 0 == $prefixLength ) {
# No prefix (not in list)--go to paragraph mode
# @todo consider using a stack for nestable elements like span, table and div
$openMatch = preg_match(
'/(?:<table|<h1|<h2|<h3|<h4|<h5|<h6|<pre|<tr|'
. '<p|<ul|<ol|<dl|<li|<\\/tr|<\\/td|<\\/th)/iS',
$t
);
$closeMatch = preg_match(
'/(?:<\\/table|<\\/h1|<\\/h2|<\\/h3|<\\/h4|<\\/h5|<\\/h6|'
. '<td|<th|<\\/?blockquote|<\\/?div|<hr|<\\/pre|<\\/p|<\\/mw:|'
. Parser::MARKER_PREFIX
. '-pre|<\\/li|<\\/ul|<\\/ol|<\\/dl|<\\/?center)/iS',
$t
);
if ( $openMatch || $closeMatch ) {
$pendingPTag = false;
# @todo bug 5718: paragraph closed
$output .= $this->closeParagraph();
if ( $preOpenMatch && !$preCloseMatch ) {
$this->inPre = true;
}
$bqOffset = 0;
while ( preg_match( '/<(\\/?)blockquote[\s>]/i', $t,
$bqMatch, PREG_OFFSET_CAPTURE, $bqOffset )
) {
$inBlockquote = !$bqMatch[1][0]; // is this a close tag?
$bqOffset = $bqMatch[0][1] + strlen( $bqMatch[0][0] );
}
$inBlockElem = !$closeMatch;
} elseif ( !$inBlockElem && !$this->inPre ) {
if ( ' ' == substr( $t, 0, 1 )
&& ( $this->lastSection === 'pre' || trim( $t ) != '' )
&& !$inBlockquote
) {
# pre
if ( $this->lastSection !== 'pre' ) {
$pendingPTag = false;
$output .= $this->closeParagraph() . '<pre>';
$this->lastSection = 'pre';
}
$t = substr( $t, 1 );
} else {
# paragraph
if ( trim( $t ) === '' ) {
if ( $pendingPTag ) {
$output .= $pendingPTag . '<br />';
$pendingPTag = false;
$this->lastSection = 'p';
} else {
if ( $this->lastSection !== 'p' ) {
$output .= $this->closeParagraph();
$this->lastSection = '';
$pendingPTag = '<p>';
} else {
$pendingPTag = '</p><p>';
}
}
} else {
if ( $pendingPTag ) {
$output .= $pendingPTag;
$pendingPTag = false;
$this->lastSection = 'p';
} elseif ( $this->lastSection !== 'p' ) {
$output .= $this->closeParagraph() . '<p>';
$this->lastSection = 'p';
}
}
}
}
}
# somewhere above we forget to get out of pre block (bug 785)
if ( $preCloseMatch && $this->inPre ) {
$this->inPre = false;
}
if ( $pendingPTag === false ) {
$output .= $t;
if ( $prefixLength === 0 ) {
$output .= "\n";
}
}
}
while ( $prefixLength ) {
$output .= $this->closeList( $prefix2[$prefixLength - 1] );
--$prefixLength;
if ( !$prefixLength ) {
$output .= "\n";
}
}
if ( $this->lastSection !== '' ) {
$output .= '</' . $this->lastSection . '>';
$this->lastSection = '';
}
return $output;
}
/**
* Split up a string on ':', ignoring any occurrences inside tags
* to prevent illegal overlapping.
*
* @param string $str The string to split
* @param string &$before Set to everything before the ':'
* @param string &$after Set to everything after the ':'
* @throws MWException
* @return string The position of the ':', or false if none found
*/
private function findColonNoLinks( $str, &$before, &$after ) {
$colonPos = strpos( $str, ':' );
if ( $colonPos === false ) {
# Nothing to find!
return false;
}
$ltPos = strpos( $str, '<' );
if ( $ltPos === false || $ltPos > $colonPos ) {
# Easy; no tag nesting to worry about
$before = substr( $str, 0, $colonPos );
$after = substr( $str, $colonPos + 1 );
return $colonPos;
}
# Ugly state machine to walk through avoiding tags.
$state = self::COLON_STATE_TEXT;
$level = 0;
$len = strlen( $str );
for ( $i = 0; $i < $len; $i++ ) {
$c = $str[$i];
switch ( $state ) {
case self::COLON_STATE_TEXT:
switch ( $c ) {
case "<":
# Could be either a <start> tag or an </end> tag
$state = self::COLON_STATE_TAGSTART;
break;
case ":":
if ( $level === 0 ) {
# We found it!
$before = substr( $str, 0, $i );
$after = substr( $str, $i + 1 );
return $i;
}
# Embedded in a tag; don't break it.
break;
default:
# Skip ahead looking for something interesting
$colonPos = strpos( $str, ':', $i );
if ( $colonPos === false ) {
# Nothing else interesting
return false;
}
$ltPos = strpos( $str, '<', $i );
if ( $level === 0 ) {
if ( $ltPos === false || $colonPos < $ltPos ) {
# We found it!
$before = substr( $str, 0, $colonPos );
$after = substr( $str, $colonPos + 1 );
return $i;
}
}
if ( $ltPos === false ) {
# Nothing else interesting to find; abort!
# We're nested, but there's no close tags left. Abort!
break 2;
}
# Skip ahead to next tag start
$i = $ltPos;
$state = self::COLON_STATE_TAGSTART;
}
break;
case self::COLON_STATE_TAG:
# In a <tag>
switch ( $c ) {
case ">":
$level++;
$state = self::COLON_STATE_TEXT;
break;
case "/":
# Slash may be followed by >?
$state = self::COLON_STATE_TAGSLASH;
break;
default:
# ignore
}
break;
case self::COLON_STATE_TAGSTART:
switch ( $c ) {
case "/":
$state = self::COLON_STATE_CLOSETAG;
break;
case "!":
$state = self::COLON_STATE_COMMENT;
break;
case ">":
# Illegal early close? This shouldn't happen D:
$state = self::COLON_STATE_TEXT;
break;
default:
$state = self::COLON_STATE_TAG;
}
break;
case self::COLON_STATE_CLOSETAG:
# In a </tag>
if ( $c === ">" ) {
$level--;
if ( $level < 0 ) {
wfDebug( __METHOD__ . ": Invalid input; too many close tags\n" );
return false;
}
$state = self::COLON_STATE_TEXT;
}
break;
case self::COLON_STATE_TAGSLASH:
if ( $c === ">" ) {
# Yes, a self-closed tag <blah/>
$state = self::COLON_STATE_TEXT;
} else {
# Probably we're jumping the gun, and this is an attribute
$state = self::COLON_STATE_TAG;
}
break;
case self::COLON_STATE_COMMENT:
if ( $c === "-" ) {
$state = self::COLON_STATE_COMMENTDASH;
}
break;
case self::COLON_STATE_COMMENTDASH:
if ( $c === "-" ) {
$state = self::COLON_STATE_COMMENTDASHDASH;
} else {
$state = self::COLON_STATE_COMMENT;
}
break;
case self::COLON_STATE_COMMENTDASHDASH:
if ( $c === ">" ) {
$state = self::COLON_STATE_TEXT;
} else {
$state = self::COLON_STATE_COMMENT;
}
break;
default:
throw new MWException( "State machine error in " . __METHOD__ );
}
}
if ( $level > 0 ) {
wfDebug( __METHOD__ . ": Invalid input; not enough close tags (level $level, state $state)\n" );
return false;
}
return false;
}
}