X-Git-Url: http://git.heureux-cyclage.org/?a=blobdiff_plain;f=includes%2FStringUtils.php;h=f20c548d7d65e16c8cde94fa3678d689e278213c;hb=9994758337412d3c0263f66317e1e88393c17a0c;hp=9a451aa8dc5466325dcdc32a66affa7033222ef4;hpb=16558d1dbc8e3ea1d2b1e8d3f5837133d7ee740f;p=lhc%2Fweb%2Fwiklou.git diff --git a/includes/StringUtils.php b/includes/StringUtils.php index 9a451aa8dc..f20c548d7d 100644 --- a/includes/StringUtils.php +++ b/includes/StringUtils.php @@ -4,15 +4,22 @@ */ class StringUtils { /** - * Perform an operation equivalent to + * Perform an operation equivalent to * * preg_replace( "!$startDelim(.*?)$endDelim!", $replace, $subject ); * * except that it's worst-case O(N) instead of O(N^2) * * Compared to delimiterReplace(), this implementation is fast but memory- - * hungry and inflexible. The memory requirements are such that I don't + * hungry and inflexible. The memory requirements are such that I don't * recommend using it on anything but guaranteed small chunks of text. + * + * @param $startDelim + * @param $endDelim + * @param $replace + * @param $subject + * + * @return string */ static function hungryDelimiterReplace( $startDelim, $endDelim, $replace, $subject ) { $segments = explode( $startDelim, $subject ); @@ -27,22 +34,28 @@ class StringUtils { } return $output; } - + /** - * Perform an operation equivalent to + * Perform an operation equivalent to * * preg_replace_callback( "!$startDelim(.*)$endDelim!s$flags", $callback, $subject ) * * This implementation is slower than hungryDelimiterReplace but uses far less * memory. The delimiters are literal strings, not regular expressions. * - * @param string $flags Regular expression flags + * If the start delimiter ends with an initial substring of the end delimiter, + * e.g. in the case of C-style comments, the behaviour differs from the model + * regex. In this implementation, the end must share no characters with the + * start, so e.g. /*\/ is not considered to be both the start and end of a + * comment. /*\/xy/*\/ is considered to be a single comment with contents /xy/. + * + * @param $startDelim String: start delimiter + * @param $endDelim String: end delimiter + * @param $callback Callback: function to call on each match + * @param $subject String + * @param $flags String: regular expression flags + * @return string */ - # If the start delimiter ends with an initial substring of the end delimiter, - # e.g. in the case of C-style comments, the behaviour differs from the model - # regex. In this implementation, the end must share no characters with the - # start, so e.g. /*/ is not considered to be both the start and end of a - # comment. /*/xy/*/ is considered to be a single comment with contents /xy/. static function delimiterReplaceCallback( $startDelim, $endDelim, $callback, $subject, $flags = '' ) { $inputPos = 0; $outputPos = 0; @@ -53,13 +66,13 @@ class StringUtils { $strcmp = strpos( $flags, 'i' ) === false ? 'strcmp' : 'strcasecmp'; $endLength = strlen( $endDelim ); $m = array(); - - while ( $inputPos < strlen( $subject ) && - preg_match( "!($encStart)|($encEnd)!S$flags", $subject, $m, PREG_OFFSET_CAPTURE, $inputPos ) ) + + while ( $inputPos < strlen( $subject ) && + preg_match( "!($encStart)|($encEnd)!S$flags", $subject, $m, PREG_OFFSET_CAPTURE, $inputPos ) ) { $tokenOffset = $m[0][1]; if ( $m[1][0] != '' ) { - if ( $foundStart && + if ( $foundStart && $strcmp( $endDelim, substr( $subject, $tokenOffset, $endLength ) ) == 0 ) { # An end match is present at the same location @@ -77,16 +90,20 @@ class StringUtils { } if ( $tokenType == 'start' ) { - $inputPos = $tokenOffset + $tokenLength; # Only move the start position if we haven't already found a start # This means that START START END matches outer pair if ( !$foundStart ) { # Found start + $inputPos = $tokenOffset + $tokenLength; # Write out the non-matching section $output .= substr( $subject, $outputPos, $tokenOffset - $outputPos ); $outputPos = $tokenOffset; $contentPos = $inputPos; $foundStart = true; + } else { + # Move the input position past the *first character* of START, + # to protect against missing END when it overlaps with START + $inputPos = $tokenOffset + 1; } } elseif ( $tokenType == 'end' ) { if ( $foundStart ) { @@ -111,17 +128,18 @@ class StringUtils { return $output; } - /* - * Perform an operation equivalent to + /** + * Perform an operation equivalent to * * preg_replace( "!$startDelim(.*)$endDelim!$flags", $replace, $subject ) * - * @param string $startDelim Start delimiter regular expression - * @param string $endDelim End delimiter regular expression - * @param string $replace Replacement string. May contain $1, which will be - * replaced by the text between the delimiters - * @param string $subject String to search - * @return string The string with the matches replaced + * @param $startDelim String: start delimiter regular expression + * @param $endDelim String: end delimiter regular expression + * @param $replace String: replacement string. May contain $1, which will be + * replaced by the text between the delimiters + * @param $subject String to search + * @param $flags String: regular expression flags + * @return String: The string with the matches replaced */ static function delimiterReplace( $startDelim, $endDelim, $replace, $subject, $flags = '' ) { $replacer = new RegexlikeReplacer( $replace ); @@ -132,16 +150,16 @@ class StringUtils { /** * More or less "markup-safe" explode() * Ignores any instances of the separator inside <...> - * @param string $separator - * @param string $text + * @param $separator String + * @param $text String * @return array */ static function explodeMarkup( $separator, $text ) { $placeholder = "\x00"; - + // Remove placeholder instances $text = str_replace( $placeholder, '', $text ); - + // Replace instances of the separator inside HTML-like tags with the placeholder $replacer = new DoubleReplacer( $separator, $placeholder ); $cleaned = StringUtils::delimiterReplaceCallback( '<', '>', $replacer->cb(), $text ); @@ -151,7 +169,7 @@ class StringUtils { foreach( $items as $i => $str ) { $items[$i] = str_replace( $placeholder, $separator, $str ); } - + return $items; } @@ -159,18 +177,33 @@ class StringUtils { * Escape a string to make it suitable for inclusion in a preg_replace() * replacement parameter. * - * @param string $string - * @return string + * @param $string String + * @return String */ static function escapeRegexReplacement( $string ) { $string = str_replace( '\\', '\\\\', $string ); $string = str_replace( '$', '\\$', $string ); return $string; } + + /** + * Workalike for explode() with limited memory usage. + * Returns an Iterator + * @param $separator + * @param $subject + * @return ArrayIterator|\ExplodeIterator + */ + static function explode( $separator, $subject ) { + if ( substr_count( $subject, $separator ) > 1000 ) { + return new ExplodeIterator( $separator, $subject ); + } else { + return new ArrayIterator( explode( $separator, $subject ) ); + } + } } /** - * Base class for "replacers", objects used in preg_replace_callback() and + * Base class for "replacers", objects used in preg_replace_callback() and * StringUtils::delimiterReplaceCallback() */ class Replacer { @@ -207,7 +240,7 @@ class DoubleReplacer extends Replacer { $this->to = $to; $this->index = $index; } - + function replace( $matches ) { return str_replace( $this->from, $this->to, $matches[$this->index] ); } @@ -283,6 +316,17 @@ class ReplacementArray { $this->fss = false; } + function removePair( $from ) { + unset($this->data[$from]); + $this->fss = false; + } + + function removeArray( $data ) { + foreach( $data as $from => $to ) + $this->removePair( $from ); + $this->fss = false; + } + function replace( $subject ) { if ( function_exists( 'fss_prep_replace' ) ) { wfProfileIn( __METHOD__.'-fss' ); @@ -300,4 +344,89 @@ class ReplacementArray { } } -?> +/** + * An iterator which works exactly like: + * + * foreach ( explode( $delim, $s ) as $element ) { + * ... + * } + * + * Except it doesn't use 193 byte per element + */ +class ExplodeIterator implements Iterator { + // The subject string + var $subject, $subjectLength; + + // The delimiter + var $delim, $delimLength; + + // The position of the start of the line + var $curPos; + + // The position after the end of the next delimiter + var $endPos; + + // The current token + var $current; + + /** + * Construct a DelimIterator + */ + function __construct( $delim, $s ) { + $this->subject = $s; + $this->delim = $delim; + + // Micro-optimisation (theoretical) + $this->subjectLength = strlen( $s ); + $this->delimLength = strlen( $delim ); + + $this->rewind(); + } + + function rewind() { + $this->curPos = 0; + $this->endPos = strpos( $this->subject, $this->delim ); + $this->refreshCurrent(); + } + + + function refreshCurrent() { + if ( $this->curPos === false ) { + $this->current = false; + } elseif ( $this->curPos >= $this->subjectLength ) { + $this->current = ''; + } elseif ( $this->endPos === false ) { + $this->current = substr( $this->subject, $this->curPos ); + } else { + $this->current = substr( $this->subject, $this->curPos, $this->endPos - $this->curPos ); + } + } + + function current() { + return $this->current; + } + + function key() { + return $this->curPos; + } + + function next() { + if ( $this->endPos === false ) { + $this->curPos = false; + } else { + $this->curPos = $this->endPos + $this->delimLength; + if ( $this->curPos >= $this->subjectLength ) { + $this->endPos = false; + } else { + $this->endPos = strpos( $this->subject, $this->delim, $this->curPos ); + } + } + $this->refreshCurrent(); + return $this->current; + } + + function valid() { + return $this->curPos !== false; + } +} +