Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
Inline::FAQ(3)	      User Contributed Perl Documentation	Inline::FAQ(3)

NAME
       Inline-FAQ - The	Inline FAQ

DESCRIPTION
       Welcome to the official Inline FAQ. In this case, FAQ means: Formerly
       Answered	Questions

       This is a collection of old, long-winded	emails that myself and others
       have sent to the	Inline mailing list. (inline@perl.org) They have been
       reviewed	and edited for general Inline edification. Some	of them	may be
       related to a specific language. They are	presented here in a
       traditional FAQ layout.

GENERAL	INLINE
       Since there is only a handful of	content	so far,	all FAQs are currently
       under this heading.

   How disposable is a ".Inline" or "_Inline" directory?
       I probably need to be more emphatic about the role of "_Inline/"	cache
       directories. Since they are created automatically, they are completely
       disposable. I delete them all the time. And it is fine to have a
       different one for each project. In fact as long as you don't have
       "~/.Inline/" defined, Inline will create	a new "./_Inline" directory
       (unless,	you've done something to override this automatic process -
       such as using the DIRECTORY config option, or using the
       "PERL_INLINE_DIRECTORY" environment variable). You can move that	to
       "./.Inline" and it will continue	to work	if you want togive it more
       longevity and hide it from view.	There is a long	complicated list of
       rules about how "[_.]Inline/" directories are used/created. But it was
       designed	to give	you the	most flexibility/ease-of-use. Never be afraid
       to nuke 'em. They'll just pop right back	next time they're needed. :)

   What	is the best way	to package Inline code for CPAN?
       This distribution includes Inline::MakeMaker, described below, which
       takes special steps during the installation of your module to make sure
       the code	gets compiled and installed, rather than compiled by users at
       runtime.	But, users of your module need to install Inline and the
       language	support	module like Inline::CPP	as prerequisites for your
       module.

       A better	way to distribute your module is with Inline::Module, which
       takes special steps to remove dependencies on Inline::* and convert it
       to a plain XS module during the construction of your distribution
       before you upload it to CPAN. It	also integrates	easily with
       Dist::Zilla and other modern authoring tools for	a more streamlined
       authoring experience.

   Whatever happened to	the "SITE_INSTALL" option?
       "SITE_INSTALL" is gone. I was going to leave it in and change the
       semantics, but thought it better	to remove it, so people	wouldn't try
       to use it the old way. There is now "_INSTALL_" (but you're not
       supposed	to know	that :). It works magically through the	use of
       Inline::MakeMaker. I explained this earlier but it's worth going
       through again because it's the biggest change for 0.40.	Here's how to
       'permanently' install an	Inline extension (Inline based module) with
       0.40:

       1.  Create a module with	Inline.

       2.  Test	it using the normal / local "_Inline/" cache.

       3.  Create a Makefile.PL	(like the one produced by h2xs)

       4.  Change 'use ExtUtils::MakeMaker' to 'use Inline::MakeMaker'

       5.  In the Makefile.PL's	WriteMakefile()	insert:

	       CONFIGURE_REQUIRES  =>  {
		   'Inline::MakeMaker'	   => 0.45,
		   'ExtUtils::MakeMaker'   => 6.52,
	       },

	   (See	the "Writing Modules with Inline" section of Inline.pod	for an
	   explanation / elaboration.)

       6.  Change your 'use Inline C =>	DATA' to 'use Inline C => DATA => NAME
	   => Foo

       => VERSION => 1.23' + Make sure NAME matches your package name ('Foo'),
       or => begins with 'Foo::'. + If you want	to quiet a harmless warning
       that will => appear when	the module is loaded via "require", do
       "Inline->init();". See => "Writing Modules with Inline" in the Inline
       pod for details.	+ Make sure => VERSION matches $Foo::VERSION. This
       must be a string	(not a number) => matching "/^\d\.\d\d$/" + Do the
       perl / make / test / install dance => (thanks binkley :)

       With Inline 0.41	(or thereabouts) you can skip steps 3 &	4, and just
       say "perl -MInline=INSTALL ./Foo.pm". This will work for	non-Inline
       modules too.  It	will become the	defacto	standard (since	there is no
       easy standard) way of installing	a Perl module. It will allow
       Makefile.PL parameters "perl - MInline=INSTALL ./Foo.pm -
       PREFIX=/home/ingy/perl" and things like that. It	will also make use of
       a MANIFEST if you provide one.

   How do I create a binary distribution using Inline?
       I've figured out	how to create and install a PPM	binary distribution;
       with or without distributing the	C code!	And I've decided to share it
       with all	of you :)

       NOTE: Future versions of	Inline will make this process a	one line
       command.	But
	     for now just use this simple recipe.

       The Inline 0.40 distribution comes with a sample	extension module
       called Math::Simple. Theoretically you could distribute this module on
       CPAN. It	has all	the necessary support for installation.	You can	find
       it in "Inline- 0.40/modules/Math/Simple/". Here are the steps for
       converting this into a binary distribution without C source code.

       NOTE: The recipient of this binary distribution will need to have the
	     PPM.pm module installed. This module requires a lot of other CPAN
	     modules. ActivePerl (available for	Win32, Linux, and Solaris) has
       all
	     of	these bundled. While ActivePerl	isn't required,	it makes
       things (a
	     lot) easier.

       1.  cd "Inline-0.40/Math/Simple/"

       2.  Divide Simple.pm into two files:

	       ---8<---	(Simple.pm)
	       package Math::Simple;
	       use strict;
	       require Exporter;
	       @Math::Simple::ISA = qw(Exporter);
	       @Math::Simple::EXPORT = qw(add subtract);
	       $Math::Simple::VERSION =	'1.23';

	       use Inline (C =>	'src/Simple.c' =>
			   NAME	=> 'Math::Simple',
			   VERSION => '1.23',
			  );
	       1;
	       ---8<---
	       ---8<---	(src/Simple.c)
	       int add (int x, int y) {
		   return x + y;
	       }

	       int subtract (int x, int	y) {
		   return x - y;
	       }
	       ---8<---

       3.  now you have	the Perl in one	file and the C in the other. The C
	   code	must be

       in a subdirectory. + Note that I	also changed the term 'DATA' to	the
       name of the C file. This	will work just as if the C were	still inline.
       + Run 'perl Makefile.PL'	+ Run 'make test' + Get	the MD5	key from
       "blib/arch/auto/Math/Simple/Simple.inl" + Edit
       "blib/lib/Math/Simple.pm".  Change "src/Simple.c" to
       "02c61710cab5b659efc343a9a830aa73" (the MD5 key)

       1.  Run 'make ppd'

       2.  Edit	'Math-Simple.ppd'. Fill	in AUTHOR and ABSTRACT if you wish.
	   Then

       change:

	     <CODEBASE HREF="" />

	   to

	     <CODEBASE HREF="Math-Simple.tar.gz" />

       1.  Run:

	       tar cvf Math-Simple.tar blib
	       gzip --best Math-Simple.tar

       2.  Run:

	       tar cvf Math-Simple-1.23.tar Math-Simple.ppd Math-Simple.tar.gz
	       gzip --best Math-Simple-1.23.tar

       3.  Distribute Math-Simple-1.23.tar.gz with the following instructions:

	   1.  Run:

	       gzip -d Math-Simple-1.23.tar.gz tar xvzf	Math-Simple-1.23.tar

	   2.  Run 'ppm	install	Math-Simple.ppd'

	   3.  Delete Math-Simple.tar and Math-Simple.ppd.

	   4.  Test with:

	       perl -MMath::Simple -le 'print add(37, 42)'

       That's it. The process should also work with zip	instead	of tar,	but I
       haven't tried it.

       The recipient of	the binary must	have Perl built	with a matching
       architecture.  Luckily, ppm will	catch this.

       For a binary dist with C	source code, simply omit steps 2, 3, 6,	and 7.

       If this seems too hard, then in a future	version	you should be able to
       just type:

	   make	ppm

   Why does "C/t/09parser.t" fail on Cygwin ?
       It doesn't always fail on Cygwin, but if	you find that it produces
       "unable to remap	.... to	same address as	parent"	errors during the
       build phase, then it's time for you to run rebaseall.

       See
       <http://cygwin.com/faq/faq-nochunks.html#faq.using.fixing-fork-failures>
       and, if needed, seek further help from the Cygwin mailing list.

perl v5.32.1			  2020-01-09			Inline::FAQ(3)

NAME | DESCRIPTION | GENERAL INLINE

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=Inline::FAQ&sektion=3&manpath=FreeBSD+13.0-RELEASE+and+Ports>

home | help