XYplorer Beta Club

Code: Select all

function getSerializedData($str, $lvl = 1, $pattern = '{|}') {
    if !($str) { return 'Error: $str is empty!'; }
    if !($lvl) { return 'Error: $lvl must be >= 1 or "count"!'; }
    // if !(isBalanced($str)) { return 'Error: $str does not contain serialized data!'; }
    if (!$pattern || !regexmatches($pattern, "\|")) { return 'Error: $pattern syntax is invalid!'; }

    $fToken = gettoken($pattern, 1, "|"); // First Token
    $sToken = gettoken($pattern, 2, "|"); // Second Token
    $lvlCount = ($lvl LikeI "count") ? 1 : 0; // Return number of occurrences instead of real data

    $fPos = 0;
    $skipNext = 0;
    while ($i++ < $lvl) {
        $j = 1;
        while ($j <= strlen($str)) {
            $c = substr($str, $j - 1, 1);
            if ($fPos) { // We already found the first valid opening token
                if ($c == $fToken) { $skipNext++; } // Another opening token -> Increase skip counter
                elseif ($c == $sToken) {
                    if ($skipNext) { $skipNext--; } // Decrease skip counter
                    else { $str = substr($str, $fPos + 1, $j - $fPos - 2); $fPos = 0; } // Reset first position!
                }
            } else {
                if ($c == $fToken) { // Find the first valid opening token
                    if (gettoken(regexmatches(substr($str, $fPos, $j - 1), '"'), "count", "|") % 2) { $fPos = 0; } // Unbalanced -> Skip it
                    else { $fPos = $j - 1; }
                }
            }
            $j++;
        }
    }
    return $str;
}

Code: Select all

    $start = now("msecs");
    $b = getSerializedData($a); // ''
    $duration = now("msecs") - $start;
    text "$b<crlf 2>Time: $duration";

Code: Select all

Original: a:1:{s:9:"@test.bat {a}";a:1:{s:24:"AJXP_METADATA_SHAREDUSER";a:1:{s:10:"users_meta";a:1:{s:4:"tags";s:20:"batch file {new tag}";}}}}

0: Error: $lvl must be >= 1 or "count"!
1: {s:9:"@test.bat {a}";a:1:{s:24:"AJXP_METADATA_SHAREDUSER";a:1:{s:10:"users_meta";a:1:{s:4:"tags";s:20:"batch file {new tag}";}}}}
2: {s:24:"AJXP_METADATA_SHAREDUSER";a:1:{s:10:"users_meta";a:1:{s:4:"tags";s:20:"batch file {new tag}";}}}
3: {s:10:"users_meta";a:1:{s:4:"tags";s:20:"batch file {new tag}";}}
4: {s:4:"tags";s:20:"batch file {new tag}";}
5: 
6: 

Count: 5

Code: Select all

// FindFreeCharCode
//   Returns the first charcode after startIdx which is not within str.
//   Otherwise -1.
function FindFreeCharCode($str, $startIdx=0) {
    if ($str == '') { return $startIdx; }

    $i = $startIdx;
    while ($i >= 0 && $i <= 65535) {
        if (-1 == StrPos($str, chr($i), 0, true)) {
            break;
        }
        $i++;
    }

    if ($i > 65535) {
        return -1;
    } else {
        return $i;
    }
}


function getSerializedData($str, $lvl = 1, $pattern = '{|}') {
    if !($str) { return 'Error: $str is empty!'; }
    if !($lvl) { return 'Error: $lvl must be >= 1 or "count"!'; }
    // if !(isBalanced($str)) { return 'Error: $str does not contain serialized data!'; }
    if (!$pattern || !regexmatches($pattern, "\|")) { return 'Error: $pattern syntax is invalid!'; }

    $fToken = gettoken($pattern, 1, "|"); // First Token
    $sToken = gettoken($pattern, 2, "|"); // Second Token
    $lvlCount = ($lvl LikeI "count") ? 1 : 0; // Return number of occurrences instead of real data

    // Find free characters to use for separators.
    $openChar = FindFreeCharCode($str);
    $endChar = FindFreeCharCode($str, $openChar+1);
    $sQuoteChar = FindFreeCharCode($str, $endChar+1);
    $dQuoteChar = FindFreeCharCode($str, $sQuoteChar+1);
    $quoteChar = FindFreeCharCode($str, $dQuoteChar+1);

    // Ensure none are <0
    Assert $quoteChar >= 0, 'Could not find enough free characters...';

    // Convert from index to chars.
    $openChar = chr($openChar);
    $endChar = chr($endChar);
    $sQuoteChar = chr($sQuoteChar);
    $dQuoteChar = chr($dQuoteChar);
    $quoteChar = chr($quoteChar);


    // TODO: Handle XY's double quote to escape.
    // Currently this only handles the \['"] method of escaping.
    // XY's method is a bigger pain in the butt because it also
    // needs to be distinguished from empty strings.

    // Replace tokens with new characters.
    // It's tempting to use ReplaceList here... 
    // but then you need to find a separator that's not in anything else.
    $newStr = Replace($str, $fToken, $openChar);        // Starting Bracket
    $newStr = Replace($newStr, $sToken, $endChar);      // Ending Bracket
    $newStr = Replace($newStr, "\'", $sQuoteChar);      // Escaped Double Quotes
    $newStr = Replace($newStr, '\"', $dQuoteChar);      // Escaped Single Quotes
    $newStr = Replace($newStr, "'", $quoteChar . "'");  // Single Quotes
    $newStr = Replace($newStr, '"', $quoteChar . '"');  // Double Quotes

    // Will hold an escaped version of the string.
    $finalStr = '';

    // Track if we're in quotes...
    $inDQ = false;
    $inSQ = false;
    foreach ($t, $newStr, $quoteChar) {
        // Get state of quotes.
        // We do this first because we replaced each quote with $quoteChar.['"]
        if ($t LikeI "'*" && ! $inDQ) {
            $inSQ = ! $inSQ;
        } elseif ($t LikeI '"*' && ! $inSQ) {
            $inDQ = ! $inDQ;
        }

        // If in either set of quotes restore the brackets.
        if ($inDQ || $inSQ) {
            $t = Replace($t, $openChar, $fToken);
            $t = Replace($t, $endChar, $sToken);
        }

        // Build up the escaped string.
        $finalStr = $finalStr . $t;
    }

    $finalStr = Replace($finalStr, $quoteChar); // Shouldn't do anything.

    // Restore escaped quotes.
    $finalStr = Replace($finalStr, $sQuoteChar, "\'");
    $finalStr = Replace($finalStr, $dQuoteChar, '\"');



    // Special case for count.
    if ($lvl LikeI 'count') {
        // TODO: This may need to be modified to account for the outter level.
        return GetToken($finalStr, $lvl, $openChar);
    }

    // Get the token (+1 to skip exterior)
    $finalStr = GetToken($finalStr, $lvl+1, $openChar,, 2);
    if ($finalStr == '') {
        return '';
    }

    // Now we need to identify the correct closing bracket.
    $nextOpen = -1;
    $nextClose = -1;
    while (true) {
        $nextOpen = StrPos($finalStr, $openChar, $nextOpen+1);
        $nextClose = StrPos($finalStr, $endChar, $nextClose+1);
        if ($nextOpen == -1 || $nextClose < $nextOpen) {
            break;
        }
    }

    // Trim to the closing bracket.
    if ($nextClose >= 0) {
        $finalStr = SubStr($finalStr, 0, $nextClose);
    }

    // Replace our characters with the actual brackets.
    $finalStr = Replace($finalStr, $openChar, $fToken);
    $finalStr = Replace($finalStr, $endChar, $sToken);

    // Restore surrounding brackets.
    return $fToken . $finalStr . $sToken;
}


"Test"
    $test = <<<'TESTS'
a:1:{s:9:"@test.bat {a}";a:1:{s:24:"AJXP_METADATA_SHAREDUSER";a:1:{s:10:"users_meta";a:1:{s:4:"tags";s:20:"batch file {new tag}";}}}}
a{b{c{d{f{g}}}}}
a"{}"b{c}
TESTS;

    $results = '';
    foreach ($a, $test, <crlf>) {
        $t0 = getSerializedData($a, 0);
        $t1 = getSerializedData($a, 1);
        $t2 = getSerializedData($a, 2);
        $t3 = getSerializedData($a, 3);
        $t4 = getSerializedData($a, 4);
        $t5 = getSerializedData($a, 5);
        $t6 = getSerializedData($a, 6);
        $tc = getSerializedData($a, 'count');

        $results = <<<TEXT
$results
Original: $a

0: $t0
1: $t1
2: $t2
3: $t3
4: $t4
5: $t5
6: $t6

Count: $tc


TEXT;
    }
    Text $results;

Code: Select all

function getSerializedData($str, $lvl = 1, $pattern = '{|}', $div = "|") {
    if !($str) { return 'Error: $str is empty!'; }
    if !($lvl) { return 'Error: $lvl must be >= 1 or "count"!'; }
    // if (isBalanced($str, $pattern, $div) != 0) { return 'Error: $str does not contain serialized data!'; }
    if (!$pattern || $pattern UnLike "*$div*") { return 'Error: $pattern syntax is invalid!'; }

    $tOpen  = gettoken($pattern, 1, "|"); // First Token
    $tClose = gettoken($pattern, 2, "|"); // Second Token
    $lvlCount = ($lvl LikeI "count") ? 1 : 0; // Return number of occurrences instead of real data

    $matchPos    = 0;
    $validMatch  = 0;
    $curOpenPos  = 0;
    $curClosePos = 0;

    $count = 0;
    while (true) {
        if !($validMatch) { // No first valid opening token yet...
            $tOpenPos = strpos($str, $tOpen, $curOpenPos); // Find the first occurrence of the opening token
            if ($tOpenPos >= 0) { // Opening token found
                // if (isBalanced(substr($str, 0, $tOpenPos), '"') != 0 ) { // A valid match was found...
                if !(gettoken(regexmatches(substr($str, 0, $tOpenPos), '"'), "count", "|") % 2) { // A valid match was found...
                    $validMatch  = 1;
                    $matchPos    = $tOpenPos + 1; // First position of the final return string
                    $curClosePos = $matchPos; // We need it for the main else part
                }
                $curOpenPos = $tOpenPos + 1;
            } else { return; } // No opening token found in the whole string!
        } else { // We already have our valid opening token
            $tClosePos = strpos($str, $tClose, $curClosePos); // Find the next closing token!
            if ($tClosePos) { // Found a closing token (cannot be on position zero any more)
                // if (isBalanced(substr($str, 0, $tClosePos), '"') != 0) {
                if !(gettoken(regexmatches(substr($str, 0, $tOpenPos), '"'), "count", "|") % 2) {
                    while (true) { // Now scan for any opening tokens in between
                        $tOpenPos = strpos($str, $tOpen, $curOpenPos); // Look for another opening token
                        $tClosePos = strpos($str, $tClose, $curClosePos); // Move the closing position!
                        if ($tOpenPos >= 0 && ($tOpenPos < $tClosePos)) {
                            // if (isBalanced(substr($str, 0, $tOpenPos), '"') != 0) { // New valid opening token (before next closing token)
                            if !(gettoken(regexmatches(substr($str, 0, $tOpenPos), '"'), "count", "|") % 2) { // New valid opening token (before next closing token)
                                $curClosePos = $tClosePos + 1;
                            }
                            $curOpenPos = $tOpenPos + 1;
                        } else {
                            $str = substr($str, $matchPos, $tClosePos - $matchPos);
                            $count++;
                            if ($count == $lvl) { return $str; }
                            $validMatch  = 0;
                            $curOpenPos  = 0;
                            $curClosePos = 0;
                            break;
                        }
                    }
                } else { $curClosePos = $tClosePos + 1; }
            } else { // No closing token found in the whole string!
                return;
            }
        }
    }
    return $str;
}