StringUtils.php

Go to the documentation of this file.

<?php
class StringUtils {
    static function isUtf8( $value, $disableMbstring = false ) {
        $value = (string)$value;

        // If the mbstring extension is loaded, use it. However, before PHP 5.4, values above
        // U+10FFFF are incorrectly allowed, so we have to check for them separately.
        if ( !$disableMbstring && function_exists( 'mb_check_encoding' ) ) {
            static $newPHP;
            if ( $newPHP === null ) {
                $newPHP = !mb_check_encoding( "\xf4\x90\x80\x80", 'UTF-8' );
            }

            return mb_check_encoding( $value, 'UTF-8' ) &&
                ( $newPHP || preg_match( "/\xf4[\x90-\xbf]|[\xf5-\xff]/S", $value ) === 0 );
        }

        if ( preg_match( "/[\x80-\xff]/S", $value ) === 0 ) {
            // String contains only ASCII characters, has to be valid
            return true;
        }

        // PCRE implements repetition using recursion; to avoid a stack overflow (and segfault)
        // for large input, we check for invalid sequences (<= 5 bytes) rather than valid
        // sequences, which can be as long as the input string is. Multiple short regexes are
        // used rather than a single long regex for performance.
        static $regexes;
        if ( $regexes === null ) {
            $cont = "[\x80-\xbf]";
            $after = "(?!$cont)"; // "(?:[^\x80-\xbf]|$)" would work here
            $regexes = array(
                // Continuation byte at the start
                "/^$cont/",

                // ASCII byte followed by a continuation byte
                "/[\\x00-\x7f]$cont/S",

                // Illegal byte
                "/[\xc0\xc1\xf5-\xff]/S",

                // Invalid 2-byte sequence, or valid one then an extra continuation byte
                "/[\xc2-\xdf](?!$cont$after)/S",

                // Invalid 3-byte sequence, or valid one then an extra continuation byte
                "/\xe0(?![\xa0-\xbf]$cont$after)/",
                "/[\xe1-\xec\xee\xef](?!$cont{2}$after)/S",
                "/\xed(?![\x80-\x9f]$cont$after)/",

                // Invalid 4-byte sequence, or valid one then an extra continuation byte
                "/\xf0(?![\x90-\xbf]$cont{2}$after)/",
                "/[\xf1-\xf3](?!$cont{3}$after)/S",
                "/\xf4(?![\x80-\x8f]$cont{2}$after)/",
            );
        }

        foreach ( $regexes as $regex ) {
            if ( preg_match( $regex, $value ) !== 0 ) {
                return false;
            }
        }

        return true;
    }

    static function hungryDelimiterReplace( $startDelim, $endDelim, $replace, $subject ) {
        $segments = explode( $startDelim, $subject );
        $output = array_shift( $segments );
        foreach ( $segments as $s ) {
            $endDelimPos = strpos( $s, $endDelim );
            if ( $endDelimPos === false ) {
                $output .= $startDelim . $s;
            } else {
                $output .= $replace . substr( $s, $endDelimPos + strlen( $endDelim ) );
            }
        }

        return $output;
    }

    static function delimiterReplaceCallback( $startDelim, $endDelim, $callback,
        $subject, $flags = ''
    ) {
        $inputPos = 0;
        $outputPos = 0;
        $output = '';
        $foundStart = false;
        $encStart = preg_quote( $startDelim, '!' );
        $encEnd = preg_quote( $endDelim, '!' );
        $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 )
        ) {
            $tokenOffset = $m[0][1];
            if ( $m[1][0] != '' ) {
                if ( $foundStart &&
                    $strcmp( $endDelim, substr( $subject, $tokenOffset, $endLength ) ) == 0
                ) {
                    # An end match is present at the same location
                    $tokenType = 'end';
                    $tokenLength = $endLength;
                } else {
                    $tokenType = 'start';
                    $tokenLength = strlen( $m[0][0] );
                }
            } elseif ( $m[2][0] != '' ) {
                $tokenType = 'end';
                $tokenLength = strlen( $m[0][0] );
            } else {
                throw new MWException( 'Invalid delimiter given to ' . __METHOD__ );
            }

            if ( $tokenType == 'start' ) {
                # 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 ) {
                    # Found match
                    $output .= call_user_func( $callback, array(
                        substr( $subject, $outputPos, $tokenOffset + $tokenLength - $outputPos ),
                        substr( $subject, $contentPos, $tokenOffset - $contentPos )
                    ) );
                    $foundStart = false;
                } else {
                    # Non-matching end, write it out
                    $output .= substr( $subject, $inputPos, $tokenOffset + $tokenLength - $outputPos );
                }
                $inputPos = $outputPos = $tokenOffset + $tokenLength;
            } else {
                throw new MWException( 'Invalid delimiter given to ' . __METHOD__ );
            }
        }
        if ( $outputPos < strlen( $subject ) ) {
            $output .= substr( $subject, $outputPos );
        }

        return $output;
    }

    static function delimiterReplace( $startDelim, $endDelim, $replace, $subject, $flags = '' ) {
        $replacer = new RegexlikeReplacer( $replace );

        return self::delimiterReplaceCallback( $startDelim, $endDelim,
            $replacer->cb(), $subject, $flags );
    }

    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 );

        // Explode, then put the replaced separators back in
        $items = explode( $separator, $cleaned );
        foreach ( $items as $i => $str ) {
            $items[$i] = str_replace( $placeholder, $separator, $str );
        }

        return $items;
    }

    static function escapeRegexReplacement( $string ) {
        $string = str_replace( '\\', '\\\\', $string );
        $string = str_replace( '$', '\\$', $string );

        return $string;
    }

    static function explode( $separator, $subject ) {
        if ( substr_count( $subject, $separator ) > 1000 ) {
            return new ExplodeIterator( $separator, $subject );
        } else {
            return new ArrayIterator( explode( $separator, $subject ) );
        }
    }
}

class Replacer {
    function cb() {
        return array( &$this, 'replace' );
    }
}

class RegexlikeReplacer extends Replacer {
    private $r;

    function __construct( $r ) {
        $this->r = $r;
    }

    function replace( $matches ) {
        $pairs = array();
        foreach ( $matches as $i => $match ) {
            $pairs["\$$i"] = $match;
        }

        return strtr( $this->r, $pairs );
    }
}

class DoubleReplacer extends Replacer {
    function __construct( $from, $to, $index = 0 ) {
        $this->from = $from;
        $this->to = $to;
        $this->index = $index;
    }

    function replace( $matches ) {
        return str_replace( $this->from, $this->to, $matches[$this->index] );
    }
}

class HashtableReplacer extends Replacer {
    private $table, $index;

    function __construct( $table, $index = 0 ) {
        $this->table = $table;
        $this->index = $index;
    }

    function replace( $matches ) {
        return $this->table[$matches[$this->index]];
    }
}

class ReplacementArray {
    private $data = false;
    private $fss = false;

    function __construct( $data = array() ) {
        $this->data = $data;
    }

    function __sleep() {
        return array( 'data' );
    }

    function __wakeup() {
        $this->fss = false;
    }

    function setArray( $data ) {
        $this->data = $data;
        $this->fss = false;
    }

    function getArray() {
        return $this->data;
    }

    function setPair( $from, $to ) {
        $this->data[$from] = $to;
        $this->fss = false;
    }

    function mergeArray( $data ) {
        $this->data = array_merge( $this->data, $data );
        $this->fss = false;
    }

    function merge( $other ) {
        $this->data = array_merge( $this->data, $other->data );
        $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' );
            if ( $this->fss === false ) {
                $this->fss = fss_prep_replace( $this->data );
            }
            $result = fss_exec_replace( $this->fss, $subject );
            wfProfileOut( __METHOD__ . '-fss' );
        } else {
            wfProfileIn( __METHOD__ . '-strtr' );
            $result = strtr( $subject, $this->data );
            wfProfileOut( __METHOD__ . '-strtr' );
        }

        return $result;
    }
}

class ExplodeIterator implements Iterator {
    // The subject string
    private $subject, $subjectLength;

    // The delimiter
    private $delim, $delimLength;

    // The position of the start of the line
    private $curPos;

    // The position after the end of the next delimiter
    private $endPos;

    // The current token
    private $current;

    function __construct( $delim, $subject ) {
        $this->subject = $subject;
        $this->delim = $delim;

        // Micro-optimisation (theoretical)
        $this->subjectLength = strlen( $subject );
        $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;
    }
}