include/php_writeexcel/class.writeexcel_biffwriter.inc.php

   1 <?php
   2
   3 /*
   4  * Copyleft 2002 Johann Hanne
   5  *
   6  * This is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This software is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this software; if not, write to the
  18  * Free Software Foundation, Inc., 59 Temple Place,
  19  * Suite 330, Boston, MA  02111-1307 USA
  20  */
  21
  22 /*
  23  * This is the Spreadsheet::WriteExcel Perl package ported to PHP
  24  * Spreadsheet::WriteExcel was written by John McNamara, jmcnamara@cpan.org
  25  */
  26
  27 class writeexcel_biffwriter {
  28     var $byte_order;
  29     var $BIFF_version;
  30     var $_byte_order;
  31     var $_data;
  32     var $_datasize;
  33     var $_limit;
  34
  35     /*
  36      * Constructor
  37      */
  38     function writeexcel_biffwriter() {
  39
  40         $this->byte_order   = '';
  41         $this->BIFF_version = 0x0500;
  42         $this->_byte_order  = '';
  43         $this->_data        = false;
  44         $this->_datasize    = 0;
  45         $this->_limit       = 2080;
  46
  47         $this->_set_byte_order();
  48     }
  49
  50     /*
  51      * Determine the byte order and store it as class data to avoid
  52      * recalculating it for each call to new().
  53      */
  54     function _set_byte_order() {
  55         $this->byteorder=0;
  56         // Check if "pack" gives the required IEEE 64bit float
  57         $teststr = pack("d", 1.2345);
  58         $number  = pack("C8", 0x8D, 0x97, 0x6E, 0x12, 0x83, 0xC0, 0xF3, 0x3F);
  59
  60         if ($number == $teststr) {
  61             $this->byte_order = 0; // Little Endian
  62         } elseif ($number == strrev($teststr)) {
  63             $this->byte_order = 1; // Big Endian
  64         } else {
  65             // Give up
  66             trigger_error("Required floating point format not supported ".
  67                           "on this platform. See the portability section ".
  68                           "of the documentation.", E_USER_ERROR);
  69         }
  70
  71         $this->_byte_order = $this->byte_order;
  72     }
  73
  74     /*
  75      * General storage function
  76      */
  77     function _prepend($data) {
  78
  79         if (func_num_args()>1) {
  80             trigger_error("writeexcel_biffwriter::_prepend() ".
  81                           "called with more than one argument", E_USER_ERROR);
  82         }
  83
  84         if ($this->_debug) {
  85             print "*** writeexcel_biffwriter::_prepend() called:";
  86             for ($c=0;$c<strlen($data);$c++) {
  87                 if ($c%16==0) {
  88                     print "\n";
  89                 }
  90                 printf("%02X ", ord($data[$c]));
  91             }
  92             print "\n";
  93         }
  94
  95         if (strlen($data) > $this->_limit) {
  96             $data = $this->_add_continue($data);
  97         }
  98
  99         $this->_data      = $data . $this->_data;
 100         $this->_datasize += strlen($data);
 101     }
 102
 103     /*
 104      * General storage function
 105      */
 106     function _append($data) {
 107
 108         if (func_num_args()>1) {
 109             trigger_error("writeexcel_biffwriter::_append() ".
 110                           "called with more than one argument", E_USER_ERROR);
 111         }
 112
 113         if ($this->_debug) {
 114             print "*** writeexcel_biffwriter::_append() called:";
 115             for ($c=0;$c<strlen($data);$c++) {
 116                 if ($c%16==0) {
 117                     print "\n";
 118                 }
 119                 printf("%02X ", ord($data[$c]));
 120             }
 121             print "\n";
 122         }
 123
 124         if (strlen($data) > $this->_limit) {
 125             $data = $this->_add_continue($data);
 126         }
 127
 128         $this->_data      = $this->_data . $data;
 129         $this->_datasize += strlen($data);
 130     }
 131
 132     /*
 133      * Writes Excel BOF record to indicate the beginning of a stream or
 134      * sub-stream in the BIFF file.
 135      *
 136      * $type = 0x0005, Workbook
 137      * $type = 0x0010, Worksheet
 138      */
 139     function _store_bof($type) {
 140
 141         $record  = 0x0809; // Record identifier
 142         $length  = 0x0008; // Number of bytes to follow
 143
 144         $version = $this->BIFF_version;
 145
 146         // According to the SDK $build and $year should be set to zero.
 147         // However, this throws a warning in Excel 5. So, use these
 148         // magic numbers.
 149         $build  = 0x096C;
 150         $year   = 0x07C9;
 151
 152         $header = pack("vv",   $record, $length);
 153         $data   = pack("vvvv", $version, $type, $build, $year);
 154
 155         $this->_prepend($header . $data);
 156     }
 157
 158     /*
 159      * Writes Excel EOF record to indicate the end of a BIFF stream.
 160      */
 161     function _store_eof() {
 162
 163         $record = 0x000A; // Record identifier
 164         $length = 0x0000; // Number of bytes to follow
 165
 166         $header = pack("vv", $record, $length);
 167
 168         $this->_append($header);
 169     }
 170
 171     /*
 172      * Excel limits the size of BIFF records. In Excel 5 the limit is 2084
 173      * bytes. In Excel 97 the limit is 8228 bytes. Records that are longer
 174      * than these limits must be split up into CONTINUE blocks.
 175      *
 176      * This function take a long BIFF record and inserts CONTINUE records as
 177      * necessary.
 178      */
 179     function _add_continue($data) {
 180
 181         $limit  = $this->_limit;
 182         $record = 0x003C; // Record identifier
 183
 184         // The first 2080/8224 bytes remain intact. However, we have to change
 185         // the length field of the record.
 186         $tmp = substr($data, 0, $limit);
 187         $data = substr($data, $limit);
 188         $tmp = substr($tmp, 0, 2) . pack ("v", $limit-4) . substr($tmp, 4);
 189
 190         // Strip out chunks of 2080/8224 bytes +4 for the header.
 191         while (strlen($data) > $limit) {
 192             $header  = pack("vv", $record, $limit);
 193             $tmp    .= $header;
 194             $tmp    .= substr($data, 0, $limit);
 195             $data    = substr($data, $limit);
 196         }
 197
 198         // Mop up the last of the data
 199         $header  = pack("vv", $record, strlen($data));
 200         $tmp    .= $header;
 201         $tmp    .= $data;
 202
 203         return $tmp;
 204     }
 205
 206 }
 207
 208 ?>