Text-CSV_XS-1.41/0000755000031300001440000000000013622243127014125 5ustar00merijnusers00000000000000Text-CSV_XS-1.41/t/0000755000031300001440000000000013622243127014370 5ustar00merijnusers00000000000000Text-CSV_XS-1.41/t/12_acc.t0000644000031300001440000002607513316623612015620 0ustar00merijnusers00000000000000#!/usr/bin/perl use strict; use warnings; use Test::More tests => 234; 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->formula, "none", "formula"); is ($csv->strict, 0, "strict"); 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->undef_str, undef, "undef_str"); 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 (";"), ";", "sep (;)"); is ($csv->sep_char (), ";", "sep_char ()"); is ($csv->quote_char ("="), "=", "quote_char (=)"); is ($csv->quote (undef), "", "quote (undef)"); is ($csv->quote (""), "", "quote (undef)"); is ($csv->quote ("**"), "**", "quote (**)"); 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->keep_meta_info (0), 0, "keep_meta_info (0)"); is ($csv->keep_meta_info (""), 0, "keep_meta_info ('')"); is ($csv->keep_meta_info (undef), 0, "keep_meta_info (undef)"); is ($csv->keep_meta_info ("false"), 0, "keep_meta_info (undef)"); is ($csv->keep_meta_info ("true"), 1, "keep_meta_info (undef)"); 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->formula ("diag"), "diag", "formula (\"diag\")"); is ($csv->strict (1), 1, "strict (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->undef_str ("-"), "-", "undef_str"); 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"); is ($csv->undef_str (undef), undef, "undef_str"); # 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 => "::::::::::", quote_char => undef, escape_char => undef, }), "new (undef ...)"); is ($csv->sep_char, "\0", "sep_char undef"); is ($csv->sep, "::::::::::", "sep long"); 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 ({ escape_char => undef }), "undef escape aliases"); is ($csv->escape_char, undef, "escape_char is undef"); ok ($csv = Text::CSV_XS->new ({ quote => undef }), "undef quote aliases"); 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"); } foreach my $esc (undef, "", " ", "\t", "!!!!!!") { foreach my $quo (undef, "", " ", "\t", "!!!!!!") { defined $esc && $esc =~ m/[ \t]/ or defined $quo && $quo =~ m/[ \t]/ or next; eval { $csv = Text::CSV_XS->new ({ escape => $esc, quote => $quo, 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 strict formula undef_str types callbacks ENCODING )]; 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.41/t/80_diag.t0000644000031300001440000003441413615017006015773 0ustar00merijnusers00000000000000#!/usr/bin/perl use strict; use warnings; use Test::More tests => 333; #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 my $fh, "<", "CSV_XS.xs" or die "Cannot read error messages from XS\n"; while (<$fh>) { m/^ \{ ([0-9]{4}), "([^"]+)"\s+\}/ and $err{$1} = $2; } close $fh; } my $tfn = "_80test.csv"; END { -f $tfn and unlink $tfn; } $| = 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"); } { my $csv = Text::CSV_XS->new ({ sep_char => "=" }); eval { $csv->quote ("::::::::::::::"); }; is (0 + $csv->error_diag, 0, "Can set quote to something long"); eval { $csv->quote ("="); }; is (0 + $csv->error_diag, 1001, "Cannot set quote to current sep"); } { my $csv = Text::CSV_XS->new ({ quote_char => "=" }); eval { $csv->sep ("::::::::::::::"); }; is (0 + $csv->error_diag, 0, "Can set sep to something long"); eval { $csv->sep (undef); }; is (0 + $csv->error_diag, 1008, "Can set sep to undef"); eval { $csv->sep (""); }; is (0 + $csv->error_diag, 1008, "Can set sep to empty"); eval { $csv->sep ("="); }; is (0 + $csv->error_diag, 1001, "Cannot set sep to current sep"); } { my $csv = Text::CSV_XS->new ({ strict => 1 }); ok ($csv->parse ("1,2,3"), "Set strict to 3 columns"); ok ($csv->parse ("a,b,c"), "3 columns should be correct"); is ($csv->parse ("3,4"), 0, "Not enough columns"); is (0 + $csv->error_diag, 2014, "Error set correctly"); } { my $csv = Text::CSV_XS->new ({ strict => 1 }); ok ($csv->parse ("1,2,3"), "Set strict to 3 columns"); is ($csv->parse ("3,4,5,6"), 0, "Too many columns"); is (0 + $csv->error_diag, 2014, "Error set correctly"); } { my $csv = Text::CSV_XS->new ({ strict => 1 }); open my $fh, ">", $tfn or die "$tfn: $!\n"; ok ($csv->say ($fh, [ 1, 2, 3 ]), "Write line 1"); ok ($csv->say ($fh, [ 1, 2, 3 ]), "Write line 2"); close $fh; open $fh, "<", $tfn or die "$tfn: $!\n"; ok ((my $r = $csv->getline ($fh)), "Get line 1 under strict"); ok (( $r = $csv->getline ($fh)), "Get line 2 under strict"); is ($csv->getline ($fh), undef, "EOF under strict"); is (0 + $csv->error_diag, 2012, "Error is 2012 instead of 2014"); ok ($csv->eof, "EOF is set"); close $fh; } { my $csv = Text::CSV_XS->new ({ strict => 1 }); open my $fh, ">", $tfn or die "$tfn: $!\n"; ok ($csv->say ($fh, [ 1, 2, 3 ]), "Write line 1"); ok ($csv->print ($fh, [ 1, 2, 3 ]), "Write line 2 no newline"); close $fh; open $fh, "<", $tfn or die "$tfn: $!\n"; ok ((my $r = $csv->getline ($fh)), "Get line 1 under strict"); ok (( $r = $csv->getline ($fh)), "Get line 2 under strict no newline"); is ($csv->getline ($fh), undef, "EOF under strict"); is (0 + $csv->error_diag, 2012, "Error is 2012 instead of 2014"); ok ($csv->eof, "EOF is set"); close $fh; } { my $csv = Text::CSV_XS->new (); open my $fh, ">", $tfn or die "$tfn: $!\n"; ok ($csv->say ($fh, [ 1 .. 3 ]), "Write line 1 (headers)"); ok ($csv->say ($fh, [ 1 .. 4 ]), "Write line 2 (data)"); close $fh; my $aoh = Text::CSV_XS::csv (in => $tfn, headers => "auto"); is_deeply ($aoh, [{ 1 => 1, 2 => 2, 3 => 3 }], "Column dropped"); my @e; eval { local $SIG{__WARN__} = sub { push @e, @_ }; $aoh = Text::CSV_XS::csv (in => $tfn, headers => "auto", strict => 1); }; is_deeply ($aoh, [], "Fail under strict"); is (scalar @e, 1, "Got error"); like ($e[0], qr{ 2014 }, "Error 2014"); open $fh, ">", $tfn or die "$tfn: $!\n"; ok ($csv->say ($fh, [ 1 .. 4 ]), "Write line 1 (headers)"); ok ($csv->say ($fh, [ 1 .. 3 ]), "Write line 2 (data)"); close $fh; $aoh = Text::CSV_XS::csv (in => $tfn, headers => "auto"); is_deeply ($aoh, [{ 1 => 1, 2 => 2, 3 => 3, 4 => undef }], "Column added"); @e = (); eval { local $SIG{__WARN__} = sub { push @e, @_ }; $aoh = Text::CSV_XS::csv (in => $tfn, headers => "auto", strict => 1); }; is_deeply ($aoh, [], "Fail under strict"); is (scalar @e, 1, "Got error"); like ($e[0], qr{ 2014 }, "Error 2014"); } { my $csv = Text::CSV_XS->new; eval { $csv->header (undef, "foo"); }; is (0 + $csv->error_diag, 1014, "Cannot read header from undefined source"); eval { $csv->header (*STDIN, "foo"); }; like ($@, qr/^usage:/, "Illegal header call"); } { my $csv = Text::CSV_XS->new; foreach my $arg ([], sub {}, Text::CSV_XS->new, {}) { eval { $csv->parse ($arg) }; my @diag = $csv->error_diag; is ($diag[0], 1500, "Invalid parameters (code)"); like ($diag[1], qr{^PRM - Invalid/unsupported argument}, "Invalid parameters (msg)"); } } SKIP: { $] < 5.008 and skip qq{$] does not support ScalarIO}, 14; foreach my $key ({}, sub {}, []) { my $csv = Text::CSV_XS->new; my $x = eval { $csv->csv (in => \"a,b", key => $key) }; is ($x, undef, "Invalid key"); my @diag = $csv->error_diag; is ($diag[0], 1501, "Invalid key type"); } { my $csv = Text::CSV_XS->new; my $x = eval { $csv->csv (in => \"a,b", value => "b") }; is ($x, undef, "Value without key"); my @diag = $csv->error_diag; is ($diag[0], 1502, "No key"); } foreach my $val ({}, sub {}, []) { my $csv = Text::CSV_XS->new; my $x = eval { $csv->csv (in => \"a,b", key => "a", value => $val) }; is ($x, undef, "Invalid value"); my @diag = $csv->error_diag; is ($diag[0], 1503, "Invalid value type"); } } # Issue 19: auto_diag > 1 does not die if ->header () is used if ($] >= 5.008002) { open my $fh, ">", $tfn or die "$tfn: $!\n"; print $fh qq{foo,bar,baz\n}; print $fh qq{a,xxx,1\n}; print $fh qq{b,"xx"xx", 2"\n}; print $fh qq{c, foo , 3\n}; close $fh; foreach my $h (0, 1) { $@ = ""; my @row; my $ok = eval { open $fh, "<", $tfn or die "$tfn: $!\n"; my $csv = Text::CSV_XS->new ({ auto_diag => 2 }); $h and push @row, [ $csv->header ($fh) ]; while (my $row = $csv->getline ($fh)) { push @row, $row } close $fh; 1; }; is_deeply (\@row, [[qw(foo bar baz)],[qw(a xxx 1)]], "2 valid rows"); like ($@, qr '^# CSV_XS ERROR: 2023 -', "3rd row dies error 2023"); } } else { ok (1, "Test skipped in this version of perl") for 1..4; } 1; Text-CSV_XS-1.41/t/76_magic.t0000644000031300001440000000611513352200375016152 0ustar00merijnusers00000000000000#!/usr/bin/perl use strict; use warnings; #use Test::More "no_plan"; use Test::More tests => 44; 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; $csv->eol (undef); ok ($csv->combine ("us", undef, 3), "Combine with undef"); is ($csv->string, "us,,3", "Default"); foreach my $us ("\\N", 1, ",,,", "", "\xe2\x80\xa2", "\x{2205}") { ok (defined ($csv->undef_str ($us)),"Set undef_str with method"); ok ($csv->combine ("us", undef, 3), "Combine with undef"); is ($csv->string, "us,$us,3", "String after method"); } tie my $us, "Bar"; $us = "NULL"; ok ($csv->undef_str ($us), "Set undef_str from tied scalar"); ok ($csv->combine ("us", undef, 3), "Combine with undef"); is ($csv->string, "us,NULL,3", "String after method"); $us = "\\N"; ok ($csv->undef_str ($us), "Set undef_str from tied scalar"); ok ($csv->combine ("us", undef, 3), "Combine with undef"); is ($csv->string, "us,\\N,3", "String after method"); $us = undef; is ($csv->undef_str ($us), undef, "Set undef_str from tied scalar"); ok ($csv->combine ("us", undef, 3), "Combine with undef"); is ($csv->string, "us,,3", "String after method"); untie $us; $csv = Text::CSV_XS->new ({ undef_str => "\\N" }); ok ($csv->combine ("us", undef, 3), "Combine with undef"); is ($csv->string, "us,\\N,3", "String after undef_str from constructor"); { 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.41/t/41_null.t0000644000031300001440000000376012753265123016045 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.41/t/91_csv_cb.t0000644000031300001440000001671413333023600016325 0ustar00merijnusers00000000000000#!/usr/bin/perl use strict; use warnings; #use Test::More "no_plan"; use Test::More tests => 58; 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 my $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"); SKIP: { $] < 5.008001 and skip "No BOM support in $]", 1; is_deeply (csv (in => $tfn, munge => { bar => "boo" }), [{ baz => 3, boo => 2, foo => 1 }, { baz => "", boo => "a b", foo => 2 }], "Munge with hash"); } 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"); } SKIP: { $] < 5.008001 and skip "Too complicated test for $]", 2; # Add to %_ in callback # And test bizarre (but allowed) attribute combinations # Most of them can be either left out or done more efficiently in # a different way my $xcsv = Text::CSV_XS->new; is_deeply (csv (in => $tfn, seps => [ ",", ";" ], munge => "uc", quo => '"', esc => '"', csv => $xcsv, 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"); is_deeply ($xcsv->csv ( file => $tfn, sep_set => [ ";", "," ], munge_column_names => "uc", quote_char => '"', quote => '"', escape_char => '"', escape => '"', filter => { 1 => sub { $_ eq "4" }}, after_in => sub { $_{BRT} = 42; }), [{ FOO => 4, BAR => 5, BAZ => 6, BRT => 42 }], "AOH with addition to %_ in on_in"); } { ok (my $hr = csv (in => $tfn, key => "foo", on_in => sub { $_[1]{quz} = "B"; $_{ziq} = 2; }), "Get into hashref with key and on_in"); is_deeply ($hr->{8}, {qw( bar 13 baz 18 foo 8 quz B ziq 2 )}, "on_in with key works"); } 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"); is_deeply (csv (in => $tfn, filter => sub { grep { defined && m/\S/ } @{$_[1]} }), [[3,3,3],[5,7,9],[8,13,18]], "filter => filled"); # Count rows in different ways open $fh, ">", $tfn or die "$tfn: $!"; print $fh <<"EOD"; foo,bar,baz 1,,3 0,"d €",4 999,999, EOD close $fh; { my $n = 0; open my $fh, "<", $tfn; my $csv = Text::CSV_XS->new ({ binary => 1 }); while (my $row = $csv->getline ($fh)) { $n++; } close $fh; is ($n, 4, "Count rows with getline"); } { my $n = 0; my $aoa = csv (in => $tfn, on_in => sub { $n++ }); is ($n, 4, "Count rows with on_in"); } { my $n = 0; my $aoa = csv (in => $tfn, filter => { 0 => sub { $n++; 0; }}); is ($n, 4, "Count rows with filter hash"); } { my $n = 0; my $aoa = csv (in => $tfn, filter => sub { $n++; 0; }); is ($n, 4, "Count rows with filter sub"); } { my $n = 0; csv (in => $tfn, on_in => sub { $n++; 0; }, out => \"skip"); is ($n, 4, "Count rows with on_in and skipped out"); } Text-CSV_XS-1.41/t/46_eol_si.t0000644000031300001440000001563513120001746016342 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 => 562; } } 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$/", "content with eol \$/"); $foo = ""; $csv->eol (undef); open $fh, ">", \$foo or die "IO: $!\n"; ok ($csv->say ($fh, [ 1, 2 ]), "say"); close $fh; $foo = ""; $csv->eol (""); open $fh, ">", \$foo or die "IO: $!\n"; ok ($csv->say ($fh, [ 1, 2 ]), "say"); close $fh; is ($foo, "1,2$/", "content with eol \$/"); $foo = ""; $csv->eol ("#"); open $fh, ">", \$foo or die "IO: $!\n"; ok ($csv->say ($fh, [ 1, 2 ]), "say"); close $fh; is ($foo, "1,2#", "content with eol #"); $foo = ""; $csv->eol ("0"); open $fh, ">", \$foo or die "IO: $!\n"; ok ($csv->say ($fh, [ 1, 2 ]), "say"); close $fh; is ($foo, "1,20", "content with eol 0"); } { ok (my $csv = Text::CSV_XS->new, "new for say"); my $foo; my $dta = "x"; ok ($csv->bind_columns (\$dta), "bind columns"); local $\ = undef; local $/ = "\n"; open my $fh, ">", \$foo or die "IO: $!\n"; ok ($csv->print ($fh, undef), "print"); close $fh; is ($foo, "x", "print, no newline"); $foo = ""; open $fh, ">", \$foo or die "IO: $!\n"; ok ($csv->say ($fh, undef), "say"); close $fh; is ($foo, "x\n", "say, with newline"); } 1; Text-CSV_XS-1.41/t/81_subclass.t0000644000031300001440000000114512753265123016711 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.41/t/55_combi.t0000644000031300001440000001133613121517151016156 0ustar00merijnusers00000000000000#!/usr/bin/perl use strict; use warnings; use Test::More tests => 25119; 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"); } { ok (my $csv = Text::CSV_XS->new ({ binary => 1 }), "New CSV default"); ok ($csv->combine ("=\x00="), "combine =\\x00="); is ($csv->string, qq{"="0="}, "string"); } { ok (my $csv = Text::CSV_XS->new ({ binary => 1, escape_null => 0 }), "New CSV no escape_null"); ok ($csv->combine ("=\x00="), "combine =\\x00="); is ($csv->string, qq{"=\0="}, "string"); } { ok (my $csv = Text::CSV_XS->new ({ binary => 1, escape_char => "" }), "New CSV no escape"); ok ($csv->combine ("=\x00="), "combine =\\x00="); is ($csv->string, qq{"=\0="}, "string"); } { ok (my $csv = Text::CSV_XS->new ({ binary => 1, escape_char => "", escape_null => 0 }), "New CSV no escape no escape_null"); ok ($csv->combine ("=\x00="), "combine =\\x00="); is ($csv->string, qq{"=\0="}, "string"); } 1; Text-CSV_XS-1.41/t/78_fragment.t0000644000031300001440000000750613120001746016676 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 => 38; } } 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->column_names (undef); foreach my $spec ("col=1;3=2", "col=1,3-2", "col=-3", "col=0", "col=2--5", "col=0-2", "col=2-0", "col=2;;3") { open my $io, "<", \$data or die "IO: $!\n"; my $ref = eval { $csv->fragment ($io, "col=2;3=2"); }; is ($ref, undef, "Bad fragment spec"); is (0 + $csv->error_diag, 2013, "Error in spec"); } #$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.41/t/15_flags.t0000644000031300001440000002747612753265123016202 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.41/t/40_misc.t0000644000031300001440000000325313056007767016027 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.41/t/77_getall.t0000644000031300001440000000403713056007767016357 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.41/t/50_utf8.t0000644000031300001440000001057113056007767015764 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.41/t/60_samples.t0000644000031300001440000000141612753265123016534 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.41/t/66_formula.t0000644000031300001440000001323013532703670016540 0ustar00merijnusers00000000000000#!/usr/bin/perl use strict; use warnings; use Test::More tests => 119; BEGIN { use_ok "Text::CSV_XS", (); plan skip_all => "Cannot load Text::CSV_XS" if $@; } my $tfn = "_66test.csv"; END { -f $tfn and unlink $tfn; } ok (my $csv = Text::CSV_XS->new, "new"); is ($csv->formula, "none", "default"); is ($csv->formula (1), "die", "die"); is ($csv->formula ("die"), "die", "die"); is ($csv->formula (2), "croak", "croak"); is ($csv->formula ("croak"), "croak", "croak"); is ($csv->formula (3), "diag", "diag"); is ($csv->formula ("diag"), "diag", "diag"); is ($csv->formula (4), "empty", "empty"); is ($csv->formula ("empty"), "empty", "empty"); is ($csv->formula (""), "empty", "explicit empty"); is ($csv->formula (5), "undef", "undef"); is ($csv->formula ("undef"), "undef", "undef"); is ($csv->formula (undef), "undef", "explicit undef"); is ($csv->formula (sub { }), "cb", "callback"); is ($csv->formula (0), "none", "none"); is ($csv->formula ("none"), "none", "none"); is ($csv->formula_handling, "none", "default"); is ($csv->formula_handling ("DIE"), "die", "die"); is ($csv->formula_handling ("CROAK"), "croak", "croak"); is ($csv->formula_handling ("DIAG"), "diag", "diag"); is ($csv->formula_handling ("EMPTY"), "empty", "empty"); is ($csv->formula_handling ("UNDEF"), "undef", "undef"); is ($csv->formula_handling ("NONE"), "none", "none"); foreach my $f (-1, 9, "xxx", "DIAX", [], {}) { eval { $csv->formula ($f); }; like ($@, qr/\bformula-handling '\Q$f\E' is not supported/, "$f in invalid"); } my %f = qw( 0 none none none 1 die die die 2 croak croak croak 3 diag diag diag 4 empty empty empty 5 undef undef undef ); foreach my $f (sort keys %f) { ok (my $p = Text::CSV_XS->new ({ formula => $f }), "new with $f"); is ($p->formula, $f{$f}, "Set to $f{$f}"); } eval { Text::CSV_XS->new ({ formula => "xxx" }); }; like ($@, qr/\bformula-handling 'xxx' is not supported/, "xxx is invalid"); # TODO : $csv->formula (sub { 42; }); # Parser my @data = split m/\n/ => <<"EOC"; a,b,c 1,2,3 =1+2,3,4 1,=2+3,4 1,2,=3+4 EOC sub parse { my $f = shift; my @d; ok (my $csv = Text::CSV_XS->new ({ formula => $f }), "new $f"); #diag ("Formula: ". $csv->formula); for (@data) { $csv->parse ($_); push @d, [ $csv->fields ]; } \@d; } # parse is_deeply (parse (0), [ [ "a", "b", "c", ], [ "1", "2", "3", ], [ "=1+2", "3", "4", ], [ "1", "=2+3", "4", ], [ "1", "2", "=3+4", ], ], "Default"); my $r = eval { parse (1) }; is ($r, undef, "Die on formulas"); is ($@, "Formulas are forbidden\n", "Message"); $@ = undef; $r = eval { parse (2) }; is ($r, undef, "Croak on formulas"); is ($@, "Formulas are forbidden\n", "Message"); $@ = undef; my @m; local $SIG{__WARN__} = sub { push @m, @_ }; is_deeply (parse (3), [ [ "a", "b", "c", ], [ "1", "2", "3", ], [ "=1+2", "3", "4", ], [ "1", "=2+3", "4", ], [ "1", "2", "=3+4", ], ], "Default"); is ($@, undef, "Legal with warnings"); is_deeply (\@m, [ "Field 1 in record 3 contains formula '=1+2'\n", "Field 2 in record 4 contains formula '=2+3'\n", "Field 3 in record 5 contains formula '=3+4'\n", ], "Warnings"); @m = (); is_deeply (parse (4), [ [ "a", "b", "c", ], [ "1", "2", "3", ], [ "", "3", "4", ], [ "1", "", "4", ], [ "1", "2", "", ], ], "Empty"); is_deeply (parse (5), [ [ "a", "b", "c", ], [ "1", "2", "3", ], [ undef, "3", "4", ], [ "1", undef, "4", ], [ "1", "2", undef, ], ], "Undef"); for ([ "Callback return", sub { 42; } ], [ "Callback assign", sub { $_ = 42; } ], [ "Callback subst", sub { s/.*/42/; $_ } ], # s///r requires 5.13.2 ) { my ($msg, $cb) = @$_; is_deeply (parse ($cb), [ [ "a", "b", "c", ], [ "1", "2", "3", ], [ "42", "3", "4", ], [ "1", "42", "4", ], [ "1", "2", "42", ], ], $msg); } is_deeply (parse (sub { eval { s{^=([-+*/0-9()]+)$}{$1}ee }; $_ }), [ [ "a", "b", "c", ], [ "1", "2", "3", ], [ "3", "3", "4", ], [ "1", "5", "4", ], [ "1", "2", "7", ], ], "Callback calculations"); { @m = (); ok (my $csv = Text::CSV_XS->new ({ formula => 3 }), "new 3 hr"); ok ($csv->column_names ("code", "value", "desc"), "Set column names"); ok ($csv->parse ("1,=2+3,4"), "Parse"); is_deeply (\@m, [ qq{Field 2 (column: 'value') contains formula '=2+3'\n} ], "Warning for HR"); } # Writer sub writer { my $f = shift; ok (my $csv = Text::CSV_XS->new ({ formula_handling => $f, quote_empty => 1 }), "new $f"); ok ($csv->combine ("1", "=2+3", "4"), "combine $f"); $csv->string; } # writer @m = (); is ( writer (0), q{1,=2+3,4}, "Out 0"); is (eval { writer (1) }, undef, "Out 1"); is (eval { writer (2) }, undef, "Out 2"); is ( writer (3), q{1,=2+3,4}, "Out 3"); is ( writer (4), q{1,"",4}, "Out 4"); is ( writer (5), q{1,,4}, "Out 5"); is_deeply (\@m, [ "Field 1 contains formula '=2+3'\n" ], "Warning 3"); @m = (); is ( writer ("none"), q{1,=2+3,4}, "Out none"); is (eval { writer ("die") }, undef, "Out die"); is (eval { writer ("croak") }, undef, "Out croak"); is ( writer ("diag"), q{1,=2+3,4}, "Out diag"); is ( writer ("empty"), q{1,"",4}, "Out empty"); is ( writer ("undef"), q{1,,4}, "Out undef"); is_deeply (\@m, [ "Field 1 contains formula '=2+3'\n" ], "Warning diag"); open my $fh, ">", $tfn; printf $fh <<"EOC"; 1,2,3 =1+2,3,4 1,=12-6,5 1,2,=4+(9-1)/2 EOC close $fh; is_deeply (Text::CSV_XS::csv (in => $tfn, formula => sub { eval { s{^=([-+*/0-9()]+)$}{$1}ee }; $_ }), [[1,2,3],[3,3,4],[1,6,5],[1,2,8]], "Formula calc from csv function"); Text-CSV_XS-1.41/t/79_callbacks.t0000644000031300001440000001242713120001746017011 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.41/t/85_util.t0000644000031300001440000002550713504105271016053 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 = 1446; $pu and $n -= 120; plan tests => $n; } use_ok "Text::CSV_XS", "csv"; # Encode up to and including 2.01 have an error in a regex: # False [] range "\s-" in regex; marked by <-- HERE in m/\bkoi8[\s- <-- HERE _]*([ru])$/ # in Encode::Alias. This however does not influence this test, as then *all* encodings # are skipped as unsupported 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"); } { open my $fh, "<", \$data; is_deeply (csv (in => $fh, set_column_names => 0), [[ "bar", "foo" ], [ 1, 2 ], [ 3, 4, 5 ]], "use header () from csv () with $sep to ARRAY not setting column names"); } { open my $fh, "<", \$data; is_deeply (csv (in => $fh, set_column_names => 0, munge => "none"), [[ "bAr", "foo" ], [ 1, 2 ], [ 3, 4, 5 ]], "use header () from csv () with $sep to ARRAY not setting column names not lc"); } } 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", detect_bom => 0 }), "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; } } foreach my $ss ("", "bad", sub { 1; }, \*STDOUT, +{}) { my $dta = "a,b\n1,2\n"; open my $fh, "<", \$dta; my @hdr = eval { $csv->header ($fh, { sep_set => $ss }) }; is (scalar @hdr, 0, "No header on invalid sep_set"); is (0 + $csv->error_diag, 1500, "Error code"); } foreach my $dta ("", "\xfe\xff", "\xf7\x64\x4c", "\xdd\x73\x66\x73", "\x0e\xfe\xff", "\xfb\xee\x28", "\x84\x31\x95\x33") { open my $fh, "<", \$dta; my @hdr = eval { $csv->header ($fh) }; is (scalar @hdr, 0, "No header on empty stream"); is (0 + $csv->error_diag, 1010, "Error code"); } my $n; for ([ undef, "_bar" ], [ "lc", "_bar" ], [ "uc", "_BAR" ], [ "none", "_bAr" ], [ sub { "column_".$n++ }, "column_0" ], [ "db", "bar" ]) { 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; } foreach my $irs ("\n", "\xaa") { local $/ = $irs; foreach my $eol ("\n", "\r\n", "\r") { my $str = join $eol => qq{zoo,b\x{00e5}r}, qq{1,"1 \x{20ac} each"}, ""; 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" ], # Below 5 not (yet) supported by Encode [ "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" ], # [ "UTF-8" => "\x{feff}" ], ) { my ($enc, $bom) = @$_; my $has_enc = 0; eval { no warnings "utf8"; 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; }; $csv = Text::CSV_XS->new ({ binary => 1, auto_diag => 9 }); SKIP: { $has_enc or skip "Encoding $enc not supported", $enc =~ m/^utf/ ? 10 : 9; $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"); $enc =~ m/^utf/ and is ($csv->{ENCODING}, uc $enc, "Encoding inquirable"); 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; my $aoh; ok ($aoh = csv (in => $fnm, bom => 1), "csv (bom => 1)"); is_deeply ($aoh, [{ zoo => 1, "b\x{00e5}r" => "1 \x{20ac} each" }], "Returned data"); ok ($aoh = csv (in => $fnm, encoding => "auto"), "csv (encoding => auto)"); is_deeply ($aoh, [{ zoo => 1, "b\x{00e5}r" => "1 \x{20ac} each" }], "Returned data"); } SKIP: { $has_enc or skip "Encoding $enc not supported", 7; $csv->column_names (undef); open my $fh, "<", $fnm; $enc eq "none" or binmode $fh, ":encoding($enc)"; 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.41/t/20_file.t0000644000031300001440000001024213056007767016005 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.41/t/21_lexicalio.t0000644000031300001440000001030513056007767017040 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.41/t/30_types.t0000644000031300001440000000324612753265123016234 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.41/t/70_rt.t0000644000031300001440000007156113172132435015521 0ustar00merijnusers00000000000000#!/usr/bin/perl use strict; use warnings; #use Test::More "no_plan"; use Test::More tests => 20469; 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 SKIP: { $] < 5.006002 and skip "unreliable in perl $]", 2; 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"); } } { # http://rt.cpan.org/Ticket/Display.html?id=120655 $rt = 120655; # bind_columns with strange behavior / length() from old value SKIP: { $] < 5.008002 and skip "UTF8 unreliable in perl $]", 5; my $csv = Text::CSV_XS->new ({ binary => 1 }); my %row; ok ($csv->bind_columns (\$row{c1}), "Bind columns"); ok ($csv->parse ("pr\x{c3}\x{b6}blem"), "Parse utf-8 content"); is (length $row{c1}, 7, "Length"); ok ($csv->parse (""), "Parse empty line"); is (length $row{c1}, 0, "Length"); } } { # http://rt.cpan.org/Ticket/Display.html?id=123320 $rt = 123320; # ext::CSV_XS bug w/Mac format files SKIP: { $] < 5.008001 and skip "unreliable in perl $]", 4; open my $fh, ">", $tfn or die "$tfn: $!\n"; print $fh join "\r" => q{col1,col2,col3,}, q{"One","","Three"}, q{"Four","Five and a half","Six"}, q{}; close $fh; ok (my $csv = Text::CSV_XS->new ({ auto_diag => 1, eol => "\r", }), "new"); my @msg; local $SIG{__WARN__} = sub { push @msg, @_; }; open $fh, "<", $tfn or die "$!\n"; my @hdr = eval { $csv->header ($fh); }; is (scalar @hdr, 0, "Empty field in header"); is (($csv->error_diag)[0], 1012, "error 1012"); close $fh; open $fh, ">", $tfn or die "$tfn: $!\n"; print $fh join "\r" => q{col1,col2,col3}, q{"One","Two","Three"}, ""; close $fh; open $fh, "<", $tfn or die "$!\n"; @hdr = eval { $csv->header ($fh); }; is_deeply (\@hdr, [qw( col1 col2 col3 )], "Header is ok"); close $fh; } } __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" 120655 - bind_columns with strange behavior / length() from old value 123320 - ext::CSV_XS bug w/Mac format files Text-CSV_XS-1.41/t/90_csv.t0000644000031300001440000003117113442476662015677 0ustar00merijnusers00000000000000#!/usr/bin/perl use strict; use warnings; use Config; #use Test::More "no_plan"; use Test::More tests => 105; 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) { my @hdr; ok (my $ref = csv (in => $tfn, bom => 1), "csv (-- not keeping header)"); is_deeply (\@hdr, [], "Should still be empty"); foreach my $alias (qw( keep_headers keep_column_names kh )) { @hdr = (); ok (my $ref = csv (in => $tfn, bom => 1, $alias => \@hdr), "csv ($alias => ...)"); is_deeply (\@hdr, [qw( foo bar baz )], "Headers kept for $alias"); } foreach my $alias (qw( keep_headers keep_column_names kh )) { @hdr = (); ok (my $ref = csv (in => $tfn, $alias => \@hdr), "csv ($alias => ... -- implied headers)"); is_deeply (\@hdr, [qw( foo bar baz )], "Headers kept for $alias"); } } else { ok (1, q{This perl cannot do scalar IO}) for 1..14; } 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"); if ($Config{usecperl} && $Config{usecperl} eq "define") { ok (1, "cperl has a different view on stable sorting of hash keys"); ok (1, "not doing this (silly) test"); } else { 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, file => $tfn), "out via file 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 $]", 4; # Simple key 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"); # Combined key is_deeply (csv (in => \"a,b,value\n1,1,2\n", key => [ ":" => "a", "b" ]), { "1:1" => { a => 1, b => 1, value => 2 }}, "key list"); is_deeply (csv (in => \"2,3,2\n", key => [ ":" => "a", "b" ], headers => [qw( a b value )]), { "2:3" => { a => 2, b => 3, value => 2 }}, "key list"); } # Basic "value" checks SKIP: { $] < 5.008001 and skip "No ScalarIO support for 'value's in $]", 5; # Simple key simple value is_deeply (csv (in => \"key,value\n1,2\n", key => "key", value => "value"), { 1 => 2 }, "key:value"); is_deeply (csv (in => \"1,2\n", key => "key", headers => [qw( key value )], value => "value"), { 1 => 2 }, "key:value"); # Simple key combined value is_deeply (csv (in => \"key,v1,v2\n1,2,3\n", key => "key", value => [ "v1", "v2" ]), { 1 => { v1 => 2, v2 => 3 }}, "key:value"); # Combined key simple value is_deeply (csv (in => \"a,b,value\n1,1,2\n", key => [ ":" => "a", "b" ], value => "value"), { "1:1" => 2 }, "[key]:value"); # Combined key combined value is_deeply (csv (in => \"a,b,v1,v2\n1,1,2,2\n", key => [ ":" => "a", "b" ], value => [ "v1", "v2" ]), { "1:1" => { v1 => 2, v2 => 2 }}, "[key]:[value]"); } # 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"; my $dta = do {local $/; <$fh>}; my @layers = eval { PerlIO::get_layers ($fh); }; close $fh; grep m/crlf/ => @layers and $dta =~ s/\n/\r\n/g; is ($dta, "a\r\n1\r\n" x 5, "AoH to out"); } # 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.008004 ? (encoding => "utf-8") : ())); } $] < 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"); $err = ""; $r = eval { csv (in => $tfn, key => [ ":" ], auto_diag => 0); }; $err =~ s{\s+at\s+\S+\s+line\s+\d+\.\r?\n?\Z}{}; is ($r, undef, "Fail call with key with not enough fields"); like ($err, qr{PRM.*unsupported type}, $err); $err = ""; $r = eval { csv (in => $tfn, key => { "fx" => 1 }, auto_diag => 0); }; $err =~ s{\s+at\s+\S+\s+line\s+\d+\.\r?\n?\Z}{}; is ($r, undef, "Fail call with unsupported key type"); like ($err, qr{PRM.*unsupported type}, $err); $err = ""; $r = eval { csv (in => $tfn, key => sub { "foo" }, auto_diag => 0); }; $err =~ s{\s+at\s+\S+\s+line\s+\d+\.\r?\n?\Z}{}; is ($r, undef, "Fail call with bad unsupported type"); like ($err, qr{PRM.*unsupported type}, $err); $err = ""; $r = eval { csv (in => $tfn, key => "xyz", auto_diag => 0); }; $err =~ s{\s+at\s+\S+\s+line\s+\d+\.\r?\n?\Z}{}; is ($r, undef, "Fail call with nonexisting key"); like ($err, qr{PRM.*xyz}, $err); $err = ""; $r = eval { csv (in => $tfn, key => [ "x" ], auto_diag => 0); }; $err =~ s{\s+at\s+\S+\s+line\s+\d+\.\r?\n?\Z}{}; is ($r, undef, "Fail call with no key in keylist"); like ($err, qr{PRM.*unsupported type}, $err); $err = ""; $r = eval { csv (in => $tfn, key => [ ":", "a", "xyz" ], auto_diag => 0); }; $err =~ s{\s+at\s+\S+\s+line\s+\d+\.\r?\n?\Z}{}; is ($r, undef, "Fail call with nonexisting key in keylist"); like ($err, qr{PRM.*xyz}, $err); $err = ""; local $SIG{__DIE__} = sub { $err = shift; }; foreach my $hr (1, "foo", \my %hr, sub { 42; }, *STDOUT) { $r = eval { csv (in => $tfn, kh => $hr, auto_diag => 0); }; $err =~ s{\s+at\s+\S+\s+line\s+\d+\.\r?\n?\Z}{}; is ($r, undef, "Fail call with bad keep_header type"); like ($err, qr{PRM.*unsupported type}, $err); $err = ""; } # $r = eval { csv (in => +{}, auto_diag => 0); }; # is ($r, undef, "Cannot read from hashref"); # like ($err, qr{No such file}i, "No such file or directory"); # undef $err; $r = eval { csv (in => undef, auto_diag => 0); }; $err =~ s{\s+at\s+\S+\s+line\s+\d+\.\r?\n?\Z}{}; is ($r, undef, "Cannot read from undef"); like ($err, qr{^usage}, "Remind them of correct syntax"); $err = ""; $r = eval { csv (in => "", auto_diag => 0); }; $err =~ s{\s+at\s+\S+\s+line\s+\d+\.\r?\n?\Z}{}; is ($r, undef, "Cannot read from empty"); like ($err, qr{^usage}, "Remind them of correct syntax"); $err = ""; my $fn = "./dev/foo/bar/\x99\x99/\x88\x88/". (join "\x99" => map { chr (128 + int rand 128) } 0..100).".csv"; $r = eval { csv (in => $fn, auto_diag => 0); }; $err =~ s{\s+at\s+\S+\s+line\s+\d+\.\r?\n?\Z}{}; is ($r, undef, "Cannot read from impossible file"); like ($err, qr{/foo/bar}, "No such file or directory"); $err = ""; $r = eval { csv (in => [[1,2]], out => $fn, auto_diag => 0); }; $err =~ s{\s+at\s+\S+\s+line\s+\d+\.\r?\n?\Z}{}; is ($r, undef, "Cannot write to impossible file"); like ($err, qr{/foo/bar}, "No such file or directory"); $err = ""; my %x; $r = eval { csv (in => $tfn, out => \%x, auto_diag => 0); }; $err =~ s{\s+at\s+\S+\s+line\s+\d+\.\r?\n?\Z}{}; is ($r, undef, "Cannot write to hashref"); like ($err, qr{Not a GLOB}i, "Not a GLOB"); $err = ""; $r = eval { csv (); }; $err =~ s{\s+at\s+\S+\s+line\s+\d+\.\r?\n?\Z}{}; is ($r, undef, "Needs arguments"); like ($err, qr{^usage}i, "Don't know what to do"); $err = ""; $r = eval { csv (in => "in.csv", out => "out.csv"); }; $err =~ s{\s+at\s+\S+\s+line\s+\d+\.\r?\n?\Z}{}; is ($r, undef, "Cannot use strings for both"); like ($err, qr{^cannot}i, "Explicitely unsupported"); $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; }, eol => "\n"); close STDOUT; my $dta = do { local (@ARGV, $/) = $ofn; <> }; is ($dta, qq{"a"\n"1"\n}, "Chained csv call inherited attributes"); unlink $ofn; open STDOUT, ">", $ofn; csv (in => [[1,2]], out => *STDOUT, eol => "\n"); close STDOUT; $dta = do { local (@ARGV, $/) = $ofn; <> }; is ($dta, qq{1,2\n}, "out to *STDOUT"); unlink $ofn; open STDOUT, ">", $ofn; csv (in => [[1,2]], out => \*STDOUT, eol => "\n"); close STDOUT; $dta = do { local (@ARGV, $/) = $ofn; <> }; is ($dta, qq{1,2\n}, "out to \\*STDOUT"); unlink $ofn; SKIP: { $] <= 5.008003 and skip qq{$] does not support ">:crlf"}, 1; open STDOUT, ">", $ofn; binmode STDOUT, ":crlf"; csv (in => [[1,2]], out => \*STDOUT); close STDOUT; open my $oh, "<", $ofn or die "$ofn: $!\n"; binmode $oh; $dta = do { local $/; <$oh> }; is ($dta, qq{1,2\r\n}, "out to \\*STDOUT"); unlink $ofn; } } Text-CSV_XS-1.41/t/45_eol.t0000644000031300001440000002202413056007767015655 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.41/t/util.pl0000644000031300001440000000075112753265123015711 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.41/t/22_scalario.t0000644000031300001440000001416713056007767016677 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.41/t/10_base.t0000644000031300001440000000774512753265123016010 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.41/t/65_allow.t0000644000031300001440000003254313333023600016203 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"); } my $fh; 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 $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.41/t/75_hashref.t0000644000031300001440000001534213017576236016525 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; Text-CSV_XS-1.41/t/51_utf8.t0000644000031300001440000001733513316623612015762 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 + 10; } 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"); } # Tests pulled from tests in perl6 { my $csv = Text::CSV_XS->new ({ binary => 1, auto_diag => 1 }); my $h = pack "C*", 224, 34, 204, 182; ok ($csv->combine (1, $h, 3)); ok (my $s = $csv->string, "String"); my $b = $h; utf8::encode ($b); ok ($csv->combine (1, $b, 3)); ok ($s = $csv->string, "String"); } { my $h = qq{\x{10fffd}xE0"}; #" my $b = $h; ok ($csv->combine (1, $b, 3)); ok (my $s = $csv->string, "String"); $b = $h; utf8::encode ($b); ok ($csv->combine (1, $b, 3)); ok ($s = $csv->string, "String"); $b = $h; utf8::encode ($b); ok ($csv->combine (1, $b, 3)); ok ($s = $csv->string, "String"); } Text-CSV_XS-1.41/cpanfile0000644000031300001440000000046313622243127015634 0ustar00merijnusers00000000000000requires "IO::Handle"; requires "XSLoader"; recommends "Encode" => "3.02"; on "configure" => sub { requires "ExtUtils::MakeMaker"; }; on "build" => sub { requires "Config"; }; on "test" => sub { requires "Test::More"; requires "Tie::Scalar"; }; Text-CSV_XS-1.41/examples/0000755000031300001440000000000013622243127015743 5ustar00merijnusers00000000000000Text-CSV_XS-1.41/examples/csv-check0000755000031300001440000001407613614552212017546 0ustar00merijnusers00000000000000#!/pro/bin/perl # csv-check: Check validity of CSV file and report # (m)'20 [30 Jan 2020] Copyright H.M.Brand 2007-2020 # This code requires the defined-or feature and PerlIO use 5.12.0; use warnings; use Data::Peek; use Encode qw( decode ); our $VERSION = "2.02"; # 2020-01-30 my $cmd = $0; $cmd =~ s{.*/}{}; sub usage { my $err = shift and select STDERR; print <<"EOU"; usage: $cmd [-s ] [-q ] [-e ] [-u] [--pp] [file.csv] -s S --sep=S use S as seperator char. Auto-detect, default = ',' the string "tab" is allowed. -q Q --quo=Q use Q as quote char. Auto-detect, default = '"' the string "undef" will disable quotation. -e E --esc=E use E as escape char. Auto-detect, default = '"' the string "undef" will disable escapes. -N --nl force EOL to \\n -C --cr force EOL to \\r -M --crnl force EOL to \\r\\n -u --utf-8 check if all fields are valid unicode -E E --enc=E open file with encoding E -h --hdr check with header (implies BOM) -b --bom check with BOM (no header) -f --skip-formula do not check formula's --pp use Text::CSV_PP instead (cross-check) EOU exit $err; } # usage use Getopt::Long qw(:config bundling); my $eol; GetOptions ( "help|?" => sub { usage (0); }, "V|version" => sub { print "$cmd [$VERSION]\n"; exit 0; }, "c|s|sep=s" => \(my $sep = ""), "q|quo|quote=s" => \(my $quo = '"'), "e|esc|escape=s" => \(my $esc = '"'), "N|nl!" => sub { $eol = "\n"; }, "C|cr!" => sub { $eol = "\r"; }, "M|crnl!" => sub { $eol = "\r\n"; }, "B|binary!" => \(my $bin = 1), "u|utf|utf8|utf-8!" => \(my $opt_u = 0), "E|enc|encoding=s" => \(my $enc), "h|hdr|header!" => \(my $opt_h = 0), "b|bom!" => \(my $opt_b = 0), "f|skip-formula!" => \(my $opt_f = 0), "pp!" => \(my $opt_p = 0), "v|verbose:1" => \(my $opt_v = 0), ) 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 (); binmode STDERR, ":encoding(utf-8)"; my $fn = $ARGV[0] // "-"; my $data = do { local $/; <> } or die "No data to analyze\n"; my @warn; my %csvarg = ( sep_char => $sep eq "tab" ? "\t" : $sep, quote_char => $quo eq "undef" ? undef : $quo, escape_char => $esc eq "undef" ? undef : $esc, eol => $eol, binary => $bin, keep_meta_info => 1, auto_diag => 1, formula => $opt_f ? "none" : "diag", ); my ($rows, %cols, $s_eol) = (0); unless ($sep) { # No sep char passed, try to auto-detect; my ($first_line) = ($data =~ m/\A(.*?)(?:\r\n|\n|\r)/); $first_line ||= $data; # if no EOL at all, use whole set $sep = $first_line =~ m/["\d],["\d,]/ ? "," : $first_line =~ m/["\d];["\d;]/ ? ";" : $first_line =~ m/["\d]\t["\d]/ ? "\t" : # If neither, then for unquoted strings $first_line =~ m/\w,[\w,]/ ? "," : $first_line =~ m/\w;[\w;]/ ? ";" : $first_line =~ m/\w\t[\w]/ ? "\t" : ","; $data =~ m/([\r\n]+)\Z/ and $s_eol = DDisplay "$1"; $csvarg{sep_char} = $sep; } my $csv = $csvmod->new (\%csvarg); $bin = 0; # Assume ASCII only sub done { my $file = $ARGV // "STDIN"; (my $pv = "$]0000000") =~ s{^([0-9]+)\.([0-9]{3})([0-9]{3})[0-9]*} {sprintf "%d.%d.%d",$1,$2,$3}e; my $uv = eval { no warnings; (my $cv = $]) =~ s/0+$//; eval { require Unicode::UCD; Unicode::UCD::UnicodeVersion () } || eval { require Module::CoreList; $Module::CoreList::version{$cv}{Unicode} }; } || "unknown"; print "Checked $file with $cmd $VERSION\nusing $csvmod @{[$csvmod->VERSION]} with perl $pv and Unicode $uv\n"; my @diag = $csv->error_diag; my $line = $. // $csv->record_number // "?"; if ($diag[0] == 2012 && $csv->eof) { my @coll = sort { $a <=> $b } keys %cols; local $" = ", "; my $cols = @coll == 1 ? $coll[0] : "(@coll)"; $s_eol //= $csv->eol || "--unknown--"; $s_eol =~ m/[\x00-\x1f]/ and $s_eol = DDisplay $s_eol; print "OK: rows: $rows, columns: $cols\n"; print " sep = <$sep>, quo = <$quo>, bin = <$bin>, eol = <$s_eol>\n"; print " encoding = $csv->{ENCODING}\n" if $csv->{ENCODING}; if (@coll > 1) { print "multiple column lengths:\n"; printf " %6d line%s with %4d field%s\n", $cols{$_}, $cols{$_} == 1 ? " " : "s", $_, $_ == 1 ? "" : "s" for @coll; } $diag[0] = 0; } elsif ($diag[2]) { print "$ARGV record $diag[3] at line $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 $line - $diag[1]\n"; } print for @warn; exit $diag[0]; } # done sub show { say STDERR join ", " => map { "\x{231e}$_\x{231d}" } @_; } # show sub stats { my $r = shift; $cols{scalar @$r}++; grep { $_ & 0x0002 } $csv->meta_info and $bin = 1; $opt_v and show (@$r); 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.*}{}; my @h = $csv->column_names; push @warn, sprintf "Field %d%s in record %d - '%s'\t- %s", $x + 1, @h ? " (column: '$h[$x]')" : "", $rows, DPeek ($r[$x]), $msg; }; my $oct = decode ("utf-8", $r[$x], Encode::FB_WARN); } } } # stats my $mode = $enc ? "<:encoding($enc)" : "<"; open my $fh, $mode, \$data or die "$fn: $!\n"; if ($opt_h) { $csv->header ($fh); } elsif ($opt_b) { my @hdr = $csv->header ($fh, { detect_bom => 1, set_column_names => 0 }); stats \@hdr; } local $SIG{__WARN__} = sub { push @warn, @_; }; while (my $row = $csv->getline ($fh)) { $rows++; stats $row; } done; Text-CSV_XS-1.41/examples/csv2xlsx0000755000031300001440000002026613614534534017501 0ustar00merijnusers00000000000000#!/pro/bin/perl # csv2xlsx: Convert csv to xlsx # (m)'19 [28 Nov 2019] Copyright H.M.Brand 2007-2020 use 5.14.0; use warnings; our $VERSION = "1.06"; sub usage { my $err = shift and select STDERR; print <<"EOU"; usage: csv2xlsx [-s ] [-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 --Fa=aaa Define formula action: die/croak/diag/empty/undef --Fd Formula's will cause a die --Fc Formula's will cause a croak --FD Formula's will cause a warning (this is the default) --Fe Formula's will be replaced by the empty string --Fu Formula's will be replaced with an undefined cell -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 $fac = "diag"; # Formula action (default is warn only) 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, "Fa=s" => \$fac, "Fd" => sub { $fac = "die"; }, "Fc" => sub { $fac = "croak"; }, "FD" => sub { $fac = "diag"; }, "Fe" => sub { $fac = "empty"; }, "Fu" => sub { $fac = "undef"; }, "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|png|jpe?g|bmp|gif|tiff|xpm)$/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 $sheetname = $csvf =~ s{\.\w+$}{}ir =~ s{.*/}{}r || "Sheet 1"; ($_ = length $sheetname) > 31 and substr $sheetname, 31, $_ - 31, ""; my $wks = $wbk->add_worksheet ($sheetname); if ($csvf =~ m/\.(png|jpe?g|bmp|gif|tiff|xpm)$/i) { $wks->insert_image (1, 1, $csvf); next; } 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; } $firstline or die "The sourcefile does not contain any usable data\n"; } 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, formula => $fac, }); 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; } $opt_v and say "Writing $xls"; $wbk->close (); Text-CSV_XS-1.41/examples/parser-xs.pl0000755000031300001440000000365613614534554020251 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-2020 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.41/examples/csv2xls0000755000031300001440000001643013614534531017304 0ustar00merijnusers00000000000000#!/pro/bin/perl # csv2xls: Convert csv to xls # (m)'19 [21 Oct 2019] Copyright H.M.Brand 2007-2020 use 5.12.0; use warnings; our $VERSION = "1.79"; sub usage { my $err = shift and select STDERR; print <<"EOU"; usage: csv2xls [-s ] [-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 --Fa=aaa Define formula action: die/croak/diag/empty/undef --Fd Formula's will cause a die --Fc Formula's will cause a croak --FD Formula's will cause a warning (this is the default) --Fe Formula's will be replaced by the empty string --Fu Formula's will be replaced with an undefined cell -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 $fac = "diag"; # Formula action (default is warn only) 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|sep=s" => \$sep, "q|quo=s" => \$quo, "e|esc=s" => \$esc, "w|width=i" => \$wdt, "o|x|out=s" => \$xls, "d|date-fmt=s" => \$dtf, "D|date-col=s" => \$dtc, "C|curr-fmt=s" => \$crf, "f|force!" => \$frc, "F|formulas!" => \$frm, "Fa=s" => \$fac, "Fd" => sub { $fac = "die"; }, "Fc" => sub { $fac = "croak"; }, "FD" => sub { $fac = "diag"; }, "Fe" => sub { $fac = "empty"; }, "Fu" => sub { $fac = "undef"; }, "u|utf-8!" => \$utf, "v|verbose: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 $snm = $title; $snm =~ s{\.csv$}{}i; $snm =~ s{.*/}{}; $snm ||= "Sheet 1"; ($_ = length $snm) > 31 and substr $snm, 31, $_ - 31, ""; my $wks = $wbk->add_worksheet ($snm); $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; } $firstline or die "The sourcefile does not contain any usable data\n"; } 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, formula => $fac, }); 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.41/examples/speed.pl0000755000031300001440000000517013614534566017421 0ustar00merijnusers00000000000000#!/usr/bin/perl -w # speed.pl: compare different versions of Text-CSV* modules # (m)'08 [07 Apr 2008] Copyright H.M.Brand 2007-2020 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.41/examples/csvdiff0000755000031300001440000001113213614534764017326 0ustar00merijnusers00000000000000#!/pro/bin/perl use strict; use warnings; # csvdiff: Show differences between CSV files # (m)'19 [05 Mar 2019] Copyright H.M.Brand 2009-2020 our $VERSION = "1.02 - 20190305"; sub usage { my $err = shift and select STDERR; print "usage: csvdiff [--no-color] [--html] [-w|-b|-Z] 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", " --no-color do not use colors\n", " -h --html produce HTML output\n", " -w --ignore-all-space ignore all whistespace is all fields\n", " -b --ignore-space-change ignore whitespace length changes\n", " -Z --ignore-trailing-space ignore trailing whitespace per field\n", " -o F --output=F send output to file F\n"; exit $err; } # usage use Getopt::Long qw(:config bundling nopermute ); my $opt_c = !$ENV{NO_COLOR}; GetOptions ( "help|?" => sub { usage (0); }, "V|version" => sub { print "csvdiff [$VERSION]\n"; exit 0 }, "w|ignore-all-space!" => \my $opt_w, "b|ignore-ws|ignore-space-change!" => \my $opt_b, "Z|ignore-trailing-space!" => \my $opt_Z, "c|color|colour!" => \ $opt_c, "h|html" => \my $opt_h, "o|output=s" => \my $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]++] or return; 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; } my @v0 = @r0; my @v1 = @r1; $opt_Z and s/[\r\n\s]+\z// for @v0, @v1; $opt_b and s/[\r\n\s]+/ /g for @v0, @v1; $opt_w and s/[\r\n\s]+//g for @v0, @v1; { local $" = "\xFF"; "@v0" eq "@v1" 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.41/examples/rewrite.pl0000755000031300001440000000377313614535105017777 0ustar00merijnusers00000000000000#!/pro/bin/perl use strict; use warnings; # rewrite.pl: Convert csv to csv # (m)'17 [20 Sep 2017] Copyright H.M.Brand 2014-2020 our $VERSION = "0.05 - 20170920"; sub usage { my $err = shift and select STDERR; print <<"EOH"; usage: $0 [-o file] [-s S] [-m] [-c] [-i] [file] -o F --out=F output to file F (default STDOUT) -s S --sep=S set input separator to S (default ; , TAB or |) -m --ms output Dutch style MicroSoft CSV (; and \\r\\n) -n --no-header CSV has no header line. If selected - default input sep = ; - BOM is not used/recognized -c --confuse Use confusing separation and quoting characters -i --invisible Use invisible separation and quotation sequences EOH 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, "n|no-header!" => \my $opt_n, "o|out=s" => \my $opt_o, ) 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)"; my @hdr; my @opt_i = (in => $io); my @opt_o = (out => \*STDOUT, eol => $eol, sep => $sep, quo => $quo); if ($opt_n) { push @opt_i, sep => $in_sep // ";"; } else { push @opt_i, bom => 1, sep_set => [ $in_sep ? $in_sep : (";", ",", "|", "\t") ], keep_headers => \@hdr; push @opt_o, headers => \@hdr; } csv (in => csv (@opt_i), @opt_o); __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.41/files/0000755000031300001440000000000013622243127015227 5ustar00merijnusers00000000000000Text-CSV_XS-1.41/files/utf8.csv0000644000031300001440000000001411021471761016623 0ustar00merijnusers00000000000000"Øl/Vin",0 Text-CSV_XS-1.41/files/macosx.csv0000644000031300001440000000164312753265122017245 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.41/README0000644000031300001440000000434113614534471015015 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-2020 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 https://github.com/Tux/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 ( 0.25 - 2007-05-07 ..) Jochen Wiedmann (.. 0.23 - 2001-10-10 ) Interface design by Alan Citterman A pure-perl version (L) is being maintained by Kenichi Ishigaki. This module was created by Makamaka Hannyaharamitu who maintained it up to 2015. It tries to follow Text::CSV_XS as closely as possible. 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::CSV_PP. Text-CSV_XS-1.41/CSV_XS.pm0000644000031300001440000041664613614750152015553 0ustar00merijnusers00000000000000package Text::CSV_XS; # Copyright (c) 2007-2020 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 XSLoader; use Carp; use vars qw( $VERSION @ISA @EXPORT_OK ); $VERSION = "1.41"; @ISA = qw( Exporter ); @EXPORT_OK = qw( csv ); XSLoader::load "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, strict => 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, formula => 0, undef_str => undef, types => undef, callbacks => undef, _EOF => "", _RECNO => 0, _STATUS => undef, _FIELDS => undef, _FFLAGS => undef, _STRING => undef, _ERROR_INPUT => undef, _COLUMN_NAMES => undef, _BOUND_COLUMNS => undef, _AHEAD => undef, _FORMULA_CB => undef, ENCODING => undef, ); my %attr_alias = ( quote_always => "always_quote", verbose_diag => "diag_verbose", quote_null => "escape_null", escape => "escape_char", ); my $last_new_err = Text::CSV_XS->SetDiag (0); # NOT a method: is also used before bless sub _unhealthy_whitespace { my ($self, $aw) = @_; $aw 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]/ and return 1002; defined $esc && $esc =~ m/^[ \t]/ and return 1002; return 0; } # _unhealty_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),"'"); # sep_char should not be undefined $sep ne "" or return 1008; length ($sep) > 16 and return 1006; $sep =~ m/[\r\n]/ and return 1003; if (defined $quo) { $quo eq $sep and return 1001; length ($quo) > 16 and return 1007; $quo =~ m/[\r\n]/ and return 1003; } if (defined $esc) { $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; } exists $attr{formula_handling} and $attr{formula} = delete $attr{formula_handling}; my $attr_formula = delete $attr{formula}; 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) { 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}); defined $attr_formula and $self->{formula} = _supported_formula ($self, $attr_formula); $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_ahead => 30, _has_hooks => 36, _is_bound => 26, # 26 .. 29 formula => 38, strict => 42, undef_str => 46, ); # 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; if (@_) { my $ec = shift; $self->_set_attr_C ("escape_char", $ec); $ec or $self->_set_attr_X ("escape_null", 0); } $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 strict { my $self = shift; @_ and $self->_set_attr_X ("strict", shift); $self->{strict}; } # always_quote sub _SetDiagInfo { my ($self, $err, $msg) = @_; $self->SetDiag ($err); my $em = $self->error_diag; $em =~ s/^\d+$// and $msg =~ s/^/# /; my $sep = $em =~ m/[;\n]$/ ? "\n\t" : ": "; join $sep => grep m/\S\S\S/ => $em, $msg; } # _SetDiagInfo sub _supported_formula { my ($self, $f) = @_; defined $f or return 5; if ($self && $f && ref $f && ref $f eq "CODE") { $self->{_FORMULA_CB} = $f; return 6; } $f =~ m/^(?: 0 | none )$/xi ? 0 : $f =~ m/^(?: 1 | die )$/xi ? 1 : $f =~ m/^(?: 2 | croak )$/xi ? 2 : $f =~ m/^(?: 3 | diag )$/xi ? 3 : $f =~ m/^(?: 4 | empty | )$/xi ? 4 : $f =~ m/^(?: 5 | undef )$/xi ? 5 : $f =~ m/^(?: 6 | cb )$/xi ? 6 : do { $self ||= "Text::CSV_XS"; croak ($self->_SetDiagInfo (1500, "formula-handling '$f' is not supported")); }; } # _supported_formula sub formula { my $self = shift; @_ and $self->_set_attr_N ("formula", _supported_formula ($self, shift)); $self->{formula} == 6 or $self->{_FORMULA_CB} = undef; [qw( none die croak diag empty undef cb )]->[_supported_formula ($self, $self->{formula})]; } # always_quote sub formula_handling { my $self = shift; $self->formula (@_); } # formula_handling 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 undef_str { my $self = shift; if (@_) { my $v = shift; $self->{undef_str} = defined $v ? "$v" : undef; $self->_cache_set ($_cache_id{undef_str}, $self->{undef_str}); } $self->{undef_str}; } # undef_str 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) { # A key cannot be a ref. That would be stored as the *string # 'SCALAR(0x1f3e710)' or 'ARRAY(0x1a5ae18)' $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); # Docs state to NEVER use UNIVERSAL::isa, because it will *never* call an # overridden isa method in any class. Well, that is exacly what I want here if ($self && ref $self and # Not a class method or direct call UNIVERSAL::isa ($self, __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->{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) = @_; ref $self->{_FFLAGS} && $idx >= 0 && $idx < @{$self->{_FFLAGS}} or return; $self->{_FFLAGS}[$idx] & 0x0001 ? 1 : 0; } # is_quoted sub is_binary { my ($self, $idx) = @_; ref $self->{_FFLAGS} && $idx >= 0 && $idx < @{$self->{_FFLAGS}} or return; $self->{_FFLAGS}[$idx] & 0x0002 ? 1 : 0; } # is_binary sub is_missing { my ($self, $idx) = @_; $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) = @_; ref $str and croak ($self->SetDiag (1500)); 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) = @_; $fh or croak ($self->SetDiag (1014)); my (@seps, %args); for (@args) { if (ref $_ eq "ARRAY") { push @seps, @$_; next; } if (ref $_ eq "HASH") { %args = %$_; next; } croak (q{usage: $csv->header ($fh, [ seps ], { options })}); } defined $args{munge} && !defined $args{munge_column_names} and $args{munge_column_names} = $args{munge}; # munge as alias defined $args{detect_bom} or $args{detect_bom} = 1; defined $args{set_column_names} or $args{set_column_names} = 1; defined $args{munge_column_names} or $args{munge_column_names} = "lc"; # Reset any previous leftovers $self->{_RECNO} = 0; $self->{_AHEAD} = undef; $self->{_COLUMN_NAMES} = undef if $args{set_column_names}; $self->{_BOUND_COLUMNS} = undef if $args{set_column_names}; if (defined $args{sep_set}) { ref $args{sep_set} eq "ARRAY" or croak ($self->_SetDiagInfo (1500, "sep_set should be an array ref")); @seps = @{$args{sep_set}}; } $^O eq "MSWin32" and binmode $fh; my $hdr = <$fh>; # check if $hdr can be empty here, I don't think so 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" } elsif ($hdr =~ s/^\x{feff}//) { $enc = "" } $self->{ENCODING} = $enc ? uc $enc : undef; $hdr eq "" and croak ($self->SetDiag (1010)); if ($enc) { if ($enc =~ m/([13]).le$/) { my $l = 0 + $1; my $x; $hdr .= "\0" x $l; read $fh, $x, $l; } if ($enc && $enc ne "utf-8") { require Encode; $hdr = Encode::decode ($enc, $hdr); } binmode $fh, ":encoding($enc)"; } } my ($ahead, $eol); if ($hdr =~ s/^([^\r\n]+)([\r\n]+)([^\r\n].+)\z/$1/s) { $eol = $2; $ahead = $3; } $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, "<", $hr or croak ($self->SetDiag (1010)); my $row = $self->getline ($h) or croak; close $h; if ($args{munge_column_names} eq "db") { for (@$row) { s/\W+/_/g; s/^_+//; $_ = lc; } } if ($ahead) { # Must be after getline, which creates the cache $self->_cache_set ($_cache_id{_has_ahead}, 1); $self->{_AHEAD} = $ahead; $eol =~ m/^\r([^\n]|\z)/ and $self->eol ($eol); } my @hdr = @$row; ref $args{munge_column_names} eq "CODE" and @hdr = map { $args{munge_column_names}->($_) } @hdr; ref $args{munge_column_names} eq "HASH" and @hdr = map { $args{munge_column_names}->{$_} || $_ } @hdr; my %hdr; $hdr{$_}++ for @hdr; exists $hdr{""} and croak ($self->SetDiag (1012)); unless (keys %hdr == @hdr) { croak ($self->_SetDiagInfo (1013, join ", " => map { "$_ ($hdr{$_})" } grep { $hdr{$_} > 1 } keys %hdr)); } $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) = @_; $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; $eol eq "" and $self->eol ($\ || $/); # say ($fh, undef) does not propage actual undef to print () my $state = $self->print ($io, @f == 1 && !defined $f[0] ? undef : @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); # $to cannot be <= 0 due to regex and ||= $from <= 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, ""); my $stack = $enc =~ s/(:\w.*)// ? $1 : ""; $enc =~ m/^[-\w.]+$/ and $enc = ":encoding($enc)"; $enc .= $stack; my $fh; my $sink = 0; 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 = exists $attr{out} && !$attr{out} ? \"skip" : delete $attr{out} || delete $attr{file}; ref $in eq "CODE" || ref $in eq "ARRAY" and $out ||= \*STDOUT; $in && $out && !ref $in && !ref $out and croak join "\n" => qq{Cannot use a string for both in and out. Instead use:}, qq{ csv (in => csv (in => "$in"), out => "$out");\n}; if ($out) { if ((ref $out and "SCALAR" ne ref $out) or "GLOB" eq ref \$out) { $fh = $out; } elsif (ref $out and "SCALAR" eq ref $out and defined $$out and $$out eq "skip") { delete $attr{out}; $sink = 1; } else { open $fh, ">", $out or croak "$out: $!"; $cls = 1; } if ($fh) { if ($enc) { binmode $fh, $enc; my $fn = fileno $fh; # This is a workaround for a bug in PerlIO::via::gzip } unless (defined $attr{eol}) { my @layers = eval { PerlIO::get_layers ($fh) }; $attr{eol} = (grep m/crlf/ => @layers) ? "\n" : "\r\n"; } } } 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 || $sink 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 $val = delete $attr{value}; my $kh = delete $attr{keep_headers} || delete $attr{keep_column_names} || delete $attr{kh}; 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 "CODE" and $fltr = { 0 => $fltr }; ref $fltr eq "HASH" or $fltr = undef; my $form = delete $attr{formula}; defined $attr{auto_diag} or $attr{auto_diag} = 1; defined $attr{escape_null} or $attr{escape_null} = 0; my $csv = delete $attr{csv} || Text::CSV_XS->new (\%attr) or croak $last_new_err; defined $form and $csv->formula ($form); return { csv => $csv, attr => { %attr }, fh => $fh, cls => $cls, in => $in, sink => $sink, out => $out, enc => $enc, hdrs => $hdrs, key => $key, val => $val, kh => $kh, 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}{qw( csv in fh hdrs )}; my %hdr; if (ref $hdrs eq "HASH") { %hdr = %$hdrs; $hdrs = "auto"; } if ($c->{out} && !$c->{sink}) { 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; } my @row1; 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}; @row1 = $csv->header ($fh, \%harg); my @hdr = $csv->column_names; @hdr and $hdrs ||= \@hdr; } if ($c->{kh}) { ref $c->{kh} eq "ARRAY" or croak ($csv->SetDiag (1501)); $hdrs ||= "auto"; } my $key = $c->{key}; if ($key) { !ref $key or ref $key eq "ARRAY" && @$key > 1 or croak ($csv->SetDiag (1501)); $hdrs ||= "auto"; } my $val = $c->{val}; if ($val) { $key or croak ($csv->SetDiag (1502)); !ref $val or ref $val eq "ARRAY" && @$val > 0 or croak ($csv->SetDiag (1503)); } $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 ]; } $c->{kh} and $hdrs and @{$c->{kh}} = @$hdrs; } 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 { my @h = $csv->column_names ($hdrs); my %h; $h{$_}++ for @h; exists $h{""} and croak ($csv->SetDiag (1012)); unless (keys %h == @h) { croak ($csv->_SetDiagInfo (1013, join ", " => map { "$_ ($h{$_})" } grep { $h{$_} > 1 } keys %h)); } $frag ? $csv->fragment ($fh, $frag) : $key ? do { my ($k, $j, @f) = ref $key ? (undef, @$key) : ($key); if (my @mk = grep { !exists $h{$_} } grep { defined } $k, @f) { croak ($csv->_SetDiagInfo (4001, join ", " => @mk)); } +{ map { my $r = $_; my $K = defined $k ? $r->{$k} : join $j => @{$r}{@f}; ( $K => ( $val ? ref $val ? { map { $_ => $r->{$_} } @$val } : $r->{$val} : $r )); } @{$csv->getline_hr_all ($fh)} } } : $csv->getline_hr_all ($fh); } : # aoa $frag ? $csv->fragment ($fh, $frag) : $csv->getline_all ($fh); if ($ref) { @row1 && !$c->{hd_c} && !ref $hdrs and unshift @$ref, \@row1; } else { Text::CSV_XS->auto_diag; } $c->{cls} and close $fh; if ($ref and $c->{cbai} || $c->{cboi}) { # Default is ARRAYref, but with key =>, you'll get a hashref foreach my $r (ref $ref eq "ARRAY" ? @{$ref} : values %{$ref}) { local %_; ref $r eq "HASH" and *_ = $r; $c->{cbai} and $c->{cbai}->($csv, $r); $c->{cboi} and $c->{cboi}->($csv, $r); } } $c->{sink} and return; 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 $fh, "<", $file or die "$file: $!"; while (my $row = $csv->getline ($fh)) { 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. See also L. 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 =head2 BOM BOM (or Byte Order Mark) handling is available only inside the L method. This method supports the following encodings: C, C, C, C, C, C, C, C, C, and C. See L. If a file has a BOM, the easiest way to deal with that is my $aoh = csv (in => $file, detect_bom => 1); All records will be encoded based on the detected BOM. This implies a call to the L method, which defaults to also set the L. So this is B the same as my $aoh = csv (in => $file, headers => "auto"); which only reads the first record to set L but ignores any meaning of possible present BOM. =head1 SPECIFICATION While no formal specification for CSV exists, L (I<1>) describes the common format and establishes C as the MIME type registered with the IANA. L (I<2>) adds fragments to CSV. Many informal documents exist that describe the C format. L<"How To: The Comma Separated Value (CSV) File Format"|http://www.creativyst.com/Doc/Articles/CSV/CSV01.htm> (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 (":"); 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. Setting C to or C<""> will disable escaping completely and is greatly discouraged. This will also disable C. 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 strict X my $csv = Text::CSV_XS->new ({ strict => 1 }); $csv->strict (0); my $f = $csv->strict; If this attribute is set to C<1>, any row that parses to a different number of fields than the previous row will cause the parser to throw error 2014. =head3 formula_handling =head3 formula X X my $csv = Text::CSV_XS->new ({ formula => "none" }); $csv->formula ("none"); my $f = $csv->formula; This defines the behavior of fields containing I. As formulas are considered dangerous in spreadsheets, this attribute can define an optional action to be taken if a field starts with an equal sign (C<=>). For purpose of code-readability, this can also be written as my $csv = Text::CSV_XS->new ({ formula_handling => "none" }); $csv->formula_handling ("none"); my $f = $csv->formula_handling; Possible values for this attribute are =over 2 =item none Take no specific action. This is the default. $csv->formula ("none"); =item die Cause the process to C whenever a leading C<=> is encountered. $csv->formula ("die"); =item croak Cause the process to C whenever a leading C<=> is encountered. (See L) $csv->formula ("croak"); =item diag Report position and content of the field whenever a leading C<=> is found. The value of the field is unchanged. $csv->formula ("diag"); =item empty Replace the content of fields that start with a C<=> with the empty string. $csv->formula ("empty"); $csv->formula (""); =item undef Replace the content of fields that start with a C<=> with C. $csv->formula ("undef"); $csv->formula (undef); =item a callback Modify the content of fields that start with a C<=> with the return-value of the callback. The original content of the field is available inside the callback as C<$_>; # Replace all formula's with 42 $csv->formula (sub { 42; }); # same as $csv->formula ("empty") but slower $csv->formula (sub { "" }); # Allow =4+12 $csv->formula (sub { s/^=(\d+\+\d+)$/$1/eer }); # Allow more complex calculations $csv->formula (sub { eval { s{^=([-+*/0-9()]+)$}{$1}ee }; $_ }); =back All other values will give a warning and then fallback to C. =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 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>. When the C attribute is set to undefined, this attribute will be set to false. The default setting will encode "=\x00=" as "="0=" With C set, this will result in "=\x00=" The default when using the C function is C. For backward compatibility reasons, the deprecated old name C is still recognized. =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 undef_str X my $csv = Text::CSV_XS->new ({ undef_str => "\\N" }); $csv->undef_str (undef); my $s = $csv->undef_str; This attribute optionally defines the output of undefined fields. The value passed is not changed at all, so if it needs quotation, the quotation needs to be included in the value of the attribute. Use with caution, as passing a value like C<",",,,,"""> will for sure mess up your output. The default for this attribute is C, meaning no special treatment. This attribute is useful when exporting CSV data to be imported in custom loaders, like for MySQL, that recognize special sequences for C data. This attribute has no meaning when parsing CSV data. =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, strict => 0, formula => 0, verbatim => 0, undef_str => undef, 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_XS->known_attributes; @attr = Text::CSV_XS::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 ($fh, $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<$fh> 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 ($fh, [ @data ]); # 11800 recs/sec $csv->print ($fh, \@data ); # 57600 recs/sec $csv->print ($fh, undef ); # 48500 recs/sec =head2 say X $status = $csv->say ($fh, $colref); Like L|/print>, but L|/eol> defaults to C<$\>. =head2 print_hr X $csv->print_hr ($fh, $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 ($fh, [ 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 ($fh); This is the counterpart to L, as L is the counterpart to L: it parses a row from the C<$fh> handle using the L method associated with C<$fh> and parses this row into an array ref. This array ref is returned by the function or C for failure. When C<$fh> 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 ($fh); $arrayref = $csv->getline_all ($fh, $offset); $arrayref = $csv->getline_all ($fh, $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<$fh> are taken into consideration. Given a CSV file with 10 lines: lines call ----- --------------------------------------------------------- 0..9 $csv->getline_all ($fh) # all 0..9 $csv->getline_all ($fh, 0) # all 8..9 $csv->getline_all ($fh, 8) # start at 8 - $csv->getline_all ($fh, 0, 0) # start at 0 first 0 rows 0..4 $csv->getline_all ($fh, 0, 5) # start at 0 first 5 rows 4..5 $csv->getline_all ($fh, 4, 2) # start at 4 first 2 rows 8..9 $csv->getline_all ($fh, -2) # last 2 rows 6..7 $csv->getline_all ($fh, -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 ($fh); 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 ($fh)}; $csv->column_names (@cols); while (my $row = $csv->getline_hr ($fh)) { print $row->{price}; } Could easily be rewritten to the much faster: my @cols = @{$csv->getline ($fh)}; my $row = {}; $csv->bind_columns (\@{$row}{@cols}); while ($csv->getline ($fh)) { 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 ($fh); $arrayref = $csv->getline_hr_all ($fh, $offset); $arrayref = $csv->getline_hr_all ($fh, $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. The C<$line> argument is supposed to be a simple scalar. Everything else is supposed to croak and set error 1500. =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 ($fh, $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 ($fh, "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 ($fh)); 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 ($fh); 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. This method resets some object properties, as it is supposed to be invoked only once per file or stream. It will leave attributes C and C alone of setting column names is disabled. Reading headers on previously process objects might fail on perl-5.8.0 and older. 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 X $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 X $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. If a supported BOM was detected as start of the stream, it is stored in the abject attribute C. my $enc = $csv->{ENCODING}; The encoding is used with 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. In case the stream starts with a decode BOM (C), C<{ENCODING}> will be C<""> (empty) instead of the default C. =item munge_column_names X 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 db - valid DB field names none - do not change \%hash - supply a mapping \&cb - supply a callback =over 2 =item Lower case $csv->header ($fh, { munge_column_names => "lc" }); The header is changed to all lower-case $_ = lc; =item Upper case $csv->header ($fh, { munge_column_names => "uc" }); The header is changed to all upper-case $_ = uc; =item Literal $csv->header ($fh, { munge_column_names => "none" }); =item Hash $csv->header ($fh, { munge_column_names => { foo => "sombrero" }); if a value does not exist, the original value is used unchanged =item Database $csv->header ($fh, { munge_column_names => "db" }); =over 2 =item - lower-case =item - all sequences of non-word characters are replaced with an underscore =item - all leading underscores are removed =back $_ = lc (s/\W+/_/gr =~ s/^_+//r); =item 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. =back =item set_column_names X $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. As described in L above, content is lost in scalar context. =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 ($fh)) { 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 (or this row has just two fields where the previous row had more), the first two fields already have been assigned the values of the current row, while the rest of the fields will still hold the values of the previous row. If you want the parser to fail in these cases, use the L|/strict> attribute. =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 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 escape_null => 0 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 csv (in => $aoa, out => "file.csv"); csv (in => $aoa, out => $fh); csv (in => $aoa, out => STDOUT); csv (in => $aoa, out => *STDOUT); csv (in => $aoa, out => \*STDOUT); csv (in => $aoa, out => \my $data); csv (in => $aoa, out => undef); csv (in => $aoa, out => \"skip"); 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>), the glob itself (e.g. C<*STDOUT>), or a reference to a scalar (e.g. C<\my $data>). 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. If C is set to a reference of the literal string C<"skip">, the output will be suppressed completely, which might be useful in combination with a filter for side effects only. my %cache; csv (in => "dump.csv", out => \"skip", on_in => sub { $cache{$_[1][1]}++ }); Currently, setting C to any false value (C, C<"">, 0) will be equivalent to C<\"skip">. =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>. Encodings can be stacked, as supported by C: # Using PerlIO::via::gzip csv (in => \@csv, out => "test.csv:via.gz", encoding => ":via(gzip):encoding(utf-8)", ); $aoa = csv (in => "test.csv:via.gz", encoding => ":via(gzip)"); # Using PerlIO::gzip csv (in => \@csv, out => "test.csv:via.gz", encoding => ":gzip:encoding(utf-8)", ); $aoa = csv (in => "test.csv:gzip.gz", encoding => ":gzip"); =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 the method 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. Allowed values are simple scalars or array-references where the first element is the joiner and the rest are the fields to join to combine the key. my $ref = csv (in => "test.csv", key => "code"); my $ref = csv (in => "test.csv", key => [ ":" => "code", "color" ]); with test.csv like code,product,price,color 1,pc,850,gray 2,keyboard,12,white 3,mouse,5,black the first example 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' } } the second example will return { "1:gray" => { code => 1, color => 'gray', price => 850, product => 'pc' }, "2:white" => { code => 2, color => 'white', price => 12, product => 'keyboard' }, "3:black" => { code => 3, color => 'black', price => 5, product => 'mouse' } } The C attribute can be combined with L|/headers> for C date that has no header line, like my $ref = csv ( in => "foo.csv", headers => [qw( c_foo foo bar description stock )], key => "c_foo", ); =head3 value X Used to create key-value hashes. Only allowed when C is valid. A C can be either a single column label or an anonymous list of column labels. In the first case, the value will be a simple scalar value, in the latter case, it will be a hashref. my $ref = csv (in => "test.csv", key => "code", value => "price"); my $ref = csv (in => "test.csv", key => "code", value => [ "product", "price" ]); my $ref = csv (in => "test.csv", key => [ ":" => "code", "color" ], value => "price"); my $ref = csv (in => "test.csv", key => [ ":" => "code", "color" ], value => [ "product", "price" ]); with test.csv like code,product,price,color 1,pc,850,gray 2,keyboard,12,white 3,mouse,5,black the first example will return { 1 => 850, 2 => 12, 3 => 5, } the second example will return { 1 => { price => 850, product => 'pc' }, 2 => { price => 12, product => 'keyboard' }, 3 => { price => 5, product => 'mouse' } } the third example will return { "1:gray" => 850, "2:white" => 12, "3:black" => 5, } the fourth example will return { "1:gray" => { price => 850, product => 'pc' }, "2:white" => { price => 12, product => 'keyboard' }, "3:black" => { price => 5, product => 'mouse' } } =head3 keep_headers X X X When using hashes, keep the column names into the arrayref passed, so all headers are available after the call in the original order. my $aoh = csv (in => "file.csv", keep_headers => \my @hdr); This attribute can be abbreviated to C or passed as C. This attribute implies a default of C for the C attribute. =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 the L method 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. If C is passed as a false value, the content of the first row is only preserved if the output is AoA: With an input-file like bAr,foo 1,2 3,4,5 This call my $aoa = csv (in => $file, set_column_names => 0); will result in [[ "bar", "foo" ], [ "1", "2" ], [ "3", "4", "5" ]] and my $aoa = csv (in => $file, set_column_names => 0, munge => "none"); will result in [[ "bAr", "foo" ], [ "1", "2" ], [ "3", "4", "5" ]] =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: =over 2 =item hashref The keys are the index to the row (the field name or 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 => { foo => sub { $_ > 4 }}); 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. 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 }} =item coderef csv (in => "file.csv", filter => sub { $n++; 0; }); If the argument to C is a coderef, it is an alias or shortcut to a filter on column 0: csv (filter => sub { $n++; 0 }); is equal to csv (filter => { 0 => sub { $n++; 0 }); =item filter-name csv (in => "file.csv", filter => "not_blank"); csv (in => "file.csv", filter => "not_empty"); csv (in => "file.csv", filter => "filled"); These are predefined filters 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 =back One could also use modules like L: use Types::Standard -types; my $type = Tuple[Str, Str, Int, Bool, Optional[Num]]; my $check = $type->compiled_check; # filter with compiled check and warnings my $aoa = csv ( in => \$data, filter => { 0 => sub { my $ok = $check->($_[1]) or warn $type->get_message ($_[1]), "\n"; return $ok; }, }, ); =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: $!"; or my $aoa = csv (in => "file.csv", on_in => sub { # do something with %_ }); =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 (); } =head3 Parsing CSV from memory Given a complete CSV data-set in scalar C<$data>, generate a list of lists to represent the rows and fields # The data my $data = join "\r\n" => map { join "," => 0 .. 5 } 0 .. 5; # in a loop my $csv = Text::CSV_XS->new ({ binary => 1, auto_diag => 1 }); open my $fh, "<", \$data; my @foo; while (my $row = $csv->getline ($fh)) { push @foo, $row; } close $fh; # a single call my $foo = csv (in => \$data); =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: $!"; =head3 Generating CSV into memory Format a data-set (C<@foo>) into a scalar value in memory (C<$data>): # The data my @foo = map { [ 0 .. 5 ] } 0 .. 3; # in a loop my $csv = Text::CSV_XS->new ({ binary => 1, auto_diag => 1, eol => "\r\n" }); open my $fh, ">", \my $data; $csv->print ($fh, $_) for @foo; close $fh; # a single call csv (in => \@foo, out => \my $data); =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 ]); } note that this will not work as expected when choosing the backslash (C<\>) as C, as that will cause the C<\> to need to be escaped by yet another C<\>, which will cause the field to need quotation and thus ending up as C<"\\N"> instead of C<\N>. See also L|/undef_str>. csv (out => "foo.csv", in => sub { $sth->fetch }, undef_str => "\\N"); 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 ($fh)) { $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 files/utf8.csv with csv-check 1.9 using Text::CSV_XS 1.32 with perl 5.26.0 and Unicode 9.0.0 OK: rows: 1, columns: 2 sep = <,>, quo = <">, bin = <1>, eol = <"\n"> =item csv2xls X A script to convert C to Microsoft Excel (C). This requires extra modules L and L. The converter accepts various options and can produce UTF-8 compliant Excel files. =item csv2xlsx X A script to convert C to Microsoft Excel (C). This requires the modules L and L. The converter does accept various options including merging several C files into a single Excel file. =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 =item rewrite.pl X A script to rewrite (in)valid CSV into valid CSV files. Script has options to generate confusing CSV files or CSV files that conform to Dutch MS-Excel exports (using C<;> as separation). Script - by default - honors BOM and auto-detects separation converting it to default standard CSV with C<,> as separator. =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 * 1008 "INI - SEP undefined" X<1008> The value passed for SEP should be defined and not empty. =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 * 1014 "INI - header called on undefined stream" X<1014> The header line cannot be parsed from an undefined sources. =item * 1500 "PRM - Invalid/unsupported argument(s)" X<1500> Function or method called with invalid argument(s) or parameter(s). =item * 1501 "PRM - The key attribute is passed as an unsupported type" X<1501> The C attribute is of an unsupported type. =item * 1502 "PRM - The value attribute is passed without the key attribute" X<1502> The C attribute is only allowed when a valid key is given. =item * 1503 "PRM - The value attribute is passed as an unsupported type" X<1503> The C attribute is of an unsupported type. =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 * 2014 "ENF - Inconsistent number of fields" X<2014> Inconsistent number of fields under strict parsing. =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-2020 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 Text-CSV_XS-1.41/ppport.h0000644000031300001440000120653713621275436015647 0ustar00merijnusers00000000000000#if 0 <<'SKIP'; #endif /* ---------------------------------------------------------------------- ppport.h -- Perl/Pollution/Portability Version 3.57 Automatically created by Devel::PPPort running under perl 5.030000. 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.57 =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_07, and has been tested up to 5.31.6. =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_07. 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 ----------------------------------------------------------------------------------------- caller_cx() NEED_caller_cx NEED_caller_cx_GLOBAL croak_xs_usage() NEED_croak_xs_usage NEED_croak_xs_usage_GLOBAL die_sv() NEED_die_sv NEED_die_sv_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 load_module() NEED_load_module NEED_load_module_GLOBAL mess() NEED_mess NEED_mess_GLOBAL mess_nocontext() NEED_mess_nocontext NEED_mess_nocontext_GLOBAL mess_sv() NEED_mess_sv NEED_mess_sv_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 my_strnlen() NEED_my_strnlen NEED_my_strnlen_GLOBAL newCONSTSUB() NEED_newCONSTSUB NEED_newCONSTSUB_GLOBAL newSVpvn_share() NEED_newSVpvn_share NEED_newSVpvn_share_GLOBAL PL_parser NEED_PL_parser NEED_PL_parser_GLOBAL PL_signals NEED_PL_signals NEED_PL_signals_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_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_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 utf8_to_uvchr_buf() NEED_utf8_to_uvchr_buf NEED_utf8_to_uvchr_buf_GLOBAL vload_module() NEED_vload_module NEED_vload_module_GLOBAL vmess() NEED_vmess NEED_vmess_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 Some of the suggested edits and/or generated patches may not compile as-is without tweaking manually. This is generally due to the need for an extra parameter to be added to the call to prevent buffer overflow. 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 send a bug report to 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 # These are tools that must be included in ppport.h. It doesn't work if given # a .pl suffix sub format_version { # Given an input version that is acceptable to parse_version(), return a # string of the standard representation of it. my($r,$v,$s) = parse_version(shift); if ($r < 5 || ($r == 5 && $v < 6)) { my $ver = sprintf "%d.%03d", $r, $v; $s > 0 and $ver .= sprintf "_%02d", $s; return $ver; } return sprintf "%d.%d.%d", $r, $v, $s; } sub parse_version { # Returns a triplet, (5, major, minor) from the input, treated as a string, # which can be in any of several typical formats. my $ver = shift; $ver = "" unless defined $ver; my($r,$v,$s); if ( ($r, $v, $s) = $ver =~ /^(5)(\d{3})(\d{3})$/ # 5029010, from the file # names in our # parts/base/ and # parts/todo directories or ($r, $v, $s) = $ver =~ /^(\d+)\.(\d+)\.(\d+)$/ # 5.25.7 or ($r, $v, $s) = $ver =~ /^(\d+)\.(\d{3})(\d{3})$/ # 5.025008, from the # output of $] or ($r, $v, $s) = $ver =~ /^(\d+)\.(\d{1,3})()$/ # 5.24, 5.004 or ($r, $v, $s) = $ver =~ /^(\d+)\.(00[1-5])_?(\d{2})$/ # 5.003_07 ) { $s = 0 unless $s; die "Only Perl 5 is supported '$ver'\n" if $r != 5; die "Invalid version number: $ver\n" if $v >= 1000 || $s >= 1000; return (5, 0 + $v, 0 + $s); } # For some safety, don't assume something is a version number if it has a # literal dot as one of the three characters. This will have to be fixed # when we reach 5.46 if ($ver !~ /\./ && (($r, $v, $s) = $ver =~ /^(.)(.)(.)$/)) # vstring 5.25.7 { $r = ord $r; $v = ord $v; $s = ord $s; die "Only Perl 5 is supported '$ver'\n" if $r != 5; return (5, $v, $s); } my $mesg = ""; $mesg = ". (In 5.00x_yz, x must be 1-5.)" if $ver =~ /_/; die "Invalid version number format: '$ver'$mesg\n"; } sub int_parse_version { # Returns integer 7 digit human-readable version, suitable for use in file # names in parts/todo parts/base. return 0 + join "", map { sprintf("%03d", $_) } parse_version(shift); } sub ivers # Shorter name for int_parse_version { return int_parse_version(shift); } sub format_version_line { # Returns a floating point representation of the input version my $version = int_parse_version(shift); $version =~ s/^5\B/5./; return $version; } sub dictionary_order($$) # Sort caselessly, ignoring punct { my ($lc_a, $lc_b); my ($squeezed_a, $squeezed_b); my ($valid_a, $valid_b); # Meaning valid for all releases # On early perls, the implicit pass by reference doesn't work, so we have # to use the globals to initialize. if ("$]" < "5.006" ) { $valid_a = $a; $valid_b = $b; } else { ($valid_a, $valid_b) = @_; } $lc_a = lc $valid_a; $lc_b = lc $valid_b; $squeezed_a = $lc_a; $squeezed_a =~ s/[\W_]//g; # No punct, including no underscore $squeezed_b = $lc_b; $squeezed_b =~ s/[\W_]//g; return( $squeezed_a cmp $squeezed_b or $lc_a cmp $lc_b or $valid_a cmp $valid_b); } sub sort_api_lines # Sort lines of the form flags|return|name|args... # by 'name' { $a =~ / ^ [^|]* \| [^|]* \| (\w+) /x; # 3rd field '|' is sep my $a_name = $1; $b =~ / ^ [^|]* \| [^|]* \| (\w+) /x; my $b_name = $1; return dictionary_order($a_name, $b_name); } 1; use strict; BEGIN { require warnings if "$]" > '5.006' } # Disable broken TRIE-optimization BEGIN { eval '${^RE_TRIE_MAXBUF} = -1' if "$]" >= 5.009004 && "$]" <= 5.009005 } my $VERSION = 3.57; 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}; $opt{'compat-version'} = 5.003_07 unless exists $opt{'compat-version'}; $opt{'compat-version'} = int_parse_version($opt{'compat-version'}); my $int_min_perl = int_parse_version(5.003_07); # Each element of this hash looks something like: # 'Poison' => { # 'base' => '5.008000', # 'provided' => 1, # 'todo' => '5.003007' # }, 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 ) : ()), (index($4, 'c') >= 0 ? ( core_only => 1 ) : ()), (index($4, 'd') >= 0 ? ( deprecated => 1 ) : ()), (index($4, 'i') >= 0 ? ( inaccessible => 1 ) : ()), (index($4, 'x') >= 0 ? ( experimental => 1 ) : ()), (index($4, 'u') >= 0 ? ( undocumented => 1 ) : ()), (index($4, 'o') >= 0 ? ( ppport_fnc => 1 ) : ()), (index($4, 'V') >= 0 ? ( unverified => 1 ) : ()), } ) : die "invalid spec: $_" } qw( abort_execution|5.025010||Viu add_above_Latin1_folds|5.021001||Viu add_cp_to_invlist|5.013011||Viu add_data|5.005000||nViu add_multi_match|5.021004||Viu _add_range_to_invlist|5.016000||cViu add_utf16_textfilter|5.011001||Viu adjust_size_and_find_bucket|5.019003||nViu advance_one_LB|5.023007||Viu advance_one_SB|5.021009||Viu advance_one_WB|5.021009||Viu alloccopstash|5.017001|5.017001|x alloc_LOGOP|5.025004||xViu allocmy|5.008001||Viu amagic_call|5.003007|5.003007|u amagic_cmp|5.009003||Viu amagic_cmp_locale|5.009003||Viu amagic_deref_call|5.013007|5.013007|u amagic_i_ncmp|5.009003||Viu amagic_is_enabled|5.015008||Viu amagic_ncmp|5.009003||Viu _aMY_CXT|5.009000|5.009000|p aMY_CXT_|5.009000|5.009000|p aMY_CXT|5.009000|5.009000|p anonymise_cv_maybe|5.013003||Viu any_dup|5.006000||Vu ao|5.005000||Viu _append_range_to_invlist|5.013010||Viu append_utf8_from_native_byte|5.019004||ncViu apply|5.003007||Viu apply_attrs|5.006000||Viu apply_attrs_my|5.007003||Viu apply_attrs_string|5.006001|5.006001|xu ARCHNAME|5.004000|5.004000| argvout_final|5.029006||Viu ASCII_TO_NEED|5.019004||ndcVu __ASSERT_|5.019007|5.008008|p assert_uft8_cache_coherent|5.013003||Viu assignment_type|5.021005||Viu atfork_lock|5.007002|5.007002|nu atfork_unlock|5.007002|5.007002|nu aTHX_|5.006000|5.003007|p aTHX|5.006000|5.003007|p aTHXR_||5.003007|pou aTHXR||5.003007|pou av_arylen_p|5.009003|5.009003|u av_clear|5.003007|5.003007| av_create_and_push|5.009005|5.009005|x av_create_and_unshift_one|5.009005|5.009005|x av_delete|5.006000|5.006000| av_exists|5.006000|5.006000| av_extend|5.003007|5.003007| av_extend_guts|5.017004||Viu av_fetch|5.003007|5.003007| av_fill|5.003007|5.003007| AvFILL|5.003007|5.003007| AvFILLp|5.004005|5.003007|poV av_iter_p|5.011000|5.011000|u av_len|5.003007|5.003007| av_make|5.003007|5.003007| av_nonelem|5.027009||Viu av_pop|5.003007|5.003007| av_push|5.003007|5.003007| av_reify|5.004004||cViu av_shift|5.003007|5.003007| av_store|5.003007|5.003007| av_tindex|5.017009|5.003007|p av_top_index|5.017009|5.003007|p av_undef|5.003007|5.003007| av_unshift|5.003007|5.003007| ax|5.003007|5.003007| backup_one_GCB|5.025003||Viu backup_one_LB|5.023007||Viu backup_one_SB|5.021009||Viu backup_one_WB|5.021009||Viu bad_type_gv|5.019002||Viu bad_type_pv|5.016000||Viu BhkDISABLE|||x BhkENABLE|||x BhkENTRY_set|||x BhkENTRY|||xi BhkFLAGS|||xi BIN|5.003007|5.003007| bind_match|5.003007||Viu block_end|5.004000|5.004000| block_gimme|5.004000|5.004000|u blockhook_register|5.013003|5.013003|x block_start|5.004000|5.004000| BOM_UTF8|5.025005|5.003007|p boolSV|5.004000|5.003007|p boot_core_mro|5.009005||Viu boot_core_PerlIO|5.007002||Viu boot_core_UNIVERSAL|5.003007||Viu _byte_dump_string|5.025006||cViu BYTEORDER|5.003007|5.003007| bytes_cmp_utf8|5.013007|5.013007| bytes_from_utf8|5.007001|5.007001|x bytes_from_utf8_loc|5.027001|5.027001|nxu bytes_to_utf8|5.006001|5.006001|x call_argv|5.006000|5.003007|p call_atexit|5.006000|5.006000|u CALL_BLOCK_HOOKS|||xi CALL_CHECKER_REQUIRE_GV|5.021004|5.021004| caller_cx|5.013005|5.006000|p call_list|5.004000|5.004000|u call_method|5.006000|5.003007|p calloc|5.007002|5.007002|n call_pv|5.006000|5.003007|p call_sv|5.006000|5.003007|p cando|5.003007||Viu C_ARRAY_END|5.013002|5.003007|p C_ARRAY_LENGTH|5.008001|5.003007|p CASTFLAGS|5.003007|5.003007| cast_i32|5.006000|5.006000|nu cast_iv|5.006000|5.006000|nu cast_ulong|5.006000|5.006000|nu cast_uv|5.006000|5.006000|nu category_name|5.027008||nViu cBOOL|5.013000|5.003007|p change_engine_size|5.029004||Viu CHARBITS|5.011002|5.011002| checkcomma|5.003007||Viu check_locale_boundary_crossing|5.015006||Viu check_type_and_open|5.009003||Viu check_uni|5.003007||Viu check_utf8_print|5.013009||Viu ck_entersub_args_core|||iu ck_entersub_args_list|5.013006|5.013006| ck_entersub_args_proto|5.013006|5.013006| ck_entersub_args_proto_or_list|5.013006|5.013006| ckWARN2|5.006000|5.006000| ckWARN2_d|5.006000|5.006000| ckWARN3|5.007003|5.007003| ckWARN3_d|5.007003|5.007003| ckWARN4|5.007003|5.007003| ckWARN4_d|5.007003|5.007003| ckWARN|5.006000|5.003007|p ckwarn|5.009003|5.009003|u ckwarn_common|5.011001||Viu ckWARN_d|5.006000|5.006000| ckwarn_d|5.009003|5.009003|u ck_warner|5.011001|5.011001|vu ck_warner_d|5.011001|5.011001|vu CLASS||5.003007| clear_defarray|5.023008|5.023008|u CLEAR_ERRSV|5.025007|5.025007| clear_placeholders|5.009004||xViu clear_special_blocks|5.021003||Viu clone_params_del|5.013002|5.013002|nu clone_params_new|5.013002|5.013002|nu closest_cop|5.007002||Viu cntrl_to_mnemonic|5.021004||ncViu compute_EXACTish|5.017003||nViu construct_ahocorasick_from_trie|5.021001||Viu cop_fetch_label|5.015001|5.015001|x CopFILE|5.006000||pVu CopFILEAV|5.006000||pVu CopFILEGV|5.006000||pVu CopFILEGV_set|5.006000||pVu CopFILE_set|5.006000||pVu CopFILESV|5.006000||pVu cop_free|5.006000||Viu cophh_2hv|5.013007|5.013007|x cophh_copy|5.013007|5.013007|x cophh_delete_pv|5.013007|5.013007|x cophh_delete_pvn|5.013007|5.013007|x cophh_delete_pvs|5.013007|5.013007|x cophh_delete_sv|5.013007|5.013007|x cophh_fetch_pv|5.013007|5.013007|x cophh_fetch_pvn|5.013007|5.013007|x cophh_fetch_pvs|5.013007|5.013007|x cophh_fetch_sv|5.013007|5.013007|x cophh_free|5.013007|5.013007|x COPHH_KEY_UTF8|5.013007|5.013007| cophh_new_empty|5.013007|5.013007|x cophh_store_pv|5.013007|5.013007|x cophh_store_pvn|5.013007|5.013007|x cophh_store_pvs|5.013007|5.013007|x cophh_store_sv|5.013007|5.013007|x cop_hints_2hv|5.013007|5.013007| cop_hints_fetch_pv|5.013007|5.013007| cop_hints_fetch_pvn|5.013007|5.013007| cop_hints_fetch_pvs|5.013007|5.013007| cop_hints_fetch_sv|5.013007|5.013007| CopLABEL|5.009005|5.009005| CopLABEL_len|5.016000|5.016000| CopLABEL_len_flags|5.016000|5.016000| CopSTASH|5.006000||pVu CopSTASH_eq|5.006000||pVu CopSTASHPV|5.006000||pVu CopSTASHPV_set|5.006000||pVu CopSTASH_set|5.006000||pVu cop_store_label|5.015001|5.015001|x Copy|5.003007|5.003007| CopyD|5.009002|5.003007|p core_prototype|5.015002||Vi coresub_op|5.015003||Viu CPERLscope|5.005000||pVu CPPLAST|5.006000|5.006000| CPPMINUS|5.003007|5.003007| CPPRUN|5.006000|5.006000| CPPSTDIN|5.003007|5.003007| create_eval_scope|5.009004||xViu croak|5.006000|5.003007|v croak_caller|5.025004||vnViu croak_memory_wrap|5.017006|5.003007|pnu croak_nocontext|5.006000||pvnVu croak_no_mem|5.017006||nViu croak_no_modify|5.013003|5.003007|pn croak_popstack|5.017008||ncViu croak_sv|5.013001|5.003007|p croak_xs_usage|5.010001|5.003007|pn cr_textfilter|5.006000||Viu csighandler1|||nu csighandler3|||nu csighandler|||nu current_re_engine|5.017001||cViu curse|5.013009||Viu custom_op_desc|5.007003|5.007003|d custom_op_get_field|5.019006||cViu custom_op_name|5.007003|5.007003|d custom_op_register|5.013007|5.013007| cv_ckproto_len_flags|5.015004||xcViu cv_clone|5.003007|5.003007| cv_clone_into|5.017004||Viu cv_const_sv|5.003007|5.003007|n cv_const_sv_or_av|5.019003||nViu CvDEPTH|5.003007|5.003007|nu cv_dump|5.006000||Vi cv_forget_slab|5.017002||Vi cv_get_call_checker|5.013006|5.013006| cv_get_call_checker_flags|5.027003|5.027003| CvGV|5.003007|5.003007|u cvgv_from_hek|||ciu cvgv_set|5.013003||cViu cv_name|5.021005|5.021005| CV_NAME_NOTQUAL|5.021005|5.021005| CvPADLIST|5.008001|5.008001|x cv_set_call_checker|5.013006|5.013006| cv_set_call_checker_flags|5.021004|5.021004| CvSTASH|5.003007|5.003007| cvstash_set|5.013007||cViu cv_undef|5.003007|5.003007| cv_undef_flags|5.021004||Viu CvWEAKOUTSIDE|||i CX_CURPAD_SAVE|||i CX_CURPAD_SV|||i cx_dump|5.005000|5.005000|u cx_dup|5.007003|5.007003|u cxinc|5.003007|5.003007|u cx_popblock|5.023008|5.023008|xu cx_popeval|5.023008|5.023008|xu cx_popformat|5.023008|5.023008|xu cx_popgiven|5.027008|5.027008|xu cx_poploop|5.023008|5.023008|xu cx_popsub|5.023008|5.023008|xu cx_popsub_args|5.023008|5.023008|xu cx_popsub_common|5.023008|5.023008|xu cx_popwhen|5.027008|5.027008|xu cx_pushblock|5.023008|5.023008|xu cx_pusheval|5.023008|5.023008|xu cx_pushformat|5.023008|5.023008|xu cx_pushgiven|5.027008|5.027008|xu cx_pushloop_for|5.023008|5.023008|xu cx_pushloop_plain|5.023008|5.023008|xu cx_pushsub|5.023008|5.023008|xu cx_pushwhen|5.027008|5.027008|xu cx_topblock|5.023008|5.023008|xu dAX|5.007002|5.003007|p dAXMARK|5.009003|5.003007|p deb|5.007003|5.007003|vu deb_curcv|5.007002||Viu deb_nocontext|5.007003|5.007003|vnu debop|5.005000|5.005000|u debprof|5.005000||Viu debprofdump|5.005000|5.005000|u debstack|5.007003|5.007003|u deb_stack_all|5.008001||Viu deb_stack_n|5.008001||Viu debstackptrs|5.007003|5.007003|u debug_start_match|5.009004||Viu DECLARATION_FOR_LC_NUMERIC_MANIPULATION|5.021010|5.021010| defelem_target|5.019002||Viu DEFSV|5.004005|5.003007|poVu DEFSV_set|5.010001||pVu delete_eval_scope|5.009004||xViu delimcpy|5.004000|5.004000|nu delimcpy_no_escape|5.025005||nViu del_sv|5.005000||Viu despatch_signals|5.007001|5.007001|u destroy_matcher|5.027008||Viu die|5.006000|5.003007|v die_nocontext|5.006000||vnVu die_sv|5.013001|5.003007|p die_unwind|5.013001||Viu dirp_dup|5.013007|5.013007|u dITEMS|5.007002|5.003007|p div128|5.005000||Viu djSP|||i dMARK|5.003007|5.003007| dMULTICALL|5.009003|5.009003| dMY_CXT|5.009000|5.009000|p dMY_CXT_SV|5.007003||poVu dNOOP|5.006000|5.003007|poVu do_aexec5|5.006000||Viu do_aexec|||iu do_aspawn|5.008000||Vu do_binmode|5.004005|5.004005|du docatch|5.005000||Vi do_chomp|5.003007||Viu do_close|5.003007|5.003007|u do_delete_local|5.011000||Viu do_dump_pad|5.008001||Vi do_eof|5.003007||Viu does_utf8_overflow|5.025006||nViu doeval_compile|5.023008||Viu do_exec3|5.006000||Viu do_exec|5.003007||Viu dofile|5.005003||Viu dofindlabel|5.003007||Viu doform|5.005000||Viu do_gv_dump|5.006000|5.006000|u do_gvgv_dump|5.006000|5.006000|u do_hv_dump|5.006000|5.006000|u doing_taint|5.008001|5.008001|nu do_ipcctl|5.003007||Viu do_ipcget|5.003007||Viu do_join|5.003007|5.003007|u do_magic_dump|5.006000|5.006000|u do_msgrcv|5.003007||Viu do_msgsnd|5.003007||Viu do_ncmp|5.015001||Viu do_oddball|5.006000||Viu dooneliner|5.006000||Viu do_op_dump|5.006000|5.006000|u do_open|5.003007|5.003007|u do_open6|5.019010||xViu do_open9|5.006000|5.006000|du do_openn|5.007001|5.007001|u doopen_pm|5.008001||Viu do_open_raw|5.019010||xViu doparseform|5.005000||Viu do_pmop_dump|5.006000|5.006000|u dopoptoeval|5.003007||Viu dopoptogivenfor|5.027008||Viu dopoptolabel|5.005000||Viu dopoptoloop|5.005000||Viu dopoptosub_at|5.005000||Viu dopoptowhen|5.027008||Viu do_print|5.003007||Viu do_readline|5.003007||Viu doref|5.009003|5.009003|u dORIGMARK|5.003007|5.003007| do_seek|5.003007||Viu do_semop|5.003007||Viu do_shmio|5.003007||Viu do_smartmatch|5.027008||Viu do_spawn|5.008000||Vu do_spawn_nowait|5.008000||Vu do_sprintf|5.003007|5.003007|u do_sv_dump|5.006000|5.006000|u do_sysseek|5.004000||Viu do_tell|5.003007||Viu do_trans|5.003007||Viu do_trans_complex|5.006001||Viu do_trans_count|5.006001||Viu do_trans_count_invmap|5.031006||Viu do_trans_invmap|5.031006||Viu do_trans_simple|5.006001||Viu DOUBLEINFBYTES|5.023000|5.023000| DOUBLEKIND|5.021006|5.021006| DOUBLEMANTBITS|5.023000|5.023000| DOUBLENANBYTES|5.023000|5.023000| DOUBLESIZE|5.005000|5.005000| dounwind|5.003007|5.003007|u DO_UTF8|5.006000|5.006000| do_vecget|5.006000||Viu do_vecset|5.003007||Viu do_vop|5.003007||Viu dowantarray|5.003007|5.003007|u drand48_init_r|||nciu drand48_r|||nciu dSAVEDERRNO|||i dSAVE_ERRNO|||i dSP|5.003007|5.003007| dTHR|5.004005|5.003007|p dTHX|5.003007|5.003007|p dTHXa|5.006000||pVu dTHXoa|5.006000||pVu dTHXR||5.003007|pou dtrace_probe_call|||ciu dtrace_probe_load|||ciu dtrace_probe_op|||ciu dtrace_probe_phase|||ciu dump_all|5.006000|5.006000| dump_all_perl|5.011000||Viu dump_c_backtrace|5.021001||V dump_eval|5.006000|5.006000|u dump_exec_pos|5.009004||Viu dump_form|5.006000|5.006000|u dump_indent|5.006000|5.006000|vu dump_mstats|5.003007||Vu dump_packsubs|5.006000|5.006000| dump_packsubs_perl|5.011000||Viu dump_regex_sets_structures|5.025006||Viu dump_sub|5.006000|5.006000|u dump_sub_perl|5.011000||Viu dump_sv_child|5.009003||Viu dump_trie|5.009004||Viu dump_trie_interim_list|5.009004||Viu dump_trie_interim_table|5.009004||Viu dumpuntil|5.005000||Viu dump_vindent|5.006000|5.006000|u dUNDERBAR|5.009002|5.003007|p dup_attrlist|5.006000||Viu dup_warnings|||ciu dVAR|5.009003|5.003007|p dXCPT|5.009002|5.003007|p dXSARGS|5.003007|5.003007| dXSI32|5.003007|5.003007|V dXSTARG|5.006000|5.003007|poVu edit_distance|5.023008||nViu emulate_cop_io|||xciu emulate_setlocale|5.027009||nViu END_EXTERN_C|5.005000|5.003007|poVu ENTER|5.003007|5.003007| ENTER_with_name|5.011002|5.011002| ERRSV|5.004005|5.003007|p eval_pv|5.006000|5.003007|p eval_sv|5.006000|5.003007|p exec_failed|5.009004||Viu expect_number|5.007001||Viu EXTEND|5.003007|5.003007| EXTERN_C|5.005000|5.003007|poVu F0convert|5.009003||nViu fbm_compile|5.005000|5.005000| fbm_instr|5.005000|5.005000| filter_add|5.003007|5.003007| filter_del|5.003007|5.003007|u filter_gets|5.005000||Viu filter_read|5.003007|5.003007| finalize_op|5.015002||Viu finalize_optree|5.015002||Vi find_and_forget_pmops|5.009005||Viu find_array_subscript|5.009004||Viu find_beginning|5.005000||Viu find_byclass|5.006000||Viu find_default_stash|5.019004||Viu find_first_differing_byte_pos|||nViu find_hash_subscript|5.009004||Viu find_in_my_stash|5.006001||Viu find_lexical_cv|5.019001||Viu find_next_masked|5.027009||nViu find_runcv|5.008001|5.008001| find_runcv_where|5.017002||Viu find_rundefsv|5.013002|5.013002| find_rundefsvoffset|5.009002|5.009002|d find_script|5.004005||Viu find_span_end|5.027009||nViu find_span_end_mask|5.027009||nViu find_uninit_var|5.009002||xVi first_symbol|5.009003||nViu fixup_errno_string|5.019007||Viu fold_constants|5.003007||Viu foldEQ|5.013002|5.013002|n foldEQ_latin1|5.013008|5.013008|nu foldEQ_latin1_s2_folded|5.029007||nViu foldEQ_locale|5.013002|5.013002|n foldEQ_utf8|5.013002|5.007003|p foldEQ_utf8_flags|5.013010||cVu forbid_setid|5.005000||Viu force_ident|5.003007||Viu force_ident_maybe_lex|5.017004||Viu force_list|5.003007||Viu force_next|5.003007||Viu _force_out_malformed_utf8_message|5.025009||cVu force_strict_version|5.011004||Viu force_version|5.005000||Viu force_word|5.003007||Viu forget_pmop|5.017007||Viu form|5.006000|5.004000|v form_alien_digit_msg|||ciu form_cp_too_large_msg|||ciu form_nocontext|5.006000||vnVu fp_dup|5.007003|5.007003|u fprintf_nocontext|5.006000||vndVu free_c_backtrace|5.021001||Vi free_global_struct|5.009003||Vu free_tied_hv_pool|5.008001||Viu FREETMPS|5.003007|5.003007| free_tmps|5.003007|5.003007|u G_ARRAY|5.003007|5.003007| G_DISCARD|5.003007|5.003007| gen_constant_list|5.003007||Viu get_and_check_backslash_N_name|5.017006||cViu get_and_check_backslash_N_name_wrapper|5.029009||Viu get_ANYOF_cp_list_for_ssc|5.019005||Viu get_ANYOFM_contents|5.027009||Viu get_aux_mg|5.011000||Viu get_av|5.006000|5.003007|p get_c_backtrace|5.021001||Vi get_c_backtrace_dump|5.021001||V get_context|5.006000|5.006000|nu get_cv|5.006000|5.003007|p get_cvn_flags|5.009005|5.003007|p get_cvs|5.011000||pVu getcwd_sv|5.007002|5.007002| get_db_sub|||iu get_debug_opts|5.008001||Viu getenv_len|5.006000||Viu get_hash_seed|5.008001||Viu get_hv|5.006000|5.003007|p get_invlist_iter_addr|5.015001||nViu get_invlist_offset_addr|5.019002||nViu get_invlist_previous_index_addr|5.017004||nViu get_mstats|5.006000||Vu get_no_modify|5.005000||Viu get_num|5.008001||Viu get_opargs|5.005000||Viu get_op_descs|5.005000|5.005000|u get_op_names|5.005000|5.005000|u get_ppaddr|5.006000|5.006000|u get_re_arg|||xciu _get_regclass_nonbitmap_data|5.019009||cViu get_regex_charset_name|5.031004||nViu get_sv|5.006000|5.003007|p GetVars|5.006000||Vu get_vtbl|5.005003|5.005003|u G_EVAL|5.003007|5.003007| GIMME|5.003007|5.003007| GIMME_V|5.004000|5.004000| gimme_V|5.031005|5.031005|xu glob_2number|5.009004||Viu glob_assign_glob|5.009004||Viu G_METHOD|5.006001|5.003007|p G_METHOD_NAMED|5.019002|5.019002| G_NOARGS|5.003007|5.003007| gp_dup|5.007003|5.007003|u gp_free|5.003007|5.003007|u gp_ref|5.003007|5.003007|u G_RETHROW|5.031002|5.003007|p grok_atoUV|5.021010||ncVi grok_bin|5.007003|5.003007|p grok_bin_oct_hex|||cVu grok_bslash_c|5.013001||cViu grok_bslash_N|5.017003||Viu grok_bslash_o|5.013003||cViu grok_bslash_x|5.017002||cViu grok_hex|5.007003|5.003007|p grok_infnan|5.021004|5.021004| grok_number|5.007002|5.003007|p grok_number_flags|5.021002|5.021002| GROK_NUMERIC_RADIX|5.007002|5.003007|p grok_numeric_radix|5.007002|5.003007|p grok_oct|5.007003|5.003007|p group_end|5.007003||Viu G_SCALAR|5.003007|5.003007| GV_ADD|5.003007|5.003007| gv_add_by_type|5.011000|5.011000|u GV_ADDMG|5.015003|5.015003| GV_ADDMULTI|5.003007|5.003007| Gv_AMupdate|5.011000|5.011000|u gv_autoload4|5.004000|5.004000|u gv_autoload_pv|5.015004|5.015004|u gv_autoload_pvn|5.015004|5.015004|u gv_autoload_sv|5.015004|5.015004|u GvAV|5.003007|5.003007| gv_AVadd|5.003007|5.003007|u gv_check|5.003007|5.003007|u gv_const_sv|5.009003|5.009003| GvCV|5.003007|5.003007| gv_dump|5.006000|5.006000|u gv_efullname3|5.003007|5.003007|u gv_efullname4|5.006001|5.006001|u gv_efullname|5.003007|5.003007|du gv_fetchfile|5.003007|5.003007|u gv_fetchfile_flags|5.009005|5.009005|u gv_fetchmeth|5.003007|5.003007| gv_fetchmeth_autoload|5.007003|5.007003| gv_fetchmeth_internal|5.021007||Viu gv_fetchmethod|5.003007|5.003007| gv_fetchmethod_autoload|5.004000|5.004000| gv_fetchmethod_pv_flags|5.015004|5.015004|xu gv_fetchmethod_pvn_flags|5.015004|5.015004|xu gv_fetchmethod_sv_flags|5.015004|5.015004|xu gv_fetchmeth_pv|5.015004|5.015004| gv_fetchmeth_pv_autoload|5.015004|5.015004| gv_fetchmeth_pvn|5.015004|5.015004| gv_fetchmeth_pvn_autoload|5.015004|5.015004| gv_fetchmeth_sv|5.015004|5.015004| gv_fetchmeth_sv_autoload|5.015004|5.015004| gv_fetchpv|5.003007|5.003007|u gv_fetchpvn_flags|5.009002|5.003007|pu gv_fetchpvs|5.009004||pVu gv_fetchsv|5.009002|5.003007|pu gv_fullname3|5.003007|5.003007|u gv_fullname4|5.006001|5.006001|u gv_fullname|5.003007|5.003007|du gv_handler|5.007001|5.007001|u GvHV|5.003007|5.003007| gv_HVadd|5.003007|5.003007|u gv_init|5.003007|5.003007| gv_init_pv|5.015004|5.015004| gv_init_pvn|5.015004|5.003007|p gv_init_sv|5.015004|5.015004| gv_init_svtype|5.015004||Viu gv_IOadd|5.003007|5.003007|u gv_is_in_main|5.019004||Viu gv_magicalize|5.019004||Viu gv_magicalize_isa|5.013005||Viu gv_name_set|5.009004|5.009004|u GV_NOADD_MASK|5.009005|5.003007|poVu GV_NOADD_NOINIT|5.009003|5.009003| GV_NOEXPAND|5.009003|5.009003| GV_NOINIT|5.004005|5.004005| G_VOID|5.004000|5.004000| gv_override|5.019006||Viu gv_setref|5.021005||Viu gv_stashpv|5.003007|5.003007| gv_stashpvn|5.003007|5.003007|p gv_stashpvn_internal|5.021004||Viu gv_stashpvs|5.009003|5.003007|p gv_stashsv|5.003007|5.003007| gv_stashsvpvn_cached|5.021004||Viu GV_SUPER|5.017004|5.017004| GvSV|5.003007|5.003007| gv_SVadd|||u GvSVn|5.009003||pVu gv_try_downgrade|5.011002||xcVi handle_named_backref|5.023008||Viu handle_possible_posix|5.023008||Viu handle_regex_sets|5.017009||Viu handle_user_defined_property|5.029008||cViu he_dup|5.007003|5.007003|u HEf_SVKEY|5.003007|5.003007|p HeHASH|5.003007|5.003007| hek_dup|5.009000|5.009000|u HeKEY|5.003007|5.003007| HeKLEN|5.003007|5.003007| HePV|5.004000|5.004000| HeSVKEY|5.003007|5.003007| HeSVKEY_force|5.003007|5.003007| HeSVKEY_set|5.004000|5.004000| HeUTF8|5.010001|5.008000|p HeVAL|5.003007|5.003007| hfree_next_entry|||iu hsplit|5.005000||Viu hv_assert|5.008009|5.008009| hv_auxinit|5.009003||Viu hv_auxinit_internal|5.019010||nViu hv_backreferences_p|||xiu hv_bucket_ratio|5.025003|5.025003|x hv_clear|5.003007|5.003007| hv_clear_placeholders|5.009001|5.009001| hv_common|5.010000|5.010000|u hv_common_key_len|5.010000|5.010000|u hv_copy_hints_hv|5.009004|5.009004| hv_delayfree_ent|5.004000|5.004000|u hv_delete|5.003007|5.003007| hv_delete_common|5.009001||xViu hv_delete_ent|5.003007|5.003007| hv_eiter_p|5.009003|5.009003|u hv_eiter_set|5.009003|5.009003|u HvENAME|5.013007|5.013007| hv_ename_add|5.013007||Vi hv_ename_delete|5.013007||Vi HvENAMELEN|5.015004|5.015004| HvENAMEUTF8|5.015004|5.015004| hv_exists|5.003007|5.003007| hv_exists_ent|5.003007|5.003007| hv_fetch|5.003007|5.003007| hv_fetch_ent|5.003007|5.003007| hv_fetchs|5.009003|5.003007|p HvFILL|5.003007|5.003007| hv_fill|5.013002|5.013002| hv_free_ent|5.004000|5.004000|u hv_free_ent_ret|5.015000||Viu hv_free_entries|5.027002||Viu hv_iterinit|5.003007|5.003007| hv_iterkey|5.003007|5.003007| hv_iterkeysv|5.003007|5.003007| hv_iternext|5.003007|5.003007| hv_iternext_flags|5.008000|5.008000|x hv_iternextsv|5.003007|5.003007| HV_ITERNEXT_WANTPLACEHOLDERS|5.008000|5.008000| hv_iterval|5.003007|5.003007| hv_kill_backrefs|||xiu hv_ksplit|5.003007|5.003007|u hv_magic|5.003007|5.003007| hv_magic_check|5.006000||nViu HvNAME|5.003007|5.003007| HvNAME_get|5.009003||pVu HvNAMELEN|5.015004|5.015004| HvNAMELEN_get|5.009003||pVu hv_name_set|5.009003|5.009003|u HvNAMEUTF8|5.015004|5.015004| hv_notallowed|5.008000||Viu hv_placeholders_get|5.009003|5.009003|u hv_placeholders_p|||ciu hv_placeholders_set|5.009003|5.009003|u hv_pushkv|5.027003||Viu hv_rand_set|5.018000|5.018000|u hv_riter_p|5.009003|5.009003|u hv_riter_set|5.009003|5.009003|u hv_scalar|5.009001|5.009001| hv_store|5.003007|5.003007| hv_store_ent|5.003007|5.003007| hv_store_flags|5.008000|5.008000|xu hv_stores|5.009004|5.003007|p hv_undef|5.003007|5.003007| hv_undef_flags|||ciu I16SIZE|5.006000|5.006000| I16TYPE|5.006000|5.006000| I32SIZE|5.006000|5.006000| I32TYPE|5.006000|5.006000| I8SIZE|5.006000|5.006000| I8TYPE|5.006000|5.006000| ibcmp|5.003007|5.003007| ibcmp_locale|5.004000|5.004000| ibcmp_utf8|5.007003|5.007003|u incline|5.005000||Viu incpush|5.005000||Viu incpush_if_exists|5.009003||Viu incpush_use_sep|5.011000||Viu ingroup|5.003007||Viu init_argv_symbols|5.007003||Viu init_constants|5.017003||Viu init_dbargs|||iu init_debugger|5.005000||Viu init_global_struct|5.009003||Vu init_i18nl10n|5.006000||cVu init_i18nl14n|5.006000||dcVu initialize_invlist_guts|5.029002||Viu init_ids|5.005000||Viu init_interp|5.005000||Viu init_main_stash|5.005000||Viu init_named_cv|5.027010||cViu init_perllib|5.005000||Viu init_postdump_symbols|5.005000||Viu init_predump_symbols|5.005000||Viu init_stacks|5.005000|5.005000|u init_tm|5.007002|5.007002|u init_uniprops|5.027011||Viu IN_LOCALE|5.007002|5.004000|p IN_LOCALE_COMPILETIME|5.007002|5.004000|p IN_LOCALE_RUNTIME|5.007002|5.004000|p IN_PERL_COMPILETIME|5.008001|5.003007|poVu inplace_aassign|5.015003||Viu instr|5.003007|5.003007|n INT2PTR|5.006000|5.003007|p intro_my|5.004000|5.004000| INTSIZE|5.003007|5.003007| intuit_method|5.005000||Viu intuit_more|5.003007||Viu _inverse_folds|5.027011||cViu invert|5.003007||Viu invlist_array|5.013010||nViu _invlist_array_init|5.015001||nViu invlist_clear|5.023009||Viu invlist_clone|5.015001||cViu _invlist_contains_cp|5.017003||nViu invlist_contents|5.023008||Viu _invlist_dump|5.019003||cViu _invlistEQ|5.023006||cViu invlist_extend|5.013010||Viu invlist_highest|5.017002||nViu _invlist_intersection|5.015001||Viu _invlist_intersection_maybe_complement_2nd|5.015008||cViu _invlist_invert|5.015001||cViu invlist_is_iterating|5.017008||nViu invlist_iterfinish|5.017008||nViu invlist_iterinit|5.015001||nViu invlist_iternext|5.015001||nViu _invlist_len|5.017004||nViu invlist_lowest|||nxViu invlist_max|5.013010||nViu invlist_previous_index|5.017004||nViu invlist_replace_list_destroys_src|5.023009||Viu _invlist_search|5.017003||ncViu invlist_set_len|5.013010||Viu invlist_set_previous_index|5.017004||nViu _invlist_subtract|5.015001||Viu invlist_trim|5.013010||nViu _invlist_union|5.015001||cVu _invlist_union_maybe_complement_2nd|5.015008||cViu invmap_dump|5.031006||Viu invoke_exception_hook|5.013001||Viu io_close|5.003007||Viu isALNUM|5.003007|5.003007|p isALNUM_A|5.031003|5.003007|p isALNUMC|5.006000|5.003007|p isALNUMC_A|5.013006|5.003007|p isALNUMC_L1|5.013006|5.003007|p isALNUMC_LC|5.006000|5.006000| isALNUMC_LC_uvchr|5.017007|5.017007| isALNUM_LC|5.004000|5.004000| isALNUM_LC_uvchr|5.007001|5.007001| isa_lookup|5.005000||Viu isALPHA|5.003007|5.003007|p isALPHA_A|5.013006|5.003007|p isALPHA_L1|5.013006|5.003007|p isALPHA_LC|5.004000|5.004000| isALPHA_LC_utf8_safe|5.025009|5.006000|p isALPHA_LC_uvchr|5.007001|5.007001| isALPHANUMERIC|5.017008|5.003007|p isALPHANUMERIC_A|5.017008|5.003007|p isALPHANUMERIC_L1|5.017008|5.003007|p isALPHANUMERIC_LC|5.017008|5.004000|p isALPHANUMERIC_LC_utf8_safe|5.025009|5.006000|p isALPHANUMERIC_LC_uvchr|5.017008|5.017008| isALPHANUMERIC_utf8|5.031005|5.031005| isALPHANUMERIC_utf8_safe|5.025009|5.006000|p isALPHANUMERIC_uvchr|5.023009|5.006000|p isALPHA_utf8|5.031005|5.031005| isALPHA_utf8_safe|5.025009|5.006000|p isALPHA_uvchr|5.023009|5.006000|p is_an_int|5.005000||Viu isASCII|5.006000|5.003007|p isASCII_A|5.013006|5.003007|p isASCII_L1|5.015004|5.003007|p isASCII_LC|5.015008|5.003007|p isASCII_LC_utf8_safe|5.025009|5.025009| isASCII_LC_uvchr|5.017007|5.017007| is_ascii_string|5.011000|5.011000|n isASCII_utf8|5.031005|5.031005| isASCII_utf8_safe|5.025009|5.003007|p isASCII_uvchr|5.023009|5.003007|p isBLANK|5.006001|5.003007|p isBLANK_A|5.013006|5.003007|p isBLANK_L1|5.013006|5.003007|p isBLANK_LC|5.006001|5.003007|p isBLANK_LC_utf8_safe|5.025009|5.006000|p isBLANK_LC_uvchr|5.017007|5.017007| isBLANK_utf8|5.031005|5.031005| isBLANK_utf8_safe|5.025009|5.006000|p isBLANK_uvchr|5.023009|5.006000|p isC9_STRICT_UTF8_CHAR|5.025005|5.025005|n is_c9strict_utf8_string|5.025006|5.025006|n is_c9strict_utf8_string_loc|5.025006|5.025006|n is_c9strict_utf8_string_loclen|5.025006|5.025006|n isCNTRL|5.006000|5.003007|p isCNTRL_A|5.013006|5.003007|p isCNTRL_L1|5.013006|5.003007|p isCNTRL_LC|5.006000|5.006000| isCNTRL_LC_utf8_safe|5.025009|5.006000|p isCNTRL_LC_uvchr|5.007001|5.007001| isCNTRL_utf8|5.031005|5.031005| isCNTRL_utf8_safe|5.025009|5.006000|p isCNTRL_uvchr|5.023009|5.006000|p _is_cur_LC_category_utf8|5.021001||cVu isDIGIT|5.003007|5.003007|p isDIGIT_A|5.013006|5.003007|p isDIGIT_L1|5.013006|5.003007|p isDIGIT_LC|5.004000|5.004000| isDIGIT_LC_utf8_safe|5.025009|5.006000|p isDIGIT_LC_uvchr|5.007001|5.007001| isDIGIT_utf8|5.031005|5.031005| isDIGIT_utf8_safe|5.025009|5.006000|p isDIGIT_uvchr|5.023009|5.006000|p isFF_OVERLONG|5.025007||nViu isFOO_lc|5.017007||cViu isFOO_utf8_lc|5.017008||Viu isGCB|5.021009||Viu isGRAPH|5.006000|5.003007|p isGRAPH_A|5.013006|5.003007|p is_grapheme|||Viu isGRAPH_L1|5.013006|5.003007|p isGRAPH_LC|5.006000|5.006000| isGRAPH_LC_utf8_safe|5.025009|5.006000|p isGRAPH_LC_uvchr|5.007001|5.007001| isGRAPH_utf8|5.031005|5.031005| isGRAPH_utf8_safe|5.025009|5.006000|p isGRAPH_uvchr|5.023009|5.006000|p isGV_with_GP|5.009004||pVu is_handle_constructor|5.006000||nViu isIDCONT|5.017008|5.003007|p isIDCONT_A|5.017008|5.003007|p isIDCONT_L1|5.017008|5.003007|p isIDCONT_LC|5.017008|5.004000|p isIDCONT_LC_utf8_safe|5.025009|5.006000|p isIDCONT_LC_uvchr|5.017008|5.017008| isIDCONT_utf8|5.031005|5.031005| isIDCONT_utf8_safe|5.025009|5.006000|p isIDCONT_uvchr|5.023009|5.006000|p isIDFIRST|5.003007|5.003007|p isIDFIRST_A|5.013006|5.003007|p isIDFIRST_L1|5.013006|5.003007|p isIDFIRST_LC|5.004000|5.004000|p isIDFIRST_LC_utf8_safe|5.025009|5.006000|p isIDFIRST_LC_uvchr|5.007001|5.007001| isIDFIRST_utf8|5.031005|5.031005| isIDFIRST_utf8_safe|5.025009|5.006000|p isIDFIRST_uvchr|5.023009|5.006000|p isinfnan|5.021004|5.021004|n isinfnansv|5.021005||Vi _is_in_locale_category|5.021001||cViu is_invariant_string|5.021007|5.011000|pn is_invlist|5.029002||nViu isLB|5.023007||Viu isLOWER|5.003007|5.003007|p isLOWER_A|5.013006|5.003007|p isLOWER_L1|5.013006|5.003007|p isLOWER_LC|5.004000|5.004000| isLOWER_LC_utf8_safe|5.025009|5.006000|p isLOWER_LC_uvchr|5.007001|5.007001| isLOWER_utf8|5.031005|5.031005| isLOWER_utf8_safe|5.025009|5.006000|p isLOWER_uvchr|5.023009|5.006000|p is_lvalue_sub|5.007001|5.007001|u IS_NUMBER_GREATER_THAN_UV_MAX|5.007002|5.003007|p IS_NUMBER_INFINITY|5.007002|5.003007|p IS_NUMBER_IN_UV|5.007002|5.003007|p IS_NUMBER_NAN|5.007003|5.003007|p IS_NUMBER_NEG|5.007002|5.003007|p IS_NUMBER_NOT_INT|5.007002|5.003007|p isOCTAL|5.013005|5.003007|p isOCTAL_A|5.013006|5.003007|p isOCTAL_L1|5.013006|5.003007|p isPRINT|5.004000|5.003007|p isPRINT_A|5.013006|5.003007|p isPRINT_L1|5.013006|5.003007|p isPRINT_LC|5.004000|5.004000| isPRINT_LC_utf8_safe|5.025009|5.006000|p isPRINT_LC_uvchr|5.007001|5.007001| isPRINT_utf8|5.031005|5.031005| isPRINT_utf8_safe|5.025009|5.006000|p isPRINT_uvchr|5.023009|5.006000|p isPSXSPC|5.006001|5.003007|p isPSXSPC_A|5.013006|5.003007|p isPSXSPC_L1|5.013006|5.003007|p isPSXSPC_LC|5.006001|5.006001| isPSXSPC_LC_utf8_safe|5.025009|5.006000|p isPSXSPC_LC_uvchr|5.017007|5.017007| isPSXSPC_utf8|5.031005|5.031005| isPSXSPC_utf8_safe|5.025009|5.006000|p isPSXSPC_uvchr|5.023009|5.006000|p isPUNCT|5.006000|5.003007|p isPUNCT_A|5.013006|5.003007|p isPUNCT_L1|5.013006|5.003007|p isPUNCT_LC|5.006000|5.006000| isPUNCT_LC_utf8_safe|5.025009|5.006000|p isPUNCT_LC_uvchr|5.007001|5.007001| isPUNCT_utf8|5.031005|5.031005| isPUNCT_utf8_safe|5.025009|5.006000|p isPUNCT_uvchr|5.023009|5.006000|p IS_SAFE_SYSCALL|5.019004|5.019004| is_safe_syscall|5.019004|5.019004| isSB|5.021009||Viu isSCRIPT_RUN|5.027008||cVi isSPACE|5.003007|5.003007|p isSPACE_A|5.013006|5.003007|p isSPACE_L1|5.013006|5.003007|p isSPACE_LC|5.004000|5.004000| isSPACE_LC_utf8_safe|5.025009|5.006000|p isSPACE_LC_uvchr|5.007001|5.007001| isSPACE_utf8|5.031005|5.031005| isSPACE_utf8_safe|5.025009|5.006000|p isSPACE_uvchr|5.023009|5.006000|p is_ssc_worth_it|5.021005||nViu isSTRICT_UTF8_CHAR|5.025005|5.025005|n is_strict_utf8_string|5.025006|5.025006|n is_strict_utf8_string_loc|5.025006|5.025006|n is_strict_utf8_string_loclen|5.025006|5.025006|n _is_uni_FOO|5.017008||cVu _is_uni_perl_idcont|5.017008||cVu _is_uni_perl_idstart|5.017007||cVu isUPPER|5.003007|5.003007|p isUPPER_A|5.013006|5.003007|p isUPPER_L1|5.013006|5.003007|p isUPPER_LC|5.004000|5.004000| isUPPER_LC_utf8_safe|5.025009|5.006000|p isUPPER_LC_uvchr|5.007001|5.007001| isUPPER_utf8|5.031005|5.031005| isUPPER_utf8_safe|5.025009|5.006000|p isUPPER_uvchr|5.023009|5.006000|p is_utf8_char|5.006000|5.006000|nd isUTF8_CHAR|5.021001|5.006001|pn is_utf8_char_buf|5.015008|5.015008|n isUTF8_CHAR_flags|5.025005|5.025005| is_utf8_char_helper|5.031004||ncVu is_utf8_common|5.009003||Viu is_utf8_cp_above_31_bits|5.025005||nViu is_utf8_fixed_width_buf_flags|5.025006|5.025006|n is_utf8_fixed_width_buf_loc_flags|5.025006|5.025006|n is_utf8_fixed_width_buf_loclen_flags|5.025006|5.025006|n _is_utf8_FOO|5.031006||cVu is_utf8_invariant_string|5.025005|5.011000|pn is_utf8_invariant_string_loc|5.027001|5.027001|n is_utf8_non_invariant_string|5.027007||ncVi is_utf8_overlong_given_start_byte_ok|5.025006||nViu _is_utf8_perl_idcont|5.031006||cVu _is_utf8_perl_idstart|5.031006||cVu is_utf8_string|5.006001|5.006001|n is_utf8_string_flags|5.025006|5.025006|n is_utf8_string_loc|5.008001|5.008001|n is_utf8_string_loc_flags|5.025006|5.025006|n is_utf8_string_loclen|5.009003|5.009003|n is_utf8_string_loclen_flags|5.025006|5.025006|n is_utf8_valid_partial_char|5.025005|5.025005|n is_utf8_valid_partial_char_flags|5.025005|5.025005|n isWB|5.021009||Viu isWORDCHAR|5.013006|5.003007|p isWORDCHAR_A|5.013006|5.003007|p isWORDCHAR_L1|5.013006|5.003007|p isWORDCHAR_LC|5.017007|5.004000|p isWORDCHAR_LC_utf8_safe|5.025009|5.006000|p isWORDCHAR_LC_uvchr|5.017007|5.017007| isWORDCHAR_utf8|5.031005|5.031005| isWORDCHAR_utf8_safe|5.025009|5.006000|p isWORDCHAR_uvchr|5.023009|5.006000|p isXDIGIT|5.006000|5.003007|p isXDIGIT_A|5.013006|5.003007|p isXDIGIT_L1|5.013006|5.003007|p isXDIGIT_LC|5.017007|5.003007|p isXDIGIT_LC_utf8_safe|5.025009|5.006000|p isXDIGIT_LC_uvchr|5.017007|5.017007| isXDIGIT_utf8|5.031005|5.031005| isXDIGIT_utf8_safe|5.025009|5.006000|p isXDIGIT_uvchr|5.023009|5.006000|p items|5.003007|5.003007|V IVdf|5.006000|5.003007|p IVSIZE|5.006000|5.003007|p IVTYPE|5.006000|5.003007|p ix|5.003007|5.003007|V jmaybe|5.003007||Viu join_exact|5.009004||Viu keyword|5.003007||Viu keyword_plugin_standard|||iu LATIN1_TO_NATIVE|5.019004|5.003007|p LEAVE|5.003007|5.003007| leave_adjust_stacks|5.023008|5.023008|xu leave_scope|5.003007|5.003007|u LEAVE_with_name|5.011002|5.011002| lex_bufutf8|5.011002|5.011002|x lex_discard_to|5.011002|5.011002|x lex_grow_linestr|5.011002|5.011002|x LEX_KEEP_PREVIOUS|5.011002|5.011002| lex_next_chunk|5.011002|5.011002|x lex_peek_unichar|5.011002|5.011002|x lex_read_space|5.011002|5.011002|x lex_read_to|5.011002|5.011002|x lex_read_unichar|5.011002|5.011002|x lex_start|5.009005|5.009005|x lex_stuff_pv|5.013006|5.013006|x lex_stuff_pvn|5.011002|5.011002|x lex_stuff_pvs|5.013005|5.013005|x lex_stuff_sv|5.011002|5.011002|x LEX_STUFF_UTF8|5.011002|5.011002| lex_unstuff|5.011002|5.011002|x LIKELY|5.009004|5.003007|p LINKLIST|5.013006|5.013006| list|5.003007||Viu listkids|5.003007||Viu load_module|5.006000|5.003007|pv load_module_nocontext|5.006000||vnVu localize|5.003007||Viu LONGDBLINFBYTES|5.023000|5.023000| LONGDBLMANTBITS|5.023000|5.023000| LONGDBLNANBYTES|5.023000|5.023000| LONGSIZE|5.004000|5.003007| looks_like_bool|5.027008||Viu looks_like_number|5.003007|5.003007| lop|5.005000||Viu lossless_NV_to_IV|5.031001||nViu LSEEKSIZE|5.006000|5.006000| LVRET|||i magic_clear_all_env|5.004001||Viu magic_cleararylen_p|5.017002||Viu magic_clearenv|5.003007||Viu magic_clearhint|5.009004||Vi magic_clearhints|5.011000||Vi magic_clearisa|5.010001||Viu magic_clearpack|5.003007||Viu magic_clearsig|5.003007||Viu magic_copycallchecker|5.017000||Viu magic_dump|5.006000|5.006000|u magic_existspack|5.003007||Viu magic_freearylen_p|5.009003||Viu magic_freeovrld|5.007001||Viu magic_get|5.003007||Viu magic_getarylen|5.003007||Viu magic_getdebugvar|5.021005||Viu magic_getdefelem|5.004000||Viu magic_getnkeys|5.004005||Viu magic_getpack|5.003007||Viu magic_getpos|5.003007||Viu magic_getsig|5.003007||Viu magic_getsubstr|5.004005||Viu magic_gettaint|5.003007||Viu magic_getuvar|5.003007||Viu magic_getvec|5.004005||Viu magic_killbackrefs|5.006000||Viu magic_methcall1|5.013001||Viu magic_methcall|||vi magic_methpack|5.005000||Viu magic_nextpack|5.003007||Viu magic_regdata_cnt|5.006000||Viu magic_regdatum_get|5.006000||Viu magic_regdatum_set|5.006001||Viu magic_scalarpack|5.009001||Viu magic_set|5.003007||Viu magic_set_all_env|5.004004||Viu magic_setarylen|5.003007||Viu magic_setcollxfrm|5.004000||Viu magic_setdbline|5.003007||Viu magic_setdebugvar|5.021005||Viu magic_setdefelem|5.004000||Viu magic_setenv|5.003007||Viu magic_sethint|5.009004||Vi magic_setisa|5.003007||Viu magic_setlvref|5.021005||Viu magic_setmglob|5.003007||Viu magic_setnkeys|5.003007||Viu magic_setnonelem|5.027009||Viu magic_setpack|5.003007||Viu magic_setpos|5.003007||Viu magic_setregexp|5.008001||Viu magic_setsig|5.003007||Viu magic_setsubstr|5.003007||Viu magic_settaint|5.003007||Viu magic_setutf8|5.008001||Viu magic_setuvar|5.003007||Viu magic_setvec|5.003007||Viu magic_sizepack|5.005000||Viu magic_wipepack|5.003007||Viu make_exactf_invlist|5.031006||Viu make_matcher|5.027008||Viu make_trie|5.009002||Viu malloc|5.007002|5.007002|n malloced_size|5.005000||nViu malloc_good_size|5.010001||nViu MARK|5.003007|5.003007| markstack_grow|5.021001|5.021001|u matcher_matches_sv|5.027008||Viu maybe_multimagic_gv|5.019004||Viu mayberelocate|5.015006||Viu measure_struct|5.007003||Viu memCHRs||5.003007|p mem_collxfrm|5.003007||dViu _mem_collxfrm|5.025002||Viu memEQ|5.004000|5.003007|p memEQs|5.009005|5.003007|p mem_log_alloc|5.024000||nViu mem_log_common|5.010001||nViu mem_log_free|5.024000||nViu mem_log_realloc|5.024000||nViu memNE|5.004000|5.003007|p memNEs|5.009005|5.003007|p mess|5.006000|5.004000|pv mess_alloc|5.005000||Viu mess_nocontext|5.006000||pvnVu mess_sv|5.013001|5.004000|p mfree|5.007002|5.007002|nu mg_clear|5.003007|5.003007| mg_copy|5.003007|5.003007| mg_dup|5.007003|5.007003|u mg_find|5.003007|5.003007|n mg_findext|5.013008|5.003007|pn mg_find_mglob|5.019002||cViu mg_free|5.003007|5.003007| mg_freeext|5.027004|5.027004| mg_free_type|5.013006|5.013006| mg_get|5.003007|5.003007| mg_length|5.005000|5.005000|d mg_localize|5.009003||Vi mg_magical|5.003007|5.003007|n mg_set|5.003007|5.003007| mg_size|5.005000|5.005000|u mini_mktime|5.007002|5.007002|nu minus_v|5.015006||Viu missingterm|5.005000||Viu mode_from_discipline|5.006000||Viu modkids|5.003007||Viu more_bodies|||iu more_sv|5.009004||Viu moreswitches|5.003007|5.003007|u Move|5.003007|5.003007| MoveD|5.009002|5.003007|p move_proto_attr|5.019005||Viu mPUSHi|5.009002|5.003007|p mPUSHn|5.009002|5.003007|p mPUSHp|5.009002|5.003007|p mPUSHs|5.010001|5.003007|p mPUSHu|5.009002|5.003007|p mro_clean_isarev|5.013007||Viu mro_gather_and_rename|5.013007||Viu mro_get_from_name|5.010001|5.010001|u mro_get_linear_isa|5.009005|5.009005| mro_get_linear_isa_dfs|5.009005||Vi mro_get_private_data|5.010001|5.010001| mro_isa_changed_in|5.009005||Vi mro_meta_dup|5.009005||Viu mro_meta_init|||ciu mro_method_changed_in|5.009005|5.009005| mro_package_moved|5.013006||Vi mro_register|5.010001|5.010001| mro_set_mro|5.010001|5.010001|u mro_set_private_data|5.010001|5.010001| mul128|5.005000||Viu MULTICALL|5.009003|5.009003| multiconcat_stringify|5.027006||cViu multideref_stringify|5.021009||cViu MUTABLE_PTR|5.010001||pVu MUTABLE_SV|5.010001||pVu mXPUSHi|5.009002|5.003007|p mXPUSHn|5.009002|5.003007|p mXPUSHp|5.009002|5.003007|p mXPUSHs|5.010001|5.003007|p mXPUSHu|5.009002|5.003007|p my_atof2|||cu my_atof3|5.029000||cVu my_atof|5.006000|5.006000|u my_attrs|5.006000||Viu my_bytes_to_utf8|5.021009||nViu my_chsize|5.003007||Vu my_clearenv|5.009003||Viu MY_CXT|5.009000|5.009000|p MY_CXT_CLONE|5.009002|5.009000|p my_cxt_index|||u MY_CXT_INIT|5.009000|5.009000|p my_cxt_init|5.009000|5.009000|u my_dirfd|5.009005|5.009005|nu my_exit|5.003007|5.003007| my_exit_jump|5.005000||Viu my_failure_exit|5.004000|5.004000|u my_fflush_all|5.006000|5.006000|u my_fork|5.007003|5.007003|nu my_kid|5.006000||Viu my_lstat_flags|5.013003||cViu my_lstat|||u my_memrchr|5.027006||nViu my_mkostemp_cloexec|||niu my_mkostemp|||niu my_mkstemp_cloexec|||niu my_mkstemp|||niu my_nl_langinfo|5.027006||nViu my_pclose|5.003007|5.003007|u my_popen|5.003007|5.003007|u my_popen_list|5.007001|5.007001|u my_setenv|5.003007|5.003007| my_snprintf|5.009004|5.003007|pvn my_socketpair|5.007003|5.007003|nu my_sprintf|5.009003|5.003007|pnd my_stat_flags|5.013003||cViu my_stat|||u my_strerror|5.021001||Viu my_strftime|5.007002|5.007002|u my_strlcat|5.009004|5.003007|pn my_strlcpy|5.009004|5.003007|pn my_strnlen|5.027006|5.003007|pn my_strtod|5.029010|5.029010|n my_unexec|5.003007||Viu my_vsnprintf|5.009004|5.009004|n NATIVE_TO_LATIN1|5.019004|5.003007|p NATIVE_TO_NEED|5.019004||ndcVu NATIVE_TO_UNI|5.007001|5.003007|p need_utf8|5.009003||nViu newANONATTRSUB|5.006000|5.006000|u newANONHASH|5.003007|5.003007|u newANONLIST|5.003007|5.003007|u newANONSUB|5.003007|5.003007|u newASSIGNOP|5.003007|5.003007| newATTRSUB|5.006000|5.006000|u newATTRSUB_x|5.019008||cVi newAV|5.003007|5.003007| newAVREF|5.003007|5.003007|u newBINOP|5.003007|5.003007| new_collate|5.006000||Viu newCONDOP|5.003007|5.003007| new_constant|||iu newCONSTSUB|5.004005|5.003007|p newCONSTSUB_flags|5.015006|5.015006| new_ctype|5.006000||Viu newCVREF|5.003007|5.003007|u newDEFSVOP|5.021006|5.021006| newFORM|5.003007|5.003007|u newFOROP|5.013007|5.013007| newGIVENOP|5.009003|5.009003| newGIVWHENOP|5.027008||Viu newGP|||xiu newGVgen|5.003007|5.003007|u newGVgen_flags|5.015004|5.015004|u newGVOP|5.003007|5.003007| newGVREF|5.003007|5.003007|u new_he|5.005000||Viu newHV|5.003007|5.003007| newHVhv|5.005000|5.005000|u newHVREF|5.003007|5.003007|u _new_invlist|5.013010||cViu _new_invlist_C_array|5.015008||cViu newIO|5.003007|5.003007|u newLISTOP|5.003007|5.003007| newLOGOP|5.003007|5.003007| new_logop|5.005000||Viu newLOOPEX|5.003007|5.003007| newLOOPOP|5.003007|5.003007| newMETHOP|5.021005|5.021005| newMETHOP_internal|5.021005||Viu newMETHOP_named|5.021005|5.021005| new_msg_hv|5.027009||Viu newMYSUB|5.017004|5.017004|u newNULLLIST|5.003007|5.003007| new_numeric|5.006000||Viu newOP|5.003007|5.003007| newPADNAMELIST|5.021007|5.021007|nx newPADNAMEouter|5.021007|5.021007|nx newPADNAMEpvn|5.021007|5.021007|nx newPADOP|5.006000||V newPMOP|5.003007|5.003007| newPROG|5.003007|5.003007|u newPVOP|5.003007|5.003007| newRANGE|5.003007|5.003007| new_regcurly|5.027001||nViu newRV|5.003007|5.003007|u newRV_inc|5.004000|5.003007|p newRV_noinc|5.004000|5.003007|p newSLICEOP|5.003007|5.003007| new_stackinfo|5.005000|5.005000|u newSTATEOP|5.003007|5.003007| newSTUB|5.017001||Viu newSUB|5.003007|5.003007|u newSV|5.003007|5.003007| newSVavdefelem|5.019004||Viu newSVhek|5.009003|5.009003| newSViv|5.003007|5.003007| newSVnv|5.006000|5.003007| newSVOP|5.003007|5.003007| newSVpadname|5.017004|5.017004|x newSVpv|5.003007|5.003007| newSVpvf|5.006000|5.004000|v newSVpvf_nocontext|5.006000||vnVu newSVpvn|5.004005|5.003007|p newSVpvn_flags|5.010001|5.003007|p newSVpvn_share|5.007001|5.003007|p newSVpvn_utf8|5.010001|5.003007|p newSVpvs|5.009003|5.003007|p newSVpvs_flags|5.010001|5.003007|p newSVpv_share|5.013006|5.013006| newSVpvs_share|5.009003|5.003007|p newSVREF|5.003007|5.003007|u newSVrv|5.003007|5.003007| newSVsv|5.003007|5.003007| newSVsv_flags|5.029009|5.003007|pu newSVsv_nomg|5.029009|5.003007|p newSV_type|5.009005|5.003007|p newSVuv|5.006000|5.003007|p newUNOP|5.003007|5.003007| newUNOP_AUX|5.021007|5.021007| new_version|5.009000|5.009000| new_warnings_bitfield|||xciu newWHENOP|5.027008|5.027008| newWHILEOP|5.013007|5.013007| Newx|5.009003|5.003007|p Newxc|5.009003|5.003007|p newXS|5.006000|5.006000| newXS_deffile|5.021006||cViu newXS_flags|5.009004|5.009004|xu newXS_len_flags|5.015006||Vi newXSproto|5.006000|5.006000| Newxz|5.009003|5.003007|p nextargv|5.003007||Viu nextchar|5.005000||Viu next_symbol|5.007003||Viu ninstr|5.003007|5.003007|n no_bareword_allowed|5.005004||Viu no_fh_allowed|5.003007||Viu no_op|5.003007||Viu NOOP|5.005000|5.003007|poVu noperl_die|5.021006||vnViu not_a_number|5.005000||Viu nothreadhook|5.008000|5.008000| notify_parser_that_changed_to_utf8|5.025010||Viu not_incrementable|5.021002||Viu nuke_stacks|5.005000||Viu Nullav|5.003007|5.003007|d Nullch|5.003007|5.003007| Nullcv|5.003007|5.003007|d Nullhv|5.003007|5.003007|d Nullsv|5.003007|5.003007| NUM2PTR|5.006000||pVu num_overflow|5.009001||nViu NVef|5.006001|5.003007|p NVff|5.006001|5.003007|p NVgf|5.006001|5.003007|p NVMANTBITS|5.023000|5.023000| NVSIZE|5.006001|5.006001| NVTYPE|5.006000|5.003007|p oopsAV|5.003007||Viu oopsHV|5.003007||Viu op_append_elem|5.013006|5.013006| op_append_list|5.013006|5.013006| OP_CLASS|5.013007|5.013007| op_class|5.025010|5.025010| op_clear|5.006000||cViu op_contextualize|5.013006|5.013006| op_convert_list|5.021006|5.021006| OP_DESC|5.007003|5.007003| op_dump|5.006000|5.006000| openn_cleanup|5.019010||Viu openn_setup|5.019010||Viu open_script|5.005000||Viu OPf_KIDS|5.003007|5.003007| op_free|5.003007|5.003007| OpHAS_SIBLING|5.021007|5.003007|p op_integerize|5.015003||Viu OpLASTSIB_set|5.021011|5.003007|p op_linklist|5.013006|5.013006| op_lvalue|5.013007|5.013007|x op_lvalue_flags|||ciu OpMAYBESIB_set|5.021011|5.003007|p opmethod_stash|5.021007||Viu OpMORESIB_set|5.021011|5.003007|p OP_NAME|5.007003|5.007003| op_null|5.007002|5.007002| op_parent|5.025001|5.025001|n OPpEARLY_CV|5.006000|5.006000| OPpENTERSUB_AMPER|5.003007|5.003007| op_prepend_elem|5.013006|5.013006| op_refcnt_dec|||xiu op_refcnt_inc|||xiu op_refcnt_lock|5.009002|5.009002|u op_refcnt_unlock|5.009002|5.009002|u op_relocate_sv|5.021005||Viu op_scope|5.013007|5.013007|x OpSIBLING|5.021007|5.003007|p op_sibling_splice|5.021002|5.021002|n opslab_force_free|5.017002||Viu opslab_free|5.017002||Viu opslab_free_nopad|5.017002||Viu op_std_init|5.015003||Viu optimize_op|5.027006||Viu optimize_optree|5.027006||Vi OP_TYPE_IS|5.019007|5.019007| OP_TYPE_IS_OR_WAS|5.019010|5.019010| op_unscope|5.017003||xViu ORIGMARK|5.003007|5.003007| OSNAME|5.003007|5.003007| OSVERS|5.007002|5.007002| output_non_portable|||Viu output_posix_warnings|5.029005||Viu package|5.003007||Viu package_version|5.011001||Viu pack_cat||| packlist|5.008001|5.008001| pack_rec|5.008001||Viu packWARN|5.007003||pVu pad_add_anon|5.008001|5.008001| pad_add_name_pv|5.015001|5.015001| pad_add_name_pvn|5.015001|5.015001| pad_add_name_pvs|5.015001|5.015001| pad_add_name_sv|5.015001|5.015001| pad_add_weakref|5.021007||Viu pad_alloc|5.003007|5.003007|x pad_alloc_name|5.015001||Vi PadARRAY|5.017004|5.017004|x PAD_BASE_SV|||i pad_block_start|5.008001||Vi pad_check_dup|5.008001||Vi PAD_CLONE_VARS|||i PAD_COMPNAME_FLAGS|||i PAD_COMPNAME_GEN|||i PAD_COMPNAME_GEN_set|||i PAD_COMPNAME_OURSTASH|||i PAD_COMPNAME_PV|||i pad_compname_type||| PAD_COMPNAME_TYPE|||i pad_findlex|5.005000||Vi pad_findmy_pv|5.015001|5.015001| pad_findmy_pvn|5.015001|5.015001| pad_findmy_pvs|5.015001|5.015001| pad_findmy_sv|5.015001|5.015001| pad_fixup_inner_anons|5.008001||Vi pad_free|5.003007||Vi pad_leavemy|5.003007||Vi PadlistARRAY|5.017004|5.017004|x padlist_dup|5.013002||Vi PadlistMAX|5.017004|5.017004|x PadlistNAMES|5.017004|5.017004|x PadlistNAMESARRAY|5.017004|5.017004|x PadlistNAMESMAX|5.017004|5.017004|x PadlistREFCNT|5.017004|5.017004|x padlist_store|5.017004||Viu PadMAX|5.017004|5.017004|x padname_dup|5.021007||Vi padname_free|||ciu PadnameIN_SCOPE|5.031004||nViu PadnameIsOUR|||i PadnameIsSTATE|||i PadnameLEN|5.017004|5.017004|x PadnamelistARRAY|5.017004|5.017004|x padnamelist_dup|5.021007||Vi padnamelist_fetch|5.021007|5.021007|nx padnamelist_free|||ciu PadnamelistMAX|5.017004|5.017004|x PadnamelistREFCNT|5.021007|5.021007|x PadnamelistREFCNT_dec|5.021007|5.021007|x padnamelist_store|5.021007|5.021007|x PadnameOURSTASH|||i PadnameOUTER|||i PadnamePV|5.017004|5.017004|x PadnameREFCNT|5.021007|5.021007|x PadnameREFCNT_dec|5.021007|5.021007|x PadnameSV|5.017004|5.017004|x PADNAMEt_OUTER|5.021007|5.021007| PadnameTYPE|||i PadnameUTF8|5.017004|5.017004|x pad_new|5.008001|5.008001| pad_push|5.008001||cVi pad_reset|5.003007||Vi PAD_RESTORE_LOCAL|||i PAD_SAVE_LOCAL|||i PAD_SAVE_SETNULLPAD|||i PAD_SET_CUR|||i PAD_SET_CUR_NOSAVE|||i pad_setsv|5.008001|5.008001| PAD_SETSV|||i pad_sv|5.003007||V PAD_SV|||i PAD_SVl|||i pad_swipe|5.003007||Vi pad_tidy|5.008001|5.008001|x parse_arithexpr|5.013008|5.013008|x parse_barestmt|5.013007|5.013007|x parse_block|5.013007|5.013007|x parse_body|5.006000||Viu parse_fullexpr|5.013008|5.013008|x parse_fullstmt|5.013005|5.013005|x parse_gv_stash_name|5.019004||Viu parse_ident|5.017010||Viu parse_label|5.013007|5.013007|x parse_listexpr|5.013008|5.013008|x parse_lparen_question_flags|5.017009||Viu PARSE_OPTIONAL|5.013007|5.013007| parser_dup|5.009000|5.009000|u parser_free|5.009005||Viu parser_free_nexttoke_ops|5.017006||Viu parse_stmtseq|5.013006|5.013006|x parse_subsignature|5.031003|5.031003|x parse_termexpr|5.013008|5.013008|x parse_unicode_opts|5.008001||Viu parse_uniprop_string|5.027011||cViu path_is_searchable|5.019001||nViu peep|5.003007||Viu pending_ident|5.017004||Viu PERL_ABS|5.008001|5.003007|p perl_alloc|5.003007|5.003007|n perl_alloc_using|5.006000||nVu PERL_BCDVERSION||5.003007|pou perl_clone|5.006000||nV perl_clone_using|5.006000||nVu perl_construct|5.003007|5.003007|n Perl_custom_op_xop|5.013007||V perl_destruct|5.007003|5.007003|n Perl_eval_pv||5.003007|ou Perl_eval_sv||5.003007|ou PERL_EXIT_ABORT|5.019003|5.019003| PERL_EXIT_DESTRUCT_END|5.007003|5.007003| PERL_EXIT_EXPECTED|5.006000|5.006000| PERL_EXIT_WARN|5.019003|5.019003| perl_free|5.003007|5.003007|n PERL_HASH|5.003007|5.003007|p PERL_INT_MAX|5.003007|5.003007|p PERL_INT_MIN|5.003007|5.003007|p PerlIO_apply_layers|5.007001|5.007001| PerlIO_binmode|5.007001|5.007001| PerlIO_canset_cnt|5.003007|5.003007|n PerlIO_clearerr|5.007003|5.007003| PerlIO_close|5.007003|5.007003| PerlIO_context_layers|5.009004|5.009004|u PerlIO_debug|5.007001|5.007001| PerlIO_eof|5.007003|5.007003| PerlIO_error|5.007003|5.007003| PerlIO_exportFILE|5.003007|5.003007|n PerlIO_fast_gets|5.003007|5.003007|n PerlIO_fdopen|5.003007|5.003007|n PerlIO_fileno|5.007003|5.007003| PerlIO_fill|5.007003|5.007003|u PerlIO_findFILE|5.003007|5.003007|n PerlIO_flush|5.007003|5.007003| PERLIO_FUNCS_CAST|5.009003||pVu PERLIO_FUNCS_DECL|5.009003||pVu PerlIO_get_base|5.007003|5.007003| PerlIO_get_bufsiz|5.007003|5.007003| PerlIO_getc|5.003007|5.003007|n PerlIO_get_cnt|5.007003|5.007003| PerlIO_getpos|5.003007|5.003007|n PerlIO_get_ptr|5.007003|5.007003| PerlIO_has_base|5.003007|5.003007|n PerlIO_has_cntptr|5.003007|5.003007|n PerlIO_importFILE|5.003007|5.003007|n PerlIO_open|5.003007|5.003007|n PerlIO_printf|5.006000|5.003007| PerlIO_putc|5.003007|5.003007|n PerlIO_puts|5.003007|5.003007|n PerlIO_read|5.007003|5.007003| PerlIO_releaseFILE|5.003007|5.003007|n PerlIO_reopen|5.003007|5.003007| PerlIO_restore_errno|5.021006||cViu PerlIO_rewind|5.003007|5.003007|n PerlIO_save_errno|5.021006||cViu PerlIO_seek|5.007003|5.007003| PerlIO_set_cnt|5.007003|5.007003| PerlIO_setlinebuf|5.007003|5.007003| PerlIO_setpos|5.003007|5.003007|n PerlIO_set_ptrcnt|5.007003|5.007003| PerlIO_stderr|5.007003|5.007003| PerlIO_stdin|5.007003|5.007003| PerlIO_stdout|5.007003|5.007003| PerlIO_stdoutf|5.006000|5.003007| PerlIO_tell|5.007003|5.007003| PerlIO_ungetc|5.003007|5.003007|n PerlIO_unread|5.007003|5.007003|u PerlIO_vprintf|5.003007|5.003007|n PerlIO_write|5.007003|5.007003| Perl_langinfo|5.027004|5.027004|n PerlLIO_dup2_cloexec|5.027008||Viu PerlLIO_dup_cloexec|5.027008||Viu PerlLIO_open3_cloexec|5.027008||Viu PerlLIO_open_cloexec|5.027008||Viu PERL_LOADMOD_DENY|5.006000|5.003007| PERL_LOADMOD_IMPORT_OPS|5.006000|5.003007| PERL_LOADMOD_NOIMPORT|5.006000|5.003007| PERL_LONG_MAX|5.003007|5.003007|p PERL_LONG_MIN|5.003007|5.003007|p PERL_MAGIC_arylen|5.007002|5.003007|p PERL_MAGIC_arylen_p|5.009003|5.009003| PERL_MAGIC_backref|5.007002|5.003007|p PERL_MAGIC_bm|5.007002|5.003007|p PERL_MAGIC_checkcall|5.013006|5.013006| PERL_MAGIC_collxfrm|5.007002|5.003007|p PERL_MAGIC_dbfile|5.007002|5.003007|p PERL_MAGIC_dbline|5.007002|5.003007|p PERL_MAGIC_debugvar|5.021005|5.021005| PERL_MAGIC_defelem|5.007002|5.003007|p PERL_MAGIC_env|5.007002|5.003007|p PERL_MAGIC_envelem|5.007002|5.003007|p PERL_MAGIC_ext|5.007002|5.003007|p PERL_MAGIC_fm|5.007002|5.003007|p PERL_MAGIC_glob||5.003007|pou PERL_MAGIC_hints|5.009004|5.009004| PERL_MAGIC_hintselem|5.009004|5.009004| PERL_MAGIC_isa|5.007002|5.003007|p PERL_MAGIC_isaelem|5.007002|5.003007|p PERL_MAGIC_lvref|5.021005|5.021005| PERL_MAGIC_mutex||5.003007|pou PERL_MAGIC_nkeys|5.007002|5.003007|p PERL_MAGIC_nonelem|5.027009|5.027009| PERL_MAGIC_overload||5.003007|pou PERL_MAGIC_overload_elem||5.003007|pou PERL_MAGIC_overload_table|5.007002|5.003007|p PERL_MAGIC_pos|5.007002|5.003007|p PERL_MAGIC_qr|5.007002|5.003007|p PERL_MAGIC_regdata|5.007002|5.003007|p PERL_MAGIC_regdatum|5.007002|5.003007|p PERL_MAGIC_regex_global|5.007002|5.003007|p PERL_MAGIC_rhash|5.009003|5.009003| PERL_MAGIC_shared|5.007003|5.003007|p PERL_MAGIC_shared_scalar|5.007003|5.003007|p PERL_MAGIC_sig|5.007002|5.003007|p PERL_MAGIC_sigelem|5.007002|5.003007|p PERL_MAGIC_substr|5.007002|5.003007|p PERL_MAGIC_sv|5.007002|5.003007|p PERL_MAGIC_symtab|5.009003|5.009003| PERL_MAGIC_taint|5.007002|5.003007|p PERL_MAGIC_tied|5.007002|5.003007|p PERL_MAGIC_tiedelem|5.007002|5.003007|p PERL_MAGIC_tiedscalar|5.007002|5.003007|p PERL_MAGIC_utf8|5.008001|5.003007|p PERL_MAGIC_uvar|5.007002|5.003007|p PERL_MAGIC_uvar_elem|5.007003|5.003007|p PERL_MAGIC_vec|5.007002|5.003007|p PERL_MAGIC_vstring|5.008001|5.003007|p perl_parse|5.006000|5.006000|n PerlProc_pipe_cloexec|5.027008||Viu PERL_PV_ESCAPE_ALL|5.009004|5.003007|p PERL_PV_ESCAPE_FIRSTCHAR|5.009004|5.003007|p PERL_PV_ESCAPE_NOBACKSLASH|5.009004|5.003007|p PERL_PV_ESCAPE_NOCLEAR|5.009004|5.003007|p PERL_PV_ESCAPE_NONASCII|5.013009|5.013009| PERL_PV_ESCAPE_QUOTE|5.009004|5.003007|p PERL_PV_ESCAPE_RE|5.009005|5.003007|p PERL_PV_ESCAPE_UNI|5.009004|5.003007|p PERL_PV_ESCAPE_UNI_DETECT|5.009004|5.003007|p PERL_PV_PRETTY_DUMP|5.009004|5.003007|poVu PERL_PV_PRETTY_ELLIPSES|5.010000|5.003007|p PERL_PV_PRETTY_LTGT|5.009004|5.003007|p PERL_PV_PRETTY_NOCLEAR|5.010000|5.003007|poVu PERL_PV_PRETTY_QUOTE|5.009004|5.003007|p PERL_PV_PRETTY_REGPROP|5.009004|5.003007|poVu PERL_QUAD_MAX|5.003007|5.003007|p PERL_QUAD_MIN|5.003007|5.003007|p PERL_REVISION|5.006000|5.003007|p perl_run|5.003007|5.003007|n PERL_SCAN_ALLOW_UNDERSCORES|5.007003|5.003007|p PERL_SCAN_DISALLOW_PREFIX|5.007003|5.003007|p PERL_SCAN_GREATER_THAN_UV_MAX|5.007003|5.003007|p PERL_SCAN_SILENT_ILLDIGIT|5.008001|5.003007|p PERL_SCAN_TRAILING|5.021002|5.021002| Perl_setlocale|5.027002|5.027002|n PERL_SHORT_MAX|5.003007|5.003007|p PERL_SHORT_MIN|5.003007|5.003007|p PERL_SIGNALS_UNSAFE_FLAG|5.008001|5.003007|poVu Perl_signbit|5.009005|5.009005|nx PerlSock_accept_cloexec|5.027008||Viu PerlSock_socket_cloexec|5.027008||Viu PerlSock_socketpair_cloexec|5.027008||Viu PERL_SUBVERSION|5.006000|5.003007|p PERL_SYS_INIT3|5.006000|5.006000| PERL_SYS_INIT|5.003007|5.003007| PERL_SYS_TERM|5.003007|5.003007| PERL_UCHAR_MAX|5.003007|5.003007|p PERL_UCHAR_MIN|5.003007|5.003007|p PERL_UINT_MAX|5.003007|5.003007|p PERL_UINT_MIN|5.003007|5.003007|poVu PERL_ULONG_MAX|5.003007|5.003007|p PERL_ULONG_MIN|5.003007|5.003007|p PERL_UNUSED_ARG|5.009003||pVu PERL_UNUSED_CONTEXT|5.009004|5.003007|poVu PERL_UNUSED_DECL|5.007002|5.003007|poVu PERL_UNUSED_RESULT|5.021001||pVu PERL_UNUSED_VAR|5.007002||pVu PERL_UQUAD_MAX|5.003007|5.003007|p PERL_UQUAD_MIN|5.003007|5.003007|p PERL_USE_GCC_BRACE_GROUPS|5.009004|5.004000|poVu PERL_USHORT_MAX|5.003007|5.003007|p PERL_USHORT_MIN|5.003007|5.003007|p PERL_VERSION|5.006000|5.003007|p perly_sighandler|||nu pidgone|5.003007||Viu PL_bufend||5.003007|pou PL_bufptr||5.003007|pou PL_check|5.009003|5.006000| PL_compiling|5.004005|5.003007|poVu PL_comppad|5.008001|5.008001|x PL_comppad_name|5.017004|5.017004|x PL_copline||5.003007|pou PL_curcop|5.004005|5.003007|p PL_curpad|5.005000|5.005000|x PL_curstash|5.004005|5.003007|p PL_DBsignal|5.005000|5.003007|poVu PL_DBsingle|5.004005|5.003007|poV PL_DBsub|5.004005|5.003007|poV PL_DBtrace|5.005000|5.003007|poV PL_debstash|5.004005|5.003007|poVu PL_defgv|5.004005|5.003007|p PL_diehook|5.004005|5.003007|poVu PL_dirty|5.004005|5.003007|poVu PL_dowarn|5.004005|5.003007|poV PL_errgv|5.004005|5.003007|p PL_error_count||5.003007|pou PL_exit_flags|5.006000|5.006000| PL_expect||5.003007|pou PL_hexdigit|5.005000|5.003007|poVu PL_hints|5.005000|5.003007|poVu PL_in_my||5.003007|pou PL_in_my_stash||5.005000|pou PL_keyword_plugin|5.011002|5.011002|x PL_last_in_gv|||i PL_laststatval|5.005000|5.003007|poVu PL_lex_state||5.003007|pou PL_lex_stuff||5.003007|pou PL_linestr||5.003007|pou PL_mess_sv|5.005000|5.004000|poVu PL_modglobal|5.005000|5.005000| PL_na|5.004005|5.003007|p PL_no_modify|5.006000|5.003007|poVu PL_ofsgv|||i PL_opfreehook|5.011000|5.011000| PL_parser|5.009005|5.003007|p PL_peepp|5.007003|5.007003| PL_perldb|5.004005|5.003007|poVu PL_perl_destruct_level|5.004005|5.003007|p PL_phase|5.013007|5.013007| PL_ppaddr|5.006000|5.003007|poVu PL_rpeepp|5.013005|5.013005| PL_rsfp||5.003007|pou PL_rsfp_filters||5.003007|pou PL_rs|||i PL_runops|5.006000|5.006000| PL_signals|5.008001||pVu PL_stack_base|5.004005|5.003007|poVu PL_stack_sp|5.004005|5.003007|poVu PL_statcache|5.005000|5.003007|poVu PL_stdingv|5.004005|5.003007|poVu PL_Sv|5.005000|5.003007|poVu PL_sv_arenaroot|5.004005|5.003007|poVu PL_sv_no|5.004005|5.003007|p PL_sv_undef|5.004005|5.003007|p PL_sv_yes|5.004005|5.003007|p PL_sv_zero|5.027003|5.027003| PL_tainted|5.004005|5.003007|poVu PL_tainting|5.004005|5.003007|poVu PL_tokenbuf||5.003007|pou PL_Xpv|5.005000|5.003007|poVu pm_description|5.009004||Viu pmop_dump|5.006000|5.006000|u pmruntime|5.003007||Viu pmtrans|5.003007||Viu _pMY_CXT|5.007003|5.009000|pV pMY_CXT_|5.007003|5.009000|pV pMY_CXT|5.009000|5.009000|p Poison|5.008000|5.003007|p PoisonFree|5.009004|5.003007|p PoisonNew|5.009004|5.003007|p PoisonWith|5.009004|5.003007|p POPi|5.003007|5.003007| POPl|5.003007|5.003007| POPMARK|||ciu POP_MULTICALL|5.009003|5.009003| POPn|5.006000|5.003007| POPp|5.003007|5.003007| POPpbytex|5.007001|5.007001| POPpx|5.005003|5.005003| POPs|5.003007|5.003007| pop_scope|5.003007|5.003007|u POPu|5.004000|5.004000| POPul|5.006000|5.006000| populate_ANYOF_from_invlist|5.019005||Viu populate_isa|||viu pregcomp|5.009005|5.009005|u pregexec|5.003007|5.003007|u pregfree2|5.011000|5.011000|u pregfree|5.003007|5.003007|u prescan_version|5.011004|5.011004| printbuf|5.009004||Viu print_bytes_for_locale|5.027002||Viu print_collxfrm_input_and_return|5.025004||Viu printf_nocontext|5.007001|5.007001|vndu PRIVLIB|5.003007|5.003007| process_special_blocks|5.009005||Viu pTHX|5.006000|5.003007|p pTHX_|5.006000|5.003007|pV PTR2IV|5.006000|5.003007|p PTR2nat|5.009003||pVu PTR2NV|5.006000|5.003007|p PTR2ul|5.007001||pVu PTR2UV|5.006000|5.003007|p ptr_hash|5.017010||nViu PTRSIZE|5.005000|5.005000| ptr_table_clear|5.009005|5.009005|du ptr_table_fetch|5.009005|5.009005|u ptr_table_find|5.009004||nViu ptr_table_free|5.009005|5.009005|u ptr_table_new|5.009005|5.009005|u ptr_table_split|5.009005|5.009005|u ptr_table_store|5.009005|5.009005|u PTRV|5.006000|5.003007|poVu PUSHi|5.003007|5.003007| PUSHMARK|5.003007|5.003007| PUSHmortal|5.009002|5.003007|p PUSH_MULTICALL|5.011000|5.011000| PUSHn|5.006000|5.003007| PUSHp|5.003007|5.003007| PUSHs|5.003007|5.003007| push_scope|5.003007|5.003007|u PUSHu|5.004000|5.003007|p PUTBACK|5.003007|5.003007| put_charclass_bitmap_innards|5.021004||Viu put_charclass_bitmap_innards_common|5.023008||Viu put_charclass_bitmap_innards_invlist|5.023008||Viu put_code_point|5.021004||Viu put_range|5.019009||Viu pv_display|5.006000|5.003007|p pv_escape|5.009004|5.003007|p pv_pretty|5.009004|5.003007|p pv_uni_display|5.007003|5.007003| qerror|5.006000||cViu quadmath_format_needed|5.021004||nVi quadmath_format_valid|||nVi RANDBITS|5.003007|5.003007| READ_XDIGIT|5.017006|5.017006| realloc|5.007002|5.007002|n ReANY|||ncu re_compile|5.009005|5.009005|u re_croak2|||iu re_dup_guts|5.011000|5.011000|u reentrant_free|5.010000|5.010000|u reentrant_init|5.010000|5.010000|u reentrant_retry|5.010000|5.010000|vnu reentrant_size|5.010000|5.010000|u re_exec_indentf|5.023009||vViu ref|5.003007||Vu ref_array_or_hash|5.027008||Viu refcounted_he_chain_2hv|5.013007||cVi refcounted_he_fetch_pv|5.013007||cVi refcounted_he_fetch_pvn|5.013007||cVi refcounted_he_fetch_pvs|||i refcounted_he_fetch_sv|5.013007||cVi refcounted_he_free|5.013007||cVi refcounted_he_inc|5.013007||cVi refcounted_he_new_pv|5.013007||cVi refcounted_he_new_pvn|5.013007||cVi refcounted_he_new_pvs|||i refcounted_he_new_sv|5.013007||cVi refcounted_he_value|5.009004||Viu refkids|5.003007||Viu refto|5.005000||Viu reg2Lanode|5.021005||Viu reg|5.005000||Viu reganode|5.005000||Viu regatom|5.005000||Viu regbranch|5.005000||Viu reg_check_named_buff_matched|5.009005||nViu regclass|5.005000||Viu regcppop|5.005000||Viu regcppush|5.005000||Viu regcp_restore|5.025006||Viu regcurly|5.013010||nViu regdump|5.005000|5.005000|u regdump_extflags|5.009005||Viu regdump_intflags|5.019002||Viu regdupe_internal|5.009000|5.009000|u regexec_flags|5.005000|5.005000|u regex_set_precedence|5.021010||nViu regfree_internal|5.009005|5.009005|u reghop3|5.007001||nViu reghop4|5.009005||nViu reghopmaybe3|5.007001||nViu reginclass|5.005000||Viu reginitcolors|5.006000|5.006000|u reginsert|5.005000||Viu regmatch|5.005000||Viu reg_named_buff|5.009005||cViu reg_named_buff_all|5.009005|5.009005|u reg_named_buff_exists|5.009005|5.009005|u reg_named_buff_fetch|5.009005|5.009005|u reg_named_buff_firstkey|5.009005|5.009005|u reg_named_buff_iter|5.009005||cViu reg_named_buff_nextkey|5.009005|5.009005|u reg_named_buff_scalar|5.009005|5.009005|u regnext|5.005000|5.005000|u reg_node|5.005000||Viu regnode_guts|5.021005||Viu reg_numbered_buff_fetch|5.009005||cViu reg_numbered_buff_length|5.009005||cViu reg_numbered_buff_store|5.009005||cViu regpiece|5.005000||Viu regprop|5.003007||Viu reg_qr_package|5.009005||cViu regrepeat|5.005000||Viu reg_scan_name|5.009005||Viu reg_skipcomment|5.009005||nViu regtail|5.005000||Viu regtail_study|5.009004||Viu reg_temp_copy|5.009005||cViu regtry|5.005000||Viu re_indentf|5.023009||vViu re_intuit_start|5.006000||cVu re_intuit_string|5.006000||cVu Renew|5.003007|5.003007| Renewc|5.003007|5.003007| re_op_compile|5.017001||Viu repeatcpy|5.003007|5.003007|nu REPLACEMENT_CHARACTER_UTF8|5.025005|5.003007|p report_evil_fh|5.006001||Viu report_redefined_cv|5.015006||Viu report_uninit|5.006000||cVi report_wrongway_fh|5.013009||Viu re_printf|5.023009||vViu require_pv|5.006000|5.006000| require_tie_mod|5.009005||Viu RESTORE_ERRNO|||i RESTORE_LC_NUMERIC|5.021010|5.021010| restore_magic|5.009003||Viu restore_switched_locale|5.027009||Viu RETVAL|5.003007|5.003007|V rninstr|5.003007|5.003007|n rpeep|5.013005||Viu rsignal|5.004000|5.004000| rsignal_restore|5.004000||Viu rsignal_save|5.004000||Viu rsignal_state|5.004000|5.004000|u run_body|5.006000||Viu runops_debug|5.005000|5.005000|u runops_standard|5.005000|5.005000|u run_user_filter|5.009003||Viu rv2cv_op_cv|5.013006|5.013006| RV2CVOPCV_MARK_EARLY|5.013006|5.013006| RV2CVOPCV_RETURN_NAME_GV|5.013006|5.013006| rvpv_dup|5.007003|5.007003|u rxres_free|5.004000||Viu rxres_restore|5.004000||Viu rxres_save|5.004000||Viu Safefree|5.003007|5.003007| safesyscalloc|5.006000|5.006000|nu safesysfree|5.006000|5.006000|nu safesysmalloc|5.006000|5.006000|nu safesysrealloc|5.006000|5.006000|nu same_dirent|5.003007||Viu SANE_ERRSV|5.031003|5.031003| save_adelete|5.011000|5.011000|u save_aelem|5.004005|5.004005|u save_aelem_flags|5.011000|5.011000|u save_alloc|5.006000|5.006000|u save_aptr|5.003007|5.003007| save_ary|5.003007|5.003007| save_bool|5.008001|5.008001|u save_clearsv|5.003007|5.003007|u SAVECLEARSV|||i SAVECOMPPAD|||i SAVE_DEFSV|5.004005|5.003007|poVu save_delete|5.003007|5.003007|u save_destructor|5.006000|5.006000|u save_destructor_x|5.006000|5.006000|u SAVE_ERRNO|||i save_freeop|5.010001|5.010001|u save_freepv|5.003007|5.003007|u save_freesv|5.003007|5.003007|u save_generic_pvref|5.006001|5.006001|u save_generic_svref|5.005003|5.005003|u save_gp|5.004000|5.004000| save_hash|5.003007|5.003007| save_hdelete|5.011000|5.011000|u save_hek_flags|5.008000||nViu save_helem|5.004005|5.004005|u save_helem_flags|5.011000|5.011000|u save_hints|5.010001|5.010001|u save_hptr|5.003007|5.003007| save_I16|5.004000|5.004000|u save_I32|5.003007|5.003007|u save_I8|5.006000|5.006000|u save_int|5.003007|5.003007|u save_item|5.003007|5.003007| save_iv|5.005000|5.005000|u save_lines|5.005000||Viu save_list|5.003007|5.003007|d save_long|5.003007|5.003007|du save_magic_flags|5.019002||Viu save_mortalizesv|5.007001|5.007001|u save_nogv|5.003007|5.003007|du save_op|5.010001|5.010001|u save_padsv_and_mortalize|5.010001|5.010001|u SAVEPADSV|||i save_pptr|5.003007|5.003007|u save_pushi32ptr|5.010001|5.010001|u save_pushptr|5.010001|5.010001|u save_pushptri32ptr|5.010001||Viu save_pushptrptr|5.010001|5.010001|u savepv|5.003007|5.003007| savepvn|5.003007|5.003007| savepvs|5.009003|5.009003| save_re_context|5.006000|5.006000|u save_scalar|5.003007|5.003007| save_scalar_at|5.005000||Viu save_set_svflags|5.009000|5.009000|u savesharedpv|5.007003|5.007003| savesharedpvn|5.009005|5.009005| save_shared_pvref|5.007003|5.007003|u savesharedpvs|5.013006|5.013006| savesharedsvpv|5.013006|5.013006| save_sptr|5.003007|5.003007|u savestack_grow|5.003007|5.003007|u savestack_grow_cnt|5.008001|5.008001|u save_strlen|5.019004||cViu savesvpv|5.009002|5.009002| save_svref|5.003007|5.003007| SAVETMPS|5.003007|5.003007| savetmps|5.023008|5.023008|xu save_to_buffer|5.027004||nViu save_vptr|5.006000|5.006000|u sawparens|5.003007||Viu scalar|5.003007||Viu scalarboolean|5.005000||Viu scalarkids|5.003007||Viu scalar_mod_type|5.006000||nViu scalarseq|5.003007||Viu scalarvoid|5.003007||Viu scan_bin|5.006000|5.006000| scan_commit|5.005000||Viu scan_const|5.003007||Viu scan_formline|5.003007||Viu scan_heredoc|5.003007||Viu scan_hex|5.006000|5.003007| scan_ident|5.003007||Viu scan_inputsymbol|5.003007||Viu scan_num|5.007001|5.007001|u scan_oct|5.006000|5.003007| scan_pat|5.003007||Viu scan_str|5.003007||xcViu scan_subst|5.003007||Viu scan_trans|5.003007||Viu scan_version|5.009001|5.009001| scan_vstring|5.009005|5.009005|u scan_word|5.003007||xcViu search_const|5.010001||Viu seed|5.008001|5.008001|u sequence_num|5.009003||Viu set_ANYOF_arg|5.019005||Viu set_caret_X|5.019006||Viu set_context|5.006000|5.006000|nu setdefout|5.003007|5.003007| SETERRNO|||i setfd_cloexec|5.027008||nViu setfd_cloexec_for_nonsysfd|5.027008||Viu setfd_cloexec_or_inhexec_by_sysfdness|5.027008||Viu setfd_inhexec|5.027008||nViu setfd_inhexec_for_sysfd|5.027008||Viu setlocale_debug_string|5.027002||nViu set_numeric_radix|5.006000||Viu set_numeric_standard|5.006000||cViu set_numeric_underlying|5.027006||cViu set_padlist|5.021006||ncViu set_regex_pv|5.029004||Viu _setup_canned_invlist|5.019008||cViu share_hek|5.004000|5.004000|u share_hek_flags|5.008000||Viu SHORTSIZE|5.004000|5.004000| should_warn_nl|5.021001||nViu si_dup|5.007003|5.007003|u sighandler1|||nViu sighandler3|||nViu sighandler|5.003007||nViu simplify_sort|5.006000||Viu SITELIB|5.003007|5.003007| skipspace_flags|5.019002||xcViu skip_to_be_ignored_text|5.023004||Viu Slab_Alloc|5.006000||cViu Slab_Free|5.007003||cViu Slab_to_ro|5.017002||Viu Slab_to_rw|5.009005||Viu softref2xv|||iu sortcv|5.009003||Viu sortcv_stacked|5.009003||Viu sortcv_xsub|5.009003||Viu sortsv|5.007003|5.007003| sortsv_flags|5.009003|5.009003| SP|5.003007|5.003007| space_join_names_mortal|5.009004||Viu SPAGAIN|5.003007|5.003007| ssc_add_range|5.019005||Viu ssc_and|5.019005||Viu ssc_anything|5.019005||Viu ssc_clear_locale|5.019005||nViu ssc_cp_and|5.019005||Viu ssc_finalize|5.019005||Viu ssc_init|5.019005||Viu ssc_intersection|5.019005||Viu ssc_is_anything|5.019005||nViu ssc_is_cp_posixl_init|5.019005||nViu ssc_or|5.019005||Viu ssc_union|5.019005||Viu ss_dup|5.007003|5.007003|u ST|5.003007|5.003007| stack_grow|5.003007|5.003007|u START_EXTERN_C|5.005000|5.003007|poVu start_glob|||xi START_MY_CXT|5.010000|5.010000|p STARTPERL|5.003007|5.003007| start_subparse|5.004000|5.003007|pu STDCHAR|5.003007|5.003007| stdize_locale|5.007001||Viu STMT_END|5.003007|5.003007|pV STMT_START|5.003007|5.003007|pV STORE_LC_NUMERIC_FORCE_TO_UNDERLYING|5.021010|5.021010| STORE_LC_NUMERIC_SET_TO_NEEDED|5.021010|5.021010| STORE_LC_NUMERIC_SET_TO_NEEDED_IN|5.031003|5.031003| strEQ|5.003007|5.003007| strGE|5.003007|5.003007| strGT|5.003007|5.003007| strip_return|5.009003||Viu strLE|5.003007|5.003007| strLT|5.003007|5.003007| strNE|5.003007|5.003007| strnEQ|5.003007|5.003007| strnNE|5.003007|5.003007| Strtod|5.029010|5.029010|n Strtol|5.006000|5.006000|n Strtoul|5.006000|5.006000|n str_to_version|5.006000|5.006000|u StructCopy|5.003007|5.003007|V STR_WITH_LEN|5.009003|5.003007|pV study_chunk|5.005000||Viu sub_crush_depth|5.004000||Viu sublex_done|5.005000||Viu sublex_push|5.005000||Viu sublex_start|5.005000||Viu sv_2bool|5.003007|5.003007| sv_2bool_flags|5.013006|5.013006| sv_2cv|5.003007|5.003007| sv_2io|5.003007|5.003007| sv_2iuv_common|5.009004||Viu sv_2iuv_non_preserve|5.007001||Viu sv_2iv|5.003007|5.003007|u sv_2iv_flags|5.009001|5.009001| sv_2mortal|5.003007|5.003007| sv_2num|5.010000||xVi sv_2nv_flags|5.013001|5.013001| sv_2pv|5.003007|5.003007|u sv_2pvbyte|5.006000|5.003007|p sv_2pvbyte_flags|5.031004|5.031004|u sv_2pvbyte_nolen|5.006000|5.003007|p sv_2pv_flags|5.007002|5.003007|p sv_2pv_nolen|5.006000|5.003007|p sv_2pvutf8|5.006000|5.006000| sv_2pvutf8_flags|5.031004|5.031004|u sv_2pvutf8_nolen|5.006000|5.006000| sv_2uv|5.004000|5.003007|pu sv_2uv_flags|5.009001|5.009001| sv_add_arena|5.003007||Vi sv_add_backref|||iu SvAMAGIC_off|5.031004|5.031004|nu SvAMAGIC_on|5.031004|5.031004|nu sv_backoff|5.003007|5.003007|n sv_bless|5.003007|5.003007| sv_buf_to_ro|5.019008||Viu sv_buf_to_rw|5.019008||Viu SV_CATBYTES|5.021005|5.021005| sv_cat_decode|5.008001|5.008001| sv_catpv|5.003007|5.003007| sv_catpvf|5.006000|5.004000|v sv_catpv_flags|5.013006|5.013006| sv_catpvf_mg|5.006000|5.004000|pv sv_catpvf_mg_nocontext|5.006000||pvnVu sv_catpvf_nocontext|5.006000||vnVu sv_catpv_mg|5.004005|5.003007|p sv_catpvn|5.003007|5.003007| sv_catpvn_flags|5.007002|5.007002| sv_catpvn_mg|5.004005|5.003007|p sv_catpvn_nomg|5.007002|5.003007|p sv_catpv_nomg|5.013006|5.013006| sv_catpvs|5.009003|5.003007|p sv_catpvs_flags|5.013006|5.013006| sv_catpvs_mg|5.013006|5.013006| sv_catpvs_nomg|5.013006|5.013006| sv_catsv|5.003007|5.003007| sv_catsv_flags|5.007002|5.007002| sv_catsv_mg|5.004005|5.003007|p sv_catsv_nomg|5.007002|5.003007|p SV_CATUTF8|5.021005|5.021005| sv_chop|5.003007|5.003007| sv_clean_all|5.003007||Vi sv_clean_objs|5.003007||Vi sv_clear|5.003007|5.003007| sv_cmp|5.003007|5.003007| sv_cmp_flags|5.013006|5.013006| sv_cmp_locale|5.004000|5.004000| sv_cmp_locale_flags|5.013006|5.013006| sv_collxfrm||| sv_collxfrm_flags|5.013006|5.013006| SV_CONST_RETURN|5.009003|5.003007|poVu sv_copypv|5.007003|5.007003| sv_copypv_flags|5.017002|5.017002| sv_copypv_nomg|5.017002|5.017002| SV_COW_DROP_PV|5.008001|5.003007|p SV_COW_SHARED_HASH_KEYS|5.009005|5.003007|poVu SvCUR|5.003007|5.003007| SvCUR_set|5.003007|5.003007| sv_dec|5.003007|5.003007| sv_dec_nomg|5.013002|5.013002| sv_del_backref|5.006000||cViu sv_derived_from|5.004000|5.004000| sv_derived_from_pv|5.015004|5.015004| sv_derived_from_pvn|5.015004|5.015004| sv_derived_from_sv|5.015004|5.015004| sv_derived_from_svpvn|5.031006||Viu sv_destroyable|5.010000|5.010000| sv_display|5.021002||Viu sv_does|5.009004|5.009004| sv_does_pv|5.015004|5.015004| sv_does_pvn|5.015004|5.015004| sv_does_sv|5.015004|5.015004| sv_dump|5.003007|5.003007| sv_dup|5.007003|5.007003|u sv_dup_common|5.013002||Viu sv_dup_inc|5.013002|5.013002|u sv_dup_inc_multiple|5.011000||Viu SvEND|5.003007|5.003007| sv_eq|5.003007|5.003007| sv_eq_flags|5.013006|5.013006| sv_exp_grow|5.009003||Viu SVf|5.006000|5.003007|p SVfARG|5.009005|5.003007|p sv_force_normal|5.006000|5.006000| sv_force_normal_flags|5.007001|5.007001| sv_free2|||xciu sv_free|5.003007|5.003007| sv_free_arenas|5.003007||Vi SVf_UTF8|5.006000|5.003007|p SvGAMAGIC|5.006001|5.006001| sv_get_backrefs|5.021008|5.021008|nx SvGETMAGIC|5.004005|5.003007|p sv_gets|5.003007|5.003007| SV_GMAGIC|5.007002|5.003007|p sv_grow|5.003007|5.003007| SvGROW|5.003007|5.003007| SV_HAS_TRAILING_NUL|5.009004|5.003007|p SV_IMMEDIATE_UNREF|5.007001|5.003007|p sv_inc|5.003007|5.003007| sv_i_ncmp|5.009003||Viu sv_inc_nomg|5.013002|5.013002| sv_insert|5.003007|5.003007| sv_insert_flags|5.010001|5.010001| SvIOK|5.003007|5.003007| SvIOK_notUV|5.006000|5.006000| SvIOK_off|5.003007|5.003007| SvIOK_on|5.003007|5.003007| SvIOK_only|5.003007|5.003007| SvIOK_only_UV|5.006000|5.006000| SvIOKp|5.003007|5.003007| SvIOK_UV|5.006000|5.006000| sv_isa|5.003007|5.003007| sv_isa_sv|||x SvIsCOW|5.008003|5.008003| SvIsCOW_shared_hash|5.008003|5.008003| sv_isobject|5.003007|5.003007| SvIV|5.003007|5.003007| sv_iv|5.005000|5.005000|d SvIV_nomg|5.009001|5.003007|p SvIV_set|5.003007|5.003007| SvIVX|5.003007|5.003007| SvIVx|5.003007|5.003007| sv_kill_backrefs|||xiu sv_len|5.003007|5.003007| SvLEN|5.003007|5.003007| SvLEN_set|5.003007|5.003007| sv_len_utf8|5.006000|5.006000|p sv_len_utf8_nomg|5.017004||pVu SvLOCK|5.007003|5.007003| sv_magic|5.003007|5.003007| sv_magicext|5.007003|5.007003| sv_magicext_mglob|5.019002||cViu sv_magic_portable||5.004000|pou SvMAGIC_set|5.009003|5.003007|p sv_mortalcopy|5.003007|5.003007| sv_mortalcopy_flags|5.017005|5.003007|p SV_MUTABLE_RETURN|5.009003|5.003007|poVu sv_ncmp|5.009003||Viu sv_newmortal|5.003007|5.003007| sv_newref|5.003007|5.003007| SvNIOK|5.003007|5.003007| SvNIOK_off|5.003007|5.003007| SvNIOKp|5.003007|5.003007| SvNOK|5.003007|5.003007| SvNOK_off|5.003007|5.003007| SvNOK_on|5.003007|5.003007| SvNOK_only|5.003007|5.003007| SvNOKp|5.003007|5.003007| sv_nolocking|5.007003|5.007003|d sv_nosharing|5.007003|5.007003| SV_NOSTEAL|5.009002|5.003007|p sv_nounlocking|5.007003|5.007003|d SvNV|5.006000|5.003007| sv_nv|5.006000|5.005000|d SvNV_nomg|5.013002|5.003007|p SvNV_set|5.006000|5.003007| SvNVX|5.006000|5.003007| SvNVx|5.006000|5.003007| SvOK|5.003007|5.003007| sv_only_taint_gmagic|5.021010||nViu SvOOK|5.003007|5.003007| SvOOK_offset|5.011000|5.011000| sv_or_pv_pos_u2b|5.019004||Viu sv_peek|5.005000|5.005000|u SvPOK|5.003007|5.003007| SvPOK_off|5.003007|5.003007| SvPOK_on|5.003007|5.003007| SvPOK_only|5.003007|5.003007| SvPOK_only_UTF8|5.006000|5.006000| SvPOKp|5.003007|5.003007| sv_pos_b2u|5.006000|5.006000| sv_pos_b2u_flags|5.019003|5.019003| sv_pos_b2u_midway|5.009004||Viu sv_pos_u2b|5.006000|5.006000| sv_pos_u2b_cached|5.009004||Viu sv_pos_u2b_flags|5.011005|5.011005| sv_pos_u2b_forwards|5.009004||nViu sv_pos_u2b_midway|5.009004||nViu SvPV|5.003007|5.003007| sv_pv|5.006000|5.006000| SvPVbyte|5.006000|5.003007|p sv_pvbyte|5.006000|5.006000| SvPVbyte_force|5.009002|5.009002| sv_pvbyten|5.006000|5.006000|d sv_pvbyten_force|5.006000|5.006000| SvPVbyte_nolen|5.006000|5.006000| SvPVbyte_nomg|5.031004|5.031004| SvPVbyte_or_null|5.031004|5.031004| SvPVbyte_or_null_nomg|5.031004|5.031004| SvPVbytex|5.006000|5.006000| SvPVbytex_force|5.006000|5.006000| SvPVCLEAR|5.025006|5.025006| SvPV_const|5.009003||pVu SvPV_flags|5.007002||pVu SvPV_flags_const|5.009003||pVu SvPV_flags_const_nolen|5.009003||pVu SvPV_flags_mutable|5.009003||pVu SvPV_force|5.003007|5.003007|p SvPV_force_flags|5.007002||pVu SvPV_force_flags_mutable|5.009003||pVu SvPV_force_flags_nolen|5.009003||pVu SvPV_force_mutable|5.009003||pVu SvPV_force_nolen|5.009003||pVu SvPV_force_nomg|5.007002|5.003007|p SvPV_force_nomg_nolen|5.009003||pVu SvPV_mutable|5.009003||pVu sv_pvn|5.005000|5.005000|d sv_pvn_force|5.003007|5.003007| sv_pvn_force_flags|5.007002|5.003007|p sv_pvn_nomg|5.007003|5.005000|pdu SvPV_nolen|5.006000|5.003007|p SvPV_nolen_const|5.009003||pVu SvPV_nomg|5.007002|5.003007|p SvPV_nomg_const|5.009003||pVu SvPV_nomg_const_nolen|5.009003||pVu SvPV_nomg_nolen|5.013007|5.003007|p SvPV_renew|5.009003||pVu SvPV_set|5.003007|5.003007| sv_pvutf8|5.006000|5.006000| SvPVutf8|5.006000|5.006000| SvPVutf8_force|5.006000|5.006000| sv_pvutf8n|5.006000|5.006000|d sv_pvutf8n_force|5.006000|5.006000| SvPVutf8_nolen|5.006000|5.006000| SvPVutf8_nomg|5.031004|5.031004| SvPVutf8_or_null|5.031004|5.031004| SvPVutf8_or_null_nomg|5.031004|5.031004| SvPVutf8x|5.006000|5.006000| SvPVutf8x_force|5.006000|5.006000| SvPVX|5.003007|5.003007| SvPVx|5.003007|5.003007| SvPVX_const|5.009003||pVu SvPVX_mutable|5.009003||pVu SvREADONLY|5.003007|5.003007| SvREADONLY_off|5.003007|5.003007| SvREADONLY_on|5.003007|5.003007| sv_recode_to_utf8|5.007003|5.007003| sv_ref|5.015004|5.015004| SvREFCNT|5.003007|5.003007| SvREFCNT_dec|5.003007|5.003007| SvREFCNT_dec_NN|5.017007|5.017007| SvREFCNT_inc|5.003007|5.003007|pn SvREFCNT_inc_NN|5.009004|5.003007|pn SvREFCNT_inc_simple|5.009004|5.003007|p SvREFCNT_inc_simple_NN|5.009004|5.003007|p SvREFCNT_inc_simple_void|5.009004|5.003007|p SvREFCNT_inc_simple_void_NN|5.009004|5.003007|p SvREFCNT_inc_void|5.009004|5.003007|pn SvREFCNT_inc_void_NN|5.009004|5.003007|p sv_reftype|5.003007|5.003007| sv_replace|5.003007|5.003007| sv_report_used|5.003007|5.003007| sv_reset|5.003007|5.003007| sv_resetpvn|5.017005||Viu SvROK|5.003007|5.003007| SvROK_off|5.003007|5.003007| SvROK_on|5.003007|5.003007| SvRV|5.003007|5.003007| SvRV_set|5.009003|5.003007|p sv_rvunweaken|5.027004|5.027004| sv_rvweaken|5.006000|5.006000| SvRX|5.009005|5.003007|p SvRXOK|5.009005|5.003007|p sv_sethek|5.015004||cViu sv_setiv|5.003007|5.003007| sv_setiv_mg|5.004005|5.003007|p SvSETMAGIC|5.003007|5.003007| SvSetMagicSV|5.004000|5.004000| SvSetMagicSV_nosteal|5.004000|5.004000| sv_setnv|5.006000|5.003007| sv_setnv_mg|5.006000|5.003007|p sv_setpv|5.003007|5.003007| sv_setpv_bufsize|5.025006|5.025006| sv_setpvf|5.006000|5.004000|v sv_setpvf_mg|5.006000|5.004000|pv sv_setpvf_mg_nocontext|5.006000||pvnVu sv_setpvf_nocontext|5.006000||vnVu sv_setpviv|5.008001|5.008001|d sv_setpviv_mg|5.008001|5.008001|d sv_setpv_mg|5.004005|5.003007|p sv_setpvn|5.003007|5.003007| sv_setpvn_mg|5.004005|5.003007|p sv_setpvs|5.009004|5.003007|p sv_setpvs_mg|5.013006|5.013006| sv_setref_iv|5.003007|5.003007| sv_setref_nv|5.006000|5.003007| sv_setref_pv|5.003007|5.003007| sv_setref_pvn|5.003007|5.003007| sv_setref_pvs|5.013006|5.013006| sv_setref_uv|5.007001|5.007001| sv_setsv|5.003007|5.003007| SvSetSV|5.003007|5.003007| sv_setsv_cow|5.009000||xcViu sv_setsv_flags|5.007002|5.003007|p sv_setsv_mg|5.004005|5.003007|p sv_setsv_nomg|5.007002|5.003007|p SvSetSV_nosteal|5.004000|5.004000| sv_set_undef|5.025008|5.025008| sv_setuv|5.004000|5.003007|p sv_setuv_mg|5.004005|5.003007|p SvSHARE|5.007003|5.007003| SvSHARED_HASH|5.009003||pVu SV_SMAGIC|5.009003|5.003007|p SVs_PADSTALE|5.009000|5.009000| SvSTASH|5.003007|5.003007| SvSTASH_set|5.009003|5.003007|p SVs_TEMP|5.003007|5.003007| sv_string_from_errnum|5.027003|5.027003| SvTAINT|5.003007|5.003007| sv_taint|5.004000|5.004000| sv_tainted|5.004000|5.004000| SvTAINTED|5.004000|5.004000| SvTAINTED_off|5.004000|5.004000| SvTAINTED_on|5.004000|5.004000| SvTHINKFIRST|||i SVt_INVLIST|||c SVt_IV|5.003007|5.003007| SVt_NULL|5.003007|5.003007| SVt_NV|5.003007|5.003007| SVt_PV|5.003007|5.003007| SVt_PVAV|5.003007|5.003007| SVt_PVCV|5.003007|5.003007| SVt_PVFM|5.003007|5.003007| SVt_PVGV|5.003007|5.003007| SVt_PVHV|5.003007|5.003007| SVt_PVIO|5.003007|5.003007| SVt_PVIV|5.003007|5.003007| SVt_PVLV|5.003007|5.003007| SVt_PVMG|5.003007|5.003007| SVt_PVNV|5.003007|5.003007| SVt_REGEXP|5.011000|5.011000| SvTRUE|5.003007|5.003007| sv_true|5.005000|5.005000| SvTRUE_nomg|5.013006|5.003007|p SvTRUEx|5.003007|5.003007| SvTYPE|5.003007|5.003007| svtype|5.003007|5.003007|V sv_unglob|5.005000||Viu sv_uni_display|5.007003|5.007003| SvUNLOCK|5.007003|5.007003| sv_unmagic|5.003007|5.003007| sv_unmagicext|5.013008|5.003007|p sv_unref|5.003007|5.003007| sv_unref_flags|5.007001|5.007001| sv_untaint|5.004000|5.004000| SvUOK|5.007001|5.006000|p sv_upgrade|5.003007|5.003007| SvUPGRADE|5.003007|5.003007| sv_usepvn|5.003007|5.003007| sv_usepvn_flags|5.009004|5.009004| sv_usepvn_mg|5.004005|5.003007|p SvUTF8|5.006000|5.003007|p sv_utf8_decode|5.006000|5.006000| sv_utf8_downgrade|5.006000|5.006000| sv_utf8_downgrade_flags|5.031004|5.031004| sv_utf8_downgrade_nomg|5.031004|5.031004| sv_utf8_encode|5.006000|5.006000| SV_UTF8_NO_ENCODING|5.008001|5.003007|poVu SvUTF8_off|5.006000|5.006000| SvUTF8_on|5.006000|5.006000| sv_utf8_upgrade|5.007001|5.007001| sv_utf8_upgrade_flags|5.007002|5.007002| sv_utf8_upgrade_flags_grow|5.011000|5.011000| sv_utf8_upgrade_nomg|5.007002|5.007002| SvUV|5.004000|5.003007|p sv_uv|5.005000|5.003007|pd SvUV_nomg|5.009001|5.003007|p SvUV_set|5.009003|5.003007|p SvUVX|5.004000|5.003007|p SvUVx|5.004000|5.003007|p SvUVXx|5.004000|5.003007|pd sv_vcatpvf|5.006000|5.004000|p sv_vcatpvf_mg|5.006000|5.004000|p sv_vcatpvfn|5.004000|5.004000| sv_vcatpvfn_flags|5.017002|5.017002| SvVOK|5.008001|5.008001| sv_vsetpvf|5.006000|5.004000|p sv_vsetpvf_mg|5.006000|5.004000|p sv_vsetpvfn|5.004000|5.004000| SvVSTRING_mg|5.009004||pVu swallow_bom|5.006001||Viu switch_category_locale_to_template|5.027009||Viu switch_to_global_locale|5.027009|5.003007|pn sync_locale|5.027009|5.003007|pn sys_init3|5.010000|5.010000|nu sys_init|5.010000|5.010000|nu sys_intern_clear|5.006001||Vu sys_intern_dup|5.006000||Vu sys_intern_init|5.006001||Vu sys_term|5.010000|5.010000|nu taint_env|5.003007|5.003007|u taint_proper|5.003007|5.003007|u THIS|5.003007|5.003007|V thread_locale_init|5.027009|5.027009|nxu thread_locale_term|5.027009|5.027009|nxu tied_method|5.013009||vViu tmps_grow_p|5.021005||cViu to_byte_substr|5.008000||Viu toFOLD|5.019001|5.019001| _to_fold_latin1|5.015005||ncViu toFOLD_utf8|5.031005|5.031005| toFOLD_utf8_safe|5.025009|5.006000|p toFOLD_uvchr|5.023009|5.006000|p tokenize_use|5.009003||Viu tokeq|5.005000||Viu tokereport|5.007001||Viu toLOWER|5.003007|5.003007| toLOWER_L1|5.019001|5.019001| to_lower_latin1|5.015005||nViu toLOWER_LC|5.004000|5.004000| toLOWER_utf8|5.031005|5.031005| toLOWER_utf8_safe|5.025009|5.006000|p toLOWER_uvchr|5.023009|5.006000|p too_few_arguments_pv|5.016000||Viu too_many_arguments_pv|5.016000||Viu TOPMARK|||ciu toTITLE|5.019001|5.019001| toTITLE_utf8|5.031005|5.031005| toTITLE_utf8_safe|5.025009|5.006000|p toTITLE_uvchr|5.023009|5.006000|p to_uni_fold|5.031004||cVu _to_uni_fold_flags|5.014000||cVu to_uni_lower|5.006000||cVu to_uni_title|5.006000||cVu to_uni_upper|5.006000||cVu toUPPER|5.003007|5.003007| _to_upper_title_latin1|5.015005||Viu toUPPER_utf8|5.031005|5.031005| toUPPER_utf8_safe|5.025009|5.006000|p toUPPER_uvchr|5.023009|5.006000|p _to_utf8_case|5.023006||Viu _to_utf8_fold_flags|5.014000||cVu _to_utf8_lower_flags|5.015006||cVu to_utf8_substr|5.008000||Viu _to_utf8_title_flags|5.015006||cVu _to_utf8_upper_flags|5.015006||cVu translate_substr_offsets|5.015006||nViu traverse_op_tree|5.029008||Vi try_amagic_bin|||ciu try_amagic_un|||ciu turkic_fc|5.029008||Viu turkic_lc|5.029008||Viu turkic_uc|5.029008||Viu U16SIZE|5.006000|5.006000| U16TYPE|5.006000|5.006000| U32SIZE|5.006000|5.006000| U32TYPE|5.006000|5.006000| U8SIZE|5.006000|5.006000| U8TYPE|5.006000|5.006000| uiv_2buf|5.009003||nViu UNDERBAR|5.009002|5.003007|p unexpected_non_continuation_text|5.025006||Viu UNICODE_REPLACEMENT|5.007001|5.003007|p UNI_TO_NATIVE|5.007001|5.003007|p UNLIKELY|5.009004|5.003007|p unlnk|5.003007||Vu unpack_rec|5.008001||Viu unpack_str|5.007003|5.007003|d unpackstring|5.008001|5.008001| unreferenced_to_tmp_stack|5.013002||Viu unshare_hek|5.004000||Viu unshare_hek_or_pvn|5.008000||Viu unsharepvn|5.003007|5.003007|u unwind_handler_stack|5.009003||Viu update_debugger_info|5.009005||Viu upg_version|5.009005|5.009005| usage|5.005000||Viu utf16_textfilter|5.011001||Viu utf16_to_utf8|5.006000||cViu utf16_to_utf8_reversed|5.006000||cViu UTF8_CHECK_ONLY|5.007001|5.007001| UTF8_CHK_SKIP|5.031006|5.006000|p UTF8_DISALLOW_ILLEGAL_C9_INTERCHANGE|5.025005|5.025005| UTF8_DISALLOW_ILLEGAL_INTERCHANGE|5.013009|5.013009| UTF8_DISALLOW_NONCHAR|5.013009|5.013009| UTF8_DISALLOW_PERL_EXTENDED|5.027002|5.027002| UTF8_DISALLOW_SUPER|5.013009|5.013009| UTF8_DISALLOW_SURROGATE|5.013009|5.013009| utf8_distance|5.006000|5.006000| UTF8f|5.019001|5.003007|p UTF8fARG|5.019002|5.003007|p utf8_hop|5.006000|5.006000|n utf8_hop_back|5.025007|5.025007|n utf8_hop_forward|5.025007|5.025007|n utf8_hop_safe|5.025007|5.025007|n UTF8_IS_INVARIANT|5.007001|5.003007|p UTF8_IS_NONCHAR|5.023002|5.023002| UTF8_IS_SUPER|5.023002|5.023002| UTF8_IS_SURROGATE|5.023002|5.023002| utf8_length|5.007001|5.007001| UTF8_MAXBYTES|5.009002|5.006000|p UTF8_MAXBYTES_CASE|5.009002|5.003007|p utf8_mg_len_cache_update|5.013003||Viu utf8_mg_pos_cache_update|5.009004||Viu utf8n_to_uvchr|5.007001|5.007001|n utf8n_to_uvchr_error|5.025006|5.025006|n utf8n_to_uvchr_msgs|5.027009|5.027009|nx _utf8n_to_uvchr_msgs_helper|5.029001||ncVu utf8n_to_uvuni|5.007001||cV UTF8_SAFE_SKIP|5.029009|5.006000|p UTF8SKIP|5.006000|5.006000| UTF8_SKIP|5.023002|5.006000|p utf8_to_bytes|5.006001|5.006001|x utf8_to_uvchr|5.007001|5.006001|pd utf8_to_uvchr_buf|5.015009|5.006001|p utf8_to_uvchr_buf_helper|5.031004||cVu utf8_to_uvuni|5.007001||dcV utf8_to_uvuni_buf|5.015009||dcV UTF8_WARN_ILLEGAL_C9_INTERCHANGE|5.025005|5.025005| UTF8_WARN_ILLEGAL_INTERCHANGE|5.013009|5.013009| UTF8_WARN_NONCHAR|5.013009|5.013009| UTF8_WARN_PERL_EXTENDED|5.027002|5.027002| UTF8_WARN_SUPER|5.013009|5.013009| UTF8_WARN_SURROGATE|5.013009|5.013009| utilize|5.003007||Viu UVCHR_IS_INVARIANT|5.019004|5.003007|p UVCHR_SKIP|5.022000|5.003007|p uvchr_to_utf8|5.007001|5.007001| uvchr_to_utf8_flags|5.007003|5.007003| uvchr_to_utf8_flags_msgs|5.027009|5.027009|x UVof|5.006000|5.003007|p uvoffuni_to_utf8_flags|||c uvoffuni_to_utf8_flags_msgs|5.027009||cVu UVSIZE|5.006000|5.003007|p UVTYPE|5.006000|5.003007|p UVuf|5.006000|5.003007|p uvuni_to_utf8|5.019004||cVu uvuni_to_utf8_flags|5.007003||cV UVxf|5.006000|5.003007|p UVXf|5.007001|5.007001|p validate_proto|5.019002||xcVi validate_suid|||iu valid_utf8_to_uvchr|5.015009||ncV valid_utf8_to_uvuni|5.015009||dcVu variant_byte_number|5.031004||ncVu variant_under_utf8_count|5.027007||nVi varname|5.009003||Viu vcmp|5.009000|5.009000| vcroak|5.006000|5.006000| vdeb|5.007003|5.007003|u vform|5.006000|5.006000|u visit|5.005000||Viu vivify_defelem|5.004000||cViu vivify_ref|5.004000||Viu vload_module|5.006000|5.003007|pu vmess|5.006000|5.004000|p vnewSVpvf|5.006000|5.004000|pu vnormal|5.009002|5.009002| vnumify|5.009000|5.009000| vstringify|5.009000|5.009000| vverify|5.009003|5.009003| vwarn|5.006000|5.006000| vwarner|5.006000|5.006000|u wait4pid|5.003007||Viu warn|5.006000|5.003007|v WARN_ALL|5.006000|5.003007|p WARN_AMBIGUOUS|5.006000|5.003007|p WARN_ASSERTIONS||5.003007|pou WARN_BAREWORD|5.006000|5.003007|p WARN_CLOSED|5.006000|5.003007|p WARN_CLOSURE|5.006000|5.003007|p WARN_DEBUGGING|5.006000|5.003007|p WARN_DEPRECATED|5.006000|5.003007|p WARN_DIGIT|5.006000|5.003007|p warner|5.006000|5.004000|pvu warner_nocontext|5.006000||vnVu WARN_EXEC|5.006000|5.003007|p WARN_EXITING|5.006000|5.003007|p WARN_EXPERIMENTAL|5.017004|5.017004| WARN_EXPERIMENTAL__ALPHA_ASSERTIONS|5.027009|5.027009| WARN_EXPERIMENTAL__BITWISE|5.021009|5.021009| WARN_EXPERIMENTAL__CONST_ATTR|5.021008|5.021008| WARN_EXPERIMENTAL__DECLARED_REFS|5.025003|5.025003| WARN_EXPERIMENTAL__ISA||| WARN_EXPERIMENTAL__LEXICAL_SUBS|5.017005|5.017005| WARN_EXPERIMENTAL__POSTDEREF|5.019005|5.019005| WARN_EXPERIMENTAL__PRIVATE_USE|5.029009|5.029009| WARN_EXPERIMENTAL__REFALIASING|5.021005|5.021005| WARN_EXPERIMENTAL__REGEX_SETS|5.017008|5.017008| WARN_EXPERIMENTAL__RE_STRICT|5.021008|5.021008| WARN_EXPERIMENTAL__SCRIPT_RUN|5.027008|5.027008| WARN_EXPERIMENTAL__SIGNATURES|5.019009|5.019009| WARN_EXPERIMENTAL__SMARTMATCH|5.017011|5.017011| WARN_EXPERIMENTAL__UNIPROP_WILDCARDS|5.029009|5.029009| WARN_EXPERIMENTAL__VLB|5.029009|5.029009| WARN_EXPERIMENTAL__WIN32_PERLIO|5.021001|5.021001| WARN_GLOB|5.006000|5.003007|p WARN_ILLEGALPROTO|5.011004|5.011004| WARN_IMPRECISION|5.011000|5.011000| WARN_INPLACE|5.006000|5.003007|p WARN_INTERNAL|5.006000|5.003007|p WARN_IO|5.006000|5.003007|p WARN_LAYER|5.008000|5.003007|p WARN_LOCALE|5.021006|5.021006| WARN_MALLOC|5.006000|5.003007|p WARN_MISC|5.006000|5.003007|p WARN_MISSING|5.021002|5.021002| WARN_NEWLINE|5.006000|5.003007|p warn_nocontext|5.006000||pvnVu WARN_NONCHAR|5.013010|5.013010| WARN_NON_UNICODE|5.013010|5.013010| WARN_NUMERIC|5.006000|5.003007|p WARN_ONCE|5.006000|5.003007|p warn_on_first_deprecated_use|5.025009||Viu WARN_OVERFLOW|5.006000|5.003007|p WARN_PACK|5.006000|5.003007|p WARN_PARENTHESIS|5.006000|5.003007|p WARN_PIPE|5.006000|5.003007|p WARN_PORTABLE|5.006000|5.003007|p WARN_PRECEDENCE|5.006000|5.003007|p WARN_PRINTF|5.006000|5.003007|p _warn_problematic_locale|5.021008||ncViu WARN_PROTOTYPE|5.006000|5.003007|p WARN_QW|5.006000|5.003007|p WARN_RECURSION|5.006000|5.003007|p WARN_REDEFINE|5.006000|5.003007|p WARN_REDUNDANT|5.021002|5.021002| WARN_REGEXP|5.006000|5.003007|p WARN_RESERVED|5.006000|5.003007|p WARN_SEMICOLON|5.006000|5.003007|p WARN_SEVERE|5.006000|5.003007|p WARN_SHADOW|5.027007|5.027007| WARN_SIGNAL|5.006000|5.003007|p WARN_SUBSTR|5.006000|5.003007|p WARN_SURROGATE|5.013010|5.013010| warn_sv|5.013001|5.003007|p WARN_SYNTAX|5.006000|5.003007|p WARN_SYSCALLS|5.019004|5.019004| WARN_TAINT|5.006000|5.003007|p WARN_THREADS|5.008000|5.003007|p WARN_UNINITIALIZED|5.006000|5.003007|p WARN_UNOPENED|5.006000|5.003007|p WARN_UNPACK|5.006000|5.003007|p WARN_UNTIE|5.006000|5.003007|p WARN_UTF8|5.006000|5.003007|p WARN_VOID|5.006000|5.003007|p was_lvalue_sub|||ciu watch|5.003007||Viu whichsig|5.003007|5.003007|u whichsig_pv|5.015004|5.015004|u whichsig_pvn|5.015004|5.015004|u whichsig_sv|5.015004|5.015004|u WIDEST_UTYPE|5.015004|5.003007|p win32_croak_not_implemented|5.017006||nViu win32_setlocale|5.027006||Viu WITH_LC_NUMERIC_SET_TO_NEEDED|5.031003|5.031003| WITH_LC_NUMERIC_SET_TO_NEEDED_IN|5.031003|5.031003| with_queued_errors|5.013001||Viu wrap_keyword_plugin|5.027006|5.027006|x wrap_op_checker|5.015008|5.015008| write_to_stderr|5.008001||Viu XCPT_CATCH|5.009002|5.003007|p XCPT_RETHROW|5.009002|5.003007|p XCPT_TRY_END|5.009002|5.003007|p XCPT_TRY_START|5.009002|5.003007|p XopDISABLE|5.013007|5.013007|V XopENABLE|5.013007|5.013007|V XopENTRY|5.013007|5.013007|V XopENTRYCUSTOM|5.019006|5.013007|V XopENTRY_set|5.013007|5.013007|V XopFLAGS|5.013007|5.013007| XPUSHi|5.003007|5.003007| XPUSHmortal|5.009002|5.003007|p XPUSHn|5.006000|5.003007| XPUSHp|5.003007|5.003007| XPUSHs|5.003007|5.003007| XPUSHu|5.004000|5.003007|p XS|5.003007|5.003007|V XS_APIVERSION_BOOTCHECK|5.013004|5.013004| xs_boot_epilog|5.021006||cViu XS_EXTERNAL|5.015002|5.015002|V xs_handshake|||vnciu XS_INTERNAL|5.015002|5.015002|V XSprePUSH|5.006000|5.003007|poVu XSPROTO|5.010000||pVu XSRETURN|5.003007|5.003007|p XSRETURN_EMPTY|5.003007|5.003007| XSRETURN_IV|5.003007|5.003007| XSRETURN_NO|5.003007|5.003007| XSRETURN_NV|5.006000|5.003007| XSRETURN_PV|5.003007|5.003007| XSRETURN_UNDEF|5.003007|5.003007| XSRETURN_UV|5.008001|5.003007|p XSRETURN_YES|5.003007|5.003007| XST_mIV|5.003007|5.003007| XST_mNO|5.003007|5.003007| XST_mNV|5.006000|5.003007| XST_mPV|5.003007|5.003007| XST_mUNDEF|5.003007|5.003007| XST_mUV|5.008001|5.003007|p XST_mYES|5.003007|5.003007| XS_VERSION|5.003007|5.003007| XS_VERSION_BOOTCHECK|5.003007|5.003007| xs_version_bootcheck|||iu yyerror|5.003007||Viu yyerror_pv|5.016000||Viu yyerror_pvn|5.016000||Viu yylex|5.003007||cViu yyparse|5.003007||Viu yyquit|5.025010||Viu yyunlex|5.013005||Viu yywarn|5.003007||Viu Zero|5.003007|5.003007| ZeroD|5.009002|5.003007|p ); if (exists $opt{'list-unsupported'}) { my $f; for $f (sort dictionary_order keys %API) { next if $API{$f}{core_only}; next if $API{$f}{beyond_depr}; next if $API{$f}{inaccessible}; next if $API{$f}{experimental}; next unless $API{$f}{todo}; next if int_parse_version($API{$f}{todo}) <= $int_min_perl; print "$f ", '.'x(40-length($f)), " ", format_version($API{$f}{todo}), "\n"; } exit 0; } # Scan for hints, possible replacement candidates, etc. my(%replace, %need, %hints, %warnings, %depends); my $replace = 0; my($hint, $define, $function); sub find_api { BEGIN { 'warnings'->unimport('uninitialized') if "$]" > '5.006' } my $code = shift; $code =~ s{ / (?: \*[^*]*\*+(?:[^$ccs][^*]*\*+)* / | /[^\r\n]*) | "[^"\\]*(?:\\.[^"\\]*)*" | '[^'\\]*(?:\\.[^'\\]*)*' }{}egsx; grep { exists $API{$_} } $code =~ /(\w+)/mg; } while () { if ($hint) { # Here, we are in the middle of accumulating a hint or warning. my $end_of_hint = 0; # A line containing a comment end marker closes the hint. Remove that # marker for processing below. if (s/\s*$rcce(.*?)\s*$//) { die "Nothing can follow the end of comment in '$_'\n" if length $1 > 0; $end_of_hint = 1; } # Set $h to the hash of which type. my $h = $hint->[0] eq 'Hint' ? \%hints : \%warnings; # Ignore any leading and trailing white space, and an optional star comment # continuation marker, then place the meat of the line into $1 m/^\s*(?:\*\s*)?(.*?)\s*$/; # Add the meat of this line to the hash value of each API element it # applies to for (@{$hint->[1]}) { $h->{$_} ||= ''; # avoid the warning older perls generate $h->{$_} .= "$1\n"; } # If the line had a comment close, we are through with this hint undef $hint if $end_of_hint; next; } # Set up $hint if this is the beginning of a Hint: or Warning: # These are from a multi-line C comment in the file, with the first line # looking like (a space has been inserted because this file can't have C # comment markers in it): # / * Warning: PL_expect, PL_copline, PL_rsfp # # $hint becomes # [ # 'Warning', # [ # 'PL_expect', # 'PL_copline', # 'PL_rsfp', # ], # ] if (m{^\s*$rccs\s+(Hint|Warning):\s+(\w+(?:,?\s+\w+)*)\s*$}) { $hint = [$1, [split /,?\s+/, $2]]; next; } if ($define) { # If in the middle of a definition... # append a continuation line ending with backslash. if ($define->[1] =~ /\\$/) { $define->[1] .= $_; } else { # Otherwise this line ends the definition, make foo depend on bar # (and what bar depends on) if its not one of ppp's own constructs if (exists $API{$define->[0]} && $define->[1] !~ /^DPPP_\(/) { my @n = find_api($define->[1]); push @{$depends{$define->[0]}}, @n if @n } undef $define; } } # For '#define foo bar' or '#define foo(a,b,c) bar', $define becomes a # reference to [ foo, bar ] $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+)\)}; # Set $replace to the number given for lines that look like # / * Replace: \d+ * / # (blanks added to keep real C comments from appearing in this file) # Thus setting it to 1 starts a region where replacements are automatically # done, and setting it to 0 ends that region. $replace = $1 if m{^\s*$rccs\s+Replace:\s+(\d+)\s+$rcce\s*$}; # Add bar => foo to %replace for lines like '#define foo bar in a region # where $replace is non-zero $replace{$2} = $1 if $replace and m{^\s*#\s*define\s+(\w+)(?:\([^)]*\))?\s+(\w+)}; # Add bar => foo to %replace for lines like '#define foo bar / * Replace * / # (blanks added to keep real C comments from appearing in this file) $replace{$2} = $1 if m{^\s*#\s*define\s+(\w+)(?:\([^)]*\))?\s+(\w+).*$rccs\s+Replace\s+$rcce}; # Add foo => bar to %replace for lines like / * Replace foo with bar * / # (blanks added to keep real C comments from appearing in this file) $replace{$1} = $2 if m{^\s*$rccs\s+Replace (\w+) with (\w+)\s+$rcce\s*$}; # For lines like / * foo, bar depends on baz, bat * / # create a list of the elements on the rhs, and make that list apply to each # element in the lhs, which becomes a key in \%depends. # (blanks added to keep real C comments from appearing in this file) 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 %seen; $_ = [sort dictionary_order grep !$seen{$_}++, @$_]; } 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 dictionary_order keys %API) { next unless $f =~ /$match/; print "\n=== $f ===\n"; my $info = 0; my $base; $base = int_parse_version($API{$f}{base}) if $API{$f}{base}; my $todo; $todo = int_parse_version($API{$f}{todo}) if $API{$f}{todo}; # Output information if it is generally publicly usable if ($base && ! $API{$f}{inaccessible} && ! $API{$f}{core_only}) { my $with_or= ""; if ( $base <= $int_min_perl || ( (! $API{$f}{provided} && ! $todo) || ($todo && $todo >= $base))) { $with_or= " with or"; } print "\nSupported at least since perl-", format_version($base), ",$with_or without $ppport."; if ($API{$f}{unverified}) { print "\nThis information is based on inspection of the source code", " and has not been\n", "verified by successful compilation."; } print "\n"; $info++; } if ($API{$f}{provided} || $todo) { print "\nThis is only supported by $ppport, and NOT by perl versions going forward.\n" unless $base; if ($todo) { if (! $base || $todo < $base) { my $additionally = ""; $additionally .= " additionally" if $base; print "$ppport$additionally provides support at least back to perl-", format_version($todo), ".\n"; } } elsif (! $base || $base > $int_min_perl) { if (exists $depends{$f}) { my $max = 0; for (@{$depends{$f}}) { $max = int_parse_version($API{$_}{todo}) if $API{$_}{todo} && $API{$_}{todo} > $max; # XXX What to assume unspecified values are? This effectively makes them MIN_PERL } $todo = $max if $max; } print "\n$ppport provides support for this, but ironically, does not", " currently know,\n", "for this report, the minimum version it supports for this"; if ($API{$f}{undocumented}) { print " and many things\n", "it provides that are implemented as macros and aren't", " documented. You can\n", "help by submitting a documentation patch"; } print ".\n"; if ($todo) { if ($todo <= $int_min_perl) { print "It may very well be supported all the way back to ", format_version(5.003_07), ".\n"; } else { print "But given the things $f depends on, it's a good", " guess that it isn't\n", "supported prior to ", format_version($todo), ".\n"; } } } } if ($API{$f}{provided}) { print "Support needs to be explicitly requested by #define NEED_$f\n", "(or #define NEED_${f}_GLOBAL).\n" if exists $need{$f}; $info++; } if ($base || ! $API{$f}{ppport_fnc}) { my $email = "Send email to perl5-porters\@perl.org if you need to have this functionality.\n"; if ($API{$f}{inaccessible}) { print "\nThis is not part of the public API, and may not even be accessible to XS code.\n"; $info++; } elsif ($API{$f}{core_only}) { print "\nThis is not part of the public API, and should not be used by XS code.\n"; $info++; } elsif ($API{$f}{deprecated}) { print "\nThis is deprecated and should not be used. Convert existing uses.\n"; $info++; } elsif ($API{$f}{experimental}) { print "\nThe API for this is unstable and should not be used by XS code.\n", $email; $info++; } elsif ($API{$f}{undocumented}) { print "\nSince this is undocumented, the API should be considered unstable.\n"; if ($API{$f}{provided}) { print "Consider bringing this up on the list: perl5-porters\@perl.org.\n"; } else { print "It may be that this is not intended for XS use, or it may just be\n", "that no one has gotten around to documenting it.\n", $email; } $info++; } unless ($info) { print "No portability information available. Check your spelling; or", " this could be\na bug in Devel::PPPort. To report an issue:\n", "https://github.com/Dual-Life/Devel-PPPort/issues/new\n"; } } print "\nDepends on: ", join(', ', @{$depends{$f}}), ".\n" if exists $depends{$f}; if (exists $hints{$f} || exists $warnings{$f}) { print "\n$hints{$f}" if exists $hints{$f}; print "\nWARNING:\n$warnings{$f}" if exists $warnings{$f}; $info++; } $count++; } $count or print "\nFound no API matching '$opt{'api-info'}'."; print "\n"; exit 0; } if (exists $opt{'list-provided'}) { my $f; for $f (sort dictionary_order 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} || int_parse_version($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} && int_parse_version($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 dictionary_order 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 dictionary_order keys %{$file{uses_replace}}) { warning("Uses $func instead of $replace{$func}"); $file{changes} += ($c =~ s/\b$func\b/$replace{$func}/g); } for $func (sort dictionary_order 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 dictionary_order keys %{$file{uses_todo}}) { next if int_parse_version($API{$func}{todo}) <= $int_min_perl; print "*** WARNING: Uses $func, which may not be portable below perl ", format_version($API{$func}{todo}), ", even with '$ppport'\n"; $warnings++; } } for $func (sort dictionary_order 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 dictionary_order 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 dictionary_order 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 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 D_PPP_DEC2BCD(dec) ((((dec)/100)<<8)|((((dec)%100)/10)<<4)|((dec)%10)) #define PERL_BCDVERSION ((D_PPP_DEC2BCD(PERL_REVISION)<<24)|(D_PPP_DEC2BCD(PERL_VERSION)<<12)|D_PPP_DEC2BCD(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 /* Hint: dTHX For pre-5.6.0 thread compatibility, instead use dTHXR, available only through ppport.h */ #ifndef dTHXa # define dTHXa(x) dNOOP #endif #ifndef pTHX # define pTHX void #endif #ifndef pTHX_ # define pTHX_ #endif #ifndef aTHX # define aTHX #endif /* Hint: aTHX For pre-5.6.0 thread compatibility, instead use aTHXR, available only through ppport.h */ #ifndef aTHX_ # define aTHX_ #endif /* Hint: aTHX_ For pre-5.6.0 thread compatibility, instead use aTHXR_, available only through ppport.h */ #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 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_Xpv Xpv # 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 # define PL_mess_sv mess_sv /* 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 it, 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 #if (PERL_BCDVERSION <= 0x5003022) # undef start_subparse # if (PERL_BCDVERSION < 0x5003022) #ifndef start_subparse # define start_subparse(a, b) Perl_start_subparse() #endif # else #ifndef start_subparse # define start_subparse(a, b) Perl_start_subparse(b) #endif # endif #if (PERL_BCDVERSION < 0x5003007) foo #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) /* And before that, we need to make sure this gets compiled for the functions * that rely on it */ #define NEED_newCONSTSUB #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 #if defined(NEED_newCONSTSUB) || defined(NEED_newCONSTSUB_GLOBAL) #ifdef newCONSTSUB # undef newCONSTSUB #endif #define newCONSTSUB(a,b,c) DPPP_(my_newCONSTSUB)(aTHX_ a,b,c) #define Perl_newCONSTSUB DPPP_(my_newCONSTSUB) /* 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( start_subparse(FALSE, 0), 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 #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 #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 HEf_SVKEY # define HEf_SVKEY -2 #endif #if defined(DEBUGGING) && !defined(__COVERITY__) #ifndef __ASSERT_ # define __ASSERT_(statement) assert(statement), #endif #else #ifndef __ASSERT_ # define __ASSERT_(statement) #endif #endif /* These could become provided if/when they become part of the public API */ #ifndef withinCOUNT # define withinCOUNT(c, l, n) \ (((WIDEST_UTYPE) (((c)) - ((l) | 0))) <= (((WIDEST_UTYPE) ((n) | 0)))) #endif #ifndef inRANGE # define inRANGE(c, l, u) \ ( (sizeof(c) == sizeof(U8)) ? withinCOUNT(((U8) (c)), (l), ((u) - (l))) \ : (sizeof(c) == sizeof(U16)) ? withinCOUNT(((U16) (c)), (l), ((u) - (l))) \ : (sizeof(c) == sizeof(U32)) ? withinCOUNT(((U32) (c)), (l), ((u) - (l))) \ : (withinCOUNT(((WIDEST_UTYPE) (c)), (l), ((u) - (l))))) #endif /* The '| 0' part ensures a compiler error if c is not integer (like e.g., a * pointer) */ #undef FITS_IN_8_BITS /* handy.h version uses a core-only constant */ #ifndef FITS_IN_8_BITS # define FITS_IN_8_BITS(c) ( (sizeof(c) == 1) \ || !(((WIDEST_UTYPE)((c) | 0)) & ~0xFF)) #endif /* Create the macro for "is'macro'_utf8_safe(s, e)". For code points below * 256, it calls the equivalent _L1 macro by converting the UTF-8 to code * point. That is so that it can automatically get the bug fixes done in this * file. */ #define D_PPP_IS_GENERIC_UTF8_SAFE(s, e, macro) \ (((e) - (s)) <= 0 \ ? 0 \ : UTF8_IS_INVARIANT((s)[0]) \ ? is ## macro ## _L1((s)[0]) \ : (((e) - (s)) < UTF8SKIP(s)) \ ? 0 \ : UTF8_IS_DOWNGRADEABLE_START((s)[0]) \ /* The cast in the line below is only to silence warnings */ \ ? is ## macro ## _L1((WIDEST_UTYPE) LATIN1_TO_NATIVE( \ UTF8_ACCUMULATE(NATIVE_UTF8_TO_I8((s)[0]) \ & UTF_START_MASK(2), \ (s)[1]))) \ : is ## macro ## _utf8(s)) /* Create the macro for "is'macro'_LC_utf8_safe(s, e)". For code points below * 256, it calls the equivalent _L1 macro by converting the UTF-8 to code * point. That is so that it can automatically get the bug fixes done in this * file. */ #define D_PPP_IS_GENERIC_LC_UTF8_SAFE(s, e, macro) \ (((e) - (s)) <= 0 \ ? 0 \ : UTF8_IS_INVARIANT((s)[0]) \ ? is ## macro ## _LC((s)[0]) \ : (((e) - (s)) < UTF8SKIP(s)) \ ? 0 \ : UTF8_IS_DOWNGRADEABLE_START((s)[0]) \ /* The cast in the line below is only to silence warnings */ \ ? is ## macro ## _LC((WIDEST_UTYPE) LATIN1_TO_NATIVE( \ UTF8_ACCUMULATE(NATIVE_UTF8_TO_I8((s)[0]) \ & UTF_START_MASK(2), \ (s)[1]))) \ : is ## macro ## _utf8(s)) /* A few of the early functions are broken. For these and the non-LC case, * machine generated code is substituted. But that code doesn't work for * locales. This is just like the above macro, but at the end, we call the * macro we've generated for the above 255 case, which is correct since locale * isn't involved. This will generate extra code to handle the 0-255 inputs, * but hopefully it will be optimized out by the C compiler. But just in case * it isn't, this macro is only used on the few versions that are broken */ #define D_PPP_IS_GENERIC_LC_UTF8_SAFE_BROKEN(s, e, macro) \ (((e) - (s)) <= 0 \ ? 0 \ : UTF8_IS_INVARIANT((s)[0]) \ ? is ## macro ## _LC((s)[0]) \ : (((e) - (s)) < UTF8SKIP(s)) \ ? 0 \ : UTF8_IS_DOWNGRADEABLE_START((s)[0]) \ /* The cast in the line below is only to silence warnings */ \ ? is ## macro ## _LC((WIDEST_UTYPE) LATIN1_TO_NATIVE( \ UTF8_ACCUMULATE(NATIVE_UTF8_TO_I8((s)[0]) \ & UTF_START_MASK(2), \ (s)[1]))) \ : is ## macro ## _utf8_safe(s, e)) #ifndef SvRX # define SvRX(rv) (SvROK((rv)) ? (SvMAGICAL(SvRV((rv))) ? (mg_find(SvRV((rv)), PERL_MAGIC_qr) ? mg_find(SvRV((rv)), PERL_MAGIC_qr)->mg_obj : NULL) : NULL) : NULL) #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 (PERL_BCDVERSION < 0x5004000) || defined(PERL_GCC_PEDANTIC) # ifndef PERL_GCC_BRACE_GROUPS_FORBIDDEN #ifndef PERL_GCC_BRACE_GROUPS_FORBIDDEN # define PERL_GCC_BRACE_GROUPS_FORBIDDEN #endif # 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 av_tindex # define av_tindex AvFILL #endif #ifndef av_top_index # define av_top_index 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 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 WIDEST_UTYPE # ifdef QUADKIND # ifdef U64TYPE # define WIDEST_UTYPE U64TYPE # else # define WIDEST_UTYPE Quad_t # endif # else # define WIDEST_UTYPE U32 # endif #endif /* On versions without NATIVE_TO_ASCII, only ASCII is supported */ #if defined(EBCDIC) && defined(NATIVE_TO_ASCI) #ifndef NATIVE_TO_LATIN1 # define NATIVE_TO_LATIN1(c) NATIVE_TO_ASCII(c) #endif #ifndef LATIN1_TO_NATIVE # define LATIN1_TO_NATIVE(c) ASCII_TO_NATIVE(c) #endif #ifndef NATIVE_TO_UNI # define NATIVE_TO_UNI(c) ((c) > 255 ? (c) : NATIVE_TO_LATIN1(c)) #endif #ifndef UNI_TO_NATIVE # define UNI_TO_NATIVE(c) ((c) > 255 ? (c) : LATIN1_TO_NATIVE(c)) #endif #else #ifndef NATIVE_TO_LATIN1 # define NATIVE_TO_LATIN1(c) (c) #endif #ifndef LATIN1_TO_NATIVE # define LATIN1_TO_NATIVE(c) (c) #endif #ifndef NATIVE_TO_UNI # define NATIVE_TO_UNI(c) (c) #endif #ifndef UNI_TO_NATIVE # define UNI_TO_NATIVE(c) (c) #endif #endif /* Warning: LATIN1_TO_NATIVE, NATIVE_TO_LATIN1 NATIVE_TO_UNI UNI_TO_NATIVE EBCDIC is not supported on versions earlier than 5.7.1 */ /* The meaning of this changed; use the modern version */ #undef isPSXSPC #undef isPSXSPC_A #undef isPSXSPC_L1 /* Hint: isPSXSPC, isPSXSPC_A, isPSXSPC_L1, isPSXSPC_utf8_safe This is equivalent to the corresponding isSPACE-type macro. On perls before 5.18, this matched a vertical tab and SPACE didn't. But the ppport.h SPACE version does match VT in all perl releases. Since VT's are extremely rarely found in real-life files, this difference effectively doesn't matter */ /* Hint: isSPACE, isSPACE_A, isSPACE_L1, isSPACE_utf8_safe Until Perl 5.18, this did not match the vertical tab (VT). The ppport.h version does match it in all perl releases. Since VT's are extremely rarely found in real-life files, this difference effectively doesn't matter */ #ifdef EBCDIC /* This is the first version where these macros are fully correct on EBCDIC * platforms. Relying on * the C library functions, as earlier releases did, * causes problems with * locales */ # if (PERL_BCDVERSION < 0x5022000) # undef isALNUM # undef isALNUM_A # undef isALNUM_L1 # undef isALNUMC # undef isALNUMC_A # undef isALNUMC_L1 # undef isALPHA # undef isALPHA_A # undef isALPHA_L1 # undef isALPHANUMERIC # undef isALPHANUMERIC_A # undef isALPHANUMERIC_L1 # undef isASCII # undef isASCII_A # undef isASCII_L1 # undef isBLANK # undef isBLANK_A # undef isBLANK_L1 # undef isCNTRL # undef isCNTRL_A # undef isCNTRL_L1 # undef isDIGIT # undef isDIGIT_A # undef isDIGIT_L1 # undef isGRAPH # undef isGRAPH_A # undef isGRAPH_L1 # undef isIDCONT # undef isIDCONT_A # undef isIDCONT_L1 # undef isIDFIRST # undef isIDFIRST_A # undef isIDFIRST_L1 # undef isLOWER # undef isLOWER_A # undef isLOWER_L1 # undef isOCTAL # undef isOCTAL_A # undef isOCTAL_L1 # undef isPRINT # undef isPRINT_A # undef isPRINT_L1 # undef isPUNCT # undef isPUNCT_A # undef isPUNCT_L1 # undef isSPACE # undef isSPACE_A # undef isSPACE_L1 # undef isUPPER # undef isUPPER_A # undef isUPPER_L1 # undef isWORDCHAR # undef isWORDCHAR_A # undef isWORDCHAR_L1 # undef isXDIGIT # undef isXDIGIT_A # undef isXDIGIT_L1 # endif #ifndef isASCII # define isASCII(c) (isCNTRL(c) || isPRINT(c)) #endif /* The below is accurate for all EBCDIC code pages supported by * all the versions of Perl overridden by this */ #ifndef isCNTRL # define isCNTRL(c) ( (c) == '\0' || (c) == '\a' || (c) == '\b' \ || (c) == '\f' || (c) == '\n' || (c) == '\r' \ || (c) == '\t' || (c) == '\v' \ || ((c) <= 3 && (c) >= 1) /* SOH, STX, ETX */ \ || (c) == 7 /* U+7F DEL */ \ || ((c) <= 0x13 && (c) >= 0x0E) /* SO, SI */ \ /* DLE, DC[1-3] */ \ || (c) == 0x18 /* U+18 CAN */ \ || (c) == 0x19 /* U+19 EOM */ \ || ((c) <= 0x1F && (c) >= 0x1C) /* [FGRU]S */ \ || (c) == 0x26 /* U+17 ETB */ \ || (c) == 0x27 /* U+1B ESC */ \ || (c) == 0x2D /* U+05 ENQ */ \ || (c) == 0x2E /* U+06 ACK */ \ || (c) == 0x32 /* U+16 SYN */ \ || (c) == 0x37 /* U+04 EOT */ \ || (c) == 0x3C /* U+14 DC4 */ \ || (c) == 0x3D /* U+15 NAK */ \ || (c) == 0x3F /* U+1A SUB */ \ ) #endif #if '^' == 106 /* EBCDIC POSIX-BC */ # define D_PPP_OUTLIER_CONTROL 0x5F #else /* EBCDIC 1047 037 */ # define D_PPP_OUTLIER_CONTROL 0xFF #endif /* The controls are everything below blank, plus one outlier */ #ifndef isCNTRL_L1 # define isCNTRL_L1(c) ((WIDEST_UTYPE) (c) < ' ' \ || (WIDEST_UTYPE) (c) == D_PPP_OUTLIER_CONTROL) #endif /* The ordering of the tests in this and isUPPER are to exclude most characters * early */ #ifndef isLOWER # define isLOWER(c) ( (c) >= 'a' && (c) <= 'z' \ && ( (c) <= 'i' \ || ((c) >= 'j' && (c) <= 'r') \ || (c) >= 's')) #endif #ifndef isUPPER # define isUPPER(c) ( (c) >= 'A' && (c) <= 'Z' \ && ( (c) <= 'I' \ || ((c) >= 'J' && (c) <= 'R') \ || (c) >= 'S')) #endif #else /* Above is EBCDIC; below is ASCII */ # if (PERL_BCDVERSION < 0x5004000) /* The implementation of these in older perl versions can give wrong results if * the C program locale is set to other than the C locale */ # undef isALNUM # undef isALNUM_A # undef isALPHA # undef isALPHA_A # undef isDIGIT # undef isDIGIT_A # undef isIDFIRST # undef isIDFIRST_A # undef isLOWER # undef isLOWER_A # undef isUPPER # undef isUPPER_A # endif # if (PERL_BCDVERSION == 0x5007000) /* this perl made space GRAPH */ # undef isGRAPH # endif # if (PERL_BCDVERSION < 0x5008000) /* earlier perls omitted DEL */ # undef isCNTRL # endif # if (PERL_BCDVERSION < 0x5010000) /* earlier perls included all of the isSPACE() characters, which is wrong. The * version provided by Devel::PPPort always overrides an existing buggy * version. */ # undef isPRINT # undef isPRINT_A # endif # if (PERL_BCDVERSION < 0x5014000) /* earlier perls always returned true if the parameter was a signed char */ # undef isASCII # undef isASCII_A # endif # if (PERL_BCDVERSION < 0x5017008) /* earlier perls didn't include PILCROW, SECTION SIGN */ # undef isPUNCT_L1 # endif # if (PERL_BCDVERSION < 0x5013007) /* khw didn't investigate why this failed */ # undef isALNUMC_L1 #endif # if (PERL_BCDVERSION < 0x5020000) /* earlier perls didn't include \v */ # undef isSPACE # undef isSPACE_A # undef isSPACE_L1 # endif #ifndef isASCII # define isASCII(c) ((WIDEST_UTYPE) (c) <= 127) #endif #ifndef isCNTRL # define isCNTRL(c) ((WIDEST_UTYPE) (c) < ' ' || (c) == 127) #endif #ifndef isCNTRL_L1 # define isCNTRL_L1(c) (isCNTRL(c) || ( (WIDEST_UTYPE) (c) <= 0x9F \ && (WIDEST_UTYPE) (c) >= 0x80)) #endif #ifndef isLOWER # define isLOWER(c) ((c) >= 'a' && (c) <= 'z') #endif #ifndef isUPPER # define isUPPER(c) ((c) <= 'Z' && (c) >= 'A') #endif #endif /* Below are definitions common to EBCDIC and ASCII */ #ifndef isASCII_L1 # define isASCII_L1(c) isASCII(c) #endif #ifndef isASCII_LC # define isASCII_LC(c) isASCII(c) #endif #ifndef isALNUM # define isALNUM(c) isWORDCHAR(c) #endif #ifndef isALNUMC # define isALNUMC(c) isALPHANUMERIC(c) #endif #ifndef isALNUMC_L1 # define isALNUMC_L1(c) isALPHANUMERIC_L1(c) #endif #ifndef isALPHA # define isALPHA(c) (isUPPER(c) || isLOWER(c)) #endif #ifndef isALPHA_L1 # define isALPHA_L1(c) (isUPPER_L1(c) || isLOWER_L1(c)) #endif #ifndef isALPHANUMERIC # define isALPHANUMERIC(c) (isALPHA(c) || isDIGIT(c)) #endif #ifndef isALPHANUMERIC_L1 # define isALPHANUMERIC_L1(c) (isALPHA_L1(c) || isDIGIT(c)) #endif #ifndef isALPHANUMERIC_LC # define isALPHANUMERIC_LC(c) (isALPHA_LC(c) || isDIGIT_LC(c)) #endif #ifndef isBLANK # define isBLANK(c) ((c) == ' ' || (c) == '\t') #endif #ifndef isBLANK_L1 # define isBLANK_L1(c) ( isBLANK(c) \ || ( FITS_IN_8_BITS(c) \ && NATIVE_TO_LATIN1((U8) c) == 0xA0)) #endif #ifndef isBLANK_LC # define isBLANK_LC(c) isBLANK(c) #endif #ifndef isDIGIT # define isDIGIT(c) inRANGE(c, '0', '9') #endif #ifndef isDIGIT_L1 # define isDIGIT_L1(c) isDIGIT(c) #endif #ifndef isGRAPH # define isGRAPH(c) (isWORDCHAR(c) || isPUNCT(c)) #endif #ifndef isGRAPH_L1 # define isGRAPH_L1(c) ( isPRINT_L1(c) \ && (c) != ' ' \ && NATIVE_TO_LATIN1((U8) c) != 0xA0) #endif #ifndef isIDCONT # define isIDCONT(c) isWORDCHAR(c) #endif #ifndef isIDCONT_L1 # define isIDCONT_L1(c) isWORDCHAR_L1(c) #endif #ifndef isIDCONT_LC # define isIDCONT_LC(c) isWORDCHAR_LC(c) #endif #ifndef isIDFIRST # define isIDFIRST(c) (isALPHA(c) || (c) == '_') #endif #ifndef isIDFIRST_L1 # define isIDFIRST_L1(c) (isALPHA_L1(c) || (U8) (c) == '_') #endif #ifndef isIDFIRST_LC # define isIDFIRST_LC(c) (isALPHA_LC(c) || (U8) (c) == '_') #endif #ifndef isLOWER_L1 # define isLOWER_L1(c) ( isLOWER(c) \ || ( FITS_IN_8_BITS(c) \ && ( ( NATIVE_TO_LATIN1((U8) c) >= 0xDF \ && NATIVE_TO_LATIN1((U8) c) != 0xF7) \ || NATIVE_TO_LATIN1((U8) c) == 0xAA \ || NATIVE_TO_LATIN1((U8) c) == 0xBA \ || NATIVE_TO_LATIN1((U8) c) == 0xB5))) #endif #ifndef isOCTAL # define isOCTAL(c) (((WIDEST_UTYPE)((c)) & ~7) == '0') #endif #ifndef isOCTAL_L1 # define isOCTAL_L1(c) isOCTAL(c) #endif #ifndef isPRINT # define isPRINT(c) (isGRAPH(c) || (c) == ' ') #endif #ifndef isPRINT_L1 # define isPRINT_L1(c) (FITS_IN_8_BITS(c) && ! isCNTRL_L1(c)) #endif #ifndef isPSXSPC # define isPSXSPC(c) isSPACE(c) #endif #ifndef isPSXSPC_L1 # define isPSXSPC_L1(c) isSPACE_L1(c) #endif #ifndef isPUNCT # define isPUNCT(c) ( (c) == '-' || (c) == '!' || (c) == '"' \ || (c) == '#' || (c) == '$' || (c) == '%' \ || (c) == '&' || (c) == '\'' || (c) == '(' \ || (c) == ')' || (c) == '*' || (c) == '+' \ || (c) == ',' || (c) == '.' || (c) == '/' \ || (c) == ':' || (c) == ';' || (c) == '<' \ || (c) == '=' || (c) == '>' || (c) == '?' \ || (c) == '@' || (c) == '[' || (c) == '\\' \ || (c) == ']' || (c) == '^' || (c) == '_' \ || (c) == '`' || (c) == '{' || (c) == '|' \ || (c) == '}' || (c) == '~') #endif #ifndef isPUNCT_L1 # define isPUNCT_L1(c) ( isPUNCT(c) \ || ( FITS_IN_8_BITS(c) \ && ( NATIVE_TO_LATIN1((U8) c) == 0xA1 \ || NATIVE_TO_LATIN1((U8) c) == 0xA7 \ || NATIVE_TO_LATIN1((U8) c) == 0xAB \ || NATIVE_TO_LATIN1((U8) c) == 0xB6 \ || NATIVE_TO_LATIN1((U8) c) == 0xB7 \ || NATIVE_TO_LATIN1((U8) c) == 0xBB \ || NATIVE_TO_LATIN1((U8) c) == 0xBF))) #endif #ifndef isSPACE # define isSPACE(c) ( isBLANK(c) || (c) == '\n' || (c) == '\r' \ || (c) == '\v' || (c) == '\f') #endif #ifndef isSPACE_L1 # define isSPACE_L1(c) ( isSPACE(c) \ || (FITS_IN_8_BITS(c) \ && ( NATIVE_TO_LATIN1((U8) c) == 0x85 \ || NATIVE_TO_LATIN1((U8) c) == 0xA0))) #endif #ifndef isUPPER_L1 # define isUPPER_L1(c) ( isUPPER(c) \ || (FITS_IN_8_BITS(c) \ && ( NATIVE_TO_LATIN1((U8) c) >= 0xC0 \ && NATIVE_TO_LATIN1((U8) c) <= 0xDE \ && NATIVE_TO_LATIN1((U8) c) != 0xD7))) #endif #ifndef isWORDCHAR # define isWORDCHAR(c) (isALPHANUMERIC(c) || (c) == '_') #endif #ifndef isWORDCHAR_L1 # define isWORDCHAR_L1(c) (isIDFIRST_L1(c) || isDIGIT(c)) #endif #ifndef isWORDCHAR_LC # define isWORDCHAR_LC(c) (isIDFIRST_LC(c) || isDIGIT_LC(c)) #endif #ifndef isXDIGIT # define isXDIGIT(c) ( isDIGIT(c) \ || ((c) >= 'a' && (c) <= 'f') \ || ((c) >= 'A' && (c) <= 'F')) #endif #ifndef isXDIGIT_L1 # define isXDIGIT_L1(c) isXDIGIT(c) #endif #ifndef isXDIGIT_LC # define isXDIGIT_LC(c) isxdigit(c) #endif #ifndef isALNUM_A # define isALNUM_A(c) isALNUM(c) #endif #ifndef isALNUMC_A # define isALNUMC_A(c) isALNUMC(c) #endif #ifndef isALPHA_A # define isALPHA_A(c) isALPHA(c) #endif #ifndef isALPHANUMERIC_A # define isALPHANUMERIC_A(c) isALPHANUMERIC(c) #endif #ifndef isASCII_A # define isASCII_A(c) isASCII(c) #endif #ifndef isBLANK_A # define isBLANK_A(c) isBLANK(c) #endif #ifndef isCNTRL_A # define isCNTRL_A(c) isCNTRL(c) #endif #ifndef isDIGIT_A # define isDIGIT_A(c) isDIGIT(c) #endif #ifndef isGRAPH_A # define isGRAPH_A(c) isGRAPH(c) #endif #ifndef isIDCONT_A # define isIDCONT_A(c) isIDCONT(c) #endif #ifndef isIDFIRST_A # define isIDFIRST_A(c) isIDFIRST(c) #endif #ifndef isLOWER_A # define isLOWER_A(c) isLOWER(c) #endif #ifndef isOCTAL_A # define isOCTAL_A(c) isOCTAL(c) #endif #ifndef isPRINT_A # define isPRINT_A(c) isPRINT(c) #endif #ifndef isPSXSPC_A # define isPSXSPC_A(c) isPSXSPC(c) #endif #ifndef isPUNCT_A # define isPUNCT_A(c) isPUNCT(c) #endif #ifndef isSPACE_A # define isSPACE_A(c) isSPACE(c) #endif #ifndef isUPPER_A # define isUPPER_A(c) isUPPER(c) #endif #ifndef isWORDCHAR_A # define isWORDCHAR_A(c) isWORDCHAR(c) #endif #ifndef isXDIGIT_A # define isXDIGIT_A(c) isXDIGIT(c) #endif #ifndef isASCII_utf8_safe # define isASCII_utf8_safe(s,e) (((e) - (s)) <= 0 ? 0 : isASCII(*(s))) #endif #ifndef isASCII_uvchr # define isASCII_uvchr(c) (FITS_IN_8_BITS(c) ? isASCII_L1(c) : 0) #endif #if (PERL_BCDVERSION >= 0x5006000) # ifdef isALPHA_uni /* If one defined, all are; this is just an exemplar */ # define D_PPP_is_ctype(upper, lower, c) \ (FITS_IN_8_BITS(c) \ ? is ## upper ## _L1(c) \ : is ## upper ## _uni((UV) (c))) /* _uni is old synonym */ # else # define D_PPP_is_ctype(upper, lower, c) \ (FITS_IN_8_BITS(c) \ ? is ## upper ## _L1(c) \ : is_uni_ ## lower((UV) (c))) /* is_uni_ is even older */ # endif #ifndef isALPHA_uvchr # define isALPHA_uvchr(c) D_PPP_is_ctype(ALPHA, alpha, c) #endif #ifndef isALPHANUMERIC_uvchr # define isALPHANUMERIC_uvchr(c) (isALPHA_uvchr(c) || isDIGIT_uvchr(c)) #endif # ifdef is_uni_blank #ifndef isBLANK_uvchr # define isBLANK_uvchr(c) D_PPP_is_ctype(BLANK, blank, c) #endif # else #ifndef isBLANK_uvchr # define isBLANK_uvchr(c) (FITS_IN_8_BITS(c) \ ? isBLANK_L1(c) \ : ( (UV) (c) == 0x1680 /* Unicode 3.0 */ \ || inRANGE((UV) (c), 0x2000, 0x200A) \ || (UV) (c) == 0x202F /* Unicode 3.0 */\ || (UV) (c) == 0x205F /* Unicode 3.2 */\ || (UV) (c) == 0x3000)) #endif # endif #ifndef isCNTRL_uvchr # define isCNTRL_uvchr(c) D_PPP_is_ctype(CNTRL, cntrl, c) #endif #ifndef isDIGIT_uvchr # define isDIGIT_uvchr(c) D_PPP_is_ctype(DIGIT, digit, c) #endif #ifndef isGRAPH_uvchr # define isGRAPH_uvchr(c) D_PPP_is_ctype(GRAPH, graph, c) #endif #ifndef isIDCONT_uvchr # define isIDCONT_uvchr(c) isWORDCHAR_uvchr(c) #endif #ifndef isIDFIRST_uvchr # define isIDFIRST_uvchr(c) D_PPP_is_ctype(IDFIRST, idfirst, c) #endif #ifndef isLOWER_uvchr # define isLOWER_uvchr(c) D_PPP_is_ctype(LOWER, lower, c) #endif #ifndef isPRINT_uvchr # define isPRINT_uvchr(c) D_PPP_is_ctype(PRINT, print, c) #endif #ifndef isPSXSPC_uvchr # define isPSXSPC_uvchr(c) isSPACE_uvchr(c) #endif #ifndef isPUNCT_uvchr # define isPUNCT_uvchr(c) D_PPP_is_ctype(PUNCT, punct, c) #endif #ifndef isSPACE_uvchr # define isSPACE_uvchr(c) D_PPP_is_ctype(SPACE, space, c) #endif #ifndef isUPPER_uvchr # define isUPPER_uvchr(c) D_PPP_is_ctype(UPPER, upper, c) #endif #ifndef isXDIGIT_uvchr # define isXDIGIT_uvchr(c) D_PPP_is_ctype(XDIGIT, xdigit, c) #endif #ifndef isWORDCHAR_uvchr # define isWORDCHAR_uvchr(c) (FITS_IN_8_BITS(c) \ ? isWORDCHAR_L1(c) : isALPHANUMERIC_uvchr(c)) #endif #ifndef isALPHA_utf8_safe # define isALPHA_utf8_safe(s,e) D_PPP_IS_GENERIC_UTF8_SAFE(s, e, ALPHA) #endif # ifdef isALPHANUMERIC_utf8 #ifndef isALPHANUMERIC_utf8_safe # define isALPHANUMERIC_utf8_safe(s,e) \ D_PPP_IS_GENERIC_UTF8_SAFE(s, e, ALPHANUMERIC) #endif # else #ifndef isALPHANUMERIC_utf8_safe # define isALPHANUMERIC_utf8_safe(s,e) \ (isALPHA_utf8_safe(s,e) || isDIGIT_utf8_safe(s,e)) #endif # endif /* This was broken before 5.18, and just use this instead of worrying about * which releases the official works on */ # if 'A' == 65 #ifndef isBLANK_utf8_safe # define isBLANK_utf8_safe(s,e) \ ( ( LIKELY((e) > (s)) ) ? /* Machine generated */ \ ( ( 0x09 == ((const U8*)s)[0] || 0x20 == ((const U8*)s)[0] ) ? 1 \ : ( LIKELY(((e) - (s)) >= UTF8SKIP(s)) ) ? \ ( ( 0xC2 == ((const U8*)s)[0] ) ? \ ( ( 0xA0 == ((const U8*)s)[1] ) ? 2 : 0 ) \ : ( 0xE1 == ((const U8*)s)[0] ) ? \ ( ( ( 0x9A == ((const U8*)s)[1] ) && ( 0x80 == ((const U8*)s)[2] ) ) ? 3 : 0 )\ : ( 0xE2 == ((const U8*)s)[0] ) ? \ ( ( 0x80 == ((const U8*)s)[1] ) ? \ ( ( inRANGE(((const U8*)s)[2], 0x80, 0x8A ) || 0xAF == ((const U8*)s)[2] ) ? 3 : 0 )\ : ( ( 0x81 == ((const U8*)s)[1] ) && ( 0x9F == ((const U8*)s)[2] ) ) ? 3 : 0 )\ : ( ( ( 0xE3 == ((const U8*)s)[0] ) && ( 0x80 == ((const U8*)s)[1] ) ) && ( 0x80 == ((const U8*)s)[2] ) ) ? 3 : 0 )\ : 0 ) \ : 0 ) #endif # elif 'A' == 193 && '^' == 95 /* EBCDIC 1047 */ #ifndef isBLANK_utf8_safe # define isBLANK_utf8_safe(s,e) \ ( ( LIKELY((e) > (s)) ) ? \ ( ( 0x05 == ((const U8*)s)[0] || 0x40 == ((const U8*)s)[0] ) ? 1 \ : ( LIKELY(((e) - (s)) >= UTF8SKIP(s)) ) ? \ ( ( 0x80 == ((const U8*)s)[0] ) ? \ ( ( 0x41 == ((const U8*)s)[1] ) ? 2 : 0 ) \ : ( 0xBC == ((const U8*)s)[0] ) ? \ ( ( ( 0x63 == ((const U8*)s)[1] ) && ( 0x41 == ((const U8*)s)[2] ) ) ? 3 : 0 )\ : ( 0xCA == ((const U8*)s)[0] ) ? \ ( ( 0x41 == ((const U8*)s)[1] ) ? \ ( ( inRANGE(((const U8*)s)[2], 0x41, 0x4A ) || 0x51 == ((const U8*)s)[2] ) ? 3 : 0 )\ : ( 0x42 == ((const U8*)s)[1] ) ? \ ( ( 0x56 == ((const U8*)s)[2] ) ? 3 : 0 ) \ : ( ( 0x43 == ((const U8*)s)[1] ) && ( 0x73 == ((const U8*)s)[2] ) ) ? 3 : 0 )\ : ( ( ( 0xCE == ((const U8*)s)[0] ) && ( 0x41 == ((const U8*)s)[1] ) ) && ( 0x41 == ((const U8*)s)[2] ) ) ? 3 : 0 )\ : 0 ) \ : 0 ) #endif # elif 'A' == 193 && '^' == 176 /* EBCDIC 037 */ #ifndef isBLANK_utf8_safe # define isBLANK_utf8_safe(s,e) \ ( ( LIKELY((e) > (s)) ) ? \ ( ( 0x05 == ((const U8*)s)[0] || 0x40 == ((const U8*)s)[0] ) ? 1 \ : ( LIKELY(((e) - (s)) >= UTF8SKIP(s)) ) ? \ ( ( 0x78 == ((const U8*)s)[0] ) ? \ ( ( 0x41 == ((const U8*)s)[1] ) ? 2 : 0 ) \ : ( 0xBD == ((const U8*)s)[0] ) ? \ ( ( ( 0x62 == ((const U8*)s)[1] ) && ( 0x41 == ((const U8*)s)[2] ) ) ? 3 : 0 )\ : ( 0xCA == ((const U8*)s)[0] ) ? \ ( ( 0x41 == ((const U8*)s)[1] ) ? \ ( ( inRANGE(((const U8*)s)[2], 0x41, 0x4A ) || 0x51 == ((const U8*)s)[2] ) ? 3 : 0 )\ : ( 0x42 == ((const U8*)s)[1] ) ? \ ( ( 0x56 == ((const U8*)s)[2] ) ? 3 : 0 ) \ : ( ( 0x43 == ((const U8*)s)[1] ) && ( 0x72 == ((const U8*)s)[2] ) ) ? 3 : 0 )\ : ( ( ( 0xCE == ((const U8*)s)[0] ) && ( 0x41 == ((const U8*)s)[1] ) ) && ( 0x41 == ((const U8*)s)[2] ) ) ? 3 : 0 )\ : 0 ) \ : 0 ) #endif # else # error Unknown character set # endif #ifndef isCNTRL_utf8_safe # define isCNTRL_utf8_safe(s,e) D_PPP_IS_GENERIC_UTF8_SAFE(s, e, CNTRL) #endif #ifndef isDIGIT_utf8_safe # define isDIGIT_utf8_safe(s,e) D_PPP_IS_GENERIC_UTF8_SAFE(s, e, DIGIT) #endif #ifndef isGRAPH_utf8_safe # define isGRAPH_utf8_safe(s,e) D_PPP_IS_GENERIC_UTF8_SAFE(s, e, GRAPH) #endif # ifdef isIDCONT_utf8 #ifndef isIDCONT_utf8_safe # define isIDCONT_utf8_safe(s,e) D_PPP_IS_GENERIC_UTF8_SAFE(s, e, IDCONT) #endif # else #ifndef isIDCONT_utf8_safe # define isIDCONT_utf8_safe(s,e) isWORDCHAR_utf8_safe(s,e) #endif # endif #ifndef isIDFIRST_utf8_safe # define isIDFIRST_utf8_safe(s,e) D_PPP_IS_GENERIC_UTF8_SAFE(s, e, IDFIRST) #endif #ifndef isLOWER_utf8_safe # define isLOWER_utf8_safe(s,e) D_PPP_IS_GENERIC_UTF8_SAFE(s, e, LOWER) #endif #ifndef isPRINT_utf8_safe # define isPRINT_utf8_safe(s,e) D_PPP_IS_GENERIC_UTF8_SAFE(s, e, PRINT) #endif # undef isPSXSPC_utf8_safe /* Use the modern definition */ #ifndef isPSXSPC_utf8_safe # define isPSXSPC_utf8_safe(s,e) isSPACE_utf8_safe(s,e) #endif #ifndef isPUNCT_utf8_safe # define isPUNCT_utf8_safe(s,e) D_PPP_IS_GENERIC_UTF8_SAFE(s, e, PUNCT) #endif #ifndef isSPACE_utf8_safe # define isSPACE_utf8_safe(s,e) D_PPP_IS_GENERIC_UTF8_SAFE(s, e, SPACE) #endif #ifndef isUPPER_utf8_safe # define isUPPER_utf8_safe(s,e) D_PPP_IS_GENERIC_UTF8_SAFE(s, e, UPPER) #endif # ifdef isWORDCHAR_utf8 #ifndef isWORDCHAR_utf8_safe # define isWORDCHAR_utf8_safe(s,e) D_PPP_IS_GENERIC_UTF8_SAFE(s, e, WORDCHAR) #endif # else #ifndef isWORDCHAR_utf8_safe # define isWORDCHAR_utf8_safe(s,e) \ (isALPHANUMERIC_utf8_safe(s,e) || (*(s)) == '_') #endif # endif /* This was broken before 5.12, and just use this instead of worrying about * which releases the official works on */ # if 'A' == 65 #ifndef isXDIGIT_utf8_safe # define isXDIGIT_utf8_safe(s,e) \ ( ( LIKELY((e) > (s)) ) ? \ ( ( inRANGE(((const U8*)s)[0], 0x30, 0x39 ) || inRANGE(((const U8*)s)[0], 0x41, 0x46 ) || inRANGE(((const U8*)s)[0], 0x61, 0x66 ) ) ? 1\ : ( ( LIKELY(((e) - (s)) >= UTF8SKIP(s)) ) && ( 0xEF == ((const U8*)s)[0] ) ) ? ( ( 0xBC == ((const U8*)s)[1] ) ?\ ( ( inRANGE(((const U8*)s)[2], 0x90, 0x99 ) || inRANGE(((const U8*)s)[2], 0xA1, 0xA6 ) ) ? 3 : 0 )\ : ( ( 0xBD == ((const U8*)s)[1] ) && ( inRANGE(((const U8*)s)[2], 0x81, 0x86 ) ) ) ? 3 : 0 ) : 0 )\ : 0 ) #endif # elif 'A' == 193 && '^' == 95 /* EBCDIC 1047 */ #ifndef isXDIGIT_utf8_safe # define isXDIGIT_utf8_safe(s,e) \ ( ( LIKELY((e) > (s)) ) ? \ ( ( inRANGE(((const U8*)s)[0], 0x81, 0x86 ) || inRANGE(((const U8*)s)[0], 0xC1, 0xC6 ) || inRANGE(((const U8*)s)[0], 0xF0, 0xF9 ) ) ? 1\ : ( ( ( LIKELY(((e) - (s)) >= UTF8SKIP(s)) ) && ( 0xDD == ((const U8*)s)[0] ) ) && ( 0x73 == ((const U8*)s)[1] ) ) ? ( ( 0x67 == ((const U8*)s)[2] ) ?\ ( ( inRANGE(((const U8*)s)[3], 0x57, 0x59 ) || inRANGE(((const U8*)s)[3], 0x62, 0x68 ) ) ? 4 : 0 )\ : ( ( inRANGE(((const U8*)s)[2], 0x68, 0x69 ) ) && ( inRANGE(((const U8*)s)[3], 0x42, 0x47 ) ) ) ? 4 : 0 ) : 0 )\ : 0 ) #endif # elif 'A' == 193 && '^' == 176 /* EBCDIC 037 */ #ifndef isXDIGIT_utf8_safe # define isXDIGIT_utf8_safe(s,e) \ ( ( LIKELY((e) > (s)) ) ? \ ( ( inRANGE(((const U8*)s)[0], 0x81, 0x86 ) || inRANGE(((const U8*)s)[0], 0xC1, 0xC6 ) || inRANGE(((const U8*)s)[0], 0xF0, 0xF9 ) ) ? 1\ : ( ( ( LIKELY(((e) - (s)) >= UTF8SKIP(s)) ) && ( 0xDD == ((const U8*)s)[0] ) ) && ( 0x72 == ((const U8*)s)[1] ) ) ? ( ( 0x66 == ((const U8*)s)[2] ) ?\ ( ( inRANGE(((const U8*)s)[3], 0x57, 0x59 ) || 0x5F == ((const U8*)s)[3] || inRANGE(((const U8*)s)[3], 0x62, 0x67 ) ) ? 4 : 0 )\ : ( ( inRANGE(((const U8*)s)[2], 0x67, 0x68 ) ) && ( inRANGE(((const U8*)s)[3], 0x42, 0x47 ) ) ) ? 4 : 0 ) : 0 )\ : 0 ) #endif # else # error Unknown character set # endif #ifndef isALPHA_LC_utf8_safe # define isALPHA_LC_utf8_safe(s,e) D_PPP_IS_GENERIC_LC_UTF8_SAFE(s, e, ALPHA) #endif # ifdef isALPHANUMERIC_utf8 #ifndef isALPHANUMERIC_LC_utf8_safe # define isALPHANUMERIC_LC_utf8_safe(s,e) \ D_PPP_IS_GENERIC_LC_UTF8_SAFE(s, e, ALPHANUMERIC) #endif # else #ifndef isALPHANUMERIC_LC_utf8_safe # define isALPHANUMERIC_LC_utf8_safe(s,e) \ (isALPHA_LC_utf8_safe(s,e) || isDIGIT_LC_utf8_safe(s,e)) #endif # endif #ifndef isBLANK_LC_utf8_safe # define isBLANK_LC_utf8_safe(s,e) \ D_PPP_IS_GENERIC_LC_UTF8_SAFE_BROKEN(s, e, BLANK) #endif #ifndef isCNTRL_LC_utf8_safe # define isCNTRL_LC_utf8_safe(s,e) D_PPP_IS_GENERIC_LC_UTF8_SAFE(s, e, CNTRL) #endif #ifndef isDIGIT_LC_utf8_safe # define isDIGIT_LC_utf8_safe(s,e) D_PPP_IS_GENERIC_LC_UTF8_SAFE(s, e, DIGIT) #endif #ifndef isGRAPH_LC_utf8_safe # define isGRAPH_LC_utf8_safe(s,e) D_PPP_IS_GENERIC_LC_UTF8_SAFE(s, e, GRAPH) #endif # ifdef isIDCONT_utf8 #ifndef isIDCONT_LC_utf8_safe # define isIDCONT_LC_utf8_safe(s,e) D_PPP_IS_GENERIC_LC_UTF8_SAFE(s, e, IDCONT) #endif # else #ifndef isIDCONT_LC_utf8_safe # define isIDCONT_LC_utf8_safe(s,e) isWORDCHAR_LC_utf8_safe(s,e) #endif # endif #ifndef isIDFIRST_LC_utf8_safe # define isIDFIRST_LC_utf8_safe(s,e) D_PPP_IS_GENERIC_LC_UTF8_SAFE(s, e, IDFIRST) #endif #ifndef isLOWER_LC_utf8_safe # define isLOWER_LC_utf8_safe(s,e) D_PPP_IS_GENERIC_LC_UTF8_SAFE(s, e, LOWER) #endif #ifndef isPRINT_LC_utf8_safe # define isPRINT_LC_utf8_safe(s,e) D_PPP_IS_GENERIC_LC_UTF8_SAFE(s, e, PRINT) #endif # undef isPSXSPC_LC_utf8_safe /* Use the modern definition */ #ifndef isPSXSPC_LC_utf8_safe # define isPSXSPC_LC_utf8_safe(s,e) isSPACE_LC_utf8_safe(s,e) #endif #ifndef isPUNCT_LC_utf8_safe # define isPUNCT_LC_utf8_safe(s,e) D_PPP_IS_GENERIC_LC_UTF8_SAFE(s, e, PUNCT) #endif #ifndef isSPACE_LC_utf8_safe # define isSPACE_LC_utf8_safe(s,e) D_PPP_IS_GENERIC_LC_UTF8_SAFE(s, e, SPACE) #endif #ifndef isUPPER_LC_utf8_safe # define isUPPER_LC_utf8_safe(s,e) D_PPP_IS_GENERIC_LC_UTF8_SAFE(s, e, UPPER) #endif # ifdef isWORDCHAR_utf8 #ifndef isWORDCHAR_LC_utf8_safe # define isWORDCHAR_LC_utf8_safe(s,e) D_PPP_IS_GENERIC_LC_UTF8_SAFE(s, e, WORDCHAR) #endif # else #ifndef isWORDCHAR_LC_utf8_safe # define isWORDCHAR_LC_utf8_safe(s,e) \ (isALPHANUMERIC_LC_utf8_safe(s,e) || (*(s)) == '_') #endif # endif #ifndef isXDIGIT_LC_utf8_safe # define isXDIGIT_LC_utf8_safe(s,e) \ D_PPP_IS_GENERIC_LC_UTF8_SAFE_BROKEN(s, e, XDIGIT) #endif /* Warning: isALPHANUMERIC_utf8_safe, isALPHA_utf8_safe, isASCII_utf8_safe, * isBLANK_utf8_safe, isCNTRL_utf8_safe, isDIGIT_utf8_safe, isGRAPH_utf8_safe, * isIDCONT_utf8_safe, isIDFIRST_utf8_safe, isLOWER_utf8_safe, * isPRINT_utf8_safe, isPSXSPC_utf8_safe, isPUNCT_utf8_safe, isSPACE_utf8_safe, * isUPPER_utf8_safe, isWORDCHAR_utf8_safe, isWORDCHAR_utf8_safe, * isXDIGIT_utf8_safe, * isALPHANUMERIC_LC_utf8_safe, isALPHA_LC_utf8_safe, isASCII_LC_utf8_safe, * isBLANK_LC_utf8_safe, isCNTRL_LC_utf8_safe, isDIGIT_LC_utf8_safe, * isGRAPH_LC_utf8_safe, isIDCONT_LC_utf8_safe, isIDFIRST_LC_utf8_safe, * isLOWER_LC_utf8_safe, isPRINT_LC_utf8_safe, isPSXSPC_LC_utf8_safe, * isPUNCT_LC_utf8_safe, isSPACE_LC_utf8_safe, isUPPER_LC_utf8_safe, * isWORDCHAR_LC_utf8_safe, isWORDCHAR_LC_utf8_safe, isXDIGIT_LC_utf8_safe, * isALPHANUMERIC_uvchr, isALPHA_uvchr, isASCII_uvchr, isBLANK_uvchr, * isCNTRL_uvchr, isDIGIT_uvchr, isGRAPH_uvchr, isIDCONT_uvchr, * isIDFIRST_uvchr, isLOWER_uvchr, isPRINT_uvchr, isPSXSPC_uvchr, * isPUNCT_uvchr, isSPACE_uvchr, isUPPER_uvchr, isWORDCHAR_uvchr, * isWORDCHAR_uvchr, isXDIGIT_uvchr * * The UTF-8 handling is buggy in early Perls, and this can give inaccurate * results for code points above 0xFF, until the implementation started * settling down in 5.12 and 5.14 */ #endif #define D_PPP_TOO_SHORT_MSG "Malformed UTF-8 character starting with:" \ " \\x%02x (too short; %d bytes available, need" \ " %d)\n" /* Perls starting here had a new API which handled multi-character results */ #if (PERL_BCDVERSION >= 0x5007003) #ifndef toLOWER_uvchr # define toLOWER_uvchr(c, s, l) UNI_TO_NATIVE(to_uni_lower(NATIVE_TO_UNI(c), s, l)) #endif #ifndef toUPPER_uvchr # define toUPPER_uvchr(c, s, l) UNI_TO_NATIVE(to_uni_upper(NATIVE_TO_UNI(c), s, l)) #endif #ifndef toTITLE_uvchr # define toTITLE_uvchr(c, s, l) UNI_TO_NATIVE(to_uni_title(NATIVE_TO_UNI(c), s, l)) #endif #ifndef toFOLD_uvchr # define toFOLD_uvchr(c, s, l) UNI_TO_NATIVE(to_uni_fold( NATIVE_TO_UNI(c), s, l)) #endif # if (PERL_BCDVERSION != 0x5015006) /* Just this version is broken */ /* Prefer the macro to the function */ # if defined toLOWER_utf8 # define D_PPP_TO_LOWER_CALLEE(s,r,l) toLOWER_utf8(s,r,l) # else # define D_PPP_TO_LOWER_CALLEE(s,r,l) to_utf8_lower(s,r,l) # endif # if defined toTITLE_utf8 # define D_PPP_TO_TITLE_CALLEE(s,r,l) toTITLE_utf8(s,r,l) # else # define D_PPP_TO_TITLE_CALLEE(s,r,l) to_utf8_title(s,r,l) # endif # if defined toUPPER_utf8 # define D_PPP_TO_UPPER_CALLEE(s,r,l) toUPPER_utf8(s,r,l) # else # define D_PPP_TO_UPPER_CALLEE(s,r,l) to_utf8_upper(s,r,l) # endif # if defined toFOLD_utf8 # define D_PPP_TO_FOLD_CALLEE(s,r,l) toFOLD_utf8(s,r,l) # else # define D_PPP_TO_FOLD_CALLEE(s,r,l) to_utf8_fold(s,r,l) # endif # else /* Below is 5.15.6, which failed to make the macros available # outside of core, so we have to use the 'Perl_' form. khw # decided it was easier to just handle this case than have to # document the exception, and make an exception in the tests below # */ # define D_PPP_TO_LOWER_CALLEE(s,r,l) \ Perl__to_utf8_lower_flags(aTHX_ s, r, l, 0, NULL) # define D_PPP_TO_TITLE_CALLEE(s,r,l) \ Perl__to_utf8_title_flags(aTHX_ s, r, l, 0, NULL) # define D_PPP_TO_UPPER_CALLEE(s,r,l) \ Perl__to_utf8_upper_flags(aTHX_ s, r, l, 0, NULL) # define D_PPP_TO_FOLD_CALLEE(s,r,l) \ Perl__to_utf8_fold_flags(aTHX_ s, r, l, FOLD_FLAGS_FULL, NULL) # endif /* The actual implementation of the backported macros. If too short, croak, * otherwise call the original that doesn't have an upper limit parameter */ # define D_PPP_GENERIC_MULTI_ARG_TO(name, s, e,r,l) \ (((((e) - (s)) <= 0) \ /* We could just do nothing, but modern perls croak */ \ ? (croak("Attempting case change on zero length string"), \ 0) /* So looks like it returns something, and will compile */ \ : ((e) - (s)) < UTF8SKIP(s)) \ ? (croak(D_PPP_TOO_SHORT_MSG, \ s[0], (int) ((e) - (s)), (int) UTF8SKIP(s)), \ 0) \ : D_PPP_TO_ ## name ## _CALLEE(s,r,l)) #ifndef toUPPER_utf8_safe # define toUPPER_utf8_safe(s,e,r,l) \ D_PPP_GENERIC_MULTI_ARG_TO(UPPER,s,e,r,l) #endif #ifndef toLOWER_utf8_safe # define toLOWER_utf8_safe(s,e,r,l) \ D_PPP_GENERIC_MULTI_ARG_TO(LOWER,s,e,r,l) #endif #ifndef toTITLE_utf8_safe # define toTITLE_utf8_safe(s,e,r,l) \ D_PPP_GENERIC_MULTI_ARG_TO(TITLE,s,e,r,l) #endif #ifndef toFOLD_utf8_safe # define toFOLD_utf8_safe(s,e,r,l) \ D_PPP_GENERIC_MULTI_ARG_TO(FOLD,s,e,r,l) #endif #elif (PERL_BCDVERSION >= 0x5006000) /* Here we have UTF-8 support, but using the original API where the case * changing functions merely returned the changed code point; hence they * couldn't handle multi-character results. */ # ifdef uvchr_to_utf8 # define D_PPP_UV_TO_UTF8 uvchr_to_utf8 # else # define D_PPP_UV_TO_UTF8 uv_to_utf8 # endif /* Get the utf8 of the case changed value, and store its length; then have * to re-calculate the changed case value in order to return it */ # define D_PPP_GENERIC_SINGLE_ARG_TO_UVCHR(name, c, s, l) \ (*(l) = (D_PPP_UV_TO_UTF8(s, \ UNI_TO_NATIVE(to_uni_ ## name(NATIVE_TO_UNI(c)))) - (s)), \ UNI_TO_NATIVE(to_uni_ ## name(NATIVE_TO_UNI(c)))) #ifndef toLOWER_uvchr # define toLOWER_uvchr(c, s, l) \ D_PPP_GENERIC_SINGLE_ARG_TO_UVCHR(lower, c, s, l) #endif #ifndef toUPPER_uvchr # define toUPPER_uvchr(c, s, l) \ D_PPP_GENERIC_SINGLE_ARG_TO_UVCHR(upper, c, s, l) #endif #ifndef toTITLE_uvchr # define toTITLE_uvchr(c, s, l) \ D_PPP_GENERIC_SINGLE_ARG_TO_UVCHR(title, c, s, l) #endif #ifndef toFOLD_uvchr # define toFOLD_uvchr(c, s, l) toLOWER_uvchr(c, s, l) #endif # define D_PPP_GENERIC_SINGLE_ARG_TO_UTF8(name, s, e, r, l) \ (((((e) - (s)) <= 0) \ ? (croak("Attempting case change on zero length string"), \ 0) /* So looks like it returns something, and will compile */ \ : ((e) - (s)) < UTF8SKIP(s)) \ ? (croak(D_PPP_TOO_SHORT_MSG, \ s[0], (int) ((e) - (s)), (int) UTF8SKIP(s)), \ 0) \ /* Get the changed code point and store its UTF-8 */ \ : D_PPP_UV_TO_UTF8(r, to_utf8_ ## name(s)), \ /* Then store its length, and re-get code point for return */ \ *(l) = UTF8SKIP(r), to_utf8_ ## name(r)) /* Warning: toUPPER_utf8_safe, toLOWER_utf8_safe, toTITLE_utf8_safe, * toUPPER_uvchr, toLOWER_uvchr, toTITLE_uvchr The UTF-8 case changing operations had bugs before around 5.12 or 5.14; this backport does not correct them. In perls before 7.3, multi-character case changing is not implemented; this backport uses the simple case changes available in those perls. */ #ifndef toUPPER_utf8_safe # define toUPPER_utf8_safe(s,e,r,l) \ D_PPP_GENERIC_SINGLE_ARG_TO_UTF8(upper, s, e, r, l) #endif #ifndef toLOWER_utf8_safe # define toLOWER_utf8_safe(s,e,r,l) \ D_PPP_GENERIC_SINGLE_ARG_TO_UTF8(lower, s, e, r, l) #endif #ifndef toTITLE_utf8_safe # define toTITLE_utf8_safe(s,e,r,l) \ D_PPP_GENERIC_SINGLE_ARG_TO_UTF8(title, s, e, r, l) #endif /* Warning: toFOLD_utf8_safe, toFOLD_uvchr The UTF-8 case changing operations had bugs before around 5.12 or 5.14; this backport does not correct them. In perls before 7.3, case folding is not implemented; instead, this backport substitutes simple (not multi-character, which isn't available) lowercasing. This gives the correct result in most, but not all, instances */ #ifndef toFOLD_utf8_safe # define toFOLD_utf8_safe(s,e,r,l) toLOWER_utf8_safe(s,e,r,l) #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 LIKELY # define LIKELY(x) (x) #endif #ifndef UNLIKELY # define UNLIKELY(x) (x) #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 #if (PERL_BCDVERSION >= 0x5004000) && !defined(vnewSVpvf) #if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) # define vnewSVpvf(pat, args) ({ SV *_sv = newSV(0); sv_vsetpvfn(_sv, (pat), strlen((pat)), (args), Null(SV**), 0, Null(bool*)); _sv; }) #else # define vnewSVpvf(pat, args) ((PL_Sv = newSV(0)), sv_vsetpvfn(PL_Sv, (pat), strlen((pat)), (args), Null(SV**), 0, Null(bool*)), PL_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 * const sv, const char * const pat, ...); static #else extern void DPPP_(my_sv_catpvf_mg)(pTHX_ SV * const sv, const char * const pat, ...); #endif #if defined(NEED_sv_catpvf_mg) || defined(NEED_sv_catpvf_mg_GLOBAL) #define Perl_sv_catpvf_mg DPPP_(my_sv_catpvf_mg) void DPPP_(my_sv_catpvf_mg)(pTHX_ SV * const sv, const char * const 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 * const sv, const char * const pat, ...); static #else extern void DPPP_(my_sv_catpvf_mg_nocontext)(SV * const sv, const char * const pat, ...); #endif #if defined(NEED_sv_catpvf_mg_nocontext) || defined(NEED_sv_catpvf_mg_nocontext_GLOBAL) #define sv_catpvf_mg_nocontext DPPP_(my_sv_catpvf_mg_nocontext) #define Perl_sv_catpvf_mg_nocontext DPPP_(my_sv_catpvf_mg_nocontext) void DPPP_(my_sv_catpvf_mg_nocontext)(SV * const sv, const char * const 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 * const sv, const char * const pat, ...); static #else extern void DPPP_(my_sv_setpvf_mg)(pTHX_ SV * const sv, const char * const pat, ...); #endif #if defined(NEED_sv_setpvf_mg) || defined(NEED_sv_setpvf_mg_GLOBAL) #define Perl_sv_setpvf_mg DPPP_(my_sv_setpvf_mg) void DPPP_(my_sv_setpvf_mg)(pTHX_ SV * const sv, const char * const 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 * const sv, const char * const pat, ...); static #else extern void DPPP_(my_sv_setpvf_mg_nocontext)(SV * const sv, const char * const pat, ...); #endif #if defined(NEED_sv_setpvf_mg_nocontext) || defined(NEED_sv_setpvf_mg_nocontext_GLOBAL) #define sv_setpvf_mg_nocontext DPPP_(my_sv_setpvf_mg_nocontext) #define Perl_sv_setpvf_mg_nocontext DPPP_(my_sv_setpvf_mg_nocontext) void DPPP_(my_sv_setpvf_mg_nocontext)(SV * const sv, const char * const 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: 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) #ifndef sv_2pvbyte # define sv_2pvbyte(sv, lp) (sv_utf8_downgrade((sv), 0), SvPV((sv), *(lp))) #endif /* Hint: sv_2pvbyte * Use the SvPVbyte() macro instead of sv_2pvbyte(). */ /* Replace sv_2pvbyte with SvPVbyte */ #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(). */ /* Replace sv_pvn with SvPV */ /* Hint: sv_pvn_force * Always use the SvPV_force() macro instead of sv_pvn_force(). */ /* Replace sv_pvn_force with SvPV_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_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 defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) #ifndef sv_2pv_flags # define sv_2pv_flags(sv, lp, flags) ({ SV *_sv = (sv); const I32 _flags = (flags); STRLEN *_lp = lp; _lp = _lp ? : &PL_na; (!(_flags & SV_GMAGIC) && SvGMAGICAL(_sv)) ? ({ char *_pv; SvGMAGICAL_off(_sv); _pv = sv_2pv(_sv, _lp); SvGMAGICAL_on(_sv); _pv; }) : sv_2pv(_sv, _lp); }) #endif #ifndef sv_pvn_force_flags # define sv_pvn_force_flags(sv, lp, flags) ({ SV *_sv = (sv); const I32 _flags = (flags); STRLEN *_lp = lp; _lp = _lp ? : &PL_na; (!(_flags & SV_GMAGIC) && SvGMAGICAL(_sv)) ? ({ char *_pv; SvGMAGICAL_off(_sv); _pv = sv_pvn_force(_sv, _lp); SvGMAGICAL_on(_sv); _pv; }) : sv_pvn_force(_sv, _lp); }) #endif #else #ifndef sv_2pv_flags # define sv_2pv_flags(sv, lp, flags) ((PL_Sv = (sv)), (!((flags) & SV_GMAGIC) && SvGMAGICAL(PL_Sv)) ? (SvGMAGICAL_off(PL_Sv), (PL_Xpv = (XPV *)sv_2pv(PL_Sv, (lp) ? (lp) : &PL_na)), SvGMAGICAL_on(PL_Sv), (char *)PL_Xpv) : sv_2pv(PL_Sv, (lp) ? (lp) : &PL_na)) #endif #ifndef sv_pvn_force_flags # define sv_pvn_force_flags(sv, lp, flags) ((PL_Sv = (sv)), (!((flags) & SV_GMAGIC) && SvGMAGICAL(PL_Sv)) ? (SvGMAGICAL_off(PL_Sv), (PL_Xpv = (XPV *)sv_pvn_force(PL_Sv, (lp) ? (lp) : &PL_na)), SvGMAGICAL_on(PL_Sv), (char *)PL_Xpv) : sv_pvn_force(PL_Sv, (lp) ? (lp) : &PL_na)) #endif #endif #if (PERL_BCDVERSION < 0x5008008) || ( (PERL_BCDVERSION >= 0x5009000) && (PERL_BCDVERSION < 0x5009003) ) # define D_PPP_SVPV_NOLEN_LP_ARG &PL_na #else # define D_PPP_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, D_PPP_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, D_PPP_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, D_PPP_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, D_PPP_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, D_PPP_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 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 #if defined(NEED_warner) || defined(NEED_warner_GLOBAL) #define Perl_warner DPPP_(my_warner) 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 #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 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 #if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) #ifndef sv_2uv # define sv_2uv(sv) ({ SV *_sv = (sv); (UV) (SvNOK(_sv) ? SvNV(_sv) : sv_2nv(_sv)); }) #endif #else #ifndef sv_2uv # define sv_2uv(sv) ((PL_Sv = (sv)), (UV) (SvNOK(PL_Sv) ? SvNV(PL_Sv) : sv_2nv(PL_Sv))) #endif #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 #if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) #ifndef SvUVx # define SvUVx(sv) ({ SV *_sv = (sv)); SvUV(_sv); }) #endif #else #ifndef SvUVx # define SvUVx(sv) ((PL_Sv = (sv)), SvUV(PL_Sv)) #endif #endif /* Hint: sv_uv * Always use the SvUVx() macro instead of sv_uv(). */ /* Replace sv_uv with SvUVx */ #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 #if !defined(my_strnlen) #if defined(NEED_my_strnlen) static Size_t DPPP_(my_my_strnlen)(const char * str, Size_t maxlen); static #else extern Size_t DPPP_(my_my_strnlen)(const char * str, Size_t maxlen); #endif #if defined(NEED_my_strnlen) || defined(NEED_my_strnlen_GLOBAL) #define my_strnlen DPPP_(my_my_strnlen) #define Perl_my_strnlen DPPP_(my_my_strnlen) Size_t DPPP_(my_my_strnlen)(const char *str, Size_t maxlen) { const char *p = str; while(maxlen-- && *p) p++; return p - str; } #endif #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 memCHRs # define memCHRs(s, c) ((const char *) memchr("" s "" , c, sizeof(s)-1)) #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 #ifdef NEED_mess_sv #define NEED_mess #endif #ifdef NEED_mess #define NEED_mess_nocontext #define NEED_vmess #endif #ifndef croak_sv #if (PERL_BCDVERSION >= 0x5007003) || ( (PERL_BCDVERSION >= 0x5006001) && (PERL_BCDVERSION < 0x5007000) ) # if ( (PERL_BCDVERSION >= 0x5008000) && (PERL_BCDVERSION < 0x5008009) ) || ( (PERL_BCDVERSION >= 0x5009000) && (PERL_BCDVERSION < 0x5010001) ) # define D_PPP_FIX_UTF8_ERRSV_FOR_SV(sv) \ STMT_START { \ SV *_errsv = ERRSV; \ SvFLAGS(_errsv) = (SvFLAGS(_errsv) & ~SVf_UTF8) | \ (SvFLAGS(sv) & SVf_UTF8); \ } STMT_END # else # define D_PPP_FIX_UTF8_ERRSV_FOR_SV(sv) STMT_START {} STMT_END # endif # define croak_sv(sv) \ STMT_START { \ SV *_sv = (sv); \ if (SvROK(_sv)) { \ sv_setsv(ERRSV, _sv); \ croak(NULL); \ } else { \ D_PPP_FIX_UTF8_ERRSV_FOR_SV(_sv); \ croak("%" SVf, SVfARG(_sv)); \ } \ } STMT_END #elif (PERL_BCDVERSION >= 0x5004000) # define croak_sv(sv) croak("%" SVf, SVfARG(sv)) #else # define croak_sv(sv) croak("%s", SvPV_nolen(sv)) #endif #endif #ifndef die_sv #if defined(NEED_die_sv) static OP * DPPP_(my_die_sv)(pTHX_ SV * baseex); static #else extern OP * DPPP_(my_die_sv)(pTHX_ SV * baseex); #endif #if defined(NEED_die_sv) || defined(NEED_die_sv_GLOBAL) #ifdef die_sv # undef die_sv #endif #define die_sv(a) DPPP_(my_die_sv)(aTHX_ a) #define Perl_die_sv DPPP_(my_die_sv) OP * DPPP_(my_die_sv)(pTHX_ SV *baseex) { croak_sv(baseex); return (OP *)NULL; } #endif #endif #ifndef warn_sv #if (PERL_BCDVERSION >= 0x5004000) # define warn_sv(sv) warn("%" SVf, SVfARG(sv)) #else # define warn_sv(sv) warn("%s", SvPV_nolen(sv)) #endif #endif #if ! defined vmess && (PERL_BCDVERSION >= 0x5004000) # if defined(NEED_vmess) static SV * DPPP_(my_vmess)(pTHX_ const char * pat, va_list * args); static #else extern SV * DPPP_(my_vmess)(pTHX_ const char * pat, va_list * args); #endif #if defined(NEED_vmess) || defined(NEED_vmess_GLOBAL) #ifdef vmess # undef vmess #endif #define vmess(a,b) DPPP_(my_vmess)(aTHX_ a,b) #define Perl_vmess DPPP_(my_vmess) SV* DPPP_(my_vmess)(pTHX_ const char* pat, va_list* args) { mess(pat, args); return PL_mess_sv; } # endif #endif #if (PERL_BCDVERSION < 0x5006000) && (PERL_BCDVERSION >= 0x5004000) #undef mess #endif #if !defined(mess_nocontext) && !defined(Perl_mess_nocontext) && (PERL_BCDVERSION >= 0x5004000) #if defined(NEED_mess_nocontext) static SV * DPPP_(my_mess_nocontext)(const char * pat, ...); static #else extern SV * DPPP_(my_mess_nocontext)(const char * pat, ...); #endif #if defined(NEED_mess_nocontext) || defined(NEED_mess_nocontext_GLOBAL) #define mess_nocontext DPPP_(my_mess_nocontext) #define Perl_mess_nocontext DPPP_(my_mess_nocontext) SV* DPPP_(my_mess_nocontext)(const char* pat, ...) { dTHX; SV *sv; va_list args; va_start(args, pat); sv = vmess(pat, &args); va_end(args); return sv; } #endif #endif #ifndef mess #if defined(NEED_mess) static SV * DPPP_(my_mess)(pTHX_ const char * pat, ...); static #else extern SV * DPPP_(my_mess)(pTHX_ const char * pat, ...); #endif #if defined(NEED_mess) || defined(NEED_mess_GLOBAL) #define Perl_mess DPPP_(my_mess) SV* DPPP_(my_mess)(pTHX_ const char* pat, ...) { SV *sv; va_list args; va_start(args, pat); sv = vmess(pat, &args); va_end(args); return sv; } #ifdef mess_nocontext #define mess mess_nocontext #else #define mess Perl_mess_nocontext #endif #endif #endif #if ! defined mess_sv && (PERL_BCDVERSION >= 0x5004000) #if defined(NEED_mess_sv) static SV * DPPP_(my_mess_sv)(pTHX_ SV * basemsg, bool consume); static #else extern SV * DPPP_(my_mess_sv)(pTHX_ SV * basemsg, bool consume); #endif #if defined(NEED_mess_sv) || defined(NEED_mess_sv_GLOBAL) #ifdef mess_sv # undef mess_sv #endif #define mess_sv(a,b) DPPP_(my_mess_sv)(aTHX_ a,b) #define Perl_mess_sv DPPP_(my_mess_sv) SV * DPPP_(my_mess_sv)(pTHX_ SV *basemsg, bool consume) { SV *tmp; SV *ret; if (SvPOK(basemsg) && SvCUR(basemsg) && *(SvEND(basemsg)-1) == '\n') { if (consume) return basemsg; ret = mess(""); SvSetSV_nosteal(ret, basemsg); return ret; } if (consume) { sv_catsv(basemsg, mess("")); return basemsg; } ret = mess(""); tmp = newSVsv(ret); SvSetSV_nosteal(ret, basemsg); sv_catsv(ret, tmp); sv_dec(tmp); return ret; } #endif #endif #ifndef warn_nocontext #define warn_nocontext warn #endif #ifndef croak_nocontext #define croak_nocontext croak #endif #ifndef croak_no_modify #define croak_no_modify() croak_nocontext("%s", PL_no_modify) #define Perl_croak_no_modify() croak_no_modify() #endif #ifndef croak_memory_wrap #if (PERL_BCDVERSION >= 0x5009002) || ( (PERL_BCDVERSION >= 0x5008006) && (PERL_BCDVERSION < 0x5009000) ) # define croak_memory_wrap() croak_nocontext("%s", PL_memory_wrap) #else # define croak_memory_wrap() croak_nocontext("panic: memory wrap") #endif #endif #ifndef croak_xs_usage #if defined(NEED_croak_xs_usage) static void DPPP_(my_croak_xs_usage)(const CV * const cv, const char * const params); static #else extern void DPPP_(my_croak_xs_usage)(const CV * const cv, const char * const params); #endif #if defined(NEED_croak_xs_usage) || defined(NEED_croak_xs_usage_GLOBAL) #define croak_xs_usage DPPP_(my_croak_xs_usage) #define Perl_croak_xs_usage DPPP_(my_croak_xs_usage) void DPPP_(my_croak_xs_usage)(const CV *const cv, const char *const params) { dTHX; const GV *const gv = CvGV(cv); #ifdef PERL_ARGS_ASSERT_CROAK_XS_USAGE PERL_ARGS_ASSERT_CROAK_XS_USAGE; #else assert(cv); assert(params); #endif if (gv) { const char *const gvname = GvNAME(gv); const HV *const stash = GvSTASH(gv); const char *const hvname = stash ? HvNAME(stash) : NULL; if (hvname) croak("Usage: %s::%s(%s)", hvname, gvname, params); else croak("Usage: %s(%s)", gvname, params); } else { /* Pants. I don't think that it should be possible to get here. */ croak("Usage: CODE(0x%" UVxf ")(%s)", PTR2UV(cv), params); } } #endif #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 #if (PERL_BCDVERSION >= 0x5003098) && (PERL_BCDVERSION < 0x5006000) #ifndef eval_pv # define eval_pv perl_eval_pv #endif #endif /* Replace: 0 */ #if (PERL_BCDVERSION < 0x5006000) #ifndef Perl_eval_sv # define Perl_eval_sv perl_eval_sv #endif #if (PERL_BCDVERSION >= 0x5003098) #ifndef Perl_eval_pv # define Perl_eval_pv perl_eval_pv #endif #endif #endif #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 #if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) # define D_PPP_CROAK_IF_ERROR(cond) ({ SV *_errsv; ((cond) && (_errsv = ERRSV) && (SvROK(_errsv) || SvTRUE(_errsv)) && (croak_sv(_errsv), 1)); }) #else # define D_PPP_CROAK_IF_ERROR(cond) ((cond) && (SvROK(ERRSV) || SvTRUE(ERRSV)) && (croak_sv(ERRSV), 1)) #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 #ifndef G_RETHROW # define G_RETHROW 8192 # ifdef eval_sv # undef eval_sv # endif # if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) # define eval_sv(sv, flags) ({ I32 _flags = (flags); I32 _ret = Perl_eval_sv(aTHX_ sv, (_flags & ~G_RETHROW)); D_PPP_CROAK_IF_ERROR(_flags & G_RETHROW); _ret; }) # else # define eval_sv(sv, flags) ((PL_na = Perl_eval_sv(aTHX_ sv, ((flags) & ~G_RETHROW))), D_PPP_CROAK_IF_ERROR((flags) & G_RETHROW), (I32)PL_na) # endif #endif /* Older Perl versions have broken croak_on_error=1 */ #if (PERL_BCDVERSION < 0x5031002) # ifdef eval_pv # undef eval_pv # if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) # define eval_pv(p, croak_on_error) ({ SV *_sv = Perl_eval_pv(aTHX_ p, 0); D_PPP_CROAK_IF_ERROR(croak_on_error); _sv; }) # else # define eval_pv(p, croak_on_error) ((PL_Sv = Perl_eval_pv(aTHX_ p, 0)), D_PPP_CROAK_IF_ERROR(croak_on_error), PL_Sv) # endif # endif #endif /* This is backport for Perl 5.3.97d and older which do not provide perl_eval_pv */ #ifndef eval_pv #if defined(NEED_eval_pv) static SV * DPPP_(my_eval_pv)(const char * p, I32 croak_on_error); static #else extern SV * DPPP_(my_eval_pv)(const char * p, I32 croak_on_error); #endif #if defined(NEED_eval_pv) || defined(NEED_eval_pv_GLOBAL) #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) SV* DPPP_(my_eval_pv)(const 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; D_PPP_CROAK_IF_ERROR(croak_on_error); return sv; } #endif #endif #if ! defined(vload_module) && defined(start_subparse) #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 #if defined(NEED_vload_module) || defined(NEED_vload_module_GLOBAL) #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) 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; utilize(!(flags & PERL_LOADMOD_DENY), start_subparse(FALSE, 0), #if (PERL_BCDVERSION > 0x5003000) veop, #endif modname, imop); 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 #if defined(NEED_load_module) || defined(NEED_load_module_GLOBAL) #ifdef load_module # undef load_module #endif #define load_module DPPP_(my_load_module) #define Perl_load_module DPPP_(my_load_module) 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(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) # define newRV_noinc(sv) ({ SV *_sv = (SV *)newRV((sv)); SvREFCNT_dec((sv)); _sv; }) #else # define newRV_noinc(sv) ((PL_Sv = (SV *)newRV((sv))), SvREFCNT_dec((sv)), PL_Sv) #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 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(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) # define newSV_type(t) ({ SV *_sv = newSV(0); sv_upgrade(_sv, (t)); _sv; }) #else # define newSV_type(t) ((PL_Sv = newSV(0)), sv_upgrade(PL_Sv, (t)), PL_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(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) # define newSVpvn_flags(s, len, flags) ({ SV *_sv = newSVpvn(D_PPP_CONSTPV_ARG((s)), (len)); SvFLAGS(_sv) |= ((flags) & SVf_UTF8); ((flags) & SVs_TEMP) ? sv_2mortal(_sv) : _sv; }) #else # define newSVpvn_flags(s, len, flags) ((PL_Sv = newSVpvn(D_PPP_CONSTPV_ARG((s)), (len))), SvFLAGS(PL_Sv) |= ((flags) & SVf_UTF8), (((flags) & SVs_TEMP) ? sv_2mortal(PL_Sv) : PL_Sv)) #endif #endif #ifndef SV_NOSTEAL # define SV_NOSTEAL 16 #endif #if ( (PERL_BCDVERSION >= 0x5007003) && (PERL_BCDVERSION < 0x5008007) ) || ( (PERL_BCDVERSION >= 0x5009000) && (PERL_BCDVERSION < 0x5009002) ) #undef sv_setsv_flags #if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) #define sv_setsv_flags(dstr, sstr, flags) \ STMT_START { \ if (((flags) & SV_NOSTEAL) && (sstr) && (SvFLAGS((SV *)(sstr)) & SVs_TEMP)) { \ SvTEMP_off((SV *)(sstr)); \ Perl_sv_setsv_flags(aTHX_ (dstr), (sstr), (flags) & ~SV_NOSTEAL); \ SvTEMP_on((SV *)(sstr)); \ } else { \ Perl_sv_setsv_flags(aTHX_ (dstr), (sstr), (flags) & ~SV_NOSTEAL); \ } \ } STMT_END #else ( \ (((flags) & SV_NOSTEAL) && (sstr) && (SvFLAGS((SV *)(sstr)) & SVs_TEMP)) ? ( \ SvTEMP_off((SV *)(sstr)), \ Perl_sv_setsv_flags(aTHX_ (dstr), (sstr), (flags) & ~SV_NOSTEAL), \ SvTEMP_on((SV *)(sstr)), \ 1 \ ) : ( \ Perl_sv_setsv_flags(aTHX_ (dstr), (sstr), (flags) & ~SV_NOSTEAL), \ 1 \ ) \ ) #endif #endif #if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) #ifndef sv_setsv_flags # define sv_setsv_flags(dstr, sstr, flags) \ STMT_START { \ if (((flags) & SV_NOSTEAL) && (sstr) && (SvFLAGS((SV *)(sstr)) & SVs_TEMP)) { \ SvTEMP_off((SV *)(sstr)); \ if (!((flags) & SV_GMAGIC) && (sstr) && SvGMAGICAL((SV *)(sstr))) { \ SvGMAGICAL_off((SV *)(sstr)); \ sv_setsv((dstr), (sstr)); \ SvGMAGICAL_on((SV *)(sstr)); \ } else { \ sv_setsv((dstr), (sstr)); \ } \ SvTEMP_on((SV *)(sstr)); \ } else { \ if (!((flags) & SV_GMAGIC) && (sstr) && SvGMAGICAL((SV *)(sstr))) { \ SvGMAGICAL_off((SV *)(sstr)); \ sv_setsv((dstr), (sstr)); \ SvGMAGICAL_on((SV *)(sstr)); \ } else { \ sv_setsv((dstr), (sstr)); \ } \ } \ } STMT_END #endif #else #ifndef sv_setsv_flags # define sv_setsv_flags(dstr, sstr, flags) \ ( \ (((flags) & SV_NOSTEAL) && (sstr) && (SvFLAGS((SV *)(sstr)) & SVs_TEMP)) ? ( \ SvTEMP_off((SV *)(sstr)), \ (!((flags) & SV_GMAGIC) && (sstr) && SvGMAGICAL((SV *)(sstr))) ? ( \ SvGMAGICAL_off((SV *)(sstr)), \ sv_setsv((dstr), (sstr)), \ SvGMAGICAL_on((SV *)(sstr)), \ 1 \ ) : ( \ sv_setsv((dstr), (sstr)), \ 1 \ ), \ SvTEMP_on((SV *)(sstr)), \ 1 \ ) : ( \ (!((flags) & SV_GMAGIC) && (sstr) && SvGMAGICAL((SV *)(sstr))) ? ( \ SvGMAGICAL_off((SV *)(sstr)), \ sv_setsv((dstr), (sstr)), \ SvGMAGICAL_on((SV *)(sstr)), \ 1 \ ) : ( \ sv_setsv((dstr), (sstr)), \ 1 \ ) \ ) \ ) #endif #endif #if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) #ifndef newSVsv_flags # define newSVsv_flags(sv, flags) ({ SV *_sv = newSV(0); sv_setsv_flags(_sv, (sv), (flags)); _sv; }) #endif #else #ifndef newSVsv_flags # define newSVsv_flags(sv, flags) ((PL_Sv = newSV(0)), sv_setsv_flags(PL_Sv, (sv), (flags)), PL_Sv) #endif #endif #ifndef newSVsv_nomg # define newSVsv_nomg(sv) newSVsv_flags((sv), SV_NOSTEAL) #endif #if (PERL_BCDVERSION >= 0x5017005) #ifndef sv_mortalcopy_flags # define sv_mortalcopy_flags(sv, flags) Perl_sv_mortalcopy_flags(aTHX_ (sv), (flags)) #endif #else #ifndef sv_mortalcopy_flags # define sv_mortalcopy_flags(sv, flags) sv_2mortal(newSVsv_flags((sv), (flags))) #endif #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 /* 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 * s, I32 len, U32 hash); static #else extern SV * DPPP_(my_newSVpvn_share)(pTHX_ const char * s, I32 len, U32 hash); #endif #if defined(NEED_newSVpvn_share) || defined(NEED_newSVpvn_share_GLOBAL) #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) SV * DPPP_(my_newSVpvn_share)(pTHX_ const char *s, I32 len, U32 hash) { SV *sv; if (len < 0) len = -len; if (!hash) PERL_HASH(hash, (char*) s, len); sv = newSVpvn((char *) s, 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 #if (PERL_BCDVERSION >= 0x5009002) && (PERL_BCDVERSION <= 0x5009003) /* 5.9.2 and 5.9.3 ignore the length param */ #undef gv_fetchpvn_flags #endif #ifndef GV_NOADD_MASK # define GV_NOADD_MASK 0xE0 #endif #ifndef gv_fetchpvn_flags # define gv_fetchpvn_flags(name, len, flags, sv_type) gv_fetchpv(SvPVX(sv_2mortal(newSVpvn((name), (len)))), ((flags) & GV_NOADD_MASK) ? FALSE : TRUE, (I32)(sv_type)) #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 /* 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 /* 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 #ifdef SVf_IVisUV #if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) #ifndef SvIV_nomg # define SvIV_nomg(sv) (!SvGMAGICAL((sv)) ? SvIV((sv)) : ({ SV *_sviv = sv_mortalcopy_flags((sv), SV_NOSTEAL); IV _iv = SvIV(_sviv); SvFLAGS((sv)) = (SvFLAGS((sv)) & ~SVf_IVisUV) | (SvFLAGS(_sviv) & SVf_IVisUV); _iv; })) #endif #ifndef SvUV_nomg # define SvUV_nomg(sv) (!SvGMAGICAL((sv)) ? SvUV((sv)) : ({ SV *_svuv = sv_mortalcopy_flags((sv), SV_NOSTEAL); UV _uv = SvUV(_svuv); SvFLAGS((sv)) = (SvFLAGS((sv)) & ~SVf_IVisUV) | (SvFLAGS(_svuv) & SVf_IVisUV); _uv; })) #endif #else #ifndef SvIV_nomg # define SvIV_nomg(sv) (!SvGMAGICAL((sv)) ? SvIV((sv)) : ((PL_Sv = sv_mortalcopy_flags((sv), SV_NOSTEAL)), sv_upgrade(PL_Sv, SVt_PVIV), (SvIVX(PL_Sv) = SvIV(PL_Sv)), (SvFLAGS((sv)) = (SvFLAGS((sv)) & ~SVf_IVisUV) | (SvFLAGS(PL_Sv) & SVf_IVisUV)), SvIVX(PL_Sv))) #endif #ifndef SvUV_nomg # define SvUV_nomg(sv) (!SvGMAGICAL((sv)) ? SvIV((sv)) : ((PL_Sv = sv_mortalcopy_flags((sv), SV_NOSTEAL)), sv_upgrade(PL_Sv, SVt_PVIV), (SvUVX(PL_Sv) = SvUV(PL_Sv)), (SvFLAGS((sv)) = (SvFLAGS((sv)) & ~SVf_IVisUV) | (SvFLAGS(PL_Sv) & SVf_IVisUV)), SvUVX(PL_Sv))) #endif #endif #else #ifndef SvIV_nomg # define SvIV_nomg(sv) (!SvGMAGICAL((sv)) ? SvIV((sv)) : SvIVx(sv_mortalcopy_flags((sv), SV_NOSTEAL))) #endif #ifndef SvUV_nomg # define SvUV_nomg(sv) (!SvGMAGICAL((sv)) ? SvUV((sv)) : SvUVx(sv_mortalcopy_flags((sv), SV_NOSTEAL))) #endif #endif #ifndef SvNV_nomg # define SvNV_nomg(sv) (!SvGMAGICAL((sv)) ? SvNV((sv)) : SvNVx(sv_mortalcopy_flags((sv), SV_NOSTEAL))) #endif #ifndef SvTRUE_nomg # define SvTRUE_nomg(sv) (!SvGMAGICAL((sv)) ? SvTRUE((sv)) : SvTRUEx(sv_mortalcopy_flags((sv), SV_NOSTEAL))) #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)(const SV * sv, int type, const MGVTBL * vtbl); static #else extern MAGIC * DPPP_(my_mg_findext)(const SV * sv, int type, const MGVTBL * vtbl); #endif #if defined(NEED_mg_findext) || defined(NEED_mg_findext_GLOBAL) #define mg_findext DPPP_(my_mg_findext) #define Perl_mg_findext DPPP_(my_mg_findext) MAGIC * DPPP_(my_mg_findext)(const 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 #if defined(NEED_sv_unmagicext) || defined(NEED_sv_unmagicext_GLOBAL) #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) 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 level, const PERL_CONTEXT * * dbcxp); static #else extern const PERL_CONTEXT * DPPP_(my_caller_cx)(pTHX_ I32 level, const PERL_CONTEXT * * dbcxp); #endif #if defined(NEED_caller_cx) || defined(NEED_caller_cx_GLOBAL) #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) const PERL_CONTEXT * DPPP_(my_caller_cx)(pTHX_ I32 level, 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)) level++; if (!level--) 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 #if defined(NEED_grok_numeric_radix) || defined(NEED_grok_numeric_radix_GLOBAL) #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) 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 #if defined(NEED_grok_number) || defined(NEED_grok_number_GLOBAL) #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) 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 #if defined(NEED_grok_bin) || defined(NEED_grok_bin_GLOBAL) #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) 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 #if defined(NEED_grok_hex) || defined(NEED_grok_hex_GLOBAL) #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) 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 #if defined(NEED_grok_oct) || defined(NEED_grok_oct_GLOBAL) #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) 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 #if defined(NEED_my_snprintf) || defined(NEED_my_snprintf_GLOBAL) #define my_snprintf DPPP_(my_my_snprintf) #define Perl_my_snprintf DPPP_(my_my_snprintf) 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 #if defined(NEED_my_sprintf) || defined(NEED_my_sprintf_GLOBAL) #define my_sprintf DPPP_(my_my_sprintf) /* Warning: my_sprintf It's safer to use my_snprintf instead */ /* Replace my_sprintf with my_snprintf */ 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 #if defined(NEED_my_strlcat) || defined(NEED_my_strlcat_GLOBAL) #define my_strlcat DPPP_(my_my_strlcat) #define Perl_my_strlcat DPPP_(my_my_strlcat) 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 #if defined(NEED_my_strlcpy) || defined(NEED_my_strlcpy_GLOBAL) #define my_strlcpy DPPP_(my_my_strlcpy) #define Perl_my_strlcpy DPPP_(my_my_strlcpy) 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 #ifdef SVf_UTF8 #ifndef SvUTF8 # define SvUTF8(sv) (SvFLAGS(sv) & SVf_UTF8) #endif #endif #if (PERL_BCDVERSION == 0x5019001) /* 5.19.1 does not have UTF8fARG, only broken UTF8f */ #undef UTF8f #endif #ifdef SVf_UTF8 #ifndef UTF8f # define UTF8f SVf #endif #ifndef UTF8fARG # define UTF8fARG(u,l,p) newSVpvn_flags((p), (l), ((u) ? SVf_UTF8 : 0) | SVs_TEMP) #endif #endif #define D_PPP_MIN(a,b) (((a) <= (b)) ? (a) : (b)) #ifndef UNICODE_REPLACEMENT # define UNICODE_REPLACEMENT 0xFFFD #endif #ifdef UTF8_MAXLEN #ifndef UTF8_MAXBYTES # define UTF8_MAXBYTES UTF8_MAXLEN #endif #endif #ifndef UTF_START_MARK # define UTF_START_MARK(len) \ (((len) > 7) ? 0xFF : (0xFF & (0xFE << (7-(len))))) #endif #if (PERL_BCDVERSION < 0x5018000) /* On non-EBCDIC was valid before this, */ /* but easier to just do one check */ # undef UTF8_MAXBYTES_CASE #endif #if 'A' == 65 # define D_PPP_BYTE_INFO_BITS 6 /* 6 bits meaningful in continuation bytes */ #ifndef UTF8_MAXBYTES_CASE # define UTF8_MAXBYTES_CASE 13 #endif #else # define D_PPP_BYTE_INFO_BITS 5 /* 5 bits meaningful in continuation bytes */ #ifndef UTF8_MAXBYTES_CASE # define UTF8_MAXBYTES_CASE 15 #endif #endif #ifndef UTF_ACCUMULATION_SHIFT # define UTF_ACCUMULATION_SHIFT D_PPP_BYTE_INFO_BITS #endif #ifdef NATIVE_TO_UTF #ifndef NATIVE_UTF8_TO_I8 # define NATIVE_UTF8_TO_I8(c) NATIVE_TO_UTF(c) #endif #else /* System doesn't support EBCDIC */ #ifndef NATIVE_UTF8_TO_I8 # define NATIVE_UTF8_TO_I8(c) (c) #endif #endif #ifdef UTF_TO_NATIVE #ifndef I8_TO_NATIVE_UTF8 # define I8_TO_NATIVE_UTF8(c) UTF_TO_NATIVE(c) #endif #else /* System doesn't support EBCDIC */ #ifndef I8_TO_NATIVE_UTF8 # define I8_TO_NATIVE_UTF8(c) (c) #endif #endif #ifndef UTF_START_MASK # define UTF_START_MASK(len) \ (((len) >= 7) ? 0x00 : (0x1F >> ((len)-2))) #endif #ifndef UTF_IS_CONTINUATION_MASK # define UTF_IS_CONTINUATION_MASK \ ((U8) (0xFF << UTF_ACCUMULATION_SHIFT)) #endif #ifndef UTF_CONTINUATION_MARK # define UTF_CONTINUATION_MARK \ (UTF_IS_CONTINUATION_MASK & 0xB0) #endif #ifndef UTF_MIN_START_BYTE # define UTF_MIN_START_BYTE \ ((UTF_CONTINUATION_MARK >> UTF_ACCUMULATION_SHIFT) | UTF_START_MARK(2)) #endif #ifndef UTF_MIN_ABOVE_LATIN1_BYTE # define UTF_MIN_ABOVE_LATIN1_BYTE \ ((0x100 >> UTF_ACCUMULATION_SHIFT) | UTF_START_MARK(2)) #endif #if (PERL_BCDVERSION < 0x5007000) /* Was the complement of what should have been */ # undef UTF8_IS_DOWNGRADEABLE_START #endif #ifndef UTF8_IS_DOWNGRADEABLE_START # define UTF8_IS_DOWNGRADEABLE_START(c) \ inRANGE(NATIVE_UTF8_TO_I8(c), \ UTF_MIN_START_BYTE, UTF_MIN_ABOVE_LATIN1_BYTE - 1) #endif #ifndef UTF_CONTINUATION_MASK # define UTF_CONTINUATION_MASK \ ((U8) ((1U << UTF_ACCUMULATION_SHIFT) - 1)) #endif #ifndef UTF8_ACCUMULATE # define UTF8_ACCUMULATE(base, added) \ (((base) << UTF_ACCUMULATION_SHIFT) \ | ((NATIVE_UTF8_TO_I8(added)) \ & UTF_CONTINUATION_MASK)) #endif #ifndef UTF8_ALLOW_ANYUV # define UTF8_ALLOW_ANYUV 0 #endif #ifndef UTF8_ALLOW_EMPTY # define UTF8_ALLOW_EMPTY 0x0001 #endif #ifndef UTF8_ALLOW_CONTINUATION # define UTF8_ALLOW_CONTINUATION 0x0002 #endif #ifndef UTF8_ALLOW_NON_CONTINUATION # define UTF8_ALLOW_NON_CONTINUATION 0x0004 #endif #ifndef UTF8_ALLOW_SHORT # define UTF8_ALLOW_SHORT 0x0008 #endif #ifndef UTF8_ALLOW_LONG # define UTF8_ALLOW_LONG 0x0010 #endif #ifndef UTF8_ALLOW_OVERFLOW # define UTF8_ALLOW_OVERFLOW 0x0080 #endif #ifndef UTF8_ALLOW_ANY # define UTF8_ALLOW_ANY ( UTF8_ALLOW_CONTINUATION \ |UTF8_ALLOW_NON_CONTINUATION \ |UTF8_ALLOW_SHORT \ |UTF8_ALLOW_LONG \ |UTF8_ALLOW_OVERFLOW) #endif #if defined UTF8SKIP /* Don't use official versions because they use MIN, which may not be available */ #undef UTF8_SAFE_SKIP #undef UTF8_CHK_SKIP #ifndef UTF8_SAFE_SKIP # define UTF8_SAFE_SKIP(s, e) ( \ ((((e) - (s)) <= 0) \ ? 0 \ : D_PPP_MIN(((e) - (s)), UTF8SKIP(s)))) #endif #ifndef UTF8_CHK_SKIP # define UTF8_CHK_SKIP(s) \ (s[0] == '\0' ? 1 : ((U8) D_PPP_MIN(my_strnlen((char *) (s), UTF8SKIP(s)), \ UTF8SKIP(s)))) #endif /* UTF8_CHK_SKIP depends on my_strnlen */ #ifndef UTF8_SKIP # define UTF8_SKIP(s) UTF8SKIP(s) #endif #endif #if 'A' == 65 #ifndef UTF8_IS_INVARIANT # define UTF8_IS_INVARIANT(c) isASCII(c) #endif #else #ifndef UTF8_IS_INVARIANT # define UTF8_IS_INVARIANT(c) (isASCII(c) || isCNTRL_L1(c)) #endif #endif #ifndef UVCHR_IS_INVARIANT # define UVCHR_IS_INVARIANT(c) UTF8_IS_INVARIANT(c) #endif #ifdef UVCHR_IS_INVARIANT # if 'A' == 65 # ifdef QUADKIND # define D_PPP_UVCHR_SKIP_UPPER(c) \ (WIDEST_UTYPE) (c) < \ (((WIDEST_UTYPE) 1) << (6 * D_PPP_BYTE_INFO_BITS)) ? 7 : 13 # else # define D_PPP_UVCHR_SKIP_UPPER(c) 7 /* 32 bit platform */ # endif # else /* In the releases this is backported to, UTF-EBCDIC had a max of 2**31-1 */ # define D_PPP_UVCHR_SKIP_UPPER(c) 7 # endif #ifndef UVCHR_SKIP # define UVCHR_SKIP(c) \ UVCHR_IS_INVARIANT(c) ? 1 : \ (WIDEST_UTYPE) (c) < (32 * (1U << ( D_PPP_BYTE_INFO_BITS))) ? 2 : \ (WIDEST_UTYPE) (c) < (16 * (1U << (2 * D_PPP_BYTE_INFO_BITS))) ? 3 : \ (WIDEST_UTYPE) (c) < ( 8 * (1U << (3 * D_PPP_BYTE_INFO_BITS))) ? 4 : \ (WIDEST_UTYPE) (c) < ( 4 * (1U << (4 * D_PPP_BYTE_INFO_BITS))) ? 5 : \ (WIDEST_UTYPE) (c) < ( 2 * (1U << (5 * D_PPP_BYTE_INFO_BITS))) ? 6 : \ D_PPP_UVCHR_SKIP_UPPER(c) #endif #endif #ifdef is_ascii_string #ifndef is_invariant_string # define is_invariant_string(s,l) is_ascii_string(s,l) #endif #ifndef is_utf8_invariant_string # define is_utf8_invariant_string(s,l) is_ascii_string(s,l) #endif /* Hint: is_ascii_string, is_invariant_string is_utf8_invariant_string() does the same thing and is preferred because its name is more accurate as to what it does */ #endif #ifdef ibcmp_utf8 #ifndef foldEQ_utf8 # define foldEQ_utf8(s1,pe1,l1,u1,s2,pe2,l2,u2) \ cBOOL(! ibcmp_utf8(s1,pe1,l1,u1,s2,pe2,l2,u2)) #endif #endif #if defined(is_utf8_string) && defined(UTF8SKIP) #ifndef isUTF8_CHAR # define isUTF8_CHAR(s, e) ( \ (e) <= (s) || ! is_utf8_string(s, UTF8_SAFE_SKIP(s, e)) \ ? 0 \ : UTF8SKIP(s)) #endif #endif #if 'A' == 65 #ifndef BOM_UTF8 # define BOM_UTF8 "\xEF\xBB\xBF" #endif #ifndef REPLACEMENT_CHARACTER_UTF8 # define REPLACEMENT_CHARACTER_UTF8 "\xEF\xBF\xBD" #endif #elif '^' == 95 #ifndef BOM_UTF8 # define BOM_UTF8 "\xDD\x73\x66\x73" #endif #ifndef REPLACEMENT_CHARACTER_UTF8 # define REPLACEMENT_CHARACTER_UTF8 "\xDD\x73\x73\x71" #endif #elif '^' == 176 #ifndef BOM_UTF8 # define BOM_UTF8 "\xDD\x72\x65\x72" #endif #ifndef REPLACEMENT_CHARACTER_UTF8 # define REPLACEMENT_CHARACTER_UTF8 "\xDD\x72\x72\x70" #endif #else # error Unknown character set #endif #if (PERL_BCDVERSION < 0x5031004) /* Versions prior to this accepted things that are now considered * malformations, and didn't return -1 on error with warnings enabled * */ # undef utf8_to_uvchr_buf #endif /* This implementation brings modern, generally more restricted standards to * utf8_to_uvchr_buf. Some of these are security related, and clearly must * be done. But its arguable that the others need not, and hence should not. * The reason they're here is that a module that intends to play with the * latest perls should be able to work the same in all releases. An example is * that perl no longer accepts any UV for a code point, but limits them to * IV_MAX or below. This is for future internal use of the larger code points. * If it turns out that some of these changes are breaking code that isn't * intended to work with modern perls, the tighter restrictions could be * relaxed. khw thinks this is unlikely, but has been wrong in the past. */ /* 5.6.0 is the first release with UTF-8, and we don't implement this function * there due to its likely lack of still being in use, and the underlying * implementation is very different from later ones, without the later * safeguards, so would require extra work to deal with */ #if (PERL_BCDVERSION >= 0x5006001) && ! defined(utf8_to_uvchr_buf) /* Choose which underlying implementation to use. At least one must be * present or the perl is too early to handle this function */ # if defined(utf8n_to_uvchr) || defined(utf8_to_uvchr) || defined(utf8_to_uv) # if defined(utf8n_to_uvchr) /* This is the preferred implementation */ # define D_PPP_utf8_to_uvchr_buf_callee utf8n_to_uvchr # elif /* Must be at least 5.6.1 from #if above; \ If have both regular and _simple, regular has all args */ \ defined(utf8_to_uv) && defined(utf8_to_uv_simple) # define D_PPP_utf8_to_uvchr_buf_callee utf8_to_uv # elif defined(utf8_to_uvchr) /* The below won't work well on error input */ # define D_PPP_utf8_to_uvchr_buf_callee(s, curlen, retlen, flags) \ utf8_to_uvchr((U8 *)(s), (retlen)) # else # define D_PPP_utf8_to_uvchr_buf_callee(s, curlen, retlen, flags) \ utf8_to_uv((U8 *)(s), (retlen)) # endif # endif # if defined(NEED_utf8_to_uvchr_buf) static UV DPPP_(my_utf8_to_uvchr_buf)(pTHX_ const U8 * s, const U8 * send, STRLEN * retlen); static #else extern UV DPPP_(my_utf8_to_uvchr_buf)(pTHX_ const U8 * s, const U8 * send, STRLEN * retlen); #endif #if defined(NEED_utf8_to_uvchr_buf) || defined(NEED_utf8_to_uvchr_buf_GLOBAL) #ifdef utf8_to_uvchr_buf # undef utf8_to_uvchr_buf #endif #define utf8_to_uvchr_buf(a,b,c) DPPP_(my_utf8_to_uvchr_buf)(aTHX_ a,b,c) #define Perl_utf8_to_uvchr_buf DPPP_(my_utf8_to_uvchr_buf) UV DPPP_(my_utf8_to_uvchr_buf)(pTHX_ const U8 *s, const U8 *send, STRLEN *retlen) { UV ret; STRLEN curlen; bool overflows = 0; const U8 *cur_s = s; const bool do_warnings = ckWARN_d(WARN_UTF8); # if (PERL_BCDVERSION < 0x5026000) && ! defined(EBCDIC) STRLEN overflow_length = 0; # endif if (send > s) { curlen = send - s; } else { assert(0); /* Modern perls die under this circumstance */ curlen = 0; if (! do_warnings) { /* Handle empty here if no warnings needed */ if (retlen) *retlen = 0; return UNICODE_REPLACEMENT; } } # if (PERL_BCDVERSION < 0x5026000) && ! defined(EBCDIC) /* Perl did not properly detect overflow for much of its history on * non-EBCDIC platforms, often returning an overlong value which may or may * not have been tolerated in the call. Also, earlier versions, when they * did detect overflow, may have disallowed it completely. Modern ones can * replace it with the REPLACEMENT CHARACTER, depending on calling * parameters. Therefore detect it ourselves in releases it was * problematic in. */ if (curlen > 0 && UNLIKELY(*s >= 0xFE)) { /* First, on a 32-bit machine the first byte being at least \xFE * automatically is overflow, as it indicates something requiring more * than 31 bits */ if (sizeof(ret) < 8) { overflows = 1; overflow_length = (*s == 0xFE) ? 7 : 13; } else { const U8 highest[] = /* 2*63-1 */ "\xFF\x80\x87\xBF\xBF\xBF\xBF\xBF\xBF\xBF\xBF\xBF\xBF"; const U8 *cur_h = highest; for (cur_s = s; cur_s < send; cur_s++, cur_h++) { if (UNLIKELY(*cur_s == *cur_h)) { continue; } /* If this byte is larger than the corresponding highest UTF-8 * byte, the sequence overflows; otherwise the byte is less * than (as we handled the equality case above), and so the * sequence doesn't overflow */ overflows = *cur_s > *cur_h; break; } /* Here, either we set the bool and broke out of the loop, or got * to the end and all bytes are the same which indicates it doesn't * overflow. If it did overflow, it would be this number of bytes * */ overflow_length = 13; } } if (UNLIKELY(overflows)) { ret = 0; if (! do_warnings && retlen) { *retlen = overflow_length; } } else # endif /* < 5.26 */ /* Here, we are either in a release that properly detects overflow, or * we have checked for overflow and the next statement is executing as * part of the above conditional where we know we don't have overflow. * * The modern versions allow anything that evaluates to a legal UV, but * not overlongs nor an empty input */ ret = D_PPP_utf8_to_uvchr_buf_callee( (U8 *) /* Early perls: no const */ s, curlen, retlen, (UTF8_ALLOW_ANYUV & ~(UTF8_ALLOW_LONG|UTF8_ALLOW_EMPTY))); # if (PERL_BCDVERSION >= 0x5026000) && (PERL_BCDVERSION < 0x5028000) /* But actually, more modern versions restrict the UV to being no more than * what an IV can hold, so it could still have gotten it wrong about * overflowing. */ if (UNLIKELY(ret > IV_MAX)) { overflows = 1; } # endif if (UNLIKELY(overflows)) { if (! do_warnings) { if (retlen) { *retlen = D_PPP_MIN(*retlen, UTF8SKIP(s)); *retlen = D_PPP_MIN(*retlen, curlen); } return UNICODE_REPLACEMENT; } else { /* We use the error message in use from 5.8-5.26 */ Perl_warner(aTHX_ packWARN(WARN_UTF8), "Malformed UTF-8 character (overflow at 0x%" UVxf ", byte 0x%02x, after start byte 0x%02x)", ret, *cur_s, *s); if (retlen) { *retlen = (STRLEN) -1; } return 0; } } /* Here, did not overflow, but if it failed for some other reason, and * warnings are off, to emulate the behavior of the real utf8_to_uvchr(), * try again, allowing anything. (Note a return of 0 is ok if the input * was '\0') */ if (UNLIKELY(ret == 0 && (curlen == 0 || *s != '\0'))) { /* If curlen is 0, we already handled the case where warnings are * disabled, so this 'if' will be true, and so later on, we know that * 's' is dereferencible */ if (do_warnings) { *retlen = (STRLEN) -1; } else { ret = D_PPP_utf8_to_uvchr_buf_callee( (U8 *) /* Early perls: no const */ s, curlen, retlen, UTF8_ALLOW_ANY); /* Override with the REPLACEMENT character, as that is what the * modern version of this function returns */ ret = UNICODE_REPLACEMENT; # if (PERL_BCDVERSION < 0x5016000) /* Versions earlier than this don't necessarily return the proper * length. It should not extend past the end of string, nor past * what the first byte indicates the length is, nor past the * continuation characters */ if (retlen && (IV) *retlen >= 0) { unsigned int i = 1; *retlen = D_PPP_MIN(*retlen, curlen); *retlen = D_PPP_MIN(*retlen, UTF8SKIP(s)); do { # ifdef UTF8_IS_CONTINUATION if (! UTF8_IS_CONTINUATION(s[i])) # else /* Versions without the above don't support EBCDIC anyway */ if (s[i] < 0x80 || s[i] > 0xBF) # endif { *retlen = i; break; } } while (++i < *retlen); } # endif } } return ret; } # endif #endif #if defined(UTF8SKIP) && defined(utf8_to_uvchr_buf) #undef utf8_to_uvchr /* Always redefine this unsafe function so that it refuses to read past a NUL, making it much less likely to read off the end of the buffer. A NUL indicates the start of the next character anyway. If the input isn't NUL-terminated, the function remains unsafe, as it always has been. */ #ifndef utf8_to_uvchr # define utf8_to_uvchr(s, lp) \ ((*(s) == '\0') \ ? utf8_to_uvchr_buf(s,((s)+1), lp) /* Handle single NUL specially */ \ : utf8_to_uvchr_buf(s, (s) + UTF8_CHK_SKIP(s), (lp))) #endif #endif /* Hint: utf8_to_uvchr Use utf8_to_uvchr_buf() instead. But ONLY if you KNOW the upper bound of the input string (not resorting to using UTF8SKIP, etc., to infer it). The backported utf8_to_uvchr() will do a better job to prevent most cases of trying to read beyond the end of the buffer */ /* Replace utf8_to_uvchr with utf8_to_uvchr_buf */ #ifdef sv_len_utf8 /* Older Perl versions have broken sv_len_utf8() when passed sv does not have SVf_UTF8 flag set */ /* Also note that SvGETMAGIC() may change presence of SVf_UTF8 flag */ # if (PERL_BCDVERSION < 0x5017005) # undef sv_len_utf8 # if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) # define sv_len_utf8_nomg(sv) ({ SV *_sv2 = (sv); (SvUTF8(_sv2) ? Perl_sv_len_utf8(aTHX_ (!SvGMAGICAL(_sv2) ? _sv2 : sv_mortalcopy_flags(_sv2, SV_NOSTEAL))) : ({ STRLEN _len; SvPV_nomg(_sv2, _len); _len; })); }) # define sv_len_utf8(sv) ({ SV *_sv1 = (sv); SvGETMAGIC(_sv1); sv_len_utf8_nomg(_sv1); }) # else # define sv_len_utf8_nomg(sv) (PL_Sv = (sv), (SvUTF8(PL_Sv) ? Perl_sv_len_utf8(aTHX_ (!SvGMAGICAL(PL_Sv) ? PL_Sv : sv_mortalcopy_flags(PL_Sv, SV_NOSTEAL))) : (SvPV_nomg(PL_Sv, PL_na), PL_na))) # define sv_len_utf8(sv) (PL_Sv = (sv), SvGETMAGIC(PL_Sv), sv_len_utf8_nomg(PL_Sv)) # endif # endif # if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) #ifndef sv_len_utf8_nomg # define sv_len_utf8_nomg(sv) ({ SV *_sv = (sv); sv_len_utf8(!SvGMAGICAL(_sv) ? _sv : sv_mortalcopy_flags(_sv, SV_NOSTEAL)); }) #endif # else #ifndef sv_len_utf8_nomg # define sv_len_utf8_nomg(sv) ((PL_Sv = (sv)), sv_len_utf8(!SvGMAGICAL(PL_Sv) ? PL_Sv : sv_mortalcopy_flags(PL_Sv, SV_NOSTEAL))) #endif # 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 #if defined(NEED_pv_escape) || defined(NEED_pv_escape_GLOBAL) #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) 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_buf) 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_buf) 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_buf) isuni ? utf8_to_uvchr_buf((U8*)pv, end, &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 #if defined(NEED_pv_pretty) || defined(NEED_pv_pretty_GLOBAL) #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) 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 #if defined(NEED_pv_display) || defined(NEED_pv_display_GLOBAL) #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) 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 /* If this doesn't exist, it's not needed, so noop */ #ifndef switch_to_global_locale # define switch_to_global_locale() #endif /* Originally, this didn't return a value, but in perls like that, the value * should always be TRUE. Add a return to Perl_sync_locale() when it's * available. And actually do a sync when its not, if locales are available on * this system. */ #ifdef sync_locale # if (PERL_BCDVERSION < 0x5027009) # if (PERL_BCDVERSION >= 0x5021003) # undef sync_locale # define sync_locale() (Perl_sync_locale(aTHX), 1) # elif defined(sync_locale) /* These should be the 5.20 maints*/ # undef sync_locale /* Just copy their defn and return 1 */ # define sync_locale() (new_ctype(setlocale(LC_CTYPE, NULL)), \ new_collate(setlocale(LC_COLLATE, NULL)), \ set_numeric_local(), \ new_numeric(setlocale(LC_NUMERIC, NULL)), \ 1) # elif defined(new_ctype) && defined(LC_CTYPE) # define sync_locale() (new_ctype(setlocale(LC_CTYPE, NULL)), 1) # endif # endif #endif #ifndef sync_locale # define sync_locale() 1 #endif #endif /* _P_P_PORTABILITY_H_ */ /* End of File ppport.h */ Text-CSV_XS-1.41/err-csv/0000755000031300001440000000000013622243127015506 5ustar00merijnusers00000000000000Text-CSV_XS-1.41/err-csv/E2022.csv0000644000031300001440000000001513614547501016715 0ustar00merijnusers000000000000001,"e2022 ",3 Text-CSV_XS-1.41/err-csv/E2024.csv0000644000031300001440000000001113614550212016704 0ustar00merijnusers000000000000001,"e2024:Text-CSV_XS-1.41/err-csv/E2023.csv0000644000031300001440000000001513614547503016720 0ustar00merijnusers000000000000001,""e2023",3 Text-CSV_XS-1.41/err-csv/E2021.csv0000644000031300001440000000001513614547475016726 0ustar00merijnusers000000000000001,"e2021 ",3 Text-CSV_XS-1.41/err-csv/check.pl0000755000031300001440000000236113614553053017130 0ustar00merijnusers00000000000000#!/pro/bin/perl use 5.14.2; use warnings; our $VERSION = "0.01 - 20200130"; our $CMD = $0 =~ s{.*/}{}r; sub usage { my $err = shift and select STDERR; say "usage: $CMD ..."; exit $err; } # usage use CSV; use Capture::Tiny qw( :all );; use Getopt::Long qw(:config bundling); GetOptions ( "help|?" => sub { usage (0); }, "V|version" => sub { say "$CMD [$VERSION]"; exit 0; }, "v|verbose:1" => \(my $opt_v = 0), ) or usage (1); my %e = ( 2021 => [qw( -N --no-binary )], 2022 => [qw( -N --no-binary )], 2024 => [qw( -N -e : )] ); my %m; my $csv = Text::CSV_XS->new; foreach my $e (1000 .. 9999) { $csv->SetDiag ($e); my $s = "" . $csv->error_diag or next; $s =~ m/[\x00-\x1f]/ and $s = DDisplay ($s) =~ s/^"(.*)"\z/$1/r; $m{$e} = $s; } foreach my $ef (sort glob "E*.csv") { print STDERR "$ef\t"; my $e = $ef =~ s/^E(\d+).*/$1/r; my $out = capture_merged { system $^X, "../examples/csv-check", @{$e{$e} || []}, $ef; }; unless ($out =~ m/# CSV_XS ERROR: (.*)/) { say "$ef does not generate a parsable error:\n$out"; next; } my $em = $1 =~ s/^([0-9]+) - //r; my $en = $1 // "----"; if ($en eq $e) { warn "OK\n"; } else { warn "$en - $em\n"; } } Text-CSV_XS-1.41/CSV_XS.xs0000644000031300001440000016024013615014641015550 0ustar00merijnusers00000000000000/* Copyright (c) 2007-2020 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_utf8_to_uvchr_buf #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_WARN 1 #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 #ifdef __THW_370__ #define CH_TAB '\005' #define CH_NL '\025' #define CH_CR '\015' #define CH_SPACE '\100' #define CH_DEL '\007' #else #define CH_TAB '\011' #define CH_NL '\012' #define CH_CR '\015' #define CH_SPACE '\040' #define CH_DEL '\177' #endif #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_reftype(f,x) \ (f && ((SvGMAGICAL (f) && mg_get (f)) || 1) && SvROK (f) && SvTYPE (SvRV (f)) == x) #define _is_arrayref(f) _is_reftype (f, SVt_PVAV) #define _is_hashref(f) _is_reftype (f, SVt_PVHV) #define _is_coderef(f) _is_reftype (f, SVt_PVCV) #define SvSetUndef(sv) sv_setpvn (sv, NULL, 0) #define SvSetEmpty(sv) sv_setpvn_mg (sv, "", 0) #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 CACHE_ID_formula 38 #define CACHE_ID_strict 42 #define CACHE_ID_undef_str 46 #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; byte formula; byte strict; short strict_n; long is_bound; ulng recno; byte * cache; SV * pself; /* PL_self, for error_diag */ HV * self; SV * bound; char * types; byte eol_len; byte sep_len; byte quo_len; byte types_len; char * bptr; SV * tmp; byte utf8; byte has_ahead; byte eolx; byte undef_flg; byte * undef_str; 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" }, { 1008, "INI - SEP undefined" }, { 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" }, { 1014, "INI - header called on undefined stream" }, /* Syntax errors */ { 1500, "PRM - Invalid/unsupported argument(s)" }, { 1501, "PRM - The key attribute is passed as an unsupported type" }, { 1502, "PRM - The value attribute is passed without the key attribute" }, { 1503, "PRM - The value attribute is passed as an unsupported type" }, /* 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" }, { 2014, "ENF - Inconsistent number of fields" }, /* 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" }, { 4001, "PRM - The key does not exist as field in the data" }, { 0, "" }, }; static int last_error = 0; static SV *m_getline, *m_print; #define is_EOL(c) (c == CH_EOLX) #define __is_SEPX(c) (c == CH_SEP && (csv->sep_len == 0 || (\ csv->size - csv->used >= (STRLEN)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 >= (STRLEN)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 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 */ /* This function should be altered to deal with the optional extra argument * that holds the replacement message */ #define SetDiag(csv,xse) cx_SetDiag (aTHX_ csv, xse) static SV *cx_SetDiag (pTHX_ csv_t *csv, int xse) { dSP; SV *err = SvDiag (xse); SV *pself = csv->pself; 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->auto_diag) { unless (_is_hashref (pself)) pself = newRV_inc ((SV *)csv->self); ENTER; PUSHMARK (SP); XPUSHs (pself); PUTBACK; call_pv ("Text::CSV_XS::error_diag", G_VOID | G_DISCARD); LEAVE; unless (pself == csv->pself) sv_free (pself); } 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; byte bv; char *cp = "\0"; STRLEN len = 0; unless ((svp = hv_fetchs (hv, "_CACHE", FALSE)) && *svp) return; cache = (byte *)SvPV_nolen (*svp); (void)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; bv = (unsigned)iv & 0xff; 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 = bv; break; case CACHE_ID_keep_meta_info: csv->keep_meta_info = bv; break; case CACHE_ID_always_quote: csv->always_quote = bv; break; case CACHE_ID_quote_empty: csv->quote_empty = bv; break; case CACHE_ID_quote_space: csv->quote_space = bv; break; case CACHE_ID_escape_null: csv->escape_null = bv; break; case CACHE_ID_quote_binary: csv->quote_binary = bv; break; case CACHE_ID_decode_utf8: csv->decode_utf8 = bv; break; case CACHE_ID_allow_loose_escapes: csv->allow_loose_escapes = bv; break; case CACHE_ID_allow_loose_quotes: csv->allow_loose_quotes = bv; break; case CACHE_ID_allow_unquoted_escape: csv->allow_unquoted_escape = bv; break; case CACHE_ID_allow_whitespace: csv->allow_whitespace = bv; break; case CACHE_ID_blank_is_undef: csv->blank_is_undef = bv; break; case CACHE_ID_empty_is_undef: csv->empty_is_undef = bv; break; case CACHE_ID_formula: csv->formula = bv; break; case CACHE_ID_strict: csv->strict = bv; break; case CACHE_ID_verbatim: csv->verbatim = bv; break; case CACHE_ID_auto_diag: csv->auto_diag = bv; break; case CACHE_ID_diag_verbose: csv->diag_verbose = bv; break; case CACHE_ID__has_ahead: csv->has_ahead = bv; break; case CACHE_ID__has_hooks: csv->has_hooks = bv; break; case CACHE_ID_has_error_input: csv->has_error_input = bv; break; /* a 4-byte IV */ case CACHE_ID__is_bound: csv->is_bound = iv; break; /* string */ case CACHE_ID_sep: (void)memcpy (csv->sep, cp, len); csv->sep_len = len == 1 ? 0 : len; break; case CACHE_ID_quo: (void)memcpy (csv->quo, cp, len); csv->quo_len = len == 1 ? 0 : len; break; case CACHE_ID_eol: (void)memcpy (csv->eol, cp, len); csv->eol_len = len; csv->eol_is_cr = len == 1 && *cp == CH_CR ? 1 : 0; break; case CACHE_ID_undef_str: if (*cp) { csv->undef_str = (byte *)cp; if (SvUTF8 (val)) csv->undef_flg = 3; } else { csv->undef_str = NULL; csv->undef_flg = 0; } break; default: warn ("Unknown cache index %d ignored\n", idx); } csv->cache = cache; (void)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); (void)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 ("formula", csv->formula); _cache_show_byte ("strict", csv->strict); _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; (void)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); (void)memcpy (csv, cache, sizeof (csv_t)); } else { SV *sv_cache; (void)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); (void)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); (void)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); (void)memcpy (csv->eol, eol, len); csv->eol_len = len; if (len == 1 && *csv->eol == CH_CR) csv->eol_is_cr = 1; } csv->undef_flg = 0; if ((svp = hv_fetchs (self, "undef_str", FALSE)) && *svp && SvOK (*svp)) { /*if (sv && (SvOK (sv) || ( (SvGMAGICAL (sv) && (mg_get (sv), 1) && SvOK (sv))))) {*/ csv->undef_str = (byte *)SvPV_nolen (*svp); if (SvUTF8 (*svp)) csv->undef_flg = 3; } else csv->undef_str = NULL; 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->strict = bool_opt ("strict"); 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"); csv->formula = num_opt ("formula"); unless (csv->escape_char) csv->escape_null = 0; sv_cache = newSVpvn ((char *)csv, sizeof (csv_t)); csv->cache = (byte *)SvPVX (sv_cache); SvREADONLY_on (sv_cache); (void)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 > 1 && is_utf8_string ((U8 *)(csv->sep), csv->sep_len)) csv->utf8 = 1; if (csv->quo_len > 1 && 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; 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_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, SSize_t 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)) { SvSetEmpty (sv); return (sv); } } } (void)SetDiag (csv, 3008); return (NULL); } /* bound_field */ #define was_quoted(mf,idx) cx_was_quoted (aTHX_ mf, idx) static int cx_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 _formula(csv,sv,len,f) cx_formula (aTHX_ csv, sv, len, f) static char *cx_formula (pTHX_ csv_t *csv, SV *sv, STRLEN *len, int f) { int fa = csv->formula; if (fa == 1) die ("Formulas are forbidden\n"); if (fa == 2) croak ("Formulas are forbidden\n"); if (fa == 3) { char *ptr = SvPV_nolen (sv); char rec[40]; char field[128]; SV **svp; if (csv->recno) (void)sprintf (rec, " in record %lu", csv->recno + 1); else *rec = (char)0; *field = (char)0; if ((svp = hv_fetchs (csv->self, "_COLUMN_NAMES", FALSE)) && _is_arrayref (*svp)) { AV *avp = (AV *)SvRV (*svp); if (avp && av_len (avp) >= (f - 1)) { SV **fnm = av_fetch (avp, f - 1, FALSE); if (fnm && *fnm && SvOK (*fnm)) (void)sprintf (field, " (column: '%.100s')", SvPV_nolen (*fnm)); } } warn ("Field %d%s%s contains formula '%s'\n", f, field, rec, ptr); return ptr; } if (len) *len = 0; if (fa == 4) { unless (SvREADONLY (sv)) SvSetEmpty (sv); return ""; } if (fa == 5) { unless (SvREADONLY (sv)) SvSetUndef (sv); return NULL; } if (fa == 6) { int result; SV **svp = hv_fetchs (csv->self, "_FORMULA_CB", FALSE); if (svp && _is_coderef (*svp)) { dSP; ENTER; SAVE_DEFSV; /* local $_ */ DEFSV = sv; PUSHMARK (SP); PUTBACK; result = call_sv (*svp, G_SCALAR); SPAGAIN; if (result) sv_setsv (sv, POPs); PUTBACK; LEAVE; } return len ? SvPV (sv, *len) : SvPV_nolen (sv); } /* So far undefined behavior */ return NULL; } /* _formula */ #define Combine(csv,dst,fields) cx_Combine (aTHX_ csv, dst, fields) static int cx_Combine (pTHX_ csv_t *csv, SV *dst, AV *fields) { SSize_t i, n; int 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 = (IV)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; STRLEN len = 0; char *ptr = NULL; 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, FALSE); sv = svp && *svp ? *svp : NULL; } if (sv && (SvOK (sv) || ( (SvGMAGICAL (sv) && (mg_get (sv), 1) && SvOK (sv))))) { int quoteMe; ptr = SvPV (sv, len); if (*ptr == '=' && csv->formula) { unless (ptr = _formula (csv, sv, &len, i)) continue; } if (len == 0) quoteMe = aq ? 1 : qe ? 1 : qm ? was_quoted (qm, i) : 0; else { if (SvUTF8 (sv)) { csv->utf8 = 1; csv->binary = 1; } quoteMe = aq ? 1 : qm ? was_quoted (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]); } } } else { if (csv->undef_str) { byte *ptr = csv->undef_str; STRLEN len = strlen ((char *)ptr); if (csv->undef_flg) { csv->utf8 = 1; csv->binary = 1; } while (len--) CSV_PUT (csv, dst, *ptr++); } } } 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, STRLEN 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; PUSHMARK (sp); EXTEND (sp, 1); PUSHs (src); PUTBACK; result = call_sv (m_getline, G_METHOD); SPAGAIN; csv->eol_pos = -1; csv->tmp = result ? POPs : NULL; PUTBACK; #if MAINT_DEBUG > 4 (void)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 (void)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 (void)fprintf (stderr, "# CSV_PUT @ %4d: 0x%02x '%c'\n", __LINE__, c, isprint (c) ? c : '?') #define PUT_SEPX_RPT1 (void)fprintf (stderr, "# PUT SEPX @ %4d\n", __LINE__) #define PUT_SEPX_RPT2 (void)fprintf (stderr, "# Done putting SEPX\n") #define PUT_QUOX_RPT1 (void)fprintf (stderr, "# PUT QUOX @ %4d\n", __LINE__) #define PUT_QUOX_RPT2 (void)fprintf (stderr, "# Done putting QUOX\n") #define PUT_EOLX_RPT1 (void)fprintf (stderr, "# PUT EOLX @ %4d\n", __LINE__) #define PUT_EOLX_RPT2 (void)fprintf (stderr, "# Done putting EOLX\n") #define PUSH_RPT (void)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; (void)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; (void)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 (csv->formula && SvCUR (sv) && *(SvPV_nolen (sv)) == '=') \ (void)_formula (csv, sv, NULL, fnum); \ if (SvCUR (sv) == 0 && ( \ csv->empty_is_undef || \ (!(f & CSV_FLAGS_QUO) && csv->blank_is_undef))) \ SvSetUndef (sv); \ 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 (""); \ fnum++; \ 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++) (void)sprintf (sep + x * x, "%02x ", csv->sep[x]); } else (void)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 (void)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 (void)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) SvSetUndef (sv); else SvSetEmpty (sv); 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 (void)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 (void)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; SvSetEmpty (sv); 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 (void)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) SvSetUndef (sv); else SvSetEmpty (sv); 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 lnu = csv->used - 5; if (lnu <= MAX_ATTR_LEN) { sep[lnu] = (char)0; (void)memcpy (csv->sep, sep, lnu); csv->sep_len = lnu == 1 ? 0 : lnu; 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 (void)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 (void)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 >= (STRLEN)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) SvSetUndef (sv); else SvSetEmpty (sv); 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)) { 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) > (IV)csv.size) sv_setiv (pos, SvIV (pos) - csv.size); } } } else { csv.tmp = src; csv.utf8 = SvUTF8 (src) ? 1 : 0; 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); (void)hv_store (hv, "_RECNO", 6, newSViv (++csv.recno), 0); (void)hv_store (hv, "_EOF", 4, &PL_sv_no, 0); if (csv.strict) { unless (csv.strict_n) csv.strict_n = (short)csv.fld_idx; if (csv.fld_idx != csv.strict_n) { unless (csv.useIO & useIO_EOF) ParseError (&csv, 2014, csv.used); result = FALSE; } } 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; */ (void)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 */ (void)memcpy (csv.cache, &csv, sizeof (csv_t)); if (result && csv.types) { STRLEN i; STRLEN len = av_len (av); SV **svp; for (i = 0; i <= len && i <= csv.types_len; i++) { if ((svp = av_fetch (av, i, FALSE)) && *svp && SvOK (*svp)) { switch (csv.types[i]) { case CSV_XS_TYPE_IV: #ifdef CSV_XS_TYPE_WARN sv_setiv (*svp, SvIV (*svp)); #else if (SvTRUE (*svp)) sv_setiv (*svp, SvIV (*svp)); else sv_setiv (*svp, 0); #endif break; case CSV_XS_TYPE_NV: #ifdef CSV_XS_TYPE_WARN sv_setnv (*svp, SvNV (*svp)); #else if (SvTRUE (*svp)) sv_setnv (*svp, SvNV (*svp)); else sv_setnv (*svp, 0.0); #endif 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 (void)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); mXPUSHs (newRV_inc ((SV *)hv)); mXPUSHs (newRV_inc ((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 */ /* API also offers av_clear and av_undef, but they have more overhead */ #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"); Perl_load_module (aTHX_ PERL_LOADMOD_NOIMPORT, newSVpvs ("IO::Handle"), NULL, NULL, NULL); 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.41/ChangeLog0000644000031300001440000010125013622243123015672 0ustar00merijnusers000000000000001.41 - 2020-02-16, H.Merijn Brand * Update to Devel::PPPort-3.56 * csv2xls uses sheetname as csv2xlsx * csv2xlsx: support images (each image gets its own tab) * More docs. (Data validation) * It's 2020 * No binary literals in fixed error messages * Fix auto_diag > 2 to die when headers are used (issue 19) 1.40 - 2019-09-15, H.Merijn Brand * Update to Devel::PPPort-3.52 * Development perl is now 5.28.2 * [csv2xlsx] sheetnames are restricted to 31 characters * Generate cpanfile * Add munge type "db" * [csv2xls/csv2xlsx] do not generate xls/xlsx on empty CSV (issue#18) * New: support $csv->formula (sub { ... }) * Support stacked encodings 1.39 - 2019-03-15, H.Merijn Brand * It's 2019 * Fix tests to skip on Encode failing (PR#17 charsbar + klapperl) * Tested on Z/OS (s390x - Hercules) :) * Test with new Module::CPANTS::Analyse * Add options -w/-b/-Z to csvdiff * Fix strict on streaming EOF * Now also tested with cperl 1.38 - 2018-12-30, H.Merijn Brand * Name the duplicate headers on error 1013 * Add missing attributes to default list (doc only, David H. Gutteridge) * Add support for combined keys * Look at $NO_COLOR for csvdiff * Add support for key-value pair 1.37 - 2018-09-27, H.Merijn Brand * Moved pod-tests from t to xt * Add munge as alias for munge_column_names * Update Devel::PPPort * Simplified ref-check defines in XS (issue 12, thanks pali) * Tested against perl-5.29.3 1.36 - 2018-06-26, H.Merijn Brand * Now also tested on FreeBSD-11.1 * Update to Devel::PPPort-3.42 * Fixed memory leak (Thanks DaveM) * Add undef_str attribute * Tested against perl-5.28.0 * Move from DynaLoader to XSLoader * Tested on Synology DSM 1.35 - 2018-03-21, H.Merijn Brand * Remove META.yml from MANIFEST.skip * Use UNIVERSAL::isa to protect against unblessed references * -Wformat warning (RT#123729) * Make detect_bom result available * It's 2018 * Add csv (out => \"skip") - suppress output deliberately * Allow sub as top-level filter * Tested against Test2::Harness-0.001062 (yath test) * Tested against perl-5.27.10 1.34 - 2017-11-05, H.Merijn Brand * Bad arg for formula (like "craok") will now die with error 1500 * Row report in formula reporting was off by 1 * Add a prominent section about BOM handling * Make sheet label more portable (csv2xlsx) * Allow munge => \%hash * Preserve first row in csv (set_column_names => 0) 1.33 - 2017-10-19, H.Merijn Brand * Small additional fix for eol = \r + BOM * Updated doc for example files * Add support for formula actions (issue 11) - csv2xls and csv2xlsx now warn by default * Reset file info on ->header call (RT#123320) 1.32 - 2017-09-15, H.Merijn Brand * Add keep_headers attribute to csv () * Fix on_in when used in combination with key * Fail on invalid arguments to csv * Fix header method on EOL = CR (RT#122764) 1.31 - 2017-06-13, H.Merijn Brand * Fix already decoded BOM in headers * New options in csv-check * Some perlcritic * "escape" is alias for "escape_char" for consistency. * Code cleanup and more tests (Devel::Cover) * Improve csv-check auto-sep-detection 1.30 - 2017-06-08, H.Merijn Brand * Add csv (..., out => ...) syntax examples (issue 7) * Disable escape_null for undefined escape_char * Fix ->say for bound columns (RT#121576) * Update to Devel::PPPort 3.36 * Tested under 5.26.0 and 5.27.0 * Doc changes and additions 1.29 - 2017-04-25, H.Merijn Brand * More docs for bind_colmns (RT#121350) * New attribute "strict" (also addresses RT#121350) 1.28 - 2017-03-22, H.Merijn Brand * Fix length problem with bound empty fields and UTF-8 (RT#120655) 1.27 - 2017-03-02, H.Merijn Brand * Remove unneeded done_testing (Paul Howarth) * Attribute sep/sep_char is not allowed to be undefined * Increased test coverage: added errors 1008 and 1014 * Default for escape_null in csv () is now false * It's 2017 * New error code for illegal argument(s)/parameter(s) (RT#119827) * Fix tests for perl without dot in @INC * Fix crlf issue for csv () on Windows (RT#120466) 1.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) - requires perl-5.6.2 or newer 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.41/MANIFEST0000644000031300001440000000443413622243127015263 0ustar00merijnusers00000000000000ChangeLog Change history README Docs MANIFEST This file cpanfile Dependency list for cpan/cpanm 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/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/66_formula.t Formula behavior 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 err-csv/check.pl Script to test error situations err-csv/E2021.csv Error 2021 err-csv/E2022.csv Error 2022 err-csv/E2023.csv Error 2023 err-csv/E2024.csv Error 2024 META.yml Module YAML meta-data (added by MakeMaker) META.json Module JSON meta-data (added by MakeMaker) Text-CSV_XS-1.41/CONTRIBUTING.md0000644000031300001440000000202613531672504016362 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). # Mail Please, please, please, do *NOT* use HTML mail. [Plain text](https://useplaintext.email) [without](http://www.goldmark.org/jeff/stupid-disclaimers/) [disclaimers](https://www.economist.com/business/2011/04/07/spare-us-the-e-mail-yada-yada) will do fine! # Requirements The minimum version required to use this module is stated in [Makefile.PL](./Makefile.PL) Text-CSV_XS-1.41/Makefile.PL0000644000031300001440000001076613614534474016122 0ustar00merijnusers00000000000000#!/usr/bin/perl # Copyright PROCURA B.V. (c) 2006-2020 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 => { "XSLoader" => 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); # perlcriticrc uses Config::Tiny, which does not support nesting -f ".perlcriticrc" && -s "$ENV{HOME}/.perlcriticrc" and eval { open my $fh, ">", ".perlcriticrc"; require Config::Tiny; my $cnf = Config::Tiny->read ("$ENV{HOME}/.perlcriticrc"); for ("ControlStructures::ProhibitPostfixControls", # postfix if in diag "Freenode::PackageMatchesFilename", # XS "Subroutines::ProhibitBuiltinHomonyms", # eof, say "ErrorHandling::RequireCarping", # for autodie "BuiltinFunctions::ProhibitBooleanGrep", "Variables::RequireLocalizedPunctuationVars", # *_, %_ ) { delete $cnf->{$_}; $cnf->{"-$_"} = {}; } $cnf->{"Compatibility::PodMinimumVersion"} {above_version} = "5.012"; # For L<> and =head3 $cnf->write (".perlcriticrc"); }; 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', '', 'ppport: ppport.h', ' perl ppport.h --compat-version=5.6.1 CSV_XS.xs', '', 'checkmeta: spellcheck ppport.h', ' 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', '', 'doc docs: doc/CSV_XS.md doc/CSV_XS.html doc/CSV_XS.man', 'doc/CSV_XS.md: CSV_XS.pm', ' pod2markdown < $? > $@', 'doc/CSV_XS.html: CSV_XS.pm', ' pod2html < $? 2>&1 | grep -v "^Cannot find" > $@', 'doc/CSV_XS.3: CSV_XS.pm', ' pod2man < $? > $@', 'doc/CSV_XS.man: doc/CSV_XS.3', ' nroff -mandoc < $? > $@', '', $min_vsn; } # postamble Text-CSV_XS-1.41/META.yml0000644000031300001440000000141213622243127015374 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.41' recommends: Encode: '3.02' requires: IO::Handle: 0 Test::More: 0 Tie::Scalar: 0 XSLoader: 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.41' Text-CSV_XS-1.41/META.json0000644000031300001440000000276313622243127015556 0ustar00merijnusers00000000000000{ "generated_by" : "Author", "version" : "1.41", "resources" : { "repository" : { "web" : "https://github.com/Tux/Text-CSV_XS", "url" : "https://github.com/Tux/Text-CSV_XS", "type" : "git" }, "homepage" : "https://metacpan.org/pod/Text::CSV_XS", "x_IRC" : "irc://irc.perl.org/#csv", "license" : [ "http://dev.perl.org/licenses/" ] }, "name" : "Text-CSV_XS", "abstract" : "Comma-Separated Values manipulation routines", "provides" : { "Text::CSV_XS" : { "file" : "CSV_XS.pm", "version" : "1.41" } }, "author" : [ "H.Merijn Brand " ], "license" : [ "perl_5" ], "dynamic_config" : 1, "release_status" : "stable", "meta-spec" : { "url" : "http://search.cpan.org/perldoc?CPAN::Meta::Spec", "version" : 2 }, "prereqs" : { "configure" : { "requires" : { "ExtUtils::MakeMaker" : "0" } }, "build" : { "requires" : { "Config" : "0" } }, "test" : { "requires" : { "Test::More" : "0", "Tie::Scalar" : "0" } }, "runtime" : { "recommends" : { "Encode" : "3.02" }, "requires" : { "IO::Handle" : "0", "XSLoader" : "0", "perl" : "5.006001" } } } }