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
80       should 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()"
106       fails:
107
108           my $parser   = Spreadsheet::ParseExcel->new();
109           my $workbook = $parser->parse('Book1.xls');
110
111           if ( !defined $workbook ) {
112               die $parser->error(), ".\n";
113           }
114
115       If you wish to generate you own error string you can use the
116       "error_code()" method instead (see below). The "error()" and
117       "error_code()" values are as follows:
118
119           error()                         error_code()
120           =======                         ============
121           ''                              0
122           'File not found'                1
123           'No Excel data found in file'   2
124           'File is encrypted'             3
125
126       The "error_code()" method is explained below.
127
128       Spreadsheet::ParseExcel will try to decrypt an encrypted Excel file
129       using the default password or a user supplied password passed to
130       "new()", see above. If these fail the module will return the 'File is
131       encrypted' error. Only the default Excel encryption scheme is currently
132       supported, see "Decryption".
133
134   error_code()
135       The Parser "error_code()" method returns an error code if a "parse()"
136       fails:
137
138           my $parser   = Spreadsheet::ParseExcel->new();
139           my $workbook = $parser->parse('Book1.xls');
140
141           if ( !defined $workbook ) {
142               die "Got error code ", $parser->error_code, ".\n";
143           }
144
145       This can be useful if you wish to employ you own error strings or error
146       handling methods.
147

Workbook

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

Worksheet

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

Cell

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

Format

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

Font

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

Font Properties

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

Formatter Class

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

Reducing the memory usage of Spreadsheet::ParseExcel

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

Decryption

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

KNOWN PROBLEMS

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

REPORTING A BUG

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

MAILING LIST

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

DONATIONS

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

TODO

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

ACKNOWLEDGEMENTS

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

DISCLAIMER OF WARRANTY

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

LICENSE

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

AUTHOR

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

COPYRIGHT

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