/ 
Inline-C2XS-0.07
/ Inline::C2XS

NAME

Inline::C2XS - create an XS file from Inline C code.

SYNOPSIS

use Inline::C2XS qw(c2xs);

my $module_name = 'MY::XS_MOD';
my $package_name = 'MY::XS_MOD';

# $build_dir is an optional third arg
my $build_dir = '/some/where/else';

# $config_opts is an optional fourth arg (hash reference)
my $config_opts = {'AUTOWRAP' => 1,
                   'AUTO_INCLUDE' => 'my_header.h',
                   'TYPEMAPS' => ['my_typemap'],
                   'INC' => '-Imy/includes/dir',
                  };

# Create /some/where/else/XS_MOD.xs from ./src/XS_MOD.c
c2xs($module_name, $package_name, $build_dir);

# Or create XS_MOD.xs in the cwd:
c2xs($module_name, $package_name);

The optional fourth arg (a reference to a hash) is to enable the
writing of XS files using Inline::C's autowrap capability. 
It currently only accommodates 4 hash keys - AUTOWRAP, INC, 
AUTO_INCLUDE, and TYPEMAPS - though other keys may be added in
in the future to accommodate additional functionality.

# Create XS_MOD.xs in the cwd, using the AUTOWRAP feature:
c2xs($module_name, $package_name, '.', $config_opts);

DESCRIPTION

Don't feed an actual Inline::C script to this module - it won't
be able to parse it. It is capable of parsing correctly only
that C code that is suitable for inclusion in an Inline::C
script.

For example, here is a simple Inline::C script:

 use warnings;
 use Inline C => Config =>
     BUILD_NOISY => 1,
     CLEAN_AFTER_BUILD => 0;
 use Inline C => <<'EOC';
 #include <stdio.h>

 void greet() {
     printf("Hello world\n");
 }
 EOC

 greet();
 __END__

The C file that Inline::C2XS needs to find would contain only that code
that's between the opening 'EOC' and the closing 'EOC' - namely:

 #include <stdio.h>

 void greet() {
     printf("Hello world\n");
 }

Inline::C2XS looks for the source file in ./src directory - expecting
that the filename will be the same as what appears after the final '::'
in the module name (with a '.c' extension). ie if your module is
called My::Next::Mod the c2xs() function looks for a file ./src/Mod.c, 
and creates a file named Mod.xs. Also created by the c2xs function, is
the file 'INLINE.h' - but only if that file is needed. The generated 
xs file (and INLINE.h) will be written to the cwd unless a third 
argument (specifying a valid directory) is provided to the c2xs
function.

The created XS file, when packaged with the '.pm' file, an
appropriate 'Makefile.PL', and 'INLINE.h' (if it's needed), can be 
used to build the module in the usual way - without any dependence
upon the Inline::C module.

BUGS

None known - patches/rewrites/enhancements welcome.
Send to sisyphus at cpan dot org

COPYRIGHT

Copyright Sisyphus. You can do whatever you want with this code.
It comes without any guarantee or warranty.