The OpenNET Project / Index page

[ новости /+++ | форум | теги | ]

Интерактивная система просмотра системных руководств (man-ов)

 ТемаНаборКатегория 
 
 [Cписок руководств | Печать]

h2xs (1)
  • >> h2xs (1) ( Solaris man: Команды и прикладные программы пользовательского уровня )
  • h2xs (1) ( Linux man: Команды и прикладные программы пользовательского уровня )
  • 
    
    

    NAME

         h2xs - convert .h C header files to Perl extensions
    
    
    

    SYNOPSIS

         h2xs [-ACOPXcdf] [-v version] [-n module_name] [-p prefix]
         [-s sub] [headerfile ... [extra_libraries]]
    
         h2xs -h
    
    
    

    DESCRIPTION

         h2xs builds a Perl extension from C header files.  The
         extension will include functions which can be used to
         retrieve the value of any #define statement which was in the
         C header files.
    
         The module_name will be used for the name of the extension.
         If module_name is not supplied then the name of the first
         header file will be used, with the first character
         capitalized.
    
         If the extension might need extra libraries, they should be
         included here.  The extension Makefile.PL will take care of
         checking whether the libraries actually exist and how they
         should be loaded.  The extra libraries should be specified
         in the form -lm -lposix, etc, just as on the cc command
         line.  By default, the Makefile.PL will search through the
         library path determined by Configure.  That path can be
         augmented by including arguments of the form
         -L/another/library/path in the extra-libraries argument.
    
    
    

    OPTIONS

         -A   Omit all autoload facilities.  This is the same as -c
              but also removes the `use AutoLoader' statement from
              the .pm file.
    
         -C   Omits creation of the Changes file, and adds a HISTORY
              section to the POD template.
    
         -F   Additional flags to specify to C preprocessor when
              scanning header for function declarations.  Should not
              be used without -x.
    
         -M regular expression
              selects functions/macros to process.
    
         -O   Allows a pre-existing extension directory to be
              overwritten.
    
         -P   Omit the autogenerated stub POD section.
    
         -X   Omit the XS portion.  Used to generate templates for a
              module which is not XS-based.  `-c' and `-f' are
              implicitly enabled.
    
         -a   Generate an accessor method for each element of structs
              and unions. The generated methods are named after the
              element name; will return the current value of the
              element if called without additional arguments; and
              will set the element to the supplied value (and return
              the new value) if called with an additional argument.
              Embedded structures and unions are returned as a
              pointer rather than the complete structure, to
              facilitate chained calls.
    
              These methods all apply to the Ptr type for the
              structure; additionally two methods are constructed for
              the structure type itself, `_to_ptr' which returns a
              Ptr type pointing to the same structure, and a `new'
              method to construct and return a new structure,
              initialised to zeroes.
    
         -c   Omit `constant()' from the .xs file and corresponding
              specialised `AUTOLOAD' from the .pm file.
    
         -d   Turn on debugging messages.
    
         -f   Allows an extension to be created for a header even if
              that header is not found in standard include
              directories.
    
         -h   Print the usage, help and version for this h2xs and
              exit.
    
         -k   For function arguments declared as `const', omit the
              const attribute in the generated XS code.
    
         -m   Experimental: for each variable declared in the header
              file(s), declare a perl variable of the same name
              magically tied to the C variable.
    
         -n module_name
              Specifies a name to be used for the extension, e.g.,
              -n RPC::DCE
    
         -o regular expression
              Use "opaque" data type for the C types matched by the
              regular expression, even if these types are
              `typedef'-equivalent to types from typemaps.  Should
              not be used without -x.
    
              This may be useful since, say, types which are
              `typedef'-equivalent to integers may represent OS-
              related handles, and one may want to work with these
              handles in OO-way, as in `$handle->do_something()'.
              Use `-o .' if you want to handle all the `typedef'ed
              types as opaque types.
    
              The type-to-match is whitewashed (except for commas,
              which have no whitespace before them, and multiple `*'
              which have no whitespace between them).
    
         -p prefix
              Specify a prefix which should be removed from the Perl
              function names, e.g., -p sec_rgy_ This sets up the XS
              PREFIX keyword and removes the prefix from functions
              that are autoloaded via the `constant()' mechanism.
    
         -s sub1,sub2
              Create a perl subroutine for the specified macros
              rather than autoload with the constant() subroutine.
              These macros are assumed to have a return type of char
              *, e.g., -s sec_rgy_wildcard_name,sec_rgy_wildcard_sid.
    
         -v version
              Specify a version number for this extension.  This
              version number is added to the templates.  The default
              is 0.01.
    
         -x   Automatically generate XSUBs basing on function
              declarations in the header file.  The package `C::Scan'
              should be installed. If this option is specified, the
              name of the header file may look like `NAME1,NAME2'. In
              this case NAME1 is used instead of the specified
              string, but XSUBs are emitted only for the declarations
              included from file NAME2.
    
              Note that some types of arguments/return-values for
              functions may result in XSUB-declarations/typemap-
              entries which need hand-editing. Such may be objects
              which cannot be converted from/to a pointer (like `long
              long'), pointers to functions, or arrays.  See also the
              section on the LIMITATIONS of -x entry elsewhere in
              this document.
    
    
    

    EXAMPLES

                 # Default behavior, extension is Rusers
                 h2xs rpcsvc/rusers
    
                 # Same, but extension is RUSERS
                 h2xs -n RUSERS rpcsvc/rusers
    
                 # Extension is rpcsvc::rusers. Still finds <rpcsvc/rusers.h>
                 h2xs rpcsvc::rusers
    
                 # Extension is ONC::RPC.  Still finds <rpcsvc/rusers.h>
                 h2xs -n ONC::RPC rpcsvc/rusers
                 # Without constant() or AUTOLOAD
                 h2xs -c rpcsvc/rusers
    
                 # Creates templates for an extension named RPC
                 h2xs -cfn RPC
    
                 # Extension is ONC::RPC.
                 h2xs -cfn ONC::RPC
    
                 # Makefile.PL will look for library -lrpc in
                 # additional directory /opt/net/lib
                 h2xs rpcsvc/rusers -L/opt/net/lib -lrpc
    
                 # Extension is DCE::rgynbase
                 # prefix "sec_rgy_" is dropped from perl function names
                 h2xs -n DCE::rgynbase -p sec_rgy_ dce/rgynbase
    
                 # Extension is DCE::rgynbase
                 # prefix "sec_rgy_" is dropped from perl function names
                 # subroutines are created for sec_rgy_wildcard_name and sec_rgy_wildcard_sid
                 h2xs -n DCE::rgynbase -p sec_rgy_ \
                 -s sec_rgy_wildcard_name,sec_rgy_wildcard_sid dce/rgynbase
    
                 # Make XS without defines in perl.h, but with function declarations
                 # visible from perl.h. Name of the extension is perl1.
                 # When scanning perl.h, define -DEXT=extern -DdEXT= -DINIT(x)=
                 # Extra backslashes below because the string is passed to shell.
                 # Note that a directory with perl header files would
                 #  be added automatically to include path.
                 h2xs -xAn perl1 -F "-DEXT=extern -DdEXT= -DINIT\(x\)=" perl.h
    
                 # Same with function declaration in proto.h as visible from perl.h.
                 h2xs -xAn perl2 perl.h,proto.h
    
                 # Same but select only functions which match /^av_/
                 h2xs -M '^av_' -xAn perl2 perl.h,proto.h
    
                 # Same but treat SV* etc as "opaque" types
                 h2xs -o '^[S]V \*$' -M '^av_' -xAn perl2 perl.h,proto.h
    
    
    
    

    ENVIRONMENT

         No environment variables are used.
    
    
    

    AUTHOR

         Larry Wall and others
    
    
    

    SEE ALSO

         the perl manpage, the perlxstut manpage, the
         ExtUtils::MakeMaker manpage, and the AutoLoader manpage.
    
    
    
    

    DIAGNOSTICS

         The usual warnings if it cannot read or write the files
         involved.
    
    
    

    LIMITATIONS of -x

         h2xs would not distinguish whether an argument to a C
         function which is of the form, say, `int *', is an input,
         output, or input/output parameter.  In particular, argument
         declarations of the form
    
             int
             foo(n)
                 int *n
    
         should be better rewritten as
    
             int
             foo(n)
                 int &n
    
         if `n' is an input parameter.
    
         Additionally, h2xs has no facilities to intuit that a
         function
    
            int
            foo(addr,l)
                 char *addr
                 int   l
    
         takes a pair of address and length of data at this address,
         so it is better to rewrite this function as
    
             int
             foo(sv)
                     SV *addr
                 PREINIT:
                     STRLEN len;
                     char *s;
                 CODE:
                     s = SvPV(sv,len);
                     RETVAL = foo(s, len);
                 OUTPUT:
                     RETVAL
    
         or alternately
    
             static int
             my_foo(SV *sv)
             {
                 STRLEN len;
                 char *s = SvPV(sv,len);
                 return foo(s, len);
             }
    
             MODULE = foo        PACKAGE = foo   PREFIX = my_
    
             int
             foo(sv)
                 SV *sv
    
         See the perlxs manpage and the perlxstut manpage for
         additional details.
    
    
    

    HISTORY

         $TEMPLATE_VERSION
                 Original version; created by h2xs $H2XS_VERSION with
                 options
    
                   @ARGS
    
    
         EOT
    
         my $exp_doc = <<EOD;
    
         EXPORT
    
         None by default.
    
         EOD if (@const_names and not $opt_P) {
           $exp_doc .= <<EOD; =head2 Exportable constants
    
           @{[join "\n  ", @const_names]}
    
         EOD } if (defined $fdecls and @$fdecls and not $opt_P) {
           $exp_doc .= <<EOD; =head2 Exportable functions
    
         EOD
           $exp_doc .= <<EOD if $opt_p; When accessing these
         functions from Perl, prefix `$opt_p' should be removed.
    
         EOD
           $exp_doc .= <<EOD;
           @{[join "\n  ", @known_fnames{@fnames}]}
    
         EOD }
    
         my $pod = <<"END" unless $opt_P; ## Below is stub
         documentation for your module. You better edit it!  #
         #=head1 NAME # #$module - Perl extension for blah blah blah
         # #=head1 SYNOPSIS # #  use $module; #  blah blah blah #
         #=head1 DESCRIPTION # #Stub documentation for $module,
         created by h2xs. It looks like the #author of the extension
         was negligent enough to leave the stub #unedited.  # #Blah
         blah blah.  #$exp_doc$revhist #=head1 AUTHOR # #$author,
         $email # #=head1 SEE ALSO # #perl(1).  # #=cut END
    
         $pod =~ s/^\#//gm unless $opt_P; print PM $pod unless
         $opt_P;
    
         close PM;
    
         if( ! $opt_X ){ # print XS, unless it is disabled warn
         "Writing $ext$modpname/$modfname.xs\n";
    
         print XS <<"END"; #include "EXTERN.h" #include "perl.h"
         #include "XSUB.h"
    
         END if( @path_h ){
             foreach my $path_h (@path_h_ini) {      my($h) =
         $path_h;      $h =~ s#^/usr/include/##;      if ($^O eq
         'VMS') { $h =~ s#.*vms\]#sys/# or $h =~ s#.*[:>\]]##; }
                 print XS qq{#include <$h>\n};
             }
             print XS "\n"; }
    
         my %pointer_typedefs; my %struct_typedefs;
    
         sub td_is_pointer {
           my $type = shift;
           my $out = $pointer_typedefs{$type};
           return $out if defined $out;
           my $otype = $type;
           $out = ($type =~ /\*$/);
           # This converts only the guys which do not have trailing
         part in the typedef
           if (not $out
               and $typedef_rex and $type =~
         s/($typedef_rex)/$typedefs_pre{$1}/go) {
             $type = normalize_type($type);
             print "Is-Pointer: Type mutation via typedefs: $otype
         ==> $type\n"
               if $opt_d;
             $out = td_is_pointer($type);
           }
           return ($pointer_typedefs{$otype} = $out); }
    
         sub td_is_struct {
           my $type = shift;
           my $out = $struct_typedefs{$type};
           return $out if defined $out;
           my $otype = $type;
           $out = ($type =~ /^(struct|union)\b/) &&
         !td_is_pointer($type);
           # This converts only the guys which do not have trailing
    
         part in the typedef
           if (not $out
               and $typedef_rex and $type =~
         s/($typedef_rex)/$typedefs_pre{$1}/go) {
             $type = normalize_type($type);
             print "Is-Struct: Type mutation via typedefs: $otype ==>
         $type\n"
               if $opt_d;
             $out = td_is_struct($type);
           }
           return ($struct_typedefs{$otype} = $out); }
    
         # Some macros will bomb if you try to return them from a
         double-returning func.  # Say, ((char *)0), or strlen (if
         somebody #define STRLEN strlen).  # Fortunately, we can
         detect both these cases...  sub protect_convert_to_double {
           my $in = shift;
           my $val;
           return '' unless defined ($val = $seen_define{$in});
           return '(IV)' if $known_fnames{$val};
           # OUT_t of ((OUT_t)-1):
           return '' unless $val =~
         /^\s*(\(\s*)?\(\s*([^()]*?)\s*\)/;
           td_is_pointer($2) ? '(IV)' : ''; }
    
         # For each of the generated functions, length($pref) leading
         # letters are already checked.  Moreover, it is recommended
         that # the generated functions uses switch on letter at
         offset at least # $off + length($pref).  # # The given list
         has length($pref) chars removed at front, it is # guarantied
         that $off leading chars in the rest are the same for all #
         elts of the list.  # # Returns: how at which offset it was
         decided to make a switch, or -1 if none.
    
         sub write_const;
    
         sub write_const {
           my ($fh, $pref, $off, $list) = (shift,shift,shift,shift);
           my %leading;
           my $offarg = length $pref;
    
           if (@$list == 0) {            # Can happen on the initial iteration only
             print $fh <<"END";
         static double
         constant(char *name, int len, int arg)
         {
             errno = EINVAL;
             return 0;
         }
         END
             return -1;
           }
           if (@$list == 1) {            # Can happen on the initial iteration only
             my $protect = protect_convert_to_double("$pref$list->[0]");
    
             print $fh <<"END";
         static double
         constant(char *name, int len, int arg)
         {
             errno = 0;
             if (strEQ(name + $offarg, "$list->[0]")) {  /* $pref removed */
         #ifdef $pref$list->[0]
                 return $protect$pref$list->[0];
         #else
                 errno = ENOENT;
                 return 0;
         #endif
             }
             errno = EINVAL;
             return 0;
         }
         END
             return -1;
           }
    
           for my $n (@$list) {
             my $c = substr $n, $off, 1;
             $leading{$c} = [] unless exists $leading{$c};
             push @{$leading{$c}}, substr $n, $off + 1;
           }
    
           if (keys(%leading) == 1) {
             return 1 + write_const $fh, $pref, $off + 1, $list;
           }
    
           my $leader = substr $list->[0], 0, $off;
           foreach my $letter (keys %leading) {
             write_const $fh, "$pref$leader$letter", 0, $leading{$letter}
               if @{$leading{$letter}} > 1;
           }
    
           my $npref = "_$pref";
           $npref = '' if $pref eq '';
    
           print $fh <<"END";
         static double
         constant$npref(char *name, int len, int arg)
         {
         END
    
           print $fh <<"END" if $npref eq '';
             errno = 0;
         END
    
           print $fh <<"END" if $off;
             if ($offarg + $off >= len ) {
                 errno = EINVAL;
                 return 0;
             }
         END
    
           print $fh <<"END";
             switch (name[$offarg + $off]) {
         END
    
           foreach my $letter (sort keys %leading) {
             my $let = $letter;
             $let = '\0' if $letter eq '';
    
             print $fh <<EOP;
             case '$let':
         EOP
             if (@{$leading{$letter}} > 1) {
               # It makes sense to call a function
               if ($off) {
                 print $fh <<EOP;
                 if (!strnEQ(name + $offarg,"$leader", $off))
                     break;
         EOP
               }
               print $fh <<EOP;
                 return constant_$pref$leader$letter(name, len, arg);
         EOP
             }
             else {
               # Do it ourselves
               my $protect
                 = protect_convert_to_double("$pref$leader$letter$leading{$letter}[0]");
    
               print $fh <<EOP;
                 if (strEQ(name + $offarg, "$leader$letter$leading{$letter}[0]")) {      /* $pref removed */
         #ifdef $pref$leader$letter$leading{$letter}[0]
                     return $protect$pref$leader$letter$leading{$letter}[0];
         #else
                     goto not_there;
         #endif
                 }
         EOP
             }
           }
           print $fh <<"END";
             }
             errno = EINVAL;
             return 0;
    
         not_there:
             errno = ENOENT;
             return 0; }
    
         END
    
         }
    
         if( ! $opt_c ) {
           print XS <<"END"; static int not_here(char *s) {
             croak("$module::%s not implemented on this
         architecture", s);
             return -1; }
    
         END
    
           write_const(\*XS, '', 0, \@const_names);
         }
    
         print_tievar_subs(\*XS, $_, $vdecl_hash{$_}) for @vdecls;
    
         my $prefix; $prefix = "PREFIX = $opt_p" if defined $opt_p;
    
         # Now switch from C to XS by issuing the first MODULE
         declaration:  print XS <<"END";
    
         MODULE = $module         PACKAGE = $module        $prefix
    
         END
    
         foreach (sort keys %const_xsub) {
             print XS <<"END"; char * $_()
    
             CODE:
         #ifdef $_
                 RETVAL = $_;
         #else
                 croak("Your vendor has not defined the $module macro $_");
         #endif
    
             OUTPUT:
                 RETVAL
    
         END }
    
         # If a constant() function was written then output a
         corresponding # XS declaration:  print XS <<"END" unless
         $opt_c;
    
         double constant(sv,arg)
             PREINIT:       STRLEN         len;
             INPUT:       SV *      sv      char *         s =
         SvPV(sv, len);      int       arg
             CODE:       RETVAL = constant(s,len,arg);
             OUTPUT:       RETVAL
    
         END
    
         my %seen_decl; my %typemap;
    
         sub print_decl {
           my $fh = shift;
           my $decl = shift;
           my ($type, $name, $args) = @$decl;
           return if $seen_decl{$name}++; # Need to do the same for
         docs as well?
    
           my @argnames = map {$_->[1]} @$args;
           my @argtypes = map { normalize_type( $_->[0], 1 ) } @$args;
           if ($opt_k) {
             s/^\s*const\b\s*// for @argtypes;
           }
           my @argarrays = map { $_->[4] || '' } @$args;
           my $numargs = @$args;
           if ($numargs and $argtypes[-1] eq '...') {
             $numargs--;
             $argnames[-1] = '...';
           }
           local $" = ', ';
           $type = normalize_type($type, 1);
    
           print $fh <<"EOP";
    
         $type $name(@argnames) EOP
    
           for my $arg (0 .. $numargs - 1) {
             print $fh <<"EOP";
                 $argtypes[$arg] $argnames[$arg]$argarrays[$arg]
         EOP
           }
         }
    
         sub print_tievar_subs {
           my($fh, $name, $type) = @_;
           print $fh <<END; I32 _get_$name(IV index, SV *sv) {
             dSP;
             PUSHMARK(SP);
             XPUSHs(sv);
             PUTBACK;
             (void)call_pv("$module\::_get_$name", G_DISCARD);
             return (I32)0; }
    
         I32 _set_$name(IV index, SV *sv) {
             dSP;
             PUSHMARK(SP);
             XPUSHs(sv);
             PUTBACK;
             (void)call_pv("$module\::_set_$name", G_DISCARD);
             return (I32)0; }
    
         END }
    
         sub print_tievar_xsubs {
           my($fh, $name, $type) = @_;
           print $fh <<END; void _tievar_$name(sv)      SV* sv
             PREINIT:       struct ufuncs uf;
             CODE:       uf.uf_val = &_get_$name;      uf.uf_set =
         &_set_$name;      uf.uf_index = (IV)&_get_$name;
              sv_magic(sv, 0, 'U', (char*)&uf, sizeof(uf));
    
         void _get_$name(THIS)      $type THIS = NO_INIT
             CODE:       THIS = $name;
             OUTPUT:       SETMAGIC: DISABLE      THIS
    
         void _set_$name(THIS)      $type THIS
             CODE:       $name = THIS;
    
         END }
    
         sub print_accessors {
           my($fh, $name, $struct) = @_;
           return unless defined $struct && $name !~ /\s|_ANON/;
           $name = normalize_type($name);
           my $ptrname = normalize_type("$name *");
           print $fh <<"EOF";
    
         MODULE = $module         PACKAGE = ${name}        $prefix
    
         $name * _to_ptr(THIS)      $name THIS = NO_INIT
             PROTOTYPE: \$
             CODE:       if (sv_derived_from(ST(0), "$name")) {
         STRLEN len;          char *s = SvPV((SV*)SvRV(ST(0)), len);
                  if (len != sizeof(THIS))           croak("Size \%d
         of packed data != expected \%d",                len,
         sizeof(THIS));          RETVAL = ($name *)s;      }
              else          croak("THIS is not of type $name");
             OUTPUT:       RETVAL
    
         $name new(CLASS)      char *CLASS = NO_INIT
             PROTOTYPE: \$
             CODE:       Zero((void*)&RETVAL, sizeof(RETVAL), char);
             OUTPUT:       RETVAL
    
         MODULE = $module         PACKAGE =
         ${name}Ptr          $prefix
    
    
         EOF
           my @items = @$struct;
           while (@items) {
             my $item = shift @items;
             if ($item->[0] =~ /_ANON/) {
               if (defined $item->[2]) {      push @items, map [
                @$_[0, 1], "$item->[2]_$_->[2]", "$item-
         >[2].$_->[2]",      ], @{ $structs{$item->[0]} };
               } else {      push @items, @{ $structs{$item->[0]} };
               }
             } else {
               my $type = normalize_type($item->[0]);
               my $ttype = $structs{$type} ? normalize_type("$type
         *") : $type;
               print $fh <<"EOF"; $ttype $item->[2](THIS, __value =
         NO_INIT)      $ptrname THIS      $type __value
             PROTOTYPE: \$;\$
             CODE:       if (items > 1)          THIS->$item->[-1] =
         __value;      RETVAL = @{[          $type eq $ttype ?
         "THIS->$item->[-1]" : "&(THIS->$item->[-1])"      ]};
             OUTPUT:       RETVAL
    
         EOF
             }
           } }
    
         # Should be called before any actual call to
         normalize_type().  sub get_typemap {
           # We do not want to read ./typemap by obvios reasons.
           my @tm =  qw(../../../typemap ../../typemap ../typemap);
           my $stdtypemap =
         "$Config::Config{privlib}/ExtUtils/typemap";
           unshift @tm, $stdtypemap;
           my $proto_re = "[" . quotemeta('\$%&*@;') . "]" ;
    
           # Start with useful default values
           $typemap{float} = 'T_DOUBLE';
    
    
    
           foreach my $typemap (@tm) {
             next unless -e $typemap ;
             # skip directories, binary files etc.
             warn " Scanning $typemap\n";
             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';
             while (<TYPEMAP>) {
               next if /^\s*\#/;
               if (/^INPUT\s*$/)   { $mode = 'Input'; next; }
               elsif (/^OUTPUT\s*$/)  { $mode = 'Output'; next; }
               elsif (/^TYPEMAP\s*$/) { $mode = 'Typemap'; next; }
               elsif ($mode eq 'Typemap') {
                 next if /^\s*($|\#)/ ;
                 my ($type, $image);
                 if ( ($type, $image) =
                      /^\s*(.*?\S)\s+(\S+)\s*($proto_re*)\s*$/o
                      # This may reference undefined functions:
                      and not ($image eq 'T_PACKED' and $typemap eq $stdtypemap)) {
                   $typemap{normalize_type($type)} = $image;
                 }
               }
             }
             close(TYPEMAP) or die "Cannot close $typemap: $!";
           }
           %std_types = %types_seen;
           %types_seen = ();
         }
    
         sub normalize_type {          # Second arg: do not strip
         const's before \*
           my $type = shift;
           my $do_keep_deep_const = shift;
           # If $do_keep_deep_const this is heuristical only
           my $keep_deep_const = ($do_keep_deep_const ?
         '\b(?![^(,)]*\*)' : '');
           my $ignore_mods
             =
         "(?:\\b(?:(?:__const__|const)$keep_deep_const|static|inline|__inline__)\\b\\s*)*";
           if ($do_keep_deep_const) {  # Keep different compiled
         /RExen/o separately!
             $type =~ s/$ignore_mods//go;
           }
           else {
             $type =~ s/$ignore_mods//go;
           }
           $type =~ s/([^\s\w])/ \1 /g;
           $type =~ s/\s+$//;
           $type =~ s/^\s+//;
           $type =~ s/\s+/ /g;
           $type =~ s/\* (?=\*)/*/g;
           $type =~ s/\. \. \./.../g;
           $type =~ s/ ,/,/g;
           $types_seen{$type}++
             unless $type eq '...' or $type eq 'void' or
         $std_types{$type};
           $type; }
    
         my $need_opaque;
    
         sub assign_typemap_entry {
           my $type = shift;
           my $otype = $type;
           my $entry;
           if ($tmask and $type =~ /$tmask/) {
             print "Type $type matches -o mask\n" if $opt_d;
             $entry = (td_is_struct($type) ? "T_OPAQUE_STRUCT" :
         "T_PTROBJ");
           }
           elsif ($typedef_rex and $type =~
         s/($typedef_rex)/$typedefs_pre{$1}/go) {
             $type = normalize_type $type;
             print "Type mutation via typedefs: $otype ==> $type\n"
         if $opt_d;
             $entry = assign_typemap_entry($type);
           }
           $entry ||= $typemap{$otype}
             || (td_is_struct($type) ? "T_OPAQUE_STRUCT" :
         "T_PTROBJ");
           $typemap{$otype} = $entry;
           $need_opaque = 1 if $entry eq "T_OPAQUE_STRUCT";
           return $entry; }
    
         for (@vdecls) {
           print_tievar_xsubs(\*XS, $_, $vdecl_hash{$_}); }
    
         if ($opt_x) {
           for my $decl (@$fdecls_parsed) { print_decl(\*XS, $decl) }
           if ($opt_a) {
             while (my($name, $struct) = each %structs) {
               print_accessors(\*XS, $name, $struct);
             }
           } }
    
         close XS;
    
         if (%types_seen) {
           my $type;
           warn "Writing $ext$modpname/typemap\n";
           open TM, ">typemap" or die "Cannot open typemap file for
         write: $!";
    
           for $type (sort keys %types_seen) {
             my $entry = assign_typemap_entry $type;
             print TM $type, "\t" x (5 - int((length $type)/8)), "\t$entry\n"
           }
    
           print TM <<'EOP' if $need_opaque; # Older Perls do not have correct entry
         #############################################################################
         INPUT
         T_OPAQUE_STRUCT
                 if (sv_derived_from($arg, \"${ntype}\")) {
                     STRLEN len;
                     char  *s = SvPV((SV*)SvRV($arg), len);
    
                     if (len != sizeof($var))
                         croak(\"Size %d of packed data != expected %d\",
                                 len, sizeof($var));
                     $var = *($type *)s;
                 }
                 else
                     croak(\"$var is not of type ${ntype}\")
         #############################################################################
         OUTPUT
         T_OPAQUE_STRUCT
                 sv_setref_pvn($arg, \"${ntype}\", (char *)&$var, sizeof($var));
         EOP
    
           close TM or die "Cannot close typemap file for write: $!";
         }
    
         } # if( ! $opt_X )
    
         warn "Writing $ext$modpname/Makefile.PL\n"; open(PL,
         ">Makefile.PL") || die "Can't create
         $ext$modpname/Makefile.PL: $!\n";
    
         print PL <<END; use ExtUtils::MakeMaker; # See
         lib/ExtUtils/MakeMaker.pm for details of how to influence #
         the contents of the Makefile that is written.
         WriteMakefile(
             'NAME'          => '$module',
             'VERSION_FROM'  => '$modfname.pm', # finds \$VERSION
             'PREREQ_PM'          => {}, # e.g., Module::Name => 1.1
         END if (!$opt_X) { # print C stuff, unless XS is disabled
           $opt_F = '' unless defined $opt_F;
           print PL <<END;
             'LIBS'          => ['$extralibs'], # e.g., '-lm'
             'DEFINE'        => '$opt_F', # e.g., '-DHAVE_SOMETHING'
             'INC'      => '', # e.g., '-I/usr/include/other' END }
         print PL ");\n"; close(PL) || die "Can't close
         $ext$modpname/Makefile.PL: $!\n";
    
    
         warn "Writing $ext$modpname/test.pl\n"; open(EX, ">test.pl")
         || die "Can't create $ext$modpname/test.pl: $!\n"; print EX
         <<'_END_'; # Before `make install' is performed this script
         should be runnable with # `make test'. After `make install'
         it should work as `perl test.pl'
    
         ######################### We start with some black magic to
         print on failure.
    
         # Change 1..1 below to 1..last_test_to_print .  # (It may
         become useful if the test is moved to ./t subdirectory.)
    
         BEGIN { $| = 1; print "1..1\n"; } END {print "not ok 1\n"
         unless $loaded;} _END_ print EX <<_END_; use $module; _END_
         print EX <<'_END_'; $loaded = 1; print "ok 1\n";
    
         ######################### End of black magic.
    
         # Insert your test code below (better if it prints "ok 13" #
         (correspondingly "not ok 13") depending on the success of
         chunk 13 # of the test code):
    
         _END_ close(EX) || die "Can't close $ext$modpname/test.pl:
         $!\n";
    
         unless ($opt_C) {
           warn "Writing $ext$modpname/Changes\n";
           $" = ' ';
           open(EX, ">Changes") || die "Can't create
         $ext$modpname/Changes: $!\n";
           @ARGS = map {/[\s\"\'\`\$*?^|&<>\[\]\{\}\(\)]/ ? "'$_'" :
         $_} @ARGS;
           print EX <<EOP; Revision history for Perl extension
         $module.
    
         $TEMPLATE_VERSION  @{[scalar localtime]} \t- original
         version; created by h2xs $H2XS_VERSION with options
         \t\t@ARGS
    
         EOP
           close(EX) || die "Can't close $ext$modpname/Changes:
         $!\n"; }
    
         warn "Writing $ext$modpname/MANIFEST\n";
         open(MANI,'>MANIFEST') or die "Can't create MANIFEST: $!";
         my @files = <*>; if (!@files) {
           eval {opendir(D,'.');};
           unless ($@) { @files = readdir(D); closedir(D); } } if
         (!@files) { @files = map {chomp && $_} `ls`; } if ($^O eq
         'VMS') {
           foreach (@files) {
             # Clip trailing '.' for portability -- non-VMS OSs don't
    
         expect it
             s%\.$%%;
             # Fix up for case-sensitive file systems
             s/$modfname/$modfname/i && next;
             $_ = "\U$_" if $_ eq 'manifest' or $_ eq 'changes';
             $_ = 'Makefile.PL' if $_ eq 'makefile.pl';
           } } print MANI join("\n",@files), "\n"; close MANI;
    
    
    
    


    Поиск по тексту MAN-ов: 




    Партнёры:
    PostgresPro
    Inferno Solutions
    Hosting by Hoster.ru
    Хостинг:

    Закладки на сайте
    Проследить за страницей
    Created 1996-2024 by Maxim Chirkov
    Добавить, Поддержать, Вебмастеру