Changeset 111448 in spip-zone for _plugins_/crayons


Ignore:
Timestamp:
Aug 27, 2018, 5:29:16 PM (8 weeks ago)
Author:
kent1@…
Message:

Report de r93106 et r93592 (Compat PHP 7)

File:
1 edited

Legend:

Unmodified
Added
Removed
  • _plugins_/crayons/trunk/lib/JavaScriptPacker/class.JavaScriptPacker.php

    r104327 r111448  
    11<?php
    2 /* 7 December 2006. version 1.0
    3  * 
    4  * This is the php version of the Dean Edwards JavaScript 's Packer,
     2/* 9 April 2008. version 1.1
     3 *
     4 * This is the php version of the Dean Edwards JavaScript's Packer,
    55 * Based on :
    6  * 
     6 *
    77 * ParseMaster, version 1.0.2 (2005-08-19) Copyright 2005, Dean Edwards
    88 * a multi-pattern parser.
    99 * KNOWN BUG: erroneous behavior when using escapeChar with a replacement
    1010 * value that is a function
    11  * 
     11 *
    1212 * packer, version 2.0.2 (2005-08-19) Copyright 2004-2005, Dean Edwards
    13  * 
     13 *
    1414 * License: http://creativecommons.org/licenses/LGPL/2.1/
    15  * 
     15 *
    1616 * Ported to PHP by Nicolas Martin.
    17  * modified by Mark Fabrizio Jr. to work with php 4 
    18  * 
     17 * modified by Mark Fabrizio Jr. to work with php 4
     18 *
    1919 * ----------------------------------------------------------------------
    20  *
     20 * changelog:
     21 * 1.1 : correct a bug, '\0' packed then unpacked becomes '\'.
     22 * ----------------------------------------------------------------------
     23 *
    2124 * examples of usage :
    2225 * $myPacker = new JavaScriptPacker($script, 62, true, false);
    2326 * $packed = $myPacker->pack();
    24  * 
     27 *
    2528 * or
    26  * 
     29 *
    2730 * $myPacker = new JavaScriptPacker($script, 'Normal', true, false);
    2831 * $packed = $myPacker->pack();
    29  * 
     32 *
    3033 * or (default values)
    31  * 
     34 *
    3235 * $myPacker = new JavaScriptPacker($script);
    3336 * $packed = $myPacker->pack();
    34  * 
    35  * 
     37 *
     38 *
    3639 * params of the constructor :
    3740 * $script:       the JavaScript to pack, string.
     
    4447 *                in the script, boolean.
    4548 *                default: false.
    46  * 
     49 *
    4750 * The pack() method return the compressed JavasScript, as a string.
    48  * 
     51 *
    4952 * see http://dean.edwards.name/packer/usage/ for more information.
    50  * 
     53 *
    5154 * Notes :
    5255 * # [del]need PHP 5 . Tested with PHP 5.1.2[/del]
    5356 *   this is a modified version for PHP 4
    54  * 
     57 *
    5558 * # The packed result may be different than with the Dean Edwards
    5659 *   version, but with the same length. The reason is that the PHP
     
    6063 *   ECMAScript standard). So the encoded keywords order can be
    6164 *   different in the two results.
    62  * 
     65 *
    6366 * # Be careful with the 'High ASCII' Level encoding if you use
    64  *   UTF-8 in your files... 
     67 *   UTF-8 in your files...
    6568 */
    66  
     69
    6770 /*
    6871 * modified by Mark Fabrizio Jr. to work with php 4
     
    7881        var $_fastDecode = true;
    7982        var $_specialChars = false;
    80        
     83
    8184        var $LITERAL_ENCODING = array(
    8285                'None' => 0,
     
    8588                'High ASCII' => 95
    8689        );
    87        
     90
    8891// https://code.spip.net/@JavaScriptPacker
    89         function JavaScriptPacker($_script, $_encoding = 62, $_fastDecode = true, $_specialChars = false)
     92        function __construct($_script, $_encoding = 62, $_fastDecode = true, $_specialChars = false)
    9093        {
    9194                $this->_script = $_script . "\n";
     
    9396                        $_encoding = $this->LITERAL_ENCODING[$_encoding];
    9497                $this->_encoding = min((int)$_encoding, 95);
    95                 $this->_fastDecode = $_fastDecode;     
     98                $this->_fastDecode = $_fastDecode;
    9699                $this->_specialChars = $_specialChars;
    97100        }
    98        
     101
    99102// https://code.spip.net/@pack
    100103        function pack() {
     
    104107                if ($this->_encoding)
    105108                        $this->_addParser('_encodeKeywords');
    106                
     109
    107110                // go!
    108111                return $this->_pack($this->_script);
    109112        }
    110        
     113
    111114        // apply all parsing routines
    112115// https://code.spip.net/@_pack
     
    117120                return $script;
    118121        }
    119        
     122
    120123        // keep a list of parsing functions, they'll be executed all at once
    121124        var $_parsers = array();
     
    124127                $this->_parsers[] = $parser;
    125128        }
    126        
     129
    127130        // zero encoding - just removal of white space and comments
    128131// https://code.spip.net/@_basicCompression
     
    135138                $parser->add('/"[^"\\n\\r]*"/', $this->IGNORE);
    136139                // remove comments
    137                 $parser->add('/\\/\\/[^\\n\\r]*[\\n\\r]/', ' ');
     140                $parser->add('/\\/\\/[^\\n\\r]*[\\n\\r]/', "\n");
    138141                $parser->add('/\\/\\*[^*]*\\*+([^\\/][^*]*\\*+)*\\//', ' ');
    139142                // protect regular expressions
     
    143146                if ($this->_specialChars) $parser->add('/;;;[^\\n\\r]+[\\n\\r]/');
    144147                // remove redundant semi-colons
    145                 $parser->add('/\\(;;\\)/', $this->IGNORE); // protect for (;;) loops
    146                 $parser->add('/;+\\s*([};])/', '$2');
     148                // Disabled : breaks for(i=0; ;i++) {...}
     149                // $parser->add('/\\(;;\\)/', $this->IGNORE); // protect for (;;) loops
     150                // $parser->add('/;+\\s*([};])/', '$2');
    147151                // apply the above
    148152                $script = $parser->exec($script);
     
    160164                return $parser->exec($script);
    161165        }
    162        
     166
    163167// https://code.spip.net/@_encodeSpecialChars
    164168        function _encodeSpecialChars($script) {
     
    174178                // quick ref
    175179                $encoded = $keywords['encoded'];
    176                
     180
    177181                $parser->add($regexp,
    178182                        array(
     
    183187                return $parser->exec($script);
    184188        }
    185        
     189
    186190// https://code.spip.net/@_encodeKeywords
    187191        function _encodeKeywords($script) {
     
    197201                $keywords = $this->_analyze($script, $regexp, $encode);
    198202                $encoded = $keywords['encoded'];
    199                
     203
    200204                // encode
    201205                $parser->add($regexp,
     
    213217                }
    214218        }
    215        
     219
    216220// https://code.spip.net/@_analyze
    217221        function _analyze($script, $regexp, $encode) {
     
    261265                                }
    262266                        } while ($i);
    263                        
     267
    264268                        // sort the words by frequency
    265269                        // Note: the javascript and php version of sort can be different :
     
    271275                        // the ECMAscript standard does not guarantee this behaviour,
    272276                        // and thus not all browsers (e.g. Mozilla versions dating back to at
    273                         // least 2003) respect this. 
     277                        // least 2003) respect this.
    274278                        usort($unsorted, array(&$this, '_sortWords'));
    275279                        $j = 0;
     
    287291                        'protected' => $_protected);
    288292        }
    289        
     293
    290294        var $_count = array();
    291295// https://code.spip.net/@_sortWords
     
    293297                return $this->_count[$match2] - $this->_count[$match1];
    294298        }
    295        
     299
    296300        // build the boot function used for loading and decoding
    297301// https://code.spip.net/@_bootStrap
     
    361365                $unpackPacker = new JavaScriptPacker($unpack, 0, false, true);
    362366                $unpack = $unpackPacker->pack();
    363                
     367
    364368                // arguments
    365369                $params = array($packed, $ascii, $count, $keywords);
     
    369373                }
    370374                $params = implode(',', $params);
    371                
     375
    372376                // the whole thing
    373377                return 'eval(' . $unpack . '(' . $params . "))\n";
    374378        }
    375        
     379
    376380        var $buffer;
    377381// https://code.spip.net/@_insertFastDecode
     
    383387                return '{$encode=' . $this->buffer . ';';
    384388        }
    385        
     389
    386390        // mmm.. ..which one do i need ??
    387391// https://code.spip.net/@_getEncoder
     
    390394                       '_encode95' : '_encode62' : '_encode36' : '_encode10';
    391395        }
    392        
     396
    393397        // zero encoding
    394398        // characters: 0123456789
     
    397401                return $charCode;
    398402        }
    399        
     403
    400404        // inherent base36 support
    401405        // characters: 0123456789abcdefghijklmnopqrstuvwxyz
     
    404408                return base_convert($charCode, 10, 36);
    405409        }
    406        
     410
    407411        // hitch a ride on base36 and add the upper case alpha characters
    408412        // characters: 0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ
     
    414418                }
    415419                $charCode = $charCode % $this->_encoding;
    416                
     420
    417421                if ($charCode > 35)
    418422                        return $res . chr($charCode + 29);
     
    420424                        return $res . base_convert($charCode, 10, 36);
    421425        }
    422        
     426
    423427        // use high-ascii values
    424         // characters: ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÃ?ÂÃÄÃ
    425 Ã†Ã‡ÃˆÃ‰ÃŠÃ‹ÃŒÃ?ÎÃ?Ã?ÑÒÓÔÕÖ×ØÙÚÛÜÃ?Þßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþ
    426 // https://code.spip.net/@_encode95
     428        // characters: ¬°¬¢¬£¬§¬•¬¶¬ß¬®¬©¬™¬´¬¨¬≠¬Æ¬Ø¬∞¬±¬≤¬≥¬¥¬µ¬∂¬∑¬∏¬π¬∫¬ª¬º¬Ω¬æ¬ø√Ä√?√Ç√É√Ñ√Ö√Ü√á√à√â√ä√ã√å√?√é√?√?√ë√í√ì√î√ï√ñ√ó√ò√ô√ö√õ√ú√?√û√ü√†√°√¢√£√§√•√¶√ß√®√©√™√´√¨√≠√Æ√Ø√∞√±√≤√≥√¥√µ√∂√∑√∏√π√∫√ª√º√Ω√æ
     429        // https://code.spip.net/@_encode95
    427430        function _encode95($charCode) {
    428431                $res = '';
    429432                if ($charCode >= $this->_encoding)
    430433                        $res = $this->_encode95($charCode / $this->_encoding);
    431                
     434
    432435                return $res . chr(($charCode % $this->_encoding) + 161);
    433436        }
    434        
     437
    435438// https://code.spip.net/@_safeRegExp
    436439        function _safeRegExp($string) {
    437440                return '/'.preg_replace('/\$/', '\\\$', $string).'/';
    438441        }
    439        
     442
    440443// https://code.spip.net/@_encodePrivate
    441444        function _encodePrivate($charCode) {
    442445                return "_" . $charCode;
    443446        }
    444        
     447
    445448        // protect characters used by the parser
    446449// https://code.spip.net/@_escape
     
    448451                return preg_replace('/([\\\\\'])/', '\\\$1', $script);
    449452        }
    450        
     453
    451454        // protect high-ascii characters already in the script
    452455// https://code.spip.net/@_escape95
     
    462465                return '\x'.((string)dechex(ord($match)));
    463466        }
    464        
    465        
     467
     468
    466469// https://code.spip.net/@_getJSFunction
    467470        function _getJSFunction($aName) {
     
    470473                        return $this->$func;
    471474                }
    472                 else 
     475                else
    473476                        return '';
    474477        }
    475        
     478
    476479        // JavaScript Functions used.
    477480        // Note : In Dean's version, these functions are converted
     
    481484        // 'while (aBool) { anAction(); }'.
    482485        // The JavaScript functions below are corrected.
    483        
     486
    484487        // unpacking function - this is the boot strap function
    485488        //  data extracted from this packing routine is passed to
     
    502505}';
    503506*/
    504        
     507
    505508        // code-snippet inserted into the unpacker to speed up decoding
    506509        var $JSFUNCTION_decodeBody = '    if (!\'\'.replace(/^/, String)) {
     
    530533    }';
    531534*/
    532        
     535
    533536         // zero encoding
    534537         // characters: 0123456789
     
    536539    return $charCode;
    537540}';//;';
    538        
     541
    539542         // inherent base36 support
    540543         // characters: 0123456789abcdefghijklmnopqrstuvwxyz
     
    542545    return $charCode.toString(36);
    543546}';//;';
    544        
     547
    545548        // hitch a ride on base36 and add the upper case alpha characters
    546549        // characters: 0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ
     
    549552    (($charCode = $charCode % _encoding) > 35 ? String.fromCharCode($charCode + 29) : $charCode.toString(36));
    550553}';
    551        
     554
    552555        // use high-ascii values
    553         // characters: ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÃ?ÂÃÄÃ
    554 Ã†Ã‡ÃˆÃ‰ÃŠÃ‹ÃŒÃ?ÎÃ?Ã?ÑÒÓÔÕÖ×ØÙÚÛÜÃ?Þßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþ
     556        // characters: ¬°¬¢¬£¬§¬•¬¶¬ß¬®¬©¬™¬´¬¨¬≠¬Æ¬Ø¬∞¬±¬≤¬≥¬¥¬µ¬∂¬∑¬∏¬π¬∫¬ª¬º¬Ω¬æ¬ø√Ä√?√Ç√É√Ñ√Ö√Ü√á√à√â√ä√ã√å√?√é√?√?√ë√í√ì√î√ï√ñ√ó√ò√ô√ö√õ√ú√?√û√ü√†√°√¢√£√§√•√¶√ß√®√©√™√´√¨√≠√Æ√Ø√∞√±√≤√≥√¥√µ√∂√∑√∏√π√∫√ª√º√Ω√æ
    555557        var $JSFUNCTION_encode95 = 'function($charCode) {
    556558    return ($charCode < _encoding ? \'\' : arguments.callee($charCode / _encoding)) +
    557559        String.fromCharCode($charCode % _encoding + 161);
    558 }'; 
    559        
     560}';
     561
    560562}
    561563
     
    564566        var $ignoreCase = false;
    565567        var $escapeChar = '';
    566        
     568
    567569        // constants
    568570        var $EXPRESSION = 0;
    569571        var $REPLACEMENT = 1;
    570572        var $LENGTH = 2;
    571        
     573
    572574        // used to determine nesting levels
    573575        var $GROUPS = '/\\(/';//g
     
    578580        var $QUOTE = '/\'/';
    579581        var $DELETED = '/\\x01[^\\x01]*\\x01/';//g
    580        
     582
    581583// https://code.spip.net/@add
    582584        function add($expression, $replacement = '') {
     
    584586                //  - add one because each pattern is itself a sub-expression
    585587                $length = 1 + preg_match_all($this->GROUPS, $this->_internalEscape((string)$expression), $out);
    586                
     588
    587589                // treat only strings $replacement
    588590                if (is_string($replacement)) {
     
    612614                else $this->_add('/^$/', $replacement, $length);
    613615        }
    614        
     616
    615617// https://code.spip.net/@exec
    616618        function exec($string) {
    617619                // execute the global replacement
    618620                $this->_escaped = array();
    619                
     621
    620622                // simulate the _patterns.toSTring of Dean
    621623                $regexp = '/';
     
    625627                $regexp = substr($regexp, 0, -1) . '/';
    626628                $regexp .= ($this->ignoreCase) ? 'i' : '';
    627                
     629
    628630                $string = $this->_escape($string, $this->escapeChar);
    629631                $string = preg_replace_callback(
     
    636638                );
    637639                $string = $this->_unescape($string, $this->escapeChar);
    638                
     640
    639641                return preg_replace($this->DELETED, '', $string);
    640642        }
    641                
     643
    642644// https://code.spip.net/@reset
    643645        function reset() {
     
    649651        var $_escaped = array();  // escaped characters
    650652        var $_patterns = array(); // patterns stored by index
    651        
     653
    652654        // create and add a new pattern to the patterns collection
    653655// https://code.spip.net/@_add
     
    656658                $this->_patterns[] = $arguments;
    657659        }
    658        
     660
    659661        // this is the global replace function (it's quite complicated)
    660662// https://code.spip.net/@_replacement
    661663        function _replacement($arguments) {
    662664                if (empty($arguments)) return '';
    663                
     665
    664666                $i = 1; $j = 0;
    665667                // loop through the patterns
     
    669671                        if (isset($arguments[$i]) && ($arguments[$i] != '')) {
    670672                                $replacement = $pattern[$this->REPLACEMENT];
    671                                
     673
    672674                                if (is_array($replacement) && isset($replacement['fn'])) {
    673                                        
     675
    674676                                        if (isset($replacement['data'])) $this->buffer = $replacement['data'];
    675677                                        return call_user_func(array(&$this, $replacement['fn']), $arguments, $i);
    676                                        
     678
    677679                                } elseif (is_int($replacement)) {
    678680                                        return $arguments[$replacement + $i];
    679                                
     681
    680682                                }
    681683                                $delete = ($this->escapeChar == '' ||
     
    683685                                        ? '' : "\x01" . $arguments[$i] . "\x01";
    684686                                return $delete . $replacement;
    685                        
     687
    686688                        // skip over references to sub-expressions
    687689                        } else {
     
    690692                }
    691693        }
    692        
     694
    693695// https://code.spip.net/@_backReferences
    694696        function _backReferences($match, $offset) {
     
    701703                return $replacement;
    702704        }
    703        
     705
    704706// https://code.spip.net/@_replace_name
    705707        function _replace_name($match, $offset){
     
    708710                return substr($match[$offset + 1], $start, $length) . $match[$offset + 4];
    709711        }
    710        
     712
    711713// https://code.spip.net/@_replace_encoded
    712714        function _replace_encoded($match, $offset) {
    713715                return $this->buffer[$match[$offset]];
    714716        }
    715        
    716        
     717
     718
    717719        // php : we cannot pass additional data to preg_replace_callback,
    718720        // and we cannot use &$this in create_function, so let's go to lower level
    719721        var $buffer;
    720        
     722
    721723        // encode escaped characters
    722724// https://code.spip.net/@_escape
     
    729731                                $string
    730732                        );
    731                        
     733
    732734                } else {
    733735                        return $string;
     
    739741                return $this->buffer;
    740742        }
    741        
     743
    742744        // decode escaped characters
    743745// https://code.spip.net/@_unescape
     
    752754                                $string
    753755                        );
    754                        
     756
    755757                } else {
    756758                        return $string;
     
    759761// https://code.spip.net/@_unescapeBis
    760762        function _unescapeBis() {
    761                 if (!empty($this->_escaped[$this->buffer['i']])) {
     763                if (isset($this->_escaped[$this->buffer['i']])
     764                        && $this->_escaped[$this->buffer['i']] != '')
     765                {
    762766                         $temp = $this->_escaped[$this->buffer['i']];
    763767                } else {
     
    767771                return $this->buffer['escapeChar'] . $temp;
    768772        }
    769        
     773
    770774// https://code.spip.net/@_internalEscape
    771775        function _internalEscape($string) {
Note: See TracChangeset for help on using the changeset viewer.