diff options
Diffstat (limited to 'Master/tlpkg/tlperl/lib/ExtUtils/ParseXS.pm')
-rw-r--r-- | Master/tlpkg/tlperl/lib/ExtUtils/ParseXS.pm | 2913 |
1 files changed, 1356 insertions, 1557 deletions
diff --git a/Master/tlpkg/tlperl/lib/ExtUtils/ParseXS.pm b/Master/tlpkg/tlperl/lib/ExtUtils/ParseXS.pm index 79b39688492..883d9059311 100644 --- a/Master/tlpkg/tlperl/lib/ExtUtils/ParseXS.pm +++ b/Master/tlpkg/tlperl/lib/ExtUtils/ParseXS.pm @@ -1,109 +1,117 @@ package ExtUtils::ParseXS; +use strict; -use 5.006; # We use /??{}/ in regexes +use 5.006001; use Cwd; use Config; +use Exporter; use File::Basename; use File::Spec; use Symbol; -require Exporter; - -@ISA = qw(Exporter); -@EXPORT_OK = qw(process_file); - -# use strict; # One of these days... - -my(@XSStack); # Stack of conditionals and INCLUDEs -my($XSS_work_idx, $cpp_next_tmp); - -use vars qw($VERSION); -$VERSION = '2.2210'; +our $VERSION; +BEGIN { + $VERSION = '3.16'; +} +use ExtUtils::ParseXS::Constants $VERSION; +use ExtUtils::ParseXS::CountLines $VERSION; +use ExtUtils::ParseXS::Utilities $VERSION; $VERSION = eval $VERSION if $VERSION =~ /_/; -use vars qw(%input_expr %output_expr $ProtoUsed @InitFileCode $FH $proto_re $Overload $errors $Fallback - $cplusplus $hiertype $WantPrototypes $WantVersionChk $except $WantLineNumbers - $WantOptimize $process_inout $process_argtypes @tm - $dir $filename $filepathname %IncludedFiles - %type_kind %proto_letter - %targetable $BLOCK_re $lastline $lastline_no - $Package $Prefix @line @BootCode %args_match %defaults %var_types %arg_list @proto_arg - $processing_arg_with_types %argtype_seen @outlist %in_out %lengthof - $proto_in_this_xsub $scope_in_this_xsub $interface $prepush_done $interface_macro $interface_macro_set - $ProtoThisXSUB $ScopeThisXSUB $xsreturn - @line_no $ret_type $func_header $orig_args - ); # Add these just to get compilation to happen. - +use ExtUtils::ParseXS::Utilities qw( + standard_typemap_locations + trim_whitespace + tidy_type + C_string + valid_proto_string + process_typemaps + make_targetable + map_type + standard_XS_defs + assign_func_args + analyze_preprocessor_statements + set_cond + Warn + current_line_number + blurt + death + check_conditional_preprocessor_statements + escape_file_for_line_directive + report_typemap_failure +); + +our @ISA = qw(Exporter); +our @EXPORT_OK = qw( + process_file + report_error_count +); + +# The scalars in the line below remain as 'our' variables because pulling +# them into $self led to build problems. In most cases, strings being +# 'eval'-ed contain the variables' names hard-coded. +our ( + $Package, $func_name, $Full_func_name, $pname, $ALIAS, +); + +our $self = bless {} => __PACKAGE__; sub process_file { - + # Allow for $package->process_file(%hash) in the future - my ($pkg, %args) = @_ % 2 ? @_ : (__PACKAGE__, @_); - - $ProtoUsed = exists $args{prototypes}; - + my ($pkg, %options) = @_ % 2 ? @_ : (__PACKAGE__, @_); + + $self->{ProtoUsed} = exists $options{prototypes}; + # Set defaults. - %args = ( - # 'C++' => 0, # Doesn't seem to *do* anything... - hiertype => 0, - except => 0, - prototypes => 0, - versioncheck => 1, - linenumbers => 1, - optimize => 1, - prototypes => 0, - inout => 1, - argtypes => 1, - typemap => [], - output => \*STDOUT, - csuffix => '.c', - %args, - ); + my %args = ( + argtypes => 1, + csuffix => '.c', + except => 0, + hiertype => 0, + inout => 1, + linenumbers => 1, + optimize => 1, + output => \*STDOUT, + prototypes => 0, + typemap => [], + versioncheck => 1, + FH => Symbol::gensym(), + %options, + ); + $args{except} = $args{except} ? ' TRY' : ''; # Global Constants - + my ($Is_VMS, $SymSet); if ($^O eq 'VMS') { $Is_VMS = 1; # Establish set of global symbols with max length 28, since xsubpp # will later add the 'XS_' prefix. require ExtUtils::XSSymSet; - $SymSet = new ExtUtils::XSSymSet 28; + $SymSet = ExtUtils::XSSymSet->new(28); } - @XSStack = ({type => 'none'}); - ($XSS_work_idx, $cpp_next_tmp) = (0, "XSubPPtmpAAAA"); - @InitFileCode = (); - $FH = Symbol::gensym(); - $proto_re = "[" . quotemeta('\$%&*@;[]_') . "]" ; - $Overload = 0; - $errors = 0; - $Fallback = '&PL_sv_undef'; + @{ $self->{XSStack} } = ({type => 'none'}); + $self->{InitFileCode} = [ @ExtUtils::ParseXS::Constants::InitFileCode ]; + $self->{Overload} = 0; + $self->{errors} = 0; + $self->{Fallback} = '&PL_sv_undef'; # Most of the 1500 lines below uses these globals. We'll have to # clean this up sometime, probably. For now, we just pull them out # of %args. -Ken - - $cplusplus = $args{'C++'}; - $hiertype = $args{hiertype}; - $WantPrototypes = $args{prototypes}; - $WantVersionChk = $args{versioncheck}; - $except = $args{except} ? ' TRY' : ''; - $WantLineNumbers = $args{linenumbers}; - $WantOptimize = $args{optimize}; - $process_inout = $args{inout}; - $process_argtypes = $args{argtypes}; - @tm = ref $args{typemap} ? @{$args{typemap}} : ($args{typemap}); - - for ($args{filename}) { - die "Missing required parameter 'filename'" unless $_; - $filepathname = $_; - ($dir, $filename) = (dirname($_), basename($_)); - $filepathname =~ s/\\/\\\\/g; - $IncludedFiles{$_}++; - } - - # Open the input file - open($FH, $args{filename}) or die "cannot open $args{filename}: $!\n"; + + $self->{hiertype} = $args{hiertype}; + $self->{WantPrototypes} = $args{prototypes}; + $self->{WantVersionChk} = $args{versioncheck}; + $self->{WantLineNumbers} = $args{linenumbers}; + $self->{IncludedFiles} = {}; + + die "Missing required parameter 'filename'" unless $args{filename}; + $self->{filepathname} = $args{filename}; + ($self->{dir}, $self->{filename}) = + (dirname($args{filename}), basename($args{filename})); + $self->{filepathname} =~ s/\\/\\\\/g; + $self->{IncludedFiles}->{$args{filename}}++; # Open the output file if given as a string. If they provide some # other kind of reference, trust them that we can print to it. @@ -114,194 +122,121 @@ sub process_file { } # Really, we shouldn't have to chdir() or select() in the first - # place. For now, just save & restore. + # place. For now, just save and restore. my $orig_cwd = cwd(); my $orig_fh = select(); - - chdir($dir); + + chdir($self->{dir}); my $pwd = cwd(); my $csuffix = $args{csuffix}; - - if ($WantLineNumbers) { + + if ($self->{WantLineNumbers}) { my $cfile; if ( $args{outfile} ) { $cfile = $args{outfile}; - } else { + } + else { $cfile = $args{filename}; $cfile =~ s/\.xs$/$csuffix/i or $cfile .= $csuffix; } tie(*PSEUDO_STDOUT, 'ExtUtils::ParseXS::CountLines', $cfile, $args{output}); select PSEUDO_STDOUT; - } else { - select $args{output}; - } - - foreach my $typemap (@tm) { - die "Can't find $typemap in $pwd\n" unless -r $typemap; } - - push @tm, standard_typemap_locations(); - - foreach my $typemap (@tm) { - next unless -f $typemap ; - # skip directories, binary files etc. - warn("Warning: ignoring non-text typemap file '$typemap'\n"), next - unless -T $typemap ; - open(TYPEMAP, $typemap) - or warn ("Warning: could not open typemap file '$typemap': $!\n"), next; - my $mode = 'Typemap'; - my $junk = "" ; - my $current = \$junk; - while (<TYPEMAP>) { - next if /^\s* #/; - my $line_no = $. + 1; - if (/^INPUT\s*$/) { - $mode = 'Input'; $current = \$junk; next; - } - if (/^OUTPUT\s*$/) { - $mode = 'Output'; $current = \$junk; next; - } - if (/^TYPEMAP\s*$/) { - $mode = 'Typemap'; $current = \$junk; next; - } - if ($mode eq 'Typemap') { - chomp; - my $line = $_ ; - TrimWhitespace($_) ; - # skip blank lines and comment lines - next if /^$/ or /^#/ ; - my($type,$kind, $proto) = /^\s*(.*?\S)\s+(\S+)\s*($proto_re*)\s*$/ or - warn("Warning: File '$typemap' Line $. '$line' TYPEMAP entry needs 2 or 3 columns\n"), next; - $type = TidyType($type) ; - $type_kind{$type} = $kind ; - # prototype defaults to '$' - $proto = "\$" unless $proto ; - warn("Warning: File '$typemap' Line $. '$line' Invalid prototype '$proto'\n") - unless ValidProtoString($proto) ; - $proto_letter{$type} = C_string($proto) ; - } elsif (/^\s/) { - $$current .= $_; - } elsif ($mode eq 'Input') { - s/\s+$//; - $input_expr{$_} = ''; - $current = \$input_expr{$_}; - } else { - s/\s+$//; - $output_expr{$_} = ''; - $current = \$output_expr{$_}; - } - } - close(TYPEMAP); - } - - foreach my $value (values %input_expr) { - $value =~ s/;*\s+\z//; - # Move C pre-processor instructions to column 1 to be strictly ANSI - # conformant. Some pre-processors are fussy about this. - $value =~ s/^\s+#/#/mg; - } - foreach my $value (values %output_expr) { - # And again. - $value =~ s/^\s+#/#/mg; + else { + select $args{output}; } - my ($cast, $size); - our $bal = qr[(?:(?>[^()]+)|\((??{ $bal })\))*]; # ()-balanced - $cast = qr[(?:\(\s*SV\s*\*\s*\)\s*)?]; # Optional (SV*) cast - $size = qr[,\s* (??{ $bal }) ]x; # Third arg (to setpvn) - - foreach my $key (keys %output_expr) { - # We can still bootstrap compile 're', because in code re.pm is - # available to miniperl, and does not attempt to load the XS code. - use re 'eval'; - - my ($t, $with_size, $arg, $sarg) = - ($output_expr{$key} =~ - m[^ \s+ sv_set ( [iunp] ) v (n)? # Type, is_setpvn - \s* \( \s* $cast \$arg \s* , - \s* ( (??{ $bal }) ) # Set from - ( (??{ $size }) )? # Possible sizeof set-from - \) \s* ; \s* $ - ]x); - $targetable{$key} = [$t, $with_size, $arg, $sarg] if $t; - } + $self->{typemap} = process_typemaps( $args{typemap}, $pwd ); - my $END = "!End!\n\n"; # "impossible" keyword (multiple newline) + my $END = "!End!\n\n"; # "impossible" keyword (multiple newline) # Match an XS keyword - $BLOCK_re= '\s*(' . join('|', qw( - REQUIRE BOOT CASE PREINIT INPUT INIT CODE PPCODE - OUTPUT CLEANUP ALIAS ATTRS PROTOTYPES PROTOTYPE - VERSIONCHECK INCLUDE INCLUDE_COMMAND SCOPE INTERFACE - INTERFACE_MACRO C_ARGS POSTCALL OVERLOAD FALLBACK - )) . "|$END)\\s*:"; - - + $self->{BLOCK_re} = '\s*(' . + join('|' => @ExtUtils::ParseXS::Constants::XSKeywords) . + "|$END)\\s*:"; + our ($C_group_rex, $C_arg); # Group in C (no support for comments or literals) $C_group_rex = qr/ [({\[] - (?: (?> [^()\[\]{}]+ ) | (??{ $C_group_rex }) )* - [)}\]] /x ; + (?: (?> [^()\[\]{}]+ ) | (??{ $C_group_rex }) )* + [)}\]] /x; # Chunk in C without comma at toplevel (no comments): $C_arg = qr/ (?: (?> [^()\[\]{},"']+ ) - | (??{ $C_group_rex }) - | " (?: (?> [^\\"]+ ) - | \\. - )* " # String literal - | ' (?: (?> [^\\']+ ) | \\. )* ' # Char literal - )* /xs; - + | (??{ $C_group_rex }) + | " (?: (?> [^\\"]+ ) + | \\. + )* " # String literal + | ' (?: (?> [^\\']+ ) | \\. )* ' # Char literal + )* /xs; + + # Since at this point we're ready to begin printing to the output file and + # reading from the input file, I want to get as much data as possible into + # the proto-object $self. That means assigning to $self and elements of + # %args referenced below this point. + # HOWEVER: This resulted in an error when I tried: + # $args{'s'} ---> $self->{s}. + # Use of uninitialized value in quotemeta at + # .../blib/lib/ExtUtils/ParseXS.pm line 733 + + foreach my $datum ( qw| argtypes except inout optimize | ) { + $self->{$datum} = $args{$datum}; + } + # Identify the version of xsubpp used - print <<EOM ; + print <<EOM; /* * This file was generated automatically by ExtUtils::ParseXS version $VERSION from the - * contents of $filename. Do not edit this file, edit $filename instead. + * contents of $self->{filename}. Do not edit this file, edit $self->{filename} instead. * - * ANY CHANGES MADE HERE WILL BE LOST! + * ANY CHANGES MADE HERE WILL BE LOST! * */ EOM - print("#line 1 \"$filepathname\"\n") - if $WantLineNumbers; + print("#line 1 \"" . escape_file_for_line_directive($self->{filepathname}) . "\"\n") + if $self->{WantLineNumbers}; + + # Open the input file (using $self->{filename} which + # is a basename'd $args{filename} due to chdir above) + open($self->{FH}, '<', $self->{filename}) or die "cannot open $self->{filename}: $!\n"; firstmodule: - while (<$FH>) { + while (readline($self->{FH})) { if (/^=/) { my $podstartline = $.; do { - if (/^=cut\s*$/) { - # We can't just write out a /* */ comment, as our embedded - # POD might itself be in a comment. We can't put a /**/ - # comment inside #if 0, as the C standard says that the source - # file is decomposed into preprocessing characters in the stage - # before preprocessing commands are executed. - # I don't want to leave the text as barewords, because the spec - # isn't clear whether macros are expanded before or after - # preprocessing commands are executed, and someone pathological - # may just have defined one of the 3 words as a macro that does - # something strange. Multiline strings are illegal in C, so - # the "" we write must be a string literal. And they aren't - # concatenated until 2 steps later, so we are safe. - # - Nicholas Clark - print("#if 0\n \"Skipped embedded POD.\"\n#endif\n"); - printf("#line %d \"$filepathname\"\n", $. + 1) - if $WantLineNumbers; - next firstmodule - } - - } while (<$FH>); + if (/^=cut\s*$/) { + # We can't just write out a /* */ comment, as our embedded + # POD might itself be in a comment. We can't put a /**/ + # comment inside #if 0, as the C standard says that the source + # file is decomposed into preprocessing characters in the stage + # before preprocessing commands are executed. + # I don't want to leave the text as barewords, because the spec + # isn't clear whether macros are expanded before or after + # preprocessing commands are executed, and someone pathological + # may just have defined one of the 3 words as a macro that does + # something strange. Multiline strings are illegal in C, so + # the "" we write must be a string literal. And they aren't + # concatenated until 2 steps later, so we are safe. + # - Nicholas Clark + print("#if 0\n \"Skipped embedded POD.\"\n#endif\n"); + printf("#line %d \"%s\"\n", $. + 1, escape_file_for_line_directive($self->{filepathname})) + if $self->{WantLineNumbers}; + next firstmodule + } + + } while (readline($self->{FH})); # At this point $. is at end of file so die won't state the start # of the problem, and as we haven't yet read any lines &death won't # show the correct line in the message either. - die ("Error: Unterminated pod in $filename, line $podstartline\n") - unless $lastline; + die ("Error: Unterminated pod in $self->{filename}, line $podstartline\n") + unless $self->{lastline}; } - last if ($Package, $Prefix) = + last if ($Package, $self->{Prefix}) = /^MODULE\s*=\s*[\w:]+(?:\s+PACKAGE\s*=\s*([\w:]+))?(?:\s+PREFIX\s*=\s*(\S+))?\s*$/; - + print $_; } unless (defined $_) { @@ -309,313 +244,259 @@ EOM exit 0; # Not a fatal error for the caller process } - print 'ExtUtils::ParseXS::CountLines'->end_marker, "\n" if $WantLineNumbers; - - print <<"EOF"; -#ifndef PERL_UNUSED_VAR -# define PERL_UNUSED_VAR(var) if (0) var = var -#endif - -EOF - - print <<"EOF"; -#ifndef PERL_ARGS_ASSERT_CROAK_XS_USAGE -#define PERL_ARGS_ASSERT_CROAK_XS_USAGE assert(cv); assert(params) - -/* prototype to pass -Wmissing-prototypes */ -STATIC void -S_croak_xs_usage(pTHX_ const CV *const cv, const char *const params); - -STATIC void -S_croak_xs_usage(pTHX_ const CV *const cv, const char *const params) -{ - const GV *const gv = CvGV(cv); - - PERL_ARGS_ASSERT_CROAK_XS_USAGE; - - if (gv) { - const char *const gvname = GvNAME(gv); - const HV *const stash = GvSTASH(gv); - const char *const hvname = stash ? HvNAME(stash) : NULL; - - if (hvname) - Perl_croak(aTHX_ "Usage: %s::%s(%s)", hvname, gvname, params); - else - Perl_croak(aTHX_ "Usage: %s(%s)", gvname, params); - } else { - /* Pants. I don't think that it should be possible to get here. */ - Perl_croak(aTHX_ "Usage: CODE(0x%"UVxf")(%s)", PTR2UV(cv), params); - } -} -#undef PERL_ARGS_ASSERT_CROAK_XS_USAGE - -#ifdef PERL_IMPLICIT_CONTEXT -#define croak_xs_usage(a,b) S_croak_xs_usage(aTHX_ a,b) -#else -#define croak_xs_usage S_croak_xs_usage -#endif - -#endif - -/* NOTE: the prototype of newXSproto() is different in versions of perls, - * so we define a portable version of newXSproto() - */ -#ifdef newXS_flags -#define newXSproto_portable(name, c_impl, file, proto) newXS_flags(name, c_impl, file, proto, 0) -#else -#define newXSproto_portable(name, c_impl, file, proto) (PL_Sv=(SV*)newXS(name, c_impl, file), sv_setpv(PL_Sv, proto), (CV*)PL_Sv) -#endif /* !defined(newXS_flags) */ + print 'ExtUtils::ParseXS::CountLines'->end_marker, "\n" if $self->{WantLineNumbers}; -EOF + standard_XS_defs(); - print 'ExtUtils::ParseXS::CountLines'->end_marker, "\n" if $WantLineNumbers; + print 'ExtUtils::ParseXS::CountLines'->end_marker, "\n" if $self->{WantLineNumbers}; - $lastline = $_; - $lastline_no = $.; + $self->{lastline} = $_; + $self->{lastline_no} = $.; + my $BootCode_ref = []; + my $XSS_work_idx = 0; + my $cpp_next_tmp = 'XSubPPtmpAAAA'; PARAGRAPH: - while (fetch_para()) { + while ($self->fetch_para()) { + my $outlist_ref = []; # Print initial preprocessor statements and blank lines - while (@line && $line[0] !~ /^[^\#]/) { - my $line = shift(@line); - print $line, "\n"; - next unless $line =~ /^\#\s*((if)(?:n?def)?|elsif|else|endif)\b/; + while (@{ $self->{line} } && $self->{line}->[0] !~ /^[^\#]/) { + my $ln = shift(@{ $self->{line} }); + print $ln, "\n"; + next unless $ln =~ /^\#\s*((if)(?:n?def)?|elsif|else|endif)\b/; my $statement = $+; - if ($statement eq 'if') { - $XSS_work_idx = @XSStack; - push(@XSStack, {type => 'if'}); - } else { - death ("Error: `$statement' with no matching `if'") - if $XSStack[-1]{type} ne 'if'; - if ($XSStack[-1]{varname}) { - push(@InitFileCode, "#endif\n"); - push(@BootCode, "#endif"); - } - - my(@fns) = keys %{$XSStack[-1]{functions}}; - if ($statement ne 'endif') { - # Hide the functions defined in other #if branches, and reset. - @{$XSStack[-1]{other_functions}}{@fns} = (1) x @fns; - @{$XSStack[-1]}{qw(varname functions)} = ('', {}); - } else { - my($tmp) = pop(@XSStack); - 0 while (--$XSS_work_idx - && $XSStack[$XSS_work_idx]{type} ne 'if'); - # Keep all new defined functions - push(@fns, keys %{$tmp->{other_functions}}); - @{$XSStack[$XSS_work_idx]{functions}}{@fns} = (1) x @fns; - } - } + ( $self, $XSS_work_idx, $BootCode_ref ) = + analyze_preprocessor_statements( + $self, $statement, $XSS_work_idx, $BootCode_ref + ); } - - next PARAGRAPH unless @line; - - if ($XSS_work_idx && !$XSStack[$XSS_work_idx]{varname}) { + + next PARAGRAPH unless @{ $self->{line} }; + + if ($XSS_work_idx && !$self->{XSStack}->[$XSS_work_idx]{varname}) { # We are inside an #if, but have not yet #defined its xsubpp variable. print "#define $cpp_next_tmp 1\n\n"; - push(@InitFileCode, "#if $cpp_next_tmp\n"); - push(@BootCode, "#if $cpp_next_tmp"); - $XSStack[$XSS_work_idx]{varname} = $cpp_next_tmp++; + push(@{ $self->{InitFileCode} }, "#if $cpp_next_tmp\n"); + push(@{ $BootCode_ref }, "#if $cpp_next_tmp"); + $self->{XSStack}->[$XSS_work_idx]{varname} = $cpp_next_tmp++; } - death ("Code is not inside a function" - ." (maybe last function was ended by a blank line " - ." followed by a statement on column one?)") - if $line[0] =~ /^\s/; - - my ($class, $externC, $static, $ellipsis, $wantRETVAL, $RETVAL_no_return); - my (@fake_INPUT_pre); # For length(s) generated variables - my (@fake_INPUT); - + $self->death( + "Code is not inside a function" + ." (maybe last function was ended by a blank line " + ." followed by a statement on column one?)") + if $self->{line}->[0] =~ /^\s/; + # initialize info arrays - undef(%args_match); - undef(%var_types); - undef(%defaults); - undef(%arg_list) ; - undef(@proto_arg) ; - undef($processing_arg_with_types) ; - undef(%argtype_seen) ; - undef(@outlist) ; - undef(%in_out) ; - undef(%lengthof) ; - undef($proto_in_this_xsub) ; - undef($scope_in_this_xsub) ; - undef($interface); - undef($prepush_done); - $interface_macro = 'XSINTERFACE_FUNC' ; - $interface_macro_set = 'XSINTERFACE_FUNC_SET' ; - $ProtoThisXSUB = $WantPrototypes ; - $ScopeThisXSUB = 0; - $xsreturn = 0; - - $_ = shift(@line); - while (my $kwd = check_keyword("REQUIRE|PROTOTYPES|FALLBACK|VERSIONCHECK|INCLUDE(?:_COMMAND)?|SCOPE")) { - &{"${kwd}_handler"}() ; - next PARAGRAPH unless @line ; - $_ = shift(@line); + foreach my $member (qw(args_match var_types defaults arg_list + argtype_seen in_out lengthof)) + { + $self->{$member} = {}; } - - if (check_keyword("BOOT")) { - &check_cpp; - push (@BootCode, "#line $line_no[@line_no - @line] \"$filepathname\"") - if $WantLineNumbers && $line[0] !~ /^\s*#\s*line\b/; - push (@BootCode, @line, "") ; - next PARAGRAPH ; + $self->{proto_arg} = []; + $self->{processing_arg_with_types} = undef; + $self->{proto_in_this_xsub} = undef; + $self->{scope_in_this_xsub} = undef; + $self->{interface} = undef; + $self->{interface_macro} = 'XSINTERFACE_FUNC'; + $self->{interface_macro_set} = 'XSINTERFACE_FUNC_SET'; + $self->{ProtoThisXSUB} = $self->{WantPrototypes}; + $self->{ScopeThisXSUB} = 0; + + my $xsreturn = 0; + + $_ = shift(@{ $self->{line} }); + while (my $kwd = $self->check_keyword("REQUIRE|PROTOTYPES|EXPORT_XSUB_SYMBOLS|FALLBACK|VERSIONCHECK|INCLUDE(?:_COMMAND)?|SCOPE")) { + my $method = $kwd . "_handler"; + $self->$method($_); + next PARAGRAPH unless @{ $self->{line} }; + $_ = shift(@{ $self->{line} }); } + if ($self->check_keyword("BOOT")) { + check_conditional_preprocessor_statements($self); + push (@{ $BootCode_ref }, "#line $self->{line_no}->[@{ $self->{line_no} } - @{ $self->{line} }] \"" + . escape_file_for_line_directive($self->{filepathname}) . "\"") + if $self->{WantLineNumbers} && $self->{line}->[0] !~ /^\s*#\s*line\b/; + push (@{ $BootCode_ref }, @{ $self->{line} }, ""); + next PARAGRAPH; + } # extract return type, function name and arguments - ($ret_type) = TidyType($_); - $RETVAL_no_return = 1 if $ret_type =~ s/^NO_OUTPUT\s+//; + ($self->{ret_type}) = tidy_type($_); + my $RETVAL_no_return = 1 if $self->{ret_type} =~ s/^NO_OUTPUT\s+//; # Allow one-line ANSI-like declaration - unshift @line, $2 - if $process_argtypes - and $ret_type =~ s/^(.*?\w.*?)\s*\b(\w+\s*\(.*)/$1/s; + unshift @{ $self->{line} }, $2 + if $self->{argtypes} + and $self->{ret_type} =~ s/^(.*?\w.*?)\s*\b(\w+\s*\(.*)/$1/s; # a function definition needs at least 2 lines - blurt ("Error: Function definition too short '$ret_type'"), next PARAGRAPH - unless @line ; + $self->blurt("Error: Function definition too short '$self->{ret_type}'"), next PARAGRAPH + unless @{ $self->{line} }; - $externC = 1 if $ret_type =~ s/^extern "C"\s+//; - $static = 1 if $ret_type =~ s/^static\s+//; + my $externC = 1 if $self->{ret_type} =~ s/^extern "C"\s+//; + my $static = 1 if $self->{ret_type} =~ s/^static\s+//; - $func_header = shift(@line); - blurt ("Error: Cannot parse function definition from '$func_header'"), next PARAGRAPH + my $func_header = shift(@{ $self->{line} }); + $self->blurt("Error: Cannot parse function definition from '$func_header'"), next PARAGRAPH unless $func_header =~ /^(?:([\w:]*)::)?(\w+)\s*\(\s*(.*?)\s*\)\s*(const)?\s*(;\s*)?$/s; - ($class, $func_name, $orig_args) = ($1, $2, $3) ; + my ($class, $orig_args); + ($class, $func_name, $orig_args) = ($1, $2, $3); $class = "$4 $class" if $4; - ($pname = $func_name) =~ s/^($Prefix)?/$Packprefix/; - ($clean_func_name = $func_name) =~ s/^$Prefix//; - $Full_func_name = "${Packid}_$clean_func_name"; + ($pname = $func_name) =~ s/^($self->{Prefix})?/$self->{Packprefix}/; + my $clean_func_name; + ($clean_func_name = $func_name) =~ s/^$self->{Prefix}//; + $Full_func_name = "$self->{Packid}_$clean_func_name"; if ($Is_VMS) { $Full_func_name = $SymSet->addsym($Full_func_name); } # Check for duplicate function definition - for my $tmp (@XSStack) { + for my $tmp (@{ $self->{XSStack} }) { next unless defined $tmp->{functions}{$Full_func_name}; - Warn("Warning: duplicate function definition '$clean_func_name' detected"); + Warn( $self, "Warning: duplicate function definition '$clean_func_name' detected"); last; } - $XSStack[$XSS_work_idx]{functions}{$Full_func_name} ++ ; - %XsubAliases = %XsubAliasValues = %Interfaces = @Attributes = (); - $DoSetMagic = 1; - - $orig_args =~ s/\\\s*/ /g; # process line continuations + $self->{XSStack}->[$XSS_work_idx]{functions}{$Full_func_name}++; + %{ $self->{XsubAliases} } = (); + %{ $self->{XsubAliasValues} } = (); + %{ $self->{Interfaces} } = (); + @{ $self->{Attributes} } = (); + $self->{DoSetMagic} = 1; + + $orig_args =~ s/\\\s*/ /g; # process line continuations my @args; - my %only_C_inlist; # Not in the signature of Perl function - if ($process_argtypes and $orig_args =~ /\S/) { + my (@fake_INPUT_pre); # For length(s) generated variables + my (@fake_INPUT); + my $only_C_inlist_ref = {}; # Not in the signature of Perl function + if ($self->{argtypes} and $orig_args =~ /\S/) { my $args = "$orig_args ,"; if ($args =~ /^( (??{ $C_arg }) , )* $ /x) { - @args = ($args =~ /\G ( (??{ $C_arg }) ) , /xg); - for ( @args ) { - s/^\s+//; - s/\s+$//; - my ($arg, $default) = / ( [^=]* ) ( (?: = .* )? ) /x; - my ($pre, $name) = ($arg =~ /(.*?) \s* - \b ( \w+ | length\( \s*\w+\s* \) ) - \s* $ /x); - next unless defined($pre) && length($pre); - my $out_type = ''; - my $inout_var; - if ($process_inout and s/^(IN|IN_OUTLIST|OUTLIST|OUT|IN_OUT)\b\s*//) { - my $type = $1; - $out_type = $type if $type ne 'IN'; - $arg =~ s/^(IN|IN_OUTLIST|OUTLIST|OUT|IN_OUT)\b\s*//; - $pre =~ s/^(IN|IN_OUTLIST|OUTLIST|OUT|IN_OUT)\b\s*//; - } - my $islength; - if ($name =~ /^length\( \s* (\w+) \s* \)\z/x) { - $name = "XSauto_length_of_$1"; - $islength = 1; - die "Default value on length() argument: `$_'" - if length $default; - } - if (length $pre or $islength) { # Has a type - if ($islength) { - push @fake_INPUT_pre, $arg; - } else { - push @fake_INPUT, $arg; - } - # warn "pushing '$arg'\n"; - $argtype_seen{$name}++; - $_ = "$name$default"; # Assigns to @args - } - $only_C_inlist{$_} = 1 if $out_type eq "OUTLIST" or $islength; - push @outlist, $name if $out_type =~ /OUTLIST$/; - $in_out{$name} = $out_type if $out_type; - } - } else { - @args = split(/\s*,\s*/, $orig_args); - Warn("Warning: cannot parse argument list '$orig_args', fallback to split"); + @args = ($args =~ /\G ( (??{ $C_arg }) ) , /xg); + for ( @args ) { + s/^\s+//; + s/\s+$//; + my ($arg, $default) = ($_ =~ m/ ( [^=]* ) ( (?: = .* )? ) /x); + my ($pre, $len_name) = ($arg =~ /(.*?) \s* + \b ( \w+ | length\( \s*\w+\s* \) ) + \s* $ /x); + next unless defined($pre) && length($pre); + my $out_type = ''; + my $inout_var; + if ($self->{inout} and s/^(IN|IN_OUTLIST|OUTLIST|OUT|IN_OUT)\b\s*//) { + my $type = $1; + $out_type = $type if $type ne 'IN'; + $arg =~ s/^(IN|IN_OUTLIST|OUTLIST|OUT|IN_OUT)\b\s*//; + $pre =~ s/^(IN|IN_OUTLIST|OUTLIST|OUT|IN_OUT)\b\s*//; + } + my $islength; + if ($len_name =~ /^length\( \s* (\w+) \s* \)\z/x) { + $len_name = "XSauto_length_of_$1"; + $islength = 1; + die "Default value on length() argument: '$_'" + if length $default; + } + if (length $pre or $islength) { # Has a type + if ($islength) { + push @fake_INPUT_pre, $arg; + } + else { + push @fake_INPUT, $arg; + } + # warn "pushing '$arg'\n"; + $self->{argtype_seen}->{$len_name}++; + $_ = "$len_name$default"; # Assigns to @args + } + $only_C_inlist_ref->{$_} = 1 if $out_type eq "OUTLIST" or $islength; + push @{ $outlist_ref }, $len_name if $out_type =~ /OUTLIST$/; + $self->{in_out}->{$len_name} = $out_type if $out_type; + } + } + else { + @args = split(/\s*,\s*/, $orig_args); + Warn( $self, "Warning: cannot parse argument list '$orig_args', fallback to split"); } - } else { + } + else { @args = split(/\s*,\s*/, $orig_args); for (@args) { - if ($process_inout and s/^(IN|IN_OUTLIST|OUTLIST|IN_OUT|OUT)\b\s*//) { - my $out_type = $1; - next if $out_type eq 'IN'; - $only_C_inlist{$_} = 1 if $out_type eq "OUTLIST"; - push @outlist, $name if $out_type =~ /OUTLIST$/; - $in_out{$_} = $out_type; - } + if ($self->{inout} and s/^(IN|IN_OUTLIST|OUTLIST|IN_OUT|OUT)\b\s*//) { + my $out_type = $1; + next if $out_type eq 'IN'; + $only_C_inlist_ref->{$_} = 1 if $out_type eq "OUTLIST"; + if ($out_type =~ /OUTLIST$/) { + push @{ $outlist_ref }, undef; + } + $self->{in_out}->{$_} = $out_type; + } } } if (defined($class)) { my $arg0 = ((defined($static) or $func_name eq 'new') - ? "CLASS" : "THIS"); + ? "CLASS" : "THIS"); unshift(@args, $arg0); } my $extra_args = 0; - @args_num = (); - $num_args = 0; + my @args_num = (); + my $num_args = 0; my $report_args = ''; + my $ellipsis; foreach my $i (0 .. $#args) { if ($args[$i] =~ s/\.\.\.//) { - $ellipsis = 1; - if ($args[$i] eq '' && $i == $#args) { - $report_args .= ", ..."; - pop(@args); - last; - } + $ellipsis = 1; + if ($args[$i] eq '' && $i == $#args) { + $report_args .= ", ..."; + pop(@args); + last; + } + } + if ($only_C_inlist_ref->{$args[$i]}) { + push @args_num, undef; } - if ($only_C_inlist{$args[$i]}) { - push @args_num, undef; - } else { - push @args_num, ++$num_args; - $report_args .= ", $args[$i]"; + else { + push @args_num, ++$num_args; + $report_args .= ", $args[$i]"; } if ($args[$i] =~ /^([^=]*[^\s=])\s*=\s*(.*)/s) { - $extra_args++; - $args[$i] = $1; - $defaults{$args[$i]} = $2; - $defaults{$args[$i]} =~ s/"/\\"/g; + $extra_args++; + $args[$i] = $1; + $self->{defaults}->{$args[$i]} = $2; + $self->{defaults}->{$args[$i]} =~ s/"/\\"/g; } - $proto_arg[$i+1] = '$' ; + $self->{proto_arg}->[$i+1] = '$'; } - $min_args = $num_args - $extra_args; + my $min_args = $num_args - $extra_args; $report_args =~ s/"/\\"/g; $report_args =~ s/^,\s+//; - my @func_args = @args; - shift @func_args if defined($class); - - for (@func_args) { - s/^/&/ if $in_out{$_}; - } - $func_args = join(", ", @func_args); - @args_match{@args} = @args_num; + $self->{func_args} = assign_func_args($self, \@args, $class); + @{ $self->{args_match} }{@args} = @args_num; - $PPCODE = grep(/^\s*PPCODE\s*:/, @line); - $CODE = grep(/^\s*CODE\s*:/, @line); + my $PPCODE = grep(/^\s*PPCODE\s*:/, @{ $self->{line} }); + my $CODE = grep(/^\s*CODE\s*:/, @{ $self->{line} }); # Detect CODE: blocks which use ST(n)= or XST_m*(n,v) - # to set explicit return values. - $EXPLICIT_RETURN = ($CODE && - ("@line" =~ /(\bST\s*\([^;]*=) | (\bXST_m\w+\s*\()/x )); - $ALIAS = grep(/^\s*ALIAS\s*:/, @line); - $INTERFACE = grep(/^\s*INTERFACE\s*:/, @line); + # to set explicit return values. + my $EXPLICIT_RETURN = ($CODE && + ("@{ $self->{line} }" =~ /(\bST\s*\([^;]*=) | (\bXST_m\w+\s*\()/x )); + + # The $ALIAS which follows is only explicitly called within the scope of + # process_file(). In principle, it ought to be a lexical, i.e., 'my + # $ALIAS' like the other nearby variables. However, implementing that + # change produced a slight difference in the resulting .c output in at + # least two distributions: B/BD/BDFOY/Crypt-Rijndael and + # G/GF/GFUJI/Hash-FieldHash. The difference is, arguably, an improvement + # in the resulting C code. Example: + # 388c388 + # < GvNAME(CvGV(cv)), + # --- + # > "Crypt::Rijndael::encrypt", + # But at this point we're committed to generating the *same* C code that + # the current version of ParseXS.pm does. So we're declaring it as 'our'. + $ALIAS = grep(/^\s*ALIAS\s*:/, @{ $self->{line} }); + + my $INTERFACE = grep(/^\s*INTERFACE\s*:/, @{ $self->{line} }); $xsreturn = 1 if $EXPLICIT_RETURN; @@ -624,40 +505,32 @@ EOF # print function header print Q(<<"EOF"); #$externC -#XS(XS_${Full_func_name}); /* prototype to pass -Wmissing-prototypes */ -#XS(XS_${Full_func_name}) +#XS_EUPXS(XS_${Full_func_name}); /* prototype to pass -Wmissing-prototypes */ +#XS_EUPXS(XS_${Full_func_name}) #[[ -##ifdef dVAR # dVAR; dXSARGS; -##else -# dXSARGS; -##endif EOF - print Q(<<"EOF") if $ALIAS ; + print Q(<<"EOF") if $ALIAS; # dXSI32; EOF - print Q(<<"EOF") if $INTERFACE ; -# dXSFUNCTION($ret_type); + print Q(<<"EOF") if $INTERFACE; +# dXSFUNCTION($self->{ret_type}); EOF - if ($ellipsis) { - $cond = ($min_args ? qq(items < $min_args) : 0); - } elsif ($min_args == $num_args) { - $cond = qq(items != $min_args); - } else { - $cond = qq(items < $min_args || items > $num_args); - } - print Q(<<"EOF") if $except; + $self->{cond} = set_cond($ellipsis, $min_args, $num_args); + + print Q(<<"EOF") if $self->{except}; # char errbuf[1024]; -# *errbuf = '\0'; +# *errbuf = '\\0'; EOF - if($cond) { - print Q(<<"EOF"); -# if ($cond) + if($self->{cond}) { + print Q(<<"EOF"); +# if ($self->{cond}) # croak_xs_usage(cv, "$report_args"); EOF - } else { + } + else { # cv likely to be unused print Q(<<"EOF"); # PERL_UNUSED_VAR(cv); /* -W */ @@ -666,7 +539,7 @@ EOF #gcc -Wall: if an xsub has PPCODE is used #it is possible none of ST, XSRETURN or XSprePUSH macros are used - #hence `ax' (setup by dXSARGS) is unused + #hence 'ax' (setup by dXSARGS) is unused #XXX: could breakup the dXSARGS; into dSP;dMARK;dITEMS #but such a move could break third-party extensions print Q(<<"EOF") if $PPCODE; @@ -679,199 +552,258 @@ EOF # Now do a block of some sort. - $condnum = 0; - $cond = ''; # last CASE: conditional - push(@line, "$END:"); - push(@line_no, $line_no[-1]); + $self->{condnum} = 0; + $self->{cond} = ''; # last CASE: conditional + push(@{ $self->{line} }, "$END:"); + push(@{ $self->{line_no} }, $self->{line_no}->[-1]); $_ = ''; - &check_cpp; - while (@line) { - &CASE_handler if check_keyword("CASE"); + check_conditional_preprocessor_statements(); + while (@{ $self->{line} }) { + + $self->CASE_handler($_) if $self->check_keyword("CASE"); print Q(<<"EOF"); -# $except [[ +# $self->{except} [[ EOF # do initialization of input variables - $thisdone = 0; - $retvaldone = 0; - $deferred = ""; - %arg_list = () ; - $gotRETVAL = 0; - - INPUT_handler() ; - process_keyword("INPUT|PREINIT|INTERFACE_MACRO|C_ARGS|ALIAS|ATTRS|PROTOTYPE|SCOPE|OVERLOAD") ; - - print Q(<<"EOF") if $ScopeThisXSUB; + $self->{thisdone} = 0; + $self->{retvaldone} = 0; + $self->{deferred} = ""; + %{ $self->{arg_list} } = (); + $self->{gotRETVAL} = 0; + $self->INPUT_handler($_); + $self->process_keyword("INPUT|PREINIT|INTERFACE_MACRO|C_ARGS|ALIAS|ATTRS|PROTOTYPE|SCOPE|OVERLOAD"); + + print Q(<<"EOF") if $self->{ScopeThisXSUB}; # ENTER; # [[ EOF - - if (!$thisdone && defined($class)) { - if (defined($static) or $func_name eq 'new') { - print "\tchar *"; - $var_types{"CLASS"} = "char *"; - &generate_init("char *", 1, "CLASS"); - } - else { - print "\t$class *"; - $var_types{"THIS"} = "$class *"; - &generate_init("$class *", 1, "THIS"); - } + + if (!$self->{thisdone} && defined($class)) { + if (defined($static) or $func_name eq 'new') { + print "\tchar *"; + $self->{var_types}->{"CLASS"} = "char *"; + generate_init( { + type => "char *", + num => 1, + var => "CLASS", + printed_name => undef, + } ); + } + else { + print "\t$class *"; + $self->{var_types}->{"THIS"} = "$class *"; + generate_init( { + type => "$class *", + num => 1, + var => "THIS", + printed_name => undef, + } ); + } } - + + # These are set if OUTPUT is found and/or CODE using RETVAL + $self->{have_OUTPUT} = $self->{have_CODE_with_RETVAL} = 0; + + my ($wantRETVAL); # do code if (/^\s*NOT_IMPLEMENTED_YET/) { - print "\n\tPerl_croak(aTHX_ \"$pname: not implemented yet\");\n"; - $_ = '' ; - } else { - if ($ret_type ne "void") { - print "\t" . &map_type($ret_type, 'RETVAL') . ";\n" - if !$retvaldone; - $args_match{"RETVAL"} = 0; - $var_types{"RETVAL"} = $ret_type; - print "\tdXSTARG;\n" - if $WantOptimize and $targetable{$type_kind{$ret_type}}; - } - - if (@fake_INPUT or @fake_INPUT_pre) { - unshift @line, @fake_INPUT_pre, @fake_INPUT, $_; - $_ = ""; - $processing_arg_with_types = 1; - INPUT_handler() ; - } - print $deferred; - - process_keyword("INIT|ALIAS|ATTRS|PROTOTYPE|INTERFACE_MACRO|INTERFACE|C_ARGS|OVERLOAD") ; - - if (check_keyword("PPCODE")) { - print_section(); - death ("PPCODE must be last thing") if @line; - print "\tLEAVE;\n" if $ScopeThisXSUB; - print "\tPUTBACK;\n\treturn;\n"; - } elsif (check_keyword("CODE")) { - print_section() ; - } elsif (defined($class) and $func_name eq "DESTROY") { - print "\n\t"; - print "delete THIS;\n"; - } else { - print "\n\t"; - if ($ret_type ne "void") { - print "RETVAL = "; - $wantRETVAL = 1; - } - if (defined($static)) { - if ($func_name eq 'new') { - $func_name = "$class"; - } else { - print "${class}::"; - } - } elsif (defined($class)) { - if ($func_name eq 'new') { - $func_name .= " $class"; - } else { - print "THIS->"; - } - } - $func_name =~ s/^\Q$args{'s'}// - if exists $args{'s'}; - $func_name = 'XSFUNCTION' if $interface; - print "$func_name($func_args);\n"; - } + print "\n\tPerl_croak(aTHX_ \"$pname: not implemented yet\");\n"; + $_ = ''; } - + else { + if ($self->{ret_type} ne "void") { + print "\t" . map_type($self, $self->{ret_type}, 'RETVAL') . ";\n" + if !$self->{retvaldone}; + $self->{args_match}->{"RETVAL"} = 0; + $self->{var_types}->{"RETVAL"} = $self->{ret_type}; + my $outputmap = $self->{typemap}->get_outputmap( ctype => $self->{ret_type} ); + print "\tdXSTARG;\n" + if $self->{optimize} and $outputmap and $outputmap->targetable; + } + + if (@fake_INPUT or @fake_INPUT_pre) { + unshift @{ $self->{line} }, @fake_INPUT_pre, @fake_INPUT, $_; + $_ = ""; + $self->{processing_arg_with_types} = 1; + $self->INPUT_handler($_); + } + print $self->{deferred}; + + $self->process_keyword("INIT|ALIAS|ATTRS|PROTOTYPE|INTERFACE_MACRO|INTERFACE|C_ARGS|OVERLOAD"); + + if ($self->check_keyword("PPCODE")) { + $self->print_section(); + $self->death("PPCODE must be last thing") if @{ $self->{line} }; + print "\tLEAVE;\n" if $self->{ScopeThisXSUB}; + print "\tPUTBACK;\n\treturn;\n"; + } + elsif ($self->check_keyword("CODE")) { + my $consumed_code = $self->print_section(); + if ($consumed_code =~ /\bRETVAL\b/) { + $self->{have_CODE_with_RETVAL} = 1; + } + } + elsif (defined($class) and $func_name eq "DESTROY") { + print "\n\t"; + print "delete THIS;\n"; + } + else { + print "\n\t"; + if ($self->{ret_type} ne "void") { + print "RETVAL = "; + $wantRETVAL = 1; + } + if (defined($static)) { + if ($func_name eq 'new') { + $func_name = "$class"; + } + else { + print "${class}::"; + } + } + elsif (defined($class)) { + if ($func_name eq 'new') { + $func_name .= " $class"; + } + else { + print "THIS->"; + } + } + $func_name =~ s/^\Q$args{'s'}// + if exists $args{'s'}; + $func_name = 'XSFUNCTION' if $self->{interface}; + print "$func_name($self->{func_args});\n"; + } + } + # do output variables - $gotRETVAL = 0; # 1 if RETVAL seen in OUTPUT section; - undef $RETVAL_code ; # code to set RETVAL (from OUTPUT section); + $self->{gotRETVAL} = 0; # 1 if RETVAL seen in OUTPUT section; + undef $self->{RETVAL_code} ; # code to set RETVAL (from OUTPUT section); # $wantRETVAL set if 'RETVAL =' autogenerated - ($wantRETVAL, $ret_type) = (0, 'void') if $RETVAL_no_return; - undef %outargs ; - process_keyword("POSTCALL|OUTPUT|ALIAS|ATTRS|PROTOTYPE|OVERLOAD"); - - &generate_output($var_types{$_}, $args_match{$_}, $_, $DoSetMagic) - for grep $in_out{$_} =~ /OUT$/, keys %in_out; - + ($wantRETVAL, $self->{ret_type}) = (0, 'void') if $RETVAL_no_return; + undef %{ $self->{outargs} }; + + $self->process_keyword("POSTCALL|OUTPUT|ALIAS|ATTRS|PROTOTYPE|OVERLOAD"); + + # A CODE section with RETVAL, but no OUTPUT? FAIL! + if ($self->{have_CODE_with_RETVAL} and not $self->{have_OUTPUT} and $self->{ret_type} ne 'void') { + $self->Warn("Warning: Found a 'CODE' section which seems to be using 'RETVAL' but no 'OUTPUT' section."); + } + + generate_output( { + type => $self->{var_types}->{$_}, + num => $self->{args_match}->{$_}, + var => $_, + do_setmagic => $self->{DoSetMagic}, + do_push => undef, + } ) for grep $self->{in_out}->{$_} =~ /OUT$/, keys %{ $self->{in_out} }; + + my $prepush_done; # all OUTPUT done, so now push the return value on the stack - if ($gotRETVAL && $RETVAL_code) { - print "\t$RETVAL_code\n"; - } elsif ($gotRETVAL || $wantRETVAL) { - my $t = $WantOptimize && $targetable{$type_kind{$ret_type}}; - my $var = 'RETVAL'; - my $type = $ret_type; - - # 0: type, 1: with_size, 2: how, 3: how_size - if ($t and not $t->[1] and $t->[0] eq 'p') { - # PUSHp corresponds to setpvn. Treat setpv directly - my $what = eval qq("$t->[2]"); - warn $@ if $@; - - print "\tsv_setpv(TARG, $what); XSprePUSH; PUSHTARG;\n"; - $prepush_done = 1; - } - elsif ($t) { - my $what = eval qq("$t->[2]"); - warn $@ if $@; - - my $size = $t->[3]; - $size = '' unless defined $size; - $size = eval qq("$size"); - warn $@ if $@; - print "\tXSprePUSH; PUSH$t->[0]($what$size);\n"; - $prepush_done = 1; - } - else { - # RETVAL almost never needs SvSETMAGIC() - &generate_output($ret_type, 0, 'RETVAL', 0); - } + if ($self->{gotRETVAL} && $self->{RETVAL_code}) { + print "\t$self->{RETVAL_code}\n"; + } + elsif ($self->{gotRETVAL} || $wantRETVAL) { + my $outputmap = $self->{typemap}->get_outputmap( ctype => $self->{ret_type} ); + my $t = $self->{optimize} && $outputmap && $outputmap->targetable; + # Although the '$var' declared in the next line is never explicitly + # used within this 'elsif' block, commenting it out leads to + # disaster, starting with the first 'eval qq' inside the 'elsif' block + # below. + # It appears that this is related to the fact that at this point the + # value of $t is a reference to an array whose [2] element includes + # '$var' as a substring: + # <i> <> <(IV)$var> + my $var = 'RETVAL'; + my $type = $self->{ret_type}; + + if ($t and not $t->{with_size} and $t->{type} eq 'p') { + # PUSHp corresponds to setpvn. Treat setpv directly + my $what = eval qq("$t->{what}"); + warn $@ if $@; + + print "\tsv_setpv(TARG, $what); XSprePUSH; PUSHTARG;\n"; + $prepush_done = 1; + } + elsif ($t) { + my $what = eval qq("$t->{what}"); + warn $@ if $@; + + my $tsize = $t->{what_size}; + $tsize = '' unless defined $tsize; + $tsize = eval qq("$tsize"); + warn $@ if $@; + print "\tXSprePUSH; PUSH$t->{type}($what$tsize);\n"; + $prepush_done = 1; + } + else { + # RETVAL almost never needs SvSETMAGIC() + generate_output( { + type => $self->{ret_type}, + num => 0, + var => 'RETVAL', + do_setmagic => 0, + do_push => undef, + } ); + } } - - $xsreturn = 1 if $ret_type ne "void"; + + $xsreturn = 1 if $self->{ret_type} ne "void"; my $num = $xsreturn; - my $c = @outlist; + my $c = @{ $outlist_ref }; print "\tXSprePUSH;" if $c and not $prepush_done; print "\tEXTEND(SP,$c);\n" if $c; $xsreturn += $c; - generate_output($var_types{$_}, $num++, $_, 0, 1) for @outlist; - + generate_output( { + type => $self->{var_types}->{$_}, + num => $num++, + var => $_, + do_setmagic => 0, + do_push => 1, + } ) for @{ $outlist_ref }; + # do cleanup - process_keyword("CLEANUP|ALIAS|ATTRS|PROTOTYPE|OVERLOAD") ; - - print Q(<<"EOF") if $ScopeThisXSUB; + $self->process_keyword("CLEANUP|ALIAS|ATTRS|PROTOTYPE|OVERLOAD"); + + print Q(<<"EOF") if $self->{ScopeThisXSUB}; # ]] EOF - print Q(<<"EOF") if $ScopeThisXSUB and not $PPCODE; + print Q(<<"EOF") if $self->{ScopeThisXSUB} and not $PPCODE; # LEAVE; EOF - + # print function trailer print Q(<<"EOF"); # ]] EOF - print Q(<<"EOF") if $except; + print Q(<<"EOF") if $self->{except}; # BEGHANDLERS # CATCHALL -# sprintf(errbuf, "%s: %s\\tpropagated", Xname, Xreason); +# sprintf(errbuf, "%s: %s\\tpropagated", Xname, Xreason); # ENDHANDLERS EOF - if (check_keyword("CASE")) { - blurt ("Error: No `CASE:' at top of function") - unless $condnum; - $_ = "CASE: $_"; # Restore CASE: label - next; + if ($self->check_keyword("CASE")) { + $self->blurt("Error: No 'CASE:' at top of function") + unless $self->{condnum}; + $_ = "CASE: $_"; # Restore CASE: label + next; } last if $_ eq "$END:"; - death(/^$BLOCK_re/o ? "Misplaced `$1:'" : "Junk at end of function ($_)"); + $self->death(/^$self->{BLOCK_re}/o ? "Misplaced '$1:'" : "Junk at end of function ($_)"); } - - print Q(<<"EOF") if $except; + + print Q(<<"EOF") if $self->{except}; # if (errbuf[0]) -# Perl_croak(aTHX_ errbuf); +# Perl_croak(aTHX_ errbuf); EOF - + if ($xsreturn) { print Q(<<"EOF") unless $PPCODE; # XSRETURN($xsreturn); EOF - } else { + } + else { print Q(<<"EOF") unless $PPCODE; # XSRETURN_EMPTY; EOF @@ -882,85 +814,84 @@ EOF # EOF - our $newXS = "newXS" ; - our $proto = "" ; - + $self->{newXS} = "newXS"; + $self->{proto} = ""; + # Build the prototype string for the xsub - if ($ProtoThisXSUB) { - $newXS = "newXSproto_portable"; - - if ($ProtoThisXSUB eq 2) { - # User has specified empty prototype + if ($self->{ProtoThisXSUB}) { + $self->{newXS} = "newXSproto_portable"; + + if ($self->{ProtoThisXSUB} eq 2) { + # User has specified empty prototype } - elsif ($ProtoThisXSUB eq 1) { - my $s = ';'; - if ($min_args < $num_args) { - $s = ''; - $proto_arg[$min_args] .= ";" ; - } - push @proto_arg, "$s\@" - if $ellipsis ; - - $proto = join ("", grep defined, @proto_arg); + elsif ($self->{ProtoThisXSUB} eq 1) { + my $s = ';'; + if ($min_args < $num_args) { + $s = ''; + $self->{proto_arg}->[$min_args] .= ";"; + } + push @{ $self->{proto_arg} }, "$s\@" + if $ellipsis; + + $self->{proto} = join ("", grep defined, @{ $self->{proto_arg} } ); } else { - # User has specified a prototype - $proto = $ProtoThisXSUB; + # User has specified a prototype + $self->{proto} = $self->{ProtoThisXSUB}; } - $proto = qq{, "$proto"}; + $self->{proto} = qq{, "$self->{proto}"}; } - if (%XsubAliases) { - $XsubAliases{$pname} = 0 - unless defined $XsubAliases{$pname} ; - while ( ($name, $value) = each %XsubAliases) { - push(@InitFileCode, Q(<<"EOF")); -# cv = ${newXS}(\"$name\", XS_$Full_func_name, file$proto); -# XSANY.any_i32 = $value ; + if (%{ $self->{XsubAliases} }) { + $self->{XsubAliases}->{$pname} = 0 + unless defined $self->{XsubAliases}->{$pname}; + while ( my ($xname, $value) = each %{ $self->{XsubAliases} }) { + push(@{ $self->{InitFileCode} }, Q(<<"EOF")); +# cv = $self->{newXS}(\"$xname\", XS_$Full_func_name, file$self->{proto}); +# XSANY.any_i32 = $value; EOF } } - elsif (@Attributes) { - push(@InitFileCode, Q(<<"EOF")); -# cv = ${newXS}(\"$pname\", XS_$Full_func_name, file$proto); -# apply_attrs_string("$Package", cv, "@Attributes", 0); + elsif (@{ $self->{Attributes} }) { + push(@{ $self->{InitFileCode} }, Q(<<"EOF")); +# cv = $self->{newXS}(\"$pname\", XS_$Full_func_name, file$self->{proto}); +# apply_attrs_string("$Package", cv, "@{ $self->{Attributes} }", 0); EOF } - elsif ($interface) { - while ( ($name, $value) = each %Interfaces) { - $name = "$Package\::$name" unless $name =~ /::/; - push(@InitFileCode, Q(<<"EOF")); -# cv = ${newXS}(\"$name\", XS_$Full_func_name, file$proto); -# $interface_macro_set(cv,$value) ; + elsif ($self->{interface}) { + while ( my ($yname, $value) = each %{ $self->{Interfaces} }) { + $yname = "$Package\::$yname" unless $yname =~ /::/; + push(@{ $self->{InitFileCode} }, Q(<<"EOF")); +# cv = $self->{newXS}(\"$yname\", XS_$Full_func_name, file$self->{proto}); +# $self->{interface_macro_set}(cv,$value); EOF } } - elsif($newXS eq 'newXS'){ # work around P5NCI's empty newXS macro - push(@InitFileCode, - " ${newXS}(\"$pname\", XS_$Full_func_name, file$proto);\n"); + elsif($self->{newXS} eq 'newXS'){ # work around P5NCI's empty newXS macro + push(@{ $self->{InitFileCode} }, + " $self->{newXS}(\"$pname\", XS_$Full_func_name, file$self->{proto});\n"); } else { - push(@InitFileCode, - " (void)${newXS}(\"$pname\", XS_$Full_func_name, file$proto);\n"); + push(@{ $self->{InitFileCode} }, + " (void)$self->{newXS}(\"$pname\", XS_$Full_func_name, file$self->{proto});\n"); } - } + } # END 'PARAGRAPH' 'while' loop - if ($Overload) # make it findable with fetchmethod - { + if ($self->{Overload}) { # make it findable with fetchmethod print Q(<<"EOF"); -#XS(XS_${Packid}_nil); /* prototype to pass -Wmissing-prototypes */ -#XS(XS_${Packid}_nil) +#XS_EUPXS(XS_$self->{Packid}_nil); /* prototype to pass -Wmissing-prototypes */ +#XS_EUPXS(XS_$self->{Packid}_nil) #{ # dXSARGS; # XSRETURN_EMPTY; #} # EOF - unshift(@InitFileCode, <<"MAKE_FETCHMETHOD_WORK"); + unshift(@{ $self->{InitFileCode} }, <<"MAKE_FETCHMETHOD_WORK"); /* Making a sub named "${Package}::()" allows the package */ /* to be findable via fetchmethod(), and causes */ /* overload::Overloaded("${Package}") to return true. */ - (void)${newXS}("${Package}::()", XS_${Packid}_nil, file$proto); + (void)$self->{newXS}("${Package}::()", XS_$self->{Packid}_nil, file$self->{proto}); MAKE_FETCHMETHOD_WORK } @@ -973,24 +904,20 @@ MAKE_FETCHMETHOD_WORK EOF print Q(<<"EOF"); -#XS(boot_$Module_cname); /* prototype to pass -Wmissing-prototypes */ -#XS(boot_$Module_cname) +#XS_EXTERNAL(boot_$self->{Module_cname}); /* prototype to pass -Wmissing-prototypes */ +#XS_EXTERNAL(boot_$self->{Module_cname}) EOF print Q(<<"EOF"); #[[ -##ifdef dVAR # dVAR; dXSARGS; -##else -# dXSARGS; -##endif EOF #Under 5.8.x and lower, newXS is declared in proto.h as expecting a non-const #file name argument. If the wrong qualifier is used, it causes breakage with #C++ compilers and warnings with recent gcc. #-Wall: if there is no $Full_func_name there are no xsubs in this .xs - #so `file' is unused + #so 'file' is unused print Q(<<"EOF") if $Full_func_name; ##if (PERL_REVISION == 5 && PERL_VERSION < 9) # char* file = __FILE__; @@ -1009,18 +936,18 @@ EOF ##endif EOF - print Q(<<"EOF") if $WantVersionChk ; -# XS_VERSION_BOOTCHECK ; + print Q(<<"EOF") if $self->{WantVersionChk}; +# XS_VERSION_BOOTCHECK; # EOF - print Q(<<"EOF") if defined $XsubAliases or defined $Interfaces ; + print Q(<<"EOF") if defined $self->{xsubaliases} or defined $self->{interfaces}; # { -# CV * cv ; +# CV * cv; # EOF - print Q(<<"EOF") if ($Overload); + print Q(<<"EOF") if ($self->{Overload}); # /* register the overloading (type 'A') magic */ # PL_amagic_generation++; # /* The magic for overload gets a GV* via gv_fetchmeth as */ @@ -1028,22 +955,21 @@ EOF # /* the "fallback" status. */ # sv_setsv( # get_sv( "${Package}::()", TRUE ), -# $Fallback +# $self->{Fallback} # ); EOF - print @InitFileCode; + print @{ $self->{InitFileCode} }; - print Q(<<"EOF") if defined $XsubAliases or defined $Interfaces ; + print Q(<<"EOF") if defined $self->{xsubaliases} or defined $self->{interfaces}; # } EOF - if (@BootCode) - { - print "\n /* Initialisation Section */\n\n" ; - @line = @BootCode; - print_section(); - print "\n /* End of Initialisation Section */\n\n" ; + if (@{ $BootCode_ref }) { + print "\n /* Initialisation Section */\n\n"; + @{ $self->{line} } = @{ $BootCode_ref }; + $self->print_section(); + print "\n /* End of Initialisation Section */\n\n"; } print Q(<<'EOF'); @@ -1059,654 +985,682 @@ EOF # EOF - warn("Please specify prototyping behavior for $filename (see perlxs manual)\n") - unless $ProtoUsed ; + warn("Please specify prototyping behavior for $self->{filename} (see perlxs manual)\n") + unless $self->{ProtoUsed}; chdir($orig_cwd); select($orig_fh); untie *PSEUDO_STDOUT if tied *PSEUDO_STDOUT; - close $FH; + close $self->{FH}; return 1; } -sub errors { $errors } - -sub standard_typemap_locations { - # Add all the default typemap locations to the search path - my @tm = qw(typemap); - - my $updir = File::Spec->updir; - foreach my $dir (File::Spec->catdir(($updir) x 1), File::Spec->catdir(($updir) x 2), - File::Spec->catdir(($updir) x 3), File::Spec->catdir(($updir) x 4)) { - - unshift @tm, File::Spec->catfile($dir, 'typemap'); - unshift @tm, File::Spec->catfile($dir, lib => ExtUtils => 'typemap'); - } - foreach my $dir (@INC) { - my $file = File::Spec->catfile($dir, ExtUtils => 'typemap'); - unshift @tm, $file if -e $file; - } - return @tm; -} - -sub TrimWhitespace -{ - $_[0] =~ s/^\s+|\s+$//go ; -} - -sub TidyType - { - local ($_) = @_ ; - - # rationalise any '*' by joining them into bunches and removing whitespace - s#\s*(\*+)\s*#$1#g; - s#(\*+)# $1 #g ; - - # change multiple whitespace into a single space - s/\s+/ /g ; +sub report_error_count { $self->{errors} } - # trim leading & trailing whitespace - TrimWhitespace($_) ; - - $_ ; -} - -# Input: ($_, @line) == unparsed input. -# Output: ($_, @line) == (rest of line, following lines). +# Input: ($self, $_, @{ $self->{line} }) == unparsed input. +# Output: ($_, @{ $self->{line} }) == (rest of line, following lines). # Return: the matched keyword if found, otherwise 0 sub check_keyword { - $_ = shift(@line) while !/\S/ && @line; - s/^(\s*)($_[0])\s*:\s*(?:#.*)?/$1/s && $2; + my $self = shift; + $_ = shift(@{ $self->{line} }) while !/\S/ && @{ $self->{line} }; + s/^(\s*)($_[0])\s*:\s*(?:#.*)?/$1/s && $2; } sub print_section { - # the "do" is required for right semantics - do { $_ = shift(@line) } while !/\S/ && @line; + my $self = shift; - print("#line ", $line_no[@line_no - @line -1], " \"$filepathname\"\n") - if $WantLineNumbers && !/^\s*#\s*line\b/ && !/^#if XSubPPtmp/; - for (; defined($_) && !/^$BLOCK_re/o; $_ = shift(@line)) { - print "$_\n"; - } - print 'ExtUtils::ParseXS::CountLines'->end_marker, "\n" if $WantLineNumbers; + # the "do" is required for right semantics + do { $_ = shift(@{ $self->{line} }) } while !/\S/ && @{ $self->{line} }; + + my $consumed_code = ''; + + print("#line ", $self->{line_no}->[@{ $self->{line_no} } - @{ $self->{line} } -1], " \"", + escape_file_for_line_directive($self->{filepathname}), "\"\n") + if $self->{WantLineNumbers} && !/^\s*#\s*line\b/ && !/^#if XSubPPtmp/; + for (; defined($_) && !/^$self->{BLOCK_re}/o; $_ = shift(@{ $self->{line} })) { + print "$_\n"; + $consumed_code .= "$_\n"; + } + print 'ExtUtils::ParseXS::CountLines'->end_marker, "\n" if $self->{WantLineNumbers}; + + return $consumed_code; } sub merge_section { - my $in = ''; + my $self = shift; + my $in = ''; - while (!/\S/ && @line) { - $_ = shift(@line); - } + while (!/\S/ && @{ $self->{line} }) { + $_ = shift(@{ $self->{line} }); + } - for (; defined($_) && !/^$BLOCK_re/o; $_ = shift(@line)) { - $in .= "$_\n"; - } - chomp $in; - return $in; + for (; defined($_) && !/^$self->{BLOCK_re}/o; $_ = shift(@{ $self->{line} })) { + $in .= "$_\n"; } + chomp $in; + return $in; +} -sub process_keyword($) - { - my($pattern) = @_ ; - my $kwd ; +sub process_keyword { + my($self, $pattern) = @_; - &{"${kwd}_handler"}() - while $kwd = check_keyword($pattern) ; + while (my $kwd = $self->check_keyword($pattern)) { + my $method = $kwd . "_handler"; + $self->$method($_); } +} sub CASE_handler { - blurt ("Error: `CASE:' after unconditional `CASE:'") - if $condnum && $cond eq ''; - $cond = $_; - TrimWhitespace($cond); - print " ", ($condnum++ ? " else" : ""), ($cond ? " if ($cond)\n" : "\n"); - $_ = '' ; + my $self = shift; + $_ = shift; + $self->blurt("Error: 'CASE:' after unconditional 'CASE:'") + if $self->{condnum} && $self->{cond} eq ''; + $self->{cond} = $_; + trim_whitespace($self->{cond}); + print " ", ($self->{condnum}++ ? " else" : ""), ($self->{cond} ? " if ($self->{cond})\n" : "\n"); + $_ = ''; } sub INPUT_handler { - for (; !/^$BLOCK_re/o; $_ = shift(@line)) { + my $self = shift; + $_ = shift; + for (; !/^$self->{BLOCK_re}/o; $_ = shift(@{ $self->{line} })) { last if /^\s*NOT_IMPLEMENTED_YET/; - next unless /\S/; # skip blank lines + next unless /\S/; # skip blank lines - TrimWhitespace($_) ; - my $line = $_ ; + trim_whitespace($_); + my $ln = $_; # remove trailing semicolon if no initialisation - s/\s*;$//g unless /[=;+].*\S/ ; + s/\s*;$//g unless /[=;+].*\S/; # Process the length(foo) declarations if (s/^([^=]*)\blength\(\s*(\w+)\s*\)\s*$/$1 XSauto_length_of_$2=NO_INIT/x) { print "\tSTRLEN\tSTRLEN_length_of_$2;\n"; - $lengthof{$2} = $name; - # $islengthof{$name} = $1; - $deferred .= "\n\tXSauto_length_of_$2 = STRLEN_length_of_$2;\n"; + $self->{lengthof}->{$2} = undef; + $self->{deferred} .= "\n\tXSauto_length_of_$2 = STRLEN_length_of_$2;\n"; } # check for optional initialisation code - my $var_init = '' ; - $var_init = $1 if s/\s*([=;+].*)$//s ; + my $var_init = ''; + $var_init = $1 if s/\s*([=;+].*)$//s; $var_init =~ s/"/\\"/g; + # *sigh* It's valid to supply explicit input typemaps in the argument list... + my $is_overridden_typemap = $var_init =~ /ST\s*\(|\$arg\b/; s/\s+/ /g; my ($var_type, $var_addr, $var_name) = /^(.*?[^&\s])\s*(\&?)\s*\b(\w+)$/s - or blurt("Error: invalid argument declaration '$line'"), next; + or $self->blurt("Error: invalid argument declaration '$ln'"), next; # Check for duplicate definitions - blurt ("Error: duplicate definition of argument '$var_name' ignored"), next - if $arg_list{$var_name}++ - or defined $argtype_seen{$var_name} and not $processing_arg_with_types; + $self->blurt("Error: duplicate definition of argument '$var_name' ignored"), next + if $self->{arg_list}->{$var_name}++ + or defined $self->{argtype_seen}->{$var_name} and not $self->{processing_arg_with_types}; - $thisdone |= $var_name eq "THIS"; - $retvaldone |= $var_name eq "RETVAL"; - $var_types{$var_name} = $var_type; + $self->{thisdone} |= $var_name eq "THIS"; + $self->{retvaldone} |= $var_name eq "RETVAL"; + $self->{var_types}->{$var_name} = $var_type; # XXXX This check is a safeguard against the unfinished conversion of # generate_init(). When generate_init() is fixed, # one can use 2-args map_type() unconditionally. + my $printed_name; if ($var_type =~ / \( \s* \* \s* \) /x) { - # Function pointers are not yet supported with &output_init! - print "\t" . &map_type($var_type, $var_name); - $name_printed = 1; - } else { - print "\t" . &map_type($var_type); - $name_printed = 0; + # Function pointers are not yet supported with output_init()! + print "\t" . map_type($self, $var_type, $var_name); + $printed_name = 1; } - $var_num = $args_match{$var_name}; + else { + print "\t" . map_type($self, $var_type, undef); + $printed_name = 0; + } + $self->{var_num} = $self->{args_match}->{$var_name}; - $proto_arg[$var_num] = ProtoString($var_type) - if $var_num ; - $func_args =~ s/\b($var_name)\b/&$1/ if $var_addr; + if ($self->{var_num}) { + my $typemap = $self->{typemap}->get_typemap(ctype => $var_type); + $self->report_typemap_failure($self->{typemap}, $var_type, "death") + if not $typemap and not $is_overridden_typemap; + $self->{proto_arg}->[$self->{var_num}] = ($typemap && $typemap->proto) || "\$"; + } + $self->{func_args} =~ s/\b($var_name)\b/&$1/ if $var_addr; if ($var_init =~ /^[=;]\s*NO_INIT\s*;?\s*$/ - or $in_out{$var_name} and $in_out{$var_name} =~ /^OUT/ - and $var_init !~ /\S/) { - if ($name_printed) { - print ";\n"; - } else { - print "\t$var_name;\n"; + or $self->{in_out}->{$var_name} and $self->{in_out}->{$var_name} =~ /^OUT/ + and $var_init !~ /\S/) { + if ($printed_name) { + print ";\n"; } - } elsif ($var_init =~ /\S/) { - &output_init($var_type, $var_num, $var_name, $var_init, $name_printed); - } elsif ($var_num) { - # generate initialization code - &generate_init($var_type, $var_num, $var_name, $name_printed); - } else { + else { + print "\t$var_name;\n"; + } + } + elsif ($var_init =~ /\S/) { + output_init( { + type => $var_type, + num => $self->{var_num}, + var => $var_name, + init => $var_init, + printed_name => $printed_name, + } ); + } + elsif ($self->{var_num}) { + generate_init( { + type => $var_type, + num => $self->{var_num}, + var => $var_name, + printed_name => $printed_name, + } ); + } + else { print ";\n"; } } } sub OUTPUT_handler { - for (; !/^$BLOCK_re/o; $_ = shift(@line)) { + my $self = shift; + $self->{have_OUTPUT} = 1; + + $_ = shift; + for (; !/^$self->{BLOCK_re}/o; $_ = shift(@{ $self->{line} })) { next unless /\S/; if (/^\s*SETMAGIC\s*:\s*(ENABLE|DISABLE)\s*/) { - $DoSetMagic = ($1 eq "ENABLE" ? 1 : 0); + $self->{DoSetMagic} = ($1 eq "ENABLE" ? 1 : 0); next; } - my ($outarg, $outcode) = /^\s*(\S+)\s*(.*?)\s*$/s ; - blurt ("Error: duplicate OUTPUT argument '$outarg' ignored"), next - if $outargs{$outarg} ++ ; - if (!$gotRETVAL and $outarg eq 'RETVAL') { + my ($outarg, $outcode) = /^\s*(\S+)\s*(.*?)\s*$/s; + $self->blurt("Error: duplicate OUTPUT argument '$outarg' ignored"), next + if $self->{outargs}->{$outarg}++; + if (!$self->{gotRETVAL} and $outarg eq 'RETVAL') { # deal with RETVAL last - $RETVAL_code = $outcode ; - $gotRETVAL = 1 ; - next ; + $self->{RETVAL_code} = $outcode; + $self->{gotRETVAL} = 1; + next; } - blurt ("Error: OUTPUT $outarg not an argument"), next - unless defined($args_match{$outarg}); - blurt("Error: No input definition for OUTPUT argument '$outarg' - ignored"), next - unless defined $var_types{$outarg} ; - $var_num = $args_match{$outarg}; + $self->blurt("Error: OUTPUT $outarg not an argument"), next + unless defined($self->{args_match}->{$outarg}); + $self->blurt("Error: No input definition for OUTPUT argument '$outarg' - ignored"), next + unless defined $self->{var_types}->{$outarg}; + $self->{var_num} = $self->{args_match}->{$outarg}; if ($outcode) { print "\t$outcode\n"; - print "\tSvSETMAGIC(ST(" , $var_num-1 , "));\n" if $DoSetMagic; - } else { - &generate_output($var_types{$outarg}, $var_num, $outarg, $DoSetMagic); + print "\tSvSETMAGIC(ST(" , $self->{var_num} - 1 , "));\n" if $self->{DoSetMagic}; } - delete $in_out{$outarg} # No need to auto-OUTPUT - if exists $in_out{$outarg} and $in_out{$outarg} =~ /OUT$/; + else { + generate_output( { + type => $self->{var_types}->{$outarg}, + num => $self->{var_num}, + var => $outarg, + do_setmagic => $self->{DoSetMagic}, + do_push => undef, + } ); + } + delete $self->{in_out}->{$outarg} # No need to auto-OUTPUT + if exists $self->{in_out}->{$outarg} and $self->{in_out}->{$outarg} =~ /OUT$/; } } -sub C_ARGS_handler() { - my $in = merge_section(); +sub C_ARGS_handler { + my $self = shift; + $_ = shift; + my $in = $self->merge_section(); - TrimWhitespace($in); - $func_args = $in; + trim_whitespace($in); + $self->{func_args} = $in; } -sub INTERFACE_MACRO_handler() { - my $in = merge_section(); +sub INTERFACE_MACRO_handler { + my $self = shift; + $_ = shift; + my $in = $self->merge_section(); - TrimWhitespace($in); - if ($in =~ /\s/) { # two - ($interface_macro, $interface_macro_set) = split ' ', $in; - } else { - $interface_macro = $in; - $interface_macro_set = 'UNKNOWN_CVT'; # catch later + trim_whitespace($in); + if ($in =~ /\s/) { # two + ($self->{interface_macro}, $self->{interface_macro_set}) = split ' ', $in; + } + else { + $self->{interface_macro} = $in; + $self->{interface_macro_set} = 'UNKNOWN_CVT'; # catch later } - $interface = 1; # local - $Interfaces = 1; # global + $self->{interface} = 1; # local + $self->{interfaces} = 1; # global } -sub INTERFACE_handler() { - my $in = merge_section(); +sub INTERFACE_handler { + my $self = shift; + $_ = shift; + my $in = $self->merge_section(); - TrimWhitespace($in); + trim_whitespace($in); foreach (split /[\s,]+/, $in) { - my $name = $_; - $name =~ s/^$Prefix//; - $Interfaces{$name} = $_; + my $iface_name = $_; + $iface_name =~ s/^$self->{Prefix}//; + $self->{Interfaces}->{$iface_name} = $_; } print Q(<<"EOF"); -# XSFUNCTION = $interface_macro($ret_type,cv,XSANY.any_dptr); +# XSFUNCTION = $self->{interface_macro}($self->{ret_type},cv,XSANY.any_dptr); EOF - $interface = 1; # local - $Interfaces = 1; # global + $self->{interface} = 1; # local + $self->{interfaces} = 1; # global +} + +sub CLEANUP_handler { + my $self = shift; + $self->print_section(); } -sub CLEANUP_handler() { print_section() } -sub PREINIT_handler() { print_section() } -sub POSTCALL_handler() { print_section() } -sub INIT_handler() { print_section() } +sub PREINIT_handler { + my $self = shift; + $self->print_section(); +} -sub GetAliases - { - my ($line) = @_ ; - my ($orig) = $line ; - my ($alias) ; - my ($value) ; +sub POSTCALL_handler { + my $self = shift; + $self->print_section(); +} - # Parse alias definitions - # format is - # alias = value alias = value ... +sub INIT_handler { + my $self = shift; + $self->print_section(); +} - while ($line =~ s/^\s*([\w:]+)\s*=\s*(\w+)\s*//) { - $alias = $1 ; - $orig_alias = $alias ; - $value = $2 ; +sub get_aliases { + my $self = shift; + my ($line) = @_; + my ($orig) = $line; - # check for optional package definition in the alias - $alias = $Packprefix . $alias if $alias !~ /::/ ; + # Parse alias definitions + # format is + # alias = value alias = value ... - # check for duplicate alias name & duplicate value - Warn("Warning: Ignoring duplicate alias '$orig_alias'") - if defined $XsubAliases{$alias} ; + while ($line =~ s/^\s*([\w:]+)\s*=\s*(\w+)\s*//) { + my ($alias, $value) = ($1, $2); + my $orig_alias = $alias; - Warn("Warning: Aliases '$orig_alias' and '$XsubAliasValues{$value}' have identical values") - if $XsubAliasValues{$value} ; + # check for optional package definition in the alias + $alias = $self->{Packprefix} . $alias if $alias !~ /::/; - $XsubAliases = 1; - $XsubAliases{$alias} = $value ; - $XsubAliasValues{$value} = $orig_alias ; - } + # check for duplicate alias name & duplicate value + Warn( $self, "Warning: Ignoring duplicate alias '$orig_alias'") + if defined $self->{XsubAliases}->{$alias}; - blurt("Error: Cannot parse ALIAS definitions from '$orig'") - if $line ; + Warn( $self, "Warning: Aliases '$orig_alias' and '$self->{XsubAliasValues}->{$value}' have identical values") + if $self->{XsubAliasValues}->{$value}; + + $self->{xsubaliases} = 1; + $self->{XsubAliases}->{$alias} = $value; + $self->{XsubAliasValues}->{$value} = $orig_alias; } -sub ATTRS_handler () - { - for (; !/^$BLOCK_re/o; $_ = shift(@line)) { - next unless /\S/; - TrimWhitespace($_) ; - push @Attributes, $_; - } + blurt( $self, "Error: Cannot parse ALIAS definitions from '$orig'") + if $line; +} + +sub ATTRS_handler { + my $self = shift; + $_ = shift; + + for (; !/^$self->{BLOCK_re}/o; $_ = shift(@{ $self->{line} })) { + next unless /\S/; + trim_whitespace($_); + push @{ $self->{Attributes} }, $_; } +} -sub ALIAS_handler () - { - for (; !/^$BLOCK_re/o; $_ = shift(@line)) { - next unless /\S/; - TrimWhitespace($_) ; - GetAliases($_) if $_ ; - } +sub ALIAS_handler { + my $self = shift; + $_ = shift; + + for (; !/^$self->{BLOCK_re}/o; $_ = shift(@{ $self->{line} })) { + next unless /\S/; + trim_whitespace($_); + $self->get_aliases($_) if $_; } +} + +sub OVERLOAD_handler { + my $self = shift; + $_ = shift; -sub OVERLOAD_handler() -{ - for (; !/^$BLOCK_re/o; $_ = shift(@line)) { + for (; !/^$self->{BLOCK_re}/o; $_ = shift(@{ $self->{line} })) { next unless /\S/; - TrimWhitespace($_) ; + trim_whitespace($_); while ( s/^\s*([\w:"\\)\+\-\*\/\%\<\>\.\&\|\^\!\~\{\}\=]+)\s*//) { - $Overload = 1 unless $Overload; - my $overload = "$Package\::(".$1 ; - push(@InitFileCode, - " (void)${newXS}(\"$overload\", XS_$Full_func_name, file$proto);\n"); + $self->{Overload} = 1 unless $self->{Overload}; + my $overload = "$Package\::(".$1; + push(@{ $self->{InitFileCode} }, + " (void)$self->{newXS}(\"$overload\", XS_$Full_func_name, file$self->{proto});\n"); } - } + } } -sub FALLBACK_handler() -{ - # the rest of the current line should contain either TRUE, +sub FALLBACK_handler { + my $self = shift; + $_ = shift; + + # the rest of the current line should contain either TRUE, # FALSE or UNDEF - - TrimWhitespace($_) ; + + trim_whitespace($_); my %map = ( - TRUE => "&PL_sv_yes", 1 => "&PL_sv_yes", - FALSE => "&PL_sv_no", 0 => "&PL_sv_no", - UNDEF => "&PL_sv_undef", - ) ; - + TRUE => "&PL_sv_yes", 1 => "&PL_sv_yes", + FALSE => "&PL_sv_no", 0 => "&PL_sv_no", + UNDEF => "&PL_sv_undef", + ); + # check for valid FALLBACK value - death ("Error: FALLBACK: TRUE/FALSE/UNDEF") unless exists $map{uc $_} ; - - $Fallback = $map{uc $_} ; + $self->death("Error: FALLBACK: TRUE/FALSE/UNDEF") unless exists $map{uc $_}; + + $self->{Fallback} = $map{uc $_}; } -sub REQUIRE_handler () - { - # the rest of the current line should contain a version number - my ($Ver) = $_ ; +sub REQUIRE_handler { + my $self = shift; + # the rest of the current line should contain a version number + my $Ver = shift; - TrimWhitespace($Ver) ; + trim_whitespace($Ver); - death ("Error: REQUIRE expects a version number") - unless $Ver ; + $self->death("Error: REQUIRE expects a version number") + unless $Ver; - # check that the version number is of the form n.n - death ("Error: REQUIRE: expected a number, got '$Ver'") - unless $Ver =~ /^\d+(\.\d*)?/ ; + # check that the version number is of the form n.n + $self->death("Error: REQUIRE: expected a number, got '$Ver'") + unless $Ver =~ /^\d+(\.\d*)?/; - death ("Error: xsubpp $Ver (or better) required--this is only $VERSION.") - unless $VERSION >= $Ver ; - } + $self->death("Error: xsubpp $Ver (or better) required--this is only $VERSION.") + unless $VERSION >= $Ver; +} -sub VERSIONCHECK_handler () - { - # the rest of the current line should contain either ENABLE or - # DISABLE +sub VERSIONCHECK_handler { + my $self = shift; + $_ = shift; - TrimWhitespace($_) ; + # the rest of the current line should contain either ENABLE or + # DISABLE - # check for ENABLE/DISABLE - death ("Error: VERSIONCHECK: ENABLE/DISABLE") - unless /^(ENABLE|DISABLE)/i ; + trim_whitespace($_); - $WantVersionChk = 1 if $1 eq 'ENABLE' ; - $WantVersionChk = 0 if $1 eq 'DISABLE' ; + # check for ENABLE/DISABLE + $self->death("Error: VERSIONCHECK: ENABLE/DISABLE") + unless /^(ENABLE|DISABLE)/i; - } + $self->{WantVersionChk} = 1 if $1 eq 'ENABLE'; + $self->{WantVersionChk} = 0 if $1 eq 'DISABLE'; -sub PROTOTYPE_handler () - { - my $specified ; - - death("Error: Only 1 PROTOTYPE definition allowed per xsub") - if $proto_in_this_xsub ++ ; - - for (; !/^$BLOCK_re/o; $_ = shift(@line)) { - next unless /\S/; - $specified = 1 ; - TrimWhitespace($_) ; - if ($_ eq 'DISABLE') { - $ProtoThisXSUB = 0 - } elsif ($_ eq 'ENABLE') { - $ProtoThisXSUB = 1 - } else { - # remove any whitespace - s/\s+//g ; - death("Error: Invalid prototype '$_'") - unless ValidProtoString($_) ; - $ProtoThisXSUB = C_string($_) ; - } - } +} - # If no prototype specified, then assume empty prototype "" - $ProtoThisXSUB = 2 unless $specified ; +sub PROTOTYPE_handler { + my $self = shift; + $_ = shift; + + my $specified; - $ProtoUsed = 1 ; + $self->death("Error: Only 1 PROTOTYPE definition allowed per xsub") + if $self->{proto_in_this_xsub}++; + for (; !/^$self->{BLOCK_re}/o; $_ = shift(@{ $self->{line} })) { + next unless /\S/; + $specified = 1; + trim_whitespace($_); + if ($_ eq 'DISABLE') { + $self->{ProtoThisXSUB} = 0; + } + elsif ($_ eq 'ENABLE') { + $self->{ProtoThisXSUB} = 1; + } + else { + # remove any whitespace + s/\s+//g; + $self->death("Error: Invalid prototype '$_'") + unless valid_proto_string($_); + $self->{ProtoThisXSUB} = C_string($_); + } } -sub SCOPE_handler () - { - death("Error: Only 1 SCOPE declaration allowed per xsub") - if $scope_in_this_xsub ++ ; + # If no prototype specified, then assume empty prototype "" + $self->{ProtoThisXSUB} = 2 unless $specified; - TrimWhitespace($_); - death ("Error: SCOPE: ENABLE/DISABLE") - unless /^(ENABLE|DISABLE)\b/i; - $ScopeThisXSUB = ( uc($1) eq 'ENABLE' ); - } + $self->{ProtoUsed} = 1; +} -sub PROTOTYPES_handler () - { - # the rest of the current line should contain either ENABLE or - # DISABLE +sub SCOPE_handler { + my $self = shift; + $_ = shift; - TrimWhitespace($_) ; + $self->death("Error: Only 1 SCOPE declaration allowed per xsub") + if $self->{scope_in_this_xsub}++; - # check for ENABLE/DISABLE - death ("Error: PROTOTYPES: ENABLE/DISABLE") - unless /^(ENABLE|DISABLE)/i ; + trim_whitespace($_); + $self->death("Error: SCOPE: ENABLE/DISABLE") + unless /^(ENABLE|DISABLE)\b/i; + $self->{ScopeThisXSUB} = ( uc($1) eq 'ENABLE' ); +} - $WantPrototypes = 1 if $1 eq 'ENABLE' ; - $WantPrototypes = 0 if $1 eq 'DISABLE' ; - $ProtoUsed = 1 ; +sub PROTOTYPES_handler { + my $self = shift; + $_ = shift; - } + # the rest of the current line should contain either ENABLE or + # DISABLE -sub PushXSStack - { - my %args = @_; - # Save the current file context. - push(@XSStack, { - type => 'file', - LastLine => $lastline, - LastLineNo => $lastline_no, - Line => \@line, - LineNo => \@line_no, - Filename => $filename, - Filepathname => $filepathname, - Handle => $FH, - IsPipe => scalar($filename =~ /\|\s*$/), - %args, - }) ; + trim_whitespace($_); - } + # check for ENABLE/DISABLE + $self->death("Error: PROTOTYPES: ENABLE/DISABLE") + unless /^(ENABLE|DISABLE)/i; -sub INCLUDE_handler () - { - # the rest of the current line should contain a valid filename + $self->{WantPrototypes} = 1 if $1 eq 'ENABLE'; + $self->{WantPrototypes} = 0 if $1 eq 'DISABLE'; + $self->{ProtoUsed} = 1; +} - TrimWhitespace($_) ; +sub EXPORT_XSUB_SYMBOLS_handler { + my $self = shift; + $_ = shift; - death("INCLUDE: filename missing") - unless $_ ; + # the rest of the current line should contain either ENABLE or + # DISABLE - death("INCLUDE: output pipe is illegal") - if /^\s*\|/ ; + trim_whitespace($_); - # simple minded recursion detector - death("INCLUDE loop detected") - if $IncludedFiles{$_} ; + # check for ENABLE/DISABLE + $self->death("Error: EXPORT_XSUB_SYMBOLS: ENABLE/DISABLE") + unless /^(ENABLE|DISABLE)/i; - ++ $IncludedFiles{$_} unless /\|\s*$/ ; + my $xs_impl = $1 eq 'ENABLE' ? 'XS_EXTERNAL' : 'XS_INTERNAL'; + + print Q(<<"EOF"); +##undef XS_EUPXS +##if defined(PERL_EUPXS_ALWAYS_EXPORT) +## define XS_EUPXS(name) XS_EXTERNAL(name) +##elif defined(PERL_EUPXS_NEVER_EXPORT) +## define XS_EUPXS(name) XS_INTERNAL(name) +##else +## define XS_EUPXS(name) $xs_impl(name) +##endif +EOF +} - if (/\|\s*$/ && /^\s*perl\s/) { - Warn("The INCLUDE directive with a command is discouraged." . - " Use INCLUDE_COMMAND instead! In particular using 'perl'" . - " in an 'INCLUDE: ... |' directive is not guaranteed to pick" . - " up the correct perl. The INCLUDE_COMMAND directive allows" . - " the use of \$^X as the currently running perl, see" . - " 'perldoc perlxs' for details."); - } - PushXSStack(); +sub PushXSStack { + my $self = shift; + my %args = @_; + # Save the current file context. + push(@{ $self->{XSStack} }, { + type => 'file', + LastLine => $self->{lastline}, + LastLineNo => $self->{lastline_no}, + Line => $self->{line}, + LineNo => $self->{line_no}, + Filename => $self->{filename}, + Filepathname => $self->{filepathname}, + Handle => $self->{FH}, + IsPipe => scalar($self->{filename} =~ /\|\s*$/), + %args, + }); + +} - $FH = Symbol::gensym(); +sub INCLUDE_handler { + my $self = shift; + $_ = shift; + # the rest of the current line should contain a valid filename - # open the new file - open ($FH, "$_") or death("Cannot open '$_': $!") ; + trim_whitespace($_); - print Q(<<"EOF"); + $self->death("INCLUDE: filename missing") + unless $_; + + $self->death("INCLUDE: output pipe is illegal") + if /^\s*\|/; + + # simple minded recursion detector + $self->death("INCLUDE loop detected") + if $self->{IncludedFiles}->{$_}; + + ++$self->{IncludedFiles}->{$_} unless /\|\s*$/; + + if (/\|\s*$/ && /^\s*perl\s/) { + Warn( $self, "The INCLUDE directive with a command is discouraged." . + " Use INCLUDE_COMMAND instead! In particular using 'perl'" . + " in an 'INCLUDE: ... |' directive is not guaranteed to pick" . + " up the correct perl. The INCLUDE_COMMAND directive allows" . + " the use of \$^X as the currently running perl, see" . + " 'perldoc perlxs' for details."); + } + + $self->PushXSStack(); + + $self->{FH} = Symbol::gensym(); + + # open the new file + open($self->{FH}, $_) or $self->death("Cannot open '$_': $!"); + + print Q(<<"EOF"); # -#/* INCLUDE: Including '$_' from '$filename' */ +#/* INCLUDE: Including '$_' from '$self->{filename}' */ # EOF - $filename = $_ ; - $filepathname = File::Spec->catfile($dir, $filename); + $self->{filename} = $_; + $self->{filepathname} = ( $^O =~ /^mswin/i ) + ? qq($self->{dir}/$self->{filename}) # See CPAN RT #61908: gcc doesn't like backslashes on win32? + : File::Spec->catfile($self->{dir}, $self->{filename}); - # Prime the pump by reading the first - # non-blank line + # Prime the pump by reading the first + # non-blank line - # skip leading blank lines - while (<$FH>) { - last unless /^\s*$/ ; - } - - $lastline = $_ ; - $lastline_no = $. ; + # skip leading blank lines + while (readline($self->{FH})) { + last unless /^\s*$/; } + $self->{lastline} = $_; + $self->{lastline_no} = $.; +} + sub QuoteArgs { - my $cmd = shift; - my @args = split /\s+/, $cmd; - $cmd = shift @args; - for (@args) { - $_ = q(").$_.q(") if !/^\"/ && length($_) > 0; - } - return join (' ', ($cmd, @args)); + my $cmd = shift; + my @args = split /\s+/, $cmd; + $cmd = shift @args; + for (@args) { + $_ = q(").$_.q(") if !/^\"/ && length($_) > 0; } + return join (' ', ($cmd, @args)); +} -sub INCLUDE_COMMAND_handler () - { - # the rest of the current line should contain a valid command +sub INCLUDE_COMMAND_handler { + my $self = shift; + $_ = shift; + # the rest of the current line should contain a valid command - TrimWhitespace($_) ; + trim_whitespace($_); - $_ = QuoteArgs($_) if $^O eq 'VMS'; + $_ = QuoteArgs($_) if $^O eq 'VMS'; - death("INCLUDE_COMMAND: command missing") - unless $_ ; + $self->death("INCLUDE_COMMAND: command missing") + unless $_; - death("INCLUDE_COMMAND: pipes are illegal") - if /^\s*\|/ or /\|\s*$/ ; + $self->death("INCLUDE_COMMAND: pipes are illegal") + if /^\s*\|/ or /\|\s*$/; - PushXSStack( IsPipe => 1 ); + $self->PushXSStack( IsPipe => 1 ); - $FH = Symbol::gensym(); + $self->{FH} = Symbol::gensym(); - # If $^X is used in INCLUDE_COMMAND, we know it's supposed to be - # the same perl interpreter as we're currently running - s/^\s*\$\^X/$^X/; + # If $^X is used in INCLUDE_COMMAND, we know it's supposed to be + # the same perl interpreter as we're currently running + s/^\s*\$\^X/$^X/; - # open the new file - open ($FH, "-|", "$_") - or death("Cannot run command '$_' to include its output: $!") ; + # open the new file + open ($self->{FH}, "-|", $_) + or $self->death( $self, "Cannot run command '$_' to include its output: $!"); - print Q(<<"EOF"); + print Q(<<"EOF"); # -#/* INCLUDE_COMMAND: Including output of '$_' from '$filename' */ +#/* INCLUDE_COMMAND: Including output of '$_' from '$self->{filename}' */ # EOF - $filename = $_ ; - $filepathname = $filename; - $filepathname =~ s/\"/\\"/g; + $self->{filename} = $_; + $self->{filepathname} = $self->{filename}; + #$self->{filepathname} =~ s/\"/\\"/g; # Fails? See CPAN RT #53938: MinGW Broken after 2.21 + $self->{filepathname} =~ s/\\/\\\\/g; # Works according to reporter of #53938 - # Prime the pump by reading the first - # non-blank line + # Prime the pump by reading the first + # non-blank line - # skip leading blank lines - while (<$FH>) { - last unless /^\s*$/ ; - } - - $lastline = $_ ; - $lastline_no = $. ; + # skip leading blank lines + while (readline($self->{FH})) { + last unless /^\s*$/; } -sub PopFile() - { - return 0 unless $XSStack[-1]{type} eq 'file' ; - - my $data = pop @XSStack ; - my $ThisFile = $filename ; - my $isPipe = $data->{IsPipe}; - - -- $IncludedFiles{$filename} - unless $isPipe ; - - close $FH ; - - $FH = $data->{Handle} ; - # $filename is the leafname, which for some reason isused for diagnostic - # messages, whereas $filepathname is the full pathname, and is used for - # #line directives. - $filename = $data->{Filename} ; - $filepathname = $data->{Filepathname} ; - $lastline = $data->{LastLine} ; - $lastline_no = $data->{LastLineNo} ; - @line = @{ $data->{Line} } ; - @line_no = @{ $data->{LineNo} } ; - - if ($isPipe and $? ) { - -- $lastline_no ; - print STDERR "Error reading from pipe '$ThisFile': $! in $filename, line $lastline_no\n" ; - exit 1 ; - } + $self->{lastline} = $_; + $self->{lastline_no} = $.; +} - print Q(<<"EOF"); -# -#/* INCLUDE: Returning to '$filename' from '$ThisFile' */ -# -EOF +sub PopFile { + my $self = shift; - return 1 ; - } + return 0 unless $self->{XSStack}->[-1]{type} eq 'file'; -sub ValidProtoString ($) - { - my($string) = @_ ; + my $data = pop @{ $self->{XSStack} }; + my $ThisFile = $self->{filename}; + my $isPipe = $data->{IsPipe}; - if ( $string =~ /^$proto_re+$/ ) { - return $string ; - } + --$self->{IncludedFiles}->{$self->{filename}} + unless $isPipe; - return 0 ; - } + close $self->{FH}; -sub C_string ($) - { - my($string) = @_ ; + $self->{FH} = $data->{Handle}; + # $filename is the leafname, which for some reason isused for diagnostic + # messages, whereas $filepathname is the full pathname, and is used for + # #line directives. + $self->{filename} = $data->{Filename}; + $self->{filepathname} = $data->{Filepathname}; + $self->{lastline} = $data->{LastLine}; + $self->{lastline_no} = $data->{LastLineNo}; + @{ $self->{line} } = @{ $data->{Line} }; + @{ $self->{line_no} } = @{ $data->{LineNo} }; - $string =~ s[\\][\\\\]g ; - $string ; + if ($isPipe and $? ) { + --$self->{lastline_no}; + print STDERR "Error reading from pipe '$ThisFile': $! in $self->{filename}, line $self->{lastline_no}\n" ; + exit 1; } -sub ProtoString ($) - { - my ($type) = @_ ; - - $proto_letter{$type} or "\$" ; - } + print Q(<<"EOF"); +# +#/* INCLUDE: Returning to '$self->{filename}' from '$ThisFile' */ +# +EOF -sub check_cpp { - my @cpp = grep(/^\#\s*(?:if|e\w+)/, @line); - if (@cpp) { - my ($cpp, $cpplevel); - for $cpp (@cpp) { - if ($cpp =~ /^\#\s*if/) { - $cpplevel++; - } elsif (!$cpplevel) { - Warn("Warning: #else/elif/endif without #if in this function"); - print STDERR " (precede it with a blank line if the matching #if is outside the function)\n" - if $XSStack[-1]{type} eq 'if'; - return; - } elsif ($cpp =~ /^\#\s*endif/) { - $cpplevel--; - } - } - Warn("Warning: #if without #endif in this function") if $cpplevel; - } + return 1; } - sub Q { my($text) = @_; $text =~ s/^#//gm; @@ -1715,480 +1669,325 @@ sub Q { $text; } -# Read next xsub into @line from ($lastline, <$FH>). +# Read next xsub into @{ $self->{line} } from ($lastline, readline($self->{FH})). sub fetch_para { + my $self = shift; + # parse paragraph - death ("Error: Unterminated `#if/#ifdef/#ifndef'") - if !defined $lastline && $XSStack[-1]{type} eq 'if'; - @line = (); - @line_no = () ; - return PopFile() if !defined $lastline; + $self->death("Error: Unterminated '#if/#ifdef/#ifndef'") + if !defined $self->{lastline} && $self->{XSStack}->[-1]{type} eq 'if'; + @{ $self->{line} } = (); + @{ $self->{line_no} } = (); + return $self->PopFile() if !defined $self->{lastline}; - if ($lastline =~ + if ($self->{lastline} =~ /^MODULE\s*=\s*([\w:]+)(?:\s+PACKAGE\s*=\s*([\w:]+))?(?:\s+PREFIX\s*=\s*(\S+))?\s*$/) { - $Module = $1; + my $Module = $1; $Package = defined($2) ? $2 : ''; # keep -w happy - $Prefix = defined($3) ? $3 : ''; # keep -w happy - $Prefix = quotemeta $Prefix ; - ($Module_cname = $Module) =~ s/\W/_/g; - ($Packid = $Package) =~ tr/:/_/; - $Packprefix = $Package; - $Packprefix .= "::" if $Packprefix ne ""; - $lastline = ""; + $self->{Prefix} = defined($3) ? $3 : ''; # keep -w happy + $self->{Prefix} = quotemeta $self->{Prefix}; + ($self->{Module_cname} = $Module) =~ s/\W/_/g; + ($self->{Packid} = $Package) =~ tr/:/_/; + $self->{Packprefix} = $Package; + $self->{Packprefix} .= "::" if $self->{Packprefix} ne ""; + $self->{lastline} = ""; } for (;;) { # Skip embedded PODs - while ($lastline =~ /^=/) { - while ($lastline = <$FH>) { - last if ($lastline =~ /^=cut\s*$/); + while ($self->{lastline} =~ /^=/) { + while ($self->{lastline} = readline($self->{FH})) { + last if ($self->{lastline} =~ /^=cut\s*$/); } - death ("Error: Unterminated pod") unless $lastline; - $lastline = <$FH>; - chomp $lastline; - $lastline =~ s/^\s+$//; + $self->death("Error: Unterminated pod") unless $self->{lastline}; + $self->{lastline} = readline($self->{FH}); + chomp $self->{lastline}; + $self->{lastline} =~ s/^\s+$//; } - if ($lastline !~ /^\s*#/ || - # CPP directives: - # ANSI: if ifdef ifndef elif else endif define undef - # line error pragma - # gcc: warning include_next - # obj-c: import - # others: ident (gcc notes that some cpps have this one) - $lastline =~ /^#[ \t]*(?:(?:if|ifn?def|elif|else|endif|define|undef|pragma|error|warning|line\s+\d+|ident)\b|(?:include(?:_next)?|import)\s*["<].*[>"])/) { - last if $lastline =~ /^\S/ && @line && $line[-1] eq ""; - push(@line, $lastline); - push(@line_no, $lastline_no) ; + + # This chunk of code strips out (and parses) embedded TYPEMAP blocks + # which support a HEREdoc-alike block syntax. + # This is special cased from the usual paragraph-handler logic + # due to the HEREdoc-ish syntax. + if ($self->{lastline} =~ /^TYPEMAP\s*:\s*<<\s*(?:(["'])(.+?)\1|([^\s'"]+))\s*;?\s*$/) { + my $end_marker = quotemeta(defined($1) ? $2 : $3); + my @tmaplines; + while (1) { + $self->{lastline} = readline($self->{FH}); + $self->death("Error: Unterminated typemap") if not defined $self->{lastline}; + last if $self->{lastline} =~ /^$end_marker\s*$/; + push @tmaplines, $self->{lastline}; + } + + my $tmapcode = join "", @tmaplines; + my $tmap = ExtUtils::Typemaps->new( + string => $tmapcode, + lineno_offset => ($self->current_line_number()||0)+1, + fake_filename => $self->{filename}, + ); + $self->{typemap}->merge(typemap => $tmap, replace => 1); + + $self->{lastline} = ""; + } + + if ($self->{lastline} !~ /^\s*#/ || + # CPP directives: + # ANSI: if ifdef ifndef elif else endif define undef + # line error pragma + # gcc: warning include_next + # obj-c: import + # others: ident (gcc notes that some cpps have this one) + $self->{lastline} =~ /^#[ \t]*(?:(?:if|ifn?def|elif|else|endif|define|undef|pragma|error|warning|line\s+\d+|ident)\b|(?:include(?:_next)?|import)\s*["<].*[>"])/) { + last if $self->{lastline} =~ /^\S/ && @{ $self->{line} } && $self->{line}->[-1] eq ""; + push(@{ $self->{line} }, $self->{lastline}); + push(@{ $self->{line_no} }, $self->{lastline_no}); } # Read next line and continuation lines - last unless defined($lastline = <$FH>); - $lastline_no = $.; + last unless defined($self->{lastline} = readline($self->{FH})); + $self->{lastline_no} = $.; my $tmp_line; - $lastline .= $tmp_line - while ($lastline =~ /\\$/ && defined($tmp_line = <$FH>)); + $self->{lastline} .= $tmp_line + while ($self->{lastline} =~ /\\$/ && defined($tmp_line = readline($self->{FH}))); - chomp $lastline; - $lastline =~ s/^\s+$//; + chomp $self->{lastline}; + $self->{lastline} =~ s/^\s+$//; } - pop(@line), pop(@line_no) while @line && $line[-1] eq ""; + pop(@{ $self->{line} }), pop(@{ $self->{line_no} }) while @{ $self->{line} } && $self->{line}->[-1] eq ""; 1; } sub output_init { - local($type, $num, $var, $init, $name_printed) = @_; - local($arg) = "ST(" . ($num - 1) . ")"; + my $argsref = shift; + my ($type, $num, $var, $init, $printed_name) = ( + $argsref->{type}, + $argsref->{num}, + $argsref->{var}, + $argsref->{init}, + $argsref->{printed_name} + ); + my $arg = "ST(" . ($num - 1) . ")"; if ( $init =~ /^=/ ) { - if ($name_printed) { + if ($printed_name) { eval qq/print " $init\\n"/; - } else { + } + else { eval qq/print "\\t$var $init\\n"/; } - warn $@ if $@; - } else { + warn $@ if $@; + } + else { if ( $init =~ s/^\+// && $num ) { - &generate_init($type, $num, $var, $name_printed); - } elsif ($name_printed) { + generate_init( { + type => $type, + num => $num, + var => $var, + printed_name => $printed_name, + } ); + } + elsif ($printed_name) { print ";\n"; $init =~ s/^;//; - } else { + } + else { eval qq/print "\\t$var;\\n"/; - warn $@ if $@; + warn $@ if $@; $init =~ s/^;//; } - $deferred .= eval qq/"\\n\\t$init\\n"/; - warn $@ if $@; + $self->{deferred} .= eval qq/"\\n\\t$init\\n"/; + warn $@ if $@; } } -sub Warn - { - # work out the line number - my $line_no = $line_no[@line_no - @line -1] ; - - print STDERR "@_ in $filename, line $line_no\n" ; - } - -sub blurt - { - Warn @_ ; - $errors ++ - } - -sub death - { - Warn @_ ; - exit 1 ; - } - sub generate_init { - local($type, $num, $var) = @_; - local($arg) = "ST(" . ($num - 1) . ")"; - local($argoff) = $num - 1; - local($ntype); - local($tk); - - $type = TidyType($type) ; - blurt("Error: '$type' not in typemap"), return - unless defined($type_kind{$type}); + my $argsref = shift; + my ($type, $num, $var, $printed_name) = ( + $argsref->{type}, + $argsref->{num}, + $argsref->{var}, + $argsref->{printed_name}, + ); + my $arg = "ST(" . ($num - 1) . ")"; + my ($argoff, $ntype); + $argoff = $num - 1; + + my $typemaps = $self->{typemap}; + + $type = tidy_type($type); + $self->report_typemap_failure($typemaps, $type), return + unless $typemaps->get_typemap(ctype => $type); ($ntype = $type) =~ s/\s*\*/Ptr/g; + my $subtype; ($subtype = $ntype) =~ s/(?:Array)?(?:Ptr)?$//; - $tk = $type_kind{$type}; - $tk =~ s/OBJ$/REF/ if $func_name =~ /DESTROY$/; - if ($tk eq 'T_PV' and exists $lengthof{$var}) { - print "\t$var" unless $name_printed; + my $typem = $typemaps->get_typemap(ctype => $type); + my $xstype = $typem->xstype; + $xstype =~ s/OBJ$/REF/ if $func_name =~ /DESTROY$/; + if ($xstype eq 'T_PV' and exists $self->{lengthof}->{$var}) { + print "\t$var" unless $printed_name; print " = ($type)SvPV($arg, STRLEN_length_of_$var);\n"; die "default value not supported with length(NAME) supplied" - if defined $defaults{$var}; + if defined $self->{defaults}->{$var}; return; } - $type =~ tr/:/_/ unless $hiertype; - blurt("Error: No INPUT definition for type '$type', typekind '$type_kind{$type}' found"), return - unless defined $input_expr{$tk} ; - $expr = $input_expr{$tk}; + $type =~ tr/:/_/ unless $self->{hiertype}; + + my $inputmap = $typemaps->get_inputmap(xstype => $xstype); + $self->blurt("Error: No INPUT definition for type '$type', typekind '" . $type->xstype . "' found"), return + unless defined $inputmap; + + my $expr = $inputmap->cleaned_code; + # Note: This gruesome bit either needs heavy rethinking or documentation. I vote for the former. --Steffen if ($expr =~ /DO_ARRAY_ELEM/) { - blurt("Error: '$subtype' not in typemap"), return - unless defined($type_kind{$subtype}); - blurt("Error: No INPUT definition for type '$subtype', typekind '$type_kind{$subtype}' found"), return - unless defined $input_expr{$type_kind{$subtype}} ; - $subexpr = $input_expr{$type_kind{$subtype}}; + my $subtypemap = $typemaps->get_typemap(ctype => $subtype); + $self->report_typemap_failure($typemaps, $subtype), return + if not $subtypemap; + my $subinputmap = $typemaps->get_inputmap(xstype => $subtypemap->xstype); + $self->blurt("Error: No INPUT definition for type '$subtype', typekind '" . $subtypemap->xstype . "' found"), return + unless $subinputmap; + my $subexpr = $subinputmap->cleaned_code; $subexpr =~ s/\$type/\$subtype/g; $subexpr =~ s/ntype/subtype/g; $subexpr =~ s/\$arg/ST(ix_$var)/g; $subexpr =~ s/\n\t/\n\t\t/g; $subexpr =~ s/is not of (.*\")/[arg %d] is not of $1, ix_$var + 1/g; - $subexpr =~ s/\$var/${var}[ix_$var - $argoff]/; + $subexpr =~ s/\$var/${var}\[ix_$var - $argoff]/; $expr =~ s/DO_ARRAY_ELEM/$subexpr/; } if ($expr =~ m#/\*.*scope.*\*/#i) { # "scope" in C comments - $ScopeThisXSUB = 1; + $self->{ScopeThisXSUB} = 1; } - if (defined($defaults{$var})) { + if (defined($self->{defaults}->{$var})) { $expr =~ s/(\t+)/$1 /g; $expr =~ s/ /\t/g; - if ($name_printed) { + if ($printed_name) { print ";\n"; - } else { + } + else { eval qq/print "\\t$var;\\n"/; - warn $@ if $@; + warn $@ if $@; } - if ($defaults{$var} eq 'NO_INIT') { - $deferred .= eval qq/"\\n\\tif (items >= $num) {\\n$expr;\\n\\t}\\n"/; - } else { - $deferred .= eval qq/"\\n\\tif (items < $num)\\n\\t $var = $defaults{$var};\\n\\telse {\\n$expr;\\n\\t}\\n"/; + if ($self->{defaults}->{$var} eq 'NO_INIT') { + $self->{deferred} .= eval qq/"\\n\\tif (items >= $num) {\\n$expr;\\n\\t}\\n"/; } - warn $@ if $@; - } elsif ($ScopeThisXSUB or $expr !~ /^\s*\$var =/) { - if ($name_printed) { + else { + $self->{deferred} .= eval qq/"\\n\\tif (items < $num)\\n\\t $var = $self->{defaults}->{$var};\\n\\telse {\\n$expr;\\n\\t}\\n"/; + } + warn $@ if $@; + } + elsif ($self->{ScopeThisXSUB} or $expr !~ /^\s*\$var =/) { + if ($printed_name) { print ";\n"; - } else { + } + else { eval qq/print "\\t$var;\\n"/; - warn $@ if $@; + warn $@ if $@; } - $deferred .= eval qq/"\\n$expr;\\n"/; - warn $@ if $@; - } else { + $self->{deferred} .= eval qq/"\\n$expr;\\n"/; + warn $@ if $@; + } + else { die "panic: do not know how to handle this branch for function pointers" - if $name_printed; + if $printed_name; eval qq/print "$expr;\\n"/; - warn $@ if $@; + warn $@ if $@; } } sub generate_output { - local($type, $num, $var, $do_setmagic, $do_push) = @_; - local($arg) = "ST(" . ($num - ($num != 0)) . ")"; - local($argoff) = $num - 1; - local($ntype); - - $type = TidyType($type) ; + my $argsref = shift; + my ($type, $num, $var, $do_setmagic, $do_push) = ( + $argsref->{type}, + $argsref->{num}, + $argsref->{var}, + $argsref->{do_setmagic}, + $argsref->{do_push} + ); + my $arg = "ST(" . ($num - ($num != 0)) . ")"; + my $ntype; + + my $typemaps = $self->{typemap}; + + $type = tidy_type($type); if ($type =~ /^array\(([^,]*),(.*)\)/) { print "\t$arg = sv_newmortal();\n"; print "\tsv_setpvn($arg, (char *)$var, $2 * sizeof($1));\n"; print "\tSvSETMAGIC($arg);\n" if $do_setmagic; - } else { - blurt("Error: '$type' not in typemap"), return - unless defined($type_kind{$type}); - blurt("Error: No OUTPUT definition for type '$type', typekind '$type_kind{$type}' found"), return - unless defined $output_expr{$type_kind{$type}} ; + } + else { + my $typemap = $typemaps->get_typemap(ctype => $type); + $self->report_typemap_failure($typemaps, $type), return + if not $typemap; + my $outputmap = $typemaps->get_outputmap(xstype => $typemap->xstype); + $self->blurt("Error: No OUTPUT definition for type '$type', typekind '" . $typemap->xstype . "' found"), return + unless $outputmap; ($ntype = $type) =~ s/\s*\*/Ptr/g; $ntype =~ s/\(\)//g; + my $subtype; ($subtype = $ntype) =~ s/(?:Array)?(?:Ptr)?$//; - $expr = $output_expr{$type_kind{$type}}; + + my $expr = $outputmap->cleaned_code; if ($expr =~ /DO_ARRAY_ELEM/) { - blurt("Error: '$subtype' not in typemap"), return - unless defined($type_kind{$subtype}); - blurt("Error: No OUTPUT definition for type '$subtype', typekind '$type_kind{$subtype}' found"), return - unless defined $output_expr{$type_kind{$subtype}} ; - $subexpr = $output_expr{$type_kind{$subtype}}; + my $subtypemap = $typemaps->get_typemap(ctype => $subtype); + $self->report_typemap_failure($typemaps, $subtype), return + if not $subtypemap; + my $suboutputmap = $typemaps->get_outputmap(xstype => $subtypemap->xstype); + $self->blurt("Error: No OUTPUT definition for type '$subtype', typekind '" . $subtypemap->xstype . "' found"), return + unless $suboutputmap; + my $subexpr = $suboutputmap->cleaned_code; $subexpr =~ s/ntype/subtype/g; $subexpr =~ s/\$arg/ST(ix_$var)/g; - $subexpr =~ s/\$var/${var}[ix_$var]/g; + $subexpr =~ s/\$var/${var}\[ix_$var]/g; $subexpr =~ s/\n\t/\n\t\t/g; $expr =~ s/DO_ARRAY_ELEM\n/$subexpr/; eval "print qq\a$expr\a"; - warn $@ if $@; + warn $@ if $@; print "\t\tSvSETMAGIC(ST(ix_$var));\n" if $do_setmagic; - } elsif ($var eq 'RETVAL') { + } + elsif ($var eq 'RETVAL') { if ($expr =~ /^\t\$arg = new/) { - # We expect that $arg has refcnt 1, so we need to - # mortalize it. - eval "print qq\a$expr\a"; - warn $@ if $@; - print "\tsv_2mortal(ST($num));\n"; - print "\tSvSETMAGIC(ST($num));\n" if $do_setmagic; - } elsif ($expr =~ /^\s*\$arg\s*=/) { - # We expect that $arg has refcnt >=1, so we need - # to mortalize it! - eval "print qq\a$expr\a"; - warn $@ if $@; - print "\tsv_2mortal(ST(0));\n"; - print "\tSvSETMAGIC(ST(0));\n" if $do_setmagic; - } else { - # Just hope that the entry would safely write it - # over an already mortalized value. By - # coincidence, something like $arg = &sv_undef - # works too. - print "\tST(0) = sv_newmortal();\n"; - eval "print qq\a$expr\a"; - warn $@ if $@; - # new mortals don't have set magic + # We expect that $arg has refcnt 1, so we need to + # mortalize it. + eval "print qq\a$expr\a"; + warn $@ if $@; + print "\tsv_2mortal(ST($num));\n"; + print "\tSvSETMAGIC(ST($num));\n" if $do_setmagic; + } + elsif ($expr =~ /^\s*\$arg\s*=/) { + # We expect that $arg has refcnt >=1, so we need + # to mortalize it! + eval "print qq\a$expr\a"; + warn $@ if $@; + print "\tsv_2mortal(ST(0));\n"; + print "\tSvSETMAGIC(ST(0));\n" if $do_setmagic; + } + else { + # Just hope that the entry would safely write it + # over an already mortalized value. By + # coincidence, something like $arg = &sv_undef + # works too. + print "\tST(0) = sv_newmortal();\n"; + eval "print qq\a$expr\a"; + warn $@ if $@; + # new mortals don't have set magic } - } elsif ($do_push) { + } + elsif ($do_push) { print "\tPUSHs(sv_newmortal());\n"; $arg = "ST($num)"; eval "print qq\a$expr\a"; - warn $@ if $@; + warn $@ if $@; print "\tSvSETMAGIC($arg);\n" if $do_setmagic; - } elsif ($arg =~ /^ST\(\d+\)$/) { + } + elsif ($arg =~ /^ST\(\d+\)$/) { eval "print qq\a$expr\a"; - warn $@ if $@; + warn $@ if $@; print "\tSvSETMAGIC($arg);\n" if $do_setmagic; } } } -sub map_type { - my($type, $varname) = @_; - - # C++ has :: in types too so skip this - $type =~ tr/:/_/ unless $hiertype; - $type =~ s/^array\(([^,]*),(.*)\).*/$1 */s; - if ($varname) { - if ($varname && $type =~ / \( \s* \* (?= \s* \) ) /xg) { - (substr $type, pos $type, 0) = " $varname "; - } else { - $type .= "\t$varname"; - } - } - $type; -} - - -######################################################### -package - ExtUtils::ParseXS::CountLines; -use strict; -use vars qw($SECTION_END_MARKER); - -sub TIEHANDLE { - my ($class, $cfile, $fh) = @_; - $cfile =~ s/\\/\\\\/g; - $SECTION_END_MARKER = qq{#line --- "$cfile"}; - - return bless {buffer => '', - fh => $fh, - line_no => 1, - }, $class; -} - -sub PRINT { - my $self = shift; - for (@_) { - $self->{buffer} .= $_; - while ($self->{buffer} =~ s/^([^\n]*\n)//) { - my $line = $1; - ++ $self->{line_no}; - $line =~ s|^\#line\s+---(?=\s)|#line $self->{line_no}|; - print {$self->{fh}} $line; - } - } -} - -sub PRINTF { - my $self = shift; - my $fmt = shift; - $self->PRINT(sprintf($fmt, @_)); -} - -sub DESTROY { - # Not necessary if we're careful to end with a "\n" - my $self = shift; - print {$self->{fh}} $self->{buffer}; -} - -sub UNTIE { - # This sub does nothing, but is necessary for references to be released. -} - -sub end_marker { - return $SECTION_END_MARKER; -} - - 1; -__END__ - -=head1 NAME - -ExtUtils::ParseXS - converts Perl XS code into C code - -=head1 SYNOPSIS - - use ExtUtils::ParseXS qw(process_file); - - process_file( filename => 'foo.xs' ); - - process_file( filename => 'foo.xs', - output => 'bar.c', - 'C++' => 1, - typemap => 'path/to/typemap', - hiertype => 1, - except => 1, - prototypes => 1, - versioncheck => 1, - linenumbers => 1, - optimize => 1, - prototypes => 1, - ); -=head1 DESCRIPTION - -C<ExtUtils::ParseXS> will compile XS code into C code by embedding the constructs -necessary to let C functions manipulate Perl values and creates the glue -necessary to let Perl access those functions. The compiler uses typemaps to -determine how to map C function parameters and variables to Perl values. - -The compiler will search for typemap files called I<typemap>. It will use -the following search path to find default typemaps, with the rightmost -typemap taking precedence. - - ../../../typemap:../../typemap:../typemap:typemap - -=head1 EXPORT - -None by default. C<process_file()> may be exported upon request. - - -=head1 FUNCTIONS - -=over 4 - -=item process_xs() - -This function processes an XS file and sends output to a C file. -Named parameters control how the processing is done. The following -parameters are accepted: - -=over 4 - -=item B<C++> - -Adds C<extern "C"> to the C code. Default is false. - -=item B<hiertype> - -Retains C<::> in type names so that C++ hierarchical types can be -mapped. Default is false. - -=item B<except> - -Adds exception handling stubs to the C code. Default is false. - -=item B<typemap> - -Indicates that a user-supplied typemap should take precedence over the -default typemaps. A single typemap may be specified as a string, or -multiple typemaps can be specified in an array reference, with the -last typemap having the highest precedence. - -=item B<prototypes> - -Generates prototype code for all xsubs. Default is false. - -=item B<versioncheck> - -Makes sure at run time that the object file (derived from the C<.xs> -file) and the C<.pm> files have the same version number. Default is -true. - -=item B<linenumbers> - -Adds C<#line> directives to the C output so error messages will look -like they came from the original XS file. Default is true. - -=item B<optimize> - -Enables certain optimizations. The only optimization that is currently -affected is the use of I<target>s by the output C code (see L<perlguts>). -Not optimizing may significantly slow down the generated code, but this is the way -B<xsubpp> of 5.005 and earlier operated. Default is to optimize. - -=item B<inout> - -Enable recognition of C<IN>, C<OUT_LIST> and C<INOUT_LIST> -declarations. Default is true. - -=item B<argtypes> - -Enable recognition of ANSI-like descriptions of function signature. -Default is true. - -=item B<s> - -I have no clue what this does. Strips function prefixes? - -=back - -=item errors() - -This function returns the number of [a certain kind of] errors -encountered during processing of the XS file. - -=back - -=head1 AUTHOR - -Based on xsubpp code, written by Larry Wall. - -Maintained by: - -=over 4 - -=item * - -Ken Williams, <ken@mathforum.org> - -=item * - -David Golden, <dagolden@cpan.org> - -=back - -=head1 COPYRIGHT - -Copyright 2002-2009 by Ken Williams, David Golden and other contributors. All -rights reserved. - -This library is free software; you can redistribute it and/or -modify it under the same terms as Perl itself. - -Based on the ExtUtils::xsubpp code by Larry Wall and the Perl 5 -Porters, which was released under the same license terms. - -=head1 SEE ALSO - -L<perl>, ExtUtils::xsubpp, ExtUtils::MakeMaker, L<perlxs>, L<perlxstut>. -=cut +# vim: ts=2 sw=2 et: |