Spreadsheet::ParseExcel(3pm)

1Spreadsheet::ParseExcelU(s3e)r Contributed Perl DocumentaStpiroenadsheet::ParseExcel(3)
2
3
4

NAME

6       Spreadsheet::ParseExcel - Read information from an Excel file.
7

SYNOPSIS

9           #!/usr/bin/perl -w
10
11           use strict;
12           use Spreadsheet::ParseExcel;
13
14           my $parser   = Spreadsheet::ParseExcel->new();
15           my $workbook = $parser->parse('Book1.xls');
16
17           if ( !defined $workbook ) {
18               die $parser->error(), ".\n";
19           }
20
21           for my $worksheet ( $workbook->worksheets() ) {
22
23               my ( $row_min, $row_max ) = $worksheet->row_range();
24               my ( $col_min, $col_max ) = $worksheet->col_range();
25
26               for my $row ( $row_min .. $row_max ) {
27                   for my $col ( $col_min .. $col_max ) {
28
29                       my $cell = $worksheet->get_cell( $row, $col );
30                       next unless $cell;
31
32                       print "Row, Col    = ($row, $col)\n";
33                       print "Value       = ", $cell->value(),       "\n";
34                       print "Unformatted = ", $cell->unformatted(), "\n";
35                       print "\n";
36                   }
37               }
38           }
39

DESCRIPTION

41       The Spreadsheet::ParseExcel module can be used to read information from
42       Excel 95-2003 binary files.
43
44       The module cannot read files in the Excel 2007 Open XML XLSX format.
45       See the Spreadsheet::XLSX module instead.
46

Parser

48   new()
49       The new() method is used to create a new "Spreadsheet::ParseExcel"
50       parser object.
51
52           my $parser = Spreadsheet::ParseExcel->new();
53
54       It is possible to pass a password to decrypt an encrypted file:
55
56           $parser = Spreadsheet::ParseExcel->new( Password => 'secret' );
57
58       Only the default Excel encryption scheme is currently supported. See
59       "Decryption".
60
61       As an advanced feature it is also possible to pass a call-back handler
62       to the parser to control the parsing of the spreadsheet.
63
64           $parser = Spreadsheet::ParseExcel->new(
65               CellHandler => \&cell_handler,
66               NotSetCell  => 1,
67           );
68
69       The call-back can be used to ignore certain cells or to reduce memory
70       usage. See the section "Reducing the memory usage of
71       Spreadsheet::ParseExcel" for more information.
72
73   parse($filename, $formatter)
74       The Parser parse() method returns a "Workbook" object.
75
76           my $parser   = Spreadsheet::ParseExcel->new();
77           my $workbook = $parser->parse('Book1.xls');
78
79       If an error occurs parse() returns "undef". In general, programs should
80       contain a test for failed parsing as follows:
81
82           my $parser   = Spreadsheet::ParseExcel->new();
83           my $workbook = $parser->parse('Book1.xls');
84
85           if ( !defined $workbook ) {
86               die $parser->error(), ".\n";
87           }
88
89       The $filename parameter is generally the file to be parsed. However, it
90       can also be a filehandle or a scalar reference.
91
92       The optional $formatter parameter can be an reference to a "Formatter
93       Class" to format the value of cells. This is useful for parsing
94       workbooks with Unicode or Asian characters:
95
96           my $parser    = Spreadsheet::ParseExcel->new();
97           my $formatter = Spreadsheet::ParseExcel::FmtJapan->new();
98           my $workbook  = $parser->parse( 'Book1.xls', $formatter );
99
100       The Spreadsheet::ParseExcel::FmtJapan formatter also supports Unicode.
101       If you encounter any encoding problems with the default formatter try
102       that instead.
103
104   error()
105       The Parser error() method returns an error string if a parse() fails:
106
107           my $parser   = Spreadsheet::ParseExcel->new();
108           my $workbook = $parser->parse('Book1.xls');
109
110           if ( !defined $workbook ) {
111               die $parser->error(), ".\n";
112           }
113
114       If you wish to generate you own error string you can use the
115       error_code() method instead (see below). The error() and error_code()
116       values are as follows:
117
118           error()                         error_code()
119           =======                         ============
120           ''                              0
121           'File not found'                1
122           'No Excel data found in file'   2
123           'File is encrypted'             3
124
125       The error_code() method is explained below.
126
127       Spreadsheet::ParseExcel will try to decrypt an encrypted Excel file
128       using the default password or a user supplied password passed to new(),
129       see above. If these fail the module will return the 'File is encrypted'
130       error. Only the default Excel encryption scheme is currently supported,
131       see "Decryption".
132
133   error_code()
134       The Parser error_code() method returns an error code if a parse()
135       fails:
136
137           my $parser   = Spreadsheet::ParseExcel->new();
138           my $workbook = $parser->parse('Book1.xls');
139
140           if ( !defined $workbook ) {
141               die "Got error code ", $parser->error_code, ".\n";
142           }
143
144       This can be useful if you wish to employ you own error strings or error
145       handling methods.
146

Workbook

148       A "Spreadsheet::ParseExcel::Workbook" is created via the
149       "Spreadsheet::ParseExcel" parse() method:
150
151           my $parser   = Spreadsheet::ParseExcel->new();
152           my $workbook = $parser->parse('Book1.xls');
153
154       The main methods of the Workbook class are:
155
156           $workbook->worksheets()
157           $workbook->worksheet()
158           $workbook->worksheet_count()
159           $workbook->get_filename()
160
161       These more commonly used methods of the Workbook class are outlined
162       below. The other, less commonly used, methods are documented in
163       Spreadsheet::ParseExcel::Worksheet.
164
165   worksheets()
166       Returns an array of "Worksheet" objects. This was most commonly used to
167       iterate over the worksheets in a workbook:
168
169           for my $worksheet ( $workbook->worksheets() ) {
170               ...
171           }
172
173   worksheet()
174       The worksheet() method returns a single "Worksheet" object using either
175       its name or index:
176
177           $worksheet = $workbook->worksheet('Sheet1');
178           $worksheet = $workbook->worksheet(0);
179
180       Returns "undef" if the sheet name or index doesn't exist.
181
182   worksheet_count()
183       The worksheet_count() method returns the number of Worksheet objects in
184       the Workbook.
185
186           my $worksheet_count = $workbook->worksheet_count();
187
188   get_filename()
189       The get_filename() method returns the name of the Excel file of "undef"
190       if the data was read from a filehandle rather than a file.
191
192           my $filename = $workbook->get_filename();
193
194   Other Workbook Methods
195       For full documentation of the methods available via a Workbook object
196       see Spreadsheet::ParseExcel::Workbook.
197

Worksheet

199       The "Spreadsheet::ParseExcel::Worksheet" class encapsulates the
200       properties of an Excel worksheet.
201
202       A Worksheet object is obtained via the "worksheets()" or "worksheet()"
203       methods.
204
205           for my $worksheet ( $workbook->worksheets() ) {
206               ...
207           }
208
209           # Or:
210
211           $worksheet = $workbook->worksheet('Sheet1');
212           $worksheet = $workbook->worksheet(0);
213
214       The most commonly used methods of the Worksheet class are:
215
216           $worksheet->get_cell()
217           $worksheet->row_range()
218           $worksheet->col_range()
219           $worksheet->get_name()
220
221       The Spreadsheet::ParseExcel::Worksheet class exposes a lot of methods
222       but in general very few are required unless you are writing an advanced
223       filter.
224
225       The most commonly used methods are detailed below. The others are
226       documented in Spreadsheet::ParseExcel::Worksheet.
227
228   get_cell($row, $col)
229       Return the "Cell" object at row $row and column $col if it is defined.
230       Otherwise returns undef.
231
232           my $cell = $worksheet->get_cell($row, $col);
233
234   row_range()
235       Returns a two-element list "($min, $max)" containing the minimum and
236       maximum defined rows in the worksheet. If there is no row defined $max
237       is smaller than $min.
238
239           my ( $row_min, $row_max ) = $worksheet->row_range();
240
241   col_range()
242       Returns a two-element list "($min, $max)" containing the minimum and
243       maximum of defined columns in the worksheet. If there is no column
244       defined $max is smaller than $min.
245
246           my ( $col_min, $col_max ) = $worksheet->col_range();
247
248   get_name()
249       The get_name() method returns the name of the worksheet, such as
250       'Sheet1'.
251
252           my $name = $worksheet->get_name();
253
254   Other Worksheet Methods
255       For other, less commonly used, Worksheet methods see
256       Spreadsheet::ParseExcel::Worksheet.
257

Cell

259       The "Spreadsheet::ParseExcel::Cell" class has the following main
260       methods.
261
262           $cell->value()
263           $cell->unformatted()
264
265   value()
266       The value() method returns the formatted value of the cell.
267
268           my $value = $cell->value();
269
270       Formatted in this sense refers to the numeric format of the cell value.
271       For example a number such as 40177 might be formatted as 40,117,
272       40117.000 or even as the date 2009/12/30.
273
274       If the cell doesn't contain a numeric format then the formatted and
275       unformatted cell values are the same, see the unformatted() method
276       below.
277
278       For a defined $cell the value() method will always return a value.
279
280       In the case of a cell with formatting but no numeric or string contents
281       the method will return the empty string ''.
282
283   unformatted()
284       The unformatted() method returns the unformatted value of the cell.
285
286           my $unformatted = $cell->unformatted();
287
288       Returns the cell value without a numeric format. See the value() method
289       above.
290
291   Other Cell Methods
292       For other, less commonly used, Worksheet methods see
293       Spreadsheet::ParseExcel::Cell.
294

Format

296       The "Spreadsheet::ParseExcel::Format" class has the following
297       properties:
298
299   Format properties
300           $format->{Font}
301           $format->{AlignH}
302           $format->{AlignV}
303           $format->{Indent}
304           $format->{Wrap}
305           $format->{Shrink}
306           $format->{Rotate}
307           $format->{JustLast}
308           $format->{ReadDir}
309           $format->{BdrStyle}
310           $format->{BdrColor}
311           $format->{BdrDiag}
312           $format->{Fill}
313           $format->{Lock}
314           $format->{Hidden}
315           $format->{Style}
316
317       These properties are generally only of interest to advanced users.
318       Casual users can skip this section.
319
320   $format->{Font}
321       Returns the "Font" object for the Format.
322
323   $format->{AlignH}
324       Returns the horizontal alignment of the format where the value has the
325       following meaning:
326
327           0 => No alignment
328           1 => Left
329           2 => Center
330           3 => Right
331           4 => Fill
332           5 => Justify
333           6 => Center across
334           7 => Distributed/Equal spaced
335
336   $format->{AlignV}
337       Returns the vertical alignment of the format where the value has the
338       following meaning:
339
340           0 => Top
341           1 => Center
342           2 => Bottom
343           3 => Justify
344           4 => Distributed/Equal spaced
345
346   $format->{Indent}
347       Returns the indent level of the "Left" horizontal alignment.
348
349   $format->{Wrap}
350       Returns true if textwrap is on.
351
352   $format->{Shrink}
353       Returns true if "Shrink to fit" is set for the format.
354
355   $format->{Rotate}
356       Returns the text rotation. In Excel97+, it returns the angle in degrees
357       of the text rotation.
358
359       In Excel95 or earlier it returns a value as follows:
360
361           0 => No rotation
362           1 => Top down
363           2 => 90 degrees anti-clockwise,
364           3 => 90 clockwise
365
366   $format->{JustLast}
367       Return true if the "justify last" property is set for the format.
368
369   $format->{ReadDir}
370       Returns the direction that the text is read from.
371
372   $format->{BdrStyle}
373       Returns an array ref of border styles as follows:
374
375           [ $left, $right, $top, $bottom ]
376
377   $format->{BdrColor}
378       Returns an array ref of border color indexes as follows:
379
380           [ $left, $right, $top, $bottom ]
381
382   $format->{BdrDiag}
383       Returns an array ref of diagonal border kind, style and color index as
384       follows:
385
386           [$kind, $style, $color ]
387
388       Where kind is:
389
390           0 => None
391           1 => Right-Down
392           2 => Right-Up
393           3 => Both
394
395   $format->{Fill}
396       Returns an array ref of fill pattern and color indexes as follows:
397
398           [ $pattern, $front_color, $back_color ]
399
400   $format->{Lock}
401       Returns true if the cell is locked.
402
403   $format->{Hidden}
404       Returns true if the cell is Hidden.
405
406   $format->{Style}
407       Returns true if the format is a Style format.
408

Font

410       Spreadsheet::ParseExcel::Font
411
412       Format class has these properties:
413

Font Properties

415           $font->{Name}
416           $font->{Bold}
417           $font->{Italic}
418           $font->{Height}
419           $font->{Underline}
420           $font->{UnderlineStyle}
421           $font->{Color}
422           $font->{Strikeout}
423           $font->{Super}
424
425   $font->{Name}
426       Returns the name of the font, for example 'Arial'.
427
428   $font->{Bold}
429       Returns true if the font is bold.
430
431   $font->{Italic}
432       Returns true if the font is italic.
433
434   $font->{Height}
435       Returns the size (height) of the font.
436
437   $font->{Underline}
438       Returns true if the font in underlined.
439
440   $font->{UnderlineStyle}
441       Returns the style of an underlined font where the value has the
442       following meaning:
443
444            0 => None
445            1 => Single
446            2 => Double
447           33 => Single accounting
448           34 => Double accounting
449
450   $font->{Color}
451       Returns the color index for the font. The mapping to an RGB color is
452       defined by each workbook.
453
454       The index can be converted to a RGB string using the
455       "$workbook-"ColorIdxToRGB()> Parser method.
456
457       (Older versions of "Spreadsheet::ParseExcel" provided the
458       "ColorIdxToRGB" class method, which is deprecated.)
459
460   $font->{Strikeout}
461       Returns true if the font has the strikeout property set.
462
463   $font->{Super}
464       Returns one of the following values if the superscript or subscript
465       property of the font is set:
466
467           0 => None
468           1 => Superscript
469           2 => Subscript
470

Formatter Class

472       Formatters can be passed to the parse() method to deal with Unicode or
473       Asian formatting.
474
475       Spreadsheet::ParseExcel includes 2 formatter classes. "FmtDefault" and
476       "FmtJapanese". It is also possible to create a user defined formatting
477       class.
478
479       The formatter class "Spreadsheet::ParseExcel::Fmt*" should provide the
480       following functions:
481
482   ChkType($self, $is_numeric, $format_index)
483       Method to check the type of data in the cell. Should return "Date",
484       "Numeric" or "Text". It is passed the following parameters:
485
486       $self
487           A scalar reference to the Formatter object.
488
489       $is_numeric
490           If true, the value seems to be number.
491
492       $format_index
493           The index number for the cell Format object.
494
495   TextFmt($self, $string_data, $string_encoding)
496       Converts the string data in the cell into the correct encoding.  It is
497       passed the following parameters:
498
499       $self
500           A scalar reference to the Formatter object.
501
502       $string_data
503           The original string/text data.
504
505       $string_encoding
506           The character encoding of original string/text.
507
508   ValFmt($self, $cell, $workbook)
509       Convert the original unformatted cell value into the appropriate
510       formatted value. For instance turn a number into a formatted date.  It
511       is passed the following parameters:
512
513       $self
514           A scalar reference to the Formatter object.
515
516       $cell
517           A scalar reference to the Cell object.
518
519       $workbook
520           A scalar reference to the Workbook object.
521
522   FmtString($self, $cell, $workbook)
523       Get the format string for the Cell.  It is passed the following
524       parameters:
525
526       $self
527           A scalar reference to the Formatter object.
528
529       $cell
530           A scalar reference to the Cell object.
531
532       $workbook
533           A scalar reference to the Workbook object.
534

Reducing the memory usage of Spreadsheet::ParseExcel

536       In some cases a "Spreadsheet::ParseExcel" application may consume a lot
537       of memory when processing a large Excel file and, as a result, may fail
538       to complete. The following explains why this can occur and how to
539       resolve it.
540
541       "Spreadsheet::ParseExcel" processes an Excel file in two stages. In the
542       first stage it extracts the Excel binary stream from the OLE container
543       file using "OLE::Storage_Lite". In the second stage it parses the
544       binary stream to read workbook, worksheet and cell data which it then
545       stores in memory. The majority of the memory usage is required for
546       storing cell data.
547
548       The reason for this is that as the Excel file is parsed and each cell
549       is encountered a cell handling function creates a relatively large
550       nested cell object that contains the cell value and all of the data
551       that relates to the cell formatting. For large files (a 10MB Excel file
552       on a 256MB system) this overhead can cause the system to grind to a
553       halt.
554
555       However, in a lot of cases when an Excel file is being processed the
556       only information that is required are the cell values. In these cases
557       it is possible to avoid most of the memory overhead by specifying your
558       own cell handling function and by telling Spreadsheet::ParseExcel not
559       to store the parsed cell data. This is achieved by passing a cell
560       handler function to new() when creating the parse object. Here is an
561       example.
562
563           #!/usr/bin/perl -w
564
565           use strict;
566           use Spreadsheet::ParseExcel;
567
568           my $parser = Spreadsheet::ParseExcel->new(
569               CellHandler => \&cell_handler,
570               NotSetCell  => 1
571           );
572
573           my $workbook = $parser->parse('file.xls');
574
575           sub cell_handler {
576
577               my $workbook    = $_[0];
578               my $sheet_index = $_[1];
579               my $row         = $_[2];
580               my $col         = $_[3];
581               my $cell        = $_[4];
582
583               # Do something useful with the formatted cell value
584               print $cell->value(), "\n";
585
586           }
587
588       The user specified cell handler is passed as a code reference to new()
589       along with the parameter "NotSetCell" which tells
590       Spreadsheet::ParseExcel not to store the parsed cell. Note, you don't
591       have to iterate over the rows and columns, this happens automatically
592       as part of the parsing.
593
594       The cell handler is passed 5 arguments. The first, $workbook, is a
595       reference to the "Spreadsheet::ParseExcel::Workbook" object that
596       represent the parsed workbook. This can be used to access any of the
597       "Spreadsheet::ParseExcel::Workbook" methods, see "Workbook". The second
598       $sheet_index is the zero-based index of the worksheet being parsed. The
599       third and fourth, $row and $col, are the zero-based row and column
600       number of the cell. The fifth, $cell, is a reference to the
601       "Spreadsheet::ParseExcel::Cell" object. This is used to extract the
602       data from the cell. See "Cell" for more information.
603
604       This technique can be useful if you are writing an Excel to database
605       filter since you can put your DB calls in the cell handler.
606
607       If you don't want all of the data in the spreadsheet you can add some
608       control logic to the cell handler. For example we can extend the
609       previous example so that it only prints the first 10 rows of the first
610       two worksheets in the parsed workbook by adding some if() statements to
611       the cell handler:
612
613           #!/usr/bin/perl -w
614
615           use strict;
616           use Spreadsheet::ParseExcel;
617
618           my $parser = Spreadsheet::ParseExcel->new(
619               CellHandler => \&cell_handler,
620               NotSetCell  => 1
621           );
622
623           my $workbook = $parser->parse('file.xls');
624
625           sub cell_handler {
626
627               my $workbook    = $_[0];
628               my $sheet_index = $_[1];
629               my $row         = $_[2];
630               my $col         = $_[3];
631               my $cell        = $_[4];
632
633               # Skip some worksheets and rows (inefficiently).
634               return if $sheet_index >= 3;
635               return if $row >= 10;
636
637               # Do something with the formatted cell value
638               print $cell->value(), "\n";
639
640           }
641
642       However, this still processes the entire workbook. If you wish to save
643       some additional processing time you can abort the parsing after you
644       have read the data that you want, using the workbook "ParseAbort"
645       method:
646
647           #!/usr/bin/perl -w
648
649           use strict;
650           use Spreadsheet::ParseExcel;
651
652           my $parser = Spreadsheet::ParseExcel->new(
653               CellHandler => \&cell_handler,
654               NotSetCell  => 1
655           );
656
657           my $workbook = $parser->parse('file.xls');
658
659           sub cell_handler {
660
661               my $workbook    = $_[0];
662               my $sheet_index = $_[1];
663               my $row         = $_[2];
664               my $col         = $_[3];
665               my $cell        = $_[4];
666
667               # Skip some worksheets and rows (more efficiently).
668               if ( $sheet_index >= 1 and $row >= 10 ) {
669                   $workbook->ParseAbort(1);
670                   return;
671               }
672
673               # Do something with the formatted cell value
674               print $cell->value(), "\n";
675
676           }
677

Decryption

679       If a workbook is "protected" then Excel will encrypt the file whether a
680       password is supplied or not. As of version 0.59 Spreadsheet::ParseExcel
681       supports decrypting Excel workbooks using a default or user supplied
682       password. However, only the following encryption scheme is supported:
683
684           Office 97/2000 Compatible encryption
685
686       The following encryption methods are not supported:
687
688           Weak Encryption (XOR)
689           RC4, Microsoft Base Cryptographic Provider v1.0
690           RC4, Microsoft Base DSS and Diffie-Hellman Cryptographic Provider
691           RC4, Microsoft DH SChannel Cryptographic Provider
692           RC4, Microsoft Enhanced Cryptographic Provider v1.0
693           RC4, Microsoft Enhanced DSS and Diffie-Hellman Cryptographic Provider
694           RC4, Microsoft Enhanced RSA and AES Cryptographic Provider
695           RC4, Microsoft RSA SChannel Cryptographic Provider
696           RC4, Microsoft Strong Cryptographic Provider
697
698       See the following for more information on Excel encryption:
699       <http://office.microsoft.com/en-us/office-2003-resource-kit/important-aspects-of-password-and-encryption-protection-HA001140311.aspx>.
700

KNOWN PROBLEMS

702       •   Issues reported by users:
703           <http://rt.cpan.org/Public/Dist/Display.html?Name=Spreadsheet-ParseExcel>
704
705       •   This module cannot read the values of formulas from files created
706           with Spreadsheet::WriteExcel unless the user specified the values
707           when creating the file (which is generally not the case). The
708           reason for this is that Spreadsheet::WriteExcel writes the formula
709           but not the formula result since it isn't in a position to
710           calculate arbitrary Excel formulas without access to Excel's
711           formula engine.
712
713       •   If Excel has date fields where the specified format is equal to the
714           system-default for the short-date locale, Excel does not store the
715           format, but defaults to an internal format which is system
716           dependent. In these cases ParseExcel uses the date format
717           'yyyy-mm-dd'.
718

REPORTING A BUG

720       Bugs can be reported via rt.cpan.org. See the following for
721       instructions on bug reporting for Spreadsheet::ParseExcel
722
723       <http://rt.cpan.org/Public/Dist/Display.html?Name=Spreadsheet-ParseExcel>
724

MAILING LIST

771       There is a Google group for discussing and asking questions about
772       Spreadsheet::ParseExcel. This is a good place to search to see if your
773       question has been asked before:
774       <http://groups-beta.google.com/group/spreadsheet-parseexcel/>
775

DONATIONS

777       If you'd care to donate to the Spreadsheet::ParseExcel project, you can
778       do so via PayPal: <http://tinyurl.com/7ayes>
779

TODO

781       •   The current maintenance work is directed towards making the
782           documentation more useful, improving and simplifying the API, and
783           improving the maintainability of the code base. After that new
784           features will be added.
785
786       •   Fix open bugs and documentation for SaveParser.
787
788       •   Add Formula support, Hyperlink support, Named Range support.
789
790       •   Improve Spreadsheet::ParseExcel::SaveParser compatibility with
791           Spreadsheet::WriteExcel.
792
793       •   Improve Unicode and other encoding support. This will probably
794           require dropping support for perls prior to 5.8+.
795

ACKNOWLEDGEMENTS

797       From Kawai Takanori:
798
799       First of all, I would like to acknowledge the following valuable
800       programs and modules: XHTML, OLE::Storage and Spreadsheet::WriteExcel.
801
802       In no particular order: Yamaji Haruna, Simamoto Takesi, Noguchi Harumi,
803       Ikezawa Kazuhiro, Suwazono Shugo, Hirofumi Morisada, Michael Edwards,
804       Kim Namusk, Slaven Rezic, Grant Stevens, H.Merijn Brand and many many
805       people + Kawai Mikako.
806
807       Alexey Mazurin added the decryption facility.
808

DISCLAIMER OF WARRANTY

810       Because this software is licensed free of charge, there is no warranty
811       for the software, to the extent permitted by applicable law. Except
812       when otherwise stated in writing the copyright holders and/or other
813       parties provide the software "as is" without warranty of any kind,
814       either expressed or implied, including, but not limited to, the implied
815       warranties of merchantability and fitness for a particular purpose. The
816       entire risk as to the quality and performance of the software is with
817       you. Should the software prove defective, you assume the cost of all
818       necessary servicing, repair, or correction.
819
820       In no event unless required by applicable law or agreed to in writing
821       will any copyright holder, or any other party who may modify and/or
822       redistribute the software as permitted by the above licence, be liable
823       to you for damages, including any general, special, incidental, or
824       consequential damages arising out of the use or inability to use the
825       software (including but not limited to loss of data or data being
826       rendered inaccurate or losses sustained by you or third parties or a
827       failure of the software to operate with any other software), even if
828       such holder or other party has been advised of the possibility of such
829       damages.
830

LICENSE

832       Either the Perl Artistic Licence
833       <http://dev.perl.org/licenses/artistic.html> or the GPL
834       <http://www.opensource.org/licenses/gpl-license.php>
835

AUTHOR

837       Current maintainer 0.60+: Douglas Wilson dougw@cpan.org
838
839       Maintainer 0.40-0.59: John McNamara jmcnamara@cpan.org
840
841       Maintainer 0.27-0.33: Gabor Szabo szabgab@cpan.org
842
843       Original author: Kawai Takanori (Hippo2000) kwitknr@cpan.org
844

COPYRIGHT

846       Copyright (c) 2014 Douglas Wilson
847
848       Copyright (c) 2009-2013 John McNamara
849
850       Copyright (c) 2006-2008 Gabor Szabo
851
852       Copyright (c) 2000-2006 Kawai Takanori
853
854       All rights reserved. This is free software. You may distribute under
855       the terms of either the GNU General Public License or the Artistic
856       License.
857
858
859
860perl v5.36.0                      2023-01-20        Spreadsheet::ParseExcel(3)