/common/libraries/plugin/phpexcel/PHPExcel/Reader/Excel5.php

<?php

/**

 * PHPExcel

 *

 * Copyright (c) 2006 - 2011 PHPExcel

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2.1 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

 *

 * @category   PHPExcel

 * @package    PHPExcel_Reader_Excel5

 * @copyright  Copyright (c) 2006 - 2011 PHPExcel (http://www.codeplex.com/PHPExcel)

 * @license    http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt	LGPL

 * @version    1.7.6, 2011-02-27

 */



// Original file header of ParseXL (used as the base for this class):

// --------------------------------------------------------------------------------

// Adapted from Excel_Spreadsheet_Reader developed by users bizon153,

// trex005, and mmp11 (SourceForge.net)

// http://sourceforge.net/projects/phpexcelreader/

// Primary changes made by canyoncasa (dvc) for ParseXL 1.00 ...

//	 Modelled moreso after Perl Excel Parse/Write modules

//	 Added Parse_Excel_Spreadsheet object

//		 Reads a whole worksheet or tab as row,column array or as

//		 associated hash of indexed rows and named column fields

//	 Added variables for worksheet (tab) indexes and names

//	 Added an object call for loading individual woorksheets

//	 Changed default indexing defaults to 0 based arrays

//	 Fixed date/time and percent formats

//	 Includes patches found at SourceForge...

//		 unicode patch by nobody

//		 unpack("d") machine depedency patch by matchy

//		 boundsheet utf16 patch by bjaenichen

//	 Renamed functions for shorter names

//	 General code cleanup and rigor, including <80 column width

//	 Included a testcase Excel file and PHP example calls

//	 Code works for PHP 5.x





// Primary changes made by canyoncasa (dvc) for ParseXL 1.10 ...

// http://sourceforge.net/tracker/index.php?func=detail&aid=1466964&group_id=99160&atid=623334

//	 Decoding of formula conditions, results, and tokens.

//	 Support for user-defined named cells added as an array "namedcells"

//		 Patch code for user-defined named cells supports single cells only.

//		 NOTE: this patch only works for BIFF8 as BIFF5-7 use a different

//		 external sheet reference structure





/** PHPExcel root directory */

if (! defined('PHPEXCEL_ROOT'))

{

    /**

     * @ignore

     */

    define('PHPEXCEL_ROOT', dirname(__FILE__) . '/../../');

    require (PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');

}



/**

 * PHPExcel_Reader_Excel5

 *

 * This class uses {@link http://sourceforge.net/projects/phpexcelreader/parseXL}

 *

 * @category	PHPExcel

 * @package	PHPExcel_Reader_Excel5

 * @copyright	Copyright (c) 2006 - 2011 PHPExcel (http://www.codeplex.com/PHPExcel)

 */

class PHPExcel_Reader_Excel5 implements PHPExcel_Reader_IReader

{

    // ParseXL definitions

    const XLS_BIFF8 = 0x0600;

    const XLS_BIFF7 = 0x0500;

    const XLS_WorkbookGlobals = 0x0005;

    const XLS_Worksheet = 0x0010;

    

    // record identifiers

    const XLS_Type_FORMULA = 0x0006;

    const XLS_Type_EOF = 0x000a;

    const XLS_Type_PROTECT = 0x0012;

    const XLS_Type_OBJECTPROTECT = 0x0063;

    const XLS_Type_SCENPROTECT = 0x00dd;

    const XLS_Type_PASSWORD = 0x0013;

    const XLS_Type_HEADER = 0x0014;

    const XLS_Type_FOOTER = 0x0015;

    const XLS_Type_EXTERNSHEET = 0x0017;

    const XLS_Type_DEFINEDNAME = 0x0018;

    const XLS_Type_VERTICALPAGEBREAKS = 0x001a;

    const XLS_Type_HORIZONTALPAGEBREAKS = 0x001b;

    const XLS_Type_NOTE = 0x001c;

    const XLS_Type_SELECTION = 0x001d;

    const XLS_Type_DATEMODE = 0x0022;

    const XLS_Type_EXTERNNAME = 0x0023;

    const XLS_Type_LEFTMARGIN = 0x0026;

    const XLS_Type_RIGHTMARGIN = 0x0027;

    const XLS_Type_TOPMARGIN = 0x0028;

    const XLS_Type_BOTTOMMARGIN = 0x0029;

    const XLS_Type_PRINTGRIDLINES = 0x002b;

    const XLS_Type_FILEPASS = 0x002f;

    const XLS_Type_FONT = 0x0031;

    const XLS_Type_CONTINUE = 0x003c;

    const XLS_Type_PANE = 0x0041;

    const XLS_Type_CODEPAGE = 0x0042;

    const XLS_Type_DEFCOLWIDTH = 0x0055;

    const XLS_Type_OBJ = 0x005d;

    const XLS_Type_COLINFO = 0x007d;

    const XLS_Type_IMDATA = 0x007f;

    const XLS_Type_SHEETPR = 0x0081;

    const XLS_Type_HCENTER = 0x0083;

    const XLS_Type_VCENTER = 0x0084;

    const XLS_Type_SHEET = 0x0085;

    const XLS_Type_PALETTE = 0x0092;

    const XLS_Type_SCL = 0x00a0;

    const XLS_Type_PAGESETUP = 0x00a1;

    const XLS_Type_MULRK = 0x00bd;

    const XLS_Type_MULBLANK = 0x00be;

    const XLS_Type_DBCELL = 0x00d7;

    const XLS_Type_XF = 0x00e0;

    const XLS_Type_MERGEDCELLS = 0x00e5;

    const XLS_Type_MSODRAWINGGROUP = 0x00eb;

    const XLS_Type_MSODRAWING = 0x00ec;

    const XLS_Type_SST = 0x00fc;

    const XLS_Type_LABELSST = 0x00fd;

    const XLS_Type_EXTSST = 0x00ff;

    const XLS_Type_EXTERNALBOOK = 0x01ae;

    const XLS_Type_DATAVALIDATIONS = 0x01b2;

    const XLS_Type_TXO = 0x01b6;

    const XLS_Type_HYPERLINK = 0x01b8;

    const XLS_Type_DATAVALIDATION = 0x01be;

    const XLS_Type_DIMENSION = 0x0200;

    const XLS_Type_BLANK = 0x0201;

    const XLS_Type_NUMBER = 0x0203;

    const XLS_Type_LABEL = 0x0204;

    const XLS_Type_BOOLERR = 0x0205;

    const XLS_Type_STRING = 0x0207;

    const XLS_Type_ROW = 0x0208;

    const XLS_Type_INDEX = 0x020b;

    const XLS_Type_ARRAY = 0x0221;

    const XLS_Type_DEFAULTROWHEIGHT = 0x0225;

    const XLS_Type_WINDOW2 = 0x023e;

    const XLS_Type_RK = 0x027e;

    const XLS_Type_STYLE = 0x0293;

    const XLS_Type_FORMAT = 0x041e;

    const XLS_Type_SHAREDFMLA = 0x04bc;

    const XLS_Type_BOF = 0x0809;

    const XLS_Type_SHEETPROTECTION = 0x0867;

    const XLS_Type_RANGEPROTECTION = 0x0868;

    const XLS_Type_SHEETLAYOUT = 0x0862;

    const XLS_Type_XFEXT = 0x087d;

    const XLS_Type_UNKNOWN = 0xffff;

    

    /**

     * Read data only?

     * Identifies whether the Reader should only read data values for cells, and ignore any formatting information;

     * or whether it should read both data and formatting

     *

     * @var	boolean

     */

    private $_readDataOnly = false;

    

    /**

     * Restrict which sheets should be loaded?

     * This property holds an array of worksheet names to be loaded. If null, then all worksheets will be loaded.

     *

     * @var	array of string

     */

    private $_loadSheetsOnly = null;

    

    /**

     * PHPExcel_Reader_IReadFilter instance

     *

     * @var PHPExcel_Reader_IReadFilter

     */

    private $_readFilter = null;

    

    /**

     * Summary Information stream data.

     *

     * @var string

     */

    private $_summaryInformation;

    

    /**

     * Extended Summary Information stream data.

     *

     * @var string

     */

    private $_documentSummaryInformation;

    

    /**

     * User-Defined Properties stream data.

     *

     * @var string

     */

    private $_userDefinedProperties;

    

    /**

     * Workbook stream data. (Includes workbook globals substream as well as sheet substreams)

     *

     * @var string

     */

    private $_data;

    

    /**

     * Size in bytes of $this->_data

     *

     * @var int

     */

    private $_dataSize;

    

    /**

     * Current position in stream

     *

     * @var integer

     */

    private $_pos;

    

    /**

     * Workbook to be returned by the reader.

     *

     * @var PHPExcel

     */

    private $_phpExcel;

    

    /**

     * Worksheet that is currently being built by the reader.

     *

     * @var PHPExcel_Worksheet

     */

    private $_phpSheet;

    

    /**

     * BIFF version

     *

     * @var int

     */

    private $_version;

    

    /**

     * Codepage set in the Excel file being read. Only important for BIFF5 (Excel 5.0 - Excel 95)

     * For BIFF8 (Excel 97 - Excel 2003) this will always have the value 'UTF-16LE'

     *

     * @var string

     */

    private $_codepage;

    

    /**

     * Shared formats

     *

     * @var array

     */

    private $_formats;

    

    /**

     * Shared fonts

     *

     * @var array

     */

    private $_objFonts;

    

    /**

     * Color palette

     *

     * @var array

     */

    private $_palette;

    

    /**

     * Worksheets

     *

     * @var array

     */

    private $_sheets;

    

    /**

     * External books

     *

     * @var array

     */

    private $_externalBooks;

    

    /**

     * REF structures. Only applies to BIFF8.

     *

     * @var array

     */

    private $_ref;

    

    /**

     * External names

     *

     * @var array

     */

    private $_externalNames;

    

    /**

     * Defined names

     *

     * @var array

     */

    private $_definedname;

    

    /**

     * Shared strings. Only applies to BIFF8.

     *

     * @var array

     */

    private $_sst;

    

    /**

     * Panes are frozen? (in sheet currently being read). See WINDOW2 record.

     *

     * @var boolean

     */

    private $_frozen;

    

    /**

     * Fit printout to number of pages? (in sheet currently being read). See SHEETPR record.

     *

     * @var boolean

     */

    private $_isFitToPages;

    

    /**

     * Objects. One OBJ record contributes with one entry.

     *

     * @var array

     */

    private $_objs;

    

    /**

     * Text Objects. One TXO record corresponds with one entry.

     *

     * @var array

     */

    private $_textObjects;

    

    /**

     * Cell Annotations (BIFF8)

     *

     * @var array

     */

    private $_cellNotes;

    

    /**

     * The combined MSODRAWINGGROUP data

     *

     * @var string

     */

    private $_drawingGroupData;

    

    /**

     * The combined MSODRAWING data (per sheet)

     *

     * @var string

     */

    private $_drawingData;

    

    /**

     * Keep track of XF index

     *

     * @var int

     */

    private $_xfIndex;

    

    /**

     * Mapping of XF index (that is a cell XF) to final index in cellXf collection

     *

     * @var array

     */

    private $_mapCellXfIndex;

    

    /**

     * Mapping of XF index (that is a style XF) to final index in cellStyleXf collection

     *

     * @var array

     */

    private $_mapCellStyleXfIndex;

    

    /**

     * The shared formulas in a sheet. One SHAREDFMLA record contributes with one value.

     *

     * @var array

     */

    private $_sharedFormulas;

    

    /**

     * The shared formula parts in a sheet. One FORMULA record contributes with one value if it

     * refers to a shared formula.

     *

     * @var array

     */

    private $_sharedFormulaParts;



    /**

     * Read data only?

     * If this is true, then the Reader will only read data values for cells, it will not read any formatting information.

     * If false (the default) it will read data and formatting.

     *

     * @return	boolean

     */

    public function getReadDataOnly()

    {

        return $this->_readDataOnly;

    }



    /**

     * Set read data only

     * Set to true, to advise the Reader only to read data values for cells, and to ignore any formatting information.

     * Set to false (the default) to advise the Reader to read both data and formatting for cells.

     *

     * @param	boolean	$pValue

     *

     * @return	PHPExcel_Reader_Excel5

     */

    public function setReadDataOnly($pValue = false)

    {

        $this->_readDataOnly = $pValue;

        return $this;

    }



    /**

     * Get which sheets to load

     * Returns either an array of worksheet names (the list of worksheets that should be loaded), or a null

     * indicating that all worksheets in the workbook should be loaded.

     *

     * @return mixed

     */

    public function getLoadSheetsOnly()

    {

        return $this->_loadSheetsOnly;

    }



    /**

     * Set which sheets to load

     *

     * @param mixed $value

     * This should be either an array of worksheet names to be loaded, or a string containing a single worksheet name.

     * If NULL, then it tells the Reader to read all worksheets in the workbook

     *

     * @return PHPExcel_Reader_Excel5

     */

    public function setLoadSheetsOnly($value = null)

    {

        $this->_loadSheetsOnly = is_array($value) ? $value : array($value);

        return $this;

    }



    /**

     * Set all sheets to load

     * Tells the Reader to load all worksheets from the workbook.

     *

     * @return	PHPExcel_Reader_Excel5

     */

    public function setLoadAllSheets()

    {

        $this->_loadSheetsOnly = null;

        return $this;

    }



    /**

     * Read filter

     *

     * @return PHPExcel_Reader_IReadFilter

     */

    public function getReadFilter()

    {

        return $this->_readFilter;

    }



    /**

     * Set read filter

     *

     * @param PHPExcel_Reader_IReadFilter $pValue

     * @return PHPExcel_Reader_Excel5

     */

    public function setReadFilter(PHPExcel_Reader_IReadFilter $pValue)

    {

        $this->_readFilter = $pValue;

        return $this;

    }



    /**

     * Create a new PHPExcel_Reader_Excel5 instance

     */

    public function __construct()

    {

        $this->_readFilter = new PHPExcel_Reader_DefaultReadFilter();

    }



    /**

     * Can the current PHPExcel_Reader_IReader read the file?

     *

     * @param 	string 		$pFileName

     * @return 	boolean

     */

    public function canRead($pFilename)

    {

        // Check if file exists

        if (! file_exists($pFilename))

        {

            throw new Exception("Could not open " . $pFilename . " for reading! File does not exist.");

        }

        

        try

        {

            // Use ParseXL for the hard work.

            $ole = new PHPExcel_Shared_OLERead();

            

            // get excel data

            $res = $ole->read($pFilename);

            return true;

        

        }

        catch (Exception $e)

        {

            return false;

        }

    }



    /**

     * Reads names of the worksheets from a file, without parsing the whole file to a PHPExcel object

     *

     * @param 	string 		$pFilename

     * @throws 	Exception

     */

    public function listWorksheetNames($pFilename)

    {

        // Check if file exists

        if (! file_exists($pFilename))

        {

            throw new Exception("Could not open " . $pFilename . " for reading! File does not exist.");

        }

        

        $worksheetNames = array();

        

        // Read the OLE file

        $this->_loadOLE($pFilename);

        

        // total byte size of Excel data (workbook global substream + sheet substreams)

        $this->_dataSize = strlen($this->_data);

        

        $this->_pos = 0;

        $this->_sheets = array();

        

        // Parse Workbook Global Substream

        while ($this->_pos < $this->_dataSize)

        {

            $code = self :: _GetInt2d($this->_data, $this->_pos);

            

            switch ($code)

            {

                case self :: XLS_Type_BOF :

                    $this->_readBof();

                    break;

                case self :: XLS_Type_SHEET :

                    $this->_readSheet();

                    break;

                case self :: XLS_Type_EOF :

                    $this->_readDefault();

                    break 2;

                default :

                    $this->_readDefault();

                    break;

            }

        }

        

        foreach ($this->_sheets as $sheet)

        {

            if ($sheet['sheetType'] != 0x00)

            {

                // 0x00: Worksheet, 0x02: Chart, 0x06: Visual Basic module

                continue;

            }

            

            $worksheetNames[] = $sheet['name'];

        }

        

        return $worksheetNames;

    }



    /**

     * Loads PHPExcel from file

     *

     * @param 	string 		$pFilename

     * @return 	PHPExcel

     * @throws 	Exception

     */

    public function load($pFilename)

    {

        // Read the OLE file

        $this->_loadOLE($pFilename);

        

        // Initialisations

        $this->_phpExcel = new PHPExcel();

        $this->_phpExcel->removeSheetByIndex(0); // remove 1st sheet

        if (! $this->_readDataOnly)

        {

            $this->_phpExcel->removeCellStyleXfByIndex(0); // remove the default style

            $this->_phpExcel->removeCellXfByIndex(0); // remove the default style

        }

        

        // Read the summary information stream (containing meta data)

        $this->_readSummaryInformation();

        

        // Read the Additional document summary information stream (containing application-specific meta data)

        $this->_readDocumentSummaryInformation();

        

        // total byte size of Excel data (workbook global substream + sheet substreams)

        $this->_dataSize = strlen($this->_data);

        

        // initialize

        $this->_pos = 0;

        $this->_codepage = 'CP1252';

        $this->_formats = array();

        $this->_objFonts = array();

        $this->_palette = array();

        $this->_sheets = array();

        $this->_externalBooks = array();

        $this->_ref = array();

        $this->_definedname = array();

        $this->_sst = array();

        $this->_drawingGroupData = '';

        $this->_xfIndex = '';

        $this->_mapCellXfIndex = array();

        $this->_mapCellStyleXfIndex = array();

        

        // Parse Workbook Global Substream

        while ($this->_pos < $this->_dataSize)

        {

            $code = self :: _GetInt2d($this->_data, $this->_pos);

            

            switch ($code)

            {

                case self :: XLS_Type_BOF :

                    $this->_readBof();

                    break;

                case self :: XLS_Type_FILEPASS :

                    $this->_readFilepass();

                    break;

                case self :: XLS_Type_CODEPAGE :

                    $this->_readCodepage();

                    break;

                case self :: XLS_Type_DATEMODE :

                    $this->_readDateMode();

                    break;

                case self :: XLS_Type_FONT :

                    $this->_readFont();

                    break;

                case self :: XLS_Type_FORMAT :

                    $this->_readFormat();

                    break;

                case self :: XLS_Type_XF :

                    $this->_readXf();

                    break;

                case self :: XLS_Type_XFEXT :

                    $this->_readXfExt();

                    break;

                case self :: XLS_Type_STYLE :

                    $this->_readStyle();

                    break;

                case self :: XLS_Type_PALETTE :

                    $this->_readPalette();

                    break;

                case self :: XLS_Type_SHEET :

                    $this->_readSheet();

                    break;

                case self :: XLS_Type_EXTERNALBOOK :

                    $this->_readExternalBook();

                    break;

                case self :: XLS_Type_EXTERNNAME :

                    $this->_readExternName();

                    break;

                case self :: XLS_Type_EXTERNSHEET :

                    $this->_readExternSheet();

                    break;

                case self :: XLS_Type_DEFINEDNAME :

                    $this->_readDefinedName();

                    break;

                case self :: XLS_Type_MSODRAWINGGROUP :

                    $this->_readMsoDrawingGroup();

                    break;

                case self :: XLS_Type_SST :

                    $this->_readSst();

                    break;

                case self :: XLS_Type_EOF :

                    $this->_readDefault();

                    break 2;

                default :

                    $this->_readDefault();

                    break;

            }

        }

        

        // Resolve indexed colors for font, fill, and border colors

        // Cannot be resolved already in XF record, because PALETTE record comes afterwards

        if (! $this->_readDataOnly)

        {

            foreach ($this->_objFonts as $objFont)

            {

                if (isset($objFont->colorIndex))

                {

                    $color = self :: _readColor($objFont->colorIndex, $this->_palette, $this->_version);

                    $objFont->getColor()->setRGB($color['rgb']);

                }

            }

            

            foreach ($this->_phpExcel->getCellXfCollection() as $objStyle)

            {

                // fill start and end color

                $fill = $objStyle->getFill();

                

                if (isset($fill->startcolorIndex))

                {

                    $startColor = self :: _readColor($fill->startcolorIndex, $this->_palette, $this->_version);

                    $fill->getStartColor()->setRGB($startColor['rgb']);

                }

                

                if (isset($fill->endcolorIndex))

                {

                    $endColor = self :: _readColor($fill->endcolorIndex, $this->_palette, $this->_version);

                    $fill->getEndColor()->setRGB($endColor['rgb']);

                }

                

                // border colors

                $top = $objStyle->getBorders()->getTop();

                $right = $objStyle->getBorders()->getRight();

                $bottom = $objStyle->getBorders()->getBottom();

                $left = $objStyle->getBorders()->getLeft();

                $diagonal = $objStyle->getBorders()->getDiagonal();

                

                if (isset($top->colorIndex))

                {

                    $borderTopColor = self :: _readColor($top->colorIndex, $this->_palette, $this->_version);

                    $top->getColor()->setRGB($borderTopColor['rgb']);

                }

                

                if (isset($right->colorIndex))

                {

                    $borderRightColor = self :: _readColor($right->colorIndex, $this->_palette, $this->_version);

                    $right->getColor()->setRGB($borderRightColor['rgb']);

                }

                

                if (isset($bottom->colorIndex))

                {

                    $borderBottomColor = self :: _readColor($bottom->colorIndex, $this->_palette, $this->_version);

                    $bottom->getColor()->setRGB($borderBottomColor['rgb']);

                }

                

                if (isset($left->colorIndex))

                {

                    $borderLeftColor = self :: _readColor($left->colorIndex, $this->_palette, $this->_version);

                    $left->getColor()->setRGB($borderLeftColor['rgb']);

                }

                

                if (isset($diagonal->colorIndex))

                {

                    $borderDiagonalColor = self :: _readColor($diagonal->colorIndex, $this->_palette, $this->_version);

                    $diagonal->getColor()->setRGB($borderDiagonalColor['rgb']);

                }

            }

        }

        

        // treat MSODRAWINGGROUP records, workbook-level Escher

        if (! $this->_readDataOnly && $this->_drawingGroupData)

        {

            $escherWorkbook = new PHPExcel_Shared_Escher();

            $reader = new PHPExcel_Reader_Excel5_Escher($escherWorkbook);

            $escherWorkbook = $reader->load($this->_drawingGroupData);

        

     // debug Escher stream

        //$debug = new Debug_Escher(new PHPExcel_Shared_Escher());

        //$debug->load($this->_drawingGroupData);

        }

        

        // Parse the individual sheets

        foreach ($this->_sheets as $sheet)

        {

            

            if ($sheet['sheetType'] != 0x00)

            {

                // 0x00: Worksheet, 0x02: Chart, 0x06: Visual Basic module

                continue;

            }

            

            // check if sheet should be skipped

            if (isset($this->_loadSheetsOnly) && ! in_array($sheet['name'], $this->_loadSheetsOnly))

            {

                continue;

            }

            

            // add sheet to PHPExcel object

            $this->_phpSheet = $this->_phpExcel->createSheet();

            $this->_phpSheet->setTitle($sheet['name']);

            $this->_phpSheet->setSheetState($sheet['sheetState']);

            

            $this->_pos = $sheet['offset'];

            

            // Initialize isFitToPages. May change after reading SHEETPR record.

            $this->_isFitToPages = false;

            

            // Initialize drawingData

            $this->_drawingData = '';

            

            // Initialize objs

            $this->_objs = array();

            

            // Initialize shared formula parts

            $this->_sharedFormulaParts = array();

            

            // Initialize shared formulas

            $this->_sharedFormulas = array();

            

            // Initialize text objs

            $this->_textObjects = array();

            

            // Initialize cell annotations

            $this->_cellNotes = array();

            $this->textObjRef = - 1;

            

            while ($this->_pos <= $this->_dataSize - 4)

            {

                $code = self :: _GetInt2d($this->_data, $this->_pos);

                

                switch ($code)

                {

                    case self :: XLS_Type_BOF :

                        $this->_readBof();

                        break;

                    case self :: XLS_Type_PRINTGRIDLINES :

                        $this->_readPrintGridlines();

                        break;

                    case self :: XLS_Type_DEFAULTROWHEIGHT :

                        $this->_readDefaultRowHeight();

                        break;

                    case self :: XLS_Type_SHEETPR :

                        $this->_readSheetPr();

                        break;

                    case self :: XLS_Type_HORIZONTALPAGEBREAKS :

                        $this->_readHorizontalPageBreaks();

                        break;

                    case self :: XLS_Type_VERTICALPAGEBREAKS :

                        $this->_readVerticalPageBreaks();

                        break;

                    case self :: XLS_Type_HEADER :

                        $this->_readHeader();

                        break;

                    case self :: XLS_Type_FOOTER :

                        $this->_readFooter();

                        break;

                    case self :: XLS_Type_HCENTER :

                        $this->_readHcenter();

                        break;

                    case self :: XLS_Type_VCENTER :

                        $this->_readVcenter();

                        break;

                    case self :: XLS_Type_LEFTMARGIN :

                        $this->_readLeftMargin();

                        break;

                    case self :: XLS_Type_RIGHTMARGIN :

                        $this->_readRightMargin();

                        break;

                    case self :: XLS_Type_TOPMARGIN :

                        $this->_readTopMargin();

                        break;

                    case self :: XLS_Type_BOTTOMMARGIN :

                        $this->_readBottomMargin();

                        break;

                    case self :: XLS_Type_PAGESETUP :

                        $this->_readPageSetup();

                        break;

                    case self :: XLS_Type_PROTECT :

                        $this->_readProtect();

                        break;

                    case self :: XLS_Type_SCENPROTECT :

                        $this->_readScenProtect();

                        break;

                    case self :: XLS_Type_OBJECTPROTECT :

                        $this->_readObjectProtect();

                        break;

                    case self :: XLS_Type_PASSWORD :

                        $this->_readPassword();

                        break;

                    case self :: XLS_Type_DEFCOLWIDTH :

                        $this->_readDefColWidth();

                        break;

                    case self :: XLS_Type_COLINFO :

                        $this->_readColInfo();

                        break;

                    case self :: XLS_Type_DIMENSION :

                        $this->_readDefault();

                        break;

                    case self :: XLS_Type_ROW :

                        $this->_readRow();

                        break;

                    case self :: XLS_Type_DBCELL :

                        $this->_readDefault();

                        break;

                    case self :: XLS_Type_RK :

                        $this->_readRk();

                        break;

                    case self :: XLS_Type_LABELSST :

                        $this->_readLabelSst();

                        break;

                    case self :: XLS_Type_MULRK :

                        $this->_readMulRk();

                        break;

                    case self :: XLS_Type_NUMBER :

                        $this->_readNumber();

                        break;

                    case self :: XLS_Type_FORMULA :

                        $this->_readFormula();

                        break;

                    case self :: XLS_Type_SHAREDFMLA :

                        $this->_readSharedFmla();

                        break;

                    case self :: XLS_Type_BOOLERR :

                        $this->_readBoolErr();

                        break;

                    case self :: XLS_Type_MULBLANK :

                        $this->_readMulBlank();

                        break;

                    case self :: XLS_Type_LABEL :

                        $this->_readLabel();

                        break;

                    case self :: XLS_Type_BLANK :

                        $this->_readBlank();

                        break;

                    case self :: XLS_Type_MSODRAWING :

                        $this->_readMsoDrawing();

                        break;

                    case self :: XLS_Type_OBJ :

                        $this->_readObj();

                        break;

                    case self :: XLS_Type_WINDOW2 :

                        $this->_readWindow2();

                        break;

                    case self :: XLS_Type_SCL :

                        $this->_readScl();

                        break;

                    case self :: XLS_Type_PANE :

                        $this->_readPane();

                        break;

                    case self :: XLS_Type_SELECTION :

                        $this->_readSelection();

                        break;

                    case self :: XLS_Type_MERGEDCELLS :

                        $this->_readMergedCells();

                        break;

                    case self :: XLS_Type_HYPERLINK :

                        $this->_readHyperLink();

                        break;

                    case self :: XLS_Type_DATAVALIDATIONS :

                        $this->_readDataValidations();

                        break;

                    case self :: XLS_Type_DATAVALIDATION :

                        $this->_readDataValidation();

                        break;

                    case self :: XLS_Type_SHEETLAYOUT :

                        $this->_readSheetLayout();

                        break;

                    case self :: XLS_Type_SHEETPROTECTION :

                        $this->_readSheetProtection();

                        break;

                    case self :: XLS_Type_RANGEPROTECTION :

                        $this->_readRangeProtection();

                        break;

                    case self :: XLS_Type_NOTE :

                        $this->_readNote();

                        break;

                    //case self::XLS_Type_IMDATA:				$this->_readImData();					break;

                    case self :: XLS_Type_TXO :

                        $this->_readTextObject();

                        break;

                    case self :: XLS_Type_CONTINUE :

                        $this->_readContinue();

                        break;

                    case self :: XLS_Type_EOF :

                        $this->_readDefault();

                        break 2;

                    default :

                        $this->_readDefault();

                        break;

                }

            

            }

            

            // treat MSODRAWING records, sheet-level Escher

            if (! $this->_readDataOnly && $this->_drawingData)

            {

                $escherWorksheet = new PHPExcel_Shared_Escher();

                $reader = new PHPExcel_Reader_Excel5_Escher($escherWorksheet);

                $escherWorksheet = $reader->load($this->_drawingData);

                

                // debug Escher stream

                //$debug = new Debug_Escher(new PHPExcel_Shared_Escher());

                //$debug->load($this->_drawingData);

                



                // get all spContainers in one long array, so they can be mapped to OBJ records

                $allSpContainers = $escherWorksheet->getDgContainer()->getSpgrContainer()->getAllSpContainers();

            }

            

            // treat OBJ records

            foreach ($this->_objs as $n => $obj)

            {

                //				echo '<hr /><b>Object</b> reference is ',$n,'<br />';

                //				var_dump($obj);

                //				echo '<br />';

                



                // the first shape container never has a corresponding OBJ record, hence $n + 1

                $spContainer = $allSpContainers[$n + 1];

                

                // we skip all spContainers that are a part of a group shape since we cannot yet handle those

                if ($spContainer->getNestingLevel() > 1)

                {

                    continue;

                }

                

                // calculate the width and height of the shape

                list($startColumn, $startRow) = PHPExcel_Cell :: coordinateFromString($spContainer->getStartCoordinates());

                list($endColumn, $endRow) = PHPExcel_Cell :: coordinateFromString($spContainer->getEndCoordinates());

                

                $startOffsetX = $spContainer->getStartOffsetX();

                $startOffsetY = $spContainer->getStartOffsetY();

                $endOffsetX = $spContainer->getEndOffsetX();

                $endOffsetY = $spContainer->getEndOffsetY();

                

                $width = PHPExcel_Shared_Excel5 :: getDistanceX($this->_phpSheet, $startColumn, $startOffsetX, $endColumn, $endOffsetX);

                $height = PHPExcel_Shared_Excel5 :: getDistanceY($this->_phpSheet, $startRow, $startOffsetY, $endRow, $endOffsetY);

                

                // calculate offsetX and offsetY of the shape

                $offsetX = $startOffsetX * PHPExcel_Shared_Excel5 :: sizeCol($this->_phpSheet, $startColumn) / 1024;

                $offsetY = $startOffsetY * PHPExcel_Shared_Excel5 :: sizeRow($this->_phpSheet, $startRow) / 256;

                

                switch ($obj['otObjType'])

                {

                    

                    case 0x19 :

                        // Note

                        //					echo 'Cell Annotation Object<br />';

                        //					echo 'Object ID is ',$obj['idObjID'],'<br />';

                        //

                        if (isset($this->_cellNotes[$obj['idObjID']]))

                        {

                            $cellNote = $this->_cellNotes[$obj['idObjID']];

                            

                            //						echo '_cellNotes[',$obj['idObjID'],']: ';

                            //						var_dump($cellNote);

                            //						echo '<br />';

                            //

                            if (isset($this->_textObjects[$obj['idObjID']]))

                            {

                                $textObject = $this->_textObjects[$obj['idObjID']];

                                //							echo '_textObject: ';

                                //							var_dump($textObject);

                                //							echo '<br />';

                                //

                                $this->_cellNotes[$obj['idObjID']]['objTextData'] = $textObject;

                                $text = $textObject['text'];

                            }

                        

     //						echo $text,'<br />';

                        }

                        break;

                    

                    case 0x08 :

                        //					echo 'Picture Object<br />';

                        // picture

                        



                        // get index to BSE entry (1-based)

                        $BSEindex = $spContainer->getOPT(0x0104);

                        $BSECollection = $escherWorkbook->getDggContainer()->getBstoreContainer()->getBSECollection();

                        $BSE = $BSECollection[$BSEindex - 1];

                        $blipType = $BSE->getBlipType();

                        

                        // need check because some blip types are not supported by Escher reader such as EMF

                        if ($blip = $BSE->getBlip())

                        {

                            $ih = imagecreatefromstring($blip->getData());

                            $drawing = new PHPExcel_Worksheet_MemoryDrawing();

                            $drawing->setImageResource($ih);

                            

                            // width, height, offsetX, offsetY

                            $drawing->setResizeProportional(false);

                            $drawing->setWidth($width);

                            $drawing->setHeight($height);

                            $drawing->setOffsetX($offsetX);

                            $drawing->setOffsetY($offsetY);

                            

                            switch ($blipType)

                            {

                                case PHPExcel_Shared_Escher_DggContainer_BstoreContainer_BSE :: BLIPTYPE_JPEG :

                                    $drawing->setRenderingFunction(PHPExcel_Worksheet_MemoryDrawing :: RENDERING_JPEG);

                                    $drawing->setMimeType(PHPExcel_Worksheet_MemoryDrawing :: MIMETYPE_JPEG);

                                    break;

                                

                                case PHPExcel_Shared_Escher_DggContainer_BstoreContainer_BSE :: BLIPTYPE_PNG :

                                    $drawing->setRenderingFunction(PHPExcel_Worksheet_MemoryDrawing :: RENDERING_PNG);

                                    $drawing->setMimeType(PHPExcel_Worksheet_MemoryDrawing :: MIMETYPE_PNG);

                                    break;

                            }

                            

                            $drawing->setWorksheet($this->_phpSheet);

                            $drawing->setCoordinates($spContainer->getStartCoordinates());

                        }

                        

                        break;

                    

                    default :

                        // other object type

                        break;

                

                }

            }

            

            // treat SHAREDFMLA records

            if ($this->_version == self :: XLS_BIFF8)

            {

                foreach ($this->_sharedFormulaParts as $cell => $baseCell)

                {

                    list($column, $row) = PHPExcel_Cell :: coordinateFromString($cell);

                    if (! is_null($this->getReadFilter()) && $this->getReadFilter()->readCell($column, $row, $this->_phpSheet->getTitle()))

                    {

                        $formula = $this->_getFormulaFromStructure($this->_sharedFormulas[$baseCell], $cell);

                        $this->_phpSheet->getCell($cell)->setValueExplicit('=' . $formula, PHPExcel_Cell_DataType :: TYPE_FORMULA);

                    }

                }

            }

            

            if (count($this->_cellNotes) > 0)

            {

                foreach ($this->_cellNotes as $note => $noteDetails)

                {

                    //					echo '<b>Cell annotation ',$note,'</b><br />';

                    //					var_dump($noteDetails);

                    //					echo '<br />';

                    $cellAddress = str_replace('$', '', $noteDetails['cellRef']);

                    $this->_phpSheet->getComment($cellAddress)->setAuthor($noteDetails['author'])->setText($this->_parseRichText($noteDetails['objTextData']['text']));

                }

            }

        }

        

        // add the named ranges (defined names)

        foreach ($this->_definedname as $definedName)

        {

            if ($definedName['isBuiltInName'])

            {

                switch ($definedName['name'])

                {

                    

                    case pack('C', 0x06) :

                        // print area

                        //	in general, formula looks like this: Foo!$C$7:$J$66,Bar!$A$1:$IV$2

                        



                        $ranges = explode(',', $definedName['formula']); // FIXME: what if sheetname contains comma?

                        



                        $extractedRanges = array();

                        foreach ($ranges as $range)

                        {

                            // $range should look like one of these

                            //		Foo!$C$7:$J$66

                            //		Bar!$A$1:$IV$2

                            



                            $explodes = explode('!', $range); // FIXME: what if sheetname contains exclamation mark?

                            $sheetName = $explodes[0];

                            

                            if (count($explodes) == 2)

                            {

                                $extractedRanges[] = str_replace('$', '', $explodes[1]); // C7:J66

                            }

                        }

                        if ($docSheet = $this->_phpExcel->getSheetByName($sheetName))

                        {

                            $docSheet->getPageSetup()->setPrintArea(implode(',', $extractedRanges)); // C7:J66,A1:IV2

                        }

                        break;

                    

                    case pack('C', 0x07) :

                        // print titles (repeating rows)

                        // Assuming BIFF8, there are 3 cases

                        // 1. repeating rows

                        //		formula looks like this: Sheet!$A$1:$IV$2

                        //		rows 1-2 repeat

                        // 2. repeating columns

                        //		formula looks like this: Sheet!$A$1:$B$65536

                        //		columns A-B repeat

                        // 3. both repeating rows and repeating columns

                        //		formula looks like this: Sheet!$A$1:$B$65536,Sheet!$A$1:$IV$2

                        



                        $ranges = explode(',', $definedName['formula']); // FIXME: what if sheetname contains comma?

                        



                        foreach ($ranges as $range)

                        {

                            // $range should look like this one of these

                            //		Sheet!$A$1:$B$65536

                            //		Sheet!$A$1:$IV$2

                            



                            $explodes = explode('!', $range);

                            

                            if (count($explodes) == 2)

                            {

                                if ($docSheet = $this->_phpExcel->getSheetByName($explodes[0]))

                                {

                                    

                                    $extractedRange = $explodes[1];

                                    $extractedRange = str_replace('$', '', $extractedRange);

                                    

                                    $coordinateStrings = explode(':', $extractedRange);

                                    if (count($coordinateStrings) == 2)

                                    {

                                        list($firstColumn, $firstRow) = PHPExcel_Cell :: coordinateFromString($coordinateStrings[0]);

                                        list($lastColumn, $lastRow) = PHPExcel_Cell :: coordinateFromString($coordinateStrings[1]);

                                        

                                        if ($firstColumn == 'A' and $lastColumn == 'IV')

                                        {

                                            // then we have repeating rows

                                            $docSheet->getPageSetup()->setRowsToRepeatAtTop(array(

                                                    $firstRow, $lastRow));

                                        }

                                        elseif ($firstRow == 1 and $lastRow == 65536)

                                        {

                                            // then we have repeating columns

                                            $docSheet->getPageSetup()->setColumnsToRepeatAtLeft(array(

                                                    $firstColumn, $lastColumn));

                                        }

                                    }

                                }

                            }

                        }

                        break;

                

                }

            }

            else

            {

                // Extract range

                $explodes = explode('!', $definedName['formula']);

                

                if (count($explodes) == 2)

                {

                    if ($docSheet = $this->_phpExcel->getSheetByName($explodes[0]))

                    {

                        $extractedRange = $explodes[1];

                        $extractedRange = str_replace('$', '', $extractedRange);

                        

                        $localOnly = ($definedName['scope'] == 0) ? false : true;

                        $scope = ($definedName['scope'] == 0) ? null : $this->_phpExcel->getSheetByName($this->_sheets[$definedName['scope'] - 1]['name']);

                        

                        $this->_phpExcel->addNamedRange(new PHPExcel_NamedRange((string) $definedName['name'], $docSheet, $extractedRange, $localOnly, $scope));

                    }

                }

            }

        }

        

        return $this->_phpExcel;

    }



    /**

     * Use OLE reader to extract the relevant data streams from the OLE file

     *

     * @param string $pFilename

     */

    private function _loadOLE($pFilename)

    {

        // OLE reader

        $ole = new PHPExcel_Shared_OLERead();

        

        // get excel data,

        $res = $ole->read($pFilename);

        // Get workbook data: workbook stream + sheet streams

        $this->_data = $ole->getStream($ole->wrkbook);

        

        // Get summary information data

        $this->_summaryInformation = $ole->getStream($ole->summaryInformation);

        

        // Get additional document summary information data

        $this->_documentSummaryInformation = $ole->getStream($ole->documentSummaryInformation);

    

     // Get user-defined property data

    //		$this->_userDefinedProperties = $ole->getUserDefinedProperties();

    }



    /**

     * Read summary information

     */

    private function _readSummaryInformation()

    {

        if (! isset($this->_summaryInformation))

        {

            return;

        }

        

        // offset: 0; size: 2; must be 0xFE 0xFF (UTF-16 LE byte order mark)

        // offset: 2; size: 2;

        // offset: 4; size: 2; OS version

        // offset: 6; size: 2; OS indicator

        // offset: 8; size: 16

        // offset: 24; size: 4; section count

        $secCount = self :: _GetInt4d($this->_summaryInformation, 24);

        

        // offset: 28; size: 16; first section's class id: e0 85 9f f2 f9 4f 68 10 ab 91 08 00 2b 27 b3 d9

        // offset: 44; size: 4

        $secOffset = self :: _GetInt4d($this->_summaryInformation, 44);

        

        // section header

        // offset: $secOffset; size: 4; section length

        $secLength = self :: _GetInt4d($this->_summaryInformation, $secOffset);

        

        // offset: $secOffset+4; size: 4; property count

        $countProperties = self :: _GetInt4d($this->_summaryInformation, $secOffset + 4);

        

        // initialize code page (used to resolve string values)

        $codePage = 'CP1252';

        

        // offset: ($secOffset+8); size: var

        // loop through property decarations and properties

        for($i = 0; $i < $countProperties; ++ $i)

        {

            

            // offset: ($secOffset+8) + (8 * $i); size: 4; property ID

            $id = self :: _GetInt4d($this->_summaryInformation, ($secOffset + 8) + (8 * $i));

            

            // Use value of property id as appropriate

            // offset: ($secOffset+12) + (8 * $i); size: 4; offset from beginning of section (48)

            $offset = self :: _GetInt4d($this->_summaryInformation, ($secOffset + 12) + (8 * $i));

            

            $type = self :: _GetInt4d($this->_summaryInformation, $secOffset + $offset);

            

            // initialize property value

            $value = null;

            

            // extract property value based on property type

            switch ($type)

            {

                case 0x02 : // 2 byte signed integer

                    $value = self :: _GetInt2d($this->_summaryInformation, $secOffset + 4 + $offset);

                    break;

                

                case 0x03 : // 4 byte signed integer

                    $value = self :: _GetInt4d($this->_summaryInformation, $secOffset + 4 + $offset);

                    break;

                

                case 0x13 : // 4 byte unsigned integer

                    // not needed yet, fix later if necessary

                    break;

                

                case 0x1E : // null-terminated string prepended by dword string length

                    $byteLength = self :: _GetInt4d($this->_summaryInformation, $secOffset + 4 + $offset);

                    $value = substr($this->_summaryInformation, $secOffset + 8 + $offset, $byteLength);

                    $value = PHPExcel_Shared_String :: ConvertEncoding($value, 'UTF-8', $codePage);

                    $value = rtrim($value);

                    break;

                

                case 0x40 : // Filetime (64-bit value representing the number of 100-nanosecond intervals since January 1, 1601)

                    // PHP-time

                    $value = PHPExcel_Shared_OLE :: OLE2LocalDate(substr($this->_summaryInformation, $secOffset + 4 + $offset, 8));

                    break;

                

                case 0x47 : // Clipboard format

                    // not needed yet, fix later if necessary

                    break;

            }

            

            switch ($id)

            {

                case 0x01 : //	Code Page

                    $codePage = PHPExcel_Shared_CodePage :: NumberToName($value);

                    break;

                

                case 0x02 : //	Title

                    $this->_phpExcel->getProperties()->setTitle($value);

                    break;

                

                case 0x03 : //	Subject

                    $this->_phpExcel->getProperties()->setSubject($value);

                    break;

                

                case 0x04 : //	Author (Creator)

                    $this->_phpExcel->getProperties()->setCreator($value);

                    break;

                

                case 0x05 : //	Keywords

                    $this->_phpExcel->getProperties()->setKeywords($value);

                    break;

                

                case 0x06 : //	Comments (Description)

                    $this->_phpExcel->getProperties()->setDescription($value);

                    break;

                

                case 0x07 : //	Template

                    //	Not supported by PHPExcel

                    break;

                

                case 0x08 : //	Last Saved By (LastModifiedBy)

                    $this->_phpExcel->getProperties()->setLastModifiedBy($value);

                    break;

                

                case 0x09 : //	Revision

                    //	Not supported by PHPExcel

                    break;

                

                case 0x0A : //	Total Editing Time

                    //	Not supported by PHPExcel

                    break;

                

                case 0x0B : //	Last Printed

                    //	Not supported by PHPExcel

                    break;

                

                case 0x0C : //	Created Date/Time

                    $this->_phpExcel->getProperties()->setCreated($value);

                    break;

                

                case 0x0D : //	Modified Date/Time

                    $this->_phpExcel->getProperties()->setModified($value);

                    break;

                

                case 0x0E : //	Number of Pages

                    //	Not supported by PHPExcel

                    break;

                

                case 0x0F : //	Number of Words

                    //	Not supported by PHPExcel

                    break;

                

                case 0x10 : //	Number of Characters

                    //	Not supported by PHPExcel

                    break;

                

                case 0x11 : //	Thumbnail

                    //	Not supported by PHPExcel

                    break;

                

                case 0x12 : //	Name of creating application

                    //	Not supported by PHPExcel

                    break;

                

                case 0x13 : //	Security

                    //	Not supported by PHPExcel

                    break;

            

            }

        }

    }



    /**

     * Read additional document summary information

     */

    private function _readDocumentSummaryInformation()

    {

        if (! isset($this->_documentSummaryInformation))

        {

            return;

        }

        

        //	offset: 0;	size: 2;	must be 0xFE 0xFF (UTF-16 LE byte order mark)

        //	offset: 2;	size: 2;

        //	offset: 4;	size: 2;	OS version

        //	offset: 6;	size: 2;	OS indicator

        //	offset: 8;	size: 16

        //	offset: 24;	size: 4;	section count

        $secCount = self :: _GetInt4d($this->_documentSummaryInformation, 24);

        //		echo '$secCount = ',$secCount,'<br />';

        



        // offset: 28;	size: 16;	first section's class id: 02 d5 cd d5 9c 2e 1b 10 93 97 08 00 2b 2c f9 ae

        // offset: 44;	size: 4;	first section offset

        $secOffset = self :: _GetInt4d($this->_documentSummaryInformation, 44);

        //		echo '$secOffset = ',$secOffset,'<br />';

        



        //	section header

        //	offset: $secOffset;	size: 4;	section length

        $secLength = self :: _GetInt4d($this->_documentSummaryInformation, $secOffset);

        //		echo '$secLength = ',$secLength,'<br />';

        



        //	offset: $secOffset+4;	size: 4;	property count

        $countProperties = self :: _GetInt4d($this->_documentSummaryInformation, $secOffset + 4);

        //		echo '$countProperties = ',$countProperties,'<br />';

        



        // initialize code page (used to resolve string values)

        $codePage = 'CP1252';

        

        //	offset: ($secOffset+8);	size: var

        //	loop through property decarations and properties

        for($i = 0; $i < $countProperties; ++ $i)

        {

            //			echo 'Property ',$i,'<br />';

            //	offset: ($secOffset+8) + (8 * $i);	size: 4;	property ID

            $id = self :: _GetInt4d($this->_documentSummaryInformation, ($secOffset + 8) + (8 * $i));

            //			echo 'ID is ',$id,'<br />';

            



            // Use value of property id as appropriate

            // offset: 60 + 8 * $i;	size: 4;	offset from beginning of section (48)

            $offset = self :: _GetInt4d($this->_documentSummaryInformation, ($secOffset + 12) + (8 * $i));

            

            $type = self :: _GetInt4d($this->_documentSummaryInformation, $secOffset + $offset);

            //			echo 'Type is ',$type,', ';

            



            // initialize property value

            $value = null;

            

            // extract property value based on property type

            switch ($type)

            {

                case 0x02 : //	2 byte signed integer

                    $value = self :: _GetInt2d($this->_documentSummaryInformation, $secOffset + 4 + $offset);

                    break;

                

                case 0x03 : //	4 byte signed integer

                    $value = self :: _GetInt4d($this->_documentSummaryInformation, $secOffset + 4 + $offset);

                    break;

                

                case 0x13 : //	4 byte unsigned integer

                    // not needed yet, fix later if necessary

                    break;

                

                case 0x1E : //	null-terminated string prepended by dword string length

                    $byteLength = self :: _GetInt4d($this->_documentSummaryInformation, $secOffset + 4 + $offset);

                    $value = substr($this->_documentSummaryInformation, $secOffset + 8 + $offset, $byteLength);

                    $value = PHPExcel_Shared_String :: ConvertEncoding($value, 'UTF-8', $codePage);

                    $value = rtrim($value);

                    break;

                

                case 0x40 : //	Filetime (64-bit value representing the number of 100-nanosecond intervals since January 1, 1601)

                    // PHP-Time

                    $value = PHPExcel_Shared_OLE :: OLE2LocalDate(substr($this->_documentSummaryInformation, $secOffset + 4 + $offset, 8));

                    break;

                

                case 0x47 : //	Clipboard format

                    // not needed yet, fix later if necessary

                    break;

            }

            

            switch ($id)

            {

                case 0x01 : //	Code Page

                    $codePage = PHPExcel_Shared_CodePage :: NumberToName($value);

                    break;

                

                case 0x02 : //	Category

                    $this->_phpExcel->getProperties()->setCategory($value);

                    break;

                

                case 0x03 : //	Presentation Target

                    //	Not supported by PHPExcel

                    break;

                

                case 0x04 : //	Bytes

                    //	Not supported by PHPExcel

                    break;

                

                case 0x05 : //	Lines

                    //	Not supported by PHPExcel

                    break;

                

                case 0x06 : //	Paragraphs

                    //	Not supported by PHPExcel

                    break;

                

                case 0x07 : //	Slides

                    //	Not supported by PHPExcel

                    break;

                

                case 0x08 : //	Notes

                    //	Not supported by PHPExcel

                    break;

                

                case 0x09 : //	Hidden Slides

                    //	Not supported by PHPExcel

                    break;

                

                case 0x0A : //	MM Clips

                    //	Not supported by PHPExcel

                    break;

                

                case 0x0B : //	Scale Crop

                    //	Not supported by PHPExcel

                    break;

                

                case 0x0C : //	Heading Pairs

                    //	Not supported by PHPExcel

                    break;

                

                case 0x0D : //	Titles of Parts

                    //	Not supported by PHPExcel

                    break;

                

                case 0x0E : //	Manager

                    $this->_phpExcel->getProperties()->setManager($value);

                    break;

                

                case 0x0F : //	Company

                    $this->_phpExcel->getProperties()->setCompany($value);

                    break;

                

                case 0x10 : //	Links up-to-date

                    //	Not supported by PHPExcel

                    break;

            

            }

        }

    }



    /**

     * Reads a general type of BIFF record. Does nothing except for moving stream pointer forward to next record.

     */

    private function _readDefault()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        //		$recordData = substr($this->_data, $this->_pos + 4, $length);

        



        // move stream pointer to next record

        $this->_pos += 4 + $length;

    }



    /**

     * The NOTE record specifies a comment associated with a particular cell. In Excel 95 (BIFF7) and earlier versions,

     * this record stores a note (cell note). This feature was significantly enhanced in Excel 97.

     */

    private function _readNote()

    {

        //		echo '<b>Read Cell Annotation</b><br />';

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        $recordData = substr($this->_data, $this->_pos + 4, $length);

        

        // move stream pointer to next record

        $this->_pos += 4 + $length;

        

        if ($this->_readDataOnly)

        {

            return;

        }

        

        $cellAddress = $this->_readBIFF8CellAddress(substr($recordData, 0, 4));

        if ($this->_version == self :: XLS_BIFF8)

        {

            $noteObjID = self :: _GetInt2d($recordData, 6);

            $noteAuthor = self :: _readUnicodeStringLong(substr($recordData, 8));

            $noteAuthor = $noteAuthor['value'];

            //			echo 'Note Address=',$cellAddress,'<br />';

            //			echo 'Note Object ID=',$noteObjID,'<br />';

            //			echo 'Note Author=',$noteAuthor,'<hr />';

            //

            $this->_cellNotes[$noteObjID] = array(

                    'cellRef' => $cellAddress, 'objectID' => $noteObjID, 'author' => $noteAuthor);

        }

        else

        {

            $extension = false;

            if ($cellAddress == '$B$65536')

            {

                //	If the address row is -1 and the column is 0, (which translates as $B$65536) then this is a continuation

                //		note from the previous cell annotation. We're not yet handling this, so annotations longer than the

                //		max 2048 bytes will probably throw a wobbly.

                $row = self :: _GetInt2d($recordData, 0);

                $extension = true;

                $cellAddress = array_pop(array_keys($this->_phpSheet->getComments()));

            }

            //			echo 'Note Address=',$cellAddress,'<br />';

            



            $cellAddress = str_replace('$', '', $cellAddress);

            $noteLength = self :: _GetInt2d($recordData, 4);

            $noteText = trim(substr($recordData, 6));

            //			echo 'Note Length=',$noteLength,'<br />';

            //			echo 'Note Text=',$noteText,'<br />';

            



            if ($extension)

            {

                //	Concatenate this extension with the currently set comment for the cell

                $comment = $this->_phpSheet->getComment($cellAddress);

                $commentText = $comment->getText()->getPlainText();

                $comment->setText($this->_parseRichText($commentText . $noteText));

            }

            else

            {

                //	Set comment for the cell

                $this->_phpSheet->getComment($cellAddress)->//													->setAuthor( $author )

                setText($this->_parseRichText($noteText));

            }

        }

    

    }



    /**

     * The TEXT Object record contains the text associated with a cell annotation.

     */

    private function _readTextObject()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        $recordData = substr($this->_data, $this->_pos + 4, $length);

        

        // move stream pointer to next record

        $this->_pos += 4 + $length;

        

        if ($this->_readDataOnly)

        {

            return;

        }

        

        // recordData consists of an array of subrecords looking like this:

        //	grbit: 2 bytes; Option Flags

        //	rot: 2 bytes; rotation

        //	cchText: 2 bytes; length of the text (in the first continue record)

        //	cbRuns: 2 bytes; length of the formatting (in the second continue record)

        // followed by the continuation records containing the actual text and formatting

        $grbitOpts = self :: _GetInt2d($recordData, 0);

        $rot = self :: _GetInt2d($recordData, 2);

        $cchText = self :: _GetInt2d($recordData, 10);

        $cbRuns = self :: _GetInt2d($recordData, 12);

        $text = $this->_getSplicedRecordData();

        

        $this->_textObjects[$this->textObjRef] = array(

                'text' => substr($text["recordData"], $text["spliceOffsets"][0] + 1, $cchText), 

                'format' => substr($text["recordData"], $text["spliceOffsets"][1], $cbRuns), 'alignment' => $grbitOpts, 

                'rotation' => $rot);

    

     //		echo '<b>_readTextObject()</b><br />';

    //		var_dump($this->_textObjects[$this->textObjRef]);

    //		echo '<br />';

    }



    /**

     * Read BOF

     */

    private function _readBof()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        $recordData = substr($this->_data, $this->_pos + 4, $length);

        

        // move stream pointer to next record

        $this->_pos += 4 + $length;

        

        // offset: 2; size: 2; type of the following data

        $substreamType = self :: _GetInt2d($recordData, 2);

        

        switch ($substreamType)

        {

            case self :: XLS_WorkbookGlobals :

                $version = self :: _GetInt2d($recordData, 0);

                if (($version != self :: XLS_BIFF8) && ($version != self :: XLS_BIFF7))

                {

                    throw new Exception('Cannot read this Excel file. Version is too old.');

                }

                $this->_version = $version;

                break;

            

            case self :: XLS_Worksheet :

                // do not use this version information for anything

                // it is unreliable (OpenOffice doc, 5.8), use only version information from the global stream

                break;

            

            default :

                // substream, e.g. chart

                // just skip the entire substream

                do

                {

                    $code = self :: _GetInt2d($this->_data, $this->_pos);

                    $this->_readDefault();

                }

                while ($code != self :: XLS_Type_EOF && $this->_pos < $this->_dataSize);

                break;

        }

    }



    /**

     * FILEPASS

     *

     * This record is part of the File Protection Block. It

     * contains information about the read/write password of the

     * file. All record contents following this record will be

     * encrypted.

     *

     * --	"OpenOffice.org's Documentation of the Microsoft

     * Excel File Format"

     */

    private function _readFilepass()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        //		$recordData = substr($this->_data, $this->_pos + 4, $length);

        



        // move stream pointer to next record

        $this->_pos += 4 + $length;

        

        throw new Exception('Cannot read encrypted file');

    }



    /**

     * CODEPAGE

     *

     * This record stores the text encoding used to write byte

     * strings, stored as MS Windows code page identifier.

     *

     * --	"OpenOffice.org's Documentation of the Microsoft

     * Excel File Format"

     */

    private function _readCodepage()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        $recordData = substr($this->_data, $this->_pos + 4, $length);

        

        // move stream pointer to next record

        $this->_pos += 4 + $length;

        

        // offset: 0; size: 2; code page identifier

        $codepage = self :: _GetInt2d($recordData, 0);

        

        $this->_codepage = PHPExcel_Shared_CodePage :: NumberToName($codepage);

    }



    /**

     * DATEMODE

     *

     * This record specifies the base date for displaying date

     * values. All dates are stored as count of days past this

     * base date. In BIFF2-BIFF4 this record is part of the

     * Calculation Settings Block. In BIFF5-BIFF8 it is

     * stored in the Workbook Globals Substream.

     *

     * --	"OpenOffice.org's Documentation of the Microsoft

     * Excel File Format"

     */

    private function _readDateMode()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        $recordData = substr($this->_data, $this->_pos + 4, $length);

        

        // move stream pointer to next record

        $this->_pos += 4 + $length;

        

        // offset: 0; size: 2; 0 = base 1900, 1 = base 1904

        PHPExcel_Shared_Date :: setExcelCalendar(PHPExcel_Shared_Date :: CALENDAR_WINDOWS_1900);

        if (ord($recordData{0}) == 1)

        {

            PHPExcel_Shared_Date :: setExcelCalendar(PHPExcel_Shared_Date :: CALENDAR_MAC_1904);

        }

    }



    /**

     * Read a FONT record

     */

    private function _readFont()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        $recordData = substr($this->_data, $this->_pos + 4, $length);

        

        // move stream pointer to next record

        $this->_pos += 4 + $length;

        

        if (! $this->_readDataOnly)

        {

            $objFont = new PHPExcel_Style_Font();

            

            // offset: 0; size: 2; height of the font (in twips = 1/20 of a point)

            $size = self :: _GetInt2d($recordData, 0);

            $objFont->setSize($size / 20);

            

            // offset: 2; size: 2; option flags

            // bit: 0; mask 0x0001; bold (redundant in BIFF5-BIFF8)

            // bit: 1; mask 0x0002; italic

            $isItalic = (0x0002 & self :: _GetInt2d($recordData, 2)) >> 1;

            if ($isItalic)

                $objFont->setItalic(true);

            

     // bit: 2; mask 0x0004; underlined (redundant in BIFF5-BIFF8)

            // bit: 3; mask 0x0008; strike

            $isStrike = (0x0008 & self :: _GetInt2d($recordData, 2)) >> 3;

            if ($isStrike)

                $objFont->setStrikethrough(true);

            

     // offset: 4; size: 2; colour index

            $colorIndex = self :: _GetInt2d($recordData, 4);

            $objFont->colorIndex = $colorIndex;

            

            // offset: 6; size: 2; font weight

            $weight = self :: _GetInt2d($recordData, 6);

            switch ($weight)

            {

                case 0x02BC :

                    $objFont->setBold(true);

                    break;

            }

            

            // offset: 8; size: 2; escapement type

            $escapement = self :: _GetInt2d($recordData, 8);

            switch ($escapement)

            {

                case 0x0001 :

                    $objFont->setSuperScript(true);

                    break;

                case 0x0002 :

                    $objFont->setSubScript(true);

                    break;

            }

            

            // offset: 10; size: 1; underline type

            $underlineType = ord($recordData{10});

            switch ($underlineType)

            {

                case 0x00 :

                    break; // no underline

                case 0x01 :

                    $objFont->setUnderline(PHPExcel_Style_Font :: UNDERLINE_SINGLE);

                    break;

                case 0x02 :

                    $objFont->setUnderline(PHPExcel_Style_Font :: UNDERLINE_DOUBLE);

                    break;

                case 0x21 :

                    $objFont->setUnderline(PHPExcel_Style_Font :: UNDERLINE_SINGLEACCOUNTING);

                    break;

                case 0x22 :

                    $objFont->setUnderline(PHPExcel_Style_Font :: UNDERLINE_DOUBLEACCOUNTING);

                    break;

            }

            

            // offset: 11; size: 1; font family

            // offset: 12; size: 1; character set

            // offset: 13; size: 1; not used

            // offset: 14; size: var; font name

            if ($this->_version == self :: XLS_BIFF8)

            {

                $string = self :: _readUnicodeStringShort(substr($recordData, 14));

            }

            else

            {

                $string = $this->_readByteStringShort(substr($recordData, 14));

            }

            $objFont->setName($string['value']);

            

            $this->_objFonts[] = $objFont;

        }

    }



    /**

     * FORMAT

     *

     * This record contains information about a number format.

     * All FORMAT records occur together in a sequential list.

     *

     * In BIFF2-BIFF4 other records referencing a FORMAT record

     * contain a zero-based index into this list. From BIFF5 on

     * the FORMAT record contains the index itself that will be

     * used by other records.

     *

     * --	"OpenOffice.org's Documentation of the Microsoft

     * Excel File Format"

     */

    private function _readFormat()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        $recordData = substr($this->_data, $this->_pos + 4, $length);

        

        // move stream pointer to next record

        $this->_pos += 4 + $length;

        

        if (! $this->_readDataOnly)

        {

            $indexCode = self :: _GetInt2d($recordData, 0);

            

            if ($this->_version == self :: XLS_BIFF8)

            {

                $string = self :: _readUnicodeStringLong(substr($recordData, 2));

            }

            else

            {

                // BIFF7

                $string = $this->_readByteStringShort(substr($recordData, 2));

            }

            

            $formatString = $string['value'];

            $this->_formats[$indexCode] = $formatString;

        }

    }



    /**

     * XF - Extended Format

     *

     * This record contains formatting information for cells, rows, columns or styles.

     * According to http://support.microsoft.com/kb/147732 there are always at least 15 cell style XF

     * and 1 cell XF.

     * Inspection of Excel files generated by MS Office Excel shows that XF records 0-14 are cell style XF

     * and XF record 15 is a cell XF

     * We only read the first cell style XF and skip the remaining cell style XF records

     * We read all cell XF records.

     *

     * --	"OpenOffice.org's Documentation of the Microsoft

     * Excel File Format"

     */

    private function _readXf()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        $recordData = substr($this->_data, $this->_pos + 4, $length);

        

        // move stream pointer to next record

        $this->_pos += 4 + $length;

        

        $objStyle = new PHPExcel_Style();

        

        if (! $this->_readDataOnly)

        {

            // offset:  0; size: 2; Index to FONT record

            if (self :: _GetInt2d($recordData, 0) < 4)

            {

                $fontIndex = self :: _GetInt2d($recordData, 0);

            }

            else

            {

                // this has to do with that index 4 is omitted in all BIFF versions for some strange reason

                // check the OpenOffice documentation of the FONT record

                $fontIndex = self :: _GetInt2d($recordData, 0) - 1;

            }

            $objStyle->setFont($this->_objFonts[$fontIndex]);

            

            // offset:  2; size: 2; Index to FORMAT record

            $numberFormatIndex = self :: _GetInt2d($recordData, 2);

            if (isset($this->_formats[$numberFormatIndex]))

            {

                // then we have user-defined format code

                $numberformat = array('code' => $this->_formats[$numberFormatIndex]);

            }

            elseif (($code = PHPExcel_Style_NumberFormat :: builtInFormatCode($numberFormatIndex)) !== '')

            {

                // then we have built-in format code

                $numberformat = array('code' => $code);

            }

            else

            {

                // we set the general format code

                $numberformat = array('code' => 'General');

            }

            $objStyle->getNumberFormat()->setFormatCode($numberformat['code']);

            

            // offset:  4; size: 2; XF type, cell protection, and parent style XF

            // bit 2-0; mask 0x0007; XF_TYPE_PROT

            $xfTypeProt = self :: _GetInt2d($recordData, 4);

            // bit 0; mask 0x01; 1 = cell is locked

            $isLocked = (0x01 & $xfTypeProt) >> 0;

            $objStyle->getProtection()->setLocked($isLocked ? PHPExcel_Style_Protection :: PROTECTION_INHERIT : PHPExcel_Style_Protection :: PROTECTION_UNPROTECTED);

            

            // bit 1; mask 0x02; 1 = Formula is hidden

            $isHidden = (0x02 & $xfTypeProt) >> 1;

            $objStyle->getProtection()->setHidden($isHidden ? PHPExcel_Style_Protection :: PROTECTION_PROTECTED : PHPExcel_Style_Protection :: PROTECTION_UNPROTECTED);

            

            // bit 2; mask 0x04; 0 = Cell XF, 1 = Cell Style XF

            $isCellStyleXf = (0x04 & $xfTypeProt) >> 2;

            

            // offset:  6; size: 1; Alignment and text break

            // bit 2-0, mask 0x07; horizontal alignment

            $horAlign = (0x07 & ord($recordData{6})) >> 0;

            switch ($horAlign)

            {

                case 0 :

                    $objStyle->getAlignment()->setHorizontal(PHPExcel_Style_Alignment :: HORIZONTAL_GENERAL);

                    break;

                case 1 :

                    $objStyle->getAlignment()->setHorizontal(PHPExcel_Style_Alignment :: HORIZONTAL_LEFT);

                    break;

                case 2 :

                    $objStyle->getAlignment()->setHorizontal(PHPExcel_Style_Alignment :: HORIZONTAL_CENTER);

                    break;

                case 3 :

                    $objStyle->getAlignment()->setHorizontal(PHPExcel_Style_Alignment :: HORIZONTAL_RIGHT);

                    break;

                case 5 :

                    $objStyle->getAlignment()->setHorizontal(PHPExcel_Style_Alignment :: HORIZONTAL_JUSTIFY);

                    break;

                case 6 :

                    $objStyle->getAlignment()->setHorizontal(PHPExcel_Style_Alignment :: HORIZONTAL_CENTER_CONTINUOUS);

                    break;

            }

            // bit 3, mask 0x08; wrap text

            $wrapText = (0x08 & ord($recordData{6})) >> 3;

            switch ($wrapText)

            {

                case 0 :

                    $objStyle->getAlignment()->setWrapText(false);

                    break;

                case 1 :

                    $objStyle->getAlignment()->setWrapText(true);

                    break;

            }

            // bit 6-4, mask 0x70; vertical alignment

            $vertAlign = (0x70 & ord($recordData{6})) >> 4;

            switch ($vertAlign)

            {

                case 0 :

                    $objStyle->getAlignment()->setVertical(PHPExcel_Style_Alignment :: VERTICAL_TOP);

                    break;

                case 1 :

                    $objStyle->getAlignment()->setVertical(PHPExcel_Style_Alignment :: VERTICAL_CENTER);

                    break;

                case 2 :

                    $objStyle->getAlignment()->setVertical(PHPExcel_Style_Alignment :: VERTICAL_BOTTOM);

                    break;

                case 3 :

                    $objStyle->getAlignment()->setVertical(PHPExcel_Style_Alignment :: VERTICAL_JUSTIFY);

                    break;

            }

            

            if ($this->_version == self :: XLS_BIFF8)

            {

                // offset:  7; size: 1; XF_ROTATION: Text rotation angle

                $angle = ord($recordData{7});

                $rotation = 0;

                if ($angle <= 90)

                {

                    $rotation = $angle;

                }

                else 

                    if ($angle <= 180)

                    {

                        $rotation = 90 - $angle;

                    }

                    else 

                        if ($angle == 255)

                        {

                            $rotation = - 165;

                        }

                $objStyle->getAlignment()->setTextRotation($rotation);

                

                // offset:  8; size: 1; Indentation, shrink to cell size, and text direction

                // bit: 3-0; mask: 0x0F; indent level

                $indent = (0x0F & ord($recordData{8})) >> 0;

                $objStyle->getAlignment()->setIndent($indent);

                

                // bit: 4; mask: 0x10; 1 = shrink content to fit into cell

                $shrinkToFit = (0x10 & ord($recordData{8})) >> 4;

                switch ($shrinkToFit)

                {

                    case 0 :

                        $objStyle->getAlignment()->setShrinkToFit(false);

                        break;

                    case 1 :

                        $objStyle->getAlignment()->setShrinkToFit(true);

                        break;

                }

                

                // offset:  9; size: 1; Flags used for attribute groups

                



                // offset: 10; size: 4; Cell border lines and background area

                // bit: 3-0; mask: 0x0000000F; left style

                if ($bordersLeftStyle = self :: _mapBorderStyle((0x0000000F & self :: _GetInt4d($recordData, 10)) >> 0))

                {

                    $objStyle->getBorders()->getLeft()->setBorderStyle($bordersLeftStyle);

                }

                // bit: 7-4; mask: 0x000000F0; right style

                if ($bordersRightStyle = self :: _mapBorderStyle((0x000000F0 & self :: _GetInt4d($recordData, 10)) >> 4))

                {

                    $objStyle->getBorders()->getRight()->setBorderStyle($bordersRightStyle);

                }

                // bit: 11-8; mask: 0x00000F00; top style

                if ($bordersTopStyle = self :: _mapBorderStyle((0x00000F00 & self :: _GetInt4d($recordData, 10)) >> 8))

                {

                    $objStyle->getBorders()->getTop()->setBorderStyle($bordersTopStyle);

                }

                // bit: 15-12; mask: 0x0000F000; bottom style

                if ($bordersBottomStyle = self :: _mapBorderStyle((0x0000F000 & self :: _GetInt4d($recordData, 10)) >> 12))

                {

                    $objStyle->getBorders()->getBottom()->setBorderStyle($bordersBottomStyle);

                }

                // bit: 22-16; mask: 0x007F0000; left color

                $objStyle->getBorders()->getLeft()->colorIndex = (0x007F0000 & self :: _GetInt4d($recordData, 10)) >> 16;

                

                // bit: 29-23; mask: 0x3F800000; right color

                $objStyle->getBorders()->getRight()->colorIndex = (0x3F800000 & self :: _GetInt4d($recordData, 10)) >> 23;

                

                // bit: 30; mask: 0x40000000; 1 = diagonal line from top left to right bottom

                $diagonalDown = (0x40000000 & self :: _GetInt4d($recordData, 10)) >> 30 ? true : false;

                

                // bit: 31; mask: 0x80000000; 1 = diagonal line from bottom left to top right

                $diagonalUp = (0x80000000 & self :: _GetInt4d($recordData, 10)) >> 31 ? true : false;

                

                if ($diagonalUp == false && $diagonalDown == false)

                {

                    $objStyle->getBorders()->setDiagonalDirection(PHPExcel_Style_Borders :: DIAGONAL_NONE);

                }

                elseif ($diagonalUp == true && $diagonalDown == false)

                {

                    $objStyle->getBorders()->setDiagonalDirection(PHPExcel_Style_Borders :: DIAGONAL_UP);

                }

                elseif ($diagonalUp == false && $diagonalDown == true)

                {

                    $objStyle->getBorders()->setDiagonalDirection(PHPExcel_Style_Borders :: DIAGONAL_DOWN);

                }

                elseif ($diagonalUp == true && $diagonalDown == true)

                {

                    $objStyle->getBorders()->setDiagonalDirection(PHPExcel_Style_Borders :: DIAGONAL_BOTH);

                }

                

                // offset: 14; size: 4;

                // bit: 6-0; mask: 0x0000007F; top color

                $objStyle->getBorders()->getTop()->colorIndex = (0x0000007F & self :: _GetInt4d($recordData, 14)) >> 0;

                

                // bit: 13-7; mask: 0x00003F80; bottom color

                $objStyle->getBorders()->getBottom()->colorIndex = (0x00003F80 & self :: _GetInt4d($recordData, 14)) >> 7;

                

                // bit: 20-14; mask: 0x001FC000; diagonal color

                $objStyle->getBorders()->getDiagonal()->colorIndex = (0x001FC000 & self :: _GetInt4d($recordData, 14)) >> 14;

                

                // bit: 24-21; mask: 0x01E00000; diagonal style

                if ($bordersDiagonalStyle = self :: _mapBorderStyle((0x01E00000 & self :: _GetInt4d($recordData, 14)) >> 21))

                {

                    $objStyle->getBorders()->getDiagonal()->setBorderStyle($bordersDiagonalStyle);

                }

                

                // bit: 31-26; mask: 0xFC000000 fill pattern

                if ($fillType = self :: _mapFillPattern((0xFC000000 & self :: _GetInt4d($recordData, 14)) >> 26))

                {

                    $objStyle->getFill()->setFillType($fillType);

                }

                // offset: 18; size: 2; pattern and background colour

                // bit: 6-0; mask: 0x007F; color index for pattern color

                $objStyle->getFill()->startcolorIndex = (0x007F & self :: _GetInt2d($recordData, 18)) >> 0;

                

                // bit: 13-7; mask: 0x3F80; color index for pattern background

                $objStyle->getFill()->endcolorIndex = (0x3F80 & self :: _GetInt2d($recordData, 18)) >> 7;

            }

            else

            {

                // BIFF5

                



                // offset: 7; size: 1; Text orientation and flags

                $orientationAndFlags = ord($recordData{7});

                

                // bit: 1-0; mask: 0x03; XF_ORIENTATION: Text orientation

                $xfOrientation = (0x03 & $orientationAndFlags) >> 0;

                switch ($xfOrientation)

                {

                    case 0 :

                        $objStyle->getAlignment()->setTextRotation(0);

                        break;

                    case 1 :

                        $objStyle->getAlignment()->setTextRotation(- 165);

                        break;

                    case 2 :

                        $objStyle->getAlignment()->setTextRotation(90);

                        break;

                    case 3 :

                        $objStyle->getAlignment()->setTextRotation(- 90);

                        break;

                }

                

                // offset: 8; size: 4; cell border lines and background area

                $borderAndBackground = self :: _GetInt4d($recordData, 8);

                

                // bit: 6-0; mask: 0x0000007F; color index for pattern color

                $objStyle->getFill()->startcolorIndex = (0x0000007F & $borderAndBackground) >> 0;

                

                // bit: 13-7; mask: 0x00003F80; color index for pattern background

                $objStyle->getFill()->endcolorIndex = (0x00003F80 & $borderAndBackground) >> 7;

                

                // bit: 21-16; mask: 0x003F0000; fill pattern

                $objStyle->getFill()->setFillType(self :: _mapFillPattern((0x003F0000 & $borderAndBackground) >> 16));

                

                // bit: 24-22; mask: 0x01C00000; bottom line style

                $objStyle->getBorders()->getBottom()->setBorderStyle(self :: _mapBorderStyle((0x01C00000 & $borderAndBackground) >> 22));

                

                // bit: 31-25; mask: 0xFE000000; bottom line color

                $objStyle->getBorders()->getBottom()->colorIndex = (0xFE000000 & $borderAndBackground) >> 25;

                

                // offset: 12; size: 4; cell border lines

                $borderLines = self :: _GetInt4d($recordData, 12);

                

                // bit: 2-0; mask: 0x00000007; top line style

                $objStyle->getBorders()->getTop()->setBorderStyle(self :: _mapBorderStyle((0x00000007 & $borderLines) >> 0));

                

                // bit: 5-3; mask: 0x00000038; left line style

                $objStyle->getBorders()->getLeft()->setBorderStyle(self :: _mapBorderStyle((0x00000038 & $borderLines) >> 3));

                

                // bit: 8-6; mask: 0x000001C0; right line style

                $objStyle->getBorders()->getRight()->setBorderStyle(self :: _mapBorderStyle((0x000001C0 & $borderLines) >> 6));

                

                // bit: 15-9; mask: 0x0000FE00; top line color index

                $objStyle->getBorders()->getTop()->colorIndex = (0x0000FE00 & $borderLines) >> 9;

                

                // bit: 22-16; mask: 0x007F0000; left line color index

                $objStyle->getBorders()->getLeft()->colorIndex = (0x007F0000 & $borderLines) >> 16;

                

                // bit: 29-23; mask: 0x3F800000; right line color index

                $objStyle->getBorders()->getRight()->colorIndex = (0x3F800000 & $borderLines) >> 23;

            }

            

            // add cellStyleXf or cellXf and update mapping

            if ($isCellStyleXf)

            {

                // we only read one style XF record which is always the first

                if ($this->_xfIndex == 0)

                {

                    $this->_phpExcel->addCellStyleXf($objStyle);

                    $this->_mapCellStyleXfIndex[$this->_xfIndex] = 0;

                }

            }

            else

            {

                // we read all cell XF records

                $this->_phpExcel->addCellXf($objStyle);

                $this->_mapCellXfIndex[$this->_xfIndex] = count($this->_phpExcel->getCellXfCollection()) - 1;

            }

            

            // update XF index for when we read next record

            ++ $this->_xfIndex;

        }

    }



    /**

     *

     */

    private function _readXfExt()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        $recordData = substr($this->_data, $this->_pos + 4, $length);

        

        // move stream pointer to next record

        $this->_pos += 4 + $length;

        

        if (! $this->_readDataOnly)

        {

            // offset: 0; size: 2; 0x087D = repeated header

            



            // offset: 2; size: 2

            



            // offset: 4; size: 8; not used

            



            // offset: 12; size: 2; record version

            



            // offset: 14; size: 2; index to XF record which this record modifies

            $ixfe = self :: _GetInt2d($recordData, 14);

            

            // offset: 16; size: 2; not used

            



            // offset: 18; size: 2; number of extension properties that follow

            $cexts = self :: _GetInt2d($recordData, 18);

            

            // start reading the actual extension data

            $offset = 20;

            while ($offset < $length)

            {

                // extension type

                $extType = self :: _GetInt2d($recordData, $offset);

                

                // extension length

                $cb = self :: _GetInt2d($recordData, $offset + 2);

                

                // extension data

                $extData = substr($recordData, $offset + 4, $cb);

                

                switch ($extType)

                {

                    case 4 : // fill start color

                        $xclfType = self :: _GetInt2d($extData, 0); // color type

                        $xclrValue = substr($extData, 4, 4); // color value (value based on color type)

                        



                        if ($xclfType == 2)

                        {

                            $rgb = sprintf('%02X%02X%02X', ord($xclrValue{0}), ord($xclrValue{1}), ord($xclrValue{2}));

                            

                            // modify the relevant style property

                            if (isset($this->_mapCellXfIndex[$ixfe]))

                            {

                                $fill = $this->_phpExcel->getCellXfByIndex($this->_mapCellXfIndex[$ixfe])->getFill();

                                $fill->getStartColor()->setRGB($rgb);

                                unset($fill->startcolorIndex); // normal color index does not apply, discard

                            }

                        }

                        break;

                    

                    case 5 : // fill end color

                        $xclfType = self :: _GetInt2d($extData, 0); // color type

                        $xclrValue = substr($extData, 4, 4); // color value (value based on color type)

                        



                        if ($xclfType == 2)

                        {

                            $rgb = sprintf('%02X%02X%02X', ord($xclrValue{0}), ord($xclrValue{1}), ord($xclrValue{2}));

                            

                            // modify the relevant style property

                            if (isset($this->_mapCellXfIndex[$ixfe]))

                            {

                                $fill = $this->_phpExcel->getCellXfByIndex($this->_mapCellXfIndex[$ixfe])->getFill();

                                $fill->getEndColor()->setRGB($rgb);

                                unset($fill->endcolorIndex); // normal color index does not apply, discard

                            }

                        }

                        break;

                    

                    case 7 : // border color top

                        $xclfType = self :: _GetInt2d($extData, 0); // color type

                        $xclrValue = substr($extData, 4, 4); // color value (value based on color type)

                        



                        if ($xclfType == 2)

                        {

                            $rgb = sprintf('%02X%02X%02X', ord($xclrValue{0}), ord($xclrValue{1}), ord($xclrValue{2}));

                            

                            // modify the relevant style property

                            if (isset($this->_mapCellXfIndex[$ixfe]))

                            {

                                $top = $this->_phpExcel->getCellXfByIndex($this->_mapCellXfIndex[$ixfe])->getBorders()->getTop();

                                $top->getColor()->setRGB($rgb);

                                unset($top->colorIndex); // normal color index does not apply, discard

                            }

                        }

                        break;

                    

                    case 8 : // border color bottom

                        $xclfType = self :: _GetInt2d($extData, 0); // color type

                        $xclrValue = substr($extData, 4, 4); // color value (value based on color type)

                        



                        if ($xclfType == 2)

                        {

                            $rgb = sprintf('%02X%02X%02X', ord($xclrValue{0}), ord($xclrValue{1}), ord($xclrValue{2}));

                            

                            // modify the relevant style property

                            if (isset($this->_mapCellXfIndex[$ixfe]))

                            {

                                $bottom = $this->_phpExcel->getCellXfByIndex($this->_mapCellXfIndex[$ixfe])->getBorders()->getBottom();

                                $bottom->getColor()->setRGB($rgb);

                                unset($bottom->colorIndex); // normal color index does not apply, discard

                            }

                        }

                        break;

                    

                    case 9 : // border color left

                        $xclfType = self :: _GetInt2d($extData, 0); // color type

                        $xclrValue = substr($extData, 4, 4); // color value (value based on color type)

                        



                        if ($xclfType == 2)

                        {

                            $rgb = sprintf('%02X%02X%02X', ord($xclrValue{0}), ord($xclrValue{1}), ord($xclrValue{2}));

                            

                            // modify the relevant style property

                            if (isset($this->_mapCellXfIndex[$ixfe]))

                            {

                                $left = $this->_phpExcel->getCellXfByIndex($this->_mapCellXfIndex[$ixfe])->getBorders()->getLeft();

                                $left->getColor()->setRGB($rgb);

                                unset($left->colorIndex); // normal color index does not apply, discard

                            }

                        }

                        break;

                    

                    case 10 : // border color right

                        $xclfType = self :: _GetInt2d($extData, 0); // color type

                        $xclrValue = substr($extData, 4, 4); // color value (value based on color type)

                        



                        if ($xclfType == 2)

                        {

                            $rgb = sprintf('%02X%02X%02X', ord($xclrValue{0}), ord($xclrValue{1}), ord($xclrValue{2}));

                            

                            // modify the relevant style property

                            if (isset($this->_mapCellXfIndex[$ixfe]))

                            {

                                $right = $this->_phpExcel->getCellXfByIndex($this->_mapCellXfIndex[$ixfe])->getBorders()->getRight();

                                $right->getColor()->setRGB($rgb);

                                unset($right->colorIndex); // normal color index does not apply, discard

                            }

                        }

                        break;

                    

                    case 11 : // border color diagonal

                        $xclfType = self :: _GetInt2d($extData, 0); // color type

                        $xclrValue = substr($extData, 4, 4); // color value (value based on color type)

                        



                        if ($xclfType == 2)

                        {

                            $rgb = sprintf('%02X%02X%02X', ord($xclrValue{0}), ord($xclrValue{1}), ord($xclrValue{2}));

                            

                            // modify the relevant style property

                            if (isset($this->_mapCellXfIndex[$ixfe]))

                            {

                                $diagonal = $this->_phpExcel->getCellXfByIndex($this->_mapCellXfIndex[$ixfe])->getBorders()->getDiagonal();

                                $diagonal->getColor()->setRGB($rgb);

                                unset($diagonal->colorIndex); // normal color index does not apply, discard

                            }

                        }

                        break;

                    

                    case 13 : // font color

                        $xclfType = self :: _GetInt2d($extData, 0); // color type

                        $xclrValue = substr($extData, 4, 4); // color value (value based on color type)

                        



                        if ($xclfType == 2)

                        {

                            $rgb = sprintf('%02X%02X%02X', ord($xclrValue{0}), ord($xclrValue{1}), ord($xclrValue{2}));

                            

                            // modify the relevant style property

                            if (isset($this->_mapCellXfIndex[$ixfe]))

                            {

                                $font = $this->_phpExcel->getCellXfByIndex($this->_mapCellXfIndex[$ixfe])->getFont();

                                $font->getColor()->setRGB($rgb);

                                unset($font->colorIndex); // normal color index does not apply, discard

                            }

                        }

                        break;

                }

                

                $offset += $cb;

            }

        }

    

    }



    /**

     * Read STYLE record

     */

    private function _readStyle()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        $recordData = substr($this->_data, $this->_pos + 4, $length);

        

        // move stream pointer to next record

        $this->_pos += 4 + $length;

        

        if (! $this->_readDataOnly)

        {

            // offset: 0; size: 2; index to XF record and flag for built-in style

            $ixfe = self :: _GetInt2d($recordData, 0);

            

            // bit: 11-0; mask 0x0FFF; index to XF record

            $xfIndex = (0x0FFF & $ixfe) >> 0;

            

            // bit: 15; mask 0x8000; 0 = user-defined style, 1 = built-in style

            $isBuiltIn = (bool) ((0x8000 & $ixfe) >> 15);

            

            if ($isBuiltIn)

            {

                // offset: 2; size: 1; identifier for built-in style

                $builtInId = ord($recordData{2});

                

                switch ($builtInId)

                {

                    case 0x00 :

                        // currently, we are not using this for anything

                        break;

                    

                    default :

                        break;

                }

            

            }

            else

            {

                // user-defined; not supported by PHPExcel

            }

        }

    }



    /**

     * Read PALETTE record

     */

    private function _readPalette()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        $recordData = substr($this->_data, $this->_pos + 4, $length);

        

        // move stream pointer to next record

        $this->_pos += 4 + $length;

        

        if (! $this->_readDataOnly)

        {

            // offset: 0; size: 2; number of following colors

            $nm = self :: _GetInt2d($recordData, 0);

            

            // list of RGB colors

            for($i = 0; $i < $nm; ++ $i)

            {

                $rgb = substr($recordData, 2 + 4 * $i, 4);

                $this->_palette[] = self :: _readRGB($rgb);

            }

        }

    }



    /**

     * SHEET

     *

     * This record is  located in the  Workbook Globals

     * Substream  and represents a sheet inside the workbook.

     * One SHEET record is written for each sheet. It stores the

     * sheet name and a stream offset to the BOF record of the

     * respective Sheet Substream within the Workbook Stream.

     *

     * --	"OpenOffice.org's Documentation of the Microsoft

     * Excel File Format"

     */

    private function _readSheet()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        $recordData = substr($this->_data, $this->_pos + 4, $length);

        

        // move stream pointer to next record

        $this->_pos += 4 + $length;

        

        // offset: 0; size: 4; absolute stream position of the BOF record of the sheet

        $rec_offset = self :: _GetInt4d($recordData, 0);

        

        // offset: 4; size: 1; sheet state

        switch (ord($recordData{4}))

        {

            case 0x00 :

                $sheetState = PHPExcel_Worksheet :: SHEETSTATE_VISIBLE;

                break;

            case 0x01 :

                $sheetState = PHPExcel_Worksheet :: SHEETSTATE_HIDDEN;

                break;

            case 0x02 :

                $sheetState = PHPExcel_Worksheet :: SHEETSTATE_VERYHIDDEN;

                break;

            default :

                $sheetState = PHPExcel_Worksheet :: SHEETSTATE_VISIBLE;

                break;

        }

        

        // offset: 5; size: 1; sheet type

        $sheetType = ord($recordData{5});

        

        // offset: 6; size: var; sheet name

        if ($this->_version == self :: XLS_BIFF8)

        {

            $string = self :: _readUnicodeStringShort(substr($recordData, 6));

            $rec_name = $string['value'];

        }

        elseif ($this->_version == self :: XLS_BIFF7)

        {

            $string = $this->_readByteStringShort(substr($recordData, 6));

            $rec_name = $string['value'];

        }

        

        $this->_sheets[] = array('name' => $rec_name, 'offset' => $rec_offset, 'sheetState' => $sheetState, 

                'sheetType' => $sheetType);

    }



    /**

     * Read EXTERNALBOOK record

     */

    private function _readExternalBook()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        $recordData = substr($this->_data, $this->_pos + 4, $length);

        

        // move stream pointer to next record

        $this->_pos += 4 + $length;

        

        // offset within record data

        $offset = 0;

        

        // there are 4 types of records

        if (strlen($recordData) > 4)

        {

            // external reference

            // offset: 0; size: 2; number of sheet names ($nm)

            $nm = self :: _GetInt2d($recordData, 0);

            $offset += 2;

            

            // offset: 2; size: var; encoded URL without sheet name (Unicode string, 16-bit length)

            $encodedUrlString = self :: _readUnicodeStringLong(substr($recordData, 2));

            $offset += $encodedUrlString['size'];

            

            // offset: var; size: var; list of $nm sheet names (Unicode strings, 16-bit length)

            $externalSheetNames = array();

            for($i = 0; $i < $nm; ++ $i)

            {

                $externalSheetNameString = self :: _readUnicodeStringLong(substr($recordData, $offset));

                $externalSheetNames[] = $externalSheetNameString['value'];

                $offset += $externalSheetNameString['size'];

            }

            

            // store the record data

            $this->_externalBooks[] = array('type' => 'external', 

                    'encodedUrl' => $encodedUrlString['value'], 'externalSheetNames' => $externalSheetNames);

        

        }

        elseif (substr($recordData, 2, 2) == pack('CC', 0x01, 0x04))

        {

            // internal reference

            // offset: 0; size: 2; number of sheet in this document

            // offset: 2; size: 2; 0x01 0x04

            $this->_externalBooks[] = array('type' => 'internal');

        }

        elseif (substr($recordData, 0, 4) == pack('vCC', 0x0001, 0x01, 0x3A))

        {

            // add-in function

            // offset: 0; size: 2; 0x0001

            $this->_externalBooks[] = array('type' => 'addInFunction');

        }

        elseif (substr($recordData, 0, 2) == pack('v', 0x0000))

        {

            // DDE links, OLE links

            // offset: 0; size: 2; 0x0000

            // offset: 2; size: var; encoded source document name

            $this->_externalBooks[] = array('type' => 'DDEorOLE');

        }

    }



    /**

     * Read EXTERNNAME record.

     */

    private function _readExternName()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        $recordData = substr($this->_data, $this->_pos + 4, $length);

        

        // move stream pointer to next record

        $this->_pos += 4 + $length;

        

        // external sheet references provided for named cells

        if ($this->_version == self :: XLS_BIFF8)

        {

            // offset: 0; size: 2; options

            $options = self :: _GetInt2d($recordData, 0);

            

            // offset: 2; size: 2;

            



            // offset: 4; size: 2; not used

            



            // offset: 6; size: var

            $nameString = self :: _readUnicodeStringShort(substr($recordData, 6));

            

            // offset: var; size: var; formula data

            $offset = 6 + $nameString['size'];

            $formula = $this->_getFormulaFromStructure(substr($recordData, $offset));

            

            $this->_externalNames[] = array('name' => $nameString['value'], 'formula' => $formula);

        }

    }



    /**

     * Read EXTERNSHEET record

     */

    private function _readExternSheet()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        $recordData = substr($this->_data, $this->_pos + 4, $length);

        

        // move stream pointer to next record

        $this->_pos += 4 + $length;

        

        // external sheet references provided for named cells

        if ($this->_version == self :: XLS_BIFF8)

        {

            // offset: 0; size: 2; number of following ref structures

            $nm = self :: _GetInt2d($recordData, 0);

            for($i = 0; $i < $nm; ++ $i)

            {

                $this->_ref[] = array(// offset: 2 + 6 * $i; index to EXTERNALBOOK record

                'externalBookIndex' => self :: _GetInt2d($recordData, 2 + 6 * $i), 

                        // offset: 4 + 6 * $i; index to first sheet in EXTERNALBOOK record

                        'firstSheetIndex' => self :: _GetInt2d($recordData, 4 + 6 * $i), 

                        // offset: 6 + 6 * $i; index to last sheet in EXTERNALBOOK record

                        'lastSheetIndex' => self :: _GetInt2d($recordData, 6 + 6 * $i));

            }

        }

    }



    /**

     * DEFINEDNAME

     *

     * This record is part of a Link Table. It contains the name

     * and the token array of an internal defined name. Token

     * arrays of defined names contain tokens with aberrant

     * token classes.

     *

     * --	"OpenOffice.org's Documentation of the Microsoft

     * Excel File Format"

     */

    private function _readDefinedName()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        $recordData = substr($this->_data, $this->_pos + 4, $length);

        

        // move stream pointer to next record

        $this->_pos += 4 + $length;

        

        if ($this->_version == self :: XLS_BIFF8)

        {

            // retrieves named cells

            



            // offset: 0; size: 2; option flags

            $opts = self :: _GetInt2d($recordData, 0);

            

            // bit: 5; mask: 0x0020; 0 = user-defined name, 1 = built-in-name

            $isBuiltInName = (0x0020 & $opts) >> 5;

            

            // offset: 2; size: 1; keyboard shortcut

            



            // offset: 3; size: 1; length of the name (character count)

            $nlen = ord($recordData{3});

            

            // offset: 4; size: 2; size of the formula data (it can happen that this is zero)

            // note: there can also be additional data, this is not included in $flen

            $flen = self :: _GetInt2d($recordData, 4);

            

            // offset: 8; size: 2; 0=Global name, otherwise index to sheet (1-based)

            $scope = self :: _GetInt2d($recordData, 8);

            

            // offset: 14; size: var; Name (Unicode string without length field)

            $string = self :: _readUnicodeString(substr($recordData, 14), $nlen);

            

            // offset: var; size: $flen; formula data

            $offset = 14 + $string['size'];

            $formulaStructure = pack('v', $flen) . substr($recordData, $offset);

            

            try

            {

                $formula = $this->_getFormulaFromStructure($formulaStructure);

            }

            catch (Exception $e)

            {

                $formula = '';

            }

            

            $this->_definedname[] = array('isBuiltInName' => $isBuiltInName, 'name' => $string['value'], 

                    'formula' => $formula, 'scope' => $scope);

        }

    }



    /**

     * Read MSODRAWINGGROUP record

     */

    private function _readMsoDrawingGroup()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        

        // get spliced record data

        $splicedRecordData = $this->_getSplicedRecordData();

        $recordData = $splicedRecordData['recordData'];

        

        $this->_drawingGroupData .= $recordData;

    }



    /**

     * SST - Shared String Table

     *

     * This record contains a list of all strings used anywhere

     * in the workbook. Each string occurs only once. The

     * workbook uses indexes into the list to reference the

     * strings.

     *

     * --	"OpenOffice.org's Documentation of the Microsoft

     * Excel File Format"

     **/

    private function _readSst()

    {

        // offset within (spliced) record data

        $pos = 0;

        

        // get spliced record data

        $splicedRecordData = $this->_getSplicedRecordData();

        

        $recordData = $splicedRecordData['recordData'];

        $spliceOffsets = $splicedRecordData['spliceOffsets'];

        

        // offset: 0; size: 4; total number of strings in the workbook

        $pos += 4;

        

        // offset: 4; size: 4; number of following strings ($nm)

        $nm = self :: _GetInt4d($recordData, 4);

        $pos += 4;

        

        // loop through the Unicode strings (16-bit length)

        for($i = 0; $i < $nm; ++ $i)

        {

            

            // number of characters in the Unicode string

            $numChars = self :: _GetInt2d($recordData, $pos);

            $pos += 2;

            

            // option flags

            $optionFlags = ord($recordData{$pos});

            ++ $pos;

            

            // bit: 0; mask: 0x01; 0 = compressed; 1 = uncompressed

            $isCompressed = (($optionFlags & 0x01) == 0);

            

            // bit: 2; mask: 0x02; 0 = ordinary; 1 = Asian phonetic

            $hasAsian = (($optionFlags & 0x04) != 0);

            

            // bit: 3; mask: 0x03; 0 = ordinary; 1 = Rich-Text

            $hasRichText = (($optionFlags & 0x08) != 0);

            

            if ($hasRichText)

            {

                // number of Rich-Text formatting runs

                $formattingRuns = self :: _GetInt2d($recordData, $pos);

                $pos += 2;

            }

            

            if ($hasAsian)

            {

                // size of Asian phonetic setting

                $extendedRunLength = self :: _GetInt4d($recordData, $pos);

                $pos += 4;

            }

            

            // expected byte length of character array if not split

            $len = ($isCompressed) ? $numChars : $numChars * 2;

            

            // look up limit position

            foreach ($spliceOffsets as $spliceOffset)

            {

                // it can happen that the string is empty, therefore we need

                // <= and not just <

                if ($pos <= $spliceOffset)

                {

                    $limitpos = $spliceOffset;

                    break;

                }

            }

            

            if ($pos + $len <= $limitpos)

            {

                // character array is not split between records

                



                $retstr = substr($recordData, $pos, $len);

                $pos += $len;

            

            }

            else

            {

                // character array is split between records

                



                // first part of character array

                $retstr = substr($recordData, $pos, $limitpos - $pos);

                

                $bytesRead = $limitpos - $pos;

                

                // remaining characters in Unicode string

                $charsLeft = $numChars - (($isCompressed) ? $bytesRead : ($bytesRead / 2));

                

                $pos = $limitpos;

                

                // keep reading the characters

                while ($charsLeft > 0)

                {

                    

                    // look up next limit position, in case the string span more than one continue record

                    foreach ($spliceOffsets as $spliceOffset)

                    {

                        if ($pos < $spliceOffset)

                        {

                            $limitpos = $spliceOffset;

                            break;

                        }

                    }

                    

                    // repeated option flags

                    // OpenOffice.org documentation 5.21

                    $option = ord($recordData{$pos});

                    ++ $pos;

                    

                    if ($isCompressed && ($option == 0))

                    {

                        // 1st fragment compressed

                        // this fragment compressed

                        $len = min($charsLeft, $limitpos - $pos);

                        $retstr .= substr($recordData, $pos, $len);

                        $charsLeft -= $len;

                        $isCompressed = true;

                    

                    }

                    elseif (! $isCompressed && ($option != 0))

                    {

                        // 1st fragment uncompressed

                        // this fragment uncompressed

                        $len = min($charsLeft * 2, $limitpos - $pos);

                        $retstr .= substr($recordData, $pos, $len);

                        $charsLeft -= $len / 2;

                        $isCompressed = false;

                    

                    }

                    elseif (! $isCompressed && ($option == 0))

                    {

                        // 1st fragment uncompressed

                        // this fragment compressed

                        $len = min($charsLeft, $limitpos - $pos);

                        for($j = 0; $j < $len; ++ $j)

                        {

                            $retstr .= $recordData{$pos + $j} . chr(0);

                        }

                        $charsLeft -= $len;

                        $isCompressed = false;

                    

                    }

                    else

                    {

                        // 1st fragment compressed

                        // this fragment uncompressed

                        $newstr = '';

                        for($j = 0; $j < strlen($retstr); ++ $j)

                        {

                            $newstr .= $retstr[$j] . chr(0);

                        }

                        $retstr = $newstr;

                        $len = min($charsLeft * 2, $limitpos - $pos);

                        $retstr .= substr($recordData, $pos, $len);

                        $charsLeft -= $len / 2;

                        $isCompressed = false;

                    }

                    

                    $pos += $len;

                }

            }

            

            // convert to UTF-8

            $retstr = self :: _encodeUTF16($retstr, $isCompressed);

            

            // read additional Rich-Text information, if any

            $fmtRuns = array();

            if ($hasRichText)

            {

                // list of formatting runs

                for($j = 0; $j < $formattingRuns; ++ $j)

                {

                    // first formatted character; zero-based

                    $charPos = self :: _GetInt2d($recordData, $pos + $j * 4);

                    

                    // index to font record

                    $fontIndex = self :: _GetInt2d($recordData, $pos + 2 + $j * 4);

                    

                    $fmtRuns[] = array('charPos' => $charPos, 'fontIndex' => $fontIndex);

                }

                $pos += 4 * $formattingRuns;

            }

            

            // read additional Asian phonetics information, if any

            if ($hasAsian)

            {

                // For Asian phonetic settings, we skip the extended string data

                $pos += $extendedRunLength;

            }

            

            // store the shared sting

            $this->_sst[] = array('value' => $retstr, 'fmtRuns' => $fmtRuns);

        }

    

     // _getSplicedRecordData() takes care of moving current position in data stream

    }



    /**

     * Read PRINTGRIDLINES record

     */

    private function _readPrintGridlines()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        $recordData = substr($this->_data, $this->_pos + 4, $length);

        

        // move stream pointer to next record

        $this->_pos += 4 + $length;

        

        if ($this->_version == self :: XLS_BIFF8 && ! $this->_readDataOnly)

        {

            // offset: 0; size: 2; 0 = do not print sheet grid lines; 1 = print sheet gridlines

            $printGridlines = (bool) self :: _GetInt2d($recordData, 0);

            $this->_phpSheet->setPrintGridlines($printGridlines);

        }

    }



    /**

     * Read DEFAULTROWHEIGHT record

     */

    private function _readDefaultRowHeight()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        $recordData = substr($this->_data, $this->_pos + 4, $length);

        

        // move stream pointer to next record

        $this->_pos += 4 + $length;

        

        // offset: 0; size: 2; option flags

        // offset: 2; size: 2; default height for unused rows, (twips 1/20 point)

        $height = self :: _GetInt2d($recordData, 2);

        $this->_phpSheet->getDefaultRowDimension()->setRowHeight($height / 20);

    }



    /**

     * Read SHEETPR record

     */

    private function _readSheetPr()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        $recordData = substr($this->_data, $this->_pos + 4, $length);

        

        // move stream pointer to next record

        $this->_pos += 4 + $length;

        

        // offset: 0; size: 2

        



        // bit: 6; mask: 0x0040; 0 = outline buttons above outline group

        $isSummaryBelow = (0x0040 & self :: _GetInt2d($recordData, 0)) >> 6;

        $this->_phpSheet->setShowSummaryBelow($isSummaryBelow);

        

        // bit: 7; mask: 0x0080; 0 = outline buttons left of outline group

        $isSummaryRight = (0x0080 & self :: _GetInt2d($recordData, 0)) >> 7;

        $this->_phpSheet->setShowSummaryRight($isSummaryRight);

        

        // bit: 8; mask: 0x100; 0 = scale printout in percent, 1 = fit printout to number of pages

        // this corresponds to radio button setting in page setup dialog in Excel

        $this->_isFitToPages = (bool) ((0x0100 & self :: _GetInt2d($recordData, 0)) >> 8);

    }



    /**

     * Read HORIZONTALPAGEBREAKS record

     */

    private function _readHorizontalPageBreaks()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        $recordData = substr($this->_data, $this->_pos + 4, $length);

        

        // move stream pointer to next record

        $this->_pos += 4 + $length;

        

        if ($this->_version == self :: XLS_BIFF8 && ! $this->_readDataOnly)

        {

            

            // offset: 0; size: 2; number of the following row index structures

            $nm = self :: _GetInt2d($recordData, 0);

            

            // offset: 2; size: 6 * $nm; list of $nm row index structures

            for($i = 0; $i < $nm; ++ $i)

            {

                $r = self :: _GetInt2d($recordData, 2 + 6 * $i);

                $cf = self :: _GetInt2d($recordData, 2 + 6 * $i + 2);

                $cl = self :: _GetInt2d($recordData, 2 + 6 * $i + 4);

                

                // not sure why two column indexes are necessary?

                $this->_phpSheet->setBreakByColumnAndRow($cf, $r, PHPExcel_Worksheet :: BREAK_ROW);

            }

        }

    }



    /**

     * Read VERTICALPAGEBREAKS record

     */

    private function _readVerticalPageBreaks()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        $recordData = substr($this->_data, $this->_pos + 4, $length);

        

        // move stream pointer to next record

        $this->_pos += 4 + $length;

        

        if ($this->_version == self :: XLS_BIFF8 && ! $this->_readDataOnly)

        {

            // offset: 0; size: 2; number of the following column index structures

            $nm = self :: _GetInt2d($recordData, 0);

            

            // offset: 2; size: 6 * $nm; list of $nm row index structures

            for($i = 0; $i < $nm; ++ $i)

            {

                $c = self :: _GetInt2d($recordData, 2 + 6 * $i);

                $rf = self :: _GetInt2d($recordData, 2 + 6 * $i + 2);

                $rl = self :: _GetInt2d($recordData, 2 + 6 * $i + 4);

                

                // not sure why two row indexes are necessary?

                $this->_phpSheet->setBreakByColumnAndRow($c, $rf, PHPExcel_Worksheet :: BREAK_COLUMN);

            }

        }

    }



    /**

     * Read HEADER record

     */

    private function _readHeader()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        $recordData = substr($this->_data, $this->_pos + 4, $length);

        

        // move stream pointer to next record

        $this->_pos += 4 + $length;

        

        if (! $this->_readDataOnly)

        {

            // offset: 0; size: var

            // realized that $recordData can be empty even when record exists

            if ($recordData)

            {

                if ($this->_version == self :: XLS_BIFF8)

                {

                    $string = self :: _readUnicodeStringLong($recordData);

                }

                else

                {

                    $string = $this->_readByteStringShort($recordData);

                }

                

                $this->_phpSheet->getHeaderFooter()->setOddHeader($string['value']);

                $this->_phpSheet->getHeaderFooter()->setEvenHeader($string['value']);

            }

        }

    }



    /**

     * Read FOOTER record

     */

    private function _readFooter()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        $recordData = substr($this->_data, $this->_pos + 4, $length);

        

        // move stream pointer to next record

        $this->_pos += 4 + $length;

        

        if (! $this->_readDataOnly)

        {

            // offset: 0; size: var

            // realized that $recordData can be empty even when record exists

            if ($recordData)

            {

                if ($this->_version == self :: XLS_BIFF8)

                {

                    $string = self :: _readUnicodeStringLong($recordData);

                }

                else

                {

                    $string = $this->_readByteStringShort($recordData);

                }

                $this->_phpSheet->getHeaderFooter()->setOddFooter($string['value']);

                $this->_phpSheet->getHeaderFooter()->setEvenFooter($string['value']);

            }

        }

    }



    /**

     * Read HCENTER record

     */

    private function _readHcenter()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        $recordData = substr($this->_data, $this->_pos + 4, $length);

        

        // move stream pointer to next record

        $this->_pos += 4 + $length;

        

        if (! $this->_readDataOnly)

        {

            // offset: 0; size: 2; 0 = print sheet left aligned, 1 = print sheet centered horizontally

            $isHorizontalCentered = (bool) self :: _GetInt2d($recordData, 0);

            

            $this->_phpSheet->getPageSetup()->setHorizontalCentered($isHorizontalCentered);

        }

    }



    /**

     * Read VCENTER record

     */

    private function _readVcenter()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        $recordData = substr($this->_data, $this->_pos + 4, $length);

        

        // move stream pointer to next record

        $this->_pos += 4 + $length;

        

        if (! $this->_readDataOnly)

        {

            // offset: 0; size: 2; 0 = print sheet aligned at top page border, 1 = print sheet vertically centered

            $isVerticalCentered = (bool) self :: _GetInt2d($recordData, 0);

            

            $this->_phpSheet->getPageSetup()->setVerticalCentered($isVerticalCentered);

        }

    }



    /**

     * Read LEFTMARGIN record

     */

    private function _readLeftMargin()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        $recordData = substr($this->_data, $this->_pos + 4, $length);

        

        // move stream pointer to next record

        $this->_pos += 4 + $length;

        

        if (! $this->_readDataOnly)

        {

            // offset: 0; size: 8

            $this->_phpSheet->getPageMargins()->setLeft(self :: _extractNumber($recordData));

        }

    }



    /**

     * Read RIGHTMARGIN record

     */

    private function _readRightMargin()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        $recordData = substr($this->_data, $this->_pos + 4, $length);

        

        // move stream pointer to next record

        $this->_pos += 4 + $length;

        

        if (! $this->_readDataOnly)

        {

            // offset: 0; size: 8

            $this->_phpSheet->getPageMargins()->setRight(self :: _extractNumber($recordData));

        }

    }



    /**

     * Read TOPMARGIN record

     */

    private function _readTopMargin()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        $recordData = substr($this->_data, $this->_pos + 4, $length);

        

        // move stream pointer to next record

        $this->_pos += 4 + $length;

        

        if (! $this->_readDataOnly)

        {

            // offset: 0; size: 8

            $this->_phpSheet->getPageMargins()->setTop(self :: _extractNumber($recordData));

        }

    }



    /**

     * Read BOTTOMMARGIN record

     */

    private function _readBottomMargin()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        $recordData = substr($this->_data, $this->_pos + 4, $length);

        

        // move stream pointer to next record

        $this->_pos += 4 + $length;

        

        if (! $this->_readDataOnly)

        {

            // offset: 0; size: 8

            $this->_phpSheet->getPageMargins()->setBottom(self :: _extractNumber($recordData));

        }

    }



    /**

     * Read PAGESETUP record

     */

    private function _readPageSetup()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        $recordData = substr($this->_data, $this->_pos + 4, $length);

        

        // move stream pointer to next record

        $this->_pos += 4 + $length;

        

        if (! $this->_readDataOnly)

        {

            // offset: 0; size: 2; paper size

            $paperSize = self :: _GetInt2d($recordData, 0);

            

            // offset: 2; size: 2; scaling factor

            $scale = self :: _GetInt2d($recordData, 2);

            

            // offset: 6; size: 2; fit worksheet width to this number of pages, 0 = use as many as needed

            $fitToWidth = self :: _GetInt2d($recordData, 6);

            

            // offset: 8; size: 2; fit worksheet height to this number of pages, 0 = use as many as needed

            $fitToHeight = self :: _GetInt2d($recordData, 8);

            

            // offset: 10; size: 2; option flags

            



            // bit: 1; mask: 0x0002; 0=landscape, 1=portrait

            $isPortrait = (0x0002 & self :: _GetInt2d($recordData, 10)) >> 1;

            

            // bit: 2; mask: 0x0004; 1= paper size, scaling factor, paper orient. not init

            // when this bit is set, do not use flags for those properties

            $isNotInit = (0x0004 & self :: _GetInt2d($recordData, 10)) >> 2;

            

            if (! $isNotInit)

            {

                $this->_phpSheet->getPageSetup()->setPaperSize($paperSize);

                switch ($isPortrait)

                {

                    case 0 :

                        $this->_phpSheet->getPageSetup()->setOrientation(PHPExcel_Worksheet_PageSetup :: ORIENTATION_LANDSCAPE);

                        break;

                    case 1 :

                        $this->_phpSheet->getPageSetup()->setOrientation(PHPExcel_Worksheet_PageSetup :: ORIENTATION_PORTRAIT);

                        break;

                }

                

                $this->_phpSheet->getPageSetup()->setScale($scale, false);

                $this->_phpSheet->getPageSetup()->setFitToPage((bool) $this->_isFitToPages);

                $this->_phpSheet->getPageSetup()->setFitToWidth($fitToWidth, false);

                $this->_phpSheet->getPageSetup()->setFitToHeight($fitToHeight, false);

            }

            

            // offset: 16; size: 8; header margin (IEEE 754 floating-point value)

            $marginHeader = self :: _extractNumber(substr($recordData, 16, 8));

            $this->_phpSheet->getPageMargins()->setHeader($marginHeader);

            

            // offset: 24; size: 8; footer margin (IEEE 754 floating-point value)

            $marginFooter = self :: _extractNumber(substr($recordData, 24, 8));

            $this->_phpSheet->getPageMargins()->setFooter($marginFooter);

        }

    }



    /**

     * PROTECT - Sheet protection (BIFF2 through BIFF8)

     * if this record is omitted, then it also means no sheet protection

     */

    private function _readProtect()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        $recordData = substr($this->_data, $this->_pos + 4, $length);

        

        // move stream pointer to next record

        $this->_pos += 4 + $length;

        

        if ($this->_readDataOnly)

        {

            return;

        }

        

        // offset: 0; size: 2;

        



        // bit 0, mask 0x01; 1 = sheet is protected

        $bool = (0x01 & self :: _GetInt2d($recordData, 0)) >> 0;

        $this->_phpSheet->getProtection()->setSheet((bool) $bool);

    }



    /**

     * SCENPROTECT

     */

    private function _readScenProtect()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        $recordData = substr($this->_data, $this->_pos + 4, $length);

        

        // move stream pointer to next record

        $this->_pos += 4 + $length;

        

        if ($this->_readDataOnly)

        {

            return;

        }

        

        // offset: 0; size: 2;

        



        // bit: 0, mask 0x01; 1 = scenarios are protected

        $bool = (0x01 & self :: _GetInt2d($recordData, 0)) >> 0;

        

        $this->_phpSheet->getProtection()->setScenarios((bool) $bool);

    }



    /**

     * OBJECTPROTECT

     */

    private function _readObjectProtect()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        $recordData = substr($this->_data, $this->_pos + 4, $length);

        

        // move stream pointer to next record

        $this->_pos += 4 + $length;

        

        if ($this->_readDataOnly)

        {

            return;

        }

        

        // offset: 0; size: 2;

        



        // bit: 0, mask 0x01; 1 = objects are protected

        $bool = (0x01 & self :: _GetInt2d($recordData, 0)) >> 0;

        

        $this->_phpSheet->getProtection()->setObjects((bool) $bool);

    }



    /**

     * PASSWORD - Sheet protection (hashed) password (BIFF2 through BIFF8)

     */

    private function _readPassword()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        $recordData = substr($this->_data, $this->_pos + 4, $length);

        

        // move stream pointer to next record

        $this->_pos += 4 + $length;

        

        if (! $this->_readDataOnly)

        {

            // offset: 0; size: 2; 16-bit hash value of password

            $password = strtoupper(dechex(self :: _GetInt2d($recordData, 0))); // the hashed password

            $this->_phpSheet->getProtection()->setPassword($password, true);

        }

    }



    /**

     * Read DEFCOLWIDTH record

     */

    private function _readDefColWidth()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        $recordData = substr($this->_data, $this->_pos + 4, $length);

        

        // move stream pointer to next record

        $this->_pos += 4 + $length;

        

        // offset: 0; size: 2; default column width

        $width = self :: _GetInt2d($recordData, 0);

        if ($width != 8)

        {

            $this->_phpSheet->getDefaultColumnDimension()->setWidth($width);

        }

    }



    /**

     * Read COLINFO record

     */

    private function _readColInfo()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        $recordData = substr($this->_data, $this->_pos + 4, $length);

        

        // move stream pointer to next record

        $this->_pos += 4 + $length;

        

        if (! $this->_readDataOnly)

        {

            // offset: 0; size: 2; index to first column in range

            $fc = self :: _GetInt2d($recordData, 0); // first column index

            



            // offset: 2; size: 2; index to last column in range

            $lc = self :: _GetInt2d($recordData, 2); // first column index

            



            // offset: 4; size: 2; width of the column in 1/256 of the width of the zero character

            $width = self :: _GetInt2d($recordData, 4);

            

            // offset: 6; size: 2; index to XF record for default column formatting

            $xfIndex = self :: _GetInt2d($recordData, 6);

            

            // offset: 8; size: 2; option flags

            



            // bit: 0; mask: 0x0001; 1= columns are hidden

            $isHidden = (0x0001 & self :: _GetInt2d($recordData, 8)) >> 0;

            

            // bit: 10-8; mask: 0x0700; outline level of the columns (0 = no outline)

            $level = (0x0700 & self :: _GetInt2d($recordData, 8)) >> 8;

            

            // bit: 12; mask: 0x1000; 1 = collapsed

            $isCollapsed = (0x1000 & self :: _GetInt2d($recordData, 8)) >> 12;

            

            // offset: 10; size: 2; not used

            



            for($i = $fc; $i <= $lc; ++ $i)

            {

                if ($lc == 255 || $lc == 256)

                {

                    $this->_phpSheet->getDefaultColumnDimension()->setWidth($width / 256);

                    break;

                }

                $this->_phpSheet->getColumnDimensionByColumn($i)->setWidth($width / 256);

                $this->_phpSheet->getColumnDimensionByColumn($i)->setVisible(! $isHidden);

                $this->_phpSheet->getColumnDimensionByColumn($i)->setOutlineLevel($level);

                $this->_phpSheet->getColumnDimensionByColumn($i)->setCollapsed($isCollapsed);

                $this->_phpSheet->getColumnDimensionByColumn($i)->setXfIndex($this->_mapCellXfIndex[$xfIndex]);

            }

        }

    }



    /**

     * ROW

     *

     * This record contains the properties of a single row in a

     * sheet. Rows and cells in a sheet are divided into blocks

     * of 32 rows.

     *

     * --	"OpenOffice.org's Documentation of the Microsoft

     * Excel File Format"

     */

    private function _readRow()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        $recordData = substr($this->_data, $this->_pos + 4, $length);

        

        // move stream pointer to next record

        $this->_pos += 4 + $length;

        

        if (! $this->_readDataOnly)

        {

            // offset: 0; size: 2; index of this row

            $r = self :: _GetInt2d($recordData, 0);

            

            // offset: 2; size: 2; index to column of the first cell which is described by a cell record

            



            // offset: 4; size: 2; index to column of the last cell which is described by a cell record, increased by 1

            



            // offset: 6; size: 2;

            



            // bit: 14-0; mask: 0x7FFF; height of the row, in twips = 1/20 of a point

            $height = (0x7FFF & self :: _GetInt2d($recordData, 6)) >> 0;

            

            // bit: 15: mask: 0x8000; 0 = row has custom height; 1= row has default height

            $useDefaultHeight = (0x8000 & self :: _GetInt2d($recordData, 6)) >> 15;

            

            if (! $useDefaultHeight)

            {

                $this->_phpSheet->getRowDimension($r + 1)->setRowHeight($height / 20);

            }

            

            // offset: 8; size: 2; not used

            



            // offset: 10; size: 2; not used in BIFF5-BIFF8

            



            // offset: 12; size: 4; option flags and default row formatting

            



            // bit: 2-0: mask: 0x00000007; outline level of the row

            $level = (0x00000007 & self :: _GetInt4d($recordData, 12)) >> 0;

            $this->_phpSheet->getRowDimension($r + 1)->setOutlineLevel($level);

            

            // bit: 4; mask: 0x00000010; 1 = outline group start or ends here... and is collapsed

            $isCollapsed = (0x00000010 & self :: _GetInt4d($recordData, 12)) >> 4;

            $this->_phpSheet->getRowDimension($r + 1)->setCollapsed($isCollapsed);

            

            // bit: 5; mask: 0x00000020; 1 = row is hidden

            $isHidden = (0x00000020 & self :: _GetInt4d($recordData, 12)) >> 5;

            $this->_phpSheet->getRowDimension($r + 1)->setVisible(! $isHidden);

            

            // bit: 7; mask: 0x00000080; 1 = row has explicit format

            $hasExplicitFormat = (0x00000080 & self :: _GetInt4d($recordData, 12)) >> 7;

            

            // bit: 27-16; mask: 0x0FFF0000; only applies when hasExplicitFormat = 1; index to XF record

            $xfIndex = (0x0FFF0000 & self :: _GetInt4d($recordData, 12)) >> 16;

            

            if ($hasExplicitFormat)

            {

                $this->_phpSheet->getRowDimension($r + 1)->setXfIndex($this->_mapCellXfIndex[$xfIndex]);

            }

        }

    }



    /**

     * Read RK record

     * This record represents a cell that contains an RK value

     * (encoded integer or floating-point value). If a

     * floating-point value cannot be encoded to an RK value,

     * a NUMBER record will be written. This record replaces the

     * record INTEGER written in BIFF2.

     *

     * --	"OpenOffice.org's Documentation of the Microsoft

     * Excel File Format"

     */

    private function _readRk()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        $recordData = substr($this->_data, $this->_pos + 4, $length);

        

        // move stream pointer to next record

        $this->_pos += 4 + $length;

        

        // offset: 0; size: 2; index to row

        $row = self :: _GetInt2d($recordData, 0);

        

        // offset: 2; size: 2; index to column

        $column = self :: _GetInt2d($recordData, 2);

        $columnString = PHPExcel_Cell :: stringFromColumnIndex($column);

        

        // Read cell?

        if (! is_null($this->getReadFilter()) && $this->getReadFilter()->readCell($columnString, $row + 1, $this->_phpSheet->getTitle()))

        {

            // offset: 4; size: 2; index to XF record

            $xfIndex = self :: _GetInt2d($recordData, 4);

            

            // offset: 6; size: 4; RK value

            $rknum = self :: _GetInt4d($recordData, 6);

            $numValue = self :: _GetIEEE754($rknum);

            

            $cell = $this->_phpSheet->getCell($columnString . ($row + 1));

            if (! $this->_readDataOnly)

            {

                // add style information

                $cell->setXfIndex($this->_mapCellXfIndex[$xfIndex]);

            }

            

            // add cell

            $cell->setValueExplicit($numValue, PHPExcel_Cell_DataType :: TYPE_NUMERIC);

        }

    }



    /**

     * Read LABELSST record

     * This record represents a cell that contains a string. It

     * replaces the LABEL record and RSTRING record used in

     * BIFF2-BIFF5.

     *

     * --	"OpenOffice.org's Documentation of the Microsoft

     * Excel File Format"

     */

    private function _readLabelSst()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        $recordData = substr($this->_data, $this->_pos + 4, $length);

        

        // move stream pointer to next record

        $this->_pos += 4 + $length;

        

        // offset: 0; size: 2; index to row

        $row = self :: _GetInt2d($recordData, 0);

        

        // offset: 2; size: 2; index to column

        $column = self :: _GetInt2d($recordData, 2);

        $columnString = PHPExcel_Cell :: stringFromColumnIndex($column);

        

        // Read cell?

        if (! is_null($this->getReadFilter()) && $this->getReadFilter()->readCell($columnString, $row + 1, $this->_phpSheet->getTitle()))

        {

            // offset: 4; size: 2; index to XF record

            $xfIndex = self :: _GetInt2d($recordData, 4);

            

            // offset: 6; size: 4; index to SST record

            $index = self :: _GetInt4d($recordData, 6);

            

            // add cell

            if (($fmtRuns = $this->_sst[$index]['fmtRuns']) && ! $this->_readDataOnly)

            {

                // then we should treat as rich text

                $richText = new PHPExcel_RichText();

                $charPos = 0;

                $sstCount = count($this->_sst[$index]['fmtRuns']);

                for($i = 0; $i <= $sstCount; ++ $i)

                {

                    if (isset($fmtRuns[$i]))

                    {

                        $text = PHPExcel_Shared_String :: Substring($this->_sst[$index]['value'], $charPos, $fmtRuns[$i]['charPos'] - $charPos);

                        $charPos = $fmtRuns[$i]['charPos'];

                    }

                    else

                    {

                        $text = PHPExcel_Shared_String :: Substring($this->_sst[$index]['value'], $charPos, PHPExcel_Shared_String :: CountCharacters($this->_sst[$index]['value']));

                    }

                    

                    if (PHPExcel_Shared_String :: CountCharacters($text) > 0)

                    {

                        if ($i == 0)

                        { // first text run, no style

                            $richText->createText($text);

                        }

                        else

                        {

                            $textRun = $richText->createTextRun($text);

                            if (isset($fmtRuns[$i - 1]))

                            {

                                if ($fmtRuns[$i - 1]['fontIndex'] < 4)

                                {

                                    $fontIndex = $fmtRuns[$i - 1]['fontIndex'];

                                }

                                else

                                {

                                    // this has to do with that index 4 is omitted in all BIFF versions for some strange reason

                                    // check the OpenOffice documentation of the FONT record

                                    $fontIndex = $fmtRuns[$i - 1]['fontIndex'] - 1;

                                }

                                $textRun->setFont(clone $this->_objFonts[$fontIndex]);

                            }

                        }

                    }

                }

                $cell = $this->_phpSheet->getCell($columnString . ($row + 1));

                $cell->setValueExplicit($richText, PHPExcel_Cell_DataType :: TYPE_STRING);

            }

            else

            {

                $cell = $this->_phpSheet->getCell($columnString . ($row + 1));

                $cell->setValueExplicit($this->_sst[$index]['value'], PHPExcel_Cell_DataType :: TYPE_STRING);

            }

            

            if (! $this->_readDataOnly)

            {

                // add style information

                $cell->setXfIndex($this->_mapCellXfIndex[$xfIndex]);

            }

        }

    }



    /**

     * Read MULRK record

     * This record represents a cell range containing RK value

     * cells. All cells are located in the same row.

     *

     * --	"OpenOffice.org's Documentation of the Microsoft

     * Excel File Format"

     */

    private function _readMulRk()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        $recordData = substr($this->_data, $this->_pos + 4, $length);

        

        // move stream pointer to next record

        $this->_pos += 4 + $length;

        

        // offset: 0; size: 2; index to row

        $row = self :: _GetInt2d($recordData, 0);

        

        // offset: 2; size: 2; index to first column

        $colFirst = self :: _GetInt2d($recordData, 2);

        

        // offset: var; size: 2; index to last column

        $colLast = self :: _GetInt2d($recordData, $length - 2);

        $columns = $colLast - $colFirst + 1;

        

        // offset within record data

        $offset = 4;

        

        for($i = 0; $i < $columns; ++ $i)

        {

            $columnString = PHPExcel_Cell :: stringFromColumnIndex($colFirst + $i);

            

            // Read cell?

            if (! is_null($this->getReadFilter()) && $this->getReadFilter()->readCell($columnString, $row + 1, $this->_phpSheet->getTitle()))

            {

                

                // offset: var; size: 2; index to XF record

                $xfIndex = self :: _GetInt2d($recordData, $offset);

                

                // offset: var; size: 4; RK value

                $numValue = self :: _GetIEEE754(self :: _GetInt4d($recordData, $offset + 2));

                $cell = $this->_phpSheet->getCell($columnString . ($row + 1));

                if (! $this->_readDataOnly)

                {

                    // add style

                    $cell->setXfIndex($this->_mapCellXfIndex[$xfIndex]);

                }

                

                // add cell value

                $cell->setValueExplicit($numValue, PHPExcel_Cell_DataType :: TYPE_NUMERIC);

            }

            

            $offset += 6;

        }

    }



    /**

     * Read NUMBER record

     * This record represents a cell that contains a

     * floating-point value.

     *

     * --	"OpenOffice.org's Documentation of the Microsoft

     * Excel File Format"

     */

    private function _readNumber()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        $recordData = substr($this->_data, $this->_pos + 4, $length);

        

        // move stream pointer to next record

        $this->_pos += 4 + $length;

        

        // offset: 0; size: 2; index to row

        $row = self :: _GetInt2d($recordData, 0);

        

        // offset: 2; size 2; index to column

        $column = self :: _GetInt2d($recordData, 2);

        $columnString = PHPExcel_Cell :: stringFromColumnIndex($column);

        

        // Read cell?

        if (! is_null($this->getReadFilter()) && $this->getReadFilter()->readCell($columnString, $row + 1, $this->_phpSheet->getTitle()))

        {

            // offset 4; size: 2; index to XF record

            $xfIndex = self :: _GetInt2d($recordData, 4);

            

            $numValue = self :: _extractNumber(substr($recordData, 6, 8));

            

            $cell = $this->_phpSheet->getCell($columnString . ($row + 1));

            if (! $this->_readDataOnly)

            {

                // add cell style

                $cell->setXfIndex($this->_mapCellXfIndex[$xfIndex]);

            }

            

            // add cell value

            $cell->setValueExplicit($numValue, PHPExcel_Cell_DataType :: TYPE_NUMERIC);

        }

    }



    /**

     * Read FORMULA record + perhaps a following STRING record if formula result is a string

     * This record contains the token array and the result of a

     * formula cell.

     *

     * --	"OpenOffice.org's Documentation of the Microsoft

     * Excel File Format"

     */

    private function _readFormula()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        $recordData = substr($this->_data, $this->_pos + 4, $length);

        

        // move stream pointer to next record

        $this->_pos += 4 + $length;

        

        // offset: 0; size: 2; row index

        $row = self :: _GetInt2d($recordData, 0);

        

        // offset: 2; size: 2; col index

        $column = self :: _GetInt2d($recordData, 2);

        $columnString = PHPExcel_Cell :: stringFromColumnIndex($column);

        

        // offset: 20: size: variable; formula structure

        $formulaStructure = substr($recordData, 20);

        

        // offset: 14: size: 2; option flags, recalculate always, recalculate on open etc.

        $options = self :: _GetInt2d($recordData, 14);

        

        // bit: 0; mask: 0x0001; 1 = recalculate always

        // bit: 1; mask: 0x0002; 1 = calculate on open

        // bit: 2; mask: 0x0008; 1 = part of a shared formula

        $isPartOfSharedFormula = (bool) (0x0008 & $options);

        

        // WARNING:

        // We can apparently not rely on $isPartOfSharedFormula. Even when $isPartOfSharedFormula = true

        // the formula data may be ordinary formula data, therefore we need to check

        // explicitly for the tExp token (0x01)

        $isPartOfSharedFormula = $isPartOfSharedFormula && ord($formulaStructure{2}) == 0x01;

        

        if ($isPartOfSharedFormula)

        {

            // part of shared formula which means there will be a formula with a tExp token and nothing else

            // get the base cell, grab tExp token

            $baseRow = self :: _GetInt2d($formulaStructure, 3);

            $baseCol = self :: _GetInt2d($formulaStructure, 5);

            $this->_baseCell = PHPExcel_Cell :: stringFromColumnIndex($baseCol) . ($baseRow + 1);

        }

        

        // Read cell?

        if (! is_null($this->getReadFilter()) && $this->getReadFilter()->readCell($columnString, $row + 1, $this->_phpSheet->getTitle()))

        {

            

            if ($isPartOfSharedFormula)

            {

                // formula is added to this cell after the sheet has been read

                $this->_sharedFormulaParts[$columnString . ($row + 1)] = $this->_baseCell;

            }

            

            // offset: 16: size: 4; not used

            



            // offset: 4; size: 2; XF index

            $xfIndex = self :: _GetInt2d($recordData, 4);

            

            // offset: 6; size: 8; result of the formula

            if ((ord($recordData{6}) == 0) && (ord($recordData{12}) == 255) && (ord($recordData{13}) == 255))

            {

                

                // String formula. Result follows in appended STRING record

                $dataType = PHPExcel_Cell_DataType :: TYPE_STRING;

                

                // read possible SHAREDFMLA record

                $code = self :: _GetInt2d($this->_data, $this->_pos);

                if ($code == self :: XLS_Type_SHAREDFMLA)

                {

                    $this->_readSharedFmla();

                }

                

                // read STRING record

                $value = $this->_readString();

            

            }

            elseif ((ord($recordData{6}) == 1) && (ord($recordData{12}) == 255) && (ord($recordData{13}) == 255))

            {

                

                // Boolean formula. Result is in +2; 0=false, 1=true

                $dataType = PHPExcel_Cell_DataType :: TYPE_BOOL;

                $value = (bool) ord($recordData{8});

            

            }

            elseif ((ord($recordData{6}) == 2) && (ord($recordData{12}) == 255) && (ord($recordData{13}) == 255))

            {

                

                // Error formula. Error code is in +2

                $dataType = PHPExcel_Cell_DataType :: TYPE_ERROR;

                $value = self :: _mapErrorCode(ord($recordData{8}));

            

            }

            elseif ((ord($recordData{6}) == 3) && (ord($recordData{12}) == 255) && (ord($recordData{13}) == 255))

            {

                

                // Formula result is a null string

                $dataType = PHPExcel_Cell_DataType :: TYPE_NULL;

                $value = '';

            

            }

            else

            {

                

                // forumla result is a number, first 14 bytes like _NUMBER record

                $dataType = PHPExcel_Cell_DataType :: TYPE_NUMERIC;

                $value = self :: _extractNumber(substr($recordData, 6, 8));

            

            }

            

            $cell = $this->_phpSheet->getCell($columnString . ($row + 1));

            if (! $this->_readDataOnly)

            {

                // add cell style

                $cell->setXfIndex($this->_mapCellXfIndex[$xfIndex]);

            }

            

            // store the formula

            if (! $isPartOfSharedFormula)

            {

                // not part of shared formula

                // add cell value. If we can read formula, populate with formula, otherwise just used cached value

                try

                {

                    if ($this->_version != self :: XLS_BIFF8)

                    {

                        throw new Exception('Not BIFF8. Can only read BIFF8 formulas');

                    }

                    $formula = $this->_getFormulaFromStructure($formulaStructure); // get formula in human language

                    $cell->setValueExplicit('=' . $formula, PHPExcel_Cell_DataType :: TYPE_FORMULA);

                

                }

                catch (Exception $e)

                {

                    $cell->setValueExplicit($value, $dataType);

                }

            }

            else

            {

                if ($this->_version == self :: XLS_BIFF8)

                {

                    // do nothing at this point, formula id added later in the code

                }

                else

                {

                    $cell->setValueExplicit($value, $dataType);

                }

            }

            

            // store the cached calculated value

            $cell->setCalculatedValue($value);

        }

    }



    /**

     * Read a SHAREDFMLA record. This function just stores the binary shared formula in the reader,

     * which usually contains relative references.

     * These will be used to construct the formula in each shared formula part after the sheet is read.

     */

    private function _readSharedFmla()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        $recordData = substr($this->_data, $this->_pos + 4, $length);

        

        // move stream pointer to next record

        $this->_pos += 4 + $length;

        

        // offset: 0, size: 6; cell range address of the area used by the shared formula, not used for anything

        $cellRange = substr($recordData, 0, 6);

        $cellRange = $this->_readBIFF5CellRangeAddressFixed($cellRange); // note: even BIFF8 uses BIFF5 syntax

        



        // offset: 6, size: 1; not used

        



        // offset: 7, size: 1; number of existing FORMULA records for this shared formula

        $no = ord($recordData{7});

        

        // offset: 8, size: var; Binary token array of the shared formula

        $formula = substr($recordData, 8);

        

        // at this point we only store the shared formula for later use

        $this->_sharedFormulas[$this->_baseCell] = $formula;

    

    }



    /**

     * Read a STRING record from current stream position and advance the stream pointer to next record

     * This record is used for storing result from FORMULA record when it is a string, and

     * it occurs directly after the FORMULA record

     *

     * @return string The string contents as UTF-8

     */

    private function _readString()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        $recordData = substr($this->_data, $this->_pos + 4, $length);

        

        // move stream pointer to next record

        $this->_pos += 4 + $length;

        

        if ($this->_version == self :: XLS_BIFF8)

        {

            $string = self :: _readUnicodeStringLong($recordData);

            $value = $string['value'];

        }

        else

        {

            $string = $this->_readByteStringLong($recordData);

            $value = $string['value'];

        }

        

        return $value;

    }



    /**

     * Read BOOLERR record

     * This record represents a Boolean value or error value

     * cell.

     *

     * --	"OpenOffice.org's Documentation of the Microsoft

     * Excel File Format"

     */

    private function _readBoolErr()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        $recordData = substr($this->_data, $this->_pos + 4, $length);

        

        // move stream pointer to next record

        $this->_pos += 4 + $length;

        

        // offset: 0; size: 2; row index

        $row = self :: _GetInt2d($recordData, 0);

        

        // offset: 2; size: 2; column index

        $column = self :: _GetInt2d($recordData, 2);

        $columnString = PHPExcel_Cell :: stringFromColumnIndex($column);

        

        // Read cell?

        if (! is_null($this->getReadFilter()) && $this->getReadFilter()->readCell($columnString, $row + 1, $this->_phpSheet->getTitle()))

        {

            // offset: 4; size: 2; index to XF record

            $xfIndex = self :: _GetInt2d($recordData, 4);

            

            // offset: 6; size: 1; the boolean value or error value

            $boolErr = ord($recordData{6});

            

            // offset: 7; size: 1; 0=boolean; 1=error

            $isError = ord($recordData{7});

            

            $cell = $this->_phpSheet->getCell($columnString . ($row + 1));

            switch ($isError)

            {

                case 0 : // boolean

                    $value = (bool) $boolErr;

                    

                    // add cell value

                    $cell->setValueExplicit($value, PHPExcel_Cell_DataType :: TYPE_BOOL);

                    break;

                

                case 1 : // error type

                    $value = self :: _mapErrorCode($boolErr);

                    

                    // add cell value

                    $cell->setValueExplicit($value, PHPExcel_Cell_DataType :: TYPE_ERROR);

                    break;

            }

            

            if (! $this->_readDataOnly)

            {

                // add cell style

                $cell->setXfIndex($this->_mapCellXfIndex[$xfIndex]);

            }

        }

    }



    /**

     * Read MULBLANK record

     * This record represents a cell range of empty cells. All

     * cells are located in the same row

     *

     * --	"OpenOffice.org's Documentation of the Microsoft

     * Excel File Format"

     */

    private function _readMulBlank()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        $recordData = substr($this->_data, $this->_pos + 4, $length);

        

        // move stream pointer to next record

        $this->_pos += 4 + $length;

        

        // offset: 0; size: 2; index to row

        $row = self :: _GetInt2d($recordData, 0);

        

        // offset: 2; size: 2; index to first column

        $fc = self :: _GetInt2d($recordData, 2);

        

        // offset: 4; size: 2 x nc; list of indexes to XF records

        // add style information

        if (! $this->_readDataOnly)

        {

            for($i = 0; $i < $length / 2 - 3; ++ $i)

            {

                $columnString = PHPExcel_Cell :: stringFromColumnIndex($fc + $i);

                

                // Read cell?

                if (! is_null($this->getReadFilter()) && $this->getReadFilter()->readCell($columnString, $row + 1, $this->_phpSheet->getTitle()))

                {

                    $xfIndex = self :: _GetInt2d($recordData, 4 + 2 * $i);

                    $this->_phpSheet->getCell($columnString . ($row + 1))->setXfIndex($this->_mapCellXfIndex[$xfIndex]);

                }

            }

        }

    

     // offset: 6; size 2; index to last column (not needed)

    }



    /**

     * Read LABEL record

     * This record represents a cell that contains a string. In

     * BIFF8 it is usually replaced by the LABELSST record.

     * Excel still uses this record, if it copies unformatted

     * text cells to the clipboard.

     *

     * --	"OpenOffice.org's Documentation of the Microsoft

     * Excel File Format"

     */

    private function _readLabel()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        $recordData = substr($this->_data, $this->_pos + 4, $length);

        

        // move stream pointer to next record

        $this->_pos += 4 + $length;

        

        // offset: 0; size: 2; index to row

        $row = self :: _GetInt2d($recordData, 0);

        

        // offset: 2; size: 2; index to column

        $column = self :: _GetInt2d($recordData, 2);

        $columnString = PHPExcel_Cell :: stringFromColumnIndex($column);

        

        // Read cell?

        if (! is_null($this->getReadFilter()) && $this->getReadFilter()->readCell($columnString, $row + 1, $this->_phpSheet->getTitle()))

        {

            // offset: 4; size: 2; XF index

            $xfIndex = self :: _GetInt2d($recordData, 4);

            

            // add cell value

            // todo: what if string is very long? continue record

            if ($this->_version == self :: XLS_BIFF8)

            {

                $string = self :: _readUnicodeStringLong(substr($recordData, 6));

                $value = $string['value'];

            }

            else

            {

                $string = $this->_readByteStringLong(substr($recordData, 6));

                $value = $string['value'];

            }

            $cell = $this->_phpSheet->getCell($columnString . ($row + 1));

            $cell->setValueExplicit($value, PHPExcel_Cell_DataType :: TYPE_STRING);

            

            if (! $this->_readDataOnly)

            {

                // add cell style

                $cell->setXfIndex($this->_mapCellXfIndex[$xfIndex]);

            }

        }

    }



    /**

     * Read BLANK record

     */

    private function _readBlank()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        $recordData = substr($this->_data, $this->_pos + 4, $length);

        

        // move stream pointer to next record

        $this->_pos += 4 + $length;

        

        // offset: 0; size: 2; row index

        $row = self :: _GetInt2d($recordData, 0);

        

        // offset: 2; size: 2; col index

        $col = self :: _GetInt2d($recordData, 2);

        $columnString = PHPExcel_Cell :: stringFromColumnIndex($col);

        

        // Read cell?

        if (! is_null($this->getReadFilter()) && $this->getReadFilter()->readCell($columnString, $row + 1, $this->_phpSheet->getTitle()))

        {

            // offset: 4; size: 2; XF index

            $xfIndex = self :: _GetInt2d($recordData, 4);

            

            // add style information

            if (! $this->_readDataOnly)

            {

                $this->_phpSheet->getCell($columnString . ($row + 1))->setXfIndex($this->_mapCellXfIndex[$xfIndex]);

            }

        }

    

    }



    /**

     * Read MSODRAWING record

     */

    private function _readMsoDrawing()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        

        // get spliced record data

        $splicedRecordData = $this->_getSplicedRecordData();

        $recordData = $splicedRecordData['recordData'];

        

        $this->_drawingData .= $recordData;

    }



    /**

     * Read OBJ record

     */

    private function _readObj()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        $recordData = substr($this->_data, $this->_pos + 4, $length);

        

        // move stream pointer to next record

        $this->_pos += 4 + $length;

        

        if ($this->_readDataOnly || $this->_version != self :: XLS_BIFF8)

        {

            return;

        }

        

        // recordData consists of an array of subrecords looking like this:

        //	ft: 2 bytes; ftCmo type (0x15)

        //	cb: 2 bytes; size in bytes of ftCmo data

        //	ot: 2 bytes; Object Type

        //	id: 2 bytes; Object id number

        //	grbit: 2 bytes; Option Flags

        //	data: var; subrecord data

        



        // for now, we are just interested in the second subrecord containing the object type

        $ftCmoType = self :: _GetInt2d($recordData, 0);

        $cbCmoSize = self :: _GetInt2d($recordData, 2);

        $otObjType = self :: _GetInt2d($recordData, 4);

        $idObjID = self :: _GetInt2d($recordData, 6);

        $grbitOpts = self :: _GetInt2d($recordData, 6);

        

        $this->_objs[] = array('ftCmoType' => $ftCmoType, 'cbCmoSize' => $cbCmoSize, 'otObjType' => $otObjType, 

                'idObjID' => $idObjID, 'grbitOpts' => $grbitOpts);

        $this->textObjRef = $idObjID;

    

     //		echo '<b>_readObj()</b><br />';

    //		var_dump(end($this->_objs));

    //		echo '<br />';

    }



    /**

     * Read WINDOW2 record

     */

    private function _readWindow2()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        $recordData = substr($this->_data, $this->_pos + 4, $length);

        

        // move stream pointer to next record

        $this->_pos += 4 + $length;

        

        // offset: 0; size: 2; option flags

        $options = self :: _GetInt2d($recordData, 0);

        

        // bit: 1; mask: 0x0002; 0 = do not show gridlines, 1 = show gridlines

        $showGridlines = (bool) ((0x0002 & $options) >> 1);

        $this->_phpSheet->setShowGridlines($showGridlines);

        

        // bit: 2; mask: 0x0004; 0 = do not show headers, 1 = show headers

        $showRowColHeaders = (bool) ((0x0004 & $options) >> 2);

        $this->_phpSheet->setShowRowColHeaders($showRowColHeaders);

        

        // bit: 3; mask: 0x0008; 0 = panes are not frozen, 1 = panes are frozen

        $this->_frozen = (bool) ((0x0008 & $options) >> 3);

        

        // bit: 6; mask: 0x0040; 0 = columns from left to right, 1 = columns from right to left

        $this->_phpSheet->setRightToLeft((bool) ((0x0040 & $options) >> 6));

        

        // bit: 10; mask: 0x0400; 0 = sheet not active, 1 = sheet active

        $isActive = (bool) ((0x0400 & $options) >> 10);

        if ($isActive)

        {

            $this->_phpExcel->setActiveSheetIndex($this->_phpExcel->getIndex($this->_phpSheet));

        }

    }



    /**

     * Read SCL record

     */

    private function _readScl()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        $recordData = substr($this->_data, $this->_pos + 4, $length);

        

        // move stream pointer to next record

        $this->_pos += 4 + $length;

        

        // offset: 0; size: 2; numerator of the view magnification

        $numerator = self :: _GetInt2d($recordData, 0);

        

        // offset: 2; size: 2; numerator of the view magnification

        $denumerator = self :: _GetInt2d($recordData, 2);

        

        // set the zoom scale (in percent)

        $this->_phpSheet->getSheetView()->setZoomScale($numerator * 100 / $denumerator);

    }



    /**

     * Read PANE record

     */

    private function _readPane()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        $recordData = substr($this->_data, $this->_pos + 4, $length);

        

        // move stream pointer to next record

        $this->_pos += 4 + $length;

        

        if (! $this->_readDataOnly)

        {

            // offset: 0; size: 2; position of vertical split

            $px = self :: _GetInt2d($recordData, 0);

            

            // offset: 2; size: 2; position of horizontal split

            $py = self :: _GetInt2d($recordData, 2);

            

            if ($this->_frozen)

            {

                // frozen panes

                $this->_phpSheet->freezePane(PHPExcel_Cell :: stringFromColumnIndex($px) . ($py + 1));

            }

            else

            {

                // unfrozen panes; split windows; not supported by PHPExcel core

            }

        }

    }



    /**

     * Read SELECTION record. There is one such record for each pane in the sheet.

     */

    private function _readSelection()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        $recordData = substr($this->_data, $this->_pos + 4, $length);

        

        // move stream pointer to next record

        $this->_pos += 4 + $length;

        

        if (! $this->_readDataOnly)

        {

            // offset: 0; size: 1; pane identifier

            $paneId = ord($recordData{0});

            

            // offset: 1; size: 2; index to row of the active cell

            $r = self :: _GetInt2d($recordData, 1);

            

            // offset: 3; size: 2; index to column of the active cell

            $c = self :: _GetInt2d($recordData, 3);

            

            // offset: 5; size: 2; index into the following cell range list to the

            //  entry that contains the active cell

            $index = self :: _GetInt2d($recordData, 5);

            

            // offset: 7; size: var; cell range address list containing all selected cell ranges

            $data = substr($recordData, 7);

            $cellRangeAddressList = $this->_readBIFF5CellRangeAddressList($data); // note: also BIFF8 uses BIFF5 syntax

            



            $selectedCells = $cellRangeAddressList['cellRangeAddresses'][0];

            

            // first row '1' + last row '16384' indicates that full column is selected (apparently also in BIFF8!)

            if (preg_match('/^([A-Z]+1\:[A-Z]+)16384$/', $selectedCells))

            {

                $selectedCells = preg_replace('/^([A-Z]+1\:[A-Z]+)16384$/', '${1}1048576', $selectedCells);

            }

            

            // first row '1' + last row '65536' indicates that full column is selected

            if (preg_match('/^([A-Z]+1\:[A-Z]+)65536$/', $selectedCells))

            {

                $selectedCells = preg_replace('/^([A-Z]+1\:[A-Z]+)65536$/', '${1}1048576', $selectedCells);

            }

            

            // first column 'A' + last column 'IV' indicates that full row is selected

            if (preg_match('/^(A[0-9]+\:)IV([0-9]+)$/', $selectedCells))

            {

                $selectedCells = preg_replace('/^(A[0-9]+\:)IV([0-9]+)$/', '${1}XFD${2}', $selectedCells);

            }

            

            $this->_phpSheet->setSelectedCells($selectedCells);

        }

    }



    private function _includeCellRangeFiltered($cellRangeAddress)

    {

        $includeCellRange = true;

        if (! is_null($this->getReadFilter()))

        {

            $includeCellRange = false;

            $rangeBoundaries = PHPExcel_Cell :: getRangeBoundaries($cellRangeAddress);

            $rangeBoundaries[1][0] ++;

            for($row = $rangeBoundaries[0][1]; $row <= $rangeBoundaries[1][1]; $row ++)

            {

                for($column = $rangeBoundaries[0][0]; $column != $rangeBoundaries[1][0]; $column ++)

                {

                    if ($this->getReadFilter()->readCell($column, $row, $this->_phpSheet->getTitle()))

                    {

                        $includeCellRange = true;

                        break 2;

                    }

                }

            }

        }

        return $includeCellRange;

    }



    /**

     * MERGEDCELLS

     *

     * This record contains the addresses of merged cell ranges

     * in the current sheet.

     *

     * --	"OpenOffice.org's Documentation of the Microsoft

     * Excel File Format"

     */

    private function _readMergedCells()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        $recordData = substr($this->_data, $this->_pos + 4, $length);

        

        // move stream pointer to next record

        $this->_pos += 4 + $length;

        

        if ($this->_version == self :: XLS_BIFF8 && ! $this->_readDataOnly)

        {

            $cellRangeAddressList = $this->_readBIFF8CellRangeAddressList($recordData);

            foreach ($cellRangeAddressList['cellRangeAddresses'] as $cellRangeAddress)

            {

                if ($this->_includeCellRangeFiltered($cellRangeAddress))

                {

                    $this->_phpSheet->mergeCells($cellRangeAddress);

                }

            }

        }

    }



    /**

     * Read HYPERLINK record

     */

    private function _readHyperLink()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        $recordData = substr($this->_data, $this->_pos + 4, $length);

        

        // move stream pointer forward to next record

        $this->_pos += 4 + $length;

        

        if (! $this->_readDataOnly)

        {

            // offset: 0; size: 8; cell range address of all cells containing this hyperlink

            try

            {

                $cellRange = $this->_readBIFF8CellRangeAddressFixed($recordData, 0, 8);

            }

            catch (Exception $e)

            {

                return;

            }

            

            // offset: 8, size: 16; GUID of StdLink

            



            // offset: 24, size: 4; unknown value

            



            // offset: 28, size: 4; option flags

            



            // bit: 0; mask: 0x00000001; 0 = no link or extant, 1 = file link or URL

            $isFileLinkOrUrl = (0x00000001 & self :: _GetInt2d($recordData, 28)) >> 0;

            

            // bit: 1; mask: 0x00000002; 0 = relative path, 1 = absolute path or URL

            $isAbsPathOrUrl = (0x00000001 & self :: _GetInt2d($recordData, 28)) >> 1;

            

            // bit: 2 (and 4); mask: 0x00000014; 0 = no description

            $hasDesc = (0x00000014 & self :: _GetInt2d($recordData, 28)) >> 2;

            

            // bit: 3; mask: 0x00000008; 0 = no text, 1 = has text

            $hasText = (0x00000008 & self :: _GetInt2d($recordData, 28)) >> 3;

            

            // bit: 7; mask: 0x00000080; 0 = no target frame, 1 = has target frame

            $hasFrame = (0x00000080 & self :: _GetInt2d($recordData, 28)) >> 7;

            

            // bit: 8; mask: 0x00000100; 0 = file link or URL, 1 = UNC path (inc. server name)

            $isUNC = (0x00000100 & self :: _GetInt2d($recordData, 28)) >> 8;

            

            // offset within record data

            $offset = 32;

            

            if ($hasDesc)

            {

                // offset: 32; size: var; character count of description text

                $dl = self :: _GetInt4d($recordData, 32);

                // offset: 36; size: var; character array of description text, no Unicode string header, always 16-bit characters, zero terminated

                $desc = self :: _encodeUTF16(substr($recordData, 36, 2 * ($dl - 1)), false);

                $offset += 4 + 2 * $dl;

            }

            if ($hasFrame)

            {

                $fl = self :: _GetInt4d($recordData, $offset);

                $offset += 4 + 2 * $fl;

            }

            

            // detect type of hyperlink (there are 4 types)

            $hyperlinkType = null;

            

            if ($isUNC)

            {

                $hyperlinkType = 'UNC';

            }

            else 

                if (! $isFileLinkOrUrl)

                {

                    $hyperlinkType = 'workbook';

                }

                else 

                    if (ord($recordData{$offset}) == 0x03)

                    {

                        $hyperlinkType = 'local';

                    }

                    else 

                        if (ord($recordData{$offset}) == 0xE0)

                        {

                            $hyperlinkType = 'URL';

                        }

            

            switch ($hyperlinkType)

            {

                case 'URL' :

                    // section 5.58.2: Hyperlink containing a URL

                    // e.g. http://example.org/index.php

                    



                    // offset: var; size: 16; GUID of URL Moniker

                    $offset += 16;

                    // offset: var; size: 4; size (in bytes) of character array of the URL including trailing zero word

                    $us = self :: _GetInt4d($recordData, $offset);

                    $offset += 4;

                    // offset: var; size: $us; character array of the URL, no Unicode string header, always 16-bit characters, zero-terminated

                    $url = self :: _encodeUTF16(substr($recordData, $offset, $us - 2), false);

                    $url .= $hasText ? '#' : '';

                    $offset += $us;

                    break;

                

                case 'local' :

                    // section 5.58.3: Hyperlink to local file

                    // examples:

                    //   mydoc.txt

                    //   ../../somedoc.xls#Sheet!A1

                    



                    // offset: var; size: 16; GUI of File Moniker

                    $offset += 16;

                    

                    // offset: var; size: 2; directory up-level count.

                    $upLevelCount = self :: _GetInt2d($recordData, $offset);

                    $offset += 2;

                    

                    // offset: var; size: 4; character count of the shortened file path and name, including trailing zero word

                    $sl = self :: _GetInt4d($recordData, $offset);

                    $offset += 4;

                    

                    // offset: var; size: sl; character array of the shortened file path and name in 8.3-DOS-format (compressed Unicode string)

                    $shortenedFilePath = substr($recordData, $offset, $sl);

                    $shortenedFilePath = self :: _encodeUTF16($shortenedFilePath, true);

                    $shortenedFilePath = substr($shortenedFilePath, 0, - 1); // remove trailing zero

                    



                    $offset += $sl;

                    

                    // offset: var; size: 24; unknown sequence

                    $offset += 24;

                    

                    // extended file path

                    // offset: var; size: 4; size of the following file link field including string lenth mark

                    $sz = self :: _GetInt4d($recordData, $offset);

                    $offset += 4;

                    

                    // only present if $sz > 0

                    if ($sz > 0)

                    {

                        // offset: var; size: 4; size of the character array of the extended file path and name

                        $xl = self :: _GetInt4d($recordData, $offset);

                        $offset += 4;

                        

                        // offset: var; size 2; unknown

                        $offset += 2;

                        

                        // offset: var; size $xl; character array of the extended file path and name.

                        $extendedFilePath = substr($recordData, $offset, $xl);

                        $extendedFilePath = self :: _encodeUTF16($extendedFilePath, false);

                        $offset += $xl;

                    }

                    

                    // construct the path

                    $url = str_repeat('..\\', $upLevelCount);

                    $url .= ($sz > 0) ? $extendedFilePath : $shortenedFilePath; // use extended path if available

                    $url .= $hasText ? '#' : '';

                    

                    break;

                

                case 'UNC' :

                    // section 5.58.4: Hyperlink to a File with UNC (Universal Naming Convention) Path

                    // todo: implement

                    return;

                

                case 'workbook' :

                    // section 5.58.5: Hyperlink to the Current Workbook

                    // e.g. Sheet2!B1:C2, stored in text mark field

                    $url = 'sheet://';

                    break;

                

                default :

                    return;

            

            }

            

            if ($hasText)

            {

                // offset: var; size: 4; character count of text mark including trailing zero word

                $tl = self :: _GetInt4d($recordData, $offset);

                $offset += 4;

                // offset: var; size: var; character array of the text mark without the # sign, no Unicode header, always 16-bit characters, zero-terminated

                $text = self :: _encodeUTF16(substr($recordData, $offset, 2 * ($tl - 1)), false);

                $url .= $text;

            }

            

            // apply the hyperlink to all the relevant cells

            foreach (PHPExcel_Cell :: extractAllCellReferencesInRange($cellRange) as $coordinate)

            {

                $this->_phpSheet->getCell($coordinate)->getHyperLink()->setUrl($url);

            }

        }

    }



    /**

     * Read DATAVALIDATIONS record

     */

    private function _readDataValidations()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        $recordData = substr($this->_data, $this->_pos + 4, $length);

        

        // move stream pointer forward to next record

        $this->_pos += 4 + $length;

    }



    /**

     * Read DATAVALIDATION record

     */

    private function _readDataValidation()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        $recordData = substr($this->_data, $this->_pos + 4, $length);

        

        // move stream pointer forward to next record

        $this->_pos += 4 + $length;

        

        if ($this->_readDataOnly)

        {

            return;

        }

        

        // offset: 0; size: 4; Options

        $options = self :: _GetInt4d($recordData, 0);

        

        // bit: 0-3; mask: 0x0000000F; type

        $type = (0x0000000F & $options) >> 0;

        switch ($type)

        {

            case 0x00 :

                $type = PHPExcel_Cell_DataValidation :: TYPE_NONE;

                break;

            case 0x01 :

                $type = PHPExcel_Cell_DataValidation :: TYPE_WHOLE;

                break;

            case 0x02 :

                $type = PHPExcel_Cell_DataValidation :: TYPE_DECIMAL;

                break;

            case 0x03 :

                $type = PHPExcel_Cell_DataValidation :: TYPE_LIST;

                break;

            case 0x04 :

                $type = PHPExcel_Cell_DataValidation :: TYPE_DATE;

                break;

            case 0x05 :

                $type = PHPExcel_Cell_DataValidation :: TYPE_TIME;

                break;

            case 0x06 :

                $type = PHPExcel_Cell_DataValidation :: TYPE_TEXTLENGTH;

                break;

            case 0x07 :

                $type = PHPExcel_Cell_DataValidation :: TYPE_CUSTOM;

                break;

        }

        

        // bit: 4-6; mask: 0x00000070; error type

        $errorStyle = (0x00000070 & $options) >> 4;

        switch ($errorStyle)

        {

            case 0x00 :

                $errorStyle = PHPExcel_Cell_DataValidation :: STYLE_STOP;

                break;

            case 0x01 :

                $errorStyle = PHPExcel_Cell_DataValidation :: STYLE_WARNING;

                break;

            case 0x02 :

                $errorStyle = PHPExcel_Cell_DataValidation :: STYLE_INFORMATION;

                break;

        }

        

        // bit: 7; mask: 0x00000080; 1= formula is explicit (only applies to list)

        // I have only seen cases where this is 1

        $explicitFormula = (0x00000080 & $options) >> 7;

        

        // bit: 8; mask: 0x00000100; 1= empty cells allowed

        $allowBlank = (0x00000100 & $options) >> 8;

        

        // bit: 9; mask: 0x00000200; 1= suppress drop down arrow in list type validity

        $suppressDropDown = (0x00000200 & $options) >> 9;

        

        // bit: 18; mask: 0x00040000; 1= show prompt box if cell selected

        $showInputMessage = (0x00040000 & $options) >> 18;

        

        // bit: 19; mask: 0x00080000; 1= show error box if invalid values entered

        $showErrorMessage = (0x00080000 & $options) >> 19;

        

        // bit: 20-23; mask: 0x00F00000; condition operator

        $operator = (0x00F00000 & $options) >> 20;

        switch ($operator)

        {

            case 0x00 :

                $operator = PHPExcel_Cell_DataValidation :: OPERATOR_BETWEEN;

                break;

            case 0x01 :

                $operator = PHPExcel_Cell_DataValidation :: OPERATOR_NOTBETWEEN;

                break;

            case 0x02 :

                $operator = PHPExcel_Cell_DataValidation :: OPERATOR_EQUAL;

                break;

            case 0x03 :

                $operator = PHPExcel_Cell_DataValidation :: OPERATOR_NOTEQUAL;

                break;

            case 0x04 :

                $operator = PHPExcel_Cell_DataValidation :: OPERATOR_GREATERTHAN;

                break;

            case 0x05 :

                $operator = PHPExcel_Cell_DataValidation :: OPERATOR_LESSTHAN;

                break;

            case 0x06 :

                $operator = PHPExcel_Cell_DataValidation :: OPERATOR_GREATERTHANOREQUAL;

                break;

            case 0x07 :

                $operator = PHPExcel_Cell_DataValidation :: OPERATOR_LESSTHANOREQUAL;

                break;

        }

        

        // offset: 4; size: var; title of the prompt box

        $offset = 4;

        $string = self :: _readUnicodeStringLong(substr($recordData, $offset));

        $promptTitle = $string['value'] !== chr(0) ? $string['value'] : '';

        $offset += $string['size'];

        

        // offset: var; size: var; title of the error box

        $string = self :: _readUnicodeStringLong(substr($recordData, $offset));

        $errorTitle = $string['value'] !== chr(0) ? $string['value'] : '';

        $offset += $string['size'];

        

        // offset: var; size: var; text of the prompt box

        $string = self :: _readUnicodeStringLong(substr($recordData, $offset));

        $prompt = $string['value'] !== chr(0) ? $string['value'] : '';

        $offset += $string['size'];

        

        // offset: var; size: var; text of the error box

        $string = self :: _readUnicodeStringLong(substr($recordData, $offset));

        $error = $string['value'] !== chr(0) ? $string['value'] : '';

        $offset += $string['size'];

        

        // offset: var; size: 2; size of the formula data for the first condition

        $sz1 = self :: _GetInt2d($recordData, $offset);

        $offset += 2;

        

        // offset: var; size: 2; not used

        $offset += 2;

        

        // offset: var; size: $sz1; formula data for first condition (without size field)

        $formula1 = substr($recordData, $offset, $sz1);

        $formula1 = pack('v', $sz1) . $formula1; // prepend the length

        try

        {

            $formula1 = $this->_getFormulaFromStructure($formula1);

            

            // in list type validity, null characters are used as item separators

            if ($type == PHPExcel_Cell_DataValidation :: TYPE_LIST)

            {

                $formula1 = str_replace(chr(0), ',', $formula1);

            }

        }

        catch (Exception $e)

        {

            return;

        }

        $offset += $sz1;

        

        // offset: var; size: 2; size of the formula data for the first condition

        $sz2 = self :: _GetInt2d($recordData, $offset);

        $offset += 2;

        

        // offset: var; size: 2; not used

        $offset += 2;

        

        // offset: var; size: $sz2; formula data for second condition (without size field)

        $formula2 = substr($recordData, $offset, $sz2);

        $formula2 = pack('v', $sz2) . $formula2; // prepend the length

        try

        {

            $formula2 = $this->_getFormulaFromStructure($formula2);

        }

        catch (Exception $e)

        {

            return;

        }

        $offset += $sz2;

        

        // offset: var; size: var; cell range address list with

        $cellRangeAddressList = $this->_readBIFF8CellRangeAddressList(substr($recordData, $offset));

        $cellRangeAddresses = $cellRangeAddressList['cellRangeAddresses'];

        

        foreach ($cellRangeAddresses as $cellRange)

        {

            $stRange = $this->_phpSheet->shrinkRangeToFit($cellRange);

            $stRange = PHPExcel_Cell :: extractAllCellReferencesInRange($stRange);

            foreach ($stRange as $coordinate)

            {

                $objValidation = $this->_phpSheet->getCell($coordinate)->getDataValidation();

                $objValidation->setType($type);

                $objValidation->setErrorStyle($errorStyle);

                $objValidation->setAllowBlank((bool) $allowBlank);

                $objValidation->setShowInputMessage((bool) $showInputMessage);

                $objValidation->setShowErrorMessage((bool) $showErrorMessage);

                $objValidation->setShowDropDown(! $suppressDropDown);

                $objValidation->setOperator($operator);

                $objValidation->setErrorTitle($errorTitle);

                $objValidation->setError($error);

                $objValidation->setPromptTitle($promptTitle);

                $objValidation->setPrompt($prompt);

                $objValidation->setFormula1($formula1);

                $objValidation->setFormula2($formula2);

            }

        }

    

    }



    /**

     * Read SHEETLAYOUT record. Stores sheet tab color information.

     */

    private function _readSheetLayout()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        $recordData = substr($this->_data, $this->_pos + 4, $length);

        

        // move stream pointer to next record

        $this->_pos += 4 + $length;

        

        // local pointer in record data

        $offset = 0;

        

        if (! $this->_readDataOnly)

        {

            // offset: 0; size: 2; repeated record identifier 0x0862

            



            // offset: 2; size: 10; not used

            



            // offset: 12; size: 4; size of record data

            // Excel 2003 uses size of 0x14 (documented), Excel 2007 uses size of 0x28 (not documented?)

            $sz = self :: _GetInt4d($recordData, 12);

            

            switch ($sz)

            {

                case 0x14 :

                    // offset: 16; size: 2; color index for sheet tab

                    $colorIndex = self :: _GetInt2d($recordData, 16);

                    $color = self :: _readColor($colorIndex, $this->_palette, $this->_version);

                    $this->_phpSheet->getTabColor()->setRGB($color['rgb']);

                    break;

                

                case 0x28 :

                    // TODO: Investigate structure for .xls SHEETLAYOUT record as saved by MS Office Excel 2007

                    return;

                    break;

            }

        }

    }



    /**

     * Read SHEETPROTECTION record (FEATHEADR)

     */

    private function _readSheetProtection()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        $recordData = substr($this->_data, $this->_pos + 4, $length);

        

        // move stream pointer to next record

        $this->_pos += 4 + $length;

        

        if ($this->_readDataOnly)

        {

            return;

        }

        

        // offset: 0; size: 2; repeated record header

        



        // offset: 2; size: 2; FRT cell reference flag (=0 currently)

        



        // offset: 4; size: 8; Currently not used and set to 0

        



        // offset: 12; size: 2; Shared feature type index (2=Enhanced Protetion, 4=SmartTag)

        $isf = self :: _GetInt2d($recordData, 12);

        if ($isf != 2)

        {

            return;

        }

        

        // offset: 14; size: 1; =1 since this is a feat header

        



        // offset: 15; size: 4; size of rgbHdrSData

        



        // rgbHdrSData, assume "Enhanced Protection"

        // offset: 19; size: 2; option flags

        $options = self :: _GetInt2d($recordData, 19);

        

        // bit: 0; mask 0x0001; 1 = user may edit objects, 0 = users must not edit objects

        $bool = (0x0001 & $options) >> 0;

        $this->_phpSheet->getProtection()->setObjects(! $bool);

        

        // bit: 1; mask 0x0002; edit scenarios

        $bool = (0x0002 & $options) >> 1;

        $this->_phpSheet->getProtection()->setScenarios(! $bool);

        

        // bit: 2; mask 0x0004; format cells

        $bool = (0x0004 & $options) >> 2;

        $this->_phpSheet->getProtection()->setFormatCells(! $bool);

        

        // bit: 3; mask 0x0008; format columns

        $bool = (0x0008 & $options) >> 3;

        $this->_phpSheet->getProtection()->setFormatColumns(! $bool);

        

        // bit: 4; mask 0x0010; format rows

        $bool = (0x0010 & $options) >> 4;

        $this->_phpSheet->getProtection()->setFormatRows(! $bool);

        

        // bit: 5; mask 0x0020; insert columns

        $bool = (0x0020 & $options) >> 5;

        $this->_phpSheet->getProtection()->setInsertColumns(! $bool);

        

        // bit: 6; mask 0x0040; insert rows

        $bool = (0x0040 & $options) >> 6;

        $this->_phpSheet->getProtection()->setInsertRows(! $bool);

        

        // bit: 7; mask 0x0080; insert hyperlinks

        $bool = (0x0080 & $options) >> 7;

        $this->_phpSheet->getProtection()->setInsertHyperlinks(! $bool);

        

        // bit: 8; mask 0x0100; delete columns

        $bool = (0x0100 & $options) >> 8;

        $this->_phpSheet->getProtection()->setDeleteColumns(! $bool);

        

        // bit: 9; mask 0x0200; delete rows

        $bool = (0x0200 & $options) >> 9;

        $this->_phpSheet->getProtection()->setDeleteRows(! $bool);

        

        // bit: 10; mask 0x0400; select locked cells

        $bool = (0x0400 & $options) >> 10;

        $this->_phpSheet->getProtection()->setSelectLockedCells(! $bool);

        

        // bit: 11; mask 0x0800; sort cell range

        $bool = (0x0800 & $options) >> 11;

        $this->_phpSheet->getProtection()->setSort(! $bool);

        

        // bit: 12; mask 0x1000; auto filter

        $bool = (0x1000 & $options) >> 12;

        $this->_phpSheet->getProtection()->setAutoFilter(! $bool);

        

        // bit: 13; mask 0x2000; pivot tables

        $bool = (0x2000 & $options) >> 13;

        $this->_phpSheet->getProtection()->setPivotTables(! $bool);

        

        // bit: 14; mask 0x4000; select unlocked cells

        $bool = (0x4000 & $options) >> 14;

        $this->_phpSheet->getProtection()->setSelectUnlockedCells(! $bool);

    

     // offset: 21; size: 2; not used

    }



    /**

     * Read RANGEPROTECTION record

     * Reading of this record is based on Microsoft Office Excel 97-2000 Binary File Format Specification,

     * where it is referred to as FEAT record

     */

    private function _readRangeProtection()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        $recordData = substr($this->_data, $this->_pos + 4, $length);

        

        // move stream pointer to next record

        $this->_pos += 4 + $length;

        

        // local pointer in record data

        $offset = 0;

        

        if (! $this->_readDataOnly)

        {

            $offset += 12;

            

            // offset: 12; size: 2; shared feature type, 2 = enhanced protection, 4 = smart tag

            $isf = self :: _GetInt2d($recordData, 12);

            if ($isf != 2)

            {

                // we only read FEAT records of type 2

                return;

            }

            $offset += 2;

            

            $offset += 5;

            

            // offset: 19; size: 2; count of ref ranges this feature is on

            $cref = self :: _GetInt2d($recordData, 19);

            $offset += 2;

            

            $offset += 6;

            

            // offset: 27; size: 8 * $cref; list of cell ranges (like in hyperlink record)

            $cellRanges = array();

            for($i = 0; $i < $cref; ++ $i)

            {

                try

                {

                    $cellRange = $this->_readBIFF8CellRangeAddressFixed(substr($recordData, 27 + 8 * $i, 8));

                }

                catch (Exception $e)

                {

                    return;

                }

                $cellRanges[] = $cellRange;

                $offset += 8;

            }

            

            // offset: var; size: var; variable length of feature specific data

            $rgbFeat = substr($recordData, $offset);

            $offset += 4;

            

            // offset: var; size: 4; the encrypted password (only 16-bit although field is 32-bit)

            $wPassword = self :: _GetInt4d($recordData, $offset);

            $offset += 4;

            

            // Apply range protection to sheet

            if ($cellRanges)

            {

                $this->_phpSheet->protectCells(implode(' ', $cellRanges), strtoupper(dechex($wPassword)), true);

            }

        }

    }



    /**

     * Read IMDATA record

     */

    private function _readImData()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        

        // get spliced record data

        $splicedRecordData = $this->_getSplicedRecordData();

        $recordData = $splicedRecordData['recordData'];

        

        // UNDER CONSTRUCTION

        



        // offset: 0; size: 2; image format

        $cf = self :: _GetInt2d($recordData, 0);

        

        // offset: 2; size: 2; environment from which the file was written

        $env = self :: _GetInt2d($recordData, 2);

        

        // offset: 4; size: 4; length of the image data

        $lcb = self :: _GetInt4d($recordData, 4);

        

        // offset: 8; size: var; image data

        $iData = substr($recordData, 8);

        

        switch ($cf)

        {

            case 0x09 : // Windows bitmap format

                // BITMAPCOREINFO

                // 1. BITMAPCOREHEADER

                // offset: 0; size: 4; bcSize, Specifies the number of bytes required by the structure

                $bcSize = self :: _GetInt4d($iData, 0);

                //			var_dump($bcSize);

                



                // offset: 4; size: 2; bcWidth, specifies the width of the bitmap, in pixels

                $bcWidth = self :: _GetInt2d($iData, 4);

                //			var_dump($bcWidth);

                



                // offset: 6; size: 2; bcHeight, specifies the height of the bitmap, in pixels.

                $bcHeight = self :: _GetInt2d($iData, 6);

                //			var_dump($bcHeight);

                $ih = imagecreatetruecolor($bcWidth, $bcHeight);

                

                // offset: 8; size: 2; bcPlanes, specifies the number of planes for the target device. This value must be 1

                



                // offset: 10; size: 2; bcBitCount specifies the number of bits-per-pixel. This value must be 1, 4, 8, or 24

                $bcBitCount = self :: _GetInt2d($iData, 10);

                //			var_dump($bcBitCount);

                



                $rgbString = substr($iData, 12);

                $rgbTriples = array();

                while (strlen($rgbString) > 0)

                {

                    $rgbTriples[] = unpack('Cb/Cg/Cr', $rgbString);

                    $rgbString = substr($rgbString, 3);

                }

                $x = 0;

                $y = 0;

                foreach ($rgbTriples as $i => $rgbTriple)

                {

                    $color = imagecolorallocate($ih, $rgbTriple['r'], $rgbTriple['g'], $rgbTriple['b']);

                    imagesetpixel($ih, $x, $bcHeight - 1 - $y, $color);

                    $x = ($x + 1) % $bcWidth;

                    $y = $y + floor(($x + 1) / $bcWidth);

                }

                //imagepng($ih, 'image.png');

                



                $drawing = new PHPExcel_Worksheet_Drawing();

                $drawing->setPath($filename);

                $drawing->setWorksheet($this->_phpSheet);

                

                break;

            

            case 0x02 : // Windows metafile or Macintosh PICT format

            case 0x0e : // native format

            default :

                break;

        

        }

    

     // _getSplicedRecordData() takes care of moving current position in data stream

    }



    /**

     * Read a free CONTINUE record. Free CONTINUE record may be a camouflaged MSODRAWING record

     * When MSODRAWING data on a sheet exceeds 8224 bytes, CONTINUE records are used instead. Undocumented.

     * In this case, we must treat the CONTINUE record as a MSODRAWING record

     */

    private function _readContinue()

    {

        $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

        $recordData = substr($this->_data, $this->_pos + 4, $length);

        

        // check if we are reading drawing data

        // this is in case a free CONTINUE record occurs in other circumstances we are unaware of

        if ($this->_drawingData == '')

        {

            // move stream pointer to next record

            $this->_pos += 4 + $length;

            

            return;

        }

        

        // check if record data is at least 4 bytes long, otherwise there is no chance this is MSODRAWING data

        if ($length < 4)

        {

            // move stream pointer to next record

            $this->_pos += 4 + $length;

            

            return;

        }

        

        // dirty check to see if CONTINUE record could be a camouflaged MSODRAWING record

        // look inside CONTINUE record to see if it looks like a part of an Escher stream

        // we know that Escher stream may be split at least at

        //		0xF003 MsofbtSpgrContainer

        //		0xF004 MsofbtSpContainer

        //		0xF00D MsofbtClientTextbox

        $validSplitPoints = array(0xF003, 0xF004, 0xF00D); // add identifiers if we find more

        



        $splitPoint = self :: _GetInt2d($recordData, 2);

        if (in_array($splitPoint, $validSplitPoints))

        {

            // get spliced record data (and move pointer to next record)

            $splicedRecordData = $this->_getSplicedRecordData();

            $this->_drawingData .= $splicedRecordData['recordData'];

            

            return;

        }

        

        // move stream pointer to next record

        $this->_pos += 4 + $length;

    

    }



    /**

     * Reads a record from current position in data stream and continues reading data as long as CONTINUE

     * records are found. Splices the record data pieces and returns the combined string as if record data

     * is in one piece.

     * Moves to next current position in data stream to start of next record different from a CONtINUE record

     *

     * @return array

     */

    private function _getSplicedRecordData()

    {

        $data = '';

        $spliceOffsets = array();

        

        $i = 0;

        $spliceOffsets[0] = 0;

        

        do

        {

            ++ $i;

            

            // offset: 0; size: 2; identifier

            $identifier = self :: _GetInt2d($this->_data, $this->_pos);

            // offset: 2; size: 2; length

            $length = self :: _GetInt2d($this->_data, $this->_pos + 2);

            $data .= substr($this->_data, $this->_pos + 4, $length);

            

            $spliceOffsets[$i] = $spliceOffsets[$i - 1] + $length;

            

            $this->_pos += 4 + $length;

            $nextIdentifier = self :: _GetInt2d($this->_data, $this->_pos);

        }

        while ($nextIdentifier == self :: XLS_Type_CONTINUE);

        

        $splicedData = array('recordData' => $data, 'spliceOffsets' => $spliceOffsets);

        

        return $splicedData;

    

    }



    /**

     * Convert formula structure into human readable Excel formula like 'A3+A5*5'

     *

     * @param string $formulaStructure The complete binary data for the formula

     * @param string $baseCell Base cell, only needed when formula contains tRefN tokens, e.g. with shared formulas

     * @return string Human readable formula

     */

    private function _getFormulaFromStructure($formulaStructure, $baseCell = 'A1')

    {

        // offset: 0; size: 2; size of the following formula data

        $sz = self :: _GetInt2d($formulaStructure, 0);

        

        // offset: 2; size: sz

        $formulaData = substr($formulaStructure, 2, $sz);

        

        // for debug: dump the formula data

        //echo '<xmp>';

        //echo 'size: ' . $sz . "\n";

        //echo 'the entire formula data: ';

        //Debug::dump($formulaData);

        //echo "\n----\n";

        



        // offset: 2 + sz; size: variable (optional)

        if (strlen($formulaStructure) > 2 + $sz)

        {

            $additionalData = substr($formulaStructure, 2 + $sz);

        

     // for debug: dump the additional data

        //echo 'the entire additional data: ';

        //Debug::dump($additionalData);

        //echo "\n----\n";

        



        }

        else

        {

            $additionalData = '';

        }

        

        return $this->_getFormulaFromData($formulaData, $additionalData, $baseCell);

    }



    /**

     * Take formula data and additional data for formula and return human readable formula

     *

     * @param string $formulaData The binary data for the formula itself

     * @param string $additionalData Additional binary data going with the formula

     * @param string $baseCell Base cell, only needed when formula contains tRefN tokens, e.g. with shared formulas

     * @return string Human readable formula

     */

    private function _getFormulaFromData($formulaData, $additionalData = '', $baseCell = 'A1')

    {

        // start parsing the formula data

        $tokens = array();

        

        while (strlen($formulaData) > 0 and $token = $this->_getNextToken($formulaData, $baseCell))

        {

            $tokens[] = $token;

            $formulaData = substr($formulaData, $token['size']);

        

     // for debug: dump the token

        //var_dump($token);

        }

        

        $formulaString = $this->_createFormulaFromTokens($tokens, $additionalData);

        

        return $formulaString;

    }



    /**

     * Take array of tokens together with additional data for formula and return human readable formula

     *

     * @param array $tokens

     * @param array $additionalData Additional binary data going with the formula

     * @param string $baseCell Base cell, only needed when formula contains tRefN tokens, e.g. with shared formulas

     * @return string Human readable formula

     */

    private function _createFormulaFromTokens($tokens, $additionalData)

    {

        // empty formula?

        if (count($tokens) == 0)

        {

            return '';

        }

        

        $formulaStrings = array();

        foreach ($tokens as $token)

        {

            // initialize spaces

            $space0 = isset($space0) ? $space0 : ''; // spaces before next token, not tParen

            $space1 = isset($space1) ? $space1 : ''; // carriage returns before next token, not tParen

            $space2 = isset($space2) ? $space2 : ''; // spaces before opening parenthesis

            $space3 = isset($space3) ? $space3 : ''; // carriage returns before opening parenthesis

            $space4 = isset($space4) ? $space4 : ''; // spaces before closing parenthesis

            $space5 = isset($space5) ? $space5 : ''; // carriage returns before closing parenthesis

            



            switch ($token['name'])

            {

                case 'tAdd' : // addition

                case 'tConcat' : // addition

                case 'tDiv' : // division

                case 'tEQ' : // equality

                case 'tGE' : // greater than or equal

                case 'tGT' : // greater than

                case 'tIsect' : // intersection

                case 'tLE' : // less than or equal

                case 'tList' : // less than or equal

                case 'tLT' : // less than

                case 'tMul' : // multiplication

                case 'tNE' : // multiplication

                case 'tPower' : // power

                case 'tRange' : // range

                case 'tSub' : // subtraction

                    $op2 = array_pop($formulaStrings);

                    $op1 = array_pop($formulaStrings);

                    $formulaStrings[] = "$op1$space1$space0{$token['data']}$op2";

                    unset($space0, $space1);

                    break;

                case 'tUplus' : // unary plus

                case 'tUminus' : // unary minus

                    $op = array_pop($formulaStrings);

                    $formulaStrings[] = "$space1$space0{$token['data']}$op";

                    unset($space0, $space1);

                    break;

                case 'tPercent' : // percent sign

                    $op = array_pop($formulaStrings);

                    $formulaStrings[] = "$op$space1$space0{$token['data']}";

                    unset($space0, $space1);

                    break;

                case 'tAttrVolatile' : // indicates volatile function

                case 'tAttrIf' :

                case 'tAttrSkip' :

                case 'tAttrChoose' :

                    // token is only important for Excel formula evaluator

                    // do nothing

                    break;

                case 'tAttrSpace' : // space / carriage return

                    // space will be used when next token arrives, do not alter formulaString stack

                    switch ($token['data']['spacetype'])

                    {

                        case 'type0' :

                            $space0 = str_repeat(' ', $token['data']['spacecount']);

                            break;

                        case 'type1' :

                            $space1 = str_repeat("\n", $token['data']['spacecount']);

                            break;

                        case 'type2' :

                            $space2 = str_repeat(' ', $token['data']['spacecount']);

                            break;

                        case 'type3' :

                            $space3 = str_repeat("\n", $token['data']['spacecount']);

                            break;

                        case 'type4' :

                            $space4 = str_repeat(' ', $token['data']['spacecount']);

                            break;

                        case 'type5' :

                            $space5 = str_repeat("\n", $token['data']['spacecount']);

                            break;

                    }

                    break;

                case 'tAttrSum' : // SUM function with one parameter

                    $op = array_pop($formulaStrings);

                    $formulaStrings[] = "{$space1}{$space0}SUM($op)";

                    unset($space0, $space1);

                    break;

                case 'tFunc' : // function with fixed number of arguments

                case 'tFuncV' : // function with variable number of arguments

                    if ($token['data']['function'] != '')

                    {

                        // normal function

                        $ops = array(); // array of operators

                        for($i = 0; $i < $token['data']['args']; ++ $i)

                        {

                            $ops[] = array_pop($formulaStrings);

                        }

                        $ops = array_reverse($ops);

                        $formulaStrings[] = "$space1$space0{$token['data']['function']}(" . implode(',', $ops) . ")";

                        unset($space0, $space1);

                    }

                    else

                    {

                        // add-in function

                        $ops = array(); // array of operators

                        for($i = 0; $i < $token['data']['args'] - 1; ++ $i)

                        {

                            $ops[] = array_pop($formulaStrings);

                        }

                        $ops = array_reverse($ops);

                        $function = array_pop($formulaStrings);

                        $formulaStrings[] = "$space1$space0$function(" . implode(',', $ops) . ")";

                        unset($space0, $space1);

                    }

                    break;

                case 'tParen' : // parenthesis

                    $expression = array_pop($formulaStrings);

                    $formulaStrings[] = "$space3$space2($expression$space5$space4)";

                    unset($space2, $space3, $space4, $space5);

                    break;

                case 'tArray' : // array constant

                    $constantArray = self :: _readBIFF8ConstantArray($additionalData);

                    $formulaStrings[] = $space1 . $space0 . $constantArray['value'];

                    $additionalData = substr($additionalData, $constantArray['size']); // bite of chunk of additional data

                    unset($space0, $space1);

                    break;

                case 'tMemArea' :

                    // bite off chunk of additional data

                    $cellRangeAddressList = $this->_readBIFF8CellRangeAddressList($additionalData);

                    $additionalData = substr($additionalData, $cellRangeAddressList['size']);

                    $formulaStrings[] = "$space1$space0{$token['data']}";

                    unset($space0, $space1);

                    break;

                case 'tArea' : // cell range address

                case 'tBool' : // boolean

                case 'tErr' : // error code

                case 'tInt' : // integer

                case 'tMemErr' :

                case 'tMemFunc' :

                case 'tMissArg' :

                case 'tName' :

                case 'tNameX' :

                case 'tNum' : // number

                case 'tRef' : // single cell reference

                case 'tRef3d' : // 3d cell reference

                case 'tArea3d' : // 3d cell range reference

                case 'tRefN' :

                case 'tAreaN' :

                case 'tStr' : // string

                    $formulaStrings[] = "$space1$space0{$token['data']}";

                    unset($space0, $space1);

                    break;

            }

        }

        $formulaString = $formulaStrings[0];

        

        // for debug: dump the human readable formula

        //echo '----' . "\n";

        //echo 'Formula: ' . $formulaString;

        



        return $formulaString;

    }



    /**

     * Fetch next token from binary formula data

     *

     * @param string Formula data

     * @param string $baseCell Base cell, only needed when formula contains tRefN tokens, e.g. with shared formulas

     * @return array

     * @throws Exception

     */

    private function _getNextToken($formulaData, $baseCell = 'A1')

    {

        // offset: 0; size: 1; token id

        $id = ord($formulaData[0]); // token id

        $name = false; // initialize token name

        



        switch ($id)

        {

            case 0x03 :

                $name = 'tAdd';

                $size = 1;

                $data = '+';

                break;

            case 0x04 :

                $name = 'tSub';

                $size = 1;

                $data = '-';

                break;

            case 0x05 :

                $name = 'tMul';

                $size = 1;

                $data = '*';

                break;

            case 0x06 :

                $name = 'tDiv';

                $size = 1;

                $data = '/';

                break;

            case 0x07 :

                $name = 'tPower';

                $size = 1;

                $data = '^';

                break;

            case 0x08 :

                $name = 'tConcat';

                $size = 1;

                $data = '&';

                break;

            case 0x09 :

                $name = 'tLT';

                $size = 1;

                $data = '<';

                break;

            case 0x0A :

                $name = 'tLE';

                $size = 1;

                $data = '<=';

                break;

            case 0x0B :

                $name = 'tEQ';

                $size = 1;

                $data = '=';

                break;

            case 0x0C :

                $name = 'tGE';

                $size = 1;

                $data = '>=';

                break;

            case 0x0D :

                $name = 'tGT';

                $size = 1;

                $data = '>';

                break;

            case 0x0E :

                $name = 'tNE';

                $size = 1;

                $data = '<>';

                break;

            case 0x0F :

                $name = 'tIsect';

                $size = 1;

                $data = ' ';

                break;

            case 0x10 :

                $name = 'tList';

                $size = 1;

                $data = ',';

                break;

            case 0x11 :

                $name = 'tRange';

                $size = 1;

                $data = ':';

                break;

            case 0x12 :

                $name = 'tUplus';

                $size = 1;

                $data = '+';

                break;

            case 0x13 :

                $name = 'tUminus';

                $size = 1;

                $data = '-';

                break;

            case 0x14 :

                $name = 'tPercent';

                $size = 1;

                $data = '%';

                break;

            case 0x15 : //	parenthesis

                $name = 'tParen';

                $size = 1;

                $data = null;

                break;

            case 0x16 : //	missing argument

                $name = 'tMissArg';

                $size = 1;

                $data = '';

                break;

            case 0x17 : //	string

                $name = 'tStr';

                // offset: 1; size: var; Unicode string, 8-bit string length

                $string = self :: _readUnicodeStringShort(substr($formulaData, 1));

                $size = 1 + $string['size'];

                $data = self :: _UTF8toExcelDoubleQuoted($string['value']);

                break;

            case 0x19 : //	Special attribute

                // offset: 1; size: 1; attribute type flags:

                switch (ord($formulaData[1]))

                {

                    case 0x01 :

                        $name = 'tAttrVolatile';

                        $size = 4;

                        $data = null;

                        break;

                    case 0x02 :

                        $name = 'tAttrIf';

                        $size = 4;

                        $data = null;

                        break;

                    case 0x04 :

                        $name = 'tAttrChoose';

                        // offset: 2; size: 2; number of choices in the CHOOSE function ($nc, number of parameters decreased by 1)

                        $nc = self :: _GetInt2d($formulaData, 2);

                        // offset: 4; size: 2 * $nc

                        // offset: 4 + 2 * $nc; size: 2

                        $size = 2 * $nc + 6;

                        $data = null;

                        break;

                    case 0x08 :

                        $name = 'tAttrSkip';

                        $size = 4;

                        $data = null;

                        break;

                    case 0x10 :

                        $name = 'tAttrSum';

                        $size = 4;

                        $data = null;

                        break;

                    case 0x40 :

                    case 0x41 :

                        $name = 'tAttrSpace';

                        $size = 4;

                        // offset: 2; size: 2; space type and position

                        switch (ord($formulaData[2]))

                        {

                            case 0x00 :

                                $spacetype = 'type0';

                                break;

                            case 0x01 :

                                $spacetype = 'type1';

                                break;

                            case 0x02 :

                                $spacetype = 'type2';

                                break;

                            case 0x03 :

                                $spacetype = 'type3';

                                break;

                            case 0x04 :

                                $spacetype = 'type4';

                                break;

                            case 0x05 :

                                $spacetype = 'type5';

                                break;

                            default :

                                throw new Exception('Unrecognized space type in tAttrSpace token');

                                break;

                        }

                        // offset: 3; size: 1; number of inserted spaces/carriage returns

                        $spacecount = ord($formulaData[3]);

                        

                        $data = array('spacetype' => $spacetype, 'spacecount' => $spacecount);

                        break;

                    default :

                        throw new Exception('Unrecognized attribute flag in tAttr token');

                        break;

                }

                break;

            case 0x1C : //	error code

                // offset: 1; size: 1; error code

                $name = 'tErr';

                $size = 2;

                $data = self :: _mapErrorCode(ord($formulaData[1]));

                break;

            case 0x1D : //	boolean

                // offset: 1; size: 1; 0 = false, 1 = true;

                $name = 'tBool';

                $size = 2;

                $data = ord($formulaData[1]) ? 'TRUE' : 'FALSE';

                break;

            case 0x1E : //	integer

                // offset: 1; size: 2; unsigned 16-bit integer

                $name = 'tInt';

                $size = 3;

                $data = self :: _GetInt2d($formulaData, 1);

                break;

            case 0x1F : //	number

                // offset: 1; size: 8;

                $name = 'tNum';

                $size = 9;

                $data = self :: _extractNumber(substr($formulaData, 1));

                $data = str_replace(',', '.', (string) $data); // in case non-English locale

                break;

            case 0x20 : //	array constant

            case 0x40 :

            case 0x60 :

                // offset: 1; size: 7; not used

                $name = 'tArray';

                $size = 8;

                $data = null;

                break;

            case 0x21 : //	function with fixed number of arguments

            case 0x41 :

            case 0x61 :

                $name = 'tFunc';

                $size = 3;

                // offset: 1; size: 2; index to built-in sheet function

                switch (self :: _GetInt2d($formulaData, 1))

                {

                    case 2 :

                        $function = 'ISNA';

                        $args = 1;

                        break;

                    case 3 :

                        $function = 'ISERROR';

                        $args = 1;

                        break;

                    case 10 :

                        $function = 'NA';

                        $args = 0;

                        break;

                    case 15 :

                        $function = 'SIN';

                        $args = 1;

                        break;

                    case 16 :

                        $function = 'COS';

                        $args = 1;

                        break;

                    case 17 :

                        $function = 'TAN';

                        $args = 1;

                        break;

                    case 18 :

                        $function = 'ATAN';

                        $args = 1;

                        break;

                    case 19 :

                        $function = 'PI';

                        $args = 0;

                        break;

                    case 20 :

                        $function = 'SQRT';

                        $args = 1;

                        break;

                    case 21 :

                        $function = 'EXP';

                        $args = 1;

                        break;

                    case 22 :

                        $function = 'LN';

                        $args = 1;

                        break;

                    case 23 :

                        $function = 'LOG10';

                        $args = 1;

                        break;

                    case 24 :

                        $function = 'ABS';

                        $args = 1;

                        break;

                    case 25 :

                        $function = 'INT';

                        $args = 1;

                        break;

                    case 26 :

                        $function = 'SIGN';

                        $args = 1;

                        break;

                    case 27 :

                        $function = 'ROUND';

                        $args = 2;

                        break;

                    case 30 :

                        $function = 'REPT';

                        $args = 2;

                        break;

                    case 31 :

                        $function = 'MID';

                        $args = 3;

                        break;

                    case 32 :

                        $function = 'LEN';

                        $args = 1;

                        break;

                    case 33 :

                        $function = 'VALUE';

                        $args = 1;

                        break;

                    case 34 :

                        $function = 'TRUE';

                        $args = 0;

                        break;

                    case 35 :

                        $function = 'FALSE';

                        $args = 0;

                        break;

                    case 38 :

                        $function = 'NOT';

                        $args = 1;

                        break;

                    case 39 :

                        $function = 'MOD';

                        $args = 2;

                        break;

                    case 40 :

                        $function = 'DCOUNT';

                        $args = 3;

                        break;

                    case 41 :

                        $function = 'DSUM';

                        $args = 3;

                        break;

                    case 42 :

                        $function = 'DAVERAGE';

                        $args = 3;

                        break;

                    case 43 :

                        $function = 'DMIN';

                        $args = 3;

                        break;

                    case 44 :

                        $function = 'DMAX';

                        $args = 3;

                        break;

                    case 45 :

                        $function = 'DSTDEV';

                        $args = 3;

                        break;

                    case 48 :

                        $function = 'TEXT';

                        $args = 2;

                        break;

                    case 61 :

                        $function = 'MIRR';

                        $args = 3;

                        break;

                    case 63 :

                        $function = 'RAND';

                        $args = 0;

                        break;

                    case 65 :

                        $function = 'DATE';

                        $args = 3;

                        break;

                    case 66 :

                        $function = 'TIME';

                        $args = 3;

                        break;

                    case 67 :

                        $function = 'DAY';

                        $args = 1;

                        break;

                    case 68 :

                        $function = 'MONTH';

                        $args = 1;

                        break;

                    case 69 :

                        $function = 'YEAR';

                        $args = 1;

                        break;

                    case 71 :

                        $function = 'HOUR';

                        $args = 1;

                        break;

                    case 72 :

                        $function = 'MINUTE';

                        $args = 1;

                        break;

                    case 73 :

                        $function = 'SECOND';

                        $args = 1;

                        break;

                    case 74 :

                        $function = 'NOW';

                        $args = 0;

                        break;

                    case 75 :

                        $function = 'AREAS';

                        $args = 1;

                        break;

                    case 76 :

                        $function = 'ROWS';

                        $args = 1;

                        break;

                    case 77 :

                        $function = 'COLUMNS';

                        $args = 1;

                        break;

                    case 83 :

                        $function = 'TRANSPOSE';

                        $args = 1;

                        break;

                    case 86 :

                        $function = 'TYPE';

                        $args = 1;

                        break;

                    case 97 :

                        $function = 'ATAN2';

                        $args = 2;

                        break;

                    case 98 :

                        $function = 'ASIN';

                        $args = 1;

                        break;

                    case 99 :

                        $function = 'ACOS';

                        $args = 1;

                        break;

                    case 105 :

                        $function = 'ISREF';

                        $args = 1;

                        break;

                    case 111 :

                        $function = 'CHAR';

                        $args = 1;

                        break;

                    case 112 :

                        $function = 'LOWER';

                        $args = 1;

                        break;

                    case 113 :

                        $function = 'UPPER';

                        $args = 1;

                        break;

                    case 114 :

                        $function = 'PROPER';

                        $args = 1;

                        break;

                    case 117 :

                        $function = 'EXACT';

                        $args = 2;

                        break;

                    case 118 :

                        $function = 'TRIM';

                        $args = 1;

                        break;

                    case 119 :

                        $function = 'REPLACE';

                        $args = 4;

                        break;

                    case 121 :

                        $function = 'CODE';

                        $args = 1;

                        break;

                    case 126 :

                        $function = 'ISERR';

                        $args = 1;

                        break;

                    case 127 :

                        $function = 'ISTEXT';

                        $args = 1;

                        break;

                    case 128 :

                        $function = 'ISNUMBER';

                        $args = 1;

                        break;

                    case 129 :

                        $function = 'ISBLANK';

                        $args = 1;

                        break;

                    case 130 :

                        $function = 'T';

                        $args = 1;

                        break;

                    case 131 :

                        $function = 'N';

                        $args = 1;

                        break;

                    case 140 :

                        $function = 'DATEVALUE';

                        $args = 1;

                        break;

                    case 141 :

                        $function = 'TIMEVALUE';

                        $args = 1;

                        break;

                    case 142 :

                        $function = 'SLN';

                        $args = 3;

                        break;

                    case 143 :

                        $function = 'SYD';

                        $args = 4;

                        break;

                    case 162 :

                        $function = 'CLEAN';

                        $args = 1;

                        break;

                    case 163 :

                        $function = 'MDETERM';

                        $args = 1;

                        break;

                    case 164 :

                        $function = 'MINVERSE';

                        $args = 1;

                        break;

                    case 165 :

                        $function = 'MMULT';

                        $args = 2;

                        break;

                    case 184 :

                        $function = 'FACT';

                        $args = 1;

                        break;

                    case 189 :

                        $function = 'DPRODUCT';

                        $args = 3;

                        break;

                    case 190 :

                        $function = 'ISNONTEXT';

                        $args = 1;

                        break;

                    case 195 :

                        $function = 'DSTDEVP';

                        $args = 3;

                        break;

                    case 196 :

                        $function = 'DVARP';

                        $args = 3;

                        break;

                    case 198 :

                        $function = 'ISLOGICAL';

                        $args = 1;

                        break;

                    case 199 :

                        $function = 'DCOUNTA';

                        $args = 3;

                        break;

                    case 207 :

                        $function = 'REPLACEB';

                        $args = 4;

                        break;

                    case 210 :

                        $function = 'MIDB';

                        $args = 3;

                        break;

                    case 211 :

                        $function = 'LENB';

                        $args = 1;

                        break;

                    case 212 :

                        $function = 'ROUNDUP';

                        $args = 2;

                        break;

                    case 213 :

                        $function = 'ROUNDDOWN';

                        $args = 2;

                        break;

                    case 214 :

                        $function = 'ASC';

                        $args = 1;

                        break;

                    case 215 :

                        $function = 'DBCS';

                        $args = 1;

                        break;

                    case 221 :

                        $function = 'TODAY';

                        $args = 0;

                        break;

                    case 229 :

                        $function = 'SINH';

                        $args = 1;

                        break;

                    case 230 :

                        $function = 'COSH';

                        $args = 1;

                        break;

                    case 231 :

                        $function = 'TANH';

                        $args = 1;

                        break;

                    case 232 :

                        $function = 'ASINH';

                        $args = 1;

                        break;

                    case 233 :

                        $function = 'ACOSH';

                        $args = 1;

                        break;

                    case 234 :

                        $function = 'ATANH';

                        $args = 1;

                        break;

                    case 235 :

                        $function = 'DGET';

                        $args = 3;

                        break;

                    case 244 :

                        $function = 'INFO';

                        $args = 1;

                        break;

                    case 252 :

                        $function = 'FREQUENCY';

                        $args = 2;

                        break;

                    case 261 :

                        $function = 'ERROR.TYPE';

                        $args = 1;

                        break;

                    case 271 :

                        $function = 'GAMMALN';

                        $args = 1;

                        break;

                    case 273 :

                        $function = 'BINOMDIST';

                        $args = 4;

                        break;

                    case 274 :

                        $function = 'CHIDIST';

                        $args = 2;

                        break;

                    case 275 :

                        $function = 'CHIINV';

                        $args = 2;

                        break;

                    case 276 :

                        $function = 'COMBIN';

                        $args = 2;

                        break;

                    case 277 :

                        $function = 'CONFIDENCE';

                        $args = 3;

                        break;

                    case 278 :

                        $function = 'CRITBINOM';

                        $args = 3;

                        break;

                    case 279 :

                        $function = 'EVEN';

                        $args = 1;

                        break;

                    case 280 :

                        $function = 'EXPONDIST';

                        $args = 3;

                        break;

                    case 281 :

                        $function = 'FDIST';

                        $args = 3;

                        break;

                    case 282 :

                        $function = 'FINV';

                        $args = 3;

                        break;

                    case 283 :

                        $function = 'FISHER';

                        $args = 1;

                        break;

                    case 284 :

                        $function = 'FISHERINV';

                        $args = 1;

                        break;

                    case 285 :

                        $function = 'FLOOR';

                        $args = 2;

                        break;

                    case 286 :

                        $function = 'GAMMADIST';

                        $args = 4;

                        break;

                    case 287 :

                        $function = 'GAMMAINV';

                        $args = 3;

                        break;

                    case 288 :

                        $function = 'CEILING';

                        $args = 2;

                        break;

                    case 289 :

                        $function = 'HYPGEOMDIST';

                        $args = 4;

                        break;

                    case 290 :

                        $function = 'LOGNORMDIST';

                        $args = 3;

                        break;

                    case 291 :

                        $function = 'LOGINV';

                        $args = 3;

                        break;

                    case 292 :

                        $function = 'NEGBINOMDIST';

                        $args = 3;

                        break;

                    case 293 :

                        $function = 'NORMDIST';

                        $args = 4;

                        break;

                    case 294 :

                        $function = 'NORMSDIST';

                        $args = 1;

                        break;

                    case 295 :

                        $function = 'NORMINV';

                        $args = 3;

                        break;

                    case 296 :

                        $function = 'NORMSINV';

                        $args = 1;

                        break;

                    case 297 :

                        $function = 'STANDARDIZE';

                        $args = 3;

                        break;

                    case 298 :

                        $function = 'ODD';

                        $args = 1;

                        break;

                    case 299 :

                        $function = 'PERMUT';

                        $args = 2;

                        break;

                    case 300 :

                        $function = 'POISSON';

                        $args = 3;

                        break;

                    case 301 :

                        $function = 'TDIST';

                        $args = 3;

                        break;

                    case 302 :

                        $function = 'WEIBULL';

                        $args = 4;

                        break;

                    case 303 :

                        $function = 'SUMXMY2';

                        $args = 2;

                        break;

                    case 304 :

                        $function = 'SUMX2MY2';

                        $args = 2;

                        break;

                    case 305 :

                        $function = 'SUMX2PY2';

                        $args = 2;

                        break;

                    case 306 :

                        $function = 'CHITEST';

                        $args = 2;

                        break;

                    case 307 :

                        $function = 'CORREL';

                        $args = 2;

                        break;

                    case 308 :

                        $function = 'COVAR';

                        $args = 2;

                        break;

                    case 309 :

                        $function = 'FORECAST';

                        $args = 3;

                        break;

                    case 310 :

                        $function = 'FTEST';

                        $args = 2;

                        break;

                    case 311 :

                        $function = 'INTERCEPT';

                        $args = 2;

                        break;

                    case 312 :

                        $function = 'PEARSON';

                        $args = 2;

                        break;

                    case 313 :

                        $function = 'RSQ';

                        $args = 2;

                        break;

                    case 314 :

                        $function = 'STEYX';

                        $args = 2;

                        break;

                    case 315 :

                        $function = 'SLOPE';

                        $args = 2;

                        break;

                    case 316 :

                        $function = 'TTEST';

                        $args = 4;

                        break;

                    case 325 :

                        $function = 'LARGE';

                        $args = 2;

                        break;

                    case 326 :

                        $function = 'SMALL';

                        $args = 2;

                        break;

                    case 327 :

                        $function = 'QUARTILE';

                        $args = 2;

                        break;

                    case 328 :

                        $function = 'PERCENTILE';

                        $args = 2;

                        break;

                    case 331 :

                        $function = 'TRIMMEAN';

                        $args = 2;

                        break;

                    case 332 :

                        $function = 'TINV';

                        $args = 2;

                        break;

                    case 337 :

                        $function = 'POWER';

                        $args = 2;

                        break;

                    case 342 :

                        $function = 'RADIANS';

                        $args = 1;

                        break;

                    case 343 :

                        $function = 'DEGREES';

                        $args = 1;

                        break;

                    case 346 :

                        $function = 'COUNTIF';

                        $args = 2;

                        break;

                    case 347 :

                        $function = 'COUNTBLANK';

                        $args = 1;

                        break;

                    case 350 :

                        $function = 'ISPMT';

                        $args = 4;

                        break;

                    case 351 :

                        $function = 'DATEDIF';

                        $args = 3;

                        break;

                    case 352 :

                        $function = 'DATESTRING';

                        $args = 1;

                        break;

                    case 353 :

                        $function = 'NUMBERSTRING';

                        $args = 2;

                        break;

                    case 360 :

                        $function = 'PHONETIC';

                        $args = 1;

                        break;

                    case 368 :

                        $function = 'BAHTTEXT';

                        $args = 1;

                        break;

                    default :

                        throw new Exception('Unrecognized function in formula');

                        break;

                }

                $data = array('function' => $function, 'args' => $args);

                break;

            case 0x22 : //	function with variable number of arguments

            case 0x42 :

            case 0x62 :

                $name = 'tFuncV';

                $size = 4;

                // offset: 1; size: 1; number of arguments

                $args = ord($formulaData[1]);

                // offset: 2: size: 2; index to built-in sheet function

                $index = self :: _GetInt2d($formulaData, 2);

                switch ($index)

                {

                    case 0 :

                        $function = 'COUNT';

                        break;

                    case 1 :

                        $function = 'IF';

                        break;

                    case 4 :

                        $function = 'SUM';

                        break;

                    case 5 :

                        $function = 'AVERAGE';

                        break;

                    case 6 :

                        $function = 'MIN';

                        break;

                    case 7 :

                        $function = 'MAX';

                        break;

                    case 8 :

                        $function = 'ROW';

                        break;

                    case 9 :

                        $function = 'COLUMN';

                        break;

                    case 11 :

                        $function = 'NPV';

                        break;

                    case 12 :

                        $function = 'STDEV';

                        break;

                    case 13 :

                        $function = 'DOLLAR';

                        break;

                    case 14 :

                        $function = 'FIXED';

                        break;

                    case 28 :

                        $function = 'LOOKUP';

                        break;

                    case 29 :

                        $function = 'INDEX';

                        break;

                    case 36 :

                        $function = 'AND';

                        break;

                    case 37 :

                        $function = 'OR';

                        break;

                    case 46 :

                        $function = 'VAR';

                        break;

                    case 49 :

                        $function = 'LINEST';

                        break;

                    case 50 :

                        $function = 'TREND';

                        break;

                    case 51 :

                        $function = 'LOGEST';

                        break;

                    case 52 :

                        $function = 'GROWTH';

                        break;

                    case 56 :

                        $function = 'PV';

                        break;

                    case 57 :

                        $function = 'FV';

                        break;

                    case 58 :

                        $function = 'NPER';

                        break;

                    case 59 :

                        $function = 'PMT';

                        break;

                    case 60 :

                        $function = 'RATE';

                        break;

                    case 62 :

                        $function = 'IRR';

                        break;

                    case 64 :

                        $function = 'MATCH';

                        break;

                    case 70 :

                        $function = 'WEEKDAY';

                        break;

                    case 78 :

                        $function = 'OFFSET';

                        break;

                    case 82 :

                        $function = 'SEARCH';

                        break;

                    case 100 :

                        $function = 'CHOOSE';

                        break;

                    case 101 :

                        $function = 'HLOOKUP';

                        break;

                    case 102 :

                        $function = 'VLOOKUP';

                        break;

                    case 109 :

                        $function = 'LOG';

                        break;

                    case 115 :

                        $function = 'LEFT';

                        break;

                    case 116 :

                        $function = 'RIGHT';

                        break;

                    case 120 :

                        $function = 'SUBSTITUTE';

                        break;

                    case 124 :

                        $function = 'FIND';

                        break;

                    case 125 :

                        $function = 'CELL';

                        break;

                    case 144 :

                        $function = 'DDB';

                        break;

                    case 148 :

                        $function = 'INDIRECT';

                        break;

                    case 167 :

                        $function = 'IPMT';

                        break;

                    case 168 :

                        $function = 'PPMT';

                        break;

                    case 169 :

                        $function = 'COUNTA';

                        break;

                    case 183 :

                        $function = 'PRODUCT';

                        break;

                    case 193 :

                        $function = 'STDEVP';

                        break;

                    case 194 :

                        $function = 'VARP';

                        break;

                    case 197 :

                        $function = 'TRUNC';

                        break;

                    case 204 :

                        $function = 'USDOLLAR';

                        break;

                    case 205 :

                        $function = 'FINDB';

                        break;

                    case 206 :

                        $function = 'SEARCHB';

                        break;

                    case 208 :

                        $function = 'LEFTB';

                        break;

                    case 209 :

                        $function = 'RIGHTB';

                        break;

                    case 216 :

                        $function = 'RANK';

                        break;

                    case 219 :

                        $function = 'ADDRESS';

                        break;

                    case 220 :

                        $function = 'DAYS360';

                        break;

                    case 222 :

                        $function = 'VDB';

                        break;

                    case 227 :

                        $function = 'MEDIAN';

                        break;

                    case 228 :

                        $function = 'SUMPRODUCT';

                        break;

                    case 247 :

                        $function = 'DB';

                        break;

                    case 255 :

                        $function = '';

                        break;

                    case 269 :

                        $function = 'AVEDEV';

                        break;

                    case 270 :

                        $function = 'BETADIST';

                        break;

                    case 272 :

                        $function = 'BETAINV';

                        break;

                    case 317 :

                        $function = 'PROB';

                        break;

                    case 318 :

                        $function = 'DEVSQ';

                        break;

                    case 319 :

                        $function = 'GEOMEAN';

                        break;

                    case 320 :

                        $function = 'HARMEAN';

                        break;

                    case 321 :

                        $function = 'SUMSQ';

                        break;

                    case 322 :

                        $function = 'KURT';

                        break;

                    case 323 :

                        $function = 'SKEW';

                        break;

                    case 324 :

                        $function = 'ZTEST';

                        break;

                    case 329 :

                        $function = 'PERCENTRANK';

                        break;

                    case 330 :

                        $function = 'MODE';

                        break;

                    case 336 :

                        $function = 'CONCATENATE';

                        break;

                    case 344 :

                        $function = 'SUBTOTAL';

                        break;

                    case 345 :

                        $function = 'SUMIF';

                        break;

                    case 354 :

                        $function = 'ROMAN';

                        break;

                    case 358 :

                        $function = 'GETPIVOTDATA';

                        break;

                    case 359 :

                        $function = 'HYPERLINK';

                        break;

                    case 361 :

                        $function = 'AVERAGEA';

                        break;

                    case 362 :

                        $function = 'MAXA';

                        break;

                    case 363 :

                        $function = 'MINA';

                        break;

                    case 364 :

                        $function = 'STDEVPA';

                        break;

                    case 365 :

                        $function = 'VARPA';

                        break;

                    case 366 :

                        $function = 'STDEVA';

                        break;

                    case 367 :

                        $function = 'VARA';

                        break;

                    default :

                        throw new Exception('Unrecognized function in formula');

                        break;

                }

                $data = array('function' => $function, 'args' => $args);

                break;

            case 0x23 : //	index to defined name

            case 0x43 :

            case 0x63 :

                $name = 'tName';

                $size = 5;

                // offset: 1; size: 2; one-based index to definedname record

                $definedNameIndex = self :: _GetInt2d($formulaData, 1) - 1;

                // offset: 2; size: 2; not used

                $data = $this->_definedname[$definedNameIndex]['name'];

                break;

            case 0x24 : //	single cell reference e.g. A5

            case 0x44 :

            case 0x64 :

                $name = 'tRef';

                $size = 5;

                $data = $this->_readBIFF8CellAddress(substr($formulaData, 1, 4));

                break;

            case 0x25 : //	cell range reference to cells in the same sheet (2d)

            case 0x45 :

            case 0x65 :

                $name = 'tArea';

                $size = 9;

                $data = $this->_readBIFF8CellRangeAddress(substr($formulaData, 1, 8));

                break;

            case 0x26 : //	Constant reference sub-expression

            case 0x46 :

            case 0x66 :

                $name = 'tMemArea';

                // offset: 1; size: 4; not used

                // offset: 5; size: 2; size of the following subexpression

                $subSize = self :: _GetInt2d($formulaData, 5);

                $size = 7 + $subSize;

                $data = $this->_getFormulaFromData(substr($formulaData, 7, $subSize));

                break;

            case 0x27 : //	Deleted constant reference sub-expression

            case 0x47 :

            case 0x67 :

                $name = 'tMemErr';

                // offset: 1; size: 4; not used

                // offset: 5; size: 2; size of the following subexpression

                $subSize = self :: _GetInt2d($formulaData, 5);

                $size = 7 + $subSize;

                $data = $this->_getFormulaFromData(substr($formulaData, 7, $subSize));

                break;

            case 0x29 : //	Variable reference sub-expression

            case 0x49 :

            case 0x69 :

                $name = 'tMemFunc';

                // offset: 1; size: 2; size of the following sub-expression

                $subSize = self :: _GetInt2d($formulaData, 1);

                $size = 3 + $subSize;

                $data = $this->_getFormulaFromData(substr($formulaData, 3, $subSize));

                break;

            

            case 0x2C : // Relative 2d cell reference reference, used in shared formulas and some other places

            case 0x4C :

            case 0x6C :

                $name = 'tRefN';

                $size = 5;

                $data = $this->_readBIFF8CellAddressB(substr($formulaData, 1, 4), $baseCell);

                break;

            

            case 0x2D : //	Relative 2d range reference

            case 0x4D :

            case 0x6D :

                $name = 'tAreaN';

                $size = 9;

                $data = $this->_readBIFF8CellRangeAddressB(substr($formulaData, 1, 8), $baseCell);

                break;

            

            case 0x39 : //	External name

            case 0x59 :

            case 0x79 :

                $name = 'tNameX';

                $size = 7;

                // offset: 1; size: 2; index to REF entry in EXTERNSHEET record

                // offset: 3; size: 2; one-based index to DEFINEDNAME or EXTERNNAME record

                $index = self :: _GetInt2d($formulaData, 3);

                // assume index is to EXTERNNAME record

                $data = $this->_externalNames[$index - 1]['name'];

                // offset: 5; size: 2; not used

                break;

            

            case 0x3A : //	3d reference to cell

            case 0x5A :

            case 0x7A :

                $name = 'tRef3d';

                $size = 7;

                

                try

                {

                    // offset: 1; size: 2; index to REF entry

                    $sheetRange = $this->_readSheetRangeByRefIndex(self :: _GetInt2d($formulaData, 1));

                    // offset: 3; size: 4; cell address

                    $cellAddress = $this->_readBIFF8CellAddress(substr($formulaData, 3, 4));

                    

                    $data = "$sheetRange!$cellAddress";

                }

                catch (Exception $e)

                {

                    // deleted sheet reference

                    $data = '#REF!';

                }

                

                break;

            case 0x3B : //	3d reference to cell range

            case 0x5B :

            case 0x7B :

                $name = 'tArea3d';

                $size = 11;

                

                try

                {

                    // offset: 1; size: 2; index to REF entry

                    $sheetRange = $this->_readSheetRangeByRefIndex(self :: _GetInt2d($formulaData, 1));

                    // offset: 3; size: 8; cell address

                    $cellRangeAddress = $this->_readBIFF8CellRangeAddress(substr($formulaData, 3, 8));

                    

                    $data = "$sheetRange!$cellRangeAddress";

                }

                catch (Exception $e)

                {

                    // deleted sheet reference

                    $data = '#REF!';

                }

                

                break;

            // Unknown cases	// don't know how to deal with

            default :

                throw new Exception('Unrecognized token ' . sprintf('%02X', $id) . ' in formula');

                break;

        }

        

        return array('id' => $id, 'name' => $name, 'size' => $size, 'data' => $data);

    }



    /**

     * Reads a cell address in BIFF8 e.g. 'A2' or '$A$2'

     * section 3.3.4

     *

     * @param string $cellAddressStructure

     * @return string

     */

    private function _readBIFF8CellAddress($cellAddressStructure)

    {

        // offset: 0; size: 2; index to row (0... 65535) (or offset (-32768... 32767))

        $row = self :: _GetInt2d($cellAddressStructure, 0) + 1;

        

        // offset: 2; size: 2; index to column or column offset + relative flags

        



        // bit: 7-0; mask 0x00FF; column index

        $column = PHPExcel_Cell :: stringFromColumnIndex(0x00FF & self :: _GetInt2d($cellAddressStructure, 2));

        

        // bit: 14; mask 0x4000; (1 = relative column index, 0 = absolute column index)

        if (! (0x4000 & self :: _GetInt2d($cellAddressStructure, 2)))

        {

            $column = '$' . $column;

        }

        // bit: 15; mask 0x8000; (1 = relative row index, 0 = absolute row index)

        if (! (0x8000 & self :: _GetInt2d($cellAddressStructure, 2)))

        {

            $row = '$' . $row;

        }

        

        return $column . $row;

    }



    /**

     * Reads a cell address in BIFF8 for shared formulas. Uses positive and negative values for row and column

     * to indicate offsets from a base cell

     * section 3.3.4

     *

     * @param string $cellAddressStructure

     * @param string $baseCell Base cell, only needed when formula contains tRefN tokens, e.g. with shared formulas

     * @return string

     */

    private function _readBIFF8CellAddressB($cellAddressStructure, $baseCell = 'A1')

    {

        list($baseCol, $baseRow) = PHPExcel_Cell :: coordinateFromString($baseCell);

        $baseCol = PHPExcel_Cell :: columnIndexFromString($baseCol) - 1;

        

        // offset: 0; size: 2; index to row (0... 65535) (or offset (-32768... 32767))

        $rowIndex = self :: _GetInt2d($cellAddressStructure, 0);

        $row = self :: _GetInt2d($cellAddressStructure, 0) + 1;

        

        // offset: 2; size: 2; index to column or column offset + relative flags

        



        // bit: 7-0; mask 0x00FF; column index

        $colIndex = 0x00FF & self :: _GetInt2d($cellAddressStructure, 2);

        

        // bit: 14; mask 0x4000; (1 = relative column index, 0 = absolute column index)

        if (! (0x4000 & self :: _GetInt2d($cellAddressStructure, 2)))

        {

            $column = PHPExcel_Cell :: stringFromColumnIndex($colIndex);

            $column = '$' . $column;

        }

        else

        {

            $colIndex = ($colIndex <= 127) ? $colIndex : $colIndex - 256;

            $column = PHPExcel_Cell :: stringFromColumnIndex($baseCol + $colIndex);

        }

        

        // bit: 15; mask 0x8000; (1 = relative row index, 0 = absolute row index)

        if (! (0x8000 & self :: _GetInt2d($cellAddressStructure, 2)))

        {

            $row = '$' . $row;

        }

        else

        {

            $rowIndex = ($rowIndex <= 32767) ? $rowIndex : $rowIndex - 65536;

            $row = $baseRow + $rowIndex;

        }

        

        return $column . $row;

    }



    /**

     * Reads a cell range address in BIFF5 e.g. 'A2:B6' or 'A1'

     * always fixed range

     * section 2.5.14

     *

     * @param string $subData

     * @return string

     * @throws Exception

     */

    private function _readBIFF5CellRangeAddressFixed($subData)

    {

        // offset: 0; size: 2; index to first row

        $fr = self :: _GetInt2d($subData, 0) + 1;

        

        // offset: 2; size: 2; index to last row

        $lr = self :: _GetInt2d($subData, 2) + 1;

        

        // offset: 4; size: 1; index to first column

        $fc = ord($subData{4});

        

        // offset: 5; size: 1; index to last column

        $lc = ord($subData{5});

        

        // check values

        if ($fr > $lr || $fc > $lc)

        {

            throw new Exception('Not a cell range address');

        }

        

        // column index to letter

        $fc = PHPExcel_Cell :: stringFromColumnIndex($fc);

        $lc = PHPExcel_Cell :: stringFromColumnIndex($lc);

        

        if ($fr == $lr and $fc == $lc)

        {

            return "$fc$fr";

        }

        return "$fc$fr:$lc$lr";

    }



    /**

     * Reads a cell range address in BIFF8 e.g. 'A2:B6' or 'A1'

     * always fixed range

     * section 2.5.14

     *

     * @param string $subData

     * @return string

     * @throws Exception

     */

    private function _readBIFF8CellRangeAddressFixed($subData)

    {

        // offset: 0; size: 2; index to first row

        $fr = self :: _GetInt2d($subData, 0) + 1;

        

        // offset: 2; size: 2; index to last row

        $lr = self :: _GetInt2d($subData, 2) + 1;

        

        // offset: 4; size: 2; index to first column

        $fc = self :: _GetInt2d($subData, 4);

        

        // offset: 6; size: 2; index to last column

        $lc = self :: _GetInt2d($subData, 6);

        

        // check values

        if ($fr > $lr || $fc > $lc)

        {

            throw new Exception('Not a cell range address');

        }

        

        // column index to letter

        $fc = PHPExcel_Cell :: stringFromColumnIndex($fc);

        $lc = PHPExcel_Cell :: stringFromColumnIndex($lc);

        

        if ($fr == $lr and $fc == $lc)

        {

            return "$fc$fr";

        }

        return "$fc$fr:$lc$lr";

    }



    /**

     * Reads a cell range address in BIFF8 e.g. 'A2:B6' or '$A$2:$B$6'

     * there are flags indicating whether column/row index is relative

     * section 3.3.4

     *

     * @param string $subData

     * @return string

     */

    private function _readBIFF8CellRangeAddress($subData)

    {

        // todo: if cell range is just a single cell, should this funciton

        // not just return e.g. 'A1' and not 'A1:A1' ?

        



        // offset: 0; size: 2; index to first row (0... 65535) (or offset (-32768... 32767))

        $fr = self :: _GetInt2d($subData, 0) + 1;

        

        // offset: 2; size: 2; index to last row (0... 65535) (or offset (-32768... 32767))

        $lr = self :: _GetInt2d($subData, 2) + 1;

        

        // offset: 4; size: 2; index to first column or column offset + relative flags

        



        // bit: 7-0; mask 0x00FF; column index

        $fc = PHPExcel_Cell :: stringFromColumnIndex(0x00FF & self :: _GetInt2d($subData, 4));

        

        // bit: 14; mask 0x4000; (1 = relative column index, 0 = absolute column index)

        if (! (0x4000 & self :: _GetInt2d($subData, 4)))

        {

            $fc = '$' . $fc;

        }

        

        // bit: 15; mask 0x8000; (1 = relative row index, 0 = absolute row index)

        if (! (0x8000 & self :: _GetInt2d($subData, 4)))

        {

            $fr = '$' . $fr;

        }

        

        // offset: 6; size: 2; index to last column or column offset + relative flags

        



        // bit: 7-0; mask 0x00FF; column index

        $lc = PHPExcel_Cell :: stringFromColumnIndex(0x00FF & self :: _GetInt2d($subData, 6));

        

        // bit: 14; mask 0x4000; (1 = relative column index, 0 = absolute column index)

        if (! (0x4000 & self :: _GetInt2d($subData, 6)))

        {

            $lc = '$' . $lc;

        }

        

        // bit: 15; mask 0x8000; (1 = relative row index, 0 = absolute row index)

        if (! (0x8000 & self :: _GetInt2d($subData, 6)))

        {

            $lr = '$' . $lr;

        }

        

        return "$fc$fr:$lc$lr";

    }



    /**

     * Reads a cell range address in BIFF8 for shared formulas. Uses positive and negative values for row and column

     * to indicate offsets from a base cell

     * section 3.3.4

     *

     * @param string $subData

     * @param string $baseCell Base cell

     * @return string Cell range address

     */

    private function _readBIFF8CellRangeAddressB($subData, $baseCell = 'A1')

    {

        list($baseCol, $baseRow) = PHPExcel_Cell :: coordinateFromString($baseCell);

        $baseCol = PHPExcel_Cell :: columnIndexFromString($baseCol) - 1;

        

        // TODO: if cell range is just a single cell, should this funciton

        // not just return e.g. 'A1' and not 'A1:A1' ?

        



        // offset: 0; size: 2; first row

        $frIndex = self :: _GetInt2d($subData, 0); // adjust below

        



        // offset: 2; size: 2; relative index to first row (0... 65535) should be treated as offset (-32768... 32767)

        $lrIndex = self :: _GetInt2d($subData, 2); // adjust below

        



        // offset: 4; size: 2; first column with relative/absolute flags

        



        // bit: 7-0; mask 0x00FF; column index

        $fcIndex = 0x00FF & self :: _GetInt2d($subData, 4);

        

        // bit: 14; mask 0x4000; (1 = relative column index, 0 = absolute column index)

        if (! (0x4000 & self :: _GetInt2d($subData, 4)))

        {

            // absolute column index

            $fc = PHPExcel_Cell :: stringFromColumnIndex($fcIndex);

            $fc = '$' . $fc;

        }

        else

        {

            // column offset

            $fcIndex = ($fcIndex <= 127) ? $fcIndex : $fcIndex - 256;

            $fc = PHPExcel_Cell :: stringFromColumnIndex($baseCol + $fcIndex);

        }

        

        // bit: 15; mask 0x8000; (1 = relative row index, 0 = absolute row index)

        if (! (0x8000 & self :: _GetInt2d($subData, 4)))

        {

            // absolute row index

            $fr = $frIndex + 1;

            $fr = '$' . $fr;

        }

        else

        {

            // row offset

            $frIndex = ($frIndex <= 32767) ? $frIndex : $frIndex - 65536;

            $fr = $baseRow + $frIndex;

        }

        

        // offset: 6; size: 2; last column with relative/absolute flags

        



        // bit: 7-0; mask 0x00FF; column index

        $lcIndex = 0x00FF & self :: _GetInt2d($subData, 6);

        $lcIndex = ($lcIndex <= 127) ? $lcIndex : $lcIndex - 256;

        $lc = PHPExcel_Cell :: stringFromColumnIndex($baseCol + $lcIndex);

        

        // bit: 14; mask 0x4000; (1 = relative column index, 0 = absolute column index)

        if (! (0x4000 & self :: _GetInt2d($subData, 6)))

        {

            // absolute column index

            $lc = PHPExcel_Cell :: stringFromColumnIndex($lcIndex);

            $lc = '$' . $lc;

        }

        else

        {

            // column offset

            $lcIndex = ($lcIndex <= 127) ? $lcIndex : $lcIndex - 256;

            $lc = PHPExcel_Cell :: stringFromColumnIndex($baseCol + $lcIndex);

        }

        

        // bit: 15; mask 0x8000; (1 = relative row index, 0 = absolute row index)

        if (! (0x8000 & self :: _GetInt2d($subData, 6)))

        {

            // absolute row index

            $lr = $lrIndex + 1;

            $lr = '$' . $lr;

        }

        else

        {

            // row offset

            $lrIndex = ($lrIndex <= 32767) ? $lrIndex : $lrIndex - 65536;

            $lr = $baseRow + $lrIndex;

        }

        

        return "$fc$fr:$lc$lr";

    }



    /**

     * Read BIFF8 cell range address list

     * section 2.5.15

     *

     * @param string $subData

     * @return array

     */

    private function _readBIFF8CellRangeAddressList($subData)

    {

        $cellRangeAddresses = array();

        

        // offset: 0; size: 2; number of the following cell range addresses

        $nm = self :: _GetInt2d($subData, 0);

        

        $offset = 2;

        // offset: 2; size: 8 * $nm; list of $nm (fixed) cell range addresses

        for($i = 0; $i < $nm; ++ $i)

        {

            $cellRangeAddresses[] = $this->_readBIFF8CellRangeAddressFixed(substr($subData, $offset, 8));

            $offset += 8;

        }

        

        return array('size' => 2 + 8 * $nm, 'cellRangeAddresses' => $cellRangeAddresses);

    }



    /**

     * Read BIFF5 cell range address list

     * section 2.5.15

     *

     * @param string $subData

     * @return array

     */

    private function _readBIFF5CellRangeAddressList($subData)

    {

        $cellRangeAddresses = array();

        

        // offset: 0; size: 2; number of the following cell range addresses

        $nm = self :: _GetInt2d($subData, 0);

        

        $offset = 2;

        // offset: 2; size: 6 * $nm; list of $nm (fixed) cell range addresses

        for($i = 0; $i < $nm; ++ $i)

        {

            $cellRangeAddresses[] = $this->_readBIFF5CellRangeAddressFixed(substr($subData, $offset, 6));

            $offset += 6;

        }

        

        return array('size' => 2 + 6 * $nm, 'cellRangeAddresses' => $cellRangeAddresses);

    }



    /**

     * Get a sheet range like Sheet1:Sheet3 from REF index

     * Note: If there is only one sheet in the range, one gets e.g Sheet1

     * It can also happen that the REF structure uses the -1 (FFFF) code to indicate deleted sheets,

     * in which case an exception is thrown

     *

     * @param int $index

     * @return string|false

     * @throws Exception

     */

    private function _readSheetRangeByRefIndex($index)

    {

        if (isset($this->_ref[$index]))

        {

            

            $type = $this->_externalBooks[$this->_ref[$index]['externalBookIndex']]['type'];

            

            switch ($type)

            {

                case 'internal' :

                    // check if we have a deleted 3d reference

                    if ($this->_ref[$index]['firstSheetIndex'] == 0xFFFF or $this->_ref[$index]['lastSheetIndex'] == 0xFFFF)

                    {

                        throw new Exception('Deleted sheet reference');

                    }

                    

                    // we have normal sheet range (collapsed or uncollapsed)

                    $firstSheetName = $this->_sheets[$this->_ref[$index]['firstSheetIndex']]['name'];

                    $lastSheetName = $this->_sheets[$this->_ref[$index]['lastSheetIndex']]['name'];

                    

                    if ($firstSheetName == $lastSheetName)

                    {

                        // collapsed sheet range

                        $sheetRange = $firstSheetName;

                    }

                    else

                    {

                        $sheetRange = "$firstSheetName:$lastSheetName";

                    }

                    

                    // escape the single-quotes

                    $sheetRange = str_replace("'", "''", $sheetRange);

                    

                    // if there are special characters, we need to enclose the range in single-quotes

                    // todo: check if we have identified the whole set of special characters

                    // it seems that the following characters are not accepted for sheet names

                    // and we may assume that they are not present: []*/:\?

                    if (preg_match("/[ !\"@#ÂŁ$%&{()}<>=+'|^,;-]/", $sheetRange))

                    {

                        $sheetRange = "'$sheetRange'";

                    }

                    

                    return $sheetRange;

                    break;

                

                default :

                    // TODO: external sheet support

                    throw new Exception('Excel5 reader only supports internal sheets in fomulas');

                    break;

            }

        }

        return false;

    }



    /**

     * read BIFF8 constant value array from array data

     * returns e.g. array('value' => '{1,2;3,4}', 'size' => 40}

     * section 2.5.8

     *

     * @param string $arrayData

     * @return array

     */

    private static function _readBIFF8ConstantArray($arrayData)

    {

        // offset: 0; size: 1; number of columns decreased by 1

        $nc = ord($arrayData[0]);

        

        // offset: 1; size: 2; number of rows decreased by 1

        $nr = self :: _GetInt2d($arrayData, 1);

        $size = 3; // initialize

        $arrayData = substr($arrayData, 3);

        

        // offset: 3; size: var; list of ($nc + 1) * ($nr + 1) constant values

        $matrixChunks = array();

        for($r = 1; $r <= $nr + 1; ++ $r)

        {

            $items = array();

            for($c = 1; $c <= $nc + 1; ++ $c)

            {

                $constant = self :: _readBIFF8Constant($arrayData);

                $items[] = $constant['value'];

                $arrayData = substr($arrayData, $constant['size']);

                $size += $constant['size'];

            }

            $matrixChunks[] = implode(',', $items); // looks like e.g. '1,"hello"'

        }

        $matrix = '{' . implode(';', $matrixChunks) . '}';

        

        return array('value' => $matrix, 'size' => $size);

    }



    /**

     * read BIFF8 constant value which may be 'Empty Value', 'Number', 'String Value', 'Boolean Value', 'Error Value'

     * section 2.5.7

     * returns e.g. array('value' => '5', 'size' => 9)

     *

     * @param string $valueData

     * @return array

     */

    private static function _readBIFF8Constant($valueData)

    {

        // offset: 0; size: 1; identifier for type of constant

        $identifier = ord($valueData[0]);

        

        switch ($identifier)

        {

            case 0x00 : // empty constant (what is this?)

                $value = '';

                $size = 9;

                break;

            case 0x01 : // number

                // offset: 1; size: 8; IEEE 754 floating-point value

                $value = self :: _extractNumber(substr($valueData, 1, 8));

                $size = 9;

                break;

            case 0x02 : // string value

                // offset: 1; size: var; Unicode string, 16-bit string length

                $string = self :: _readUnicodeStringLong(substr($valueData, 1));

                $value = '"' . $string['value'] . '"';

                $size = 1 + $string['size'];

                break;

            case 0x04 : // boolean

                // offset: 1; size: 1; 0 = FALSE, 1 = TRUE

                if (ord($valueData[1]))

                {

                    $value = 'TRUE';

                }

                else

                {

                    $value = 'FALSE';

                }

                $size = 9;

                break;

            case 0x10 : // error code

                // offset: 1; size: 1; error code

                $value = self :: _mapErrorCode(ord($valueData[1]));

                $size = 9;

                break;

        }

        return array('value' => $value, 'size' => $size);

    }



    /**

     * Extract RGB color

     * OpenOffice.org's Documentation of the Microsoft Excel File Format, section 2.5.4

     *

     * @param string $rgb Encoded RGB value (4 bytes)

     * @return array

     */

    private static function _readRGB($rgb)

    {

        // offset: 0; size 1; Red component

        $r = ord($rgb{0});

        

        // offset: 1; size: 1; Green component

        $g = ord($rgb{1});

        

        // offset: 2; size: 1; Blue component

        $b = ord($rgb{2});

        

        // HEX notation, e.g. 'FF00FC'

        $rgb = sprintf('%02X%02X%02X', $r, $g, $b);

        

        return array('rgb' => $rgb);

    }



    /**

     * Read byte string (8-bit string length)

     * OpenOffice documentation: 2.5.2

     *

     * @param string $subData

     * @return array

     */

    private function _readByteStringShort($subData)

    {

        // offset: 0; size: 1; length of the string (character count)

        $ln = ord($subData[0]);

        

        // offset: 1: size: var; character array (8-bit characters)

        $value = $this->_decodeCodepage(substr($subData, 1, $ln));

        

        return array('value' => $value, 'size' => 1 + $ln)// size in bytes of data structure

;

    }



    /**

     * Read byte string (16-bit string length)

     * OpenOffice documentation: 2.5.2

     *

     * @param string $subData

     * @return array

     */

    private function _readByteStringLong($subData)

    {

        // offset: 0; size: 2; length of the string (character count)

        $ln = self :: _GetInt2d($subData, 0);

        

        // offset: 2: size: var; character array (8-bit characters)

        $value = $this->_decodeCodepage(substr($subData, 2));

        

        //return $string;

        return array('value' => $value, 'size' => 2 + $ln)// size in bytes of data structure

;

    }



    /**

     * Extracts an Excel Unicode short string (8-bit string length)

     * OpenOffice documentation: 2.5.3

     * function will automatically find out where the Unicode string ends.

     *

     * @param string $subData

     * @return array

     */

    private static function _readUnicodeStringShort($subData)

    {

        $value = '';

        

        // offset: 0: size: 1; length of the string (character count)

        $characterCount = ord($subData[0]);

        

        $string = self :: _readUnicodeString(substr($subData, 1), $characterCount);

        

        // add 1 for the string length

        $string['size'] += 1;

        

        return $string;

    }



    /**

     * Extracts an Excel Unicode long string (16-bit string length)

     * OpenOffice documentation: 2.5.3

     * this function is under construction, needs to support rich text, and Asian phonetic settings

     *

     * @param string $subData

     * @return array

     */

    private static function _readUnicodeStringLong($subData)

    {

        $value = '';

        

        // offset: 0: size: 2; length of the string (character count)

        $characterCount = self :: _GetInt2d($subData, 0);

        

        $string = self :: _readUnicodeString(substr($subData, 2), $characterCount);

        

        // add 2 for the string length

        $string['size'] += 2;

        

        return $string;

    }



    /**

     * Read Unicode string with no string length field, but with known character count

     * this function is under construction, needs to support rich text, and Asian phonetic settings

     * OpenOffice.org's Documentation of the Microsoft Excel File Format, section 2.5.3

     *

     * @param string $subData

     * @param int $characterCount

     * @return array

     */

    private static function _readUnicodeString($subData, $characterCount)

    {

        $value = '';

        

        // offset: 0: size: 1; option flags

        



        // bit: 0; mask: 0x01; character compression (0 = compressed 8-bit, 1 = uncompressed 16-bit)

        $isCompressed = ! ((0x01 & ord($subData[0])) >> 0);

        

        // bit: 2; mask: 0x04; Asian phonetic settings

        $hasAsian = (0x04) & ord($subData[0]) >> 2;

        

        // bit: 3; mask: 0x08; Rich-Text settings

        $hasRichText = (0x08) & ord($subData[0]) >> 3;

        

        // offset: 1: size: var; character array

        // this offset assumes richtext and Asian phonetic settings are off which is generally wrong

        // needs to be fixed

        $value = self :: _encodeUTF16(substr($subData, 1, $isCompressed ? $characterCount : 2 * $characterCount), $isCompressed);

        

        return array('value' => $value, 'size' => $isCompressed ? 1 + $characterCount : 1 + 2 * $characterCount)// the size in bytes including the option flags

;

    }



    /**

     * Convert UTF-8 string to string surounded by double quotes. Used for explicit string tokens in formulas.

     * Example:  hello"world  -->  "hello""world"

     *

     * @param string $value UTF-8 encoded string

     * @return string

     */

    private static function _UTF8toExcelDoubleQuoted($value)

    {

        return '"' . str_replace('"', '""', $value) . '"';

    }



    /**

     * Reads first 8 bytes of a string and return IEEE 754 float

     *

     * @param string $data Binary string that is at least 8 bytes long

     * @return float

     */

    private static function _extractNumber($data)

    {

        $rknumhigh = self :: _GetInt4d($data, 4);

        $rknumlow = self :: _GetInt4d($data, 0);

        $sign = ($rknumhigh & 0x80000000) >> 31;

        $exp = (($rknumhigh & 0x7ff00000) >> 20) - 1023;

        $mantissa = (0x100000 | ($rknumhigh & 0x000fffff));

        $mantissalow1 = ($rknumlow & 0x80000000) >> 31;

        $mantissalow2 = ($rknumlow & 0x7fffffff);

        $value = $mantissa / pow(2, (20 - $exp));

        

        if ($mantissalow1 != 0)

        {

            $value += 1 / pow(2, (21 - $exp));

        }

        

        $value += $mantissalow2 / pow(2, (52 - $exp));

        if ($sign)

        {

            $value = - 1 * $value;

        }

        

        return $value;

    }



    private static function _GetIEEE754($rknum)

    {

        if (($rknum & 0x02) != 0)

        {

            $value = $rknum >> 2;

        }

        else

        {

            // changes by mmp, info on IEEE754 encoding from

            // research.microsoft.com/~hollasch/cgindex/coding/ieeefloat.html

            // The RK format calls for using only the most significant 30 bits

            // of the 64 bit floating point value. The other 34 bits are assumed

            // to be 0 so we use the upper 30 bits of $rknum as follows...

            $sign = ($rknum & 0x80000000) >> 31;

            $exp = ($rknum & 0x7ff00000) >> 20;

            $mantissa = (0x100000 | ($rknum & 0x000ffffc));

            $value = $mantissa / pow(2, (20 - ($exp - 1023)));

            if ($sign)

            {

                $value = - 1 * $value;

            }

        

     //end of changes by mmp

        }

        if (($rknum & 0x01) != 0)

        {

            $value /= 100;

        }

        return $value;

    }



    /**

     * Get UTF-8 string from (compressed or uncompressed) UTF-16 string

     *

     * @param string $string

     * @param bool $compressed

     * @return string

     */

    private static function _encodeUTF16($string, $compressed = '')

    {

        if ($compressed)

        {

            $string = self :: _uncompressByteString($string);

        }

        

        return PHPExcel_Shared_String :: ConvertEncoding($string, 'UTF-8', 'UTF-16LE');

    }



    /**

     * Convert UTF-16 string in compressed notation to uncompressed form. Only used for BIFF8.

     *

     * @param string $string

     * @return string

     */

    private static function _uncompressByteString($string)

    {

        $uncompressedString = '';

        $strLen = strlen($string);

        for($i = 0; $i < $strLen; ++ $i)

        {

            $uncompressedString .= $string[$i] . "\0";

        }

        

        return $uncompressedString;

    }



    /**

     * Convert string to UTF-8. Only used for BIFF5.

     *

     * @param string $string

     * @return string

     */

    private function _decodeCodepage($string)

    {

        return PHPExcel_Shared_String :: ConvertEncoding($string, 'UTF-8', $this->_codepage);

    }



    /**

     * Read 16-bit unsigned integer

     *

     * @param string $data

     * @param int $pos

     * @return int

     */

    public static function _GetInt2d($data, $pos)

    {

        return ord($data[$pos]) | (ord($data[$pos + 1]) << 8);

    }



    /**

     * Read 32-bit signed integer

     *

     * @param string $data

     * @param int $pos

     * @return int

     */

    public static function _GetInt4d($data, $pos)

    {

        // FIX: represent numbers correctly on 64-bit system

        // http://sourceforge.net/tracker/index.php?func=detail&aid=1487372&group_id=99160&atid=623334

        // Hacked by Andreas Rehm 2006 to ensure correct result of the <<24 block on 32 and 64bit systems

        $_or_24 = ord($data[$pos + 3]);

        if ($_or_24 >= 128)

        {

            // negative number

            $_ord_24 = - abs((256 - $_or_24) << 24);

        }

        else

        {

            $_ord_24 = ($_or_24 & 127) << 24;

        }

        return ord($data[$pos]) | (ord($data[$pos + 1]) << 8) | (ord($data[$pos + 2]) << 16) | $_ord_24;

    }



    /**

     * Read color

     *

     * @param int $color Indexed color

     * @param array $palette Color palette

     * @return array RGB color value, example: array('rgb' => 'FF0000')

     */

    private static function _readColor($color, $palette, $version)

    {

        if ($color <= 0x07 || $color >= 0x40)

        {

            // special built-in color

            return self :: _mapBuiltInColor($color);

        }

        elseif (isset($palette) && isset($palette[$color - 8]))

        {

            // palette color, color index 0x08 maps to pallete index 0

            return $palette[$color - 8];

        }

        else

        {

            // default color table

            if ($version == self :: XLS_BIFF8)

            {

                return self :: _mapColor($color);

            }

            else

            {

                // BIFF5

                return self :: _mapColorBIFF5($color);

            }

        }

        

        return $color;

    }



    /**

     * Map border style

     * OpenOffice documentation: 2.5.11

     *

     * @param int $index

     * @return string

     */

    private static function _mapBorderStyle($index)

    {

        switch ($index)

        {

            case 0x00 :

                return PHPExcel_Style_Border :: BORDER_NONE;

            case 0x01 :

                return PHPExcel_Style_Border :: BORDER_THIN;

            case 0x02 :

                return PHPExcel_Style_Border :: BORDER_MEDIUM;

            case 0x03 :

                return PHPExcel_Style_Border :: BORDER_DASHED;

            case 0x04 :

                return PHPExcel_Style_Border :: BORDER_DOTTED;

            case 0x05 :

                return PHPExcel_Style_Border :: BORDER_THICK;

            case 0x06 :

                return PHPExcel_Style_Border :: BORDER_DOUBLE;

            case 0x07 :

                return PHPExcel_Style_Border :: BORDER_HAIR;

            case 0x08 :

                return PHPExcel_Style_Border :: BORDER_MEDIUMDASHED;

            case 0x09 :

                return PHPExcel_Style_Border :: BORDER_DASHDOT;

            case 0x0A :

                return PHPExcel_Style_Border :: BORDER_MEDIUMDASHDOT;

            case 0x0B :

                return PHPExcel_Style_Border :: BORDER_DASHDOTDOT;

            case 0x0C :

                return PHPExcel_Style_Border :: BORDER_MEDIUMDASHDOTDOT;

            case 0x0D :

                return PHPExcel_Style_Border :: BORDER_SLANTDASHDOT;

            default :

                return PHPExcel_Style_Border :: BORDER_NONE;

        }

    }



    /**

     * Get fill pattern from index

     * OpenOffice documentation: 2.5.12

     *

     * @param int $index

     * @return string

     */

    private static function _mapFillPattern($index)

    {

        switch ($index)

        {

            case 0x00 :

                return PHPExcel_Style_Fill :: FILL_NONE;

            case 0x01 :

                return PHPExcel_Style_Fill :: FILL_SOLID;

            case 0x02 :

                return PHPExcel_Style_Fill :: FILL_PATTERN_MEDIUMGRAY;

            case 0x03 :

                return PHPExcel_Style_Fill :: FILL_PATTERN_DARKGRAY;

            case 0x04 :

                return PHPExcel_Style_Fill :: FILL_PATTERN_LIGHTGRAY;

            case 0x05 :

                return PHPExcel_Style_Fill :: FILL_PATTERN_DARKHORIZONTAL;

            case 0x06 :

                return PHPExcel_Style_Fill :: FILL_PATTERN_DARKVERTICAL;

            case 0x07 :

                return PHPExcel_Style_Fill :: FILL_PATTERN_DARKDOWN;

            case 0x08 :

                return PHPExcel_Style_Fill :: FILL_PATTERN_DARKUP;

            case 0x09 :

                return PHPExcel_Style_Fill :: FILL_PATTERN_DARKGRID;

            case 0x0A :

                return PHPExcel_Style_Fill :: FILL_PATTERN_DARKTRELLIS;

            case 0x0B :

                return PHPExcel_Style_Fill :: FILL_PATTERN_LIGHTHORIZONTAL;

            case 0x0C :

                return PHPExcel_Style_Fill :: FILL_PATTERN_LIGHTVERTICAL;

            case 0x0D :

                return PHPExcel_Style_Fill :: FILL_PATTERN_LIGHTDOWN;

            case 0x0E :

                return PHPExcel_Style_Fill :: FILL_PATTERN_LIGHTUP;

            case 0x0F :

                return PHPExcel_Style_Fill :: FILL_PATTERN_LIGHTGRID;

            case 0x10 :

                return PHPExcel_Style_Fill :: FILL_PATTERN_LIGHTTRELLIS;

            case 0x11 :

                return PHPExcel_Style_Fill :: FILL_PATTERN_GRAY125;

            case 0x12 :

                return PHPExcel_Style_Fill :: FILL_PATTERN_GRAY0625;

            default :

                return PHPExcel_Style_Fill :: FILL_NONE;

        }

    }



    /**

     * Map error code, e.g. '#N/A'

     *

     * @param int $subData

     * @return string

     */

    private static function _mapErrorCode($subData)

    {

        switch ($subData)

        {

            case 0x00 :

                return '#NULL!';

                break;

            case 0x07 :

                return '#DIV/0!';

                break;

            case 0x0F :

                return '#VALUE!';

                break;

            case 0x17 :

                return '#REF!';

                break;

            case 0x1D :

                return '#NAME?';

                break;

            case 0x24 :

                return '#NUM!';

                break;

            case 0x2A :

                return '#N/A';

                break;

            default :

                return false;

        }

    }



    /**

     * Map built-in color to RGB value

     *

     * @param int $color Indexed color

     * @return array

     */

    private static function _mapBuiltInColor($color)

    {

        switch ($color)

        {

            case 0x00 :

                return array('rgb' => '000000');

            case 0x01 :

                return array('rgb' => 'FFFFFF');

            case 0x02 :

                return array('rgb' => 'FF0000');

            case 0x03 :

                return array('rgb' => '00FF00');

            case 0x04 :

                return array('rgb' => '0000FF');

            case 0x05 :

                return array('rgb' => 'FFFF00');

            case 0x06 :

                return array('rgb' => 'FF00FF');

            case 0x07 :

                return array('rgb' => '00FFFF');

            case 0x40 :

                return array('rgb' => '000000'); // system window text color

            case 0x41 :

                return array('rgb' => 'FFFFFF'); // system window background color

            default :

                return array('rgb' => '000000');

        }

    }



    /**

     * Map color array from BIFF5 built-in color index

     *

     * @param int $subData

     * @return array

     */

    private static function _mapColorBIFF5($subData)

    {

        switch ($subData)

        {

            case 0x08 :

                return array('rgb' => '000000');

            case 0x09 :

                return array('rgb' => 'FFFFFF');

            case 0x0A :

                return array('rgb' => 'FF0000');

            case 0x0B :

                return array('rgb' => '00FF00');

            case 0x0C :

                return array('rgb' => '0000FF');

            case 0x0D :

                return array('rgb' => 'FFFF00');

            case 0x0E :

                return array('rgb' => 'FF00FF');

            case 0x0F :

                return array('rgb' => '00FFFF');

            case 0x10 :

                return array('rgb' => '800000');

            case 0x11 :

                return array('rgb' => '008000');

            case 0x12 :

                return array('rgb' => '000080');

            case 0x13 :

                return array('rgb' => '808000');

            case 0x14 :

                return array('rgb' => '800080');

            case 0x15 :

                return array('rgb' => '008080');

            case 0x16 :

                return array('rgb' => 'C0C0C0');

            case 0x17 :

                return array('rgb' => '808080');

            case 0x18 :

                return array('rgb' => '8080FF');

            case 0x19 :

                return array('rgb' => '802060');

            case 0x1A :

                return array('rgb' => 'FFFFC0');

            case 0x1B :

                return array('rgb' => 'A0E0F0');

            case 0x1C :

                return array('rgb' => '600080');

            case 0x1D :

                return array('rgb' => 'FF8080');

            case 0x1E :

                return array('rgb' => '0080C0');

            case 0x1F :

                return array('rgb' => 'C0C0FF');

            case 0x20 :

                return array('rgb' => '000080');

            case 0x21 :

                return array('rgb' => 'FF00FF');

            case 0x22 :

                return array('rgb' => 'FFFF00');

            case 0x23 :

                return array('rgb' => '00FFFF');

            case 0x24 :

                return array('rgb' => '800080');

            case 0x25 :

                return array('rgb' => '800000');

            case 0x26 :

                return array('rgb' => '008080');

            case 0x27 :

                return array('rgb' => '0000FF');

            case 0x28 :

                return array('rgb' => '00CFFF');

            case 0x29 :

                return array('rgb' => '69FFFF');

            case 0x2A :

                return array('rgb' => 'E0FFE0');

            case 0x2B :

                return array('rgb' => 'FFFF80');

            case 0x2C :

                return array('rgb' => 'A6CAF0');

            case 0x2D :

                return array('rgb' => 'DD9CB3');

            case 0x2E :

                return array('rgb' => 'B38FEE');

            case 0x2F :

                return array('rgb' => 'E3E3E3');

            case 0x30 :

                return array('rgb' => '2A6FF9');

            case 0x31 :

                return array('rgb' => '3FB8CD');

            case 0x32 :

                return array('rgb' => '488436');

            case 0x33 :

                return array('rgb' => '958C41');

            case 0x34 :

                return array('rgb' => '8E5E42');

            case 0x35 :

                return array('rgb' => 'A0627A');

            case 0x36 :

                return array('rgb' => '624FAC');

            case 0x37 :

                return array('rgb' => '969696');

            case 0x38 :

                return array('rgb' => '1D2FBE');

            case 0x39 :

                return array('rgb' => '286676');

            case 0x3A :

                return array('rgb' => '004500');

            case 0x3B :

                return array('rgb' => '453E01');

            case 0x3C :

                return array('rgb' => '6A2813');

            case 0x3D :

                return array('rgb' => '85396A');

            case 0x3E :

                return array('rgb' => '4A3285');

            case 0x3F :

                return array('rgb' => '424242');

            default :

                return array('rgb' => '000000');

        }

    }



    /**

     * Map color array from BIFF8 built-in color index

     *

     * @param int $subData

     * @return array

     */

    private static function _mapColor($subData)

    {

        switch ($subData)

        {

            case 0x08 :

                return array('rgb' => '000000');

            case 0x09 :

                return array('rgb' => 'FFFFFF');

            case 0x0A :

                return array('rgb' => 'FF0000');

            case 0x0B :

                return array('rgb' => '00FF00');

            case 0x0C :

                return array('rgb' => '0000FF');

            case 0x0D :

                return array('rgb' => 'FFFF00');

            case 0x0E :

                return array('rgb' => 'FF00FF');

            case 0x0F :

                return array('rgb' => '00FFFF');

            case 0x10 :

                return array('rgb' => '800000');

            case 0x11 :

                return array('rgb' => '008000');

            case 0x12 :

                return array('rgb' => '000080');

            case 0x13 :

                return array('rgb' => '808000');

            case 0x14 :

                return array('rgb' => '800080');

            case 0x15 :

                return array('rgb' => '008080');

            case 0x16 :

                return array('rgb' => 'C0C0C0');

            case 0x17 :

                return array('rgb' => '808080');

            case 0x18 :

                return array('rgb' => '9999FF');

            case 0x19 :

                return array('rgb' => '993366');

            case 0x1A :

                return array('rgb' => 'FFFFCC');

            case 0x1B :

                return array('rgb' => 'CCFFFF');

            case 0x1C :

                return array('rgb' => '660066');

            case 0x1D :

                return array('rgb' => 'FF8080');

            case 0x1E :

                return array('rgb' => '0066CC');

            case 0x1F :

                return array('rgb' => 'CCCCFF');

            case 0x20 :

                return array('rgb' => '000080');

            case 0x21 :

                return array('rgb' => 'FF00FF');

            case 0x22 :

                return array('rgb' => 'FFFF00');

            case 0x23 :

                return array('rgb' => '00FFFF');

            case 0x24 :

                return array('rgb' => '800080');

            case 0x25 :

                return array('rgb' => '800000');

            case 0x26 :

                return array('rgb' => '008080');

            case 0x27 :

                return array('rgb' => '0000FF');

            case 0x28 :

                return array('rgb' => '00CCFF');

            case 0x29 :

                return array('rgb' => 'CCFFFF');

            case 0x2A :

                return array('rgb' => 'CCFFCC');

            case 0x2B :

                return array('rgb' => 'FFFF99');

            case 0x2C :

                return array('rgb' => '99CCFF');

            case 0x2D :

                return array('rgb' => 'FF99CC');

            case 0x2E :

                return array('rgb' => 'CC99FF');

            case 0x2F :

                return array('rgb' => 'FFCC99');

            case 0x30 :

                return array('rgb' => '3366FF');

            case 0x31 :

                return array('rgb' => '33CCCC');

            case 0x32 :

                return array('rgb' => '99CC00');

            case 0x33 :

                return array('rgb' => 'FFCC00');

            case 0x34 :

                return array('rgb' => 'FF9900');

            case 0x35 :

                return array('rgb' => 'FF6600');

            case 0x36 :

                return array('rgb' => '666699');

            case 0x37 :

                return array('rgb' => '969696');

            case 0x38 :

                return array('rgb' => '003366');

            case 0x39 :

                return array('rgb' => '339966');

            case 0x3A :

                return array('rgb' => '003300');

            case 0x3B :

                return array('rgb' => '333300');

            case 0x3C :

                return array('rgb' => '993300');

            case 0x3D :

                return array('rgb' => '993366');

            case 0x3E :

                return array('rgb' => '333399');

            case 0x3F :

                return array('rgb' => '333333');

            default :

                return array('rgb' => '000000');

        }

    }



    private function _parseRichText($is = '')

    {

        $value = new PHPExcel_RichText();

        

        $value->createText($is);

        

        return $value;

    }



}