NAME¶

Module::Build::WithXSpp - XS++ enhanced flavour of Module::Build

SYNOPSIS¶

In Build.PL:

  use strict;
  use warnings;
  use 5.006001;
  
  use Module::Build::WithXSpp;
  
  my $build = Module::Build::WithXSpp->new(
    # normal Module::Build arguments...
    # optional: mix in some extra C typemaps:
    extra_typemap_modules => {
      'ExtUtils::Typemaps::ObjectMap' => '0',
    },
  );
  $build->create_build_script;

DESCRIPTION¶

This subclass of Module::Build adds some tools and processes to make it easier to use for wrapping C++ using XS++ (ExtUtils::XSpp).

There are a few minor differences from using "Module::Build" for an ordinary XS module and a few conventions that you should be aware of as an XS++ module author. They are documented in the "FEATURES AND CONVENTIONS" section below. But if you can't be bothered to read all that, you may choose skip it and blindly follow the advice in "JUMP START FOR THE IMPATIENT".

An example of a full distribution based on this build tool can be found in the ExtUtils::XSpp distribution under examples/XSpp-Example. Using that example as the basis for your "Module::Build::WithXSpp"-based distribution is probably a good idea.

FEATURES AND CONVENTIONS¶

  #include <something>
  using namespace some::thing;

  #include "mystuff.h"
  
  %{
    ... verbatim XS here ...
  %}

  Module::Build::WithXSpp->new(
    early_includes => [qw(
      "mylocalheader.h"
      <mysystemheader.h>
    )]
  )

JUMP START FOR THE IMPATIENT¶

There are as many ways to start a new CPAN distribution as there are CPAN distributions. Choose your favourite (I just do "h2xs -An My::Module"), then apply a few changes to your setup:

• Obliterate any Makefile.PL.

  This is what your Build.PL should look like:

    use strict;
    use warnings;
    use 5.006001;
    use Module::Build::WithXSpp;
    
    my $build = Module::Build::WithXSpp->new(
      module_name         => 'My::Module',
      license             => 'perl',
      dist_author         => q{John Doe <john_does_mail_address>},
      dist_version_from   => 'lib/My/Module.pm',
      build_requires => { 'Test::More' => 0, },
      extra_typemap_modules => {
        'ExtUtils::Typemaps::ObjectMap' => '0',
        # ...
      },
    );
    $build->create_build_script;
      

  If you need to link against some library "libfoo", add this to the options:

      extra_linker_flags => [qw(-lfoo)],
      

  There is "extra_compiler_flags", too, if you need it.

• You create two folders in the main distribution folder: src and xsp.
• You put any C++ code that you want to build and include in the module into src/. All the typical C(++) file extensions are recognized and will be compiled to object files and linked into the module. And headers in that folder will be accessible for "#include <myheader.h>".

  For good measure, move a copy of ppport.h to that directory. See Devel::PPPort.

• You do not write normal XS files. Instead, you write XS++ and put it into the xsp/ folder in files with the ".xsp" extension. Do not worry, you can include verbatim XS blocks in XS++. For details on XS++, see ExtUtils::XSpp.
• If you need to do any XS type mapping, put your typemaps into a .map file in the "xsp" directory. Alternatively, search CPAN for an appropriate typemap module (cf. ExtUtils::Typemaps::Default for an explanation). XS++ typemaps belong into .xspt files in the same directory.
• In this scheme, lib/ only contains Perl module files (and POD). If you started from a pure-Perl distribution, don't forget to add these magic two lines to your main module:

    require XSLoader;
    XSLoader::load('My::Module', $VERSION);
      

SEE ALSO¶

Module::Build upon which this module is based.

ExtUtils::XSpp implements XS++. The "ExtUtils::XSpp" distribution contains an examples directory with a usage example of this module.

ExtUtils::Typemaps implements progammatic modification (merging) of C/XS typemaps. "ExtUtils::Typemaps" was renamed from "ExtUtils::Typemap" since the original name conflicted with the core typemap file on case-insensitive file systems.

ExtUtils::Typemaps::Default explains the concept of having typemaps shipped as modules.

ExtUtils::Typemaps::ObjectMap is such a typemap module and probably very useful for any XS++ module.

ExtUtils::Typemaps::STL::String implements simple typemapping for STL "std::string"s.

AUTHOR¶

Steffen Mueller <smueller@cpan.org>

With input and bug fixes from:

Mattia Barbon

Shmuel Fomberg

Florian Schlichting

COPYRIGHT AND LICENSE¶

Copyright 2010, 2011, 2012, 2013 Steffen Mueller.

This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself.