WordPress.org

Make WordPress Core

Changeset 12042


Ignore:
Timestamp:
10/15/09 20:26:21 (5 years ago)
Author:
ryan
Message:

Associate subdirector of whitespace trims trailing whites with pinking shears.

Location:
trunk
Files:
12 edited

Legend:

Unmodified
Added
Removed
  • trunk/wp-admin/includes/class-pclzip.php

    r11993 r12042  
    3030    define( 'PCLZIP_READ_BLOCK_SIZE', 2048 ); 
    3131  } 
    32    
     32 
    3333  // ----- File list separator 
    3434  // In version 1.x of PclZip, the separator for file list is a space 
     
    6969  // ----- Optional threshold ratio for use of temporary files 
    7070  //       Pclzip sense the size of the file to add/extract and decide to 
    71   //       use or not temporary file. The algorythm is looking for  
     71  //       use or not temporary file. The algorythm is looking for 
    7272  //       memory_limit of PHP and apply a ratio. 
    7373  //       threshold = memory_limit * ratio. 
     
    153153  define( 'PCLZIP_OPT_TEMP_FILE_OFF', 77022 ); 
    154154  define( 'PCLZIP_OPT_ADD_TEMP_FILE_OFF', 77022 ); // alias 
    155    
     155 
    156156  // ----- File description attributes 
    157157  define( 'PCLZIP_ATT_FILE_NAME', 79001 ); 
     
    199199    var $error_code = 1; 
    200200    var $error_string = ''; 
    201      
     201 
    202202    // ----- Current status of the magic_quotes_runtime 
    203203    // This value store the php configuration for magic_quotes 
     
    333333      } 
    334334    } 
    335      
     335 
    336336    // ----- Look for default option values 
    337337    $this->privOptionDefaultThreshold($v_options); 
     
    342342    $v_filedescr_list = array(); 
    343343    $p_result_list = array(); 
    344      
     344 
    345345    // ----- Look if the $p_filelist is really an array 
    346346    if (is_array($p_filelist)) { 
    347      
     347 
    348348      // ----- Look if the first element is also an array 
    349349      //       This will mean that this is a file description entry 
     
    351351        $v_att_list = $p_filelist; 
    352352      } 
    353        
     353 
    354354      // ----- The list is a list of string names 
    355355      else { 
     
    369369      return 0; 
    370370    } 
    371      
     371 
    372372    // ----- Reformat the string list 
    373373    if (sizeof($v_string_list) != 0) { 
     
    380380      } 
    381381    } 
    382      
     382 
    383383    // ----- For each file in the list check the attributes 
    384384    $v_supported_attributes 
     
    529529    $v_filedescr_list = array(); 
    530530    $p_result_list = array(); 
    531      
     531 
    532532    // ----- Look if the $p_filelist is really an array 
    533533    if (is_array($p_filelist)) { 
    534      
     534 
    535535      // ----- Look if the first element is also an array 
    536536      //       This will mean that this is a file description entry 
     
    538538        $v_att_list = $p_filelist; 
    539539      } 
    540        
     540 
    541541      // ----- The list is a list of string names 
    542542      else { 
     
    556556      return 0; 
    557557    } 
    558      
     558 
    559559    // ----- Reformat the string list 
    560560    if (sizeof($v_string_list) != 0) { 
     
    563563      } 
    564564    } 
    565      
     565 
    566566    // ----- For each file in the list check the attributes 
    567567    $v_supported_attributes 
     
    997997  //   PCLZIP_OPT_BY_INDEX : 
    998998  //   PCLZIP_OPT_BY_NAME : 
    999   //   PCLZIP_OPT_BY_EREG :  
     999  //   PCLZIP_OPT_BY_EREG : 
    10001000  //   PCLZIP_OPT_BY_PREG : 
    10011001  // Return Values : 
     
    10651065  function deleteByIndex($p_index) 
    10661066  { 
    1067      
     1067 
    10681068    $p_list = $this->delete(PCLZIP_OPT_BY_INDEX, $p_index); 
    10691069 
     
    11151115      { 
    11161116        $this->privSwapBackMagicQuotes(); 
    1117          
     1117 
    11181118        // ----- Error log 
    11191119        PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, 'Unable to open archive \''.$this->zipname.'\' in binary read mode'); 
     
    14271427  { 
    14281428    $v_result=1; 
    1429      
     1429 
    14301430    // ----- Read the options 
    14311431    $i=0; 
     
    14671467            return PclZip::errorCode(); 
    14681468          } 
    1469            
     1469 
    14701470          // ----- Check for incompatible options 
    14711471          if (isset($v_result_list[PCLZIP_OPT_TEMP_FILE_OFF])) { 
     
    14731473            return PclZip::errorCode(); 
    14741474          } 
    1475            
     1475 
    14761476          // ----- Check the value 
    14771477          $v_value = $p_options_list[$i+1]; 
     
    14921492            return PclZip::errorCode(); 
    14931493          } 
    1494            
     1494 
    14951495          $v_result_list[$p_options_list[$i]] = true; 
    14961496        break; 
     
    15071507            return PclZip::errorCode(); 
    15081508          } 
    1509            
     1509 
    15101510          $v_result_list[$p_options_list[$i]] = true; 
    15111511        break; 
     
    16561656            return PclZip::errorCode(); 
    16571657          } 
    1658            
     1658 
    16591659          // ----- Reduce the index list 
    16601660          // each index item in the list must be a couple with a start and 
     
    16671667              $v_item_list = explode("-", $v_work_list[$j]); 
    16681668              $v_size_item_list = sizeof($v_item_list); 
    1669                
     1669 
    16701670              // ----- TBC : Here we might check that each item is a 
    16711671              // real integer ... 
    1672                
     1672 
    16731673              // ----- Look for single value 
    16741674              if ($v_size_item_list == 1) { 
     
    17041704              $v_sort_value = $v_result_list[$p_options_list[$i]][$j]['start']; 
    17051705          } 
    1706            
     1706 
    17071707          // ----- Sort the items 
    17081708          if ($v_sort_flag) { 
     
    18071807      } 
    18081808    } 
    1809      
     1809 
    18101810    // ----- Look for default values 
    18111811    if (!isset($v_result_list[PCLZIP_OPT_TEMP_FILE_THRESHOLD])) { 
    1812        
     1812 
    18131813    } 
    18141814 
     
    18271827  { 
    18281828    $v_result=1; 
    1829      
     1829 
    18301830    if (isset($p_options[PCLZIP_OPT_TEMP_FILE_THRESHOLD]) 
    18311831        || isset($p_options[PCLZIP_OPT_TEMP_FILE_OFF])) { 
    18321832      return $v_result; 
    18331833    } 
    1834      
     1834 
    18351835    // ----- Get 'memory_limit' configuration value 
    18361836    $v_memory_limit = ini_get('memory_limit'); 
    18371837    $v_memory_limit = trim($v_memory_limit); 
    18381838    $last = strtolower(substr($v_memory_limit, -1)); 
    1839   
     1839 
    18401840    if($last == 'g') 
    18411841        //$v_memory_limit = $v_memory_limit*1024*1024*1024; 
     
    18461846    if($last == 'k') 
    18471847        $v_memory_limit = $v_memory_limit*1024; 
    1848              
     1848 
    18491849    $p_options[PCLZIP_OPT_TEMP_FILE_THRESHOLD] = floor($v_memory_limit*PCLZIP_TEMPORARY_FILE_RATIO); 
    1850      
     1850 
    18511851 
    18521852    // ----- Sanity check : No threshold if value lower than 1M 
     
    18541854      unset($p_options[PCLZIP_OPT_TEMP_FILE_THRESHOLD]); 
    18551855    } 
    1856            
     1856 
    18571857    // ----- Return 
    18581858    return $v_result; 
     
    18711871  { 
    18721872    $v_result=1; 
    1873      
     1873 
    18741874    // ----- For each file in the list check the attributes 
    18751875    foreach ($p_file_list as $v_key => $v_value) { 
    1876      
     1876 
    18771877      // ----- Check if the option is supported 
    18781878      if (!isset($v_requested_options[$v_key])) { 
     
    18931893 
    18941894          $p_filedescr['filename'] = PclZipUtilPathReduction($v_value); 
    1895            
     1895 
    18961896          if ($p_filedescr['filename'] == '') { 
    18971897            PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE, "Invalid empty filename for attribute '".PclZipUtilOptionText($v_key)."'"); 
     
    19741974        } 
    19751975      } 
    1976      
     1976 
    19771977    // end foreach 
    19781978    } 
    1979      
     1979 
    19801980    // ----- Return 
    19811981    return $v_result; 
     
    19901990  //   just ignore the item. 
    19911991  //   Then prepare the information that will be stored for that file. 
    1992   //   When its a folder, expand the folder with all the files that are in that  
     1992  //   When its a folder, expand the folder with all the files that are in that 
    19931993  //   folder (recursively). 
    19941994  // Parameters : 
     
    20002000  { 
    20012001    $v_result=1; 
    2002      
     2002 
    20032003    // ----- Create a result list 
    20042004    $v_result_list = array(); 
    2005      
     2005 
    20062006    // ----- Look each entry 
    20072007    for ($i=0; $i<sizeof($p_filedescr_list); $i++) { 
    2008        
     2008 
    20092009      // ----- Get filedescr 
    20102010      $v_descr = $p_filedescr_list[$i]; 
    2011        
     2011 
    20122012      // ----- Reduce the filename 
    20132013      $v_descr['filename'] = PclZipUtilTranslateWinPath($v_descr['filename'], false); 
    20142014      $v_descr['filename'] = PclZipUtilPathReduction($v_descr['filename']); 
    2015        
     2015 
    20162016      // ----- Look for real file or folder 
    20172017      if (file_exists($v_descr['filename'])) { 
     
    20312031        } 
    20322032      } 
    2033        
     2033 
    20342034      // ----- Look for string added as file 
    20352035      else if (isset($v_descr['content'])) { 
    20362036        $v_descr['type'] = 'virtual_file'; 
    20372037      } 
    2038        
     2038 
    20392039      // ----- Missing file 
    20402040      else { 
     
    20452045        return PclZip::errorCode(); 
    20462046      } 
    2047        
     2047 
    20482048      // ----- Calculate the stored filename 
    20492049      $this->privCalculateStoredFilename($v_descr, $p_options); 
    2050        
     2050 
    20512051      // ----- Add the descriptor in result list 
    20522052      $v_result_list[sizeof($v_result_list)] = $v_descr; 
    2053        
     2053 
    20542054      // ----- Look for folder 
    20552055      if ($v_descr['type'] == 'folder') { 
     
    20642064                continue; 
    20652065            } 
    2066              
     2066 
    20672067            // ----- Compose the full filename 
    20682068            $v_dirlist_descr[$v_dirlist_nb]['filename'] = $v_descr['filename'].'/'.$v_item_handler; 
    2069              
     2069 
    20702070            // ----- Look for different stored filename 
    20712071            // Because the name of the folder was changed, the name of the 
     
    20802080              } 
    20812081            } 
    2082        
     2082 
    20832083            $v_dirlist_nb++; 
    20842084          } 
    2085            
     2085 
    20862086          @closedir($v_folder_handler); 
    20872087        } 
     
    20892089          // TBC : unable to open folder in read mode 
    20902090        } 
    2091          
     2091 
    20922092        // ----- Expand each element of the list 
    20932093        if ($v_dirlist_nb != 0) { 
     
    20962096            return $v_result; 
    20972097          } 
    2098            
     2098 
    20992099          // ----- Concat the resulting list 
    21002100          $v_result_list = array_merge($v_result_list, $v_dirlist_descr); 
     
    21022102        else { 
    21032103        } 
    2104            
     2104 
    21052105        // ----- Free local array 
    21062106        unset($v_dirlist_descr); 
    21072107      } 
    21082108    } 
    2109      
     2109 
    21102110    // ----- Get the result list 
    21112111    $p_filedescr_list = $v_result_list; 
     
    21262126    $v_result=1; 
    21272127    $v_list_detail = array(); 
    2128      
     2128 
    21292129    // ----- Magic quotes trick 
    21302130    $this->privDisableMagicQuotes(); 
     
    24562456  // Description : 
    24572457  // Parameters : 
    2458   //   $p_filedescr_list : An array containing the file description  
     2458  //   $p_filedescr_list : An array containing the file description 
    24592459  //                      or directory names to add in the zip 
    24602460  //   $p_result_list : list of added files with their properties (specially the status field) 
     
    24742474      $p_filedescr_list[$j]['filename'] 
    24752475      = PclZipUtilTranslateWinPath($p_filedescr_list[$j]['filename'], false); 
    2476        
     2476 
    24772477 
    24782478      // ----- Skip empty file names 
     
    25262526  { 
    25272527    $v_result=1; 
    2528      
     2528 
    25292529    // ----- Working variable 
    25302530    $p_filename = $p_filedescr['filename']; 
     
    25382538      return PclZip::errorCode(); 
    25392539    } 
    2540    
    2541     // ----- Look for a stored different filename  
     2540 
     2541    // ----- Look for a stored different filename 
    25422542    /* TBC : Removed 
    25432543    if (isset($p_filedescr['stored_filename'])) { 
     
    25742574      $p_header['size'] = filesize($p_filename); 
    25752575    } 
    2576      
     2576 
    25772577    // ----- Look for regular folder 
    25782578    else if ($p_filedescr['type']=='folder') { 
     
    25812581      $p_header['size'] = filesize($p_filename); 
    25822582    } 
    2583      
     2583 
    25842584    // ----- Look for virtual file 
    25852585    else if ($p_filedescr['type'] == 'virtual_file') { 
     
    25872587      $p_header['size'] = strlen($p_filedescr['content']); 
    25882588    } 
    2589      
     2589 
    25902590 
    25912591    // ----- Look for filetime 
     
    26382638      $p_header['status'] = "filtered"; 
    26392639    } 
    2640      
     2640 
    26412641    // ----- Check the path length 
    26422642    if (strlen($p_header['stored_filename']) > 0xFF) { 
     
    26502650      if ($p_filedescr['type'] == 'file') { 
    26512651        // ----- Look for using temporary file to zip 
    2652         if ( (!isset($p_options[PCLZIP_OPT_TEMP_FILE_OFF]))  
     2652        if ( (!isset($p_options[PCLZIP_OPT_TEMP_FILE_OFF])) 
    26532653            && (isset($p_options[PCLZIP_OPT_TEMP_FILE_ON]) 
    26542654                || (isset($p_options[PCLZIP_OPT_TEMP_FILE_THRESHOLD]) 
     
    26592659          } 
    26602660        } 
    2661          
     2661 
    26622662        // ----- Use "in memory" zip algo 
    26632663        else { 
     
    26772677        // ----- Calculate the CRC 
    26782678        $p_header['crc'] = @crc32($v_content); 
    2679          
     2679 
    26802680        // ----- Look for no compression 
    26812681        if ($p_options[PCLZIP_OPT_NO_COMPRESSION]) { 
     
    26842684          $p_header['compression'] = 0; 
    26852685        } 
    2686          
     2686 
    26872687        // ----- Look for normal compression 
    26882688        else { 
     
    26942694          $p_header['compression'] = 8; 
    26952695        } 
    2696          
     2696 
    26972697        // ----- Call the header generation 
    26982698        if (($v_result = $this->privWriteFileHeader($p_header)) != 1) { 
     
    27102710      // ----- Look for a virtual file (a file from string) 
    27112711      else if ($p_filedescr['type'] == 'virtual_file') { 
    2712            
     2712 
    27132713        $v_content = $p_filedescr['content']; 
    27142714 
    27152715        // ----- Calculate the CRC 
    27162716        $p_header['crc'] = @crc32($v_content); 
    2717          
     2717 
    27182718        // ----- Look for no compression 
    27192719        if ($p_options[PCLZIP_OPT_NO_COMPRESSION]) { 
     
    27222722          $p_header['compression'] = 0; 
    27232723        } 
    2724          
     2724 
    27252725        // ----- Look for normal compression 
    27262726        else { 
     
    27322732          $p_header['compression'] = 8; 
    27332733        } 
    2734          
     2734 
    27352735        // ----- Call the header generation 
    27362736        if (($v_result = $this->privWriteFileHeader($p_header)) != 1) { 
     
    27972797  { 
    27982798    $v_result=PCLZIP_ERR_NO_ERROR; 
    2799      
     2799 
    28002800    // ----- Working variable 
    28012801    $p_filename = $p_filedescr['filename']; 
     
    28922892    // ----- Unlink the temporary file 
    28932893    @unlink($v_gzip_temp_name); 
    2894      
     2894 
    28952895    // ----- Return 
    28962896    return $v_result; 
     
    29092909  { 
    29102910    $v_result=1; 
    2911      
     2911 
    29122912    // ----- Working variables 
    29132913    $p_filename = $p_filedescr['filename']; 
     
    29372937      $v_stored_filename = PclZipUtilTranslateWinPath($p_filedescr['new_full_name']); 
    29382938    } 
    2939      
     2939 
    29402940    // ----- Look for path and/or short name change 
    29412941    else { 
     
    29672967        if (   (substr($p_filename, 0, 2) == "./") 
    29682968            || (substr($p_remove_dir, 0, 2) == "./")) { 
    2969              
     2969 
    29702970          if (   (substr($p_filename, 0, 2) == "./") 
    29712971              && (substr($p_remove_dir, 0, 2) != "./")) { 
     
    29902990        } 
    29912991      } 
    2992        
     2992 
    29932993      // ----- Remove drive letter if any 
    29942994      $v_stored_filename = PclZipUtilTranslateWinPath($v_stored_filename); 
    2995        
     2995 
    29962996      // ----- Look for path to add 
    29972997      if ($p_add_dir != "") { 
     
    30063006    $v_stored_filename = PclZipUtilPathReduction($v_stored_filename); 
    30073007    $p_filedescr['stored_filename'] = $v_stored_filename; 
    3008      
     3008 
    30093009    // ----- Return 
    30103010    return $v_result; 
     
    31573157      // ----- Magic quotes trick 
    31583158      $this->privSwapBackMagicQuotes(); 
    3159        
     3159 
    31603160      // ----- Error log 
    31613161      PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, 'Unable to open archive \''.$this->zipname.'\' in binary read mode'); 
     
    33883388      // ----- Look for extract by ereg rule 
    33893389      // ereg() is deprecated with PHP 5.3 
    3390       /*  
     3390      /* 
    33913391      else if (   (isset($p_options[PCLZIP_OPT_BY_EREG])) 
    33923392               && ($p_options[PCLZIP_OPT_BY_EREG] != "")) { 
     
    34103410      else if (   (isset($p_options[PCLZIP_OPT_BY_INDEX])) 
    34113411               && ($p_options[PCLZIP_OPT_BY_INDEX] != 0)) { 
    3412            
     3412 
    34133413          // ----- Look if the index is in the list 
    34143414          for ($j=$j_start; ($j<sizeof($p_options[PCLZIP_OPT_BY_INDEX])) && (!$v_extract); $j++) { 
     
    34433443 
    34443444              $this->privSwapBackMagicQuotes(); 
    3445                
     3445 
    34463446              PclZip::privErrorLog(PCLZIP_ERR_UNSUPPORTED_COMPRESSION, 
    34473447                                   "Filename '".$v_header['stored_filename']."' is " 
     
    34523452          } 
    34533453      } 
    3454        
     3454 
    34553455      // ----- Check encrypted files 
    34563456      if (($v_extract) && (($v_header['flag'] & 1) == 1)) { 
     
    34843484          $v_extract = false; 
    34853485      } 
    3486        
     3486 
    34873487      // ----- Look for real extraction 
    34883488      if ($v_extract) 
     
    35333533          // ----- Next extracted file 
    35343534          $v_nb_extracted++; 
    3535            
     3535 
    35363536          // ----- Look for user callback abort 
    35373537          if ($v_result1 == 2) { 
     
    36693669      $p_entry['filename'] = $p_path."/".$p_entry['filename']; 
    36703670    } 
    3671      
     3671 
    36723672    // ----- Check a base_dir_restriction 
    36733673    if (isset($p_options[PCLZIP_OPT_EXTRACT_DIR_RESTRICTION])) { 
    36743674      $v_inclusion 
    36753675      = PclZipUtilPathInclusion($p_options[PCLZIP_OPT_EXTRACT_DIR_RESTRICTION], 
    3676                                 $p_entry['filename']);  
     3676                                $p_entry['filename']); 
    36773677      if ($v_inclusion == 0) { 
    36783678 
     
    37013701        $v_result = 1; 
    37023702      } 
    3703        
     3703 
    37043704      // ----- Look for abort result 
    37053705      if ($v_result == 2) { 
     
    37283728        // ----- Change the file status 
    37293729        $p_entry['status'] = "already_a_directory"; 
    3730          
     3730 
    37313731        // ----- Look for PCLZIP_OPT_STOP_ON_ERROR 
    37323732        // For historical reason first PclZip implementation does not stop 
     
    38013801 
    38023802        if (($v_result = $this->privDirCheck($v_dir_to_check, (($p_entry['external']&0x00000010)==0x00000010))) != 1) { 
    3803    
     3803 
    38043804          // ----- Change the file status 
    38053805          $p_entry['status'] = "path_creation_fail"; 
    3806    
     3806 
    38073807          // ----- Return 
    38083808          //return $v_result; 
     
    38433843            @fwrite($v_dest_file, $v_binary_data, $v_read_size); 
    38443844            */ 
    3845             @fwrite($v_dest_file, $v_buffer, $v_read_size);             
     3845            @fwrite($v_dest_file, $v_buffer, $v_read_size); 
    38463846            $v_size -= $v_read_size; 
    38473847          } 
     
    38523852          // ----- Change the file mtime 
    38533853          touch($p_entry['filename'], $p_entry['mtime']); 
    3854            
     3854 
    38553855 
    38563856        } 
     
    38653865 
    38663866          // ----- Look for using temporary file to unzip 
    3867           if ( (!isset($p_options[PCLZIP_OPT_TEMP_FILE_OFF]))  
     3867          if ( (!isset($p_options[PCLZIP_OPT_TEMP_FILE_OFF])) 
    38683868              && (isset($p_options[PCLZIP_OPT_TEMP_FILE_ON]) 
    38693869                  || (isset($p_options[PCLZIP_OPT_TEMP_FILE_THRESHOLD]) 
     
    38743874            } 
    38753875          } 
    3876            
     3876 
    38773877          // ----- Look for extract in memory 
    38783878          else { 
    38793879 
    3880            
     3880 
    38813881            // ----- Read the compressed file in a buffer (one shot) 
    38823882            $v_buffer = @fread($this->zip_fd, $p_entry['compressed_size']); 
    3883              
     3883 
    38843884            // ----- Decompress the file 
    38853885            $v_file_content = @gzinflate($v_buffer); 
    38863886            unset($v_buffer); 
    38873887            if ($v_file_content === FALSE) { 
    3888    
     3888 
    38893889              // ----- Change the file status 
    38903890              // TBC 
    38913891              $p_entry['status'] = "error"; 
    3892                
     3892 
    38933893              return $v_result; 
    38943894            } 
    3895              
     3895 
    38963896            // ----- Opening destination file 
    38973897            if (($v_dest_file = @fopen($p_entry['filename'], 'wb')) == 0) { 
    3898    
     3898 
    38993899              // ----- Change the file status 
    39003900              $p_entry['status'] = "write_error"; 
    3901    
     3901 
    39023902              return $v_result; 
    39033903            } 
    3904    
     3904 
    39053905            // ----- Write the uncompressed data 
    39063906            @fwrite($v_dest_file, $v_file_content, $p_entry['size']); 
    39073907            unset($v_file_content); 
    3908    
     3908 
    39093909            // ----- Closing the destination file 
    39103910            @fclose($v_dest_file); 
    3911              
     3911 
    39123912          } 
    39133913 
     
    39303930        $p_entry['status'] = "skipped"; 
    39313931    } 
    3932      
     3932 
    39333933    // ----- Look for post-extract callback 
    39343934    elseif (isset($p_options[PCLZIP_CB_POST_EXTRACT])) { 
     
    39633963  { 
    39643964    $v_result=1; 
    3965          
     3965 
    39663966    // ----- Creates a temporary file 
    39673967    $v_gzip_temp_name = PCLZIP_TEMPORARY_DIR.uniqid('pclzip-').'.gz'; 
     
    40244024    // ----- Delete the temporary file 
    40254025    @unlink($v_gzip_temp_name); 
    4026      
     4026 
    40274027    // ----- Return 
    40284028    return $v_result; 
     
    41024102          // ----- Read the compressed file in a buffer (one shot) 
    41034103          $v_buffer = @fread($this->zip_fd, $p_entry['compressed_size']); 
    4104            
     4104 
    41054105          // ----- Decompress the file 
    41064106          $v_file_content = gzinflate($v_buffer); 
     
    41814181        $v_result = 1; 
    41824182      } 
    4183        
     4183 
    41844184      // ----- Look for abort result 
    41854185      if ($v_result == 2) { 
     
    42034203  //      if ($p_entry['compressed_size'] == $p_entry['size']) 
    42044204        if ($p_entry['compression'] == 0) { 
    4205    
     4205 
    42064206          // ----- Reading the file 
    42074207          $p_string = @fread($this->zip_fd, $p_entry['compressed_size']); 
    42084208        } 
    42094209        else { 
    4210    
     4210 
    42114211          // ----- Reading the file 
    42124212          $v_data = @fread($this->zip_fd, $p_entry['compressed_size']); 
    4213            
     4213 
    42144214          // ----- Decompress the file 
    42154215          if (($p_string = @gzinflate($v_data)) === FALSE) { 
     
    42174217          } 
    42184218        } 
    4219    
     4219 
    42204220        // ----- Trace 
    42214221      } 
     
    42234223          // TBC : error : can not extract a folder in a string 
    42244224      } 
    4225        
     4225 
    42264226    } 
    42274227 
     
    42304230        $p_entry['status'] = "skipped"; 
    42314231    } 
    4232      
     4232 
    42334233    // ----- Look for post-extract callback 
    42344234    elseif (isset($p_options[PCLZIP_CB_POST_EXTRACT])) { 
     
    42374237      $v_local_header = array(); 
    42384238      $this->privConvertHeader2FileInfo($p_entry, $v_local_header); 
    4239        
     4239 
    42404240      // ----- Swap the content to header 
    42414241      $v_local_header['content'] = $p_string; 
     
    44974497    if ($p_local_header['filename_len'] != $p_central_header['filename_len']) { 
    44984498    } 
    4499    
     4499 
    45004500    // ----- Look for flag bit 3 
    45014501    if (($p_local_header['flag'] & 8) == 8) { 
     
    45834583        // -----  Add the byte 
    45844584        //$v_bytes = ($v_bytes << 8) | Ord($v_byte); 
    4585         // Note we mask the old value down such that once shifted we can never end up with more than a 32bit number  
    4586         // Otherwise on systems where we have 64bit integers the check below for the magic number will fail.  
    4587         $v_bytes = ( ($v_bytes & 0xFFFFFF) << 8) | Ord($v_byte);  
     4585        // Note we mask the old value down such that once shifted we can never end up with more than a 32bit number 
     4586        // Otherwise on systems where we have 64bit integers the check below for the magic number will fail. 
     4587        $v_bytes = ( ($v_bytes & 0xFFFFFF) << 8) | Ord($v_byte); 
    45884588 
    45894589        // ----- Compare the bytes 
     
    48634863                return $v_result; 
    48644864            } 
    4865              
     4865 
    48664866            // ----- Check that local file header is same as central file header 
    48674867            if ($this->privCheckFileHeaders($v_local_header, 
     
    49474947        //@rename($v_zip_temp_name, $this->zipname); 
    49484948        PclZipUtilRename($v_zip_temp_name, $this->zipname); 
    4949      
     4949 
    49504950        // ----- Destroy the temporary archive 
    49514951        unset($v_temp_zip); 
    49524952    } 
    4953      
     4953 
    49544954    // ----- Remove every files : reset the file 
    49554955    else if ($v_central_dir['entries'] != 0) { 
     
    54385438        } 
    54395439      } 
    5440        
     5440 
    54415441      // ----- Look for skip 
    54425442      if ($v_skip > 0) { 
     
    54715471  { 
    54725472    $v_result = 1; 
    5473      
     5473 
    54745474    // ----- Look for path beginning by ./ 
    54755475    if (   ($p_dir == '.') 
     
    56395639  function PclZipUtilOptionText($p_option) 
    56405640  { 
    5641      
     5641 
    56425642    $v_list = get_defined_constants(); 
    56435643    for (reset($v_list); $v_key = key($v_list); next($v_list)) { 
     
    56505650        } 
    56515651    } 
    5652      
     5652 
    56535653    $v_result = 'Unknown'; 
    56545654 
  • trunk/wp-admin/includes/plugin.php

    r11991 r12042  
    992992 * 
    993993 * @param string $option_group A settings group name.  Should correspond to a whitelisted option key name. 
    994  *  Default whitelisted option key names include "general," "discussion," and "reading," among others.  
     994 *  Default whitelisted option key names include "general," "discussion," and "reading," among others. 
    995995 * @param string $option_name The name of an option to sanitize and save. 
    996996 * @param unknown_type $sanitize_callback A callback function that sanitizes the option's value. 
  • trunk/wp-admin/press-this.php

    r12030 r12042  
    437437        jQuery('#title').unbind(); 
    438438        jQuery('#publish, #save').click(function() { jQuery('#saving').css('display', 'inline'); }); 
    439          
     439 
    440440        $('#tagsdiv-post_tag, #categorydiv').children('h3').click(function(){ 
    441441            $(this).siblings('.inside').toggle(); 
  • trunk/wp-includes/class-oembed.php

    r12027 r12042  
    175175        elseif ( function_exists('simplexml_load_string') ) { 
    176176            $errors = libxml_use_internal_errors( 'true' ); 
    177              
     177 
    178178            $data = simplexml_load_string( $result ); 
    179179 
  • trunk/wp-includes/comment.php

    r12008 r12042  
    897897    $comment['comment_approved'] = $status; 
    898898 
    899     delete_comment_meta($comment_id, '_wp_trash_meta_time');  
    900     delete_comment_meta($comment_id, '_wp_trash_meta_status');  
     899    delete_comment_meta($comment_id, '_wp_trash_meta_time'); 
     900    delete_comment_meta($comment_id, '_wp_trash_meta_status'); 
    901901 
    902902    wp_update_comment($comment); 
  • trunk/wp-includes/deprecated.php

    r11980 r12042  
    17161716 * 
    17171717 * @deprecated 2.9.0 
    1718  *  
     1718 * 
    17191719 * @param string $more_link_text Optional. Text to display when more content is available but not displayed. 
    17201720 * @param int|bool $stripteaser Optional. Default is 0. 
  • trunk/wp-includes/functions.php

    r12023 r12042  
    31733173 
    31743174function get_site_option( $key, $default = false, $use_cache = true ) { 
    3175     // Allow plugins to short-circuit site options.  
    3176     $pre = apply_filters( 'pre_site_option_' . $key, false );  
    3177     if ( false !== $pre )  
    3178         return $pre;  
    3179   
     3175    // Allow plugins to short-circuit site options. 
     3176    $pre = apply_filters( 'pre_site_option_' . $key, false ); 
     3177    if ( false !== $pre ) 
     3178        return $pre; 
     3179 
    31803180    $value = get_option($key, $default); 
    3181   
     3181 
    31823182    return apply_filters( 'site_option_' . $key, $value ); 
    31833183} 
  • trunk/wp-includes/media.php

    r12039 r12042  
    561561 * Uses the begin_fetch_post_image_html and end_fetch_post_image_html action hooks to 
    562562 * dynamically add/remove itself so as to only filter post image thumbnails 
    563  *  
     563 * 
    564564 * @author Mark Jaquith 
    565565 * @since 2.9.0 
     
    574574/** 
    575575 * Adds _wp_post_image_class_filter to the wp_get_attachment_image_attributes filter 
    576  *  
     576 * 
    577577 * @author Mark Jaquith 
    578578 * @since 2.9.0 
     
    584584/** 
    585585 * Removes _wp_post_image_class_filter from the wp_get_attachment_image_attributes filter 
    586  *  
     586 * 
    587587 * @author Mark Jaquith 
    588588 * @since 2.9.0 
  • trunk/wp-includes/meta.php

    r11999 r12042  
    8282 
    8383function delete_metadata($meta_type, $object_id, $meta_key, $meta_value = '', $delete_all = false) { 
    84     if ( !$meta_type || !$meta_key || (!$delete_all && ! (int)$object_id) )  
    85         return false; 
    86      
     84    if ( !$meta_type || !$meta_key || (!$delete_all && ! (int)$object_id) ) 
     85        return false; 
     86 
    8787    if ( ! $table = _get_meta_table($meta_type) ) 
    8888        return false; 
  • trunk/wp-includes/post.php

    r11998 r12042  
    474474 * 
    475475 * exclude_from_search - Whether to exclude posts with this post type from search results. Defaults to true. 
    476  *  
     476 * 
    477477 * @package WordPress 
    478478 * @subpackage Post 
     
    22472247 * It uses auxiliary structure to hold parent-children relationships and 
    22482248 * runs in O(N) complexity 
    2249  *  
     2249 * 
    22502250 * @since 2.0.0 
    22512251 * 
     
    22552255 */ 
    22562256function &get_page_hierarchy( &$pages, $page_id = 0 ) { 
    2257      
     2257 
    22582258    if ( empty( $pages ) ) 
    22592259        return null; 
    2260          
     2260 
    22612261    $children = array(); 
    22622262    foreach ( (array) $pages as $p ) { 
    2263          
     2263 
    22642264        $parent_id = intval( $p->post_parent ); 
    22652265        $children[ $parent_id ][] = $p; 
    22662266     } 
    2267       
     2267 
    22682268     $result = array(); 
    22692269     _page_traverse_name( $page_id, $children, $result ); 
    2270       
     2270 
    22712271    return $result; 
    22722272} 
     
    22752275 * function to traverse and return all the nested children post names of a root page. 
    22762276 * $children contains parent-chilren relations 
    2277  *  
    2278  */ 
    2279 function _page_traverse_name( $page_id, &$children, &$result ){  
    2280      
     2277 * 
     2278 */ 
     2279function _page_traverse_name( $page_id, &$children, &$result ){ 
     2280 
    22812281    if ( isset( $children[ $page_id ] ) ){ 
    2282          
     2282 
    22832283        foreach( (array)$children[ $page_id ] as $child ) { 
    2284              
     2284 
    22852285            $result[ $child->ID ] = $child->post_name; 
    22862286            _page_traverse_name( $child->ID, $children, $result ); 
  • trunk/wp-includes/script-loader.php

    r12037 r12042  
    386386        $scripts->add( 'set-post-thumbnail-handler', "/wp-admin/js/set-post-thumbnail-handler$suffix.js", array( 'jquery' ), '20091015' ); 
    387387        $scripts->add_data( 'set-post-thumbnail-handler', 'group', 1 ); 
    388      
     388 
    389389    } 
    390390} 
  • trunk/wp-includes/theme.php

    r12025 r12042  
    130130    $theme_root = get_theme_root( $template ); 
    131131    $template_dir = "$theme_root/$template"; 
    132          
     132 
    133133    return apply_filters( 'template_directory', $template_dir, $template, $theme_root ); 
    134134} 
     
    146146    $theme_root_uri = get_theme_root_uri( $template ); 
    147147    $template_dir_uri = "$theme_root_uri/$template"; 
    148      
     148 
    149149    return apply_filters( 'template_directory_uri', $template_dir_uri, $template, $theme_root_uri ); 
    150150} 
     
    267267    if ( !$theme_files = search_theme_directories() ) 
    268268        return false; 
    269      
     269 
    270270    asort( $theme_files ); 
    271      
     271 
    272272    foreach ( (array) $theme_files as $theme_file ) { 
    273273        $theme_root = $theme_file['theme_root']; 
     
    308308                continue; 
    309309        } 
    310          
     310 
    311311        $template = trim( $template ); 
    312312 
     
    316316                $template = "$theme_root/$parent_dir/$template"; 
    317317            } else { 
    318                 /**   
    319                  * The parent theme doesn't exist in the current theme's folder or sub folder  
    320                  * so lets use the theme root for the parent template.  
     318                /** 
     319                 * The parent theme doesn't exist in the current theme's folder or sub folder 
     320                 * so lets use the theme root for the parent template. 
    321321                 */ 
    322322                $parent_theme_root = $theme_files[$template]['theme_root']; 
     
    327327                    continue; 
    328328                } 
    329                  
     329 
    330330            } 
    331331        } else { 
    332332            $template = trim( $theme_root . '/' . $template ); 
    333333        } 
    334          
     334 
    335335        $stylesheet_files = array(); 
    336336        $template_files = array(); 
     
    420420 
    421421    $wp_themes = $themes; 
    422      
     422 
    423423    return $themes; 
    424424} 
     
    502502function register_theme_directory( $directory ) { 
    503503    global $wp_theme_directories; 
    504      
     504 
    505505    /* The theme directory should be relative to the content directory */ 
    506506    $registered_directory = WP_CONTENT_DIR . '/' . $directory; 
    507      
     507 
    508508    /* If this folder does not exist, return and do not register */ 
    509509    if ( !file_exists( $registered_directory ) ) 
    510510        return false; 
    511      
     511 
    512512    $wp_theme_directories[] = $registered_directory; 
    513      
     513 
    514514    return true; 
    515515} 
     
    524524function search_theme_directories() { 
    525525    global $wp_theme_directories, $wp_broken_themes; 
    526      
     526 
    527527    if ( empty( $wp_theme_directories ) ) 
    528528        return false; 
     
    534534    foreach ( (array) $wp_theme_directories as $theme_root ) { 
    535535        $theme_loc = $theme_root; 
    536          
     536 
    537537        /* We don't want to replace all forward slashes, see Trac #4541 */ 
    538         if ( '/' != WP_CONTENT_DIR )  
     538        if ( '/' != WP_CONTENT_DIR ) 
    539539            $theme_loc = str_replace(WP_CONTENT_DIR, '', $theme_root); 
    540540 
     
    552552                $stylish_dir = @ opendir($theme_root . '/' . $theme_dir); 
    553553                $found_stylesheet = false; 
    554                  
     554 
    555555                while ( ($theme_file = readdir($stylish_dir)) !== false ) { 
    556556                    if ( $theme_file == 'style.css' ) { 
     
    561561                } 
    562562                @closedir($stylish_dir); 
    563                  
     563 
    564564                if ( !$found_stylesheet ) { // look for themes in that dir 
    565565                    $subdir = "$theme_root/$theme_dir"; 
    566566                    $subdir_name = $theme_dir; 
    567567                    $theme_subdir = @ opendir( $subdir ); 
    568                      
     568 
    569569                    while ( ($theme_dir = readdir($theme_subdir)) !== false ) { 
    570570                        if ( is_dir( $subdir . '/' . $theme_dir) && is_readable($subdir . '/' . $theme_dir) ) { 
    571571                            if ( $theme_dir{0} == '.' || $theme_dir == '..' || $theme_dir == 'CVS' ) 
    572572                                continue; 
    573                                  
     573 
    574574                            $stylish_dir = @ opendir($subdir . '/' . $theme_dir); 
    575575                            $found_stylesheet = false; 
    576                              
     576 
    577577                            while ( ($theme_file = readdir($stylish_dir)) !== false ) { 
    578578                                if ( $theme_file == 'style.css' ) { 
     
    586586                    } 
    587587                    @closedir($theme_subdir); 
    588                      
     588 
    589589                    $wp_broken_themes[$theme_dir] = array('Name' => $theme_dir, 'Title' => $theme_dir, 'Description' => __('Stylesheet is missing.')); 
    590590                } 
     
    594594            @closedir( $theme_dir ); 
    595595    } 
    596      
     596 
    597597    return $theme_files; 
    598598} 
     
    611611function get_theme_root( $stylesheet_or_template = false ) { 
    612612    $theme_roots = get_theme_roots(); 
    613      
     613 
    614614    if ( $theme_roots[$stylesheet_or_template] ) 
    615615        $theme_root = WP_CONTENT_DIR . '/' . $theme_roots[$stylesheet_or_template]; 
     
    632632function get_theme_root_uri( $stylesheet_or_template = false ) { 
    633633    $theme_roots = get_theme_roots(); 
    634      
     634 
    635635    if ( $theme_roots[$stylesheet_or_template] ) 
    636636        $theme_root_uri = content_url( $theme_roots[$stylesheet_or_template] ); 
     
    737737 * trying tag ID, for example 'tag-1.php' and will finally fallback to tag.php 
    738738 * template, if those files don't exist. 
    739  *  
     739 * 
    740740 * @since 2.3.0 
    741741 * @uses apply_filters() Calls 'tag_template' on file path of tag template. 
     
    754754        $templates[] = "tag-$tag_id.php"; 
    755755    $templates[] = "tag.php"; 
    756      
     756 
    757757    $template = locate_template($templates); 
    758758    return apply_filters('tag_template', $template); 
Note: See TracChangeset for help on using the changeset viewer.