Changeset 125320 in spip-zone


Ignore:
Timestamp:
Jun 25, 2020, 5:26:38 PM (3 weeks ago)
Author:
Matthieu Marcillaud
Message:

On copie la version de pclzip présente dans 'archiviste' qui corrige un petit problème sur les PHP > 7.1
Fix #4452

Location:
_outils_/spip_loader/trunk
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • _outils_/spip_loader/trunk

    • Property subgit:lock:06e7eb44b8e3f48cc7dbf805e930f6279a18aaa9 deleted
    • Property subgit:lock:0e93074c83190d06c5f73756b9af93fe76459d89 set to 2020-06-25T19:28:42.079
  • _outils_/spip_loader/trunk/pclzip.php

    r96264 r125320  
    2424
    2525
    26   // personnalisations spip
    27   if (!defined('PCLZIP_TEMPORARY_DIR')) {
    28     define('PCLZIP_TEMPORARY_DIR', _DIR_TMP);
    29   }
    30   if (!function_exists('gzopen') && function_exists('gzopen64')) {
    31     function gzopen($filename, $mode, $use_include_path = 0) {
    32       return gzopen64($filename, $mode, $use_include_path);
    33     }
    34   }
    35   // fin personnalisations spip
    36 
    37   // ----- Constants
    38   if (!defined('PCLZIP_READ_BLOCK_SIZE')) {
    39     define( 'PCLZIP_READ_BLOCK_SIZE', 2048 );
    40   }
    41  
    42   // ----- File list separator
    43   // In version 1.x of PclZip, the separator for file list is a space
    44   // (which is not a very smart choice, specifically for windows paths !).
    45   // A better separator should be a comma (,). This constant gives you the
    46   // abilty to change that.
    47   // However notice that changing this value, may have impact on existing
    48   // scripts, using space separated filenames.
    49   // Recommanded values for compatibility with older versions :
    50   //define( 'PCLZIP_SEPARATOR', ' ' );
    51   // Recommanded values for smart separation of filenames.
    52   if (!defined('PCLZIP_SEPARATOR')) {
    53     define( 'PCLZIP_SEPARATOR', ',' );
    54   }
    55 
    56   // ----- Error configuration
    57   // 0 : PclZip Class integrated error handling
    58   // 1 : PclError external library error handling. By enabling this
    59   //     you must ensure that you have included PclError library.
    60   // [2,...] : reserved for futur use
    61   if (!defined('PCLZIP_ERROR_EXTERNAL')) {
    62     define( 'PCLZIP_ERROR_EXTERNAL', 0 );
    63   }
    64 
    65   // ----- Optional static temporary directory
    66   //       By default temporary files are generated in the script current
    67   //       path.
    68   //       If defined :
    69   //       - MUST BE terminated by a '/'.
    70   //       - MUST be a valid, already created directory
    71   //       Samples :
    72   // define( 'PCLZIP_TEMPORARY_DIR', '/temp/' );
    73   // define( 'PCLZIP_TEMPORARY_DIR', 'C:/Temp/' );
    74   if (!defined('PCLZIP_TEMPORARY_DIR')) {
    75     define( 'PCLZIP_TEMPORARY_DIR', '' );
    76   }
    77 
    78   // ----- Optional threshold ratio for use of temporary files
    79   //       Pclzip sense the size of the file to add/extract and decide to
    80   //       use or not temporary file. The algorythm is looking for
    81   //       memory_limit of PHP and apply a ratio.
    82   //       threshold = memory_limit * ratio.
    83   //       Recommended values are under 0.5. Default 0.47.
    84   //       Samples :
    85   // define( 'PCLZIP_TEMPORARY_FILE_RATIO', 0.5 );
    86   if (!defined('PCLZIP_TEMPORARY_FILE_RATIO')) {
    87     define( 'PCLZIP_TEMPORARY_FILE_RATIO', 0.47 );
    88   }
     26// personnalisations spip
     27if (!defined('PCLZIP_TEMPORARY_DIR')) {
     28  define('PCLZIP_TEMPORARY_DIR', _DIR_TMP);
     29}
     30if (!function_exists('gzopen') && function_exists('gzopen64')) {
     31  function gzopen($filename, $mode, $use_include_path = 0) {
     32    return gzopen64($filename, $mode, $use_include_path);
     33  }
     34}
     35// fin personnalisations spip
     36
     37// ----- Constants
     38if (!defined('PCLZIP_READ_BLOCK_SIZE')) {
     39  define('PCLZIP_READ_BLOCK_SIZE', 2048);
     40}
     41
     42// ----- File list separator
     43// In version 1.x of PclZip, the separator for file list is a space
     44// (which is not a very smart choice, specifically for windows paths !).
     45// A better separator should be a comma (,). This constant gives you the
     46// abilty to change that.
     47// However notice that changing this value, may have impact on existing
     48// scripts, using space separated filenames.
     49// Recommanded values for compatibility with older versions :
     50//define( 'PCLZIP_SEPARATOR', ' ' );
     51// Recommanded values for smart separation of filenames.
     52if (!defined('PCLZIP_SEPARATOR')) {
     53  define('PCLZIP_SEPARATOR', ',');
     54}
     55
     56// ----- Error configuration
     57// 0 : PclZip Class integrated error handling
     58// 1 : PclError external library error handling. By enabling this
     59//     you must ensure that you have included PclError library.
     60// [2,...] : reserved for futur use
     61if (!defined('PCLZIP_ERROR_EXTERNAL')) {
     62  define('PCLZIP_ERROR_EXTERNAL', 0);
     63}
     64
     65// ----- Optional static temporary directory
     66//       By default temporary files are generated in the script current
     67//       path.
     68//       If defined :
     69//       - MUST BE terminated by a '/'.
     70//       - MUST be a valid, already created directory
     71//       Samples :
     72// define( 'PCLZIP_TEMPORARY_DIR', '/temp/' );
     73// define( 'PCLZIP_TEMPORARY_DIR', 'C:/Temp/' );
     74if (!defined('PCLZIP_TEMPORARY_DIR')) {
     75  define('PCLZIP_TEMPORARY_DIR', '');
     76}
     77
     78// ----- Optional threshold ratio for use of temporary files
     79//       Pclzip sense the size of the file to add/extract and decide to
     80//       use or not temporary file. The algorythm is looking for
     81//       memory_limit of PHP and apply a ratio.
     82//       threshold = memory_limit * ratio.
     83//       Recommended values are under 0.5. Default 0.47.
     84//       Samples :
     85// define( 'PCLZIP_TEMPORARY_FILE_RATIO', 0.5 );
     86if (!defined('PCLZIP_TEMPORARY_FILE_RATIO')) {
     87  define('PCLZIP_TEMPORARY_FILE_RATIO', 0.47);
     88}
    8989
    9090// --------------------------------------------------------------------------------
     
    9292// --------------------------------------------------------------------------------
    9393
    94   // ----- Global variables
    95   $g_pclzip_version = "2.8.2";
    96 
    97   // ----- Error codes
    98   //   -1 : Unable to open file in binary write mode
    99   //   -2 : Unable to open file in binary read mode
    100   //   -3 : Invalid parameters
    101   //   -4 : File does not exist
    102   //   -5 : Filename is too long (max. 255)
    103   //   -6 : Not a valid zip file
    104   //   -7 : Invalid extracted file size
    105   //   -8 : Unable to create directory
    106   //   -9 : Invalid archive extension
    107   //  -10 : Invalid archive format
    108   //  -11 : Unable to delete file (unlink)
    109   //  -12 : Unable to rename file (rename)
    110   //  -13 : Invalid header checksum
    111   //  -14 : Invalid archive size
    112   define( 'PCLZIP_ERR_USER_ABORTED', 2 );
    113   define( 'PCLZIP_ERR_NO_ERROR', 0 );
    114   define( 'PCLZIP_ERR_WRITE_OPEN_FAIL', -1 );
    115   define( 'PCLZIP_ERR_READ_OPEN_FAIL', -2 );
    116   define( 'PCLZIP_ERR_INVALID_PARAMETER', -3 );
    117   define( 'PCLZIP_ERR_MISSING_FILE', -4 );
    118   define( 'PCLZIP_ERR_FILENAME_TOO_LONG', -5 );
    119   define( 'PCLZIP_ERR_INVALID_ZIP', -6 );
    120   define( 'PCLZIP_ERR_BAD_EXTRACTED_FILE', -7 );
    121   define( 'PCLZIP_ERR_DIR_CREATE_FAIL', -8 );
    122   define( 'PCLZIP_ERR_BAD_EXTENSION', -9 );
    123   define( 'PCLZIP_ERR_BAD_FORMAT', -10 );
    124   define( 'PCLZIP_ERR_DELETE_FILE_FAIL', -11 );
    125   define( 'PCLZIP_ERR_RENAME_FILE_FAIL', -12 );
    126   define( 'PCLZIP_ERR_BAD_CHECKSUM', -13 );
    127   define( 'PCLZIP_ERR_INVALID_ARCHIVE_ZIP', -14 );
    128   define( 'PCLZIP_ERR_MISSING_OPTION_VALUE', -15 );
    129   define( 'PCLZIP_ERR_INVALID_OPTION_VALUE', -16 );
    130   define( 'PCLZIP_ERR_ALREADY_A_DIRECTORY', -17 );
    131   define( 'PCLZIP_ERR_UNSUPPORTED_COMPRESSION', -18 );
    132   define( 'PCLZIP_ERR_UNSUPPORTED_ENCRYPTION', -19 );
    133   define( 'PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE', -20 );
    134   define( 'PCLZIP_ERR_DIRECTORY_RESTRICTION', -21 );
    135 
    136   // ----- Options values
    137   define( 'PCLZIP_OPT_PATH', 77001 );
    138   define( 'PCLZIP_OPT_ADD_PATH', 77002 );
    139   define( 'PCLZIP_OPT_REMOVE_PATH', 77003 );
    140   define( 'PCLZIP_OPT_REMOVE_ALL_PATH', 77004 );
    141   define( 'PCLZIP_OPT_SET_CHMOD', 77005 );
    142   define( 'PCLZIP_OPT_EXTRACT_AS_STRING', 77006 );
    143   define( 'PCLZIP_OPT_NO_COMPRESSION', 77007 );
    144   define( 'PCLZIP_OPT_BY_NAME', 77008 );
    145   define( 'PCLZIP_OPT_BY_INDEX', 77009 );
    146   define( 'PCLZIP_OPT_BY_EREG', 77010 );
    147   define( 'PCLZIP_OPT_BY_PREG', 77011 );
    148   define( 'PCLZIP_OPT_COMMENT', 77012 );
    149   define( 'PCLZIP_OPT_ADD_COMMENT', 77013 );
    150   define( 'PCLZIP_OPT_PREPEND_COMMENT', 77014 );
    151   define( 'PCLZIP_OPT_EXTRACT_IN_OUTPUT', 77015 );
    152   define( 'PCLZIP_OPT_REPLACE_NEWER', 77016 );
    153   define( 'PCLZIP_OPT_STOP_ON_ERROR', 77017 );
    154   // Having big trouble with crypt. Need to multiply 2 long int
    155   // which is not correctly supported by PHP ...
    156   //define( 'PCLZIP_OPT_CRYPT', 77018 );
    157   define( 'PCLZIP_OPT_EXTRACT_DIR_RESTRICTION', 77019 );
    158   define( 'PCLZIP_OPT_TEMP_FILE_THRESHOLD', 77020 );
    159   define( 'PCLZIP_OPT_ADD_TEMP_FILE_THRESHOLD', 77020 ); // alias
    160   define( 'PCLZIP_OPT_TEMP_FILE_ON', 77021 );
    161   define( 'PCLZIP_OPT_ADD_TEMP_FILE_ON', 77021 ); // alias
    162   define( 'PCLZIP_OPT_TEMP_FILE_OFF', 77022 );
    163   define( 'PCLZIP_OPT_ADD_TEMP_FILE_OFF', 77022 ); // alias
    164  
    165   // ----- File description attributes
    166   define( 'PCLZIP_ATT_FILE_NAME', 79001 );
    167   define( 'PCLZIP_ATT_FILE_NEW_SHORT_NAME', 79002 );
    168   define( 'PCLZIP_ATT_FILE_NEW_FULL_NAME', 79003 );
    169   define( 'PCLZIP_ATT_FILE_MTIME', 79004 );
    170   define( 'PCLZIP_ATT_FILE_CONTENT', 79005 );
    171   define( 'PCLZIP_ATT_FILE_COMMENT', 79006 );
    172 
    173   // ----- Call backs values
    174   define( 'PCLZIP_CB_PRE_EXTRACT', 78001 );
    175   define( 'PCLZIP_CB_POST_EXTRACT', 78002 );
    176   define( 'PCLZIP_CB_PRE_ADD', 78003 );
    177   define( 'PCLZIP_CB_POST_ADD', 78004 );
    178   /* For futur use
     94// ----- Global variables
     95$g_pclzip_version = "2.8.2";
     96
     97// ----- Error codes
     98//   -1 : Unable to open file in binary write mode
     99//   -2 : Unable to open file in binary read mode
     100//   -3 : Invalid parameters
     101//   -4 : File does not exist
     102//   -5 : Filename is too long (max. 255)
     103//   -6 : Not a valid zip file
     104//   -7 : Invalid extracted file size
     105//   -8 : Unable to create directory
     106//   -9 : Invalid archive extension
     107//  -10 : Invalid archive format
     108//  -11 : Unable to delete file (unlink)
     109//  -12 : Unable to rename file (rename)
     110//  -13 : Invalid header checksum
     111//  -14 : Invalid archive size
     112define('PCLZIP_ERR_USER_ABORTED', 2);
     113define('PCLZIP_ERR_NO_ERROR', 0);
     114define('PCLZIP_ERR_WRITE_OPEN_FAIL', -1);
     115define('PCLZIP_ERR_READ_OPEN_FAIL', -2);
     116define('PCLZIP_ERR_INVALID_PARAMETER', -3);
     117define('PCLZIP_ERR_MISSING_FILE', -4);
     118define('PCLZIP_ERR_FILENAME_TOO_LONG', -5);
     119define('PCLZIP_ERR_INVALID_ZIP', -6);
     120define('PCLZIP_ERR_BAD_EXTRACTED_FILE', -7);
     121define('PCLZIP_ERR_DIR_CREATE_FAIL', -8);
     122define('PCLZIP_ERR_BAD_EXTENSION', -9);
     123define('PCLZIP_ERR_BAD_FORMAT', -10);
     124define('PCLZIP_ERR_DELETE_FILE_FAIL', -11);
     125define('PCLZIP_ERR_RENAME_FILE_FAIL', -12);
     126define('PCLZIP_ERR_BAD_CHECKSUM', -13);
     127define('PCLZIP_ERR_INVALID_ARCHIVE_ZIP', -14);
     128define('PCLZIP_ERR_MISSING_OPTION_VALUE', -15);
     129define('PCLZIP_ERR_INVALID_OPTION_VALUE', -16);
     130define('PCLZIP_ERR_ALREADY_A_DIRECTORY', -17);
     131define('PCLZIP_ERR_UNSUPPORTED_COMPRESSION', -18);
     132define('PCLZIP_ERR_UNSUPPORTED_ENCRYPTION', -19);
     133define('PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE', -20);
     134define('PCLZIP_ERR_DIRECTORY_RESTRICTION', -21);
     135
     136// ----- Options values
     137define('PCLZIP_OPT_PATH', 77001);
     138define('PCLZIP_OPT_ADD_PATH', 77002);
     139define('PCLZIP_OPT_REMOVE_PATH', 77003);
     140define('PCLZIP_OPT_REMOVE_ALL_PATH', 77004);
     141define('PCLZIP_OPT_SET_CHMOD', 77005);
     142define('PCLZIP_OPT_EXTRACT_AS_STRING', 77006);
     143define('PCLZIP_OPT_NO_COMPRESSION', 77007);
     144define('PCLZIP_OPT_BY_NAME', 77008);
     145define('PCLZIP_OPT_BY_INDEX', 77009);
     146define('PCLZIP_OPT_BY_EREG', 77010);
     147define('PCLZIP_OPT_BY_PREG', 77011);
     148define('PCLZIP_OPT_COMMENT', 77012);
     149define('PCLZIP_OPT_ADD_COMMENT', 77013);
     150define('PCLZIP_OPT_PREPEND_COMMENT', 77014);
     151define('PCLZIP_OPT_EXTRACT_IN_OUTPUT', 77015);
     152define('PCLZIP_OPT_REPLACE_NEWER', 77016);
     153define('PCLZIP_OPT_STOP_ON_ERROR', 77017);
     154// Having big trouble with crypt. Need to multiply 2 long int
     155// which is not correctly supported by PHP ...
     156//define( 'PCLZIP_OPT_CRYPT', 77018 );
     157define('PCLZIP_OPT_EXTRACT_DIR_RESTRICTION', 77019);
     158define('PCLZIP_OPT_TEMP_FILE_THRESHOLD', 77020);
     159define('PCLZIP_OPT_ADD_TEMP_FILE_THRESHOLD', 77020); // alias
     160define('PCLZIP_OPT_TEMP_FILE_ON', 77021);
     161define('PCLZIP_OPT_ADD_TEMP_FILE_ON', 77021); // alias
     162define('PCLZIP_OPT_TEMP_FILE_OFF', 77022);
     163define('PCLZIP_OPT_ADD_TEMP_FILE_OFF', 77022); // alias
     164
     165// ----- File description attributes
     166define('PCLZIP_ATT_FILE_NAME', 79001);
     167define('PCLZIP_ATT_FILE_NEW_SHORT_NAME', 79002);
     168define('PCLZIP_ATT_FILE_NEW_FULL_NAME', 79003);
     169define('PCLZIP_ATT_FILE_MTIME', 79004);
     170define('PCLZIP_ATT_FILE_CONTENT', 79005);
     171define('PCLZIP_ATT_FILE_COMMENT', 79006);
     172
     173// ----- Call backs values
     174define('PCLZIP_CB_PRE_EXTRACT', 78001);
     175define('PCLZIP_CB_POST_EXTRACT', 78002);
     176define('PCLZIP_CB_PRE_ADD', 78003);
     177define('PCLZIP_CB_POST_ADD', 78004);
     178/* For futur use
    179179  define( 'PCLZIP_CB_PRE_LIST', 78005 );
    180180  define( 'PCLZIP_CB_POST_LIST', 78006 );
     
    183183  */
    184184
    185   // --------------------------------------------------------------------------------
    186   // Class : PclZip
    187   // Description :
    188   //   PclZip is the class that represent a Zip archive.
    189   //   The public methods allow the manipulation of the archive.
    190   // Attributes :
    191   //   Attributes must not be accessed directly.
    192   // Methods :
    193   //   PclZip() : Object creator
    194   //   create() : Creates the Zip archive
    195   //   listContent() : List the content of the Zip archive
    196   //   extract() : Extract the content of the archive
    197   //   properties() : List the properties of the archive
    198   // --------------------------------------------------------------------------------
    199   class PclZip
    200   {
    201     // ----- Filename of the zip file
    202     var $zipname = '';
    203 
    204     // ----- File descriptor of the zip file
    205     var $zip_fd = 0;
    206 
    207     // ----- Internal error handling
    208     var $error_code = 1;
    209     var $error_string = '';
    210    
    211     // ----- Current status of the magic_quotes_runtime
    212     // This value store the php configuration for magic_quotes
    213     // The class can then disable the magic_quotes and reset it after
    214     var $magic_quotes_status;
     185// --------------------------------------------------------------------------------
     186// Class : PclZip
     187// Description :
     188//   PclZip is the class that represent a Zip archive.
     189//   The public methods allow the manipulation of the archive.
     190// Attributes :
     191//   Attributes must not be accessed directly.
     192// Methods :
     193//   PclZip() : Object creator
     194//   create() : Creates the Zip archive
     195//   listContent() : List the content of the Zip archive
     196//   extract() : Extract the content of the archive
     197//   properties() : List the properties of the archive
     198// --------------------------------------------------------------------------------
     199class PclZip {
     200  // ----- Filename of the zip file
     201  public $zipname = '';
     202
     203  // ----- File descriptor of the zip file
     204  public $zip_fd = 0;
     205
     206  // ----- Internal error handling
     207  public $error_code = 1;
     208  public $error_string = '';
     209
     210  // ----- Current status of the magic_quotes_runtime
     211  // This value store the php configuration for magic_quotes
     212  // The class can then disable the magic_quotes and reset it after
     213  public $magic_quotes_status;
    215214
    216215  // --------------------------------------------------------------------------------
     
    222221  //   created. Use create() for that.
    223222  // --------------------------------------------------------------------------------
    224   function __construct($p_zipname)
    225   {
     223  public function __construct($p_zipname) {
    226224
    227225    // ----- Tests the zlib
    228     if (!function_exists('gzopen'))
    229     {
    230       die('Abort '.basename(__FILE__).' : Missing zlib extensions');
     226    if (!function_exists('gzopen')) {
     227      die('Abort ' . basename(__FILE__) . ' : Missing zlib extensions');
    231228    }
    232229
     
    278275  //   (see PclZip::listContent() for list entry format)
    279276  // --------------------------------------------------------------------------------
    280   function create($p_filelist)
    281   {
    282     $v_result=1;
     277  public function create($p_filelist) {
     278    $v_result = 1;
    283279
    284280    // ----- Reset the error handler
     
    287283    // ----- Set default values
    288284    $v_options = array();
    289     $v_options[PCLZIP_OPT_NO_COMPRESSION] = FALSE;
     285    $v_options[PCLZIP_OPT_NO_COMPRESSION] = false;
    290286
    291287    // ----- Look for variable options arguments
     
    306302        // ----- Parse the options
    307303        $v_result = $this->privParseOptions($v_arg_list, $v_size, $v_options,
    308                                             array (PCLZIP_OPT_REMOVE_PATH => 'optional',
    309                                                    PCLZIP_OPT_REMOVE_ALL_PATH => 'optional',
    310                                                    PCLZIP_OPT_ADD_PATH => 'optional',
    311                                                    PCLZIP_CB_PRE_ADD => 'optional',
    312                                                    PCLZIP_CB_POST_ADD => 'optional',
    313                                                    PCLZIP_OPT_NO_COMPRESSION => 'optional',
    314                                                    PCLZIP_OPT_COMMENT => 'optional',
    315                                                    PCLZIP_OPT_TEMP_FILE_THRESHOLD => 'optional',
    316                                                    PCLZIP_OPT_TEMP_FILE_ON => 'optional',
    317                                                    PCLZIP_OPT_TEMP_FILE_OFF => 'optional'
    318                                                    //, PCLZIP_OPT_CRYPT => 'optional'
    319                                              ));
     304            array(
     305                PCLZIP_OPT_REMOVE_PATH => 'optional',
     306                PCLZIP_OPT_REMOVE_ALL_PATH => 'optional',
     307                PCLZIP_OPT_ADD_PATH => 'optional',
     308                PCLZIP_CB_PRE_ADD => 'optional',
     309                PCLZIP_CB_POST_ADD => 'optional',
     310                PCLZIP_OPT_NO_COMPRESSION => 'optional',
     311                PCLZIP_OPT_COMMENT => 'optional',
     312                PCLZIP_OPT_TEMP_FILE_THRESHOLD => 'optional',
     313                PCLZIP_OPT_TEMP_FILE_ON => 'optional',
     314                PCLZIP_OPT_TEMP_FILE_OFF => 'optional'
     315              //, PCLZIP_OPT_CRYPT => 'optional'
     316            ));
    320317        if ($v_result != 1) {
    321318          return 0;
     
    334331        if ($v_size == 2) {
    335332          $v_options[PCLZIP_OPT_REMOVE_PATH] = $v_arg_list[1];
    336         }
    337         else if ($v_size > 2) {
    338           PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER,
    339                                        "Invalid number / type of arguments");
    340           return 0;
    341         }
    342       }
    343     }
    344    
     333        } else {
     334          if ($v_size > 2) {
     335            PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER,
     336                "Invalid number / type of arguments");
     337
     338            return 0;
     339          }
     340        }
     341      }
     342    }
     343
    345344    // ----- Look for default option values
    346345    $this->privOptionDefaultThreshold($v_options);
     
    351350    $v_filedescr_list = array();
    352351    $p_result_list = array();
    353    
     352
    354353    // ----- Look if the $p_filelist is really an array
    355354    if (is_array($p_filelist)) {
    356    
     355
    357356      // ----- Look if the first element is also an array
    358357      //       This will mean that this is a file description entry
    359358      if (isset($p_filelist[0]) && is_array($p_filelist[0])) {
    360359        $v_att_list = $p_filelist;
    361       }
    362      
    363       // ----- The list is a list of string names
     360      } // ----- The list is a list of string names
    364361      else {
    365362        $v_string_list = $p_filelist;
    366363      }
    367     }
    368 
    369     // ----- Look if the $p_filelist is a string
    370     else if (is_string($p_filelist)) {
    371       // ----- Create a list from the string
    372       $v_string_list = explode(PCLZIP_SEPARATOR, $p_filelist);
    373     }
    374 
    375     // ----- Invalid variable type for $p_filelist
     364    } // ----- Look if the $p_filelist is a string
    376365    else {
    377       PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid variable type p_filelist");
    378       return 0;
    379     }
    380    
     366      if (is_string($p_filelist)) {
     367        // ----- Create a list from the string
     368        $v_string_list = explode(PCLZIP_SEPARATOR, $p_filelist);
     369      } // ----- Invalid variable type for $p_filelist
     370      else {
     371        PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid variable type p_filelist");
     372
     373        return 0;
     374      }
     375    }
     376
    381377    // ----- Reformat the string list
    382378    if (sizeof($v_string_list) != 0) {
     
    384380        if ($v_string != '') {
    385381          $v_att_list[][PCLZIP_ATT_FILE_NAME] = $v_string;
    386         }
    387         else {
    388         }
    389       }
    390     }
    391    
     382        } else {
     383        }
     384      }
     385    }
     386
    392387    // ----- For each file in the list check the attributes
    393388    $v_supported_attributes
    394     = array ( PCLZIP_ATT_FILE_NAME => 'mandatory'
    395              ,PCLZIP_ATT_FILE_NEW_SHORT_NAME => 'optional'
    396              ,PCLZIP_ATT_FILE_NEW_FULL_NAME => 'optional'
    397              ,PCLZIP_ATT_FILE_MTIME => 'optional'
    398              ,PCLZIP_ATT_FILE_CONTENT => 'optional'
    399              ,PCLZIP_ATT_FILE_COMMENT => 'optional'
    400                                                 );
     389        = array(
     390        PCLZIP_ATT_FILE_NAME => 'mandatory',
     391        PCLZIP_ATT_FILE_NEW_SHORT_NAME => 'optional',
     392        PCLZIP_ATT_FILE_NEW_FULL_NAME => 'optional',
     393        PCLZIP_ATT_FILE_MTIME => 'optional',
     394        PCLZIP_ATT_FILE_CONTENT => 'optional',
     395        PCLZIP_ATT_FILE_COMMENT => 'optional'
     396    );
    401397    foreach ($v_att_list as $v_entry) {
    402398      $v_result = $this->privFileDescrParseAtt($v_entry,
    403                                                $v_filedescr_list[],
    404                                                $v_options,
    405                                                $v_supported_attributes);
     399          $v_filedescr_list[],
     400          $v_options,
     401          $v_supported_attributes);
    406402      if ($v_result != 1) {
    407403        return 0;
     
    461457  //   (see PclZip::listContent() for list entry format)
    462458  // --------------------------------------------------------------------------------
    463   function add($p_filelist)
    464   {
    465     $v_result=1;
     459  public function add($p_filelist) {
     460    $v_result = 1;
    466461
    467462    // ----- Reset the error handler
     
    470465    // ----- Set default values
    471466    $v_options = array();
    472     $v_options[PCLZIP_OPT_NO_COMPRESSION] = FALSE;
     467    $v_options[PCLZIP_OPT_NO_COMPRESSION] = false;
    473468
    474469    // ----- Look for variable options arguments
     
    489484        // ----- Parse the options
    490485        $v_result = $this->privParseOptions($v_arg_list, $v_size, $v_options,
    491                                             array (PCLZIP_OPT_REMOVE_PATH => 'optional',
    492                                                    PCLZIP_OPT_REMOVE_ALL_PATH => 'optional',
    493                                                    PCLZIP_OPT_ADD_PATH => 'optional',
    494                                                    PCLZIP_CB_PRE_ADD => 'optional',
    495                                                    PCLZIP_CB_POST_ADD => 'optional',
    496                                                    PCLZIP_OPT_NO_COMPRESSION => 'optional',
    497                                                    PCLZIP_OPT_COMMENT => 'optional',
    498                                                    PCLZIP_OPT_ADD_COMMENT => 'optional',
    499                                                    PCLZIP_OPT_PREPEND_COMMENT => 'optional',
    500                                                    PCLZIP_OPT_TEMP_FILE_THRESHOLD => 'optional',
    501                                                    PCLZIP_OPT_TEMP_FILE_ON => 'optional',
    502                                                    PCLZIP_OPT_TEMP_FILE_OFF => 'optional'
    503                                                    //, PCLZIP_OPT_CRYPT => 'optional'
    504                                                                                                    ));
     486            array(
     487                PCLZIP_OPT_REMOVE_PATH => 'optional',
     488                PCLZIP_OPT_REMOVE_ALL_PATH => 'optional',
     489                PCLZIP_OPT_ADD_PATH => 'optional',
     490                PCLZIP_CB_PRE_ADD => 'optional',
     491                PCLZIP_CB_POST_ADD => 'optional',
     492                PCLZIP_OPT_NO_COMPRESSION => 'optional',
     493                PCLZIP_OPT_COMMENT => 'optional',
     494                PCLZIP_OPT_ADD_COMMENT => 'optional',
     495                PCLZIP_OPT_PREPEND_COMMENT => 'optional',
     496                PCLZIP_OPT_TEMP_FILE_THRESHOLD => 'optional',
     497                PCLZIP_OPT_TEMP_FILE_ON => 'optional',
     498                PCLZIP_OPT_TEMP_FILE_OFF => 'optional'
     499              //, PCLZIP_OPT_CRYPT => 'optional'
     500            ));
    505501        if ($v_result != 1) {
    506502          return 0;
     
    519515        if ($v_size == 2) {
    520516          $v_options[PCLZIP_OPT_REMOVE_PATH] = $v_arg_list[1];
    521         }
    522         else if ($v_size > 2) {
    523           // ----- Error log
    524           PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid number / type of arguments");
    525 
    526           // ----- Return
    527           return 0;
     517        } else {
     518          if ($v_size > 2) {
     519            // ----- Error log
     520            PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid number / type of arguments");
     521
     522            // ----- Return
     523            return 0;
     524          }
    528525        }
    529526      }
     
    538535    $v_filedescr_list = array();
    539536    $p_result_list = array();
    540    
     537
    541538    // ----- Look if the $p_filelist is really an array
    542539    if (is_array($p_filelist)) {
    543    
     540
    544541      // ----- Look if the first element is also an array
    545542      //       This will mean that this is a file description entry
    546543      if (isset($p_filelist[0]) && is_array($p_filelist[0])) {
    547544        $v_att_list = $p_filelist;
    548       }
    549      
    550       // ----- The list is a list of string names
     545      } // ----- The list is a list of string names
    551546      else {
    552547        $v_string_list = $p_filelist;
    553548      }
    554     }
    555 
    556     // ----- Look if the $p_filelist is a string
    557     else if (is_string($p_filelist)) {
    558       // ----- Create a list from the string
    559       $v_string_list = explode(PCLZIP_SEPARATOR, $p_filelist);
    560     }
    561 
    562     // ----- Invalid variable type for $p_filelist
     549    } // ----- Look if the $p_filelist is a string
    563550    else {
    564       PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid variable type '".gettype($p_filelist)."' for p_filelist");
    565       return 0;
    566     }
    567    
     551      if (is_string($p_filelist)) {
     552        // ----- Create a list from the string
     553        $v_string_list = explode(PCLZIP_SEPARATOR, $p_filelist);
     554      } // ----- Invalid variable type for $p_filelist
     555      else {
     556        PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER,
     557            "Invalid variable type '" . gettype($p_filelist) . "' for p_filelist");
     558
     559        return 0;
     560      }
     561    }
     562
    568563    // ----- Reformat the string list
    569564    if (sizeof($v_string_list) != 0) {
     
    572567      }
    573568    }
    574    
     569
    575570    // ----- For each file in the list check the attributes
    576571    $v_supported_attributes
    577     = array ( PCLZIP_ATT_FILE_NAME => 'mandatory'
    578              ,PCLZIP_ATT_FILE_NEW_SHORT_NAME => 'optional'
    579              ,PCLZIP_ATT_FILE_NEW_FULL_NAME => 'optional'
    580              ,PCLZIP_ATT_FILE_MTIME => 'optional'
    581              ,PCLZIP_ATT_FILE_CONTENT => 'optional'
    582              ,PCLZIP_ATT_FILE_COMMENT => 'optional'
    583                                                 );
     572        = array(
     573        PCLZIP_ATT_FILE_NAME => 'mandatory',
     574        PCLZIP_ATT_FILE_NEW_SHORT_NAME => 'optional',
     575        PCLZIP_ATT_FILE_NEW_FULL_NAME => 'optional',
     576        PCLZIP_ATT_FILE_MTIME => 'optional',
     577        PCLZIP_ATT_FILE_CONTENT => 'optional',
     578        PCLZIP_ATT_FILE_COMMENT => 'optional'
     579    );
    584580    foreach ($v_att_list as $v_entry) {
    585581      $v_result = $this->privFileDescrParseAtt($v_entry,
    586                                                $v_filedescr_list[],
    587                                                $v_options,
    588                                                $v_supported_attributes);
     582          $v_filedescr_list[],
     583          $v_options,
     584          $v_supported_attributes);
    589585      if ($v_result != 1) {
    590586        return 0;
     
    650646  //   The list of the files in the archive.
    651647  // --------------------------------------------------------------------------------
    652   function listContent()
    653   {
    654     $v_result=1;
     648  public function listContent() {
     649    $v_result = 1;
    655650
    656651    // ----- Reset the error handler
     
    659654    // ----- Check archive
    660655    if (!$this->privCheckFormat()) {
    661       return(0);
     656      return (0);
    662657    }
    663658
    664659    // ----- Call the extracting fct
    665660    $p_list = array();
    666     if (($v_result = $this->privList($p_list)) != 1)
    667     {
     661    if (($v_result = $this->privList($p_list)) != 1) {
    668662      unset($p_list);
    669       return(0);
     663
     664      return (0);
    670665    }
    671666
     
    707702  //   (see PclZip::listContent() for list entry format)
    708703  // --------------------------------------------------------------------------------
    709   function extract()
    710   {
    711     $v_result=1;
     704  public function extract() {
     705    $v_result = 1;
    712706
    713707    // ----- Reset the error handler
     
    716710    // ----- Check archive
    717711    if (!$this->privCheckFormat()) {
    718       return(0);
     712      return (0);
    719713    }
    720714
     
    730724
    731725    // ----- Default values for option
    732     $v_options[PCLZIP_OPT_EXTRACT_AS_STRING] = FALSE;
     726    $v_options[PCLZIP_OPT_EXTRACT_AS_STRING] = false;
    733727
    734728    // ----- Look for arguments
     
    742736        // ----- Parse the options
    743737        $v_result = $this->privParseOptions($v_arg_list, $v_size, $v_options,
    744                                             array (PCLZIP_OPT_PATH => 'optional',
    745                                                    PCLZIP_OPT_REMOVE_PATH => 'optional',
    746                                                    PCLZIP_OPT_REMOVE_ALL_PATH => 'optional',
    747                                                    PCLZIP_OPT_ADD_PATH => 'optional',
    748                                                    PCLZIP_CB_PRE_EXTRACT => 'optional',
    749                                                    PCLZIP_CB_POST_EXTRACT => 'optional',
    750                                                    PCLZIP_OPT_SET_CHMOD => 'optional',
    751                                                    PCLZIP_OPT_BY_NAME => 'optional',
    752                                                    PCLZIP_OPT_BY_EREG => 'optional',
    753                                                    PCLZIP_OPT_BY_PREG => 'optional',
    754                                                    PCLZIP_OPT_BY_INDEX => 'optional',
    755                                                    PCLZIP_OPT_EXTRACT_AS_STRING => 'optional',
    756                                                    PCLZIP_OPT_EXTRACT_IN_OUTPUT => 'optional',
    757                                                    PCLZIP_OPT_REPLACE_NEWER => 'optional'
    758                                                    ,PCLZIP_OPT_STOP_ON_ERROR => 'optional'
    759                                                    ,PCLZIP_OPT_EXTRACT_DIR_RESTRICTION => 'optional',
    760                                                    PCLZIP_OPT_TEMP_FILE_THRESHOLD => 'optional',
    761                                                    PCLZIP_OPT_TEMP_FILE_ON => 'optional',
    762                                                    PCLZIP_OPT_TEMP_FILE_OFF => 'optional'
    763                                                                                                     ));
     738            array(
     739                PCLZIP_OPT_PATH => 'optional',
     740                PCLZIP_OPT_REMOVE_PATH => 'optional',
     741                PCLZIP_OPT_REMOVE_ALL_PATH => 'optional',
     742                PCLZIP_OPT_ADD_PATH => 'optional',
     743                PCLZIP_CB_PRE_EXTRACT => 'optional',
     744                PCLZIP_CB_POST_EXTRACT => 'optional',
     745                PCLZIP_OPT_SET_CHMOD => 'optional',
     746                PCLZIP_OPT_BY_NAME => 'optional',
     747                PCLZIP_OPT_BY_EREG => 'optional',
     748                PCLZIP_OPT_BY_PREG => 'optional',
     749                PCLZIP_OPT_BY_INDEX => 'optional',
     750                PCLZIP_OPT_EXTRACT_AS_STRING => 'optional',
     751                PCLZIP_OPT_EXTRACT_IN_OUTPUT => 'optional',
     752                PCLZIP_OPT_REPLACE_NEWER => 'optional',
     753                PCLZIP_OPT_STOP_ON_ERROR => 'optional',
     754                PCLZIP_OPT_EXTRACT_DIR_RESTRICTION => 'optional',
     755                PCLZIP_OPT_TEMP_FILE_THRESHOLD => 'optional',
     756                PCLZIP_OPT_TEMP_FILE_ON => 'optional',
     757                PCLZIP_OPT_TEMP_FILE_OFF => 'optional'
     758            ));
    764759        if ($v_result != 1) {
    765760          return 0;
     
    796791        if ($v_size == 2) {
    797792          $v_remove_path = $v_arg_list[1];
    798         }
    799         else if ($v_size > 2) {
    800           // ----- Error log
    801           PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid number / type of arguments");
    802 
    803           // ----- Return
    804           return 0;
     793        } else {
     794          if ($v_size > 2) {
     795            // ----- Error log
     796            PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid number / type of arguments");
     797
     798            // ----- Return
     799            return 0;
     800          }
    805801        }
    806802      }
     
    815811    $p_list = array();
    816812    $v_result = $this->privExtractByRule($p_list, $v_path, $v_remove_path,
    817                                              $v_remove_all_path, $v_options);
     813        $v_remove_all_path, $v_options);
    818814    if ($v_result < 1) {
    819815      unset($p_list);
    820       return(0);
     816
     817      return (0);
    821818    }
    822819
     
    864861  // --------------------------------------------------------------------------------
    865862  //function extractByIndex($p_index, options...)
    866   function extractByIndex($p_index)
    867   {
    868     $v_result=1;
     863  public function extractByIndex($p_index) {
     864    $v_result = 1;
    869865
    870866    // ----- Reset the error handler
     
    873869    // ----- Check archive
    874870    if (!$this->privCheckFormat()) {
    875       return(0);
     871      return (0);
    876872    }
    877873
     
    887883
    888884    // ----- Default values for option
    889     $v_options[PCLZIP_OPT_EXTRACT_AS_STRING] = FALSE;
     885    $v_options[PCLZIP_OPT_EXTRACT_AS_STRING] = false;
    890886
    891887    // ----- Look for arguments
     
    903899        // ----- Parse the options
    904900        $v_result = $this->privParseOptions($v_arg_list, $v_size, $v_options,
    905                                             array (PCLZIP_OPT_PATH => 'optional',
    906                                                    PCLZIP_OPT_REMOVE_PATH => 'optional',
    907                                                    PCLZIP_OPT_REMOVE_ALL_PATH => 'optional',
    908                                                    PCLZIP_OPT_EXTRACT_AS_STRING => 'optional',
    909                                                    PCLZIP_OPT_ADD_PATH => 'optional',
    910                                                    PCLZIP_CB_PRE_EXTRACT => 'optional',
    911                                                    PCLZIP_CB_POST_EXTRACT => 'optional',
    912                                                    PCLZIP_OPT_SET_CHMOD => 'optional',
    913                                                    PCLZIP_OPT_REPLACE_NEWER => 'optional'
    914                                                    ,PCLZIP_OPT_STOP_ON_ERROR => 'optional'
    915                                                    ,PCLZIP_OPT_EXTRACT_DIR_RESTRICTION => 'optional',
    916                                                    PCLZIP_OPT_TEMP_FILE_THRESHOLD => 'optional',
    917                                                    PCLZIP_OPT_TEMP_FILE_ON => 'optional',
    918                                                    PCLZIP_OPT_TEMP_FILE_OFF => 'optional'
    919                                                                                                    ));
     901            array(
     902                PCLZIP_OPT_PATH => 'optional',
     903                PCLZIP_OPT_REMOVE_PATH => 'optional',
     904                PCLZIP_OPT_REMOVE_ALL_PATH => 'optional',
     905                PCLZIP_OPT_EXTRACT_AS_STRING => 'optional',
     906                PCLZIP_OPT_ADD_PATH => 'optional',
     907                PCLZIP_CB_PRE_EXTRACT => 'optional',
     908                PCLZIP_CB_POST_EXTRACT => 'optional',
     909                PCLZIP_OPT_SET_CHMOD => 'optional',
     910                PCLZIP_OPT_REPLACE_NEWER => 'optional',
     911                PCLZIP_OPT_STOP_ON_ERROR => 'optional',
     912                PCLZIP_OPT_EXTRACT_DIR_RESTRICTION => 'optional',
     913                PCLZIP_OPT_TEMP_FILE_THRESHOLD => 'optional',
     914                PCLZIP_OPT_TEMP_FILE_ON => 'optional',
     915                PCLZIP_OPT_TEMP_FILE_OFF => 'optional'
     916            ));
    920917        if ($v_result != 1) {
    921918          return 0;
     
    940937        }
    941938        if (!isset($v_options[PCLZIP_OPT_EXTRACT_AS_STRING])) {
    942           $v_options[PCLZIP_OPT_EXTRACT_AS_STRING] = FALSE;
    943         }
    944         else {
     939          $v_options[PCLZIP_OPT_EXTRACT_AS_STRING] = false;
     940        } else {
    945941        }
    946942      }
     
    957953        if ($v_size == 2) {
    958954          $v_remove_path = $v_arg_list[1];
    959         }
    960         else if ($v_size > 2) {
    961           // ----- Error log
    962           PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid number / type of arguments");
    963 
    964           // ----- Return
    965           return 0;
     955        } else {
     956          if ($v_size > 2) {
     957            // ----- Error log
     958            PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid number / type of arguments");
     959
     960            // ----- Return
     961            return 0;
     962          }
    966963        }
    967964      }
     
    973970    // Here I want to reuse extractByRule(), so I need to parse the $p_index
    974971    // with privParseOptions()
    975     $v_arg_trick = array (PCLZIP_OPT_BY_INDEX, $p_index);
     972    $v_arg_trick = array(PCLZIP_OPT_BY_INDEX, $p_index);
    976973    $v_options_trick = array();
    977974    $v_result = $this->privParseOptions($v_arg_trick, sizeof($v_arg_trick), $v_options_trick,
    978                                         array (PCLZIP_OPT_BY_INDEX => 'optional' ));
     975        array(PCLZIP_OPT_BY_INDEX => 'optional'));
    979976    if ($v_result != 1) {
    980         return 0;
     977      return 0;
    981978    }
    982979    $v_options[PCLZIP_OPT_BY_INDEX] = $v_options_trick[PCLZIP_OPT_BY_INDEX];
     
    987984    // ----- Call the extracting fct
    988985    if (($v_result = $this->privExtractByRule($p_list, $v_path, $v_remove_path, $v_remove_all_path, $v_options)) < 1) {
    989         return(0);
     986      return (0);
    990987    }
    991988
     
    10061003  //   PCLZIP_OPT_BY_INDEX :
    10071004  //   PCLZIP_OPT_BY_NAME :
    1008   //   PCLZIP_OPT_BY_EREG : 
     1005  //   PCLZIP_OPT_BY_EREG :
    10091006  //   PCLZIP_OPT_BY_PREG :
    10101007  // Return Values :
     
    10131010  //   (see PclZip::listContent() for list entry format)
    10141011  // --------------------------------------------------------------------------------
    1015   function delete()
    1016   {
    1017     $v_result=1;
     1012  public function delete() {
     1013    $v_result = 1;
    10181014
    10191015    // ----- Reset the error handler
     
    10221018    // ----- Check archive
    10231019    if (!$this->privCheckFormat()) {
    1024       return(0);
     1020      return (0);
    10251021    }
    10261022
     
    10381034      // ----- Parse the options
    10391035      $v_result = $this->privParseOptions($v_arg_list, $v_size, $v_options,
    1040                                         array (PCLZIP_OPT_BY_NAME => 'optional',
    1041                                                PCLZIP_OPT_BY_EREG => 'optional',
    1042                                                PCLZIP_OPT_BY_PREG => 'optional',
    1043                                                PCLZIP_OPT_BY_INDEX => 'optional' ));
     1036          array(
     1037              PCLZIP_OPT_BY_NAME => 'optional',
     1038              PCLZIP_OPT_BY_EREG => 'optional',
     1039              PCLZIP_OPT_BY_PREG => 'optional',
     1040              PCLZIP_OPT_BY_INDEX => 'optional'
     1041          ));
    10441042      if ($v_result != 1) {
    1045           return 0;
     1043        return 0;
    10461044      }
    10471045    }
     
    10551053      $this->privSwapBackMagicQuotes();
    10561054      unset($v_list);
    1057       return(0);
     1055
     1056      return (0);
    10581057    }
    10591058
     
    10721071  //   delete(PCLZIP_OPT_BY_INDEX, $p_index) should be prefered.
    10731072  // --------------------------------------------------------------------------------
    1074   function deleteByIndex($p_index)
    1075   {
    1076    
     1073  public function deleteByIndex($p_index) {
     1074
    10771075    $p_list = $this->delete(PCLZIP_OPT_BY_INDEX, $p_index);
    10781076
     
    10961094  //   An array with the archive properties.
    10971095  // --------------------------------------------------------------------------------
    1098   function properties()
    1099   {
     1096  public function properties() {
    11001097
    11011098    // ----- Reset the error handler
     
    11081105    if (!$this->privCheckFormat()) {
    11091106      $this->privSwapBackMagicQuotes();
    1110       return(0);
     1107
     1108      return (0);
    11111109    }
    11121110
     
    11181116
    11191117    // ----- Look if file exists
    1120     if (@is_file($this->zipname))
    1121     {
     1118    if (@is_file($this->zipname)) {
    11221119      // ----- Open the zip file
    1123       if (($this->zip_fd = @fopen($this->zipname, 'rb')) == 0)
    1124       {
     1120      if (($this->zip_fd = @fopen($this->zipname, 'rb')) == 0) {
    11251121        $this->privSwapBackMagicQuotes();
    1126        
     1122
    11271123        // ----- Error log
    1128         PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, 'Unable to open archive \''.$this->zipname.'\' in binary read mode');
     1124        PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL,
     1125            'Unable to open archive \'' . $this->zipname . '\' in binary read mode');
    11291126
    11301127        // ----- Return
     
    11341131      // ----- Read the central directory informations
    11351132      $v_central_dir = array();
    1136       if (($v_result = $this->privReadEndCentralDir($v_central_dir)) != 1)
    1137       {
     1133      if (($v_result = $this->privReadEndCentralDir($v_central_dir)) != 1) {
    11381134        $this->privSwapBackMagicQuotes();
     1135
    11391136        return 0;
    11401137      }
     
    11691166  //   0 or a negative value on error (error code).
    11701167  // --------------------------------------------------------------------------------
    1171   function duplicate($p_archive)
    1172   {
     1168  public function duplicate($p_archive) {
    11731169    $v_result = 1;
    11741170
     
    11771173
    11781174    // ----- Look if the $p_archive is a PclZip object
    1179     if ((is_object($p_archive)) && (get_class($p_archive) == 'pclzip'))
    1180     {
     1175    if ((is_object($p_archive)) && (get_class($p_archive) == 'pclzip')) {
    11811176
    11821177      // ----- Duplicate the archive
    11831178      $v_result = $this->privDuplicate($p_archive->zipname);
    1184     }
    1185 
    1186     // ----- Look if the $p_archive is a string (so a filename)
    1187     else if (is_string($p_archive))
    1188     {
    1189 
    1190       // ----- Check that $p_archive is a valid zip file
    1191       // TBC : Should also check the archive format
    1192       if (!is_file($p_archive)) {
     1179    } // ----- Look if the $p_archive is a string (so a filename)
     1180    else {
     1181      if (is_string($p_archive)) {
     1182
     1183        // ----- Check that $p_archive is a valid zip file
     1184        // TBC : Should also check the archive format
     1185        if (!is_file($p_archive)) {
     1186          // ----- Error log
     1187          PclZip::privErrorLog(PCLZIP_ERR_MISSING_FILE, "No file with filename '" . $p_archive . "'");
     1188          $v_result = PCLZIP_ERR_MISSING_FILE;
     1189        } else {
     1190          // ----- Duplicate the archive
     1191          $v_result = $this->privDuplicate($p_archive);
     1192        }
     1193      } // ----- Invalid variable
     1194      else {
    11931195        // ----- Error log
    1194         PclZip::privErrorLog(PCLZIP_ERR_MISSING_FILE, "No file with filename '".$p_archive."'");
    1195         $v_result = PCLZIP_ERR_MISSING_FILE;
    1196       }
    1197       else {
    1198         // ----- Duplicate the archive
    1199         $v_result = $this->privDuplicate($p_archive);
    1200       }
    1201     }
    1202 
    1203     // ----- Invalid variable
    1204     else
    1205     {
    1206       // ----- Error log
    1207       PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid variable type p_archive_to_add");
    1208       $v_result = PCLZIP_ERR_INVALID_PARAMETER;
     1196        PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid variable type p_archive_to_add");
     1197        $v_result = PCLZIP_ERR_INVALID_PARAMETER;
     1198      }
    12091199    }
    12101200
     
    12281218  //   0 or negative values on error (see below).
    12291219  // --------------------------------------------------------------------------------
    1230   function merge($p_archive_to_add)
    1231   {
     1220  public function merge($p_archive_to_add) {
    12321221    $v_result = 1;
    12331222
     
    12371226    // ----- Check archive
    12381227    if (!$this->privCheckFormat()) {
    1239       return(0);
     1228      return (0);
    12401229    }
    12411230
    12421231    // ----- Look if the $p_archive_to_add is a PclZip object
    1243     if ((is_object($p_archive_to_add)) && (get_class($p_archive_to_add) == 'pclzip'))
    1244     {
     1232    if ((is_object($p_archive_to_add)) && (get_class($p_archive_to_add) == 'pclzip')) {
    12451233
    12461234      // ----- Merge the archive
    12471235      $v_result = $this->privMerge($p_archive_to_add);
    1248     }
    1249 
    1250     // ----- Look if the $p_archive_to_add is a string (so a filename)
    1251     else if (is_string($p_archive_to_add))
    1252     {
    1253 
    1254       // ----- Create a temporary archive
    1255       $v_object_archive = new PclZip($p_archive_to_add);
    1256 
    1257       // ----- Merge the archive
    1258       $v_result = $this->privMerge($v_object_archive);
    1259     }
    1260 
    1261     // ----- Invalid variable
    1262     else
    1263     {
    1264       // ----- Error log
    1265       PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid variable type p_archive_to_add");
    1266       $v_result = PCLZIP_ERR_INVALID_PARAMETER;
     1236    } // ----- Look if the $p_archive_to_add is a string (so a filename)
     1237    else {
     1238      if (is_string($p_archive_to_add)) {
     1239
     1240        // ----- Create a temporary archive
     1241        $v_object_archive = new PclZip($p_archive_to_add);
     1242
     1243        // ----- Merge the archive
     1244        $v_result = $this->privMerge($v_object_archive);
     1245      } // ----- Invalid variable
     1246      else {
     1247        // ----- Error log
     1248        PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid variable type p_archive_to_add");
     1249        $v_result = PCLZIP_ERR_INVALID_PARAMETER;
     1250      }
    12671251    }
    12681252
     
    12711255  }
    12721256  // --------------------------------------------------------------------------------
    1273 
    12741257
    12751258
     
    12791262  // Parameters :
    12801263  // --------------------------------------------------------------------------------
    1281   function errorCode()
    1282   {
     1264  public function errorCode() {
    12831265    if (PCLZIP_ERROR_EXTERNAL == 1) {
    1284       return(PclErrorCode());
    1285     }
    1286     else {
    1287       return($this->error_code);
     1266      return (PclErrorCode());
     1267    } else {
     1268      return ($this->error_code);
    12881269    }
    12891270  }
     
    12951276  // Parameters :
    12961277  // --------------------------------------------------------------------------------
    1297   function errorName($p_with_code=false)
    1298   {
    1299     $v_name = array ( PCLZIP_ERR_NO_ERROR => 'PCLZIP_ERR_NO_ERROR',
    1300                       PCLZIP_ERR_WRITE_OPEN_FAIL => 'PCLZIP_ERR_WRITE_OPEN_FAIL',
    1301                       PCLZIP_ERR_READ_OPEN_FAIL => 'PCLZIP_ERR_READ_OPEN_FAIL',
    1302                       PCLZIP_ERR_INVALID_PARAMETER => 'PCLZIP_ERR_INVALID_PARAMETER',
    1303                       PCLZIP_ERR_MISSING_FILE => 'PCLZIP_ERR_MISSING_FILE',
    1304                       PCLZIP_ERR_FILENAME_TOO_LONG => 'PCLZIP_ERR_FILENAME_TOO_LONG',
    1305                       PCLZIP_ERR_INVALID_ZIP => 'PCLZIP_ERR_INVALID_ZIP',
    1306                       PCLZIP_ERR_BAD_EXTRACTED_FILE => 'PCLZIP_ERR_BAD_EXTRACTED_FILE',
    1307                       PCLZIP_ERR_DIR_CREATE_FAIL => 'PCLZIP_ERR_DIR_CREATE_FAIL',
    1308                       PCLZIP_ERR_BAD_EXTENSION => 'PCLZIP_ERR_BAD_EXTENSION',
    1309                       PCLZIP_ERR_BAD_FORMAT => 'PCLZIP_ERR_BAD_FORMAT',
    1310                       PCLZIP_ERR_DELETE_FILE_FAIL => 'PCLZIP_ERR_DELETE_FILE_FAIL',
    1311                       PCLZIP_ERR_RENAME_FILE_FAIL => 'PCLZIP_ERR_RENAME_FILE_FAIL',
    1312                       PCLZIP_ERR_BAD_CHECKSUM => 'PCLZIP_ERR_BAD_CHECKSUM',
    1313                       PCLZIP_ERR_INVALID_ARCHIVE_ZIP => 'PCLZIP_ERR_INVALID_ARCHIVE_ZIP',
    1314                       PCLZIP_ERR_MISSING_OPTION_VALUE => 'PCLZIP_ERR_MISSING_OPTION_VALUE',
    1315                       PCLZIP_ERR_INVALID_OPTION_VALUE => 'PCLZIP_ERR_INVALID_OPTION_VALUE',
    1316                       PCLZIP_ERR_UNSUPPORTED_COMPRESSION => 'PCLZIP_ERR_UNSUPPORTED_COMPRESSION',
    1317                       PCLZIP_ERR_UNSUPPORTED_ENCRYPTION => 'PCLZIP_ERR_UNSUPPORTED_ENCRYPTION'
    1318                       ,PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE => 'PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE'
    1319                       ,PCLZIP_ERR_DIRECTORY_RESTRICTION => 'PCLZIP_ERR_DIRECTORY_RESTRICTION'
    1320                     );
     1278  public function errorName($p_with_code = false) {
     1279    $v_name = array(
     1280        PCLZIP_ERR_NO_ERROR => 'PCLZIP_ERR_NO_ERROR',
     1281        PCLZIP_ERR_WRITE_OPEN_FAIL => 'PCLZIP_ERR_WRITE_OPEN_FAIL',
     1282        PCLZIP_ERR_READ_OPEN_FAIL => 'PCLZIP_ERR_READ_OPEN_FAIL',
     1283        PCLZIP_ERR_INVALID_PARAMETER => 'PCLZIP_ERR_INVALID_PARAMETER',
     1284        PCLZIP_ERR_MISSING_FILE => 'PCLZIP_ERR_MISSING_FILE',
     1285        PCLZIP_ERR_FILENAME_TOO_LONG => 'PCLZIP_ERR_FILENAME_TOO_LONG',
     1286        PCLZIP_ERR_INVALID_ZIP => 'PCLZIP_ERR_INVALID_ZIP',
     1287        PCLZIP_ERR_BAD_EXTRACTED_FILE => 'PCLZIP_ERR_BAD_EXTRACTED_FILE',
     1288        PCLZIP_ERR_DIR_CREATE_FAIL => 'PCLZIP_ERR_DIR_CREATE_FAIL',
     1289        PCLZIP_ERR_BAD_EXTENSION => 'PCLZIP_ERR_BAD_EXTENSION',
     1290        PCLZIP_ERR_BAD_FORMAT => 'PCLZIP_ERR_BAD_FORMAT',
     1291        PCLZIP_ERR_DELETE_FILE_FAIL => 'PCLZIP_ERR_DELETE_FILE_FAIL',
     1292        PCLZIP_ERR_RENAME_FILE_FAIL => 'PCLZIP_ERR_RENAME_FILE_FAIL',
     1293        PCLZIP_ERR_BAD_CHECKSUM => 'PCLZIP_ERR_BAD_CHECKSUM',
     1294        PCLZIP_ERR_INVALID_ARCHIVE_ZIP => 'PCLZIP_ERR_INVALID_ARCHIVE_ZIP',
     1295        PCLZIP_ERR_MISSING_OPTION_VALUE => 'PCLZIP_ERR_MISSING_OPTION_VALUE',
     1296        PCLZIP_ERR_INVALID_OPTION_VALUE => 'PCLZIP_ERR_INVALID_OPTION_VALUE',
     1297        PCLZIP_ERR_UNSUPPORTED_COMPRESSION => 'PCLZIP_ERR_UNSUPPORTED_COMPRESSION',
     1298        PCLZIP_ERR_UNSUPPORTED_ENCRYPTION => 'PCLZIP_ERR_UNSUPPORTED_ENCRYPTION',
     1299        PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE => 'PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE',
     1300        PCLZIP_ERR_DIRECTORY_RESTRICTION => 'PCLZIP_ERR_DIRECTORY_RESTRICTION'
     1301    );
    13211302
    13221303    if (isset($v_name[$this->error_code])) {
    13231304      $v_value = $v_name[$this->error_code];
    1324     }
    1325     else {
     1305    } else {
    13261306      $v_value = 'NoName';
    13271307    }
    13281308
    13291309    if ($p_with_code) {
    1330       return($v_value.' ('.$this->error_code.')');
    1331     }
    1332     else {
    1333       return($v_value);
     1310      return ($v_value . ' (' . $this->error_code . ')');
     1311    } else {
     1312      return ($v_value);
    13341313    }
    13351314  }
     
    13411320  // Parameters :
    13421321  // --------------------------------------------------------------------------------
    1343   function errorInfo($p_full=false)
    1344   {
     1322  public function errorInfo($p_full = false) {
    13451323    if (PCLZIP_ERROR_EXTERNAL == 1) {
    1346       return(PclErrorString());
    1347     }
    1348     else {
     1324      return (PclErrorString());
     1325    } else {
    13491326      if ($p_full) {
    1350         return($this->errorName(true)." : ".$this->error_string);
    1351       }
    1352       else {
    1353         return($this->error_string." [code ".$this->error_code."]");
     1327        return ($this->errorName(true) . " : " . $this->error_string);
     1328      } else {
     1329        return ($this->error_string . " [code " . $this->error_code . "]");
    13541330      }
    13551331    }
     
    13631339// *****       THESES FUNCTIONS MUST NOT BE USED DIRECTLY       *****
    13641340// --------------------------------------------------------------------------------
    1365 
    13661341
    13671342
     
    13801355  //   false on error, the error code is set.
    13811356  // --------------------------------------------------------------------------------
    1382   function privCheckFormat($p_level=0)
    1383   {
     1357  public function privCheckFormat($p_level = 0) {
    13841358    $v_result = true;
    13851359
    1386         // ----- Reset the file system cache
     1360    // ----- Reset the file system cache
    13871361    clearstatcache();
    13881362
     
    13931367    if (!is_file($this->zipname)) {
    13941368      // ----- Error log
    1395       PclZip::privErrorLog(PCLZIP_ERR_MISSING_FILE, "Missing archive file '".$this->zipname."'");
    1396       return(false);
     1369      PclZip::privErrorLog(PCLZIP_ERR_MISSING_FILE, "Missing archive file '" . $this->zipname . "'");
     1370
     1371      return (false);
    13971372    }
    13981373
     
    14001375    if (!is_readable($this->zipname)) {
    14011376      // ----- Error log
    1402       PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, "Unable to read archive '".$this->zipname."'");
    1403       return(false);
     1377      PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, "Unable to read archive '" . $this->zipname . "'");
     1378
     1379      return (false);
    14041380    }
    14051381
     
    14331409  //   0 on failure.
    14341410  // --------------------------------------------------------------------------------
    1435   function privParseOptions(&$p_options_list, $p_size, &$v_result_list, $v_requested_options=false)
    1436   {
    1437     $v_result=1;
    1438    
     1411  public function privParseOptions(&$p_options_list, $p_size, &$v_result_list, $v_requested_options = false) {
     1412    $v_result = 1;
     1413
    14391414    // ----- Read the options
    1440     $i=0;
    1441     while ($i<$p_size) {
     1415    $i = 0;
     1416    while ($i < $p_size) {
    14421417
    14431418      // ----- Check if the option is supported
    14441419      if (!isset($v_requested_options[$p_options_list[$i]])) {
    14451420        // ----- Error log
    1446         PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid optional parameter '".$p_options_list[$i]."' for this method");
     1421        PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER,
     1422            "Invalid optional parameter '" . $p_options_list[$i] . "' for this method");
    14471423
    14481424        // ----- Return
     
    14571433        case PCLZIP_OPT_ADD_PATH :
    14581434          // ----- Check the number of parameters
    1459           if (($i+1) >= $p_size) {
     1435          if (($i + 1) >= $p_size) {
    14601436            // ----- Error log
    1461             PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE, "Missing parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
     1437            PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE,
     1438                "Missing parameter value for option '" . PclZipUtilOptionText($p_options_list[$i]) . "'");
    14621439
    14631440            // ----- Return
     
    14661443
    14671444          // ----- Get the value
    1468           $v_result_list[$p_options_list[$i]] = PclZipUtilTranslateWinPath($p_options_list[$i+1], FALSE);
     1445          $v_result_list[$p_options_list[$i]] = PclZipUtilTranslateWinPath($p_options_list[$i + 1], false);
    14691446          $i++;
    1470         break;
     1447          break;
    14711448
    14721449        case PCLZIP_OPT_TEMP_FILE_THRESHOLD :
    14731450          // ----- Check the number of parameters
    1474           if (($i+1) >= $p_size) {
    1475             PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE, "Missing parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
     1451          if (($i + 1) >= $p_size) {
     1452            PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE,
     1453                "Missing parameter value for option '" . PclZipUtilOptionText($p_options_list[$i]) . "'");
     1454
    14761455            return PclZip::errorCode();
    14771456          }
    1478          
     1457
    14791458          // ----- Check for incompatible options
    14801459          if (isset($v_result_list[PCLZIP_OPT_TEMP_FILE_OFF])) {
    1481             PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Option '".PclZipUtilOptionText($p_options_list[$i])."' can not be used with option 'PCLZIP_OPT_TEMP_FILE_OFF'");
     1460            PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER,
     1461                "Option '" . PclZipUtilOptionText($p_options_list[$i]) . "' can not be used with option 'PCLZIP_OPT_TEMP_FILE_OFF'");
     1462
    14821463            return PclZip::errorCode();
    14831464          }
    1484          
     1465
    14851466          // ----- Check the value
    1486           $v_value = $p_options_list[$i+1];
    1487           if ((!is_integer($v_value)) || ($v_value<0)) {
    1488             PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE, "Integer expected for option '".PclZipUtilOptionText($p_options_list[$i])."'");
     1467          $v_value = $p_options_list[$i + 1];
     1468          if ((!is_integer($v_value)) || ($v_value < 0)) {
     1469            PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE,
     1470                "Integer expected for option '" . PclZipUtilOptionText($p_options_list[$i]) . "'");
     1471
    14891472            return PclZip::errorCode();
    14901473          }
    14911474
    14921475          // ----- Get the value (and convert it in bytes)
    1493           $v_result_list[$p_options_list[$i]] = $v_value*1048576;
     1476          $v_result_list[$p_options_list[$i]] = $v_value * 1048576;
    14941477          $i++;
    1495         break;
     1478          break;
    14961479
    14971480        case PCLZIP_OPT_TEMP_FILE_ON :
    14981481          // ----- Check for incompatible options
    14991482          if (isset($v_result_list[PCLZIP_OPT_TEMP_FILE_OFF])) {
    1500             PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Option '".PclZipUtilOptionText($p_options_list[$i])."' can not be used with option 'PCLZIP_OPT_TEMP_FILE_OFF'");
     1483            PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER,
     1484                "Option '" . PclZipUtilOptionText($p_options_list[$i]) . "' can not be used with option 'PCLZIP_OPT_TEMP_FILE_OFF'");
     1485
    15011486            return PclZip::errorCode();
    15021487          }
    1503          
     1488
    15041489          $v_result_list[$p_options_list[$i]] = true;
    1505         break;
     1490          break;
    15061491
    15071492        case PCLZIP_OPT_TEMP_FILE_OFF :
    15081493          // ----- Check for incompatible options
    15091494          if (isset($v_result_list[PCLZIP_OPT_TEMP_FILE_ON])) {
    1510             PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Option '".PclZipUtilOptionText($p_options_list[$i])."' can not be used with option 'PCLZIP_OPT_TEMP_FILE_ON'");
     1495            PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER,
     1496                "Option '" . PclZipUtilOptionText($p_options_list[$i]) . "' can not be used with option 'PCLZIP_OPT_TEMP_FILE_ON'");
     1497
    15111498            return PclZip::errorCode();
    15121499          }
    15131500          // ----- Check for incompatible options
    15141501          if (isset($v_result_list[PCLZIP_OPT_TEMP_FILE_THRESHOLD])) {
    1515             PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Option '".PclZipUtilOptionText($p_options_list[$i])."' can not be used with option 'PCLZIP_OPT_TEMP_FILE_THRESHOLD'");
     1502            PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER,
     1503                "Option '" . PclZipUtilOptionText($p_options_list[$i]) . "' can not be used with option 'PCLZIP_OPT_TEMP_FILE_THRESHOLD'");
     1504
    15161505            return PclZip::errorCode();
    15171506          }
    1518          
     1507
    15191508          $v_result_list[$p_options_list[$i]] = true;
    1520         break;
     1509          break;
    15211510
    15221511        case PCLZIP_OPT_EXTRACT_DIR_RESTRICTION :
    15231512          // ----- Check the number of parameters
    1524           if (($i+1) >= $p_size) {
     1513          if (($i + 1) >= $p_size) {
    15251514            // ----- Error log
    1526             PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE, "Missing parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
     1515            PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE,
     1516                "Missing parameter value for option '" . PclZipUtilOptionText($p_options_list[$i]) . "'");
    15271517
    15281518            // ----- Return
     
    15311521
    15321522          // ----- Get the value
    1533           if (   is_string($p_options_list[$i+1])
    1534               && ($p_options_list[$i+1] != '')) {
    1535             $v_result_list[$p_options_list[$i]] = PclZipUtilTranslateWinPath($p_options_list[$i+1], FALSE);
     1523          if (is_string($p_options_list[$i + 1])
     1524              && ($p_options_list[$i + 1] != '')
     1525          ) {
     1526            $v_result_list[$p_options_list[$i]] = PclZipUtilTranslateWinPath($p_options_list[$i + 1], false);
    15361527            $i++;
    1537           }
    1538           else {
    1539           }
    1540         break;
     1528          } else {
     1529          }
     1530          break;
    15411531
    15421532        // ----- Look for options that request an array of string for value
    15431533        case PCLZIP_OPT_BY_NAME :
    15441534          // ----- Check the number of parameters
    1545           if (($i+1) >= $p_size) {
     1535          if (($i + 1) >= $p_size) {
    15461536            // ----- Error log
    1547             PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE, "Missing parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
     1537            PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE,
     1538                "Missing parameter value for option '" . PclZipUtilOptionText($p_options_list[$i]) . "'");
    15481539
    15491540            // ----- Return
     
    15521543
    15531544          // ----- Get the value
    1554           if (is_string($p_options_list[$i+1])) {
    1555               $v_result_list[$p_options_list[$i]][0] = $p_options_list[$i+1];
    1556           }
    1557           else if (is_array($p_options_list[$i+1])) {
    1558               $v_result_list[$p_options_list[$i]] = $p_options_list[$i+1];
    1559           }
    1560           else {
    1561             // ----- Error log
    1562             PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE, "Wrong parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
    1563 
    1564             // ----- Return
    1565             return PclZip::errorCode();
     1545          if (is_string($p_options_list[$i + 1])) {
     1546            $v_result_list[$p_options_list[$i]][0] = $p_options_list[$i + 1];
     1547          } else {
     1548            if (is_array($p_options_list[$i + 1])) {
     1549              $v_result_list[$p_options_list[$i]] = $p_options_list[$i + 1];
     1550            } else {
     1551              // ----- Error log
     1552              PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE,
     1553                  "Wrong parameter value for option '" . PclZipUtilOptionText($p_options_list[$i]) . "'");
     1554
     1555              // ----- Return
     1556              return PclZip::errorCode();
     1557            }
    15661558          }
    15671559          $i++;
    1568         break;
     1560          break;
    15691561
    15701562        // ----- Look for options that request an EREG or PREG expression
     
    15741566          $p_options_list[$i] = PCLZIP_OPT_BY_PREG;
    15751567        case PCLZIP_OPT_BY_PREG :
    1576         //case PCLZIP_OPT_CRYPT :
     1568          //case PCLZIP_OPT_CRYPT :
    15771569          // ----- Check the number of parameters
    1578           if (($i+1) >= $p_size) {
     1570          if (($i + 1) >= $p_size) {
    15791571            // ----- Error log
    1580             PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE, "Missing parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
     1572            PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE,
     1573                "Missing parameter value for option '" . PclZipUtilOptionText($p_options_list[$i]) . "'");
    15811574
    15821575            // ----- Return
     
    15851578
    15861579          // ----- Get the value
    1587           if (is_string($p_options_list[$i+1])) {
    1588               $v_result_list[$p_options_list[$i]] = $p_options_list[$i+1];
    1589           }
    1590           else {
     1580          if (is_string($p_options_list[$i + 1])) {
     1581            $v_result_list[$p_options_list[$i]] = $p_options_list[$i + 1];
     1582          } else {
    15911583            // ----- Error log
    1592             PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE, "Wrong parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
     1584            PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE,
     1585                "Wrong parameter value for option '" . PclZipUtilOptionText($p_options_list[$i]) . "'");
    15931586
    15941587            // ----- Return
     
    15961589          }
    15971590          $i++;
    1598         break;
     1591          break;
    15991592
    16001593        // ----- Look for options that takes a string
     
    16031596        case PCLZIP_OPT_PREPEND_COMMENT :
    16041597          // ----- Check the number of parameters
    1605           if (($i+1) >= $p_size) {
     1598          if (($i + 1) >= $p_size) {
    16061599            // ----- Error log
    16071600            PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE,
    1608                                              "Missing parameter value for option '"
    1609                                                                  .PclZipUtilOptionText($p_options_list[$i])
    1610                                                                  ."'");
     1601                "Missing parameter value for option '"
     1602                . PclZipUtilOptionText($p_options_list[$i])
     1603                . "'");
    16111604
    16121605            // ----- Return
     
    16151608
    16161609          // ----- Get the value
    1617           if (is_string($p_options_list[$i+1])) {
    1618               $v_result_list[$p_options_list[$i]] = $p_options_list[$i+1];
    1619           }
    1620           else {
     1610          if (is_string($p_options_list[$i + 1])) {
     1611            $v_result_list[$p_options_list[$i]] = $p_options_list[$i + 1];
     1612          } else {
    16211613            // ----- Error log
    16221614            PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE,
    1623                                              "Wrong parameter value for option '"
    1624                                                                  .PclZipUtilOptionText($p_options_list[$i])
    1625                                                                  ."'");
     1615                "Wrong parameter value for option '"
     1616                . PclZipUtilOptionText($p_options_list[$i])
     1617                . "'");
    16261618
    16271619            // ----- Return
     
    16291621          }
    16301622          $i++;
    1631         break;
     1623          break;
    16321624
    16331625        // ----- Look for options that request an array of index
    16341626        case PCLZIP_OPT_BY_INDEX :
    16351627          // ----- Check the number of parameters
    1636           if (($i+1) >= $p_size) {
     1628          if (($i + 1) >= $p_size) {
    16371629            // ----- Error log
    1638             PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE, "Missing parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
     1630            PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE,
     1631                "Missing parameter value for option '" . PclZipUtilOptionText($p_options_list[$i]) . "'");
    16391632
    16401633            // ----- Return
     
    16441637          // ----- Get the value
    16451638          $v_work_list = array();
    1646           if (is_string($p_options_list[$i+1])) {
    1647 
    1648               // ----- Remove spaces
    1649               $p_options_list[$i+1] = strtr($p_options_list[$i+1], ' ', '');
    1650 
    1651               // ----- Parse items
    1652               $v_work_list = explode(",", $p_options_list[$i+1]);
    1653           }
    1654           else if (is_integer($p_options_list[$i+1])) {
    1655               $v_work_list[0] = $p_options_list[$i+1].'-'.$p_options_list[$i+1];
    1656           }
    1657           else if (is_array($p_options_list[$i+1])) {
    1658               $v_work_list = $p_options_list[$i+1];
    1659           }
    1660           else {
    1661             // ----- Error log
    1662             PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE, "Value must be integer, string or array for option '".PclZipUtilOptionText($p_options_list[$i])."'");
    1663 
    1664             // ----- Return
    1665             return PclZip::errorCode();
    1666           }
    1667          
     1639          if (is_string($p_options_list[$i + 1])) {
     1640
     1641            // ----- Remove spaces
     1642            $p_options_list[$i + 1] = strtr($p_options_list[$i + 1], ' ', '');
     1643
     1644            // ----- Parse items
     1645            $v_work_list = explode(",", $p_options_list[$i + 1]);
     1646          } else {
     1647            if (is_integer($p_options_list[$i + 1])) {
     1648              $v_work_list[0] = $p_options_list[$i + 1] . '-' . $p_options_list[$i + 1];
     1649            } else {
     1650              if (is_array($p_options_list[$i + 1])) {
     1651                $v_work_list = $p_options_list[$i + 1];
     1652              } else {
     1653                // ----- Error log
     1654                PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE,
     1655                    "Value must be integer, string or array for option '" . PclZipUtilOptionText($p_options_list[$i]) . "'");
     1656
     1657                // ----- Return
     1658                return PclZip::errorCode();
     1659              }
     1660            }
     1661          }
     1662
    16681663          // ----- Reduce the index list
    16691664          // each index item in the list must be a couple with a start and
    16701665          // an end value : [0,3], [5-5], [8-10], ...
    16711666          // ----- Check the format of each item
    1672           $v_sort_flag=false;
    1673           $v_sort_value=0;
    1674           for ($j=0; $j<sizeof($v_work_list); $j++) {
    1675               // ----- Explode the item
    1676               $v_item_list = explode("-", $v_work_list[$j]);
    1677               $v_size_item_list = sizeof($v_item_list);
    1678              
    1679               // ----- TBC : Here we might check that each item is a
    1680               // real integer ...
    1681              
    1682               // ----- Look for single value
    1683               if ($v_size_item_list == 1) {
    1684                   // ----- Set the option value
    1685                   $v_result_list[$p_options_list[$i]][$j]['start'] = $v_item_list[0];
    1686                   $v_result_list[$p_options_list[$i]][$j]['end'] = $v_item_list[0];
    1687               }
    1688               elseif ($v_size_item_list == 2) {
    1689                   // ----- Set the option value
    1690                   $v_result_list[$p_options_list[$i]][$j]['start'] = $v_item_list[0];
    1691                   $v_result_list[$p_options_list[$i]][$j]['end'] = $v_item_list[1];
    1692               }
    1693               else {
    1694                   // ----- Error log
    1695                   PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE, "Too many values in index range for option '".PclZipUtilOptionText($p_options_list[$i])."'");
    1696 
    1697                   // ----- Return
    1698                   return PclZip::errorCode();
    1699               }
    1700 
    1701 
    1702               // ----- Look for list sort
    1703               if ($v_result_list[$p_options_list[$i]][$j]['start'] < $v_sort_value) {
    1704                   $v_sort_flag=true;
    1705 
    1706                   // ----- TBC : An automatic sort should be writen ...
    1707                   // ----- Error log
    1708                   PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE, "Invalid order of index range for option '".PclZipUtilOptionText($p_options_list[$i])."'");
    1709 
    1710                   // ----- Return
    1711                   return PclZip::errorCode();
    1712               }
    1713               $v_sort_value = $v_result_list[$p_options_list[$i]][$j]['start'];
    1714           }
    1715          
     1667          $v_sort_flag = false;
     1668          $v_sort_value = 0;
     1669          for ($j = 0; $j < sizeof($v_work_list); $j++) {
     1670            // ----- Explode the item
     1671            $v_item_list = explode("-", $v_work_list[$j]);
     1672            $v_size_item_list = sizeof($v_item_list);
     1673
     1674            // ----- TBC : Here we might check that each item is a
     1675            // real integer ...
     1676
     1677            // ----- Look for single value
     1678            if ($v_size_item_list == 1) {
     1679              // ----- Set the option value
     1680              $v_result_list[$p_options_list[$i]][$j]['start'] = $v_item_list[0];
     1681              $v_result_list[$p_options_list[$i]][$j]['end'] = $v_item_list[0];
     1682            } elseif ($v_size_item_list == 2) {
     1683              // ----- Set the option value
     1684              $v_result_list[$p_options_list[$i]][$j]['start'] = $v_item_list[0];
     1685              $v_result_list[$p_options_list[$i]][$j]['end'] = $v_item_list[1];
     1686            } else {
     1687              // ----- Error log
     1688              PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE,
     1689                  "Too many values in index range for option '" . PclZipUtilOptionText($p_options_list[$i]) . "'");
     1690
     1691              // ----- Return
     1692              return PclZip::errorCode();
     1693            }
     1694
     1695
     1696            // ----- Look for list sort
     1697            if ($v_result_list[$p_options_list[$i]][$j]['start'] < $v_sort_value) {
     1698              $v_sort_flag = true;
     1699
     1700              // ----- TBC : An automatic sort should be writen ...
     1701              // ----- Error log
     1702              PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE,
     1703                  "Invalid order of index range for option '" . PclZipUtilOptionText($p_options_list[$i]) . "'");
     1704
     1705              // ----- Return
     1706              return PclZip::errorCode();
     1707            }
     1708            $v_sort_value = $v_result_list[$p_options_list[$i]][$j]['start'];
     1709          }
     1710
    17161711          // ----- Sort the items
    17171712          if ($v_sort_flag) {
    1718               // TBC : To Be Completed
     1713            // TBC : To Be Completed
    17191714          }
    17201715
    17211716          // ----- Next option
    17221717          $i++;
    1723         break;
     1718          break;
    17241719
    17251720        // ----- Look for options that request no value
     
    17311726        case PCLZIP_OPT_STOP_ON_ERROR :
    17321727          $v_result_list[$p_options_list[$i]] = true;
    1733         break;
     1728          break;
    17341729
    17351730        // ----- Look for options that request an octal value
    17361731        case PCLZIP_OPT_SET_CHMOD :
    17371732          // ----- Check the number of parameters
    1738           if (($i+1) >= $p_size) {
     1733          if (($i + 1) >= $p_size) {
    17391734            // ----- Error log
    1740             PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE, "Missing parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
     1735            PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE,
     1736                "Missing parameter value for option '" . PclZipUtilOptionText($p_options_list[$i]) . "'");
    17411737
    17421738            // ----- Return
     
    17451741
    17461742          // ----- Get the value
    1747           $v_result_list[$p_options_list[$i]] = $p_options_list[$i+1];
     1743          $v_result_list[$p_options_list[$i]] = $p_options_list[$i + 1];
    17481744          $i++;
    1749         break;
     1745          break;
    17501746
    17511747        // ----- Look for options that request a call-back
     
    17541750        case PCLZIP_CB_PRE_ADD :
    17551751        case PCLZIP_CB_POST_ADD :
    1756         /* for futur use
    1757         case PCLZIP_CB_PRE_DELETE :
    1758         case PCLZIP_CB_POST_DELETE :
    1759         case PCLZIP_CB_PRE_LIST :
    1760         case PCLZIP_CB_POST_LIST :
    1761         */
     1752          /* for futur use
     1753                                case PCLZIP_CB_PRE_DELETE :
     1754                                case PCLZIP_CB_POST_DELETE :
     1755                                case PCLZIP_CB_PRE_LIST :
     1756                                case PCLZIP_CB_POST_LIST :
     1757                                */
    17621758          // ----- Check the number of parameters
    1763           if (($i+1) >= $p_size) {
     1759          if (($i + 1) >= $p_size) {
    17641760            // ----- Error log
    1765             PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE, "Missing parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
     1761            PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE,
     1762                "Missing parameter value for option '" . PclZipUtilOptionText($p_options_list[$i]) . "'");
    17661763
    17671764            // ----- Return
     
    17701767
    17711768          // ----- Get the value
    1772           $v_function_name = $p_options_list[$i+1];
     1769          $v_function_name = $p_options_list[$i + 1];
    17731770
    17741771          // ----- Check that the value is a valid existing function
    17751772          if (!function_exists($v_function_name)) {
    17761773            // ----- Error log
    1777             PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE, "Function '".$v_function_name."()' is not an existing function for option '".PclZipUtilOptionText($p_options_list[$i])."'");
     1774            PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE,
     1775                "Function '" . $v_function_name . "()' is not an existing function for option '" . PclZipUtilOptionText($p_options_list[$i]) . "'");
    17781776
    17791777            // ----- Return
     
    17841782          $v_result_list[$p_options_list[$i]] = $v_function_name;
    17851783          $i++;
    1786         break;
     1784          break;
    17871785
    17881786        default :
    17891787          // ----- Error log
    17901788          PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER,
    1791                                        "Unknown parameter '"
    1792                                                            .$p_options_list[$i]."'");
     1789              "Unknown parameter '"
     1790              . $p_options_list[$i] . "'");
    17931791
    17941792          // ----- Return
     
    18021800    // ----- Look for mandatory options
    18031801    if ($v_requested_options !== false) {
    1804       for ($key=reset($v_requested_options); $key=key($v_requested_options); $key=next($v_requested_options)) {
     1802      for ($key = reset($v_requested_options); $key = key($v_requested_options); $key = next($v_requested_options)) {
    18051803        // ----- Look for mandatory option
    18061804        if ($v_requested_options[$key] == 'mandatory') {
     
    18081806          if (!isset($v_result_list[$key])) {
    18091807            // ----- Error log
    1810             PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Missing mandatory parameter ".PclZipUtilOptionText($key)."(".$key.")");
     1808            PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER,
     1809                "Missing mandatory parameter " . PclZipUtilOptionText($key) . "(" . $key . ")");
    18111810
    18121811            // ----- Return
     
    18161815      }
    18171816    }
    1818    
     1817
    18191818    // ----- Look for default values
    18201819    if (!isset($v_result_list[PCLZIP_OPT_TEMP_FILE_THRESHOLD])) {
    1821      
     1820
    18221821    }
    18231822
     
    18331832  // Return Values :
    18341833  // --------------------------------------------------------------------------------
    1835   function privOptionDefaultThreshold(&$p_options)
    1836   {
    1837     $v_result=1;
    1838    
     1834  public function privOptionDefaultThreshold(&$p_options) {
     1835    $v_result = 1;
     1836
    18391837    if (isset($p_options[PCLZIP_OPT_TEMP_FILE_THRESHOLD])
    1840         || isset($p_options[PCLZIP_OPT_TEMP_FILE_OFF])) {
     1838        || isset($p_options[PCLZIP_OPT_TEMP_FILE_OFF])
     1839    ) {
    18411840      return $v_result;
    18421841    }
    1843    
     1842
    18441843    // ----- Get 'memory_limit' configuration value
    18451844    $v_memory_limit = ini_get('memory_limit');
    18461845    $v_memory_limit = trim($v_memory_limit);
    18471846    $last = strtolower(substr($v_memory_limit, -1));
    1848  
    1849     if($last == 'g')
    1850         //$v_memory_limit = $v_memory_limit*1024*1024*1024;
    1851         $v_memory_limit = $v_memory_limit*1073741824;
    1852     if($last == 'm')
    1853         //$v_memory_limit = $v_memory_limit*1024*1024;
    1854         $v_memory_limit = $v_memory_limit*1048576;
    1855     if($last == 'k')
    1856         $v_memory_limit = $v_memory_limit*1024;
    1857            
    1858     $p_options[PCLZIP_OPT_TEMP_FILE_THRESHOLD] = floor($v_memory_limit*PCLZIP_TEMPORARY_FILE_RATIO);
    1859    
     1847    $v_memory_limit = strtolower(substr($v_memory_limit, 0, -1));
     1848
     1849    if ($last == 'g') //$v_memory_limit = $v_memory_limit*1024*1024*1024;
     1850    {
     1851      $v_memory_limit = $v_memory_limit * 1073741824;
     1852    }
     1853    if ($last == 'm') //$v_memory_limit = $v_memory_limit*1024*1024;
     1854    {
     1855      $v_memory_limit = $v_memory_limit * 1048576;
     1856    }
     1857    if ($last == 'k') {
     1858      $v_memory_limit = $v_memory_limit * 1024;
     1859    }
     1860
     1861    $p_options[PCLZIP_OPT_TEMP_FILE_THRESHOLD] = floor($v_memory_limit * PCLZIP_TEMPORARY_FILE_RATIO);
     1862
    18601863
    18611864    // ----- Sanity check : No threshold if value lower than 1M
     
    18631866      unset($p_options[PCLZIP_OPT_TEMP_FILE_THRESHOLD]);
    18641867    }
    1865          
     1868
    18661869    // ----- Return
    18671870    return $v_result;
     
    18771880  //   0 on failure.
    18781881  // --------------------------------------------------------------------------------
    1879   function privFileDescrParseAtt(&$p_file_list, &$p_filedescr, $v_options, $v_requested_options=false)
    1880   {
    1881     $v_result=1;
    1882    
     1882  public function privFileDescrParseAtt(&$p_file_list, &$p_filedescr, $v_options, $v_requested_options = false) {
     1883    $v_result = 1;
     1884
    18831885    // ----- For each file in the list check the attributes
    18841886    foreach ($p_file_list as $v_key => $v_value) {
    1885    
     1887
    18861888      // ----- Check if the option is supported
    18871889      if (!isset($v_requested_options[$v_key])) {
    18881890        // ----- Error log
    1889         PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid file attribute '".$v_key."' for this file");
     1891        PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid file attribute '" . $v_key . "' for this file");
    18901892
    18911893        // ----- Return
     
    18971899        case PCLZIP_ATT_FILE_NAME :
    18981900          if (!is_string($v_value)) {
    1899             PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE, "Invalid type ".gettype($v_value).". String expected for attribute '".PclZipUtilOptionText($v_key)."'");
     1901            PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE,
     1902                "Invalid type " . gettype($v_value) . ". String expected for attribute '" . PclZipUtilOptionText($v_key) . "'");
     1903
    19001904            return PclZip::errorCode();
    19011905          }
    19021906
    19031907          $p_filedescr['filename'] = PclZipUtilPathReduction($v_value);
    1904          
     1908
    19051909          if ($p_filedescr['filename'] == '') {
    1906             PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE, "Invalid empty filename for attribute '".PclZipUtilOptionText($v_key)."'");
     1910            PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE,
     1911                "Invalid empty filename for attribute '" . PclZipUtilOptionText($v_key) . "'");
     1912
    19071913            return PclZip::errorCode();
    19081914          }
    19091915
    1910         break;
     1916          break;
    19111917
    19121918        case PCLZIP_ATT_FILE_NEW_SHORT_NAME :
    19131919          if (!is_string($v_value)) {
    1914             PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE, "Invalid type ".gettype($v_value).". String expected for attribute '".PclZipUtilOptionText($v_key)."'");
     1920            PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE,
     1921                "Invalid type " . gettype($v_value) . ". String expected for attribute '" . PclZipUtilOptionText($v_key) . "'");
     1922
    19151923            return PclZip::errorCode();
    19161924          }
     
    19191927
    19201928          if ($p_filedescr['new_short_name'] == '') {
    1921             PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE, "Invalid empty short filename for attribute '".PclZipUtilOptionText($v_key)."'");
     1929            PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE,
     1930                "Invalid empty short filename for attribute '" . PclZipUtilOptionText($v_key) . "'");
     1931
    19221932            return PclZip::errorCode();
    19231933          }
    1924         break;
     1934          break;
    19251935
    19261936        case PCLZIP_ATT_FILE_NEW_FULL_NAME :
    19271937          if (!is_string($v_value)) {
    1928             PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE, "Invalid type ".gettype($v_value).". String expected for attribute '".PclZipUtilOptionText($v_key)."'");
     1938            PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE,
     1939                "Invalid type " . gettype($v_value) . ". String expected for attribute '" . PclZipUtilOptionText($v_key) . "'");
     1940
    19291941            return PclZip::errorCode();
    19301942          }
     
    19331945
    19341946          if ($p_filedescr['new_full_name'] == '') {
    1935             PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE, "Invalid empty full filename for attribute '".PclZipUtilOptionText($v_key)."'");
     1947            PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE,
     1948                "Invalid empty full filename for attribute '" . PclZipUtilOptionText($v_key) . "'");
     1949
    19361950            return PclZip::errorCode();
    19371951          }
    1938         break;
     1952          break;
    19391953
    19401954        // ----- Look for options that takes a string
    19411955        case PCLZIP_ATT_FILE_COMMENT :
    19421956          if (!is_string($v_value)) {
    1943             PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE, "Invalid type ".gettype($v_value).". String expected for attribute '".PclZipUtilOptionText($v_key)."'");
     1957            PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE,
     1958                "Invalid type " . gettype($v_value) . ". String expected for attribute '" . PclZipUtilOptionText($v_key) . "'");
     1959
    19441960            return PclZip::errorCode();
    19451961          }
    19461962
    19471963          $p_filedescr['comment'] = $v_value;
    1948         break;
     1964          break;
    19491965
    19501966        case PCLZIP_ATT_FILE_MTIME :
    19511967          if (!is_integer($v_value)) {
    1952             PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE, "Invalid type ".gettype($v_value).". Integer expected for attribute '".PclZipUtilOptionText($v_key)."'");
     1968            PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE,
     1969                "Invalid type " . gettype($v_value) . ". Integer expected for attribute '" . PclZipUtilOptionText($v_key) . "'");
     1970
    19531971            return PclZip::errorCode();
    19541972          }
    19551973
    19561974          $p_filedescr['mtime'] = $v_value;
    1957         break;
     1975          break;
    19581976
    19591977        case PCLZIP_ATT_FILE_CONTENT :
    19601978          $p_filedescr['content'] = $v_value;
    1961         break;
     1979          break;
    19621980
    19631981        default :
    19641982          // ----- Error log
    19651983          PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER,
    1966                                            "Unknown parameter '".$v_key."'");
     1984              "Unknown parameter '" . $v_key . "'");
    19671985
    19681986          // ----- Return
     
    19721990      // ----- Look for mandatory options
    19731991      if ($v_requested_options !== false) {
    1974         for ($key=reset($v_requested_options); $key=key($v_requested_options); $key=next($v_requested_options)) {
     1992        for ($key = reset($v_requested_options); $key = key($v_requested_options); $key = next($v_requested_options)) {
    19751993          // ----- Look for mandatory option
    19761994          if ($v_requested_options[$key] == 'mandatory') {
    19771995            // ----- Look if present
    19781996            if (!isset($p_file_list[$key])) {
    1979               PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Missing mandatory parameter ".PclZipUtilOptionText($key)."(".$key.")");
     1997              PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER,
     1998                  "Missing mandatory parameter " . PclZipUtilOptionText($key) . "(" . $key . ")");
     1999
    19802000              return PclZip::errorCode();
    19812001            }
     
    19832003        }
    19842004      }
    1985    
    1986     // end foreach
    1987     }
    1988    
     2005
     2006      // end foreach
     2007    }
     2008
    19892009    // ----- Return
    19902010    return $v_result;
     
    19992019  //   just ignore the item.
    20002020  //   Then prepare the information that will be stored for that file.
    2001   //   When its a folder, expand the folder with all the files that are in that 
     2021  //   When its a folder, expand the folder with all the files that are in that
    20022022  //   folder (recursively).
    20032023  // Parameters :
     
    20062026  //   0 on failure.
    20072027  // --------------------------------------------------------------------------------
    2008   function privFileDescrExpand(&$p_filedescr_list, &$p_options)
    2009   {
    2010     $v_result=1;
    2011    
     2028  public function privFileDescrExpand(&$p_filedescr_list, &$p_options) {
     2029    $v_result = 1;
     2030
    20122031    // ----- Create a result list
    20132032    $v_result_list = array();
    2014    
     2033
    20152034    // ----- Look each entry
    2016     for ($i=0; $i<sizeof($p_filedescr_list); $i++) {
    2017      
     2035    for ($i = 0; $i < sizeof($p_filedescr_list); $i++) {
     2036
    20182037      // ----- Get filedescr
    20192038      $v_descr = $p_filedescr_list[$i];
    2020      
     2039
    20212040      // ----- Reduce the filename
    20222041      $v_descr['filename'] = PclZipUtilTranslateWinPath($v_descr['filename'], false);
    20232042      $v_descr['filename'] = PclZipUtilPathReduction($v_descr['filename']);
    2024      
     2043
    20252044      // ----- Look for real file or folder
    20262045      if (file_exists($v_descr['filename'])) {
    20272046        if (@is_file($v_descr['filename'])) {
    20282047          $v_descr['type'] = 'file';
    2029         }
    2030         else if (@is_dir($v_descr['filename'])) {
    2031           $v_descr['type'] = 'folder';
    2032         }
    2033         else if (@is_link($v_descr['filename'])) {
    2034           // skip
    2035           continue;
    2036         }
     2048        } else {
     2049          if (@is_dir($v_descr['filename'])) {
     2050            $v_descr['type'] = 'folder';
     2051          } else {
     2052            if (@is_link($v_descr['filename'])) {
     2053              // skip
     2054              continue;
     2055            } else {
     2056              // skip
     2057              continue;
     2058            }
     2059          }
     2060        }
     2061      } // ----- Look for string added as file
     2062      else {
     2063        if (isset($v_descr['content'])) {
     2064          $v_descr['type'] = 'virtual_file';
     2065        } // ----- Missing file
    20372066        else {
    2038           // skip
    2039           continue;
    2040         }
    2041       }
    2042      
    2043       // ----- Look for string added as file
    2044       else if (isset($v_descr['content'])) {
    2045         $v_descr['type'] = 'virtual_file';
    2046       }
    2047      
    2048       // ----- Missing file
    2049       else {
    2050         // ----- Error log
    2051         PclZip::privErrorLog(PCLZIP_ERR_MISSING_FILE, "File '".$v_descr['filename']."' does not exist");
    2052 
    2053         // ----- Return
    2054         return PclZip::errorCode();
    2055       }
    2056      
     2067          // ----- Error log
     2068          PclZip::privErrorLog(PCLZIP_ERR_MISSING_FILE, "File '" . $v_descr['filename'] . "' does not exist");
     2069
     2070          // ----- Return
     2071          return PclZip::errorCode();
     2072        }
     2073      }
     2074
    20572075      // ----- Calculate the stored filename
    20582076      $this->privCalculateStoredFilename($v_descr, $p_options);
    2059      
     2077
    20602078      // ----- Add the descriptor in result list
    20612079      $v_result_list[sizeof($v_result_list)] = $v_descr;
    2062      
     2080
    20632081      // ----- Look for folder
    20642082      if ($v_descr['type'] == 'folder') {
     
    20662084        $v_dirlist_descr = array();
    20672085        $v_dirlist_nb = 0;
    2068         if ($v_folder_handler = @opendir($v_descr['filename'])) {
     2086        if ($v_folder_handler = opendir($v_descr['filename'])) {
    20692087          while (($v_item_handler = @readdir($v_folder_handler)) !== false) {
    20702088
    20712089            // ----- Skip '.' and '..'
    20722090            if (($v_item_handler == '.') || ($v_item_handler == '..')) {
    2073                 continue;
     2091              continue;
    20742092            }
    2075            
     2093
    20762094            // ----- Compose the full filename
    2077             $v_dirlist_descr[$v_dirlist_nb]['filename'] = $v_descr['filename'].'/'.$v_item_handler;
    2078            
     2095            $v_dirlist_descr[$v_dirlist_nb]['filename'] = $v_descr['filename'] . '/' . $v_item_handler;
     2096
    20792097            // ----- Look for different stored filename
    20802098            // Because the name of the folder was changed, the name of the
    20812099            // files/sub-folders also change
    20822100            if (($v_descr['stored_filename'] != $v_descr['filename'])
    2083                  && (!isset($p_options[PCLZIP_OPT_REMOVE_ALL_PATH]))) {
     2101                && (!isset($p_options[PCLZIP_OPT_REMOVE_ALL_PATH]))
     2102            ) {
    20842103              if ($v_descr['stored_filename'] != '') {
    2085                 $v_dirlist_descr[$v_dirlist_nb]['new_full_name'] = $v_descr['stored_filename'].'/'.$v_item_handler;
    2086               }
    2087               else {
     2104                $v_dirlist_descr[$v_dirlist_nb]['new_full_name'] = $v_descr['stored_filename'] . '/' . $v_item_handler;
     2105              } else {
    20882106                $v_dirlist_descr[$v_dirlist_nb]['new_full_name'] = $v_item_handler;
    20892107              }
    20902108            }
    2091      
     2109
    20922110            $v_dirlist_nb++;
    20932111          }
    2094          
     2112
    20952113          @closedir($v_folder_handler);
    2096         }
    2097         else {
     2114        } else {
    20982115          // TBC : unable to open folder in read mode
    20992116        }
    2100        
     2117
    21012118        // ----- Expand each element of the list
    21022119        if ($v_dirlist_nb != 0) {
     
    21052122            return $v_result;
    21062123          }
    2107          
     2124
    21082125          // ----- Concat the resulting list
    21092126          $v_result_list = array_merge($v_result_list, $v_dirlist_descr);
    2110         }
    2111         else {
    2112         }
    2113          
     2127        } else {
     2128        }
     2129
    21142130        // ----- Free local array
    21152131        unset($v_dirlist_descr);
    21162132      }
    21172133    }
    2118    
     2134
    21192135    // ----- Get the result list
    21202136    $p_filedescr_list = $v_result_list;
     
    21312147  // Return Values :
    21322148  // --------------------------------------------------------------------------------
    2133   function privCreate($p_filedescr_list, &$p_result_list, &$p_options)
    2134   {
    2135     $v_result=1;
     2149  public function privCreate($p_filedescr_list, &$p_result_list, &$p_options) {
     2150    $v_result = 1;
    21362151    $v_list_detail = array();
    2137    
     2152
    21382153    // ----- Magic quotes trick
    21392154    $this->privDisableMagicQuotes();
    21402155
    21412156    // ----- Open the file in write mode
    2142     if (($v_result = $this->privOpenFd('wb')) != 1)
    2143     {
     2157    if (($v_result = $this->privOpenFd('wb')) != 1) {
    21442158      // ----- Return
    21452159      return $v_result;
     
    21662180  // Return Values :
    21672181  // --------------------------------------------------------------------------------
    2168   function privAdd($p_filedescr_list, &$p_result_list, &$p_options)
    2169   {
    2170     $v_result=1;
     2182  public function privAdd($p_filedescr_list, &$p_result_list, &$p_options) {
     2183    $v_result = 1;
    21712184    $v_list_detail = array();
    21722185
    21732186    // ----- Look if the archive exists or is empty
    2174     if ((!is_file($this->zipname)) || (filesize($this->zipname) == 0))
    2175     {
     2187    if ((!is_file($this->zipname)) || (filesize($this->zipname) == 0)) {
    21762188
    21772189      // ----- Do a create
     
    21852197
    21862198    // ----- Open the zip file
    2187     if (($v_result=$this->privOpenFd('rb')) != 1)
    2188     {
     2199    if (($v_result = $this->privOpenFd('rb')) != 1) {
    21892200      // ----- Magic quotes trick
    21902201      $this->privSwapBackMagicQuotes();
     
    21962207    // ----- Read the central directory informations
    21972208    $v_central_dir = array();
    2198     if (($v_result = $this->privReadEndCentralDir($v_central_dir)) != 1)
    2199     {
     2209    if (($v_result = $this->privReadEndCentralDir($v_central_dir)) != 1) {
    22002210      $this->privCloseFd();
    22012211      $this->privSwapBackMagicQuotes();
     2212
    22022213      return $v_result;
    22032214    }
     
    22072218
    22082219    // ----- Creates a temporay file
    2209     $v_zip_temp_name = PCLZIP_TEMPORARY_DIR.uniqid('pclzip-').'.tmp';
     2220    $v_zip_temp_name = PCLZIP_TEMPORARY_DIR . uniqid('pclzip-') . '.tmp';
    22102221
    22112222    // ----- Open the temporary file in write mode
    2212     if (($v_zip_temp_fd = @fopen($v_zip_temp_name, 'wb')) == 0)
    2213     {
     2223    if (($v_zip_temp_fd = @fopen($v_zip_temp_name, 'wb')) == 0) {
    22142224      $this->privCloseFd();
    22152225      $this->privSwapBackMagicQuotes();
    22162226
    2217       PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, 'Unable to open temporary file \''.$v_zip_temp_name.'\' in binary write mode');
     2227      PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL,
     2228          'Unable to open temporary file \'' . $v_zip_temp_name . '\' in binary write mode');
    22182229
    22192230      // ----- Return
     
    22242235    // TBC : Here I should better append the file and go back to erase the central dir
    22252236    $v_size = $v_central_dir['offset'];
    2226     while ($v_size != 0)
    2227     {
     2237    while ($v_size != 0) {
    22282238      $v_read_size = ($v_size < PCLZIP_READ_BLOCK_SIZE ? $v_size : PCLZIP_READ_BLOCK_SIZE);
    22292239      $v_buffer = fread($this->zip_fd, $v_read_size);
     
    22412251    // ----- Add the files
    22422252    $v_header_list = array();
    2243     if (($v_result = $this->privAddFileList($p_filedescr_list, $v_header_list, $p_options)) != 1)
    2244     {
     2253    if (($v_result = $this->privAddFileList($p_filedescr_list, $v_header_list, $p_options)) != 1) {
    22452254      fclose($v_zip_temp_fd);
    22462255      $this->privCloseFd();
     
    22572266    // ----- Copy the block of file headers from the old archive
    22582267    $v_size = $v_central_dir['size'];
    2259     while ($v_size != 0)
    2260     {
     2268    while ($v_size != 0) {
    22612269      $v_read_size = ($v_size < PCLZIP_READ_BLOCK_SIZE ? $v_size : PCLZIP_READ_BLOCK_SIZE);
    22622270      $v_buffer = @fread($v_zip_temp_fd, $v_read_size);
     
    22662274
    22672275    // ----- Create the Central Dir files header
    2268     for ($i=0, $v_count=0; $i<sizeof($v_header_list); $i++)
    2269     {
     2276    for ($i = 0, $v_count = 0; $i < sizeof($v_header_list); $i++) {
    22702277      // ----- Create the file header
    22712278      if ($v_header_list[$i]['status'] == 'ok') {
     
    22922299    }
    22932300    if (isset($p_options[PCLZIP_OPT_ADD_COMMENT])) {
    2294       $v_comment = $v_comment.$p_options[PCLZIP_OPT_ADD_COMMENT];
     2301      $v_comment = $v_comment . $p_options[PCLZIP_OPT_ADD_COMMENT];
    22952302    }
    22962303    if (isset($p_options[PCLZIP_OPT_PREPEND_COMMENT])) {
    2297       $v_comment = $p_options[PCLZIP_OPT_PREPEND_COMMENT].$v_comment;
     2304      $v_comment = $p_options[PCLZIP_OPT_PREPEND_COMMENT] . $v_comment;
    22982305    }
    22992306
    23002307    // ----- Calculate the size of the central header
    2301     $v_size = @ftell($this->zip_fd)-$v_offset;
     2308    $v_size = @ftell($this->zip_fd) - $v_offset;
    23022309
    23032310    // ----- Create the central dir footer
    2304     if (($v_result = $this->privWriteCentralHeader($v_count+$v_central_dir['entries'], $v_size, $v_offset, $v_comment)) != 1)
    2305     {
     2311    if (($v_result = $this->privWriteCentralHeader($v_count + $v_central_dir['entries'], $v_size, $v_offset,
     2312            $v_comment)) != 1
     2313    ) {
    23062314      // ----- Reset the file list
    23072315      unset($v_header_list);
     
    23452353  // Parameters :
    23462354  // --------------------------------------------------------------------------------
    2347   function privOpenFd($p_mode)
    2348   {
    2349     $v_result=1;
     2355  public function privOpenFd($p_mode) {
     2356    $v_result = 1;
    23502357
    23512358    // ----- Look if already open
    2352     if ($this->zip_fd != 0)
    2353     {
     2359    if ($this->zip_fd != 0) {
    23542360      // ----- Error log
    2355       PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, 'Zip file \''.$this->zipname.'\' already open');
     2361      PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, 'Zip file \'' . $this->zipname . '\' already open');
    23562362
    23572363      // ----- Return
     
    23602366
    23612367    // ----- Open the zip file
    2362     if (($this->zip_fd = @fopen($this->zipname, $p_mode)) == 0)
    2363     {
     2368    if (($this->zip_fd = @fopen($this->zipname, $p_mode)) == 0) {
    23642369      // ----- Error log
    2365       PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, 'Unable to open archive \''.$this->zipname.'\' in '.$p_mode.' mode');
     2370      PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL,
     2371          'Unable to open archive \'' . $this->zipname . '\' in ' . $p_mode . ' mode');
    23662372
    23672373      // ----- Return
     
    23792385  // Parameters :
    23802386  // --------------------------------------------------------------------------------
    2381   function privCloseFd()
    2382   {
    2383     $v_result=1;
    2384 
    2385     if ($this->zip_fd != 0)
     2387  public function privCloseFd() {
     2388    $v_result = 1;
     2389
     2390    if ($this->zip_fd != 0) {
    23862391      @fclose($this->zip_fd);
     2392    }
    23872393    $this->zip_fd = 0;
    23882394
     
    24062412  // --------------------------------------------------------------------------------
    24072413//  function privAddList($p_list, &$p_result_list, $p_add_dir, $p_remove_dir, $p_remove_all_dir, &$p_options)
    2408   function privAddList($p_filedescr_list, &$p_result_list, &$p_options)
    2409   {
    2410     $v_result=1;
     2414  public function privAddList($p_filedescr_list, &$p_result_list, &$p_options) {
     2415    $v_result = 1;
    24112416
    24122417    // ----- Add the files
    24132418    $v_header_list = array();
    2414     if (($v_result = $this->privAddFileList($p_filedescr_list, $v_header_list, $p_options)) != 1)
    2415     {
     2419    if (($v_result = $this->privAddFileList($p_filedescr_list, $v_header_list, $p_options)) != 1) {
    24162420      // ----- Return
    24172421      return $v_result;
     
    24222426
    24232427    // ----- Create the Central Dir files header
    2424     for ($i=0,$v_count=0; $i<sizeof($v_header_list); $i++)
    2425     {
     2428    for ($i = 0, $v_count = 0; $i < sizeof($v_header_list); $i++) {
    24262429      // ----- Create the file header
    24272430      if ($v_header_list[$i]['status'] == 'ok') {
     
    24442447
    24452448    // ----- Calculate the size of the central header
    2446     $v_size = @ftell($this->zip_fd)-$v_offset;
     2449    $v_size = @ftell($this->zip_fd) - $v_offset;
    24472450
    24482451    // ----- Create the central dir footer
    2449     if (($v_result = $this->privWriteCentralHeader($v_count, $v_size, $v_offset, $v_comment)) != 1)
    2450     {
     2452    if (($v_result = $this->privWriteCentralHeader($v_count, $v_size, $v_offset, $v_comment)) != 1) {
    24512453      // ----- Reset the file list
    24522454      unset($v_header_list);
     
    24652467  // Description :
    24662468  // Parameters :
    2467   //   $p_filedescr_list : An array containing the file description 
     2469  //   $p_filedescr_list : An array containing the file description
    24682470  //                      or directory names to add in the zip
    24692471  //   $p_result_list : list of added files with their properties (specially the status field)
    24702472  // Return Values :
    24712473  // --------------------------------------------------------------------------------
    2472   function privAddFileList($p_filedescr_list, &$p_result_list, &$p_options)
    2473   {
    2474     $v_result=1;
     2474  public function privAddFileList($p_filedescr_list, &$p_result_list, &$p_options) {
     2475    $v_result = 1;
    24752476    $v_header = array();
    24762477
     
    24792480
    24802481    // ----- Loop on the files
    2481     for ($j=0; ($j<sizeof($p_filedescr_list)) && ($v_result==1); $j++) {
     2482    for ($j = 0; ($j < sizeof($p_filedescr_list)) && ($v_result == 1); $j++) {
    24822483      // ----- Format the filename
    24832484      $p_filedescr_list[$j]['filename']
    2484       = PclZipUtilTranslateWinPath($p_filedescr_list[$j]['filename'], false);
    2485      
     2485          = PclZipUtilTranslateWinPath($p_filedescr_list[$j]['filename'], false);
     2486
    24862487
    24872488      // ----- Skip empty file names
     
    24922493
    24932494      // ----- Check the filename
    2494       if (   ($p_filedescr_list[$j]['type'] != 'virtual_file')
    2495           && (!file_exists($p_filedescr_list[$j]['filename']))) {
    2496         PclZip::privErrorLog(PCLZIP_ERR_MISSING_FILE, "File '".$p_filedescr_list[$j]['filename']."' does not exist");
     2495      if (($p_filedescr_list[$j]['type'] != 'virtual_file')
     2496          && (!file_exists($p_filedescr_list[$j]['filename']))
     2497      ) {
     2498        PclZip::privErrorLog(PCLZIP_ERR_MISSING_FILE,
     2499            "File '" . $p_filedescr_list[$j]['filename'] . "' does not exist");
     2500
    24972501        return PclZip::errorCode();
    24982502      }
     
    25022506//      if (   (is_file($p_filedescr_list[$j]['filename']))
    25032507//          || (   is_dir($p_filedescr_list[$j]['filename'])
    2504       if (   ($p_filedescr_list[$j]['type'] == 'file')
     2508      if (($p_filedescr_list[$j]['type'] == 'file')
    25052509          || ($p_filedescr_list[$j]['type'] == 'virtual_file')
    2506           || (   ($p_filedescr_list[$j]['type'] == 'folder')
    2507               && (   !isset($p_options[PCLZIP_OPT_REMOVE_ALL_PATH])
     2510          || (($p_filedescr_list[$j]['type'] == 'folder')
     2511              && (!isset($p_options[PCLZIP_OPT_REMOVE_ALL_PATH])
    25082512                  || !$p_options[PCLZIP_OPT_REMOVE_ALL_PATH]))
    2509           ) {
     2513      ) {
    25102514
    25112515        // ----- Add the file
    25122516        $v_result = $this->privAddFile($p_filedescr_list[$j], $v_header,
    2513                                        $p_options);
     2517            $p_options);
    25142518        if ($v_result != 1) {
    25152519          return $v_result;
     
    25322536  // Return Values :
    25332537  // --------------------------------------------------------------------------------
    2534   function privAddFile($p_filedescr, &$p_header, &$p_options)
    2535   {
    2536     $v_result=1;
    2537    
     2538  public function privAddFile($p_filedescr, &$p_header, &$p_options) {
     2539    $v_result = 1;
     2540
    25382541    // ----- Working variable
    25392542    $p_filename = $p_filedescr['filename'];
     
    25472550      return PclZip::errorCode();
    25482551    }
    2549  
    2550     // ----- Look for a stored different filename 
     2552
     2553    // ----- Look for a stored different filename
    25512554    /* TBC : Removed
    25522555    if (isset($p_filedescr['stored_filename'])) {
     
    25792582
    25802583    // ----- Look for regular file
    2581     if ($p_filedescr['type']=='file') {
     2584    if ($p_filedescr['type'] == 'file') {
    25822585      $p_header['external'] = 0x00000000;
    25832586      $p_header['size'] = filesize($p_filename);
    2584     }
    2585    
    2586     // ----- Look for regular folder
    2587     else if ($p_filedescr['type']=='folder') {
    2588       $p_header['external'] = 0x00000010;
    2589       $p_header['mtime'] = filemtime($p_filename);
    2590       $p_header['size'] = filesize($p_filename);
    2591     }
    2592    
    2593     // ----- Look for virtual file
    2594     else if ($p_filedescr['type'] == 'virtual_file') {
    2595       $p_header['external'] = 0x00000000;
    2596       $p_header['size'] = strlen($p_filedescr['content']);
    2597     }
    2598    
     2587    } // ----- Look for regular folder
     2588    else {
     2589      if ($p_filedescr['type'] == 'folder') {
     2590        $p_header['external'] = 0x00000010;
     2591        $p_header['mtime'] = filemtime($p_filename);
     2592        $p_header['size'] = filesize($p_filename);
     2593      } // ----- Look for virtual file
     2594      else {
     2595        if ($p_filedescr['type'] == 'virtual_file') {
     2596          $p_header['external'] = 0x00000000;
     2597          $p_header['size'] = strlen($p_filedescr['content']);
     2598        }
     2599      }
     2600    }
     2601
    25992602
    26002603    // ----- Look for filetime
    26012604    if (isset($p_filedescr['mtime'])) {
    26022605      $p_header['mtime'] = $p_filedescr['mtime'];
    2603     }
    2604     else if ($p_filedescr['type'] == 'virtual_file') {
    2605       $p_header['mtime'] = time();
    2606     }
    2607     else {
    2608       $p_header['mtime'] = filemtime($p_filename);
     2606    } else {
     2607      if ($p_filedescr['type'] == 'virtual_file') {
     2608        $p_header['mtime'] = time();
     2609      } else {
     2610        $p_header['mtime'] = filemtime($p_filename);
     2611      }
    26092612    }
    26102613
     
    26132616      $p_header['comment_len'] = strlen($p_filedescr['comment']);
    26142617      $p_header['comment'] = $p_filedescr['comment'];
    2615     }
    2616     else {
     2618    } else {
    26172619      $p_header['comment_len'] = 0;
    26182620      $p_header['comment'] = '';
     
    26482650      $p_header['status'] = "filtered";
    26492651    }
    2650    
     2652
    26512653    // ----- Check the path length
    26522654    if (strlen($p_header['stored_filename']) > 0xFF) {
     
    26602662      if ($p_filedescr['type'] == 'file') {
    26612663        // ----- Look for using temporary file to zip
    2662         if ( (!isset($p_options[PCLZIP_OPT_TEMP_FILE_OFF]))
     2664        if ((!isset($p_options[PCLZIP_OPT_TEMP_FILE_OFF]))
    26632665            && (isset($p_options[PCLZIP_OPT_TEMP_FILE_ON])
    26642666                || (isset($p_options[PCLZIP_OPT_TEMP_FILE_THRESHOLD])
    2665                     && ($p_options[PCLZIP_OPT_TEMP_FILE_THRESHOLD] <= $p_header['size'])) ) ) {
     2667                    && ($p_options[PCLZIP_OPT_TEMP_FILE_THRESHOLD] <= $p_header['size'])))
     2668        ) {
    26662669          $v_result = $this->privAddFileUsingTempFile($p_filedescr, $p_header, $p_options);
    26672670          if ($v_result < PCLZIP_ERR_NO_ERROR) {
    26682671            return $v_result;
    26692672          }
    2670         }
    2671        
    2672         // ----- Use "in memory" zip algo
     2673        } // ----- Use "in memory" zip algo
    26732674        else {
    26742675
    2675         // ----- Open the source file
    2676         if (($v_file = @fopen($p_filename, "rb")) == 0) {
    2677           PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, "Unable to open file '$p_filename' in binary read mode");
    2678           return PclZip::errorCode();
    2679         }
    2680 
    2681         // ----- Read the file content
    2682         $v_content = @fread($v_file, $p_header['size']);
    2683 
    2684         // ----- Close the file
    2685         @fclose($v_file);
    2686 
    2687         // ----- Calculate the CRC
    2688         $p_header['crc'] = @crc32($v_content);
    2689        
    2690         // ----- Look for no compression
    2691         if ($p_options[PCLZIP_OPT_NO_COMPRESSION]) {
    2692           // ----- Set header parameters
    2693           $p_header['compressed_size'] = $p_header['size'];
    2694           $p_header['compression'] = 0;
    2695         }
    2696        
    2697         // ----- Look for normal compression
     2676          // ----- Open the source file
     2677          if (($v_file = @fopen($p_filename, "rb")) == 0) {
     2678            PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, "Unable to open file '$p_filename' in binary read mode");
     2679
     2680            return PclZip::errorCode();
     2681          }
     2682
     2683          // ----- Read the file content
     2684          $v_content = @fread($v_file, $p_header['size']);
     2685
     2686          // ----- Close the file
     2687          @fclose($v_file);
     2688
     2689          // ----- Calculate the CRC
     2690          $p_header['crc'] = @crc32($v_content);
     2691
     2692          // ----- Look for no compression
     2693          if ($p_options[PCLZIP_OPT_NO_COMPRESSION]) {
     2694            // ----- Set header parameters
     2695            $p_header['compressed_size'] = $p_header['size'];
     2696            $p_header['compression'] = 0;
     2697          } // ----- Look for normal compression
     2698          else {
     2699            // ----- Compress the content
     2700            $v_content = @gzdeflate($v_content);
     2701
     2702            // ----- Set header parameters
     2703            $p_header['compressed_size'] = strlen($v_content);
     2704            $p_header['compression'] = 8;
     2705          }
     2706
     2707          // ----- Call the header generation
     2708          if (($v_result = $this->privWriteFileHeader($p_header)) != 1) {
     2709            @fclose($v_file);
     2710
     2711            return $v_result;
     2712          }
     2713
     2714          // ----- Write the compressed (or not) content
     2715          @fwrite($this->zip_fd, $v_content, $p_header['compressed_size']);
     2716
     2717        }
     2718
     2719      } // ----- Look for a virtual file (a file from string)
     2720      else {
     2721        if ($p_filedescr['type'] == 'virtual_file') {
     2722
     2723          $v_content = $p_filedescr['content'];
     2724
     2725          // ----- Calculate the CRC
     2726          $p_header['crc'] = @crc32($v_content);
     2727
     2728          // ----- Look for no compression
     2729          if ($p_options[PCLZIP_OPT_NO_COMPRESSION]) {
     2730            // ----- Set header parameters
     2731            $p_header['compressed_size'] = $p_header['size'];
     2732            $p_header['compression'] = 0;
     2733          } // ----- Look for normal compression
     2734          else {
     2735            // ----- Compress the content
     2736            $v_content = @gzdeflate($v_content);
     2737
     2738            // ----- Set header parameters
     2739            $p_header['compressed_size'] = strlen($v_content);
     2740            $p_header['compression'] = 8;
     2741          }
     2742
     2743          // ----- Call the header generation
     2744          if (($v_result = $this->privWriteFileHeader($p_header)) != 1) {
     2745            @fclose($v_file);
     2746
     2747            return $v_result;
     2748          }
     2749
     2750          // ----- Write the compressed (or not) content
     2751          @fwrite($this->zip_fd, $v_content, $p_header['compressed_size']);
     2752        } // ----- Look for a directory
    26982753        else {
    2699           // ----- Compress the content
    2700           $v_content = @gzdeflate($v_content);
    2701 
    2702           // ----- Set header parameters
    2703           $p_header['compressed_size'] = strlen($v_content);
    2704           $p_header['compression'] = 8;
    2705         }
    2706        
    2707         // ----- Call the header generation
    2708         if (($v_result = $this->privWriteFileHeader($p_header)) != 1) {
    2709           @fclose($v_file);
    2710           return $v_result;
    2711         }
    2712 
    2713         // ----- Write the compressed (or not) content
    2714         @fwrite($this->zip_fd, $v_content, $p_header['compressed_size']);
    2715 
    2716         }
    2717 
    2718       }
    2719 
    2720       // ----- Look for a virtual file (a file from string)
    2721       else if ($p_filedescr['type'] == 'virtual_file') {
    2722          
    2723         $v_content = $p_filedescr['content'];
    2724 
    2725         // ----- Calculate the CRC
    2726         $p_header['crc'] = @crc32($v_content);
    2727        
    2728         // ----- Look for no compression
    2729         if ($p_options[PCLZIP_OPT_NO_COMPRESSION]) {
    2730           // ----- Set header parameters
    2731           $p_header['compressed_size'] = $p_header['size'];
    2732           $p_header['compression'] = 0;
    2733         }
    2734        
    2735         // ----- Look for normal compression
    2736         else {
    2737           // ----- Compress the content
    2738           $v_content = @gzdeflate($v_content);
    2739 
    2740           // ----- Set header parameters
    2741           $p_header['compressed_size'] = strlen($v_content);
    2742           $p_header['compression'] = 8;
    2743         }
    2744        
    2745         // ----- Call the header generation
    2746         if (($v_result = $this->privWriteFileHeader($p_header)) != 1) {
    2747           @fclose($v_file);
    2748           return $v_result;
    2749         }
    2750 
    2751         // ----- Write the compressed (or not) content
    2752         @fwrite($this->zip_fd, $v_content, $p_header['compressed_size']);
    2753       }
    2754 
    2755       // ----- Look for a directory
    2756       else if ($p_filedescr['type'] == 'folder') {
    2757         // ----- Look for directory last '/'
    2758         if (@substr($p_header['stored_filename'], -1) != '/') {
    2759           $p_header['stored_filename'] .= '/';
    2760         }
    2761 
    2762         // ----- Set the file properties
    2763         $p_header['size'] = 0;
    2764         //$p_header['external'] = 0x41FF0010;   // Value for a folder : to be checked
    2765         $p_header['external'] = 0x00000010;   // Value for a folder : to be checked
    2766 
    2767         // ----- Call the header generation
    2768         if (($v_result = $this->privWriteFileHeader($p_header)) != 1)
    2769         {
    2770           return $v_result;
     2754          if ($p_filedescr['type'] == 'folder') {
     2755            // ----- Look for directory last '/'
     2756            if (@substr($p_header['stored_filename'], -1) != '/') {
     2757              $p_header['stored_filename'] .= '/';
     2758            }
     2759
     2760            // ----- Set the file properties
     2761            $p_header['size'] = 0;
     2762            //$p_header['external'] = 0x41FF0010;   // Value for a folder : to be checked
     2763            $p_header['external'] = 0x00000010;   // Value for a folder : to be checked
     2764
     2765            // ----- Call the header generation
     2766            if (($v_result = $this->privWriteFileHeader($p_header)) != 1) {
     2767              return $v_result;
     2768            }
     2769          }
    27712770        }
    27722771      }
     
    28052804  // Return Values :
    28062805  // --------------------------------------------------------------------------------
    2807   function privAddFileUsingTempFile($p_filedescr, &$p_header, &$p_options)
    2808   {
    2809     $v_result=PCLZIP_ERR_NO_ERROR;
    2810    
     2806  public function privAddFileUsingTempFile($p_filedescr, &$p_header, &$p_options) {
     2807    $v_result = PCLZIP_ERR_NO_ERROR;
     2808
    28112809    // ----- Working variable
    28122810    $p_filename = $p_filedescr['filename'];
     
    28162814    if (($v_file = @fopen($p_filename, "rb")) == 0) {
    28172815      PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, "Unable to open file '$p_filename' in binary read mode");
     2816
    28182817      return PclZip::errorCode();
    28192818    }
    28202819
    28212820    // ----- Creates a compressed temporary file
    2822     $v_gzip_temp_name = PCLZIP_TEMPORARY_DIR.uniqid('pclzip-').'.gz';
     2821    $v_gzip_temp_name = PCLZIP_TEMPORARY_DIR . uniqid('pclzip-') . '.gz';
    28232822    if (($v_file_compressed = @gzopen($v_gzip_temp_name, "wb")) == 0) {
    28242823      fclose($v_file);
    2825       PclZip::privErrorLog(PCLZIP_ERR_WRITE_OPEN_FAIL, 'Unable to open temporary file \''.$v_gzip_temp_name.'\' in binary write mode');
     2824      PclZip::privErrorLog(PCLZIP_ERR_WRITE_OPEN_FAIL,
     2825          'Unable to open temporary file \'' . $v_gzip_temp_name . '\' in binary write mode');
     2826
    28262827      return PclZip::errorCode();
    28272828    }
     
    28432844    // ----- Check the minimum file size
    28442845    if (filesize($v_gzip_temp_name) < 18) {
    2845       PclZip::privErrorLog(PCLZIP_ERR_BAD_FORMAT, 'gzip temporary file \''.$v_gzip_temp_name.'\' has invalid filesize - should be minimum 18 bytes');
     2846      PclZip::privErrorLog(PCLZIP_ERR_BAD_FORMAT,
     2847          'gzip temporary file \'' . $v_gzip_temp_name . '\' has invalid filesize - should be minimum 18 bytes');
     2848
    28462849      return PclZip::errorCode();
    28472850    }
     
    28492852    // ----- Extract the compressed attributes
    28502853    if (($v_file_compressed = @fopen($v_gzip_temp_name, "rb")) == 0) {
    2851       PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, 'Unable to open temporary file \''.$v_gzip_temp_name.'\' in binary read mode');
     2854      PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL,
     2855          'Unable to open temporary file \'' . $v_gzip_temp_name . '\' in binary read mode');
     2856
    28522857      return PclZip::errorCode();
    28532858    }
     
    28612866
    28622867    // ----- Read the gzip file footer
    2863     @fseek($v_file_compressed, filesize($v_gzip_temp_name)-8);
     2868    @fseek($v_file_compressed, filesize($v_gzip_temp_name) - 8);
    28642869    $v_binary_data = @fread($v_file_compressed, 8);
    28652870    $v_data_footer = unpack('Vcrc/Vcompressed_size', $v_binary_data);
     
    28692874    //$p_header['mtime'] = $v_data_header['mtime'];
    28702875    $p_header['crc'] = $v_data_footer['crc'];
    2871     $p_header['compressed_size'] = filesize($v_gzip_temp_name)-18;
     2876    $p_header['compressed_size'] = filesize($v_gzip_temp_name) - 18;
    28722877
    28732878    // ----- Close the file
     
    28802885
    28812886    // ----- Add the compressed data
    2882     if (($v_file_compressed = @fopen($v_gzip_temp_name, "rb")) == 0)
    2883     {
    2884       PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, 'Unable to open temporary file \''.$v_gzip_temp_name.'\' in binary read mode');
     2887    if (($v_file_compressed = @fopen($v_gzip_temp_name, "rb")) == 0) {
     2888      PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL,
     2889          'Unable to open temporary file \'' . $v_gzip_temp_name . '\' in binary read mode');
     2890
    28852891      return PclZip::errorCode();
    28862892    }
     
    28892895    fseek($v_file_compressed, 10);
    28902896    $v_size = $p_header['compressed_size'];
    2891     while ($v_size != 0)
    2892     {
     2897    while ($v_size != 0) {
    28932898      $v_read_size = ($v_size < PCLZIP_READ_BLOCK_SIZE ? $v_size : PCLZIP_READ_BLOCK_SIZE);
    28942899      $v_buffer = @fread($v_file_compressed, $v_read_size);
     
    29032908    // ----- Unlink the temporary file
    29042909    @unlink($v_gzip_temp_name);
    2905    
     2910
    29062911    // ----- Return
    29072912    return $v_result;
     
    29172922  // Return Values :
    29182923  // --------------------------------------------------------------------------------
    2919   function privCalculateStoredFilename(&$p_filedescr, &$p_options)
    2920   {
    2921     $v_result=1;
    2922    
     2924  public function privCalculateStoredFilename(&$p_filedescr, &$p_options) {
     2925    $v_result = 1;
     2926
    29232927    // ----- Working variables
    29242928    $p_filename = $p_filedescr['filename'];
    29252929    if (isset($p_options[PCLZIP_OPT_ADD_PATH])) {
    29262930      $p_add_dir = $p_options[PCLZIP_OPT_ADD_PATH];
    2927     }
    2928     else {
     2931    } else {
    29292932      $p_add_dir = '';
    29302933    }
    29312934    if (isset($p_options[PCLZIP_OPT_REMOVE_PATH])) {
    29322935      $p_remove_dir = $p_options[PCLZIP_OPT_REMOVE_PATH];
    2933     }
    2934     else {
     2936    } else {
    29352937      $p_remove_dir = '';
    29362938    }
    29372939    if (isset($p_options[PCLZIP_OPT_REMOVE_ALL_PATH])) {
    29382940      $p_remove_all_dir = $p_options[PCLZIP_OPT_REMOVE_ALL_PATH];
    2939     }
    2940     else {
     2941    } else {
    29412942      $p_remove_all_dir = 0;
    29422943    }
     
    29472948      // ----- Remove drive letter if any
    29482949      $v_stored_filename = PclZipUtilTranslateWinPath($p_filedescr['new_full_name']);
    2949     }
    2950    
    2951     // ----- Look for path and/or short name change
     2950    } // ----- Look for path and/or short name change
    29522951    else {
    29532952
     
    29582957        $v_dir = '';
    29592958        if ($v_path_info['dirname'] != '') {
    2960           $v_dir = $v_path_info['dirname'].'/';
    2961         }
    2962         $v_stored_filename = $v_dir.$p_filedescr['new_short_name'];
    2963       }
    2964       else {
     2959          $v_dir = $v_path_info['dirname'] . '/';
     2960        }
     2961        $v_stored_filename = $v_dir . $p_filedescr['new_short_name'];
     2962      } else {
    29652963        // ----- Calculate the stored filename
    29662964        $v_stored_filename = $p_filename;
     
    29702968      if ($p_remove_all_dir) {
    29712969        $v_stored_filename = basename($p_filename);
    2972       }
    2973       // ----- Look for partial path remove
    2974       else if ($p_remove_dir != "") {
    2975         if (substr($p_remove_dir, -1) != '/')
    2976           $p_remove_dir .= "/";
    2977 
    2978         if (   (substr($p_filename, 0, 2) == "./")
    2979             || (substr($p_remove_dir, 0, 2) == "./")) {
    2980            
    2981           if (   (substr($p_filename, 0, 2) == "./")
    2982               && (substr($p_remove_dir, 0, 2) != "./")) {
    2983             $p_remove_dir = "./".$p_remove_dir;
    2984           }
    2985           if (   (substr($p_filename, 0, 2) != "./")
    2986               && (substr($p_remove_dir, 0, 2) == "./")) {
    2987             $p_remove_dir = substr($p_remove_dir, 2);
    2988           }
    2989         }
    2990 
    2991         $v_compare = PclZipUtilPathInclusion($p_remove_dir,
    2992                                              $v_stored_filename);
    2993         if ($v_compare > 0) {
    2994           if ($v_compare == 2) {
    2995             $v_stored_filename = "";
    2996           }
    2997           else {
    2998             $v_stored_filename = substr($v_stored_filename,
    2999                                         strlen($p_remove_dir));
    3000           }
    3001         }
    3002       }
    3003      
     2970      } // ----- Look for partial path remove
     2971      else {
     2972        if ($p_remove_dir != "") {
     2973          if (substr($p_remove_dir, -1) != '/') {
     2974            $p_remove_dir .= "/";
     2975          }
     2976
     2977          if ((substr($p_filename, 0, 2) == "./")
     2978              || (substr($p_remove_dir, 0, 2) == "./")
     2979          ) {
     2980
     2981            if ((substr($p_filename, 0, 2) == "./")
     2982                && (substr($p_remove_dir, 0, 2) != "./")
     2983            ) {
     2984              $p_remove_dir = "./" . $p_remove_dir;
     2985            }
     2986            if ((substr($p_filename, 0, 2) != "./")
     2987                && (substr($p_remove_dir, 0, 2) == "./")
     2988            ) {
     2989              $p_remove_dir = substr($p_remove_dir, 2);
     2990            }
     2991          }
     2992
     2993          $v_compare = PclZipUtilPathInclusion($p_remove_dir,
     2994              $v_stored_filename);
     2995          if ($v_compare > 0) {
     2996            if ($v_compare == 2) {
     2997              $v_stored_filename = "";
     2998            } else {
     2999              $v_stored_filename = substr($v_stored_filename,
     3000                  strlen($p_remove_dir));
     3001            }
     3002          }
     3003        }
     3004      }
     3005
    30043006      // ----- Remove drive letter if any
    30053007      $v_stored_filename = PclZipUtilTranslateWinPath($v_stored_filename);
    3006      
     3008
    30073009      // ----- Look for path to add
    30083010      if ($p_add_dir != "") {
    3009         if (substr($p_add_dir, -1) == "/")
    3010           $v_stored_filename = $p_add_dir.$v_stored_filename;
    3011         else
    3012           $v_stored_filename = $p_add_dir."/".$v_stored_filename;
     3011        if (substr($p_add_dir, -1) == "/") {
     3012          $v_stored_filename = $p_add_dir . $v_stored_filename;
     3013        } else {
     3014          $v_stored_filename = $p_add_dir . "/" . $v_stored_filename;
     3015        }
    30133016      }
    30143017    }
     
    30173020    $v_stored_filename = PclZipUtilPathReduction($v_stored_filename);
    30183021    $p_filedescr['stored_filename'] = $v_stored_filename;
    3019    
     3022
    30203023    // ----- Return
    30213024    return $v_result;
     
    30293032  // Return Values :
    30303033  // --------------------------------------------------------------------------------
    3031   function privWriteFileHeader(&$p_header)
    3032   {
    3033     $v_result=1;
     3034  public function privWriteFileHeader(&$p_header) {
     3035    $v_result = 1;
    30343036
    30353037    // ----- Store the offset position of the file
     
    30383040    // ----- Transform UNIX mtime to DOS format mdate/mtime
    30393041    $v_date = getdate($p_header['mtime']);
    3040     $v_mtime = ($v_date['hours']<<11) + ($v_date['minutes']<<5) + $v_date['seconds']/2;
    3041     $v_mdate = (($v_date['year']-1980)<<9) + ($v_date['mon']<<5) + $v_date['mday'];
     3042    $v_mtime = ($v_date['hours'] << 11) + ($v_date['minutes'] << 5) + $v_date['seconds'] / 2;
     3043    $v_mdate = (($v_date['year'] - 1980) << 9) + ($v_date['mon'] << 5) + $v_date['mday'];
    30423044
    30433045    // ----- Packed data
    30443046    $v_binary_data = pack("VvvvvvVVVvv", 0x04034b50,
    3045                               $p_header['version_extracted'], $p_header['flag'],
    3046                           $p_header['compression'], $v_mtime, $v_mdate,
    3047                           $p_header['crc'], $p_header['compressed_size'],
    3048                                                   $p_header['size'],
    3049                           strlen($p_header['stored_filename']),
    3050                                                   $p_header['extra_len']);
     3047        $p_header['version_extracted'], $p_header['flag'],
     3048        $p_header['compression'], $v_mtime, $v_mdate,
     3049        $p_header['crc'], $p_header['compressed_size'],
     3050        $p_header['size'],
     3051        strlen($p_header['stored_filename']),
     3052        $p_header['extra_len']);
    30513053
    30523054    // ----- Write the first 148 bytes of the header in the archive
     
    30543056
    30553057    // ----- Write the variable fields
    3056     if (strlen($p_header['stored_filename']) != 0)
    3057     {
     3058    if (strlen($p_header['stored_filename']) != 0) {
    30583059      fputs($this->zip_fd, $p_header['stored_filename'], strlen($p_header['stored_filename']));
    30593060    }
    3060     if ($p_header['extra_len'] != 0)
    3061     {
     3061    if ($p_header['extra_len'] != 0) {
    30623062      fputs($this->zip_fd, $p_header['extra'], $p_header['extra_len']);
    30633063    }
     
    30743074  // Return Values :
    30753075  // --------------------------------------------------------------------------------
    3076   function privWriteCentralFileHeader(&$p_header)
    3077   {
    3078     $v_result=1;
     3076  public function privWriteCentralFileHeader(&$p_header) {
     3077    $v_result = 1;
    30793078
    30803079    // TBC
     
    30843083    // ----- Transform UNIX mtime to DOS format mdate/mtime
    30853084    $v_date = getdate($p_header['mtime']);
    3086     $v_mtime = ($v_date['hours']<<11) + ($v_date['minutes']<<5) + $v_date['seconds']/2;
    3087     $v_mdate = (($v_date['year']-1980)<<9) + ($v_date['mon']<<5) + $v_date['mday'];
     3085    $v_mtime = ($v_date['hours'] << 11) + ($v_date['minutes'] << 5) + $v_date['seconds'] / 2;
     3086    $v_mdate = (($v_date['year'] - 1980) << 9) + ($v_date['mon'] << 5) + $v_date['mday'];
    30883087
    30893088
    30903089    // ----- Packed data
    30913090    $v_binary_data = pack("VvvvvvvVVVvvvvvVV", 0x02014b50,
    3092                               $p_header['version'], $p_header['version_extracted'],
    3093                           $p_header['flag'], $p_header['compression'],
    3094                                                   $v_mtime, $v_mdate, $p_header['crc'],
    3095                           $p_header['compressed_size'], $p_header['size'],
    3096                           strlen($p_header['stored_filename']),
    3097                                                   $p_header['extra_len'], $p_header['comment_len'],
    3098                           $p_header['disk'], $p_header['internal'],
    3099                                                   $p_header['external'], $p_header['offset']);
     3091        $p_header['version'], $p_header['version_extracted'],
     3092        $p_header['flag'], $p_header['compression'],
     3093        $v_mtime, $v_mdate, $p_header['crc'],
     3094        $p_header['compressed_size'], $p_header['size'],
     3095        strlen($p_header['stored_filename']),
     3096        $p_header['extra_len'], $p_header['comment_len'],
     3097        $p_header['disk'], $p_header['internal'],
     3098        $p_header['external'], $p_header['offset']);
    31003099
    31013100    // ----- Write the 42 bytes of the header in the zip file
     
    31033102
    31043103    // ----- Write the variable fields
    3105     if (strlen($p_header['stored_filename']) != 0)
    3106     {
     3104    if (strlen($p_header['stored_filename']) != 0) {
    31073105      fputs($this->zip_fd, $p_header['stored_filename'], strlen($p_header['stored_filename']));
    31083106    }
    3109     if ($p_header['extra_len'] != 0)
    3110     {
     3107    if ($p_header['extra_len'] != 0) {
    31113108      fputs($this->zip_fd, $p_header['extra'], $p_header['extra_len']);
    31123109    }
    3113     if ($p_header['comment_len'] != 0)
    3114     {
     3110    if ($p_header['comment_len'] != 0) {
    31153111      fputs($this->zip_fd, $p_header['comment'], $p_header['comment_len']);
    31163112    }
     
    31273123  // Return Values :
    31283124  // --------------------------------------------------------------------------------
    3129   function privWriteCentralHeader($p_nb_entries, $p_size, $p_offset, $p_comment)
    3130   {
    3131     $v_result=1;
     3125  public function privWriteCentralHeader($p_nb_entries, $p_size, $p_offset, $p_comment) {
     3126    $v_result = 1;
    31323127
    31333128    // ----- Packed data
    31343129    $v_binary_data = pack("VvvvvVVv", 0x06054b50, 0, 0, $p_nb_entries,
    3135                               $p_nb_entries, $p_size,
    3136                                                   $p_offset, strlen($p_comment));
     3130        $p_nb_entries, $p_size,
     3131        $p_offset, strlen($p_comment));
    31373132
    31383133    // ----- Write the 22 bytes of the header in the zip file
     
    31403135
    31413136    // ----- Write the variable fields
    3142     if (strlen($p_comment) != 0)
    3143     {
     3137    if (strlen($p_comment) != 0) {
    31443138      fputs($this->zip_fd, $p_comment, strlen($p_comment));
    31453139    }
     
    31563150  // Return Values :
    31573151  // --------------------------------------------------------------------------------
    3158   function privList(&$p_list)
    3159   {
    3160     $v_result=1;
     3152  public function privList(&$p_list) {
     3153    $v_result = 1;
    31613154
    31623155    // ----- Magic quotes trick
     
    31643157
    31653158    // ----- Open the zip file
    3166     if (($this->zip_fd = @fopen($this->zipname, 'rb')) == 0)
    3167     {
     3159    if (($this->zip_fd = @fopen($this->zipname, 'rb')) == 0) {
    31683160      // ----- Magic quotes trick
    31693161      $this->privSwapBackMagicQuotes();
    3170      
     3162
    31713163      // ----- Error log
    3172       PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, 'Unable to open archive \''.$this->zipname.'\' in binary read mode');
     3164      PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL,
     3165          'Unable to open archive \'' . $this->zipname . '\' in binary read mode');
    31733166
    31743167      // ----- Return
     
    31783171    // ----- Read the central directory informations
    31793172    $v_central_dir = array();
    3180     if (($v_result = $this->privReadEndCentralDir($v_central_dir)) != 1)
    3181     {
     3173    if (($v_result = $this->privReadEndCentralDir($v_central_dir)) != 1) {
    31823174      $this->privSwapBackMagicQuotes();
     3175
    31833176      return $v_result;
    31843177    }
     
    31863179    // ----- Go to beginning of Central Dir
    31873180    @rewind($this->zip_fd);
    3188     if (@fseek($this->zip_fd, $v_central_dir['offset']))
    3189     {
     3181    if (@fseek($this->zip_fd, $v_central_dir['offset'])) {
    31903182      $this->privSwapBackMagicQuotes();
    31913183
     
    31983190
    31993191    // ----- Read each entry
    3200     for ($i=0; $i<$v_central_dir['entries']; $i++)
    3201     {
     3192    for ($i = 0; $i < $v_central_dir['entries']; $i++) {
    32023193      // ----- Read the file header
    3203       if (($v_result = $this->privReadCentralFileHeader($v_header)) != 1)
    3204       {
     3194      if (($v_result = $this->privReadCentralFileHeader($v_header)) != 1) {
    32053195        $this->privSwapBackMagicQuotes();
     3196
    32063197        return $v_result;
    32073198      }
     
    32433234  // Return Values :
    32443235  // --------------------------------------------------------------------------------
    3245   function privConvertHeader2FileInfo($p_header, &$p_info)
    3246   {
    3247     $v_result=1;
     3236  public function privConvertHeader2FileInfo($p_header, &$p_info) {
     3237    $v_result = 1;
    32483238
    32493239    // ----- Get the interesting attributes
     
    32563246    $p_info['mtime'] = $p_header['mtime'];
    32573247    $p_info['comment'] = $p_header['comment'];
    3258     $p_info['folder'] = (($p_header['external']&0x00000010)==0x00000010);
     3248    $p_info['folder'] = (($p_header['external'] & 0x00000010) == 0x00000010);
    32593249    $p_info['index'] = $p_header['index'];
    32603250    $p_info['status'] = $p_header['status'];
     
    32823272  //   1 on success,0 or less on error (see error code list)
    32833273  // --------------------------------------------------------------------------------
    3284   function privExtractByRule(&$p_file_list, $p_path, $p_remove_path, $p_remove_all_path, &$p_options)
    3285   {
    3286     $v_result=1;
     3274  public function privExtractByRule(&$p_file_list, $p_path, $p_remove_path, $p_remove_all_path, &$p_options) {
     3275    $v_result = 1;
    32873276
    32883277    // ----- Magic quotes trick
     
    32903279
    32913280    // ----- Check the path
    3292     if (   ($p_path == "")
    3293             || (   (substr($p_path, 0, 1) != "/")
    3294                     && (substr($p_path, 0, 3) != "../")
    3295                         && (substr($p_path,1,2)!=":/")))
    3296       $p_path = "./".$p_path;
     3281    if (($p_path == "")
     3282        || ((substr($p_path, 0, 1) != "/")
     3283            && (substr($p_path, 0, 3) != "../")
     3284            && (substr($p_path, 1, 2) != ":/"))
     3285    ) {
     3286      $p_path = "./" . $p_path;
     3287    }
    32973288
    32983289    // ----- Reduce the path last (and duplicated) '/'
    3299     if (($p_path != "./") && ($p_path != "/"))
    3300     {
     3290    if (($p_path != "./") && ($p_path != "/")) {
    33013291      // ----- Look for the path end '/'
    3302       while (substr($p_path, -1) == "/")
    3303       {
    3304         $p_path = substr($p_path, 0, strlen($p_path)-1);
     3292      while (substr($p_path, -1) == "/") {
     3293        $p_path = substr($p_path, 0, strlen($p_path) - 1);
    33053294      }
    33063295    }
    33073296
    33083297    // ----- Look for path to remove format (should end by /)
    3309     if (($p_remove_path != "") && (substr($p_remove_path, -1) != '/'))
    3310     {
     3298    if (($p_remove_path != "") && (substr($p_remove_path, -1) != '/')) {
    33113299      $p_remove_path .= '/';
    33123300    }
     
    33143302
    33153303    // ----- Open the zip file
    3316     if (($v_result = $this->privOpenFd('rb')) != 1)
    3317     {
     3304    if (($v_result = $this->privOpenFd('rb')) != 1) {
    33183305      $this->privSwapBackMagicQuotes();
     3306
    33193307      return $v_result;
    33203308    }
     
    33223310    // ----- Read the central directory informations
    33233311    $v_central_dir = array();
    3324     if (($v_result = $this->privReadEndCentralDir($v_central_dir)) != 1)
    3325     {
     3312    if (($v_result = $this->privReadEndCentralDir($v_central_dir)) != 1) {
    33263313      // ----- Close the zip file
    33273314      $this->privCloseFd();
     
    33363323    // ----- Read each entry
    33373324    $j_start = 0;
    3338     for ($i=0, $v_nb_extracted=0; $i<$v_central_dir['entries']; $i++)
    3339     {
     3325    for ($i = 0, $v_nb_extracted = 0; $i < $v_central_dir['entries']; $i++) {
    33403326
    33413327      // ----- Read next Central dir entry
    33423328      @rewind($this->zip_fd);
    3343       if (@fseek($this->zip_fd, $v_pos_entry))
    3344       {
     3329      if (@fseek($this->zip_fd, $v_pos_entry)) {
    33453330        // ----- Close the zip file
    33463331        $this->privCloseFd();
     
    33563341      // ----- Read the file header
    33573342      $v_header = array();
    3358       if (($v_result = $this->privReadCentralFileHeader($v_header)) != 1)
    3359       {
     3343      if (($v_result = $this->privReadCentralFileHeader($v_header)) != 1) {
    33603344        // ----- Close the zip file
    33613345        $this->privCloseFd();
     
    33753359
    33763360      // ----- Look for extract by name rule
    3377       if (   (isset($p_options[PCLZIP_OPT_BY_NAME]))
    3378           && ($p_options[PCLZIP_OPT_BY_NAME] != 0)) {
    3379 
    3380           // ----- Look if the filename is in the list
    3381           for ($j=0; ($j<sizeof($p_options[PCLZIP_OPT_BY_NAME])) && (!$v_extract); $j++) {
    3382 
    3383               // ----- Look for a directory
    3384               if (substr($p_options[PCLZIP_OPT_BY_NAME][$j], -1) == "/") {
    3385 
    3386                   // ----- Look if the directory is in the filename path
    3387                   if (   (strlen($v_header['stored_filename']) > strlen($p_options[PCLZIP_OPT_BY_NAME][$j]))
    3388                       && (substr($v_header['stored_filename'], 0, strlen($p_options[PCLZIP_OPT_BY_NAME][$j])) == $p_options[PCLZIP_OPT_BY_NAME][$j])) {
    3389                       $v_extract = true;
    3390                   }
    3391               }
    3392               // ----- Look for a filename
    3393               elseif ($v_header['stored_filename'] == $p_options[PCLZIP_OPT_BY_NAME][$j]) {
    3394                   $v_extract = true;
    3395               }
    3396           }
     3361      if ((isset($p_options[PCLZIP_OPT_BY_NAME]))
     3362          && ($p_options[PCLZIP_OPT_BY_NAME] != 0)
     3363      ) {
     3364
     3365        // ----- Look if the filename is in the list
     3366        for ($j = 0; ($j < sizeof($p_options[PCLZIP_OPT_BY_NAME])) && (!$v_extract); $j++) {
     3367
     3368          // ----- Look for a directory
     3369          if (substr($p_options[PCLZIP_OPT_BY_NAME][$j], -1) == "/") {
     3370
     3371            // ----- Look if the directory is in the filename path
     3372            if ((strlen($v_header['stored_filename']) > strlen($p_options[PCLZIP_OPT_BY_NAME][$j]))
     3373                && (substr($v_header['stored_filename'], 0,
     3374                        strlen($p_options[PCLZIP_OPT_BY_NAME][$j])) == $p_options[PCLZIP_OPT_BY_NAME][$j])
     3375            ) {
     3376              $v_extract = true;
     3377            }
     3378          } // ----- Look for a filename
     3379          elseif ($v_header['stored_filename'] == $p_options[PCLZIP_OPT_BY_NAME][$j]) {
     3380            $v_extract = true;
     3381          }
     3382        }
    33973383      }
    33983384
    33993385      // ----- Look for extract by ereg rule
    34003386      // ereg() is deprecated with PHP 5.3
    3401       /* 
     3387      /*
    34023388      else if (   (isset($p_options[PCLZIP_OPT_BY_EREG]))
    34033389               && ($p_options[PCLZIP_OPT_BY_EREG] != "")) {
     
    34103396
    34113397      // ----- Look for extract by preg rule
    3412       else if (   (isset($p_options[PCLZIP_OPT_BY_PREG]))
    3413                && ($p_options[PCLZIP_OPT_BY_PREG] != "")) {
     3398      else {
     3399        if ((isset($p_options[PCLZIP_OPT_BY_PREG]))
     3400            && ($p_options[PCLZIP_OPT_BY_PREG] != "")
     3401        ) {
    34143402
    34153403          if (preg_match($p_options[PCLZIP_OPT_BY_PREG], $v_header['stored_filename'])) {
    3416               $v_extract = true;
    3417           }
    3418       }
    3419 
    3420       // ----- Look for extract by index rule
    3421       else if (   (isset($p_options[PCLZIP_OPT_BY_INDEX]))
    3422                && ($p_options[PCLZIP_OPT_BY_INDEX] != 0)) {
    3423          
    3424           // ----- Look if the index is in the list
    3425           for ($j=$j_start; ($j<sizeof($p_options[PCLZIP_OPT_BY_INDEX])) && (!$v_extract); $j++) {
    3426 
    3427               if (($i>=$p_options[PCLZIP_OPT_BY_INDEX][$j]['start']) && ($i<=$p_options[PCLZIP_OPT_BY_INDEX][$j]['end'])) {
    3428                   $v_extract = true;
     3404            $v_extract = true;
     3405          }
     3406        } // ----- Look for extract by index rule
     3407        else {
     3408          if ((isset($p_options[PCLZIP_OPT_BY_INDEX]))
     3409              && ($p_options[PCLZIP_OPT_BY_INDEX] != 0)
     3410          ) {
     3411
     3412            // ----- Look if the index is in the list
     3413            for ($j = $j_start; ($j < sizeof($p_options[PCLZIP_OPT_BY_INDEX])) && (!$v_extract); $j++) {
     3414
     3415              if (($i >= $p_options[PCLZIP_OPT_BY_INDEX][$j]['start']) && ($i <= $p_options[PCLZIP_OPT_BY_INDEX][$j]['end'])) {
     3416                $v_extract = true;
    34293417              }
    3430               if ($i>=$p_options[PCLZIP_OPT_BY_INDEX][$j]['end']) {
    3431                   $j_start = $j+1;
     3418              if ($i >= $p_options[PCLZIP_OPT_BY_INDEX][$j]['end']) {
     3419                $j_start = $j + 1;
    34323420              }
    34333421
    3434               if ($p_options[PCLZIP_OPT_BY_INDEX][$j]['start']>$i) {
    3435                   break;
     3422              if ($p_options[PCLZIP_OPT_BY_INDEX][$j]['start'] > $i) {
     3423                break;
    34363424              }
    3437           }
    3438       }
    3439 
    3440       // ----- Look for no rule, which means extract all the archive
    3441       else {
    3442           $v_extract = true;
    3443       }
    3444 
    3445           // ----- Check compression method
    3446           if (   ($v_extract)
    3447               && (   ($v_header['compression'] != 8)
    3448                       && ($v_header['compression'] != 0))) {
    3449           $v_header['status'] = 'unsupported_compression';
    3450 
    3451           // ----- Look for PCLZIP_OPT_STOP_ON_ERROR
    3452           if (   (isset($p_options[PCLZIP_OPT_STOP_ON_ERROR]))
    3453                       && ($p_options[PCLZIP_OPT_STOP_ON_ERROR]===true)) {
    3454 
    3455               $this->privSwapBackMagicQuotes();
    3456              
    3457               PclZip::privErrorLog(PCLZIP_ERR_UNSUPPORTED_COMPRESSION,
    3458                                                "Filename '".$v_header['stored_filename']."' is "
    3459                                                            ."compressed by an unsupported compression "
    3460                                                            ."method (".$v_header['compression'].") ");
    3461 
    3462               return PclZip::errorCode();
    3463                   }
    3464           }
    3465          
    3466           // ----- Check encrypted files
    3467           if (($v_extract) && (($v_header['flag'] & 1) == 1)) {
    3468           $v_header['status'] = 'unsupported_encryption';
    3469 
    3470           // ----- Look for PCLZIP_OPT_STOP_ON_ERROR
    3471           if (   (isset($p_options[PCLZIP_OPT_STOP_ON_ERROR]))
    3472                       && ($p_options[PCLZIP_OPT_STOP_ON_ERROR]===true)) {
    3473 
    3474               $this->privSwapBackMagicQuotes();
    3475 
    3476               PclZip::privErrorLog(PCLZIP_ERR_UNSUPPORTED_ENCRYPTION,
    3477                                                "Unsupported encryption for "
    3478                                                            ." filename '".$v_header['stored_filename']
    3479                                                                    ."'");
    3480 
    3481               return PclZip::errorCode();
    3482                   }
    3483     }
     3425            }
     3426          } // ----- Look for no rule, which means extract all the archive
     3427          else {
     3428            $v_extract = true;
     3429          }
     3430        }
     3431      }
     3432
     3433      // ----- Check compression method
     3434      if (($v_extract)
     3435          && (($v_header['compression'] != 8)
     3436              && ($v_header['compression'] != 0))
     3437      ) {
     3438        $v_header['status'] = 'unsupported_compression';
     3439
     3440        // ----- Look for PCLZIP_OPT_STOP_ON_ERROR
     3441        if ((isset($p_options[PCLZIP_OPT_STOP_ON_ERROR]))
     3442            && ($p_options[PCLZIP_OPT_STOP_ON_ERROR] === true)
     3443        ) {
     3444
     3445          $this->privSwapBackMagicQuotes();
     3446
     3447          PclZip::privErrorLog(PCLZIP_ERR_UNSUPPORTED_COMPRESSION,
     3448              "Filename '" . $v_header['stored_filename'] . "' is "
     3449              . "compressed by an unsupported compression "
     3450              . "method (" . $v_header['compression'] . ") ");
     3451
     3452          return PclZip::errorCode();
     3453        }
     3454      }
     3455
     3456      // ----- Check encrypted files
     3457      if (($v_extract) && (($v_header['flag'] & 1) == 1)) {
     3458        $v_header['status'] = 'unsupported_encryption';
     3459
     3460        // ----- Look for PCLZIP_OPT_STOP_ON_ERROR
     3461        if ((isset($p_options[PCLZIP_OPT_STOP_ON_ERROR]))
     3462            && ($p_options[PCLZIP_OPT_STOP_ON_ERROR] === true)
     3463        ) {
     3464
     3465          $this->privSwapBackMagicQuotes();
     3466
     3467          PclZip::privErrorLog(PCLZIP_ERR_UNSUPPORTED_ENCRYPTION,
     3468              "Unsupported encryption for "
     3469              . " filename '" . $v_header['stored_filename']
     3470              . "'");
     3471
     3472          return PclZip::errorCode();
     3473        }
     3474      }
    34843475
    34853476      // ----- Look for real extraction
    34863477      if (($v_extract) && ($v_header['status'] != 'ok')) {
    3487           $v_result = $this->privConvertHeader2FileInfo($v_header,
    3488                                                         $p_file_list[$v_nb_extracted++]);
    3489           if ($v_result != 1) {
    3490               $this->privCloseFd();
    3491               $this->privSwapBackMagicQuotes();
    3492               return $v_result;
    3493           }
    3494 
    3495           $v_extract = false;
    3496       }
    3497      
     3478        $v_result = $this->privConvertHeader2FileInfo($v_header,
     3479            $p_file_list[$v_nb_extracted++]);
     3480        if ($v_result != 1) {
     3481          $this->privCloseFd();
     3482          $this->privSwapBackMagicQuotes();
     3483
     3484          return $v_result;
     3485        }
     3486
     3487        $v_extract = false;
     3488      }
     3489
    34983490      // ----- Look for real extraction
    3499       if ($v_extract)
    3500       {
     3491      if ($v_extract) {
    35013492
    35023493        // ----- Go to the file position
    35033494        @rewind($this->zip_fd);
    3504         if (@fseek($this->zip_fd, $v_header['offset']))
    3505         {
     3495        if (@fseek($this->zip_fd, $v_header['offset'])) {
    35063496          // ----- Close the zip file
    35073497          $this->privCloseFd();
     
    35263516            $this->privCloseFd();
    35273517            $this->privSwapBackMagicQuotes();
     3518
    35283519            return $v_result1;
    35293520          }
    35303521
    35313522          // ----- Get the only interesting attributes
    3532           if (($v_result = $this->privConvertHeader2FileInfo($v_header, $p_file_list[$v_nb_extracted])) != 1)
    3533           {
     3523          if (($v_result = $this->privConvertHeader2FileInfo($v_header, $p_file_list[$v_nb_extracted])) != 1) {
    35343524            // ----- Close the zip file
    35353525            $this->privCloseFd();
     
    35443534          // ----- Next extracted file
    35453535          $v_nb_extracted++;
    3546          
     3536
    35473537          // ----- Look for user callback abort
    35483538          if ($v_result1 == 2) {
    3549                 break;
    3550           }
    3551         }
    3552         // ----- Look for extraction in standard output
    3553         elseif (   (isset($p_options[PCLZIP_OPT_EXTRACT_IN_OUTPUT]))
    3554                         && ($p_options[PCLZIP_OPT_EXTRACT_IN_OUTPUT])) {
     3539            break;
     3540          }
     3541        } // ----- Look for extraction in standard output
     3542        elseif ((isset($p_options[PCLZIP_OPT_EXTRACT_IN_OUTPUT]))
     3543            && ($p_options[PCLZIP_OPT_EXTRACT_IN_OUTPUT])
     3544        ) {
    35553545          // ----- Extracting the file in standard output
    35563546          $v_result1 = $this->privExtractFileInOutput($v_header, $p_options);
     
    35583548            $this->privCloseFd();
    35593549            $this->privSwapBackMagicQuotes();
     3550
    35603551            return $v_result1;
    35613552          }
     
    35653556            $this->privCloseFd();
    35663557            $this->privSwapBackMagicQuotes();
     3558
    35673559            return $v_result;
    35683560          }
     
    35703562          // ----- Look for user callback abort
    35713563          if ($v_result1 == 2) {
    3572                 break;
    3573           }
    3574         }
    3575         // ----- Look for normal extraction
     3564            break;
     3565          }
     3566        } // ----- Look for normal extraction
    35763567        else {
    35773568          // ----- Extracting the file
    35783569          $v_result1 = $this->privExtractFile($v_header,
    3579                                                       $p_path, $p_remove_path,
    3580                                                                                           $p_remove_all_path,
    3581                                                                                           $p_options);
     3570              $p_path, $p_remove_path,
     3571              $p_remove_all_path,
     3572              $p_options);
    35823573          if ($v_result1 < 1) {
    35833574            $this->privCloseFd();
    35843575            $this->privSwapBackMagicQuotes();
     3576
    35853577            return $v_result1;
    35863578          }
    35873579
    35883580          // ----- Get the only interesting attributes
    3589           if (($v_result = $this->privConvertHeader2FileInfo($v_header, $p_file_list[$v_nb_extracted++])) != 1)
    3590           {
     3581          if (($v_result = $this->privConvertHeader2FileInfo($v_header, $p_file_list[$v_nb_extracted++])) != 1) {
    35913582            // ----- Close the zip file
    35923583            $this->privCloseFd();
     
    35983589          // ----- Look for user callback abort
    35993590          if ($v_result1 == 2) {
    3600                 break;
     3591            break;
    36013592          }
    36023593        }
     
    36223613  // PCLZIP_ERR_USER_ABORTED(2) : User ask for extraction stop in callback
    36233614  // --------------------------------------------------------------------------------
    3624   function privExtractFile(&$p_entry, $p_path, $p_remove_path, $p_remove_all_path, &$p_options)
    3625   {
    3626     $v_result=1;
     3615  public function privExtractFile(&$p_entry, $p_path, $p_remove_path, $p_remove_all_path, &$p_options) {
     3616    $v_result = 1;
    36273617
    36283618    // ----- Read the file header
    3629     if (($v_result = $this->privReadFileHeader($v_header)) != 1)
    3630     {
     3619    if (($v_result = $this->privReadFileHeader($v_header)) != 1) {
    36313620      // ----- Return
    36323621      return $v_result;
     
    36363625    // ----- Check that the file header is coherent with $p_entry info
    36373626    if ($this->privCheckFileHeaders($v_header, $p_entry) != 1) {
    3638         // TBC
     3627      // TBC
    36393628    }
    36403629
    36413630    // ----- Look for all path to remove
    36423631    if ($p_remove_all_path == true) {
    3643         // ----- Look for folder entry that not need to be extracted
    3644         if (($p_entry['external']&0x00000010)==0x00000010) {
    3645 
    3646             $p_entry['status'] = "filtered";
    3647 
    3648             return $v_result;
    3649         }
    3650 
    3651         // ----- Get the basename of the path
    3652         $p_entry['filename'] = basename($p_entry['filename']);
    3653     }
    3654 
    3655     // ----- Look for path to remove
    3656     else if ($p_remove_path != "")
    3657     {
    3658       if (PclZipUtilPathInclusion($p_remove_path, $p_entry['filename']) == 2)
    3659       {
    3660 
    3661         // ----- Change the file status
     3632      // ----- Look for folder entry that not need to be extracted
     3633      if (($p_entry['external'] & 0x00000010) == 0x00000010) {
     3634
    36623635        $p_entry['status'] = "filtered";
    36633636
    3664         // ----- Return
    36653637        return $v_result;
    36663638      }
    36673639
    3668       $p_remove_path_size = strlen($p_remove_path);
    3669       if (substr($p_entry['filename'], 0, $p_remove_path_size) == $p_remove_path)
    3670       {
    3671 
    3672         // ----- Remove the path
    3673         $p_entry['filename'] = substr($p_entry['filename'], $p_remove_path_size);
    3674 
     3640      // ----- Get the basename of the path
     3641      $p_entry['filename'] = basename($p_entry['filename']);
     3642    } // ----- Look for path to remove
     3643    else {
     3644      if ($p_remove_path != "") {
     3645        if (PclZipUtilPathInclusion($p_remove_path, $p_entry['filename']) == 2) {
     3646
     3647          // ----- Change the file status
     3648          $p_entry['status'] = "filtered";
     3649
     3650          // ----- Return
     3651          return $v_result;
     3652        }
     3653
     3654        $p_remove_path_size = strlen($p_remove_path);
     3655        if (substr($p_entry['filename'], 0, $p_remove_path_size) == $p_remove_path) {
     3656
     3657          // ----- Remove the path
     3658          $p_entry['filename'] = substr($p_entry['filename'], $p_remove_path_size);
     3659
     3660        }
    36753661      }
    36763662    }
     
    36783664    // ----- Add the path
    36793665    if ($p_path != '') {
    3680       $p_entry['filename'] = $p_path."/".$p_entry['filename'];
    3681     }
    3682    
     3666      $p_entry['filename'] = $p_path . "/" . $p_entry['filename'];
     3667    }
     3668
    36833669    // ----- Check a base_dir_restriction
    36843670    if (isset($p_options[PCLZIP_OPT_EXTRACT_DIR_RESTRICTION])) {
    36853671      $v_inclusion
    3686       = PclZipUtilPathInclusion($p_options[PCLZIP_OPT_EXTRACT_DIR_RESTRICTION],
    3687                                 $p_entry['filename']);
     3672          = PclZipUtilPathInclusion($p_options[PCLZIP_OPT_EXTRACT_DIR_RESTRICTION],
     3673          $p_entry['filename']);
    36883674      if ($v_inclusion == 0) {
    36893675
    36903676        PclZip::privErrorLog(PCLZIP_ERR_DIRECTORY_RESTRICTION,
    3691                                              "Filename '".$p_entry['filename']."' is "
    3692                                                                  ."outside PCLZIP_OPT_EXTRACT_DIR_RESTRICTION");
     3677            "Filename '" . $p_entry['filename'] . "' is "
     3678            . "outside PCLZIP_OPT_EXTRACT_DIR_RESTRICTION");
    36933679
    36943680        return PclZip::errorCode();
     
    37133699        $v_result = 1;
    37143700      }
    3715      
     3701
    37163702      // ----- Look for abort result
    37173703      if ($v_result == 2) {
    37183704        // ----- This status is internal and will be changed in 'skipped'
    37193705        $p_entry['status'] = "aborted";
    3720         $v_result = PCLZIP_ERR_USER_ABORTED;
     3706        $v_result = PCLZIP_ERR_USER_ABORTED;
    37213707      }
    37223708
     
    37303716    if ($p_entry['status'] == 'ok') {
    37313717
    3732     // ----- Look for specific actions while the file exist
    3733     if (file_exists($p_entry['filename']))
    3734     {
    3735 
    3736       // ----- Look if file is a directory
    3737       if (is_dir($p_entry['filename']))
    3738       {
    3739 
    3740         // ----- Change the file status
    3741         $p_entry['status'] = "already_a_directory";
    3742        
    3743         // ----- Look for PCLZIP_OPT_STOP_ON_ERROR
    3744         // For historical reason first PclZip implementation does not stop
    3745         // when this kind of error occurs.
    3746         if (   (isset($p_options[PCLZIP_OPT_STOP_ON_ERROR]))
    3747                     && ($p_options[PCLZIP_OPT_STOP_ON_ERROR]===true)) {
     3718      // ----- Look for specific actions while the file exist
     3719      if (file_exists($p_entry['filename'])) {
     3720
     3721        // ----- Look if file is a directory
     3722        if (is_dir($p_entry['filename'])) {
     3723
     3724          // ----- Change the file status
     3725          $p_entry['status'] = "already_a_directory";
     3726
     3727          // ----- Look for PCLZIP_OPT_STOP_ON_ERROR
     3728          // For historical reason first PclZip implementation does not stop
     3729          // when this kind of error occurs.
     3730          if ((isset($p_options[PCLZIP_OPT_STOP_ON_ERROR]))
     3731              && ($p_options[PCLZIP_OPT_STOP_ON_ERROR] === true)
     3732          ) {
    37483733
    37493734            PclZip::privErrorLog(PCLZIP_ERR_ALREADY_A_DIRECTORY,
    3750                                              "Filename '".$p_entry['filename']."' is "
    3751                                                                  ."already used by an existing directory");
     3735                "Filename '" . $p_entry['filename'] . "' is "
     3736                . "already used by an existing directory");
    37523737
    37533738            return PclZip::errorCode();
    3754                     }
    3755       }
    3756       // ----- Look if file is write protected
    3757       else if (!is_writeable($p_entry['filename']))
    3758       {
    3759 
    3760         // ----- Change the file status
    3761         $p_entry['status'] = "write_protected";
    3762 
    3763         // ----- Look for PCLZIP_OPT_STOP_ON_ERROR
    3764         // For historical reason first PclZip implementation does not stop
    3765         // when this kind of error occurs.
    3766         if (   (isset($p_options[PCLZIP_OPT_STOP_ON_ERROR]))
    3767                     && ($p_options[PCLZIP_OPT_STOP_ON_ERROR]===true)) {
    3768 
    3769             PclZip::privErrorLog(PCLZIP_ERR_WRITE_OPEN_FAIL,
    3770                                              "Filename '".$p_entry['filename']."' exists "
    3771                                                                  ."and is write protected");
    3772 
    3773             return PclZip::errorCode();
    3774                     }
    3775       }
    3776 
    3777       // ----- Look if the extracted file is older
    3778       else if (filemtime($p_entry['filename']) > $p_entry['mtime'])
    3779       {
    3780         // ----- Change the file status
    3781         if (   (isset($p_options[PCLZIP_OPT_REPLACE_NEWER]))
    3782                     && ($p_options[PCLZIP_OPT_REPLACE_NEWER]===true)) {
    3783                   }
    3784                     else {
    3785             $p_entry['status'] = "newer_exist";
     3739          }
     3740        } // ----- Look if file is write protected
     3741        else {
     3742          if (!is_writeable($p_entry['filename'])) {
     3743
     3744            // ----- Change the file status
     3745            $p_entry['status'] = "write_protected";
    37863746
    37873747            // ----- Look for PCLZIP_OPT_STOP_ON_ERROR
    37883748            // For historical reason first PclZip implementation does not stop
    37893749            // when this kind of error occurs.
    3790             if (   (isset($p_options[PCLZIP_OPT_STOP_ON_ERROR]))
    3791                         && ($p_options[PCLZIP_OPT_STOP_ON_ERROR]===true)) {
    3792 
    3793                 PclZip::privErrorLog(PCLZIP_ERR_WRITE_OPEN_FAIL,
    3794                                      "Newer version of '".$p_entry['filename']."' exists "
    3795                                             ."and option PCLZIP_OPT_REPLACE_NEWER is not selected");
    3796 
    3797                 return PclZip::errorCode();
    3798                       }
    3799                     }
    3800       }
     3750            if ((isset($p_options[PCLZIP_OPT_STOP_ON_ERROR]))
     3751                && ($p_options[PCLZIP_OPT_STOP_ON_ERROR] === true)
     3752            ) {
     3753
     3754              PclZip::privErrorLog(PCLZIP_ERR_WRITE_OPEN_FAIL,
     3755                  "Filename '" . $p_entry['filename'] . "' exists "
     3756                  . "and is write protected");
     3757
     3758              return PclZip::errorCode();
     3759            }
     3760          } // ----- Look if the extracted file is older
     3761          else {
     3762            if (filemtime($p_entry['filename']) > $p_entry['mtime']) {
     3763              // ----- Change the file status
     3764              if ((isset($p_options[PCLZIP_OPT_REPLACE_NEWER]))
     3765                  && ($p_options[PCLZIP_OPT_REPLACE_NEWER] === true)
     3766              ) {
     3767              } else {
     3768                $p_entry['status'] = "newer_exist";
     3769
     3770                // ----- Look for PCLZIP_OPT_STOP_ON_ERROR
     3771                // For historical reason first PclZip implementation does not stop
     3772                // when this kind of error occurs.
     3773                if ((isset($p_options[PCLZIP_OPT_STOP_ON_ERROR]))
     3774                    && ($p_options[PCLZIP_OPT_STOP_ON_ERROR] === true)
     3775                ) {
     3776
     3777                  PclZip::privErrorLog(PCLZIP_ERR_WRITE_OPEN_FAIL,
     3778                      "Newer version of '" . $p_entry['filename'] . "' exists "
     3779                      . "and option PCLZIP_OPT_REPLACE_NEWER is not selected");
     3780
     3781                  return PclZip::errorCode();
     3782                }
     3783              }
     3784            } else {
     3785            }
     3786          }
     3787        }
     3788      } // ----- Check the directory availability and create it if necessary
    38013789      else {
    3802       }
    3803     }
    3804 
    3805     // ----- Check the directory availability and create it if necessary
    3806     else {
    3807       if ((($p_entry['external']&0x00000010)==0x00000010) || (substr($p_entry['filename'], -1) == '/'))
    3808         $v_dir_to_check = $p_entry['filename'];
    3809       else if (!strstr($p_entry['filename'], "/"))
    3810         $v_dir_to_check = "";
    3811       else
    3812         $v_dir_to_check = dirname($p_entry['filename']);
    3813 
    3814         if (($v_result = $this->privDirCheck($v_dir_to_check, (($p_entry['external']&0x00000010)==0x00000010))) != 1) {
    3815  
     3790        if ((($p_entry['external'] & 0x00000010) == 0x00000010) || (substr($p_entry['filename'], -1) == '/')) {
     3791          $v_dir_to_check = $p_entry['filename'];
     3792        } else {
     3793          if (!strstr($p_entry['filename'], "/")) {
     3794            $v_dir_to_check = "";
     3795          } else {
     3796            $v_dir_to_check = dirname($p_entry['filename']);
     3797          }
     3798        }
     3799
     3800        if (($v_result = $this->privDirCheck($v_dir_to_check,
     3801                (($p_entry['external'] & 0x00000010) == 0x00000010))) != 1
     3802        ) {
     3803
    38163804          // ----- Change the file status
    38173805          $p_entry['status'] = "path_creation_fail";
    3818  
     3806
    38193807          // ----- Return
    38203808          //return $v_result;
     
    38283816
    38293817      // ----- Do the extraction (if not a folder)
    3830       if (!(($p_entry['external']&0x00000010)==0x00000010))
    3831       {
     3818      if (!(($p_entry['external'] & 0x00000010) == 0x00000010)) {
    38323819        // ----- Look for not compressed file
    38333820        if ($p_entry['compression'] == 0) {
    38343821
    3835                   // ----- Opening destination file
    3836           if (($v_dest_file = @fopen($p_entry['filename'], 'wb')) == 0)
    3837           {
     3822          // ----- Opening destination file
     3823          if (($v_dest_file = @fopen($p_entry['filename'], 'wb')) == 0) {
    38383824
    38393825            // ----- Change the file status
     
    38473833          // ----- Read the file by PCLZIP_READ_BLOCK_SIZE octets blocks
    38483834          $v_size = $p_entry['compressed_size'];
    3849           while ($v_size != 0)
    3850           {
     3835          while ($v_size != 0) {
    38513836            $v_read_size = ($v_size < PCLZIP_READ_BLOCK_SIZE ? $v_size : PCLZIP_READ_BLOCK_SIZE);
    38523837            $v_buffer = @fread($this->zip_fd, $v_read_size);
     
    38553840            @fwrite($v_dest_file, $v_binary_data, $v_read_size);
    38563841            */
    3857             @fwrite($v_dest_file, $v_buffer, $v_read_size);           
     3842            @fwrite($v_dest_file, $v_buffer, $v_read_size);
    38583843            $v_size -= $v_read_size;
    38593844          }
     
    38643849          // ----- Change the file mtime
    38653850          touch($p_entry['filename'], $p_entry['mtime']);
    3866          
    3867 
    3868         }
    3869         else {
     3851
     3852
     3853        } else {
    38703854          // ----- TBC
    38713855          // Need to be finished
    38723856          if (($p_entry['flag'] & 1) == 1) {
    3873             PclZip::privErrorLog(PCLZIP_ERR_UNSUPPORTED_ENCRYPTION, 'File \''.$p_entry['filename'].'\' is encrypted. Encrypted files are not supported.');
     3857            PclZip::privErrorLog(PCLZIP_ERR_UNSUPPORTED_ENCRYPTION,
     3858                'File \'' . $p_entry['filename'] . '\' is encrypted. Encrypted files are not supported.');
     3859
    38743860            return PclZip::errorCode();
    38753861          }
     
    38773863
    38783864          // ----- Look for using temporary file to unzip
    3879           if ( (!isset($p_options[PCLZIP_OPT_TEMP_FILE_OFF]))
     3865          if ((!isset($p_options[PCLZIP_OPT_TEMP_FILE_OFF]))
    38803866              && (isset($p_options[PCLZIP_OPT_TEMP_FILE_ON])
    38813867                  || (isset($p_options[PCLZIP_OPT_TEMP_FILE_THRESHOLD])
    3882                       && ($p_options[PCLZIP_OPT_TEMP_FILE_THRESHOLD] <= $p_entry['size'])) ) ) {
     3868                      && ($p_options[PCLZIP_OPT_TEMP_FILE_THRESHOLD] <= $p_entry['size'])))
     3869          ) {
    38833870            $v_result = $this->privExtractFileUsingTempFile($p_entry, $p_options);
    38843871            if ($v_result < PCLZIP_ERR_NO_ERROR) {
    38853872              return $v_result;
    38863873            }
    3887           }
    3888          
    3889           // ----- Look for extract in memory
     3874          } // ----- Look for extract in memory
    38903875          else {
    38913876
    3892          
     3877
    38933878            // ----- Read the compressed file in a buffer (one shot)
    38943879            $v_buffer = @fread($this->zip_fd, $p_entry['compressed_size']);
    3895            
     3880
    38963881            // ----- Decompress the file
    38973882            $v_file_content = @gzinflate($v_buffer);
    38983883            unset($v_buffer);
    3899             if ($v_file_content === FALSE) {
    3900  
     3884            if ($v_file_content === false) {
     3885
    39013886              // ----- Change the file status
    39023887              // TBC
    39033888              $p_entry['status'] = "error";
    3904              
     3889
    39053890              return $v_result;
    39063891            }
    3907            
     3892
    39083893            // ----- Opening destination file
    39093894            if (($v_dest_file = @fopen($p_entry['filename'], 'wb')) == 0) {
    3910  
     3895
    39113896              // ----- Change the file status
    39123897              $p_entry['status'] = "write_error";
    3913  
     3898
    39143899              return $v_result;
    39153900            }
    3916  
     3901
    39173902            // ----- Write the uncompressed data
    39183903            @fwrite($v_dest_file, $v_file_content, $p_entry['size']);
    39193904            unset($v_file_content);
    3920  
     3905
    39213906            // ----- Closing the destination file
    39223907            @fclose($v_dest_file);
    3923            
     3908
    39243909          }
    39253910
     
    39383923    }
    39393924
    3940         // ----- Change abort status
    3941         if ($p_entry['status'] == "aborted") {
    3942         $p_entry['status'] = "skipped";
    3943         }
    3944        
    3945     // ----- Look for post-extract callback
     3925    // ----- Change abort status
     3926    if ($p_entry['status'] == "aborted") {
     3927      $p_entry['status'] = "skipped";
     3928    } // ----- Look for post-extract callback
    39463929    elseif (isset($p_options[PCLZIP_CB_POST_EXTRACT])) {
    39473930
     
    39583941      // ----- Look for abort result
    39593942      if ($v_result == 2) {
    3960         $v_result = PCLZIP_ERR_USER_ABORTED;
     3943        $v_result = PCLZIP_ERR_USER_ABORTED;
    39613944      }
    39623945    }
     
    39733956  // Return Values :
    39743957  // --------------------------------------------------------------------------------
    3975   function privExtractFileUsingTempFile(&$p_entry, &$p_options)
    3976   {
    3977     $v_result=1;
    3978        
     3958  public function privExtractFileUsingTempFile(&$p_entry, &$p_options) {
     3959    $v_result = 1;
     3960
    39793961    // ----- Creates a temporary file
    3980     $v_gzip_temp_name = PCLZIP_TEMPORARY_DIR.uniqid('pclzip-').'.gz';
     3962    $v_gzip_temp_name = PCLZIP_TEMPORARY_DIR . uniqid('pclzip-') . '.gz';
    39813963    if (($v_dest_file = @fopen($v_gzip_temp_name, "wb")) == 0) {
    39823964      fclose($v_file);
    3983       PclZip::privErrorLog(PCLZIP_ERR_WRITE_OPEN_FAIL, 'Unable to open temporary file \''.$v_gzip_temp_name.'\' in binary write mode');
     3965      PclZip::privErrorLog(PCLZIP_ERR_WRITE_OPEN_FAIL,
     3966          'Unable to open temporary file \'' . $v_gzip_temp_name . '\' in binary write mode');
     3967
    39843968      return PclZip::errorCode();
    39853969    }
     
    39923976    // ----- Read the file by PCLZIP_READ_BLOCK_SIZE octets blocks
    39933977    $v_size = $p_entry['compressed_size'];
    3994     while ($v_size != 0)
    3995     {
     3978    while ($v_size != 0) {
    39963979      $v_read_size = ($v_size < PCLZIP_READ_BLOCK_SIZE ? $v_size : PCLZIP_READ_BLOCK_SIZE);
    39973980      $v_buffer = @fread($this->zip_fd, $v_read_size);
     
    40113994    if (($v_dest_file = @fopen($p_entry['filename'], 'wb')) == 0) {
    40123995      $p_entry['status'] = "write_error";
     3996
    40133997      return $v_result;
    40143998    }
     
    40184002      @fclose($v_dest_file);
    40194003      $p_entry['status'] = "read_error";
    4020       PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, 'Unable to open temporary file \''.$v_gzip_temp_name.'\' in binary read mode');
     4004      PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL,
     4005          'Unable to open temporary file \'' . $v_gzip_temp_name . '\' in binary read mode');
     4006
    40214007      return PclZip::errorCode();
    40224008    }
     
    40374023    // ----- Delete the temporary file
    40384024    @unlink($v_gzip_temp_name);
    4039    
     4025
    40404026    // ----- Return
    40414027    return $v_result;
     
    40494035  // Return Values :
    40504036  // --------------------------------------------------------------------------------
    4051   function privExtractFileInOutput(&$p_entry, &$p_options)
    4052   {
    4053     $v_result=1;
     4037  public function privExtractFileInOutput(&$p_entry, &$p_options) {
     4038    $v_result = 1;
    40544039
    40554040    // ----- Read the file header
     
    40614046    // ----- Check that the file header is coherent with $p_entry info
    40624047    if ($this->privCheckFileHeaders($v_header, $p_entry) != 1) {
    4063         // TBC
     4048      // TBC
    40644049    }
    40654050
     
    40864071        // ----- This status is internal and will be changed in 'skipped'
    40874072        $p_entry['status'] = "aborted";
    4088         $v_result = PCLZIP_ERR_USER_ABORTED;
     4073        $v_result = PCLZIP_ERR_USER_ABORTED;
    40894074      }
    40904075
     
    41004085
    41014086      // ----- Do the extraction (if not a folder)
    4102       if (!(($p_entry['external']&0x00000010)==0x00000010)) {
     4087      if (!(($p_entry['external'] & 0x00000010) == 0x00000010)) {
    41034088        // ----- Look for not compressed file
    41044089        if ($p_entry['compressed_size'] == $p_entry['size']) {
     
    41104095          echo $v_buffer;
    41114096          unset($v_buffer);
    4112         }
    4113         else {
     4097        } else {
    41144098
    41154099          // ----- Read the compressed file in a buffer (one shot)
    41164100          $v_buffer = @fread($this->zip_fd, $p_entry['compressed_size']);
    4117          
     4101
    41184102          // ----- Decompress the file
    41194103          $v_file_content = gzinflate($v_buffer);
     
    41274111    }
    41284112
    4129         // ----- Change abort status
    4130         if ($p_entry['status'] == "aborted") {
     4113    // ----- Change abort status
     4114    if ($p_entry['status'] == "aborted") {
    41314115      $p_entry['status'] = "skipped";
    4132         }
    4133 
    4134     // ----- Look for post-extract callback
     4116    } // ----- Look for post-extract callback
    41354117    elseif (isset($p_options[PCLZIP_CB_POST_EXTRACT])) {
    41364118
     
    41474129      // ----- Look for abort result
    41484130      if ($v_result == 2) {
    4149         $v_result = PCLZIP_ERR_USER_ABORTED;
     4131        $v_result = PCLZIP_ERR_USER_ABORTED;
    41504132      }
    41514133    }
     
    41614143  // Return Values :
    41624144  // --------------------------------------------------------------------------------
    4163   function privExtractFileAsString(&$p_entry, &$p_string, &$p_options)
    4164   {
    4165     $v_result=1;
     4145  public function privExtractFileAsString(&$p_entry, &$p_string, &$p_options) {
     4146    $v_result = 1;
    41664147
    41674148    // ----- Read the file header
    41684149    $v_header = array();
    4169     if (($v_result = $this->privReadFileHeader($v_header)) != 1)
    4170     {
     4150    if (($v_result = $this->privReadFileHeader($v_header)) != 1) {
    41714151      // ----- Return
    41724152      return $v_result;
     
    41764156    // ----- Check that the file header is coherent with $p_entry info
    41774157    if ($this->privCheckFileHeaders($v_header, $p_entry) != 1) {
    4178         // TBC
     4158      // TBC
    41794159    }
    41804160
     
    41964176        $v_result = 1;
    41974177      }
    4198      
     4178
    41994179      // ----- Look for abort result
    42004180      if ($v_result == 2) {
    42014181        // ----- This status is internal and will be changed in 'skipped'
    42024182        $p_entry['status'] = "aborted";
    4203         $v_result = PCLZIP_ERR_USER_ABORTED;
     4183        $v_result = PCLZIP_ERR_USER_ABORTED;
    42044184      }
    42054185
     
    42144194
    42154195      // ----- Do the extraction (if not a folder)
    4216       if (!(($p_entry['external']&0x00000010)==0x00000010)) {
     4196      if (!(($p_entry['external'] & 0x00000010) == 0x00000010)) {
    42174197        // ----- Look for not compressed file
    4218   //      if ($p_entry['compressed_size'] == $p_entry['size'])
     4198        //      if ($p_entry['compressed_size'] == $p_entry['size'])
    42194199        if ($p_entry['compression'] == 0) {
    4220  
     4200
    42214201          // ----- Reading the file
    42224202          $p_string = @fread($this->zip_fd, $p_entry['compressed_size']);
    4223         }
    4224         else {
    4225  
     4203        } else {
     4204
    42264205          // ----- Reading the file
    42274206          $v_data = @fread($this->zip_fd, $p_entry['compressed_size']);
    4228          
     4207
    42294208          // ----- Decompress the file
    4230           if (($p_string = @gzinflate($v_data)) === FALSE) {
    4231               // TBC
    4232           }
    4233         }
    4234  
     4209          if (($p_string = @gzinflate($v_data)) === false) {
     4210            // TBC
     4211          }
     4212        }
     4213
    42354214        // ----- Trace
    4236       }
    4237       else {
    4238           // TBC : error : can not extract a folder in a string
    4239       }
    4240      
    4241     }
    4242 
    4243         // ----- Change abort status
    4244         if ($p_entry['status'] == "aborted") {
    4245         $p_entry['status'] = "skipped";
    4246         }
    4247        
    4248     // ----- Look for post-extract callback
     4215      } else {
     4216        // TBC : error : can not extract a folder in a string
     4217      }
     4218
     4219    }
     4220
     4221    // ----- Change abort status
     4222    if ($p_entry['status'] == "aborted") {
     4223      $p_entry['status'] = "skipped";
     4224    } // ----- Look for post-extract callback
    42494225    elseif (isset($p_options[PCLZIP_CB_POST_EXTRACT])) {
    42504226
     
    42524228      $v_local_header = array();
    42534229      $this->privConvertHeader2FileInfo($p_entry, $v_local_header);
    4254      
     4230
    42554231      // ----- Swap the content to header
    42564232      $v_local_header['content'] = $p_string;
     
    42694245      // ----- Look for abort result
    42704246      if ($v_result == 2) {
    4271         $v_result = PCLZIP_ERR_USER_ABORTED;
     4247        $v_result = PCLZIP_ERR_USER_ABORTED;
    42724248      }
    42734249    }
     
    42844260  // Return Values :
    42854261  // --------------------------------------------------------------------------------
    4286   function privReadFileHeader(&$p_header)
    4287   {
    4288     $v_result=1;
     4262  public function privReadFileHeader(&$p_header) {
     4263    $v_result = 1;
    42894264
    42904265    // ----- Read the 4 bytes signature
     
    42934268
    42944269    // ----- Check signature
    4295     if ($v_data['id'] != 0x04034b50)
    4296     {
     4270    if ($v_data['id'] != 0x04034b50) {
    42974271
    42984272      // ----- Error log
     
    43074281
    43084282    // ----- Look for invalid block size
    4309     if (strlen($v_binary_data) != 26)
    4310     {
     4283    if (strlen($v_binary_data) != 26) {
    43114284      $p_header['filename'] = "";
    43124285      $p_header['status'] = "invalid_header";
    43134286
    43144287      // ----- Error log
    4315       PclZip::privErrorLog(PCLZIP_ERR_BAD_FORMAT, "Invalid block size : ".strlen($v_binary_data));
     4288      PclZip::privErrorLog(PCLZIP_ERR_BAD_FORMAT, "Invalid block size : " . strlen($v_binary_data));
    43164289
    43174290      // ----- Return
     
    43204293
    43214294    // ----- Extract the values
    4322     $v_data = unpack('vversion/vflag/vcompression/vmtime/vmdate/Vcrc/Vcompressed_size/Vsize/vfilename_len/vextra_len', $v_binary_data);
     4295    $v_data = unpack('vversion/vflag/vcompression/vmtime/vmdate/Vcrc/Vcompressed_size/Vsize/vfilename_len/vextra_len',
     4296        $v_binary_data);
    43234297
    43244298    // ----- Get filename
     
    43284302    if ($v_data['extra_len'] != 0) {
    43294303      $p_header['extra'] = fread($this->zip_fd, $v_data['extra_len']);
    4330     }
    4331     else {
     4304    } else {
    43324305      $p_header['extra'] = '';
    43334306    }
     
    43454318    $p_header['mdate'] = $v_data['mdate'];
    43464319    $p_header['mtime'] = $v_data['mtime'];
    4347     if ($p_header['mdate'] && $p_header['mtime'])
    4348     {
     4320    if ($p_header['mdate'] && $p_header['mtime']) {
    43494321      // ----- Extract time
    43504322      $v_hour = ($p_header['mtime'] & 0xF800) >> 11;
    43514323      $v_minute = ($p_header['mtime'] & 0x07E0) >> 5;
    4352       $v_seconde = ($p_header['mtime'] & 0x001F)*2;
     4324      $v_seconde = ($p_header['mtime'] & 0x001F) * 2;
    43534325
    43544326      // ----- Extract date
     
    43604332      $p_header['mtime'] = @mktime($v_hour, $v_minute, $v_seconde, $v_month, $v_day, $v_year);
    43614333
    4362     }
    4363     else
    4364     {
     4334    } else {
    43654335      $p_header['mtime'] = time();
    43664336    }
     
    43874357  // Return Values :
    43884358  // --------------------------------------------------------------------------------
    4389   function privReadCentralFileHeader(&$p_header)
    4390   {
    4391     $v_result=1;
     4359  public function privReadCentralFileHeader(&$p_header) {
     4360    $v_result = 1;
    43924361
    43934362    // ----- Read the 4 bytes signature
     
    43964365
    43974366    // ----- Check signature
    4398     if ($v_data['id'] != 0x02014b50)
    4399     {
     4367    if ($v_data['id'] != 0x02014b50) {
    44004368
    44014369      // ----- Error log
     
    44104378
    44114379    // ----- Look for invalid block size
    4412     if (strlen($v_binary_data) != 42)
    4413     {
     4380    if (strlen($v_binary_data) != 42) {
    44144381      $p_header['filename'] = "";
    44154382      $p_header['status'] = "invalid_header";
    44164383
    44174384      // ----- Error log
    4418       PclZip::privErrorLog(PCLZIP_ERR_BAD_FORMAT, "Invalid block size : ".strlen($v_binary_data));
     4385      PclZip::privErrorLog(PCLZIP_ERR_BAD_FORMAT, "Invalid block size : " . strlen($v_binary_data));
    44194386
    44204387      // ----- Return
     
    44234390
    44244391    // ----- Extract the values
    4425     $p_header = unpack('vversion/vversion_extracted/vflag/vcompression/vmtime/vmdate/Vcrc/Vcompressed_size/Vsize/vfilename_len/vextra_len/vcomment_len/vdisk/vinternal/Vexternal/Voffset', $v_binary_data);
     4392    $p_header = unpack('vversion/vversion_extracted/vflag/vcompression/vmtime/vmdate/Vcrc/Vcompressed_size/Vsize/vfilename_len/vextra_len/vcomment_len/vdisk/vinternal/Vexternal/Voffset',
     4393        $v_binary_data);
    44264394
    44274395    // ----- Get filename
    4428     if ($p_header['filename_len'] != 0)
     4396    if ($p_header['filename_len'] != 0) {
    44294397      $p_header['filename'] = fread($this->zip_fd, $p_header['filename_len']);
    4430     else
     4398    } else {
    44314399      $p_header['filename'] = '';
     4400    }
    44324401
    44334402    // ----- Get extra
    4434     if ($p_header['extra_len'] != 0)
     4403    if ($p_header['extra_len'] != 0) {
    44354404      $p_header['extra'] = fread($this->zip_fd, $p_header['extra_len']);
    4436     else
     4405    } else {
    44374406      $p_header['extra'] = '';
     4407    }
    44384408
    44394409    // ----- Get comment
    4440     if ($p_header['comment_len'] != 0)
     4410    if ($p_header['comment_len'] != 0) {
    44414411      $p_header['comment'] = fread($this->zip_fd, $p_header['comment_len']);
    4442     else
     4412    } else {
    44434413      $p_header['comment'] = '';
     4414    }
    44444415
    44454416    // ----- Extract properties
     
    44484419    //if ($p_header['mdate'] && $p_header['mtime'])
    44494420    // TBC : bug : this was ignoring time with 0/0/0
    4450     if (1)
    4451     {
     4421    if (1) {
    44524422      // ----- Extract time
    44534423      $v_hour = ($p_header['mtime'] & 0xF800) >> 11;
    44544424      $v_minute = ($p_header['mtime'] & 0x07E0) >> 5;
    4455       $v_seconde = ($p_header['mtime'] & 0x001F)*2;
     4425      $v_seconde = ($p_header['mtime'] & 0x001F) * 2;
    44564426
    44574427      // ----- Extract date
     
    44634433      $p_header['mtime'] = @mktime($v_hour, $v_minute, $v_seconde, $v_month, $v_day, $v_year);
    44644434
    4465     }
    4466     else
    4467     {
     4435    } else {
    44684436      $p_header['mtime'] = time();
    44694437    }
     
    44954463  //   0 on error;
    44964464  // --------------------------------------------------------------------------------
    4497   function privCheckFileHeaders(&$p_local_header, &$p_central_header)
    4498   {
    4499     $v_result=1;
    4500 
    4501         // ----- Check the static values
    4502         // TBC
    4503         if ($p_local_header['filename'] != $p_central_header['filename']) {
    4504         }
    4505         if ($p_local_header['version_extracted'] != $p_central_header['version_extracted']) {
    4506         }
    4507         if ($p_local_header['flag'] != $p_central_header['flag']) {
    4508         }
    4509         if ($p_local_header['compression'] != $p_central_header['compression']) {
    4510         }
    4511         if ($p_local_header['mtime'] != $p_central_header['mtime']) {
    4512         }
    4513         if ($p_local_header['filename_len'] != $p_central_header['filename_len']) {
    4514         }
    4515  
    4516         // ----- Look for flag bit 3
    4517         if (($p_local_header['flag'] & 8) == 8) {
    4518           $p_local_header['size'] = $p_central_header['size'];
    4519           $p_local_header['compressed_size'] = $p_central_header['compressed_size'];
    4520           $p_local_header['crc'] = $p_central_header['crc'];
    4521         }
     4465  public function privCheckFileHeaders(&$p_local_header, &$p_central_header) {
     4466    $v_result = 1;
     4467
     4468    // ----- Check the static values
     4469    // TBC
     4470    if ($p_local_header['filename'] != $p_central_header['filename']) {
     4471    }
     4472    if ($p_local_header['version_extracted'] != $p_central_header['version_extracted']) {
     4473    }
     4474    if ($p_local_header['flag'] != $p_central_header['flag']) {
     4475    }
     4476    if ($p_local_header['compression'] != $p_central_header['compression']) {
     4477    }
     4478    if ($p_local_header['mtime'] != $p_central_header['mtime']) {
     4479    }
     4480    if ($p_local_header['filename_len'] != $p_central_header['filename_len']) {
     4481    }
     4482
     4483    // ----- Look for flag bit 3
     4484    if (($p_local_header['flag'] & 8) == 8) {
     4485      $p_local_header['size'] = $p_central_header['size'];
     4486      $p_local_header['compressed_size'] = $p_central_header['compressed_size'];
     4487      $p_local_header['crc'] = $p_central_header['crc'];
     4488    }
    45224489
    45234490    // ----- Return
     
    45324499  // Return Values :
    45334500  // --------------------------------------------------------------------------------
    4534   function privReadEndCentralDir(&$p_central_dir)
    4535   {
    4536     $v_result=1;
     4501  public function privReadEndCentralDir(&$p_central_dir) {
     4502    $v_result = 1;
    45374503
    45384504    // ----- Go to the end of the zip file
    45394505    $v_size = filesize($this->zipname);
    45404506    @fseek($this->zip_fd, $v_size);
    4541     if (@ftell($this->zip_fd) != $v_size)
    4542     {
     4507    if (@ftell($this->zip_fd) != $v_size) {
    45434508      // ----- Error log
    4544       PclZip::privErrorLog(PCLZIP_ERR_BAD_FORMAT, 'Unable to go to the end of the archive \''.$this->zipname.'\'');
     4509      PclZip::privErrorLog(PCLZIP_ERR_BAD_FORMAT, 'Unable to go to the end of the archive \'' . $this->zipname . '\'');
    45454510
    45464511      // ----- Return
     
    45524517    $v_found = 0;
    45534518    if ($v_size > 26) {
    4554       @fseek($this->zip_fd, $v_size-22);
    4555       if (($v_pos = @ftell($this->zip_fd)) != ($v_size-22))
    4556       {
     4519      @fseek($this->zip_fd, $v_size - 22);
     4520      if (($v_pos = @ftell($this->zip_fd)) != ($v_size - 22)) {
    45574521        // ----- Error log
    4558         PclZip::privErrorLog(PCLZIP_ERR_BAD_FORMAT, 'Unable to seek back to the middle of the archive \''.$this->zipname.'\'');
     4522        PclZip::privErrorLog(PCLZIP_ERR_BAD_FORMAT,
     4523            'Unable to seek back to the middle of the archive \'' . $this->zipname . '\'');
    45594524
    45604525        // ----- Return
     
    45774542    if (!$v_found) {
    45784543      $v_maximum_size = 65557; // 0xFFFF + 22;
    4579       if ($v_maximum_size > $v_size)
     4544      if ($v_maximum_size > $v_size) {
    45804545        $v_maximum_size = $v_size;
    4581       @fseek($this->zip_fd, $v_size-$v_maximum_size);
    4582       if (@ftell($this->zip_fd) != ($v_size-$v_maximum_size))
    4583       {
     4546      }
     4547      @fseek($this->zip_fd, $v_size - $v_maximum_size);
     4548      if (@ftell($this->zip_fd) != ($v_size - $v_maximum_size)) {
    45844549        // ----- Error log
    4585         PclZip::privErrorLog(PCLZIP_ERR_BAD_FORMAT, 'Unable to seek back to the middle of the archive \''.$this->zipname.'\'');
     4550        PclZip::privErrorLog(PCLZIP_ERR_BAD_FORMAT,
     4551            'Unable to seek back to the middle of the archive \'' . $this->zipname . '\'');
    45864552
    45874553        // ----- Return
     
    45924558      $v_pos = ftell($this->zip_fd);
    45934559      $v_bytes = 0x00000000;
    4594       while ($v_pos < $v_size)
    4595       {
     4560      while ($v_pos < $v_size) {
    45964561        // ----- Read a byte
    45974562        $v_byte = @fread($this->zip_fd, 1);
     
    45994564        // -----  Add the byte
    46004565        //$v_bytes = ($v_bytes << 8) | Ord($v_byte);
    4601         // Note we mask the old value down such that once shifted we can never end up with more than a 32bit number 
    4602         // Otherwise on systems where we have 64bit integers the check below for the magic number will fail. 
    4603         $v_bytes = ( ($v_bytes & 0xFFFFFF) << 8) | Ord($v_byte);
     4566        // Note we mask the old value down such that once shifted we can never end up with more than a 32bit number
     4567        // Otherwise on systems where we have 64bit integers the check below for the magic number will fail.
     4568        $v_bytes = (($v_bytes & 0xFFFFFF) << 8) | Ord($v_byte);
    46044569
    46054570        // ----- Compare the bytes
    4606         if ($v_bytes == 0x504b0506)
    4607         {
     4571        if ($v_bytes == 0x504b0506) {
    46084572          $v_pos++;
    46094573          break;
     
    46144578
    46154579      // ----- Look if not found end of central dir
    4616       if ($v_pos == $v_size)
    4617       {
     4580      if ($v_pos == $v_size) {
    46184581
    46194582        // ----- Error log
     
    46294592
    46304593    // ----- Look for invalid block size
    4631     if (strlen($v_binary_data) != 18)
    4632     {
     4594    if (strlen($v_binary_data) != 18) {
    46334595
    46344596      // ----- Error log
    4635       PclZip::privErrorLog(PCLZIP_ERR_BAD_FORMAT, "Invalid End of Central Dir Record size : ".strlen($v_binary_data));
     4597      PclZip::privErrorLog(PCLZIP_ERR_BAD_FORMAT, "Invalid End of Central Dir Record size : " . strlen($v_binary_data));
    46364598
    46374599      // ----- Return
     
    46454607    if (($v_pos + $v_data['comment_size'] + 18) != $v_size) {
    46464608
    4647           // ----- Removed in release 2.2 see readme file
    4648           // The check of the file size is a little too strict.
    4649           // Some bugs where found when a zip is encrypted/decrypted with 'crypt'.
    4650           // While decrypted, zip has training 0 bytes
    4651           if (0) {
    4652       // ----- Error log
    4653       PclZip::privErrorLog(PCLZIP_ERR_BAD_FORMAT,
    4654                                'The central dir is not at the end of the archive.'
    4655                                                    .' Some trailing bytes exists after the archive.');
    4656 
    4657       // ----- Return
    4658       return PclZip::errorCode();
    4659           }
     4609      // ----- Removed in release 2.2 see readme file
     4610      // The check of the file size is a little too strict.
     4611      // Some bugs where found when a zip is encrypted/decrypted with 'crypt'.
     4612      // While decrypted, zip has training 0 bytes
     4613      if (0) {
     4614        // ----- Error log
     4615        PclZip::privErrorLog(PCLZIP_ERR_BAD_FORMAT,
     4616            'The central dir is not at the end of the archive.'
     4617            . ' Some trailing bytes exists after the archive.');
     4618
     4619        // ----- Return
     4620        return PclZip::errorCode();
     4621      }
    46604622    }
    46614623
     
    46634625    if ($v_data['comment_size'] != 0) {
    46644626      $p_central_dir['comment'] = fread($this->zip_fd, $v_data['comment_size']);
    4665     }
    4666     else
     4627    } else {
    46674628      $p_central_dir['comment'] = '';
     4629    }
    46684630
    46694631    $p_central_dir['entries'] = $v_data['entries'];
     
    46894651  // Return Values :
    46904652  // --------------------------------------------------------------------------------
    4691   function privDeleteByRule(&$p_result_list, &$p_options)
    4692   {
    4693     $v_result=1;
     4653  public function privDeleteByRule(&$p_result_list, &$p_options) {
     4654    $v_result = 1;
    46944655    $v_list_detail = array();
    46954656
    46964657    // ----- Open the zip file
    4697     if (($v_result=$this->privOpenFd('rb')) != 1)
    4698     {
     4658    if (($v_result = $this->privOpenFd('rb')) != 1) {
    46994659      // ----- Return
    47004660      return $v_result;
     
    47034663    // ----- Read the central directory informations
    47044664    $v_central_dir = array();
    4705     if (($v_result = $this->privReadEndCentralDir($v_central_dir)) != 1)
    4706     {
     4665    if (($v_result = $this->privReadEndCentralDir($v_central_dir)) != 1) {
    47074666      $this->privCloseFd();
     4667
    47084668      return $v_result;
    47094669    }
     
    47164676    $v_pos_entry = $v_central_dir['offset'];
    47174677    @rewind($this->zip_fd);
    4718     if (@fseek($this->zip_fd, $v_pos_entry))
    4719     {
     4678    if (@fseek($this->zip_fd, $v_pos_entry)) {
    47204679      // ----- Close the zip file
    47214680      $this->privCloseFd();
     
    47314690    $v_header_list = array();
    47324691    $j_start = 0;
    4733     for ($i=0, $v_nb_extracted=0; $i<$v_central_dir['entries']; $i++)
    4734     {
     4692    for ($i = 0, $v_nb_extracted = 0; $i < $v_central_dir['entries']; $i++) {
    47354693
    47364694      // ----- Read the file header
    47374695      $v_header_list[$v_nb_extracted] = array();
    4738       if (($v_result = $this->privReadCentralFileHeader($v_header_list[$v_nb_extracted])) != 1)
    4739       {
     4696      if (($v_result = $this->privReadCentralFileHeader($v_header_list[$v_nb_extracted])) != 1) {
    47404697        // ----- Close the zip file
    47414698        $this->privCloseFd();
     
    47524709
    47534710      // ----- Look for extract by name rule
    4754       if (   (isset($p_options[PCLZIP_OPT_BY_NAME]))
    4755           && ($p_options[PCLZIP_OPT_BY_NAME] != 0)) {
    4756 
    4757           // ----- Look if the filename is in the list
    4758           for ($j=0; ($j<sizeof($p_options[PCLZIP_OPT_BY_NAME])) && (!$v_found); $j++) {
    4759 
    4760               // ----- Look for a directory
    4761               if (substr($p_options[PCLZIP_OPT_BY_NAME][$j], -1) == "/") {
    4762 
    4763                   // ----- Look if the directory is in the filename path
    4764                   if (   (strlen($v_header_list[$v_nb_extracted]['stored_filename']) > strlen($p_options[PCLZIP_OPT_BY_NAME][$j]))
    4765                       && (substr($v_header_list[$v_nb_extracted]['stored_filename'], 0, strlen($p_options[PCLZIP_OPT_BY_NAME][$j])) == $p_options[PCLZIP_OPT_BY_NAME][$j])) {
    4766                       $v_found = true;
    4767                   }
    4768                   elseif (   (($v_header_list[$v_nb_extracted]['external']&0x00000010)==0x00000010) /* Indicates a folder */
    4769                           && ($v_header_list[$v_nb_extracted]['stored_filename'].'/' == $p_options[PCLZIP_OPT_BY_NAME][$j])) {
    4770                       $v_found = true;
    4771                   }
    4772               }
    4773               // ----- Look for a filename
    4774               elseif ($v_header_list[$v_nb_extracted]['stored_filename'] == $p_options[PCLZIP_OPT_BY_NAME][$j]) {
    4775                   $v_found = true;
    4776               }
    4777           }
     4711      if ((isset($p_options[PCLZIP_OPT_BY_NAME]))
     4712          && ($p_options[PCLZIP_OPT_BY_NAME] != 0)
     4713      ) {
     4714
     4715        // ----- Look if the filename is in the list
     4716        for ($j = 0; ($j < sizeof($p_options[PCLZIP_OPT_BY_NAME])) && (!$v_found); $j++) {
     4717
     4718          // ----- Look for a directory
     4719          if (substr($p_options[PCLZIP_OPT_BY_NAME][$j], -1) == "/") {
     4720
     4721            // ----- Look if the directory is in the filename path
     4722            if ((strlen($v_header_list[$v_nb_extracted]['stored_filename']) > strlen($p_options[PCLZIP_OPT_BY_NAME][$j]))
     4723                && (substr($v_header_list[$v_nb_extracted]['stored_filename'], 0,
     4724                        strlen($p_options[PCLZIP_OPT_BY_NAME][$j])) == $p_options[PCLZIP_OPT_BY_NAME][$j])
     4725            ) {
     4726              $v_found = true;
     4727            } elseif ((($v_header_list[$v_nb_extracted]['external'] & 0x00000010) == 0x00000010) /* Indicates a folder */
     4728                && ($v_header_list[$v_nb_extracted]['stored_filename'] . '/' == $p_options[PCLZIP_OPT_BY_NAME][$j])
     4729            ) {
     4730              $v_found = true;
     4731            }
     4732          } // ----- Look for a filename
     4733          elseif ($v_header_list[$v_nb_extracted]['stored_filename'] == $p_options[PCLZIP_OPT_BY_NAME][$j]) {
     4734            $v_found = true;
     4735          }
     4736        }
    47784737      }
    47794738
     
    47914750
    47924751      // ----- Look for extract by preg rule
    4793       else if (   (isset($p_options[PCLZIP_OPT_BY_PREG]))
    4794                && ($p_options[PCLZIP_OPT_BY_PREG] != "")) {
     4752      else {
     4753        if ((isset($p_options[PCLZIP_OPT_BY_PREG]))
     4754            && ($p_options[PCLZIP_OPT_BY_PREG] != "")
     4755        ) {
    47954756
    47964757          if (preg_match($p_options[PCLZIP_OPT_BY_PREG], $v_header_list[$v_nb_extracted]['stored_filename'])) {
    4797               $v_found = true;
    4798           }
    4799       }
    4800 
    4801       // ----- Look for extract by index rule
    4802       else if (   (isset($p_options[PCLZIP_OPT_BY_INDEX]))
    4803                && ($p_options[PCLZIP_OPT_BY_INDEX] != 0)) {
    4804 
    4805           // ----- Look if the index is in the list
    4806           for ($j=$j_start; ($j<sizeof($p_options[PCLZIP_OPT_BY_INDEX])) && (!$v_found); $j++) {
    4807 
    4808               if (($i>=$p_options[PCLZIP_OPT_BY_INDEX][$j]['start']) && ($i<=$p_options[PCLZIP_OPT_BY_INDEX][$j]['end'])) {
    4809                   $v_found = true;
     4758            $v_found = true;
     4759          }
     4760        } // ----- Look for extract by index rule
     4761        else {
     4762          if ((isset($p_options[PCLZIP_OPT_BY_INDEX]))
     4763              && ($p_options[PCLZIP_OPT_BY_INDEX] != 0)
     4764          ) {
     4765
     4766            // ----- Look if the index is in the list
     4767            for ($j = $j_start; ($j < sizeof($p_options[PCLZIP_OPT_BY_INDEX])) && (!$v_found); $j++) {
     4768
     4769              if (($i >= $p_options[PCLZIP_OPT_BY_INDEX][$j]['start']) && ($i <= $p_options[PCLZIP_OPT_BY_INDEX][$j]['end'])) {
     4770                $v_found = true;
    48104771              }
    4811               if ($i>=$p_options[PCLZIP_OPT_BY_INDEX][$j]['end']) {
    4812                   $j_start = $j+1;
     4772              if ($i >= $p_options[PCLZIP_OPT_BY_INDEX][$j]['end']) {
     4773                $j_start = $j + 1;
    48134774              }
    48144775
    4815               if ($p_options[PCLZIP_OPT_BY_INDEX][$j]['start']>$i) {
    4816                   break;
     4776              if ($p_options[PCLZIP_OPT_BY_INDEX][$j]['start'] > $i) {
     4777                break;
    48174778              }
    4818           }
    4819       }
    4820       else {
    4821         $v_found = true;
     4779            }
     4780          } else {
     4781            $v_found = true;
     4782          }
     4783        }
    48224784      }
    48234785
    48244786      // ----- Look for deletion
    4825       if ($v_found)
    4826       {
     4787      if ($v_found) {
    48274788        unset($v_header_list[$v_nb_extracted]);
    4828       }
    4829       else
    4830       {
     4789      } else {
    48314790        $v_nb_extracted++;
    48324791      }
     
    48364795    if ($v_nb_extracted > 0) {
    48374796
    4838         // ----- Creates a temporay file
    4839         $v_zip_temp_name = PCLZIP_TEMPORARY_DIR.uniqid('pclzip-').'.tmp';
    4840 
    4841         // ----- Creates a temporary zip archive
    4842         $v_temp_zip = new PclZip($v_zip_temp_name);
    4843 
    4844         // ----- Open the temporary zip file in write mode
    4845         if (($v_result = $v_temp_zip->privOpenFd('wb')) != 1) {
    4846             $this->privCloseFd();
    4847 
    4848             // ----- Return
    4849             return $v_result;
    4850         }
    4851 
    4852         // ----- Look which file need to be kept
    4853         for ($i=0; $i<sizeof($v_header_list); $i++) {
    4854 
    4855             // ----- Calculate the position of the header
    4856             @rewind($this->zip_fd);
    4857             if (@fseek($this->zip_fd,  $v_header_list[$i]['offset'])) {
    4858                 // ----- Close the zip file
    4859                 $this->privCloseFd();
    4860                 $v_temp_zip->privCloseFd();
    4861                 @unlink($v_zip_temp_name);
    4862 
    4863                 // ----- Error log
    4864                 PclZip::privErrorLog(PCLZIP_ERR_INVALID_ARCHIVE_ZIP, 'Invalid archive size');
    4865 
    4866                 // ----- Return
    4867                 return PclZip::errorCode();
    4868             }
    4869 
    4870             // ----- Read the file header
    4871             $v_local_header = array();
    4872             if (($v_result = $this->privReadFileHeader($v_local_header)) != 1) {
    4873                 // ----- Close the zip file
    4874                 $this->privCloseFd();
    4875                 $v_temp_zip->privCloseFd();
    4876                 @unlink($v_zip_temp_name);
    4877 
    4878                 // ----- Return
    4879                 return $v_result;
    4880             }
    4881            
    4882             // ----- Check that local file header is same as central file header
    4883             if ($this->privCheckFileHeaders($v_local_header,
    4884                                                         $v_header_list[$i]) != 1) {
    4885                 // TBC
    4886             }
    4887             unset($v_local_header);
    4888 
    4889             // ----- Write the file header
    4890             if (($v_result = $v_temp_zip->privWriteFileHeader($v_header_list[$i])) != 1) {
    4891                 // ----- Close the zip file
    4892                 $this->privCloseFd();
    4893                 $v_temp_zip->privCloseFd();
    4894                 @unlink($v_zip_temp_name);
    4895 
    4896                 // ----- Return
    4897                 return $v_result;
    4898             }
    4899 
    4900             // ----- Read/write the data block
    4901             if (($v_result = PclZipUtilCopyBlock($this->zip_fd, $v_temp_zip->zip_fd, $v_header_list[$i]['compressed_size'])) != 1) {
    4902                 // ----- Close the zip file
    4903                 $this->privCloseFd();
    4904                 $v_temp_zip->privCloseFd();
    4905                 @unlink($v_zip_temp_name);
    4906 
    4907                 // ----- Return
    4908                 return $v_result;
    4909             }
    4910         }
    4911 
    4912         // ----- Store the offset of the central dir
    4913         $v_offset = @ftell($v_temp_zip->zip_fd);
    4914 
    4915         // ----- Re-Create the Central Dir files header
    4916         for ($i=0; $i<sizeof($v_header_list); $i++) {
    4917             // ----- Create the file header
    4918             if (($v_result = $v_temp_zip->privWriteCentralFileHeader($v_header_list[$i])) != 1) {
    4919                 $v_temp_zip->privCloseFd();
    4920                 $this->privCloseFd();
    4921                 @unlink($v_zip_temp_name);
    4922 
    4923                 // ----- Return
    4924                 return $v_result;
    4925             }
    4926 
    4927             // ----- Transform the header to a 'usable' info
    4928             $v_temp_zip->privConvertHeader2FileInfo($v_header_list[$i], $p_result_list[$i]);
    4929         }
    4930 
    4931 
    4932         // ----- Zip file comment
    4933         $v_comment = '';
    4934         if (isset($p_options[PCLZIP_OPT_COMMENT])) {
    4935           $v_comment = $p_options[PCLZIP_OPT_COMMENT];
    4936         }
    4937 
    4938         // ----- Calculate the size of the central header
    4939         $v_size = @ftell($v_temp_zip->zip_fd)-$v_offset;
    4940 
    4941         // ----- Create the central dir footer
    4942         if (($v_result = $v_temp_zip->privWriteCentralHeader(sizeof($v_header_list), $v_size, $v_offset, $v_comment)) != 1) {
    4943             // ----- Reset the file list
    4944             unset($v_header_list);
    4945             $v_temp_zip->privCloseFd();
    4946             $this->privCloseFd();
    4947             @unlink($v_zip_temp_name);
    4948 
    4949             // ----- Return
    4950             return $v_result;
    4951         }
    4952 
    4953         // ----- Close
     4797      // ----- Creates a temporay file
     4798      $v_zip_temp_name = PCLZIP_TEMPORARY_DIR . uniqid('pclzip-') . '.tmp';
     4799
     4800      // ----- Creates a temporary zip archive
     4801      $v_temp_zip = new PclZip($v_zip_temp_name);
     4802
     4803      // ----- Open the temporary zip file in write mode
     4804      if (($v_result = $v_temp_zip->privOpenFd('wb')) != 1) {
     4805        $this->privCloseFd();
     4806
     4807        // ----- Return
     4808        return $v_result;
     4809      }
     4810
     4811      // ----- Look which file need to be kept
     4812      for ($i = 0; $i < sizeof($v_header_list); $i++) {
     4813
     4814        // ----- Calculate the position of the header
     4815        @rewind($this->zip_fd);
     4816        if (@fseek($this->zip_fd, $v_header_list[$i]['offset'])) {
     4817          // ----- Close the zip file
     4818          $this->privCloseFd();
     4819          $v_temp_zip->privCloseFd();
     4820          @unlink($v_zip_temp_name);
     4821
     4822          // ----- Error log
     4823          PclZip::privErrorLog(PCLZIP_ERR_INVALID_ARCHIVE_ZIP, 'Invalid archive size');
     4824
     4825          // ----- Return
     4826          return PclZip::errorCode();
     4827        }
     4828
     4829        // ----- Read the file header
     4830        $v_local_header = array();
     4831        if (($v_result = $this->privReadFileHeader($v_local_header)) != 1) {
     4832          // ----- Close the zip file
     4833          $this->privCloseFd();
     4834          $v_temp_zip->privCloseFd();
     4835          @unlink($v_zip_temp_name);
     4836
     4837          // ----- Return
     4838          return $v_result;
     4839        }
     4840
     4841        // ----- Check that local file header is same as central file header
     4842        if ($this->privCheckFileHeaders($v_local_header,
     4843                $v_header_list[$i]) != 1
     4844        ) {
     4845          // TBC
     4846        }
     4847        unset($v_local_header);
     4848
     4849        // ----- Write the file header
     4850        if (($v_result = $v_temp_zip->privWriteFileHeader($v_header_list[$i])) != 1) {
     4851          // ----- Close the zip file
     4852          $this->privCloseFd();
     4853          $v_temp_zip->privCloseFd();
     4854          @unlink($v_zip_temp_name);
     4855
     4856          // ----- Return
     4857          return $v_result;
     4858        }
     4859
     4860        // ----- Read/write the data block
     4861        if (($v_result = PclZipUtilCopyBlock($this->zip_fd, $v_temp_zip->zip_fd,
     4862                $v_header_list[$i]['compressed_size'])) != 1
     4863        ) {
     4864          // ----- Close the zip file
     4865          $this->privCloseFd();
     4866          $v_temp_zip->privCloseFd();
     4867          @unlink($v_zip_temp_name);
     4868
     4869          // ----- Return
     4870          return $v_result;
     4871        }
     4872      }
     4873
     4874      // ----- Store the offset of the central dir
     4875      $v_offset = @ftell($v_temp_zip->zip_fd);
     4876
     4877      // ----- Re-Create the Central Dir files header
     4878      for ($i = 0; $i < sizeof($v_header_list); $i++) {
     4879        // ----- Create the file header
     4880        if (($v_result = $v_temp_zip->privWriteCentralFileHeader($v_header_list[$i])) != 1) {
     4881          $v_temp_zip->privCloseFd();
     4882          $this->privCloseFd();
     4883          @unlink($v_zip_temp_name);
     4884
     4885          // ----- Return
     4886          return $v_result;
     4887        }
     4888
     4889        // ----- Transform the header to a 'usable' info
     4890        $v_temp_zip->privConvertHeader2FileInfo($v_header_list[$i], $p_result_list[$i]);
     4891      }
     4892
     4893
     4894      // ----- Zip file comment
     4895      $v_comment = '';
     4896      if (isset($p_options[PCLZIP_OPT_COMMENT])) {
     4897        $v_comment = $p_options[PCLZIP_OPT_COMMENT];
     4898      }
     4899
     4900      // ----- Calculate the size of the central header
     4901      $v_size = @ftell($v_temp_zip->zip_fd) - $v_offset;
     4902
     4903      // ----- Create the central dir footer
     4904      if (($v_result = $v_temp_zip->privWriteCentralHeader(sizeof($v_header_list), $v_size, $v_offset,
     4905              $v_comment)) != 1
     4906      ) {
     4907        // ----- Reset the file list
     4908        unset($v_header_list);
    49544909        $v_temp_zip->privCloseFd();
    49554910        $this->privCloseFd();
    4956 
    4957         // ----- Delete the zip file
    4958         // TBC : I should test the result ...
    4959         @unlink($this->zipname);
    4960 
    4961         // ----- Rename the temporary file
    4962         // TBC : I should test the result ...
    4963         //@rename($v_zip_temp_name, $this->zipname);
    4964         PclZipUtilRename($v_zip_temp_name, $this->zipname);
    4965    
    4966         // ----- Destroy the temporary archive
    4967         unset($v_temp_zip);
    4968     }
    4969    
    4970     // ----- Remove every files : reset the file
    4971     else if ($v_central_dir['entries'] != 0) {
     4911        @unlink($v_zip_temp_name);
     4912
     4913        // ----- Return
     4914        return $v_result;
     4915      }
     4916
     4917      // ----- Close
     4918      $v_temp_zip->privCloseFd();
     4919      $this->privCloseFd();
     4920
     4921      // ----- Delete the zip file
     4922      // TBC : I should test the result ...
     4923      @unlink($this->zipname);
     4924
     4925      // ----- Rename the temporary file
     4926      // TBC : I should test the result ...
     4927      //@rename($v_zip_temp_name, $this->zipname);
     4928      PclZipUtilRename($v_zip_temp_name, $this->zipname);
     4929
     4930      // ----- Destroy the temporary archive
     4931      unset($v_temp_zip);
     4932    } // ----- Remove every files : reset the file
     4933    else {
     4934      if ($v_central_dir['entries'] != 0) {
    49724935        $this->privCloseFd();
    49734936
     
    49814944
    49824945        $this->privCloseFd();
     4946      }
    49834947    }
    49844948
     
    49994963  //   -1 : Unable to create directory
    50004964  // --------------------------------------------------------------------------------
    5001   function privDirCheck($p_dir, $p_is_dir=false)
    5002   {
     4965  public function privDirCheck($p_dir, $p_is_dir = false) {
    50034966    $v_result = 1;
    50044967
    50054968
    50064969    // ----- Remove the final '/'
    5007     if (($p_is_dir) && (substr($p_dir, -1)=='/'))
    5008     {
    5009       $p_dir = substr($p_dir, 0, strlen($p_dir)-1);
     4970    if (($p_is_dir) && (substr($p_dir, -1) == '/')) {
     4971      $p_dir = substr($p_dir, 0, strlen($p_dir) - 1);
    50104972    }
    50114973
    50124974    // ----- Check the directory availability
    5013     if ((is_dir($p_dir)) || ($p_dir == ""))
    5014     {
     4975    if ((is_dir($p_dir)) || ($p_dir == "")) {
    50154976      return 1;
    50164977    }
     
    50204981
    50214982    // ----- Just a check
    5022     if ($p_parent_dir != $p_dir)
    5023     {
     4983    if ($p_parent_dir != $p_dir) {
    50244984      // ----- Look for parent directory
    5025       if ($p_parent_dir != "")
    5026       {
    5027         if (($v_result = $this->privDirCheck($p_parent_dir)) != 1)
    5028         {
     4985      if ($p_parent_dir != "") {
     4986        if (($v_result = $this->privDirCheck($p_parent_dir)) != 1) {
    50294987          return $v_result;
    50304988        }
     
    50334991
    50344992    // ----- Create the directory
    5035     if (!@mkdir($p_dir, 0777))
    5036     {
     4993    if (!@mkdir($p_dir, 0777)) {
    50374994      // ----- Error log
    50384995      PclZip::privErrorLog(PCLZIP_ERR_DIR_CREATE_FAIL, "Unable to create directory '$p_dir'");
     
    50545011  // Return Values :
    50555012  // --------------------------------------------------------------------------------
    5056   function privMerge(&$p_archive_to_add)
    5057   {
    5058     $v_result=1;
     5013  public function privMerge(&$p_archive_to_add) {
     5014    $v_result = 1;
    50595015
    50605016    // ----- Look if the archive_to_add exists
    5061     if (!is_file($p_archive_to_add->zipname))
    5062     {
     5017    if (!is_file($p_archive_to_add->zipname)) {
    50635018
    50645019      // ----- Nothing to merge, so merge is a success
     
    50705025
    50715026    // ----- Look if the archive exists