<?php

/**

 * A collection of static methods to play with strings.

 */

class StringUtils {

    /**

     * 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

     * recommend using it on anything but guaranteed small chunks of text.

     */

    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;

    }



    /**

     * 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/.

    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' ) {

                $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

                    # Write out the non-matching section

                    $output .= substr( $subject, $outputPos, $tokenOffset - $outputPos );

                    $outputPos = $tokenOffset;

                    $contentPos = $inputPos;

                    $foundStart = true;

                }

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

    }



    /*

     * 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

     */

    static function delimiterReplace( $startDelim, $endDelim, $replace, $subject, $flags = '' ) {

        $replacer = new RegexlikeReplacer( $replace );

        return self::delimiterReplaceCallback( $startDelim, $endDelim,

            $replacer->cb(), $subject, $flags );

    }



    /**

     * More or less "markup-safe" explode()

     * Ignores any instances of the separator inside <...>

     * @param string $separator

     * @param string $text

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



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

    }



    /**

     * Escape a string to make it suitable for inclusion in a preg_replace()

     * replacement parameter.

     *

     * @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

     */

    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

 * StringUtils::delimiterReplaceCallback()

 */

class Replacer {

    function cb() {

        return array( &$this, 'replace' );

    }

}



/**

 * Class to replace regex matches with a string similar to that used in preg_replace()

 */

class RegexlikeReplacer extends Replacer {

    var $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 to perform secondary replacement within each replacement string

 */

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 to perform replacement based on a simple hashtable lookup

 */

class HashtableReplacer extends Replacer {

    var $table, $index;



    function __construct( $table, $index = 0 ) {

        $this->table = $table;

        $this->index = $index;

    }



    function replace( $matches ) {

        return $this->table[$matches[$this->index]];

    }

}



/**

 * Replacement array for FSS with fallback to strtr()

 * Supports lazy initialisation of FSS resource

 */

class ReplacementArray {

    /*mostly private*/ var $data = false;

    /*mostly private*/ var $fss = false;



    /**

     * Create an object with the specified replacement array

     * The array should have the same form as the replacement array for strtr()

     */

    function __construct( $data = array() ) {

        $this->data = $data;

    }



    function __sleep() {

        return array( 'data' );

    }



    function __wakeup() {

        $this->fss = false;

    }



    /**

     * Set the whole replacement array at once

     */

    function setArray( $data ) {

        $this->data = $data;

        $this->fss = false;

    }



    function getArray() {

        return $this->data;

    }



    /**

     * Set an element of the replacement array

     */

    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' ) ) {

            if ( $this->fss === false ) {

                $this->fss = fss_prep_replace( $this->data );

            }

            $result = fss_exec_replace( $this->fss, $subject );

        } else {

            $result = strtr( $subject, $this->data );

        }

        return $result;

    }

}



/**

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

    }

}