Text-CSV_XS-1.26/0000755000031300001440000000000013017540445014131 5ustar00merijnusers00000000000000Text-CSV_XS-1.26/examples/0000755000031300001440000000000013017540444015746 5ustar00merijnusers00000000000000Text-CSV_XS-1.26/examples/parser-xs.pl0000755000031300001440000000365612753265122020247 0ustar00merijnusers00000000000000#!/pro/bin/perl # This script can be used as a base to parse unreliable CSV streams # Modify to your own needs # # (m)'08 [23 Apr 2008] Copyright H.M.Brand 2008-2016 use strict; use warnings; use Text::CSV_XS; my $csv = Text::CSV_XS->new ({ binary => 1, blank_is_undef => 1, eol => $/, }); my $csa = Text::CSV_XS->new ({ binary => 1, allow_loose_quotes => 1, blank_is_undef => 1, escape_char => undef, }); my $file = @ARGV ? shift : "test.csv"; open my $fh, "<", $file or die "$file: $!\n"; my %err_eol = map { $_ => 1 } 2010, 2027, 2031, 2032; print STDERR "Reading $file with Text::CSV_XS $Text::CSV_XS::VERSION\n"; while (1) { my $row = $csv->getline ($fh); unless ($row) { # Parsing failed # Could be end of file $csv->eof and last; # Diagnose and show what was wrong my @diag = $csv->error_diag; print STDERR "$file line $./$diag[2] - $diag[0] - $diag[1]\n"; my $ep = $diag[2] - 1; # diag[2] is 1-based my $ein = $csv->error_input; # The line scanned so far my $err = $ein . " "; substr $err, $ep + 1, 0, "*"; # Bad character marked between ** substr $err, $ep, 0, "*"; ($err = substr $err, $ep - 5, 12) =~ s/ +$//; print STDERR " |$err|\n"; REPARSE: { # Now retry with allowed options if ($csa->parse ($ein)) { print STDERR "Accepted in allow mode ...\n"; $row = [ $csa->fields ]; } else { # Still fails my @diag = $csa->error_diag; if (exists $err_eol{$diag[0]}) { # \r or \n inside field print STDERR " Extending line with next chunk\n"; $ein .= scalar <$fh>; goto REPARSE; } print STDERR " Also could not parse it in allow mode\n"; print STDERR " $./$diag[2] - $diag[0] - $diag[1]\n"; print STDERR " Line skipped\n"; next; } } } # Data was fine, print data properly quoted $csv->print (*STDOUT, $row); } Text-CSV_XS-1.26/examples/speed.pl0000755000031300001440000000517012753265122017414 0ustar00merijnusers00000000000000#!/usr/bin/perl -w # speed.pl: compare different versions of Text-CSV* modules # (m)'08 [07 Apr 2008] Copyright H.M.Brand 2007-2016 require 5.006001; use strict; use IO::Handle; use Text::CSV_XS; use Benchmark "timethese"; eval { Benchmark->import (":hireswallclock"); }; our $csv = Text::CSV_XS->new ({ eol => "\n" }); my $duration = int (shift || 2); my @fields = ( "Holmes", "Sherlock", "Baker street", 221, "B", 72555, "London", "NW1 6XE", "United Kingdom", "+44 7123 84567", "sherlock\@holmes,co.uk"); our @fields1 = (@fields) x 1; our @fields10 = (@fields) x 10; our @fields100 = (@fields) x 100; $csv->combine (@fields1 ); our $str1 = $csv->string; $csv->combine (@fields10 ); our $str10 = $csv->string; $csv->combine (@fields100); our $str100 = $csv->string; timethese (-1.5,{ "combine 1" => q{ $csv->combine (@fields1 ) }, "combine 10" => q{ $csv->combine (@fields10 ) }, "combine 100" => q{ $csv->combine (@fields100) }, "parse 1" => q{ $csv->parse ($str1 ) }, "parse 10" => q{ $csv->parse ($str10 ) }, "parse 100" => q{ $csv->parse ($str100 ) }, }); sub max { $_[0] >= $_[1] ? $_[0] : $_[1] } my $line_count = max (200_000, 20_000 * $duration); our $io; my $mem = ""; my $bigfile = "_file.csv"; if ($] >= 5.010) { eval "use Sys::MemInfo qw( freemem );"; unless ($@) { my $need = $line_count * (1 + length $str10); if (freemem () > $need) { $mem = ""; open $io, ">", \$mem; } } } $io or open $io, ">", $bigfile; $csv->print ($io, \@fields10) or die "Cannot print ()\n"; timethese ($line_count, { "print io" => q{ $csv->print ($io, \@fields10) }}); close $io; my $l = $mem ? length ($mem) : -s $bigfile; $l or die "Buffer/file is empty!\n"; my @f = @fields10; $csv->can ("bind_columns") and $csv->bind_columns (\(@f)); open $io, "<", ($mem ? \$mem : $bigfile); timethese ($line_count, { "getline io" => q{ my $ref = $csv->getline ($io) }}); close $io; print "Data was $l bytes long, line length ", length ($str10), "\n"; $mem or unlink $bigfile; __END__ # The examples from the docs { $csv = Text::CSV_XS->new ({ keep_meta_info => 1, binary => 1 }); my $sample_input_string = qq{"I said, ""Hi!""",Yes,"",2.34,,"1.09","\x{20ac}",}; if ($csv->parse ($sample_input_string)) { my @field = $csv->fields; foreach my $col (0 .. $#field) { my $quo = $csv->is_quoted ($col) ? $csv->{quote_char} : ""; printf "%2d: %s%s%s\n", $col, $quo, $field[$col], $quo; } } else { my $err = $csv->error_input; print "parse () failed on argument: ", $err, "\n"; } } Text-CSV_XS-1.26/examples/rewrite.pl0000755000031300001440000000210113015116344017755 0ustar00merijnusers00000000000000#!/pro/bin/perl use strict; use warnings; sub usage { my $err = shift and select STDERR; print "usage: $0 [--ms] [--confuse] [--invisible]\n"; exit $err; } # usage use Getopt::Long qw(:config bundling); GetOptions ( "help|?" => sub { usage (0); }, "s|sep=s" => \my $in_sep, "m|ms!" => \my $ms, "c|confuse!" => \my $confuse, "i|invisible!" => \my $invis, ) or usage (1); $invis and $confuse++; use Text::CSV_XS qw( csv ); # U+0022 " QUOTATION MARK " # U+002c , COMMA , # U+037e ; GREEK QUESTION MARK ; # U+201a ‚ SINGLE LOW-9 QUOTATION MARK , # U+2033 ″ DOUBLE PRIME " # U+2063 INVISIBLE SEPARATOR my $io = shift || \*DATA; my $eol = $ms ? "\r\n" : "\n"; my $sep = $confuse ? $ms ? "\x{037e}" : $invis ? "\x{2063}" : "\x{201a}" : $ms ? ";" : ","; my $quo = $confuse ? "\x{2033}" : '"'; binmode STDOUT, ":encoding(utf-8)"; csv (in => csv (in => $io, sep => $in_sep // ";"), out => \*STDOUT, eol => $eol, sep => $sep, quo => $quo); __END__ a;b;c;d;e;f 1;2;3;4;5;6 2;3;4;5;6;7 3;4;5;6;7;8 4;5;6;7;8;9 Text-CSV_XS-1.26/examples/csv2xls0000755000031300001440000001446712753265122017317 0ustar00merijnusers00000000000000#!/pro/bin/perl # csv2xls: Convert csv to xls # (m)'16 [17 May 2016] Copyright H.M.Brand 2007-2016 use strict; use warnings; our $VERSION = "1.76"; sub usage { my $err = shift and select STDERR; print <] [-q ] [-w ] [-d ] [-o ] [file.csv] -s use as seperator char, auto-detect, default = ',' The string "tab" is allowed. -e use as escape char, auto-detect, default = '"' The string "undef" is allowed. -q use as quotation char, default = '"' The string "undef" will disable quotation. -w use as default minimum column width default = 4 -o write output to file named , defaults to input file name with .csv replaced with .xls if from standard input, defaults to csv2xls.xls -F allow formula's. Otherwise fields starting with an equal sign are forced to string -f force usage of if already exists (unlink before use) -d use as date formats. Default = 'dd-mm-yyyy' -C use as currency formats for currency , no default -D cols only convert dates in columns . Default is everywhere. -u CSV is UTF8 -v [] verbosity (default = 1) EOU exit $err; } # usage use Getopt::Long qw(:config bundling nopermute passthrough); my $sep; # Set after reading first line in a flurry attempt to auto-detect my $quo = '"'; my $esc = '"'; my $wdt = 4; # Default minimal column width my $xls; # Excel out file name my $frc = 0; # Force use of file my $utf = 0; # Data is encoded in Unicode my $frm = 0; # Allow formula's my $dtf = "dd-mm-yyyy"; # Date format my $crf = ""; # Currency format, e.g.: $:### ### ##0.00 my $opt_v = 1; my $dtc; GetOptions ( "help|?" => sub { usage (0); }, "c|s=s" => \$sep, "q=s" => \$quo, "e=s" => \$esc, "w=i" => \$wdt, "o|x=s" => \$xls, "d=s" => \$dtf, "D=s" => \$dtc, "C=s" => \$crf, "f" => \$frc, "F" => \$frm, "u" => \$utf, "v:1" => \$opt_v, ) or usage (1); my $title = @ARGV && -f $ARGV[0] ? $ARGV[0] : "csv2xls"; ($xls ||= $title) =~ s/(?:\.csv)?$/.xls/i; -s $xls && $frc and unlink $xls; if (-s $xls) { print STDERR "File '$xls' already exists. Overwrite? [y/N] > N\b"; scalar =~ m/^[yj](es|a)?$/i or exit; } # Don't split ourselves when modules do it _much_ better, and follow the standards use Text::CSV_XS; use Date::Calc qw( Delta_Days Days_in_Month ); use Spreadsheet::WriteExcel; use Encode qw( from_to ); my $wbk = Spreadsheet::WriteExcel->new ($xls); my $wks = $wbk->add_worksheet (); $dtf =~ s/j/y/g; my %fmt = ( date => $wbk->add_format (align => "center", num_format => $dtf), rest => $wbk->add_format (align => "left"), wrap => $wbk->add_format (text_wrap => 1), ); $crf =~ s/^([^:]+):(.*)/$1/ and $fmt{currency} = $wbk->add_format ( num_format => "$1 $2", align => "right", ); my ($h, $w, @w) = (0, 1); # data height, -width, and default column widths my $row; my $firstline; unless ($sep) { # No sep char passed, try to auto-detect; while (<>) { m/\S/ or next; # Skip empty leading blank lines $sep = # start auto-detect with quoted strings m/["\d];["\d;]/ ? ";" : m/["\d],["\d,]/ ? "," : m/["\d]\t["\d,]/ ? "\t" : # If neither, then for unquoted strings m/\w;[\w;]/ ? ";" : m/\w,[\w,]/ ? "," : m/\w\t[\w,]/ ? "\t" : ";" ; # Yeah I know it should be a ',' (hence Csv), but the majority # of the csv files to be shown comes from fucking Micky$hit, # that uses semiColon ';' instead. $firstline = $_; last; } } my $csv = Text::CSV_XS-> new ({ sep_char => $sep eq "tab" ? "\t" : $sep, quote_char => $quo eq "undef" ? undef : $quo, escape_char => $esc eq "undef" ? undef : $esc, binary => 1, keep_meta_info => 1, auto_diag => 1, }); if ($firstline) { $csv->parse ($firstline) or die $csv->error_diag (); $row = [ $csv->fields ]; } if ($opt_v > 3) { foreach my $k (qw( sep_char quote_char escape_char )) { my $c = $csv->$k () || "undef"; $c =~ s/\t/\\t/g; $c =~ s/\r/\\r/g; $c =~ s/\n/\\n/g; $c =~ s/\0/\\0/g; $c =~ s/([\x00-\x1f\x7f-\xff])/sprintf"\\x{%02x}",ord$1/ge; printf STDERR "%-11s = %s\n", $k, $c; } } if (my $rows = $dtc) { $rows =~ s/-$/-999/; # 3,6- $rows =~ s/-/../g; eval "\$dtc = { map { \$_ => 1 } $rows }"; } while ($row && @$row or $row = $csv->getline (*ARGV)) { my @row = @$row; @row > $w and push @w, ($wdt) x (($w = @row) - @w); foreach my $c (0 .. $#row) { my $val = $row[$c] // ""; my $l = length $val; $l > ($w[$c] // -1) and $w[$c] = $l; if ($utf and $csv->is_binary ($c)) { from_to ($val, "utf-8", "ucs2"); $wks->write_unicode ($h, $c, $val); next; } if ($csv->is_quoted ($c)) { if ($utf) { from_to ($val, "utf-8", "ucs2"); $val =~ m/\n/ ? $wks->write_unicode ($h, $c, $val, $fmt{wrap}) : $wks->write_unicode ($h, $c, $val); } else { $val =~ m/\n/ ? $wks->write_string ($h, $c, $val, $fmt{wrap}) : $wks->write_string ($h, $c, $val); } next; } if (!$dtc or $dtc->{$c + 1}) { my @d = (0, 0, 0); # Y, M, D $val =~ m/^(\d{4})(\d{2})(\d{2})$/ and @d = ($1, $2, $3); $val =~ m/^(\d{2})-(\d{2})-(\d{4})$/ and @d = ($3, $2, $1); if ( $d[2] >= 1 && $d[2] <= 31 && $d[1] >= 1 && $d[1] <= 12 && $d[0] >= 1900 && $d[0] <= 2199) { my $dm = Days_in_Month (@d[0,1]); $d[2] < 1 and $d[2] = 1; $d[2] > $dm and $d[2] = $dm; my $dt = 2 + Delta_Days (1900, 1, 1, @d); $wks->write ($h, $c, $dt, $fmt{date}); next; } } if ($crf and $val =~ m/^\s*\Q$crf\E\s*([0-9.]+)$/) { $wks->write ($h, $c, $1 + 0, $fmt{currency}); next; } if (!$frm && $val =~ m/^=/) { $wks->write_string ($h, $c, $val); } else { $wks->write ($h, $c, $val); } } ++$h % 100 or $opt_v && printf STDERR "%6d x %6d\r", $w, $h; } continue { $row = undef } $opt_v && printf STDERR "%6d x %6d\n", $w, $h; $wks->set_column ($_, $_, $w[$_]) for 0 .. $#w; $wbk->close (); Text-CSV_XS-1.26/examples/csv2xlsx0000755000031300001440000001626512753265122017505 0ustar00merijnusers00000000000000#!/pro/bin/perl # csv2xlsx: Convert csv to xlsx # (m)'16 [06 Jun 2016] Copyright H.M.Brand 2007-2016 use 5.14.0; use warnings; our $VERSION = "1.01"; sub usage { my $err = shift and select STDERR; print <] [-q ] [-w ] [-d ] [-o ] [file.csv] -s use as seperator char, auto-detect, default = ',' The string "tab" is allowed. -e use as escape char, auto-detect, default = '"' The string "undef" is allowed. -q use as quotation char, default = '"' The string "undef" will disable quotation. -w use as default minimum column width default = 4 -o write output to file named , defaults to input file name with .csv replaced with .xlsx if from standard input, defaults to csv2xlsx.xlsx -F allow formula's. Otherwise fields starting with an equal sign are forced to string -f force usage of if already exists (unlink before use) -d use as date formats. Default = 'dd-mm-yyyy' -C use as currency formats for currency , no default -D cols only convert dates in columns . Default is everywhere. -u CSV is UTF8 -m merge multiple CSV's into a single xlsx (separate sheets) -o is required, all arguments should be existing files -v [] verbosity (default = 1) EOU exit $err; } # usage use Getopt::Long qw(:config bundling passthrough); my $quo = '"'; my $esc = '"'; my $wdt = 4; # Default minimal column width my $dtf = "dd-mm-yyyy"; # Date format my $crf = ""; # Currency format, e.g.: $:### ### ##0.00 my $opt_v = 1; my $dtc; GetOptions ( "help|?" => sub { usage (0); }, "V|version" => sub { say $0 =~ s{.*/}{}r, " [$VERSION]"; exit 0; }, "c|s|sep=s" => \my $sep, # Set after reading first line in attempt to auto-detect "q|quo=s" => \$quo, "e|esc=s" => \$esc, "w|width=i" => \$wdt, "o|x|out=s" => \my $xls, "d|date-fmt=s" => \$dtf, "D|date-col=s" => \$dtc, "C|curr-fmt=s" => \$crf, "f|force!" => \my $frc, "F|formulas!" => \my $frm, "u|utf-8|utf8!" => \my $utf, "m|merge!" => \my $mrg, "v|verbose:1" => \$opt_v, ) or usage (1); if ($mrg) { my @csv; for (@ARGV) { if (m/\.xlsx?$/i) { $xls and usage (1); $xls = $_; next; } if (m/\.csv$/i && -s $_) { push @csv, $_; next; } warn "Argument $_ is not an existing (CSV) file\n"; usage (1); } $xls && @csv or usage (1); @ARGV = @csv; } my $base //= @ARGV && -f $ARGV[0] ? $ARGV[0] : "csv2xlsx"; $xls ||= $base =~ s/(?:\.csv)?$/.xlsx/ir; -s $xls && $frc and unlink $xls; if (-s $xls) { print STDERR "File '$xls' already exists. Overwrite? [y/N] > N\b"; scalar =~ m/^[yj](es|a)?$/i or exit; } # Don't split ourselves when modules do it _much_ better, and follow the standards use Text::CSV_XS; use Date::Calc qw( Delta_Days Days_in_Month ); use Excel::Writer::XLSX; use Encode qw( from_to ); my $wbk = Excel::Writer::XLSX->new ($xls); $dtf =~ s/j/y/g; my %fmt = ( date => $wbk->add_format (align => "center", num_format => $dtf), rest => $wbk->add_format (align => "left"), wrap => $wbk->add_format (text_wrap => 1), ); $crf =~ s/^([^:]+):(.*)/$1/ and $fmt{currency} = $wbk->add_format ( num_format => "$1 $2", align => "right", ); my @args = @ARGV ? @ARGV : (""); foreach my $csvf (@args) { my $wks = $wbk->add_worksheet ($csvf =~ s{\.csv$}{}ir || "Sheet 1"); my ($h, $w, @w) = (0, 1); # data height, -width, and default column widths my $row; my $firstline; my $fh; if (-f $csvf) { $opt_v and say "Reading $csvf"; open $fh, "<", $csvf or die "$csvf: $!\n"; } else { $opt_v and say "Reading STDIN"; $fh = *ARGV; } my $Sep = $sep; unless ($Sep) { # No sep char passed, try to auto-detect; while (<$fh>) { m/\S/ or next; # Skip empty leading blank lines $Sep = # start auto-detect with quoted strings m/["\d];["\d;]/ ? ";" : m/["\d],["\d,]/ ? "," : m/["\d]\t["\d,]/ ? "\t" : # If neither, then for unquoted strings m/\w;[\w;]/ ? ";" : m/\w,[\w,]/ ? "," : m/\w\t[\w,]/ ? "\t" : # And pipes (lowest prio) m/["\d]\|["\d,]/ ? "|" : m/\w\|[\w,]/ ? "|" : m/,/ && !m/[;\t]/ ? "," : m/;/ && !m/[,\t]/ ? ";" : m/\t/ && !m/[,;]/ ? "\t" : "," ; $firstline = $_; last; } } my $csv = Text::CSV_XS-> new ({ sep_char => $Sep eq "tab" ? "\t" : $Sep, quote_char => $quo eq "undef" ? undef : $quo, escape_char => $esc eq "undef" ? undef : $esc, binary => 1, keep_meta_info => 1, auto_diag => 1, }); if ($firstline) { $csv->parse ($firstline) or die $csv->error_diag (); $row = [ $csv->fields ]; } if ($opt_v > 3) { foreach my $k (qw( sep_char quote_char escape_char )) { my $c = $csv->$k () || "undef"; $c =~ s/\t/\\t/g; $c =~ s/\r/\\r/g; $c =~ s/\n/\\n/g; $c =~ s/\0/\\0/g; $c =~ s/([\x00-\x1f\x7f-\xff])/sprintf"\\x{%02x}",ord$1/ge; printf STDERR "%-11s = %s\n", $k, $c; } } if (my $rows = $dtc) { $rows =~ s/-$/-999/; # 3,6- $rows =~ s/-/../g; eval "\$dtc = { map { \$_ => 1 } $rows }"; } while ($row && @$row or $row = $csv->getline ($fh)) { my @row = @$row; @row > $w and push @w, ($wdt) x (($w = @row) - @w); foreach my $c (0 .. $#row) { my $val = $row[$c] // ""; my $l = length $val; $l > ($w[$c] // -1) and $w[$c] = $l; if ($utf and $csv->is_binary ($c)) { from_to ($val, "utf-8", "ucs2"); $wks->write_unicode ($h, $c, $val); next; } if ($csv->is_quoted ($c)) { $val =~ s/\r\n/\n/g; if ($utf) { from_to ($val, "utf-8", "ucs2"); $val =~ m/\n/ ? $wks->write_unicode ($h, $c, $val, $fmt{wrap}) : $wks->write_unicode ($h, $c, $val); } else { $val =~ m/\n/ ? $wks->write_string ($h, $c, $val, $fmt{wrap}) : $wks->write_string ($h, $c, $val); } next; } if (!$dtc or $dtc->{$c + 1}) { my @d = (0, 0, 0); # Y, M, D $val =~ m/^(\d{4})(\d{2})(\d{2})$/ and @d = ($1, $2, $3); $val =~ m/^(\d{2})-(\d{2})-(\d{4})$/ and @d = ($3, $2, $1); if ( $d[2] >= 1 && $d[2] <= 31 && $d[1] >= 1 && $d[1] <= 12 && $d[0] >= 1900 && $d[0] <= 2199) { my $dm = Days_in_Month (@d[0,1]); $d[2] < 1 and $d[2] = 1; $d[2] > $dm and $d[2] = $dm; my $dt = 2 + Delta_Days (1900, 1, 1, @d); $wks->write ($h, $c, $dt, $fmt{date}); next; } } if ($crf and $val =~ m/^\s*\Q$crf\E\s*([0-9.]+)$/) { $wks->write ($h, $c, $1 + 0, $fmt{currency}); next; } if (!$frm && $val =~ m/^=/) { $wks->write_string ($h, $c, $val); } else { $wks->write ($h, $c, $val); } } ++$h % 100 or $opt_v && printf STDERR "%6d x %6d\r", $w, $h; } continue { $row = undef } close $fh; $opt_v && printf STDERR "%6d x %6d\n", $w, $h; $wks->set_column ($_, $_, $w[$_]) for 0 .. $#w; } $wbk->close (); Text-CSV_XS-1.26/examples/csvdiff0000755000031300001440000000721112753265122017324 0ustar00merijnusers00000000000000#!/pro/bin/perl use strict; use warnings; sub usage { my $err = shift and select STDERR; print "usage: csvdiff [--no-color] [--html] file.csv file.csv\n", " provides colorized diff on sorted CSV files\n", " assuming first line is header and first field is the key\n"; exit $err; } # usage use Getopt::Long qw(:config bundling nopermute ); my $opt_c = 1; my $opt_h = 0; my $opt_o = ""; GetOptions ( "help|?" => sub { usage (0); }, "c|color|colour!" => \$opt_c, "h|html" => \$opt_h, "o|output=s" => \$opt_o, ) or usage (1); @ARGV == 2 or usage (1); if ($opt_o) { open STDOUT, ">", $opt_o or die "$opt_o: $!\n"; } use HTML::Entities; use Term::ANSIColor qw(:constants); use Text::CSV_XS; my $csv = Text::CSV_XS->new ({ binary => 1, auto_diag => 0 }); if ($opt_h) { binmode STDOUT, ":encoding(utf-8)"; print < CFI School updates

CSV diff @ARGV

EOH $::{RED} = sub { "\cA\rr"; }; $::{GREEN} = sub { "\cA\rg"; }; $::{RESET} = sub { ""; }; } elsif (!$opt_c) { $::{$_} = sub { "" } for qw( RED GREEN RESET ); } my @f; my $opt_n = 1; foreach my $x (0, 1) { open my $fh, "<", $ARGV[$x] or die "$ARGV[$x]: $!\n"; my $n = 0; while (1) { my $row = $csv->getline ($fh) or last; @$row and push @{$f[$x]}, $row; $n++ && $row->[0] =~ m/\D/ and $opt_n = 0; } } my @n = map { $#{$f[$_]} } 0, 1; my @i = (1, 1); my $hdr = "# csvdiff < $ARGV[0] > $ARGV[1]\n"; $f[$_][1+$n[$_]][0] = $opt_n ? 2147483647 : "\xff\xff\xff\xff" for 0, 1; my %cls; %cls = ( "b" => 0, "-" => sub { "rd" }, "+" => sub { "gr" }, "H" => sub { "hd" }, "<" => sub { $cls{b} ^= 1; "b$cls{b}" }, ">" => sub { "b$cls{b}" }, ); sub show { my ($pfx, $x) = @_; my $row = $f[$x][$i[$x]++]; if ($opt_h) { my $bg = $cls{$pfx}->(); print qq{ }, (map{"$_"}@$row), "\n"; return; } print $hdr, $pfx, " ", $pfx eq "-" ? RED : $pfx eq "+" ? GREEN : ""; $csv->print (*STDOUT, $row); print RESET, "\n"; $hdr = ""; } # show # Skip first line of both are same: it probably is a header my @h0 = @{$f[0][0]}; my @h1 = @{$f[1][0]}; if ("@h0" eq "@h1") { if ($opt_h) { $i[0]--; show ("H", 0); } shift @{$f[0]}; shift @{$f[1]}; } my $x = 0; while ($i[0] <= $n[0] || $i[1] <= $n[1]) { my @r0 = @{$f[0][$i[0]]}; my @r1 = @{$f[1][$i[1]]}; if ($opt_n) { $r0[0] < $r1[0] and show ("-", 0), next; $r0[0] > $r1[0] and show ("+", 1), next; } else { $r0[0] lt $r1[0] and show ("-", 0), next; $r0[0] gt $r1[0] and show ("+", 1), next; } "@r0" eq "@r1" and $i[0]++, $i[1]++, next; foreach my $c (1 .. $#h0) { my ($L, $R) = map { $_ // "" } $r0[$c], $r1[$c]; $L eq $R and next; $f[0][$i[0]][$c] = RED . $L . RESET; $f[1][$i[1]][$c] = GREEN . $R . RESET; } show ("<", 0); show (">", 1); } $opt_h and print "
\n\n\n"; close STDOUT; Text-CSV_XS-1.26/examples/csv-check0000755000031300001440000000770512753265122017556 0ustar00merijnusers00000000000000#!/pro/bin/perl # csv-check: Check validity of CSV file and report # (m)'15 [19 Nov 2015] Copyright H.M.Brand 2007-2016 # This code requires the defined-or feature and PerlIO use strict; use warnings; use Data::Peek; use Encode qw( decode ); our $VERSION = "1.7"; # 2015-11-19 sub usage { my $err = shift and select STDERR; print <] [-q ] [-e ] [-u] [--pp] [file.csv] -s use as seperator char. Auto-detect, default = ',' The string "tab" is allowed. -e use as seperator char. Auto-detect, default = ',' The string "undef" is allowed. -q use as quotation char. Default = '"' The string "undef" will disable quotation. -u check if all fields are valid unicode --pp use Text::CSV_PP instead (cross-check) EOU exit $err; } # usage use Getopt::Long qw(:config bundling nopermute passthrough); my $sep; # Set after reading first line in a flurry attempt to auto-detect my $quo = '"'; my $esc = '"'; my $opt_u = 0; my $opt_p = 0; GetOptions ( "help|?" => sub { usage (0); }, "c|s=s" => \$sep, "q=s" => \$quo, "e=s" => \$esc, "u" => \$opt_u, "pp!" => \$opt_p, ) or usage (1); my $csvmod = "Text::CSV_XS"; if ($opt_p) { require Text::CSV_PP; $csvmod = "Text::CSV_PP"; } else { require Text::CSV_XS; } $csvmod->import (); my $fn = $ARGV[0] // "-"; my $data = do { local $/; <> } or die "No data to analyze\n"; my ($bin, $rows, $eol, %cols) = (0, 0, undef); unless ($sep) { # No sep char passed, try to auto-detect; $sep = $data =~ m/["\d],["\d,]/ ? "," : $data =~ m/["\d];["\d;]/ ? ";" : $data =~ m/["\d]\t["\d]/ ? "\t" : # If neither, then for unquoted strings $data =~ m/\w,[\w,]/ ? "," : $data =~ m/\w;[\w;]/ ? ";" : $data =~ m/\w\t[\w]/ ? "\t" : ","; $data =~ m/([\r\n]+)\Z/ and $eol = DDisplay "$1"; } my $csv = $csvmod->new ({ sep_char => $sep eq "tab" ? "\t" : $sep, quote_char => $quo eq "undef" ? undef : $quo, escape_char => $esc eq "undef" ? undef : $esc, binary => 1, keep_meta_info => 1, auto_diag => 1, }); sub done { (my $file = $ARGV // "") =~ s{(\S)$}{$1 }; (my $prog = $0) =~ s{.*/}{}; print "Checked $file with $prog $VERSION using $csvmod @{[$csvmod->VERSION]}\n"; my @diag = $csv->error_diag; if ($diag[0] == 2012 && $csv->eof) { my @coll = sort { $a <=> $b } keys %cols; local $" = ", "; my $cols = @coll == 1 ? $coll[0] : "(@coll)"; $eol //= $csv->eol || "--unknown--"; print "OK: rows: $rows, columns: $cols\n"; print " sep = <$sep>, quo = <$quo>, bin = <$bin>, eol = <$eol>\n"; if (@coll > 1) { print "WARN: multiple column lengths:\n"; printf " %6d line%s with %4d field%s\n", $cols{$_}, $cols{$_} == 1 ? " " : "s", $_, $_ == 1 ? "" : "s" for @coll; } exit 0; } if ($diag[2]) { print "$ARGV record $diag[3] at line $./$diag[2] - $diag[0] - $diag[1]\n"; my $ep = $diag[2] - 1; # diag[2] is 1-based my $err = $csv->error_input . " "; substr $err, $ep + 1, 0, "*"; substr $err, $ep, 0, "*"; ($err = substr $err, $ep - 5, 12) =~ s/ +$//; print " |$err|\n"; } else { print "$ARGV line $. - $diag[1]\n"; } exit $diag[0]; } # done sub stats { my $r = shift; $cols{scalar @$r}++; grep { $_ & 0x0002 } $csv->meta_info and $bin = 1; if ($opt_u) { my @r = @$r; foreach my $x (0 .. $#r) { utf8::is_utf8 ($r[$x]) and next; local $SIG{__WARN__} = sub { (my $msg = shift) =~ s{ at /\S+Encode.pm.*}{}; printf STDERR "Field %3d:%3d - '%s'\t- %s", $rows, $x, DPeek ($r[$x]), $msg; }; my $oct = decode ("utf-8", $r[$x], Encode::FB_WARN); } } } # stats open my $fh, "<", \$data or die "$fn: $!\n"; while (my $row = $csv->getline ($fh)) { $rows++; stats $row; } done; Text-CSV_XS-1.26/ChangeLog0000644000031300001440000007066313017533713015717 0ustar00merijnusers000000000000001.26 - 2016-11-29, H.Merijn Brand * Disable some Unicode related tests for unhealthy $PERL_UNICODE (RT#117856) * is_missing (0) on empty line returns 1 for keep_meta_info = true (issue 27 on github) 1.25 - 2016-08-28, H.Merijn Brand * Allow lc, uc, and coderef for csv () headers attribute * Document for eof when the last line has an error (RT#115954) * Allow csv () to call header () with all supported arguments * Add some docs for bind_columns 1.24 - 2016-07-09, H.Merijn Brand * Fix typo in docs example code (issue#4, joevak) * Set auto-wrap on for csv2xls with embedded newlines * Add examples/csv2xlsx, the MSExcel-2007+ version of csv2xls Includes new feature to merge multiple CSV's into a single xlsx * Slight modification in examples * Fix parse error in complex option combo (RT#115953) 1.23 - 2016-03-25, H.Merijn Brand * Skip unsupported encodings * Reorganize Unicode section and mention layers (Dan Book) * Amend some UTF-8 tests for PERL_UNICODE settings * Fix crash on error in parsing with bound columns (RT#113279) * Add predefined filters (not_blank, not_empty, filled) 1.22 - 2016-02-23, H.Merijn Brand * Small doc updates regarding blank_is_undef * Precedence error in doc * Add new method header 1.21 - 2016-01-06, H.Merijn Brand * Add confusion option to rewrite example * Alias %_ to row in hashref mode for csv function attributes on_in and before_out * Examples now use defined-or and thus require perl-5.10 or up * Fix \r\n ending with allow_loose_escapes (reported by Bas Bloemsaat) * It's 2016 * Clarify $csv->csv (...) documentation (RT#110941) 1.20 - 2015-10-09, H.Merijn Brand * Use "say" in synopsis * Remove needless special characters in doc section * Change doc =item attributes for new to =head for index * Add known_attributes function/method * Add contributor notes * Allow undef as value for aliased attributes 1.19 - 2015-06-17, H.Merijn Brand * Guard tests against $PERL_UNICODE * Numeric options were sometimes interpreted as boolean * Safer meta_info use 1.18 - 2015-05-22, H.Merijn Brand * Add quote_empty attribute * Add database NULL documentation * Inherit csv attributes in csv () when called in void context * micro-optimisation for combine/print (empty fields will be faster) 1.17 - 2015-04-24, H.Merijn Brand * Enable overruling $csv in csv () * Allow encoding to be shortened to enc in csv () * Allow filter to alter content * Add say (print with default eol => $\) * Allow MS sep=; on first line (RT#100304) 1.16 - 2015-03-02, H.Merijn Brand * filter made more useful (access to other fields) 1.15 - 2015-02-11, H.Merijn Brand * Remove perl recommendation from META as it breaks cpan clients 1.14 - 2015-02-02, H.Merijn Brand * Move to github * Add csv (filter => {}); * Change csv ()'s void context behavior 1.13 - 2015-01-03, H.Merijn Brand * Simplify code path for old perl * Fix quote_binary (#RT100676) * Fix csv () for hashrefs with aliased headers * Update copyright to 2015 1.12 - 2014-11-01, H.Merijn Brand * Add field number to error_diag * Fixed non-IO parsing multi-byte EOL * Fixed a possible missed multi-byte EOL * Allow hashref for csv ()'s headers attribute * Allow encoding on all output handles in csv () * Include doc changes as ticketed in the Text::CSV queue * Fix parallel testing issue * Allow csv as method call (not using the object) * Rename quote_null to escape_null * Give meaning to keep_meta_info on output (RT#99941) 1.11 - 2014-08-16, H.Merijn Brand * Fixed eof (RT#97742) * Check for attribute conflicts early * csv (in => [..]) now defaults to *STDOUT for out * Support for multi-byte quote_char * New attribute "key" for csv () 1.10 - 2014-08-04, H.Merijn Brand * Support for scalar ref in out: csv (out => \(my $x = ""), ...) * Support for multi-byte sep_char * Simplified the cache coding 1.09 - 2014-06-09, H.Merijn Brand * Missed defined-or need in csv2xls (RT#95787) 1.08 - 2014-05-17, H.Merijn Brand * Documentation updates * Allow disjointed CSV cell fragment lists 1.07 - 2014-04-28, H.Merijn Brand * Allow ref to scalar for csv (in => ...) * Allow CODE ref to in attribute * Allow * in fragment cellspec's bottom-right cell 1.06 - 2014-04-20, H.Merijn Brand * Fix possible fail in tests on Windows (Thanks Mithaldu for explaing) * Only close file handles in csv () for files * new callbacks for csv () 1.05 - 2014-03-02, H.Merijn Brand * Allow case insensitive attributes and attribute aliases (quote_always = always_quote) * Enhanced the csv () function (diagnostics) * Start callbacks support * Minor doc fixes * Make subclassing safer 1.04 - 2014-02-06, H.Merijn Brand * column_names () with no argument now returns the empty list instead of undef when no columns defined * fragments (rfc7111) now also support AoH (was AoA only) * Error code conflict for fragments resolved to 2013 * New function "csv" (not a method) 1.03 - 2014-01-21, H.Merijn Brand * Update copyright to 2014 * Implement RFC7111 1.02 - 2013-09-25, H.Merijn Brand * Add example for reading only a single column * Don't store NULL in _ERROR_INPUT (RT#86217/Clone) * Prevent double-decode in csv-check * Add decode_utf8 attribute (default is true) 1.01 - 2013-06-16, H.Merijn Brand * Cache not re-read on getline_all (RT#86155) 1.00 - 2013-06-13, H.Merijn Brand * Fix automatic UTF-8 in getline/parse for SV's with \0 0.99 - 2013-06-05, H.Merijn Brand * Documents return value of bind_columns without arguments * Fix automatic UTF-8 in getline/parse 0.98 - 2013-06-03, H.Merijn Brand * Clarify eol documentation * Move error_input to XS 0.97 - 2013-03-30, H.Merijn Brand * Regain the speed from 0.91 (buffer back to 1k) * Minor cleanup in XS code * Add diag_verbose attribute 0.96 - 2013-03-26, H.Merijn Brand * No need to require Test::Harness if unused (RT#82693) * parse ("") should return one empty field, not undef * Now that we know the record number, show it in auto_diag 0.95 - 2013-01-13, H.Merijn Brand * Introduce allow_unquoted_escape as workaround for RT#81295 * Update copyright to 2013 * Introduce print_hr () for RT#76143 * Dropped plans to support EBCDIC 0.94 - 2012-12-03, H.Merijn Brand * Guard against beta releases of Encode (Xavier Guimard - RT#81499) * Fix sv_cache init global-buffer-overflow (Reini Urban - RT#81469) * Tested with perl compiled with clang (also to verify RT#81469) * Fix memory leak reported in RT#81539 (Fix by Tony Cook) 0.93 - 2012-11-19, H.Merijn Brand * Skip Encode related tests on too old Encode * Force old(er) tar format (ustar) - assumes GNU tar on release box 0.92 - 2012-11-12, H.Merijn Brand * Allow bind_columns () for print () * Increase buffer size for print to 64k * Fix RT#80680 - Buffer break halfway UTF8 + tests 0.91 - 2012-08-21, H.Merijn Brand * Prevent test-failures for long doubles on weird architectures * More utf-8 tests for te change of 0.90 * Update test case now 5.005 is not supported anymore * Rip out the tell/seek introduced in 0.90 0.90 - 2012-06-15, H.Merijn Brand * Drop 5.005 support (5.6.1 is now minimum) * Introduce record_number * Try harder to get the complete input parsed for the current record when hitting errors on parsing seekable IO (only works in 5.14.0 and up) * Tested with perl 5.6.1 .. 5.17.0 (99 versions of perl) on Linux, HP-UX, AIX, and Windows * SvSETMAGIC was missing for tied variables causing weird actions at a distance, e.g. in printf (Thanks TonyC for finding this) * UTF8 flag was not always reset when using bound variables (TonyC) 0.88 - 2012-03-16, H.Merijn Brand * Fix for $/ in 0.86 broke parsing fields that contain excessive $/'s 0.87 - 2012-03-08, H.Merijn Brand * Extra check on utf8 output (RT#74330) * examples/csvdiff now recognizes numerically sorted CSV files * Document example comparing getline_hr vs bind_columns + getline 0.86 - 2012-01-22, H.Merijn Brand * Introduce quote_binary attribute * Update copyright to 2012 * Versions * Fixed a utf8::decode on undef (found by perl-5.15.7) * Fixed localized $/ interference with other handles (RT#74216) 0.85 - 2011-09-07, H.Merijn Brand * NAME / DISTNAME in Makefile.PL 0.84 - 2011-09-07, H.Merijn Brand * More cross-checks for META data 0.83 - 2011-08-07, H.Merijn Brand * Fix spurious auto_diag warning (RT#69673) * Tested with 50 versions of perl, including 5.15.1 0.82 - 2011-05-01, H.Merijn Brand * Doc fix (RT#66905, Peter Newman) * Documentation overhaul (pod links) 0.81 - 2011-03-07, H.Merijn Brand * Add is_missing () * Doc overhaul * Fix Build on OpenVMS (RT#65654, Martin P.J. Zinser) * Fix SetDiag () leak (RT#66453, Sven Schöling) 0.80 - 2010-12-24, H.Merijn Brand * Implement getline_all () and getaline_hr_all () * Fixed another parsing for eol = \r (RT#61525) 0.79 - 2010-11-26, H.Merijn Brand * Use correct type for STRLEN (HP-UX/PA-RISC/32) * More code coverage * EOF unreliable when line-end missing at eof 0.78 - 2010-11-26, H.Merijn Brand * Version 0.77 broke MacOS exported CSV files with only \r 0.77 - 2010-10-23, H.Merijn Brand * Internals now use warn () instead of (void)fprintf (stderr, ...) Now the test in t/80_diag also passes on Windows * Better parsing for eol = \r and set as such (RT#61525) * Workaround for AIX cpp bug (RT#62388, Jan Dubois) 0.76 - 2010-10-09, H.Merijn Brand * Windows doesn't support STDERR redirection as used in t/80_diag 0.75 - 2010-10-05, H.Merijn Brand * Fixed undefinedness of $\ in print (RT#61880) 0.74 - 2010-09-29, H.Merijn Brand * Spelling fixes * Real eol support for parsing streams (beyond \n, \r and \r\n) * Clarify doc for always_quote to not quote undef fields * Clarify UTF8 process for print () and combine () 0.73 - 2010-05-03, H.Merijn Brand * Improve date conversion in examples/csv2xls new option -D allows column selection for date conversions * Tested under perl-5.12.0 (and 21 other versions of perl) * Added a note about EBCDIC data files * Test suite is now safe for parallel test (prove --shuffle -j6) 0.72 - 2010-03-16, H.Merijn Brand * Introduce quote_null attribute (RT#55200) * examples/csv-check can be used for Text::CSV_PP * examples/csv-check more options for sep_, escape_ and quote_char * examples/csv2xls more options for sep_, escape_ and quote_char * examples/csv2xls added auto_diag and verbosity * Dropped YAML spec to 1.0 0.71 - 2010-02-15, H.Merijn Brand * Upped copyright to 2010 * Prevent double encoding: make Text::CSV_XS streams behave just like perl would (thanks ikegami for the test cases) * Text::CSV_XS->error_diag () in void context now warns instead of doing nothing * auto_diag also used for new () itself 0.70 - 2009-12-02, H.Merijn Brand * Add quote_space attribute * Forbid \r and \n in sep_char, quote_char, and escape_char 0.69 - 2009-10-10, H.Merijn Brand * Missing end quotes in error code docs * examples/csv-check now shows detected eol * Auto detection of eol => "\r" in streams * Optimized caching. All cache changes now in XS 0.68 - 2009-10-04, H.Merijn Brand * Attribute auto_diag now localizes to +1 if autodie is active * Output name generation in csv2xls (RT#48954) * Added csvdiff to examples/ * Reordered docs. Rewrote SYNOPSIS to be more like a real-world code example 0.67 - 2009-08-08, H.Merijn Brand * Fix empty_diag typo for attribute handler * Fix AUTOMATED_TESTING erroneous skip 0.66 - 2009-08-07, H.Merijn Brand * Reordered examples in doc to show best method first * Documentation grammatical fix (John P. Linderman, RT#46411) * Fail if first arg to new () is not a hash ref * Implement empty_is_undef on request of Evan Carroll * Typo in documentation (Herwin Weststrate, RT#47613) * error_diag () uses warn () in void context instead of STDERR * Add auto_diag attribute (still under construction) * FIX: reset attributes (after they have been set) with accessor 0.65 - 2009-05-14, H.Merijn Brand * Initial known errors can now be checked on number (1002) * More tests for illegal combinations * Added -u option to examples/csv-check to validate utf-8 encoding * Correct documentation for error_diag () return value in case of constructor failure (Slaven, RT#46076) * All error_diag () returns should now be dual-var (both numeric and string context valid) * Remove (3) from L<..> links (Slaven, RT#46078) 0.64 - 2009-04-03, H.Merijn Brand * Skip perlio tests for perl older than 5.8, as perlio was experimental in 5.6 * Up Devel::PPPort to 3.17 * Fix initialization of eol => undef (could cause core dump) * Added configure_require to META.yml 0.63 - 2009-03-20, H.Merijn Brand * Fixed allow_whitespace with sep_char = TAB (RT#44402) 0.62 - 2009-03-13, H.Merijn Brand * Prevent warnings in older perls (without utf8) * All known errors are covered and/or documented. TODO dropped * Unicode TODO dropped. All covered, or use Text::CSV::Encoded * Documented the examples 0.61 - 2009-03-08, H.Merijn Brand * valgrind found a possible uninitialized value * Restriction in print () was only for really old perls * Fix for bind_columns () initialization (vincent, RT#43927) 0.60 - 2009-01-27, H.Merijn Brand * Optimize for threaded perls. (Goro Fuji, RT#42517) Non-threaded perls won't notice 0.59 - 2009-01-23, H.Merijn Brand * Wrong e-mail in META.yml * Missing $IO argument in bind_columns example (docs only) * Upped Copyright notices to 2009 * Added warning for parse () (RT#42261) * Small optimizations (Goro Fuji, RT#42517) * ppport.h updated to 3.15 * Added git clone command to README * ppport.h updated to 3.16-pre * Optimize getline/print method calls (Goro Fuji, RT#42517) * Decode *_char attributes for perl 5.8.2 and up 0.58 - 2008-10-30, H.Merijn Brand * Small typo in test message (RT#40410, JPL) * Parse error test on "\0 (RT#40507) * Fixed allow_loose_escapes bug disclosed by RT#40507 0.57 - 2008-10-21, H.Merijn Brand * Don't bootstrap twice. Don't know how/when it came in there 0.56 - 2008-10-21, H.Merijn Brand * Update to ppport.h 3.14_01 * Updated docs (Unicode, TODO, Release Plan) * As Text::CSV::Encoded is about to be released, refer to it in the documentation * Default for eol is "", undef now treated as "" * Don't print $\ twice (eol prevails over $\ in ->print ()) Fix only works in perl5.8 and up * Undef treated as 0 for boolean attributes * Trailing whitespace in pod removed * Sync up doc with latest Text::CSV::Encoded * YAML declared 1.4 (META.yml) instead of 1.1 (YAML) 0.55 - 2008-10-15, H.Merijn Brand * Improve documentation on eol * Unicode on perl-5.8.[0-2] sucks. Don't use it! * Test error codes in expected IO failures * Allow SetDiag to be used as class method * Document the MS/Excel separation character * Hint that eof is not an error per se (RT#40047) 0.54 - 2008-09-04, H.Merijn Brand * IO failure in print () was not propagated (ilmari, RT#38960) 0.53 - 2008-09-01, H.Merijn Brand * SvUPGRADE is a safer choice than sv_upgrade (Lubomir Rintel, RT#38890) * bring docs in sync with reality for msg 2023 * Default eol for print is $\ * examples/csv-check should default to CSV , not to ; * Tests for SetDiag (0) * Tests for error 2030 * Code cleanup (Devel::Cover++) 0.52 - 2008-06-28, H.Merijn Brand * Using undef for hash keys is a bad plan * Fix, tests, and documentation for column_names () 0.51 - 2008-06-17, H.Merijn Brand * Allow UTF8 even without binary => 1 * Fixed a few pod typo's * Lifted the max of 255 for bind_columns 0.50 - 2008-06-04, H.Merijn Brand * Skip a few tests in automated testing, as they confuse reports. This is important for the automated sites that mark modules as fail if it is not an obvious full PASS * 0.46 caused the last still open RT bug to be closed! * Tested on 5.11.0, 5.10.0, 5.8.8, 5.6.2, and 5.005_04, Strawberry and Cygwin 0.46 - 2008-06-04, H.Merijn Brand * In examples add die on failed close calls * Use Test::MinimumVersion (not distributed) * Added option -F to examples/csv2xls * More source code cleanup * Nailed the UTF8 issues for parsing * Nailed the UTF8 issues for combining 0.45 - 2008-04-23, H.Merijn Brand * Forgot to pack examples/parser-xs.pl 0.44 - 2008-04-23, H.Merijn Brand * Fixed the error position returned as third arg in error_diag () * Made examples/csv-check use this even more vebose * Removed double-double quote from TODO * Added examples/parse-xs.pl (attempt to fix bad CSV) 0.43 - 2008-04-21, H.Merijn Brand * parse errors try to remember failing position * used valgrind to test for leaks (devel-only) * used Test::Valgrind as alternative leak check (devel-only) * improve documentation for error 2023 * nailed the loose quotes in quoted fields 0.42 - 2008-04-16, H.Merijn Brand * Generate META.yml myself. I won't use Build.PL * Array-refs now accept scalars with magic: $csv->print (*STDOUT, $sth->{NAME_lc}); * More/better examples * Added t/76_magic.t 0.41 - 2008-04-11, H.Merijn Brand * error_diag () subclassable * typo in bind_columns () docs * examples/csv2xls now uses getline () * better test for getline in t/75_hashref.t (makamata) * document return value of getline () with bind_columns () * add perl version prereq to META.yml 0.40 - 2008-04-07, H.Merijn Brand * Implemented getline_hr () and column_names () (RT#34474) (suggestions accepted from Mark Stosberg) * Corrected misspelled variable names in XS * Functions are now =head2 type doc entries (Mark Stosberg) * Make SetDiag () available to the perl level, so errors can be centralized and consistent * Integrate the non-XS errors into XS * Add t/75_hashref.t * Testcase for error 2023 (Michael P Randall) * Completely refactored the XS part of parse/getline, which is now up to 6% faster. YMMV * Completed bind_columns. On straight fetches now up to three times as fast as normal fetches (both using getline ()) 0.37 - 2008-03-11, H.Merijn Brand * Copied GIT repo to public mirror * Fix leak / make meta info available to getline () + tests 0.36 - 2008-03-06, H.Merijn Brand * Updated ppport.h * auto-load IO::Handle when needed * Tested with all available perl builds, including a fresh threaded 5.11 (blead) 0.35 - 2008-03-01, H.Merijn Brand Valloire-release * use warnings/$^W = 1 * Tested on 5.10.0, 5.8.8, 5.6.2, and 5.005_04, Strawberry and Cygwin * Diagnostics for failed new () * New 'blank_is_undef' option * Updated docs * Extended the DIAGNOSTICS a bit * Updated TODO * Fixed allow_whitespace issue, revealed by blank_is_undef * Re-enabled some tests * Fixed parse error that passed for q{1, "bar",2} with escape_char + * Reversed an erroneous test result in the funny combo section * Extended diagnostics tests * Extended XS coverage * Removed error 2033 0.34 - 2008-01-04, H.Merijn Brand * No change, but 0.33 was shipped with an old META.yml 0.33 - 2008-01-02, H.Merijn Brand * Text-CSV_XS now under git * Upped copyright to 2008 * Added all prereq's to Makefile.PL * Tested under perl 5.10 0.32 - 2007-10-24, H.Merijn Brand * Added $csv->error_diag () to SYNOPSIS * Added need for diag when new () fails to TODO * Fixed a sneaked-in defined or in examples/csv2xls * Plugged a 32byte memory leak in the cache code (valgrind++) * Some perlcritic level1 changes 0.31 - 2007-07-23, H.Merijn Brand * Removed prototypes in examples/csv2xls * Improved usage for examples/csv2xls (GetOpt::Long now does --help/-?) * Extended examples/csv2xls to deal with Unicode (-u) * Serious bug in Text::CSV_XS::NV () type setting, causing the resulting field to be truncated to IV 0.30 - 2007-06-21, H.Merijn Brand * ,\rx, is definitely an error without binary (used to HANG!) * Fixed bug in attribute caching for undefined eol * Cleaned up some code after -W*** warnings * Added verbatim. * More test to cover the really dark corners and edge cases * Even more typo fixes in the docs * Added error_diag () * Added t/80_diag.t - Will not be mirrored by Text::CSV_PP * Added DIAGNOSTICS section to pod - Will grow * Small pod niot (abeltje) * Doc fix in TODO (Miller Hall) 0.29 - 2007-06-08, H.Merijn Brand * Removed an unused 'use Data::Dumper' * Added $csv->eof () (RT#27424) * Two typo's in the doc's (Amsterdam.pm) * Modified examples/speed.pl to better show the diffs between versions * Cache attribute settings and regain speed of 0.23! and beyond Relative overall speeds (YMMV, use examples/speed.pl to check), the 1.0x versions are from Text::CSV_PP. 0.23 0.25 0.26 0.27 0.28 0.29 1.00 1.02 1.05 ==== ==== ==== ==== ==== ==== ==== ==== ==== combine 1 62 61 61 60 58 100 14 14 14 combine 10 41 41 41 42 42 100 6 6 6 combine 100 35 35 36 36 36 100 5 5 5 parse 1 100 92 87 90 81 96 19 19 17 parse 10 95 100 86 97 94 94 15 16 14 parse 100 90 95 84 94 92 100 16 16 14 print io 93 89 91 91 95 100 0 0 6 getline io 90 92 84 87 89 100 0 0 13 ---- ---- ---- ---- ---- ---- ---- ---- ---- average 75 75 71 74 73 98 9 9 11 * Removed prototypes * Added a SPECIFICATION section to the pod * Safe caching of eol, and a warning in the docs * Rewrote t/20_file.t do do actual file IO instead of IO_Scalar fake * Small optimization for parse (juerd) * Added make target test_speed * Merged the items from CAVEAT to SPECIFICATION * Updated the TODO and Release Plan sections * Speed up internals by using references instead of copies (juerd) * Reworked error_input, which also had an undetected internal error * Added IO tests for lexical IO handles and perlio IO to/from scalars 0.28 - 2007-06-03, H.Merijn Brand * IMPORTANT CHANGE: new () returns undef if it gets unsupported attributes. Until now, new ({ esc_char => "\\" }) was just silently ignored. Rejecting it and failing is better than continuing with false assumptions. * Added allow_loose_quotes (see doc) * Added t/65_allow.t * Added allow_loose_escapes (see doc) (RT#15076) * More code cleanup in XS * Added allow_whitespace (see doc) 0.27 - 2007-05-31, H.Merijn Brand * checked with perlcritic (still works under 5.00504) so 3-arg open cannot be used (except in the docs) * 3-arg open in docs too * Added a lot to the TODO list * Some more info on using escape character (jZed) * Mention Text::CSV_PP in README * Added t/45_eol.t, eol tests * Added a section about embedded newlines in the pod * Allow \r as eol ($/) for parsing * More docs for eol * More eol = \r fixes, tfrayner's test case added to t/45_eol.t 0.26 - 2007-05-15, H.Merijn Brand * Add $csv->allow_undef (1) suggestion in TODO Still have to find the best spot to document the difference between empty string and undef * Spell-checked the pod and fixed some typo's * Added t/70_rt.t - Regression for RT#24386: \t doesn't work (WFM) - Regression and fix for RT#21530: getline () return at eof This one still passes under perl 5.00504 - Regression for RT#18703: Fails to use quote_char of '~' * Added t/55_combi.t for most combinations of always_quote, sep_char, quote_char, and escape_char * Added docs about sep_char not allowed to be either quote_char or escape_char * Both combine () and parse () now return FALSE id sep_char is equal to either quote_char or escape_char. Done in XS, as it was a slowdown of 10% when done in perl. 0.25 - 2007-05-07, H.Merijn Brand # Merijn got the maintainership * code reformat and code cleanup * renamed internal (Encode, Decode) to (Combine, Parse) to prevent misinterpretation with upcoming Unicode changes and possible name clashes * added pod check (and fixed pod) * added pod coverage and small additions to the pod. More to do in this area * renamed test to fixate the sequence * Added t/50_utf8.t * tests now use Test::More . Makefile.PL requires Test::More * checked proclaimed version compatibility . 5.9.x-64int works @31159 . 5.8.x-64int-dor works @31162 . 5.8.0-dor works . 5.6.2 works . 5.005.04 works . 5.004.05 fails * 5.005 is now prerequisite * Added missing info in docs for new () * Added meta_info () method and docs * Added keep_meta_info in new () * Added t/15_flags.t * Added test_cover make target * Added test for error_input () * Added tests for fields () and meta_info () before parse () * Added tests for ->types () as method * Added tests for deleting types (coverage now over 99%) * Added is_quoted (), is_binary () and tests * Added COPYRIGHT section to pod * Added the parse example from the pod to test.pl * Added accessor methods for internals: quote_char () et all * Added tests for the new accessor methods * Added always_quote to the missing places in the doc and in new () * Changed the tests to use the accessors instead of the hash keys except for the ->{types} and ->{_types} * Moved test.pl to examples/speed.pl 0.23 - 2001-10-10, Jochen Wiedmann * Changed "char" to "unsigned char" in CSV_XS.xs. Matthew Graham 0.22 - 2000-12-22, Jochen Wiedmann * CSV_XS.xs: Added the handling of escape characters outside of quotes. Kirill Paliy 0.21 - 2000-08-18, Jochen Wiedmann * CSV_XS.pm (parse): Minor bugfix in the parse method. Norikatsu Shigemura (nork@cityfujisawa.ne.jp) 0.20 - 1999-06-28, Jochen Wiedmann * CSV_XS.xs: Fixed a bug in the decoder where escapeChar wasn't handled right. Pavel Kotala 0.19 - 1999-05-01, Jochen Wiedmann * CSV_XS.xs: Setting escape_char => undef should now work. Requested by Syed Muhammad Nayeem 0.18 - 1999-04-05, Jochen Wiedmann * CSV_XS.pm: Portability fixes (sv_undef => PL_sv_undef and the like. 0.17 - 1999-03-04, Jochen Wiedmann * CSV_XS.pm: Added always_quote attribute. (Ken Williams ) * The types method is now implemented in Perl. 0.16 - 1999-02-11, Jochen Wiedmann * CSV_XS.pm: PV, IV and NV are no longer exportable, so that I need not inherit from Exporter any longer. (This caused trying to autoload DESTROY without any reason. Seems to me to be a serious performance penalty.) * CSV_XS.pm: Being a little bit less strict now: If quoteChar and escapeChar are different, then the quote char may be part of the field. (Not at the fields start, of course.) 0.15 - 1998-08-21, Jochen Wiedmann * CSV_XS.pm: Moved print () and getline () to XS. 0.14 - 1998-08-13, Jochen Wiedmann * CSV_XS.xs: Forgot to escape sepchar; patched by Paul Walmsley, . 0.13 - 1998-07-20, Jochen Wiedmann * CSV_XS.xs (Encode): Strings qre quoted only if required. * CSV_XS.xs: Added support for $csv->{types}. 0.12 - 1998-06-11, Jochen Wiedmann * CSV_XS.xs (Encode): Integers and Reals are no longer quoted. * Added $csv->{types}. 0.11 - 1998-05-12, Jochen Wiedmann * Added $csv->{eol} * Added $csv->{quote_char} = undef 0.10 - 1998-05-05, Jochen Wiedmann * Moved encoding and decoding to XS; added binary mode; added print () and getline () methods. 1998-06-05 Alan Citterman * Initial version Text-CSV_XS-1.26/META.yml0000644000031300001440000000141413017540445015402 0ustar00merijnusers00000000000000--- abstract: Comma-Separated Values manipulation routines author: - H.Merijn Brand build_requires: Config: 0 configure_requires: ExtUtils::MakeMaker: 0 dynamic_config: 1 generated_by: Author, CPAN::Meta::Converter version 2.150010 license: perl meta-spec: url: http://module-build.sourceforge.net/META-spec-v1.4.html version: '1.4' name: Text-CSV_XS provides: Text::CSV_XS: file: CSV_XS.pm version: '1.26' recommends: Encode: '2.88' requires: DynaLoader: 0 IO::Handle: 0 Test::More: 0 Tie::Scalar: 0 perl: '5.006001' resources: IRC: irc://irc.perl.org/#csv homepage: https://metacpan.org/pod/Text::CSV_XS license: http://dev.perl.org/licenses/ repository: https://github.com/Tux/Text-CSV_XS version: '1.26' Text-CSV_XS-1.26/MANIFEST0000644000031300001440000000416313017540445015266 0ustar00merijnusers00000000000000ChangeLog Change history README Docs MANIFEST This file CONTRIBUTING.md Guide in how to contribute CSV_XS.pm Perl part of the module CSV_XS.xs C part of the module Makefile.PL Makefile generator ppport.h Perl/Pollution/Portability script/include file t/00_pod.t Check if pod is valid t/01_pod.t Check if pod covers all t/10_base.t Base tests (combine and parse only) t/12_acc.t Accessor methods t/15_flags.t Basic flag tests t/20_file.t IO tests (print and getline) global handles t/21_lexicalio.t IO tests (print and getline) lexical handles t/22_scalario.t IO tests (print and getline) scalar io (perlio) t/30_types.t Tests for the "types" attribute. t/40_misc.t Binary mode tests t/41_null.t NULL test in combination with line endings t/45_eol.t Embedded EOL t/46_eol_si.t Embedded EOL using scalar io (perlio) t/50_utf8.t Unicode stress tests t/51_utf8.t Unicode IO encoding tests t/55_combi.t Different CSV character combinations t/60_samples.t Miscellaneous problems from the modules history. t/65_allow.t Allow bad formats t/70_rt.t Tests based on RT reports t/75_hashref.t getline_hr related tests t/76_magic.t array_ref from magic t/77_getall.t Get all rows at once t/78_fragment.t Get fragments according to RFC7111 specs t/79_callbacks.t Test callback features t/80_diag.t Error diagnostics t/81_subclass.t Subclassed t/85_util.t Test for utility methods t/90_csv.t Function csv () checks t/91_csv_cb.t Callbacks with csv function t/util.pl Extra test utilities examples/csv2xls Script to onvert CSV files to M$Excel XLS examples/csv2xlsx Script to onvert CSV files to M$Excel 2007+ XLSX examples/csv-check Script to check a CSV file/stream examples/csvdiff Script to shoff diff between sorted CSV files examples/parser-xs.pl Parse CSV stream, be forgiving on bad lines examples/rewrite.pl Simple CSV rewriter examples/speed.pl Small benchmark script files/macosx.csv A CSV files exported on MacOSX files/utf8.csv A UTF-8 encode test file META.yml Module YAML meta-data (added by MakeMaker) META.json Module JSON meta-data (added by MakeMaker) Text-CSV_XS-1.26/ppport.h0000644000031300001440000060553012753265122015641 0ustar00merijnusers00000000000000#if 0 <<'SKIP'; #endif /* ---------------------------------------------------------------------- ppport.h -- Perl/Pollution/Portability Version 3.35 Automatically created by Devel::PPPort running under perl 5.024000. Do NOT edit this file directly! -- Edit PPPort_pm.PL and the includes in parts/inc/ instead. Use 'perldoc ppport.h' to view the documentation below. ---------------------------------------------------------------------- SKIP =pod =head1 NAME ppport.h - Perl/Pollution/Portability version 3.35 =head1 SYNOPSIS perl ppport.h [options] [source files] Searches current directory for files if no [source files] are given --help show short help --version show version --patch=file write one patch file with changes --copy=suffix write changed copies with suffix --diff=program use diff program and options --compat-version=version provide compatibility with Perl version --cplusplus accept C++ comments --quiet don't output anything except fatal errors --nodiag don't show diagnostics --nohints don't show hints --nochanges don't suggest changes --nofilter don't filter input files --strip strip all script and doc functionality from ppport.h --list-provided list provided API --list-unsupported list unsupported API --api-info=name show Perl API portability information =head1 COMPATIBILITY This version of F is designed to support operation with Perl installations back to 5.003, and has been tested up to 5.20. =head1 OPTIONS =head2 --help Display a brief usage summary. =head2 --version Display the version of F. =head2 --patch=I If this option is given, a single patch file will be created if any changes are suggested. This requires a working diff program to be installed on your system. =head2 --copy=I If this option is given, a copy of each file will be saved with the given suffix that contains the suggested changes. This does not require any external programs. Note that this does not automagically add a dot between the original filename and the suffix. If you want the dot, you have to include it in the option argument. If neither C<--patch> or C<--copy> are given, the default is to simply print the diffs for each file. This requires either C or a C program to be installed. =head2 --diff=I Manually set the diff program and options to use. The default is to use C, when installed, and output unified context diffs. =head2 --compat-version=I Tell F to check for compatibility with the given Perl version. The default is to check for compatibility with Perl version 5.003. You can use this option to reduce the output of F if you intend to be backward compatible only down to a certain Perl version. =head2 --cplusplus Usually, F will detect C++ style comments and replace them with C style comments for portability reasons. Using this option instructs F to leave C++ comments untouched. =head2 --quiet Be quiet. Don't print anything except fatal errors. =head2 --nodiag Don't output any diagnostic messages. Only portability alerts will be printed. =head2 --nohints Don't output any hints. Hints often contain useful portability notes. Warnings will still be displayed. =head2 --nochanges Don't suggest any changes. Only give diagnostic output and hints unless these are also deactivated. =head2 --nofilter Don't filter the list of input files. By default, files not looking like source code (i.e. not *.xs, *.c, *.cc, *.cpp or *.h) are skipped. =head2 --strip Strip all script and documentation functionality from F. This reduces the size of F dramatically and may be useful if you want to include F in smaller modules without increasing their distribution size too much. The stripped F will have a C<--unstrip> option that allows you to undo the stripping, but only if an appropriate C module is installed. =head2 --list-provided Lists the API elements for which compatibility is provided by F. Also lists if it must be explicitly requested, if it has dependencies, and if there are hints or warnings for it. =head2 --list-unsupported Lists the API elements that are known not to be supported by F and below which version of Perl they probably won't be available or work. =head2 --api-info=I Show portability information for API elements matching I. If I is surrounded by slashes, it is interpreted as a regular expression. =head1 DESCRIPTION In order for a Perl extension (XS) module to be as portable as possible across differing versions of Perl itself, certain steps need to be taken. =over 4 =item * Including this header is the first major one. This alone will give you access to a large part of the Perl API that hasn't been available in earlier Perl releases. Use perl ppport.h --list-provided to see which API elements are provided by ppport.h. =item * You should avoid using deprecated parts of the API. For example, using global Perl variables without the C prefix is deprecated. Also, some API functions used to have a C prefix. Using this form is also deprecated. You can safely use the supported API, as F will provide wrappers for older Perl versions. =item * If you use one of a few functions or variables that were not present in earlier versions of Perl, and that can't be provided using a macro, you have to explicitly request support for these functions by adding one or more C<#define>s in your source code before the inclusion of F. These functions or variables will be marked C in the list shown by C<--list-provided>. Depending on whether you module has a single or multiple files that use such functions or variables, you want either C or global variants. For a C function or variable (used only in a single source file), use: #define NEED_function #define NEED_variable For a global function or variable (used in multiple source files), use: #define NEED_function_GLOBAL #define NEED_variable_GLOBAL Note that you mustn't have more than one global request for the same function or variable in your project. Function / Variable Static Request Global Request ----------------------------------------------------------------------------------------- PL_parser NEED_PL_parser NEED_PL_parser_GLOBAL PL_signals NEED_PL_signals NEED_PL_signals_GLOBAL SvRX() NEED_SvRX NEED_SvRX_GLOBAL caller_cx() NEED_caller_cx NEED_caller_cx_GLOBAL eval_pv() NEED_eval_pv NEED_eval_pv_GLOBAL grok_bin() NEED_grok_bin NEED_grok_bin_GLOBAL grok_hex() NEED_grok_hex NEED_grok_hex_GLOBAL grok_number() NEED_grok_number NEED_grok_number_GLOBAL grok_numeric_radix() NEED_grok_numeric_radix NEED_grok_numeric_radix_GLOBAL grok_oct() NEED_grok_oct NEED_grok_oct_GLOBAL gv_fetchpvn_flags() NEED_gv_fetchpvn_flags NEED_gv_fetchpvn_flags_GLOBAL load_module() NEED_load_module NEED_load_module_GLOBAL mg_findext() NEED_mg_findext NEED_mg_findext_GLOBAL my_snprintf() NEED_my_snprintf NEED_my_snprintf_GLOBAL my_sprintf() NEED_my_sprintf NEED_my_sprintf_GLOBAL my_strlcat() NEED_my_strlcat NEED_my_strlcat_GLOBAL my_strlcpy() NEED_my_strlcpy NEED_my_strlcpy_GLOBAL newCONSTSUB() NEED_newCONSTSUB NEED_newCONSTSUB_GLOBAL newRV_noinc() NEED_newRV_noinc NEED_newRV_noinc_GLOBAL newSV_type() NEED_newSV_type NEED_newSV_type_GLOBAL newSVpvn_flags() NEED_newSVpvn_flags NEED_newSVpvn_flags_GLOBAL newSVpvn_share() NEED_newSVpvn_share NEED_newSVpvn_share_GLOBAL pv_display() NEED_pv_display NEED_pv_display_GLOBAL pv_escape() NEED_pv_escape NEED_pv_escape_GLOBAL pv_pretty() NEED_pv_pretty NEED_pv_pretty_GLOBAL sv_2pv_flags() NEED_sv_2pv_flags NEED_sv_2pv_flags_GLOBAL sv_2pvbyte() NEED_sv_2pvbyte NEED_sv_2pvbyte_GLOBAL sv_catpvf_mg() NEED_sv_catpvf_mg NEED_sv_catpvf_mg_GLOBAL sv_catpvf_mg_nocontext() NEED_sv_catpvf_mg_nocontext NEED_sv_catpvf_mg_nocontext_GLOBAL sv_pvn_force_flags() NEED_sv_pvn_force_flags NEED_sv_pvn_force_flags_GLOBAL sv_setpvf_mg() NEED_sv_setpvf_mg NEED_sv_setpvf_mg_GLOBAL sv_setpvf_mg_nocontext() NEED_sv_setpvf_mg_nocontext NEED_sv_setpvf_mg_nocontext_GLOBAL sv_unmagicext() NEED_sv_unmagicext NEED_sv_unmagicext_GLOBAL vload_module() NEED_vload_module NEED_vload_module_GLOBAL vnewSVpvf() NEED_vnewSVpvf NEED_vnewSVpvf_GLOBAL warner() NEED_warner NEED_warner_GLOBAL To avoid namespace conflicts, you can change the namespace of the explicitly exported functions / variables using the C macro. Just C<#define> the macro before including C: #define DPPP_NAMESPACE MyOwnNamespace_ #include "ppport.h" The default namespace is C. =back The good thing is that most of the above can be checked by running F on your source code. See the next section for details. =head1 EXAMPLES To verify whether F is needed for your module, whether you should make any changes to your code, and whether any special defines should be used, F can be run as a Perl script to check your source code. Simply say: perl ppport.h The result will usually be a list of patches suggesting changes that should at least be acceptable, if not necessarily the most efficient solution, or a fix for all possible problems. If you know that your XS module uses features only available in newer Perl releases, if you're aware that it uses C++ comments, and if you want all suggestions as a single patch file, you could use something like this: perl ppport.h --compat-version=5.6.0 --cplusplus --patch=test.diff If you only want your code to be scanned without any suggestions for changes, use: perl ppport.h --nochanges You can specify a different C program or options, using the C<--diff> option: perl ppport.h --diff='diff -C 10' This would output context diffs with 10 lines of context. If you want to create patched copies of your files instead, use: perl ppport.h --copy=.new To display portability information for the C function, use: perl ppport.h --api-info=newSVpvn Since the argument to C<--api-info> can be a regular expression, you can use perl ppport.h --api-info=/_nomg$/ to display portability information for all C<_nomg> functions or perl ppport.h --api-info=/./ to display information for all known API elements. =head1 BUGS If this version of F is causing failure during the compilation of this module, please check if newer versions of either this module or C are available on CPAN before sending a bug report. If F was generated using the latest version of C and is causing failure of this module, please file a bug report here: L Please include the following information: =over 4 =item 1. The complete output from running "perl -V" =item 2. This file. =item 3. The name and version of the module you were trying to build. =item 4. A full log of the build that failed. =item 5. Any other information that you think could be relevant. =back For the latest version of this code, please get the C module from CPAN. =head1 COPYRIGHT Version 3.x, Copyright (c) 2004-2013, Marcus Holland-Moritz. Version 2.x, Copyright (C) 2001, Paul Marquess. Version 1.x, Copyright (C) 1999, Kenneth Albanowski. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =head1 SEE ALSO See L. =cut use strict; # Disable broken TRIE-optimization BEGIN { eval '${^RE_TRIE_MAXBUF} = -1' if $] >= 5.009004 && $] <= 5.009005 } my $VERSION = 3.35; my %opt = ( quiet => 0, diag => 1, hints => 1, changes => 1, cplusplus => 0, filter => 1, strip => 0, version => 0, ); my($ppport) = $0 =~ /([\w.]+)$/; my $LF = '(?:\r\n|[\r\n])'; # line feed my $HS = "[ \t]"; # horizontal whitespace # Never use C comments in this file! my $ccs = '/'.'*'; my $cce = '*'.'/'; my $rccs = quotemeta $ccs; my $rcce = quotemeta $cce; eval { require Getopt::Long; Getopt::Long::GetOptions(\%opt, qw( help quiet diag! filter! hints! changes! cplusplus strip version patch=s copy=s diff=s compat-version=s list-provided list-unsupported api-info=s )) or usage(); }; if ($@ and grep /^-/, @ARGV) { usage() if "@ARGV" =~ /^--?h(?:elp)?$/; die "Getopt::Long not found. Please don't use any options.\n"; } if ($opt{version}) { print "This is $0 $VERSION.\n"; exit 0; } usage() if $opt{help}; strip() if $opt{strip}; if (exists $opt{'compat-version'}) { my($r,$v,$s) = eval { parse_version($opt{'compat-version'}) }; if ($@) { die "Invalid version number format: '$opt{'compat-version'}'\n"; } die "Only Perl 5 is supported\n" if $r != 5; die "Invalid version number: $opt{'compat-version'}\n" if $v >= 1000 || $s >= 1000; $opt{'compat-version'} = sprintf "%d.%03d%03d", $r, $v, $s; } else { $opt{'compat-version'} = 5; } my %API = map { /^(\w+)\|([^|]*)\|([^|]*)\|(\w*)$/ ? ( $1 => { ($2 ? ( base => $2 ) : ()), ($3 ? ( todo => $3 ) : ()), (index($4, 'v') >= 0 ? ( varargs => 1 ) : ()), (index($4, 'p') >= 0 ? ( provided => 1 ) : ()), (index($4, 'n') >= 0 ? ( nothxarg => 1 ) : ()), } ) : die "invalid spec: $_" } qw( ASCII_TO_NEED||5.007001|n AvFILLp|5.004050||p AvFILL||| BhkDISABLE||5.024000| BhkENABLE||5.024000| BhkENTRY_set||5.024000| BhkENTRY||| BhkFLAGS||| CALL_BLOCK_HOOKS||| CLASS|||n CPERLscope|5.005000||p CX_CURPAD_SAVE||| CX_CURPAD_SV||| C_ARRAY_END|5.013002||p C_ARRAY_LENGTH|5.008001||p CopFILEAV|5.006000||p CopFILEGV_set|5.006000||p CopFILEGV|5.006000||p CopFILESV|5.006000||p CopFILE_set|5.006000||p CopFILE|5.006000||p CopSTASHPV_set|5.006000||p CopSTASHPV|5.006000||p CopSTASH_eq|5.006000||p CopSTASH_set|5.006000||p CopSTASH|5.006000||p CopyD|5.009002|5.004050|p Copy||| CvPADLIST||5.008001| CvSTASH||| CvWEAKOUTSIDE||| DECLARATION_FOR_LC_NUMERIC_MANIPULATION||5.021010|n DEFSV_set|5.010001||p DEFSV|5.004050||p DO_UTF8||5.006000| END_EXTERN_C|5.005000||p ENTER||| ERRSV|5.004050||p EXTEND||| EXTERN_C|5.005000||p F0convert|||n FREETMPS||| GIMME_V||5.004000|n GIMME|||n GROK_NUMERIC_RADIX|5.007002||p G_ARRAY||| G_DISCARD||| G_EVAL||| G_METHOD|5.006001||p G_NOARGS||| G_SCALAR||| G_VOID||5.004000| GetVars||| GvAV||| GvCV||| GvHV||| GvSV||| Gv_AMupdate||5.011000| HEf_SVKEY|5.003070||p HeHASH||5.003070| HeKEY||5.003070| HeKLEN||5.003070| HePV||5.004000| HeSVKEY_force||5.003070| HeSVKEY_set||5.004000| HeSVKEY||5.003070| HeUTF8|5.010001|5.008000|p HeVAL||5.003070| HvENAMELEN||5.015004| HvENAMEUTF8||5.015004| HvENAME||5.013007| HvNAMELEN_get|5.009003||p HvNAMELEN||5.015004| HvNAMEUTF8||5.015004| HvNAME_get|5.009003||p HvNAME||| INT2PTR|5.006000||p IN_LOCALE_COMPILETIME|5.007002||p IN_LOCALE_RUNTIME|5.007002||p IN_LOCALE|5.007002||p IN_PERL_COMPILETIME|5.008001||p IS_NUMBER_GREATER_THAN_UV_MAX|5.007002||p IS_NUMBER_INFINITY|5.007002||p IS_NUMBER_IN_UV|5.007002||p IS_NUMBER_NAN|5.007003||p IS_NUMBER_NEG|5.007002||p IS_NUMBER_NOT_INT|5.007002||p IVSIZE|5.006000||p IVTYPE|5.006000||p IVdf|5.006000||p LEAVE||| LINKLIST||5.013006| LVRET||| MARK||| MULTICALL||5.024000| MUTABLE_PTR|5.010001||p MUTABLE_SV|5.010001||p MY_CXT_CLONE|5.009002||p MY_CXT_INIT|5.007003||p MY_CXT|5.007003||p MoveD|5.009002|5.004050|p Move||| NATIVE_TO_NEED||5.007001|n NOOP|5.005000||p NUM2PTR|5.006000||p NVTYPE|5.006000||p NVef|5.006001||p NVff|5.006001||p NVgf|5.006001||p Newxc|5.009003||p Newxz|5.009003||p Newx|5.009003||p Nullav||| Nullch||| Nullcv||| Nullhv||| Nullsv||| OP_CLASS||5.013007| OP_DESC||5.007003| OP_NAME||5.007003| OP_TYPE_IS_OR_WAS||5.019010| OP_TYPE_IS||5.019007| ORIGMARK||| OpHAS_SIBLING|5.021007||p OpLASTSIB_set|5.021011||p OpMAYBESIB_set|5.021011||p OpMORESIB_set|5.021011||p OpSIBLING|5.021007||p PAD_BASE_SV||| PAD_CLONE_VARS||| PAD_COMPNAME_FLAGS||| PAD_COMPNAME_GEN_set||| PAD_COMPNAME_GEN||| PAD_COMPNAME_OURSTASH||| PAD_COMPNAME_PV||| PAD_COMPNAME_TYPE||| PAD_RESTORE_LOCAL||| PAD_SAVE_LOCAL||| PAD_SAVE_SETNULLPAD||| PAD_SETSV||| PAD_SET_CUR_NOSAVE||| PAD_SET_CUR||| PAD_SVl||| PAD_SV||| PERLIO_FUNCS_CAST|5.009003||p PERLIO_FUNCS_DECL|5.009003||p PERL_ABS|5.008001||p PERL_BCDVERSION|5.024000||p PERL_GCC_BRACE_GROUPS_FORBIDDEN|5.008001||p PERL_HASH|5.003070||p PERL_INT_MAX|5.003070||p PERL_INT_MIN|5.003070||p PERL_LONG_MAX|5.003070||p PERL_LONG_MIN|5.003070||p PERL_MAGIC_arylen|5.007002||p PERL_MAGIC_backref|5.007002||p PERL_MAGIC_bm|5.007002||p PERL_MAGIC_collxfrm|5.007002||p PERL_MAGIC_dbfile|5.007002||p PERL_MAGIC_dbline|5.007002||p PERL_MAGIC_defelem|5.007002||p PERL_MAGIC_envelem|5.007002||p PERL_MAGIC_env|5.007002||p PERL_MAGIC_ext|5.007002||p PERL_MAGIC_fm|5.007002||p PERL_MAGIC_glob|5.024000||p PERL_MAGIC_isaelem|5.007002||p PERL_MAGIC_isa|5.007002||p PERL_MAGIC_mutex|5.024000||p PERL_MAGIC_nkeys|5.007002||p PERL_MAGIC_overload_elem|5.024000||p PERL_MAGIC_overload_table|5.007002||p PERL_MAGIC_overload|5.024000||p PERL_MAGIC_pos|5.007002||p PERL_MAGIC_qr|5.007002||p PERL_MAGIC_regdata|5.007002||p PERL_MAGIC_regdatum|5.007002||p PERL_MAGIC_regex_global|5.007002||p PERL_MAGIC_shared_scalar|5.007003||p PERL_MAGIC_shared|5.007003||p PERL_MAGIC_sigelem|5.007002||p PERL_MAGIC_sig|5.007002||p PERL_MAGIC_substr|5.007002||p PERL_MAGIC_sv|5.007002||p PERL_MAGIC_taint|5.007002||p PERL_MAGIC_tiedelem|5.007002||p PERL_MAGIC_tiedscalar|5.007002||p PERL_MAGIC_tied|5.007002||p PERL_MAGIC_utf8|5.008001||p PERL_MAGIC_uvar_elem|5.007003||p PERL_MAGIC_uvar|5.007002||p PERL_MAGIC_vec|5.007002||p PERL_MAGIC_vstring|5.008001||p PERL_PV_ESCAPE_ALL|5.009004||p PERL_PV_ESCAPE_FIRSTCHAR|5.009004||p PERL_PV_ESCAPE_NOBACKSLASH|5.009004||p PERL_PV_ESCAPE_NOCLEAR|5.009004||p PERL_PV_ESCAPE_QUOTE|5.009004||p PERL_PV_ESCAPE_RE|5.009005||p PERL_PV_ESCAPE_UNI_DETECT|5.009004||p PERL_PV_ESCAPE_UNI|5.009004||p PERL_PV_PRETTY_DUMP|5.009004||p PERL_PV_PRETTY_ELLIPSES|5.010000||p PERL_PV_PRETTY_LTGT|5.009004||p PERL_PV_PRETTY_NOCLEAR|5.010000||p PERL_PV_PRETTY_QUOTE|5.009004||p PERL_PV_PRETTY_REGPROP|5.009004||p PERL_QUAD_MAX|5.003070||p PERL_QUAD_MIN|5.003070||p PERL_REVISION|5.006000||p PERL_SCAN_ALLOW_UNDERSCORES|5.007003||p PERL_SCAN_DISALLOW_PREFIX|5.007003||p PERL_SCAN_GREATER_THAN_UV_MAX|5.007003||p PERL_SCAN_SILENT_ILLDIGIT|5.008001||p PERL_SHORT_MAX|5.003070||p PERL_SHORT_MIN|5.003070||p PERL_SIGNALS_UNSAFE_FLAG|5.008001||p PERL_SUBVERSION|5.006000||p PERL_SYS_INIT3||5.006000| PERL_SYS_INIT||| PERL_SYS_TERM||5.024000| PERL_UCHAR_MAX|5.003070||p PERL_UCHAR_MIN|5.003070||p PERL_UINT_MAX|5.003070||p PERL_UINT_MIN|5.003070||p PERL_ULONG_MAX|5.003070||p PERL_ULONG_MIN|5.003070||p PERL_UNUSED_ARG|5.009003||p PERL_UNUSED_CONTEXT|5.009004||p PERL_UNUSED_DECL|5.007002||p PERL_UNUSED_RESULT|5.021001||p PERL_UNUSED_VAR|5.007002||p PERL_UQUAD_MAX|5.003070||p PERL_UQUAD_MIN|5.003070||p PERL_USE_GCC_BRACE_GROUPS|5.009004||p PERL_USHORT_MAX|5.003070||p PERL_USHORT_MIN|5.003070||p PERL_VERSION|5.006000||p PL_DBsignal|5.005000||p PL_DBsingle|||pn PL_DBsub|||pn PL_DBtrace|||pn PL_Sv|5.005000||p PL_bufend|5.024000||p PL_bufptr|5.024000||p PL_check||5.006000| PL_compiling|5.004050||p PL_comppad_name||5.017004| PL_comppad||5.008001| PL_copline|5.024000||p PL_curcop|5.004050||p PL_curpad||5.005000| PL_curstash|5.004050||p PL_debstash|5.004050||p PL_defgv|5.004050||p PL_diehook|5.004050||p PL_dirty|5.004050||p PL_dowarn|||pn PL_errgv|5.004050||p PL_error_count|5.024000||p PL_expect|5.024000||p PL_hexdigit|5.005000||p PL_hints|5.005000||p PL_in_my_stash|5.024000||p PL_in_my|5.024000||p PL_keyword_plugin||5.011002| PL_last_in_gv|||n PL_laststatval|5.005000||p PL_lex_state|5.024000||p PL_lex_stuff|5.024000||p PL_linestr|5.024000||p PL_modglobal||5.005000|n PL_na|5.004050||pn PL_no_modify|5.006000||p PL_ofsgv|||n PL_opfreehook||5.011000|n PL_parser|5.009005||p PL_peepp||5.007003|n PL_perl_destruct_level|5.004050||p PL_perldb|5.004050||p PL_ppaddr|5.006000||p PL_rpeepp||5.013005|n PL_rsfp_filters|5.024000||p PL_rsfp|5.024000||p PL_rs|||n PL_signals|5.008001||p PL_stack_base|5.004050||p PL_stack_sp|5.004050||p PL_statcache|5.005000||p PL_stdingv|5.004050||p PL_sv_arenaroot|5.004050||p PL_sv_no|5.004050||pn PL_sv_undef|5.004050||pn PL_sv_yes|5.004050||pn PL_tainted|5.004050||p PL_tainting|5.004050||p PL_tokenbuf|5.024000||p POP_MULTICALL||5.024000| POPi|||n POPl|||n POPn|||n POPpbytex||5.007001|n POPpx||5.005030|n POPp|||n POPs|||n POPul||5.006000|n POPu||5.004000|n PTR2IV|5.006000||p PTR2NV|5.006000||p PTR2UV|5.006000||p PTR2nat|5.009003||p PTR2ul|5.007001||p PTRV|5.006000||p PUSHMARK||| PUSH_MULTICALL||5.024000| PUSHi||| PUSHmortal|5.009002||p PUSHn||| PUSHp||| PUSHs||| PUSHu|5.004000||p PUTBACK||| PadARRAY||5.024000| PadMAX||5.024000| PadlistARRAY||5.024000| PadlistMAX||5.024000| PadlistNAMESARRAY||5.024000| PadlistNAMESMAX||5.024000| PadlistNAMES||5.024000| PadlistREFCNT||5.017004| PadnameIsOUR||| PadnameIsSTATE||| PadnameLEN||5.024000| PadnameOURSTASH||| PadnameOUTER||| PadnamePV||5.024000| PadnameREFCNT_dec||5.024000| PadnameREFCNT||5.024000| PadnameSV||5.024000| PadnameTYPE||| PadnameUTF8||5.021007| PadnamelistARRAY||5.024000| PadnamelistMAX||5.024000| PadnamelistREFCNT_dec||5.024000| PadnamelistREFCNT||5.024000| PerlIO_clearerr||5.007003| PerlIO_close||5.007003| PerlIO_context_layers||5.009004| PerlIO_eof||5.007003| PerlIO_error||5.007003| PerlIO_fileno||5.007003| PerlIO_fill||5.007003| PerlIO_flush||5.007003| PerlIO_get_base||5.007003| PerlIO_get_bufsiz||5.007003| PerlIO_get_cnt||5.007003| PerlIO_get_ptr||5.007003| PerlIO_read||5.007003| PerlIO_restore_errno||| PerlIO_save_errno||| PerlIO_seek||5.007003| PerlIO_set_cnt||5.007003| PerlIO_set_ptrcnt||5.007003| PerlIO_setlinebuf||5.007003| PerlIO_stderr||5.007003| PerlIO_stdin||5.007003| PerlIO_stdout||5.007003| PerlIO_tell||5.007003| PerlIO_unread||5.007003| PerlIO_write||5.007003| Perl_signbit||5.009005|n PoisonFree|5.009004||p PoisonNew|5.009004||p PoisonWith|5.009004||p Poison|5.008000||p READ_XDIGIT||5.017006| RESTORE_LC_NUMERIC||5.024000| RETVAL|||n Renewc||| Renew||| SAVECLEARSV||| SAVECOMPPAD||| SAVEPADSV||| SAVETMPS||| SAVE_DEFSV|5.004050||p SPAGAIN||| SP||| START_EXTERN_C|5.005000||p START_MY_CXT|5.007003||p STMT_END|||p STMT_START|||p STORE_LC_NUMERIC_FORCE_TO_UNDERLYING||5.024000| STORE_LC_NUMERIC_SET_TO_NEEDED||5.024000| STR_WITH_LEN|5.009003||p ST||| SV_CONST_RETURN|5.009003||p SV_COW_DROP_PV|5.008001||p SV_COW_SHARED_HASH_KEYS|5.009005||p SV_GMAGIC|5.007002||p SV_HAS_TRAILING_NUL|5.009004||p SV_IMMEDIATE_UNREF|5.007001||p SV_MUTABLE_RETURN|5.009003||p SV_NOSTEAL|5.009002||p SV_SMAGIC|5.009003||p SV_UTF8_NO_ENCODING|5.008001||p SVfARG|5.009005||p SVf_UTF8|5.006000||p SVf|5.006000||p SVt_INVLIST||5.019002| SVt_IV||| SVt_NULL||| SVt_NV||| SVt_PVAV||| SVt_PVCV||| SVt_PVFM||| SVt_PVGV||| SVt_PVHV||| SVt_PVIO||| SVt_PVIV||| SVt_PVLV||| SVt_PVMG||| SVt_PVNV||| SVt_PV||| SVt_REGEXP||5.011000| Safefree||| Slab_Alloc||| Slab_Free||| Slab_to_ro||| Slab_to_rw||| StructCopy||| SvCUR_set||| SvCUR||| SvEND||| SvGAMAGIC||5.006001| SvGETMAGIC|5.004050||p SvGROW||| SvIOK_UV||5.006000| SvIOK_notUV||5.006000| SvIOK_off||| SvIOK_only_UV||5.006000| SvIOK_only||| SvIOK_on||| SvIOKp||| SvIOK||| SvIVX||| SvIV_nomg|5.009001||p SvIV_set||| SvIVx||| SvIV||| SvIsCOW_shared_hash||5.008003| SvIsCOW||5.008003| SvLEN_set||| SvLEN||| SvLOCK||5.007003| SvMAGIC_set|5.009003||p SvNIOK_off||| SvNIOKp||| SvNIOK||| SvNOK_off||| SvNOK_only||| SvNOK_on||| SvNOKp||| SvNOK||| SvNVX||| SvNV_nomg||5.013002| SvNV_set||| SvNVx||| SvNV||| SvOK||| SvOOK_offset||5.011000| SvOOK||| SvPOK_off||| SvPOK_only_UTF8||5.006000| SvPOK_only||| SvPOK_on||| SvPOKp||| SvPOK||| SvPVX_const|5.009003||p SvPVX_mutable|5.009003||p SvPVX||| SvPV_const|5.009003||p SvPV_flags_const_nolen|5.009003||p SvPV_flags_const|5.009003||p SvPV_flags_mutable|5.009003||p SvPV_flags|5.007002||p SvPV_force_flags_mutable|5.009003||p SvPV_force_flags_nolen|5.009003||p SvPV_force_flags|5.007002||p SvPV_force_mutable|5.009003||p SvPV_force_nolen|5.009003||p SvPV_force_nomg_nolen|5.009003||p SvPV_force_nomg|5.007002||p SvPV_force|||p SvPV_mutable|5.009003||p SvPV_nolen_const|5.009003||p SvPV_nolen|5.006000||p SvPV_nomg_const_nolen|5.009003||p SvPV_nomg_const|5.009003||p SvPV_nomg_nolen|5.013007||p SvPV_nomg|5.007002||p SvPV_renew|5.009003||p SvPV_set||| SvPVbyte_force||5.009002| SvPVbyte_nolen||5.006000| SvPVbytex_force||5.006000| SvPVbytex||5.006000| SvPVbyte|5.006000||p SvPVutf8_force||5.006000| SvPVutf8_nolen||5.006000| SvPVutf8x_force||5.006000| SvPVutf8x||5.006000| SvPVutf8||5.006000| SvPVx||| SvPV||| SvREFCNT_dec_NN||5.017007| SvREFCNT_dec||| SvREFCNT_inc_NN|5.009004||p SvREFCNT_inc_simple_NN|5.009004||p SvREFCNT_inc_simple_void_NN|5.009004||p SvREFCNT_inc_simple_void|5.009004||p SvREFCNT_inc_simple|5.009004||p SvREFCNT_inc_void_NN|5.009004||p SvREFCNT_inc_void|5.009004||p SvREFCNT_inc|||p SvREFCNT||| SvROK_off||| SvROK_on||| SvROK||| SvRV_set|5.009003||p SvRV||| SvRXOK|5.009005||p SvRX|5.009005||p SvSETMAGIC||| SvSHARED_HASH|5.009003||p SvSHARE||5.007003| SvSTASH_set|5.009003||p SvSTASH||| SvSetMagicSV_nosteal||5.004000| SvSetMagicSV||5.004000| SvSetSV_nosteal||5.004000| SvSetSV||| SvTAINTED_off||5.004000| SvTAINTED_on||5.004000| SvTAINTED||5.004000| SvTAINT||| SvTHINKFIRST||| SvTRUE_nomg||5.013006| SvTRUE||| SvTYPE||| SvUNLOCK||5.007003| SvUOK|5.007001|5.006000|p SvUPGRADE||| SvUTF8_off||5.006000| SvUTF8_on||5.006000| SvUTF8||5.006000| SvUVXx|5.004000||p SvUVX|5.004000||p SvUV_nomg|5.009001||p SvUV_set|5.009003||p SvUVx|5.004000||p SvUV|5.004000||p SvVOK||5.008001| SvVSTRING_mg|5.009004||p THIS|||n UNDERBAR|5.009002||p UTF8SKIP||5.006000| UTF8_MAXBYTES|5.009002||p UVCHR_SKIP||5.022000| UVSIZE|5.006000||p UVTYPE|5.006000||p UVXf|5.007001||p UVof|5.006000||p UVuf|5.006000||p UVxf|5.006000||p WARN_ALL|5.006000||p WARN_AMBIGUOUS|5.006000||p WARN_ASSERTIONS|5.024000||p WARN_BAREWORD|5.006000||p WARN_CLOSED|5.006000||p WARN_CLOSURE|5.006000||p WARN_DEBUGGING|5.006000||p WARN_DEPRECATED|5.006000||p WARN_DIGIT|5.006000||p WARN_EXEC|5.006000||p WARN_EXITING|5.006000||p WARN_GLOB|5.006000||p WARN_INPLACE|5.006000||p WARN_INTERNAL|5.006000||p WARN_IO|5.006000||p WARN_LAYER|5.008000||p WARN_MALLOC|5.006000||p WARN_MISC|5.006000||p WARN_NEWLINE|5.006000||p WARN_NUMERIC|5.006000||p WARN_ONCE|5.006000||p WARN_OVERFLOW|5.006000||p WARN_PACK|5.006000||p WARN_PARENTHESIS|5.006000||p WARN_PIPE|5.006000||p WARN_PORTABLE|5.006000||p WARN_PRECEDENCE|5.006000||p WARN_PRINTF|5.006000||p WARN_PROTOTYPE|5.006000||p WARN_QW|5.006000||p WARN_RECURSION|5.006000||p WARN_REDEFINE|5.006000||p WARN_REGEXP|5.006000||p WARN_RESERVED|5.006000||p WARN_SEMICOLON|5.006000||p WARN_SEVERE|5.006000||p WARN_SIGNAL|5.006000||p WARN_SUBSTR|5.006000||p WARN_SYNTAX|5.006000||p WARN_TAINT|5.006000||p WARN_THREADS|5.008000||p WARN_UNINITIALIZED|5.006000||p WARN_UNOPENED|5.006000||p WARN_UNPACK|5.006000||p WARN_UNTIE|5.006000||p WARN_UTF8|5.006000||p WARN_VOID|5.006000||p WIDEST_UTYPE|5.015004||p XCPT_CATCH|5.009002||p XCPT_RETHROW|5.009002||p XCPT_TRY_END|5.009002||p XCPT_TRY_START|5.009002||p XPUSHi||| XPUSHmortal|5.009002||p XPUSHn||| XPUSHp||| XPUSHs||| XPUSHu|5.004000||p XSPROTO|5.010000||p XSRETURN_EMPTY||| XSRETURN_IV||| XSRETURN_NO||| XSRETURN_NV||| XSRETURN_PV||| XSRETURN_UNDEF||| XSRETURN_UV|5.008001||p XSRETURN_YES||| XSRETURN|||p XST_mIV||| XST_mNO||| XST_mNV||| XST_mPV||| XST_mUNDEF||| XST_mUV|5.008001||p XST_mYES||| XS_APIVERSION_BOOTCHECK||5.024000| XS_EXTERNAL||5.024000| XS_INTERNAL||5.024000| XS_VERSION_BOOTCHECK||5.024000| XS_VERSION||| XSprePUSH|5.006000||p XS||| XopDISABLE||5.024000| XopENABLE||5.024000| XopENTRYCUSTOM||5.024000| XopENTRY_set||5.024000| XopENTRY||5.024000| XopFLAGS||5.013007| ZeroD|5.009002||p Zero||| _aMY_CXT|5.007003||p _add_range_to_invlist||| _append_range_to_invlist||| _core_swash_init||| _get_encoding||| _get_regclass_nonbitmap_data||| _get_swash_invlist||| _invlistEQ||| _invlist_array_init|||n _invlist_contains_cp|||n _invlist_dump||| _invlist_intersection_maybe_complement_2nd||| _invlist_intersection||| _invlist_invert||| _invlist_len|||n _invlist_populate_swatch|||n _invlist_search|||n _invlist_subtract||| _invlist_union_maybe_complement_2nd||| _invlist_union||| _is_cur_LC_category_utf8||| _is_in_locale_category||5.021001| _is_uni_FOO||5.017008| _is_uni_perl_idcont||5.017008| _is_uni_perl_idstart||5.017007| _is_utf8_FOO||5.017008| _is_utf8_char_slow||5.021001|n _is_utf8_idcont||5.021001| _is_utf8_idstart||5.021001| _is_utf8_mark||5.017008| _is_utf8_perl_idcont||5.017008| _is_utf8_perl_idstart||5.017007| _is_utf8_xidcont||5.021001| _is_utf8_xidstart||5.021001| _load_PL_utf8_foldclosures||| _make_exactf_invlist||| _new_invlist_C_array||| _new_invlist||| _pMY_CXT|5.007003||p _setlocale_debug_string|||n _setup_canned_invlist||| _swash_inversion_hash||| _swash_to_invlist||| _to_fold_latin1||| _to_uni_fold_flags||5.014000| _to_upper_title_latin1||| _to_utf8_case||| _to_utf8_fold_flags||5.019009| _to_utf8_lower_flags||5.019009| _to_utf8_title_flags||5.019009| _to_utf8_upper_flags||5.019009| _warn_problematic_locale|||n aMY_CXT_|5.007003||p aMY_CXT|5.007003||p aTHXR_|5.024000||p aTHXR|5.024000||p aTHX_|5.006000||p aTHX|5.006000||p add_above_Latin1_folds||| add_cp_to_invlist||| add_data|||n add_multi_match||| add_utf16_textfilter||| adjust_size_and_find_bucket|||n advance_one_LB||| advance_one_SB||| advance_one_WB||| alloc_maybe_populate_EXACT||| alloccopstash||| allocmy||| amagic_call||| amagic_cmp_locale||| amagic_cmp||| amagic_deref_call||5.013007| amagic_i_ncmp||| amagic_is_enabled||| amagic_ncmp||| anonymise_cv_maybe||| any_dup||| ao||| append_utf8_from_native_byte||5.019004|n apply_attrs_my||| apply_attrs_string||5.006001| apply_attrs||| apply||| assert_uft8_cache_coherent||| assignment_type||| atfork_lock||5.007003|n atfork_unlock||5.007003|n av_arylen_p||5.009003| av_clear||| av_create_and_push||5.009005| av_create_and_unshift_one||5.009005| av_delete||5.006000| av_exists||5.006000| av_extend_guts||| av_extend||| av_fetch||| av_fill||| av_iter_p||5.011000| av_len||| av_make||| av_pop||| av_push||| av_reify||| av_shift||| av_store||| av_tindex||5.017009| av_top_index||5.017009| av_undef||| av_unshift||| ax|||n backup_one_LB||| backup_one_SB||| backup_one_WB||| bad_type_gv||| bad_type_pv||| bind_match||| block_end||5.004000| block_gimme||5.004000| block_start||5.004000| blockhook_register||5.013003| boolSV|5.004000||p boot_core_PerlIO||| boot_core_UNIVERSAL||| boot_core_mro||| bytes_cmp_utf8||5.013007| bytes_from_utf8||5.007001| bytes_to_utf8||5.006001| cBOOL|5.013000||p call_argv|5.006000||p call_atexit||5.006000| call_list||5.004000| call_method|5.006000||p call_pv|5.006000||p call_sv|5.006000||p caller_cx|5.013005|5.006000|p calloc||5.007002|n cando||| cast_i32||5.006000|n cast_iv||5.006000|n cast_ulong||5.006000|n cast_uv||5.006000|n check_locale_boundary_crossing||| check_type_and_open||| check_uni||| check_utf8_print||| checkcomma||| ckWARN|5.006000||p ck_entersub_args_core||| ck_entersub_args_list||5.013006| ck_entersub_args_proto_or_list||5.013006| ck_entersub_args_proto||5.013006| ck_warner_d||5.011001|v ck_warner||5.011001|v ckwarn_common||| ckwarn_d||5.009003| ckwarn||5.009003| clear_defarray||5.023008| clear_placeholders||| clear_special_blocks||| clone_params_del|||n clone_params_new|||n closest_cop||| cntrl_to_mnemonic|||n compute_EXACTish|||n construct_ahocorasick_from_trie||| cop_fetch_label||5.015001| cop_free||| cop_hints_2hv||5.013007| cop_hints_fetch_pvn||5.013007| cop_hints_fetch_pvs||5.013007| cop_hints_fetch_pv||5.013007| cop_hints_fetch_sv||5.013007| cop_store_label||5.015001| cophh_2hv||5.013007| cophh_copy||5.013007| cophh_delete_pvn||5.013007| cophh_delete_pvs||5.013007| cophh_delete_pv||5.013007| cophh_delete_sv||5.013007| cophh_fetch_pvn||5.013007| cophh_fetch_pvs||5.013007| cophh_fetch_pv||5.013007| cophh_fetch_sv||5.013007| cophh_free||5.013007| cophh_new_empty||5.024000| cophh_store_pvn||5.013007| cophh_store_pvs||5.013007| cophh_store_pv||5.013007| cophh_store_sv||5.013007| core_prototype||| coresub_op||| cr_textfilter||| create_eval_scope||| croak_memory_wrap||5.019003|n croak_no_mem|||n croak_no_modify||5.013003|n croak_nocontext|||vn croak_popstack|||n croak_sv||5.013001| croak_xs_usage||5.010001|n croak|||v csighandler||5.009003|n current_re_engine||| curse||| custom_op_desc||5.007003| custom_op_get_field||| custom_op_name||5.007003| custom_op_register||5.013007| custom_op_xop||5.013007| cv_ckproto_len_flags||| cv_clone_into||| cv_clone||| cv_const_sv_or_av|||n cv_const_sv||5.003070|n cv_dump||| cv_forget_slab||| cv_get_call_checker||5.013006| cv_name||5.021005| cv_set_call_checker_flags||5.021004| cv_set_call_checker||5.013006| cv_undef_flags||| cv_undef||| cvgv_from_hek||| cvgv_set||| cvstash_set||| cx_dump||5.005000| cx_dup||| cx_popblock||5.023008| cx_popeval||5.023008| cx_popformat||5.023008| cx_popgiven||5.023008| cx_poploop||5.023008| cx_popsub_args||5.023008| cx_popsub_common||5.023008| cx_popsub||5.023008| cx_popwhen||5.023008| cx_pushblock||5.023008| cx_pusheval||5.023008| cx_pushformat||5.023008| cx_pushgiven||5.023008| cx_pushloop_for||5.023008| cx_pushloop_plain||5.023008| cx_pushsub||5.023008| cx_pushwhen||5.023008| cx_topblock||5.023008| cxinc||| dAXMARK|5.009003||p dAX|5.007002||p dITEMS|5.007002||p dMARK||| dMULTICALL||5.009003| dMY_CXT_SV|5.007003||p dMY_CXT|5.007003||p dNOOP|5.006000||p dORIGMARK||| dSP||| dTHR|5.004050||p dTHXR|5.024000||p dTHXa|5.006000||p dTHXoa|5.006000||p dTHX|5.006000||p dUNDERBAR|5.009002||p dVAR|5.009003||p dXCPT|5.009002||p dXSARGS||| dXSI32||| dXSTARG|5.006000||p deb_curcv||| deb_nocontext|||vn deb_stack_all||| deb_stack_n||| debop||5.005000| debprofdump||5.005000| debprof||| debstackptrs||5.007003| debstack||5.007003| debug_start_match||| deb||5.007003|v defelem_target||| del_sv||| delete_eval_scope||| delimcpy||5.004000|n deprecate_commaless_var_list||| despatch_signals||5.007001| destroy_matcher||| die_nocontext|||vn die_sv||5.013001| die_unwind||| die|||v dirp_dup||| div128||| djSP||| do_aexec5||| do_aexec||| do_aspawn||| do_binmode||5.004050| do_chomp||| do_close||| do_delete_local||| do_dump_pad||| do_eof||| do_exec3||| do_execfree||| do_exec||| do_gv_dump||5.006000| do_gvgv_dump||5.006000| do_hv_dump||5.006000| do_ipcctl||| do_ipcget||| do_join||| do_magic_dump||5.006000| do_msgrcv||| do_msgsnd||| do_ncmp||| do_oddball||| do_op_dump||5.006000| do_open6||| do_open9||5.006000| do_open_raw||| do_openn||5.007001| do_open||5.003070| do_pmop_dump||5.006000| do_print||| do_readline||| do_seek||| do_semop||| do_shmio||| do_smartmatch||| do_spawn_nowait||| do_spawn||| do_sprintf||| do_sv_dump||5.006000| do_sysseek||| do_tell||| do_trans_complex_utf8||| do_trans_complex||| do_trans_count_utf8||| do_trans_count||| do_trans_simple_utf8||| do_trans_simple||| do_trans||| do_vecget||| do_vecset||| do_vop||| docatch||| doeval_compile||| dofile||| dofindlabel||| doform||| doing_taint||5.008001|n dooneliner||| doopen_pm||| doparseform||| dopoptoeval||| dopoptogivenfor||| dopoptolabel||| dopoptoloop||| dopoptosub_at||| dopoptowhen||| doref||5.009003| dounwind||| dowantarray||| drand48_init_r|||n drand48_r|||n dtrace_probe_call||| dtrace_probe_load||| dtrace_probe_op||| dtrace_probe_phase||| dump_all_perl||| dump_all||5.006000| dump_c_backtrace||| dump_eval||5.006000| dump_exec_pos||| dump_form||5.006000| dump_indent||5.006000|v dump_mstats||| dump_packsubs_perl||| dump_packsubs||5.006000| dump_sub_perl||| dump_sub||5.006000| dump_sv_child||| dump_trie_interim_list||| dump_trie_interim_table||| dump_trie||| dump_vindent||5.006000| dumpuntil||| dup_attrlist||| edit_distance|||n emulate_cop_io||| eval_pv|5.006000||p eval_sv|5.006000||p exec_failed||| expect_number||| fbm_compile||5.005000| fbm_instr||5.005000| feature_is_enabled||| filter_add||| filter_del||| filter_gets||| filter_read||| finalize_optree||| finalize_op||| find_and_forget_pmops||| find_array_subscript||| find_beginning||| find_byclass||| find_default_stash||| find_hash_subscript||| find_in_my_stash||| find_lexical_cv||| find_runcv_where||| find_runcv||5.008001| find_rundefsvoffset||5.009002| find_rundefsv||5.013002| find_script||| find_uninit_var||| first_symbol|||n fixup_errno_string||| foldEQ_latin1||5.013008|n foldEQ_locale||5.013002|n foldEQ_utf8_flags||5.013010| foldEQ_utf8||5.013002| foldEQ||5.013002|n fold_constants||| forbid_setid||| force_ident_maybe_lex||| force_ident||| force_list||| force_next||| force_strict_version||| force_version||| force_word||| forget_pmop||| form_nocontext|||vn form_short_octal_warning||| form||5.004000|v fp_dup||| fprintf_nocontext|||vn free_c_backtrace||| free_global_struct||| free_tied_hv_pool||| free_tmps||| gen_constant_list||| get_ANYOF_cp_list_for_ssc||| get_and_check_backslash_N_name||| get_aux_mg||| get_av|5.006000||p get_c_backtrace_dump||| get_c_backtrace||| get_context||5.006000|n get_cvn_flags||| get_cvs|5.011000||p get_cv|5.006000||p get_db_sub||| get_debug_opts||| get_hash_seed||| get_hv|5.006000||p get_invlist_iter_addr|||n get_invlist_offset_addr|||n get_invlist_previous_index_addr|||n get_mstats||| get_no_modify||| get_num||| get_op_descs||5.005000| get_op_names||5.005000| get_opargs||| get_ppaddr||5.006000| get_re_arg||| get_sv|5.006000||p get_vtbl||5.005030| getcwd_sv||5.007002| getenv_len||| glob_2number||| glob_assign_glob||| gp_dup||| gp_free||| gp_ref||| grok_atoUV|||n grok_bin|5.007003||p grok_bslash_N||| grok_bslash_c||| grok_bslash_o||| grok_bslash_x||| grok_hex|5.007003||p grok_infnan||5.021004| grok_number_flags||5.021002| grok_number|5.007002||p grok_numeric_radix|5.007002||p grok_oct|5.007003||p group_end||| gv_AVadd||| gv_HVadd||| gv_IOadd||| gv_SVadd||| gv_add_by_type||5.011000| gv_autoload4||5.004000| gv_autoload_pvn||5.015004| gv_autoload_pv||5.015004| gv_autoload_sv||5.015004| gv_check||| gv_const_sv||5.009003| gv_dump||5.006000| gv_efullname3||5.003070| gv_efullname4||5.006001| gv_efullname||| gv_fetchfile_flags||5.009005| gv_fetchfile||| gv_fetchmeth_autoload||5.007003| gv_fetchmeth_internal||| gv_fetchmeth_pv_autoload||5.015004| gv_fetchmeth_pvn_autoload||5.015004| gv_fetchmeth_pvn||5.015004| gv_fetchmeth_pv||5.015004| gv_fetchmeth_sv_autoload||5.015004| gv_fetchmeth_sv||5.015004| gv_fetchmethod_autoload||5.004000| gv_fetchmethod_pv_flags||5.015004| gv_fetchmethod_pvn_flags||5.015004| gv_fetchmethod_sv_flags||5.015004| gv_fetchmethod||| gv_fetchmeth||| gv_fetchpvn_flags|5.009002||p gv_fetchpvs|5.009004||p gv_fetchpv||| gv_fetchsv||| gv_fullname3||5.003070| gv_fullname4||5.006001| gv_fullname||| gv_handler||5.007001| gv_init_pvn||| gv_init_pv||5.015004| gv_init_svtype||| gv_init_sv||5.015004| gv_init||| gv_is_in_main||| gv_magicalize_isa||| gv_magicalize||| gv_name_set||5.009004| gv_override||| gv_setref||| gv_stashpvn_internal||| gv_stashpvn|5.003070||p gv_stashpvs|5.009003||p gv_stashpv||| gv_stashsvpvn_cached||| gv_stashsv||| gv_try_downgrade||| handle_named_backref||| handle_possible_posix||| handle_regex_sets||| he_dup||| hek_dup||| hfree_next_entry||| hfreeentries||| hsplit||| hv_assert||| hv_auxinit_internal|||n hv_auxinit||| hv_backreferences_p||| hv_clear_placeholders||5.009001| hv_clear||| hv_common_key_len||5.010000| hv_common||5.010000| hv_copy_hints_hv||5.009004| hv_delayfree_ent||5.004000| hv_delete_common||| hv_delete_ent||5.003070| hv_delete||| hv_eiter_p||5.009003| hv_eiter_set||5.009003| hv_ename_add||| hv_ename_delete||| hv_exists_ent||5.003070| hv_exists||| hv_fetch_ent||5.003070| hv_fetchs|5.009003||p hv_fetch||| hv_fill||5.013002| hv_free_ent_ret||| hv_free_ent||5.004000| hv_iterinit||| hv_iterkeysv||5.003070| hv_iterkey||| hv_iternext_flags||5.008000| hv_iternextsv||| hv_iternext||| hv_iterval||| hv_kill_backrefs||| hv_ksplit||5.003070| hv_magic_check|||n hv_magic||| hv_name_set||5.009003| hv_notallowed||| hv_placeholders_get||5.009003| hv_placeholders_p||| hv_placeholders_set||5.009003| hv_rand_set||5.018000| hv_riter_p||5.009003| hv_riter_set||5.009003| hv_scalar||5.009001| hv_store_ent||5.003070| hv_store_flags||5.008000| hv_stores|5.009004||p hv_store||| hv_undef_flags||| hv_undef||| ibcmp_locale||5.004000| ibcmp_utf8||5.007003| ibcmp||| incline||| incpush_if_exists||| incpush_use_sep||| incpush||| ingroup||| init_argv_symbols||| init_constants||| init_dbargs||| init_debugger||| init_global_struct||| init_i18nl10n||5.006000| init_i18nl14n||5.006000| init_ids||| init_interp||| init_main_stash||| init_perllib||| init_postdump_symbols||| init_predump_symbols||| init_stacks||5.005000| init_tm||5.007002| inplace_aassign||| instr|||n intro_my||5.004000| intuit_method||| intuit_more||| invert||| invlist_array|||n invlist_clear||| invlist_clone||| invlist_contents||| invlist_extend||| invlist_highest|||n invlist_is_iterating|||n invlist_iterfinish|||n invlist_iterinit|||n invlist_iternext|||n invlist_max|||n invlist_previous_index|||n invlist_replace_list_destroys_src||| invlist_set_len||| invlist_set_previous_index|||n invlist_trim|||n invoke_exception_hook||| io_close||| isALNUMC|5.006000||p isALNUM_lazy||5.021001| isALPHANUMERIC||5.017008| isALPHA||| isASCII|5.006000||p isBLANK|5.006001||p isCNTRL|5.006000||p isDIGIT||| isFOO_lc||| isFOO_utf8_lc||| isGCB|||n isGRAPH|5.006000||p isIDCONT||5.017008| isIDFIRST_lazy||5.021001| isIDFIRST||| isLB||| isLOWER||| isOCTAL||5.013005| isPRINT|5.004000||p isPSXSPC|5.006001||p isPUNCT|5.006000||p isSB||| isSPACE||| isUPPER||| isUTF8_CHAR||5.021001| isWB||| isWORDCHAR||5.013006| isXDIGIT|5.006000||p is_an_int||| is_ascii_string||5.011000| is_handle_constructor|||n is_invariant_string||5.021007|n is_lvalue_sub||5.007001| is_safe_syscall||5.019004| is_ssc_worth_it|||n is_uni_alnum_lc||5.006000| is_uni_alnumc_lc||5.017007| is_uni_alnumc||5.017007| is_uni_alnum||5.006000| is_uni_alpha_lc||5.006000| is_uni_alpha||5.006000| is_uni_ascii_lc||5.006000| is_uni_ascii||5.006000| is_uni_blank_lc||5.017002| is_uni_blank||5.017002| is_uni_cntrl_lc||5.006000| is_uni_cntrl||5.006000| is_uni_digit_lc||5.006000| is_uni_digit||5.006000| is_uni_graph_lc||5.006000| is_uni_graph||5.006000| is_uni_idfirst_lc||5.006000| is_uni_idfirst||5.006000| is_uni_lower_lc||5.006000| is_uni_lower||5.006000| is_uni_print_lc||5.006000| is_uni_print||5.006000| is_uni_punct_lc||5.006000| is_uni_punct||5.006000| is_uni_space_lc||5.006000| is_uni_space||5.006000| is_uni_upper_lc||5.006000| is_uni_upper||5.006000| is_uni_xdigit_lc||5.006000| is_uni_xdigit||5.006000| is_utf8_alnumc||5.017007| is_utf8_alnum||5.006000| is_utf8_alpha||5.006000| is_utf8_ascii||5.006000| is_utf8_blank||5.017002| is_utf8_char_buf||5.015008|n is_utf8_char||5.006000|n is_utf8_cntrl||5.006000| is_utf8_common||| is_utf8_digit||5.006000| is_utf8_graph||5.006000| is_utf8_idcont||5.008000| is_utf8_idfirst||5.006000| is_utf8_lower||5.006000| is_utf8_mark||5.006000| is_utf8_perl_space||5.011001| is_utf8_perl_word||5.011001| is_utf8_posix_digit||5.011001| is_utf8_print||5.006000| is_utf8_punct||5.006000| is_utf8_space||5.006000| is_utf8_string_loclen||5.009003|n is_utf8_string_loc||5.008001|n is_utf8_string||5.006001|n is_utf8_upper||5.006000| is_utf8_xdigit||5.006000| is_utf8_xidcont||5.013010| is_utf8_xidfirst||5.013010| isa_lookup||| isinfnansv||| isinfnan||5.021004|n items|||n ix|||n jmaybe||| join_exact||| keyword_plugin_standard||| keyword||| leave_adjust_stacks||5.023008| leave_scope||| lex_bufutf8||5.011002| lex_discard_to||5.011002| lex_grow_linestr||5.011002| lex_next_chunk||5.011002| lex_peek_unichar||5.011002| lex_read_space||5.011002| lex_read_to||5.011002| lex_read_unichar||5.011002| lex_start||5.009005| lex_stuff_pvn||5.011002| lex_stuff_pvs||5.013005| lex_stuff_pv||5.013006| lex_stuff_sv||5.011002| lex_unstuff||5.011002| listkids||| list||| load_module_nocontext|||vn load_module|5.006000||pv localize||| looks_like_bool||| looks_like_number||| lop||| mPUSHi|5.009002||p mPUSHn|5.009002||p mPUSHp|5.009002||p mPUSHs|5.010001||p mPUSHu|5.009002||p mXPUSHi|5.009002||p mXPUSHn|5.009002||p mXPUSHp|5.009002||p mXPUSHs|5.010001||p mXPUSHu|5.009002||p magic_clear_all_env||| magic_cleararylen_p||| magic_clearenv||| magic_clearhints||| magic_clearhint||| magic_clearisa||| magic_clearpack||| magic_clearsig||| magic_copycallchecker||| magic_dump||5.006000| magic_existspack||| magic_freearylen_p||| magic_freeovrld||| magic_getarylen||| magic_getdebugvar||| magic_getdefelem||| magic_getnkeys||| magic_getpack||| magic_getpos||| magic_getsig||| magic_getsubstr||| magic_gettaint||| magic_getuvar||| magic_getvec||| magic_get||| magic_killbackrefs||| magic_methcall1||| magic_methcall|||v magic_methpack||| magic_nextpack||| magic_regdata_cnt||| magic_regdatum_get||| magic_regdatum_set||| magic_scalarpack||| magic_set_all_env||| magic_setarylen||| magic_setcollxfrm||| magic_setdbline||| magic_setdebugvar||| magic_setdefelem||| magic_setenv||| magic_sethint||| magic_setisa||| magic_setlvref||| magic_setmglob||| magic_setnkeys||| magic_setpack||| magic_setpos||| magic_setregexp||| magic_setsig||| magic_setsubstr||| magic_settaint||| magic_setutf8||| magic_setuvar||| magic_setvec||| magic_set||| magic_sizepack||| magic_wipepack||| make_matcher||| make_trie||| malloc_good_size|||n malloced_size|||n malloc||5.007002|n markstack_grow||5.021001| matcher_matches_sv||| maybe_multimagic_gv||| mayberelocate||| measure_struct||| memEQs|5.009005||p memEQ|5.004000||p memNEs|5.009005||p memNE|5.004000||p mem_collxfrm||| mem_log_alloc|||n mem_log_common|||n mem_log_free|||n mem_log_realloc|||n mess_alloc||| mess_nocontext|||vn mess_sv||5.013001| mess||5.006000|v mfree||5.007002|n mg_clear||| mg_copy||| mg_dup||| mg_find_mglob||| mg_findext|5.013008||pn mg_find|||n mg_free_type||5.013006| mg_free||| mg_get||| mg_length||5.005000| mg_localize||| mg_magical|||n mg_set||| mg_size||5.005000| mini_mktime||5.007002|n minus_v||| missingterm||| mode_from_discipline||| modkids||| more_bodies||| more_sv||| moreswitches||| move_proto_attr||| mro_clean_isarev||| mro_gather_and_rename||| mro_get_from_name||5.010001| mro_get_linear_isa_dfs||| mro_get_linear_isa||5.009005| mro_get_private_data||5.010001| mro_isa_changed_in||| mro_meta_dup||| mro_meta_init||| mro_method_changed_in||5.009005| mro_package_moved||| mro_register||5.010001| mro_set_mro||5.010001| mro_set_private_data||5.010001| mul128||| mulexp10|||n multideref_stringify||| my_atof2||5.007002| my_atof||5.006000| my_attrs||| my_bcopy||5.004050|n my_bytes_to_utf8|||n my_bzero|||n my_chsize||| my_clearenv||| my_cxt_index||| my_cxt_init||| my_dirfd||5.009005|n my_exit_jump||| my_exit||| my_failure_exit||5.004000| my_fflush_all||5.006000| my_fork||5.007003|n my_kid||| my_lstat_flags||| my_lstat||5.024000| my_memcmp|||n my_memset|||n my_pclose||5.003070| my_popen_list||5.007001| my_popen||5.003070| my_setenv||| my_setlocale||| my_snprintf|5.009004||pvn my_socketpair||5.007003|n my_sprintf|5.009003||pvn my_stat_flags||| my_stat||5.024000| my_strerror||5.021001| my_strftime||5.007002| my_strlcat|5.009004||pn my_strlcpy|5.009004||pn my_unexec||| my_vsnprintf||5.009004|n need_utf8|||n newANONATTRSUB||5.006000| newANONHASH||| newANONLIST||| newANONSUB||| newASSIGNOP||| newATTRSUB_x||| newATTRSUB||5.006000| newAVREF||| newAV||| newBINOP||| newCONDOP||| newCONSTSUB_flags||5.015006| newCONSTSUB|5.004050||p newCVREF||| newDEFSVOP||5.021006| newFORM||| newFOROP||5.013007| newGIVENOP||5.009003| newGIVWHENOP||| newGP||| newGVOP||| newGVREF||| newGVgen_flags||5.015004| newGVgen||| newHVREF||| newHVhv||5.005000| newHV||| newIO||| newLISTOP||| newLOGOP||| newLOOPEX||| newLOOPOP||| newMETHOP_internal||| newMETHOP_named||5.021005| newMETHOP||5.021005| newMYSUB||5.017004| newNULLLIST||| newOP||| newPADNAMELIST||5.021007|n newPADNAMEouter||5.021007|n newPADNAMEpvn||5.021007|n newPADOP||| newPMOP||| newPROG||| newPVOP||| newRANGE||| newRV_inc|5.004000||p newRV_noinc|5.004000||p newRV||| newSLICEOP||| newSTATEOP||| newSTUB||| newSUB||| newSVOP||| newSVREF||| newSV_type|5.009005||p newSVavdefelem||| newSVhek||5.009003| newSViv||| newSVnv||| newSVpadname||5.017004| newSVpv_share||5.013006| newSVpvf_nocontext|||vn newSVpvf||5.004000|v newSVpvn_flags|5.010001||p newSVpvn_share|5.007001||p newSVpvn_utf8|5.010001||p newSVpvn|5.004050||p newSVpvs_flags|5.010001||p newSVpvs_share|5.009003||p newSVpvs|5.009003||p newSVpv||| newSVrv||| newSVsv||| newSVuv|5.006000||p newSV||| newUNOP_AUX||5.021007| newUNOP||| newWHENOP||5.009003| newWHILEOP||5.013007| newXS_deffile||| newXS_flags||5.009004| newXS_len_flags||| newXSproto||5.006000| newXS||5.006000| new_collate||5.006000| new_constant||| new_ctype||5.006000| new_he||| new_logop||| new_numeric||5.006000| new_stackinfo||5.005000| new_version||5.009000| new_warnings_bitfield||| next_symbol||| nextargv||| nextchar||| ninstr|||n no_bareword_allowed||| no_fh_allowed||| no_op||| noperl_die|||vn not_a_number||| not_incrementable||| nothreadhook||5.008000| nuke_stacks||| num_overflow|||n oopsAV||| oopsHV||| op_append_elem||5.013006| op_append_list||5.013006| op_clear||| op_contextualize||5.013006| op_convert_list||5.021006| op_dump||5.006000| op_free||| op_integerize||| op_linklist||5.013006| op_lvalue_flags||| op_lvalue||5.013007| op_null||5.007002| op_parent|||n op_prepend_elem||5.013006| op_refcnt_dec||| op_refcnt_inc||| op_refcnt_lock||5.009002| op_refcnt_unlock||5.009002| op_relocate_sv||| op_scope||5.013007| op_sibling_splice||5.021002|n op_std_init||| op_unscope||| open_script||| openn_cleanup||| openn_setup||| opmethod_stash||| opslab_force_free||| opslab_free_nopad||| opslab_free||| output_or_return_posix_warnings||| pMY_CXT_|5.007003||p pMY_CXT|5.007003||p pTHX_|5.006000||p pTHX|5.006000||p packWARN|5.007003||p pack_cat||5.007003| pack_rec||| package_version||| package||| packlist||5.008001| pad_add_anon||5.008001| pad_add_name_pvn||5.015001| pad_add_name_pvs||5.015001| pad_add_name_pv||5.015001| pad_add_name_sv||5.015001| pad_add_weakref||| pad_alloc_name||| pad_alloc||| pad_block_start||| pad_check_dup||| pad_compname_type||5.009003| pad_findlex||| pad_findmy_pvn||5.015001| pad_findmy_pvs||5.015001| pad_findmy_pv||5.015001| pad_findmy_sv||5.015001| pad_fixup_inner_anons||| pad_free||| pad_leavemy||| pad_new||5.008001| pad_push||| pad_reset||| pad_setsv||| pad_sv||| pad_swipe||| pad_tidy||5.008001| padlist_dup||| padlist_store||| padname_dup||| padname_free||| padnamelist_dup||| padnamelist_fetch||5.021007|n padnamelist_free||| padnamelist_store||5.021007| parse_arithexpr||5.013008| parse_barestmt||5.013007| parse_block||5.013007| parse_body||| parse_fullexpr||5.013008| parse_fullstmt||5.013005| parse_gv_stash_name||| parse_ident||| parse_label||5.013007| parse_listexpr||5.013008| parse_lparen_question_flags||| parse_stmtseq||5.013006| parse_subsignature||| parse_termexpr||5.013008| parse_unicode_opts||| parser_dup||| parser_free_nexttoke_ops||| parser_free||| path_is_searchable|||n peep||| pending_ident||| perl_alloc_using|||n perl_alloc|||n perl_clone_using|||n perl_clone|||n perl_construct|||n perl_destruct||5.007003|n perl_free|||n perl_parse||5.006000|n perl_run|||n pidgone||| pm_description||| pmop_dump||5.006000| pmruntime||| pmtrans||| pop_scope||| populate_ANYOF_from_invlist||| populate_isa|||v pregcomp||5.009005| pregexec||| pregfree2||5.011000| pregfree||| prescan_version||5.011004| printbuf||| printf_nocontext|||vn process_special_blocks||| ptr_hash|||n ptr_table_clear||5.009005| ptr_table_fetch||5.009005| ptr_table_find|||n ptr_table_free||5.009005| ptr_table_new||5.009005| ptr_table_split||5.009005| ptr_table_store||5.009005| push_scope||| put_charclass_bitmap_innards_common||| put_charclass_bitmap_innards_invlist||| put_charclass_bitmap_innards||| put_code_point||| put_range||| pv_display|5.006000||p pv_escape|5.009004||p pv_pretty|5.009004||p pv_uni_display||5.007003| qerror||| qsortsvu||| quadmath_format_needed|||n quadmath_format_single|||n re_compile||5.009005| re_croak2||| re_dup_guts||| re_exec_indentf|||v re_indentf|||v re_intuit_start||5.019001| re_intuit_string||5.006000| re_op_compile||| re_printf|||v realloc||5.007002|n reentrant_free||5.024000| reentrant_init||5.024000| reentrant_retry||5.024000|vn reentrant_size||5.024000| ref_array_or_hash||| refcounted_he_chain_2hv||| refcounted_he_fetch_pvn||| refcounted_he_fetch_pvs||| refcounted_he_fetch_pv||| refcounted_he_fetch_sv||| refcounted_he_free||| refcounted_he_inc||| refcounted_he_new_pvn||| refcounted_he_new_pvs||| refcounted_he_new_pv||| refcounted_he_new_sv||| refcounted_he_value||| refkids||| refto||| ref||5.024000| reg2Lanode||| reg_check_named_buff_matched|||n reg_named_buff_all||5.009005| reg_named_buff_exists||5.009005| reg_named_buff_fetch||5.009005| reg_named_buff_firstkey||5.009005| reg_named_buff_iter||| reg_named_buff_nextkey||5.009005| reg_named_buff_scalar||5.009005| reg_named_buff||| reg_node||| reg_numbered_buff_fetch||| reg_numbered_buff_length||| reg_numbered_buff_store||| reg_qr_package||| reg_recode||| reg_scan_name||| reg_skipcomment|||n reg_temp_copy||| reganode||| regatom||| regbranch||| regclass_swash||5.009004| regclass||| regcppop||| regcppush||| regcurly|||n regdump_extflags||| regdump_intflags||| regdump||5.005000| regdupe_internal||| regex_set_precedence|||n regexec_flags||5.005000| regfree_internal||5.009005| reghop3|||n reghop4|||n reghopmaybe3|||n reginclass||| reginitcolors||5.006000| reginsert||| regmatch||| regnext||5.005000| regnode_guts||| regpiece||| regprop||| regrepeat||| regtail_study||| regtail||| regtry||| reg||| repeatcpy|||n report_evil_fh||| report_redefined_cv||| report_uninit||| report_wrongway_fh||| require_pv||5.006000| require_tie_mod||| restore_magic||| rninstr|||n rpeep||| rsignal_restore||| rsignal_save||| rsignal_state||5.004000| rsignal||5.004000| run_body||| run_user_filter||| runops_debug||5.005000| runops_standard||5.005000| rv2cv_op_cv||5.013006| rvpv_dup||| rxres_free||| rxres_restore||| rxres_save||| safesyscalloc||5.006000|n safesysfree||5.006000|n safesysmalloc||5.006000|n safesysrealloc||5.006000|n same_dirent||| save_I16||5.004000| save_I32||| save_I8||5.006000| save_adelete||5.011000| save_aelem_flags||5.011000| save_aelem||5.004050| save_alloc||5.006000| save_aptr||| save_ary||| save_bool||5.008001| save_clearsv||| save_delete||| save_destructor_x||5.006000| save_destructor||5.006000| save_freeop||| save_freepv||| save_freesv||| save_generic_pvref||5.006001| save_generic_svref||5.005030| save_gp||5.004000| save_hash||| save_hdelete||5.011000| save_hek_flags|||n save_helem_flags||5.011000| save_helem||5.004050| save_hints||5.010001| save_hptr||| save_int||| save_item||| save_iv||5.005000| save_lines||| save_list||| save_long||| save_magic_flags||| save_mortalizesv||5.007001| save_nogv||| save_op||5.005000| save_padsv_and_mortalize||5.010001| save_pptr||| save_pushi32ptr||5.010001| save_pushptri32ptr||| save_pushptrptr||5.010001| save_pushptr||5.010001| save_re_context||5.006000| save_scalar_at||| save_scalar||| save_set_svflags||5.009000| save_shared_pvref||5.007003| save_sptr||| save_strlen||| save_svref||| save_vptr||5.006000| savepvn||| savepvs||5.009003| savepv||| savesharedpvn||5.009005| savesharedpvs||5.013006| savesharedpv||5.007003| savesharedsvpv||5.013006| savestack_grow_cnt||5.008001| savestack_grow||| savesvpv||5.009002| savetmps||5.023008| sawparens||| scalar_mod_type|||n scalarboolean||| scalarkids||| scalarseq||| scalarvoid||| scalar||| scan_bin||5.006000| scan_commit||| scan_const||| scan_formline||| scan_heredoc||| scan_hex||| scan_ident||| scan_inputsymbol||| scan_num||5.007001| scan_oct||| scan_pat||| scan_str||| scan_subst||| scan_trans||| scan_version||5.009001| scan_vstring||5.009005| scan_word||| search_const||| seed||5.008001| sequence_num||| set_ANYOF_arg||| set_caret_X||| set_context||5.006000|n set_numeric_local||5.006000| set_numeric_radix||5.006000| set_numeric_standard||5.006000| set_padlist|||n setdefout||| share_hek_flags||| share_hek||5.004000| should_warn_nl|||n si_dup||| sighandler|||n simplify_sort||| skip_to_be_ignored_text||| skipspace_flags||| softref2xv||| sortcv_stacked||| sortcv_xsub||| sortcv||| sortsv_flags||5.009003| sortsv||5.007003| space_join_names_mortal||| ss_dup||| ssc_add_range||| ssc_and||| ssc_anything||| ssc_clear_locale|||n ssc_cp_and||| ssc_finalize||| ssc_init||| ssc_intersection||| ssc_is_anything|||n ssc_is_cp_posixl_init|||n ssc_or||| ssc_union||| stack_grow||| start_glob||| start_subparse||5.004000| stdize_locale||| strEQ||| strGE||| strGT||| strLE||| strLT||| strNE||| str_to_version||5.006000| strip_return||| strnEQ||| strnNE||| study_chunk||| sub_crush_depth||| sublex_done||| sublex_push||| sublex_start||| sv_2bool_flags||5.013006| sv_2bool||| sv_2cv||| sv_2io||| sv_2iuv_common||| sv_2iuv_non_preserve||| sv_2iv_flags||5.009001| sv_2iv||| sv_2mortal||| sv_2num||| sv_2nv_flags||5.013001| sv_2pv_flags|5.007002||p sv_2pv_nolen|5.006000||p sv_2pvbyte_nolen|5.006000||p sv_2pvbyte|5.006000||p sv_2pvutf8_nolen||5.006000| sv_2pvutf8||5.006000| sv_2pv||| sv_2uv_flags||5.009001| sv_2uv|5.004000||p sv_add_arena||| sv_add_backref||| sv_backoff|||n sv_bless||| sv_buf_to_ro||| sv_buf_to_rw||| sv_cat_decode||5.008001| sv_catpv_flags||5.013006| sv_catpv_mg|5.004050||p sv_catpv_nomg||5.013006| sv_catpvf_mg_nocontext|||pvn sv_catpvf_mg|5.006000|5.004000|pv sv_catpvf_nocontext|||vn sv_catpvf||5.004000|v sv_catpvn_flags||5.007002| sv_catpvn_mg|5.004050||p sv_catpvn_nomg|5.007002||p sv_catpvn||| sv_catpvs_flags||5.013006| sv_catpvs_mg||5.013006| sv_catpvs_nomg||5.013006| sv_catpvs|5.009003||p sv_catpv||| sv_catsv_flags||5.007002| sv_catsv_mg|5.004050||p sv_catsv_nomg|5.007002||p sv_catsv||| sv_chop||| sv_clean_all||| sv_clean_objs||| sv_clear||| sv_cmp_flags||5.013006| sv_cmp_locale_flags||5.013006| sv_cmp_locale||5.004000| sv_cmp||| sv_collxfrm_flags||5.013006| sv_collxfrm||| sv_copypv_flags||5.017002| sv_copypv_nomg||5.017002| sv_copypv||| sv_dec_nomg||5.013002| sv_dec||| sv_del_backref||| sv_derived_from_pvn||5.015004| sv_derived_from_pv||5.015004| sv_derived_from_sv||5.015004| sv_derived_from||5.004000| sv_destroyable||5.010000| sv_display||| sv_does_pvn||5.015004| sv_does_pv||5.015004| sv_does_sv||5.015004| sv_does||5.009004| sv_dump||| sv_dup_common||| sv_dup_inc_multiple||| sv_dup_inc||| sv_dup||| sv_eq_flags||5.013006| sv_eq||| sv_exp_grow||| sv_force_normal_flags||5.007001| sv_force_normal||5.006000| sv_free2||| sv_free_arenas||| sv_free||| sv_get_backrefs||5.021008|n sv_gets||5.003070| sv_grow||| sv_i_ncmp||| sv_inc_nomg||5.013002| sv_inc||| sv_insert_flags||5.010001| sv_insert||| sv_isa||| sv_isobject||| sv_iv||5.005000| sv_kill_backrefs||| sv_len_utf8_nomg||| sv_len_utf8||5.006000| sv_len||| sv_magic_portable|5.024000|5.004000|p sv_magicext_mglob||| sv_magicext||5.007003| sv_magic||| sv_mortalcopy_flags||| sv_mortalcopy||| sv_ncmp||| sv_newmortal||| sv_newref||| sv_nolocking||5.007003| sv_nosharing||5.007003| sv_nounlocking||| sv_nv||5.005000| sv_only_taint_gmagic|||n sv_or_pv_pos_u2b||| sv_peek||5.005000| sv_pos_b2u_flags||5.019003| sv_pos_b2u_midway||| sv_pos_b2u||5.006000| sv_pos_u2b_cached||| sv_pos_u2b_flags||5.011005| sv_pos_u2b_forwards|||n sv_pos_u2b_midway|||n sv_pos_u2b||5.006000| sv_pvbyten_force||5.006000| sv_pvbyten||5.006000| sv_pvbyte||5.006000| sv_pvn_force_flags|5.007002||p sv_pvn_force||| sv_pvn_nomg|5.007003|5.005000|p sv_pvn||5.005000| sv_pvutf8n_force||5.006000| sv_pvutf8n||5.006000| sv_pvutf8||5.006000| sv_pv||5.006000| sv_recode_to_utf8||5.007003| sv_reftype||| sv_ref||5.015004| sv_replace||| sv_report_used||| sv_resetpvn||| sv_reset||| sv_rvweaken||5.006000| sv_sethek||| sv_setiv_mg|5.004050||p sv_setiv||| sv_setnv_mg|5.006000||p sv_setnv||| sv_setpv_mg|5.004050||p sv_setpvf_mg_nocontext|||pvn sv_setpvf_mg|5.006000|5.004000|pv sv_setpvf_nocontext|||vn sv_setpvf||5.004000|v sv_setpviv_mg||5.008001| sv_setpviv||5.008001| sv_setpvn_mg|5.004050||p sv_setpvn||| sv_setpvs_mg||5.013006| sv_setpvs|5.009004||p sv_setpv||| sv_setref_iv||| sv_setref_nv||| sv_setref_pvn||| sv_setref_pvs||5.024000| sv_setref_pv||| sv_setref_uv||5.007001| sv_setsv_cow||| sv_setsv_flags||5.007002| sv_setsv_mg|5.004050||p sv_setsv_nomg|5.007002||p sv_setsv||| sv_setuv_mg|5.004050||p sv_setuv|5.004000||p sv_tainted||5.004000| sv_taint||5.004000| sv_true||5.005000| sv_unglob||| sv_uni_display||5.007003| sv_unmagicext|5.013008||p sv_unmagic||| sv_unref_flags||5.007001| sv_unref||| sv_untaint||5.004000| sv_upgrade||| sv_usepvn_flags||5.009004| sv_usepvn_mg|5.004050||p sv_usepvn||| sv_utf8_decode||5.006000| sv_utf8_downgrade||5.006000| sv_utf8_encode||5.006000| sv_utf8_upgrade_flags_grow||5.011000| sv_utf8_upgrade_flags||5.007002| sv_utf8_upgrade_nomg||5.007002| sv_utf8_upgrade||5.007001| sv_uv|5.005000||p sv_vcatpvf_mg|5.006000|5.004000|p sv_vcatpvfn_flags||5.017002| sv_vcatpvfn||5.004000| sv_vcatpvf|5.006000|5.004000|p sv_vsetpvf_mg|5.006000|5.004000|p sv_vsetpvfn||5.004000| sv_vsetpvf|5.006000|5.004000|p svtype||| swallow_bom||| swash_fetch||5.007002| swash_init||5.006000| swash_scan_list_line||| swatch_get||| sync_locale||5.021004| sys_init3||5.010000|n sys_init||5.010000|n sys_intern_clear||| sys_intern_dup||| sys_intern_init||| sys_term||5.010000|n taint_env||| taint_proper||| tied_method|||v tmps_grow_p||| toFOLD_utf8||5.019001| toFOLD_uvchr||5.023009| toFOLD||5.019001| toLOWER_L1||5.019001| toLOWER_LC||5.004000| toLOWER_utf8||5.015007| toLOWER_uvchr||5.023009| toLOWER||| toTITLE_utf8||5.015007| toTITLE_uvchr||5.023009| toTITLE||5.019001| toUPPER_utf8||5.015007| toUPPER_uvchr||5.023009| toUPPER||| to_byte_substr||| to_lower_latin1|||n to_uni_fold||5.007003| to_uni_lower_lc||5.006000| to_uni_lower||5.007003| to_uni_title_lc||5.006000| to_uni_title||5.007003| to_uni_upper_lc||5.006000| to_uni_upper||5.007003| to_utf8_case||5.007003| to_utf8_fold||5.015007| to_utf8_lower||5.015007| to_utf8_substr||| to_utf8_title||5.015007| to_utf8_upper||5.015007| tokenize_use||| tokeq||| tokereport||| too_few_arguments_pv||| too_many_arguments_pv||| translate_substr_offsets|||n try_amagic_bin||| try_amagic_un||| uiv_2buf|||n unlnk||| unpack_rec||| unpack_str||5.007003| unpackstring||5.008001| unreferenced_to_tmp_stack||| unshare_hek_or_pvn||| unshare_hek||| unsharepvn||5.003070| unwind_handler_stack||| update_debugger_info||| upg_version||5.009005| usage||| utf16_textfilter||| utf16_to_utf8_reversed||5.006001| utf16_to_utf8||5.006001| utf8_distance||5.006000| utf8_hop||5.006000|n utf8_length||5.007001| utf8_mg_len_cache_update||| utf8_mg_pos_cache_update||| utf8_to_bytes||5.006001| utf8_to_uvchr_buf||5.015009| utf8_to_uvchr||5.007001| utf8_to_uvuni_buf||5.015009| utf8_to_uvuni||5.007001| utf8n_to_uvchr||5.007001| utf8n_to_uvuni||5.007001| utilize||| uvchr_to_utf8_flags||5.007003| uvchr_to_utf8||5.007001| uvoffuni_to_utf8_flags||5.019004| uvuni_to_utf8_flags||5.007003| uvuni_to_utf8||5.007001| valid_utf8_to_uvchr||5.015009| valid_utf8_to_uvuni||5.015009| validate_proto||| validate_suid||| varname||| vcmp||5.009000| vcroak||5.006000| vdeb||5.007003| vform||5.006000| visit||| vivify_defelem||| vivify_ref||| vload_module|5.006000||p vmess||5.006000| vnewSVpvf|5.006000|5.004000|p vnormal||5.009002| vnumify||5.009000| vstringify||5.009000| vverify||5.009003| vwarner||5.006000| vwarn||5.006000| wait4pid||| warn_nocontext|||vn warn_sv||5.013001| warner_nocontext|||vn warner|5.006000|5.004000|pv warn|||v was_lvalue_sub||| watch||| whichsig_pvn||5.015004| whichsig_pv||5.015004| whichsig_sv||5.015004| whichsig||| win32_croak_not_implemented|||n with_queued_errors||| wrap_op_checker||5.015008| write_to_stderr||| xs_boot_epilog||| xs_handshake|||vn xs_version_bootcheck||| yyerror_pvn||| yyerror_pv||| yyerror||| yylex||| yyparse||| yyunlex||| yywarn||| ); if (exists $opt{'list-unsupported'}) { my $f; for $f (sort { lc $a cmp lc $b } keys %API) { next unless $API{$f}{todo}; print "$f ", '.'x(40-length($f)), " ", format_version($API{$f}{todo}), "\n"; } exit 0; } # Scan for possible replacement candidates my(%replace, %need, %hints, %warnings, %depends); my $replace = 0; my($hint, $define, $function); sub find_api { my $code = shift; $code =~ s{ / (?: \*[^*]*\*+(?:[^$ccs][^*]*\*+)* / | /[^\r\n]*) | "[^"\\]*(?:\\.[^"\\]*)*" | '[^'\\]*(?:\\.[^'\\]*)*' }{}egsx; grep { exists $API{$_} } $code =~ /(\w+)/mg; } while () { if ($hint) { my $h = $hint->[0] eq 'Hint' ? \%hints : \%warnings; if (m{^\s*\*\s(.*?)\s*$}) { for (@{$hint->[1]}) { $h->{$_} ||= ''; # suppress warning with older perls $h->{$_} .= "$1\n"; } } else { undef $hint } } $hint = [$1, [split /,?\s+/, $2]] if m{^\s*$rccs\s+(Hint|Warning):\s+(\w+(?:,?\s+\w+)*)\s*$}; if ($define) { if ($define->[1] =~ /\\$/) { $define->[1] .= $_; } else { if (exists $API{$define->[0]} && $define->[1] !~ /^DPPP_\(/) { my @n = find_api($define->[1]); push @{$depends{$define->[0]}}, @n if @n } undef $define; } } $define = [$1, $2] if m{^\s*#\s*define\s+(\w+)(?:\([^)]*\))?\s+(.*)}; if ($function) { if (/^}/) { if (exists $API{$function->[0]}) { my @n = find_api($function->[1]); push @{$depends{$function->[0]}}, @n if @n } undef $function; } else { $function->[1] .= $_; } } $function = [$1, ''] if m{^DPPP_\(my_(\w+)\)}; $replace = $1 if m{^\s*$rccs\s+Replace:\s+(\d+)\s+$rcce\s*$}; $replace{$2} = $1 if $replace and m{^\s*#\s*define\s+(\w+)(?:\([^)]*\))?\s+(\w+)}; $replace{$2} = $1 if m{^\s*#\s*define\s+(\w+)(?:\([^)]*\))?\s+(\w+).*$rccs\s+Replace\s+$rcce}; $replace{$1} = $2 if m{^\s*$rccs\s+Replace (\w+) with (\w+)\s+$rcce\s*$}; if (m{^\s*$rccs\s+(\w+(\s*,\s*\w+)*)\s+depends\s+on\s+(\w+(\s*,\s*\w+)*)\s+$rcce\s*$}) { my @deps = map { s/\s+//g; $_ } split /,/, $3; my $d; for $d (map { s/\s+//g; $_ } split /,/, $1) { push @{$depends{$d}}, @deps; } } $need{$1} = 1 if m{^#if\s+defined\(NEED_(\w+)(?:_GLOBAL)?\)}; } for (values %depends) { my %s; $_ = [sort grep !$s{$_}++, @$_]; } if (exists $opt{'api-info'}) { my $f; my $count = 0; my $match = $opt{'api-info'} =~ m!^/(.*)/$! ? $1 : "^\Q$opt{'api-info'}\E\$"; for $f (sort { lc $a cmp lc $b } keys %API) { next unless $f =~ /$match/; print "\n=== $f ===\n\n"; my $info = 0; if ($API{$f}{base} || $API{$f}{todo}) { my $base = format_version($API{$f}{base} || $API{$f}{todo}); print "Supported at least starting from perl-$base.\n"; $info++; } if ($API{$f}{provided}) { my $todo = $API{$f}{todo} ? format_version($API{$f}{todo}) : "5.003"; print "Support by $ppport provided back to perl-$todo.\n"; print "Support needs to be explicitly requested by NEED_$f.\n" if exists $need{$f}; print "Depends on: ", join(', ', @{$depends{$f}}), ".\n" if exists $depends{$f}; print "\n$hints{$f}" if exists $hints{$f}; print "\nWARNING:\n$warnings{$f}" if exists $warnings{$f}; $info++; } print "No portability information available.\n" unless $info; $count++; } $count or print "Found no API matching '$opt{'api-info'}'."; print "\n"; exit 0; } if (exists $opt{'list-provided'}) { my $f; for $f (sort { lc $a cmp lc $b } keys %API) { next unless $API{$f}{provided}; my @flags; push @flags, 'explicit' if exists $need{$f}; push @flags, 'depend' if exists $depends{$f}; push @flags, 'hint' if exists $hints{$f}; push @flags, 'warning' if exists $warnings{$f}; my $flags = @flags ? ' ['.join(', ', @flags).']' : ''; print "$f$flags\n"; } exit 0; } my @files; my @srcext = qw( .xs .c .h .cc .cpp -c.inc -xs.inc ); my $srcext = join '|', map { quotemeta $_ } @srcext; if (@ARGV) { my %seen; for (@ARGV) { if (-e) { if (-f) { push @files, $_ unless $seen{$_}++; } else { warn "'$_' is not a file.\n" } } else { my @new = grep { -f } glob $_ or warn "'$_' does not exist.\n"; push @files, grep { !$seen{$_}++ } @new; } } } else { eval { require File::Find; File::Find::find(sub { $File::Find::name =~ /($srcext)$/i and push @files, $File::Find::name; }, '.'); }; if ($@) { @files = map { glob "*$_" } @srcext; } } if (!@ARGV || $opt{filter}) { my(@in, @out); my %xsc = map { /(.*)\.xs$/ ? ("$1.c" => 1, "$1.cc" => 1) : () } @files; for (@files) { my $out = exists $xsc{$_} || /\b\Q$ppport\E$/i || !/($srcext)$/i; push @{ $out ? \@out : \@in }, $_; } if (@ARGV && @out) { warning("Skipping the following files (use --nofilter to avoid this):\n| ", join "\n| ", @out); } @files = @in; } die "No input files given!\n" unless @files; my(%files, %global, %revreplace); %revreplace = reverse %replace; my $filename; my $patch_opened = 0; for $filename (@files) { unless (open IN, "<$filename") { warn "Unable to read from $filename: $!\n"; next; } info("Scanning $filename ..."); my $c = do { local $/; }; close IN; my %file = (orig => $c, changes => 0); # Temporarily remove C/XS comments and strings from the code my @ccom; $c =~ s{ ( ^$HS*\#$HS*include\b[^\r\n]+\b(?:\Q$ppport\E|XSUB\.h)\b[^\r\n]* | ^$HS*\#$HS*(?:define|elif|if(?:def)?)\b[^\r\n]* ) | ( ^$HS*\#[^\r\n]* | "[^"\\]*(?:\\.[^"\\]*)*" | '[^'\\]*(?:\\.[^'\\]*)*' | / (?: \*[^*]*\*+(?:[^$ccs][^*]*\*+)* / | /[^\r\n]* ) ) }{ defined $2 and push @ccom, $2; defined $1 ? $1 : "$ccs$#ccom$cce" }mgsex; $file{ccom} = \@ccom; $file{code} = $c; $file{has_inc_ppport} = $c =~ /^$HS*#$HS*include[^\r\n]+\b\Q$ppport\E\b/m; my $func; for $func (keys %API) { my $match = $func; $match .= "|$revreplace{$func}" if exists $revreplace{$func}; if ($c =~ /\b(?:Perl_)?($match)\b/) { $file{uses_replace}{$1}++ if exists $revreplace{$func} && $1 eq $revreplace{$func}; $file{uses_Perl}{$func}++ if $c =~ /\bPerl_$func\b/; if (exists $API{$func}{provided}) { $file{uses_provided}{$func}++; if (!exists $API{$func}{base} || $API{$func}{base} > $opt{'compat-version'}) { $file{uses}{$func}++; my @deps = rec_depend($func); if (@deps) { $file{uses_deps}{$func} = \@deps; for (@deps) { $file{uses}{$_} = 0 unless exists $file{uses}{$_}; } } for ($func, @deps) { $file{needs}{$_} = 'static' if exists $need{$_}; } } } if (exists $API{$func}{todo} && $API{$func}{todo} > $opt{'compat-version'}) { if ($c =~ /\b$func\b/) { $file{uses_todo}{$func}++; } } } } while ($c =~ /^$HS*#$HS*define$HS+(NEED_(\w+?)(_GLOBAL)?)\b/mg) { if (exists $need{$2}) { $file{defined $3 ? 'needed_global' : 'needed_static'}{$2}++; } else { warning("Possibly wrong #define $1 in $filename") } } for (qw(uses needs uses_todo needed_global needed_static)) { for $func (keys %{$file{$_}}) { push @{$global{$_}{$func}}, $filename; } } $files{$filename} = \%file; } # Globally resolve NEED_'s my $need; for $need (keys %{$global{needs}}) { if (@{$global{needs}{$need}} > 1) { my @targets = @{$global{needs}{$need}}; my @t = grep $files{$_}{needed_global}{$need}, @targets; @targets = @t if @t; @t = grep /\.xs$/i, @targets; @targets = @t if @t; my $target = shift @targets; $files{$target}{needs}{$need} = 'global'; for (@{$global{needs}{$need}}) { $files{$_}{needs}{$need} = 'extern' if $_ ne $target; } } } for $filename (@files) { exists $files{$filename} or next; info("=== Analyzing $filename ==="); my %file = %{$files{$filename}}; my $func; my $c = $file{code}; my $warnings = 0; for $func (sort keys %{$file{uses_Perl}}) { if ($API{$func}{varargs}) { unless ($API{$func}{nothxarg}) { my $changes = ($c =~ s{\b(Perl_$func\s*\(\s*)(?!aTHX_?)(\)|[^\s)]*\))} { $1 . ($2 eq ')' ? 'aTHX' : 'aTHX_ ') . $2 }ge); if ($changes) { warning("Doesn't pass interpreter argument aTHX to Perl_$func"); $file{changes} += $changes; } } } else { warning("Uses Perl_$func instead of $func"); $file{changes} += ($c =~ s{\bPerl_$func(\s*)\((\s*aTHX_?)?\s*} {$func$1(}g); } } for $func (sort keys %{$file{uses_replace}}) { warning("Uses $func instead of $replace{$func}"); $file{changes} += ($c =~ s/\b$func\b/$replace{$func}/g); } for $func (sort keys %{$file{uses_provided}}) { if ($file{uses}{$func}) { if (exists $file{uses_deps}{$func}) { diag("Uses $func, which depends on ", join(', ', @{$file{uses_deps}{$func}})); } else { diag("Uses $func"); } } $warnings += hint($func); } unless ($opt{quiet}) { for $func (sort keys %{$file{uses_todo}}) { print "*** WARNING: Uses $func, which may not be portable below perl ", format_version($API{$func}{todo}), ", even with '$ppport'\n"; $warnings++; } } for $func (sort keys %{$file{needed_static}}) { my $message = ''; if (not exists $file{uses}{$func}) { $message = "No need to define NEED_$func if $func is never used"; } elsif (exists $file{needs}{$func} && $file{needs}{$func} ne 'static') { $message = "No need to define NEED_$func when already needed globally"; } if ($message) { diag($message); $file{changes} += ($c =~ s/^$HS*#$HS*define$HS+NEED_$func\b.*$LF//mg); } } for $func (sort keys %{$file{needed_global}}) { my $message = ''; if (not exists $global{uses}{$func}) { $message = "No need to define NEED_${func}_GLOBAL if $func is never used"; } elsif (exists $file{needs}{$func}) { if ($file{needs}{$func} eq 'extern') { $message = "No need to define NEED_${func}_GLOBAL when already needed globally"; } elsif ($file{needs}{$func} eq 'static') { $message = "No need to define NEED_${func}_GLOBAL when only used in this file"; } } if ($message) { diag($message); $file{changes} += ($c =~ s/^$HS*#$HS*define$HS+NEED_${func}_GLOBAL\b.*$LF//mg); } } $file{needs_inc_ppport} = keys %{$file{uses}}; if ($file{needs_inc_ppport}) { my $pp = ''; for $func (sort keys %{$file{needs}}) { my $type = $file{needs}{$func}; next if $type eq 'extern'; my $suffix = $type eq 'global' ? '_GLOBAL' : ''; unless (exists $file{"needed_$type"}{$func}) { if ($type eq 'global') { diag("Files [@{$global{needs}{$func}}] need $func, adding global request"); } else { diag("File needs $func, adding static request"); } $pp .= "#define NEED_$func$suffix\n"; } } if ($pp && ($c =~ s/^(?=$HS*#$HS*define$HS+NEED_\w+)/$pp/m)) { $pp = ''; $file{changes}++; } unless ($file{has_inc_ppport}) { diag("Needs to include '$ppport'"); $pp .= qq(#include "$ppport"\n) } if ($pp) { $file{changes} += ($c =~ s/^($HS*#$HS*define$HS+NEED_\w+.*?)^/$1$pp/ms) || ($c =~ s/^(?=$HS*#$HS*include.*\Q$ppport\E)/$pp/m) || ($c =~ s/^($HS*#$HS*include.*XSUB.*\s*?)^/$1$pp/m) || ($c =~ s/^/$pp/); } } else { if ($file{has_inc_ppport}) { diag("No need to include '$ppport'"); $file{changes} += ($c =~ s/^$HS*?#$HS*include.*\Q$ppport\E.*?$LF//m); } } # put back in our C comments my $ix; my $cppc = 0; my @ccom = @{$file{ccom}}; for $ix (0 .. $#ccom) { if (!$opt{cplusplus} && $ccom[$ix] =~ s!^//!!) { $cppc++; $file{changes} += $c =~ s/$rccs$ix$rcce/$ccs$ccom[$ix] $cce/; } else { $c =~ s/$rccs$ix$rcce/$ccom[$ix]/; } } if ($cppc) { my $s = $cppc != 1 ? 's' : ''; warning("Uses $cppc C++ style comment$s, which is not portable"); } my $s = $warnings != 1 ? 's' : ''; my $warn = $warnings ? " ($warnings warning$s)" : ''; info("Analysis completed$warn"); if ($file{changes}) { if (exists $opt{copy}) { my $newfile = "$filename$opt{copy}"; if (-e $newfile) { error("'$newfile' already exists, refusing to write copy of '$filename'"); } else { local *F; if (open F, ">$newfile") { info("Writing copy of '$filename' with changes to '$newfile'"); print F $c; close F; } else { error("Cannot open '$newfile' for writing: $!"); } } } elsif (exists $opt{patch} || $opt{changes}) { if (exists $opt{patch}) { unless ($patch_opened) { if (open PATCH, ">$opt{patch}") { $patch_opened = 1; } else { error("Cannot open '$opt{patch}' for writing: $!"); delete $opt{patch}; $opt{changes} = 1; goto fallback; } } mydiff(\*PATCH, $filename, $c); } else { fallback: info("Suggested changes:"); mydiff(\*STDOUT, $filename, $c); } } else { my $s = $file{changes} == 1 ? '' : 's'; info("$file{changes} potentially required change$s detected"); } } else { info("Looks good"); } } close PATCH if $patch_opened; exit 0; sub try_use { eval "use @_;"; return $@ eq '' } sub mydiff { local *F = shift; my($file, $str) = @_; my $diff; if (exists $opt{diff}) { $diff = run_diff($opt{diff}, $file, $str); } if (!defined $diff and try_use('Text::Diff')) { $diff = Text::Diff::diff($file, \$str, { STYLE => 'Unified' }); $diff = <
$tmp") { print F $str; close F; if (open F, "$prog $file $tmp |") { while () { s/\Q$tmp\E/$file.patched/; $diff .= $_; } close F; unlink $tmp; return $diff; } unlink $tmp; } else { error("Cannot open '$tmp' for writing: $!"); } return undef; } sub rec_depend { my($func, $seen) = @_; return () unless exists $depends{$func}; $seen = {%{$seen||{}}}; return () if $seen->{$func}++; my %s; grep !$s{$_}++, map { ($_, rec_depend($_, $seen)) } @{$depends{$func}}; } sub parse_version { my $ver = shift; if ($ver =~ /^(\d+)\.(\d+)\.(\d+)$/) { return ($1, $2, $3); } elsif ($ver !~ /^\d+\.[\d_]+$/) { die "cannot parse version '$ver'\n"; } $ver =~ s/_//g; $ver =~ s/$/000000/; my($r,$v,$s) = $ver =~ /(\d+)\.(\d{3})(\d{3})/; $v = int $v; $s = int $s; if ($r < 5 || ($r == 5 && $v < 6)) { if ($s % 10) { die "cannot parse version '$ver'\n"; } } return ($r, $v, $s); } sub format_version { my $ver = shift; $ver =~ s/$/000000/; my($r,$v,$s) = $ver =~ /(\d+)\.(\d{3})(\d{3})/; $v = int $v; $s = int $s; if ($r < 5 || ($r == 5 && $v < 6)) { if ($s % 10) { die "invalid version '$ver'\n"; } $s /= 10; $ver = sprintf "%d.%03d", $r, $v; $s > 0 and $ver .= sprintf "_%02d", $s; return $ver; } return sprintf "%d.%d.%d", $r, $v, $s; } sub info { $opt{quiet} and return; print @_, "\n"; } sub diag { $opt{quiet} and return; $opt{diag} and print @_, "\n"; } sub warning { $opt{quiet} and return; print "*** ", @_, "\n"; } sub error { print "*** ERROR: ", @_, "\n"; } my %given_hints; my %given_warnings; sub hint { $opt{quiet} and return; my $func = shift; my $rv = 0; if (exists $warnings{$func} && !$given_warnings{$func}++) { my $warn = $warnings{$func}; $warn =~ s!^!*** !mg; print "*** WARNING: $func\n", $warn; $rv++; } if ($opt{hints} && exists $hints{$func} && !$given_hints{$func}++) { my $hint = $hints{$func}; $hint =~ s/^/ /mg; print " --- hint for $func ---\n", $hint; } $rv; } sub usage { my($usage) = do { local(@ARGV,$/)=($0); <> } =~ /^=head\d$HS+SYNOPSIS\s*^(.*?)\s*^=/ms; my %M = ( 'I' => '*' ); $usage =~ s/^\s*perl\s+\S+/$^X $0/; $usage =~ s/([A-Z])<([^>]+)>/$M{$1}$2$M{$1}/g; print < }; my($copy) = $self =~ /^=head\d\s+COPYRIGHT\s*^(.*?)^=\w+/ms; $copy =~ s/^(?=\S+)/ /gms; $self =~ s/^$HS+Do NOT edit.*?(?=^-)/$copy/ms; $self =~ s/^SKIP.*(?=^__DATA__)/SKIP if (\@ARGV && \$ARGV[0] eq '--unstrip') { eval { require Devel::PPPort }; \$@ and die "Cannot require Devel::PPPort, please install.\\n"; if (eval \$Devel::PPPort::VERSION < $VERSION) { die "$0 was originally generated with Devel::PPPort $VERSION.\\n" . "Your Devel::PPPort is only version \$Devel::PPPort::VERSION.\\n" . "Please install a newer version, or --unstrip will not work.\\n"; } Devel::PPPort::WriteFile(\$0); exit 0; } print <$0" or die "cannot strip $0: $!\n"; print OUT "$pl$c\n"; exit 0; } __DATA__ */ #ifndef _P_P_PORTABILITY_H_ #define _P_P_PORTABILITY_H_ #ifndef DPPP_NAMESPACE # define DPPP_NAMESPACE DPPP_ #endif #define DPPP_CAT2(x,y) CAT2(x,y) #define DPPP_(name) DPPP_CAT2(DPPP_NAMESPACE, name) #ifndef PERL_REVISION # if !defined(__PATCHLEVEL_H_INCLUDED__) && !(defined(PATCHLEVEL) && defined(SUBVERSION)) # define PERL_PATCHLEVEL_H_IMPLICIT # include # endif # if !(defined(PERL_VERSION) || (defined(SUBVERSION) && defined(PATCHLEVEL))) # include # endif # ifndef PERL_REVISION # define PERL_REVISION (5) /* Replace: 1 */ # define PERL_VERSION PATCHLEVEL # define PERL_SUBVERSION SUBVERSION /* Replace PERL_PATCHLEVEL with PERL_VERSION */ /* Replace: 0 */ # endif #endif #define _dpppDEC2BCD(dec) ((((dec)/100)<<8)|((((dec)%100)/10)<<4)|((dec)%10)) #define PERL_BCDVERSION ((_dpppDEC2BCD(PERL_REVISION)<<24)|(_dpppDEC2BCD(PERL_VERSION)<<12)|_dpppDEC2BCD(PERL_SUBVERSION)) /* It is very unlikely that anyone will try to use this with Perl 6 (or greater), but who knows. */ #if PERL_REVISION != 5 # error ppport.h only works with Perl version 5 #endif /* PERL_REVISION != 5 */ #ifndef dTHR # define dTHR dNOOP #endif #ifndef dTHX # define dTHX dNOOP #endif #ifndef dTHXa # define dTHXa(x) dNOOP #endif #ifndef pTHX # define pTHX void #endif #ifndef pTHX_ # define pTHX_ #endif #ifndef aTHX # define aTHX #endif #ifndef aTHX_ # define aTHX_ #endif #if (PERL_BCDVERSION < 0x5006000) # ifdef USE_THREADS # define aTHXR thr # define aTHXR_ thr, # else # define aTHXR # define aTHXR_ # endif # define dTHXR dTHR #else # define aTHXR aTHX # define aTHXR_ aTHX_ # define dTHXR dTHX #endif #ifndef dTHXoa # define dTHXoa(x) dTHXa(x) #endif #ifdef I_LIMITS # include #endif #ifndef PERL_UCHAR_MIN # define PERL_UCHAR_MIN ((unsigned char)0) #endif #ifndef PERL_UCHAR_MAX # ifdef UCHAR_MAX # define PERL_UCHAR_MAX ((unsigned char)UCHAR_MAX) # else # ifdef MAXUCHAR # define PERL_UCHAR_MAX ((unsigned char)MAXUCHAR) # else # define PERL_UCHAR_MAX ((unsigned char)~(unsigned)0) # endif # endif #endif #ifndef PERL_USHORT_MIN # define PERL_USHORT_MIN ((unsigned short)0) #endif #ifndef PERL_USHORT_MAX # ifdef USHORT_MAX # define PERL_USHORT_MAX ((unsigned short)USHORT_MAX) # else # ifdef MAXUSHORT # define PERL_USHORT_MAX ((unsigned short)MAXUSHORT) # else # ifdef USHRT_MAX # define PERL_USHORT_MAX ((unsigned short)USHRT_MAX) # else # define PERL_USHORT_MAX ((unsigned short)~(unsigned)0) # endif # endif # endif #endif #ifndef PERL_SHORT_MAX # ifdef SHORT_MAX # define PERL_SHORT_MAX ((short)SHORT_MAX) # else # ifdef MAXSHORT /* Often used in */ # define PERL_SHORT_MAX ((short)MAXSHORT) # else # ifdef SHRT_MAX # define PERL_SHORT_MAX ((short)SHRT_MAX) # else # define PERL_SHORT_MAX ((short) (PERL_USHORT_MAX >> 1)) # endif # endif # endif #endif #ifndef PERL_SHORT_MIN # ifdef SHORT_MIN # define PERL_SHORT_MIN ((short)SHORT_MIN) # else # ifdef MINSHORT # define PERL_SHORT_MIN ((short)MINSHORT) # else # ifdef SHRT_MIN # define PERL_SHORT_MIN ((short)SHRT_MIN) # else # define PERL_SHORT_MIN (-PERL_SHORT_MAX - ((3 & -1) == 3)) # endif # endif # endif #endif #ifndef PERL_UINT_MAX # ifdef UINT_MAX # define PERL_UINT_MAX ((unsigned int)UINT_MAX) # else # ifdef MAXUINT # define PERL_UINT_MAX ((unsigned int)MAXUINT) # else # define PERL_UINT_MAX (~(unsigned int)0) # endif # endif #endif #ifndef PERL_UINT_MIN # define PERL_UINT_MIN ((unsigned int)0) #endif #ifndef PERL_INT_MAX # ifdef INT_MAX # define PERL_INT_MAX ((int)INT_MAX) # else # ifdef MAXINT /* Often used in */ # define PERL_INT_MAX ((int)MAXINT) # else # define PERL_INT_MAX ((int)(PERL_UINT_MAX >> 1)) # endif # endif #endif #ifndef PERL_INT_MIN # ifdef INT_MIN # define PERL_INT_MIN ((int)INT_MIN) # else # ifdef MININT # define PERL_INT_MIN ((int)MININT) # else # define PERL_INT_MIN (-PERL_INT_MAX - ((3 & -1) == 3)) # endif # endif #endif #ifndef PERL_ULONG_MAX # ifdef ULONG_MAX # define PERL_ULONG_MAX ((unsigned long)ULONG_MAX) # else # ifdef MAXULONG # define PERL_ULONG_MAX ((unsigned long)MAXULONG) # else # define PERL_ULONG_MAX (~(unsigned long)0) # endif # endif #endif #ifndef PERL_ULONG_MIN # define PERL_ULONG_MIN ((unsigned long)0L) #endif #ifndef PERL_LONG_MAX # ifdef LONG_MAX # define PERL_LONG_MAX ((long)LONG_MAX) # else # ifdef MAXLONG # define PERL_LONG_MAX ((long)MAXLONG) # else # define PERL_LONG_MAX ((long) (PERL_ULONG_MAX >> 1)) # endif # endif #endif #ifndef PERL_LONG_MIN # ifdef LONG_MIN # define PERL_LONG_MIN ((long)LONG_MIN) # else # ifdef MINLONG # define PERL_LONG_MIN ((long)MINLONG) # else # define PERL_LONG_MIN (-PERL_LONG_MAX - ((3 & -1) == 3)) # endif # endif #endif #if defined(HAS_QUAD) && (defined(convex) || defined(uts)) # ifndef PERL_UQUAD_MAX # ifdef ULONGLONG_MAX # define PERL_UQUAD_MAX ((unsigned long long)ULONGLONG_MAX) # else # ifdef MAXULONGLONG # define PERL_UQUAD_MAX ((unsigned long long)MAXULONGLONG) # else # define PERL_UQUAD_MAX (~(unsigned long long)0) # endif # endif # endif # ifndef PERL_UQUAD_MIN # define PERL_UQUAD_MIN ((unsigned long long)0L) # endif # ifndef PERL_QUAD_MAX # ifdef LONGLONG_MAX # define PERL_QUAD_MAX ((long long)LONGLONG_MAX) # else # ifdef MAXLONGLONG # define PERL_QUAD_MAX ((long long)MAXLONGLONG) # else # define PERL_QUAD_MAX ((long long) (PERL_UQUAD_MAX >> 1)) # endif # endif # endif # ifndef PERL_QUAD_MIN # ifdef LONGLONG_MIN # define PERL_QUAD_MIN ((long long)LONGLONG_MIN) # else # ifdef MINLONGLONG # define PERL_QUAD_MIN ((long long)MINLONGLONG) # else # define PERL_QUAD_MIN (-PERL_QUAD_MAX - ((3 & -1) == 3)) # endif # endif # endif #endif /* This is based on code from 5.003 perl.h */ #ifdef HAS_QUAD # ifdef cray #ifndef IVTYPE # define IVTYPE int #endif #ifndef IV_MIN # define IV_MIN PERL_INT_MIN #endif #ifndef IV_MAX # define IV_MAX PERL_INT_MAX #endif #ifndef UV_MIN # define UV_MIN PERL_UINT_MIN #endif #ifndef UV_MAX # define UV_MAX PERL_UINT_MAX #endif # ifdef INTSIZE #ifndef IVSIZE # define IVSIZE INTSIZE #endif # endif # else # if defined(convex) || defined(uts) #ifndef IVTYPE # define IVTYPE long long #endif #ifndef IV_MIN # define IV_MIN PERL_QUAD_MIN #endif #ifndef IV_MAX # define IV_MAX PERL_QUAD_MAX #endif #ifndef UV_MIN # define UV_MIN PERL_UQUAD_MIN #endif #ifndef UV_MAX # define UV_MAX PERL_UQUAD_MAX #endif # ifdef LONGLONGSIZE #ifndef IVSIZE # define IVSIZE LONGLONGSIZE #endif # endif # else #ifndef IVTYPE # define IVTYPE long #endif #ifndef IV_MIN # define IV_MIN PERL_LONG_MIN #endif #ifndef IV_MAX # define IV_MAX PERL_LONG_MAX #endif #ifndef UV_MIN # define UV_MIN PERL_ULONG_MIN #endif #ifndef UV_MAX # define UV_MAX PERL_ULONG_MAX #endif # ifdef LONGSIZE #ifndef IVSIZE # define IVSIZE LONGSIZE #endif # endif # endif # endif #ifndef IVSIZE # define IVSIZE 8 #endif #ifndef LONGSIZE # define LONGSIZE 8 #endif #ifndef PERL_QUAD_MIN # define PERL_QUAD_MIN IV_MIN #endif #ifndef PERL_QUAD_MAX # define PERL_QUAD_MAX IV_MAX #endif #ifndef PERL_UQUAD_MIN # define PERL_UQUAD_MIN UV_MIN #endif #ifndef PERL_UQUAD_MAX # define PERL_UQUAD_MAX UV_MAX #endif #else #ifndef IVTYPE # define IVTYPE long #endif #ifndef LONGSIZE # define LONGSIZE 4 #endif #ifndef IV_MIN # define IV_MIN PERL_LONG_MIN #endif #ifndef IV_MAX # define IV_MAX PERL_LONG_MAX #endif #ifndef UV_MIN # define UV_MIN PERL_ULONG_MIN #endif #ifndef UV_MAX # define UV_MAX PERL_ULONG_MAX #endif #endif #ifndef IVSIZE # ifdef LONGSIZE # define IVSIZE LONGSIZE # else # define IVSIZE 4 /* A bold guess, but the best we can make. */ # endif #endif #ifndef UVTYPE # define UVTYPE unsigned IVTYPE #endif #ifndef UVSIZE # define UVSIZE IVSIZE #endif #ifndef sv_setuv # define sv_setuv(sv, uv) \ STMT_START { \ UV TeMpUv = uv; \ if (TeMpUv <= IV_MAX) \ sv_setiv(sv, TeMpUv); \ else \ sv_setnv(sv, (double)TeMpUv); \ } STMT_END #endif #ifndef newSVuv # define newSVuv(uv) ((uv) <= IV_MAX ? newSViv((IV)uv) : newSVnv((NV)uv)) #endif #ifndef sv_2uv # define sv_2uv(sv) ((PL_Sv = (sv)), (UV) (SvNOK(PL_Sv) ? SvNV(PL_Sv) : sv_2nv(PL_Sv))) #endif #ifndef SvUVX # define SvUVX(sv) ((UV)SvIVX(sv)) #endif #ifndef SvUVXx # define SvUVXx(sv) SvUVX(sv) #endif #ifndef SvUV # define SvUV(sv) (SvIOK(sv) ? SvUVX(sv) : sv_2uv(sv)) #endif #ifndef SvUVx # define SvUVx(sv) ((PL_Sv = (sv)), SvUV(PL_Sv)) #endif /* Hint: sv_uv * Always use the SvUVx() macro instead of sv_uv(). */ #ifndef sv_uv # define sv_uv(sv) SvUVx(sv) #endif #if !defined(SvUOK) && defined(SvIOK_UV) # define SvUOK(sv) SvIOK_UV(sv) #endif #ifndef XST_mUV # define XST_mUV(i,v) (ST(i) = sv_2mortal(newSVuv(v)) ) #endif #ifndef XSRETURN_UV # define XSRETURN_UV(v) STMT_START { XST_mUV(0,v); XSRETURN(1); } STMT_END #endif #ifndef PUSHu # define PUSHu(u) STMT_START { sv_setuv(TARG, (UV)(u)); PUSHTARG; } STMT_END #endif #ifndef XPUSHu # define XPUSHu(u) STMT_START { sv_setuv(TARG, (UV)(u)); XPUSHTARG; } STMT_END #endif #ifdef HAS_MEMCMP #ifndef memNE # define memNE(s1,s2,l) (memcmp(s1,s2,l)) #endif #ifndef memEQ # define memEQ(s1,s2,l) (!memcmp(s1,s2,l)) #endif #else #ifndef memNE # define memNE(s1,s2,l) (bcmp(s1,s2,l)) #endif #ifndef memEQ # define memEQ(s1,s2,l) (!bcmp(s1,s2,l)) #endif #endif #ifndef memEQs # define memEQs(s1, l, s2) \ (sizeof(s2)-1 == l && memEQ(s1, (s2 ""), (sizeof(s2)-1))) #endif #ifndef memNEs # define memNEs(s1, l, s2) !memEQs(s1, l, s2) #endif #ifndef MoveD # define MoveD(s,d,n,t) memmove((char*)(d),(char*)(s), (n) * sizeof(t)) #endif #ifndef CopyD # define CopyD(s,d,n,t) memcpy((char*)(d),(char*)(s), (n) * sizeof(t)) #endif #ifdef HAS_MEMSET #ifndef ZeroD # define ZeroD(d,n,t) memzero((char*)(d), (n) * sizeof(t)) #endif #else #ifndef ZeroD # define ZeroD(d,n,t) ((void)memzero((char*)(d), (n) * sizeof(t)), d) #endif #endif #ifndef PoisonWith # define PoisonWith(d,n,t,b) (void)memset((char*)(d), (U8)(b), (n) * sizeof(t)) #endif #ifndef PoisonNew # define PoisonNew(d,n,t) PoisonWith(d,n,t,0xAB) #endif #ifndef PoisonFree # define PoisonFree(d,n,t) PoisonWith(d,n,t,0xEF) #endif #ifndef Poison # define Poison(d,n,t) PoisonFree(d,n,t) #endif #ifndef Newx # define Newx(v,n,t) New(0,v,n,t) #endif #ifndef Newxc # define Newxc(v,n,t,c) Newc(0,v,n,t,c) #endif #ifndef Newxz # define Newxz(v,n,t) Newz(0,v,n,t) #endif #ifndef PERL_MAGIC_qr # define PERL_MAGIC_qr 'r' #endif #ifndef cBOOL # define cBOOL(cbool) ((cbool) ? (bool)1 : (bool)0) #endif #ifndef OpHAS_SIBLING # define OpHAS_SIBLING(o) (cBOOL((o)->op_sibling)) #endif #ifndef OpSIBLING # define OpSIBLING(o) (0 + (o)->op_sibling) #endif #ifndef OpMORESIB_set # define OpMORESIB_set(o, sib) ((o)->op_sibling = (sib)) #endif #ifndef OpLASTSIB_set # define OpLASTSIB_set(o, parent) ((o)->op_sibling = NULL) #endif #ifndef OpMAYBESIB_set # define OpMAYBESIB_set(o, sib, parent) ((o)->op_sibling = (sib)) #endif #ifndef SvRX #if defined(NEED_SvRX) static void * DPPP_(my_SvRX)(pTHX_ SV *rv); static #else extern void * DPPP_(my_SvRX)(pTHX_ SV *rv); #endif #ifdef SvRX # undef SvRX #endif #define SvRX(a) DPPP_(my_SvRX)(aTHX_ a) #if defined(NEED_SvRX) || defined(NEED_SvRX_GLOBAL) void * DPPP_(my_SvRX)(pTHX_ SV *rv) { if (SvROK(rv)) { SV *sv = SvRV(rv); if (SvMAGICAL(sv)) { MAGIC *mg = mg_find(sv, PERL_MAGIC_qr); if (mg && mg->mg_obj) { return mg->mg_obj; } } } return 0; } #endif #endif #ifndef SvRXOK # define SvRXOK(sv) (!!SvRX(sv)) #endif #ifndef PERL_UNUSED_DECL # ifdef HASATTRIBUTE # if (defined(__GNUC__) && defined(__cplusplus)) || defined(__INTEL_COMPILER) # define PERL_UNUSED_DECL # else # define PERL_UNUSED_DECL __attribute__((unused)) # endif # else # define PERL_UNUSED_DECL # endif #endif #ifndef PERL_UNUSED_ARG # if defined(lint) && defined(S_SPLINT_S) /* www.splint.org */ # include # define PERL_UNUSED_ARG(x) NOTE(ARGUNUSED(x)) # else # define PERL_UNUSED_ARG(x) ((void)x) # endif #endif #ifndef PERL_UNUSED_VAR # define PERL_UNUSED_VAR(x) ((void)x) #endif #ifndef PERL_UNUSED_CONTEXT # ifdef USE_ITHREADS # define PERL_UNUSED_CONTEXT PERL_UNUSED_ARG(my_perl) # else # define PERL_UNUSED_CONTEXT # endif #endif #ifndef PERL_UNUSED_RESULT # if defined(__GNUC__) && defined(HASATTRIBUTE_WARN_UNUSED_RESULT) # define PERL_UNUSED_RESULT(v) STMT_START { __typeof__(v) z = (v); (void)sizeof(z); } STMT_END # else # define PERL_UNUSED_RESULT(v) ((void)(v)) # endif #endif #ifndef NOOP # define NOOP /*EMPTY*/(void)0 #endif #ifndef dNOOP # define dNOOP extern int /*@unused@*/ Perl___notused PERL_UNUSED_DECL #endif #ifndef NVTYPE # if defined(USE_LONG_DOUBLE) && defined(HAS_LONG_DOUBLE) # define NVTYPE long double # else # define NVTYPE double # endif typedef NVTYPE NV; #endif #ifndef INT2PTR # if (IVSIZE == PTRSIZE) && (UVSIZE == PTRSIZE) # define PTRV UV # define INT2PTR(any,d) (any)(d) # else # if PTRSIZE == LONGSIZE # define PTRV unsigned long # else # define PTRV unsigned # endif # define INT2PTR(any,d) (any)(PTRV)(d) # endif #endif #ifndef PTR2ul # if PTRSIZE == LONGSIZE # define PTR2ul(p) (unsigned long)(p) # else # define PTR2ul(p) INT2PTR(unsigned long,p) # endif #endif #ifndef PTR2nat # define PTR2nat(p) (PTRV)(p) #endif #ifndef NUM2PTR # define NUM2PTR(any,d) (any)PTR2nat(d) #endif #ifndef PTR2IV # define PTR2IV(p) INT2PTR(IV,p) #endif #ifndef PTR2UV # define PTR2UV(p) INT2PTR(UV,p) #endif #ifndef PTR2NV # define PTR2NV(p) NUM2PTR(NV,p) #endif #undef START_EXTERN_C #undef END_EXTERN_C #undef EXTERN_C #ifdef __cplusplus # define START_EXTERN_C extern "C" { # define END_EXTERN_C } # define EXTERN_C extern "C" #else # define START_EXTERN_C # define END_EXTERN_C # define EXTERN_C extern #endif #if defined(PERL_GCC_PEDANTIC) # ifndef PERL_GCC_BRACE_GROUPS_FORBIDDEN # define PERL_GCC_BRACE_GROUPS_FORBIDDEN # endif #endif #if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) && !defined(__cplusplus) # ifndef PERL_USE_GCC_BRACE_GROUPS # define PERL_USE_GCC_BRACE_GROUPS # endif #endif #undef STMT_START #undef STMT_END #ifdef PERL_USE_GCC_BRACE_GROUPS # define STMT_START (void)( /* gcc supports ``({ STATEMENTS; })'' */ # define STMT_END ) #else # if defined(VOIDFLAGS) && (VOIDFLAGS) && (defined(sun) || defined(__sun__)) && !defined(__GNUC__) # define STMT_START if (1) # define STMT_END else (void)0 # else # define STMT_START do # define STMT_END while (0) # endif #endif #ifndef boolSV # define boolSV(b) ((b) ? &PL_sv_yes : &PL_sv_no) #endif /* DEFSV appears first in 5.004_56 */ #ifndef DEFSV # define DEFSV GvSV(PL_defgv) #endif #ifndef SAVE_DEFSV # define SAVE_DEFSV SAVESPTR(GvSV(PL_defgv)) #endif #ifndef DEFSV_set # define DEFSV_set(sv) (DEFSV = (sv)) #endif /* Older perls (<=5.003) lack AvFILLp */ #ifndef AvFILLp # define AvFILLp AvFILL #endif #ifndef ERRSV # define ERRSV get_sv("@",FALSE) #endif /* Hint: gv_stashpvn * This function's backport doesn't support the length parameter, but * rather ignores it. Portability can only be ensured if the length * parameter is used for speed reasons, but the length can always be * correctly computed from the string argument. */ #ifndef gv_stashpvn # define gv_stashpvn(str,len,create) gv_stashpv(str,create) #endif /* Replace: 1 */ #ifndef get_cv # define get_cv perl_get_cv #endif #ifndef get_sv # define get_sv perl_get_sv #endif #ifndef get_av # define get_av perl_get_av #endif #ifndef get_hv # define get_hv perl_get_hv #endif /* Replace: 0 */ #ifndef dUNDERBAR # define dUNDERBAR dNOOP #endif #ifndef UNDERBAR # define UNDERBAR DEFSV #endif #ifndef dAX # define dAX I32 ax = MARK - PL_stack_base + 1 #endif #ifndef dITEMS # define dITEMS I32 items = SP - MARK #endif #ifndef dXSTARG # define dXSTARG SV * targ = sv_newmortal() #endif #ifndef dAXMARK # define dAXMARK I32 ax = POPMARK; \ register SV ** const mark = PL_stack_base + ax++ #endif #ifndef XSprePUSH # define XSprePUSH (sp = PL_stack_base + ax - 1) #endif #if (PERL_BCDVERSION < 0x5005000) # undef XSRETURN # define XSRETURN(off) \ STMT_START { \ PL_stack_sp = PL_stack_base + ax + ((off) - 1); \ return; \ } STMT_END #endif #ifndef XSPROTO # define XSPROTO(name) void name(pTHX_ CV* cv) #endif #ifndef SVfARG # define SVfARG(p) ((void*)(p)) #endif #ifndef PERL_ABS # define PERL_ABS(x) ((x) < 0 ? -(x) : (x)) #endif #ifndef dVAR # define dVAR dNOOP #endif #ifndef SVf # define SVf "_" #endif #ifndef UTF8_MAXBYTES # define UTF8_MAXBYTES UTF8_MAXLEN #endif #ifndef CPERLscope # define CPERLscope(x) x #endif #ifndef PERL_HASH # define PERL_HASH(hash,str,len) \ STMT_START { \ const char *s_PeRlHaSh = str; \ I32 i_PeRlHaSh = len; \ U32 hash_PeRlHaSh = 0; \ while (i_PeRlHaSh--) \ hash_PeRlHaSh = hash_PeRlHaSh * 33 + *s_PeRlHaSh++; \ (hash) = hash_PeRlHaSh; \ } STMT_END #endif #ifndef PERLIO_FUNCS_DECL # ifdef PERLIO_FUNCS_CONST # define PERLIO_FUNCS_DECL(funcs) const PerlIO_funcs funcs # define PERLIO_FUNCS_CAST(funcs) (PerlIO_funcs*)(funcs) # else # define PERLIO_FUNCS_DECL(funcs) PerlIO_funcs funcs # define PERLIO_FUNCS_CAST(funcs) (funcs) # endif #endif /* provide these typedefs for older perls */ #if (PERL_BCDVERSION < 0x5009003) # ifdef ARGSproto typedef OP* (CPERLscope(*Perl_ppaddr_t))(ARGSproto); # else typedef OP* (CPERLscope(*Perl_ppaddr_t))(pTHX); # endif typedef OP* (CPERLscope(*Perl_check_t)) (pTHX_ OP*); #endif #ifndef isPSXSPC # define isPSXSPC(c) (isSPACE(c) || (c) == '\v') #endif #ifndef isBLANK # define isBLANK(c) ((c) == ' ' || (c) == '\t') #endif #ifdef EBCDIC #ifndef isALNUMC # define isALNUMC(c) isalnum(c) #endif #ifndef isASCII # define isASCII(c) isascii(c) #endif #ifndef isCNTRL # define isCNTRL(c) iscntrl(c) #endif #ifndef isGRAPH # define isGRAPH(c) isgraph(c) #endif #ifndef isPRINT # define isPRINT(c) isprint(c) #endif #ifndef isPUNCT # define isPUNCT(c) ispunct(c) #endif #ifndef isXDIGIT # define isXDIGIT(c) isxdigit(c) #endif #else # if (PERL_BCDVERSION < 0x5010000) /* Hint: isPRINT * The implementation in older perl versions includes all of the * isSPACE() characters, which is wrong. The version provided by * Devel::PPPort always overrides a present buggy version. */ # undef isPRINT # endif #ifdef HAS_QUAD # ifdef U64TYPE # define WIDEST_UTYPE U64TYPE # else # define WIDEST_UTYPE Quad_t # endif #else # define WIDEST_UTYPE U32 #endif #ifndef isALNUMC # define isALNUMC(c) (isALPHA(c) || isDIGIT(c)) #endif #ifndef isASCII # define isASCII(c) ((WIDEST_UTYPE) (c) <= 127) #endif #ifndef isCNTRL # define isCNTRL(c) ((WIDEST_UTYPE) (c) < ' ' || (c) == 127) #endif #ifndef isGRAPH # define isGRAPH(c) (isALNUM(c) || isPUNCT(c)) #endif #ifndef isPRINT # define isPRINT(c) (((c) >= 32 && (c) < 127)) #endif #ifndef isPUNCT # define isPUNCT(c) (((c) >= 33 && (c) <= 47) || ((c) >= 58 && (c) <= 64) || ((c) >= 91 && (c) <= 96) || ((c) >= 123 && (c) <= 126)) #endif #ifndef isXDIGIT # define isXDIGIT(c) (isDIGIT(c) || ((c) >= 'a' && (c) <= 'f') || ((c) >= 'A' && (c) <= 'F')) #endif #endif /* Until we figure out how to support this in older perls... */ #if (PERL_BCDVERSION >= 0x5008000) #ifndef HeUTF8 # define HeUTF8(he) ((HeKLEN(he) == HEf_SVKEY) ? \ SvUTF8(HeKEY_sv(he)) : \ (U32)HeKUTF8(he)) #endif #endif #ifndef C_ARRAY_LENGTH # define C_ARRAY_LENGTH(a) (sizeof(a)/sizeof((a)[0])) #endif #ifndef C_ARRAY_END # define C_ARRAY_END(a) ((a) + C_ARRAY_LENGTH(a)) #endif #ifndef PERL_SIGNALS_UNSAFE_FLAG #define PERL_SIGNALS_UNSAFE_FLAG 0x0001 #if (PERL_BCDVERSION < 0x5008000) # define D_PPP_PERL_SIGNALS_INIT PERL_SIGNALS_UNSAFE_FLAG #else # define D_PPP_PERL_SIGNALS_INIT 0 #endif #if defined(NEED_PL_signals) static U32 DPPP_(my_PL_signals) = D_PPP_PERL_SIGNALS_INIT; #elif defined(NEED_PL_signals_GLOBAL) U32 DPPP_(my_PL_signals) = D_PPP_PERL_SIGNALS_INIT; #else extern U32 DPPP_(my_PL_signals); #endif #define PL_signals DPPP_(my_PL_signals) #endif /* Hint: PL_ppaddr * Calling an op via PL_ppaddr requires passing a context argument * for threaded builds. Since the context argument is different for * 5.005 perls, you can use aTHXR (supplied by ppport.h), which will * automatically be defined as the correct argument. */ #if (PERL_BCDVERSION <= 0x5005005) /* Replace: 1 */ # define PL_ppaddr ppaddr # define PL_no_modify no_modify /* Replace: 0 */ #endif #if (PERL_BCDVERSION <= 0x5004005) /* Replace: 1 */ # define PL_DBsignal DBsignal # define PL_DBsingle DBsingle # define PL_DBsub DBsub # define PL_DBtrace DBtrace # define PL_Sv Sv # define PL_bufend bufend # define PL_bufptr bufptr # define PL_compiling compiling # define PL_copline copline # define PL_curcop curcop # define PL_curstash curstash # define PL_debstash debstash # define PL_defgv defgv # define PL_diehook diehook # define PL_dirty dirty # define PL_dowarn dowarn # define PL_errgv errgv # define PL_error_count error_count # define PL_expect expect # define PL_hexdigit hexdigit # define PL_hints hints # define PL_in_my in_my # define PL_laststatval laststatval # define PL_lex_state lex_state # define PL_lex_stuff lex_stuff # define PL_linestr linestr # define PL_na na # define PL_perl_destruct_level perl_destruct_level # define PL_perldb perldb # define PL_rsfp_filters rsfp_filters # define PL_rsfp rsfp # define PL_stack_base stack_base # define PL_stack_sp stack_sp # define PL_statcache statcache # define PL_stdingv stdingv # define PL_sv_arenaroot sv_arenaroot # define PL_sv_no sv_no # define PL_sv_undef sv_undef # define PL_sv_yes sv_yes # define PL_tainted tainted # define PL_tainting tainting # define PL_tokenbuf tokenbuf /* Replace: 0 */ #endif /* Warning: PL_parser * For perl versions earlier than 5.9.5, this is an always * non-NULL dummy. Also, it cannot be dereferenced. Don't * use it if you can avoid is and unless you absolutely know * what you're doing. * If you always check that PL_parser is non-NULL, you can * define DPPP_PL_parser_NO_DUMMY to avoid the creation of * a dummy parser structure. */ #if (PERL_BCDVERSION >= 0x5009005) # ifdef DPPP_PL_parser_NO_DUMMY # define D_PPP_my_PL_parser_var(var) ((PL_parser ? PL_parser : \ (croak("panic: PL_parser == NULL in %s:%d", \ __FILE__, __LINE__), (yy_parser *) NULL))->var) # else # ifdef DPPP_PL_parser_NO_DUMMY_WARNING # define D_PPP_parser_dummy_warning(var) # else # define D_PPP_parser_dummy_warning(var) \ warn("warning: dummy PL_" #var " used in %s:%d", __FILE__, __LINE__), # endif # define D_PPP_my_PL_parser_var(var) ((PL_parser ? PL_parser : \ (D_PPP_parser_dummy_warning(var) &DPPP_(dummy_PL_parser)))->var) #if defined(NEED_PL_parser) static yy_parser DPPP_(dummy_PL_parser); #elif defined(NEED_PL_parser_GLOBAL) yy_parser DPPP_(dummy_PL_parser); #else extern yy_parser DPPP_(dummy_PL_parser); #endif # endif /* PL_expect, PL_copline, PL_rsfp, PL_rsfp_filters, PL_linestr, PL_bufptr, PL_bufend, PL_lex_state, PL_lex_stuff, PL_tokenbuf depends on PL_parser */ /* Warning: PL_expect, PL_copline, PL_rsfp, PL_rsfp_filters, PL_linestr, PL_bufptr, PL_bufend, PL_lex_state, PL_lex_stuff, PL_tokenbuf * Do not use this variable unless you know exactly what you're * doing. It is internal to the perl parser and may change or even * be removed in the future. As of perl 5.9.5, you have to check * for (PL_parser != NULL) for this variable to have any effect. * An always non-NULL PL_parser dummy is provided for earlier * perl versions. * If PL_parser is NULL when you try to access this variable, a * dummy is being accessed instead and a warning is issued unless * you define DPPP_PL_parser_NO_DUMMY_WARNING. * If DPPP_PL_parser_NO_DUMMY is defined, the code trying to access * this variable will croak with a panic message. */ # define PL_expect D_PPP_my_PL_parser_var(expect) # define PL_copline D_PPP_my_PL_parser_var(copline) # define PL_rsfp D_PPP_my_PL_parser_var(rsfp) # define PL_rsfp_filters D_PPP_my_PL_parser_var(rsfp_filters) # define PL_linestr D_PPP_my_PL_parser_var(linestr) # define PL_bufptr D_PPP_my_PL_parser_var(bufptr) # define PL_bufend D_PPP_my_PL_parser_var(bufend) # define PL_lex_state D_PPP_my_PL_parser_var(lex_state) # define PL_lex_stuff D_PPP_my_PL_parser_var(lex_stuff) # define PL_tokenbuf D_PPP_my_PL_parser_var(tokenbuf) # define PL_in_my D_PPP_my_PL_parser_var(in_my) # define PL_in_my_stash D_PPP_my_PL_parser_var(in_my_stash) # define PL_error_count D_PPP_my_PL_parser_var(error_count) #else /* ensure that PL_parser != NULL and cannot be dereferenced */ # define PL_parser ((void *) 1) #endif #ifndef mPUSHs # define mPUSHs(s) PUSHs(sv_2mortal(s)) #endif #ifndef PUSHmortal # define PUSHmortal PUSHs(sv_newmortal()) #endif #ifndef mPUSHp # define mPUSHp(p,l) sv_setpvn(PUSHmortal, (p), (l)) #endif #ifndef mPUSHn # define mPUSHn(n) sv_setnv(PUSHmortal, (NV)(n)) #endif #ifndef mPUSHi # define mPUSHi(i) sv_setiv(PUSHmortal, (IV)(i)) #endif #ifndef mPUSHu # define mPUSHu(u) sv_setuv(PUSHmortal, (UV)(u)) #endif #ifndef mXPUSHs # define mXPUSHs(s) XPUSHs(sv_2mortal(s)) #endif #ifndef XPUSHmortal # define XPUSHmortal XPUSHs(sv_newmortal()) #endif #ifndef mXPUSHp # define mXPUSHp(p,l) STMT_START { EXTEND(sp,1); sv_setpvn(PUSHmortal, (p), (l)); } STMT_END #endif #ifndef mXPUSHn # define mXPUSHn(n) STMT_START { EXTEND(sp,1); sv_setnv(PUSHmortal, (NV)(n)); } STMT_END #endif #ifndef mXPUSHi # define mXPUSHi(i) STMT_START { EXTEND(sp,1); sv_setiv(PUSHmortal, (IV)(i)); } STMT_END #endif #ifndef mXPUSHu # define mXPUSHu(u) STMT_START { EXTEND(sp,1); sv_setuv(PUSHmortal, (UV)(u)); } STMT_END #endif /* Replace: 1 */ #ifndef call_sv # define call_sv perl_call_sv #endif #ifndef call_pv # define call_pv perl_call_pv #endif #ifndef call_argv # define call_argv perl_call_argv #endif #ifndef call_method # define call_method perl_call_method #endif #ifndef eval_sv # define eval_sv perl_eval_sv #endif /* Replace: 0 */ #ifndef PERL_LOADMOD_DENY # define PERL_LOADMOD_DENY 0x1 #endif #ifndef PERL_LOADMOD_NOIMPORT # define PERL_LOADMOD_NOIMPORT 0x2 #endif #ifndef PERL_LOADMOD_IMPORT_OPS # define PERL_LOADMOD_IMPORT_OPS 0x4 #endif #ifndef G_METHOD # define G_METHOD 64 # ifdef call_sv # undef call_sv # endif # if (PERL_BCDVERSION < 0x5006000) # define call_sv(sv, flags) ((flags) & G_METHOD ? perl_call_method((char *) SvPV_nolen_const(sv), \ (flags) & ~G_METHOD) : perl_call_sv(sv, flags)) # else # define call_sv(sv, flags) ((flags) & G_METHOD ? Perl_call_method(aTHX_ (char *) SvPV_nolen_const(sv), \ (flags) & ~G_METHOD) : Perl_call_sv(aTHX_ sv, flags)) # endif #endif /* Replace perl_eval_pv with eval_pv */ #ifndef eval_pv #if defined(NEED_eval_pv) static SV* DPPP_(my_eval_pv)(char *p, I32 croak_on_error); static #else extern SV* DPPP_(my_eval_pv)(char *p, I32 croak_on_error); #endif #ifdef eval_pv # undef eval_pv #endif #define eval_pv(a,b) DPPP_(my_eval_pv)(aTHX_ a,b) #define Perl_eval_pv DPPP_(my_eval_pv) #if defined(NEED_eval_pv) || defined(NEED_eval_pv_GLOBAL) SV* DPPP_(my_eval_pv)(char *p, I32 croak_on_error) { dSP; SV* sv = newSVpv(p, 0); PUSHMARK(sp); eval_sv(sv, G_SCALAR); SvREFCNT_dec(sv); SPAGAIN; sv = POPs; PUTBACK; if (croak_on_error && SvTRUE(GvSV(errgv))) croak(SvPVx(GvSV(errgv), na)); return sv; } #endif #endif #ifndef vload_module #if defined(NEED_vload_module) static void DPPP_(my_vload_module)(U32 flags, SV *name, SV *ver, va_list *args); static #else extern void DPPP_(my_vload_module)(U32 flags, SV *name, SV *ver, va_list *args); #endif #ifdef vload_module # undef vload_module #endif #define vload_module(a,b,c,d) DPPP_(my_vload_module)(aTHX_ a,b,c,d) #define Perl_vload_module DPPP_(my_vload_module) #if defined(NEED_vload_module) || defined(NEED_vload_module_GLOBAL) void DPPP_(my_vload_module)(U32 flags, SV *name, SV *ver, va_list *args) { dTHR; dVAR; OP *veop, *imop; OP * const modname = newSVOP(OP_CONST, 0, name); /* 5.005 has a somewhat hacky force_normal that doesn't croak on SvREADONLY() if PL_compling is true. Current perls take care in ck_require() to correctly turn off SvREADONLY before calling force_normal_flags(). This seems a better fix than fudging PL_compling */ SvREADONLY_off(((SVOP*)modname)->op_sv); modname->op_private |= OPpCONST_BARE; if (ver) { veop = newSVOP(OP_CONST, 0, ver); } else veop = NULL; if (flags & PERL_LOADMOD_NOIMPORT) { imop = sawparens(newNULLLIST()); } else if (flags & PERL_LOADMOD_IMPORT_OPS) { imop = va_arg(*args, OP*); } else { SV *sv; imop = NULL; sv = va_arg(*args, SV*); while (sv) { imop = append_elem(OP_LIST, imop, newSVOP(OP_CONST, 0, sv)); sv = va_arg(*args, SV*); } } { const line_t ocopline = PL_copline; COP * const ocurcop = PL_curcop; const int oexpect = PL_expect; #if (PERL_BCDVERSION >= 0x5004000) utilize(!(flags & PERL_LOADMOD_DENY), start_subparse(FALSE, 0), veop, modname, imop); #elif (PERL_BCDVERSION > 0x5003000) utilize(!(flags & PERL_LOADMOD_DENY), start_subparse(), veop, modname, imop); #else utilize(!(flags & PERL_LOADMOD_DENY), start_subparse(), modname, imop); #endif PL_expect = oexpect; PL_copline = ocopline; PL_curcop = ocurcop; } } #endif #endif #ifndef load_module #if defined(NEED_load_module) static void DPPP_(my_load_module)(U32 flags, SV *name, SV *ver, ...); static #else extern void DPPP_(my_load_module)(U32 flags, SV *name, SV *ver, ...); #endif #ifdef load_module # undef load_module #endif #define load_module DPPP_(my_load_module) #define Perl_load_module DPPP_(my_load_module) #if defined(NEED_load_module) || defined(NEED_load_module_GLOBAL) void DPPP_(my_load_module)(U32 flags, SV *name, SV *ver, ...) { va_list args; va_start(args, ver); vload_module(flags, name, ver, &args); va_end(args); } #endif #endif #ifndef newRV_inc # define newRV_inc(sv) newRV(sv) /* Replace */ #endif #ifndef newRV_noinc #if defined(NEED_newRV_noinc) static SV * DPPP_(my_newRV_noinc)(SV *sv); static #else extern SV * DPPP_(my_newRV_noinc)(SV *sv); #endif #ifdef newRV_noinc # undef newRV_noinc #endif #define newRV_noinc(a) DPPP_(my_newRV_noinc)(aTHX_ a) #define Perl_newRV_noinc DPPP_(my_newRV_noinc) #if defined(NEED_newRV_noinc) || defined(NEED_newRV_noinc_GLOBAL) SV * DPPP_(my_newRV_noinc)(SV *sv) { SV *rv = (SV *)newRV(sv); SvREFCNT_dec(sv); return rv; } #endif #endif /* Hint: newCONSTSUB * Returns a CV* as of perl-5.7.1. This return value is not supported * by Devel::PPPort. */ /* newCONSTSUB from IO.xs is in the core starting with 5.004_63 */ #if (PERL_BCDVERSION < 0x5004063) && (PERL_BCDVERSION != 0x5004005) #if defined(NEED_newCONSTSUB) static void DPPP_(my_newCONSTSUB)(HV *stash, const char *name, SV *sv); static #else extern void DPPP_(my_newCONSTSUB)(HV *stash, const char *name, SV *sv); #endif #ifdef newCONSTSUB # undef newCONSTSUB #endif #define newCONSTSUB(a,b,c) DPPP_(my_newCONSTSUB)(aTHX_ a,b,c) #define Perl_newCONSTSUB DPPP_(my_newCONSTSUB) #if defined(NEED_newCONSTSUB) || defined(NEED_newCONSTSUB_GLOBAL) /* This is just a trick to avoid a dependency of newCONSTSUB on PL_parser */ /* (There's no PL_parser in perl < 5.005, so this is completely safe) */ #define D_PPP_PL_copline PL_copline void DPPP_(my_newCONSTSUB)(HV *stash, const char *name, SV *sv) { U32 oldhints = PL_hints; HV *old_cop_stash = PL_curcop->cop_stash; HV *old_curstash = PL_curstash; line_t oldline = PL_curcop->cop_line; PL_curcop->cop_line = D_PPP_PL_copline; PL_hints &= ~HINT_BLOCK_SCOPE; if (stash) PL_curstash = PL_curcop->cop_stash = stash; newSUB( #if (PERL_BCDVERSION < 0x5003022) start_subparse(), #elif (PERL_BCDVERSION == 0x5003022) start_subparse(0), #else /* 5.003_23 onwards */ start_subparse(FALSE, 0), #endif newSVOP(OP_CONST, 0, newSVpv((char *) name, 0)), newSVOP(OP_CONST, 0, &PL_sv_no), /* SvPV(&PL_sv_no) == "" -- GMB */ newSTATEOP(0, Nullch, newSVOP(OP_CONST, 0, sv)) ); PL_hints = oldhints; PL_curcop->cop_stash = old_cop_stash; PL_curstash = old_curstash; PL_curcop->cop_line = oldline; } #endif #endif /* * Boilerplate macros for initializing and accessing interpreter-local * data from C. All statics in extensions should be reworked to use * this, if you want to make the extension thread-safe. See ext/re/re.xs * for an example of the use of these macros. * * Code that uses these macros is responsible for the following: * 1. #define MY_CXT_KEY to a unique string, e.g. "DynaLoader_guts" * 2. Declare a typedef named my_cxt_t that is a structure that contains * all the data that needs to be interpreter-local. * 3. Use the START_MY_CXT macro after the declaration of my_cxt_t. * 4. Use the MY_CXT_INIT macro such that it is called exactly once * (typically put in the BOOT: section). * 5. Use the members of the my_cxt_t structure everywhere as * MY_CXT.member. * 6. Use the dMY_CXT macro (a declaration) in all the functions that * access MY_CXT. */ #if defined(MULTIPLICITY) || defined(PERL_OBJECT) || \ defined(PERL_CAPI) || defined(PERL_IMPLICIT_CONTEXT) #ifndef START_MY_CXT /* This must appear in all extensions that define a my_cxt_t structure, * right after the definition (i.e. at file scope). The non-threads * case below uses it to declare the data as static. */ #define START_MY_CXT #if (PERL_BCDVERSION < 0x5004068) /* Fetches the SV that keeps the per-interpreter data. */ #define dMY_CXT_SV \ SV *my_cxt_sv = get_sv(MY_CXT_KEY, FALSE) #else /* >= perl5.004_68 */ #define dMY_CXT_SV \ SV *my_cxt_sv = *hv_fetch(PL_modglobal, MY_CXT_KEY, \ sizeof(MY_CXT_KEY)-1, TRUE) #endif /* < perl5.004_68 */ /* This declaration should be used within all functions that use the * interpreter-local data. */ #define dMY_CXT \ dMY_CXT_SV; \ my_cxt_t *my_cxtp = INT2PTR(my_cxt_t*,SvUV(my_cxt_sv)) /* Creates and zeroes the per-interpreter data. * (We allocate my_cxtp in a Perl SV so that it will be released when * the interpreter goes away.) */ #define MY_CXT_INIT \ dMY_CXT_SV; \ /* newSV() allocates one more than needed */ \ my_cxt_t *my_cxtp = (my_cxt_t*)SvPVX(newSV(sizeof(my_cxt_t)-1));\ Zero(my_cxtp, 1, my_cxt_t); \ sv_setuv(my_cxt_sv, PTR2UV(my_cxtp)) /* This macro must be used to access members of the my_cxt_t structure. * e.g. MYCXT.some_data */ #define MY_CXT (*my_cxtp) /* Judicious use of these macros can reduce the number of times dMY_CXT * is used. Use is similar to pTHX, aTHX etc. */ #define pMY_CXT my_cxt_t *my_cxtp #define pMY_CXT_ pMY_CXT, #define _pMY_CXT ,pMY_CXT #define aMY_CXT my_cxtp #define aMY_CXT_ aMY_CXT, #define _aMY_CXT ,aMY_CXT #endif /* START_MY_CXT */ #ifndef MY_CXT_CLONE /* Clones the per-interpreter data. */ #define MY_CXT_CLONE \ dMY_CXT_SV; \ my_cxt_t *my_cxtp = (my_cxt_t*)SvPVX(newSV(sizeof(my_cxt_t)-1));\ Copy(INT2PTR(my_cxt_t*, SvUV(my_cxt_sv)), my_cxtp, 1, my_cxt_t);\ sv_setuv(my_cxt_sv, PTR2UV(my_cxtp)) #endif #else /* single interpreter */ #ifndef START_MY_CXT #define START_MY_CXT static my_cxt_t my_cxt; #define dMY_CXT_SV dNOOP #define dMY_CXT dNOOP #define MY_CXT_INIT NOOP #define MY_CXT my_cxt #define pMY_CXT void #define pMY_CXT_ #define _pMY_CXT #define aMY_CXT #define aMY_CXT_ #define _aMY_CXT #endif /* START_MY_CXT */ #ifndef MY_CXT_CLONE #define MY_CXT_CLONE NOOP #endif #endif #ifndef IVdf # if IVSIZE == LONGSIZE # define IVdf "ld" # define UVuf "lu" # define UVof "lo" # define UVxf "lx" # define UVXf "lX" # elif IVSIZE == INTSIZE # define IVdf "d" # define UVuf "u" # define UVof "o" # define UVxf "x" # define UVXf "X" # else # error "cannot define IV/UV formats" # endif #endif #ifndef NVef # if defined(USE_LONG_DOUBLE) && defined(HAS_LONG_DOUBLE) && \ defined(PERL_PRIfldbl) && (PERL_BCDVERSION != 0x5006000) /* Not very likely, but let's try anyway. */ # define NVef PERL_PRIeldbl # define NVff PERL_PRIfldbl # define NVgf PERL_PRIgldbl # else # define NVef "e" # define NVff "f" # define NVgf "g" # endif #endif #ifndef SvREFCNT_inc # ifdef PERL_USE_GCC_BRACE_GROUPS # define SvREFCNT_inc(sv) \ ({ \ SV * const _sv = (SV*)(sv); \ if (_sv) \ (SvREFCNT(_sv))++; \ _sv; \ }) # else # define SvREFCNT_inc(sv) \ ((PL_Sv=(SV*)(sv)) ? (++(SvREFCNT(PL_Sv)),PL_Sv) : NULL) # endif #endif #ifndef SvREFCNT_inc_simple # ifdef PERL_USE_GCC_BRACE_GROUPS # define SvREFCNT_inc_simple(sv) \ ({ \ if (sv) \ (SvREFCNT(sv))++; \ (SV *)(sv); \ }) # else # define SvREFCNT_inc_simple(sv) \ ((sv) ? (SvREFCNT(sv)++,(SV*)(sv)) : NULL) # endif #endif #ifndef SvREFCNT_inc_NN # ifdef PERL_USE_GCC_BRACE_GROUPS # define SvREFCNT_inc_NN(sv) \ ({ \ SV * const _sv = (SV*)(sv); \ SvREFCNT(_sv)++; \ _sv; \ }) # else # define SvREFCNT_inc_NN(sv) \ (PL_Sv=(SV*)(sv),++(SvREFCNT(PL_Sv)),PL_Sv) # endif #endif #ifndef SvREFCNT_inc_void # ifdef PERL_USE_GCC_BRACE_GROUPS # define SvREFCNT_inc_void(sv) \ ({ \ SV * const _sv = (SV*)(sv); \ if (_sv) \ (void)(SvREFCNT(_sv)++); \ }) # else # define SvREFCNT_inc_void(sv) \ (void)((PL_Sv=(SV*)(sv)) ? ++(SvREFCNT(PL_Sv)) : 0) # endif #endif #ifndef SvREFCNT_inc_simple_void # define SvREFCNT_inc_simple_void(sv) STMT_START { if (sv) SvREFCNT(sv)++; } STMT_END #endif #ifndef SvREFCNT_inc_simple_NN # define SvREFCNT_inc_simple_NN(sv) (++SvREFCNT(sv), (SV*)(sv)) #endif #ifndef SvREFCNT_inc_void_NN # define SvREFCNT_inc_void_NN(sv) (void)(++SvREFCNT((SV*)(sv))) #endif #ifndef SvREFCNT_inc_simple_void_NN # define SvREFCNT_inc_simple_void_NN(sv) (void)(++SvREFCNT((SV*)(sv))) #endif #ifndef newSV_type #if defined(NEED_newSV_type) static SV* DPPP_(my_newSV_type)(pTHX_ svtype const t); static #else extern SV* DPPP_(my_newSV_type)(pTHX_ svtype const t); #endif #ifdef newSV_type # undef newSV_type #endif #define newSV_type(a) DPPP_(my_newSV_type)(aTHX_ a) #define Perl_newSV_type DPPP_(my_newSV_type) #if defined(NEED_newSV_type) || defined(NEED_newSV_type_GLOBAL) SV* DPPP_(my_newSV_type)(pTHX_ svtype const t) { SV* const sv = newSV(0); sv_upgrade(sv, t); return sv; } #endif #endif #if (PERL_BCDVERSION < 0x5006000) # define D_PPP_CONSTPV_ARG(x) ((char *) (x)) #else # define D_PPP_CONSTPV_ARG(x) (x) #endif #ifndef newSVpvn # define newSVpvn(data,len) ((data) \ ? ((len) ? newSVpv((data), (len)) : newSVpv("", 0)) \ : newSV(0)) #endif #ifndef newSVpvn_utf8 # define newSVpvn_utf8(s, len, u) newSVpvn_flags((s), (len), (u) ? SVf_UTF8 : 0) #endif #ifndef SVf_UTF8 # define SVf_UTF8 0 #endif #ifndef newSVpvn_flags #if defined(NEED_newSVpvn_flags) static SV * DPPP_(my_newSVpvn_flags)(pTHX_ const char *s, STRLEN len, U32 flags); static #else extern SV * DPPP_(my_newSVpvn_flags)(pTHX_ const char *s, STRLEN len, U32 flags); #endif #ifdef newSVpvn_flags # undef newSVpvn_flags #endif #define newSVpvn_flags(a,b,c) DPPP_(my_newSVpvn_flags)(aTHX_ a,b,c) #define Perl_newSVpvn_flags DPPP_(my_newSVpvn_flags) #if defined(NEED_newSVpvn_flags) || defined(NEED_newSVpvn_flags_GLOBAL) SV * DPPP_(my_newSVpvn_flags)(pTHX_ const char *s, STRLEN len, U32 flags) { SV *sv = newSVpvn(D_PPP_CONSTPV_ARG(s), len); SvFLAGS(sv) |= (flags & SVf_UTF8); return (flags & SVs_TEMP) ? sv_2mortal(sv) : sv; } #endif #endif /* Backwards compatibility stuff... :-( */ #if !defined(NEED_sv_2pv_flags) && defined(NEED_sv_2pv_nolen) # define NEED_sv_2pv_flags #endif #if !defined(NEED_sv_2pv_flags_GLOBAL) && defined(NEED_sv_2pv_nolen_GLOBAL) # define NEED_sv_2pv_flags_GLOBAL #endif /* Hint: sv_2pv_nolen * Use the SvPV_nolen() or SvPV_nolen_const() macros instead of sv_2pv_nolen(). */ #ifndef sv_2pv_nolen # define sv_2pv_nolen(sv) SvPV_nolen(sv) #endif #ifdef SvPVbyte /* Hint: SvPVbyte * Does not work in perl-5.6.1, ppport.h implements a version * borrowed from perl-5.7.3. */ #if (PERL_BCDVERSION < 0x5007000) #if defined(NEED_sv_2pvbyte) static char * DPPP_(my_sv_2pvbyte)(pTHX_ SV *sv, STRLEN *lp); static #else extern char * DPPP_(my_sv_2pvbyte)(pTHX_ SV *sv, STRLEN *lp); #endif #ifdef sv_2pvbyte # undef sv_2pvbyte #endif #define sv_2pvbyte(a,b) DPPP_(my_sv_2pvbyte)(aTHX_ a,b) #define Perl_sv_2pvbyte DPPP_(my_sv_2pvbyte) #if defined(NEED_sv_2pvbyte) || defined(NEED_sv_2pvbyte_GLOBAL) char * DPPP_(my_sv_2pvbyte)(pTHX_ SV *sv, STRLEN *lp) { sv_utf8_downgrade(sv,0); return SvPV(sv,*lp); } #endif /* Hint: sv_2pvbyte * Use the SvPVbyte() macro instead of sv_2pvbyte(). */ #undef SvPVbyte #define SvPVbyte(sv, lp) \ ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8)) == (SVf_POK) \ ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_2pvbyte(sv, &lp)) #endif #else # define SvPVbyte SvPV # define sv_2pvbyte sv_2pv #endif #ifndef sv_2pvbyte_nolen # define sv_2pvbyte_nolen(sv) sv_2pv_nolen(sv) #endif /* Hint: sv_pvn * Always use the SvPV() macro instead of sv_pvn(). */ /* Hint: sv_pvn_force * Always use the SvPV_force() macro instead of sv_pvn_force(). */ /* If these are undefined, they're not handled by the core anyway */ #ifndef SV_IMMEDIATE_UNREF # define SV_IMMEDIATE_UNREF 0 #endif #ifndef SV_GMAGIC # define SV_GMAGIC 0 #endif #ifndef SV_COW_DROP_PV # define SV_COW_DROP_PV 0 #endif #ifndef SV_UTF8_NO_ENCODING # define SV_UTF8_NO_ENCODING 0 #endif #ifndef SV_NOSTEAL # define SV_NOSTEAL 0 #endif #ifndef SV_CONST_RETURN # define SV_CONST_RETURN 0 #endif #ifndef SV_MUTABLE_RETURN # define SV_MUTABLE_RETURN 0 #endif #ifndef SV_SMAGIC # define SV_SMAGIC 0 #endif #ifndef SV_HAS_TRAILING_NUL # define SV_HAS_TRAILING_NUL 0 #endif #ifndef SV_COW_SHARED_HASH_KEYS # define SV_COW_SHARED_HASH_KEYS 0 #endif #if (PERL_BCDVERSION < 0x5007002) #if defined(NEED_sv_2pv_flags) static char * DPPP_(my_sv_2pv_flags)(pTHX_ SV *sv, STRLEN *lp, I32 flags); static #else extern char * DPPP_(my_sv_2pv_flags)(pTHX_ SV *sv, STRLEN *lp, I32 flags); #endif #ifdef sv_2pv_flags # undef sv_2pv_flags #endif #define sv_2pv_flags(a,b,c) DPPP_(my_sv_2pv_flags)(aTHX_ a,b,c) #define Perl_sv_2pv_flags DPPP_(my_sv_2pv_flags) #if defined(NEED_sv_2pv_flags) || defined(NEED_sv_2pv_flags_GLOBAL) char * DPPP_(my_sv_2pv_flags)(pTHX_ SV *sv, STRLEN *lp, I32 flags) { STRLEN n_a = (STRLEN) flags; return sv_2pv(sv, lp ? lp : &n_a); } #endif #if defined(NEED_sv_pvn_force_flags) static char * DPPP_(my_sv_pvn_force_flags)(pTHX_ SV *sv, STRLEN *lp, I32 flags); static #else extern char * DPPP_(my_sv_pvn_force_flags)(pTHX_ SV *sv, STRLEN *lp, I32 flags); #endif #ifdef sv_pvn_force_flags # undef sv_pvn_force_flags #endif #define sv_pvn_force_flags(a,b,c) DPPP_(my_sv_pvn_force_flags)(aTHX_ a,b,c) #define Perl_sv_pvn_force_flags DPPP_(my_sv_pvn_force_flags) #if defined(NEED_sv_pvn_force_flags) || defined(NEED_sv_pvn_force_flags_GLOBAL) char * DPPP_(my_sv_pvn_force_flags)(pTHX_ SV *sv, STRLEN *lp, I32 flags) { STRLEN n_a = (STRLEN) flags; return sv_pvn_force(sv, lp ? lp : &n_a); } #endif #endif #if (PERL_BCDVERSION < 0x5008008) || ( (PERL_BCDVERSION >= 0x5009000) && (PERL_BCDVERSION < 0x5009003) ) # define DPPP_SVPV_NOLEN_LP_ARG &PL_na #else # define DPPP_SVPV_NOLEN_LP_ARG 0 #endif #ifndef SvPV_const # define SvPV_const(sv, lp) SvPV_flags_const(sv, lp, SV_GMAGIC) #endif #ifndef SvPV_mutable # define SvPV_mutable(sv, lp) SvPV_flags_mutable(sv, lp, SV_GMAGIC) #endif #ifndef SvPV_flags # define SvPV_flags(sv, lp, flags) \ ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \ ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_2pv_flags(sv, &lp, flags)) #endif #ifndef SvPV_flags_const # define SvPV_flags_const(sv, lp, flags) \ ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \ ? ((lp = SvCUR(sv)), SvPVX_const(sv)) : \ (const char*) sv_2pv_flags(sv, &lp, flags|SV_CONST_RETURN)) #endif #ifndef SvPV_flags_const_nolen # define SvPV_flags_const_nolen(sv, flags) \ ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \ ? SvPVX_const(sv) : \ (const char*) sv_2pv_flags(sv, DPPP_SVPV_NOLEN_LP_ARG, flags|SV_CONST_RETURN)) #endif #ifndef SvPV_flags_mutable # define SvPV_flags_mutable(sv, lp, flags) \ ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \ ? ((lp = SvCUR(sv)), SvPVX_mutable(sv)) : \ sv_2pv_flags(sv, &lp, flags|SV_MUTABLE_RETURN)) #endif #ifndef SvPV_force # define SvPV_force(sv, lp) SvPV_force_flags(sv, lp, SV_GMAGIC) #endif #ifndef SvPV_force_nolen # define SvPV_force_nolen(sv) SvPV_force_flags_nolen(sv, SV_GMAGIC) #endif #ifndef SvPV_force_mutable # define SvPV_force_mutable(sv, lp) SvPV_force_flags_mutable(sv, lp, SV_GMAGIC) #endif #ifndef SvPV_force_nomg # define SvPV_force_nomg(sv, lp) SvPV_force_flags(sv, lp, 0) #endif #ifndef SvPV_force_nomg_nolen # define SvPV_force_nomg_nolen(sv) SvPV_force_flags_nolen(sv, 0) #endif #ifndef SvPV_force_flags # define SvPV_force_flags(sv, lp, flags) \ ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST)) == SVf_POK \ ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_pvn_force_flags(sv, &lp, flags)) #endif #ifndef SvPV_force_flags_nolen # define SvPV_force_flags_nolen(sv, flags) \ ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST)) == SVf_POK \ ? SvPVX(sv) : sv_pvn_force_flags(sv, DPPP_SVPV_NOLEN_LP_ARG, flags)) #endif #ifndef SvPV_force_flags_mutable # define SvPV_force_flags_mutable(sv, lp, flags) \ ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST)) == SVf_POK \ ? ((lp = SvCUR(sv)), SvPVX_mutable(sv)) \ : sv_pvn_force_flags(sv, &lp, flags|SV_MUTABLE_RETURN)) #endif #ifndef SvPV_nolen # define SvPV_nolen(sv) \ ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \ ? SvPVX(sv) : sv_2pv_flags(sv, DPPP_SVPV_NOLEN_LP_ARG, SV_GMAGIC)) #endif #ifndef SvPV_nolen_const # define SvPV_nolen_const(sv) \ ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \ ? SvPVX_const(sv) : sv_2pv_flags(sv, DPPP_SVPV_NOLEN_LP_ARG, SV_GMAGIC|SV_CONST_RETURN)) #endif #ifndef SvPV_nomg # define SvPV_nomg(sv, lp) SvPV_flags(sv, lp, 0) #endif #ifndef SvPV_nomg_const # define SvPV_nomg_const(sv, lp) SvPV_flags_const(sv, lp, 0) #endif #ifndef SvPV_nomg_const_nolen # define SvPV_nomg_const_nolen(sv) SvPV_flags_const_nolen(sv, 0) #endif #ifndef SvPV_nomg_nolen # define SvPV_nomg_nolen(sv) ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \ ? SvPVX(sv) : sv_2pv_flags(sv, DPPP_SVPV_NOLEN_LP_ARG, 0)) #endif #ifndef SvPV_renew # define SvPV_renew(sv,n) STMT_START { SvLEN_set(sv, n); \ SvPV_set((sv), (char *) saferealloc( \ (Malloc_t)SvPVX(sv), (MEM_SIZE)((n)))); \ } STMT_END #endif #ifndef SvMAGIC_set # define SvMAGIC_set(sv, val) \ STMT_START { assert(SvTYPE(sv) >= SVt_PVMG); \ (((XPVMG*) SvANY(sv))->xmg_magic = (val)); } STMT_END #endif #if (PERL_BCDVERSION < 0x5009003) #ifndef SvPVX_const # define SvPVX_const(sv) ((const char*) (0 + SvPVX(sv))) #endif #ifndef SvPVX_mutable # define SvPVX_mutable(sv) (0 + SvPVX(sv)) #endif #ifndef SvRV_set # define SvRV_set(sv, val) \ STMT_START { assert(SvTYPE(sv) >= SVt_RV); \ (((XRV*) SvANY(sv))->xrv_rv = (val)); } STMT_END #endif #else #ifndef SvPVX_const # define SvPVX_const(sv) ((const char*)((sv)->sv_u.svu_pv)) #endif #ifndef SvPVX_mutable # define SvPVX_mutable(sv) ((sv)->sv_u.svu_pv) #endif #ifndef SvRV_set # define SvRV_set(sv, val) \ STMT_START { assert(SvTYPE(sv) >= SVt_RV); \ ((sv)->sv_u.svu_rv = (val)); } STMT_END #endif #endif #ifndef SvSTASH_set # define SvSTASH_set(sv, val) \ STMT_START { assert(SvTYPE(sv) >= SVt_PVMG); \ (((XPVMG*) SvANY(sv))->xmg_stash = (val)); } STMT_END #endif #if (PERL_BCDVERSION < 0x5004000) #ifndef SvUV_set # define SvUV_set(sv, val) \ STMT_START { assert(SvTYPE(sv) == SVt_IV || SvTYPE(sv) >= SVt_PVIV); \ (((XPVIV*) SvANY(sv))->xiv_iv = (IV) (val)); } STMT_END #endif #else #ifndef SvUV_set # define SvUV_set(sv, val) \ STMT_START { assert(SvTYPE(sv) == SVt_IV || SvTYPE(sv) >= SVt_PVIV); \ (((XPVUV*) SvANY(sv))->xuv_uv = (val)); } STMT_END #endif #endif #if (PERL_BCDVERSION >= 0x5004000) && !defined(vnewSVpvf) #if defined(NEED_vnewSVpvf) static SV * DPPP_(my_vnewSVpvf)(pTHX_ const char *pat, va_list *args); static #else extern SV * DPPP_(my_vnewSVpvf)(pTHX_ const char *pat, va_list *args); #endif #ifdef vnewSVpvf # undef vnewSVpvf #endif #define vnewSVpvf(a,b) DPPP_(my_vnewSVpvf)(aTHX_ a,b) #define Perl_vnewSVpvf DPPP_(my_vnewSVpvf) #if defined(NEED_vnewSVpvf) || defined(NEED_vnewSVpvf_GLOBAL) SV * DPPP_(my_vnewSVpvf)(pTHX_ const char *pat, va_list *args) { register SV *sv = newSV(0); sv_vsetpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*)); return sv; } #endif #endif #if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_vcatpvf) # define sv_vcatpvf(sv, pat, args) sv_vcatpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*)) #endif #if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_vsetpvf) # define sv_vsetpvf(sv, pat, args) sv_vsetpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*)) #endif #if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_catpvf_mg) #if defined(NEED_sv_catpvf_mg) static void DPPP_(my_sv_catpvf_mg)(pTHX_ SV *sv, const char *pat, ...); static #else extern void DPPP_(my_sv_catpvf_mg)(pTHX_ SV *sv, const char *pat, ...); #endif #define Perl_sv_catpvf_mg DPPP_(my_sv_catpvf_mg) #if defined(NEED_sv_catpvf_mg) || defined(NEED_sv_catpvf_mg_GLOBAL) void DPPP_(my_sv_catpvf_mg)(pTHX_ SV *sv, const char *pat, ...) { va_list args; va_start(args, pat); sv_vcatpvfn(sv, pat, strlen(pat), &args, Null(SV**), 0, Null(bool*)); SvSETMAGIC(sv); va_end(args); } #endif #endif #ifdef PERL_IMPLICIT_CONTEXT #if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_catpvf_mg_nocontext) #if defined(NEED_sv_catpvf_mg_nocontext) static void DPPP_(my_sv_catpvf_mg_nocontext)(SV *sv, const char *pat, ...); static #else extern void DPPP_(my_sv_catpvf_mg_nocontext)(SV *sv, const char *pat, ...); #endif #define sv_catpvf_mg_nocontext DPPP_(my_sv_catpvf_mg_nocontext) #define Perl_sv_catpvf_mg_nocontext DPPP_(my_sv_catpvf_mg_nocontext) #if defined(NEED_sv_catpvf_mg_nocontext) || defined(NEED_sv_catpvf_mg_nocontext_GLOBAL) void DPPP_(my_sv_catpvf_mg_nocontext)(SV *sv, const char *pat, ...) { dTHX; va_list args; va_start(args, pat); sv_vcatpvfn(sv, pat, strlen(pat), &args, Null(SV**), 0, Null(bool*)); SvSETMAGIC(sv); va_end(args); } #endif #endif #endif /* sv_catpvf_mg depends on sv_catpvf_mg_nocontext */ #ifndef sv_catpvf_mg # ifdef PERL_IMPLICIT_CONTEXT # define sv_catpvf_mg Perl_sv_catpvf_mg_nocontext # else # define sv_catpvf_mg Perl_sv_catpvf_mg # endif #endif #if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_vcatpvf_mg) # define sv_vcatpvf_mg(sv, pat, args) \ STMT_START { \ sv_vcatpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*)); \ SvSETMAGIC(sv); \ } STMT_END #endif #if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_setpvf_mg) #if defined(NEED_sv_setpvf_mg) static void DPPP_(my_sv_setpvf_mg)(pTHX_ SV *sv, const char *pat, ...); static #else extern void DPPP_(my_sv_setpvf_mg)(pTHX_ SV *sv, const char *pat, ...); #endif #define Perl_sv_setpvf_mg DPPP_(my_sv_setpvf_mg) #if defined(NEED_sv_setpvf_mg) || defined(NEED_sv_setpvf_mg_GLOBAL) void DPPP_(my_sv_setpvf_mg)(pTHX_ SV *sv, const char *pat, ...) { va_list args; va_start(args, pat); sv_vsetpvfn(sv, pat, strlen(pat), &args, Null(SV**), 0, Null(bool*)); SvSETMAGIC(sv); va_end(args); } #endif #endif #ifdef PERL_IMPLICIT_CONTEXT #if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_setpvf_mg_nocontext) #if defined(NEED_sv_setpvf_mg_nocontext) static void DPPP_(my_sv_setpvf_mg_nocontext)(SV *sv, const char *pat, ...); static #else extern void DPPP_(my_sv_setpvf_mg_nocontext)(SV *sv, const char *pat, ...); #endif #define sv_setpvf_mg_nocontext DPPP_(my_sv_setpvf_mg_nocontext) #define Perl_sv_setpvf_mg_nocontext DPPP_(my_sv_setpvf_mg_nocontext) #if defined(NEED_sv_setpvf_mg_nocontext) || defined(NEED_sv_setpvf_mg_nocontext_GLOBAL) void DPPP_(my_sv_setpvf_mg_nocontext)(SV *sv, const char *pat, ...) { dTHX; va_list args; va_start(args, pat); sv_vsetpvfn(sv, pat, strlen(pat), &args, Null(SV**), 0, Null(bool*)); SvSETMAGIC(sv); va_end(args); } #endif #endif #endif /* sv_setpvf_mg depends on sv_setpvf_mg_nocontext */ #ifndef sv_setpvf_mg # ifdef PERL_IMPLICIT_CONTEXT # define sv_setpvf_mg Perl_sv_setpvf_mg_nocontext # else # define sv_setpvf_mg Perl_sv_setpvf_mg # endif #endif #if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_vsetpvf_mg) # define sv_vsetpvf_mg(sv, pat, args) \ STMT_START { \ sv_vsetpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*)); \ SvSETMAGIC(sv); \ } STMT_END #endif /* Hint: newSVpvn_share * The SVs created by this function only mimic the behaviour of * shared PVs without really being shared. Only use if you know * what you're doing. */ #ifndef newSVpvn_share #if defined(NEED_newSVpvn_share) static SV * DPPP_(my_newSVpvn_share)(pTHX_ const char *src, I32 len, U32 hash); static #else extern SV * DPPP_(my_newSVpvn_share)(pTHX_ const char *src, I32 len, U32 hash); #endif #ifdef newSVpvn_share # undef newSVpvn_share #endif #define newSVpvn_share(a,b,c) DPPP_(my_newSVpvn_share)(aTHX_ a,b,c) #define Perl_newSVpvn_share DPPP_(my_newSVpvn_share) #if defined(NEED_newSVpvn_share) || defined(NEED_newSVpvn_share_GLOBAL) SV * DPPP_(my_newSVpvn_share)(pTHX_ const char *src, I32 len, U32 hash) { SV *sv; if (len < 0) len = -len; if (!hash) PERL_HASH(hash, (char*) src, len); sv = newSVpvn((char *) src, len); sv_upgrade(sv, SVt_PVIV); SvIVX(sv) = hash; SvREADONLY_on(sv); SvPOK_on(sv); return sv; } #endif #endif #ifndef SvSHARED_HASH # define SvSHARED_HASH(sv) (0 + SvUVX(sv)) #endif #ifndef HvNAME_get # define HvNAME_get(hv) HvNAME(hv) #endif #ifndef HvNAMELEN_get # define HvNAMELEN_get(hv) (HvNAME_get(hv) ? (I32)strlen(HvNAME_get(hv)) : 0) #endif #ifndef gv_fetchpvn_flags #if defined(NEED_gv_fetchpvn_flags) static GV* DPPP_(my_gv_fetchpvn_flags)(pTHX_ const char* name, STRLEN len, int flags, int types); static #else extern GV* DPPP_(my_gv_fetchpvn_flags)(pTHX_ const char* name, STRLEN len, int flags, int types); #endif #ifdef gv_fetchpvn_flags # undef gv_fetchpvn_flags #endif #define gv_fetchpvn_flags(a,b,c,d) DPPP_(my_gv_fetchpvn_flags)(aTHX_ a,b,c,d) #define Perl_gv_fetchpvn_flags DPPP_(my_gv_fetchpvn_flags) #if defined(NEED_gv_fetchpvn_flags) || defined(NEED_gv_fetchpvn_flags_GLOBAL) GV* DPPP_(my_gv_fetchpvn_flags)(pTHX_ const char* name, STRLEN len, int flags, int types) { char *namepv = savepvn(name, len); GV* stash = gv_fetchpv(namepv, TRUE, SVt_PVHV); Safefree(namepv); return stash; } #endif #endif #ifndef GvSVn # define GvSVn(gv) GvSV(gv) #endif #ifndef isGV_with_GP # define isGV_with_GP(gv) isGV(gv) #endif #ifndef gv_fetchsv # define gv_fetchsv(name, flags, svt) gv_fetchpv(SvPV_nolen_const(name), flags, svt) #endif #ifndef get_cvn_flags # define get_cvn_flags(name, namelen, flags) get_cv(name, flags) #endif #ifndef gv_init_pvn # define gv_init_pvn(gv, stash, ptr, len, flags) gv_init(gv, stash, ptr, len, flags & GV_ADDMULTI ? TRUE : FALSE) #endif #ifndef WARN_ALL # define WARN_ALL 0 #endif #ifndef WARN_CLOSURE # define WARN_CLOSURE 1 #endif #ifndef WARN_DEPRECATED # define WARN_DEPRECATED 2 #endif #ifndef WARN_EXITING # define WARN_EXITING 3 #endif #ifndef WARN_GLOB # define WARN_GLOB 4 #endif #ifndef WARN_IO # define WARN_IO 5 #endif #ifndef WARN_CLOSED # define WARN_CLOSED 6 #endif #ifndef WARN_EXEC # define WARN_EXEC 7 #endif #ifndef WARN_LAYER # define WARN_LAYER 8 #endif #ifndef WARN_NEWLINE # define WARN_NEWLINE 9 #endif #ifndef WARN_PIPE # define WARN_PIPE 10 #endif #ifndef WARN_UNOPENED # define WARN_UNOPENED 11 #endif #ifndef WARN_MISC # define WARN_MISC 12 #endif #ifndef WARN_NUMERIC # define WARN_NUMERIC 13 #endif #ifndef WARN_ONCE # define WARN_ONCE 14 #endif #ifndef WARN_OVERFLOW # define WARN_OVERFLOW 15 #endif #ifndef WARN_PACK # define WARN_PACK 16 #endif #ifndef WARN_PORTABLE # define WARN_PORTABLE 17 #endif #ifndef WARN_RECURSION # define WARN_RECURSION 18 #endif #ifndef WARN_REDEFINE # define WARN_REDEFINE 19 #endif #ifndef WARN_REGEXP # define WARN_REGEXP 20 #endif #ifndef WARN_SEVERE # define WARN_SEVERE 21 #endif #ifndef WARN_DEBUGGING # define WARN_DEBUGGING 22 #endif #ifndef WARN_INPLACE # define WARN_INPLACE 23 #endif #ifndef WARN_INTERNAL # define WARN_INTERNAL 24 #endif #ifndef WARN_MALLOC # define WARN_MALLOC 25 #endif #ifndef WARN_SIGNAL # define WARN_SIGNAL 26 #endif #ifndef WARN_SUBSTR # define WARN_SUBSTR 27 #endif #ifndef WARN_SYNTAX # define WARN_SYNTAX 28 #endif #ifndef WARN_AMBIGUOUS # define WARN_AMBIGUOUS 29 #endif #ifndef WARN_BAREWORD # define WARN_BAREWORD 30 #endif #ifndef WARN_DIGIT # define WARN_DIGIT 31 #endif #ifndef WARN_PARENTHESIS # define WARN_PARENTHESIS 32 #endif #ifndef WARN_PRECEDENCE # define WARN_PRECEDENCE 33 #endif #ifndef WARN_PRINTF # define WARN_PRINTF 34 #endif #ifndef WARN_PROTOTYPE # define WARN_PROTOTYPE 35 #endif #ifndef WARN_QW # define WARN_QW 36 #endif #ifndef WARN_RESERVED # define WARN_RESERVED 37 #endif #ifndef WARN_SEMICOLON # define WARN_SEMICOLON 38 #endif #ifndef WARN_TAINT # define WARN_TAINT 39 #endif #ifndef WARN_THREADS # define WARN_THREADS 40 #endif #ifndef WARN_UNINITIALIZED # define WARN_UNINITIALIZED 41 #endif #ifndef WARN_UNPACK # define WARN_UNPACK 42 #endif #ifndef WARN_UNTIE # define WARN_UNTIE 43 #endif #ifndef WARN_UTF8 # define WARN_UTF8 44 #endif #ifndef WARN_VOID # define WARN_VOID 45 #endif #ifndef WARN_ASSERTIONS # define WARN_ASSERTIONS 46 #endif #ifndef packWARN # define packWARN(a) (a) #endif #ifndef ckWARN # ifdef G_WARN_ON # define ckWARN(a) (PL_dowarn & G_WARN_ON) # else # define ckWARN(a) PL_dowarn # endif #endif #if (PERL_BCDVERSION >= 0x5004000) && !defined(warner) #if defined(NEED_warner) static void DPPP_(my_warner)(U32 err, const char *pat, ...); static #else extern void DPPP_(my_warner)(U32 err, const char *pat, ...); #endif #define Perl_warner DPPP_(my_warner) #if defined(NEED_warner) || defined(NEED_warner_GLOBAL) void DPPP_(my_warner)(U32 err, const char *pat, ...) { SV *sv; va_list args; PERL_UNUSED_ARG(err); va_start(args, pat); sv = vnewSVpvf(pat, &args); va_end(args); sv_2mortal(sv); warn("%s", SvPV_nolen(sv)); } #define warner Perl_warner #define Perl_warner_nocontext Perl_warner #endif #endif /* concatenating with "" ensures that only literal strings are accepted as argument * note that STR_WITH_LEN() can't be used as argument to macros or functions that * under some configurations might be macros */ #ifndef STR_WITH_LEN # define STR_WITH_LEN(s) (s ""), (sizeof(s)-1) #endif #ifndef newSVpvs # define newSVpvs(str) newSVpvn(str "", sizeof(str) - 1) #endif #ifndef newSVpvs_flags # define newSVpvs_flags(str, flags) newSVpvn_flags(str "", sizeof(str) - 1, flags) #endif #ifndef newSVpvs_share # define newSVpvs_share(str) newSVpvn_share(str "", sizeof(str) - 1, 0) #endif #ifndef sv_catpvs # define sv_catpvs(sv, str) sv_catpvn(sv, str "", sizeof(str) - 1) #endif #ifndef sv_setpvs # define sv_setpvs(sv, str) sv_setpvn(sv, str "", sizeof(str) - 1) #endif #ifndef hv_fetchs # define hv_fetchs(hv, key, lval) hv_fetch(hv, key "", sizeof(key) - 1, lval) #endif #ifndef hv_stores # define hv_stores(hv, key, val) hv_store(hv, key "", sizeof(key) - 1, val, 0) #endif #ifndef gv_fetchpvs # define gv_fetchpvs(name, flags, svt) gv_fetchpvn_flags(name "", sizeof(name) - 1, flags, svt) #endif #ifndef gv_stashpvs # define gv_stashpvs(name, flags) gv_stashpvn(name "", sizeof(name) - 1, flags) #endif #ifndef get_cvs # define get_cvs(name, flags) get_cvn_flags(name "", sizeof(name)-1, flags) #endif #ifndef SvGETMAGIC # define SvGETMAGIC(x) STMT_START { if (SvGMAGICAL(x)) mg_get(x); } STMT_END #endif /* Some random bits for sv_unmagicext. These should probably be pulled in for real and organized at some point */ #ifndef HEf_SVKEY # define HEf_SVKEY -2 #endif #ifndef MUTABLE_PTR #if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) # define MUTABLE_PTR(p) ({ void *_p = (p); _p; }) #else # define MUTABLE_PTR(p) ((void *) (p)) #endif #endif #ifndef MUTABLE_SV # define MUTABLE_SV(p) ((SV *)MUTABLE_PTR(p)) #endif /* end of random bits */ #ifndef PERL_MAGIC_sv # define PERL_MAGIC_sv '\0' #endif #ifndef PERL_MAGIC_overload # define PERL_MAGIC_overload 'A' #endif #ifndef PERL_MAGIC_overload_elem # define PERL_MAGIC_overload_elem 'a' #endif #ifndef PERL_MAGIC_overload_table # define PERL_MAGIC_overload_table 'c' #endif #ifndef PERL_MAGIC_bm # define PERL_MAGIC_bm 'B' #endif #ifndef PERL_MAGIC_regdata # define PERL_MAGIC_regdata 'D' #endif #ifndef PERL_MAGIC_regdatum # define PERL_MAGIC_regdatum 'd' #endif #ifndef PERL_MAGIC_env # define PERL_MAGIC_env 'E' #endif #ifndef PERL_MAGIC_envelem # define PERL_MAGIC_envelem 'e' #endif #ifndef PERL_MAGIC_fm # define PERL_MAGIC_fm 'f' #endif #ifndef PERL_MAGIC_regex_global # define PERL_MAGIC_regex_global 'g' #endif #ifndef PERL_MAGIC_isa # define PERL_MAGIC_isa 'I' #endif #ifndef PERL_MAGIC_isaelem # define PERL_MAGIC_isaelem 'i' #endif #ifndef PERL_MAGIC_nkeys # define PERL_MAGIC_nkeys 'k' #endif #ifndef PERL_MAGIC_dbfile # define PERL_MAGIC_dbfile 'L' #endif #ifndef PERL_MAGIC_dbline # define PERL_MAGIC_dbline 'l' #endif #ifndef PERL_MAGIC_mutex # define PERL_MAGIC_mutex 'm' #endif #ifndef PERL_MAGIC_shared # define PERL_MAGIC_shared 'N' #endif #ifndef PERL_MAGIC_shared_scalar # define PERL_MAGIC_shared_scalar 'n' #endif #ifndef PERL_MAGIC_collxfrm # define PERL_MAGIC_collxfrm 'o' #endif #ifndef PERL_MAGIC_tied # define PERL_MAGIC_tied 'P' #endif #ifndef PERL_MAGIC_tiedelem # define PERL_MAGIC_tiedelem 'p' #endif #ifndef PERL_MAGIC_tiedscalar # define PERL_MAGIC_tiedscalar 'q' #endif #ifndef PERL_MAGIC_qr # define PERL_MAGIC_qr 'r' #endif #ifndef PERL_MAGIC_sig # define PERL_MAGIC_sig 'S' #endif #ifndef PERL_MAGIC_sigelem # define PERL_MAGIC_sigelem 's' #endif #ifndef PERL_MAGIC_taint # define PERL_MAGIC_taint 't' #endif #ifndef PERL_MAGIC_uvar # define PERL_MAGIC_uvar 'U' #endif #ifndef PERL_MAGIC_uvar_elem # define PERL_MAGIC_uvar_elem 'u' #endif #ifndef PERL_MAGIC_vstring # define PERL_MAGIC_vstring 'V' #endif #ifndef PERL_MAGIC_vec # define PERL_MAGIC_vec 'v' #endif #ifndef PERL_MAGIC_utf8 # define PERL_MAGIC_utf8 'w' #endif #ifndef PERL_MAGIC_substr # define PERL_MAGIC_substr 'x' #endif #ifndef PERL_MAGIC_defelem # define PERL_MAGIC_defelem 'y' #endif #ifndef PERL_MAGIC_glob # define PERL_MAGIC_glob '*' #endif #ifndef PERL_MAGIC_arylen # define PERL_MAGIC_arylen '#' #endif #ifndef PERL_MAGIC_pos # define PERL_MAGIC_pos '.' #endif #ifndef PERL_MAGIC_backref # define PERL_MAGIC_backref '<' #endif #ifndef PERL_MAGIC_ext # define PERL_MAGIC_ext '~' #endif /* That's the best we can do... */ #ifndef sv_catpvn_nomg # define sv_catpvn_nomg sv_catpvn #endif #ifndef sv_catsv_nomg # define sv_catsv_nomg sv_catsv #endif #ifndef sv_setsv_nomg # define sv_setsv_nomg sv_setsv #endif #ifndef sv_pvn_nomg # define sv_pvn_nomg sv_pvn #endif #ifndef SvIV_nomg # define SvIV_nomg SvIV #endif #ifndef SvUV_nomg # define SvUV_nomg SvUV #endif #ifndef sv_catpv_mg # define sv_catpv_mg(sv, ptr) \ STMT_START { \ SV *TeMpSv = sv; \ sv_catpv(TeMpSv,ptr); \ SvSETMAGIC(TeMpSv); \ } STMT_END #endif #ifndef sv_catpvn_mg # define sv_catpvn_mg(sv, ptr, len) \ STMT_START { \ SV *TeMpSv = sv; \ sv_catpvn(TeMpSv,ptr,len); \ SvSETMAGIC(TeMpSv); \ } STMT_END #endif #ifndef sv_catsv_mg # define sv_catsv_mg(dsv, ssv) \ STMT_START { \ SV *TeMpSv = dsv; \ sv_catsv(TeMpSv,ssv); \ SvSETMAGIC(TeMpSv); \ } STMT_END #endif #ifndef sv_setiv_mg # define sv_setiv_mg(sv, i) \ STMT_START { \ SV *TeMpSv = sv; \ sv_setiv(TeMpSv,i); \ SvSETMAGIC(TeMpSv); \ } STMT_END #endif #ifndef sv_setnv_mg # define sv_setnv_mg(sv, num) \ STMT_START { \ SV *TeMpSv = sv; \ sv_setnv(TeMpSv,num); \ SvSETMAGIC(TeMpSv); \ } STMT_END #endif #ifndef sv_setpv_mg # define sv_setpv_mg(sv, ptr) \ STMT_START { \ SV *TeMpSv = sv; \ sv_setpv(TeMpSv,ptr); \ SvSETMAGIC(TeMpSv); \ } STMT_END #endif #ifndef sv_setpvn_mg # define sv_setpvn_mg(sv, ptr, len) \ STMT_START { \ SV *TeMpSv = sv; \ sv_setpvn(TeMpSv,ptr,len); \ SvSETMAGIC(TeMpSv); \ } STMT_END #endif #ifndef sv_setsv_mg # define sv_setsv_mg(dsv, ssv) \ STMT_START { \ SV *TeMpSv = dsv; \ sv_setsv(TeMpSv,ssv); \ SvSETMAGIC(TeMpSv); \ } STMT_END #endif #ifndef sv_setuv_mg # define sv_setuv_mg(sv, i) \ STMT_START { \ SV *TeMpSv = sv; \ sv_setuv(TeMpSv,i); \ SvSETMAGIC(TeMpSv); \ } STMT_END #endif #ifndef sv_usepvn_mg # define sv_usepvn_mg(sv, ptr, len) \ STMT_START { \ SV *TeMpSv = sv; \ sv_usepvn(TeMpSv,ptr,len); \ SvSETMAGIC(TeMpSv); \ } STMT_END #endif #ifndef SvVSTRING_mg # define SvVSTRING_mg(sv) (SvMAGICAL(sv) ? mg_find(sv, PERL_MAGIC_vstring) : NULL) #endif /* Hint: sv_magic_portable * This is a compatibility function that is only available with * Devel::PPPort. It is NOT in the perl core. * Its purpose is to mimic the 5.8.0 behaviour of sv_magic() when * it is being passed a name pointer with namlen == 0. In that * case, perl 5.8.0 and later store the pointer, not a copy of it. * The compatibility can be provided back to perl 5.004. With * earlier versions, the code will not compile. */ #if (PERL_BCDVERSION < 0x5004000) /* code that uses sv_magic_portable will not compile */ #elif (PERL_BCDVERSION < 0x5008000) # define sv_magic_portable(sv, obj, how, name, namlen) \ STMT_START { \ SV *SvMp_sv = (sv); \ char *SvMp_name = (char *) (name); \ I32 SvMp_namlen = (namlen); \ if (SvMp_name && SvMp_namlen == 0) \ { \ MAGIC *mg; \ sv_magic(SvMp_sv, obj, how, 0, 0); \ mg = SvMAGIC(SvMp_sv); \ mg->mg_len = -42; /* XXX: this is the tricky part */ \ mg->mg_ptr = SvMp_name; \ } \ else \ { \ sv_magic(SvMp_sv, obj, how, SvMp_name, SvMp_namlen); \ } \ } STMT_END #else # define sv_magic_portable(a, b, c, d, e) sv_magic(a, b, c, d, e) #endif #if !defined(mg_findext) #if defined(NEED_mg_findext) static MAGIC * DPPP_(my_mg_findext)(SV * sv, int type, const MGVTBL *vtbl); static #else extern MAGIC * DPPP_(my_mg_findext)(SV * sv, int type, const MGVTBL *vtbl); #endif #define mg_findext DPPP_(my_mg_findext) #define Perl_mg_findext DPPP_(my_mg_findext) #if defined(NEED_mg_findext) || defined(NEED_mg_findext_GLOBAL) MAGIC * DPPP_(my_mg_findext)(SV * sv, int type, const MGVTBL *vtbl) { if (sv) { MAGIC *mg; #ifdef AvPAD_NAMELIST assert(!(SvTYPE(sv) == SVt_PVAV && AvPAD_NAMELIST(sv))); #endif for (mg = SvMAGIC (sv); mg; mg = mg->mg_moremagic) { if (mg->mg_type == type && mg->mg_virtual == vtbl) return mg; } } return NULL; } #endif #endif #if !defined(sv_unmagicext) #if defined(NEED_sv_unmagicext) static int DPPP_(my_sv_unmagicext)(pTHX_ SV * const sv, const int type, MGVTBL * vtbl); static #else extern int DPPP_(my_sv_unmagicext)(pTHX_ SV * const sv, const int type, MGVTBL * vtbl); #endif #ifdef sv_unmagicext # undef sv_unmagicext #endif #define sv_unmagicext(a,b,c) DPPP_(my_sv_unmagicext)(aTHX_ a,b,c) #define Perl_sv_unmagicext DPPP_(my_sv_unmagicext) #if defined(NEED_sv_unmagicext) || defined(NEED_sv_unmagicext_GLOBAL) int DPPP_(my_sv_unmagicext)(pTHX_ SV *const sv, const int type, MGVTBL *vtbl) { MAGIC* mg; MAGIC** mgp; if (SvTYPE(sv) < SVt_PVMG || !SvMAGIC(sv)) return 0; mgp = &(SvMAGIC(sv)); for (mg = *mgp; mg; mg = *mgp) { const MGVTBL* const virt = mg->mg_virtual; if (mg->mg_type == type && virt == vtbl) { *mgp = mg->mg_moremagic; if (virt && virt->svt_free) virt->svt_free(aTHX_ sv, mg); if (mg->mg_ptr && mg->mg_type != PERL_MAGIC_regex_global) { if (mg->mg_len > 0) Safefree(mg->mg_ptr); else if (mg->mg_len == HEf_SVKEY) /* Questionable on older perls... */ SvREFCNT_dec(MUTABLE_SV(mg->mg_ptr)); else if (mg->mg_type == PERL_MAGIC_utf8) Safefree(mg->mg_ptr); } if (mg->mg_flags & MGf_REFCOUNTED) SvREFCNT_dec(mg->mg_obj); Safefree(mg); } else mgp = &mg->mg_moremagic; } if (SvMAGIC(sv)) { if (SvMAGICAL(sv)) /* if we're under save_magic, wait for restore_magic; */ mg_magical(sv); /* else fix the flags now */ } else { SvMAGICAL_off(sv); SvFLAGS(sv) |= (SvFLAGS(sv) & (SVp_IOK|SVp_NOK|SVp_POK)) >> PRIVSHIFT; } return 0; } #endif #endif #ifdef USE_ITHREADS #ifndef CopFILE # define CopFILE(c) ((c)->cop_file) #endif #ifndef CopFILEGV # define CopFILEGV(c) (CopFILE(c) ? gv_fetchfile(CopFILE(c)) : Nullgv) #endif #ifndef CopFILE_set # define CopFILE_set(c,pv) ((c)->cop_file = savepv(pv)) #endif #ifndef CopFILESV # define CopFILESV(c) (CopFILE(c) ? GvSV(gv_fetchfile(CopFILE(c))) : Nullsv) #endif #ifndef CopFILEAV # define CopFILEAV(c) (CopFILE(c) ? GvAV(gv_fetchfile(CopFILE(c))) : Nullav) #endif #ifndef CopSTASHPV # define CopSTASHPV(c) ((c)->cop_stashpv) #endif #ifndef CopSTASHPV_set # define CopSTASHPV_set(c,pv) ((c)->cop_stashpv = ((pv) ? savepv(pv) : Nullch)) #endif #ifndef CopSTASH # define CopSTASH(c) (CopSTASHPV(c) ? gv_stashpv(CopSTASHPV(c),GV_ADD) : Nullhv) #endif #ifndef CopSTASH_set # define CopSTASH_set(c,hv) CopSTASHPV_set(c, (hv) ? HvNAME(hv) : Nullch) #endif #ifndef CopSTASH_eq # define CopSTASH_eq(c,hv) ((hv) && (CopSTASHPV(c) == HvNAME(hv) \ || (CopSTASHPV(c) && HvNAME(hv) \ && strEQ(CopSTASHPV(c), HvNAME(hv))))) #endif #else #ifndef CopFILEGV # define CopFILEGV(c) ((c)->cop_filegv) #endif #ifndef CopFILEGV_set # define CopFILEGV_set(c,gv) ((c)->cop_filegv = (GV*)SvREFCNT_inc(gv)) #endif #ifndef CopFILE_set # define CopFILE_set(c,pv) CopFILEGV_set((c), gv_fetchfile(pv)) #endif #ifndef CopFILESV # define CopFILESV(c) (CopFILEGV(c) ? GvSV(CopFILEGV(c)) : Nullsv) #endif #ifndef CopFILEAV # define CopFILEAV(c) (CopFILEGV(c) ? GvAV(CopFILEGV(c)) : Nullav) #endif #ifndef CopFILE # define CopFILE(c) (CopFILESV(c) ? SvPVX(CopFILESV(c)) : Nullch) #endif #ifndef CopSTASH # define CopSTASH(c) ((c)->cop_stash) #endif #ifndef CopSTASH_set # define CopSTASH_set(c,hv) ((c)->cop_stash = (hv)) #endif #ifndef CopSTASHPV # define CopSTASHPV(c) (CopSTASH(c) ? HvNAME(CopSTASH(c)) : Nullch) #endif #ifndef CopSTASHPV_set # define CopSTASHPV_set(c,pv) CopSTASH_set((c), gv_stashpv(pv,GV_ADD)) #endif #ifndef CopSTASH_eq # define CopSTASH_eq(c,hv) (CopSTASH(c) == (hv)) #endif #endif /* USE_ITHREADS */ #if (PERL_BCDVERSION >= 0x5006000) #ifndef caller_cx # if defined(NEED_caller_cx) || defined(NEED_caller_cx_GLOBAL) static I32 DPPP_dopoptosub_at(const PERL_CONTEXT *cxstk, I32 startingblock) { I32 i; for (i = startingblock; i >= 0; i--) { register const PERL_CONTEXT * const cx = &cxstk[i]; switch (CxTYPE(cx)) { default: continue; case CXt_EVAL: case CXt_SUB: case CXt_FORMAT: return i; } } return i; } # endif # if defined(NEED_caller_cx) static const PERL_CONTEXT * DPPP_(my_caller_cx)(pTHX_ I32 count, const PERL_CONTEXT **dbcxp); static #else extern const PERL_CONTEXT * DPPP_(my_caller_cx)(pTHX_ I32 count, const PERL_CONTEXT **dbcxp); #endif #ifdef caller_cx # undef caller_cx #endif #define caller_cx(a,b) DPPP_(my_caller_cx)(aTHX_ a,b) #define Perl_caller_cx DPPP_(my_caller_cx) #if defined(NEED_caller_cx) || defined(NEED_caller_cx_GLOBAL) const PERL_CONTEXT * DPPP_(my_caller_cx)(pTHX_ I32 count, const PERL_CONTEXT **dbcxp) { register I32 cxix = DPPP_dopoptosub_at(cxstack, cxstack_ix); register const PERL_CONTEXT *cx; register const PERL_CONTEXT *ccstack = cxstack; const PERL_SI *top_si = PL_curstackinfo; for (;;) { /* we may be in a higher stacklevel, so dig down deeper */ while (cxix < 0 && top_si->si_type != PERLSI_MAIN) { top_si = top_si->si_prev; ccstack = top_si->si_cxstack; cxix = DPPP_dopoptosub_at(ccstack, top_si->si_cxix); } if (cxix < 0) return NULL; /* caller() should not report the automatic calls to &DB::sub */ if (PL_DBsub && GvCV(PL_DBsub) && cxix >= 0 && ccstack[cxix].blk_sub.cv == GvCV(PL_DBsub)) count++; if (!count--) break; cxix = DPPP_dopoptosub_at(ccstack, cxix - 1); } cx = &ccstack[cxix]; if (dbcxp) *dbcxp = cx; if (CxTYPE(cx) == CXt_SUB || CxTYPE(cx) == CXt_FORMAT) { const I32 dbcxix = DPPP_dopoptosub_at(ccstack, cxix - 1); /* We expect that ccstack[dbcxix] is CXt_SUB, anyway, the field below is defined for any cx. */ /* caller() should not report the automatic calls to &DB::sub */ if (PL_DBsub && GvCV(PL_DBsub) && dbcxix >= 0 && ccstack[dbcxix].blk_sub.cv == GvCV(PL_DBsub)) cx = &ccstack[dbcxix]; } return cx; } # endif #endif /* caller_cx */ #endif /* 5.6.0 */ #ifndef IN_PERL_COMPILETIME # define IN_PERL_COMPILETIME (PL_curcop == &PL_compiling) #endif #ifndef IN_LOCALE_RUNTIME # define IN_LOCALE_RUNTIME (PL_curcop->op_private & HINT_LOCALE) #endif #ifndef IN_LOCALE_COMPILETIME # define IN_LOCALE_COMPILETIME (PL_hints & HINT_LOCALE) #endif #ifndef IN_LOCALE # define IN_LOCALE (IN_PERL_COMPILETIME ? IN_LOCALE_COMPILETIME : IN_LOCALE_RUNTIME) #endif #ifndef IS_NUMBER_IN_UV # define IS_NUMBER_IN_UV 0x01 #endif #ifndef IS_NUMBER_GREATER_THAN_UV_MAX # define IS_NUMBER_GREATER_THAN_UV_MAX 0x02 #endif #ifndef IS_NUMBER_NOT_INT # define IS_NUMBER_NOT_INT 0x04 #endif #ifndef IS_NUMBER_NEG # define IS_NUMBER_NEG 0x08 #endif #ifndef IS_NUMBER_INFINITY # define IS_NUMBER_INFINITY 0x10 #endif #ifndef IS_NUMBER_NAN # define IS_NUMBER_NAN 0x20 #endif #ifndef GROK_NUMERIC_RADIX # define GROK_NUMERIC_RADIX(sp, send) grok_numeric_radix(sp, send) #endif #ifndef PERL_SCAN_GREATER_THAN_UV_MAX # define PERL_SCAN_GREATER_THAN_UV_MAX 0x02 #endif #ifndef PERL_SCAN_SILENT_ILLDIGIT # define PERL_SCAN_SILENT_ILLDIGIT 0x04 #endif #ifndef PERL_SCAN_ALLOW_UNDERSCORES # define PERL_SCAN_ALLOW_UNDERSCORES 0x01 #endif #ifndef PERL_SCAN_DISALLOW_PREFIX # define PERL_SCAN_DISALLOW_PREFIX 0x02 #endif #ifndef grok_numeric_radix #if defined(NEED_grok_numeric_radix) static bool DPPP_(my_grok_numeric_radix)(pTHX_ const char ** sp, const char * send); static #else extern bool DPPP_(my_grok_numeric_radix)(pTHX_ const char ** sp, const char * send); #endif #ifdef grok_numeric_radix # undef grok_numeric_radix #endif #define grok_numeric_radix(a,b) DPPP_(my_grok_numeric_radix)(aTHX_ a,b) #define Perl_grok_numeric_radix DPPP_(my_grok_numeric_radix) #if defined(NEED_grok_numeric_radix) || defined(NEED_grok_numeric_radix_GLOBAL) bool DPPP_(my_grok_numeric_radix)(pTHX_ const char **sp, const char *send) { #ifdef USE_LOCALE_NUMERIC #ifdef PL_numeric_radix_sv if (PL_numeric_radix_sv && IN_LOCALE) { STRLEN len; char* radix = SvPV(PL_numeric_radix_sv, len); if (*sp + len <= send && memEQ(*sp, radix, len)) { *sp += len; return TRUE; } } #else /* older perls don't have PL_numeric_radix_sv so the radix * must manually be requested from locale.h */ #include dTHR; /* needed for older threaded perls */ struct lconv *lc = localeconv(); char *radix = lc->decimal_point; if (radix && IN_LOCALE) { STRLEN len = strlen(radix); if (*sp + len <= send && memEQ(*sp, radix, len)) { *sp += len; return TRUE; } } #endif #endif /* USE_LOCALE_NUMERIC */ /* always try "." if numeric radix didn't match because * we may have data from different locales mixed */ if (*sp < send && **sp == '.') { ++*sp; return TRUE; } return FALSE; } #endif #endif #ifndef grok_number #if defined(NEED_grok_number) static int DPPP_(my_grok_number)(pTHX_ const char * pv, STRLEN len, UV * valuep); static #else extern int DPPP_(my_grok_number)(pTHX_ const char * pv, STRLEN len, UV * valuep); #endif #ifdef grok_number # undef grok_number #endif #define grok_number(a,b,c) DPPP_(my_grok_number)(aTHX_ a,b,c) #define Perl_grok_number DPPP_(my_grok_number) #if defined(NEED_grok_number) || defined(NEED_grok_number_GLOBAL) int DPPP_(my_grok_number)(pTHX_ const char *pv, STRLEN len, UV *valuep) { const char *s = pv; const char *send = pv + len; const UV max_div_10 = UV_MAX / 10; const char max_mod_10 = UV_MAX % 10; int numtype = 0; int sawinf = 0; int sawnan = 0; while (s < send && isSPACE(*s)) s++; if (s == send) { return 0; } else if (*s == '-') { s++; numtype = IS_NUMBER_NEG; } else if (*s == '+') s++; if (s == send) return 0; /* next must be digit or the radix separator or beginning of infinity */ if (isDIGIT(*s)) { /* UVs are at least 32 bits, so the first 9 decimal digits cannot overflow. */ UV value = *s - '0'; /* This construction seems to be more optimiser friendly. (without it gcc does the isDIGIT test and the *s - '0' separately) With it gcc on arm is managing 6 instructions (6 cycles) per digit. In theory the optimiser could deduce how far to unroll the loop before checking for overflow. */ if (++s < send) { int digit = *s - '0'; if (digit >= 0 && digit <= 9) { value = value * 10 + digit; if (++s < send) { digit = *s - '0'; if (digit >= 0 && digit <= 9) { value = value * 10 + digit; if (++s < send) { digit = *s - '0'; if (digit >= 0 && digit <= 9) { value = value * 10 + digit; if (++s < send) { digit = *s - '0'; if (digit >= 0 && digit <= 9) { value = value * 10 + digit; if (++s < send) { digit = *s - '0'; if (digit >= 0 && digit <= 9) { value = value * 10 + digit; if (++s < send) { digit = *s - '0'; if (digit >= 0 && digit <= 9) { value = value * 10 + digit; if (++s < send) { digit = *s - '0'; if (digit >= 0 && digit <= 9) { value = value * 10 + digit; if (++s < send) { digit = *s - '0'; if (digit >= 0 && digit <= 9) { value = value * 10 + digit; if (++s < send) { /* Now got 9 digits, so need to check each time for overflow. */ digit = *s - '0'; while (digit >= 0 && digit <= 9 && (value < max_div_10 || (value == max_div_10 && digit <= max_mod_10))) { value = value * 10 + digit; if (++s < send) digit = *s - '0'; else break; } if (digit >= 0 && digit <= 9 && (s < send)) { /* value overflowed. skip the remaining digits, don't worry about setting *valuep. */ do { s++; } while (s < send && isDIGIT(*s)); numtype |= IS_NUMBER_GREATER_THAN_UV_MAX; goto skip_value; } } } } } } } } } } } } } } } } } } numtype |= IS_NUMBER_IN_UV; if (valuep) *valuep = value; skip_value: if (GROK_NUMERIC_RADIX(&s, send)) { numtype |= IS_NUMBER_NOT_INT; while (s < send && isDIGIT(*s)) /* optional digits after the radix */ s++; } } else if (GROK_NUMERIC_RADIX(&s, send)) { numtype |= IS_NUMBER_NOT_INT | IS_NUMBER_IN_UV; /* valuep assigned below */ /* no digits before the radix means we need digits after it */ if (s < send && isDIGIT(*s)) { do { s++; } while (s < send && isDIGIT(*s)); if (valuep) { /* integer approximation is valid - it's 0. */ *valuep = 0; } } else return 0; } else if (*s == 'I' || *s == 'i') { s++; if (s == send || (*s != 'N' && *s != 'n')) return 0; s++; if (s == send || (*s != 'F' && *s != 'f')) return 0; s++; if (s < send && (*s == 'I' || *s == 'i')) { s++; if (s == send || (*s != 'N' && *s != 'n')) return 0; s++; if (s == send || (*s != 'I' && *s != 'i')) return 0; s++; if (s == send || (*s != 'T' && *s != 't')) return 0; s++; if (s == send || (*s != 'Y' && *s != 'y')) return 0; s++; } sawinf = 1; } else if (*s == 'N' || *s == 'n') { /* XXX TODO: There are signaling NaNs and quiet NaNs. */ s++; if (s == send || (*s != 'A' && *s != 'a')) return 0; s++; if (s == send || (*s != 'N' && *s != 'n')) return 0; s++; sawnan = 1; } else return 0; if (sawinf) { numtype &= IS_NUMBER_NEG; /* Keep track of sign */ numtype |= IS_NUMBER_INFINITY | IS_NUMBER_NOT_INT; } else if (sawnan) { numtype &= IS_NUMBER_NEG; /* Keep track of sign */ numtype |= IS_NUMBER_NAN | IS_NUMBER_NOT_INT; } else if (s < send) { /* we can have an optional exponent part */ if (*s == 'e' || *s == 'E') { /* The only flag we keep is sign. Blow away any "it's UV" */ numtype &= IS_NUMBER_NEG; numtype |= IS_NUMBER_NOT_INT; s++; if (s < send && (*s == '-' || *s == '+')) s++; if (s < send && isDIGIT(*s)) { do { s++; } while (s < send && isDIGIT(*s)); } else return 0; } } while (s < send && isSPACE(*s)) s++; if (s >= send) return numtype; if (len == 10 && memEQ(pv, "0 but true", 10)) { if (valuep) *valuep = 0; return IS_NUMBER_IN_UV; } return 0; } #endif #endif /* * The grok_* routines have been modified to use warn() instead of * Perl_warner(). Also, 'hexdigit' was the former name of PL_hexdigit, * which is why the stack variable has been renamed to 'xdigit'. */ #ifndef grok_bin #if defined(NEED_grok_bin) static UV DPPP_(my_grok_bin)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result); static #else extern UV DPPP_(my_grok_bin)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result); #endif #ifdef grok_bin # undef grok_bin #endif #define grok_bin(a,b,c,d) DPPP_(my_grok_bin)(aTHX_ a,b,c,d) #define Perl_grok_bin DPPP_(my_grok_bin) #if defined(NEED_grok_bin) || defined(NEED_grok_bin_GLOBAL) UV DPPP_(my_grok_bin)(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result) { const char *s = start; STRLEN len = *len_p; UV value = 0; NV value_nv = 0; const UV max_div_2 = UV_MAX / 2; bool allow_underscores = *flags & PERL_SCAN_ALLOW_UNDERSCORES; bool overflowed = FALSE; if (!(*flags & PERL_SCAN_DISALLOW_PREFIX)) { /* strip off leading b or 0b. for compatibility silently suffer "b" and "0b" as valid binary numbers. */ if (len >= 1) { if (s[0] == 'b') { s++; len--; } else if (len >= 2 && s[0] == '0' && s[1] == 'b') { s+=2; len-=2; } } } for (; len-- && *s; s++) { char bit = *s; if (bit == '0' || bit == '1') { /* Write it in this wonky order with a goto to attempt to get the compiler to make the common case integer-only loop pretty tight. With gcc seems to be much straighter code than old scan_bin. */ redo: if (!overflowed) { if (value <= max_div_2) { value = (value << 1) | (bit - '0'); continue; } /* Bah. We're just overflowed. */ warn("Integer overflow in binary number"); overflowed = TRUE; value_nv = (NV) value; } value_nv *= 2.0; /* If an NV has not enough bits in its mantissa to * represent a UV this summing of small low-order numbers * is a waste of time (because the NV cannot preserve * the low-order bits anyway): we could just remember when * did we overflow and in the end just multiply value_nv by the * right amount. */ value_nv += (NV)(bit - '0'); continue; } if (bit == '_' && len && allow_underscores && (bit = s[1]) && (bit == '0' || bit == '1')) { --len; ++s; goto redo; } if (!(*flags & PERL_SCAN_SILENT_ILLDIGIT)) warn("Illegal binary digit '%c' ignored", *s); break; } if ( ( overflowed && value_nv > 4294967295.0) #if UVSIZE > 4 || (!overflowed && value > 0xffffffff ) #endif ) { warn("Binary number > 0b11111111111111111111111111111111 non-portable"); } *len_p = s - start; if (!overflowed) { *flags = 0; return value; } *flags = PERL_SCAN_GREATER_THAN_UV_MAX; if (result) *result = value_nv; return UV_MAX; } #endif #endif #ifndef grok_hex #if defined(NEED_grok_hex) static UV DPPP_(my_grok_hex)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result); static #else extern UV DPPP_(my_grok_hex)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result); #endif #ifdef grok_hex # undef grok_hex #endif #define grok_hex(a,b,c,d) DPPP_(my_grok_hex)(aTHX_ a,b,c,d) #define Perl_grok_hex DPPP_(my_grok_hex) #if defined(NEED_grok_hex) || defined(NEED_grok_hex_GLOBAL) UV DPPP_(my_grok_hex)(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result) { const char *s = start; STRLEN len = *len_p; UV value = 0; NV value_nv = 0; const UV max_div_16 = UV_MAX / 16; bool allow_underscores = *flags & PERL_SCAN_ALLOW_UNDERSCORES; bool overflowed = FALSE; const char *xdigit; if (!(*flags & PERL_SCAN_DISALLOW_PREFIX)) { /* strip off leading x or 0x. for compatibility silently suffer "x" and "0x" as valid hex numbers. */ if (len >= 1) { if (s[0] == 'x') { s++; len--; } else if (len >= 2 && s[0] == '0' && s[1] == 'x') { s+=2; len-=2; } } } for (; len-- && *s; s++) { xdigit = strchr((char *) PL_hexdigit, *s); if (xdigit) { /* Write it in this wonky order with a goto to attempt to get the compiler to make the common case integer-only loop pretty tight. With gcc seems to be much straighter code than old scan_hex. */ redo: if (!overflowed) { if (value <= max_div_16) { value = (value << 4) | ((xdigit - PL_hexdigit) & 15); continue; } warn("Integer overflow in hexadecimal number"); overflowed = TRUE; value_nv = (NV) value; } value_nv *= 16.0; /* If an NV has not enough bits in its mantissa to * represent a UV this summing of small low-order numbers * is a waste of time (because the NV cannot preserve * the low-order bits anyway): we could just remember when * did we overflow and in the end just multiply value_nv by the * right amount of 16-tuples. */ value_nv += (NV)((xdigit - PL_hexdigit) & 15); continue; } if (*s == '_' && len && allow_underscores && s[1] && (xdigit = strchr((char *) PL_hexdigit, s[1]))) { --len; ++s; goto redo; } if (!(*flags & PERL_SCAN_SILENT_ILLDIGIT)) warn("Illegal hexadecimal digit '%c' ignored", *s); break; } if ( ( overflowed && value_nv > 4294967295.0) #if UVSIZE > 4 || (!overflowed && value > 0xffffffff ) #endif ) { warn("Hexadecimal number > 0xffffffff non-portable"); } *len_p = s - start; if (!overflowed) { *flags = 0; return value; } *flags = PERL_SCAN_GREATER_THAN_UV_MAX; if (result) *result = value_nv; return UV_MAX; } #endif #endif #ifndef grok_oct #if defined(NEED_grok_oct) static UV DPPP_(my_grok_oct)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result); static #else extern UV DPPP_(my_grok_oct)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result); #endif #ifdef grok_oct # undef grok_oct #endif #define grok_oct(a,b,c,d) DPPP_(my_grok_oct)(aTHX_ a,b,c,d) #define Perl_grok_oct DPPP_(my_grok_oct) #if defined(NEED_grok_oct) || defined(NEED_grok_oct_GLOBAL) UV DPPP_(my_grok_oct)(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result) { const char *s = start; STRLEN len = *len_p; UV value = 0; NV value_nv = 0; const UV max_div_8 = UV_MAX / 8; bool allow_underscores = *flags & PERL_SCAN_ALLOW_UNDERSCORES; bool overflowed = FALSE; for (; len-- && *s; s++) { /* gcc 2.95 optimiser not smart enough to figure that this subtraction out front allows slicker code. */ int digit = *s - '0'; if (digit >= 0 && digit <= 7) { /* Write it in this wonky order with a goto to attempt to get the compiler to make the common case integer-only loop pretty tight. */ redo: if (!overflowed) { if (value <= max_div_8) { value = (value << 3) | digit; continue; } /* Bah. We're just overflowed. */ warn("Integer overflow in octal number"); overflowed = TRUE; value_nv = (NV) value; } value_nv *= 8.0; /* If an NV has not enough bits in its mantissa to * represent a UV this summing of small low-order numbers * is a waste of time (because the NV cannot preserve * the low-order bits anyway): we could just remember when * did we overflow and in the end just multiply value_nv by the * right amount of 8-tuples. */ value_nv += (NV)digit; continue; } if (digit == ('_' - '0') && len && allow_underscores && (digit = s[1] - '0') && (digit >= 0 && digit <= 7)) { --len; ++s; goto redo; } /* Allow \octal to work the DWIM way (that is, stop scanning * as soon as non-octal characters are seen, complain only iff * someone seems to want to use the digits eight and nine). */ if (digit == 8 || digit == 9) { if (!(*flags & PERL_SCAN_SILENT_ILLDIGIT)) warn("Illegal octal digit '%c' ignored", *s); } break; } if ( ( overflowed && value_nv > 4294967295.0) #if UVSIZE > 4 || (!overflowed && value > 0xffffffff ) #endif ) { warn("Octal number > 037777777777 non-portable"); } *len_p = s - start; if (!overflowed) { *flags = 0; return value; } *flags = PERL_SCAN_GREATER_THAN_UV_MAX; if (result) *result = value_nv; return UV_MAX; } #endif #endif #if !defined(my_snprintf) #if defined(NEED_my_snprintf) static int DPPP_(my_my_snprintf)(char * buffer, const Size_t len, const char * format, ...); static #else extern int DPPP_(my_my_snprintf)(char * buffer, const Size_t len, const char * format, ...); #endif #define my_snprintf DPPP_(my_my_snprintf) #define Perl_my_snprintf DPPP_(my_my_snprintf) #if defined(NEED_my_snprintf) || defined(NEED_my_snprintf_GLOBAL) int DPPP_(my_my_snprintf)(char *buffer, const Size_t len, const char *format, ...) { dTHX; int retval; va_list ap; va_start(ap, format); #ifdef HAS_VSNPRINTF retval = vsnprintf(buffer, len, format, ap); #else retval = vsprintf(buffer, format, ap); #endif va_end(ap); if (retval < 0 || (len > 0 && (Size_t)retval >= len)) Perl_croak(aTHX_ "panic: my_snprintf buffer overflow"); return retval; } #endif #endif #if !defined(my_sprintf) #if defined(NEED_my_sprintf) static int DPPP_(my_my_sprintf)(char * buffer, const char * pat, ...); static #else extern int DPPP_(my_my_sprintf)(char * buffer, const char * pat, ...); #endif #define my_sprintf DPPP_(my_my_sprintf) #define Perl_my_sprintf DPPP_(my_my_sprintf) #if defined(NEED_my_sprintf) || defined(NEED_my_sprintf_GLOBAL) int DPPP_(my_my_sprintf)(char *buffer, const char* pat, ...) { va_list args; va_start(args, pat); vsprintf(buffer, pat, args); va_end(args); return strlen(buffer); } #endif #endif #ifdef NO_XSLOCKS # ifdef dJMPENV # define dXCPT dJMPENV; int rEtV = 0 # define XCPT_TRY_START JMPENV_PUSH(rEtV); if (rEtV == 0) # define XCPT_TRY_END JMPENV_POP; # define XCPT_CATCH if (rEtV != 0) # define XCPT_RETHROW JMPENV_JUMP(rEtV) # else # define dXCPT Sigjmp_buf oldTOP; int rEtV = 0 # define XCPT_TRY_START Copy(top_env, oldTOP, 1, Sigjmp_buf); rEtV = Sigsetjmp(top_env, 1); if (rEtV == 0) # define XCPT_TRY_END Copy(oldTOP, top_env, 1, Sigjmp_buf); # define XCPT_CATCH if (rEtV != 0) # define XCPT_RETHROW Siglongjmp(top_env, rEtV) # endif #endif #if !defined(my_strlcat) #if defined(NEED_my_strlcat) static Size_t DPPP_(my_my_strlcat)(char * dst, const char * src, Size_t size); static #else extern Size_t DPPP_(my_my_strlcat)(char * dst, const char * src, Size_t size); #endif #define my_strlcat DPPP_(my_my_strlcat) #define Perl_my_strlcat DPPP_(my_my_strlcat) #if defined(NEED_my_strlcat) || defined(NEED_my_strlcat_GLOBAL) Size_t DPPP_(my_my_strlcat)(char *dst, const char *src, Size_t size) { Size_t used, length, copy; used = strlen(dst); length = strlen(src); if (size > 0 && used < size - 1) { copy = (length >= size - used) ? size - used - 1 : length; memcpy(dst + used, src, copy); dst[used + copy] = '\0'; } return used + length; } #endif #endif #if !defined(my_strlcpy) #if defined(NEED_my_strlcpy) static Size_t DPPP_(my_my_strlcpy)(char * dst, const char * src, Size_t size); static #else extern Size_t DPPP_(my_my_strlcpy)(char * dst, const char * src, Size_t size); #endif #define my_strlcpy DPPP_(my_my_strlcpy) #define Perl_my_strlcpy DPPP_(my_my_strlcpy) #if defined(NEED_my_strlcpy) || defined(NEED_my_strlcpy_GLOBAL) Size_t DPPP_(my_my_strlcpy)(char *dst, const char *src, Size_t size) { Size_t length, copy; length = strlen(src); if (size > 0) { copy = (length >= size) ? size - 1 : length; memcpy(dst, src, copy); dst[copy] = '\0'; } return length; } #endif #endif #ifndef PERL_PV_ESCAPE_QUOTE # define PERL_PV_ESCAPE_QUOTE 0x0001 #endif #ifndef PERL_PV_PRETTY_QUOTE # define PERL_PV_PRETTY_QUOTE PERL_PV_ESCAPE_QUOTE #endif #ifndef PERL_PV_PRETTY_ELLIPSES # define PERL_PV_PRETTY_ELLIPSES 0x0002 #endif #ifndef PERL_PV_PRETTY_LTGT # define PERL_PV_PRETTY_LTGT 0x0004 #endif #ifndef PERL_PV_ESCAPE_FIRSTCHAR # define PERL_PV_ESCAPE_FIRSTCHAR 0x0008 #endif #ifndef PERL_PV_ESCAPE_UNI # define PERL_PV_ESCAPE_UNI 0x0100 #endif #ifndef PERL_PV_ESCAPE_UNI_DETECT # define PERL_PV_ESCAPE_UNI_DETECT 0x0200 #endif #ifndef PERL_PV_ESCAPE_ALL # define PERL_PV_ESCAPE_ALL 0x1000 #endif #ifndef PERL_PV_ESCAPE_NOBACKSLASH # define PERL_PV_ESCAPE_NOBACKSLASH 0x2000 #endif #ifndef PERL_PV_ESCAPE_NOCLEAR # define PERL_PV_ESCAPE_NOCLEAR 0x4000 #endif #ifndef PERL_PV_ESCAPE_RE # define PERL_PV_ESCAPE_RE 0x8000 #endif #ifndef PERL_PV_PRETTY_NOCLEAR # define PERL_PV_PRETTY_NOCLEAR PERL_PV_ESCAPE_NOCLEAR #endif #ifndef PERL_PV_PRETTY_DUMP # define PERL_PV_PRETTY_DUMP PERL_PV_PRETTY_ELLIPSES|PERL_PV_PRETTY_QUOTE #endif #ifndef PERL_PV_PRETTY_REGPROP # define PERL_PV_PRETTY_REGPROP PERL_PV_PRETTY_ELLIPSES|PERL_PV_PRETTY_LTGT|PERL_PV_ESCAPE_RE #endif /* Hint: pv_escape * Note that unicode functionality is only backported to * those perl versions that support it. For older perl * versions, the implementation will fall back to bytes. */ #ifndef pv_escape #if defined(NEED_pv_escape) static char * DPPP_(my_pv_escape)(pTHX_ SV * dsv, char const * const str, const STRLEN count, const STRLEN max, STRLEN * const escaped, const U32 flags); static #else extern char * DPPP_(my_pv_escape)(pTHX_ SV * dsv, char const * const str, const STRLEN count, const STRLEN max, STRLEN * const escaped, const U32 flags); #endif #ifdef pv_escape # undef pv_escape #endif #define pv_escape(a,b,c,d,e,f) DPPP_(my_pv_escape)(aTHX_ a,b,c,d,e,f) #define Perl_pv_escape DPPP_(my_pv_escape) #if defined(NEED_pv_escape) || defined(NEED_pv_escape_GLOBAL) char * DPPP_(my_pv_escape)(pTHX_ SV *dsv, char const * const str, const STRLEN count, const STRLEN max, STRLEN * const escaped, const U32 flags) { const char esc = flags & PERL_PV_ESCAPE_RE ? '%' : '\\'; const char dq = flags & PERL_PV_ESCAPE_QUOTE ? '"' : esc; char octbuf[32] = "%123456789ABCDF"; STRLEN wrote = 0; STRLEN chsize = 0; STRLEN readsize = 1; #if defined(is_utf8_string) && defined(utf8_to_uvchr) bool isuni = flags & PERL_PV_ESCAPE_UNI ? 1 : 0; #endif const char *pv = str; const char * const end = pv + count; octbuf[0] = esc; if (!(flags & PERL_PV_ESCAPE_NOCLEAR)) sv_setpvs(dsv, ""); #if defined(is_utf8_string) && defined(utf8_to_uvchr) if ((flags & PERL_PV_ESCAPE_UNI_DETECT) && is_utf8_string((U8*)pv, count)) isuni = 1; #endif for (; pv < end && (!max || wrote < max) ; pv += readsize) { const UV u = #if defined(is_utf8_string) && defined(utf8_to_uvchr) isuni ? utf8_to_uvchr((U8*)pv, &readsize) : #endif (U8)*pv; const U8 c = (U8)u & 0xFF; if (u > 255 || (flags & PERL_PV_ESCAPE_ALL)) { if (flags & PERL_PV_ESCAPE_FIRSTCHAR) chsize = my_snprintf(octbuf, sizeof octbuf, "%" UVxf, u); else chsize = my_snprintf(octbuf, sizeof octbuf, "%cx{%" UVxf "}", esc, u); } else if (flags & PERL_PV_ESCAPE_NOBACKSLASH) { chsize = 1; } else { if (c == dq || c == esc || !isPRINT(c)) { chsize = 2; switch (c) { case '\\' : /* fallthrough */ case '%' : if (c == esc) octbuf[1] = esc; else chsize = 1; break; case '\v' : octbuf[1] = 'v'; break; case '\t' : octbuf[1] = 't'; break; case '\r' : octbuf[1] = 'r'; break; case '\n' : octbuf[1] = 'n'; break; case '\f' : octbuf[1] = 'f'; break; case '"' : if (dq == '"') octbuf[1] = '"'; else chsize = 1; break; default: chsize = my_snprintf(octbuf, sizeof octbuf, pv < end && isDIGIT((U8)*(pv+readsize)) ? "%c%03o" : "%c%o", esc, c); } } else { chsize = 1; } } if (max && wrote + chsize > max) { break; } else if (chsize > 1) { sv_catpvn(dsv, octbuf, chsize); wrote += chsize; } else { char tmp[2]; my_snprintf(tmp, sizeof tmp, "%c", c); sv_catpvn(dsv, tmp, 1); wrote++; } if (flags & PERL_PV_ESCAPE_FIRSTCHAR) break; } if (escaped != NULL) *escaped= pv - str; return SvPVX(dsv); } #endif #endif #ifndef pv_pretty #if defined(NEED_pv_pretty) static char * DPPP_(my_pv_pretty)(pTHX_ SV * dsv, char const * const str, const STRLEN count, const STRLEN max, char const * const start_color, char const * const end_color, const U32 flags); static #else extern char * DPPP_(my_pv_pretty)(pTHX_ SV * dsv, char const * const str, const STRLEN count, const STRLEN max, char const * const start_color, char const * const end_color, const U32 flags); #endif #ifdef pv_pretty # undef pv_pretty #endif #define pv_pretty(a,b,c,d,e,f,g) DPPP_(my_pv_pretty)(aTHX_ a,b,c,d,e,f,g) #define Perl_pv_pretty DPPP_(my_pv_pretty) #if defined(NEED_pv_pretty) || defined(NEED_pv_pretty_GLOBAL) char * DPPP_(my_pv_pretty)(pTHX_ SV *dsv, char const * const str, const STRLEN count, const STRLEN max, char const * const start_color, char const * const end_color, const U32 flags) { const U8 dq = (flags & PERL_PV_PRETTY_QUOTE) ? '"' : '%'; STRLEN escaped; if (!(flags & PERL_PV_PRETTY_NOCLEAR)) sv_setpvs(dsv, ""); if (dq == '"') sv_catpvs(dsv, "\""); else if (flags & PERL_PV_PRETTY_LTGT) sv_catpvs(dsv, "<"); if (start_color != NULL) sv_catpv(dsv, D_PPP_CONSTPV_ARG(start_color)); pv_escape(dsv, str, count, max, &escaped, flags | PERL_PV_ESCAPE_NOCLEAR); if (end_color != NULL) sv_catpv(dsv, D_PPP_CONSTPV_ARG(end_color)); if (dq == '"') sv_catpvs(dsv, "\""); else if (flags & PERL_PV_PRETTY_LTGT) sv_catpvs(dsv, ">"); if ((flags & PERL_PV_PRETTY_ELLIPSES) && escaped < count) sv_catpvs(dsv, "..."); return SvPVX(dsv); } #endif #endif #ifndef pv_display #if defined(NEED_pv_display) static char * DPPP_(my_pv_display)(pTHX_ SV * dsv, const char * pv, STRLEN cur, STRLEN len, STRLEN pvlim); static #else extern char * DPPP_(my_pv_display)(pTHX_ SV * dsv, const char * pv, STRLEN cur, STRLEN len, STRLEN pvlim); #endif #ifdef pv_display # undef pv_display #endif #define pv_display(a,b,c,d,e) DPPP_(my_pv_display)(aTHX_ a,b,c,d,e) #define Perl_pv_display DPPP_(my_pv_display) #if defined(NEED_pv_display) || defined(NEED_pv_display_GLOBAL) char * DPPP_(my_pv_display)(pTHX_ SV *dsv, const char *pv, STRLEN cur, STRLEN len, STRLEN pvlim) { pv_pretty(dsv, pv, cur, pvlim, NULL, NULL, PERL_PV_PRETTY_DUMP); if (len > cur && pv[cur] == '\0') sv_catpvs(dsv, "\\0"); return SvPVX(dsv); } #endif #endif #endif /* _P_P_PORTABILITY_H_ */ /* End of File ppport.h */ Text-CSV_XS-1.26/Makefile.PL0000644000031300001440000000651312753265122016112 0ustar00merijnusers00000000000000#!/usr/bin/perl # Copyright PROCURA B.V. (c) 2006-2016 H.Merijn Brand require 5.006001; # <- also see postamble at the bottom for META.yml use strict; use ExtUtils::MakeMaker; my %wm = ( NAME => "Text::CSV_XS", DISTNAME => "Text-CSV_XS", ABSTRACT => "Comma-Separated Values manipulation routines", AUTHOR => "H.Merijn Brand ", VERSION_FROM => "CSV_XS.pm", PREREQ_PM => { "DynaLoader" => 0, "Config" => 0, "IO::Handle" => 0, "Test::More" => 0, }, clean => { FILES => join " ", qw( CSV_XS.c.gcov CSV_XS.gcda CSV_XS.gcno CSV_XS.xs.gcov cover_db valgrind.log pod2htmd.tmp ) }, macro => { GCC_WALL => (join " " => qw( -Wall -Wextra -Wbad-function-cast -Wcomment -Wcomments -Wformat -Wdisabled-optimization -Wmissing-prototypes -Werror-implicit-function-declaration -Wmissing-noreturn -Wmissing-format-attribute -Wno-cast-qual -Wunused-value -Wno-sign-compare -Wpointer-arith -Wreturn-type -Wshadow -Wswitch-default -Wuninitialized -Wunreachable-code -Wundef )), TARFLAGS => "--format=ustar -c -v -f", "#OPTIMIZE" => "-O2 \$(GCC_WALL)", }, ); $ExtUtils::MakeMaker::VERSION > 6.30 and $wm{LICENSE} = "perl"; my $rv = WriteMakefile (%wm); 1; package MY; sub postamble { my $make_sep = $^O eq "VMS" ? "," : ""; my $valgrind = join " ", qw( PERL_DESTRUCT_LEVEL=2 PERL_DL_NONLAZY=1 valgrind --suppressions=sandbox/perl.supp --leak-check=yes --leak-resolution=high --show-reachable=yes --num-callers=50 --log-fd=3 $(FULLPERLRUN) "-MPerl::Destruct::Level=level,2" "-MExtUtils::Command::MM" "-e" "test_harness($(TEST_VERBOSE), '$(INST_LIB)', '$(INST_ARCHLIB)')" $(TEST_FILES) 3>valgrind.log ); my $min_vsn = ($] >= 5.010 && -d "xt" && -d "tmp" && ($ENV{AUTOMATED_TESTING} || 0) != 1) ? join "\n" => 'test ::', ' -@env TEST_FILES="xt/*.t" make -e test_dynamic', '' : ""; my $no_inc = join " " => map { "-ignore $_" } grep { -s $_ } map { "$_/CORE/inline.h" } @INC; join "\n" => 'cover $make_sep test_cover:', ' ccache -C', ' -@rm -f *.gc??', ' cover -test', " cover -report html_basic $no_inc", '', 'leakrun:', ' env HARNESS_PERL=sandbox/leakperl make test', ' -@tail -14 valgrind.log', '', 'leakcheck:', " $valgrind", ' -@tail -14 valgrind.log', '', 'leaktest:', q{ sandbox/leaktest $(FULLPERLRUN) "test_harness($(TEST_VERBOSE), '$(INST_LIB)', '$(INST_ARCHLIB)')" $(TEST_FILES)}, '', 'leaktrace:', q{ sandbox/leaktrace $(FULLPERLRUN) "test_harness($(TEST_VERBOSE), '$(INST_LIB)', '$(INST_ARCHLIB)')" $(TEST_FILES)}, '', 'spellcheck:', ' pod-spell-check --aspell --ispell', '', 'checkmeta: spellcheck', ' perl sandbox/genPPPort_h.pl', ' perl sandbox/genMETA.pl -c', '', 'fixmeta: distmeta', ' perl sandbox/genMETA.pl', '', 'tgzdist: checkmeta fixmeta $(DISTVNAME).tar.gz distcheck', ' -@mv -f $(DISTVNAME).tar.gz $(DISTVNAME).tgz', ' -@cpants_lint.pl $(DISTVNAME).tgz', ' -@rm -f Debian_CPANTS.txt', ' -@echo "Consider running sandbox/used-by.pl now"', '', 'test_speed: pure_all', ' PERL_DL_NONLAZY=1 $(FULLPERLRUN) -I"$(INST_LIB)" -I"$(INST_ARCHLIB)" examples/speed.pl', '', 'test_used: test', ' prove -vwb sandbox/used-by.pl', '', $min_vsn; } # postamble Text-CSV_XS-1.26/CONTRIBUTING.md0000644000031300001440000000141712753265122016367 0ustar00merijnusers00000000000000# General I am always open to improvements and suggestions. Use [issues](https://github.com/Tux/Text-CSV_XS/issues) # Style I will never accept pull request that do not strictly conform to my style, however you might hate it. You can read the reasoning behind my [preferences](http://tux.nl/style.html). I really do not care about mixed spaces and tabs in (leading) whitespace Perl::Tidy will help getting the code in shape, but as all software, it is not perfect. You can find my preferences for these in [.perltidy](https://github.com/Tux/Release-Checklist/blob/master/.perltidyrc) and [.perlcritic](https://github.com/Tux/Release-Checklist/blob/master/.perlcriticrc). # Requirements The minimum version required to use this module is stated in [Makefile.PL](./Makefile.PL) Text-CSV_XS-1.26/CSV_XS.xs0000644000031300001440000014703513002677013015560 0ustar00merijnusers00000000000000/* Copyright (c) 2007-2016 H.Merijn Brand. All rights reserved. * Copyright (c) 1998-2001 Jochen Wiedmann. All rights reserved. * This program is free software; you can redistribute it and/or * modify it under the same terms as Perl itself. */ #define PERL_NO_GET_CONTEXT #include #include #include #define DPPP_PL_parser_NO_DUMMY #define NEED_my_snprintf #define NEED_pv_escape #define NEED_pv_pretty #ifndef PERLIO_F_UTF8 # define PERLIO_F_UTF8 0x00008000 # endif #ifndef MAXINT # define MAXINT ((int)(~(unsigned)0 >> 1)) # endif #include "ppport.h" #define is_utf8_sv(s) is_utf8_string ((U8 *)SvPV_nolen (s), SvCUR (s)) #define MAINT_DEBUG 0 #define BUFFER_SIZE 1024 #define CSV_XS_TYPE_PV 0 #define CSV_XS_TYPE_IV 1 #define CSV_XS_TYPE_NV 2 /* maximum length for EOL, SEP, and QUOTE - keep in sync with .pm */ #define MAX_ATTR_LEN 16 #define CSV_FLAGS_QUO 0x0001 #define CSV_FLAGS_BIN 0x0002 #define CSV_FLAGS_EIF 0x0004 #define CSV_FLAGS_MIS 0x0010 #define HOOK_ERROR 0x0001 #define HOOK_AFTER_PARSE 0x0002 #define HOOK_BEFORE_PRINT 0x0004 #define CH_TAB '\011' #define CH_NL '\012' #define CH_CR '\015' #define CH_SPACE '\040' #define CH_DEL '\177' #define CH_EOLX 1215 #define CH_EOL *csv->eol #define CH_SEPX 8888 #define CH_SEP *csv->sep #define CH_QUOTEX 8889 #define CH_QUOTE *csv->quo #define useIO_EOF 0x10 #define unless(expr) if (!(expr)) #define _is_arrayref(f) ( f && \ (SvROK (f) || (SvRMAGICAL (f) && (mg_get (f), 1) && SvROK (f))) && \ SvOK (f) && SvTYPE (SvRV (f)) == SVt_PVAV ) #define _is_hashref(f) ( f && \ (SvROK (f) || (SvRMAGICAL (f) && (mg_get (f), 1) && SvROK (f))) && \ SvOK (f) && SvTYPE (SvRV (f)) == SVt_PVHV ) #define _is_coderef(f) ( f && \ (SvROK (f) || (SvRMAGICAL (f) && (mg_get (f), 1) && SvROK (f))) && \ SvOK (f) && SvTYPE (SvRV (f)) == SVt_PVCV ) #define CSV_XS_SELF \ if (!self || !SvOK (self) || !SvROK (self) || \ SvTYPE (SvRV (self)) != SVt_PVHV) \ croak ("self is not a hash ref"); \ hv = (HV *)SvRV (self) /* Keep in sync with .pm! */ #define CACHE_ID_quote_char 0 #define CACHE_ID_escape_char 1 #define CACHE_ID_sep_char 2 #define CACHE_ID_binary 3 #define CACHE_ID_keep_meta_info 4 #define CACHE_ID_always_quote 5 #define CACHE_ID_allow_loose_quotes 6 #define CACHE_ID_allow_loose_escapes 7 #define CACHE_ID_allow_unquoted_escape 8 #define CACHE_ID_allow_whitespace 9 #define CACHE_ID_blank_is_undef 10 #define CACHE_ID_sep 39 #define CACHE_ID_sep_len 38 #define CACHE_ID_eol 11 #define CACHE_ID_eol_len 12 #define CACHE_ID_eol_is_cr 13 #define CACHE_ID_quo 15 #define CACHE_ID_quo_len 16 #define CACHE_ID_verbatim 22 #define CACHE_ID_empty_is_undef 23 #define CACHE_ID_auto_diag 24 #define CACHE_ID_quote_space 25 #define CACHE_ID_quote_empty 37 #define CACHE_ID__is_bound 26 #define CACHE_ID__has_ahead 30 #define CACHE_ID_escape_null 31 #define CACHE_ID_quote_binary 32 #define CACHE_ID_diag_verbose 33 #define CACHE_ID_has_error_input 34 #define CACHE_ID_decode_utf8 35 #define CACHE_ID__has_hooks 36 #define byte unsigned char #define ulng unsigned long typedef struct { byte quote_char; byte escape_char; byte fld_idx; byte binary; byte keep_meta_info; byte always_quote; byte useIO; /* Also used to indicate EOF */ byte eol_is_cr; byte allow_loose_quotes; byte allow_loose_escapes; byte allow_unquoted_escape; byte allow_whitespace; byte blank_is_undef; byte empty_is_undef; byte verbatim; byte auto_diag; byte quote_space; byte escape_null; byte quote_binary; byte first_safe_char; byte diag_verbose; byte has_error_input; byte decode_utf8; byte has_hooks; byte quote_empty; long is_bound; ulng recno; byte * cache; SV * pself; HV * self; SV * bound; char * types; byte eol_len; byte sep_len; byte quo_len; byte types_len; char * bptr; SV * tmp; int utf8; byte has_ahead; byte eolx; int eol_pos; STRLEN size; STRLEN used; byte eol[MAX_ATTR_LEN]; byte sep[MAX_ATTR_LEN]; byte quo[MAX_ATTR_LEN]; char buffer[BUFFER_SIZE]; } csv_t; #define bool_opt_def(o,d) \ (((svp = hv_fetchs (self, o, FALSE)) && *svp) ? SvTRUE (*svp) : d) #define bool_opt(o) bool_opt_def (o, 0) #define num_opt_def(o,d) \ (((svp = hv_fetchs (self, o, FALSE)) && *svp) ? SvIV (*svp) : d) #define num_opt(o) num_opt_def (o, 0) typedef struct { int xs_errno; char *xs_errstr; } xs_error_t; static const xs_error_t xs_errors[] = { /* Generic errors */ { 1000, "INI - constructor failed" }, { 1001, "INI - sep_char is equal to quote_char or escape_char" }, { 1002, "INI - allow_whitespace with escape_char or quote_char SP or TAB" }, { 1003, "INI - \r or \n in main attr not allowed" }, { 1004, "INI - callbacks should be undef or a hashref" }, { 1005, "INI - EOL too long" }, { 1006, "INI - SEP too long" }, { 1007, "INI - QUOTE too long" }, { 1010, "INI - the header is empty" }, { 1011, "INI - the header contains more than one valid separator" }, { 1012, "INI - the header contains an empty field" }, { 1013, "INI - the header contains nun-unique fields" }, /* Parse errors */ { 2010, "ECR - QUO char inside quotes followed by CR not part of EOL" }, { 2011, "ECR - Characters after end of quoted field" }, { 2012, "EOF - End of data in parsing input stream" }, { 2013, "ESP - Specification error for fragments RFC7111" }, /* EIQ - Error Inside Quotes */ { 2021, "EIQ - NL char inside quotes, binary off" }, { 2022, "EIQ - CR char inside quotes, binary off" }, { 2023, "EIQ - QUO character not allowed" }, { 2024, "EIQ - EOF cannot be escaped, not even inside quotes" }, { 2025, "EIQ - Loose unescaped escape" }, { 2026, "EIQ - Binary character inside quoted field, binary off" }, { 2027, "EIQ - Quoted field not terminated" }, /* EIF - Error Inside Field */ { 2030, "EIF - NL char inside unquoted verbatim, binary off" }, { 2031, "EIF - CR char is first char of field, not part of EOL" }, { 2032, "EIF - CR char inside unquoted, not part of EOL" }, { 2034, "EIF - Loose unescaped quote" }, { 2035, "EIF - Escaped EOF in unquoted field" }, { 2036, "EIF - ESC error" }, { 2037, "EIF - Binary character in unquoted field, binary off" }, /* Combine errors */ { 2110, "ECB - Binary character in Combine, binary off" }, /* IO errors */ { 2200, "EIO - print to IO failed. See errno" }, /* Hash-Ref errors */ { 3001, "EHR - Unsupported syntax for column_names ()" }, { 3002, "EHR - getline_hr () called before column_names ()" }, { 3003, "EHR - bind_columns () and column_names () fields count mismatch" }, { 3004, "EHR - bind_columns () only accepts refs to scalars" }, { 3006, "EHR - bind_columns () did not pass enough refs for parsed fields" }, { 3007, "EHR - bind_columns needs refs to writable scalars" }, { 3008, "EHR - unexpected error in bound fields" }, { 3009, "EHR - print_hr () called before column_names ()" }, { 3010, "EHR - print_hr () called with invalid arguments" }, { 0, "" }, }; static int io_handle_loaded = 0; static SV *m_getline, *m_print, *m_read; static int last_error = 0; #define is_EOL(c) (c == CH_EOLX) #define __is_SEPX(c) (c == CH_SEP && (csv->sep_len == 0 || (\ csv->size - csv->used >= csv->sep_len - 1 &&\ !memcmp (csv->bptr + csv->used, csv->sep + 1, csv->sep_len - 1) &&\ (csv->used += csv->sep_len - 1) &&\ (c = CH_SEPX)))) #if MAINT_DEBUG > 1 static byte _is_SEPX (unsigned int *c, csv_t *csv, int line) { unsigned int b = __is_SEPX (*c); (void)fprintf (stderr, "# %4d - is_SEPX:\t%d (%d)\n", line, b, csv->sep_len); if (csv->sep_len) (void)fprintf (stderr, "# len: %d, siz: %d, usd: %d, c: %03x, *sep: %03x\n", csv->sep_len, csv->size, csv->used, *c, CH_SEP); return b; } /* _is_SEPX */ #define is_SEP(c) _is_SEPX (&c, csv, __LINE__) #else #define is_SEP(c) __is_SEPX (c) #endif #define __is_QUOTEX(c) (CH_QUOTE && c == CH_QUOTE && (csv->quo_len == 0 || (\ csv->size - csv->used >= csv->quo_len - 1 &&\ !memcmp (csv->bptr + csv->used, csv->quo + 1, csv->quo_len - 1) &&\ (csv->used += csv->quo_len - 1) &&\ (c = CH_QUOTEX)))) #if MAINT_DEBUG > 1 static byte _is_QUOTEX (unsigned int *c, csv_t *csv, int line) { unsigned int b = __is_QUOTEX (*c); (void)fprintf (stderr, "# %4d - is_QUOTEX:\t%d (%d)\n", line, b, csv->quo_len); if (csv->quo_len) (void)fprintf (stderr, "# len: %d, siz: %d, usd: %d, c: %03x, *quo: %03x\n", csv->quo_len, csv->size, csv->used, *c, CH_QUOTE); return b; } /* _is_QUOTEX */ #define is_QUOTE(c) _is_QUOTEX (&c, csv, __LINE__) #else #define is_QUOTE(c) __is_QUOTEX (c) #endif #define require_IO_Handle \ unless (io_handle_loaded) {\ ENTER;\ Perl_load_module (aTHX_ PERL_LOADMOD_NOIMPORT,\ newSVpvs ("IO::Handle"), NULL, NULL, NULL);\ LEAVE;\ io_handle_loaded = 1;\ } #define is_whitespace(ch) \ ( (ch) != CH_SEP && \ (ch) != CH_QUOTE && \ (ch) != csv->escape_char && \ ( (ch) == CH_SPACE || \ (ch) == CH_TAB \ ) \ ) #define SvDiag(xse) cx_SvDiag (aTHX_ xse) static SV *cx_SvDiag (pTHX_ int xse) { int i = 0; SV *err; while (xs_errors[i].xs_errno && xs_errors[i].xs_errno != xse) i++; if ((err = newSVpv (xs_errors[i].xs_errstr, 0))) { (void)SvUPGRADE (err, SVt_PVIV); SvIV_set (err, xse); SvIOK_on (err); } return (err); } /* SvDiag */ #define SetDiag(csv,xse) cx_SetDiag (aTHX_ csv, xse) static SV *cx_SetDiag (pTHX_ csv_t *csv, int xse) { dSP; SV *err = SvDiag (xse); last_error = xse; (void)hv_store (csv->self, "_ERROR_DIAG", 11, err, 0); if (xse == 0) { (void)hv_store (csv->self, "_ERROR_POS", 10, newSViv (0), 0); (void)hv_store (csv->self, "_ERROR_FLD", 10, newSViv (0), 0); (void)hv_store (csv->self, "_ERROR_INPUT", 12, &PL_sv_undef, 0); csv->has_error_input = 0; } if (xse == 2012) /* EOF */ (void)hv_store (csv->self, "_EOF", 4, &PL_sv_yes, 0); if (csv->pself && csv->auto_diag) { ENTER; SAVETMPS; PUSHMARK (SP); XPUSHs (csv->pself); PUTBACK; call_pv ("Text::CSV_XS::error_diag", G_VOID | G_DISCARD); FREETMPS; LEAVE; } return (err); } /* SetDiag */ #define xs_cache_set(hv,idx,val) cx_xs_cache_set (aTHX_ hv, idx, val) static void cx_xs_cache_set (pTHX_ HV *hv, int idx, SV *val) { SV **svp; byte *cache; csv_t csvs; csv_t *csv = &csvs; IV iv; char *cp = "\0"; STRLEN len = 0; unless ((svp = hv_fetchs (hv, "_CACHE", FALSE)) && *svp) return; cache = (byte *)SvPV_nolen (*svp); memcpy (csv, cache, sizeof (csv_t)); if (SvPOK (val)) cp = SvPV (val, len); if (SvIOK (val)) iv = SvIV (val); else if (SvNOK (val)) /* Needed for 5.6.x but safe for 5.8.x+ */ iv = (IV)SvNV (val); /* uncoverable statement ancient perl required */ else iv = *cp; switch (idx) { /* single char/byte */ case CACHE_ID_sep_char: CH_SEP = *cp; csv->sep_len = 0; break; case CACHE_ID_quote_char: CH_QUOTE = *cp; csv->quo_len = 0; break; case CACHE_ID_escape_char: csv->escape_char = *cp; break; /* boolean/numeric */ case CACHE_ID_binary: csv->binary = iv; break; case CACHE_ID_keep_meta_info: csv->keep_meta_info = iv; break; case CACHE_ID_always_quote: csv->always_quote = iv; break; case CACHE_ID_quote_empty: csv->quote_empty = iv; break; case CACHE_ID_quote_space: csv->quote_space = iv; break; case CACHE_ID_escape_null: csv->escape_null = iv; break; case CACHE_ID_quote_binary: csv->quote_binary = iv; break; case CACHE_ID_decode_utf8: csv->decode_utf8 = iv; break; case CACHE_ID_allow_loose_escapes: csv->allow_loose_escapes = iv; break; case CACHE_ID_allow_loose_quotes: csv->allow_loose_quotes = iv; break; case CACHE_ID_allow_unquoted_escape: csv->allow_unquoted_escape = iv; break; case CACHE_ID_allow_whitespace: csv->allow_whitespace = iv; break; case CACHE_ID_blank_is_undef: csv->blank_is_undef = iv; break; case CACHE_ID_empty_is_undef: csv->empty_is_undef = iv; break; case CACHE_ID_verbatim: csv->verbatim = iv; break; case CACHE_ID_auto_diag: csv->auto_diag = iv; break; case CACHE_ID_diag_verbose: csv->diag_verbose = iv; break; case CACHE_ID__has_hooks: csv->has_hooks = iv; break; case CACHE_ID_has_error_input: csv->has_error_input = iv; break; /* a 4-byte IV */ case CACHE_ID__is_bound: csv->is_bound = iv; break; /* string */ case CACHE_ID_sep: memcpy (csv->sep, cp, len); csv->sep_len = len == 1 ? 0 : len; break; case CACHE_ID_quo: memcpy (csv->quo, cp, len); csv->quo_len = len == 1 ? 0 : len; break; case CACHE_ID_eol: memcpy (csv->eol, cp, len); csv->eol_len = len; csv->eol_is_cr = len == 1 && *cp == CH_CR ? 1 : 0; break; default: warn ("Unknown cache index %d ignored\n", idx); } csv->cache = cache; memcpy (cache, csv, sizeof (csv_t)); } /* cache_set */ #define _pretty_str(csv,xse) cx_pretty_str (aTHX_ csv, xse) static char *cx_pretty_str (pTHX_ byte *s, STRLEN l) { SV *dsv = sv_2mortal (newSVpvs ("")); return (pv_pretty (dsv, (char *)s, l, 0, NULL, NULL, (PERL_PV_PRETTY_DUMP | PERL_PV_ESCAPE_UNI_DETECT))); } /* _pretty_str */ #define _cache_show_byte(trim,c) \ warn (" %-21s %02x:%3d\n", trim, c, c) #define _cache_show_char(trim,c) \ warn (" %-21s %02x:%s\n", trim, c, _pretty_str (&c, 1)) #define _cache_show_str(trim,l,str) \ warn (" %-21s %02d:%s\n", trim, l, _pretty_str (str, l)) #define xs_cache_diag(hv) cx_xs_cache_diag (aTHX_ hv) static void cx_xs_cache_diag (pTHX_ HV *hv) { SV **svp; byte *cache; csv_t csvs; csv_t *csv = &csvs; unless ((svp = hv_fetchs (hv, "_CACHE", FALSE)) && *svp) { warn ("CACHE: invalid\n"); return; } cache = (byte *)SvPV_nolen (*svp); memcpy (csv, cache, sizeof (csv_t)); warn ("CACHE:\n"); _cache_show_char ("quote_char", CH_QUOTE); _cache_show_char ("escape_char", csv->escape_char); _cache_show_char ("sep_char", CH_SEP); _cache_show_byte ("binary", csv->binary); _cache_show_byte ("decode_utf8", csv->decode_utf8); _cache_show_byte ("allow_loose_escapes", csv->allow_loose_escapes); _cache_show_byte ("allow_loose_quotes", csv->allow_loose_quotes); _cache_show_byte ("allow_unquoted_escape", csv->allow_unquoted_escape); _cache_show_byte ("allow_whitespace", csv->allow_whitespace); _cache_show_byte ("always_quote", csv->always_quote); _cache_show_byte ("quote_empty", csv->quote_empty); _cache_show_byte ("quote_space", csv->quote_space); _cache_show_byte ("escape_null", csv->escape_null); _cache_show_byte ("quote_binary", csv->quote_binary); _cache_show_byte ("auto_diag", csv->auto_diag); _cache_show_byte ("diag_verbose", csv->diag_verbose); _cache_show_byte ("has_error_input", csv->has_error_input); _cache_show_byte ("blank_is_undef", csv->blank_is_undef); _cache_show_byte ("empty_is_undef", csv->empty_is_undef); _cache_show_byte ("has_ahead", csv->has_ahead); _cache_show_byte ("keep_meta_info", csv->keep_meta_info); _cache_show_byte ("verbatim", csv->verbatim); _cache_show_byte ("has_hooks", csv->has_hooks); _cache_show_byte ("eol_is_cr", csv->eol_is_cr); _cache_show_byte ("eol_len", csv->eol_len); _cache_show_str ("eol", csv->eol_len, csv->eol); _cache_show_byte ("sep_len", csv->sep_len); if (csv->sep_len > 1) _cache_show_str ("sep", csv->sep_len, csv->sep); _cache_show_byte ("quo_len", csv->quo_len); if (csv->quo_len > 1) _cache_show_str ("quote", csv->quo_len, csv->quo); } /* xs_cache_diag */ #define set_eol_is_cr(csv) cx_set_eol_is_cr (aTHX_ csv) static void cx_set_eol_is_cr (pTHX_ csv_t *csv) { csv->eol[0] = CH_CR; csv->eol_is_cr = 1; csv->eol_len = 1; memcpy (csv->cache, csv, sizeof (csv_t)); (void)hv_store (csv->self, "eol", 3, newSVpvn ((char *)csv->eol, 1), 0); } /* set_eol_is_cr */ #define SetupCsv(csv,self,pself) cx_SetupCsv (aTHX_ csv, self, pself) static void cx_SetupCsv (pTHX_ csv_t *csv, HV *self, SV *pself) { SV **svp; STRLEN len; char *ptr; last_error = 0; if ((svp = hv_fetchs (self, "_CACHE", FALSE)) && *svp) { byte *cache = (byte *)SvPVX (*svp); memcpy (csv, cache, sizeof (csv_t)); } else { SV *sv_cache; memset (csv, 0, sizeof (csv_t)); /* Reset everything */ csv->self = self; csv->pself = pself; CH_SEP = ','; if ((svp = hv_fetchs (self, "sep_char", FALSE)) && *svp && SvOK (*svp)) CH_SEP = *SvPV (*svp, len); if ((svp = hv_fetchs (self, "sep", FALSE)) && *svp && SvOK (*svp)) { ptr = SvPV (*svp, len); memcpy (csv->sep, ptr, len); if (len > 1) csv->sep_len = len; } CH_QUOTE = '"'; if ((svp = hv_fetchs (self, "quote_char", FALSE)) && *svp) { if (SvOK (*svp)) { ptr = SvPV (*svp, len); CH_QUOTE = len ? *ptr : (char)0; } else CH_QUOTE = (char)0; } if ((svp = hv_fetchs (self, "quote", FALSE)) && *svp && SvOK (*svp)) { ptr = SvPV (*svp, len); memcpy (csv->quo, ptr, len); if (len > 1) csv->quo_len = len; } csv->escape_char = '"'; if ((svp = hv_fetchs (self, "escape_char", FALSE)) && *svp) { if (SvOK (*svp)) { ptr = SvPV (*svp, len); csv->escape_char = len ? *ptr : (char)0; } else csv->escape_char = (char)0; } if ((svp = hv_fetchs (self, "eol", FALSE)) && *svp && SvOK (*svp)) { char *eol = SvPV (*svp, len); memcpy (csv->eol, eol, len); csv->eol_len = len; if (len == 1 && *csv->eol == CH_CR) csv->eol_is_cr = 1; } if ((svp = hv_fetchs (self, "_types", FALSE)) && *svp && SvOK (*svp)) { csv->types = SvPV (*svp, len); csv->types_len = len; } if ((svp = hv_fetchs (self, "_is_bound", FALSE)) && *svp && SvOK (*svp)) csv->is_bound = SvIV(*svp); if ((svp = hv_fetchs (self, "callbacks", FALSE)) && _is_hashref (*svp)) { HV *cb = (HV *)SvRV (*svp); if ((svp = hv_fetchs (cb, "after_parse", FALSE)) && _is_coderef (*svp)) csv->has_hooks |= HOOK_AFTER_PARSE; if ((svp = hv_fetchs (cb, "before_print", FALSE)) && _is_coderef (*svp)) csv->has_hooks |= HOOK_BEFORE_PRINT; } csv->binary = bool_opt ("binary"); csv->decode_utf8 = bool_opt ("decode_utf8"); csv->always_quote = bool_opt ("always_quote"); csv->quote_empty = bool_opt ("quote_empty"); csv->quote_space = bool_opt_def ("quote_space", 1); csv->escape_null = bool_opt_def ("escape_null", 1); csv->quote_binary = bool_opt_def ("quote_binary", 1); csv->allow_loose_quotes = bool_opt ("allow_loose_quotes"); csv->allow_loose_escapes = bool_opt ("allow_loose_escapes"); csv->allow_unquoted_escape = bool_opt ("allow_unquoted_escape"); csv->allow_whitespace = bool_opt ("allow_whitespace"); csv->blank_is_undef = bool_opt ("blank_is_undef"); csv->empty_is_undef = bool_opt ("empty_is_undef"); csv->verbatim = bool_opt ("verbatim"); csv->auto_diag = num_opt ("auto_diag"); csv->diag_verbose = num_opt ("diag_verbose"); csv->keep_meta_info = num_opt ("keep_meta_info"); sv_cache = newSVpvn ((char *)csv, sizeof (csv_t)); csv->cache = (byte *)SvPVX (sv_cache); SvREADONLY_on (sv_cache); memcpy (csv->cache, csv, sizeof (csv_t)); (void)hv_store (self, "_CACHE", 6, sv_cache, 0); } csv->utf8 = 0; csv->size = 0; csv->used = 0; csv->first_safe_char = csv->quote_space ? 0x21 : 0x20; if (csv->is_bound) { if ((svp = hv_fetchs (self, "_BOUND_COLUMNS", FALSE)) && _is_arrayref (*svp)) csv->bound = *svp; else csv->is_bound = 0; } csv->eol_pos = -1; csv->eolx = csv->eol_len ? csv->verbatim || csv->eol_len >= 2 ? 1 : csv->eol[0] == CH_CR || csv->eol[0] == CH_NL ? 0 : 1 : 0; if (csv->sep_len && is_utf8_string ((U8 *)(csv->sep), csv->sep_len)) csv->utf8 = 1; if (csv->quo_len && is_utf8_string ((U8 *)(csv->quo), csv->quo_len)) csv->utf8 = 1; } /* SetupCsv */ #define Print(csv,dst) cx_Print (aTHX_ csv, dst) static int cx_Print (pTHX_ csv_t *csv, SV *dst) { int result; int keep = 0; if (csv->useIO) { SV *tmp = sv_2mortal (newSVpvn (csv->buffer, csv->used)); dSP; require_IO_Handle; PUSHMARK (sp); EXTEND (sp, 2); PUSHs ((dst)); if (csv->utf8) { STRLEN len; char *ptr; int j; ptr = SvPV (tmp, len); while (len > 0 && !is_utf8_sv (tmp) && keep < 16) { ptr[--len] = (char)0; SvCUR_set (tmp, len); keep++; } for (j = 0; j < keep; j++) csv->buffer[j] = csv->buffer[csv->used - keep + j]; SvUTF8_on (tmp); } PUSHs (tmp); PUTBACK; result = call_sv (m_print, G_SCALAR | G_METHOD); SPAGAIN; if (result) { result = POPi; unless (result) (void)SetDiag (csv, 2200); } PUTBACK; } else { sv_catpvn (SvRV (dst), csv->buffer, csv->used); result = TRUE; } if (csv->utf8 && !csv->useIO && csv->decode_utf8 && SvROK (dst) && is_utf8_sv (SvRV (dst))) SvUTF8_on (SvRV (dst)); csv->used = keep; return result; } /* Print */ #define CSV_PUT(csv,dst,c) { \ if ((csv)->used == sizeof ((csv)->buffer) - 1) { \ unless (Print ((csv), (dst))) \ return FALSE; \ } \ (csv)->buffer[(csv)->used++] = (c); \ } #define bound_field(csv,i,keep) cx_bound_field (aTHX_ csv, i, keep) static SV *cx_bound_field (pTHX_ csv_t *csv, int i, int keep) { SV *sv = csv->bound; AV *av; /* fprintf (stderr, "# New bind %d/%d\n", i, csv->is_bound);\ */ if (i >= csv->is_bound) { (void)SetDiag (csv, 3006); return (NULL); } if (sv && SvROK (sv)) { av = (AV *)(SvRV (sv)); /* fprintf (stderr, "# Bind %d/%d/%d\n", i, csv->is_bound, av_len (av)); */ sv = *av_fetch (av, i, FALSE); if (sv && SvROK (sv)) { sv = SvRV (sv); if (keep) return (sv); unless (SvREADONLY (sv)) { sv_setpvn (sv, "", 0); return (sv); } } } (void)SetDiag (csv, 3008); return (NULL); } /* bound_field */ static int was_quoted (pTHX_ AV *mf, int idx) { SV **x = av_fetch (mf, idx, FALSE); return (x && SvIOK (*x) && SvIV (*x) & CSV_FLAGS_QUO ? 1 : 0); } /* was_quoted */ /* Should be extended for EBCDIC ? */ #define is_csv_binary(ch) ((ch < CH_SPACE || ch >= CH_DEL) && ch != CH_TAB) #define Combine(csv,dst,fields) cx_Combine (aTHX_ csv, dst, fields) static int cx_Combine (pTHX_ csv_t *csv, SV *dst, AV *fields) { int i, n, bound = 0; int aq = (int)csv->always_quote; int qe = (int)csv->quote_empty; int kmi = (int)csv->keep_meta_info; AV *qm = NULL; n = av_len (fields); if (n < 0 && csv->is_bound) { n = csv->is_bound - 1; bound = 1; } if (kmi >= 10) { SV **svp; if ((svp = hv_fetchs (csv->self, "_FFLAGS", FALSE)) && _is_arrayref (*svp)) { AV *avp = (AV *)SvRV (*svp); if (avp && av_len (avp) >= n) qm = avp; } } for (i = 0; i <= n; i++) { SV *sv; if (i > 0) { CSV_PUT (csv, dst, CH_SEP); if (csv->sep_len) { int x; for (x = 1; x < (int)csv->sep_len; x++) CSV_PUT (csv, dst, csv->sep[x]); } } if (bound) sv = bound_field (csv, i, 1); else { SV **svp = av_fetch (fields, i, 0); sv = svp && *svp ? *svp : NULL; } if (sv) { STRLEN len; char *ptr; int quoteMe; unless ((SvOK (sv) || ( (SvGMAGICAL (sv) && (mg_get (sv), 1) && SvOK (sv))) )) continue; ptr = SvPV (sv, len); if (len == 0) quoteMe = aq ? 1 : qe ? 1 : qm ? was_quoted (aTHX_ qm, i) : 0; else { if (SvUTF8 (sv)) { csv->utf8 = 1; csv->binary = 1; } quoteMe = aq ? 1 : qm ? was_quoted (aTHX_ qm, i) : 0; /* Do we need quoting? We do quote, if the user requested * (always_quote), if binary or blank characters are found * and if the string contains quote or escape characters. */ if (!quoteMe && ( quoteMe = (!SvIOK (sv) && !SvNOK (sv) && CH_QUOTE))) { char *ptr2; STRLEN l; for (ptr2 = ptr, l = len; l; ++ptr2, --l) { byte c = *ptr2; if ((CH_QUOTE && c == CH_QUOTE) || (CH_SEP && c == CH_SEP) || (csv->escape_char && c == csv->escape_char) || (csv->quote_binary ? (c >= 0x7f && c <= 0xa0) || c < csv->first_safe_char : c == CH_NL || c == CH_CR || (csv->quote_space && ( c == CH_SPACE || c == CH_TAB)))) { /* Binary character */ break; } } quoteMe = (l > 0); } } if (quoteMe) { CSV_PUT (csv, dst, CH_QUOTE); if (csv->quo_len) { int x; for (x = 1; x < (int)csv->quo_len; x++) CSV_PUT (csv, dst, csv->quo[x]); } } while (len-- > 0) { char c = *ptr++; int e = 0; if (!csv->binary && is_csv_binary (c)) { SvREFCNT_inc (sv); csv->has_error_input = 1; unless (hv_store (csv->self, "_ERROR_INPUT", 12, sv, 0)) SvREFCNT_dec (sv); /* uncoverable statement memory fail */ (void)SetDiag (csv, 2110); return FALSE; } if (CH_QUOTE && (byte)c == CH_QUOTE && (csv->quo_len == 0 || memcmp (ptr, csv->quo +1, csv->quo_len - 1) == 0)) e = 1; else if (c == csv->escape_char && csv->escape_char) e = 1; else if (c == (char)0 && csv->escape_null) { e = 1; c = '0'; } if (e && csv->escape_char) CSV_PUT (csv, dst, csv->escape_char); CSV_PUT (csv, dst, c); } if (quoteMe) { CSV_PUT (csv, dst, CH_QUOTE); if (csv->quo_len) { int x; for (x = 1; x < (int)csv->quo_len; x++) CSV_PUT (csv, dst, csv->quo[x]); } } } } if (csv->eol_len) { STRLEN len = csv->eol_len; byte *ptr = csv->eol; while (len--) CSV_PUT (csv, dst, *ptr++); } if (csv->used) return Print (csv, dst); return TRUE; } /* Combine */ #define ParseError(csv,xse,pos) cx_ParseError (aTHX_ csv, xse, pos) static void cx_ParseError (pTHX_ csv_t *csv, int xse, int pos) { (void)hv_store (csv->self, "_ERROR_POS", 10, newSViv (pos), 0); (void)hv_store (csv->self, "_ERROR_FLD", 10, newSViv (csv->fld_idx), 0); if (csv->tmp) { csv->has_error_input = 1; if (hv_store (csv->self, "_ERROR_INPUT", 12, csv->tmp, 0)) SvREFCNT_inc (csv->tmp); } (void)SetDiag (csv, xse); } /* ParseError */ #define CsvGet(csv,src) cx_CsvGet (aTHX_ csv, src) static int cx_CsvGet (pTHX_ csv_t *csv, SV *src) { unless (csv->useIO) return EOF; if (csv->tmp && csv->eol_pos >= 0) { csv->eol_pos = -2; sv_setpvn (csv->tmp, (char *)csv->eol, csv->eol_len); csv->bptr = SvPV (csv->tmp, csv->size); csv->used = 0; return CH_EOLX; } { STRLEN result; dSP; require_IO_Handle; PUSHMARK (sp); EXTEND (sp, 1); PUSHs (src); PUTBACK; result = call_sv (m_getline, G_SCALAR | G_METHOD); SPAGAIN; csv->eol_pos = -1; csv->tmp = result ? POPs : NULL; PUTBACK; #if MAINT_DEBUG > 4 fprintf (stderr, "getline () returned:\n"); sv_dump (csv->tmp); #endif } if (csv->tmp && SvOK (csv->tmp)) { STRLEN tmp_len; csv->bptr = SvPV (csv->tmp, tmp_len); csv->used = 0; csv->size = tmp_len; if (csv->eolx && csv->size >= csv->eol_len) { int i, match = 1; for (i = 1; i <= (int)csv->eol_len; i++) { unless (csv->bptr[csv->size - i] == csv->eol[csv->eol_len - i]) { match = 0; break; } } if (match) { #if MAINT_DEBUG > 4 fprintf (stderr, "# EOLX match, size: %d\n", csv->size); #endif csv->size -= csv->eol_len; unless (csv->verbatim) csv->eol_pos = csv->size; csv->bptr[csv->size] = (char)0; SvCUR_set (csv->tmp, csv->size); unless (csv->verbatim || csv->size) return CH_EOLX; } } if (SvUTF8 (csv->tmp)) csv->utf8 = 1; if (tmp_len) return ((byte)csv->bptr[csv->used++]); } csv->useIO |= useIO_EOF; return EOF; } /* CsvGet */ #define ERROR_INSIDE_QUOTES(diag_code) { \ unless (csv->is_bound) SvREFCNT_dec (sv); \ ParseError (csv, diag_code, csv->used - 1); \ return FALSE; \ } #define ERROR_INSIDE_FIELD(diag_code) { \ unless (csv->is_bound) SvREFCNT_dec (sv); \ ParseError (csv, diag_code, csv->used - 1); \ return FALSE; \ } #if MAINT_DEBUG > 4 #define PUT_RPT fprintf (stderr, "# CSV_PUT @ %4d: 0x%02x '%c'\n", __LINE__, c, isprint (c) ? c : '?') #define PUT_SEPX_RPT1 fprintf (stderr, "# PUT SEPX @ %4d\n", __LINE__) #define PUT_SEPX_RPT2 fprintf (stderr, "# Done putting SEPX\n") #define PUT_QUOX_RPT1 fprintf (stderr, "# PUT QUOX @ %4d\n", __LINE__) #define PUT_QUOX_RPT2 fprintf (stderr, "# Done putting QUOX\n") #define PUT_EOLX_RPT1 fprintf (stderr, "# PUT EOLX @ %4d\n", __LINE__) #define PUT_EOLX_RPT2 fprintf (stderr, "# Done putting EOLX\n") #define PUSH_RPT fprintf (stderr, "# AV_PUSHd @ %4d\n", __LINE__); sv_dump (sv) #else #define PUT_RPT #define PUT_SEPX_RPT1 #define PUT_SEPX_RPT2 #define PUT_QUOX_RPT1 #define PUT_QUOX_RPT2 #define PUT_EOLX_RPT1 #define PUT_EOLX_RPT2 #define PUSH_RPT #endif #define CSV_PUT_SV1(c) { \ len = SvCUR ((sv)); \ SvGROW ((sv), len + 2); \ *SvEND ((sv)) = c; \ PUT_RPT; \ SvCUR_set ((sv), len + 1); \ } #define CSV_PUT_SV(c) { \ if (c == CH_EOLX) { \ int x; PUT_EOLX_RPT1; \ if (csv->eol_pos == -2) \ csv->size = 0; \ for (x = 0; x < (int)csv->eol_len; x++) \ CSV_PUT_SV1 (csv->eol[x]); \ csv->eol_pos = -1; \ PUT_EOLX_RPT2; \ } \ else if (c == CH_SEPX) { \ int x; PUT_SEPX_RPT1; \ for (x = 0; x < (int)csv->sep_len; x++) \ CSV_PUT_SV1 (csv->sep[x]); \ PUT_SEPX_RPT2; \ } \ else if (c == CH_QUOTEX) { \ int x; PUT_QUOX_RPT1; \ for (x = 0; x < (int)csv->quo_len; x++) \ CSV_PUT_SV1 (csv->quo[x]); \ PUT_QUOX_RPT2; \ } \ else \ CSV_PUT_SV1 (c); \ } #define CSV_GET1 \ (csv->used < csv->size ? (byte)csv->bptr[csv->used++] : CsvGet (csv, src)) #if MAINT_DEBUG > 3 int CSV_GET_ (pTHX_ csv_t *csv, SV *src, int l) { int c; fprintf (stderr, "# 1-CSV_GET @ %4d: (used: %d, size: %d, eol_pos: %d, eolx = %d)\n", l, csv->used, csv->size, csv->eol_pos, csv->eolx); c = CSV_GET1; fprintf (stderr, "# 2-CSV_GET @ %4d: 0x%02x '%c'\n", l, c, isprint (c) ? c : '?'); return (c); } /* CSV_GET_ */ #define CSV_GET CSV_GET_ (aTHX_ csv, src, __LINE__) #else #define CSV_GET CSV_GET1 #endif #define AV_PUSH { \ *SvEND (sv) = (char)0; \ SvUTF8_off (sv); \ if (SvCUR (sv) == 0 && ( \ csv->empty_is_undef || \ (!(f & CSV_FLAGS_QUO) && csv->blank_is_undef))) \ sv_setpvn (sv, NULL, 0); \ else { \ if (csv->allow_whitespace && ! (f & CSV_FLAGS_QUO)) \ strip_trail_whitespace (sv); \ if (f & CSV_FLAGS_BIN && csv->decode_utf8 \ && (csv->utf8 || is_utf8_sv (sv))) \ SvUTF8_on (sv); \ } \ SvSETMAGIC (sv); \ unless (csv->is_bound) av_push (fields, sv); \ PUSH_RPT; \ sv = NULL; \ if (csv->keep_meta_info && fflags) \ av_push (fflags, newSViv (f)); \ waitingForField = 1; \ } #define strip_trail_whitespace(sv) cx_strip_trail_whitespace (aTHX_ sv) static void cx_strip_trail_whitespace (pTHX_ SV *sv) { STRLEN len; char *s = SvPV (sv, len); unless (s && len) return; while (s[len - 1] == CH_SPACE || s[len - 1] == CH_TAB) s[--len] = (char)0; SvCUR_set (sv, len); } /* strip_trail_whitespace */ #define NewField \ unless (sv) { \ if (csv->is_bound) \ sv = bound_field (csv, fnum++, 0); \ else \ sv = newSVpvs (""); \ unless (sv) return FALSE; \ f = 0; csv->fld_idx++; \ } #if MAINT_DEBUG static char str_parsed[40]; #endif #if MAINT_DEBUG > 1 static char *_sep_string (csv_t *csv) { char sep[64]; if (csv->sep_len) { int x; for (x = 0; x < csv->sep_len; x++) sprintf (sep + x * x, "%02x ", csv->sep[x]); } else sprintf (sep, "'%c' (0x%02x)", CH_SEP, CH_SEP); return sep; } /* _sep_string */ #endif #define Parse(csv,src,fields,fflags) cx_Parse (aTHX_ csv, src, fields, fflags) static int cx_Parse (pTHX_ csv_t *csv, SV *src, AV *fields, AV *fflags) { int c, f = 0; int waitingForField = 1; SV *sv = NULL; STRLEN len; int seenSomething = FALSE; int fnum = 0; int spl = -1; #if MAINT_DEBUG memset (str_parsed, 0, 40); #endif csv->fld_idx = 0; while ((c = CSV_GET) != EOF) { NewField; seenSomething = TRUE; spl++; #if MAINT_DEBUG if (spl < 39) str_parsed[spl] = c; #endif restart: if (is_SEP (c)) { #if MAINT_DEBUG > 1 fprintf (stderr, "# %d/%d/%03x pos %d = SEP %s\t'%s'\n", waitingForField ? 1 : 0, sv ? 1 : 0, f, spl, _sep_string (csv), csv->bptr + csv->used); #endif if (waitingForField) { /* ,1,"foo, 3",,bar, * ^ ^ */ if (csv->blank_is_undef || csv->empty_is_undef) sv_setpvn (sv, NULL, 0); else sv_setpvn (sv, "", 0); unless (csv->is_bound) av_push (fields, sv); sv = NULL; if (csv->keep_meta_info && fflags) av_push (fflags, newSViv (f)); } else if (f & CSV_FLAGS_QUO) { /* ,1,"foo, 3",,bar, * ^ */ CSV_PUT_SV (c) } else { /* ,1,"foo, 3",,bar, * ^ ^ ^ */ AV_PUSH; } } /* SEP char */ else if (is_QUOTE (c)) { #if MAINT_DEBUG > 1 fprintf (stderr, "# %d/%d/%03x pos %d = QUO '%c'\t\t'%s'\n", waitingForField ? 1 : 0, sv ? 1 : 0, f, spl, c, csv->bptr + csv->used); #endif if (waitingForField) { /* ,1,"foo, 3",,bar,\r\n * ^ */ f |= CSV_FLAGS_QUO; waitingForField = 0; continue; } if (f & CSV_FLAGS_QUO) { /* ,1,"foo, 3",,bar,\r\n * ^ */ int quoesc = 0; int c2 = CSV_GET; if (csv->allow_whitespace) { /* , 1 , "foo, 3" , , bar , \r\n * ^ */ while (is_whitespace (c2)) { if (csv->allow_loose_quotes && !(csv->escape_char && c2 == csv->escape_char)) { /* This feels like a brittle fix for RT115953, where * ["foo "bar" baz"] got parsed as [foo "bar"baz] * when both allow_whitespace and allow_loose_quotes * are true and escape does not equal quote */ CSV_PUT_SV (c); c = c2; } c2 = CSV_GET; } } if (is_SEP (c2)) { /* ,1,"foo, 3",,bar,\r\n * ^ */ AV_PUSH; continue; } if (c2 == CH_NL || c2 == CH_EOLX) { /* ,1,"foo, 3",,"bar"\n * ^ */ AV_PUSH; return TRUE; } /* --- * if QUOTE eq ESCAPE * AND ( c2 eq QUOTE 1,"abc""def",2 * OR c2 eq ESCAPE 1,"abc""def",2 (QUO eq ESC) * OR c2 eq NULL ) 1,"abc"0def",2 * --- */ if (csv->escape_char && c == csv->escape_char) { quoesc = 1; if (c2 == '0') { /* ,1,"foo, 3"056",,bar,\r\n * ^ */ CSV_PUT_SV (0) continue; } if (is_QUOTE (c2)) { /* ,1,"foo, 3""56",,bar,\r\n * ^ */ if (csv->utf8) f |= CSV_FLAGS_BIN; CSV_PUT_SV (c2) continue; } if (csv->allow_loose_escapes && c2 != CH_CR) { /* ,1,"foo, 3"56",,bar,\r\n * ^ */ CSV_PUT_SV (c); c = c2; goto restart; } } if (c2 == CH_CR) { int c3; if (csv->eol_is_cr) { /* ,1,"foo, 3"\r * ^ */ AV_PUSH; return TRUE; } c3 = CSV_GET; if (c3 == CH_NL) { /* \r is not optional before EOLX! */ /* ,1,"foo, 3"\r\n * ^ */ AV_PUSH; return TRUE; } if (csv->useIO && csv->eol_len == 0 && !is_csv_binary (c3)) { /* ,1,"foo\n 3",,"bar"\r * baz,4 * ^ */ set_eol_is_cr (csv); csv->used--; csv->has_ahead++; AV_PUSH; return TRUE; } ParseError (csv, quoesc ? 2023 : 2010, csv->used - 2); return FALSE; } if (c2 == EOF) { /* ,1,"foo, 3" * ^ */ AV_PUSH; return TRUE; } if (csv->allow_loose_quotes && !quoesc) { /* ,1,"foo, 3"456",,bar,\r\n * ^ */ CSV_PUT_SV (c); c = c2; goto restart; } /* 1,"foo" ",3 * ^ */ if (quoesc) { csv->used--; ERROR_INSIDE_QUOTES (2023); } ERROR_INSIDE_QUOTES (2011); } /* !waitingForField, !InsideQuotes */ if (csv->allow_loose_quotes) { /* 1,foo "boo" d'uh,1 */ f |= CSV_FLAGS_EIF; /* Mark as error-in-field */ CSV_PUT_SV (c); } else ERROR_INSIDE_FIELD (2034); } /* QUO char */ else if (c == csv->escape_char && csv->escape_char) { #if MAINT_DEBUG > 1 fprintf (stderr, "# %d/%d/%03x pos %d = ESC '%c'\t'%s%\n", waitingForField ? 1 : 0, sv ? 1 : 0, f, spl, c, csv->bptr + csv->used); #endif /* This means quote_char != escape_char */ if (waitingForField) { waitingForField = 0; if (csv->allow_unquoted_escape) { /* The escape character is the first character of an * unquoted field */ /* ... get and store next character */ int c2 = CSV_GET; sv_setpvn (sv, "", 0); if (c2 == EOF) { csv->used--; ERROR_INSIDE_FIELD (2035); } if (c2 == '0') CSV_PUT_SV (0) else if ( is_QUOTE (c2) || is_SEP (c2) || c2 == csv->escape_char || csv->allow_loose_escapes) { if (csv->utf8) f |= CSV_FLAGS_BIN; CSV_PUT_SV (c2) } else { csv->used--; ERROR_INSIDE_QUOTES (2025); } } } else if (f & CSV_FLAGS_QUO) { int c2 = CSV_GET; if (c2 == EOF) { csv->used--; ERROR_INSIDE_QUOTES (2024); } if (c2 == '0') CSV_PUT_SV (0) else if ( is_QUOTE (c2) || is_SEP (c2) || c2 == csv->escape_char || csv->allow_loose_escapes) { if (csv->utf8) f |= CSV_FLAGS_BIN; CSV_PUT_SV (c2) } else { csv->used--; ERROR_INSIDE_QUOTES (2025); } } else if (sv) { int c2 = CSV_GET; if (c2 == EOF) { csv->used--; ERROR_INSIDE_FIELD (2035); } CSV_PUT_SV (c2); } else ERROR_INSIDE_FIELD (2036); /* uncoverable statement I think there's no way to get here */ } /* ESC char */ else if (c == CH_NL || is_EOL (c)) { EOLX: #if MAINT_DEBUG > 1 fprintf (stderr, "# %d/%d/%03x pos %d = NL\t'%s'\n", waitingForField ? 1 : 0, sv ? 1 : 0, f, spl, csv->bptr + csv->used); #endif if (waitingForField) { /* ,1,"foo, 3",,bar, * ^ */ if (csv->blank_is_undef || csv->empty_is_undef) sv_setpvn (sv, NULL, 0); else sv_setpvn (sv, "", 0); unless (csv->is_bound) av_push (fields, sv); if (csv->keep_meta_info && fflags) av_push (fflags, newSViv (f)); return TRUE; } if (f & CSV_FLAGS_QUO) { /* ,1,"foo\n 3",,bar, * ^ */ f |= CSV_FLAGS_BIN; unless (csv->binary) ERROR_INSIDE_QUOTES (2021); CSV_PUT_SV (c); } else if (csv->verbatim) { /* ,1,foo\n 3,,bar, * This feature should be deprecated */ f |= CSV_FLAGS_BIN; unless (csv->binary) ERROR_INSIDE_FIELD (2030); CSV_PUT_SV (c); } else { /* sep=, * ^ */ if (csv->recno == 0 && csv->fld_idx == 1 && csv->useIO && (csv->bptr[0] == 's' || csv->bptr[0] == 'S') && (csv->bptr[1] == 'e' || csv->bptr[1] == 'E') && (csv->bptr[2] == 'p' || csv->bptr[2] == 'P') && csv->bptr[3] == '=') { char *sep = csv->bptr + 4; int len = csv->used - 5; if (len <= MAX_ATTR_LEN) { sep[len] = (char)0; memcpy (csv->sep, sep, len); csv->sep_len = len == 1 ? 0 : len; return Parse (csv, src, fields, fflags); } } /* ,1,"foo\n 3",,bar * ^ */ AV_PUSH; return TRUE; } } /* CH_NL */ else if (c == CH_CR && !(csv->verbatim)) { #if MAINT_DEBUG > 1 fprintf (stderr, "# %d/%d/%03x pos %d = CR\n", waitingForField ? 1 : 0, sv ? 1 : 0, f, spl); #endif if (waitingForField) { int c2; waitingForField = 0; if (csv->eol_is_cr) { /* ,1,"foo\n 3",,bar,\r * ^ */ c = CH_NL; goto restart; } c2 = CSV_GET; if (c2 == EOF) { /* ,1,"foo\n 3",,bar,\r * ^ */ c = EOF; goto restart; } if (c2 == CH_NL) { /* \r is not optional before EOLX! */ /* ,1,"foo\n 3",,bar,\r\n * ^ */ c = c2; goto restart; } if (csv->useIO && csv->eol_len == 0 && !is_csv_binary (c2)) { /* ,1,"foo\n 3",,bar,\r * baz,4 * ^ */ set_eol_is_cr (csv); csv->used--; csv->has_ahead++; AV_PUSH; return TRUE; } /* ,1,"foo\n 3",,bar,\r\t * ^ */ csv->used--; ERROR_INSIDE_FIELD (2031); } if (f & CSV_FLAGS_QUO) { /* ,1,"foo\r 3",,bar,\r\t * ^ */ f |= CSV_FLAGS_BIN; unless (csv->binary) ERROR_INSIDE_QUOTES (2022); CSV_PUT_SV (c); } else { int c2; if (csv->eol_is_cr) { /* ,1,"foo\n 3",,bar\r * ^ */ AV_PUSH; return TRUE; } c2 = CSV_GET; if (c2 == CH_NL) { /* \r is not optional before EOLX! */ /* ,1,"foo\n 3",,bar\r\n * ^ */ AV_PUSH; return TRUE; } if (csv->useIO && csv->eol_len == 0 && !is_csv_binary (c2)) { /* ,1,"foo\n 3",,bar\r * baz,4 * ^ */ set_eol_is_cr (csv); csv->used--; csv->has_ahead++; AV_PUSH; return TRUE; } /* ,1,"foo\n 3",,bar\r\t * ^ */ ERROR_INSIDE_FIELD (2032); } } /* CH_CR */ else { #if MAINT_DEBUG > 1 fprintf (stderr, "# %d/%d/%03x pos %d = CCC '%c'\t\t'%s'\n", waitingForField ? 1 : 0, sv ? 1 : 0, f, spl, c, csv->bptr + csv->used); #endif /* Needed for non-IO parse, where EOL is not set during read */ if (csv->eolx && c == CH_EOL && csv->size - csv->used >= csv->eol_len - 1 && !memcmp (csv->bptr + csv->used, csv->eol + 1, csv->eol_len - 1) && (csv->used += csv->eol_len - 1)) { c = CH_EOLX; goto EOLX; } if (waitingForField) { if (csv->allow_whitespace && is_whitespace (c)) { do { c = CSV_GET; } while (is_whitespace (c)); if (c == EOF) break; goto restart; } waitingForField = 0; goto restart; } if (f & CSV_FLAGS_QUO) { if (is_csv_binary (c)) { f |= CSV_FLAGS_BIN; unless (csv->binary || csv->utf8) ERROR_INSIDE_QUOTES (2026); } CSV_PUT_SV (c); } else { if (is_csv_binary (c)) { f |= CSV_FLAGS_BIN; unless (csv->binary || csv->utf8) ERROR_INSIDE_FIELD (2037); } CSV_PUT_SV (c); } } /* continue */ if (csv->verbatim && csv->useIO && csv->used == csv->size) break; } if (waitingForField) { if (seenSomething || !csv->useIO) { NewField; if (csv->blank_is_undef || csv->empty_is_undef) sv_setpvn (sv, NULL, 0); else sv_setpvn (sv, "", 0); unless (csv->is_bound) av_push (fields, sv); if (csv->keep_meta_info && fflags) av_push (fflags, newSViv (f)); return TRUE; } (void)SetDiag (csv, 2012); return FALSE; } if (f & CSV_FLAGS_QUO) ERROR_INSIDE_QUOTES (2027); if (sv) AV_PUSH; return TRUE; } /* Parse */ #define c_xsParse(csv,hv,av,avf,src,useIO) cx_c_xsParse (aTHX_ csv, hv, av, avf, src, useIO) static int cx_c_xsParse (pTHX_ csv_t csv, HV *hv, AV *av, AV *avf, SV *src, bool useIO) { int result, ahead = 0; SV *pos = NULL; ENTER; if (csv.eolx || csv.eol_is_cr) { /* local $/ = $eol */ SAVEGENERICSV (PL_rs); PL_rs = newSVpvn ((char *)csv.eol, csv.eol_len); } if ((csv.useIO = useIO)) { require_IO_Handle; csv.tmp = NULL; if ((ahead = csv.has_ahead)) { SV **svp; if ((svp = hv_fetchs (hv, "_AHEAD", FALSE)) && *svp) { csv.bptr = SvPV (csv.tmp = *svp, csv.size); csv.used = 0; if (pos && SvIV (pos) > csv.size) sv_setiv (pos, SvIV (pos) - csv.size); } } } else { csv.tmp = src; csv.utf8 = SvUTF8 (src); csv.bptr = SvPV (src, csv.size); } if (csv.has_error_input) { (void)hv_store (hv, "_ERROR_INPUT", 12, &PL_sv_undef, 0); csv.has_error_input = 0; } result = Parse (&csv, src, av, avf); hv_store (hv, "_RECNO", 6, newSViv (++csv.recno), 0); (void)hv_store (hv, "_EOF", 4, &PL_sv_no, 0); if (csv.useIO) { if (csv.tmp && csv.used < csv.size && csv.has_ahead) { SV *sv = newSVpvn (csv.bptr + csv.used, csv.size - csv.used); (void)hv_store (hv, "_AHEAD", 6, sv, 0); } else { csv.has_ahead = 0; if (csv.useIO & useIO_EOF) (void)hv_store (hv, "_EOF", 4, &PL_sv_yes, 0); } /* csv.cache[CACHE_ID__has_ahead] = csv.has_ahead; */ memcpy (csv.cache, &csv, sizeof (csv_t)); if (avf) { if (csv.keep_meta_info) (void)hv_store (hv, "_FFLAGS", 7, newRV_noinc ((SV *)avf), 0); else { av_undef (avf); sv_free ((SV *)avf); } } } else /* just copy the cache */ memcpy (csv.cache, &csv, sizeof (csv_t)); if (result && csv.types) { I32 i; STRLEN len = av_len (av); SV **svp; for (i = 0; i <= (I32)len && i <= (I32)csv.types_len; i++) { if ((svp = av_fetch (av, i, 0)) && *svp && SvOK (*svp)) { switch (csv.types[i]) { case CSV_XS_TYPE_IV: sv_setiv (*svp, SvIV (*svp)); break; case CSV_XS_TYPE_NV: sv_setnv (*svp, SvNV (*svp)); break; default: break; } } } } LEAVE; return result; } /* c_xsParse */ static int hook (pTHX_ HV *hv, char *cb_name, AV *av) { SV **svp; HV *cb; int res; #if MAINT_DEBUG > 1 fprintf (stderr, "# HOOK %s %x\n", cb_name, av); #endif unless ((svp = hv_fetchs (hv, "callbacks", FALSE)) && _is_hashref (*svp)) return 0; /* uncoverable statement defensive programming */ cb = (HV *)SvRV (*svp); svp = hv_fetch (cb, cb_name, strlen (cb_name), FALSE); unless (svp && _is_coderef (*svp)) return 0; { dSP; ENTER; SAVETMPS; PUSHMARK (SP); XPUSHs (newRV_noinc ((SV *)hv)); XPUSHs (newRV_noinc ((SV *)av)); PUTBACK; res = call_sv (*svp, G_SCALAR); SPAGAIN; if (res) { SV *rv = POPs; if (SvROK (rv) && (rv = SvRV (rv)) && SvPOK (rv)) { if (strcmp (SvPV_nolen (rv), "skip") == 0) res = 0; } } PUTBACK; FREETMPS; LEAVE; } return res; } /* hook */ #define xsParse(self,hv,av,avf,src,useIO) cx_xsParse (aTHX_ self, hv, av, avf, src, useIO) static int cx_xsParse (pTHX_ SV *self, HV *hv, AV *av, AV *avf, SV *src, bool useIO) { csv_t csv; int state; SetupCsv (&csv, hv, self); state = c_xsParse (csv, hv, av, avf, src, useIO); if (state && csv.has_hooks & HOOK_AFTER_PARSE) (void)hook (aTHX_ hv, "after_parse", av); return (state || !last_error); } /* xsParse */ #define av_empty(av) cx_av_empty (aTHX_ av) static void cx_av_empty (pTHX_ AV *av) { while (av_len (av) >= 0) sv_free (av_pop (av)); } /* av_empty */ #define xsParse_all(self,hv,io,off,len) cx_xsParse_all (aTHX_ self, hv, io, off, len) static SV *cx_xsParse_all (pTHX_ SV *self, HV *hv, SV *io, SV *off, SV *len) { csv_t csv; int n = 0, skip = 0, length = MAXINT, tail = MAXINT; AV *avr = newAV (); AV *row = newAV (); SetupCsv (&csv, hv, self); if (SvIOK (off)) { skip = SvIV (off); if (skip < 0) { tail = -skip; skip = -1; } } if (SvIOK (len)) length = SvIV (len); while (c_xsParse (csv, hv, row, NULL, io, 1)) { SetupCsv (&csv, hv, self); if (skip > 0) { skip--; av_empty (row); /* re-use */ continue; } if (n++ >= tail) { SvREFCNT_dec (av_shift (avr)); n--; } if (csv.has_hooks & HOOK_AFTER_PARSE) { unless (hook (aTHX_ hv, "after_parse", row)) { av_empty (row); /* re-use */ continue; } } av_push (avr, newRV_noinc ((SV *)row)); if (n >= length && skip >= 0) break; /* We have enough */ row = newAV (); } while (n > length) { SvREFCNT_dec (av_pop (avr)); n--; } return (SV *)sv_2mortal (newRV_noinc ((SV *)avr)); } /* xsParse_all */ #define xsCombine(self,hv,av,io,useIO) cx_xsCombine (aTHX_ self, hv, av, io, useIO) static int cx_xsCombine (pTHX_ SV *self, HV *hv, AV *av, SV *io, bool useIO) { csv_t csv; int result; #if (PERL_BCDVERSION >= 0x5008000) SV *ors = PL_ors_sv; #endif SetupCsv (&csv, hv, self); csv.useIO = useIO; #if (PERL_BCDVERSION >= 0x5008000) if (*csv.eol) PL_ors_sv = NULL; #endif if (useIO && csv.has_hooks & HOOK_BEFORE_PRINT) (void)hook (aTHX_ hv, "before_print", av); result = Combine (&csv, io, av); #if (PERL_BCDVERSION >= 0x5008000) PL_ors_sv = ors; #endif if (result && !useIO && csv.utf8) sv_utf8_upgrade (io); return result; } /* xsCombine */ MODULE = Text::CSV_XS PACKAGE = Text::CSV_XS PROTOTYPES: DISABLE BOOT: m_getline = newSVpvs ("getline"); m_print = newSVpvs ("print"); m_read = newSVpvs ("read"); void SetDiag (self, xse, ...) SV *self int xse PPCODE: HV *hv; csv_t csv; if (SvOK (self) && SvROK (self)) { CSV_XS_SELF; SetupCsv (&csv, hv, self); ST (0) = SetDiag (&csv, xse); } else ST (0) = sv_2mortal (SvDiag (xse)); if (xse && items > 1 && SvPOK (ST (2))) { sv_setpvn (ST (0), SvPVX (ST (2)), SvCUR (ST (2))); SvIOK_on (ST (0)); } XSRETURN (1); /* XS SetDiag */ void error_input (self) SV *self PPCODE: if (self && SvOK (self) && SvROK (self) && SvTYPE (SvRV (self)) == SVt_PVHV) { HV *hv = (HV *)SvRV (self); SV **sv = hv_fetchs (hv, "_ERROR_INPUT", FALSE); if (SvOK (*sv)) ST (0) = *sv; else ST (0) = newSV (0); } else ST (0) = newSV (0); XSRETURN (1); /* XS error_input */ void Combine (self, dst, fields, useIO) SV *self SV *dst SV *fields bool useIO PPCODE: HV *hv; AV *av; CSV_XS_SELF; av = (AV *)SvRV (fields); ST (0) = xsCombine (self, hv, av, dst, useIO) ? &PL_sv_yes : &PL_sv_undef; XSRETURN (1); /* XS Combine */ void Parse (self, src, fields, fflags) SV *self SV *src SV *fields SV *fflags PPCODE: HV *hv; AV *av; AV *avf; CSV_XS_SELF; av = (AV *)SvRV (fields); avf = (AV *)SvRV (fflags); ST (0) = xsParse (self, hv, av, avf, src, 0) ? &PL_sv_yes : &PL_sv_no; XSRETURN (1); /* XS Parse */ void print (self, io, fields) SV *self SV *io SV *fields PPCODE: HV *hv; AV *av; CSV_XS_SELF; if (fields == &PL_sv_undef) av = newAV (); else { unless (_is_arrayref (fields)) croak ("Expected fields to be an array ref"); av = (AV *)SvRV (fields); } ST (0) = xsCombine (self, hv, av, io, 1) ? &PL_sv_yes : &PL_sv_no; XSRETURN (1); /* XS print */ void getline (self, io) SV *self SV *io PPCODE: HV *hv; AV *av; AV *avf; CSV_XS_SELF; av = newAV (); avf = newAV (); ST (0) = xsParse (self, hv, av, avf, io, 1) ? sv_2mortal (newRV_noinc ((SV *)av)) : &PL_sv_undef; XSRETURN (1); /* XS getline */ void getline_all (self, io, ...) SV *self SV *io PPCODE: HV *hv; SV *offset, *length; CSV_XS_SELF; offset = items > 2 ? ST (2) : &PL_sv_undef; length = items > 3 ? ST (3) : &PL_sv_undef; ST (0) = xsParse_all (self, hv, io, offset, length); XSRETURN (1); /* XS getline_all */ void _cache_set (self, idx, val) SV *self int idx SV *val PPCODE: HV *hv; CSV_XS_SELF; xs_cache_set (hv, idx, val); XSRETURN (1); /* XS _cache_set */ void _cache_diag (self) SV *self PPCODE: HV *hv; CSV_XS_SELF; xs_cache_diag (hv); XSRETURN (1); /* XS _cache_diag */ Text-CSV_XS-1.26/files/0000755000031300001440000000000013017540444015232 5ustar00merijnusers00000000000000Text-CSV_XS-1.26/files/macosx.csv0000644000031300001440000000164312753265122017250 0ustar00merijnusers00000000000000"'\'\\'\\\'""\""\\""\\\""",,,,,,,,,,,,,, Exported 12/16/2008 10:30 AM,,,,,,Category,Category name,,,,,Category name 2,, Username,Last Name,First Name M.,Section/Group,Status,Notes,Assignment,Category name 1,Category name 2,Category name 3,woot!,dqwdqwd,Category name 2 1,Total Score,Class Grade ,,,,,,Grading scale,Points,Points,Points,Points,Points,Points,, ,,,,,,Points possible,11,11,11,11,11,11,, dcwalker,,,,Dropped,,,1,34,1,,,,109, jdr99,,,devs,Active,"qwd qwd qwd",,12,0,1,,,,39, jlaney,,,devs,Active,,,,2,23,,,,114, mcrawfor,,,devs,Active,"line 1 line 2 line 3 XX fwe and so on yea!",,,,,,,,, ,,,,,,,,,,,,,, ,,,,,,Mean,6.5,12.0,8.33,#DIV/0!,#DIV/0!,#DIV/0!,87.33, ,,,,,,Median,6.5,2.0,1.0,#NUM!,#NUM!,#NUM!,109.0, ,,,,,,Mode,#N/A,#N/A,1.0,#N/A,#N/A,#N/A,#N/A, ,,,,,,Min,1.0,0.0,1.0,0.0,0.0,0.0,39.0, ,,,,,,Max,12.0,34.0,23.0,0.0,0.0,0.0,114.0, ,,,,,,Std. Dev.,7.78,19.08,12.7,#DIV/0!,#DIV/0!,#DIV/0!,41.93,Text-CSV_XS-1.26/files/utf8.csv0000644000031300001440000000001411021471761016626 0ustar00merijnusers00000000000000"Øl/Vin",0 Text-CSV_XS-1.26/README0000644000031300001440000000407212753265122015016 0ustar00merijnusers00000000000000Module: Text::CSV_XS Description: Text::CSV_XS provides facilities for the composition and decomposition of comma-separated values. An instance of the Text::CSV_XS class can combine fields into a CSV string and parse a CSV string into fields. Copying: Copyright (c) 2007-2016 H.Merijn Brand. All rights reserved. Copyright (c) 1998-2001 Jochen Wiedmann. All rights reserved. Portions Copyright (c) 1997 Alan Citterman. All rights reserved. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. Recent changes can be (re)viewed in the public GIT repository at http://repo.or.cz/w/Text-CSV_XS Feel free to clone your own copy: $ git clone https://github.com/Tux/Text-CSV_XS Text-CSV_XS or get it as a tgz: $ wget --output-document=Text-CSV_XS-git.tgz \ https://github.com/Tux/Text-CSV_XS/archive/master.tar.gz Prerequisites: perl 5.6.1 or up. You can have working Test::More for 5.6.1 by requiring version Test::Harness-2.64 and Test::Simple-0.90 I found no easy way to get Test::More working on 5.6.0 examples/csv-check requires perl with defined-or and PerlIO, and making that work on other versions is left as an exercise to the reader. Other examples are checked against 5.8.4. For Unicode to work more or less reliable, you'd need perl 5.8.2 or newer. examples/csv2xlsx requires 5.14 or newer. Build/Installation: Standard build/installation: perl Makefile.PL make test make install Author: H.Merijn Brand Jochen Wiedmann Interface design by Alan Citterman A pure-perl version is being maintained by Makamaka Hannyaharamitu as Text::CSV_PP, which tries to follow Text::CSV_XS. It is not worth filing bugs to Text::CSV_XS when Text::CSV is not in sync. Text::CSV_PP is bundled in Text::CSV, which now is a wrapper module over Text::CSV_XS and Text::CSV_PP that will select Text::CSV_XS if available, and otherwise use Text::PP. Text-CSV_XS-1.26/META.json0000644000031300001440000000267613017540445015565 0ustar00merijnusers00000000000000{ "provides" : { "Text::CSV_XS" : { "version" : "1.26", "file" : "CSV_XS.pm" } }, "version" : "1.26", "release_status" : "stable", "dynamic_config" : 1, "resources" : { "x_IRC" : "irc://irc.perl.org/#csv", "repository" : { "type" : "git", "url" : "https://github.com/Tux/Text-CSV_XS", "web" : "https://github.com/Tux/Text-CSV_XS" }, "license" : [ "http://dev.perl.org/licenses/" ], "homepage" : "https://metacpan.org/pod/Text::CSV_XS" }, "license" : [ "perl_5" ], "generated_by" : "Author", "prereqs" : { "build" : { "requires" : { "Config" : "0" } }, "test" : { "requires" : { "Test::More" : "0", "Tie::Scalar" : "0" } }, "configure" : { "requires" : { "ExtUtils::MakeMaker" : "0" } }, "runtime" : { "recommends" : { "Encode" : "2.88" }, "requires" : { "DynaLoader" : "0", "perl" : "5.006001", "IO::Handle" : "0" } } }, "name" : "Text-CSV_XS", "abstract" : "Comma-Separated Values manipulation routines", "meta-spec" : { "url" : "http://search.cpan.org/perldoc?CPAN::Meta::Spec", "version" : "2" }, "author" : [ "H.Merijn Brand " ] } Text-CSV_XS-1.26/t/0000755000031300001440000000000013017540444014373 5ustar00merijnusers00000000000000Text-CSV_XS-1.26/t/46_eol_si.t0000644000031300001440000001404312753265123016351 0ustar00merijnusers00000000000000#!/usr/bin/perl use strict; use warnings; use Config; use Test::More; BEGIN { unless (exists $Config{useperlio} && defined $Config{useperlio} && $] >= 5.008 && # perlio was experimental in 5.6.2, but not reliable $Config{useperlio} eq "define") { plan skip_all => "No reliable perlIO available"; } else { plan tests => 553; } } BEGIN { require_ok "Text::CSV_XS"; plan skip_all => "Cannot load Text::CSV_XS" if $@; require "t/util.pl"; } $| = 1; # Embedded newline tests my $file = ""; my $def_rs = $/; foreach my $rs ("\n", "\r\n", "\r") { for $\ (undef, $rs) { my $csv = Text::CSV_XS->new ({ binary => 1 }); $csv->eol ($/ = $rs) unless defined $\; my $fh; foreach my $pass (0, 1) { if ($pass == 0) { $file = ""; open $fh, ">", \$file or die "IO: $!\n"; } else { open $fh, "<", \$file or die "IO: $!\n"; } foreach my $eol ("", "\r", "\n", "\r\n", "\n\r") { my $s_eol = join " - ", map { defined $_ ? $_ : "" } $\, $rs, $eol; $s_eol =~ s/\r/\\r/g; $s_eol =~ s/\n/\\n/g; my @p; my @f = ("", 1, $eol, " $eol", "$eol ", " $eol ", "'$eol'", "\"$eol\"", " \" $eol \"\n ", "EOL"); if ($pass == 0) { ok ($csv->combine (@f), "combine |$s_eol|"); ok (my $str = $csv->string, "string |$s_eol|"); my $state = $csv->parse ($str); ok ($state, "parse |$s_eol|"); if ($state) { ok (@p = $csv->fields, "fields |$s_eol|"); } else{ is ($csv->error_input, $str, "error |$s_eol|"); } print $fh $str; } else { ok (my $row = $csv->getline ($fh), "getline |$s_eol|"); is (ref $row, "ARRAY", "row |$s_eol|"); @p = @$row; } local $, = "|"; is_binary ("@p", "@f", "result |$s_eol|"); } close $fh; } } } $/ = $def_rs; { my $csv = Text::CSV_XS->new ({ escape_char => undef }); ok ($csv->parse (qq{"x"\r\n}), "Trailing \\r\\n with no escape char"); is ($csv->eol ("\r"), "\r", "eol set to \\r"); ok ($csv->parse (qq{"x"\r}), "Trailing \\r with no escape char"); ok ($csv->allow_whitespace (1), "Allow whitespace"); ok ($csv->parse (qq{"x" \r}), "Trailing \\r with no escape char"); } SKIP: { $] < 5.008 and skip "\$\\ tests don't work in perl 5.6.x and older", 2; { local $\ = "#\r\n"; my $csv = Text::CSV_XS->new (); $file = ""; open my $fh, ">", \$file or die "IO: $!\n"; $csv->print ($fh, [ "a", 1 ]); close $fh; open $fh, "<", \$file or die "IO: $!\n"; local $/; is (<$fh>, "a,1#\r\n", "Strange \$\\"); close $fh; } { local $\ = "#\r\n"; my $csv = Text::CSV_XS->new ({ eol => $\ }); $file = ""; open my $fh, ">", \$file or die "IO: $!\n"; $csv->print ($fh, [ "a", 1 ]); close $fh; open $fh, "<", \$file or die "IO: $!\n"; local $/; is (<$fh>, "a,1#\r\n", "Strange \$\\ + eol"); close $fh; } } $/ = $def_rs; ok (1, "Auto-detecting \\r"); { my @row = qw( a b c ); local $" = ","; for (["\n", "\\n"], ["\r\n", "\\r\\n"], ["\r", "\\r"]) { my ($eol, $s_eol) = @$_; $file = ""; open my $fh, ">", \$file or die "IO: $!\n"; print $fh qq{@row$eol@row$eol@row$eol\x91}; close $fh; open $fh, "<", \$file or die "IO: $!\n"; my $c = Text::CSV_XS->new ({ binary => 1, auto_diag => 1 }); is ($c->eol (), "", "default EOL"); is_deeply ($c->getline ($fh), [ @row ], "EOL 1 $s_eol"); is ($c->eol (), $eol eq "\r" ? "\r" : "", "EOL"); is_deeply ($c->getline ($fh), [ @row ], "EOL 2 $s_eol"); is_deeply ($c->getline ($fh), [ @row ], "EOL 3 $s_eol"); close $fh; } } ok (1, "Specific \\r test from tfrayner"); { $/ = "\r"; $file = ""; open my $fh, ">", \$file or die "IO: $!\n"; print $fh qq{a,b,c$/}, qq{"d","e","f"$/}; close $fh; open $fh, "<", \$file or die "IO: $!\n"; my $c = Text::CSV_XS->new ({ eol => $/ }); my $row; local $" = " "; ok ($row = $c->getline ($fh), "getline 1"); is (scalar @$row, 3, "# fields"); is ("@$row", "a b c", "fields 1"); ok ($row = $c->getline ($fh), "getline 2"); is (scalar @$row, 3, "# fields"); is ("@$row", "d e f", "fields 2"); close $fh; } $/ = $def_rs; ok (1, "EOL undef"); { $/ = "\r"; ok (my $csv = Text::CSV_XS->new ({ eol => undef }), "new csv with eol => undef"); $file = ""; open my $fh, ">", \$file or die "IO: $!\n"; ok ($csv->print ($fh, [1, 2, 3]), "print"); ok ($csv->print ($fh, [4, 5, 6]), "print"); close $fh; open $fh, "<", \$file or die "IO: $!\n"; ok (my $row = $csv->getline ($fh), "getline 1"); is (scalar @$row, 5, "# fields"); is_deeply ($row, [ 1, 2, 34, 5, 6], "fields 1"); close $fh; } $/ = $def_rs; foreach my $eol ("!", "!!", "!\n", "!\n!") { (my $s_eol = $eol) =~ s/\n/\\n/g; ok (1, "EOL $s_eol"); ok (my $csv = Text::CSV_XS->new ({ eol => $eol }), "new csv with eol => $s_eol"); $file = ""; open my $fh, ">", \$file or die "IO: $!\n"; ok ($csv->print ($fh, [1, 2, 3]), "print"); ok ($csv->print ($fh, [4, 5, 6]), "print"); close $fh; foreach my $rs (undef, "", "\n", $eol, "!", "!\n", "\n!", "!\n!", "\n!\n") { local $/ = $rs; (my $s_rs = defined $rs ? $rs : "-- undef --") =~ s/\n/\\n/g; ok (1, "with RS $s_rs"); open $fh, "<", \$file or die "IO: $!\n"; ok (my $row = $csv->getline ($fh), "getline 1"); is (scalar @$row, 3, "# fields"); is_deeply ($row, [ 1, 2, 3], "fields 1"); ok ( $row = $csv->getline ($fh), "getline 2"); is (scalar @$row, 3, "# fields"); is_deeply ($row, [ 4, 5, 6], "fields 2"); close $fh; } } $/ = $def_rs; { ok (my $csv = Text::CSV_XS->new, "new for say"); my $foo; open my $fh, ">", \$foo or die "IO: $!\n"; ok ($csv->say ($fh, [ 1, 2 ]), "say"); close $fh; is ($foo, "1,2$/"); $foo = ""; $csv->eol ("#"); open $fh, ">", \$foo or die "IO: $!\n"; ok ($csv->say ($fh, [ 1, 2 ]), "say"); close $fh; is ($foo, "1,2#"); $foo = ""; $csv->eol ("0"); open $fh, ">", \$foo or die "IO: $!\n"; ok ($csv->say ($fh, [ 1, 2 ]), "say"); close $fh; is ($foo, "1,20"); } 1; Text-CSV_XS-1.26/t/20_file.t0000644000031300001440000001024012753265123016001 0ustar00merijnusers00000000000000#!/usr/bin/perl use strict; use warnings; use Test::More tests => 105; BEGIN { use_ok "Text::CSV_XS"; plan skip_all => "Cannot load Text::CSV_XS" if $@; require "t/util.pl"; } $| = 1; $/ = "\n"; $\ = undef; my $tfn = "_20test.csv"; END { -f $tfn and unlink $tfn; } my $csv = Text::CSV_XS->new (); my $UTF8 = ($ENV{LANG} || "C").($ENV{LC_ALL} || "C") =~ m/utf-?8/i ? 1 : 0; open FH, ">", $tfn or die "$tfn: $!"; ok (!$csv->print (*FH, ["abc", "def\007", "ghi"]), "print bad character"); close FH; for ( [ 1, 1, 1, '""' ], [ 2, 1, 1, '', '' ], [ 3, 1, 0, '', 'I said, "Hi!"', '' ], [ 4, 1, 0, '"', 'abc' ], [ 5, 1, 0, 'abc', '"' ], [ 6, 1, 1, 'abc', 'def', 'ghi' ], [ 7, 1, 1, "abc\tdef", 'ghi' ], [ 8, 1, 0, '"abc' ], [ 9, 1, 0, 'ab"c' ], [ 10, 1, 0, '"ab"c"' ], [ 11, 0, 0, qq("abc\nc") ], [ 12, 1, 1, q(","), ',' ], [ 13, 1, 0, qq("","I said,\t""Hi!""",""), '', qq(I said,\t"Hi!"), '' ], ) { my ($tst, $validp, $validg, @arg, $row) = @$_; open FH, ">", $tfn or die "$tfn: $!"; is ($csv->print (*FH, \@arg), $validp||"", "$tst - print ()"); close FH; open FH, ">", $tfn or die "$tfn: $!"; print FH join ",", @arg; close FH; open FH, "<", $tfn or die "$tfn: $!"; $row = $csv->getline (*FH); unless ($validg) { is ($row, undef, "$tst - false getline ()"); next; } ok ($row, "$tst - good getline ()"); $tst == 12 and @arg = (",", "", ""); foreach my $a (0 .. $#arg) { (my $exp = $arg[$a]) =~ s/^"(.*)"$/$1/; is ($row->[$a], $exp, "$tst - field $a"); } } unlink $tfn; # This test because of a problem with DBD::CSV ok (1, "Tests for DBD::CSV"); open FH, ">", $tfn or die "$tfn: $!"; $csv->binary (1); $csv->eol ("\r\n"); ok ($csv->print (*FH, [ "id", "name" ]), "Bad character"); ok ($csv->print (*FH, [ 1, "Alligator Descartes" ]), "Name 1"); ok ($csv->print (*FH, [ "3", "Jochen Wiedmann" ]), "Name 2"); ok ($csv->print (*FH, [ 2, "Tim Bunce" ]), "Name 3"); ok ($csv->print (*FH, [ " 4", "Andreas Knig" ]), "Name 4"); ok ($csv->print (*FH, [ 5 ]), "Name 5"); close FH; my $expected = <<"CONTENTS"; id,name\015 1,"Alligator Descartes"\015 3,"Jochen Wiedmann"\015 2,"Tim Bunce"\015 " 4","Andreas Knig"\015 5\015 CONTENTS open FH, "<", $tfn or die "$tfn: $!"; my $content = do { local $/; }; close FH; is ($content, $expected, "Content"); open FH, ">", $tfn or die "$tfn: $!"; print FH $content; close FH; open FH, "<", $tfn or die "$tfn: $!"; my $fields; print "# Retrieving data\n"; for (0 .. 5) { ok ($fields = $csv->getline (*FH), "Fetch field $_"); is ($csv->eof, "", "EOF"); print "# Row $_: $fields (@$fields)\n"; } is ($csv->getline (*FH), undef, "Fetch field 6"); is ($csv->eof, 1, "EOF"); # Edge cases $csv = Text::CSV_XS->new ({ escape_char => "+" }); for ([ 1, 1, 0, "\n" ], [ 2, 1, 0, "+\n" ], [ 3, 1, 0, "+" ], [ 4, 0, 2021, qq{"+"\n} ], [ 5, 0, 2025, qq{"+\n} ], [ 6, 0, 2011, qq{""+\n} ], [ 7, 0, 2027, qq{"+"} ], [ 8, 0, 2024, qq{"+} ], [ 9, 0, 2011, qq{""+} ], [ 10, 0, 2037, "\r" ], [ 11, 0, 2031, "\r\r" ], [ 12, 0, 2032, "+\r\r" ], [ 13, 0, 2032, "+\r\r+" ], [ 14, 0, 2022, qq{"\r"} ], [ 15, 0, 2022, qq{"\r\r" } ], [ 16, 0, 2022, qq{"\r\r"\t} ], [ 17, 0, 2025, qq{"+\r\r"} ], [ 18, 0, 2025, qq{"+\r\r+"} ], [ 19, 0, 2022, qq{"\r"\r} ], [ 20, 0, 2022, qq{"\r\r"\r} ], [ 21, 0, 2025, qq{"+\r\r"\r} ], [ 22, 0, 2025, qq{"+\r\r+"\r} ], ) { my ($tst, $valid, $err, $str) = @$_; my $raw = $] < 5.008 ? "" : ":raw"; open FH, ">$raw", $tfn or die "$tfn: $!"; print FH $str; close FH; open FH, "<$raw", $tfn or die "$tfn: $!"; my $row = $csv->getline (*FH); close FH; my @err = $csv->error_diag; my $sstr = _readable ($str); SKIP: { $tst == 10 && $] >= 5.008 && $] < 5.008003 && $UTF8 and skip "Be reasonable, this perl version does not do Unicode reliable", 2; ok ($valid ? $row : !$row, "$tst - getline ESC +, '$sstr'"); is ($err[0], $err, "Error expected $err"); } } Text-CSV_XS-1.26/t/76_magic.t0000644000031300001440000000371112753265123016162 0ustar00merijnusers00000000000000#!/usr/bin/perl use strict; use warnings; #use Test::More "no_plan"; use Test::More tests => 13; BEGIN { use_ok "Text::CSV_XS", (); plan skip_all => "Cannot load Text::CSV_XS" if $@; } my $tfn = "_76test.csv"; END { -f $tfn and unlink $tfn; } my $csv = Text::CSV_XS->new ({ binary => 1, eol => "\n" }); my $fh; my $foo; my $bar; my @foo = ("#", 1..3); tie $foo, "Foo"; ok ($csv->combine (@$foo), "combine () from magic"); untie $foo; is_deeply ([$csv->fields], \@foo, "column_names ()"); tie $bar, "Bar"; $bar = "#"; ok ($csv->combine ($bar, @{$foo}[1..3]),"combine () from magic"); untie $bar; is_deeply ([$csv->fields], \@foo, "column_names ()"); tie $foo, "Foo"; open $fh, ">", $tfn or die "$tfn: $!\n"; ok ($csv->print ($fh, $foo), "print with unused magic scalar"); close $fh; untie $foo; open $fh, "<", $tfn or die "$tfn: $!\n"; is_deeply ($csv->getline ($fh), \@foo, "Content read-back"); close $fh; tie $foo, "Foo"; ok ($csv->column_names ($foo), "column_names () from magic"); untie $foo; is_deeply ([$csv->column_names], \@foo, "column_names ()"); open $fh, "<", $tfn or die "$tfn: $!\n"; tie $bar, "Bar"; ok ($csv->bind_columns (\$bar, \my ($f0, $f1, $f2)), "bind"); ok ($csv->getline ($fh), "fetch with magic"); is_deeply ([$bar,$f0,$f1,$f2], \@foo, "columns fetched on magic"); # free any refs is ($csv->bind_columns (undef), undef, "bind column clear"); untie $bar; close $fh; { package Foo; use strict; use warnings; require Tie::Scalar; use vars qw( @ISA ); @ISA = qw(Tie::Scalar); sub FETCH { [ "#", 1 .. 3 ]; } # FETCH sub TIESCALAR { bless [], "Foo"; } # TIESCALAR 1; } { package Bar; use strict; use warnings; require Tie::Scalar; use vars qw( @ISA ); @ISA = qw(Tie::Scalar); sub FETCH { return ${$_[0]}; } # FETCH sub STORE { ${$_[0]} = $_[1]; } # STORE sub TIESCALAR { my $bar; bless \$bar, "Bar"; } # TIESCALAR 1; } Text-CSV_XS-1.26/t/81_subclass.t0000644000031300001440000000114512753265123016714 0ustar00merijnusers00000000000000#!/usr/bin/perl package Text::CSV_XS::Subclass; use strict; use warnings; use base "Text::CSV_XS"; use Test::More tests => 6; ok (1, "Subclassed"); my $csvs = Text::CSV_XS::Subclass->new (); is ($csvs->error_diag (), "", "Last failure for new () - OK"); my $sc_csv; eval { $sc_csv = Text::CSV_XS::Subclass->new ({ ecs_char => ":" }); }; is ($sc_csv, undef, "Unsupported option"); is ($@, "", "error"); is (Text::CSV_XS::Subclass->error_diag (), "INI - Unknown attribute 'ecs_char'", "Last failure for new () - FAIL"); is (Text::CSV_XS::Subclass->new ({ fail_me => "now" }), undef, "bad new ()"); 1; Text-CSV_XS-1.26/t/util.pl0000644000031300001440000000075112753265123015714 0ustar00merijnusers00000000000000use strict; my %special = ( 9 => "\\t", 10 => "\\n", 13 => "\\r" ); sub _readable { defined $_[0] or return "--undef--"; join "", map { my $cp = ord $_; $cp >= 0x20 && $cp <= 0x7e ? $_ : $special{$cp} || sprintf "\\x{%02x}", $cp } split m//, $_[0]; } # _readable sub is_binary { my ($str, $exp, $tst) = @_; if ($str eq $exp) { ok (1, $tst); } else { my ($hs, $he) = map { _readable $_ } $str, $exp; is ($hs, $he, $tst); } } # is_binary 1; Text-CSV_XS-1.26/t/40_misc.t0000644000031300001440000000325112753265123016023 0ustar00merijnusers00000000000000#!/usr/bin/perl use strict; use warnings; use Test::More tests => 24; BEGIN { require_ok "Text::CSV_XS"; plan skip_all => "Cannot load Text::CSV_XS" if $@; require "t/util.pl"; } $| = 1; my @binField = ("abc\0def\n\rghi", "ab\"ce,\032\"'", "\377"); my $csv = Text::CSV_XS->new ({ binary => 1 }); ok ($csv->combine (@binField), "combine ()"); my $string; is_binary ($string = $csv->string, qq("abc"0def\n\rghi","ab""ce,\032""'",\377), "string ()"); ok ($csv->parse ($string), "parse ()"); is ($csv->fields, scalar @binField, "field count"); my @field = $csv->fields (); for (0 .. $#binField) { is ($field[$_], $binField[$_], "Field $_"); } ok (1, "eol \\r\\n"); $csv->eol ("\r\n"); ok ($csv->combine (@binField), "combine ()"); is_binary ($csv->string, qq("abc"0def\n\rghi","ab""ce,\032""'",\377\r\n), "string ()"); ok (1, "eol \\n"); $csv->eol ("\n"); ok ($csv->combine (@binField), "combine ()"); is_binary ($csv->string, qq("abc"0def\n\rghi","ab""ce,\032""'",\377\n), "string ()"); ok (1, "eol ,xxxxxxx\\n"); $csv->eol (",xxxxxxx\n"); ok ($csv->combine (@binField), "combine ()"); is_binary ($csv->string, qq("abc"0def\n\rghi","ab""ce,\032""'",\377,xxxxxxx\n), "string ()"); $csv->eol ("\n"); ok (1, "quote_char undef"); $csv->quote_char (undef); ok ($csv->combine ("abc","def","ghi"), "combine"); is ($csv->string, "abc,def,ghi\n", "string ()"); # Ken's test ok (1, "always_quote"); my $csv2 = Text::CSV_XS->new ({ always_quote => 1 }); ok ($csv2, "new ()"); ok ($csv2->combine ("abc","def","ghi"), "combine ()"); is ($csv2->string, '"abc","def","ghi"', "string ()"); Text-CSV_XS-1.26/t/70_rt.t0000644000031300001440000006633212753265123015531 0ustar00merijnusers00000000000000#!/usr/bin/perl use strict; use warnings; #use Test::More "no_plan"; use Test::More tests => 20460; BEGIN { use_ok "Text::CSV_XS", (); plan skip_all => "Cannot load Text::CSV_XS" if $@; require "t/util.pl"; } my $tfn = "_70test.csv"; END { unlink $tfn, "_$tfn"; } my ($rt, %input, %desc); while () { if (s/^(x?[0-9]+)\s*-?\s*//) { chomp; $rt = $1; $desc{$rt} = $_; next; } s/\\([0-7]{1,3})/chr oct $1/ge; push @{$input{$rt}}, $_; } # Regression Tests based on RT reports { # http://rt.cpan.org/Ticket/Display.html?id=24386 $rt = 24386; # \t doesn't work in _XS, works in _PP my @lines = @{$input{$rt}}; ok (my $csv = Text::CSV_XS->new ({ sep_char => "\t" }), "RT-$rt: $desc{$rt}"); is ($csv->sep_char, "\t", "sep_char = TAB"); foreach my $line (0 .. $#lines) { ok ($csv->parse ($lines[$line]), "parse line $line"); ok (my @fld = $csv->fields, "Fields for line $line"); is (scalar @fld, 25, "Line $line has 25 fields"); # print STDERR "# $fld[2] - $fld[3]\t- $fld[4]\n"; } } { # http://rt.cpan.org/Ticket/Display.html?id=21530 $rt = 21530; # getline () does not return documented value at end of # filehandle IO::Handle was first released with perl 5.00307 open my $fh, ">", $tfn or die "$tfn: $!\n"; print $fh @{$input{$rt}}; close $fh; ok (my $csv = Text::CSV_XS->new ({ binary => 1 }), "RT-$rt: $desc{$rt}"); open $fh, "<", $tfn or die "$tfn: $!\n"; my $row; foreach my $line (1 .. 5) { ok ($row = $csv->getline ($fh), "getline $line"); is (ref $row, "ARRAY", "is arrayref"); is ($row->[0], $line, "Line $line"); } ok (eof $fh, "EOF"); is ($row = $csv->getline ($fh), undef, "getline EOF"); close $fh; unlink $tfn; } { # http://rt.cpan.org/Ticket/Display.html?id=21530 $rt = 18703; # Fails to use quote_char of '~' my ($csv, @fld); ok ($csv = Text::CSV_XS->new ({ quote_char => "~" }), "RT-$rt: $desc{$rt}"); is ($csv->quote_char, "~", "quote_char is '~'"); ok ($csv->parse ($input{$rt}[0]), "Line 1"); ok (@fld = $csv->fields, "Fields"); is (scalar @fld, 1, "Line 1 has only one field"); is ($fld[0], "Style Name", "Content line 1"); # The line has invalid escape. the escape should only be # used for the special characters ok (!$csv->parse ($input{$rt}[1]), "Line 2"); } { # http://rt.cpan.org/Ticket/Display.html?id=15076 $rt = 15076; # escape_char before characters that do not need to be escaped. my ($csv, @fld); ok ($csv = Text::CSV_XS->new ({ sep_char => ";", escape_char => "\\", allow_loose_escapes => 1, }), "RT-$rt: $desc{$rt}"); ok ($csv->parse ($input{$rt}[0]), "Line 1"); ok (@fld = $csv->fields, "Fields"); is (scalar @fld, 2, "Line 1 has two fields"); is ($fld[0], "Example", "Content field 1"); is ($fld[1], "It's an apostrophee", "Content field 2"); } { # http://rt.cpan.org/Ticket/Display.html?id=34474 $rt = 34474; # wish: integrate row-as-hashref feature from Parse::CSV open my $fh, ">", $tfn or die "$tfn: $!\n"; print $fh @{$input{$rt}}; close $fh; ok (my $csv = Text::CSV_XS->new (), "RT-$rt: $desc{$rt}"); is ($csv->column_names, undef, "No headers yet"); open $fh, "<", $tfn or die "$tfn: $!\n"; my $row; ok ($row = $csv->getline ($fh), "getline headers"); is ($row->[0], "code", "Header line"); $csv->column_names (@$row); is_deeply ([ $csv->column_names ], [ @$row ], "Keys set"); while (my $hr = $csv->getline_hr ($fh)) { ok (exists $hr->{code}, "Line has a code field"); like ($hr->{code}, qr/^[0-9]+$/, "Code is numeric"); ok (exists $hr->{name}, "Line has a name field"); like ($hr->{name}, qr/^[A-Z][a-z]+$/, "Name"); } close $fh; unlink $tfn; } { # http://rt.cpan.org/Ticket/Display.html?id=38960 $rt = 38960; # print () on invalid filehandle warns and returns success open my $fh, ">", $tfn or die "$tfn: $!\n"; print $fh ""; close $fh; my $err = ""; open $fh, "<", $tfn or die "$tfn: $!\n"; ok (my $csv = Text::CSV_XS->new (), "RT-$rt: $desc{$rt}"); local $SIG{__WARN__} = sub { $err = "Warning" }; ok (!$csv->print ($fh, [ 1 .. 4 ]), "print ()"); is ($err, "Warning", "IO::Handle triggered a warning"); is (($csv->error_diag)[0], 2200, "error 2200"); close $fh; unlink $tfn; } { # http://rt.cpan.org/Ticket/Display.html?id=40507 $rt = 40507; # Parsing fails on escaped null byte ok (my $csv = Text::CSV_XS->new ({ binary => 1 }), "RT-$rt: $desc{$rt}"); my $str = $input{$rt}[0]; ok ($csv->parse ($str), "parse () correctly escaped NULL"); is_deeply ([ $csv->fields ], [ qq{Audit active: "TRUE \0}, qq{Desired:}, qq{Audit active: "TRUE \0} ], "fields ()"); $str = $input{$rt}[1]; is ($csv->parse ($str), 0, "parse () badly escaped NULL"); my @diag = $csv->error_diag; is ($diag[0], 2023, "Error 2023"); is ($diag[2], 23, "Position 23"); $csv->allow_loose_escapes (1); ok ($csv->parse ($str), "parse () badly escaped NULL"); } { # http://rt.cpan.org/Ticket/Display.html?id=42642 $rt = 42642; # failure on unusual quote/sep values SKIP: { $] < 5.008002 and skip "UTF8 unreliable in perl $]", 6; open my $fh, ">:raw", $tfn or die "$tfn: $!\n"; print $fh @{$input{$rt}}; close $fh; my ($sep, $quo) = ("\x14", "\xfe"); chop ($_ = "$_\x{20ac}") for $sep, $quo; ok (my $csv = Text::CSV_XS->new ({ binary => 1, sep_char => $sep }), "RT-$rt: $desc{$rt}"); ok ($csv->quote_char ($quo), "Set quote_char"); open $fh, "<:raw", $tfn or die "$tfn: $!\n"; ok (my $row = $csv->getline ($fh), "getline () with decode sep/quo"); $csv->error_diag (); close $fh; unlink $tfn; is_deeply ($row, [qw( DOG CAT WOMBAT BANDERSNATCH )], "fields ()"); ok ($csv->parse ($input{$rt}[1]), "parse () with decoded sep/quo"); is_deeply ([ $csv->fields ], [ 0..3 ], "fields ()"); } } { # http://rt.cpan.org/Ticket/Display.html?id=43927 $rt = 43927; # Is bind_columns broken or am I using it wrong? open my $fh, ">", $tfn or die "$tfn: $!\n"; print $fh @{$input{$rt}}; close $fh; my ($c1, $c2); ok (my $csv = Text::CSV_XS->new ({ binary => 1 }), "RT-$rt: $desc{$rt}"); ok ($csv->bind_columns (\$c1, \$c2), "bind columns"); open $fh, "<", $tfn or die "$tfn: $!\n"; ok (my $row = $csv->getline ($fh), "getline () with bound columns"); $csv->error_diag (); close $fh; unlink $tfn; is_deeply ($row, [], "should return empty ref"); is_deeply ([ $c1, $c2], [ 1, 2 ], "fields ()"); } { # http://rt.cpan.org/Ticket/Display.html?id=44402 $rt = 44402; # Unexpected results parsing tab-separated spaces open my $fh, ">", $tfn or die "$tfn: $!\n"; my @ws = ("", " ", " "); foreach my $f1 (@ws) { foreach my $f2 (@ws) { foreach my $f3 (@ws) { print $fh "$f1\t$f2\t$f3\r\n"; } } } close $fh; my $csv; ok ($csv = Text::CSV_XS->new ({ sep_char => "\t", }), "RT-$rt: $desc{$rt}"); open $fh, "<", $tfn or die "$tfn: $!\n"; while (my $row = $csv->getline ($fh)) { ok ($row, "getline $."); my @row = @$row; is ($#row, 2, "Got 3 fields"); like ($row[$_], qr{^ *$}, "field $_ with only spaces") for 0..2; } ok ($csv->eof, "read complete file"); close $fh; ok ($csv = Text::CSV_XS->new ({ sep_char => "\t", allow_whitespace => 1, }), "RT-$rt: $desc{$rt}"); open $fh, "<", $tfn or die "$tfn: $!\n"; while (my $row = $csv->getline ($fh)) { ok ($row, "getline $."); my @row = @$row; is ($#row, 2, "Got 3 fields"); is ($row[$_], "", "field $_ empty") for 0..2; } ok ($csv->eof, "read complete file"); close $fh; unlink $tfn; ok ($csv->parse (" \t \t "), "parse ()"); is_deeply ([$csv->fields],["","",""],"3 empty fields"); } { # Detlev reported an inconsistent difference between _XS and _PP $rt = "x1000"; open my $fh, ">", $tfn or die "$tfn: $!\n"; print $fh @{$input{$rt}}; close $fh; my ($c1, $c2); ok (my $csv = Text::CSV_XS->new ({ binary => 1, eol => "\n", sep_char => "\t", escape_char => undef, quote_char => undef, binary => 1 }), "RT-$rt: $desc{$rt}"); open $fh, "<", $tfn or die "$tfn: $!\n"; for (1 .. 4) { ok (my $row = $csv->getline ($fh), "getline ()"); is (scalar @$row, 27, "Line $_: 27 columns"); } for (5 .. 6) { ok (my $row = $csv->getline ($fh), "getline ()"); is (scalar @$row, 1, "Line $_: 1 column"); } $csv->error_diag (); close $fh; unlink $tfn; } { # Ruslan reported a case where only Text::CSV_PP misbehaved (regression test) $rt = "x1001"; open my $fh, ">", $tfn or die "$tfn: $!\n"; print $fh @{$input{$rt}}; close $fh; my ($c1, $c2); ok (my $csv = Text::CSV_XS->new (), "RT-$rt: $desc{$rt}"); open $fh, "<", $tfn or die "$tfn: $!\n"; for (1 .. 4) { ok (my $row = $csv->getline ($fh), "getline ($_)"); is (scalar @$row, 2, "Line $_: 2 columns"); my @exp = $_ <= 2 ? ("0", "A") : ("A", "0"); is_deeply ($row, \@exp, "@exp"); } close $fh; unlink $tfn; } { # http://rt.cpan.org/Ticket/Display.html?id=58356 $rt = "58356"; # Incorrect CSV generated if "quote_space => 0" ok (my $csv = Text::CSV_XS->new ({ binary => 1, quote_space => 0 }), "RT-$rt: $desc{$rt}"); my @list = ("a a", "b,b", "c ,c"); ok ($csv->combine (@list), "combine ()"); is ($csv->string, q{a a,"b,b","c ,c"}, "string ()"); } { # http://rt.cpan.org/Ticket/Display.html?id=61525 $rt = "61525"; # eol not working for values other than "\n"? # First try with eol in constructor foreach my $eol ("\n", "\r", "!") { $/ = "\n"; my $s_eol = _readable ($eol); ok (my $csv = Text::CSV_XS->new ({ binary => 1, sep_char => ":", quote_char => '"', escape_char => '"', eol => $eol, auto_diag => 1, }), "RT-$rt: $desc{$rt} - eol = $s_eol (1)"); open my $fh, ">", $tfn or die "$tfn: $!\n"; print $fh join $eol => qw( "a":"b" "c":"d" "e":"x!y" "!!":"z" ); close $fh; open $fh, "<", $tfn or die "$tfn: $!\n"; is_deeply ($csv->getline ($fh), [ "a", "b" ], "Pair 1"); is_deeply ($csv->getline ($fh), [ "c", "d" ], "Pair 2"); is_deeply ($csv->getline ($fh), [ "e", "x!y" ], "Pair 3"); is_deeply ($csv->getline ($fh), [ "!!", "z" ], "Pair 4"); is ($csv->getline ($fh), undef, "no more pairs"); ok ($csv->eof, "EOF"); close $fh; unlink $tfn; } # And secondly with eol as method only if not one of the defaults foreach my $eol ("\n", "\r", "!") { $/ = "\n"; my $s_eol = _readable ($eol); ok (my $csv = Text::CSV_XS->new ({ binary => 1, sep_char => ":", quote_char => '"', escape_char => '"', auto_diag => 1, }), "RT-$rt: $desc{$rt} - eol = $s_eol (2)"); $eol eq "!" and $csv->eol ($eol); open my $fh, ">", $tfn or die "$tfn: $!\n"; print $fh join $eol => qw( "a":"b" "c":"d" "e":"x!y" "!!":"z" ); close $fh; open $fh, "<", $tfn or die "$tfn: $!\n"; is_deeply ($csv->getline ($fh), [ "a", "b" ], "Pair 1"); is_deeply ($csv->getline ($fh), [ "c", "d" ], "Pair 2"); is_deeply ($csv->getline ($fh), [ "e", "x!y" ], "Pair 3"); is_deeply ($csv->getline ($fh), [ "!!", "z" ], "Pair 4"); is ($csv->getline ($fh), undef, "no more pairs"); ok ($csv->eof, "EOF"); close $fh; unlink $tfn; } } { # http://rt.cpan.org/Ticket/Display.html?id=74216 $rt = "74216"; # setting 'eol' affects global input record separator open my $fh, ">", $tfn or die "$tfn: $!\n"; print $fh @{$input{$rt}}; close $fh; my $slurp_check = sub { open $fh, "<", $tfn or die "$tfn: $!\n"; is (scalar @{[<$fh>]}, 4); close $fh; }; $slurp_check->(); my $crlf = "\015\012"; open my $fhx, ">", "_$tfn" or die "_$tfn: $!\n"; print $fhx "a,b,c" . $crlf . "1,2,3" . $crlf; close $fhx; open $fhx, "<", "_$tfn" or die "_$tfn: $!\n"; my $csv = Text::CSV_XS->new ({ eol => $crlf }); is_deeply ($csv->getline ($fhx), [qw( a b c )]); close $fhx; unlink "_$tfn"; $slurp_check->(); { local $/ = "\n"; $slurp_check->(); } } SKIP: { # http://rt.cpan.org/Ticket/Display.html?id=74220 $] < 5.008002 and skip "UTF8 unreliable in perl $]", 7; $rt = "74220"; # Text::CSV_XS can be made to produce bad strings my $csv = Text::CSV_XS->new ({ binary => 1 }); my $ax = chr (0xfa); my $bx = "foo"; # We set the UTF-8 flag on a string with no funny characters utf8::upgrade ($bx); is ($bx, "foo", "no funny characters in the string"); ok (utf8::valid ($ax), "first string correct in Perl"); ok (utf8::valid ($bx), "second string correct in Perl"); ok ($csv->combine ($ax, $bx), "combine ()"); ok (my $foo = $csv->string (), "string ()"); ok (utf8::valid ($foo), "is combined string correct inside Perl?"); is ($foo, qq{\xfa,foo}, "expected result"); } SKIP: { # http://rt.cpan.org/Ticket/Display.html?id=80680 (eval { require Encode; $Encode::VERSION } || "0.00") =~ m{^([0-9.]+)}; $1 < 2.47 and skip "Encode is too old for these tests", 20000; $] < 5.008008 and skip "UTF8+Encode unreliable in perl $]", 20000; $rt = "80680"; # Text::CSV_XS produces garbage on some data my $csv = Text::CSV_XS->new ({ binary => 1 }); my $txt = "\x{415}\x{43a}\x{438}\x{43d}\x{431}\x{443}\x{440}\x{433}\x{2116}"; BIG_LOOP: foreach my $n (1 .. 5000) { foreach my $e (0 .. 3) { my $data = ("a" x $e) . ($txt x $n); my $enc = Encode::encode ("UTF-8", $data); my $exp = qq{1,"$enc"}; my $out = ""; open my $fh, ">:encoding(utf-8)", \$out or die "IO: $!\n"; $csv->print ($fh, [ 1, $data ]); close $fh; my $l = length ($out); if ($out eq $exp) { ok (1, "Buffer boundary check $n/$e ($l)"); next; } is ($out, $exp, "Data $n/$e ($l)"); last BIG_LOOP; } } } { # http://rt.cpan.org/Ticket/Display.html?id=81295 $rt = 81295; # escaped sep_char discarded when only item in unquoted field my $csv = Text::CSV_XS->new ({ escape_char => "\\", auto_diag => 1 }); ok ($csv->parse ($input{$rt}[0]), "parse without allow_unquoted_escape"); is_deeply ([ $csv->fields ], [ 1, ",", 3 ], "escaped sep in quoted field"); $csv->allow_unquoted_escape (1); ok ($csv->parse ($input{$rt}[1]), "parse with allow_unquoted_escape"); is_deeply ([ $csv->fields ], [ 1, ",", 3 ], "escaped sep in unquoted field"); } { # http://rt.cpan.org/Ticket/Display.html?id=113279 $rt = 113279; # Failed parse + bind_columns causes memory corruption my $csv = Text::CSV_XS->new (); is ($csv->parse ($input{$rt}[0]), 0, "parse invalid content"); is (0 + $csv->error_diag, 2034, "Error is kept"); my $fld; ok ($csv->bind_columns (\$fld), "bound column"); is ($csv->parse ($input{$rt}[0]), 0, "parse invalid content to bc"); is (0 + $csv->error_diag, 2034, "Error is kept"); } { # http://rt.cpan.org/Ticket/Display.html?id=115953 $rt = 115953; # Space stripped from middle of field value with allow_whitespace and allow_loose_quotes my $csv = Text::CSV_XS->new ({ allow_loose_quotes => 1, escape_char => undef, allow_whitespace => 1, }); ok ($csv->parse ($input{$rt}[0]), "parse valid content"); is_deeply ([ $csv->fields ], [ q{foo "bar" baz} ], "Data"); } __END__ 24386 - \t doesn't work in _XS, works in _PP VIN StockNumber Year Make Model MD Engine EngineSize Transmission DriveTrain Trim BodyStyle CityFuel HWYFuel Mileage Color InteriorColor InternetPrice RetailPrice Notes ShortReview Certified NewUsed Image_URLs Equipment 1HGCM66573A030460 1621HA 2003 HONDA ACCORD EX V-6 ACCORD DOHC 16-Valve VTEC 3.0L 5-Speed Automatic EX V-6 4DR 21 30 70940 Gray Gray 15983 15983 AutoWeek calls the 2003 model the best Accord yet * Fun to hustle down a twisty road according to Road & Track * Sedan perfection according to Car and Driver * Named on the 2003 Car and Driver Ten Best List * Named a Consumer Guide Best Buy for 2003 * 0 0 http://vin.windowstickers.biz/incoming/w_1HGCM66573A030460_1.JPG, http://vin.windowstickers.biz/incoming/w_1HGCM66573A030460_2.JPG, http://vin.windowstickers.biz/incoming/w_1HGCM66573A030460_3.JPG, http://vin.windowstickers.biz/incoming/w_1HGCM66573A030460_4.JPG, http://vin.windowstickers.biz/incoming/w_1HGCM66573A030460_5.JPG, http://vin.windowstickers.biz/incoming/w_1HGCM66573A030460_6.JPG, http://vin.windowstickers.biz/incoming/w_1HGCM66573A030460_7.JPG, http://vin.windowstickers.biz/incoming/w_1HGCM66573A030460_8.JPG 120-Watt AM/FM Stereo System,3-Point Seat Belts,4-Wheel Double Wishbone Suspension,6-Disc In-Dash Compact Disc Changer,6-Speaker Audio System,8-Way Power Adjustable Driver's Seat,Air Conditioning w/Air-Filtration System,Anti-Lock Braking System,Automatic-Up/Down Driver's Window,Center Console Armrest w/Storage,Child Safety Rear Door Locks,Cruise Control,Driver & Front Passenger Dual-Stage Airbags,Electronic Remote Trunk Release,Emergency Trunk Release,Fold-Down Rear Seat Center Armrest,Fold-Down Rear Seatback w/Lock,Front Seat Side-Impact Airbags,Immobilizer Theft Deterrent System,LATCH Lower Anchor & Tethers For Children,Power Driver's Seat Height Adjustment,Power Exterior Mirrors,Power Moonroof w/Tilt Feature,Power Windows & Door Locks,Power-Assisted 4-Wheel Disc Brakes,Rear Window Defroster w/Timer,Remote Keyless Entry System w/Window Control,Security System,Tilt & Telescopic Steering Column,Traction Control System,Variable Intermittent Windshield Wipers,Variable-Assist Power Rack & Pinion Steering 1FTRW12W66KA65476 4110J 2006 FORD F-150 XLT CREW 5.5SB 4X2 F-150 SOHC Triton V8 4.6L 4-Speed Automatic 4X2 XLT CREW 5.5SB 15 19 20334 Black Gray 22923 22923 Named a Consumer Guide 2005 & 2006 Best Buy * Named Best Pickup by Car and Driver * The Detroit Free Press calls F-150 the best pickup truck ever * The Detroit News calls F-150 the best America has to offer * 0 0 http://vin.windowstickers.biz/incoming/w_1FTRW12W66KA65476_1.JPG, http://vin.windowstickers.biz/incoming/w_1FTRW12W66KA65476_2.JPG, http://vin.windowstickers.biz/incoming/w_1FTRW12W66KA65476_3.JPG, http://vin.windowstickers.biz/incoming/w_1FTRW12W66KA65476_4.JPG, http://vin.windowstickers.biz/incoming/w_1FTRW12W66KA65476_5.JPG, http://vin.windowstickers.biz/incoming/w_1FTRW12W66KA65476_6.JPG, http://vin.windowstickers.biz/incoming/w_1FTRW12W66KA65476_7.JPG, http://vin.windowstickers.biz/incoming/w_1FTRW12W66KA65476_8.JPG, http://vin.windowstickers.biz/incoming/w_1FTRW12W66KA65476_9.JPG 4-Pin Trailer Tow Connector,Air Conditioning,AM/FM Stereo w/Single Compact Disc Player,Auxiliary Power Outlets,Cargo Box Light & Tie-Downs,Child Safety Seat Lower Anchors & Tether Anchors,Crash Severity Sensor,Cruise Control,Dual-Stage Driver & Front-Right Passenger Airbags,Electronic Brake Force Distribution,Exterior Temperature & Compass Display,Fail-Safe Engine Cooling System,Front Dome Light w/Integrated Map Lights,Front Power Points,Front Seat Personal Safety System,Front-Passenger Sensing System,Manual Day/Night Interior Rearview Mirror,Oil Pressure & Coolant Temperature Gauges,Power 4-Wheel Disc Anti-Lock Brakes,Power Door Locks,Power Exterior Mirrors,Power Front Windows w/One-Touch Driver Side,Power Rack & Pinion Steering,Remote Keyless Entry System,Removable Tailgate w/Key Lock,Securilock Passive Anti-Theft System,Spare Tire w/Wheel Lock,Speed-Dependent Interval Windshield Wipers,Tailgate Assist System,Tilt Steering Wheel,Visors w/Covered Vanity Mirrors 5GZCZ23D03S826657 2111A 2003 SATURN VUE BASE FWD VUE DOHC 4-cylinder 2.2L 5-Speed Manual FWD BASE 5DR 23 28 74877 Silver Gray 11598 11598 Edmunds 2003 Buyer's Guide calls Vue a well-thought-out and capable mini sport utility vehicle, with large doors for ease of entry and exit, extensive cabin space and excellent crash test scores * 0 0 http://vin.windowstickers.biz/incoming/w_5GZCZ23D03S826657_1.JPG, http://vin.windowstickers.biz/incoming/w_5GZCZ23D03S826657_2.JPG, http://vin.windowstickers.biz/incoming/w_5GZCZ23D03S826657_3.JPG, http://vin.windowstickers.biz/incoming/w_5GZCZ23D03S826657_4.JPG, http://vin.windowstickers.biz/incoming/w_5GZCZ23D03S826657_5.JPG, http://vin.windowstickers.biz/incoming/w_5GZCZ23D03S826657_6.JPG, http://vin.windowstickers.biz/incoming/w_5GZCZ23D03S826657_7.JPG, http://vin.windowstickers.biz/incoming/w_5GZCZ23D03S826657_8.JPG 70/30 Split Folding Rear Seatback,AM/FM Stereo System,Center Console w/Storage,Center High-Mounted Rear Stop Light,CFC-Free Air Conditioning,Cloth Upholstery,Daytime Running Lights,Dent-Resistant Polymer Body Panels,Distributorless Ignition System,Driver & Front Passenger Frontal Airbags,Electric Power Rack-And-Pinion Steering,Fold-Flat Front Passenger Seat,Front & Rear Crumple Zones,Front & Rear Cup Holders,Front Bucket Seats,Front-Wheel Drive,Independent Front & Rear Suspension,Interval Rear Window Wiper/Washer,Interval Windshield Wipers,LATCH Child Safety Seat Anchor System,Platinum-Tipped Spark Plugs,Power Front Disc/Rear Drum Brakes,Rear Privacy Glass,Rear Window Defogger,Remote Rear Liftgate Release,Roof Rack,Sequential Fuel Injection,Side-Impact Door Beams,Tachometer,Theft-Deterrent System,Tilt Adjustable Steering Wheel,Visor Vanity Mirrors 1FMZU67K15UB18754 4067T 2005 FORD EXPLORER SPORT TRAC XLT 4X2 EXPLORER SPORT TRAC Flex Fuel SOHC V6 4.0L 5-Speed Automatic 4X2 XLT 4DR 16 21 12758 Maroon Gray 20995 20995 Consumer Guide 2005 reports Sport Trac offers more passenger space than other crew-cab pick-ups and is a good choice as a multipurpose vehicle * Consumer Guide 2005 credits Sport Trac with good in-cabin storage * 0 0 http://vin.windowstickers.biz/incoming/w_1FMZU67K15UB18754_1.JPG, http://vin.windowstickers.biz/incoming/w_1FMZU67K15UB18754_2.JPG, http://vin.windowstickers.biz/incoming/w_1FMZU67K15UB18754_3.JPG, http://vin.windowstickers.biz/incoming/w_1FMZU67K15UB18754_4.JPG, http://vin.windowstickers.biz/incoming/w_1FMZU67K15UB18754_5.JPG, http://vin.windowstickers.biz/incoming/w_1FMZU67K15UB18754_6.JPG, http://vin.windowstickers.biz/incoming/w_1FMZU67K15UB18754_7.JPG 3-Point Front & Rear Seatbelts,4-Speaker Audio System,Air Conditioning,AM/FM Stereo w/Compact Disc Player,Belt-Minder Safety Belt Reminder System,Child Safety Rear Door Locks,Cloth Upholstery,Cruise Control,Driver & Front Passenger Airbags,Driver Door Keyless Entry Keypad,Headlights-On Alert Chime,Height-Adjustable Front Seatbelts,LATCH Child Seat Lower Anchors & Tether Anchors,Locking Tailgate,Low-Back Front Bucket Seats,Lower Bodyside Moldings,Manual Day/Night Interior Rearview Mirror,Power 4-Wheel Disc Anti-Lock Brakes,Power Door Locks,Power Exterior Mirrors,Power Rack & Pinion Steering,Power Rear Window w/Anti-Pinch,Power Windows w/Driver One-Touch Down,Remote Keyless Entry System,Roof Rails,Securilock Passive Anti-Theft System,Side-Intrusion Door Beams,Sirius Satellite Radio/MP3 Capability,Solar-Tinted Glass Windows,Speed-Sensitive Intermittent Windshield Wipers,Tachometer,Tilt Steering Wheel 1J4GK48K96W108753 4068T 2006 JEEP LIBERTY SPORT 4X2 LIBERTY SOHC 12-valve V6 3.7L 4-Speed Automatic 4X2 SPORT 5DR 17 22 12419 Silver Gray 16999 16999 Named on the Automobile Magazine 50 Great New Cars List * Motor Trend reports Liberty fulfills the original go-anywhere mission of SUVs without fail or compromise * A Consumer Guide 2005 & 2006 Recommended Buy * 0 0 http://vin.windowstickers.biz/incoming/w_1J4GK48K96W108753_1.JPG, http://vin.windowstickers.biz/incoming/w_1J4GK48K96W108753_2.JPG, http://vin.windowstickers.biz/incoming/w_1J4GK48K96W108753_3.JPG, http://vin.windowstickers.biz/incoming/w_1J4GK48K96W108753_4.JPG, http://vin.windowstickers.biz/incoming/w_1J4GK48K96W108753_5.JPG, http://vin.windowstickers.biz/incoming/w_1J4GK48K96W108753_6.JPG, http://vin.windowstickers.biz/incoming/w_1J4GK48K96W108753_7.JPG, http://vin.windowstickers.biz/incoming/w_1J4GK48K96W108753_8.JPG, http://vin.windowstickers.biz/incoming/w_1J4GK48K96W108753_9.JPG 12-Volt Cargo Area Power Outlet,65/35 Split-Folding Rear Bench Seat,6-Speaker Audio System,Advanced Multi-Stage Frontal Airbags,Air Conditioning,All-Wheel Traction Control System,AM/FM Stereo w/Compact Disc Player,Center Console 12-Volt Power Outlet,Child Safety Rear Door Locks,Cloth Sun Visors w/Pull-Out Sunshade,Cloth Upholstery,Coolant Temperature Gauge,Electric Rear Window Defroster,Electronic Stability Program,Enhanced Accident Response System,Halogen Headlights w/Delay-Off Feature,LATCH Child Safety Seat Anchor System,Manual Day/Night Interior Rearview Mirror,Power 4-Wheel Disc Anti-Lock Brake System,Power Door Locks,Power Exterior Mirrors,Power Rack & Pinion Steering,Power Windows w/Front One-Touch Down,Rear Window Wiper/Washer,Remote Keyless Entry System,Roof Side Rails,Sentry Key Engine Immobilizer,Spare Tire Carrier,Tachometer,Tilt Steering Column,Tinted Windshield Glass,Variable Speed Intermittent Windshield Wipers 21530 - getline () does not return documented value at end of filehandle 1,1,2,3,4,5 2,1,2,3,4,5 3,1,2,3,4,5 4,1,2,3,4,5 5,1,2,3,4,5 18703 - Fails to use quote_char of '~' ~Style Name~ ~5dr Crew Cab 130" WB 2WD LS~ ",~"~,~""~,~"""~,,~~, 15076 - escape_char before characters that do not need to be escaped. "Example";"It\'s an apostrophee" 34474 - wish: integrate row-as-hashref feature from Parse::CSV code,name,price,description 1,Dress,240.00,"Evening gown" 2,Drinks,82.78,"Drinks" 3,Sex,-9999.99,"Priceless" 38960 - print () on invalid filehandle warns and returns success 40507 - Parsing fails on escaped null byte "Audit active: ""TRUE "0","Desired:","Audit active: ""TRUE "0" "Audit active: ""TRUE "\0","Desired:","Audit active: ""TRUE "\0" 42642 - failure on unusual quote/sep values DOGCATWOMBATBANDERSNATCH 0123 43927 - Is bind_columns broken or am I using it wrong? 1,2 44402 - Unexpected results parsing tab-separated spaces x1000 - Detlev reported inconsistent behavior between XS and PP B:033_02_ -drop, +drop animal legs @p 02-033.bmp @p 02-033.bmp  \x{A} 1 :c/b01:!1 ! 13 !6.!6 :b/b01:0 B:033_02_ R#012a 2 B:034_02c diagonal, trac -bound up @p 02-034c.bmp @p 02-034c.bmp  Found through e_sect2.pdf as U+F824 (,) and U+2E88 (⺈,) but won't display \x{A} 1 :c/b01:!1 ! 11 !10 :b/b01:0 2E88 B:034_02c R#018b 2 B:035_02_ +drop, -drop fission 丷  Aufgrund folgender Fälle definiere ich einen neuen Baustein, der simp. mit "horns&" identisch ist.\x{A}隊队 (jap.: pinnacle, horns&sow)\x{A}曾曾兌兑\x{A}über "golden calf":\x{A}送送 1 :c/b01:!1 ! 11 !10 :b/b01:0 4E37 B:035_02_ 2 B:035_03_ fission, one horns @p 03-035.bmp @p 03-035.bmp  obsolete Heising explanation for form without the horizontal line: Variante von "horns", die erscheint, wenn darunter keine horizontale Linie steht\x{A}\x{A}Found through e_sect2.pdf as U+F7EA (??,) but won't display \x{A} 1 :c/b01:!1 ! 11 !10 :b/b01:0 B:035_03_ 3 --------------090302050909040309030109-- 58356 - Incorrect CSV generated if "quote_space => 0" 61525 - eol not working for values other than "\n"? 74216 - setting 'eol' affects global input record separator 1,2 3,4 5,6 7,8 74330 - Text::CSV_XS can be made to produce bad strings 80680 - Text::CSV_XS produces garbage on some data 81295 - escaped sep_char discarded when only item in unquoted field 1,"\,",3 1,\,,3 x1001 - Lines starting with "0" (Ruslan Dautkhanov) "0","A" "0","A" "A","0" "A","0" 113279 - Failed parse + bind_columns causes memory corruption foo "bar" 115953 - Space stripped from middle of field value with allow_whitespace and allow_loose_quotes "foo "bar" baz" Text-CSV_XS-1.26/t/22_scalario.t0000644000031300001440000001416512753265123016673 0ustar00merijnusers00000000000000#!/usr/bin/perl use strict; use warnings; $| = 1; use Config; use Test::More; BEGIN { unless (exists $Config{useperlio} && defined $Config{useperlio} && $] >= 5.008 && # perlio was experimental in 5.6.2, but not reliable $Config{useperlio} eq "define") { plan skip_all => "No reliable perlIO available"; } else { plan tests => 132; } } BEGIN { use_ok "Text::CSV_XS"; plan skip_all => "Cannot load Text::CSV_XS" if $@; require "t/util.pl"; } $/ = "\n"; $\ = undef; my $io; my $io_str = ""; my $csv = Text::CSV_XS->new (); open $io, ">", \$io_str or die "IO: $!"; ok (!$csv->print ($io, ["abc", "def\007", "ghi"]), "print bad character"); close $io; for ( [ 1, 1, 1, '""' ], [ 2, 1, 1, '', '' ], [ 3, 1, 0, '', 'I said, "Hi!"', '' ], [ 4, 1, 0, '"', 'abc' ], [ 5, 1, 0, 'abc', '"' ], [ 6, 1, 1, 'abc', 'def', 'ghi' ], [ 7, 1, 1, "abc\tdef", 'ghi' ], [ 8, 1, 0, '"abc' ], [ 9, 1, 0, 'ab"c' ], [ 10, 1, 0, '"ab"c"' ], [ 11, 0, 0, qq("abc\nc") ], [ 12, 1, 1, q(","), ',' ], [ 13, 1, 0, qq("","I said,\t""Hi!""",""), '', qq(I said,\t"Hi!"), '' ], ) { my ($tst, $validp, $validg, @arg, $row) = @$_; open $io, ">", \$io_str or die "IO: $!"; is ($csv->print ($io, \@arg), $validp||"", "$tst - print ()"); close $io; open $io, ">", \$io_str or die "IO: $!"; print $io join ",", @arg; close $io; open $io, "<", \$io_str or die "IO: $!"; $row = $csv->getline ($io); unless ($validg) { is ($row, undef, "$tst - false getline ()"); next; } ok ($row, "$tst - good getline ()"); $tst == 12 and @arg = (",", "", ""); foreach my $a (0 .. $#arg) { (my $exp = $arg[$a]) =~ s/^"(.*)"$/$1/; is ($row->[$a], $exp, "$tst - field $a"); } } # This test because of a problem with DBD::CSV ok (1, "Tests for DBD::CSV"); open $io, ">", \$io_str or die "IO: $!"; $csv->binary (1); $csv->eol ("\r\n"); ok ($csv->print ($io, [ "id", "name" ]), "Bad character"); ok ($csv->print ($io, [ 1, "Alligator Descartes" ]), "Name 1"); ok ($csv->print ($io, [ "3", "Jochen Wiedmann" ]), "Name 2"); ok ($csv->print ($io, [ 2, "Tim Bunce" ]), "Name 3"); ok ($csv->print ($io, [ " 4", "Andreas Knig" ]), "Name 4"); ok ($csv->print ($io, [ 5 ]), "Name 5"); close $io; my $expected = <<"CONTENTS"; id,name\015 1,"Alligator Descartes"\015 3,"Jochen Wiedmann"\015 2,"Tim Bunce"\015 " 4","Andreas Knig"\015 5\015 CONTENTS open $io, "<", \$io_str or die "IO: $!"; my $content = do { local $/; <$io> }; close $io; is ($content, $expected, "Content"); open $io, ">", \$io_str or die "IO: $!"; print $io $content; close $io; open $io, "<", \$io_str or die "IO: $!"; my $fields; print "# Retrieving data\n"; for (0 .. 5) { ok ($fields = $csv->getline ($io), "Fetch field $_"); is ($csv->eof, "", "EOF"); print "# Row $_: $fields (@$fields)\n"; } is ($csv->getline ($io), undef, "Fetch field 6"); is ($csv->eof, 1, "EOF"); { ok (my $csv = Text::CSV_XS->new ({ binary => 1, eol => "\n" }), "new csv"); my ($out1, $out2, @fld, $fh) = ("", "", qw( 1 aa 3.14 ahhrg )); open $fh, ">", \$out1 or die "IO: $!"; ok ($csv->print ($fh, \@fld), "Add line $_") for 1..3; close $fh; $csv->bind_columns (\(@fld)); open $fh, ">", \$out2 or die "IO: $!"; ok ($csv->print ($fh, \@fld), "Add line $_") for 1..3; close $fh; is ($out2, $out1, "ignoring bound columns"); $out2 = ""; open $fh, ">", \$out2 or die "IO: $!"; ok ($csv->print ($fh, undef), "Add line $_") for 1..3; close $fh; is ($out2, $out1, "using bound columns"); } # Edge cases $csv = Text::CSV_XS->new ({ escape_char => "+" }); for ([ 1, 1, 0, "\n" ], [ 2, 1, 0, "+\n" ], [ 3, 1, 0, "+" ], [ 4, 0, 2021, qq{"+"\n} ], [ 5, 0, 2025, qq{"+\n} ], [ 6, 0, 2011, qq{""+\n} ], [ 7, 0, 2027, qq{"+"} ], [ 8, 0, 2024, qq{"+} ], [ 9, 0, 2011, qq{""+} ], [ 10, 0, 2037, "\r" ], [ 11, 0, 2031, "\r\r" ], [ 12, 0, 2032, "+\r\r" ], [ 13, 0, 2032, "+\r\r+" ], [ 14, 0, 2022, qq{"\r"} ], [ 15, 0, 2022, qq{"\r\r" } ], [ 16, 0, 2022, qq{"\r\r"\t} ], [ 17, 0, 2025, qq{"+\r\r"} ], [ 18, 0, 2025, qq{"+\r\r+"} ], [ 19, 0, 2022, qq{"\r"\r} ], [ 20, 0, 2022, qq{"\r\r"\r} ], [ 21, 0, 2025, qq{"+\r\r"\r} ], [ 22, 0, 2025, qq{"+\r\r+"\r} ], ) { my ($tst, $valid, $err, $str) = @$_; $io_str = $str; open $io, "<", \$io_str or die "IO: $!"; binmode $io; my $row = $csv->getline ($io); close $io; my @err = $csv->error_diag; my $sstr = _readable ($str); ok ($valid ? $row : !$row, "$tst - getline ESC +, '$sstr'"); is ($err[0], $err, "Error expected $err"); } { ok (my $csv = Text::CSV_XS->new, "new for sep="); open my $fh, "<", \qq{sep=;\n"a b";3\n} or die "IO: $!"; is_deeply ($csv->getline_all ($fh), [["a b", 3]], "valid sep="); is (($csv->error_diag)[0], 2012, "EOF"); } { ok (my $csv = Text::CSV_XS->new, "new for sep="); open my $fh, "<", \qq{sep=;\n"a b",3\n} or die "IO: $!"; is_deeply (eval { $csv->getline_all ($fh); }, [], "invalid sep="); is (($csv->error_diag)[0], 2023, "error"); } { ok (my $csv = Text::CSV_XS->new, "new for sep="); open my $fh, "<", \qq{sep=XX\n"a b"XX3\n} or die "IO: $!"; is_deeply (eval { $csv->getline_all ($fh); }, [["a b", 3]], "multibyte sep="); is (($csv->error_diag)[0], 2012, "error"); } { ok (my $csv = Text::CSV_XS->new, "new for sep="); # To check that it is *only* supported on the first line open my $fh, "<", \qq{sep=;\n"a b";3\nsep=,\n"a b",3\n} or die "IO: $!"; is_deeply ($csv->getline_all ($fh), [["a b","3"],["sep=,"]], "sep= not on 1st line"); is (($csv->error_diag)[0], 2023, "error"); } { ok (my $csv = Text::CSV_XS->new, "new for sep="); my $sep = "#" x 80; open my $fh, "<", \qq{sep=$sep\n"a b",3\n2,3\n} or die "IO: $!"; my $r = $csv->getline_all ($fh); is_deeply ($r, [["sep=$sep"],["a b","3"],[2,3]], "sep= too long"); is (($csv->error_diag)[0], 2012, "EOF"); } Text-CSV_XS-1.26/t/21_lexicalio.t0000644000031300001440000001030312753265123017034 0ustar00merijnusers00000000000000#!/usr/bin/perl use strict; use warnings; use Test::More tests => 105; BEGIN { use_ok "Text::CSV_XS"; plan skip_all => "Cannot load Text::CSV_XS" if $@; require "t/util.pl"; } $| = 1; $/ = "\n"; $\ = undef; my $io; my $tfn = "_21test.csv"; END { -f $tfn and unlink $tfn; } my $csv = Text::CSV_XS->new (); my $UTF8 = ($ENV{LANG} || "C").($ENV{LC_ALL} || "C") =~ m/utf-?8/i ? 1 : 0; open $io, ">", $tfn or die "$tfn: $!"; ok (!$csv->print ($io, ["abc", "def\007", "ghi"]), "print bad character"); close $io; for ( [ 1, 1, 1, '""' ], [ 2, 1, 1, '', '' ], [ 3, 1, 0, '', 'I said, "Hi!"', '' ], [ 4, 1, 0, '"', 'abc' ], [ 5, 1, 0, 'abc', '"' ], [ 6, 1, 1, 'abc', 'def', 'ghi' ], [ 7, 1, 1, "abc\tdef", 'ghi' ], [ 8, 1, 0, '"abc' ], [ 9, 1, 0, 'ab"c' ], [ 10, 1, 0, '"ab"c"' ], [ 11, 0, 0, qq("abc\nc") ], [ 12, 1, 1, q(","), ',' ], [ 13, 1, 0, qq("","I said,\t""Hi!""",""), '', qq(I said,\t"Hi!"), '' ], ) { my ($tst, $validp, $validg, @arg, $row) = @$_; open $io, ">", $tfn or die "$tfn: $!"; is ($csv->print ($io, \@arg), $validp||"", "$tst - print ()"); close $io; open $io, ">", $tfn or die "$tfn: $!"; print $io join ",", @arg; close $io; open $io, "<", $tfn or die "$tfn: $!"; $row = $csv->getline ($io); unless ($validg) { is ($row, undef, "$tst - false getline ()"); next; } ok ($row, "$tst - good getline ()"); $tst == 12 and @arg = (",", "", ""); foreach my $a (0 .. $#arg) { (my $exp = $arg[$a]) =~ s/^"(.*)"$/$1/; is ($row->[$a], $exp, "$tst - field $a"); } } unlink $tfn; # This test because of a problem with DBD::CSV ok (1, "Tests for DBD::CSV"); open $io, ">", $tfn or die "$tfn: $!"; $csv->binary (1); $csv->eol ("\r\n"); ok ($csv->print ($io, [ "id", "name" ]), "Bad character"); ok ($csv->print ($io, [ 1, "Alligator Descartes" ]), "Name 1"); ok ($csv->print ($io, [ "3", "Jochen Wiedmann" ]), "Name 2"); ok ($csv->print ($io, [ 2, "Tim Bunce" ]), "Name 3"); ok ($csv->print ($io, [ " 4", "Andreas Knig" ]), "Name 4"); ok ($csv->print ($io, [ 5 ]), "Name 5"); close $io; my $expected = <<"CONTENTS"; id,name\015 1,"Alligator Descartes"\015 3,"Jochen Wiedmann"\015 2,"Tim Bunce"\015 " 4","Andreas Knig"\015 5\015 CONTENTS open $io, "<", $tfn or die "$tfn: $!"; my $content = do { local $/; <$io> }; close $io; is ($content, $expected, "Content"); open $io, ">", $tfn or die "$tfn: $!"; print $io $content; close $io; open $io, "<", $tfn or die "$tfn: $!"; my $fields; print "# Retrieving data\n"; for (0 .. 5) { ok ($fields = $csv->getline ($io), "Fetch field $_"); is ($csv->eof, "", "EOF"); print "# Row $_: $fields (@$fields)\n"; } is ($csv->getline ($io), undef, "Fetch field 6"); is ($csv->eof, 1, "EOF"); # Edge cases $csv = Text::CSV_XS->new ({ escape_char => "+" }); for ([ 1, 1, 0, "\n" ], [ 2, 1, 0, "+\n" ], [ 3, 1, 0, "+" ], [ 4, 0, 2021, qq{"+"\n} ], [ 5, 0, 2025, qq{"+\n} ], [ 6, 0, 2011, qq{""+\n} ], [ 7, 0, 2027, qq{"+"} ], [ 8, 0, 2024, qq{"+} ], [ 9, 0, 2011, qq{""+} ], [ 10, 0, 2037, "\r" ], [ 11, 0, 2031, "\r\r" ], [ 12, 0, 2032, "+\r\r" ], [ 13, 0, 2032, "+\r\r+" ], [ 14, 0, 2022, qq{"\r"} ], [ 15, 0, 2022, qq{"\r\r" } ], [ 16, 0, 2022, qq{"\r\r"\t} ], [ 17, 0, 2025, qq{"+\r\r"} ], [ 18, 0, 2025, qq{"+\r\r+"} ], [ 19, 0, 2022, qq{"\r"\r} ], [ 20, 0, 2022, qq{"\r\r"\r} ], [ 21, 0, 2025, qq{"+\r\r"\r} ], [ 22, 0, 2025, qq{"+\r\r+"\r} ], ) { my ($tst, $valid, $err, $str) = @$_; my $raw = $] < 5.008 ? "" : ":raw"; open my $io, ">$raw", $tfn or die "$tfn: $!"; print $io $str; close $io; open $io, "<$raw", $tfn or die "$tfn: $!"; my $row = $csv->getline ($io); close $io; my @err = $csv->error_diag; my $sstr = _readable ($str); SKIP: { $tst == 10 && $] >= 5.008 && $] < 5.008003 && $UTF8 and skip "Be reasonable, this perl version does not do Unicode reliable", 2; ok ($valid ? $row : !$row, "$tst - getline ESC +, '$sstr'"); is ($err[0], $err, "Error expected $err"); } } Text-CSV_XS-1.26/t/77_getall.t0000644000031300001440000000403512753265123016353 0ustar00merijnusers00000000000000#!/usr/bin/perl use strict; use warnings; use Test::More tests => 61; BEGIN { require_ok "Text::CSV_XS"; plan skip_all => "Cannot load Text::CSV_XS" if $@; require "t/util.pl"; } $| = 1; my $tfn = "_77test.csv"; END { -f $tfn and unlink $tfn; } my @testlist = ( [ 1, "a", "\x01", "A" ], [ 2, "b", "\x02", "B" ], [ 3, "c", "\x03", "C" ], [ 4, "d", "\x04", "D" ], ); my @list; sub do_tests { my $sub = shift; $sub->(\@list); $sub->(\@list, 0); $sub->([@list[2,3]], 2); $sub->([], 0, 0); $sub->(\@list, 0, 10); $sub->([@list[0,1]], 0, 2); $sub->([@list[1,2]], 1, 2); $sub->([@list[1..3]], -3); $sub->([@list[1,2]], -3, 2); $sub->([@list[1..3]], -3, 3); } # do_tests foreach my $eol ("\n", "\r") { @list = @testlist; { ok (my $csv = Text::CSV_XS->new ({ binary => 1, eol => $eol }), "csv out EOL "._readable ($eol)); open my $fh, ">", $tfn or die "$tfn: $!"; ok ($csv->print ($fh, $_), "write $_->[0]") for @list; close $fh; } { ok (my $csv = Text::CSV_XS->new ({ binary => 1 }), "csv in"); do_tests (sub { my ($expect, @args) = @_; open my $fh, "<", $tfn or die "$tfn: $!"; my $s_args = join ", " => @args; is_deeply ($csv->getline_all ($fh, @args), $expect, "getline_all ($s_args)"); close $fh; }); } { ok (my $csv = Text::CSV_XS->new ({ binary => 1 }), "csv in"); ok ($csv->column_names (my @cn = qw( foo bar bin baz )), "Set column names"); @list = map { my %h; @h{@cn} = @$_; \%h } @list; do_tests (sub { my ($expect, @args) = @_; open my $fh, "<", $tfn or die "$tfn: $!"; my $s_args = join ", " => @args; is_deeply ($csv->getline_hr_all ($fh, @args), $expect, "getline_hr_all ($s_args)"); close $fh; }); } { ok (my $csv = Text::CSV_XS->new ({ binary => 1 }), "csv in"); open my $fh, "<", $tfn or die "$tfn: $!"; eval { my $row = $csv->getline_hr_all ($fh); }; is ($csv->error_diag () + 0, 3002, "Use _hr before colnames ()"); } } Text-CSV_XS-1.26/t/12_acc.t0000644000031300001440000002402012753265123015612 0ustar00merijnusers00000000000000#!/usr/bin/perl use strict; use warnings; use Test::More tests => 189; BEGIN { use_ok "Text::CSV_XS"; plan skip_all => "Cannot load Text::CSV_XS" if $@; } my $csv; ok ($csv = Text::CSV_XS->new, "new ()"); is ($csv->quote_char, '"', "quote_char"); is ($csv->quote, '"', "quote"); is ($csv->escape_char, '"', "escape_char"); is ($csv->sep_char, ",", "sep_char"); is ($csv->sep, ",", "sep"); is ($csv->eol, "", "eol"); is ($csv->always_quote, 0, "always_quote"); is ($csv->binary, 0, "binary"); is ($csv->keep_meta_info, 0, "keep_meta_info"); is ($csv->allow_loose_quotes, 0, "allow_loose_quotes"); is ($csv->allow_loose_escapes, 0, "allow_loose_escapes"); is ($csv->allow_unquoted_escape, 0, "allow_unquoted_escape"); is ($csv->allow_whitespace, 0, "allow_whitespace"); is ($csv->blank_is_undef, 0, "blank_is_undef"); is ($csv->empty_is_undef, 0, "empty_is_undef"); is ($csv->auto_diag, 0, "auto_diag"); is ($csv->diag_verbose, 0, "diag_verbose"); is ($csv->verbatim, 0, "verbatim"); is ($csv->quote_space, 1, "quote_space"); is ($csv->quote_empty, 0, "quote_empty"); is ($csv->escape_null, 1, "escape_null"); is ($csv->quote_null, 1, "quote_null"); is ($csv->quote_binary, 1, "quote_binary"); is ($csv->record_number, 0, "record_number"); is ($csv->decode_utf8, 1, "decode_utf8"); is ($csv->binary (1), 1, "binary (1)"); my @fld = ( 'txt =, "Hi!"', "Yes", "", 2, undef, "1.09", "\r", undef ); ok ($csv->combine (@fld), "combine"); is ($csv->string, qq{"txt =, ""Hi!""",Yes,,2,,1.09,"\r",}, "string"); is ($csv->sep_char (";"), ";", "sep_char (;)"); is ($csv->sep (";"), ";", "sep (;)"); is ($csv->sep_char (), ";", "sep_char ()"); is ($csv->quote_char ("="), "=", "quote_char (=)"); is ($csv->quote (undef), "", "quote (undef)"); is ($csv->quote ("="), "=", "quote (=)"); is ($csv->eol (undef), "", "eol (undef)"); is ($csv->eol (""), "", "eol ('')"); is ($csv->eol ("\r"), "\r", "eol (\\r)"); is ($csv->keep_meta_info (1), 1, "keep_meta_info (1)"); is ($csv->always_quote (undef), 0, "always_quote (undef)"); is ($csv->always_quote (1), 1, "always_quote (1)"); is ($csv->allow_loose_quotes (1), 1, "allow_loose_quotes (1)"); is ($csv->allow_loose_escapes (1), 1, "allow_loose_escapes (1)"); is ($csv->allow_unquoted_escape (1), 1, "allow_unquoted_escape (1)"); is ($csv->allow_whitespace (1), 1, "allow_whitespace (1)"); is ($csv->blank_is_undef (1), 1, "blank_is_undef (1)"); is ($csv->empty_is_undef (1), 1, "empty_is_undef (1)"); is ($csv->auto_diag (1), 1, "auto_diag (1)"); is ($csv->auto_diag (2), 2, "auto_diag (2)"); is ($csv->auto_diag (9), 9, "auto_diag (9)"); is ($csv->auto_diag ("true"), 1, "auto_diag (\"true\")"); is ($csv->auto_diag ("false"), 0, "auto_diag (\"false\")"); is ($csv->auto_diag (undef), 0, "auto_diag (undef)"); is ($csv->auto_diag (""), 0, "auto_diag (\"\")"); is ($csv->diag_verbose (1), 1, "diag_verbose (1)"); is ($csv->diag_verbose (2), 2, "diag_verbose (2)"); is ($csv->diag_verbose (9), 9, "diag_verbose (9)"); is ($csv->diag_verbose ("true"), 1, "diag_verbose (\"true\")"); is ($csv->diag_verbose ("false"), 0, "diag_verbose (\"false\")"); is ($csv->diag_verbose (undef), 0, "diag_verbose (undef)"); is ($csv->diag_verbose (""), 0, "diag_verbose (\"\")"); is ($csv->verbatim (1), 1, "verbatim (1)"); is ($csv->quote_space (1), 1, "quote_space (1)"); is ($csv->quote_empty (1), 1, "quote_empty (1)"); is ($csv->escape_null (1), 1, "escape_null (1)"); is ($csv->quote_null (1), 1, "quote_null (1)"); is ($csv->quote_binary (1), 1, "quote_binary (1)"); is ($csv->escape_char ("\\"), "\\", "escape_char (\\)"); ok ($csv->combine (@fld), "combine"); is ($csv->string, qq{=txt \\=, "Hi!"=;=Yes=;==;=2=;;=1.09=;=\r=;\r}, "string"); is ($csv->allow_whitespace (0), 0, "allow_whitespace (0)"); is ($csv->quote_space (0), 0, "quote_space (0)"); is ($csv->quote_empty (0), 0, "quote_empty (0)"); is ($csv->escape_null (0), 0, "escape_null (0)"); is ($csv->quote_null (0), 0, "quote_null (0)"); is ($csv->quote_binary (0), 0, "quote_binary (0)"); is ($csv->decode_utf8 (0), 0, "decode_utf8 (0)"); is ($csv->sep ("--"), "--", "sep (\"--\")"); is ($csv->sep_char (), "\0", "sep_char"); is ($csv->quote ("++"), "++", "quote (\"++\")"); is ($csv->quote_char (), "\0", "quote_char"); # Test single-byte specials in UTF-8 mode is ($csv->sep ("|"), "|", "sep |"); is ($csv->sep_char (), "|", "sep_char"); chop (my $s = "|\x{20ac}"); is ($csv->sep ($s), "|", "sep |"); is ($csv->sep (), "|", "sep_char"); is ($csv->sep_char (), "|", "sep_char"); is ($csv->quote ("'"), "'", "quote '"); is ($csv->quote_char (), "'", "quote_char"); chop (my $q = "'\x{20ac}"); is ($csv->quote ($q), "'", "quote '"); is ($csv->quote (), "'", "quote_char"); is ($csv->quote_char (), "'", "quote_char"); # Funny settings, all three translate to \0 internally ok ($csv = Text::CSV_XS->new ({ sep_char => undef, quote_char => undef, escape_char => undef, }), "new (undef ...)"); is ($csv->sep_char, undef, "sep_char undef"); is ($csv->sep, undef, "sep undef"); is ($csv->quote_char, undef, "quote_char undef"); is ($csv->quote, undef, "quote undef"); is ($csv->escape_char, undef, "escape_char undef"); ok ($csv->parse ("foo"), "parse (foo)"); $csv->sep_char (","); is ($csv->record_number, 1, "record_number"); ok ($csv->parse ("foo"), "parse (foo)"); is ($csv->record_number, 2, "record_number"); ok (!$csv->parse ("foo,foo\0bar"), "parse (foo)"); $csv->escape_char ("\\"); ok (!$csv->parse ("foo,foo\0bar"), "parse (foo)"); $csv->binary (1); ok ( $csv->parse ("foo,foo\0bar"), "parse (foo)"); # Attribute aliasses ok ($csv = Text::CSV_XS->new ({ quote_always => 1, verbose_diag => 1})); is ($csv->always_quote, 1, "always_quote = quote_always"); is ($csv->diag_verbose, 1, "diag_verbose = verbose_diag"); ok ($csv = Text::CSV_XS->new ({ quote => undef, sep => undef }), "undef aliases"); is ($csv->sep_char, undef, "sep_char is undef"); is ($csv->sep, undef, "sep is undef"); is ($csv->quote_char, undef, "quote_char is undef"); is ($csv->quote, undef, "quote is undef"); # Some forbidden combinations foreach my $ws (" ", "\t") { ok ($csv = Text::CSV_XS->new ({ escape_char => $ws }), "New blank escape"); eval { ok ($csv->allow_whitespace (1), "Allow ws") }; is (($csv->error_diag)[0], 1002, "Wrong combo"); ok ($csv = Text::CSV_XS->new ({ quote_char => $ws }), "New blank quote"); eval { ok ($csv->allow_whitespace (1), "Allow ws") }; is (($csv->error_diag)[0], 1002, "Wrong combo"); ok ($csv = Text::CSV_XS->new ({ allow_whitespace => 1 }), "New ws 1"); eval { ok ($csv->escape_char ($ws), "esc") }; is (($csv->error_diag)[0], 1002, "Wrong combo"); ok ($csv = Text::CSV_XS->new ({ allow_whitespace => 1 }), "New ws 1"); eval { ok ($csv->quote_char ($ws), "esc") }; is (($csv->error_diag)[0], 1002, "Wrong combo"); } eval { $csv = Text::CSV_XS->new ({ escape_char => "\t", quote_char => " ", allow_whitespace => 1, }) }; like ((Text::CSV_XS::error_diag)[1], qr{^INI - allow_whitespace}, "Wrong combo - error message"); is ((Text::CSV_XS::error_diag)[0], 1002, "Wrong combo - numeric error"); # Test 1003 in constructor foreach my $x ("\r", "\n", "\r\n", "x\n", "\rx") { foreach my $attr (qw( sep_char quote_char escape_char )) { eval { $csv = Text::CSV_XS->new ({ $attr => $x }) }; is ((Text::CSV_XS::error_diag)[0], 1003, "eol in $attr"); } } # Test 1003 in methods foreach my $attr (qw( sep_char quote_char escape_char )) { ok ($csv = Text::CSV_XS->new, "New"); eval { ok ($csv->$attr ("\n"), "$attr => \\n") }; is (($csv->error_diag)[0], 1003, "not allowed"); } # Too long attr (max 16) $csv = Text::CSV_XS->new ({ quote => "'" }); my $xl = "X" x 32; eval { $csv->eol ($xl); }; is (($csv->error_diag)[0], 1005, "eol too long"); is ($csv->eol (), "", "eol unchanged"); eval { $csv->sep ($xl); }; is (($csv->error_diag)[0], 1006, "sep too long"); is ($csv->sep (), ",", "sep unchanged"); eval { $csv->quote ($xl); }; is (($csv->error_diag)[0], 1007, "quo too long"); is ($csv->quote (), "'", "quo unchanged"); eval { $csv = Text::CSV_XS->new ({ eol => $xl }); }; is ($csv, undef, "new with EOL too long"); is ((Text::CSV_XS::error_diag)[0], 1005, "error set"); eval { $csv = Text::CSV_XS->new ({ sep => $xl }); }; is ($csv, undef, "new with SEP too long"); is ((Text::CSV_XS::error_diag)[0], 1006, "error set"); eval { $csv = Text::CSV_XS->new ({ quote => $xl }); }; is ($csv, undef, "new with QUO too long"); is ((Text::CSV_XS::error_diag)[0], 1007, "error set"); # And test erroneous calls is (Text::CSV_XS::new (0), undef, "new () as function"); is (Text::CSV_XS::error_diag (), "usage: my \$csv = Text::CSV_XS->new ([{ option => value, ... }]);", "Generic usage () message"); is (Text::CSV_XS->new ({ oel => "" }), undef, "typo in attr"); is (Text::CSV_XS::error_diag (), "INI - Unknown attribute 'oel'", "Unsupported attr"); is (Text::CSV_XS->new ({ _STATUS => "" }), undef, "private attr"); is (Text::CSV_XS::error_diag (), "INI - Unknown attribute '_STATUS'", "Unsupported private attr"); foreach my $arg (undef, 0, "", " ", 1, [], [ 0 ], *STDOUT) { is (Text::CSV_XS->new ($arg), undef, "Illegal type for first arg"); is ((Text::CSV_XS::error_diag)[0], 1000, "Should be a hashref - numeric error"); } my $attr = [ sort qw( eol sep_char sep quote_char quote escape_char binary decode_utf8 auto_diag diag_verbose blank_is_undef empty_is_undef allow_whitespace allow_loose_quotes allow_loose_escapes allow_unquoted_escape always_quote quote_space quote_empty quote_binary escape_null keep_meta_info verbatim types callbacks )]; is_deeply ([ Text::CSV_XS::known_attributes () ], $attr, "Known attributes (function)"); is_deeply ([ Text::CSV_XS->known_attributes () ], $attr, "Known attributes (class method)"); is_deeply ([ Text::CSV_XS->new->known_attributes () ], $attr, "Known attributes (method)"); 1; Text-CSV_XS-1.26/t/00_pod.t0000644000031300001440000000025712753265123015651 0ustar00merijnusers00000000000000#!/usr/bin/perl use strict; use warnings; use Test::More; eval "use Test::Pod 1.00"; plan skip_all => "Test::Pod 1.00 required for testing POD" if $@; all_pod_files_ok (); Text-CSV_XS-1.26/t/60_samples.t0000644000031300001440000000141612753265123016537 0ustar00merijnusers00000000000000#!/usr/bin/perl use strict; use warnings; use Test::More tests => 8; BEGIN { use_ok "Text::CSV_XS", (); plan skip_all => "Cannot load Text::CSV_XS" if $@; } # Some assorted examples from the modules history # "Pavel Kotala" { my $csv = Text::CSV_XS->new ({ quote_char => '"', escape_char => '\\', sep_char => ';', binary => 1, }); ok ($csv, "new (\", \\\\, ;, 1)"); my @list = ("c:\\winnt", "text"); ok ($csv->combine (@list), "combine ()"); my $line = $csv->string; ok ($line, "string ()"); ok ($csv->parse ($line), "parse ()"); my @olist = $csv->fields; is (scalar @list, scalar @olist, "field count"); is ($list[0], $olist[0], "field 1"); is ($list[1], $olist[1], "field 2"); } Text-CSV_XS-1.26/t/01_pod.t0000644000031300001440000000036512753265123015652 0ustar00merijnusers00000000000000#!/usr/bin/perl use strict; use warnings; use Test::More; eval "use Test::Pod::Coverage tests => 1"; plan skip_all => "Test::Pod::Coverage required for testing POD Coverage" if $@; pod_coverage_ok ("Text::CSV_XS", "Text::CSV_XS is covered"); Text-CSV_XS-1.26/t/75_hashref.t0000644000031300001440000001536113015123436016515 0ustar00merijnusers00000000000000#!/usr/bin/perl use strict; use warnings; #use Test::More "no_plan"; use Test::More tests => 102; BEGIN { use_ok "Text::CSV_XS", (); plan skip_all => "Cannot load Text::CSV_XS" if $@; } my $tfn = "_75hashref.csv"; END { -f $tfn and unlink $tfn; } open my $fh, ">", $tfn or die "$tfn: $!\n"; print $fh <new (), "new"); is ($csv->column_names, undef, "No headers yet"); foreach my $args ([\1], ["foo", \1], [{ 1 => 2 }]) { eval { $csv->column_names (@$args) }; like ($@, qr/^EHR/, "croak"); is ($csv->error_diag () + 0, 3001, "Bad args to column_names"); } ok ($csv->column_names ("name"), "One single name"); is ($csv->column_names (undef), undef, "reset column_names"); eval { $csv->column_names (\undef) }; is ($csv->error_diag () + 0, 3001, "No hash please"); eval { $csv->column_names ({ 1 => 2 }) }; is ($csv->error_diag () + 0, 3001, "No hash please"); my $hr; eval { $hr = $csv->getline_hr ($fh) }; is ($hr, undef, "getline_hr before column_names"); like ($@, qr/^EHR/, "croak"); is ($csv->error_diag () + 0, 3002, "error code"); ok ($csv->column_names ("name", "code"), "column_names (list)"); is_deeply ([ $csv->column_names ], [ "name", "code" ], "well set"); open $fh, "<", $tfn or die "$tfn: $!\n"; my $row; ok ($row = $csv->getline ($fh), "getline headers"); is ($row->[0], "code", "Header line"); ok ($csv->column_names ($row), "column_names from array_ref"); is_deeply ([ $csv->column_names ], [ @$row ], "Keys set"); while (my $hr = $csv->getline_hr ($fh)) { ok (exists $hr->{code}, "Line has a code field"); like ($hr->{code}, qr/^[0-9]+$/, "Code is numeric"); ok (exists $hr->{name}, "Line has a name field"); like ($hr->{name}, qr/^[A-Z][a-z]+$/, "Name"); } close $fh; my ($code, $name, $price, $desc) = (1..4); is ($csv->bind_columns (), undef, "No bound columns yet"); eval { $csv->bind_columns (\$code) }; is ($csv->error_diag () + 0, 3003, "Arg cound mismatch"); eval { $csv->bind_columns ({}, {}, {}, {}) }; is ($csv->error_diag () + 0, 3004, "bad arg types"); is ($csv->column_names (undef), undef, "reset column_names"); ok ($csv->bind_columns (\($code, $name, $price)), "Bind columns"); eval { $csv->column_names ("foo") }; is ($csv->error_diag () + 0, 3003, "Arg cound mismatch"); $csv->bind_columns (undef); eval { $csv->bind_columns ([undef]) }; is ($csv->error_diag () + 0, 3004, "legal header defenition"); my @bcr = \($code, $name, $price, $desc); open $fh, "<", $tfn or die "$tfn: $!\n"; ok ($row = $csv->getline ($fh), "getline headers"); ok ($csv->bind_columns (@bcr), "Bind columns"); ok ($csv->column_names ($row), "column_names from array_ref"); is_deeply ([ $csv->column_names ], [ @$row ], "Keys set"); $row = $csv->getline ($fh); is_deeply ([ $csv->bind_columns ], [ @bcr ], "check refs"); is_deeply ($row, [], "return from getline with bind_columns"); is ($csv->column_names (undef), undef, "reset column headers"); is ($csv->bind_columns (undef), undef, "reset bound columns"); my $foo; ok ($csv->bind_columns (@bcr, \$foo), "bind too many columns"); ($code, $name, $price, $desc, $foo) = (101 .. 105); ok ($csv->getline ($fh), "fetch less than expected"); is_deeply ([ $code, $name, $price, $desc, $foo ], [ 2, "Drinks", "82.78", "Drinks", 105 ], "unfetched not reset"); my @foo = (0) x 0x012345; ok ($csv->bind_columns (\(@foo)), "bind a lot of columns"); ok ($csv->bind_columns (\1, \2, \3, \""), "bind too constant columns"); is ($csv->getline ($fh), undef, "fetch to read-only ref"); is ($csv->error_diag () + 0, 3008, "Read-only"); ok ($csv->bind_columns (\$code), "bind not enough columns"); eval { $row = $csv->getline ($fh) }; is ($csv->error_diag () + 0, 3006, "cannot read all fields"); close $fh; open $fh, "<", $tfn or die "$tfn: $!\n"; is ($csv->column_names (undef), undef, "reset column headers"); is ($csv->bind_columns (undef), undef, "reset bound columns"); is_deeply ([ $csv->column_names (undef, "", "name", "name") ], [ "\cAUNDEF\cA", "", "name", "name" ], "undefined column header"); ok ($hr = $csv->getline_hr ($fh), "getline_hr ()"); is (ref $hr, "HASH", "returned a hashref"); is_deeply ($hr, { "\cAUNDEF\cA" => "code", "" => "name", "name" => "description" }, "Discarded 3rd field"); close $fh; open $fh, ">", $tfn or die "$tfn: $!\n"; $hr = { c_foo => 1, foo => "poison", zebra => "Of course" }; is ($csv->column_names (undef), undef, "reset column headers"); ok ($csv->column_names (sort keys %$hr), "set column names"); ok ($csv->eol ("\n"), "set eol for output"); ok ($csv->print ($fh, [ $csv->column_names ]), "print header"); ok ($csv->print_hr ($fh, $hr), "print_hr"); ok ($csv->print ($fh, []), "empty print"); close $fh; ok ($csv->keep_meta_info (1), "keep meta info"); open $fh, "<", $tfn or die "$tfn: $!\n"; ok ($csv->column_names ($csv->getline ($fh)), "get column names"); is_deeply ($csv->getline_hr ($fh), $hr, "compare to written hr"); is_deeply ($csv->getline_hr ($fh), { c_foo => "", foo => undef, zebra => undef }, "compare to written hr"); is ($csv->is_missing (1), 1, "No col 1"); close $fh; open $fh, ">", $tfn or die "$tfn: $!\n"; print $fh <<"EOC"; a,b 2 EOC close $fh; ok ($csv = Text::CSV_XS->new (), "new"); open $fh, "<", $tfn or die "$tfn: $!\n"; ok ($csv->column_names ("code", "foo"), "set column names"); ok ($hr = $csv->getline_hr ($fh), "get header line"); is ($csv->is_missing (0), undef, "not is_missing () - no meta"); is ($csv->is_missing (1), undef, "not is_missing () - no meta"); ok ($hr = $csv->getline_hr ($fh), "get empty line"); is ($csv->is_missing (0), undef, "not is_missing () - no meta"); is ($csv->is_missing (1), undef, "not is_missing () - no meta"); ok ($hr = $csv->getline_hr ($fh), "get partial data line"); is (int $hr->{code}, 2, "code == 2"); is ($csv->is_missing (0), undef, "not is_missing () - no meta"); is ($csv->is_missing (1), undef, "not is_missing () - no meta"); close $fh; open $fh, "<", $tfn or die "$tfn: $!\n"; $csv->keep_meta_info (1); ok ($csv->column_names ("code", "foo"), "set column names"); ok ($hr = $csv->getline_hr ($fh), "get header line"); is ($csv->is_missing (0), 0, "not is_missing () - with meta"); is ($csv->is_missing (1), 0, "not is_missing () - with meta"); ok ($hr = $csv->getline_hr ($fh), "get empty line"); is ($csv->is_missing (0), 1, "not is_missing () - with meta"); is ($csv->is_missing (1), 1, "not is_missing () - with meta"); ok ($hr = $csv->getline_hr ($fh), "get partial data line"); is (int $hr->{code}, 2, "code == 2"); is ($csv->is_missing (0), 0, "not is_missing () - with meta"); is ($csv->is_missing (1), 1, "not is_missing () - with meta"); close $fh; done_testing; Text-CSV_XS-1.26/t/65_allow.t0000644000031300001440000003251712753265123016224 0ustar00merijnusers00000000000000#!/usr/bin/perl use strict; use warnings; #use Test::More "no_plan"; use Test::More tests => 1119; BEGIN { use_ok "Text::CSV_XS", (); plan skip_all => "Cannot load Text::CSV_XS" if $@; require "t/util.pl"; } my $tfn = "_65test.csv"; END { -f $tfn and unlink $tfn; } my $csv; ok (1, "Allow unescaped quotes"); # Allow unescaped quotes inside an unquoted field { my @bad = ( # valid, line [ 1, 1, 0, qq{foo,bar,"baz",quux} ], [ 2, 0, 2034, qq{rj,bs,r"jb"s,rjbs} ], [ 3, 0, 2034, qq{some "spaced" quote data,2,3,4} ], [ 4, 1, 0, qq{and an,entirely,quoted,"field"} ], [ 5, 1, 0, qq{and then,"one with ""quoted"" quotes",okay,?} ], ); for (@bad) { my ($tst, $valid, $err, $bad) = @$_; $csv = Text::CSV_XS->new (); ok ($csv, "$tst - new (alq => 0)"); is ($csv->parse ($bad), $valid, "$tst - parse () fail"); is (0 + $csv->error_diag, $err, "$tst - error $err"); $csv->allow_loose_quotes (1); ok ($csv->parse ($bad), "$tst - parse () pass"); ok (my @f = $csv->fields, "$tst - fields"); } #$csv = Text::CSV_XS->new ({ quote_char => '"', escape_char => "=" }); #ok (!$csv->parse (qq{foo,d'uh"bar}), "should fail"); } ok (1, "Allow loose quotes inside quoted"); # Allow unescaped quotes inside a quoted field { my @bad = ( # valid, line [ 1, 1, 0, qq{foo,bar,"baz",quux} ], [ 2, 0, 2023, qq{rj,bs,"r"jb"s",rjbs} ], [ 3, 0, 2023, qq{"some "spaced" quote data",2,3,4} ], [ 4, 1, 0, qq{and an,entirely,quoted,"field"} ], [ 5, 1, 0, qq{and then,"one with ""quoted"" quotes",okay,?} ], ); for (@bad) { my ($tst, $valid, $err, $bad) = @$_; $csv = Text::CSV_XS->new (); ok ($csv, "$tst - new (alq => 0)"); is ($csv->parse ($bad), $valid, "$tst - parse () fail"); is (0 + $csv->error_diag, $err, "$tst - error $err"); $csv->allow_loose_quotes (1); is ($csv->parse ($bad), $valid, "$tst - parse () fail with lq"); is (0 + $csv->error_diag, $err, "$tst - error $err"); $csv->escape_char (undef); ok ($csv->parse ($bad), "$tst - parse () pass"); ok (my @f = $csv->fields, "$tst - fields"); } } ok (1, "Allow loose escapes"); # Allow escapes to escape characters that should not be escaped { my @bad = ( # valid, line [ 1, 1, 0, qq{1,foo,bar,"baz",quux} ], [ 2, 1, 0, qq{2,escaped,"quote\\"s",in,"here"} ], [ 3, 1, 0, qq{3,escaped,quote\\"s,in,"here"} ], [ 4, 1, 0, qq{4,escap\\'d chars,allowed,in,unquoted,fields} ], [ 5, 0, 2025, qq{5,42,"and it\\'s dog",} ], [ 6, 1, 0, qq{\\,} ], [ 7, 1, 0, qq{\\} ], [ 8, 0, 2035, qq{foo\\} ], ); for (@bad) { my ($tst, $valid, $err, $bad) = @$_; $csv = Text::CSV_XS->new ({ escape_char => "\\" }); ok ($csv, "$tst - new (ale => 0)"); is ($csv->parse ($bad), $valid, "$tst - parse () fail"); is (0 + $csv->error_diag, $err, "$tst - error $err"); $csv->allow_loose_escapes (1); if ($tst >= 8) { # Should always fail ok (!$csv->parse ($bad), "$tst - parse () fail"); is (0 + $csv->error_diag, $err, "$tst - error $err"); } else { ok ($csv->parse ($bad), "$tst - parse () pass"); ok (my @f = $csv->fields, "$tst - fields"); } } } ok (1, "Allow whitespace"); # Allow whitespace to surround sep char { my @bad = ( # valid, line [ 1, 1, 0, qq{1,foo,bar,baz,quux} ], [ 2, 1, 0, qq{1,foo,bar,"baz",quux} ], [ 3, 1, 0, qq{1, foo,bar,"baz",quux} ], [ 4, 1, 0, qq{ 1,foo,bar,"baz",quux} ], [ 5, 0, 2034, qq{1,foo,bar, "baz",quux} ], [ 6, 1, 0, qq{1,foo ,bar,"baz",quux} ], [ 7, 1, 0, qq{1,foo,bar,"baz",quux } ], [ 8, 1, 0, qq{1,foo,bar,"baz","quux"} ], [ 9, 0, 2023, qq{1,foo,bar,"baz" ,quux} ], [ 10, 0, 2023, qq{1,foo,bar,"baz","quux" } ], [ 11, 0, 2034, qq{ 1 , foo , bar , "baz" , quux } ], [ 12, 0, 2034, qq{ 1 , foo , bar , "baz" , quux } ], [ 13, 0, 2034, qq{ 1 , foo , bar , "baz"\t , quux } ], ); foreach my $eol ("", "\n", "\r", "\r\n") { my $s_eol = _readable ($eol); for (@bad) { my ($tst, $ok, $err, $bad) = @$_; $csv = Text::CSV_XS->new ({ eol => $eol, binary => 1 }); ok ($csv, "$s_eol / $tst - new - '$bad')"); is ($csv->parse ($bad), $ok, "$s_eol / $tst - parse () fail"); is (0 + $csv->error_diag, $err, "$tst - error $err"); $csv->allow_whitespace (1); ok ($csv->parse ("$bad$eol"), "$s_eol / $tst - parse () pass"); ok (my @f = $csv->fields, "$s_eol / $tst - fields"); local $" = ","; is ("@f", $bad[0][-1], "$s_eol / $tst - content"); } } } ok (1, "Allow whitespace"); # Allow whitespace to surround sep char { my @bad = ( # test, ok, line [ 1, 1, 0, qq{1,foo,bar,baz,quux} ], [ 2, 1, 0, qq{1,foo,bar,"baz",quux} ], [ 3, 1, 0, qq{1, foo,bar,"baz",quux} ], [ 4, 1, 0, qq{ 1,foo,bar,"baz",quux} ], [ 5, 0, 2034, qq{1,foo,bar, "baz",quux} ], [ 6, 1, 0, qq{1,foo ,bar,"baz",quux} ], [ 7, 1, 0, qq{1,foo,bar,"baz",quux } ], [ 8, 1, 0, qq{1,foo,bar,"baz","quux"} ], [ 9, 0, 2023, qq{1,foo,bar,"baz" ,quux} ], [ 10, 0, 2023, qq{1,foo,bar,"baz","quux" } ], [ 11, 0, 2023, qq{1,foo,bar,"baz","quux" } ], [ 12, 0, 2034, qq{ 1 , foo , bar , "baz" , quux } ], [ 13, 0, 2034, qq{ 1 , foo , bar , "baz" , quux } ], [ 14, 0, 2034, qq{ 1 , foo , bar , "baz"\t , quux } ], ); foreach my $eol ("", "\n", "\r", "\r\n") { my $s_eol = _readable ($eol); for (@bad) { my ($tst, $ok, $err, $bad) = @$_; $csv = Text::CSV_XS->new ({ eol => $eol, binary => 1, }); ok ($csv, "$s_eol / $tst - new - '$bad')"); is ($csv->parse ($bad), $ok, "$s_eol / $tst - parse () fail"); is (0 + $csv->error_diag, $err, "$tst - error $err"); $csv->allow_whitespace (1); ok ($csv->parse ("$bad$eol"), "$s_eol / $tst - parse () pass"); ok (my @f = $csv->fields, "$s_eol / $tst - fields"); local $" = ","; is ("@f", $bad[0][-1], "$s_eol / $tst - content"); } } } ok (1, "blank_is_undef"); foreach my $conf ( [ 0, 0, 0, 1, "", " ", '""', 2, "", "", "" ], [ 0, 0, 1, 1, undef, " ", '""', 2, undef, undef, undef ], [ 0, 1, 0, 1, "", " ", '""', 2, "", "", "" ], [ 0, 1, 1, 1, undef, " ", '""', 2, undef, undef, undef ], [ 1, 0, 0, 1, "", " ", '""', 2, "", "", "" ], [ 1, 0, 1, 1, "", " ", '""', 2, undef, "", undef ], [ 1, 1, 0, 1, "", " ", '""', 2, "", "", "" ], [ 1, 1, 1, 1, "", " ", '""', 2, undef, "", undef ], ) { my ($aq, $aw, $bu, @expect, $str) = @$conf; $csv = Text::CSV_XS->new ({ always_quote => $aq, allow_whitespace => $aw, blank_is_undef => $bu }); ok ($csv, "new ({ aq $aq aw $aw bu $bu })"); ok ($csv->combine (1, "", " ", '""', 2, undef, "", undef), "combine ()"); ok ($str = $csv->string, "string ()"); foreach my $eol ("", "\n", "\r\n") { my $s_eol = _readable ($eol); ok ($csv->parse ($str.$eol), "parse (*$str$s_eol*)"); ok (my @f = $csv->fields, "fields ()"); is_deeply (\@f, \@expect, "result"); } } ok (1, "empty_is_undef"); foreach my $conf ( [ 0, 0, 0, 1, "", " ", '""', 2, "", "", "" ], [ 0, 0, 1, 1, undef, " ", '""', 2, undef, undef, undef ], [ 0, 1, 0, 1, "", " ", '""', 2, "", "", "" ], [ 0, 1, 1, 1, undef, " ", '""', 2, undef, undef, undef ], [ 1, 0, 0, 1, "", " ", '""', 2, "", "", "" ], [ 1, 0, 1, 1, undef, " ", '""', 2, undef, undef, undef ], [ 1, 1, 0, 1, "", " ", '""', 2, "", "", "" ], [ 1, 1, 1, 1, undef, " ", '""', 2, undef, undef, undef ], ) { my ($aq, $aw, $bu, @expect, $str) = @$conf; $csv = Text::CSV_XS->new ({ always_quote => $aq, allow_whitespace => $aw, empty_is_undef => $bu }); ok ($csv, "new ({ aq $aq aw $aw bu $bu })"); ok ($csv->combine (1, "", " ", '""', 2, undef, "", undef), "combine ()"); ok ($str = $csv->string, "string ()"); foreach my $eol ("", "\n", "\r\n") { my $s_eol = _readable ($eol); ok ($csv->parse ($str.$eol), "parse (*$str$s_eol*)"); ok (my @f = $csv->fields, "fields ()"); is_deeply (\@f, \@expect, "result"); } } ok (1, "Trailing junk"); foreach my $bin (0, 1) { foreach my $eol (undef, "\r") { my $s_eol = _readable ($eol); my $csv = Text::CSV_XS->new ({ binary => $bin, eol => $eol }); ok ($csv, "$s_eol - new ()"); my @bad = ( # test, line [ 1, qq{"\r\r\n"\r} ], [ 2, qq{"\r\r\n"\r\r} ], [ 3, qq{"\r\r\n"\r\r\n} ], [ 4, qq{"\r\r\n"\t \r} ], [ 5, qq{"\r\r\n"\t \r\r} ], [ 6, qq{"\r\r\n"\t \r\r\n} ], ); my @pass = ( 0, 0, 0, 1 ); my @fail = ( 2022, 2022, 2023, 0 ); foreach my $arg (@bad) { my ($tst, $bad) = @$arg; my $ok = ($bin << 1) | ($eol ? 1 : 0); is ($csv->parse ($bad), $pass[$ok], "$tst $ok - parse () default"); is (0 + $csv->error_diag, $fail[$ok], "$tst $ok - error $fail[$ok]"); $csv->allow_whitespace (1); is ($csv->parse ($bad), $pass[$ok], "$tst $ok - parse () allow"); is (0 + $csv->error_diag, $fail[$ok], "$tst $ok - error $fail[$ok]"); } } } { ok (1, "verbatim"); my $csv = Text::CSV_XS->new ({ sep_char => "^", binary => 1, }); my @str = ( qq{M^^Abe^Timmerman#\r\n}, qq{M^^Abe\nTimmerman#\r\n}, ); my $gc; ok (1, "verbatim on parse ()"); foreach $gc (0, 1) { $csv->verbatim ($gc); ok ($csv->parse ($str[0]), "\\n $gc parse"); my @fld = $csv->fields; is (@fld, 4, "\\n $gc fields"); is ($fld[2], "Abe", "\\n $gc fld 2"); if ($gc) { # Note line ending is still there! is ($fld[3], "Timmerman#\r\n", "\\n $gc fld 3"); } else { # Note the stripped \r! is ($fld[3], "Timmerman#", "\\n $gc fld 3"); } ok ($csv->parse ($str[1]), "\\n $gc parse"); @fld = $csv->fields; is (@fld, 3, "\\n $gc fields"); if ($gc) { # All newlines verbatim is ($fld[2], "Abe\nTimmerman#\r\n", "\\n $gc fld 2"); } else { # Note, rest is next line is ($fld[2], "Abe", "\\n $gc fld 2"); } } $csv->eol ($/ = "#\r\n"); foreach $gc (0, 1) { $csv->verbatim ($gc); ok ($csv->parse ($str[0]), "#\\r\\n $gc parse"); my @fld = $csv->fields; is (@fld, 4, "#\\r\\n $gc fields"); is ($fld[2], "Abe", "#\\r\\n $gc fld 2"); is ($fld[3], $gc ? "Timmerman#\r\n" : "Timmerman", "#\\r\\n $gc fld 3"); ok ($csv->parse ($str[1]), "#\\r\\n $gc parse"); @fld = $csv->fields; is (@fld, 3, "#\\r\\n $gc fields"); is ($fld[2], $gc ? "Abe\nTimmerman#\r\n" : "Abe", "#\\r\\n $gc fld 2"); } ok (1, "verbatim on getline (*FH)"); open FH, ">", $tfn or die "$tfn: $!\n"; print FH @str, "M^Abe^*\r\n"; close FH; foreach $gc (0, 1) { $csv->verbatim ($gc); open FH, "<", $tfn or die "$tfn: $!\n"; my $row; ok ($row = $csv->getline (*FH), "#\\r\\n $gc getline"); is (@$row, 4, "#\\r\\n $gc fields"); is ($row->[2], "Abe", "#\\r\\n $gc fld 2"); is ($row->[3], "Timmerman", "#\\r\\n $gc fld 3"); ok ($row = $csv->getline (*FH), "#\\r\\n $gc parse"); is (@$row, 3, "#\\r\\n $gc fields"); is ($row->[2], $gc ? "Abe\nTimmerman" : "Abe", "#\\r\\n $gc fld 2"); } $gc = $csv->verbatim (); ok (my $row = $csv->getline (*FH), "#\\r\\n $gc parse EOF"); is (@$row, 3, "#\\r\\n $gc fields"); is ($row->[2], "*\r\n", "#\\r\\n $gc fld 2"); close FH; $csv = Text::CSV_XS->new ({ binary => 0, verbatim => 1, eol => "#\r\n", }); open my $fh, ">", $tfn or die "$tfn: $!\n"; print $fh $str[1]; close $fh; open $fh, "<", $tfn or die "$tfn: $!\n"; is ($csv->getline ($fh), undef, "#\\r\\n $gc getline 2030"); is (0 + $csv->error_diag, 2030, "Got 2030"); close $fh; unlink $tfn; } { ok (1, "keep_meta_info on getline ()"); my $csv = Text::CSV_XS->new ({ eol => "\n" }); open my $fh, ">", $tfn or die "$tfn: $!\n"; print $fh qq{1,"",,"Q",2\n}; close $fh; is ($csv->keep_meta_info (0), 0, "No meta info"); open $fh, "<", $tfn or die "$tfn: $!\n"; my $row = $csv->getline ($fh); ok ($row, "Get 1st line"); $csv->error_diag (); is ($csv->is_quoted (2), undef, "Is field 2 quoted?"); is ($csv->is_quoted (3), undef, "Is field 3 quoted?"); close $fh; open $fh, ">", $tfn or die "$tfn: $!\n"; print $fh qq{1,"",,"Q",2\n}; close $fh; is ($csv->keep_meta_info (1), 1, "Keep meta info"); open $fh, "<", $tfn or die "$tfn: $!\n"; $row = $csv->getline ($fh); ok ($row, "Get 2nd line"); $csv->error_diag (); is ($csv->is_quoted (2), 0, "Is field 2 quoted?"); is ($csv->is_quoted (3), 1, "Is field 3 quoted?"); close $fh; unlink $tfn; } { my $csv = Text::CSV_XS->new ({}); my $s2023 = qq{2023,",2008-04-05," \tFoo, Bar",\n}; # " # ^ is ( $csv->parse ($s2023), 0, "Parse 2023"); is (($csv->error_diag)[0], 2023, "Fail code 2023"); is (($csv->error_diag)[2], 19, "Fail position"); is ( $csv->allow_whitespace (1), 1, "Allow whitespace"); is ( $csv->parse ($s2023), 0, "Parse 2023"); is (($csv->error_diag)[0], 2023, "Fail code 2023"); is (($csv->error_diag)[2], 22, "Space is eaten now"); } { my $csv = Text::CSV_XS->new ({ allow_unquoted_escape => 1, escape_char => "=" }); my $str = q{1,3,=}; is ( $csv->parse ($str), 0, "Parse trailing ESC"); is (($csv->error_diag)[0], 2035, "Fail code 2035"); $str .= "0"; is ( $csv->parse ($str), 1, "Parse trailing ESC"); is_deeply ([ $csv->fields ], [ 1,3,"\0" ], "Parse passed"); } Text-CSV_XS-1.26/t/50_utf8.t0000644000031300001440000001056712753265123015767 0ustar00merijnusers00000000000000#!/usr/bin/perl use strict; use warnings; use Test::More; BEGIN { if ($] < 5.008001) { plan skip_all => "UTF8 tests useless in this ancient perl version"; } else { plan tests => 93; } } BEGIN { require_ok "Text::CSV_XS"; plan skip_all => "Cannot load Text::CSV_XS" if $@; require "t/util.pl"; } my $tfn = "_50test.csv"; END { -f $tfn and unlink $tfn; } # No binary => 1, as UTF8 is supposed to be allowed without it my $csv = Text::CSV_XS->new ({ always_quote => 1, keep_meta_info => 1, }); # Special characters to check: # 0A = \n 2C = , 20 = 22 = " # 0D = \r 3B = ; foreach my $test ( # Space-like characters [ "\x{0000A0}", "U+0000A0 NO-BREAK SPACE" ], [ "\x{00200B}", "U+00200B ZERO WIDTH SPACE" ], # Some characters with possible problems in the code point [ "\x{000122}", "U+000122 LATIN CAPITAL LETTER G WITH CEDILLA" ], [ "\x{002C22}", "U+002C22 GLAGOLITIC CAPITAL LETTER SPIDERY HA" ], [ "\x{000A2C}", "U+000A2C GURMUKHI LETTER BA" ], [ "\x{000E2C}", "U+000E2C THAI CHARACTER LO CHULA" ], [ "\x{010A2C}", "U+010A2C KHAROSHTHI LETTER VA" ], # Characters with possible problems in the encoded representation # Should not be possible. ASCII is coded in 000..127, all other # characters in 128..255 ) { my ($u, $msg) = @$test; ($u = "$u\x{0123}") =~ s/.$//; # Make sure it's marked UTF8 my @in = ("", " ", $u, ""); my $exp = join ",", map { qq{"$_"} } @in; ok ($csv->combine (@in), "combine $msg"); my $str = $csv->string; is_binary ($str, $exp, "string $msg"); ok ($csv->parse ($str), "parse $msg"); my @out = $csv->fields; # Cannot use is_deeply (), because of the binary content is (scalar @in, scalar @out, "fields $msg"); is_binary ($in[$_], $out[$_], "field $_ $msg") for 0 .. $#in; } # Test if the UTF8 part is accepted, but the \n is not is ($csv->parse (qq{"\x{0123}\n\x{20ac}"}), 0, "\\n still needs binary"); is ($csv->binary, 0, "bin flag still unset"); is ($csv->error_diag + 0, 2021, "Error 2021"); my $file = "files/utf8.csv"; SKIP: { open my $fh, "<:encoding(utf8)", $file or skip "Cannot open UTF-8 test file", 6; my $row; ok ($row = $csv->getline ($fh), "read/parse"); is ($csv->is_quoted (0), 1, "First field is quoted"); is ($csv->is_quoted (1), 0, "Second field is not quoted"); is ($csv->is_binary (0), 1, "First field is binary"); is ($csv->is_binary (1), 0, "Second field is not binary"); ok (utf8::valid ($row->[0]), "First field is valid utf8"); $csv->combine (@$row); ok (utf8::valid ($csv->string), "Combined string is valid utf8"); } # Test quote_binary $csv->always_quote (0); $csv->quote_space (0); $csv->quote_binary (0); ok ($csv->combine (" ", 1, "\x{20ac} "), "Combine"); is ($csv->string, qq{ ,1,\x{20ac} }, "String 0-0"); $csv->quote_binary (1); ok ($csv->combine (" ", 1, "\x{20ac} "), "Combine"); is ($csv->string, qq{ ,1,"\x{20ac} "}, "String 0-1"); $csv->quote_space (1); $csv->quote_binary (0); ok ($csv->combine (" ", 1, "\x{20ac} "), "Combine"); is ($csv->string, qq{" ",1,"\x{20ac} "}, "String 1-0"); ok ($csv->quote_binary (1), "quote binary on"); ok ($csv->combine (" ", 1, "\x{20ac} "), "Combine"); is ($csv->string, qq{" ",1,"\x{20ac} "}, "String 1-1"); ok ($csv->parse (qq{,1,"f\x{014d}o, 3""56",,bar,\r\n}), "example from XS"); is_deeply ([$csv->fields], [ "", 1, qq{f\x{014d}o, 3"56}, "", "bar", "" ], "content"); open my $fh, ">:encoding(utf-8)", $tfn or die "$tfn: $!\n"; print $fh "euro\n\x{20ac}\neuro\n"; close $fh; open $fh, "<:encoding(utf-8)", $tfn or die "$tfn: $!\n"; SKIP: { my $out = ""; my $isutf8 = $] < 5.008001 ? sub { !$_[0]; } : # utf8::is_utf8 () not available in 5.8.0 sub { utf8::is_utf8 ($out); }; ok ($csv->auto_diag (1), "auto diag"); ok ($csv->binary (1), "set binary"); ok ($csv->bind_columns (\$out), "bind"); ok ($csv->getline ($fh), "parse"); is ($csv->is_binary (0), 0, "not binary"); is ($out, "euro", "euro"); ok (!$isutf8->(1), "not utf8"); ok ($csv->getline ($fh), "parse"); is ($csv->is_binary (0), 1, "is binary"); is ($out, "\x{20ac}", "euro"); ok ($isutf8->(0), "is utf8"); ok ($csv->getline ($fh), "parse"); is ($csv->is_binary (0), 0, "not binary"); is ($out, "euro", "euro"); ok (!$isutf8->(1), "not utf8"); close $fh; } Text-CSV_XS-1.26/t/41_null.t0000644000031300001440000000376012753265123016050 0ustar00merijnusers00000000000000#!/usr/bin/perl use strict; use warnings; use Test::More tests => 128; use Text::CSV_XS; my @pat = ( "00", "\00", "0\0", "\0\0", "0\n0", "\0\n0", "0\n\0", "\0\n\0", "\"0\n0", "\"\0\n0", "\"0\n\0", "\"\0\n\0", "\"0\n\"0", "\"\0\n\"0", "\"0\n\"\0", "\"\0\n\"\0", "0\n0", "\0\n0", "0\n\0", "\0\n\0", ); my %exp = map { my $x = $_; $x =~ s/\0/\\0/g; $x =~ s/\n/\\n/g; ($_ => $x); } @pat; my $line = ["", undef, "0\n", "", "\0\0\n0"]; my $tfn = "_41test.csv"; END { -f $tfn and unlink $tfn; } my $csv = Text::CSV_XS->new ({ eol => "\n", binary => 1, auto_diag => 1, blank_is_undef => 1, }); ok ($csv->combine (@$line), "combine [ ... ]"); is ($csv->string, qq{,,"0\n",,""0"0\n0"\n}, "string"); open my $fh, ">", $tfn or die "$tfn: $!\n"; binmode $fh; ok ($csv->print ($fh, [ $_ ]), "print $exp{$_}") for @pat; $csv->always_quote (1); ok ($csv->print ($fh, $line), "print [ ... ]"); close $fh; open $fh, "<", $tfn or die "$tfn: $!\n"; binmode $fh; foreach my $pat (@pat) { ok (my $row = $csv->getline ($fh), "getline $exp{$pat}"); is ($row->[0], $pat, "data $exp{$pat}"); } is_deeply ($csv->getline ($fh), $line, "read [ ... ]"); close $fh; unlink $tfn; $csv = Text::CSV_XS->new ({ eol => "\n", binary => 1, auto_diag => 1, blank_is_undef => 1, quote_null => 0, }); ok ($csv->combine (@$line), "combine [ ... ]"); is ($csv->string, qq{,,"0\n",,"\0\0\n0"\n}, "string"); open $fh, ">", $tfn or die "$tfn: $!\n"; binmode $fh; for (@pat) { ok ($csv->print ($fh, [ $_ ]), "print $exp{$_}"); } $csv->always_quote (1); ok ($csv->print ($fh, $line), "print [ ... ]"); close $fh; open $fh, "<", $tfn or die "$tfn: $!\n"; binmode $fh; foreach my $pat (@pat) { ok (my $row = $csv->getline ($fh), "getline $exp{$pat}"); is ($row->[0], $pat, "data $exp{$pat}"); } is_deeply ($csv->getline ($fh), $line, "read [ ... ]"); close $fh; Text-CSV_XS-1.26/t/30_types.t0000644000031300001440000000324612753265123016237 0ustar00merijnusers00000000000000#!/usr/bin/perl use strict; use warnings; use Test::More tests => 25; BEGIN { use_ok "Text::CSV_XS", (); plan skip_all => "Cannot load Text::CSV_XS" if $@; } $| = 1; my $csv = Text::CSV_XS->new ({ types => [ Text::CSV_XS::IV (), Text::CSV_XS::PV (), Text::CSV_XS::NV (), ], }); ok ($csv, "CSV_XS->new ()"); is (@{$csv->{types}}, 3, "->{types} as hash"); is ($csv->{types}[0], Text::CSV_XS::IV (), "type IV"); is ($csv->{types}[1], Text::CSV_XS::PV (), "type PV"); is ($csv->{types}[2], Text::CSV_XS::NV (), "type NV"); is (ref ($csv->types), "ARRAY", "->types () as method"); is ($csv->types ()->[0], Text::CSV_XS::IV (), "type IV"); is ($csv->types ()->[1], Text::CSV_XS::PV (), "type PV"); is ($csv->types ()->[2], Text::CSV_XS::NV (), "type NV"); is (length $csv->{_types}, 3, "->{_types}"); my $inp = join "", map { chr $_ } Text::CSV_XS::IV (), Text::CSV_XS::PV (), Text::CSV_XS::NV (); # should be "\001\000\002" is ($csv->{_types}, $inp, "IV PV NV"); ok ($csv->parse ("2.55,CSFDATVM01,3.75"), "parse ()"); my @fields = $csv->fields (); is ($fields[0], "2", "Field 1"); is ($fields[1], "CSFDATVM01", "Field 2"); is ($fields[2], "3.75", "Field 3"); ok ($csv->combine ("", "", "1.00"), "combine ()"); is ($csv->string, ',,1.00', "string"); my $warning; $SIG{__WARN__} = sub { $warning = shift }; ok ($csv->parse ($csv->string ()), "parse (combine ())"); like ($warning, qr/numeric/, "numeric warning"); @fields = $csv->fields (); is ($fields[0], "0", "Field 1"); is ($fields[1], "", "Field 2"); is ($fields[2], "1", "Field 3"); is ($csv->types (0), undef, "delete types"); is ($csv->types, undef, "types gone"); Text-CSV_XS-1.26/t/90_csv.t0000644000031300001440000001367112753265123015677 0ustar00merijnusers00000000000000#!/usr/bin/perl use strict; use warnings; use Config; #use Test::More "no_plan"; use Test::More tests => 45; BEGIN { use_ok "Text::CSV_XS", ("csv"); plan skip_all => "Cannot load Text::CSV_XS" if $@; require "t/util.pl"; } my $tfn = "_90test.csv"; END { -f $tfn and unlink $tfn } my $data = "foo,bar,baz\n". "1,2,3\n". "2,a b,\n"; open FH, ">", $tfn or die "$tfn: $!"; print FH $data; close FH; my @hdr = qw( foo bar baz ); my $aoa = [ \@hdr, [ 1, 2, 3 ], [ 2, "a b", "" ], ]; my $aoh = [ { foo => 1, bar => 2, baz => 3 }, { foo => 2, bar => "a b", baz => "" }, ]; SKIP: for my $io ([ $tfn, "file" ], [ \*FH, "globref" ], [ *FH, "glob" ], [ \$data, "ScalarIO"] ) { $] < 5.008 && ref $io->[0] eq "SCALAR" and skip "No ScalarIO support for $]", 1; open FH, "<", $tfn or die "$tfn: $!\n"; is_deeply (csv ({ in => $io->[0] }), $aoa, "AOA $io->[1]"); close FH; } SKIP: for my $io ([ $tfn, "file" ], [ \*FH, "globref" ], [ *FH, "glob" ], [ \$data, "ScalarIO"] ) { $] < 5.008 && ref $io->[0] eq "SCALAR" and skip "No ScalarIO support for $]", 1; open FH, "<", $tfn or die "$tfn: $!\n"; is_deeply (csv (in => $io->[0], headers => "auto"), $aoh, "AOH $io->[1]"); close FH; } is_deeply (csv (in => $tfn, headers => { bar => "tender" }), [ { foo => 1, tender => 2, baz => 3 }, { foo => 2, tender => "a b", baz => "" }, ], "AOH with header map"); my @aoa = @{$aoa}[1,2]; is_deeply (csv (file => $tfn, headers => "skip"), \@aoa, "AOA skip"); is_deeply (csv (file => $tfn, fragment => "row=2-3"), \@aoa, "AOA fragment"); if ($] >= 5.008001) { is_deeply (csv (in => $tfn, encoding => "utf-8", headers => ["a", "b", "c"], fragment => "row=2", sep_char => ","), [{ a => 1, b => 2, c => 3 }], "AOH headers fragment"); is_deeply (csv (in => $tfn, enc => "utf-8", headers => ["a", "b", "c"], fragment => "row=2", sep_char => ","), [{ a => 1, b => 2, c => 3 }], "AOH headers fragment"); } else { ok (1, q{This perl does not support open with "<:encoding(...)"}); ok (1, q{This perl does not support open with "<:encoding(...)"}); } ok (csv (in => $aoa, out => $tfn), "AOA out file"); is_deeply (csv (in => $tfn), $aoa, "AOA parse out"); ok (csv (in => $aoh, out => $tfn, headers => "auto"), "AOH out file"); is_deeply (csv (in => $tfn, headers => "auto"), $aoh, "AOH parse out"); ok (csv (in => $aoh, out => $tfn, headers => "skip"), "AOH out file no header"); is_deeply (csv (in => $tfn, headers => [keys %{$aoh->[0]}]), $aoh, "AOH parse out no header"); my $idx = 0; sub getrowa { return $aoa->[$idx++]; } sub getrowh { return $aoh->[$idx++]; } ok (csv (in => \&getrowa, out => $tfn), "out from CODE/AR"); is_deeply (csv (in => $tfn), $aoa, "data from CODE/AR"); $idx = 0; ok (csv (in => \&getrowh, out => $tfn, headers => \@hdr), "out from CODE/HR"); is_deeply (csv (in => $tfn, headers => "auto"), $aoh, "data from CODE/HR"); $idx = 0; ok (csv (in => \&getrowh, out => $tfn), "out from CODE/HR (auto headers)"); is_deeply (csv (in => $tfn, headers => "auto"), $aoh, "data from CODE/HR"); unlink $tfn; # Basic "key" checks SKIP: { $] < 5.008 and skip "No ScalarIO support for $]", 2; is_deeply (csv (in => \"key,value\n1,2\n", key => "key"), { 1 => { key => 1, value => 2 }}, "key"); is_deeply (csv (in => \"1,2\n", key => "key", headers => [qw( key value )]), { 1 => { key => 1, value => 2 }}, "key"); } # Some "out" checks open my $fh, ">", $tfn or die "$tfn: $!\n"; csv (in => [{ a => 1 }], out => $fh); csv (in => [{ a => 1 }], out => $fh, headers => undef); csv (in => [{ a => 1 }], out => $fh, headers => "auto"); csv (in => [{ a => 1 }], out => $fh, headers => ["a"]); csv (in => [{ b => 1 }], out => $fh, headers => { b => "a" }); close $fh; open $fh, "<", $tfn or die "$tfn: $!\n"; is (do {local $/; <$fh>}, "a\r\n1\r\n" x 5, "AoH to out"); close $fh; # check internal defaults { my $ad = 1; sub check { my ($csv, $ar) = @_; is ($csv->auto_diag, $ad, "default auto_diag ($ad)"); is ($csv->binary, 1, "default binary"); is ($csv->eol, "\r\n", "default eol"); } # check # Note that 5.6.x writes to a *file* named SCALAR(0x50414A10) open my $fh, ">", \my $out or die "IO: $!\n"; csv (in => [[1,2]], out => $fh, on_in => \&check); # Check that I can overrule auto_diag $ad = 0; csv (in => [[1,2]], out => $fh, on_in => \&check, auto_diag => 0); } $] < 5.008 and unlink glob "SCALAR(*)"; # errors { my $err; local $SIG{__DIE__} = sub { $err = shift; }; my $r = eval { csv (in => undef); }; is ($r, undef, "csv needs in or file"); like ($err, qr{^usage:}, "error"); undef $err; } eval { exists $Config{useperlio} && defined $Config{useperlio} && $] >= 5.008 && $Config{useperlio} eq "define" or skip "No scalar ref in this perl", 5; my $out = ""; open my $fh, ">", \$out or die "IO: $!\n"; ok (csv (in => [[ 1, 2, 3 ]], out => $fh), "out to fh to scalar ref"); is ($out, "1,2,3\r\n", "Scalar out"); $out = ""; ok (csv (in => [[ 1, 2, 3 ]], out => \$out), "out to scalar ref"); is ($out, "1,2,3\r\n", "Scalar out"); is_deeply (csv (in => \qq{1,"2 3"}, quo => undef, esc => undef), [["1", q{"2 3"}]], "quo => undef"); }; { my $csv = Text::CSV_XS->new ({ binary => 1, auto_diag => 1 }); my $expect = [["a"],[1],["a"],[1],["a"],[1],["a"],[1],["a"],[1]]; is_deeply ($csv->csv (in => $tfn), $expect, "csv from object"); is_deeply (csv (in => $tfn, csv => $csv), $expect, "csv from attribute"); } { local *STDOUT; my $ofn = "_STDOUT.csv"; open STDOUT, ">", $ofn or die "$ofn: $!\n"; csv (in => $tfn, quote_always => 1, fragment => "row=1-2", on_in => sub { splice @{$_[1]}, 1; }); close STDOUT; open my $oh, "<", $ofn or die "$ofn: $!\n"; is (do { local (@ARGV, $/) = $ofn; <> }, qq{"a"\r\n"1"\r\n}, "Chained csv call inherited attributes"); unlink $ofn; } Text-CSV_XS-1.26/t/51_utf8.t0000644000031300001440000001604312753265123015763 0ustar00merijnusers00000000000000#!/usr/bin/perl use strict; use warnings; use charnames ":full"; use Test::More; $| = 1; BEGIN { $] < 5.008002 and plan skip_all => "UTF8 tests useless in this ancient perl version"; } my @tests; BEGIN { delete $ENV{PERLIO}; my $pu = $ENV{PERL_UNICODE}; $pu = defined $pu && ($pu eq "" || $pu =~ m/[oD]/ || ($pu =~ m/^[0-9]+$/ && $pu & 16)); my $euro_ch = "\x{20ac}"; utf8::encode (my $bytes = $euro_ch); utf8::downgrade (my $bytes_dn = $bytes); utf8::upgrade (my $bytes_up = $bytes); @tests = ( # $test $perlio $data, $encoding $expect_w # ---------------------------- ------------------- ----------- --------- ---------- [ "Unicode default", "", $euro_ch, "utf8", $pu ? "no warn" : "warn" ], [ "Unicode binmode", "[binmode]", $euro_ch, "utf8", "warn", ], [ "Unicode :utf8", ":utf8", $euro_ch, "utf8", "no warn", ], [ "Unicode :encoding(utf8)", ":encoding(utf8)", $euro_ch, "utf8", "no warn", ], [ "Unicode :encoding(UTF-8)", ":encoding(UTF-8)", $euro_ch, "utf8", "no warn", ], [ "bytes dn default", "", $bytes_dn, "[none]", "no warn", ], [ "bytes dn binmode", "[binmode]", $bytes_dn, "[none]", "no warn", ], [ "bytes dn :utf8", ":utf8", $bytes_dn, "utf8", "no warn", ], [ "bytes dn :encoding(utf8)", ":encoding(utf8)", $bytes_dn, "utf8", "no warn", ], [ "bytes dn :encoding(UTF-8)", ":encoding(UTF-8)", $bytes_dn, "utf8", "no warn", ], [ "bytes up default", "", $bytes_up, "[none]", "no warn", ], [ "bytes up binmode", "[binmode]", $bytes_up, "[none]", "no warn", ], [ "bytes up :utf8", ":utf8", $bytes_up, "utf8", "no warn", ], [ "bytes up :encoding(utf8)", ":encoding(utf8)", $bytes_up, "utf8", "no warn", ], [ "bytes up :encoding(UTF-8)", ":encoding(UTF-8)", $bytes_up, "utf8", "no warn", ], ); my $builder = Test::More->builder; binmode $builder->output, ":encoding(utf8)"; binmode $builder->failure_output, ":encoding(utf8)"; binmode $builder->todo_output, ":encoding(utf8)"; plan tests => 11 + 6 * @tests + 4 * 22 + 6; } BEGIN { use_ok "Text::CSV_XS", ("csv"); plan skip_all => "Cannot load Text::CSV_XS" if $@; require "t/util.pl"; } sub hexify { join " ", map { sprintf "%02x", $_ } unpack "C*", @_ } sub warned { length ($_[0]) ? "warn" : "no warn" } my $csv = Text::CSV_XS->new ({ binary => 1, auto_diag => 1 }); for (@tests) { my ($test, $perlio, $data, $enc, $expect_w) = @$_; my $expect = qq{"$data"}; $enc eq "utf8" and utf8::encode ($expect); my ($p_out, $p_fh) = (""); my ($c_out, $c_fh) = (""); if ($perlio eq "[binmode]") { open $p_fh, ">", \$p_out or die "IO: $!\n"; binmode $p_fh; open $c_fh, ">", \$c_out or die "IO: $!\n"; binmode $c_fh; } else { open $p_fh, ">$perlio", \$p_out or die "IO: $!\n"; open $c_fh, ">$perlio", \$c_out or die "IO: $!\n"; } my $p_warn = ""; { local $SIG{__WARN__} = sub { $p_warn .= join "", @_ }; ok ((print $p_fh qq{"$data"}), "$test perl print"); close $p_fh; } my $c_warn = ""; { local $SIG{__WARN__} = sub { $c_warn .= join "", @_ }; ok ($csv->print ($c_fh, [ $data ]), "$test csv print"); close $c_fh; } is (hexify ($c_out), hexify ($p_out), "$test against Perl"); is (hexify ($c_out), hexify ($expect), "$test against expected"); is (warned ($c_warn), warned ($p_warn), "$test against Perl warning"); is (warned ($c_warn), $expect_w, "$test against expected warning"); } # Test automatic upgrades for valid UTF-8 { my $blob = pack "C*", 0..255; $blob =~ tr/",//d; # perl-5.10.x has buggy SvCUR () on blob $] >= 5.010000 && $] <= 5.012001 and $blob =~ tr/\0//d; my @data = ( qq[1,aap,3], # No diac qq[1,a\x{e1}p,3], # a_ACUTE in ISO-8859-1 qq[1,a\x{c4}\x{83}p,3], # a_BREVE in UTF-8 qq[1,"$blob",3], # Binary shit ) x 2; my $data = join "\n" => @data; my @expect = ("aap", "a\341p", "a\x{0103}p", $blob) x 2; my $csv = Text::CSV_XS->new ({ binary => 1, auto_diag => 1 }); foreach my $bc (undef, 3) { my @read; # Using getline () open my $fh, "<", \$data or die "IO: $!\n"; binmode $fh; $bc and $csv->bind_columns (\my ($f1, $f2, $f3)); is (scalar $csv->bind_columns, $bc, "Columns_bound?"); while (my $row = $csv->getline ($fh)) { push @read, $bc ? $f2 : $row->[1]; } close $fh; is_deeply (\@read, \@expect, "Set and reset UTF-8 ".($bc?"no bind":"bind_columns")); is_deeply ([ map { utf8::is_utf8 ($_) } @read ], [ "", "", 1, "", "", "", 1, "" ], "UTF8 flags"); # Using parse () @read = map { $csv->parse ($_); $bc ? $f2 : ($csv->fields)[1]; } @data; is_deeply (\@read, \@expect, "Set and reset UTF-8 ".($bc?"no bind":"bind_columns")); is_deeply ([ map { utf8::is_utf8 ($_) } @read ], [ "", "", 1, "", "", "", 1, "" ], "UTF8 flags"); } } my $sep = "\x{2665}";#"\N{INVISIBLE SEPARATOR}"; my $quo = "\x{2661}";#"\N{FULLWIDTH QUOTATION MARK}"; foreach my $new (0, 1, 2, 3) { my %attr = ( binary => 1, always_quote => 1, );; $new & 1 and $attr{sep} = $sep; $new & 2 and $attr{quote} = $quo; my $csv = Text::CSV_XS->new (\%attr); my $s = $attr{sep} || ','; my $q = $attr{quote} || '"'; note ("Test SEP: '$s', QUO: '$q'") if $Test::More::VERSION > 0.81; is ($csv->sep, $s, "sep"); is ($csv->quote, $q, "quote"); foreach my $data ( [ 1, 2 ], [ "\N{EURO SIGN}", "\N{SNOWMAN}" ], # [ $sep, $quo ], ) { my $exp8 = join $s => map { qq{$q$_$q} } @$data; utf8::encode (my $expb = $exp8); my @exp = ($expb, $exp8); ok ($csv->combine (@$data), "combine"); my $x = $csv->string; is ($csv->string, $exp8, "string"); open my $fh, ">:encoding(utf8)", \(my $out = "") or die "IO: $!\n"; ok ($csv->print ($fh, $data), "print with UTF8 sep"); close $fh; is ($out, $expb, "output"); ok ($csv->parse ($expb), "parse"); is_deeply ([ $csv->fields ], $data, "fields"); open $fh, "<", \$expb or die "IO: $!\n"; binmode $fh; is_deeply ($csv->getline ($fh), $data, "data from getline ()"); close $fh; $expb =~ tr/"//d; ok ($csv->parse ($expb), "parse"); is_deeply ([ $csv->fields ], $data, "fields"); open $fh, "<", \$expb or die "IO: $!\n"; binmode $fh; is_deeply ($csv->getline ($fh), $data, "data from getline ()"); close $fh; } } { my $h = "\N{WHITE HEART SUIT}"; my $H = "\N{BLACK HEART SUIT}"; my $str = "${h}I$h$H${h}L\"${h}ve$h$H${h}Perl$h"; utf8::encode ($str); ok (my $aoa = csv (in => \$str, sep => $H, quote => $h), "Hearts"); is_deeply ($aoa, [[ "I", "L${h}ve", "Perl"]], "I $H Perl"); ok (my $csv = Text::CSV_XS->new ({ binary => 1, sep => $H, quote => $h }), "new hearts"); ok ($csv->combine (@{$aoa->[0]}), "combine"); ok ($str = $csv->string, "string"); utf8::decode ($str); is ($str, "I${H}${h}L\"${h}ve${h}${H}Perl", "Correct quotation"); } Text-CSV_XS-1.26/t/10_base.t0000644000031300001440000000774512753265123016013 0ustar00merijnusers00000000000000#!/usr/bin/perl use strict; use warnings; use Test::More tests => 64; BEGIN { use_ok "Text::CSV_XS"; plan skip_all => "Cannot load Text::CSV_XS" if $@; } # empty subclass test # package Empty_Subclass; @Empty_Subclass::ISA = qw( Text::CSV_XS ); package main; ok (new Text::CSV_XS, "Indirect object notation"); # Important: Do not modify these tests unless you have a good # reason. This file ought to guarantee compatibility to Text::CSV. # my $empty = Empty_Subclass->new (); is (ref $empty, "Empty_Subclass", "Empty Subclass"); is ($empty->version (), Text::CSV_XS->version (), "Version"); ok ($empty->parse (""), "Subclass parse ()"); ok ($empty->combine (""), "Subclass combine ()"); ok ($empty->new, "new () based on object"); my $csv; ok ($csv = Text::CSV_XS->new, "new ()"); is ($csv->fields, undef, "fields () before parse ()"); is ($csv->string, undef, "string () undef before combine"); # Important: Do not modify these tests unless you have a good # reason. This file ought to guarantee compatibility to Text::CSV. # ok (1, "combine () & string () tests"); ok (!$csv->combine (), "Missing arguments"); ok (!$csv->combine ("abc", "def\n", "ghi"), "Bad character"); is ( $csv->error_input, "def\n", "Error_input ()"); ok ( $csv->combine (""), "Empty string - combine ()"); is ( $csv->string, '', "Empty string - string ()"); ok ( $csv->combine ("", " "), "Two fields, one space - combine ()"); is ( $csv->string, '," "', "Two fields, one space - string ()"); ok ( $csv->combine ("", 'I said, "Hi!"', ""), "Hi! - combine ()"); is ( $csv->string, ',"I said, ""Hi!""",', "Hi! - string ()"); ok ( $csv->combine ('"', "abc"), "abc - combine ()"); is ( $csv->string, '"""",abc', "abc - string ()"); ok ( $csv->combine (","), "comma - combine ()"); is ( $csv->string, '","', "comma - string ()"); ok ( $csv->combine ("abc", '"'), "abc + \" - combine ()"); is ( $csv->string, 'abc,""""', "abc + \" - string ()"); ok ( $csv->combine ("abc", "def", "ghi", "j,k"), "abc .. j,k - combine ()"); is ( $csv->string, 'abc,def,ghi,"j,k"', "abc .. j,k - string ()"); ok ( $csv->combine ("abc\tdef", "ghi"), "abc + TAB - combine ()"); is ( $csv->string, qq("abc\tdef",ghi), "abc + TAB - string ()"); ok (1, "parse () tests"); ok (!$csv->parse (), "Missing arguments"); ok ( $csv->parse ("\n"), "Single newline"); ok (!$csv->parse ('"abc'), "Missing closing \""); ok (!$csv->parse ('ab"c'), "\" outside of \"'s"); ok (!$csv->parse ('"ab"c"'), "Bad character sequence"); ok (!$csv->parse (qq("abc\nc")), "Bad character (NL)"); ok (!$csv->status (), "Wrong status ()"); ok ( $csv->parse ('","'), "comma - parse ()"); is ( scalar $csv->fields (), 1, "comma - fields () - count"); is (($csv->fields ())[0], ",", "comma - fields () - content"); ok ( $csv->parse (qq("","I said,\t""Hi!""","")), "Hi! - parse ()"); is ( scalar $csv->fields (), 3, "Hi! - fields () - count"); is (($csv->fields ())[0], "", "Hi! - fields () - field 1"); is (($csv->fields ())[1], qq(I said,\t"Hi!"), "Hi! - fields () - field 2"); is (($csv->fields ())[2], "", "Hi! - fields () - field 3"); ok ( $csv->status (), "status ()"); ok ( $csv->parse (""), "Empty line"); is ( scalar $csv->fields (), 1, "Empty - count"); is (($csv->fields ())[0], "", "One empty field"); # Are Integers and Reals quoted? # # Important: Do not modify these tests unless you have a good # reason. This file ought to guarantee compatibility to Text::CSV. # ok (1, "Integers and Reals"); ok ( $csv->combine ("", 2, 3.25, "a", "a b"), "Mixed - combine ()"); is ( $csv->string, ',2,3.25,a,"a b"', "Mixed - string ()"); # New from object ok ($csv->new (), "\$csv->new ()"); my $state; for ( [ 0, 0 ], [ 0, "foo" ], [ 0, {} ], [ 0, \0 ], [ 0, *STDOUT ], ) { eval { $state = $csv->print (@$_) }; ok (!$state, "print needs (IO, ARRAY_REF)"); ok ($@ =~ m/^Expected fields to be an array ref/, "Error msg"); } 1; Text-CSV_XS-1.26/t/55_combi.t0000644000031300001440000000765012753265123016176 0ustar00merijnusers00000000000000#!/usr/bin/perl use strict; use warnings; use Test::More tests => 25107; BEGIN { require_ok "Text::CSV_XS"; plan skip_all => "Cannot load Text::CSV_XS" if $@; require "t/util.pl"; } my $csv = Text::CSV_XS->new ({ binary => 1 }); my @attrib = qw( quote_char escape_char sep_char ); my @special = ('"', "'", ",", ";", "\t", "\\", "~"); # Add undef, once we can return undef my @input = ( "", 1, "1", 1.4, "1.4", " - 1,4", "1+2=3", "' ain't it great '", '"foo"! said the `br', q{the ~ in "0 \0 this l'ne is \r ; or "'"} ); my $ninput = scalar @input; my $string = join "=", "", @input, ""; my %fail; ok (1, "-- qc ec sc ac"); sub combi { my %attr = @_; my $combi = join " ", "--", map { sprintf "%6s", _readable $attr{$_} } @attrib, "always_quote"; ok (1, $combi); # use legal non-special characters is ($csv->allow_whitespace (0), 0, "Reset allow WS"); is ($csv->sep_char ("\x03"), "\x03", "Reset sep"); is ($csv->quote_char ("\x04"), "\x04", "Reset quo"); is ($csv->escape_char ("\x05"), "\x05", "Reset esc"); # Set the attributes and check failure my %state; foreach my $attr (sort keys %attr) { eval { $csv->$attr ($attr{$attr}); }; $@ or next; $state{0 + $csv->error_diag} ||= $@; } if ($attr{sep_char} eq $attr{quote_char} || $attr{sep_char} eq $attr{escape_char}) { ok (exists $state{1001}, "Illegal combo"); like ($state{1001}, qr{sep_char is equal to}, "Illegal combo"); } else { ok (!exists $state{1001}, "No char conflict"); } if (!exists $state{1001} and $attr{sep_char} =~ m/[\r\n]/ || $attr{quote_char} =~ m/[\r\n]/ || $attr{escape_char} =~ m/[\r\n]/ ) { ok (exists $state{1003}, "Special contains eol"); like ($state{1003}, qr{in main attr not}, "Illegal combo"); } if ($attr{allow_whitespace} and $attr{quote_char} =~ m/^[ \t]/ || $attr{escape_char} =~ m/^[ \t]/ ) { #diag (join " -> ** " => $combi, join ", " => sort %state); ok (exists $state{1002}, "Illegal combo under allow_whitespace"); like ($state{1002}, qr{allow_whitespace with}, "Illegal combo"); } %state and return; # Check success is ($csv->$_ (), $attr{$_}, "check $_") for sort keys %attr; my $ret = $csv->combine (@input); ok ($ret, "combine"); ok (my $str = $csv->string, "string"); SKIP: { ok (my $ok = $csv->parse ($str), "parse"); unless ($ok) { $fail{parse}{$combi} = $csv->error_input; skip "parse () failed", 3; } ok (my @ret = $csv->fields, "fields"); unless (@ret) { $fail{fields}{$combi} = $csv->error_input; skip "fields () failed", 2; } is (scalar @ret, $ninput, "$ninput fields"); unless (scalar @ret == $ninput) { $fail{'$#fields'}{$combi} = $str; skip "# fields failed", 1; } my $ret = join "=", "", @ret, ""; is ($ret, $string, "content"); } } # combi foreach my $aw (0, 1) { foreach my $aq (0, 1) { foreach my $qc (@special) { foreach my $ec (@special, "+") { foreach my $sc (@special, "\0") { combi ( sep_char => $sc, quote_char => $qc, escape_char => $ec, always_quote => $aq, allow_whitespace => $aw, ); } } } } } foreach my $fail (sort keys %fail) { print STDERR "Failed combi for $fail ():\n", "-- qc ec sc ac\n"; foreach my $combi (sort keys %{$fail{$fail}}) { printf STDERR "%-20s - %s\n", map { _readable $_ } $combi, $fail{$fail}{$combi}; } } { my $err = ""; local $SIG{__WARN__} = sub { $err = shift; }; is (Text::CSV_XS->new ({ sep => ",", quote => ",", auto_diag => 1 }), undef, "New (illegal combo + auto_diag)"); like ($err, qr{\bERROR: 1001 - INI -}, "Error message"); $err = ""; ok (my $csv = Text::CSV_XS->new ({ auto_diag => 1 }), "new auto_diag"); eval { $csv->sep ('"'); }; like ($err, qr{\bERROR: 1001 - INI -}, "Error message"); is ($csv->sep_char (), '"', "sep changed anyway"); } 1; Text-CSV_XS-1.26/t/91_csv_cb.t0000644000031300001440000001210712753265123016335 0ustar00merijnusers00000000000000#!/usr/bin/perl use strict; use warnings; #use Test::More "no_plan"; use Test::More tests => 48; BEGIN { use_ok "Text::CSV_XS", ("csv"); plan skip_all => "Cannot load Text::CSV_XS" if $@; require "t/util.pl"; } my $tfn = "_91test.csv"; END { -f $tfn and unlink $tfn } my $data = "foo,bar,baz\n". "1,2,3\n". "2,a b,\n"; open FH, ">", $tfn or die "$tfn: $!"; print FH $data; close FH; my $aoa = [ [qw( foo bar baz )], [ 1, 2, 3 ], [ 2, "a b", "" ], ]; my $aoh = [ { foo => 1, bar => 2, baz => 3 }, { foo => 2, bar => "a b", baz => "" }, ]; for (qw( after_in on_in before_out )) { is_deeply (csv (in => $tfn, $_ => sub {}), $aoa, "callback $_ on AOA with empty sub"); is_deeply (csv (in => $tfn, callbacks => { $_ => sub {} }), $aoa, "callback $_ on AOA with empty sub"); } is_deeply (csv (in => $tfn, after_in => sub {}, callbacks => { on_in => sub {} }), $aoa, "callback after_in and on_in on AOA"); for (qw( after_in on_in before_out )) { is_deeply (csv (in => $tfn, headers => "auto", $_ => sub {}), $aoh, "callback $_ on AOH with empty sub"); is_deeply (csv (in => $tfn, headers => "auto", callbacks => { $_ => sub {} }), $aoh, "callback $_ on AOH with empty sub"); } is_deeply (csv (in => $tfn, headers => "auto", after_in => sub {}, callbacks => { on_in => sub {} }), $aoh, "callback after_in and on_in on AOH"); is_deeply (csv (in => $tfn, after_in => sub { push @{$_[1]}, "A" }), [ [qw( foo bar baz A )], [ 1, 2, 3, "A" ], [ 2, "a b", "", "A" ], ], "AOA ith after_in callback"); is_deeply (csv (in => $tfn, headers => "auto", after_in => sub { $_[1]{baz} = "A" }), [ { foo => 1, bar => 2, baz => "A" }, { foo => 2, bar => "a b", baz => "A" }, ], "AOH with after_in callback"); is_deeply (csv (in => $tfn, filter => { 2 => sub { /a/ }}), [ [qw( foo bar baz )], [ 2, "a b", "" ], ], "AOA with filter on col 2"); is_deeply (csv (in => $tfn, filter => { 2 => sub { /a/ }, 1 => sub { length > 1 }}), [ [qw( foo bar baz )], ], "AOA with filter on col 1 and 2"); is_deeply (csv (in => $tfn, filter => { foo => sub { $_ > 1 }}), [ { foo => 2, bar => "a b", baz => "" }, ], "AOH with filter on column name"); is_deeply (csv (in => $tfn, headers => "lc"), [ { foo => 1, bar => 2, baz => 3 }, { foo => 2, bar => "a b", baz => "" }], "AOH with lc headers"); is_deeply (csv (in => $tfn, headers => "uc"), [ { FOO => 1, BAR => 2, BAZ => 3 }, { FOO => 2, BAR => "a b", BAZ => "" }], "AOH with lc headers"); is_deeply (csv (in => $tfn, headers => sub { lcfirst uc $_[0] }), [ { fOO => 1, bAR => 2, bAZ => 3 }, { fOO => 2, bAR => "a b", bAZ => "" }], "AOH with mangled headers"); open FH, ">>", $tfn or die "$tfn: $!"; print FH <<"EOD"; 3,3,3 4,5,6 5,7,9 6,9,12 7,11,15 8,13,18 EOD close FH; is_deeply (csv (in => $tfn, filter => { foo => sub { $_ > 2 && $_[1][2] - $_[1][1] < 4 }}), [ { foo => 3, bar => 3, baz => 3 }, { foo => 4, bar => 5, baz => 6 }, { foo => 5, bar => 7, baz => 9 }, { foo => 6, bar => 9, baz => 12 }, ], "AOH with filter on column name + on other numbered fields"); is_deeply (csv (in => $tfn, filter => { foo => sub { $_ > 2 && $_{baz} - $_{bar} < 4 }}), [ { foo => 3, bar => 3, baz => 3 }, { foo => 4, bar => 5, baz => 6 }, { foo => 5, bar => 7, baz => 9 }, { foo => 6, bar => 9, baz => 12 }, ], "AOH with filter on column name + on other named fields"); # Check content ref in on_in AOA { my $aoa = csv ( in => $tfn, filter => { 1 => sub { m/^[3-9]/ }}, on_in => sub { is ($_[1][1], 2 * $_[1][0] - 3, "AOA $_[1][0]: b = 2a - 3 \$_[1][]"); }); } # Check content ref in on_in AOH { my $aoa = csv ( in => $tfn, headers => "auto", filter => { foo => sub { m/^[3-9]/ }}, after_parse => sub { is ($_[1]{bar}, 2 * $_[1]{foo} - 3, "AOH $_[1]{foo}: b = 2a - 3 \$_[1]{}"); }); } # Check content ref in on_in AOH with aliases %_ { %_ = ( brt => 42 ); my $aoa = csv ( in => $tfn, headers => "auto", filter => { foo => sub { m/^[3-9]/ }}, on_in => sub { is ($_{bar}, 2 * $_{foo} - 3, "AOH $_{foo}: b = 2a - 3 \$_{}"); }); is_deeply (\%_, { brt => 42 }, "%_ restored"); } # Add to %_ in callback is_deeply (csv (in => $tfn, headers => "auto", filter => { 1 => sub { $_ eq "4" }}, on_in => sub { $_{brt} = 42; }), [{ foo => 4, bar => 5, baz => 6, brt => 42 }], "AOH with addition to %_ in on_in"); open FH, ">", $tfn or die "$tfn: $!"; print FH <<"EOD"; 3,3,3 5,7,9 , "", ,, , ,"", ,," ", "" 8,13,18 EOD close FH; is_deeply (csv (in => $tfn, filter => "not_blank"), [[3,3,3],[5,7,9],["",""],["",""],["",""," ",""], ["","",""],["",""," ",""],[8,13,18]], "filter => not_blank"); is_deeply (csv (in => $tfn, filter => "not_empty"), [[3,3,3],[5,7,9],["",""," ",""],["",""," ",""],[8,13,18]], "filter => not_empty"); is_deeply (csv (in => $tfn, filter => "filled"), [[3,3,3],[5,7,9],[8,13,18]], "filter => filled"); Text-CSV_XS-1.26/t/80_diag.t0000644000031300001440000002066312753265123016006 0ustar00merijnusers00000000000000#!/usr/bin/perl use strict; use warnings; use Test::More tests => 264; #use Test::More "no_plan"; my %err; BEGIN { require_ok "Text::CSV_XS"; plan skip_all => "Cannot load Text::CSV_XS" if $@; require "t/util.pl"; open XS, "<", "CSV_XS.xs" or die "Cannot read error messages from XS\n"; while () { m/^ \{ ([0-9]{4}), "([^"]+)"\s+\}/ and $err{$1} = $2; } } $| = 1; my $csv = Text::CSV_XS->new (); is (Text::CSV_XS::error_diag (), "", "Last failure for new () - OK"); is_deeply ([ $csv->error_diag ], [ 0, "", 0, 0, 0], "OK in list context"); sub parse_err { my ($n_err, $p_err, $r_err, $f_err, $str) = @_; my $s_err = $err{$n_err}; my $STR = _readable ($str); is ($csv->parse ($str), 0, "$n_err - Err for parse ('$STR')"); is ($csv->error_diag () + 0, $n_err, "$n_err - Diag in numerical context"); is ($csv->error_diag (), $s_err, "$n_err - Diag in string context"); my ($c_diag, $s_diag, $p_diag, $r_diag, $f_diag) = $csv->error_diag (); is ($c_diag, $n_err, "$n_err - Num diag in list context"); is ($s_diag, $s_err, "$n_err - Str diag in list context"); is ($p_diag, $p_err, "$n_err - Pos diag in list context"); is ($r_diag, $r_err, "$n_err - Rec diag in list context"); is ($f_diag, $f_err, "$n_err - Fld diag in list context"); } # parse_err parse_err 2023, 19, 1, 2, qq{2023,",2008-04-05,"Foo, Bar",\n}; # " $csv = Text::CSV_XS->new ({ escape_char => "+", eol => "\n" }); is ($csv->error_diag (), "", "No errors yet"); parse_err 2010, 3, 1, 1, qq{"x"\r}; parse_err 2011, 4, 2, 1, qq{"x"x}; parse_err 2021, 2, 3, 1, qq{"\n"}; parse_err 2022, 2, 4, 1, qq{"\r"}; parse_err 2025, 2, 5, 1, qq{"+ "}; parse_err 2026, 2, 6, 1, qq{"\0 "}; parse_err 2027, 1, 7, 1, '"'; parse_err 2031, 1, 8, 1, qq{\r }; parse_err 2032, 2, 9, 1, qq{ \r}; parse_err 2034, 4, 10, 2, qq{1, "bar",2}; parse_err 2037, 1, 11, 1, qq{\0 }; { my @warn; local $SIG{__WARN__} = sub { push @warn, @_ }; $csv->error_diag (); ok (@warn == 1, "Got error message"); like ($warn[0], qr{^# CSV_XS ERROR: 2037 - EIF}, "error content"); } is ($csv->eof, "", "No EOF"); $csv->SetDiag (2012); is ($csv->eof, 1, "EOF caused by 2012"); is (Text::CSV_XS->new ({ ecs_char => ":" }), undef, "Unsupported option"); { my @warn; local $SIG{__WARN__} = sub { push @warn, @_ }; Text::CSV_XS::error_diag (); ok (@warn == 1, "Error_diag in void context ::"); like ($warn[0], qr{^# CSV_XS ERROR: 1000 - INI}, "error content"); } { my @warn; local $SIG{__WARN__} = sub { push @warn, @_ }; Text::CSV_XS->error_diag (); ok (@warn == 1, "Error_diag in void context ->"); like ($warn[0], qr{^# CSV_XS ERROR: 1000 - INI}, "error content"); } { my @warn; local $SIG{__WARN__} = sub { push @warn, @_ }; is (Text::CSV_XS->new ({ auto_diag => 0, ecs_char => ":" }), undef, "Unsupported option"); ok (@warn == 0, "Error_diag in from new ({ auto_diag => 0})"); } { my @warn; local $SIG{__WARN__} = sub { push @warn, @_ }; is (Text::CSV_XS->new ({ auto_diag => 1, ecs_char => ":" }), undef, "Unsupported option"); ok (@warn == 1, "Error_diag in from new ({ auto_diag => 1})"); like ($warn[0], qr{^# CSV_XS ERROR: 1000 - INI}, "error content"); } is (Text::CSV_XS::error_diag (), "INI - Unknown attribute 'ecs_char'", "Last failure for new () - FAIL"); is (Text::CSV_XS->error_diag (), "INI - Unknown attribute 'ecs_char'", "Last failure for new () - FAIL"); is (Text::CSV_XS::error_diag (bless {}, "Foo"), "INI - Unknown attribute 'ecs_char'", "Last failure for new () - FAIL"); $csv->SetDiag (1000); is (0 + $csv->error_diag (), 1000, "Set error NUM"); is ( $csv->error_diag (), "INI - constructor failed","Set error STR"); $csv->SetDiag (0); is (0 + $csv->error_diag (), 0, "Reset error NUM"); is ( $csv->error_diag (), "", "Reset error STR"); ok (1, "Test auto_diag"); $csv = Text::CSV_XS->new ({ auto_diag => 1 }); { my @warn; local $SIG{__WARN__} = sub { push @warn, @_ }; is ($csv->{_RECNO}, 0, "No records read yet"); is ($csv->parse ('"","'), 0, "1 - bad parse"); ok (@warn == 1, "1 - One error"); like ($warn[0], qr '^# CSV_XS ERROR: 2027 -', "1 - error message"); is ($csv->{_RECNO}, 1, "One record read"); } { my @warn; local $SIG{__WARN__} = sub { push @warn, @_ }; is ($csv->diag_verbose (3), 3, "Set diag_verbose"); is ($csv->parse ('"","'), 0, "1 - bad parse"); ok (@warn == 1, "1 - One error"); @warn = split m/\n/ => $warn[0]; ok (@warn == 3, "1 - error plus two lines"); like ($warn[0], qr '^# CSV_XS ERROR: 2027 -', "1 - error message"); like ($warn[1], qr '^"","', "1 - input line"); like ($warn[2], qr '^ \^', "1 - position indicator"); is ($csv->{_RECNO}, 2, "Another record read"); } { ok ($csv->{auto_diag} = 2, "auto_diag = 2 to die"); eval { $csv->parse ('"","') }; like ($@, qr '^# CSV_XS ERROR: 2027 -', "2 - error message"); } { my @warn; local $SIG{__WARN__} = sub { push @warn, @_ }; # Invalid error_input calls is (Text::CSV_XS::error_input (undef), undef, "Bad error_input call"); is (Text::CSV_XS::error_input (""), undef, "Bad error_input call"); is (Text::CSV_XS::error_input ([]), undef, "Bad error_input call"); is (Text::CSV_XS->error_input, undef, "Bad error_input call"); ok (my $csv = Text::CSV_XS->new (), "new for cache diag"); $csv->_cache_diag (); ok (@warn == 1, "Got warn"); is ($warn[0], "CACHE: invalid\n", "Uninitialized cache"); @warn = (); ok ($csv->parse ("1"), "parse"); # initialize cache $csv->_cache_set (987, 10); ok (@warn == 1, "Got warn"); is ($warn[0], "Unknown cache index 987 ignored\n", "Ignore bad cache calls"); is ($csv->parse ('"'), 0, "Bad parse"); is ($csv->error_input, '"', "Error input"); ok ($csv->_cache_set (34, 0), "Reset error input (dangerous!)"); is ($csv->error_input, '"', "Error input not reset"); } { my $csv = Text::CSV_XS->new (); ok ($csv->parse (q{1,"abc"}), "Valid parse"); is ($csv->error_input (), undef, "Undefined error_input"); is ($csv->{_ERROR_INPUT}, undef, "Undefined error_input"); } foreach my $spec ( undef, # No spec at all "", # No spec at all "row=0", # row > 0 "col=0", # col > 0 "cell=0", # cell = r,c "cell=0,0", # TL col > 0 "cell=1,0", # TL row > 0 "cell=1,1;0,1", # BR col > 0 "cell=1,1;1,0", # BR row > 0 "row=*", # * only after n- "col=3-1", # to >= from "cell=4,1;1", # cell has no ; "cell=3,3-2,1", # bottom-right should be right to and below top-left "cell=3,3-2,*", # bottom-right should be right to and below top-left "cell=3,3-4,1", # bottom-right should be right to and below top-left "cell=3,3-*,1", # bottom-right should be right to and below top-left "cell=1,*", # * in single cell col "cell=*,1", # * in single cell row "cell=*,*", # * in single cell row and column "cell=1,*-8,9", # * in cell range top-left cell col "cell=*,1-8,9", # * in cell range top-left cell row "cell=*,*-8,9", # * in cell range top-left cell row and column "row=/", # illegal character "col=4;row=3", # cannot combine rows and columns ) { my $csv = Text::CSV_XS->new (); my $r; eval { $r = $csv->fragment (undef, $spec); }; is ($r, undef, "Cannot do fragment with bad RFC7111 spec"); my ($c_diag, $s_diag, $p_diag) = $csv->error_diag (); is ($c_diag, 2013, "Illegal RFC7111 spec"); is ($p_diag, 0, "Position"); } my $diag_file = "_$$.out"; open EH, ">&STDERR" or die "STDERR: $!\n"; open STDERR, ">", $diag_file or die "STDERR: $!\n"; # Trigger extra output for longer quote and sep is ($csv->sep ("--"), "--", "set longer sep"); is ($csv->quote ("^^"), "^^", "set longer quote"); ok ($csv->_cache_diag, "Cache debugging output"); close STDERR; open STDERR, ">&EH" or die "STDERR: $!\n"; open EH, "<", $diag_file or die "STDERR: $!\n"; is (scalar , "CACHE:\n", "Title"); while () { like ($_, qr{^ \w+\s+[0-9a-f]+:(?:".*"|\s*[0-9]+)$}, "Content"); } close EH; unlink $diag_file; { my $err = ""; local $SIG{__DIE__} = sub { $err = shift; }; ok (my $csv = Text::CSV_XS->new, "new"); eval { $csv->print_hr (*STDERR, {}); }; is (0 + $csv->error_diag, 3009, "Missing column names"); ok ($csv->column_names ("foo"), "set columns"); eval { $csv->print_hr (*STDERR, []); }; is (0 + $csv->error_diag, 3010, "print_hr needs a hashref"); } 1; Text-CSV_XS-1.26/t/45_eol.t0000644000031300001440000002202212753265123015651 0ustar00merijnusers00000000000000#!/usr/bin/perl use strict; use warnings; use Test::More tests => 1082; BEGIN { require_ok "Text::CSV_XS"; plan skip_all => "Cannot load Text::CSV_XS" if $@; require "t/util.pl"; } $| = 1; # Embedded newline tests my $tfn = "_45eol.csv"; END { -f $tfn and unlink $tfn; } my $def_rs = $/; foreach my $rs ("\n", "\r\n", "\r") { for $\ (undef, $rs) { my $csv = Text::CSV_XS->new ({ binary => 1 }); $csv->eol ($/ = $rs) unless defined $\; foreach my $pass (0, 1) { my $fh; if ($pass == 0) { open $fh, ">", $tfn or die "$tfn: $!\n"; } else { open $fh, "<", $tfn or die "$tfn: $!\n"; } foreach my $eol ("", "\r", "\n", "\r\n", "\n\r") { my $s_eol = join " - ", map { defined $_ ? $_ : "" } $\, $rs, $eol; $s_eol =~ s/\r/\\r/g; $s_eol =~ s/\n/\\n/g; my @p; my @f = ("", 1, $eol, " $eol", "$eol ", " $eol ", "'$eol'", "\"$eol\"", " \" $eol \"\n ", "EOL"); if ($pass == 0) { ok ($csv->combine (@f), "combine |$s_eol|"); ok (my $str = $csv->string, "string |$s_eol|"); my $state = $csv->parse ($str); ok ($state, "parse |$s_eol|"); if ($state) { ok (@p = $csv->fields, "fields |$s_eol|"); } else{ is ($csv->error_input, $str, "error |$s_eol|"); } print $fh $str; } else { ok (my $row = $csv->getline ($fh), "getline |$s_eol|"); is (ref $row, "ARRAY", "row |$s_eol|"); @p = @$row; } local $, = "|"; is_binary ("@p", "@f", "result |$s_eol|"); } close $fh; } unlink $tfn; } } $/ = $def_rs; { my $csv = Text::CSV_XS->new ({ escape_char => undef }); ok ($csv->parse (qq{"x"\r\n}), "Trailing \\r\\n with no escape char"); is ($csv->eol ("\r"), "\r", "eol set to \\r"); ok ($csv->parse (qq{"x"\r}), "Trailing \\r with no escape char"); ok ($csv->allow_whitespace (1), "Allow whitespace"); ok ($csv->parse (qq{"x" \r}), "Trailing \\r with no escape char"); } SKIP: { $] < 5.008 and skip "\$\\ tests don't work in perl 5.6.x and older", 2; { local $\ = "#\r\n"; my $csv = Text::CSV_XS->new (); open my $fh, ">", $tfn or die "$tfn: $!\n"; $csv->print ($fh, [ "a", 1 ]); close $fh; open $fh, "<", $tfn or die "$tfn: $!\n"; local $/; is (<$fh>, "a,1#\r\n", "Strange \$\\"); close $fh; unlink $tfn; } { local $\ = "#\r\n"; my $csv = Text::CSV_XS->new ({ eol => $\ }); open my $fh, ">", $tfn or die "$tfn: $!\n"; $csv->print ($fh, [ "a", 1 ]); close $fh; open $fh, "<", $tfn or die "$tfn: $!\n"; local $/; is (<$fh>, "a,1#\r\n", "Strange \$\\ + eol"); close $fh; unlink $tfn; } } $/ = $def_rs; ok (1, "Auto-detecting \\r"); { my @row = qw( a b c ); local $" = ","; for (["\n", "\\n"], ["\r\n", "\\r\\n"], ["\r", "\\r"]) { my ($eol, $s_eol) = @$_; open my $fh, ">", $tfn or die "$tfn: $!\n"; print $fh qq{@row$eol@row$eol@row$eol\x91}; close $fh; open $fh, "<", $tfn or die "$tfn: $!\n"; my $c = Text::CSV_XS->new ({ binary => 1, auto_diag => 1 }); is ($c->eol (), "", "default EOL"); is_deeply ($c->getline ($fh), [ @row ], "EOL 1 $s_eol"); is ($c->eol (), $eol eq "\r" ? "\r" : "", "EOL"); is_deeply ($c->getline ($fh), [ @row ], "EOL 2 $s_eol"); is_deeply ($c->getline ($fh), [ @row ], "EOL 3 $s_eol"); close $fh; unlink $tfn; } } ok (1, "Specific \\r test from tfrayner"); { $/ = "\r"; open my $fh, ">", $tfn or die "$tfn: $!\n"; print $fh qq{a,b,c$/}, qq{"d","e","f"$/}; close $fh; open $fh, "<", $tfn or die "$tfn: $!\n"; my $c = Text::CSV_XS->new ({ eol => $/ }); my $row; local $" = " "; ok ($row = $c->getline ($fh), "getline 1"); is (scalar @$row, 3, "# fields"); is ("@$row", "a b c", "fields 1"); ok ($row = $c->getline ($fh), "getline 2"); is (scalar @$row, 3, "# fields"); is ("@$row", "d e f", "fields 2"); close $fh; unlink $tfn; } $/ = $def_rs; ok (1, "EOL undef"); { $/ = "\r"; ok (my $csv = Text::CSV_XS->new ({ eol => undef }), "new csv with eol => undef"); open my $fh, ">", $tfn or die "$tfn: $!\n"; ok ($csv->print ($fh, [1, 2, 3]), "print"); ok ($csv->print ($fh, [4, 5, 6]), "print"); close $fh; open $fh, "<", $tfn or die "$tfn: $!\n"; ok (my $row = $csv->getline ($fh), "getline 1"); is (scalar @$row, 5, "# fields"); is_deeply ($row, [ 1, 2, 34, 5, 6], "fields 1"); close $fh; unlink $tfn; } $/ = $def_rs; foreach my $eol ("!", "!!", "!\n", "!\n!", "!!!!!!!!", "!!!!!!!!!!", "\n!!!!!\n!!!!!", "!!!!!\n!!!!!\n", "%^+_\n\0!X**", "\r\n", "\r") { (my $s_eol = $eol) =~ s/\n/\\n/g; $s_eol =~ s/\r/\\r/g; $s_eol =~ s/\0/\\0/g; ok (1, "EOL $s_eol"); ok (my $csv = Text::CSV_XS->new ({ eol => $eol }), "new csv with eol => $s_eol"); open my $fh, ">", $tfn or die "$tfn: $!\n"; ok ($csv->print ($fh, [1, 2, 3]), "print"); ok ($csv->print ($fh, [4, 5, 6]), "print"); close $fh; foreach my $rs (undef, "", "\n", $eol, "!", "!\n", "\n!", "!\n!", "\n!\n") { local $/ = $rs; (my $s_rs = defined $rs ? $rs : "-- undef --") =~ s/\n/\\n/g; ok (1, "with RS $s_rs"); open $fh, "<", $tfn or die "$tfn: $!\n"; ok (my $row = $csv->getline ($fh), "getline 1"); is (scalar @$row, 3, "field count"); is_deeply ($row, [ 1, 2, 3], "fields 1"); ok ( $row = $csv->getline ($fh), "getline 2"); is (scalar @$row, 3, "field count"); is_deeply ($row, [ 4, 5, 6], "fields 2"); close $fh; } unlink $tfn; } $/ = $def_rs; { open my $fh, "<", "files/macosx.csv" or die "files/macosx.csv: $!"; ok (1, "MacOSX exported file"); ok (my $csv = Text::CSV_XS->new ({ auto_diag => 1, binary => 1 }), "new csv"); ok (my $row = $csv->getline ($fh), "getline 1"); is (scalar @$row, 15, "field count"); is ($row->[7], "", "field 8"); ok ( $row = $csv->getline ($fh), "getline 2"); is (scalar @$row, 15, "field count"); is ($row->[6], "Category", "field 7"); ok ( $row = $csv->getline ($fh), "getline 3"); is (scalar @$row, 15, "field count"); is ($row->[5], "Notes", "field 6"); ok ( $row = $csv->getline ($fh), "getline 4"); is (scalar @$row, 15, "field count"); is ($row->[7], "Points", "field 8"); ok ( $row = $csv->getline ($fh), "getline 5"); is (scalar @$row, 15, "field count"); is ($row->[7], 11, "field 8"); ok ( $row = $csv->getline ($fh), "getline 6"); is (scalar @$row, 15, "field count"); is ($row->[8], 34, "field 9"); ok ( $row = $csv->getline ($fh), "getline 7"); is (scalar @$row, 15, "field count"); is ($row->[7], 12, "field 8"); ok ( $row = $csv->getline ($fh), "getline 8"); is (scalar @$row, 15, "field count"); is ($row->[8], 2, "field 9"); ok ( $row = $csv->getline ($fh), "getline 9"); is (scalar @$row, 15, "field count"); is ($row->[3], "devs", "field 4"); ok ( $row = $csv->getline ($fh), "getline 10"); is (scalar @$row, 15, "field count"); is ($row->[3], "", "field 4"); ok ( $row = $csv->getline ($fh), "getline 11"); is (scalar @$row, 15, "field count"); is ($row->[6], "Mean", "field 7"); ok ( $row = $csv->getline ($fh), "getline 12"); is (scalar @$row, 15, "field count"); is ($row->[6], "Median", "field 7"); ok ( $row = $csv->getline ($fh), "getline 13"); is (scalar @$row, 15, "field count"); is ($row->[6], "Mode", "field 7"); ok ( $row = $csv->getline ($fh), "getline 14"); is (scalar @$row, 15, "field count"); is ($row->[6], "Min", "field 7"); ok ( $row = $csv->getline ($fh), "getline 15"); is (scalar @$row, 15, "field count"); is ($row->[6], "Max", "field 7"); ok ( $row = $csv->getline ($fh), "getline 16"); is (scalar @$row, 15, "field count"); is ($row->[0], "", "field 1"); close $fh; } { ok (my $csv = Text::CSV_XS->new ({ auto_diag => 1, binary => 1 }), "new csv"); ok ($csv->eol ("--"), "eol = --"); ok ($csv->parse (qq{1,"2--3",4}), "no eol"); is_deeply ([$csv->fields], [ "1", "2--3", 4 ], "parse"); ok ($csv->parse (qq{1,"2--3",4--}), "eol"); is_deeply ([$csv->fields], [ "1", "2--3", 4 ], "parse"); ok ($csv->parse (qq{1,"2--3",4,--}), ",eol"); is_deeply ([$csv->fields], [ "1", "2--3", 4, "" ], "parse"); open my $fh, ">", $tfn or die "$tfn: $!\n"; print $fh qq{1,"2--3",4--}; print $fh qq{1,"2--3",4,--}; print $fh qq{1,"2--3",4}; close $fh; open $fh, "<", $tfn or die "$tfn: $!\n"; is_deeply ($csv->getline ($fh), [ "1", "2--3", 4 ], "getline eol"); is_deeply ($csv->getline ($fh), [ "1", "2--3", 4, "" ], "getline ,eol"); is_deeply ($csv->getline ($fh), [ "1", "2--3", 4 ], "getline eof"); close $fh; } { ok (my $csv = Text::CSV_XS->new (), "new csv"); ok ($csv->parse (qq{"a","b","c"\r\n}), "parse \\r\\n"); is_deeply ([$csv->fields], [qw( a b c )], "result"); ok ($csv->allow_loose_escapes (1), "allow loose escapes"); ok ($csv->parse (qq{"a","b","c"\r\n}), "parse \\r\\n"); is_deeply ([$csv->fields], [qw( a b c )], "result"); } 1; Text-CSV_XS-1.26/t/79_callbacks.t0000644000031300001440000001242112753265123017022 0ustar00merijnusers00000000000000#!/usr/bin/perl use strict; use warnings; use Test::More tests => 111; #use Test::More "no_plan"; BEGIN { require_ok "Text::CSV_XS"; plan skip_all => "Cannot load Text::CSV_XS" if $@; require "t/util.pl"; } $| = 1; my $csv; my $tfn = "_79test.csv"; END { -f $tfn and unlink $tfn; } # These tests are for the constructor { my $warn; local $SIG{__WARN__} = sub { $warn = shift; }; ok ($csv = Text::CSV_XS->new ({ callbacks => undef }), "new"); is ($warn, undef, "no warn for undef"); is ($csv->callbacks, $warn = undef, "no callbacks for undef"); ok ($csv = Text::CSV_XS->new ({ callbacks => 0 }), "new"); like ($warn, qr{: ignored\n}, "warn for 0"); is ($csv->callbacks, $warn = undef, "no callbacks for 0"); ok ($csv = Text::CSV_XS->new ({ callbacks => 1 }), "new"); like ($warn, qr{: ignored\n}, "warn for 1"); is ($csv->callbacks, $warn = undef, "no callbacks for 1"); ok ($csv = Text::CSV_XS->new ({ callbacks => \1 }), "new"); like ($warn, qr{: ignored\n}, "warn for \\1"); is ($csv->callbacks, $warn = undef, "no callbacks for \\1"); ok ($csv = Text::CSV_XS->new ({ callbacks => "" }), "new"); like ($warn, qr{: ignored\n}, "warn for ''"); is ($csv->callbacks, $warn = undef, "no callbacks for ''"); ok ($csv = Text::CSV_XS->new ({ callbacks => [] }), "new"); like ($warn, qr{: ignored\n}, "warn for []"); is ($csv->callbacks, $warn = undef, "no callbacks for []"); ok ($csv = Text::CSV_XS->new ({ callbacks => sub {} }), "new"); like ($warn, qr{: ignored\n}, "warn for sub {}"); is ($csv->callbacks, $warn = undef, "no callbacks for sub {}"); } ok ($csv = Text::CSV_XS->new (), "new"); is ($csv->callbacks, undef, "no callbacks"); ok ($csv->bind_columns (\my ($c, $s)), "bind"); ok ($csv->getline (*DATA), "parse ok"); is ($c, 1, "key"); is ($s, "foo", "value"); $s = "untouched"; ok ($csv->getline (*DATA), "parse bad"); is ($c, 1, "key"); is ($s, "untouched", "untouched"); ok ($csv->getline (*DATA), "parse bad"); is ($c, "foo", "key"); is ($s, "untouched", "untouched"); ok ($csv->getline (*DATA), "parse good"); is ($c, 2, "key"); is ($s, "bar", "value"); eval { is ($csv->getline (*DATA), undef,"parse bad"); }; my @diag = $csv->error_diag; is ($diag[0], 3006, "too many values"); # These tests are for the method foreach my $args ([""], [1], [[]], [sub{}], [1,2], [1,2,3], [undef,"error"], ["error",undef], ["%23bad",sub {}],["error",sub{0;},undef,1], ["error",[]],["error","error"],["",sub{0;}], [sub{0;},0],[[],""]) { eval { $csv->callbacks (@$args); }; my @diag = $csv->error_diag; is ($diag[0], 1004, "invalid callbacks"); is ($csv->callbacks, undef, "not set"); } # These tests are for invalid arguments *inside* the hash foreach my $arg (undef, 0, 1, \1, "", [], $csv) { eval { $csv->callbacks ({ error => $arg }); }; my @diag = $csv->error_diag; is ($diag[0], 1004, "invalid callbacks"); is ($csv->callbacks, undef, "not set"); } ok ($csv->callbacks (bogus => sub { 0; }), "useless callback"); my $error = 3006; sub ignore { is ($_[0], $error, "Caught error $error"); $csv->SetDiag (0); # Ignore this error } # ignore my $idx = 1; ok ($csv->auto_diag (1), "set auto_diag"); my $callbacks = { error => \&ignore, after_parse => sub { my ($c, $av) = @_; # Just add a field push @$av, "NEW"; }, before_print => sub { my ($c, $av) = @_; # First field set to line number $av->[0] = $idx++; # Maximum 2 fields @{$av} > 2 and splice @{$av}, 2; # Minimum 2 fields @{$av} < 2 and push @{$av}, ""; }, }; is (ref $csv->callbacks ($callbacks), "HASH", "callbacks set"); ok ($csv->getline (*DATA), "parse ok"); is ($c, 1, "key"); is ($s, "foo", "value"); ok ($csv->getline (*DATA), "parse bad, skip 3006"); ok ($csv->getline (*DATA), "parse good"); is ($c, 2, "key"); is ($s, "bar", "value"); $csv->bind_columns (undef); ok (my $row = $csv->getline (*DATA), "get row"); is_deeply ($row, [ 1, 2, 3, "NEW" ], "fetch + value from hook"); $error = 2012; # EOF ok ($csv->getline (*DATA), "parse past eof"); ok ($csv->eol ("\n"), "eol for output"); open my $fh, ">", $tfn or die "$tfn: $!"; ok ($csv->print ($fh, [ 0, "foo" ]), "print OK"); ok ($csv->print ($fh, [ 0, "bar", 3 ]), "print too many"); ok ($csv->print ($fh, [ 0 ]), "print too few"); close $fh; open $fh, "<", $tfn or die "$tfn: $!"; is (do { local $/; <$fh> }, "1,foo\n2,bar\n3,\n", "Modified output"); close $fh; # Test the non-IO interface ok ($csv->parse ("10,blah,33\n"), "parse"); is_deeply ([ $csv->fields ], [ 10, "blah", 33, "NEW" ], "fields"); ok ($csv->combine (11, "fri", 22, 18), "combine - no hook"); is ($csv->string, qq{11,fri,22,18\n}, "string"); is ($csv->callbacks (undef), undef, "clear callbacks"); is_deeply (Text::CSV_XS::csv (in => $tfn, callbacks => $callbacks), [[1,"foo","NEW"],[2,"bar","NEW"],[3,"","NEW"]], "using getline_all"); open $fh, ">", $tfn or die "$tfn: $!\n"; print $fh <<"EOC"; 1,foo 2,bar 3,baz 4,zoo EOC close $fh; open $fh, "<", $tfn or die "$tfn: $!\n"; $csv->callbacks (after_parse => sub { $_[1][0] eq 3 and return \"skip" }); is_deeply ($csv->getline_all ($fh), [[1,"foo"],[2,"bar"],[4,"zoo"]]); close $fh; __END__ 1,foo 1 foo 2,bar 3,baz,2 1,foo 3,baz,2 2,bar 1,2,3 Text-CSV_XS-1.26/t/85_util.t0000644000031300001440000002041612766477214016072 0ustar00merijnusers00000000000000#!/usr/bin/perl use strict; use warnings; use Test::More; my $pu; BEGIN { $pu = $ENV{PERL_UNICODE}; $pu = defined $pu && ($pu eq "" || $pu =~ m/[oD]/ || ($pu =~ m/^[0-9]+$/ && $pu & 16)); if ($] < 5.008002) { plan skip_all => "This test unit requires perl-5.8.2 or higher"; } else { my $n = 297; $pu and $n -= 120; plan tests => $n; } use_ok "Text::CSV_XS", "csv"; require Encode; require "t/util.pl"; } $| = 1; ok (my $csv = Text::CSV_XS->new, "new for header tests"); is ($csv->sep_char, ",", "Sep = ,"); my $hdr_lc = [qw( bar foo )]; foreach my $sep (",", ";") { my $data = "bAr,foo\n1,2\n3,4,5\n"; $data =~ s/,/$sep/g; $csv->column_names (undef); { open my $fh, "<", \$data; ok (my $slf = $csv->header ($fh), "header"); is ($slf, $csv, "Return self"); is ($csv->sep_char, $sep, "Sep = $sep"); is_deeply ([ $csv->column_names ], $hdr_lc, "headers"); is_deeply ($csv->getline ($fh), [ 1, 2 ], "Line 1"); is_deeply ($csv->getline ($fh), [ 3, 4, 5 ], "Line 2"); close $fh; } $csv->column_names (undef); { open my $fh, "<", \$data; ok (my @hdr = $csv->header ($fh), "header"); is_deeply (\@hdr, $hdr_lc, "Return headers"); close $fh; } $csv->column_names (undef); { open my $fh, "<", \$data; ok (my $slf = $csv->header ($fh), "header"); is ($slf, $csv, "Return self"); is ($csv->sep_char, $sep, "Sep = $sep"); is_deeply ([ $csv->column_names ], $hdr_lc, "headers"); is_deeply ($csv->getline_hr ($fh), { bar => 1, foo => 2 }, "Line 1"); is_deeply ($csv->getline_hr ($fh), { bar => 3, foo => 4 }, "Line 2"); close $fh; } { open my $fh, "<", \$data; is_deeply (csv (in => $fh, bom => 1), [{ bar => 1, foo => 2 }, { bar => 3, foo => 4 }], "use header () from csv () with $sep"); } { open my $fh, "<", \$data; is_deeply (csv (in => $fh, seps => [ ",", ";" ]), [{ bar => 1, foo => 2 }, { bar => 3, foo => 4 }], "use header () from csv () with $sep"); } { open my $fh, "<", \$data; is_deeply (csv (in => $fh, bom => 1, key => "bar"), { 1 => { bar => 1, foo => 2 }, 3 => { bar => 3, foo => 4 }}, "use header () from csv (key) with $sep"); } { open my $fh, "<", \$data; is_deeply (csv (in => $fh, munge => "uc", key => "BAR"), { 1 => { BAR => 1, FOO => 2 }, 3 => { BAR => 3, FOO => 4 }}, "use header () from csv (key, uc) with $sep"); } } my $sep_ok = [ "\t", "|", ",", ";", "##", "\xe2\x81\xa3" ]; unless ($pu) { foreach my $sep (@$sep_ok) { my $data = "bAr,foo\n1,2\n3,4,5\n"; $data =~ s/,/$sep/g; $csv->column_names (undef); { open my $fh, "<", \$data; ok (my $slf = $csv->header ($fh, $sep_ok), "header with specific sep set"); is ($slf, $csv, "Return self"); is (Encode::encode ("utf-8", $csv->sep), $sep, "Sep = $sep"); is_deeply ([ $csv->column_names ], $hdr_lc, "headers"); is_deeply ($csv->getline ($fh), [ 1, 2 ], "Line 1"); is_deeply ($csv->getline ($fh), [ 3, 4, 5 ], "Line 2"); close $fh; } $csv->column_names (undef); { open my $fh, "<", \$data; ok (my @hdr = $csv->header ($fh, $sep_ok), "header with specific sep set"); is_deeply (\@hdr, $hdr_lc, "Return headers"); close $fh; } $csv->column_names (undef); { open my $fh, "<", \$data; ok (my $slf = $csv->header ($fh, { sep_set => $sep_ok }), "header with specific sep set as opt"); is ($slf, $csv, "Return self"); is (Encode::encode ("utf-8", $csv->sep), $sep, "Sep = $sep"); is_deeply ([ $csv->column_names ], $hdr_lc, "headers"); is_deeply ($csv->getline ($fh), [ 1, 2 ], "Line 1"); is_deeply ($csv->getline ($fh), [ 3, 4, 5 ], "Line 2"); close $fh; } $csv->column_names (undef); { open my $fh, "<", \$data; ok (my $slf = $csv->header ($fh, $sep_ok), "header with specific sep set"); is ($slf, $csv, "Return self"); is (Encode::encode ("utf-8", $csv->sep), $sep, "Sep = $sep"); is_deeply ([ $csv->column_names ], $hdr_lc, "headers"); is_deeply ($csv->getline_hr ($fh), { bar => 1, foo => 2 }, "Line 1"); is_deeply ($csv->getline_hr ($fh), { bar => 3, foo => 4 }, "Line 2"); close $fh; } } } for ( [ 1010, 0, qq{} ], # Empty header [ 1011, 0, qq{a,b;c,d} ], # Multiple allowed separators [ 1012, 0, qq{a,,b} ], # Empty header field [ 1013, 0, qq{a,a,b} ], # Non-unique headers [ 2027, 1, qq{a,"b\nc",c} ], # Embedded newline binary on [ 2021, 0, qq{a,"b\nc",c} ], # Embedded newline binary off ) { my ($err, $bin, $data) = @$_; $csv->binary ($bin); open my $fh, "<", \$data; my $self = eval { $csv->header ($fh); }; is ($self, undef, "FAIL for '$data'"); ok ($@, "Error"); is (0 + $csv->error_diag, $err, "Error code $err"); close $fh; } { open my $fh, "<", \"bar,bAr,bAR,BAR\n1,2,3,4"; $csv->column_names (undef); ok ($csv->header ($fh, { munge_column_names => "none" }), "non-unique unfolded headers"); is_deeply ([ $csv->column_names ], [qw( bar bAr bAR BAR )], "Headers"); close $fh; } { open my $fh, "<", \"bar,bAr,bAR,BAR\n1,2,3,4"; $csv->column_names (undef); ok (my @hdr = $csv->header ($fh, { munge_column_names => "none" }), "non-unique unfolded headers"); is_deeply (\@hdr, [qw( bar bAr bAR BAR )], "Headers from method"); is_deeply ([ $csv->column_names ], [qw( bar bAr bAR BAR )], "Headers from column_names"); close $fh; } foreach my $sep (",", ";") { my $data = "bAr,foo\n1,2\n3,4,5\n"; $data =~ s/,/$sep/g; $csv->column_names (undef); { open my $fh, "<", \$data; ok (my $slf = $csv->header ($fh, { set_column_names => 0 }), "Header without column setting"); is ($slf, $csv, "Return self"); is ($csv->sep_char, $sep, "Sep = $sep"); is_deeply ([ $csv->column_names ], [], "headers"); is_deeply ($csv->getline ($fh), [ 1, 2 ], "Line 1"); is_deeply ($csv->getline ($fh), [ 3, 4, 5 ], "Line 2"); close $fh; } $csv->column_names (undef); { open my $fh, "<", \$data; ok (my @hdr = $csv->header ($fh, { set_column_names => 0 }), "Header without column setting"); is_deeply (\@hdr, $hdr_lc, "Headers from method"); is_deeply ([ $csv->column_names ], [], "Headers from column_names"); close $fh; } } my $n; for ([ undef, "bar" ], [ "lc", "bar" ], [ "uc", "BAR" ], [ "none", "bAr" ], [ sub { "column_".$n++ }, "column_0" ]) { my ($munge, $hdr) = @$_; my $data = "bAr,foo\n1,2\n3,4,5\n"; my $how = defined $munge ? ref $munge ? "CB" : $munge : "undef"; $n = 0; $csv->column_names (undef); open my $fh, "<", \$data; ok (my $slf = $csv->header ($fh, { munge_column_names => $munge }), "munge header with $how"); is (($csv->column_names)[0], $hdr, "folded header to $hdr"); close $fh; $n = 0; $csv->column_names (undef); open $fh, "<", \$data; ok (my @hdr = $csv->header ($fh, { munge_column_names => $munge }), "munge header with $how"); is ($hdr[0], $hdr, "folded header to $hdr"); close $fh; } my $fnm = "_85hdr.csv"; END { unlink $fnm; } $csv->binary (1); $csv->auto_diag (9); my $str = qq{zoo,b\x{00e5}r\n1,"1 \x{20ac} each"\n}; for ( [ "none" => "" ], [ "utf-8" => "\xef\xbb\xbf" ], [ "utf-16be" => "\xfe\xff" ], [ "utf-16le" => "\xff\xfe" ], [ "utf-32be" => "\x00\x00\xfe\xff" ], [ "utf-32le" => "\xff\xfe\x00\x00" ], [ "utf-1" => "\xf7\x64\x4c" ], [ "utf-ebcdic" => "\xdd\x73\x66\x73" ], [ "scsu" => "\x0e\xfe\xff" ], [ "bocu-1" => "\xfb\xee\x28" ], [ "gb-18030" => "\x84\x31\x95" ], ) { my ($enc, $bom) = @$_; my $has_enc = 0; eval { open my $fh, ">", $fnm; binmode $fh; print $fh $bom; print $fh Encode::encode ($enc eq "none" ? "utf-8" : $enc, $str); close $fh; $has_enc = 1; }; SKIP: { $has_enc or skip "Encoding $enc not supported", 7; $csv->column_names (undef); open my $fh, "<", $fnm; binmode $fh; ok (1, "$fnm opened for enc $enc"); ok ($csv->header ($fh), "headers with BOM for $enc"); is (($csv->column_names)[1], "b\x{00e5}r", "column name was decoded"); ok (my $row = $csv->getline_hr ($fh), "getline_hr"); is ($row->{"b\x{00e5}r"}, "1 \x{20ac} each", "Returned in Unicode"); close $fh; ok (my $aoh = csv (in => $fnm, bom => 1), "csv (bom => 1)"); is_deeply ($aoh, [{ zoo => 1, "b\x{00e5}r" => "1 \x{20ac} each" }], "Returned data"); } unlink $fnm; } Text-CSV_XS-1.26/t/78_fragment.t0000644000031300001440000000674712753265123016723 0ustar00merijnusers00000000000000#!/pro/bin/perl use strict; use warnings; $| = 1; use Config; use Test::More; BEGIN { unless (exists $Config{useperlio} && defined $Config{useperlio} && $] >= 5.008 && # perlio was experimental in 5.6.2, but not reliable $Config{useperlio} eq "define") { plan skip_all => "No reliable perlIO available"; } else { plan tests => 22; } } use Text::CSV_XS; my $csv = Text::CSV_XS->new (); my @test = ( "row=1" => [[ 11,12,13,14,15,16,17,18,19 ]], "row=2-3" => [[ 21,22,23,24,25,26,27,28,29 ], [ 31,32,33,34,35,36,37,38,39 ]], "row=2;4;6" => [[ 21,22,23,24,25,26,27,28,29 ], [ 41,42,43,44,45,46,47,48,49 ], [ 61,62,63,64,65,66,67,68,69 ]], "row=1-2;4;6-*" => [[ 11,12,13,14,15,16,17,18,19 ], [ 21,22,23,24,25,26,27,28,29 ], [ 41,42,43,44,45,46,47,48,49 ], [ 61,62,63,64,65,66,67,68,69 ], [ 71,72,73,74,75,76,77,78,79 ], [ 81,82,83,84,85,86,87,88,89 ], [ 91,92,93,94,95,96,97,98,99 ]], "col=1" => [[11],[21],[31],[41],[51],[61],[71],[81],[91]], "col=2-3" => [[12,13],[22,23],[32,33],[42,43],[52,53], [62,63],[72,73],[82,83],[92,93]], "col=2;4;6" => [[12,14,16],[22,24,26],[32,34,36],[42,44,46],[52,54,56], [62,64,66],[72,74,76],[82,84,86],[92,94,96]], "col=1-2;4;6-*" => [[11,12,14,16,17,18,19], [21,22,24,26,27,28,29], [31,32,34,36,37,38,39], [41,42,44,46,47,48,49], [51,52,54,56,57,58,59], [61,62,64,66,67,68,69], [71,72,74,76,77,78,79], [81,82,84,86,87,88,89], [91,92,94,96,97,98,99]], #cell=R,C "cell=7,7" => [[ 77 ]], "cell=7,7-8,8" => [[ 77,78 ], [ 87,88 ]], "cell=7,7-*,8" => [[ 77,78 ], [ 87,88 ], [ 97,98 ]], "cell=7,7-8,*" => [[ 77,78,79 ], [ 87,88,89 ]], "cell=7,7-*,*" => [[ 77,78,79 ], [ 87,88,89 ], [ 97,98,99 ]], "cell=7,7;7,8;8,7;8,8" => [[ 77,78 ], [ 87,88 ]], "cell=8,8;8,7;7,8;7,7" => [[ 77,78 ], [ 87,88 ]], "cell=1,1-2,2;3,3-4,4" => [ [11,12], [21,22], [33,34], [43,44]], "cell=1,1-3,3;2,3-4,4" => [ [11,12,13], [21,22,23,24], [31,32,33,34], [43,44]], "cell=1,1-3,3;2,2-4,4;2,3;4,2" => [ [11,12,13], [21,22,23,24], [31,32,33,34], [42,43,44]], "cell=1,1-2,2;3,3-4,4;1,4;4,1" => [ [11,12, 14], [21,22], [33,34], [41, 43,44]], ); my $todo = ""; my $data = join "" => ; while (my ($spec, $expect) = splice @test, 0, 2) { open my $io, "<", \$data or die "IO: $!\n"; my $aoa = $csv->fragment ($io, $spec); is_deeply ($aoa, $expect, "${todo}Fragment $spec"); } { $csv->column_names ("c3", "c4"); open my $io, "<", \$data or die "IO: $!\n"; is_deeply ($csv->fragment ($io, "cell=3,2-4,3"), [ { c3 => 32, c4 => 33 }, { c3 => 42, c4 => 43 }], "Fragment to AoH"); } { $csv->column_names ("C1", "C2"); open my $io, "<", \$data or die "IO: $!\n"; is_deeply ($csv->fragment ($io, "row=3"), [ { C1 => 31, C2 => 32 }], "Fragment row with headers to AoH"); } { $csv->column_names ("C1"); open my $io, "<", \$data or die "IO: $!\n"; is_deeply ($csv->fragment ($io, "col=2"), [ map +{ C1 => $_.2 } => 1 .. 9 ], "Fragment col with headers to AoH"); } #$csv->eol ("\n"); #foreach my $r (1..9){$csv->print(*STDOUT,[map{$r.$_}1..9])} __END__ 11,12,13,14,15,16,17,18,19 21,22,23,24,25,26,27,28,29 31,32,33,34,35,36,37,38,39 41,42,43,44,45,46,47,48,49 51,52,53,54,55,56,57,58,59 61,62,63,64,65,66,67,68,69 71,72,73,74,75,76,77,78,79 81,82,83,84,85,86,87,88,89 91,92,93,94,95,96,97,98,99 Text-CSV_XS-1.26/t/15_flags.t0000644000031300001440000002747612753265123016205 0ustar00merijnusers00000000000000#!/usr/bin/perl use strict; use warnings; use Test::More tests => 225; BEGIN { use_ok "Text::CSV_XS"; plan skip_all => "Cannot load Text::CSV_XS" if $@; } sub crnlsp { my $csv = shift; ok (!$csv->parse (), "Missing arguments"); ok ( $csv->parse ("\n"), "NL"); if ($csv->eol eq "\r") { ok ( $csv->parse ("\r"), "CR"); ok ( $csv->parse ("\r\r"), "CR CR"); ok ( $csv->parse ("\r "), "CR + Space"); ok ( $csv->parse (" \r"), "Space + CR"); } else { ok (!$csv->parse ("\r"), "CR"); ok (!$csv->parse ("\r\r"), "CR CR"); if ($csv->binary) { ok ( $csv->parse ("\r "), "CR + Space"); ok ( $csv->parse (" \r"), "Space + CR"); } else { ok (!$csv->parse ("\r "), "CR + Space"); ok (!$csv->parse (" \r"), "Space + CR"); } } ok ( $csv->parse ("\r\n"), "CR NL"); ok ( $csv->parse ("\n "), "NL + Space"); ok ( $csv->parse ("\r\n "), "CR NL + Space"); if ($csv->binary) { ok ( $csv->parse (qq{"\n"}), "Quoted NL"); ok ( $csv->parse (qq{"\r"}), "Quoted CR"); ok ( $csv->parse (qq{"\r\n"}), "Quoted CR NL"); ok ( $csv->parse (qq{"\n "}), "Quoted NL + Space"); ok ( $csv->parse (qq{"\r "}), "Quoted CR + Space"); ok ( $csv->parse (qq{"\r\n "}), "Quoted CR NL + Space"); } else { ok (!$csv->parse (qq{"\n"}), "Quoted NL"); ok (!$csv->parse (qq{"\r"}), "Quoted CR"); ok (!$csv->parse (qq{"\r\n"}), "Quoted CR NL"); ok (!$csv->parse (qq{"\n "}), "Quoted NL + Space"); ok (!$csv->parse (qq{"\r "}), "Quoted CR + Space"); ok (!$csv->parse (qq{"\r\n "}), "Quoted CR NL + Space"); } ok (!$csv->parse (qq{"\r\r\n"\r}), "Quoted CR CR NL >CR"); ok (!$csv->parse (qq{"\r\r\n"\r\r}), "Quoted CR CR NL >CR CR"); ok (!$csv->parse (qq{"\r\r\n"\r\r\n}), "Quoted CR CR NL >CR CR NL"); ok (!$csv->parse (qq{"\r\r\n"\t \r}), "Quoted CR CR NL >TAB Space CR"); ok (!$csv->parse (qq{"\r\r\n"\t \r\r}), "Quoted CR CR NL >TAB Space CR CR"); ok (!$csv->parse (qq{"\r\r\n"\t \r\r\n}), "Quoted CR CR NL >TAB Space CR CR NL"); } # crnlsp { my $csv = Text::CSV_XS->new (); my $c99 = chr (0x99); # A random binary character is ($csv->meta_info, undef, "meta_info () before parse ()"); ok (1, "parse () tests - No meta_info"); crnlsp ($csv); ok (!$csv->parse ('"abc'), "Missing closing \""); ok (!$csv->parse ('ab"c'), "\" outside of \"'s"); ok (!$csv->parse ('"ab"c"'), "Bad character sequence"); ok (!$csv->parse ("ab${c99}c"), "Binary character"); ok (!$csv->parse (qq{"ab${c99}c"}), "Binary character in quotes"); ok (!$csv->parse (qq("abc\nc")), "Bad character (NL)"); ok (!$csv->status (), "Wrong status ()"); ok ( $csv->parse ('","'), "comma - parse ()"); is ( scalar $csv->fields (), 1, "comma - fields () - count"); is ( scalar $csv->meta_info (), 0, "comma - meta_info () - count"); is (($csv->fields ())[0], ",", "comma - fields () - content"); is (($csv->meta_info ())[0], undef, "comma - meta_info () - content"); ok ( $csv->parse (qq("","I said,\t""Hi!""","")), "Hi! - parse ()"); is ( scalar $csv->fields (), 3, "Hi! - fields () - count"); is ( scalar $csv->meta_info (), 0, "Hi! - meta_info () - count"); } { my $csv = Text::CSV_XS->new ({ keep_meta_info => 1 }); ok (1, "parse () tests - With flags"); is ( $csv->meta_info, undef, "meta_info before parse"); ok (!$csv->parse (), "Missing arguments"); is ( $csv->meta_info, undef, "meta_info after failing parse"); crnlsp ($csv); ok (!$csv->parse ('"abc'), "Missing closing \""); ok (!$csv->parse ('ab"c'), "\" outside of \"'s"); ok (!$csv->parse ('"ab"c"'), "Bad character sequence"); ok (!$csv->parse (qq("abc\nc")), "Bad character (NL)"); ok (!$csv->status (), "Wrong status ()"); ok ( $csv->parse ('","'), "comma - parse ()"); is ( scalar $csv->fields (), 1, "comma - fields () - count"); is ( scalar $csv->meta_info (), 1, "comma - meta_info () - count"); is (($csv->fields ())[0], ",", "comma - fields () - content"); is (($csv->meta_info ())[0], 1, "comma - meta_info () - content"); ok ( $csv->parse (qq("","I said,\t""Hi!""",)), "Hi! - parse ()"); is ( scalar $csv->fields (), 3, "Hi! - fields () - count"); is ( scalar $csv->meta_info (), 3, "Hi! - meta_info () - count"); is (($csv->fields ())[0], "", "Hi! - fields () - field 1"); is (($csv->meta_info ())[0], 1, "Hi! - meta_info () - field 1"); is (($csv->fields ())[1], qq(I said,\t"Hi!"), "Hi! - fields () - field 2"); is (($csv->meta_info ())[1], 1, "Hi! - meta_info () - field 2"); is (($csv->fields ())[2], "", "Hi! - fields () - field 3"); is (($csv->meta_info ())[2], 0, "Hi! - meta_info () - field 3"); } { my $csv = Text::CSV_XS->new ({ keep_meta_info => 1, binary => 1, quote_space => 0, }); ok ($csv->parse (qq{1,,"", ," ",f,"g","h""h",h\xe9lp,"h\xeblp"}), "Parse"); ok (my @f = $csv->fields, "fields"); is_deeply (\@f, [ 1, "", "", " ", " ", "f", "g", "h\"h", "h\xe9lp", "h\xeblp" ], "fields content"); ok ($csv->combine (@f), "combine"); is ($csv->string, qq{1,,, , ,f,g,"h""h",h\xe9lp,h\xeblp}, "string 1"); ok ($csv->parse (qq{1,,"", ," ",f,"g","h""h",h\xe9lp,"h\xeblp"}), "Parse"); is ($csv->keep_meta_info (11), 11, "keep meta on out"); ok ($csv->combine (@f), "combine"); is ($csv->string, qq{1,,"", ," ",f,"g","h""h",h\xe9lp,"h\xeblp"}, "string 11"); ok ($csv->parse (qq{1,,"1193-1",4,"",,6}), "parse under 11"); ok ($csv->combine ($csv->fields), "combine"); is ($csv->string, qq{1,,"1193-1",4,"",,6}, "return same"); } { my $csv = Text::CSV_XS->new ({ keep_meta_info => 1, eol => "\r" }); ok (1, "parse () tests - With flags"); is ( $csv->meta_info, undef, "meta_info before parse"); ok (!$csv->parse (), "Missing arguments"); is ( $csv->meta_info, undef, "meta_info after failing parse"); crnlsp ($csv); ok (!$csv->parse ('"abc'), "Missing closing \""); ok (!$csv->parse ('ab"c'), "\" outside of \"'s"); ok (!$csv->parse ('"ab"c"'), "Bad character sequence"); ok (!$csv->parse (qq("abc\nc")), "Bad character (NL)"); ok (!$csv->status (), "Wrong status ()"); ok ( $csv->parse ('","'), "comma - parse ()"); is ( scalar $csv->fields (), 1, "comma - fields () - count"); is ( scalar $csv->meta_info (), 1, "comma - meta_info () - count"); is (($csv->fields ())[0], ",", "comma - fields () - content"); is (($csv->meta_info ())[0], 1, "comma - meta_info () - content"); ok ( $csv->parse (qq("","I said,\t""Hi!""",)), "Hi! - parse ()"); is ( scalar $csv->fields (), 3, "Hi! - fields () - count"); is ( scalar $csv->meta_info (), 3, "Hi! - meta_info () - count"); is (($csv->fields ())[0], "", "Hi! - fields () - field 1"); is (($csv->meta_info ())[0], 1, "Hi! - meta_info () - field 1"); is (($csv->fields ())[1], qq(I said,\t"Hi!"), "Hi! - fields () - field 2"); is (($csv->meta_info ())[1], 1, "Hi! - meta_info () - field 2"); is (($csv->fields ())[2], "", "Hi! - fields () - field 3"); is (($csv->meta_info ())[2], 0, "Hi! - meta_info () - field 3"); } { my $csv = Text::CSV_XS->new ({ keep_meta_info => 1, binary => 1 }); is ($csv->is_quoted (0), undef, "is_quoted () before parse"); is ($csv->is_binary (0), undef, "is_binary () before parse"); is ($csv->is_missing (0), undef, "is_missing () before parse"); my $bintxt = chr (0x20ac); ok ( $csv->parse (qq{,"1","a\rb",0,"a\nb",1,\x8e,"a\r\n","$bintxt","",}), "parse () - mixed quoted/binary"); is (scalar $csv->fields, 11, "fields () - count"); my @fflg; ok (@fflg = $csv->meta_info, "meta_info ()"); is (scalar @fflg, 11, "meta_info () - count"); is_deeply ([ @fflg ], [ 0, 1, 3, 0, 3, 0, 2, 3, 3, 1, 0 ], "meta_info ()"); is ($csv->is_quoted (0), 0, "fflag 0 - not quoted"); is ($csv->is_binary (0), 0, "fflag 0 - not binary"); is ($csv->is_missing (0), 0, "fflag 0 - not missig"); is ($csv->is_quoted (2), 1, "fflag 2 - quoted"); is ($csv->is_binary (2), 1, "fflag 2 - binary"); is ($csv->is_missing (2), 0, "fflag 2 - not missing"); is ($csv->is_quoted (6), 0, "fflag 5 - not quoted"); is ($csv->is_binary (6), 1, "fflag 5 - binary"); is ($csv->is_missing (6), 0, "fflag 5 - not missing"); is ($csv->is_quoted (-1), undef, "fflag -1 - undefined"); is ($csv->is_binary (-8), undef, "fflag -8 - undefined"); is ($csv->is_missing (-8), undef, "fflag -8 - undefined"); is ($csv->is_quoted (21), undef, "fflag 21 - undefined"); is ($csv->is_binary (98), undef, "fflag 98 - undefined"); is ($csv->is_missing (98), 1, "fflag 98 - missing"); } { my $csv = Text::CSV_XS->new ({ escape_char => "+" }); ok ( $csv->parse ("+"), "ESC"); ok (!$csv->parse ("++"), "ESC ESC"); ok ( $csv->parse ("+ "), "ESC Space"); ok ( $csv->parse ("+0"), "ESC NUL"); ok ( $csv->parse ("+\n"), "ESC NL"); ok (!$csv->parse ("+\r"), "ESC CR"); ok ( $csv->parse ("+\r\n"), "ESC CR NL"); ok (!$csv->parse (qq{"+"}), "Quo ESC"); ok (!$csv->parse (qq{""+}), "Quo ESC >"); ok ( $csv->parse (qq{"++"}), "Quo ESC ESC"); ok (!$csv->parse (qq{"+ "}), "Quo ESC Space"); ok ( $csv->parse (qq{"+0"}), "Quo ESC NUL"); ok (!$csv->parse (qq{"+\n"}), "Quo ESC NL"); ok (!$csv->parse (qq{"+\r"}), "Quo ESC CR"); ok (!$csv->parse (qq{"+\r\n"}), "Quo ESC CR NL"); } { my $csv = Text::CSV_XS->new ({ escape_char => "+", binary => 1 }); ok ( $csv->parse ("+"), "ESC"); ok (!$csv->parse ("++"), "ESC ESC"); ok ( $csv->parse ("+ "), "ESC Space"); ok ( $csv->parse ("+0"), "ESC NUL"); ok ( $csv->parse ("+\n"), "ESC NL"); ok (!$csv->parse ("+\r"), "ESC CR"); ok ( $csv->parse ("+\r\n"), "ESC CR NL"); ok (!$csv->parse (qq{"+"}), "Quo ESC"); ok ( $csv->parse (qq{"++"}), "Quo ESC ESC"); ok (!$csv->parse (qq{"+ "}), "Quo ESC Space"); ok ( $csv->parse (qq{"+0"}), "Quo ESC NUL"); ok (!$csv->parse (qq{"+\n"}), "Quo ESC NL"); ok (!$csv->parse (qq{"+\r"}), "Quo ESC CR"); ok (!$csv->parse (qq{"+\r\n"}), "Quo ESC CR NL"); } ok (1, "Testing always_quote"); { ok (my $csv = Text::CSV_XS->new ({ always_quote => 0 }), "new (aq => 0)"); ok ($csv->combine (1..3), "Combine"); is ($csv->string, q{1,2,3}, "String"); is ($csv->always_quote, 0, "Attr 0"); ok ($csv->always_quote (1), "Attr 1"); ok ($csv->combine (1..3), "Combine"); is ($csv->string, q{"1","2","3"}, "String"); is ($csv->always_quote, 1, "Attr 1"); is ($csv->always_quote (0), 0, "Attr 0"); ok ($csv->combine (1..3), "Combine"); is ($csv->string, q{1,2,3}, "String"); is ($csv->always_quote, 0, "Attr 0"); } ok (1, "Testing quote_space"); { ok (my $csv = Text::CSV_XS->new ({ quote_space => 1 }), "new (qs => 1)"); ok ($csv->combine (1, " ", 3), "Combine"); is ($csv->string, q{1," ",3}, "String"); is ($csv->quote_space, 1, "Attr 1"); is ($csv->quote_space (0), 0, "Attr 0"); ok ($csv->combine (1, " ", 3), "Combine"); is ($csv->string, q{1, ,3}, "String"); is ($csv->quote_space, 0, "Attr 0"); is ($csv->quote_space (1), 1, "Attr 1"); ok ($csv->combine (1, " ", 3), "Combine"); is ($csv->string, q{1," ",3}, "String"); is ($csv->quote_space, 1, "Attr 1"); } ok (1, "Testing quote_empty"); { ok (my $csv = Text::CSV_XS->new (), "new (default)"); is ($csv->quote_empty, 0, "default = 0"); ok ($csv->combine (1, undef, "", " ", 2), "combine qe = 0"); is ($csv->string, qq{1,,," ",2}, "string"); is ($csv->quote_empty (1), 1, "enable quote_empty"); ok ($csv->combine (1, undef, "", " ", 2), "combine qe = 1"); is ($csv->string, qq{1,,""," ",2}, "string"); } Text-CSV_XS-1.26/CSV_XS.pm0000644000031300001440000034620113017533723015543 0ustar00merijnusers00000000000000package Text::CSV_XS; # Copyright (c) 2007-2016 H.Merijn Brand. All rights reserved. # Copyright (c) 1998-2001 Jochen Wiedmann. All rights reserved. # Copyright (c) 1997 Alan Citterman. All rights reserved. # # This program is free software; you can redistribute it and/or # modify it under the same terms as Perl itself. # HISTORY # # 0.24 - # H.Merijn Brand (h.m.brand@xs4all.nl) # 0.10 - 0.23 # Jochen Wiedmann # Based on (the original) Text::CSV by: # Alan Citterman require 5.006001; use strict; use warnings; require Exporter; use DynaLoader (); use Carp; use vars qw( $VERSION @ISA @EXPORT_OK ); $VERSION = "1.26"; @ISA = qw( DynaLoader Exporter ); @EXPORT_OK = qw( csv ); bootstrap Text::CSV_XS $VERSION; sub PV { 0 } sub IV { 1 } sub NV { 2 } if ($] < 5.008002) { no warnings "redefine"; *utf8::decode = sub {}; } # version # # class/object method expecting no arguments and returning the version # number of Text::CSV. there are no side-effects. sub version { return $VERSION; } # version # new # # class/object method expecting no arguments and returning a reference to # a newly created Text::CSV object. my %def_attr = ( eol => '', sep_char => ',', quote_char => '"', escape_char => '"', binary => 0, decode_utf8 => 1, auto_diag => 0, diag_verbose => 0, blank_is_undef => 0, empty_is_undef => 0, allow_whitespace => 0, allow_loose_quotes => 0, allow_loose_escapes => 0, allow_unquoted_escape => 0, always_quote => 0, quote_empty => 0, quote_space => 1, quote_binary => 1, escape_null => 1, keep_meta_info => 0, verbatim => 0, types => undef, callbacks => undef, _EOF => 0, _RECNO => 0, _STATUS => undef, _FIELDS => undef, _FFLAGS => undef, _STRING => undef, _ERROR_INPUT => undef, _COLUMN_NAMES => undef, _BOUND_COLUMNS => undef, _AHEAD => undef, ); my %attr_alias = ( quote_always => "always_quote", verbose_diag => "diag_verbose", quote_null => "escape_null", ); my $last_new_err = Text::CSV_XS->SetDiag (0); # NOT a method: is also used before bless sub _unhealthy_whitespace { my $self = shift; $_[0] or return 0; # no checks needed without allow_whitespace my $quo = $self->{quote}; defined $quo && length ($quo) or $quo = $self->{quote_char}; my $esc = $self->{escape_char}; (defined $quo && $quo =~ m/^[ \t]/) || (defined $esc && $esc =~ m/^[ \t]/) and return 1002; return 0; } # _sane_whitespace sub _check_sanity { my $self = shift; my $eol = $self->{eol}; my $sep = $self->{sep}; defined $sep && length ($sep) or $sep = $self->{sep_char}; my $quo = $self->{quote}; defined $quo && length ($quo) or $quo = $self->{quote_char}; my $esc = $self->{escape_char}; # use DP;::diag ("SEP: '", DPeek ($sep), # "', QUO: '", DPeek ($quo), # "', ESC: '", DPeek ($esc),"'"); if (defined $sep) { # sep_char should not be undefined length ($sep) > 16 and return 1006; $sep =~ m/[\r\n]/ and return 1003; } if (defined $quo) { defined $sep && $quo eq $sep and return 1001; length ($quo) > 16 and return 1007; $quo =~ m/[\r\n]/ and return 1003; } if (defined $esc) { defined $sep && $esc eq $sep and return 1001; $esc =~ m/[\r\n]/ and return 1003; } if (defined $eol) { length ($eol) > 16 and return 1005; } return _unhealthy_whitespace ($self, $self->{allow_whitespace}); } # _check_sanity sub known_attributes { sort grep !m/^_/ => "sep", "quote", keys %def_attr; } # known_attributes sub new { $last_new_err = Text::CSV_XS->SetDiag (1000, "usage: my \$csv = Text::CSV_XS->new ([{ option => value, ... }]);"); my $proto = shift; my $class = ref ($proto) || $proto or return; @_ > 0 && ref $_[0] ne "HASH" and return; my $attr = shift || {}; my %attr = map { my $k = m/^[a-zA-Z]\w+$/ ? lc $_ : $_; exists $attr_alias{$k} and $k = $attr_alias{$k}; $k => $attr->{$_}; } keys %$attr; my $sep_aliased = 0; if (exists $attr{sep}) { $attr{sep_char} = delete $attr{sep}; $sep_aliased = 1; } my $quote_aliased = 0; if (exists $attr{quote}) { $attr{quote_char} = delete $attr{quote}; $quote_aliased = 1; } for (keys %attr) { if (m/^[a-z]/ && exists $def_attr{$_}) { # uncoverable condition false defined $attr{$_} && m/_char$/ and utf8::decode ($attr{$_}); next; } # croak? $last_new_err = Text::CSV_XS->SetDiag (1000, "INI - Unknown attribute '$_'"); $attr{auto_diag} and error_diag (); return; } if ($sep_aliased and defined $attr{sep_char}) { my @b = unpack "U0C*", $attr{sep_char}; if (@b > 1) { $attr{sep} = $attr{sep_char}; $attr{sep_char} = "\0"; } else { $attr{sep} = undef; } } if ($quote_aliased and defined $attr{quote_char}) { my @b = unpack "U0C*", $attr{quote_char}; if (@b > 1) { $attr{quote} = $attr{quote_char}; $attr{quote_char} = "\0"; } else { $attr{quote} = undef; } } my $self = { %def_attr, %attr }; if (my $ec = _check_sanity ($self)) { $last_new_err = Text::CSV_XS->SetDiag ($ec); $attr{auto_diag} and error_diag (); return; } if (defined $self->{callbacks} && ref $self->{callbacks} ne "HASH") { carp "The 'callbacks' attribute is set but is not a hash: ignored\n"; $self->{callbacks} = undef; } $last_new_err = Text::CSV_XS->SetDiag (0); defined $\ && !exists $attr{eol} and $self->{eol} = $\; bless $self, $class; defined $self->{types} and $self->types ($self->{types}); $self; } # new # Keep in sync with XS! my %_cache_id = ( # Only expose what is accessed from within PM quote_char => 0, escape_char => 1, sep_char => 2, sep => 39, # 39 .. 55 binary => 3, keep_meta_info => 4, always_quote => 5, allow_loose_quotes => 6, allow_loose_escapes => 7, allow_unquoted_escape => 8, allow_whitespace => 9, blank_is_undef => 10, eol => 11, quote => 15, verbatim => 22, empty_is_undef => 23, auto_diag => 24, diag_verbose => 33, quote_space => 25, quote_empty => 37, quote_binary => 32, escape_null => 31, decode_utf8 => 35, _has_hooks => 36, _is_bound => 26, # 26 .. 29 ); # A `character' sub _set_attr_C { my ($self, $name, $val, $ec) = @_; defined $val or $val = 0; utf8::decode ($val); $self->{$name} = $val; $ec = _check_sanity ($self) and croak ($self->SetDiag ($ec)); $self->_cache_set ($_cache_id{$name}, $val); } # _set_attr_C # A flag sub _set_attr_X { my ($self, $name, $val) = @_; defined $val or $val = 0; $self->{$name} = $val; $self->_cache_set ($_cache_id{$name}, 0 + $val); } # _set_attr_X # A number sub _set_attr_N { my ($self, $name, $val) = @_; $self->{$name} = $val; $self->_cache_set ($_cache_id{$name}, 0 + $val); } # _set_attr_N # Accessor methods. # It is unwise to change them halfway through a single file! sub quote_char { my $self = shift; if (@_) { $self->_set_attr_C ("quote_char", shift); $self->_cache_set ($_cache_id{quote}, ""); } $self->{quote_char}; } # quote_char sub quote { my $self = shift; if (@_) { my $quote = shift; defined $quote or $quote = ""; utf8::decode ($quote); my @b = unpack "U0C*", $quote; if (@b > 1) { @b > 16 and croak ($self->SetDiag (1007)); $self->quote_char ("\0"); } else { $self->quote_char ($quote); $quote = ""; } $self->{quote} = $quote; my $ec = _check_sanity ($self); $ec and croak ($self->SetDiag ($ec)); $self->_cache_set ($_cache_id{quote}, $quote); } my $quote = $self->{quote}; defined $quote && length ($quote) ? $quote : $self->{quote_char}; } # quote sub escape_char { my $self = shift; @_ and $self->_set_attr_C ("escape_char", shift); $self->{escape_char}; } # escape_char sub sep_char { my $self = shift; if (@_) { $self->_set_attr_C ("sep_char", shift); $self->_cache_set ($_cache_id{sep}, ""); } $self->{sep_char}; } # sep_char sub sep { my $self = shift; if (@_) { my $sep = shift; defined $sep or $sep = ""; utf8::decode ($sep); my @b = unpack "U0C*", $sep; if (@b > 1) { @b > 16 and croak ($self->SetDiag (1006)); $self->sep_char ("\0"); } else { $self->sep_char ($sep); $sep = ""; } $self->{sep} = $sep; my $ec = _check_sanity ($self); $ec and croak ($self->SetDiag ($ec)); $self->_cache_set ($_cache_id{sep}, $sep); } my $sep = $self->{sep}; defined $sep && length ($sep) ? $sep : $self->{sep_char}; } # sep sub eol { my $self = shift; if (@_) { my $eol = shift; defined $eol or $eol = ""; length ($eol) > 16 and croak ($self->SetDiag (1005)); $self->{eol} = $eol; $self->_cache_set ($_cache_id{eol}, $eol); } $self->{eol}; } # eol sub always_quote { my $self = shift; @_ and $self->_set_attr_X ("always_quote", shift); $self->{always_quote}; } # always_quote sub quote_space { my $self = shift; @_ and $self->_set_attr_X ("quote_space", shift); $self->{quote_space}; } # quote_space sub quote_empty { my $self = shift; @_ and $self->_set_attr_X ("quote_empty", shift); $self->{quote_empty}; } # quote_empty sub escape_null { my $self = shift; @_ and $self->_set_attr_X ("escape_null", shift); $self->{escape_null}; } # escape_null sub quote_null { goto &escape_null; } sub quote_binary { my $self = shift; @_ and $self->_set_attr_X ("quote_binary", shift); $self->{quote_binary}; } # quote_binary sub binary { my $self = shift; @_ and $self->_set_attr_X ("binary", shift); $self->{binary}; } # binary sub decode_utf8 { my $self = shift; @_ and $self->_set_attr_X ("decode_utf8", shift); $self->{decode_utf8}; } # decode_utf8 sub keep_meta_info { my $self = shift; if (@_) { my $v = shift; !defined $v || $v eq "" and $v = 0; $v =~ m/^[0-9]/ or $v = lc $v eq "false" ? 0 : 1; # true/truth = 1 $self->_set_attr_X ("keep_meta_info", $v); } $self->{keep_meta_info}; } # keep_meta_info sub allow_loose_quotes { my $self = shift; @_ and $self->_set_attr_X ("allow_loose_quotes", shift); $self->{allow_loose_quotes}; } # allow_loose_quotes sub allow_loose_escapes { my $self = shift; @_ and $self->_set_attr_X ("allow_loose_escapes", shift); $self->{allow_loose_escapes}; } # allow_loose_escapes sub allow_whitespace { my $self = shift; if (@_) { my $aw = shift; _unhealthy_whitespace ($self, $aw) and croak ($self->SetDiag (1002)); $self->_set_attr_X ("allow_whitespace", $aw); } $self->{allow_whitespace}; } # allow_whitespace sub allow_unquoted_escape { my $self = shift; @_ and $self->_set_attr_X ("allow_unquoted_escape", shift); $self->{allow_unquoted_escape}; } # allow_unquoted_escape sub blank_is_undef { my $self = shift; @_ and $self->_set_attr_X ("blank_is_undef", shift); $self->{blank_is_undef}; } # blank_is_undef sub empty_is_undef { my $self = shift; @_ and $self->_set_attr_X ("empty_is_undef", shift); $self->{empty_is_undef}; } # empty_is_undef sub verbatim { my $self = shift; @_ and $self->_set_attr_X ("verbatim", shift); $self->{verbatim}; } # verbatim sub auto_diag { my $self = shift; if (@_) { my $v = shift; !defined $v || $v eq "" and $v = 0; $v =~ m/^[0-9]/ or $v = lc $v eq "false" ? 0 : 1; # true/truth = 1 $self->_set_attr_X ("auto_diag", $v); } $self->{auto_diag}; } # auto_diag sub diag_verbose { my $self = shift; if (@_) { my $v = shift; !defined $v || $v eq "" and $v = 0; $v =~ m/^[0-9]/ or $v = lc $v eq "false" ? 0 : 1; # true/truth = 1 $self->_set_attr_X ("diag_verbose", $v); } $self->{diag_verbose}; } # diag_verbose # status # # object method returning the success or failure of the most recent # combine () or parse (). there are no side-effects. sub status { my $self = shift; return $self->{_STATUS}; } # status sub eof { my $self = shift; return $self->{_EOF}; } # status sub types { my $self = shift; if (@_) { if (my $types = shift) { $self->{_types} = join "", map { chr } @{$types}; $self->{types} = $types; } else { delete $self->{types}; delete $self->{_types}; undef; } } else { $self->{types}; } } # types sub callbacks { my $self = shift; if (@_) { my $cb; my $hf = 0x00; if (defined $_[0]) { grep { !defined } @_ and croak ($self->SetDiag (1004)); $cb = @_ == 1 && ref $_[0] eq "HASH" ? shift : @_ % 2 == 0 ? { @_ } : croak ($self->SetDiag (1004)); foreach my $cbk (keys %$cb) { (!ref $cbk && $cbk =~ m/^[\w.]+$/) && ref $cb->{$cbk} eq "CODE" or croak ($self->SetDiag (1004)); } exists $cb->{error} and $hf |= 0x01; exists $cb->{after_parse} and $hf |= 0x02; exists $cb->{before_print} and $hf |= 0x04; } elsif (@_ > 1) { # (undef, whatever) croak ($self->SetDiag (1004)); } $self->_set_attr_X ("_has_hooks", $hf); $self->{callbacks} = $cb; } $self->{callbacks}; } # callbacks # error_diag # # If (and only if) an error occurred, this function returns a code that # indicates the reason of failure sub error_diag { my $self = shift; my @diag = (0 + $last_new_err, $last_new_err, 0, 0, 0); if ($self && ref $self && # Not a class method or direct call $self->isa (__PACKAGE__) && exists $self->{_ERROR_DIAG}) { $diag[0] = 0 + $self->{_ERROR_DIAG}; $diag[1] = $self->{_ERROR_DIAG}; $diag[2] = 1 + $self->{_ERROR_POS} if exists $self->{_ERROR_POS}; $diag[3] = $self->{_RECNO}; $diag[4] = $self->{_ERROR_FLD} if exists $self->{_ERROR_FLD}; $diag[0] && $self && $self->{callbacks} && $self->{callbacks}{error} and return $self->{callbacks}{error}->(@diag); } my $context = wantarray; unless (defined $context) { # Void context, auto-diag if ($diag[0] && $diag[0] != 2012) { my $msg = "# CSV_XS ERROR: $diag[0] - $diag[1] \@ rec $diag[3] pos $diag[2]\n"; $diag[4] and $msg =~ s/$/ field $diag[4]/; unless ($self && ref $self) { # auto_diag # called without args in void context warn $msg; return; } if ($self->{diag_verbose} and $self->{_ERROR_INPUT}) { $msg .= "$self->{_ERROR_INPUT}'\n"; $msg .= " " x ($diag[2] - 1); $msg .= "^\n"; } my $lvl = $self->{auto_diag}; if ($lvl < 2) { my @c = caller (2); if (@c >= 11 && $c[10] && ref $c[10] eq "HASH") { my $hints = $c[10]; (exists $hints->{autodie} && $hints->{autodie} or exists $hints->{"guard Fatal"} && !exists $hints->{"no Fatal"}) and $lvl++; # Future releases of autodie will probably set $^H{autodie} # to "autodie @args", like "autodie :all" or "autodie open" # so we can/should check for "open" or "new" } } $lvl > 1 ? die $msg : warn $msg; } return; } return $context ? @diag : $diag[1]; } # error_diag sub record_number { my $self = shift; return $self->{_RECNO}; } # record_number # string # # object method returning the result of the most recent combine () or the # input to the most recent parse (), whichever is more recent. there are # no side-effects. sub string { my $self = shift; return ref $self->{_STRING} ? ${$self->{_STRING}} : undef; } # string # fields # # object method returning the result of the most recent parse () or the # input to the most recent combine (), whichever is more recent. there # are no side-effects. sub fields { my $self = shift; return ref $self->{_FIELDS} ? @{$self->{_FIELDS}} : undef; } # fields # meta_info # # object method returning the result of the most recent parse () or the # input to the most recent combine (), whichever is more recent. there # are no side-effects. meta_info () returns (if available) some of the # field's properties sub meta_info { my $self = shift; return ref $self->{_FFLAGS} ? @{$self->{_FFLAGS}} : undef; } # meta_info sub is_quoted { my ($self, $idx, $val) = @_; ref $self->{_FFLAGS} && $idx >= 0 && $idx < @{$self->{_FFLAGS}} or return; $self->{_FFLAGS}[$idx] & 0x0001 ? 1 : 0; } # is_quoted sub is_binary { my ($self, $idx, $val) = @_; ref $self->{_FFLAGS} && $idx >= 0 && $idx < @{$self->{_FFLAGS}} or return; $self->{_FFLAGS}[$idx] & 0x0002 ? 1 : 0; } # is_binary sub is_missing { my ($self, $idx, $val) = @_; $idx < 0 || !ref $self->{_FFLAGS} and return; $idx >= @{$self->{_FFLAGS}} and return 1; $self->{_FFLAGS}[$idx] & 0x0010 ? 1 : 0; } # is_missing # combine # # Object method returning success or failure. The given arguments are # combined into a single comma-separated value. Failure can be the # result of no arguments or an argument containing an invalid character. # side-effects include: # setting status () # setting fields () # setting string () # setting error_input () sub combine { my $self = shift; my $str = ""; $self->{_FIELDS} = \@_; $self->{_STATUS} = (@_ > 0) && $self->Combine (\$str, \@_, 0); $self->{_STRING} = \$str; $self->{_STATUS}; } # combine # parse # # Object method returning success or failure. The given argument is # expected to be a valid comma-separated value. Failure can be the # result of no arguments or an argument containing an invalid sequence # of characters. Side-effects include: # setting status () # setting fields () # setting meta_info () # setting string () # setting error_input () sub parse { my ($self, $str) = @_; my $fields = []; my $fflags = []; $self->{_STRING} = \$str; if (defined $str && $self->Parse ($str, $fields, $fflags)) { $self->{_FIELDS} = $fields; $self->{_FFLAGS} = $fflags; $self->{_STATUS} = 1; } else { $self->{_FIELDS} = undef; $self->{_FFLAGS} = undef; $self->{_STATUS} = 0; } $self->{_STATUS}; } # parse sub column_names { my ($self, @keys) = @_; @keys or return defined $self->{_COLUMN_NAMES} ? @{$self->{_COLUMN_NAMES}} : (); @keys == 1 && ! defined $keys[0] and return $self->{_COLUMN_NAMES} = undef; if (@keys == 1 && ref $keys[0] eq "ARRAY") { @keys = @{$keys[0]}; } elsif (join "", map { defined $_ ? ref $_ : "" } @keys) { croak ($self->SetDiag (3001)); } $self->{_BOUND_COLUMNS} && @keys != @{$self->{_BOUND_COLUMNS}} and croak ($self->SetDiag (3003)); $self->{_COLUMN_NAMES} = [ map { defined $_ ? $_ : "\cAUNDEF\cA" } @keys ]; @{$self->{_COLUMN_NAMES}}; } # column_names sub header { my ($self, $fh, @args) = @_; my (@seps, %args); for (@args) { if (ref $_ eq "ARRAY") { push @seps, @$_; next; } if (ref $_ eq "HASH") { %args = %$_; next; } croak (q{usage: $csv->headers ($fh, [ seps ], { options })}); } defined $args{detect_bom} or $args{detect_bom} = 1; defined $args{munge_column_names} or $args{munge_column_names} = "lc"; defined $args{set_column_names} or $args{set_column_names} = 1; defined $args{sep_set} && ref $args{sep_set} eq "ARRAY" and @seps = @{$args{sep_set}}; my $hdr = <$fh>; defined $hdr && $hdr ne "" or croak ($self->SetDiag (1010)); my %sep; @seps or @seps = (",", ";"); foreach my $sep (@seps) { index ($hdr, $sep) >= 0 and $sep{$sep}++; } keys %sep >= 2 and croak ($self->SetDiag (1011)); $self->sep (keys %sep); my $enc = ""; if ($args{detect_bom}) { # UTF-7 is not supported if ($hdr =~ s/^\x00\x00\xfe\xff//) { $enc = "utf-32be" } elsif ($hdr =~ s/^\xff\xfe\x00\x00//) { $enc = "utf-32le" } elsif ($hdr =~ s/^\xfe\xff//) { $enc = "utf-16be" } elsif ($hdr =~ s/^\xff\xfe//) { $enc = "utf-16le" } elsif ($hdr =~ s/^\xef\xbb\xbf//) { $enc = "utf-8" } elsif ($hdr =~ s/^\xf7\x64\x4c//) { $enc = "utf-1" } elsif ($hdr =~ s/^\xdd\x73\x66\x73//) { $enc = "utf-ebcdic" } elsif ($hdr =~ s/^\x0e\xfe\xff//) { $enc = "scsu" } elsif ($hdr =~ s/^\xfb\xee\x28//) { $enc = "bocu-1" } elsif ($hdr =~ s/^\x84\x31\x95\x33//) { $enc = "gb-18030" } if ($enc) { if ($enc =~ m/([13]).le$/) { my $l = 0 + $1; my $x; $hdr .= "\0" x $l; read $fh, $x, $l; } $enc = ":encoding($enc)"; binmode $fh, $enc; } } $args{munge_column_names} eq "lc" and $hdr = lc $hdr; $args{munge_column_names} eq "uc" and $hdr = uc $hdr; my $hr = \$hdr; # Will cause croak on perl-5.6.x open my $h, "<$enc", $hr; my $row = $self->getline ($h) or croak; close $h; my @hdr = @$row or croak ($self->SetDiag (1010)); ref $args{munge_column_names} eq "CODE" and @hdr = map { $args{munge_column_names}->($_) } @hdr; my %hdr = map { $_ => 1 } @hdr; exists $hdr{""} and croak ($self->SetDiag (1012)); keys %hdr == @hdr or croak ($self->SetDiag (1013)); $args{set_column_names} and $self->column_names (@hdr); wantarray ? @hdr : $self; } # header sub bind_columns { my ($self, @refs) = @_; @refs or return defined $self->{_BOUND_COLUMNS} ? @{$self->{_BOUND_COLUMNS}} : undef; if (@refs == 1 && ! defined $refs[0]) { $self->{_COLUMN_NAMES} = undef; return $self->{_BOUND_COLUMNS} = undef; } $self->{_COLUMN_NAMES} && @refs != @{$self->{_COLUMN_NAMES}} and croak ($self->SetDiag (3003)); join "", map { ref $_ eq "SCALAR" ? "" : "*" } @refs and croak ($self->SetDiag (3004)); $self->_set_attr_N ("_is_bound", scalar @refs); $self->{_BOUND_COLUMNS} = [ @refs ]; @refs; } # bind_columns sub getline_hr { my ($self, @args, %hr) = @_; $self->{_COLUMN_NAMES} or croak ($self->SetDiag (3002)); my $fr = $self->getline (@args) or return; if (ref $self->{_FFLAGS}) { # missing $self->{_FFLAGS}[$_] = 0x0010 for (@$fr ? $#{$fr} + 1 : 0) .. $#{$self->{_COLUMN_NAMES}}; @$fr == 1 && (!defined $fr->[0] || $fr->[0] eq "") and $self->{_FFLAGS}[0] ||= 0x0010; } @hr{@{$self->{_COLUMN_NAMES}}} = @$fr; \%hr; } # getline_hr sub getline_hr_all { my ($self, @args, %hr) = @_; $self->{_COLUMN_NAMES} or croak ($self->SetDiag (3002)); my @cn = @{$self->{_COLUMN_NAMES}}; [ map { my %h; @h{@cn} = @$_; \%h } @{$self->getline_all (@args)} ]; } # getline_hr_all sub say { my ($self, $io, @f) = @_; my $eol = $self->eol; defined $eol && $eol ne "" or $self->eol ($\ || $/); my $state = $self->print ($io, @f); $self->eol ($eol); return $state; } # say sub print_hr { my ($self, $io, $hr) = @_; $self->{_COLUMN_NAMES} or croak ($self->SetDiag (3009)); ref $hr eq "HASH" or croak ($self->SetDiag (3010)); $self->print ($io, [ map { $hr->{$_} } $self->column_names ]); } # print_hr sub fragment { my ($self, $io, $spec) = @_; my $qd = qr{\s* [0-9]+ \s* }x; # digit my $qs = qr{\s* (?: [0-9]+ | \* ) \s*}x; # digit or star my $qr = qr{$qd (?: - $qs )?}x; # range my $qc = qr{$qr (?: ; $qr )*}x; # list defined $spec && $spec =~ m{^ \s* \x23 ? \s* # optional leading # ( row | col | cell ) \s* = ( $qc # for row and col | $qd , $qd (?: - $qs , $qs)? # for cell (ranges) (?: ; $qd , $qd (?: - $qs , $qs)? )* # and cell (range) lists ) \s* $}xi or croak ($self->SetDiag (2013)); my ($type, $range) = (lc $1, $2); my @h = $self->column_names (); my @c; if ($type eq "cell") { my @spec; my $min_row; my $max_row = 0; for (split m/\s*;\s*/ => $range) { my ($tlr, $tlc, $brr, $brc) = (m{ ^ \s* ([0-9]+ ) \s* , \s* ([0-9]+ ) \s* (?: - \s* ([0-9]+ | \*) \s* , \s* ([0-9]+ | \*) \s* )? $}x) or croak ($self->SetDiag (2013)); defined $brr or ($brr, $brc) = ($tlr, $tlc); $tlr == 0 || $tlc == 0 || ($brr ne "*" && ($brr == 0 || $brr < $tlr)) || ($brc ne "*" && ($brc == 0 || $brc < $tlc)) and croak ($self->SetDiag (2013)); $tlc--; $brc-- unless $brc eq "*"; defined $min_row or $min_row = $tlr; $tlr < $min_row and $min_row = $tlr; $brr eq "*" || $brr > $max_row and $max_row = $brr; push @spec, [ $tlr, $tlc, $brr, $brc ]; } my $r = 0; while (my $row = $self->getline ($io)) { ++$r < $min_row and next; my %row; my $lc; foreach my $s (@spec) { my ($tlr, $tlc, $brr, $brc) = @$s; $r < $tlr || ($brr ne "*" && $r > $brr) and next; !defined $lc || $tlc < $lc and $lc = $tlc; my $rr = $brc eq "*" ? $#$row : $brc; $row{$_} = $row->[$_] for $tlc .. $rr; } push @c, [ @row{sort { $a <=> $b } keys %row } ]; if (@h) { my %h; @h{@h} = @{$c[-1]}; $c[-1] = \%h; } $max_row ne "*" && $r == $max_row and last; } return \@c; } # row or col my @r; my $eod = 0; for (split m/\s*;\s*/ => $range) { my ($from, $to) = m/^\s* ([0-9]+) (?: \s* - \s* ([0-9]+ | \* ))? \s* $/x or croak ($self->SetDiag (2013)); $to ||= $from; $to eq "*" and ($to, $eod) = ($from, 1); $from <= 0 || $to <= 0 || $to < $from and croak ($self->SetDiag (2013)); $r[$_] = 1 for $from .. $to; } my $r = 0; $type eq "col" and shift @r; $_ ||= 0 for @r; while (my $row = $self->getline ($io)) { $r++; if ($type eq "row") { if (($r > $#r && $eod) || $r[$r]) { push @c, $row; if (@h) { my %h; @h{@h} = @{$c[-1]}; $c[-1] = \%h; } } next; } push @c, [ map { ($_ > $#r && $eod) || $r[$_] ? $row->[$_] : () } 0..$#$row ]; if (@h) { my %h; @h{@h} = @{$c[-1]}; $c[-1] = \%h; } } return \@c; } # fragment my $csv_usage = q{usage: my $aoa = csv (in => $file);}; sub _csv_attr { my %attr = (@_ == 1 && ref $_[0] eq "HASH" ? %{$_[0]} : @_) or croak; $attr{binary} = 1; my $enc = delete $attr{enc} || delete $attr{encoding} || ""; $enc eq "auto" and ($attr{detect_bom}, $enc) = (1, ""); $enc =~ m/^[-\w.]+$/ and $enc = ":encoding($enc)"; my $fh; my $cls = 0; # If I open a file, I have to close it my $in = delete $attr{in} || delete $attr{file} or croak $csv_usage; my $out = delete $attr{out} || delete $attr{file}; ref $in eq "CODE" || ref $in eq "ARRAY" and $out ||= \*STDOUT; if ($out) { $in or croak $csv_usage; # No out without in defined $attr{eol} or $attr{eol} = "\r\n"; if ((ref $out and ref $out ne "SCALAR") or "GLOB" eq ref \$out) { $fh = $out; } else { open $fh, ">", $out or croak "$out: $!"; $cls = 1; } $enc and binmode $fh, $enc; } if ( ref $in eq "CODE" or ref $in eq "ARRAY") { # All done } elsif (ref $in eq "SCALAR") { # Strings with code points over 0xFF may not be mapped into in-memory file handles # "<$enc" does not change that :( open $fh, "<", $in or croak "Cannot open from SCALAR using PerlIO"; $cls = 1; } elsif (ref $in or "GLOB" eq ref \$in) { if (!ref $in && $] < 5.008005) { $fh = \*$in; # uncoverable statement ancient perl version required } else { $fh = $in; } } else { open $fh, "<$enc", $in or croak "$in: $!"; $cls = 1; } $fh or croak qq{No valid source passed. "in" is required}; my $hdrs = delete $attr{headers}; my $frag = delete $attr{fragment}; my $key = delete $attr{key}; my $cbai = delete $attr{callbacks}{after_in} || delete $attr{after_in} || delete $attr{callbacks}{after_parse} || delete $attr{after_parse}; my $cbbo = delete $attr{callbacks}{before_out} || delete $attr{before_out}; my $cboi = delete $attr{callbacks}{on_in} || delete $attr{on_in}; my $hd_s = delete $attr{sep_set} || delete $attr{seps}; my $hd_b = delete $attr{detect_bom} || delete $attr{bom}; my $hd_m = delete $attr{munge} || delete $attr{munge_column_names}; my $hd_c = delete $attr{set_column_names}; for ([ quo => "quote" ], [ esc => "escape" ], [ escape => "escape_char" ], ) { my ($f, $t) = @$_; exists $attr{$f} and !exists $attr{$t} and $attr{$t} = delete $attr{$f}; } my $fltr = delete $attr{filter}; my %fltr = ( not_blank => sub { @{$_[1]} > 1 or defined $_[1][0] && $_[1][0] ne "" }, not_empty => sub { grep { defined && $_ ne "" } @{$_[1]} }, filled => sub { grep { defined && m/\S/ } @{$_[1]} }, ); defined $fltr && !ref $fltr && exists $fltr{$fltr} and $fltr = { 0 => $fltr{$fltr} }; ref $fltr eq "HASH" or $fltr = undef; defined $attr{auto_diag} or $attr{auto_diag} = 1; my $csv = delete $attr{csv} || Text::CSV_XS->new (\%attr) or croak $last_new_err; return { csv => $csv, attr => { %attr }, fh => $fh, cls => $cls, in => $in, out => $out, enc => $enc, hdrs => $hdrs, key => $key, frag => $frag, fltr => $fltr, cbai => $cbai, cbbo => $cbbo, cboi => $cboi, hd_s => $hd_s, hd_b => $hd_b, hd_m => $hd_m, hd_c => $hd_c, }; } # _csv_attr sub csv { @_ && ref $_[0] eq __PACKAGE__ and splice @_, 0, 0, "csv"; @_ or croak $csv_usage; my $c = _csv_attr (@_); my ($csv, $in, $fh, $hdrs) = @{$c}{"csv", "in", "fh", "hdrs"}; my %hdr; if (ref $hdrs eq "HASH") { %hdr = %$hdrs; $hdrs = "auto"; } if ($c->{out}) { if (ref $in eq "CODE") { my $hdr = 1; while (my $row = $in->($csv)) { if (ref $row eq "ARRAY") { $csv->print ($fh, $row); next; } if (ref $row eq "HASH") { if ($hdr) { $hdrs ||= [ map { $hdr{$_} || $_ } keys %$row ]; $csv->print ($fh, $hdrs); $hdr = 0; } $csv->print ($fh, [ @{$row}{@$hdrs} ]); } } } elsif (ref $in->[0] eq "ARRAY") { # aoa ref $hdrs and $csv->print ($fh, $hdrs); for (@{$in}) { $c->{cboi} and $c->{cboi}->($csv, $_); $c->{cbbo} and $c->{cbbo}->($csv, $_); $csv->print ($fh, $_); } } else { # aoh my @hdrs = ref $hdrs ? @{$hdrs} : keys %{$in->[0]}; defined $hdrs or $hdrs = "auto"; ref $hdrs || $hdrs eq "auto" and $csv->print ($fh, [ map { $hdr{$_} || $_ } @hdrs ]); for (@{$in}) { local %_; *_ = $_; $c->{cboi} and $c->{cboi}->($csv, $_); $c->{cbbo} and $c->{cbbo}->($csv, $_); $csv->print ($fh, [ @{$_}{@hdrs} ]); } } $c->{cls} and close $fh; return 1; } if (defined $c->{hd_s} || defined $c->{hd_b} || defined $c->{hd_m} || defined $c->{hd_c}) { my %harg; defined $c->{hd_s} and $harg{set_set} = $c->{hd_s}; defined $c->{hd_d} and $harg{detect_bom} = $c->{hd_b}; defined $c->{hd_m} and $harg{munge_column_names} = $hdrs ? "none" : $c->{hd_m}; defined $c->{hd_c} and $harg{set_column_names} = $hdrs ? 0 : $c->{hd_c}; $csv->header ($fh, \%harg); my @hdr = $csv->column_names; @hdr and $hdrs ||= \@hdr; } my $key = $c->{key} and $hdrs ||= "auto"; $c->{fltr} && grep m/\D/ => keys %{$c->{fltr}} and $hdrs ||= "auto"; if (defined $hdrs) { if (!ref $hdrs) { if ($hdrs eq "skip") { $csv->getline ($fh); # discard; } elsif ($hdrs eq "auto") { my $h = $csv->getline ($fh) or return; $hdrs = [ map { $hdr{$_} || $_ } @$h ]; } elsif ($hdrs eq "lc") { my $h = $csv->getline ($fh) or return; $hdrs = [ map { lc ($hdr{$_} || $_) } @$h ]; } elsif ($hdrs eq "uc") { my $h = $csv->getline ($fh) or return; $hdrs = [ map { uc ($hdr{$_} || $_) } @$h ]; } } elsif (ref $hdrs eq "CODE") { my $h = $csv->getline ($fh) or return; my $cr = $hdrs; $hdrs = [ map { $cr->($hdr{$_} || $_) } @$h ]; } } if ($c->{fltr}) { my %f = %{$c->{fltr}}; # convert headers to index my @hdr; if (ref $hdrs) { @hdr = @{$hdrs}; for (0 .. $#hdr) { exists $f{$hdr[$_]} and $f{$_ + 1} = delete $f{$hdr[$_]}; } } $csv->callbacks (after_parse => sub { my ($CSV, $ROW) = @_; # lexical sub-variables in caps foreach my $FLD (sort keys %f) { local $_ = $ROW->[$FLD - 1]; local %_; @hdr and @_{@hdr} = @$ROW; $f{$FLD}->($CSV, $ROW) or return \"skip"; $ROW->[$FLD - 1] = $_; } }); } my $frag = $c->{frag}; my $ref = ref $hdrs ? # aoh do { $csv->column_names ($hdrs); $frag ? $csv->fragment ($fh, $frag) : $key ? { map { $_->{$key} => $_ } @{$csv->getline_hr_all ($fh)} } : $csv->getline_hr_all ($fh); } : # aoa $frag ? $csv->fragment ($fh, $frag) : $csv->getline_all ($fh); $ref or Text::CSV_XS->auto_diag; $c->{cls} and close $fh; if ($ref and $c->{cbai} || $c->{cboi}) { foreach my $r (@{$ref}) { local %_; ref $r eq "HASH" and *_ = $r; $c->{cbai} and $c->{cbai}->($csv, $r); $c->{cboi} and $c->{cboi}->($csv, $r); } } defined wantarray or return csv (%{$c->{attr}}, in => $ref, headers => $hdrs, %{$c->{attr}}); return $ref; } # csv 1; __END__ =encoding utf-8 =head1 NAME Text::CSV_XS - comma-separated values manipulation routines =head1 SYNOPSIS # Functional interface use Text::CSV_XS qw( csv ); # Read whole file in memory my $aoa = csv (in => "data.csv"); # as array of array my $aoh = csv (in => "data.csv", headers => "auto"); # as array of hash # Write array of arrays as csv file csv (in => $aoa, out => "file.csv", sep_char=> ";"); # Only show lines where "code" is odd csv (in => "data.csv", filter => { code => sub { $_ % 2 }}); # Object interface use Text::CSV_XS; my @rows; # Read/parse CSV my $csv = Text::CSV_XS->new ({ binary => 1, auto_diag => 1 }); open my $fh, "<:encoding(utf8)", "test.csv" or die "test.csv: $!"; while (my $row = $csv->getline ($fh)) { $row->[2] =~ m/pattern/ or next; # 3rd field should match push @rows, $row; } close $fh; # and write as CSV open $fh, ">:encoding(utf8)", "new.csv" or die "new.csv: $!"; $csv->say ($fh, $_) for @rows; close $fh or die "new.csv: $!"; =head1 DESCRIPTION Text::CSV_XS provides facilities for the composition and decomposition of comma-separated values. An instance of the Text::CSV_XS class will combine fields into a C string and parse a C string into fields. The module accepts either strings or files as input and support the use of user-specified characters for delimiters, separators, and escapes. =head2 Embedded newlines B: The default behavior is to accept only ASCII characters in the range from C<0x20> (space) to C<0x7E> (tilde). This means that the fields can not contain newlines. If your data contains newlines embedded in fields, or characters above C<0x7E> (tilde), or binary data, you B> set C<< binary => 1 >> in the call to L. To cover the widest range of parsing options, you will always want to set binary. But you still have the problem that you have to pass a correct line to the L method, which is more complicated from the usual point of usage: my $csv = Text::CSV_XS->new ({ binary => 1, eol => $/ }); while (<>) { # WRONG! $csv->parse ($_); my @fields = $csv->fields (); } this will break, as the C might read broken lines: it does not care about the quoting. If you need to support embedded newlines, the way to go is to B pass L|/eol> in the parser (it accepts C<\n>, C<\r>, B C<\r\n> by default) and then my $csv = Text::CSV_XS->new ({ binary => 1 }); open my $io, "<", $file or die "$file: $!"; while (my $row = $csv->getline ($io)) { my @fields = @$row; } The old(er) way of using global file handles is still supported while (my $row = $csv->getline (*ARGV)) { ... } =head2 Unicode Unicode is only tested to work with perl-5.8.2 and up. The simplest way to ensure the correct encoding is used for in- and output is by either setting layers on the filehandles, or setting the L argument for L. open my $fh, "<:encoding(UTF-8)", "in.csv" or die "in.csv: $!"; or my $aoa = csv (in => "in.csv", encoding => "UTF-8"); open my $fh, ">:encoding(UTF-8)", "out.csv" or die "out.csv: $!"; or csv (in => $aoa, out => "out.csv", encoding => "UTF-8"); On parsing (both for L and L), if the source is marked being UTF8, then all fields that are marked binary will also be marked UTF8. On combining (L and L): if any of the combining fields was marked UTF8, the resulting string will be marked as UTF8. Note however that all fields I the first field marked UTF8 and contained 8-bit characters that were not upgraded to UTF8, these will be C in the resulting string too, possibly causing unexpected errors. If you pass data of different encoding, or you don't know if there is different encoding, force it to be upgraded before you pass them on: $csv->print ($fh, [ map { utf8::upgrade (my $x = $_); $x } @data ]); For complete control over encoding, please use L: use Text::CSV::Encoded; my $csv = Text::CSV::Encoded->new ({ encoding_in => "iso-8859-1", # the encoding comes into Perl encoding_out => "cp1252", # the encoding comes out of Perl }); $csv = Text::CSV::Encoded->new ({ encoding => "utf8" }); # combine () and print () accept *literally* utf8 encoded data # parse () and getline () return *literally* utf8 encoded data $csv = Text::CSV::Encoded->new ({ encoding => undef }); # default # combine () and print () accept UTF8 marked data # parse () and getline () return UTF8 marked data =head1 SPECIFICATION While no formal specification for CSV exists, RFC 4180 I<1>) describes the common format and establishes C as the MIME type registered with the IANA. RFC 7111 I<2> adds fragments to CSV. Many informal documents exist that describe the C format. "How To: The Comma Separated Value (CSV) File Format" I<3>) provides an overview of the C format in the most widely used applications and explains how it can best be used and supported. 1) http://tools.ietf.org/html/rfc4180 2) http://tools.ietf.org/html/rfc7111 3) http://www.creativyst.com/Doc/Articles/CSV/CSV01.htm The basic rules are as follows: B is a delimited data format that has fields/columns separated by the comma character and records/rows separated by newlines. Fields that contain a special character (comma, newline, or double quote), must be enclosed in double quotes. However, if a line contains a single entry that is the empty string, it may be enclosed in double quotes. If a field's value contains a double quote character it is escaped by placing another double quote character next to it. The C file format does not require a specific character encoding, byte order, or line terminator format. =over 2 =item * Each record is a single line ended by a line feed (ASCII/C=C<0x0A>) or a carriage return and line feed pair (ASCII/C=C<0x0D 0x0A>), however, line-breaks may be embedded. =item * Fields are separated by commas. =item * Allowable characters within a C field include C<0x09> (C) and the inclusive range of C<0x20> (space) through C<0x7E> (tilde). In binary mode all characters are accepted, at least in quoted fields. =item * A field within C must be surrounded by double-quotes to contain a separator character (comma). =back Though this is the most clear and restrictive definition, Text::CSV_XS is way more liberal than this, and allows extension: =over 2 =item * Line termination by a single carriage return is accepted by default =item * The separation-, escape-, and escape- characters can be any ASCII character in the range from C<0x20> (space) to C<0x7E> (tilde). Characters outside this range may or may not work as expected. Multibyte characters, like UTF C (ARABIC COMMA), C (FULLWIDTH COMMA), C (SYMBOL FOR ESCAPE), C (SYMBOL FOR NEWLINE), C (FULLWIDTH QUOTATION MARK), and C (LEFT DOUBLE QUOTATION MARK) (to give some examples of what might look promising) work for newer versions of perl for C, and C but not for C. If you use perl-5.8.2 or higher these three attributes are utf8-decoded, to increase the likelihood of success. This way C will be allowed as a quote character. =item * A field in C must be surrounded by double-quotes to make an embedded double-quote, represented by a pair of consecutive double-quotes, valid. In binary mode you may additionally use the sequence C<"0> for representation of a NULL byte. Using C<0x00> in binary mode is just as valid. =item * Several violations of the above specification may be lifted by passing some options as attributes to the object constructor. =back =head1 METHODS =head2 version X (Class method) Returns the current module version. =head2 new X (Class method) Returns a new instance of class Text::CSV_XS. The attributes are described by the (optional) hash ref C<\%attr>. my $csv = Text::CSV_XS->new ({ attributes ... }); The following attributes are available: =head3 eol X my $csv = Text::CSV_XS->new ({ eol => $/ }); $csv->eol (undef); my $eol = $csv->eol; The end-of-line string to add to rows for L or the record separator for L. When not passed in a B instance, the default behavior is to accept C<\n>, C<\r>, and C<\r\n>, so it is probably safer to not specify C at all. Passing C or the empty string behave the same. When not passed in a B instance, records are not terminated at all, so it is probably wise to pass something you expect. A safe choice for C on output is either C<$/> or C<\r\n>. Common values for C are C<"\012"> (C<\n> or Line Feed), C<"\015\012"> (C<\r\n> or Carriage Return, Line Feed), and C<"\015"> (C<\r> or Carriage Return). The L|/eol> attribute cannot exceed 7 (ASCII) characters. If both C<$/> and L|/eol> equal C<"\015">, parsing lines that end on only a Carriage Return without Line Feed, will be Ld correct. =head3 sep_char X my $csv = Text::CSV_XS->new ({ sep_char => ";" }); $csv->sep_char (";"); my $c = $csv->sep_char; The char used to separate fields, by default a comma. (C<,>). Limited to a single-byte character, usually in the range from C<0x20> (space) to C<0x7E> (tilde). When longer sequences are required, use L|/sep>. The separation character can not be equal to the quote character or to the escape character. See also L =head3 sep X my $csv = Text::CSV_XS->new ({ sep => "\N{FULLWIDTH COMMA}" }); $csv->sep (";"); my $sep = $csv->sep; The chars used to separate fields, by default undefined. Limited to 8 bytes. When set, overrules L|/sep_char>. If its length is one byte it acts as an alias to L|/sep_char>. See also L =head3 quote_char X my $csv = Text::CSV_XS->new ({ quote_char => "'" }); $csv->quote_char (undef); my $c = $csv->quote_char; The character to quote fields containing blanks or binary data, by default the double quote character (C<">). A value of undef suppresses quote chars (for simple cases only). Limited to a single-byte character, usually in the range from C<0x20> (space) to C<0x7E> (tilde). When longer sequences are required, use L|/quote>. C can not be equal to L|/sep_char>. =head3 quote X my $csv = Text::CSV_XS->new ({ quote => "\N{FULLWIDTH QUOTATION MARK}" }); $csv->quote ("'"); my $quote = $csv->quote; The chars used to quote fields, by default undefined. Limited to 8 bytes. When set, overrules L|/quote_char>. If its length is one byte it acts as an alias to L|/quote_char>. See also L =head3 escape_char X my $csv = Text::CSV_XS->new ({ escape_char => "\\" }); $csv->escape_char (undef); my $c = $csv->escape_char; The character to escape certain characters inside quoted fields. This is limited to a single-byte character, usually in the range from C<0x20> (space) to C<0x7E> (tilde). The C defaults to being the double-quote mark (C<">). In other words the same as the default L|/quote_char>. This means that doubling the quote mark in a field escapes it: "foo","bar","Escape ""quote mark"" with two ""quote marks""","baz" If you change the L|/quote_char> without changing the C, the C will still be the double-quote (C<">). If instead you want to escape the L|/quote_char> by doubling it you will need to also change the C to be the same as what you have changed the L|/quote_char> to. The escape character can not be equal to the separation character. =head3 binary X my $csv = Text::CSV_XS->new ({ binary => 1 }); $csv->binary (0); my $f = $csv->binary; If this attribute is C<1>, you may use binary characters in quoted fields, including line feeds, carriage returns and C bytes. (The latter could be escaped as C<"0>.) By default this feature is off. If a string is marked UTF8, C will be turned on automatically when binary characters other than C and C are encountered. Note that a simple string like C<"\x{00a0}"> might still be binary, but not marked UTF8, so setting C<< { binary => 1 } >> is still a wise option. =head3 decode_utf8 X my $csv = Text::CSV_XS->new ({ decode_utf8 => 1 }); $csv->decode_utf8 (0); my $f = $csv->decode_utf8; This attributes defaults to TRUE. While I, fields that are valid UTF-8, are automatically set to be UTF-8, so that $csv->parse ("\xC4\xA8\n"); results in PV("\304\250"\0) [UTF8 "\x{128}"] Sometimes it might not be a desired action. To prevent those upgrades, set this attribute to false, and the result will be PV("\304\250"\0) =head3 auto_diag X my $csv = Text::CSV_XS->new ({ auto_diag => 1 }); $csv->auto_diag (2); my $l = $csv->auto_diag; Set this attribute to a number between C<1> and C<9> causes L to be automatically called in void context upon errors. In case of error C<2012 - EOF>, this call will be void. If C is set to a numeric value greater than C<1>, it will C on errors instead of C. If set to anything unrecognized, it will be silently ignored. Future extensions to this feature will include more reliable auto-detection of C being active in the scope of which the error occurred which will increment the value of C with C<1> the moment the error is detected. =head3 diag_verbose X my $csv = Text::CSV_XS->new ({ diag_verbose => 1 }); $csv->diag_verbose (2); my $l = $csv->diag_verbose; Set the verbosity of the output triggered by C. Currently only adds the current input-record-number (if known) to the diagnostic output with an indication of the position of the error. =head3 blank_is_undef X my $csv = Text::CSV_XS->new ({ blank_is_undef => 1 }); $csv->blank_is_undef (0); my $f = $csv->blank_is_undef; Under normal circumstances, C data makes no distinction between quoted- and unquoted empty fields. These both end up in an empty string field once read, thus 1,"",," ",2 is read as ("1", "", "", " ", "2") When I C files with either L|/always_quote> or L|/quote_empty> set, the unquoted I field is the result of an undefined value. To enable this distinction when I C data, the C attribute will cause unquoted empty fields to be set to C, causing the above to be parsed as ("1", "", undef, " ", "2") note that this is specifically important when loading C fields into a database that allows C values, as the perl equivalent for C is C in L land. =head3 empty_is_undef X my $csv = Text::CSV_XS->new ({ empty_is_undef => 1 }); $csv->empty_is_undef (0); my $f = $csv->empty_is_undef; Going one step further than L|/blank_is_undef>, this attribute converts all empty fields to C, so 1,"",," ",2 is read as (1, undef, undef, " ", 2) Note that this effects only fields that are originally empty, not fields that are empty after stripping allowed whitespace. YMMV. =head3 allow_whitespace X my $csv = Text::CSV_XS->new ({ allow_whitespace => 1 }); $csv->allow_whitespace (0); my $f = $csv->allow_whitespace; When this option is set to true, the whitespace (C's and C's) surrounding the separation character is removed when parsing. If either C or C is one of the three characters L|/sep_char>, L|/quote_char>, or L|/escape_char> it will not be considered whitespace. Now lines like: 1 , "foo" , bar , 3 , zapp are parsed as valid C, even though it violates the C specs. Note that B whitespace is stripped from both start and end of each field. That would make it I than a I to enable parsing bad C lines, as 1, 2.0, 3, ape , monkey will now be parsed as ("1", "2.0", "3", "ape", "monkey") even if the original line was perfectly acceptable C. =head3 allow_loose_quotes X my $csv = Text::CSV_XS->new ({ allow_loose_quotes => 1 }); $csv->allow_loose_quotes (0); my $f = $csv->allow_loose_quotes; By default, parsing unquoted fields containing L|/quote_char> characters like 1,foo "bar" baz,42 would result in parse error 2034. Though it is still bad practice to allow this format, we cannot help the fact that some vendors make their applications spit out lines styled this way. If there is B bad C data, like 1,"foo "bar" baz",42 or 1,""foo bar baz"",42 there is a way to get this data-line parsed and leave the quotes inside the quoted field as-is. This can be achieved by setting C B making sure that the L|/escape_char> is I equal to L|/quote_char>. =head3 allow_loose_escapes X my $csv = Text::CSV_XS->new ({ allow_loose_escapes => 1 }); $csv->allow_loose_escapes (0); my $f = $csv->allow_loose_escapes; Parsing fields that have L|/escape_char> characters that escape characters that do not need to be escaped, like: my $csv = Text::CSV_XS->new ({ escape_char => "\\" }); $csv->parse (qq{1,"my bar\'s",baz,42}); would result in parse error 2025. Though it is bad practice to allow this format, this attribute enables you to treat all escape character sequences equal. =head3 allow_unquoted_escape X my $csv = Text::CSV_XS->new ({ allow_unquoted_escape => 1 }); $csv->allow_unquoted_escape (0); my $f = $csv->allow_unquoted_escape; A backward compatibility issue where L|/escape_char> differs from L|/quote_char> prevents L|/escape_char> to be in the first position of a field. If L|/quote_char> is equal to the default C<"> and L|/escape_char> is set to C<\>, this would be illegal: 1,\0,2 Setting this attribute to C<1> might help to overcome issues with backward compatibility and allow this style. =head3 always_quote X my $csv = Text::CSV_XS->new ({ always_quote => 1 }); $csv->always_quote (0); my $f = $csv->always_quote; By default the generated fields are quoted only if they I to be. For example, if they contain the separator character. If you set this attribute to C<1> then I defined fields will be quoted. (C fields are not quoted, see L). This makes it quite often easier to handle exported data in external applications. (Poor creatures who are better to use Text::CSV_XS. :) =head3 quote_space X my $csv = Text::CSV_XS->new ({ quote_space => 1 }); $csv->quote_space (0); my $f = $csv->quote_space; By default, a space in a field would trigger quotation. As no rule exists this to be forced in C, nor any for the opposite, the default is true for safety. You can exclude the space from this trigger by setting this attribute to 0. =head3 quote_empty X my $csv = Text::CSV_XS->new ({ quote_empty => 1 }); $csv->quote_empty (0); my $f = $csv->quote_empty; By default the generated fields are quoted only if they I to be. An empty (defined) field does not need quotation. If you set this attribute to C<1> then I defined fields will be quoted. (C fields are not quoted, see L). See also L|/always_quote>. =head3 quote_binary X my $csv = Text::CSV_XS->new ({ quote_binary => 1 }); $csv->quote_binary (0); my $f = $csv->quote_binary; By default, all "unsafe" bytes inside a string cause the combined field to be quoted. By setting this attribute to C<0>, you can disable that trigger for bytes >= C<0x7F>. =head3 escape_null or quote_null (deprecated) X X my $csv = Text::CSV_XS->new ({ escape_null => 1 }); $csv->escape_null (0); my $f = $csv->escape_null; By default, a C byte in a field would be escaped. This option enables you to treat the C byte as a simple binary character in binary mode (the C<< { binary => 1 } >> is set). The default is true. You can prevent C escapes by setting this attribute to C<0>. =head3 keep_meta_info X my $csv = Text::CSV_XS->new ({ keep_meta_info => 1 }); $csv->keep_meta_info (0); my $f = $csv->keep_meta_info; By default, the parsing of input records is as simple and fast as possible. However, some parsing information - like quotation of the original field - is lost in that process. Setting this flag to true enables retrieving that information after parsing with the methods L, L, and L described below. Default is false for performance. If you set this attribute to a value greater than 9, than you can control output quotation style like it was used in the input of the the last parsed record (unless quotation was added because of other reasons). my $csv = Text::CSV_XS->new ({ binary => 1, keep_meta_info => 1, quote_space => 0, }); my $row = $csv->parse (q{1,,"", ," ",f,"g","h""h",help,"help"}); $csv->print (*STDOUT, \@row); # 1,,, , ,f,g,"h""h",help,help $csv->keep_meta_info (11); $csv->print (*STDOUT, \@row); # 1,,"", ," ",f,"g","h""h",help,"help" =head3 verbatim X my $csv = Text::CSV_XS->new ({ verbatim => 1 }); $csv->verbatim (0); my $f = $csv->verbatim; This is a quite controversial attribute to set, but makes some hard things possible. The rationale behind this attribute is to tell the parser that the normally special characters newline (C) and Carriage Return (C) will not be special when this flag is set, and be dealt with as being ordinary binary characters. This will ease working with data with embedded newlines. When C is used with L, L auto-C's every line. Imagine a file format like M^^Hans^Janssen^Klas 2\n2A^Ja^11-06-2007#\r\n where, the line ending is a very specific C<"#\r\n">, and the sep_char is a C<^> (caret). None of the fields is quoted, but embedded binary data is likely to be present. With the specific line ending, this should not be too hard to detect. By default, Text::CSV_XS' parse function is instructed to only know about C<"\n"> and C<"\r"> to be legal line endings, and so has to deal with the embedded newline as a real C, so it can scan the next line if binary is true, and the newline is inside a quoted field. With this option, we tell L to parse the line as if C<"\n"> is just nothing more than a binary character. For L this means that the parser has no more idea about line ending and L Cs line endings on reading. =head3 types A set of column types; the attribute is immediately passed to the L method. =head3 callbacks X See the L section below. =head3 accessors To sum it up, $csv = Text::CSV_XS->new (); is equivalent to $csv = Text::CSV_XS->new ({ eol => undef, # \r, \n, or \r\n sep_char => ',', sep => undef, quote_char => '"', quote => undef, escape_char => '"', binary => 0, decode_utf8 => 1, auto_diag => 0, diag_verbose => 0, blank_is_undef => 0, empty_is_undef => 0, allow_whitespace => 0, allow_loose_quotes => 0, allow_loose_escapes => 0, allow_unquoted_escape => 0, always_quote => 0, quote_empty => 0, quote_space => 1, escape_null => 1, quote_binary => 1, keep_meta_info => 0, verbatim => 0, types => undef, callbacks => undef, }); For all of the above mentioned flags, an accessor method is available where you can inquire the current value, or change the value my $quote = $csv->quote_char; $csv->binary (1); It is not wise to change these settings halfway through writing C data to a stream. If however you want to create a new stream using the available C object, there is no harm in changing them. If the L constructor call fails, it returns C, and makes the fail reason available through the L method. $csv = Text::CSV_XS->new ({ ecs_char => 1 }) or die "".Text::CSV_XS->error_diag (); L will return a string like "INI - Unknown attribute 'ecs_char'" =head2 known_attributes X @attr = Text::CSV_CS->known_attributes; @attr = Text::CSV_CS::known_attributes; @attr = $csv->known_attributes; This method will return an ordered list of all the supported attributes as described above. This can be useful for knowing what attributes are valid in classes that use or extend Text::CSV_XS. =head2 print X $status = $csv->print ($io, $colref); Similar to L + L + L, but much more efficient. It expects an array ref as input (not an array!) and the resulting string is not really created, but immediately written to the C<$io> object, typically an IO handle or any other object that offers a L method. For performance reasons C does not create a result string, so all L, L, L, and L methods will return undefined information after executing this method. If C<$colref> is C (explicit, not through a variable argument) and L was used to specify fields to be printed, it is possible to make performance improvements, as otherwise data would have to be copied as arguments to the method call: $csv->bind_columns (\($foo, $bar)); $status = $csv->print ($fh, undef); A short benchmark my @data = ("aa" .. "zz"); $csv->bind_columns (\(@data)); $csv->print ($io, [ @data ]); # 11800 recs/sec $csv->print ($io, \@data ); # 57600 recs/sec $csv->print ($io, undef ); # 48500 recs/sec =head2 say X $status = $csv->say ($io, $colref); Like L|/print>, but L|/eol> defaults to C<$\>. =head2 print_hr X $csv->print_hr ($io, $ref); Provides an easy way to print a C<$ref> (as fetched with L) provided the column names are set with L. It is just a wrapper method with basic parameter checks over $csv->print ($io, [ map { $ref->{$_} } $csv->column_names ]); =head2 combine X $status = $csv->combine (@fields); This method constructs a C record from C<@fields>, returning success or failure. Failure can result from lack of arguments or an argument that contains an invalid character. Upon success, L can be called to retrieve the resultant C string. Upon failure, the value returned by L is undefined and L could be called to retrieve the invalid argument. =head2 string X $line = $csv->string (); This method returns the input to L or the resultant C string of L, whichever was called more recently. =head2 getline X $colref = $csv->getline ($io); This is the counterpart to L, as L is the counterpart to L: it parses a row from the C<$io> handle using the L method associated with C<$io> and parses this row into an array ref. This array ref is returned by the function or C for failure. When C<$io> does not support C, you are likely to hit errors. When fields are bound with L the return value is a reference to an empty list. The L, L, and L methods are meaningless again. =head2 getline_all X $arrayref = $csv->getline_all ($io); $arrayref = $csv->getline_all ($io, $offset); $arrayref = $csv->getline_all ($io, $offset, $length); This will return a reference to a list of L results. In this call, C is disabled. If C<$offset> is negative, as with C, only the last C records of C<$io> are taken into consideration. Given a CSV file with 10 lines: lines call ----- --------------------------------------------------------- 0..9 $csv->getline_all ($io) # all 0..9 $csv->getline_all ($io, 0) # all 8..9 $csv->getline_all ($io, 8) # start at 8 - $csv->getline_all ($io, 0, 0) # start at 0 first 0 rows 0..4 $csv->getline_all ($io, 0, 5) # start at 0 first 5 rows 4..5 $csv->getline_all ($io, 4, 2) # start at 4 first 2 rows 8..9 $csv->getline_all ($io, -2) # last 2 rows 6..7 $csv->getline_all ($io, -4, 2) # first 2 of last 4 rows =head2 getline_hr X The L and L methods work together to allow you to have rows returned as hashrefs. You must call L first to declare your column names. $csv->column_names (qw( code name price description )); $hr = $csv->getline_hr ($io); print "Price for $hr->{name} is $hr->{price} EUR\n"; L will croak if called before L. Note that L creates a hashref for every row and will be much slower than the combined use of L and L but still offering the same ease of use hashref inside the loop: my @cols = @{$csv->getline ($io)}; $csv->column_names (@cols); while (my $row = $csv->getline_hr ($io)) { print $row->{price}; } Could easily be rewritten to the much faster: my @cols = @{$csv->getline ($io)}; my $row = {}; $csv->bind_columns (\@{$row}{@cols}); while ($csv->getline ($io)) { print $row->{price}; } Your mileage may vary for the size of the data and the number of rows. With perl-5.14.2 the comparison for a 100_000 line file with 14 rows: Rate hashrefs getlines hashrefs 1.00/s -- -76% getlines 4.15/s 313% -- =head2 getline_hr_all X $arrayref = $csv->getline_hr_all ($io); $arrayref = $csv->getline_hr_all ($io, $offset); $arrayref = $csv->getline_hr_all ($io, $offset, $length); This will return a reference to a list of L results. In this call, L|/keep_meta_info> is disabled. =head2 parse X $status = $csv->parse ($line); This method decomposes a C string into fields, returning success or failure. Failure can result from a lack of argument or the given C string is improperly formatted. Upon success, L can be called to retrieve the decomposed fields. Upon failure calling L will return undefined data and L can be called to retrieve the invalid argument. You may use the L method for setting column types. See L' description below. =head2 fragment X This function tries to implement RFC7111 (URI Fragment Identifiers for the text/csv Media Type) - http://tools.ietf.org/html/rfc7111 my $AoA = $csv->fragment ($io, $spec); In specifications, C<*> is used to specify the I item, a dash (C<->) to indicate a range. All indices are C<1>-based: the first row or column has index C<1>. Selections can be combined with the semi-colon (C<;>). When using this method in combination with L, the returned reference will point to a list of hashes instead of a list of lists. A disjointed cell-based combined selection might return rows with different number of columns making the use of hashes unpredictable. $csv->column_names ("Name", "Age"); my $AoH = $csv->fragment ($io, "col=3;8"); If the L callback is active, it is also called on every line parsed and skipped before the fragment. =over 2 =item row row=4 row=5-7 row=6-* row=1-2;4;6-* =item col col=2 col=1-3 col=4-* col=1-2;4;7-* =item cell In cell-based selection, the comma (C<,>) is used to pair row and column cell=4,1 The range operator (C<->) using Cs can be used to define top-left and bottom-right C location cell=3,1-4,6 The C<*> is only allowed in the second part of a pair cell=3,2-*,2 # row 3 till end, only column 2 cell=3,2-3,* # column 2 till end, only row 3 cell=3,2-*,* # strip row 1 and 2, and column 1 Cells and cell ranges may be combined with C<;>, possibly resulting in rows with different number of columns cell=1,1-2,2;3,3-4,4;1,4;4,1 Disjointed selections will only return selected cells. The cells that are not specified will not be included in the returned set, not even as C. As an example given a C like 11,12,13,...19 21,22,...28,29 : : 91,...97,98,99 with C will return: 11,12,14 21,22 33,34 41,43,44 Overlapping cell-specs will return those cells only once, So C will return: 11,12,13 21,22,23,24 31,32,33,34 42,43,44 =back L does B allow different types of specs to be combined (either C I C I C). Passing an invalid fragment specification will croak and set error 2013. =head2 column_names X Set the "keys" that will be used in the L calls. If no keys (column names) are passed, it will return the current setting as a list. L accepts a list of scalars (the column names) or a single array_ref, so you can pass the return value from L too: $csv->column_names ($csv->getline ($io)); L does B checking on duplicates at all, which might lead to unexpected results. Undefined entries will be replaced with the string C<"\cAUNDEF\cA">, so $csv->column_names (undef, "", "name", "name"); $hr = $csv->getline_hr ($io); Will set C<< $hr->{"\cAUNDEF\cA"} >> to the 1st field, C<< $hr->{""} >> to the 2nd field, and C<< $hr->{name} >> to the 4th field, discarding the 3rd field. L croaks on invalid arguments. =head2 header This method does NOT work in perl-5.6.x Parse the CSV header and set L|/sep>, column_names and encoding. my @hdr = $csv->header ($fh); $csv->header ($fh, { sep_set => [ ";", ",", "|", "\t" ] }); $csv->header ($fh, { detect_bom => 1, munge_column_names => "lc" }); The first argument should be a file handle. Assuming that the file opened for parsing has a header, and the header does not contain problematic characters like embedded newlines, read the first line from the open handle then auto-detect whether the header separates the column names with a character from the allowed separator list. If any of the allowed separators matches, and none of the I allowed separators match, set L|/sep> to that separator for the current CSV_XS instance and use it to parse the first line, map those to lowercase, and use that to set the instance L: my $csv = Text::CSV_XS->new ({ binary => 1, auto_diag => 1 }); open my $fh, "<", "file.csv"; binmode $fh; # for Windows $csv->header ($fh); while (my $row = $csv->getline_hr ($fh)) { ... } If the header is empty, contains more than one unique separator out of the allowed set, contains empty fields, or contains identical fields (after folding), it will croak with error 1010, 1011, 1012, or 1013 respectively. If the header contains embedded newlines or is not valid CSV in any other way, this method will croak and leave the parse error untouched. A successful call to C
will always set the L|/sep> of the C<$csv> object. This behavior can not be disabled. =head3 return value On error this method will croak. In list context, the headers will be returned whether they are used to set L or not. In scalar context, the instance itself is returned. B: the values as found in the header will effectively be B if C is false. =head3 Options =over 2 =item sep_set $csv->header ($fh, { sep_set => [ ";", ",", "|", "\t" ] }); The list of legal separators defaults to C<[ ";", "," ]> and can be changed by this option. As this is probably the most often used option, it can be passed on its own as an unnamed argument: $csv->header ($fh, [ ";", ",", "|", "\t", "::", "\x{2063}" ]); Multi-byte sequences are allowed, both multi-character and Unicode. See L|/sep>. =item detect_bom $csv->header ($fh, { detect_bom => 1 }); The default behavior is to detect if the header line starts with a BOM. If the header has a BOM, use that to set the encoding of C<$fh>. This default behavior can be disabled by passing a false value to C. Supported encodings from BOM are: UTF-8, UTF-16BE, UTF-16LE, UTF-32BE, and UTF-32LE. BOM's also support UTF-1, UTF-EBCDIC, SCSU, BOCU-1, and GB-18030 but L does not (yet). UTF-7 is not supported. The encoding is set using C on C<$fh>. If the handle was opened in a (correct) encoding, this method will B alter the encoding, as it checks the leading B of the first line. =item munge_column_names This option offers the means to modify the column names into something that is most useful to the application. The default is to map all column names to lower case. $csv->header ($fh, { munge_column_names => "lc" }); The following values are available: lc - lower case uc - upper case none - do not change \&cb - supply a callback $csv->header ($fh, { munge_column_names => sub { fc } }); $csv->header ($fh, { munge_column_names => sub { "column_".$col++ } }); $csv->header ($fh, { munge_column_names => sub { lc (s/\W+/_/gr) } }); As this callback is called in a C, you can use C<$_> directly. =item set_column_names $csv->header ($fh, { set_column_names => 1 }); The default is to set the instances column names using L if the method is successful, so subsequent calls to L can return a hash. Disable setting the header can be forced by using a false value for this option. =back =head3 Validation When receiving CSV files from external sources, this method can be used to protect against changes in the layout by restricting to known headers (and typos in the header fields). my %known = ( "record key" => "c_rec", "rec id" => "c_rec", "id_rec" => "c_rec", "kode" => "code", "code" => "code", "vaule" => "value", "value" => "value", ); my $csv = Text::CSV_XS->new ({ binary => 1, auto_diag => 1 }); open my $fh, "<", $source or die "$source: $!"; $csv->header ($fh, { munge_column_names => sub { s/\s+$//; s/^\s+//; $known{lc $_} or die "Unknown column '$_' in $source"; }}); while (my $row = $csv->getline_hr ($fh)) { say join "\t", $row->{c_rec}, $row->{code}, $row->{value}; } =head2 bind_columns X Takes a list of scalar references to be used for output with L or to store in the fields fetched by L. When you do not pass enough references to store the fetched fields in, L will fail with error C<3006>. If you pass more than there are fields to return, the content of the remaining references is left untouched. $csv->bind_columns (\$code, \$name, \$price, \$description); while ($csv->getline ($io)) { print "The price of a $name is \x{20ac} $price\n"; } To reset or clear all column binding, call L with the single argument C. This will also clear column names. $csv->bind_columns (undef); If no arguments are passed at all, L will return the list of current bindings or C if no binds are active. Note that in parsing with C, the fields are set on the fly. That implies that if the third field of a row causes an error, the first two fields already have been assigned the values of the current row, while the rest will still hold the values of the previous row. =head2 eof X $eof = $csv->eof (); If L or L was used with an IO stream, this method will return true (1) if the last call hit end of file, otherwise it will return false (''). This is useful to see the difference between a failure and end of file. Note that if the parsing of the last line caused an error, C is still true. That means that if you are I using L, an idiom like while (my $row = $csv->getline ($fh)) { # ... } $csv->eof or $csv->error_diag; will I report the error. You would have to change that to while (my $row = $csv->getline ($fh)) { # ... } +$csv->error_diag and $csv->error_diag; =head2 types X $csv->types (\@tref); This method is used to force that (all) columns are of a given type. For example, if you have an integer column, two columns with doubles and a string column, then you might do a $csv->types ([Text::CSV_XS::IV (), Text::CSV_XS::NV (), Text::CSV_XS::NV (), Text::CSV_XS::PV ()]); Column types are used only for I columns while parsing, in other words by the L and L methods. You can unset column types by doing a $csv->types (undef); or fetch the current type settings with $types = $csv->types (); =over 4 =item IV X Set field type to integer. =item NV X Set field type to numeric/float. =item PV X Set field type to string. =back =head2 fields X @columns = $csv->fields (); This method returns the input to L or the resultant decomposed fields of a successful L, whichever was called more recently. Note that the return value is undefined after using L, which does not fill the data structures returned by L. =head2 meta_info X @flags = $csv->meta_info (); This method returns the "flags" of the input to L or the flags of the resultant decomposed fields of L, whichever was called more recently. For each field, a meta_info field will hold flags that inform something about the field returned by the L method or passed to the L method. The flags are bit-wise-C'd like: =over 2 =item C< >0x0001 The field was quoted. =item C< >0x0002 The field was binary. =back See the C methods below. =head2 is_quoted X my $quoted = $csv->is_quoted ($column_idx); Where C<$column_idx> is the (zero-based) index of the column in the last result of L. This returns a true value if the data in the indicated column was enclosed in L|/quote_char> quotes. This might be important for fields where content C<,20070108,> is to be treated as a numeric value, and where C<,"20070108",> is explicitly marked as character string data. This method is only valid when L is set to a true value. =head2 is_binary X my $binary = $csv->is_binary ($column_idx); Where C<$column_idx> is the (zero-based) index of the column in the last result of L. This returns a true value if the data in the indicated column contained any byte in the range C<[\x00-\x08,\x10-\x1F,\x7F-\xFF]>. This method is only valid when L is set to a true value. =head2 is_missing X my $missing = $csv->is_missing ($column_idx); Where C<$column_idx> is the (zero-based) index of the column in the last result of L. $csv->keep_meta_info (1); while (my $hr = $csv->getline_hr ($fh)) { $csv->is_missing (0) and next; # This was an empty line } When using L, it is impossible to tell if the parsed fields are C because they where not filled in the C stream or because they were not read at all, as B the fields defined by L are set in the hash-ref. If you still need to know if all fields in each row are provided, you should enable L|/keep_meta_info> so you can check the flags. If L|/keep_meta_info> is C, C will always return C, regardless of C<$column_idx> being valid or not. If this attribute is C it will return either C<0> (the field is present) or C<1> (the field is missing). A special case is the empty line. If the line is completely empty - after dealing with the flags - this is still a valid CSV line: it is a record of just one single empty field. However, if C is set, invoking C with index C<0> will now return true. =head2 status X $status = $csv->status (); This method returns the status of the last invoked L or L call. Status is success (true: C<1>) or failure (false: C or C<0>). =head2 error_input X $bad_argument = $csv->error_input (); This method returns the erroneous argument (if it exists) of L or L, whichever was called more recently. If the last invocation was successful, C will return C. =head2 error_diag X Text::CSV_XS->error_diag (); $csv->error_diag (); $error_code = 0 + $csv->error_diag (); $error_str = "" . $csv->error_diag (); ($cde, $str, $pos, $rec, $fld) = $csv->error_diag (); If (and only if) an error occurred, this function returns the diagnostics of that error. If called in void context, this will print the internal error code and the associated error message to STDERR. If called in list context, this will return the error code and the error message in that order. If the last error was from parsing, the rest of the values returned are a best guess at the location within the line that was being parsed. Their values are 1-based. The position currently is index of the byte at which the parsing failed in the current record. It might change to be the index of the current character in a later release. The records is the index of the record parsed by the csv instance. The field number is the index of the field the parser thinks it is currently trying to parse. See F for how this can be used. If called in scalar context, it will return the diagnostics in a single scalar, a-la C<$!>. It will contain the error code in numeric context, and the diagnostics message in string context. When called as a class method or a direct function call, the diagnostics are that of the last L call. =head2 record_number X $recno = $csv->record_number (); Returns the records parsed by this csv instance. This value should be more accurate than C<$.> when embedded newlines come in play. Records written by this instance are not counted. =head2 SetDiag X $csv->SetDiag (0); Use to reset the diagnostics if you are dealing with errors. =head1 FUNCTIONS =head2 csv X This function is not exported by default and should be explicitly requested: use Text::CSV_XS qw( csv ); This is the second draft. This function will stay, but the arguments might change based on user feedback. This is an high-level function that aims at simple (user) interfaces. This can be used to read/parse a C file or stream (the default behavior) or to produce a file or write to a stream (define the C attribute). It returns an array- or hash-reference on parsing (or C on fail) or the numeric value of L on writing. When this function fails you can get to the error using the class call to L my $aoa = csv (in => "test.csv") or die Text::CSV_XS->error_diag; This function takes the arguments as key-value pairs. This can be passed as a list or as an anonymous hash: my $aoa = csv ( in => "test.csv", sep_char => ";"); my $aoh = csv ({ in => $fh, headers => "auto" }); The arguments passed consist of two parts: the arguments to L itself and the optional attributes to the C object used inside the function as enumerated and explained in L. If not overridden, the default option used for CSV is auto_diag => 1 The option that is always set and cannot be altered is binary => 1 As this function will likely be used in one-liners, it allows C to be abbreviated as C, and C to be abbreviated as C or C. Alternative invocations: my $aoa = Text::CSV_XS::csv (in => "file.csv"); my $csv = Text::CSV_XS->new (); my $aoa = $csv->csv (in => "file.csv"); In the latter case, the object attributes are used from the existing object and the attribute arguments in the function call are ignored: my $csv = Text::CSV_XS->new ({ sep_char => ";" }); my $aoh = $csv->csv (in => "file.csv", bom => 1); will parse using C<;> as C, not C<,>. =head3 in X Used to specify the source. C can be a file name (e.g. C<"file.csv">), which will be opened for reading and closed when finished, a file handle (e.g. C<$fh> or C), a reference to a glob (e.g. C<\*ARGV>), the glob itself (e.g. C<*STDIN>), or a reference to a scalar (e.g. C<\q{1,2,"csv"}>). When used with L, C should be a reference to a CSV structure (AoA or AoH) or a CODE-ref that returns an array-reference or a hash-reference. The code-ref will be invoked with no arguments. my $aoa = csv (in => "file.csv"); open my $fh, "<", "file.csv"; my $aoa = csv (in => $fh); my $csv = [ [qw( Foo Bar )], [ 1, 2 ], [ 2, 3 ]]; my $err = csv (in => $csv, out => "file.csv"); If called in void context without the L attribute, the resulting ref will be used as input to a subsequent call to csv: csv (in => "file.csv", filter => { 2 => sub { length > 2 }}) will be a shortcut to csv (in => csv (in => "file.csv", filter => { 2 => sub { length > 2 }})) where, in the absence of the C attribute, this is a shortcut to csv (in => csv (in => "file.csv", filter => { 2 => sub { length > 2 }}), out => *STDOUT) =head3 out X In output mode, the default CSV options when producing CSV are eol => "\r\n" The L attribute is ignored in output mode. C can be a file name (e.g. C<"file.csv">), which will be opened for writing and closed when finished, a file handle (e.g. C<$fh> or C), a reference to a glob (e.g. C<\*STDOUT>), or the glob itself (e.g. C<*STDOUT>). csv (in => sub { $sth->fetch }, out => "dump.csv"); csv (in => sub { $sth->fetchrow_hashref }, out => "dump.csv", headers => $sth->{NAME_lc}); When a code-ref is used for C, the output is generated per invocation, so no buffering is involved. This implies that there is no size restriction on the number of records. The C function ends when the coderef returns a false value. =head3 encoding X If passed, it should be an encoding accepted by the C<:encoding()> option to C. There is no default value. This attribute does not work in perl 5.6.x. C can be abbreviated to C for ease of use in command line invocations. If C is set to the literal value C<"auto">, the method L
will be invoked on the opened stream to check if there is a BOM and set the encoding accordingly. This is equal to passing a true value in the option L|/detect_bom>. =head3 detect_bom X If C is given, the method L
will be invoked on the opened stream to check if there is a BOM and set the encoding accordingly. C can be abbreviated to C. This is the same as setting L|/encoding> to C<"auto">. Note that as L is invoked, its default is to also set the headers. =head3 headers X If this attribute is not given, the default behavior is to produce an array of arrays. If C is supplied, it should be an anonymous list of column names, an anonymous hashref, a coderef, or a literal flag: C, C, C, or C. =over 2 =item skip X When C is used, the header will not be included in the output. my $aoa = csv (in => $fh, headers => "skip"); =item auto X If C is used, the first line of the C source will be read as the list of field headers and used to produce an array of hashes. my $aoh = csv (in => $fh, headers => "auto"); =item lc X If C is used, the first line of the C source will be read as the list of field headers mapped to lower case and used to produce an array of hashes. This is a variation of C. my $aoh = csv (in => $fh, headers => "lc"); =item uc X If C is used, the first line of the C source will be read as the list of field headers mapped to upper case and used to produce an array of hashes. This is a variation of C. my $aoh = csv (in => $fh, headers => "uc"); =item CODE X If a coderef is used, the first line of the C source will be read as the list of mangled field headers in which each field is passed as the only argument to the coderef. This list is used to produce an array of hashes. my $aoh = csv (in => $fh, headers => sub { lc ($_[0]) =~ s/kode/code/gr }); this example is a variation of using C where all occurrences of C are replaced with C. =item ARRAY X If C is an anonymous list, the entries in the list will be used as field names. The first line is considered data instead of headers. my $aoh = csv (in => $fh, headers => [qw( Foo Bar )]); csv (in => $aoa, out => $fh, headers => [qw( code description price )]); =item HASH X If C is an hash reference, this implies C, but header fields for that exist as key in the hashref will be replaced by the value for that key. Given a CSV file like post-kode,city,name,id number,fubble 1234AA,Duckstad,Donald,13,"X313DF" using csv (headers => { "post-kode" => "pc", "id number" => "ID" }, ... will return an entry like { pc => "1234AA", city => "Duckstad", name => "Donald", ID => "13", fubble => "X313DF", } =back See also L|/munge_column_names> and L|/set_column_names>. =head3 munge_column_names X If C is set, the method L is invoked on the opened stream with all matching arguments to detect and set the headers. C can be abbreviated to C. =head3 key X If passed, will default L|/headers> to C<"auto"> and return a hashref instead of an array of hashes. my $ref = csv (in => "test.csv", key => "code"); with test.csv like code,product,price,color 1,pc,850,gray 2,keyboard,12,white 3,mouse,5,black will return { 1 => { code => 1, color => 'gray', price => 850, product => 'pc' }, 2 => { code => 2, color => 'white', price => 12, product => 'keyboard' }, 3 => { code => 3, color => 'black', price => 5, product => 'mouse' } } =head3 fragment X Only output the fragment as defined in the L method. This option is ignored when I C. See L. Combining all of them could give something like use Text::CSV_XS qw( csv ); my $aoh = csv ( in => "test.txt", encoding => "utf-8", headers => "auto", sep_char => "|", fragment => "row=3;6-9;15-*", ); say $aoh->[15]{Foo}; =head3 sep_set X X If C is set, the method L is invoked on the opened stream to detect and set L|/sep_char> with the given set. C can be abbreviated to C. Note that as L is invoked, its default is to also set the headers. =head3 set_column_names X If C is passed, the method L is invoked on the opened stream with all arguments meant for L. =head2 Callbacks X Callbacks enable actions triggered from the I of Text::CSV_XS. While most of what this enables can easily be done in an unrolled loop as described in the L callbacks can be used to meet special demands or enhance the L function. =over 2 =item error X $csv->callbacks (error => sub { $csv->SetDiag (0) }); the C callback is invoked when an error occurs, but I when L is set to a true value. A callback is invoked with the values returned by L: my ($c, $s); sub ignore3006 { my ($err, $msg, $pos, $recno, $fldno) = @_; if ($err == 3006) { # ignore this error ($c, $s) = (undef, undef); Text::CSV_XS->SetDiag (0); } # Any other error return; } # ignore3006 $csv->callbacks (error => \&ignore3006); $csv->bind_columns (\$c, \$s); while ($csv->getline ($fh)) { # Error 3006 will not stop the loop } =item after_parse X $csv->callbacks (after_parse => sub { push @{$_[1]}, "NEW" }); while (my $row = $csv->getline ($fh)) { $row->[-1] eq "NEW"; } This callback is invoked after parsing with L only if no error occurred. The callback is invoked with two arguments: the current C parser object and an array reference to the fields parsed. The return code of the callback is ignored unless it is a reference to the string "skip", in which case the record will be skipped in L. sub add_from_db { my ($csv, $row) = @_; $sth->execute ($row->[4]); push @$row, $sth->fetchrow_array; } # add_from_db my $aoa = csv (in => "file.csv", callbacks => { after_parse => \&add_from_db }); This hook can be used for validation: X =over 2 =item FAIL Die if any of the records does not validate a rule: after_parse => sub { $_[1][4] =~ m/^[0-9]{4}\s?[A-Z]{2}$/ or die "5th field does not have a valid Dutch zipcode"; } =item DEFAULT Replace invalid fields with a default value: after_parse => sub { $_[1][2] =~ m/^\d+$/ or $_[1][2] = 0 } =item SKIP Skip records that have invalid fields (only applies to L): after_parse => sub { $_[1][0] =~ m/^\d+$/ or return \"skip"; } =back =item before_print X my $idx = 1; $csv->callbacks (before_print => sub { $_[1][0] = $idx++ }); $csv->print (*STDOUT, [ 0, $_ ]) for @members; This callback is invoked before printing with L only if no error occurred. The callback is invoked with two arguments: the current C parser object and an array reference to the fields passed. The return code of the callback is ignored. sub max_4_fields { my ($csv, $row) = @_; @$row > 4 and splice @$row, 4; } # max_4_fields csv (in => csv (in => "file.csv"), out => *STDOUT, callbacks => { before print => \&max_4_fields }); This callback is not active for L. =back =head3 Callbacks for csv () The L allows for some callbacks that do not integrate in XS internals but only feature the L function. csv (in => "file.csv", callbacks => { filter => { 6 => sub { $_ > 15 } }, # first after_parse => sub { say "AFTER PARSE"; }, # first after_in => sub { say "AFTER IN"; }, # second on_in => sub { say "ON IN"; }, # third }, ); csv (in => $aoh, out => "file.csv", callbacks => { on_in => sub { say "ON IN"; }, # first before_out => sub { say "BEFORE OUT"; }, # second before_print => sub { say "BEFORE PRINT"; }, # third }, ); =over 2 =item filter X This callback can be used to filter records. It is called just after a new record has been scanned. The callback accepts a hashref where the keys are the index to the row (the field number, 1-based) and the values are subs to return a true or false value. csv (in => "file.csv", filter => { 3 => sub { m/a/ }, # third field should contain an "a" 5 => sub { length > 4 }, # length of the 5th field minimal 5 }); csv (in => "file.csv", filter => "not_blank"); csv (in => "file.csv", filter => "not_empty"); csv (in => "file.csv", filter => "filled"); If the keys to the filter hash contain any character that is not a digit it will also implicitly set L to C<"auto"> unless L was already passed as argument. When headers are active, returning an array of hashes, the filter is not applicable to the header itself. csv (in => "file.csv", filter => { foo => sub { $_ > 4 }}); All sub results should match, as in AND. The context of the callback sets C<$_> localized to the field indicated by the filter. The two arguments are as with all other callbacks, so the other fields in the current row can be seen: filter => { 3 => sub { $_ > 100 ? $_[1][1] =~ m/A/ : $_[1][6] =~ m/B/ }} If the context is set to return a list of hashes (L is defined), the current record will also be available in the localized C<%_>: filter => { 3 => sub { $_ > 100 && $_{foo} =~ m/A/ && $_{bar} < 1000 }} If the filter is used to I the content by changing C<$_>, make sure that the sub returns true in order not to have that record skipped: filter => { 2 => sub { $_ = uc }} will upper-case the second field, and then skip it if the resulting content evaluates to false. To always accept, end with truth: filter => { 2 => sub { $_ = uc; 1 }} B Given a file like (line numbers prefixed for doc purpose only): 1:1,2,3 2: 3:, 4:"" 5:,, 6:, , 7:"", 8:" " 9:4,5,6 =over 2 =item not_blank Filter out the blank lines This filter is a shortcut for filter => { 0 => sub { @{$_[1]} > 1 or defined $_[1][0] && $_[1][0] ne "" } } Due to the implementation, it is currently impossible to also filter lines that consists only of a quoted empty field. These lines are also considered blank lines. With the given example, lines 2 and 4 will be skipped. =item not_empty Filter out lines where all the fields are empty. This filter is a shortcut for filter => { 0 => sub { grep { defined && $_ ne "" } @{$_[1]} } } A space is not regarded being empty, so given the example data, lines 2, 3, 4, 5, and 7 are skipped. =item filled Filter out lines that have no visible data This filter is a shortcut for filter => { 0 => sub { grep { defined && m/\S/ } @{$_[1]} } } This filter rejects all lines that I have at least one field that does not evaluate to the empty string. With the given example data, this filter would skip lines 2 through 8. =back =item after_in X This callback is invoked for each record after all records have been parsed but before returning the reference to the caller. The hook is invoked with two arguments: the current C parser object and a reference to the record. The reference can be a reference to a HASH or a reference to an ARRAY as determined by the arguments. This callback can also be passed as an attribute without the C wrapper. =item before_out X This callback is invoked for each record before the record is printed. The hook is invoked with two arguments: the current C parser object and a reference to the record. The reference can be a reference to a HASH or a reference to an ARRAY as determined by the arguments. This callback can also be passed as an attribute without the C wrapper. This callback makes the row available in C<%_> if the row is a hashref. In this case C<%_> is writable and will change the original row. =item on_in X This callback acts exactly as the L or the L hooks. This callback can also be passed as an attribute without the C wrapper. This callback makes the row available in C<%_> if the row is a hashref. In this case C<%_> is writable and will change the original row. So e.g. with my $aoh = csv ( in => \"foo\n1\n2\n", headers => "auto", on_in => sub { $_{bar} = 2; }, ); C<$aoh> will be: [ { foo => 1, bar => 2, } { foo => 2, bar => 2, } ] =item csv The I L can also be called as a method or with an existing Text::CSV_XS object. This could help if the function is to be invoked a lot of times and the overhead of creating the object internally over and over again would be prevented by passing an existing instance. my $csv = Text::CSV_XS->new ({ binary => 1, auto_diag => 1 }); my $aoa = $csv->csv (in => $fh); my $aoa = csv (in => $fh, csv => $csv); both act the same. Running this 20000 times on a 20 lines CSV file, showed a 53% speedup. =back =head1 INTERNALS =over 4 =item Combine (...) =item Parse (...) =back The arguments to these internal functions are deliberately not described or documented in order to enable the module authors make changes it when they feel the need for it. Using them is highly discouraged as the API may change in future releases. =head1 EXAMPLES =head2 Reading a CSV file line by line: my $csv = Text::CSV_XS->new ({ binary => 1, auto_diag => 1 }); open my $fh, "<", "file.csv" or die "file.csv: $!"; while (my $row = $csv->getline ($fh)) { # do something with @$row } close $fh or die "file.csv: $!"; =head3 Reading only a single column my $csv = Text::CSV_XS->new ({ binary => 1, auto_diag => 1 }); open my $fh, "<", "file.csv" or die "file.csv: $!"; # get only the 4th column my @column = map { $_->[3] } @{$csv->getline_all ($fh)}; close $fh or die "file.csv: $!"; with L, you could do my @column = map { $_->[0] } @{csv (in => "file.csv", fragment => "col=4")}; =head2 Parsing CSV strings: my $csv = Text::CSV_XS->new ({ keep_meta_info => 1, binary => 1 }); my $sample_input_string = qq{"I said, ""Hi!""",Yes,"",2.34,,"1.09","\x{20ac}",}; if ($csv->parse ($sample_input_string)) { my @field = $csv->fields; foreach my $col (0 .. $#field) { my $quo = $csv->is_quoted ($col) ? $csv->{quote_char} : ""; printf "%2d: %s%s%s\n", $col, $quo, $field[$col], $quo; } } else { print STDERR "parse () failed on argument: ", $csv->error_input, "\n"; $csv->error_diag (); } =head2 Printing CSV data =head3 The fast way: using L An example for creating C files using the L method: my $csv = Text::CSV_XS->new ({ binary => 1, eol => $/ }); open my $fh, ">", "foo.csv" or die "foo.csv: $!"; for (1 .. 10) { $csv->print ($fh, [ $_, "$_" ]) or $csv->error_diag; } close $fh or die "$tbl.csv: $!"; =head3 The slow way: using L and L or using the slower L and L methods: my $csv = Text::CSV_XS->new; open my $csv_fh, ">", "hello.csv" or die "hello.csv: $!"; my @sample_input_fields = ( 'You said, "Hello!"', 5.67, '"Surely"', '', '3.14159'); if ($csv->combine (@sample_input_fields)) { print $csv_fh $csv->string, "\n"; } else { print "combine () failed on argument: ", $csv->error_input, "\n"; } close $csv_fh or die "hello.csv: $!"; =head2 Rewriting CSV Rewrite C files with C<;> as separator character to well-formed C: use Text::CSV_XS qw( csv ); csv (in => csv (in => "bad.csv", sep_char => ";"), out => *STDOUT); As C is now default in L, a one-liner converting a UTF-16 CSV file with BOM and TAB-separation to valid UTF-8 CSV could be: $ perl -C3 -MText::CSV_XS=csv -we\ 'csv(in=>"utf16tab.csv",encoding=>"utf16",sep=>"\t")' >utf8.csv =head2 Dumping database tables to CSV Dumping a database table can be simple as this (TIMTOWTDI): my $dbh = DBI->connect (...); my $sql = "select * from foo"; # using your own loop open my $fh, ">", "foo.csv" or die "foo.csv: $!\n"; my $csv = Text::CSV_XS->new ({ binary => 1, eol => "\r\n" }); my $sth = $dbh->prepare ($sql); $sth->execute; $csv->print ($fh, $sth->{NAME_lc}); while (my $row = $sth->fetch) { $csv->print ($fh, $row); } # using the csv function, all in memory csv (out => "foo.csv", in => $dbh->selectall_arrayref ($sql)); # using the csv function, streaming with callbacks my $sth = $dbh->prepare ($sql); $sth->execute; csv (out => "foo.csv", in => sub { $sth->fetch }); csv (out => "foo.csv", in => sub { $sth->fetchrow_hashref }); Note that this does not discriminate between "empty" values and NULL-values from the database, as both will be the same empty field in CSV. To enable distinction between the two, use L|/quote_empty>. csv (out => "foo.csv", in => sub { $sth->fetch }, quote_empty => 1); If the database import utility supports special sequences to insert C values into the database, like MySQL/MariaDB supports C<\N>, use a filter or a map csv (out => "foo.csv", in => sub { $sth->fetch }, on_in => sub { $_ //= "\\N" for @{$_[1]} }); while (my $row = $sth->fetch) { $csv->print ($fh, [ map { $_ // "\\N" } @$row ]); } these special sequences are not recognized by Text::CSV_XS on parsing the CSV generated like this, but map and filter are your friends again while (my $row = $csv->getline ($io)) { $sth->execute (map { $_ eq "\\N" ? undef : $_ } @$row); } csv (in => "foo.csv", filter => { 1 => sub { $sth->execute (map { $_ eq "\\N" ? undef : $_ } @{$_[1]}); 0; }}); =head2 The examples folder For more extended examples, see the F C<1>. sub-directory in the original distribution or the git repository C<2>. 1. https://github.com/Tux/Text-CSV_XS/tree/master/examples 2. https://github.com/Tux/Text-CSV_XS The following files can be found there: =over 2 =item parser-xs.pl X This can be used as a boilerplate to parse invalid C and parse beyond (expected) errors alternative to using the L callback. $ perl examples/parser-xs.pl bad.csv >good.csv =item csv-check X This is a command-line tool that uses parser-xs.pl techniques to check the C file and report on its content. $ csv-check files/utf8.csv Checked with examples/csv-check 1.5 using Text::CSV_XS 0.81 OK: rows: 1, columns: 2 sep = <,>, quo = <">, bin = <1> =item csv2xls X A script to convert C to Microsoft Excel. This requires L and L. The converter accepts various options and can produce UTF-8 Excel files. =item csvdiff X A script that provides colorized diff on sorted CSV files, assuming first line is header and first field is the key. Output options include colorized ANSI escape codes or HTML. $ csvdiff --html --output=diff.html file1.csv file2.csv =back =head1 CAVEATS Text::CSV_XS is I designed to detect the characters used to quote and separate fields. The parsing is done using predefined (default) settings. In the examples sub-directory, you can find scripts that demonstrate how you could try to detect these characters yourself. =head2 Microsoft Excel The import/export from Microsoft Excel is a I, according to the documentation in C. Microsoft uses the system's list separator defined in the regional settings, which happens to be a semicolon for Dutch, German and Spanish (and probably some others as well). For the English locale, the default is a comma. In Windows however, the user is free to choose a predefined locale, and then change I individual setting in it, so checking the locale is no solution. As of version 1.17, a lone first line with just sep=; will be recognized and honored when parsing with L. =head1 TODO =over 2 =item More Errors & Warnings New extensions ought to be clear and concise in reporting what error has occurred where and why, and maybe also offer a remedy to the problem. L is a (very) good start, but there is more work to be done in this area. Basic calls should croak or warn on illegal parameters. Errors should be documented. =item setting meta info Future extensions might include extending the L, L, and L to accept setting these flags for fields, so you can specify which fields are quoted in the L/L combination. $csv->meta_info (0, 1, 1, 3, 0, 0); $csv->is_quoted (3, 1); L (a W3C editor's draft) could be an example for supporting more metadata. =item Parse the whole file at once Implement new methods or functions that enable parsing of a complete file at once, returning a list of hashes. Possible extension to this could be to enable a column selection on the call: my @AoH = $csv->parse_file ($filename, { cols => [ 1, 4..8, 12 ]}); Returning something like [ { fields => [ 1, 2, "foo", 4.5, undef, "", 8 ], flags => [ ... ], }, { fields => [ ... ], . }, ] Note that the L function already supports most of this, but does not return flags. L returns all rows for an open stream, but this will not return flags either. L can reduce the required rows I columns, but cannot combine them. =item Cookbook Write a document that has recipes for most known non-standard (and maybe some standard) C formats, including formats that use C, C<;>, C<|>, or other non-comma separators. Examples could be taken from W3C's L =item Steal Steal good new ideas and features from L or L. =item Perl6 support I'm already working on perl6 support L. No promises yet on when it is finished (or fast). Trying to keep the API alike as much as possible. =back =head2 NOT TODO =over 2 =item combined methods Requests for adding means (methods) that combine L and L in a single call will B be honored (use L instead). Likewise for L and L (use L instead), given the problems with embedded newlines. =back =head2 Release plan No guarantees, but this is what I had in mind some time ago: =over 2 =item * DIAGNOSTICS section in pod to *describe* the errors (see below) =back =head1 EBCDIC The current hard-coding of characters and character ranges makes this code unusable on C systems. Recent work in perl-5.20 might change that. Opening C encoded files on C+ systems is likely to succeed using Encode's C, C, or C: open my $fh, "<:encoding(cp1047)", "ebcdic_file.csv" or die "..."; =head1 DIAGNOSTICS Still under construction ... If an error occurs, C<< $csv->error_diag >> can be used to get information on the cause of the failure. Note that for speed reasons the internal value is never cleared on success, so using the value returned by L in normal cases - when no error occurred - may cause unexpected results. If the constructor failed, the cause can be found using L as a class method, like C<< Text::CSV_XS->error_diag >>. The C<< $csv->error_diag >> method is automatically invoked upon error when the contractor was called with L|/auto_diag> set to C<1> or C<2>, or when L is in effect. When set to C<1>, this will cause a C with the error message, when set to C<2>, it will C. C<2012 - EOF> is excluded from L|/auto_diag> reports. Errors can be (individually) caught using the L callback. The errors as described below are available. I have tried to make the error itself explanatory enough, but more descriptions will be added. For most of these errors, the first three capitals describe the error category: =over 2 =item * INI Initialization error or option conflict. =item * ECR Carriage-Return related parse error. =item * EOF End-Of-File related parse error. =item * EIQ Parse error inside quotation. =item * EIF Parse error inside field. =item * ECB Combine error. =item * EHR HashRef parse related error. =back And below should be the complete list of error codes that can be returned: =over 2 =item * 1001 "INI - sep_char is equal to quote_char or escape_char" X<1001> The L cannot be equal to L or to L, as this would invalidate all parsing rules. =item * 1002 "INI - allow_whitespace with escape_char or quote_char SP or TAB" X<1002> Using the L|/allow_whitespace> attribute when either L|/quote_char> or L|/escape_char> is equal to C or C is too ambiguous to allow. =item * 1003 "INI - \r or \n in main attr not allowed" X<1003> Using default L|/eol> characters in either L|/sep_char>, L|/quote_char>, or L|/escape_char> is not allowed. =item * 1004 "INI - callbacks should be undef or a hashref" X<1004> The L|/Callbacks> attribute only allows one to be C or a hash reference. =item * 1005 "INI - EOL too long" X<1005> The value passed for EOL is exceeding its maximum length (16). =item * 1006 "INI - SEP too long" X<1006> The value passed for SEP is exceeding its maximum length (16). =item * 1007 "INI - QUOTE too long" X<1007> The value passed for QUOTE is exceeding its maximum length (16). =item * 1010 "INI - the header is empty" X<1010> The header line parsed in the L is empty. =item * 1011 "INI - the header contains more than one valid separator" X<1011> The header line parsed in the L contains more than one (unique) separator character out of the allowed set of separators. =item * 1012 "INI - the header contains an empty field" X<1012> The header line parsed in the L is contains an empty field. =item * 1013 "INI - the header contains nun-unique fields" X<1013> The header line parsed in the L contains at least two identical fields. =item * 2010 "ECR - QUO char inside quotes followed by CR not part of EOL" X<2010> When L|/eol> has been set to anything but the default, like C<"\r\t\n">, and the C<"\r"> is following the B (closing) L|/quote_char>, where the characters following the C<"\r"> do not make up the L|/eol> sequence, this is an error. =item * 2011 "ECR - Characters after end of quoted field" X<2011> Sequences like C<1,foo,"bar"baz,22,1> are not allowed. C<"bar"> is a quoted field and after the closing double-quote, there should be either a new-line sequence or a separation character. =item * 2012 "EOF - End of data in parsing input stream" X<2012> Self-explaining. End-of-file while inside parsing a stream. Can happen only when reading from streams with L, as using L is done on strings that are not required to have a trailing L|/eol>. =item * 2013 "INI - Specification error for fragments RFC7111" X<2013> Invalid specification for URI L specification. =item * 2021 "EIQ - NL char inside quotes, binary off" X<2021> Sequences like C<1,"foo\nbar",22,1> are allowed only when the binary option has been selected with the constructor. =item * 2022 "EIQ - CR char inside quotes, binary off" X<2022> Sequences like C<1,"foo\rbar",22,1> are allowed only when the binary option has been selected with the constructor. =item * 2023 "EIQ - QUO character not allowed" X<2023> Sequences like C<"foo "bar" baz",qu> and C<2023,",2008-04-05,"Foo, Bar",\n> will cause this error. =item * 2024 "EIQ - EOF cannot be escaped, not even inside quotes" X<2024> The escape character is not allowed as last character in an input stream. =item * 2025 "EIQ - Loose unescaped escape" X<2025> An escape character should escape only characters that need escaping. Allowing the escape for other characters is possible with the attribute L. =item * 2026 "EIQ - Binary character inside quoted field, binary off" X<2026> Binary characters are not allowed by default. Exceptions are fields that contain valid UTF-8, that will automatically be upgraded if the content is valid UTF-8. Set L|/binary> to C<1> to accept binary data. =item * 2027 "EIQ - Quoted field not terminated" X<2027> When parsing a field that started with a quotation character, the field is expected to be closed with a quotation character. When the parsed line is exhausted before the quote is found, that field is not terminated. =item * 2030 "EIF - NL char inside unquoted verbatim, binary off" X<2030> =item * 2031 "EIF - CR char is first char of field, not part of EOL" X<2031> =item * 2032 "EIF - CR char inside unquoted, not part of EOL" X<2032> =item * 2034 "EIF - Loose unescaped quote" X<2034> =item * 2035 "EIF - Escaped EOF in unquoted field" X<2035> =item * 2036 "EIF - ESC error" X<2036> =item * 2037 "EIF - Binary character in unquoted field, binary off" X<2037> =item * 2110 "ECB - Binary character in Combine, binary off" X<2110> =item * 2200 "EIO - print to IO failed. See errno" X<2200> =item * 3001 "EHR - Unsupported syntax for column_names ()" X<3001> =item * 3002 "EHR - getline_hr () called before column_names ()" X<3002> =item * 3003 "EHR - bind_columns () and column_names () fields count mismatch" X<3003> =item * 3004 "EHR - bind_columns () only accepts refs to scalars" X<3004> =item * 3006 "EHR - bind_columns () did not pass enough refs for parsed fields" X<3006> =item * 3007 "EHR - bind_columns needs refs to writable scalars" X<3007> =item * 3008 "EHR - unexpected error in bound fields" X<3008> =item * 3009 "EHR - print_hr () called before column_names ()" X<3009> =item * 3010 "EHR - print_hr () called with invalid arguments" X<3010> =back =head1 SEE ALSO L, L, L, L, L, L, L, L, L and L, and of course L. If you are using perl6, you can have a look at C in the perl6 ecosystem, offering the same features. =head3 non-perl A CSV parser in JavaScript, also used by L, is the multi-threaded in-browser L. L is a python CSV parsing toolkit. =head1 AUTHOR Alan Citterman Falan@mfgrtl.comE> wrote the original Perl module. Please don't send mail concerning Text::CSV_XS to Alan, who is not involved in the C/XS part that is now the main part of the module. Jochen Wiedmann Fjoe@ispsoft.deE> rewrote the en- and decoding in C by implementing a simple finite-state machine. He added variable quote, escape and separator characters, the binary mode and the print and getline methods. See F releases 0.10 through 0.23. H.Merijn Brand Fh.m.brand@xs4all.nlE> cleaned up the code, added the field flags methods, wrote the major part of the test suite, completed the documentation, fixed most RT bugs, added all the allow flags and the L function. See ChangeLog releases 0.25 and on. =head1 COPYRIGHT AND LICENSE Copyright (C) 2007-2016 H.Merijn Brand. All rights reserved. Copyright (C) 1998-2001 Jochen Wiedmann. All rights reserved. Copyright (C) 1997 Alan Citterman. All rights reserved. This library is free software; you can redistribute and/or modify it under the same terms as Perl itself. =cut =for elvis :ex:se gw=75|color guide #ff0000: =cut