Spreadsheet::ParseExcel
Spreadsheet::ParseExcUser)Contributed Perl DocumentSpreadsheet::ParseExcel(3)
NAME
Spreadsheet::ParseExcel - Extract information from an Excel file.
SYNOPSIS
#!/usr/bin/perl -w
use strict;
use Spreadsheet::ParseExcel;
my $parser = Spreadsheet::ParseExcel->new();
my $workbook = $parser->Parse(’Book1.xls’);
for my $worksheet ( $workbook->worksheets() ) {
my ( $row_min, $row_max ) = $worksheet->row_range();
my ( $col_min, $col_max ) = $worksheet->col_range();
for my $row ( $row_min .. $row_max ) {
for my $col ( $col_min .. $col_max ) {
my $cell = $worksheet->get_cell( $row, $col );
next unless $cell;
print "Row, Col = ($row, $col)\n";
print "Value = ", $cell->value(), "\n";
print "Unformatted = ", $cell->unformatted(), "\n";
print "\n";
}
}
}
DESCRIPTION
The Spreadsheet::ParseExcel module can be used to read information
from an Excel 95-2003 file.
Parser
new()
The "new()" method is used to create a new "Spreadsheet::ParseExcel"
parser object.
my $parser = Spreadsheet::ParseExcel->new();
As an advanced feature it is also possible to pass a call-back handler
to the parser to control the parsing of the spreadsheet.
$parser = Spreadsheet::ParseExcel->new(
[ CellHandler => \&cell_handler,
NotSetCell => 1,
]);
The call-back can be used to ignore certain cells or to reduce memory
usage. See the section "Reducing the memory usage of Spread-
sheet::ParseExcel" for more information.
Parse($filename, [$formatter])
The Parser "Parse()" method return a "Workbook" object.
my $parser = Spreadsheet::ParseExcel->new();
my $workbook = $parser->Parse(’Book1.xls’);
If an error occurs "Parse()" returns "undef".
The $filename parameter is generally the file to be parsed. However,
it can also be a filehandle or a scalar reference.
The optional $formatter array ref can be an reference to a "Formatter
Class" to format the value of cells.
ColorIdxToRGB()
The "ColorIdxToRGB()" method returns a RGB string corresponding to a
specified color index. The RGB string has 6 characters, representing
the RGB hex value, for example ’FF0000’. The color index is generally
obtained from a FONT object.
$RGB = $parser->ColorIdxToRGB($color_index);
Workbook
A "Spreadsheet::ParseExcel::Workbook" is created via the "Spread-
sheet::ParseExcel" "Parse()" method:
my $parser = Spreadsheet::ParseExcel->new();
my $workbook = $parser->Parse(’Book1.xls’);
The Workbook class has methods and properties that are outlined in the
following sections.
Workbook Methods
Parse()
As a syntactic shorthand you can create a Parser and Workbook object
in one go using the Workbook "Parse()" method. The following examples
are equivalent:
# Method 1
my $parser = Spreadsheet::ParseExcel->new();
my $workbook = $parser->Parse(’Book1.xls’);
# Method 2
my $workbook = Spreadsheet::ParseExcel::Workbook->Parse(’Book1.xls’);
worksheets()
Returns an array of "Worksheet" objects. This was most commonly used
to iterate over the worksheets in a workbook:
for my $worksheet ( $workbook->worksheets() ) {
...
}
Worksheet()
The "Worksheet()" method returns a single "Worksheet" object using
either its name or index:
$worksheet = $workbook->Worksheet(’Sheet1’);
$worksheet = $workbook->Worksheet(0);
Returns "undef" if the sheet name or index doesn’t exist.
Workbook Properties
A workbook object exposes a number of properties as shown below:
$workbook->{Worksheet }->[$index]
$workbook->{File}
$workbook->{Author}
$workbook->{Flg1904}
$workbook->{Version}
$workbook->{SheetCount}
$workbook->{PrintArea }->[$index]
$workbook->{PrintTitle}->[$index]
These properties are generally only of interest to advanced users.
Casual users can skip this section.
$workbook->{Worksheet}->[$index]
Returns an array of "Worksheet" objects. This was most commonly used
to iterate over the worksheets in a workbook:
for my $worksheet (@{$workbook->{Worksheet}}) {
...
}
It is now deprecated, use worksheets()) instead.
$workbook->{File}
Returns the name of the Excel file.
$workbook->{Author}
Returns the author of the Excel file.
$workbook->{Flg1904}
Returns true if the Excel file is using the 1904 date epoch instead of
the 1900 epoch. The Windows version of Excel generally uses the 1900
epoch while the Mac version of Excel generally uses the 1904 epoch.
$workbook->{Version}
Returns the version of the Excel file.
$workbook->{SheetCount}
Returns the numbers of "Worksheet" objects in the Workbook.
$workbook->{PrintArea}->[$index]
Returns an array ref of print areas. Each print area is as follows:
[ $start_row, $start_col, $end_row, $end_col]
$workbook->{PrintTitle}->[$index]
Returns an array ref of print title hash refs. Each print title is as
follows:
{
Row => [$start_row, $end_row],
Column => [$start_col, $end_col]
}
Worksheet
The "Spreadsheet::ParseExcel::Worksheet" class has the following meth-
ods and properties.
Worksheet methods
get_cell($row, $col)
Return the "Cell" object at row $row and column $col if it is defined.
Otherwise returns undef.
my $cell = $worksheet->get_cell($row, $col);
row_range()
Return a two-element list "($min, $max)" containing the minimum and
maximum defined rows in the worksheet. If there is no row defined $max
is smaller than $min.
my ( $row_min, $row_max ) = $worksheet->row_range();
col_range()
Return a two-element list "($min, $max)" containing the minimum and
maximum of defined columns in the worksheet. If there is no column
defined $max is smaller than $min.
my ( $col_min, $col_max ) = $worksheet->col_range();
Worksheet Properties
A worksheet object exposes a number of properties as shown below:
$worksheet->{Name}
$worksheet->{DefRowHeight}
$worksheet->{DefColWidth}
$worksheet->{RowHeight}->[$row]
$worksheet->{ColWidth}->[$col]
$worksheet->{Cells}->[$row]->[$col]
$worksheet->{Landscape}
$worksheet->{Scale}
$worksheet->{PageFit}
$worksheet->{FitWidth}
$worksheet->{FitHeight}
$worksheet->{PaperSize}
$worksheet->{PageStart}
$worksheet->{UsePage}
$worksheet->{$margin}
$worksheet->{HCenter}
$worksheet->{VCenter}
$worksheet->{Header}
$worksheet->{Footer}
$worksheet->{PrintGrid}
$worksheet->{PrintHeaders}
$worksheet->{NoColor}
$worksheet->{Draft}
$worksheet->{Notes}
$worksheet->{LeftToRight}
$worksheet->{HPageBreak}
$worksheet->{VPageBreak}
$worksheet->{MergedArea}
These properties are generally only of interest to advanced users.
Casual users can skip this section.
$worksheet->{Name}
Returns the name of the worksheet such as ’Sheet1’.
$worksheet->{DefRowHeight}
Returns default height of the rows in the worksheet.
$worksheet->{DefColWidth}
Returns default width of columns in the worksheet.
$worksheet->{RowHeight}->[$row]
Returns an array of row heights.
$worksheet->{ColWidth}->[$col]
Returns array of column widths. A value of "undef" means the column
has the "DefColWidth".
$worksheet->{Cells}->[$row]->[$col]
Returns array of "Cell" objects in the worksheet.
my $cell = $worksheet->{Cells}->[$row]->[$col];
$worksheet->{Landscape}
Returns 0 for horizontal or 1 for vertical.
$worksheet->{Scale}
Returns the worksheet print scale.
$worksheet->{PageFit}
Returns true if the "fit to" print option is set.
$worksheet->{FitWidth}
Return the number of pages in the "fit to width" option.
$worksheet->{FitHeight}
Return the number of pages in the "fit to height" option.
$worksheet->{PaperSize}
Returns the printer paper size. The value corresponds to the formats
shown below:
Index Paper format Paper size
===== ============ ==========
0 Printer default -
1 Letter 8 1/2 x 11 in
2 Letter Small 8 1/2 x 11 in
3 Tabloid 11 x 17 in
4 Ledger 17 x 11 in
5 Legal 8 1/2 x 14 in
6 Statement 5 1/2 x 8 1/2 in
7 Executive 7 1/4 x 10 1/2 in
8 A3 297 x 420 mm
9 A4 210 x 297 mm
10 A4 Small 210 x 297 mm
11 A5 148 x 210 mm
12 B4 250 x 354 mm
13 B5 182 x 257 mm
14 Folio 8 1/2 x 13 in
15 Quarto 215 x 275 mm
16 - 10x14 in
17 - 11x17 in
18 Note 8 1/2 x 11 in
19 Envelope 9 3 7/8 x 8 7/8
20 Envelope 10 4 1/8 x 9 1/2
21 Envelope 11 4 1/2 x 10 3/8
22 Envelope 12 4 3/4 x 11
23 Envelope 14 5 x 11 1/2
24 C size sheet -
25 D size sheet -
26 E size sheet -
27 Envelope DL 110 x 220 mm
28 Envelope C3 324 x 458 mm
29 Envelope C4 229 x 324 mm
30 Envelope C5 162 x 229 mm
31 Envelope C6 114 x 162 mm
32 Envelope C65 114 x 229 mm
33 Envelope B4 250 x 353 mm
34 Envelope B5 176 x 250 mm
35 Envelope B6 176 x 125 mm
36 Envelope 110 x 230 mm
37 Monarch 3.875 x 7.5 in
38 Envelope 3 5/8 x 6 1/2 in
39 Fanfold 14 7/8 x 11 in
40 German Std Fanfold 8 1/2 x 12 in
41 German Legal Fanfold 8 1/2 x 13 in
256 User defined
The two most common paper sizes are "1 = "US Letter"" and "9 = A4".
$worksheet->{PageStart}
Returns the page number where printing starts.
$worksheet->{UsePage}
Returns whether a user defined start page is in use.
$worksheet->{$margin}
Returns the worksheet margin for left, right, top, bottom, header and
footer where $margin has one of the following values:
LeftMargin
RightMargin
TopMargin
BottomMargin
HeaderMargin
FooterMargin
$worksheet->{HCenter}
Returns true if the "Center horizontally when Printing" option is set.
$worksheet->{VCenter}
Returns true if the "Center vertically when Printing" option is set.
$worksheet->{Header}
Returns the print header string. This can contain control codes for
alignment and font properties. Refer to the Excel on-line help on
headers and footers or to the Spreadsheet::WriteExcel documentation
for "set_header()".
$worksheet->{Footer}
Returns the print footer string. This can contain control codes for
alignment and font properties. Refer to the Excel on-line help on
headers and footers or to the Spreadsheet::WriteExcel documentation
for "set_header()".
$worksheet->{PrintGrid}
Returns true if Print with gridlines is set.
$worksheet->{PrintHeaders}
Returns true if Print with headings is set.
$worksheet->{NoColor}
Returns true if Print in black and white is set.
$worksheet->{Draft}
Returns true if the "draft mode" print option is set.
$worksheet->{Notes}
Returns true if print with notes option is set.
$worksheet->{LeftToRight}
Returns the print order for the worksheet. Returns 0 for "left to
right" printing and 1 for "top down" printing.
$worksheet->{HPageBreak}
Return an array ref of horizontal page breaks.
$worksheet->{VPageBreak}
Return an array ref of vertical page breaks.
$worksheet->{MergedArea}
Return an array ref of merged areas. Each merged area is:
[ $start_row, $start_col, $end_row, $end_col]
Cell
The "Spreadsheet::ParseExcel::Cell" class has the following methods
and properties.
Cell methods
value()
Formatted value of the cell.
unformatted()
Unformatted value of the cell.
Cell properties
$cell->{Val}
$cell->{Type}
$cell->{Code}
$cell->{Format}
$cell->{Merged}
$cell->{Rich}
$cell->{Val}
Returns the unformatted value of the cell. This is Deprecated, use
"$cell->unformatted()" instead.
$cell->{Type}
Returns the type of cell such as "Text", "Numeric" or "Date".
If the type was detected as "Numeric", and the Cell Format matches
"m{^[dmy][-\\/dmy]*$}", it will be treated as a "Date" type.
$cell->{Code}
Returns the character encoding of the cell. It is either "undef",
"ucs2" or "_native_".
If "undef" then the character encoding seems to be "ascii".
If "_native_" it means that cell seems to be ’sjis’ or something simi-
lar.
$cell->{Format}
Returns the "Format" object for the cell.
$cell->{Merged}
Returns true if the cell is merged.
$cell->{Rich}
Returns an array ref of font information about each string block in a
"rich", i.e. multi-format, string. Each entry has the form:
[ $start_position>, $font_object ]
For more information refer to the example program "sample/dmpExR.pl".
Format
The "Spreadsheet::ParseExcel::Format" class has the following proper-
ties:
Format properties
$format->{Font}
$format->{AlignH}
$format->{AlignV}
$format->{Indent}
$format->{Wrap}
$format->{Shrink}
$format->{Rotate}
$format->{JustLast}
$format->{ReadDir}
$format->{BdrStyle}
$format->{BdrColor}
$format->{BdrDiag}
$format->{Fill}
$format->{Lock}
$format->{Hidden}
$format->{Style}
These properties are generally only of interest to advanced users.
Casual users can skip this section.
$format->{Font}
Returns the "Font" object for the Format.
$format->{AlignH}
Returns the horizontal alignment of the format where the value has the
following meaning:
0 => No alignment
1 => Left
2 => Center
3 => Right
4 => Fill
5 => Justify
6 => Center across
7 => Distributed/Equal spaced
$format->{AlignV}
Returns the vertical alignment of the format where the value has the
following meaning:
0 => Top
1 => Center
2 => Bottom
3 => Justify
4 => Distributed/Equal spaced
$format->{Indent}
Returns the indent level of the "Left" horizontal alignment.
$format->{Wrap}
Returns true if textwrap is on.
$format->{Shrink}
Returns true if "Shrink to fit" is set for the format.
$format->{Rotate}
Returns the text rotation. In Excel97+, it returns the angle in
degrees of the text rotation.
In Excel95 or earlier it returns a value as follows:
0 => No rotation
1 => Top down
2 => 90 degrees anti-clockwise,
3 => 90 clockwise
$format->{JustLast}
Return true if the "justify last" property is set for the format.
$format->{ReadDir}
Returns the direction that the text is read from.
$format->{BdrStyle}
Returns an array ref of border styles as follows:
[ $left, $right, $top, $bottom ]
$format->{BdrColor}
Returns an array ref of border color indexes as follows:
[ $left, $right, $top, $bottom ]
$format->{BdrDiag}
Returns an array ref of diagonal border kind, style and color index as
follows:
[$kind, $style, $color ]
Where kind is:
0 => None
1 => Right-Down
2 => Right-Up
3 => Both
$format->{Fill}
Returns an array ref of fill pattern and color indexes as follows:
[ $pattern, $front_color, $back_color ]
$format->{Lock}
Returns true if the cell is locked.
$format->{Hidden}
Returns true if the cell is Hidden.
$format->{Style}
Returns true if the format is a Style format.
Font
Spreadsheet::ParseExcel::Font
Format class has these properties:
Font Properties
$font->{Name}
$font->{Bold}
$font->{Italic}
$font->{Height}
$font->{Underline}
$font->{UnderlineStyle}
$font->{Color}
$font->{Strikeout}
$font->{Super}
$font->{Name}
Returns the name of the font, for example ’Arial’.
$font->{Bold}
Returns true if the font is bold.
$font->{Italic}
Returns true if the font is italic.
$font->{Height}
Returns the size (height) of the font.
$font->{Underline}
Returns true if the font in underlined.
$font->{UnderlineStyle}
Returns the style of an underlined font where the value has the fol-
lowing meaning:
0 => None
1 => Single
2 => Double
33 => Single accounting
34 => Double accounting
$font->{Color}
Returns the color index for the font. The index can be converted to a
RGB string using the "ColorIdxToRGB()" Parser method.
$font->{Strikeout}
Returns true if the font has the strikeout property set.
$font->{Super}
Returns one of the following values if the superscript or subscript
property of the font is set:
0 => None
1 => Superscript
2 => Subscript
Formatter class
Spreadsheet::ParseExcel::Fmt*
Formatter class will convert cell data.
Spreadsheet::ParseExcel includes 2 formatter classes. "FmtDefault" and
"FmtJapanese". It is also possible to create a user defined formatting
class.
The formatter class "Spreadsheet::ParseExcel::Fmt*" should provide the
following functions:
ChkType($self, $is_numeric, $format_index)
Method to check the the type of data in the cell. Should return
"Date", "Numeric" or "Text". It is passed the following parameters:
$self
A scalar reference to the Formatter object.
$is_numeric
If true, the value seems to be number.
$format_index
The index number for the cell Format object.
TextFmt($self, $string_data, $string_encoding)
Converts the string data in the cell into the correct encoding. It is
passed the following parameters:
$self
A scalar reference to the Formatter object.
$string_data
The original string/text data.
$string_encoding
The character encoding of original string/text.
ValFmt($self, $cell, $workbook)
Convert the original unformatted cell value into the appropriate for-
matted value. For instance turn a number into a formatted date. It is
passed the following parameters:
$self
A scalar reference to the Formatter object.
$cell
A scalar reference to the Cell object.
$workbook
A scalar reference to the Workbook object.
FmtString($self, $cell, $workbook)
Get the format string for the Cell. It is passed the following param-
eters:
$self
A scalar reference to the Formatter object.
$cell
A scalar reference to the Cell object.
$workbook
A scalar reference to the Workbook object.
Reducing the memory usage of Spreadsheet::ParseExcel
In some cases a "Spreadsheet::ParseExcel" application may consume a
lot of memory when processing a large Excel file and, as a result, may
fail to complete. The following explains why this can occur and how to
resolve it.
"Spreadsheet::ParseExcel" processes an Excel file in two stages. In
the first stage it extracts the Excel binary stream from the OLE con-
tainer file using "OLE::Storage_Lite". In the second stage it parses
the binary stream to read workbook, worksheet and cell data which it
then stores in memory. The majority of the memory usage is required
for storing cell data.
The reason for this is that as the Excel file is parsed and each cell
is encountered a cell handling function creates a relatively large
nested cell object that contains the cell value and all of the data
that relates to the cell formatting. For large files (a 10MB Excel
file on a 256MB system) this overhead can cause the system to grind to
a halt.
However, in a lot of cases when an Excel file is being processed the
only information that is required are the cell values. In these cases
it is possible to avoid most of the memory overhead by specifying your
own cell handling function and by telling Spreadsheet::ParseExcel not
to store the parsed cell data. This is achieved by passing a cell han-
dler function to "new()" when creating the parse object. Here is an
example.
#!/usr/bin/perl -w
use strict;
use Spreadsheet::ParseExcel;
my $parser = Spreadsheet::ParseExcel->new(
CellHandler => \&cell_handler,
NotSetCell => 1
);
my $workbook = $parser->Parse(’file.xls’);
sub cell_handler {
my $workbook = $_[0];
my $sheet_index = $_[1];
my $row = $_[2];
my $col = $_[3];
my $cell = $_[4];
# Do something useful with the formatted cell value
print $cell->value(), "\n";
}
The user specified cell handler is passed as a code reference to
"new()" along with the parameter "NotSetCell" which tells Spread-
sheet::ParseExcel not to store the parsed cell. Note, you don’t have
to iterate over the rows and columns, this happens automatically as
part of the parsing.
The cell handler is passed 5 arguments. The first, $workbook, is a
reference to the "Spreadsheet::ParseExcel::Workbook" object that rep-
resent the parsed workbook. This can be used to access any of the
"Spreadsheet::ParseExcel::Workbook" methods, see "Workbook". The sec-
ond $sheet_index is the zero-based index of the worksheet being
parsed. The third and fourth, $row and $col, are the zero-based row
and column number of the cell. The fifth, $cell, is a reference to the
"Spreadsheet::ParseExcel::Cell" object. This is used to extract the
data from the cell. See "Cell" for more information.
This technique can be useful if you are writing an Excel to database
filter since you can put your DB calls in the cell handler.
If you don’t want all of the data in the spreadsheet you can add some
control logic to the cell handler. For example we can extend the pre-
vious example so that it only prints the first 10 rows of the first
two worksheets in the parsed workbook by adding some "if()" statements
to the cell handler:
#!/usr/bin/perl -w
use strict;
use Spreadsheet::ParseExcel;
my $parser = Spreadsheet::ParseExcel->new(
CellHandler => \&cell_handler,
NotSetCell => 1
);
my $workbook = $parser->Parse(’file.xls’);
sub cell_handler {
my $workbook = $_[0];
my $sheet_index = $_[1];
my $row = $_[2];
my $col = $_[3];
my $cell = $_[4];
# Skip some worksheets and rows (inefficiently).
return if $sheet_index >= 3;
return if $row >= 10;
# Do something with the formatted cell value
print $cell->value(), "\n";
}
However, this still processes the entire workbook. If you wish to save
some additional processing time you can abort the parsing after you
have read the data that you want, using the workbook "ParseAbort"
method:
#!/usr/bin/perl -w
use strict;
use Spreadsheet::ParseExcel;
my $parser = Spreadsheet::ParseExcel->new(
CellHandler => \&cell_handler,
NotSetCell => 1
);
my $workbook = $parser->Parse(’file.xls’);
sub cell_handler {
my $workbook = $_[0];
my $sheet_index = $_[1];
my $row = $_[2];
my $col = $_[3];
my $cell = $_[4];
# Skip some worksheets and rows (more efficiently).
if ( $sheet_index >= 1 and $row >= 10 ) {
$workbook->ParseAbort(1);
return;
}
# Do something with the formatted cell value
print $cell->value(), "\n";
}
KNOWN PROBLEMS
* Issues reported by users: http://rt.cpan.org/Public/Dist/Dis-
play.html?Name=Spreadsheet-ParseExcel
* This module cannot read the values of formulas from files created
with Spreadsheet::WriteExcel unless the user specified the values when
creating the file (which is generally not the case). The reason for
this is that Spreadsheet::WriteExcel writes the formula but not the
formula result since it isn’t in a position to calculate arbitrary
Excel formulas without access to Excel’s formula engine.
* If Excel has date fields where the specified format is equal to the
system-default for the short-date locale, Excel does not store the
format, but defaults to an internal format which is system dependent.
In these cases ParseExcel uses the date format ’yyyy-mm-dd’.
REPORTING A BUG
Bugs can be reported via rt.cpan.org. See the following for instruc-
tions on bug reporting for Spreadsheet::ParseExcel
http://rt.cpan.org/Public/Dist/Display.html?Name=Spreadsheet-ParseEx-
cel
SEE ALSO
* xls2csv by Ken Prows
(http://search.cpan.org/~ken/xls2csv-1.06/script/xls2csv).
* xls2csv and xlscat by H.Merijn Brand (these utilities are part of
Spreadsheet::Read, see below).
* excel2txt by Ken Youens-Clark,
(http://search.cpan.org/~kclark/excel2txt/excel2txt). This is an
excellent example of an Excel filter using Spreadsheet::ParseExcel. It
can produce CSV, Tab delimited, Html, XML and Yaml.
* XLSperl by Jon Allen (http://search.cpan.org/~jon-
allen/XLSperl/bin/XLSperl). This application allows you to use Perl
"one-liners" with Microsoft Excel files.
* Spreadsheet::XLSX (http://search.cpan.org/~dmow/Spread-
sheet-XLSX/lib/Spreadsheet/XLSX.pm) by Dmitry Ovsyanko. A module with
a similar interface to Spreadsheet::ParseExcel for parsing Excel 2007
XLSX OpenXML files.
* Spreadsheet::Read (http://search.cpan.org/~hmbrand/Spread-
sheet-Read/Read.pm) by H.Merijn Brand. A single interface for reading
several different spreadsheet formats.
* Spreadsheet::WriteExcel (http://search.cpan.org/~jmcnamara/Spread-
sheet-WriteExcel/lib/Spreadsheet/WriteExcel.pm). A perl module for
creating new Excel files.
* Spreadsheet::ParseExcel::SaveParser (http://search.cpan.org/~jmcna-
mara/Spreadsheet-ParseExcel/lib/Spreadsheet/ParseExcel/SaveParser.pm).
This is a combination of Spreadsheet::ParseExcel and Spread-
sheet::WriteExcel and it allows you to "rewrite" an Excel file. See
the following example (http://search.cpan.org/~jmcnamara/Spread-
sheet-WriteExcel/lib/Spreadsheet/WriteExcel.pm#MODIFYING_AND_REWRIT-
ING_EXCEL_FILES). It is part of the Spreadsheet::ParseExcel distro.
* Text::CSV_XS (http://search.cpan.org/~hmbrand/Text-CSV_XS/CSV_XS.pm)
by H.Merijn Brand. A fast and rigorous module for reading and writing
CSV data. Don’t consider rolling your own CSV handling, use this mod-
ule instead.
MAILING LIST
There is a Google group for discussing and asking questions about
Spreadsheet::ParseExcel. This is a good place to search to see if your
question has been asked before:
http://groups-beta.google.com/group/spreadsheet-parseexcel/
DONATIONS
If you’d care to donate to the Spreadsheet::ParseExcel project, you
can do so via PayPal: http://tinyurl.com/7ayes
TODO
* The current maintenance work is directed towards making the documen-
tation more useful, improving and simplifying the API, and improving
the maintainability of the code base. After that new features will be
added.
* Fix open bugs and documentation for SaveParser.
* Add Formula support, Hyperlink support, Named Range support.
* Improve Spreadsheet::ParseExcel::SaveParser compatibility with
Spreadsheet::WriteExcel.
* Improve Unicode and other encoding support. This will probably
require dropping support for perls prior to 5.8+.
ACKNOWLEDGEMENTS
From Kawai Takanori:
First of all, I would like to acknowledge the following valuable pro-
grams and modules: XHTML, OLE::Storage and Spreadsheet::WriteExcel.
In no particular order: Yamaji Haruna, Simamoto Takesi, Noguchi
Harumi, Ikezawa Kazuhiro, Suwazono Shugo, Hirofumi Morisada, Michael
Edwards, Kim Namusk, Slaven Rezic, Grant Stevens, H.Merijn Brand and
many many people + Kawai Mikako.
DISCLAIMER OF WARRANTY
Because this software is licensed free of charge, there is no warranty
for the software, to the extent permitted by applicable law. Except
when otherwise stated in writing the copyright holders and/or other
parties provide the software "as is" without warranty of any kind,
either expressed or implied, including, but not limited to, the
implied warranties of merchantability and fitness for a particular
purpose. The entire risk as to the quality and performance of the
software is with you. Should the software prove defective, you assume
the cost of all necessary servicing, repair, or correction.
In no event unless required by applicable law or agreed to in writing
will any copyright holder, or any other party who may modify and/or
redistribute the software as permitted by the above licence, be liable
to you for damages, including any general, special, incidental, or
consequential damages arising out of the use or inability to use the
software (including but not limited to loss of data or data being ren-
dered inaccurate or losses sustained by you or third parties or a
failure of the software to operate with any other software), even if
such holder or other party has been advised of the possibility of such
damages.
LICENSE
Either the Perl Artistic Licence http://dev.perl.org/licenses/artis-
tic.html or the GPL http://www.opensource.org/licenses/gpl-license.php
AUTHOR
Current maintainer 0.40+: John McNamara jmcnamara@cpan.org
Maintainer 0.27-0.33: Gabor Szabo szabgab@cpan.org
Original author: Kawai Takanori (Hippo2000) kwitknr@cpan.org
COPYRIGHT
Copyright (c) 2009 John McNamara
Copyright (c) 2006-2008 Gabor Szabo
Copyright (c) 2000-2006 Kawai Takanori
All rights reserved. This is free software. You may distribute under
the terms of either the GNU General Public License or the Artistic
License.
perl v5.8.8 2009-01-23 Spreadsheet::ParseExcel(3)
