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] );
}
# Close an open ';
$this->lastSection = 'pre';
}
$t = substr( $t, 1 );
} else {
# paragraph
if ( trim( $t ) === '' ) {
if ( $pendingPTag ) {
$output .= $pendingPTag . '
';
$pendingPTag = false;
$this->lastSection = 'p';
} else {
if ( $this->lastSection !== 'p' ) {
$output .= $this->closeParagraph();
$this->lastSection = '';
$pendingPTag = '';
} else {
$pendingPTag = '
';
}
}
} else {
if ( $pendingPTag ) {
$output .= $pendingPTag;
$pendingPTag = false;
$this->lastSection = 'p';
} elseif ( $this->lastSection !== 'p' ) {
$output .= $this->closeParagraph() . '
';
$this->lastSection = 'p';
}
}
}
}
}
# somewhere above we forget to get out of pre block (T2785)
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 .= '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 ) {
if ( !preg_match( '/:|<|-\{/', $str, $m, PREG_OFFSET_CAPTURE ) ) {
# Nothing to find!
return false;
}
if ( $m[0][0] === ':' ) {
# Easy; no tag nesting to worry about
$colonPos = $m[0][1];
$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;
$ltLevel = 0;
$lcLevel = 0;
$len = strlen( $str );
for ( $i = $m[0][1]; $i < $len; $i++ ) {
$c = $str[$i];
switch ( $state ) {
case self::COLON_STATE_TEXT:
switch ( $c ) {
case "<":
# Could be either a tag or an tag
$state = self::COLON_STATE_TAGSTART;
break;
case ":":
if ( $ltLevel === 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
if ( !preg_match( '/:|<|-\{/', $str, $m, PREG_OFFSET_CAPTURE, $i ) ) {
# Nothing else interesting
return false;
}
if ( $m[0][0] === '-{' ) {
$state = self::COLON_STATE_LC;
$lcLevel++;
$i = $m[0][1] + 1;
} else {
# Skip ahead to next interesting character.
$i = $m[0][1] - 1;
}
break;
}
break;
case self::COLON_STATE_LC:
# In language converter markup -{ ... }-
if ( !preg_match( '/-\{|\}-/', $str, $m, PREG_OFFSET_CAPTURE, $i ) ) {
# Nothing else interesting to find; abort!
# We're nested in language converter markup, but there
# are no close tags left. Abort!
break 2;
} elseif ( $m[0][0] === '-{' ) {
$i = $m[0][1] + 1;
$lcLevel++;
} elseif ( $m[0][0] === '}-' ) {
$i = $m[0][1] + 1;
$lcLevel--;
if ( $lcLevel === 0 ) {
$state = self::COLON_STATE_TEXT;
}
}
break;
case self::COLON_STATE_TAG:
# In a
switch ( $c ) {
case ">":
$ltLevel++;
$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
if ( $c === ">" ) {
if ( $ltLevel > 0 ) {
$ltLevel--;
} else {
# ignore the excess close tag, but keep looking for
# colons. (This matches Parsoid behavior.)
wfDebug( __METHOD__ . ": Invalid input; too many close tags\n" );
}
$state = self::COLON_STATE_TEXT;
}
break;
case self::COLON_STATE_TAGSLASH:
if ( $c === ">" ) {
# Yes, a self-closed tag